test_true([["$Id: testsuite.in,v 1.62 1997/12/03 22:46:18 hubbe Exp $"]])
test_eq(1e1,10.0)
test_eq(1E1,10.0)
test_eq(1e+1,10.0)
test_eq(1.1e1,11.0)
test_eq(1e-1,0.1)
test_eq('\x20',32)
test_eq("\x20","\040")

test_eq(class { static int foo=17; }()->foo,0)
test_eval_error(class { static int foo=17; }()->foo=18;)
test_equal( [[ ({ (["foo":"bar"]), (<"foo">), ([]) })->foo ]], [[ ({"bar",1,0}) ]])
test_any([[mixed a=({([]),0}); a[1]=a; return a->foo[0];]],0)
test_eval_error([[return column(({0}),"foo");]])

test_any([[
class p1 { int foo() { return 1; }};
class p2 { int foo() { return 3; }};
class c1 { inherit p1; inherit p2; int foo() { return p1::foo()+p2::foo(); }};
class c2 { inherit c1; }; return c2()->foo();]],4)

test_any([[
class p1 { int foo() { return 1; } };
class p2 { int foo() { return 2; } };
class c1 { inherit p1; inherit p2; };
return c1()->foo();]],2);

test_any([[class foo { int x=random(100); int `<(object o) { return x < o->x; } }; object *o=Array.map(allocate(100),foo); sort(o); for(int e=1;e<100;e++) if(o[e-1]->x > o[e]->x) return e; return -1;]],-1)
test_compile_error([[void foo() { return destruct(this_object()); }]])
test_any([[class foo { constant x=17; }; class bar { inherit foo; constant x=18; }; return bar()->x;]],18)
test_program([[inline string foo(string s){ while(s[0] == ' ' || s[0] == '\t') s = s[1..]; return(s); } string a() { return foo("   bar"); }]])
test_true([[lambda(function f) {return 1;}(object_program(this_object()));]])
test_eq([[class { int `()(){ return 4711; } }()(); ]],4711)
teste_eval_error(mixed foo=({}); sort(@foo); )
test_compile_error([[int foo() { return 1} ; constant foo=(["foo":foo]); return foo->foo();]])
test_compile_error([[class T{void p(object e,object f){lambda::create(f);}}]])
test_eval_error(mixed *foo=({}); return mkmapping(foo,({1})); )
test_true(time())
test_compile_error([[mapping (string:array(string:string)) foo=([]); ]])
test_compile_error([[int a() { switch(random(2)) { case 3: if(random(2)) { case 0: return 1; } else { case 1: return 2; } } }]])

test_true(encode_value(0))
test_true(encode_value(0)[0]=='\266')
define(test_encode, [[ test_equal($1, decode_value(encode_value($1))) ]])
test_eq(replace("foobar","","X"),"fXoXoXbXaXr")
test_encode(0)
test_encode("")
test_encode(0.0)
test_encode(1.0)
test_encode(-1.0)
test_encode(12.0)
test_encode(100000.0)
test_encode(3.14159265)
test_encode(0.000001)
test_encode(({}))
test_encode(([]))
test_encode("foobar")
test_encode((<>))
test_eq(decode_value("\210\201"),1)
test_eq(decode_value("\210\011\001"),-1)
test_eq(decode_value("\206\200"),""))
test_equal(decode_value("\200\200"),({}))
test_equal(decode_value("\206\206\146\157\157\142\141\162"),"foobar")
test_any([[mixed a=({0}); a[0]=a; return equal(a, decode_value(encode_value(a)));]], 1)
test_any([[ int e; for(e=0;e<100000;e+=1+(e>>4)) if(decode_value(encode_value(e))!=e) return e; return -1;]], -1)
test_any([[ int e; for(e=0;e<100000;e+=1+(e>>4)) if(decode_value(encode_value(-e))!=-e) return e; return -1;]], -1)

test_any([[mixed s="foo"; return s++;]],"foo")
test_any([[mixed s="foo"; s++; return s;]],"foo1")
test_any([[mixed s="foo"; return ++s;]],"foo1")
test_any([[float p=2.0; return p--;]],2.0);
test_any([[float p=2.0; p--; return p;]],1.0);
test_any([[float p=2.0; return --p;]],1.0);

test_compile_error(int foo() { LJjjjjJJJ ; })
test_true(clone(class { constant i=1; })->i)
test_true(clone(class { constant i=0; mixed `->(string s) { if(s=="i") return 1; }})->i)
test_true(clone(class { constant i=1; mixed `->(string s) { return 0; }})["i"])
test_true(clone(class { constant i=0; mixed `[](string s) { if(s=="i") return 1; }})["i"])
test_eq([[class{mixed `[](int a,int b) { return a+b; }}()[1..4]]],5)
test_true(clone(class { mixed `[]=(mixed a, mixed b) { if(a!=b) throw(1); }})[1]=1)
test_true(clone(class { mixed `->=(mixed a, mixed b) { if(a!=b) throw(1); }})->i="i")

test_compile(class A {}; class B { inherit A; })

test_true(mappingp(_memory_usage()))
test_true(objectp( _next(this_object()) || _prev(this_object())))
test_true(arrayp( _next(({})) || _prev(({}))))
test_any(object o=this_object(); while(o=_next(o)));
test_any(object o=this_object(); while(o=_prev(o)));

test_any([[object(Stdio.File) o=Stdio.File(); return objectp(o);]],1)
test_any([[object o=Regexp("foo"); return objectp(o);]],1)
test_any([[object o=Regexp("foo"); return object_program(o);]],Regexp)
test_any([[class Test {}; object(Test) o=Test(); return object_program(o);]],Test)
test_define_program(test,[[constant foo = 1; int a() { return foo; }]])
test_true(new(test)->a())
test_program(inherit test;)
test_program(inherit test; int a() { return foo; } )
test_define_program(test,[[class TEST { int a() { return 1; } }]])
test_program(inherit test; inherit TEST; )
test_compile_error(class { object(Stdio.File) foo; object(Regexp) bar=foo; })
test_do(class { object foo; object(Regexp) bar=foo; })
test_do(class { object(Stdio.File) foo; object bar=foo; })
test_any(if(int i=1) return i; return 0;,1)
test_compile(for(int i=0;i<100;i++) return 0;)
test_compile(foreach(({}),mixed i){})
test_compile(sscanf("","",mixed foo))

// ++
test_any([[int e; e++; return e;]],1)
test_any([[int e; ++e; return e;]],1)
test_any([[int e; return e++;]],0)
test_any([[int e; return ++e;]],1)
test_any([[int e; if(e++) return 0; return e;]],1)

// --
test_any([[int e; e--; return e;]],-1)
test_any([[int e; --e; return e;]],-1)
test_any([[int e; return e--;]],0)
test_any([[int e; return --e;]],-1)
test_any([[int e; if(e--) return 0; return e;]],-1)

test_compile_error_low(master()->add_precompiled_program(\"/test\",compile_string(\"int foo() { return 17; }\",\"62\")))

test_any([[function f=random_seed; int t; foreach(allocate(1),t) f(t); return 1;]],1)
test_compile([[while(0)if(0)continue;else;]])
test_program([[int b=1,c; int a() { c=b+2; return c==3; }]])
test_true([[ ("foobar"/"o") & ({ "foo" }) ]])
test_any([[ array a="foo bar"/" "; return sizeof(a & ({"foo"}))]],1)

// glob
test_false(glob("foo","bar"))
test_true(glob("foo","foo"))
test_true(glob("f?o","foo"))
test_true(glob("f??","foo"))
test_true(glob("?o?","foo"))
test_true(glob("f*","foo"))
test_true(glob("*o","foo"))
test_true(glob("*<<<*","<<<"))
test_true(glob("*<<<*","<<<foo"))
test_false(glob("*f","foo"))
test_false(glob("o*","foo"))
test_false(glob("?f?","foo"))
test_equal([[glob("?f?",({"ff","ffff","off","fff",""}))]],[[({"off","fff"})]])
test_equal([[glob("foo*bar",({"foobar","foobargazonk","","foofoobar","fobar","fooar"}))]],[[({"foobar","foofoobar"})]])

// localtime
cond([[all_constants()->localtime]],
[[
test_true(mappingp(localtime(0)))
]])

// sort
test_equal(sort(({1,3,2,4})),({1,2,3,4}))
test_equal(sort(({4,3,2,1})),({1,2,3,4}))
test_equal([[lambda() {string *a=({1,2,3,4}); sort(({4,3,2,1}),a); return a; }()]],[[({4,3,2,1})]] )
test_equal([[lambda() {string *a=({1,2,3,4}),*b=a+({}); sort(({4,3,2,1}),a,b); return b; }()]],[[({4,3,2,1})]] )

cond([[all_constants()->thread_create]],
[[
// thread_create
  test_do(thread_create(lambda() { }))

// /precompiled/mutex
  test_true(Thread.Mutex())
  test_do(add_constant("_tmp_mutex",Thread.Mutex()))
  test_true(_tmp_mutex->lock())
  test_true(_tmp_mutex->lock())
  test_true(_tmp_mutex->trylock())
  test_true(_tmp_mutex->trylock())
  test_do(add_constant("_tmp_mutex_lock",_tmp_mutex->lock()))
  test_true(catch(_tmp_mutex->trylock()))
  test_do(add_constant("_tmp_mutex_lock"))
  test_true(_tmp_mutex->trylock())
  test_do(add_constant("_tmp_mutex"))
  test_any([[ object m = Thread.Mutex(); object k = m->lock(); thread_create(lambda(object k){ sleep(10); catch { destruct(k); }; }, k);if (catch{m->lock(); return 0;}) { return 1; } return 0; ]],1)
  test_any([[ mixed *data=({0,Thread.Mutex(),Thread.Mutex(),0}); data[3]=data[2]->lock(); thread_create(lambda(mixed *data) {object o=data[1]->lock(); destruct(data[3]); sleep(10); data[0]=1; destruct(o);  },data); object l=data[2]->lock(1); object ll=data[1]->lock(); return data[0]; ]],1)
  test_any([[
mixed *data=({1, Thread.Mutex(), Thread.Condition(), 0});
for(int e=0;e<3;e++) { data[3]++; thread_create(lambda(mixed *data) {
  for(int e=0;e<1000;e++) { object o=data[1]->lock(); data[0]*=2;
    for(int d=0;d<5;d++) { data[0]--; data[0]*=2; } data[0]--; destruct(o); }
   data[3]--; data[2]->signal();}, data);}
 while(data[3]) data[2]->wait(); return data[0];]],1)

// /precompiled/condition
  test_true(Thread.Condition())
  test_do(Thread.Condition()->signal())
  test_do(Thread.Condition()->broadcast())

  test_true(objectp(clone(Thread.Fifo)))
  test_true(objectp(clone(Thread.Queue)))

  test_any([[object o=Thread.Queue(); thread_create(lambda(object f) { for(int e=0;e<10000;e++) f->write(random(4711)); f->write(-1); },o); int tmp=0; while(o->read() != -1) tmp++; return tmp;]],10000)
  test_any([[object o=Thread.Fifo(); thread_create(lambda(object f) { for(int e=0;e<10000;e++) f->write(random(4711)); f->write(-1); },o); int tmp=0; while(o->read() != -1) tmp++; return tmp;]],10000)
]])


  test_true(Getopt.find_option(({"","--foo"}),"p","foo"))
  test_eq(Getopt.find_option(({"","--foo=bar"}),"p","foo",0,0),"bar")
  test_eq(Getopt.find_option(({"","--foo","bar"}),"p","foo",0,0),"bar")
  test_eq(Getopt.find_option(({"","--","--foo=bar"}),"p","foo",0,0),0)

  test_true(Getopt.find_option(({"","-p"}),"p","foo"))
  test_eq(Getopt.find_option(({"","-pbar"}),"p","foo",0,0),"bar")
  test_eq(Getopt.find_option(({"","-p","bar"}),"p","foo",0,0),"bar")
  test_eq(Getopt.find_option(({"","--","--p","bar"}),"p","foo",0,0),0)

  test_equal(Getopt.get_args(({"",0,0,"sune","--","-foo"})),({"","sune","-foo"}))

  test_true(objectp(clone(String.String_buffer)))
  test_do(clone(String.String_buffer)->append("foo"))
  test_do(add_constant("Flurp",clone(String.String_buffer)))
  test_do(Flurp->append("test"))
  test_do(Flurp->append("test"))
  test_eq((string)Flurp,"testtest")
  test_do(add_constant("Flurp"))

  test_eq(String.strmult("foo",4),"foofoofoofoo")

// m_delete
test_equal(([1:1]),m_delete(a(),0))
test_equal(([1:1]),m_delete(([1:1,0:3]),0))
test_any(mapping a=([1:1]); return a==m_delete(a,1),1)
test_any([[mapping m=([]); m[1]++; return m[1];]],1)
test_any([[mapping m=([1:1]); m[1]++; return m[1];]],2)
test_any([[mapping m=([]); m[1]++; m[1]++; return m[1];]],2)

// mapping tests

test_any([[mapping m=([]);int e;
  for(e=0;e<1000;e++) m[e]=e;
  for(e=0;e<1000;e++) if(m[e]!=e) return 0;
  return 1;
]],1)

test_any([[mapping m=([]);int e;
  for(e=0;e<1000;e++) m[e]=e;
  for(e=999;e>=0;e--) if(m[e]!=e) return 0;
  return 1;
]],1)


test_any([[mapping m=([]);int e;
  for(e=999;e>=0;e--) m[e]=e;
  for(e=0;e<1000;e++) if(m[e]!=e) return 0;
  return 1;
]],1)

test_any([[mapping m=([]);int e;
  for(e=999;e>=0;e--) m[e]=e;
  for(e=999;e>=0;e--) if(m[e]!=e) return 0;
  return 1;
]],1)


test_any([[mapping m=([]);int e;
  for(e=0;e<1000;e++) m[reverse(e)]=e;
  for(e=0;e<1000;e++) if(m[reverse(e)]!=e) return 0;
  return 1;
]],1)


test_any([[mapping m=([]);int e;
  for(e=999;e>=0;e--) m[reverse(e)]=e;
  for(e=0;e<1000;e++) if(m[reverse(e)]!=e) return 0;
  return 1;
]],1)


test_any([[mapping m=([]);int e;
  for(e=0;e<1000;e++) m[reverse(e)]=e;
  for(e=0;e<1000;e++) m_delete(m,reverse(e));
  return sizeof(m);
]],0)

test_any([[mapping m=([]);int e;
  for(e=0;e<1000;e++) m[reverse(e)]=e;
  for(e=0;e<1000;e+=2) m_delete(m,reverse(e));
  for(e=0;e<1000;e+=2) if(m[reverse(e)]) return 0;
  for(e=1;e<1000;e+=2) if(m[reverse(e)]!=e) return 0;
  return 1;
]],1)

test_any([[mapping m=([]);int e;
  for(e=0;e<1000;e++) m[reverse(e)]=e;
  for(e=0;e<1000;e++) m[reverse(e)]++;
  for(e=0;e<1000;e++) if(m[reverse(e)]!=e+1) return 0;
  return 1;
]],1)

test_any([[mapping m=([]);int e;
  mixed a,b;
  a=allocate(1000);
  b=allocate(1000);
  for(e=0;e<1000;e++)
  {
    m[reverse(e)]=e;
    a[e]=reverse(e);
    b[e]=e;
  }
  add_constant("mtest_m",m);
  add_constant("mtest_i",a);
  add_constant("mtest_v",b);
  return 1;
]],1)


test_eq([[sizeof(mtest_m)]],sizeof(mtest_i))
test_equal(Array.sort_array(indices(mtest_m)),Array.sort_array(mtest_i))
test_equal(Array.sort_array(values(mtest_m)),Array.sort_array(mtest_v))
test_equal(mtest_m,copy_value(mtest_m))
test_any([[int e; for(e=0;e<1000;e++) if(!equal(mtest_m[mtest_i[e] ],mtest_v[e])) return 0; return 1;]],1)


test_any([[mapping m=([]);int e;
  mixed a,b;
  a=allocate(100);
  b=allocate(100);
  for(e=0;e<100;e++)
  {
    m[reverse(e-50)]=e-50;
    a[e]=reverse(e-50);
    b[e]=reverse(e-50);
  }
  add_constant("mtest_m2",m);
  add_constant("mtest_i2",a);
  add_constant("mtest_v2",b);
  return 1;
]],1)

test_any([[int e;mapping q=([]),p=([]); for(e=0;e<1000;e++) { p[reverse(e)]=e; q+=([reverse(e):e]); if(!equal(sort(indices(p)),sort(indices(q)))) return 0; } return 1;]],1)
test_any([[mapping m=([]); m+=(["foo":"bar"]); m+=(["bar":"foo"]); m+=(["foo":"foo"]); if(sizeof(m)==3) return 1; return m["foo"]=="foo" && m["bar"]=="foo"]],1)

test_equal(sort(indices(mtest_m|mtest_m2)),sort(mtest_i|mtest_i2))
test_equal(sort(indices(mtest_m&mtest_m2)),sort(mtest_i&mtest_i2))
test_equal(sort(indices(mtest_m-mtest_m2)),sort(mtest_i-mtest_i2))
test_equal(sort(indices(mtest_m^mtest_m2)),sort(mtest_i^mtest_i2))
test_equal(sort(indices(mtest_m2|mtest_m)),sort(mtest_i2|mtest_i))
test_equal(sort(indices(mtest_m2&mtest_m)),sort(mtest_i2&mtest_i))
test_equal(sort(indices(mtest_m2-mtest_m)),sort(mtest_i2-mtest_i))
test_equal(sort(indices(mtest_m2^mtest_m)),sort(mtest_i2^mtest_i))

define(MTEST,[[test_equal([[mkmapping(indices(allocate($1)),reverse(indices(allocate($1))))]],[[mkmapping(reverse(indices(allocate($1))),indices(allocate($1)))]])]])

MTEST(0)
MTEST(1)
MTEST(2)
MTEST(3)
MTEST(5)
MTEST(8)
MTEST(13)
MTEST(21)
MTEST(34)
MTEST(55)

define([[MTEST]])

test_do(add_constant("mtest_m"); add_constant("mtest_i"); add_constant("mtest_v");)
test_do(add_constant("mtest_m2"); add_constant("mtest_i2"); add_constant("mtest_v2");)

// rows
test_equal([[rows(({1,2,3,4,5,6,7,8,9}),({6,7,2}))]],[[({7,8,3})]])
test_equal([[rows(({1,2,3,4,5,6,7,8,9}),({0,4,1}))]],[[({1,5,2})]])
test_equal([[rows(({1,2,3,4,5,6,7,8,9}),({8,3,5}))]],[[({9,4,6})]])

// column
test_equal([[column(({({1,2,3}),({5,6,7}),({8,9,0})}),0)]],[[({1,5,8})]])
test_equal([[column(({({1,2,3}),({5,6,7}),({8,9,0})}),1)]],[[({2,6,9})]])
test_equal([[column(({({1,2,3}),({5,6,7}),({8,9,0})}),2)]],[[({3,7,0})]])


// gc
ifefun(gc,
[[
  test_true(intp(gc()));
  test_any([[ array a=({0}); a[0]=a; gc(); a=0; return gc() > 0; ]],1);
  test_any([[object o=class {object o;}(); o->o=o; gc(); o=0; return gc() > 0; ]],1);
  test_any([[object o=class {object o;}(); o->o=o; gc(); o=0; return gc() > 0; ]],1);
  test_any([[mapping m=([]); m[m]=m; gc(); m=0; return gc() > 0; ]],1);
  test_any([[multiset m=(<>); m[m]=1; gc(); m=0; return gc() > 0; ]],1);
]])


test_eq("\377"[0],255)
test_do(add_constant("foo",clone(class {int i;})))
test_eq(foo->i,0)
test_do(foo->i=17)
test_eq(foo->i,17)
test_do(add_constant("foo"));
test_do(add_constant("foo",clone(class {int *i=({0});})))
test_eq(foo->i[0],0)
test_do(foo->i[0]=17)
test_eq(foo->i[0],17)
test_do(add_constant("foo"));

// signum, signame
test_eq(signum("SIGKILL"),9)
test_eq(signum("SIGINT"),2)
test_eq(signame(9),"SIGKILL")
test_eq(signame(2),"SIGINT")

// kill, signal, getpid
test_true(intp(getpid()))
test_do(signal(signum("SIGFPE"),lambda() { add_constant("AFJLLAF",17); }))
test_do(kill(getpid(),signum("SIGFPE")))
test_do(sleep(2))
test_eq(AFJLLAF,17)
test_do(add_constant("AFJLLAF"))
test_do(signal(signum("SIGFPE",0)))
test_do(signal(signum("SIGFPE")))

// typeof
test_eq(typeof(1),"int")
test_eq(typeof(""),"string")
test_eq(typeof(""[0]),"int")
test_eq(typeof(0.0),"float")
test_eq(typeof(all_constants()["all_constants"]),"mixed")

// class
test_true(programp(class {}))
test_true(functionp(clone(class { int foo() { return 1; }})->foo))
test_true(clone(class { int foo() { return 1; }})->foo())
test_true(clone(class { int i=1; })->i)
test_false(clone(class { int foo() { return 1; }})->bar)
test_eq(clone(clone(class { program foo=class { int i=20; }; })->foo)->i,20)

// type checks
test_compile_error([[} int foo() { return]]);
test_compile_error([[} void foo() { return 1]]);

// Not yet cataloged
test_any(int i=10; { int i; } return i, 10)
test_program(void foo(int a ,int b); function(int,int:void) a() { return foo; })
test_program(void foo(int a, int ... b); function(int,int ...:void) a() { return foo; })
test_program(void foo(); function(:void) a() { return foo; })
test_compile_error([[} void foo(); function(:string) a() { return foo;]])

test_do(lambda(){return;}())
test_equal( ({ lambda() { return 3; } , lambda() { return 7; }, lambda() { return 9; } })(), ({ 3,7,9 }))
test_any(int *a=({10}); a[0]++; return a[0], 11)
test_any(mapping a=([10:11]); a[10]++; return a[10], 12)
test_equal(mkmapping( ({3,6,2}), ({"3","6","2"})), ([3:"3", 6:"6", 2:"2"]))
test_equal(`+(([3:"3", 6:"6", 2:"2"])), ([3:"3", 6:"6", 2:"2"]))
test_true(`+(([3:"3", 6:"6", 2:"2"])) != ([3:"3", 6:"6", 2:"2"]))

test_true(predef::stringp(""))
test_equal([["a,b,4,7,8s,asfd,a,d,f" / ","]],[["a,b,4,7,8s,asfd,a,d,f" / ","]])
test_any([[string *a="a,b"/","; a[0]="c"; return equal(a,({"c","b"}))]],1)
test_true(0||1)
test_true(1||0)
test_true(!0||!0)
test_true(!0&&!0)
test_any(mixed a=1; a+=1; return a,2)
test_any(mixed a=1; a-=1; return a,0)
test_equal("abcd"/"" - indices("abcd"),({"a","b","c","d"}))
test_equal("abcd"/"" & indices("abcd"),({}))
test_eq(sizeof("abcd"/"" & "de"/""),1)
test_equal( ({0,0,0,0,0}), ({0,0,0,0,0}))
test_equal( ({0,0,0,0,0}), allocate(5,"object"))
test_equal(mkmapping("abcd"/"","jklm"/"") | mkmapping("jclm"/"","alcd"/""),
	mkmapping("abcdjlm"/"","jklmacd"/""))
test_program(int foo() { return 17;} mixed a() { return foo() == 17; })
test_any([[mixed a; a=2; a=a*3; return a]],6)
test_any([[mixed a = ({1}); a=a+({2}); return equal(a,({1,2}))]],1)
test_define_program(test,[[int foo() { return 17; }]])
test_any(function bar=clone(test)->foo; return bar(),17)

// sscanf
test_any([[mixed a; return sscanf("11","%d",a)]],1)
test_any([[mixed a; sscanf("11","%d",a); return a]],11)
test_any([[mixed a; sscanf("11","%o",a); return a]],011)
test_any([[mixed a; sscanf("11","%x",a); return a]],0x11)
test_any([[mixed a; sscanf("11","%D",a); return a]],11)
test_any([[mixed a; sscanf("0x11","%D",a); return a]],0x11)
test_any([[mixed a; sscanf("011","%D",a); return a]],011)
test_any([[mixed a,b; return sscanf("11foo","%dfoo",a)]],1)
test_any([[mixed a,b; sscanf("11foo","%dfoo",a); return a]],11)
test_any([[mixed a,b; return sscanf("11foo","%d%s",a,b)]],2)
test_any([[mixed a,b; sscanf("11foo","%d%s",a,b); return b]],"foo")
test_any([[mixed a,b; return sscanf("foo","%c%s",b,a)]],2)
test_any([[mixed a,b; sscanf("foo","%c%s",b,a); return b]],'f')
test_any([[mixed a,b; sscanf("foo","%c%s",b,a); return a]],"oo")
test_any([[mixed a,b; return sscanf("1.0","%f",a)]],1)
test_any([[mixed a,b; sscanf("1.0","%f",a); return a]],1.0)
test_any([[mixed a,b; sscanf("abcdeFGji","%[a-z]%s",a,b); return a]],"abcde")
test_any([[mixed a,b; sscanf("abcdeFGji","%[a-z]%s",a,b); return b]],"FGji")

test_any([[mixed a,b; return sscanf("foo-%-bar","%s-%%-%s",a,b);]],2)
test_any([[mixed a,b; sscanf("foo-%-bar","%s-%%-%s",a,b); return a]],"foo")
test_any([[mixed a,b; sscanf("foo-%-bar","%s-%%-%s",a,b); return b]],"bar")
test_any([[mixed a; sscanf("ab","%2c",a); return a]],'a'*256+'b')
test_any([[mixed a; sscanf("abc","%3c",a); return a]],'a'*256*256+'b'*256+'c')
test_any([[mixed a; sscanf("abc","%2c",a); return a]],'a'*256+'b')
test_any([[mixed a; sscanf("ac","%3c",a); return a]],0)
test_any([[mixed a; sscanf("ab","%2s",a); return a]],"ab")
test_any([[mixed a; sscanf("abc","%3s",a); return a]],"abc")
test_any([[mixed a; sscanf("abc","%2s",a); return a]],"ab")
test_any([[mixed a; sscanf("ac","%3s",a); return a]],0)

// Basics
test_true(1)
test_true("")
test_true(!0)
test_true(!(!1))
test_true(this_object())
test_true(a) // a is the test function
test_true(0.0)
test_true(([]))
test_true(({}))
test_true((<>))
test_true(object_program(this_object()))

// testing !
test_equal(!"",0)
test_equal(!this_object(),0)
test_equal(!Simulate.this_function(),0)

// testing ==
test_true(1==1)
test_true(!(1==2))
test_true(""=="")
test_true(!(""=="foo"))
test_true(this_object()==this_object())
test_true(Simulate.this_function()==a)
test_true(2.0==2.0)
test_true(({})==({}))

// testing !=
test_true(({1})!=({1}))
test_true(1!=2)
test_true(!(1==2))
test_true(!(""!=""))
test_true(""!="foo")

test_cmp(1,2)
test_cmp(1.0,2.0)
test_cmp(1,2.0)
test_cmp(1.0,2)
test_cmp("a","b")
test_cmp("","b")

// hex construction
test_eq(0,0x0)
test_eq(1,0x1)
test_eq(10,0xa)
test_eq(16,0x10)
test_eq(65535,0xffff)
test_eq(17*257*65537,0x11111111)

// octal construction
test_eq(0,00)
test_eq(1,01)
test_eq(8,010)
test_eq(64,0100)
test_eq(1073741824,010000000000)
test_eq((8+1)*(8*8+1)*(8*8*8*8+1),011111111)

// string construction tests
test_eq(16,"\20"[0])
test_eq(16,"\020"[0])
test_eq(255,"\377"[0])
test_eq(4,'\4')
test_true("\r"[0]!='r')
test_eq("\r"[0],'\r')
test_eq("\n"[0],'\n')

// testing +
test_eq(1+1,2)
test_eq(1+(-2),-1)
test_eq((-2)+(-2),-4)
test_eq("hi"+"there","hithere")
test_eq("human"+"number"+666,"humannumber666")
test_eq("human"+("number"+666),"humannumber666")
test_eq(("human"+"number")+666,"humannumber666")
test_eq(("human"+"number")+666+111,"humannumber666111")
test_eq("humannumber"+(666+111),"humannumber777")
test_eq("a"+"b"+"c"+"d"+"e"+"f"+"g"+"h"+"i"+"j"+"k"+"l"+"m"+"n"+"o"+"p"+"q"+"r"+"s"+"t"+"u"+"v"+"x"+"y","abcdefghijklmnopqrstuvxy")
test_eq(1.0+1.0,2.0)
test_eq(1.0+(-1.0),0.0)
test_eq((-1.0)+(-1.0),-2.0)
test_eq(1.0+1,2.0)
test_eq(1+1.0,2.0)
test_eq(1+(-1.0),0.0)
test_eq(1.0+(-1),0.0)
test_eq((-1)+(-1.0),-2.0)
test_eq((-1.0)+(-1),-2.0)
test_equal(({1,2,3})+({4,5,6}),({1,2,3,4,5,6}))
test_equal((<1,2,3,4>)+(<4,5,6>),(<1,2,3,4,4,5,6>))
test_equal(([0:1,3:6])+([5:2,3:6]),([0:1,3:6,3:6,5:2]))
test_eval_error(return this_object() + this_object())

// testing -
test_eq(10-3,7)
test_eq(3-10,-7)
test_eq(10.0-3.0,7.0)
test_eq(3.0-10.0,-7.0)
test_eq(10-3.0,7.0)
test_eq(3-10.0,-7.0)
test_eq(10.0-3,7.0)
test_eq(3.0-10,-7.0)
test_eq("foobargazonk"-"o","fbargaznk")
test_equal(({"foo","bar","gazonk"})-({"foo","gazonk"}),({"bar"}))
test_equal(({"c","foo","bar","gazonk","a","b",})-({"foo","gazonk"}),({"c","bar","a","b"}))
test_equal((<"foo","bar","gazonk">)-(<"foo","gazonk">),(<"bar">))
test_equal((["foo":3,"bar":4,"gazonk":5])-(["foo":3,"gazonk":8]),(["bar":4]))

// testing ~
test_eq(-1-4,~4)
test_eq(-1-627893874,~627893874)

// testing *
test_eq(3*4,12)
test_eq(4*3,12)
test_eq(2*2*2*2*2,32)
test_eq(3.0*4.0,12.0)
test_eq(4.0*3.0,12.0)
test_eq(2.0*2.0*2.0*2.0*2.0,32.0)
test_eq(3*4.0,12.0)
test_eq(4*3.0,12.0)
test_eq(2*2.0*2.0*2.0*2.0,32.0)
test_eq(3.0*4,12.0)
test_eq(4.0*3,12.0)
test_eq(2.0*2*2.0*2*2.0,32.0)
test_eq(({"foo","bar","gazonk"})*"-","foo-bar-gazonk")
test_equal( ({ ({1}), ({2}), ({3}) })*({8}), ({1,8,2,8,3}))

// testing /
test_eq(12/3,4)
test_eq(13/3,4)
test_eq(14/3,4)
test_eq(15/3,5)
test_eq(-2/4,-1)
test_eq(-12/3,-4)
test_eq(-13/3,-5)
test_eq(-14/3,-5)
test_eq(-15/3,-5)
test_eval_error(return 15/0)
test_eq(12.0/3.0,4.0)
test_eq(14.0/4.0,3.5)
test_eq(15.0/3.0,5.0)
test_eq(12/3.0,4.0)
test_eq(14/4.0,3.5)
test_eq(15/3.0,5.0)
test_eq(12.0/3,4.0)
test_eq(14.0/4,3.5)
test_eq(15.0/3,5.0)
test_eval_error(return 15.0/0.0)
test_equal("foo-bar-gazonk"/"-",({"foo","bar","gazonk"}))
test_equal("foobargazonk"/"",({"f","o","o","b","a","r","g","a","z","o","n","k"}))
test_equal(({1,0,1,2,1,2,2,2,1,1,1})/({2}),({ ({1,0,1}), ({1}), ({}), ({}), ({1,1,1}) }))
test_equal(({1,2,3,4})/({}),({ ({1}), ({2}), ({3}), ({4}) }))
test_equal(({1,0,1,2,1,2,2,2,1,1,1})/({2,1}),({ ({1,0,1}), ({2,2}), ({1,1}) }))
test_equal( ({1,2,3})/({2,3}), ({ ({1}), ({}) }) )

// testing %
test_eq(12%3,0)
test_eq(13%3,1)
test_eq(14%3,2)
test_eq(15%3,0)
test_eq(2%17,2)
test_eq(2%-17,-15)
test_eq(-2%17,15)
test_eq(-2%-17,-2)
test_eq(-10%10,0)
test_eq(10%-10,0)
test_eq(-10%-10,0)
test_eq(10%10,0)
test_eval_error(return 15 % 0)
test_eq(12.0 % 3.0,0.0)
test_eq(13.0 % 3.0,1.0)
test_eq(14.0 % 3.0,2.0)
test_eq(14.5 % 3.0,2.5)
test_eq(15.0 % 3.0,0.0)
test_eq(13 % 3.0,1.0)
test_eq(14 % 3.0,2.0)
test_eq(13.0 % 3,1.0)
test_eq(14.0 % 3,2.0)
test_eq(14.5 % 3,2.5)
test_eval_error(return 15.0 % 0.0)

// testing &&
test_eq(0 && 1,0)
test_eq(1 && 0,0)
test_eq(0 && 0,0)
test_eq(1 && 1,1)
test_eq(78 && 1,1)
test_eq(78 && 99,99)
test_eq(78 && 99,99)

// testing ||
test_eq(0 || 1,1)
test_eq(1 || 0,1)
test_eq(0 || 0,0)
test_eq(1 || 1,1)
test_eq(78 || 1,78)
test_eq(78 || 0,78)

// testing |
test_eq(0 | 0,0)
test_eq(1 | 1,1)
test_eq(4 | 1,5)
test_eq(1 | 9,9)
test_equal( Array.sort_array(({1,2,3,4,4}) | ({3,5,6})), ({1,2,3,4,4,5,6}))
test_equal( (<4,5,6>) | (<5,5,5>), (<4,5,5,5,6>) )
test_equal( ([-4:8,8:7]) | ([3:3,8:3]), ([-4:8,8:3,3:3]) )

// testing &
test_eq(0 & 0,0)
test_eq(1 & 1,1)
test_eq(4 & 1,0)
test_eq(1 & 9,1)
test_equal( ({1,2,3,4,4}) & ({3,5,6}), ({3}))
test_equal( (<4,5,6>) & (<5,5,5>), (<5>) )
test_equal( ([-4:8,8:7]) & ([3:3,8:3]), ([8:3]) )

// testing ^
test_eq(0 ^ 0,0)
test_eq(1 ^ 1,0)
test_eq(4 ^ 1,5)
test_eq(1 ^ 9,8)
test_equal( ({1,2,3,4,4}) ^ ({3,5,6}), ({1,2,4,4,5,6}))
test_equal( (<4,5,6>) ^ (<5,5,5>), (<4,5,5,6>) )
test_equal( ([-4:8,8:7]) ^ ([3:3,8:3]), ([-4:8,3:3]) )

// testing <<
test_eq(1<<0,1)
test_eq(1<<1,2)
test_eq(1<<10,1024)
test_eq(5<<3,40)

// testing >>
test_eq(9>>2,2)
test_eq(1>>1,0)
test_eq(1024>>10,1)
test_eq(47>>3,5)

// testing ? :
test_true(0?0:1)
test_true(1?1:0)
test_true(""?1:0)
test_true(!0?1:0)
test_true(!(!1)?1:0)
test_true(this_object()?1:0)
test_true(a?1:0) // a is the test function
test_true(0.0?1:0)
test_true(([])?1:0)
test_true(({})?1:0)
test_true((<>)?1:0)
test_true(object_program(this_object())?1:0)

// testing indexing
test_eq("foo"[0],'f')
test_eq("foo"[1],'o')
test_eq("foo"[2],'o')
test_eq("foo"[-1],'o')
test_eq("foo"[-2],'o')
test_eq("foo"[-3],'f')
test_eq(({'f','o','o'})[0],'f')
test_eq(({'f','o','o'})[1],'o')
test_eq(({'f','o','o'})[2],'o')
test_eq(({'f','o','o'})[-1],'o')
test_eq(({'f','o','o'})[-2],'o')
test_eq(({'f','o','o'})[-3],'f')
test_eq(([0:'f',1:'o',2:'o'])[0],'f')
test_eq(([0:'f',1:'o',2:'o'])[1],'o')
test_eq(([0:'f',1:'o',2:'o'])[2],'o')
test_eq(([0:'f',1:'o',2:'o'])[3],0)
test_eq(([0:'f',1:'o',2:'o'])[-1],0)
test_eq((<'f','o','o'>)['o'],1)
test_eq((<'f','o','o'>)['f'],1)
test_eq((<'f','o','o'>)['b'],0)
test_eq((<'f','o','o'>)[-1],0)

// index assigning
test_any(mixed a=({1}); a[0]=2; return equal(a,({2})),1)
test_any(mixed a=(<1>); a[1]=2; return equal(a,(<1>)),1)
test_any(mixed a=(<1>); a[0]=2; return equal(a,(<1,0>)),1)
test_any(mixed a=(<1>); a[1]=0; return equal(a,(<>)),1)
test_any(mixed a=(<1>); a[0]=0; return equal(a,(<1>)),1)
test_any(mixed a=([1:1]); a[0]=0; return equal(a,([1:1,0:0])),1)
test_any(mixed a=([1:1]); a[1]=0; return equal(a,([1:0])),1)

test_define_program(test,[[public int q,w,e,r; mixed t; mixed getw() { return w; } void setw(int _) { w=_; }]])
test_eq(clone(test)->q,0)
test_eq(clone(test)->w,0)
test_eq(clone(test)->e,0)
test_eq(clone(test)->r,0)
test_eq(clone(test)->getw(),0)
test_any(object o=clone(test); o->setw(17); return o->w,17)
test_any(object o=clone(test); o->w=17; return o->getw(),17)

test_eq(clone(test)["q"],0)
test_eq(clone(test)["w"],0)
test_eq(clone(test)["e"],0)
test_eq(clone(test)["r"],0)
test_eq(clone(test)["getw"](),0)
test_any(object o=clone(test); o["setw"](17); return o["w"],17)
test_any(object o=clone(test); o["w"]=17; return o["getw"](),17)

// testing range
test_eq("foObar"[0..0],"f")
test_eq("foobargazonk"[3..5],"bar")
test_eq("foo"[1..10],"oo")
test_eq("foo"[-100..0],"f")
test_eq("foo"[-100..100],"foo")
test_eq("foo"[1..0],"")
test_eq("foo"[0..-100],"")
test_eq("foobargazonk"[0..],"foobargazonk")
test_eq("foobargazonk"[1..],"oobargazonk")
test_eq("foobargazonk"[5..],"rgazonk")
test_eq("foobargazonk"[..2],"foo")
test_eq("foobargazonk"[..5],"foobar")
test_equal(({1,2,3})[0..0],({1}))
test_equal(({1,2,3})[1..2],({2,3}))
test_equal(({1,2,3})[2..10],({3}))
test_equal(({1,2,3})[-100..0],({1}))
test_equal(({1,2,3})[-100..100],({1,2,3}))
test_equal(({1,2,3})[1..0],({}))
test_equal(({1,2,3})[0..-100],({}))

// testing @
test_equal(({1,2,3}),lambda(mixed ... x) { return x; }(@a()))
test_equal("foo"/"",lambda(mixed ... x) { return x; }(@a()))
test_any([[mixed *a=({1,2,3}); return lambda(mixed ... x) { return x; }(@a) !=a]],1)

// testing +=
test_any(int a=1; a+=10; return a,11)
// testing -=
test_any(int a=1; a-=10; return a,-9)
// testing &=
test_any(int a=3; a&=10; return a,2)
// testing |=
test_any(int a=3; a|=10; return a,11)
// testing ^=
test_any(int a=3; a^=10; return a,9)
// testing <<=
test_any(int a=3; a<<=2; return a,12)
// testing <<=
test_any(int a=12; a>>=2; return a,3)
// testing *=
test_any(int a=12; a*=2; return a,24)
// testing /=
test_any(int a=12; a/=2; return a,6)
// testing %=
test_any(int a=12; a%=7; return a,5)

// testing control structs
test_any(return 1,1)
test_any(return lambda(){return 1;} (),1 )
test_any(if(0) return 0; else return 1,1)
test_any(if(0) return 0; return 1,1)
test_any(if(1) return 1; else return 0,1)
test_any(if("") return 1; else return 0,1)
test_any(if(!0) return 1; else return 0,1)
test_any(if(!(!1)) return 1; else return 0,1)
test_any(if(this_object()) return 1; else return 0,1)
test_any(if(a) return 1; else return 0,1) dnl a is the test function
test_any(if(0.0) return 1; else return 0,1)
test_any(if(([])) return 1; else return 0,1)
test_any(if(({})) return 1; else return 0,1)
test_any(if((<>)) return 1; else return 0,1)
test_any(if(object_program(this_object())) return 1; else return 0,1)

// break
test_any(while(1) break; return 1,1)
test_any(while(1) if(1) break; return 1,1)

// for
test_any(int e; for(e=0;e<10;e++) break; return e,0)
test_any(int e; for(e=0;e<10;e++) continue; return e,10)
test_any(int e;string t=""; for(e=0;e<10;e++) t+=e; return t,"0123456789")
test_any(int e;string t=""; for(e=0;e<=10;e++) t+=e; return t,"012345678910")
test_any(int e;string t=""; for(e=9;e>0;e--) t+=e; return t,"987654321")
test_any(int e;string t=""; for(e=9;e>=0;e--) t+=e; return t,"9876543210")
test_any(int e;string t=""; for(e=9;e!=0;e--) t+=e;  return t,"987654321")
test_any(int e;string t=""; for(e=2;e!=10;e++) t+=e; return t,"23456789")
test_any(int e;string t=""; for(e=0;e>-10;e--) t+=e; return t,"0-1-2-3-4-5-6-7-8-9")

// foreach
test_any([[int e;string t=""; foreach(({7,6,3,8}),e) t+=e; return t]],"7638")
test_any([[string s;if(1) foreach(({}),s); else foreach(({}),s); return 1]],1)

// do-whilte
test_any(int e;string t=""; e=0; do{ t+=e; }while(++e<6); return t,"012345";)

// while
test_any(int e;string t=""; e=8; while(--e) t+=e; return t,"7654321";)
test_any(int e;string t=""; e=8; while(e--) t+=e; return t,"76543210";)
test_any(int e;string t=""; e=0; while(++e<6) t+=e; return t,"12345";)
test_any(int e=1;string t=""; while(e<20){t+=e;e*=2;} return t,"124816";)

// Switch
test_any(switch("") { case -1: case "gazonk": return 0; } return 1,1)
test_any(switch("") { case -2: case "gazonk": return 0; } return 1,1)
test_any(switch("") { case 0: case "gazonk": return 0; } return 1,1)
test_any(switch("") { case "gazonk": case 0: return 0; } return 1,1)
test_any(switch(0) { case 0: case "gazonk": return 0; } return 1,0)
test_any(switch("gazonk") { case "gazonk": case 0: return 0; } return 1,0)
test_any(switch(0) { case "": } return 1,1)
test_any(switch(1) { case 1: return 1; default: } return 0,1)
test_any(switch(2) { case 1: return 0; default: return 1;} return 0,1)
test_any(switch(1) { default: return 0; case 1: return 1; } return 0,1)
test_any(switch(2) { default: return 1; case 1: return 0; } return 0,1)
test_any(switch(0) { case "apa": case 1.0: return 0; }  return 1,1)
test_any(switch("apa") { case "apa": return 1; case 1.0: }  return 0,1)
test_any(switch(1.0) { case "apa": return 0; case 1.0: return 1; } return 0,1)
test_any(switch("sune") { case "gunnel": return 0; case "gunnar": return 1; case "sune": case "gusten": return 0; } return 0,0)
test_any(switch("a") { case "a": return 1; case "b": case "c": case "d": case 'a': case '1': case '0': default: } return 0,1)
test_any(switch("b") { case "a": return 0; case "b": return 1; case "c": case "d": case 'a': case '1': case '0': default: } return 0,1)
test_any(switch("c") { case "a": case "b": return 0; case "c": return 1; case "d": case 'a': case '1': case '0': default: } return 0,1)
test_any(switch("d") { case "a": case "b": case "c": return 0; case "d": return 1; case 'a': case '1': case '0': default: } return 0,1)
test_any(switch('a') { case "a": case "b": case "c": case "d": return 0; case 'a': return 1; case '1': case '0': default: } return 0,1)
test_any(switch('1') { case "a": case "b": case "c": case "d": case 'a': return 0; case '1': return 1; case '0': default: } return 0,1)
test_any(switch('0') { case "a": case "b": case "c": case "d": case 'a': case '1': return 0; case '0': return 1; default: } return 0,1)
test_any(switch("a") { case "a": return 1; case "b": return 2; case "c": return 3; case "d": return 4; case 'a': return 5; case '1': return 6; case '0': return 7; default: return 8; } return 9,1)
test_any(switch("b") { case "a": return 1; case "b": return 2; case "c": return 3; case "d": return 4; case 'a': return 5; case '1': return 6; case '0': return 7; default: return 8; } return 9,2)
test_any(switch("c") { case "a": return 1; case "b": return 2; case "c": return 3; case "d": return 4; case 'a': return 5; case '1': return 6; case '0': return 7; default: return 8; } return 9,3)
test_any(switch("d") { case "a": return 1; case "b": return 2; case "c": return 3; case "d": return 4; case 'a': return 5; case '1': return 6; case '0': return 7; default: return 8; } return 9,4)
test_any(switch('a') { case "a": return 1; case "b": return 2; case "c": return 3; case "d": return 4; case 'a': return 5; case '1': return 6; case '0': return 7; default: return 8; } return 9,5)
test_any(switch('1') { case "a": return 1; case "b": return 2; case "c": return 3; case "d": return 4; case 'a': return 5; case '1': return 6; case '0': return 7; default: return 8; } return 9,6)
test_any(switch('0') { case "a": return 1; case "b": return 2; case "c": return 3; case "d": return 4; case 'a': return 5; case '1': return 6; case '0': return 7; default: return 8; } return 9,7)
test_any(switch('9') { case "a": return 1; case "b": return 2; case "c": return 3; case "d": return 4; case 'a': return 5; case '1': return 6; case '0': return 7; default: return 8; } return 9,8)


define(test_switch0,[[
test_any(switch($1) { $2; $3; $4; $5; } return 0,$6)
test_any(switch($1) { default: return 0; $2; $3; $4; $5; } return -1,$6)
test_any(switch($1) { $2; default: return 0; $3; $4; $5; } return -1,$6)
test_any(switch($1) { $2; $3; default: return 0; $4; $5; } return -1,$6)
test_any(switch($1) { $2; $3; $4; default: return 0; $5; } return -1,$6)
test_any(switch($1) { $2; $3; $4; $5; default: return 0; } return -1,$6)
]])

define(test_switch1,[[
test_switch0($1, $2,$3,$4,$5, $6)
test_switch0($1, $2,$3,$5,$4, $6)
]])

define(test_switch2,[[
test_switch1($1, $2,$3,$4,$5, $6)
test_switch1($1, $2,$4,$3,$5, $6)
test_switch1($1, $2,$5,$4,$3, $6)
]])

define(test_switch3,[[
test_switch2($1,case $2:return 2,case $3:return 3,case $4:return 4,case $5:return 5,$6)
test_switch2($1,case $3:return 3,case $2:return 2,case $4:return 4,case $5:return 5,$6)
test_switch2($1,case $4:return 4,case $3:return 3,case $2:return 2,case $5:return 5,$6)
test_switch2($1,case $5:return 5,case $3:return 3,case $4:return 4,case $2:return 2,$6)
]])

define(test_switch4,[[
test_switch3($1,$2,$3,$4,$5,0)
test_switch3($2,$2,$3,$4,$5,2)
test_switch3($3,$2,$3,$4,$5,3)
test_switch3($4,$2,$3,$4,$5,4)
test_switch3($5,$2,$3,$4,$5,5)
]])

test_switch4(17,18,19,20,21)
test_switch4("a","b","c","d","e")
test_switch4("a",0,"c","d","e")
test_switch4(1.0,2.0,3.0,4.0,5.0)
test_switch4(this_object(),"",0,4.0,1)

test_any(int e;string t=""; for(e=0;e<10;e++) switch(e) { default: t+=e; case 4..8: } return t,"01239")
test_any([[float e,q; q=0.0; for(e=0.1;e<10.0;e+=1.0) switch(e) { default: q+=e; case 4.0..8.0: } return q]],0.1+1.1+2.1+3.1+8.1+9.1)

// testing preprocessor
test_program([[
#include <simulate.h>
mixed a() { return explode ; }
]])
test_program([[
#include "lib/include/simulate.h"
mixed a() { return implode; }
]])

test_true(intp(__LINE__))
test_true(stringp(__FILE__))
test_true(stringp(__DATE__))
test_true(stringp(__TIME__))

// #define
test_any([[
#define FOOa 1
return FOOa;
]],1)

test_any([[
#define FOOa array
FOOa(int) b;
return 1;
]],1)

test_any([[
#define FOOb 17
#undef FOOb
#define FOOb 1
return FOOb;
]],1)

test_compile_error([[
#define FOOc FOOc FOO
FOO
]])

test_compile_error([[
#error FOOd
FOO
]])

// /* */
test_any([[
/* return 99; * /  /* */
return 1;
]],1)

// //
test_any([[
// return 99;
return 1;
]],1)

// #if
define(test_if_true,[[test_any([[
#if $1
return 1;
#else
return 0;
#endif
]],1)]])
define(test_if_false,[[test_any([[
#if $1
return 1;
#else
return 0;
#endif
]],0)]])

test_if_true(1)
test_if_false(0)

// #if ==
test_if_true(1==1)
test_if_false(1==2)

// #if !=
test_if_true(1!=2)
test_if_false(1!=1)

// #if ( )
test_if_true( (((1))==1) )
test_if_false( ((1)==(2)) )

// #if -1
test_if_true( -1 )
test_if_true( (-1) )
test_if_true( (-1==0-1) )

// #if ~
test_if_true( (-1-1==~1) )

// #if ?:
test_if_true( 17 == ( 1 ? 17 : 18 ) )
test_if_true( 18 == ( 0 ? 17 : 18 ) )

// #if ||
test_if_true( 10 == ( 10 || 20 ) )
test_if_true( 20 == ( 0 || 20 ) )

// #if &&
test_if_true( 0 == ( 0 && 20 ) )
test_if_true( 20 == ( 10 && 20 ) )

// #if |
test_if_true( 3 == ( 1 | 2 ) )
test_if_true( 2 == ( 2 | 2 ) )

// #if ^
test_if_true( 0 == ( 2 ^ 2 ) )
test_if_true( 3 == ( 1 ^ 2 ) )

// #if &
test_if_true( 0 == ( 1 & 2 ) )
test_if_true( 2 == ( 2 & 7 ) )

// #if <= >= < > ! strings, floats

define(test_if_cmp,[[
test_if_true($1<$2)
test_if_true(!($1>$2))
test_if_true($2>$1)
test_if_true(!($2<$1))
test_if_true($1<=$2)
test_if_true(!($1>=$2))
test_if_true($2>=$1)
test_if_true(!($2<=$1))
test_if_true($2<=$2)
test_if_true($1>=$1) ]])

test_if_cmp(1,2)
test_if_cmp(1.0,2.0)
test_if_cmp("a","b")

// #if <<
test_if_true(1<<10==1024)
test_if_true(5<<3==40)

// #if >>
test_if_true(1024>>10==1)
test_if_true(47>>3==5)

// #if +
test_if_true(1024+10==1034)
test_if_true(47+3==50)

// #if -
test_if_true(1024-10==1014)
test_if_true(47-3==44)

// #if *
test_if_true(1024*10==10240)

// #if /
test_if_true(47/3==15)

test_compile_error([[
#if 1/0
return 1;
#else
return 0;
#endif
]])

// #if %
test_if_true(47%3==2)
test_compile_error([[
#if 1%0
return 1;
#else
return 0;
#endif
]])

// #if [ ]
test_if_true("foo"[0]=='f')

// #if defined
test_any([[
#define FOOe 0
#if defined(FOOe)
return 1;
#else
return 0;
#endif
]],1)

// #if define < x
test_any([[
#define FOOf 1
#if FOOf < 2
return 1;
#else
return 0;
#endif
]],1)

// #if define < x
test_any([[
#define FOOg 1
#if FOOg < 0
return 0;
#else
return 1;
#endif
]],1)

// #if x < define
test_any([[
#define FOOh 1
#if 0 < FOOh
return 1;
#else
return 0;
#endif
]],1)

// #if x < define
test_any([[
#define FOOi 1
#if 2 < FOOi
return 0;
#else
return 1;
#endif
]],1)

// #if efun
// see test for add_constant()

// #if /* */
test_any([[
#if 1 /* trying to be mean //  * / */ /* /* */
return 1;  /* */
#define foo
# 1 "---"
#undef foo
#else /* trying to be mean //  * / */ /* /* */
return 0;  //
#endif /* trying to be mean //  * / */ /* /* */
]],1)

test_any([[
#if 0 /* trying to be mean //  * / */ /* /* */
return 0; /* */
#define foo
# 1 "---"
#undef foo
#else /* trying to be mean //  * / */ /* /* */
return 1; //
#endif /* trying to be mean //  * / */ /* /* */
]],1)

// #if //
test_any([[
#if 1 //* trying to be mean //  */ */
return 1;
#else //* trying to be mean //  */ */
return 0;
#endif //* trying to be mean //  */ */
]],1)

test_any([[
#if 0 //* trying to be mean //  */ */
return 0;
#else //* trying to be mean //  */ */
return 1;
#endif //* trying to be mean // */ */
]],1)

test_any([[
#define FOOj
#if defined(FOOj)
return 1;
#else
return 0;
#endif
]],1)

test_any([[
#if defined(FOOk)
return 0;
#else
return 1;
#endif
]],1)

// #ifdef
test_any([[
#ifdef FOOl
return 0;
#else
return 1;
#endif
]],1)

test_any([[
#define FOOm
#ifdef FOOm
return 1;
#else
return 0;
#endif
]],1)

// #ifndef
test_any([[
#define FOOo
#ifndef FOOo
return 0;
#else
return 1;
#endif
]],1)

test_any([[
#ifndef FOOp
return 1;
#else
return 0;
#endif
]],1)

// #else
test_any([[
#if 1
return 1;
#else
FEL
#if 0
FEL
#else
FEL
#endif
return 0;
#endif
]],1)

test_any([[
#if 0
FEL
#if 0
FEL
#else
FEL
#if 1
FEL
#else
FEL
#endif
#endif
return 0;
#else
return 1;
#endif
]],1)

// #elif
test_any([[
#if 0
return 0;
#elif 0
return 0;
#else
return 1;
#endif
]],1)

test_any([[
#if 0
return 0;
#elif 1
return 1;
#else
return 0;
#endif
]],1)

test_any([[
#if 1
return 1;
#elif 1
return 0;
#else
return 0;
#endif
]],1)

// #elseif
test_any([[
#if 0
return 0;
#elseif 0
return 0;
#else
return 1;
#endif
]],1)

test_any([[
#if 0
return 0;
#elseif 0
return 0;
#elseif 1
return 1;
#elseif 0
return 0;
#elseif 0
return 0;
#else
FEL
#endif
]],1)

test_any([[
#if 0
return 0;
#elseif 1
return 1;
#else
return 0;
#endif
]],1)

test_any([[
#if 1
return 1;
#elseif 1
return 0;
#else
return 0;
#endif
]],1)

// #pragma
// FIXME: add tests for real pragmas
test_any([[
#pragma whatever
return 1;
]],1)

// #include
// FIXME add test for #include

// foop
define(do_test_foop,[[
test_eq($1 (17), !($2))
test_eq($1 (1.7), !($2-1))
test_eq($1 ("17"), !($2-2))
test_eq($1 (this_object()), !($2-3))
test_eq($1 (a), !($2-4)) // a is the test function
test_eq($1 (({})), !($2-5))
test_eq($1 (([])), !($2-6))
test_eq($1 ((<>)), !($2-7))
test_eq($1 (object_program(this_object())), !($2-8))
]])

do_test_foop(intp,0)
do_test_foop(floatp,1)
do_test_foop(stringp,2)
do_test_foop(objectp,3)
do_test_foop(functionp,4)
do_test_foop(arrayp,5)
do_test_foop(mappingp,6)
do_test_foop(multisetp,7)
do_test_foop(programp,8)

// add_constant
test_do(add_constant("foobar",lambda() { return 1; }))
test_any([[
#if efun(foobar)
return 1;
#else
return 0;
#endif
]],1)
test_eq(foobar(),1)
test_do(add_constant("foobar"))
test_any([[
#if efun(foobar)
return 1;
#else
return 0;
#endif
]],0)

// - aggregate
test_true(arrayp(aggregate()))
test_eq(sizeof(aggregate()),0)
test_equal(aggregate(1,2,3,4),({1,2,3,4}))

// - aggregate_multiset
test_true(multisetp(aggregate_multiset()))

// - aggregate_mapping
test_true(multisetp(aggregate_multiset()))

// - all_efuns
test_true(mappingp(all_constants()))
test_true(all_constants()["all_constants"])
test_eq(all_constants()["all_constants"],all_constants)

// - allocate
test_true(arrayp(allocate(0)))
test_equal(allocate(2),({0,0}))
test_false(allocate(2)==({0,0}))

// - backtrace
test_true(arrayp(backtrace()))
test_eq(backtrace()[-1][2],a)

// - call_function
test_eq(1,call_function(a))
test_eq(1,call_function(lambda(int a){ return a; },1))
test_eq(1,call_function(intp,1))

// - capitalize
test_eq(String.capitalize("fubar"),"Fubar")
test_eq(String.capitalize("FooBar"),"FooBar")
test_eq(String.capitalize("-"),"-")

// - clone
// clone is already tested a lot by this script
test_true(objectp(clone(compile_string("int foo() { return 17; }"))))
test_eq(clone(compile_string("int foo() { return 17; }"))->foo(),17)

// - combine_path
test_eq([[combine_path("/foo/bar/gazonk/","..")]],"/foo/bar")
test_eq([[combine_path("/.../","sune")]],"/.../sune")
test_eq([[combine_path("/",".")]],"/")
test_eq([[combine_path("/","foo/.../sune")]],"/foo/.../sune")
test_eq([[combine_path("/./foo/bar//gazonk/","../")]],"/foo/bar/")
test_eq([[combine_path("/","/foo/./bar/gazonk/..")]],"/foo/bar")
test_eq([[combine_path("/","/foo/bar/gazonk/../../")]],"/foo/")
test_eq([[combine_path("/","/foo//bar/gazonk/../..")]],"/foo")
test_eq([[combine_path("/","/foo/bar/./gazonk/../../..")]],"/")
test_eq([[combine_path("/","/foo/../bar//./gazonk/../..")]],"/")
test_eq([[combine_path("/","/foo/././/bar/gazonk/../../../..")]],"/")
test_eq([[combine_path("/","..")]],"/")
test_eq([[combine_path("./","..")]],"..")
test_eq([[combine_path("./.","..")]],"..")
test_eq([[combine_path("/","../../foo")]],"/foo")
test_eq([[combine_path("./foobar/.","..")]],".")

// - compile_file
// FIXME: add tests for compile_file

// - compile_string
// see test for clone()

// - copy_value
test_eq(copy_value(1),1)
test_eq(copy_value(""),"")
test_eq(copy_value(1.0),1.0)
test_eq(copy_value(this_object()),this_object())
test_eq(copy_value(a),a)
define(do_test_copy_value,[[
test_any([[mixed x=$1; return x==x]],1)
test_any([[mixed x=$1; return copy_value(x)!=x]],1)
test_any([[mixed x=$1; return equal(copy_value(x),x)]],1)]])
do_test_copy_value( ({1}) )
do_test_copy_value( ([]) )
do_test_copy_value( (<>) )
do_test_copy_value( (< ([]), ({1}) ,"" , 1.0 >) )

// - crypt
test_true(stringp(crypt("hej")))
test_true(crypt("hej",crypt("hej")))

// - ctime
test_true(stringp(ctime(0)))

// - destruct
// FIXME put tests for destruct here.
test_do(add_constant("PROG",compile_string("int foo() { return 1; }")));
test_any([[object o=clone(PROG); destruct(o); return o]],0);
test_any([[object o=clone(PROG); destruct(o); return objectp(o)]],0);
test_any([[object *o=({clone(PROG)}); destruct(o[0]); return o-({0}) ]],({}));
test_any([[mapping o=(["foo":clone(PROG)]); destruct(o["foo"]); return o["foo"]; ]],0);
dnl test_any([[object t; mapping o=([t=clone(PROG):"foo"]); destruct(t); return sizeof(o)]],0);
test_do([[object t,*o=({}); o+=({t=clone(PROG)}); destruct(t); o=({});]]);

// - equal
// equl is already tested by this script

// - exit
// FIXME put test for exit here

// - explode
test_equal(({"a","b","c",}), "anna bnna c"/"nna ")
test_equal(({"","",}),"hej"/"hej")
test_equal(({"",}),""/"hej")

// - fork()
// FIXME: add tests for fork

// - function_name
test_eq(function_name(a),"a")
test_eq(function_name(function_name),0)

// - function_object
test_eq(function_object(a),this_object())
test_eq(function_name(function_object),0)

// - get_function (actually in simulate.pike)
test_eq(a,Simulate.get_function(this_object(),"a"))
test_eq(a,this_object()->a)

// - hash
test_true(intp(hash("foo")))
test_true(intp(hash("foo",10)))
test_true(hash("foo",10)<10)
test_true(hash("bar",10)<10)
test_true(hash("gazonk",10)<10)
test_eq(hash("foobargazonk"),hash("foobargazonk"))

// - implode
test_eq([[({})*""]],"")
test_eq([[("foo"/"o")*"o"]],"foo")
test_eq([[({"foo","bar"})*"-"]],"foo-bar")
test_eq([[({"foo",0,"bar"})*"-"]],"foo-bar")
test_eq([[({1.0,"foo",0,"bar",this_object(),([])})*"-"]],"foo-bar")
test_eq([[({"f","o","o"})*""]],"foo")

// - indices
test_equal(indices("foo"),({0,1,2}))
test_equal(indices(({'f','o','o'})),({0,1,2}))
test_equal(Array.sort_array(indices(([7:3,8:9,99:12]))),({7,8,99}))
test_equal(Array.sort_array(indices((<7,8,99>))),({7,8,99}))
test_equal(mkmultiset(indices(this_object())),(<"a","b">))

// - lower_case
test_equal(lower_case("foo"),"foo")
test_equal(lower_case("Foo"),"foo")
test_equal(lower_case("Foo1234-*~\n"),"foo1234-*~\n")

// - next_object
test_true(objectp(next_object()))
test_any(int e;object o=next_object(); for(e=0;e<1000 && o;e++) o=next_object(o); return o,0)

// - object_program
test_true(programp(object_program(this_object())))

// - query_num_arg
test_eq(lambda(int ... q) { return query_num_arg(); }(),0)
test_eq(lambda(int ... q) { return query_num_arg(); }(1),1)
test_eq(lambda(int ... q) { return query_num_arg(); }(1,1),2)
test_eq(lambda(int ... q) { return query_num_arg(); }(1,1,1),3)
test_eq(lambda(int ... q) { return query_num_arg(); }(1,1,1,1),4)

// - random
test_any([[int e,d;for(e=0;e<1000;e++){d=random(10); if(d<0 || d>=10) return 0;} return 1]],1)

// random_seed
test_do(int p; foreach(({1,2,3,4,5}),p) random_seed(p))
test_eq([[random_seed(17),random(20000)]],[[random_seed(17),random(20000)]])
test_eq([[random_seed(18),random(20000)]],[[random_seed(18),random(20000)]])
test_eq([[random_seed(19),random(20000)]],[[random_seed(19),random(20000)]])

// - replace
test_eq(replace("foobargazonk","o","-"),"f--bargaz-nk")
test_eq(replace("foobargazonk",({"o","a"}),({"()","<>"})),"f()()b<>rg<>z()nk")
test_eq(replace("f--barf--",({"f--","f--bar"}),({"f--bar","f--"})),"f--f--bar")
test_eq(replace("f--barf--",({"f--bar","f--"}),({"f--","f--bar"})),"f--f--bar")
test_equal(replace(({1,2,3,4,5,1,2,3,4}),3,-1),({1,2,-1,4,5,1,2,-1,4}))
test_equal(replace(([1:2,3:4,5:1,2:3]),3,-1),([1:2,3:4,5:1,2:-1]))

// - reverse
test_eq(reverse("reverse"),"esrever")
test_eq(reverse(""),"")
test_eq(reverse("a"),"a")
test_equal(reverse(({1,5,9})),({9,5,1}))
test_equal(reverse(0x12345678),0x1e6a2c48)

// - rusage
test_true(arrayp(rusage()))
test_true(sizeof(rusage())>0)

// - search
test_eq(search("foolbar","gazonk"),-1)
test_eq(search("qowiueproqiuweproiwqueoplkjljlklksjjriwueproiuwerowieu","lkjljlklksjj"),24)
test_eq(search("lkjljlklksjjriwueproiuwerlskjdvlaskjfowieu","lkjljlklksjj"),0)
test_eq(search("aaaaaaaaaaaaaaaaaaaaaaaalkjljlklksjj","lkjljlklksjj"),24)
test_eq(search("foobargazonk","oo"),1)
test_eq(search("foobargazonk","o",3),9)
test_eq(search("foobargazonk","o",9),9)
test_eq(search("foobargazonk","o",10),-1)
test_eq(search("foobargazonk","x",9),-1)
test_eq(search(({56,8,2,6,2,7,3,56,7}),8),1)
test_eq(search(({56,8,2,6,2,7,3,56,7}),56,0),0)
test_eq(search(({56,8,2,6,2,7,3,56,7}),56,1),7)
test_eq(search(({56,8,2,6,2,7,3,56,7}),56,7),7)
test_eq(search(({56,8,2,6,2,7,3,56,7}),56,8),-1)
test_eq(search(({"foo"}),"foo"),0)
test_eq(search("fo-obar|gazonk"/"|","fo-obar"),0)
test_eq(search("fo-obar|gazonk"/"|","gazonk"),1)
test_eq(search(([1:2,3:4,5:6,7:8]),4),3)
test_true(zero_type(search(([1:2,3:4,5:6,7:8]),1)))
test_eq(search(([1:2,3:4,5:6,7:8]),8),7)

// test large searches (find string, size, pattern)
define(test_search,[[
test_eq(search(sprintf($1+"%'"+$3+"'*n",$2),$1),0)
test_eq(search(sprintf("%'"+$3+"'*n" ,$2),$1),-1)
test_eq(search(sprintf("%'"+$3+"'*n"+$1,$2),$1),$2)
test_eq(search(sprintf("%'"+$3+"'*n"+$1+"%'"+$3+"'*n",$2,$2),$1),$2)
]])

define(test_search2,[[dnl
test_search($1,$2,$3)
test_search($1,$2+1,$3)
test_search($1,$2+2,$3)
test_search($1,$2+3,$3)
test_search($1,$2+4,$3)
test_search($1,$2+5,$3)
]])

define(test_search3,[[dnl
test_search2($1,10,$2)
test_search2($1,1000,$2)
test_search2($1,100000,$2)
]])

define(test_search4,[[dnl
test_search3($1,"+-*")
test_search3($1,($1[..strlen($1)-2]))
test_search3($1,($1[..strlen($1)-3]))
test_search3($1,($1[1..]))
]])

test_search4("SUNE")
test_search4("kapit\344l>")
test_search4("-------------------+")
test_search4("\345-------------------")
test_search4(sprintf("%'argel-bargel glop-glyf?'2000n"))

// - sizeof
test_eq(sizeof("felbar"),6)
test_eq(sizeof(({"fulbar","gazonk",7})),3)
test_eq(sizeof(([8:3,6:6,7:0])),3)
test_eq(sizeof((<8,7,6,5,4,7>)),6)

// - sleep
test_do(sleep(1))
test_do(sleep(0.5))

// - sum
test_eq(`+(1,1),2)
test_eq(`+(1,-2),-1)
test_eq(`+(-2,-2),-4)
test_eq(`+("hi","there"),"hithere")
test_eq(`+("human","number",666),"humannumber666")
test_eq(`+("human","number",666),"humannumber666")
test_eq(`+("human","number",666),"humannumber666")
test_eq(`+("human","number",666,111),"humannumber666111")
test_eq(`+("humannumber",`+(666+111)),"humannumber777")
test_eq(`+("a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","x","y"),"abcdefghijklmnopqrstuvxy")
test_eq(`+(1.0+1.0),2.0)
test_eq(`+(1.0,-1.0),0.0)
test_eq(`+(-1.0,-1.0),-2.0)
test_equal(`+(({1,2,3}),({4,5,6})),({1,2,3,4,5,6}))
test_equal(`+((<1,2,3,4>),(<4,5,6>)),(<1,2,3,4,4,5,6>))
test_equal(`+(([0:1,3:6]),([5:2,3:6])),([0:1,3:6,3:6,5:2]))

// - this_object
test_true(objectp(this_object()))

// - throw
test_eq(20,catch(throw(a())))

// - time
test_true(intp(time()))

// - trace
test_do(trace(0))
test_eq(trace(0),0)

// - upper_case
test_equal(upper_case("fooq"),"FOOQ")
test_equal(upper_case("FooR"),"FOOR")
test_equal(upper_case("Foo1234-*~\n"),"FOO1234-*~\n")

// - values
test_equal(values("foo"),({'f','o','o'}))
test_equal(values(({'f','o','o'})),({'f','o','o'}))
test_equal(Array.sort_array(values(([7:3,8:9,99:12]))),({3,9,12}))
test_equal(values((<7,8,99>)),({1,1,1}))
test_equal(mkmultiset(values(this_object())),(<a,b>))

// - zero_type
test_eq(zero_type(0),0)
test_eq(zero_type(([])[7]),1)

test_program(int b=10; mixed a() { return 1; })
test_program(mixed b=10; mixed a() { return 1;})
test_define_program(test,[[int q,w,e,r,t; mixed foo() { return 10; }]])

test_program(inherit test; mixed a() { return foo()==10; })
test_program(inherit test; mixed a() { return test::foo()==10; })
test_program(inherit test : bar; mixed a() { return bar::foo()==10; })

test_define_program(test2,[[int z,x,c,v,b; mixed bar() { return 11; }]])
test_program(inherit test; inherit test2; mixed a() { return foo()==10 && bar()==11; })
test_program(inherit test2; inherit test; mixed a() { return foo()==10 && bar()==11; })

test_define_program(test,[[int q,w,e,r; mixed t; mixed getw() { return w; } void setw(int _) { w=_; }]])
test_define_program(test2,[[int z,x,c,v,b; mixed getb() { return b; } void setb(int _) { b=_; }]])

test_program(inherit test; inherit test2; mixed a() { w=20; b=22; return getw()==20 && getb()==22; })
test_program(inherit test; inherit test2; mixed a() { setw(20); setb(22); return w==20 && b==22; })
test_program(inherit test2; inherit test; mixed a() { w=20; b=22; return getw()==20 && getb()==22; })
test_program(inherit test2; inherit test; mixed a() { setw(20); setb(22); return w==20 && b==22; })

test_eval_error(clone(class{int i;void foo(){ destruct(this_object());i=0;}})->foo())

// Pike modules
// LR
test_true(LR.parser)
test_true(LR.Grammar_parser)
test_program([[ object(LR.parser) p=LR.Grammar_parser.make_parser("foo : bar;foo : foo bar;bar : \"a\";"); int pos; array(string) data="aaaaaaaaa"/""; string scan() { if (pos < sizeof(data)) return(data[pos++]); else return ""; } int a() { return(p->parse(scan) == "a"); }]])
