• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1/*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16function main() {
17    let res = false;
18    switch (0) {
19        case 0:
20          switch (1) {
21            case 1:
22              res = true
23              break;
24            case 2:
25              break;
26            default:
27              throw Error('Bad overload');
28          }
29          break;
30        case 1:
31          break;
32        case 2:
33          break;
34        case 3:
35          break;
36        case 4:
37          break;
38        case 5:
39          break;
40        case 6:
41          break;
42        case 7:
43          break;
44        case 8:
45          break;
46        case 9:
47          break;
48        case 10:
49          break;
50        case 11:
51          break;
52        case 12:
53          break;
54        case 13:
55          break;
56        case 14:
57          break;
58        case 15:
59          break;
60        case 16:
61          break;
62        case 17:
63          break;
64        case 18:
65          break;
66        case 19:
67          break;
68        case 20:
69          switch (1) {
70            case 1:
71              break;
72            case 2:
73              break;
74            default:
75              throw Error('Bad overload');
76          }
77          break;
78        case 21:
79          break;
80        case 22:
81          break;
82        case 23:
83          break;
84        case 24:
85          break;
86        case 25:
87          break;
88        case 26:
89          break;
90        case 27:
91          break;
92        case 28:
93          break;
94        case 29:
95          break;
96        case 30:
97          break;
98        case 31:
99          break;
100        case 32:
101          break;
102        case 33:
103          break;
104        case 34:
105          break;
106        case 35:
107          break;
108        case 36:
109          break;
110        case 37:
111          break;
112        case 38:
113          break;
114        case 39:
115          break;
116        case 40:
117          switch (1) {
118            case 1:
119              break;
120            case 2:
121              break;
122            default:
123              throw Error('Bad overload');
124          }
125          break;
126        case 41:
127          break;
128        case 42:
129          break;
130        case 43:
131          break;
132        case 44:
133          break;
134        case 45:
135          break;
136        case 46:
137          break;
138        case 47:
139          break;
140        case 48:
141          break;
142        case 49:
143          break;
144        case 50:
145          break;
146        case 51:
147          break;
148        case 52:
149          break;
150        case 53:
151          break;
152        case 54:
153          break;
154        case 55:
155          break;
156        case 56:
157          break;
158        case 57:
159          break;
160        case 58:
161          break;
162        case 59:
163          break;
164        case 60:
165          switch (1) {
166            case 1:
167              break;
168            case 2:
169              break;
170            default:
171              throw Error('Bad overload');
172          }
173          break;
174        case 61:
175          break;
176        case 62:
177          break;
178        case 63:
179          break;
180        case 64:
181          break;
182        case 65:
183          break;
184        case 66:
185          break;
186        case 67:
187          break;
188        case 68:
189          break;
190        case 69:
191          break;
192        case 70:
193          break;
194        case 71:
195          break;
196        case 72:
197          break;
198        case 73:
199          break;
200        case 74:
201          break;
202        case 75:
203          break;
204        case 76:
205          break;
206        case 77:
207          break;
208        case 78:
209          break;
210        case 79:
211          break;
212        case 80:
213          switch (1) {
214            case 1:
215              break;
216            case 2:
217              break;
218            default:
219              throw Error('Bad overload');
220          }
221          break;
222        case 81:
223          break;
224        case 82:
225          break;
226        case 83:
227          break;
228        case 84:
229          break;
230        case 85:
231          break;
232        case 86:
233          break;
234        case 87:
235          break;
236        case 88:
237          break;
238        case 89:
239          break;
240        case 90:
241          break;
242        case 91:
243          break;
244        case 92:
245          break;
246        case 93:
247          break;
248        case 94:
249          break;
250        case 95:
251          break;
252        case 96:
253          break;
254        case 97:
255          break;
256        case 98:
257          break;
258        case 99:
259          break;
260        case 100:
261          switch (1) {
262            case 1:
263              break;
264            case 2:
265              break;
266            default:
267              throw Error('Bad overload');
268          }
269          break;
270        case 101:
271          break;
272        case 102:
273          break;
274        case 103:
275          break;
276        case 104:
277          break;
278        case 105:
279          break;
280        case 106:
281          break;
282        case 107:
283          break;
284        case 108:
285          break;
286        case 109:
287          break;
288        case 110:
289          break;
290        case 111:
291          break;
292        case 112:
293          break;
294        case 113:
295          break;
296        case 114:
297          break;
298        case 115:
299          break;
300        case 116:
301          break;
302        case 117:
303          break;
304        case 118:
305          break;
306        case 119:
307          break;
308        case 120:
309          switch (1) {
310            case 1:
311              break;
312            case 2:
313              break;
314            default:
315              throw Error('Bad overload');
316          }
317          break;
318        case 121:
319          break;
320        case 122:
321          break;
322        case 123:
323          break;
324        case 124:
325          break;
326        case 125:
327          break;
328        case 126:
329          break;
330        case 127:
331          break;
332        case 128:
333          break;
334        case 129:
335          break;
336        case 130:
337          break;
338        case 131:
339          break;
340        case 132:
341          break;
342        case 133:
343          break;
344        case 134:
345          break;
346        case 135:
347          break;
348        case 136:
349          break;
350        case 137:
351          break;
352        case 138:
353          break;
354        case 139:
355          break;
356        case 140:
357          switch (1) {
358            case 1:
359              break;
360            case 2:
361              break;
362            default:
363              throw Error('Bad overload');
364          }
365          break;
366        case 141:
367          break;
368        case 142:
369          break;
370        case 143:
371          break;
372        case 144:
373          break;
374        case 145:
375          break;
376        case 146:
377          break;
378        case 147:
379          break;
380        case 148:
381          break;
382        case 149:
383          break;
384        case 150:
385          break;
386        case 151:
387          break;
388        case 152:
389          break;
390        case 153:
391          break;
392        case 154:
393          break;
394        case 155:
395          break;
396        case 156:
397          break;
398        case 157:
399          break;
400        case 158:
401          break;
402        case 159:
403          break;
404        case 160:
405          switch (1) {
406            case 1:
407              break;
408            case 2:
409              break;
410            default:
411              throw Error('Bad overload');
412          }
413          break;
414        case 161:
415          break;
416        case 162:
417          break;
418        case 163:
419          break;
420        case 164:
421          break;
422        case 165:
423          break;
424        case 166:
425          break;
426        case 167:
427          break;
428        case 168:
429          break;
430        case 169:
431          break;
432        case 170:
433          break;
434        case 171:
435          break;
436        case 172:
437          break;
438        case 173:
439          break;
440        case 174:
441          break;
442        case 175:
443          break;
444        case 176:
445          break;
446        case 177:
447          break;
448        case 178:
449          break;
450        case 179:
451          break;
452        case 180:
453          switch (1) {
454            case 1:
455              break;
456            case 2:
457              break;
458            default:
459              throw Error('Bad overload');
460          }
461          break;
462        case 181:
463          break;
464        case 182:
465          break;
466        case 183:
467          break;
468        case 184:
469          break;
470        case 185:
471          break;
472        case 186:
473          break;
474        case 187:
475          break;
476        case 188:
477          break;
478        case 189:
479          break;
480        case 190:
481          break;
482        case 191:
483          break;
484        case 192:
485          break;
486        case 193:
487          break;
488        case 194:
489          break;
490        case 195:
491          break;
492        case 196:
493          break;
494        case 197:
495          break;
496        case 198:
497          break;
498        case 199:
499          break;
500        case 200:
501          switch (1) {
502            case 1:
503              break;
504            case 2:
505              break;
506            default:
507              throw Error('Bad overload');
508          }
509          break;
510        case 201:
511          break;
512        case 202:
513          break;
514        case 203:
515          break;
516        case 204:
517          break;
518        case 205:
519          break;
520        case 206:
521          break;
522        case 207:
523          break;
524        case 208:
525          break;
526        case 209:
527          break;
528        case 210:
529          break;
530        case 211:
531          break;
532        case 212:
533          break;
534        case 213:
535          break;
536        case 214:
537          break;
538        case 215:
539          break;
540        case 216:
541          break;
542        case 217:
543          break;
544        case 218:
545          break;
546        case 219:
547          break;
548        case 220:
549          switch (1) {
550            case 1:
551              break;
552            case 2:
553              break;
554            default:
555              throw Error('Bad overload');
556          }
557          break;
558        case 221:
559          break;
560        case 222:
561          break;
562        case 223:
563          break;
564        case 224:
565          break;
566        case 225:
567          break;
568        case 226:
569          break;
570        case 227:
571          break;
572        case 228:
573          break;
574        case 229:
575          break;
576        case 230:
577          break;
578        case 231:
579          break;
580        case 232:
581          break;
582        case 233:
583          break;
584        case 234:
585          break;
586        case 235:
587          break;
588        case 236:
589          break;
590        case 237:
591          break;
592        case 238:
593          break;
594        case 239:
595          break;
596        case 240:
597          switch (1) {
598            case 1:
599              break;
600            case 2:
601              break;
602            default:
603              throw Error('Bad overload');
604          }
605          break;
606        case 241:
607          break;
608        case 242:
609          break;
610        case 243:
611          break;
612        case 244:
613          break;
614        case 245:
615          break;
616        case 246:
617          break;
618        case 247:
619          break;
620        case 248:
621          break;
622        case 249:
623          break;
624        case 250:
625          break;
626        case 251:
627          break;
628        case 252:
629          break;
630        case 253:
631          break;
632        case 254:
633          break;
634        case 255:
635          break;
636        case 256:
637          break;
638        case 257:
639          break;
640        case 258:
641          break;
642        case 259:
643          break;
644        case 260:
645          switch (1) {
646            case 1:
647              break;
648            case 2:
649              break;
650            default:
651              throw Error('Bad overload');
652          }
653          break;
654        case 261:
655          break;
656        case 262:
657          break;
658        case 263:
659          break;
660        case 264:
661          break;
662        case 265:
663          break;
664        case 266:
665          break;
666        case 267:
667          break;
668        case 268:
669          break;
670        case 269:
671          break;
672        case 270:
673          break;
674        case 271:
675          break;
676        case 272:
677          break;
678        case 273:
679          break;
680        case 274:
681          break;
682        case 275:
683          break;
684        case 276:
685          break;
686        case 277:
687          break;
688        case 278:
689          break;
690        case 279:
691          break;
692        case 280:
693          switch (1) {
694            case 1:
695              break;
696            case 2:
697              break;
698            default:
699              throw Error('Bad overload');
700          }
701          break;
702        case 281:
703          break;
704        case 282:
705          break;
706        case 283:
707          break;
708        case 284:
709          break;
710        case 285:
711          break;
712        case 286:
713          break;
714        case 287:
715          break;
716        case 288:
717          break;
718        case 289:
719          break;
720        case 290:
721          break;
722        case 291:
723          break;
724        case 292:
725          break;
726        case 293:
727          break;
728        case 294:
729          break;
730        case 295:
731          break;
732        case 296:
733          break;
734        case 297:
735          break;
736        case 298:
737          break;
738        case 299:
739          break;
740        case 300:
741          switch (1) {
742            case 1:
743              break;
744            case 2:
745              break;
746            default:
747              throw Error('Bad overload');
748          }
749          break;
750        case 301:
751          break;
752        case 302:
753          break;
754        case 303:
755          break;
756        case 304:
757          break;
758        case 305:
759          break;
760        case 306:
761          break;
762        case 307:
763          break;
764        case 308:
765          break;
766        case 309:
767          break;
768        case 310:
769          break;
770        case 311:
771          break;
772        case 312:
773          break;
774        case 313:
775          break;
776        case 314:
777          break;
778        case 315:
779          break;
780        case 316:
781          break;
782        case 317:
783          break;
784        case 318:
785          break;
786        case 319:
787          break;
788        case 320:
789          switch (1) {
790            case 1:
791              break;
792            case 2:
793              break;
794            default:
795              throw Error('Bad overload');
796          }
797          break;
798        case 321:
799          break;
800        case 322:
801          break;
802        case 323:
803          break;
804        case 324:
805          break;
806        case 325:
807          break;
808        case 326:
809          break;
810        case 327:
811          break;
812        case 328:
813          break;
814        case 329:
815          break;
816        case 330:
817          break;
818        case 331:
819          break;
820        case 332:
821          break;
822        case 333:
823          break;
824        case 334:
825          break;
826        case 335:
827          break;
828        case 336:
829          break;
830        case 337:
831          break;
832        case 338:
833          break;
834        case 339:
835          break;
836        case 340:
837          switch (1) {
838            case 1:
839              break;
840            case 2:
841              break;
842            default:
843              throw Error('Bad overload');
844          }
845          break;
846        case 341:
847          break;
848        case 342:
849          break;
850        case 343:
851          break;
852        case 344:
853          break;
854        case 345:
855          break;
856        case 346:
857          break;
858        case 347:
859          break;
860        case 348:
861          break;
862        case 349:
863          break;
864        case 350:
865          break;
866        case 351:
867          break;
868        case 352:
869          break;
870        case 353:
871          break;
872        case 354:
873          break;
874        case 355:
875          break;
876        case 356:
877          break;
878        case 357:
879          break;
880        case 358:
881          break;
882        case 359:
883          break;
884        case 360:
885          switch (1) {
886            case 1:
887              break;
888            case 2:
889              break;
890            default:
891              throw Error('Bad overload');
892          }
893          break;
894        case 361:
895          break;
896        case 362:
897          break;
898        case 363:
899          break;
900        case 364:
901          break;
902        case 365:
903          break;
904        case 366:
905          break;
906        case 367:
907          break;
908        case 368:
909          break;
910        case 369:
911          break;
912        case 370:
913          break;
914        case 371:
915          break;
916        case 372:
917          break;
918        case 373:
919          break;
920        case 374:
921          break;
922        case 375:
923          break;
924        case 376:
925          break;
926        case 377:
927          break;
928        case 378:
929          break;
930        case 379:
931          break;
932        case 380:
933          switch (1) {
934            case 1:
935              break;
936            case 2:
937              break;
938            default:
939              throw Error('Bad overload');
940          }
941          break;
942        case 381:
943          break;
944        case 382:
945          break;
946        case 383:
947          break;
948        case 384:
949          break;
950        case 385:
951          break;
952        case 386:
953          break;
954        case 387:
955          break;
956        case 388:
957          break;
958        case 389:
959          break;
960        case 390:
961          break;
962        case 391:
963          break;
964        case 392:
965          break;
966        case 393:
967          break;
968        case 394:
969          break;
970        case 395:
971          break;
972        case 396:
973          break;
974        case 397:
975          break;
976        case 398:
977          break;
978        case 399:
979          break;
980        case 400:
981          switch (1) {
982            case 1:
983              break;
984            case 2:
985              break;
986            default:
987              throw Error('Bad overload');
988          }
989          break;
990        case 401:
991          break;
992        case 402:
993          break;
994        case 403:
995          break;
996        case 404:
997          break;
998        case 405:
999          break;
1000        case 406:
1001          break;
1002        case 407:
1003          break;
1004        case 408:
1005          break;
1006        case 409:
1007          break;
1008        case 410:
1009          break;
1010        case 411:
1011          break;
1012        case 412:
1013          break;
1014        case 413:
1015          break;
1016        case 414:
1017          break;
1018        case 415:
1019          break;
1020        case 416:
1021          break;
1022        case 417:
1023          break;
1024        case 418:
1025          break;
1026        case 419:
1027          break;
1028        case 420:
1029          switch (1) {
1030            case 1:
1031              break;
1032            case 2:
1033              break;
1034            default:
1035              throw Error('Bad overload');
1036          }
1037          break;
1038        case 421:
1039          break;
1040        case 422:
1041          break;
1042        case 423:
1043          break;
1044        case 424:
1045          break;
1046        case 425:
1047          break;
1048        case 426:
1049          break;
1050        case 427:
1051          break;
1052        case 428:
1053          break;
1054        case 429:
1055          break;
1056        case 430:
1057          break;
1058        case 431:
1059          break;
1060        case 432:
1061          break;
1062        case 433:
1063          break;
1064        case 434:
1065          break;
1066        case 435:
1067          break;
1068        case 436:
1069          break;
1070        case 437:
1071          break;
1072        case 438:
1073          break;
1074        case 439:
1075          break;
1076        case 440:
1077          switch (1) {
1078            case 1:
1079              break;
1080            case 2:
1081              break;
1082            default:
1083              throw Error('Bad overload');
1084          }
1085          break;
1086        case 441:
1087          break;
1088        case 442:
1089          break;
1090        case 443:
1091          break;
1092        case 444:
1093          break;
1094        case 445:
1095          break;
1096        case 446:
1097          break;
1098        case 447:
1099          break;
1100        case 448:
1101          break;
1102        case 449:
1103          break;
1104        case 450:
1105          break;
1106        case 451:
1107          break;
1108        case 452:
1109          break;
1110        case 453:
1111          break;
1112        case 454:
1113          break;
1114        case 455:
1115          break;
1116        case 456:
1117          break;
1118        case 457:
1119          break;
1120        case 458:
1121          break;
1122        case 459:
1123          break;
1124        case 460:
1125          switch (1) {
1126            case 1:
1127              break;
1128            case 2:
1129              break;
1130            default:
1131              throw Error('Bad overload');
1132          }
1133          break;
1134        case 461:
1135          break;
1136        case 462:
1137          break;
1138        case 463:
1139          break;
1140        case 464:
1141          break;
1142        case 465:
1143          break;
1144        case 466:
1145          break;
1146        case 467:
1147          break;
1148        case 468:
1149          break;
1150        case 469:
1151          break;
1152        case 470:
1153          break;
1154        case 471:
1155          break;
1156        case 472:
1157          break;
1158        case 473:
1159          break;
1160        case 474:
1161          break;
1162        case 475:
1163          break;
1164        case 476:
1165          break;
1166        case 477:
1167          break;
1168        case 478:
1169          break;
1170        case 479:
1171          break;
1172        case 480:
1173          switch (1) {
1174            case 1:
1175              break;
1176            case 2:
1177              break;
1178            default:
1179              throw Error('Bad overload');
1180          }
1181          break;
1182        case 481:
1183          break;
1184        case 482:
1185          break;
1186        case 483:
1187          break;
1188        case 484:
1189          break;
1190        case 485:
1191          break;
1192        case 486:
1193          break;
1194        case 487:
1195          break;
1196        case 488:
1197          break;
1198        case 489:
1199          break;
1200        case 490:
1201          break;
1202        case 491:
1203          break;
1204        case 492:
1205          break;
1206        case 493:
1207          break;
1208        case 494:
1209          break;
1210        case 495:
1211          break;
1212        case 496:
1213          break;
1214        case 497:
1215          break;
1216        case 498:
1217          break;
1218        case 499:
1219          break;
1220        default:
1221          break;
1222      }
1223      assertTrue(res)
1224}