C++Script: test_types.cpp Source File

00001 // Copyright (C) Calum Grant 2008
00002 
00003 #include <cppscript>
00004 #include "unit_tests.hpp"
00005 #include <sstream>
00006 
00007 
00008 void test_default_container(var v)
00009 {
00010         assert_throws( not_supported, var x = v[12] );
00011         assert_throws( not_supported, v[12] = 12 );
00012         assert( !v.contains(123) );
00013         assert( v.size() == 0 );
00014         assert( v.empty() );
00015         assert( v.begin() == v.end() );
00016         assert( v.rbegin() == v.rend() );
00017         assert_throws( not_supported, v.resize(1) );
00018         assert( v.keys() == var() );
00019         assert( v.values() == var() );
00020         assert_throws( not_supported, v.push_back(1) );
00021         assert_throws( not_supported, v.push_front(1) );
00022         assert_throws( not_supported, v.back() );
00023         assert_throws( not_supported, v.front() );
00024         assert_throws( not_supported, v.clear() );
00025         v.erase(0);
00026         assert_throws( not_supported, v.mixin(var()) );
00027         assert( !v.enumerator() );
00028         assert( !v.reverse_enumerator() );
00029 
00030         assert_throws( not_supported, v.impl().member_inc("") );
00031         assert_throws( not_supported, v.impl().member_inc("", 0) );
00032         assert_throws( not_supported, v.impl().member_dec("") );
00033         assert_throws( not_supported, v.impl().member_dec("", 0) );
00034 
00035         assert_throws( not_supported, v.impl().member_add("", 1) );
00036         assert_throws( not_supported, v.impl().member_sub("", 1) );
00037 
00038         assert_throws( not_supported, v.impl().member_call("") );
00039 
00040         v.impl().reserve(10);
00041         assert( v.impl().capacity() == 0 );
00042 }
00043 
00044 
00045 void test_default_iterator(var v)
00046 {
00047         assert_throws( not_supported, *v );
00048         assert_throws( not_supported, v.key() );
00049         assert_throws( not_supported, v.value() );
00050         assert_throws( not_supported, ++v );
00051         assert_throws( not_supported, --v );
00052         assert_throws( not_supported, v++ );
00053         assert_throws( not_supported, v-- );
00054 }
00055 
00056 
00057 void test_default_assignment(var v)
00058 {
00059         assert_throws( not_supported, v+=4 );
00060         assert_throws( not_supported, v-=4 );
00061         assert_throws( not_supported, v*=4 );
00062         assert_throws( not_supported, v/=4 );
00063         assert_throws( not_supported, v%=4 );
00064         assert_throws( not_supported, v<<=4 );
00065         assert_throws( not_supported, v>>=4 );
00066         assert_throws( not_supported, v&=4 );
00067         assert_throws( not_supported, v|=4 );
00068         assert_throws( not_supported, v^=4 );
00069 }
00070 
00071 
00072 void test_default_operators(var str)
00073 {
00074         assert_throws( not_supported, str+1 );
00075         assert_throws( not_supported, str-1 );
00076         assert_throws( not_supported, str*1 );
00077         assert_throws( not_supported, str/1 );
00078         assert_throws( not_supported, str%1 );
00079         assert_throws( not_supported, -str );
00080         assert_throws( not_supported, str<<1 );
00081         assert_throws( not_supported, str>>1 );
00082         assert_throws( not_supported, str&1 );
00083         assert_throws( not_supported, str|1 );
00084         assert_throws( not_supported, str^1 );
00085         assert_throws( not_supported, ~str );
00086 }
00087 
00088 
00089 void test_null()
00090 {
00091         // Basics
00092         assert( !var().impl().shared_var() );
00093         assert( null == var() );
00094         assert( var() != 3 );
00095         assert( var() < false );
00096         assert( !(var()<var()) );
00097         assert( var().clone() == var() );
00098         assert( +var() == var() );
00099         assert( var() == unpickle(pickle(var())) );
00100         assert( var().class_name() == "null" );
00101         assert( var().impl().comparison_index() == cmp_null );
00102         assert_throws( not_supported, null() );
00103         assert( null.max_args() == -1 );
00104 
00105         std::pair<std::size_t, std::size_t> r;
00106         assert_not_supported( null.impl().get_range(10,r) );
00107 
00108         assert( null.proxy().as_string() == "null" );
00109 
00110         // Conversions
00111         assert( var().as_int() == 0 );
00112         assert( var().as_double() == 0.0 );
00113         assert( var().as_string() == "null" );
00114         assert( var().as_wstring() == L"null" );
00115         assert( !var().as_bool() );
00116         assert( !var() );
00117         assert( !var().impl().as_ptr() );
00118 
00119         // Container
00120         test_default_container( var() );
00121 
00122         // Iterator
00123         test_default_iterator( var() );
00124 
00125         // Operators
00126         assert( var() + 1 == 1 );
00127         assert( var() - 1 == -1 );
00128         assert( var() * 12 == var() );
00129         assert( var() / 12 == var() );
00130         assert( -var() == var() );
00131         assert( var() % 12 == var() );
00132         assert( var() << 12 == var() );
00133         assertx( var() >> 2 == var());
00134         assert( var() | 4 == 4 );
00135         assert( (var() & 2) == var() );
00136         assert( var() ^ 3 == 3 );
00137         assert_throws( not_supported, ~var() );
00138 
00139         // Assignment
00140         test_default_assignment( var() );
00141 }
00142 
00143 
00144 void test_bool()
00145 {
00146         // Construction
00147         var t=true, f=false;
00148         assert( var(true) == true );
00149         assert( var(false) == false );
00150 
00151         // Basics
00152         assert( !t.impl().shared_var() );
00153         assert( t.class_name() == "bool" );
00154         assert( f < t );
00155         assert( t < 1 );
00156         assert( t != 2 );
00157         assert( f != 0 );
00158         assert( t == +t );
00159         assert( f == +f );
00160         assert_throws( not_supported, t() );
00161         assert( t.max_args() == -1 );
00162         assert( t == unpickle(pickle(t)) );
00163         assert( f == unpickle(pickle(f)) );
00164         assert( f.impl().comparison_index() == cmp_false );
00165         assert( t.impl().comparison_index() == cmp_true );
00166 
00167         // Conversions
00168         assert( var(true) );
00169         assert( !var(false) );
00170         assert( t.as_int() == 1 );
00171         assert( f.as_int() == 0 );
00172         assert( t.as_double() == 1.0 );
00173         assert( f.as_double() == 0.0 );
00174         assert( t.as_string() == "true" );
00175         assert( f.as_string() == "false" );
00176         assert( t.as_wstring() == L"true" );
00177         assert( f.as_wstring() == L"false" );
00178         assert( !t.impl().as_ptr() );
00179 
00180         test_default_container( true );
00181         test_default_container( false );
00182         test_default_iterator( true );
00183         test_default_assignment( true );
00184 
00185         // Operators
00186         assert( t == t+f );
00187         assert_throws( not_supported, t-f );
00188         assert( f == t*f );
00189         assert_throws( not_supported, f/t );
00190         assert_throws( not_supported, f%t );
00191         assert_throws( not_supported, -t );
00192         assert_throws( not_supported, t<<1 );
00193         assert_throws( not_supported, t>>1 );
00194         assert( t|f );
00195         assert( !(f|f) );
00196         assert( t&t );
00197         assert( !(f&t) );
00198         assert( t^f );
00199         assert( !(t^t) );
00200         assert( !(f^f) );
00201         assert( ~f );
00202         assert( !~t );
00203 }
00204 
00205 
00206 void test_ch()
00207 {
00208         // Constructor
00209         var c = 'a';
00210         var w = L'a';
00211         assert( var('a') == 'a' );
00212         assert( var(L'b') == L'b' );
00213 
00214         // Basics
00215         assert( c.class_name() == "char" );
00216         assert( w.class_name() == "char" );
00217         assert( c == +c );
00218         assert( w == +w );
00219         assert( unpickle(pickle(w)) == w );
00220         assert( unpickle(pickle(c)) == c );
00221         assert( unpickle(pickle(c)).as_string() == "a" );
00222         assert( c.max_args() == -1 );
00223         assert( w.max_args() == -1 );
00224         assert_throws( not_supported, c() );
00225         assert_throws( not_supported, w() );
00226         assert( c.impl().comparison_index() == cmp_char );
00227         assert( w.impl().comparison_index() == cmp_wchar );
00228 
00229         // Comparison
00230         assert( c == 'a' );
00231         assert( w == L'a' );
00232         assert( c < w );
00233         assert( c == c );
00234         assert( w == w );
00235         assert( w < L'b' );
00236         assert( c < 'c' );
00237         assert( var(char(020)) == '\020' );
00238         assert( var('a') < var('b') );
00239 
00240         // Conversion
00241         assert( c.as_int() == 'a' );
00242         assert( w.as_int() == L'a' );
00243         assert( c.as_string() == "a" );
00244         assert( w.as_wstring() == L"a" );
00245         assert( c.as_double() == 'a' );
00246         assert( w.as_double() == 'a' );
00247         assert( c );
00248         assert( !var('\0') );
00249         assert( !c.impl().as_ptr() );
00250 
00251         // Container
00252         test_default_container( c );
00253         test_default_container( w );
00254 
00255         // Iterator
00256         assert_throws( not_supported, c.key() );
00257         assert_throws( not_supported, c.value() );
00258         assert_throws( not_supported, *c );
00259 
00260         assert( ++c == 'b' );
00261         assert( --c == 'a' );
00262 
00263         // Operators
00264         assert( (c+3).class_name() == "char" );
00265         assert( (c+3).as_string() == "d" );
00266         assert( (var('z')-2).as_string() == "x" );
00267         assert( -c == -'a' );
00268         assert( c*2 == 'a'*2 );
00269         assert( c/2 == 'a'/2 );
00270         assert( c%2 == 'a'%2 );
00271         assert( c>>1 == 'a'>>1 );
00272         assert( c<<1 == 'a'<<1 );
00273         assert( (c&15) == ('a'&15) );
00274         assert( (c|15) == ('a'|15) );
00275         assert( (c^15) == ('a'^15) );
00276         assert( ~c == ~'a' );
00277 
00278         // Assignment
00279         c+=2; assert( c == 'c' );
00280         c-=2; assert( c == 'a' );
00281         c*=3; assert( c.as_int() == 'a'*3 );
00282         c/=3; assert( c == 'a' );
00283         c %= 'a'; assert( c == '\0' );
00284         c = 'a'; c<<=1; assert( c.as_int() == 'a'<<1 );
00285         c>>=1; assert( c == 'a' );
00286         c&=123; assert( c.as_int() == ('a' & 123) );
00287         c='a'; c|=12; assert( c.as_int() == ('a'|12) );
00288         c='a'; c^=15; assert( c.as_int() == ('a'^15) );
00289 }
00290 
00291 
00292 void test_int()
00293 {
00294         // Construction
00295         assert( var(12) == 12 );
00296 
00297         // Basics
00298         assert( !var(5).impl().shared_var() );
00299         assert( var(5).class_name() == "int" );
00300         assert( +var(1) == 1 );
00301         assert_throws( not_supported, var(1)() );
00302         assert( unpickle(pickle(4)) == 4 );
00303         assert( unpickle(pickle(-3)) == -3 );
00304         var tmp = object();
00305         tmp["x"] = var(1);
00306         assert( tmp["x"] == 1 );
00307         assert( var(12).max_args() == -1 );
00308         assert_throws( not_supported, var(12)() );
00309 
00310         // Comparison
00311         assert( var(1).impl().comparison_index() == cmp_int );
00312         assert( var(5) < 6 );
00313         assert( var(true) < var(0) );
00314         assert( var(1) != 2 );
00315         assert( var(1) <= 2 );
00316         assert( var(1) < 2 );
00317         assert( var(2) > 1 );
00318         assert( var(2) >= 1 );
00319         assert( var(1) <= 1 );
00320         assert( var(1) >= 1 );
00321 
00322         // Conversions
00323         assert( var(12).as_string() == "12" );
00324         assert( var(-2).as_string() == "-2" );
00325         assert( var(12).as_wstring() == L"12" );
00326         assert( var(-2).as_wstring() == L"-2" );
00327         assert( var(2).as_double() == 2.0 );
00328         assert( var(1) );
00329         assert( !var(0) );
00330         assert( !var(1).impl().as_ptr() );
00331 
00332         test_default_container( 1 );
00333 
00334         assert_throws( not_supported, *var(1) );
00335         assert_throws( not_supported, var(1).key() );
00336         assert_throws( not_supported, var(1).value() );
00337 
00338         // Operators
00339         assert( var(12) + 4 == 16 );
00340         assert( var(12) + "1" == 13 );
00341         assert( var(10) - 3 == 7 );
00342         assert( var(10) * 2 == 20 );
00343         assert( var(10) / 5 == 2 );
00344         assert( var(10) % 3 == 1 );
00345 
00346         // The ++ operator increments
00347         var i=5;
00348         assert( ++i == 6 );
00349 
00350         // The -- operator decrements
00351         assert( --i == 5 );
00352         
00353         // Postincrement & postdecrement
00354         assert( i++ == 5 && i == 6 );
00355         assert( i-- == 6 && i == 5 );
00356 
00357         // The bitwise operators: | & ^ ~
00358         assert( var(1)|2==3 );
00359         assert( var(3)&2==2 );
00360         assert( var(3)^1 == 2 );
00361         assert( ~var(1)==~1 );
00362 
00363         // The shift operators
00364         assert( var(1) << "2" == 4 );
00365         assert( var(4) >> 1 == 2 );
00366 
00367         // The unary operators
00368         assert( +var(1) == 1 );
00369         assert( -var(2) == -2 );
00370 
00371         // Assignment operators += -= *= /= %= >>= <<= |= ||= &= &&= 
00372         var x=0;
00373         assert( (x+=2) == 2 );
00374         assert( (x-=1) == 1 );
00375         assert( (x*=6) == 6 );
00376         assert( (x/=3) == 2 );
00377         assert( (x%=2) == 0 );
00378         x+=1;
00379         x<<=10;
00380         assert( x == 1024 );
00381         x>>=9;
00382         assert( x == 2 );
00383         x|=1;
00384         assert( x == 3 );
00385         x&=2;
00386         assert( x == 2 );
00387 }
00388 
00389 
00390 void test_double()
00391 {
00392         // Construction
00393         var x = 0.5;
00394         var y = 1.0;
00395 
00396         // Basics
00397         assert( x.class_name() == "double" );
00398         assert( x.impl().comparison_index() == cmp_double );
00399         assert( x == +x );
00400         assert( unpickle(pickle(x)) == x );
00401         assert_throws( not_supported, x() );
00402         assert( x.max_args() == -1 );
00403         
00404         // Comparison
00405         assert( x < 1.0 );
00406         assert( x > 0.25 );
00407         assert( x > 12 );
00408 
00409         // Conversion
00410         assert( y.as_int() == 1 );
00411         assert( x.as_string() == "0.5" );
00412         assert( x.as_double() == 0.5 );
00413         assert( x );
00414         assert( !var(0.0).as_bool() );
00415 
00416         test_default_container( x );
00417 
00418         // Iterator
00419         assert_throws( not_supported, x.key() );
00420         assert_throws( not_supported, x.value() );
00421         assert_throws( not_supported, *x );
00422 
00423         assert( x+0.5 == 1.0 );
00424         assert( x+"0.5" == 1.0 );
00425         assert( x - 1 == -0.5 );
00426         assert( x - "1" == -0.5 );
00427         assert( x * "0.5" == 0.25 );
00428         assert( x / "0.5" == 1.0 );
00429         assert_throws( not_supported, x % 1 );
00430         assert_throws( not_supported, x >> 1 );
00431         assert_throws( not_supported, x << 1 );
00432         assert_throws( not_supported, x & 1 );
00433         assert_throws( not_supported, x | 1 );
00434         assert_throws( not_supported, x ^ 1 );
00435         assert_throws( not_supported, ~x );
00436 
00437         assert( ++x == 1.5 );
00438         assert( --x == 0.5 );
00439         assert( +var(2.0) == 2.0 );
00440         assert( -var(2.0) == -2.0 );
00441 
00442         var d = 1.0;
00443         d+=1;
00444         assert( d == 2.0 );
00445         d-=1;
00446         assert( d == 1.0 );
00447         d*=6;
00448         assert( d == 6.0 );
00449         d/=2;
00450         assert( d == 3.0 );
00451         
00452         assert_throws( not_supported, x %= 2 );
00453         assert_throws( not_supported, x <<= 2 );
00454         assert_throws( not_supported, x >>= 2 );
00455         assert_throws( not_supported, x &= 2 );
00456         assert_throws( not_supported, x |= 2 );
00457         assert_throws( not_supported, x ^= 2 );
00458 }
00459 
00460 
00461 void test_string()
00462 {
00463         // Comparison
00464         assert( var() == var() );
00465         assert( var() < 12 );
00466 
00467         // A string is created by assigning a char* to it
00468         var i = "abc";
00469 
00470         // The original string can be extracted using var::as_string() method
00471         assert( i.as_string() == "abc" );
00472 
00473         // This also works for std::string
00474         var j = std::string("def");
00475         assert( j.as_string() == "def");
00476 
00477         // A wide pointer will create a wide string
00478         var k = L"abc";
00479         assert( k.as_wstring() == L"abc" );
00480 
00481         // The function create_string() also creates a string.
00482         assert( internal::create_string("123") == "123" );
00483 
00484         // Assignment to string
00485         var s;
00486         s = "123";
00487         assert( s == "123" );
00488 
00489         // You can also convert wide strings to narrow strings implicitly,
00490         // though you are better off just sticking to one string type.
00491         assert( k.as_string() == "abc" );
00492         assert( k != i );
00493         assert( i != k );
00494 
00495         // The + operator concatenates two strings
00496         assert( var("ab") + "cd" == "abcd" );
00497 
00498         // The * operator repeats a string
00499         assert( var("abc") * 0 == "" );
00500         assert( var("abc") * 2 == "abcabc" );
00501 
00502         // Comparison performs a lexographical, case sensitive compare
00503         assert( var("abc") < "def" );
00504         assert( var("") < i );
00505 
00506         // An empty string is false
00507         assert( !var("") );
00508 
00509         // A non-empty string is true
00510         assert( var("abc") );
00511 
00512         // Conversion to an int parses the number
00513         assert( var("abc").as_int() == 0 );
00514         assert( var(L"2").as_int() == 2 );
00515 
00516         // Conversion to a double parses it
00517         assert( var("0.5").as_double() == 0.5 );
00518         assert( var("bbc").as_double() == 0.0 );
00519 
00520         // resize
00521         var abcd("abcd");
00522         abcd.resize(2);
00523         assert( abcd == "ab" );
00524         abcd.resize(4);
00525         assert( abcd == "ab  " );
00526 
00527         // +=
00528         assert( (abcd += "xy") == "ab  xy" );
00529 
00530         // Clone
00531         var s1="hello", s2= +s1;
00532         s1[0] = 'x';
00533         assert(s2 == "hello");
00534 }