1169d92004-05-02Martin Nilsson START_MARKER
4f9a0a2002-09-21Martin Stjernholm  // This triggered a bug only if run sufficiently early.
2144ac2014-11-24Martin Nilsson test_compule_any([[#pike 7.6]])
3daf982014-02-17Martin Nilsson test_compile_any([[#pike 7.8]])
b8ce9d2014-08-24Martin Nilsson test_compile_any([[#pike 8.0]])
63c1a62014-10-05Martin Nilsson test_compile_any([[#pike 8.1]])
2144ac2014-11-24Martin Nilsson test_compile_any([[#pike 8.2]])
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);
3e50212014-08-18Martin Nilsson 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)")
3e50212014-08-18Martin Nilsson test_eq([["(" + 0x7fffffffffffffff + ")"]], "(9223372036854775807)") test_eq([["(" + -0x8000000000000000 + ")"]], "(-9223372036854775808)")
649dce2008-05-21Martin Stjernholm test_eq([["(" + Int.NATIVE_MAX + ")"]], [[sprintf ("(%d)", Int.NATIVE_MAX)]]) test_eq([["(" + Int.NATIVE_MIN + ")"]], [[sprintf ("(%d)", Int.NATIVE_MIN)]])
3362ea2012-07-06Martin Stjernholm test_eq([[Int.NATIVE_MAX]], [[(int) (Int.NATIVE_MAX + "")]]) test_eq([[Int.NATIVE_MIN]], [[(int) (Int.NATIVE_MIN + "")]]) test_eq([[(string) Int.NATIVE_MAX]], [[Int.NATIVE_MAX + ""]]) test_eq([[(string) Int.NATIVE_MIN]], [[Int.NATIVE_MIN + ""]]) test_eq([[(string) Int.NATIVE_MAX]], [[sprintf ("%d", Int.NATIVE_MAX)]]) test_eq([[(string) Int.NATIVE_MIN]], [[sprintf ("%d", Int.NATIVE_MIN)]])
649dce2008-05-21Martin Stjernholm 
137eab2014-08-19Martin Nilsson test_any_equal([[ array res = ({}); array ops = ({ `+, `-, `*, `/, `%, `<<, `>>, `&, `|, `^ }); array nums_a = ({ 0, 1, -1, 0xffffffff, 0xffffffffffffffff }); array nums_b = ({ 0, 1, -1 }); foreach(ops;; function op) foreach(nums_a;; int a) foreach(nums_b;; int b) { mixed err = catch { res += ({ op(a,b) }); }; if( err ) res += ({ "E" }); } return res; ]],[[ ({ // + 0, 1, -1, 1, 2, 0, -1, 0, -2, 0xffffffff, 0x100000000, 0xfffffffe, 0xffffffffffffffff, 0x10000000000000000, 0xfffffffffffffffe, // - 0, -1, 1, 1, 0, 2, -1, -2, 0, 0xffffffff, 0xfffffffe, 0x100000000, 0xffffffffffffffff, 0xfffffffffffffffe, 0x10000000000000000, // * 0, 0, 0, 0, 1, -1, 0, -1, 1, 0, 0xffffffff, -0xffffffff, 0, 0xffffffffffffffff, -0xffffffffffffffff, // / "E", 0, 0, "E", 1, -1, "E", -1, 1, "E", 0xffffffff, -0xffffffff, "E", 0xffffffffffffffff, -0xffffffffffffffff, // % "E", 0, 0, "E", 0, 0, "E", 0, 0, "E", 0, 0, "E", 0, 0, // << 0, 0, "E", 1, 2, "E", -1, -2, "E", 0xffffffff, 0x1fffffffe, "E", 0xffffffffffffffff, 0x1fffffffffffffffe, "E", // >> 0, 0, "E", 1, 0, "E", -1, -1, "E", 0xffffffff, 0x7fffffff, "E", 0xffffffffffffffff, 0x7fffffffffffffff, "E", // & 0, 0, 0, 0, 1, 1, 0, 1, -1, 0, 1, 0xffffffff, 0, 1, 0xffffffffffffffff, // | 0, 1, -1, 1, 1, -1, -1, -1, -1, 0xffffffff, 0xffffffff, -1, 0xffffffffffffffff, 0xffffffffffffffff, -1, // ^ 0, 1, -1, 1, 0, -2, -1, -2, 0, 0xffffffff, 0xfffffffe, -0x100000000, 0xffffffffffffffff, 0xfffffffffffffffe, -0x10000000000000000, }) ]])
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) 
0346dc2014-05-10Martin Nilsson test_compile_error('\3434523423423523423423423423') test_compile_error("\3434523423423523423423423423") test_compile_error("\d109827346981234561823743412654")
9a90b32014-10-22Per Hedbor test_compile_error('\d109827346981234561823743412654')
0346dc2014-05-10Martin Nilsson test_compile_error("\x109a27bc69e256c83deaa34c26b4")
9a90b32014-10-22Per Hedbor test_compile_error('\x109a27bc69e256c83deaa34c26b4')
b168bb2004-11-01Martin Stjernholm test_compile_error('\u17fo')
0346dc2014-05-10Martin Nilsson test_compile_error("\u17fo")
9a90b32014-10-22Per Hedbor  test_eq('012456789abcdefghijklmnopqrstuvwxyz'->digits(256), "012456789abcdefghijklmnopqrstuvwxyz") test_eq('\uu117f', 0x5c7531313766)
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')
0346dc2014-05-10Martin Nilsson test_compile_error("\U117f") test_compile_error("\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")
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)
07b70d2014-10-27Martin Nilsson test_any([[ for(int i; i<10; i++) ; return 1; ]], 1)
9002ef2004-04-29Martin Nilsson test_any([[ // Another over-optimization test. string x(string i) { return i; }; return x("")+1+1; ]], "11")
df23b92009-11-20Henrik Grubbström (Grubba) test_any([[ // Check that parent pointers aren't added unnecessarily [bug 2672]. class I {}; class X { // Neither the inherit nor the variable type should add // a parent pointer requirement. inherit I; I i; }; X x = ((program) X)(); // Error: Parent lost, cannot clone program. return 0; ]], 0)
2045362011-03-28Henrik Grubbström (Grubba) test_any([[
df23b92009-11-20Henrik Grubbström (Grubba)  // Check that parent pointers aren't added unnecessarily [bug 2672]. class I {}; class X {
2045362011-03-28Henrik Grubbström (Grubba)  // The cloning of I makes X need its parent usually, // but note that since we're nested in a function // scope by the testsuite, I will not be overloadable, // and thus we won't need the parent.
df23b92009-11-20Henrik Grubbström (Grubba)  inherit I; I i = I(); }; X x = ((program) X)(); // Error: Parent lost, cannot clone program. return 0; ]], 0)
2045362011-03-28Henrik Grubbström (Grubba) test_eval_error([[ class Wrapper { // Check that parent pointers aren't added unnecessarily [bug 2672]. class I {} class X { // The cloning of I makes X need its parent. inherit I; I i = I(); } }; object x = ((program) (Wrapper()->X))(); // Error: Parent lost, cannot clone program. return 0; ]], 0) test_any([[ // Check that parent pointers aren't added unnecessarily [LysLysKOM 18781511]. class Foo { final constant const = 1; class Bar { int func() { // parent-pointer not needed, since const is final. return const; }; } }; return !Foo.Bar; ]], 0)
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; } ]])
1273162014-07-02Arne Goedeke define(test_string_range,[[ test_any([[ string s = (string) ({ $1, $1 }); if (!arrayp(String.range(s))) return "huh?"; // dont optimize this, it forces string range check return search(s, $1); ]], 0) ]]) test_string_range(254); test_string_range(255); test_string_range((1<<16)-1); test_string_range((1<<16)+1); test_string_range((1<<29)-1); test_string_range((1<<29)+1); test_string_range((1<<31)-1); test_string_range(-(1<<31));
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([[
50ab1c2010-07-12Martin Stjernholm  log_status("Testing scoped variables $1:$2%s...", $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) 
774f9a2011-03-21Martin Stjernholm test_eval_error([[ // [Bug 5911] class X { string s; }; X()->s = (mixed) X(); ]])
b0dfbb2011-09-04Martin Nilsson test_any([[ // Bug 6062 class C { mapping options = ([ 1:1 ]); }; C c = C(); c->options[3] = 3; c = C(); return sizeof(c->options) == 1; ]], 1)
6c98ca2011-09-05Henrik Grubbström (Grubba) test_any([[ // Bug 6063 class A { extern string s; string q() { return s; } }; class B { inherit A; string s = "s"; }; class C { inherit B; }; class D { inherit C; }; return ({ B(), C(), D() })->q() * ""; ]], "sss")
6bf0fa2011-09-12Henrik Grubbström (Grubba) test_any([[ // bug 6065 class A(string s) {}; class B(string s) { inherit A; }; return B("foo")->s; ]], "foo")
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 ]]);
f61d772013-12-12Henrik Grubbström (Grubba) dnl Check the derived return type of sprintf(). test_any([[return sprintf("%O", typeof(sprintf("%1H", "foo"))); ]],
a2f2422014-01-05Henrik Grubbström (Grubba)  "string(8bit)");
f61d772013-12-12Henrik Grubbström (Grubba) test_any([[return sprintf("%O", typeof(sprintf("foo"))); ]], "string(102..111)"); test_any([[return sprintf("%O", typeof(sprintf("foo%c", 17))); ]], "string(17..17 | 102..111)"); test_any([[return sprintf("%O", typeof(sprintf("%2c\n", 'a'))); ]],
a2f2422014-01-05Henrik Grubbström (Grubba)  "string(8bit)");
8b2dd42014-08-31Henrik Grubbström (Grubba) dnl Note the following tests the return type of int2char().
f61d772013-12-12Henrik Grubbström (Grubba) test_any([[return sprintf("%O", typeof(sprintf("%c", 1023))); ]], "string(1023..1023)"); test_any([[return sprintf("%O", typeof(sprintf("%c\n", 1023))); ]], "string(10..10 | 1023..1023)");
8b2dd42014-08-31Henrik Grubbström (Grubba) dnl The following is due to (string & sprintf_result) == sprintf_result.
f61d772013-12-12Henrik Grubbström (Grubba) test_any([[return sprintf("%O", typeof(sprintf("%c\n", Stdio))); ]],
8b2dd42014-08-31Henrik Grubbström (Grubba)  sprintf("%O", sprintf_result));
f61d772013-12-12Henrik Grubbström (Grubba) test_any([[return sprintf("%O", typeof(sprintf("%4[1]c", 17))); ]],
a2f2422014-01-05Henrik Grubbström (Grubba)  "string(8bit)");
f61d772013-12-12Henrik Grubbström (Grubba) test_any([[return sprintf("%O", typeof(sprintf("%[1]n", 17))); ]], "string(zero)");
b347262013-06-03Martin Nilsson test_any([[return sprintf("%O", typeof(aggregate("foo")));]], "array(string(102..111))");
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){
0b8d2f2013-06-17Martin Nilsson  return Charset.decoder("utf-8")->feed(s)->drain();
32efc92003-03-07Henrik Grubbström (Grubba)  })) ]], [[ "function(string : string)" ]])
9d3a7a2005-02-18Henrik Grubbström (Grubba) // Test implicit lambda. test_eq([[ `()(){ return 1; } ]], 1)
d967202004-02-28Martin Stjernholm // Argument checking
bed4582012-07-12Henrik Grubbström (Grubba) // Test new_check_call.
c287ef2012-07-18Henrik Grubbström (Grubba) test_any([[
bed4582012-07-12Henrik Grubbström (Grubba)  constant foo = 5; // Test that it survives a F_ARG_LIST with CAR == CDR. return foo%foo; ]], 0)
d967202004-02-28Martin Stjernholm // 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(`+)) ]])
aba09a2011-12-28Henrik Grubbström (Grubba) test_compile_error([[ static_assert(0, "Fail."); ]]) test_any([[ static_assert(1, "Ok."); ]], 0)
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")
18cfc12002-05-24Martin Nilsson // Warnings 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([[
d5a1ec2013-11-03Henrik Grubbström (Grubba)  // #pragma strict_types
f0a7652008-06-24Martin Stjernholm  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;
9ead322009-08-18Henrik Grubbström (Grubba)  local mixed g() {} mixed h();
1cc0682008-09-14Henrik Grubbström (Grubba)  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();
9ead322009-08-18Henrik Grubbström (Grubba)  protected mixed g(); protected mixed h();
1cc0682008-09-14Henrik Grubbström (Grubba)  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())) });
10e23f2009-08-18Henrik Grubbström (Grubba) ]], ({ "A", ({ "a", "b", "c", "d", "e", "f", "g", "get_a", "h" }),
1cc0682008-09-14Henrik Grubbström (Grubba)  "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;
8e06a32014-09-30Martin Nilsson  this_program get_d() { return this::this; }
1cc0682008-09-14Henrik Grubbström (Grubba)  }; 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)
42d5b32012-01-09Henrik Grubbström (Grubba) test_any([[ // Test that backtraces with event handlers are rendered correctly. // These backtraces have caused SEGV's due to function pointers // out of bounds. cf [bug 6156]. return sizeof(describe_backtrace(catch {
f5005c2012-02-17Henrik Grubbström (Grubba)  Builtin.__Backtrace_Tester__();
42d5b32012-01-09Henrik Grubbström (Grubba)  })) > 0; ]], 1) test_any([[ // Test that backtraces with event handlers are rendered correctly. // These backtraces have caused SEGV's due to function pointers // out of bounds. cf [bug 6156].
f5005c2012-02-17Henrik Grubbström (Grubba)  return catch { Builtin.__Backtrace_Tester__(); }[1][-1][2]; ]], Builtin.__Backtrace_Tester__)
42d5b32012-01-09Henrik Grubbström (Grubba) 
2181762014-08-15Martin Nilsson test_compile_warning([[ class A { static int foo = 1; int bar() { return foo; } } ]])
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]; ]])
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);} ]])
bbc79f2009-11-10Martin Stjernholm test_compile_any([[ class X { X bar(); } class Y { constant X = global::X; X foo(); } ]])
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_any([[ class A {}; class B { inherit A:C; mixed f() {return C::this_program;} }; return B()->f() == A; ]], 1)
0f91072013-04-27Henrik Grubbström (Grubba) test_any([[ class A { class Nested { constant nested = 1; } }; class B { inherit A; class Nested { inherit ::this_program; constant other = 2; } }; object n = B()->Nested(); return n->nested + n->other; ]], 3)
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(
0b8d2f2013-06-17Martin Nilsson Charset.encoder("]]$1[[")->feed(
34db632001-10-06Mirar (Pontus Hagland) "#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;} ]])
f1accd2010-02-04Henrik Grubbström (Grubba) dnl This test used to get the last line of the else block test_any([[ int expected_line; void foo(object o) { expected_line = __LINE__ + 1; if (o->a && b) { o->a = o->b; } else if (o->b) { o->b = o->a; } }; mixed err = catch { foo(UNDEFINED); }; return err[1][-1][1] - expected_line; ]], 0)
1f4dbd2001-05-19Mirar (Pontus Hagland) dnl ---------------------------------------------------------------- dnl scopes and stuff dnl ----------------------------------------------------------------
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) {
50ab1c2010-07-12Martin Stjernholm  // log_msg("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) 
c2a9522013-06-08Henrik Grubbström (Grubba) dnl variant test_any([[ class A { variant string a() { return "A:a()"; } variant string a(string s) { return sprintf("A:a(%q)", s); } }; class B { inherit A; variant string a(int i) { return local::a() + ":" + local::a((string)i) + ":" + ::a((string)i); } variant string a(string s) { return sprintf("B:a(%q)", s); } }; class C { inherit B; string a() { return "C:a()"; } variant string a(string s) { return ::a(sizeof(s)) + "|" + ::a(s) + "|" + a(); } }; return C()->a("foo"); ]], "A:a():B:a(\"3\"):A:a(\"3\")|B:a(\"foo\")|C:a()")
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")
33d4cf2010-01-21Henrik Grubbström (Grubba) test_any([[
67731b2010-01-21Henrik Grubbström (Grubba)  // Test external symbol lookup in las.c:eval_low_safe_and_stupid().
33d4cf2010-01-21Henrik Grubbström (Grubba)  // LysLysKOM 18285732 // An old pike will fail with the fatal // "Identifier out of range, loc->parent_identifer=-1!" // during __INIT(). class A {
2181762014-08-15Martin Nilsson  protected string foo = "bar";
33d4cf2010-01-21Henrik Grubbström (Grubba)  }; string to_compile=#" constant fum = \"gazonk\"; class B() { inherit A;
67731b2010-01-21Henrik Grubbström (Grubba)  int fi()
33d4cf2010-01-21Henrik Grubbström (Grubba)  { return fum?1:0; } } "; add_constant("A",A); compile_string(to_compile); add_constant("A"); return 0; ]], 0)
479afe2010-02-09Henrik Grubbström (Grubba) test_any([[ // Test eval_low() on seemingly constant expressions, that // attempt to access variables in the fake object. [Bug 5273] // An old pike (with RTL debug) will fail with the fatal // "Invalid type 33896 in svalue at 891e510." // during compilation. class Test { protected object foo; mixed `-> (mixed what) { return foo; } int bar () { return (this_object()->gazonk == "foo") ? 1 : 0; } }; return Test()->bar; ]], 0)
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 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);]])
3e50212014-08-18Martin Nilsson 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) int maxdepth;
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();
4da9332011-04-04Martin Stjernholm  log_status("Testing vtables and scope access: %d:%d",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++;
50ab1c2010-07-12Martin Stjernholm  log_msg("Test 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];
50ab1c2010-07-12Martin Stjernholm  log_msg("%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 {
50ab1c2010-07-12Martin Stjernholm  log_msg("Encoding...\n");
5b13792004-03-08Henrik Grubbström (Grubba)  string encoded = ((function)encode_value)(tmp, Codec(), 6);
50ab1c2010-07-12Martin Stjernholm  log_msg("Decoding...\n");
5b13792004-03-08Henrik Grubbström (Grubba)  tmp = ((function)decode_value)(encoded, Codec(), 6);
50ab1c2010-07-12Martin Stjernholm  log_msg("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]+({
4da9332011-04-04Martin Stjernholm  sprintf("class C%d {\n%s\n};",cnt,code[e..]*"\n")
342fef2000-08-23Fredrik Hübinette (Hubbe)  }), 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) {
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) 
342fef2000-08-23Fredrik Hübinette (Hubbe)  total_tests+=tests; tests=0; }
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([[ 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([[ 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_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_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;}}]])
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([[
bf6ea82013-08-12Martin Nilsson  class X { int x = 1; int zz = 1; int zzz=8; int xx=16; };
c2076f2013-08-05Martin Nilsson  class Y { int y = 2; int xx; }; class Z { inherit X; inherit Y; int z = 4; int zz = 0; int zzz; };
34c76c1998-04-11Henrik Grubbström (Grubba)  object zz = Z();
c2076f2013-08-05Martin Nilsson  return zz->x + zz->y + zz->z + zz->zz + zz->zzz + zz->xx; ]], 15)
34c76c1998-04-11Henrik Grubbström (Grubba) 
bb6ffa2013-07-15Henrik Grubbström (Grubba) test_any([[ // Test __INIT with forward references to programs needing their parents. class X { program y = Y; local class Y { program z = y; }; }; object x = X(); return x->y == x->Y; ]], 1)
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)
bbbf5f2015-01-27Arne Goedeke test_any([[ // Triggered fatal since object_equal_p did not handle // getter/setter identifier correctly class A { string `foo() { return "bar"; }
0bbb9c2015-01-31Arne Goedeke  };
bbbf5f2015-01-27Arne Goedeke  return equal(A(), A()); ]], 1)
a3b1dc2010-09-27Henrik Grubbström (Grubba) test_eval_error([[ // Triggered infinite recursion and core dump. // cf LysLysKOM 18719518/Pike mailinglist 12047. object o = class{}(); o->foo += ""; ]])
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)
9bb90a2014-12-05Henrik Grubbström (Grubba) test_any([[mapping m=([0:2]); m[0]++; return m[0]++;]], 3); test_any([[mapping m=([0:2]); ++m[0]; return ++m[0];]], 4); test_any([[mapping m=([0:2]); m[0]--; return m[0]--;]], 1); test_any([[mapping m=([0:2]); --m[0]; return --m[0];]], 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
28d2be2014-08-28Martin Nilsson test_eq(map("abc", `+, 1), "bcd") test_equal(map((["a":1,"b":2]), `+, 1), (["a":2,"b":3])) test_equal(map((<1,2,3>), `+, 1), (<2,3,4>)) test_any_equal(class A { constant a=1; constant b=2; }; return map(A, `+ ,1);, (["a":2,"b":3])) test_any_equal(class A { protected mixed cast(string t) { if(t=="mapping") return (["a":1,"b":2]);}}; return map(A(), `+, 1);, (["a":2,"b":3])) test_any_equal(class A { protected mixed cast(string t) { if(t=="array") return ({1,2,3});}}; return map(A(), `+, 1);, ({2,3,4})) test_any_equal(class A { protected mixed cast(string t) { if(t=="multiset") return (<1,2,3>);}}; return map(A(), `+, 1);, (<2,3,4>))
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"])}))
28d2be2014-08-28Martin Nilsson 
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 
381baa2011-04-02Henrik Grubbström (Grubba) cond_end // thread_create
52500d2011-04-02Martin Stjernholm cond(0, [[
1943a12003-11-25Martin Stjernholm  test_any([[ // Test that a loop relinquishes the interpreter lock every now and then.
52500d2011-04-02Martin Stjernholm  // // This test is unfortunately disabled since it fails too often. // The subthread does really yield in the loop, but the main // thread, which really is waiting, fails to run. My conclusion is // that the problem is the unreliability of th_yield() - we need // to replace it with something else. :( // /mast
e9a5472010-10-26Martin Stjernholm  int count, stop, fail; Thread.thread_create (lambda() {
b4226f2011-03-30Henrik Grubbström (Grubba)  int t_start = time(); // Note: We need sub-second precision. float stop_time = 1.0 + time(t_start);
e9a5472010-10-26Martin Stjernholm  while (!stop) { count++;
b4226f2011-03-30Henrik Grubbström (Grubba)  if (time(t_start) > stop_time) {
e9a5472010-10-26Martin Stjernholm  fail = 1; break; } } });
1943a12003-11-25Martin Stjernholm  sleep (0.1); stop = 1; sleep (0.1);
e9a5472010-10-26Martin Stjernholm  return fail ? -1 : count > 0;
1943a12003-11-25Martin Stjernholm  ]], 1)
52500d2011-04-02Martin Stjernholm ]])
381baa2011-04-02Henrik Grubbström (Grubba) cond_begin([[all_constants()->thread_create]])
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;
50ab1c2010-07-12Martin Stjernholm  log_msg (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 
dde5572009-03-13Martin Stjernholm  return 1; ]], 1)
d644c12009-03-15Martin Stjernholm 
74efe62009-09-29Martin Stjernholm  test_any([[ Stdio.write_file ("testsuite_test.pike", #"\ int main() { Thread.Mutex m = Thread.Mutex(); Thread.MutexKey l = m->lock(); Thread.thread_create (lambda () {m->lock(); exit (0);}); call_out (destruct, 0, l); return -1; }"); return Process.system (RUNPIKE +" testsuite_test.pike"); ]], 0)
d273ca2014-12-07Henrik Grubbström (Grubba)  test_eval_error([[ Thread.thread_create(lambda(){ // NB: It's currently not possible to inhibit the // backtrace (without messing with the master). error("Ignore the following line.\n"); })->wait(); ]])
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)
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)
5625622011-03-06Martin Stjernholm test_any_equal([[ class X (float i) { protected int `< (X o) {return i < o->i;} protected int id = ++all_constants()->cnt; protected string _sprintf() {return "X(" + i + ")[" + id + "]";} }; X x1 = X(1.0), x2 = X(1.0); multiset m = (<x1, X(2.0), X(3.0)>); m[x2] = 1; add_constant ("cnt"); return ({m[x1], m[x2], m[X(0.5)]}); ]], [[({1, 1, 0})]]) test_any_equal([[ class X (float i) { protected int `< (X o) {return i < o->i;} protected int id = ++all_constants()->cnt; protected string _sprintf() {return "X(" + i + ")[" + id + "]";} }; X x1 = X(1.0), x2 = X(1.0); multiset m = (<x1, X(2.0), X(3.0)>); m[x2] = 1; add_constant ("cnt"); return ({(m[x1] = 1, sizeof (m)), (m[x2] = 1, sizeof (m)), (m[X(0.5)] = 1, sizeof (m))}); ]], [[({4, 4, 5})]])
b23a6d2012-02-20Martin Nilsson test_do(add_constant("cnt");)
fb61ba1998-04-26Fredrik Hübinette (Hubbe) 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"}))
94bf3d2010-10-17Martin Stjernholm test_any([[ class X (int i) { int `< (mixed o) {return 0;} int `== (mixed o) {return 0;} }; multiset m = (<X(2)>); m[X(4)] = 1; m[X(1)] = 1; m[X(3)] = 1; return sizeof (m); ]], 4)
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; } } }(); ]])
3b2cd42012-11-04Arne Goedeke test_any([[ mapping m = ([ "foo" : 1 ]); class A { int __hash() { return hash_value("foo"); } int `==(mixed o) { return o == "foo"; } }; return m[A()]; ]], 1) test_any([[ mapping m = ([ "foo" : 1 ]); class A { int __hash() { return hash_value("foo"); } int `==(mixed o) { return o == "foo"; } }; return sizeof(m - ([ A() : 1 ])); ]], 0)
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([[{
0db3762013-08-03Arne Goedeke  mapping a = ([17:17]);
639e6e2000-09-04Martin Stjernholm  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 (
5adf942011-03-23Henrik Grubbström (Grubba)  "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)
0311712013-06-17Martin Nilsson 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)]])
6490fb2008-10-12Martin Stjernholm test_do([[add_constant("count_memory_stats")]])
f83f0a2008-05-11Martin Stjernholm 
84c33e2010-04-16Martin Stjernholm test_program([[ function ff() { array x; array b() {return x;}; x = ({b}); return b; } int a() { function f = ff(); int s = Pike.count_memory (0, f()); f = 0; gc(); return s > 0; } ]])
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]])
14bf8b2009-11-30Henrik Grubbström (Grubba) test_true([[1 <= 1.0]]) test_true([[1 >= 1.0]]) test_true([[1.0 <= 1]]) test_true([[1.0 >= 1]])
00dbf62003-11-08Martin Stjernholm 
0311712013-06-17Martin Nilsson // 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) ]]) test_eq("9223372036854775808", [[ (string)0x8000000000000000 ]]) test_eq("9223372036854775809", [[ (string)0x8000000000000001 ]]) test_eq("-9223372036854775808", [[ (string)-0x8000000000000000 ]]) test_eq("-9223372036854775809", [[ (string)-0x8000000000000001 ]]) test_eq("9223372036854775808", [[ (string)-(-0x8000000000000000) ]]) test_eq("9223372036854775809", [[ (string)-(-0x8000000000000001) ]]) 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 ]]) test_eq("1125899906842624", [[ (string)0b100000000000000000000000000000000000000000000000000 ]]) test_eq("-1125899906842624", [[ (string)-0b100000000000000000000000000000000000000000000000000 ]]) test_eq(500000000 * 10, 5000000000) test_eq(5000000000000000000 * 10, 50000000000000000000) // 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) ]]) // 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) ]]) // 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() ]]) 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() ]]) // 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()]]) 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()]]) test_encode(1<<99); // - Left shift. 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) ]]) 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) // - Right shift. test_eq("53265209898187398182",
a0bcec1999-10-23Fredrik Noring  [[ (string)((int)"54543574935743895738479">>10) ]])
0311712013-06-17Martin Nilsson 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 ]]) 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) // - abs. test_eq("2147483648", [[ (string)abs(-0x80000000) ]]) test_eq("2147483648", [[ (string)abs(0x80000000) ]]) test_eq("2147483649", [[ (string)abs(0x80000001) ]]) test_eq("2147483649", [[ (string)abs(-0x80000001) ]]) test_eq("9223372036854775808", [[ (string)abs(-0x8000000000000000) ]]) test_eq("9223372036854775808", [[ (string)abs(0x8000000000000000) ]]) test_eq("9223372036854775809", [[ (string)abs(0x8000000000000001) ]]) test_eq("9223372036854775809", [[ (string)abs(-0x8000000000000001) ]]) // - Add. test_eq("2147483648", [[ (string)(0x7fffffff + 1) ]]) test_eq("2147483649", [[ (string)(0x7fffffff + 2) ]]) test_eq("-2147483648", [[ (string)((-0x80000001) + 1) ]]) test_eq("9223372036854775808", [[ (string)(0x7fffffffffffffff + 1) ]]) test_eq("9223372036854775809", [[ (string)(0x7fffffffffffffff + 2) ]]) test_eq("-9223372036854775808", [[ (string)((-0x8000000000000001) + 1) ]]) test_eq("2684354560", [[ (string)(0x50000000 + 0x50000000) ]]) test_eq("-2684354560", [[ (string)((-0x50000000) + (-0x50000000)) ]]) test_false([[ objectp((-0x80000001) + 1) ]]) // - Add-eq. test_eq([[lambda() { int a=0x100000000; int b = a; a += 1; return b+a; }()]],
a105d71999-10-31Henrik Grubbström (Grubba)  [[0x200000001]])
cb5d8e1999-10-31Henrik Grubbström (Grubba) 
0311712013-06-17Martin Nilsson // - Sub. test_eq("-2147483648", [[ (string)(-0x7fffffff - 1) ]]) test_eq("-2147483649", [[ (string)(-0x80000000 - 1) ]]) test_eq("2147483647", [[ (string)(0x80000000 - 1) ]]) test_eq("-9223372036854775808", [[ (string)(-0x7fffffffffffffff - 1) ]]) test_eq("-9223372036854775809", [[ (string)(-0x8000000000000000 - 1) ]]) test_eq("9223372036854775807", [[ (string)(0x8000000000000000 - 1) ]]) test_false([[ objectp(0x80000000 - 1) ]]) // - Multiplication. test_eq("6442450941", [[ (string)(0x7fffffff * 3) ]]) test_eq("-6442450941", [[ (string)(0x7fffffff * -3) ]]) test_eq(-2147483648*-1,2147483648) test_eq(-9223372036854775808*-1,9223372036854775808) // Division. test_eq("1073741824", [[ (string)((int)"2147483648" / 2) ]]) test_false([[ objectp((int)"2147483648" / 2) ]]) test_eq("13934998268672547360069539025", [[ (string)(48324683476346278246238462784624627348 / 3467864333) ]]) // - sscanf. test_eq("12345678901234567890",
a0bcec1999-10-23Fredrik Noring  [[ (string)array_sscanf("12345678901234567890", "%d")[0] ]])
0311712013-06-17Martin Nilsson test_eq("1375488932614371410344080",
a0bcec1999-10-23Fredrik Noring  [[ (string)array_sscanf("123456789F01234567890", "%x")[0] ]])
0311712013-06-17Martin Nilsson test_eq("1375488932614371410344080",
f218802001-06-05Fredrik Hübinette (Hubbe)  [[ (string)array_sscanf("0x123456789F01234567890", "%x")[0] ]])
0311712013-06-17Martin Nilsson test_eq("1375488932614371410344080",
f218802001-06-05Fredrik Hübinette (Hubbe)  [[ (string)array_sscanf("0X123456789F01234567890", "%x")[0] ]])
0311712013-06-17Martin Nilsson test_eq("1375488932614371410344080",
a0bcec1999-10-23Fredrik Noring  [[ (string)array_sscanf("0x123456789F01234567890", "%i")[0] ]])
0311712013-06-17Martin Nilsson test_eq("1375488932614371410344080",
f218802001-06-05Fredrik Hübinette (Hubbe)  [[ (string)array_sscanf("0X123456789F01234567890", "%i")[0] ]])
0311712013-06-17Martin Nilsson test_eq("45954944846776",
a0bcec1999-10-23Fredrik Noring  [[ (string)array_sscanf("1234567012345670", "%o")[0] ]])
0311712013-06-17Martin Nilsson test_eq("45954944846776",
a0bcec1999-10-23Fredrik Noring  [[ (string)array_sscanf("01234567012345670", "%i")[0] ]])
0311712013-06-17Martin Nilsson 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] ]]) test_eq("-12345678901234567890",
a0bcec1999-10-23Fredrik Noring  [[ (string)array_sscanf("-12345678901234567890", "%d")[0] ]])
0311712013-06-17Martin Nilsson test_eq("-1375488932614371410344080",
a0bcec1999-10-23Fredrik Noring  [[ (string)array_sscanf("-123456789F01234567890", "%x")[0] ]])
0311712013-06-17Martin Nilsson test_eq("-1375488932614371410344080",
a0bcec1999-10-23Fredrik Noring  [[ (string)array_sscanf("-0x123456789F01234567890","%i")[0] ]])
0311712013-06-17Martin Nilsson test_eq("-45954944846776",
a0bcec1999-10-23Fredrik Noring  [[ (string)array_sscanf("-1234567012345670", "%o")[0] ]])
0311712013-06-17Martin Nilsson test_eq("-45954944846776",
a0bcec1999-10-23Fredrik Noring  [[ (string)array_sscanf("-01234567012345670", "%i")[0] ]])
0311712013-06-17Martin Nilsson 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] ]]) 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") 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") ]]) test_equal([[array_sscanf("foo \12345 bar <fie>","%[^<]")]],
58d1d22001-05-14Fredrik Hübinette (Hubbe)  [[ ({"foo \12345 bar " }) ]])
0311712013-06-17Martin Nilsson test_equal(471100000000000000000000000000000000000000000000042, (int)(mixed)471100000000000000000000000000000000000000000000042) test_eq(6745697846498645967,
3e50212014-08-18Martin Nilsson  [[ (int)Gmp.mpz("6745697846498645967") ]])
0311712013-06-17Martin Nilsson  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))]]) 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))) ]]) test_eq(2147483648, -2147483648/-1) test_eq(2147483648, -2147483648*-1) test_true([[ random(0x7fffffff)+1 ]]) test_true([[ random(0x7ffffffff)+1 ]]) test_true([[ sqrt(0x7fffffff)+1 ]]) test_true([[ sqrt(0x7ffffffff)+1 ]]) test_true([[ catch { destruct((mixed)0x4783647824687234628462); } ]])
2db2421999-10-29Martin Stjernholm 
0311712013-06-17Martin Nilsson test_any_equal([[ array a = ({4711, 0x54325827a124*0x12348795482485425}); set_weak_flag (a, 1); gc(); return set_weak_flag(a, 0); ]], [[ ({4711, 0x54325827a124*0x12348795482485425}) ]])
2db2421999-10-29Martin Stjernholm 
0311712013-06-17Martin Nilsson test_any_equal([[ mapping m = ([
2db2421999-10-29Martin Stjernholm  4711: 0x54325827a124*0x12348795482485425, 0x54325827124*0x1234879548a2485425: 1174,
0311712013-06-17Martin Nilsson  ]); set_weak_flag (m, 1); gc(); return set_weak_flag(m, 0); ]], [[ ([ 4711: 0x54325827a124*0x12348795482485425, 0x54325827124*0x1234879548a2485425: 1174, ]) ]]) 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) 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) ]]); 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); 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)); 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);
9c8ca02000-11-05Mirar (Pontus Hagland)  array a=({k+17,k+16,k+13,k+14,k+12,k,k+9});
0311712013-06-17Martin Nilsson  return sort(a)[0]==k && sort(a)[-1]==k+17]],1)
9c8ca02000-11-05Mirar (Pontus Hagland) 
0311712013-06-17Martin Nilsson test_do([[ // This is a memleak test rm("testsuite_test.pike"); Stdio.write_file("testsuite_test.pike",
997b732001-09-10Fredrik Hübinette (Hubbe)  "constant Q=10000000000000000;\n" "int main() {}\n");
0311712013-06-17Martin Nilsson  Process.system(RUNPIKE +" testsuite_test.pike"); rm("testsuite_test.pike"); ]])
997b732001-09-10Fredrik Hübinette (Hubbe) 
9c8ca02000-11-05Mirar (Pontus Hagland) // test the corresponding integer operations first
0311712013-06-17Martin Nilsson 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);
9c8ca02000-11-05Mirar (Pontus Hagland)  // now the bignum ones
0311712013-06-17Martin Nilsson 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);
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)")
94fd482014-05-11Martin Nilsson ignore_warning("Indexing the empty string.", [[ test_aq([[ sprintf("%O", typeof(""[0])) ]], "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) 
a2133d2014-04-17Arne Goedeke define(test_sscanf, [[ test_any([[$1 a = $3, b; string s = sprintf($2, a); sscanf(s, $2, b); return s == sprintf($2, b);]], 1) ]]) define(test_sscanf_F, [[ test_sscanf(float, "%8F", $1) test_sscanf(float, "%-8F", $1) test_sscanf(float, "%4F", $1) test_sscanf(float, "%-4F", $1) ]]) test_sscanf_F(Math.e) test_sscanf_F(Math.pi) test_sscanf_F(Math.nan) test_sscanf_F(Math.inf)
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 }) ]])
e02b4f2010-11-21Henrik Grubbström (Grubba) test_equal([[ array_sscanf("hejhopp", "%*!3s%s%n") ]], [[ ({ "hopp", 4 }) ]])
e45d9a2001-01-14Mirar (Pontus Hagland) 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]],"^^")
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) // testing == test_true(1==1) test_true(!(1==2)) test_true(""=="") test_true(!(""=="foo")) test_true(this_object()==this_object()) 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')
0346dc2014-05-10Martin Nilsson test_eq('a',0x61) test_eq('ab',0x6162) test_eq('abc',0x616263) test_eq('abcd',0x61626364) test_true("\r"[-1]!='r')
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 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)
31649d2014-11-03Arne Goedeke // testing F_APPEND_MAPPING test_any([[ // F_APPEND_MAPPING is not used when adding constant mappings string index = "foo"; mapping m = ([ "foo" : 1 ]); m += ([ index : 2 ]); return m->foo; ]], 2)
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"}))
a5a6492011-03-03Martin Stjernholm test_eq(({})/100.0, ({})); test_eq(({})/100, ({}));
d429a71998-02-24Fredrik Hübinette (Hubbe)  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) 
45fe642013-01-08Arne Goedeke // testing overflow checks test_eq(-1 - 0x7fffffff, -0x80000000)
34e2782013-01-11Arne Goedeke test_eq(Int.NATIVE_MIN % -1, 0) test_eq(Int.NATIVE_MAX % Int.NATIVE_MIN, -1)
45fe642013-01-08Arne Goedeke 
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)
7ed6bb2013-03-06Henrik Grubbström (Grubba) // Test some indexing opcodes. test_eval_error([[return ({1})[1];]]) test_eval_error([[int i = 1; return ({1})[i];]]) test_eval_error([[array a = ({ 1 }); return a[1];]]) test_eval_error([[array a = ({ 1 }); int i = 1; return a[i];]])
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"]])
8c7ce92010-06-02Henrik Grubbström (Grubba) // Note: 32-bit floats overflow at ~3.4e38. test_true([[has_value ((string)1e38, ".") || has_value ((string)1e38, "e")]]) test_true([[has_value ((string)-1e38, ".") || has_value ((string)-1e38, "e")]]) test_true([[has_value ((string)1e-38, ".") || has_value ((string)1e-38, "e")]]) test_true([[has_value ((string)-1e-38, ".") || has_value ((string)-1e-38, "e")]]) cond([[Float.DIGITS_10 >= 15]], [[ // Usual size with 64 bit IEEE floats. // Note: 1e100 overflows to infinity with 32 bit floats. test_true([[has_value ((string)1e100, ".") || has_value ((string)1e100, "e")]]) test_true([[has_value ((string)-1e100, ".") || has_value ((string)-1e100, "e")]]) ]]) // Note: 1e-100 underflows to 0.0 with 32 bit IEEE floats, but that's ok.
b13bc32009-06-30Martin Stjernholm 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")]])
766e0b2009-08-05Martin Stjernholm test_eq([[(string) 0.8]], [["0.8"]]) cond([[Float.DIGITS_10 >= 6]], [[ // Usual size with 32 bit IEEE floats. test_eq([[(string) 0.811113]], [["0.811113"]]) test_eq([[(string) 0.811114]], [["0.811114"]])
ba332a2009-08-15Martin Stjernholm  test_true([[Regexp ("^8\\.11113e\\+0*19$")->match ((string) 0.811113e20)]]) test_true([[Regexp ("^8\\.11114e\\+0*19$")->match ((string) 0.811114e20)]])
766e0b2009-08-05Martin Stjernholm ]]) cond([[Float.DIGITS_10 >= 15]], [[ // Usual size with 64 bit IEEE floats. test_eq([[(string) 0.811111111111113]], [["0.811111111111113"]]) test_eq([[(string) 0.811111111111114]], [["0.811111111111114"]])
ba332a2009-08-15Martin Stjernholm  test_true([[Regexp ("^8\\.11111111111113e\\+0*19$")->match ((string) 0.811111111111113e20)]]) test_true([[Regexp ("^8\\.11111111111114e\\+0*19$")->match ((string) 0.811111111111114e20)]])
766e0b2009-08-05Martin Stjernholm ]])
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})]])
c43e8c2014-08-16Martin Nilsson test_eval_error([[(int)class { mixed cast() { return UNDEFINED; } }();]]) test_eval_error([[(string)class { mixed cast() { return UNDEFINED; } }();]]) test_eval_error([[(mapping)class { mixed cast() { return UNDEFINED; } }();]])
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)
4e1b092014-09-30Henrik Grubbström (Grubba) test_do([[ add_constant("FOO", class { array(string) arr = ({ "a", "b", "c" }); }()); ]]) test_any_equal([[ // LysLysKOM 20983743. compile_string("void x() {string z=\"a\"; FOO->arr-=({z});}")()->x(); compile_string("void x() {string z=\"b\"; FOO->arr=FOO->arr-({z});}")()->x(); compile_string("void x() {FOO->arr-=({\"c\"});}")()->x(); return FOO->arr; ]], ({})) test_do([[ add_constant("FOO"); ]])
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) // 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)
5dfb312009-09-08Martin Nilsson test_any_equal(array a=({ "x" }); a|=({"x","y"}); return a, ({"x","y"})) test_any_equal(array a=({ "x" }); a|=({"y"}); return a, ({"x","y"})) test_any_equal(array a=({ "x" }); a|=({"x"}); return a, ({"x"})) test_any_equal(array a=({ "x" }); a|=a; return a, ({"x"})) test_any_equal(array a=({ "x" }); mapping m=(["a":a]); a|=({"x","y"}); return a, ({"x","y"})) test_any_equal(array a=({ "x" }); mapping m=(["a":a]); a|=({"y"}); return a, ({"x","y"})) test_any_equal(array a=({ "x" }); mapping m=(["a":a]); a|=({"x"}); return a, ({"x"})) test_any_equal(array a=({ "x" }); mapping m=(["a":a]); a|=a; return a, ({"x"}))
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)
6d0dbb2011-03-25Martin Stjernholm test_any([[ // Check foreach iterator stepping behavior. array a = indices (allocate (7)); Array.Iterator i = get_iterator (a); foreach (i;; int v) if (v > 3) break; foreach (i;; int v) if (v < 5) break; foreach (i;; int v) return v; ]], 4)
b280282014-07-15Henrik Grubbström (Grubba) test_any([[ // Check foreach with negative ranges [bug 7216]/[LysLysKOM 20892964]. array a = ({ -2, -1, 0, 1, 2 }); int total; foreach(a, int start) { foreach(a[start..], int val) { if (!intp(val)) error("Invalid svalue!\n"); total += (val + 3)*(start + 3); } } return total; ]], 15 + 30 + 45 + 56 + 60)
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
8235cd2012-07-30Martin Nilsson test_eq([[cpp("#define FOO(X,Y) (X) (Y)\nFOO( (A),(B) )")]],"#line 1 \"-\"\n\n( (A) ) ( (B) )") test_eq([[cpp("#define FOO(X)\nFOO BAR")]],"#line 1 \"-\"\n\nFOO BAR") test_eq([[cpp("#define F 'F'\nF")]],"#line 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)")]],"#line 1 \"-\"\n\n\n(( (( 1 )>( 2 )?( 1 ):( 2 )) )>( 3 )?( (( 1 )>( 2 )?( 1 ):( 2 )) ):( 3 ))")
f3ece81999-02-28Fredrik Hübinette (Hubbe) 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)")]],
8235cd2012-07-30Martin Nilsson  "#line 1 \"-\"\n\n\n \"foo\" ") test_eq([[cpp("#define FOO(X) X\nFOO(\"\\\n\")\n")]], "#line 1 \"-\"\n\n\n \"\" \n");
1c6c942014-06-09Martin Nilsson test_eq([[cpp("#define FOO(X) X\r\nFOO(\"\\\r\n\")\r\n")]], "#line 1 \"-\"\n\n\n \"\" \n" /* Note: Added extra spaces 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; ]], "")
51d3f32011-12-28Henrik Grubbström (Grubba) test_eq([[cpp("foo _Pragma(\"strict_types \\\\back \\\"str\\\"\") bar")]],
8235cd2012-07-30Martin Nilsson  "#line 1 \"-\"\nfoo \n#pragma strict_types \\back \"str\"\n#line 1 \"-\"\n bar")
b056b12004-06-30Henrik Grubbström (Grubba) test_equal([[
0b8d2f2013-06-17Martin Nilsson  compile_string(Charset.encoder("ebcdic-us")->
b056b12004-06-30Henrik Grubbström (Grubba)  feed("#charset ebcdic-us\n" "constant val = \"abc\";\n")->drain())()->val; ]], "abc")
8235cd2012-07-30Martin Nilsson test_eq([[cpp("\\\n")]], "#line 1 \"-\"\n\n") test_eq([[cpp("#if 1\\\n-1\nfoo\n#endif\n")]], "#line 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());
8235cd2012-07-30Martin Nilsson ]], "#line 1 \"-\"\n1 p");
e208cf2001-12-20Martin Stjernholm 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) 
ec4f032014-08-26Martin Nilsson test_any_equal([[ int base = __COUNTER__; #define X __COUNTER__ return map( ({ __COUNTER__, X, __COUNTER__ }), `-, base); ]], [[ ({ 1,2,3 }) ]]) test_any_equal([[ int base = __COUNTER__; #define X __COUNTER__ return map( ({ __COUNTER__, X, __COUNTER__ }), `-, base); ]], [[ ({ 1,2,3 }) ]]) test_do(add_constant("COUNTER",__COUNTER__)) test_eq(__COUNTER__-1,COUNTER) test_do(add_constant("COUNTER"))
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([[
30d4ff2014-08-27Martin Nilsson #if constant(String.Buffer) return 1; #else return 0; #endif
e573932004-04-16Martin Nilsson ]],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) 
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([[
3daf982014-02-17Martin Nilsson #if constant(foobar) return 1; #else return 0; #endif ]],1)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) test_eq(foobar(),1)
2de3791997-02-11Fredrik Hübinette (Hubbe) test_do(add_constant("foobar"))
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) test_any([[
3daf982014-02-17Martin Nilsson #if constant(foobar)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 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>))
0311712013-06-17Martin Nilsson test_equal(1700000000000000000000+class{mixed ``+(mixed n){return (<n>);}}(),(<1700000000000000000000>))
d644c12009-03-15Martin Stjernholm 
0311712013-06-17Martin Nilsson 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.Buffer) ) test_true( callablep( class { void `()() { } }() ) ) test_false( callablep(String.Buffer()) ) test_true( callablep( ({}) ) ) test_true( callablep( ({ 0,0 }) ) )
ca20652013-12-14Henrik Grubbström (Grubba) test_true( callablep( ({ 0,1 }) ) )
039ef72004-04-29Martin Nilsson 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 ) )
d476332013-12-14Martin Nilsson test_true( callablep( ({ ({ 0, 1, time }) }) ) ) test_false( callablep( ({ ({ 0, "" }) }) ) )
039ef72004-04-29Martin Nilsson 
12cec82003-01-15Martin Nilsson // - cd // - ceil // Tested in _math // - chmod // - chown // - chroot // - cleargroups // - 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();
50ab1c2010-07-12Martin Stjernholm  if (!(i % 100)) log_status ("%s: %O at %d", 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)
32b1572010-07-11Martin Stjernholm test_any([[ mapping m = ([]); multiset l = (<>); m->foo = ({l}); m->bar = ({l}); mapping copy = copy_value (m); return copy->foo != copy->bar && copy->foo[0] == copy->bar[0]; ]], 1)
e5bb7d1996-09-23Fredrik Hübinette (Hubbe) 
ac8b522009-08-26Martin Stjernholm test_any([[ class X {int __hash() {return 17;}}; mixed c = copy_value (X()); return objectp (c) && object_program (c) == X; ]], 1)
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
ff7c4d2011-03-30Martin Stjernholm // equal is already tested a lot in this script test_any([[ class X (string s) {}; return equal (({X ("foo")}), ({X (0)})); ]], 0) test_any([[ class X (string s) {}; return equal (({X (0)}), ({X ("foo")})); ]], 0) test_any([[ class X (string s) {}; return equal (({X ("foo")}), ({X ("foo")})); ]], 1)
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) 
1a3aec2014-11-24Stephen R. van den Berg // - hash_7_4 define(test_hash_7_4, [[ test_any([[ int i = hash_7_4($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) test_eval_error( return 7.4::hash("foo",0) ) // - hash_7_0 test_eq([[ hash_7_0("foo") ]],27734) test_eq([[ hash_7_0("foo",10) ]],4) test_eq([[ hash_7_0("bar") ]],26689) test_eq([[ hash_7_0("bar",10) ]],9)
d542412014-12-06Marcus Comstedt test_eq([[ hash_7_0("b\666arqwerty1234") ]], [[(Pike.get_runtime_info().native_byteorder == 4321? 2142487018 : 1858424874)]])
1a3aec2014-11-24Stephen R. van den Berg test_eq([[ hash_7_0("") ]],0) test_eval_error( return hash_7_0("foo",0) )
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))
a31d562014-10-24Arne Goedeke test_any([[ int v = 0; void trampoline() { v = 1; }; int(0..1) check_hash() { function f1 = trampoline; function f2 = trampoline; return hash_value(f1) == hash_value(f2); }; return check_hash(); ]], 1)
7f20c02008-01-13Martin Nilsson 
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
ffdd4c2014-06-20Martin 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, 0x025d, 0x0260, 0x0261, 0x0262, 0x0263, 0x0264, 0x0265, 0x0266, 0x0267, 0x0268, 0x0269, 0x026a, 0x026b, 0x026c, 0x026d, 0x026f, 0x0270, 0x0271, 0x0272, 0x0273, 0x0275, 0x0276, 0x027d, 0x027e, 0x0280, 0x0281, 0x0283, 0x0284, 0x0287, 0x0288, 0x0289, 0x028a, 0x028c, 0x028d, 0x0292, 0x0293, 0x029e, 0x029f, 0x0345, 0x0346, 0x0370, 0x0374, 0x0376, 0x0378, 0x037b, 0x037e, 0x037f, 0x0380, 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, 0x0530, 0x0531, 0x0557, 0x0561, 0x0587, })), (string) ({ 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, 0x025d, 0x0260, 0x0261, 0x0262, 0x0263, 0x0264, 0x0265, 0x0266, 0x0267, 0x0268, 0x0269, 0x026a, 0x026b, 0x026c, 0x026d, 0x026f, 0x0270, 0x0271, 0x0272, 0x0273, 0x0275, 0x0276, 0x027d, 0x027e, 0x0280, 0x0281, 0x0283, 0x0284, 0x0287, 0x0288, 0x0289, 0x028a, 0x028c, 0x028d, 0x0292, 0x0293, 0x029e, 0x029f, 0x0345, 0x0346, 0x0371, 0x0374, 0x0377, 0x0378, 0x037b, 0x037e, 0x03f3, 0x0380, 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, 0x0530, 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 -
ffdd4c2014-06-20Martin Nilsson 0x10a0, 0x10c6, 0x10c7, 0x10c8, 0x10cd, 0x10ce, 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, 0x2c71, 0x2c72, 0x2c74, 0x2c75, 0x2c77, 0x2c7e, 0x2c80, 0x2ce4, 0x2ceb, 0x2cef, 0x2cf2, 0x2cf4, 0x2d00, 0x2d26, 0x2d27, 0x2d28, 0x2d2d, 0x2d2e, 0xa640, 0xa66e, 0xa680, 0xa69c, 0xa722, 0xa730, 0xa732, 0xa770, 0xa779, 0xa77d, 0xa77e, 0xa788, 0xa78b, 0xa78d, 0xa78e, 0xa790, 0xa794, 0xa796, 0xa7aa, 0xa7ab, 0xa7ac, 0xa7ad, 0xa7ae, 0xa7b0, 0xa7b1, 0xa7b2, 0xff21, 0xff3b, 0xff41, 0xff5b, 0x10400, 0x10428, 0x10450, 0x118a0, 0x118e0, })), (string) ({ 0x2d00, 0x10c6, 0x2d27, 0x10c8, 0x2d2d, 0x10ce, 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, 0x0252, 0x2c71, 0x2c73, 0x2c74, 0x2c76, 0x2c77, 0x023f, 0x2c81, 0x2ce4, 0x2cec, 0x2cef, 0x2cf3, 0x2cf4, 0x2d00, 0x2d26, 0x2d27, 0x2d28, 0x2d2d, 0x2d2e, 0xa641, 0xa66e, 0xa681, 0xa69c, 0xa723, 0xa730, 0xa733, 0xa770,
de94402014-06-25Henrik Grubbström (Grubba) 0xa77a, 0x1d79, 0xa77f, 0xa788, 0xa78c, 0x0265, 0xa78e, 0xa791, 0xa794, 0xa797, 0x0266, 0x025c, 0x0261, 0x026c, 0xa7ae, 0x029e, 0x0287, 0xa7b2, 0xff41, 0xff3b, 0xff41, 0xff5b, 0x10428, 0x10428,
ffdd4c2014-06-20Martin Nilsson 0x10450, 0x118c0, 0x118e0, }))
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-03