github
/
boa
mirror of https://github.com/boa-dev/boa.git
1
0
Fork 0
Code Issues Releases Wiki Activity
Browse Source

tests: add check_output test helper (#1458) 

Co-authored-by: jedel1043 <jedel0124@gmail.com>
pull/1498/head
Bartek Iwańczuk 3 years ago committed by GitHub
parent
5ee865f745
commit
1b380c69af
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 231 additions and 237 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 13
      boa/src/builtins/symbol/tests.rs
  2. 144
      boa/src/exec/tests.rs
  3. 44
      boa/src/lib.rs
  4. 157
      boa/src/syntax/ast/node/iteration/tests.rs
  5. 110
      boa/src/value/tests.rs

13
boa/src/builtins/symbol/tests.rs
Unescape View File

@ -1,4 +1,4 @@
use crate::{forward, forward_val, Context};
use crate::{check_output, forward, forward_val, Context, TestAction};
#[test]
fn call_symbol_and_check_return_type() {
@ -24,7 +24,6 @@ fn print_symbol_expect_description() {
#[test]
fn symbol_access() {
let mut context = Context::new();
let init = r#"
var x = {};
var sym1 = Symbol("Hello");
@ -32,8 +31,10 @@ fn symbol_access() {
x[sym1] = 10;
x[sym2] = 20;
"#;
forward_val(&mut context, init).unwrap();
assert_eq!(forward(&mut context, "x[sym1]"), "10");
assert_eq!(forward(&mut context, "x[sym2]"), "20");
assert_eq!(forward(&mut context, "x['Symbol(Hello)']"), "undefined");
check_output(&[
TestAction::Execute(init),
TestAction::TestEq("x[sym1]", "10"),
TestAction::TestEq("x[sym2]", "20"),
TestAction::TestEq("x['Symbol(Hello)']", "undefined"),
]);
}

144
boa/src/exec/tests.rs
Unescape View File

@ -1,4 +1,6 @@
use crate::{builtins::Number, exec, forward, forward_val, Context, JsValue};
use crate::{
builtins::Number, check_output, exec, forward, forward_val, Context, JsValue, TestAction,
};
#[test]
fn function_declaration_returns_undefined() {
@ -118,8 +120,6 @@ fn object_field_set() {
#[test]
fn spread_with_arguments() {
let mut context = Context::new();
let scenario = r#"
const a = [1, "test", 3, 4];
function foo(...a) {
@ -128,31 +128,27 @@ fn spread_with_arguments() {
var result = foo(...a);
"#;
forward(&mut context, scenario);
let one = forward(&mut context, "result[0]");
assert_eq!(one, String::from("1"));
let two = forward(&mut context, "result[1]");
assert_eq!(two, String::from("\"test\""));
let three = forward(&mut context, "result[2]");
assert_eq!(three, String::from("3"));
let four = forward(&mut context, "result[3]");
assert_eq!(four, String::from("4"));
check_output(&[
TestAction::Execute(scenario),
TestAction::TestEq("result[0]", "1"),
TestAction::TestEq("result[1]", "\"test\""),
TestAction::TestEq("result[2]", "3"),
TestAction::TestEq("result[3]", "4"),
]);
}
#[test]
fn array_rest_with_arguments() {
let mut context = Context::new();
let scenario = r#"
var b = [4, 5, 6]
var a = [1, 2, 3, ...b];
"#;
forward(&mut context, scenario);
let one = forward(&mut context, "a");
assert_eq!(one, String::from("[ 1, 2, 3, 4, 5, 6 ]"));
check_output(&[
TestAction::Execute(scenario),
TestAction::TestEq("a", "[ 1, 2, 3, 4, 5, 6 ]"),
]);
}
#[test]
@ -722,8 +718,6 @@ mod in_operator {
#[test]
fn should_type_error_when_rhs_not_object() {
let mut context = Context::new();
let scenario = r#"
var x = false;
try {
@ -733,14 +727,14 @@ mod in_operator {
}
"#;
forward(&mut context, scenario);
assert_eq!(forward(&mut context, "x"), "true");
check_output(&[
TestAction::Execute(scenario),
TestAction::TestEq("x", "true"),
]);
}
#[test]
fn should_set_this_value() {
let mut context = Context::new();
let scenario = r#"
function Foo() {
this.a = "a";
@ -749,22 +743,24 @@ mod in_operator {
var bar = new Foo();
"#;
forward(&mut context, scenario);
assert_eq!(forward(&mut context, "bar.a"), "\"a\"");
assert_eq!(forward(&mut context, "bar.b"), "\"b\"");
check_output(&[
TestAction::Execute(scenario),
TestAction::TestEq("bar.a", "\"a\""),
TestAction::TestEq("bar.b", "\"b\""),
]);
}
#[test]
fn should_type_error_when_new_is_not_constructor() {
let mut context = Context::new();
let scenario = r#"
const a = "";
new a();
"#;
let result = forward(&mut context, scenario);
assert_eq!(result, "Uncaught \"TypeError\": \"a is not a constructor\"");
check_output(&[TestAction::TestEq(
&scenario,
"Uncaught \"TypeError\": \"a is not a constructor\"",
)]);
}
#[test]
@ -1223,45 +1219,38 @@ fn number_object_access_benchmark() {
#[test]
fn not_a_function() {
let mut context = Context::new();
let init = r#"
let a = {};
let b = true;
"#;
forward(&mut context, init);
let scenario = r#"
let scenario1 = r#"
try {
a();
} catch(e) {
e.toString()
}
"#;
assert_eq!(
forward(&mut context, scenario),
"\"TypeError: not a function\""
);
let scenario = r#"
let scenario2 = r#"
try {
a.a();
} catch(e) {
e.toString()
}
"#;
assert_eq!(
forward(&mut context, scenario),
"\"TypeError: not a function\""
);
let scenario = r#"
let scenario3 = r#"
try {
b();
} catch(e) {
e.toString()
}
"#;
assert_eq!(
forward(&mut context, scenario),
"\"TypeError: not a function\""
);
check_output(&[
TestAction::Execute(init),
TestAction::TestEq(scenario1, "\"TypeError: not a function\""),
TestAction::TestEq(scenario2, "\"TypeError: not a function\""),
TestAction::TestEq(scenario3, "\"TypeError: not a function\""),
]);
}
#[test]
@ -1339,12 +1328,12 @@ fn multicharacter_bitwise_assignment_to_non_assignable() {
#[test]
fn assign_to_array_decl() {
let mut context = Context::new();
assert!(forward(&mut context, "[1] = [2]").starts_with("Uncaught \"SyntaxError\": "));
assert!(forward(&mut context, "[3, 5] = [7, 8]").starts_with("Uncaught \"SyntaxError\": "));
assert!(forward(&mut context, "[6, 8] = [2]").starts_with("Uncaught \"SyntaxError\": "));
assert!(forward(&mut context, "[6] = [2, 9]").starts_with("Uncaught \"SyntaxError\": "));
check_output(&[
TestAction::TestStartsWith("[1] = [2]", "Uncaught \"SyntaxError\": "),
TestAction::TestStartsWith("[3, 5] = [7, 8]", "Uncaught \"SyntaxError\": "),
TestAction::TestStartsWith("[6, 8] = [2]", "Uncaught \"SyntaxError\": "),
TestAction::TestStartsWith("[6] = [2, 9]", "Uncaught \"SyntaxError\": "),
]);
}
#[test]
@ -1407,11 +1396,10 @@ fn test_strict_mode_octal() {
var n = 023;
"#;
let mut context = Context::new();
let string = dbg!(forward(&mut context, scenario));
assert!(string.starts_with("Uncaught \"SyntaxError\": "));
check_output(&[TestAction::TestStartsWith(
scenario,
"Uncaught \"SyntaxError\": ",
)]);
}
#[test]
@ -1428,11 +1416,10 @@ fn test_strict_mode_with() {
}
"#;
let mut context = Context::new();
let string = dbg!(forward(&mut context, scenario));
assert!(string.starts_with("Uncaught \"SyntaxError\": "));
check_output(&[TestAction::TestStartsWith(
scenario,
"Uncaught \"SyntaxError\": ",
)]);
}
#[test]
@ -1446,11 +1433,10 @@ fn test_strict_mode_delete() {
delete x;
"#;
let mut context = Context::new();
let string = dbg!(forward(&mut context, scenario));
assert!(string.starts_with("Uncaught \"SyntaxError\": "));
check_output(&[TestAction::TestStartsWith(
scenario,
"Uncaught \"SyntaxError\": ",
)]);
}
#[test]
@ -1494,11 +1480,10 @@ fn test_strict_mode_func_decl_in_block() {
if (a < b) { function f() {} }
"#;
let mut context = Context::new();
let string = dbg!(forward(&mut context, scenario));
assert!(string.starts_with("Uncaught \"SyntaxError\": "));
check_output(&[TestAction::TestStartsWith(
scenario,
"Uncaught \"SyntaxError\": ",
)]);
}
#[test]
@ -1511,11 +1496,10 @@ fn test_strict_mode_dup_func_parameters() {
function f(a, b, b) {}
"#;
let mut context = Context::new();
let string = dbg!(forward(&mut context, scenario));
assert!(string.starts_with("Uncaught \"SyntaxError\": "));
check_output(&[TestAction::TestStartsWith(
scenario,
"Uncaught \"SyntaxError\": ",
)]);
}
#[test]

44
boa/src/lib.rs
Unescape View File

@ -159,3 +159,47 @@ pub(crate) fn exec<T: AsRef<[u8]>>(src: T) -> String {
Err(error) => error.display().to_string(),
}
}
#[cfg(test)]
pub(crate) enum TestAction {
Execute(&'static str),
TestEq(&'static str, &'static str),
TestStartsWith(&'static str, &'static str),
}
/// Create a clean Context, call "forward" for each action, and optionally
/// assert equality of the returned value or if returned value starts with
/// expected string.
#[cfg(test)]
#[track_caller]
pub(crate) fn check_output(actions: &[TestAction]) {
let mut context = Context::new();
let mut i = 1;
for action in actions {
match action {
TestAction::Execute(src) => {
forward(&mut context, src);
}
TestAction::TestEq(case, expected) => {
assert_eq!(
&forward(&mut context, case),
expected,
"Test case {} ('{}')",
i,
case
);
i += 1;
}
TestAction::TestStartsWith(case, expected) => {
assert!(
&forward(&mut context, case).starts_with(expected),
"Test case {} ('{}')",
i,
case
);
i += 1;
}
}
}
}

157
boa/src/syntax/ast/node/iteration/tests.rs
Unescape View File

@ -1,4 +1,4 @@
use crate::{exec, forward, Context};
use crate::{check_output, exec, TestAction};
#[test]
fn while_loop_late_break() {
@ -194,87 +194,84 @@ fn do_while_loop_continue() {
#[test]
fn for_of_loop_declaration() {
let mut context = Context::new();
let scenario = r#"
var result = 0;
for (i of [1, 2, 3]) {
result = i;
}
"#;
context.eval(scenario).unwrap();
assert_eq!(&forward(&mut context, "result"), "3");
assert_eq!(&forward(&mut context, "i"), "3");
check_output(&[
TestAction::Execute(scenario),
TestAction::TestEq("result", "3"),
TestAction::TestEq("i", "3"),
]);
}
#[test]
fn for_of_loop_var() {
let mut context = Context::new();
let scenario = r#"
var result = 0;
for (var i of [1, 2, 3]) {
result = i;
}
"#;
context.eval(scenario).unwrap();
assert_eq!(&forward(&mut context, "result"), "3");
assert_eq!(&forward(&mut context, "i"), "3");
check_output(&[
TestAction::Execute(scenario),
TestAction::TestEq("result", "3"),
TestAction::TestEq("i", "3"),
]);
}
#[test]
fn for_of_loop_let() {
let mut context = Context::new();
let scenario = r#"
var result = 0;
for (let i of [1, 2, 3]) {
result = i;
}
"#;
context.eval(scenario).unwrap();
assert_eq!(&forward(&mut context, "result"), "3");
assert_eq!(
&forward(
&mut context,
check_output(&[
TestAction::Execute(scenario),
TestAction::TestEq("result", "3"),
TestAction::TestEq(
r#"
try {
i
} catch(e) {
e.toString()
}
"#
"#,
"\"ReferenceError: i is not defined\"",
),
"\"ReferenceError: i is not defined\""
);
]);
}
#[test]
fn for_of_loop_const() {
let mut context = Context::new();
let scenario = r#"
var result = 0;
for (let i of [1, 2, 3]) {
result = i;
}
"#;
context.eval(scenario).unwrap();
assert_eq!(&forward(&mut context, "result"), "3");
assert_eq!(
&forward(
&mut context,
check_output(&[
TestAction::Execute(scenario),
TestAction::TestEq("result", "3"),
TestAction::TestEq(
r#"
try {
i
} catch(e) {
e.toString()
}
"#
"#,
"\"ReferenceError: i is not defined\"",
),
"\"ReferenceError: i is not defined\""
);
]);
}
#[test]
fn for_of_loop_break() {
let mut context = Context::new();
let scenario = r#"
var result = 0;
for (var i of [1, 2, 3]) {
@ -283,14 +280,15 @@ fn for_of_loop_break() {
result = i
}
"#;
context.eval(scenario).unwrap();
assert_eq!(&forward(&mut context, "result"), "1");
assert_eq!(&forward(&mut context, "i"), "2");
check_output(&[
TestAction::Execute(scenario),
TestAction::TestEq("result", "1"),
TestAction::TestEq("i", "2"),
]);
}
#[test]
fn for_of_loop_continue() {
let mut context = Context::new();
let scenario = r#"
var result = 0;
for (var i of [1, 2, 3]) {
@ -299,14 +297,15 @@ fn for_of_loop_continue() {
result = i
}
"#;
context.eval(scenario).unwrap();
assert_eq!(&forward(&mut context, "result"), "2");
assert_eq!(&forward(&mut context, "i"), "3");
check_output(&[
TestAction::Execute(scenario),
TestAction::TestEq("result", "2"),
TestAction::TestEq("i", "3"),
]);
}
#[test]
fn for_of_loop_return() {
let mut context = Context::new();
let scenario = r#"
function foo() {
for (i of [1, 2, 3]) {
@ -315,8 +314,10 @@ fn for_of_loop_return() {
}
}
"#;
context.eval(scenario).unwrap();
assert_eq!(&forward(&mut context, "foo()"), "2");
check_output(&[
TestAction::Execute(scenario),
TestAction::TestEq("foo()", "2"),
]);
}
#[test]
@ -356,8 +357,6 @@ fn for_loop_continue_label() {
#[test]
fn for_in_declaration() {
let mut context = Context::new();
let init = r#"
let result = [];
let obj = { a: "a", b: 2};
@ -366,21 +365,17 @@ fn for_in_declaration() {
result = result.concat([i]);
}
"#;
eprintln!("{}", forward(&mut context, init));
assert_eq!(
forward(
&mut context,
"result.length === 2 && result.includes('a') && result.includes('b')"
check_output(&[
TestAction::Execute(init),
TestAction::TestEq(
"result.length === 2 && result.includes('a') && result.includes('b')",
"true",
),
"true"
);
]);
}
#[test]
fn for_in_var_object() {
let mut context = Context::new();
let init = r#"
let result = [];
let obj = { a: "a", b: 2};
@ -388,21 +383,17 @@ fn for_in_var_object() {
result = result.concat([i]);
}
"#;
eprintln!("{}", forward(&mut context, init));
assert_eq!(
forward(
&mut context,
"result.length === 2 && result.includes('a') && result.includes('b')"
check_output(&[
TestAction::Execute(init),
TestAction::TestEq(
"result.length === 2 && result.includes('a') && result.includes('b')",
"true",
),
"true"
);
]);
}
#[test]
fn for_in_var_array() {
let mut context = Context::new();
let init = r#"
let result = [];
let arr = ["a", "b"];
@ -410,21 +401,17 @@ fn for_in_var_array() {
result = result.concat([i]);
}
"#;
eprintln!("{}", forward(&mut context, init));
assert_eq!(
forward(
&mut context,
"result.length === 2 && result.includes('0') && result.includes('1')"
check_output(&[
TestAction::Execute(init),
TestAction::TestEq(
"result.length === 2 && result.includes('0') && result.includes('1')",
"true",
),
"true"
);
]);
}
#[test]
fn for_in_let_object() {
let mut context = Context::new();
let init = r#"
let result = [];
let obj = { a: "a", b: 2};
@ -432,21 +419,17 @@ fn for_in_let_object() {
result = result.concat([i]);
}
"#;
eprintln!("{}", forward(&mut context, init));
assert_eq!(
forward(
&mut context,
"result.length === 2 && result.includes('a') && result.includes('b')"
check_output(&[
TestAction::Execute(init),
TestAction::TestEq(
"result.length === 2 && result.includes('a') && result.includes('b')",
"true",
),
"true"
);
]);
}
#[test]
fn for_in_const_array() {
let mut context = Context::new();
let init = r#"
let result = [];
let arr = ["a", "b"];
@ -454,15 +437,13 @@ fn for_in_const_array() {
result = result.concat([i]);
}
"#;
eprintln!("{}", forward(&mut context, init));
assert_eq!(
forward(
&mut context,
"result.length === 2 && result.includes('0') && result.includes('1')"
check_output(&[
TestAction::Execute(init),
TestAction::TestEq(
"result.length === 2 && result.includes('0') && result.includes('1')",
"true",
),
"true"
);
]);
}
#[test]

110
boa/src/value/tests.rs
Unescape View File

@ -1,7 +1,7 @@
#![allow(clippy::float_cmp)]
use super::*;
use crate::{forward, forward_val, Context};
use crate::{check_output, forward, forward_val, Context, TestAction};
use std::collections::hash_map::DefaultHasher;
use std::hash::{Hash, Hasher};
@ -64,63 +64,45 @@ fn number_is_true() {
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Equality_comparisons_and_sameness
#[test]
fn abstract_equality_comparison() {
let mut context = Context::new();
assert_eq!(forward(&mut context, "undefined == undefined"), "true");
assert_eq!(forward(&mut context, "null == null"), "true");
assert_eq!(forward(&mut context, "true == true"), "true");
assert_eq!(forward(&mut context, "false == false"), "true");
assert_eq!(forward(&mut context, "'foo' == 'foo'"), "true");
assert_eq!(forward(&mut context, "0 == 0"), "true");
assert_eq!(forward(&mut context, "+0 == -0"), "true");
assert_eq!(forward(&mut context, "+0 == 0"), "true");
assert_eq!(forward(&mut context, "-0 == 0"), "true");
assert_eq!(forward(&mut context, "0 == false"), "true");
assert_eq!(forward(&mut context, "'' == false"), "true");
assert_eq!(forward(&mut context, "'' == 0"), "true");
assert_eq!(forward(&mut context, "'17' == 17"), "true");
assert_eq!(forward(&mut context, "[1,2] == '1,2'"), "true");
assert_eq!(forward(&mut context, "new String('foo') == 'foo'"), "true");
assert_eq!(forward(&mut context, "null == undefined"), "true");
assert_eq!(forward(&mut context, "undefined == null"), "true");
assert_eq!(forward(&mut context, "null == false"), "false");
assert_eq!(forward(&mut context, "[] == ![]"), "true");
assert_eq!(
forward(
&mut context,
"a = { foo: 'bar' }; b = { foo: 'bar'}; a == b"
check_output(&[
TestAction::TestEq("undefined == undefined", "true"),
TestAction::TestEq("null == null", "true"),
TestAction::TestEq("true == true", "true"),
TestAction::TestEq("false == false", "true"),
TestAction::TestEq("'foo' == 'foo'", "true"),
TestAction::TestEq("0 == 0", "true"),
TestAction::TestEq("+0 == -0", "true"),
TestAction::TestEq("+0 == 0", "true"),
TestAction::TestEq("-0 == 0", "true"),
TestAction::TestEq("0 == false", "true"),
TestAction::TestEq("'' == false", "true"),
TestAction::TestEq("'' == 0", "true"),
TestAction::TestEq("'17' == 17", "true"),
TestAction::TestEq("[1,2] == '1,2'", "true"),
TestAction::TestEq("new String('foo') == 'foo'", "true"),
TestAction::TestEq("null == undefined", "true"),
TestAction::TestEq("undefined == null", "true"),
TestAction::TestEq("null == false", "false"),
TestAction::TestEq("[] == ![]", "true"),
TestAction::TestEq("a = { foo: 'bar' }; b = { foo: 'bar'}; a == b", "false"),
TestAction::TestEq("new String('foo') == new String('foo')", "false"),
TestAction::TestEq("0 == null", "false"),
TestAction::TestEq("0 == '-0'", "true"),
TestAction::TestEq("0 == '+0'", "true"),
TestAction::TestEq("'+0' == 0", "true"),
TestAction::TestEq("'-0' == 0", "true"),
TestAction::TestEq("0 == NaN", "false"),
TestAction::TestEq("'foo' == NaN", "false"),
TestAction::TestEq("NaN == NaN", "false"),
TestAction::TestEq(
"Number.POSITIVE_INFINITY === Number.POSITIVE_INFINITY",
"true",
),
"false"
);
assert_eq!(
forward(&mut context, "new String('foo') == new String('foo')"),
"false"
);
assert_eq!(forward(&mut context, "0 == null"), "false");
assert_eq!(forward(&mut context, "0 == '-0'"), "true");
assert_eq!(forward(&mut context, "0 == '+0'"), "true");
assert_eq!(forward(&mut context, "'+0' == 0"), "true");
assert_eq!(forward(&mut context, "'-0' == 0"), "true");
assert_eq!(forward(&mut context, "0 == NaN"), "false");
assert_eq!(forward(&mut context, "'foo' == NaN"), "false");
assert_eq!(forward(&mut context, "NaN == NaN"), "false");
assert_eq!(
forward(
&mut context,
"Number.POSITIVE_INFINITY === Number.POSITIVE_INFINITY"
TestAction::TestEq(
"Number.NEGATIVE_INFINITY === Number.NEGATIVE_INFINITY",
"true",
),
"true"
);
assert_eq!(
forward(
&mut context,
"Number.NEGAVIVE_INFINITY === Number.NEGAVIVE_INFINITY"
),
"true"
);
]);
}
/// Helper function to get the hash of a `Value`.
@ -608,20 +590,20 @@ fn to_integer_or_infinity() {
#[test]
fn test_accessors() {
let mut context = Context::new();
let src = r#"
let arr = [];
let a = { get b() { return "c" }, set b(value) { arr = arr.concat([value]) }} ;
a.b = "a";
"#;
context.eval(src).unwrap();
assert_eq!(forward(&mut context, "a.b"), r#""c""#);
assert_eq!(forward(&mut context, "arr"), r#"[ "a" ]"#);
check_output(&[
TestAction::Execute(src),
TestAction::TestEq("a.b", r#""c""#),
TestAction::TestEq("arr", r#"[ "a" ]"#),
]);
}
#[test]
fn to_primitive() {
let mut context = Context::new();
let src = r#"
let a = {};
a[Symbol.toPrimitive] = function() {
@ -629,8 +611,10 @@ fn to_primitive() {
};
let primitive = a + 0;
"#;
context.eval(src).unwrap();
assert_eq!(forward(&mut context, "primitive"), "42");
check_output(&[
TestAction::Execute(src),
TestAction::TestEq("primitive", "42"),
]);
}
/// Test cyclic conversions that previously caused stack overflows

Write Preview
Loading…
Cancel
Save