| // PERMUTE_ARGS: -w |
| |
| extern(C) int printf(const char*, ...); |
| |
| int testswitch(string h) |
| { |
| int x; |
| |
| switch (h) |
| { |
| case "abc": |
| printf("abc\n"); |
| x = 4; |
| break; |
| case "foo": |
| printf("foo\n"); |
| x = 1; |
| break; |
| case "bar": |
| printf("bar\n"); |
| x = 2; |
| break; |
| default: |
| printf("default\n"); |
| x = 3; |
| break; |
| } |
| return x; |
| } |
| |
| void test1() |
| { |
| int i; |
| |
| i = testswitch("foo"); |
| printf("i = %d\n", i); |
| assert(i == 1); |
| assert(testswitch("abc") == 4); |
| assert(testswitch("bar") == 2); |
| assert(testswitch("hello") == 3); |
| printf("Success\n"); |
| } |
| |
| /*****************************************/ |
| |
| void test2() |
| { |
| int i; |
| |
| switch (5) |
| { |
| case 3,4,5,6: |
| i = 20; |
| break; |
| |
| case 7: |
| default: |
| assert(0); |
| } |
| assert(i == 20); |
| } |
| |
| |
| /*****************************************/ |
| |
| void test3() |
| { |
| int i; |
| |
| switch (5) |
| { |
| case 7: |
| i = 6; |
| goto default; |
| default: |
| i = 8; |
| break; |
| |
| case 3,4,5,6: |
| i = 20; |
| goto default; |
| } |
| assert(i == 8); |
| } |
| |
| |
| /*****************************************/ |
| |
| void test4() |
| { int i; |
| |
| switch (5) |
| { |
| case 3,4,5,6: |
| i = 20; |
| goto default; |
| |
| case 7: |
| i = 6; |
| goto default; |
| |
| default: |
| i = 8; |
| break; |
| } |
| assert(i == 8); |
| } |
| |
| |
| /*****************************************/ |
| |
| void test5() |
| { int i; |
| |
| switch (5) |
| { |
| case 7: |
| i = 6; |
| goto case; |
| default: |
| i = 8; |
| break; |
| |
| case 3,4,5,6: |
| i = 20; |
| break; |
| } |
| assert(i == 20); |
| } |
| |
| |
| /*****************************************/ |
| |
| void test6() |
| { |
| int i; |
| |
| switch (5) |
| { |
| case 7: |
| i = 6; |
| goto case 4; |
| default: |
| i = 8; |
| break; |
| |
| case 3,4,5,6: |
| i = 20; |
| break; |
| } |
| assert(i == 20); |
| } |
| |
| |
| /*****************************************/ |
| |
| void test7() |
| { |
| int i; |
| |
| switch (5) |
| { |
| case 3,4,5,6: |
| i = 20; |
| break; |
| |
| case 7: |
| i = 6; |
| goto case 4; |
| default: |
| i = 8; |
| break; |
| } |
| assert(i == 20); |
| } |
| |
| |
| /*****************************************/ |
| |
| void test8() |
| { |
| dstring str = "xyz"; |
| switch (str) |
| { |
| case "xyz": |
| printf("correct\n"); |
| return; |
| |
| case "abc": |
| break; |
| |
| default: |
| assert(0); |
| } |
| assert(0); |
| } |
| |
| /*****************************************/ |
| |
| void test9() |
| { |
| int i = 1; |
| |
| switch(i) |
| { |
| case 2: |
| return; |
| case 1: |
| switch(i) |
| { |
| case 1: |
| goto case 2; |
| default: |
| assert(0); |
| } |
| default: |
| assert(0); |
| } |
| assert(0); |
| } |
| |
| /*****************************************/ |
| |
| void test10() |
| { |
| int id1 = 0; |
| int id; |
| switch (id1) |
| { |
| case 0: ++id; goto case; |
| case 7: ++id; goto case; |
| case 6: ++id; goto case; |
| case 5: ++id; goto case; |
| case 4: ++id; goto case; |
| case 3: ++id; goto case; |
| case 2: ++id; goto case; |
| case 1: ++id; goto default; |
| default: |
| break; |
| } |
| assert(id == 8); |
| } |
| |
| /*****************************************/ |
| |
| void test11() |
| { |
| long foo = 4; |
| switch (foo) |
| { |
| case 2: assert (false); |
| case 3: break; |
| case 4: break; |
| case 5: break; |
| default: assert(0); |
| } |
| } |
| |
| /*****************************************/ |
| |
| void test12() |
| { |
| switch("#!") |
| { |
| case "#!": printf("----Found #!\n"); break; |
| case "\xFF\xFE"c: break; |
| default: |
| assert(0); |
| } |
| } |
| |
| /*****************************************/ |
| |
| void test13() |
| { |
| switch("#!") |
| { |
| case "#!": printf("----Found #!\n"); break; |
| case "#\xFE"c: break; |
| default: |
| assert(0); |
| } |
| } |
| |
| /*****************************************/ |
| |
| void foo14(A...)(int i) |
| { |
| switch (i) |
| { |
| foreach(a; A) |
| { |
| goto case; |
| case a: |
| printf("%d\n", a); |
| } |
| break; |
| default: |
| assert(0); |
| } |
| } |
| |
| void bar14(A...)(int i) |
| { |
| switch (i) |
| { |
| foreach(j, a; A) |
| { |
| goto case; |
| case A[j]: |
| printf("a = %d, A[%d] = %d\n", a, j, A[j]); |
| } |
| break; |
| default: |
| assert(0); |
| } |
| } |
| |
| void test14() |
| { |
| foo14!(1,2,3,4,5)(1); |
| bar14!(1,2,3,4,5)(1); |
| } |
| |
| /*****************************************/ |
| |
| const int X15; |
| immutable int Y15; |
| const int Z15; |
| |
| int foo15(int i) |
| { |
| auto y = 1; |
| switch (i) |
| { |
| case X15: |
| y += 1; |
| goto case; |
| case 3: |
| y += 2; |
| break; |
| case Y15: |
| y += 20; |
| goto case; |
| case Z15: |
| y += 10; |
| break; |
| default: |
| y += 4; |
| break; |
| } |
| printf("y = %d\n", y); |
| return y; |
| } |
| |
| static this() |
| { |
| X15 = 4; |
| Y15 = 4; |
| Z15 = 5; |
| } |
| |
| void test15() |
| { |
| auto i = foo15(3); |
| assert(i == 3); |
| i = foo15(4); |
| assert(i == 4); |
| i = foo15(7); |
| assert(i == 5); |
| i = foo15(5); |
| assert(i == 11); |
| } |
| |
| /*****************************************/ |
| |
| enum E16 |
| { |
| A,B,C |
| } |
| |
| void test16() |
| { |
| E16 e = E16.A; |
| final switch (e) |
| { |
| case E16.A: |
| case E16.B: |
| case E16.C: |
| {} |
| } |
| } |
| |
| /*****************************************/ |
| |
| void test17() |
| { |
| int i = 2; |
| switch (i) |
| { |
| case 1: .. case 3: |
| i = 5; |
| break; |
| default: |
| assert(0); |
| } |
| if (i != 5) |
| assert(0); |
| |
| switch (i) |
| { |
| case 1: .. case 3: |
| i = 4; |
| break; |
| case 5: |
| i = 6; |
| break; |
| default: |
| assert(0); |
| } |
| if (i != 6) |
| assert(0); |
| } |
| |
| /*****************************************/ |
| |
| int test19() |
| { |
| enum foo{ bar } |
| foo x; |
| final switch(x){ case foo.bar: return 0; } |
| } |
| |
| /*****************************************/ |
| |
| void test20() |
| { |
| switch(1) |
| { |
| mixin("case 0:{}"); |
| case 1: |
| case 2: |
| default: |
| } |
| } |
| |
| /*****************************************/ |
| |
| void hang3139(int x) |
| { |
| switch(x) { |
| case -9: .. case -1: |
| default: |
| } |
| } |
| |
| int wrongcode3139(int x) |
| { |
| switch(x) { |
| case -9: .. case 2: return 3; |
| default: |
| return 4; |
| } |
| } |
| |
| static assert(wrongcode3139(-5)==3); |
| |
| // bug 3139 |
| static assert(!is(typeof( |
| (long x) { switch(x) { case long.max: .. case -long.max: |
| default:} return 4; }(3) |
| ))); |
| |
| |
| /*****************************************/ |
| |
| void test7358() |
| { |
| static void test7358a() |
| { |
| enum X { A = 1, B = 2 } |
| |
| auto x = X.A | X.B; |
| |
| final switch(x) |
| { |
| case X.A: |
| case X.B: |
| break; |
| } |
| } |
| |
| bool exception; |
| try |
| test7358a(); |
| catch (Error) |
| exception = true; |
| assert(exception); |
| } |
| |
| /*****************************************/ |
| // 9263 |
| |
| void test9263() |
| { |
| enum Foo { A } |
| |
| Foo f; |
| final switch (f) with(Foo) |
| { |
| case A: |
| return; |
| } |
| } |
| |
| /*****************************************/ |
| |
| int bar21(int i) |
| { |
| switch (i) |
| { |
| // case 1: return 11; |
| case 2: return 12; |
| case 3: return 13; |
| case 4: return 14; |
| case 5: return 15; |
| case 6: return 16; |
| case 7: return 17; |
| case 8: return 18; |
| case 9: return 19; |
| case 10: return 20; |
| default: break; |
| } |
| |
| switch (i) |
| { |
| case 11: return 21; |
| case 12: return 22; |
| case 13: return 23; |
| case 14: return 24; |
| case 15: return 25; |
| case 16: return 26; |
| case 17: return 27; |
| case 18: return 28; |
| case 19: return 29; |
| case 20: return 30; |
| default: return 31; |
| } |
| } |
| |
| void test21() |
| { |
| // int j = bar(12); |
| // printf("j = %d\n", j); |
| |
| for (int i = 2; i < 21; i++) |
| { |
| int j = bar21(i); |
| //printf("j = %d\n", j); |
| assert(j == i + 10); |
| } |
| } |
| |
| /*****************************************/ |
| |
| int bar22(int i) |
| { |
| switch (i) |
| { |
| case 1: return i + 1; |
| case 10: return i + 2; |
| case 20: return i + 3; |
| case 50: return i + 4; |
| case 1000: return i + 5; |
| default: return 28; |
| } |
| } |
| |
| void test22() |
| { |
| assert(bar22(1) == 2); |
| assert(bar22(10) == 12); |
| assert(bar22(20) == 23); |
| assert(bar22(50) == 54); |
| assert(bar22(1000) == 1005); |
| assert(bar22(0) == 28); |
| assert(bar22(5) == 28); |
| assert(bar22(15) == 28); |
| assert(bar22(25) == 28); |
| assert(bar22(58) == 28); |
| assert(bar22(2000) == 28); |
| } |
| |
| /*****************************************/ |
| |
| long bar23(long i) |
| { |
| switch (i) |
| { |
| case 1: return i + 1; |
| case 0x10_0000_0000L: return i + 2; |
| case 0x20_0070_0000L: return i + 3; |
| case 0x50_0000_0000L: return i + 4; |
| case 0x1000_0000_8000L: return i + 5; |
| default: return 28; |
| } |
| } |
| |
| void test23() |
| { |
| assert(bar23(1) == 2); |
| assert(bar23(0x10_0000_0000L) == 0x10_0000_0000L + 2); |
| assert(bar23(0x20_0070_0000L) == 0x20_0070_0000L + 3); |
| assert(bar23(0x50_0000_0000L) == 0x50_0000_0000L + 4); |
| assert(bar23(0x1000_0000_8000L) == 0x1000_0000_8000L + 5); |
| assert(bar23(0) == 28); |
| assert(bar23(58) == 28); |
| assert(bar23(0x10_0000_0000L+1) == 28); |
| assert(bar23(0x20_0070_0000L+5) == 28); |
| assert(bar23(0x50_0000_0000L+25) == 28); |
| assert(bar23(0x1000_0000_8000L+1) == 28); |
| } |
| |
| /*****************************************/ |
| // 14352 |
| |
| int transmogrify14352(int input) |
| { |
| int output = 0; |
| switch (input) |
| { |
| case 0, 1: |
| if (input == 0) |
| goto case; |
| else |
| output++; |
| goto case; |
| case 2: |
| output += 5; |
| goto case; |
| case 3: |
| output += 5; |
| break; |
| case 4, 5, 6: |
| goto default; |
| case 7: |
| case 8: |
| output += 20; |
| break; |
| default: |
| return -1; |
| } |
| return output; |
| } |
| |
| void test14352() |
| { |
| assert(transmogrify14352(0) == 10); |
| } |
| |
| /*****************************************/ |
| // Issue 14587 - DMD 2.067.1 generating crashing binary on OSX |
| |
| struct Card { |
| int value; |
| int suit; |
| } |
| |
| void foo14587(Card card) { |
| switch(card.value) { |
| case 4: case 5: case 6: case 11: |
| break; |
| default: |
| } |
| } |
| |
| void test14587() { |
| auto card = Card(11, 1); |
| foo14587(card); |
| } |
| |
| /*****************************************/ |
| // Issue 15396 - static immutable not recognized as constant within switch statement |
| |
| void test15396() |
| { |
| static immutable Foo = "Foobar"; |
| static const Bar = "BarFoo"; |
| |
| foreach (var; [ "Foobar", "BarFoo" ]) |
| { |
| switch (var) |
| { |
| case Foo: |
| break; |
| case Bar: |
| break; |
| default: |
| assert(0, "test15396 failed"); |
| } |
| } |
| } |
| |
| /*****************************************/ |
| |
| int main() |
| { |
| test1(); |
| test2(); |
| test3(); |
| test4(); |
| test5(); |
| test6(); |
| test7(); |
| test8(); |
| test9(); |
| test10(); |
| test11(); |
| test12(); |
| test13(); |
| test14(); |
| test15(); |
| test16(); |
| test17(); |
| test19(); |
| test20(); |
| test7358(); |
| test9263(); |
| test21(); |
| test22(); |
| test23(); |
| test14352(); |
| test14587(); |
| test15396(); |
| |
| printf("Success\n"); |
| return 0; |
| } |
