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

   1 // PERMUTE_ARGS:
   2
   3 // Test memset style array assignments.
   4
   5 extern(C) int printf(const char*, ...);
   6
   7 /**************************************/
   8
   9 char[] b1;
  10
  11 char[] func1(int dim)
  12 {
  13     char[] a = new char[dim];
  14
  15     b1 = a;
  16     return a;
  17 }
  18
  19 void test1()
  20 {
  21     printf("test1()\n");
  22     int i;
  23     int j;
  24
  25     char[1] a1;
  26     a1[] = 'x';
  27     assert(a1[0] == 'x');
  28
  29     char[2] a2;
  30     a2[] = 'x';
  31     for (i = 0; i < a2.length; i++)
  32         assert(a2[i] == 'x');
  33
  34     char[3] a3;
  35     a3[] = 'x';
  36     for (i = 0; i < a3.length; i++)
  37         assert(a3[i] == 'x');
  38
  39     char[4] a4;
  40     a4[] = 'x';
  41     for (i = 0; i < a4.length; i++)
  42         assert(a4[i] == 'x');
  43
  44     char[8] a8;
  45     a8[] = 'x';
  46     for (i = 0; i < a8.length; i++)
  47         assert(a8[i] == 'x');
  48
  49     char[27] a27;
  50     a27[] = 'x';
  51     for (i = 0; i < a27.length; i++)
  52         assert(a27[i] == 'x');
  53
  54     func1(33)[] = 'y';
  55     for (i = 0; i < b1.length; i++)
  56         assert(b1[i] == 'y');
  57
  58
  59     char[23] a23 = 'x';
  60     i = 16;
  61     j = 18;
  62     a23[i++..++j] = 'c';
  63     printf("i = %d, j = %d\n", i, j);
  64     assert(i == 17);
  65     assert(j == 19);
  66     assert(a23[15] == 'x');
  67     assert(a23[16] == 'c');
  68     assert(a23[17] == 'c');
  69     assert(a23[18] == 'c');
  70     assert(a23[19] == 'x');
  71     assert(a23[20] == 'x');
  72 }
  73
  74 /**************************************/
  75
  76 short[] b2;
  77
  78 short[] func2(int dim)
  79 {
  80     short[] a = new short[dim];
  81
  82     b2 = a;
  83     return a;
  84 }
  85
  86 void test2()
  87 {
  88     printf("test2()\n");
  89     int i;
  90     int j;
  91
  92     short[1] a1;
  93     a1[] = 0x1234;
  94     assert(a1[0] == 0x1234);
  95
  96     short[2] a2;
  97     a2[] = 0x1234;
  98     for (i = 0; i < a2.length; i++)
  99         assert(a2[i] == 0x1234);
 100
 101     short[3] a3;
 102     a3[] = 0x1234;
 103     for (i = 0; i < a3.length; i++)
 104         assert(a3[i] == 0x1234);
 105
 106     short[4] a4;
 107     a4[] = 0x1234;
 108     for (i = 0; i < a4.length; i++)
 109         assert(a4[i] == 0x1234);
 110
 111     short[8] a8;
 112     a8[] = 0x1234;
 113     for (i = 0; i < a8.length; i++)
 114         assert(a8[i] == 0x1234);
 115
 116     short[27] a27;
 117     a27[] = 0x1234;
 118     for (i = 0; i < a27.length; i++)
 119         assert(a27[i] == 0x1234);
 120
 121     func2(33)[] = 0x5678;
 122     for (i = 0; i < b2.length; i++)
 123         assert(b2[i] == 0x5678);
 124
 125
 126     short[23] a23 = 0x1234;
 127     i = 16;
 128     j = 18;
 129     a23[i++..++j] = 0x4554;
 130     printf("i = %d, j = %d\n", i, j);
 131     assert(i == 17);
 132     assert(j == 19);
 133     assert(a23[15] == 0x1234);
 134     assert(a23[16] == 0x4554);
 135     assert(a23[17] == 0x4554);
 136     assert(a23[18] == 0x4554);
 137     assert(a23[19] == 0x1234);
 138     assert(a23[20] == 0x1234);
 139 }
 140
 141 /**************************************/
 142
 143 int[] b3;
 144
 145 int[] func3(int dim)
 146 {
 147     int[] a = new int[dim];
 148
 149     b3 = a;
 150     return a;
 151 }
 152
 153 void test3()
 154 {
 155     printf("test3()\n");
 156     int i;
 157     int j;
 158
 159     int[1] a1;
 160     a1[] = 0x12345678;
 161     assert(a1[0] == 0x12345678);
 162
 163     int[2] a2;
 164     a2[] = 0x12345678;
 165     for (i = 0; i < a2.length; i++)
 166         assert(a2[i] == 0x12345678);
 167
 168     int[3] a3;
 169     a3[] = 0x12345678;
 170     for (i = 0; i < a3.length; i++)
 171         assert(a3[i] == 0x12345678);
 172
 173     int[4] a4;
 174     a4[] = 0x12345678;
 175     for (i = 0; i < a4.length; i++)
 176         assert(a4[i] == 0x12345678);
 177
 178     int[8] a8;
 179     a8[] = 0x12345678;
 180     for (i = 0; i < a8.length; i++)
 181         assert(a8[i] == 0x12345678);
 182
 183     int[27] a27;
 184     a27[] = 0x12345678;
 185     for (i = 0; i < a27.length; i++)
 186         assert(a27[i] == 0x12345678);
 187
 188     func3(33)[] = 0x56781234;
 189     for (i = 0; i < b3.length; i++)
 190         assert(b3[i] == 0x56781234);
 191
 192
 193     int[23] a23 = 0x12345678;
 194     i = 16;
 195     j = 18;
 196     a23[i++..++j] = 0x45546776;
 197     printf("i = %d, j = %d\n", i, j);
 198     assert(i == 17);
 199     assert(j == 19);
 200     assert(a23[15] == 0x12345678);
 201     assert(a23[16] == 0x45546776);
 202     assert(a23[17] == 0x45546776);
 203     assert(a23[18] == 0x45546776);
 204     assert(a23[19] == 0x12345678);
 205     assert(a23[20] == 0x12345678);
 206 }
 207
 208 /**************************************/
 209
 210 long[] b4;
 211
 212 long[] func4(int dim)
 213 {
 214     long[] a = new long[dim];
 215
 216     b4 = a;
 217     return a;
 218 }
 219
 220 void test4()
 221 {
 222     printf("test4()\n");
 223     int i;
 224     int j;
 225
 226     long[1] a1;
 227     a1[] = 0x123456789ABCDEF0;
 228     assert(a1[0] == 0x123456789ABCDEF0);
 229
 230     long[2] a2;
 231     a2[] = 0x123456789ABCDEF0;
 232     for (i = 0; i < a2.length; i++)
 233         assert(a2[i] == 0x123456789ABCDEF0);
 234
 235     long[3] a3;
 236     a3[] = 0x123456789ABCDEF0;
 237     for (i = 0; i < a3.length; i++)
 238         assert(a3[i] == 0x123456789ABCDEF0);
 239
 240     long[4] a4;
 241     a4[] = 0x123456789ABCDEF0;
 242     for (i = 0; i < a4.length; i++)
 243         assert(a4[i] == 0x123456789ABCDEF0);
 244
 245     long[8] a8;
 246     a8[] = 0x123456789ABCDEF0;
 247     for (i = 0; i < a8.length; i++)
 248         assert(a8[i] == 0x123456789ABCDEF0);
 249
 250     long[27] a27;
 251     a27[] = 0x123456789ABCDEF0;
 252     for (i = 0; i < a27.length; i++)
 253         assert(a27[i] == 0x123456789ABCDEF0);
 254
 255     func4(33)[] = 0x5678889911223344;
 256     for (i = 0; i < b4.length; i++)
 257         assert(b4[i] == 0x5678889911223344);
 258
 259
 260     long[23] a23 = 0x123456789ABCDEF0;
 261     i = 16;
 262     j = 18;
 263     a23[i++..++j] = 0x567888991122334B;
 264     printf("i = %d, j = %d\n", i, j);
 265     assert(i == 17);
 266     assert(j == 19);
 267     assert(a23[15] == 0x123456789ABCDEF0);
 268     assert(a23[16] == 0x567888991122334B);
 269     assert(a23[17] == 0x567888991122334B);
 270     assert(a23[18] == 0x567888991122334B);
 271     assert(a23[19] == 0x123456789ABCDEF0);
 272     assert(a23[20] == 0x123456789ABCDEF0);
 273 }
 274
 275 /**************************************/
 276
 277 real[] b5;
 278
 279 real[] func5(int dim)
 280 {
 281     real[] a = new real[dim];
 282
 283     b5 = a;
 284     return a;
 285 }
 286
 287 void test5()
 288 {
 289     printf("test5()\n");
 290     int i;
 291     int j;
 292
 293     real[1] a1;
 294     a1[] = 31234;
 295     assert(a1[0] == 31234);
 296
 297     real[2] a2;
 298     a2[] = 31234;
 299     for (i = 0; i < a2.length; i++)
 300         assert(a2[i] == 31234);
 301
 302     real[3] a3;
 303     a3[] = 31234;
 304     for (i = 0; i < a3.length; i++)
 305         assert(a3[i] == 31234);
 306
 307     real[4] a4;
 308     a4[] = 31234;
 309     for (i = 0; i < a4.length; i++)
 310         assert(a4[i] == 31234);
 311
 312     real[8] a8;
 313     a8[] = 31234;
 314     for (i = 0; i < a8.length; i++)
 315         assert(a8[i] == 31234);
 316
 317     real[27] a27;
 318     a27[] = 31234;
 319     for (i = 0; i < a27.length; i++)
 320         assert(a27[i] == 31234);
 321
 322     func5(33)[] = 35678;
 323     for (i = 0; i < b5.length; i++)
 324         assert(b5[i] == 35678);
 325
 326
 327     real[23] a23 = 31234;
 328     i = 16;
 329     j = 18;
 330     a23[i++..++j] = 34554e+4;
 331     printf("i = %d, j = %d\n", i, j);
 332     assert(i == 17);
 333     assert(j == 19);
 334     assert(a23[15] == 31234);
 335     assert(a23[16] == 34554e+4);
 336     assert(a23[17] == 34554e+4);
 337     assert(a23[18] == 34554e+4);
 338     assert(a23[19] == 31234);
 339     assert(a23[20] == 31234);
 340 }
 341
 342 /**************************************/
 343
 344 struct ABC
 345 {
 346     int a,b,c,d;
 347 }
 348
 349 ABC abc1 = { a:1, b:2, c:3, d:4 };
 350 ABC abc2 = { a:7, b:6, c:8, d:9 };
 351 ABC abc3 = { a:5, b:10, c:11, d:12 };
 352
 353 ABC[] b6;
 354
 355 ABC[] func6(int dim)
 356 {
 357     ABC[] a = new ABC[dim];
 358
 359     b6 = a;
 360     return a;
 361 }
 362
 363 void test6()
 364 {
 365     printf("test6()\n");
 366     int i;
 367     int j;
 368
 369     ABC[1] a1;
 370     a1[] = abc1;
 371     assert(a1[0] == abc1);
 372
 373     ABC[2] a2;
 374     a2[] = abc1;
 375     for (i = 0; i < a2.length; i++)
 376         assert(a2[i] == abc1);
 377
 378     ABC[3] a3;
 379     a3[] = abc1;
 380     for (i = 0; i < a3.length; i++)
 381         assert(a3[i] == abc1);
 382
 383     ABC[4] a4;
 384     a4[] = abc1;
 385     for (i = 0; i < a4.length; i++)
 386         assert(a4[i] == abc1);
 387
 388     ABC[8] a8;
 389     a8[] = abc1;
 390     for (i = 0; i < a8.length; i++)
 391         assert(a8[i] == abc1);
 392
 393     ABC[27] a27;
 394     a27[] = abc1;
 395     for (i = 0; i < a27.length; i++)
 396         assert(a27[i] == abc1);
 397
 398     func6(33)[] = abc2;
 399     for (i = 0; i < b6.length; i++)
 400         assert(b6[i] == abc2);
 401
 402
 403     ABC[23] a23 = abc1;
 404     i = 16;
 405     j = 18;
 406     a23[i++..++j] = abc3;
 407     printf("i = %d, j = %d\n", i, j);
 408     assert(i == 17);
 409     assert(j == 19);
 410     assert(a23[15] == abc1);
 411     assert(a23[16] == abc3);
 412     assert(a23[17] == abc3);
 413     assert(a23[18] == abc3);
 414     assert(a23[19] == abc1);
 415     assert(a23[20] == abc1);
 416 }
 417
 418 /**************************************/
 419
 420 bool[] b7;
 421
 422 bool[] func7(int dim)
 423 {
 424     bool[] a = new bool[dim];
 425
 426     b7 = a;
 427     return a;
 428 }
 429
 430 void test7()
 431 {
 432     printf("test7()\n");
 433     int i;
 434     int j;
 435
 436     bool[1] a1;
 437     a1[] = 1;
 438     assert(a1[0] == 1);
 439
 440     bool[2] a2;
 441     a2[] = 1;
 442     for (i = 0; i < a2.length; i++)
 443         assert(a2[i] == 1);
 444
 445     bool[3] a3;
 446     a3[] = 1;
 447     for (i = 0; i < a3.length; i++)
 448         assert(a3[i] == 1);
 449
 450     bool[4] a4;
 451     a4[] = 1;
 452     for (i = 0; i < a4.length; i++)
 453         assert(a4[i] == 1);
 454
 455     bool[8] a8;
 456     a8[] = 1;
 457     for (i = 0; i < a8.length; i++)
 458         assert(a8[i] == 1);
 459
 460     bool[27] a27;
 461     a27[] = 1;
 462     for (i = 0; i < a27.length; i++)
 463         assert(a27[i] == 1);
 464
 465     func7(33)[] = 1;
 466     assert(b7.length == 33);
 467     for (i = 0; i < b7.length; i++)
 468         assert(b7[i] == 1);
 469
 470     func7(33)[3..6] = 1;
 471     //printf("b7.ptr = %p, b7.length = %d\n", b7.ptr, b7.length);
 472     assert(b7.length == 33);
 473     for (i = 0; i < b7.length; i++)
 474     {
 475         //printf("b7[%d] = %d\n", i, b7[i]);
 476         if (i >= 3 && i < 6)
 477             assert(b7[i] == 1);
 478         else
 479             assert(b7[i] == 0);
 480     }
 481
 482     bool[23] a23 = 1;
 483     i = 16;
 484     j = 18;
 485     a23[i++..++j] = 0;
 486     printf("i = %d, j = %d\n", i, j);
 487     assert(i == 17);
 488     assert(j == 19);
 489     assert(a23[15] == 1);
 490     assert(a23[16] == 0);
 491     assert(a23[17] == 0);
 492     assert(a23[18] == 0);
 493     assert(a23[19] == 1);
 494     assert(a23[20] == 1);
 495
 496 }
 497
 498 /**************************************/
 499
 500 bool[] slice8(bool[] b)
 501 {
 502     return b[8..16];
 503 }
 504
 505 void test8()
 506 {
 507     bool[16] b;
 508     bool[] b2;
 509     b[9] = true;
 510     b2 = slice8(b);
 511     assert(b2.length == 8);
 512     assert(b2[1] == true);
 513     b[9] = false;
 514     assert(b2[1] == false);
 515 }
 516
 517
 518 /**************************************/
 519
 520 bool[] slice9(bool[] b, int i, int j)
 521 {
 522     return b[i..j];
 523 }
 524
 525 void test9()
 526 {
 527     bool[17] b;
 528     bool[] b2;
 529     b[9] = true;
 530     b[16] = true;
 531     b2 = slice9(b,8,17);
 532     assert(b2.length == 9);
 533     assert(b2[1] == true);
 534     assert(b2[8] == true);
 535     b[9] = false;
 536     b[16] = false;
 537     assert(b2[1] == false);
 538     assert(b2[8] == false);
 539 }
 540
 541
 542 /**************************************/
 543
 544 bool* foo10(bool[] b, int i)
 545 {
 546     return &b[i];
 547 }
 548
 549 void test10()
 550 {
 551     bool[17] b;
 552     bool* pb;
 553
 554     b[8] = true;
 555     b[9] = true;
 556     pb = foo10(b, 8);
 557     assert(*pb == true);
 558     b[8] = false;
 559     assert(*pb == false);
 560 }
 561
 562 /**************************************/
 563
 564 bool* foo11(bool[] b, int i)
 565 {
 566     return &b[i];
 567 }
 568
 569 void test11()
 570 {
 571     bool[17] b;
 572     bool* pb;
 573
 574     b[9] = true;
 575     b[10] = true;
 576     pb = foo11(b, 8);
 577     assert(pb[1] == true);
 578     b[9] = false;
 579     assert(pb[1] == false);
 580 }
 581
 582
 583 /**************************************/
 584
 585 bool* foo12(bool[] b, int i)
 586 {
 587     return &b[i];
 588 }
 589
 590 void test12()
 591 {
 592     bool[17] b;
 593     bool* pb;
 594
 595     b[9] = true;
 596     b[10] = true;
 597     pb = foo12(b, 0);
 598     pb = pb + 8;
 599     assert(pb[1] == true);
 600     b[9] = false;
 601     assert(pb[1] == false);
 602 }
 603
 604 /**************************************/
 605
 606 bool* foo13(bool* b, int i)
 607 {
 608     return &b[i];
 609 }
 610
 611 void test13()
 612 {
 613     bool[17] b;
 614     bool* pb;
 615
 616     b[9] = true;
 617     b[10] = true;
 618     pb = foo13(b.ptr, 8);
 619     assert(pb[1] == true);
 620     b[9] = false;
 621     assert(pb[1] == false);
 622 }
 623
 624 /**************************************/
 625
 626 void test14()
 627 {
 628     bool b = true;
 629     assert(b);
 630     b = !b;
 631     assert(!b);
 632 }
 633
 634 /**************************************/
 635
 636 void test15()
 637 {
 638    bool b = 1;
 639    bool *pb = &b;
 640    *pb = false;
 641    assert(!b);
 642 }
 643
 644
 645 /**************************************/
 646
 647 void foo16(bool[] b1, bool[] b2)
 648 {
 649     b1[0..3] = b2[8..11];
 650 }
 651
 652 void test16()
 653 {
 654     static bool[16] b1 = [1,1,0,1,0,0,0,0];
 655     static bool[16] b2 = [0,0,0,0,0,0,0,0, 0,0,1,0,1,1,1,1];
 656
 657     foo16(b1, b2);
 658     assert(b1[0] == false);
 659     assert(b1[1] == false);
 660     assert(b1[2] == true);
 661     assert(b1[3] == true);
 662     assert(b1[4] == false);
 663     assert(b1[5] == false);
 664     assert(b1[6] == false);
 665     assert(b1[7] == false);
 666     assert(b1[8] == false);
 667 }
 668
 669 /**************************************/
 670
 671 void test17()
 672 {
 673   bool bi = true;
 674   byte by;
 675
 676   by=bi;
 677   assert(by == 1);
 678 }
 679
 680
 681 /**************************************/
 682
 683 void test18()
 684 {
 685     bool b = 1;
 686     bool c = 1;
 687     b |= cast(bool)(3 + c);
 688     assert(b == true);
 689 }
 690
 691
 692 /**************************************/
 693
 694 void test19()
 695 {
 696         int i;
 697         for (i = 0; i < 10; i++){
 698                 version(dummy) i=22;
 699         }
 700         assert(i==10);
 701
 702         char[][] args;
 703         foreach(char[] p; args){
 704                 version(dummy) int i;
 705         }
 706 }
 707
 708 /**************************************/
 709
 710 int main()
 711 {
 712     test1();
 713     test2();
 714     test3();
 715     test4();
 716     test5();
 717     test6();
 718     test7();
 719     test8();
 720     test9();
 721     test10();
 722     test11();
 723     test12();
 724     test13();
 725     test14();
 726     test15();
 727     test16();
 728     test17();
 729     test18();
 730     test19();
 731
 732     printf("Success\n");
 733     return 0;
 734 }