Retro68/gcc/newlib/libm/test/convert.c
Wolfgang Thaller ec13cc9ce7 fix newlib
2018-12-29 09:59:36 +01:00

363 lines
6.4 KiB
C

/* Test conversions */
#include "test.h"
#include <stdlib.h>
#include <errno.h>
static char buffer[500];
extern double_type doubles[];
/* TEST ATOF ATOFF */
double_type *pd = doubles;
void
test_strtod (void)
{
char *tail;
double v;
/* On average we'll loose 1/2 a bit, so the test is for within 1 bit */
v = strtod(pd->string, &tail);
test_mok(v, pd->value, 64);
test_iok(tail - pd->string, pd->endscan);
}
void
test_strtof (void)
{
char *tail;
double v;
/* On average we'll loose 1/2 a bit, so the test is for within 1 bit */
v = strtof(pd->string, &tail);
test_mok(v, pd->value, 32);
test_iok(tail - pd->string, pd->endscan);
}
void
test_atof (void)
{
test_mok(atof(pd->string), pd->value, 64);
}
void
test_atoff (void)
{
test_mok(atoff(pd->string), pd->value, 32);
}
static
void
iterate (void (*func) (void),
char *name)
{
newfunc(name);
pd = doubles;
while (pd->string) {
line(pd->line);
func();
pd++;
}
}
extern int_type ints[];
int_type *p = ints;
static void
int_iterate (void (*func)(),
char *name)
{
newfunc(name);
p = ints;
while (p->string) {
line(p->line);
errno = 0;
func();
p++;
}
}
void
test_strtol_base (int base,
int_scan_type *pi,
char *string)
{
long r;
char *ptr;
errno = 0;
r = strtol(string, &ptr, base);
test_iok(r, pi->value);
test_eok(errno, pi->errno_val);
test_iok(ptr - string, pi->end);
}
void
test_strtol (void)
{
test_strtol_base(8,&(p->octal), p->string);
test_strtol_base(10,&(p->decimal), p->string);
test_strtol_base(16, &(p->hex), p->string);
test_strtol_base(0, &(p->normal), p->string);
test_strtol_base(26, &(p->alphabetical), p->string);
}
void
test_atoi (void)
{
test_iok(atoi(p->string), p->decimal.value);
test_eok(errno, p->decimal.errno_val);
}
void
test_atol (void)
{
test_iok(atol(p->string), p->decimal.value);
test_eok(errno, p->decimal.errno_val);
}
/* test ECVT and friends */
extern ddouble_type ddoubles[];
ddouble_type *pdd;
void
test_ecvtbuf (void)
{
int a2,a3;
char *s;
s = ecvtbuf(pdd->value, pdd->e1, &a2, &a3, buffer);
test_sok(s,pdd->estring);
test_iok(pdd->e2,a2);
test_iok(pdd->e3,a3);
}
void
test_ecvt (void)
{
int a2,a3;
char *s;
s = ecvt(pdd->value, pdd->e1, &a2, &a3);
test_sok(s,pdd->estring);
test_iok(pdd->e2,a2);
test_iok(pdd->e3,a3);
s = ecvtf(pdd->value, pdd->e1, &a2, &a3);
test_sok(s,pdd->estring);
test_iok(pdd->e2,a2);
test_iok(pdd->e3,a3);
}
void
test_fcvtbuf (void)
{
int a2,a3;
char *s;
s = fcvtbuf(pdd->value, pdd->f1, &a2, &a3, buffer);
test_scok(s,pdd->fstring,10);
test_iok(pdd->f2,a2);
test_iok(pdd->f3,a3);
}
void
test_gcvt (void)
{
char *s = gcvt(pdd->value, pdd->g1, buffer);
test_scok(s, pdd->gstring, 9);
s = gcvtf(pdd->value, pdd->g1, buffer);
test_scok(s, pdd->gstring, 9);
}
void
test_fcvt (void)
{
int a2,a3;
char *sd;
char *sf;
double v1;
double v2;
sd = fcvt(pdd->value, pdd->f1, &a2, &a3);
test_scok(sd,pdd->fstring,10);
test_iok(pdd->f2,a2);
test_iok(pdd->f3,a3);
/* Test the float version by converting and inspecting the numbers 3
after reconverting */
sf = fcvtf(pdd->value, pdd->f1, &a2, &a3);
sscanf(sd, "%lg", &v1);
sscanf(sf, "%lg", &v2);
test_mok(v1, v2,32);
test_iok(pdd->f2,a2);
test_iok(pdd->f3,a3);
}
static void
diterate (void (*func)(),
char *name)
{
newfunc(name);
pdd = ddoubles;
while (pdd->estring) {
line(pdd->line);
errno = 0;
func();
pdd++;
}
}
void
deltest (void)
{
newfunc("rounding");
line(1);
sprintf(buffer,"%.2f", 9.999);
test_sok(buffer,"10.00");
line(2);
sprintf(buffer,"%.2g", 1.0);
test_sok(buffer,"1");
line(3);
sprintf(buffer,"%.2g", 1.2e-6);
test_sok(buffer,"1.2e-06");
line(4);
sprintf(buffer,"%.0g", 1.0);
test_sok(buffer,"1");
line(5);
sprintf(buffer,"%.0e",1e1);
test_sok(buffer,"1e+01");
line(6);
sprintf(buffer, "%f", 12.3456789);
test_sok(buffer, "12.345679");
line(7);
sprintf(buffer, "%6.3f", 12.3456789);
test_sok(buffer, "12.346");
line(8);
sprintf(buffer,"%.0f", 12.3456789);
test_sok(buffer,"12");
}
/* Most of what sprint does is tested with the tests of
fcvt/ecvt/gcvt, but here are some more */
void
test_sprint (void)
{
extern sprint_double_type sprint_doubles[];
sprint_double_type *s = sprint_doubles;
extern sprint_int_type sprint_ints[];
sprint_int_type *si = sprint_ints;
newfunc( "sprintf");
while (s->line)
{
line( s->line);
sprintf(buffer, s->format_string, s->value);
test_scok(buffer, s->result, 12); /* Only check the first 12 digs,
other stuff is random */
s++;
}
while (si->line)
{
line( si->line);
sprintf(buffer, si->format_string, si->value);
test_sok(buffer, si->result);
si++;
}
}
/* Scanf calls strtod etc tested elsewhere, but also has some pattern matching skills */
void
test_scan (void)
{
int i,j;
extern sprint_double_type sprint_doubles[];
sprint_double_type *s = sprint_doubles;
extern sprint_int_type sprint_ints[];
sprint_int_type *si = sprint_ints;
newfunc( "scanf");
/* Test scanf by converting all the numbers in the sprint vectors
to and from their source and making sure nothing breaks */
while (s->line)
{
double d0,d1;
line( s->line);
sscanf(s->result, "%lg", &d0);
sprintf(buffer, "%20.17e", d0);
sscanf(buffer, "%lg", &d1);
test_mok(d0,d1, 64);
s++;
}
/* And integers too */
while (si->line)
{
long d0,d1;
line(si->line);
sscanf(si->result, "%d", &d0);
sprintf(buffer, "%d", d0);
sscanf(buffer, "%d", &d1);
test_iok(d0,d1);
si++;
}
/* And the string matching */
sscanf(" 9","%d", &i);
test_iok(i, 9);
sscanf("foo bar 123 zap 456","foo bar %d zap %d", &i, &j);
test_iok(i, 123);
test_iok(j, 456);
sscanf("magicXYZZYfoobar","magic%[XYZ]", buffer);
test_sok("XYZZY", buffer);
sscanf("magicXYZZYfoobar","%[^XYZ]", buffer);
test_sok("magic", buffer);
}
void
test_cvt (void)
{
deltest();
diterate(test_fcvtbuf,"fcvtbuf");
diterate(test_fcvt,"fcvt/fcvtf");
diterate(test_gcvt,"gcvt/gcvtf");
diterate(test_ecvtbuf,"ecvtbuf");
diterate(test_ecvt,"ecvt/ecvtf");
iterate(test_strtod, "strtod");
test_scan();
test_sprint();
iterate(test_atof, "atof");
iterate(test_atoff, "atoff");
iterate(test_strtof, "strtof");
int_iterate(test_atoi,"atoi");
int_iterate(test_atol,"atol");
int_iterate(test_strtol, "strtol");
}