// PERMUTE_ARGS:

module run.module_01;

import core.memory;
import core.exception;
import core.vararg;

extern(C) void* malloc(size_t size);
extern(C) int printf(const char*, ...);

/* ================================ */

struct MyStruct
{
        int i;
}

void test1()
{
        MyStruct inner()
        in{
                assert(1);
        }out (result){
                assert(result.i==1);
        }do{
                MyStruct s;
                s.i = 1;
                return s;
        }
        assert(inner.i==1);
}

/* ================================ */

void foo2()
in{
        assert(0);
}
do{
}

void test2()
{
        try{
                foo2();
        }catch(Error ie){
                return;
        }
        assert(0);
}

/* ================================ */

class MyClass3
{

        private int g() const {
                return 1;
        }

        invariant()
        {
                assert(g()==1);
        }
}

void test3()
{
        MyClass3 c = new MyClass3();
        assert(c);
}

/* ================================ */

class A
{
        int x;

        this(){
            printf("A.this()\n");
            x=3;
        }

        invariant()
        {
            printf("A.invariant\n");
            assert(x>2);
        }
}

class B : A
{
        int y;

        this(){
            printf("B.this()\n");
            y=5;
        }

        invariant()
        {
            printf("B.invariant\n");
            assert(y>4);
        }
}

void test4()
{
        B gc = new B();
}

/* ================================ */

class A5
{

        int x;

        this(){
            printf("A5.this()\n");
            x=3;
        }

        invariant()
        {
            printf("A5.invariant\n");
            assert(x>2);
        }
}

class C5 : A5 { }

class B5 : C5
{

        int y;

        this(){
            printf("B5.this()\n");
            y=5;
        }

        invariant()
        {
            printf("B5.invariant\n");
            assert(y>4);
        }
}

void test5()
{
        B5 gc = new B5();
}

/* ================================ */

void test6()
{
        long a;
        assert(a.max == 0x7FFF_FFFF_FFFF_FFFFL);
        //assert(a.min == 0xFFFF_FFFF_FFFF_FFFFL);
        assert(a.min == 0x8000_0000_0000_0000L);
        assert(a.init == 0);
        assert(a.sizeof == 8);
}

/* ================================ */

int i;

void test7()
{
        assert(run.module_01.i==0);
        run.module_01.i++;
        assert(run.module_01.i==1);
}

/* ================================ */

template mix(){
        int x;
}

mixin .mix;

void test8()
{
}

/* ================================ */

struct A9
{
    B9 next;
}

alias A9* B9;

void test9()
{
    B9 n = new A9;
}

/* ================================ */


struct TestStruct
{
        void add(...)
        {
                TestStruct other = va_arg!TestStruct(_argptr);
                foreach(int value; other)
                {
                        foo();
                }
        }

        void foo()
        {
                assert(left is null);
                bar();
        }

        void bar()
        {
                assert(left is null);
        }

        int opApply(int delegate(ref int val) dg)
        {
                return 0;
        }

        void* left;
}

void test10()
{
        TestStruct t;
        t.foo();
}

/* ================================ */

int status11;

void check(int x){
        status11++;
}

class MyClass11{
        void test(){
                assert(status11==0);
                .check(0);
                assert(status11==1);
                check();
                assert(status11==3);
        }

        void check(){
                assert(status11==1);
                status11+=2;
        }
}

void test11()
{
        MyClass11 c = new MyClass11();
        assert(status11==0);
        c.test();
        assert(status11==3);
        check(0);
        assert(status11==4);
}

/* ================================ */

int status12;

class C12{
        void foo(){
                status12='N';
        }

        static void foo(int x){
                status12=x;
        }
}

void test12()
{
        C12 m = new C12();

        C12.foo('S');
        assert(status12=='S');

        m.foo('s');
        assert(status12=='s');

        m.foo();
        assert(status12=='N');
}

/* ================================ */

void test13()
{
        wstring a="abc";
        wstring b="efg";
        wstring c=a~"d"~b;

        assert(c == "abcdefg");
}

/* ================================ */

void test14()
{
        dstring a="abc";
        dstring b="efg";
        dstring c=a~"d"~b;

        assert(c == "abcdefg");
}

/* ================================ */

class Parent15
{
        void test(int i){
        }

        int opCast(){
                return 0;
        }
}

class Child15 : Parent15
{
}

void test15()
{
        (new Child15()).test(2);
}

/* ================================ */

class Parent16
{
        void test(int i){
        }
}

class Child16 : Parent16
{
        int opCast(){
                return 0;
        }
}

void test16()
{
        (new Child16()).test=2;
}

/* ================================ */

void foo17(){
        class MyClass{
                static int x;
        }
}

void foo17(int i){
        class MyClass{
                static int x;
        }
}

void test17()
{
}

/* ================================ */

void foo18(){
        struct MyStruct{
                static int x;
        }
}

void foo18(int i){
        struct MyStruct{
                static int x;
        }
}

void test18()
{
}

/* ================================ */

class Class19 : Throwable
{
    this() { super(""); }
}

alias Class19 Alias19;

void test19()
{
        try{
                throw new Alias19();
        }catch(Throwable){
                return;
        }
        assert(0);
}

/* ================================ */

public static const uint U20 = (cast(uint)(-1)) >>> 2;

alias uint myType20;
public static const myType20 T20 = (cast(myType20)(-1)) >>> 2;

void test20()
{
        assert(U20 == 0x3FFFFFFF);
        assert(T20 == 0x3FFFFFFF);
}

/* ================================ */

class C21(T1){
        alias T1 type1;
}

class C21(T1, T2){
        alias T1 type1;
        alias .C21!(T2) type2;
}

void test21()
{
        alias C21!(int,long) CT;
        CT c = new CT();
}

/* ================================ */

class AutoClass{
}

void test22()
{
        scope AutoClass ac = new AutoClass();

        with(ac){
        }
}

/* ================================ */

int status23;

class C23{
        ~this(){
                assert(status23==0);
                status23--;
                throw new Exception("error msg");
        }
}

void foo23(){
        assert(status23==0);
        scope C23 ac = new C23();
}

void test23()
{
        try{
                foo23();
        }catch(Throwable){
        }
        assert(status23==-1);
}

/* ================================ */

int status24;

class C24{
        this(){
                assert(status24==0);
                status24+=2;
        }
        ~this(){
                assert(status24==2);
                status24--;
                throw new Exception("error msg");
        }
}

void check24(){
        scope C24 ac = new C24();
        throw new Exception("check error");
}

void test24()
{
        assert(status24==0);
        try{
                check24();
        }catch(Throwable){
                assert(status24==1);
                status24-=5;
        }
        assert(status24==-4);
}

/* ================================ */

struct S25{
        S25 opBinary(string op)(int i) if (op == "-") { S25 s; return s; }
}

struct GeomObject{
        S25     mesh;
        int     xlate;
}


void extractTriangles(GeomObject g)
{
    void foobar()
    {
        g.mesh - g.xlate;
        //g.mesh.opBinary!("-")(g.xlate);
    }

    foobar();
}

void test25()
{
}

/* ================================ */

struct S26{
        int i;

        void display(){
                assert(i==10);
        }

        void someFunc(){
                // We never call this function
                void bug(S26[] array){
                        array[0].i = i+1;
                }

                assert(i==10);
                display();
                assert(i==10);
        }
}

void test26()
{
        S26 m;
        m.i = 10;
        assert(m.i==10);
        m.someFunc();
        assert(m.i==10);
}

/* ================================ */

template foo27(T:T[],alias S) {
        string foo(T[] a, T[] b) {
                return a ~ S ~ b;
        }
}

string comma = ", ";
alias foo27!(string,comma).foo catComma;

void test27()
{
        string a = "Heath";
        string b = "Regan";

        assert("Heath, Regan"==catComma(a,b));
}

/* ================================ */

void test28()
{
        assert((new S28!()).i==int.sizeof);
}

struct S28(){
        int i=func28(0).sizeof;
}

int func28(...){
        return 0;
}

/* ================================ */

void test29()
{
        uint u;
        u = 1 << 31;
        assert( u == 0b1000_0000__0000_0000__0000_0000__0000_0000u);
}

/* ================================ */
// Test for FinalizeError - it will be thrown if an Exception is thrown
// during the class object finalization.

int status30;

class C30
{
    this()
    {
        status30++;
    }

    ~this()
    {
        status30--;
        throw new Exception("E2");
    }
}

void test30()
{
    try
    {
        //scope C30 m = new C30();
        // It will insert one more `delete m` for the scope destruction, and it will be
        // called during stack unwinding.
        // Instead use bare memory chunk on stack to construct dummy class instance.
        void[__traits(classInstanceSize, C30)] payload =
            typeid(C30).initializer[];
        C30 m = cast(C30)payload.ptr;
        m.__ctor();

        assert(status30 == 1);

        destroy(m);   // _d_callfinalizer
    }
    catch (Error e) // FinalizeError
    {
        assert(status30 == 0);
        status30--;
    }

    assert(status30 == -1);
}

/* ================================ */

void test31()
{
        string str = "\xF0\x9D\x83\x93"; // utf-8 for U+1D0D3

        int count=0;
        dchar tmp;
        foreach(dchar value ; str){
                tmp=value;
                count++;
        }
        assert(count==1);
        assert(tmp==0x01D0D3);
}

/* ================================ */

union MyUnion32
{
        int i;
        byte b;
}

void test32()
{
        TypeInfo ti = typeid(MyUnion32*);
        assert(!(ti is null));
        assert(ti.tsize==(MyUnion32*).sizeof);
        assert(ti.toString()=="run.module_01.MyUnion32*");
}

/* ================================ */

void test35()
{
        try{
                onOutOfMemoryError();
        }catch(OutOfMemoryError e){
                return;
        }
        assert(0);
}

/* ================================ */

void test36()
{
        try{
                onOutOfMemoryError();
        }catch(OutOfMemoryError e){
                return;
        }
        assert(0);
}

/* ================================ */

struct S37{
        int a;
}

const int i37 = 15;

const S37 s1 = { i37+1 };
const S37 s2 = s1;

void test37()
{
        assert(s1.a == 16);
        assert(s2.a == 16);
}

/* ================================ */

class Foo38
{
        enum MyEnum{
                VALUE_A=1,
        }
}

class Bar38
{
        enum MyEnum{
                VALUE_B=2,
        }
}

void test38()
{
        assert(Foo38.MyEnum.VALUE_A==1);
        assert(Bar38.MyEnum.VALUE_B==2);
}

/* ================================ */

void test39()
{
        bool[] bArray;
        int[] iArray;

        bArray[]=false;

        foreach(int c; iArray){
                assert(0);
        }
}

/* ================================ */

bool checked40;

class Parent40{
        int x;

        void test(){
        }

        invariant()
        {
                assert(!checked40);
                checked40=true;
                // even number
                assert((x&1u)==0);
        }
}

class Child40 : Parent40{
}

class GrandChild40 : Child40{
        this(){
                x=5;
        }
}

void test40()
{
        try{
                assert(!checked40);
                GrandChild40 gc = new GrandChild40();
        }catch(Throwable){
                assert(checked40);
                return;
        }
        assert(0);
}

/* ================================ */

int counter41;

class C41{
        this(){
                printf("this: counter41 = %d\n", counter41);
                assert(counter41==0);
                counter41+=2;
        }
}

void test41()
{
        C41 c;
        assert(counter41==0);
        c = new C41();
        assert(counter41==2);
}

/* ================================ */

struct S42{
        int y;
        void* x;
}

void test42()
{
        size_t t;
        t = S42.y.offsetof;
        assert(t == 0);
        t = S42.x.offsetof;
        assert((t % (void*).sizeof) == 0);
}

/* ================================ */

int main()
{
    test1();
    test2();
    test3();
    test4();
    test5();
    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();
    test35();
    test36();
    test37();
    test38();
    test39();
    test40();
    test41();
    test42();

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