1169d92004-05-02Martin Nilsson START_MARKER
b13bc32009-06-30Martin Stjernholm test_true([["$Id: testsuite.in,v 1.876 2009/06/30 21:39:51 mast Exp $"]]);
4f9a0a2002-09-21Martin Stjernholm  // This triggered a bug only if run sufficiently early. test_compile_any([[#pike 7.2]])
5f174f2003-04-02Martin Nilsson test_compile_any([[#pike 7.4]]) test_compile_any([[#pike 7.0]]) test_compile_any([[#pike 0.6]])
ab01ea1999-09-21Fredrik Hübinette (Hubbe) 
694bb11998-04-23Fredrik Hübinette (Hubbe) cond([[all_constants()->_verify_internals]],
c0988f1998-04-17Fredrik Hübinette (Hubbe) [[ test_do(_verify_internals())
3b74641999-11-24Henrik Grubbström (Grubba) ]]); 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("\d32","\x20"); test_eq('Å',"Å"[0]); test_eq('\7777',"\7777"[0]); test_eq('\77777777',"\77777777"[0]); test_eq("\x10000","\x10000"); test_eq(0x80000000-0x80000000, 0); test_eq(0xf0000000-0xf0000000, 0); test_eq(0x80000001-0x80000000, 1); test_eq(0x80000000-0x80000001,-1); test_eq(-2147483648*-1, -2147483648/-1);
4fcc7a2004-03-12Henrik Grubbström (Grubba) cond([[ 0x8000000000000000 ]], [[ test_eq(0x8000000000000000-0x8000000000000000, 0); test_eq(0xf000000000000000-0xf000000000000000, 0); test_eq(0x8000000000000001-0x8000000000000000, 1); test_eq(0x8000000000000000-0x8000000000000001,-1); test_eq(-9223372036854775808*-1, -9223372036854775808/-1); ]])
3b74641999-11-24Henrik Grubbström (Grubba) test_true([[1.0e-40]]);
a83f8c1998-03-20Fredrik Hübinette (Hubbe) test_eq([[#"foo
3b74641999-11-24Henrik Grubbström (Grubba) bar"]],[["foo\nbar"]]);
b62bf62000-03-30Fredrik Hübinette (Hubbe) test_eq([[#"foo\ bar"]],[["foobar"]]);
3b74641999-11-24Henrik Grubbström (Grubba) test_true([[stringp(#string "Makefile")]]);
3488ef2000-04-17Henrik Grubbström (Grubba) test_any([[class Bar { array(int) foo = ({}); }; class Foo { inherit Bar; array(int) foo = ({1}); }; return sizeof(Foo()->foo);]],1);
87c9d21998-04-09Fredrik Hübinette (Hubbe) 
649dce2008-05-21Martin Stjernholm test_eq([["(" + 0x7fffffff + ")"]], "(2147483647)") test_eq([["(" + -0x80000000 + ")"]], "(-2147483648)") cond(0x8000000000000000, [[ test_eq([["(" + 0x7fffffffffffffff + ")"]], "(9223372036854775807)") test_eq([["(" + -0x8000000000000000 + ")"]], "(-9223372036854775808)") ]]) test_eq([["(" + Int.NATIVE_MAX + ")"]], [[sprintf ("(%d)", Int.NATIVE_MAX)]]) test_eq([["(" + Int.NATIVE_MIN + ")"]], [[sprintf ("(%d)", Int.NATIVE_MIN)]])
2166c02008-05-06Henrik Grubbström (Grubba) # __func__ test_eq(__func__, "a") test_eq("b", __func__)
3b74641999-11-24Henrik Grubbström (Grubba) test_eq(8, 0b1000); test_eq(-8, -0b1000); test_eq(16, 0b10000); test_eq(-16, -0b10000);
5656451999-10-26Fredrik Noring 
9262082003-02-26Martin Stjernholm test_true(1e-100000000000000000000000000000000000000000000000000000000000<=1e-10000)
6f35772003-02-26Mirar (Pontus Hagland) test_true(1e-10000<=1e-1000) test_true(1e-1000<=1e-100) test_true(1e-100<=1e-10) test_true(1e-10<=1e-1) test_true(1e-1<=1e1) test_true(1e1<=1e10) test_true(1e10<=1e100) test_true(1e100<=1e1000) test_true(1e1000<=1e10000)
9262082003-02-26Martin Stjernholm test_true(1e10000<=1e100000000000000000000000000000000000000000000000000000000000)
6f35772003-02-26Mirar (Pontus Hagland) 
b168bb2004-11-01Martin Stjernholm test_compile_warning('\3434523423423523423423423423') test_compile_warning("\3434523423423523423423423423") test_compile_warning("\d109827346981234561823743412654") test_compile_warning("\x109a27bc69e256c83deaa34c26b4") test_compile_error('\u17fo') test_compile_warning("\u17fo") test_compile_error('\uu117f')
aee0b52004-11-16Martin Stjernholm test_eq("\uuuu17fo", "\\uuu17fo")
b168bb2004-11-01Martin Stjernholm test_eq('\u117f', 0x117f) test_eq("\u117foo", "\10577oo") test_eq("\u1117foo", "\10427foo") test_eq("\uuuu117foo", "\\uuu117foo") test_compile_error('\U117f') test_compile_warning("\U117f") test_compile_warning("\UdEaDbEaT")
aee0b52004-11-16Martin Stjernholm test_eq("\UUdEaDbEaT", "\\UdEaDbEaT")
b168bb2004-11-01Martin Stjernholm test_eq('\UDeaDBeEF', -559038737) test_eq("\UDeaDBeEFFF", "\33653337357FF") test_eq("\UUDeaDBeEFFF", "\\UDeaDBeEFFF") test_any([[ // Suppress warnings. class handler { void compile_warning (string file, int line, string err) {}; }; return compile_string("string s = \"\\3434523423423523423423423423\";", "-", handler())()->s; ]], "\37777777777") test_any([[ // Suppress warnings. class handler { void compile_warning (string file, int line, string err) {}; }; return compile_string("int i = '\\3434523423423523423423423423';", "-", handler())()->i; ]], -1)
e80a292002-02-28Martin Stjernholm test_do([[
bcc7d62002-04-12Martin Nilsson  // bug 2677
e80a292002-02-28Martin Stjernholm  int x; if (time()) x = 1; else foo: break foo; ]])
14dd022002-06-11Henrik Grubbström (Grubba) test_any([[ // bug 2690 array(function) foo(void|int b) { int add() { return b++; }; return ({ add, add }); }; array(function) bar = foo(); return equal(({`==(@bar),@bar()}), ({ 1, 0, 1 })); ]], 1)
805ea62002-02-26Martin Stjernholm test_any([[ int f (int i) {i = 0; return i;}; return f (1); ]],0)
fa78922001-07-28Fredrik Hübinette (Hubbe) test_any([[
c209412002-11-13Henrik Grubbström (Grubba)  // Test that F_TAIL_RECUR and RECUR work properly. class X { int Ack(int M, int N) { if (M == 0) return( N + 1 ); if (N == 0) return( Ack(M - 1, 1) ); return( Ack(M - 1, Ack(M, (N - 1))) ); } }; return X()->Ack(3,5); ]],253) test_any([[ // Test that F_COND_RECUR works properly.
daf6492002-11-14Henrik Grubbström (Grubba)  // This test forces F_COND_RECUR to fail.
c209412002-11-13Henrik Grubbström (Grubba)  class X { int Ack(int M, int N) { if (M == 0) return( N + 1 ); if (N == 0) return( Ack(M - 1, 1) ); return( Ack(M - 1, Ack(M, (N - 1))) ); } };
fa78922001-07-28Fredrik Hübinette (Hubbe) 
daf6492002-11-14Henrik Grubbström (Grubba)  class Y { inherit X; int Ack(int M, int N) { return ::Ack(M, N); } };
fa78922001-07-28Fredrik Hübinette (Hubbe) 
c209412002-11-13Henrik Grubbström (Grubba)  return Y()->Ack(2,2);
fa78922001-07-28Fredrik Hübinette (Hubbe) ]],7)
20043f2008-07-17Henrik Grubbström (Grubba) test_any([[ // Test that F_RECUR et al are not used for inlined functions // where the scope is in use. class X { inline function(int:int) foo(int x, int y) { if (y) return foo(x+y, y-1); return lambda(int z) { return x+z; }; } }; return X()->foo(10, 3)(5); ]], 21)
ce9bfb2002-12-20Henrik Grubbström (Grubba) test_any([[ // Test that loop optimizer isn't too aggressive. // Thanks to Alexander Demenshin <aldem-pike@aldem.net> int x,y,a; for(;x<10000;x++) { y += (x - a++); } return a; ]], 10000) test_any([[ // Test that loop optimizer isn't too aggressive. // Thanks to Alexander Demenshin <aldem-pike@aldem.net> mapping m = ([]); for(;m->x<10000;m->x++) { m->y += (m->x - m->a++); } return m->a; ]], 10000)
4ce36d2003-01-29Marcus Comstedt test_any([[ // Test that loop optimizer isn't too aggressive. // Thanks to me. / Marcus for(int i=0; i<3.0; i++) if(i>4.0) return -1; return 0; ]], 0)
f88fda2003-03-21Johan Sundström test_any([[ // Test that optimizer notes side effects in arguments to `!= // Thanks to Marcus Agehall int j = 20, i; string end = "17"; for( ; i < j ; i++) if(sscanf(end, "%d%s", j, end) != 2) cd("."); return i; ]], 17)
9002ef2004-04-29Martin Nilsson test_any([[ // Another over-optimization test. string x(string i) { return i; }; return x("")+1+1; ]], "11")
f538022003-02-25Marcus Comstedt test_compile_any([[
1615822008-01-04Henrik Grubbström (Grubba)  mixed foo()
f538022003-02-25Marcus Comstedt  { Stdio.File bar(int x, int y) { return 0;
1615822008-01-04Henrik Grubbström (Grubba)  }; return bar;
f538022003-02-25Marcus Comstedt  } ]])
7a84422003-10-10Martin Stjernholm test_compile_any([[ string foo (string a, string b, string c, string d, string e, string f, string g) { string out; if (a) out = "foo"; else out = "bar"; return out; } ]])
2fa1222006-03-01Henrik Grubbström (Grubba) dnl number of variables/scope, number of scopes, expect_compiler_error define(test_scopes,[[
887c592006-03-01Henrik Grubbström (Grubba)  test_any([[
5520722007-06-18Martin Stjernholm  write("Testing scoped variables $1:$2%s...\n", $3?" expecting a compilation error":"");
887c592006-03-01Henrik Grubbström (Grubba)  string line = sprintf("#line %d %O\n", __LINE__, __FILE__);
2fa1222006-03-01Henrik Grubbström (Grubba)  string s = "{\n" + (map(indices(allocate($1)), lambda(int no) { no++; return sprintf(" int var_%d;\n" " if (var_%d)\n" " error(\"Variable var_%d not \"\n" " \"initialized to zero: \"\n" " \"%%O\\n\",\n" " var_%d);\n" " var_%d = %d;\n", no, no, no, no, no, no); }) + map(indices(allocate($1)), lambda(int no) { no++; return sprintf(" if (var_%d != %d)\n" " error(\"Variable var_%d was \"\n" " \"clobbered with %%O.\\n\",\n" " var_%d);\n", no, no, no, no); })) * "" + "}\n"; program p;
d553522007-06-18Martin Stjernholm  if ($3) master()->set_inhibit_compile_errors (1);
2fa1222006-03-01Henrik Grubbström (Grubba)  mixed err = catch { p = compile_string("int a() {\n" + line + (s * $2) + " return 0;\n" "}\n"); }; if ($3) {
d553522007-06-18Martin Stjernholm  master()->set_inhibit_compile_errors (0);
2fa1222006-03-01Henrik Grubbström (Grubba)  if (err) return 0; error("Expected a compilation error for $1 variables in $2 scope%s.\n", ($2>1)?"s":""); } if (err) throw(err);
887c592006-03-01Henrik Grubbström (Grubba)  return p()->a(); ]], 0) ]])
2fa1222006-03-01Henrik Grubbström (Grubba) test_scopes(255, 1, 0) test_scopes(256, 1, 1) test_scopes(16, 17, 0) test_scopes(17, 16, 0)
4ce36d2003-01-29Marcus Comstedt 
078c602006-03-02Henrik Grubbström (Grubba) test_any([[ // LysLysKOM 14180500 if (1) { string var = "Reinitialization error."; } sscanf("", "%d", int zero); return zero; ]], 0);
414ab92006-03-04Henrik Grubbström (Grubba) test_any([[ // LysLysKOM 14189033 int i; for (i = 0; i < 4; i++) { sscanf("", "%d", int test); if (test) return test; test = i+1; } return 0; ]], 0)
ae0ac12002-11-14Henrik Grubbström (Grubba) dnl FIXME: Add test that local and local:: in combination dnl with recursion works correctly.
3b74641999-11-24Henrik Grubbström (Grubba) test_eval_error([[mixed x; return mkmapping(x,x)]]);
97431e1999-03-19Fredrik Hübinette (Hubbe) 
3488ef2000-04-17Henrik Grubbström (Grubba) test_eval_error([[class Foo { void bar() {} void foo() {destruct(this_object());bar();} }; Foo()->foo(); ]])
7ddaa32000-08-22Martin Stjernholm test_do([[ void foo (int i) { multiset res = (<>); if (i) res = res; }; foo (1); ]])
5e44422001-02-25Fredrik Hübinette (Hubbe) test_any([[ array tmp=({}); tmp=({([])})+tmp; tmp->foo=7; tmp=({([])})+tmp; return sizeof(tmp[0]); ]], 0)
52032c2008-05-12Henrik Grubbström (Grubba) test_any([[ // Bug 4537. void fiddle(array(int) a) { a += ({ 2 }); }; array(int) a = ({ 1 }); fiddle(a); return sizeof(a); ]], 1)
5e44422001-02-25Fredrik Hübinette (Hubbe) 
fdd6a82008-10-13Mirar (Pontus Hagland) dnl bug in for loop optimization in combination with += test_any([[ array v=({1,2,3}); for (int i=0; i<sizeof(v); i++) for (int j=0; j<i; j++) { v+=({1+i}); if (i==17) { i=10000; break; } } return sizeof(v); // if buggy, will be 6 and not 140 ]], 140); test_any([[ array v=({1,2,3}); for (int i=0; i<sizeof(v); i++) for (int j=0; j<i; j++) { v=v+({1+i}); if (i==17) { i=10000; break; } } return sizeof(v); // not buggy, will be 140 ]], 140);
3b74641999-11-24Henrik Grubbström (Grubba) test_any([[int a=0xffffffff; return a+17]], 0x100000010); test_any([[int a=0xffffffff; return a-17]], 0xffffffee); test_any([[int a=0xffffffff; return a*17]], 0x10ffffffef); test_any([[int a=0xffffffff; return a^17]], 0xffffffee); test_any([[int a=0xffffffff; return a&17]], 17); test_any([[int a=0xffffffff; return a|17]], 0xffffffff); test_any([[int a=0xffffffff; return a<<17]], 0x1fffffffe0000);
2b2df21999-11-01Henrik Grubbström (Grubba)  test_any([[ int a=0xffffffff; return a/17 ]],
3b74641999-11-24Henrik Grubbström (Grubba)  [[ (0xffffffff == -1)?-1:0x0f0f0f0f ]]);
2b2df21999-11-01Henrik Grubbström (Grubba) test_any([[ int a=0xffffffff; return a%17 ]],
3b74641999-11-24Henrik Grubbström (Grubba)  [[ (0xffffffff == -1)?16:0 ]]);
2b2df21999-11-01Henrik Grubbström (Grubba) test_any([[ int a=0xffffffff; return a>>17 ]],
3b74641999-11-24Henrik Grubbström (Grubba)  [[ (0xffffffff == -1)?-1:0x7fff ]]);
71a4bf2007-05-03Henrik Grubbström (Grubba) test_any([[return sprintf("%O", typeof(aggregate("foo")));]], "array(string(0..255))");
4405922000-05-25Henrik Grubbström (Grubba) test_any([[int a; return sprintf("%O", typeof(aggregate(a)));]], "array(int)");
3b74641999-11-24Henrik Grubbström (Grubba) test_any([[int|string a;
4405922000-05-25Henrik Grubbström (Grubba)  string s = sprintf("%O", typeof(aggregate(a)));
3b30c92007-04-03Henrik Grubbström (Grubba)  return (< "array(string) | array(int)", "array(string | int)", "array(int | string)" >)[s];]], 1);
4405922000-05-25Henrik Grubbström (Grubba) test_any([[return sprintf("%O", typeof(aggregate()));]], "array(zero)");
1954be1999-12-10Henrik Grubbström (Grubba) test_any([[int i; return (< "int", "int | zero", "zero | int" >)
4405922000-05-25Henrik Grubbström (Grubba)  [sprintf("%O", typeof(max(i,0)))];]], 1)
3b74641999-11-24Henrik Grubbström (Grubba) 
4405922000-05-25Henrik Grubbström (Grubba) test_any([[array(string) a; return sprintf("%O", typeof(a[0])); ]], "string")
3b74641999-11-24Henrik Grubbström (Grubba)  test_any([[class foo { string a; }; object(foo) bar;
4405922000-05-25Henrik Grubbström (Grubba)  return sprintf("%O", typeof(bar->a));]], "string");
3b74641999-11-24Henrik Grubbström (Grubba)  test_any([[class foo { string a; }; array(object(foo)) bar;
4405922000-05-25Henrik Grubbström (Grubba)  return sprintf("%O", typeof(bar[0]->a));]], "string");
94b5241999-11-01Mirar (Pontus Hagland) 
4405922000-05-25Henrik Grubbström (Grubba) test_any([[function(:string)|function(int:int) f; return sprintf("%O", typeof(f())); ]],
f2e6a41999-11-24Henrik Grubbström (Grubba)  "string")
4405922000-05-25Henrik Grubbström (Grubba) test_any([[function(:string)|function(int:int) f; return sprintf("%O", typeof(f(1))); ]],
f2e6a41999-11-24Henrik Grubbström (Grubba)  "int")
dc19e71999-11-24Henrik Grubbström (Grubba) test_any([[function(:string)|function(mixed, mixed...:int) f;
4405922000-05-25Henrik Grubbström (Grubba)  return sprintf("%O", typeof(f())); ]],
dc19e71999-11-24Henrik Grubbström (Grubba)  "string") test_any([[function(:string)|function(mixed, mixed ...:int) f;
4405922000-05-25Henrik Grubbström (Grubba)  return sprintf("%O", typeof(f(1))); ]],
dc19e71999-11-24Henrik Grubbström (Grubba)  "int")
00091b1999-12-05Martin Stjernholm test_any([[mapping(object:string)|mapping(string:int) f;
4405922000-05-25Henrik Grubbström (Grubba)  return sprintf("%O", typeof(f[class{}()])); ]],
00091b1999-12-05Martin Stjernholm  "string") test_any([[mapping(object:string)|mapping(string:int) f;
4405922000-05-25Henrik Grubbström (Grubba)  return sprintf("%O", typeof(f[""])); ]],
00091b1999-12-05Martin Stjernholm  "int") test_any([[mapping(object:string)|mapping(string:int) f;
4405922000-05-25Henrik Grubbström (Grubba)  return sort((sprintf("%O", typeof(f[0])) - " ")/"|")*"|"; ]],
00091b1999-12-05Martin Stjernholm  "int|string")
4d7b181999-12-07Fredrik Hübinette (Hubbe) test_any([[class Foo { string `[](mixed y) {return "";} };
b6733a1999-12-05Henrik Grubbström (Grubba)  object(Foo) foo;
4405922000-05-25Henrik Grubbström (Grubba)  return sprintf("%O", typeof(foo[0])); ]],
b6733a1999-12-05Henrik Grubbström (Grubba)  "string")
f600911999-12-05Henrik Grubbström (Grubba) test_any([[class Foo { array(int) _indices() {return ({0});} };
b6733a1999-12-05Henrik Grubbström (Grubba)  object(Foo) foo;
4405922000-05-25Henrik Grubbström (Grubba)  return sprintf("%O", typeof(indices(foo))); ]],
f600911999-12-05Henrik Grubbström (Grubba)  "array(int)")
b6733a1999-12-05Henrik Grubbström (Grubba)  test_any([[class Foo { array(string) _values() {return ({""});} }; object(Foo) foo;
4405922000-05-25Henrik Grubbström (Grubba)  return sprintf("%O", typeof(values(foo))); ]],
b6733a1999-12-05Henrik Grubbström (Grubba)  "array(string)")
ffb7fe1999-12-08Henrik Grubbström (Grubba) test_any([[mapping(string:int) foo; array(string) bar;
4405922000-05-25Henrik Grubbström (Grubba)  return sprintf("%O", typeof(rows(foo, bar))); ]],
ffb7fe1999-12-08Henrik Grubbström (Grubba)  "array(int)")
85ff732001-07-03Martin Stjernholm test_any([[{ class Foo { mixed m;
537f1e2001-07-03Henrik Grubbström (Grubba)  };
85ff732001-07-03Martin Stjernholm  class Bar { inherit Foo; string m; Foo b;
537f1e2001-07-03Henrik Grubbström (Grubba)  mixed f() { return typeof(b->m); } };
f704a22001-07-03Henrik Grubbström (Grubba)  Foo c; Bar d;
537f1e2001-07-03Henrik Grubbström (Grubba)  return sprintf("%O$%O$%O$%O", Bar()->f(), typeof(c->m), typeof(d->m), typeof(d->b->m));
f704a22001-07-03Henrik Grubbström (Grubba) }]], "mixed$mixed$string$mixed")
85ff732001-07-03Martin Stjernholm 
32efc92003-03-07Henrik Grubbström (Grubba) // las.c:find_return_type() checks. test_eq([[ // Test case from Robert J. Budzynski <Robert.Budzynski@fuw.edu.pl>. // When broken the return type will be mixed. sprintf("%O", typeof(lambda(string s){ return Locale.Charset.decoder("utf-8")->feed(s)->drain(); })) ]], [[ "function(string : string)" ]])
9d3a7a2005-02-18Henrik Grubbström (Grubba) // Test implicit lambda. test_eq([[ `()(){ return 1; } ]], 1)
d967202004-02-28Martin Stjernholm // Argument checking // Test get_all_args. test_eval_error([[ // A trick to get some svalues to freed refcounted stuff on the stack. lambda (mixed a, mixed b, mixed c) {} (({time()}), ({time()}), ({time()})); // set_weak_flag is chosen since it calls get_all_args with an // argument spec that contains two arguments of different types. ([function] set_weak_flag)(); ]]) test_eval_error([[ lambda (mixed a, mixed b, mixed c) {} (({time()}), ({time()}), ({time()})); ([function] set_weak_flag) (17); ]]) test_eval_error([[ lambda (mixed a, mixed b, mixed c) {} (({time()}), ({time()}), ({time()})); ([function] set_weak_flag) ("foo"); ]]) test_eval_error([[ lambda (mixed a, mixed b, mixed c) {} (({time()}), ({time()}), ({time()})); ([function] set_weak_flag) (17, "foo"); ]])
ac1e892009-03-11Marcus Comstedt // Check that write() and error() with one argument are not // incorrectly subjected to sprintf() argument test_compile([[write("%\u2323");]]) test_compile([[error("%\u2323");]])
5bcd222001-02-21Mirar (Pontus Hagland) // type checks define(test_type_error, [[ test_compile_error([[ $1 x; x=$3; ]])
6b3f5c2002-04-11Martin Nilsson  test_compile_error_any([[ class ErrBa { $1 x() { return $3; } } ]]) test_compile_error_any([[ class ErrBa { $1 x() { $2 a=$3; return a; } } ]])
5bcd222001-02-21Mirar (Pontus Hagland) ]]) test_type_error(int,float,17.23) test_type_error(int,array,({1,2,3})) test_type_error(int,mapping,([1:2,3:4])) test_type_error(int,multiset,(<1,2,3>)) test_type_error(int,function,lambda() { return 17; }) test_type_error(int,program,object_program(this_object())) test_type_error(int,object,this_object()) test_type_error(float,int,17) test_type_error(float,array,({1,2,3})) test_type_error(float,mapping,([1:2,3:4])) test_type_error(float,multiset,(<1,2,3>)) test_type_error(float,function,lambda() { return 17; }) test_type_error(float,program,object_program(this_object())) test_type_error(float,object,this_object()) test_type_error(array,int,17) test_type_error(array,float,17.23) test_type_error(array,mapping,([1:2,3:4])) test_type_error(array,multiset,(<1,2,3>)) test_type_error(array,function,lambda() { return 17; }) test_type_error(array,program,object_program(this_object())) test_type_error(array,object,this_object()) test_type_error(mapping,int,17) test_type_error(mapping,float,17.23) test_type_error(mapping,array,({1,2,3})) test_type_error(mapping,multiset,(<1,2,3>)) test_type_error(mapping,function,lambda() { return 17; }) test_type_error(mapping,program,object_program(this_object())) test_type_error(mapping,object,this_object()) test_type_error(multiset,int,17) test_type_error(multiset,float,17.23) test_type_error(multiset,array,({1,2,3})) test_type_error(multiset,mapping,([1:2,3:4])) test_type_error(multiset,function,lambda() { return 17; }) test_type_error(multiset,program,object_program(this_object())) test_type_error(multiset,object,this_object()) test_type_error(function,int,17) test_type_error(function,float,17.23) test_type_error(function,array,({1,2,3})) test_type_error(function,mapping,([1:2,3:4])) test_type_error(function,multiset,(<1,2,3>)) test_type_error(program,int,17) test_type_error(program,float,17.23) test_type_error(program,array,({1,2,3})) test_type_error(program,mapping,([1:2,3:4])) test_type_error(program,multiset,(<1,2,3>)) test_type_error(object,int,17) test_type_error(object,float,17.23) test_type_error(object,array,({1,2,3})) test_type_error(object,mapping,([1:2,3:4])) test_type_error(object,multiset,(<1,2,3>))
b5ca842009-06-22Henrik Grubbström (Grubba) test_any_equal([[ // This code caused a NULL dereference in Pike 7.8.306 and earlier. indices foo; return typeof(foo); ]], typeof(indices((mixed)0)))
b8efef2008-09-12Henrik Grubbström (Grubba) // Check that complex function types survive soft casting to function.
a4cf892008-09-12Henrik Grubbström (Grubba) ignore_warning("Soft cast of scope(0,function(*)) to function is a noop.", [[
b8efef2008-09-12Henrik Grubbström (Grubba)  test_eq(typeof([function]`+), typeof(`+)) ]])
f900a92005-01-17Henrik Grubbström (Grubba) test_any([[ /* Detect bug in modify_shared_string(). * * Note: For proper operation this test depends on HASH_PREFIX being * <= 128, and the initial string in test having a single ref. */ string prefix = "A"*128; string suffix = "B"*128; string test = prefix + "C" + suffix; string match = prefix + "D" + suffix; if (test == match) return("Early match!"); test[128] = 'D'; if (test != match) return("Late mismatch!"); ]], 0)
5bcd222001-02-21Mirar (Pontus Hagland) test_compile_error([[ string a="abcb"; a=a/"b"; ]]) test_compile_error([[ string a="abcb"; a/="b"; ]]) test_compile_error([[ string a="abcb"; string b="b"; a=a/b; ]]) test_compile_error([[ string a="abcb"; string b="b"; a/=b; ]]) test_compile_error([[ string a="x"; int b; b="x"*17; ]]) test_compile_error([[ string a="x"; array b; b="x"*17; ]]) test_compile_error([[ int b=17; string a; a=b*42; ]]) test_compile_error([[ int b=17; float c=42.0; b=b/c; ]]) test_compile_error([[ int b=17; float c=42.0; b/=c; ]]) test_compile_error([[ int b=17; float c=42.0; b=b*c; ]]) test_compile_error([[ int b=17; float c=42.0; b*=c; ]])
2d190e2001-02-21Mirar (Pontus Hagland) test_compile_error([[ int b=17; float c=42.0; b=b+c; ]]) test_compile_error([[ int b=17; float c=42.0; b+=c; ]]) test_compile_error([[ int b=17; float c=42.0; b=b-c; ]]) test_compile_error([[ int b=17; float c=42.0; b-=c; ]])
5bcd222001-02-21Mirar (Pontus Hagland) test_compile_error([[ float b=17.0; string a; a=b*42; ]]) test_compile_error([[ float b=17.0; string a; a=b*42.0; ]])
9692ed2001-12-20Martin Stjernholm test_compile_error([[class F {inherit master()->dirnode;};]]);
eea2162008-07-11Martin Stjernholm test_any([[ class A { constant i = -1; string f() { return ([1: "foo"])[i] || "bar"; // No warning here. C.f. lyslys 16630665. } }; class B { inherit A; constant i = 1; }; return B()->f(); ]], "foo")
e36a502008-05-24Henrik Grubbström (Grubba) ignore_warning("Wrong return type.", [[ ignore_warning("Expected: string.", [[ ignore_warning("Got : array(string).", [[
f453ae2008-05-22Martin Stjernholm test_program_equal([[ #pike 7.6 string a() { string|array(string) res = ({"spud"}); return res + ({}); } ]], ({"spud"}))
e36a502008-05-24Henrik Grubbström (Grubba) ]])]])]])
f453ae2008-05-22Martin Stjernholm 
18cfc12002-05-24Martin Nilsson // Warnings test_compile_warning([[ int *a ]]) test_compile_warning([[ int|float *a ]]) test_compile_warning([[ [mixed]1 ]])
90bf262004-01-15Martin Nilsson test_compile_warning([[ class A { int a = 6; }; class B { constant a = 5; inherit A; }; ]])
18cfc12002-05-24Martin Nilsson 
5bcd222001-02-21Mirar (Pontus Hagland) //
6447302000-03-10Henrik Grubbström (Grubba) test_any([[ class Foo { constant zero = 0; mapping(string:array(int)) m;
4405922000-05-25Henrik Grubbström (Grubba)  string foo() { return sprintf("%O", typeof(m[""][zero])); }
6447302000-03-10Henrik Grubbström (Grubba)  }; return Foo()->foo(); ]], "int")
a915882000-09-20Fredrik Noring test_compile_any([[ class { ; } ]]) test_compile_any([[ class { ; ; } ]]) test_compile_any([[ class { ; constant c = 0; } ]])
107a0a2001-01-16Fredrik Hübinette (Hubbe) test_compile_any([[
1615822008-01-04Henrik Grubbström (Grubba)  class { mixed a() { constant c = 17; return c; } mixed b() { constant c = 17; return c; } }
107a0a2001-01-16Fredrik Hübinette (Hubbe) ]])
9847f11999-11-27Martin Stjernholm test_compile_any([[ constant FOO = 0; mapping(int:string) foo = ([FOO: "foo"]); ]])
7612332000-03-30Henrik Grubbström (Grubba) test_compile_error([[
099be62000-03-30Henrik Grubbström (Grubba)  function(...:int) foo; ]]);
7612332000-03-30Henrik Grubbström (Grubba) test_compile_error([[
099be62000-03-30Henrik Grubbström (Grubba)  function(,...:int) foo; ]]);
7612332000-03-30Henrik Grubbström (Grubba) test_compile_error([[
099be62000-03-30Henrik Grubbström (Grubba)  function(string,...:int) foo; ]]);
f0a7652008-06-24Martin Stjernholm test_compile_any([[ #pragma strict_types void x (void|mapping(string:string) args) { if (args) foreach (indices (args), string a) werror ("%O\n", a); } ]]) // For some reason, the test above doesn't generate the warning (about // the type from indices (args)) if it comes after the one below. // Also, if it is repeated it doesn't generate the warning the second // time. Not very reassuring.. /mast
d0cd2f1998-11-08Fredrik Hübinette (Hubbe) test_any([[return class Z { string bonk() { return "oiff"; } class A { string bonk_me() { return bonk(); } } class B { inherit A; } class C { string oiff() { return "bonk"; } class D { inherit B; } } }()->C()->D()->bonk_me()]],"oiff")
1cc0682008-09-14Henrik Grubbström (Grubba) test_any_equal([[ // Test hiding of inherited symbols with protected. class A { local mixed a() {} mixed b(); mixed c; local mixed d; extern mixed e; local mixed f; this_program get_a() { return this_program::this; } }; class B { inherit A; protected mixed a() {} protected mixed b() {} protected mixed c = a(); protected mixed d = b(); protected mixed e = a(); protected local mixed f = b(); this_program get_b() { return this_program::this; } }; class C { inherit B; this_program get_c() { return this_program::this; } }; class D { inherit C; this_program get_d() { return this_program::this; } }; object(D) d = D(); return ({ "A", sort(indices(d->get_a())), "B", sort(indices(d->get_b())), "C", sort(indices(d->get_c())), "D", sort(indices(d->get_d())) }); ]], ({ "A", ({ "a", "b", "c", "d", "e", "f", "get_a" }), "B", ({ "get_a", "get_b" }), "C", ({ "get_a", "get_b", "get_c" }), "D", ({ "get_a", "get_b", "get_c", "get_d" }) })) test_any_equal([[ // Test hiding of inherited symbols with private. class A { local mixed a() {} mixed b(); mixed c; local mixed d; extern mixed e; local mixed f; this_program get_a() { return this_program::this; } }; class B { inherit A; private mixed a() {} private mixed b() {} private mixed c = a(); private mixed d = b(); private mixed e = a(); private local mixed f = b(); this_program get_b() { return this_program::this; } }; class C { inherit B; this_program get_c() { return this_program::this; } }; class D { inherit C; this_program get_d() { return this_program::this; } }; object(D) d = D(); return ({ "A", sort(indices(d->get_a())), "B", sort(indices(d->get_b())), "C", sort(indices(d->get_c())), "D", sort(indices(d->get_d())) }); ]], ({ "A", ({ "a", "b", "c", "d", "e", "f", "get_a" }), "B", ({ "get_a", "get_b" }), "C", ({ "get_a", "get_b", "get_c" }), "D", ({ "get_a", "get_b", "get_c", "get_d" }) }))
d1e8d12009-06-24Henrik Grubbström (Grubba) test_any([[ // Test that backtraces with prototypes are rendered correctly by // describe_backtrace() et al. These backtraces have caused both // "Bad offset" and "Identifier reference index out of range".
76ed452009-06-24Henrik Grubbström (Grubba)  class A { void foo(); }; class B { int gazonk; inherit A; void bar() { foo(); } };
d1e8d12009-06-24Henrik Grubbström (Grubba)  return sizeof(describe_backtrace(catch { B()->bar(); })) > 0; ]], 1)
64b1dd2009-06-21Henrik Grubbström (Grubba) test_any([[ // Test multiple inherit of same symbol, // where later symbol is protected. class A { constant foo = 1; }; class B { constant foo = 2; }; class C { inherit A; protected inherit B; }; return C()->foo; ]], 1) test_any([[ // Test multiple inherit of same symbol, // where later symbol is protected. class A { constant foo = 1; }; class B { protected constant foo = 2; }; class C { inherit A; inherit B; }; return C()->foo; ]], 1)
f99b1e2008-09-15Henrik Grubbström (Grubba) test_any_equal([[ // Test that extern works as intended. class A { extern mixed foo; }; class B { inherit A; mixed foo; object get_a() { return A::this; } }; object(B) b = B(); b->foo = 17; array res = ({ b->foo, b->get_a()->foo }); b->get_a()->foo = 10; return res + ({ b->foo, b->get_a()->foo }); ]], ({ 17, 17, 10, 10 })) test_eval_error([[ // Test that extern works as intended. class A { extern mixed foo; }; class B { inherit A; mixed bar; }; object(B) b = B(); b->bar = 17; b->foo = 10; return b->foo; ]])
f73a7b2000-02-09Fredrik Hübinette (Hubbe) test_compile_error([[ class A { constant q = "x"; } class B { inherit A; string z="z"; constant q="x"+z; } ]])
bff94f2000-09-10Mirar (Pontus Hagland) test_compile_any([[ class A { object x(int y) { return B(y); } } class B { void create(int y) { } } ]])
5f05c11999-12-27Fredrik Hübinette (Hubbe) 
eb46772003-02-24Martin Stjernholm // Test that prototypes evaluate to zero. test_any([[ class Foo {int foo();}; return Foo()->foo == 0; ]], 1) test_any_equal([[ class Foo {int foo();}; return indices(Foo()); ]], ({"foo"})) test_any_equal([[ class Foo {int foo();}; return values(Foo()); ]], ({0}))
0d6adc2001-07-04Henrik Grubbström (Grubba) test_any([[ class Foo { int foo();
65f2282001-07-04Henrik Grubbström (Grubba)  int(0..1) f()
0d6adc2001-07-04Henrik Grubbström (Grubba)  {
eb46772003-02-24Martin Stjernholm  return foo == 0;
0d6adc2001-07-04Henrik Grubbström (Grubba)  }
a27a682001-07-04Henrik Grubbström (Grubba)  };
0d6adc2001-07-04Henrik Grubbström (Grubba)  return Foo()->f(); ]], 1) test_any([[ class Foo { int foo();
eb46772003-02-24Martin Stjernholm  int(0..1) f() { return functionp(foo); } }; class Bar { inherit Foo; int foo() {}
a27a682001-07-04Henrik Grubbström (Grubba)  };
eb46772003-02-24Martin Stjernholm  return Bar()->f();
0d6adc2001-07-04Henrik Grubbström (Grubba) ]], 1)
5f05c11999-12-27Fredrik Hübinette (Hubbe) test_do([[ class Foo { inherit Stdio.File; void create() { } }; class Bar { int y; class Gazonk { inherit Foo; void create(Stdio.File f) { assign(f); } } void create() { Gazonk(Stdio.stdin); } }; Bar(); ]])
8131642001-01-17Martin Stjernholm test_any([[ object f = class { array recursive(mixed func, array data, mixed ... args) { array ret=({}); foreach(data, mixed foo) { if(arrayp(foo)) { ret+=({ recursive(func, foo, @args) }); }else{ ret+=({ foo }); } } return func(ret, @args); }; }(); mixed x = ({ "A", ({}) }); x = f->recursive(replace, x, "B", ({})); for(int i = 0; i < sizeof(x); i++) { if (!stringp(x[i]) && !arrayp(x[i])) return 0; } return 1; ]], 1);
c22d272002-04-09Henrik Grubbström (Grubba) test_compile_error( [[ // This triggs a compiler bug on old Pike 7.3. non_existant(17) { return 0; } ]])
deb36c2008-11-21Henrik Grubbström (Grubba) test_compile_error( [[ // This triggs a segfault on Pike 7.4. void f() { constant days = ([ "1" : "Sunday" "2" : "Monday" ]); } ]])
3c995d2004-03-18Henrik Grubbström (Grubba) test_compile_error( [[ // This triggs a compiler bug on old Pike 7.5. return lambda(object (([mixed]a)->syntax_error) { return 0; }(0); ]])
a884df2007-05-04Henrik Grubbström (Grubba) test_compile_error( [[ // [bug 4362] This triggs a segfault on some versions of Pike 7.7. mixed x = all_constants()[undefined_identifier]; ]])
372e472008-05-07Martin Stjernholm test_compile_any([[ #pike 7.4 #pragma strict_types string x (string s) {return s;} void y (void|string s) {x (s);} ]])
8a1fe12008-05-08Henrik Grubbström (Grubba) test_compile_warning([[ #pragma strict_types // NB: This case used to leak the type function(:string).
c616602008-05-08Henrik Grubbström (Grubba)  string x (string s) {return s;}; void y (string|int s) {x (s);};
8a1fe12008-05-08Henrik Grubbström (Grubba) ]])
f938952008-08-07Martin Stjernholm test_compile_any([[ #pragma strict_types array(string) x = ({"A", "B"}); mixed a() {return map (x, lower_case);} ]])
1d96e72003-01-15Martin Nilsson cond( [[ master()->resolv("Pike")->Security ]],[[ test_any( [[ // bug [2830] ------------------------------------------------------------ // http://community/crunch/show_bug.cgi?id=2830 class User{};
0cfe852002-03-08Henrik Grubbström (Grubba) 
1d96e72003-01-15Martin Nilsson  object luser = User();
0cfe852002-03-08Henrik Grubbström (Grubba) 
1d96e72003-01-15Martin Nilsson  object luser_creds = Pike.Security.Creds(luser, 0, 0); return !catch {
c42aef2003-09-06Martin Nilsson  return !!Pike.Security.call_with_creds(luser_creds, Stdio.File, "/dev/null");
1d96e72003-01-15Martin Nilsson  }; return 0; ]], 0 ) ]])
0cfe852002-03-08Henrik Grubbström (Grubba) 
ef0a502001-09-23Mirar (Pontus Hagland) test_any( [[ // bug [1996] ------------------------------------------------------------ // http://community/crunch/show_bug.cgi?id=1996 class Implementation { int foo() { return 1; } }; class Prototype { int foo(); int bar() { return foo(); } }; class Test { inherit Implementation; inherit Prototype; int test() { return bar(); } }; return Test()->test(); ]], 1 ); test_any( [[ // bug [721] ------------------------------------------------------------- // http://community/crunch/show_bug.cgi?id=721 int res=0; catch { add_constant("test_a",compile_string("int foo();","test_a")); add_constant("test_b",compile_string("int foo();","test_b")); add_constant("test_c",compile_string( "inherit test_a;\n" "inherit test_b;\n" "final int foo() { return 1; }\n","test_c")); res=compile_string("inherit test_c;\n","test_d")()->foo(); }; return res; ]],1);
9040cc2002-10-14Martin Nilsson test_do(add_constant("test_a")) test_do(add_constant("test_b")) test_do(add_constant("test_c"))
ef0a502001-09-23Mirar (Pontus Hagland) 
8d813e2001-09-23Mirar (Pontus Hagland) test_any( [[ // bug [1858] ------------------------------------------------------------ // http://community/crunch/show_bug.cgi?id=1858 string s=#" constant foo=({this_object()}); int|string test() { if (!foo[0]) return sprintf(\"foo is %O\\n\",foo)-\"\\n\"; if (foo[0]==this_object()) return 1; return sprintf(\"foo is %O\\n\",foo)-\"\\n\"; } "; class handler { void compile_error(string file, int line, string err) { }}; catch { program p=compile_string(s,"test",handler()); return p()->test(); }; return 1; // compile error is ok ]],1);
ef0a502001-09-23Mirar (Pontus Hagland) // -----------------------------------------------------------------------
ec6f972001-01-19Martin Stjernholm // This test checks for excessive recursion in // destruct_objects_to_destruct, and also that it keeps the destruct // order sane. test_do([[ class Top { int count = 0; class Foo { int c; object foo;
35f51c2008-06-28Martin Nilsson  protected void create(object o)
ec6f972001-01-19Martin Stjernholm  { foo = o; c = count++; } void destroy() { count--; if (count != c) error ("Destruct out of sequence, " "%d destructed when %d should be.\n", c, count); object x = foo && Foo(0); x = 0; // Cause call to destruct_objects_to_destruct.
5520722007-06-18Martin Stjernholm  for (int j = 0; j < 10; j++) write ("");
ec6f972001-01-19Martin Stjernholm  } }
64621b2004-07-16Henrik Grubbström (Grubba)  mixed eat_stack(int|void probe)
ec6f972001-01-19Martin Stjernholm  {
64621b2004-07-16Henrik Grubbström (Grubba)  // Avoid eating as much C-stack by releasing the // catch at every level. if (probe) return 1; if (catch(eat_stack(1))) return 1;
ec6f972001-01-19Martin Stjernholm  mixed err = 1;
64621b2004-07-16Henrik Grubbström (Grubba)  if ((err = eat_stack()) != 10) return intp(err) && err > 0 ? err + 1 : err;
ec6f972001-01-19Martin Stjernholm  if (err = catch { Foo foo; for(int i=0; i < 10000; i++) foo = Foo(foo); foo = 0; // Cause call to destruct_objects_to_destruct.
5520722007-06-18Martin Stjernholm  for (int j = 0; j < 10; j++) write ("");
ec6f972001-01-19Martin Stjernholm  }) return err; }
35f51c2008-06-28Martin Nilsson  protected void create()
ec6f972001-01-19Martin Stjernholm  { if (mixed err = eat_stack()) { catch (err[1] = err[1][sizeof (err[1]) - 50..]); throw (err); } } }; Top(); ]]);
a3d4d42003-04-08Martin Stjernholm // Testing stack popping wrt the various function call opcodes
692ebe2001-02-08Martin Stjernholm test_program([[ inherit Thread.Mutex : monitor; int f (int x) { if(monitor::trylock(1)) return 0; return x; } int a() { object key = monitor::lock(); return f (1); // F_CALL_LFUN_AND_RETURN }; ]]); test_program([[ inherit Thread.Mutex : monitor; int f (int x) { if(monitor::trylock(1)) return 0; return x; }; mixed g = f; int a() { object key = monitor::lock(); return g (1); // F_CALL_FUNCTION_AND_RETURN } ]]); test_program([[ Thread.Mutex monitor = Thread.Mutex(); int f (int x) { if(monitor->trylock(1)) return 0; return x; } int a() { add_constant ("f", f); add_constant ("monitor", monitor); return compile_string(#" int g() { object key = monitor->lock(); return f (1); // F_APPLY_AND_RETURN }")()->g(); } ]]);
9b036b2003-04-08Martin Stjernholm test_program([[ inherit Thread.Mutex : monitor; int dummy; int f (int x) { if(monitor::trylock(1)) return 0; return x; }; int a() { object key = monitor::lock(); int res = this->f (1); // F_CALL_OTHER (no `->) dummy = random (res); return res; } ]]); test_program([[ inherit Thread.Mutex : monitor; mixed `-> (string what) {return this[what];} int dummy; int f (int x) { if(monitor::trylock(1)) return 0; return x; }; int a() { object key = monitor::lock(); int res = this->f (1); // F_CALL_OTHER (with `->) dummy = random (res); return res; } ]]); test_program([[ inherit Thread.Mutex : monitor; int res = 0; void f (int x) { if(monitor::trylock(1)) res = 0; else res = x; }; int a() { object key = monitor::lock(); this->f (1); // F_CALL_OTHER_AND_POP (no `->) return res; } ]]); test_program([[ inherit Thread.Mutex : monitor; mixed `-> (string what) {return this[what];} int res = 0; void f (int x) { if(monitor::trylock(1)) res = 0; else res = x; }; int a() { object key = monitor::lock(); this->f (1); // F_CALL_OTHER_AND_POP (with `->) return res; } ]]); test_program([[ inherit Thread.Mutex : monitor; int f (int x) { if(monitor::trylock(1)) return 0; return x; }; int a() { object key = monitor::lock(); return this->f (1); // F_CALL_OTHER_AND_RETURN (no `->) } ]]); test_program([[ inherit Thread.Mutex : monitor; mixed `-> (string what) {return this[what];} int f (int x) { if(monitor::trylock(1)) return 0; return x; }; int a() { object key = monitor::lock(); return this->f (1); // F_CALL_OTHER_AND_RETURN (with `->) } ]]);
692ebe2001-02-08Martin Stjernholm test_program([[ inherit Thread.Mutex : monitor; int iter = 0; int a (void|int x) { if (iter == 1) { if (monitor::trylock(1)) return 0; return x; } else { object key = monitor::lock(); iter = 1; return a (1); // F_COND_RECUR } } ]]); test_program([[ inherit Thread.Mutex : monitor; int iter = 0; int a (void|int x) { if (!iter) { iter = 1; return a (x); } else if (iter == 2) { if (monitor::trylock(1)) return 0; return x; } else { object key = monitor::lock(); iter = 2; return a (1); // F_TAIL_RECUR } } ]]); test_program([[ inherit Thread.Mutex : monitor; int iter = 0; int a (void|int x) { if (!iter) { iter = 1; return a (x); } else if (iter == 2) { if (monitor::trylock(1)) return 0; return x; } else { object key = monitor::lock(); iter = 2; int res = a (1); // F_RECUR iter = -1; return res; } } ]]); test_program([[ inherit Thread.Mutex : monitor; int iter = 0; int a (void|int x) { if (!iter) { iter = 1; return a (x); } else if (iter == 2) { if (monitor::trylock(1)) iter = 0; iter = x; } else { object key = monitor::lock(); iter = 2; a (1); // F_RECUR_AND_POP return iter; } } ]]); test_program([[ inherit Thread.Mutex : monitor; int f (int x) { if(monitor::trylock(1)) return 0; return x; } int a() {
1615822008-01-04Henrik Grubbström (Grubba)  foreach (({1, monitor::lock()}), mixed m) return f (m); // F_CALL_LFUN_AND_RETURN
692ebe2001-02-08Martin Stjernholm  }; ]]); test_program([[ inherit Thread.Mutex : monitor; int f (int x) { if(monitor::trylock(1)) return 0; return x; }; mixed g = f; int a() {
1615822008-01-04Henrik Grubbström (Grubba)  foreach (({1, monitor::lock()}), mixed m) return g (m); // F_CALL_FUNCTION_AND_RETURN
692ebe2001-02-08Martin Stjernholm  } ]]); test_program([[ Thread.Mutex monitor = Thread.Mutex(); int f (int x) { if(monitor->trylock(1)) return 0; return x; } int a() { add_constant ("f", f); add_constant ("monitor", monitor); return compile_string(#" int g() {
1615822008-01-04Henrik Grubbström (Grubba)  foreach (({1, monitor->lock()}), mixed m) return f (m); // F_APPLY_AND_RETURN
692ebe2001-02-08Martin Stjernholm  }")()->g(); } ]]);
9b036b2003-04-08Martin Stjernholm test_program([[ inherit Thread.Mutex : monitor; int dummy; int f (int x) { if(monitor::trylock(1)) return 0; return x; }; int a() { int res;
1615822008-01-04Henrik Grubbström (Grubba)  foreach (({1, monitor::lock()}), mixed m) { res = this->f (m); // F_CALL_OTHER (no `->)
9b036b2003-04-08Martin Stjernholm  dummy = random (res); return res; } } ]]); test_program([[ inherit Thread.Mutex : monitor; mixed `-> (string what) {return this[what];} int dummy; int f (int x) { if(monitor::trylock(1)) return 0; return x; }; int a() { int res;
1615822008-01-04Henrik Grubbström (Grubba)  foreach (({1, monitor::lock()}), mixed m) { res = this->f (m); // F_CALL_OTHER (with `->)
9b036b2003-04-08Martin Stjernholm  dummy = random (res); return res; } } ]]); test_program([[ inherit Thread.Mutex : monitor; int res = 0; void f (int x) { if(monitor::trylock(1)) res = 0; else res = x; }; int a() {
1615822008-01-04Henrik Grubbström (Grubba)  foreach (({1, monitor::lock()}), mixed m) { this->f (m); // F_CALL_OTHER_AND_POP (no `->)
9b036b2003-04-08Martin Stjernholm  return res; } } ]]); test_program([[ inherit Thread.Mutex : monitor; mixed `-> (string what) {return this[what];} int res = 0; void f (int x) { if(monitor::trylock(1)) res = 0; else res = x; }; int a() {
1615822008-01-04Henrik Grubbström (Grubba)  foreach (({1, monitor::lock()}), mixed m) { this->f (m); // F_CALL_OTHER_AND_POP (with `->)
9b036b2003-04-08Martin Stjernholm  return res; } } ]]); test_program([[ inherit Thread.Mutex : monitor; int f (int x) { if(monitor::trylock(1)) return 0; return x; }; int a() {
1615822008-01-04Henrik Grubbström (Grubba)  foreach (({1, monitor::lock()}), mixed m) return this->f (m); // F_CALL_OTHER_AND_RETURN (no `->)
9b036b2003-04-08Martin Stjernholm  } ]]); test_program([[ inherit Thread.Mutex : monitor; mixed `-> (string what) {return this[what];} int f (int x) { if(monitor::trylock(1)) return 0; return x; }; int a() {
1615822008-01-04Henrik Grubbström (Grubba)  foreach (({1, monitor::lock()}), mixed m) return this->f (m); // F_CALL_OTHER_AND_RETURN (with `->)
9b036b2003-04-08Martin Stjernholm  } ]]);
692ebe2001-02-08Martin Stjernholm test_program([[ inherit Thread.Mutex : monitor; int iter = 0; int a (void|int x) { if (iter == 1) { if (monitor::trylock(1)) return 0; return x; } else { iter = 1;
1615822008-01-04Henrik Grubbström (Grubba)  foreach (({1, monitor::lock()}), mixed m) return a (m); // F_COND_RECUR
692ebe2001-02-08Martin Stjernholm  } } ]]); test_program([[ inherit Thread.Mutex : monitor; int iter = 0; int a (void|int x) { if (!iter) { iter = 1; return a (x); } else if (iter == 2) { if (monitor::trylock(1)) return 0; return x; } else { iter = 2;
1615822008-01-04Henrik Grubbström (Grubba)  foreach (({1, monitor::lock()}), mixed m) return a (m); // F_TAIL_RECUR
692ebe2001-02-08Martin Stjernholm  } } ]]); test_program([[ inherit Thread.Mutex : monitor; int iter = 0; int a (void|int x) { if (!iter) { iter = 1; return a (x); } else if (iter == 2) { if (monitor::trylock(1)) return 0; return x; } else { iter = 2; int res;
1615822008-01-04Henrik Grubbström (Grubba)  foreach (({1, monitor::lock()}), mixed m) { res = a (m); // F_RECUR
8e27a32001-02-10Martin Stjernholm  iter = random (res); return res; }
692ebe2001-02-08Martin Stjernholm  } } ]]); test_program([[ inherit Thread.Mutex : monitor; int iter = 0; int a (void|int x) { if (!iter) { iter = 1; return a (x); } else if (iter == 2) { if (monitor::trylock(1)) iter = 0; iter = x; } else { iter = 2;
1615822008-01-04Henrik Grubbström (Grubba)  foreach (({1, monitor::lock()}), mixed m) { a (m); // F_RECUR_AND_POP
8e27a32001-02-10Martin Stjernholm  return iter; }
692ebe2001-02-08Martin Stjernholm  } } ]]);
9040cc2002-10-14Martin Nilsson test_do(add_constant("f")) test_do(add_constant("monitor"))
692ebe2001-02-08Martin Stjernholm 
a3d4d42003-04-08Martin Stjernholm // Testing scoped frames wrt the various function call opcodes test_program([[ int f (int x) { return x; } int a (void|int x) { function s = lambda () {return x;}; return f (1); // F_CALL_LFUN_AND_RETURN }; ]]); test_program([[ int f (int x) { return x; }; mixed g = f; int a (void|int x) { function s = lambda () {return x;}; return g (1); // F_CALL_FUNCTION_AND_RETURN } ]]); test_program([[ int f (int x) { return x; } int a() { add_constant ("f", f); return compile_string(#" int g (void|int x) { function s = lambda () {return x;}; return f (1); // F_APPLY_AND_RETURN }")()->g(); } ]]);
9b036b2003-04-08Martin Stjernholm test_program([[ int dummy; int f (int x) { return x; }; int a (void|int x) { function s = lambda () {return x;}; int res = this->f (1); // F_CALL_OTHER (no `->) dummy = random (res); return res; } ]]); test_program([[ mixed `-> (string what) {return this[what];} int dummy; int f (int x) { return x; }; int a (void|int x) { function s = lambda () {return x;}; int res = this->f (1); // F_CALL_OTHER (with `->) dummy = random (res); return res; } ]]); test_program([[ int res = 0; void f (int x) { res = x; }; int a (void|int x) { function s = lambda () {return x;}; this->f (1); // F_CALL_OTHER_AND_POP (no `->) return res; } ]]); test_program([[ mixed `-> (string what) {return this[what];} int res = 0; void f (int x) { res = x; }; int a (void|int x) { function s = lambda () {return x;}; this->f (1); // F_CALL_OTHER_AND_POP (with `->) return res; } ]]); test_program([[ int f (int x) { return x; }; int a (void|int x) { function s = lambda () {return x;}; return this->f (1); // F_CALL_OTHER_AND_RETURN (no `->) } ]]); test_program([[ mixed `-> (string what) {return this[what];} int f (int x) { return x; }; int a (void|int x) { function s = lambda () {return x;}; return this->f (1); // F_CALL_OTHER_AND_RETURN (with `->) } ]]);
a3d4d42003-04-08Martin Stjernholm test_program([[ int iter = 0; int a (void|int x) { if (iter == 1) { return x; } else { function s = lambda () {return x;}; iter = 1; return a (1); // F_COND_RECUR } } ]]); test_program([[ int iter = 0; int a (void|int x) { if (!iter) { iter = 1; return a (x); } else if (iter == 2) { return x; } else { function s = lambda () {return x;}; iter = 2; return a (1); // F_TAIL_RECUR } } ]]); test_program([[ int iter = 0; int a (void|int x) { if (!iter) { iter = 1; return a (x); } else if (iter == 2) { return x; } else { function s = lambda () {return x;}; iter = 2; int res = a (1); // F_RECUR iter = -1; return res; } } ]]); test_program([[ int iter = 0; int a (void|int x) { if (!iter) { iter = 1; return a (x); } else if (iter == 2) { iter = x; } else { function s = lambda () {return x;}; iter = 2; a (1); // F_RECUR_AND_POP return iter; } } ]]); test_do(add_constant("f"))
fb61ba1998-04-26Fredrik Hübinette (Hubbe) test_false([[object_variablep(class X { int y; int z() { return 1; }}(),"foo")]]) test_false([[object_variablep(class X { int y; int z() { return 1; }}(),"z")]]) test_true([[object_variablep(class X { int y; int z() { return 1; }}(),"y")]]) test_any([[ int a,b; [a,b]=({1,2}); return a]],1) test_any([[ int a,b; [a,b]=({1,2}); return b]],2) test_any([[ int a,b; [ [a],b]=({ ({ 1 }) ,2}); return a]],1) test_any([[ int a,b; [ [a],b]=({ ({ 1 }) ,2}); return b]],2)
f869d42008-01-29Henrik Grubbström (Grubba) test_any([[ int a; catch { [a]=({1,2}); return 0; }; return 1]],1) test_compile_error([[ int a,b; catch { [a,b]=({1}); return 0; }; return 1]],1)
f840e72008-01-29Henrik Grubbström (Grubba) test_any([[ int a,b; catch { [a,b]=lambda(){ return ({1}); }(); return 0; }; return 1]],1)
aa73fc1999-10-21Fredrik Hübinette (Hubbe) test_any([[ mapping m=([]); m[m]=m; return stringp(sprintf("%O",m)); ]],1)
4b9f0d2001-10-02Fredrik Hübinette (Hubbe) dnl test_any([[ dnl // don't know if this /should/ be valid /Mirar dnl // remove if it shouldn't dnl dnl // I see no reason this should be allowed - Hubbe dnl dnl array a=({}); dnl []=a; return 1; ]],1)
aa73fc1999-10-21Fredrik Hübinette (Hubbe) 
3958992001-06-23Fredrik Hübinette (Hubbe) test_any([[ int q() { throw(1); }; catch { return q(); }; return 17; ]],17) test_any([[ return class { int q() { throw(1); }; int p() { catch { return q(); }; return 17; } }()->p(); ]],17)
0893ca1999-12-09Henrik Grubbström (Grubba) test_compile_error([[
35f51c2008-06-28Martin Nilsson  protected function foo(string ...:object);
0893ca1999-12-09Henrik Grubbström (Grubba)  int bar() { return 17; } ]])
55356e1999-05-26Fredrik Hübinette (Hubbe) test_compile_error([[ array a; a = path_info[..(sizeof(path_info)-2]*"/"; ]])
fb61ba1998-04-26Fredrik Hübinette (Hubbe) test_compile_error([[ default ; ]])
5dd2181999-01-29Fredrik Hübinette (Hubbe) test_compile_error([[ 0999; ]])
fb61ba1998-04-26Fredrik Hübinette (Hubbe) test_compile_error([[ int a,b; [a,b]++; ]])
4142a61998-05-19Fredrik Hübinette (Hubbe) test_compile_error([[ array(int) x; string foo() { return "foo "+(array(string) x) * ","; } int main() { return 0; } ]])
da26fe2000-03-09Henrik Grubbström (Grubba) dnl dnl this_program dnl
b584212002-05-11Martin Stjernholm 
da26fe2000-03-09Henrik Grubbström (Grubba) test_true(this_program) test_any([[int this_program; return this_program;]], 0)
3895da2000-03-09Henrik Grubbström (Grubba) test_any([[class A { int a() { return this_program == A; }}; return A()->a();]], 1)
50e3882002-04-13Martin Stjernholm test_program([[ class A (int v) { this_program clone() {return this_program (v);} } int a() {return A (4)->clone()->v == 4;} ]]) test_program([[ int i = 17, j = 18; class A (int v) { this_program clone() {return this_program (i);} } int a() {return A (4)->clone()->v == 17;} ]]) test_program([[ class A (int v) { this_program clone() {return this_program (j);} } int i = 17, j = 18; int a() {return A (4)->clone()->v == 18;} ]]) test_program([[ int i = 17, v; this_program clone() {return this_program (i);} void create (int v_) {v = v_;} int a() {return clone()->v == 17;} ]]) test_program([[ this_program clone() {return this_program (i);} int i = 17, v; void create (int v_) {v = v_;} int a() {return clone()->v == 17;} ]]) test_program([[ class A {this_program clone() {return this_program();}} class B {inherit A;}
daa74f2002-11-07Marcus Comstedt  int a() {return object_program (B()->clone()) == B;}
50e3882002-04-13Martin Stjernholm ]])
d1c9bc2002-11-07Marcus Comstedt test_program([[ class A {this_program clone() {return this_program();}} class B {inherit A;} int a() {return typeof(B()->clone()) <= B;} ]])
da26fe2000-03-09Henrik Grubbström (Grubba) 
b584212002-05-11Martin Stjernholm test_program([[ class A { class B { mixed f() { return ({global::this_program, A::this_program, // Works, but not really useful. B::this_program, // Ditto. this_program}); } } } int a() {
c0afd02002-11-28Henrik Grubbström (Grubba)  return equal (A()->B()->f(), ({object_program (this_object()), A, A.B, A.B})); } ]]) test_compile_error([[ mixed x() { return ::x;
b584212002-05-11Martin Stjernholm  } ]]) test_program([[ class A { class B { constant this_program = "foo"; mixed f (int this_program) { return ({A::this_program, B::this_program, this_program}); } } } int a() { return equal (A()->B()->f (1), ({A, "foo", 1})); } ]]) test_program([[ class I { string this_program = "foo"; } class A { class B { inherit I; mixed f (int this_program) { return ({A::this_program, B::this_program, this_program}); } } } int a() { return equal (A()->B()->f (1), ({A, "foo", 1})); } ]]) test_program([[ string this_program = "foo"; class A { class B { mixed f() { return ({A::this_program, B::this_program, this_program}); } } } int a() { return equal (A()->B()->f(), ({A, A.B, "foo"})); } ]]) test_compile_error_any([[ class A {} class B {
7854902004-12-19Henrik Grubbström (Grubba)  inherit A:C;
b584212002-05-11Martin Stjernholm  mixed f() {return A::this_program;} } ]])
7854902004-12-19Henrik Grubbström (Grubba) test_compile_error_any([[ #pike 7.6 class A {} class B { inherit A:C; mixed f() {return C::this_program;} } ]]) test_any([[ class A {}; class B { inherit A:C; mixed f() {return C::this_program;} }; return B()->f() == A; ]], 1)
265b721999-03-06Henrik Grubbström (Grubba) dnl test_compile_error(0()) test_compile_error(1()) test_compile_error(""()) test_compile_error(([])()) test_compile_error(([])())
fb61ba1998-04-26Fredrik Hübinette (Hubbe) test_any([[ class X { int y; class Z { void destroy() { y++; } } }; X x=X(); destruct(x->Z()); return x->y;]],1)
2c17091999-06-22Fredrik Hübinette (Hubbe) 
fb61ba1998-04-26Fredrik Hübinette (Hubbe) test_eval_error([[ class Z { int destroy() { return 1/y; } }(); ]])
35f51c2008-06-28Martin Nilsson test_any([[ class X { int y; class Z { protected void destroy() { y++; } } }; X x=X(); destruct(x->Z()); return x->y;]],1) test_any([[ class X { int y; class Z { protected void create() { y++; } } }; X x=X(); destruct(x->Z()); return x->y;]],1)
2c17091999-06-22Fredrik Hübinette (Hubbe) 
a4b8121998-04-28Fredrik Hübinette (Hubbe) cond([[all_constants()->_debug]], [[ test_do(_debug(_debug(0))) ]])
e70e2f2003-07-30Martin Stjernholm test_do(indices(_static_modules))
694bb11998-04-23Fredrik Hübinette (Hubbe) test_compile_any([[import Stdio; class x { string y() { read_file("foo"); } }]])
b82cc91999-10-04Fredrik Hübinette (Hubbe) 
f57ba32001-10-05Mirar (Pontus Hagland) dnl ---------------------------------------------------------------- dnl backtrace/linenumber tests dnl ---------------------------------------------------------------- test_any([[ program p=compile_string( "int foo()\n" "{\n" " error(\"test error\\n\"); // line 3\n" " return 17;\n" "}","test");
34db632001-10-06Mirar (Pontus Hagland)  mixed err=catch { p()->foo(); }; if (err[1][-1][1]!=3) { werror("backtrace is:\n"+master()->describe_backtrace(err)); } return err[1][-1][1]; ]],3);
93c16b2002-01-04Henrik Grubbström (Grubba)  // Bug 2660 test_any([[ int foo(mixed a, mixed ... b) { return sizeof(backtrace()[-1]) - (3 + 1 + sizeof(b)); }; return foo(1,2,3,4)|foo(1); ]], 0)
34db632001-10-06Mirar (Pontus Hagland) define(test_backtrace_line_charset, [[ test_any([[ program p=compile_string( Locale.Charset.encoder("]]$1[[")->feed( "#charset ]]$1[[\n" "int foo()\n" "{\n" " error(\"test error\\n\"); // line 3\n" " return 17;\n" "}")->drain(),"test");
f57ba32001-10-05Mirar (Pontus Hagland)  mixed err=catch { p()->foo(); }; if (err[1][0][1]!=3) { werror("backtrace is:\n"+master()->describe_backtrace(err)); } return err[1][0][1]; ]],3);
34db632001-10-06Mirar (Pontus Hagland) ]]) dnl test_backtrace_line_charset(utf-7)
f57ba32001-10-05Mirar (Pontus Hagland) 
ec3c9d2002-04-28Martin Stjernholm test_program([[ class X {
35f51c2008-06-28Martin Nilsson  protected void create (int i)
ec3c9d2002-04-28Martin Stjernholm  { if (i) error ("foo\n"); // Line 7 } } int f() { X (0); X (1); // Line 14 } int a() { array bt = catch (f())[1]; int ok = 0; foreach (reverse (bt), object ent) switch (functionp (ent[2]) && function_name (ent[2])) { case "create": if (ent[1] == 7) ok++; break; case "f": if (ent[1] == 14) ok++; break; } return ok == 2; } ]])
f5ee3c2002-04-28Martin Stjernholm test_program([[// [bug 3060] void x (mixed val) { } class X { void create() {error ("foo\n");} // Line 8 } object rx = class {}(); int y() { x (rx->x); rx = X(); // Line 16 } int a() { mixed bt = catch (y())[1]; int ok = 0; foreach (reverse (bt), object ent) switch (functionp (ent[2]) && function_name (ent[2])) { case "create": if (ent[1] == 8) ok++; break; case "y": if (ent[1] == 16) ok++; break; } return ok == 2; } ]])
4fa0582003-03-20Martin Stjernholm test_any([[ // Test a lot of code without a relative pc update in it. There must // not be any labels in it since the pc counting is reset then. int a = 1, b = 1, c; c=a+b,a=b,b=c; c=a+b,a=b,b=c; c=a+b,a=b,b=c; c=a+b,a=b,b=c; c=a+b,a=b,b=c; c=a+b,a=b,b=c; c=a+b,a=b,b=c; c=a+b,a=b,b=c; c=a+b,a=b,b=c; c=a+b,a=b,b=c; c=a+b,a=b,b=c; c=a+b,a=b,b=c; c=a+b,a=b,b=c; c=a+b,a=b,b=c; c=a+b,a=b,b=c; c=a+b,a=b,b=c; c=a+b,a=b,b=c; c=a+b,a=b,b=c; c=a+b,a=b,b=c; c=a+b,a=b,b=c; c=a+b,a=b,b=c; c=a+b,a=b,b=c; return __LINE__ == backtrace()[-1][1]; ]], 1)
b58db92002-05-11Martin Stjernholm dnl Note: This line number error tend to go away with more debug. test_program([[ int x = 0; int y = [int] backtrace()[-1][1]; int a() {return y == 3;} ]])
1f4dbd2001-05-19Mirar (Pontus Hagland) dnl ---------------------------------------------------------------- dnl scopes and stuff dnl ----------------------------------------------------------------
b82cc91999-10-04Fredrik Hübinette (Hubbe) dnl dnl Undocumented but important behaviour... dnl test_eq([[Stdio._stdin]],[[Stdio.stdin->_fd]])
4705b52002-05-01Martin Stjernholm test_program([[ class A { string f() {return "A";} } class B { string f() {return "B";} } class C { inherit B; } class D { inherit A; inherit C; string g() {return f();} } int a() { return D()->g() == "B"; } ]]) test_program([[ class A { string f() {return "A";} } class B { string f() {return "B";} } class C { inherit B; } class D { inherit C; inherit A; string g() {return f();} } int a() { return D()->g() == "A"; } ]]) test_program([[ class A { string f() {return "A";} } class B { string f() {return "B";} } class C { inherit B; } class D { string f() {return "D";} inherit A; inherit C; string g() {return f();} } int a() { return D()->g() == "D"; } ]])
086acc1999-09-11Fredrik Hübinette (Hubbe) test_compile_any([[ class Bar { int f() {return 17;} class Foo { int g() {return f();} } inherit Foo; } ]])
94b5241999-11-01Mirar (Pontus Hagland) test_compile_any([[
086acc1999-09-11Fredrik Hübinette (Hubbe) class Bar { int f() {return 17;} class Foo { int g() {return f();} } } class Gnu { inherit Bar; inherit Foo; } ]])
ae60c21999-12-02Mirar (Pontus Hagland) 
93c16b2002-01-04Henrik Grubbström (Grubba) dnl Bug 2571
8e5b452001-11-27Martin Stjernholm test_any([[ int var; void x() {var++;}; lambda () {x();}(); return var; ]], 1);
10c07f2002-11-16Henrik Grubbström (Grubba) test_do([[ // Save our constants for future use... add_constant("__saved_constants__", ([]) + all_constants()); ]])
1f4dbd2001-05-19Mirar (Pontus Hagland) test_any([[ Stdio.write_file("testsuite_test.pmod", #" // this crashes Pike /Mirar 2001-05-19 // I haven't been able to minimize it futher, // and it needs to be in a separate module. mapping es=0; string efoo(string e) { if (!es) { mapping res=([]); string l; if (sscanf(l,\"%s%s\",string ext,string type)==4 && ext!=\"\" && ext[0]!=\"#\") // note the type error res[ext]=type; es=res; } } ");
6edc4f2001-05-24Henrik Grubbström (Grubba)  // Compilation handler that hides compilation errors. class handler { void compile_error(string file, int line, string err) {
5520722007-06-18Martin Stjernholm  // write("file: %O, line: %O, err: %O\n", file, line, err);
6edc4f2001-05-24Henrik Grubbström (Grubba)  } };
1f4dbd2001-05-19Mirar (Pontus Hagland)  // turn this on when the bug is found // master()->set_inhibit_compile_errors(lambda(){});
ba14f32001-05-22Henrik Grubbström (Grubba)  //_optimizer_debug(2); //_assembler_debug(20);
1184fa2001-12-12Martin Stjernholm  object orig_master = master(); replace_master(object_program(orig_master)());
1f4dbd2001-05-19Mirar (Pontus Hagland)  catch {
6edc4f2001-05-24Henrik Grubbström (Grubba)  compile_string("import \".\";\n" "int foo() { testsuite_test.efoo; }\n", "testsuite_test", handler());
1f4dbd2001-05-19Mirar (Pontus Hagland)  };
1184fa2001-12-12Martin Stjernholm  replace_master(orig_master);
1f4dbd2001-05-19Mirar (Pontus Hagland)  return 0; ]],0);
34db632001-10-06Mirar (Pontus Hagland) test_any([[ // infokom:350113
1184fa2001-12-12Martin Stjernholm  Stdio.recursive_rm("testsuite_test_dir.pmod");
6c67762001-10-06Mirar (Pontus Hagland)  mkdir("testsuite_test_dir.pmod"); Stdio.write_file("testsuite_test_dir.pmod/module.pmod",
34db632001-10-06Mirar (Pontus Hagland)  #" .A a() {return 0;} ");
6c67762001-10-06Mirar (Pontus Hagland)  Stdio.write_file("testsuite_test_dir.pmod/A.pike",
34db632001-10-06Mirar (Pontus Hagland)  #" void create (.X x) {.y();} "); // Compilation handler that hides compilation errors. class handler
8307ee2001-11-08Fredrik Hübinette (Hubbe)  { void handle_error(array(mixed)|object trace) { } void compile_error(string file, int line, string err) { } void compile_warning(string file, int line, string err) { }
34db632001-10-06Mirar (Pontus Hagland)  };
1184fa2001-12-12Martin Stjernholm  object orig_master = master(); replace_master(object_program(orig_master)());
8307ee2001-11-08Fredrik Hübinette (Hubbe)  master()->set_inhibit_compile_errors(handler()); mixed err = catch { compile_string("import \".\"; "
1184fa2001-12-12Martin Stjernholm  "int foo() { testsuite_test_dir.a(); }", "test",handler());
8307ee2001-11-08Fredrik Hübinette (Hubbe)  }; master()->set_inhibit_compile_errors(0);
1184fa2001-12-12Martin Stjernholm  replace_master(orig_master);
8307ee2001-11-08Fredrik Hübinette (Hubbe)  if(err) {
1184fa2001-12-12Martin Stjernholm  Stdio.recursive_rm("testsuite_test_dir.pmod");
8307ee2001-11-08Fredrik Hübinette (Hubbe)  return 0; } return 1;
34db632001-10-06Mirar (Pontus Hagland) ]],0);
11cbae2001-11-10Martin Stjernholm test_do([[ Stdio.recursive_rm("testsuite_test_dir.pmod"); mkdir("testsuite_test_dir.pmod"); Stdio.write_file("testsuite_test_dir.pmod/module.pmod", #" .A a(); class X {} "); Stdio.write_file("testsuite_test_dir.pmod/A.pike", #" .X f() {return 0;} ");
1184fa2001-12-12Martin Stjernholm  object orig_master = master(); replace_master(object_program(orig_master)()); mixed err = catch { compile_string("import \".\"; " "int foo() { testsuite_test_dir.A(); }", "test"); }; replace_master(orig_master); if (err) throw (err);
11cbae2001-11-10Martin Stjernholm  Stdio.recursive_rm("testsuite_test_dir.pmod"); ]]);
06203b2001-12-15Martin Stjernholm test_do([[ Stdio.recursive_rm ("testsuite_test_dir.pmod"); mkdir ("testsuite_test_dir.pmod"); Stdio.write_file ("testsuite_test_dir.pmod/module.pmod", #"\ .B b(); class X {}"); Stdio.write_file ("testsuite_test_dir.pmod/A.pike", #"\ int f() {return 0;}"); Stdio.write_file ("testsuite_test_dir.pmod/B.pike", #"\ inherit .A; .X g() {return f() && .X();}"); object orig_master = master(); replace_master (object_program (orig_master)()); mixed err = catch { compile_string ("import \".\";\n" "int foo() { testsuite_test_dir.B(); }", "test"); }; replace_master (orig_master); if (err) throw (err); Stdio.recursive_rm ("testsuite_test_dir.pmod"); ]]); test_do([[ Stdio.recursive_rm ("testsuite_test_dir.pmod"); mkdir ("testsuite_test_dir.pmod"); Stdio.write_file ("testsuite_test_dir.pmod/module.pmod", #"\
9439bd2003-01-16Henrik Grubbström (Grubba)  .B.B b();
06203b2001-12-15Martin Stjernholm  class X {}"); Stdio.write_file ("testsuite_test_dir.pmod/A.pike", #"\ int f() {return 0;}"); Stdio.write_file ("testsuite_test_dir.pmod/B.pmod", #"\ class B { inherit .A; .X g() {return f() && .X();} }"); object orig_master = master(); replace_master (object_program (orig_master)()); mixed err = catch { compile_string ("import \".\";\n" "int foo() { testsuite_test_dir.B.B(); }", "test"); }; replace_master (orig_master); if (err) throw (err); Stdio.recursive_rm ("testsuite_test_dir.pmod"); ]]);
a244cc2002-03-01Martin Stjernholm test_do([[ // Problem: The expression .B.c in module.pmod is resolved during // compilation pass 1 of B.pike, but it's only declared then and // doesn't yet have any value. Stdio.recursive_rm ("testsuite_test_dir.pmod"); mkdir ("testsuite_test_dir.pmod"); Stdio.write_file ("testsuite_test_dir.pmod/module.pmod", #"\ mixed x = .B.c; class A {}"); Stdio.write_file ("testsuite_test_dir.pmod/B.pike", #"\ constant c = .A();"); // Should give a "not constant" compile error. // Compilation handler that hides compilation errors. class handler { void handle_error(array(mixed)|object trace) { } void compile_error(string file, int line, string err) { } void compile_warning(string file, int line, string err) { } }; object orig_master = master(); replace_master (object_program (orig_master)()); mixed err = catch { compile_string (#"\ mixed foo() {return .testsuite_test_dir.A;}", "test", handler()); }; replace_master (orig_master); if (!err) error ("Expected compile error.\n"); if (!objectp (err) || !err->is_compilation_error) throw (err); Stdio.recursive_rm("testsuite_test_dir.pmod"); ]]);
fa8c4f2002-03-01Martin Stjernholm test_any_equal([[
a244cc2002-03-01Martin Stjernholm  // Problem: module.pmod is in pass 1 when it tries to resolve the // .B.c constant and is therefore temporarily interned as a
fa8c4f2002-03-01Martin Stjernholm  // placeholder object. The (<>) in B.pike is equivalent to // aggregate_multiset, which due to the import is looked up in the
a244cc2002-03-01Martin Stjernholm  // placeholder object and therefore resolved as a nonconstant // placeholder object.
fa8c4f2002-03-01Martin Stjernholm  Stdio.recursive_rm ("testsuite_test_dir.pmod"); mkdir ("testsuite_test_dir.pmod"); Stdio.write_file ("testsuite_test_dir.pmod/module.pmod", #"\
a244cc2002-03-01Martin Stjernholm  mixed x = .B.C; mixed foo() {return x->c;}");
fa8c4f2002-03-01Martin Stjernholm  Stdio.write_file ("testsuite_test_dir.pmod/B.pike", #"\ import \".\";
a244cc2002-03-01Martin Stjernholm  class C { constant c = (<>); }");
fa8c4f2002-03-01Martin Stjernholm  object orig_master = master(); replace_master (object_program (orig_master)()); mixed res; mixed err = catch { res = compile_string (#"\
a244cc2002-03-01Martin Stjernholm  mixed foo() {return .testsuite_test_dir.foo();}",
fa8c4f2002-03-01Martin Stjernholm  "test")()->foo(); }; replace_master (orig_master); if (err) throw (err);
a244cc2002-03-01Martin Stjernholm  Stdio.recursive_rm("testsuite_test_dir.pmod");
fa8c4f2002-03-01Martin Stjernholm  return res; ]], (<>));
569c6c2003-03-05Martin Stjernholm test_do([[ Stdio.recursive_rm ("testsuite_test_dir.pmod"); mkdir ("testsuite_test_dir.pmod"); Stdio.write_file ("testsuite_test_dir.pmod/A.pmod", #"\ string pof() {return testsuite_test_dir.A.bingo();} string bingo () {return \"17\";}"); object orig_master = master(); replace_master (object_program (orig_master)()); master()->add_module_path (getcwd()); mixed err = catch { compile_string (#"\ string foo() { return testsuite_test_dir.A.pof(); }", "test"); }; replace_master (orig_master); if (err) throw (err); Stdio.recursive_rm ("testsuite_test_dir.pmod"); ]])
1899f82003-03-27Martin Stjernholm test_do([[ Stdio.recursive_rm ("testsuite_test_dir.pmod"); mkdir ("testsuite_test_dir.pmod"); Stdio.write_file ("testsuite_test_dir.pmod/module.pmod", #"\ .Foo.C x;"); Stdio.write_file ("testsuite_test_dir.pmod/Foo.pmod", #"\ import \".\"; class C { int f (array x) { return lambda() { // 'sizeof' below will be a placeholder object in // pass 1. That shouldn't cause a type error. int i = sizeof (x); return i; }(); } }"); object orig_master = master(); replace_master (object_program (orig_master)()); mixed err = catch { compile_string (#"\ mixed foo() {return .testsuite_test_dir.x;}", "test"); }; replace_master (orig_master); if (err) throw (err); Stdio.recursive_rm("testsuite_test_dir.pmod"); ]]);
6c92612008-08-17Martin Stjernholm test_do([[ Stdio.write_file ("testsuite_test_a.pmod", #" class a {} testsuite_test_b.b2 foo() {return testsuite_test_b.b2 (17);}"); Stdio.recursive_rm ("testsuite_test_b.pmod"); mkdir ("testsuite_test_b.pmod"); Stdio.write_file ("testsuite_test_b.pmod/b1.pike", #" protected void create() {}"); Stdio.write_file ("testsuite_test_b.pmod/b2.pike", #" inherit testsuite_test_b.b1; constant a = testsuite_test_a.a; protected void create (int i) {}"); object orig_master = master(); replace_master (object_program (orig_master)()); master()->add_module_path (getcwd()); mixed err = catch { compile_string ("inherit testsuite_test_b.b2;"); }; replace_master (orig_master); if (err) throw (err); Stdio.recursive_rm ("testsuite_test_a.pmod"); Stdio.recursive_rm ("testsuite_test_b.pmod"); ]])
3843f52001-12-16Martin Stjernholm cond(0,[[ test_do([[ // This is a case of cyclic references I think should work, but // afaict it's not possible without changing the resolve methods // thoroughly. /mast Stdio.recursive_rm ("testsuite_test_dir.pmod"); mkdir ("testsuite_test_dir.pmod"); Stdio.write_file ("testsuite_test_dir.pmod/A.pmod", #"\ .B.B b() {} class A {} class Ab {int ai() {return 4711;}} class Ad {inherit .B.Bb; int ai() {return bi() + 1;}}"); Stdio.write_file ("testsuite_test_dir.pmod/B.pmod", #"\ .A.A a() {} class B {} class Bb {int bi() {return 17;}} class Bd {inherit .A.Ab; int bi() {return ai() - 1;}}"); object orig_master = master(); replace_master (object_program (orig_master)()); mixed err = catch { compile_string (#"\ import \".\"; int foo() { testsuite_test_dir.A.Ad(); testsuite_test_dir.B.Bd(); }", "test"); }; replace_master (orig_master); if (err) throw (err); Stdio.recursive_rm ("testsuite_test_dir.pmod"); ]]); ]]);
10c07f2002-11-16Henrik Grubbström (Grubba) test_do([[ // Restore constants that were zapped by the various masters used above. foreach(__saved_constants__; string const; mixed val) { add_constant(const, val); } add_constant("__saved_constants__"); ]])
ae60c21999-12-02Mirar (Pontus Hagland) test_compile_any([[int log() { return 17; } class Greta { int hanna() { return log(); } }]]) test_compile_any([[int kajsa(int a,int b) { return 17; } class Jenny { int kajsa() { return 17; } class Greta { int hanna() { return kajsa(); } } }]])
40c2901999-12-02Mirar (Pontus Hagland) test_any([[add_constant("kajsa",lambda(int a,int b) { return 17; }); return compile_string("int kajsa() { return 17; } class Greta { int hanna() { return kajsa(); } }")()->kajsa()]],17)
9040cc2002-10-14Martin Nilsson test_do(add_constant("kajsa"))
ae60c21999-12-02Mirar (Pontus Hagland) 
6bc9281998-04-10Fredrik Hübinette (Hubbe) test_compile([[Stdio.File foo=Stdio.File();]])
4b38371998-04-28Fredrik Hübinette (Hubbe) test_compile([[ string|multiset(string) foo; array(string) gazonk; array(string) bar = indices(foo)-gazonk; ]])
6bc9281998-04-10Fredrik Hübinette (Hubbe) test_compile([[class { Stdio.File foo=Stdio.File(); }]]) test_compile_any([[void foo(Stdio.FILE f) {}]]) test_compile_any([[void foo(array(Stdio.FILE) f) {}]]) test_compile_any([[void foo(array(Stdio.FILE) f) {}]]) test_compile_any([[Stdio.File foo(array(Stdio.FILE) f) { return f[0]; }]])
2816052000-03-30Fredrik Hübinette (Hubbe) test_compile_any([[ class a { int `== (mixed x) { return 0; } } class b { inherit a; class c { int d (string x, string y) { return x==y; } } } ]])
6bc9281998-04-10Fredrik Hübinette (Hubbe) test_compile([[Stdio.File foo=Stdio.FILE();]])
87c9d21998-04-09Fredrik Hübinette (Hubbe) 
d165152008-05-03Henrik Grubbström (Grubba) test_any([[ // Test symbol lookup for inherit in multi-pass. // LysLysKOM 16472935 // An old pike will attempt to lookup X in the innermost X // during the second pass and thus fail with a compilation error. class X { constant foo = "outer"; class X { constant foo = "middle"; class X { constant foo = "inner"; } } }; class Y { inherit X.X; }; return Y()->foo; ]], "middle")
5fb9b02000-04-06Fredrik Hübinette (Hubbe) test_any([[string gurk="bozo"; string b(int x) { return (x?b(x-1)+gurk:""); }; return b(5)]],[["bozo"*5]])
fb61ba1998-04-26Fredrik Hübinette (Hubbe) dnl this should really work... dnl test_compile_any([[void foo(int,string,...);]])
9ddbf22001-05-10Fredrik Hübinette (Hubbe) dnl This test doesn't run out of stack anymore, freaky dnl test_eval_error([[class X { int create() { create(); } }();]])
fb61ba1998-04-26Fredrik Hübinette (Hubbe) test_compile_error([[ int float; ]]) test_compile_error([[ int array; ]]) test_compile_error([[ int function; ]]) test_compile_error([[ int int; ]]) test_compile_error([[ int mapping; ]]) test_compile_error([[ int multiset; ]]) test_compile_error([[ int object; ]]) test_compile_error([[ int string; ]]) test_compile_error([[ int void; ]]) test_compile_error([[ int inline; ]]) test_compile_error([[ int local; ]]) test_compile_error([[ int nomask; ]]) test_compile_error([[ int predef; ]]) test_compile_error([[ int private; ]]) test_compile_error([[ int protected; ]]) test_compile_error([[ int public; ]]) test_compile_error([[ int static; ]]) test_compile_error([[ int final; ]]) test_compile_error([[ int do; ]]) test_compile_error([[ int else; ]]) test_compile_error([[ int return; ]]) test_compile_error([[ int constant; ]]) test_compile_error([[ int import; ]]) test_compile_error([[ int inherit; ]]) test_compile_error([[ int catch; ]])
ee2f201999-10-10Fredrik Noring test_compile_error([[ float gauge; ]])
fb61ba1998-04-26Fredrik Hübinette (Hubbe) test_compile_error([[ int lambda; ]]) test_compile_error([[ int sscanf; ]]) test_compile_error([[ int switch; ]]) test_compile_error([[ int typeof; ]]) test_compile_error([[ int break; ]]) test_compile_error([[ int case; ]]) test_compile_error([[ int continue; ]]) test_compile_error([[ int default; ]]) test_compile_error([[ int for; ]]) test_compile_error([[ int foreach; ]]) test_compile_error([[ int if; ]]) test_compile_error([[ int float = 0; ]]) test_eval_error([[ return 0.0[0]; ]]) test_eval_error([[ return 0[0]; ]])
a3a6c21998-04-19Fredrik Hübinette (Hubbe) test_compile_error([[constant x=class {}(); ]])
73406b1999-02-14Fredrik Hübinette (Hubbe) 
6b3f5c2002-04-11Martin Nilsson test_compile_error_any([[
1994251999-09-06Fredrik Hübinette (Hubbe)  mixed foo; mapping query_variables() { return ([]); }; mixed foo(mixed bar) { return 1/foo; } ]])
6b3f5c2002-04-11Martin Nilsson test_compile_error_any([[
2823691999-11-27Martin Stjernholm  class A {int wrong = "bogus"; void create() {}} class B {inherit A;} ]])
1994251999-09-06Fredrik Hübinette (Hubbe) 
45ad7f2005-07-13Henrik Grubbström (Grubba) test_any([[ // Test dynamic module indexing. object protocols = Protocols; return protocols.HTTP.get_url_data; ]], [[ Protocols.HTTP.get_url_data ]])
1994251999-09-06Fredrik Hübinette (Hubbe) 
ee2f201999-10-10Fredrik Noring test_compile([[float x=(gauge { return; },1.0);]])
a3a6c21998-04-19Fredrik Hübinette (Hubbe) cond( [[ master()->resolv("Gmp")->mpz ]], [[ test_compile_error([[object x = Gmp.mpz(17); constant y = x;]]) ]])
a83f8c1998-03-20Fredrik Hübinette (Hubbe) test_any([[object(Stdio.File) f; f=Stdio.File(); return 1]],1)
1615822008-01-04Henrik Grubbström (Grubba) test_compile([[float t=gauge { string foo; foo; };]])
086bfa1998-04-09Fredrik Hübinette (Hubbe) test_compile_any([[class { object(Stdio.FILE) f; void create() { f=Stdio.FILE(); }}]])
097e3d1998-02-27Fredrik Hübinette (Hubbe) test_eq([[compile_string("#define A(X) (X)\nint x() { return A \n\t(1); }")()->x()]],1)
3b589f1999-02-04Fredrik Hübinette (Hubbe) 
d429a71998-02-24Fredrik Hübinette (Hubbe) test_any([[class G { mapping t=([]); class tO { void init(string name) { t[name]=this_object(); }} class W { inherit tO; void create() { init("foo"); }} }; object x=G(); x->W(); return objectp(x->t->foo)]],1)
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) 
51ffdb1998-01-19Fredrik Hübinette (Hubbe) test_program([[class foo { program x() { return class {}; }}; class bar { inherit foo; program x() { return class {}; }} int a() { return foo()->x != bar()->x(); }]])
265b721999-03-06Henrik Grubbström (Grubba) test_any([[ class A { constant gurka = 2; int foo = gurka; }; class B {
35f51c2008-06-28Martin Nilsson  protected inherit A;
265b721999-03-06Henrik Grubbström (Grubba)  constant gurka = 1; int bar; void create() { bar = foo; } }; return B()->bar; ]], 1) test_any([[ class A { constant gurka = 2; int foo = gurka; }; class B {
35f51c2008-06-28Martin Nilsson  protected inherit A;
265b721999-03-06Henrik Grubbström (Grubba)  constant gurka = 1; int bar; int baz = 3; void create() { bar = baz + foo; } }; return B()->bar; ]], 4) test_any([[ class A {
18c2b71999-03-06Henrik Grubbström (Grubba)  constant gurka = 1;
265b721999-03-06Henrik Grubbström (Grubba)  int foo = gurka; }; class B {
18c2b71999-03-06Henrik Grubbström (Grubba)  constant banan = 2;
265b721999-03-06Henrik Grubbström (Grubba)  int foo = banan; }; class C {
35f51c2008-06-28Martin Nilsson  protected inherit A; protected inherit B;
18c2b71999-03-06Henrik Grubbström (Grubba)  constant gurka = 3; constant banan = 4;
265b721999-03-06Henrik Grubbström (Grubba)  int bar;
18c2b71999-03-06Henrik Grubbström (Grubba)  int baz = 5;
265b721999-03-06Henrik Grubbström (Grubba)  void create() { bar = baz + A::foo + B::foo; } };
13d4011999-03-06Henrik Grubbström (Grubba)  return C()->bar;
18c2b71999-03-06Henrik Grubbström (Grubba) ]], 12)
265b721999-03-06Henrik Grubbström (Grubba) 
a3ece01999-03-15Henrik Grubbström (Grubba) test_any([[ class A { int a = 1; }; class B { int b = 2; }; class C { inherit A; inherit B; int c = 4; }; class D { inherit C; }; object d = D(); return d->a + d->b + d->c; ]], 7)
6b3f5c2002-04-11Martin Nilsson test_compile_error_any([[
1994251999-09-06Fredrik Hübinette (Hubbe)  class AScope { int gurka; class A { int func() { return gurka; } } } class CScope { string hohum; class C { inherit AScope.A; } } ]])
9669c12003-06-06Marcus Comstedt test_program([[ class A { constant x = 1.0; } class B { inherit A; class C { constant y = x+2.0; } } mixed a() { return 3.0 == B()->C()->y; } ]])
e5c2972003-08-18Martin Stjernholm test_program_eq([[ constant x = X; class X {constant c = "right";} constant y = Y; class Y {constant c = "wrong";} string a() { return ::`[]("x")->c; } ]], "right")
06b16a2003-08-20Martin Stjernholm test_program_eq([[ class A { string x = "x"; class B { string f() {return x;} } } class C { inherit A; constant D = A::B; } string a() { return C()->D()->f(); } ]], "x") test_program_eq([[ class A { string x = "x"; class B { string f() {return x;} } } class C { inherit A; string x = "y"; constant D = A::B; } string a() { return C()->D()->f(); } ]], "y") test_program_eq([[ class A { local string x = "x"; class B { string f() {return x;} } } class C { inherit A; string x = "y"; constant D = A::B; } string a() { return C()->D()->f(); } ]], "x") test_program_eq([[ class A { local string x = "x"; class B { void set (string new) {x = new;} string f() {return x;} } } class C { inherit A; string x = "y"; constant D = A::B; } string a() { C c = C(); C.D d = c->D(); d->set ("bar"); c->x = "foo"; return d->f(); } ]], "bar")
9669c12003-06-06Marcus Comstedt 
bb4e052000-02-11Fredrik Hübinette (Hubbe) dnl Come back when we decide that this should be possible dnl test_do([[ dnl class A { dnl constant i = 5; dnl }; dnl class B { dnl inherit A; dnl int i = 17; dnl }; dnl B(); dnl ]])
6c6c1b2000-02-07Martin Stjernholm 
1994251999-09-06Fredrik Hübinette (Hubbe)  test_any([[ class A {}; class B { inherit A; }; class C { inherit B; }; class D { inherit C; }; return Program.inherits(D,A); ]],1) test_any([[ class A {}; class B { inherit A; }; class C { inherit B; }; class D { inherit C; }; return Program.inherits(A,D); ]],0) test_any([[ class A {}; class B { inherit A; }; class C { inherit B; }; class D { inherit C; }; return Program.inherits(A,C); ]],0) test_any([[ class A {}; class B { inherit A; }; class C { inherit B; }; class D { inherit C; }; return Program.inherits(C,A); ]],1) test_any_equal([[ class A {}; class B { inherit A; }; class C { inherit B; }; class D { inherit C; }; return Program.inherit_list(D); ]],[[ ({ C }) ]] ) test_any_equal([[ class A {}; class B { inherit A; }; class C { inherit B; }; class D { inherit A; inherit B; inherit C; }; return Program.inherit_list(D); ]],[[ ({ A,B,C }) ]]) test_any_equal([[ class A {}; class B { inherit A; }; class C { inherit B; }; class D { inherit C; }; return Program.inherit_tree(D); ]],[[ ({D, ({C, ({B, ({A})})})}) ]]) test_any([[ class A {}; class B { inherit A; }; class C { inherit B; }; class D { inherit C; }; return sizeof( Program.all_inherits(D) - ({A,B,C}) ); ]],0)
e92ea22004-04-23Martin Stjernholm test_any_equal([[ class A { class C {} }; class B { class C {} }; return ({A <= B, A >= B}); ]], ({1, 1}))
878bf42002-05-02Martin Nilsson test_tests([[
342fef2000-08-23Fredrik Hübinette (Hubbe) 
562a402000-08-06Fredrik Hübinette (Hubbe) int errors; int tests;
342fef2000-08-23Fredrik Hübinette (Hubbe) #define indent(X) (X)
8307ee2001-11-08Fredrik Hübinette (Hubbe) #define FMT "%d:%d "
562a402000-08-06Fredrik Hübinette (Hubbe) 
342fef2000-08-23Fredrik Hübinette (Hubbe) int maxdepth;
36e4772000-10-13Martin Nilsson int quiet;
8307ee2001-11-08Fredrik Hübinette (Hubbe) string status_prefix="";
342fef2000-08-23Fredrik Hübinette (Hubbe) 
8527272002-04-18Henrik Grubbström (Grubba) class Codec { string nameof(mixed x) {
5520722007-06-18Martin Stjernholm  return ([ trace:"efun:trace", write:"efun:write", `+:"efun:`+" ])[x];
8527272002-04-18Henrik Grubbström (Grubba)  } function functionof(string x) {
5520722007-06-18Martin Stjernholm  return ([ "efun:trace":trace, "efun:write":write, "efun:`+":`+ ])[x] ||
8527272002-04-18Henrik Grubbström (Grubba)  0; }
4f101c2002-05-02Martin Stjernholm  mixed encode_object (object o) {} void decode_object (object o, mixed d) {}
8527272002-04-18Henrik Grubbström (Grubba) }
342fef2000-08-23Fredrik Hübinette (Hubbe) void low_generate(int depth, array(string) code, string acc, string ans, int cnt)
562a402000-08-06Fredrik Hübinette (Hubbe) {
342fef2000-08-23Fredrik Hübinette (Hubbe)  mixed tmp; if(--depth<0)
562a402000-08-06Fredrik Hübinette (Hubbe)  {
342fef2000-08-23Fredrik Hübinette (Hubbe)  string res="None";
562a402000-08-06Fredrik Hübinette (Hubbe)  tests++;
342fef2000-08-23Fredrik Hübinette (Hubbe)  if(!(tests & 63)) { __signal_watchdog();
36e4772000-10-13Martin Nilsson  if(!quiet)
5520722007-06-18Martin Stjernholm  write("\r%s" FMT, status_prefix,maxdepth,tests);
342fef2000-08-23Fredrik Hübinette (Hubbe)  } string test=code*"\n"+"\n" "mixed Q() { return "+acc+"();}\n"
5520722007-06-18Martin Stjernholm  "int main() { trace(9); write(\"%O\\n\","+acc+"()); }\n"
342fef2000-08-23Fredrik Hübinette (Hubbe)  ;
ed1aad2000-09-01Fredrik Hübinette (Hubbe) 
52f66d2003-08-03Martin Stjernholm  mixed tmp, x;
562a402000-08-06Fredrik Hübinette (Hubbe)  mixed err=catch {
ed1aad2000-09-01Fredrik Hübinette (Hubbe)  tmp=compile_string(test)();
342fef2000-08-23Fredrik Hübinette (Hubbe)  res=tmp->Q();
562a402000-08-06Fredrik Hübinette (Hubbe)  if(res != ans)
52f66d2003-08-03Martin Stjernholm  throw("Test failed"); res = "None";
8527272002-04-18Henrik Grubbström (Grubba)  tmp = decode_value(encode_value(tmp, Codec()), Codec()); res=tmp->Q(); if(res != ans)
52f66d2003-08-03Martin Stjernholm  throw("Test failed for encode/decode."); x=Program.inherit_list(object_program(tmp));
562a402000-08-06Fredrik Hübinette (Hubbe)  }; if(err) { errors++;
5b13792004-03-08Henrik Grubbström (Grubba)  werror("\nTest failed:\n" "----------------------------------\n" "%s\n" "---------------------------------\n" "expected answer: %O\n" "Answer received: %O\n",test,ans,res);
8527272002-04-18Henrik Grubbström (Grubba)  if(!stringp(err) || !has_prefix(err, "Test failed"))
342fef2000-08-23Fredrik Hübinette (Hubbe)  { string tmp=master()->describe_backtrace(err); array s=tmp/"\n"; s=s[..20];
5520722007-06-18Martin Stjernholm  write("%s\n",s*"\n");
342fef2000-08-23Fredrik Hübinette (Hubbe)  }
5b13792004-03-08Henrik Grubbström (Grubba)  if (res == "None") { // Probable decode error; try to get some debug. catch {
5520722007-06-18Martin Stjernholm  write("Encoding...\n");
5b13792004-03-08Henrik Grubbström (Grubba)  string encoded = ((function)encode_value)(tmp, Codec(), 6);
5520722007-06-18Martin Stjernholm  write("Decoding...\n");
5b13792004-03-08Henrik Grubbström (Grubba)  tmp = ((function)decode_value)(encoded, Codec(), 6);
5520722007-06-18Martin Stjernholm  write("Strange... No error thrown...\n");
5b13792004-03-08Henrik Grubbström (Grubba)  }; }
342fef2000-08-23Fredrik Hübinette (Hubbe)  return;
562a402000-08-06Fredrik Hübinette (Hubbe)  } }else{ low_generate(depth,
342fef2000-08-23Fredrik Hübinette (Hubbe)  code+ ({sprintf("string F%d(){ return %s()+\"F%d\"; }",cnt,acc,cnt)}), sprintf("F%d",cnt), sprintf("%sF%d",ans,cnt), cnt+1);
562a402000-08-06Fredrik Hübinette (Hubbe) 
342fef2000-08-23Fredrik Hübinette (Hubbe)  for(int e=0;e<sizeof(code);e++) { low_generate(depth, code[..e-1]+({ sprintf("class C%d {\n%s\n};",cnt,indent(code[e..]*"\n")) }), sprintf("C%d()->%s",cnt,acc), ans,cnt+1); }
562a402000-08-06Fredrik Hübinette (Hubbe)  if(sscanf(acc,"%s()->%s",string classname,string rest)) {
342fef2000-08-23Fredrik Hübinette (Hubbe)  low_generate(depth, code+({sprintf("inherit %s;",classname) }), rest, ans, cnt);
562a402000-08-06Fredrik Hübinette (Hubbe)  } } }
878bf42002-05-02Martin Nilsson array(int) a()
562a402000-08-06Fredrik Hübinette (Hubbe) {
5520722007-06-18Martin Stjernholm  write("\nTesting vtables and scope access.\n");
36e4772000-10-13Martin Nilsson 
b17a782002-07-29Martin Nilsson  quiet = !_verbose;
03f6012001-01-22Fredrik Hübinette (Hubbe) 
342fef2000-08-23Fredrik Hübinette (Hubbe)  int total_tests; for(maxdepth=1;maxdepth<9 && !errors;maxdepth++) { low_generate(maxdepth, ({ "string X(){return \"X\";}" }),
562a402000-08-06Fredrik Hübinette (Hubbe)  "X", "X",0);
8307ee2001-11-08Fredrik Hübinette (Hubbe)  status_prefix+=sprintf(FMT,maxdepth,tests);
36e4772000-10-13Martin Nilsson  if(quiet)
5520722007-06-18Martin Stjernholm  write("%d .. ",maxdepth);
36e4772000-10-13Martin Nilsson  else
5520722007-06-18Martin Stjernholm  write("\r%s",status_prefix);
342fef2000-08-23Fredrik Hübinette (Hubbe)  total_tests+=tests; tests=0; }
5520722007-06-18Martin Stjernholm  write("\n");
878bf42002-05-02Martin Nilsson  return ({ total_tests-errors, errors });
562a402000-08-06Fredrik Hübinette (Hubbe) }
342fef2000-08-23Fredrik Hübinette (Hubbe) 
562a402000-08-06Fredrik Hübinette (Hubbe) ]])
1f4dbd2001-05-19Mirar (Pontus Hagland) 
1994251999-09-06Fredrik Hübinette (Hubbe) test_true([[Program.implements( class { int x; string y; void foo(int x) {} }, class { void foo(mixed z) {} int x; })]]) test_false([[Program.implements( class { int x; string y; void foo(int x) {} }, class { void foo(mixed z) {} string x; })]])
fb61ba1998-04-26Fredrik Hübinette (Hubbe) test_eq([[object_program(master())]],[[(program)"/master"]]) test_compile([[object("master") m = master();]])
6126472000-03-02Fredrik Hübinette (Hubbe) test_any([[if(int x=1,y=2) return x;]],1)
fb61ba1998-04-26Fredrik Hübinette (Hubbe) test_any([[int x; x++; if(x) return x; return -1;]],1) test_any([[int x; if(x) return x; return -1;]],-1) test_any([[int x,y; if(x==y || x==1) return 2; return 0;]],2); test_any([[int x,y; if(x==y && x==0) return 2; return 0;]],2); test_any([[int x,y=1; if(x==y || x==1) return 2; return 0;]],0); test_any([[int x,y=1; if(x==y && x==0) return 2; return 0;]],0);
96794f2008-03-22Henrik Grubbström (Grubba) test_any([[int x = 1; x = x + (x = 0, 1); return x;]], 2);
fb61ba1998-04-26Fredrik Hübinette (Hubbe) 
a5787d1999-03-03Fredrik Hübinette (Hubbe)  test_any([[ return class { int i=17; }()["i"] ]],17) test_any([[ return class { int i=17; mixed `[](string foo) { return i; }}()[""] ]],17) test_any([[ return class { int i=17; mixed `[](string foo) { return ::`[]("i"); }}()[""] ]],17) test_any([[ return class { int i=17; mixed `[](string foo) { return ::`[]; }}()[""]("i") ]],17) test_any([[ return class { int i=17; mixed `[](string foo) { return ::`[]; }}()[""]("y") ]],0)
686df71999-03-04Fredrik Hübinette (Hubbe) test_any([[ object o=class { int i=17; mixed `[](string foo) { return ::`[]=; } mixed `[]=(string ind, mixed foo) {} }(); o[""]("i",99); return o->i; ]],99)
70e9781999-03-06Fredrik Hübinette (Hubbe) test_any([[ object o=class { int foo=7; int bar=11; int i=17; int gazonk=12; mixed `[](string foo) { return ::`[]=; } mixed `[]=(string ind, mixed foo) {} }(); o[""]("i",99); return o->i; ]],99) test_any([[ class Fonk { int foo=1; int bar=2; int i=17; int gazonk=3; }; object o=class { inherit Fonk; mixed `[](string foo) { return ::`[]=; } mixed `[]=(string ind, mixed foo) {} }(); o[""]("i",99); return o->i; ]],99) test_any([[ class Fonk { int foo=1; int bar=2; int i=17; int gazonk=3; }; object o=class { inherit Fonk : zonk; mixed `[](string foo) { return zonk::`[]=; } mixed `[]=(string ind, mixed foo) {} }(); o[""]("i",99); return o->i; ]],99)
68cf012000-01-07Martin Stjernholm test_any([[ class A {int foo() {return bar();} int bar();}; class B {int bar() {return 1;}}; class C {inherit A; inherit B; int bar() {return B::bar();}}; return C()->foo(); ]], 1)
c0e4461998-06-23Fredrik Hübinette (Hubbe) test_compile_any([[ class X { void hej() {} } class Y { inherit X:banan; void hopp() { banan::hej(); } } ]])
a5787d1999-03-03Fredrik Hübinette (Hubbe) 
c0e4461998-06-23Fredrik Hübinette (Hubbe) test_compile_any([[
35f51c2008-06-28Martin Nilsson  class X { protected void hej() {} }
c0e4461998-06-23Fredrik Hübinette (Hubbe)  class Y { inherit X:banan; void hopp() { ::hej(); } } ]]) test_compile_any([[
35f51c2008-06-28Martin Nilsson  class X { protected void hej() {} }
c0e4461998-06-23Fredrik Hübinette (Hubbe)  class Y { inherit X; void hopp() { X::hej(); } } ]]) test_compile_any([[
35f51c2008-06-28Martin Nilsson  class X { protected void hej() {} }
c0e4461998-06-23Fredrik Hübinette (Hubbe)  class Y { public inherit X:banan; void hopp() { banan::hej(); } } ]]) test_compile_any([[
35f51c2008-06-28Martin Nilsson  class X { protected void hej() {} }
c0e4461998-06-23Fredrik Hübinette (Hubbe)  class Y { inherit X:banan; void hopp() { banan::hej(); } }
91b0d92002-05-05Martin Stjernholm ]])
59e7652002-05-11Martin Stjernholm // Testing hidden identifier lookup with ::
3604362002-05-05Martin Stjernholm 
91b0d92002-05-05Martin Stjernholm test_program([[ class X { int i = 17; class Y { constant i = 18; mixed f (int i) {return ({i, Y::i, X::i});} } } int a() {return equal (X()->Y()->f (19), ({19, 18, 17}));} ]]) test_compile_error_any([[ #pike 7.2 class X { int i = 17; class Y { constant i = 18; mixed f (int i) {return ({i, Y::i, X::i});} } } ]]) test_compile_error_any([[ class X { constant i = 18; mixed f() {return Y::i;} } ]]) test_program([[ class A { int i = 17; } class X { inherit A: Y; class Y { constant i = 18; mixed f() {return Y::i;} } } int a() {return X()->Y()->f() == 18;} ]]) test_program([[ #pike 7.2 class A { int i = 17; } class X { inherit A: Y; class Y { constant i = 18; mixed f() {return Y::i;} } } int a() {return X()->Y()->f() == 17;} ]]) test_program([[ class A { string s = "A"; } class B { constant s = "B"; } class X { constant s = "X"; inherit A; class Y { inherit B: A; constant s = "Y"; mixed f() {return X::s + X::A::s + Y::s + Y::A::s + A::s;} } }
90bf262004-01-15Martin Nilsson  int a() { // Ignore the warning we get from overloading a constant with a string. master()->get_inhibit_compile_errors()->warning=0; return X()->Y()->f() == "XAYBB"; }
c0e4461998-06-23Fredrik Hübinette (Hubbe) ]])
f34f642002-05-05Martin Stjernholm test_program([[ class A { string s = "A"; } inherit A; class X { constant s = "X"; mixed f (string s) {return s + X::s + A::s;} } int a() {return X()->f("L") == "LXA";} ]])
59e7652002-05-11Martin Stjernholm test_program([[ class A { string f() {return "A";} string g() {return A::f();} } class B { inherit A; string f() {return "B";} } int a() {return B()->g() == "B";} ]]) test_program([[ class A { string g() {return A::f();} string f() {return "A";} } class B { inherit A; string f() {return "B";} } int a() {return B()->g() == "B";} ]]) test_program([[ class A { string f() {return "A";} string g() {return A::f();} } class B { string f() {return "B";} inherit A; } int a() {return B()->g() == "B";} ]]) test_program([[ class A { string f() {return "A";} class I { string g() {return A::f();} } } class B { inherit A; string f() {return "B";} } int a() {return B()->I()->g() == "B";} ]])
f34f642002-05-05Martin Stjernholm // Testing 'global::'
3604362002-05-05Martin Stjernholm  test_equal([[ compile_string (#" string p = \"g\"; mixed f (string p) {return ({global::p, p});}")()->f ("l"); ]], ({"g", "l"})) test_eval_error([[ compile_string (#" string pp = \"g\"; mixed f (string p) {return global::p;}"); ]]) test_eval_error([[ compile_string (#" #pike 7.2 string p = \"g\"; mixed f (string p) {return global::p;}"); ]]) test_equal([[ compile_string (#" int x = 23; class A { constant x = 24; } inherit A; class X { int x = 32; mixed f (int x) {return ({global::x, global::A::x, X::x, x});} }")()->X()->f (33); ]], ({23, 24, 32, 33}))
f34f642002-05-05Martin Stjernholm // Testing 'global.' test_compile([[
1615822008-01-04Henrik Grubbström (Grubba)  mixed a() {return global.Parser.HTML;}; a;
f34f642002-05-05Martin Stjernholm ]], 0); test_compile_error([[ #pike 7.2 mixed a() {return global.Parser.HTML;} ]], 0); test_any([[ if (!programp (Parser.HTML)) error ("This test uses the existence of Parser.HTML.\n"); return compile_string (#" class Parser {constant HTML = 1;} mixed foo() {return programp (Parser.HTML);}")()->foo(); ]], 0); test_any([[ if (!programp (Parser.HTML)) error ("This test uses the existence of Parser.HTML.\n"); return compile_string (#" mixed foo() {return programp (Parser.HTML);} class Parser {constant HTML = 1;}")()->foo(); ]], 0); test_any([[ if (!programp (Parser.HTML)) error ("This test uses the existence of Parser.HTML.\n"); return compile_string (#" class Parser {constant HTML = 1;} mixed foo() {return programp (global.Parser.HTML);}")()->foo(); ]], 1); test_any([[ if (!programp (Parser.HTML)) error ("This test uses the existence of Parser.HTML.\n"); return compile_string (#" mixed foo() {return programp (global.Parser.HTML);} class Parser {constant HTML = 1;}")()->foo(); ]], 1);
07d3f21999-04-08Fredrik Hübinette (Hubbe) // testing virtual overloading test_any([[ class fnord { int ber() { return 1; } int goo() { return ber(); } }; class blorg { inherit fnord; int ber() { return 2; } }; return blorg()->goo(); ]],2) // testing 'local' test_any([[ class fnord { local int ber() { return 1; } int goo() { return ber(); } }; class blorg { inherit fnord; int ber() { return 2; } }; return blorg()->goo(); ]],1)
f7d4312000-06-21Henrik Grubbström (Grubba) // testing 'local::' test_any([[ class fnord { int ber() { return 1; } int goo() { return local::ber(); } }; class blorg { inherit fnord; int ber() { return 2; } }; return blorg()->goo(); ]],1)
4a906f2000-06-22Henrik Grubbström (Grubba) test_any([[ class fnord { int ber() { return 1; } int goo() { return local::ber()+ber(); } }; class blorg { inherit fnord; int ber() { return 2; } }; return blorg()->goo(); ]],3) test_any([[ class fnord { int ber() { return 1; } int goo() { return ber()+local::ber(); } }; class blorg { inherit fnord; int ber() { return 2; } }; return blorg()->goo(); ]],3)
c0e4461998-06-23Fredrik Hübinette (Hubbe) 
934a662002-09-21Martin Stjernholm test_compile_error_any([[class X {int x; int f() {return local::x;}}]]) test_compile_any([[ #pike 7.2 class X {int x; int f() {return local::x;}} ]])
61e9a01998-01-25Fredrik Hübinette (Hubbe) // Testing the 'inline' keyword
31e0d31998-01-29Fredrik Hübinette (Hubbe) test_program([[class foo { inline int c() { return time(); } int d() { return c(); } }; class bar { inherit foo; int c() { return 0; } } int a() { return bar()->d(); }]],0)
61e9a01998-01-25Fredrik Hübinette (Hubbe) 
086bfa1998-04-09Fredrik Hübinette (Hubbe) test_compile_any([[ class top { class the_class { } } class inherit_top { inherit top:top; constant top_the_class=top::the_class; class the_other_class { inherit top_the_class; } } ]])
34c76c1998-04-11Henrik Grubbström (Grubba) 
3c75f32003-04-02Martin Stjernholm // Identity of nested programs. test_program([[ class A {int i; class X {int j;};} class B {inherit A;} int a() {return A()->X == B()->X;} ]]) test_program([[ class A {int i; class X {int j;};} class B {inherit A;} int a() {return A.X == B.X;} ]]) test_program([[ class A {int i; class X {int j = i;};} class B {inherit A;} int a() {return A()->X != B()->X;} ]]) test_program([[ class A {int i; class X {int j = i;};} class B {inherit A;} int a() {return A.X == B.X;} ]])
34c76c1998-04-11Henrik Grubbström (Grubba) // Testing __INIT test_any([[ class X { int x = 1; }; class Y { int y = 2; }; class Z { inherit X; inherit Y; int z = 4; }; object zz = Z(); return zz->x + zz->y + zz->z; ]], 7)
a85e2f2006-10-28Henrik Grubbström (Grubba) // Testing getter/setters test_any([[ // Trivial case. class X { int `->x() { return 5; } }; return X()->x; ]], 5) test_any([[ // Strange behaviour getter & setter. class X { int y = 2; int `->x() { return y*3; } void `->x=(int z) { y += z*5; } }; X x = X(); x->x = 2; return x->x; ]], 36) test_any([[ // Multiple inheritance. class X { int y = 0; int `->x() { return y; } void `->x=(int z) { y = z; } }; class Y { inherit X:x1; inherit X:x2; int `->x1() { return x1::x; } void `->x1=(int z) { x1::x = z; } int `->x2() { return x2::x; } void `->x2=(int z) { x2::x = z; } }; Y y = Y(); y->x1 = 1; y->x2 = 2; return (y->x1 + y->x2) * y->x; ]], 6)
d7e1de2007-09-14Henrik Grubbström (Grubba) test_any([[ // Triggered fatal error "Getter/setter variable outside program!". class X {
35f51c2008-06-28Martin Nilsson  protected int xx;
d7e1de2007-09-14Henrik Grubbström (Grubba)  int `->x() { return xx; } void `->x=(int xxx) { xx = xxx; }
35f51c2008-06-28Martin Nilsson  protected void create(int xxx) {
d7e1de2007-09-14Henrik Grubbström (Grubba)  x = xxx; } }; class Y { inherit X;
35f51c2008-06-28Martin Nilsson  protected void create(int yyy) {
d7e1de2007-09-14Henrik Grubbström (Grubba)  X:x = yyy + 2; } }; return Y(5)->x; ]], 7)
9bab652007-03-20Henrik Grubbström (Grubba) test_compile_error([[ class X { int x; int `->x() { return 0; } }; ]]) test_compile_error([[ class X { int `->x() { return 0; } int x; }; ]]) test_compile_error([[ class X { int x; void `->x=(int z) { } }; ]]) test_compile_error([[ class X { void `->x=(int z) { } int x; }; ]]) test_compile_error([[ class X { void `->x(int z) { } }; ]]) // Disabled for now. cond([[ 0 ]], [[ test_compile_error([[ class X { int `->x=() { } }; ]]) ]]) test_compile_warning([[ class X {
35f51c2008-06-28Martin Nilsson  protected int `->x() { return 0; }
9bab652007-03-20Henrik Grubbström (Grubba)  private void `->x=(int x) { } }; ]]) test_compile_warning([[ class X {
35f51c2008-06-28Martin Nilsson  protected int `->x() { return 0; }
9bab652007-03-20Henrik Grubbström (Grubba)  void `->x=(int x) { } }; ]])
11762b2000-02-08Martin Stjernholm test_do([[
bcc7d62002-04-12Martin Nilsson  // bug 3006
11762b2000-02-08Martin Stjernholm  class X { constant foo = Foo; class Foo {}
4fefbf2002-05-12Martin Stjernholm  void bar() { foo f = Foo(); } }; ]])
5590d72002-05-12Martin Stjernholm test_program([[ // Another variant of [bug 3006].
4fefbf2002-05-12Martin Stjernholm  class X {
5590d72002-05-12Martin Stjernholm  constant foo = Foo;
4fefbf2002-05-12Martin Stjernholm  class Foo {}
5590d72002-05-12Martin Stjernholm  } int a() {return programp (X.foo);} ]]) cond(0,[[ test_program([[ // This shows a case when on-demand resolving is required. class X { constant foo = a + 1; constant a = b + 1; constant b = c + 1; constant c = d + 1; constant d = 1; }; int a() {return X.foo == 5;} ]]) test_program([[ // Reference case for the test above. class X { constant d = 1; constant c = d + 1; constant b = c + 1; constant a = b + 1; constant foo = a + 1; }; int a() {return X.foo == 5;} ]])
11762b2000-02-08Martin Stjernholm ]])
d429a71998-02-24Fredrik Hübinette (Hubbe) test_any([[ class X {
35f51c2008-06-28Martin Nilsson  protected string f() { return "p"; } protected class gazonk { void create() { f(); }}; protected class g { object e() { return gazonk(); }};
d429a71998-02-24Fredrik Hübinette (Hubbe)  void create() { g()->e(); }}; return objectp(X()); ]],1)
021a2d2007-10-06Henrik Grubbström (Grubba) test_any([[class A { int x=1; }; class B { protected inherit A; int foo() { return A::x; }}; return A()->x && !B()->x && B()->foo()==A()->x;]],1)
d429a71998-02-24Fredrik Hübinette (Hubbe) test_any([[class C { int q() { return p(); } int p() { return 17; }}; return C()->q();]],17) test_any([[class C1 { class D { string id() { return "foo"; } }; class Y { program YinD() { return D; }} }; class C2 { inherit C1; class D { string id() { return "bar"; } } }; return C2()->Y()->YinD()()->id()]],"bar")
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) test_any([[object o=class foo{int c;class bar{void create(){c++;};}}(); o->bar(); return o->c;]],1) test_do([[add_constant("GURKA2",class foo { int c; class bar{void create() {c+=17;}}}()); ]]) test_any([[class x { inherit GURKA2.bar; }(); return GURKA2->c;]],17) test_any([[class x { inherit GURKA2.bar; }(); return GURKA2->c;]],34) test_do([[add_constant("GURKA2",class foo { int c; class bar{void create() { class sune { void create() {c+=17;}}(); }}}()); ]]) test_any([[class x { inherit GURKA2.bar; }(); return GURKA2->c;]],17) test_any([[class x { inherit GURKA2.bar; }(); return GURKA2->c;]],34) test_do([[add_constant("GURKA2");]]);
35f51c2008-06-28Martin Nilsson test_eq(class { protected int foo=17; }()->foo,0) test_eval_error(class c { protected int foo=17; }()->foo=18;)
de2a581997-09-28Fredrik Hübinette (Hubbe) test_equal( [[ ({ (["foo":"bar"]), (<"foo">), ([]) })->foo ]], [[ ({"bar",1,0}) ]])
fc33451997-10-02Fredrik Hübinette (Hubbe) test_any([[mixed a=({([]),0}); a[1]=a; return a->foo[0];]],0)
2c24a61997-10-07Fredrik Hübinette (Hubbe) test_eval_error([[return column(({0}),"foo");]])
284c361997-09-15Fredrik Hübinette (Hubbe) 
3b90091998-02-11Henrik Grubbström (Grubba) test_any([[ class A { constant a=0; int foo() { return a; } }; class B { inherit A; constant a=1; }; return B()->foo(); ]], 1)
2d9cbe1997-09-08Fredrik Hübinette (Hubbe) test_any([[ class p1 { int foo() { return 1; }};
7fda7a1997-09-08Fredrik Hübinette (Hubbe) class p2 { int foo() { return 3; }};
2d9cbe1997-09-08Fredrik Hübinette (Hubbe) class c1 { inherit p1; inherit p2; int foo() { return p1::foo()+p2::foo(); }};
7fda7a1997-09-08Fredrik Hübinette (Hubbe) 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; };
fb61ba1998-04-26Fredrik Hübinette (Hubbe) return c1()->foo();]],2)
7fda7a1997-09-08Fredrik Hübinette (Hubbe) 
345f101998-11-06Fredrik Hübinette (Hubbe) test_any([[ mixed ret=({}); int a, b = 3; for (a = 0; a < b; a++) { ret+=({a,b}); if (a % 2) b += 1; } return equal(ret,({0,3,1,3,2,4,3,4,4,5})); ]],1) test_any([[ mixed ret=({}); int a, b = 3; for (a = 0; a < b; a++) { ret+=({a,b}); if (a % 2) b ++; } return equal(ret,({0,3,1,3,2,4,3,4,4,5})); ]],1) test_any([[ mixed ret=({}); int a, b = 3; for (a = 0; a < b; a++) { ret+=({a,b}); if (a % 2) b=b+1; } return equal(ret,({0,3,1,3,2,4,3,4,4,5})); ]],1) test_any([[ mixed ret=({}); int a, b = 3; for (a = 0; a < b; a++) { ret+=({a,b}); if (a % 2) b-=-1; } return equal(ret,({0,3,1,3,2,4,3,4,4,5})); ]],1)
097e3d1998-02-27Fredrik Hübinette (Hubbe) test_compile_error([[void foo() { 1++; }]])
e2dab31999-12-14Fredrik Hübinette (Hubbe) dnl test_compile_error([[void foo() { return destruct(this_object()); }]])
2d12341997-03-10Fredrik Hübinette (Hubbe) test_any([[class foo { constant x=17; }; class bar { inherit foo; constant x=18; }; return bar()->x;]],18)
419fab1997-03-09Fredrik Hübinette (Hubbe) test_program([[inline string foo(string s){ while(s[0] == ' ' || s[0] == '\t') s = s[1..]; return(s); } string a() { return foo(" bar"); }]])
4218011999-01-31Fredrik Hübinette (Hubbe) 
005bf42001-09-29Fredrik Hübinette (Hubbe)  // lambda function tests
4218011999-01-31Fredrik Hübinette (Hubbe) test_true([[lambda(int x) { return lambda() { return x; };}]]) test_eq([[lambda(int x) { return lambda() { return x; };}(4)()]],4) test_eq([[lambda(int x) { return lambda() { return x; };}(17)()]],17) test_eq([[lambda(int x) { return lambda() { return lambda() { return x; };};}(17)()()]],17)
ea13682003-01-15Martin Stjernholm // trampoline tests test_do([[{ function trampoline = lambda() { int i = 17; return lambda () { error ("Trampoline called.\n"); return i; }; }(); // Now find the trampoline object. Pike tries very hard to hide
77c6b32003-02-13Martin Stjernholm  // it, so we have to do it the hard way..
ea13682003-01-15Martin Stjernholm  object obj; find_trampoline_object: {
77c6b32003-02-13Martin Stjernholm  for (obj = next_object(); objectp (obj) || // It's a normal object. (intp (obj) && obj); // It's a bignum object. obj = next_object (obj))
ea13682003-01-15Martin Stjernholm  if (obj->`() == trampoline) break find_trampoline_object; error ("Trampoline object not found.\n"); } if (!obj) error ("Trampoline object false.\n"); if (!stringp (sprintf ("%O", obj))) // The important part is to try to call the _sprintf lfun in the // trampoline object, not to check what sprintf() returns. error ("Failed to describe trampoline object.\n"); }]])
005bf42001-09-29Fredrik Hübinette (Hubbe) // local function tests
e391b72000-03-07Fredrik Noring test_eq(120,
662a902000-03-07Fredrik Hübinette (Hubbe)  [[ lambda()
e391b72000-03-07Fredrik Noring  { int f(int i) { return i == 0 ? 1 : i*f(i-1); }; return f(5);
662a902000-03-07Fredrik Hübinette (Hubbe)  }(); ]])
e391b72000-03-07Fredrik Noring 
36e93d1999-08-03Fredrik Noring test_eq([[function f; for(int i = 0; i < 2; i++) { {int _i = i; f = lambda(int j) { return _i+j; }; } } return f(17);]], [[function f; for(int i = 0; i < 2; i++)
1615822008-01-04Henrik Grubbström (Grubba)  { {int _i = i; f = lambda(int j) { return _i+j; }; } int FEL; FEL; }
36e93d1999-08-03Fredrik Noring  return f(17);]]);
005bf42001-09-29Fredrik Hübinette (Hubbe) test_any([[ int x,y,z; function p; void foo() { y+=7; }; void bar() { foo(); void gazonk() { foo(); void quux() { foo(); y+=4711; }; p=quux; }; gazonk(); gazonk(); }; foo(); bar(); p();
1615822008-01-04Henrik Grubbström (Grubba)  return y; x; z;
005bf42001-09-29Fredrik Hübinette (Hubbe) ]], 7 * 5 + 4711 )
71bde82001-03-16Fredrik Hübinette (Hubbe) 
1b54052001-06-11Henrik Grubbström (Grubba) test_any([[ int x=1; void for10(function f) { for(int e=0;e<10;e++) f(); }; for10(lambda() { x++; }); return x; ]], 11)
005bf42001-09-29Fredrik Hübinette (Hubbe) // implicit lambda tests
71bde82001-03-16Fredrik Hübinette (Hubbe) test_any([[ int x=1; void for10(function f) { for(int e=0;e<10;e++) f(); };
74d75d2002-09-16Marcus Comstedt  for10() { x++; };
71bde82001-03-16Fredrik Hübinette (Hubbe)  return x; ]], 11)
74d75d2002-09-16Marcus Comstedt test_compile_error([[ int x=1; void for10(function f) { for(int e=0;e<10;e++) f(); }; for10() { x++; } return x; ]])
43acdb2001-03-20Henrik Grubbström (Grubba) test_any([[ int x; for(int i=5; i < 10; i++) x++; return x; ]], 5)
9f68471997-03-08Fredrik Hübinette (Hubbe) test_true([[lambda(function f) {return 1;}(object_program(this_object()));]])
2898e62001-08-02Fredrik Hübinette (Hubbe) test_any([[ function my_lambda; { string foo = "foo", bar = "bar"; my_lambda = lambda() { return foo; }; } int really_magic_var;
1615822008-01-04Henrik Grubbström (Grubba)  return my_lambda(); really_magic_var;
2898e62001-08-02Fredrik Hübinette (Hubbe) ]],"foo")
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) test_eq([[class c { int `()(){ return 4711; } }()(); ]],4711)
034fb91997-02-24Fredrik Hübinette (Hubbe) teste_eval_error(mixed foo=({}); sort(@foo); ) test_compile_error([[int foo() { return 1} ; constant foo=(["foo":foo]); return foo->foo();]])
febbc81997-04-22Fredrik Hübinette (Hubbe) test_compile_error([[class T{void p(object e,object f){lambda::create(f);}}]])
18cfc12002-05-24Martin Nilsson test_eval_error(array foo=({}); return mkmapping(foo,({1})); )
0a6ffb1997-02-13Fredrik Hübinette (Hubbe) 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; } } }]])
5b43031997-01-27Fredrik Hübinette (Hubbe) test_true(encode_value(0)[0]=='\266')
2d8c5d2000-03-26Martin Stjernholm define(test_encode, [[ test_equal($1, decode_value(encode_value($1))) test_equal($1, decode_value(encode_value_canonic($1))) ]])
a991451997-07-08Fredrik Hübinette (Hubbe) test_eq(replace("foobar","","X"),"fXoXoXbXaXr")
5b43031997-01-27Fredrik Hübinette (Hubbe) test_encode(0) test_encode("") test_encode(0.0) test_encode(1.0)
bc86b31997-10-19Fredrik Hübinette (Hubbe) test_encode(-1.0)
5b43031997-01-27Fredrik Hübinette (Hubbe) test_encode(12.0) test_encode(100000.0)
f09afa2000-10-21Henrik Grubbström (Grubba) test_encode(3.1875)
bcc8af2000-10-21Henrik Grubbström (Grubba) test_encode(0.0000019073486328125)
5b43031997-01-27Fredrik Hübinette (Hubbe) test_encode(({}))
ab18db2008-02-25Per Hedbor // This should work both with and without bignums. test_encode(({0xffffffff+1, 0xffffffff+2}))
5b43031997-01-27Fredrik Hübinette (Hubbe) test_encode(([])) test_encode("foobar") test_encode((<>))
454d541999-09-18Fredrik Hübinette (Hubbe) test_encode("\7") test_encode("\77") test_encode("\777") test_encode("\7777") test_encode("\77777") test_encode("\777777") test_encode("\7777777") test_encode("\77777777")
2d8c5d2000-03-26Martin Stjernholm test_encode(({"en","sv","de"})) test_encode((<"en","sv","de">)) test_encode((["en":1,"sv":2,"de":3]))
bcc8af2000-10-21Henrik Grubbström (Grubba) test_encode(({"s",1,0,-3.40625})) test_encode((<"s",1,0,-3.40625>)) test_encode((["s":1,1:2,0:3,-3.40625:4]))
523cfb2000-08-18Henrik Grubbström (Grubba) test_encode((<1, 2, 2, 3, 3, 3>))
5b43031997-01-27Fredrik Hübinette (Hubbe) 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)
be1daa1999-11-15Henrik Grubbström (Grubba) test_eval_error([[return decode_value("\266ke0\241\346abc\b&\346de~\200\335\1\362PO\35\242")]]) test_eval_error([[return decode_value("\266ke0\241\346abcpf\221\337v\37\224")]]) test_eval_error([[return decode_value("\266ke0\241\346abc\b&\346def`\266\212\340\337\b\252\b")]]) test_eval_error([[return decode_value("\266ke0\241\346abc\b&\346def`\266\264\22\330\207")]]) test_eval_error([[return decode_value("\266ke0\241\262\266\216\213{@\333|")]]) test_eval_error([[return decode_value("\266ke0\241\346a\211[\266SN\313\331")]]) test_eval_error([[return decode_value("\266ke0\241\346ab-\266""6\227}u\320\274\251\211")]]) test_eval_error([[return decode_value("\266ke0\241\346abc\b&\346de\276\266\364\30\251s\233UF\362")]]) test_eval_error([[return decode_value("\266ke0\241\346abcv\22C\246\264\264L" )]]) test_eval_error([[return decode_value("\266ke0\241\260\303\rl")]])
ab01ea1999-09-21Fredrik Hübinette (Hubbe) 
2d8c5d2000-03-26Martin Stjernholm test_equal(encode_value_canonic ((["en":1,"sv":2,"de":3])), encode_value_canonic ((["en":1,"de":3,"sv":2]))) test_equal(encode_value_canonic ((["en":1,"sv":2,"de":3])), encode_value_canonic ((["de":3,"sv":2,"en":1]))) test_equal(encode_value_canonic ((["en":1,"sv":2,"de":3])), encode_value_canonic ((["sv":2,"en":1,"de":3]))) test_equal(encode_value_canonic ((<"en","sv","de">)), encode_value_canonic ((<"en","de","sv">))) test_equal(encode_value_canonic ((<"en","sv","de">)), encode_value_canonic ((<"de","sv","en">))) test_equal(encode_value_canonic ((<"en","sv","de">)), encode_value_canonic ((<"sv","en","de">)))
ab01ea1999-09-21Fredrik Hübinette (Hubbe) 
0176742001-07-12Fredrik Hübinette (Hubbe)  test_any([[
a662f82002-04-15Martin Nilsson // bug 3013
0176742001-07-12Fredrik Hübinette (Hubbe) class Test { class Resolver (array c) { mixed resolv (string id) { if (id == "c") return c; } } class Codec { mixed fooof (string name) {return all_constants()[name];} function objectof = fooof; function functionof = fooof; function programof = fooof; string nameof (mixed what) { if (string name = search (all_constants(), what)) return name; return ([])[0]; }
4f101c2002-05-02Martin Stjernholm  mixed encode_object (object o) {} void decode_object (object o, mixed d) {}
0176742001-07-12Fredrik Hübinette (Hubbe)  } mixed main() { array c = ({"subres"}); object o = compile (
f652862007-04-07Henrik Grubbström (Grubba)  #"string res() {return `+(@((array(function(:string)))c)());}
0176742001-07-12Fredrik Hübinette (Hubbe)  string subres() {return \"foo\";}", Resolver (c))(); for (int i = 0; i < sizeof (c); i++) if (stringp (c[i])) c[i] = o[c[i] ]; #ifdef DEBUG #define D ,1 #else #define D #endif function e=encode_value; function d=decode_value; return d (e (o, Codec() D), Codec() D)->res(); } }; return Test()->main(); ]],"foo")
3b8c9b2001-07-15Fredrik Hübinette (Hubbe) test_any([[
a662f82002-04-15Martin Nilsson // bug 3014
3b8c9b2001-07-15Fredrik Hübinette (Hubbe) class Test { class Codec { mixed nameof (mixed what) { return ([])[0]; }
4f101c2002-05-02Martin Stjernholm  mixed encode_object (object o) {} void decode_object (object o, mixed d) {}
3b8c9b2001-07-15Fredrik Hübinette (Hubbe)  } int main() { object o = compile_string (#" constant x = ({0}); int f() {return 17;}
f652862007-04-07Henrik Grubbström (Grubba)  int g() {return ((array(function(:int)))x)[0]();}
3b8c9b2001-07-15Fredrik Hübinette (Hubbe)  ")(); o->x[0] = o->f; function e=encode_value; function d=decode_value; o = d (e (o, Codec()), Codec()); return function_object (o->x[0]) == o; } }; return Test()->main(); ]],1);
7961fb1997-10-10Fredrik Hübinette (Hubbe) 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);
fb61ba1998-04-26Fredrik Hübinette (Hubbe) test_any([[float p=2.0; p--; return p;]],1.0) test_any([[float p=2.0; return --p;]],1.0)
5b43031997-01-27Fredrik Hübinette (Hubbe) 
b8cda21997-01-21Fredrik Hübinette (Hubbe) test_compile_error(int foo() { LJjjjjJJJ ; })
2aeef52002-11-26Martin Nilsson test_true(class c { constant i=1; }()->i) test_true(class c { constant i=0; mixed `->(string s) { if(s=="i") return 1; }}()->i) test_true(class c { constant i=1; mixed `->(string s) { return 0; }}()["i"]) test_true(class c { constant i=0; mixed `[](string s) { if(s=="i") return 1; }}()["i"]) test_true(class c { optional constant i=0; mixed `[](string s) { if(s=="i") return 1; }}()["i"]) test_true(class c { mixed `[]=(mixed a, mixed b) { if(a!=b) throw(1); }}()[1]=1) test_true(class c { mixed `->=(mixed a, mixed b) { if(a!=b) throw(1); }}()->i="i")
b8cda21997-01-21Fredrik Hübinette (Hubbe) 
849cfb2008-12-13Martin Nilsson test_do([[ #pragma strict_types class A { int a; optional int x; }; class B { int a; }; A a = B(); return a; ]]) test_compile_error_any([[ #pragma strict_types class A { int a; optional int x; }; class B { int b; }; A a = B(); return a; ]])
21b2c91999-12-17Fredrik Hübinette (Hubbe) test_eq((["static":42])->static,42)
35f51c2008-06-28Martin Nilsson test_eq((["protected":42])->protected,42)
21b2c91999-12-17Fredrik Hübinette (Hubbe) 
086bfa1998-04-09Fredrik Hübinette (Hubbe) test_compile_any(class A {}; class B { inherit A; })
b8cda21997-01-21Fredrik Hübinette (Hubbe) 
6bd4cc2004-05-28Henrik Grubbström (Grubba) test_any([[ // Check that indexing of objects works as expected. object m = master(); array(mixed) val = values(m); foreach(indices(m); int i; string ind) { if (m[ind] != val[i]) { error("Indexing error: master()[%O]:%O != %O.\n", ind, m[ind], val[i]); } } ]], 0)
8bef1b2001-09-27Fredrik Hübinette (Hubbe)  // Automap tests test_equal([[ ({10,20})[*] + 30 ]], [[ ({40, 50}) ]]) test_equal([[ 30 + ({10,20})[*] ]], [[ ({40, 50}) ]]) test_equal([[ ({1,2})[*] + ({10,20})[*] ]], [[ ({11, 22}) ]]) test_equal([[ ({ ({10,20}), ({30,40}) })[*][*] + 5 ]], [[ ({ ({15,25}), ({35,45}) }) ]]) test_equal([[ 5 + ({ ({10,20}), ({30,40}) })[*][*] ]], [[ ({ ({15,25}), ({35,45}) }) ]]) test_any_equal([[ array a=({ ({10,20}), ({30,40}) }); a[*][*] += 5; return a; ]], [[ ({ ({15,25}), ({35,45}) }) ]])
005bf42001-09-29Fredrik Hübinette (Hubbe) test_any_equal([[ mixed a=({1,2,3}); a[*] += -2; return a; ]], [[ ({-1,0,1}) ]]) test_any_equal([[ mixed a=({1,2,3}); a[*] += -1; return a; ]], [[ ({0,1,2}) ]]) test_any_equal([[ mixed a=({1,2,3}); a[*] += 0; return a; ]], [[ ({1,2,3}) ]]) test_any_equal([[ mixed a=({1,2,3}); a[*] += 1; return a; ]], [[ ({2,3,4}) ]]) test_any_equal([[ mixed a=({1,2,3}); a[*] += 2; return a; ]], [[ ({3,4,5}) ]]) test_any_equal([[ mixed a=({1,2,3}); return a[*] += -2; ]], [[ ({-1,0,1}) ]]) test_any_equal([[ mixed a=({1,2,3}); return a[*] += -1; ]], [[ ({0,1,2}) ]]) test_any_equal([[ mixed a=({1,2,3}); return a[*] += 0; ]], [[ ({1,2,3}) ]]) test_any_equal([[ mixed a=({1,2,3}); return a[*] += 1; ]], [[ ({2,3,4}) ]]) test_any_equal([[ mixed a=({1,2,3}); return a[*] += 2; ]], [[ ({3,4,5}) ]])
8bef1b2001-09-27Fredrik Hübinette (Hubbe) test_equal([[ "foo"[ ({ 2,0,1,2 })[*] ] ]], [[ ({ 'o', 'f', 'o', 'o' }) ]])
005bf42001-09-29Fredrik Hübinette (Hubbe) test_equal([[ ({ ({1}), ({2}), ({3}) })[*][0] ]], [[ ({ 1,2,3 }) ]]) test_equal([[ ({ ({1,2}), ({3,4}), ({5,6}) })[*][ ({0,1,1})[*] ] ]], [[ ({ 1,4,6 }) ]])
8bef1b2001-09-27Fredrik Hübinette (Hubbe) // map tests
014c361999-08-17Martin Stjernholm test_any_equal(array a = ({({1,0,0}),({1,1,0}),({0,1,1})}); return map(a,`[],1);, ({0,1,1})) test_any_equal(array a = ({({1,0,0}),({1,1,0}),({0,1,1})}); map(a,`[]=,1,0); return a;, ({({1,0,0}),({1,0,0}),({0,0,1})})) test_any_equal(array a = ({(<1>),(<1,2>),(<2,3>),(<1,3>)}); return map(a,`[],1);, ({1,1,0,1})) test_any_equal(array a = ({(<1>),(<1,2>),(<2,3>),(<1,3>)}); map(a,`[]=,1,0); return a;, ({(<>),(<2>),(<2,3>),(<3>)})) test_any_equal(array a = ({(<"a">),(<"b">),(<>)}); map(a,`->=,"a",1); return a;, ({(<"a">),(<"a","b">),(<"a">)})) test_any_equal(array a = ({([1:10]),([1:11,2:12]),([2:13])}); return map(a,`[],1);, ({10,11,0})) test_any_equal(array a = ({([1:10]),([1:11,2:12]),([2:13])}); map(a,`[]=,1,1); return a;, ({([1:1]),([1:1,2:12]),([1:1,2:13])})) test_any_equal(array a = ({(["a":10]),(["b":11]),([])}); map(a,`->=,"a",1); return a;, ({(["a":1]),(["a":1,"b":11]),(["a":1])}))
2228d51999-08-20Martin Stjernholm test_any_equal(array a = ({(["i":1]),([])}); return a["i"];, ({1,0})) test_any_equal(array a = ({(["i":1]),([])}); a["i"] = 7; return a;, ({(["i":7]),(["i":7])}))
014c361999-08-17Martin Stjernholm test_any([[
96df322000-01-03Martin Stjernholm  class A {local int i = 10; int ii(){return i;}};
014c361999-08-17Martin Stjernholm  class B {inherit A;}; class C {inherit A; int i = 11;};
96df322000-01-03Martin Stjernholm  array a = ({A(),B(),C()});
014c361999-08-17Martin Stjernholm  map(a,`[]=,"i",7);
96df322000-01-03Martin Stjernholm  return equal(a->i,({7,7,7})) && equal(a->ii(),({7,7,10}));
327c051999-11-24Fredrik Hübinette (Hubbe) ]],1)
014c361999-08-17Martin Stjernholm test_any([[
96df322000-01-03Martin Stjernholm  class A {local int i = 10; int ii(){return i;}};
014c361999-08-17Martin Stjernholm  class B {inherit A;}; class C {inherit A; int i = 11;};
96df322000-01-03Martin Stjernholm  array a = ({A(),B(),C()});
014c361999-08-17Martin Stjernholm  a->i = 7;
96df322000-01-03Martin Stjernholm  return equal(a->i,({7,7,7})) && equal(a->ii(),({7,7,10}));
327c051999-11-24Fredrik Hübinette (Hubbe) ]],1)
014c361999-08-17Martin Stjernholm test_any([[
96df322000-01-03Martin Stjernholm  class A {local int i = 10; int ii(){return i;}};
014c361999-08-17Martin Stjernholm  class B {inherit A;}; class C {inherit A; int i = 11;};
96df322000-01-03Martin Stjernholm  array a = ({A(),B(),C()});
014c361999-08-17Martin Stjernholm  map(a,`->=,"i",7);
96df322000-01-03Martin Stjernholm  return equal(a->i,({7,7,7})) && equal(a->ii(),({7,7,10}));
327c051999-11-24Fredrik Hübinette (Hubbe) ]],1)
014c361999-08-17Martin Stjernholm test_any_equal([[ array a = ({({(["a":"b"]),([]),(["c":17])}),({(["a":"b"]),(["a":7])}),(["b":"d"])}); a->a = 1; return a; ]], ({({(["a":1]),(["a":1]),(["a":1,"c":17])}), ({(["a":1]),(["a":1])}), (["a":1,"b":"d"])})) test_any_equal([[ array a = ({({(["a":"b"]),([]),(["c":17])}),({(["a":"b"]),(["a":7])}),(["b":"d"])}); map(a,`->=,"a",1); return a; ]], ({({(["a":1]),(["a":1]),(["a":1,"c":17])}), ({(["a":1]),(["a":1])}), (["a":1,"b":"d"])}))
469b532000-01-19Martin Stjernholm test_any_equal([[ /* This test tests a wild program pointer in the object o. The bug can trig a coredump in a later test. */ class A { array a = ({1}); void `->= (string var, mixed val) {::`->= (var, val);} }; class B { inherit A; void `->= (string var, mixed val) {if (var) ::`->= (var, val);} }; object o = B(); o->a += ({2}); return o->a; ]], ({1,2}))
6168ce2000-01-27Fredrik Hübinette (Hubbe) 
469b532000-01-19Martin Stjernholm test_any_equal([[ class A { array a = ({1}); void `->= (string var, mixed val) {::`->= (var, val);} }; class B { inherit A; }; object o = B(); o->a += ({2}); return o->a; ]], ({1,2}))
6168ce2000-01-27Fredrik Hübinette (Hubbe) test_any_equal([[ class A { array a = ({1}); // void `->= (string var, mixed val) {::`->= (var, val);} }; class B { int z; inherit A; void `->= (string var, mixed val) { A::`->= (var, val);} }; object o = B(); o->a += ({2}); return o->a; ]], ({1,2})) test_any_equal([[ class FOO { int q,w,z; }; class A { array a = ({1}); }; class B { inherit FOO; int b,c,d,e,f,g; inherit A; void `->= (string var, mixed val) { A::`->= (var, val);} }; object o = B(); o->a += ({2}); return o->a; ]], ({1,2})) test_any_equal([[ class A { array a = ({1}); }; class B { int z; inherit A : FNORD; class Q { mixed `-> (string var) { return FNORD::`-> (var); } void `->= (string var, mixed val) { FNORD::`->= (var, val); } } }; object o = B(); object o2=o->Q(); o2->a += ({2}); return o->a; ]], ({1,2}))
ef0a502001-09-23Mirar (Pontus Hagland) 
23d1c72000-09-30Martin Stjernholm dnl // Undefined behaviour, don't do this - Hubbe
bb4e052000-02-11Fredrik Hübinette (Hubbe) dnl test_any_equal([[ dnl class A { dnl array a = ({1}); dnl void `->= (string var, mixed val) {::`->= (var, val); a += ({17});} dnl }; dnl class B { dnl inherit A; dnl }; dnl object o = B(); dnl o->a += ({2}); dnl return o->a; dnl ]], ({1,2,17}))
00689d2000-02-10Martin Stjernholm  cond(0,[[ dnl This test is not really right, since ::`->= is defined to look up dnl statically. Still, a variant of ::`->= that does a low-level dynamic dnl lookup instead would be really useful in cases like this. test_any_equal([[ class A { int f; void `->= (string var, mixed val) {::`->= (var, val); f = 17;} }; class B { inherit A; array a = ({1}); }; object o = B(); o->a += ({2}); return o->a + ({o->f}); ]], ({1,2,17})) ]])
8e9fdf1996-12-04Fredrik Hübinette (Hubbe) test_true(mappingp(_memory_usage()))
dc38832006-09-04Martin Nilsson test_any([[ int ret = 1; foreach(_memory_usage(); string type; int value) if(value<0) { werror("_memory_usage()->%s has value %d which is <0\n", type, value); ret = 0; } return ret; ]],1)
fb61ba1998-04-26Fredrik Hübinette (Hubbe) test_true(_refs("")); test_true(_refs(({}))); test_true(_refs(([]))); test_true(_refs(this_object()))
8e9fdf1996-12-04Fredrik Hübinette (Hubbe) test_true(arrayp( _next(({})) || _prev(({}))))
327c051999-11-24Fredrik Hübinette (Hubbe) test_do(object o=this_object(); while(o=_next(o))) test_do(object o=this_object(); while(o=_prev(o)))
8e9fdf1996-12-04Fredrik Hübinette (Hubbe) 
2898e62001-08-02Fredrik Hübinette (Hubbe) test_any([[ object q=class {}(); object o=_next(this_object()); while(zero_type(o)) o=_next(o); /* skip destructed */ catch { if(objectp(o) || object_program(o)) return 1; }; o=_prev(this_object()); while(zero_type(o)) o=_prev(o); /* skip destructed */ catch { if(objectp(o) || object_program(o)) return 1; }; return 0; ]],1)
2de3791997-02-11Fredrik Hübinette (Hubbe) test_any([[object(Stdio.File) o=Stdio.File(); return objectp(o);]],1)
d2c6081996-11-07Fredrik Hübinette (Hubbe) test_any([[class Test {}; object(Test) o=Test(); return object_program(o);]],Test)
2de3791997-02-11Fredrik Hübinette (Hubbe) test_define_program(test,[[constant foo = 1; int a() { return foo; }]])
2aeef52002-11-26Martin Nilsson test_true(test()->a())
2de3791997-02-11Fredrik Hübinette (Hubbe) 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; )
2aeef52002-11-26Martin Nilsson test_do(add_constant("test");)
1c1c5e2001-04-08Fredrik Hübinette (Hubbe)  test_any([[
b9836b2001-07-05Fredrik Hübinette (Hubbe)  /* don't save parent */
1c1c5e2001-04-08Fredrik Hübinette (Hubbe)  class Foo { };
c3b5642003-01-09Henrik Grubbström (Grubba)  return (!function_object(object_program(Foo()))) && (function_program(object_program(Foo())) == object_program(this_object()));
1c1c5e2001-04-08Fredrik Hübinette (Hubbe) ]], 1) test_any([[ class Foo { };
dfaacc2009-02-21Henrik Grubbström (Grubba)  return function_name(object_program(Foo()));
1c1c5e2001-04-08Fredrik Hübinette (Hubbe) ]], "Foo")
5a6d7d2001-04-10Fredrik Hübinette (Hubbe) test_any([[ int q; return stringp(function_name( lambda() { return q; })); ]],1)
dfaacc2009-02-21Henrik Grubbström (Grubba) test_any([[ // Named lambda. int foo(){}; return function_name(foo); ]], "foo") test_any([[ // Named trampoline. int q; int foo() { return q; }; return function_name(foo); ]], "foo")
5a6d7d2001-04-10Fredrik Hübinette (Hubbe) test_any([[ int q; return function_object( lambda() { return q; }); ]],[[this_object()]])
13fa3e2002-07-27Henrik Grubbström (Grubba) test_compile(class c { object(Stdio.File) foo=class foobar {} ();}) test_compile(class c { object(Stdio.File) foo=class {} ();}) test_compile_error(class c { object(Stdio.File) foo=class {float is_file;} ();}) test_compile(class c { object(Stdio.File) foo=class { int is_file;} ();})
20d9f92003-08-10Martin Nilsson test_do(class c { object foo; object(Stdio.File) bar=foo; }) test_do(class c { object foo; Stdio.File bar=foo; })
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) test_do(class c { object(Stdio.File) foo; object bar=foo; })
20d9f92003-08-10Martin Nilsson test_do(class c { Stdio.File foo; object bar=foo; })
2f37431996-11-25Fredrik Hübinette (Hubbe) test_any(if(int i=1) return i; return 0;,1) test_compile(for(int i=0;i<100;i++) return 0;)
1615822008-01-04Henrik Grubbström (Grubba) test_compile(foreach(({}),mixed i){i;})
9e85212008-05-18Henrik Grubbström (Grubba) test_compile(sscanf("","%O",mixed foo);foo;) test_compile_error(sscanf("","",mixed foo);) test_compile_error(sscanf("","%f",float))
fb61ba1998-04-26Fredrik Hübinette (Hubbe) test_compile_error(sscanf("",float))
d2c6081996-11-07Fredrik Hübinette (Hubbe) 
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // ++ 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)
fb61ba1998-04-26Fredrik Hübinette (Hubbe) test_any([[string e=""; e++; return e;]],"1")
e5bb7d1996-09-23Fredrik Hübinette (Hubbe)  // -- 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)
6b3f5c2002-04-11Martin Nilsson test_compile_error_any(master()->add_precompiled_program(\"/test\",compile_string(\"int foo() { return 17; }\",\"62\")))
e5bb7d1996-09-23Fredrik Hübinette (Hubbe)  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;]])
c05f7c1999-11-20Mirar (Pontus Hagland) test_compile([[do { break; } while (0);]])
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 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)
694bb11998-04-23Fredrik Hübinette (Hubbe) cond([[all_constants()->_verify_internals]],
c0988f1998-04-17Fredrik Hübinette (Hubbe) [[ test_do(_verify_internals()) ]])
d644c12009-03-15Martin Stjernholm cond_begin([[all_constants()->thread_create]])
6f6eb21996-10-05Fredrik Hübinette (Hubbe) // thread_create test_do(thread_create(lambda() { })) // /precompiled/mutex
3f8f981997-02-27Fredrik Hübinette (Hubbe)  test_true(Thread.Mutex())
a0de781997-02-27Fredrik Hübinette (Hubbe)  test_do(add_constant("_tmp_mutex",Thread.Mutex()))
7f15d61996-12-07Fredrik Hübinette (Hubbe)  test_true(_tmp_mutex->lock()) test_true(_tmp_mutex->lock()) test_true(_tmp_mutex->trylock()) test_true(_tmp_mutex->trylock())
9c9ee01997-02-27Fredrik Hübinette (Hubbe)  test_do(add_constant("_tmp_mutex_lock",_tmp_mutex->lock()))
b17d201997-09-03Henrik Grubbström (Grubba)  test_true(catch(_tmp_mutex->trylock()))
9c9ee01997-02-27Fredrik Hübinette (Hubbe)  test_do(add_constant("_tmp_mutex_lock")) test_true(_tmp_mutex->trylock())
0a250e1996-12-07Fredrik Hübinette (Hubbe)  test_do(add_constant("_tmp_mutex"))
d644c12009-03-15Martin Stjernholm  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([[ array data=({0,Thread.Mutex(),Thread.Mutex(),0}); data[3]=data[2]->lock(); thread_create(lambda(array 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)
5b83801997-09-09Fredrik Hübinette (Hubbe)  test_any([[
0d6f012002-10-01Henrik Grubbström (Grubba)  array data=({1, Thread.Mutex(), Thread.Condition(), 0}); object key = data[1]->lock(); for(int e=0;e<3;e++) { data[3]++; thread_create(lambda(array 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); } object o = data[1]->lock(); data[3]--; data[2]->signal(); }, data); } while(data[3]) data[2]->wait(key); return data[0]; ]],1)
3e9fd32002-10-28Martin Stjernholm  test_any([[ object lock = Thread.Mutex()->lock(); gc(); return objectp (lock); ]], 1)
6f6eb21996-10-05Fredrik Hübinette (Hubbe)  // /precompiled/condition
3f8f981997-02-27Fredrik Hübinette (Hubbe)  test_true(Thread.Condition()) test_do(Thread.Condition()->signal()) test_do(Thread.Condition()->broadcast())
6f6eb21996-10-05Fredrik Hübinette (Hubbe) 
2aeef52002-11-26Martin Nilsson  test_true(objectp(Thread.Fifo())) test_true(objectp(Thread.Queue()))
a0de781997-02-27Fredrik Hübinette (Hubbe) 
3c47942008-07-24Henrik Grubbström (Grubba)  // Check that Thread.Queue works on the basic level. test_any([[ Thread.Queue q = Thread.Queue(); int to_write = 100000; int to_read = 0; while (to_write + to_read) {
e27dea2008-07-24Henrik Grubbström (Grubba)  if (!to_write || random(4 * to_read)) {
3c47942008-07-24Henrik Grubbström (Grubba)  int val = q->read();
e27dea2008-07-24Henrik Grubbström (Grubba)  if (val != (to_write + to_read)) return val + " != " + (to_write + to_read);
3c47942008-07-24Henrik Grubbström (Grubba)  to_read--; } else { q->write(to_write--);
e27dea2008-07-24Henrik Grubbström (Grubba)  to_read++;
3c47942008-07-24Henrik Grubbström (Grubba)  } } return 0; ]], 0)
d644c12009-03-15Martin Stjernholm  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)
dad2bb2001-05-15Mirar (Pontus Hagland)  dnl this will crash pike on out-of-address-space-related errors dnl test_any([[ catch { allocate(10000,thread_create)(lambda() { sleep(1); })->wait(); } ]])
1943a12003-11-25Martin Stjernholm  test_any([[ // Test that a loop relinquishes the interpreter lock every now and then. int count, stop; Thread.thread_create (lambda() {while (!stop) count++;}); sleep (0.1); stop = 1; sleep (0.1); return count > 0; ]], 1)
4ce3e42001-01-01Mirar (Pontus Hagland) 
9fe0a42001-11-01Martin Stjernholm  // _disable_threads test_any([[
90d08a2001-11-01Martin Stjernholm #ifndef __NT__ // Using a named pipe here to make open() block. That doesn't exist on NT.
9fe0a42001-11-01Martin Stjernholm object t = class { void log (function f, string msg) { #if 0 if (f == test) msg = "[T] " + msg; else if (f == thread_disabler) msg = " " * 20 + "[D] " + msg; else if (f == mutex_locker) msg = " " * 40 + "[L] " + msg;
5520722007-06-18Martin Stjernholm  write (msg);
9fe0a42001-11-01Martin Stjernholm #endif } mixed err; string fifo = "/tmp/testpipe." + getpid(); int started; Thread.Mutex start_lock = Thread.Mutex(); Thread.Mutex locker_lock = Thread.Mutex(); Thread.Mutex locked_mutex = Thread.Mutex(); Thread.MutexKey locked_mutex_key; void mutex_locker() { log (mutex_locker, "locker started\n"); started++; Thread.MutexKey k = start_lock->lock(); k = 0; k = locker_lock->lock(); k = 0; log (mutex_locker, "locker running\n"); err = catch (k = locked_mutex->lock()); log (mutex_locker, "locker done, error: " + (err && describe_error (err)) + "\n"); k = 0; } void thread_disabler() { log (thread_disabler, "disabler started\n"); Thread.MutexKey locker_key = locker_lock->lock(); started++; Thread.MutexKey k = start_lock->lock(); k = 0; sleep (0.1); log (thread_disabler, "disabling\n"); locker_key = 0; // Race: Don't want mutex_locker to get the lock on locker_lock // until we're in _disable_threads. object disable = _disable_threads(); log (thread_disabler, "disabled\n"); sleep (0.1); disable = 0; log (thread_disabler, "disabler done\n"); } void test() { locked_mutex_key = locked_mutex->lock(); started = 0; Thread.MutexKey start_key = start_lock->lock(); object disabler = thread_create (thread_disabler); object locker = thread_create (mutex_locker); while (started < 2) sleep (0.1);
e9b0102003-05-17Henrik Grubbström (Grubba)  Process.Process writer = Process.create_process( RUNPIKE_ARRAY + ({
9fe0a42001-11-01Martin Stjernholm  "-e",
e9b0102003-05-17Henrik Grubbström (Grubba)  sprintf ("sleep(0.5); " "Stdio.File f = Stdio.File(%O, \"w\"); " "sleep(0.5); " "f->close();", fifo) }));
9fe0a42001-11-01Martin Stjernholm  log (test, "opening pipe\n"); start_key = 0; Stdio.File f = Stdio.File (fifo, "r"); log (test, "pipe opened\n"); locked_mutex_key = 0; f->close(); disabler->wait(); locker->wait(); writer->wait(); log (test, "test done\n"); } }(); rm (t->fifo); Process.system ("mkfifo " + t->fifo); for (int i = 0; i < 5; i++) { t->test(); if (t->err) return 0; t->log (0, "------------\n"); } rm (t->fifo);
90d08a2001-11-01Martin Stjernholm  #endif
9fe0a42001-11-01Martin Stjernholm  return 1; ]], 1);
d0ba9c2008-09-09Martin Stjernholm  test_do([[ object l = _disable_threads(); Thread.thread_create (lambda () {}); destruct (l); ]])
9fe0a42001-11-01Martin Stjernholm 
dde5572009-03-13Martin Stjernholm  test_any([[ int run = 1; mapping(string:int) rounds = ([]); void imutex_locker (string id) { while (run) {
5c5f5b2009-03-14Martin Stjernholm #ifdef __NT__ // Windows got an imutex in create_process. It doesn't have to // be successful. catch (Process.create_process (({""}))); #else // Unix systems don't have an imutex in create_process, but // they got the standard password functions.
dde5572009-03-13Martin Stjernholm  getpwuid (0);
5c5f5b2009-03-14Martin Stjernholm #endif
dde5572009-03-13Martin Stjernholm  rounds[id]++; //werror (id); } }; void threads_disabler (string id) { while (run) { object l = _disable_threads(); rounds[id]++; //werror (id); l = 0; } }; array(Thread.Thread) t = ({ Thread.thread_create (imutex_locker, "0"), Thread.thread_create (imutex_locker, "1"), Thread.thread_create (imutex_locker, "2"), Thread.thread_create (threads_disabler, "a"), Thread.thread_create (threads_disabler, "b"), }); sleep (5); run = 0; t->wait(); //werror ("%O\n", rounds);
5c5f5b2009-03-14Martin Stjernholm  #if 0 // The thread yielding is really bad - even the following very // weak tests trig alarms: On FreeBSD 7.1-STABLE i386 the // thread_disablers do over 1000 times more rounds than the // imutex_lockers. On Linux 2.6.15-1.1833_FC4 x86_64 and Linux // 2.6.24-23-server i686 they do over 100 times more. On SunOS // 5.11 i86pc the thread_disablers do only 1-20 rounds in total.
dde5572009-03-13Martin Stjernholm  int minimum = min (@values (rounds)), maximum = max (@values (rounds)); if (minimum < 10) { werror ("A thread got stuck: %O\n", rounds); return 0; } // This span is currently very generous, since the time slicing in // threads.c:check_threads can be flaky on some systems. if (minimum * 100 < maximum) { werror ("Too uneven distribution between threads: %O\n", rounds); return 0; }
5c5f5b2009-03-14Martin Stjernholm #endif
dde5572009-03-13Martin Stjernholm  return 1; ]], 1)
d644c12009-03-15Martin Stjernholm  cond_end // thread_create
dde5572009-03-13Martin Stjernholm 
4716f02001-01-14Mirar (Pontus Hagland) cond([[0]], [[
4ce3e42001-01-01Mirar (Pontus Hagland)  test_any([[ // test if read() hangs when fd is closed by other thread
20a2862001-01-01Mirar (Pontus Hagland)  object f=Stdio.File(); object g=f->pipe();
4ce3e42001-01-01Mirar (Pontus Hagland)  object t=thread_create( lambda() {
20a2862001-01-01Mirar (Pontus Hagland)  g->read(4);
4ce3e42001-01-01Mirar (Pontus Hagland)  }); sleep(0.1); // yield
20a2862001-01-01Mirar (Pontus Hagland)  g->close(); // close same side of pipe as we have in read above
4ce3e42001-01-01Mirar (Pontus Hagland)  sleep(0.1); // yield if (!t->status()) return 0; // should be done now
20a2862001-01-01Mirar (Pontus Hagland)  // if not, there's no way to kill that thread
4ce3e42001-01-01Mirar (Pontus Hagland)  return 1;]],1);
6f6eb21996-10-05Fredrik Hübinette (Hubbe) ]])
747bb81996-10-15Fredrik Hübinette (Hubbe) 
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // m_delete
8d1c572000-07-11Fredrik Hübinette (Hubbe) test_any_equal([[ mapping m=([1:1]); m_delete(m,0); return m; ]],[[ ([1:1]) ]]) test_any_equal([[ mapping m=([1:1,0:3]); m_delete(m,0); return m; ]],[[ ([1:1]) ]]) test_any([[mapping a=([1:1]); return m_delete(a,1)]],1)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) test_any([[mapping m=([]); m[1]++; return m[1];]],1) test_any([[mapping m=([1:1]); m[1]++; return m[1];]],2)
1d96e72003-01-15Martin Nilsson test_any([[mapping m=([1:1]); m[1]++; return m[1]++;]],2)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) test_any([[mapping m=([]); m[1]++; m[1]++; return m[1];]],2)
7f07d82008-05-24Henrik Grubbström (Grubba) ignore_warning("Bad argument 2 to m_delete.", [[ ignore_warning("Expected: string.", [[ ignore_warning("Got : int(17..17).", [[
ab42d02008-05-21Martin Stjernholm test_any([[ #pike 7.6 mapping(string:int) x = ([]); return zero_type (m_delete (x, 17)); ]], 1)
7f07d82008-05-24Henrik Grubbström (Grubba) ]])]])]])
ab42d02008-05-21Martin Stjernholm 
fb61ba1998-04-26Fredrik Hübinette (Hubbe) // multiset tests test_any([[multiset m=(<>);int e; for(e=0;e<1000;e++) m[e]=1; for(e=0;e<1000;e++) if(!m[e]) return e; return -1; ]],-1) test_any([[multiset m=(<>);int e; for(e=0;e<1000;e++) m[e]++; for(e=0;e<1000;e++) if(!m[e]) return e; return -1; ]],-1) test_any([[multiset m=(<>);int e; for(e=0;e<1000;e++) m[e]=1; for(e=999;e>=0;e--) if(!m[e]) return e; return -1; ]],-1) test_any([[multiset m=(<>);int e; for(e=999;e>=0;e--) m[e]=1; for(e=0;e<1000;e++) if(!m[e]) return e; return -1; ]],-1) test_any([[multiset m=(<>);int e; for(e=999;e>=0;e--) m[e]=1; for(e=999;e>=0;e--) if(!m[e]) return e; return -1; ]],-1) test_any([[multiset m=(<>);int e; for(e=0;e<1000;e++) m[reverse(e)]=1; for(e=0;e<1000;e++) if(!m[reverse(e)]) return e; return -1; ]],-1) test_any([[multiset m=(<>);int e; for(e=999;e>=0;e--) m[reverse(e)]=1; for(e=0;e<1000;e++) if(!m[reverse(e)]) return e; return -1; ]],-1) test_any([[multiset m=(<>);int e; for(e=0;e<1000;e++) m[reverse(e)]=1; for(e=0;e<1000;e++) m[reverse(e)]=0; return sizeof(m); ]],0) test_any([[multiset m=(<>);int e; for(e=0;e<1000;e++) m[reverse(e)]=1; for(e=0;e<1000;e+=2) m[reverse(e)]=0; for(e=0;e<1000;e+=2) if(m[reverse(e)]) return e; for(e=1;e<1000;e+=2) if(!m[reverse(e)]) return e; return -1; ]],-1) test_any([[multiset m=(<>);int e; for(e=0;e<1000;e++) m[reverse(e)]=1; for(e=0;e<1000;e++) m[reverse(e)]++; for(e=0;e<1000;e++) if(m[reverse(e)]!=1) return e; return -1; ]],-1) test_any([[multiset m=(<>);int e; mixed a; a=allocate(1000); for(e=0;e<1000;e++) { m[reverse(e)]=1; a[e]=reverse(e); } add_constant("mtest_m",m); add_constant("mtest_i",a); return 1; ]],1)
bdba3f2001-06-20Henrik Grubbström (Grubba) test_any([[
d5202d2001-06-20Henrik Grubbström (Grubba)  multiset m = set_weak_flag((<>), 1); m[1] = 1; return sizeof(m); ]], 1) test_true([[ multiset m = set_weak_flag((<>), 1); m[1] = 1; return get_weak_flag(m); ]])
fb61ba1998-04-26Fredrik Hübinette (Hubbe) test_eq([[sizeof(mtest_m)]],sizeof(mtest_i)) test_equal(Array.sort_array(indices(mtest_m)),Array.sort_array(mtest_i)) test_equal(mtest_m,copy_value(mtest_m)) test_any([[multiset m=(<>);int e; mixed a; a=allocate(100); for(e=0;e<100;e++) { m[reverse(e-50)]=1; a[e]=reverse(e-50); if(sizeof(m)!=e+1) return e; } add_constant("mtest_m2",m); add_constant("mtest_i2",a); return -1; ]],-1) test_eq([[sizeof(mtest_m2)]],sizeof(mtest_i2)) test_any([[int e;multiset q=(<>),p=(<>); for(e=0;e<1000;e++) { p[reverse(e)]=1; q+=(<reverse(e)>); if(!equal(sort(indices(p)),sort(indices(q)))) return 0; } return 1;]],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)) test_do(add_constant("mtest_m"); add_constant("mtest_i"); ) test_do(add_constant("mtest_m2"); add_constant("mtest_i2"); )
ebb0b41998-04-29Fredrik Hübinette (Hubbe) define([[MTEST]],[[test_equal([[mkmultiset(indices(allocate($1)))]],[[mkmultiset(reverse(indices(allocate($1))))]])]])
fb61ba1998-04-26Fredrik Hübinette (Hubbe)  MTEST(0) MTEST(1) MTEST(2) MTEST(3) MTEST(5) MTEST(8) MTEST(13) MTEST(21) MTEST(34) MTEST(55) define([[MTEST]])
17f2a42001-03-02Marcus Comstedt test_equal([[lambda(multiset x){return ({x[17]++,x[17]++,x[17]++});}((<>))]], [[({0,1,1})]])
7f202a2004-06-13Martin Stjernholm test_any([[ object o1 = class{}(), o2 = class{}(), o3 = class{}(); multiset m = (<o1, o2, o3, 17>); destruct (o1), destruct (o2), destruct (o3); return m[17]; ]], 1); test_any_equal([[ object o1 = class{}(), o2 = class{}(), o3 = class{}(); multiset m = (<o1, o2, o3, 17>); destruct (o1), destruct (o2), destruct (o3); return copy_value (m); ]], (<17>));
fb025e2004-05-19Martin Stjernholm test_do([[ multiset a = copy_value ((<(<1,2,3>), ({5,4}), ([1:2]), 1, ({}), (<1,2>), "foo">)); foreach (a; mixed i;) if (!a[i]) error ("Can't find multiset member in itself: %O\n", i); ]])
f8d9402006-07-07Martin Stjernholm test_any_equal([[ multiset m=(<"Stone","2","%70">); foreach(m;string k;) { if(k=="%70") { m[k]=0; break; } } return sort ((array) (m - (<>))); ]], ({"2", "Stone"}))
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // 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; }
2de3791997-02-11Fredrik Hübinette (Hubbe)  add_constant("mtest_m",m); add_constant("mtest_i",a); add_constant("mtest_v",b);
e5bb7d1996-09-23Fredrik Hübinette (Hubbe)  return 1; ]],1) test_eq([[sizeof(mtest_m)]],sizeof(mtest_i))
2de3791997-02-11Fredrik Hübinette (Hubbe) 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))
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 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);
1b8b4f2003-11-12Henrik Grubbström (Grubba)  b[e]=e-50;
e5bb7d1996-09-23Fredrik Hübinette (Hubbe)  }
2de3791997-02-11Fredrik Hübinette (Hubbe)  add_constant("mtest_m2",m); add_constant("mtest_i2",a); add_constant("mtest_v2",b);
e5bb7d1996-09-23Fredrik Hübinette (Hubbe)  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))
1b8b4f2003-11-12Henrik Grubbström (Grubba) test_equal(sort(values(mtest_m|mtest_m2)),sort(map(mtest_i|mtest_i2,mtest_m|mtest_m2))) test_equal(sort(values(mtest_m&mtest_m2)),sort(map(mtest_i&mtest_i2,mtest_m|mtest_m2))) test_equal(sort(values(mtest_m-mtest_m2)),sort(map(mtest_i-mtest_i2,mtest_m|mtest_m2))) test_equal(sort(values(mtest_m^mtest_m2)),sort(map(mtest_i^mtest_i2,mtest_m|mtest_m2))) test_equal(sort(values(mtest_m2|mtest_m)),sort(map(mtest_i2|mtest_i,mtest_m|mtest_m2))) test_equal(sort(values(mtest_m2&mtest_m)),sort(map(mtest_i2&mtest_i,mtest_m|mtest_m2))) test_equal(sort(values(mtest_m2-mtest_m)),sort(map(mtest_i2-mtest_i,mtest_m|mtest_m2))) test_equal(sort(values(mtest_m2^mtest_m)),sort(map(mtest_i2^mtest_i,mtest_m|mtest_m2)))
e664411998-04-27Fredrik Hübinette (Hubbe) 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");)
ebb0b41998-04-29Fredrik Hübinette (Hubbe) define([[MTEST]],[[test_equal([[mkmapping(indices(allocate($1)),reverse(indices(allocate($1))))]],[[mkmapping(reverse(indices(allocate($1))),indices(allocate($1)))]])]])
e5bb7d1996-09-23Fredrik Hübinette (Hubbe)  MTEST(0) MTEST(1) MTEST(2) MTEST(3) MTEST(5) MTEST(8) MTEST(13) MTEST(21) MTEST(34) MTEST(55) define([[MTEST]])
9e6d452001-09-04Fredrik Hübinette (Hubbe) test_do([[ class X { mapping gurka; class Tomat { int `==(mixed x) { /* make hash bigger */ for(int e=sizeof(gurka);e<1000;e++) gurka[e]=e; return 0; } int __hash() { return 99999; } }; class Sallad { int __hash() { return 99999; } }; void create() { for(int x=1;x<255;x++) { gurka=([]); for(int e=0;e<x;e++) gurka[~e]=e; gurka[Sallad()]=-2; gurka[Tomat()]=-3; } } }(); ]])
e664411998-04-27Fredrik Hübinette (Hubbe) test_equal([[ `+( ([1:2]) )]],[[ ([1:2]) ]]) test_false( `+( ([1:2]) ) == ([1:2]) ) test_equal([[ `+( ([1:2]), ([1:2]) )]],[[ ([1:2]) ]]) test_equal([[ `+( ([1:2]), ([1:2]), ([2:3,4:5]) )]],[[ ([1:2,2:3,4:5]) ]]) test_equal([[ `+( ([1:2]), ([1:2]), ([2:3,4:5]), ([6:7,1:2]) )]],[[ ([1:2,2:3,4:5,6:7]) ]]) test_equal([[ `+( ([1:2]), ([1:2]), ([2:3,4:5]), ([6:7,1:2]),([8:9]) )]],[[ ([1:2,2:3,4:5,6:7,8:9]) ]] ) test_any([[mapping m=([1:2,3:2]); return search(m,2,search(m,2))!=-1;]],1)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 
ee37801999-02-09Fredrik Hübinette (Hubbe) test_any([[mapping m=([]); for(int e=0;e<1000;e++) m[e&3]+=({e}); return sizeof(m)==4 && sizeof(m[0])==250;]],1)
958ced2001-01-26Martin Stjernholm test_any([[ mapping m = set_weak_flag (([1:1]), 1); m_delete (m, 1); return get_weak_flag (([])); ]], 0);
17f2a42001-03-02Marcus Comstedt test_equal([[lambda(mapping x){return ({x[17]++,x[17]++,x[17]++});}(([]))]], [[({0,1,2})]])
5215a82003-06-02Martin Stjernholm test_equal([[([1:2, 3:4]) - (<0, 1, 2>)]], ([3:4])) test_equal([[([1:2, 3:4]) - ({0, 1, 2})]], ([3:4])) test_equal([[([1:2, 3:4]) & (<0, 1, 2>)]], ([1:2])) test_equal([[([1:2, 3:4]) & ({0, 1, 2})]], ([1:2]))
639e6e2000-09-04Martin Stjernholm // destructed indices test_any([[{ object o = class{}(); mapping m = ([o: 1]); destruct (o); return equal (m, ([])) && equal (m, ([])); }]], 1) test_any([[{ object o = class{}(); mapping m = ([o: 1]), n = ([class{}(): 1]); destruct (o); return !equal (m, n) && !equal (m, n); }]], 1)
72a90c2000-09-23Martin Stjernholm test_any([[{ object o = class{}(); mapping m = ([o: 1]); destruct (o); return sizeof (indices (m)) || sizeof (m); }]], 0) test_any([[{ object o = class{}(); mapping m = ([o: 1]); destruct (o); return sizeof (values (m)) || sizeof (m); }]], 0)
639e6e2000-09-04Martin Stjernholm 
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // gc
44dbb62003-02-12Martin Stjernholm 
e5bb7d1996-09-23Fredrik Hübinette (Hubbe)  test_true(intp(gc()));
6ea4d62008-08-23Martin Stjernholm  test_true(mappingp (((function) Debug.gc_status)()))
d9e9bd1996-12-05Fredrik Hübinette (Hubbe)  test_any([[ array a=({0}); a[0]=a; gc(); a=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);
5953b22000-06-10Martin Stjernholm  test_any([[{ #if !constant (_debug) int _debug (int d) {return 0;}; #endif // Must turn off debug in this test or else we'll get extra // references to p in the backlog. int dlevel = _debug (0); program p=compile_string("constant a=({0});"); object o=p(); o->a[0]=p; gc(); p=o=0; _debug (dlevel); return gc() > 0; }]], 1);
c023e91999-11-18Fredrik Hübinette (Hubbe) 
14db072003-02-13Martin Stjernholm test_any([[ object o = class {function f; void foo() {}}(); o->f = o->foo; gc(); o = 0; return gc(); ]], 0) test_any([[ object o = class {object o;}(); o->o = o; gc(); o = 0; return gc(); ]], 0) test_any([[ class X {function f; void foo() {}}; object o1 = X(), o2 = X(); o1->f = o2->foo; o2->f = o1->foo; gc(); o1 = o2 = 0; return gc(); ]], 2) test_any([[ class X {object o;}; object o1 = X(), o2 = X(); o1->o = o2; o2->o = o1; gc(); o1 = o2 = 0; return gc(); ]], 2)
c023e91999-11-18Fredrik Hübinette (Hubbe)  test_any([[gc(); int q=lambda() { mixed foo; foo=lambda() { return foo; }; return 1; }(); return gc()>0; ]],1)
2db2421999-10-29Martin Stjernholm  test_true([[ object o = class{}(); mapping m = ([class{}(): o, o: class{}()]); set_weak_flag (m, 1); gc(); return !sizeof (m); ]])
9da7f42001-06-05Martin Stjernholm  test_true([[ object o = class{}(); mapping m = ([class{}(): o, o: class{}()]); set_weak_flag (m, Pike.WEAK_INDICES); gc(); return sizeof (m); ]]) test_true([[ object o = class{}(); mapping m = ([class{}(): o, o: class{}()]); set_weak_flag (m, Pike.WEAK_VALUES); gc(); return sizeof (m); ]]) test_true([[
2db2421999-10-29Martin Stjernholm  object o = class{}(); multiset m = (<o>); set_weak_flag (m, 1); m[class{}()] = 1; m[o] = 0; gc(); return !sizeof (m); ]])
1f342f2000-02-04Fredrik Hübinette (Hubbe) 
8131642001-01-17Martin Stjernholm  test_do([[
64621b2004-07-16Henrik Grubbström (Grubba)  mixed eat_stack(int|void probe)
8131642001-01-17Martin Stjernholm  {
64621b2004-07-16Henrik Grubbström (Grubba)  // Avoid eating as much C-stack by releasing the // catch at every level. if (probe) return 1; if (catch(eat_stack(1))) return 1;
5f03ba2001-01-18Martin Stjernholm  mixed err = 1;
64621b2004-07-16Henrik Grubbström (Grubba)  if ((err = eat_stack()) != 10) return intp(err) && err > 0 ? err + 1 : err;
5f03ba2001-01-18Martin Stjernholm  if (err = catch { class Foo { object foo;
35f51c2008-06-28Martin Nilsson  protected void create(object o) {foo = o;}
5f03ba2001-01-18Martin Stjernholm  }; Foo foo; for(int i=0; i < 10000; i++) foo = Foo(foo); gc(); }) return err;
8131642001-01-17Martin Stjernholm  };
45b9cf2001-01-18Martin Stjernholm  if (mixed err = eat_stack()) throw (err);
8131642001-01-17Martin Stjernholm  ]])
1f342f2000-02-04Fredrik Hübinette (Hubbe)  test_any([[ mapping m=([]); m->self=m; mapping q=(["foo":"bar","gazonk":1]); m->q=q; q+=([]); m=0; gc(); return sizeof(q); ]],2)
3825ec2000-04-14Martin Stjernholm  test_eq([[ int dummy; gc(); function f = lambda() { object o = class{}(); int i; return lambda() {return i;}; }(); lambda() {dummy++;}(); // Ensure refcount garbing is done. int n = gc(); // n should be 0; o should be refcount garbed above, the frame for f // should be intact for use below. dummy += f(); return n; ]], 0) test_true([[ class Foo { object c; class A {object b;} class B {object a; void destroy() {c = class{}();}} mixed test() { object a = A(), b = B(); a->b = b; b->a = a; a = b = 0; gc(); return c; } }()->test(); ]])
5953b22000-06-10Martin Stjernholm  test_any([[{ array a = ({({0})}); a[0][0] = a; gc(); a = 0; return gc() > 0; }]], 1)
f06dc32000-12-14Martin Stjernholm  test_any([[{ object o = class {}(); mapping m = ([o: ({17})]); gc(); destruct (o); return gc() > 0; }]], 1)
5953b22000-06-10Martin Stjernholm  test_any([[{ class Dead {object o;}; object o = Dead(); o->o = Dead(); o->o->o = o; gc(); o = 0; return gc() > 0; }]], 1) test_any([[{ class Live {object o; void destroy() {}}; object o = Live(); o->o = Live(); o->o->o = o; gc(); o = 0; return gc() > 0; }]], 1) test_any([[{ class Dead {object o;}; class Live {object o; void destroy() {}}; object o = Dead(); o->o = Live(); o->o->o = o; gc(); o = 0; return gc() > 0; }]], 1) test_any([[{ class Dead {object o;}; class Live {object o; void destroy() {}}; object o = Live(); o->o = Dead(); o->o->o = o; gc(); o = 0; return gc() > 0; }]], 1) test_any_equal([[{ class Live {object o; void destroy() {}}; array a = set_weak_flag(({Live()}), 1);
d3ade92003-02-19Henrik Grubbström (Grubba)  gc(); return set_weak_flag(a, 0);
5953b22000-06-10Martin Stjernholm  }]], ({0})) test_any_equal([[{ class Live {object o; void destroy() {}}; multiset l = set_weak_flag((<Live()>), 1);
d3ade92003-02-19Henrik Grubbström (Grubba)  gc(); return set_weak_flag(l, 0);
5953b22000-06-10Martin Stjernholm  }]], (<>)) test_any_equal([[{ class Live {object o; void destroy() {}}; mapping m = set_weak_flag(([0: Live()]), 1);
d3ade92003-02-19Henrik Grubbström (Grubba)  gc(); return set_weak_flag(m, 0);
5953b22000-06-10Martin Stjernholm  }]], ([])) test_any_equal([[{ class Live {object o; void destroy() {}}; mapping m = set_weak_flag(([Live(): 0]), 1);
d3ade92003-02-19Henrik Grubbström (Grubba)  gc(); return set_weak_flag(m, 0);
5953b22000-06-10Martin Stjernholm  }]], ([])) test_any_equal([[{ array a = set_weak_flag(({4711, 0x54325827a124*0x12348795482485425}), 1);
d3ade92003-02-19Henrik Grubbström (Grubba)  gc(); return set_weak_flag(a, 0);
5953b22000-06-10Martin Stjernholm  }]], ({4711, 0x54325827a124*0x12348795482485425}))
a44f1a2000-09-15Martin Stjernholm  test_any_equal([[{ object o = class Live {
14db072003-02-13Martin Stjernholm  array g;
a44f1a2000-09-15Martin Stjernholm  array a = ({17});
14db072003-02-13Martin Stjernholm  void create() {g = ({this_object()});}
a44f1a2000-09-15Martin Stjernholm  void destroy() {all_constants()->kablutt = a;} }(); o = 0; gc(); return all_constants()->kablutt; }]], ({17})); test_any([[{ object o = class Live {
14db072003-02-13Martin Stjernholm  array g;
a44f1a2000-09-15Martin Stjernholm  array a = set_weak_flag (({({17})}), 1);
14db072003-02-13Martin Stjernholm  void create() {g = ({this_object()});}
a44f1a2000-09-15Martin Stjernholm  void destroy() { if (!equal (a, ({({17})}))) error ("Contents in weak array zapped: %O.\n", a); } }(); o = 0; return gc() >= 3; }]], 1); test_any_equal([[{ object o = class Live {
14db072003-02-13Martin Stjernholm  array g;
a44f1a2000-09-15Martin Stjernholm  array a = set_weak_flag (({({17})}), 1);
14db072003-02-13Martin Stjernholm  void create() {g = ({this_object()});}
a44f1a2000-09-15Martin Stjernholm  void destroy() {all_constants()->blatinka = a;} }(); o = 0; gc(); if (!equal (all_constants()->blatinka, ({({17})}))) error ("Contents in saved weak array zapped: %O.\n", all_constants()->blatinka); gc(); return all_constants()->blatinka; }]], ({0}));
2aeef52002-11-26Martin Nilsson test_do(add_constant("kablutt");) test_do(add_constant("blatinka");)
5bf37d2000-10-13Fredrik Hübinette (Hubbe) 
0455ff2003-03-30Martin Stjernholm  test_any([[{ #if constant (_debug) // Temporarily disable debug so we don't get references to p in // the intepreter backlog. int old_debug = _debug (0); #endif object o = class {program p; object o;}(); class Resolver (mixed x) {mixed resolv (string id) {return x;}}; program p = compile ("constant o = foo;", Resolver (o)); o->p = p; o->o = p(); gc(); o = p = 0; #if constant (_debug) _debug (old_debug); #endif return gc() > 0; }]], 1)
5953b22000-06-10Martin Stjernholm  test_any([[{ class Dead {object o;}; object o = Dead(); o->o = Dead(); array a = set_weak_flag(({o}), 1); gc(); o = 0; return gc() > 0; }]], 1) test_any([[{ class Dead {object o;}; class Live {object o; void destroy() {}}; object o = Live(); o->o = Dead(); array a = set_weak_flag(({o}), 1); gc(); o = 0; return gc() > 0; }]], 1) test_any([[{ class Dead {object o;}; class Live {object o; void destroy() {}}; object o = Dead(); o->o = Live(); array a = set_weak_flag(({o}), 1); gc(); o = 0; return gc() > 0; }]], 1)
96dd6f2000-06-12Martin Stjernholm  test_do([[{ object o = class {}(); array a = ({o}); destruct (o); gc(); }]]);
6d30f52000-07-11Martin Stjernholm  test_any([[{ array a = ({0}), b = ({a, set_weak_flag (({a}), 1)}); array x = set_weak_flag (({a}), 1); a[0] = b; a = b = 0; gc(); return !x[0]; }]], 1); test_any([[{ mapping a = ([]), b = ([a:set_weak_flag (([a:a]), 1)]); mapping x = set_weak_flag (([a:2]), 1); a[b] = b; a = b = 0; gc(); return !sizeof (x); }]], 1); test_any([[{ multiset a = (<>), b = (<a, set_weak_flag ((<a>), 1)>); multiset x = set_weak_flag ((<a>), 1); a[b] = 1; a = b = 0; gc(); return !sizeof (x); }]], 1);
5bf37d2000-10-13Fredrik Hübinette (Hubbe) 
6d30f52000-07-11Martin Stjernholm  test_any([[{ class Foo {
14db072003-02-13Martin Stjernholm  array(Foo) f = ({this_object()});
6d30f52000-07-11Martin Stjernholm  multiset(Foo) g = set_weak_flag((<this_object()>), 1); }; multiset(Foo) x = set_weak_flag ((<Foo()>), 1); gc(); return !sizeof (x); }]], 1); test_any([[{ class Foo {
14db072003-02-13Martin Stjernholm  array(Foo) f = ({this_object()});
6d30f52000-07-11Martin Stjernholm  multiset(Foo) g = set_weak_flag((<this_object()>), 1); void destroy() {add_constant("beltbent_oblivion", 1);} }; multiset(Foo) x = set_weak_flag ((<Foo()>), 1); gc(); int res = all_constants()->beltbent_oblivion; add_constant("beltbent_oblivion"); return res; }]], 1);
10c4a42000-08-17Martin Stjernholm  test_any([[{
bc23b42003-01-11Martin Stjernholm  gc();
10c4a42000-08-17Martin Stjernholm  array x = set_weak_flag (({0}), 1); x[0] = x; multiset b = set_weak_flag ((<x>), 1); array a = ({17}); b[a] = 1; x = 0;
bc23b42003-01-11Martin Stjernholm  return gc() >= 1;
10c4a42000-08-17Martin Stjernholm  }]], 1); test_any([[{
bc23b42003-01-11Martin Stjernholm  gc();
10c4a42000-08-17Martin Stjernholm  array a = set_weak_flag (({0, this_object()}), 1); a[0] = a; a = 0;
bc23b42003-01-11Martin Stjernholm  return gc() >= 1;
10c4a42000-08-17Martin Stjernholm  }]], 1); test_any([[{
bc23b42003-01-11Martin Stjernholm  gc();
10c4a42000-08-17Martin Stjernholm  array y = set_weak_flag (({0}), 1), z = set_weak_flag (({y}), 1); y[0] = z; y = z = 0;
bc23b42003-01-11Martin Stjernholm  return gc() >= 2;
10c4a42000-08-17Martin Stjernholm  }]], 1); test_any([[{ class Live { array a;
14db072003-02-13Martin Stjernholm  array g = ({this_object()});
10c4a42000-08-17Martin Stjernholm  void create() { a = set_weak_flag (({0}), 1); array b = set_weak_flag (({a}), 1); a[0] = b; } void destroy() { if (!arrayp(a) || !arrayp(a[0]) || a[0][0] != a)
3cc12a2001-07-01Martin Stjernholm  add_constant ("my_little_error", "GC garbed weak things too early.\n");
10c4a42000-08-17Martin Stjernholm  } };
bc23b42003-01-11Martin Stjernholm  gc();
10c4a42000-08-17Martin Stjernholm  object o = Live(); o = 0;
bc23b42003-01-11Martin Stjernholm  int res = gc() >= 3;
3cc12a2001-07-01Martin Stjernholm  if (all_constants()->my_little_error) error (all_constants()->my_little_error); return res;
10c4a42000-08-17Martin Stjernholm  }]], 1);
3cc12a2001-07-01Martin Stjernholm  test_do([[{ class Live { Foo f; void destroy() { if (!f->l || !f->a || !f->a[0] || !f->a[1]) add_constant ("my_little_error", "GC garbed live things.\n"); } }; class Foo { int i; class Bar { int j = i++; // Ensure parent pointer. array a = ({j}); } Live l; void create (Live _l) { l = _l; l->f = this_object(); } array a = allocate (2, Bar)(); }; object o = Foo(Live()); o = 0; gc(), gc(); if (all_constants()->my_little_error) error (all_constants()->my_little_error); }]]);
3fe44f2001-07-02Martin Stjernholm  test_do([[{ object o = compile_string(#" class Foo { int i; class Bar { int j = i++; // Ensure parent pointer. } inherit Bar; }")(); o = 0; gc(); }]]);
5bf37d2000-10-13Fredrik Hübinette (Hubbe) 
639e6e2000-09-04Martin Stjernholm  test_do([[{ mapping a = ([1:({17}),2:3,4:5,6:7,8:9]), b = a + ([]); set_weak_flag (b, 1); gc(); }]]); test_do([[{ mapping a = ([1:({17})]), b = a + ([]); set_weak_flag (b, 1); gc(); }]]); test_any([[{ mapping a = ([17:({17})]); for (int i = 0; i < 10; i++) a[class{}()] = i; mapping b = a + ([]); set_weak_flag (b, 1); foreach (indices (a), mixed o) if (objectp (o)) destruct (o); gc(); return sizeof (a) == 1 && sizeof (b) == 1; }]], 1); test_any([[{ mapping a = ([17:({17})]); for (int i = 0; i < 10; i++) a[class{}()] = i; mapping b = a + ([]); set_weak_flag (a, 1); foreach (indices (a), mixed o) if (objectp (o)) destruct (o); gc(); return sizeof (a) == 1 && sizeof (b) == 1; }]], 1); test_any([[{ mapping a = ([17:({17})]); for (int i = 0; i < 10; i++) a[class{}()] = i; mapping b = a + ([]); set_weak_flag (a, 1); set_weak_flag (b, 1); foreach (indices (a), mixed o) if (objectp (o)) destruct (o); gc(); return !sizeof (a) && !sizeof (b); }]], 1); test_any([[{ mapping a = ([17:({17})]); set_weak_flag (a, 1); for (int i = 0; i < 10; i++) a[class{}()] = i; mapping b = a + ([]); foreach (indices (a), mixed o) if (objectp (o)) destruct (o); gc(); return sizeof (a) == 1 && sizeof (b) == 1; }]], 1);
a44f1a2000-09-15Martin Stjernholm  test_any([[{ mapping a = set_weak_flag (([17: set_weak_flag (({({17})}), 1)]), 1); return gc() >= 2 && !sizeof (a); }]], 1);
639e6e2000-09-04Martin Stjernholm 
23d1c72000-09-30Martin Stjernholm  test_any([[{ object o = class{}(); mapping a = set_weak_flag ((["foo": o]), 1); gc(); return sizeof (a); }]], 1); test_any([[{ object o = class{}(); mapping a = set_weak_flag (([o: o]), 1); gc(); return sizeof (a); }]], 1); test_any([[{ object o1 = class{}(), o2 = class{}(); mapping a = set_weak_flag (([o1: o2]), 1); gc(); return sizeof (a); }]], 1); test_any([[{ object o = class{}(); mapping a = set_weak_flag (([o: o]), 1); o = 0; return gc() >= 1 && !sizeof (a); }]], 1); test_any([[{ object o = class{}(); mapping a = set_weak_flag (([class{}(): o]), 1); return gc() >= 1 && !sizeof (a); }]], 1); test_any([[{ object o = class{}(); mapping a = set_weak_flag (([o: class{}()]), 1); return gc() >= 1 && !sizeof (a); }]], 1); test_any([[{ mapping a = set_weak_flag (([class{}(): class{}()]), 1); return gc() >= 2 && !sizeof (a); }]], 1);
f06dc32000-12-14Martin Stjernholm  test_any([[{
23d1c72000-09-30Martin Stjernholm  object o = class{}(); mapping a = set_weak_flag ((["foo": o]), 1); destruct (o); gc(); return !sizeof (a); }]], 1); test_any([[{ object o = class{}(); mapping a = set_weak_flag (([o: o]), 1); destruct (o); gc(); return !sizeof (a); }]], 1); test_any([[{ object o = class{}(); mapping a = set_weak_flag (([class{}(): o]), 1); destruct (o); return gc() >= 1 && !sizeof (a); }]], 1); test_any([[{ object o = class{}(); mapping a = set_weak_flag (([o: class{}()]), 1); destruct (o); return gc() >= 1 && !sizeof (a); }]], 1); test_any([[{ object o = class{}(); mapping a = set_weak_flag (([o: o]), 0); destruct (o); gc(); return !sizeof (a); }]], 1); test_any([[{ object o = class{}(); mapping a = set_weak_flag (([class{}(): o]), 0); destruct (o); gc(); return sizeof (a); }]], 1); test_any([[{ object o = class{}(); mapping a = set_weak_flag (([o: class{}()]), 0); destruct (o); gc(); return !sizeof (a); }]], 1);
a1cf472001-07-12Martin Stjernholm  test_any_equal([[{ array a = set_weak_flag (({1, "foo", 3.14}), 1); gc();
d3ade92003-02-19Henrik Grubbström (Grubba)  return set_weak_flag(a, 0);
a1cf472001-07-12Martin Stjernholm  }]], ({1, "foo", 3.14})); test_any_equal([[{ multiset a = set_weak_flag ((<1, "foo", 3.14>), 1); gc();
d3ade92003-02-19Henrik Grubbström (Grubba)  return set_weak_flag(a, 0);
a1cf472001-07-12Martin Stjernholm  }]], (<1, "foo", 3.14>)); test_any_equal([[{ mapping a = set_weak_flag (([1: 1, "foo": "foo", 3.14: 3.14]), 1); gc();
d3ade92003-02-19Henrik Grubbström (Grubba)  return set_weak_flag(a, 0);
a1cf472001-07-12Martin Stjernholm  }]], ([1: 1, "foo": "foo", 3.14: 3.14]));
4c7c352001-10-15Martin Stjernholm  test_do([[{ object f = class { object o = class {}(); array a = set_weak_flag (({o}), 1); object this = this_object(); void create() {destruct (o);} }(); f = 0; gc(); }]]); test_do([[{ object f = class { object o = class {}(); mapping m = set_weak_flag (([1:o]), 1); object this = this_object(); void create() {destruct (o);} }(); f = 0; gc(); }]]); test_do([[{ object f = class { object o = class {}(); mapping m = set_weak_flag (([o:1]), 1); object this = this_object(); void create() {destruct (o);} }(); f = 0; gc(); }]]); test_do([[{ object f = class { object o = class {}(); multiset m = set_weak_flag ((<o>), 1); object this = this_object(); void create() {destruct (o);} }(); f = 0; gc(); }]]);
5bf37d2000-10-13Fredrik Hübinette (Hubbe) 
007e542003-01-28Marcus Comstedt  test_tests([[inherit "]]SRCDIR[[/test_gc.pike";]])
46d4e72000-06-12Martin Stjernholm  test_any([[mapping q=([ "t":class {} ()]); gc(); if(!objectp(q->t)) return -1; set_weak_flag(q,1); gc(); if(objectp(q->t)) return -2; return 0;]],0); test_do([[class bar { object foo; void create(void|object tmp) { foo=tmp; } }; object o=bar(),o2=o; for(int e=0;e<10000;e++) o=bar(o); o2->foo=o; o=o2=0; gc(); ]])
9da7f42001-06-05Martin Stjernholm  test_any([[ object o = class{}(); mapping m = set_weak_flag (([o: "x"]), Pike.WEAK_INDICES); gc(); return sizeof (m); ]], 1) test_any([[ object o = class{}(); mapping m = set_weak_flag (([o: "x"]), Pike.WEAK_VALUES); gc(); return sizeof (m); ]], 1) test_any([[ object o = class{}(); mapping m = set_weak_flag ((["x": o]), Pike.WEAK_INDICES); gc(); return sizeof (m); ]], 1) test_any([[ object o = class{}(); mapping m = set_weak_flag ((["x": o]), Pike.WEAK_VALUES); gc(); return sizeof (m); ]], 1) test_any([[ mapping m = set_weak_flag (([class{}(): "x"]), Pike.WEAK_INDICES); gc(); return sizeof (m); ]], 0) test_any([[ mapping m = set_weak_flag (([class{}(): "x"]), Pike.WEAK_VALUES); gc(); return sizeof (m); ]], 1) test_any([[ mapping m = set_weak_flag ((["x": class{}()]), Pike.WEAK_INDICES); gc(); return sizeof (m); ]], 1) test_any([[ mapping m = set_weak_flag ((["x": class{}()]), Pike.WEAK_VALUES); gc(); return sizeof (m); ]], 0) test_any([[ object o = class{}(); mapping m = set_weak_flag (([o: o]), Pike.WEAK_INDICES); o = 0; gc(); return sizeof (m); ]], 1) test_any([[ object o = class{}(); mapping m = set_weak_flag (([o: o]), Pike.WEAK_VALUES); o = 0; gc(); return sizeof (m); ]], 1) test_any([[ object o = class{}(); mapping m = set_weak_flag (([o: o]), Pike.WEAK); o = 0; gc(); return sizeof (m); ]], 0) test_any([[ object o = class{}(); mapping m = set_weak_flag (([o: "x"]), Pike.WEAK_INDICES); destruct (o); gc(); return sizeof (m); ]], 0) test_any([[ object o = class{}(); mapping m = set_weak_flag (([o: "x"]), Pike.WEAK_VALUES); destruct (o); gc(); return sizeof (m); ]], 0) test_any([[ object o = class{}(); mapping m = ([o: "x"]); destruct (o); gc(); return sizeof (m); ]], 0) test_any([[ object o = class{}(); mapping m = set_weak_flag ((["x": o]), Pike.WEAK_INDICES); destruct (o); gc(); return sizeof (m); ]], 1) test_any([[ object o = class{}(); mapping m = set_weak_flag ((["x": o]), Pike.WEAK_VALUES); destruct (o); gc(); return sizeof (m); ]], 0) test_any([[ object o = class{}(); mapping m = (["x": o]); destruct (o); gc(); return sizeof (m); ]], 1)
b2764a2001-06-27Martin Stjernholm 
fcb3222001-07-05Martin Stjernholm  test_do([[ mapping m = set_weak_flag (([]), Pike.WEAK_INDICES); object o = class {object o;}(); m[o] = ({1}); o->o = o; o = 0; gc(); ]]) test_do([[ mapping m = set_weak_flag (([]), Pike.WEAK_INDICES); object o = class {object o;}(); m[o] = ({1}); array a = set_weak_flag (({class (object o) {} (o)}), 1); o = 0; gc(); ]])
b2764a2001-06-27Martin Stjernholm  test_any([[ return class { mapping x; int test() { object o = class { mapping a = ([1: this_object()]); void destroy() {x = a;} }(); o = 0; gc(); return x && !x[1]; } }()->test(); ]], 1) test_any([[ return class { multiset x; int test() { object o = class { multiset a = (<this_object()>); void destroy() {x = a;} }(); o = 0; gc();
e813b02001-12-10Martin Stjernholm  return x && !sizeof (indices (x + (<>)));
b2764a2001-06-27Martin Stjernholm  } }()->test(); ]], 1) test_any([[ return class { array x; int test() { object o = class { array a = ({this_object()}); void destroy() {x = a;} }(); o = 0; gc(); return x && !x[0]; } }()->test(); ]], 1) test_any([[ return class { class Obj (object o) {void destroy() {}} Obj x; int test() { object o = class { Obj a = Obj (this_object()); void destroy() {x = a;} }(); o = 0; gc(); return !x; } }()->test(); ]], 1) test_any([[ return class { class Obj (object o) {} Obj x; int test() { object o = class { Obj a = Obj (this_object()); void destroy() {x = a;} }(); o = 0; gc(); return x && !x->o; } }()->test(); ]], 1)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 
f83f0a2008-05-11Martin Stjernholm // Pike.count_memory
6490fb2008-10-12Martin Stjernholm test_do([[ add_constant ("count_memory_stats", lambda (int|mapping opts, mixed... things) { if (intp (opts)) opts = (["lookahead": opts, "collect_stats": 1]); else opts += (["collect_stats": 1]); Pike.count_memory (opts, @things); return sprintf ("i:%d,c:%d,e:%d,v:%d,r:%d,rnd:%d", opts->internal, opts->cyclic, opts->external, opts->visits, opts->revisits, opts->rounds); }) ]])
f83f0a2008-05-11Martin Stjernholm // time(1) is used below to avoid constants with extra refs.
6490fb2008-10-12Martin Stjernholm test_true([[Pike.count_memory (-1) == 0]]) test_true([[Pike.count_memory (-1, ({})) > 0]]) test_true([[Pike.count_memory (-1, ({time(1)})) > 0]]) test_true([[Pike.count_memory (-1, (<>)) > 0]]) test_true([[Pike.count_memory (-1, (<time(1)>)) > Pike.count_memory (-1, (<>))]]) test_true([[Pike.count_memory (-1, (<time(1)>)) > Pike.count_memory (-1, (<1>))]]) test_true([[Pike.count_memory (-1, ([])) > 0]]) test_true([[Pike.count_memory (-1, ([1: time(1)])) > Pike.count_memory (-1, ([]))]]) test_true([[Pike.count_memory (-1, ([1: time(1)])) > Pike.count_memory (-1, ([1: 2]))]]) test_true([[Pike.count_memory (-1, class {}) > 0]]) test_true([[Pike.count_memory (-1, class {float f;}) > Pike.count_memory (-1, class {})]]) test_true([[Pike.count_memory (-1, class {constant f = 0.0;}) > Pike.count_memory (-1, class {})]]) test_true([[Pike.count_memory (-1, class {}()) > 0]]) test_true([[Pike.count_memory (-1, class {float f;}()) > Pike.count_memory (-1, class {}())]]) test_true([[Pike.count_memory (-1, class {constant f = 0.0;}()) == Pike.count_memory (-1, class {}())]]) test_true([[Pike.count_memory (-1, "foo") > 0]]) test_true([[Pike.count_memory (-1, typeof (map)) > 0]]) test_true([[Pike.count_memory (-1, 17) == 0]]) test_true([[Pike.count_memory (-1, ({"some string with no other ref in memory "+ Standards.UUID.make_version4()->str()})) == Pike.count_memory (-1, ({""}))]]) test_true([[Pike.count_memory (0, ({"some string with no other ref in memory " +
42df3a2008-10-04Martin Stjernholm  Standards.UUID.make_version4()->str()})) >
6490fb2008-10-12Martin Stjernholm  Pike.count_memory (0, ({""}))]]) test_true([[Pike.count_memory (-1, ({time(1)})) + Pike.count_memory (-1, ([1: time(1)])) == Pike.count_memory (0, ({([1: time(1)])}))]]) test_true([[Pike.count_memory (0, class X {mapping(X:array(int)) x;}) > Pike.count_memory (0, class Y {int x;})]]) test_true([[Pike.count_memory (0, ({compile (
f83f0a2008-05-11Martin Stjernholm  "constant x = ([1: time(1)]);")})) >
6490fb2008-10-12Martin Stjernholm  Pike.count_memory (0, ({([1: time(1)])}))]]) test_eq([[count_memory_stats (-1, ({time(1)}))]], [["i:1,c:0,e:0,v:1,r:0,rnd:1"]]) test_eq([[count_memory_stats (-1, (<time(1)>))]], [["i:1,c:0,e:0,v:2,r:0,rnd:1"]]) test_eq([[count_memory_stats (-1, ([1: time(1)]))]], [["i:1,c:0,e:0,v:2,r:0,rnd:1"]]) test_eq([[count_memory_stats (-1, class {float f;})]], [["i:1,c:0,e:0,v:1,r:0,rnd:1"]]) test_eq([[count_memory_stats (-1, class {float f;}())]], [["i:1,c:0,e:0,v:1,r:0,rnd:1"]]) test_eq([[count_memory_stats (-1, "foo")]], [["i:1,c:0,e:0,v:1,r:0,rnd:1"]]) test_eq([[count_memory_stats (-1, typeof(all_constants()))]], [["i:1,c:0,e:0,v:1,r:0,rnd:1"]])
f83f0a2008-05-11Martin Stjernholm test_any([[ array a1 = ({({time(1)})}), a2 = ({a1[0]});
6490fb2008-10-12Martin Stjernholm  return Pike.count_memory (0, a1, a2) > Pike.count_memory (0, a1) + Pike.count_memory (0, a2);
f83f0a2008-05-11Martin Stjernholm ]], 1) test_any([[ mapping m = ([1: time(1)]);
6490fb2008-10-12Martin Stjernholm  return Pike.count_memory (0, ({m})) == Pike.count_memory (0, ({0}));
f83f0a2008-05-11Martin Stjernholm ]], 1) test_any([[ array a = ({([1: time(1)])});
6490fb2008-10-12Martin Stjernholm  return Pike.count_memory (0, a) > Pike.count_memory (0, ({([])}));
f83f0a2008-05-11Martin Stjernholm ]], 1) test_any([[ program p = class {};
6490fb2008-10-12Martin Stjernholm  return Pike.count_memory (0, p) > Pike.count_memory (0, p());
f83f0a2008-05-11Martin Stjernholm ]], 1) test_any([[ class X (void|object a) {};
42df3a2008-10-04Martin Stjernholm  X o = X (X());
6490fb2008-10-12Martin Stjernholm  return count_memory_stats (0, o); ]], [["i:2,c:0,e:0,v:2,r:0,rnd:1"]])
f83f0a2008-05-11Martin Stjernholm test_any([[ class X (void|object a) {}; X o = X (X (X()));
6490fb2008-10-12Martin Stjernholm  o->a->a->a = o; return count_memory_stats (0, o); ]], [["i:3,c:0,e:0,v:3,r:0,rnd:1"]])
f83f0a2008-05-11Martin Stjernholm test_any([[ class X (void|object a) {}; X o = X (X (X())); o->a->a->a = o->a;
6490fb2008-10-12Martin Stjernholm  return count_memory_stats (2, o); ]], [["i:3,c:2,e:0,v:7,r:4,rnd:2"]])
f83f0a2008-05-11Martin Stjernholm test_any([[ class X (void|object a) {}; X o = X (X (X())); o->a->a->a = o->a;
6490fb2008-10-12Martin Stjernholm  return count_memory_stats (1, o); ]], [["i:1,c:0,e:1,v:3,r:1,rnd:1"]])
f83f0a2008-05-11Martin Stjernholm test_any([[ class X (void|object a) {}; X o = X (X (X()));
6490fb2008-10-12Martin Stjernholm  int size = Pike.count_memory (0, o); o->a->a->a = o->a; return Pike.count_memory ((["lookahead": 2]), o) == size;
f83f0a2008-05-11Martin Stjernholm ]], 1) test_any([[ class X (void|object a) {}; X o = X (X (X()));
6490fb2008-10-12Martin Stjernholm  return count_memory_stats ((["block_objects": 1]), o); ]], [["i:3,c:0,e:0,v:3,r:0,rnd:1"]])
42df3a2008-10-04Martin Stjernholm test_any([[ class X (void|object a) {}; X o = X (X (X()));
f83f0a2008-05-11Martin Stjernholm  o->a->a->a = o->a;
6490fb2008-10-12Martin Stjernholm  return count_memory_stats ((["lookahead": 2, "block_objects": 1]), o); ]], [["i:1,c:0,e:0,v:1,r:0,rnd:1"]])
f83f0a2008-05-11Martin Stjernholm test_any([[ class X (void|object a) {}; X o = X (X (X())); o->a->a->a = o->a; X r = o->a->a;
6490fb2008-10-12Martin Stjernholm  return count_memory_stats (10, o); ]], [["i:1,c:0,e:2,v:7,r:4,rnd:1"]])
42df3a2008-10-04Martin Stjernholm test_any([[ class X (void|object a) {}; X o = X (X (X())); o->a->a->a = o->a;
6490fb2008-10-12Martin Stjernholm  X r = o->a->a; return count_memory_stats (2, o); ]], [["i:1,c:0,e:2,v:7,r:4,rnd:1"]])
f83f0a2008-05-11Martin Stjernholm test_any([[ class X (void|object a) {}; X o = X (X (X())); o->a->a->a = o->a;
6490fb2008-10-12Martin Stjernholm  X r = o->a; return count_memory_stats (2, o); ]], [["i:1,c:0,e:2,v:5,r:2,rnd:1"]])
42df3a2008-10-04Martin Stjernholm test_any([[ class X (void|object a, void|object b) {}; X o = X (X (X (X (X (X ()))))); o->a->b = o; o->a->a->b = o->a; o->a->a->a->b = o->a->a; o->a->a->a->a->b = o->a->a->a; o->a->a->a->a->a->b = o->a->a->a->a;
6490fb2008-10-12Martin Stjernholm  return count_memory_stats (1, o); ]], [["i:1,c:0,e:1,v:3,r:1,rnd:1"]])
42df3a2008-10-04Martin Stjernholm test_any([[ class X (void|object a, void|object b) {}; X o = X (X (X (X (X (X ()))))); o->a->b = o; o->a->a->b = o->a; o->a->a->a->b = o->a->a; o->a->a->a->a->b = o->a->a->a; o->a->a->a->a->a->b = o->a->a->a->a;
6490fb2008-10-12Martin Stjernholm  return count_memory_stats (2, o); ]], [["i:6,c:5,e:0,v:19,r:13,rnd:2"]])
42df3a2008-10-04Martin Stjernholm test_any([[ class X (void|object a, void|object b) {}; X o = X (X (X (X (X (X ()))))); o->a->b = o; o->a->a->b = o->a; o->a->a->a->b = o->a->a; o->a->a->a->a->b = o->a->a->a; o->a->a->a->a->a->b = o->a->a->a->a; X p = o->a->a->a->a;
6490fb2008-10-12Martin Stjernholm  return count_memory_stats (2, o); ]], [["i:1,c:0,e:5,v:17,r:11,rnd:1"]])
42df3a2008-10-04Martin Stjernholm test_any([[ class X (void|object a, void|object b) {constant pike_cycle_depth = 2;}; X o = X (X (X (X (X (X ()))))); o->a->b = o; o->a->a->b = o->a; o->a->a->a->b = o->a->a; o->a->a->a->a->b = o->a->a->a; o->a->a->a->a->a->b = o->a->a->a->a;
6490fb2008-10-12Martin Stjernholm  return count_memory_stats (0, o); ]], [["i:6,c:5,e:0,v:19,r:13,rnd:2"]])
42df3a2008-10-04Martin Stjernholm test_any([[ class X (void|object a, void|object b) {constant pike_cycle_depth = 1;}; X o = X (X (X (X (X (X ()))))); o->a->b = o; o->a->a->b = o->a; o->a->a->a->b = o->a->a; o->a->a->a->a->b = o->a->a->a; o->a->a->a->a->a->b = o->a->a->a->a;
6490fb2008-10-12Martin Stjernholm  return count_memory_stats (0, o); ]], [["i:1,c:0,e:1,v:3,r:1,rnd:1"]])
42df3a2008-10-04Martin Stjernholm test_any([[ class X (void|object a, void|object b) {constant pike_cycle_depth = 0;}; X o = X (X (X (X (X (X ()))))); o->a->b = o; o->a->a->b = o->a; o->a->a->a->b = o->a->a; o->a->a->a->a->b = o->a->a->a; o->a->a->a->a->a->b = o->a->a->a->a;
6490fb2008-10-12Martin Stjernholm  return count_memory_stats (2, o); ]], [["i:1,c:0,e:0,v:1,r:0,rnd:1"]])
42df3a2008-10-04Martin Stjernholm test_any([[ class X (void|object a, void|object b) {constant pike_cycle_depth = 2;}; X o = X (X (X (X (X (X ()))))); o->a->b = o; o->a->a->b = o->a; o->a->a->a->b = o->a->a; o->a->a->a->a->b = o->a->a->a; o->a->a->a->a->a->b = o->a->a->a->a;
6490fb2008-10-12Martin Stjernholm  return count_memory_stats ((["block_pike_cycle_depth": 1]), o); ]], [["i:1,c:0,e:0,v:1,r:0,rnd:1"]]) test_any([[ class X (void|object a, void|object b) {constant pike_cycle_depth = 4;}; class Y (void|object a) {constant pike_cycle_depth = 0;}; X o = X (X(), X()); o->a->a = o->b; o->b->a = o->a; o->a->b = o->b->b = Y (Y()); return count_memory_stats (0, o); ]], [["i:5,c:2,e:0,v:8,r:3,rnd:2"]]) test_any([[ class X (void|object a, void|object b) {constant pike_cycle_depth = 4;}; class Y (void|object a) {constant pike_cycle_depth = 0;}; X o = X (X(), X()); o->a->a = o->b; o->b->a = o->a; o->a->b = o->b->b = Y (Y()); o->a->b->a->a = o->a->b; return count_memory_stats (0, o); ]], [["i:3,c:2,e:0,v:6,r:3,rnd:2"]])
f83f0a2008-05-11Martin Stjernholm test_any([[ class X (void|object a, void|object b) {}; X o = X (X (X())); o->a->a->a = o->a; X o2 = X(); o->b = o2; o2->a = o->a->a; o2 = 0;
6490fb2008-10-12Martin Stjernholm  return count_memory_stats (2, o); ]], [["i:4,c:2,e:0,v:7,r:3,rnd:2"]])
42df3a2008-10-04Martin Stjernholm test_any([[ class X (void|object a, void|object b) {}; X o = X (X (X())); o->a->a->a = o->a; X o2 = X(); o->b = o2; o2->a = o->a->a;
6490fb2008-10-12Martin Stjernholm  return count_memory_stats (2, o); ]], [["i:1,c:0,e:3,v:9,r:5,rnd:1"]])
f83f0a2008-05-11Martin Stjernholm test_any([[ class X (void|object a, void|object b) {}; X o = X (X(), X()); o->a->b = o->b; o->b->a = o->a; o->a->a = o->b->b = X();
6490fb2008-10-12Martin Stjernholm  return count_memory_stats (2, o); ]], [["i:4,c:3,e:0,v:8,r:4,rnd:2"]])
f83f0a2008-05-11Martin Stjernholm test_any([[ class X (void|object a, void|object b) {}; X o = X (X(), X()); o->a->b = o->b; o->b->a = o->a; X o2 = X (X(), X()); o2->a->b = o2->b; o2->b->a = o2->a; o2->a->a = o2->b->b = X(); o->a->a = o->b->b = o2; o2 = 0;
6490fb2008-10-12Martin Stjernholm  return count_memory_stats (1, o); ]], [["i:7,c:6,e:0,v:15,r:8,rnd:2"]]) test_any([[ class X (void|object a, void|object b) {}; X o = X (X(), X()); o->a->b = o->b; o->b->a = o->a; X o2 = X (X(), X()); o2->a->b = o2->b; o2->b->a = o2->a; o2->a->a = o2->b->b = X(); o->a->a = o->b->b = o2; o2 = o2->b; mapping m = (["lookahead": 1, "collect_stats": 1, "collect_direct_externals": 1]);
f83f0a2008-05-11Martin Stjernholm  Pike.count_memory (m, o);
6490fb2008-10-12Martin Stjernholm  //werror ("%O\n", m); return m->internal == 4 && m->cyclic == 3 && m->external == 3 && equal (m->collect_direct_externals, ({o2}));
f83f0a2008-05-11Martin Stjernholm ]], 1)
42df3a2008-10-04Martin Stjernholm test_any([[ mixed r = ([]), p = r; p->next = ([]); p->next->prev = p; p = p->next; p->next = ([]); p->next->prev = p; p = p->next; p->next = ([]); p->next->prev = p; p = p->next; p->next = ([]); p->next->prev = p; p = p->next; p->next = ([]); p->next->prev = p; p = 0;
6490fb2008-10-12Martin Stjernholm  return count_memory_stats (1, r); ]], [["i:1,c:0,e:1,v:6,r:2,rnd:1"]])
42df3a2008-10-04Martin Stjernholm test_any([[ mixed r = ([]), p = r; p->next = ([]); p->next->prev = p; p = p->next; p->next = ([]); p->next->prev = p; p = p->next; p->next = ([]); p->next->prev = p; p = p->next; p->next = ([]); p->next->prev = p; p = p->next; p->next = ([]); p->next->prev = p; p = 0;
6490fb2008-10-12Martin Stjernholm  return count_memory_stats (2, r); ]], [["i:6,c:5,e:0,v:38,r:26,rnd:2"]])
42df3a2008-10-04Martin Stjernholm test_any([[ mixed r = ([]), p = r; p->next = ([]); p->next->prev = p; p = p->next; p->next = ([]); p->next->prev = p; p = p->next; p->next = ([]); p->next->prev = p; p = p->next; p->next = ([]); p->next->prev = p; p = p->next; p->next = ([]); p->next->prev = p; p = 0;
6490fb2008-10-12Martin Stjernholm  return Pike.count_memory ((["lookahead": 2, "return_count": 1]), r);
42df3a2008-10-04Martin Stjernholm ]], 6)
6490fb2008-10-12Martin Stjernholm test_any([[ class X (void|array|object a, void|array|object b) {}; array a = ({X (X())}); object o = a[0]; o->a->a = o; o->b = ({X (X())}); o = o->b[0]; o->a->a = o; o->b = ({X (X())}); o = o->b[0]; o->a->a = o; o->b = ({X (X())}); o = o->b[0]; o->a->a = o; o->b = ({X (X())}); o = o->b[0]; o->a->a = o; o = 0; return count_memory_stats ((["lookahead": 2, "block_arrays": 1]), a); ]], [["i:15,c:10,e:0,v:35,r:20,rnd:6"]]) test_any([[ class X (void|array|object a, void|array|object b) {}; array a = ({X (X())}); object o = a[0]; o->a->a = o; o->a->b = ({X (X())}); o = o->a->b[0]; o->a->a = o; o->a->b = ({X (X())}); o = o->a->b[0]; o->a->a = o; o->a->b = ({X (X())}); o = o->a->b[0]; o->a->a = o; o->a->b = ({X (X())}); o = o->a->b[0]; o->a->a = o; o = 0; return count_memory_stats ((["lookahead": 2, "block_arrays": 1]), a); ]], [["i:15,c:10,e:0,v:35,r:20,rnd:6"]])
f83f0a2008-05-11Martin Stjernholm test_true([[Pike.count_memory (Int.NATIVE_MAX, ({master()})) ==
6490fb2008-10-12Martin Stjernholm  Pike.count_memory (-1, ({0}))]]) test_any([[
f83f0a2008-05-11Martin Stjernholm  mapping m = (["lookahead": Int.NATIVE_MAX, "block_programs": 0, "collect_stats": 1]); Pike.count_memory (m, master());
6490fb2008-10-12Martin Stjernholm  return m->rounds; ]], 2)
f83f0a2008-05-11Martin Stjernholm cond([[has_value (cpp ("__AUTO_BIGNUM__"), "1")]], [[
6490fb2008-10-12Martin Stjernholm  test_true([[Pike.count_memory (-1, Int.NATIVE_MAX + 1) > Pike.count_memory (-1, 17)]]) test_true([[Pike.count_memory (-1, Int.NATIVE_MAX << 100) > Pike.count_memory (-1, Int.NATIVE_MAX + 1)]])
f83f0a2008-05-11Martin Stjernholm ]])
6490fb2008-10-12Martin Stjernholm test_do([[add_constant("count_memory_stats")]])
f83f0a2008-05-11Martin Stjernholm 
00dbf62003-11-08Martin Stjernholm // Numerical limits. test_true([[Int.NATIVE_MIN <= -2147483648]]) test_true([[Int.NATIVE_MAX >= 2147483647]]) test_true([[Float.DIGITS_10 >= 6]]) test_true([[Float.MIN_10_EXP <= -37]]) test_true([[Float.MAX_10_EXP >= 37]]) test_true([[Float.MIN <= 1e-37]]) test_true([[Float.MAX >= 1e37]]) test_true([[Float.EPSILON <= 1e-5]])
d644c12009-03-15Martin Stjernholm cond_begin([[ sizeof( cpp("__AUTO_BIGNUM__")/"__AUTO_BIGNUM__" ) == 1 ]])
a0bcec1999-10-23Fredrik Noring  // Test the lexer. test_eq("2147483648", [[ (string)0x80000000 ]]) test_eq("2147483649", [[ (string)0x80000001 ]]) test_eq("-2147483648", [[ (string)-0x80000000 ]]) test_eq("-2147483649", [[ (string)-0x80000001 ]]) test_eq("2147483648", [[ (string)-(-0x80000000) ]]) test_eq("2147483649", [[ (string)-(-0x80000001) ]])
f8dd212003-10-10Henrik Grubbström (Grubba)  test_eq("9223372036854775808", [[ (string)0x8000000000000000 ]]) test_eq("9223372036854775809", [[ (string)0x8000000000000001 ]]) test_eq("-9223372036854775808", [[ (string)-0x8000000000000000 ]])
28e5f12003-10-11Henrik Grubbström (Grubba)  test_eq("-9223372036854775809", [[ (string)-0x8000000000000001 ]])
f8dd212003-10-10Henrik Grubbström (Grubba)  test_eq("9223372036854775808", [[ (string)-(-0x8000000000000000) ]]) test_eq("9223372036854775809", [[ (string)-(-0x8000000000000001) ]])
a0bcec1999-10-23Fredrik Noring  test_eq("123456789123456789", [[ (string)123456789123456789 ]]) test_eq("-123456789123456789", [[ (string)-123456789123456789 ]]) test_eq("335812727629498640265", [[ (string)0x123456789123456789 ]]) test_eq("-335812727629498640265", [[ (string)-0x123456789123456789 ]]) test_eq("718046312823", [[ (string)012345671234567 ]]) test_eq("-718046312823", [[ (string)-012345671234567 ]])
5656451999-10-26Fredrik Noring  test_eq("1125899906842624", [[ (string)0b100000000000000000000000000000000000000000000000000 ]]) test_eq("-1125899906842624", [[ (string)-0b100000000000000000000000000000000000000000000000000 ]])
9262082003-02-26Martin Stjernholm  test_eq(500000000 * 10, 5000000000)
f8dd212003-10-10Henrik Grubbström (Grubba)  test_eq(5000000000000000000 * 10, 50000000000000000000)
00dbf62003-11-08Martin Stjernholm  // Numbers that shouldn't be native integers. Has to resort to // strange methods to test this since bignums behave like native // integers in almost every way. test_do([[ _next ((mixed) Int.NATIVE_MAX + 1) ]]) test_do([[ _next ((mixed) Int.NATIVE_MIN - 1) ]])
d644c12009-03-15Martin Stjernholm  cond_end // __AUTO_BIGNUM__
00dbf62003-11-08Martin Stjernholm  // These numbers should be native integers. test_eval_error([[ _next ((mixed) -0x80000000) ]]) test_eval_error([[ _next ((mixed) -0x7fffffff) ]]) test_eval_error([[ _next ((mixed) 0x7fffffff) ]]) test_eval_error([[ _next ((mixed) Int.NATIVE_MAX) ]]) test_eval_error([[ _next ((mixed) Int.NATIVE_MIN) ]])
9ae5912003-10-11Henrik Grubbström (Grubba) 
d644c12009-03-15Martin Stjernholm cond_begin([[ sizeof( cpp("__AUTO_BIGNUM__")/"__AUTO_BIGNUM__" ) == 1 ]])
a0bcec1999-10-23Fredrik Noring  // Test incrementations (FIXME: More cases?). test_eq("2147483648", [[ (string)(class { int f(int x) { x++; return x; } })()->f(0x7fffffff) ]]) test_eq("2147483648", [[ (string)(class { int f(int x) { ++x; return x; } })()->f(0x7fffffff) ]]) test_eq("2147483648", [[ (string)(class { int x=0x7fffffff;int f() { ++x;return x; } })()->f() ]]) test_eq("2147483648", [[ (string)(class { int x=0x7fffffff;int f() { x++;return x; } })()->f() ]]) test_eq("2147483648", [[ (string)(class { int f() { int x=0x7fffffff;++x;return x; } })()->f() ]]) test_eq("2147483648", [[ (string)(class { int f() { int x=0x7fffffff;x++;return x; } })()->f() ]])
f8dd212003-10-10Henrik Grubbström (Grubba)  test_eq("9223372036854775808", [[ (string)(class { int f(int x) { x++; return x; } })()->f(0x7fffffffffffffff) ]]) test_eq("9223372036854775808", [[ (string)(class { int f(int x) { ++x; return x; } })()->f(0x7fffffffffffffff) ]]) test_eq("9223372036854775808", [[ (string)(class { int x=0x7fffffffffffffff;int f() { ++x;return x; } })()->f() ]]) test_eq("9223372036854775808", [[ (string)(class { int x=0x7fffffffffffffff;int f() { x++;return x; } })()->f() ]]) test_eq("9223372036854775808", [[ (string)(class { int f() { int x=0x7fffffffffffffff;++x;return x; } })()->f() ]]) test_eq("9223372036854775808", [[ (string)(class { int f() { int x=0x7fffffffffffffff;x++;return x; } })()->f() ]])
a0bcec1999-10-23Fredrik Noring  // Test decrementations (FIXME: More cases?). test_eq("-2147483649", [[ (string)(class { int f(int x) { x--; return x; } })()->f(-0x80000000) ]]) test_eq("-2147483649", [[ (string)(class { int f(int x) { --x; return x; } })()->f(-0x80000000) ]]) test_eq("-2147483649", [[ (string)(class { int x=-0x80000000;int f() { --x;return x; } })()->f()]]) test_eq("-2147483649", [[ (string)(class { int x=-0x80000000;int f() { x--;return x; } })()->f()]]) test_eq("-2147483649", [[ (string)(class { int f() { int x=-0x80000000;--x;return x; } })()->f()]]) test_eq("-2147483649", [[ (string)(class { int f() { int x=-0x80000000;x--;return x; } })()->f()]])
f8dd212003-10-10Henrik Grubbström (Grubba)  test_eq("-9223372036854775809", [[ (string)(class { int f(int x) { x--; return x; } })()->f(-0x8000000000000000) ]]) test_eq("-9223372036854775809", [[ (string)(class { int f(int x) { --x; return x; } })()->f(-0x8000000000000000) ]]) test_eq("-9223372036854775809", [[ (string)(class { int x=-0x8000000000000000;int f() { --x;return x; } })()->f()]]) test_eq("-9223372036854775809", [[ (string)(class { int x=-0x8000000000000000;int f() { x--;return x; } })()->f()]]) test_eq("-9223372036854775809", [[ (string)(class { int f() { int x=-0x8000000000000000;--x;return x; } })()->f()]]) test_eq("-9223372036854775809", [[ (string)(class { int f() { int x=-0x8000000000000000;x--;return x; } })()->f()]])
52bb181999-10-25Fredrik Hübinette (Hubbe)  test_encode(1<<99);
a0bcec1999-10-23Fredrik Noring 
95fc7d1999-10-24Fredrik Noring  // - Left shift.
a0bcec1999-10-23Fredrik Noring  test_eq("1073741824", [[ (string)(1<<30) ]]) test_eq("2147483648", [[ (string)(1<<31) ]]) test_eq("4294967296", [[ (string)(1<<32) ]]) test_eq("8589934592", [[ (string)(1<<33) ]]) test_eq("1267650600228229401496703205376", [[ (string)(1<<100) ]])
2c16212003-03-30Henrik Grubbström (Grubba)  test_eval_error(return 1<<100000000000000000000) test_eval_error(return (-1)<<100000000000000000000) test_eq(0<<100000000000000000000, 0) test_eval_error(return 100000000000000000000<<100000000000000000000) test_eval_error(return (-100000000000000000000)<<100000000000000000000)
126bf22002-10-15Marcus Comstedt 
95fc7d1999-10-24Fredrik Noring  // - Right shift.
a0bcec1999-10-23Fredrik Noring  test_eq("53265209898187398182", [[ (string)((int)"54543574935743895738479">>10) ]]) test_false([[ objectp((int)"54543574935743895738479">>60) ]]) test_eq(0, [[ 25>>30 ]]) test_eq(0, [[ 25>>31 ]]) test_eq(0, [[ 25>>32 ]]) test_eq(0, [[ 25>>33 ]])
2c16212003-03-30Henrik Grubbström (Grubba)  test_eq(1>>100000000000000000000, 0) test_eq(-1>>100000000000000000000, -1) test_eq(0>>100000000000000000000, 0) test_eq(100000000000000000000>>100000000000000000000, 0) test_eq((-100000000000000000000)>>100000000000000000000, -1)
126bf22002-10-15Marcus Comstedt 
95fc7d1999-10-24Fredrik Noring  // - abs.
a0bcec1999-10-23Fredrik Noring  test_eq("2147483648", [[ (string)abs(-0x80000000) ]]) test_eq("2147483648", [[ (string)abs(0x80000000) ]]) test_eq("2147483649", [[ (string)abs(0x80000001) ]]) test_eq("2147483649", [[ (string)abs(-0x80000001) ]])
f8dd212003-10-10Henrik Grubbström (Grubba)  test_eq("9223372036854775808", [[ (string)abs(-0x8000000000000000) ]]) test_eq("9223372036854775808", [[ (string)abs(0x8000000000000000) ]]) test_eq("9223372036854775809", [[ (string)abs(0x8000000000000001) ]]) test_eq("9223372036854775809", [[ (string)abs(-0x8000000000000001) ]])
a0bcec1999-10-23Fredrik Noring 
95fc7d1999-10-24Fredrik Noring  // - Add.
a0bcec1999-10-23Fredrik Noring  test_eq("2147483648", [[ (string)(0x7fffffff + 1) ]]) test_eq("2147483649", [[ (string)(0x7fffffff + 2) ]])
f8dd212003-10-10Henrik Grubbström (Grubba)  test_eq("-2147483648", [[ (string)((-0x80000001) + 1) ]]) test_eq("9223372036854775808", [[ (string)(0x7fffffffffffffff + 1) ]])
28e5f12003-10-11Henrik Grubbström (Grubba)  test_eq("9223372036854775809", [[ (string)(0x7fffffffffffffff + 2) ]])
f8dd212003-10-10Henrik Grubbström (Grubba)  test_eq("-9223372036854775808", [[ (string)((-0x8000000000000001) + 1) ]])
a0bcec1999-10-23Fredrik Noring  test_eq("2684354560", [[ (string)(0x50000000 + 0x50000000) ]]) test_eq("-2684354560", [[ (string)((-0x50000000) + (-0x50000000)) ]])
b72e6d1999-10-24Henrik Grubbström (Grubba)  test_false([[ objectp((-0x80000001) + 1) ]])
a0bcec1999-10-23Fredrik Noring 
cb5d8e1999-10-31Henrik Grubbström (Grubba)  // - Add-eq.
a105d71999-10-31Henrik Grubbström (Grubba)  test_eq([[lambda() { int a=0x100000000; int b = a; a += 1; return b+a; }()]], [[0x200000001]])
cb5d8e1999-10-31Henrik Grubbström (Grubba) 
95fc7d1999-10-24Fredrik Noring  // - Sub.
a0bcec1999-10-23Fredrik Noring  test_eq("-2147483648", [[ (string)(-0x7fffffff - 1) ]]) test_eq("-2147483649", [[ (string)(-0x80000000 - 1) ]])
b72e6d1999-10-24Henrik Grubbström (Grubba)  test_eq("2147483647", [[ (string)(0x80000000 - 1) ]])
9ae5912003-10-11Henrik Grubbström (Grubba)  test_eq("-9223372036854775808", [[ (string)(-0x7fffffffffffffff - 1) ]]) test_eq("-9223372036854775809", [[ (string)(-0x8000000000000000 - 1) ]]) test_eq("9223372036854775807", [[ (string)(0x8000000000000000 - 1) ]])
b72e6d1999-10-24Henrik Grubbström (Grubba)  test_false([[ objectp(0x80000000 - 1) ]])
a0bcec1999-10-23Fredrik Noring 
95fc7d1999-10-24Fredrik Noring  // - Multiplication.
a0bcec1999-10-23Fredrik Noring  test_eq("6442450941", [[ (string)(0x7fffffff * 3) ]]) test_eq("-6442450941", [[ (string)(0x7fffffff * -3) ]])
0c09a71999-10-30Fredrik Hübinette (Hubbe)  test_eq(-2147483648*-1,2147483648)
9ae5912003-10-11Henrik Grubbström (Grubba)  test_eq(-9223372036854775808*-1,9223372036854775808)
a0bcec1999-10-23Fredrik Noring  // Division. test_eq("1073741824", [[ (string)((int)"2147483648" / 2) ]]) test_false([[ objectp((int)"2147483648" / 2) ]])
aa5ef31999-10-23Fredrik Noring  test_eq("13934998268672547360069539025", [[ (string)(48324683476346278246238462784624627348 / 3467864333) ]])
a0bcec1999-10-23Fredrik Noring 
4619f12003-09-09Martin Stjernholm  // sprintf (and the describe stuff in the master) test_do([[sprintf ("%O", 10->pow);]])
02aa911999-11-06Fredrik Hübinette (Hubbe) 
95fc7d1999-10-24Fredrik Noring  // - sscanf.
a0bcec1999-10-23Fredrik Noring  test_eq("12345678901234567890", [[ (string)array_sscanf("12345678901234567890", "%d")[0] ]]) test_eq("1375488932614371410344080", [[ (string)array_sscanf("123456789F01234567890", "%x")[0] ]])
f218802001-06-05Fredrik Hübinette (Hubbe)  test_eq("1375488932614371410344080", [[ (string)array_sscanf("0x123456789F01234567890", "%x")[0] ]]) test_eq("1375488932614371410344080", [[ (string)array_sscanf("0X123456789F01234567890", "%x")[0] ]])
a0bcec1999-10-23Fredrik Noring  test_eq("1375488932614371410344080", [[ (string)array_sscanf("0x123456789F01234567890", "%i")[0] ]])
f218802001-06-05Fredrik Hübinette (Hubbe)  test_eq("1375488932614371410344080", [[ (string)array_sscanf("0X123456789F01234567890", "%i")[0] ]])
a0bcec1999-10-23Fredrik Noring  test_eq("45954944846776", [[ (string)array_sscanf("1234567012345670", "%o")[0] ]]) test_eq("45954944846776", [[ (string)array_sscanf("01234567012345670", "%i")[0] ]])
5656451999-10-26Fredrik Noring  test_eq("11", [[ (string)array_sscanf("1011", "%b")[0] ]]) test_eq("1125968643114208", [[ (string)array_sscanf("100000000000001000000000001000000000100010011100000", "%b")[0] ]]) test_eq("11", [[ (string)array_sscanf("0b1011", "%i")[0] ]]) test_eq("1125968643114208", [[ (string)array_sscanf("0b100000000000001000000000001000000000100010011100000", "%i")[0] ]])
a0bcec1999-10-23Fredrik Noring  test_eq("-12345678901234567890", [[ (string)array_sscanf("-12345678901234567890", "%d")[0] ]]) test_eq("-1375488932614371410344080", [[ (string)array_sscanf("-123456789F01234567890", "%x")[0] ]]) test_eq("-1375488932614371410344080", [[ (string)array_sscanf("-0x123456789F01234567890","%i")[0] ]]) test_eq("-45954944846776", [[ (string)array_sscanf("-1234567012345670", "%o")[0] ]]) test_eq("-45954944846776", [[ (string)array_sscanf("-01234567012345670", "%i")[0] ]])
5656451999-10-26Fredrik Noring  test_eq("-11", [[ (string)array_sscanf("-1011", "%b")[0] ]]) test_eq("-1125968643114208", [[ (string)array_sscanf("-100000000000001000000000001000000000100010011100000", "%b")[0] ]]) test_eq("-11", [[ (string)array_sscanf("-0b1011", "%i")[0] ]]) test_eq("-1125968643114208", [[ (string)array_sscanf("-0b100000000000001000000000001000000000100010011100000", "%i")[0] ]])
6ee24a1999-10-24Fredrik Noring 
eccd0a1999-10-29Fredrik Noring  test_eq([[ sprintf("%x", @array_sscanf("\0\0\0\0\1\2\3\4", "%4c")) ]], "0") test_eq([[ sprintf("%x", @array_sscanf("\0\0\0\0\1\2\3\4", "%8c")) ]], "1020304") test_eq([[ sprintf("%08x", @array_sscanf("\0\0\0\0\1\2\3\4", "%8c")) ]], "01020304") test_eq([[ sprintf("%08x", @array_sscanf("\0\0\0\5\1\2\3\4", "%8c")) ]], "501020304") test_eq([[ sprintf("%08x", @array_sscanf("\0\0\6\5\1\2\3\4", "%8c")) ]], "60501020304") test_eq([[ sprintf("%08x", @array_sscanf("\0\7\6\5\1\2\3\4", "%8c")) ]], "7060501020304") test_eq([[ sprintf("%08x", @array_sscanf("\8\7\6\5\1\2\3\4", "%8c")) ]], "3807060501020304") test_eq([[ sprintf("%08x", @array_sscanf("\010\7\6\5\1\2\3\4", "%8c")) ]], "807060501020304")
f218802001-06-05Fredrik Hübinette (Hubbe)  test_equal([[ ({ 118 }) ]], [[ array_sscanf("0x76", "%x") ]]) test_equal([[ ({42 }) ]], [[ array_sscanf("101010", "%b") ]]) test_equal([[ ({42 }) ]], [[ array_sscanf("0b101010", "%b") ]]) test_equal([[ ({42 }) ]], [[ array_sscanf("0B101010", "%b") ]]) test_equal([[ ({ 557239244978618154304871 }) ]], [[ array_sscanf("0x76000000000001234567", "%x") ]])
5656451999-10-26Fredrik Noring 
58d1d22001-05-14Fredrik Hübinette (Hubbe)  test_equal([[array_sscanf("foo \12345 bar <fie>","%[^<]")]], [[ ({"foo \12345 bar " }) ]])
5656451999-10-26Fredrik Noring  test_equal(471100000000000000000000000000000000000000000000042, (int)(mixed)471100000000000000000000000000000000000000000000042)
0d1f2a1999-10-26Fredrik Noring  test_eq(6745697846498645967, [[ Gmp.mpz("6745697846498645967")->cast_to_int(); ]])
a0bcec1999-10-23Fredrik Noring 
95fc7d1999-10-24Fredrik Noring  test_eq(0x7fffffff, [[ decode_value(encode_value(0x7fffffff)) ]]) test_eq(0x7ffffffff, [[ decode_value(encode_value(0x7ffffffff)) ]]) test_eq(0x7fffffffff, [[ decode_value(encode_value(0x7fffffffff)) ]]) test_eq(0x7ffffffffff, [[ decode_value(encode_value(0x7ffffffffff)) ]]) test_eq(0x7fffffffffff, [[ decode_value(encode_value(0x7fffffffffff)) ]]) test_eq(0x7ffffffffffff, [[ decode_value(encode_value(0x7ffffffffffff)) ]]) test_eq(0x80000000, [[ decode_value(encode_value(0x80000000)) ]]) test_eq(0x800000000, [[ decode_value(encode_value(0x800000000)) ]]) test_eq(0x8000000000, [[ decode_value(encode_value(0x8000000000)) ]]) test_eq(0x80000000000, [[ decode_value(encode_value(0x80000000000)) ]]) test_eq(0x800000000000, [[ decode_value(encode_value(0x800000000000)) ]]) test_eq(0x8000000000000, [[ decode_value(encode_value(0x8000000000000)) ]]) test_eq(0x12345678, [[ decode_value(encode_value(0x12345678)) ]]) test_eq(0x123456780, [[ decode_value(encode_value(0x123456780)) ]]) test_eq(0x1234567801, [[ decode_value(encode_value(0x1234567801)) ]]) test_eq(0x12345678012, [[ decode_value(encode_value(0x12345678012)) ]]) test_eq(0x123456780123, [[ decode_value(encode_value(0x123456780123)) ]]) test_eq(0x1234567801234, [[ decode_value(encode_value(0x1234567801234)) ]]) test_eq(-0x7fffffff, [[ decode_value(encode_value(-0x7fffffff)) ]]) test_eq(-0x7ffffffff, [[ decode_value(encode_value(-0x7ffffffff)) ]]) test_eq(-0x7fffffffff, [[ decode_value(encode_value(-0x7fffffffff)) ]]) test_eq(-0x7ffffffffff, [[ decode_value(encode_value(-0x7ffffffffff)) ]]) test_eq(-0x7fffffffffff, [[ decode_value(encode_value(-0x7fffffffffff)) ]]) test_eq(-0x7ffffffffffff, [[ decode_value(encode_value(-0x7ffffffffffff))]]) test_eq(-0x80000000, [[ decode_value(encode_value(-0x80000000)) ]]) test_eq(-0x800000000, [[ decode_value(encode_value(-0x800000000)) ]]) test_eq(-0x8000000000, [[ decode_value(encode_value(-0x8000000000)) ]]) test_eq(-0x80000000000, [[ decode_value(encode_value(-0x80000000000)) ]]) test_eq(-0x800000000000, [[ decode_value(encode_value(-0x800000000000)) ]]) test_eq(-0x8000000000000, [[ decode_value(encode_value(-0x8000000000000))]]) test_eq(-0x12345678, [[ decode_value(encode_value(-0x12345678)) ]]) test_eq(-0x123456780, [[ decode_value(encode_value(-0x123456780)) ]]) test_eq(-0x1234567801, [[ decode_value(encode_value(-0x1234567801)) ]]) test_eq(-0x12345678012, [[ decode_value(encode_value(-0x12345678012)) ]]) test_eq(-0x123456780123, [[ decode_value(encode_value(-0x123456780123)) ]]) test_eq(-0x1234567801234, [[ decode_value(encode_value(-0x1234567801234))]])
09f3c42003-11-15Martin Stjernholm  test_eval_error([[ _next ((mixed) decode_value (encode_value (Int.NATIVE_MAX))) ]]) test_eval_error([[ _next ((mixed) decode_value (encode_value (Int.NATIVE_MIN))) ]]) test_do([[ _next ((mixed) decode_value (encode_value (Int.NATIVE_MAX + 1))) ]]) test_do([[ _next ((mixed) decode_value (encode_value (Int.NATIVE_MIN - 1))) ]])
08b9801999-10-30Fredrik Noring  test_eq(2147483648, -2147483648/-1) test_eq(2147483648, -2147483648*-1)
95fc7d1999-10-24Fredrik Noring  test_true([[ random(0x7fffffff)+1 ]]) test_true([[ random(0x7ffffffff)+1 ]]) test_true([[ sqrt(0x7fffffff)+1 ]]) test_true([[ sqrt(0x7ffffffff)+1 ]])
a1e8a91999-10-29Fredrik Noring  test_true([[ catch { destruct((mixed)0x4783647824687234628462); } ]])
2db2421999-10-29Martin Stjernholm  test_any_equal([[ array a = ({4711, 0x54325827a124*0x12348795482485425}); set_weak_flag (a, 1); gc();
d3ade92003-02-19Henrik Grubbström (Grubba)  return set_weak_flag(a, 0);
2db2421999-10-29Martin Stjernholm  ]], [[ ({4711, 0x54325827a124*0x12348795482485425}) ]]) test_any_equal([[ mapping m = ([ 4711: 0x54325827a124*0x12348795482485425, 0x54325827124*0x1234879548a2485425: 1174, ]); set_weak_flag (m, 1); gc();
d3ade92003-02-19Henrik Grubbström (Grubba)  return set_weak_flag(m, 0);
2db2421999-10-29Martin Stjernholm  ]], [[ ([ 4711: 0x54325827a124*0x12348795482485425, 0x54325827124*0x1234879548a2485425: 1174, ]) ]])
95fc7d1999-10-24Fredrik Noring 
6229531999-11-01Mirar (Pontus Hagland)  test_any([[int a=2147483648; a=a+17; return a]], 2147483665) test_any([[int a=2147483648; a=a-17; return a]], 2147483631) test_any([[int a=2147483648; a=a*17; return a]], 36507222016) test_any([[int a=2147483648; a=a/17; return a]], 126322567) test_any([[int a=2147483648; a=a%17; return a]], 9) test_any([[int a=2147483648; a=a^17; return a]], 2147483665) test_any([[int a=2147483648; a=a&17; return a]], 0) test_any([[int a=2147483648; a=a|17; return a]], 2147483665) test_any([[int a=2147483648; a=a<<17; return a]], 281474976710656) test_any([[int a=2147483648; a=a>>17; return a]], 16384) test_eq([[2147483648+17 ]], 2147483665) test_eq([[2147483648-17 ]], 2147483631) test_eq([[2147483648*17 ]], 36507222016) test_eq([[2147483648/17 ]], 126322567) test_eq([[2147483648%17 ]], 9) test_eq([[2147483648^17 ]], 2147483665) test_eq([[2147483648&17 ]], 0) test_eq([[2147483648|17 ]], 2147483665) test_eq([[2147483648<<17]], 281474976710656) test_eq([[2147483648>>17]], 16384)
49c2db1999-12-08Fredrik Noring  test_true([[ floatp((1<<99)/3.14) ]]); test_true([[ floatp((1<<99)*3.14) ]]); test_true([[ floatp((1<<99)-3.14) ]]); test_true([[ floatp((1<<99)+3.14) ]]);
6229531999-11-01Mirar (Pontus Hagland) 
2dc4c72004-02-17Mirar (Pontus Hagland)  test_eq([[(12)+(3)]],0xf); test_eq([[(12)+(3*(1<<32))]],0x30000000c); test_eq([[(12)+(3*(1<<64))]],0x3000000000000000c); test_eq([[(12)+(3*(1<<128))]],0x30000000000000000000000000000000c); test_eq([[(12*(1<<32))+(3)]],0xc00000003); test_eq([[(12*(1<<32))+(3*(1<<32))]],0xf00000000); test_eq([[(12*(1<<32))+(3*(1<<64))]],0x30000000c00000000); test_eq([[(12*(1<<32))+(3*(1<<128))]],0x300000000000000000000000c00000000); test_eq([[(12*(1<<64))+(3)]],0xc0000000000000003); test_eq([[(12*(1<<64))+(3*(1<<32))]],0xc0000000300000000); test_eq([[(12*(1<<64))+(3*(1<<64))]],0xf0000000000000000); test_eq([[(12*(1<<64))+(3*(1<<128))]],0x3000000000000000c0000000000000000); test_eq([[(12*(1<<128))+(3)]],0xc00000000000000000000000000000003); test_eq([[(12*(1<<128))+(3*(1<<32))]],0xc00000000000000000000000300000000); test_eq([[(12*(1<<128))+(3*(1<<64))]],0xc00000000000000030000000000000000); test_eq([[(12*(1<<128))+(3*(1<<128))]],0xf00000000000000000000000000000000); test_eq([[(12)-(3)]],0x9); test_eq([[(12)-(3*(1<<32))]],-0x2fffffff4); test_eq([[(12)-(3*(1<<64))]],-0x2fffffffffffffff4); test_eq([[(12)-(3*(1<<128))]],-0x2fffffffffffffffffffffffffffffff4); test_eq([[(12*(1<<32))-(3)]],0xbfffffffd); test_eq([[(12*(1<<32))-(3*(1<<32))]],0x900000000); test_eq([[(12*(1<<32))-(3*(1<<64))]],-0x2fffffff400000000); test_eq([[(12*(1<<32))-(3*(1<<128))]],-0x2fffffffffffffffffffffff400000000); test_eq([[(12*(1<<64))-(3)]],0xbfffffffffffffffd); test_eq([[(12*(1<<64))-(3*(1<<32))]],0xbfffffffd00000000); test_eq([[(12*(1<<64))-(3*(1<<64))]],0x90000000000000000); test_eq([[(12*(1<<64))-(3*(1<<128))]],-0x2fffffffffffffff40000000000000000); test_eq([[(12*(1<<128))-(3)]],0xbfffffffffffffffffffffffffffffffd); test_eq([[(12*(1<<128))-(3*(1<<32))]],0xbfffffffffffffffffffffffd00000000); test_eq([[(12*(1<<128))-(3*(1<<64))]],0xbfffffffffffffffd0000000000000000); test_eq([[(12*(1<<128))-(3*(1<<128))]],0x900000000000000000000000000000000); test_eq([[(12)*(3)]],0x24); test_eq([[(12)*(3*(1<<32))]],0x2400000000); test_eq([[(12)*(3*(1<<64))]],0x240000000000000000); test_eq([[(12)*(3*(1<<128))]],0x2400000000000000000000000000000000); test_eq([[(12*(1<<32))*(3)]],0x2400000000); test_eq([[(12*(1<<32))*(3*(1<<32))]],0x240000000000000000); test_eq([[(12*(1<<32))*(3*(1<<64))]],0x24000000000000000000000000); test_eq([[(12*(1<<32))*(3*(1<<128))]],0x240000000000000000000000000000000000000000); test_eq([[(12*(1<<64))*(3)]],0x240000000000000000); test_eq([[(12*(1<<64))*(3*(1<<32))]],0x24000000000000000000000000); test_eq([[(12*(1<<64))*(3*(1<<64))]],0x2400000000000000000000000000000000); test_eq([[(12*(1<<64))*(3*(1<<128))]],0x24000000000000000000000000000000000000000000000000); test_eq([[(12*(1<<128))*(3)]],0x2400000000000000000000000000000000); test_eq([[(12*(1<<128))*(3*(1<<32))]],0x240000000000000000000000000000000000000000); test_eq([[(12*(1<<128))*(3*(1<<64))]],0x24000000000000000000000000000000000000000000000000); test_eq([[(12*(1<<128))*(3*(1<<128))]],0x240000000000000000000000000000000000000000000000000000000000000000); test_eq([[(12)/(3)]],0x4); test_eq([[(12)/(3*(1<<32))]],0x0); test_eq([[(12)/(3*(1<<64))]],0x0); test_eq([[(12)/(3*(1<<128))]],0x0); test_eq([[(12*(1<<32))/(3*(1<<32))]],0x4); test_eq([[(12*(1<<32))/(3*(1<<64))]],0x0); test_eq([[(12*(1<<32))/(3*(1<<128))]],0x0); test_eq([[(12*(1<<64))/(3*(1<<64))]],0x4); test_eq([[(12*(1<<64))/(3*(1<<128))]],0x0); test_eq([[(12*(1<<128))/(3*(1<<128))]],0x4); test_eq([[(17+12)%(3)]],0x2); test_eq([[(17+12)%(3*(1<<32))]],0x1d); test_eq([[(17+12)%(3*(1<<64))]],0x1d); test_eq([[(17+12)%(3*(1<<128))]],0x1d); test_eq([[(17+12*(1<<32))%(3*(1<<32))]],0x11); test_eq([[(17+12*(1<<32))%(3*(1<<64))]],0xc00000011); test_eq([[(17+12*(1<<32))%(3*(1<<128))]],0xc00000011); test_eq([[(17+12*(1<<64))%(3*(1<<64))]],0x11); test_eq([[(17+12*(1<<64))%(3*(1<<128))]],0xc0000000000000011); test_eq([[(17+12*(1<<128))%(3*(1<<128))]],0x11); cond( [[ master()->resolv("Gmp")->mpz ]], [[
4fcc7a2004-03-12Henrik Grubbström (Grubba)  test_eq([[Gmp.mpz(68719476736)/Gmp.mpz(12884901888)]],5); test_eq([[Gmp.mpz(123456789012345678901234567890)/Gmp.mpz(12884901888)]], Gmp.mpz(9581507883061474724)); test_eq([[Gmp.mpz(123456789012345678901234567890)/ Gmp.mpz(67890123456789012345)]],1818479371); test_eq([[Gmp.mpz(123456789012345678901234567890)/ Gmp.mpz(67890123456789)]],Gmp.mpz(1818479371169857));
2dc4c72004-02-17Mirar (Pontus Hagland)  ]] )
9c8ca02000-11-05Mirar (Pontus Hagland)  test_any([[int a=10->pow(30); int b=1000000000000000000000000000000; return ([a:1])[b]]],1); test_any([[int a=10->pow(30); int b=1000000000000000000000000000000; return (<a>)[b]]],1); test_any([[int a=10->pow(30); int b=1000000000000000000000000000000; return sizeof( ({a})-({b}) )]],0); test_any([[int a=10->pow(30); int b=1000000000000000000000000000000; return sizeof( ({a})&({b}) )]],1); test_any([[int k=10->pow(30); array a=({k+17,k+16,k+13,k+14,k+12,k,k+9}); return sort(a)[0]==k && sort(a)[-1]==k+17]],1)
997b732001-09-10Fredrik Hübinette (Hubbe)  test_do([[ // This is a memleak test rm("testsuite_test.pike"); Stdio.write_file("testsuite_test.pike", "constant Q=10000000000000000;\n" "int main() {}\n"); Process.system(RUNPIKE +" testsuite_test.pike"); rm("testsuite_test.pike"); ]])
9c8ca02000-11-05Mirar (Pontus Hagland) // test the corresponding integer operations first test_any([[int k=100; int j=k+1; array a=({k+17,k+16,k+13,k+14,k+12,k,k+9}); array b=({j+16,j+15,j+12,j+13,j+11,j-1,j+8}); return sizeof( a&b )]],7); test_any([[int k=100; int j=k+1; array a=({k+17,k+16,k+13,k+14,k+12,k,k+9}); array b=({j+13,j+11,j-1,j+8,j+16,j+15,j+12}); return sizeof( a-b )]],0); // now the bignum ones test_any([[int k=10->pow(30); int j=k+1; array a=({k+17,k+16,k+13,k+14,k+12,k,k+9}); array b=({j+16,j+15,j+12,j+13,j+11,j-1,j+8}); return sizeof( a&b )]],7); test_any([[int k=10->pow(30); int j=k+1; array a=({k+17,k+16,k+13,k+14,k+12,k,k+9}); array b=({j+13,j+11,j-1,j+8,j+16,j+15,j+12}); return sizeof( a-b )]],0);
d644c12009-03-15Martin Stjernholm cond_end // __AUTO_BIGNUM__
9c8ca02000-11-05Mirar (Pontus Hagland) 
694bb11998-04-23Fredrik Hübinette (Hubbe) cond([[all_constants()->_verify_internals]],
c0988f1998-04-17Fredrik Hübinette (Hubbe) [[ test_do(_verify_internals()) ]])
e5bb7d1996-09-23Fredrik Hübinette (Hubbe)  test_eq("\377"[0],255)
2aeef52002-11-26Martin Nilsson test_do(add_constant("foo",class c {int i;}()))
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) test_eq(foo->i,0) test_do(foo->i=17) test_eq(foo->i,17)
2de3791997-02-11Fredrik Hübinette (Hubbe) test_do(add_constant("foo"));
2aeef52002-11-26Martin Nilsson test_do(add_constant("foo",class c {array(int) i=({0});}()))
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) test_eq(foo->i[0],0) test_do(foo->i[0]=17) test_eq(foo->i[0],17)
2de3791997-02-11Fredrik Hübinette (Hubbe) test_do(add_constant("foo"));
e5bb7d1996-09-23Fredrik Hübinette (Hubbe)  // signum, signame
e42eaf1998-01-02Fredrik Hübinette (Hubbe) test_true(intp(signum("SIGKILL")))
e5bb7d1996-09-23Fredrik Hübinette (Hubbe)  // kill, signal, getpid test_true(intp(getpid()))
5001c31998-02-28Fredrik Hübinette (Hubbe) cond([[all_constants()->kill && (cpp("__NT__")/"\n")[1]=="__NT__" ]],
e42eaf1998-01-02Fredrik Hübinette (Hubbe) [[ 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"))
4e78701999-11-24Henrik Grubbström (Grubba)  test_do(signal(signum("SIGFPE"), 0))
e42eaf1998-01-02Fredrik Hübinette (Hubbe)  test_do(signal(signum("SIGFPE"))) ]])
e5bb7d1996-09-23Fredrik Hübinette (Hubbe)  // typeof
4405922000-05-25Henrik Grubbström (Grubba) test_eq(sprintf("%O", typeof(1)),"int(1..1)")
71a4bf2007-05-03Henrik Grubbström (Grubba) test_eq(sprintf("%O", typeof("")),"string(zero)")
b0b5be2007-05-03Henrik Grubbström (Grubba) test_any([[ // Suppress warnings. class handler { void compile_warning (string file, int line, string err) {}; }; return compile_string("string s = sprintf(\"%O\", typeof(\"\"[0]));", "-", handler())()->s; ]], "zero")
4405922000-05-25Henrik Grubbström (Grubba) test_eq(sprintf("%O", typeof(0.0)),"float") test_eq(sprintf("%O", typeof(all_constants()["all_constants"])),"mixed")
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 
4fbfe21998-12-21Fredrik Hübinette (Hubbe) // _typeof
4405922000-05-25Henrik Grubbström (Grubba) test_eq(sprintf("%O", _typeof(1)),"int(1..1)")
71a4bf2007-05-03Henrik Grubbström (Grubba) test_eq(sprintf("%O", _typeof("")),"string(zero)")
4405922000-05-25Henrik Grubbström (Grubba) test_eq(sprintf("%O", _typeof("x"[0])),"int(120..120)") test_eq(sprintf("%O", _typeof(0.0)),"float")
b584212002-05-11Martin Stjernholm test_eq([[sscanf(sprintf("%Ox", _typeof(this_object))-" ",
780c2b2007-05-09Henrik Grubbström (Grubba)  "function(void|int(0..%*[0-9]):object)%*c")]], 2)
4fbfe21998-12-21Fredrik Hübinette (Hubbe) 
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // class
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) test_true(programp(class c {}))
2aeef52002-11-26Martin Nilsson test_true(functionp(class c { int foo() { return 1; }}()->foo)) test_true(class c { int foo() { return 1; }}()->foo()) test_true(class c { int i=1; }()->i) test_false(class c { int foo() { return 1; }}()->bar) test_eq(class c { program foo=class c { int i=20; }; }()->foo()->i,20)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 
31fb1d2000-07-10Henrik Grubbström (Grubba) // class() test_true(programp(class c(){}))
35f51c2008-06-28Martin Nilsson test_equal(indices(class c(string a,protected int b){}("foo",0)), ({"a"})) test_equal(values(class c(string a,protected int b){}("foo",0)), ({"foo"}))
fde2442001-03-31Henrik Grubbström (Grubba) test_true(programp(class c(string ... a){}))
35f51c2008-06-28Martin Nilsson test_equal(indices(class c(string a,protected int ... b){}("foo",0)), ({"a"})) test_equal(values(class c(protected string a, int ... b){}("foo",0)), ({({0})}))
31fb1d2000-07-10Henrik Grubbström (Grubba) 
f8b6ba2001-11-28Martin Stjernholm test_do([[ class A (int i) {}; class B (int i, int j) {inherit A;}; class C {inherit B;}; C (1,1); ]])
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // type checks test_compile_error([[} int foo() { return]]); test_compile_error([[} void foo() { return 1]]);
62cda41999-11-23Martin Stjernholm test_compile([[mapping a; int b; a = b = 0;]]); test_compile_error([[mapping a; int b; a = b = 1;]]);
327c051999-11-24Fredrik Hübinette (Hubbe) test_compile_any([[void a(int q){} void b(function(int:void) f){} void c(){b(a);}]]);
6b3f5c2002-04-11Martin Nilsson test_compile_error_any([[void a(int i){} void b(function(:void) f){} void c(){b(a);}]]);
653c361999-11-24Martin Stjernholm test_compile_any([[void a(){} function(int:void) b = a;]]);
6b3f5c2002-04-11Martin Nilsson test_compile_error_any([[void a(int i){} function(:void) b = a;]]);
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 
1edce92000-11-04Martin Stjernholm // Duplicate local variable test_compile_error([[void f() {int i; int i;}]]); test_compile_error([[void f() {int i; mapping i;}]]); test_compile_error([[void f() {int i; void i() {};}]]); test_compile_error([[void f (int i) {string i;}]]);
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // Not yet cataloged
7991f12008-01-05Henrik Grubbström (Grubba) test_any(int i=10; { int i=0; } return i, 10)
5639732001-07-04Henrik Grubbström (Grubba) 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;]])
e5bb7d1996-09-23Fredrik Hübinette (Hubbe)  test_do(lambda(){return;}()) test_equal( ({ lambda() { return 3; } , lambda() { return 7; }, lambda() { return 9; } })(), ({ 3,7,9 }))
3488ef2000-04-17Henrik Grubbström (Grubba) test_any(array(int) a=({10}); a[0]++; return a[0], 11)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 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"]))
2de3791997-02-11Fredrik Hübinette (Hubbe) 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"]))
e5bb7d1996-09-23Fredrik Hübinette (Hubbe)  test_true(predef::stringp("")) test_equal([["a,b,4,7,8s,asfd,a,d,f" / ","]],[["a,b,4,7,8s,asfd,a,d,f" / ","]])
3488ef2000-04-17Henrik Grubbström (Grubba) test_any([[array(string) a="a,b"/","; a[0]="c"; return equal(a,({"c","b"}))]],1)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 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}))
8267f41998-01-28Fredrik Hübinette (Hubbe) test_equal( ({"object","object","object","object","object"}), allocate(5,"object"))
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 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)
2de3791997-02-11Fredrik Hübinette (Hubbe) test_define_program(test,[[int foo() { return 17; }]])
2aeef52002-11-26Martin Nilsson test_any(function bar=test()->foo; return bar(),17) test_do(add_constant("test"))
e5bb7d1996-09-23Fredrik Hübinette (Hubbe)  // sscanf test_any([[mixed a; return sscanf("11","%d",a)]],1)
3a1e7e2008-05-18Henrik Grubbström (Grubba) test_any([[return sscanf("11","%*d")]],1)
b01dbc2007-05-20Martin Nilsson test_any([[mixed a; return sscanf("11","_%d",a)]],0) test_any([[mixed a,b,c; return sscanf("11","%1d%1d%1d",a,b,c)]],2)
6c35af1998-04-14Fredrik Hübinette (Hubbe) 
b01dbc2007-05-20Martin Nilsson test_any([[mixed a; sscanf("11","%b",a); return a]],0b11)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 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)
6c35af1998-04-14Fredrik Hübinette (Hubbe) 
b01dbc2007-05-20Martin Nilsson test_any([[mixed a; sscanf("11","%2b",a); return a]],0b11)
6c35af1998-04-14Fredrik Hübinette (Hubbe) test_any([[mixed a; sscanf("11","%2d",a); return a]],11) test_any([[mixed a; sscanf("11","%2o",a); return a]],011) test_any([[mixed a; sscanf("11","%2x",a); return a]],0x11) test_any([[mixed a; sscanf("11","%2D",a); return a]],11)
b01dbc2007-05-20Martin Nilsson test_any([[mixed a; sscanf("11","%4711b",a); return a]],0b11)
6c35af1998-04-14Fredrik Hübinette (Hubbe) test_any([[mixed a; sscanf("11","%4711d",a); return a]],11) test_any([[mixed a; sscanf("11","%4711o",a); return a]],011) test_any([[mixed a; sscanf("11","%4711x",a); return a]],0x11) test_any([[mixed a; sscanf("11","%4711D",a); return a]],11)
b01dbc2007-05-20Martin Nilsson test_any([[mixed a; sscanf("11","%1b",a); return a]],1)
6c35af1998-04-14Fredrik Hübinette (Hubbe) test_any([[mixed a; sscanf("11","%1d",a); return a]],1) test_any([[mixed a; sscanf("11","%1o",a); return a]],1) test_any([[mixed a; sscanf("11","%1x",a); return a]],1) test_any([[mixed a; sscanf("11","%1D",a); return a]],1)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) test_any([[mixed a; sscanf("0x11","%D",a); return a]],0x11) test_any([[mixed a; sscanf("011","%D",a); return a]],011)
7991f12008-01-05Henrik Grubbström (Grubba) test_any([[mixed a; return sscanf("11foo","%dfoo",a)]],1) test_any([[mixed a; sscanf("11foo","%dfoo",a); return a]],11)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 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")
7991f12008-01-05Henrik Grubbström (Grubba) test_any([[mixed a; return sscanf("1.0","%f",a),a]],1.0) test_any([[mixed a; return sscanf("-1.0","%f",a),a]],-1.0) test_any([[mixed a; return sscanf("1.25","%f",a),a]],1.25) test_any([[mixed a; return sscanf("-1.25","%f",a),a]],-1.25) test_any([[mixed a; return sscanf("1.25e3","%f",a),a]],1.25e3) test_any([[mixed a; return sscanf("-1.25e3","%f",a),a]],-1.25e3) test_any([[mixed a; return sscanf("1.25e-3","%f",a),a]],1.25e-3) test_any([[mixed a; return sscanf("-1.25e-3","%f",a),a]],-1.25e-3) test_any([[mixed a; sscanf("1.0","%f",a); return a]],1.0)
dca5981998-04-15Fredrik Hübinette (Hubbe) test_any([[mixed a,b; sscanf("-z ","%[-z]%s",a,b); return a]],"-z") test_any([[mixed a,b; sscanf("-z ","%[z-]%s",a,b); return a]],"-z")
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 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)
fb61ba1998-04-26Fredrik Hübinette (Hubbe) test_any([[mixed a; sscanf("a3","%*s%d",a); return a]],3) test_any([[mixed a; sscanf("a3","%s%*d",a); return a]],"a") test_any([[mixed a; sscanf("a93","%s%*o",a); return a]],"a9") test_any([[mixed a; sscanf("a93","%*s%o",a); return a]],3) test_any([[mixed a; sscanf("a93","%s%*x",a); return a]],"") test_any([[mixed a; sscanf("a93","%*s%x",a); return a]],0xa93) test_any([[mixed a; sscanf("f","f%n",a); return a]],1)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 
e478b11998-05-25Marcus Comstedt test_any([[mixed a; sscanf("\102\052\100\000","%F",a); return a]],42.5625) test_any([[mixed a; sscanf("\102\052\100\000","%4F",a); return a]],42.5625) test_any([[mixed a; sscanf("\100\105\110\000\0\0\0\0","%8F",a); return a]],42.5625) test_any([[mixed a; sscanf("\275\007\053\002","%4F",a); return a]],-0.032999999821186065673828125) test_any([[mixed a; sscanf("\277\240\345\140\100\0\0\0","%8F",a); return a]],-0.032999999821186065673828125)
d5202d2001-06-20Henrik Grubbström (Grubba) // Inf
dd66242000-11-18Marcus Comstedt test_any([[mixed a; sscanf("\177\200\0\0","%4F",a); return a>0.0]],1) test_any([[mixed a; sscanf("\177\200\0\0","%4F",a); return (a/2)==a]],1)
d5202d2001-06-20Henrik Grubbström (Grubba) // -Inf
dd66242000-11-18Marcus Comstedt test_any([[mixed a; sscanf("\377\200\0\0","%4F",a); return a<0.0]],1) test_any([[mixed a; sscanf("\377\200\0\0","%4F",a); return (a/2)==a]],1)
d5202d2001-06-20Henrik Grubbström (Grubba) // NaN
dd66242000-11-18Marcus Comstedt test_any([[mixed a; sscanf("\177\300\0\0","%4F",a); return a>0.0]],0) test_any([[mixed a; sscanf("\177\300\0\0","%4F",a); return a<0.0]],0) test_any([[mixed a; sscanf("\177\300\0\0","%4F",a); return a==0.0]],0)
d5202d2001-06-20Henrik Grubbström (Grubba) // -NaN
dd66242000-11-18Marcus Comstedt test_any([[mixed a; sscanf("\377\300\0\0","%4F",a); return a>0.0]],0) test_any([[mixed a; sscanf("\377\300\0\0","%4F",a); return a<0.0]],0) test_any([[mixed a; sscanf("\377\300\0\0","%4F",a); return a==0.0]],0)
d5202d2001-06-20Henrik Grubbström (Grubba) // Inf
dd66242000-11-18Marcus Comstedt test_any([[mixed a; sscanf("\177\360\0\0\0\0\0\0","%8F",a); return a>0.0]],1) test_any([[mixed a; sscanf("\177\360\0\0\0\0\0\0","%8F",a); return(a/2)==a]],1)
d5202d2001-06-20Henrik Grubbström (Grubba) // -Inf
dd66242000-11-18Marcus Comstedt test_any([[mixed a; sscanf("\377\360\0\0\0\0\0\0","%8F",a); return a<0.0]],1) test_any([[mixed a; sscanf("\377\360\0\0\0\0\0\0","%8F",a); return(a/2)==a]],1)
d5202d2001-06-20Henrik Grubbström (Grubba) // NaN
dd66242000-11-18Marcus Comstedt test_any([[mixed a; sscanf("\177\370\0\0\0\0\0\0","%8F",a); return a>0.0]],0) test_any([[mixed a; sscanf("\177\370\0\0\0\0\0\0","%8F",a); return a<0.0]],0) test_any([[mixed a; sscanf("\177\370\0\0\0\0\0\0","%8F",a); return a==0.0]],0)
d5202d2001-06-20Henrik Grubbström (Grubba) // -NaN
dd66242000-11-18Marcus Comstedt test_any([[mixed a; sscanf("\377\370\0\0\0\0\0\0","%8F",a); return a>0.0]],0) test_any([[mixed a; sscanf("\377\370\0\0\0\0\0\0","%8F",a); return a<0.0]],0) test_any([[mixed a; sscanf("\377\370\0\0\0\0\0\0","%8F",a); return a==0.0]],0)
dca5981998-04-15Fredrik Hübinette (Hubbe) test_equal([[array_sscanf("10 20 30","%d %d %d")]],[[({10,20,30})]]) test_equal([[array_sscanf("1 2 3 4 5 6 7 8 9","%d %d %d %d %d %d %d %d %s")]],[[({1,2,3,4,5,6,7,8,"9"})]]) test_equal([[array_sscanf("abc","%{%c%}")]],[[ ({ ({ ({'a'}), ({'b'}), ({'c'}) }) }) ]])
eccd0a1999-10-29Fredrik Noring test_equal([[array_sscanf("\x7fffffab#", "%c%c")]], [[ ({ 0x7fffffab, '#' }) ]])
22d95e1999-11-04Fredrik Hübinette (Hubbe) test_equal([[array_sscanf("\x7fffffab#", "%1c%1c")]], [[ ({ }) ]])
eccd0a1999-10-29Fredrik Noring 
c5ad621999-06-15Mirar (Pontus Hagland) test_true([[array_sscanf("(02323) 23455 344","%{%*[^0-9]%[0-9]%}")]])
6229531999-11-01Mirar (Pontus Hagland) test_eq([[ array_sscanf(sprintf("%4c",16909060),"%4c")[0] ]],16909060) test_eq([[ array_sscanf(sprintf("%-4c",16909060),"%-4c")[0] ]],16909060)
64979f2003-09-10Henrik Grubbström (Grubba) test_eq([[ array_sscanf(sprintf("%4c",16909060),"%+4c")[0] ]],16909060) test_eq([[ array_sscanf(sprintf("%-4c",16909060),"%+-4c")[0] ]],16909060) test_eq([[ array_sscanf(sprintf("%4c",-16909060),"%+4c")[0] ]],-16909060) test_eq([[ array_sscanf(sprintf("%-4c",-16909060),"%+-4c")[0] ]],-16909060)
6229531999-11-01Mirar (Pontus Hagland) 
e7a1721999-11-04Fredrik Hübinette (Hubbe) test_equal([[array_sscanf("\1000\1001\2000","%[\1000-\1111]%s")]], [[ ({ "\1000\1001", "\2000" }) ]]) test_equal([[array_sscanf("foo\1000\1001\1111\1110\2000","%s%[\1000-\1111]%s")]], [[ ({ "foo", "\1000\1001\1111\1110", "\2000" }) ]]) test_equal([[array_sscanf("\2000\1000\1111\1001\1110foo","%s%[\1000-\1111]%s")]], [[ ({ "\2000", "\1000\1111\1001\1110", "foo"}) ]])
2b24591999-11-04Fredrik Hübinette (Hubbe)  test_equal([[ array_sscanf("02 00 DC 00 0B","%{%x%*[\0-/:-@]%}")[0] ]], [[ ({ ({2}), ({0}), ({220}),({0}), ({11}) }) ]])
035b2d2000-08-13Henrik Grubbström (Grubba)  test_equal([[ array_sscanf("\51726\30212\66610\30131", "%*[ \t]%s")[0] ]],
57fbc82000-08-14Henrik Grubbström (Grubba)  [[ "\51726\30212\66610\30131" ]])
e45d9a2001-01-14Mirar (Pontus Hagland)  test_equal([[ array_sscanf("hej","%s") ]], [[ ({ "hej" }) ]]) test_equal([[ array_sscanf("hej","%s%n") ]], [[ ({ "hej", 3 }) ]]) test_eval_error([[ function f=array_sscanf; f("hej","%s% ") ]])
209e172003-02-19Marcus Comstedt 
d3ade92003-02-19Henrik Grubbström (Grubba) test_equal([[ array_sscanf("\x304b\x3066\x3044\x308a\x3087\x3046\x308a", "%[^\x3042\x3044\x3046\x3048\x304a]")[0] ]],
209e172003-02-19Marcus Comstedt  [[ "\x304b\x3066" ]])
56ec3b2004-03-07Martin Nilsson test_equal( array_sscanf("xfoox", "%sfoo%s"), ({ "x", "x" }) ) test_equal( array_sscanf("xfoox", "%sfo\400%s"), ({}) ) test_equal( array_sscanf("xfoox", "%sfo\200000%s"), ({}) ) test_equal( array_sscanf("xfo\400x", "%sfoo%s"), ({}) ) test_equal( array_sscanf("xfo\400x", "%sfo\400%s"), ({ "x", "x" }) ) test_equal( array_sscanf("xfo\400x", "%sfo\200000%s"), ({}) ) test_equal( array_sscanf("xfo\200000x", "%sfoo%s"), ({}) ) test_equal( array_sscanf("xfo\200000x", "%sfo\400%s"), ({}) ) test_equal( array_sscanf("xfo\200000x", "%sfo\200000%s"), ({ "x", "x" }) )
b01dbc2007-05-20Martin Nilsson test_any([[mixed a; sscanf("","%H",a); return a]],0) test_any([[mixed a; sscanf("\0","%H",a); return a]],"") test_any([[mixed a; sscanf("\4","%H",a); return a]],0) test_any([[mixed a; sscanf("\4hello","%H",a); return a]],"hell") test_eval_error([[mixed a; sscanf("","%0H",a); return a]]) test_eval_error([[mixed a; sscanf("\0","%0H",a); return a]]) test_eval_error([[mixed a; sscanf("\4","%0H",a); return a]]) test_eval_error([[mixed a; sscanf("\4hello","%0H",a); return a]]) test_any([[mixed a; sscanf("","%1H",a); return a]],0) test_any([[mixed a; sscanf("\0","%1H",a); return a]],"") test_any([[mixed a; sscanf("\4","%1H",a); return a]],0) test_any([[mixed a; sscanf("\4hello","%1H",a); return a]],"hell") test_any([[mixed a; sscanf("","%-1H",a); return a]],0) test_any([[mixed a; sscanf("\0","%-1H",a); return a]],"") test_any([[mixed a; sscanf("\4","%-1H",a); return a]],0) test_any([[mixed a; sscanf("\4hello","%-1H",a); return a]],"hell") test_any([[mixed a; sscanf("","%2H",a); return a]],0) test_any([[mixed a; sscanf("\0\0","%2H",a); return a]],"") test_any([[mixed a; sscanf("\0","%2H",a); return a]],0) test_any([[mixed a; sscanf("\0\4","%2H",a); return a]],0) test_any([[mixed a; sscanf("\0\4hello","%2H",a); return a]],"hell") test_any([[mixed a; sscanf("","%-2H",a); return a]],0) test_any([[mixed a; sscanf("\0\0","%-2H",a); return a]],"") test_any([[mixed a; sscanf("\4","%-2H",a); return a]],0) test_any([[mixed a; sscanf("\4\0","%-2H",a); return a]],0) test_any([[mixed a; sscanf("\4\0hello","%-2H",a); return a]],"hell")
e7a1721999-11-04Fredrik Hübinette (Hubbe) 
99aaf21999-11-17Henrik Grubbström (Grubba) test_any([[ class Bar { string sum = ""; void bar(string s) { sum += s; } string foo() { foreach(({ "foo ", "bar ", "baz " }), string s) { sscanf(s, "%*[\t ]%[^ \t]", s); switch(foo) { default: bar(s); break; } } return sum; } }; return Bar()->foo() ]], "foobarbaz")
37e4132008-05-17Marcus Comstedt test_equal( array_sscanf("^^;|", "%[^-|]%s"), ({ "^^", ";|" }) ) test_any([[mixed a; sscanf("^^;|","%[^-|]",a); return a]],"^^")
7f07d82008-05-24Henrik Grubbström (Grubba) ignore_warning("Bad argument 3 to sscanf_76.", [[ ignore_warning("Expected: string.", [[ ignore_warning("Got : int.", [[
5715072008-05-21Martin Stjernholm test_any([[ #pike 7.6 int foo; sscanf ("11", "%s", foo); return foo; ]], "11")
7f07d82008-05-24Henrik Grubbström (Grubba) ]])]])]])
5715072008-05-21Martin Stjernholm 
7f07d82008-05-24Henrik Grubbström (Grubba) ignore_warning("Too many arguments to sscanf_76 (expected 2 arguments).", [[ ignore_warning("Got : string.", [[
ab42d02008-05-21Martin Stjernholm test_any([[ #pike 7.6 string s; sscanf ("foo", "%*s", s); return s; ]], 0)
7f07d82008-05-24Henrik Grubbström (Grubba) ]])]])
ab42d02008-05-21Martin Stjernholm 
e248ee2003-02-13Mirar (Pontus Hagland) // sscanf %O -------------------------------------------------------------
af8e402003-02-13Henrik Grubbström (Grubba) define(test_percent_o_raw, [[
e248ee2003-02-13Mirar (Pontus Hagland)  test_equal(array_sscanf(]]$3[[,]]$1[[),[[$2]]) ]])
af8e402003-02-13Henrik Grubbström (Grubba) define(test_percent_o_fmt, [[ test_percent_o_raw(]]$1[[,]]$2[[,sprintf(]]$1[[,@]]$2[[))
e248ee2003-02-13Mirar (Pontus Hagland) ]])
af8e402003-02-13Henrik Grubbström (Grubba) define(test_percent_o_char, [[
e248ee2003-02-13Mirar (Pontus Hagland) dnl patsubst doesn't exist on all m4's (it's a gnuism?) ifdef(patsubst,[[
af8e402003-02-13Henrik Grubbström (Grubba)  test_percent_o_raw("%O",({']]$1[['}),"']]patsubst($1,\\,\\\\)[['")) test_percent_o_raw("%O%s",({']]$1[[',"abc"}),"']]patsubst($1,\\,\\\\)[['abc"))
e248ee2003-02-13Mirar (Pontus Hagland) ]])]]) ifdef(patsubst,[[
af8e402003-02-13Henrik Grubbström (Grubba) define(test_percent_o_string, [[ test_percent_o_raw("%O",({"]]$1[["}),"\"]]patsubst($1,\\,\\\\)[[\"")) test_percent_o_raw("%O%s",({"]]$1[[","abc"}),"\"]]patsubst($1,\\,\\\\)[[\"abc"))
e248ee2003-02-13Mirar (Pontus Hagland) ]])]])
af8e402003-02-13Henrik Grubbström (Grubba) test_percent_o_fmt("%O",({10})) test_percent_o_fmt("%O%s",({10,"abc"}))
e248ee2003-02-13Mirar (Pontus Hagland) 
af8e402003-02-13Henrik Grubbström (Grubba) test_percent_o_char([[a]]) test_percent_o_char([[\a]]) test_percent_o_char([[\123]]) test_percent_o_char([[\x4711]]) test_percent_o_char([[\d4711]])
e248ee2003-02-13Mirar (Pontus Hagland) 
af8e402003-02-13Henrik Grubbström (Grubba) test_percent_o_string([[a]]) test_percent_o_string([[\a]]) test_percent_o_string([[\123]]) test_percent_o_string([[\x4711]]) test_percent_o_string([[\d4711]])
e248ee2003-02-13Mirar (Pontus Hagland) 
af8e402003-02-13Henrik Grubbström (Grubba) test_percent_o_fmt("%O %O %O",({10,20,30})) test_percent_o_fmt("%O %O %s",({10,20,"30"}))
e248ee2003-02-13Mirar (Pontus Hagland)  // -------------------------------------------------------------
e7a1721999-11-04Fredrik Hübinette (Hubbe) 
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // 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)
ac87152000-09-25Fredrik Hübinette (Hubbe) test_equal( #pike 7.0 !Simulate.this_function(),0)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe)  // testing == test_true(1==1) test_true(!(1==2)) test_true(""=="") test_true(!(""=="foo")) test_true(this_object()==this_object())
ac87152000-09-25Fredrik Hübinette (Hubbe) test_true( #pike 7.0 Simulate.this_function()==a)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 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")
d429a71998-02-24Fredrik Hübinette (Hubbe) test_cmp3(1,2,3) test_cmp3(1.0,2.0,3.0) test_cmp3(1,2.0,3.6) test_cmp3(1.0,2,4) test_cmp3("a","b","c") test_cmp3("","b","cc")
3e625c1998-10-11Fredrik Hübinette (Hubbe) test_cmp3("\x0","\x100","\x10000") test_cmp3("a\x10000","b\x100","c\x100")
e5bb7d1996-09-23Fredrik Hübinette (Hubbe)  // 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())
12cec82003-01-15Martin Nilsson test_any(return((1+2+3)-(1+2-3)), 6)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe)  // 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)
0bc4cf1998-10-13Fredrik Hübinette (Hubbe) test_eq(034567 - 10000,4711)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 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]))
d8ca9d2003-03-08Mirar (Pontus Hagland) test_any([[string s="\57070 abcdefghijklmnopqrstuvwxyz012345678"; return strlen(s-s[1..35])]],37-35)
3a2b822003-03-08Mirar (Pontus Hagland) 
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // testing ~ test_eq(-1-4,~4) test_eq(-1-627893874,~627893874)
fb61ba1998-04-26Fredrik Hübinette (Hubbe) test_eq(~1.0,-2.0) test_eq(~"\x55","\xaa")
e5bb7d1996-09-23Fredrik Hübinette (Hubbe)  // 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)
0bc4cf1998-10-13Fredrik Hübinette (Hubbe) 
12cec82003-01-15Martin Nilsson test_eq([[({})*""]],"") test_eq([[({"foo",0,"bar"})*"-"]],"foo-bar") test_eq([[({"f","o","o"})*""]],"foo")
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) test_eq(({"foo","bar","gazonk"})*"-","foo-bar-gazonk")
3e625c1998-10-11Fredrik Hübinette (Hubbe) test_eq(({"f\777\777","bar","gaz\777nk"})*"-","f\777\777-bar-gaz\777nk") test_eq(({"f\7777777\7777777","bar","gaz\7777777nk"})*"-","f\7777777\7777777-bar-gaz\7777777nk")
0bc4cf1998-10-13Fredrik Hübinette (Hubbe)  test_eq(({"foo","bar","gazonk"})*"\777","foo\777bar\777gazonk") test_eq(({"f\777\777","bar","gaz\777nk"})*"\777","f\777\777\777bar\777gaz\777nk") test_eq(({"f\7777777\7777777","bar","gaz\7777777nk"})*"\777","f\7777777\7777777\777bar\777gaz\7777777nk") test_eq(({"foo","bar","gazonk"})*"\7777777","foo\7777777bar\7777777gazonk") test_eq(({"f\777\777","bar","gaz\777nk"})*"\7777777","f\777\777\7777777bar\7777777gaz\777nk") test_eq(({"f\7777777\7777777","bar","gaz\7777777nk"})*"\7777777","f\7777777\7777777\7777777bar\7777777gaz\7777777nk")
7fa9101997-02-18Fredrik Hübinette (Hubbe) test_equal( ({ ({1}), ({2}), ({3}) })*({8}), ({1,8,2,8,3}))
d429a71998-02-24Fredrik Hübinette (Hubbe) test_equal( ({ 1 })*3, ({1,1,1}) ) test_equal( "foo"*3, "foofoofoo" )
b0dfdc2000-09-26Henrik Wallin test_equal( "foo"*2.5, "foofoofo" ) test_equal( "\1234oo"*2.5, "\1234oo\1234oo\1234o" ) test_equal( ({1,2,3})*1.5, ({1,2,3,1,2})) test_equal( ({1,2,3})*1.4, ({1,2,3,1})) test_equal( ({1,2,3})*0.0, ({})) test_equal( ({})*3.0, ({}))
e5bb7d1996-09-23Fredrik Hübinette (Hubbe)  // testing / test_eq(12/3,4) test_eq(13/3,4) test_eq(14/3,4) test_eq(15/3,5)
c93f0e1997-12-03Fredrik Hübinette (Hubbe) test_eq(-2/4,-1)
806a2c1997-04-28Fredrik Hübinette (Hubbe) test_eq(-12/3,-4) test_eq(-13/3,-5) test_eq(-14/3,-5) test_eq(-15/3,-5)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 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"}))
7fa9101997-02-18Fredrik Hübinette (Hubbe) 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}) }))
8045522009-05-02Henrik Grubbström (Grubba) test_eq(sizeof(allocate(119)/({})), 119) test_eq(sizeof(allocate(120)/({})), 120) test_eq(sizeof(allocate(121)/({})), 121) test_eq(sizeof(allocate(122)/({})), 122)
7fa9101997-02-18Fredrik Hübinette (Hubbe) test_equal(({1,0,1,2,1,2,2,2,1,1,1})/({2,1}),({ ({1,0,1}), ({2,2}), ({1,1}) }))
034fb91997-02-24Fredrik Hübinette (Hubbe) test_equal( ({1,2,3})/({2,3}), ({ ({1}), ({}) }) )
d429a71998-02-24Fredrik Hübinette (Hubbe) test_eq([[`/(20,2,2)]],5) test_eq([[`/(13,2,3)]],2) test_equal("foobargazonk"/1,"foobargazonk"/"") test_equal("foobargazonk"/2,({"fo","ob","ar","ga","zo","nk"})) test_equal("foobargazonk"/3,({"foo","bar","gaz","onk"})) test_equal("foobargazonk"/4,({"foob","arga","zonk"})) test_equal("foobargazonk"/5,({"fooba","rgazo"})) test_equal("foobargazonk"/-6,({"foobar","gazonk"})) test_equal("foobargazonk"/-7,({"rgazonk"})) test_equal("foobargazonk"/5.0,({"fooba","rgazo","nk"})) test_equal("foobargazonk"/-5.0,({"fo","obarg","azonk"}))
b0dfdc2000-09-26Henrik Wallin test_equal("foobargazonk"/2.5,({"foo","ba","rga","zo","nk"})) test_equal("foo"/2.6,({"foo",""})) test_equal("\1233oo"/2.6,({"\1233oo",""}))
d429a71998-02-24Fredrik Hübinette (Hubbe) 
0bc4cf1998-10-13Fredrik Hübinette (Hubbe) test_equal("f\777\777bargaz\777nk"/1,"f\777\777bargaz\777nk"/"") test_equal("f\777\777bargaz\777nk"/2,({"f\777","\777b","ar","ga","z\777","nk"})) test_equal("f\777\777bargaz\777nk"/3,({"f\777\777","bar","gaz","\777nk"})) test_equal("f\777\777bargaz\777nk"/4,({"f\777\777b","arga","z\777nk"})) test_equal("f\777\777bargaz\777nk"/5,({"f\777\777ba","rgaz\777"})) test_equal("f\777\777bargaz\777nk"/-6,({"f\777\777bar","gaz\777nk"})) test_equal("f\777\777bargaz\777nk"/-7,({"rgaz\777nk"})) test_equal("f\777\777bargaz\777nk"/5.0,({"f\777\777ba","rgaz\777","nk"})) test_equal("f\777\777bargaz\777nk"/-5.0,({"f\777","\777barg","az\777nk"}))
1e5db52000-09-27Henrik Wallin test_equal("f\777\777bargaz\777nk"/2.5,({"f\777\777","ba","rga","z\777","nk"}))
0bc4cf1998-10-13Fredrik Hübinette (Hubbe) 
12cec82003-01-15Martin Nilsson test_equal(""/"hej", ({""})) test_equal("hej"/"hej", ({"",""}))
0bc4cf1998-10-13Fredrik Hübinette (Hubbe) test_equal("f\7777777\7777777bargaz\7777777nk"/1,"f\7777777\7777777bargaz\7777777nk"/"") test_equal("f\7777777\7777777bargaz\7777777nk"/2,({"f\7777777","\7777777b","ar","ga","z\7777777","nk"})) test_equal("f\7777777\7777777bargaz\7777777nk"/3,({"f\7777777\7777777","bar","gaz","\7777777nk"})) test_equal("f\7777777\7777777bargaz\7777777nk"/4,({"f\7777777\7777777b","arga","z\7777777nk"})) test_equal("f\7777777\7777777bargaz\7777777nk"/5,({"f\7777777\7777777ba","rgaz\7777777"})) test_equal("f\7777777\7777777bargaz\7777777nk"/-6,({"f\7777777\7777777bar","gaz\7777777nk"})) test_equal("f\7777777\7777777bargaz\7777777nk"/-7,({"rgaz\7777777nk"})) test_equal("f\7777777\7777777bargaz\7777777nk"/5.0,({"f\7777777\7777777ba","rgaz\7777777","nk"})) test_equal("f\7777777\7777777bargaz\7777777nk"/-5.0,({"f\7777777","\7777777barg","az\7777777nk"}))
fed8df2000-09-27Henrik Grubbström (Grubba) test_equal("f\7777777\7777777bargaz\7777777nk"/2.5,({"f\7777777\7777777", "ba","rga","z\7777777","nk"}))
0bc4cf1998-10-13Fredrik Hübinette (Hubbe) 
d429a71998-02-24Fredrik Hübinette (Hubbe) test_equal(({1,2,3})/1,({ ({1}), ({2}), ({3}) })) test_equal(({1,2,3})/2,({ ({1,2}) })) test_equal(({1,2,3})/-2,({ ({2,3}) })) test_equal(({1,2,3})/2.0,({ ({1,2}), ({3}) })) test_equal(({1,2,3})/-2.0,({ ({1}), ({2,3}) }))
b0dfdc2000-09-26Henrik Wallin test_equal(({1,2,3})/1.5,({ ({1, 2}), ({3}) }))
e5bb7d1996-09-23Fredrik Hübinette (Hubbe)  // testing % test_eq(12%3,0) test_eq(13%3,1) test_eq(14%3,2) test_eq(15%3,0)
806a2c1997-04-28Fredrik Hübinette (Hubbe) test_eq(2%17,2) test_eq(2%-17,-15) test_eq(-2%17,15) test_eq(-2%-17,-2)
284c361997-09-15Fredrik Hübinette (Hubbe) test_eq(-10%10,0) test_eq(10%-10,0) test_eq(-10%-10,0) test_eq(10%10,0)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 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)
d429a71998-02-24Fredrik Hübinette (Hubbe) test_eq("foobargazonk"%5,"nk") test_eq("foobargazonk"%-5,"fo")
0bc4cf1998-10-13Fredrik Hübinette (Hubbe) test_eq("f\777\777bargaz\777nk"%5,"nk") test_eq("f\777\777bargaz\777nk"%-5,"f\777") test_eq("f\7777777\7777777bargaz\7777777nk"%5,"nk") test_eq("f\7777777\7777777bargaz\7777777nk"%-5,"f\7777777")
d429a71998-02-24Fredrik Hübinette (Hubbe) test_equal(({1,2,3})%2,({3})) test_equal(({1,2,3})%-2,({1}))
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // 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)
20d9f92003-08-10Martin Nilsson test_eq([[ "\007" | "\023"]],"\027") test_eq([[ "\177777x" | "ab" ]], "\177777z")
934a7f2003-11-10Martin Stjernholm test_equal( ({1,2,3,4,4}) | ({3,5,6}), ({1,2,3,4,4,5,6}))
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 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]) )
aa4a322001-01-03Martin Stjernholm test_any([[ class Foo {int `< (object o) {return 0;}}; return sizeof (({Foo()}) | ({Foo()})); ]], 2)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe)  // testing & test_eq(0 & 0,0) test_eq(1 & 1,1) test_eq(4 & 1,0) test_eq(1 & 9,1)
20d9f92003-08-10Martin Nilsson test_eq([[ "\007" & "\023"]],"\003") test_eq([[ "\177777x" & "ab" ]], "a`")
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 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]) )
b117982004-04-15Martin Stjernholm test_equal(({1,2,1}) & ({1,2}), ({1,2})) test_equal(({2,1,2}) & ({1,2}), ({2,1})) test_equal(({1,2,1,2,2}) & ({1,2}), ({1,2})) test_equal(({2,1,2,1,2}) & ({1,2}), ({2,1}))
e5bb7d1996-09-23Fredrik Hübinette (Hubbe)  // testing ^ test_eq(0 ^ 0,0) test_eq(1 ^ 1,0) test_eq(4 ^ 1,5) test_eq(1 ^ 9,8)
20d9f92003-08-10Martin Nilsson test_eq([[ "\007" ^ "\023"]],"\024") test_eq([[ "\177777x" ^ "ab" ]], "\177636\32")
934a7f2003-11-10Martin Stjernholm test_equal( ({1,2,3,4,4}) ^ ({3,5,6}) , ({1,2,4,4,5,6}))
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 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]) )
934a7f2003-11-10Martin Stjernholm test_equal(({1,3,3,3,4}) ^ ({2,3,3,5}), ({1,3,4,2,5})) test_equal(({1,3,3,4}) ^ ({2,3,3,3,5}), ({1,4,2,3,5}))
e5bb7d1996-09-23Fredrik Hübinette (Hubbe)  // testing << test_eq(1<<0,1) test_eq(1<<1,2) test_eq(1<<10,1024) test_eq(5<<3,40)
df8dce2002-10-16Henrik Grubbström (Grubba) test_eval_error(return 17<<-10)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe)  // testing >> test_eq(9>>2,2) test_eq(1>>1,0) test_eq(1024>>10,1) test_eq(47>>3,5)
0c50a22002-10-15Marcus Comstedt test_eq(-10>>10000,-1)
df8dce2002-10-16Henrik Grubbström (Grubba) test_eval_error(return 17>>-10)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe)  // 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)
8dc4ff1999-02-05Martin Stjernholm test_eq(1 ? "a" : 1 ? "b" : 1, "a") test_eq(0 ? "a" : 1 ? "b" : 1 ? "c" : 1, "b") test_eq(0 ? "a" : 0 ? "b" : 1 ? "c" : 1, "c")
e5bb7d1996-09-23Fredrik Hübinette (Hubbe)  // 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')
3e625c1998-10-11Fredrik Hübinette (Hubbe)  test_eq("f\777\777"[0],'f') test_eq("f\777\777"[1],'\777') test_eq("f\777\777"[2],'\777') test_eq("f\777\777"[-1],'\777') test_eq("f\777\777"[-2],'\777') test_eq("f\777\777"[-3],'f') test_eq("f\77777777\77777777"[0],'f') test_eq("f\77777777\77777777"[1],'\77777777') test_eq("f\77777777\77777777"[2],'\77777777') test_eq("f\77777777\77777777"[-1],'\77777777') test_eq("f\77777777\77777777"[-2],'\77777777') test_eq("f\77777777\77777777"[-3],'f')
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 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')
cf6e632008-06-28Martin Nilsson test_eq(([0:'f',1:'o',2:'o'])[random(0)+3],0) test_eq(([0:'f',1:'o',2:'o'])[random(0)-1],0)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) test_eq((<'f','o','o'>)['o'],1) test_eq((<'f','o','o'>)['f'],1)
cf6e632008-06-28Martin Nilsson test_eq((<'f','o','o'>)[random(0)+'b'],0)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) test_eq((<'f','o','o'>)[-1],0)
99761f1998-10-09Fredrik Hübinette (Hubbe) test_eq([[class Z { mixed `->(mixed x) { return this_object()[x]; } int foo() { return 1; }}()->foo()]],1)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // 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)
1414872005-05-18Martin Nilsson test_any(mixed a="hej"; a[1]='o'; return a,"hoj") test_do( string x=" "*73; x[64]=1; x[65]=1; )
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 
2de3791997-02-11Fredrik Hübinette (Hubbe) test_define_program(test,[[public int q,w,e,r; mixed t; mixed getw() { return w; } void setw(int _) { w=_; }]])
2aeef52002-11-26Martin Nilsson test_eq(test()->q,0) test_eq(test()->w,0) test_eq(test()->e,0) test_eq(test()->r,0) test_eq(test()->getw(),0) test_any(object o=test(); o->setw(17); return o->w,17) test_any(object o=test(); o->w=17; return o->getw(),17) test_eq(test()["q"],0) test_eq(test()["w"],0) test_eq(test()["e"],0) test_eq(test()["r"],0) test_eq(test()["getw"](),0) test_any(object o=test(); o["setw"](17); return o["w"],17) test_any(object o=test(); o["w"]=17; return o["getw"](),17) test_do(add_constant("test");)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe)  // 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")
e485a02006-06-16Henrik Grubbström (Grubba) ignore_warning("Range is always empty.", [[ test_any(return "foo"[1..0];,"") ]])
408a1e2004-10-30Martin Stjernholm test_any(int u=-100; return "foo"[0..u];,"") dnl Use variable to avoid warning.
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 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")
63d4582008-09-02Martin Stjernholm test_eq("1234"[..Int.NATIVE_MAX], "1234") test_eq("1234"[..Int.NATIVE_MAX - 1], "1234") test_eq("1234"[Int.NATIVE_MIN..], "1234") test_eq("1234"[Int.NATIVE_MIN + 1..], "1234")
3e625c1998-10-11Fredrik Hübinette (Hubbe)  test_eq("f\7777\7777bargaz\7777nk"[0..],"f\7777\7777bargaz\7777nk") test_eq("f\7777\7777bargaz\7777nk"[1..],"\7777\7777bargaz\7777nk") test_eq("f\7777\7777bargaz\7777nk"[5..],"rgaz\7777nk") test_eq("f\7777\7777bargaz\7777nk"[..2],"f\7777\7777") test_eq("f\7777\7777bargaz\7777nk"[..5],"f\7777\7777bar") test_eq("f\77777777\77777777bargaz\77777777nk"[0..],"f\77777777\77777777bargaz\77777777nk") test_eq("f\77777777\77777777bargaz\77777777nk"[1..],"\77777777\77777777bargaz\77777777nk") test_eq("f\77777777\77777777bargaz\77777777nk"[5..],"rgaz\77777777nk") test_eq("f\77777777\77777777bargaz\77777777nk"[..2],"f\77777777\77777777") test_eq("f\77777777\77777777bargaz\77777777nk"[..5],"f\77777777\77777777bar")
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 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}))
e485a02006-06-16Henrik Grubbström (Grubba) ignore_warning("Range is always empty.", [[ test_any_equal(return ({1,2,3})[1..0];,({})) ]])
408a1e2004-10-30Martin Stjernholm test_any_equal(int u=-100; return ({1,2,3})[0..u];,({})) dnl Use variable to avoid warning. test_eq("abcdef"[1..3], "bcd") test_eq("abcdef"[1..<3], "bc") test_eq("abcdef"[1..], "bcdef") test_eq("abcdef"[<1..3], "") test_eq("abcdef"[<1..<3], "") test_eq("abcdef"[<1..], "ef") test_eq("abcdef"[<3..3], "cd") test_eq("abcdef"[<3..<3], "c") test_eq("abcdef"[<3..], "cdef") test_eq("abcdef"[..3], "abcd") test_eq("abcdef"[..<3], "abc")
e485a02006-06-16Henrik Grubbström (Grubba) ignore_warning("Redundant range operator.", [[ test_eq("abcdef"[..], "abcdef") ]])
408a1e2004-10-30Martin Stjernholm  test_equal(`[..] ("abcdef"/"", 1, Pike.INDEX_FROM_BEG, 3, Pike.INDEX_FROM_BEG), "bcd"/""); test_equal(`[..] ("abcdef"/"", 1, Pike.INDEX_FROM_BEG, 3, Pike.INDEX_FROM_END), "bc"/""); test_equal(`[..] ("abcdef"/"", 1, Pike.INDEX_FROM_BEG, 3, Pike.OPEN_BOUND), "bcdef"/""); test_equal(`[..] ("abcdef"/"", 3, Pike.INDEX_FROM_END, 3, Pike.INDEX_FROM_BEG), "cd"/""); test_equal(`[..] ("abcdef"/"", 3, Pike.INDEX_FROM_END, 3, Pike.INDEX_FROM_END), "c"/""); test_equal(`[..] ("abcdef"/"", 3, Pike.INDEX_FROM_END, 3, Pike.OPEN_BOUND), "cdef"/""); test_equal(`[..] ("abcdef"/"", 1, Pike.OPEN_BOUND, 3, Pike.INDEX_FROM_BEG), "abcd"/""); test_equal(`[..] ("abcdef"/"", 1, Pike.OPEN_BOUND, 3, Pike.INDEX_FROM_END), "abc"/""); test_equal(`[..] ("abcdef"/"", 1, Pike.OPEN_BOUND, 3, Pike.OPEN_BOUND), "abcdef"/""); define(test_new_style, [[ test_any_equal([[ object new_style = class { array(int) `[..] (int... args) {return args;} }(); return new_style $1; ]], $2) ]]) test_new_style([1..3], ({1, Pike.INDEX_FROM_BEG, 3, Pike.INDEX_FROM_BEG})) test_new_style([1..<3], ({1, Pike.INDEX_FROM_BEG, 3, Pike.INDEX_FROM_END})) test_new_style([1..], ({1, Pike.INDEX_FROM_BEG, 0, Pike.OPEN_BOUND})) test_new_style([<1..3], ({1, Pike.INDEX_FROM_END, 3, Pike.INDEX_FROM_BEG})) test_new_style([<1..<3], ({1, Pike.INDEX_FROM_END, 3, Pike.INDEX_FROM_END})) test_new_style([<1..], ({1, Pike.INDEX_FROM_END, 0, Pike.OPEN_BOUND})) test_new_style([..3], ({0, Pike.OPEN_BOUND, 3, Pike.INDEX_FROM_BEG})) test_new_style([..<3], ({0, Pike.OPEN_BOUND, 3, Pike.INDEX_FROM_END})) test_new_style([..], ({0, Pike.OPEN_BOUND, 0, Pike.OPEN_BOUND})) undefine([[test_new_style]]) define(test_old_style, [[ test_any_equal([[ object old_style = class { int _sizeof() {return 6;} array(int) `[] (int... args) {return args;} }(); return old_style $1; ]], $2) ]]) test_old_style([1..3], ({1, 3})) test_old_style([1..<3], ({1, 2})) test_old_style([1..], ({1, Int.NATIVE_MAX})) dnl Upper bound might become larger. test_old_style([<1..3], ({4, 3})) test_old_style([<1..<3], ({4, 2})) test_old_style([<1..], ({4, Int.NATIVE_MAX})) dnl Upper bound might become larger. test_old_style([..3], ({0, 3})) test_old_style([..<3], ({0, 2})) test_old_style([..], ({0, Int.NATIVE_MAX})) dnl Upper bound might become larger. undefine([[test_old_style]])
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 
d429a71998-02-24Fredrik Hübinette (Hubbe) // casting test_eq([[(int)1]],[[1]])
17a46a2000-06-13Martin Nilsson test_eq([[(int)-1]],[[-1]])
d429a71998-02-24Fredrik Hübinette (Hubbe) test_eq([[(int)1.0]],[[1]])
17a46a2000-06-13Martin Nilsson test_eq([[(int)-1.0]],[[-1]])
d429a71998-02-24Fredrik Hübinette (Hubbe) test_eq([[(int)"1"]],[[1]])
17a46a2000-06-13Martin Nilsson test_eq([[(int)"-1"]],[[-1]])
f218802001-06-05Fredrik Hübinette (Hubbe) test_eq([[(int)"0x1"]],[[0]]) test_eq([[(int)"010"]],[[10]])
d429a71998-02-24Fredrik Hübinette (Hubbe) test_eq([[(float)"1"]],[[1.0]])
17a46a2000-06-13Martin Nilsson test_eq([[(float)"-1"]],[[-1.0]])
d429a71998-02-24Fredrik Hübinette (Hubbe) test_eq([[(float)"1.0"]],[[1.0]])
17a46a2000-06-13Martin Nilsson test_eq([[(float)"-1.0"]],[[-1.0]])
d429a71998-02-24Fredrik Hübinette (Hubbe) test_eq([[(float)1.0]],[[1.0]])
17a46a2000-06-13Martin Nilsson test_eq([[(float)-1.0]],[[-1.0]])
d429a71998-02-24Fredrik Hübinette (Hubbe) test_eq([[(float)1]],[[1.0]])
17a46a2000-06-13Martin Nilsson test_eq([[(float)-1]],[[-1.0]])
d429a71998-02-24Fredrik Hübinette (Hubbe) test_eq([[(string)1]],[["1"]])
17a46a2000-06-13Martin Nilsson test_eq([[(string)-1]],[["-1"]])
d7e29c2009-06-30Martin Stjernholm test_eq([[(string)1.0]],[["1.0"]]) test_eq([[(string)-1.0]],[["-1.0"]])
b13bc32009-06-30Martin Stjernholm test_true([[has_value ((string)1e100, ".") || has_value ((string)1e100, "e")]]) test_true([[has_value ((string)-1e100, ".") || has_value ((string)-1e100, "e")]]) test_true([[has_value ((string)1e-100, ".") || has_value ((string)1e-100, "e")]]) test_true([[has_value ((string)-1e-100, ".") || has_value ((string)-1e-100, "e")]]) test_true([[has_value ((string)124354236143512312334562453624.1, ".") || has_value ((string)124354236143512312334562453624.1, "e")]])
adc0e92008-08-22Mirar (Pontus Hagland) test_do(return (string)1e308) test_do(return (string)1e200) test_do(return (string)1e-200) test_do(return (string)1e-307)
83ffdb2003-03-29Henrik Grubbström (Grubba) test_any([[ array foo=({ 1 }); return (string)sizeof(foo); ]], [["1"]]) test_any([[ array foo=({ -1 }); return (string)-sizeof(foo); ]], [["-1"]])
d429a71998-02-24Fredrik Hübinette (Hubbe) test_equal([[(array)(["1":1])]],[[ ({ ({"1", 1}) }) ]]) test_equal([[(array(int)) ({"1","4711",2.0,4})]],[[({1,4711,2,4})]])
1671fe1998-05-16Fredrik Hübinette (Hubbe) test_equal([[(array(array))({({})})]],[[({({})})]])
4234be1998-05-16Fredrik Hübinette (Hubbe) test_equal([[ (array(array(int))) ({ ({"1","4711",2.0,4}) }) ]],[[ ({ ({1,4711,2,4}) }) ]])
798adb1998-05-16Fredrik Hübinette (Hubbe) test_equal([[ (array(array(array(int)))) ({ ({ ({"1","4711",2.0,4}) }) }) ]],[[ ({ ({ ({1,4711,2,4}) }) }) ]]) test_equal([[ (array(array(array(array(int))))) ({ ({ ({ ({"1","4711",2.0,4}) }) }) }) ]],[[ ({ ({ ({ ({1,4711,2,4}) }) }) }) ]])
d429a71998-02-24Fredrik Hübinette (Hubbe) 
fb61ba1998-04-26Fredrik Hübinette (Hubbe) test_equal([[(array)"foo"]],[[ values("foo") ]]) test_equal([[(array)(<1,2,3>)]],[[ indices( (<1,2,3>) )]])
de51d11998-05-13Fredrik Hübinette (Hubbe) test_equal([[sort(column((array)([1:2,3:4]),0))]],[[ sort(indices(([1:2,3:4])) )]]) test_equal([[sort(column((array)([1:2,3:4]),1))]],[[ sort(values(([1:2,3:4])))]])
1671fe1998-05-16Fredrik Hübinette (Hubbe) test_true([[(array(array))([]) ]]) test_true([[(array(array))([1:2]) ]]) test_true([[(array(array))([1:2,3:4]) ]])
de51d11998-05-13Fredrik Hübinette (Hubbe) test_true([[(array(array))([1:2,3:4,5:6]) ]])
6168ce2000-01-27Fredrik Hübinette (Hubbe) test_equal( [[ (multiset) ({1})]], [[ (< 1 >) ]] )
862bd02003-08-26Henrik Grubbström (Grubba) test_equal( [[ (multiset(string)) ({1})]], [[ (< "1" >) ]] )
be1daa1999-11-15Henrik Grubbström (Grubba) test_eval_error([[return (mapping)""]])
94671c2000-11-29Mirar (Pontus Hagland) test_equal([[ (mapping)({({1,2}),({3,4})})]], [[([1:2,3:4]) ]]) test_equal([[ ({({1,2})})]], [[(array)([1:2]) ]]) test_equal([[ (mapping)({})]], [[ ([]) ]]) test_equal([[ ({}) ]], [[ (array)([]) ]])
505aec2000-11-29Mirar (Pontus Hagland) test_eval_error([[ mapping m=(mapping)({ ({1,2,3}), ({4,5,6}) }); ]])
d429a71998-02-24Fredrik Hübinette (Hubbe) 
eba0752004-09-20Martin Stjernholm test_any([[ object x = class { mixed cast (string t) {return t == "string" && "foo";} }(); destruct (x); return (string) x; ]], "0")
5d100b2008-07-17Martin Stjernholm test_eq([[(string) ({0,1,2})]], "\0\1\2") test_eq([[(string) ({'z', 0xff, '.'})]], "z\xff.") test_eq([[(string) ({'z', 0x100, '.'})]], "z\x100.") test_eq([[(string) ({'z', 0xffff, '.'})]], "z\xffff.") test_eq([[(string) ({'z', 0x10000, '.'})]], "z\x10000.") test_eq([[(string) ({'z', -1, '.'})]], "z\xffffffff.") test_eq([[(string) ({'z', 0x7fffffff, '.'})]], "z\x7fffffff.")
50428e2008-07-18Martin Stjernholm test_eval_error([[(string) ({0x80000000})]])
5d100b2008-07-17Martin Stjernholm test_eq([[(string) ({'z', -0x80000000, '.'})]], "z\x80000000.")
50428e2008-07-18Martin Stjernholm test_eval_error([[(string) ({-0x80000001})]])
5d100b2008-07-17Martin Stjernholm 
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // testing @ test_equal(({1,2,3}),lambda(mixed ... x) { return x; }(@a()))
2de3791997-02-11Fredrik Hübinette (Hubbe) test_equal("foo"/"",lambda(mixed ... x) { return x; }(@a()))
3488ef2000-04-17Henrik Grubbström (Grubba) test_any([[array a=({1,2,3}); return lambda(mixed ... x) { return x; }(@a) !=a]],1)
18b0a82001-01-25Fredrik Hübinette (Hubbe) test_any([[array z=({lambda(mixed x){return x;},17});return `()(@z);]],17)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe)  // testing += test_any(int a=1; a+=10; return a,11)
916f352007-06-10Martin Nilsson test_any_equal(mapping m=([]); m->x+=([]); return m->x, ([])) test_any_equal(mapping m=([]); m->x+=(<>); return m->x, (<>)) test_any_equal(mapping m=([]); m->x+=({}); return m->x, ({})) test_any_equal([[ array a = ({}); catch { a += Array.reduce(`+,({})); }; return a; ]],({}))
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // 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)
01980d2008-03-22Henrik Grubbström (Grubba) test_any(int a = UNDEFINED; a|=1; return zero_type(a), 0)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // 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
cd90c51998-08-05Fredrik Hübinette (Hubbe) test_program(
3488ef2000-04-17Henrik Grubbström (Grubba) array(int) ia=({1,2,3,4,5,6});
cd90c51998-08-05Fredrik Hübinette (Hubbe)  int a() { int i; for (i=0; i<sizeof(ia); i++) { if (ia[i]==3) { ia=ia[..i-1]+ia[i+1..]; --i; } } return 1; } )
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 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")
3488ef2000-04-17Henrik Grubbström (Grubba) test_any([[ /* FIXME: This test needs to be proofed against the optimizer. */ string s;if(1) foreach(({}),s); else foreach(({}),s); return 1 ]],1)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 
2e952a2001-02-27Fredrik Hübinette (Hubbe) test_any([[ int ret; foreach( ([1:2,3:5,7:11,13:17]) ; int a ; int b) ret+=a*b; return ret; ]],315) test_any([[ int ret; foreach( ([1:2,3:5,7:11,13:17]) ; ; int b) ret+=b; return ret; ]],35) test_any([[ int ret; foreach( ([1:2,3:5,7:11,13:17]) ; int a; ) ret+=a; return ret; ]],24) test_any([[ int ret;
1e17942001-02-28Henrik Grubbström (Grubba)  foreach( (<1,3,7,13>) ; ; int b) ret+=b;
2e952a2001-02-27Fredrik Hübinette (Hubbe)  return ret; ]],4) test_any([[ int ret; foreach( (<1,3,7,13>) ; int a; ) ret+=a; return ret; ]],24)
c8565d2001-09-30Mirar (Pontus Hagland) test_any([[ int ret; foreach( (<1,3,7,13>) ; ; ) ret++; return ret; ]],4)
2e952a2001-02-27Fredrik Hübinette (Hubbe)  test_any([[ int ret; foreach( (<1,3,7,13>) ; int a; int b) ret+=a+b; return ret; ]],24+4) test_any([[ int ret; foreach( ({2,5,11,17}) ; int a; ) ret+=a; return ret; ]],6) test_any([[ int ret; foreach( ({2,5,11,17}) ; ; int b) ret+=b; return ret; ]],35) test_any([[ int ret; foreach( ({2,5,11,17}) ; int a; int b) ret+=a*b; return ret; ]],78)
c8565d2001-09-30Mirar (Pontus Hagland) test_any([[ int ret; foreach( ({2,5,11,17}) ; ; ) ret++; return ret; ]],4)
2e952a2001-02-27Fredrik Hübinette (Hubbe) test_any([[ int ret; foreach( "foobar" ; int a; int b) ret+=a*b; return ret; ]],1585)
6fda9f2001-02-28Henrik Grubbström (Grubba) test_any([[ int ret; foreach( "foobar" ; int a;) ret+=a; return ret;
96b9982001-02-28Henrik Grubbström (Grubba) ]],15)
6fda9f2001-02-28Henrik Grubbström (Grubba)  test_any([[ int ret; foreach( "foobar" ; ; int b) ret+=b; return ret; ]],633)
2e952a2001-02-27Fredrik Hübinette (Hubbe) test_any([[ mapping m=([1:2,3:5,7:11,13:17]);
7991f12008-01-05Henrik Grubbström (Grubba)  foreach(m; int a; int b) if (m_delete(m,a) != b) return -1;
2e952a2001-02-27Fredrik Hübinette (Hubbe)  return sizeof(m); ]],0) test_any([[ mapping m=([1:2,3:5,7:11,13:17]);
1e17942001-02-28Henrik Grubbström (Grubba)  int ret;
2e952a2001-02-27Fredrik Hübinette (Hubbe)  foreach(m ; int a ; int b) { m_delete(m,a); ret+=a*b; }
1e17942001-02-28Henrik Grubbström (Grubba)  return ret;
2e952a2001-02-27Fredrik Hübinette (Hubbe) ]],315)
13a16d2003-05-31Martin Stjernholm test_eval_error([[ int i; foreach (class{}(); mixed a; mixed b) i++; return i; ]])
f139182003-09-05Martin Stjernholm test_any([[ String.Iterator iter = String.Iterator ("foo"); foreach (iter; int idx;) if (idx != iter->index()) return 1; return 0; ]], 0)
e9ead02006-11-07Martin Stjernholm test_any([[ mapping(object:int) x = ([]); object o = class {}(); x[o] = 1; destruct (o); int i;
7991f12008-01-05Henrik Grubbström (Grubba)  foreach (x;;) i++;
e9ead02006-11-07Martin Stjernholm  return i; ]], 0) test_any([[ multiset(object) x = (<>); object o = class {}(); x[o] = 1; destruct (o); int i;
7991f12008-01-05Henrik Grubbström (Grubba)  foreach (x;;) i++;
e9ead02006-11-07Martin Stjernholm  return i; ]], 0)
ff581d1998-05-24Fredrik Noring // do-while
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 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
1ac94a2000-01-04Henrik Grubbström (Grubba) test_any(switch((mixed)"") { case -1: case "gazonk": return 0; } return 1,1) test_any(switch((mixed)"") { case -2: case "gazonk": return 0; } return 1,1) test_any(switch((mixed)"") { case 0: case "gazonk": return 0; } return 1,1) test_any(switch((mixed)"") { case "gazonk": case 0: return 0; } return 1,1) test_any(switch((mixed)0) { case 0: case "gazonk": return 0; } return 1,0) test_any(switch((mixed)"gazonk") { case "gazonk": case 0: return 0; } return 1,0) test_any(switch((mixed)0) { case "": } return 1,1) test_any(switch((mixed)1) { case 1: return 1; default: } return 0,1) test_any(switch((mixed)2) { case 1: return 0; default: return 1;} return 0,1) test_any(switch((mixed)1) { default: return 0; case 1: return 1; } return 0,1) test_any(switch((mixed)2) { default: return 1; case 1: return 0; } return 0,1) test_any(switch((mixed)0) { case "apa": case 1.0: return 0; } return 1,1) test_any(switch((mixed)"apa") { case "apa": return 1; case 1.0: } return 0,1) test_any(switch((mixed)1.0) { case "apa": return 0; case 1.0: return 1; } return 0,1) test_any(switch((mixed)"sune") { case "gunnel": return 0; case "gunnar": return 1; case "sune": case "gusten": return 0; } return 0,0) test_any(switch((mixed)"a") { case "a": return 1; case "b": case "c": case "d": case 'a': case '1': case '0': default: } return 0,1) test_any(switch((mixed)"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((mixed)"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((mixed)"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((mixed)'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((mixed)'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((mixed)'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((mixed)"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((mixed)"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((mixed)"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((mixed)"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((mixed)'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((mixed)'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((mixed)'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((mixed)'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)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 
d53a941999-11-17Fredrik Hübinette (Hubbe) test_program([[ void bar() {} int a() { foreach( ({1}), int n) { switch(n) { default: bar(); break; } } return 1; } ]])
e5bb7d1996-09-23Fredrik Hübinette (Hubbe)  define(test_switch0,[[
1ac94a2000-01-04Henrik Grubbström (Grubba) test_any(switch((mixed)$1) { $2; $3; $4; $5; } return 0,$6) test_any(switch((mixed)$1) { default: return 0; $2; $3; $4; $5; } return -1,$6) test_any(switch((mixed)$1) { $2; default: return 0; $3; $4; $5; } return -1,$6) test_any(switch((mixed)$1) { $2; $3; default: return 0; $4; $5; } return -1,$6) test_any(switch((mixed)$1) { $2; $3; $4; default: return 0; $5; } return -1,$6) test_any(switch((mixed)$1) { $2; $3; $4; $5; default: return 0; } return -1,$6)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) ]]) 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")
a5c7712001-01-15Mirar (Pontus Hagland)  // use sprintf here; the sums aren't totally equal for doubles (error~=1e-16) 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 sprintf("%.6f",q)]],[[sprintf("%.6f",0.1+1.1+2.1+3.1+8.1+9.1)]])
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 
d638b52002-03-02Martin Stjernholm test_compile_error([[switch (1) {case 1: break; case 1: break;}]]) test_compile_error([[switch (1) {case 1: break; case 0..2: break;}]]) test_compile_error([[switch (1) {case 1..2: break; case 0..3: break;}]]) test_compile_error([[switch (1) {case 1..3: break; case 0..2: break;}]]) test_compile_error([[switch (1) {case 1..2: break; case 0..: break;}]]) test_compile_error([[switch (1) {case 1..2: break; case ..3: break;}]]) test_compile_error([[switch (1) {case 1..: break; case ..3: break;}]]) test_compile_error([[switch (1) {case ..: break;}]]) test_compile_error([[switch (1) {case "x"..: break;}]]) test_compile_error([[switch (1) {case .."y": break;}]]) test_compile_error([[switch (1) {case "x".."y": break;}]]) define(test_switch_ranges,[[ test_any_equal([[ int f (int i) {{$1;} return 0;}; array res = ({}); for (int i = -3; i <= 3; i++) res += ({f (i)}); return res; ]], $2) ]]) test_switch_ranges([[ switch (i) {case 1..2: return 2; case -2..-1: return 1;} ]], ({0, 1, 1, 0, 2, 2, 0})) test_switch_ranges([[ switch (i) {case 1..2: return 2; case -2..0: return 1;} ]], ({0, 1, 1, 1, 2, 2, 0})) test_switch_ranges([[ switch (i) {case 1..2: return 2; case -2..-1: return 1; case 0: return 3;} ]], ({0, 1, 1, 3, 2, 2, 0})) test_switch_ranges([[ switch (i) {case 1..2: return 2; case ..-1: return 1; case 0: return 3;} ]], ({1, 1, 1, 3, 2, 2, 0})) test_switch_ranges([[ switch (i) {case 1..: return 2; case -2..-1: return 1; case 0: return 3;} ]], ({0, 1, 1, 3, 2, 2, 2})) test_switch_ranges([[ switch (i) {case 1..: return 2; case ..-1: return 1; case 0: return 3;} ]], ({1, 1, 1, 3, 2, 2, 2}))
7d80002001-01-10Martin Stjernholm // Breaks and continues with labels
7f97fe2001-01-15Martin Stjernholm test_compile_error([[break;]]) test_compile_error([[continue;]]) test_compile_error([[foo: break;]]) test_compile_error([[foo: continue;]]) test_compile_error([[break foo;]]) test_compile_error([[continue foo;]]) test_any([[foo: break foo; return 1;]], 1) test_compile_error([[foo: continue foo;]])
7d80002001-01-10Martin Stjernholm test_compile_error([[int a; foo: if (a++) a++; else foo: a++;]]) test_compile_error([[int a; foo: foo: if (a++) a++; else a++;]]) test_compile([[int a; foo: if (a++) a++; foo: a++;]]) test_compile_error([[int a; do if (a++) break foo; while (0);]]) test_compile([[int a; do foo: if (a++) break foo; while (0);]]) test_compile([[int a; foo: do if (a++) break foo; while (0);]]) test_compile_error([[int a; do foo: if (a++) continue foo; while (0);]]) test_compile([[int a; foo: do if (a++) continue foo; while (0);]])
7f97fe2001-01-15Martin Stjernholm test_any([[ int i; for (i = 1; i <= 4; i++) foo: break; return i; ]], 1); test_any([[ int i; for (int j = 1; j <= 4; j++) { foo: continue; i = j; } return i; ]], 0);
e9ebb72001-01-15Martin Stjernholm test_any([[ int i; for (i = 1; i <= 4; i++) foo: { if (i > 5) break foo; break; } return i; ]], 1);
7d80002001-01-10Martin Stjernholm test_any_equal([[ int a, b; foo: for (int i = 1; i <= 4; i++) { a = i; switch (1) { case 1: if (i >= 3) break foo; if (i >= 2) continue foo; } b = i; } return ({a, b}); ]], ({3, 1}));
ced3f02001-01-11Martin Stjernholm test_any_equal([[ int a, b; foo: { for (int i = 1; i <= 4; i++) { a = i; switch (1) { case 1: if (i >= 3) break foo; } b = i; } } return ({a, b}); ]], ({3, 2})); test_any_equal([[ array res = ({}); foreach (({1, 2, 3}), int x) { res += ({-x}); foo: foreach (({1, 2, 3, 4}), int i) { res += ({i}); foreach (({1, 2}), int y) { if (i >= 3) break foo; if (i >= 2) continue foo;
7991f12008-01-05Henrik Grubbström (Grubba)  y;
ced3f02001-01-11Martin Stjernholm  } res += ({i}); } } return res; ]], ({-1, 1, 1, 2, 3, -2, 1, 1, 2, 3, -3, 1, 1, 2, 3}));
7d80002001-01-10Martin Stjernholm test_any_equal([[ int a, b; foo: for (int i = 1; i <= 4; i++) { a = i; catch { catch { if (i >= 3) break foo; if (i >= 2) continue foo; }; }; b = i; } return ({a, b}); ]], ({3, 1})); test_any_equal([[ int a, b; foo: for (int i = 1; i <= 4; i++) { a = i; catch { catch { if (i >= 3) break; if (i >= 2) continue; }; }; b += i; } return ({a, b}); ]], ({4, 8}));
7f97fe2001-01-15Martin Stjernholm test_any([[ foo:
72fa462002-09-24Henrik Grubbström (Grubba)  if (stringp (catch {int q=1; break foo;}) + 1) return 1;
7f97fe2001-01-15Martin Stjernholm  else return 2; return 3; ]], 3); test_any([[ foo: do {
72fa462002-09-24Henrik Grubbström (Grubba)  if ((3*time() + 5) + stringp (catch {int q=1; break foo;})) return 1;
7f97fe2001-01-15Martin Stjernholm  else return 2; } while (0); return 3; ]], 3); test_do([[ void gnu (mixed... args) {}; foo: gnu (1,2,3, gauge {break foo;},4,5); ]]); test_do([[ void gnu (mixed... args) {}; foo: gnu (@indices (all_constants()), gauge {break foo;}); ]]); test_do([[ void gnu (mixed... args) {}; foo:
72fa462002-09-24Henrik Grubbström (Grubba)  gnu (1,2,3, catch {int q=1; break foo;},4,5);
7f97fe2001-01-15Martin Stjernholm ]]); test_do([[ void gnu (mixed... args) {}; foo:
72fa462002-09-24Henrik Grubbström (Grubba)  gnu (@indices (all_constants()), catch {int q=1; break foo;});
7f97fe2001-01-15Martin Stjernholm ]]); test_do([[ void gnu (mixed... args) {}; foo:
72fa462002-09-24Henrik Grubbström (Grubba)  gnu (@({1,2,3,4,5}), catch {int q=1; break foo;});
7f97fe2001-01-15Martin Stjernholm ]]); test_do([[ void gnu (mixed... args) {}; foo:
72fa462002-09-24Henrik Grubbström (Grubba)  gnu (@indices (all_constants()), @allocate (511, 1), catch {int q=1; break foo;});
7f97fe2001-01-15Martin Stjernholm ]]); test_do([[ void gnu (mixed... args) {}; foo:
72fa462002-09-24Henrik Grubbström (Grubba)  gnu (@allocate (511, 1), @indices (all_constants()), catch {int q=1; break foo;});
7f97fe2001-01-15Martin Stjernholm ]]); test_compile_error([[ foo: { @indices (all_constants()); break foo; } ]]); test_do([[ // Note: This is valid <= 7.0 code. foreach (({1,2,3}), int j) do if (17 + j + gauge {break;}) return 0; while (0); ]]);
b8efef2008-09-12Henrik Grubbström (Grubba) test_do([[ // Note: This is valid <= 7.0 code. foreach (({1,2,3}), int j) do if (17 - j - gauge {break;}) return 0; while (0); ]]);
7f97fe2001-01-15Martin Stjernholm test_do([[ int gnu (mixed... args) {}; gnu(@indices (all_constants()), gauge { foreach (({1,2,3}), int j) do
7991f12008-01-05Henrik Grubbström (Grubba)  if (j && gnu(@indices (all_constants()),
7f97fe2001-01-15Martin Stjernholm  17 + gauge {break;})) return 0; while (0); }); ]]); test_do([[ int gnu (mixed... args) {}; foo: gnu(@indices (all_constants()), gauge { foreach (({1,2,3}), int j) do
7991f12008-01-05Henrik Grubbström (Grubba)  if (j && gnu(@indices (all_constants()),
7f97fe2001-01-15Martin Stjernholm  17 + gauge {break foo;})) return 0; while (0); }); ]]);
7d80002001-01-10Martin Stjernholm 
694bb11998-04-23Fredrik Hübinette (Hubbe) cond([[all_constants()->_verify_internals]],
c0988f1998-04-17Fredrik Hübinette (Hubbe) [[ test_do(_verify_internals()) ]])
5f174f2003-04-02Martin Nilsson test_compile_any([[import Stdio.Readline; mapping x=([]);]]);
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // testing preprocessor
f3ece81999-02-28Fredrik Hübinette (Hubbe) test_eq([[cpp("#define FOO(X,Y) (X) (Y)\nFOO( (A),(B) )")]],"# 1 \"-\"\n\n( (A) ) ( (B) )") test_eq([[cpp("#define F 'F'\nF")]],"# 1 \"-\"\n\n'F'") test_eq([[cpp("#define MAX(X,Y) ((X)>(Y)?(X):(Y))\n#define MAX3(X,Y,Z) MAX(MAX(X,Y),Z)\nMAX3(1,2,3)")]],"# 1 \"-\"\n\n\n(( (( 1 )>( 2 )?( 1 ):( 2 )) )>( 3 )?( (( 1 )>( 2 )?( 1 ):( 2 )) ):( 3 ))") test_eq([[cpp("foo\xfeff""bar \xfeff gazonk")]],[[cpp("foobar gazonk")]])
7c19af2002-11-01Johan Sundström test_eq([[cpp("#define A(X) #X\n#define B(Y) A(Y)\nB(foo)")]],
4457a82002-11-04Henrik Grubbström (Grubba)  "# 1 \"-\"\n\n\n \"foo\" ")
a191cb2003-09-30Henrik Grubbström (Grubba) test_eq([[cpp("#define FOO(X) X\nFOO(\"\\\n\")\n")]], "# 1 \"-\"\n\n\n \"\" \n"); test_eq([[cpp("#define FOO(X) X\r\nFOO(\"\\\r\n\")\r\n")]], "# 1 \"-\"\n\n\n \"\" \n" /* Note: Added extra space for \r. */);
e19d322003-09-24Martin Stjernholm test_equal([[compile_string("#define FOO(X) X\nstring s=FOO(\"\\\n\\\n\");\nmixed f() {return ({__LINE__, backtrace()[-1][1]});}\n")()->f()]], ({5, 5})); test_equal([[compile_string("#define FOO(X) X\nstring s=FOO(#\"\n\n\");\nmixed f() {return ({__LINE__, backtrace()[-1][1]});}\n")()->f()]], ({5, 5}));
b056b12004-06-30Henrik Grubbström (Grubba) test_equal([[ compile_string("#define FOO BAR\n" "#define TOSTR(X) #X\n" "#define TOSTR2(X) TOSTR(X)\n" "constant val = TOSTR2(FOO);\n")()->val; ]], "BAR") test_equal([[ compile_string("#define FOO\n" "#define TOSTR(X) #X\n" "#define TOSTR2(X) TOSTR(X)\n" "constant val = TOSTR2(FOO);\n")()->val; ]], "") test_equal([[
cc432e2004-06-30Henrik Grubbström (Grubba)  compile_string(Locale.Charset.encoder("ebcdic-us")->
b056b12004-06-30Henrik Grubbström (Grubba)  feed("#charset ebcdic-us\n" "constant val = \"abc\";\n")->drain())()->val; ]], "abc")
13f2e02004-10-31Martin Stjernholm test_eq([[cpp("\\\n")]], "# 1 \"-\"\n\n") test_eq([[cpp("#if 1\\\n-1\nfoo\n#endif\n")]], "# 1 \"-\"\n\n\n\n\n")
c0ed8d2004-11-01Martin Stjernholm test_any([[ Stdio.write_file("testsuite_test.h", ""); return compile_string(#" #include \"\\ testsuite_test.h\" int line = __LINE__; ")()->line; ]], 4)
0bb0f02005-12-06Henrik Grubbström (Grubba) test_do([[cpp(#" #define FOO(X) X FOO(// Pike 7.6 and earlier don't seem to like single /* quotes (') in comments in macro arguments. */ arg)")]])
2a890d2004-10-22Henrik Grubbström (Grubba)  // The following three tests are in triplicate to force testing in all shifts.
b4fed82004-04-21Martin Stjernholm test_do([[ #define FOO(X) X string s = FOO (#"a b c"); ]]);
352d092004-04-22Henrik Grubbström (Grubba) test_do([[ #define FOO(X) X string s = FOO (#"a b c"); ]]); test_do([[ #define FOO(X) X string s = FOO (#"a b c"); ]]);
2a890d2004-10-22Henrik Grubbström (Grubba) test_do([[ #define FOO(X) X string s = FOO (#" "); ]]); test_do([[ #define FOO(X) X string s = FOO (#" "); ]]); test_do([[ #define FOO(X) X string s = FOO (#" "); ]]);
352d092004-04-22Henrik Grubbström (Grubba) test_any([[ #define FOO(X) X FOO ("\ \ "); return __LINE__; ]], 6); test_any([[ #define FOO(X) X FOO ("\ \ "); return __LINE__; ]], 6);
b4fed82004-04-21Martin Stjernholm test_any([[ #define FOO(X) X FOO ("\ \ "); return __LINE__; ]], 6);
f3ece81999-02-28Fredrik Hübinette (Hubbe) 
5164822004-11-14Martin Stjernholm test_any([[ #define ab\u0063 #ifdef \u0061\ bc return 1; #else return 0; #endif ]], 1) test_any([[ #define \U00010330(\U00010331) #\U00010331 #define \U00010332(\U00010333) \U00010330 (\U00010333) #define \U00010334 qth return \U00010332 (\U00010334) ]], "qth") test_any([[ #define \U00010330(\U00010331) #\U00010331 #define \U00010332(\U00010333) \U00010330 (\U00010333) #define \U00010334 \u0220qt\u0222h return \U00010332 (\U00010334) ]], "\x220qt\x222h") test_any([[ #define \U00010330(\U00010331) #\U00010331 #define \U00010332(\U00010333) \U00010330 (\U00010333) #define \U00010334 \U00010330qt\u0222h return \U00010332 (\U00010334) ]], "\x10330qt\x222h") test_program([[ typedef \u0069n\u0074 \u02222; \u0222\u0032 my_\u0223 (\u02222 \u0220) {re\u0074urn \u0220+1\u0031;} int a() {return m\u0079_\u0223 (17) == 28;} ]])
204dc02001-03-23Martin Stjernholm test_eq([[compile_string(#" #define Y(y) #y #define X(x) x(z) string a() {return X(Y);} ")()->a()]], "z") test_eq([[compile_string(#" #define Y() \"z\" #define X(x) x() string a() {return X(Y);} ")()->a()]], "z")
43b2b82004-06-30Henrik Grubbström (Grubba) test_compile([[
204dc02001-03-23Martin Stjernholm #define Y(y) y #define X(x) x() X(Y) ]]) test_compile_error([[
43b2b82004-06-30Henrik Grubbström (Grubba) #define Y(y,z) y #define X(x) x() X(Y) ]]) test_compile_error([[
204dc02001-03-23Martin Stjernholm #define Y() y #define X(x) x(z) X(Y) ]]) test_true([[compile_string(#" #define Y() z #define X(x) x() int z() {return 0;} mixed a() {return functionp(X(Y));} ")()->a()]]) test_false([[compile_string(#" #define Y z #define X(x) x() int z() {return 0;} mixed a() {return functionp(X(Y));} ")()->a()]])
8385b42004-05-27Martin Stjernholm test_do([[
4002982004-05-27Martin Stjernholm  Stdio.write_file("testsuite_test.pmod", "syntax error");
8385b42004-05-27Martin Stjernholm  object orig_master = master(); replace_master(object_program(orig_master)()); mixed err = catch { compile_string(#" #ifdef NONEXISTING_DEFINE #error Not expected #if constant (.testsuite_test) #error Not expected either #endif #endif", "testsuite_test"); }; replace_master(orig_master); if (err) throw (err); ]]); test_do([[
4002982004-05-27Martin Stjernholm  Stdio.write_file("testsuite_test.pmod", "syntax error");
8385b42004-05-27Martin Stjernholm  object orig_master = master(); replace_master(object_program(orig_master)()); mixed err = catch { compile_string(#" #if defined (NONEXISTING_DEFINE) && constant (.testsuite_test) #error Not expected #endif", "testsuite_test"); }; replace_master(orig_master); if (err) throw (err); ]]);
e208cf2001-12-20Martin Stjernholm test_any([[ class handler {mapping get_predefines() {return (["x": "1", "y": "", "z": 0]);}}; return cpp ("x y z p", "-", 0, handler()); ]], "# 1 \"-\"\n1 p"); test_eval_error([[ class handler {mixed get_predefines() {return (<"x">);}}; cpp ("x y z", "-", 0, handler()); ]]); test_eval_error([[ class handler {mapping get_predefines() {return ([0: 0]);}}; cpp ("x y z", "-", 0, handler()); ]]); test_eval_error([[ class handler {mapping get_predefines() {return (["": 1]);}}; cpp ("x y z", "-", 0, handler()); ]]); test_eval_error([[ class handler {mapping get_predefines() {return (["x": 1]);}}; cpp ("x y z", "-", 0, handler()); ]]);
5f174f2003-04-02Martin Nilsson test_true( Stdio.write_file("conftest.h", "return 17;\n") )
1994251999-09-06Fredrik Hübinette (Hubbe) 
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) test_any([[ #include "conftest.h" ]],17) dnltest_any([[ dnl#include <conftest.h> dnl]],17)
5f174f2003-04-02Martin Nilsson 
6110a22007-10-20Henrik Grubbström (Grubba) test_any([[ // bug 2440 (a) #define FILENAME "conftest.h" return #string FILENAME; ]], "return 17;\n") test_any([[ // bug 2440 (b) #define FILENAME "conftest.h" #include FILENAME ]], 17)
0fe1c12007-10-22Henrik Grubbström (Grubba) test_any([[ // Double expansion string FILENAME = ""; #define FILENAME "conftest.h" + FILENAME return #string FILENAME; ]], "return 17;\n")
5f174f2003-04-02Martin Nilsson test_true( rm("conftest.h") )
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) test_true(intp(__LINE__)) test_true(stringp(__FILE__))
89b83e2008-06-29Marcus Comstedt test_eq(dirname(__FILE__),__DIR__)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) test_true(stringp(__DATE__))
e5fac42000-03-09Johan Sundström test_true([[ sscanf(__DATE__, "%3s %d %d", string m, int d, int y) == 3 && search(({"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}), m) != -1 && intp(d) && d>0 && d<32 && intp(y) ]])
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) test_true(stringp(__TIME__))
e5fac42000-03-09Johan Sundström test_true([[ sscanf(__TIME__, "%d:%d:%d", int h, int m, int s) == 3 && intp(h) && intp(m) && intp(s) && h>=0 && m>=0 && s>=0 && h<24 && m<60 && s<61 ]])
ffb7fe1999-12-08Henrik Grubbström (Grubba) test_true(floatp(__VERSION__))
5f174f2003-04-02Martin Nilsson test_true(floatp(__REAL_VERSION__))
ffb7fe1999-12-08Henrik Grubbström (Grubba) test_true(intp(__MAJOR__))
5f174f2003-04-02Martin Nilsson test_true(intp(__REAL_MAJOR__))
ffb7fe1999-12-08Henrik Grubbström (Grubba) test_true(intp(__MINOR__))
5f174f2003-04-02Martin Nilsson test_true(intp(__REAL_MINOR__))
ffb7fe1999-12-08Henrik Grubbström (Grubba) test_true(intp(__BUILD__))
5f174f2003-04-02Martin Nilsson test_true(intp(__REAL_BUILD__)) test_eq(__PIKE__,1)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 
1809f82003-04-10Martin Nilsson test_eq( compile_string("string a=#\"a\nb\";")()->a, "a\nb" ) test_eq( compile_string("string a=#\"a\r\nb\";")()->a, "a\nb" ) test_eq( compile_string("string a=#\"a\n\rb\";")()->a, "a\nb" )
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // #define test_any([[ #define FOOa 1 return FOOa; ]],1) test_any([[ #define FOOa array
7991f12008-01-05Henrik Grubbström (Grubba) FOOa(int) b = ({0}); return sizeof(b);
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) ]],1) test_any([[ #define FOOb 17 #undef FOOb #define FOOb 1 return FOOb; ]],1) test_compile_error([[ #define FOOc FOOc FOO FOO ]])
e435e72000-02-28Fredrik Hübinette (Hubbe) test_any([[ #define FOOa(X) (X) return FOOa(2); ]],2) test_any([[ #define FOOa(X) \ (X) return FOOa(2); ]],2)
2fad1d2000-06-06Fredrik Hübinette (Hubbe) test_any([[ #define FOOa(X) \ (X) return FOOa(3); ]],3)
99656a2000-06-13Fredrik Hübinette (Hubbe) test_any_equal([[ #define FOOa(X,Y...) ({X,Y}) return FOOa(3); ]],({3})) test_any_equal([[ #define FOOa(X,Y...) ({X,Y}) return FOOa(3,4); ]],({3,4})) test_any_equal([[ #define FOOa(X,Y...) ({X,Y}) return FOOa(3,4,5); ]],({3,4,5})) test_any_equal([[ #define FOOa(X,Y...) ({X,Y}) return FOOa(3,4,5,6); ]],({3,4,5,6}))
2fad1d2000-06-06Fredrik Hübinette (Hubbe) test_any([[ #define FOOa(X) "bar\ gazonk" return FOOa(3); ]],"bargazonk") test_any([[ #define FOOa(X) "bar\ gazonk" return FOOa(3); ]],"bargazonk")
e435e72000-02-28Fredrik Hübinette (Hubbe) 
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // /* */ test_any([[ /* return 99; * / /* */ return 1; ]],1)
20d9f92003-08-10Martin Nilsson test_any([[ /* return 99; // */ return 1; ]],1)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // // test_any([[ // return 99;
20d9f92003-08-10Martin Nilsson return 1; // return 47;
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) ]],1)
20d9f92003-08-10Martin Nilsson // #! test_any([[ #! int i=4; int i=3; #! i=5; return i; ]],3)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // #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)
8b665c2004-11-02Martin Stjernholm test_if_true('n' == 110)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // #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)
82dfbd2004-11-14Martin Nilsson test_any([[ #if 0 #blahong #endif return 1; ]],1)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // #if efun
2de3791997-02-11Fredrik Hübinette (Hubbe) // see test for add_constant()
e5bb7d1996-09-23Fredrik Hübinette (Hubbe)  // #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)
e573932004-04-16Martin Nilsson // #if constant test_any([[ #if constant(Foo.Bar) return 0; #else return 1; #endif ]],1) test_any([[ #if constant(Foo) && constant(Bar) return 0; #else return 1; #endif ]],1) test_any([[ #if constant(String.Buffer) return 1; #else return 0; #endif ]],1) test_any([[ #if constant(String.Bar) return 0; #else return 1; #endif ]],1) test_any([[ #if constant(String) && constant(String.Bar) return 0; #else return 1; #endif ]],1)
7048422004-07-05Martin Nilsson test_compile_error([[ #if constant() constant foo=1; #endif ]])
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // #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
c23dba2008-06-28Martin Nilsson test_compile_warning([[
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) #pragma whatever return 1;
c23dba2008-06-28Martin Nilsson ]])
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 
a3196f2008-06-28Martin Nilsson test_compile_warning([[ class A { nomask int x; } ]]) test_do([[ #pragma no_deprecation_warnings class A { nomask int x; } ]]) test_compile_warning([[ #pragma no_deprecation_warnings #pragma deprecation_warnings class A { nomask int x; } ]])
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // #include
ac87152000-09-25Fredrik Hübinette (Hubbe) test_compile_any([[ #pike 7.0 #include <simulate.h>
a3a6c21998-04-19Fredrik Hübinette (Hubbe) ]])
e664411998-04-27Fredrik Hübinette (Hubbe) // #error test_compile_error([[ #error Gurgel ]])
fb59d22004-02-07Martin Nilsson // #warning test_compile_warning([[ #warning Gurgel ]])
20d9f92003-08-10Martin Nilsson // <<<<<<< test_eval_error( cpp("<<<<<<<") ) test_compile_error([[ #if 0 <<<<<<< #endif ]])
7b4c2a2001-05-17Fredrik Hübinette (Hubbe) define(do_test_cpp_string,[[ test_eq([[ (({""}) + (string)indices("."*256)/"" + ({""})) * $1]], [[ Stdio.write_file("testsuite.tmp",a()),compile_string("string s=#string \"testsuite.tmp\";")()->s ]]) ]]) do_test_cpp_string([["0"]]) do_test_cpp_string([["1"]]) do_test_cpp_string([["2"]]) do_test_cpp_string([["3"]]) do_test_cpp_string([["4"]]) do_test_cpp_string([["5"]]) do_test_cpp_string([["6"]]) do_test_cpp_string([["7"]]) do_test_cpp_string([["8"]]) do_test_cpp_string([["9"]]) do_test_cpp_string([["a"]]) do_test_cpp_string([["A"]]) do_test_cpp_string([["\\"]]) do_test_cpp_string([["\\\\"]]) do_test_cpp_string([["\\\\\\"]]) do_test_cpp_string([["\""]])
8538192001-05-29Henrik Grubbström (Grubba) // #undef inside an evaluation of the macro. test_compile_error([[ #define LOCALE(X,Y) (Y) #define DEFVAR(X, Y) ret[(X)]=my_defvar((X),(Y),vars) DEFVAR("cm_wa", Sitebuilder.SBConnect()-> ChooseWorkareaVariable(LOCALE(0, "Work area") + LOCALE(0, "Work area"), LOCALE(0, "the")); DEFVAR("cr_startpage", Variable.URLList(LOCALE(0, "Crawling behaviour") + LOCALE(0, "Start pages"), "")); #undef DEFVAR constant cif_defines = #" <input align='&_.img-align;' type='image' name='&_.name;' value='&_.contents;' src='&var.url;' border='0' /> </define>"; ]])
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // 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))
12cec82003-01-15Martin Nilsson test_eq($1 (typeof(1)), 0)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) ]]) 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)
2de3791997-02-11Fredrik Hübinette (Hubbe) // add_constant test_do(add_constant("foobar",lambda() { return 1; }))
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) test_any([[ #if efun(foobar) return 1; #else return 0; #endif ]],1) test_eq(foobar(),1)
2de3791997-02-11Fredrik Hübinette (Hubbe) test_do(add_constant("foobar"))
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) test_any([[ #if efun(foobar) return 1; #else return 0; #endif ]],0)
12cec82003-01-15Martin Nilsson  // #### Test everything in all_constants. // - __automap__ // - __empty_program // - __null_program // - __parse_pike_type // - __placeholder_object // - _describe_program // - _disable_threads // - _do_call_outs // - _exit // - _leak // - _memory_usage // - _next // - _prev // - _refs // - _static_modules // - _typeof // - _verify_internals cond([[all_constants()->_verify_internals]], [[ test_do(_verify_internals()) ]]) // - `! // - `!= // - `% // - `& // - `() // - `* // - `+ test_eq(`+(1,1),2) test_eq(`+(1,-2),-1) test_eq(`+(-2,-2),-4) test_eq(`+("hi","there"),"hithere") test_eq(`+("hi\777","there"),"hi\777there") test_eq(`+("hi","there\777"),"hithere\777") test_eq(`+("hi\7777777","there"),"hi\7777777there") test_eq(`+("hi","there\7777777"),"hithere\7777777") 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]))
274c862005-09-14Marcus Comstedt test_equal(17+class{mixed ``+(mixed n){return (<n>);}}(),(<17>)) cond([[ sizeof( cpp("__AUTO_BIGNUM__")/"__AUTO_BIGNUM__" ) == 1 ]], [[ test_equal(1700000000000000000000+class{mixed ``+(mixed n){return (<n>);}}(),(<1700000000000000000000>))
d644c12009-03-15Martin Stjernholm ]]) cond( [[ sizeof( cpp("__AUTO_BIGNUM__")/"__AUTO_BIGNUM__" ) == 1 && master()->resolv("Gmp")->mpz ]], [[ test_eval_error(Gmp.mpz(1700000000000000000000)+class{mixed ``+(mixed n){return (<n>);}}())
274c862005-09-14Marcus Comstedt ]])
12cec82003-01-15Martin Nilsson // - `- // - `-> // - `->= // - `/ // - `< // - `<< // - `<= // - `== // - `> // - `>= // - `>> // - `[] // - `[]= // - `^ // - `| // - `~ // - abs // - acos // Tested in _math // - add_constant
1d96e72003-01-15Martin Nilsson test_compile_error(int a=grunk(5);) test_do(add_constant("grunk",abs)) test_do(int a=grunk(5);) test_do(add_constant("grunk")) test_compile_error(int a=grunk(5);)
12cec82003-01-15Martin Nilsson  // - add_include_path // - add_module_path // - add_program_path // Tested in lib
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // - aggregate
12cec82003-01-15Martin Nilsson test_equal(aggregate(),({}))
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) test_equal(aggregate(1,2,3,4),({1,2,3,4}))
7f20c02008-01-13Martin Nilsson test_equal(aggregate(1,2)+aggregate(3,4),({1,2,3,4})) test_equal(aggregate(@({1,2,3,4})),({1,2,3,4})) test_equal(aggregate(@({7})*50),({7})*50)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe)  // - aggregate_multiset
12cec82003-01-15Martin Nilsson test_equal(aggregate_multiset(), (<>)) test_equal(aggregate_multiset(1,1), (<1,1>)) test_equal(aggregate_multiset(1,2,"3"), (<1,2,"3">))
e5bb7d1996-09-23Fredrik Hübinette (Hubbe)  // - aggregate_mapping
12cec82003-01-15Martin Nilsson test_equal(aggregate_mapping(), ([])) test_equal(aggregate_mapping(1,2,3,4), ([1:2,3:4])) test_eval_error(aggregate_mapping(1,2,3)) // - alarm
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 
694bb11998-04-23Fredrik Hübinette (Hubbe) // - all_constants
2de3791997-02-11Fredrik Hübinette (Hubbe) test_true(mappingp(all_constants())) test_eq(all_constants()["all_constants"],all_constants)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 
12cec82003-01-15Martin Nilsson // - all_threads
281d4a2003-01-20Marcus Comstedt cond([[all_constants()->thread_create]], [[ test_true(arrayp(all_threads())) test_true(sizeof(all_threads())) test_true(objectp(all_threads()[0])) ]])
12cec82003-01-15Martin Nilsson 
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // - allocate
12cec82003-01-15Martin Nilsson test_equal(allocate(0),({}))
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) test_equal(allocate(2),({0,0})) test_false(allocate(2)==({0,0}))
12cec82003-01-15Martin Nilsson test_equal(allocate(2,2),({2,2}))
f9abcf1999-09-16Fredrik Hübinette (Hubbe) test_true(allocate(65536,random))
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 
12cec82003-01-15Martin Nilsson // - array_sscanf // - arrayp // Tested in foop // - asin // - atan // - atan2 // Tested in _math // - atexit
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // - backtrace test_true(arrayp(backtrace())) test_eq(backtrace()[-1][2],a)
12cec82003-01-15Martin Nilsson // - basename // Tested in lib // - basetype
1d96e72003-01-15Martin Nilsson test_eq(basetype(0),"int") test_eq(basetype(0.0),"float") test_eq(basetype(""),"string") test_eq(basetype(({})),"array") test_eq(basetype(({1})),"array") test_eq(basetype((<>)),"multiset") test_eq(basetype(([])),"mapping") test_eq(basetype(class {}),"program") test_eq(basetype(class {}()),"object") test_eq(basetype(abs),"function") test_eq(basetype(lambda(){}),"function") test_eq(basetype(typeof(0)),"type")
12cec82003-01-15Martin Nilsson 
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // - 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))
12cec82003-01-15Martin Nilsson // - call_out // - call_out_info
039ef72004-04-29Martin Nilsson 
12cec82003-01-15Martin Nilsson // - callablep
039ef72004-04-29Martin Nilsson test_true( callablep(time) ) test_true( callablep(String.capitalize) ) test_true( callablep(CommonLog.read) ) test_true( callablep(ADT.Stack) ) test_true( callablep(String.Buffer) ) test_true( callablep( class { void `()() { } }() ) ) test_false( callablep(String.Buffer()) ) test_true( callablep( ({}) ) ) test_true( callablep( ({ 0,0 }) ) ) test_false( callablep( ({ 0,1 }) ) ) test_true( callablep( ({ time }) ) ) test_true( callablep( ({ time, 0 }) ) ) test_false( callablep( ({ "a", time }) ) ) test_false( callablep( ({ "" }) ) ) test_false( callablep( "" ) ) test_false( callablep( 3.14 ) ) test_false( callablep( (< time >) ) ) test_false( callablep( 0 ) ) test_false( callablep( 7 ) )
12cec82003-01-15Martin Nilsson // - cd // - ceil // Tested in _math // - chmod // - chown // - chroot // - cleargroups
8f9f212002-11-28Martin Nilsson // - new/clone
8cde8d2002-11-28Martin Nilsson test_true([[ #pike 7.2 objectp(new(compile_string("int foo() { return 17; }"))) ]]) test_eq([[ #pike 7.2 new(compile_string("int foo() { return 17; }"))->foo() ]],17)
8f9f212002-11-28Martin Nilsson test_true([[ #pike 7.2 objectp(clone(compile_string("int foo() { return 17; }"))) ]]) test_eq([[ #pike 7.2 clone(compile_string("int foo() { return 17; }"))->foo() ]],17)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 
12cec82003-01-15Martin Nilsson // - closelog
1d96e72003-01-15Martin Nilsson 
12cec82003-01-15Martin Nilsson // - column
1d96e72003-01-15Martin Nilsson 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})]])
bcd8012003-04-28Martin Stjernholm test_any_equal([[ array a = ({({(["foo": 17])})}); mixed res = column (a, "foo"); // Avoid constant optimization. return res && a[0][0]; ]], (["foo": 17]))
12cec82003-01-15Martin Nilsson 
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // - combine_path test_eq([[combine_path("/foo/bar/gazonk/","..")]],"/foo/bar")
269aae2001-06-08Henrik Grubbström (Grubba) test_eq([[combine_path("/foo/bar/gazonk","..")]],"/foo/bar") test_eq([[combine_path("/foo/bar/", "gazonk")]],"/foo/bar/gazonk") test_eq([[combine_path("/foo/bar", "gazonk")]],"/foo/bar/gazonk")
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) test_eq([[combine_path("/.../","sune")]],"/.../sune")
0577581997-08-27Henrik Grubbström (Grubba) test_eq([[combine_path("/",".")]],"/")
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 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/../../../..")]],"/")
b603cd1997-08-26Fredrik Hübinette (Hubbe) test_eq([[combine_path("/","..")]],"/") test_eq([[combine_path("./","..")]],"..") test_eq([[combine_path("./.","..")]],"..")
9674d41997-11-13Fredrik Hübinette (Hubbe) test_eq([[combine_path("/","../../foo")]],"/foo")
b603cd1997-08-26Fredrik Hübinette (Hubbe) test_eq([[combine_path("./foobar/.","..")]],".")
086bfa1998-04-09Fredrik Hübinette (Hubbe) test_eq([[combine_path("/","foo","bar","gazonk")]],"/foo/bar/gazonk")
1b54052001-06-11Henrik Grubbström (Grubba) test_eq([[combine_path("/", "foo", "")]], "/foo/")
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 
8e06782001-06-07Fredrik Hübinette (Hubbe) test_eq([[combine_path("/","/foo/bar/ga\11111zonk/../../")]],"/foo/") test_eq([[combine_path("/","/fo\1111/bar/ga\11111zonk/../../")]],"/fo\1111/") test_eq([[combine_path("/","/fo\1111/bar/gazonk/../../")]],"/fo\1111/")
12cec82003-01-15Martin Nilsson 
51d2a52004-05-01Martin Stjernholm test_eq([[combine_path("foo", "../bar")]],"bar") test_eq([[combine_path("foo/", "../bar")]],"bar") test_eq([[combine_path("foo/", "../bar/")]],"bar/") test_eq([[combine_path("foo/.", "../bar")]],"bar") test_eq([[combine_path("foo", "..")]],".") test_eq([[combine_path("foo/", "..")]],".") test_eq([[combine_path("foo/.", "..")]],".") test_eq([[combine_path(".", "bar")]],"bar") test_eq([[combine_path("./", "bar")]],"bar") test_eq([[combine_path(".", "../bar")]],"../bar") test_eq([[combine_path("./", "../bar")]],"../bar")
12cec82003-01-15Martin Nilsson // - combine_path_nt
8e06782001-06-07Fredrik Hübinette (Hubbe) test_eq([[combine_path_nt("/","/fo\1111/bar/gazonk/../../")]],"/fo\1111/") test_eq([[combine_path_nt("a:/","/fo\1111/bar/gazonk/../../")]],"a:/fo\1111/")
7ea8b42001-06-29Henrik Grubbström (Grubba) test_eq([[combine_path_nt("a:/", "/foo","bar")+combine_path_nt("/foo","bar")]], "a:/foo/bar/foo/bar")
8e06782001-06-07Fredrik Hübinette (Hubbe) 
12cec82003-01-15Martin Nilsson // - combine_path_unix test_eq([[combine_path_unix("/","/fo\1111/bar/gazonk/../../")]],"/fo\1111/")
01bab71999-11-23Fredrik Noring 
12cec82003-01-15Martin Nilsson // - compile
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // - compile_file // - compile_string // see test for clone()
d644c12009-03-15Martin Stjernholm cond_begin([[all_constants()->thread_create]])
60dd6d1999-07-01Henrik Grubbström (Grubba)  test_any([[ string file = #" /*
b4fed82004-04-21Martin Stjernholm  * Attempt to trig the lex.current_file == NULL bug.
60dd6d1999-07-01Henrik Grubbström (Grubba)  * * Henrik Grubbström 1999-07-01 */ string file = Stdio.File(__FILE__, \"r\")->read(); void thread_func() { int i;
7874611999-07-04Fredrik Hübinette (Hubbe)  for (i=0; i < 1000; i++) {
60dd6d1999-07-01Henrik Grubbström (Grubba)  compile_string(file); } } int main(int argc, array(string) argv) {
7874611999-07-04Fredrik Hübinette (Hubbe)  array(object) a = allocate(10, thread_create)(thread_func);
60dd6d1999-07-01Henrik Grubbström (Grubba)  a->wait(); return 0; } ";
b3c32a1999-07-04Henrik Grubbström (Grubba)  allocate(10, thread_create)(lambda() {
60dd6d1999-07-01Henrik Grubbström (Grubba)  int i;
b3c32a1999-07-04Henrik Grubbström (Grubba)  for(i = 0; i < 1000; i++) {
60dd6d1999-07-01Henrik Grubbström (Grubba)  compile_string(file);
402b142008-12-15Martin Stjernholm  // These watchdog calls shouldn't be necessary - the timeframe // is at least 20 minutes between two calls, so doing these can // extend the test time to up to 20000 minutes before the // watchdog kicks in.. /mast
349ec02008-12-14Martin Stjernholm  //if (!(i%10)) // __signal_watchdog();
402b142008-12-15Martin Stjernholm  //if (!(i % 100)) // write ("%s: %O at %d\n", ctime (time())[..<1], this_thread(), i);
60dd6d1999-07-01Henrik Grubbström (Grubba)  } } )->wait(); return 0; ]], 0)
d644c12009-03-15Martin Stjernholm  cond_end // thread_create
60dd6d1999-07-01Henrik Grubbström (Grubba) 
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // - 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)
7f20c02008-01-13Martin Nilsson test_eq(copy_value(typeof(true)),typeof(true))
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 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 >) )
a44f1a2000-09-15Martin Stjernholm test_true(get_weak_flag(copy_value(set_weak_flag(({17}), 1)))) test_true(get_weak_flag(copy_value(set_weak_flag((<17>), 1))))
b3fedb2000-09-15Martin Stjernholm test_true(get_weak_flag(copy_value(set_weak_flag(([17:17]), 1)))) test_true(get_weak_flag(copy_value(set_weak_flag(([17:({17})]), 1))))
b0bc822001-08-09Martin Stjernholm test_any([[ array x = ({0}); x[0] = x; return equal (copy_value (x), x); ]], 1) test_any([[ mapping x = ([]); x[x] = x; return equal (copy_value (x), x); ]], 1) test_any([[ multiset x = (<>); x[x] = 1; return equal (copy_value (x), x); ]], 1)
c272062002-12-12Martin Nilsson test_any([[ array a=({0,0,0}); array b=copy_value(a); b[0]=17; b[1]=42; b[2]=128; return equal( ({0,0,0}), a) && equal( ({17,42,128}), b); ]], 1)
6bd4cc2004-05-28Henrik Grubbström (Grubba) test_any([[ // Bug 3693 array(mapping) a = ({([])})*2; return a[0] == a[1]; ]], 1)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 
12cec82003-01-15Martin Nilsson // - cos // Tested in _math // - cpp
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // - crypt test_true(stringp(crypt("hej"))) test_true(crypt("hej",crypt("hej")))
8cde8d2002-11-28Martin Nilsson test_true(crypt("hej","Oz5i0K.16qkgA")) test_true(crypt("hej","buf8/Z7taE6qs")) test_true(crypt("123456789", crypt("123456780")))
fb61ba1998-04-26Fredrik Hübinette (Hubbe) test_false(crypt("hej","hej")) test_false(crypt("h","hej"))
8cde8d2002-11-28Martin Nilsson test_false(crypt("hej","buf8/Z7taE6qst")) test_false(crypt("hej","buf8/Z7taE6q"))
e5bb7d1996-09-23Fredrik Hübinette (Hubbe)  // - ctime
8e77102002-12-01Martin Nilsson test_eq(ctime(0)[-1],'\n')
1d96e72003-01-15Martin Nilsson test_do([[int t = -1; catch(ctime(t));]])
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 
12cec82003-01-15Martin Nilsson // - decode_value // - delay // - describe_backtrace // - describe_error
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // - destruct
2de3791997-02-11Fredrik Hübinette (Hubbe) test_do(add_constant("PROG",compile_string("int foo() { return 1; }")));
2aeef52002-11-26Martin Nilsson test_any([[object o=PROG(); destruct(o); return o]],0); test_any([[object o=PROG(); destruct(o); return objectp(o)]],0); test_any([[array(object) o=({PROG()}); destruct(o[0]); return o-({0}) ]],({})); test_any([[mapping o=(["foo":PROG()]); destruct(o["foo"]); return o["foo"]; ]],0); dnl test_any([[object t; mapping o=([t=PROG():"foo"]); destruct(t); return sizeof(o)]],0); test_do([[object t; array(object) o=({}); o+=({t=PROG()}); destruct(t); o=({});]]);
9040cc2002-10-14Martin Nilsson test_do(add_constant("PROG"))
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 
12cec82003-01-15Martin Nilsson // - dirname // Tested in lib // - encode_value // - encode_value_canonic // - endgrent // - endpwent
c350602003-03-01Martin Nilsson 
12cec82003-01-15Martin Nilsson // - enumerate
c350602003-03-01Martin Nilsson // Tested in lib
15b4dc2002-01-31Henrik Grubbström (Grubba) 
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // - equal
15eb1b1998-02-24Henrik Grubbström (Grubba) // equal is already tested by this script
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 
12cec82003-01-15Martin Nilsson // - errno // - error // Tested in lib // - exece
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // - exit
12cec82003-01-15Martin Nilsson // - exp // Tested in _math
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 
12cec82003-01-15Martin Nilsson // - explode_path // - file_stat // - file_truncate // - filesystem_stat
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 
12cec82003-01-15Martin Nilsson // - filter // Tested in lib/modules // - find_call_out // - floatp // Tested in foop // - floor // Tested in _math // - fork
c0988f1998-04-17Fredrik Hübinette (Hubbe) 
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // - 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)
12cec82003-01-15Martin Nilsson // - function_program // - functionp // Tested in foop
c350602003-03-01Martin Nilsson // - gc // gc is already tested above
12cec82003-01-15Martin Nilsson // - get_all_groups
c350602003-03-01Martin Nilsson ifefun(get_all_groups,[[ test_true(arrayp(get_all_groups())) test_any([[ foreach(get_all_groups(), array group) foreach(group; int pos; array(string)|int|string value) switch(pos) { case 0: case 1: if(!stringp(value)) return 0; break; case 2: if(!intp(value)) return 0; break; case 3: if(!arrayp(value)) return 0; foreach(value, string user) if(!stringp(user)) return 0; break; } return 1; ]], 1) ]])
12cec82003-01-15Martin Nilsson // - get_all_users
c350602003-03-01Martin Nilsson ifefun(get_all_users,[[ test_true(arrayp(get_all_users())) test_any([[ foreach(get_all_users(), array user) foreach(user; int pos; int|string value) switch(pos) { case 0: case 1: case 4: case 5: case 6: if(!stringp(value)) return 0; break; case 2: case 3: if(!intp(value)) return 0; break; } return 1; ]], 1) ]])
12cec82003-01-15Martin Nilsson // - get_dir
c350602003-03-01Martin Nilsson test_do(Stdio.recursive_rm("get_dir_test")) test_do(mkdir("get_dir_test")) test_equal(get_dir("get_dir_test"),({})) test_do(Stdio.write_file("get_dir_test/x", "x")); test_equal(get_dir("get_dir_test"),({"x"})) test_do(Stdio.recursive_rm("get_dir_test"))
82dfbd2004-11-14Martin Nilsson test_true(arrayp(get_dir()))
c350602003-03-01Martin Nilsson 
12cec82003-01-15Martin Nilsson // - get_groups_for_user // - get_weak_flag
c350602003-03-01Martin Nilsson 
12cec82003-01-15Martin Nilsson // - getcwd
c350602003-03-01Martin Nilsson test_true(stringp(getcwd())) test_true(sizeof(getcwd())) test_do(Stdio.recursive_rm("getcwd_test")) test_do(mkdir("getcwd_test")) test_any([[ string a = getcwd(); cd("getcwd_test"); string b = getcwd(); cd(".."); #ifdef __NT__ return a==getcwd() && b==a+"\\getcwd_test"; #else return a==getcwd() && b==a+"/getcwd_test"; #endif ]], 1) test_do(Stdio.recursive_rm("getcwd_test"))
12cec82003-01-15Martin Nilsson // - getegid
ed47cc2003-03-13Martin Nilsson ifefun(getegid,[[ test_true(intp(getegid())) test_true(getegid()==getegid()) ]])
12cec82003-01-15Martin Nilsson // - getenv
ed47cc2003-03-13Martin Nilsson 
12cec82003-01-15Martin Nilsson // - geteuid
ed47cc2003-03-13Martin Nilsson ifefun(geteuid,[[ test_true(intp(geteuid())) test_true(geteuid()==geteuid()) ]])
12cec82003-01-15Martin Nilsson // - getgid
ed47cc2003-03-13Martin Nilsson ifefun(getgid,[[ test_true(intp(getgid())) test_true(getgid()==getgid()) ]])
12cec82003-01-15Martin Nilsson // - getgrent // - getgrgid // - getgrnam // - getgroups // - gethostbyaddr // - gethostbyname
c350602003-03-01Martin Nilsson 
12cec82003-01-15Martin Nilsson // - gethostname
c350602003-03-01Martin Nilsson test_true(stringp(gethostname())) test_true(sizeof(gethostname()))
12cec82003-01-15Martin Nilsson  // - gethrtime // See time // - gethrvtime
ed47cc2003-03-13Martin Nilsson 
12cec82003-01-15Martin Nilsson // - getpgrp
ed47cc2003-03-13Martin Nilsson ifefun(getpgrp,[[ test_true(intp(getpgrp())) test_true(getpgrp()==getpgrp()) ]])
12cec82003-01-15Martin Nilsson // - getpid
ed47cc2003-03-13Martin Nilsson ifefun(getpid,[[ test_true(intp(getpid())) test_true(getpid()==getpid()) ]])
12cec82003-01-15Martin Nilsson // - getppid
ed47cc2003-03-13Martin Nilsson ifefun(getppid,[[ test_true(intp(getppid())) test_true(getppid()==getppid()) ]])
12cec82003-01-15Martin Nilsson // - getpwent // - getpwnam // - getpwuid
c350602003-03-01Martin Nilsson 
12cec82003-01-15Martin Nilsson // - getsid
c350602003-03-01Martin Nilsson ifefun(getsid,[[ test_true(intp(getsid())) test_true(getsid()==getsid()) ]])
12cec82003-01-15Martin Nilsson // - getuid
c350602003-03-01Martin Nilsson ifefun(getuid,[[ test_true(intp(getuid())) test_true(getuid()==getuid()) ]])
1d96e72003-01-15Martin Nilsson 
12cec82003-01-15Martin Nilsson // - glob
1d96e72003-01-15Martin Nilsson test_false(glob("","a")) test_false(glob("a","")) test_false(glob("?","")) test_true(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"})]])
e195ea2004-04-29Martin Nilsson test_eval_error([[ array a=({"a","b",3}); return glob("*", a); ]])
9523d42008-07-04Martin Stjernholm test_equal([[glob("foo", ({}))]], ({}))
1d96e72003-01-15Martin Nilsson 
12cec82003-01-15Martin Nilsson // - gmtime
1d96e72003-01-15Martin Nilsson cond([[all_constants()->localtime && all_constants()->mktime]],[[ test_do([[int t = -1; catch(gmtime(t));]]) ]])
12cec82003-01-15Martin Nilsson // - hardlink // - has_index
c4c8c72003-08-05Martin Stjernholm define(test_has_index,[[test_any([[mixed foo=$1; return has_index(foo,$2)==$3;]], 1)]])
12cec82003-01-15Martin Nilsson test_has_index([[ ({}) ]],0,0) test_has_index([[ ({}) ]],"foo",0) test_has_index([[ ({ "a" }) ]],-1,0) test_has_index([[ ({ "a" }) ]],"a",0) test_has_index([[ ({ "a" }) ]],0,1) test_has_index([[ ({ "a" }) ]],1,0) test_has_index([[ ({ "a", "b" }) ]],1,1) test_has_index([[ ([ "a":"A" ]) ]],4711,0) test_has_index([[ ([ "a":"A" ]) ]],"a",1) test_has_index([[ ([ "a":"A" ]) ]],"A",0) test_has_index([[ ([ "a":"A", "b":"B", "c":"C" ]) ]],"b",1) test_has_index([[ ([ "a":"A", "b":"B", "c":"C" ]) ]],"B",0)
c4c8c72003-08-05Martin Stjernholm test_has_index([[ (< "a" >) ]],4711,0) test_has_index([[ (< "a" >) ]],"a",1) test_has_index([[ (< "a" >) ]],"A",0) test_has_index([[ (< "a", "b", "c" >) ]],"b",1) test_has_index([[ (< "a", "b", "c" >) ]],"B",0)
12cec82003-01-15Martin Nilsson test_has_index([[ class {}() ]],"foo",0) test_has_index([[ (class{array _indices(){return({"a","b"});}})() ]],"b",1) // - has_prefix
c350602003-03-01Martin Nilsson test_true(has_prefix("abc","a")) test_false(has_prefix("abc","b")) test_true(has_prefix("abc","")) test_true(has_prefix("","")) test_false(has_prefix("","abc")) test_true(has_prefix("\666abc","\666a"))
12cec82003-01-15Martin Nilsson // - has_suffix
c350602003-03-01Martin Nilsson test_true(has_suffix("cba","a")) test_false(has_suffix("cba","b")) test_true(has_suffix("abc","")) test_true(has_suffix("","")) test_false(has_suffix("","abc")) test_true(has_suffix("cba\666","a\666"))
12cec82003-01-15Martin Nilsson  // - has_value define(test_has_value,[[test_true([[mixed foo=$1; return has_value(foo,$2)==$3;]])]]) test_has_value([[ ({}) ]],0,0) test_has_value([[ ({}) ]],"foo",0) test_has_value([[ ({ "a" }) ]],-1,0) test_has_value([[ ({ "a" }) ]],"a",1) test_has_value([[ ({ "a" }) ]],0,0) test_has_value([[ ({ "a", "b" }) ]],"b",1) test_has_value([[ ([ "a":"A" ]) ]],4711,0) test_has_value([[ ([ "a":"A" ]) ]],"a",0) test_has_value([[ ([ "a":"A" ]) ]],"A",1) test_has_value([[ ([ "a":"A", "b":"B", "c":"C" ]) ]],"B",1) test_has_value([[ ([ "a":"A", "b":"B", "c":"C" ]) ]],"b",0) test_has_value([[ class {}() ]],"foo",0) test_has_value([[ (class{array _values(){return({"a","b"});}})() ]],"b",1)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe)  // - hash
c350602003-03-01Martin Nilsson test_eq(hash("foo"),2091538203) test_eq(hash("foo",10),3) test_eq(hash("bar"),2091518428) test_eq(hash("bar",10),8)
c601052003-03-02Henrik Grubbström (Grubba) test_eq(hash("b\666arqwerty1234"),1829582221)
c350602003-03-01Martin Nilsson test_eq(hash(""),0)
e46bf22004-05-14Martin Nilsson test_eval_error( return hash("foo",0) ) test_eval_error( return hash("foo",-1) )
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 
c601052003-03-02Henrik Grubbström (Grubba) // - hash_7_4 define(test_hash_7_4, [[
7907332008-06-29Henrik Grubbström (Grubba)  ignore_warning("Calling a deprecated value.", [[
c601052003-03-02Henrik Grubbström (Grubba)  test_any([[ int i = hash_7_4($1); return ]]dnl ifelse([[$3]],,, [[((i==$2)||(i==$3))?$2:]])dnl
7907332008-06-29Henrik Grubbström (Grubba) [[i; ]], $2) ]]) test_any([[ int i = 7.4::hash($1); return ]]dnl ifelse([[$3]],,, [[((i==$2)||(i==$3))?$2:]])dnl
c601052003-03-02Henrik Grubbström (Grubba) [[i; ]], $2) test_any([[ #pike 7.4 int i = hash($1); return ]]dnl ifelse([[$3]],,, [[((i==$2)||(i==$3))?$2:]])dnl [[i; ]], $2) ]]) test_hash_7_4("foo",2091538203) test_hash_7_4([["foo",10]],3) test_hash_7_4("bar",2091518428) test_hash_7_4([["bar",10]],8) test_hash_7_4("b\666arqwerty1234", 2142487018, 1858424874) test_hash_7_4("",0)
7907332008-06-29Henrik Grubbström (Grubba) test_eval_error( return 7.4::hash("foo",0) )
c601052003-03-02Henrik Grubbström (Grubba) 
12cec82003-01-15Martin Nilsson // - hash_7_0
c601052003-03-02Henrik Grubbström (Grubba) define(test_hash_7_0, [[
7907332008-06-29Henrik Grubbström (Grubba)  ignore_warning("Calling a deprecated value.", [[
c601052003-03-02Henrik Grubbström (Grubba)  test_any([[ int i = hash_7_0($1); return ]]dnl ifelse([[$3]],,, [[((i==$2)||(i==$3))?$2:]])dnl
7907332008-06-29Henrik Grubbström (Grubba) [[i; ]], $2) ]]) test_any([[ int i = 7.0::hash($1); return ]]dnl ifelse([[$3]],,, [[((i==$2)||(i==$3))?$2:]])dnl
c601052003-03-02Henrik Grubbström (Grubba) [[i; ]], $2)
c350602003-03-01Martin Nilsson  test_any([[ #pike 7.0
c601052003-03-02Henrik Grubbström (Grubba)  int i = hash($1); return ]]dnl ifelse([[$3]],,, [[((i==$2)||(i==$3))?$2:]])dnl [[i; ]], $2)
c350602003-03-01Martin Nilsson ]])
c601052003-03-02Henrik Grubbström (Grubba) test_hash_7_0("foo",27734) test_hash_7_0([["foo",10]],4) test_hash_7_0("bar",26689) test_hash_7_0([["bar",10]],9) test_hash_7_0("b\666arqwerty1234", 2142487018, 1858424874) test_hash_7_0("",0)
e46bf22004-05-14Martin Nilsson test_eval_error( return hash_7_0("foo",0) )
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 
7f20c02008-01-13Martin Nilsson // - hash_value define(test_hash_value, [[ test_true(intp(hash_value($1)))
9222142008-04-20Henrik Grubbström (Grubba)  dnl Make sure the value to hash has a chance at surviving the optimizer... test_do(add_constant("test_value", $1))
7f20c02008-01-13Martin Nilsson  test_eq(hash_value($1),hash_value($1))
9222142008-04-20Henrik Grubbström (Grubba)  test_do(add_constant("test_value"))
7f20c02008-01-13Martin Nilsson ]]) test_hash_value(77) test_hash_value(5.0) test_hash_value("hello") test_hash_value(({}))
1233072008-01-16Henrik Grubbström (Grubba) dnl (<>) is mutable. test_true(intp(hash_value((<>)))) dnl ([]) is mutable. test_true(intp(hash_value(([]))))
7f20c02008-01-13Martin Nilsson test_hash_value(time) test_hash_value(ADT.Stack) dnl test_hash_value(String) test_hash_value(typeof(true))
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // - indices test_equal(indices("foo"),({0,1,2})) test_equal(indices(({'f','o','o'})),({0,1,2}))
2de3791997-02-11Fredrik Hübinette (Hubbe) 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}))
e9c6891999-03-01Henrik Grubbström (Grubba) test_equal(mkmultiset(indices(class{constant a="a"; constant b="b";}())), (<"a","b">))
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 
12cec82003-01-15Martin Nilsson // - initgroups // - innetgrp // - int2char // - int2hex // Tested in String // - intp // Tested in foop // - is_absolute_path // Tested in lib // - kill // - load_module
1d96e72003-01-15Martin Nilsson 
12cec82003-01-15Martin Nilsson // - localtime
1d96e72003-01-15Martin Nilsson cond([[all_constants()->localtime]],[[ test_true(mappingp(localtime(0))) test_do([[int t = -1; catch(localtime(t));]]) ]]) cond([[all_constants()->localtime && all_constants()->mktime]], [[ test_any([[int x=time(); return mktime(localtime(x)) == x;]], 1) test_any([[int x=time(); for(int y=0;y<100;y++) if(mktime(localtime(x+y)) != x+y) return x+y; return 0;]], 0) ]])
12cec82003-01-15Martin Nilsson  // - log // Tested in _math
15eb1b1998-02-24Henrik Grubbström (Grubba) 
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // - lower_case test_equal(lower_case("foo"),"foo") test_equal(lower_case("Foo"),"foo") test_equal(lower_case("Foo1234-*~\n"),"foo1234-*~\n")
14d0881999-03-20Henrik Grubbström (Grubba) test_equal(lower_case("foo\x3000"),"foo\x3000") test_equal(lower_case("Foo\x3000"),"foo\x3000") test_equal(lower_case("Foo1234-*~\n\x3000"),"foo1234-*~\n\x3000") test_equal(lower_case("foo\x13000"),"foo\x13000") test_equal(lower_case("Foo\x13000"),"foo\x13000") test_equal(lower_case("Foo1234-*~\n\x13000"),"foo1234-*~\n\x13000")
8229a01999-03-20Fredrik Hübinette (Hubbe) test_equal(lower_case("Foo\x178"),"foo\xff")
0cb4152000-07-19Andreas Lange test_equal(lower_case("Foo\x39c"),"foo\x3bc")
b4cb871999-03-20Henrik Grubbström (Grubba) test_equal(lower_case((string) ({
7913702002-04-29Henrik Grubbström (Grubba) // These characters correspond to the cases in case_info.h // Please update this and the corresponding upper_case table // when UnicodeData.txt is changed.
97478f2003-01-29Marcus Comstedt // Part 1: 0x0000 - 0x0FFF
70a6932008-05-29Martin Nilsson 0x0000, 0x0041, 0x005b, 0x0061, 0x007b, 0x00b5, 0x00b6, 0x00c0, 0x00d7, 0x00d8, 0x00df, 0x00e0, 0x00f7, 0x00f8, 0x00ff, 0x0100, 0x0130, 0x0131, 0x0132, 0x0138, 0x0139, 0x0149, 0x014a, 0x0178, 0x0179, 0x017f, 0x0180, 0x0181, 0x0182, 0x0186, 0x0187, 0x0189, 0x018b, 0x018d, 0x018e, 0x018f, 0x0190, 0x0191, 0x0193, 0x0194, 0x0195, 0x0196, 0x0197, 0x0198, 0x019a, 0x019b, 0x019c, 0x019d, 0x019e, 0x019f, 0x01a0, 0x01a6, 0x01a7, 0x01a9, 0x01aa, 0x01ac, 0x01ae, 0x01af, 0x01b1, 0x01b3, 0x01b7, 0x01b8, 0x01ba, 0x01bc, 0x01be, 0x01bf, 0x01c0, 0x01c4, 0x01c5, 0x01c7, 0x01c8, 0x01ca, 0x01cb, 0x01dd, 0x01de, 0x01f0, 0x01f1, 0x01f2, 0x01f6, 0x01f7, 0x01f8, 0x0220, 0x0221, 0x0222, 0x0234, 0x023a, 0x023b, 0x023d, 0x023e, 0x023f, 0x0241, 0x0243, 0x0244, 0x0245, 0x0246, 0x0250, 0x0251, 0x0252, 0x0253, 0x0254, 0x0255, 0x0256, 0x0258, 0x0259, 0x025a, 0x025b, 0x025c, 0x0260, 0x0261, 0x0263, 0x0264, 0x0268, 0x0269, 0x026a, 0x026b, 0x026c, 0x026f, 0x0270, 0x0271, 0x0272, 0x0273, 0x0275, 0x0276, 0x027d, 0x027e, 0x0280, 0x0281, 0x0283, 0x0284, 0x0288, 0x0289, 0x028a, 0x028c, 0x028d, 0x0292, 0x0293, 0x0345, 0x0346, 0x0370, 0x0374, 0x0376, 0x0378, 0x037b, 0x037e, 0x0386, 0x0387, 0x0388, 0x038b, 0x038c, 0x038d, 0x038e, 0x0390, 0x0391, 0x03a0, 0x03a2, 0x03a3, 0x03ac, 0x03ad, 0x03b0, 0x03b1, 0x03c0, 0x03c2, 0x03c3, 0x03cc, 0x03cd, 0x03cf, 0x03d0, 0x03d1, 0x03d2, 0x03d5, 0x03d6, 0x03d7, 0x03d8, 0x03f0, 0x03f1, 0x03f2, 0x03f3, 0x03f4, 0x03f5, 0x03f6, 0x03f7, 0x03f9, 0x03fa, 0x03fc, 0x03fd, 0x0400, 0x0410, 0x0420, 0x0430, 0x0440, 0x0450, 0x0460, 0x0482, 0x048a, 0x04c0, 0x04c1, 0x04cf, 0x04d0, 0x0524, 0x0531, 0x0557, 0x0561, 0x0587 })),
f74e872006-12-29Martin Nilsson (string) ({
70a6932008-05-29Martin Nilsson 0x0000, 0x0061, 0x005b, 0x0061, 0x007b, 0x00b5, 0x00b6, 0x00e0, 0x00d7, 0x00f8, 0x00df, 0x00e0, 0x00f7, 0x00f8, 0x00ff, 0x0101, 0x0069, 0x0131, 0x0133, 0x0138, 0x013a, 0x0149, 0x014b, 0x00ff, 0x017a, 0x017f, 0x0180, 0x0253, 0x0183, 0x0254, 0x0188, 0x0256, 0x018c, 0x018d, 0x01dd, 0x0259, 0x025b, 0x0192, 0x0260, 0x0263, 0x0195, 0x0269, 0x0268, 0x0199, 0x019a, 0x019b, 0x026f, 0x0272, 0x019e, 0x0275, 0x01a1, 0x0280, 0x01a8, 0x0283, 0x01aa, 0x01ad, 0x0288, 0x01b0, 0x028a, 0x01b4, 0x0292, 0x01b9, 0x01ba, 0x01bd, 0x01be, 0x01bf, 0x01c0, 0x01c6, 0x01c6, 0x01c9, 0x01c9, 0x01cc, 0x01cc, 0x01dd, 0x01df, 0x01f0, 0x01f3, 0x01f3, 0x0195, 0x01bf, 0x01f9, 0x019e, 0x0221, 0x0223, 0x0234, 0x2c65, 0x023c, 0x019a, 0x2c66, 0x023f, 0x0242, 0x0180, 0x0289, 0x028c, 0x0247, 0x0250, 0x0251, 0x0252, 0x0253, 0x0254, 0x0255, 0x0256, 0x0258, 0x0259, 0x025a, 0x025b, 0x025c, 0x0260, 0x0261, 0x0263, 0x0264, 0x0268, 0x0269, 0x026a, 0x026b, 0x026c, 0x026f, 0x0270, 0x0271, 0x0272, 0x0273, 0x0275, 0x0276, 0x027d, 0x027e, 0x0280, 0x0281, 0x0283, 0x0284, 0x0288, 0x0289, 0x028a, 0x028c, 0x028d, 0x0292, 0x0293, 0x0345, 0x0346, 0x0371, 0x0374, 0x0377, 0x0378, 0x037b, 0x037e, 0x03ac, 0x0387, 0x03ad, 0x038b, 0x03cc, 0x038d, 0x03cd, 0x0390, 0x03b1, 0x03c0, 0x03a2, 0x03c3, 0x03ac, 0x03ad, 0x03b0, 0x03b1, 0x03c0, 0x03c2, 0x03c3, 0x03cc, 0x03cd, 0x03d7, 0x03d0, 0x03d1, 0x03d2, 0x03d5, 0x03d6, 0x03d7, 0x03d9, 0x03f0, 0x03f1, 0x03f2, 0x03f3, 0x03b8, 0x03f5, 0x03f6, 0x03f8, 0x03f2, 0x03fb, 0x03fc, 0x037b, 0x0450, 0x0430, 0x0440, 0x0430, 0x0440, 0x0450, 0x0461, 0x0482, 0x048b, 0x04cf, 0x04c2, 0x04cf, 0x04d1, 0x0524, 0x0561, 0x0557, 0x0561, 0x0587 }))
97478f2003-01-29Marcus Comstedt test_equal(lower_case((string) ({ // These characters correspond to the cases in case_info.h // Please update this and the corresponding upper_case table // when UnicodeData.txt is changed. // Part 2: 0x1000 -
70a6932008-05-29Martin Nilsson 0x10a0, 0x10c6, 0x1d79, 0x1d7a, 0x1d7d, 0x1d7e, 0x1e00, 0x1e96, 0x1e9b, 0x1e9c, 0x1e9e, 0x1e9f, 0x1ea0, 0x1f00, 0x1f08, 0x1f10, 0x1f16, 0x1f18, 0x1f1e, 0x1f20, 0x1f28, 0x1f30, 0x1f38, 0x1f40, 0x1f46, 0x1f48, 0x1f4e, 0x1f51, 0x1f52, 0x1f53, 0x1f54, 0x1f55, 0x1f56, 0x1f57, 0x1f58, 0x1f59, 0x1f5a, 0x1f5b, 0x1f5c, 0x1f5d, 0x1f5e, 0x1f5f, 0x1f60, 0x1f68, 0x1f70, 0x1f72, 0x1f76, 0x1f78, 0x1f7a, 0x1f7c, 0x1f7e, 0x1f80, 0x1f88, 0x1f90, 0x1f98, 0x1fa0, 0x1fa8, 0x1fb0, 0x1fb2, 0x1fb3, 0x1fb4, 0x1fb8, 0x1fba, 0x1fbc, 0x1fbd, 0x1fbe, 0x1fbf, 0x1fc3, 0x1fc4, 0x1fc8, 0x1fcc, 0x1fcd, 0x1fd0, 0x1fd2, 0x1fd8, 0x1fda, 0x1fdc, 0x1fe0, 0x1fe2, 0x1fe5, 0x1fe6, 0x1fe8, 0x1fea, 0x1fec, 0x1fed, 0x1ff3, 0x1ff4, 0x1ff8, 0x1ffa, 0x1ffc, 0x1ffd, 0x2126, 0x2127, 0x212a, 0x212b, 0x212c, 0x2132, 0x2133, 0x214e, 0x214f, 0x2160, 0x2180, 0x2183, 0x2185, 0x24b6, 0x24d0, 0x24ea, 0x2c00, 0x2c2f, 0x2c30, 0x2c5f, 0x2c60, 0x2c62, 0x2c63, 0x2c64, 0x2c65, 0x2c66, 0x2c67, 0x2c6d, 0x2c6e, 0x2c6f, 0x2c70, 0x2c72, 0x2c74, 0x2c75, 0x2c77, 0x2c80, 0x2ce4, 0x2d00, 0x2d26, 0xa640, 0xa660, 0xa662, 0xa66e, 0xa680, 0xa698, 0xa722, 0xa730, 0xa732, 0xa770, 0xa779, 0xa77d, 0xa77e, 0xa788, 0xa78b, 0xa78d, 0xff21, 0xff3b, 0xff41, 0xff5b, 0x10400, 0x10428,
f74e872006-12-29Martin Nilsson 0x10450 })), (string) ({
70a6932008-05-29Martin Nilsson 0x2d00, 0x10c6, 0x1d79, 0x1d7a, 0x1d7d, 0x1d7e, 0x1e01, 0x1e96, 0x1e9b, 0x1e9c, 0x00df, 0x1e9f, 0x1ea1, 0x1f00, 0x1f00, 0x1f10, 0x1f16, 0x1f10, 0x1f1e, 0x1f20, 0x1f20, 0x1f30, 0x1f30, 0x1f40, 0x1f46, 0x1f40, 0x1f4e, 0x1f51, 0x1f52, 0x1f53, 0x1f54, 0x1f55, 0x1f56, 0x1f57, 0x1f58, 0x1f51, 0x1f5a, 0x1f53, 0x1f5c, 0x1f55, 0x1f5e, 0x1f57, 0x1f60, 0x1f60, 0x1f70, 0x1f72, 0x1f76, 0x1f78, 0x1f7a, 0x1f7c, 0x1f7e, 0x1f80, 0x1f80, 0x1f90, 0x1f90, 0x1fa0, 0x1fa0, 0x1fb0, 0x1fb2, 0x1fb3, 0x1fb4, 0x1fb0, 0x1f70, 0x1fb3, 0x1fbd, 0x1fbe, 0x1fbf, 0x1fc3, 0x1fc4, 0x1f72, 0x1fc3, 0x1fcd, 0x1fd0, 0x1fd2, 0x1fd0, 0x1f76, 0x1fdc, 0x1fe0, 0x1fe2, 0x1fe5, 0x1fe6, 0x1fe0, 0x1f7a, 0x1fe5, 0x1fed, 0x1ff3, 0x1ff4, 0x1f78, 0x1f7c, 0x1ff3, 0x1ffd, 0x03c9, 0x2127, 0x006b, 0x00e5, 0x212c, 0x214e, 0x2133, 0x214e, 0x214f, 0x2170, 0x2180, 0x2184, 0x2185, 0x24d0, 0x24d0, 0x24ea, 0x2c30, 0x2c2f, 0x2c30, 0x2c5f, 0x2c61, 0x026b, 0x1d7d, 0x027d, 0x2c65, 0x2c66, 0x2c68, 0x0251, 0x0271, 0x0250, 0x2c70, 0x2c73, 0x2c74, 0x2c76, 0x2c77, 0x2c81, 0x2ce4, 0x2d00, 0x2d26, 0xa641, 0xa660, 0xa663, 0xa66e, 0xa681, 0xa698, 0xa723, 0xa730, 0xa733, 0xa770, 0xa77a, 0x1d79, 0xa77f, 0xa788, 0xa78c, 0xa78d, 0xff41, 0xff3b, 0xff41, 0xff5b, 0x10428, 0x10428,
f74e872006-12-29Martin Nilsson 0x10450 }))
b4cb871999-03-20Henrik Grubbström (Grubba) 
12cec82003-01-15Martin Nilsson // - m_delete // - map // - mappingp // Tested in foop // - master // - max // - min // Tested in _math // - mkdir
ed47cc2003-03-13Martin Nilsson 
12cec82003-01-15Martin Nilsson // - mkmapping
ed47cc2003-03-13Martin Nilsson test_equal(mkmapping(({}),({})), ([])) test_equal(mkmapping(({0}),({0})), ([0:0])) test_any_equal([[ array a=({"a"}); return mkmapping(a,a); ]], (["a":"a"])) test_equal(mkmapping( ({({})}),({({})}) )[ ({}) ], ({}))
12cec82003-01-15Martin Nilsson // - mkmultiset
ed47cc2003-03-13Martin Nilsson test_equal(mkmultiset(({})), (<>)) test_equal(mkmultiset(({0})), (<0>)) test_equal(mkmultiset(({(<>)})), (<(<>)>))
1d96e72003-01-15Martin Nilsson 
12cec82003-01-15Martin Nilsson // - mktime
1d96e72003-01-15Martin Nilsson cond([[all_constants()->mktime]], [[ test_true([[mktime( ([ "sec":58, "isdst":1, "year":98, "mon":3, "mday":26, "hour":1, "min":51 ]))]]) test_eq([[mktime(58,51,1,26,3,98,1,0)]],[[mktime( ([ "sec":58, "isdst":1, "year":98, "mon":3, "mday":26, "hour":1, "min":51, "timezone":0, ]) ) ]])
3114ac2004-02-03Marcus Comstedt  test_any([[foreach(({1075550400,94691300,220921700,347152100,473382500, 599612900,725843300,852073700,978304100,1104534500, 1230764900,1356995300,1483225700,1609456100,1735686500, 1861916900,1988147300,2114377700
724f4b2004-12-15Martin Stjernholm  }),int t) { int res = mktime (gmtime (t)); if(res!=t) return ({t, res}); } return 0;]], 0)
3114ac2004-02-03Marcus Comstedt 
7785682007-03-29Martin Stjernholm  test_eq(mktime (0, 0, 0, -200, -6, 101, 0, 0), 945043200); test_eq(mktime (0, 0, 0, -1, 2, 107, 0, 0), 1172534400); test_eq(mktime (0, 0, 0, 200, 1, 107, 0, 0), 1187481600); test_eq(mktime (200, 200, 200, 200, 1, 107, 0, 0), 1188213800); test_eq(mktime (-200, -200, -200, 200, 1, 107, 0, 0), 1186749400); test_any( [[ // bug [2861] ------------------------------------------------------------ // http://community/crunch/show_bug.cgi?id=2861 return mktime(0,0,0,1,0,70,0,0); ]], 0) test_any( [[ // bug [3270] ------------------------------------------------------------ // http://community/crunch/show_bug.cgi?id=3270 // Tue, 15 Oct 2002 09:38:32 GMT return mktime(32, 38, 9, 15, 9, 102, 0, 0); ]], 1034674712)
1d96e72003-01-15Martin Nilsson ]])
12cec82003-01-15Martin Nilsson  // - multisetp // Tested in foop // - mv
e5bb7d1996-09-23Fredrik Hübinette (Hubbe)  // - next_object
c29a252003-02-08Martin Stjernholm test_true(objectp(next_object()) || intp(next_object()) && next_object()) test_any([[ object o=next_object(); for(int e=0; e<10000 && (objectp(o) || intp(o) && o); e++) o=next_object(o); return o; ]], 0)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 
12cec82003-01-15Martin Nilsson // - normalize_path // Tested in lib
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // - object_program test_true(programp(object_program(this_object())))
12cec82003-01-15Martin Nilsson // - object_variablep // - openlog // - pow // Tested in _math // - programp // Tested in foop // - putenv // Tested in lib
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // - 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)
f218802001-06-05Fredrik Hübinette (Hubbe) test_eq([[ random( ({11,21,31,41}) ) % 10 ]], 1) test_eq([[ random( ({11,21,31,41}) ) % 10 ]], 1) test_eq([[ random( ({11,21,31,41}) ) % 10 ]], 1) test_eq([[ random( ({11,21,31,41}) ) % 10 ]], 1) test_eq([[ random( (<11,21,31,41>) ) % 10 ]], 1) test_eq([[ random( (<11,21,31,41>) ) % 10 ]], 1) test_eq([[ random( (<11,21,31,41>) ) % 10 ]], 1) test_eq([[ random( (<11,21,31,41>) ) % 10 ]], 1) test_eq([[ random( (<11,21,31,41>) ) % 10 ]], 1) test_eq([[ random( (<11,21,31,41>) ) % 10 ]], 1) test_eq([[ `-( @random( ([11:21,31:41]) )) ]], -10) test_eq([[ `-( @random( ([11:21,31:41]) )) ]], -10) test_eq([[ `-( @random( ([11:21,31:41]) )) ]], -10) test_eq([[ `-( @random( ([11:21,31:41]) )) ]], -10) test_eval_error([[ return random( ({}) ) ]]) test_eval_error([[ return random( (<>) ) ]]) test_eval_error([[ return random( ([]) ) ]]) test_eq([[ random( class() { int _random() { return 17; }}()) ]], 17)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 
12cec82003-01-15Martin Nilsson // - random_seed
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 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)]])
386b412003-03-28Marcus Comstedt test_equal([[random_seed(4711),map(allocate(10,1000), random)]], [[({598,11,331,991,383,553,997,53,272,381})]])
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 
12cec82003-01-15Martin Nilsson // - random_string
e46bf22004-05-14Martin Nilsson test_eq( sizeof(random_string(47)), 47 ) test_eq( random_string(0), "" ) test_eval_error( return random_string(-1); )
12cec82003-01-15Martin Nilsson // - readlink // - remove_call_out // - remove_include_path // - remove_module_path // - remove_program_path // Tested in lib
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // - replace
e5a1451999-06-30Fredrik Hübinette (Hubbe) test_eq(replace("foo","f","\x9999"),"\x9999oo") test_eq(replace("foo",({"f"}),({"\x9999"})),"\x9999oo")
7e97c31999-01-21Fredrik Hübinette (Hubbe) test_eq([[replace("11013",({"1","100","108","13","1069","1067","106","10"}), ({"A","B","C","D","E","F","G","H"}))]],"AHD") test_eq([[replace("1264412124",({"126","124","12","122","1260"}), ({"13333","13335","883","13329","226709"}))]],"133334488313335")
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 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")
7e97c31999-01-21Fredrik Hübinette (Hubbe) test_eq(replace("test\ntest\n\ntest\ntest",({"\n","\n\n"}),({" ","<p>"})),"test test<p>test test") test_eq(replace("test\ntest\n\ntest\ntest",({"\n\n","\n"}),({"<p>"," "})),"test test<p>test test")
8c8c462001-06-27Henrik Grubbström (Grubba) test_eq(replace("\xfffffff0", ({ "\xfffffff0" }), ({ "" })), "")
9040cc2002-10-14Martin Nilsson test_eq([[ replace("abcdefg", ([ "a":"x", "d":"y", "h":"z" ])) ]], "xbcyefg")
7e97c31999-01-21Fredrik Hübinette (Hubbe) 
e27ab21999-03-30Henrik Grubbström (Grubba) test_eq("123\000456""890"-"\0", "123\456""890") test_eq("123\456000""890"-"\0", "123\456000""890")
6377672001-06-01Henrik Grubbström (Grubba) test_any([[ array a=({ 1 }); replace(a,1,2); return a[0]; ]], 2) test_any([[ mapping a=([ 1:1 ]); replace(a,1,2); return a[1]; ]], 2)
7e97c31999-01-21Fredrik Hübinette (Hubbe) test_any([[
3488ef2000-04-17Henrik Grubbström (Grubba) function reference=lambda(string x, array(string) a, array(string) b)
7e97c31999-01-21Fredrik Hübinette (Hubbe) { string ret=""; for(int pos=0;pos<strlen(x);) { int best=-1; int bestlen=-1; for(int e=0;e<sizeof(a);e++) { if(strlen(a[e])>bestlen) { if(x[pos..pos+strlen(a[e])-1] == a[e]) { best=e; bestlen=strlen(a[e]); } } } if(best==-1) { ret+=x[pos..pos]; pos++; }else{ ret+=b[best]; pos+=bestlen; } } return ret; }; for(int e=0;e<10000;e++) {
3488ef2000-04-17Henrik Grubbström (Grubba)  array(string) base=(array(string)) ( (({random})*(1+random(10)))(20) );
7e97c31999-01-21Fredrik Hübinette (Hubbe)  for(int d=0;d<random(random(40));d++) base+=({ base[ random(sizeof(base))] + random(10) }); base=Array.uniq(base);
18cfc12002-05-24Martin Nilsson  array(string) to=(array(string))Array.map(base,hash);
7e97c31999-01-21Fredrik Hübinette (Hubbe)  string text=""; for(int d=0;d<1+random(random(50));d++) { if(random(2)) text+=base[ random(sizeof(base))]; else text+=sprintf("%2d",random(100)); } string r1=replace(text,base,to); string r2=reference(text,base,to); if(r1 != r2) {
fa41962002-10-18Henrik Grubbström (Grubba)  werror("\nFailure:\n");
7e97c31999-01-21Fredrik Hübinette (Hubbe)  werror("Text: %O\n",text); werror("From: %O\n",base); werror("To : %O\n",to); werror("Builtin: %O\n",r1); werror("Ref : %O\n",r2); return -1; } } return 1; ]],1)
3e625c1998-10-11Fredrik Hübinette (Hubbe)  test_eq(replace("f\777\777bargaz\777nk","\777","-"),"f--bargaz-nk") test_eq(replace("f\777\777bargaz\777nk",({"\777","a"}),({"()","<>"})),"f()()b<>rg<>z()nk") test_eq(replace("f\777\777barf\777\777",({"f\777\777","f\777\777bar"}),({"f\777\777bar","f\777\777"})),"f\777\777f\777\777bar") test_eq(replace("f\777\777barf\777\777",({"f\777\777bar","f\777\777"}),({"f\777\777","f\777\777bar"})),"f\777\777f\777\777bar") test_eq(replace("f\7777777\7777777bargaz\7777777nk","\7777777","-"),"f--bargaz-nk") test_eq(replace("f\7777777\7777777bargaz\7777777nk",({"\7777777","a"}),({"()","<>"})),"f()()b<>rg<>z()nk") test_eq(replace("f\7777777\7777777barf\7777777\7777777",({"f\7777777\7777777","f\7777777\7777777bar"}),({"f\7777777\7777777bar","f\7777777\7777777"})),"f\7777777\7777777f\7777777\7777777bar") test_eq(replace("f\7777777\7777777barf\7777777\7777777",({"f\7777777\7777777bar","f\7777777\7777777"}),({"f\7777777\7777777","f\7777777\7777777bar"})),"f\7777777\7777777f\7777777\7777777bar")
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 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]))
e195ea2004-04-29Martin Nilsson test_eval_error([[ mapping a = ([ "a":"b", 3:"c" ]); return replace("bar", a); ]]) test_eval_error([[ mapping a = ([ "a":"b", "c":3 ]); return replace("bar", a); ]]) test_eval_error([[ return replace("bar", ({"a"}), ({"b","c"})); ]])
12cec82003-01-15Martin Nilsson // - replace_master
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // - reverse test_eq(reverse("reverse"),"esrever")
0bc4cf1998-10-13Fredrik Hübinette (Hubbe) test_eq(reverse("r\777v\777rs\777"),"\777sr\777v\777r") test_eq(reverse("r\7777777v\7777777rs\7777777"),"\7777777sr\7777777v\7777777r")
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) test_eq(reverse(""),"") test_eq(reverse("a"),"a") test_equal(reverse(({1,5,9})),({9,5,1}))
04a1ae2000-12-13Fredrik Noring test_equal(reverse(({})),({})) test_equal(reverse(({42})),({42})) test_equal(reverse(({42,4711})),({4711,42}))
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) test_equal(reverse(0x12345678),0x1e6a2c48)
12cec82003-01-15Martin Nilsson // - rm
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 
12cec82003-01-15Martin Nilsson // - round // Tested in _math
b7d3322000-01-21Fredrik Noring 
12cec82003-01-15Martin Nilsson // - rows
1d96e72003-01-15Martin Nilsson 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})]])
b7d3322000-01-21Fredrik Noring 
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // - search
be1daa1999-11-15Henrik Grubbström (Grubba) test_eval_error(return search("foolbar","o",-10)) test_eval_error(return search("foolbar","o",2983742))
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) test_eq(search("foolbar","gazonk"),-1) test_eq(search("qowiueproqiuweproiwqueoplkjljlklksjjriwueproiuwerowieu","lkjljlklksjj"),24) test_eq(search("lkjljlklksjjriwueproiuwerlskjdvlaskjfowieu","lkjljlklksjj"),0) test_eq(search("aaaaaaaaaaaaaaaaaaaaaaaalkjljlklksjj","lkjljlklksjj"),24)
53ec792004-03-07Martin Nilsson  // Search cache is initialized with 10 slots. test_eq(search("aaaaaaaaaaaaaaaaaaaaaaaalkjljlklksjj1","lkjljlklksjj1"),24) test_eq(search("aaaaaaaaaaaaaaaaaaaaaaaalkjljlklksjj2","lkjljlklksjj2"),24) test_eq(search("aaaaaaaaaaaaaaaaaaaaaaaalkjljlklksjj3","lkjljlklksjj3"),24) test_eq(search("aaaaaaaaaaaaaaaaaaaaaaaalkjljlklksjj4","lkjljlklksjj4"),24) test_eq(search("aaaaaaaaaaaaaaaaaaaaaaaalkjljlklksjj5","lkjljlklksjj5"),24) test_eq(search("aaaaaaaaaaaaaaaaaaaaaaaalkjljlklksjj6","lkjljlklksjj6"),24) test_eq(search("aaaaaaaaaaaaaaaaaaaaaaaalkjljlklksjj7","lkjljlklksjj7"),24) test_eq(search("aaaaaaaaaaaaaaaaaaaaaaaalkjljlklksjj8","lkjljlklksjj8"),24) test_eq(search("aaaaaaaaaaaaaaaaaaaaaaaalkjljlklksjj9","lkjljlklksjj9"),24) test_eq(search("aaaaaaaaaaaaaaaaaaaaaaaalkjljlklksjj0","lkjljlklksjj0"),24) test_eq(search("aaaaaaaaaaaaaaaaaaaaaaaalkjljlklksjjx","lkjljlklksjjx"),24) test_eq(search("aaaaaaaaaaaaaaaaaaaaaaaalkjljlklksjj","lkjljlklksjj"),24)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) test_eq(search("foobargazonk","oo"),1) test_eq(search("f