From 47c4196d41f887054d099747ee5a25c5f3b24a13 Mon Sep 17 00:00:00 2001
From: Ingvar Stepanyan <me@rreverser.com>
Date: Thu, 24 Jul 2014 02:21:06 +0300
Subject: [PATCH] Some testFail message fixes.

---
 test/tests-harmony.js | 696 +++++++-----------------------------------
 test/tests.js         |   2 +-
 2 files changed, 117 insertions(+), 581 deletions(-)

diff --git a/test/tests-harmony.js b/test/tests-harmony.js
index 1abcf22bd6..05d5097780 100644
--- a/test/tests-harmony.js
+++ b/test/tests-harmony.js
@@ -10472,41 +10472,17 @@ test("class A { set foo(v) {} get foo() {} }", {
   locations: true
 });
 
-testFail("class A { get foo() {} get foo() {} }", "Unexpected token (1:31)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("class A { get foo() {} get foo() {} }", "Unexpected token (1:31)", {ecmaVersion: 6});
 
-testFail("class A { set foo(v) {} set foo(v) {} }", "Unexpected token (1:32)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("class A { set foo(v) {} set foo(v) {} }", "Unexpected token (1:32)", {ecmaVersion: 6});
 
-testFail("class A { get foo() {} foo() {} }", "Unexpected token (1:27)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("class A { get foo() {} foo() {} }", "Unexpected token (1:27)", {ecmaVersion: 6});
 
-testFail("class A { foo() {} get foo() {} }", "Unexpected token (1:27)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("class A { foo() {} get foo() {} }", "Unexpected token (1:27)", {ecmaVersion: 6});
 
-testFail("class A { set foo(v) {} foo() {} }", "Unexpected token (1:28)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("class A { set foo(v) {} foo() {} }", "Unexpected token (1:28)", {ecmaVersion: 6});
 
-testFail("class A { foo() {} set foo(v) {} }", "Unexpected token (1:27)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("class A { foo() {} set foo(v) {} }", "Unexpected token (1:27)", {ecmaVersion: 6});
 
 // ES6: Computed Properties
 
@@ -11319,11 +11295,7 @@ test("var x = {*[test]() { yield *v; }}", {
   locations: true
 });
 
-testFail("({[x]})", "Unexpected token (1:6)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("({[x]})", "Unexpected token (1:6)", {ecmaVersion: 6});
 
 // ES6: Default parameters
 
@@ -15743,395 +15715,135 @@ test("func(a, ...b)", {
 
 // Harmony Invalid syntax
 
-testFail("0o", "Unexpected token (1:3)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("0o", "Expected number in radix 8 (1:2)", {ecmaVersion: 6});
 
-testFail("0o1a", "Unexpected token (1:4)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("0o1a", "Identifier directly after number (1:3)", {ecmaVersion: 6});
 
-testFail("0o9", "Unexpected token (1:3)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("0o9", "Expected number in radix 8 (1:2)", {ecmaVersion: 6});
 
-testFail("0o18", "Unexpected token (1:4)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("0o18", "Unexpected token (1:3)", {ecmaVersion: 6});
 
-testFail("0O", "Unexpected token (1:3)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("0O", "Expected number in radix 8 (1:2)", {ecmaVersion: 6});
 
-testFail("0O1a", "Unexpected token (1:4)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("0O1a", "Identifier directly after number (1:3)", {ecmaVersion: 6});
 
-testFail("0O9", "Unexpected token (1:3)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("0O9", "Expected number in radix 8 (1:2)", {ecmaVersion: 6});
 
-testFail("0O18", "Unexpected token (1:4)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("0O18", "Unexpected token (1:3)", {ecmaVersion: 6});
 
-testFail("0b", "Unexpected token (1:3)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("0b", "Expected number in radix 2 (1:2)", {ecmaVersion: 6});
 
-testFail("0b1a", "Unexpected token (1:4)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("0b1a", "Identifier directly after number (1:3)", {ecmaVersion: 6});
 
-testFail("0b9", "Unexpected token (1:3)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("0b9", "Expected number in radix 2 (1:2)", {ecmaVersion: 6});
 
-testFail("0b18", "Unexpected token (1:4)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("0b18", "Unexpected token (1:3)", {ecmaVersion: 6});
 
-testFail("0b12", "Unexpected token (1:4)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("0b12", "Unexpected token (1:3)", {ecmaVersion: 6});
 
-testFail("0B", "Unexpected token (1:3)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("0B", "Expected number in radix 2 (1:2)", {ecmaVersion: 6});
 
-testFail("0B1a", "Unexpected token (1:4)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("0B1a", "Identifier directly after number (1:3)", {ecmaVersion: 6});
 
-testFail("0B9", "Unexpected token (1:3)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("0B9", "Expected number in radix 2 (1:2)", {ecmaVersion: 6});
 
-testFail("0B18", "Unexpected token (1:4)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("0B18", "Unexpected token (1:3)", {ecmaVersion: 6});
 
-testFail("0B12", "Unexpected token (1:4)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("0B12", "Unexpected token (1:3)", {ecmaVersion: 6});
 
-testFail("\"\\u{110000}\"", "Unexpected token (1:12)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("\"\\u{110000}\"", "Unexpected token (1:12)", {ecmaVersion: 6});
 
-testFail("\"\\u{}\"", "Unexpected token (1:5)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("\"\\u{}\"", "Unexpected token (1:5)", {ecmaVersion: 6});
 
-testFail("\"\\u{FFFF\"", "Unexpected token (1:10)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("\"\\u{FFFF\"", "Unexpected token (1:10)", {ecmaVersion: 6});
 
-testFail("\"\\u{FFZ}\"", "Unexpected token (1:8)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("\"\\u{FFZ}\"", "Unexpected token (1:8)", {ecmaVersion: 6});
 
-testFail("[v] += ary", "Unexpected token (1:4)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("[v] += ary", "Unexpected token (1:4)", {ecmaVersion: 6});
 
-testFail("[2] = 42", "Unexpected token (1:4)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("[2] = 42", "Unexpected token (1:4)", {ecmaVersion: 6});
 
-testFail("({ obj:20 }) = 42", "Unexpected token (1:13)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("({ obj:20 }) = 42", "Unexpected token (1:13)", {ecmaVersion: 6});
 
-testFail("( { get x() {} } ) = 0", "Unexpected token (1:19)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("( { get x() {} } ) = 0", "Unexpected token (1:19)", {ecmaVersion: 6});
 
-testFail("x \n is y", "Unexpected token (2:5)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("x \n is y", "Unexpected token (2:5)", {ecmaVersion: 6});
 
-testFail("x \n isnt y", "Unexpected token (2:7)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("x \n isnt y", "Unexpected token (2:7)", {ecmaVersion: 6});
 
-testFail("function default() {}", "Unexpected token (1:10)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("function default() {}", "Unexpected token (1:9)", {ecmaVersion: 6});
 
-testFail("function hello() {'use strict'; ({ i: 10, s(eval) { } }); }", "Unexpected token (1:45)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("function hello() {'use strict'; ({ i: 10, s(eval) { } }); }", "Unexpected token (1:45)", {ecmaVersion: 6});
 
-testFail("function a() { \"use strict\"; ({ b(t, t) { } }); }", "Unexpected token (1:38)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("function a() { \"use strict\"; ({ b(t, t) { } }); }", "Unexpected token (1:38)", {ecmaVersion: 6});
 
-testFail("var super", "Unexpected token (1:5)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("var super", "Unexpected token (1:5)", {ecmaVersion: 6});
 
-testFail("var default", "Unexpected token (1:5)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("var default", "Unexpected token (1:4)", {ecmaVersion: 6});
 
-testFail("let default", "Unexpected token (1:5)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("let default", "Unexpected token (1:4)", {ecmaVersion: 6});
 
-testFail("const default", "Unexpected token (1:7)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("const default", "Unexpected token (1:6)", {ecmaVersion: 6});
 
-testFail("({ v: eval }) = obj", "Unexpected token (1:14)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("({ v: eval }) = obj", "Unexpected token (1:14)", {ecmaVersion: 6});
 
-testFail("({ v: arguments }) = obj", "Unexpected token (1:19)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("({ v: arguments }) = obj", "Unexpected token (1:19)", {ecmaVersion: 6});
 
-testFail("for (var i = function() { return 10 in [] } in list) process(x);", "Unexpected token (1:45)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("for (var i = function() { return 10 in [] } in list) process(x);", "Unexpected token (1:45)", {ecmaVersion: 6});
 
-testFail("for (let x = 42 in list) process(x);", "Unexpected token (1:17)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("for (let x = 42 in list) process(x);", "Unexpected token (1:17)", {ecmaVersion: 6});
 
-testFail("for (let x = 42 of list) process(x);", "Unexpected token (1:17)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("for (let x = 42 of list) process(x);", "Unexpected token (1:17)", {ecmaVersion: 6});
 
-testFail("module\n\"crypto\" {}", "Unexpected token (1:7)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("module\n\"crypto\" {}", "Unexpected token (1:7)", {ecmaVersion: 6});
 
-testFail("module foo from bar", "Unexpected token (1:20)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("module foo from bar", "Unexpected token (1:20)", {ecmaVersion: 6});
 
-testFail("module 42", "Unexpected token (1:8)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("module 42", "Unexpected token (1:8)", {ecmaVersion: 6});
 
-testFail("module foo bar", "Unexpected token (1:12)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("module foo bar", "Unexpected token (1:12)", {ecmaVersion: 6});
 
-testFail("module \"crypto\" { module \"e\" {} }", "Unexpected token (1:18)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("module \"crypto\" { module \"e\" {} }", "Unexpected token (1:18)", {ecmaVersion: 6});
 
-testFail("module \"x\" { export * from foo }", "Unexpected token (1:31)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("module \"x\" { export * from foo }", "Unexpected token (1:31)", {ecmaVersion: 6});
 
-testFail("import foo", "Unexpected token (1:11)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("import foo", "Unexpected token (1:11)", {ecmaVersion: 6});
 
-testFail("import { foo, bar }", "Unexpected token (1:20)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("import { foo, bar }", "Unexpected token (1:20)", {ecmaVersion: 6});
 
-testFail("import foo from bar", "Unexpected token (1:20)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("import foo from bar", "Unexpected token (1:20)", {ecmaVersion: 6});
 
-testFail("((a)) => 42", "Unexpected token (1:7)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("((a)) => 42", "Unexpected token (1:7)", {ecmaVersion: 6});
 
-testFail("(a, (b)) => 42", "Unexpected token (1:10)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("(a, (b)) => 42", "Unexpected token (1:10)", {ecmaVersion: 6});
 
-testFail("\"use strict\"; (eval = 10) => 42", "Unexpected token (1:16)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("\"use strict\"; (eval = 10) => 42", "Unexpected token (1:16)", {ecmaVersion: 6});
 
-testFail("\"use strict\"; eval => 42", "Unexpected token (1:25)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("\"use strict\"; eval => 42", "Unexpected token (1:25)", {ecmaVersion: 6});
 
-testFail("\"use strict\"; arguments => 42", "Unexpected token (1:30)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("\"use strict\"; arguments => 42", "Unexpected token (1:30)", {ecmaVersion: 6});
 
-testFail("\"use strict\"; (eval, a) => 42", "Unexpected token (1:30)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("\"use strict\"; (eval, a) => 42", "Unexpected token (1:30)", {ecmaVersion: 6});
 
-testFail("\"use strict\"; (arguments, a) => 42", "Unexpected token (1:35)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("\"use strict\"; (arguments, a) => 42", "Unexpected token (1:35)", {ecmaVersion: 6});
 
-testFail("\"use strict\"; (eval, a = 10) => 42", "Unexpected token (1:35)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("\"use strict\"; (eval, a = 10) => 42", "Unexpected token (1:35)", {ecmaVersion: 6});
 
-testFail("(a, a) => 42", "Unexpected token (1:7)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("(a, a) => 42", "Unexpected token (1:7)", {ecmaVersion: 6});
 
-testFail("\"use strict\"; (a, a) => 42", "Unexpected token (1:21)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("\"use strict\"; (a, a) => 42", "Unexpected token (1:21)", {ecmaVersion: 6});
 
-testFail("\"use strict\"; (a) => 00", "Unexpected token (1:22)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("\"use strict\"; (a) => 00", "Unexpected token (1:22)", {ecmaVersion: 6});
 
-testFail("() <= 42", "Unexpected token (1:4)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("() <= 42", "Unexpected token (1:4)", {ecmaVersion: 6});
 
-testFail("(10) => 00", "Unexpected token (1:6)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("(10) => 00", "Unexpected token (1:6)", {ecmaVersion: 6});
 
-testFail("(10, 20) => 00", "Unexpected token (1:10)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("(10, 20) => 00", "Unexpected token (1:10)", {ecmaVersion: 6});
 
-testFail("yield v", "Unexpected token (1:7)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("yield v", "Unexpected token (1:7)", {ecmaVersion: 6});
 
-testFail("yield 10", "Unexpected token (1:7)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("yield 10", "Unexpected token (1:7)", {ecmaVersion: 6});
 
 test("yield* 10", {
   type: "Program",
@@ -16253,11 +15965,7 @@ test("e => yield* 10", {
   locations: true
 });
 
-testFail("(function () { yield 10 })", "Unexpected token (1:22)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("(function () { yield 10 })", "Unexpected token (1:22)", {ecmaVersion: 6});
 
 test("(function () { yield* 10 })", {
   type: "Program",
@@ -16338,260 +16046,88 @@ test("(function () { yield* 10 })", {
   locations: true
 });
 
-testFail("(function() { \"use strict\"; f(yield v) })", "Unexpected token (1:36)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("(function() { \"use strict\"; f(yield v) })", "Unexpected token (1:36)", {ecmaVersion: 6});
 
-testFail("var obj = { *test** }", "Unexpected token (1:18)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("var obj = { *test** }", "Unexpected token (1:18)", {ecmaVersion: 6});
 
-testFail("class A extends yield B { }", "Unexpected token (1:23)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("class A extends yield B { }", "Unexpected token (1:23)", {ecmaVersion: 6});
 
-testFail("class default", "Unexpected token (1:7)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("class default", "Unexpected token (1:6)", {ecmaVersion: 6});
 
-testFail("`test", "Unexpected token (1:6)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("`test", "Unexpected token (1:6)", {ecmaVersion: 6});
 
-testFail("switch `test`", "Unexpected token (1:8)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("switch `test`", "Unexpected token (1:8)", {ecmaVersion: 6});
 
-testFail("`hello ${10 `test`", "Unexpected token (1:19)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("`hello ${10 `test`", "Unexpected token (1:19)", {ecmaVersion: 6});
 
-testFail("`hello ${10;test`", "Unexpected token (1:12)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("`hello ${10;test`", "Unexpected token (1:12)", {ecmaVersion: 6});
 
-testFail("function a() 1 // expression closure is not supported", "Unexpected token (1:14)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("function a() 1 // expression closure is not supported", "Unexpected token (1:14)", {ecmaVersion: 6});
 
-testFail("[a,b if (a)] // (a,b)", "Unexpected token (1:5)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("[a,b if (a)] // (a,b)", "Unexpected token (1:5)", {ecmaVersion: 6});
 
-testFail("for each (let x in {}) {};", "Unexpected token (1:4)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("for each (let x in {}) {};", "Unexpected token (1:4)", {ecmaVersion: 6});
 
-testFail("[x for (let x in [])]", "Unexpected token (1:21)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("[x for (let x in [])]", "Unexpected token (1:21)", {ecmaVersion: 6});
 
-testFail("[x for (const x in [])]", "Unexpected token (1:23)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("[x for (const x in [])]", "Unexpected token (1:23)", {ecmaVersion: 6});
 
-testFail("[x for (var x in [])]", "Unexpected token (1:21)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("[x for (var x in [])]", "Unexpected token (1:21)", {ecmaVersion: 6});
 
-testFail("[a,b for (a in [])] // (a,b) ", "Unexpected token (1:5)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("[a,b for (a in [])] // (a,b) ", "Unexpected token (1:5)", {ecmaVersion: 6});
 
-testFail("[x if (x)]  // block required", "Unexpected token (1:11)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("[x if (x)]  // block required", "Unexpected token (1:11)", {ecmaVersion: 6});
 
-testFail("var a = [x if (x)]", "Unexpected token (1:19)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("var a = [x if (x)]", "Unexpected token (1:19)", {ecmaVersion: 6});
 
-testFail("[for (x in [])]  // no espression", "Unexpected token (1:16)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("[for (x in [])]  // no espression", "Unexpected token (1:16)", {ecmaVersion: 6});
 
-testFail("({ \"chance\" }) = obj", "Unexpected token (1:13)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("({ \"chance\" }) = obj", "Unexpected token (1:13)", {ecmaVersion: 6});
 
-testFail("({ 42 }) = obj", "Unexpected token (1:7)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("({ 42 }) = obj", "Unexpected token (1:7)", {ecmaVersion: 6});
 
-testFail("function f(a, ...b, c)", "Unexpected token (1:19)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("function f(a, ...b, c)", "Unexpected token (1:19)", {ecmaVersion: 6});
 
-testFail("function f(a, ...b = 0)", "Unexpected token (1:20)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("function f(a, ...b = 0)", "Unexpected token (1:20)", {ecmaVersion: 6});
 
-testFail("function x(...{ a }){}", "Unexpected token (1:15)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("function x(...{ a }){}", "Unexpected token (1:15)", {ecmaVersion: 6});
 
-testFail("\"use strict\"; function x(a, { a }){}", "Unexpected token (1:37)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("\"use strict\"; function x(a, { a }){}", "Unexpected token (1:37)", {ecmaVersion: 6});
 
-testFail("\"use strict\"; function x({ b: { a } }, [{ b: { a } }]){}", "Unexpected token (1:57)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("\"use strict\"; function x({ b: { a } }, [{ b: { a } }]){}", "Unexpected token (1:57)", {ecmaVersion: 6});
 
-testFail("\"use strict\"; function x(a, ...[a]){}", "Unexpected token (1:38)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("\"use strict\"; function x(a, ...[a]){}", "Unexpected token (1:38)", {ecmaVersion: 6});
 
-testFail("(...a, b) => {}", "Unexpected token (1:6)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("(...a, b) => {}", "Unexpected token (1:6)", {ecmaVersion: 6});
 
-testFail("([ 5 ]) => {}", "Unexpected token (1:8)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("([ 5 ]) => {}", "Unexpected token (1:8)", {ecmaVersion: 6});
 
-testFail("({ 5 }) => {}", "Unexpected token (1:6)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("({ 5 }) => {}", "Unexpected token (1:6)", {ecmaVersion: 6});
 
-testFail("(...[ 5 ]) => {}", "Unexpected token (1:10)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("(...[ 5 ]) => {}", "Unexpected token (1:10)", {ecmaVersion: 6});
 
-testFail("[...{ a }] = b", "Unexpected token (1:11)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("[...{ a }] = b", "Unexpected token (1:11)", {ecmaVersion: 6});
 
-testFail("[...a, b] = c", "Unexpected token (1:6)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("[...a, b] = c", "Unexpected token (1:6)", {ecmaVersion: 6});
 
-testFail("func(...a, b)", "Unexpected token (1:10)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("func(...a, b)", "Unexpected token (1:10)", {ecmaVersion: 6});
 
-testFail("({ t(eval) { \"use strict\"; } });", "Unexpected token (1:6)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("({ t(eval) { \"use strict\"; } });", "Unexpected token (1:6)", {ecmaVersion: 6});
 
-testFail("\"use strict\"; `${test}\\02`;", "Unexpected token (1:22)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("\"use strict\"; `${test}\\02`;", "Unexpected token (1:22)", {ecmaVersion: 6});
 
-testFail("[...a, ] = b", "Unexpected token (1:6)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("[...a, ] = b", "Unexpected token (1:6)", {ecmaVersion: 6});
 
-testFail("if (b,...a, );", "Unexpected token (1:11)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("if (b,...a, );", "Unexpected token (1:11)", {ecmaVersion: 6});
 
-testFail("(b, ...a)", "Unexpected token (1:9)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("(b, ...a)", "Unexpected token (1:9)", {ecmaVersion: 6});
 
-testFail("module \"Universe\" { ;  ;  ", "Unexpected token (1:27)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("module \"Universe\" { ;  ;  ", "Unexpected token (1:27)", {ecmaVersion: 6});
 
-testFail("switch (cond) { case 10: let a = 20; ", "Unexpected token (1:38)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("switch (cond) { case 10: let a = 20; ", "Unexpected token (1:37)", {ecmaVersion: 6});
 
-testFail("\"use strict\"; (eval) => 42", "Unexpected token (1:27)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("\"use strict\"; (eval) => 42", "Unexpected token (1:27)", {ecmaVersion: 6});
 
-testFail("(eval) => { \"use strict\"; 42 }", "Unexpected token (1:31)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("(eval) => { \"use strict\"; 42 }", "Unexpected token (1:31)", {ecmaVersion: 6});
 
-testFail("({ get test() { } }) => 42", "Unexpected token (1:21)", {
-  ecmaVersion: 6,
-  ranges: true,
-  locations: true
-});
+testFail("({ get test() { } }) => 42", "Unexpected token (1:21)", {ecmaVersion: 6});
diff --git a/test/tests.js b/test/tests.js
index 0bf82d5fcf..9a7793e78c 100644
--- a/test/tests.js
+++ b/test/tests.js
@@ -26723,7 +26723,7 @@ testFail("3x0",
          "Identifier directly after number (1:1)");
 
 testFail("0x",
-         "Expected hexadecimal number (1:2)");
+         "Expected number in radix 16 (1:2)");
 
 testFail("09",
          "Invalid number (1:0)");