| #! blah |
| // RUNNABLE_PHOBOS_TEST |
| static assert(__LINE__ == 3); // fails as __LINE__ is 2 |
| |
| import core.stdc.math : signbit; |
| |
| |
| /************************************/ |
| |
| static assert(-(1) == -1); |
| |
| static assert(!27 == 0); |
| static assert(!0 == 1); |
| static assert(!6.2 == 0); |
| static assert(!0.0 == 1); |
| |
| static assert((6 % 4) == 2); |
| static assert((6u % 4u) == 2u); |
| |
| static assert((cast(byte)0x109 >> 1) == 4); |
| static assert((cast(byte)-1 >> 1) == -1); |
| static assert((cast(ubyte)0x109 >> 1) == 4); |
| |
| static assert((cast(short)0x10009 >> 1) == 4); |
| static assert((cast(short)-1 >> 1) == -1); |
| static assert((cast(ushort)0x10009 >> 1) == 4); |
| |
| static assert((cast(long)0x1_0000_0000_0009 >> 1) == 0x8000_0000_0004); |
| static assert((cast(long)-1L >> 1) == -1); |
| static assert((cast(ulong)0x10009 >> 1) == 0x8004); |
| |
| static assert((cast(byte)0x109 >>> 1) == 4); |
| static assert((cast(byte)-1 >>> 1) == int.max); |
| static assert((cast(ubyte)0x109 >>> 1) == 4); |
| |
| static assert((cast(short)0x10009 >>> 1) == 4); |
| static assert((cast(short)-1 >>> 1) == int.max); |
| static assert((cast(ushort)0x10009 >>> 1) == 4); |
| |
| static assert((cast(long)0x1_0000_0000_0009 >>> 1) == 0x8000_0000_0004); |
| static assert((cast(long)-1L >>> 1) == long.max); |
| static assert((cast(ulong)0x10009 >>> 1) == 0x8004); |
| |
| static assert((3 ^ 5) == 6); |
| |
| static assert((0 && 0) == 0); |
| static assert((0 && 5) == 0); |
| static assert((10 && 0) == 0); |
| static assert((58 && 10000) == 1); |
| |
| static assert((0.0 && 0.0) == 0); |
| static assert((0.0 && 5.1) == 0); |
| static assert((10.0 && 0.0) == 0); |
| static assert((58.6 && 10000.7) == 1); |
| |
| static assert((0 || 0) == 0); |
| static assert((0 || 5) == 1); |
| static assert((10 || 0) == 1); |
| static assert((58 || 10000) == 1); |
| |
| static assert((0.0 || 0.0) == 0); |
| static assert((0.0 || 5.1) == 1); |
| static assert((10.0 || 0.0) == 1); |
| static assert((58.6 || 10000.7) == 1); |
| |
| static assert((5 < 3) == 0); |
| static assert((5 < 5) == 0); |
| static assert((5 < 6) == 1); |
| static assert((5 <= 3) == 0); |
| static assert((5 <= 5) == 1); |
| static assert((5 <= 6) == 1); |
| static assert((5 > 3) == 1); |
| static assert((5 > 5) == 0); |
| static assert((5 > 6) == 0); |
| static assert((5 >= 3) == 1); |
| static assert((5 >= 5) == 1); |
| static assert((5 >= 6) == 0); |
| |
| static assert((-5 < -3) == 1); |
| static assert((-5 < -5) == 0); |
| static assert((-5 < -6) == 0); |
| static assert((-5 <= -3) == 1); |
| static assert((-5 <= -5) == 1); |
| static assert((-5 <= -6) == 0); |
| static assert((-5 > -3) == 0); |
| static assert((-5 > -5) == 0); |
| static assert((-5 > -6) == 1); |
| static assert((-5 >= -3) == 0); |
| static assert((-5 >= -5) == 1); |
| static assert((-5 >= -6) == 1); |
| |
| static assert((5u < 3u) == 0); |
| static assert((5u < 5u) == 0); |
| static assert((5u < 6u) == 1); |
| static assert((5u <= 3u) == 0); |
| static assert((5u <= 5u) == 1); |
| static assert((5u <= 6u) == 1); |
| static assert((5u > 3u) == 1); |
| static assert((5u > 5u) == 0); |
| static assert((5u > 6u) == 0); |
| static assert((5u >= 3u) == 1); |
| static assert((5u >= 5u) == 1); |
| static assert((5u >= 6u) == 0); |
| |
| static assert((-5u < 3) == 0); |
| static assert((-5u <= 3) == 0); |
| static assert((-5u > 3) == 1); |
| static assert((-5u >= 3) == 1); |
| |
| static assert((-5 < 3u) == 0); |
| static assert((-5 <= 3u) == 0); |
| static assert((-5 > 3u) == 1); |
| static assert((-5 >= 3u) == 1); |
| |
| static assert((5.2 < double.nan) == 0); |
| static assert((5.2 <= double.nan) == 0); |
| static assert((5.2 > double.nan) == 0); |
| static assert((5.2 >= double.nan) == 0); |
| |
| static assert((double.nan < 6.2) == 0); |
| static assert((double.nan <= 6.2) == 0); |
| static assert((double.nan > 6.2) == 0); |
| static assert((double.nan >= 6.2) == 0); |
| |
| static assert((double.nan < double.nan) == 0); |
| static assert((double.nan <= double.nan) == 0); |
| static assert((double.nan > double.nan) == 0); |
| static assert((double.nan >= double.nan) == 0); |
| |
| static assert((5.2 < 6.2) == 1); |
| static assert((5.2 <= 6.2) == 1); |
| static assert((5.2 > 6.2) == 0); |
| static assert((5.2 >= 6.2) == 0); |
| |
| static assert((5.2 < 5.2) == 0); |
| static assert((5.2 <= 5.2) == 1); |
| static assert((5.2 > 5.2) == 0); |
| static assert((5.2 >= 5.2) == 1); |
| |
| static assert((7.2 < 6.2) == 0); |
| static assert((7.2 <= 6.2) == 0); |
| static assert((7.2 > 6.2) == 1); |
| static assert((7.2 >= 6.2) == 1); |
| |
| static assert((7.2 == 6.2) == 0); |
| static assert((7.2 != 6.2) == 1); |
| |
| static assert((7.2 == 7.2) == 1); |
| static assert((7.2 != 7.2) == 0); |
| |
| static assert((7.2 == double.nan) == 0); |
| static assert((7.2 != double.nan) == 1); |
| static assert((double.nan == double.nan) == 0); |
| static assert((double.nan != double.nan) == 1); |
| static assert((double.nan == 7.2) == 0); |
| static assert((double.nan != 7.2) == 1); |
| |
| static assert((5 is 5) == 1); |
| static assert((5 is 4) == 0); |
| static assert((5 !is 5) == 0); |
| static assert((5 !is 4) == 1); |
| |
| static assert((5.1 is 5.1) == 1); |
| static assert((5.1 is 4.1) == 0); |
| static assert((5.1 !is 5.1) == 0); |
| static assert((5.1 !is 4.1) == 1); |
| |
| static assert((5 ? 2 : 3) == 2); |
| static assert((0 ? 2 : 3) == 3); |
| static assert((5.0 ? 2 : 3) == 2); |
| static assert((0.0 ? 2 : 3) == 3); |
| |
| static assert("abc" == "abc"); |
| |
| //static assert("abc"w.sizeof == 6); |
| //static assert("\U00010000bc"w.sizeof == 8); |
| |
| static assert([1,2,3][1] == 2); |
| static assert([1,2,3] ~ [4] == [1,2,3,4]); |
| static assert([1,2,3][1..3] == [2,3]); |
| |
| static assert(['a','b','c','d'] == "abcd"); |
| static assert("efgh" == ['e','f','g','h']); |
| static assert("efgi" != ['e','f','g','h']); |
| |
| |
| void test1() |
| { |
| int x; |
| int y; |
| int* p; |
| |
| p = &x + cast(size_t)&y; |
| p = &x + 2; |
| p = 4 + &y; |
| p = &x - 1; |
| |
| assert((&x is &x) == 1); |
| assert((&x is &y) == 0); |
| assert((&x !is &x) == 0); |
| assert((&x !is &y) == 1); |
| } |
| |
| /************************************/ |
| |
| void test2() |
| { |
| // This test only tests undefined, architecture-dependant behavior. |
| // E.g. the result of converting a float whose value doesn't fit into the integer |
| // leads to an undefined result. |
| version (DigitalMars) |
| { |
| float f = float.infinity; |
| int i = cast(int) f; |
| assert(i == cast(int)float.max); |
| assert(i == 0x80000000); |
| } |
| } |
| |
| /************************************/ |
| |
| void test3() |
| { |
| real n = -0.0; |
| const real m = -0.0; |
| |
| assert(signbit(n) != 0); |
| assert(signbit(m) != 0); |
| } |
| |
| /************************************/ |
| |
| struct A4 { char [] a; } |
| struct B4 { long x; } |
| struct C4 { int a; |
| static C4 opCall(int b) { C4 q; q.a=b; return q; } |
| } |
| static assert(!is(typeof( (){ A4 s; B4 q = s; }))); |
| static assert(!is(typeof( (){ B4 x =1L; }))); |
| static assert(is(typeof( (){ C4 g = 7; }))); |
| static assert(is(typeof( (){ C4 g = 7; C4 h = g;}))); |
| |
| /************************************/ |
| |
| alias uint DWORD; |
| MY_API_FUNCTION lpStartAddress; |
| extern (Windows) alias DWORD function(void*) MY_API_FUNCTION; |
| static assert(MY_API_FUNCTION.stringof == "extern (Windows) uint function(void*)"); |
| |
| /************************************/ |
| |
| enum bug6 = cast(void*)0xFEFEFEFE; |
| static assert(bug6 is bug6); |
| |
| /************************************/ |
| |
| struct S7{ |
| double z; |
| } |
| |
| int bug7(int x) { return x; } |
| |
| S7 s7; |
| double e7 = 4; |
| const double d7 = 4; |
| |
| static assert(!is(typeof(bug7(cast(long)e7)))); |
| static assert(!is(typeof(bug7(cast(long)s7)))); |
| version (LDC) {} else // cast in LDC undefined result w/ x > long.max |
| static assert(!is(typeof(bug7(cast(long)3.256679e30)))); |
| |
| static assert(is(typeof(bug7(cast(long)d7)))); |
| static assert(is(typeof(bug7(cast(long)3.256679e4)))); |
| |
| /************************************/ |
| |
| class C8 { |
| int x; |
| } |
| alias C8.x F8; |
| static assert(is(typeof(F8) == int)); |
| static assert(is(typeof(C8.x) == int)); |
| |
| /************************************/ |
| |
| int foo9() { |
| int u = cast(int)(0x1_0000_0000L); |
| while (u) { |
| if (u) { |
| assert(u!=0); |
| } |
| assert(u!=0); |
| } |
| return 2; |
| } |
| |
| static assert(foo9()==2); |
| |
| /************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=6077 |
| |
| void test6077() { |
| static string scat(string s1, string s2) |
| { |
| return s1 ~ s2; |
| } |
| |
| static string scatass(string s1, string s2) |
| { |
| s1 ~= s2; |
| return s1; |
| } |
| |
| static string[] arycats(string[] ary, string s) |
| { |
| return ary ~ s; |
| } |
| |
| static string[] scatary(string s, string[] ary) |
| { |
| return s ~ ary; |
| } |
| |
| static string[] arycatasss(string[] ary, string s) |
| { |
| ary ~= s; |
| return ary; |
| } |
| |
| static assert(scat(null, null) is null); |
| static assert(scatass(null, null) is null); |
| static assert(arycats(null, null) == cast(string[])[null]); |
| static assert(scatary(null, null) == cast(string[])[null]); |
| static assert(arycatasss(null, null) == cast(string[])[null]); |
| } |
| |
| /************************************/ |
| |
| int test4() |
| { |
| int i; |
| |
| dchar d; |
| d >>= 1; |
| d >>>= 1; |
| d <<= 1; |
| d = d >> 1; |
| d = d >>> 1; |
| d = d << 1; |
| wchar w; |
| w >>= 1; |
| w >>>= 1; |
| w <<= 1; |
| w = w >> 1; |
| w = w >>> 1; |
| i = w << 1; // promoted to int |
| char c; |
| c >>= 1; |
| c >>>= 1; |
| c <<= 1; |
| c = c >> 1; |
| c = c >>> 1; |
| i = c << 1; // promoted to int |
| return d + w + c + i; |
| } |
| |
| static assert(test4() == 24666); |
| |
| /************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=8400 |
| |
| void test8400() |
| { |
| immutable a = [1,2]; |
| int[a.length+0] b; // ok |
| int[a.length ] c; // error |
| } |
| |
| /************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=8939 |
| |
| void foo8939(T)(ref T) { } // same for `auto ref` |
| void bar8939(ref const int) { } |
| void bar8939(ref const S8939) { } |
| |
| static struct S8939 { int n; } |
| |
| const gn8939 = 1; // or `immutable` |
| const gs8939 = S8939(3); |
| static assert(__traits(compiles, foo8939(gn8939), bar8939(gn8939))); |
| static assert(__traits(compiles, foo8939(gs8939), bar8939(gs8939))); |
| |
| void test8939() |
| { |
| foo8939(gn8939), bar8939(gn8939); |
| foo8939(gs8939), bar8939(gs8939); |
| |
| const ln8939 = 1; |
| const ls8939 = S8939(3); |
| foo8939(ln8939), bar8939(ln8939); |
| foo8939(ls8939), bar8939(ls8939); |
| } |
| |
| class C8939regression |
| { |
| const int n1 = 0; |
| const int n2 = 0; |
| const int n3 = 0; |
| const int n4 = 1; |
| |
| int refValue(V)(ref V var) |
| { |
| return 0; |
| } |
| |
| void foo() |
| { |
| string[2] str; |
| refValue(str[n1]); |
| |
| int[] da; |
| refValue(da[n2]); |
| |
| int n; int* p = &n; |
| refValue(*cast(int*)(p + n3)); |
| |
| refValue([1,2,n4].ptr[0]); |
| } |
| } |
| |
| /************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=9058 |
| |
| template TypeTuple9058(TL...) { alias TypeTuple9058 = TL; } |
| template EnumMembers9058(T) |
| { |
| alias EnumMembers9058 = TypeTuple9058!(Foo9058.A, Foo9058.B); |
| } |
| enum Foo9058 { A, B } |
| size_t bar9058(size_t n) |
| { |
| return 0; |
| } |
| void test9058() |
| { |
| Foo9058 x = [EnumMembers9058!Foo9058][bar9058($)]; |
| } |
| |
| /************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=12306 |
| |
| void test12306() |
| { |
| struct Point3D { ubyte x, y, z; } |
| |
| enum Point3D pt1 = {x:1, y:1, z:1}; |
| const Point3D pt2 = {x:1, y:1, z:1}; |
| immutable Point3D pt3 = {x:1, y:1, z:1}; |
| |
| int[pt1.z][pt1.y][pt1.x] a1; |
| int[pt2.z][pt2.y][pt2.x] a2; |
| int[pt3.z][pt3.y][pt3.x] a3; |
| |
| ubyte a = 1; |
| const Point3D ptx = {x:a, y:1, z:1}; |
| |
| static assert(!__traits(compiles, { int[ptx.z][ptx.y][ptx.x] ax; })); |
| } |
| |
| /************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=13977 |
| |
| void test13977() |
| { |
| bool cond(bool b) { return b; } |
| int x = 0; |
| void check(int n = 1) { x = n; } |
| |
| cond(true) && check(); |
| assert(x == 1); x = 0; |
| |
| cond(false) && check(); |
| assert(x == 0); x = 0; |
| |
| true && check(); |
| assert(x == 1); x = 0; |
| |
| false && check(); |
| assert(x == 0); x = 0; |
| (int[]).init && check(); |
| assert(x == 0); x = 0; |
| Object.init && check(); |
| assert(x == 0); |
| |
| check(2); |
| false && check(); |
| assert(x == 2); x = 0; |
| } |
| |
| /************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=13978 |
| |
| void test13978() |
| { |
| bool cond(bool b) { return b; } |
| int x = 0; |
| void check(int n = 1) { x = n; } |
| |
| cond(true) || check(); |
| assert(x == 0); x = 0; |
| |
| cond(false) || check(); |
| assert(x == 1); x = 0; |
| |
| true || check(); |
| assert(x == 0); x = 0; |
| |
| false || check(); |
| assert(x == 1); x = 0; |
| (int[]).init || check(); |
| assert(x == 1); x = 0; |
| Object.init || check(); |
| assert(x == 1); x = 0; |
| |
| check(2); |
| true || check(); |
| assert(x == 2); x = 0; |
| } |
| |
| /************************************/ |
| // Pull Request 3697 |
| |
| void test3697and() |
| { |
| enum x = 0; |
| auto y = x && 1 / x; |
| } |
| |
| void test3697or() |
| { |
| enum x = 0; |
| enum y = 1; |
| auto z = y || 1 / x; |
| } |
| |
| /************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=14459 |
| |
| void test14459() |
| { |
| const char* s0 = "hi0"; |
| const(char)* p0 = s0; |
| assert(p0 == s0); |
| |
| const char* s1 = "hi1"; |
| const char* s2 = "hi2"; |
| const char* s3 = "hi3"; |
| const char* s4 = "hi4"; |
| const char* s5 = "hi5"; |
| const char* s6 = "hi6"; |
| const char* s7 = "hi7"; |
| const char* s8 = "hi8"; |
| const char* s9 = "hi9"; |
| const char* s10 = "hi10"; |
| const char* s11 = "hi11"; |
| const char* s12 = "hi12"; |
| const char* s13 = "hi13"; |
| const char* s14 = "hi14"; |
| const char* s15 = "hi15"; |
| assert(p0 == s0); // ok |
| const char* s16 = "hi16"; |
| assert(p0 == s0); // ok <- fails |
| } |
| |
| /************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=15607 |
| |
| static immutable char[2][4] code_base = [ "??", 12 ]; |
| static assert(code_base[0] == "??"); |
| static assert(code_base[1] == [12, 12]); |
| static assert(code_base[2] == typeof(code_base[2]).init); |
| |
| /************************************/ |
| |
| int main() |
| { |
| test1(); |
| test2(); |
| test3(); |
| test3697and(); |
| test3697or(); |
| test6077(); |
| test8400(); |
| test8939(); |
| test9058(); |
| test13977(); |
| test13978(); |
| test14459(); |
| |
| return 0; |
| } |