URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [newlib-1.17.0/] [newlib/] [libm/] [test/] [convert.c] - Blame information for rev 148

Go to most recent revision | Details | Compare with Previous | View Log


/* 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
_DEFUN_VOID(test_strtod)
{
  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
_DEFUN_VOID(test_strtof)
{
  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
_DEFUN_VOID(test_atof)
{
  test_mok(atof(pd->string), pd->value, 64);
}
 
void
_DEFUN_VOID(test_atoff)
{
  test_mok(atoff(pd->string), pd->value, 32);
}
 
 
static
void
_DEFUN(iterate,(func, name),
       void _EXFUN((*func),(void)) _AND
       char *name)
{
 
  newfunc(name);
  pd = doubles;
  while (pd->string) {
    line(pd->line);
    func();
    pd++;
  }
}
 
 
extern int_type ints[];
 
int_type *p = ints;
 
 
static void
_DEFUN(int_iterate,(func, name),
       void (*func)() _AND
       char *name)
{
  newfunc(name);
 
  p = ints;
  while (p->string) {
    line(p->line);
    errno = 0;
    func();
    p++;
  }
}
 
void
_DEFUN(test_strtol_base,(base, pi, string),
       int base _AND
       int_scan_type *pi _AND
       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
_DEFUN_VOID(test_strtol)
{
  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
_DEFUN_VOID(test_atoi)
{
  test_iok(atoi(p->string), p->decimal.value);
  test_eok(errno, p->decimal.errno_val);
}
 
void
_DEFUN_VOID(test_atol)
{
  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
_DEFUN_VOID(test_ecvtbuf)
{
  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
_DEFUN_VOID(test_ecvt)
{
  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
_DEFUN_VOID(test_fcvtbuf)
{
  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
_DEFUN_VOID(test_gcvt)
{
  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
_DEFUN_VOID(test_fcvt)
{
  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
 
_DEFUN(diterate,(func, name),
       void (*func)() _AND
       char *name)
{
  newfunc(name);
 
  pdd = ddoubles;
  while (pdd->estring) {
    line(pdd->line);
    errno = 0;
    func();
    pdd++;
  }
}
 
 
void
_DEFUN_VOID(deltest)
{
  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
_DEFUN_VOID(test_sprint)
{
  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
_DEFUN_VOID(test_scan)
{
  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
_DEFUN_VOID(test_cvt)
{
  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");
}

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [newlib-1.17.0/] [newlib/] [libm/] [test/] [convert.c] - Blame information for rev 148

Line No.	Rev	Author	Line
1	148	jeremybenn	`/* Test conversions */`
2
3			`#include "test.h"`
4			`#include <stdlib.h>`
5			`#include <errno.h>`
6
7			`static char buffer[500];`
8
9			`extern double_type doubles[];`
10
11			`/* TEST ATOF ATOFF */`
12
13			`double_type *pd = doubles;`
14
15			`void`
16			`_DEFUN_VOID(test_strtod)`
17			`{`
18			`char *tail;`
19			`double v;`
20			`/* On average we'll loose 1/2 a bit, so the test is for within 1 bit */`
21			`v = strtod(pd->string, &tail);`
22			`test_mok(v, pd->value, 64);`
23			`test_iok(tail - pd->string, pd->endscan);`
24			`}`
25
26			`void`
27			`_DEFUN_VOID(test_strtof)`
28			`{`
29			`char *tail;`
30			`double v;`
31			`/* On average we'll loose 1/2 a bit, so the test is for within 1 bit */`
32			`v = strtof(pd->string, &tail);`
33			`test_mok(v, pd->value, 32);`
34			`test_iok(tail - pd->string, pd->endscan);`
35			`}`
36
37			`void`
38			`_DEFUN_VOID(test_atof)`
39			`{`
40			`test_mok(atof(pd->string), pd->value, 64);`
41			`}`
42
43			`void`
44			`_DEFUN_VOID(test_atoff)`
45			`{`
46			`test_mok(atoff(pd->string), pd->value, 32);`
47			`}`
48
49
50			`static`
51			`void`
52			`_DEFUN(iterate,(func, name),`
53			`void _EXFUN((*func),(void)) _AND`
54			`char *name)`
55			`{`
56
57			`newfunc(name);`
58			`pd = doubles;`
59			`while (pd->string) {`
60			`line(pd->line);`
61			`func();`
62			`pd++;`
63			`}`
64			`}`
65
66
67			`extern int_type ints[];`
68
69			`int_type *p = ints;`
70
71
72			`static void`
73			`_DEFUN(int_iterate,(func, name),`
74			`void (*func)() _AND`
75			`char *name)`
76			`{`
77			`newfunc(name);`
78
79			`p = ints;`
80			`while (p->string) {`
81			`line(p->line);`
82			`errno = 0;`
83			`func();`
84			`p++;`
85			`}`
86			`}`
87
88			`void`
89			`_DEFUN(test_strtol_base,(base, pi, string),`
90			`int base _AND`
91			`int_scan_type *pi _AND`
92			`char *string)`
93			`{`
94			`long r;`
95			`char *ptr;`
96			`errno = 0;`
97			`r = strtol(string, &ptr, base);`
98			`test_iok(r, pi->value);`
99			`test_eok(errno, pi->errno_val);`
100			`test_iok(ptr - string, pi->end);`
101			`}`
102
103			`void`
104			`_DEFUN_VOID(test_strtol)`
105			`{`
106			`test_strtol_base(8,&(p->octal), p->string);`
107			`test_strtol_base(10,&(p->decimal), p->string);`
108			`test_strtol_base(16, &(p->hex), p->string);`
109			`test_strtol_base(0, &(p->normal), p->string);`
110			`test_strtol_base(26, &(p->alphabetical), p->string);`
111			`}`
112
113			`void`
114			`_DEFUN_VOID(test_atoi)`
115			`{`
116			`test_iok(atoi(p->string), p->decimal.value);`
117			`test_eok(errno, p->decimal.errno_val);`
118			`}`
119
120			`void`
121			`_DEFUN_VOID(test_atol)`
122			`{`
123			`test_iok(atol(p->string), p->decimal.value);`
124			`test_eok(errno, p->decimal.errno_val);`
125			`}`
126
127			`/* test ECVT and friends */`
128			`extern ddouble_type ddoubles[];`
129			`ddouble_type *pdd;`
130			`void`
131			`_DEFUN_VOID(test_ecvtbuf)`
132			`{`
133			`int a2,a3;`
134			`char *s;`
135			`s = ecvtbuf(pdd->value, pdd->e1, &a2, &a3, buffer);`
136
137			`test_sok(s,pdd->estring);`
138			`test_iok(pdd->e2,a2);`
139			`test_iok(pdd->e3,a3);`
140			`}`
141
142			`void`
143			`_DEFUN_VOID(test_ecvt)`
144			`{`
145			`int a2,a3;`
146			`char *s;`
147			`s = ecvt(pdd->value, pdd->e1, &a2, &a3);`
148
149			`test_sok(s,pdd->estring);`
150			`test_iok(pdd->e2,a2);`
151			`test_iok(pdd->e3,a3);`
152
153			`s = ecvtf(pdd->value, pdd->e1, &a2, &a3);`
154
155			`test_sok(s,pdd->estring);`
156			`test_iok(pdd->e2,a2);`
157			`test_iok(pdd->e3,a3);`
158			`}`
159
160			`void`
161			`_DEFUN_VOID(test_fcvtbuf)`
162			`{`
163			`int a2,a3;`
164			`char *s;`
165			`s = fcvtbuf(pdd->value, pdd->f1, &a2, &a3, buffer);`
166
167			`test_scok(s,pdd->fstring,10);`
168			`test_iok(pdd->f2,a2);`
169			`test_iok(pdd->f3,a3);`
170			`}`
171
172			`void`
173			`_DEFUN_VOID(test_gcvt)`
174			`{`
175			`char *s = gcvt(pdd->value, pdd->g1, buffer);`
176			`test_scok(s, pdd->gstring, 9);`
177
178			`s = gcvtf(pdd->value, pdd->g1, buffer);`
179			`test_scok(s, pdd->gstring, 9);`
180
181			`}`
182
183			`void`
184			`_DEFUN_VOID(test_fcvt)`
185			`{`
186			`int a2,a3;`
187			`char *sd;`
188			`char *sf;`
189			`double v1;`
190			`double v2;`
191			`sd = fcvt(pdd->value, pdd->f1, &a2, &a3);`
192
193			`test_scok(sd,pdd->fstring,10);`
194			`test_iok(pdd->f2,a2);`
195			`test_iok(pdd->f3,a3);`
196
197			`/* Test the float version by converting and inspecting the numbers 3`
198			`after reconverting */`
199			`sf = fcvtf(pdd->value, pdd->f1, &a2, &a3);`
200			`sscanf(sd, "%lg", &v1);`
201			`sscanf(sf, "%lg", &v2);`
202			`test_mok(v1, v2,32);`
203			`test_iok(pdd->f2,a2);`
204			`test_iok(pdd->f3,a3);`
205			`}`
206
207			`static void`
208
209			`_DEFUN(diterate,(func, name),`
210			`void (*func)() _AND`
211			`char *name)`
212			`{`
213			`newfunc(name);`
214
215			`pdd = ddoubles;`
216			`while (pdd->estring) {`
217			`line(pdd->line);`
218			`errno = 0;`
219			`func();`
220			`pdd++;`
221			`}`
222			`}`
223
224
225			`void`
226			`_DEFUN_VOID(deltest)`
227			`{`
228			`newfunc("rounding");`
229			`line(1);`
230			`sprintf(buffer,"%.2f", 9.999);`
231			`test_sok(buffer,"10.00");`
232			`line(2);`
233			`sprintf(buffer,"%.2g", 1.0);`
234			`test_sok(buffer,"1");`
235			`line(3);`
236			`sprintf(buffer,"%.2g", 1.2e-6);`
237			`test_sok(buffer,"1.2e-06");`
238			`line(4);`
239			`sprintf(buffer,"%.0g", 1.0);`
240			`test_sok(buffer,"1");`
241			`line(5);`
242			`sprintf(buffer,"%.0e",1e1);`
243			`test_sok(buffer,"1e+01");`
244			`line(6);`
245			`sprintf(buffer, "%f", 12.3456789);`
246			`test_sok(buffer, "12.345679");`
247			`line(7);`
248			`sprintf(buffer, "%6.3f", 12.3456789);`
249			`test_sok(buffer, "12.346");`
250			`line(8);`
251			`sprintf(buffer,"%.0f", 12.3456789);`
252			`test_sok(buffer,"12");`
253			`}`
254
255			`/* Most of what sprint does is tested with the tests of`
256			`fcvt/ecvt/gcvt, but here are some more */`
257			`void`
258			`_DEFUN_VOID(test_sprint)`
259			`{`
260			`extern sprint_double_type sprint_doubles[];`
261			`sprint_double_type *s = sprint_doubles;`
262			`extern sprint_int_type sprint_ints[];`
263			`sprint_int_type *si = sprint_ints;`
264
265
266			`newfunc( "sprintf");`
267
268
269			`while (s->line)`
270			`{`
271			`line( s->line);`
272			`sprintf(buffer, s->format_string, s->value);`
273			`test_scok(buffer, s->result, 12); /* Only check the first 12 digs,`
274			`other stuff is random */`
275			`s++;`
276			`}`
277
278			`while (si->line)`
279			`{`
280			`line( si->line);`
281			`sprintf(buffer, si->format_string, si->value);`
282			`test_sok(buffer, si->result);`
283			`si++;`
284			`}`
285			`}`
286
287			`/* Scanf calls strtod etc tested elsewhere, but also has some pattern matching skills */`
288			`void`
289			`_DEFUN_VOID(test_scan)`
290			`{`
291			`int i,j;`
292			`extern sprint_double_type sprint_doubles[];`
293			`sprint_double_type *s = sprint_doubles;`
294			`extern sprint_int_type sprint_ints[];`
295			`sprint_int_type *si = sprint_ints;`
296
297			`newfunc( "scanf");`
298
299			`/* Test scanf by converting all the numbers in the sprint vectors`
300			`to and from their source and making sure nothing breaks */`
301
302			`while (s->line)`
303			`{`
304
305			`double d0,d1;`
306			`line( s->line);`
307			`sscanf(s->result, "%lg", &d0);`
308			`sprintf(buffer, "%20.17e", d0);`
309			`sscanf(buffer, "%lg", &d1);`
310			`test_mok(d0,d1, 64);`
311			`s++;`
312			`}`
313
314			`/* And integers too */`
315			`while (si->line)`
316			`{`
317
318			`long d0,d1;`
319
320			`line(si->line);`
321			`sscanf(si->result, "%d", &d0);`
322			`sprintf(buffer, "%d", d0);`
323			`sscanf(buffer, "%d", &d1);`
324			`test_iok(d0,d1);`
325			`si++;`
326			`}`
327
328			`/* And the string matching */`
329
330			`sscanf(" 9","%d", &i);`
331			`test_iok(i, 9);`
332			`sscanf("foo bar 123 zap 456","foo bar %d zap %d", &i, &j);`
333			`test_iok(i, 123);`
334			`test_iok(j, 456);`
335
336			`sscanf("magicXYZZYfoobar","magic%[XYZ]", buffer);`
337			`test_sok("XYZZY", buffer);`
338			`sscanf("magicXYZZYfoobar","%[^XYZ]", buffer);`
339			`test_sok("magic", buffer);`
340			`}`
341
342			`void`
343			`_DEFUN_VOID(test_cvt)`
344			`{`
345			`deltest();`
346
347			`diterate(test_fcvtbuf,"fcvtbuf");`
348			`diterate(test_fcvt,"fcvt/fcvtf");`
349
350			`diterate(test_gcvt,"gcvt/gcvtf");`
351			`diterate(test_ecvtbuf,"ecvtbuf");`
352			`diterate(test_ecvt,"ecvt/ecvtf");`
353
354			`iterate(test_strtod, "strtod");`
355
356			`test_scan();`
357			`test_sprint();`
358			`iterate(test_atof, "atof");`
359			`iterate(test_atoff, "atoff");`
360
361			`iterate(test_strtof, "strtof");`
362
363			`int_iterate(test_atoi,"atoi");`
364			`int_iterate(test_atol,"atol");`
365			`int_iterate(test_strtol, "strtol");`
366			`}`