Changeset 653

Timestamp:

09/01/10 01:51:00 (1 year ago)

Author:

braddr

Message:

Integrate changes from the private test suite into the public one

Files:

• trunk/test/compilable/imports/test66a.d (added)
• trunk/test/compilable/imports/test67a.d (added)
• trunk/test/compilable/imports/test68a.d (added)
• trunk/test/compilable/test66.d (added)
• trunk/test/compilable/test67.d (added)
• trunk/test/compilable/test68.d (added)
• trunk/test/runnable/arrayop.d (modified) (2 diffs)
• trunk/test/runnable/interface.d (modified) (1 diff)
• trunk/test/runnable/nested.d (modified) (2 diffs)
• trunk/test/runnable/opover.d (modified) (2 diffs)
• trunk/test/runnable/sdtor.d (modified) (2 diffs)
• trunk/test/runnable/template4.d (modified) (1 diff)
• trunk/test/runnable/test4.d (modified) (2 diffs)
• trunk/test/runnable/test42.d (modified) (3 diffs)
• trunk/test/runnable/test60.d (modified) (1 diff)
• trunk/test/runnable/xtest46.d (modified) (2 diffs)

trunk/test/runnable/arrayop.d

@@ -417 +417 @@
-/************************************************************************/
-
+void test4()
+{
+    int[] a, b;
+    if (a && b) {}
+}
+
+/************************************************************************/
+
-int main()
-{
@@ -422 +430 @@
-    test2();
-    test3();
+    test4();
-
-    printf("Success\n");

trunk/test/runnable/interface.d

@@ -56 +56 @@
-/*******************************************/
-
+interface I3 {
+    void h();
+}
+interface K3 {
+    void f();
+}
+
+interface J3 : I3, K3 {}
+
+class A3 : J3 {
+    void f(){ }
+    void h(){ } 
+}
+
+void test3()
+{
+    auto a = new A3();
+    J3 b = a;
+    K3 c = a;
+    assert(&b.f == &c.f); // Bugzilla 3706
+}
+
+/*******************************************/
+
-int main()
-{
-    test1();
-    test2();
+    test3();
-
-    printf("Success\n");

trunk/test/runnable/nested.d

@@ -1465 +1465 @@
-    auto c = new A;
-    assert(c.bar(4) == 44);
+}
+/*******************************************/
+
+void test55()
+{
+    int localvar = 7;
+
+    int inner(int delegate(ref int) dg) {
+        int k = localvar;
+        return 0;
+    }
+
+    int a = localvar * localvar; // This modifies the EAX register
+
+    foreach (entry; &inner)
+    {
+    }
-}
-
@@ -1525 +1542 @@
-    test53();
-    test54();
+    test55();
-
-    printf("Success\n");

trunk/test/runnable/opover.d

@@ -882 +882 @@
-/**************************************/
-
+// 3983
+
+struct Fug
+{
+    bool opEquals(ref const Fug y) const {
+        return false;
+    }
+}
+
+struct Fig
+{
+   Fug f;
+   bool opEquals(Tdummy=void)(ref const Fig y) const {
+      return false;
+   }
+
+   bool opEquals(T: int)(T y) const {
+      return false;
+   }
+}
+
+void test15()
+{
+  Fig fx, fy;
+  if (fx==2) {}
+}
+
+/**************************************/
+
-int main()
-{
@@ -898 +927 @@
-    test13();
-    test14();
+    test15();
-
-    printf("Success\n");

trunk/test/runnable/sdtor.d

@@ -1270 +1270 @@
-  final switch(0) A51 a;
-  A51 a; with(a) A51 b;
+}
+
+/**********************************/
+
+string s52;
+
+struct A52
+{
+    int m;
+    this(this)
+    {
+        printf("this(this) %p\n", &this);
+      s52 ~= 'a';
+    }
+    ~this()
+    {
+        printf("~this() %p\n", &this);
+      s52 ~= 'b';
+    }
+    A52 copy()
+    {
+      s52 ~= 'c';
+      A52 another = this;
+      return another;
+    }
+}
+
+void test52()
+{
+  {
+    A52 a;
+    A52 b = a.copy();
+    printf("a: %p, b: %p\n", &a, &b);
+  }
+    printf("s = '%.*s'\n", s52);
+    assert(s52 == "caabbb");
+}
+
+/**********************************/
+// 4339
+
+struct A53 {
+    invariant() {   }
+    ~this() { }
+    void opAssign(A53 a) {}
+    int blah(A53 a) { return 0; }
-}
-
@@ -1327 +1373 @@
-    test50();
-    test51();
+    test52();
-
-    printf("Success\n");

trunk/test/runnable/template4.d

@@ -1019 +1019 @@
-}
-
+/*********************************************************/
+
+void bug4652(U, T...)(long y, T x, U num) {}
+void bug4652default(T) (T value, int x=2) {}
+void bug4652default(T) (T value, int y) {}
+void bug4676(T...)(T args, string str) {}
+void bug4676(T...)(T args) {}
+
+void instantiate4652()
+{
+    bug4652(2, 'c', 27, 'e', 'f',1); // rejects-valid
+    bug4652(2, 1);  // infinite loop on valid code
+    bug4652default(true);
+    bug4676(1, 2, 3);
+}
-
-/*********************************************************/

trunk/test/runnable/test4.d

@@ -1374 +1374 @@
-        printf("catch %.*s\n", e.msg);
-        assert(e.msg == "second");
+        //assert(e.msg == "first");
+        //assert(e.next.msg == "second");
-        assert(status==3);
-    }
@@ -1392 +1394 @@
-    {
-    printf("inner catch %p\n", e);
+    printf("e.msg == %.*s\n", e.msg);
-    assert(e.msg == "second");
+    //assert(e.msg == "first");
+    //assert(e.next.msg == "second");
-    }
-}

trunk/test/runnable/test42.d

@@ -699 +699 @@
-void test45()
-{
-(Windows)
+ (Windows)  // this test fails in -release because asserts will be removed
-   {
-      assert(foo45(0)==2);
@@ -3455 +3455 @@
-
-static assert(A196.sizeof == B196.sizeof);
+
+/***************************************************/
+
+template Compileable(int z) { bool OK;}
+
+struct Bug3569 {
+    int bar() { return 7; }
+}
+
+struct Bug3569b {
+    Bug3569 foo;
+    void crash() {
+        static assert(!is(typeof(Compileable!(foo.bar()))));
+        static assert(!is(typeof(Compileable!((foo = Bug3569.init).bar()))));
+    }
+}
+
+void test197()
+{
+}
+
+/***************************************************/
+
+void test198()  // Bugzilla 4506
+{
+    int c = 1;
+    for (int k = 0; k < 2; k++) {
+        assert((k == 0 && c == 1) || (k == 1 && c == -1));
+        c *= -1;
+    }
+}
+
+/***************************************************/
+
+// Bugzilla 4514
+void g199(void delegate(void*, void*) d) { }
+
+struct X199 {
+    void f(void*, void*) {}
+    void n()
+    {
+        g199(&f);
+    }
+}
+
+/***************************************************/
+// Bugzilla 4443
+
+struct Struct4443
+{
+    int x;
+    char[5] unused;
+}
+
+void foo4443(Struct4443 *dest, Struct4443[] arr)
+{
+    int junk = arr[$-1].x;
+    if (dest || arr[$-1].x) {
+        *dest = arr[$-1];
+    }
+}
+
+void test200()
+{
+    Struct4443[1] a;
+    Struct4443 info;
+    foo4443(&info, a);
+}
+
+/***************************************************/
+
+// Bugzilla 2931
+
+struct Bug2931 {
+        int val[3][4];
+}
+
+struct Outer2931 {
+        Bug2931 p = Bug2931(67);  // Applies to struct static initializers too
+        int zoom = 2;
+        int move = 3;
+        int scale = 4;
+}
+
+int bug2931()
+{
+  Outer2931 v;
+  assert(v.move==3);
+  assert(v.scale == 4);
+  return v.zoom;
+}
+
+int bug2931_2()
+{
+  Outer2931 v;
+  assert(v.move==3);
+  for (int i = 0; i < 4; i++)
+  { for (int j = 0; j < 3; j++)
+    {
+    printf("[%d][%d] = %d\n", j, i, v.p.val[j][i]);
+    if (i == 0 && j == 0)
+        assert(v.p.val[j][i] == 67);
+    else
+        assert(v.p.val[j][i] == 0);
+    }
+  }
+  printf("v.zoom = %d\n", v.zoom);
+  assert(v.scale == 4);
+  return v.zoom;
+}
+
+static assert(bug2931()==2);
+
+void test201() {
+    assert(bug2931()==2);
+    assert(bug2931_2()==2);
+}
+
+
+/***************************************************/
+
+import std.stdarg;
+
+void foo202(int x, ...) {
+    printf("%d arguments\n", _arguments.length);
+    for (int i = 0; i < _arguments.length; i++) {   
+        int j = va_arg!(int)(_argptr);
+        printf("\t%d\n", j);
+    assert(j == i + 2);
+    }
+}
+
+void fooRef202(ref int x, ...) {
+    printf("%d arguments\n", _arguments.length);
+    for (int i = 0; i < _arguments.length; i++) {   
+        int j = va_arg!(int)(_argptr);
+        printf("\t%d\n", j);
+    assert(j == i + 2);
+    }
+}
+
+void test202()
+{
+    foo202(1, 2, 3, 4, 5);
+
+    printf("---\n");
+
+    int x = 1;
+    fooRef202(x, 2, 3, 4, 5);
+}
+
+/***************************************************/
+// Bugzilla 1418
+
+class A203
+{
+    char name = 'A';
+    class B203
+    {
+        char name = 'B';
+    }
+}
+
+void test203()
+{
+    class C203
+    {
+    char name = 'C';
+    }
+
+    auto a = new A203;
+    auto b = a.new B203;
+    auto c = new C203;
+
+    writeln(a.tupleof); // prints: A
+    writeln(b.tupleof); // prints: B main.A
+    writeln(c.tupleof); // prints: C 0000
+    assert(a.tupleof.length == 1 && a.tupleof[0] == 'A');
+    assert(b.tupleof.length == 1 && b.tupleof[0] == 'B');
+    assert(c.tupleof.length == 1 && c.tupleof[0] == 'C');
+}
+
+/***************************************************/
+// Bugzilla 4516
+
+struct A204 { B204 b; }
+enum B204 { Z }
+
+/***************************************************/
+// Bugzilla 4503
+
+class Collection205(T) { }
+ICollection c;
+
+alias Collection205!int ICollection;
+
+/***************************************************/
+
+enum TaskStatus:int { Building=-1, }
+
+TaskStatus test206(char[] s){
+    char[] t="TaskStatus".dup;
+    if (s.length>t.length && s[0..t.length]==t){
+        long res=0;
+        if (s[t.length]=='-') res= -res;    // <= OPnegass
+        return cast(TaskStatus)cast(int)res;
+    }
+    assert(0);
+}
+
+/***************************************************/
+
+struct UN {   double dd;    long ll; }
+bool cmp( UN * pU ) {   return pU.dd >= pU.ll ? true : false; }
+
+struct UN2 {  real dd; long ll; }
+bool cmp2( UN2 * pU ) {  return pU.dd >= pU.ll ? true : false; }
+
+struct UN3 {  double dd; int ll; }
+bool cmp3( UN3 * pU ) {  return pU.dd >= pU.ll ? true : false; }
+
+void test207()
+{
+   static UN u = { 10.50, 10 };
+   auto i = cmp(&u);
+   printf( "%d\n", cmp( &u ) );
+   assert(i);
+
+   static UN2 u2 = { 10.50, 10 };
+   i = cmp2(&u2);
+   assert(i);
+
+   static UN3 u3 = { 10.50, 10 };
+   i = cmp3(&u3);
+   assert(i);
+
+   static UN3 u3_1 = { 9.50, 10 };
+   i = cmp3(&u3_1);
+   assert(!i);
+}
+
+/***************************************************/
+
+template fail4302() {
+    static assert(0);
+}
+template bug4302() {
+   alias fail4302!() bad;
+}
+static if (is(bug4302!())) {}
+
+/***************************************************/
+
+template tough4302()
+{
+  template bar()
+  { 
+     template far()
+     {
+         static assert(0);
+     }
+     alias far!() par;
+  }
+  static if (is(bar!())) {}
+}
+
+alias tough4302!() tougher;
+
+/***************************************************/
+
+// Bugzilla 190
+
+//typedef int avocado;
+//void test208(avocado x208 = .x208) { }
+//avocado x208;
+
+/***************************************************/
+// Bugzilla 3493
+
+const bar209 = foo209;
+const int * foo209 = null;
-
-/***************************************************/
@@ -3647 +3928 @@
-    test194();
-
+    test198();
+
+    test200();
+    test201();
+    test202();
+    test203();
+
+//    test208();
+
-    writefln("Success");
-    return 0;

trunk/test/runnable/test60.d

@@ -1 @@
-// PERMUTE_ARGS:
-
-import std.stdio;
-import std.algorithm;
-
-main
+test1
-{
-    int[] a = [1,2,3,4,5];
-    writeln( remove!("a < 3")(a) );
-}
+
+void test2()
+{
+    auto arr = [1,2,3,4,5];
+    auto m = map!"a + 1"(filter!"a < 4"(arr));
+}
+
+void main()
+{
+    test1();
+    test2();
+
+    writeln("Success");
+}

trunk/test/runnable/xtest46.d

@@ -1970 +1970 @@
-static assert(B110.s == "Boo!(double)");
-static assert(A110.s == "Boo!(int)");
+
+/***************************************************/
+
+// 3716
+void test111()
+{
+    auto k1 = true ? [1,2] : []; // OK
+    auto k2 = true ? [[1,2]] : [[]];
+    auto k3 = true ? [] : [[1,2]];
+    auto k4 = true ? [[[]]] : [[[1,2]]];
+    auto k5 = true ? [[[1,2]]] : [[[]]];
+    auto k6 = true ? [] : [[[]]];
+    static assert(!is(typeof(true ? [[[]]] : [[1,2]]))); // Must fail
+}
+
+/***************************************************/
+// 4303
+
+template foo112() if (__traits(compiles,undefined))
+{
+    enum foo112 = false;
+}
+
+template foo112() if (true)
+{
+    enum foo112 = true;
+}
+
+pragma(msg,__traits(compiles,foo112!()));
+static assert(__traits(compiles,foo112!()));
+
+const bool bar112 = foo112!();
+
+
+/***************************************************/
+
+struct File113
+{
+    this(int name) { }
+
+    ~this() { }
+
+    void opAssign(File113 rhs) { }
+
+    struct ByLine
+    {
+        File113 file;
+
+        this(int) { }
+
+    }
+
+    ByLine byLine()
+    {
+        return ByLine(1);
+    }
+}
+
+auto filter113(File113.ByLine rs)
+{
+    struct Filter
+    {
+    this(File113.ByLine r) { }
+    }
+
+    return Filter(rs);
+}
+
+void test113()
+{
+    auto f = File113(1);
+    auto rx = f.byLine();
+    auto file = filter113(rx);
+}
+
+/***************************************************/
+
+template foo114(fun...)
+{
+    auto foo114(int[] args)
+    {
+    return 1;
+    }
+}
+
+pragma(msg, typeof(foo114!"a + b"([1,2,3])));
+
+/***************************************************/
+// Bugzilla 3935
+
+struct Foo115 {
+    void opBinary(string op)(Foo other) {
+        pragma(msg, "op: " ~ op);
+    assert(0);
+    }
+}
+
+void test115()
+{
+    Foo115 f;
+    f = f;
+}
+
+/***************************************************/
+// Bugzilla 2477
+
+void foo116(T,)(T t) { T x; }
+
+void test116()
+{
+    int[] data = [1,2,3,];  // OK
+
+    data = [ 1,2,3, ];  // fails
+    auto i = data[1,];
+    foo116!(int)(3);
+    foo116!(int,)(3);
+    foo116!(int,)(3,);
+}
+
+/***************************************************/
+// Bugzilla 4291
+
+void test117() pure
+{
+    mixin declareVariable;
+    var = 42;
+    mixin declareFunction;
+    readVar();
+}
+template declareVariable() { int var; }
+template declareFunction()
+{
+    int readVar() { return var; }
+}
+
+/***************************************************/
+// Bugzilla 4177
+
+pure real log118(real x) {
+    if (__ctfe)
+        return 0.0;
+    else
+        return 1.0;
+}
+
+enum x118 = log118(4.0);
+
+void test118() {}
-
-/***************************************************/
@@ -2085 +2233 @@
-    test109();
-
+    test111();
+
+    test113();
+
+    test115();
+    test116();
+    test117();
+    test118();
+
-    printf("Success\n");
-    return 0;