gdc.test/runnable/test11.d

// RUNNABLE_PHOBOS_TEST
// REQUIRED_ARGS:

extern(C) int printf(const char*, ...);
extern(C) size_t strlen(const char*);

/**************************************/

alias strlen foo1;

void test1()
{
    const(char) *p = "bar";
    size_t i = foo1(p);
    assert(i == 3);
}

/**************************************/

template Foo2(T)
{
    alias T t;
}

alias Foo2!(int) t1;
alias Foo2!(int).t t2;
alias t1.t t3;
alias t2 t4;
alias Foo2!(int) t5;

void test2()
{
    t1.t v1;
    t2 v2;
    t3 v3;
    t4 v4;
    t5.t v5;
    int *p;

    p = &v1;
    p = &v2;
    p = &v3;
    p = &v4;
    p = &v5;
}


/**************************************/

debug = stdchar;

debug(mychar)
{
    alias byte mychar;
}

void test3()
{
    debug(mychar)
    {
    mychar[] line=cast(mychar[])cast(char[])"It is a long line.";
    mychar[] delimiter=cast(mychar[])cast(string)"is";
    }

    debug(stdchar)
    {
    string line="It is a long line.";
    string delimiter="is";
    }

    debug(stdbyte)
    {
    byte[] line=cast(byte[])cast(string)"It is a long line.";
    byte[] delimiter=cast(byte[])cast(string)"is";
    }

    debug(stdwchar)
    {
    wstring line="It is a long line.";
    wstring delimiter="is";
    }
    int ptr=3;

    size_t dl=delimiter.length;
    size_t pl=ptr+dl;

    assert(line[ptr..pl]==delimiter[]);
}


/**************************************/

void test4()
{
    byte* p;

    version(D_LP64)
        assert(p.sizeof == 8);
    else
        assert(p.sizeof == 4);
}


/**************************************/


class Foo6
{
}

void test6()
{
    Foo6 foo = new Foo6();

     with (foo)
     {
         int x;

         x = 4;
     }
}

/**************************************/

int i7 = 3;

void test7()
{
    switch (i7)
    {
    default: assert(0);
    case 3:
        int x;

        x = 4;
    }
}

/**************************************/

void test8()
{
    string a = "a
b
c";
    assert(a.length == 5);
    assert(a[1] == '\n');
}

/**************************************/


struct Foo9 { char c; char bar() { return c; } }

Foo9 makeFoo() { Foo9 f; return f; }

void callFoo (Foo9 a)
{
    a.bar();
}

void test9()
{
    callFoo(makeFoo ());
}

/**************************************/


struct Foo10 { }

Foo10 makeFoo10() { Foo10 f; return f; }

void callFoo (Foo10 a)
{
}

void test10()
{
    callFoo(makeFoo10());
}

/**************************************/

struct Color
{ int x; }

Color[3] colors;

Color eval(float x, float y)
{
    colors[1].x = 7;
    return colors[1];
}

void test11()
{
    Color c;

    c = eval(1.0, 2.0);
    assert(c.x == 7);
}

/**************************************/

struct Size12
{
  int width;
  int height;
}

int x12;

void foo12(out Size12 sz)
{
  sz.width = 2;

  if(sz.width == 2)
    x12 = 1;
}


void test12()
{
  Size12 sz;

  foo12(sz);
  assert(x12 == 1);
  assert(sz.width == 2);
}

/**************************************/


interface D13
{
    void setHostFrame();
}

class A13 : D13
{
    void setHostFrame()
    {
    }

    char         group;
}


void setLayout(D13 lo)
{
    printf("lo = %p\n", lo);
    lo.setHostFrame();
    printf("ok\n");
}


void test13()
{
    A13 a = new A13();
    printf("a  = %p\n", a);
    setLayout(a);
}

/**************************************/

void test14()
{
    while(false)
    {
        static int a;
    }
}


/**************************************/

alias void delegate(int) t_func;

class Foo15
{
   t_func func1;
   int x;

   void dothis()
   {
     if (func1)
        func1(4);
     else
        x = 3;
   }

   void func(int num) { x = num; }
}

void test15()
{
   Foo15 a = new Foo15;
   a.dothis();
   assert(a.x == 3);
   a.func1 = &a.func;
   a.dothis();
   assert(a.x == 4);
}


/**************************************/

int[] foo16(byte[] a)
{
    return cast(int[])a;
}

void test16()
{
    byte[12] b;
    int[] i;

    i = foo16(b);
    assert(i.length == 3);
}

/**************************************/

void test17()
{
  {
    float x = 10;
    x %= 4;
    printf("x = %g\n", x);
    assert(x == 2);
    x = 10;
    x = x % 4;
    printf("x = %g\n", x);
    assert(x == 2);
    x = 4;
    x = 10 % x;
    printf("x = %g\n", x);
    assert(x == 2);
  }
  {
    double y = 10;
    y %= 4;
    printf("y = %g\n", y);
    assert(y == 2);
    y = 10;
    y = y % 4;
    printf("y = %g\n", y);
    assert(y == 2);
    y = 4;
    y = 10 % y;
    printf("y = %g\n", y);
    assert(y == 2);
  }
  {
    real z = 10;
    z %= 4;
    printf("z = %Lg\n", z);
    assert(z == 2);
    z = 10;
    z = z % 4;
    printf("z = %Lg\n", z);
    assert(z == 2);
    z = 4;
    z = 10 % z;
    printf("z = %Lg\n", z);
    assert(z == 2);
  }
}


/**************************************/

struct Bar18 { }

struct Foo18
{
     static Bar18 x = { };
}

void test18()
{
     const Bar18 b = Foo18.x;
}


/**************************************/

int x19 = 10;

void test19()
{   bool b;

    b = cast(bool)x19;
    assert(b == true);
}

/**************************************/

class A20
{
  int abc() { return 3; }

  alias abc def;
}

void test20()
{
    int i;
    A20 a = new A20();

    i = a.def();
    assert(i == 3);
}


/**************************************/

void test21()
{
    string s;
    s = 1 ? "a" : "b";
    assert(s == "a");
}

/**************************************/

class Foo22
{
}

class Bar22 : Foo22
{
}

class Abc22
{
    Foo22 test() { return null; }
}

class Def22 : Abc22
{
    override Bar22 test() { return new Bar22; }
}

void testx22(Abc22 a)
{
    assert(a.test() !is null);
}

void test22()
{
    Def22 d = new Def22();

    testx22(d);
}

/**************************************/

struct foo23
{
   static struct bar
   {
      int x;
   }
}

void test23()
{
   //printf ("%d\n", foo23.bar.sizeof);
   assert(foo23.bar.sizeof == int.sizeof);
}


/**************************************/

void test24()
{
  struct Test
  {
    int i;

    bool bar(int a)
    {
      i = a;
      return true;
    }
  }

  Test t;
  assert(t.bar(3));
}


/**************************************/

void test25()
{
    {   const int [] list = [ 1, 2 ];
      assert(list[0] == 1);
      assert(list[1] == 2);
    }

    {   const int [] list = [ 3, 4 ];
      assert(list[0] == 3);
      assert(list[1] == 4);
    }
}


/**************************************/

void test26()
{
   while (0)
   {
      int x;
   }

   while (0)
   {
      int x;
   }
}


/**************************************/

struct NODE27 {
    int data;
    shared(NODE27) *next;
}

static shared NODE27 nodetbl[3] =
[
    {   0,cast(shared(NODE27)*)nodetbl + 1},
    {   0,cast(shared(NODE27)*)nodetbl + 2},
    {   0,null}
];

static shared NODE27 nodetbl2[3] = [
    {   0,&nodetbl2[1]},
    {   0,&nodetbl2[2]},
    {   0,null}
];

void test27()
{
}


/**************************************/

class Foo28
{
    protected int x;

    static class Bar
    {
       Foo28 f;

       int method () { return f.x; }
    }
}

void test28()
{
}


/**************************************/

void test29()
{
  int[immutable(byte)[]] foo;

  static immutable(byte)[] bar = [ 65, 66, 67 ];

  foo[bar] = 1;
  assert(foo[bar] == 1);
}

/**************************************/

class A30
{
   static class Child
   {
   }
}


class B30
{
   static class Child
   {
      static int value = 6;
   }
}

void test30()
{
   printf ("%d\n", B30.Child.value);
   assert(B30.Child.value == 6);
}


/**************************************/

void test31()
{
    float b;
    b -= 1.0;
    b += 1.0;
}

/**************************************/

class Foo32
{
    struct Bar
    {
        int x;
    }
}

void test32()
{
    with (new Foo32)
    {
        Bar z;
        z.x = 5;
    }
}


/**************************************/

string[2][] foo33;

void test33()
{
    string[2] bar;

    bar[1] = "hello";
    foo33 ~= bar;
    assert(foo33[0][1] == "hello");
}


/**************************************/


void test34()
{
 try {
  int i = 0;
  printf( "i:%d\n", i );
 } finally {
  printf( "Done\n" );
 }
 try {
  int i = 1;
  printf( "i:%d\n", i );
 } finally {
  printf( "Done\n" );
 }
}


/**************************************/

class Bar35 {}

template Foo35( T )
{
    void func() { };
}

void test35()
{
 try {
  alias Foo35!( Bar35 ) filter;
 } catch (Exception e) {
  printf( "Exception %.*s", e.msg.length, e.msg.ptr );
 } finally {
  printf( "Done0." );
 }
}


/**************************************/

void test36()
{
    enum {A=1}
    enum {B=A?0:1}
    assert(A == 1);
    assert(B == 0);
}

/**************************************/

struct A37
{
    int a;
}

struct B37
{
    int a;
    int b;
}

struct C37
{
    int a;
    int b;
    int c;
}

struct D37
{
    byte a,b,c;
}

void test37()
{
    A37 a;
    B37 b;
    C37 c;
    D37 d;

    assert(a.a == 0);
    assert(b.a == 0 && b.b == 0);
    assert(c.a == 0 && c.b == 0 && c.c == 0);
    assert(d.a == 0 && d.b == 0 && d.c == 0);
}


/**************************************/

int function() fp18;

extern(Windows) int func18()
{
    static int otherfunc()
    {   return 18; }

    fp18 = &otherfunc;
    return fp18();
}

void test38()
{
    assert(func18() == 18);
}


/**************************************/

class bar39
{
  struct _sub
  {
    bool a;
    string d;
  };
  _sub mySub;
};

class foo39
{
  bar39._sub[] subArray;

  this(bar39[] arr)
  {
    for(int i=0; i<arr.length; i++)
      subArray ~= arr[i].mySub;
  };
};


void test39()
{
}


/**************************************/

void test40()
{
    void* h;

    h = h.init;
    assert(h == cast(void*)0);
}

/**************************************/

int test41()
{
 label:
 int foo;
 foo = 0;
 return foo;
}


/**************************************/

struct A42
{
    invariant()
    {
    }

    B42 *findPool()
    {
        return null;
    }

}

struct B42
{
    int cmp(B42 *p2)
    {
        return 0;
    }
}

void test42()
{
}


/**************************************/

void test43()
{
    real a = 0.9;
    ulong b = cast(ulong) a;
    printf("%u", cast(uint) b);
    assert(cast(uint) b == 0);

    int c = cast(int) a;
    printf("%i", c);
    assert(c == 0);
}


/**************************************/

void test44()
{
   switch("asdf")
   {
   case "asdf":
     printf("asdf\n");
     break;


   case "jkl":
     printf("jkl\n");
     assert(0);
     break;


   default:
     printf("default\n");
     assert(0);
   }
}


/**************************************/

void func45(string a)
{
    assert(a.length == 5);
}

void test45()
{
    char[5] foo;

    foo[] = "hello";
    printf("'%.*s'\n", foo.length, foo.ptr);
    func45(cast(string)foo);
}

/**************************************/

struct Foo46
{
    int x;
}

void test46()
{
    Foo46 f;

    with (f)
    {
        x = 3;
    }
    assert(f.x == 3);
}

/**************************************/

struct Bar48
{
    uint k;
    ubyte m;
}

Bar48 makebar48() { Bar48 b; return b; }

void test48()
{
    Bar48 b = makebar48();
}

/**************************************/

void testx49() { printf("testx49()\n"); }

void test49() { return testx49(); }

/**************************************/

int testx50() { printf("testx50()\n"); return 3; }

void test50() { return cast(void)testx50(); }

/**************************************/

class A51
{
    static typeof(this) foo()
    {
        return new A51();
    }

    this()
    {
        bar = 3;
    }

    int bar;
}

class B51 : A51
{
    static typeof(super) b;
}

struct C51
{
    typeof(&this) x;
}

void test51()
{
    A51 a = A51.foo();
    assert(a.bar == 3);

    B51.b = a;
    assert(B51.b.bar == 3);
    assert(B51.b.classinfo == A51.classinfo);

    C51 c;
    c.x = &c;
}


/**************************************/

class A52
{
    char get() { return 'A'; }

    char foo() { return typeof(this).get(); }
    char bar() { return A52.get(); }
}

class B52 : A52
{
    override char get() { return 'B'; }
}

void test52()
{
    B52 b = new B52();

    assert(b.foo() == 'A');
    assert(b.bar() == 'A');
    assert(b.get() == 'B');
}

/**************************************/

struct A53
{
    int b() { return 1; }
}

int x53()
{
    A53 a;
    return a.b;
}

void test53()
{
    assert(x53() == 1);
}

/**************************************/

class A54
{
    void a()
    {
        printf("A54.a\n");
    }

    void b()
    {
        typeof(this).a();
    }
}

class B54 : A54
{
    override void a()
    {
        printf("B54.a\n");
        assert(0);
    }
}

void test54()
{
    B54 b = new B54();

    b.b();
}


/**************************************/

int foo55(int x = 5)
{
    printf("x = %d\n", x);
    return x;
}

void test55()
{   int i;

    i = foo55(6);
    assert(i == 6);
    i = foo55();
    assert(i == 5);
}

/**************************************/

class A56
{
    int foo(int x = 5)
    {
        printf("A56.x = %d\n", x);
        return x;
    }
}

class B56 : A56
{
    override int foo(int x = 7)
    {
        printf("B56.x = %d\n", x);
        return x;
    }
}


void test56()
{   int i;
    B56 b = new B56();

    i = b.foo(6);
    assert(i == 6);
    i = b.foo();
    assert(i == 7);
}


/**************************************/

void test57()
{
    char c;
    wchar w;
    dchar d;

    printf("c = %x, w = %x, d = %x\n", c, w, d);
    assert(c == 0xFF);
    assert(w == 0xFFFF);
    assert(d == 0xFFFF);
}

/**************************************/

void test58()
{
    static int x;

    static class S
    {
        static this()
        {
            printf ("static constructor\n");
            x = 10;
        }

        this()
        {
            printf ("class constructor\n");
        }
    }

    assert(x == 10);
    new S;
}

/**************************************/

struct S61 {
    int a, b, c, d;
}

void rec(int n, S61 t)
{
 if (n > 0) {
  t.b++;
  rec(n-1,t);
 }
}

void test61()
{
    S61 F;

    rec(100, F);
}

/**************************************/

class A62
{
    static A62 test(int q=0) {
        return null;
    }
}

A62 foo62()
{
    return A62.test;
}

void test62()
{
    foo62();
}


/**************************************/

class A63
{
     private import std.file;
     alias std.file.getcwd getcwd;
}

void test63()
{
     A63 f = new A63();
     auto s = f.getcwd();
     printf("%.*s\n", s.length, s.ptr);
}


/**************************************/

debug = 3;

void test64()
{
    debug(5)
    {
        assert(0);
    }
    debug(3)
    {
        int x = 3;
    }
    assert(x == 3);
}

/**************************************/

version = 3;

void test65()
{
    version(5)
    {
        assert(0);
    }
    version(3)
    {
        int x = 3;
    }
    assert(x == 3);
}

/**************************************/
// 8809

void test8809()
{
    static class B
    {
        char foo() { return 'B'; }
    }
    static class C : B
    {
        char test1Bx() { return B.foo(); }
        char test1Cx() { return C.foo(); }
        char test1Dx() { return   foo(); }
        char test1By() { return this.B.foo(); }
        char test1Cy() { return this.C.foo(); }   // cannot compile -> OK
        char test1Dy() { return this.  foo(); }
        char test1Bz() { return typeof(super).foo(); }
        char test1Cz() { return typeof(this). foo(); }
      //char test1Dz();

        char test2Bx() { return { return B.foo(); }(); }
        char test2Cx() { return { return C.foo(); }(); }
        char test2Dx() { return { return   foo(); }(); }
        char test2By() { return { return this.B.foo(); }(); }
        char test2Cy() { return { return this.C.foo(); }(); }   // cannot compile -> OK
        char test2Dy() { return { return this.  foo(); }(); }
        char test2Bz() { return { return typeof(super).foo(); }(); }
        char test2Cz() { return { return typeof(this). foo(); }(); }
      //char test2Dz();

        char test3Bx() { return (new class Object { char bar() { return B.foo(); } }).bar(); }
        char test3Cx() { return (new class Object { char bar() { return C.foo(); } }).bar(); }
        char test3Dx() { return (new class Object { char bar() { return   foo(); } }).bar(); }

        override char foo() { return 'C'; }
    }
    static class D : C
    {
        override char foo() { return 'D'; }
    }

    C c = new D();

    assert(c.test1Bx() == 'B');
    assert(c.test1Cx() == 'C');
    assert(c.test1Dx() == 'D');
    assert(c.test1By() == 'B');
    assert(c.test1Cy() == 'C');
    assert(c.test1Dy() == 'D');
    assert(c.test1Bz() == 'B'); // NG('D') -> OK
    assert(c.test1Cz() == 'C');
  //assert(c.test1Dz() == 'D');

    assert(c.test2Bx() == 'B'); // NG('D') -> OK
    assert(c.test2Cx() == 'C'); // NG('D') -> OK
    assert(c.test2Dx() == 'D');
    assert(c.test2By() == 'B');
    assert(c.test2Cy() == 'C');
    assert(c.test2Dy() == 'D');
    assert(c.test2Bz() == 'B'); // NG('D') -> OK
    assert(c.test2Cz() == 'C'); // NG('D') -> OK
  //assert(c.test2Dz() == 'D');

    assert(c.test3Bx() == 'B'); // NG('D') -> OK
    assert(c.test3Cx() == 'C'); // NG('D') -> OK
    assert(c.test3Dx() == 'D');
}

/**************************************/
// 9734

void test9734()
{
    class C {}
    class D : C
    {
        static bool test(C) { return true; }

        void foo()() if (is(typeof(test(super)))) {}
        void bar()() if (is(typeof(super) == C)) {}
    }
    void baz()() if (is(typeof(super))) {}

    auto d = new D();
    d.foo();
    d.bar();
    static assert(!__traits(compiles, baz()));
}

/**************************************/

int main(string[] argv)
{
    test1();
    test2();
    test3();
    test4();
    test6();
    test7();
    test8();
    test9();
    test10();
    test11();
    test12();
    test13();
    test14();
    test15();
    test16();
    test17();
    test18();
    test19();
    test20();
    test21();
    test22();
    test23();
    test24();
    test25();
    test26();
    test27();
    test28();
    test29();
    test30();
    test31();
    test32();
    test33();
    test34();
    test35();
    test36();
    test37();
    test38();
    test39();
    test40();
    test41();
    test42();
    test43();
    test44();
    test45();
    test46();
    test48();
    test49();
    test50();
    test51();
    test52();
    test53();
    test54();
    test55();
    test56();
    test57();
    test58();
    test61();
    test62();
    test63();
    test64();
    test65();
    test8809();
    test9734();

    printf("Success\n");
    return 0;
}