gcc/testsuite/gdc.test/runnable/test8.d

/*
TEST_OUTPUT:
---
runnable/test8.d(261): Deprecation: identity comparison of static arrays implicitly coerces them to slices, which are compared by reference
---
*/

module testxxx8;

import core.vararg;

extern(C)
{
    int atoi(const char*);
    int printf(const char*, ...);
    size_t strlen(const char*);
    version(Windows)
    {
        int _snprintf(char*, size_t, const char*, ...);
        alias _snprintf snprintf;
    }
    else
        int snprintf(char*, size_t, const char*, ...);
}

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

struct Foo1
{
        static int x = 3;
        int y = 4;
}

void test1()
{
    Foo1 f;

    assert(Foo1.x == 3);
    assert(f.x == 3);
    assert(f.y == 4);
}

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

class Foo2
{
        static int x = 5;
        int y = 6;
}

void test2()
{
    Foo2 f = new Foo2();

    assert(Foo2.x == 5);
    assert(f.x == 5);
    assert(f.y == 6);
}


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

struct Foo3
{
        static int bar() { return 3; }
        int y = 4;
}

void test3()
{
    Foo3 f;

    assert(Foo3.bar() == 3);
    assert(f.bar() == 3);
}

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

class Foo4
{
        static int bar() { return 3; }
        int y = 4;
}

void test4()
{
    Foo4 f = new Foo4();

    assert(Foo4.bar() == 3);
    assert(f.bar() == 3);
}


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

struct Foo5
{
        int bar() { return y + 3; }
        int y = 4;
}

void test5()
{
    Foo5 f;

    assert(f.bar() == 7);
}

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

class Foo6
{
        int bar() { return y + 3; }
        final int abc() { return y + 8; }
        int y = 4;
}

class FooX6 : Foo6
{
        override int bar() { return y + 5; }
}

void test6()
{
    Foo6 f = new FooX6();

    assert(f.bar() == 9);
    assert(f.abc() == 12);
}


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

void bar7(char[3] cad)
{
    assert(cad.length == 3);
    printf("cad[0] = %d\n", cad[0]);
    assert(cad[0] == 0xFF);
    assert(cad[1] == 1);
    assert(cad[2] == 0xFF);
}

void test7()
{
    char[3] foo;

    foo[1] = 1;
    bar7(foo);
}


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

class gap8
{
    this(char[3] cad)
    {
        assert(cad[0] == 0xFF);
        assert(cad[1] == 1);
        assert(cad[2] == 0xFF);
    }
}

void test8()
{
    char[3] foo;
    gap8 g;

    foo[1] = 1;
    g = new gap8(foo);
}


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

class Foo11
{
  public:
    int a = 47;

  protected:
    int b;

  private:
    int c;

    int bar()
    {
        return a + b + c;
    }
}

class Bar11 : Foo11
{
    int abc()
    {
        return a + b;
    }
}

void test11()
{
    Foo11 f = new Foo11();

    int i = f.a;
    assert(i == 47);
}

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

class A12
{
    protected void foo() { }
}

class B12: A12
{
    override void foo() { super.foo(); }
}

void test12()
{
}

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

alias void *HWND;

const HWND hWnd = cast(HWND)(null);

void test13()
{
}

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

string bar14()
{
    return "f";
}

char foo14()
{
    return bar14()[0];
}

void test14()
{
    char f = foo14();
    assert(f == 'f');
}


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

void test15()
{
        char[30] a;
        char[30] b;

        assert(a !is b);
}

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

void test16()
{
    static int function() fp = &func16;
    int i = fp();
    assert(i == 648);
}

int func16()
{
    return 648;
}


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

string returnSameString(string inputstr)
{
    return inputstr;
}

string passString()
{
    return returnSameString("First string" ~ "Concatenated with second");
}

string butThisWorks()
{
    string s = "Third string";
    s = s ~ "Concatenated with fourth";
    return returnSameString(s);
}

void test17()
{
    string s;

    s = passString();
    printf("passString() = %.*s\n", cast(int)s.length, s.ptr);
    assert(s == "First stringConcatenated with second");

    s = butThisWorks();
    printf("butThisWorks() = %.*s\n", cast(int)s.length, s.ptr);
    assert(s == "Third stringConcatenated with fourth");
}

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



class A20
{
    private:
        static int a;

    public:
        int foo(B20 j) { return j.b; }
}

class B20
{
    private:
        static int b;

    public:
        int bar(A20 j) { return j.a; }
}

void test20()
{
}

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

alias int* IP;

void test21()
{
    int i = 5;
    IP ip = cast(IP) &i;
    assert(*ip == 5);
}

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

struct RECT
{
    int    left = 1;
    int    top = 2;
    int    right = 3;
    int    bottom = 4;
}

struct Rect
{
  RECT theRect;
}


void Test(Rect pos)
{
    //printf("left = %d\n", pos.theRect.left);
    assert(pos.theRect.left == 1);
    assert(pos.theRect.top == 2);
    assert(pos.theRect.right == 3);
    assert(pos.theRect.bottom == 4);
}

class Window
{
  Rect position;

  void createWindow()
  {
    Test(position);
  }
}

void test22()
{
    Window w = new Window();
    w.createWindow();
}

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

struct Size
{
  int width;
  int height;
}

Size computeSize()
{
  Size foo;

  foo.width = 12;
  foo.height = 34;

  printf("Inside: %d,%d\n",foo.width,foo.height);

  return foo;
}


void test24()
{
  Size bar;
  bar = computeSize();

  printf("Outside: %d,%d\n",bar.width,bar.height);
  assert(bar.width == 12);
  assert(bar.height == 34);
}

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

void test25()
{   int i = 5;

    while (i)
    {
        break;
    }
}

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

int test26()
in
{
}
out (result)
{
}
do
{   int i = 5;

    while (i)
    {
        break;
    }
    return i;
}

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

class A27
{
    int a;

    this()
    {
        a = 1;
    }
}

class B27 : A27
{
}

class C27 : B27
{
    this()
    {
        super();
    }

    this(int i)
    {
    }
}

void test27()
{
    A27 a = new A27();
    assert(a.a == 1);

    B27 b = new B27();
    assert(b.a == 1);

    C27 c = new C27();
    assert(c.a == 1);

    C27 c2 = new C27(2);
    assert(c2.a == 1);
}


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

const char[1] sep = '/';

string testx28(string s, string t)
{
    return cast(string)(s ~ sep ~ t);
}

void test28()
{
    string r;

    r = testx28("ab", "cd");
    assert(r == "ab/cd");
}

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

void test29()
{
}


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

bool func30(int x, int y)
{
    bool b;
    b|=(x==y);
    return b;
}

void test30()
{
    bool b;

    b = func30(1,1);
    assert(b == true);
    b = func30(1,2);
    assert(b == false);
}

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

int a31;

void test31()
{
    testxxx8.a31 = 3;
    assert(a31 == 3);
}

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

void test32()
{
    string[] foo;
    int i;

    foo = new string[45];
    for (i = 0; i < 45; i++)
        foo[i] = "hello";
    for (i = 0; i < 45; i++)
        assert(foo[i] == "hello");
}


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

void test33()
{
    string[] foo;
    int i = 45;

    foo = new string[i];
    for (i = 0; i < 45; i++)
        foo[i] = "hello";
    for (i = 0; i < 45; i++)
        assert(foo[i] == "hello");
}


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

void test34()
{
    int[3][4] a;
    int[5][6] b = 16;
    int i, j;

    for (i = 0; i < 4; i++)
        for (j = 0; j < 3; j++)
            assert(a[i][j] == 0);

    for (i = 0; i < 6; i++)
        for (j = 0; j < 5; j++)
            assert(b[i][j] == 16);
}

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

string itoa(int i)
{
    char[32] buffer;
    snprintf(buffer.ptr, 32, "%d", i);
    return buffer[0 .. strlen(buffer.ptr)].idup;
}

string testa36(int i, int j, string a, string b, string c)
{
    string s =  "string 0;" ~ itoa(i) ~
                "string 1;" ~ itoa(j) ~
                "string 2;" ~ itoa(i) ~
                "string 3;";

//    string s = a ~ b ~ c;
    return s;
}

void test36()
{
    string s = testa36(26, 47, "a", "b", "c");

    printf("s = '%.*s'\n", cast(int)s.length, s.ptr);
    assert(s == "string 0;26string 1;47string 2;26string 3;");
}

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

void test37()
{
    string[ulong] x;
    ulong v1 = 297321415603;
    ulong v2 = 331681153971;
    x[v1] = "aa";
    printf( "%llx %llx\n", v1, v2 );
    assert(!(v2 in x));
}


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

void test38()
{
    int n = atoi("1");
    static char[8192 + 1] flags;
    long i, k;
    int count = 0;

    try
    {
       while (n--)
       {
          count = 0;

          for (i = 2; i <= 8192; i++)
             flags[cast(size_t)i] = 1;

          for (i = 2; i <= 8192; i++)
          {
             if (flags[cast(size_t)i])
             {
                for (k = i+i; k <= 8192; k += i)
                   flags[cast(size_t)k] = 0;

                count++;
             }
          }
       }

       printf("Count: %d\n", count);
        assert(count == 1028);
    }
    catch(Throwable)
    {
       printf("Exception: %lld\n", k);
        assert(0);
    }
}


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

interface I39
{
}

class C39 : I39
{
    int x = 432;
}

void test39()
{
    C39 c = new C39;

    printf("%p %d\n", c, c.x);
    assert(c.x == 432);
    printf("%p\n", cast(I39) c);
    c = cast(C39) cast(I39) c;
    printf("%p\n", c);
    assert(c !is null);
}


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

void test40()
{
       Object x;

       x = null;
       x = 0 ? x : null;
       x = 0 ? null : x;
}

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

int foo42(const(char) *x, ...)
{
    va_list ap;

    va_start!(typeof(x))(ap, x);
    assert(ap != va_list.init);

    int i;
    i = va_arg!(typeof(i))(ap);
    assert(i == 3);

    long l;
    l = va_arg!(typeof(l))(ap);
    assert(l == 23);

    uint k;
    k = va_arg!(typeof(k))(ap);
    assert(k == 4);

    va_end(ap);

    return cast(int)(i + l + k);
}

void test42()
{
    int j;

    j = foo42("hello", 3, 23L, 4);
    printf("j = %d\n", j);
    assert(j == 30);
}

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

int x44;

class A44 {
     this() { printf("A44 ctor\n"); x44 += 1; }
     ~this() { printf("A44 dtor\n"); x44 += 0x100; }
}
class B44 : A44 { }

void foo44() { scope B44 b = new B44; }

void test44()
{
     printf("foo44...\n");
     foo44();
     printf("...foo44\n");
     assert(x44 == 0x101);
}

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

/*
import std.stdarg;
import std.utf;

int unFormat( bool delegate( out dchar ) getc,
        bool delegate( dchar ) ungetc,
        TypeInfo[] arguments,
        void* argptr )
{
    size_t  arg = 0;
    dchar[] fmt;

    if( arguments[arg] is typeid( string ) )
        fmt = toUTF32( va_arg!(string)( argptr ) );
    else if( arguments[arg] is typeid( wchar[] ) )
        fmt = toUTF32( va_arg!(wchar[])( argptr ) );
    else if( arguments[arg] is typeid( dchar[] ) )
        fmt = va_arg!(dchar[])( argptr );
    else
        return 0;
}
*/

void test45()
{
}

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

int sreadf( ... )
{
    va_arg!(string)( _argptr );
    return 0;
}


void test46()
{
    printf( "hello world\n" );
}

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

void test48()
{
  try{
  }finally{
    debug(p48) { }
  }
}

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

void test49()
{
  int k = 1;
  if(k == 0)
    debug{printf("test");}
}

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

void test50()
{       int x;

        if (x)
             version (none)
                 foo;
}

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

int main()
{
    test1();
    test2();
    test3();
    test4();
    test5();
    test6();
    test7();
    test8();
    test11();
    test12();
    test13();
    test14();
    test15();
    test16();
    test17();
    test20();
    test21();
    test22();
    test24();
    test25();
    test26();
    test27();
    test28();
    test29();
    test30();
    test31();
    test32();
    test33();
    test34();
    test36();
    test37();
    test38();
    test39();
    test40();
    test42();
    test44();
    test45();
    test46();
    test48();
    test49();
    test50();

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