← Back to branch summary

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

« back to all changes in this revision

Viewing changes to tests/simulate/fplib/flt2long-01.c

  • Committer: Bazaar Package Importer
  • Author(s): Hakan Ardo
  • Date: 2009-10-31 11:52:10 UTC
  • mfrom: (1.1.8 upstream) (4.1.2 squeeze)
  • Revision ID: james.westby@ubuntu.com-20091031115210-x0mlijnegkce86fk
Tags: 1:1.6.7-1
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/flt2long-01.c
1
 
/* Test of conversion float --> signed long.
2
 
   $Id: flt2long-01.c,v 1.2 2007/12/01 02:12:55 dmix Exp $
3
 
 */
4
 
#include <stdio.h>
5
 
#include <stdlib.h>
6
 
#include "progmem.h"
7
 
 
8
 
union lofl_u {
9
 
    long lo;
10
 
    float fl;
11
 
};
12
 
 
13
 
volatile long v = 1;
14
 
 
15
 
PROGMEM const struct {          /* Table of test cases. */
16
 
    union lofl_u x;
17
 
    long z;
18
 
} t[] = {
19
 
 
20
 
    /* 0.0      */
21
 
    { { 0x00000000 }, 0 },
22
 
    { { 0x80000000 }, 0 },
23
 
 
24
 
    /* too small        */
25
 
    { { 0x00000001 }, 0 },
26
 
    { { 0x007fffff }, 0 },
27
 
    { { 0x00800000 }, 0 },
28
 
    { { 0x3f7fffff }, 0 },
29
 
    { { 0x80000001 }, 0 },
30
 
    { { 0x807fffff }, 0 },
31
 
    { { 0x80800000 }, 0 },
32
 
    { { 0xbf7fffff }, 0 },
33
 
    
34
 
    /* all shift values */
35
 
    { { .fl = 0x1p00 }, 0x00000001 },
36
 
    { { .fl = 0x1p01 }, 0x00000002 },
37
 
    { { .fl = 0x1p02 }, 0x00000004 },
38
 
    { { .fl = 0x1p03 }, 0x00000008 },
39
 
    { { .fl = 0x1p04 }, 0x00000010 },
40
 
    { { .fl = 0x1p05 }, 0x00000020 },
41
 
    { { .fl = 0x1p06 }, 0x00000040 },
42
 
    { { .fl = 0x1p07 }, 0x00000080 },
43
 
    { { .fl = 0x1p08 }, 0x00000100 },
44
 
    { { .fl = 0x1p09 }, 0x00000200 },
45
 
    { { .fl = 0x1p10 }, 0x00000400 },
46
 
    { { .fl = 0x1p11 }, 0x00000800 },
47
 
    { { .fl = 0x1p12 }, 0x00001000 },
48
 
    { { .fl = 0x1p13 }, 0x00002000 },
49
 
    { { .fl = 0x1p14 }, 0x00004000 },
50
 
    { { .fl = 0x1p15 }, 0x00008000 },
51
 
    { { .fl = 0x1p16 }, 0x00010000 },
52
 
    { { .fl = 0x1p17 }, 0x00020000 },
53
 
    { { .fl = 0x1p18 }, 0x00040000 },
54
 
    { { .fl = 0x1p19 }, 0x00080000 },
55
 
    { { .fl = 0x1p20 }, 0x00100000 },
56
 
    { { .fl = 0x1p21 }, 0x00200000 },
57
 
    { { .fl = 0x1p22 }, 0x00400000 },
58
 
    { { .fl = 0x1p23 }, 0x00800000 },
59
 
    { { .fl = 0x1p24 }, 0x01000000 },
60
 
    { { .fl = 0x1p25 }, 0x02000000 },
61
 
    { { .fl = 0x1p26 }, 0x04000000 },
62
 
    { { .fl = 0x1p27 }, 0x08000000 },
63
 
    { { .fl = 0x1p28 }, 0x10000000 },
64
 
    { { .fl = 0x1p29 }, 0x20000000 },
65
 
    { { .fl = 0x1p30 }, 0x40000000 },
66
 
    { { .fl = -0x1p31 },0x80000000 },
67
 
    
68
 
    /* negative */
69
 
    { { .fl = -0x1p00 },        -1 },
70
 
    { { .fl = -0x3p00 },        -0x00000003 },
71
 
    { { .fl = -0xffp00 },       -0x000000ff },
72
 
    { { .fl = -0x100p00 },      -0x00000100 },
73
 
    { { .fl = -0xffffp00 },     -0x0000ffffL },
74
 
    { { .fl = -0x10000p00 },    -0x00010000L },
75
 
    { { .fl = -0xffffffp00 },   -0x00ffffffL },
76
 
    { { .fl = -0xffffffp07 },   -0x7fffff80L },
77
 
    
78
 
    /* max values       */
79
 
    { { .fl =  0x1.fffffep+30 },  0x7fffff80 },
80
 
    { { .fl = -0x1.fffffep+30 }, -0x7fffff80L },
81
 
    { { .fl = -0x1.000000p+31 }, -0x80000000L },
82
 
    
83
 
    /* rounding (trunc to zero) */
84
 
    { { 0x3f7fffff }, 0 },
85
 
    { { 0x3f800000 }, 1 },
86
 
    { { 0x3fffffff }, 1 },
87
 
    { { 0x40000000 }, 2 },
88
 
    { { 0x403fffff }, 2 },
89
 
    { { 0x40400000 }, 3 },
90
 
    { { 0x407fffff }, 3 },
91
 
    { { .fl = 0x1.000000p+22 }, 0x00400000 },
92
 
    { { .fl = 0x1.000002p+22 }, 0x00400000 },
93
 
 
94
 
    /* This realization returns 0x80000000 with all possible errors:
95
 
       overflow and NaN.  This is like GCC/x86. */
96
 
 
97
 
    /* Positive overflow        */
98
 
    { { .fl= 0x0.800000p+32 }, 0x80000000 },
99
 
    { { .fl= 0x0.800001p+32 }, 0x80000000 },
100
 
    { { .fl= 0x0.ffffffp+32 }, 0x80000000 },
101
 
    { { .fl= 0x0.800000p+33 }, 0x80000000 },
102
 
    { { .fl= 0x0.ffffffp+33 }, 0x80000000 },
103
 
    { { .lo= 0x7f000000 },     0x80000000 },
104
 
    { { .lo= 0x7f7fffff },     0x80000000 },
105
 
    { { .lo= 0x7f800000 },     0x80000000 },    /* +Inf */
106
 
 
107
 
    /* Negative overflow        */
108
 
    { { .fl= -0x0.800000p+32 }, 0x80000000 },   /* no overflow  */
109
 
    { { .fl= -0x0.800001p+32 }, 0x80000000 },
110
 
    { { .fl= -0x0.ffffffp+32 }, 0x80000000 },
111
 
    { { .fl= -0x0.800000p+33 }, 0x80000000 },
112
 
    { { .fl= -0x0.ffffffp+33 }, 0x80000000 },
113
 
    { { .lo= 0xff000000 },      0x80000000 },
114
 
    { { .lo= 0xff7fffff },      0x80000000 },
115
 
    { { .lo= 0xff800000 },      0x80000000 },   /* -Inf */
116
 
 
117
 
    /* Inf      */
118
 
    { { 0x7f800000 }, 0x80000000 },
119
 
    { { 0xff800000 }, 0x80000000 },
120
 
    
121
 
    /* NaN      */
122
 
    { { 0x7f800001 }, 0x80000000 },
123
 
    { { 0x7fc00000 }, 0x80000000 },
124
 
    { { 0x7fffffff }, 0x80000000 },
125
 
    { { 0xff800001 }, 0x80000000 },
126
 
    { { 0xffc00000 }, 0x80000000 },
127
 
    { { 0xffffffff }, 0x80000000 },
128
 
};
129
 
 
130
 
void x_exit (int index)
131
 
{
132
 
#ifndef __AVR__
133
 
    fprintf (stderr, "t[%d]:  %lu (%#lx)\n", index - 1, v, v);
134
 
#endif
135
 
    exit (index ? index : -1);
136
 
}
137
 
 
138
 
int main ()
139
 
{
140
 
    union lofl_u x;
141
 
    long z;
142
 
    int i;
143
 
    
144
 
    for (i = 0; i < (int) (sizeof(t) / sizeof(t[0])); i++) {
145
 
        x.lo = pgm_read_dword (& t[i].x);
146
 
        z    = pgm_read_dword (& t[i].z);
147
 
        v = x.fl;
148
 
        if (v != z)
149
 
            x_exit (i+1);
150
 
    }
151
 
    return 0;
152
 
}