xref: /aosp_15_r20/art/test/2275-integral-unsigned-arithmetic/src/Main.java (revision 795d594fd825385562da6b089ea9b2033f3abf5a) 
1 /*
2  * Copyright (C) 2024 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 public class Main {
main(String[] args)18   public static void main(String[] args) {
19     test_Integer_compareUnsigned_no_fold();
20     test_Long_compareUnsigned_no_fold();
21     test_Integer_compareUnsigned();
22     test_Long_compareUnsigned();
23     test_Integer_divideUnsigned_no_fold();
24     test_Long_divideUnsigned_no_fold();
25     test_Integer_divideUnsigned();
26     test_Long_divideUnsigned();
27     test_Integer_remainderUnsigned_no_fold();
28     test_Long_remainderUnsigned_no_fold();
29     test_Integer_remainderUnsigned();
30     test_Long_remainderUnsigned();
31 
32     test_Integer_compareUnsigned_in_condition();
33     test_Long_compareUnsigned_in_condition();
34 
35     assertEquals($noinline$compareSignedSameOperands(300), IF_TRUE_VALUE);
36 
37     test_Integer_doubleUnsignedCompare();
38     test_Integer_doubleUnsignedCompare_Xored();
39   }
40 
$noinline$cmpUnsignedInt(int a, int b)41   public static int $noinline$cmpUnsignedInt(int a, int b) {
42     return Integer.compareUnsigned(a, b);
43   }
44 
test_Integer_compareUnsigned_no_fold()45   public static void test_Integer_compareUnsigned_no_fold() {
46     assertEquals($noinline$cmpUnsignedInt(100, 100), 0);
47     assertEquals($noinline$cmpUnsignedInt(100, 1), 1);
48     assertEquals($noinline$cmpUnsignedInt(1, 100), -1);
49     assertEquals($noinline$cmpUnsignedInt(-2, 2), 1);
50     assertEquals($noinline$cmpUnsignedInt(2, -2), -1);
51     assertEquals($noinline$cmpUnsignedInt(Integer.MAX_VALUE, Integer.MIN_VALUE), -1);
52     assertEquals($noinline$cmpUnsignedInt(Integer.MIN_VALUE, Integer.MAX_VALUE), 1);
53     assertEquals($noinline$cmpUnsignedInt(Integer.MAX_VALUE, -1), -1);
54     assertEquals($noinline$cmpUnsignedInt(-1, Integer.MAX_VALUE), 1);
55     assertEquals($noinline$cmpUnsignedInt(0, 0), 0);
56   }
57 
$noinline$cmpUnsignedLong(long a, long b)58   public static int $noinline$cmpUnsignedLong(long a, long b) {
59     return Long.compareUnsigned(a, b);
60   }
61 
test_Long_compareUnsigned_no_fold()62   public static void test_Long_compareUnsigned_no_fold() {
63     assertEquals($noinline$cmpUnsignedLong(100L, 100L), 0);
64     assertEquals($noinline$cmpUnsignedLong(100L, 1L), 1);
65     assertEquals($noinline$cmpUnsignedLong(1L, 100L), -1);
66     assertEquals($noinline$cmpUnsignedLong(-2L, 2L), 1);
67     assertEquals($noinline$cmpUnsignedLong(2L, -2L), -1);
68     assertEquals($noinline$cmpUnsignedLong(Long.MAX_VALUE, Long.MIN_VALUE), -1);
69     assertEquals($noinline$cmpUnsignedLong(Long.MIN_VALUE, Long.MAX_VALUE), 1);
70     assertEquals($noinline$cmpUnsignedLong(Long.MAX_VALUE, -1L), -1);
71     assertEquals($noinline$cmpUnsignedLong(-1L, Long.MAX_VALUE), 1);
72     assertEquals($noinline$cmpUnsignedLong(0L, 0L), 0);
73   }
74 
test_Integer_compareUnsigned()75   public static void test_Integer_compareUnsigned() {
76     assertEquals(Integer.compareUnsigned(100, 100), 0);
77     assertEquals(Integer.compareUnsigned(100, 1), 1);
78     assertEquals(Integer.compareUnsigned(1, 100), -1);
79     assertEquals(Integer.compareUnsigned(-2, 2), 1);
80     assertEquals(Integer.compareUnsigned(2, -2), -1);
81     assertEquals(Integer.compareUnsigned(Integer.MAX_VALUE, Integer.MIN_VALUE), -1);
82     assertEquals(Integer.compareUnsigned(Integer.MIN_VALUE, Integer.MAX_VALUE), 1);
83     assertEquals(Integer.compareUnsigned(Integer.MAX_VALUE, -1), -1);
84     assertEquals(Integer.compareUnsigned(-1, Integer.MAX_VALUE), 1);
85     assertEquals(Integer.compareUnsigned(0, 0), 0);
86   }
87 
test_Long_compareUnsigned()88   public static void test_Long_compareUnsigned() {
89     assertEquals(Long.compareUnsigned(100L, 100L), 0);
90     assertEquals(Long.compareUnsigned(100L, 1L), 1);
91     assertEquals(Long.compareUnsigned(1L, 100L), -1);
92     assertEquals(Long.compareUnsigned(-2L, 2L), 1);
93     assertEquals(Long.compareUnsigned(2L, -2L), -1);
94     assertEquals(Long.compareUnsigned(Long.MAX_VALUE, Long.MIN_VALUE), -1);
95     assertEquals(Long.compareUnsigned(Long.MIN_VALUE, Long.MAX_VALUE), 1);
96     assertEquals(Long.compareUnsigned(Long.MAX_VALUE, -1L), -1);
97     assertEquals(Long.compareUnsigned(-1L, Long.MAX_VALUE), 1);
98     assertEquals(Long.compareUnsigned(0L, 0L), 0);
99   }
100 
$noinline$divideUnsignedInt(int a, int b)101   public static int $noinline$divideUnsignedInt(int a, int b) {
102     return Integer.divideUnsigned(a, b);
103   }
104 
test_Integer_divideUnsigned_no_fold()105   public static void test_Integer_divideUnsigned_no_fold() {
106     assertEquals($noinline$divideUnsignedInt(100, 10), 10);
107     assertEquals($noinline$divideUnsignedInt(100, 1), 100);
108     assertEquals($noinline$divideUnsignedInt(1024, 128), 8);
109     assertEquals($noinline$divideUnsignedInt(12345678, 264), 46763);
110     assertEquals($noinline$divideUnsignedInt(13, 5), 2);
111     assertEquals($noinline$divideUnsignedInt(-2, 2), Integer.MAX_VALUE);
112     assertEquals($noinline$divideUnsignedInt(-1, 2), Integer.MAX_VALUE);
113     assertEquals($noinline$divideUnsignedInt(100000, -1), 0);
114     assertEquals($noinline$divideUnsignedInt(Integer.MAX_VALUE, -1), 0);
115     assertEquals($noinline$divideUnsignedInt(-2, -1), 0);
116     assertEquals($noinline$divideUnsignedInt(-1, -2), 1);
117     assertEquals($noinline$divideUnsignedInt(-173448, 13), 330368757);
118     assertEquals($noinline$divideUnsignedInt(Integer.MIN_VALUE, 2), (1 << 30));
119     assertEquals($noinline$divideUnsignedInt(-1, Integer.MIN_VALUE), 1);
120     assertEquals($noinline$divideUnsignedInt(Integer.MAX_VALUE, Integer.MIN_VALUE), 0);
121     assertEquals($noinline$divideUnsignedInt(Integer.MIN_VALUE, Integer.MAX_VALUE), 1);
122 
123     try {
124       $noinline$divideUnsignedInt(1, 0);
125       throw new Error("Unreachable");
126     } catch (ArithmeticException expected) {
127     }
128   }
129 
$noinline$divideUnsignedLong(long a, long b)130   public static long $noinline$divideUnsignedLong(long a, long b) {
131     return Long.divideUnsigned(a, b);
132   }
133 
134   private static final long BIG_LONG_VALUE = 739287620162442240L;
135 
test_Long_divideUnsigned_no_fold()136   public static void test_Long_divideUnsigned_no_fold() {
137     assertEquals($noinline$divideUnsignedLong(100L, 10L), 10L);
138     assertEquals($noinline$divideUnsignedLong(100L, 1L), 100L);
139     assertEquals($noinline$divideUnsignedLong(1024L, 128L), 8L);
140     assertEquals($noinline$divideUnsignedLong(12345678L, 264L), 46763L);
141     assertEquals($noinline$divideUnsignedLong(13L, 5L), 2L);
142     assertEquals($noinline$divideUnsignedLong(-2L, 2L), Long.MAX_VALUE);
143     assertEquals($noinline$divideUnsignedLong(-1L, 2L), Long.MAX_VALUE);
144     assertEquals($noinline$divideUnsignedLong(100000L, -1L), 0L);
145     assertEquals($noinline$divideUnsignedLong(Long.MAX_VALUE, -1L), 0L);
146     assertEquals($noinline$divideUnsignedLong(-2L, -1L), 0L);
147     assertEquals($noinline$divideUnsignedLong(-1L, -2L), 1L);
148     assertEquals($noinline$divideUnsignedLong(-173448L, 13L), 1418980313362259859L);
149     assertEquals($noinline$divideUnsignedLong(Long.MIN_VALUE, 2L), (1L << 62));
150     assertEquals($noinline$divideUnsignedLong(-1L, Long.MIN_VALUE), 1L);
151     assertEquals($noinline$divideUnsignedLong(Long.MAX_VALUE, Long.MIN_VALUE), 0L);
152     assertEquals($noinline$divideUnsignedLong(Long.MIN_VALUE, Long.MAX_VALUE), 1L);
153     assertEquals($noinline$divideUnsignedLong(Long.MAX_VALUE, 1L), Long.MAX_VALUE);
154     assertEquals($noinline$divideUnsignedLong(Long.MIN_VALUE, 1L), Long.MIN_VALUE);
155     assertEquals($noinline$divideUnsignedLong(BIG_LONG_VALUE, BIG_LONG_VALUE), 1L);
156     assertEquals($noinline$divideUnsignedLong(BIG_LONG_VALUE, 1L), BIG_LONG_VALUE);
157     assertEquals($noinline$divideUnsignedLong(BIG_LONG_VALUE, 1024L), 721960566564885L);
158     assertEquals($noinline$divideUnsignedLong(BIG_LONG_VALUE, 0x1FFFFFFFFL), 86064406L);
159 
160     try {
161       $noinline$divideUnsignedLong(1L, 0L);
162       throw new Error("Unreachable");
163     } catch (ArithmeticException expected) {
164     }
165   }
166 
test_Integer_divideUnsigned()167   public static void test_Integer_divideUnsigned() {
168     assertEquals(Integer.divideUnsigned(100, 10), 10);
169     assertEquals(Integer.divideUnsigned(100, 1), 100);
170     assertEquals(Integer.divideUnsigned(1024, 128), 8);
171     assertEquals(Integer.divideUnsigned(12345678, 264), 46763);
172     assertEquals(Integer.divideUnsigned(13, 5), 2);
173     assertEquals(Integer.divideUnsigned(-2, 2), Integer.MAX_VALUE);
174     assertEquals(Integer.divideUnsigned(-1, 2), Integer.MAX_VALUE);
175     assertEquals(Integer.divideUnsigned(100000, -1), 0);
176     assertEquals(Integer.divideUnsigned(Integer.MAX_VALUE, -1), 0);
177     assertEquals(Integer.divideUnsigned(-2, -1), 0);
178     assertEquals(Integer.divideUnsigned(-1, -2), 1);
179     assertEquals(Integer.divideUnsigned(-173448, 13), 330368757);
180     assertEquals(Integer.divideUnsigned(Integer.MIN_VALUE, 2), (1 << 30));
181     assertEquals(Integer.divideUnsigned(-1, Integer.MIN_VALUE), 1);
182     assertEquals(Integer.divideUnsigned(Integer.MAX_VALUE, Integer.MIN_VALUE), 0);
183     assertEquals(Integer.divideUnsigned(Integer.MIN_VALUE, Integer.MAX_VALUE), 1);
184 
185     try {
186       Integer.divideUnsigned(1, 0);
187       throw new Error("Unreachable");
188     } catch (ArithmeticException expected) {
189     }
190   }
191 
test_Long_divideUnsigned()192   public static void test_Long_divideUnsigned() {
193     assertEquals(Long.divideUnsigned(100L, 10L), 10L);
194     assertEquals(Long.divideUnsigned(100L, 1L), 100L);
195     assertEquals(Long.divideUnsigned(1024L, 128L), 8L);
196     assertEquals(Long.divideUnsigned(12345678L, 264L), 46763L);
197     assertEquals(Long.divideUnsigned(13L, 5L), 2L);
198     assertEquals(Long.divideUnsigned(-2L, 2L), Long.MAX_VALUE);
199     assertEquals(Long.divideUnsigned(-1L, 2L), Long.MAX_VALUE);
200     assertEquals(Long.divideUnsigned(100000L, -1L), 0L);
201     assertEquals(Long.divideUnsigned(Long.MAX_VALUE, -1L), 0L);
202     assertEquals(Long.divideUnsigned(-2L, -1L), 0L);
203     assertEquals(Long.divideUnsigned(-1L, -2L), 1L);
204     assertEquals(Long.divideUnsigned(-173448L, 13L), 1418980313362259859L);
205     assertEquals(Long.divideUnsigned(Long.MIN_VALUE, 2L), (1L << 62));
206     assertEquals(Long.divideUnsigned(-1L, Long.MIN_VALUE), 1L);
207     assertEquals(Long.divideUnsigned(Long.MAX_VALUE, Long.MIN_VALUE), 0L);
208     assertEquals(Long.divideUnsigned(Long.MIN_VALUE, Long.MAX_VALUE), 1L);
209     assertEquals(Long.divideUnsigned(Long.MAX_VALUE, 1L), Long.MAX_VALUE);
210     assertEquals(Long.divideUnsigned(Long.MIN_VALUE, 1L), Long.MIN_VALUE);
211     assertEquals(Long.divideUnsigned(BIG_LONG_VALUE, BIG_LONG_VALUE), 1L);
212     assertEquals(Long.divideUnsigned(BIG_LONG_VALUE, 1L), BIG_LONG_VALUE);
213     assertEquals(Long.divideUnsigned(BIG_LONG_VALUE, 1024L), 721960566564885L);
214     assertEquals(Long.divideUnsigned(BIG_LONG_VALUE, 0x1FFFFFFFFL), 86064406L);
215 
216     try {
217       Long.divideUnsigned(1L, 0L);
218       throw new Error("Unreachable");
219     } catch (ArithmeticException expected) {
220     }
221   }
222 
$noinline$remainderUnsignedInt(int a, int b)223   public static int $noinline$remainderUnsignedInt(int a, int b) {
224     return Integer.remainderUnsigned(a, b);
225   }
226 
test_Integer_remainderUnsigned_no_fold()227   public static void test_Integer_remainderUnsigned_no_fold() {
228     assertEquals($noinline$remainderUnsignedInt(100, 10), 0);
229     assertEquals($noinline$remainderUnsignedInt(100, 1), 0);
230     assertEquals($noinline$remainderUnsignedInt(1024, 127), 8);
231     assertEquals($noinline$remainderUnsignedInt(12345678, 264), 246);
232     assertEquals($noinline$remainderUnsignedInt(13, 5), 3);
233     assertEquals($noinline$remainderUnsignedInt(-2, 2), 0);
234     assertEquals($noinline$remainderUnsignedInt(-1, 2), 1);
235     assertEquals($noinline$remainderUnsignedInt(100000, -1), 100000);
236     assertEquals($noinline$remainderUnsignedInt(Integer.MAX_VALUE, -1), Integer.MAX_VALUE);
237     assertEquals($noinline$remainderUnsignedInt(-2, -1), -2);
238     assertEquals($noinline$remainderUnsignedInt(-1, -2), 1);
239     assertEquals($noinline$remainderUnsignedInt(-173448, 13), 7);
240     assertEquals($noinline$remainderUnsignedInt(Integer.MIN_VALUE, 2), 0);
241     assertEquals($noinline$remainderUnsignedInt(-1, Integer.MIN_VALUE), Integer.MAX_VALUE);
242     assertEquals(
243         $noinline$remainderUnsignedInt(Integer.MAX_VALUE, Integer.MIN_VALUE), Integer.MAX_VALUE);
244     assertEquals($noinline$remainderUnsignedInt(Integer.MIN_VALUE, Integer.MAX_VALUE), 1);
245 
246     try {
247       $noinline$remainderUnsignedInt(1, 0);
248       throw new Error("Unreachable");
249     } catch (ArithmeticException expected) {
250     }
251   }
252 
$noinline$remainderUnsignedLong(long a, long b)253   public static long $noinline$remainderUnsignedLong(long a, long b) {
254     return Long.remainderUnsigned(a, b);
255   }
256 
test_Long_remainderUnsigned_no_fold()257   public static void test_Long_remainderUnsigned_no_fold() {
258     assertEquals($noinline$remainderUnsignedLong(100L, 10L), 0L);
259     assertEquals($noinline$remainderUnsignedLong(100L, 1L), 0L);
260     assertEquals($noinline$remainderUnsignedLong(1024L, 127L), 8L);
261     assertEquals($noinline$remainderUnsignedLong(12345678L, 264L), 246L);
262     assertEquals($noinline$remainderUnsignedLong(13L, 5L), 3L);
263     assertEquals($noinline$remainderUnsignedLong(-2L, 2L), 0L);
264     assertEquals($noinline$remainderUnsignedLong(-1L, 2L), 1L);
265     assertEquals($noinline$remainderUnsignedLong(100000L, -1L), 100000L);
266     assertEquals($noinline$remainderUnsignedLong(Long.MAX_VALUE, -1L), Long.MAX_VALUE);
267     assertEquals($noinline$remainderUnsignedLong(-2L, -1L), -2L);
268     assertEquals($noinline$remainderUnsignedLong(-1L, -2L), 1L);
269     assertEquals($noinline$remainderUnsignedLong(-173448L, 13L), 1L);
270     assertEquals($noinline$remainderUnsignedLong(Long.MIN_VALUE, 2L), 0L);
271     assertEquals($noinline$remainderUnsignedLong(-1L, Long.MIN_VALUE), Long.MAX_VALUE);
272     assertEquals($noinline$remainderUnsignedLong(Long.MAX_VALUE, Long.MIN_VALUE), Long.MAX_VALUE);
273     assertEquals($noinline$remainderUnsignedLong(Long.MIN_VALUE, Long.MAX_VALUE), 1L);
274     assertEquals($noinline$remainderUnsignedLong(Long.MAX_VALUE, 1L), 0L);
275     assertEquals($noinline$remainderUnsignedLong(Long.MIN_VALUE, 1L), 0L);
276     assertEquals($noinline$remainderUnsignedLong(BIG_LONG_VALUE, BIG_LONG_VALUE), 0L);
277     assertEquals($noinline$remainderUnsignedLong(BIG_LONG_VALUE, 1L), 0L);
278     assertEquals($noinline$remainderUnsignedLong(BIG_LONG_VALUE, 1024L), 0L);
279     assertEquals($noinline$remainderUnsignedLong(BIG_LONG_VALUE, 0x1FFFFFFFFL), 2009174294L);
280     assertEquals(
281         $noinline$remainderUnsignedLong(BIG_LONG_VALUE, -38766615688777L), 739287620162442240L);
282 
283     try {
284       $noinline$remainderUnsignedLong(1L, 0L);
285       throw new Error("Unreachable");
286     } catch (ArithmeticException expected) {
287     }
288   }
289 
test_Integer_remainderUnsigned()290   public static void test_Integer_remainderUnsigned() {
291     assertEquals(Integer.remainderUnsigned(100, 10), 0);
292     assertEquals(Integer.remainderUnsigned(100, 1), 0);
293     assertEquals(Integer.remainderUnsigned(1024, 127), 8);
294     assertEquals(Integer.remainderUnsigned(12345678, 264), 246);
295     assertEquals(Integer.remainderUnsigned(13, 5), 3);
296     assertEquals(Integer.remainderUnsigned(-2, 2), 0);
297     assertEquals(Integer.remainderUnsigned(-1, 2), 1);
298     assertEquals(Integer.remainderUnsigned(100000, -1), 100000);
299     assertEquals(Integer.remainderUnsigned(Integer.MAX_VALUE, -1), Integer.MAX_VALUE);
300     assertEquals(Integer.remainderUnsigned(-2, -1), -2);
301     assertEquals(Integer.remainderUnsigned(-1, -2), 1);
302     assertEquals(Integer.remainderUnsigned(-173448, 13), 7);
303     assertEquals(Integer.remainderUnsigned(Integer.MIN_VALUE, 2), 0);
304     assertEquals(Integer.remainderUnsigned(-1, Integer.MIN_VALUE), Integer.MAX_VALUE);
305     assertEquals(
306         Integer.remainderUnsigned(Integer.MAX_VALUE, Integer.MIN_VALUE), Integer.MAX_VALUE);
307     assertEquals(Integer.remainderUnsigned(Integer.MIN_VALUE, Integer.MAX_VALUE), 1);
308 
309     try {
310       Integer.remainderUnsigned(1, 0);
311       throw new Error("Unreachable");
312     } catch (ArithmeticException expected) {
313     }
314   }
315 
test_Long_remainderUnsigned()316   public static void test_Long_remainderUnsigned() {
317     assertEquals(Long.remainderUnsigned(100L, 10L), 0L);
318     assertEquals(Long.remainderUnsigned(100L, 1L), 0L);
319     assertEquals(Long.remainderUnsigned(1024L, 127L), 8L);
320     assertEquals(Long.remainderUnsigned(12345678L, 264L), 246L);
321     assertEquals(Long.remainderUnsigned(13L, 5L), 3L);
322     assertEquals(Long.remainderUnsigned(-2L, 2L), 0L);
323     assertEquals(Long.remainderUnsigned(-1L, 2L), 1L);
324     assertEquals(Long.remainderUnsigned(100000L, -1L), 100000L);
325     assertEquals(Long.remainderUnsigned(Long.MAX_VALUE, -1L), Long.MAX_VALUE);
326     assertEquals(Long.remainderUnsigned(-2L, -1L), -2L);
327     assertEquals(Long.remainderUnsigned(-1L, -2L), 1L);
328     assertEquals(Long.remainderUnsigned(-173448L, 13L), 1L);
329     assertEquals(Long.remainderUnsigned(Long.MIN_VALUE, 2L), 0L);
330     assertEquals(Long.remainderUnsigned(-1L, Long.MIN_VALUE), Long.MAX_VALUE);
331     assertEquals(Long.remainderUnsigned(Long.MAX_VALUE, Long.MIN_VALUE), Long.MAX_VALUE);
332     assertEquals(Long.remainderUnsigned(Long.MIN_VALUE, Long.MAX_VALUE), 1L);
333     assertEquals(Long.remainderUnsigned(Long.MAX_VALUE, 1L), 0L);
334     assertEquals(Long.remainderUnsigned(Long.MIN_VALUE, 1L), 0L);
335     assertEquals(Long.remainderUnsigned(BIG_LONG_VALUE, BIG_LONG_VALUE), 0L);
336     assertEquals(Long.remainderUnsigned(BIG_LONG_VALUE, 1L), 0L);
337     assertEquals(Long.remainderUnsigned(BIG_LONG_VALUE, 1024L), 0L);
338     assertEquals(Long.remainderUnsigned(BIG_LONG_VALUE, 0x1FFFFFFFFL), 2009174294L);
339     assertEquals(Long.remainderUnsigned(BIG_LONG_VALUE, -38766615688777L), 739287620162442240L);
340 
341     try {
342       Long.remainderUnsigned(1L, 0L);
343       throw new Error("Unreachable");
344     } catch (ArithmeticException expected) {
345     }
346   }
347 
assertEquals(int expected, int actual)348   public static void assertEquals(int expected, int actual) {
349       if (expected != actual) {
350           throw new Error("Expected: " + expected + ", found: " + actual);
351       }
352   }
353 
assertEquals(long expected, long actual)354   public static void assertEquals(long expected, long actual) {
355       if (expected != actual) {
356           throw new Error("Expected: " + expected + ", found: " + actual);
357       }
358   }
359 
assertEquals(boolean expected, boolean actual)360   public static void assertEquals(boolean expected, boolean actual) {
361       if (expected != actual) {
362           throw new Error("Expected: " + expected + ", found: " + actual);
363       }
364   }
365 
366   static final int IF_TRUE_VALUE = -55555;
367   static final int IF_FALSE_VALUE = 99999;
368 
$noinline$compareUnsignedInt_LT(int a, int b)369   public static int $noinline$compareUnsignedInt_LT(int a, int b) {
370     return Integer.compareUnsigned(a, b) < 0 ? IF_TRUE_VALUE : IF_FALSE_VALUE;
371   }
372 
$noinline$compareUnsignedInt_LE(int a, int b)373   public static int $noinline$compareUnsignedInt_LE(int a, int b) {
374     return Integer.compareUnsigned(a, b) <= 0 ? IF_TRUE_VALUE : IF_FALSE_VALUE;
375   }
376 
$noinline$compareUnsignedInt_GT(int a, int b)377   public static int $noinline$compareUnsignedInt_GT(int a, int b) {
378     return Integer.compareUnsigned(a, b) > 0 ? IF_TRUE_VALUE : IF_FALSE_VALUE;
379   }
380 
$noinline$compareUnsignedInt_GE(int a, int b)381   public static int $noinline$compareUnsignedInt_GE(int a, int b) {
382     return Integer.compareUnsigned(a, b) >= 0 ? IF_TRUE_VALUE : IF_FALSE_VALUE;
383   }
384 
$noinline$compareUnsignedInt_EQ(int a, int b)385   public static int $noinline$compareUnsignedInt_EQ(int a, int b) {
386     return Integer.compareUnsigned(a, b) == 0 ? IF_TRUE_VALUE : IF_FALSE_VALUE;
387   }
388 
$noinline$compareUnsignedInt_NE(int a, int b)389   public static int $noinline$compareUnsignedInt_NE(int a, int b) {
390     return Integer.compareUnsigned(a, b) != 0 ? IF_TRUE_VALUE : IF_FALSE_VALUE;
391   }
392 
$noinline$compareUnsignedLong_LT(long a, long b)393   public static int $noinline$compareUnsignedLong_LT(long a, long b) {
394     return Long.compareUnsigned(a, b) < 0 ? IF_TRUE_VALUE : IF_FALSE_VALUE;
395   }
396 
$noinline$compareUnsignedLong_LE(long a, long b)397   public static int $noinline$compareUnsignedLong_LE(long a, long b) {
398     return Long.compareUnsigned(a, b) <= 0 ? IF_TRUE_VALUE : IF_FALSE_VALUE;
399   }
400 
$noinline$compareUnsignedLong_GT(long a, long b)401   public static int $noinline$compareUnsignedLong_GT(long a, long b) {
402     return Long.compareUnsigned(a, b) > 0 ? IF_TRUE_VALUE : IF_FALSE_VALUE;
403   }
404 
$noinline$compareUnsignedLong_GE(long a, long b)405   public static int $noinline$compareUnsignedLong_GE(long a, long b) {
406     return Long.compareUnsigned(a, b) >= 0 ? IF_TRUE_VALUE : IF_FALSE_VALUE;
407   }
408 
$noinline$compareUnsignedLong_EQ(long a, long b)409   public static int $noinline$compareUnsignedLong_EQ(long a, long b) {
410     return Long.compareUnsigned(a, b) == 0 ? IF_TRUE_VALUE : IF_FALSE_VALUE;
411   }
412 
$noinline$compareUnsignedLong_NE(long a, long b)413   public static int $noinline$compareUnsignedLong_NE(long a, long b) {
414     return Long.compareUnsigned(a, b) != 0 ? IF_TRUE_VALUE : IF_FALSE_VALUE;
415   }
416 
$noinline$compareSignedSameOperands(long a)417   public static int $noinline$compareSignedSameOperands(long a) {
418     return Long.compare(a, a) >= 0 ? IF_TRUE_VALUE : IF_FALSE_VALUE;
419   }
420 
test_Integer_compareUnsigned_in_condition()421   public static void test_Integer_compareUnsigned_in_condition() {
422     // <
423     assertEquals($noinline$compareUnsignedInt_LT(10, 20), IF_TRUE_VALUE);
424     assertEquals($noinline$compareUnsignedInt_LT(Integer.MIN_VALUE, 0), IF_FALSE_VALUE);
425     assertEquals($noinline$compareUnsignedInt_LT(0, 0), IF_FALSE_VALUE);
426 
427     // <=
428     assertEquals($noinline$compareUnsignedInt_LE(10, 20), IF_TRUE_VALUE);
429     assertEquals($noinline$compareUnsignedInt_LE(Integer.MIN_VALUE, 0), IF_FALSE_VALUE);
430     assertEquals($noinline$compareUnsignedInt_LE(0, 0), IF_TRUE_VALUE);
431 
432     // >
433     assertEquals($noinline$compareUnsignedInt_GT(10, 20), IF_FALSE_VALUE);
434     assertEquals($noinline$compareUnsignedInt_GT(Integer.MIN_VALUE, 0), IF_TRUE_VALUE);
435     assertEquals($noinline$compareUnsignedInt_GT(0, 0), IF_FALSE_VALUE);
436 
437     // =>
438     assertEquals($noinline$compareUnsignedInt_GE(10, 20), IF_FALSE_VALUE);
439     assertEquals($noinline$compareUnsignedInt_GE(Integer.MIN_VALUE, 0), IF_TRUE_VALUE);
440     assertEquals($noinline$compareUnsignedInt_GE(0, 0), IF_TRUE_VALUE);
441 
442     // ==
443     assertEquals($noinline$compareUnsignedInt_EQ(10, 20), IF_FALSE_VALUE);
444     assertEquals($noinline$compareUnsignedInt_EQ(Integer.MIN_VALUE, 0), IF_FALSE_VALUE);
445     assertEquals($noinline$compareUnsignedInt_EQ(0, 0), IF_TRUE_VALUE);
446 
447     // !=
448     assertEquals($noinline$compareUnsignedInt_NE(10, 20), IF_TRUE_VALUE);
449     assertEquals($noinline$compareUnsignedInt_NE(Integer.MIN_VALUE, 0), IF_TRUE_VALUE);
450     assertEquals($noinline$compareUnsignedInt_NE(0, 0), IF_FALSE_VALUE);
451   }
452 
test_Long_compareUnsigned_in_condition()453   public static void test_Long_compareUnsigned_in_condition() {
454     // <
455     assertEquals($noinline$compareUnsignedLong_LT(10L, 20L), IF_TRUE_VALUE);
456     assertEquals($noinline$compareUnsignedLong_LT(Long.MIN_VALUE, 0L), IF_FALSE_VALUE);
457     assertEquals($noinline$compareUnsignedLong_LT(0L, 0L), IF_FALSE_VALUE);
458 
459     // <=
460     assertEquals($noinline$compareUnsignedLong_LE(10L, 20L), IF_TRUE_VALUE);
461     assertEquals($noinline$compareUnsignedLong_LE(Long.MIN_VALUE, 0L), IF_FALSE_VALUE);
462     assertEquals($noinline$compareUnsignedLong_LE(0L, 0L), IF_TRUE_VALUE);
463 
464     // >
465     assertEquals($noinline$compareUnsignedLong_GT(10L, 20L), IF_FALSE_VALUE);
466     assertEquals($noinline$compareUnsignedLong_GT(Long.MIN_VALUE, 0L), IF_TRUE_VALUE);
467     assertEquals($noinline$compareUnsignedLong_GT(0L, 0L), IF_FALSE_VALUE);
468 
469     // =>
470     assertEquals($noinline$compareUnsignedLong_GE(10L, 20L), IF_FALSE_VALUE);
471     assertEquals($noinline$compareUnsignedLong_GE(Long.MIN_VALUE, 0L), IF_TRUE_VALUE);
472     assertEquals($noinline$compareUnsignedLong_GE(0L, 0L), IF_TRUE_VALUE);
473 
474     // ==
475     assertEquals($noinline$compareUnsignedLong_EQ(10L, 20L), IF_FALSE_VALUE);
476     assertEquals($noinline$compareUnsignedLong_EQ(Long.MIN_VALUE, 0L), IF_FALSE_VALUE);
477     assertEquals($noinline$compareUnsignedLong_EQ(0L, 0L), IF_TRUE_VALUE);
478 
479     // !=
480     assertEquals($noinline$compareUnsignedLong_NE(10L, 20L), IF_TRUE_VALUE);
481     assertEquals($noinline$compareUnsignedLong_NE(Long.MIN_VALUE, 0L), IF_TRUE_VALUE);
482     assertEquals($noinline$compareUnsignedLong_NE(0L, 0L), IF_FALSE_VALUE);
483   }
484 
$inline$hidden_zero()485   private static int $inline$hidden_zero() {
486     return "1".indexOf('1');
487   }
488 
$inline$BelowInteger(int x, int y)489   public static boolean $inline$BelowInteger(int x, int y) {
490     return Integer.compare(x + Integer.MIN_VALUE, y + Integer.MIN_VALUE) < 0;
491   }
492 
$noinline$testDoubleUnsignedCompareInteger_B(int x, int y)493   public static boolean $noinline$testDoubleUnsignedCompareInteger_B(int x, int y) {
494     int cmp = Integer.compare(x + Integer.MIN_VALUE, y + Integer.MIN_VALUE);
495     return $inline$BelowInteger(cmp, $inline$hidden_zero());
496   }
497 
$inline$BelowOrEqualInteger(int x, int y)498   public static boolean $inline$BelowOrEqualInteger(int x, int y) {
499     return Integer.compare(x + Integer.MIN_VALUE, y + Integer.MIN_VALUE) <= 0;
500   }
501 
$noinline$testDoubleUnsignedCompareInteger_BE(int x, int y)502   public static boolean $noinline$testDoubleUnsignedCompareInteger_BE(int x, int y) {
503     int cmp = Integer.compare(x + Integer.MIN_VALUE, y + Integer.MIN_VALUE);
504     return $inline$BelowOrEqualInteger(cmp, $inline$hidden_zero());
505   }
506 
$inline$AboveInteger(int x, int y)507   public static boolean $inline$AboveInteger(int x, int y) {
508     return Integer.compare(x + Integer.MIN_VALUE, y + Integer.MIN_VALUE) > 0;
509   }
510 
$noinline$testDoubleUnsignedCompareInteger_A(int x, int y)511   public static boolean $noinline$testDoubleUnsignedCompareInteger_A(int x, int y) {
512     int cmp = Integer.compare(x + Integer.MIN_VALUE, y + Integer.MIN_VALUE);
513     return $inline$AboveInteger(cmp, $inline$hidden_zero());
514   }
515 
$inline$AboveOrEqualInteger(int x, int y)516   public static boolean $inline$AboveOrEqualInteger(int x, int y) {
517     return Integer.compare(x + Integer.MIN_VALUE, y + Integer.MIN_VALUE) >= 0;
518   }
519 
$noinline$testDoubleUnsignedCompareInteger_AE(int x, int y)520   public static boolean $noinline$testDoubleUnsignedCompareInteger_AE(int x, int y) {
521     int cmp = Integer.compare(x + Integer.MIN_VALUE, y + Integer.MIN_VALUE);
522     return $inline$AboveOrEqualInteger(cmp, $inline$hidden_zero());
523   }
524 
test_Integer_doubleUnsignedCompare()525   public static void test_Integer_doubleUnsignedCompare() {
526     // <
527     assertEquals($noinline$testDoubleUnsignedCompareInteger_B(0, 0), false);
528     assertEquals($noinline$testDoubleUnsignedCompareInteger_B(Integer.MIN_VALUE, 0), false);
529     assertEquals($noinline$testDoubleUnsignedCompareInteger_B(0, Integer.MIN_VALUE), false);
530 
531     // <=
532     assertEquals($noinline$testDoubleUnsignedCompareInteger_BE(0, 0), true);
533     assertEquals($noinline$testDoubleUnsignedCompareInteger_BE(Integer.MIN_VALUE, 0), false);
534     assertEquals($noinline$testDoubleUnsignedCompareInteger_BE(0, Integer.MIN_VALUE), false);
535 
536     // >
537     assertEquals($noinline$testDoubleUnsignedCompareInteger_A(0, 0), false);
538     assertEquals($noinline$testDoubleUnsignedCompareInteger_A(Integer.MIN_VALUE, 0), true);
539     assertEquals($noinline$testDoubleUnsignedCompareInteger_A(0, Integer.MIN_VALUE), true);
540 
541     // =>
542     assertEquals($noinline$testDoubleUnsignedCompareInteger_AE(0, 0), true);
543     assertEquals($noinline$testDoubleUnsignedCompareInteger_AE(Integer.MIN_VALUE, 0), true);
544     assertEquals($noinline$testDoubleUnsignedCompareInteger_AE(0, Integer.MIN_VALUE), true);
545   }
546 
$inline$BelowInteger_Xored(int x, int y)547   public static boolean $inline$BelowInteger_Xored(int x, int y) {
548     return Integer.compare(x ^ Integer.MIN_VALUE, y ^ Integer.MIN_VALUE) < 0;
549   }
550 
$noinline$testDoubleUnsignedCompareInteger_BT_Xored(int x, int y)551   public static boolean $noinline$testDoubleUnsignedCompareInteger_BT_Xored(int x, int y) {
552     int cmp = Integer.compare(x ^ Integer.MIN_VALUE, y ^ Integer.MIN_VALUE);
553     return $inline$BelowInteger_Xored(cmp, $inline$hidden_zero());
554   }
555 
$inline$BelowOrEqualInteger_Xored(int x, int y)556   public static boolean $inline$BelowOrEqualInteger_Xored(int x, int y) {
557     return Integer.compare(x ^ Integer.MIN_VALUE, y ^ Integer.MIN_VALUE) <= 0;
558   }
559 
$noinline$testDoubleUnsignedCompareInteger_BE_Xored(int x, int y)560   public static boolean $noinline$testDoubleUnsignedCompareInteger_BE_Xored(int x, int y) {
561     int cmp = Integer.compare(x ^ Integer.MIN_VALUE, y ^ Integer.MIN_VALUE);
562     return $inline$BelowOrEqualInteger_Xored(cmp, $inline$hidden_zero());
563   }
564 
$inline$AboveInteger_Xored(int x, int y)565   public static boolean $inline$AboveInteger_Xored(int x, int y) {
566     return Integer.compare(x ^ Integer.MIN_VALUE, y ^ Integer.MIN_VALUE) > 0;
567   }
568 
$noinline$testDoubleUnsignedCompareInteger_AT_Xored(int x, int y)569   public static boolean $noinline$testDoubleUnsignedCompareInteger_AT_Xored(int x, int y) {
570     int cmp = Integer.compare(x ^ Integer.MIN_VALUE, y ^ Integer.MIN_VALUE);
571     return $inline$AboveInteger_Xored(cmp, $inline$hidden_zero());
572   }
573 
$inline$AboveOrEqualInteger_Xored(int x, int y)574   public static boolean $inline$AboveOrEqualInteger_Xored(int x, int y) {
575     return Integer.compare(x ^ Integer.MIN_VALUE, y ^ Integer.MIN_VALUE) >= 0;
576   }
577 
$noinline$testDoubleUnsignedCompareInteger_AE_Xored(int x, int y)578   public static boolean $noinline$testDoubleUnsignedCompareInteger_AE_Xored(int x, int y) {
579     int cmp = Integer.compare(x ^ Integer.MIN_VALUE, y ^ Integer.MIN_VALUE);
580     return $inline$AboveOrEqualInteger_Xored(cmp, $inline$hidden_zero());
581   }
582 
test_Integer_doubleUnsignedCompare_Xored()583   public static void test_Integer_doubleUnsignedCompare_Xored() {
584     // <
585     assertEquals($noinline$testDoubleUnsignedCompareInteger_BT_Xored(0, 0), false);
586     assertEquals($noinline$testDoubleUnsignedCompareInteger_BT_Xored(Integer.MIN_VALUE, 0), false);
587     assertEquals($noinline$testDoubleUnsignedCompareInteger_BT_Xored(0, Integer.MIN_VALUE), false);
588 
589     // <=
590     assertEquals($noinline$testDoubleUnsignedCompareInteger_BE_Xored(0, 0), true);
591     assertEquals($noinline$testDoubleUnsignedCompareInteger_BE_Xored(Integer.MIN_VALUE, 0), false);
592     assertEquals($noinline$testDoubleUnsignedCompareInteger_BE_Xored(0, Integer.MIN_VALUE), false);
593 
594     // >
595     assertEquals($noinline$testDoubleUnsignedCompareInteger_AT_Xored(0, 0), false);
596     assertEquals($noinline$testDoubleUnsignedCompareInteger_AT_Xored(Integer.MIN_VALUE, 0), true);
597     assertEquals($noinline$testDoubleUnsignedCompareInteger_AT_Xored(0, Integer.MIN_VALUE), true);
598 
599     // =>
600     assertEquals($noinline$testDoubleUnsignedCompareInteger_AE_Xored(0, 0), true);
601     assertEquals($noinline$testDoubleUnsignedCompareInteger_AE_Xored(Integer.MIN_VALUE, 0), true);
602     assertEquals($noinline$testDoubleUnsignedCompareInteger_AE_Xored(0, Integer.MIN_VALUE), true);
603   }
604 }
605