def test_objectpattern_assignment(): 'Tests that ObjectPatterns are respected' results = _do_test_raw(""" var foo = {a:3,b:4,c:5}; var {a:x, b:y, c:z} = foo; """) assert not results.failed() assert _get_var(results, 'x') == 3 assert _get_var(results, 'y') == 4 assert _get_var(results, 'z') == 5 results = _do_test_raw(""" var foo = { a:1, b:2, c:{ d:4 } }; var {a:x, c:{d:y}} = foo; """) assert not results.failed() assert _get_var(results, 'x') == 1 assert _get_var(results, 'y') == 4
def test_objectpattern_assignment(): "Tests that ObjectPatterns are respected" results = _do_test_raw( """ var foo = {a:3,b:4,c:5}; var {a:x, b:y, c:z} = foo; """ ) assert not results.failed() assert _get_var(results, "x") == 3 assert _get_var(results, "y") == 4 assert _get_var(results, "z") == 5 results = _do_test_raw( """ var foo = { a:1, b:2, c:{ d:4 } }; var {a:x, c:{d:y}} = foo; """ ) assert not results.failed() assert _get_var(results, "x") == 1 assert _get_var(results, "y") == 4
def test_typecasting(): 'Tests that strings are treated as numbers when necessary' err = _do_test('tests/resources/javascript/strings_typecasting.js') assert err.message_count == 0 assert _get_var(err, 'x') == '44' assert _get_var(err, 'y') == 16
def test_typecasting(): "Tests that strings are treated as numbers when necessary" err = _do_test("tests/resources/javascript/strings_typecasting.js") assert err.message_count == 0 assert _get_var(err, "x") == "44" assert _get_var(err, "y") == 16
def test_arraypattern_assignment(): "Tests that array patterns can be used to assign variables" results = _do_test_raw(""" var [x, y, z] = [1, 2, 3]; """) assert not results.failed() assert _get_var(results, "x") == 1 assert _get_var(results, "y") == 2 assert _get_var(results, "z") == 3
def test_arraypattern_assignment(): 'Tests that array patterns can be used to assign variables' results = _do_test_raw(""" var [x, y, z] = [1, 2, 3]; """) assert not results.failed() assert _get_var(results, 'x') == 1 assert _get_var(results, 'y') == 2 assert _get_var(results, 'z') == 3
def test_property_members(): "Tests that properties and members are treated fairly" results = _do_test_raw(""" var x = {"foo":"bar"}; var y = x.foo; var z = x["foo"]; """) assert _get_var(results, "y") == "bar" assert _get_var(results, "z") == "bar"
def test_multiple_assignments(): 'Tests that multiple variables can be assigned in one sitting' results = _do_test_raw(""" var x = 1, y = 2, z = 3; """) assert not results.failed() assert _get_var(results, 'x') == 1 assert _get_var(results, 'y') == 2 assert _get_var(results, 'z') == 3
def test_multiple_assignments(): "Tests that multiple variables can be assigned in one sitting" results = _do_test_raw(""" var x = 1, y = 2, z = 3; """) assert not results.failed() assert _get_var(results, "x") == 1 assert _get_var(results, "y") == 2 assert _get_var(results, "z") == 3
def test_typecasting(): """Test that types are properly casted.""" scope = _do_test_raw(""" var a = 1 == '1', b = 255 == '0xff', c = 0 == '\\r'; """) assert _get_var(scope, 'a') is True assert _get_var(scope, 'b') is True assert _get_var(scope, 'c') is True
def test_typecasting(): """Test that types are properly casted.""" scope = _do_test_raw(""" var a = 1 == '1', b = 255 == '0xff', c = 0 == '\\r'; """) eq_(_get_var(scope, "a"), True) eq_(_get_var(scope, "b"), True) eq_(_get_var(scope, "c"), True)
def test_equality_type_coercion(): """Test that types are properly coerced in equality operations.""" scope = _do_test_raw(""" var a = 1 == '1', b = 255 == '0xff', c = 0 == '\\r'; """) eq_(_get_var(scope, 'a'), True) eq_(_get_var(scope, 'b'), True) eq_(_get_var(scope, 'c'), True)
def test_lazy_object_member_assgt(): """ Test that members of lazy objects can be assigned, even if the lazy object hasn't yet been created. """ results = _do_test_raw(""" foo.bar = "asdf"; zap.fizz.buzz = 123; var a = foo.bar, b = zap.fizz.buzz; """) assert not results.failed() eq_(_get_var(results, 'a'), 'asdf') eq_(_get_var(results, 'b'), 123)
def test_addition_expressions(): """Test that varying types are added correctly.""" scope = _do_test_raw(""" var a = true + false, b = Boolean(true) + Boolean(false); var x = 100, y = -1; var c = x + y, d = Number(x) + Number(y); """) eq_(_get_var(scope, "a"), 1) eq_(_get_var(scope, "b"), 1) eq_(_get_var(scope, "c"), 99) eq_(_get_var(scope, "d"), 99)
def test_addition_expressions(): """Test that varying types are added correctly.""" scope = _do_test_raw(""" var a = true + false, b = Boolean(true) + Boolean(false); var x = 100, y = -1; var c = x + y, d = Number(x) + Number(y); """) assert _get_var(scope, 'a') == 1 assert _get_var(scope, 'b') == 1 assert _get_var(scope, 'c') == 99 assert _get_var(scope, 'd') == 99
def test_unicode_escapes(): """Tests that unicode/hex escapes are passed through to Spidermonkey.""" result = _do_test_raw("var foo = '\\u263a\\u0027\\x27'") assert not result.failed() eq_(_get_var(result, "foo"), u"\u263a''")
def test_basic_concatenation(): 'Tests that contexts work and that basic concat ops are executed properly' err = _do_test('tests/resources/javascript/basicstrings.js') assert err.message_count == 0 assert _get_var(err, 'x') == 'foo' assert _get_var(err, 'y') == 'bar' assert _get_var(err, 'z') == 'foobar' assert _get_var(err, 'a') == '5' assert _get_var(err, 'b') == '6' assert _get_var(err, 'c') == '56' assert _get_var(err, 'd') == 1 assert _get_var(err, 'e') == 30 assert _get_var(err, 'f') == 5
def test_basic_concatenation(): "Tests that contexts work and that basic concat ops are executed properly" err = _do_test("tests/resources/javascript/basicstrings.js") assert err.message_count == 0 assert _get_var(err, "x") == "foo" assert _get_var(err, "y") == "bar" assert _get_var(err, "z") == "foobar" assert _get_var(err, "a") == "5" assert _get_var(err, "b") == "6" assert _get_var(err, "c") == "56" assert _get_var(err, "d") == 1 assert _get_var(err, "e") == 30 assert _get_var(err, "f") == 5
def test_augconcat(): "Tests augmented concatenation operators" err = _do_test_raw(""" var x = "foo"; x += "bar"; """) assert not err.message_count print _get_var(err, "x") assert _get_var(err, "x") == "foobar" err = _do_test_raw(""" var x = {"xyz":"foo"}; x["xyz"] += "bar"; """) assert not err.message_count xyz_val = err.final_context.data["x"].get(None, "xyz").get_literal_value() print xyz_val assert xyz_val == "foobar"
def test_max_str_size_binop(): """Test that the max string size is enforced for binary operators.""" # Create a string and max out its size. err = _do_test_raw(""" var x = "%s"; x = x + x; x = x + x; """ % ("x" * (MAX_STR_SIZE / 2))) eq_(len(_get_var(err, "x")), MAX_STR_SIZE)
def test_max_str_size_aug_assig(): """Test that the max string size is enforced for augmented assignment.""" # Create a string and max out its size. err = _do_test_raw(""" var x = "%s"; x += x; x += x; """ % ("x" * (MAX_STR_SIZE / 2))) eq_(len(_get_var(err, "x")), MAX_STR_SIZE)
def test_number_global_conversions(): """Test that the Number global constructor functions properly.""" err = _do_test_raw(""" var a = Number(), b = Number(123), c = Number(123.123), d = Number("123"), e = Number("123.456"), f = Number("foo"), g = Number(null), nan = window.NaN; """) assert not err.failed() eq_(_get_var(err, 'a'), 0) eq_(_get_var(err, 'b'), 123) eq_(_get_var(err, 'c'), 123.123) eq_(_get_var(err, 'd'), 123) eq_(_get_var(err, 'e'), 123.456) eq_(_get_var(err, 'f'), _get_var(err, 'nan')) eq_(_get_var(err, 'g'), _get_var(err, 'nan'))
def test_number_global_conversions(): """Test that the Number global constructor functions properly.""" err = _do_test_raw(""" var a = Number(), b = Number(123), c = Number(123.123), d = Number("123"), e = Number("123.456"), f = Number("foo"), g = Number(null), nan = window.NaN; """) assert not err.failed() eq_(_get_var(err, "a"), 0) eq_(_get_var(err, "b"), 123) eq_(_get_var(err, "c"), 123.123) eq_(_get_var(err, "d"), 123) eq_(_get_var(err, "e"), 123.456) eq_(_get_var(err, "f"), _get_var(err, "nan")) eq_(_get_var(err, "g"), _get_var(err, "nan"))
def test_basic_math(): "Tests that contexts work and that basic math is executed properly" err = _do_test_raw(""" var x = 1; var y = 2; var z = x + y; var dbz = 1; var dbz1 = 1; dbz = dbz / 0; dbz1 = dbz1 % 0; var dbz2 = 1; var dbz3 = 1; dbz2 /= 0; dbz3 %= 0; var a = 2 + 3; var b = a - 1; var c = b * 2; """) assert err.message_count == 0 assert _get_var(err, "x") == 1 assert _get_var(err, "y") == 2 assert _get_var(err, "z") == 3 assert _get_var(err, "dbz") == 0 # Spidermonkey does this. assert _get_var(err, "dbz1") == 0 # ...and this. assert _get_var(err, "dbz2") == 0 assert _get_var(err, "dbz3") == 0 assert _get_var(err, "a") == 5 assert _get_var(err, "b") == 4 assert _get_var(err, "c") == 8
def test_basic_math(): 'Tests that contexts work and that basic math is executed properly' err = _do_test_raw(""" var x = 1; var y = 2; var z = x + y; var dbz = 1; var dbz1 = 1; dbz = dbz / 0; dbz1 = dbz1 % 0; var dbz2 = 1; var dbz3 = 1; dbz2 /= 0; dbz3 %= 0; var a = 2 + 3; var b = a - 1; var c = b * 2; """) assert err.message_count == 0 assert _get_var(err, 'x') == 1 assert _get_var(err, 'y') == 2 assert _get_var(err, 'z') == 3 assert _get_var(err, 'dbz') == 0 # Spidermonkey does this. assert _get_var(err, 'dbz1') == 0 # ...and this. assert _get_var(err, 'dbz2') == 0 assert _get_var(err, 'dbz3') == 0 assert _get_var(err, 'a') == 5 assert _get_var(err, 'b') == 4 assert _get_var(err, 'c') == 8
def test_with_statement(): "Tests that 'with' statements work as intended" err = _do_test_raw(""" var x = {"foo":"bar"}; with(x) { foo = "zap"; } var z = x["foo"]; """) assert not err.failed() print _get_var(err, "z") assert _get_var(err, "z") == "zap" # Assert that the contets of a with statement are still evaluated even # if the context object is not available. err = _do_test_raw(""" with(foo.bar) { // These do not exist yet eval("evil"); } """) assert err.failed()
def test_augconcat(): 'Tests augmented concatenation operators' err = _do_test_raw(""" var x = "foo"; x += "bar"; """) assert not err.message_count eq_(_get_var(err, 'x'), 'foobar') err = _do_test_raw(""" var x = {"xyz":"foo"}; x["xyz"] += "bar"; """) assert not err.message_count xyz_val = err.final_context.data['x'].get('xyz').as_primitive() assert xyz_val == 'foobar'
def test_string_comparison(): """Test that strings are properly compared.""" scope = _do_test_raw(""" var a = "string" < "string", b = "astring" < "string", c = "strings" < "stringy", d = "strings" < "stringier", e = "string" < "astring", f = "string" < "strings"; """) eq_(_get_var(scope, "a"), False) eq_(_get_var(scope, "b"), True) eq_(_get_var(scope, "c"), True) eq_(_get_var(scope, "d"), False) eq_(_get_var(scope, "e"), False) eq_(_get_var(scope, "f"), True)
def test_string_comparison(): """Test that strings are properly compared.""" scope = _do_test_raw(""" var a = "string" < "string", b = "astring" < "string", c = "strings" < "stringy", d = "strings" < "stringier", e = "string" < "astring", f = "string" < "strings"; """) assert _get_var(scope, 'a') is False assert _get_var(scope, 'b') is True assert _get_var(scope, 'c') is True assert _get_var(scope, 'd') is False assert _get_var(scope, 'e') is False assert _get_var(scope, 'f') is True
def test_signed_zero(): """Test that signed zeroes are compared properly.""" scope = _do_test_raw(""" var a = 0 == 0, b = 0 != 0, c = 0 == -0, d = 0 != -0, e = -0 == 0, f = -0 != 0; """) assert _get_var(scope, 'a') is True assert _get_var(scope, 'b') is False assert _get_var(scope, 'c') is True assert _get_var(scope, 'd') is False assert _get_var(scope, 'e') is True assert _get_var(scope, 'f') is False
def test_signed_zero(): """Test that signed zeroes are compared properly.""" scope = _do_test_raw(""" var a = 0 == 0, b = 0 != 0, c = 0 == -0, d = 0 != -0, e = -0 == 0, f = -0 != 0; """) eq_(_get_var(scope, "a"), True) eq_(_get_var(scope, "b"), False) eq_(_get_var(scope, "c"), True) eq_(_get_var(scope, "d"), False) eq_(_get_var(scope, "e"), True) eq_(_get_var(scope, "f"), False)
def test_additive_typecasting(): """ Test than additive and multiplicative expressions are evaluated properly. """ scope = _do_test_raw(""" var first = true, second = "foo", third = 345; var a = first + second, b = second + first, c = Boolean(true) + String("foo"), d = String("foo") + Boolean(false), e = second + third, f = String("foo") + Number(-100); """) eq_(_get_var(scope, "a"), "truefoo") eq_(_get_var(scope, "b"), "footrue") eq_(_get_var(scope, "c"), "truefoo") eq_(_get_var(scope, "d"), "foofalse") eq_(_get_var(scope, "e"), "foo345") eq_(_get_var(scope, "f"), "foo-100")
def test_additive_typecasting(): """ Test than additive and multiplicative expressions are evaluated properly. """ scope = _do_test_raw(""" var first = true, second = "foo", third = 345; var a = first + second, b = second + first, c = Boolean(true) + String("foo"), d = String("foo") + Boolean(false), e = second + third, f = String("foo") + Number(-100); """) assert _get_var(scope, 'a') == 'truefoo' assert _get_var(scope, 'b') == 'footrue' assert _get_var(scope, 'c') == 'truefoo' assert _get_var(scope, 'd') == 'foofalse' assert _get_var(scope, 'e') == 'foo345' assert _get_var(scope, 'f') == 'foo-100'
def test_in_operator(): "Tests the 'in' operator." err = _do_test_raw(""" var list = ["a",1,2,3,"foo"]; var dict = {"abc":123, "foo":"bar"}; // Must be true var x = 0 in list; var y = "abc" in dict; // Must be false var a = 5 in list; var b = "asdf" in dict; """) assert err.message_count == 0 assert _get_var(err, "x") == True assert _get_var(err, "y") == True print _get_var(err, "a"), "<<<" assert _get_var(err, "a") == False assert _get_var(err, "b") == False
def test_logical_not(): """Test that logical not is evaluated properly.""" scope = _do_test_raw(""" var a = !(null), // b = !(var x), c = !(void 0), d = !(false), e = !(true), // f = !(), g = !(0), h = !(-0), // i = !(NaN), j = !(Infinity), k = !(-Infinity), l = !(Math.PI), m = !(1), n = !(-1), o = !(''), p = !('\\t'), q = !('0'), r = !('string'), s = !(new String('')); // This should cover all type globals. """) eq_(_get_var(scope, "a"), True) # eq_(_get_var(scope, "b"), True) eq_(_get_var(scope, "c"), True) eq_(_get_var(scope, "d"), True) eq_(_get_var(scope, "e"), False) # eq_(_get_var(scope, "f"), True) eq_(_get_var(scope, "g"), True) eq_(_get_var(scope, "h"), True) # eq_(_get_var(scope, "i"), True) eq_(_get_var(scope, "j"), False) eq_(_get_var(scope, "k"), False) eq_(_get_var(scope, "l"), False) eq_(_get_var(scope, "m"), False) eq_(_get_var(scope, "n"), False) eq_(_get_var(scope, "o"), True) eq_(_get_var(scope, "p"), False) eq_(_get_var(scope, "q"), False) eq_(_get_var(scope, "r"), False) eq_(_get_var(scope, "s"), False)
def test_unary_typeof(): """Test that the typeof operator does good.""" scope = _do_test_raw(""" var a = typeof(void(0)), b = typeof(null), c = typeof(true), d = typeof(false), e = typeof(new Boolean()), f = typeof(new Boolean(true)), g = typeof(Boolean()), h = typeof(Boolean(false)), i = typeof(Boolean(true)), j = typeof(NaN), k = typeof(Infinity), l = typeof(-Infinity), m = typeof(Math.PI), n = typeof(0), o = typeof(1), p = typeof(-1), q = typeof('0'), r = typeof(Number()), s = typeof(Number(0)), t = typeof(new Number()), u = typeof(new Number(0)), v = typeof(new Number(1)), x = typeof(function() {}), y = typeof(Math.abs); """) eq_(_get_var(scope, "a"), "undefined") eq_(_get_var(scope, "b"), "object") eq_(_get_var(scope, "c"), "boolean") eq_(_get_var(scope, "d"), "boolean") eq_(_get_var(scope, "e"), "object") eq_(_get_var(scope, "f"), "object") eq_(_get_var(scope, "g"), "boolean") eq_(_get_var(scope, "h"), "boolean") eq_(_get_var(scope, "i"), "boolean") # TODO: Implement "typeof" for predefined entities # eq_(_get_var(scope, "j"), "number") # eq_(_get_var(scope, "k"), "number") # eq_(_get_var(scope, "l"), "number") eq_(_get_var(scope, "m"), "number") eq_(_get_var(scope, "n"), "number") eq_(_get_var(scope, "o"), "number") eq_(_get_var(scope, "p"), "number") eq_(_get_var(scope, "q"), "string") eq_(_get_var(scope, "r"), "number") eq_(_get_var(scope, "s"), "number") eq_(_get_var(scope, "t"), "object") eq_(_get_var(scope, "u"), "object") eq_(_get_var(scope, "v"), "object") eq_(_get_var(scope, "x"), "function") eq_(_get_var(scope, "y"), "function")