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_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_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);
""")
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_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_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_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_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_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")
