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

   1 /*
   2 TEST_OUTPUT:
   3 ---
   4 runnable/test8.d(261): Deprecation: identity comparison of static arrays implicitly coerces them to slices, which are compared by reference
   5 ---
   6 */
   7
   8 module testxxx8;
   9
  10 import core.vararg;
  11
  12 extern(C)
  13 {
  14     int atoi(const char*);
  15     int printf(const char*, ...);
  16     size_t strlen(const char*);
  17     version(Windows)
  18     {
  19         int _snprintf(char*, size_t, const char*, ...);
  20         alias _snprintf snprintf;
  21     }
  22     else
  23         int snprintf(char*, size_t, const char*, ...);
  24 }
  25
  26 /***********************************/
  27
  28 struct Foo1
  29 {
  30         static int x = 3;
  31         int y = 4;
  32 }
  33
  34 void test1()
  35 {
  36     Foo1 f;
  37
  38     assert(Foo1.x == 3);
  39     assert(f.x == 3);
  40     assert(f.y == 4);
  41 }
  42
  43 /***********************************/
  44
  45 class Foo2
  46 {
  47         static int x = 5;
  48         int y = 6;
  49 }
  50
  51 void test2()
  52 {
  53     Foo2 f = new Foo2();
  54
  55     assert(Foo2.x == 5);
  56     assert(f.x == 5);
  57     assert(f.y == 6);
  58 }
  59
  60
  61 /***********************************/
  62
  63 struct Foo3
  64 {
  65         static int bar() { return 3; }
  66         int y = 4;
  67 }
  68
  69 void test3()
  70 {
  71     Foo3 f;
  72
  73     assert(Foo3.bar() == 3);
  74     assert(f.bar() == 3);
  75 }
  76
  77 /***********************************/
  78
  79 class Foo4
  80 {
  81         static int bar() { return 3; }
  82         int y = 4;
  83 }
  84
  85 void test4()
  86 {
  87     Foo4 f = new Foo4();
  88
  89     assert(Foo4.bar() == 3);
  90     assert(f.bar() == 3);
  91 }
  92
  93
  94 /***********************************/
  95
  96 struct Foo5
  97 {
  98         int bar() { return y + 3; }
  99         int y = 4;
 100 }
 101
 102 void test5()
 103 {
 104     Foo5 f;
 105
 106     assert(f.bar() == 7);
 107 }
 108
 109 /***********************************/
 110
 111 class Foo6
 112 {
 113         int bar() { return y + 3; }
 114         final int abc() { return y + 8; }
 115         int y = 4;
 116 }
 117
 118 class FooX6 : Foo6
 119 {
 120         override int bar() { return y + 5; }
 121 }
 122
 123 void test6()
 124 {
 125     Foo6 f = new FooX6();
 126
 127     assert(f.bar() == 9);
 128     assert(f.abc() == 12);
 129 }
 130
 131
 132 /***********************************/
 133
 134 void bar7(char[3] cad)
 135 {
 136     assert(cad.length == 3);
 137     printf("cad[0] = %d\n", cad[0]);
 138     assert(cad[0] == 0xFF);
 139     assert(cad[1] == 1);
 140     assert(cad[2] == 0xFF);
 141 }
 142
 143 void test7()
 144 {
 145     char[3] foo;
 146
 147     foo[1] = 1;
 148     bar7(foo);
 149 }
 150
 151
 152 /***********************************/
 153
 154 class gap8
 155 {
 156     this(char[3] cad)
 157     {
 158         assert(cad[0] == 0xFF);
 159         assert(cad[1] == 1);
 160         assert(cad[2] == 0xFF);
 161     }
 162 }
 163
 164 void test8()
 165 {
 166     char[3] foo;
 167     gap8 g;
 168
 169     foo[1] = 1;
 170     g = new gap8(foo);
 171 }
 172
 173
 174 /***********************************/
 175
 176 class Foo11
 177 {
 178   public:
 179     int a = 47;
 180
 181   protected:
 182     int b;
 183
 184   private:
 185     int c;
 186
 187     int bar()
 188     {
 189         return a + b + c;
 190     }
 191 }
 192
 193 class Bar11 : Foo11
 194 {
 195     int abc()
 196     {
 197         return a + b;
 198     }
 199 }
 200
 201 void test11()
 202 {
 203     Foo11 f = new Foo11();
 204
 205     int i = f.a;
 206     assert(i == 47);
 207 }
 208
 209 /***********************************/
 210
 211 class A12
 212 {
 213     protected void foo() { }
 214 }
 215
 216 class B12: A12
 217 {
 218     override void foo() { super.foo(); }
 219 }
 220
 221 void test12()
 222 {
 223 }
 224
 225 /***********************************/
 226
 227 alias void *HWND;
 228
 229 const HWND hWnd = cast(HWND)(null);
 230
 231 void test13()
 232 {
 233 }
 234
 235 /***********************************/
 236
 237 string bar14()
 238 {
 239     return "f";
 240 }
 241
 242 char foo14()
 243 {
 244     return bar14()[0];
 245 }
 246
 247 void test14()
 248 {
 249     char f = foo14();
 250     assert(f == 'f');
 251 }
 252
 253
 254 /***********************************/
 255
 256 void test15()
 257 {
 258         char[30] a;
 259         char[30] b;
 260
 261         assert(a !is b);
 262 }
 263
 264 /***********************************/
 265
 266 void test16()
 267 {
 268     static int function() fp = &func16;
 269     int i = fp();
 270     assert(i == 648);
 271 }
 272
 273 int func16()
 274 {
 275     return 648;
 276 }
 277
 278
 279 /***********************************/
 280
 281 string returnSameString(string inputstr)
 282 {
 283     return inputstr;
 284 }
 285
 286 string passString()
 287 {
 288     return returnSameString("First string" ~ "Concatenated with second");
 289 }
 290
 291 string butThisWorks()
 292 {
 293     string s = "Third string";
 294     s = s ~ "Concatenated with fourth";
 295     return returnSameString(s);
 296 }
 297
 298 void test17()
 299 {
 300     string s;
 301
 302     s = passString();
 303     printf("passString() = %.*s\n", cast(int)s.length, s.ptr);
 304     assert(s == "First stringConcatenated with second");
 305
 306     s = butThisWorks();
 307     printf("butThisWorks() = %.*s\n", cast(int)s.length, s.ptr);
 308     assert(s == "Third stringConcatenated with fourth");
 309 }
 310
 311 /***********************************/
 312
 313
 314
 315 class A20
 316 {
 317     private:
 318         static int a;
 319
 320     public:
 321         int foo(B20 j) { return j.b; }
 322 }
 323
 324 class B20
 325 {
 326     private:
 327         static int b;
 328
 329     public:
 330         int bar(A20 j) { return j.a; }
 331 }
 332
 333 void test20()
 334 {
 335 }
 336
 337 /***********************************/
 338
 339 alias int* IP;
 340
 341 void test21()
 342 {
 343     int i = 5;
 344     IP ip = cast(IP) &i;
 345     assert(*ip == 5);
 346 }
 347
 348 /***********************************/
 349
 350 struct RECT
 351 {
 352     int    left = 1;
 353     int    top = 2;
 354     int    right = 3;
 355     int    bottom = 4;
 356 }
 357
 358 struct Rect
 359 {
 360   RECT theRect;
 361 }
 362
 363
 364 void Test(Rect pos)
 365 {
 366     //printf("left = %d\n", pos.theRect.left);
 367     assert(pos.theRect.left == 1);
 368     assert(pos.theRect.top == 2);
 369     assert(pos.theRect.right == 3);
 370     assert(pos.theRect.bottom == 4);
 371 }
 372
 373 class Window
 374 {
 375   Rect position;
 376
 377   void createWindow()
 378   {
 379     Test(position);
 380   }
 381 }
 382
 383 void test22()
 384 {
 385     Window w = new Window();
 386     w.createWindow();
 387 }
 388
 389 /***********************************/
 390
 391 struct Size
 392 {
 393   int width;
 394   int height;
 395 }
 396
 397 Size computeSize()
 398 {
 399   Size foo;
 400
 401   foo.width = 12;
 402   foo.height = 34;
 403
 404   printf("Inside: %d,%d\n",foo.width,foo.height);
 405
 406   return foo;
 407 }
 408
 409
 410 void test24()
 411 {
 412   Size bar;
 413   bar = computeSize();
 414
 415   printf("Outside: %d,%d\n",bar.width,bar.height);
 416   assert(bar.width == 12);
 417   assert(bar.height == 34);
 418 }
 419
 420 /***********************************/
 421
 422 void test25()
 423 {   int i = 5;
 424
 425     while (i)
 426     {
 427         break;
 428     }
 429 }
 430
 431 /***********************************/
 432
 433 int test26()
 434 in
 435 {
 436 }
 437 out (result)
 438 {
 439 }
 440 do
 441 {   int i = 5;
 442
 443     while (i)
 444     {
 445         break;
 446     }
 447     return i;
 448 }
 449
 450 /***********************************/
 451
 452 class A27
 453 {
 454     int a;
 455
 456     this()
 457     {
 458         a = 1;
 459     }
 460 }
 461
 462 class B27 : A27
 463 {
 464 }
 465
 466 class C27 : B27
 467 {
 468     this()
 469     {
 470         super();
 471     }
 472
 473     this(int i)
 474     {
 475     }
 476 }
 477
 478 void test27()
 479 {
 480     A27 a = new A27();
 481     assert(a.a == 1);
 482
 483     B27 b = new B27();
 484     assert(b.a == 1);
 485
 486     C27 c = new C27();
 487     assert(c.a == 1);
 488
 489     C27 c2 = new C27(2);
 490     assert(c2.a == 1);
 491 }
 492
 493
 494 /***********************************/
 495
 496 const char[1] sep = '/';
 497
 498 string testx28(string s, string t)
 499 {
 500     return cast(string)(s ~ sep ~ t);
 501 }
 502
 503 void test28()
 504 {
 505     string r;
 506
 507     r = testx28("ab", "cd");
 508     assert(r == "ab/cd");
 509 }
 510
 511 /***********************************/
 512
 513 void test29()
 514 {
 515 }
 516
 517
 518 /***********************************/
 519
 520 bool func30(int x, int y)
 521 {
 522     bool b;
 523     b|=(x==y);
 524     return b;
 525 }
 526
 527 void test30()
 528 {
 529     bool b;
 530
 531     b = func30(1,1);
 532     assert(b == true);
 533     b = func30(1,2);
 534     assert(b == false);
 535 }
 536
 537 /***********************************/
 538
 539 int a31;
 540
 541 void test31()
 542 {
 543     testxxx8.a31 = 3;
 544     assert(a31 == 3);
 545 }
 546
 547 /***********************************/
 548
 549 void test32()
 550 {
 551     string[] foo;
 552     int i;
 553
 554     foo = new string[45];
 555     for (i = 0; i < 45; i++)
 556         foo[i] = "hello";
 557     for (i = 0; i < 45; i++)
 558         assert(foo[i] == "hello");
 559 }
 560
 561
 562 /***********************************/
 563
 564 void test33()
 565 {
 566     string[] foo;
 567     int i = 45;
 568
 569     foo = new string[i];
 570     for (i = 0; i < 45; i++)
 571         foo[i] = "hello";
 572     for (i = 0; i < 45; i++)
 573         assert(foo[i] == "hello");
 574 }
 575
 576
 577 /***********************************/
 578
 579 void test34()
 580 {
 581     int[3][4] a;
 582     int[5][6] b = 16;
 583     int i, j;
 584
 585     for (i = 0; i < 4; i++)
 586         for (j = 0; j < 3; j++)
 587             assert(a[i][j] == 0);
 588
 589     for (i = 0; i < 6; i++)
 590         for (j = 0; j < 5; j++)
 591             assert(b[i][j] == 16);
 592 }
 593
 594 /***********************************/
 595 // https://issues.dlang.org/show_bug.cgi?id=19178
 596
 597 float[3][4] arr2f = 10;
 598 Int3_4[1] arr3i = 20;
 599 short[3][4][1][1] arr4s = 30;
 600
 601 enum Int3 : int[3] {
 602     a = [0, 1, 2],
 603 }
 604
 605 enum Int3_4 : Int3[4] {
 606     b = Int3[4].init,
 607 }
 608
 609 struct S35
 610 {
 611     int[3][3] arr = [2, 1];
 612 }
 613
 614 void test35()
 615 {
 616     for (int i = 0; i < 4; i++)
 617     {
 618         for (int j = 0; j < 3; j++)
 619         {
 620             // printf("[%d %d]: %f %d %d\n", i, j, arr2f[i][j], arr3i[0][i][j], arr4s[0][0][i][j]);
 621             assert(arr2f[i][j] == 10);
 622             assert(arr3i[0][i][j] == 20);
 623             assert(arr4s[0][0][i][j] == 30);
 624         }
 625     }
 626
 627     S35 t = S35.init;
 628     assert(t.arr[0] == [2, 2, 2]);
 629     assert(t.arr[1] == [1, 1, 1]);
 630     assert(t.arr[2] == [0, 0, 0]);
 631 }
 632 /***********************************/
 633
 634 string itoa(int i)
 635 {
 636     char[32] buffer;
 637     snprintf(buffer.ptr, 32, "%d", i);
 638     return buffer[0 .. strlen(buffer.ptr)].idup;
 639 }
 640
 641 string testa36(int i, int j, string a, string b, string c)
 642 {
 643     string s =  "string 0;" ~ itoa(i) ~
 644                 "string 1;" ~ itoa(j) ~
 645                 "string 2;" ~ itoa(i) ~
 646                 "string 3;";
 647
 648 //    string s = a ~ b ~ c;
 649     return s;
 650 }
 651
 652 void test36()
 653 {
 654     string s = testa36(26, 47, "a", "b", "c");
 655
 656     printf("s = '%.*s'\n", cast(int)s.length, s.ptr);
 657     assert(s == "string 0;26string 1;47string 2;26string 3;");
 658 }
 659
 660 /***********************************/
 661
 662 void test37()
 663 {
 664     string[ulong] x;
 665     ulong v1 = 297321415603;
 666     ulong v2 = 331681153971;
 667     x[v1] = "aa";
 668     printf( "%llx %llx\n", v1, v2 );
 669     assert(!(v2 in x));
 670 }
 671
 672
 673 /***********************************/
 674
 675 void test38()
 676 {
 677     int n = atoi("1");
 678     static char[8192 + 1] flags;
 679     long i, k;
 680     int count = 0;
 681
 682     try
 683     {
 684        while (n--)
 685        {
 686           count = 0;
 687
 688           for (i = 2; i <= 8192; i++)
 689              flags[cast(size_t)i] = 1;
 690
 691           for (i = 2; i <= 8192; i++)
 692           {
 693              if (flags[cast(size_t)i])
 694              {
 695                 for (k = i+i; k <= 8192; k += i)
 696                    flags[cast(size_t)k] = 0;
 697
 698                 count++;
 699              }
 700           }
 701        }
 702
 703        printf("Count: %d\n", count);
 704         assert(count == 1028);
 705     }
 706     catch(Throwable)
 707     {
 708        printf("Exception: %lld\n", k);
 709         assert(0);
 710     }
 711 }
 712
 713
 714 /***********************************/
 715
 716 interface I39
 717 {
 718 }
 719
 720 class C39 : I39
 721 {
 722     int x = 432;
 723 }
 724
 725 void test39()
 726 {
 727     C39 c = new C39;
 728
 729     printf("%p %d\n", c, c.x);
 730     assert(c.x == 432);
 731     printf("%p\n", cast(I39) c);
 732     c = cast(C39) cast(I39) c;
 733     printf("%p\n", c);
 734     assert(c !is null);
 735 }
 736
 737
 738 /***********************************/
 739
 740 void test40()
 741 {
 742        Object x;
 743
 744        x = null;
 745        x = 0 ? x : null;
 746        x = 0 ? null : x;
 747 }
 748
 749 /***********************************/
 750
 751 int foo42(const(char) *x, ...)
 752 {
 753     va_list ap;
 754
 755     va_start!(typeof(x))(ap, x);
 756     assert(ap != va_list.init);
 757
 758     int i;
 759     i = va_arg!(typeof(i))(ap);
 760     assert(i == 3);
 761
 762     long l;
 763     l = va_arg!(typeof(l))(ap);
 764     assert(l == 23);
 765
 766     uint k;
 767     k = va_arg!(typeof(k))(ap);
 768     assert(k == 4);
 769
 770     va_end(ap);
 771
 772     return cast(int)(i + l + k);
 773 }
 774
 775 void test42()
 776 {
 777     int j;
 778
 779     j = foo42("hello", 3, 23L, 4);
 780     printf("j = %d\n", j);
 781     assert(j == 30);
 782 }
 783
 784 /***********************************/
 785
 786 int x44;
 787
 788 class A44 {
 789      this() scope { printf("A44 ctor\n"); x44 += 1; }
 790      ~this() scope { printf("A44 dtor\n"); x44 += 0x100; }
 791 }
 792 class B44 : A44 { }
 793
 794 void foo44() { scope B44 b = new B44; }
 795
 796 void test44()
 797 {
 798      printf("foo44...\n");
 799      foo44();
 800      printf("...foo44\n");
 801      assert(x44 == 0x101);
 802 }
 803
 804 /***********************************/
 805
 806 /*
 807 import std.stdarg;
 808 import std.utf;
 809
 810 int unFormat( bool delegate( out dchar ) getc,
 811         bool delegate( dchar ) ungetc,
 812         TypeInfo[] arguments,
 813         void* argptr )
 814 {
 815     size_t  arg = 0;
 816     dchar[] fmt;
 817
 818     if( arguments[arg] is typeid( string ) )
 819         fmt = toUTF32( va_arg!(string)( argptr ) );
 820     else if( arguments[arg] is typeid( wchar[] ) )
 821         fmt = toUTF32( va_arg!(wchar[])( argptr ) );
 822     else if( arguments[arg] is typeid( dchar[] ) )
 823         fmt = va_arg!(dchar[])( argptr );
 824     else
 825         return 0;
 826 }
 827 */
 828
 829 void test45()
 830 {
 831 }
 832
 833 /***********************************/
 834
 835 int sreadf( ... )
 836 {
 837     va_arg!(string)( _argptr );
 838     return 0;
 839 }
 840
 841
 842 void test46()
 843 {
 844     printf( "hello world\n" );
 845 }
 846
 847 /***********************************/
 848
 849 void test48()
 850 {
 851   try{
 852   }finally{
 853     debug(p48) { }
 854   }
 855 }
 856
 857 /***********************************/
 858
 859 void test49()
 860 {
 861   int k = 1;
 862   if(k == 0)
 863     debug{printf("test");}
 864 }
 865
 866 /***********************************/
 867
 868 void test50()
 869 {       int x;
 870
 871         if (x)
 872              version (none)
 873                  foo;
 874 }
 875
 876 /***********************************/
 877
 878 int main()
 879 {
 880     test1();
 881     test2();
 882     test3();
 883     test4();
 884     test5();
 885     test6();
 886     test7();
 887     test8();
 888     test11();
 889     test12();
 890     test13();
 891     test14();
 892     test15();
 893     test16();
 894     test17();
 895     test20();
 896     test21();
 897     test22();
 898     test24();
 899     test25();
 900     test26();
 901     test27();
 902     test28();
 903     test29();
 904     test30();
 905     test31();
 906     test32();
 907     test33();
 908     test34();
 909     test35();
 910     test36();
 911     test37();
 912     test38();
 913     test39();
 914     test40();
 915     test42();
 916     test44();
 917     test45();
 918     test46();
 919     test48();
 920     test49();
 921     test50();
 922
 923     printf("Success\n");
 924     return 0;
 925 }