← Back to branch summary

~ubuntu-branches/ubuntu/maverick/avr-libc/maverick

« back to all changes in this revision

Viewing changes to tests/simulate/fplib/div-nan.c

  • Committer: Bazaar Package Importer
  • Author(s): Hakan Ardo
  • Date: 2009-10-31 11:52:10 UTC
  • mfrom: (1.2.2 upstream)
  • mto: This revision was merged to the branch mainline in revision 10.
  • Revision ID: james.westby@ubuntu.com-20091031115210-crjd42sn6ezrj52c
http://bugs.debian.org/544030
http://bugs.debian.org/553265
* New upstream relese (closes: #544030)
* Added lintian overrides (closes: #553265)

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/simulate/fplib/div-nan.c
1
 
/* Test of division.  NaNs.
2
 
   $Id: div-nan.c,v 1.1 2007/02/05 21:35:58 dmix Exp $
3
 
 */
4
 
#include <math.h>
5
 
#include <stdio.h>
6
 
#include <stdlib.h>
7
 
#include "progmem.h"
8
 
 
9
 
union lofl_u {
10
 
    long lo;
11
 
    float fl;
12
 
};
13
 
 
14
 
volatile union lofl_u v = { .lo = 1 };
15
 
 
16
 
PROGMEM const struct {          /* Table of test cases:  x / y = NaN    */
17
 
    union lofl_u x, y;
18
 
} t[] = {
19
 
 
20
 
    /* 0.0 / 0.0        */
21
 
    { { 0x00000000 }, { 0x00000000 } },
22
 
    { { 0x00000000 }, { 0x80000000 } },
23
 
    { { 0x80000000 }, { 0x00000000 } },
24
 
    { { 0x80000000 }, { 0x80000000 } },
25
 
 
26
 
    /* Inf / Inf        */
27
 
    { { 0x7f800000 }, { 0x7f800000 } },
28
 
    { { 0xff800000 }, { 0x7f800000 } },
29
 
    { { 0x7f800000 }, { 0xff800000 } },
30
 
    { { 0xff800000 }, { 0xff800000 } },
31
 
 
32
 
    /* NaN * NaN        */
33
 
    { { 0x7f800001 }, { 0x7f800001 } },
34
 
    { { 0x7f800100 }, { 0x7f800100 } },
35
 
    { { 0x7f810000 }, { 0x7f810000 } },
36
 
    { { 0x7fffffff }, { 0x7fffffff } },
37
 
    { { 0xff800001 }, { 0xff800001 } },
38
 
    { { 0xff800100 }, { 0xff800100 } },
39
 
    { { 0xff810000 }, { 0xff810000 } },
40
 
    { { 0xffffffff }, { 0xffffffff } },
41
 
 
42
 
    /* NaN / finite     */
43
 
    { { 0x7f800001 }, { .fl = 1 } },
44
 
    { { 0x7f800100 }, { .fl = 1 } },
45
 
    { { 0x7f810000 }, { .fl = 1 } },
46
 
    { { 0x7fffffff }, { .fl = 1 } },
47
 
    { { 0xff800001 }, { .fl = 1 } },
48
 
    { { 0xff800100 }, { .fl = 1 } },
49
 
    { { 0xff810000 }, { .fl = 1 } },
50
 
    { { 0xffffffff }, { .fl = 1 } },
51
 
 
52
 
    /* finite / NaN     */
53
 
    { { .fl = 1 }, { 0x7f800001 } },
54
 
    { { .fl = 1 }, { 0x7f800100 } },
55
 
    { { .fl = 1 }, { 0x7f810000 } },
56
 
    { { .fl = 1 }, { 0x7fffffff } },
57
 
    { { .fl = 1 }, { 0xff800001 } },
58
 
    { { .fl = 1 }, { 0xff800100 } },
59
 
    { { .fl = 1 }, { 0xff810000 } },
60
 
    { { .fl = 1 }, { 0xffffffff } },
61
 
 
62
 
    /* NaN / 0.0        */
63
 
    { { 0x7f800001 }, { 0 } },
64
 
    { { 0x7f800100 }, { 0 } },
65
 
    { { 0x7f810000 }, { 0 } },
66
 
    { { 0x7fffffff }, { 0 } },
67
 
    { { 0xff800001 }, { 0 } },
68
 
    { { 0xff800100 }, { 0 } },
69
 
    { { 0xff810000 }, { 0 } },
70
 
    { { 0xffffffff }, { 0 } },
71
 
 
72
 
    /* 0.0 / NaN        */
73
 
    { { 0 }, { 0x7f800001 } },
74
 
    { { 0 }, { 0x7f800100 } },
75
 
    { { 0 }, { 0x7f810000 } },
76
 
    { { 0 }, { 0x7fffffff } },
77
 
    { { 0 }, { 0xff800001 } },
78
 
    { { 0 }, { 0xff800100 } },
79
 
    { { 0 }, { 0xff810000 } },
80
 
    { { 0 }, { 0xffffffff } },
81
 
    
82
 
    /* NaN / Inf        */
83
 
    { { 0x7f800001 }, { 0x7f800000 } },
84
 
    { { 0x7fffffff }, { 0x7f800000 } },
85
 
    { { 0xff800001 }, { 0xff800000 } },
86
 
    { { 0xffffffff }, { 0xff800000 } },
87
 
    
88
 
    /* Inf / NaN        */
89
 
    { { 0x7f800000 }, { 0x7f800001 } },
90
 
    { { 0x7f800000 }, { 0x7fffffff } },
91
 
    { { 0xff800000 }, { 0xff800001 } },
92
 
    { { 0xff800000 }, { 0xffffffff } },
93
 
};
94
 
 
95
 
void x_exit (int index)
96
 
{
97
 
#ifndef __AVR__
98
 
    fprintf (stderr, "t[%d]:  %#lx\n", index - 1, v.lo);
99
 
#endif
100
 
    exit (index ? index : -1);
101
 
}
102
 
 
103
 
int main ()
104
 
{
105
 
    union lofl_u x,y;
106
 
    int i;
107
 
    
108
 
    for (i = 0; i < (int) (sizeof(t) / sizeof(t[0])); i++) {
109
 
        x.lo = pgm_read_dword (& t[i].x);
110
 
        y.lo = pgm_read_dword (& t[i].y);
111
 
        v.fl = x.fl / y.fl;
112
 
        if (!isnan(v.fl))
113
 
            x_exit (i+1);
114
 
    }
115
 
    return 0;
116
 
}