739 lines
12 KiB
D
739 lines
12 KiB
D
// 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;
|
|
}
|