1 /*
2  * Copyright (C) 2007 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 /**
18  * Test switch() blocks
19  */
20 public class Main {
21 
22     // TODO: This should be translated to smali tests, so it is guaranteed we have the right kind
23     //       of switch.
24 
25     // Simple packed-switch.
packedSwitch(int value)26     public static void packedSwitch(int value) {
27         switch (value) {
28             case 0:
29                 System.out.println("0"); break;
30             case 1:
31                 System.out.println("1"); break;
32             case 2:
33                 System.out.println("2"); break;
34             case 3:
35                 System.out.println("3"); break;
36             case 4:
37                 System.out.println("4"); break;
38             default:
39                 System.out.println("default"); break;
40         }
41     }
42 
43     // Simple packed-switch starting at a negative index.
packedSwitch2(int value)44     public static void packedSwitch2(int value) {
45         switch (value) {
46             case -3:
47                 System.out.println("-3"); break;
48             case -2:
49                 System.out.println("-2"); break;
50             case -1:
51                 System.out.println("-1"); break;
52             case 0:
53                 System.out.println("0"); break;
54             case 1:
55                 System.out.println("1"); break;
56             case 2:
57                 System.out.println("2"); break;
58             default:
59                 System.out.println("default"); break;
60         }
61     }
62 
63     // Simple packed-switch starting above 0.
packedSwitch3(int value)64     public static void packedSwitch3(int value) {
65         switch (value) {
66             case 2:
67                 System.out.println("2"); break;
68             case 3:
69                 System.out.println("3"); break;
70             case 4:
71                 System.out.println("4"); break;
72             case 5:
73                 System.out.println("5"); break;
74             case 6:
75                 System.out.println("6"); break;
76             default:
77                 System.out.println("default"); break;
78         }
79     }
80 
81     // Simple packed-switch going up to max_int.
packedSwitch4(int value)82     public static void packedSwitch4(int value) {
83         switch (value) {
84             case Integer.MAX_VALUE - 1:
85                 System.out.println(Integer.MAX_VALUE - 1); break;
86             case Integer.MAX_VALUE:
87                 System.out.println(Integer.MAX_VALUE); break;
88             default:
89                 System.out.println("default"); break;
90         }
91     }
92 
93     // Simple packed-switch starting at min_int.
packedSwitch5(int value)94     public static void packedSwitch5(int value) {
95         switch (value) {
96             case Integer.MIN_VALUE:
97                 System.out.println(Integer.MIN_VALUE); break;
98             case Integer.MIN_VALUE + 1:
99                 System.out.println(Integer.MIN_VALUE + 1); break;
100             default:
101                 System.out.println("default"); break;
102         }
103     }
104 
105     // Simple (packed-)switch with only min_int.
packedSwitch6(int value)106     public static void packedSwitch6(int value) {
107         switch (value) {
108             case Integer.MIN_VALUE:
109                 System.out.println(Integer.MIN_VALUE); break;
110             default:
111                 System.out.println("default"); break;
112         }
113     }
114 
115     // Long packed-switch that might lead to not creating chained-ifs.
packedSwitch7(int value)116     public static void packedSwitch7(int value) {
117         switch (value) {
118             case 1:
119                 System.out.println(1); break;
120             case 2:
121                 System.out.println(2); break;
122             case 3:
123                 System.out.println(3); break;
124             case 4:
125                 System.out.println(4); break;
126             case 5:
127                 System.out.println(5); break;
128             case 6:
129                 System.out.println(6); break;
130             case 7:
131                 System.out.println(7); break;
132             case 8:
133                 System.out.println(8); break;
134             case 9:
135                 System.out.println(9); break;
136             case 10:
137                 System.out.println(10); break;
138             case 11:
139                 System.out.println(11); break;
140             case 12:
141                 System.out.println(12); break;
142             case 13:
143                 System.out.println(13); break;
144             case 14:
145                 System.out.println(14); break;
146             case 15:
147                 System.out.println(15); break;
148             default:
149                 System.out.println("default"); break;
150         }
151     }
152 
153     // Sparse switch, just leave a gap.
sparseSwitch(int value)154     public static void sparseSwitch(int value) {
155         switch (value) {
156             case 0:
157                 System.out.println("0"); break;
158             case 1:
159                 System.out.println("1"); break;
160             case 3:
161                 System.out.println("3"); break;
162             case 4:
163                 System.out.println("4"); break;
164             default:
165                 System.out.println("default"); break;
166         }
167     }
168 
169     // Simple sparse-switch starting at a negative index.
sparseSwitch2(int value)170     public static void sparseSwitch2(int value) {
171         switch (value) {
172             case -3:
173                 System.out.println("-3"); break;
174             case -2:
175                 System.out.println("-2"); break;
176             case -1:
177                 System.out.println("-1"); break;
178             case 0:
179                 System.out.println("0"); break;
180             case 2:
181                 System.out.println("2"); break;
182             default:
183                 System.out.println("default"); break;
184         }
185     }
186 
187     // Simple sparse-switch starting above 0.
sparseSwitch3(int value)188     public static void sparseSwitch3(int value) {
189         switch (value) {
190             case 2:
191                 System.out.println("2"); break;
192             case 4:
193                 System.out.println("4"); break;
194             case 5:
195                 System.out.println("5"); break;
196             case 6:
197                 System.out.println("6"); break;
198             default:
199                 System.out.println("default"); break;
200         }
201     }
202 
203     // Simple sparse-switch going up to max_int.
sparseSwitch4(int value)204     public static void sparseSwitch4(int value) {
205         switch (value) {
206             case Integer.MAX_VALUE - 2:
207                 System.out.println(Integer.MAX_VALUE - 2); break;
208             case Integer.MAX_VALUE:
209                 System.out.println(Integer.MAX_VALUE); break;
210             default:
211                 System.out.println("default"); break;
212         }
213     }
214 
215     // Simple sparse-switch starting at min_int.
sparseSwitch5(int value)216     public static void sparseSwitch5(int value) {
217         switch (value) {
218             case Integer.MIN_VALUE:
219                 System.out.println(Integer.MIN_VALUE); break;
220             case Integer.MIN_VALUE + 2:
221                 System.out.println(Integer.MIN_VALUE + 2); break;
222             default:
223                 System.out.println("default"); break;
224         }
225     }
226 
227     // Long sparse-switch that might lead to not creating chained-ifs.
sparseSwitch7(int value)228     public static void sparseSwitch7(int value) {
229         switch (value) {
230             case 1:
231                 System.out.println(1); break;
232             case 2:
233                 System.out.println(2); break;
234             case 4:
235                 System.out.println(4); break;
236             case 5:
237                 System.out.println(5); break;
238             case 6:
239                 System.out.println(6); break;
240             case 7:
241                 System.out.println(7); break;
242             case 8:
243                 System.out.println(8); break;
244             case 9:
245                 System.out.println(9); break;
246             case 10:
247                 System.out.println(10); break;
248             case 11:
249                 System.out.println(11); break;
250             case 12:
251                 System.out.println(12); break;
252             case 13:
253                 System.out.println(13); break;
254             case 14:
255                 System.out.println(14); break;
256             case 15:
257                 System.out.println(15); break;
258             default:
259                 System.out.println("default"); break;
260         }
261     }
262 
main(String args[])263     public static void main(String args[]) {
264         /*
265          * Note: We are using for loops and calls to hopefully avoid simplifying the switch
266          *       structure from constant propagation. When inlining is supported, this needs to
267          *       be revisited.
268          */
269 
270         System.out.println("packed");
271         for (int i = -2; i < 3; i++) {
272             packedSwitch(i);
273         }
274         packedSwitch(Integer.MIN_VALUE);
275         packedSwitch(Integer.MAX_VALUE);
276 
277         System.out.println("packed2");
278         for (int i = -2; i < 3; i++) {
279             packedSwitch2(i);
280         }
281         packedSwitch2(Integer.MIN_VALUE);
282         packedSwitch2(Integer.MAX_VALUE);
283 
284         System.out.println("packed3");
285         for (int i = -2; i < 7; i++) {
286             packedSwitch3(i);
287         }
288         packedSwitch3(Integer.MIN_VALUE);
289         packedSwitch3(Integer.MAX_VALUE);
290 
291         System.out.println("packed4");
292         for (int i = Integer.MAX_VALUE - 2; i > 0; i++) {
293             packedSwitch4(i);
294         }
295         packedSwitch4(Integer.MIN_VALUE);
296 
297         System.out.println("packed5");
298         for (int i = Integer.MIN_VALUE; i < Integer.MIN_VALUE + 2; i++) {
299             packedSwitch5(i);
300         }
301         packedSwitch5(Integer.MAX_VALUE);
302 
303         System.out.println("packed6");
304         packedSwitch6(Integer.MIN_VALUE);
305         packedSwitch6(Integer.MAX_VALUE);
306 
307         System.out.println("packed7");
308         for (int i = -1; i < 17; i++) {
309             packedSwitch7(i);
310         }
311 
312 
313         System.out.println("sparse");
314         for (int i = -2; i < 4; i++) {
315             sparseSwitch(i);
316         }
317         sparseSwitch(Integer.MIN_VALUE);
318         sparseSwitch(Integer.MAX_VALUE);
319 
320         System.out.println("sparse2");
321         for (int i = -2; i < 3; i++) {
322             sparseSwitch2(i);
323         }
324         sparseSwitch2(Integer.MIN_VALUE);
325         sparseSwitch2(Integer.MAX_VALUE);
326 
327         System.out.println("sparse3");
328         for (int i = -2; i < 7; i++) {
329             sparseSwitch3(i);
330         }
331         sparseSwitch3(Integer.MIN_VALUE);
332         sparseSwitch3(Integer.MAX_VALUE);
333 
334         System.out.println("sparse4");
335         for (int i = Integer.MAX_VALUE - 2; i > 0; i++) {
336             sparseSwitch4(i);
337         }
338         sparseSwitch4(Integer.MIN_VALUE);
339 
340         System.out.println("sparse5");
341         for (int i = Integer.MIN_VALUE; i < Integer.MIN_VALUE + 2; i++) {
342             sparseSwitch5(i);
343         }
344         sparseSwitch5(Integer.MAX_VALUE);
345 
346         System.out.println("sparse7");
347         for (int i = -1; i < 17; i++) {
348             sparseSwitch7(i);
349         }
350 
351         // Older tests.
352 
353         int a = 1;
354 
355         switch (a) {
356             case -1: System.out.print("neg one\n"); break;
357             case 0: System.out.print("zero\n"); break;
358             case 1: System.out.print("CORRECT (one)\n"); break;
359             case 2: System.out.print("two\n"); break;
360             case 3: System.out.print("three\n"); break;
361             case 4: System.out.print("four\n"); break;
362             default: System.out.print("???\n"); break;
363         }
364         switch (a) {
365             case 3: System.out.print("three\n"); break;
366             case 4: System.out.print("four\n"); break;
367             default: System.out.print("CORRECT (not found)\n"); break;
368         }
369 
370         a = 0x12345678;
371 
372         switch (a) {
373             case 0x12345678: System.out.print("CORRECT (large)\n"); break;
374             case 0x12345679: System.out.print("large+1\n"); break;
375             default: System.out.print("nuts\n"); break;
376         }
377         switch (a) {
378             case 0x12345678: System.out.print("CORRECT (large2)\n"); break;
379             case 0x12345700: System.out.print("large+many\n"); break;
380             default: System.out.print("nuts\n"); break;
381         }
382         switch (a) {
383             case 57: System.out.print("fifty-seven!\n"); break;
384             case -6: System.out.print("neg six!\n"); break;
385             case 0x12345678: System.out.print("CORRECT (large3)\n"); break;
386             case 22: System.out.print("twenty-two!\n"); break;
387             case 3: System.out.print("three!\n"); break;
388             default: System.out.print("huh?\n"); break;
389         }
390         switch (a) {
391             case -6: System.out.print("neg six!\n"); break;
392             case 3: System.out.print("three!\n"); break;
393             default: System.out.print("CORRECT (not found)\n"); break;
394         }
395 
396         a = -5;
397         switch (a) {
398             case 12: System.out.print("twelve\n"); break;
399             case -5: System.out.print("CORRECT (not found)\n"); break;
400             case 0: System.out.print("zero\n"); break;
401             default: System.out.print("wah?\n"); break;
402         }
403 
404         switch (a) {
405             default: System.out.print("CORRECT (default only)\n"); break;
406         }
407 
408         a = -10;
409         switch (a) {
410             case -10: System.out.print("CORRECT big sparse / first\n"); break;
411             case -5: System.out.print("neg five\n"); break;
412             case 0: System.out.print("zero\n"); break;
413             case 5: System.out.print("five\n"); break;
414             case 10: System.out.print("ten\n"); break;
415             case 15: System.out.print("fifteen\n"); break;
416             case 20: System.out.print("twenty\n"); break;
417             case 50: System.out.print("fifty\n"); break;
418             case 100: System.out.print("hundred\n"); break;
419             default: System.out.print("blah!\n"); break;
420         }
421 
422         a = 100;
423         switch (a) {
424             case -10: System.out.print("neg ten\n"); break;
425             case -5: System.out.print("neg five\n"); break;
426             case 0: System.out.print("zero\n"); break;
427             case 5: System.out.print("five\n"); break;
428             case 10: System.out.print("ten\n"); break;
429             case 15: System.out.print("fifteen\n"); break;
430             case 20: System.out.print("twenty\n"); break;
431             case 50: System.out.print("fifty\n"); break;
432             case 100: System.out.print("CORRECT big sparse / last\n"); break;
433             default: System.out.print("blah!\n"); break;
434         }
435 
436         for (a = 253; a <= 258; a++) {
437           switch (a) {
438             case 254: System.out.println("254"); break;
439             case 255: System.out.println("255"); break;
440             case 256: System.out.println("256"); break;
441             case 257: System.out.println("257"); break;
442             default: System.out.println("default"); break;
443           }
444         }
445     }
446 }
447