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
func1(int dim)11 char[] func1(int dim)
12 {
13 char[] a = new char[dim];
14
15 b1 = a;
16 return a;
17 }
18
test1()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
func2(int dim)78 short[] func2(int dim)
79 {
80 short[] a = new short[dim];
81
82 b2 = a;
83 return a;
84 }
85
test2()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
func3(int dim)145 int[] func3(int dim)
146 {
147 int[] a = new int[dim];
148
149 b3 = a;
150 return a;
151 }
152
test3()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
func4(int dim)212 long[] func4(int dim)
213 {
214 long[] a = new long[dim];
215
216 b4 = a;
217 return a;
218 }
219
test4()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
func5(int dim)279 real[] func5(int dim)
280 {
281 real[] a = new real[dim];
282
283 b5 = a;
284 return a;
285 }
286
test5()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
func6(int dim)355 ABC[] func6(int dim)
356 {
357 ABC[] a = new ABC[dim];
358
359 b6 = a;
360 return a;
361 }
362
test6()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
func7(int dim)422 bool[] func7(int dim)
423 {
424 bool[] a = new bool[dim];
425
426 b7 = a;
427 return a;
428 }
429
test7()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
slice8(bool[]b)500 bool[] slice8(bool[] b)
501 {
502 return b[8..16];
503 }
504
test8()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
slice9(bool[]b,int i,int j)520 bool[] slice9(bool[] b, int i, int j)
521 {
522 return b[i..j];
523 }
524
test9()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
foo10(bool[]b,int i)544 bool* foo10(bool[] b, int i)
545 {
546 return &b[i];
547 }
548
test10()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
foo11(bool[]b,int i)564 bool* foo11(bool[] b, int i)
565 {
566 return &b[i];
567 }
568
test11()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
foo12(bool[]b,int i)585 bool* foo12(bool[] b, int i)
586 {
587 return &b[i];
588 }
589
test12()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
foo13(bool * b,int i)606 bool* foo13(bool* b, int i)
607 {
608 return &b[i];
609 }
610
test13()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
test14()626 void test14()
627 {
628 bool b = true;
629 assert(b);
630 b = !b;
631 assert(!b);
632 }
633
634 /**************************************/
635
test15()636 void test15()
637 {
638 bool b = 1;
639 bool *pb = &b;
640 *pb = false;
641 assert(!b);
642 }
643
644
645 /**************************************/
646
foo16(bool[]b1,bool[]b2)647 void foo16(bool[] b1, bool[] b2)
648 {
649 b1[0..3] = b2[8..11];
650 }
651
test16()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
test17()671 void test17()
672 {
673 bool bi = true;
674 byte by;
675
676 by=bi;
677 assert(by == 1);
678 }
679
680
681 /**************************************/
682
test18()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
test19()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
main()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 }
735