1 // RUNNABLE_PHOBOS_TEST
2 import core.stdc.stdio;
3 import std.stdio;
4
5 alias bool bit;
6
7 /************************************************/
8
9 class Foo
10 {
11 uint array[2];
12
opApply(int delegate (ref uint)dg)13 int opApply(int delegate(ref uint) dg)
14 {
15 int result;
16 for (int i = 0; i < array.length; i++)
17 {
18 result = dg(array[i]);
19 if (result)
20 break;
21 }
22 return result;
23 }
24 }
25
26
27 /**************************************************/
28
test1()29 void test1()
30 {
31 Foo a = new Foo();
32 int i;
33
34 a.array[0] = 73;
35 a.array[1] = 82;
36
37 foreach (uint u; a)
38 {
39 i++;
40 u++;
41 }
42 assert(i == 2);
43 assert(a.array[0] == 73);
44 assert(a.array[1] == 82);
45 }
46
47 /**************************************************/
48
test2()49 void test2()
50 {
51 Foo a = new Foo();
52 int i;
53
54 a.array[0] = 73;
55 a.array[1] = 82;
56
57 foreach (ref uint u; a)
58 {
59 i++;
60 u++;
61 }
62 assert(i == 2);
63 assert(a.array[0] == 74);
64 assert(a.array[1] == 83);
65 }
66
67 /**************************************************/
68
test3()69 void test3()
70 {
71 Foo a = new Foo();
72 int i;
73
74 a.array[0] = 73;
75 a.array[1] = 82;
76
77 foreach (ref uint u; a)
78 {
79 i++;
80 if (i)
81 break;
82 u++;
83 }
84 assert(i == 1);
85 assert(a.array[0] == 73);
86 assert(a.array[1] == 82);
87 }
88
89 /**************************************************/
90
test4()91 void test4()
92 {
93 Foo a = new Foo();
94 int i;
95
96 a.array[0] = 73;
97 a.array[1] = 82;
98
99 foreach (ref uint u; a)
100 {
101 i++;
102 if (i == 1)
103 continue;
104 u++;
105 }
106 assert(i == 2);
107 assert(a.array[0] == 73 && a.array[1] == 83);
108 }
109
110 /**************************************************/
111
test5()112 void test5()
113 {
114 Foo a = new Foo();
115 int i;
116
117 a.array[0] = 73;
118 a.array[1] = 82;
119
120 Loop:
121 while (1)
122 {
123 foreach (ref uint u; a)
124 {
125 i++;
126 if (i)
127 break Loop;
128 u++;
129 }
130 }
131 assert(i == 1);
132 assert(a.array[0] == 73);
133 assert(a.array[1] == 82);
134 }
135
136 /**************************************************/
137
test6()138 void test6()
139 {
140 Foo a = new Foo();
141 int i;
142
143 a.array[0] = 73;
144 a.array[1] = 82;
145
146 Loop:
147 while (1)
148 {
149 foreach (ref uint u; a)
150 {
151 i++;
152 if (i == 1)
153 continue Loop;
154 u++;
155 }
156 break;
157 }
158 assert(i == 3);
159 assert(a.array[0] == 74);
160 assert(a.array[1] == 83);
161 }
162
163 /**************************************************/
164
test7()165 void test7()
166 {
167 Foo a = new Foo();
168 int i;
169
170 a.array[0] = 73;
171 a.array[1] = 82;
172
173 foreach (ref uint u; a)
174 {
175 i++;
176 if (i)
177 goto Label;
178 u++;
179 }
180 assert(0);
181 Label:
182 assert(i == 1);
183 assert(a.array[0] == 73);
184 assert(a.array[1] == 82);
185 }
186
187 /**************************************************/
188
test8_x(Foo a)189 void test8_x(Foo a)
190 {
191 int i;
192 foreach (ref uint u; a)
193 {
194 i++;
195 if (i)
196 return;
197 u++;
198 }
199 }
200
test8()201 void test8()
202 {
203 Foo a = new Foo();
204 int i;
205
206 a.array[0] = 73;
207 a.array[1] = 82;
208
209 test8_x(a);
210 assert(i == 0);
211 assert(a.array[0] == 73);
212 assert(a.array[1] == 82);
213 }
214
215 /**************************************************/
216
test9_x(Foo a)217 int test9_x(Foo a)
218 {
219 int i;
220 foreach (ref uint u; a)
221 {
222 i++;
223 if (i)
224 return 67;
225 u++;
226 }
227 return 23;
228 }
229
test9()230 void test9()
231 {
232 Foo a = new Foo();
233 int i;
234
235 a.array[0] = 73;
236 a.array[1] = 82;
237
238 i = test9_x(a);
239 assert(i == 67);
240 assert(a.array[0] == 73);
241 assert(a.array[1] == 82);
242 }
243
244 /**************************************************/
245
test10_x(Foo a)246 int test10_x(Foo a)
247 {
248 int i;
249 foreach (ref uint u; a)
250 {
251 i++;
252 if (i)
253 return i;
254 u++;
255 }
256 return 23;
257 }
258
test10()259 void test10()
260 {
261 Foo a = new Foo();
262 int i;
263
264 a.array[0] = 73;
265 a.array[1] = 82;
266
267 i = test10_x(a);
268 assert(i == 1);
269 assert(a.array[0] == 73);
270 assert(a.array[1] == 82);
271 }
272
273 /**************************************************/
274 /+
275 the expected output:
276
277 1 1 0 0 0 1 1 0 0 0 1 1 0 0 0 1 1 0 0 0 1 1 0 0 0
278 1
279 1 1 0 1 0 1 1 0 1 0 1 1 0 1 0 1 1 0 1 0 1 1 1 1 0
280 1 1 0 1 0 1 1 0 1 0 1 1 0 1 0 1 1 0 1 0 1 1 1 1 0
281 1 1 0 1 0 1 1 0 1 0 1 1 0 1 0 1 1 0 1 0 1 1 1 1 0
282 +/
283
test11()284 void test11()
285 {
286 bit[25] data;
287 int j;
288
289 for (int i = 0; i < 25; i += 5) {
290 data[i+0] = data[i+1] = true;
291 }
292
293 for (int i = 0; i < 25; i++) {
294 printf("%d ", data[i]);
295 if ((i % 5) < 2)
296 assert(data[i] == true);
297 else
298 assert(data[i] == false);
299 }
300
301 printf("\n%d\n", data[22] = true);
302 j = data[22] = true;
303 assert(j == true);
304
305 for (int i = 0; i < 25; i += 5) {
306 data[i+1] = data[i+3] = true;
307 j = i % 5;
308 if (j == 0 || j == 1 || j == 3)
309 assert(data[i] == true);
310 else
311 assert(data[i] == false);
312 }
313
314 for (int i = 0; i < 25; i++) {
315 printf("%d ", data[i]);
316 }
317
318 printf("\n");
319
320 int k;
321 foreach (bit b; data) {
322 printf("%d ", b);
323 j = k % 5;
324 if (j == 0 || j == 1 || j == 3 || k == 22)
325 assert(data[k] == true);
326 else
327 assert(data[k] == false);
328 k++;
329 }
330 printf("\n");
331
332 foreach (int l, bit b; data) {
333 printf("%d ", b);
334 j = l % 5;
335 if (j == 0 || j == 1 || j == 3 || l == 22)
336 assert(data[l] == true);
337 else
338 assert(data[l] == false);
339 }
340 printf("\n");
341 }
342
343
344 /**************************************************/
345
test12()346 void test12()
347 {
348 int j;
349
350 j = 0;
351 foreach (dchar d; "hello")
352 {
353 printf("d = x%x\n", d);
354 if (j == 0) assert(d == 'h');
355 if (j == 1) assert(d == 'e');
356 if (j == 2) assert(d == 'l');
357 if (j == 3) assert(d == 'l');
358 if (j == 4) assert(d == 'o');
359 j++;
360 }
361 assert(j == 5);
362
363 j = 0;
364 foreach (size_t i, dchar d; "hello")
365 {
366 printf("i = %d, d = x%x\n", i, d);
367 if (j == 0) assert(d == 'h');
368 if (j == 1) assert(d == 'e');
369 if (j == 2) assert(d == 'l');
370 if (j == 3) assert(d == 'l');
371 if (j == 4) assert(d == 'o');
372 assert(i == j);
373 j++;
374 }
375 assert(j == 5);
376 }
377
378 /**************************************************/
379
test13()380 void test13()
381 {
382 int j;
383
384 j = 0;
385 foreach (wchar d; "hello")
386 {
387 printf("d = x%x\n", d);
388 if (j == 0) assert(d == 'h');
389 if (j == 1) assert(d == 'e');
390 if (j == 2) assert(d == 'l');
391 if (j == 3) assert(d == 'l');
392 if (j == 4) assert(d == 'o');
393 j++;
394 }
395 assert(j == 5);
396
397 j = 0;
398 foreach (size_t i, wchar d; "hello")
399 {
400 printf("i = %d, d = x%x\n", i, d);
401 if (j == 0) assert(d == 'h');
402 if (j == 1) assert(d == 'e');
403 if (j == 2) assert(d == 'l');
404 if (j == 3) assert(d == 'l');
405 if (j == 4) assert(d == 'o');
406 assert(i == j);
407 j++;
408 }
409 assert(j == 5);
410 }
411
412 /**************************************************/
413
test14()414 void test14()
415 {
416 int j;
417
418 j = 0;
419 foreach (char d; cast(wstring)"hello")
420 {
421 printf("d = x%x\n", d);
422 if (j == 0) assert(d == 'h');
423 if (j == 1) assert(d == 'e');
424 if (j == 2) assert(d == 'l');
425 if (j == 3) assert(d == 'l');
426 if (j == 4) assert(d == 'o');
427 j++;
428 }
429 assert(j == 5);
430
431 j = 0;
432 foreach (size_t i, char d; cast(wstring)"hello")
433 {
434 printf("i = %d, d = x%x\n", i, d);
435 if (j == 0) assert(d == 'h');
436 if (j == 1) assert(d == 'e');
437 if (j == 2) assert(d == 'l');
438 if (j == 3) assert(d == 'l');
439 if (j == 4) assert(d == 'o');
440 assert(i == j);
441 j++;
442 }
443 assert(j == 5);
444 }
445
446 /**************************************************/
447
test15()448 void test15()
449 {
450 int j;
451
452 j = 0;
453 foreach (dchar d; cast(wstring)"hello")
454 {
455 printf("d = x%x\n", d);
456 if (j == 0) assert(d == 'h');
457 if (j == 1) assert(d == 'e');
458 if (j == 2) assert(d == 'l');
459 if (j == 3) assert(d == 'l');
460 if (j == 4) assert(d == 'o');
461 j++;
462 }
463 assert(j == 5);
464
465 j = 0;
466 foreach (size_t i, dchar d; cast(wstring)"hello")
467 {
468 printf("i = %d, d = x%x\n", i, d);
469 if (j == 0) assert(d == 'h');
470 if (j == 1) assert(d == 'e');
471 if (j == 2) assert(d == 'l');
472 if (j == 3) assert(d == 'l');
473 if (j == 4) assert(d == 'o');
474 assert(i == j);
475 j++;
476 }
477 assert(j == 5);
478 }
479
480 /**************************************************/
481
test16()482 void test16()
483 {
484 int j;
485
486 j = 0;
487 foreach (char d; cast(dstring)"hello")
488 {
489 printf("d = x%x\n", d);
490 if (j == 0) assert(d == 'h');
491 if (j == 1) assert(d == 'e');
492 if (j == 2) assert(d == 'l');
493 if (j == 3) assert(d == 'l');
494 if (j == 4) assert(d == 'o');
495 j++;
496 }
497 assert(j == 5);
498
499 j = 0;
500 foreach (size_t i, char d; cast(dstring)"hello")
501 {
502 printf("i = %d, d = x%x\n", i, d);
503 if (j == 0) assert(d == 'h');
504 if (j == 1) assert(d == 'e');
505 if (j == 2) assert(d == 'l');
506 if (j == 3) assert(d == 'l');
507 if (j == 4) assert(d == 'o');
508 assert(i == j);
509 j++;
510 }
511 assert(j == 5);
512 }
513
514 /**************************************************/
515
test17()516 void test17()
517 {
518 int j;
519
520 j = 0;
521 foreach (wchar d; cast(dstring)"hello")
522 {
523 printf("d = x%x\n", d);
524 if (j == 0) assert(d == 'h');
525 if (j == 1) assert(d == 'e');
526 if (j == 2) assert(d == 'l');
527 if (j == 3) assert(d == 'l');
528 if (j == 4) assert(d == 'o');
529 j++;
530 }
531 assert(j == 5);
532
533 j = 0;
534 foreach (size_t i, wchar d; cast(dstring)"hello")
535 {
536 printf("i = %d, d = x%x\n", i, d);
537 if (j == 0) assert(d == 'h');
538 if (j == 1) assert(d == 'e');
539 if (j == 2) assert(d == 'l');
540 if (j == 3) assert(d == 'l');
541 if (j == 4) assert(d == 'o');
542 assert(i == j);
543 j++;
544 }
545 assert(j == 5);
546 }
547
548 /**************************************************/
549
test18()550 void test18()
551 {
552 string a = "\xE2\x89\xA0"; // \u2260 encoded as 3 UTF-8 bytes
553
554 foreach (dchar c; a)
555 {
556 printf("a[] = %x\n", c); // prints 'a[] = 2260'
557 assert(c == 0x2260);
558 }
559
560 dstring b = "\u2260";
561
562 int i;
563 foreach (char c; b)
564 {
565 printf("%x, ", c); // prints e2, 89, a0
566 if (i == 0) assert(c == 0xE2);
567 else if (i == 1) assert(c == 0x89);
568 else if (i == 2) assert(c == 0xA0);
569 else
570 assert(0);
571 i++;
572 }
573 printf("\n");
574 }
575
576 /**************************************************/
577
test19()578 void test19()
579 {
580 string string = x"F0 9D 83 93";
581
582 int count=0;
583 dchar tmp;
584 foreach(dchar value ; string){
585 tmp=value;
586 count++;
587 }
588 assert(count==1);
589 assert(tmp==0x01D0D3);
590 }
591
592 /**************************************************/
593
594 struct S20
595 {
opApplyS20596 int opApply(int delegate(ref int i) dg)
597 {
598 return 0;
599 }
600 }
601
602 S20 foo20;
603
test20()604 void test20()
605 {
606 label:
607 foreach(int i; foo20)
608 {
609 continue label;
610 }
611 }
612
613
614 /**************************************************/
615
foo21(string[]args)616 void foo21(string[] args)
617 {
618 printf("args.length = %d\n", args.length);
619 assert(args.length == 3);
620 foreach (i, arg; args)
621 {
622 assert(typeid(typeof(i)) == typeid(size_t));
623 assert(typeid(typeof(arg)) == typeid(string));
624 writefln("args[%d] = '%s'", i, arg);
625 }
626 foreach (arg; args)
627 {
628 assert(typeid(typeof(arg)) == typeid(string));
629 writefln("args[] = '%s'", arg);
630 }
631 }
632
test21()633 void test21()
634 {
635 string[] args;
636
637 args.length = 3;
638 args[0] = "a";
639 args[1] = "bc";
640 args[2] = "d";
641 foo21(args);
642 }
643
644 /**************************************************/
645
test22()646 void test22()
647 {
648 int[string] map;
649
650 map["hello"] = 3;
651 map["world"] = 4;
652
653 foreach (key, value; map)
654 {
655 assert(typeid(typeof(key)) == typeid(string));
656 assert(typeid(typeof(value)) == typeid(int));
657 writefln("map[%s] = %s", key, value);
658 }
659 foreach (key, int value; map)
660 {
661 assert(typeid(typeof(key)) == typeid(string));
662 assert(typeid(typeof(value)) == typeid(int));
663 writefln("map[%s] = %s", key, value);
664 }
665 foreach (string key, value; map)
666 {
667 assert(typeid(typeof(key)) == typeid(string));
668 assert(typeid(typeof(value)) == typeid(int));
669 writefln("map[%s] = %s", key, value);
670 }
671 foreach (value; map)
672 {
673 assert(typeid(typeof(value)) == typeid(int));
674 writefln("map[] = %s", value);
675 }
676 }
677
678 /**************************************************/
679
680 class Foo23
681 {
682 int array[2];
683
opApply(int delegate (ref int)dg)684 int opApply(int delegate(ref int) dg)
685 {
686 int result;
687 for (int i = 0; i < array.length; i++)
688 {
689 result = dg(array[i]);
690 if (result)
691 break;
692 }
693 return result;
694 }
695
opApply(int delegate (ref size_t,ref int)dg)696 int opApply(int delegate(ref size_t, ref int) dg)
697 {
698 int result;
699 for (size_t i = 0; i < array.length; i++)
700 {
701 result = dg(i, array[i]);
702 if (result)
703 break;
704 }
705 return result;
706 }
707 }
708
test23()709 void test23()
710 {
711 Foo23 a = new Foo23();
712 int i;
713
714 a.array[0] = 73;
715 a.array[1] = 82;
716
717 foreach (u; a)
718 {
719 assert(typeid(typeof(u)) == typeid(int));
720 i++;
721 u++;
722 //writefln("u = %d", u);
723 assert((i == 1) ? u == 74 : u == 83);
724 }
725 assert(i == 2);
726 assert(a.array[0] == 73);
727 assert(a.array[1] == 82);
728
729 foreach (j, u; a)
730 {
731 assert(typeid(typeof(j)) == typeid(size_t));
732 assert(typeid(typeof(u)) == typeid(int));
733 i++;
734 u++;
735 writefln("u = %d", u);
736 assert((i == 3) ? u == 74 : u == 83);
737 assert(j == i - 3);
738 }
739 assert(i == 4);
740 assert(a.array[0] == 73);
741 assert(a.array[1] == 82);
742 }
743
744 /**************************************************/
745
746 struct Collection24
747 {
opApplyCollection24748 int opApply(int delegate(ref int) dg){
749 return 0;
750 }
751 }
752
foo24()753 bool foo24()
754 {
755 Collection24 a,b;
756
757 foreach(int x; a){
758 foreach(int y; b){
759 return false;
760 }
761 }
762
763 return true;
764 }
765
test24()766 void test24()
767 {
768 assert(foo24() == true);
769 }
770
771 /**************************************************/
772
test25()773 void test25()
774 {
775 alias void function(string[string]) FN;
776 FN fn = function (string[string] aarray)
777 {
778 foreach (string s; aarray)
779 {
780 writeln(s);
781 assert(s == "b");
782 }
783 };
784 string[string] aarray;
785 aarray["a"] = "b";
786 fn(aarray);
787 }
788
789 /**************************************************/
790
791 struct Foo26
792 {
793 uint array[2];
794
forwardFoo26795 int forward(int delegate(ref uint) dg)
796 {
797 int result;
798 for (int i = 0; i < array.length; i++)
799 {
800 result = dg(array[i]);
801 if (result)
802 break;
803 }
804 return result;
805 }
806
forwardFoo26807 int forward(int delegate(ref uint) dg, int x) { return 1; }
808
reverseFoo26809 int reverse(int delegate(ref uint) dg, int x) { return 1; }
810
reverseFoo26811 int reverse(int delegate(ref uint) dg)
812 {
813 int result;
814 foreach_reverse (v; array)
815 {
816 auto u = v;
817 result = dg(u);
818 if (result)
819 break;
820 }
821 return result;
822 }
823 }
824
825
test26()826 void test26()
827 {
828 Foo26 a;
829 int i;
830
831 a.array[0] = 73;
832 a.array[1] = 82;
833
834 foreach (u; &a.forward)
835 {
836 writeln(u);
837 i++;
838 u++;
839 }
840 assert(i == 2);
841 assert(a.array[0] == 73);
842 assert(a.array[1] == 82);
843
844 foreach (uint u; &a.reverse)
845 {
846 writeln(u);
847 }
848 }
849
850 /**************************************************/
851
852 struct S27
853 {
854 int[] a;
855
emptyS27856 bool empty() { return a.length == 0; }
857
popFrontS27858 void popFront() { a = a[1 .. $]; }
frontS27859 int front() { return a[0]; }
860
popBackS27861 void popBack() { a = a[0 .. $ - 1]; }
backS27862 ref int back() { return a[$ - 1]; }
863 }
864
test27()865 void test27()
866 {
867 S27 s;
868 s.a = [5,6,7];
869 string r;
870
871 foreach (e; s)
872 {
873 printf("%d\n", e);
874 r ~= cast(char)(e + '0');
875 }
876 assert(r == "567");
877
878 r = null;
879 foreach_reverse (ref e; s)
880 {
881 e++;
882 printf("%d\n", e);
883 r ~= cast(char)(e + '0');
884 }
885 assert(r == "876");
886
887 r = null;
888 foreach (e; s)
889 {
890 printf("%d\n", e);
891 r ~= cast(char)(e + '0');
892 }
893 assert(r == "678");
894 }
895
896 /**************************************************/
897
main()898 int main()
899 {
900 test1();
901 test2();
902 test3();
903 test4();
904 test5();
905 test6();
906 test7();
907 test8();
908 test9();
909 test10();
910 test11();
911 test12();
912 test13();
913 test14();
914 test15();
915 test16();
916 test17();
917 test18();
918 test19();
919 test20();
920 test21();
921 test22();
922 test23();
923 test24();
924 test25();
925 test26();
926 test27();
927
928 printf("Success\n");
929 return 0;
930 }
931