mcs/tests/test-49.cs

   1 //
   2 // This tests excercises a number of switch things:
   3 //
   4 // Code to test for multiple-labels is different that
   5 // code for a single label.
   6 //
   7 // Code for switching on strings is different from the integer
   8 // code.
   9 //
  10 // nulls (for strings) need to be handled specially since ceq will
  11 // throw an exception if there.
  12 //
  13 // null as a case statement needs to be caught specially
  14 //
  15 using System;
  16
  17 class X {
  18         enum A {
  19                 a = 23333,
  20         }
  21         public const string One = "one";
  22
  23         static int s (byte b)
  24         {
  25                 switch (b){
  26                         case 0: return 255-0;
  27                         case 1: return 255-1;
  28                         case 2: return 255-2;
  29                         case 3: return 255-3;
  30                         case 4: return 255-4;
  31                         case 5: return 255-5;
  32                         case 6: return 255-6;
  33                         case 7: return 255-7;
  34                         case 8: return 255-8;
  35                         case 9: return 255-9;
  36                         case 10: return 255-10;
  37                         case 11: return 255-11;
  38                         case 12: return 255-12;
  39                         case 13: return 255-13;
  40                         case 14: return 255-14;
  41                         case 15: return 255-15;
  42                         case 16: return 255-16;
  43                         case 17: return 255-17;
  44                         case 18: return 255-18;
  45                         case 19: return 255-19;
  46                         case 20: return 255-20;
  47                         case 21: return 255-21;
  48                         case 22: return 255-22;
  49                         case 23: return 255-23;
  50                         case 24: return 255-24;
  51                         case 25: return 255-25;
  52                         case 26: return 255-26;
  53                         case 27: return 255-27;
  54                         case 28: return 255-28;
  55                         case 29: return 255-29;
  56                         case 30: return 255-30;
  57                         case 31: return 255-31;
  58                         case 32: return 255-32;
  59                         case 33: return 255-33;
  60                         case 34: return 255-34;
  61                         case 35: return 255-35;
  62                         case 36: return 255-36;
  63                         case 37: return 255-37;
  64                         case 38: return 255-38;
  65                         case 39: return 255-39;
  66                         case 40: return 255-40;
  67                         case 41: return 255-41;
  68                         case 42: return 255-42;
  69                         case 43: return 255-43;
  70                         case 44: return 255-44;
  71                         case 45: return 255-45;
  72                         case 46: return 255-46;
  73                         case 47: return 255-47;
  74                         case 48: return 255-48;
  75                         case 49: return 255-49;
  76                         case 50: return 255-50;
  77                         case 51: return 255-51;
  78                         case 52: return 255-52;
  79                         case 53: return 255-53;
  80                         case 54: return 255-54;
  81                         case 55: return 255-55;
  82                         case 56: return 255-56;
  83                         case 57: return 255-57;
  84                         case 58: return 255-58;
  85                         case 59: return 255-59;
  86                         case 60: return 255-60;
  87                         case 61: return 255-61;
  88                         case 62: return 255-62;
  89                         case 63: return 255-63;
  90                         case 64: return 255-64;
  91                         case 65: return 255-65;
  92                         case 66: return 255-66;
  93                         case 67: return 255-67;
  94                         case 68: return 255-68;
  95                         case 69: return 255-69;
  96                         case 70: return 255-70;
  97                         case 71: return 255-71;
  98                         case 72: return 255-72;
  99                         case 73: return 255-73;
 100                         case 74: return 255-74;
 101                         case 75: return 255-75;
 102                         case 76: return 255-76;
 103                         case 77: return 255-77;
 104                         case 78: return 255-78;
 105                         case 79: return 255-79;
 106                         case 80: return 255-80;
 107                         case 81: return 255-81;
 108                         case 82: return 255-82;
 109                         case 83: return 255-83;
 110                         case 84: return 255-84;
 111                         case 85: return 255-85;
 112                         case 86: return 255-86;
 113                         case 87: return 255-87;
 114                         case 88: return 255-88;
 115                         case 89: return 255-89;
 116                         case 90: return 255-90;
 117                         case 91: return 255-91;
 118                         case 92: return 255-92;
 119                         case 93: return 255-93;
 120                         case 94: return 255-94;
 121                         case 95: return 255-95;
 122                         case 96: return 255-96;
 123                         case 97: return 255-97;
 124                         case 98: return 255-98;
 125                         case 99: return 255-99;
 126                         case 100: return 255-100;
 127                         case 101: return 255-101;
 128                         case 102: return 255-102;
 129                         case 103: return 255-103;
 130                         case 104: return 255-104;
 131                         case 105: return 255-105;
 132                         case 106: return 255-106;
 133                         case 107: return 255-107;
 134                         case 108: return 255-108;
 135                         case 109: return 255-109;
 136                         case 110: return 255-110;
 137                         case 111: return 255-111;
 138                         case 112: return 255-112;
 139                         case 113: return 255-113;
 140                         case 114: return 255-114;
 141                         case 115: return 255-115;
 142                         case 116: return 255-116;
 143                         case 117: return 255-117;
 144                         case 118: return 255-118;
 145                         case 119: return 255-119;
 146                         case 120: return 255-120;
 147                         case 121: return 255-121;
 148                         case 122: return 255-122;
 149                         case 123: return 255-123;
 150                         case 124: return 255-124;
 151                         case 125: return 255-125;
 152                         case 126: return 255-126;
 153                         case 127: return 255-127;
 154                         case 128: return 255-128;
 155                         case 129: return 255-129;
 156                         case 130: return 255-130;
 157                         case 131: return 255-131;
 158                         case 132: return 255-132;
 159                         case 133: return 255-133;
 160                         case 134: return 255-134;
 161                         case 135: return 255-135;
 162                         case 136: return 255-136;
 163                         case 137: return 255-137;
 164                         case 138: return 255-138;
 165                         case 139: return 255-139;
 166                         case 140: return 255-140;
 167                         case 141: return 255-141;
 168                         case 142: return 255-142;
 169                         case 143: return 255-143;
 170                         case 144: return 255-144;
 171                         case 145: return 255-145;
 172                         case 146: return 255-146;
 173                         case 147: return 255-147;
 174                         case 148: return 255-148;
 175                         case 149: return 255-149;
 176                         case 150: return 255-150;
 177                         case 151: return 255-151;
 178                         case 152: return 255-152;
 179                         case 153: return 255-153;
 180                         case 154: return 255-154;
 181                         case 155: return 255-155;
 182                         case 156: return 255-156;
 183                         case 157: return 255-157;
 184                         case 158: return 255-158;
 185                         case 159: return 255-159;
 186                         case 160: return 255-160;
 187                         case 161: return 255-161;
 188                         case 162: return 255-162;
 189                         case 163: return 255-163;
 190                         case 164: return 255-164;
 191                         case 165: return 255-165;
 192                         case 166: return 255-166;
 193                         case 167: return 255-167;
 194                         case 168: return 255-168;
 195                         case 169: return 255-169;
 196                         case 170: return 255-170;
 197                         case 171: return 255-171;
 198                         case 172: return 255-172;
 199                         case 173: return 255-173;
 200                         case 174: return 255-174;
 201                         case 175: return 255-175;
 202                         case 176: return 255-176;
 203                         case 177: return 255-177;
 204                         case 178: return 255-178;
 205                         case 179: return 255-179;
 206                         case 180: return 255-180;
 207                         case 181: return 255-181;
 208                         case 182: return 255-182;
 209                         case 183: return 255-183;
 210                         case 184: return 255-184;
 211                         case 185: return 255-185;
 212                         case 186: return 255-186;
 213                         case 187: return 255-187;
 214                         case 188: return 255-188;
 215                         case 189: return 255-189;
 216                         case 190: return 255-190;
 217                         case 191: return 255-191;
 218                         case 192: return 255-192;
 219                         case 193: return 255-193;
 220                         case 194: return 255-194;
 221                         case 195: return 255-195;
 222                         case 196: return 255-196;
 223                         case 197: return 255-197;
 224                         case 198: return 255-198;
 225                         case 199: return 255-199;
 226                         case 200: return 255-200;
 227                         case 201: return 255-201;
 228                         case 202: return 255-202;
 229                         case 203: return 255-203;
 230                         case 204: return 255-204;
 231                         case 205: return 255-205;
 232                         case 206: return 255-206;
 233                         case 207: return 255-207;
 234                         case 208: return 255-208;
 235                         case 209: return 255-209;
 236                         case 210: return 255-210;
 237                         case 211: return 255-211;
 238                         case 212: return 255-212;
 239                         case 213: return 255-213;
 240                         case 214: return 255-214;
 241                         case 215: return 255-215;
 242                         case 216: return 255-216;
 243                         case 217: return 255-217;
 244                         case 218: return 255-218;
 245                         case 219: return 255-219;
 246                         case 220: return 255-220;
 247                         case 221: return 255-221;
 248                         case 222: return 255-222;
 249                         case 223: return 255-223;
 250                         case 224: return 255-224;
 251                         case 225: return 255-225;
 252                         case 226: return 255-226;
 253                         case 227: return 255-227;
 254                         case 228: return 255-228;
 255                         case 229: return 255-229;
 256                         case 230: return 255-230;
 257                         case 231: return 255-231;
 258                         case 232: return 255-232;
 259                         case 233: return 255-233;
 260                         case 234: return 255-234;
 261                         case 235: return 255-235;
 262                         case 236: return 255-236;
 263                         case 237: return 255-237;
 264                         case 238: return 255-238;
 265                         case 239: return 255-239;
 266                         case 240: return 255-240;
 267                         case 241: return 255-241;
 268                         case 242: return 255-242;
 269                         case 243: return 255-243;
 270                         case 244: return 255-244;
 271                         case 245: return 255-245;
 272                         case 246: return 255-246;
 273                         case 247: return 255-247;
 274                         case 248: return 255-248;
 275                         case 249: return 255-249;
 276                         case 250: return 255-250;
 277                         case 251: return 255-251;
 278                         case 252: return 255-252;
 279                         case 253: return 255-253;
 280                         case 254: return 255-254;
 281                         case 255: return 255-255;
 282                 }
 283
 284                 return -1;
 285         }
 286
 287         static int test (int v)
 288         {
 289                 Console.WriteLine ("value: " + v);
 290                 switch (v){
 291                 case 1:
 292                 case 2:
 293                         return 1;
 294
 295                 case 3:
 296                         return 3;
 297
 298                 case 4:
 299                         return 5;
 300
 301                 default:
 302                         Console.WriteLine ("default");
 303                         return 6;
 304                 }
 305
 306                 return 7;
 307         }
 308
 309         static int tests (string s)
 310         {
 311                 switch (s){
 312                 case "one":
 313                 case "two":
 314                         return 1;
 315                 case "three":
 316                         return 3;
 317                 case "four":
 318                         return 5;
 319                 case null:
 320                         return 9;
 321                 default:
 322                         return 6;
 323                 }
 324
 325                 return 1;
 326         }
 327
 328         static int testn (string s)
 329         {
 330                 switch (s){
 331                 case "one":
 332                         return 1;
 333
 334                 default:
 335                         return 0;
 336                 }
 337                 return -1;
 338         }
 339
 340         static int testm (string s)
 341         {
 342                 switch (s){
 343                 case "one":
 344                         return 1;
 345                 }
 346                 return 100;
 347         }
 348
 349         static int testo (string s)
 350         {
 351                 switch (s){
 352                 case "one":
 353                         return 1;
 354                 case null:
 355                         return 100;
 356                 }
 357                 return 2;
 358         }
 359
 360         static int testp (string s)
 361         {
 362                 switch (s){
 363                 case "one":
 364                 case null:
 365                 case "two":
 366                         return 1;
 367                 case "three":
 368                         return 3;
 369                 }
 370                 return 4;
 371         }
 372
 373         static int test_def (string s)
 374         {
 375                 switch (s){
 376                 case "one":
 377                         goto default;
 378                 case "two":
 379                         return 1;
 380                 case "three":
 381                         return 2;
 382                 default:
 383                         return 3;
 384                 }
 385                 return 4;
 386         }
 387
 388         static int test_coverage (int x)
 389         {
 390                 switch (x){
 391                 case 0:
 392                         return 1;
 393                 default:
 394                         return 10;
 395                 }
 396         }
 397
 398         static int test_goto (int a)
 399         {
 400                 switch (a){
 401                 case 0:
 402                         goto case 2;
 403                 case 1:
 404                         return 10;
 405                 case 2:
 406                         return 20;
 407                 default:
 408                         return 100;
 409                 }
 410         }
 411
 412         static int test_memberaccess (string s)
 413         {
 414                 switch (s){
 415                 case X.One:
 416                         return 3;
 417                 default:
 418                         return 4;
 419                 }
 420         }
 421
 422         static int test_string_multiple_targets (string s)
 423         {
 424                 switch (s){
 425                 case "A":
 426                         return 1;
 427                 case "B":
 428                         return 2;
 429                 case "C":
 430                 case "D":
 431                         return 3;
 432                 }
 433                 return 0;
 434         }
 435
 436         enum My : byte {
 437                 A
 438         }
 439
 440         static int test_casts (int n)
 441         {
 442                 switch (n) {
 443                         case (int) (char) (int) My.A:
 444                                 return 1;
 445
 446                         default:
 447                                 return 2;
 448                 }
 449         }
 450
 451         public enum TestEnum : long {
 452                 a, b, c
 453         }
 454
 455         public static int testSwitchEnumLong (TestEnum c)
 456         {
 457
 458                 switch (c) {
 459                 case TestEnum.a:
 460                         return 10;
 461
 462                 case TestEnum.b:
 463                         return 20;
 464
 465                 case TestEnum.c:
 466                         return 30;
 467
 468                 default:
 469                         return 40;
 470                 }
 471
 472         }
 473
 474         static int test_long_enum_switch ()
 475         {
 476                 if (testSwitchEnumLong (TestEnum.a) != 10)
 477                         return 1;
 478                 if (testSwitchEnumLong (TestEnum.b) != 20)
 479                         return 2;
 480                 if (testSwitchEnumLong (TestEnum.c) != 30)
 481                         return 3;
 482                 if (testSwitchEnumLong ((TestEnum)5) != 40)
 483                         return 4;
 484                 return 0;
 485         }
 486
 487         static int Main ()
 488         {
 489                 byte b;
 490
 491                 for (b = 0; b < 255; b++){
 492                         if (s (b) != 255 - b){
 493                                 Console.WriteLine ("Failed with: " + b + " [" + s (b) + "]");
 494                                 return 1;
 495                         }
 496                 }
 497
 498                 Console.WriteLine ("Batch 2");
 499                 if (test (1) != 1)
 500                         return 1;
 501                 if (test (2) != 1)
 502                         return 2;
 503                 if (test (3) != 3)
 504                         return 3;
 505                 if (test (4) != 5)
 506                         return 4;
 507                 if (test (100) != 6)
 508                         return 5;
 509
 510                 if (tests ("one") != 1)
 511                         return 6;
 512                 if (tests ("two") != 1)
 513                         return 7;
 514                 if (tests ("three") != 3)
 515                         return 8;
 516                 if (tests ("four") != 5)
 517                         return 9;
 518                 if (tests (null) != 9)
 519                         return 10;
 520                 if (tests ("blah") != 6)
 521                         return 11;
 522
 523                 if (testn ("one") != 1)
 524                         return 12;
 525                 if (testn ("hello") != 0)
 526                         return 13;
 527                 if (testn (null) != 0)
 528                         return 14;
 529
 530                 if (testm ("one") != 1)
 531                         return 15;
 532                 if (testm ("two") != 100)
 533                         return 16;
 534                 if (testm (null) != 100)
 535                         return 17;
 536
 537                 if (testo ("one") != 1)
 538                         return 18;
 539                 if (testo ("two") != 2)
 540                         return 19;
 541                 if (testo (null) != 100)
 542                         return 20;
 543
 544                 if (testp ("one") != 1)
 545                         return 21;
 546                 if (testp (null) != 1)
 547                         return 22;
 548                 if (testp ("two") != 1)
 549                         return 23;
 550                 if (testp ("three") != 3)
 551                         return 24;
 552                 if (testp ("blah") != 4)
 553                         return 25;
 554
 555                 if (test_def ("one") != 3)
 556                         return 26;
 557                 if (test_def ("two") != 1)
 558                         return 27;
 559                 if (test_def ("three") != 2)
 560                         return 28;
 561                 if (test_def (null) != 3)
 562                         return 29;
 563
 564                 if (test_coverage (100) != 10)
 565                         return 30;
 566
 567                 if (test_goto (0) != 20)
 568                         return 31;
 569                 if (test_goto (1) != 10)
 570                         return 32;
 571                 if (test_goto (2) != 20)
 572                         return 33;
 573                 if (test_goto (200) != 100)
 574                         return 34;
 575
 576                 if (test_memberaccess ("one") != 3)
 577                         return 35;
 578
 579                 if (test_string_multiple_targets ("A") != 1)
 580                         return 36;
 581                 if (test_string_multiple_targets ("B") != 2)
 582                         return 37;
 583                 if (test_string_multiple_targets ("C") != 3)
 584                         return 38;
 585                 if (test_string_multiple_targets ("D") != 3)
 586                         return 39;
 587                 if (test_string_multiple_targets ("E") != 0)
 588                         return 40;
 589
 590                 if (test_casts (0) != 1)
 591                         return 41;
 592
 593                 if (test_long_enum_switch () != 0)
 594                         return 42;
 595
 596                 Console.WriteLine ("All tests pass");
 597                 return 0;
 598         }
 599 }