* src/mcs51/peep.c (isCallerSaveFunc): fixed bug 1749275, thanks Robert
[fw/sdcc] / support / regression / tests / constantRange.c
1 /** constant range tests.
2
3 */
4
5 #include <testfwk.h>
6 #include <stdbool.h>
7 #ifdef __sun__
8 #include <inttypes.h>
9 #else
10 #include <stdint.h>
11 #endif
12
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)
16 #else
17 #define INT_CAST
18 #endif
19
20  int8_t s8;
21 uint8_t u8;
22
23  int16_t s16;
24 uint16_t u16;
25
26  int32_t s32;
27 uint32_t u32;
28
29 void
30 testConstantRange (void)
31 {
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));
44
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));
51   ASSERT (  (        0     <= u8));
52   ASSERT (! (UINT8_MAX + 1 <= u8));
53   ASSERT (! (        0     >  u8));
54   ASSERT (  (UINT8_MAX + 1 >  u8));
55   ASSERT (! (        0 - 1 >= u8));
56   ASSERT (  (UINT8_MAX     >= u8));
57
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));
71
72   ASSERT (! (         0 - 1  == u16));
73   ASSERT (! (UINT16_MAX + 1L == u16));
74   ASSERT (  (         0 - 1  != u16));
75   ASSERT (  (UINT16_MAX + 1L != u16));
76   ASSERT (! (UINT16_MAX      <  u16));
77   ASSERT (  (         0      <= u16));
78   ASSERT (! (UINT16_MAX + 1L <= u16));
79   ASSERT (! (         0      >  u16));
80   ASSERT (  (UINT16_MAX + 1L >  u16));
81   ASSERT (  (UINT16_MAX      >= u16));
82
83 #if defined(PORT_HOST)
84 /* on 32bit host: -1 is presented as 32 bit int, 16 bit unsigned short is promoted to 32 bit int */
85   ASSERT (  (         0 - 1  <  u16)); /* -1 > 0 */
86   ASSERT (! (         0 - 1  >= u16)); /* !(-1 <= 0) */
87 #else
88 /* on 16bit sdcc: int (-1) is promoted to unsigned int (0xffff) */
89   ASSERT (  (         0 - 1  >  u16)); /* 0xffff > 0 */
90   ASSERT (! (         0 - 1  <= u16)); /* !(0xffff <= 0) */
91 #endif
92
93    /* sdcc can't hold a number (INT32_MIN - 1) or (INT32_MAX + 1),
94       there's no 'double' or 'long long' */
95 /* ASSERT (! (INT32_MIN - 1 == s32)); */
96 /* ASSERT (! (INT32_MAX + 1 == s32)); */
97 /* ASSERT (  (INT32_MIN - 1 != s32)); */
98 /* ASSERT (  (INT32_MAX + 1 != s32)); */
99 /* ASSERT (  (INT32_MIN - 1 <  s32)); */
100    ASSERT (! (INT32_MAX     <  s32));
101    ASSERT (  (INT32_MIN     <= s32));
102    ASSERT (! (INT32_MAX     <= s32));
103    ASSERT (! (INT32_MIN     >  s32));
104 /* ASSERT (  (INT32_MAX + 1 >  s32)); */
105 /* ASSERT (! (INT32_MIN - 1 >= s32)); */
106    ASSERT (  (INT32_MAX     >= s32));
107
108    ASSERT (! (         0 - 1 == u32));
109 /* ASSERT (! (UINT32_MAX + 1 == u32)); */
110    ASSERT (  (         0 - 1 != u32));
111 /* ASSERT (  (UINT32_MAX + 1 != u32)); */
112    ASSERT (  (         0 - 1 >  u32)); /* 0xffffffff > 0 */
113    ASSERT (! (UINT32_MAX     <  u32));
114    ASSERT (  (         0     <= u32));
115 /* ASSERT (! (UINT32_MAX + 1 <= u32)); */
116    ASSERT (! (         0     >  u32));
117 /* ASSERT (  (UINT32_MAX + 1 >  u32)); */
118    ASSERT (! (         0 - 1 <= u32)); /* !(0xffffffff <= 0) */
119    ASSERT (  (UINT32_MAX     >= u32));
120 }
121
122 void
123 testFoo1(void)
124 {
125 #if defined(PORT_HOST)
126    volatile bool sb, ub;
127 #else
128    volatile   signed bool sb;
129    volatile unsigned bool ub;
130 #endif
131
132   sb = 0;
133   ub = 0;
134
135   ASSERT (! (-1 == sb));
136   ASSERT (  ( 0 == sb));
137   ASSERT (! ( 1 == sb));
138
139   ASSERT (  (-1 != sb));
140   ASSERT (! ( 0 != sb));
141   ASSERT (  ( 1 != sb));
142
143   ASSERT (  (-1 <  INT_CAST sb));
144   ASSERT (! ( 0 <  sb));
145
146   ASSERT (  ( 0 <= sb));
147   ASSERT (! ( 1 <= sb));
148
149   ASSERT (! ( 0 >  sb));
150   ASSERT (  ( 1 >  sb));
151
152   ASSERT (! (-1 >= INT_CAST sb));
153   ASSERT (  ( 0 >= sb));
154
155
156   ASSERT (! (-1 == ub));
157   ASSERT (  ( 0 == ub));
158   ASSERT (! ( 1 == ub));
159
160   ASSERT (  (-1 != ub));
161   ASSERT (! ( 0 != ub));
162   ASSERT (  ( 1 != ub));
163
164   ASSERT (  (-1 <  INT_CAST ub));
165   ASSERT (! ( 0 <  ub));
166
167   ASSERT (  ( 0 <= ub));
168   ASSERT (! ( 1 <= ub));
169
170   ASSERT (! ( 0 >  ub));
171   ASSERT (  ( 1 >  ub));
172
173   ASSERT (! (-1 >= INT_CAST ub));
174   ASSERT (  ( 0 >= ub));
175 }
176
177 void
178 testFoo2(void)
179 {
180   volatile struct {
181       signed sb1:1;
182       signed sb3:3;
183     unsigned ub1:1;
184     unsigned ub3:3;
185   } str;
186
187   str.sb1 = 0;
188   str.ub1 = 0;
189   str.sb3 = 0;
190   str.ub3 = 0;
191
192   ASSERT (! (-2 == str.sb1));
193   ASSERT (! (-1 == str.sb1));
194   ASSERT (  ( 0 == str.sb1));
195   ASSERT (! ( 1 == str.sb1));
196
197   ASSERT (! (-1 == str.ub1));
198   ASSERT (  ( 0 == str.ub1));
199   ASSERT (! ( 1 == str.ub1));
200   ASSERT (! ( 2 == str.ub1));
201
202   ASSERT (! (-5 == str.sb3));
203   ASSERT (! (-4 == str.sb3));
204   ASSERT (  ( 0 == str.sb3));
205   ASSERT (! ( 3 == str.sb3));
206   ASSERT (! ( 4 == str.sb3));
207
208   ASSERT (! (-1 == str.ub3));
209   ASSERT (  ( 0 == str.ub3));
210   ASSERT (! ( 7 == str.ub3));
211   ASSERT (! ( 8 == str.ub3));
212 }