blob: f2e19439647b378b0250b3b0208813e2834ba3b2 [file] [log] [blame]
import core.stdc.stdio;
alias bool bit;
/************************************************/
class Foo
{
uint[2] array;
int opApply(int delegate(ref uint) dg)
{
int result;
for (int i = 0; i < array.length; i++)
{
result = dg(array[i]);
if (result)
break;
}
return result;
}
}
/**************************************************/
void test1()
{
Foo a = new Foo();
int i;
a.array[0] = 73;
a.array[1] = 82;
foreach (uint u; a)
{
i++;
u++;
}
assert(i == 2);
assert(a.array[0] == 73);
assert(a.array[1] == 82);
}
/**************************************************/
void test2()
{
Foo a = new Foo();
int i;
a.array[0] = 73;
a.array[1] = 82;
foreach (ref uint u; a)
{
i++;
u++;
}
assert(i == 2);
assert(a.array[0] == 74);
assert(a.array[1] == 83);
}
/**************************************************/
void test3()
{
Foo a = new Foo();
int i;
a.array[0] = 73;
a.array[1] = 82;
foreach (ref uint u; a)
{
i++;
if (i)
break;
u++;
}
assert(i == 1);
assert(a.array[0] == 73);
assert(a.array[1] == 82);
}
/**************************************************/
void test4()
{
Foo a = new Foo();
int i;
a.array[0] = 73;
a.array[1] = 82;
foreach (ref uint u; a)
{
i++;
if (i == 1)
continue;
u++;
}
assert(i == 2);
assert(a.array[0] == 73 && a.array[1] == 83);
}
/**************************************************/
void test5()
{
Foo a = new Foo();
int i;
a.array[0] = 73;
a.array[1] = 82;
Loop:
while (1)
{
foreach (ref uint u; a)
{
i++;
if (i)
break Loop;
u++;
}
}
assert(i == 1);
assert(a.array[0] == 73);
assert(a.array[1] == 82);
}
/**************************************************/
void test6()
{
Foo a = new Foo();
int i;
a.array[0] = 73;
a.array[1] = 82;
Loop:
while (1)
{
foreach (ref uint u; a)
{
i++;
if (i == 1)
continue Loop;
u++;
}
break;
}
assert(i == 3);
assert(a.array[0] == 74);
assert(a.array[1] == 83);
}
/**************************************************/
void test7()
{
Foo a = new Foo();
int i;
a.array[0] = 73;
a.array[1] = 82;
foreach (ref uint u; a)
{
i++;
if (i)
goto Label;
u++;
}
assert(0);
Label:
assert(i == 1);
assert(a.array[0] == 73);
assert(a.array[1] == 82);
}
/**************************************************/
void test8_x(Foo a)
{
int i;
foreach (ref uint u; a)
{
i++;
if (i)
return;
u++;
}
}
void test8()
{
Foo a = new Foo();
int i;
a.array[0] = 73;
a.array[1] = 82;
test8_x(a);
assert(i == 0);
assert(a.array[0] == 73);
assert(a.array[1] == 82);
}
/**************************************************/
int test9_x(Foo a)
{
int i;
foreach (ref uint u; a)
{
i++;
if (i)
return 67;
u++;
}
return 23;
}
void test9()
{
Foo a = new Foo();
int i;
a.array[0] = 73;
a.array[1] = 82;
i = test9_x(a);
assert(i == 67);
assert(a.array[0] == 73);
assert(a.array[1] == 82);
}
/**************************************************/
int test10_x(Foo a)
{
int i;
foreach (ref uint u; a)
{
i++;
if (i)
return i;
u++;
}
return 23;
}
void test10()
{
Foo a = new Foo();
int i;
a.array[0] = 73;
a.array[1] = 82;
i = test10_x(a);
assert(i == 1);
assert(a.array[0] == 73);
assert(a.array[1] == 82);
}
/**************************************************/
/+
the expected output:
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
1
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
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
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
+/
void test11()
{
bit[25] data;
int j;
for (int i = 0; i < 25; i += 5) {
data[i+0] = data[i+1] = true;
}
for (int i = 0; i < 25; i++) {
printf("%d ", data[i]);
if ((i % 5) < 2)
assert(data[i] == true);
else
assert(data[i] == false);
}
printf("\n%d\n", data[22] = true);
j = data[22] = true;
assert(j == true);
for (int i = 0; i < 25; i += 5) {
data[i+1] = data[i+3] = true;
j = i % 5;
if (j == 0 || j == 1 || j == 3)
assert(data[i] == true);
else
assert(data[i] == false);
}
for (int i = 0; i < 25; i++) {
printf("%d ", data[i]);
}
printf("\n");
int k;
foreach (bit b; data) {
printf("%d ", b);
j = k % 5;
if (j == 0 || j == 1 || j == 3 || k == 22)
assert(data[k] == true);
else
assert(data[k] == false);
k++;
}
printf("\n");
foreach (int l, bit b; data) {
printf("%d ", b);
j = l % 5;
if (j == 0 || j == 1 || j == 3 || l == 22)
assert(data[l] == true);
else
assert(data[l] == false);
}
printf("\n");
}
/**************************************************/
void test12()
{
int j;
j = 0;
foreach (dchar d; "hello")
{
printf("d = x%x\n", d);
if (j == 0) assert(d == 'h');
if (j == 1) assert(d == 'e');
if (j == 2) assert(d == 'l');
if (j == 3) assert(d == 'l');
if (j == 4) assert(d == 'o');
j++;
}
assert(j == 5);
j = 0;
foreach (size_t i, dchar d; "hello")
{
printf("i = %d, d = x%x\n", cast(int)i, d);
if (j == 0) assert(d == 'h');
if (j == 1) assert(d == 'e');
if (j == 2) assert(d == 'l');
if (j == 3) assert(d == 'l');
if (j == 4) assert(d == 'o');
assert(i == j);
j++;
}
assert(j == 5);
}
/**************************************************/
void test13()
{
int j;
j = 0;
foreach (wchar d; "hello")
{
printf("d = x%x\n", d);
if (j == 0) assert(d == 'h');
if (j == 1) assert(d == 'e');
if (j == 2) assert(d == 'l');
if (j == 3) assert(d == 'l');
if (j == 4) assert(d == 'o');
j++;
}
assert(j == 5);
j = 0;
foreach (size_t i, wchar d; "hello")
{
printf("i = %d, d = x%x\n", cast(int)i, d);
if (j == 0) assert(d == 'h');
if (j == 1) assert(d == 'e');
if (j == 2) assert(d == 'l');
if (j == 3) assert(d == 'l');
if (j == 4) assert(d == 'o');
assert(i == j);
j++;
}
assert(j == 5);
}
/**************************************************/
void test14()
{
int j;
j = 0;
foreach (char d; cast(wstring)"hello")
{
printf("d = x%x\n", d);
if (j == 0) assert(d == 'h');
if (j == 1) assert(d == 'e');
if (j == 2) assert(d == 'l');
if (j == 3) assert(d == 'l');
if (j == 4) assert(d == 'o');
j++;
}
assert(j == 5);
j = 0;
foreach (size_t i, char d; cast(wstring)"hello")
{
printf("i = %d, d = x%x\n", cast(int)i, d);
if (j == 0) assert(d == 'h');
if (j == 1) assert(d == 'e');
if (j == 2) assert(d == 'l');
if (j == 3) assert(d == 'l');
if (j == 4) assert(d == 'o');
assert(i == j);
j++;
}
assert(j == 5);
}
/**************************************************/
void test15()
{
int j;
j = 0;
foreach (dchar d; cast(wstring)"hello")
{
printf("d = x%x\n", d);
if (j == 0) assert(d == 'h');
if (j == 1) assert(d == 'e');
if (j == 2) assert(d == 'l');
if (j == 3) assert(d == 'l');
if (j == 4) assert(d == 'o');
j++;
}
assert(j == 5);
j = 0;
foreach (size_t i, dchar d; cast(wstring)"hello")
{
printf("i = %d, d = x%x\n", cast(int)i, d);
if (j == 0) assert(d == 'h');
if (j == 1) assert(d == 'e');
if (j == 2) assert(d == 'l');
if (j == 3) assert(d == 'l');
if (j == 4) assert(d == 'o');
assert(i == j);
j++;
}
assert(j == 5);
}
/**************************************************/
void test16()
{
int j;
j = 0;
foreach (char d; cast(dstring)"hello")
{
printf("d = x%x\n", d);
if (j == 0) assert(d == 'h');
if (j == 1) assert(d == 'e');
if (j == 2) assert(d == 'l');
if (j == 3) assert(d == 'l');
if (j == 4) assert(d == 'o');
j++;
}
assert(j == 5);
j = 0;
foreach (size_t i, char d; cast(dstring)"hello")
{
printf("i = %d, d = x%x\n", cast(int)i, d);
if (j == 0) assert(d == 'h');
if (j == 1) assert(d == 'e');
if (j == 2) assert(d == 'l');
if (j == 3) assert(d == 'l');
if (j == 4) assert(d == 'o');
assert(i == j);
j++;
}
assert(j == 5);
}
/**************************************************/
void test17()
{
int j;
j = 0;
foreach (wchar d; cast(dstring)"hello")
{
printf("d = x%x\n", d);
if (j == 0) assert(d == 'h');
if (j == 1) assert(d == 'e');
if (j == 2) assert(d == 'l');
if (j == 3) assert(d == 'l');
if (j == 4) assert(d == 'o');
j++;
}
assert(j == 5);
j = 0;
foreach (size_t i, wchar d; cast(dstring)"hello")
{
printf("i = %d, d = x%x\n", cast(int)i, d);
if (j == 0) assert(d == 'h');
if (j == 1) assert(d == 'e');
if (j == 2) assert(d == 'l');
if (j == 3) assert(d == 'l');
if (j == 4) assert(d == 'o');
assert(i == j);
j++;
}
assert(j == 5);
}
/**************************************************/
void test18()
{
string a = "\xE2\x89\xA0"; // \u2260 encoded as 3 UTF-8 bytes
foreach (dchar c; a)
{
printf("a[] = %x\n", c); // prints 'a[] = 2260'
assert(c == 0x2260);
}
dstring b = "\u2260";
int i;
foreach (char c; b)
{
printf("%x, ", c); // prints e2, 89, a0
if (i == 0) assert(c == 0xE2);
else if (i == 1) assert(c == 0x89);
else if (i == 2) assert(c == 0xA0);
else
assert(0);
i++;
}
printf("\n");
}
/**************************************************/
void test19()
{
string string = "\xF0\x9D\x83\x93";
int count=0;
dchar tmp;
foreach(dchar value ; string){
tmp=value;
count++;
}
assert(count==1);
assert(tmp==0x01D0D3);
}
/**************************************************/
struct S20
{
int opApply(int delegate(ref int i) dg)
{
return 0;
}
}
S20 foo20;
void test20()
{
label:
foreach(int i; foo20)
{
continue label;
}
}
/**************************************************/
void foo21(string[] args)
{
printf("args.length = %d\n", cast(int)args.length);
assert(args.length == 3);
foreach (i, arg; args)
{
assert(typeid(typeof(i)) == typeid(size_t));
assert(typeid(typeof(arg)) == typeid(string));
printf("args[%d] = '%.*s'\n", cast(int)i, cast(int)arg.length, arg.ptr);
}
foreach (arg; args)
{
assert(typeid(typeof(arg)) == typeid(string));
printf("args[] = '%.*s'\n", cast(int)arg.length, arg.ptr);
}
}
void test21()
{
string[] args;
args.length = 3;
args[0] = "a";
args[1] = "bc";
args[2] = "d";
foo21(args);
}
/**************************************************/
void test22()
{
int[string] map;
map["hello"] = 3;
map["world"] = 4;
foreach (key, value; map)
{
assert(typeid(typeof(key)) == typeid(string));
assert(typeid(typeof(value)) == typeid(int));
printf("map[%.*s] = %d\n", cast(int)key.length, key.ptr, value);
}
foreach (key, int value; map)
{
assert(typeid(typeof(key)) == typeid(string));
assert(typeid(typeof(value)) == typeid(int));
printf("map[%.*s] = %d\n", cast(int)key.length, key.ptr, value);
}
foreach (string key, value; map)
{
assert(typeid(typeof(key)) == typeid(string));
assert(typeid(typeof(value)) == typeid(int));
printf("map[%.*s] = %d\n", cast(int)key.length, key.ptr, value);
}
foreach (value; map)
{
assert(typeid(typeof(value)) == typeid(int));
printf("map[] = %d\n", value);
}
}
/**************************************************/
class Foo23
{
int[2] array;
int opApply(int delegate(ref int) dg)
{
int result;
for (int i = 0; i < array.length; i++)
{
result = dg(array[i]);
if (result)
break;
}
return result;
}
int opApply(int delegate(ref size_t, ref int) dg)
{
int result;
for (size_t i = 0; i < array.length; i++)
{
result = dg(i, array[i]);
if (result)
break;
}
return result;
}
}
void test23()
{
Foo23 a = new Foo23();
int i;
a.array[0] = 73;
a.array[1] = 82;
foreach (u; a)
{
assert(typeid(typeof(u)) == typeid(int));
i++;
u++;
//printf("u = %d\n", u);
assert((i == 1) ? u == 74 : u == 83);
}
assert(i == 2);
assert(a.array[0] == 73);
assert(a.array[1] == 82);
foreach (j, u; a)
{
assert(typeid(typeof(j)) == typeid(size_t));
assert(typeid(typeof(u)) == typeid(int));
i++;
u++;
//printf("u = %d\n", u);
assert((i == 3) ? u == 74 : u == 83);
assert(j == i - 3);
}
assert(i == 4);
assert(a.array[0] == 73);
assert(a.array[1] == 82);
}
/**************************************************/
struct Collection24
{
int opApply(int delegate(ref int) dg){
return 0;
}
}
bool foo24()
{
Collection24 a,b;
foreach(int x; a){
foreach(int y; b){
return false;
}
}
return true;
}
void test24()
{
assert(foo24() == true);
}
/**************************************************/
void test25()
{
alias void function(string[string]) FN;
FN fn = function (string[string] aarray)
{
foreach (string s; aarray)
{
assert(s == "b");
}
};
string[string] aarray;
aarray["a"] = "b";
fn(aarray);
}
/**************************************************/
struct Foo26
{
uint[2] array;
int forward(int delegate(ref uint) dg)
{
int result;
for (int i = 0; i < array.length; i++)
{
result = dg(array[i]);
if (result)
break;
}
return result;
}
int forward(int delegate(ref uint) dg, int x) { return 1; }
int reverse(int delegate(ref uint) dg, int x) { return 1; }
int reverse(int delegate(ref uint) dg)
{
int result;
foreach_reverse (v; array)
{
auto u = v;
result = dg(u);
if (result)
break;
}
return result;
}
}
void test26()
{
Foo26 a;
int i;
a.array[0] = 73;
a.array[1] = 82;
foreach (u; &a.forward)
{
printf("%d\n", u);
i++;
u++;
}
assert(i == 2);
assert(a.array[0] == 73);
assert(a.array[1] == 82);
foreach (uint u; &a.reverse)
{
printf("%d\n", u);
}
}
/**************************************************/
struct S27
{
int[] a;
bool empty() { return a.length == 0; }
void popFront() { a = a[1 .. $]; }
int front() { return a[0]; }
void popBack() { a = a[0 .. $ - 1]; }
ref int back() { return a[$ - 1]; }
}
void test27()
{
S27 s;
s.a = [5,6,7];
string r;
foreach (e; s)
{
printf("%d\n", e);
r ~= cast(char)(e + '0');
}
assert(r == "567");
r = null;
foreach_reverse (ref e; s)
{
e++;
printf("%d\n", e);
r ~= cast(char)(e + '0');
}
assert(r == "876");
r = null;
foreach (e; s)
{
printf("%d\n", e);
r ~= cast(char)(e + '0');
}
assert(r == "678");
}
/**************************************************/
int main()
{
test1();
test2();
test3();
test4();
test5();
test6();
test7();
test8();
test9();
test10();
test11();
test12();
test13();
test14();
test15();
test16();
test17();
test18();
test19();
test20();
test21();
test22();
test23();
test24();
test25();
test26();
test27();
printf("Success\n");
return 0;
}