1 /** constant range tests.
13 #if defined (__GNUC__) && defined (__alpha__) && (__GNUC__ < 3)
14 /* bool should be casted to int in order to pass the test. Is this a gcc bug? */
15 #define INT_CAST (int)
30 testConstantRange (void)
32 ASSERT (! (INT8_MIN - 1 == s8));
33 ASSERT (! (INT8_MAX + 1 == s8));
34 ASSERT ( (INT8_MIN - 1 != s8));
35 ASSERT ( (INT8_MAX + 1 != s8));
36 ASSERT ( (INT8_MIN - 1 < s8));
37 ASSERT (! (INT8_MAX < s8));
38 ASSERT ( (INT8_MIN <= s8));
39 ASSERT (! (INT8_MAX <= s8));
40 ASSERT (! (INT8_MIN > s8));
41 ASSERT ( (INT8_MAX + 1 > s8));
42 ASSERT (! (INT8_MIN - 1 >= s8));
43 ASSERT ( (INT8_MAX >= s8));
45 ASSERT (! ( 0 - 1 == u8));
46 ASSERT (! (UINT8_MAX + 1 == u8));
47 ASSERT ( ( 0 - 1 != u8));
48 ASSERT ( (UINT8_MAX + 1 != u8));
49 ASSERT ( ( 0 - 1 < u8));
50 ASSERT (! (UINT8_MAX < u8));
52 ASSERT (! (UINT8_MAX + 1 <= u8));
54 ASSERT ( (UINT8_MAX + 1 > u8));
55 ASSERT (! ( 0 - 1 >= u8));
56 ASSERT ( (UINT8_MAX >= u8));
58 /* force extension to long to avoid int (16 bit) overflow */
59 ASSERT (! (INT16_MIN - 1L == s16));
60 ASSERT (! (INT16_MAX + 1L == s16));
61 ASSERT ( (INT16_MIN - 1L != s16));
62 ASSERT ( (INT16_MAX + 1L != s16));
63 ASSERT ( (INT16_MIN - 1L < s16));
64 ASSERT (! (INT16_MAX < s16));
65 ASSERT ( (INT16_MIN <= s16));
66 ASSERT (! (INT16_MAX <= s16));
67 ASSERT (! (INT16_MIN > s16));
68 ASSERT ( (INT16_MAX + 1L > s16));
69 ASSERT (! (INT16_MIN - 1L >= s16));
70 ASSERT ( (INT16_MAX >= s16));
72 ASSERT (! ( 0 - 1 == u16));
73 ASSERT (! (UINT16_MAX + 1L == u16));
74 ASSERT ( ( 0 - 1 != u16));
75 ASSERT ( (UINT16_MAX + 1L != u16));
76 ASSERT ( ( 0 - 1 < u16));
77 ASSERT (! (UINT16_MAX < u16));
78 ASSERT ( ( 0 <= u16));
79 ASSERT (! (UINT16_MAX + 1L <= u16));
80 ASSERT (! ( 0 > u16));
81 ASSERT ( (UINT16_MAX + 1L > u16));
82 ASSERT (! ( 0 - 1 >= u16));
83 ASSERT ( (UINT16_MAX >= u16));
85 /* sdcc can't hold a number (INT32_MIN - 1) or (INT32_MAX + 1),
86 there's no 'double' or 'long long' */
87 /* ASSERT (! (INT32_MIN - 1 == s32)); */
88 /* ASSERT (! (INT32_MAX + 1 == s32)); */
89 /* ASSERT ( (INT32_MIN - 1 != s32)); */
90 /* ASSERT ( (INT32_MAX + 1 != s32)); */
91 /* ASSERT ( (INT32_MIN - 1 < s32)); */
92 ASSERT (! (INT32_MAX < s32));
93 ASSERT ( (INT32_MIN <= s32));
94 ASSERT (! (INT32_MAX <= s32));
95 ASSERT (! (INT32_MIN > s32));
96 /* ASSERT ( (INT32_MAX + 1 > s32)); */
97 /* ASSERT (! (INT32_MIN - 1 >= s32)); */
98 ASSERT ( (INT32_MAX >= s32));
100 ASSERT (! ( 0 - 1 == u32));
101 /* ASSERT (! (UINT32_MAX + 1 == u32)); */
102 ASSERT ( ( 0 - 1 != u32));
103 /* ASSERT ( (UINT32_MAX + 1 != u32)); */
104 ASSERT ( ( 0 - 1 < u32));
105 ASSERT (! (UINT32_MAX < u32));
106 ASSERT ( ( 0 <= u32));
107 /* ASSERT (! (UINT32_MAX + 1 <= u32)); */
108 ASSERT (! ( 0 > u32));
109 /* ASSERT ( (UINT32_MAX + 1 > u32)); */
110 ASSERT (! ( 0 - 1 >= u32));
111 ASSERT ( (UINT32_MAX >= u32));
117 #if defined(PORT_HOST)
118 volatile bool sb, ub;
120 volatile signed bool sb;
121 volatile unsigned bool ub;
127 ASSERT (! (-1 == sb));
128 ASSERT ( ( 0 == sb));
129 ASSERT (! ( 1 == sb));
131 ASSERT ( (-1 != sb));
132 ASSERT (! ( 0 != sb));
133 ASSERT ( ( 1 != sb));
135 ASSERT ( (-1 < INT_CAST sb));
136 ASSERT (! ( 0 < sb));
138 ASSERT ( ( 0 <= sb));
139 ASSERT (! ( 1 <= sb));
141 ASSERT (! ( 0 > sb));
144 ASSERT (! (-1 >= INT_CAST sb));
145 ASSERT ( ( 0 >= sb));
148 ASSERT (! (-1 == ub));
149 ASSERT ( ( 0 == ub));
150 ASSERT (! ( 1 == ub));
152 ASSERT ( (-1 != ub));
153 ASSERT (! ( 0 != ub));
154 ASSERT ( ( 1 != ub));
156 ASSERT ( (-1 < INT_CAST ub));
157 ASSERT (! ( 0 < ub));
159 ASSERT ( ( 0 <= ub));
160 ASSERT (! ( 1 <= ub));
162 ASSERT (! ( 0 > ub));
165 ASSERT (! (-1 >= INT_CAST ub));
166 ASSERT ( ( 0 >= ub));
184 ASSERT (! (-2 == str.sb1));
185 ASSERT (! (-1 == str.sb1));
186 ASSERT ( ( 0 == str.sb1));
187 ASSERT (! ( 1 == str.sb1));
189 ASSERT (! (-1 == str.ub1));
190 ASSERT ( ( 0 == str.ub1));
191 ASSERT (! ( 1 == str.ub1));
192 ASSERT (! ( 2 == str.ub1));
194 ASSERT (! (-5 == str.sb3));
195 ASSERT (! (-4 == str.sb3));
196 ASSERT ( ( 0 == str.sb3));
197 ASSERT (! ( 3 == str.sb3));
198 ASSERT (! ( 4 == str.sb3));
200 ASSERT (! (-1 == str.ub3));
201 ASSERT ( ( 0 == str.ub3));
202 ASSERT (! ( 7 == str.ub3));
203 ASSERT (! ( 8 == str.ub3));