| 1169d9 | 2004-05-02 | Martin Nilsson | | START_MARKER
|
| 141487 | 2005-05-18 | Martin Nilsson | | test_true([["$Id: testsuite.in,v 1.755 2005/05/17 22:31:50 nilsson Exp $"]]);
|
| 4f9a0a | 2002-09-21 | Martin Stjernholm | |
// This triggered a bug only if run sufficiently early.
test_compile_any([[#pike 7.2]])
|
| 5f174f | 2003-04-02 | Martin Nilsson | | test_compile_any([[#pike 7.4]])
test_compile_any([[#pike 7.0]])
test_compile_any([[#pike 0.6]])
|
| ab01ea | 1999-09-21 | Fredrik Hübinette (Hubbe) | |
|
| 694bb1 | 1998-04-23 | Fredrik Hübinette (Hubbe) | | cond([[all_constants()->_verify_internals]],
|
| c0988f | 1998-04-17 | Fredrik Hübinette (Hubbe) | | [[
test_do(_verify_internals())
|
| 3b7464 | 1999-11-24 | Henrik 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);
|
| 4fcc7a | 2004-03-12 | Henrik Grubbström (Grubba) | | cond([[ 0x8000000000000000 ]],
[[
test_eq(0x8000000000000000-0x8000000000000000, 0);
test_eq(0xf000000000000000-0xf000000000000000, 0);
test_eq(0x8000000000000001-0x8000000000000000, 1);
test_eq(0x8000000000000000-0x8000000000000001,-1);
test_eq(-9223372036854775808*-1, -9223372036854775808/-1);
]])
|
| 3b7464 | 1999-11-24 | Henrik Grubbström (Grubba) | | test_true([[1.0e-40]]);
|
| a83f8c | 1998-03-20 | Fredrik Hübinette (Hubbe) | | test_eq([[#"foo
|
| 3b7464 | 1999-11-24 | Henrik Grubbström (Grubba) | | bar"]],[["foo\nbar"]]);
|
| b62bf6 | 2000-03-30 | Fredrik Hübinette (Hubbe) | | test_eq([[#"foo\
bar"]],[["foobar"]]);
|
| 3b7464 | 1999-11-24 | Henrik Grubbström (Grubba) | | test_true([[stringp(#string "Makefile")]]);
|
| 3488ef | 2000-04-17 | Henrik Grubbström (Grubba) | | test_any([[class Bar { array(int) foo = ({}); };
class Foo { inherit Bar; array(int) foo = ({1}); };
return sizeof(Foo()->foo);]],1);
|
| 87c9d2 | 1998-04-09 | Fredrik Hübinette (Hubbe) | |
|
| 3b7464 | 1999-11-24 | Henrik Grubbström (Grubba) | | test_eq(8, 0b1000);
test_eq(-8, -0b1000);
test_eq(16, 0b10000);
test_eq(-16, -0b10000);
|
| 565645 | 1999-10-26 | Fredrik Noring | |
|
| 926208 | 2003-02-26 | Martin Stjernholm | | test_true(1e-100000000000000000000000000000000000000000000000000000000000<=1e-10000)
|
| 6f3577 | 2003-02-26 | Mirar (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)
|
| 926208 | 2003-02-26 | Martin Stjernholm | | test_true(1e10000<=1e100000000000000000000000000000000000000000000000000000000000)
|
| 6f3577 | 2003-02-26 | Mirar (Pontus Hagland) | |
|
| b168bb | 2004-11-01 | Martin Stjernholm | | test_compile_warning('\3434523423423523423423423423')
test_compile_warning("\3434523423423523423423423423")
test_compile_warning("\d109827346981234561823743412654")
test_compile_warning("\x109a27bc69e256c83deaa34c26b4")
test_compile_error('\u17fo')
test_compile_warning("\u17fo")
test_compile_error('\uu117f')
|
| aee0b5 | 2004-11-16 | Martin Stjernholm | | test_eq("\uuuu17fo", "\\uuu17fo")
|
| b168bb | 2004-11-01 | Martin Stjernholm | | test_eq('\u117f', 0x117f)
test_eq("\u117foo", "\10577oo")
test_eq("\u1117foo", "\10427foo")
test_eq("\uuuu117foo", "\\uuu117foo")
test_compile_error('\U117f')
test_compile_warning("\U117f")
test_compile_warning("\UdEaDbEaT")
|
| aee0b5 | 2004-11-16 | Martin Stjernholm | | test_eq("\UUdEaDbEaT", "\\UdEaDbEaT")
|
| b168bb | 2004-11-01 | Martin Stjernholm | | test_eq('\UDeaDBeEF', -559038737)
test_eq("\UDeaDBeEFFF", "\33653337357FF")
test_eq("\UUDeaDBeEFFF", "\\UDeaDBeEFFF")
test_any([[
// Suppress warnings.
class handler {
void compile_warning (string file, int line, string err) {};
};
return compile_string("string s = \"\\3434523423423523423423423423\";",
"-", handler())()->s;
]], "\37777777777")
test_any([[
// Suppress warnings.
class handler {
void compile_warning (string file, int line, string err) {};
};
return compile_string("int i = '\\3434523423423523423423423423';",
"-", handler())()->i;
]], -1)
|
| e80a29 | 2002-02-28 | Martin Stjernholm | | test_do([[
|
| bcc7d6 | 2002-04-12 | Martin Nilsson | | // bug 2677
|
| e80a29 | 2002-02-28 | Martin Stjernholm | | int x;
if (time())
x = 1;
else
foo: break foo;
]])
|
| 14dd02 | 2002-06-11 | Henrik 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)
|
| 805ea6 | 2002-02-26 | Martin Stjernholm | | test_any([[
int f (int i) {i = 0; return i;};
return f (1);
]],0)
|
| fa7892 | 2001-07-28 | Fredrik Hübinette (Hubbe) | | test_any([[
|
| c20941 | 2002-11-13 | Henrik 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.
|
| daf649 | 2002-11-14 | Henrik Grubbström (Grubba) | | // This test forces F_COND_RECUR to fail.
|
| c20941 | 2002-11-13 | Henrik 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))) );
}
};
|
| fa7892 | 2001-07-28 | Fredrik Hübinette (Hubbe) | |
|
| daf649 | 2002-11-14 | Henrik Grubbström (Grubba) | | class Y { inherit X;
int Ack(int M, int N) { return ::Ack(M, N); }
};
|
| fa7892 | 2001-07-28 | Fredrik Hübinette (Hubbe) | |
|
| c20941 | 2002-11-13 | Henrik Grubbström (Grubba) | | return Y()->Ack(2,2);
|
| fa7892 | 2001-07-28 | Fredrik Hübinette (Hubbe) | | ]],7)
|
| ce9bfb | 2002-12-20 | Henrik 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)
|
| 4ce36d | 2003-01-29 | Marcus 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)
|
| f88fda | 2003-03-21 | Johan 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)
|
| 9002ef | 2004-04-29 | Martin Nilsson | | test_any([[
// Another over-optimization test.
string x(string i) { return i; };
return x("")+1+1;
]], "11")
|
| f53802 | 2003-02-25 | Marcus Comstedt | | test_compile_any([[
void foo()
{
Stdio.File bar(int x, int y)
{
return 0;
};
}
]])
|
| 7a8442 | 2003-10-10 | Martin 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;
}
]])
|
| 4ce36d | 2003-01-29 | Marcus Comstedt | |
|
| ae0ac1 | 2002-11-14 | Henrik Grubbström (Grubba) | | dnl FIXME: Add test that local and local:: in combination
dnl with recursion works correctly.
|
| 3b7464 | 1999-11-24 | Henrik Grubbström (Grubba) | | test_eval_error([[mixed x; return mkmapping(x,x)]]);
|
| 97431e | 1999-03-19 | Fredrik Hübinette (Hubbe) | |
|
| 3488ef | 2000-04-17 | Henrik Grubbström (Grubba) | | test_eval_error([[class Foo {
void bar() {}
void foo() {destruct(this_object());bar();}
};
Foo()->foo();
]])
|
| 7ddaa3 | 2000-08-22 | Martin Stjernholm | | test_do([[
void foo (int i) {
multiset res = (<>);
if (i) res = res;
};
foo (1);
]])
|
| 5e4442 | 2001-02-25 | Fredrik Hübinette (Hubbe) | | test_any([[
array tmp=({});
tmp=({([])})+tmp;
tmp->foo=7;
tmp=({([])})+tmp;
return sizeof(tmp[0]);
]], 0)
|
| 3b7464 | 1999-11-24 | Henrik 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);
|
| 2b2df2 | 1999-11-01 | Henrik Grubbström (Grubba) | |
test_any([[ int a=0xffffffff; return a/17 ]],
|
| 3b7464 | 1999-11-24 | Henrik Grubbström (Grubba) | | [[ (0xffffffff == -1)?-1:0x0f0f0f0f ]]);
|
| 2b2df2 | 1999-11-01 | Henrik Grubbström (Grubba) | | test_any([[ int a=0xffffffff; return a%17 ]],
|
| 3b7464 | 1999-11-24 | Henrik Grubbström (Grubba) | | [[ (0xffffffff == -1)?16:0 ]]);
|
| 2b2df2 | 1999-11-01 | Henrik Grubbström (Grubba) | | test_any([[ int a=0xffffffff; return a>>17 ]],
|
| 3b7464 | 1999-11-24 | Henrik Grubbström (Grubba) | | [[ (0xffffffff == -1)?-1:0x7fff ]]);
|
| 440592 | 2000-05-25 | Henrik Grubbström (Grubba) | | test_any([[return sprintf("%O", typeof(aggregate("foo")));]], "array(string)");
test_any([[int a; return sprintf("%O", typeof(aggregate(a)));]], "array(int)");
|
| 3b7464 | 1999-11-24 | Henrik Grubbström (Grubba) | | test_any([[int|string a;
|
| 440592 | 2000-05-25 | Henrik Grubbström (Grubba) | | string s = sprintf("%O", typeof(aggregate(a)));
|
| 3b7464 | 1999-11-24 | Henrik Grubbström (Grubba) | | return (< "array(string | int)", "array(int | string)" >)[s];]], 1);
|
| 440592 | 2000-05-25 | Henrik Grubbström (Grubba) | | test_any([[return sprintf("%O", typeof(aggregate()));]], "array(zero)");
|
| 1954be | 1999-12-10 | Henrik Grubbström (Grubba) | | test_any([[int i; return (< "int", "int | zero", "zero | int" >)
|
| 440592 | 2000-05-25 | Henrik Grubbström (Grubba) | | [sprintf("%O", typeof(max(i,0)))];]], 1)
|
| 3b7464 | 1999-11-24 | Henrik Grubbström (Grubba) | |
|
| 440592 | 2000-05-25 | Henrik Grubbström (Grubba) | | test_any([[array(string) a; return sprintf("%O", typeof(a[0])); ]], "string")
|
| 3b7464 | 1999-11-24 | Henrik Grubbström (Grubba) | |
test_any([[class foo { string a; };
object(foo) bar;
|
| 440592 | 2000-05-25 | Henrik Grubbström (Grubba) | | return sprintf("%O", typeof(bar->a));]], "string");
|
| 3b7464 | 1999-11-24 | Henrik Grubbström (Grubba) | |
test_any([[class foo { string a; };
array(object(foo)) bar;
|
| 440592 | 2000-05-25 | Henrik Grubbström (Grubba) | | return sprintf("%O", typeof(bar[0]->a));]], "string");
|
| 94b524 | 1999-11-01 | Mirar (Pontus Hagland) | |
|
| 440592 | 2000-05-25 | Henrik Grubbström (Grubba) | | test_any([[function(:string)|function(int:int) f;
return sprintf("%O", typeof(f())); ]],
|
| f2e6a4 | 1999-11-24 | Henrik Grubbström (Grubba) | | "string")
|
| 440592 | 2000-05-25 | Henrik Grubbström (Grubba) | | test_any([[function(:string)|function(int:int) f;
return sprintf("%O", typeof(f(1))); ]],
|
| f2e6a4 | 1999-11-24 | Henrik Grubbström (Grubba) | | "int")
|
| dc19e7 | 1999-11-24 | Henrik Grubbström (Grubba) | | test_any([[function(:string)|function(mixed, mixed...:int) f;
|
| 440592 | 2000-05-25 | Henrik Grubbström (Grubba) | | return sprintf("%O", typeof(f())); ]],
|
| dc19e7 | 1999-11-24 | Henrik Grubbström (Grubba) | | "string")
test_any([[function(:string)|function(mixed, mixed ...:int) f;
|
| 440592 | 2000-05-25 | Henrik Grubbström (Grubba) | | return sprintf("%O", typeof(f(1))); ]],
|
| dc19e7 | 1999-11-24 | Henrik Grubbström (Grubba) | | "int")
|
| 00091b | 1999-12-05 | Martin Stjernholm | | test_any([[mapping(object:string)|mapping(string:int) f;
|
| 440592 | 2000-05-25 | Henrik Grubbström (Grubba) | | return sprintf("%O", typeof(f[class{}()])); ]],
|
| 00091b | 1999-12-05 | Martin Stjernholm | | "string")
test_any([[mapping(object:string)|mapping(string:int) f;
|
| 440592 | 2000-05-25 | Henrik Grubbström (Grubba) | | return sprintf("%O", typeof(f[""])); ]],
|
| 00091b | 1999-12-05 | Martin Stjernholm | | "int")
test_any([[mapping(object:string)|mapping(string:int) f;
|
| 440592 | 2000-05-25 | Henrik Grubbström (Grubba) | | return sort((sprintf("%O", typeof(f[0])) - " ")/"|")*"|"; ]],
|
| 00091b | 1999-12-05 | Martin Stjernholm | | "int|string")
|
| 4d7b18 | 1999-12-07 | Fredrik Hübinette (Hubbe) | | test_any([[class Foo { string `[](mixed y) {return "";} };
|
| b6733a | 1999-12-05 | Henrik Grubbström (Grubba) | | object(Foo) foo;
|
| 440592 | 2000-05-25 | Henrik Grubbström (Grubba) | | return sprintf("%O", typeof(foo[0])); ]],
|
| b6733a | 1999-12-05 | Henrik Grubbström (Grubba) | | "string")
|
| f60091 | 1999-12-05 | Henrik Grubbström (Grubba) | | test_any([[class Foo { array(int) _indices() {return ({0});} };
|
| b6733a | 1999-12-05 | Henrik Grubbström (Grubba) | | object(Foo) foo;
|
| 440592 | 2000-05-25 | Henrik Grubbström (Grubba) | | return sprintf("%O", typeof(indices(foo))); ]],
|
| f60091 | 1999-12-05 | Henrik Grubbström (Grubba) | | "array(int)")
|
| b6733a | 1999-12-05 | Henrik Grubbström (Grubba) | |
test_any([[class Foo { array(string) _values() {return ({""});} };
object(Foo) foo;
|
| 440592 | 2000-05-25 | Henrik Grubbström (Grubba) | | return sprintf("%O", typeof(values(foo))); ]],
|
| b6733a | 1999-12-05 | Henrik Grubbström (Grubba) | | "array(string)")
|
| ffb7fe | 1999-12-08 | Henrik Grubbström (Grubba) | | test_any([[mapping(string:int) foo;
array(string) bar;
|
| 440592 | 2000-05-25 | Henrik Grubbström (Grubba) | | return sprintf("%O", typeof(rows(foo, bar))); ]],
|
| ffb7fe | 1999-12-08 | Henrik Grubbström (Grubba) | | "array(int)")
|
| 85ff73 | 2001-07-03 | Martin Stjernholm | | test_any([[{
class Foo
{
mixed m;
|
| 537f1e | 2001-07-03 | Henrik Grubbström (Grubba) | | };
|
| 85ff73 | 2001-07-03 | Martin Stjernholm | | class Bar
{
inherit Foo;
string m;
Foo b;
|
| 537f1e | 2001-07-03 | Henrik Grubbström (Grubba) | | mixed f() {
return typeof(b->m);
}
};
|
| f704a2 | 2001-07-03 | Henrik Grubbström (Grubba) | | Foo c;
Bar d;
|
| 537f1e | 2001-07-03 | Henrik Grubbström (Grubba) | | return sprintf("%O$%O$%O$%O",
Bar()->f(), typeof(c->m), typeof(d->m), typeof(d->b->m));
|
| f704a2 | 2001-07-03 | Henrik Grubbström (Grubba) | | }]], "mixed$mixed$string$mixed")
|
| 85ff73 | 2001-07-03 | Martin Stjernholm | |
|
| 32efc9 | 2003-03-07 | Henrik Grubbström (Grubba) | | // las.c:find_return_type() checks.
test_eq([[
// Test case from Robert J. Budzynski <Robert.Budzynski@fuw.edu.pl>.
// When broken the return type will be mixed.
sprintf("%O", typeof(lambda(string s){
return Locale.Charset.decoder("utf-8")->feed(s)->drain();
}))
]], [[ "function(string : string)" ]])
|
| 9d3a7a | 2005-02-18 | Henrik Grubbström (Grubba) | | // Test implicit lambda.
test_eq([[
`()(){ return 1; }
]], 1)
|
| d96720 | 2004-02-28 | Martin Stjernholm | | // Argument checking
// Test get_all_args.
test_eval_error([[
// A trick to get some svalues to freed refcounted stuff on the stack.
lambda (mixed a, mixed b, mixed c) {} (({time()}), ({time()}), ({time()}));
// set_weak_flag is chosen since it calls get_all_args with an
// argument spec that contains two arguments of different types.
([function] set_weak_flag)();
]])
test_eval_error([[
lambda (mixed a, mixed b, mixed c) {} (({time()}), ({time()}), ({time()}));
([function] set_weak_flag) (17);
]])
test_eval_error([[
lambda (mixed a, mixed b, mixed c) {} (({time()}), ({time()}), ({time()}));
([function] set_weak_flag) ("foo");
]])
test_eval_error([[
lambda (mixed a, mixed b, mixed c) {} (({time()}), ({time()}), ({time()}));
([function] set_weak_flag) (17, "foo");
]])
|
| 5bcd22 | 2001-02-21 | Mirar (Pontus Hagland) | | // type checks
define(test_type_error, [[
test_compile_error([[ $1 x; x=$3; ]])
|
| 6b3f5c | 2002-04-11 | Martin Nilsson | | test_compile_error_any([[ class ErrBa { $1 x() { return $3; } } ]])
test_compile_error_any([[ class ErrBa { $1 x() { $2 a=$3; return a; } } ]])
|
| 5bcd22 | 2001-02-21 | Mirar (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>))
|
| f900a9 | 2005-01-17 | Henrik 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)
|
| 5bcd22 | 2001-02-21 | Mirar (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; ]])
|
| 2d190e | 2001-02-21 | Mirar (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; ]])
|
| 5bcd22 | 2001-02-21 | Mirar (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; ]])
|
| 9692ed | 2001-12-20 | Martin Stjernholm | | test_compile_error([[class F {inherit master()->dirnode;};]]);
|
| 18cfc1 | 2002-05-24 | Martin Nilsson | | // Warnings
test_compile_warning([[ int *a ]])
test_compile_warning([[ int|float *a ]])
test_compile_warning([[ [mixed]1 ]])
|
| 90bf26 | 2004-01-15 | Martin Nilsson | | test_compile_warning([[
class A { int a = 6; };
class B {
constant a = 5;
inherit A;
};
]])
|
| 18cfc1 | 2002-05-24 | Martin Nilsson | |
|
| 5bcd22 | 2001-02-21 | Mirar (Pontus Hagland) | | //
|
| 644730 | 2000-03-10 | Henrik Grubbström (Grubba) | | test_any([[
class Foo {
constant zero = 0;
mapping(string:array(int)) m;
|
| 440592 | 2000-05-25 | Henrik Grubbström (Grubba) | | string foo() { return sprintf("%O", typeof(m[""][zero])); }
|
| 644730 | 2000-03-10 | Henrik Grubbström (Grubba) | | };
return Foo()->foo();
]], "int")
|
| a91588 | 2000-09-20 | Fredrik Noring | | test_compile_any([[
class { ; }
]])
test_compile_any([[
class { ; ; }
]])
test_compile_any([[
class { ; constant c = 0; }
]])
|
| 107a0a | 2001-01-16 | Fredrik Hübinette (Hubbe) | | test_compile_any([[
class { void a() { constant c = 17; }
void b() { constant c = 17; } }
]])
|
| 9847f1 | 1999-11-27 | Martin Stjernholm | | test_compile_any([[
constant FOO = 0;
mapping(int:string) foo = ([FOO: "foo"]);
]])
|
| 761233 | 2000-03-30 | Henrik Grubbström (Grubba) | | test_compile_error([[
|
| 099be6 | 2000-03-30 | Henrik Grubbström (Grubba) | | function(...:int) foo;
]]);
|
| 761233 | 2000-03-30 | Henrik Grubbström (Grubba) | | test_compile_error([[
|
| 099be6 | 2000-03-30 | Henrik Grubbström (Grubba) | | function(,...:int) foo;
]]);
|
| 761233 | 2000-03-30 | Henrik Grubbström (Grubba) | | test_compile_error([[
|
| 099be6 | 2000-03-30 | Henrik Grubbström (Grubba) | | function(string,...:int) foo;
]]);
|
| d0cd2f | 1998-11-08 | Fredrik 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")
|
| f73a7b | 2000-02-09 | Fredrik Hübinette (Hubbe) | | test_compile_error([[
class A { constant q = "x"; }
class B { inherit A; string z="z"; constant q="x"+z; }
]])
|
| bff94f | 2000-09-10 | Mirar (Pontus Hagland) | | test_compile_any([[
class A
{
object x(int y)
{
return B(y);
}
}
class B
{
void create(int y)
{
}
}
]])
|
| 5f05c1 | 1999-12-27 | Fredrik Hübinette (Hubbe) | |
|
| eb4677 | 2003-02-24 | Martin 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}))
|
| 0d6adc | 2001-07-04 | Henrik Grubbström (Grubba) | | test_any([[
class Foo
{
int foo();
|
| 65f228 | 2001-07-04 | Henrik Grubbström (Grubba) | | int(0..1) f()
|
| 0d6adc | 2001-07-04 | Henrik Grubbström (Grubba) | | {
|
| eb4677 | 2003-02-24 | Martin Stjernholm | | return foo == 0;
|
| 0d6adc | 2001-07-04 | Henrik Grubbström (Grubba) | | }
|
| a27a68 | 2001-07-04 | Henrik Grubbström (Grubba) | | };
|
| 0d6adc | 2001-07-04 | Henrik Grubbström (Grubba) | | return Foo()->f();
]], 1)
test_any([[
class Foo
{
int foo();
|
| eb4677 | 2003-02-24 | Martin Stjernholm | | int(0..1) f()
{
return functionp(foo);
}
};
class Bar
{
inherit Foo;
int foo() {}
|
| a27a68 | 2001-07-04 | Henrik Grubbström (Grubba) | | };
|
| eb4677 | 2003-02-24 | Martin Stjernholm | | return Bar()->f();
|
| 0d6adc | 2001-07-04 | Henrik Grubbström (Grubba) | | ]], 1)
|
| 5f05c1 | 1999-12-27 | Fredrik 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();
]])
|
| 813164 | 2001-01-17 | Martin 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);
|
| c22d27 | 2002-04-09 | Henrik Grubbström (Grubba) | | test_compile_error( [[
// This triggs a compiler bug on old Pike 7.3.
non_existant(17) {
return 0;
}
]])
|
| 3c995d | 2004-03-18 | Henrik 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);
]])
|
| fffe2b | 2002-03-21 | Henrik Grubbström (Grubba) | | test_any( [[
// bug [2861] ------------------------------------------------------------
// http://community/crunch/show_bug.cgi?id=2861
return mktime(0,0,0,1,0,70,0,0);
]], 0)
|
| e29a2e | 2002-10-15 | Henrik Grubbström (Grubba) | | test_any( [[
// bug [3270] ------------------------------------------------------------
// http://community/crunch/show_bug.cgi?id=3270
// Tue, 15 Oct 2002 09:38:32 GMT
return mktime(32, 38, 9, 15, 9, 102, 0, 0);
]], 1034674712)
|
| 1d96e7 | 2003-01-15 | Martin Nilsson | | cond( [[ master()->resolv("Pike")->Security ]],[[
test_any( [[
// bug [2830] ------------------------------------------------------------
// http://community/crunch/show_bug.cgi?id=2830
class User{};
|
| 0cfe85 | 2002-03-08 | Henrik Grubbström (Grubba) | |
|
| 1d96e7 | 2003-01-15 | Martin Nilsson | | object luser = User();
|
| 0cfe85 | 2002-03-08 | Henrik Grubbström (Grubba) | |
|
| 1d96e7 | 2003-01-15 | Martin Nilsson | | object luser_creds = Pike.Security.Creds(luser, 0, 0);
return !catch {
|
| c42aef | 2003-09-06 | Martin Nilsson | | return !!Pike.Security.call_with_creds(luser_creds, Stdio.File,
"/dev/null");
|
| 1d96e7 | 2003-01-15 | Martin Nilsson | | };
return 0;
]], 0 )
]])
|
| 0cfe85 | 2002-03-08 | Henrik Grubbström (Grubba) | |
|
| ef0a50 | 2001-09-23 | Mirar (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;
program p;
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);
|
| 9040cc | 2002-10-14 | Martin Nilsson | | test_do(add_constant("test_a"))
test_do(add_constant("test_b"))
test_do(add_constant("test_c"))
|
| ef0a50 | 2001-09-23 | Mirar (Pontus Hagland) | |
|
| 8d813e | 2001-09-23 | Mirar (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);
|
| ef0a50 | 2001-09-23 | Mirar (Pontus Hagland) | | // -----------------------------------------------------------------------
|
| ec6f97 | 2001-01-19 | Martin 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;
static void create(object o)
{
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.
for (int j = 0; j < 10; j++) werror ("");
}
}
|
| 64621b | 2004-07-16 | Henrik Grubbström (Grubba) | | mixed eat_stack(int|void probe)
|
| ec6f97 | 2001-01-19 | Martin Stjernholm | | {
|
| 64621b | 2004-07-16 | Henrik 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;
|
| ec6f97 | 2001-01-19 | Martin Stjernholm | | mixed err = 1;
|
| 64621b | 2004-07-16 | Henrik Grubbström (Grubba) | | if ((err = eat_stack()) != 10)
return intp(err) && err > 0 ? err + 1 : err;
|
| ec6f97 | 2001-01-19 | Martin 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.
for (int j = 0; j < 10; j++) werror ("");
}) return err;
}
static void create()
{
if (mixed err = eat_stack()) {
catch (err[1] = err[1][sizeof (err[1]) - 50..]);
throw (err);
}
}
};
Top();
]]);
|
| a3d4d4 | 2003-04-08 | Martin Stjernholm | | // Testing stack popping wrt the various function call opcodes
|
| 692ebe | 2001-02-08 | Martin 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();
}
]]);
|
| 9b036b | 2003-04-08 | Martin 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 `->)
}
]]);
|
| 692ebe | 2001-02-08 | Martin 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()
{
|
| 8e27a3 | 2001-02-10 | Martin Stjernholm | | foreach (({0, monitor::lock()}), mixed m)
|
| 692ebe | 2001-02-08 | Martin Stjernholm | | 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()
{
|
| 8e27a3 | 2001-02-10 | Martin Stjernholm | | foreach (({0, monitor::lock()}), mixed m)
|
| 692ebe | 2001-02-08 | Martin Stjernholm | | 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()
{
|
| 8e27a3 | 2001-02-10 | Martin Stjernholm | | foreach (({0, monitor->lock()}), mixed m)
|
| 692ebe | 2001-02-08 | Martin Stjernholm | | return f (1); // F_APPLY_AND_RETURN
}")()->g();
}
]]);
|
| 9b036b | 2003-04-08 | Martin 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;
foreach (({0, monitor::lock()}), mixed m) {
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()
{
int res;
foreach (({0, monitor::lock()}), mixed m) {
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()
{
foreach (({0, monitor::lock()}), mixed m) {
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()
{
foreach (({0, monitor::lock()}), mixed m) {
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()
{
foreach (({0, monitor::lock()}), mixed m)
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()
{
foreach (({0, monitor::lock()}), mixed m)
return this->f (1); // F_CALL_OTHER_AND_RETURN (with `->)
}
]]);
|
| 692ebe | 2001-02-08 | Martin 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;
|
| 8e27a3 | 2001-02-10 | Martin Stjernholm | | foreach (({0, monitor::lock()}), mixed m)
|
| 692ebe | 2001-02-08 | Martin Stjernholm | | 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 {
iter = 2;
|
| 8e27a3 | 2001-02-10 | Martin Stjernholm | | foreach (({0, monitor::lock()}), mixed m)
|
| 692ebe | 2001-02-08 | Martin Stjernholm | | 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 {
iter = 2;
int res;
|
| 8e27a3 | 2001-02-10 | Martin Stjernholm | | foreach (({0, monitor::lock()}), mixed m) {
|
| 692ebe | 2001-02-08 | Martin Stjernholm | | res = a (1); // F_RECUR
|
| 8e27a3 | 2001-02-10 | Martin Stjernholm | | iter = random (res);
return res;
}
|
| 692ebe | 2001-02-08 | Martin 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;
|
| 8e27a3 | 2001-02-10 | Martin Stjernholm | | foreach (({0, monitor::lock()}), mixed m) {
|
| 692ebe | 2001-02-08 | Martin Stjernholm | | a (1); // F_RECUR_AND_POP
|
| 8e27a3 | 2001-02-10 | Martin Stjernholm | | return iter;
}
|
| 692ebe | 2001-02-08 | Martin Stjernholm | | }
}
]]);
|
| 9040cc | 2002-10-14 | Martin Nilsson | | test_do(add_constant("f"))
test_do(add_constant("monitor"))
|
| 692ebe | 2001-02-08 | Martin Stjernholm | |
|
| a3d4d4 | 2003-04-08 | Martin 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();
}
]]);
|
| 9b036b | 2003-04-08 | Martin 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 `->)
}
]]);
|
| a3d4d4 | 2003-04-08 | Martin 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"))
|
| fb61ba | 1998-04-26 | Fredrik 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)
|
| 371e35 | 1999-05-10 | Mirar (Pontus Hagland) | | test_any([[ int a; catch { [a]=({1,2}); }; return 1]],1)
test_any([[ int a,b; catch { [a,b]=({1}); }; return 1]],1)
|
| aa73fc | 1999-10-21 | Fredrik Hübinette (Hubbe) | | test_any([[ mapping m=([]); m[m]=m; return stringp(sprintf("%O",m)); ]],1)
|
| 4b9f0d | 2001-10-02 | Fredrik 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)
|
| aa73fc | 1999-10-21 | Fredrik Hübinette (Hubbe) | |
|
| 395899 | 2001-06-23 | Fredrik 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)
|
| 0893ca | 1999-12-09 | Henrik Grubbström (Grubba) | | test_compile_error([[
static function foo(string ...:object);
int bar()
{
return 17;
}
]])
|
| 55356e | 1999-05-26 | Fredrik Hübinette (Hubbe) | | test_compile_error([[
array a;
a = path_info[..(sizeof(path_info)-2]*"/";
]])
|
| fb61ba | 1998-04-26 | Fredrik Hübinette (Hubbe) | | test_compile_error([[ default ; ]])
|
| 5dd218 | 1999-01-29 | Fredrik Hübinette (Hubbe) | | test_compile_error([[ 0999; ]])
|
| fb61ba | 1998-04-26 | Fredrik Hübinette (Hubbe) | | test_compile_error([[ int a,b; [a,b]++; ]])
|
| 4142a6 | 1998-05-19 | Fredrik Hübinette (Hubbe) | | test_compile_error([[
array(int) x;
string foo()
{
return "foo "+(array(string) x) * ",";
}
int main()
{
return 0;
}
]])
|
| da26fe | 2000-03-09 | Henrik Grubbström (Grubba) | | dnl
dnl this_program
dnl
|
| b58421 | 2002-05-11 | Martin Stjernholm | |
|
| da26fe | 2000-03-09 | Henrik Grubbström (Grubba) | | test_true(this_program)
test_any([[int this_program; return this_program;]], 0)
|
| 3895da | 2000-03-09 | Henrik Grubbström (Grubba) | | test_any([[class A { int a() { return this_program == A; }}; return A()->a();]], 1)
|
| 50e388 | 2002-04-13 | Martin 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;}
|
| daa74f | 2002-11-07 | Marcus Comstedt | | int a() {return object_program (B()->clone()) == B;}
|
| 50e388 | 2002-04-13 | Martin Stjernholm | | ]])
|
| d1c9bc | 2002-11-07 | Marcus Comstedt | | test_program([[
class A {this_program clone() {return this_program();}}
class B {inherit A;}
int a() {return typeof(B()->clone()) <= B;}
]])
|
| da26fe | 2000-03-09 | Henrik Grubbström (Grubba) | |
|
| b58421 | 2002-05-11 | Martin 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() {
|
| c0afd0 | 2002-11-28 | Henrik Grubbström (Grubba) | | return equal (A()->B()->f(), ({object_program (this_object()), A, A.B, A.B}));
}
]])
test_compile_error([[
mixed x() {
return ::x;
|
| b58421 | 2002-05-11 | Martin 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 {
|
| 785490 | 2004-12-19 | Henrik Grubbström (Grubba) | | inherit A:C;
|
| b58421 | 2002-05-11 | Martin Stjernholm | | mixed f() {return A::this_program;}
}
]])
|
| 785490 | 2004-12-19 | Henrik Grubbström (Grubba) | | test_compile_error_any([[
#pike 7.6
class A {}
class B {
inherit A:C;
mixed f() {return C::this_program;}
}
]])
test_any([[
class A {};
class B {
inherit A:C;
mixed f() {return C::this_program;}
};
return B()->f() == A;
]], 1)
|
| 265b72 | 1999-03-06 | Henrik Grubbström (Grubba) | | dnl test_compile_error(0())
test_compile_error(1())
test_compile_error(""())
test_compile_error(([])())
test_compile_error(([])())
|
| fb61ba | 1998-04-26 | Fredrik Hübinette (Hubbe) | | test_any([[ class X { int y; class Z { void destroy() { y++; } } }; X x=X(); destruct(x->Z()); return x->y;]],1)
|
| 2c1709 | 1999-06-22 | Fredrik Hübinette (Hubbe) | |
|
| fb61ba | 1998-04-26 | Fredrik Hübinette (Hubbe) | | test_eval_error([[ class Z { int destroy() { return 1/y; } }(); ]])
|
| 2c1709 | 1999-06-22 | Fredrik Hübinette (Hubbe) | | test_any([[ class X { int y; class Z { static void destroy() { y++; } } }; X x=X(); destruct(x->Z()); return x->y;]],1)
test_any([[ class X { int y; class Z { static void create() { y++; } } }; X x=X(); destruct(x->Z()); return x->y;]],1)
|
| a4b812 | 1998-04-28 | Fredrik Hübinette (Hubbe) | | cond([[all_constants()->_debug]],
[[
test_do(_debug(_debug(0)))
]])
|
| e70e2f | 2003-07-30 | Martin Stjernholm | | test_do(indices(_static_modules))
|
| 694bb1 | 1998-04-23 | Fredrik Hübinette (Hubbe) | | test_compile_any([[import Stdio; class x { string y() { read_file("foo"); } }]])
|
| b82cc9 | 1999-10-04 | Fredrik Hübinette (Hubbe) | |
|
| f57ba3 | 2001-10-05 | Mirar (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");
|
| 34db63 | 2001-10-06 | Mirar (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);
|
| 93c16b | 2002-01-04 | Henrik 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)
|
| 34db63 | 2001-10-06 | Mirar (Pontus Hagland) | | define(test_backtrace_line_charset, [[
test_any([[
program p=compile_string(
Locale.Charset.encoder("]]$1[[")->feed(
"#charset ]]$1[[\n"
"int foo()\n"
"{\n"
" error(\"test error\\n\"); // line 3\n"
" return 17;\n"
"}")->drain(),"test");
|
| f57ba3 | 2001-10-05 | Mirar (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);
|
| 34db63 | 2001-10-06 | Mirar (Pontus Hagland) | | ]])
dnl test_backtrace_line_charset(utf-7)
|
| f57ba3 | 2001-10-05 | Mirar (Pontus Hagland) | |
|
| ec3c9d | 2002-04-28 | Martin Stjernholm | | test_program([[
class X
{
static void create (int i)
{
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;
}
]])
|
| f5ee3c | 2002-04-28 | Martin 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;
}
]])
|
| 4fa058 | 2003-03-20 | Martin 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)
|
| b58db9 | 2002-05-11 | Martin 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;}
]])
|
| 1f4dbd | 2001-05-19 | Mirar (Pontus Hagland) | | dnl ----------------------------------------------------------------
dnl scopes and stuff
dnl ----------------------------------------------------------------
|
| b82cc9 | 1999-10-04 | Fredrik Hübinette (Hubbe) | | dnl
dnl Undocumented but important behaviour...
dnl
test_eq([[Stdio._stdin]],[[Stdio.stdin->_fd]])
|
| 4705b5 | 2002-05-01 | Martin 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";
}
]])
|
| 086acc | 1999-09-11 | Fredrik Hübinette (Hubbe) | | test_compile_any([[
class Bar
{
int f() {return 17;}
class Foo {
int g() {return f();}
}
inherit Foo;
}
]])
|
| 94b524 | 1999-11-01 | Mirar (Pontus Hagland) | | test_compile_any([[
|
| 086acc | 1999-09-11 | Fredrik Hübinette (Hubbe) | | class Bar
{
int f() {return 17;}
class Foo {
int g() {return f();}
}
}
class Gnu
{
inherit Bar;
inherit Foo;
}
]])
|
| ae60c2 | 1999-12-02 | Mirar (Pontus Hagland) | |
|
| 93c16b | 2002-01-04 | Henrik Grubbström (Grubba) | | dnl Bug 2571
|
| 8e5b45 | 2001-11-27 | Martin Stjernholm | | test_any([[
int var;
void x() {var++;};
lambda () {x();}();
return var;
]], 1);
|
| 10c07f | 2002-11-16 | Henrik Grubbström (Grubba) | | test_do([[
// Save our constants for future use...
add_constant("__saved_constants__", ([]) + all_constants());
]])
|
| 1f4dbd | 2001-05-19 | Mirar (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;
}
}
");
|
| 6edc4f | 2001-05-24 | Henrik Grubbström (Grubba) | | // Compilation handler that hides compilation errors.
class handler
{
void compile_error(string file, int line, string err)
{
// werror("file: %O, line: %O, err: %O\n", file, line, err);
}
};
|
| 1f4dbd | 2001-05-19 | Mirar (Pontus Hagland) | | // turn this on when the bug is found
// master()->set_inhibit_compile_errors(lambda(){});
|
| ba14f3 | 2001-05-22 | Henrik Grubbström (Grubba) | | //_optimizer_debug(2);
//_assembler_debug(20);
|
| 1184fa | 2001-12-12 | Martin Stjernholm | | object orig_master = master();
replace_master(object_program(orig_master)());
|
| 1f4dbd | 2001-05-19 | Mirar (Pontus Hagland) | | catch {
|
| 6edc4f | 2001-05-24 | Henrik Grubbström (Grubba) | | compile_string("import \".\";\n"
"int foo() { testsuite_test.efoo; }\n",
"testsuite_test", handler());
|
| 1f4dbd | 2001-05-19 | Mirar (Pontus Hagland) | | };
|
| 1184fa | 2001-12-12 | Martin Stjernholm | | replace_master(orig_master);
|
| 1f4dbd | 2001-05-19 | Mirar (Pontus Hagland) | | return 0;
]],0);
|
| 34db63 | 2001-10-06 | Mirar (Pontus Hagland) | | test_any([[
// infokom:350113
|
| 1184fa | 2001-12-12 | Martin Stjernholm | | Stdio.recursive_rm("testsuite_test_dir.pmod");
|
| 6c6776 | 2001-10-06 | Mirar (Pontus Hagland) | | mkdir("testsuite_test_dir.pmod");
Stdio.write_file("testsuite_test_dir.pmod/module.pmod",
|
| 34db63 | 2001-10-06 | Mirar (Pontus Hagland) | | #"
.A a() {return 0;}
");
|
| 6c6776 | 2001-10-06 | Mirar (Pontus Hagland) | | Stdio.write_file("testsuite_test_dir.pmod/A.pike",
|
| 34db63 | 2001-10-06 | Mirar (Pontus Hagland) | | #"
void create (.X x) {.y();}
");
// Compilation handler that hides compilation errors.
class handler
|
| 8307ee | 2001-11-08 | Fredrik 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) { }
|
| 34db63 | 2001-10-06 | Mirar (Pontus Hagland) | | };
|
| 1184fa | 2001-12-12 | Martin Stjernholm | | object orig_master = master();
replace_master(object_program(orig_master)());
|
| 8307ee | 2001-11-08 | Fredrik Hübinette (Hubbe) | | master()->set_inhibit_compile_errors(handler());
mixed err = catch {
compile_string("import \".\"; "
|
| 1184fa | 2001-12-12 | Martin Stjernholm | | "int foo() { testsuite_test_dir.a(); }",
"test",handler());
|
| 8307ee | 2001-11-08 | Fredrik Hübinette (Hubbe) | | };
master()->set_inhibit_compile_errors(0);
|
| 1184fa | 2001-12-12 | Martin Stjernholm | | replace_master(orig_master);
|
| 8307ee | 2001-11-08 | Fredrik Hübinette (Hubbe) | | if(err)
{
|
| 1184fa | 2001-12-12 | Martin Stjernholm | | Stdio.recursive_rm("testsuite_test_dir.pmod");
|
| 8307ee | 2001-11-08 | Fredrik Hübinette (Hubbe) | | return 0;
}
return 1;
|
| 34db63 | 2001-10-06 | Mirar (Pontus Hagland) | | ]],0);
|
| 11cbae | 2001-11-10 | Martin 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;}
");
|
| 1184fa | 2001-12-12 | Martin 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);
|
| 11cbae | 2001-11-10 | Martin Stjernholm | |
Stdio.recursive_rm("testsuite_test_dir.pmod");
]]);
|
| 06203b | 2001-12-15 | Martin 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", #"\
|
| 9439bd | 2003-01-16 | Henrik Grubbström (Grubba) | | .B.B b();
|
| 06203b | 2001-12-15 | Martin 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");
]]);
|
| a244cc | 2002-03-01 | Martin 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");
]]);
|
| fa8c4f | 2002-03-01 | Martin Stjernholm | | test_any_equal([[
|
| a244cc | 2002-03-01 | Martin Stjernholm | | // Problem: module.pmod is in pass 1 when it tries to resolve the
// .B.c constant and is therefore temporarily interned as a
|
| fa8c4f | 2002-03-01 | Martin Stjernholm | | // placeholder object. The (<>) in B.pike is equivalent to
// aggregate_multiset, which due to the import is looked up in the
|
| a244cc | 2002-03-01 | Martin Stjernholm | | // placeholder object and therefore resolved as a nonconstant
// placeholder object.
|
| fa8c4f | 2002-03-01 | Martin Stjernholm | | Stdio.recursive_rm ("testsuite_test_dir.pmod");
mkdir ("testsuite_test_dir.pmod");
Stdio.write_file ("testsuite_test_dir.pmod/module.pmod", #"\
|
| a244cc | 2002-03-01 | Martin Stjernholm | | mixed x = .B.C;
mixed foo() {return x->c;}");
|
| fa8c4f | 2002-03-01 | Martin Stjernholm | | Stdio.write_file ("testsuite_test_dir.pmod/B.pike", #"\
import \".\";
|
| a244cc | 2002-03-01 | Martin Stjernholm | | class C {
constant c = (<>);
}");
|
| fa8c4f | 2002-03-01 | Martin Stjernholm | |
object orig_master = master();
replace_master (object_program (orig_master)());
mixed res;
mixed err = catch {
res = compile_string (#"\
|
| a244cc | 2002-03-01 | Martin Stjernholm | | mixed foo() {return .testsuite_test_dir.foo();}",
|
| fa8c4f | 2002-03-01 | Martin Stjernholm | | "test")()->foo();
};
replace_master (orig_master);
if (err) throw (err);
|
| a244cc | 2002-03-01 | Martin Stjernholm | | Stdio.recursive_rm("testsuite_test_dir.pmod");
|
| fa8c4f | 2002-03-01 | Martin Stjernholm | | return res;
]], (<>));
|
| 569c6c | 2003-03-05 | Martin 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");
]])
|
| 1899f8 | 2003-03-27 | Martin 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");
]]);
|
| 3843f5 | 2001-12-16 | Martin 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");
]]);
]]);
|
| 10c07f | 2002-11-16 | Henrik 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__");
]])
|
| ae60c2 | 1999-12-02 | Mirar (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(); } } }]])
|
| 40c290 | 1999-12-02 | Mirar (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)
|
| 9040cc | 2002-10-14 | Martin Nilsson | | test_do(add_constant("kajsa"))
|
| ae60c2 | 1999-12-02 | Mirar (Pontus Hagland) | |
|
| 6bc928 | 1998-04-10 | Fredrik Hübinette (Hubbe) | | test_compile([[Stdio.File foo=Stdio.File();]])
|
| 4b3837 | 1998-04-28 | Fredrik Hübinette (Hubbe) | | test_compile([[ string|multiset(string) foo;
array(string) gazonk;
array(string) bar = indices(foo)-gazonk;
]])
|
| 6bc928 | 1998-04-10 | Fredrik 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]; }]])
|
| 281605 | 2000-03-30 | Fredrik 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;
}
}
}
]])
|
| 6bc928 | 1998-04-10 | Fredrik Hübinette (Hubbe) | | test_compile([[Stdio.File foo=Stdio.FILE();]])
|
| 87c9d2 | 1998-04-09 | Fredrik Hübinette (Hubbe) | |
|
| 5fb9b0 | 2000-04-06 | Fredrik Hübinette (Hubbe) | | test_any([[string gurk="bozo"; string b(int x) { return (x?b(x-1)+gurk:""); }; return b(5)]],[["bozo"*5]])
|
| fb61ba | 1998-04-26 | Fredrik Hübinette (Hubbe) | | dnl this should really work...
dnl test_compile_any([[void foo(int,string,...);]])
|
| 9ddbf2 | 2001-05-10 | Fredrik Hübinette (Hubbe) | | dnl This test doesn't run out of stack anymore, freaky
dnl test_eval_error([[class X { int create() { create(); } }();]])
|
| fb61ba | 1998-04-26 | Fredrik Hübinette (Hubbe) | | test_compile_error([[ int float; ]])
test_compile_error([[ int array; ]])
test_compile_error([[ int function; ]])
test_compile_error([[ int int; ]])
test_compile_error([[ int mapping; ]])
test_compile_error([[ int multiset; ]])
test_compile_error([[ int object; ]])
test_compile_error([[ int string; ]])
test_compile_error([[ int void; ]])
test_compile_error([[ int inline; ]])
test_compile_error([[ int local; ]])
test_compile_error([[ int nomask; ]])
test_compile_error([[ int predef; ]])
test_compile_error([[ int private; ]])
test_compile_error([[ int protected; ]])
test_compile_error([[ int public; ]])
test_compile_error([[ int static; ]])
test_compile_error([[ int final; ]])
test_compile_error([[ int do; ]])
test_compile_error([[ int else; ]])
test_compile_error([[ int return; ]])
test_compile_error([[ int constant; ]])
test_compile_error([[ int import; ]])
test_compile_error([[ int inherit; ]])
test_compile_error([[ int catch; ]])
|
| ee2f20 | 1999-10-10 | Fredrik Noring | | test_compile_error([[ float gauge; ]])
|
| fb61ba | 1998-04-26 | Fredrik 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]; ]])
|
| a3a6c2 | 1998-04-19 | Fredrik Hübinette (Hubbe) | | test_compile_error([[constant x=class {}(); ]])
|
| 73406b | 1999-02-14 | Fredrik Hübinette (Hubbe) | |
|
| 6b3f5c | 2002-04-11 | Martin Nilsson | | test_compile_error_any([[
|
| 199425 | 1999-09-06 | Fredrik Hübinette (Hubbe) | | mixed foo;
mapping query_variables() { return ([]); };
mixed foo(mixed bar) { return 1/foo; }
]])
|
| 6b3f5c | 2002-04-11 | Martin Nilsson | | test_compile_error_any([[
|
| 282369 | 1999-11-27 | Martin Stjernholm | | class A {int wrong = "bogus"; void create() {}}
class B {inherit A;}
]])
|
| 199425 | 1999-09-06 | Fredrik Hübinette (Hubbe) | |
|
| ee2f20 | 1999-10-10 | Fredrik Noring | | test_compile([[float x=(gauge { return; },1.0);]])
|
| a3a6c2 | 1998-04-19 | Fredrik Hübinette (Hubbe) | | cond( [[ master()->resolv("Gmp")->mpz ]],
[[
test_compile_error([[object x = Gmp.mpz(17); constant y = x;]])
]])
|
| a83f8c | 1998-03-20 | Fredrik Hübinette (Hubbe) | | test_any([[object(Stdio.File) f; f=Stdio.File(); return 1]],1)
|
| ee2f20 | 1999-10-10 | Fredrik Noring | | test_compile([[float t=gauge { string foo; };]])
|
| 086bfa | 1998-04-09 | Fredrik Hübinette (Hubbe) | | test_compile_any([[class { object(Stdio.FILE) f; void create() { f=Stdio.FILE(); }}]])
|
| 097e3d | 1998-02-27 | Fredrik Hübinette (Hubbe) | | test_eq([[compile_string("#define A(X) (X)\nint x() { return A \n\t(1); }")()->x()]],1)
|
| 3b589f | 1999-02-04 | Fredrik Hübinette (Hubbe) | |
|
| d429a7 | 1998-02-24 | Fredrik 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)
|
| b1f4eb | 1998-01-13 | Fredrik Hübinette (Hubbe) | |
|
| 51ffdb | 1998-01-19 | Fredrik 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(); }]])
|
| 265b72 | 1999-03-06 | Henrik Grubbström (Grubba) | | test_any([[
class A {
constant gurka = 2;
int foo = gurka;
};
class B {
static inherit A;
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 {
static inherit A;
constant gurka = 1;
int bar;
int baz = 3;
void create() { bar = baz + foo; }
};
return B()->bar;
]], 4)
test_any([[
class A {
|
| 18c2b7 | 1999-03-06 | Henrik Grubbström (Grubba) | | constant gurka = 1;
|
| 265b72 | 1999-03-06 | Henrik Grubbström (Grubba) | | int foo = gurka;
};
class B {
|
| 18c2b7 | 1999-03-06 | Henrik Grubbström (Grubba) | | constant banan = 2;
|
| 265b72 | 1999-03-06 | Henrik Grubbström (Grubba) | | int foo = banan;
};
class C {
static inherit A;
static inherit B;
|
| 18c2b7 | 1999-03-06 | Henrik Grubbström (Grubba) | | constant gurka = 3;
constant banan = 4;
|
| 265b72 | 1999-03-06 | Henrik Grubbström (Grubba) | | int bar;
|
| 18c2b7 | 1999-03-06 | Henrik Grubbström (Grubba) | | int baz = 5;
|
| 265b72 | 1999-03-06 | Henrik Grubbström (Grubba) | |
void create() { bar = baz + A::foo + B::foo; }
};
|
| 13d401 | 1999-03-06 | Henrik Grubbström (Grubba) | | return C()->bar;
|
| 18c2b7 | 1999-03-06 | Henrik Grubbström (Grubba) | | ]], 12)
|
| 265b72 | 1999-03-06 | Henrik Grubbström (Grubba) | |
|
| a3ece0 | 1999-03-15 | Henrik 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)
|
| 6b3f5c | 2002-04-11 | Martin Nilsson | | test_compile_error_any([[
|
| 199425 | 1999-09-06 | Fredrik Hübinette (Hubbe) | | class AScope
{
int gurka;
class A
{
int func() { return gurka; }
}
}
class CScope
{
string hohum;
class C
{
inherit AScope.A;
}
}
]])
|
| 9669c1 | 2003-06-06 | Marcus 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;
}
]])
|
| e5c297 | 2003-08-18 | Martin 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")
|
| 06b16a | 2003-08-20 | Martin 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")
|
| 9669c1 | 2003-06-06 | Marcus Comstedt | |
|
| bb4e05 | 2000-02-11 | Fredrik 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 ]])
|
| 6c6c1b | 2000-02-07 | Martin Stjernholm | |
|
| 199425 | 1999-09-06 | Fredrik 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)
|
| e92ea2 | 2004-04-23 | Martin Stjernholm | | test_any_equal([[
class A {
class C {}
};
class B {
class C {}
};
return ({A <= B, A >= B});
]], ({1, 1}))
|
| 878bf4 | 2002-05-02 | Martin Nilsson | | test_tests([[
|
| 342fef | 2000-08-23 | Fredrik Hübinette (Hubbe) | |
|
| 562a40 | 2000-08-06 | Fredrik Hübinette (Hubbe) | | int errors;
int tests;
|
| 342fef | 2000-08-23 | Fredrik Hübinette (Hubbe) | | #define indent(X) (X)
|
| 8307ee | 2001-11-08 | Fredrik Hübinette (Hubbe) | | #define FMT "%d:%d "
|
| 562a40 | 2000-08-06 | Fredrik Hübinette (Hubbe) | |
|
| 342fef | 2000-08-23 | Fredrik Hübinette (Hubbe) | | int maxdepth;
|
| 36e477 | 2000-10-13 | Martin Nilsson | | int quiet;
|
| 8307ee | 2001-11-08 | Fredrik Hübinette (Hubbe) | | string status_prefix="";
|
| 342fef | 2000-08-23 | Fredrik Hübinette (Hubbe) | |
|
| 852727 | 2002-04-18 | Henrik Grubbström (Grubba) | | class Codec {
string nameof(mixed x)
{
return ([ trace:"efun:trace", werror:"efun:werror", `+:"efun:`+" ])[x];
}
function functionof(string x)
{
return ([ "efun:trace":trace, "efun:werror":werror, "efun:`+":`+ ])[x] ||
0;
}
|
| 4f101c | 2002-05-02 | Martin Stjernholm | |
mixed encode_object (object o) {}
void decode_object (object o, mixed d) {}
|
| 852727 | 2002-04-18 | Henrik Grubbström (Grubba) | | }
|
| 342fef | 2000-08-23 | Fredrik Hübinette (Hubbe) | | void low_generate(int depth,
array(string) code,
string acc,
string ans,
int cnt)
|
| 562a40 | 2000-08-06 | Fredrik Hübinette (Hubbe) | | {
|
| 342fef | 2000-08-23 | Fredrik Hübinette (Hubbe) | | mixed tmp;
if(--depth<0)
|
| 562a40 | 2000-08-06 | Fredrik Hübinette (Hubbe) | | {
|
| 342fef | 2000-08-23 | Fredrik Hübinette (Hubbe) | | string res="None";
|
| 562a40 | 2000-08-06 | Fredrik Hübinette (Hubbe) | | tests++;
|
| 342fef | 2000-08-23 | Fredrik Hübinette (Hubbe) | |
if(!(tests & 63))
{
__signal_watchdog();
|
| 36e477 | 2000-10-13 | Martin Nilsson | | if(!quiet)
|
| 8307ee | 2001-11-08 | Fredrik Hübinette (Hubbe) | | werror("\r%s" FMT, status_prefix,maxdepth,tests);
|
| 342fef | 2000-08-23 | Fredrik Hübinette (Hubbe) | | }
string test=code*"\n"+"\n"
"mixed Q() { return "+acc+"();}\n"
"int main() { trace(9); werror(\"%O\\n\","+acc+"()); }\n"
;
|
| ed1aad | 2000-09-01 | Fredrik Hübinette (Hubbe) | |
|
| 52f66d | 2003-08-03 | Martin Stjernholm | | mixed tmp, x;
|
| 562a40 | 2000-08-06 | Fredrik Hübinette (Hubbe) | | mixed err=catch {
|
| ed1aad | 2000-09-01 | Fredrik Hübinette (Hubbe) | | tmp=compile_string(test)();
|
| 342fef | 2000-08-23 | Fredrik Hübinette (Hubbe) | | res=tmp->Q();
|
| 562a40 | 2000-08-06 | Fredrik Hübinette (Hubbe) | | if(res != ans)
|
| 52f66d | 2003-08-03 | Martin Stjernholm | | throw("Test failed");
res = "None";
|
| 852727 | 2002-04-18 | Henrik Grubbström (Grubba) | | tmp = decode_value(encode_value(tmp, Codec()), Codec());
res=tmp->Q();
if(res != ans)
|
| 52f66d | 2003-08-03 | Martin Stjernholm | | throw("Test failed for encode/decode.");
x=Program.inherit_list(object_program(tmp));
|
| 562a40 | 2000-08-06 | Fredrik Hübinette (Hubbe) | | };
if(err)
{
errors++;
|
| 5b1379 | 2004-03-08 | Henrik Grubbström (Grubba) | | werror("\nTest failed:\n"
"----------------------------------\n"
"%s\n"
"---------------------------------\n"
"expected answer: %O\n"
"Answer received: %O\n",test,ans,res);
|
| 852727 | 2002-04-18 | Henrik Grubbström (Grubba) | | if(!stringp(err) || !has_prefix(err, "Test failed"))
|
| 342fef | 2000-08-23 | Fredrik Hübinette (Hubbe) | | {
string tmp=master()->describe_backtrace(err);
array s=tmp/"\n";
s=s[..20];
werror("%s\n",s*"\n");
}
|
| 5b1379 | 2004-03-08 | Henrik Grubbström (Grubba) | | if (res == "None") {
// Probable decode error; try to get some debug.
catch {
werror("Encoding...\n");
string encoded = ((function)encode_value)(tmp, Codec(), 6);
werror("Decoding...\n");
tmp = ((function)decode_value)(encoded, Codec(), 6);
werror("Strange... No error thrown...\n");
};
}
|
| 342fef | 2000-08-23 | Fredrik Hübinette (Hubbe) | | return;
|
| 562a40 | 2000-08-06 | Fredrik Hübinette (Hubbe) | | }
}else{
low_generate(depth,
|
| 342fef | 2000-08-23 | Fredrik 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);
|
| 562a40 | 2000-08-06 | Fredrik Hübinette (Hubbe) | |
|
| 342fef | 2000-08-23 | Fredrik Hübinette (Hubbe) | | for(int e=0;e<sizeof(code);e++)
{
low_generate(depth,
code[..e-1]+({
sprintf("class C%d {\n%s\n};",cnt,indent(code[e..]*"\n"))
}),
sprintf("C%d()->%s",cnt,acc),
ans,cnt+1);
}
|
| 562a40 | 2000-08-06 | Fredrik Hübinette (Hubbe) | |
if(sscanf(acc,"%s()->%s",string classname,string rest))
{
|
| 342fef | 2000-08-23 | Fredrik Hübinette (Hubbe) | | low_generate(depth,
code+({sprintf("inherit %s;",classname) }),
rest,
ans,
cnt);
|
| 562a40 | 2000-08-06 | Fredrik Hübinette (Hubbe) | | }
}
}
|
| 878bf4 | 2002-05-02 | Martin Nilsson | | array(int) a()
|
| 562a40 | 2000-08-06 | Fredrik Hübinette (Hubbe) | | {
|
| b5b82b | 2001-10-01 | Martin Nilsson | | werror("\nTesting vtables and scope access.\n");
|
| 36e477 | 2000-10-13 | Martin Nilsson | |
|
| b17a78 | 2002-07-29 | Martin Nilsson | | quiet = !_verbose;
|
| 03f601 | 2001-01-22 | Fredrik Hübinette (Hubbe) | |
|
| 342fef | 2000-08-23 | Fredrik Hübinette (Hubbe) | | int total_tests;
for(maxdepth=1;maxdepth<9 && !errors;maxdepth++)
{
low_generate(maxdepth,
({ "string X(){return \"X\";}" }),
|
| 562a40 | 2000-08-06 | Fredrik Hübinette (Hubbe) | | "X",
"X",0);
|
| 8307ee | 2001-11-08 | Fredrik Hübinette (Hubbe) | |
status_prefix+=sprintf(FMT,maxdepth,tests);
|
| 36e477 | 2000-10-13 | Martin Nilsson | | if(quiet)
|
| 8307ee | 2001-11-08 | Fredrik Hübinette (Hubbe) | | werror("%d .. ",maxdepth);
|
| 36e477 | 2000-10-13 | Martin Nilsson | | else
|
| 8307ee | 2001-11-08 | Fredrik Hübinette (Hubbe) | | werror("\r%s",status_prefix);
|
| 342fef | 2000-08-23 | Fredrik Hübinette (Hubbe) | | total_tests+=tests;
tests=0;
}
|
| 8307ee | 2001-11-08 | Fredrik Hübinette (Hubbe) | | werror("\n");
|
| 878bf4 | 2002-05-02 | Martin Nilsson | | return ({ total_tests-errors, errors });
|
| 562a40 | 2000-08-06 | Fredrik Hübinette (Hubbe) | | }
|
| 342fef | 2000-08-23 | Fredrik Hübinette (Hubbe) | |
|
| 562a40 | 2000-08-06 | Fredrik Hübinette (Hubbe) | | ]])
|
| 1f4dbd | 2001-05-19 | Mirar (Pontus Hagland) | |
|
| 199425 | 1999-09-06 | Fredrik 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; })]])
|
| fb61ba | 1998-04-26 | Fredrik Hübinette (Hubbe) | | test_eq([[object_program(master())]],[[(program)"/master"]])
test_compile([[object("master") m = master();]])
|
| 612647 | 2000-03-02 | Fredrik Hübinette (Hubbe) | | test_any([[if(int x=1,y=2) return x;]],1)
|
| fb61ba | 1998-04-26 | Fredrik 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);
|
| a5787d | 1999-03-03 | Fredrik 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)
|
| 686df7 | 1999-03-04 | Fredrik 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)
|
| 70e978 | 1999-03-06 | Fredrik 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)
|
| 68cf01 | 2000-01-07 | Martin 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)
|
| c0e446 | 1998-06-23 | Fredrik Hübinette (Hubbe) | | test_compile_any([[
class X { void hej() {} }
class Y { inherit X:banan; void hopp() { banan::hej(); } }
]])
|
| a5787d | 1999-03-03 | Fredrik Hübinette (Hubbe) | |
|
| c0e446 | 1998-06-23 | Fredrik Hübinette (Hubbe) | | test_compile_any([[
class X { static void hej() {} }
class Y { inherit X:banan; void hopp() { ::hej(); } }
]])
test_compile_any([[
class X { static void hej() {} }
class Y { inherit X; void hopp() { X::hej(); } }
]])
test_compile_any([[
class X { static void hej() {} }
class Y { public inherit X:banan; void hopp() { banan::hej(); } }
]])
test_compile_any([[
class X { static void hej() {} }
class Y { inherit X:banan; void hopp() { banan::hej(); } }
|
| 91b0d9 | 2002-05-05 | Martin Stjernholm | | ]])
|
| 59e765 | 2002-05-11 | Martin Stjernholm | | // Testing hidden identifier lookup with ::
|
| 360436 | 2002-05-05 | Martin Stjernholm | |
|
| 91b0d9 | 2002-05-05 | Martin Stjernholm | | test_program([[
class X {
int i = 17;
class Y {
constant i = 18;
mixed f (int i) {return ({i, Y::i, X::i});}
}
}
int a() {return equal (X()->Y()->f (19), ({19, 18, 17}));}
]])
test_compile_error_any([[
#pike 7.2
class X {
int i = 17;
class Y {
constant i = 18;
mixed f (int i) {return ({i, Y::i, X::i});}
}
}
]])
test_compile_error_any([[
class X {
constant i = 18;
mixed f() {return Y::i;}
}
]])
test_program([[
class A {
int i = 17;
}
class X {
inherit A: Y;
class Y {
constant i = 18;
mixed f() {return Y::i;}
}
}
int a() {return X()->Y()->f() == 18;}
]])
test_program([[
#pike 7.2
class A {
int i = 17;
}
class X {
inherit A: Y;
class Y {
constant i = 18;
mixed f() {return Y::i;}
}
}
int a() {return X()->Y()->f() == 17;}
]])
test_program([[
class A {
string s = "A";
}
class B {
constant s = "B";
}
class X {
constant s = "X";
inherit A;
class Y {
inherit B: A;
constant s = "Y";
mixed f() {return X::s + X::A::s + Y::s + Y::A::s + A::s;}
}
}
|
| 90bf26 | 2004-01-15 | Martin 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";
}
|
| c0e446 | 1998-06-23 | Fredrik Hübinette (Hubbe) | | ]])
|
| f34f64 | 2002-05-05 | Martin 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";}
]])
|
| 59e765 | 2002-05-11 | Martin 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";}
]])
|
| f34f64 | 2002-05-05 | Martin Stjernholm | | // Testing 'global::'
|
| 360436 | 2002-05-05 | Martin Stjernholm | |
test_equal([[
compile_string (#"
string p = \"g\";
mixed f (string p) {return ({global::p, p});}")()->f ("l");
]], ({"g", "l"}))
test_eval_error([[
compile_string (#"
string pp = \"g\";
mixed f (string p) {return global::p;}");
]])
test_eval_error([[
compile_string (#"
#pike 7.2
string p = \"g\";
mixed f (string p) {return global::p;}");
]])
test_equal([[
compile_string (#"
int x = 23;
class A {
constant x = 24;
}
inherit A;
class X {
int x = 32;
mixed f (int x) {return ({global::x, global::A::x, X::x, x});}
}")()->X()->f (33);
]], ({23, 24, 32, 33}))
|
| f34f64 | 2002-05-05 | Martin Stjernholm | | // Testing 'global.'
test_compile([[
mixed a() {return global.Parser.HTML;}
]], 0);
test_compile_error([[
#pike 7.2
mixed a() {return global.Parser.HTML;}
]], 0);
test_any([[
if (!programp (Parser.HTML)) error ("This test uses the existence of Parser.HTML.\n");
return compile_string (#"
class Parser {constant HTML = 1;}
mixed foo() {return programp (Parser.HTML);}")()->foo();
]], 0);
test_any([[
if (!programp (Parser.HTML)) error ("This test uses the existence of Parser.HTML.\n");
return compile_string (#"
mixed foo() {return programp (Parser.HTML);}
class Parser {constant HTML = 1;}")()->foo();
]], 0);
test_any([[
if (!programp (Parser.HTML)) error ("This test uses the existence of Parser.HTML.\n");
return compile_string (#"
class Parser {constant HTML = 1;}
mixed foo() {return programp (global.Parser.HTML);}")()->foo();
]], 1);
test_any([[
if (!programp (Parser.HTML)) error ("This test uses the existence of Parser.HTML.\n");
return compile_string (#"
mixed foo() {return programp (global.Parser.HTML);}
class Parser {constant HTML = 1;}")()->foo();
]], 1);
|
| 07d3f2 | 1999-04-08 | Fredrik 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)
|
| f7d431 | 2000-06-21 | Henrik 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)
|
| 4a906f | 2000-06-22 | Henrik 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)
|
| c0e446 | 1998-06-23 | Fredrik Hübinette (Hubbe) | |
|
| 934a66 | 2002-09-21 | Martin Stjernholm | | test_compile_error_any([[class X {int x; int f() {return local::x;}}]])
test_compile_any([[
#pike 7.2
class X {int x; int f() {return local::x;}}
]])
|
| 61e9a0 | 1998-01-25 | Fredrik Hübinette (Hubbe) | | // Testing the 'inline' keyword
|
| 31e0d3 | 1998-01-29 | Fredrik 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)
|
| 61e9a0 | 1998-01-25 | Fredrik Hübinette (Hubbe) | |
|
| 086bfa | 1998-04-09 | Fredrik 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;
}
}
]])
|
| 34c76c | 1998-04-11 | Henrik Grubbström (Grubba) | |
|
| 3c75f3 | 2003-04-02 | Martin 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;}
]])
|
| 34c76c | 1998-04-11 | Henrik Grubbström (Grubba) | | // Testing __INIT
test_any([[
class X { int x = 1; };
class Y { int y = 2; };
class Z { inherit X; inherit Y; int z = 4; };
object zz = Z();
return zz->x + zz->y + zz->z;
]], 7)
|
| 11762b | 2000-02-08 | Martin Stjernholm | | test_do([[
|
| bcc7d6 | 2002-04-12 | Martin Nilsson | | // bug 3006
|
| 11762b | 2000-02-08 | Martin Stjernholm | | class X {
constant foo = Foo;
class Foo {}
|
| 4fefbf | 2002-05-12 | Martin Stjernholm | | void bar()
{
foo f = Foo();
}
};
]])
|
| 5590d7 | 2002-05-12 | Martin Stjernholm | | test_program([[
// Another variant of [bug 3006].
|
| 4fefbf | 2002-05-12 | Martin Stjernholm | | class X {
|
| 5590d7 | 2002-05-12 | Martin Stjernholm | | constant foo = Foo;
|
| 4fefbf | 2002-05-12 | Martin Stjernholm | | class Foo {}
|
| 5590d7 | 2002-05-12 | Martin 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;}
]])
|
| 11762b | 2000-02-08 | Martin Stjernholm | | ]])
|
| d429a7 | 1998-02-24 | Fredrik Hübinette (Hubbe) | | test_any([[
class X {
static string f() { return "p"; }
static class gazonk { void create() { f(); }};
static class g { object e() { return gazonk(); }};
void create() { g()->e(); }}; return objectp(X()); ]],1)
test_any([[class A { protected int x=1; }; class B { inherit A; int foo() { return A::x; }}; return A()->x==B()->x && B()->foo()==A()->x;]],1)
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")
|
| b1f4eb | 1998-01-13 | Fredrik 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");]]);
|
| 51ffdb | 1998-01-19 | Fredrik Hübinette (Hubbe) | | test_eq(class { static int foo=17; }()->foo,0)
|
| b1f4eb | 1998-01-13 | Fredrik Hübinette (Hubbe) | | test_eval_error(class c { static int foo=17; }()->foo=18;)
|
| de2a58 | 1997-09-28 | Fredrik Hübinette (Hubbe) | | test_equal( [[ ({ (["foo":"bar"]), (<"foo">), ([]) })->foo ]], [[ ({"bar",1,0}) ]])
|
| fc3345 | 1997-10-02 | Fredrik Hübinette (Hubbe) | | test_any([[mixed a=({([]),0}); a[1]=a; return a->foo[0];]],0)
|
| 2c24a6 | 1997-10-07 | Fredrik Hübinette (Hubbe) | | test_eval_error([[return column(({0}),"foo");]])
|
| 284c36 | 1997-09-15 | Fredrik Hübinette (Hubbe) | |
|
| 3b9009 | 1998-02-11 | Henrik 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)
|
| 2d9cbe | 1997-09-08 | Fredrik Hübinette (Hubbe) | | test_any([[
class p1 { int foo() { return 1; }};
|
| 7fda7a | 1997-09-08 | Fredrik Hübinette (Hubbe) | | class p2 { int foo() { return 3; }};
|
| 2d9cbe | 1997-09-08 | Fredrik Hübinette (Hubbe) | | class c1 { inherit p1; inherit p2; int foo() { return p1::foo()+p2::foo(); }};
|
| 7fda7a | 1997-09-08 | Fredrik 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; };
|
| fb61ba | 1998-04-26 | Fredrik Hübinette (Hubbe) | | return c1()->foo();]],2)
|
| 7fda7a | 1997-09-08 | Fredrik Hübinette (Hubbe) | |
|
| 345f10 | 1998-11-06 | Fredrik 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)
|
| 097e3d | 1998-02-27 | Fredrik Hübinette (Hubbe) | | test_compile_error([[void foo() { 1++; }]])
|
| e2dab3 | 1999-12-14 | Fredrik Hübinette (Hubbe) | | dnl test_compile_error([[void foo() { return destruct(this_object()); }]])
|
| 2d1234 | 1997-03-10 | Fredrik Hübinette (Hubbe) | | test_any([[class foo { constant x=17; }; class bar { inherit foo; constant x=18; }; return bar()->x;]],18)
|
| 419fab | 1997-03-09 | Fredrik 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"); }]])
|
| 421801 | 1999-01-31 | Fredrik Hübinette (Hubbe) | |
|
| 005bf4 | 2001-09-29 | Fredrik Hübinette (Hubbe) | |
// lambda function tests
|
| 421801 | 1999-01-31 | Fredrik 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)
|
| ea1368 | 2003-01-15 | Martin 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
|
| 77c6b3 | 2003-02-13 | Martin Stjernholm | | // it, so we have to do it the hard way..
|
| ea1368 | 2003-01-15 | Martin Stjernholm | | object obj;
find_trampoline_object: {
|
| 77c6b3 | 2003-02-13 | Martin Stjernholm | | for (obj = next_object();
objectp (obj) || // It's a normal object.
(intp (obj) && obj); // It's a bignum object.
obj = next_object (obj))
|
| ea1368 | 2003-01-15 | Martin 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");
}]])
|
| 005bf4 | 2001-09-29 | Fredrik Hübinette (Hubbe) | | // local function tests
|
| e391b7 | 2000-03-07 | Fredrik Noring | | test_eq(120,
|
| 662a90 | 2000-03-07 | Fredrik Hübinette (Hubbe) | | [[ lambda()
|
| e391b7 | 2000-03-07 | Fredrik Noring | | {
int f(int i) { return i == 0 ? 1 : i*f(i-1); };
return f(5);
|
| 662a90 | 2000-03-07 | Fredrik Hübinette (Hubbe) | | }(); ]])
|
| e391b7 | 2000-03-07 | Fredrik Noring | |
|
| 36e93d | 1999-08-03 | Fredrik 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++)
{ {int _i = i; f = lambda(int j) { return _i+j; }; } int FEL; }
return f(17);]]);
|
| 005bf4 | 2001-09-29 | Fredrik 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();
return y;
]], 7 * 5 + 4711 )
|
| 71bde8 | 2001-03-16 | Fredrik Hübinette (Hubbe) | |
|
| 1b5405 | 2001-06-11 | Henrik 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)
|
| 005bf4 | 2001-09-29 | Fredrik Hübinette (Hubbe) | | // implicit lambda tests
|
| 71bde8 | 2001-03-16 | Fredrik Hübinette (Hubbe) | | test_any([[
int x=1;
void for10(function f) { for(int e=0;e<10;e++) f(); };
|
| 74d75d | 2002-09-16 | Marcus Comstedt | | for10() { x++; };
|
| 71bde8 | 2001-03-16 | Fredrik Hübinette (Hubbe) | | return x;
]], 11)
|
| 74d75d | 2002-09-16 | Marcus Comstedt | | test_compile_error([[
int x=1;
void for10(function f) { for(int e=0;e<10;e++) f(); };
for10() { x++; }
return x;
]])
|
| 43acdb | 2001-03-20 | Henrik Grubbström (Grubba) | | test_any([[
int x;
for(int i=5; i < 10; i++) x++;
return x;
]], 5)
|
| 9f6847 | 1997-03-08 | Fredrik Hübinette (Hubbe) | | test_true([[lambda(function f) {return 1;}(object_program(this_object()));]])
|
| 2898e6 | 2001-08-02 | Fredrik Hübinette (Hubbe) | | test_any([[
function my_lambda;
{
string foo = "foo", bar = "bar";
my_lambda = lambda() { return foo; };
}
int really_magic_var;
return my_lambda();
]],"foo")
|
| b1f4eb | 1998-01-13 | Fredrik Hübinette (Hubbe) | | test_eq([[class c { int `()(){ return 4711; } }()(); ]],4711)
|
| 034fb9 | 1997-02-24 | Fredrik Hübinette (Hubbe) | | teste_eval_error(mixed foo=({}); sort(@foo); )
test_compile_error([[int foo() { return 1} ; constant foo=(["foo":foo]); return foo->foo();]])
|
| febbc8 | 1997-04-22 | Fredrik Hübinette (Hubbe) | | test_compile_error([[class T{void p(object e,object f){lambda::create(f);}}]])
|
| 18cfc1 | 2002-05-24 | Martin Nilsson | | test_eval_error(array foo=({}); return mkmapping(foo,({1})); )
|
| 0a6ffb | 1997-02-13 | Fredrik 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; } } }]])
|
| 5b4303 | 1997-01-27 | Fredrik Hübinette (Hubbe) | | test_true(encode_value(0)[0]=='\266')
|
| 2d8c5d | 2000-03-26 | Martin Stjernholm | | define(test_encode, [[ test_equal($1, decode_value(encode_value($1)))
test_equal($1, decode_value(encode_value_canonic($1))) ]])
|
| a99145 | 1997-07-08 | Fredrik Hübinette (Hubbe) | | test_eq(replace("foobar","","X"),"fXoXoXbXaXr")
|
| 5b4303 | 1997-01-27 | Fredrik Hübinette (Hubbe) | | test_encode(0)
test_encode("")
test_encode(0.0)
test_encode(1.0)
|
| bc86b3 | 1997-10-19 | Fredrik Hübinette (Hubbe) | | test_encode(-1.0)
|
| 5b4303 | 1997-01-27 | Fredrik Hübinette (Hubbe) | | test_encode(12.0)
test_encode(100000.0)
|
| f09afa | 2000-10-21 | Henrik Grubbström (Grubba) | | test_encode(3.1875)
|
| bcc8af | 2000-10-21 | Henrik Grubbström (Grubba) | | test_encode(0.0000019073486328125)
|
| 5b4303 | 1997-01-27 | Fredrik Hübinette (Hubbe) | | test_encode(({}))
test_encode(([]))
test_encode("foobar")
test_encode((<>))
|
| 454d54 | 1999-09-18 | Fredrik 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")
|
| 2d8c5d | 2000-03-26 | Martin Stjernholm | | test_encode(({"en","sv","de"}))
test_encode((<"en","sv","de">))
test_encode((["en":1,"sv":2,"de":3]))
|
| bcc8af | 2000-10-21 | Henrik 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]))
|
| 523cfb | 2000-08-18 | Henrik Grubbström (Grubba) | | test_encode((<1, 2, 2, 3, 3, 3>))
|
| 5b4303 | 1997-01-27 | Fredrik 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)
|
| be1daa | 1999-11-15 | Henrik 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")]])
|
| ab01ea | 1999-09-21 | Fredrik Hübinette (Hubbe) | |
|
| 2d8c5d | 2000-03-26 | Martin 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">)))
|
| ab01ea | 1999-09-21 | Fredrik Hübinette (Hubbe) | |
|
| 017674 | 2001-07-12 | Fredrik Hübinette (Hubbe) | |
test_any([[
|
| a662f8 | 2002-04-15 | Martin Nilsson | | // bug 3013
|
| 017674 | 2001-07-12 | Fredrik 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];
}
|
| 4f101c | 2002-05-02 | Martin Stjernholm | |
mixed encode_object (object o) {}
void decode_object (object o, mixed d) {}
|
| 017674 | 2001-07-12 | Fredrik Hübinette (Hubbe) | | }
mixed main()
{
array c = ({"subres"});
object o = compile (
#"string res() {return `+(@c());}
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")
|
| 3b8c9b | 2001-07-15 | Fredrik Hübinette (Hubbe) | | test_any([[
|
| a662f8 | 2002-04-15 | Martin Nilsson | | // bug 3014
|
| 3b8c9b | 2001-07-15 | Fredrik Hübinette (Hubbe) | | class Test
{
class Codec
{
mixed nameof (mixed what)
{
return ([])[0];
}
|
| 4f101c | 2002-05-02 | Martin Stjernholm | | mixed encode_object (object o) {}
void decode_object (object o, mixed d) {}
|
| 3b8c9b | 2001-07-15 | Fredrik Hübinette (Hubbe) | | }
int main()
{
object o = compile_string (#"
constant x = ({0});
int f() {return 17;}
int g() {return x[0]();}
")();
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);
|
| 7961fb | 1997-10-10 | Fredrik 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);
|
| fb61ba | 1998-04-26 | Fredrik Hübinette (Hubbe) | | test_any([[float p=2.0; p--; return p;]],1.0)
test_any([[float p=2.0; return --p;]],1.0)
|
| 5b4303 | 1997-01-27 | Fredrik Hübinette (Hubbe) | |
|
| b8cda2 | 1997-01-21 | Fredrik Hübinette (Hubbe) | | test_compile_error(int foo() { LJjjjjJJJ ; })
|
| 2aeef5 | 2002-11-26 | Martin 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")
|
| b8cda2 | 1997-01-21 | Fredrik Hübinette (Hubbe) | |
|
| 21b2c9 | 1999-12-17 | Fredrik Hübinette (Hubbe) | | test_eq((["static":42])->static,42)
|
| 086bfa | 1998-04-09 | Fredrik Hübinette (Hubbe) | | test_compile_any(class A {}; class B { inherit A; })
|
| b8cda2 | 1997-01-21 | Fredrik Hübinette (Hubbe) | |
|
| 6bd4cc | 2004-05-28 | Henrik 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)
|
| 8bef1b | 2001-09-27 | Fredrik 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}) }) ]])
|
| 005bf4 | 2001-09-29 | Fredrik 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}) ]])
|
| 8bef1b | 2001-09-27 | Fredrik Hübinette (Hubbe) | | test_equal([[ "foo"[ ({ 2,0,1,2 })[*] ] ]],
[[ ({ 'o', 'f', 'o', 'o' }) ]])
|
| 005bf4 | 2001-09-29 | Fredrik 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 }) ]])
|
| 8bef1b | 2001-09-27 | Fredrik Hübinette (Hubbe) | | // map tests
|
| 014c36 | 1999-08-17 | Martin 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])}))
|
| 2228d5 | 1999-08-20 | Martin 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])}))
|
| 014c36 | 1999-08-17 | Martin Stjernholm | | test_any([[
|
| 96df32 | 2000-01-03 | Martin Stjernholm | | class A {local int i = 10; int ii(){return i;}};
|
| 014c36 | 1999-08-17 | Martin Stjernholm | | class B {inherit A;};
class C {inherit A; int i = 11;};
|
| 96df32 | 2000-01-03 | Martin Stjernholm | | array a = ({A(),B(),C()});
|
| 014c36 | 1999-08-17 | Martin Stjernholm | | map(a,`[]=,"i",7);
|
| 96df32 | 2000-01-03 | Martin Stjernholm | | return equal(a->i,({7,7,7})) && equal(a->ii(),({7,7,10}));
|
| 327c05 | 1999-11-24 | Fredrik Hübinette (Hubbe) | | ]],1)
|
| 014c36 | 1999-08-17 | Martin Stjernholm | | test_any([[
|
| 96df32 | 2000-01-03 | Martin Stjernholm | | class A {local int i = 10; int ii(){return i;}};
|
| 014c36 | 1999-08-17 | Martin Stjernholm | | class B {inherit A;};
class C {inherit A; int i = 11;};
|
| 96df32 | 2000-01-03 | Martin Stjernholm | | array a = ({A(),B(),C()});
|
| 014c36 | 1999-08-17 | Martin Stjernholm | | a->i = 7;
|
| 96df32 | 2000-01-03 | Martin Stjernholm | | return equal(a->i,({7,7,7})) && equal(a->ii(),({7,7,10}));
|
| 327c05 | 1999-11-24 | Fredrik Hübinette (Hubbe) | | ]],1)
|
| 014c36 | 1999-08-17 | Martin Stjernholm | | test_any([[
|
| 96df32 | 2000-01-03 | Martin Stjernholm | | class A {local int i = 10; int ii(){return i;}};
|
| 014c36 | 1999-08-17 | Martin Stjernholm | | class B {inherit A;};
class C {inherit A; int i = 11;};
|
| 96df32 | 2000-01-03 | Martin Stjernholm | | array a = ({A(),B(),C()});
|
| 014c36 | 1999-08-17 | Martin Stjernholm | | map(a,`->=,"i",7);
|
| 96df32 | 2000-01-03 | Martin Stjernholm | | return equal(a->i,({7,7,7})) && equal(a->ii(),({7,7,10}));
|
| 327c05 | 1999-11-24 | Fredrik Hübinette (Hubbe) | | ]],1)
|
| 014c36 | 1999-08-17 | Martin 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"])}))
|
| 469b53 | 2000-01-19 | Martin 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}))
|
| 6168ce | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
|
| 469b53 | 2000-01-19 | Martin 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}))
|
| 6168ce | 2000-01-27 | Fredrik 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}))
|
| ef0a50 | 2001-09-23 | Mirar (Pontus Hagland) | |
|
| 23d1c7 | 2000-09-30 | Martin Stjernholm | | dnl // Undefined behaviour, don't do this - Hubbe
|
| bb4e05 | 2000-02-11 | Fredrik 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}))
|
| 00689d | 2000-02-10 | Martin 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}))
]])
|
| 8e9fdf | 1996-12-04 | Fredrik Hübinette (Hubbe) | | test_true(mappingp(_memory_usage()))
|
| fb61ba | 1998-04-26 | Fredrik Hübinette (Hubbe) | | test_true(_refs(""));
test_true(_refs(({})));
test_true(_refs(([])));
test_true(_refs(this_object()))
|
| 8e9fdf | 1996-12-04 | Fredrik Hübinette (Hubbe) | | test_true(arrayp( _next(({})) || _prev(({}))))
|
| 327c05 | 1999-11-24 | Fredrik Hübinette (Hubbe) | | test_do(object o=this_object(); while(o=_next(o)))
test_do(object o=this_object(); while(o=_prev(o)))
|
| 8e9fdf | 1996-12-04 | Fredrik Hübinette (Hubbe) | |
|
| 2898e6 | 2001-08-02 | Fredrik 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)
|
| 2de379 | 1997-02-11 | Fredrik Hübinette (Hubbe) | | test_any([[object(Stdio.File) o=Stdio.File(); return objectp(o);]],1)
|
| d2c608 | 1996-11-07 | Fredrik Hübinette (Hubbe) | | test_any([[class Test {}; object(Test) o=Test(); return object_program(o);]],Test)
|
| 2de379 | 1997-02-11 | Fredrik Hübinette (Hubbe) | | test_define_program(test,[[constant foo = 1; int a() { return foo; }]])
|
| 2aeef5 | 2002-11-26 | Martin Nilsson | | test_true(test()->a())
|
| 2de379 | 1997-02-11 | Fredrik 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; )
|
| 2aeef5 | 2002-11-26 | Martin Nilsson | | test_do(add_constant("test");)
|
| 1c1c5e | 2001-04-08 | Fredrik Hübinette (Hubbe) | |
test_any([[
|
| b9836b | 2001-07-05 | Fredrik Hübinette (Hubbe) | | /* don't save parent */
|
| 1c1c5e | 2001-04-08 | Fredrik Hübinette (Hubbe) | | class Foo { };
|
| c3b564 | 2003-01-09 | Henrik Grubbström (Grubba) | | return (!function_object(object_program(Foo()))) &&
(function_program(object_program(Foo())) ==
object_program(this_object()));
|
| 1c1c5e | 2001-04-08 | Fredrik Hübinette (Hubbe) | | ]], 1)
test_any([[
class Foo { };
return function_name(object_program(Foo()));
]], "Foo")
|
| 5a6d7d | 2001-04-10 | Fredrik Hübinette (Hubbe) | | test_any([[
int q;
return stringp(function_name( lambda() { return q; }));
]],1)
test_any([[
int q;
return function_object( lambda() { return q; });
]],[[this_object()]])
|
| 13fa3e | 2002-07-27 | Henrik 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;} ();})
|
| 20d9f9 | 2003-08-10 | Martin Nilsson | | test_do(class c { object foo; object(Stdio.File) bar=foo; })
test_do(class c { object foo; Stdio.File bar=foo; })
|
| b1f4eb | 1998-01-13 | Fredrik Hübinette (Hubbe) | | test_do(class c { object(Stdio.File) foo; object bar=foo; })
|
| 20d9f9 | 2003-08-10 | Martin Nilsson | | test_do(class c { Stdio.File foo; object bar=foo; })
|
| 2f3743 | 1996-11-25 | Fredrik 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;)
test_compile(foreach(({}),mixed i){})
test_compile(sscanf("","",mixed foo))
|
| fb61ba | 1998-04-26 | Fredrik Hübinette (Hubbe) | | test_compile_error(sscanf("","",float))
test_compile_error(sscanf("",float))
|
| d2c608 | 1996-11-07 | Fredrik Hübinette (Hubbe) | |
|
| e5bb7d | 1996-09-23 | Fredrik 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)
|
| fb61ba | 1998-04-26 | Fredrik Hübinette (Hubbe) | | test_any([[string e=""; e++; return e;]],"1")
|
| e5bb7d | 1996-09-23 | Fredrik 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)
|
| 6b3f5c | 2002-04-11 | Martin Nilsson | | test_compile_error_any(master()->add_precompiled_program(\"/test\",compile_string(\"int foo() { return 17; }\",\"62\")))
|
| e5bb7d | 1996-09-23 | Fredrik 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;]])
|
| c05f7c | 1999-11-20 | Mirar (Pontus Hagland) | | test_compile([[do { break; } while (0);]])
|
| e5bb7d | 1996-09-23 | Fredrik 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)
|
| 694bb1 | 1998-04-23 | Fredrik Hübinette (Hubbe) | | cond([[all_constants()->_verify_internals]],
|
| c0988f | 1998-04-17 | Fredrik Hübinette (Hubbe) | | [[
test_do(_verify_internals())
]])
|
| 2de379 | 1997-02-11 | Fredrik Hübinette (Hubbe) | | cond([[all_constants()->thread_create]],
|
| 6f6eb2 | 1996-10-05 | Fredrik Hübinette (Hubbe) | | [[
// thread_create
test_do(thread_create(lambda() { }))
// /precompiled/mutex
|
| 3f8f98 | 1997-02-27 | Fredrik Hübinette (Hubbe) | | test_true(Thread.Mutex())
|
| a0de78 | 1997-02-27 | Fredrik Hübinette (Hubbe) | | test_do(add_constant("_tmp_mutex",Thread.Mutex()))
|
| 7f15d6 | 1996-12-07 | Fredrik Hübinette (Hubbe) | | test_true(_tmp_mutex->lock())
test_true(_tmp_mutex->lock())
test_true(_tmp_mutex->trylock())
test_true(_tmp_mutex->trylock())
|
| 9c9ee0 | 1997-02-27 | Fredrik Hübinette (Hubbe) | | test_do(add_constant("_tmp_mutex_lock",_tmp_mutex->lock()))
|
| b17d20 | 1997-09-03 | Henrik Grubbström (Grubba) | | test_true(catch(_tmp_mutex->trylock()))
|
| 9c9ee0 | 1997-02-27 | Fredrik Hübinette (Hubbe) | | test_do(add_constant("_tmp_mutex_lock"))
test_true(_tmp_mutex->trylock())
|
| 0a250e | 1996-12-07 | Fredrik Hübinette (Hubbe) | | test_do(add_constant("_tmp_mutex"))
|
| 4acdae | 1997-09-11 | Henrik Grubbström (Grubba) | | 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)
|
| 3488ef | 2000-04-17 | Henrik Grubbström (Grubba) | | 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)
|
| 5b8380 | 1997-09-09 | Fredrik Hübinette (Hubbe) | | test_any([[
|
| 0d6f01 | 2002-10-01 | Henrik 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)
|
| 3e9fd3 | 2002-10-28 | Martin Stjernholm | | test_any([[
object lock = Thread.Mutex()->lock();
gc();
return objectp (lock);
]], 1)
|
| 6f6eb2 | 1996-10-05 | Fredrik Hübinette (Hubbe) | |
// /precompiled/condition
|
| 3f8f98 | 1997-02-27 | Fredrik Hübinette (Hubbe) | | test_true(Thread.Condition())
test_do(Thread.Condition()->signal())
test_do(Thread.Condition()->broadcast())
|
| 6f6eb2 | 1996-10-05 | Fredrik Hübinette (Hubbe) | |
|
| 2aeef5 | 2002-11-26 | Martin Nilsson | | test_true(objectp(Thread.Fifo()))
test_true(objectp(Thread.Queue()))
|
| a0de78 | 1997-02-27 | Fredrik Hübinette (Hubbe) | |
|
| 90229d | 1997-02-27 | Fredrik Hübinette (Hubbe) | | 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)
|
| ffc09f | 1997-02-27 | Fredrik Hübinette (Hubbe) | | 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)
|
| dad2bb | 2001-05-15 | Mirar (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(); } ]])
|
| 1943a1 | 2003-11-25 | Martin Stjernholm | |
test_any([[
// Test that a loop relinquishes the interpreter lock every now and then.
int count, stop;
Thread.thread_create (lambda() {while (!stop) count++;});
sleep (0.1);
stop = 1;
sleep (0.1);
return count > 0;
]], 1)
|
| 4716f0 | 2001-01-14 | Mirar (Pontus Hagland) | | ]])
|
| 4ce3e4 | 2001-01-01 | Mirar (Pontus Hagland) | |
|
| 9fe0a4 | 2001-11-01 | Martin Stjernholm | | cond([[all_constants()->thread_create]],
[[
// _disable_threads
test_any([[
|
| 90d08a | 2001-11-01 | Martin Stjernholm | | #ifndef __NT__
// Using a named pipe here to make open() block. That doesn't exist on NT.
|
| 9fe0a4 | 2001-11-01 | Martin 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;
werror (msg);
#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);
|
| e9b010 | 2003-05-17 | Henrik Grubbström (Grubba) | | Process.Process writer = Process.create_process(
RUNPIKE_ARRAY + ({
|
| 9fe0a4 | 2001-11-01 | Martin Stjernholm | | "-e",
|
| e9b010 | 2003-05-17 | Henrik Grubbström (Grubba) | | sprintf ("sleep(0.5); "
"Stdio.File f = Stdio.File(%O, \"w\"); "
"sleep(0.5); "
"f->close();", fifo)
}));
|
| 9fe0a4 | 2001-11-01 | Martin 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);
|
| 90d08a | 2001-11-01 | Martin Stjernholm | |
#endif
|
| 9fe0a4 | 2001-11-01 | Martin Stjernholm | | return 1;
]], 1);
]])
|
| 4716f0 | 2001-01-14 | Mirar (Pontus Hagland) | | cond([[0]],
[[
|
| 4ce3e4 | 2001-01-01 | Mirar (Pontus Hagland) | | test_any([[
// test if read() hangs when fd is closed by other thread
|
| 20a286 | 2001-01-01 | Mirar (Pontus Hagland) | | object f=Stdio.File();
object g=f->pipe();
|
| 4ce3e4 | 2001-01-01 | Mirar (Pontus Hagland) | | object t=thread_create(
lambda()
{
|
| 20a286 | 2001-01-01 | Mirar (Pontus Hagland) | | g->read(4);
|
| 4ce3e4 | 2001-01-01 | Mirar (Pontus Hagland) | | });
sleep(0.1); // yield
|
| 20a286 | 2001-01-01 | Mirar (Pontus Hagland) | | g->close(); // close same side of pipe as we have in read above
|
| 4ce3e4 | 2001-01-01 | Mirar (Pontus Hagland) | | sleep(0.1); // yield
if (!t->status()) return 0; // should be done now
|
| 20a286 | 2001-01-01 | Mirar (Pontus Hagland) | | // if not, there's no way to kill that thread
|
| 4ce3e4 | 2001-01-01 | Mirar (Pontus Hagland) | | return 1;]],1);
|
| 6f6eb2 | 1996-10-05 | Fredrik Hübinette (Hubbe) | | ]])
|
| 747bb8 | 1996-10-15 | Fredrik Hübinette (Hubbe) | |
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | // m_delete
|
| 8d1c57 | 2000-07-11 | Fredrik 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)
|
| e5bb7d | 1996-09-23 | Fredrik 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)
|
| 1d96e7 | 2003-01-15 | Martin Nilsson | | test_any([[mapping m=([1:1]); m[1]++; return m[1]++;]],2)
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | test_any([[mapping m=([]); m[1]++; m[1]++; return m[1];]],2)
|
| fb61ba | 1998-04-26 | Fredrik 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)
|
| bdba3f | 2001-06-20 | Henrik Grubbström (Grubba) | | test_any([[
|
| d5202d | 2001-06-20 | Henrik 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);
]])
|
| fb61ba | 1998-04-26 | Fredrik Hübinette (Hubbe) | | test_eq([[sizeof(mtest_m)]],sizeof(mtest_i))
test_equal(Array.sort_array(indices(mtest_m)),Array.sort_array(mtest_i))
test_equal(mtest_m,copy_value(mtest_m))
test_any([[multiset m=(<>);int e;
mixed a;
a=allocate(100);
for(e=0;e<100;e++)
{
m[reverse(e-50)]=1;
a[e]=reverse(e-50);
if(sizeof(m)!=e+1) return e;
}
add_constant("mtest_m2",m);
add_constant("mtest_i2",a);
return -1;
]],-1)
test_eq([[sizeof(mtest_m2)]],sizeof(mtest_i2))
test_any([[int e;multiset q=(<>),p=(<>); for(e=0;e<1000;e++) { p[reverse(e)]=1; q+=(<reverse(e)>); if(!equal(sort(indices(p)),sort(indices(q)))) return 0; } return 1;]],1)
test_equal(sort(indices(mtest_m|mtest_m2)),sort(mtest_i|mtest_i2))
test_equal(sort(indices(mtest_m&mtest_m2)),sort(mtest_i&mtest_i2))
test_equal(sort(indices(mtest_m-mtest_m2)),sort(mtest_i-mtest_i2))
test_equal(sort(indices(mtest_m^mtest_m2)),sort(mtest_i^mtest_i2))
test_equal(sort(indices(mtest_m2|mtest_m)),sort(mtest_i2|mtest_i))
test_equal(sort(indices(mtest_m2&mtest_m)),sort(mtest_i2&mtest_i))
test_equal(sort(indices(mtest_m2-mtest_m)),sort(mtest_i2-mtest_i))
test_equal(sort(indices(mtest_m2^mtest_m)),sort(mtest_i2^mtest_i))
test_do(add_constant("mtest_m"); add_constant("mtest_i"); )
test_do(add_constant("mtest_m2"); add_constant("mtest_i2"); )
|
| ebb0b4 | 1998-04-29 | Fredrik Hübinette (Hubbe) | | define([[MTEST]],[[test_equal([[mkmultiset(indices(allocate($1)))]],[[mkmultiset(reverse(indices(allocate($1))))]])]])
|
| fb61ba | 1998-04-26 | Fredrik 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]])
|
| 17f2a4 | 2001-03-02 | Marcus Comstedt | | test_equal([[lambda(multiset x){return ({x[17]++,x[17]++,x[17]++});}((<>))]],
[[({0,1,1})]])
|
| 7f202a | 2004-06-13 | Martin 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>));
|
| fb025e | 2004-05-19 | Martin 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);
]])
|
| e5bb7d | 1996-09-23 | Fredrik 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;
}
|
| 2de379 | 1997-02-11 | Fredrik Hübinette (Hubbe) | | add_constant("mtest_m",m);
add_constant("mtest_i",a);
add_constant("mtest_v",b);
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | return 1;
]],1)
test_eq([[sizeof(mtest_m)]],sizeof(mtest_i))
|
| 2de379 | 1997-02-11 | Fredrik 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))
|
| e5bb7d | 1996-09-23 | Fredrik 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);
|
| 1b8b4f | 2003-11-12 | Henrik Grubbström (Grubba) | | b[e]=e-50;
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | }
|
| 2de379 | 1997-02-11 | Fredrik Hübinette (Hubbe) | | add_constant("mtest_m2",m);
add_constant("mtest_i2",a);
add_constant("mtest_v2",b);
|
| e5bb7d | 1996-09-23 | Fredrik 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))
|
| 1b8b4f | 2003-11-12 | Henrik 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)))
|
| e66441 | 1998-04-27 | Fredrik 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");)
|
| ebb0b4 | 1998-04-29 | Fredrik Hübinette (Hubbe) | | define([[MTEST]],[[test_equal([[mkmapping(indices(allocate($1)),reverse(indices(allocate($1))))]],[[mkmapping(reverse(indices(allocate($1))),indices(allocate($1)))]])]])
|
| e5bb7d | 1996-09-23 | Fredrik 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]])
|
| 9e6d45 | 2001-09-04 | Fredrik 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;
}
}
}();
]])
|
| e66441 | 1998-04-27 | Fredrik 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)
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
|
| ee3780 | 1999-02-09 | Fredrik 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)
|
| 958ced | 2001-01-26 | Martin Stjernholm | | test_any([[
mapping m = set_weak_flag (([1:1]), 1);
m_delete (m, 1);
return get_weak_flag (([]));
]], 0);
|
| 17f2a4 | 2001-03-02 | Marcus Comstedt | | test_equal([[lambda(mapping x){return ({x[17]++,x[17]++,x[17]++});}(([]))]],
[[({0,1,2})]])
|
| 5215a8 | 2003-06-02 | Martin 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]))
|
| 639e6e | 2000-09-04 | Martin 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)
|
| 72a90c | 2000-09-23 | Martin 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)
|
| 639e6e | 2000-09-04 | Martin Stjernholm | |
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | // gc
|
| 44dbb6 | 2003-02-12 | Martin Stjernholm | |
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | test_true(intp(gc()));
|
| d9e9bd | 1996-12-05 | Fredrik 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);
|
| 5953b2 | 2000-06-10 | Martin 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);
|
| c023e9 | 1999-11-18 | Fredrik Hübinette (Hubbe) | |
|
| 14db07 | 2003-02-13 | Martin 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)
|
| c023e9 | 1999-11-18 | Fredrik Hübinette (Hubbe) | | test_any([[gc();
int q=lambda() { mixed foo; foo=lambda() { return foo; }; return 1; }();
return gc()>0;
]],1)
|
| 2db242 | 1999-10-29 | Martin Stjernholm | | test_true([[
object o = class{}();
mapping m = ([class{}(): o, o: class{}()]);
set_weak_flag (m, 1);
gc();
return !sizeof (m);
]])
|
| 9da7f4 | 2001-06-05 | Martin 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([[
|
| 2db242 | 1999-10-29 | Martin Stjernholm | | object o = class{}();
multiset m = (<o>);
set_weak_flag (m, 1);
m[class{}()] = 1;
m[o] = 0;
gc();
return !sizeof (m);
]])
|
| 1f342f | 2000-02-04 | Fredrik Hübinette (Hubbe) | |
|
| 813164 | 2001-01-17 | Martin Stjernholm | | test_do([[
|
| 64621b | 2004-07-16 | Henrik Grubbström (Grubba) | | mixed eat_stack(int|void probe)
|
| 813164 | 2001-01-17 | Martin Stjernholm | | {
|
| 64621b | 2004-07-16 | Henrik 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;
|
| 5f03ba | 2001-01-18 | Martin Stjernholm | | mixed err = 1;
|
| 64621b | 2004-07-16 | Henrik Grubbström (Grubba) | | if ((err = eat_stack()) != 10)
return intp(err) && err > 0 ? err + 1 : err;
|
| 5f03ba | 2001-01-18 | Martin Stjernholm | | if (err = catch {
class Foo
{
object foo;
static void create(object o) {foo = o;}
};
Foo foo;
for(int i=0; i < 10000; i++)
foo = Foo(foo);
gc();
}) return err;
|
| 813164 | 2001-01-17 | Martin Stjernholm | | };
|
| 45b9cf | 2001-01-18 | Martin Stjernholm | | if (mixed err = eat_stack()) throw (err);
|
| 813164 | 2001-01-17 | Martin Stjernholm | | ]])
|
| 1f342f | 2000-02-04 | Fredrik 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)
|
| 3825ec | 2000-04-14 | Martin 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();
]])
|
| 5953b2 | 2000-06-10 | Martin Stjernholm | |
test_any([[{
array a = ({({0})}); a[0][0] = a;
gc(); a = 0; return gc() > 0;
}]], 1)
|
| f06dc3 | 2000-12-14 | Martin Stjernholm | | test_any([[{
object o = class {}();
mapping m = ([o: ({17})]);
gc(); destruct (o); return gc() > 0;
}]], 1)
|
| 5953b2 | 2000-06-10 | Martin 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);
|
| d3ade9 | 2003-02-19 | Henrik Grubbström (Grubba) | | gc();
return set_weak_flag(a, 0);
|
| 5953b2 | 2000-06-10 | Martin Stjernholm | | }]], ({0}))
test_any_equal([[{
class Live {object o; void destroy() {}};
multiset l = set_weak_flag((<Live()>), 1);
|
| d3ade9 | 2003-02-19 | Henrik Grubbström (Grubba) | | gc();
return set_weak_flag(l, 0);
|
| 5953b2 | 2000-06-10 | Martin Stjernholm | | }]], (<>))
test_any_equal([[{
class Live {object o; void destroy() {}};
mapping m = set_weak_flag(([0: Live()]), 1);
|
| d3ade9 | 2003-02-19 | Henrik Grubbström (Grubba) | | gc();
return set_weak_flag(m, 0);
|
| 5953b2 | 2000-06-10 | Martin Stjernholm | | }]], ([]))
test_any_equal([[{
class Live {object o; void destroy() {}};
mapping m = set_weak_flag(([Live(): 0]), 1);
|
| d3ade9 | 2003-02-19 | Henrik Grubbström (Grubba) | | gc();
return set_weak_flag(m, 0);
|
| 5953b2 | 2000-06-10 | Martin Stjernholm | | }]], ([]))
test_any_equal([[{
array a = set_weak_flag(({4711, 0x54325827a124*0x12348795482485425}), 1);
|
| d3ade9 | 2003-02-19 | Henrik Grubbström (Grubba) | | gc();
return set_weak_flag(a, 0);
|
| 5953b2 | 2000-06-10 | Martin Stjernholm | | }]], ({4711, 0x54325827a124*0x12348795482485425}))
|
| a44f1a | 2000-09-15 | Martin Stjernholm | | test_any_equal([[{
object o = class Live {
|
| 14db07 | 2003-02-13 | Martin Stjernholm | | array g;
|
| a44f1a | 2000-09-15 | Martin Stjernholm | | array a = ({17});
|
| 14db07 | 2003-02-13 | Martin Stjernholm | | void create() {g = ({this_object()});}
|
| a44f1a | 2000-09-15 | Martin Stjernholm | | void destroy() {all_constants()->kablutt = a;}
}();
o = 0;
gc();
return all_constants()->kablutt;
}]], ({17}));
test_any([[{
object o = class Live {
|
| 14db07 | 2003-02-13 | Martin Stjernholm | | array g;
|
| a44f1a | 2000-09-15 | Martin Stjernholm | | array a = set_weak_flag (({({17})}), 1);
|
| 14db07 | 2003-02-13 | Martin Stjernholm | | void create() {g = ({this_object()});}
|
| a44f1a | 2000-09-15 | Martin 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 {
|
| 14db07 | 2003-02-13 | Martin Stjernholm | | array g;
|
| a44f1a | 2000-09-15 | Martin Stjernholm | | array a = set_weak_flag (({({17})}), 1);
|
| 14db07 | 2003-02-13 | Martin Stjernholm | | void create() {g = ({this_object()});}
|
| a44f1a | 2000-09-15 | Martin 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}));
|
| 2aeef5 | 2002-11-26 | Martin Nilsson | | test_do(add_constant("kablutt");)
test_do(add_constant("blatinka");)
|
| 5bf37d | 2000-10-13 | Fredrik Hübinette (Hubbe) | |
|
| 0455ff | 2003-03-30 | Martin 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)
|
| 5953b2 | 2000-06-10 | Martin 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)
|
| 96dd6f | 2000-06-12 | Martin Stjernholm | | test_do([[{
object o = class {}();
array a = ({o});
destruct (o);
gc();
}]]);
|
| 6d30f5 | 2000-07-11 | Martin 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);
|
| 5bf37d | 2000-10-13 | Fredrik Hübinette (Hubbe) | |
|
| 6d30f5 | 2000-07-11 | Martin Stjernholm | | test_any([[{
class Foo {
|
| 14db07 | 2003-02-13 | Martin Stjernholm | | array(Foo) f = ({this_object()});
|
| 6d30f5 | 2000-07-11 | Martin 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 {
|
| 14db07 | 2003-02-13 | Martin Stjernholm | | array(Foo) f = ({this_object()});
|
| 6d30f5 | 2000-07-11 | Martin 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);
|
| 10c4a4 | 2000-08-17 | Martin Stjernholm | | test_any([[{
|
| bc23b4 | 2003-01-11 | Martin Stjernholm | | gc();
|
| 10c4a4 | 2000-08-17 | Martin 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;
|
| bc23b4 | 2003-01-11 | Martin Stjernholm | | return gc() >= 1;
|
| 10c4a4 | 2000-08-17 | Martin Stjernholm | | }]], 1);
test_any([[{
|
| bc23b4 | 2003-01-11 | Martin Stjernholm | | gc();
|
| 10c4a4 | 2000-08-17 | Martin Stjernholm | | array a = set_weak_flag (({0, this_object()}), 1);
a[0] = a;
a = 0;
|
| bc23b4 | 2003-01-11 | Martin Stjernholm | | return gc() >= 1;
|
| 10c4a4 | 2000-08-17 | Martin Stjernholm | | }]], 1);
test_any([[{
|
| bc23b4 | 2003-01-11 | Martin Stjernholm | | gc();
|
| 10c4a4 | 2000-08-17 | Martin Stjernholm | | array y = set_weak_flag (({0}), 1), z = set_weak_flag (({y}), 1);
y[0] = z;
y = z = 0;
|
| bc23b4 | 2003-01-11 | Martin Stjernholm | | return gc() >= 2;
|
| 10c4a4 | 2000-08-17 | Martin Stjernholm | | }]], 1);
test_any([[{
class Live {
array a;
|
| 14db07 | 2003-02-13 | Martin Stjernholm | | array g = ({this_object()});
|
| 10c4a4 | 2000-08-17 | Martin 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)
|
| 3cc12a | 2001-07-01 | Martin Stjernholm | | add_constant ("my_little_error", "GC garbed weak things too early.\n");
|
| 10c4a4 | 2000-08-17 | Martin Stjernholm | | }
};
|
| bc23b4 | 2003-01-11 | Martin Stjernholm | | gc();
|
| 10c4a4 | 2000-08-17 | Martin Stjernholm | | object o = Live();
o = 0;
|
| bc23b4 | 2003-01-11 | Martin Stjernholm | | int res = gc() >= 3;
|
| 3cc12a | 2001-07-01 | Martin Stjernholm | | if (all_constants()->my_little_error)
error (all_constants()->my_little_error);
return res;
|
| 10c4a4 | 2000-08-17 | Martin Stjernholm | | }]], 1);
|
| 3cc12a | 2001-07-01 | Martin 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);
}]]);
|
| 3fe44f | 2001-07-02 | Martin Stjernholm | |
test_do([[{
object o = compile_string(#"
class Foo
{
int i;
class Bar
{
int j = i++; // Ensure parent pointer.
}
inherit Bar;
}")();
o = 0;
gc();
}]]);
|
| 5bf37d | 2000-10-13 | Fredrik Hübinette (Hubbe) | |
|
| 639e6e | 2000-09-04 | Martin Stjernholm | | test_do([[{
mapping a = ([1:({17}),2:3,4:5,6:7,8:9]), b = a + ([]);
set_weak_flag (b, 1);
gc();
}]]);
test_do([[{
mapping a = ([1:({17})]), b = a + ([]);
set_weak_flag (b, 1);
gc();
}]]);
test_any([[{
mapping a = ([17:({17})]);
for (int i = 0; i < 10; i++) a[class{}()] = i;
mapping b = a + ([]);
set_weak_flag (b, 1);
foreach (indices (a), mixed o) if (objectp (o)) destruct (o);
gc();
return sizeof (a) == 1 && sizeof (b) == 1;
}]], 1);
test_any([[{
mapping a = ([17:({17})]);
for (int i = 0; i < 10; i++) a[class{}()] = i;
mapping b = a + ([]);
set_weak_flag (a, 1);
foreach (indices (a), mixed o) if (objectp (o)) destruct (o);
gc();
return sizeof (a) == 1 && sizeof (b) == 1;
}]], 1);
test_any([[{
mapping a = ([17:({17})]);
for (int i = 0; i < 10; i++) a[class{}()] = i;
mapping b = a + ([]);
set_weak_flag (a, 1);
set_weak_flag (b, 1);
foreach (indices (a), mixed o) if (objectp (o)) destruct (o);
gc();
return !sizeof (a) && !sizeof (b);
}]], 1);
test_any([[{
mapping a = ([17:({17})]);
set_weak_flag (a, 1);
for (int i = 0; i < 10; i++) a[class{}()] = i;
mapping b = a + ([]);
foreach (indices (a), mixed o) if (objectp (o)) destruct (o);
gc();
return sizeof (a) == 1 && sizeof (b) == 1;
}]], 1);
|
| a44f1a | 2000-09-15 | Martin Stjernholm | | test_any([[{
mapping a = set_weak_flag (([17: set_weak_flag (({({17})}), 1)]), 1);
return gc() >= 2 && !sizeof (a);
}]], 1);
|
| 639e6e | 2000-09-04 | Martin Stjernholm | |
|
| 23d1c7 | 2000-09-30 | Martin 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);
|
| f06dc3 | 2000-12-14 | Martin Stjernholm | | test_any([[{
|
| 23d1c7 | 2000-09-30 | Martin 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);
|
| a1cf47 | 2001-07-12 | Martin Stjernholm | | test_any_equal([[{
array a = set_weak_flag (({1, "foo", 3.14}), 1);
gc();
|
| d3ade9 | 2003-02-19 | Henrik Grubbström (Grubba) | | return set_weak_flag(a, 0);
|
| a1cf47 | 2001-07-12 | Martin Stjernholm | | }]], ({1, "foo", 3.14}));
test_any_equal([[{
multiset a = set_weak_flag ((<1, "foo", 3.14>), 1);
gc();
|
| d3ade9 | 2003-02-19 | Henrik Grubbström (Grubba) | | return set_weak_flag(a, 0);
|
| a1cf47 | 2001-07-12 | Martin Stjernholm | | }]], (<1, "foo", 3.14>));
test_any_equal([[{
mapping a = set_weak_flag (([1: 1, "foo": "foo", 3.14: 3.14]), 1);
gc();
|
| d3ade9 | 2003-02-19 | Henrik Grubbström (Grubba) | | return set_weak_flag(a, 0);
|
| a1cf47 | 2001-07-12 | Martin Stjernholm | | }]], ([1: 1, "foo": "foo", 3.14: 3.14]));
|
| 4c7c35 | 2001-10-15 | Martin 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();
}]]);
|
| 5bf37d | 2000-10-13 | Fredrik Hübinette (Hubbe) | |
|
| 007e54 | 2003-01-28 | Marcus Comstedt | | test_tests([[inherit "]]SRCDIR[[/test_gc.pike";]])
|
| 46d4e7 | 2000-06-12 | Martin 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();
]])
|
| 9da7f4 | 2001-06-05 | Martin 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)
|
| b2764a | 2001-06-27 | Martin Stjernholm | |
|
| fcb322 | 2001-07-05 | Martin 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();
]])
|
| b2764a | 2001-06-27 | Martin 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();
|
| e813b0 | 2001-12-10 | Martin Stjernholm | | return x && !sizeof (indices (x + (<>)));
|
| b2764a | 2001-06-27 | Martin 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)
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
|
| 00dbf6 | 2003-11-08 | Martin 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]])
|
| a0bcec | 1999-10-23 | Fredrik Noring | | cond([[ sizeof( cpp("__AUTO_BIGNUM__")/"__AUTO_BIGNUM__" ) == 1 ]],
[[
// 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) ]])
|
| f8dd21 | 2003-10-10 | Henrik Grubbström (Grubba) | | test_eq("9223372036854775808", [[ (string)0x8000000000000000 ]])
test_eq("9223372036854775809", [[ (string)0x8000000000000001 ]])
test_eq("-9223372036854775808", [[ (string)-0x8000000000000000 ]])
|
| 28e5f1 | 2003-10-11 | Henrik Grubbström (Grubba) | | test_eq("-9223372036854775809", [[ (string)-0x8000000000000001 ]])
|
| f8dd21 | 2003-10-10 | Henrik Grubbström (Grubba) | | test_eq("9223372036854775808", [[ (string)-(-0x8000000000000000) ]])
test_eq("9223372036854775809", [[ (string)-(-0x8000000000000001) ]])
|
| a0bcec | 1999-10-23 | Fredrik Noring | | test_eq("123456789123456789", [[ (string)123456789123456789 ]])
test_eq("-123456789123456789", [[ (string)-123456789123456789 ]])
test_eq("335812727629498640265", [[ (string)0x123456789123456789 ]])
test_eq("-335812727629498640265", [[ (string)-0x123456789123456789 ]])
test_eq("718046312823", [[ (string)012345671234567 ]])
test_eq("-718046312823", [[ (string)-012345671234567 ]])
|
| 565645 | 1999-10-26 | Fredrik Noring | | test_eq("1125899906842624", [[ (string)0b100000000000000000000000000000000000000000000000000 ]])
test_eq("-1125899906842624", [[ (string)-0b100000000000000000000000000000000000000000000000000 ]])
|
| 926208 | 2003-02-26 | Martin Stjernholm | | test_eq(500000000 * 10, 5000000000)
|
| f8dd21 | 2003-10-10 | Henrik Grubbström (Grubba) | | test_eq(5000000000000000000 * 10, 50000000000000000000)
|
| 00dbf6 | 2003-11-08 | Martin Stjernholm | |
// Numbers that shouldn't be native integers. Has to resort to
// strange methods to test this since bignums behave like native
// integers in almost every way.
test_do([[ _next ((mixed) Int.NATIVE_MAX + 1) ]])
test_do([[ _next ((mixed) Int.NATIVE_MIN - 1) ]])
|
| 9ae591 | 2003-10-11 | Henrik Grubbström (Grubba) | | ]])
|
| 00dbf6 | 2003-11-08 | Martin Stjernholm | |
// These numbers should be native integers.
test_eval_error([[ _next ((mixed) -0x80000000) ]])
test_eval_error([[ _next ((mixed) -0x7fffffff) ]])
test_eval_error([[ _next ((mixed) 0x7fffffff) ]])
test_eval_error([[ _next ((mixed) Int.NATIVE_MAX) ]])
test_eval_error([[ _next ((mixed) Int.NATIVE_MIN) ]])
|
| 9ae591 | 2003-10-11 | Henrik Grubbström (Grubba) | |
cond([[ sizeof( cpp("__AUTO_BIGNUM__")/"__AUTO_BIGNUM__" ) == 1 ]],
[[
|
| a0bcec | 1999-10-23 | Fredrik Noring | | // Test incrementations (FIXME: More cases?).
test_eq("2147483648",
[[ (string)(class { int f(int x) { x++; return x; } })()->f(0x7fffffff) ]])
test_eq("2147483648",
[[ (string)(class { int f(int x) { ++x; return x; } })()->f(0x7fffffff) ]])
test_eq("2147483648",
[[ (string)(class { int x=0x7fffffff;int f() { ++x;return x; } })()->f() ]])
test_eq("2147483648",
[[ (string)(class { int x=0x7fffffff;int f() { x++;return x; } })()->f() ]])
test_eq("2147483648",
[[ (string)(class { int f() { int x=0x7fffffff;++x;return x; } })()->f() ]])
test_eq("2147483648",
[[ (string)(class { int f() { int x=0x7fffffff;x++;return x; } })()->f() ]])
|
| f8dd21 | 2003-10-10 | Henrik Grubbström (Grubba) | | test_eq("9223372036854775808",
[[ (string)(class { int f(int x) { x++; return x; } })()->f(0x7fffffffffffffff) ]])
test_eq("9223372036854775808",
[[ (string)(class { int f(int x) { ++x; return x; } })()->f(0x7fffffffffffffff) ]])
test_eq("9223372036854775808",
[[ (string)(class { int x=0x7fffffffffffffff;int f() { ++x;return x; } })()->f() ]])
test_eq("9223372036854775808",
[[ (string)(class { int x=0x7fffffffffffffff;int f() { x++;return x; } })()->f() ]])
test_eq("9223372036854775808",
[[ (string)(class { int f() { int x=0x7fffffffffffffff;++x;return x; } })()->f() ]])
test_eq("9223372036854775808",
[[ (string)(class { int f() { int x=0x7fffffffffffffff;x++;return x; } })()->f() ]])
|
| a0bcec | 1999-10-23 | Fredrik Noring | |
// Test decrementations (FIXME: More cases?).
test_eq("-2147483649",
[[ (string)(class { int f(int x) { x--; return x; } })()->f(-0x80000000) ]])
test_eq("-2147483649",
[[ (string)(class { int f(int x) { --x; return x; } })()->f(-0x80000000) ]])
test_eq("-2147483649",
[[ (string)(class { int x=-0x80000000;int f() { --x;return x; } })()->f()]])
test_eq("-2147483649",
[[ (string)(class { int x=-0x80000000;int f() { x--;return x; } })()->f()]])
test_eq("-2147483649",
[[ (string)(class { int f() { int x=-0x80000000;--x;return x; } })()->f()]])
test_eq("-2147483649",
[[ (string)(class { int f() { int x=-0x80000000;x--;return x; } })()->f()]])
|
| f8dd21 | 2003-10-10 | Henrik Grubbström (Grubba) | | test_eq("-9223372036854775809",
[[ (string)(class { int f(int x) { x--; return x; } })()->f(-0x8000000000000000) ]])
test_eq("-9223372036854775809",
[[ (string)(class { int f(int x) { --x; return x; } })()->f(-0x8000000000000000) ]])
test_eq("-9223372036854775809",
[[ (string)(class { int x=-0x8000000000000000;int f() { --x;return x; } })()->f()]])
test_eq("-9223372036854775809",
[[ (string)(class { int x=-0x8000000000000000;int f() { x--;return x; } })()->f()]])
test_eq("-9223372036854775809",
[[ (string)(class { int f() { int x=-0x8000000000000000;--x;return x; } })()->f()]])
test_eq("-9223372036854775809",
[[ (string)(class { int f() { int x=-0x8000000000000000;x--;return x; } })()->f()]])
|
| 52bb18 | 1999-10-25 | Fredrik Hübinette (Hubbe) | |
test_encode(1<<99);
|
| a0bcec | 1999-10-23 | Fredrik Noring | | ]])
cond([[ sizeof( cpp("__AUTO_BIGNUM__")/"__AUTO_BIGNUM__" ) == 1 ]],
[[
|
| 95fc7d | 1999-10-24 | Fredrik Noring | | // - Left shift.
|
| a0bcec | 1999-10-23 | Fredrik Noring | | test_eq("1073741824", [[ (string)(1<<30) ]])
test_eq("2147483648", [[ (string)(1<<31) ]])
test_eq("4294967296", [[ (string)(1<<32) ]])
test_eq("8589934592", [[ (string)(1<<33) ]])
test_eq("1267650600228229401496703205376", [[ (string)(1<<100) ]])
|
| 2c1621 | 2003-03-30 | Henrik Grubbström (Grubba) | | test_eval_error(return 1<<100000000000000000000)
test_eval_error(return (-1)<<100000000000000000000)
test_eq(0<<100000000000000000000, 0)
test_eval_error(return 100000000000000000000<<100000000000000000000)
test_eval_error(return (-100000000000000000000)<<100000000000000000000)
|
| 126bf2 | 2002-10-15 | Marcus Comstedt | |
|
| 95fc7d | 1999-10-24 | Fredrik Noring | | // - Right shift.
|
| a0bcec | 1999-10-23 | Fredrik Noring | | test_eq("53265209898187398182",
[[ (string)((int)"54543574935743895738479">>10) ]])
test_false([[ objectp((int)"54543574935743895738479">>60) ]])
test_eq(0, [[ 25>>30 ]])
test_eq(0, [[ 25>>31 ]])
test_eq(0, [[ 25>>32 ]])
test_eq(0, [[ 25>>33 ]])
|
| 2c1621 | 2003-03-30 | Henrik Grubbström (Grubba) | | test_eq(1>>100000000000000000000, 0)
test_eq(-1>>100000000000000000000, -1)
test_eq(0>>100000000000000000000, 0)
test_eq(100000000000000000000>>100000000000000000000, 0)
test_eq((-100000000000000000000)>>100000000000000000000, -1)
|
| 126bf2 | 2002-10-15 | Marcus Comstedt | |
|
| 95fc7d | 1999-10-24 | Fredrik Noring | | // - abs.
|
| a0bcec | 1999-10-23 | Fredrik Noring | | test_eq("2147483648", [[ (string)abs(-0x80000000) ]])
test_eq("2147483648", [[ (string)abs(0x80000000) ]])
test_eq("2147483649", [[ (string)abs(0x80000001) ]])
test_eq("2147483649", [[ (string)abs(-0x80000001) ]])
|
| f8dd21 | 2003-10-10 | Henrik Grubbström (Grubba) | | test_eq("9223372036854775808", [[ (string)abs(-0x8000000000000000) ]])
test_eq("9223372036854775808", [[ (string)abs(0x8000000000000000) ]])
test_eq("9223372036854775809", [[ (string)abs(0x8000000000000001) ]])
test_eq("9223372036854775809", [[ (string)abs(-0x8000000000000001) ]])
|
| 9ae591 | 2003-10-11 | Henrik Grubbström (Grubba) | | ]])
|
| a0bcec | 1999-10-23 | Fredrik Noring | |
|
| 9ae591 | 2003-10-11 | Henrik Grubbström (Grubba) | | cond([[ sizeof( cpp("__AUTO_BIGNUM__")/"__AUTO_BIGNUM__" ) == 1 ]],
[[
|
| 95fc7d | 1999-10-24 | Fredrik Noring | | // - Add.
|
| a0bcec | 1999-10-23 | Fredrik Noring | | test_eq("2147483648", [[ (string)(0x7fffffff + 1) ]])
test_eq("2147483649", [[ (string)(0x7fffffff + 2) ]])
|
| f8dd21 | 2003-10-10 | Henrik Grubbström (Grubba) | | test_eq("-2147483648", [[ (string)((-0x80000001) + 1) ]])
test_eq("9223372036854775808", [[ (string)(0x7fffffffffffffff + 1) ]])
|
| 28e5f1 | 2003-10-11 | Henrik Grubbström (Grubba) | | test_eq("9223372036854775809", [[ (string)(0x7fffffffffffffff + 2) ]])
|
| f8dd21 | 2003-10-10 | Henrik Grubbström (Grubba) | | test_eq("-9223372036854775808", [[ (string)((-0x8000000000000001) + 1) ]])
|
| a0bcec | 1999-10-23 | Fredrik Noring | | test_eq("2684354560", [[ (string)(0x50000000 + 0x50000000) ]])
test_eq("-2684354560", [[ (string)((-0x50000000) + (-0x50000000)) ]])
|
| b72e6d | 1999-10-24 | Henrik Grubbström (Grubba) | | test_false([[ objectp((-0x80000001) + 1) ]])
|
| a0bcec | 1999-10-23 | Fredrik Noring | |
|
| cb5d8e | 1999-10-31 | Henrik Grubbström (Grubba) | | // - Add-eq.
|
| a105d7 | 1999-10-31 | Henrik Grubbström (Grubba) | | test_eq([[lambda() { int a=0x100000000; int b = a; a += 1; return b+a; }()]],
[[0x200000001]])
|
| cb5d8e | 1999-10-31 | Henrik Grubbström (Grubba) | |
|
| 95fc7d | 1999-10-24 | Fredrik Noring | | // - Sub.
|
| a0bcec | 1999-10-23 | Fredrik Noring | | test_eq("-2147483648", [[ (string)(-0x7fffffff - 1) ]])
test_eq("-2147483649", [[ (string)(-0x80000000 - 1) ]])
|
| b72e6d | 1999-10-24 | Henrik Grubbström (Grubba) | | test_eq("2147483647", [[ (string)(0x80000000 - 1) ]])
|
| 9ae591 | 2003-10-11 | Henrik Grubbström (Grubba) | | test_eq("-9223372036854775808", [[ (string)(-0x7fffffffffffffff - 1) ]])
test_eq("-9223372036854775809", [[ (string)(-0x8000000000000000 - 1) ]])
test_eq("9223372036854775807", [[ (string)(0x8000000000000000 - 1) ]])
|
| b72e6d | 1999-10-24 | Henrik Grubbström (Grubba) | | test_false([[ objectp(0x80000000 - 1) ]])
|
| a0bcec | 1999-10-23 | Fredrik Noring | |
|
| 95fc7d | 1999-10-24 | Fredrik Noring | | // - Multiplication.
|
| a0bcec | 1999-10-23 | Fredrik Noring | | test_eq("6442450941", [[ (string)(0x7fffffff * 3) ]])
test_eq("-6442450941", [[ (string)(0x7fffffff * -3) ]])
|
| 0c09a7 | 1999-10-30 | Fredrik Hübinette (Hubbe) | | test_eq(-2147483648*-1,2147483648)
|
| 9ae591 | 2003-10-11 | Henrik Grubbström (Grubba) | | test_eq(-9223372036854775808*-1,9223372036854775808)
|
| a0bcec | 1999-10-23 | Fredrik Noring | |
// Division.
test_eq("1073741824", [[ (string)((int)"2147483648" / 2) ]])
test_false([[ objectp((int)"2147483648" / 2) ]])
|
| aa5ef3 | 1999-10-23 | Fredrik Noring | | test_eq("13934998268672547360069539025",
[[ (string)(48324683476346278246238462784624627348 / 3467864333) ]])
|
| a0bcec | 1999-10-23 | Fredrik Noring | |
|
| 4619f1 | 2003-09-09 | Martin Stjernholm | | // sprintf (and the describe stuff in the master)
test_do([[sprintf ("%O", 10->pow);]])
|
| 02aa91 | 1999-11-06 | Fredrik Hübinette (Hubbe) | | ]])
cond([[ sizeof( cpp("__AUTO_BIGNUM__")/"__AUTO_BIGNUM__" ) == 1 ]],
[[
|
| 95fc7d | 1999-10-24 | Fredrik Noring | | // - sscanf.
|
| a0bcec | 1999-10-23 | Fredrik Noring | | test_eq("12345678901234567890",
[[ (string)array_sscanf("12345678901234567890", "%d")[0] ]])
test_eq("1375488932614371410344080",
[[ (string)array_sscanf("123456789F01234567890", "%x")[0] ]])
|
| f21880 | 2001-06-05 | Fredrik Hübinette (Hubbe) | | test_eq("1375488932614371410344080",
[[ (string)array_sscanf("0x123456789F01234567890", "%x")[0] ]])
test_eq("1375488932614371410344080",
[[ (string)array_sscanf("0X123456789F01234567890", "%x")[0] ]])
|
| a0bcec | 1999-10-23 | Fredrik Noring | | test_eq("1375488932614371410344080",
[[ (string)array_sscanf("0x123456789F01234567890", "%i")[0] ]])
|
| f21880 | 2001-06-05 | Fredrik Hübinette (Hubbe) | | test_eq("1375488932614371410344080",
[[ (string)array_sscanf("0X123456789F01234567890", "%i")[0] ]])
|
| a0bcec | 1999-10-23 | Fredrik Noring | | test_eq("45954944846776",
[[ (string)array_sscanf("1234567012345670", "%o")[0] ]])
test_eq("45954944846776",
[[ (string)array_sscanf("01234567012345670", "%i")[0] ]])
|
| 565645 | 1999-10-26 | Fredrik Noring | | test_eq("11", [[ (string)array_sscanf("1011", "%b")[0] ]])
test_eq("1125968643114208", [[ (string)array_sscanf("100000000000001000000000001000000000100010011100000", "%b")[0] ]])
test_eq("11", [[ (string)array_sscanf("0b1011", "%i")[0] ]])
test_eq("1125968643114208", [[ (string)array_sscanf("0b100000000000001000000000001000000000100010011100000", "%i")[0] ]])
|
| a0bcec | 1999-10-23 | Fredrik Noring | |
test_eq("-12345678901234567890",
[[ (string)array_sscanf("-12345678901234567890", "%d")[0] ]])
test_eq("-1375488932614371410344080",
[[ (string)array_sscanf("-123456789F01234567890", "%x")[0] ]])
test_eq("-1375488932614371410344080",
[[ (string)array_sscanf("-0x123456789F01234567890","%i")[0] ]])
test_eq("-45954944846776",
[[ (string)array_sscanf("-1234567012345670", "%o")[0] ]])
test_eq("-45954944846776",
[[ (string)array_sscanf("-01234567012345670", "%i")[0] ]])
|
| 565645 | 1999-10-26 | Fredrik Noring | | test_eq("-11", [[ (string)array_sscanf("-1011", "%b")[0] ]])
test_eq("-1125968643114208", [[ (string)array_sscanf("-100000000000001000000000001000000000100010011100000", "%b")[0] ]])
test_eq("-11", [[ (string)array_sscanf("-0b1011", "%i")[0] ]])
test_eq("-1125968643114208", [[ (string)array_sscanf("-0b100000000000001000000000001000000000100010011100000", "%i")[0] ]])
|
| 6ee24a | 1999-10-24 | Fredrik Noring | |
|
| eccd0a | 1999-10-29 | Fredrik Noring | | test_eq([[ sprintf("%x", @array_sscanf("\0\0\0\0\1\2\3\4", "%4c")) ]], "0")
test_eq([[ sprintf("%x", @array_sscanf("\0\0\0\0\1\2\3\4", "%8c")) ]], "1020304")
test_eq([[ sprintf("%08x", @array_sscanf("\0\0\0\0\1\2\3\4", "%8c")) ]], "01020304")
test_eq([[ sprintf("%08x", @array_sscanf("\0\0\0\5\1\2\3\4", "%8c")) ]], "501020304")
test_eq([[ sprintf("%08x", @array_sscanf("\0\0\6\5\1\2\3\4", "%8c")) ]], "60501020304")
test_eq([[ sprintf("%08x", @array_sscanf("\0\7\6\5\1\2\3\4", "%8c")) ]], "7060501020304")
test_eq([[ sprintf("%08x", @array_sscanf("\8\7\6\5\1\2\3\4", "%8c")) ]], "3807060501020304")
test_eq([[ sprintf("%08x", @array_sscanf("\010\7\6\5\1\2\3\4", "%8c")) ]], "807060501020304")
|
| f21880 | 2001-06-05 | Fredrik Hübinette (Hubbe) | | test_equal([[ ({ 118 }) ]], [[ array_sscanf("0x76", "%x") ]])
test_equal([[ ({42 }) ]], [[ array_sscanf("101010", "%b") ]])
test_equal([[ ({42 }) ]], [[ array_sscanf("0b101010", "%b") ]])
test_equal([[ ({42 }) ]], [[ array_sscanf("0B101010", "%b") ]])
test_equal([[ ({ 557239244978618154304871 }) ]],
[[ array_sscanf("0x76000000000001234567", "%x") ]])
|
| 565645 | 1999-10-26 | Fredrik Noring | |
|
| 58d1d2 | 2001-05-14 | Fredrik Hübinette (Hubbe) | | test_equal([[array_sscanf("foo \12345 bar <fie>","%[^<]")]],
[[ ({"foo \12345 bar " }) ]])
|
| 565645 | 1999-10-26 | Fredrik Noring | | test_equal(471100000000000000000000000000000000000000000000042,
(int)(mixed)471100000000000000000000000000000000000000000000042)
|
| 0d1f2a | 1999-10-26 | Fredrik Noring | | test_eq(6745697846498645967,
[[ Gmp.mpz("6745697846498645967")->cast_to_int(); ]])
|
| a0bcec | 1999-10-23 | Fredrik Noring | | ]])
|
| 95fc7d | 1999-10-24 | Fredrik Noring | | cond([[ sizeof( cpp("__AUTO_BIGNUM__")/"__AUTO_BIGNUM__" ) == 1 ]],
[[
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))]])
|
| 09f3c4 | 2003-11-15 | Martin Stjernholm | |
test_eval_error([[ _next ((mixed) decode_value (encode_value (Int.NATIVE_MAX))) ]])
test_eval_error([[ _next ((mixed) decode_value (encode_value (Int.NATIVE_MIN))) ]])
test_do([[ _next ((mixed) decode_value (encode_value (Int.NATIVE_MAX + 1))) ]])
test_do([[ _next ((mixed) decode_value (encode_value (Int.NATIVE_MIN - 1))) ]])
|
| 95fc7d | 1999-10-24 | Fredrik Noring | | ]])
cond([[ sizeof( cpp("__AUTO_BIGNUM__")/"__AUTO_BIGNUM__" ) == 1 ]],
[[
|
| 08b980 | 1999-10-30 | Fredrik Noring | | test_eq(2147483648, -2147483648/-1)
test_eq(2147483648, -2147483648*-1)
|
| 95fc7d | 1999-10-24 | Fredrik Noring | | test_true([[ random(0x7fffffff)+1 ]])
test_true([[ random(0x7ffffffff)+1 ]])
test_true([[ sqrt(0x7fffffff)+1 ]])
test_true([[ sqrt(0x7ffffffff)+1 ]])
|
| a1e8a9 | 1999-10-29 | Fredrik Noring | |
test_true([[ catch { destruct((mixed)0x4783647824687234628462); } ]])
|
| 2db242 | 1999-10-29 | Martin Stjernholm | |
test_any_equal([[
array a = ({4711, 0x54325827a124*0x12348795482485425});
set_weak_flag (a, 1);
gc();
|
| d3ade9 | 2003-02-19 | Henrik Grubbström (Grubba) | | return set_weak_flag(a, 0);
|
| 2db242 | 1999-10-29 | Martin Stjernholm | | ]], [[ ({4711, 0x54325827a124*0x12348795482485425}) ]])
test_any_equal([[
mapping m = ([
4711: 0x54325827a124*0x12348795482485425,
0x54325827124*0x1234879548a2485425: 1174,
]);
set_weak_flag (m, 1);
gc();
|
| d3ade9 | 2003-02-19 | Henrik Grubbström (Grubba) | | return set_weak_flag(m, 0);
|
| 2db242 | 1999-10-29 | Martin Stjernholm | | ]], [[ ([
4711: 0x54325827a124*0x12348795482485425,
0x54325827124*0x1234879548a2485425: 1174,
]) ]])
|
| 95fc7d | 1999-10-24 | Fredrik Noring | | ]])
|
| 622953 | 1999-11-01 | Mirar (Pontus Hagland) | | cond([[ sizeof( cpp("__AUTO_BIGNUM__")/"__AUTO_BIGNUM__" ) == 1 ]],
[[
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)
|
| 49c2db | 1999-12-08 | Fredrik Noring | |
test_true([[ floatp((1<<99)/3.14) ]]);
test_true([[ floatp((1<<99)*3.14) ]]);
test_true([[ floatp((1<<99)-3.14) ]]);
test_true([[ floatp((1<<99)+3.14) ]]);
|
| 622953 | 1999-11-01 | Mirar (Pontus Hagland) | | ]])
|
| 2dc4c7 | 2004-02-17 | Mirar (Pontus Hagland) | | cond([[ sizeof( cpp("__AUTO_BIGNUM__")/"__AUTO_BIGNUM__" ) == 1 ]],
[[
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);
]])
cond([[ sizeof( cpp("__AUTO_BIGNUM__")/"__AUTO_BIGNUM__" ) == 1 ]],
[[
test_eq([[(12)*(3)]],0x24);
test_eq([[(12)*(3*(1<<32))]],0x2400000000);
test_eq([[(12)*(3*(1<<64))]],0x240000000000000000);
test_eq([[(12)*(3*(1<<128))]],0x2400000000000000000000000000000000);
test_eq([[(12*(1<<32))*(3)]],0x2400000000);
test_eq([[(12*(1<<32))*(3*(1<<32))]],0x240000000000000000);
test_eq([[(12*(1<<32))*(3*(1<<64))]],0x24000000000000000000000000);
test_eq([[(12*(1<<32))*(3*(1<<128))]],0x240000000000000000000000000000000000000000);
test_eq([[(12*(1<<64))*(3)]],0x240000000000000000);
test_eq([[(12*(1<<64))*(3*(1<<32))]],0x24000000000000000000000000);
test_eq([[(12*(1<<64))*(3*(1<<64))]],0x2400000000000000000000000000000000);
test_eq([[(12*(1<<64))*(3*(1<<128))]],0x24000000000000000000000000000000000000000000000000);
test_eq([[(12*(1<<128))*(3)]],0x2400000000000000000000000000000000);
test_eq([[(12*(1<<128))*(3*(1<<32))]],0x240000000000000000000000000000000000000000);
test_eq([[(12*(1<<128))*(3*(1<<64))]],0x24000000000000000000000000000000000000000000000000);
test_eq([[(12*(1<<128))*(3*(1<<128))]],0x240000000000000000000000000000000000000000000000000000000000000000);
test_eq([[(12)/(3)]],0x4);
test_eq([[(12)/(3*(1<<32))]],0x0);
test_eq([[(12)/(3*(1<<64))]],0x0);
test_eq([[(12)/(3*(1<<128))]],0x0);
test_eq([[(12*(1<<32))/(3*(1<<32))]],0x4);
test_eq([[(12*(1<<32))/(3*(1<<64))]],0x0);
test_eq([[(12*(1<<32))/(3*(1<<128))]],0x0);
test_eq([[(12*(1<<64))/(3*(1<<64))]],0x4);
test_eq([[(12*(1<<64))/(3*(1<<128))]],0x0);
test_eq([[(12*(1<<128))/(3*(1<<128))]],0x4);
test_eq([[(17+12)%(3)]],0x2);
test_eq([[(17+12)%(3*(1<<32))]],0x1d);
test_eq([[(17+12)%(3*(1<<64))]],0x1d);
test_eq([[(17+12)%(3*(1<<128))]],0x1d);
test_eq([[(17+12*(1<<32))%(3*(1<<32))]],0x11);
test_eq([[(17+12*(1<<32))%(3*(1<<64))]],0xc00000011);
test_eq([[(17+12*(1<<32))%(3*(1<<128))]],0xc00000011);
test_eq([[(17+12*(1<<64))%(3*(1<<64))]],0x11);
test_eq([[(17+12*(1<<64))%(3*(1<<128))]],0xc0000000000000011);
test_eq([[(17+12*(1<<128))%(3*(1<<128))]],0x11);
cond( [[ master()->resolv("Gmp")->mpz ]],
[[
|
| 4fcc7a | 2004-03-12 | Henrik Grubbström (Grubba) | | test_eq([[Gmp.mpz(68719476736)/Gmp.mpz(12884901888)]],5);
test_eq([[Gmp.mpz(123456789012345678901234567890)/Gmp.mpz(12884901888)]],
Gmp.mpz(9581507883061474724));
test_eq([[Gmp.mpz(123456789012345678901234567890)/
Gmp.mpz(67890123456789012345)]],1818479371);
test_eq([[Gmp.mpz(123456789012345678901234567890)/
Gmp.mpz(67890123456789)]],Gmp.mpz(1818479371169857));
|
| 2dc4c7 | 2004-02-17 | Mirar (Pontus Hagland) | | ]] )
]])
|
| 9c8ca0 | 2000-11-05 | Mirar (Pontus Hagland) | | cond([[ sizeof( cpp("__AUTO_BIGNUM__")/"__AUTO_BIGNUM__" ) == 1 ]],
[[
test_any([[int a=10->pow(30); int b=1000000000000000000000000000000;
return ([a:1])[b]]],1);
test_any([[int a=10->pow(30); int b=1000000000000000000000000000000;
return (<a>)[b]]],1);
test_any([[int a=10->pow(30); int b=1000000000000000000000000000000;
return sizeof( ({a})-({b}) )]],0);
test_any([[int a=10->pow(30); int b=1000000000000000000000000000000;
return sizeof( ({a})&({b}) )]],1);
test_any([[int k=10->pow(30);
array a=({k+17,k+16,k+13,k+14,k+12,k,k+9});
return sort(a)[0]==k && sort(a)[-1]==k+17]],1)
|
| 997b73 | 2001-09-10 | Fredrik Hübinette (Hubbe) | | test_do([[
// This is a memleak test
rm("testsuite_test.pike");
Stdio.write_file("testsuite_test.pike",
"constant Q=10000000000000000;\n"
"int main() {}\n");
Process.system(RUNPIKE +" testsuite_test.pike");
rm("testsuite_test.pike");
]])
|
| 9c8ca0 | 2000-11-05 | Mirar (Pontus Hagland) | | // test the corresponding integer operations first
test_any([[int k=100; int j=k+1;
array a=({k+17,k+16,k+13,k+14,k+12,k,k+9});
array b=({j+16,j+15,j+12,j+13,j+11,j-1,j+8});
return sizeof( a&b )]],7);
test_any([[int k=100; int j=k+1;
array a=({k+17,k+16,k+13,k+14,k+12,k,k+9});
array b=({j+13,j+11,j-1,j+8,j+16,j+15,j+12});
return sizeof( a-b )]],0);
// now the bignum ones
test_any([[int k=10->pow(30); int j=k+1;
array a=({k+17,k+16,k+13,k+14,k+12,k,k+9});
array b=({j+16,j+15,j+12,j+13,j+11,j-1,j+8});
return sizeof( a&b )]],7);
test_any([[int k=10->pow(30); int j=k+1;
array a=({k+17,k+16,k+13,k+14,k+12,k,k+9});
array b=({j+13,j+11,j-1,j+8,j+16,j+15,j+12});
return sizeof( a-b )]],0);
]])
|
| 694bb1 | 1998-04-23 | Fredrik Hübinette (Hubbe) | | cond([[all_constants()->_verify_internals]],
|
| c0988f | 1998-04-17 | Fredrik Hübinette (Hubbe) | | [[
test_do(_verify_internals())
]])
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
test_eq("\377"[0],255)
|
| 2aeef5 | 2002-11-26 | Martin Nilsson | | test_do(add_constant("foo",class c {int i;}()))
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | test_eq(foo->i,0)
test_do(foo->i=17)
test_eq(foo->i,17)
|
| 2de379 | 1997-02-11 | Fredrik Hübinette (Hubbe) | | test_do(add_constant("foo"));
|
| 2aeef5 | 2002-11-26 | Martin Nilsson | | test_do(add_constant("foo",class c {array(int) i=({0});}()))
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | test_eq(foo->i[0],0)
test_do(foo->i[0]=17)
test_eq(foo->i[0],17)
|
| 2de379 | 1997-02-11 | Fredrik Hübinette (Hubbe) | | test_do(add_constant("foo"));
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
// signum, signame
|
| e42eaf | 1998-01-02 | Fredrik Hübinette (Hubbe) | | test_true(intp(signum("SIGKILL")))
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
// kill, signal, getpid
test_true(intp(getpid()))
|
| 5001c3 | 1998-02-28 | Fredrik Hübinette (Hubbe) | | cond([[all_constants()->kill && (cpp("__NT__")/"\n")[1]=="__NT__" ]],
|
| e42eaf | 1998-01-02 | Fredrik 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"))
|
| 4e7870 | 1999-11-24 | Henrik Grubbström (Grubba) | | test_do(signal(signum("SIGFPE"), 0))
|
| e42eaf | 1998-01-02 | Fredrik Hübinette (Hubbe) | | test_do(signal(signum("SIGFPE")))
]])
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
// typeof
|
| 440592 | 2000-05-25 | Henrik Grubbström (Grubba) | | test_eq(sprintf("%O", typeof(1)),"int(1..1)")
test_eq(sprintf("%O", typeof("")),"string")
test_eq(sprintf("%O", typeof(""[0])),"int")
test_eq(sprintf("%O", typeof(0.0)),"float")
test_eq(sprintf("%O", typeof(all_constants()["all_constants"])),"mixed")
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
|
| 4fbfe2 | 1998-12-21 | Fredrik Hübinette (Hubbe) | | // _typeof
|
| 440592 | 2000-05-25 | Henrik Grubbström (Grubba) | | test_eq(sprintf("%O", _typeof(1)),"int(1..1)")
test_eq(sprintf("%O", _typeof("")),"string")
test_eq(sprintf("%O", _typeof("x"[0])),"int(120..120)")
test_eq(sprintf("%O", _typeof(0.0)),"float")
|
| b58421 | 2002-05-11 | Martin Stjernholm | | test_eq([[sscanf(sprintf("%Ox", _typeof(this_object))-" ",
"function(void|int(0..%*[0-9]):object)%*c")]], 2)
|
| 4fbfe2 | 1998-12-21 | Fredrik Hübinette (Hubbe) | |
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | // class
|
| b1f4eb | 1998-01-13 | Fredrik Hübinette (Hubbe) | | test_true(programp(class c {}))
|
| 2aeef5 | 2002-11-26 | Martin 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)
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
|
| 31fb1d | 2000-07-10 | Henrik Grubbström (Grubba) | | // class()
test_true(programp(class c(){}))
test_equal(indices(class c(string a,static int b){}("foo",0)), ({"a"}))
test_equal(values(class c(string a,static int b){}("foo",0)), ({"foo"}))
|
| fde244 | 2001-03-31 | Henrik Grubbström (Grubba) | | test_true(programp(class c(string ... a){}))
test_equal(indices(class c(string a,static int ... b){}("foo",0)), ({"a"}))
test_equal(values(class c(static string a, int ... b){}("foo",0)), ({({0})}))
|
| 31fb1d | 2000-07-10 | Henrik Grubbström (Grubba) | |
|
| f8b6ba | 2001-11-28 | Martin Stjernholm | | test_do([[
class A (int i) {};
class B (int i, int j) {inherit A;};
class C {inherit B;};
C (1,1);
]])
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | // type checks
test_compile_error([[} int foo() { return]]);
test_compile_error([[} void foo() { return 1]]);
|
| 62cda4 | 1999-11-23 | Martin Stjernholm | | test_compile([[mapping a; int b; a = b = 0;]]);
test_compile_error([[mapping a; int b; a = b = 1;]]);
|
| 327c05 | 1999-11-24 | Fredrik Hübinette (Hubbe) | | test_compile_any([[void a(int q){} void b(function(int:void) f){} void c(){b(a);}]]);
|
| 6b3f5c | 2002-04-11 | Martin Nilsson | | test_compile_error_any([[void a(int i){} void b(function(:void) f){} void c(){b(a);}]]);
|
| 653c36 | 1999-11-24 | Martin Stjernholm | | test_compile_any([[void a(){} function(int:void) b = a;]]);
|
| 6b3f5c | 2002-04-11 | Martin Nilsson | | test_compile_error_any([[void a(int i){} function(:void) b = a;]]);
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
|
| 1edce9 | 2000-11-04 | Martin 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;}]]);
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | // Not yet cataloged
test_any(int i=10; { int i; } return i, 10)
|
| 563973 | 2001-07-04 | Henrik 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;]])
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
test_do(lambda(){return;}())
test_equal( ({ lambda() { return 3; } , lambda() { return 7; }, lambda() { return 9; } })(), ({ 3,7,9 }))
|
| 3488ef | 2000-04-17 | Henrik Grubbström (Grubba) | | test_any(array(int) a=({10}); a[0]++; return a[0], 11)
|
| e5bb7d | 1996-09-23 | Fredrik 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"]))
|
| 2de379 | 1997-02-11 | Fredrik 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"]))
|
| e5bb7d | 1996-09-23 | Fredrik 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" / ","]])
|
| 3488ef | 2000-04-17 | Henrik Grubbström (Grubba) | | test_any([[array(string) a="a,b"/","; a[0]="c"; return equal(a,({"c","b"}))]],1)
|
| e5bb7d | 1996-09-23 | Fredrik 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}))
|
| 8267f4 | 1998-01-28 | Fredrik Hübinette (Hubbe) | | test_equal( ({"object","object","object","object","object"}), allocate(5,"object"))
|
| e5bb7d | 1996-09-23 | Fredrik 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)
|
| 2de379 | 1997-02-11 | Fredrik Hübinette (Hubbe) | | test_define_program(test,[[int foo() { return 17; }]])
|
| 2aeef5 | 2002-11-26 | Martin Nilsson | | test_any(function bar=test()->foo; return bar(),17)
test_do(add_constant("test"))
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
// sscanf
test_any([[mixed a; return sscanf("11","%d",a)]],1)
|
| 6c35af | 1998-04-14 | Fredrik Hübinette (Hubbe) | |
|
| e5bb7d | 1996-09-23 | Fredrik 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)
|
| 6c35af | 1998-04-14 | Fredrik 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)
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)
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)
|
| e5bb7d | 1996-09-23 | Fredrik 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)
test_any([[mixed a,b; return sscanf("11foo","%dfoo",a)]],1)
test_any([[mixed a,b; sscanf("11foo","%dfoo",a); return a]],11)
test_any([[mixed a,b; return sscanf("11foo","%d%s",a,b)]],2)
test_any([[mixed a,b; sscanf("11foo","%d%s",a,b); return b]],"foo")
test_any([[mixed a,b; return sscanf("foo","%c%s",b,a)]],2)
test_any([[mixed a,b; sscanf("foo","%c%s",b,a); return b]],'f')
test_any([[mixed a,b; sscanf("foo","%c%s",b,a); return a]],"oo")
|
| d77143 | 1999-11-24 | Mirar (Pontus Hagland) | | test_any([[mixed a,b; return sscanf("1.0","%f",a),a]],1.0)
test_any([[mixed a,b; return sscanf("-1.0","%f",a),a]],-1.0)
test_any([[mixed a,b; return sscanf("1.25","%f",a),a]],1.25)
test_any([[mixed a,b; return sscanf("-1.25","%f",a),a]],-1.25)
test_any([[mixed a,b; return sscanf("1.25e3","%f",a),a]],1.25e3)
test_any([[mixed a,b; return sscanf("-1.25e3","%f",a),a]],-1.25e3)
test_any([[mixed a,b; return sscanf("1.25e-3","%f",a),a]],1.25e-3)
test_any([[mixed a,b; return sscanf("-1.25e-3","%f",a),a]],-1.25e-3)
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | test_any([[mixed a,b; sscanf("1.0","%f",a); return a]],1.0)
|
| dca598 | 1998-04-15 | Fredrik 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")
|
| e5bb7d | 1996-09-23 | Fredrik 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)
|
| fb61ba | 1998-04-26 | Fredrik 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)
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
|
| e478b1 | 1998-05-25 | Marcus 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)
|
| d5202d | 2001-06-20 | Henrik Grubbström (Grubba) | | // Inf
|
| dd6624 | 2000-11-18 | Marcus 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)
|
| d5202d | 2001-06-20 | Henrik Grubbström (Grubba) | | // -Inf
|
| dd6624 | 2000-11-18 | Marcus 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)
|
| d5202d | 2001-06-20 | Henrik Grubbström (Grubba) | | // NaN
|
| dd6624 | 2000-11-18 | Marcus 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)
|
| d5202d | 2001-06-20 | Henrik Grubbström (Grubba) | | // -NaN
|
| dd6624 | 2000-11-18 | Marcus 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)
|
| d5202d | 2001-06-20 | Henrik Grubbström (Grubba) | | // Inf
|
| dd6624 | 2000-11-18 | Marcus 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)
|
| d5202d | 2001-06-20 | Henrik Grubbström (Grubba) | | // -Inf
|
| dd6624 | 2000-11-18 | Marcus 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)
|
| d5202d | 2001-06-20 | Henrik Grubbström (Grubba) | | // NaN
|
| dd6624 | 2000-11-18 | Marcus 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)
|
| d5202d | 2001-06-20 | Henrik Grubbström (Grubba) | | // -NaN
|
| dd6624 | 2000-11-18 | Marcus 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)
|
| dca598 | 1998-04-15 | Fredrik 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'}) }) }) ]])
|
| eccd0a | 1999-10-29 | Fredrik Noring | | test_equal([[array_sscanf("\x7fffffab#", "%c%c")]], [[ ({ 0x7fffffab, '#' }) ]])
|
| 22d95e | 1999-11-04 | Fredrik Hübinette (Hubbe) | | test_equal([[array_sscanf("\x7fffffab#", "%1c%1c")]], [[ ({ }) ]])
|
| eccd0a | 1999-10-29 | Fredrik Noring | |
|
| c5ad62 | 1999-06-15 | Mirar (Pontus Hagland) | | test_true([[array_sscanf("(02323) 23455 344","%{%*[^0-9]%[0-9]%}")]])
|
| 622953 | 1999-11-01 | Mirar (Pontus Hagland) | | test_eq([[ array_sscanf(sprintf("%4c",16909060),"%4c")[0] ]],16909060)
test_eq([[ array_sscanf(sprintf("%-4c",16909060),"%-4c")[0] ]],16909060)
|
| 64979f | 2003-09-10 | Henrik 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)
|
| 622953 | 1999-11-01 | Mirar (Pontus Hagland) | |
|
| e7a172 | 1999-11-04 | Fredrik 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"}) ]])
|
| 2b2459 | 1999-11-04 | Fredrik Hübinette (Hubbe) | |
test_equal([[ array_sscanf("02 00 DC 00 0B","%{%x%*[\0-/:-@]%}")[0] ]],
[[ ({ ({2}), ({0}), ({220}),({0}), ({11}) }) ]])
|
| 035b2d | 2000-08-13 | Henrik Grubbström (Grubba) | |
test_equal([[ array_sscanf("\51726\30212\66610\30131", "%*[ \t]%s")[0] ]],
|
| 57fbc8 | 2000-08-14 | Henrik Grubbström (Grubba) | | [[ "\51726\30212\66610\30131" ]])
|
| e45d9a | 2001-01-14 | Mirar (Pontus Hagland) | |
test_equal([[ array_sscanf("hej","%s") ]], [[ ({ "hej" }) ]])
test_equal([[ array_sscanf("hej","%s%n") ]], [[ ({ "hej", 3 }) ]])
test_eval_error([[ function f=array_sscanf; f("hej","%s% ") ]])
|
| 209e17 | 2003-02-19 | Marcus Comstedt | |
|
| d3ade9 | 2003-02-19 | Henrik Grubbström (Grubba) | | test_equal([[ array_sscanf("\x304b\x3066\x3044\x308a\x3087\x3046\x308a", "%[^\x3042\x3044\x3046\x3048\x304a]")[0] ]],
|
| 209e17 | 2003-02-19 | Marcus Comstedt | | [[ "\x304b\x3066" ]])
|
| 56ec3b | 2004-03-07 | Martin 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" }) )
|
| e7a172 | 1999-11-04 | Fredrik Hübinette (Hubbe) | |
|
| 99aaf2 | 1999-11-17 | Henrik 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")
|
| e248ee | 2003-02-13 | Mirar (Pontus Hagland) | | // sscanf %O -------------------------------------------------------------
|
| af8e40 | 2003-02-13 | Henrik Grubbström (Grubba) | | define(test_percent_o_raw, [[
|
| e248ee | 2003-02-13 | Mirar (Pontus Hagland) | | test_equal(array_sscanf(]]$3[[,]]$1[[),[[$2]])
]])
|
| af8e40 | 2003-02-13 | Henrik Grubbström (Grubba) | | define(test_percent_o_fmt, [[
test_percent_o_raw(]]$1[[,]]$2[[,sprintf(]]$1[[,@]]$2[[))
|
| e248ee | 2003-02-13 | Mirar (Pontus Hagland) | | ]])
|
| af8e40 | 2003-02-13 | Henrik Grubbström (Grubba) | | define(test_percent_o_char, [[
|
| e248ee | 2003-02-13 | Mirar (Pontus Hagland) | | dnl patsubst doesn't exist on all m4's (it's a gnuism?)
ifdef(patsubst,[[
|
| af8e40 | 2003-02-13 | Henrik Grubbström (Grubba) | | test_percent_o_raw("%O",({']]$1[['}),"']]patsubst($1,\\,\\\\)[['"))
test_percent_o_raw("%O%s",({']]$1[[',"abc"}),"']]patsubst($1,\\,\\\\)[['abc"))
|
| e248ee | 2003-02-13 | Mirar (Pontus Hagland) | | ]])]])
ifdef(patsubst,[[
|
| af8e40 | 2003-02-13 | Henrik 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"))
|
| e248ee | 2003-02-13 | Mirar (Pontus Hagland) | | ]])]])
|
| af8e40 | 2003-02-13 | Henrik Grubbström (Grubba) | | test_percent_o_fmt("%O",({10}))
test_percent_o_fmt("%O%s",({10,"abc"}))
|
| e248ee | 2003-02-13 | Mirar (Pontus Hagland) | |
|
| af8e40 | 2003-02-13 | Henrik 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]])
|
| e248ee | 2003-02-13 | Mirar (Pontus Hagland) | |
|
| af8e40 | 2003-02-13 | Henrik 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]])
|
| e248ee | 2003-02-13 | Mirar (Pontus Hagland) | |
|
| af8e40 | 2003-02-13 | Henrik Grubbström (Grubba) | | test_percent_o_fmt("%O %O %O",({10,20,30}))
test_percent_o_fmt("%O %O %s",({10,20,"30"}))
|
| e248ee | 2003-02-13 | Mirar (Pontus Hagland) | |
// -------------------------------------------------------------
|
| e7a172 | 1999-11-04 | Fredrik Hübinette (Hubbe) | |
|
| e5bb7d | 1996-09-23 | Fredrik 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)
|
| ac8715 | 2000-09-25 | Fredrik Hübinette (Hubbe) | | test_equal(
#pike 7.0
!Simulate.this_function(),0)
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
// testing ==
test_true(1==1)
test_true(!(1==2))
test_true(""=="")
test_true(!(""=="foo"))
test_true(this_object()==this_object())
|
| ac8715 | 2000-09-25 | Fredrik Hübinette (Hubbe) | | test_true(
#pike 7.0
Simulate.this_function()==a)
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | test_true(2.0==2.0)
test_true(({})==({}))
// testing !=
test_true(({1})!=({1}))
test_true(1!=2)
test_true(!(1==2))
test_true(!(""!=""))
test_true(""!="foo")
|
| d429a7 | 1998-02-24 | Fredrik 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")
|
| 3e625c | 1998-10-11 | Fredrik Hübinette (Hubbe) | | test_cmp3("\x0","\x100","\x10000")
test_cmp3("a\x10000","b\x100","c\x100")
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
// hex construction
test_eq(0,0x0)
test_eq(1,0x1)
test_eq(10,0xa)
test_eq(16,0x10)
test_eq(65535,0xffff)
test_eq(17*257*65537,0x11111111)
// octal construction
test_eq(0,00)
test_eq(1,01)
test_eq(8,010)
test_eq(64,0100)
test_eq(1073741824,010000000000)
test_eq((8+1)*(8*8+1)*(8*8*8*8+1),011111111)
// string construction tests
test_eq(16,"\20"[0])
test_eq(16,"\020"[0])
test_eq(255,"\377"[0])
test_eq(4,'\4')
test_true("\r"[0]!='r')
test_eq("\r"[0],'\r')
test_eq("\n"[0],'\n')
// testing +
test_eq(1+1,2)
test_eq(1+(-2),-1)
test_eq((-2)+(-2),-4)
test_eq("hi"+"there","hithere")
test_eq("human"+"number"+666,"humannumber666")
test_eq("human"+("number"+666),"humannumber666")
test_eq(("human"+"number")+666,"humannumber666")
test_eq(("human"+"number")+666+111,"humannumber666111")
test_eq("humannumber"+(666+111),"humannumber777")
test_eq("a"+"b"+"c"+"d"+"e"+"f"+"g"+"h"+"i"+"j"+"k"+"l"+"m"+"n"+"o"+"p"+"q"+"r"+"s"+"t"+"u"+"v"+"x"+"y","abcdefghijklmnopqrstuvxy")
test_eq(1.0+1.0,2.0)
test_eq(1.0+(-1.0),0.0)
test_eq((-1.0)+(-1.0),-2.0)
test_eq(1.0+1,2.0)
test_eq(1+1.0,2.0)
test_eq(1+(-1.0),0.0)
test_eq(1.0+(-1),0.0)
test_eq((-1)+(-1.0),-2.0)
test_eq((-1.0)+(-1),-2.0)
test_equal(({1,2,3})+({4,5,6}),({1,2,3,4,5,6}))
test_equal((<1,2,3,4>)+(<4,5,6>),(<1,2,3,4,4,5,6>))
test_equal(([0:1,3:6])+([5:2,3:6]),([0:1,3:6,3:6,5:2]))
test_eval_error(return this_object() + this_object())
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | test_any(return((1+2+3)-(1+2-3)), 6)
|
| e5bb7d | 1996-09-23 | Fredrik 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)
|
| 0bc4cf | 1998-10-13 | Fredrik Hübinette (Hubbe) | | test_eq(034567 - 10000,4711)
|
| e5bb7d | 1996-09-23 | Fredrik 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]))
|
| d8ca9d | 2003-03-08 | Mirar (Pontus Hagland) | | test_any([[string s="\57070 abcdefghijklmnopqrstuvwxyz012345678"; return strlen(s-s[1..35])]],37-35)
|
| 3a2b82 | 2003-03-08 | Mirar (Pontus Hagland) | |
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | // testing ~
test_eq(-1-4,~4)
test_eq(-1-627893874,~627893874)
|
| fb61ba | 1998-04-26 | Fredrik Hübinette (Hubbe) | | test_eq(~1.0,-2.0)
test_eq(~"\x55","\xaa")
|
| e5bb7d | 1996-09-23 | Fredrik 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)
|
| 0bc4cf | 1998-10-13 | Fredrik Hübinette (Hubbe) | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | test_eq([[({})*""]],"")
test_eq([[({"foo",0,"bar"})*"-"]],"foo-bar")
test_eq([[({1.0,"foo",0,"bar",this_object(),([])})*"-"]],"foo-bar")
test_eq([[({"f","o","o"})*""]],"foo")
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | test_eq(({"foo","bar","gazonk"})*"-","foo-bar-gazonk")
|
| 3e625c | 1998-10-11 | Fredrik 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")
|
| 0bc4cf | 1998-10-13 | Fredrik 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")
|
| 7fa910 | 1997-02-18 | Fredrik Hübinette (Hubbe) | | test_equal( ({ ({1}), ({2}), ({3}) })*({8}), ({1,8,2,8,3}))
|
| d429a7 | 1998-02-24 | Fredrik Hübinette (Hubbe) | | test_equal( ({ 1 })*3, ({1,1,1}) )
test_equal( "foo"*3, "foofoofoo" )
|
| b0dfdc | 2000-09-26 | Henrik 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, ({}))
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
// testing /
test_eq(12/3,4)
test_eq(13/3,4)
test_eq(14/3,4)
test_eq(15/3,5)
|
| c93f0e | 1997-12-03 | Fredrik Hübinette (Hubbe) | | test_eq(-2/4,-1)
|
| 806a2c | 1997-04-28 | Fredrik Hübinette (Hubbe) | | test_eq(-12/3,-4)
test_eq(-13/3,-5)
test_eq(-14/3,-5)
test_eq(-15/3,-5)
|
| e5bb7d | 1996-09-23 | Fredrik 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"}))
|
| 7fa910 | 1997-02-18 | Fredrik 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}) }))
test_equal(({1,0,1,2,1,2,2,2,1,1,1})/({2,1}),({ ({1,0,1}), ({2,2}), ({1,1}) }))
|
| 034fb9 | 1997-02-24 | Fredrik Hübinette (Hubbe) | | test_equal( ({1,2,3})/({2,3}), ({ ({1}), ({}) }) )
|
| d429a7 | 1998-02-24 | Fredrik Hübinette (Hubbe) | | test_eq([[`/(20,2,2)]],5)
test_eq([[`/(13,2,3)]],2)
test_equal("foobargazonk"/1,"foobargazonk"/"")
test_equal("foobargazonk"/2,({"fo","ob","ar","ga","zo","nk"}))
test_equal("foobargazonk"/3,({"foo","bar","gaz","onk"}))
test_equal("foobargazonk"/4,({"foob","arga","zonk"}))
test_equal("foobargazonk"/5,({"fooba","rgazo"}))
test_equal("foobargazonk"/-6,({"foobar","gazonk"}))
test_equal("foobargazonk"/-7,({"rgazonk"}))
test_equal("foobargazonk"/5.0,({"fooba","rgazo","nk"}))
test_equal("foobargazonk"/-5.0,({"fo","obarg","azonk"}))
|
| b0dfdc | 2000-09-26 | Henrik Wallin | | test_equal("foobargazonk"/2.5,({"foo","ba","rga","zo","nk"}))
test_equal("foo"/2.6,({"foo",""}))
test_equal("\1233oo"/2.6,({"\1233oo",""}))
|
| d429a7 | 1998-02-24 | Fredrik Hübinette (Hubbe) | |
|
| 0bc4cf | 1998-10-13 | Fredrik 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"}))
|
| 1e5db5 | 2000-09-27 | Henrik Wallin | | test_equal("f\777\777bargaz\777nk"/2.5,({"f\777\777","ba","rga","z\777","nk"}))
|
| 0bc4cf | 1998-10-13 | Fredrik Hübinette (Hubbe) | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | test_equal(""/"hej", ({""}))
test_equal("hej"/"hej", ({"",""}))
|
| 0bc4cf | 1998-10-13 | Fredrik 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"}))
|
| fed8df | 2000-09-27 | Henrik Grubbström (Grubba) | | test_equal("f\7777777\7777777bargaz\7777777nk"/2.5,({"f\7777777\7777777", "ba","rga","z\7777777","nk"}))
|
| 0bc4cf | 1998-10-13 | Fredrik Hübinette (Hubbe) | |
|
| d429a7 | 1998-02-24 | Fredrik 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}) }))
|
| b0dfdc | 2000-09-26 | Henrik Wallin | | test_equal(({1,2,3})/1.5,({ ({1, 2}), ({3}) }))
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
// testing %
test_eq(12%3,0)
test_eq(13%3,1)
test_eq(14%3,2)
test_eq(15%3,0)
|
| 806a2c | 1997-04-28 | Fredrik Hübinette (Hubbe) | | test_eq(2%17,2)
test_eq(2%-17,-15)
test_eq(-2%17,15)
test_eq(-2%-17,-2)
|
| 284c36 | 1997-09-15 | Fredrik Hübinette (Hubbe) | | test_eq(-10%10,0)
test_eq(10%-10,0)
test_eq(-10%-10,0)
test_eq(10%10,0)
|
| e5bb7d | 1996-09-23 | Fredrik 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)
|
| d429a7 | 1998-02-24 | Fredrik Hübinette (Hubbe) | | test_eq("foobargazonk"%5,"nk")
test_eq("foobargazonk"%-5,"fo")
|
| 0bc4cf | 1998-10-13 | Fredrik 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")
|
| d429a7 | 1998-02-24 | Fredrik Hübinette (Hubbe) | | test_equal(({1,2,3})%2,({3}))
test_equal(({1,2,3})%-2,({1}))
|
| e5bb7d | 1996-09-23 | Fredrik 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)
|
| 20d9f9 | 2003-08-10 | Martin Nilsson | | test_eq([[ "\007" | "\023"]],"\027")
test_eq([[ "\177777x" | "ab" ]], "\177777z")
|
| 934a7f | 2003-11-10 | Martin Stjernholm | | test_equal( ({1,2,3,4,4}) | ({3,5,6}), ({1,2,3,4,4,5,6}))
|
| e5bb7d | 1996-09-23 | Fredrik 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]) )
|
| aa4a32 | 2001-01-03 | Martin Stjernholm | | test_any([[
class Foo {int `< (object o) {return 0;}};
return sizeof (({Foo()}) | ({Foo()}));
]], 2)
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
// testing &
test_eq(0 & 0,0)
test_eq(1 & 1,1)
test_eq(4 & 1,0)
test_eq(1 & 9,1)
|
| 20d9f9 | 2003-08-10 | Martin Nilsson | | test_eq([[ "\007" & "\023"]],"\003")
test_eq([[ "\177777x" & "ab" ]], "a`")
|
| e5bb7d | 1996-09-23 | Fredrik 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]) )
|
| b11798 | 2004-04-15 | Martin 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}))
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
// testing ^
test_eq(0 ^ 0,0)
test_eq(1 ^ 1,0)
test_eq(4 ^ 1,5)
test_eq(1 ^ 9,8)
|
| 20d9f9 | 2003-08-10 | Martin Nilsson | | test_eq([[ "\007" ^ "\023"]],"\024")
test_eq([[ "\177777x" ^ "ab" ]], "\177636\32")
|
| 934a7f | 2003-11-10 | Martin Stjernholm | | test_equal( ({1,2,3,4,4}) ^ ({3,5,6}) , ({1,2,4,4,5,6}))
|
| e5bb7d | 1996-09-23 | Fredrik 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]) )
|
| 934a7f | 2003-11-10 | Martin 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}))
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
// testing <<
test_eq(1<<0,1)
test_eq(1<<1,2)
test_eq(1<<10,1024)
test_eq(5<<3,40)
|
| df8dce | 2002-10-16 | Henrik Grubbström (Grubba) | | test_eval_error(return 17<<-10)
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
// testing >>
test_eq(9>>2,2)
test_eq(1>>1,0)
test_eq(1024>>10,1)
test_eq(47>>3,5)
|
| 0c50a2 | 2002-10-15 | Marcus Comstedt | | test_eq(-10>>10000,-1)
|
| df8dce | 2002-10-16 | Henrik Grubbström (Grubba) | | test_eval_error(return 17>>-10)
|
| e5bb7d | 1996-09-23 | Fredrik 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)
|
| 8dc4ff | 1999-02-05 | Martin 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")
|
| e5bb7d | 1996-09-23 | Fredrik 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')
|
| 3e625c | 1998-10-11 | Fredrik 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')
|
| e5bb7d | 1996-09-23 | Fredrik 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')
test_eq(([0:'f',1:'o',2:'o'])[3],0)
test_eq(([0:'f',1:'o',2:'o'])[-1],0)
test_eq((<'f','o','o'>)['o'],1)
test_eq((<'f','o','o'>)['f'],1)
test_eq((<'f','o','o'>)['b'],0)
test_eq((<'f','o','o'>)[-1],0)
|
| 99761f | 1998-10-09 | Fredrik Hübinette (Hubbe) | | test_eq([[class Z { mixed `->(mixed x) { return this_object()[x]; } int foo() { return 1; }}()->foo()]],1)
|
| e5bb7d | 1996-09-23 | Fredrik 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)
|
| 141487 | 2005-05-18 | Martin Nilsson | | test_any(mixed a="hej"; a[1]='o'; return a,"hoj")
test_do( string x=" "*73; x[64]=1; x[65]=1; )
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
|
| 2de379 | 1997-02-11 | Fredrik Hübinette (Hubbe) | | test_define_program(test,[[public int q,w,e,r; mixed t; mixed getw() { return w; } void setw(int _) { w=_; }]])
|
| 2aeef5 | 2002-11-26 | Martin 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");)
|
| e5bb7d | 1996-09-23 | Fredrik 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")
test_eq("foo"[1..0],"")
|
| 408a1e | 2004-10-30 | Martin Stjernholm | | test_any(int u=-100; return "foo"[0..u];,"") dnl Use variable to avoid warning.
|
| e5bb7d | 1996-09-23 | Fredrik 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")
|
| 3e625c | 1998-10-11 | Fredrik 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")
|
| e5bb7d | 1996-09-23 | Fredrik 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}))
test_equal(({1,2,3})[1..0],({}))
|
| 408a1e | 2004-10-30 | Martin 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")
test_eq("abcdef"[..], "abcdef")
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]])
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
|
| d429a7 | 1998-02-24 | Fredrik Hübinette (Hubbe) | | // casting
test_eq([[(int)1]],[[1]])
|
| 17a46a | 2000-06-13 | Martin Nilsson | | test_eq([[(int)-1]],[[-1]])
|
| d429a7 | 1998-02-24 | Fredrik Hübinette (Hubbe) | | test_eq([[(int)1.0]],[[1]])
|
| 17a46a | 2000-06-13 | Martin Nilsson | | test_eq([[(int)-1.0]],[[-1]])
|
| d429a7 | 1998-02-24 | Fredrik Hübinette (Hubbe) | | test_eq([[(int)"1"]],[[1]])
|
| 17a46a | 2000-06-13 | Martin Nilsson | | test_eq([[(int)"-1"]],[[-1]])
|
| f21880 | 2001-06-05 | Fredrik Hübinette (Hubbe) | | test_eq([[(int)"0x1"]],[[0]])
test_eq([[(int)"010"]],[[10]])
|
| d429a7 | 1998-02-24 | Fredrik Hübinette (Hubbe) | | test_eq([[(float)"1"]],[[1.0]])
|
| 17a46a | 2000-06-13 | Martin Nilsson | | test_eq([[(float)"-1"]],[[-1.0]])
|
| d429a7 | 1998-02-24 | Fredrik Hübinette (Hubbe) | | test_eq([[(float)"1.0"]],[[1.0]])
|
| 17a46a | 2000-06-13 | Martin Nilsson | | test_eq([[(float)"-1.0"]],[[-1.0]])
|
| d429a7 | 1998-02-24 | Fredrik Hübinette (Hubbe) | | test_eq([[(float)1.0]],[[1.0]])
|
| 17a46a | 2000-06-13 | Martin Nilsson | | test_eq([[(float)-1.0]],[[-1.0]])
|
| d429a7 | 1998-02-24 | Fredrik Hübinette (Hubbe) | | test_eq([[(float)1]],[[1.0]])
|
| 17a46a | 2000-06-13 | Martin Nilsson | | test_eq([[(float)-1]],[[-1.0]])
|
| d429a7 | 1998-02-24 | Fredrik Hübinette (Hubbe) | | test_eq([[(string)1]],[["1"]])
|
| 17a46a | 2000-06-13 | Martin Nilsson | | test_eq([[(string)-1]],[["-1"]])
|
| 83ffdb | 2003-03-29 | Henrik Grubbström (Grubba) | | test_any([[
array foo=({ 1 });
return (string)sizeof(foo);
]], [["1"]])
test_any([[
array foo=({ -1 });
return (string)-sizeof(foo);
]], [["-1"]])
|
| d429a7 | 1998-02-24 | Fredrik Hübinette (Hubbe) | | test_equal([[(array)(["1":1])]],[[ ({ ({"1", 1}) }) ]])
test_equal([[(array(int)) ({"1","4711",2.0,4})]],[[({1,4711,2,4})]])
|
| 1671fe | 1998-05-16 | Fredrik Hübinette (Hubbe) | | test_equal([[(array(array))({({})})]],[[({({})})]])
|
| 4234be | 1998-05-16 | Fredrik Hübinette (Hubbe) | | test_equal([[ (array(array(int))) ({ ({"1","4711",2.0,4}) }) ]],[[ ({ ({1,4711,2,4}) }) ]])
|
| 798adb | 1998-05-16 | Fredrik 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}) }) }) }) ]])
|
| d429a7 | 1998-02-24 | Fredrik Hübinette (Hubbe) | |
|
| fb61ba | 1998-04-26 | Fredrik Hübinette (Hubbe) | | test_equal([[(array)"foo"]],[[ values("foo") ]])
test_equal([[(array)(<1,2,3>)]],[[ indices( (<1,2,3>) )]])
|
| de51d1 | 1998-05-13 | Fredrik 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])))]])
|
| 1671fe | 1998-05-16 | Fredrik Hübinette (Hubbe) | | test_true([[(array(array))([]) ]])
test_true([[(array(array))([1:2]) ]])
test_true([[(array(array))([1:2,3:4]) ]])
|
| de51d1 | 1998-05-13 | Fredrik Hübinette (Hubbe) | | test_true([[(array(array))([1:2,3:4,5:6]) ]])
|
| 6168ce | 2000-01-27 | Fredrik Hübinette (Hubbe) | | test_equal( [[ (multiset) ({1})]], [[ (< 1 >) ]] )
|
| 862bd0 | 2003-08-26 | Henrik Grubbström (Grubba) | | test_equal( [[ (multiset(string)) ({1})]], [[ (< "1" >) ]] )
|
| be1daa | 1999-11-15 | Henrik Grubbström (Grubba) | | test_eval_error([[return (mapping)""]])
|
| 94671c | 2000-11-29 | Mirar (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)([]) ]])
|
| 505aec | 2000-11-29 | Mirar (Pontus Hagland) | | test_eval_error([[ mapping m=(mapping)({ ({1,2,3}), ({4,5,6}) }); ]])
|
| d429a7 | 1998-02-24 | Fredrik Hübinette (Hubbe) | |
|
| eba075 | 2004-09-20 | Martin Stjernholm | | test_any([[
object x = class {
mixed cast (string t) {return t == "string" && "foo";}
}();
destruct (x);
return (string) x;
]], "0")
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | // testing @
test_equal(({1,2,3}),lambda(mixed ... x) { return x; }(@a()))
|
| 2de379 | 1997-02-11 | Fredrik Hübinette (Hubbe) | | test_equal("foo"/"",lambda(mixed ... x) { return x; }(@a()))
|
| 3488ef | 2000-04-17 | Henrik Grubbström (Grubba) | | test_any([[array a=({1,2,3}); return lambda(mixed ... x) { return x; }(@a) !=a]],1)
|
| 18b0a8 | 2001-01-25 | Fredrik Hübinette (Hubbe) | | test_any([[array z=({lambda(mixed x){return x;},17});return `()(@z);]],17)
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
// testing +=
test_any(int a=1; a+=10; return a,11)
// testing -=
test_any(int a=1; a-=10; return a,-9)
// testing &=
test_any(int a=3; a&=10; return a,2)
// testing |=
test_any(int a=3; a|=10; return a,11)
// testing ^=
test_any(int a=3; a^=10; return a,9)
// testing <<=
test_any(int a=3; a<<=2; return a,12)
// testing <<=
test_any(int a=12; a>>=2; return a,3)
// testing *=
test_any(int a=12; a*=2; return a,24)
// testing /=
test_any(int a=12; a/=2; return a,6)
// testing %=
test_any(int a=12; a%=7; return a,5)
// testing control structs
test_any(return 1,1)
test_any(return lambda(){return 1;} (),1 )
test_any(if(0) return 0; else return 1,1)
test_any(if(0) return 0; return 1,1)
test_any(if(1) return 1; else return 0,1)
test_any(if("") return 1; else return 0,1)
test_any(if(!0) return 1; else return 0,1)
test_any(if(!(!1)) return 1; else return 0,1)
test_any(if(this_object()) return 1; else return 0,1)
test_any(if(a) return 1; else return 0,1) dnl a is the test function
test_any(if(0.0) return 1; else return 0,1)
test_any(if(([])) return 1; else return 0,1)
test_any(if(({})) return 1; else return 0,1)
test_any(if((<>)) return 1; else return 0,1)
test_any(if(object_program(this_object())) return 1; else return 0,1)
// break
test_any(while(1) break; return 1,1)
test_any(while(1) if(1) break; return 1,1)
// for
|
| cd90c5 | 1998-08-05 | Fredrik Hübinette (Hubbe) | | test_program(
|
| 3488ef | 2000-04-17 | Henrik Grubbström (Grubba) | | array(int) ia=({1,2,3,4,5,6});
|
| cd90c5 | 1998-08-05 | Fredrik 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;
}
)
|
| e5bb7d | 1996-09-23 | Fredrik 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")
|
| 3488ef | 2000-04-17 | Henrik 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)
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
|
| 2e952a | 2001-02-27 | Fredrik 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;
|
| 1e1794 | 2001-02-28 | Henrik Grubbström (Grubba) | | foreach( (<1,3,7,13>) ; ; int b) ret+=b;
|
| 2e952a | 2001-02-27 | Fredrik Hübinette (Hubbe) | | return ret;
]],4)
test_any([[
int ret;
foreach( (<1,3,7,13>) ; int a; ) ret+=a;
return ret;
]],24)
|
| c8565d | 2001-09-30 | Mirar (Pontus Hagland) | | test_any([[
int ret;
foreach( (<1,3,7,13>) ; ; ) ret++;
return ret;
]],4)
|
| 2e952a | 2001-02-27 | Fredrik 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)
|
| c8565d | 2001-09-30 | Mirar (Pontus Hagland) | | test_any([[
int ret;
foreach( ({2,5,11,17}) ; ; ) ret++;
return ret;
]],4)
|
| 2e952a | 2001-02-27 | Fredrik Hübinette (Hubbe) | | test_any([[
int ret;
foreach( "foobar" ; int a; int b) ret+=a*b;
return ret;
]],1585)
|
| 6fda9f | 2001-02-28 | Henrik Grubbström (Grubba) | | test_any([[
int ret;
foreach( "foobar" ; int a;) ret+=a;
return ret;
|
| 96b998 | 2001-02-28 | Henrik Grubbström (Grubba) | | ]],15)
|
| 6fda9f | 2001-02-28 | Henrik Grubbström (Grubba) | |
test_any([[
int ret;
foreach( "foobar" ; ; int b) ret+=b;
return ret;
]],633)
|
| 2e952a | 2001-02-27 | Fredrik Hübinette (Hubbe) | | test_any([[
mapping m=([1:2,3:5,7:11,13:17]);
foreach(m ; int a ; int b) m_delete(m,a);
return sizeof(m);
]],0)
test_any([[
mapping m=([1:2,3:5,7:11,13:17]);
|
| 1e1794 | 2001-02-28 | Henrik Grubbström (Grubba) | | int ret;
|
| 2e952a | 2001-02-27 | Fredrik Hübinette (Hubbe) | | foreach(m ; int a ; int b) { m_delete(m,a); ret+=a*b; }
|
| 1e1794 | 2001-02-28 | Henrik Grubbström (Grubba) | | return ret;
|
| 2e952a | 2001-02-27 | Fredrik Hübinette (Hubbe) | | ]],315)
|
| 13a16d | 2003-05-31 | Martin Stjernholm | | test_eval_error([[
int i;
foreach (class{}(); mixed a; mixed b) i++;
return i;
]])
|
| f13918 | 2003-09-05 | Martin Stjernholm | | test_any([[
String.Iterator iter = String.Iterator ("foo");
foreach (iter; int idx;)
if (idx != iter->index()) return 1;
return 0;
]], 0)
|
| ff581d | 1998-05-24 | Fredrik Noring | | // do-while
|
| e5bb7d | 1996-09-23 | Fredrik 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
|
| 1ac94a | 2000-01-04 | Henrik 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)
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
|
| d53a94 | 1999-11-17 | Fredrik Hübinette (Hubbe) | | test_program([[
void bar() {}
int a()
{
foreach( ({1}), int n)
{
switch(n)
{
default:
bar();
break;
}
}
return 1;
}
]])
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
define(test_switch0,[[
|
| 1ac94a | 2000-01-04 | Henrik 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)
|
| e5bb7d | 1996-09-23 | Fredrik 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")
|
| a5c771 | 2001-01-15 | Mirar (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)]])
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
|
| d638b5 | 2002-03-02 | Martin 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}))
|
| 7d8000 | 2001-01-10 | Martin Stjernholm | | // Breaks and continues with labels
|
| 7f97fe | 2001-01-15 | Martin 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;]])
|
| 7d8000 | 2001-01-10 | Martin 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);]])
|
| 7f97fe | 2001-01-15 | Martin 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);
|
| e9ebb7 | 2001-01-15 | Martin Stjernholm | | test_any([[
int i;
for (i = 1; i <= 4; i++)
foo: {
if (i > 5) break foo;
break;
}
return i;
]], 1);
|
| 7d8000 | 2001-01-10 | Martin 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}));
|
| ced3f0 | 2001-01-11 | Martin 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;
}
res += ({i});
}
}
return res;
]], ({-1, 1, 1, 2, 3, -2, 1, 1, 2, 3, -3, 1, 1, 2, 3}));
|
| 7d8000 | 2001-01-10 | Martin 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}));
|
| 7f97fe | 2001-01-15 | Martin Stjernholm | | test_any([[
foo:
|
| 72fa46 | 2002-09-24 | Henrik Grubbström (Grubba) | | if (stringp (catch {int q=1; break foo;}) + 1) return 1;
|
| 7f97fe | 2001-01-15 | Martin Stjernholm | | else return 2;
return 3;
]], 3);
test_any([[
foo:
do {
|
| 72fa46 | 2002-09-24 | Henrik Grubbström (Grubba) | | if ((3*time() + 5) + stringp (catch {int q=1; break foo;})) return 1;
|
| 7f97fe | 2001-01-15 | Martin 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:
|
| 72fa46 | 2002-09-24 | Henrik Grubbström (Grubba) | | gnu (1,2,3, catch {int q=1; break foo;},4,5);
|
| 7f97fe | 2001-01-15 | Martin Stjernholm | | ]]);
test_do([[
void gnu (mixed... args) {};
foo:
|
| 72fa46 | 2002-09-24 | Henrik Grubbström (Grubba) | | gnu (@indices (all_constants()), catch {int q=1; break foo;});
|
| 7f97fe | 2001-01-15 | Martin Stjernholm | | ]]);
test_do([[
void gnu (mixed... args) {};
foo:
|
| 72fa46 | 2002-09-24 | Henrik Grubbström (Grubba) | | gnu (@({1,2,3,4,5}), catch {int q=1; break foo;});
|
| 7f97fe | 2001-01-15 | Martin Stjernholm | | ]]);
test_do([[
void gnu (mixed... args) {};
foo:
|
| 72fa46 | 2002-09-24 | Henrik Grubbström (Grubba) | | gnu (@indices (all_constants()), @allocate (511, 1), catch {int q=1; break foo;});
|
| 7f97fe | 2001-01-15 | Martin Stjernholm | | ]]);
test_do([[
void gnu (mixed... args) {};
foo:
|
| 72fa46 | 2002-09-24 | Henrik Grubbström (Grubba) | | gnu (@allocate (511, 1), @indices (all_constants()), catch {int q=1; break foo;});
|
| 7f97fe | 2001-01-15 | Martin 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);
]]);
test_do([[
int gnu (mixed... args) {};
gnu(@indices (all_constants()), gauge {
foreach (({1,2,3}), int j)
do
if (gnu(@indices (all_constants()),
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
if (gnu(@indices (all_constants()),
17 + gauge {break foo;}))
return 0;
while (0);
});
]]);
|
| 7d8000 | 2001-01-10 | Martin Stjernholm | |
|
| 694bb1 | 1998-04-23 | Fredrik Hübinette (Hubbe) | | cond([[all_constants()->_verify_internals]],
|
| c0988f | 1998-04-17 | Fredrik Hübinette (Hubbe) | | [[
test_do(_verify_internals())
]])
|
| 5f174f | 2003-04-02 | Martin Nilsson | | test_compile_any([[import Stdio.Readline; mapping x=([]);]]);
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | // testing preprocessor
|
| f3ece8 | 1999-02-28 | Fredrik Hübinette (Hubbe) | | test_eq([[cpp("#define FOO(X,Y) (X) (Y)\nFOO( (A),(B) )")]],"# 1 \"-\"\n\n( (A) ) ( (B) )")
test_eq([[cpp("#define F 'F'\nF")]],"# 1 \"-\"\n\n'F'")
test_eq([[cpp("#define MAX(X,Y) ((X)>(Y)?(X):(Y))\n#define MAX3(X,Y,Z) MAX(MAX(X,Y),Z)\nMAX3(1,2,3)")]],"# 1 \"-\"\n\n\n(( (( 1 )>( 2 )?( 1 ):( 2 )) )>( 3 )?( (( 1 )>( 2 )?( 1 ):( 2 )) ):( 3 ))")
test_eq([[cpp("foo\xfeff""bar \xfeff gazonk")]],[[cpp("foobar gazonk")]])
|
| 7c19af | 2002-11-01 | Johan Sundström | | test_eq([[cpp("#define A(X) #X\n#define B(Y) A(Y)\nB(foo)")]],
|
| 4457a8 | 2002-11-04 | Henrik Grubbström (Grubba) | | "# 1 \"-\"\n\n\n \"foo\" ")
|
| a191cb | 2003-09-30 | Henrik Grubbström (Grubba) | | test_eq([[cpp("#define FOO(X) X\nFOO(\"\\\n\")\n")]], "# 1 \"-\"\n\n\n \"\" \n");
test_eq([[cpp("#define FOO(X) X\r\nFOO(\"\\\r\n\")\r\n")]], "# 1 \"-\"\n\n\n \"\" \n" /* Note: Added extra space for \r. */);
|
| e19d32 | 2003-09-24 | Martin 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}));
|
| b056b1 | 2004-06-30 | Henrik Grubbström (Grubba) | | test_equal([[
compile_string("#define FOO BAR\n"
"#define TOSTR(X) #X\n"
"#define TOSTR2(X) TOSTR(X)\n"
"constant val = TOSTR2(FOO);\n")()->val;
]], "BAR")
test_equal([[
compile_string("#define FOO\n"
"#define TOSTR(X) #X\n"
"#define TOSTR2(X) TOSTR(X)\n"
"constant val = TOSTR2(FOO);\n")()->val;
]], "")
test_equal([[
|
| cc432e | 2004-06-30 | Henrik Grubbström (Grubba) | | compile_string(Locale.Charset.encoder("ebcdic-us")->
|
| b056b1 | 2004-06-30 | Henrik Grubbström (Grubba) | | feed("#charset ebcdic-us\n"
"constant val = \"abc\";\n")->drain())()->val;
]], "abc")
|
| 13f2e0 | 2004-10-31 | Martin Stjernholm | | test_eq([[cpp("\\\n")]], "# 1 \"-\"\n\n")
test_eq([[cpp("#if 1\\\n-1\nfoo\n#endif\n")]], "# 1 \"-\"\n\n\n\n\n")
|
| c0ed8d | 2004-11-01 | Martin Stjernholm | | test_any([[
Stdio.write_file("testsuite_test.h", "");
return compile_string(#"
#include \"\\
testsuite_test.h\"
int line = __LINE__;
")()->line;
]], 4)
|
| 2a890d | 2004-10-22 | Henrik Grubbström (Grubba) | |
// The following three tests are in triplicate to force testing in all shifts.
|
| b4fed8 | 2004-04-21 | Martin Stjernholm | | test_do([[
#define FOO(X) X
string s = FOO (#"a
b
c");
]]);
|
| 352d09 | 2004-04-22 | Henrik 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");
]]);
|
| 2a890d | 2004-10-22 | Henrik 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 (#"
");
]]);
|
| 352d09 | 2004-04-22 | Henrik Grubbström (Grubba) | | test_any([[
#define FOO(X) X
FOO ("\
\
");
return __LINE__;
]], 6);
test_any([[
#define FOO(X) X
FOO ("\
\
");
return __LINE__;
]], 6);
|
| b4fed8 | 2004-04-21 | Martin Stjernholm | | test_any([[
#define FOO(X) X
FOO ("\
\
");
return __LINE__;
]], 6);
|
| f3ece8 | 1999-02-28 | Fredrik Hübinette (Hubbe) | |
|
| 516482 | 2004-11-14 | Martin 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;}
]])
|
| 204dc0 | 2001-03-23 | Martin 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")
|
| 43b2b8 | 2004-06-30 | Henrik Grubbström (Grubba) | | test_compile([[
|
| 204dc0 | 2001-03-23 | Martin Stjernholm | | #define Y(y) y
#define X(x) x()
X(Y)
]])
test_compile_error([[
|
| 43b2b8 | 2004-06-30 | Henrik Grubbström (Grubba) | | #define Y(y,z) y
#define X(x) x()
X(Y)
]])
test_compile_error([[
|
| 204dc0 | 2001-03-23 | Martin 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()]])
|
| 8385b4 | 2004-05-27 | Martin Stjernholm | | test_do([[
|
| 400298 | 2004-05-27 | Martin Stjernholm | | Stdio.write_file("testsuite_test.pmod", "syntax error");
|
| 8385b4 | 2004-05-27 | Martin 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([[
|
| 400298 | 2004-05-27 | Martin Stjernholm | | Stdio.write_file("testsuite_test.pmod", "syntax error");
|
| 8385b4 | 2004-05-27 | Martin 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);
]]);
|
| e208cf | 2001-12-20 | Martin Stjernholm | | test_any([[
class handler {mapping get_predefines() {return (["x": "1", "y": "", "z": 0]);}};
return cpp ("x y z p", "-", 0, handler());
]], "# 1 \"-\"\n1 p");
test_eval_error([[
class handler {mixed get_predefines() {return (<"x">);}};
cpp ("x y z", "-", 0, handler());
]]);
test_eval_error([[
class handler {mapping get_predefines() {return ([0: 0]);}};
cpp ("x y z", "-", 0, handler());
]]);
test_eval_error([[
class handler {mapping get_predefines() {return (["": 1]);}};
cpp ("x y z", "-", 0, handler());
]]);
test_eval_error([[
class handler {mapping get_predefines() {return (["x": 1]);}};
cpp ("x y z", "-", 0, handler());
]]);
|
| 5f174f | 2003-04-02 | Martin Nilsson | | test_true( Stdio.write_file("conftest.h", "return 17;\n") )
|
| 199425 | 1999-09-06 | Fredrik Hübinette (Hubbe) | |
|
| b1f4eb | 1998-01-13 | Fredrik Hübinette (Hubbe) | | test_any([[
#include "conftest.h"
]],17)
dnltest_any([[
dnl#include <conftest.h>
dnl]],17)
|
| 5f174f | 2003-04-02 | Martin Nilsson | |
test_true( rm("conftest.h") )
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | test_true(intp(__LINE__))
test_true(stringp(__FILE__))
test_true(stringp(__DATE__))
|
| e5fac4 | 2000-03-09 | Johan 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) ]])
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | test_true(stringp(__TIME__))
|
| e5fac4 | 2000-03-09 | Johan 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 ]])
|
| ffb7fe | 1999-12-08 | Henrik Grubbström (Grubba) | | test_true(floatp(__VERSION__))
|
| 5f174f | 2003-04-02 | Martin Nilsson | | test_true(floatp(__REAL_VERSION__))
|
| ffb7fe | 1999-12-08 | Henrik Grubbström (Grubba) | | test_true(intp(__MAJOR__))
|
| 5f174f | 2003-04-02 | Martin Nilsson | | test_true(intp(__REAL_MAJOR__))
|
| ffb7fe | 1999-12-08 | Henrik Grubbström (Grubba) | | test_true(intp(__MINOR__))
|
| 5f174f | 2003-04-02 | Martin Nilsson | | test_true(intp(__REAL_MINOR__))
|
| ffb7fe | 1999-12-08 | Henrik Grubbström (Grubba) | | test_true(intp(__BUILD__))
|
| 5f174f | 2003-04-02 | Martin Nilsson | | test_true(intp(__REAL_BUILD__))
test_eq(__PIKE__,1)
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
|
| 1809f8 | 2003-04-10 | Martin 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" )
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | // #define
test_any([[
#define FOOa 1
return FOOa;
]],1)
test_any([[
#define FOOa array
FOOa(int) b;
return 1;
]],1)
test_any([[
#define FOOb 17
#undef FOOb
#define FOOb 1
return FOOb;
]],1)
test_compile_error([[
#define FOOc FOOc FOO
FOO
]])
|
| e435e7 | 2000-02-28 | Fredrik Hübinette (Hubbe) | | test_any([[
#define FOOa(X) (X)
return FOOa(2);
]],2)
test_any([[
#define FOOa(X) \
(X)
return FOOa(2);
]],2)
|
| 2fad1d | 2000-06-06 | Fredrik Hübinette (Hubbe) | | test_any([[
#define FOOa(X) \
(X)
return FOOa(3);
]],3)
|
| 99656a | 2000-06-13 | Fredrik 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}))
|
| 2fad1d | 2000-06-06 | Fredrik 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")
|
| e435e7 | 2000-02-28 | Fredrik Hübinette (Hubbe) | |
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | // /* */
test_any([[
/* return 99; * / /* */
return 1;
]],1)
|
| 20d9f9 | 2003-08-10 | Martin Nilsson | | test_any([[
/* return 99; // */
return 1;
]],1)
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | // //
test_any([[
// return 99;
|
| 20d9f9 | 2003-08-10 | Martin Nilsson | | return 1; // return 47;
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | ]],1)
|
| 20d9f9 | 2003-08-10 | Martin Nilsson | | // #!
test_any([[
#! int i=4;
int i=3;
#! i=5;
return i;
]],3)
|
| e5bb7d | 1996-09-23 | Fredrik 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)
|
| 8b665c | 2004-11-02 | Martin Stjernholm | | test_if_true('n' == 110)
|
| e5bb7d | 1996-09-23 | Fredrik 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)
|
| 82dfbd | 2004-11-14 | Martin Nilsson | | test_any([[
#if 0
#blahong
#endif
return 1;
]],1)
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | // #if efun
|
| 2de379 | 1997-02-11 | Fredrik Hübinette (Hubbe) | | // see test for add_constant()
|
| e5bb7d | 1996-09-23 | Fredrik 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)
|
| e57393 | 2004-04-16 | Martin Nilsson | | // #if constant
test_any([[
#if constant(Foo.Bar)
return 0;
#else
return 1;
#endif
]],1)
test_any([[
#if constant(Foo) && constant(Bar)
return 0;
#else
return 1;
#endif
]],1)
test_any([[
#if constant(String.Buffer)
return 1;
#else
return 0;
#endif
]],1)
test_any([[
#if constant(String.Bar)
return 0;
#else
return 1;
#endif
]],1)
test_any([[
#if constant(String) && constant(String.Bar)
return 0;
#else
return 1;
#endif
]],1)
|
| 704842 | 2004-07-05 | Martin Nilsson | | test_compile_error([[
#if constant()
constant foo=1;
#endif
]])
|
| e5bb7d | 1996-09-23 | Fredrik 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
test_any([[
#pragma whatever
return 1;
]],1)
// #include
|
| ac8715 | 2000-09-25 | Fredrik Hübinette (Hubbe) | | test_compile_any([[
#pike 7.0
#include <simulate.h>
|
| a3a6c2 | 1998-04-19 | Fredrik Hübinette (Hubbe) | | ]])
|
| e66441 | 1998-04-27 | Fredrik Hübinette (Hubbe) | | // #error
test_compile_error([[
#error Gurgel
]])
|
| fb59d2 | 2004-02-07 | Martin Nilsson | | // #warning
test_compile_warning([[
#warning Gurgel
]])
|
| 20d9f9 | 2003-08-10 | Martin Nilsson | | // <<<<<<<
test_eval_error( cpp("<<<<<<<") )
test_compile_error([[
#if 0
<<<<<<<
#endif
]])
|
| 7b4c2a | 2001-05-17 | Fredrik 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([["\""]])
|
| 853819 | 2001-05-29 | Henrik 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>";
]])
|
| e5bb7d | 1996-09-23 | Fredrik 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))
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | test_eq($1 (typeof(1)), 0)
|
| e5bb7d | 1996-09-23 | Fredrik 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)
|
| 2de379 | 1997-02-11 | Fredrik Hübinette (Hubbe) | | // add_constant
test_do(add_constant("foobar",lambda() { return 1; }))
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | test_any([[
#if efun(foobar)
return 1;
#else
return 0;
#endif
]],1)
test_eq(foobar(),1)
|
| 2de379 | 1997-02-11 | Fredrik Hübinette (Hubbe) | | test_do(add_constant("foobar"))
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | test_any([[
#if efun(foobar)
return 1;
#else
return 0;
#endif
]],0)
|
| 12cec8 | 2003-01-15 | Martin Nilsson | |
// #### Test everything in all_constants.
// - __automap__
// - __empty_program
// - __null_program
// - __parse_pike_type
// - __placeholder_object
// - _describe_program
// - _disable_threads
// - _do_call_outs
// - _exit
// - _gc_status
// - _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]))
// - `-
// - `->
// - `->=
// - `/
// - `<
// - `<<
// - `<=
// - `==
// - `>
// - `>=
// - `>>
// - `[]
// - `[]=
// - `^
// - `|
// - `~
// - abs
// - acos
// Tested in _math
// - add_constant
|
| 1d96e7 | 2003-01-15 | Martin 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);)
|
| 12cec8 | 2003-01-15 | Martin Nilsson | |
// - add_include_path
// - add_module_path
// - add_program_path
// Tested in lib
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | // - aggregate
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | test_equal(aggregate(),({}))
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | test_equal(aggregate(1,2,3,4),({1,2,3,4}))
// - aggregate_multiset
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | test_equal(aggregate_multiset(), (<>))
test_equal(aggregate_multiset(1,1), (<1,1>))
test_equal(aggregate_multiset(1,2,"3"), (<1,2,"3">))
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
// - aggregate_mapping
|
| 12cec8 | 2003-01-15 | Martin 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
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
|
| 694bb1 | 1998-04-23 | Fredrik Hübinette (Hubbe) | | // - all_constants
|
| 2de379 | 1997-02-11 | Fredrik Hübinette (Hubbe) | | test_true(mappingp(all_constants()))
test_eq(all_constants()["all_constants"],all_constants)
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - all_threads
|
| 281d4a | 2003-01-20 | Marcus Comstedt | | cond([[all_constants()->thread_create]],
[[
test_true(arrayp(all_threads()))
test_true(sizeof(all_threads()))
test_true(objectp(all_threads()[0]))
]])
|
| 12cec8 | 2003-01-15 | Martin Nilsson | |
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | // - allocate
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | test_equal(allocate(0),({}))
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | test_equal(allocate(2),({0,0}))
test_false(allocate(2)==({0,0}))
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | test_equal(allocate(2,2),({2,2}))
|
| f9abcf | 1999-09-16 | Fredrik Hübinette (Hubbe) | | test_true(allocate(65536,random))
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - array_sscanf
// - arrayp
// Tested in foop
// - asin
// - atan
// - atan2
// Tested in _math
// - atexit
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | // - backtrace
test_true(arrayp(backtrace()))
test_eq(backtrace()[-1][2],a)
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - basename
// Tested in lib
// - basetype
|
| 1d96e7 | 2003-01-15 | Martin 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")
|
| 12cec8 | 2003-01-15 | Martin Nilsson | |
|
| e5bb7d | 1996-09-23 | Fredrik 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))
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - call_out
// - call_out_info
|
| 039ef7 | 2004-04-29 | Martin Nilsson | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - callablep
|
| 039ef7 | 2004-04-29 | Martin Nilsson | | test_true( callablep(time) )
test_true( callablep(String.capitalize) )
test_true( callablep(CommonLog.read) )
test_true( callablep(ADT.Stack) )
test_true( callablep(String.Buffer) )
test_true( callablep( class { void `()() { } }() ) )
test_false( callablep(String.Buffer()) )
test_true( callablep( ({}) ) )
test_true( callablep( ({ 0,0 }) ) )
test_false( callablep( ({ 0,1 }) ) )
test_true( callablep( ({ time }) ) )
test_true( callablep( ({ time, 0 }) ) )
test_false( callablep( ({ "a", time }) ) )
test_false( callablep( ({ "" }) ) )
test_false( callablep( "" ) )
test_false( callablep( 3.14 ) )
test_false( callablep( (< time >) ) )
test_false( callablep( 0 ) )
test_false( callablep( 7 ) )
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - cd
// - ceil
// Tested in _math
// - chmod
// - chown
// - chroot
// - cleargroups
|
| 8f9f21 | 2002-11-28 | Martin Nilsson | | // - new/clone
|
| 8cde8d | 2002-11-28 | Martin Nilsson | | test_true([[
#pike 7.2
objectp(new(compile_string("int foo() { return 17; }"))) ]])
test_eq([[
#pike 7.2
new(compile_string("int foo() { return 17; }"))->foo() ]],17)
|
| 8f9f21 | 2002-11-28 | Martin Nilsson | | test_true([[
#pike 7.2
objectp(clone(compile_string("int foo() { return 17; }"))) ]])
test_eq([[
#pike 7.2
clone(compile_string("int foo() { return 17; }"))->foo() ]],17)
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - closelog
|
| 1d96e7 | 2003-01-15 | Martin Nilsson | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - column
|
| 1d96e7 | 2003-01-15 | Martin 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})]])
|
| bcd801 | 2003-04-28 | Martin Stjernholm | | test_any_equal([[
array a = ({({(["foo": 17])})});
mixed res = column (a, "foo"); // Avoid constant optimization.
return res && a[0][0];
]], (["foo": 17]))
|
| 12cec8 | 2003-01-15 | Martin Nilsson | |
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | // - combine_path
test_eq([[combine_path("/foo/bar/gazonk/","..")]],"/foo/bar")
|
| 269aae | 2001-06-08 | Henrik 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")
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | test_eq([[combine_path("/.../","sune")]],"/.../sune")
|
| 057758 | 1997-08-27 | Henrik Grubbström (Grubba) | | test_eq([[combine_path("/",".")]],"/")
|
| e5bb7d | 1996-09-23 | Fredrik 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/../../../..")]],"/")
|
| b603cd | 1997-08-26 | Fredrik Hübinette (Hubbe) | | test_eq([[combine_path("/","..")]],"/")
test_eq([[combine_path("./","..")]],"..")
test_eq([[combine_path("./.","..")]],"..")
|
| 9674d4 | 1997-11-13 | Fredrik Hübinette (Hubbe) | | test_eq([[combine_path("/","../../foo")]],"/foo")
|
| b603cd | 1997-08-26 | Fredrik Hübinette (Hubbe) | | test_eq([[combine_path("./foobar/.","..")]],".")
|
| 086bfa | 1998-04-09 | Fredrik Hübinette (Hubbe) | | test_eq([[combine_path("/","foo","bar","gazonk")]],"/foo/bar/gazonk")
|
| 1b5405 | 2001-06-11 | Henrik Grubbström (Grubba) | | test_eq([[combine_path("/", "foo", "")]], "/foo/")
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
|
| 8e0678 | 2001-06-07 | Fredrik 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/")
|
| 12cec8 | 2003-01-15 | Martin Nilsson | |
|
| 51d2a5 | 2004-05-01 | Martin 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")
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - combine_path_nt
|
| 8e0678 | 2001-06-07 | Fredrik 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/")
|
| 7ea8b4 | 2001-06-29 | Henrik Grubbström (Grubba) | | test_eq([[combine_path_nt("a:/", "/foo","bar")+combine_path_nt("/foo","bar")]],
"a:/foo/bar/foo/bar")
|
| 8e0678 | 2001-06-07 | Fredrik Hübinette (Hubbe) | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - combine_path_unix
test_eq([[combine_path_unix("/","/fo\1111/bar/gazonk/../../")]],"/fo\1111/")
|
| 01bab7 | 1999-11-23 | Fredrik Noring | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - compile
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | // - compile_file
// - compile_string
// see test for clone()
|
| 60dd6d | 1999-07-01 | Henrik Grubbström (Grubba) | | cond([[all_constants()->thread_create]],
[[
test_any([[
string file = #"
/*
|
| b4fed8 | 2004-04-21 | Martin Stjernholm | | * Attempt to trig the lex.current_file == NULL bug.
|
| 60dd6d | 1999-07-01 | Henrik Grubbström (Grubba) | | *
* Henrik Grubbström 1999-07-01
*/
string file = Stdio.File(__FILE__, \"r\")->read();
void thread_func()
{
int i;
|
| 787461 | 1999-07-04 | Fredrik Hübinette (Hubbe) | | for (i=0; i < 1000; i++) {
|
| 60dd6d | 1999-07-01 | Henrik Grubbström (Grubba) | | compile_string(file);
}
}
int main(int argc, array(string) argv)
{
|
| 787461 | 1999-07-04 | Fredrik Hübinette (Hubbe) | | array(object) a = allocate(10, thread_create)(thread_func);
|
| 60dd6d | 1999-07-01 | Henrik Grubbström (Grubba) | |
a->wait();
return 0;
}
";
|
| b3c32a | 1999-07-04 | Henrik Grubbström (Grubba) | | allocate(10, thread_create)(lambda() {
|
| 60dd6d | 1999-07-01 | Henrik Grubbström (Grubba) | | int i;
|
| b3c32a | 1999-07-04 | Henrik Grubbström (Grubba) | | for(i = 0; i < 1000; i++) {
|
| 60dd6d | 1999-07-01 | Henrik Grubbström (Grubba) | | compile_string(file);
|
| 96a7d8 | 2002-11-25 | Henrik Grubbström (Grubba) | | if (!(i%10))
__signal_watchdog();
|
| 60dd6d | 1999-07-01 | Henrik Grubbström (Grubba) | | }
} )->wait();
return 0;
]], 0)
]])
|
| e5bb7d | 1996-09-23 | Fredrik 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)
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 >) )
|
| a44f1a | 2000-09-15 | Martin 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))))
|
| b3fedb | 2000-09-15 | Martin 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))))
|
| b0bc82 | 2001-08-09 | Martin 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)
|
| c27206 | 2002-12-12 | Martin 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)
|
| 6bd4cc | 2004-05-28 | Henrik Grubbström (Grubba) | | test_any([[
// Bug 3693
array(mapping) a = ({([])})*2;
return a[0] == a[1];
]], 1)
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - cos
// Tested in _math
// - cpp
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | // - crypt
test_true(stringp(crypt("hej")))
test_true(crypt("hej",crypt("hej")))
|
| 8cde8d | 2002-11-28 | Martin Nilsson | | test_true(crypt("hej","Oz5i0K.16qkgA"))
test_true(crypt("hej","buf8/Z7taE6qs"))
test_true(crypt("123456789", crypt("123456780")))
|
| fb61ba | 1998-04-26 | Fredrik Hübinette (Hubbe) | | test_false(crypt("hej","hej"))
test_false(crypt("h","hej"))
|
| 8cde8d | 2002-11-28 | Martin Nilsson | | test_false(crypt("hej","buf8/Z7taE6qst"))
test_false(crypt("hej","buf8/Z7taE6q"))
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
// - ctime
|
| 8e7710 | 2002-12-01 | Martin Nilsson | | test_eq(ctime(0)[-1],'\n')
|
| 1d96e7 | 2003-01-15 | Martin Nilsson | | test_do([[int t = -1; catch(ctime(t));]])
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - decode_value
// - delay
// - describe_backtrace
// - describe_error
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | // - destruct
|
| 2de379 | 1997-02-11 | Fredrik Hübinette (Hubbe) | | test_do(add_constant("PROG",compile_string("int foo() { return 1; }")));
|
| 2aeef5 | 2002-11-26 | Martin 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=({});]]);
|
| 9040cc | 2002-10-14 | Martin Nilsson | | test_do(add_constant("PROG"))
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - dirname
// Tested in lib
// - encode_value
// - encode_value_canonic
// - endgrent
// - endpwent
|
| c35060 | 2003-03-01 | Martin Nilsson | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - enumerate
|
| c35060 | 2003-03-01 | Martin Nilsson | | // Tested in lib
|
| 15b4dc | 2002-01-31 | Henrik Grubbström (Grubba) | |
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | // - equal
|
| 15eb1b | 1998-02-24 | Henrik Grubbström (Grubba) | | // equal is already tested by this script
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - errno
// - error
// Tested in lib
// - exece
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | // - exit
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - exp
// Tested in _math
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - explode_path
// - file_stat
// - file_truncate
// - filesystem_stat
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - filter
// Tested in lib/modules
// - find_call_out
// - floatp
// Tested in foop
// - floor
// Tested in _math
// - fork
|
| c0988f | 1998-04-17 | Fredrik Hübinette (Hubbe) | |
|
| e5bb7d | 1996-09-23 | Fredrik 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)
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - function_program
// - functionp
// Tested in foop
|
| c35060 | 2003-03-01 | Martin Nilsson | | // - gc
// gc is already tested above
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - get_all_groups
|
| c35060 | 2003-03-01 | Martin 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)
]])
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - get_all_users
|
| c35060 | 2003-03-01 | Martin 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)
]])
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - get_dir
|
| c35060 | 2003-03-01 | Martin 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"))
|
| 82dfbd | 2004-11-14 | Martin Nilsson | | test_true(arrayp(get_dir()))
|
| c35060 | 2003-03-01 | Martin Nilsson | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - get_groups_for_user
// - get_weak_flag
|
| c35060 | 2003-03-01 | Martin Nilsson | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - getcwd
|
| c35060 | 2003-03-01 | Martin 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"))
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - getegid
|
| ed47cc | 2003-03-13 | Martin Nilsson | | ifefun(getegid,[[
test_true(intp(getegid()))
test_true(getegid()==getegid())
]])
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - getenv
|
| ed47cc | 2003-03-13 | Martin Nilsson | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - geteuid
|
| ed47cc | 2003-03-13 | Martin Nilsson | | ifefun(geteuid,[[
test_true(intp(geteuid()))
test_true(geteuid()==geteuid())
]])
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - getgid
|
| ed47cc | 2003-03-13 | Martin Nilsson | | ifefun(getgid,[[
test_true(intp(getgid()))
test_true(getgid()==getgid())
]])
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - getgrent
// - getgrgid
// - getgrnam
// - getgroups
// - gethostbyaddr
// - gethostbyname
|
| c35060 | 2003-03-01 | Martin Nilsson | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - gethostname
|
| c35060 | 2003-03-01 | Martin Nilsson | | test_true(stringp(gethostname()))
test_true(sizeof(gethostname()))
|
| 12cec8 | 2003-01-15 | Martin Nilsson | |
// - gethrtime
// See time
// - gethrvtime
|
| ed47cc | 2003-03-13 | Martin Nilsson | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - getpgrp
|
| ed47cc | 2003-03-13 | Martin Nilsson | | ifefun(getpgrp,[[
test_true(intp(getpgrp()))
test_true(getpgrp()==getpgrp())
]])
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - getpid
|
| ed47cc | 2003-03-13 | Martin Nilsson | | ifefun(getpid,[[
test_true(intp(getpid()))
test_true(getpid()==getpid())
]])
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - getppid
|
| ed47cc | 2003-03-13 | Martin Nilsson | | ifefun(getppid,[[
test_true(intp(getppid()))
test_true(getppid()==getppid())
]])
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - getpwent
// - getpwnam
// - getpwuid
|
| c35060 | 2003-03-01 | Martin Nilsson | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - getsid
|
| c35060 | 2003-03-01 | Martin Nilsson | | ifefun(getsid,[[
test_true(intp(getsid()))
test_true(getsid()==getsid())
]])
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - getuid
|
| c35060 | 2003-03-01 | Martin Nilsson | | ifefun(getuid,[[
test_true(intp(getuid()))
test_true(getuid()==getuid())
]])
|
| 1d96e7 | 2003-01-15 | Martin Nilsson | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - glob
|
| 1d96e7 | 2003-01-15 | Martin 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"})]])
|
| e195ea | 2004-04-29 | Martin Nilsson | | test_eval_error([[
array a=({"a","b",3});
return glob("*", a);
]])
|
| 1d96e7 | 2003-01-15 | Martin Nilsson | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - gmtime
|
| 1d96e7 | 2003-01-15 | Martin Nilsson | | cond([[all_constants()->localtime && all_constants()->mktime]],[[
test_do([[int t = -1; catch(gmtime(t));]])
]])
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - hardlink
// - has_index
|
| c4c8c7 | 2003-08-05 | Martin Stjernholm | | define(test_has_index,[[test_any([[mixed foo=$1; return has_index(foo,$2)==$3;]], 1)]])
|
| 12cec8 | 2003-01-15 | Martin 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)
|
| c4c8c7 | 2003-08-05 | Martin 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)
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | test_has_index([[ class {}() ]],"foo",0)
test_has_index([[ (class{array _indices(){return({"a","b"});}})() ]],"b",1)
// - has_prefix
|
| c35060 | 2003-03-01 | Martin 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"))
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - has_suffix
|
| c35060 | 2003-03-01 | Martin 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"))
|
| 12cec8 | 2003-01-15 | Martin 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)
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
// - hash
|
| c35060 | 2003-03-01 | Martin Nilsson | | test_eq(hash("foo"),2091538203)
test_eq(hash("foo",10),3)
test_eq(hash("bar"),2091518428)
test_eq(hash("bar",10),8)
|
| c60105 | 2003-03-02 | Henrik Grubbström (Grubba) | | test_eq(hash("b\666arqwerty1234"),1829582221)
|
| c35060 | 2003-03-01 | Martin Nilsson | | test_eq(hash(""),0)
|
| e46bf2 | 2004-05-14 | Martin Nilsson | | test_eval_error( return hash("foo",0) )
test_eval_error( return hash("foo",-1) )
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
|
| c60105 | 2003-03-02 | Henrik Grubbström (Grubba) | | // - 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_any([[
#pike 7.4
int i = hash($1);
return ]]dnl
ifelse([[$3]],,, [[((i==$2)||(i==$3))?$2:]])dnl
[[i;
]], $2)
]])
test_hash_7_4("foo",2091538203)
test_hash_7_4([["foo",10]],3)
test_hash_7_4("bar",2091518428)
test_hash_7_4([["bar",10]],8)
test_hash_7_4("b\666arqwerty1234", 2142487018, 1858424874)
test_hash_7_4("",0)
|
| e46bf2 | 2004-05-14 | Martin Nilsson | | test_eval_error( return hash_7_4("foo",0) )
|
| c60105 | 2003-03-02 | Henrik Grubbström (Grubba) | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - hash_7_0
|
| c60105 | 2003-03-02 | Henrik Grubbström (Grubba) | | define(test_hash_7_0, [[
test_any([[
int i = hash_7_0($1);
return ]]dnl
ifelse([[$3]],,, [[((i==$2)||(i==$3))?$2:]])dnl
[[i;
]], $2)
|
| c35060 | 2003-03-01 | Martin Nilsson | | test_any([[
#pike 7.0
|
| c60105 | 2003-03-02 | Henrik Grubbström (Grubba) | | int i = hash($1);
return ]]dnl
ifelse([[$3]],,, [[((i==$2)||(i==$3))?$2:]])dnl
[[i;
]], $2)
|
| c35060 | 2003-03-01 | Martin Nilsson | | ]])
|
| c60105 | 2003-03-02 | Henrik Grubbström (Grubba) | | test_hash_7_0("foo",27734)
test_hash_7_0([["foo",10]],4)
test_hash_7_0("bar",26689)
test_hash_7_0([["bar",10]],9)
test_hash_7_0("b\666arqwerty1234", 2142487018, 1858424874)
test_hash_7_0("",0)
|
| e46bf2 | 2004-05-14 | Martin Nilsson | | test_eval_error( return hash_7_0("foo",0) )
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
// - indices
test_equal(indices("foo"),({0,1,2}))
test_equal(indices(({'f','o','o'})),({0,1,2}))
|
| 2de379 | 1997-02-11 | Fredrik 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}))
|
| e9c689 | 1999-03-01 | Henrik Grubbström (Grubba) | | test_equal(mkmultiset(indices(class{constant a="a"; constant b="b";}())),
(<"a","b">))
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - initgroups
// - innetgrp
// - int2char
// - int2hex
// Tested in String
// - intp
// Tested in foop
// - is_absolute_path
// Tested in lib
// - kill
// - load_module
|
| 1d96e7 | 2003-01-15 | Martin Nilsson | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - localtime
|
| 1d96e7 | 2003-01-15 | Martin 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)
]])
|
| 12cec8 | 2003-01-15 | Martin Nilsson | |
// - log
// Tested in _math
|
| 15eb1b | 1998-02-24 | Henrik Grubbström (Grubba) | |
|
| e5bb7d | 1996-09-23 | Fredrik 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")
|
| 14d088 | 1999-03-20 | Henrik 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")
|
| 8229a0 | 1999-03-20 | Fredrik Hübinette (Hubbe) | | test_equal(lower_case("Foo\x178"),"foo\xff")
|
| 0cb415 | 2000-07-19 | Andreas Lange | | test_equal(lower_case("Foo\x39c"),"foo\x3bc")
|
| b4cb87 | 1999-03-20 | Henrik Grubbström (Grubba) | | test_equal(lower_case((string) ({
|
| 791370 | 2002-04-29 | Henrik 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.
|
| 97478f | 2003-01-29 | Marcus Comstedt | | // Part 1: 0x0000 - 0x0FFF
|
| 926dee | 2005-05-06 | Martin 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, 0x023b, 0x023d, 0x023e,
0x0241, 0x0242, 0x0253, 0x0254, 0x0255, 0x0256, 0x0258, 0x0259,
0x025a, 0x025b, 0x025c, 0x0260, 0x0261, 0x0263, 0x0264, 0x0268,
0x0269, 0x026a, 0x026f, 0x0270, 0x0272, 0x0273, 0x0275, 0x0276,
0x0280, 0x0281, 0x0283, 0x0284, 0x0288, 0x0289, 0x028a, 0x028c,
0x0292, 0x0293, 0x0294, 0x0295, 0x0345, 0x0346, 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, 0x0400, 0x0410,
0x0420, 0x0430, 0x0440, 0x0450, 0x0460, 0x0482, 0x048a, 0x04c0,
0x04c1, 0x04cf, 0x04d0, 0x04fa, 0x0500, 0x0510, 0x0531, 0x0557,
0x0561, 0x0587, })), (string) ({
|
| 0cb415 | 2000-07-19 | Andreas Lange | | 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,
|
| 926dee | 2005-05-06 | Martin Nilsson | | 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, 0x023c, 0x019a, 0x023e,
0x0294, 0x0242, 0x0253, 0x0254, 0x0255, 0x0256, 0x0258, 0x0259,
0x025a, 0x025b, 0x025c, 0x0260, 0x0261, 0x0263, 0x0264, 0x0268,
0x0269, 0x026a, 0x026f, 0x0270, 0x0272, 0x0273, 0x0275, 0x0276,
0x0280, 0x0281, 0x0283, 0x0284, 0x0288, 0x0289, 0x028a, 0x028c,
0x0292, 0x0293, 0x0294, 0x0295, 0x0345, 0x0346, 0x03ac, 0x0387,
|
| 7e93c7 | 2002-04-29 | Henrik Grubbström (Grubba) | | 0x03ad, 0x038b, 0x03cc, 0x038d, 0x03cd, 0x0390, 0x03b1, 0x03c0,
0x03a2, 0x03c3, 0x03ac, 0x03ad, 0x03b0, 0x03b1, 0x03c0, 0x03c2,
0x03c3, 0x03cc, 0x03cd, 0x03cf, 0x03d0, 0x03d1, 0x03d2, 0x03d5,
|
| 926dee | 2005-05-06 | Martin Nilsson | | 0x03d6, 0x03d7, 0x03d9, 0x03f0, 0x03f1, 0x03f2, 0x03f3, 0x03b8,
0x03f5, 0x03f6, 0x03f8, 0x03f2, 0x03fb, 0x03fc, 0x0450, 0x0430,
0x0440, 0x0430, 0x0440, 0x0450, 0x0461, 0x0482, 0x048b, 0x04c0,
0x04c2, 0x04cf, 0x04d1, 0x04fa, 0x0501, 0x0510, 0x0561, 0x0557,
0x0561, 0x0587, }))
|
| 97478f | 2003-01-29 | Marcus 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 -
|
| 926dee | 2005-05-06 | Martin Nilsson | | 0x10a0, 0x10c6, 0x1e00, 0x1e96, 0x1e9b, 0x1e9c,
0x1ea0, 0x1efa, 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, 0x2160, 0x2180, 0x24b6,
0x24d0, 0x24ea, 0x2c00, 0x2c2f, 0x2c30, 0x2c5f, 0x2c80, 0x2ce4,
0x2d00, 0x2d26, 0xff21, 0xff3b, 0xff41, 0xff5b, 0x10400, 0x10428,
0x10450, })), (string) ({
0x2d00, 0x10c6, 0x1e01, 0x1e96, 0x1e9b, 0x1e9c,
0x1ea1, 0x1efa, 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, 0x2170, 0x2180, 0x24d0,
0x24d0, 0x24ea, 0x2c30, 0x2c2f, 0x2c30, 0x2c5f, 0x2c81, 0x2ce4,
0x2d00, 0x2d26, 0xff41, 0xff3b, 0xff41, 0xff5b, 0x10428, 0x10428,
0x10450, }))
|
| b4cb87 | 1999-03-20 | Henrik Grubbström (Grubba) | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - m_delete
// - map
// - mappingp
// Tested in foop
// - master
// - max
// - min
// Tested in _math
// - mkdir
|
| ed47cc | 2003-03-13 | Martin Nilsson | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - mkmapping
|
| ed47cc | 2003-03-13 | Martin 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( ({({})}),({({})}) )[ ({}) ], ({}))
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - mkmultiset
|
| ed47cc | 2003-03-13 | Martin Nilsson | | test_equal(mkmultiset(({})), (<>))
test_equal(mkmultiset(({0})), (<0>))
test_equal(mkmultiset(({(<>)})), (<(<>)>))
|
| 1d96e7 | 2003-01-15 | Martin Nilsson | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - mktime
|
| 1d96e7 | 2003-01-15 | Martin 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,
]) ) ]])
|
| 3114ac | 2004-02-03 | Marcus Comstedt | | test_any([[foreach(({1075550400,94691300,220921700,347152100,473382500,
599612900,725843300,852073700,978304100,1104534500,
1230764900,1356995300,1483225700,1609456100,1735686500,
1861916900,1988147300,2114377700
|
| 724f4b | 2004-12-15 | Martin Stjernholm | | }),int t) {
int res = mktime (gmtime (t));
if(res!=t) return ({t, res});
}
return 0;]], 0)
|
| 3114ac | 2004-02-03 | Marcus Comstedt | |
|
| 1d96e7 | 2003-01-15 | Martin Nilsson | | ]])
|
| 12cec8 | 2003-01-15 | Martin Nilsson | |
// - multisetp
// Tested in foop
// - mv
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
// - next_object
|
| c29a25 | 2003-02-08 | Martin Stjernholm | | test_true(objectp(next_object()) || intp(next_object()) && next_object())
test_any([[
object o=next_object();
for(int e=0; e<10000 && (objectp(o) || intp(o) && o); e++)
o=next_object(o);
return o;
]], 0)
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - normalize_path
// Tested in lib
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | // - object_program
test_true(programp(object_program(this_object())))
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - object_variablep
// - openlog
// - pow
// Tested in _math
// - programp
// Tested in foop
// - putenv
// Tested in lib
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | // - query_num_arg
test_eq(lambda(int ... q) { return query_num_arg(); }(),0)
test_eq(lambda(int ... q) { return query_num_arg(); }(1),1)
test_eq(lambda(int ... q) { return query_num_arg(); }(1,1),2)
test_eq(lambda(int ... q) { return query_num_arg(); }(1,1,1),3)
test_eq(lambda(int ... q) { return query_num_arg(); }(1,1,1,1),4)
// - random
test_any([[int e,d;for(e=0;e<1000;e++){d=random(10); if(d<0 || d>=10) return 0;} return 1]],1)
|
| f21880 | 2001-06-05 | Fredrik Hübinette (Hubbe) | | test_eq([[ random( ({11,21,31,41}) ) % 10 ]], 1)
test_eq([[ random( ({11,21,31,41}) ) % 10 ]], 1)
test_eq([[ random( ({11,21,31,41}) ) % 10 ]], 1)
test_eq([[ random( ({11,21,31,41}) ) % 10 ]], 1)
test_eq([[ random( (<11,21,31,41>) ) % 10 ]], 1)
test_eq([[ random( (<11,21,31,41>) ) % 10 ]], 1)
test_eq([[ random( (<11,21,31,41>) ) % 10 ]], 1)
test_eq([[ random( (<11,21,31,41>) ) % 10 ]], 1)
test_eq([[ random( (<11,21,31,41>) ) % 10 ]], 1)
test_eq([[ random( (<11,21,31,41>) ) % 10 ]], 1)
test_eq([[ `-( @random( ([11:21,31:41]) )) ]], -10)
test_eq([[ `-( @random( ([11:21,31:41]) )) ]], -10)
test_eq([[ `-( @random( ([11:21,31:41]) )) ]], -10)
test_eq([[ `-( @random( ([11:21,31:41]) )) ]], -10)
test_eval_error([[ return random( ({}) ) ]])
test_eval_error([[ return random( (<>) ) ]])
test_eval_error([[ return random( ([]) ) ]])
test_eq([[ random( class() { int _random() { return 17; }}()) ]], 17)
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - random_seed
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | test_do(int p; foreach(({1,2,3,4,5}),p) random_seed(p))
test_eq([[random_seed(17),random(20000)]],[[random_seed(17),random(20000)]])
test_eq([[random_seed(18),random(20000)]],[[random_seed(18),random(20000)]])
test_eq([[random_seed(19),random(20000)]],[[random_seed(19),random(20000)]])
|
| 386b41 | 2003-03-28 | Marcus Comstedt | | test_equal([[random_seed(4711),map(allocate(10,1000), random)]],
[[({598,11,331,991,383,553,997,53,272,381})]])
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - random_string
|
| e46bf2 | 2004-05-14 | Martin Nilsson | | test_eq( sizeof(random_string(47)), 47 )
test_eq( random_string(0), "" )
test_eval_error( return random_string(-1); )
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - readlink
// - remove_call_out
// - remove_include_path
// - remove_module_path
// - remove_program_path
// Tested in lib
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | // - replace
|
| e5a145 | 1999-06-30 | Fredrik Hübinette (Hubbe) | | test_eq(replace("foo","f","\x9999"),"\x9999oo")
test_eq(replace("foo",({"f"}),({"\x9999"})),"\x9999oo")
|
| 7e97c3 | 1999-01-21 | Fredrik Hübinette (Hubbe) | | test_eq([[replace("11013",({"1","100","108","13","1069","1067","106","10"}),
({"A","B","C","D","E","F","G","H"}))]],"AHD")
test_eq([[replace("1264412124",({"126","124","12","122","1260"}),
({"13333","13335","883","13329","226709"}))]],"133334488313335")
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | test_eq(replace("foobargazonk","o","-"),"f--bargaz-nk")
test_eq(replace("foobargazonk",({"o","a"}),({"()","<>"})),"f()()b<>rg<>z()nk")
test_eq(replace("f--barf--",({"f--","f--bar"}),({"f--bar","f--"})),"f--f--bar")
test_eq(replace("f--barf--",({"f--bar","f--"}),({"f--","f--bar"})),"f--f--bar")
|
| 7e97c3 | 1999-01-21 | Fredrik Hübinette (Hubbe) | | test_eq(replace("test\ntest\n\ntest\ntest",({"\n","\n\n"}),({" ","<p>"})),"test test<p>test test")
test_eq(replace("test\ntest\n\ntest\ntest",({"\n\n","\n"}),({"<p>"," "})),"test test<p>test test")
|
| 8c8c46 | 2001-06-27 | Henrik Grubbström (Grubba) | | test_eq(replace("\xfffffff0", ({ "\xfffffff0" }), ({ "" })), "")
|
| 9040cc | 2002-10-14 | Martin Nilsson | | test_eq([[ replace("abcdefg", ([ "a":"x", "d":"y", "h":"z" ])) ]], "xbcyefg")
|
| 7e97c3 | 1999-01-21 | Fredrik Hübinette (Hubbe) | |
|
| e27ab2 | 1999-03-30 | Henrik Grubbström (Grubba) | | test_eq("123\000456""890"-"\0", "123\456""890")
test_eq("123\456000""890"-"\0", "123\456000""890")
|
| 637767 | 2001-06-01 | Henrik Grubbström (Grubba) | | test_any([[
array a=({ 1 });
replace(a,1,2);
return a[0];
]], 2)
test_any([[
mapping a=([ 1:1 ]);
replace(a,1,2);
return a[1];
]], 2)
|
| 7e97c3 | 1999-01-21 | Fredrik Hübinette (Hubbe) | | test_any([[
|
| 3488ef | 2000-04-17 | Henrik Grubbström (Grubba) | | function reference=lambda(string x, array(string) a, array(string) b)
|
| 7e97c3 | 1999-01-21 | Fredrik Hübinette (Hubbe) | | {
string ret="";
for(int pos=0;pos<strlen(x);)
{
int best=-1;
int bestlen=-1;
for(int e=0;e<sizeof(a);e++)
{
if(strlen(a[e])>bestlen)
{
if(x[pos..pos+strlen(a[e])-1] == a[e])
{
best=e;
bestlen=strlen(a[e]);
}
}
}
if(best==-1)
{
ret+=x[pos..pos];
pos++;
}else{
ret+=b[best];
pos+=bestlen;
}
}
return ret;
};
for(int e=0;e<10000;e++)
{
|
| 3488ef | 2000-04-17 | Henrik Grubbström (Grubba) | | array(string) base=(array(string)) ( (({random})*(1+random(10)))(20) );
|
| 7e97c3 | 1999-01-21 | Fredrik Hübinette (Hubbe) | |
for(int d=0;d<random(random(40));d++)
base+=({ base[ random(sizeof(base))] + random(10) });
base=Array.uniq(base);
|
| 18cfc1 | 2002-05-24 | Martin Nilsson | | array(string) to=(array(string))Array.map(base,hash);
|
| 7e97c3 | 1999-01-21 | Fredrik Hübinette (Hubbe) | |
string text="";
for(int d=0;d<1+random(random(50));d++)
{
if(random(2))
text+=base[ random(sizeof(base))];
else
text+=sprintf("%2d",random(100));
}
string r1=replace(text,base,to);
string r2=reference(text,base,to);
if(r1 != r2)
{
|
| fa4196 | 2002-10-18 | Henrik Grubbström (Grubba) | | werror("\nFailure:\n");
|
| 7e97c3 | 1999-01-21 | Fredrik Hübinette (Hubbe) | | werror("Text: %O\n",text);
werror("From: %O\n",base);
werror("To : %O\n",to);
werror("Builtin: %O\n",r1);
werror("Ref : %O\n",r2);
return -1;
}
}
return 1;
]],1)
|
| 3e625c | 1998-10-11 | Fredrik Hübinette (Hubbe) | |
test_eq(replace("f\777\777bargaz\777nk","\777","-"),"f--bargaz-nk")
test_eq(replace("f\777\777bargaz\777nk",({"\777","a"}),({"()","<>"})),"f()()b<>rg<>z()nk")
test_eq(replace("f\777\777barf\777\777",({"f\777\777","f\777\777bar"}),({"f\777\777bar","f\777\777"})),"f\777\777f\777\777bar")
test_eq(replace("f\777\777barf\777\777",({"f\777\777bar","f\777\777"}),({"f\777\777","f\777\777bar"})),"f\777\777f\777\777bar")
test_eq(replace("f\7777777\7777777bargaz\7777777nk","\7777777","-"),"f--bargaz-nk")
test_eq(replace("f\7777777\7777777bargaz\7777777nk",({"\7777777","a"}),({"()","<>"})),"f()()b<>rg<>z()nk")
test_eq(replace("f\7777777\7777777barf\7777777\7777777",({"f\7777777\7777777","f\7777777\7777777bar"}),({"f\7777777\7777777bar","f\7777777\7777777"})),"f\7777777\7777777f\7777777\7777777bar")
test_eq(replace("f\7777777\7777777barf\7777777\7777777",({"f\7777777\7777777bar","f\7777777\7777777"}),({"f\7777777\7777777","f\7777777\7777777bar"})),"f\7777777\7777777f\7777777\7777777bar")
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | test_equal(replace(({1,2,3,4,5,1,2,3,4}),3,-1),({1,2,-1,4,5,1,2,-1,4}))
test_equal(replace(([1:2,3:4,5:1,2:3]),3,-1),([1:2,3:4,5:1,2:-1]))
|
| e195ea | 2004-04-29 | Martin Nilsson | | test_eval_error([[
mapping a = ([ "a":"b", 3:"c" ]);
return replace("bar", a);
]])
test_eval_error([[
mapping a = ([ "a":"b", "c":3 ]);
return replace("bar", a);
]])
test_eval_error([[
return replace("bar", ({"a"}), ({"b","c"}));
]])
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - replace_master
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | // - reverse
test_eq(reverse("reverse"),"esrever")
|
| 0bc4cf | 1998-10-13 | Fredrik Hübinette (Hubbe) | | test_eq(reverse("r\777v\777rs\777"),"\777sr\777v\777r")
test_eq(reverse("r\7777777v\7777777rs\7777777"),"\7777777sr\7777777v\7777777r")
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | test_eq(reverse(""),"")
test_eq(reverse("a"),"a")
test_equal(reverse(({1,5,9})),({9,5,1}))
|
| 04a1ae | 2000-12-13 | Fredrik Noring | | test_equal(reverse(({})),({}))
test_equal(reverse(({42})),({42}))
test_equal(reverse(({42,4711})),({4711,42}))
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | test_equal(reverse(0x12345678),0x1e6a2c48)
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - rm
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - round
// Tested in _math
|
| b7d332 | 2000-01-21 | Fredrik Noring | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - rows
|
| 1d96e7 | 2003-01-15 | Martin Nilsson | | test_equal([[rows(({1,2,3,4,5,6,7,8,9}),({6,7,2}))]],[[({7,8,3})]])
test_equal([[rows(({1,2,3,4,5,6,7,8,9}),({0,4,1}))]],[[({1,5,2})]])
test_equal([[rows(({1,2,3,4,5,6,7,8,9}),({8,3,5}))]],[[({9,4,6})]])
|
| b7d332 | 2000-01-21 | Fredrik Noring | |
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | // - search
|
| be1daa | 1999-11-15 | Henrik Grubbström (Grubba) | | test_eval_error(return search("foolbar","o",-10))
test_eval_error(return search("foolbar","o",2983742))
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | test_eq(search("foolbar","gazonk"),-1)
test_eq(search("qowiueproqiuweproiwqueoplkjljlklksjjriwueproiuwerowieu","lkjljlklksjj"),24)
test_eq(search("lkjljlklksjjriwueproiuwerlskjdvlaskjfowieu","lkjljlklksjj"),0)
test_eq(search("aaaaaaaaaaaaaaaaaaaaaaaalkjljlklksjj","lkjljlklksjj"),24)
|
| 53ec79 | 2004-03-07 | Martin Nilsson | |
// Search cache is initialized with 10 slots.
test_eq(search("aaaaaaaaaaaaaaaaaaaaaaaalkjljlklksjj1","lkjljlklksjj1"),24)
test_eq(search("aaaaaaaaaaaaaaaaaaaaaaaalkjljlklksjj2","lkjljlklksjj2"),24)
test_eq(search("aaaaaaaaaaaaaaaaaaaaaaaalkjljlklksjj3","lkjljlklksjj3"),24)
test_eq(search("aaaaaaaaaaaaaaaaaaaaaaaalkjljlklksjj4","lkjljlklksjj4"),24)
test_eq(search("aaaaaaaaaaaaaaaaaaaaaaaalkjljlklksjj5","lkjljlklksjj5"),24)
test_eq(search("aaaaaaaaaaaaaaaaaaaaaaaalkjljlklksjj6","lkjljlklksjj6"),24)
test_eq(search("aaaaaaaaaaaaaaaaaaaaaaaalkjljlklksjj7","lkjljlklksjj7"),24)
test_eq(search("aaaaaaaaaaaaaaaaaaaaaaaalkjljlklksjj8","lkjljlklksjj8"),24)
test_eq(search("aaaaaaaaaaaaaaaaaaaaaaaalkjljlklksjj9","lkjljlklksjj9"),24)
test_eq(search("aaaaaaaaaaaaaaaaaaaaaaaalkjljlklksjj0","lkjljlklksjj0"),24)
test_eq(search("aaaaaaaaaaaaaaaaaaaaaaaalkjljlklksjjx","lkjljlklksjjx"),24)
test_eq(search("aaaaaaaaaaaaaaaaaaaaaaaalkjljlklksjj","lkjljlklksjj"),24)
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | test_eq(search("foobargazonk","oo"),1)
test_eq(search("foobargazonk","o",3),9)
test_eq(search("foobargazonk","o",9),9)
test_eq(search("foobargazonk","o",10),-1)
test_eq(search("foobargazonk","x",9),-1)
test_eq(search(({56,8,2,6,2,7,3,56,7}),8),1)
test_eq(search(({56,8,2,6,2,7,3,56,7}),56,0),0)
test_eq(search(({56,8,2,6,2,7,3,56,7}),56,1),7)
test_eq(search(({56,8,2,6,2,7,3,56,7}),56,7),7)
test_eq(search(({56,8,2,6,2,7,3,56,7}),56,8),-1)
test_eq(search(({"foo"}),"foo"),0)
test_eq(search("fo-obar|gazonk"/"|","fo-obar"),0)
test_eq(search("fo-obar|gazonk"/"|","gazonk"),1)
test_eq(search(([1:2,3:4,5:6,7:8]),4),3)
|
| f9b413 | 2001-03-31 | Henrik Grubbström (Grubba) | | test_true(zero_type(search(([1:2,3:4,5:6,7:8]),(int)3)))
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | test_eq(search(([1:2,3:4,5:6,7:8]),8),7)
|
| 301a40 | 2001-10-19 | Martin Stjernholm | | test_eq(search("foo",""),0)
|
| 0b6c80 | 2000-02-03 | Fredrik Hübinette (Hubbe) | | test_any([[
mapping m=([]);
m+=(["x":([])]);
m->x->y++;
m=([]);
m+=(["x":([])]);
return m->x->y;
]], 0)
|
| b7d332 | 2000-01-21 | Fredrik Noring | | test_do([[
class C
{
mapping m;
int `==()
{
foreach(indices(m), mixed x)
m_delete(m, x);
return 0;
}
void create(mapping _m)
{
m = _m;
}
|
| 3fcd53 | 2000-01-24 | Martin Stjernholm | | };
|
| b7d332 | 2000-01-21 | Fredrik Noring | |
mapping m = ([ ]);
C o = C(m);
for(int i = 0; i < 100; i++)
m[i] = o;
|
| 3488ef | 2000-04-17 | Henrik Grubbström (Grubba) | | return search(m, 4711);
|
| b7d332 | 2000-01-21 | Fredrik Noring | | ]])
|
| d356f5 | 2000-02-05 | Martin Stjernholm | | test_any_equal([[
mapping m = (["foo": "bar", "bar": "gnu", "gnu": "bar"]);
array a = ({});
a += ({search (m, "bar")});
a += ({search (m, "bar", a[-1])});
a += ({search (m, "bar", a[-1])});
return sort (a);
|
| 1a4202 | 2000-02-05 | Fredrik Hübinette (Hubbe) | | ]], sort(({0, "foo", "gnu"})))
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
// test large searches (find string, size, pattern)
define(test_search,[[
|
| 0bc4cf | 1998-10-13 | Fredrik Hübinette (Hubbe) | | test_eq(sprintf($1+"%'"+$3+"'*n",$2)[..strlen($1)-1],$1)
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | test_eq(search(sprintf($1+"%'"+$3+"'*n",$2),$1),0)
test_eq(search(sprintf("%'"+$3+"'*n" ,$2),$1),-1)
test_eq(search(sprintf("%'"+$3+"'*n"+$1,$2),$1),$2)
test_eq(search(sprintf("%'"+$3+"'*n"+$1+"%'"+$3+"'*n",$2,$2),$1),$2)
]])
define(test_search2,[[dnl
test_search($1,$2,$3)
test_search($1,$2+1,$3)
test_search($1,$2+2,$3)
test_search($1,$2+3,$3)
|
| 31da03 | 1997-03-17 | Fredrik Hübinette (Hubbe) | | test_search($1,$2+4,$3)
test_search($1,$2+5,$3)
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | ]])
define(test_search3,[[dnl
test_search2($1,10,$2)
test_search2($1,1000,$2)
test_search2($1,100000,$2)
]])
define(test_search4,[[dnl
test_search3($1,"+-*")
|
| 31da03 | 1997-03-17 | Fredrik Hübinette (Hubbe) | | test_search3($1,($1[..strlen($1)-2]))
test_search3($1,($1[..strlen($1)-3]))
test_search3($1,($1[1..]))
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | ]])
|
| 34c76c | 1998-04-11 | Henrik Grubbström (Grubba) | | dnl some m4's don't handle 8 bit characters...
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | test_search4("SUNE")
|
| 017bb2 | 1997-05-19 | Fredrik Hübinette (Hubbe) | | test_search4("kapit\344l>")
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | test_search4("-------------------+")
|
| 017bb2 | 1997-05-19 | Fredrik Hübinette (Hubbe) | | test_search4("\345-------------------")
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | test_search4(sprintf("%'argel-bargel glop-glyf?'2000n"))
|
| 0bc4cf | 1998-10-13 | Fredrik Hübinette (Hubbe) | | test_search4("\34567-------------------")
test_search4("\345677777-------------------")
test_search4("kapit\3333l>")
test_search4("kapit\3333333l>")
|
| 3e625c | 1998-10-11 | Fredrik Hübinette (Hubbe) | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - rusage
test_true(
#pike 7.4
arrayp(rusage()))
test_true(
#pike 7.4
sizeof(rusage())>28)
|
| 3e625c | 1998-10-11 | Fredrik Hübinette (Hubbe) | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - set_priority
// - set_weak_flag
// - setegid
// - seteuid
// - setgid
// - setgrent
// - setgroups
// - setpgrp
// - setpwent
// - setresgid
// - setresuid
// - setsid
// - setuid
// - sgn
// Tested in _math
// - signal
// - signame
// - signum
// - sin
// Tested in _math
|
| 02d40d | 1999-06-17 | Fredrik Noring | |
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | // - sizeof
test_eq(sizeof("felbar"),6)
test_eq(sizeof(({"fulbar","gazonk",7})),3)
test_eq(sizeof(([8:3,6:6,7:0])),3)
test_eq(sizeof((<8,7,6,5,4,7>)),6)
|
| 9040cc | 2002-10-14 | Martin Nilsson | | test_eq([[ sizeof( class { int _sizeof() { return 17; } }() ) ]], 17)
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
// - sleep
test_do(sleep(1))
test_do(sleep(0.5))
|
| ade5df | 1998-05-05 | Fredrik Hübinette (Hubbe) | | test_any([[int x=time(); sleep(2); return x!=time()]],1)
test_any([[int x=time(); sleep(2); return x!=time()]],1)
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - sort
|
| 1d96e7 | 2003-01-15 | Martin Nilsson | | test_equal(sort(({1,3,2,4})),({1,2,3,4}))
test_equal(sort(({4,3,2,1})),({1,2,3,4}))
test_equal([[lambda() {array(int) a=({1,2,3,4}); sort(({4,3,2,1}),a); return a; }()]],[[({4,3,2,1})]] )
test_equal([[lambda() {array(int) a=({1,2,3,4}), b=a+({}); sort(({4,3,2,1}),a,b); return b; }()]],[[({4,3,2,1})]] )
|
| 80dad4 | 2003-04-29 | Martin Nilsson | | test_equal([[sort("a,A,å,Å,ä,*A,[A"/",")]],[["*A,A,[A,a,Å,ä,å"/","]])
test_equal([[sort(sprintf("%c",enumerate(256)[*]))]],
[[sprintf("%c",enumerate(256)[*])]])
test_equal([[sort(sprintf("%c",enumerate(1024)[*]))]],
[[sprintf("%c",enumerate(1024)[*])]])
|
| 1d96e7 | 2003-01-15 | Martin Nilsson | | test_equal(sort(({})),({}))
test_equal(sort(({1.0,2.0,4.0,3.0})),({1.0,2.0,3.0,4.0}))
|
| 6ec019 | 2003-04-27 | Martin Stjernholm | | test_any_equal([[
// sort() on one arg should be stable.
class C (int id) {int `< (mixed x) {return 0;}};
return sort (({C(2), C(6), C(1), C(4), C(3), C(5)}))->id;
]], ({2, 6, 1, 4, 3, 5}))
test_any_equal([[
// sort() on several args should be stable.
array a = ({2, 6, 1, 4, 3, 5});
sort (({1, 1, 1, 1, 1, 1}), a);
return a;
]], ({2, 6, 1, 4, 3, 5}))
test_any_equal([[
// sort() on several args should be stable.
array a = ({2, 6, 1, 4, 3, 5});
sort (({1, 2, 1, 2, 1, 2}), a);
return a;
]], ({2, 1, 3, 6, 4, 5}))
test_any([[
class foo {
int x=random(100);
int `<(object o) {return x < o->x;}
};
array(object) o=allocate(100,foo)();
sort(o);
for(int e=1;e<100;e++)
if(o[e-1]->x > o[e]->x)
return e;
return -1;
]],-1)
|
| 66bfd8 | 2003-08-26 | Martin Stjernholm | | test_equal(sort (({(<2>), (<1>)})), ({(<1>), (<2>)}))
|
| 1d96e7 | 2003-01-15 | Martin Nilsson | | dnl missing tests for objects, arrays, multisets and mappings
|
| 12cec8 | 2003-01-15 | Martin Nilsson | |
// - sprintf
// Tested in sprintf
// - sqrt
// Tested in _math
// - strerror
|
| 1d96e7 | 2003-01-15 | Martin Nilsson | | test_true(stringp(strerror(0)))
test_true(stringp(strerror(1)))
test_true(stringp(strerror(-1)))
|
| 12cec8 | 2003-01-15 | Martin Nilsson | |
|
| 4f23b4 | 1998-10-15 | Henrik Grubbström (Grubba) | | // - string_to_unicode, unicode_to_string
|
| 039ef7 | 2004-04-29 | Martin Nilsson | | test_eq(string_to_unicode(""), "")
|
| 4f23b4 | 1998-10-15 | Henrik Grubbström (Grubba) | | test_eq(string_to_unicode("foo"), "\0f\0o\0o")
|
| cad313 | 1998-10-15 | Henrik Grubbström (Grubba) | | test_eq(string_to_unicode("blä"), "\0b\0l\0ä")
|
| 4f23b4 | 1998-10-15 | Henrik Grubbström (Grubba) | | test_eq(string_to_unicode("\77077"), "\176\77")
test_eq(string_to_unicode("\777077"), "\330\277\336\77")
|
| f27279 | 2001-04-18 | Marcus Comstedt | | test_eq(string_to_unicode("\777077foo\77077\777077blä\777077"), "\330\277\336\77\0f\0o\0o\176\77\330\277\336\77\0b\0l\0ä\330\277\336\77")
|
| 039ef7 | 2004-04-29 | Martin Nilsson | | test_eq(unicode_to_string(""), "")
|
| f27279 | 2001-04-18 | Marcus Comstedt | | test_eq(unicode_to_string("\330\277\336\77\0f\0o\0o\176\77\330\277\336\77\0b\0l\0ä\330\277\336\77"), "\777077foo\77077\777077blä\777077")
test_eq(unicode_to_string("\330\277\336\77"), "\777077")
|
| 4f23b4 | 1998-10-15 | Henrik Grubbström (Grubba) | | test_eq(unicode_to_string("\176\77"), "\77077")
test_eq(unicode_to_string("\0b\0l\0ä"), "blä")
test_eq(unicode_to_string("\0f\0o\0o"), "foo")
|
| f27279 | 2001-04-18 | Marcus Comstedt | | test_eq(unicode_to_string("\xfe\xff\330\277\336\77\0f\0o\0o\176\77\330\277\336\77\0b\0l\0ä\330\277\336\77"), "\777077foo\77077\777077blä\777077")
test_eq(unicode_to_string("\xfe\xff\330\277\336\77"), "\777077")
test_eq(unicode_to_string("\xfe\xff\176\77"), "\77077")
test_eq(unicode_to_string("\xfe\xff\0b\0l\0ä"), "blä")
test_eq(unicode_to_string("\xfe\xff\0f\0o\0o"), "foo")
test_eq(unicode_to_string("\xff\xfe\277\330\77\336f\0o\0o\0\77\176\277\330\77\336b\0l\0ä\0\277\330\77\336"), "\777077foo\77077\777077blä\777077")
test_eq(unicode_to_string("\xff\xfe\277\330\77\336"), "\777077")
test_eq(unicode_to_string("\xff\xfe\77\176"), "\77077")
test_eq(unicode_to_string("\xff\xfe""b\0l\0ä\0"), "blä")
test_eq(unicode_to_string("\xff\xfe""f\0o\0o\0"), "foo")
|
| 4f23b4 | 1998-10-15 | Henrik Grubbström (Grubba) | |
|
| be1daa | 1999-11-15 | Henrik Grubbström (Grubba) | | test_eval_error(return string_to_unicode("\7077077"))
|
| 039ef7 | 2004-04-29 | Martin Nilsson | | test_eval_error(return string_to_unicode("\xffff\x10000"))
test_eval_error(return unicode_to_string(" "))
|
| 4f23b4 | 1998-10-15 | Henrik Grubbström (Grubba) | |
// - string_to_utf8, utf8_to_string
|
| 1a84bc | 1998-10-15 | Henrik Grubbström (Grubba) | | test_eq(string_to_utf8("foo"), "foo")
test_eq(string_to_utf8("blä"), "bl\303\244")
test_eq(string_to_utf8("\77077"), "\347\270\277")
|
| dee894 | 2005-04-02 | Martin Stjernholm | | test_eq(string_to_utf8("\7077077", 1), "\367\207\270\277")
test_eq(string_to_utf8("\77077077", 1), "\370\277\207\270\277")
test_eq(string_to_utf8("\7077077077", 1), "\374\270\277\207\270\277")
|
| b168bb | 2004-11-01 | Martin Stjernholm | |
// 077077077077 has 33 bits unsigned. The escape sequence parser used
// to silently truncate too long char values, but not anymore.
dnl test_eq(string_to_utf8("\77077077077", 1), "\376\203\270\277\207\270\277")
dnl test_eq(utf8_to_string("\376\203\270\277\207\270\277", 1), "\77077077077")
// The following uses the char that actually got tested.
test_eq(string_to_utf8("\37077077077", 1), "\376\203\270\277\207\270\277")
test_eq(utf8_to_string("\376\203\270\277\207\270\277", 1), "\37077077077")
|
| dee894 | 2005-04-02 | Martin Stjernholm | | test_eq(utf8_to_string("\374\270\277\207\270\277", 1), "\7077077077")
test_eq(utf8_to_string("\370\277\207\270\277", 1), "\77077077")
test_eq(utf8_to_string("\367\207\270\277", 1), "\7077077")
|
| 1a84bc | 1998-10-15 | Henrik Grubbström (Grubba) | | test_eq(utf8_to_string("\347\270\277"), "\77077")
test_eq(utf8_to_string("bl\303\244"), "blä")
test_eq(utf8_to_string("foo"), "foo")
|
| be1daa | 1999-11-15 | Henrik Grubbström (Grubba) | | test_eval_error(return string_to_utf8("\77077077077"))
test_eval_error(return utf8_to_string("\376\203\270\277\207\270\277"))
test_eval_error(return utf8_to_string("\277"));
test_eval_error(return utf8_to_string("\377"));
test_eval_error(return utf8_to_string("\376\203\270\277\207\270", 1));
test_eval_error(return utf8_to_string("\374\270\277\207\270"));
test_eval_error(return utf8_to_string("\370\277\207\270"));
test_eval_error(return utf8_to_string("\367\207\270"));
test_eval_error(return utf8_to_string("\347\270"));
test_eval_error(return utf8_to_string("\303"));
test_eval_error(return utf8_to_string("\376\203\270\277\207\270a"));
test_eval_error(return utf8_to_string("\374\270\277\207\270a"));
test_eval_error(return utf8_to_string("\370\277\207\270a"));
test_eval_error(return utf8_to_string("\367\207\270a"));
test_eval_error(return utf8_to_string("\347\270a"));
test_eval_error(return utf8_to_string("\303a"));
|
| 1a84bc | 1998-10-15 | Henrik Grubbström (Grubba) | |
|
| dee894 | 2005-04-02 | Martin Stjernholm | | // Invalid ranges
test_eq(string_to_utf8 ("\ud7ff"), "\u00ed\u009f\u00bf")
test_eval_error(return string_to_utf8 ("\ud800"))
test_eq(string_to_utf8 ("\ud800", 1), "\u00ed\u00a0\u0080")
test_eq(string_to_utf8 ("\udfff", 1), "\u00ed\u00bf\u00bf")
test_eval_error(return string_to_utf8 ("\udfff"))
test_eq(string_to_utf8 ("\ue000"), "\u00ee\u0080\u0080")
test_eq(string_to_utf8 ("\U0010ffff"), "\u00f4\u008f\u00bf\u00bf")
test_eval_error(return string_to_utf8 ("\U00110000"))
test_eq(string_to_utf8 ("\U00110000", 1), "\u00f4\u0090\u0080\u0080")
test_eq(utf8_to_string ("\u00ed\u009f\u00bf"), "\ud7ff")
test_eval_error(return utf8_to_string ("\u00ed\u00a0\u0080"))
test_eq(utf8_to_string ("\u00ed\u00a0\u0080", 1), "\ud800")
test_eq(utf8_to_string ("\u00ed\u00bf\u00bf", 1), "\udfff")
test_eval_error(return utf8_to_string ("\u00ed\u00bf\u00bf"))
test_eq(utf8_to_string ("\u00ee\u0080\u0080"), "\ue000")
test_eq(utf8_to_string ("\u00f4\u008f\u00bf\u00bf"), "\U0010ffff")
test_eval_error(return utf8_to_string ("\u00f4\u0090\u0080\u0080"))
test_eq(utf8_to_string ("\u00f4\u0090\u0080\u0080", 1), "\U00110000")
test_eval_error(return utf8_to_string ("\u00f8\u0088\u0080\u0080\u0080"))
test_eval_error(return utf8_to_string ("\u00fc\u0084\u0080\u0080\u0080\u0080"))
test_eval_error(return utf8_to_string ("\u00fe\u0082\u0080\u0080\u0080\u0080\u0080"))
test_eq(utf8_to_string ("\u00fe\u0083\u00bf\u00bf\u00bf\u00bf\u00bf", 1), "\Uffffffff")
test_eval_error(return utf8_to_string ("\u00fe\u0084\u0080\u0080\u0080\u0080\u0080", 1))
test_eval_error(return utf8_to_string ("\u00ff"))
test_eval_error(return utf8_to_string ("\u00ff", 1))
// Non-shortest forms
test_eval_error(return utf8_to_string ("\u00c0\u0080"))
test_eval_error(return utf8_to_string ("\u00c1\u00bf"))
test_eq(utf8_to_string ("\u00c2\u0080"), "\u0080")
test_eval_error(return utf8_to_string ("\u00e0\u0080\u0080"))
test_eval_error(return utf8_to_string ("\u00e0\u009f\u00bf"))
test_eq(utf8_to_string ("\u00e0\u00a0\u0080"), "\u0800"))
test_eval_error(return utf8_to_string ("\u00f0\u0080\u0080\u0080"))
test_eval_error(return utf8_to_string ("\u00f0\u008f\u00bf\u00bf"))
test_eq(utf8_to_string ("\u00f0\u0090\u0080\u0080"), "\U00010000")
test_eval_error(return utf8_to_string ("\u00f8\u0080\u0080\u0080\u0080", 1))
test_eval_error(return utf8_to_string ("\u00f8\u0087\u00bf\u00bf\u00bf", 1))
test_eq(utf8_to_string ("\u00f8\u0088\u0080\u0080\u0080", 1), "\U00200000")
test_eval_error(return utf8_to_string ("\u00fc\u0080\u0080\u0080\u0080\u0080", 1))
test_eval_error(return utf8_to_string ("\u00fc\u0083\u00bf\u00bf\u00bf\u00bf", 1))
test_eq(utf8_to_string ("\u00fc\u0084\u0080\u0080\u0080\u0080", 1), "\U04000000")
test_eval_error(return utf8_to_string ("\u00fe\u0080\u0080\u0080\u0080\u0080\u0080", 1))
test_eval_error(return utf8_to_string ("\u00fe\u0081\u00bf\u00bf\u00bf\u00bf\u00bf", 1))
test_eq(utf8_to_string ("\u00fe\u0082\u0080\u0080\u0080\u0080\u0080", 1), "\U80000000")
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - stringp
// Tested in foop
|
| 3e625c | 1998-10-11 | Fredrik Hübinette (Hubbe) | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - strlen
test_eq(strlen, sizeof)
|
| 3e625c | 1998-10-11 | Fredrik Hübinette (Hubbe) | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - symlink
// - syslog
|
| 3e625c | 1998-10-11 | Fredrik Hübinette (Hubbe) | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - tan
// Tested in _math
|
| 7af261 | 2000-10-01 | Henrik Grubbström (Grubba) | |
|
| b58421 | 2002-05-11 | Martin Stjernholm | | // - this_object and this
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | test_true(objectp(this_object()))
|
| 52f66d | 2003-08-03 | Martin Stjernholm | | test_true(objectp(this))
test_true(objectp(global::this))
test_true(this_object() == this)
test_true([[typeof(this) == typeof(this_object())]])
test_true([[typeof(this) == typeof(global::this)]])
test_true([[typeof(this_program) == typeof(object_program(this_object()))]])
test_true([[typeof(this_program) == typeof(object_program(global::this))]])
test_program_eq([[
|
| b58421 | 2002-05-11 | Martin Stjernholm | | string _sprintf() {return "g";}
class A {
string _sprintf() {return "A";}
class B {
string _sprintf() {return "B";}
mixed f() {
|
| e5674c | 2002-06-07 | Martin Stjernholm | | return sprintf ("%O%O%O%O%O",
global::this, A::this, B::this, this_program::this, this);
|
| b58421 | 2002-05-11 | Martin Stjernholm | | }
}
}
|
| 52f66d | 2003-08-03 | Martin Stjernholm | | string a() {return A()->B()->f();}
]], "gABBB")
|
| b58421 | 2002-05-11 | Martin Stjernholm | |
|
| 52f66d | 2003-08-03 | Martin Stjernholm | | test_program_eq([[
|
| b58421 | 2002-05-11 | Martin Stjernholm | | string _sprintf() {return "g";}
class A {
string _sprintf() {return "A";}
class B {
string _sprintf() {return "B";}
mixed f() {
return sprintf ("%O%O%O%O",
this_object (2), this_object (1), this_object (0), this_object());
}
}
}
|
| 52f66d | 2003-08-03 | Martin Stjernholm | | string a() {return A()->B()->f();}
]], "gABB")
|
| b58421 | 2002-05-11 | Martin Stjernholm | |
|
| 52f66d | 2003-08-03 | Martin Stjernholm | | test_program_eq([[
|
| b58421 | 2002-05-11 | Martin Stjernholm | | string _sprintf() {return "g";}
class A {
string _sprintf() {return "A";}
class B {
string _sprintf() {return "B";}
mixed f() {
return map (({2, 1, 0}), lambda (int l) {
return sprintf ("%O", this_object (l));
}) * "";
}
}
}
|
| 52f66d | 2003-08-03 | Martin Stjernholm | | string a() {return A()->B()->f();}
]], "gAB")
|
| b58421 | 2002-05-11 | Martin Stjernholm | |
|
| 52f66d | 2003-08-03 | Martin Stjernholm | | test_program_eq([[
|
| b58421 | 2002-05-11 | Martin Stjernholm | | string _sprintf() {return "g";}
class A {
string _sprintf() {return "A";}
class B {
string _sprintf() {return "B";}
mixed f() {
|
| e5674c | 2002-06-07 | Martin Stjernholm | | return sprintf ("%O%O%O%O%O",
global::this, A::this, B::this, this_program::this, this);
|
| b58421 | 2002-05-11 | Martin Stjernholm | | }
}
constant this = 7;
}
|
| 52f66d | 2003-08-03 | Martin Stjernholm | | string a() {return A()->B()->f();}
]], "g7BB7")
test_compile_error([[
this = 17;
]])
test_compile_error([[
class A {
class B {
void f() {A::this = 17;}
}
};
|
| b58421 | 2002-05-11 | Martin Stjernholm | | ]])
|
| 52f66d | 2003-08-03 | Martin Stjernholm | | test_any([[
class A {
class B {
A parent() {return A::this;}
}
};
A a = A();
A.B b = a->B();
destruct (a);
return zero_type (b->parent());
]], 2)
test_eval_error([[
class A {
class B {
class C {
A grandparent() {return A::this;}
}
}
};
A.B b = A()->B();
A.B.C c = b->C();
destruct (b);
b->grandparent();
]], 2)
test_program_eq([[
string _sprintf() {return "g";}
class A {
string _sprintf() {return "A";}
mixed f() {
return sprintf ("%O%O", global::this, A::this);
}
}
class B {
string _sprintf() {return "B";}
class C {
inherit A;
string _sprintf() {return "C";}
mixed f() {
return A::f() + sprintf ("%O%O%O%O",
global::this, B::this, this_program::this, this);
}
}
}
string a() {return B()->C()->f();}
]], "gCgBCC")
test_program_eq([[
string _sprintf() {return "g";}
class A {
string _sprintf() {return "A";}
mixed f() {
return sprintf ("%O%O%O%O",
global::this, A::this, this_program::this, this);
}
}
class B {
string _sprintf() {return "B";}
class C {
inherit A;
string _sprintf() {return "C";}
mixed f() {
return A::f() + "|" +
sprintf ("%O%O%O%O%O",
global::this, B::this, C::this, this_program::this, this);
}
}
}
string a() {return B()->C()->f();}
]], "gCCC|gBCCC")
|
| b58421 | 2002-05-11 | Martin Stjernholm | | test_program([[
class A {
class B {
mixed f() {
return typeof (A::this) != typeof (B::this);
}
}
}
int a() {return A()->B()->f();}
]])
test_program([[
class A {
class B {
mixed f() {
return typeof (this_object (1)) != typeof (this_object (0));
}
}
}
int a() {return A()->B()->f();}
]])
|
| 52f66d | 2003-08-03 | Martin Stjernholm | | test_program([[
class A {
class B {
mixed f() {
return typeof (A::this_program) != typeof (B::this_program);
}
}
}
int a() {return A()->B()->f();}
]])
test_program_eq([[
object ao = compile_string(#"
string id() {return \"A\";}
class B {
string id() {return \"B\";}
string foo()
{
return this->id() + id() + local::id() + global::this->id() + global::id();
}
}")();
class Handler
{
mixed resolv (string id, void|string file, void|object handler)
{
if (id == "B") return ao->B;
return master()->resolv (id, file, handler);
}
}
string a()
{
object c = compile_string(#"
string id() {return \"C\";}
class D {
inherit B;
string id() {return \"D\";}
string foo()
{
return ::foo() + \"|\" +
this->id() + id() + B::id() + global::this->id() + global::id();
}
}", 0, Handler())();
return c->D()->foo();
}
]], "DDBAA|DDBCC")
test_program_eq([[
class X
{
object parent() {return global::this;}
}
class Handler
{
mixed resolv (string id, void|string file, void|object handler)
{
if (id == "X") return X;
return master()->resolv (id, file, handler);
}
}
object a()
{
object o = compile_string ("inherit X;", 0, Handler())();
return o->parent();
}
]], this_object())
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - this_thread
// - thread_create
// - thread_local
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | // - throw
|
| 6a2872 | 2002-09-24 | Henrik Grubbström (Grubba) | | test_eq(20,catch(throw(a())))
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
// - time
|
| c47769 | 2000-11-05 | Martin Nilsson | | test_true(time())
test_true(time(1))
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | test_true(intp(time()))
|
| 499e22 | 1998-07-15 | Fredrik Hübinette (Hubbe) | | test_true(intp(time(1)))
test_true(floatp(time(2)))
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
|
| 7b5f51 | 2001-02-05 | Mirar (Pontus Hagland) | | // gethrtime() may gethrtime(), RDTSC or gettimeofday
// sleep uses a combination of select/poll and the above
// time() uses gettimeofday
test_any([[
float tts=2.0;
int t0=time();
float t1=time(t0);
int hrt1=gethrtime();
sleep(tts);
int hrt2=gethrtime();
float t2=time(t0);
float e=(hrt2-hrt1)*1e-6;
float f=t2-t1;
array r=({});
if (e<tts-0.1 || e>tts+0.1)
r+=({sprintf("hrtime %.6f, %+.6f",e,e-tts)});
if (f<tts-0.1 || f>tts+0.1)
r+=({sprintf("timeofday %.6f, %+.6f",f,f-tts)});
if (sizeof(r)) return r*" / ";
return "no error";
]],"no error")
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | // - trace
test_do(trace(0))
test_eq(trace(0),0)
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - ualarm
// - umask
// - uname
// - unicode_to_string
// See string_to_unicode
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | // - upper_case
test_equal(upper_case("fooq"),"FOOQ")
test_equal(upper_case("FooR"),"FOOR")
test_equal(upper_case("Foo1234-*~\n"),"FOO1234-*~\n")
|
| 14d088 | 1999-03-20 | Henrik Grubbström (Grubba) | | test_equal(upper_case("fooq\x3000"),"FOOQ\x3000")
test_equal(upper_case("FooR\x3000"),"FOOR\x3000")
test_equal(upper_case("Foo1234-*~\n\x3000"),"FOO1234-*~\n\x3000")
test_equal(upper_case("fooq\x13000"),"FOOQ\x13000")
test_equal(upper_case("FooR\x13000"),"FOOR\x13000")
test_equal(upper_case("Foo1234-*~\n\x13000"),"FOO1234-*~\n\x13000")
|
| 8229a0 | 1999-03-20 | Fredrik Hübinette (Hubbe) | | test_equal(upper_case("Foo\xff"),"FOO\x178")
|
| 0cb415 | 2000-07-19 | Andreas Lange | | test_equal(upper_case("Foo\xb5"),"FOO\x39c")
|
| b4cb87 | 1999-03-20 | Henrik Grubbström (Grubba) | | test_equal(upper_case((string) ({
|
| 791370 | 2002-04-29 | Henrik Grubbström (Grubba) | | // These characters correspond to the cases in case_info.h
// Please update this and the corresponding lower_case table
// when UnicodeData.txt is changed.
|
| 97478f | 2003-01-29 | Marcus Comstedt | | // Part 1: 0x0000 - 0x0FFF
|
| 926dee | 2005-05-06 | Martin 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, 0x023b, 0x023d, 0x023e,
0x0241, 0x0242, 0x0253, 0x0254, 0x0255, 0x0256, 0x0258, 0x0259,
0x025a, 0x025b, 0x025c, 0x0260, 0x0261, 0x0263, 0x0264, 0x0268,
0x0269, 0x026a, 0x026f, 0x0270, 0x0272, 0x0273, 0x0275, 0x0276,
0x0280, 0x0281, 0x0283, 0x0284, 0x0288, 0x0289, 0x028a, 0x028c,
0x0292, 0x0293, 0x0294, 0x0295, 0x0345, 0x0346, 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, 0x0400, 0x0410,
0x0420, 0x0430, 0x0440, 0x0450, 0x0460, 0x0482, 0x048a, 0x04c0,
0x04c1, 0x04cf, 0x04d0, 0x04fa, 0x0500, 0x0510, 0x0531, 0x0557,
0x0561, 0x0587, })), (string) ({
|
| 0cb415 | 2000-07-19 | Andreas Lange | | 0x0000, 0x0041, 0x005b, 0x0041, 0x007b, 0x039c, 0x00b6, 0x00c0,
0x00d7, 0x00d8, 0x00df, 0x00c0, 0x00f7, 0x00d8, 0x0178, 0x0100,
0x0130, 0x0049, 0x0132, 0x0138, 0x0139, 0x0149, 0x014a, 0x0178,
0x0179, 0x0053, 0x0180, 0x0181, 0x0182, 0x0186, 0x0187, 0x0189,
0x018b, 0x018d, 0x018e, 0x018f, 0x0190, 0x0191, 0x0193, 0x0194,
|
| 926dee | 2005-05-06 | Martin Nilsson | | 0x01f6, 0x0196, 0x0197, 0x0198, 0x023d, 0x019b, 0x019c, 0x019d,
0x0220, 0x019f, 0x01a0, 0x01a6, 0x01a7, 0x01a9, 0x01aa, 0x01ac,
0x01ae, 0x01af, 0x01b1, 0x01b3, 0x01b7, 0x01b8, 0x01ba, 0x01bc,
0x01be, 0x01f7, 0x01c0, 0x01c4, 0x01c5, 0x01c7, 0x01c8, 0x01ca,
0x01cb, 0x018e, 0x01de, 0x01f0, 0x01f1, 0x01f2, 0x01f6, 0x01f7,
0x01f8, 0x0220, 0x0221, 0x0222, 0x0234, 0x023b, 0x023d, 0x023e,
0x0241, 0x0242, 0x0181, 0x0186, 0x0255, 0x0189, 0x0258, 0x018f,
0x025a, 0x0190, 0x025c, 0x0193, 0x0261, 0x0194, 0x0264, 0x0197,
0x0196, 0x026a, 0x019c, 0x0270, 0x019d, 0x0273, 0x019f, 0x0276,
0x01a6, 0x0281, 0x01a9, 0x0284, 0x01ae, 0x0289, 0x01b1, 0x028c,
0x01b7, 0x0293, 0x0241, 0x0295, 0x0399, 0x0346, 0x0386, 0x0387,
|
| 7e93c7 | 2002-04-29 | Henrik Grubbström (Grubba) | | 0x0388, 0x038b, 0x038c, 0x038d, 0x038e, 0x0390, 0x0391, 0x03a0,
0x03a2, 0x03a3, 0x0386, 0x0388, 0x03b0, 0x0391, 0x03a0, 0x03a3,
0x03a3, 0x038c, 0x038e, 0x03cf, 0x0392, 0x0398, 0x03d2, 0x03a6,
|
| dc0df3 | 2003-06-05 | Henrik Grubbström (Grubba) | | 0x03a0, 0x03d7, 0x03d8, 0x039a, 0x03a1, 0x03f9, 0x03f3, 0x03f4,
|
| 926dee | 2005-05-06 | Martin Nilsson | | 0x0395, 0x03f6, 0x03f7, 0x03f9, 0x03fa, 0x03fc, 0x0400, 0x0410,
0x0420, 0x0410, 0x0420, 0x0400, 0x0460, 0x0482, 0x048a, 0x04c0,
0x04c1, 0x04cf, 0x04d0, 0x04fa, 0x0500, 0x0510, 0x0531, 0x0557,
0x0531, 0x0587, }))
|
| 97478f | 2003-01-29 | Marcus Comstedt | | test_equal(upper_case((string) ({
// These characters correspond to the cases in case_info.h
// Please update this and the corresponding lower_case table
// when UnicodeData.txt is changed.
// Part 2: 0x1000 -
|
| 926dee | 2005-05-06 | Martin Nilsson | | 0x10a0, 0x10c6, 0x1e00, 0x1e96, 0x1e9b, 0x1e9c,
0x1ea0, 0x1efa, 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, 0x2160, 0x2180, 0x24b6,
0x24d0, 0x24ea, 0x2c00, 0x2c2f, 0x2c30, 0x2c5f, 0x2c80, 0x2ce4,
0x2d00, 0x2d26, 0xff21, 0xff3b, 0xff41, 0xff5b, 0x10400, 0x10428,
0x10450, })), (string) ({
0x10a0, 0x10c6, 0x1e00, 0x1e96, 0x1e60, 0x1e9c,
0x1ea0, 0x1efa, 0x1f08, 0x1f08, 0x1f18, 0x1f16, 0x1f18, 0x1f1e,
0x1f28, 0x1f28, 0x1f38, 0x1f38, 0x1f48, 0x1f46, 0x1f48, 0x1f4e,
0x1f59, 0x1f52, 0x1f5b, 0x1f54, 0x1f5d, 0x1f56, 0x1f5f, 0x1f58,
0x1f59, 0x1f5a, 0x1f5b, 0x1f5c, 0x1f5d, 0x1f5e, 0x1f5f, 0x1f68,
0x1f68, 0x1fba, 0x1fc8, 0x1fda, 0x1ff8, 0x1fea, 0x1ffa, 0x1f7e,
0x1f88, 0x1f88, 0x1f98, 0x1f98, 0x1fa8, 0x1fa8, 0x1fb8, 0x1fb2,
0x1fbc, 0x1fb4, 0x1fb8, 0x1fba, 0x1fbc, 0x1fbd, 0x0399, 0x1fbf,
0x1fcc, 0x1fc4, 0x1fc8, 0x1fcc, 0x1fcd, 0x1fd8, 0x1fd2, 0x1fd8,
0x1fda, 0x1fdc, 0x1fe8, 0x1fe2, 0x1fec, 0x1fe6, 0x1fe8, 0x1fea,
0x1fec, 0x1fed, 0x1ffc, 0x1ff4, 0x1ff8, 0x1ffa, 0x1ffc, 0x1ffd,
0x2126, 0x2127, 0x212a, 0x212b, 0x212c, 0x2160, 0x2180, 0x24b6,
0x24b6, 0x24ea, 0x2c00, 0x2c2f, 0x2c00, 0x2c5f, 0x2c80, 0x2ce4,
0x10a0, 0x2d26, 0xff21, 0xff3b, 0xff21, 0xff5b, 0x10400, 0x10400,
0x10450, }))
|
| 0cb415 | 2000-07-19 | Andreas Lange | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - utf8_to_string
// See string_to_utf8
// - utime
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
// - values
test_equal(values("foo"),({'f','o','o'}))
test_equal(values(({'f','o','o'})),({'f','o','o'}))
|
| 2de379 | 1997-02-11 | Fredrik Hübinette (Hubbe) | | test_equal(Array.sort_array(values(([7:3,8:9,99:12]))),({3,9,12}))
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | test_equal(values((<7,8,99>)),({1,1,1}))
|
| e9c689 | 1999-03-01 | Henrik Grubbström (Grubba) | | test_equal(mkmultiset(values(class{ constant a="a"; constant b="b";}())),
(<"a","b">))
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - version
test_equal(version(), "Pike v"+__REAL_MAJOR__+"."+__REAL_MINOR__+" release "+__REAL_BUILD__)
// - werror
// - write
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | // - zero_type
test_eq(zero_type(0),0)
test_eq(zero_type(([])[7]),1)
|
| 847c4b | 2002-02-14 | Henrik Grubbström (Grubba) | | test_eq(zero_type(UNDEFINED), 1)
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
|
| 8784d3 | 1999-06-02 | Henrik Grubbström (Grubba) | | test_true([[lambda (int|void a) { return zero_type(a); }()]])
|
| 3c11af | 1999-07-31 | Martin Stjernholm | | test_true([[lambda () {mixed a; return zero_type(a = ([])[0]);}()]])
test_true([[lambda () {mapping a=([]); return zero_type(a[0] = ([])[0]);}()]])
test_true([[zero_type (lambda () {return ([])[0];}())]])
|
| 8784d3 | 1999-06-02 | Henrik Grubbström (Grubba) | |
|
| 8643ef | 2004-10-06 | Martin Stjernholm | | test_any([[
int i = lambda() {return UNDEFINED;}();
lambda (int x) {} (i += 17);
return zero_type (i);
]], 0)
test_any([[
int i = lambda() {return UNDEFINED;}();
lambda (int x) {} (i -= 17);
return zero_type (i);
]], 0)
test_any([[
int i = lambda() {return UNDEFINED;}();
lambda (int x) {} (i++);
i++;
return zero_type (i);
]], 0)
test_any([[
int i = lambda() {return UNDEFINED;}();
lambda (int x) {} (i--);
return zero_type (i);
]], 0)
test_any([[
int i = lambda() {return UNDEFINED;}();
return zero_type (-i);
]], 0)
|
| 12cec8 | 2003-01-15 | Martin Nilsson | |
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | | test_program(int b=10; mixed a() { return 1; })
test_program(mixed b=10; mixed a() { return 1;})
|
| 2de379 | 1997-02-11 | Fredrik Hübinette (Hubbe) | | test_define_program(test,[[int q,w,e,r,t; mixed foo() { return 10; }]])
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
|
| 2de379 | 1997-02-11 | Fredrik Hübinette (Hubbe) | | test_program(inherit test; mixed a() { return foo()==10; })
test_program(inherit test; mixed a() { return test::foo()==10; })
test_program(inherit test : bar; mixed a() { return bar::foo()==10; })
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
|
| 2de379 | 1997-02-11 | Fredrik Hübinette (Hubbe) | | test_define_program(test2,[[int z,x,c,v,b; mixed bar() { return 11; }]])
test_program(inherit test; inherit test2; mixed a() { return foo()==10 && bar()==11; })
test_program(inherit test2; inherit test; mixed a() { return foo()==10 && bar()==11; })
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
|
| 2de379 | 1997-02-11 | Fredrik Hübinette (Hubbe) | | test_define_program(test,[[int q,w,e,r; mixed t; mixed getw() { return w; } void setw(int _) { w=_; }]])
test_define_program(test2,[[int z,x,c,v,b; mixed getb() { return b; } void setb(int _) { b=_; }]])
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
|
| 2de379 | 1997-02-11 | Fredrik Hübinette (Hubbe) | | test_program(inherit test; inherit test2; mixed a() { w=20; b=22; return getw()==20 && getb()==22; })
test_program(inherit test; inherit test2; mixed a() { setw(20); setb(22); return w==20 && b==22; })
test_program(inherit test2; inherit test; mixed a() { w=20; b=22; return getw()==20 && getb()==22; })
test_program(inherit test2; inherit test; mixed a() { setw(20); setb(22); return w==20 && b==22; })
|
| e5bb7d | 1996-09-23 | Fredrik Hübinette (Hubbe) | |
|
| 2aeef5 | 2002-11-26 | Martin Nilsson | | test_do(add_constant("test"))
test_do(add_constant("test2"))
test_eval_error(return class c{int i;void foo(){ destruct(this_object());i=0;return i;}}()->foo())
|
| 916e38 | 1996-09-25 | Fredrik Hübinette (Hubbe) | |
|
| 12cec8 | 2003-01-15 | Martin Nilsson | | // - get_function (actually in simulate.pike)
test_eq(a,
#pike 7.0
Simulate.get_function(this_object(),"a"))
test_eq(a,this_object()->a)
// - catch
test_false([[class X { string test(string foo) { catch { return lower_case(foo); }; return foo; }}()->test(0); ]])
|
| 47ad17 | 2003-09-15 | Martin Stjernholm | | test_true([[catch (1.0 / 0.0)]])
|
| fc75ac | 2003-09-18 | Henrik Grubbström (Grubba) | | test_true([[catch {float f = 1.0 / 0.0;}]])
|
| 12cec8 | 2003-01-15 | Martin Nilsson | |
|
| acc75e | 2002-07-29 | Martin Nilsson | |
|
| 2ae467 | 1997-04-22 | Henrik Grubbström (Grubba) | | // Pike modules
|
| 790a05 | 1998-04-06 | Fredrik Hübinette (Hubbe) | |
|
| 4c203e | 2001-02-04 | Mirar (Pontus Hagland) | | // - this failed in Calendar.Timezone
test_compile(
[[
array tz_ux(int ux)
{
if (ux<-0x80000000 || ux>0x7fffffff)
error("bah\n");
return ({});
};
]]);
|
| 6668b8 | 2003-05-15 | Martin Stjernholm | | // string[]=
|
| 19aaeb | 1998-05-25 | Fredrik Hübinette (Hubbe) | | test_any([[string s="foo"; s[2]='t'; s[0]--; return s;]],"eot")
|
| bcffed | 1998-10-12 | Fredrik Hübinette (Hubbe) | | test_any([[string s="foo"; s[2]=0777; s[1]--; return s;]],"fn\777")
test_any([[string s="foo"; s[2]=07777777; s[1]--; return s;]],"fn\7777777")
|
| 6668b8 | 2003-05-15 | Martin Stjernholm | | test_any([[string s="foo"; s[2]='t'; catch (s[10]='x'); return s;]], "fot")
|
| 19aaeb | 1998-05-25 | Fredrik Hübinette (Hubbe) | |
|
| 694bb1 | 1998-04-23 | Fredrik Hübinette (Hubbe) | | cond([[all_constants()->_verify_internals]],
|
| c0988f | 1998-04-17 | Fredrik Hübinette (Hubbe) | | [[
test_do(_verify_internals())
]])
|
| 82cb5c | 1999-01-24 | Fredrik Hübinette (Hubbe) | |
|
| f9032d | 2004-04-16 | Henrik Grubbström (Grubba) | | test_tests([[
|
| b64a9a | 2004-04-16 | Henrik Grubbström (Grubba) | | array a()
{
|
| f9032d | 2004-04-16 | Henrik Grubbström (Grubba) | | Stdio.File p = Stdio.File();
object pid = Process.create_process(RUNPIKE_ARRAY +
({ "]]SRCDIR[[/test_resolve.pike" }),
([ "stdout":p->pipe(Stdio.PROP_IPC) ]));
|
| 8307ee | 2001-11-08 | Fredrik Hübinette (Hubbe) | | __signal_watchdog();
|
| f9032d | 2004-04-16 | Henrik Grubbström (Grubba) | | string results = lower_case(p->read());
__signal_watchdog();
int err = pid->wait();
int ok;
int failed;
|
| 3676f5 | 2004-04-16 | Henrik Grubbström (Grubba) | | if (((sscanf(results, "%*sok:%d", ok) != 2) +
(sscanf(results, "%*sfailed:%d", failed) != 2)) == 2) {
|
| f9032d | 2004-04-16 | Henrik Grubbström (Grubba) | | // No "ok", and no "failed".
|
| 3676f5 | 2004-04-16 | Henrik Grubbström (Grubba) | | return ({ err, results });
|
| f9032d | 2004-04-16 | Henrik Grubbström (Grubba) | | }
return ({ ok, failed });
|
| b64a9a | 2004-04-16 | Henrik Grubbström (Grubba) | | }
|
| 82cb5c | 1999-01-24 | Fredrik Hübinette (Hubbe) | | ]])
|
| 1c59f9 | 1999-08-09 | Martin Stjernholm | | // - modifiers, compile time type checks
test_compile_any(class A {int v;} class B {inherit A; int v;})
|
| 6b3f5c | 2002-04-11 | Martin Nilsson | | test_compile_error_any(class A {int v;} class B {inherit A; float v;})
dnl test_compile_error_any(class A {int v;} class B {inherit A; mixed v;})
dnl test_compile_error_any(class A {mixed v;} class B {inherit A; int v;})
dnl test_compile_error_any(class A {public int v;} class B {inherit A; mixed v;})
dnl test_compile_error_any(class A { public { int v; } } class B {inherit A; mixed v;})
dnl test_compile_error_any(class A {public mixed v;} class B {inherit A; int v;})
test_compile_error_any(class A {static int v;} class B {inherit A; float v;})
dnl test_compile_error_any(class A {static int v;} class B {inherit A; mixed v;})
dnl test_compile_error_any(class A {static mixed v;} class B {inherit A; int v;})
|
| 1c59f9 | 1999-08-09 | Martin Stjernholm | | test_compile_any(class A {private int v;} class B {inherit A; float v;})
|
| 9eaa6e | 2000-02-12 | Fredrik Hübinette (Hubbe) | | dnl test_compile_any(class A {private int v;} class B {inherit A; mixed v;})
dnl test_compile_any(class A {private mixed v;} class B {inherit A; int v;})
|
| 6b3f5c | 2002-04-11 | Martin Nilsson | | test_compile_error_any(class A {final int v;} class B {inherit A; int v;})
test_compile_error_any(class A {final int v;} class B {inherit A; final int v;})
test_compile_error_any(class A {nomask int v;} class B {inherit A; int v;})
test_compile_error_any(class A {nomask int v;} class B {inherit A; nomask int v;})
|
| 1c59f9 | 1999-08-09 | Martin Stjernholm | | test_compile_any(class A {local int v;} class B {inherit A; float v;})
test_compile_any(class A {local int v;} class B {inherit A; mixed v;})
test_compile_any(class A {local mixed v;} class B {inherit A; int v;})
test_compile_any(class A {inline int v;} class B {inherit A; float v;})
test_compile_any(class A {inline int v;} class B {inherit A; mixed v;})
test_compile_any(class A {inline mixed v;} class B {inherit A; int v;})
test_compile_any(class A {int f(){}} class B {inherit A; int f(){}})
test_compile_any(class A {int f(){}} class B {inherit A; float f(){}})
test_compile_any(class A {int f(){}} class B {inherit A; mixed f(){}})
test_compile_any(class A {mixed f(){}} class B {inherit A; int f(){}})
test_compile_any(class A {void f(){}} class B {inherit A; void f(int a){}})
test_compile_any(class A {void f(int a){}} class B {inherit A; void f(float a){}})
test_compile_any(class A {void f(int a){}} class B {inherit A; void f(mixed a){}})
test_compile_any(class A {void f(mixed a){}} class B {inherit A; void f(int a){}})
|
| 6b3f5c | 2002-04-11 | Martin Nilsson | | test_compile_error_any(class A {final int f(){}} class B {inherit A; int f(){}})
test_compile_error_any(class A {final int f(){}} class B {inherit A; final int f(){}})
test_compile_error_any(class A {nomask int f(){}} class B {inherit A; int f(){}})
test_compile_error_any(class A {nomask int f(){}} class B {inherit A; nomask int f(){}})
|
| 1c59f9 | 1999-08-09 | Martin Stjernholm | |
|
| 90bf26 | 2004-01-15 | Martin Nilsson | | test_compile_warning(class A {int v;}; class B {inherit A; int v(){}})
test_compile_warning(class A {public int v;}; class B {inherit A; int v(){}})
test_compile_warning(class A {static int v;}; class B {inherit A; int v(){}})
|
| 1c59f9 | 1999-08-09 | Martin Stjernholm | | test_compile_any(class A {private int v;} class B {inherit A; int v(){}})
|
| 6b3f5c | 2002-04-11 | Martin Nilsson | | test_compile_error_any(class A {final int v;} class B {inherit A; int v(){}})
test_compile_error_any(class A {nomask int v;} class B {inherit A; int v(){}})
|
| 1c59f9 | 1999-08-09 | Martin Stjernholm | | test_compile_any(class A {local int v;} class B {inherit A; int v(){}})
test_compile_any(class A {inline int v;} class B {inherit A; int v(){}})
|
| 6b3f5c | 2002-04-11 | Martin Nilsson | | test_compile_error_any(class A {int f(){}} class B {inherit A; int f;})
test_compile_error_any(class A {public int f(){}} class B {inherit A; int f;})
test_compile_error_any(class A {static int f(){}} class B {inherit A; int f;})
|
| 1c59f9 | 1999-08-09 | Martin Stjernholm | | test_compile_any(class A {private int f(){}} class B {inherit A; int f;})
|
| 6b3f5c | 2002-04-11 | Martin Nilsson | | test_compile_error_any(class A {final int f(){}} class B {inherit A; int f;})
test_compile_error_any(class A {nomask int f(){}} class B {inherit A; int f;})
|
| 1c59f9 | 1999-08-09 | Martin Stjernholm | | test_compile_any(class A {local int f(){}} class B {inherit A; int f;})
test_compile_any(class A {inline int f(){}} class B {inherit A; int f;})
// - modifiers, compile time access properties
|
| 6b3f5c | 2002-04-11 | Martin Nilsson | | test_compile_error_any(class A {} class B {inherit A; int q; void g(){q=v;}})
|
| 3488ef | 2000-04-17 | Henrik Grubbström (Grubba) | | test_compile_any(class A {int v;} class B {inherit A; int q; void g(){q=v;}})
test_compile_any(class A {public int v;} class B {inherit A; int q; void g(){q=v;}})
test_compile_any(class A {static int v;} class B {inherit A; int q; void g(){q=v;}})
|
| 6b3f5c | 2002-04-11 | Martin Nilsson | | test_compile_error_any(class A {private int v;} class B {inherit A; int q; void g(){q=v;}})
|
| 3488ef | 2000-04-17 | Henrik Grubbström (Grubba) | | test_compile_any(class A {final int v;} class B {inherit A; int q; void g(){q=v;}})
test_compile_any(class A {nomask int v;} class B {inherit A; int q; void g(){q=v;}})
test_compile_any(class A {local int v;} class B {inherit A; int q; void g(){q=v;}})
test_compile_any(class A {inline int v;} class B {inherit A; int q; void g(){q=v;}})
|
| 1c59f9 | 1999-08-09 | Martin Stjernholm | | test_compile_any(class A {int f(){}} class B {inherit A; void g(){f();}})
test_compile_any(class A {public int f(){}} class B {inherit A; void g(){f();}})
test_compile_any(class A {static int f(){}} class B {inherit A; void g(){f();}})
|
| 6b3f5c | 2002-04-11 | Martin Nilsson | | test_compile_error_any(class A {private int f(){}} class B {inherit A; void g(){f();}})
|
| 1c59f9 | 1999-08-09 | Martin Stjernholm | | test_compile_any(class A {final int f(){}} class B {inherit A; void g(){f();}})
test_compile_any(class A {nomask int f(){}} class B {inherit A; void g(){f();}})
test_compile_any(class A {local int f(){}} class B {inherit A; void g(){f();}})
test_compile_any(class A {inline int f(){}} class B {inherit A; void g(){f();}})
|
| 3488ef | 2000-04-17 | Henrik Grubbström (Grubba) | | test_compile_any(class A {int v;} class B {public inherit A; int q; void g(){q=v;}})
test_compile_any(class A {int v;} class B {static inherit A; int q; void g(){q=v;}})
test_compile_any(class A {int v;} class B {private inherit A; int q; void g(){q=v;}})
test_compile_any(class A {int v;} class B {final inherit A; int q; void g(){q=v;}})
test_compile_any(class A {int v;} class B {nomask inherit A; int q; void g(){q=v;}})
test_compile_any(class A {int v;} class B {local inherit A; int q; void g(){q=v;}})
test_compile_any(class A {int v;} class B {inline inherit A; int q; void g(){q=v;}})
|
| 1c59f9 | 1999-08-09 | Martin Stjernholm | | test_compile_any(class A {int f(){}} class B {public inherit A; void g(){f();}})
test_compile_any(class A {int f(){}} class B {static inherit A; void g(){f();}})
test_compile_any(class A {int f(){}} class B {private inherit A; void g(){f();}})
test_compile_any(class A {int f(){}} class B {final inherit A; void g(){f();}})
test_compile_any(class A {int f(){}} class B {nomask inherit A; void g(){f();}})
test_compile_any(class A {int f(){}} class B {local inherit A; void g(){f();}})
test_compile_any(class A {int f(){}} class B {inline inherit A; void g(){f();}})
|
| 6b3f5c | 2002-04-11 | Martin Nilsson | | test_compile_error_any(class A {} class B {inherit A; int q; void g(){q=A::v;}})
|
| 3488ef | 2000-04-17 | Henrik Grubbström (Grubba) | | test_compile_any(class A {int v;} class B {inherit A; int q; void g(){q=A::v;}})
test_compile_any(class A {public int v;} class B {inherit A; int q; void g(){q=A::v;}})
test_compile_any(class A {static int v;} class B {inherit A; int q; void g(){q=A::v;}})
|
| 6b3f5c | 2002-04-11 | Martin Nilsson | | test_compile_error_any(class A {private int v;} class B {inherit A; int q; void g(){q=A::v;}})
|
| 3488ef | 2000-04-17 | Henrik Grubbström (Grubba) | | test_compile_any(class A {final int v;} class B {inherit A; int q; void g(){q=A::v;}})
test_compile_any(class A {nomask int v;} class B {inherit A; int q; void g(){q=A::v;}})
test_compile_any(class A {local int v;} class B {inherit A; int q; void g(){q=A::v;}})
test_compile_any(class A {inline int v;} class B {inherit A; int q; void g(){q=A::v;}})
|
| 1c59f9 | 1999-08-09 | Martin Stjernholm | | test_compile_any(class A {int f(){}} class B {inherit A; void g(){A::f();}})
test_compile_any(class A {public int f(){}} class B {inherit A; void g(){A::f();}})
test_compile_any(class A {static int f(){}} class B {inherit A; void g(){A::f();}})
|
| 6b3f5c | 2002-04-11 | Martin Nilsson | | test_compile_error_any(class A {private int f(){}} class B {inherit A; void g(){A::f();}})
|
| 1c59f9 | 1999-08-09 | Martin Stjernholm | | test_compile_any(class A {final int f(){}} class B {inherit A; void g(){A::f();}})
test_compile_any(class A {nomask int f(){}} class B {inherit A; void g(){A::f();}})
test_compile_any(class A {local int f(){}} class B {inherit A; void g(){A::f();}})
test_compile_any(class A {inline int f(){}} class B {inherit A; void g(){A::f();}})
|
| 3488ef | 2000-04-17 | Henrik Grubbström (Grubba) | | test_compile_any(class A {int v;} class B {public inherit A; int q; void g(){q=A::v;}})
test_compile_any(class A {int v;} class B {static inherit A; int q; void g(){q=A::v;}})
test_compile_any(class A {int v;} class B {private inherit A; int q; void g(){q=A::v;}})
test_compile_any(class A {int v;} class B {final inherit A; int q; void g(){q=A::v;}})
test_compile_any(class A {int v;} class B {nomask inherit A; int q; void g(){q=A::v;}})
test_compile_any(class A {int v;} class B {local inherit A; int q; void g(){q=A::v;}})
test_compile_any(class A {int v;} class B {inline inherit A; int q; void g(){q=A::v;}})
|
| 1c59f9 | 1999-08-09 | Martin Stjernholm | | test_compile_any(class A {int f(){}} class B {public inherit A; void g(){A::f();}})
test_compile_any(class A {int f(){}} class B {static inherit A; void g(){A::f();}})
test_compile_any(class A {int f(){}} class B {private inherit A; void g(){A::f();}})
test_compile_any(class A {int f(){}} class B {final inherit A; void g(){A::f();}})
test_compile_any(class A {int f(){}} class B {nomask inherit A; void g(){A::f();}})
test_compile_any(class A {int f(){}} class B {local inherit A; void g(){A::f();}})
test_compile_any(class A {int f(){}} class B {inline inherit A; void g(){A::f();}})
|
| 6b3f5c | 2002-04-11 | Martin Nilsson | | test_compile_error_any(class A {} class B {inherit A;} class C {inherit B; int q; void g(){q=B::v;}})
|
| 3488ef | 2000-04-17 | Henrik Grubbström (Grubba) | | test_compile_any(class A {int v;} class B {inherit A;} class C {inherit B; int q; void g(){q=B::v;}})
test_compile_any(class A {int v;} class B {public inherit A;} class C {inherit B; int q; void g(){q=B::v;}})
test_compile_any(class A {int v;} class B {static inherit A;} class C {inherit B; int q; void g(){q=B::v;}})
|
| 6b3f5c | 2002-04-11 | Martin Nilsson | | test_compile_error_any(class A {int v;} class B {private inherit A;} class C {inherit B; int q; void g(){q=B::v;}})
|
| 3488ef | 2000-04-17 | Henrik Grubbström (Grubba) | | test_compile_any(class A {int v;} class B {final inherit A;} class C {inherit B; int q; void g(){q=B::v;}})
test_compile_any(class A {int v;} class B {nomask inherit A;} class C {inherit B; int q; void g(){q=B::v;}})
test_compile_any(class A {int v;} class B {local inherit A;} class C {inherit B; int q; void g(){q=B::v;}})
test_compile_any(class A {int v;} class B {inline inherit A;} class C {inherit B; int q; void g(){q=B::v;}})
|
| 1c59f9 | 1999-08-09 | Martin Stjernholm | | test_compile_any(class A {int f(){}} class B {inherit A;} class C {inherit B; void g(){B::f();}})
test_compile_any(class A {int f(){}} class B {public inherit A;} class C {inherit B; void g(){B::f();}})
test_compile_any(class A {int f(){}} class B {static inherit A;} class C {inherit B; void g(){B::f();}})
|
| 6b3f5c | 2002-04-11 | Martin Nilsson | | test_compile_error_any(class A {int f(){}} class B {private inherit A;} class C {inherit B; void g(){B::f();}})
|
| 1c59f9 | 1999-08-09 | Martin Stjernholm | | test_compile_any(class A {int f(){}} class B {final inherit A;} class C {inherit B; void g(){B::f();}})
test_compile_any(class A {int f(){}} class B {nomask inherit A;} class C {inherit B; void g(){B::f();}})
test_compile_any(class A {int f(){}} class B {local inherit A;} class C {inherit B; void g(){B::f();}})
test_compile_any(class A {int f(){}} class B {inline inherit A;} class C {inherit B; void g(){B::f();}})
// - modifiers, run time access properties
|
| be1daa | 1999-11-15 | Henrik Grubbström (Grubba) | | test_eval_error(return class {}()->f())
|
| 1c59f9 | 1999-08-09 | Martin Stjernholm | | test_do(class {int f(){}}()->f())
test_do(class {public int f(){}}()->f())
|
| be1daa | 1999-11-15 | Henrik Grubbström (Grubba) | | test_eval_error(return class {static int f(){}}()->f())
test_eval_error(return class {private int f(){}}()->f())
|
| 1c59f9 | 1999-08-09 | Martin Stjernholm | | test_do(class {final int f(){}}()->f())
test_do(class {nomask int f(){}}()->f())
test_do(class {local int f(){}}()->f())
test_do(class {inline int f(){}}()->f())
test_do(class {class A {}}()->A())
test_do(class {public class A {}}()->A())
|
| be1daa | 1999-11-15 | Henrik Grubbström (Grubba) | | test_eval_error(return class {static class A {}}()->A())
test_eval_error(return class {private class A {}}()->A())
|
| 1c59f9 | 1999-08-09 | Martin Stjernholm | | test_do(class {final class A {}}()->A())
test_do(class {nomask class A {}}()->A())
test_do(class {local class A {}}()->A())
test_do(class {inline class A {}}()->A())
test_equal(indices(class {}()), ({}))
test_equal(indices(class {int v;}()), ({"v"}))
test_equal(indices(class {public int v;}()), ({"v"}))
test_equal(indices(class {static int v;}()), ({}))
test_equal(indices(class {private int v;}()), ({}))
test_equal(indices(class {final int v;}()), ({"v"}))
test_equal(indices(class {nomask int v;}()), ({"v"}))
test_equal(indices(class {local int v;}()), ({"v"}))
test_equal(indices(class {inline int v;}()), ({"v"}))
test_equal(indices(class {int f(){}}()), ({"f"}))
test_equal(indices(class {public int f(){}}()), ({"f"}))
test_equal(indices(class {static int f(){}}()), ({}))
test_equal(indices(class {private int f(){}}()), ({}))
test_equal(indices(class {final int f(){}}()), ({"f"}))
test_equal(indices(class {nomask int f(){}}()), ({"f"}))
test_equal(indices(class {local int f(){}}()), ({"f"}))
test_equal(indices(class {inline int f(){}}()), ({"f"}))
test_equal(indices(class {class A {} class B {inherit A;}}()->B()), ({}))
test_equal(indices(class {class A {int v;} class B {inherit A;}}()->B()), ({"v"}))
test_equal(indices(class {class A {public int v;} class B {inherit A;}}()->B()), ({"v"}))
test_equal(indices(class {class A {static int v;} class B {inherit A;}}()->B()), ({}))
test_equal(indices(class {class A {private int v;} class B {inherit A;}}()->B()), ({}))
test_equal(indices(class {class A {final int v;} class B {inherit A;}}()->B()), ({"v"}))
test_equal(indices(class {class A {nomask int v;} class B {inherit A;}}()->B()), ({"v"}))
test_equal(indices(class {class A {local int v;} class B {inherit A;}}()->B()), ({"v"}))
test_equal(indices(class {class A {inline int v;} class B {inherit A;}}()->B()), ({"v"}))
test_equal(indices(class {class A {int f(){}} class B {inherit A;}}()->B()), ({"f"}))
test_equal(indices(class {class A {public int f(){}} class B {inherit A;}}()->B()), ({"f"}))
test_equal(indices(class {class A {static int f(){}} class B {inherit A;}}()->B()), ({}))
test_equal(indices(class {class A {private int f(){}} class B {inherit A;}}()->B()), ({}))
test_equal(indices(class {class A {final int f(){}} class B {inherit A;}}()->B()), ({"f"}))
test_equal(indices(class {class A {nomask int f(){}} class B {inherit A;}}()->B()), ({"f"}))
test_equal(indices(class {class A {local int f(){}} class B {inherit A;}}()->B()), ({"f"}))
test_equal(indices(class {class A {inline int f(){}} class B {inherit A;}}()->B()), ({"f"}))
test_equal(indices(class {class A {int v;} class B {public inherit A;}}()->B()), ({"v"}))
test_equal(indices(class {class A {int v;} class B {static inherit A;}}()->B()), ({}))
test_equal(indices(class {class A {int v;} class B {private inherit A;}}()->B()), ({}))
test_equal(indices(class {class A {int v;} class B {final inherit A;}}()->B()), ({"v"}))
test_equal(indices(class {class A {int v;} class B {nomask inherit A;}}()->B()), ({"v"}))
test_equal(indices(class {class A {int v;} class B {local inherit A;}}()->B()), ({"v"}))
test_equal(indices(class {class A {int v;} class B {inline inherit A;}}()->B()), ({"v"}))
test_equal(indices(class {class A {int f(){}} class B {public inherit A;}}()->B()), ({"f"}))
test_equal(indices(class {class A {int f(){}} class B {static inherit A;}}()->B()), ({}))
test_equal(indices(class {class A {int f(){}} class B {private inherit A;}}()->B()), ({}))
test_equal(indices(class {class A {int f(){}} class B {final inherit A;}}()->B()), ({"f"}))
test_equal(indices(class {class A {int f(){}} class B {nomask inherit A;}}()->B()), ({"f"}))
test_equal(indices(class {class A {int f(){}} class B {local inherit A;}}()->B()), ({"f"}))
test_equal(indices(class {class A {int f(){}} class B {inline inherit A;}}()->B()), ({"f"}))
test_equal(indices(class {class A {} class B {inherit A;} class C {inherit B;}}()->C()), ({}))
test_equal(indices(class {class A {int v;} class B {inherit A;} class C {inherit B;}}()->C()), ({"v"}))
test_equal(indices(class {class A {int v;} class B {public inherit A;} class C {inherit B;}}()->C()), ({"v"}))
test_equal(indices(class {class A {int v;} class B {static inherit A;} class C {inherit B;}}()->C()), ({}))
test_equal(indices(class {class A {int v;} class B {private inherit A;} class C {inherit B;}}()->C()), ({}))
test_equal(indices(class {class A {int v;} class B {final inherit A;} class C {inherit B;}}()->C()), ({"v"}))
test_equal(indices(class {class A {int v;} class B {nomask inherit A;} class C {inherit B;}}()->C()), ({"v"}))
test_equal(indices(class {class A {int v;} class B {local inherit A;} class C {inherit B;}}()->C()), ({"v"}))
test_equal(indices(class {class A {int v;} class B {inline inherit A;} class C {inherit B;}}()->C()), ({"v"}))
test_equal(indices(class {class A {int f(){}} class B {inherit A;} class C {inherit B;}}()->C()), ({"f"}))
test_equal(indices(class {class A {int f(){}} class B {public inherit A;} class C {inherit B;}}()->C()), ({"f"}))
test_equal(indices(class {class A {int f(){}} class B {static inherit A;} class C {inherit B;}}()->C()), ({}))
test_equal(indices(class {class A {int f(){}} class B {private inherit A;} class C {inherit B;}}()->C()), ({}))
test_equal(indices(class {class A {int f(){}} class B {final inherit A;} class C {inherit B;}}()->C()), ({"f"}))
test_equal(indices(class {class A {int f(){}} class B {nomask inherit A;} class C {inherit B;}}()->C()), ({"f"}))
test_equal(indices(class {class A {int f(){}} class B {local inherit A;} class C {inherit B;}}()->C()), ({"f"}))
test_equal(indices(class {class A {int f(){}} class B {inline inherit A;} class C {inherit B;}}()->C()), ({"f"}))
// - modifiers, binding and redefinition properties with compile time access
test_any(class A {int v=1;}; class B {inherit A; int v=2; int t(){return v;}}; return B()->t(), 2)
test_any(class A {public int v=1;}; class B {inherit A; int v=2; int t(){return v;}}; return B()->t(), 2)
test_any(class A {static int v=1;}; class B {inherit A; int v=2; int t(){return v;}}; return B()->t(), 2)
test_any(class A {private int v=1;}; class B {inherit A; int v=2; int t(){return v;}}; return B()->t(), 2)
|
| 6b3f5c | 2002-04-11 | Martin Nilsson | | test_compile_error_any(class A {final int v=1;}; class B {inherit A; int v=2;};)
test_compile_error_any(class A {nomask int v=1;}; class B {inherit A; int v=2;};)
|
| 1c59f9 | 1999-08-09 | Martin Stjernholm | | test_any(class A {local int v=1;}; class B {inherit A; int v=2; int t(){return v;}}; return B()->t(), 2)
test_any(class A {inline int v=1;}; class B {inherit A; int v=2; int t(){return v;}}; return B()->t(), 2)
test_any(class A {int f(){return 1;}}; class B {inherit A; int f(){return 2;} int t(){return f();}}; return B()->t(), 2)
test_any(class A {public int f(){return 1;}}; class B {inherit A; int f(){return 2;} int t(){return f();}}; return B()->t(), 2)
test_any(class A {static int f(){return 1;}}; class B {inherit A; int f(){return 2;} int t(){return f();}}; return B()->t(), 2)
test_any(class A {private int f(){return 1;}}; class B {inherit A; int f(){return 2;} int t(){return f();}}; return B()->t(), 2)
|
| 6b3f5c | 2002-04-11 | Martin Nilsson | | test_compile_error_any(class A {final int f(){return 1;}}; class B {inherit A; int f(){return 2;}};)
test_compile_error_any(class A {nomask int f(){return 1;}}; class B {inherit A; int f(){return 2;}};)
|
| 1c59f9 | 1999-08-09 | Martin Stjernholm | | test_any(class A {local int f(){return 1;}}; class B {inherit A; int f(){return 2;} int t(){return f();}}; return B()->t(), 2)
test_any(class A {inline int f(){return 1;}}; class B {inherit A; int f(){return 2;} int t(){return f();}}; return B()->t(), 2)
test_any(class A {int v=1;}; class B {public inherit A; int v=2; int t(){return v;}}; return B()->t(), 2)
test_any(class A {int v=1;}; class B {static inherit A; int v=2; int t(){return v;}}; return B()->t(), 2)
test_any(class A {int v=1;}; class B {private inherit A; int v=2; int t(){return v;}}; return B()->t(), 2)
|
| 6b3f5c | 2002-04-11 | Martin Nilsson | | test_compile_error_any(class A {int v=1;}; class B {final inherit A; int v=2;};)
test_compile_error_any(class A {int v=1;}; class B {nomask inherit A; int v=2;};)
|
| 1c59f9 | 1999-08-09 | Martin Stjernholm | | test_any(class A {int v=1;}; class B {local inherit A; int v=2; int t(){return v;}}; return B()->t(), 2)
test_any(class A {int v=1;}; class B {inline inherit A; int v=2; int t(){return v;}}; return B()->t(), 2)
test_any(class A {int f(){return 1;}}; class B {public inherit A; int f(){return 2;} int t(){return f();}}; return B()->t(), 2)
test_any(class A {int f(){return 1;}}; class B {static inherit A; int f(){return 2;} int t(){return f();}}; return B()->t(), 2)
test_any(class A {int f(){return 1;}}; class B {private inherit A; int f(){return 2;} int t(){return f();}}; return B()->t(), 2)
|
| 6b3f5c | 2002-04-11 | Martin Nilsson | | test_compile_error_any(class A {int f(){return 1;}}; class B {final inherit A; int f(){return 2;}};)
test_compile_error_any(class A {int f(){return 1;}}; class B {nomask inherit A; int f(){return 2;}};)
|
| 1c59f9 | 1999-08-09 | Martin Stjernholm | | test_any(class A {int f(){return 1;}}; class B {local inherit A; int f(){return 2;} int t(){return f();}}; return B()->t(), 2)
test_any(class A {int f(){return 1;}}; class B {inline inherit A; int f(){return 2;} int t(){return f();}}; return B()->t(), 2)
test_any(class A {int v=1;}; class B {inherit A; int v=2; int t(){return v;}}; return B()->t(), 2)
test_any(class A {int v=1;}; class B {inherit A; public int v=2; int t(){return v;}}; return B()->t(), 2)
test_any(class A {int v=1;}; class B {inherit A; static int v=2; int t(){return v;}}; return B()->t(), 2)
test_any(class A {int v=1;}; class B {inherit A; private int v=2; int t(){return v;}}; return B()->t(), 2)
test_any(class A {int v=1;}; class B {inherit A; final int v=2; int t(){return v;}}; return B()->t(), 2)
test_any(class A {int v=1;}; class B {inherit A; nomask int v=2; int t(){return v;}}; return B()->t(), 2)
test_any(class A {int v=1;}; class B {inherit A; local int v=2; int t(){return v;}}; return B()->t(), 2)
test_any(class A {int v=1;}; class B {inherit A; inline int v=2; int t(){return v;}}; return B()->t(), 2)
test_any(class A {int f(){return 1;}}; class B {inherit A; int f(){return 2;} int t(){return f();}}; return B()->t(), 2)
test_any(class A {int f(){return 1;}}; class B {inherit A; public int f(){return 2;} int t(){return f();}}; return B()->t(), 2)
test_any(class A {int f(){return 1;}}; class B {inherit A; static int f(){return 2;} int t(){return f();}}; return B()->t(), 2)
test_any(class A {int f(){return 1;}}; class B {inherit A; private int f(){return 2;} int t(){return f();}}; return B()->t(), 2)
test_any(class A {int f(){return 1;}}; class B {inherit A; final int f(){return 2;} int t(){return f();}}; return B()->t(), 2)
test_any(class A {int f(){return 1;}}; class B {inherit A; nomask int f(){return 2;} int t(){return f();}}; return B()->t(), 2)
test_any(class A {int f(){return 1;}}; class B {inherit A; local int f(){return 2;} int t(){return f();}}; return B()->t(), 2)
|
| 4a906f | 2000-06-22 | Henrik Grubbström (Grubba) | | test_any(class A {int f(){return 1;}}; class B {inherit A; int f(){return 2;} int t(){return local::f();}}; return B()->t(), 2)
|
| 1c59f9 | 1999-08-09 | Martin Stjernholm | | test_any(class A {int f(){return 1;}}; class B {inherit A; inline int f(){return 2;} int t(){return f();}}; return B()->t(), 2)
test_any(class A {int v=1; int t(){return v;}}; class B {inherit A; int v=2;}; return B()->t(), 2)
test_any(class A {public int v=1; int t(){return v;}}; class B {inherit A; int v=2;}; return B()->t(), 2)
test_any(class A {static int v=1; int t(){return v;}}; class B {inherit A; int v=2;}; return B()->t(), 2)
test_any(class A {private int v=1; int t(){return v;}}; class B {inherit A; int v=2;}; return B()->t(), 1)
test_any(class A {local int v=1; int t(){return v;}}; class B {inherit A; int v=2;}; return B()->t(), 1)
test_any(class A {inline int v=1; int t(){return v;}}; class B {inherit A; int v=2;}; return B()->t(), 1)
test_any(class A {int f(){return 1;} int t(){return f();}}; class B {inherit A; int f(){return 2;}}; return B()->t(), 2)
test_any(class A {public int f(){return 1;} int t(){return f();}}; class B {inherit A; int f(){return 2;}}; return B()->t(), 2)
test_any(class A {static int f(){return 1;} int t(){return f();}}; class B {inherit A; int f(){return 2;}}; return B()->t(), 2)
test_any(class A {private int f(){return 1;} int t(){return f();}}; class B {inherit A; int f(){return 2;}}; return B()->t(), 1)
test_any(class A {local int f(){return 1;} int t(){return f();}}; class B {inherit A; int f(){return 2;}}; return B()->t(), 1)
|
| 4a906f | 2000-06-22 | Henrik Grubbström (Grubba) | | test_any(class A {int f(){return 1;} int t(){return local::f();}}; class B {inherit A; int f(){return 2;}}; return B()->t(), 1)
|
| 1c59f9 | 1999-08-09 | Martin Stjernholm | | test_any(class A {inline int f(){return 1;} int t(){return f();}}; class B {inherit A; int f(){return 2;}}; return B()->t(), 1)
test_any(class A {int v=1; int t(){return v;}}; class B {inherit A; int v=2; int t(){return A::t();}}; return B()->t(), 2)
test_any(class A {int v=1; int t(){return v;}}; class B {public inherit A; int v=2; int t(){return A::t();}}; return B()->t(), 2)
test_any(class A {int v=1; int t(){return v;}}; class B {static inherit A; int v=2; int t(){return A::t();}}; return B()->t(), 2)
test_any(class A {int v=1; int t(){return v;}}; class B {private inherit A; int v=2; int t(){return A::t();}}; return B()->t(), 2)
test_any(class A {int v=1; int t(){return v;}}; class B {local inherit A; int v=2; int t(){return A::t();}}; return B()->t(), 1)
test_any(class A {int v=1; int t(){return v;}}; class B {inline inherit A; int v=2; int t(){return A::t();}}; return B()->t(), 1)
test_any(class A {int f(){return 1;} int t(){return f();}}; class B {inherit A; int f(){return 2;} int t(){return A::t();}}; return B()->t(), 2)
test_any(class A {int f(){return 1;} int t(){return f();}}; class B {public inherit A; int f(){return 2;} int t(){return A::t();}}; return B()->t(), 2)
test_any(class A {int f(){return 1;} int t(){return f();}}; class B {static inherit A; int f(){return 2;} int t(){return A::t();}}; return B()->t(), 2)
test_any(class A {int f(){return 1;} int t(){return f();}}; class B {private inherit A; int f(){return 2;} int t(){return A::t();}}; return B()->t(), 2)
test_any(class A {int f(){return 1;} int t(){return f();}}; class B {local inherit A; int f(){return 2;} int t(){return A::t();}}; return B()->t(), 1)
test_any(class A {int f(){return 1;} int t(){return f();}}; class B {inline inherit A; int f(){return 2;} int t(){return A::t();}}; return B()->t(), 1)
|
| 021656 | 1999-08-20 | Martin Stjernholm | | test_any([[
class A {int v=0x100; int a(){return v;}}; class B {inherit A; int v=0x010; int b(){return v;}}; class C {inherit B; int v=0x001; int c(){return v;}};
object c=C(); return c->a()+c->b()+c->c();
]], 0x003)
test_any([[
class A {int v=0x100; int a(){return v;}}; class B {inherit A; public int v=0x010; int b(){return v;}}; class C {inherit B; int v=0x001; int c(){return v;}};
object c=C(); return c->a()+c->b()+c->c();
]], 0x003)
test_any([[
class A {int v=0x100; int a(){return v;}}; class B {inherit A; private int v=0x010; int b(){return v;}}; class C {inherit B; int v=0x001; int c(){return v;}};
object c=C(); return c->a()+c->b()+c->c();
]], 0x021)
test_any([[
class A {int v=0x100; int a(){return v;}}; class B {inherit A; static int v=0x010; int b(){return v;}}; class C {inherit B; int v=0x001; int c(){return v;}};
object c=C(); return c->a()+c->b()+c->c();
]], 0x003)
test_any([[
class A {int v=0x100; int a(){return v;}}; class B {inherit A; local int v=0x010; int b(){return v;}}; class C {inherit B; int v=0x001; int c(){return v;}};
object c=C(); return c->a()+c->b()+c->c();
]], 0x021)
test_any([[
class A {int v=0x100; int a(){return v;}}; class B {inherit A; inline int v=0x010; int b(){return v;}}; class C {inherit B; int v=0x001; int c(){return v;}};
object c=C(); return c->a()+c->b()+c->c();
]], 0x021)
|
| 1c59f9 | 1999-08-09 | Martin Stjernholm | | // - modifiers, binding and redefinition properties with run time access
test_any(class A {int v=1;}; class B {inherit A; int v=2;}; return B()->v, 2)
test_any(class A {public int v=1;}; class B {inherit A; int v=2;}; return B()->v, 2)
test_any(class A {static int v=1;}; class B {inherit A; int v=2;}; return B()->v, 2)
test_any(class A {private int v=1;}; class B {inherit A; int v=2;}; return B()->v, 2)
test_any(class A {local int v=1;}; class B {inherit A; int v=2;}; return B()->v, 2)
test_any(class A {inline int v=1;}; class B {inherit A; int v=2;}; return B()->v, 2)
test_any(class A {int f(){return 1;}}; class B {inherit A; int f(){return 2;}}; return B()->f(), 2)
test_any(class A {public int f(){return 1;}}; class B {inherit A; int f(){return 2;}}; return B()->f(), 2)
test_any(class A {static int f(){return 1;}}; class B {inherit A; int f(){return 2;}}; return B()->f(), 2)
test_any(class A {private int f(){return 1;}}; class B {inherit A; int f(){return 2;}}; return B()->f(), 2)
test_any(class A {local int f(){return 1;}}; class B {inherit A; int f(){return 2;}}; return B()->f(), 2)
test_any(class A {inline int f(){return 1;}}; class B {inherit A; int f(){return 2;}}; return B()->f(), 2)
test_any(class A {int v=1;}; class B {public inherit A; int v=2;}; return B()->v, 2)
test_any(class A {int v=1;}; class B {static inherit A; int v=2;}; return B()->v, 2)
test_any(class A {int v=1;}; class B {private inherit A; int v=2;}; return B()->v, 2)
test_any(class A {int v=1;}; class B {local inherit A; int v=2;}; return B()->v, 2)
test_any(class A {int v=1;}; class B {inline inherit A; int v=2;}; return B()->v, 2)
test_any(class A {int f(){return 1;}}; class B {public inherit A; int f(){return 2;}}; return B()->f(), 2)
test_any(class A {int f(){return 1;}}; class B {static inherit A; int f(){return 2;}}; return B()->f(), 2)
test_any(class A {int f(){return 1;}}; class B {private inherit A; int f(){return 2;}}; return B()->f(), 2)
test_any(class A {int f(){return 1;}}; class B {local inherit A; int f(){return 2;}}; return B()->f(), 2)
test_any(class A {int f(){return 1;}}; class B {inline inherit A; int f(){return 2;}}; return B()->f(), 2)
test_any(class A {int v=1;}; class B {inherit A; public int v=2;}; return B()->v, 2)
test_any(class A {int v=1;}; class B {inherit A; static int v=2;}; return B()->v, 0)
test_any(class A {int v=1;}; class B {inherit A; private int v=2;}; return B()->v, 0)
test_any(class A {int v=1;}; class B {inherit A; final int v=2;}; return B()->v, 2)
test_any(class A {int v=1;}; class B {inherit A; nomask int v=2;}; return B()->v, 2)
test_any(class A {int v=1;}; class B {inherit A; local int v=2;}; return B()->v, 2)
test_any(class A {int v=1;}; class B {inherit A; inline int v=2;}; return B()->v, 2)
test_any(class A {int f(){return 1;}}; class B {inherit A; public int f(){return 2;}}; return B()->f(), 2)
test_any(class A {int f(){return 1;}}; class B {inherit A; static int f(){return 2;}}; return B()->f, 0)
test_any(class A {int f(){return 1;}}; class B {inherit A; private int f(){return 2;}}; return B()->f, 0)
test_any(class A {int f(){return 1;}}; class B {inherit A; final int f(){return 2;}}; return B()->f(), 2)
test_any(class A {int f(){return 1;}}; class B {inherit A; nomask int f(){return 2;}}; return B()->f(), 2)
test_any(class A {int f(){return 1;}}; class B {inherit A; local int f(){return 2;}}; return B()->f(), 2)
test_any(class A {int f(){return 1;}}; class B {inherit A; inline int f(){return 2;}}; return B()->f(), 2)
|
| 993ba7 | 2000-02-15 | Fredrik Hübinette (Hubbe) | |
|
| 7ebef9 | 2002-06-10 | Martin Stjernholm | | // - modifiers, misc checks
test_program([[
class A {int i = 17;}
class B {
private inherit A;
class C {
int f() {return i;}
}
}
int a() {return B()->C()->f() == 17;}
]])
|
| 993ba7 | 2000-02-15 | Fredrik Hübinette (Hubbe) | | test_any([[
class Fnord
{
array gnzpp() { }
constant fNord = 4711;
class Bzonk
{
int xxxxx=17;
int yyyyy=17;
int zzzzz=17;
}
class Zboink
{
int pphfiztzz=1;
inherit Bzonk;
constant floingngg=fNord;
array Zpfoooinginoooo() {}
int t()
{
return fNord + fNord;
}
int z()
{
return floingngg + floingngg;
}
}
};
return Fnord()->Zboink()->t() + Fnord()->Zboink()->z();
]],4711 * 4)
|
| e3489e | 2000-08-27 | Henrik Grubbström (Grubba) | |
test_any([[
class Foo
{
string s = "a";
int|string foo()
{
int i;
for (; i < strlen(s); i++) {
if (!strlen(s) && i) {
return "Optimizer error!";
}
s = "";
i = 0;
}
return 0;
}
};
return Foo()->foo();
]], 0)
|
| 87f908 | 2001-03-12 | Fredrik Hübinette (Hubbe) | |
// - call_out, call_out_info, remove_call_out, find_call_out
test_do(add_constant("call_out_cb", a))
test_do(call_out(call_out_cb,100000))
test_true(call_out(lambda() {},1000.0))
test_true(remove_call_out(call_out(lambda() {},1000.0)) != -1)
test_true(find_call_out(call_out(lambda() {},1000.0)) > 990)
test_false(zero_type(remove_call_out(call_out(lambda() {},1000.0))))
test_true(arrayp(call_out_info()))
test_true(sizeof(call_out_info()) > 0)
test_true(call_out_info()[-1][0] > 1)
test_eq(find_call_out(call_out_info()[-1][2]), call_out_info()[-1][0])
test_eq(find_call_out(a),-1)
test_true(zero_type(find_call_out(a)))
test_true(!sizeof(call_out_info()) || function_name(call_out_info()[-1][2])!="call_out_cb")
test_do(remove_call_out(call_out_info()[-1][2]))
test_do(add_constant("call_out_cb"))
test_do(_do_call_outs())
|
| 62593e | 2004-03-08 | Henrik Grubbström (Grubba) | | test_any([[
|
| 5b1379 | 2004-03-08 | Henrik Grubbström (Grubba) | | object pid = Process.create_process(RUNPIKE_ARRAY +
|
| 47cc28 | 2004-03-08 | Henrik Grubbström (Grubba) | | ({ "]]SRCDIR[[/test_co.pike" }));
|
| 5b1379 | 2004-03-08 | Henrik Grubbström (Grubba) | | int i;
|
| 5deb6a | 2004-03-12 | Henrik Grubbström (Grubba) | | for (i=0; i < 120; i++) {
|
| 5b1379 | 2004-03-08 | Henrik Grubbström (Grubba) | | if (pid->status()>0) break;
__signal_watchdog();
sleep(1);
}
if (pid->status() <= 0) {
pid->kill(9);
|
| 3f0b9a | 2004-03-08 | Henrik Grubbström (Grubba) | | return "Killed";
|
| 5b1379 | 2004-03-08 | Henrik Grubbström (Grubba) | | }
return pid->wait();
|
| 62593e | 2004-03-08 | Henrik Grubbström (Grubba) | | ]], 0)
|
| 24c37f | 2001-05-24 | Fredrik Hübinette (Hubbe) | | test_do_([[ catch { _do_call_outs(); }]])
|
| d4a895 | 2002-11-21 | Martin Nilsson | |
// - varargs
test_any_equal([[
mixed test(int a, mixed ... b) {
return b;
};
return test(1);
]],[[ ({}) ]])
test_any_equal([[
mixed test(int a, mixed ... b) {
return b;
};
return test(1,2);
]],[[ ({2}) ]])
test_any_equal([[
mixed test(int a, mixed ... b) {
return b;
};
return test(1,2,3);
]],[[ ({2,3}) ]])
test_any_equal([[
mixed test(int a, mixed ... b) {
return b;
};
return test(1,2,3);
]],[[ ({2,3}) ]])
test_compile_error([[
mixed test(int a, mixed ... b) {
return b;
};
return test();
]])
test_any_equal([[
mixed test(void|int a, mixed ... b) {
return b;
};
return test();
]],[[ ({}) ]])
test_any_equal([[
mixed test(int a, mixed ... b) {
if(a) return test(0);
return b;
};
return test(1,2);
]],[[ ({}) ]])
test_any_equal([[
class X {
mixed test(int a, mixed ... b) {
if(a) return test(0);
return b;
}
|
| 5198c5 | 2002-11-22 | Henrik Grubbström (Grubba) | | };
|
| d4a895 | 2002-11-21 | Martin Nilsson | | return X()->test(1,2);
]],[[ ({}) ]])
|
| 1169d9 | 2004-05-02 | Martin Nilsson | | END_MARKER
|