pike.git
/
src
/
testsuite.in
version
»
Context lines:
10
20
40
80
file
none
3
pike.git/src/testsuite.in:1:
START_MARKER
-
test_true([["$Id: testsuite.in,v 1.
868
2009/03/
14
21
:
16
:
14
mast Exp $"]]);
+
test_true([["$Id: testsuite.in,v 1.
869
2009/03/
15
12
:
11
:
23
mast Exp $"]]);
// This triggered a bug only if run sufficiently early. test_compile_any([[#pike 7.2]]) test_compile_any([[#pike 7.4]]) test_compile_any([[#pike 7.0]]) test_compile_any([[#pike 0.6]]) cond([[all_constants()->_verify_internals]], [[ test_do(_verify_internals())
pike.git/src/testsuite.in:4713:
test_compile([[do { break; } while (0);]]) 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) cond([[all_constants()->_verify_internals]], [[ test_do(_verify_internals()) ]])
-
cond([[all_constants()->thread_create]]
,
-
[[
+
cond
_begin
([[all_constants()->thread_create]]
)
+
// thread_create test_do(thread_create(lambda() { })) // /precompiled/mutex test_true(Thread.Mutex()) test_do(add_constant("_tmp_mutex",Thread.Mutex())) test_true(_tmp_mutex->lock()) test_true(_tmp_mutex->lock()) test_true(_tmp_mutex->trylock()) test_true(_tmp_mutex->trylock()) test_do(add_constant("_tmp_mutex_lock",_tmp_mutex->lock())) test_true(catch(_tmp_mutex->trylock())) test_do(add_constant("_tmp_mutex_lock")) test_true(_tmp_mutex->trylock()) test_do(add_constant("_tmp_mutex"))
-
test_any([[ object m = Thread.Mutex(); object k = m->lock(); thread_create(lambda(object k){ sleep(10); catch { destruct(k); }; }, k);if (catch{m->lock(); return 0;}) { return 1; } return 0; ]],1)
-
test_any([[ 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)
+
test_any([[
-
+
object m = Thread.Mutex();
+
object k = m->lock();
+
thread_create(lambda(object k){
+
sleep(10);
+
catch { destruct(k); };
+
}, k);
+
if (catch{
+
m->lock();
+
return 0;
+
}) {
+
return 1;
+
}
+
return 0;
+
]],1)
+
+
test_any([[
+
array data=({0,Thread.Mutex(),Thread.Mutex(),0});
+
data[3]=data[2]->lock();
+
thread_create(lambda(array data) {
+
object o=data[1]->lock();
+
destruct(data[3]);
+
sleep(10);
+
data[0]=1;
+
destruct(o);
+
},data);
+
object l=data[2]->lock(1);
+
object ll=data[1]->lock();
+
return data[0];
+
]],1)
+
+
test_any([[
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++) {
pike.git/src/testsuite.in:4792:
return val + " != " + (to_write + to_read); to_read--; } else { q->write(to_write--); to_read++; } } return 0; ]], 0)
-
test_any([[object o=Thread.Queue(); thread_create(lambda(object f) {
for(int
e=0;e<10000;e++)
f->write(random(4711));
f->write(-1);
},o);
int
tmp=0;
while(o->read()
!=
-1)
tmp++;
return
tmp;]],10000)
-
test_any([[object
o=Thread.Fifo();
thread_create(lambda(object
f)
{
for(int e=0;e<10000;e++) f->write(random(4711)); f->write(-1); },o); int tmp=0; while(o->read() != -1) tmp++; return tmp;]],10000)
+
test_any([[
+
object o=Thread.Queue();
+
thread_create(lambda(object f) {
+
for(int e=0;e<10000;e++)
+
f->write(random(4711));
+
f->write(-1);
+
},o);
+
int tmp=0;
+
while(o->read() != -1)
+
tmp++;
+
return tmp;
+
]],10000)
-
+
test_any([[
+
object o=Thread.Fifo();
+
thread_create(lambda(object f) {
+
for(int e=0;e<10000;e++)
+
f->write(random(4711));
+
f->write(-1);
+
},o);
+
int tmp=0;
+
while(o->read() != -1)
+
tmp++;
+
return tmp;
+
]],10000)
+
dnl this will crash pike on out-of-address-space-related errors dnl test_any([[ catch { allocate(10000,thread_create)(lambda() { sleep(1); })->wait(); } ]]) 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)
-
]])
+
-
cond([[all_constants()->thread_create]],
-
[[
+
// _disable_threads test_any([[ #ifndef __NT__ // Using a named pipe here to make open() block. That doesn't exist on NT. object t = class { void log (function f, string msg) { #if 0 if (f == test) msg = "[T] " + msg;
pike.git/src/testsuite.in:4925:
#endif return 1; ]], 1); test_do([[ object l = _disable_threads(); Thread.thread_create (lambda () {}); destruct (l); ]])
-
]])
+
-
cond([[all_constants()->thread_create]],
-
[[
+
test_any([[ int run = 1; mapping(string:int) rounds = ([]); void imutex_locker (string id) { while (run) { #ifdef __NT__ // Windows got an imutex in create_process. It doesn't have to
pike.git/src/testsuite.in:4998:
// This span is currently very generous, since the time slicing in // threads.c:check_threads can be flaky on some systems. if (minimum * 100 < maximum) { werror ("Too uneven distribution between threads: %O\n", rounds); return 0; } #endif return 1; ]], 1)
-
]])
+
-
+
cond_end // thread_create
+
cond([[0]], [[ test_any([[ // test if read() hangs when fd is closed by other thread object f=Stdio.File(); object g=f->pipe(); object t=thread_create( lambda() { g->read(4);
pike.git/src/testsuite.in:6708:
// 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]])
-
cond([[ sizeof( cpp("__AUTO_BIGNUM__")/"__AUTO_BIGNUM__" ) == 1 ]]
,
-
[[
+
cond
_begin
([[ 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) ]]) test_eq("9223372036854775808", [[ (string)0x8000000000000000 ]]) test_eq("9223372036854775809", [[ (string)0x8000000000000001 ]]) test_eq("-9223372036854775808", [[ (string)-0x8000000000000000 ]])
pike.git/src/testsuite.in:6739:
test_eq("1125899906842624", [[ (string)0b100000000000000000000000000000000000000000000000000 ]]) test_eq("-1125899906842624", [[ (string)-0b100000000000000000000000000000000000000000000000000 ]]) test_eq(500000000 * 10, 5000000000) test_eq(5000000000000000000 * 10, 50000000000000000000) // Numbers that shouldn't be native integers. Has to resort to // strange methods to test this since bignums behave like native // integers in almost every way. test_do([[ _next ((mixed) Int.NATIVE_MAX + 1) ]]) test_do([[ _next ((mixed) Int.NATIVE_MIN - 1) ]])
-
]])
+
-
+
cond_end // __AUTO_BIGNUM__
+
// 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) ]])
-
cond([[ sizeof( cpp("__AUTO_BIGNUM__")/"__AUTO_BIGNUM__" ) == 1 ]]
,
-
[[
+
cond
_begin
([[ sizeof( cpp("__AUTO_BIGNUM__")/"__AUTO_BIGNUM__" ) == 1 ]]
)
+
// 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",
pike.git/src/testsuite.in:6803:
test_eq("-9223372036854775809", [[ (string)(class { int x=-0x8000000000000000;int f() { --x;return x; } })()->f()]]) test_eq("-9223372036854775809", [[ (string)(class { int x=-0x8000000000000000;int f() { x--;return x; } })()->f()]]) test_eq("-9223372036854775809", [[ (string)(class { int f() { int x=-0x8000000000000000;--x;return x; } })()->f()]]) test_eq("-9223372036854775809", [[ (string)(class { int f() { int x=-0x8000000000000000;x--;return x; } })()->f()]]) test_encode(1<<99);
-
]])
+
-
cond([[ sizeof( cpp("__AUTO_BIGNUM__")/"__AUTO_BIGNUM__" ) == 1 ]],
-
[[
+
// - Left shift. test_eq("1073741824", [[ (string)(1<<30) ]]) test_eq("2147483648", [[ (string)(1<<31) ]]) test_eq("4294967296", [[ (string)(1<<32) ]]) test_eq("8589934592", [[ (string)(1<<33) ]]) test_eq("1267650600228229401496703205376", [[ (string)(1<<100) ]]) test_eval_error(return 1<<100000000000000000000) test_eval_error(return (-1)<<100000000000000000000) test_eq(0<<100000000000000000000, 0)
pike.git/src/testsuite.in:6844:
// - abs. test_eq("2147483648", [[ (string)abs(-0x80000000) ]]) test_eq("2147483648", [[ (string)abs(0x80000000) ]]) test_eq("2147483649", [[ (string)abs(0x80000001) ]]) test_eq("2147483649", [[ (string)abs(-0x80000001) ]]) test_eq("9223372036854775808", [[ (string)abs(-0x8000000000000000) ]]) test_eq("9223372036854775808", [[ (string)abs(0x8000000000000000) ]]) test_eq("9223372036854775809", [[ (string)abs(0x8000000000000001) ]]) test_eq("9223372036854775809", [[ (string)abs(-0x8000000000000001) ]])
-
]])
+
-
cond([[ sizeof( cpp("__AUTO_BIGNUM__")/"__AUTO_BIGNUM__" ) == 1 ]],
-
[[
+
// - Add. test_eq("2147483648", [[ (string)(0x7fffffff + 1) ]]) test_eq("2147483649", [[ (string)(0x7fffffff + 2) ]]) test_eq("-2147483648", [[ (string)((-0x80000001) + 1) ]]) test_eq("9223372036854775808", [[ (string)(0x7fffffffffffffff + 1) ]]) test_eq("9223372036854775809", [[ (string)(0x7fffffffffffffff + 2) ]]) test_eq("-9223372036854775808", [[ (string)((-0x8000000000000001) + 1) ]]) test_eq("2684354560", [[ (string)(0x50000000 + 0x50000000) ]]) test_eq("-2684354560", [[ (string)((-0x50000000) + (-0x50000000)) ]]) test_false([[ objectp((-0x80000001) + 1) ]])
pike.git/src/testsuite.in:6886:
test_eq(-9223372036854775808*-1,9223372036854775808) // Division. test_eq("1073741824", [[ (string)((int)"2147483648" / 2) ]]) test_false([[ objectp((int)"2147483648" / 2) ]]) test_eq("13934998268672547360069539025", [[ (string)(48324683476346278246238462784624627348 / 3467864333) ]]) // sprintf (and the describe stuff in the master) test_do([[sprintf ("%O", 10->pow);]])
-
]])
+
-
cond([[ sizeof( cpp("__AUTO_BIGNUM__")/"__AUTO_BIGNUM__" ) == 1 ]],
-
[[
-
+
// - sscanf. 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", "%x")[0] ]]) test_eq("1375488932614371410344080", [[ (string)array_sscanf("0X123456789F01234567890", "%x")[0] ]]) test_eq("1375488932614371410344080",
pike.git/src/testsuite.in:6951:
test_equal([[ ({ 557239244978618154304871 }) ]], [[ array_sscanf("0x76000000000001234567", "%x") ]]) test_equal([[array_sscanf("foo \12345 bar <fie>","%[^<]")]], [[ ({"foo \12345 bar " }) ]]) test_equal(471100000000000000000000000000000000000000000000042, (int)(mixed)471100000000000000000000000000000000000000000000042) test_eq(6745697846498645967, [[ Gmp.mpz("6745697846498645967")->cast_to_int(); ]])
-
]])
+
-
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)) ]])
pike.git/src/testsuite.in:6997:
test_eq(-0x123456780, [[ decode_value(encode_value(-0x123456780)) ]]) test_eq(-0x1234567801, [[ decode_value(encode_value(-0x1234567801)) ]]) test_eq(-0x12345678012, [[ decode_value(encode_value(-0x12345678012)) ]]) test_eq(-0x123456780123, [[ decode_value(encode_value(-0x123456780123)) ]]) test_eq(-0x1234567801234, [[ decode_value(encode_value(-0x1234567801234))]]) test_eval_error([[ _next ((mixed) decode_value (encode_value (Int.NATIVE_MAX))) ]]) test_eval_error([[ _next ((mixed) decode_value (encode_value (Int.NATIVE_MIN))) ]]) test_do([[ _next ((mixed) decode_value (encode_value (Int.NATIVE_MAX + 1))) ]]) test_do([[ _next ((mixed) decode_value (encode_value (Int.NATIVE_MIN - 1))) ]])
-
]])
-
-
cond([[ sizeof( cpp("__AUTO_BIGNUM__")/"__AUTO_BIGNUM__" ) == 1 ]],
-
[[
+
test_eq(2147483648, -2147483648/-1) test_eq(2147483648, -2147483648*-1) test_true([[ random(0x7fffffff)+1 ]]) test_true([[ random(0x7ffffffff)+1 ]]) test_true([[ sqrt(0x7fffffff)+1 ]]) test_true([[ sqrt(0x7ffffffff)+1 ]]) test_true([[ catch { destruct((mixed)0x4783647824687234628462); } ]])
pike.git/src/testsuite.in:7030:
4711: 0x54325827a124*0x12348795482485425, 0x54325827124*0x1234879548a2485425: 1174, ]); set_weak_flag (m, 1); gc(); return set_weak_flag(m, 0); ]], [[ ([ 4711: 0x54325827a124*0x12348795482485425, 0x54325827124*0x1234879548a2485425: 1174, ]) ]])
-
]])
+
-
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)
pike.git/src/testsuite.in:7060:
test_eq([[2147483648^17 ]], 2147483665) test_eq([[2147483648&17 ]], 0) test_eq([[2147483648|17 ]], 2147483665) test_eq([[2147483648<<17]], 281474976710656) test_eq([[2147483648>>17]], 16384) test_true([[ floatp((1<<99)/3.14) ]]); test_true([[ floatp((1<<99)*3.14) ]]); test_true([[ floatp((1<<99)-3.14) ]]); test_true([[ floatp((1<<99)+3.14) ]]);
-
]])
+
-
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);
pike.git/src/testsuite.in:7096:
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);
pike.git/src/testsuite.in:7147:
cond( [[ master()->resolv("Gmp")->mpz ]], [[ 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)); ]] )
-
]])
+
-
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});
pike.git/src/testsuite.in:7193:
// 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);
-
]])
+
cond_end // __AUTO_BIGNUM__
cond([[all_constants()->_verify_internals]], [[ test_do(_verify_internals()) ]]) test_eq("\377"[0],255) test_do(add_constant("foo",class c {int i;}())) test_eq(foo->i,0) test_do(foo->i=17)
pike.git/src/testsuite.in:9830:
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])) test_equal(17+class{mixed ``+(mixed n){return (<n>);}}(),(<17>)) cond([[ sizeof( cpp("__AUTO_BIGNUM__")/"__AUTO_BIGNUM__" ) == 1 ]], [[ test_equal(1700000000000000000000+class{mixed ``+(mixed n){return (<n>);}}(),(<1700000000000000000000>))
-
cond( [[ master()->resolv("Gmp")->mpz ]],
+
]])
+
+
cond( [[
sizeof( cpp("__AUTO_BIGNUM__")/"__AUTO_BIGNUM__" ) == 1 &&
master()->resolv("Gmp")->mpz ]],
[[ test_eval_error(Gmp.mpz(1700000000000000000000)+class{mixed ``+(mixed n){return (<n>);}}()) ]])
-
]])
+
// - `- // - `-> // - `->= // - `/ // - `< // - `<< // - `<= // - `== // - `>
pike.git/src/testsuite.in:10060:
// - combine_path_unix test_eq([[combine_path_unix("/","/fo\1111/bar/gazonk/../../")]],"/fo\1111/") // - compile // - compile_file // - compile_string // see test for clone()
-
cond([[all_constants()->thread_create]]
,
-
[[
+
cond
_begin
([[all_constants()->thread_create]]
)
+
test_any([[ string file = #" /* * Attempt to trig the lex.current_file == NULL bug. * * Henrik Grubbström 1999-07-01 */ string file = Stdio.File(__FILE__, \"r\")->read();
pike.git/src/testsuite.in:10108:
// watchdog kicks in.. /mast //if (!(i%10)) // __signal_watchdog(); //if (!(i % 100)) // write ("%s: %O at %d\n", ctime (time())[..<1], this_thread(), i); } } )->wait(); return 0; ]], 0)
-
]])
+
-
+
cond_end // thread_create
+
// - 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) test_eq(copy_value(typeof(true)),typeof(true)) 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)