ECMAScript 3 Core Language Test

This page tests AWeb's ECMAScript 3 (JavaScript 1.5) core language features. These tests focus on the JavaScript language itself, not browser-specific extensions. Rows under Graceful Failure use intentional faults to verify stable error handling.

Variables & Data Types

ES1: Variable Declaration - PASS

Variable x = Expected: 1 | Actual:

ES2: Basic Arithmetic - PASS

a = 5, b = 3

Sum (a + b) = Expected: 8 | Actual:

Product (a * b) = Expected: 15 | Actual:

ES3: String Concatenation - FAIL except for Direct concat test

Message (two-step): Expected: Hello World | Actual:

Message (chained): Expected: Hello World | Actual:

Direct concat test: Expected: Hello World | Actual:

Direct concat with vars: Expected: Hello World | Actual:

ES4: Function Call - PASS

addNumbers(10, 20) = Expected: 30 | Actual:

ES5: Array Operations - PASS

Array: [1, 2, 3, 4, 5] (created with new Array)

First element (arr[0]) = Expected: 1 | Actual:

Array length = Expected: 5 | Actual:

Array type check: Expected: object | Actual:

ES6: Conditional Statement - PASS

testValue = 8

Is testValue even? Expected: yes | Actual:

ES7: Comparison Operators - PASS

val1 = 5, val2 = 3

val1 > val2: Expected: true | Actual:

val1 < val2: Expected: false | Actual:

val1 == val2: Expected: false | Actual:

val1 != val2: Expected: true | Actual:

ES8: While Loop - PASS

Loop result (0 to 2): Expected: 0 1 2 | Actual:

ES9: For Loop - FAIL

For loop result (0 to 2): Expected: 0 1 2 | Actual:

ES10: Object Property Access - PASS

obj.name = Expected: Test | Actual:

obj.value = Expected: 42 | Actual:

ES11: String Methods - PASS

Original: "Hello World"

toUpperCase(): Expected: HELLO WORLD | Actual:

toLowerCase(): Expected: hello world | Actual:

length: Expected: 11 | Actual:

charAt(0): Expected: H | Actual:

ES12: Math Object - PASS

Math.PI: Expected: 3.141592653589793 | Actual:

Math.sqrt(16): Expected: 4 | Actual:

Math.max(5, 10): Expected: 10 | Actual:

Math.min(5, 10): Expected: 5 | Actual:

Math.abs(-5): Expected: 5 | Actual:

ES13: Date Object - PASS

Current Date object created

getYear(): Expected: current year (e.g., 2026) | Actual:

getMonth(): Expected: current month (0-11) | Actual:

getDate(): Expected: current day of month (1-31) | Actual:

ES14: Nested Function Calls - PASS

addAndMultiply(2, 3, 4) = (2+3)*4 = Expected: 20 | Actual:

ES15: Array with new Array() - PASS

Array: [1, 2, 3, 4, 5]

First element: Expected: 1 | Actual:

Last element: Expected: 5 | Actual:

Array length: Expected: 5 | Actual:

ES16: Logical Operators - PASS

a = true, b = false

a && b: Expected: false | Actual:

a && a: Expected: true | Actual:

a || b: Expected: true | Actual:

b || b: Expected: false | Actual:

!a: Expected: false | Actual:

!b: Expected: true | Actual:

ES17: Type Checking (typeof)

Direct typeof tests (simpler): - PASS

typeof 42: Expected: number | Actual:

typeof "test": Expected: string | Actual:

typeof true: Expected: boolean | Actual:

typeof undefined: Expected: undefined | Actual:

typeof with variables: - PASS

typeof num (42): Expected: number | Actual:

typeof str ("hello"): Expected: string | Actual:

typeof bool (true): Expected: boolean | Actual:

typeof obj (new Object()): Expected: object | Actual:

typeof arr (new Array()): Expected: object | Actual:

typeof func (function): Expected: function | Actual:

ES18: String indexOf and lastIndexOf - PASS

String: "Hello World"

indexOf("o"): Expected: 4 | Actual:

lastIndexOf("o"): Expected: 7 | Actual:

indexOf("x") (not found): Expected: -1 | Actual:

ES19: String substring - PASS

String: "Hello World"

substring(0, 5): Expected: Hello | Actual:

substring(6): Expected: World | Actual:

ES20: Array join and reverse - PASS

Array: ["a", "b", "c"]

join(", "): Expected: a, b, c | Actual:

After reverse(), join(", "): Expected: c, b, a | Actual:

ES21: More Math Functions - PASS

Math.pow(2, 8): Expected: 256 | Actual:

Math.round(3.7): Expected: 4 | Actual:

Math.round(3.2): Expected: 3 | Actual:

Math.floor(3.7): Expected: 3 | Actual:

Math.ceil(3.2): Expected: 4 | Actual:

Math.random(): Expected: [number between 0 and 1] | Actual:

ES22: More Date Methods - PASS

Current Date object

getHours(): Expected: [current hour 0-23] | Actual:

getMinutes(): Expected: [current minute 0-59] | Actual:

getSeconds(): Expected: [current second 0-59] | Actual:

getDay(): Expected: [current day 0-6, 0=Sunday] | Actual:

getTime(): Expected: [milliseconds since epoch] | Actual:

ES23: Complex Expressions - PASS

a = 10, b = 5, c = 2

a + b * c (precedence): Expected: 20 | Actual:

(a + b) * c: Expected: 30 | Actual:

a - b / c (precedence): Expected: 7.5 | Actual:

(a - b) / c: Expected: 2.5 | Actual:

ES24: Object with Multiple Properties - PASS

Object with multiple properties

person.name: Expected: John | Actual:

person.age: Expected: 30 | Actual:

person.city: Expected: New York | Actual:

ES25: Function with Multiple Statements - PASS

calculate(3, 4) = (3+4) + (3*4) = Expected: 19 | Actual:

ES26: Nested Conditionals - PASS

score = 85

Grade: Expected: B | Actual:

ES27: Array Element Assignment

Array: [1, 2, 3]

After arr[1] = 99, arr[1] = Expected: 99 | Actual:

Array length: Expected: 5 | Actual:

ES28: Modulo Operator

10 % 3: Expected: 1 | Actual:

15 % 5: Expected: 0 | Actual:

7 % 2: Expected: 1 | Actual:

ES29: Bitwise Operators

a = 5, b = 3

a & b (bitwise AND): Expected: 1 | Actual:

a | b (bitwise OR): Expected: 7 | Actual:

a ^ b (bitwise XOR): Expected: 6 | Actual:

ES30: Shift Operators

num = 8

num << 2 (left shift): Expected: 32 | Actual:

num >> 1 (right shift): Expected: 4 | Actual:

ES31: Assignment Operators

Initial x = 10

After x += 5: Expected: 15 | Actual:

After x *= 2 (from 10): Expected: 20 | Actual:

After x -= 3 (from 10): Expected: 7 | Actual:

ES32: Increment and Decrement

a = 5, ++a: Expected: 6 | Actual:

a++, then a: Expected: 7 | Actual:

b = 5, --b: Expected: 4 | Actual:

b--, then b: Expected: 3 | Actual:

ES33: String charCodeAt

String: "ABC"

charCodeAt(0): Expected: 65 | Actual:

charCodeAt(1): Expected: 66 | Actual:

charCodeAt(2): Expected: 67 | Actual:

ES34: Array sort

Array: [3, 1, 4, 1, 5]

After sort(): Expected: 1, 1, 3, 4, 5 | Actual:

ES35: Nested Objects

Nested object structure

person.address.city: Expected: New York | Actual:

person.address.zip: Expected: 10001 | Actual:

ES36: Function Expressions

square = function(x) { return x * x; }

square(5): Expected: 25 | Actual:

ES37: Multiple Return Statements

max(10, 7): Expected: 10 | Actual:

ES38: Variable Scope

global = 10, function has local = 20

testScope() returns: Expected: 30 | Actual:

ES39: Math Constants

Math.PI: Expected: 3.141592653589793 | Actual:

Math.E: Expected: 2.718281828459045 | Actual:

ES40: Date toString

new Date().toString(): Expected: [date string representation] | Actual:

ES41: String length

"Hello".length: Expected: 5 | Actual:

"World".length: Expected: 5 | Actual:

"".length: Expected: 0 | Actual:

ES42: Array push and pop

Array: [1, 2, 3]

After push(4), length: Expected: 4 | Actual:

pop() returned: Expected: 4 | Actual:

After pop(), length: Expected: 3 | Actual:

ES43: Array shift and unshift

Array: [2, 3, 4]

After unshift(1), length: Expected: 4 | Actual:

shift() returned: Expected: 1 | Actual:

After shift(), length: Expected: [number] | Actual:

ES44: Math round, floor, ceil

Math.round(3.7): Expected: [trigonometric/logarithmic result] | Actual:

Math.round(3.2): Expected: [trigonometric/logarithmic result] | Actual:

Math.floor(3.7): Expected: [trigonometric/logarithmic result] | Actual:

Math.ceil(3.2): Expected: [trigonometric/logarithmic result] | Actual:

ES45: Math pow and random

Math.pow(2, 3): Expected: [trigonometric/logarithmic result] | Actual:

Math.pow(5, 2): Expected: [trigonometric/logarithmic result] | Actual:

Math.random(): (should be 0-1)

ES46: Logical AND and OR

true && true: Expected: [boolean] | Actual:

true && false: Expected: [boolean] | Actual:

true || false: Expected: [boolean] | Actual:

false || false: Expected: [boolean] | Actual:

5 && 3: Expected: [see test code above] | Actual:

0 || 7: Expected: [see test code above] | Actual:

ES47: Ternary Operator

(5 > 3) ? "yes" : "no": Expected: [see test code above] | Actual:

(2 > 5) ? "yes" : "no": Expected: [see test code above] | Actual:

(10 > 5) ? 100 : 50: Expected: [see test code above] | Actual:

ES48: parseInt and parseFloat - PASS

parseInt("42"): Expected: [parsed number] | Actual:

parseInt("3.14"): Expected: [parsed number] | Actual:

parseFloat("3.14"): Expected: [parsed number] | Actual:

parseFloat("42"): Expected: [parsed number] | Actual:

ES49: String concat

str1 = "Hello", str2 = "World"

str1.concat(" ", str2): Expected: [array or string] | Actual:

"A".concat("B", "C"): Expected: [array or string] | Actual:

ES50: Array slice

Array: [1, 2, 3, 4, 5]

slice(1, 3): Expected: [array or string] | Actual:

slice(2): Expected: [array or string] | Actual:

ES51: Do-While Loop

do-while loop: sum from 0 to 4

Result: Expected: inner caught, outer caught | Actual:

ES52: Function Arguments

sum(1, 2, 3, 4, 5) using arguments: Expected: [see test code above] | Actual:

ES53: Recursive Function

factorial(5): Expected: [see test code above] | Actual:

ES54: Date getTime

new Date().getTime(): (milliseconds since epoch)

ES55: Object Property Deletion

obj.prop1 before delete: Expected: [see test code above] | Actual:

obj.prop1 after delete: Expected: [see test code above] | Actual:

obj.prop2 still exists: Expected: [see test code above] | Actual:

ES56: For-In Loop

Object properties: name, age, city

Properties found: Expected: [see test code above] | Actual:

ES57: Break Statement

Loop breaks when i > 5

Sum (0 to 5): Expected: [see test code above] | Actual:

ES58: Continue Statement

Continue skips even numbers

Sum of odd numbers (1,3,5,7,9): Expected: [see test code above] | Actual:

ES59: Global Functions - escape and unescape - PASS

Original: "Hello World!"

escaped: Expected: [encoded/decoded string] | Actual:

unescaped: Expected: [encoded/decoded string] | Actual:

ES60: Global Function - isNaN - PASS

isNaN("not a number"): Expected: [boolean] | Actual:

isNaN(42): Expected: [boolean] | Actual:

isNaN(NaN): Expected: [boolean] | Actual:

ES61: Array concat

Array 1: [1, 2, 3]

Array 2: [4, 5, 6]

concat result: Expected: [array or string] | Actual:

ES62: String split

String: "apple,banana,cherry"

split(",") result: Expected: [array of strings] | Actual:

ES63: With Statement

obj.x = 10, obj.y = 20

with (obj) { result = x + y; }

Result: Expected: inner caught, outer caught | Actual:

ES64: Void Operator

x = 42

void x: Expected: [see test code above] | Actual:

typeof void x: Expected: [see test code above] | Actual:

ES65: Comma Operator

a = 1, b = 2, c = 3

(a++, b++, c++) returns: Expected: 3 | Actual:

After comma: a + b + c = Expected: 9 | Actual:

ES66: Object toString

new Object().toString(): Expected: [string] | Actual:

ES67: Number toString

42.toString(): Expected: [string] | Actual:

3.14.toString(): Expected: [string] | Actual:

ES68: Boolean toString

true.toString(): Expected: [boolean] | Actual:

false.toString(): Expected: [boolean] | Actual:

ES69: This Keyword

obj.value = 100

Direct access obj.value: Expected: [see test code above] | Actual:

obj.getValue() using this: Expected: [see test code above] | Actual:

ES70: Array toString

Array: [1, 2, 3]

arr.toString(): Expected: [string] | Actual:

ES71: Null and Undefined Handling

nullVar = null

typeof null: Expected: [see test code above] | Actual:

typeof undefined: Expected: undefined | Actual:

nullVar == null: Expected: [see test code above] | Actual:

undefinedVar == undefined: Expected: [see test code above] | Actual:

ES72: Function length Property - FAIL

function testFunc(a, b, c) { ... }

testFunc.length: Expected: [number] | Actual:

ES73: RegExp Constructor

new RegExp("test"): Expected: [see test code above] | Actual:

new RegExp("hello", "i"): Expected: [see test code above] | Actual:

/pattern/: Expected: [see test code above] | Actual:

/test/gi: Expected: [see test code above] | Actual:

ES74: RegExp test() Method

Pattern: /hello/

test("hello world"): Expected: [boolean or array] | Actual:

test("goodbye"): Expected: [boolean or array] | Actual:

Pattern: /hello/i (case-insensitive)

test("HELLO"): Expected: [boolean or array] | Actual:

ES75: RegExp exec() Method

Pattern: /(\d+)/

exec("abc123def")[0]: Expected: [boolean or array] | Actual:

exec("no numbers"): Expected: [boolean or array] | Actual:

ES76: RegExp Properties - source, global, ignoreCase, multiline

Pattern: /test/gi

source: Expected: [see test code above] | Actual:

global: Expected: [see test code above] | Actual:

ignoreCase: Expected: [case result] | Actual:

multiline: Expected: [see test code above] | Actual:

Pattern: /pattern/m

multiline: Expected: [see test code above] | Actual:

ES77: RegExp lastIndex Property

Pattern: /test/g (global)

After first test(), lastIndex: Expected: [boolean or array] | Actual:

After second test(), lastIndex: Expected: [boolean or array] | Actual:

After setting lastIndex = 0: Expected: [see test code above] | Actual:

ES78: RegExp with String match()

String: "Hello World"

match(/o/)[0]: Expected: [match result] | Actual:

match(/x/): Expected: [match result] | Actual:

match(/o/g): Expected: [match result] | Actual:

ES79: RegExp with String search()

String: "Hello World"

search(/World/): Expected: [match result] | Actual:

search(/x/): Expected: [match result] | Actual:

search(/o/i): Expected: [match result] | Actual:

ES80: RegExp with String replace()

String: "Hello World"

replace(/World/, "Universe"): Expected: [match result] | Actual:

String: "test test test"

replace(/test/g, "TEST"): Expected: [match result] | Actual:

String: "abc123def456"

replace(/\d+/, "NUM"): Expected: abcNUMdef456 | Actual:

ES81: RegExp with String split()

String: "apple,banana,cherry"

split(/,/): Expected: [array of strings] | Actual:

String: "one two three"

split(/\s+/): Expected: one, two, three | Actual:

ES82: RegExp compile() Method

Pattern: new RegExp("test")

test("test string"): Expected: [boolean or array] | Actual:

After compile("hello", "i"):

test("HELLO"): Expected: [boolean or array] | Actual:

source: Expected: [see test code above] | Actual:

ES83: RegExp Capturing Groups

Pattern: /(\d+)-(\d+)/

exec("123-456")[0]: Expected: [match result] | Actual:

exec("123-456")[1]: Expected: [boolean or array] | Actual:

exec("123-456")[2]: Expected: [boolean or array] | Actual:

ES84: RegExp toString() Method

Pattern: /test/gi

toString(): Expected: [string] | Actual:

Pattern: new RegExp("hello", "m")

toString(): Expected: [string] | Actual:

ES85: Try-Catch Statement

try { var x = 10; var y = x + 5; } catch (e) { }

Result: Expected: [try-catch result] | Actual:

ES86: Try-Catch with Throw

try { throw "error message"; } catch (e) { }

Result: Expected: [thrown value] | Actual:

ES87: Try-Catch-Finally

try-catch-finally block

try result: Expected: [try-catch result] | Actual:

finally executed: Expected: [try-catch result] | Actual:

ES88: Try-Catch-Finally with Throw

try { throw "error"; } catch (e) { } finally { }

catch result: Expected: [thrown value] | Actual:

finally executed: Expected: [thrown value] | Actual:

ES89: Nested Try-Catch

Nested try-catch blocks

Result: Expected: inner caught, outer caught | Actual:

ES90: Instanceof Operator

arr instanceof Array: Expected: true | Actual:

obj instanceof Object: Expected: true | Actual:

str instanceof String: Expected: true | Actual:

arr instanceof Object: Expected: true | Actual:

obj instanceof Array: Expected: false | Actual:

ES91: In Operator

obj.name = "John", obj.age = 30

"name" in obj: Expected: [boolean] | Actual:

"age" in obj: Expected: [boolean] | Actual:

"city" in obj: Expected: [boolean] | Actual:

"0" in arr: Expected: [see test code above] | Actual:

"length" in arr: Expected: [number] | Actual:

ES92: Throw Statement

throw "test error": Expected: [Error object or string] | Actual:

throw 42: Expected: [thrown value] | Actual:

ES93: Error Object

new Error("test error")

Error name: Expected: [Error object or string] | Actual:

Error message: Expected: [Error object or string] | Actual:

Error toString(): Expected: [string] | Actual:

ES94: TypeError Object

new TypeError("type error")

TypeError name: Expected: [Error object or string] | Actual:

TypeError message: Expected: [Error object or string] | Actual:

ES95: RangeError Object

new RangeError("range error")

RangeError name: Expected: [Error object or string] | Actual:

RangeError message: Expected: [Error object or string] | Actual:

ES96: SyntaxError Object

new SyntaxError("syntax error")

SyntaxError name: Expected: [Error object or string] | Actual:

SyntaxError message: Expected: [Error object or string] | Actual:

ES97: ReferenceError Object

new ReferenceError("reference error")

ReferenceError name: Expected: [Error object or string] | Actual:

ReferenceError message: Expected: [Error object or string] | Actual:

ES98: URIError Object

new URIError("URI error")

URIError name: Expected: [Error object or string] | Actual:

URIError message: Expected: [Error object or string] | Actual:

ES99: EvalError Object

new EvalError("eval error")

EvalError name: Expected: [Error object or string] | Actual:

EvalError message: Expected: [Error object or string] | Actual:

ES100: Strict Equality (===)

5 === 5: Expected: [boolean] | Actual:

5 === "5": Expected: [boolean] | Actual:

null === null: Expected: [boolean] | Actual:

null === undefined: Expected: [boolean] | Actual:

true === true: Expected: [boolean] | Actual:

true === 1: Expected: [boolean] | Actual:

ES101: Strict Inequality (!==)

5 !== 5: Expected: [boolean] | Actual:

5 !== "5": Expected: [boolean] | Actual:

null !== null: Expected: [boolean] | Actual:

null !== undefined: Expected: [boolean] | Actual:

ES102: Switch Statement

switch (2) { case 1: ... case 2: ... case 3: ... default: ... }

Result: Expected: [case result] | Actual:

ES103: Switch Statement with Default

switch (99) with default case

Result: Expected: [case result] | Actual:

ES104: Switch Statement Fall-Through

switch (1) with fall-through

Result: Expected: [case result] | Actual:

ES105: Labeled Statements

Labeled loops with break

Result: Expected: [loop result] | Actual:

ES106: Labeled Break

break outer from inner loop

Result: Expected: [loop result] | Actual:

ES107: Labeled Continue

continue outer from inner loop

Result: Expected: [loop result] | Actual:

ES108: Number toFixed

3.14159.toFixed(2): Expected: [formatted number string] | Actual:

3.14159.toFixed(0): Expected: [formatted number string] | Actual:

3.14159.toFixed(5): Expected: [formatted number string] | Actual:

42.toFixed(2): Expected: [formatted number string] | Actual:

ES109: Number Constants

Number.MAX_VALUE: Expected: [number constant] | Actual:

Number.MIN_VALUE: Expected: [number constant] | Actual:

Number.NaN: Expected: [number constant] | Actual:

Number.POSITIVE_INFINITY: Expected: [number constant] | Actual:

Number.NEGATIVE_INFINITY: Expected: [number constant] | Actual:

ES110: Array splice

Array: [1, 2, 3, 4, 5]

After splice(1, 2): Expected: 1, 4, 5 | Actual:

Removed: Expected: 2, 3 | Actual:

Array: ["a", "b", "c", "d"]

After splice(1, 1, "x", "y"): Expected: a, x, y, c, d | Actual:

ES111: String fromCharCode

String.fromCharCode(65, 66, 67): Expected: [string from char codes] | Actual:

String.fromCharCode(72, 101, 108, 108, 111): Expected: [string from char codes] | Actual:

ES112: String localeCompare

"apple".localeCompare("banana"): Expected: [number: -1, 0, or 1] | Actual:

"banana".localeCompare("apple"): Expected: [number: -1, 0, or 1] | Actual:

"apple".localeCompare("apple"): Expected: [number: -1, 0, or 1] | Actual:

ES113: Function call Method

function greet(name) { return "Hello, " + name; }

greet.call(obj, "John"): Expected: [return value] | Actual:

greet.call(null, "Jane"): Expected: [return value] | Actual:

ES114: Function apply Method

function sum(a, b, c) { return a + b + c; }

sum.apply(null, [1, 2, 3]): Expected: [return value] | Actual:

sum.apply(null, [10, 20, 30]): Expected: [return value] | Actual:

ES115: Function call with This

obj.value = 100, function getValue() { return this.value; }

getValue.call(obj): Expected: [return value] | Actual:

ES116: Boolean Constructor

new Boolean(true): Expected: true | Actual:

new Boolean(false): Expected: false | Actual:

new Boolean(1): Expected: true | Actual:

new Boolean(0): Expected: false | Actual:

ES117: Number Constructor

new Number(42).valueOf(): Expected: [primitive value] | Actual:

new Number(3.14).valueOf(): Expected: [primitive value] | Actual:

new Number(42).toString(): Expected: [string] | Actual:

ES118: String Constructor

new String("Hello").valueOf(): Expected: [primitive value] | Actual:

new String(42).valueOf(): Expected: [primitive value] | Actual:

new String("Hello").length: Expected: [number] | Actual:

ES119: Object Methods - hasOwnProperty

obj.name = "John"

obj.hasOwnProperty("name"): Expected: [boolean] | Actual:

obj.hasOwnProperty("toString"): Expected: [string] | Actual:

obj.hasOwnProperty("nonexistent"): Expected: [boolean] | Actual:

ES120: Object Methods - propertyIsEnumerable

obj.name = "John"

obj.propertyIsEnumerable("name"): Expected: [boolean] | Actual:

obj.propertyIsEnumerable("toString"): Expected: [string] | Actual:

ES121: Object Methods - isPrototypeOf

Parent.prototype.isPrototypeOf(child): Expected: [boolean] | Actual:

Object.prototype.isPrototypeOf(child): Expected: [boolean] | Actual:

ES122: More Math Methods - Trigonometric

Math.sin(0): Expected: [trigonometric/logarithmic result] | Actual:

Math.cos(0): Expected: [trigonometric/logarithmic result] | Actual:

Math.tan(0): Expected: [trigonometric/logarithmic result] | Actual:

Math.asin(0): Expected: [trigonometric/logarithmic result] | Actual:

Math.acos(1): Expected: [trigonometric/logarithmic result] | Actual:

Math.atan(0): Expected: [trigonometric/logarithmic result] | Actual:

Math.atan2(0, 1): Expected: [trigonometric/logarithmic result] | Actual:

ES123: More Math Methods - Logarithmic

Math.log(Math.E): Expected: [trigonometric/logarithmic result] | Actual:

Math.log(1): Expected: [trigonometric/logarithmic result] | Actual:

Math.exp(1): Expected: [trigonometric/logarithmic result] | Actual:

Math.exp(0): Expected: [trigonometric/logarithmic result] | Actual:

ES124: More Math Constants

Math.LN2: Expected: [trigonometric/logarithmic result] | Actual:

Math.LN10: Expected: [trigonometric/logarithmic result] | Actual:

Math.LOG2E: Expected: [trigonometric/logarithmic result] | Actual:

Math.LOG10E: Expected: [trigonometric/logarithmic result] | Actual:

Math.SQRT1_2: Expected: [trigonometric/logarithmic result] | Actual:

Math.SQRT2: Expected: [trigonometric/logarithmic result] | Actual:

ES125: More Date Methods - Setters

Date setters

After setYear(2001), getYear(): Expected: [updated date value] | Actual:

After setMonth(5), getMonth(): Expected: [updated date value] | Actual:

After setDate(15), getDate(): Expected: [number or date string] | Actual:

ES126: Date parse Method

Date.parse("2000-01-01"): Expected: [number or date string] | Actual:

Type: Expected: [see test code above] | Actual:

ES127: Global isFinite Function

isFinite(42): Expected: [boolean] | Actual:

isFinite(Infinity): Expected: [boolean] | Actual:

isFinite(-Infinity): Expected: [boolean] | Actual:

isFinite(NaN): Expected: [boolean] | Actual:

isFinite("42"): Expected: [boolean] | Actual:

ES128: parseInt with Radix

parseInt("10", 10): Expected: [parsed number] | Actual:

parseInt("10", 2): Expected: [parsed number] | Actual:

parseInt("10", 8): Expected: [parsed number] | Actual:

parseInt("10", 16): Expected: [parsed number] | Actual:

parseInt("FF", 16): Expected: [parsed number] | Actual:

ES129: More String Methods - slice

String: "Hello World"

slice(0, 5): Expected: [array or string] | Actual:

slice(6): Expected: [array or string] | Actual:

slice(-5): Expected: [array or string] | Actual:

slice(0, -6): Expected: [array or string] | Actual:

ES130: More String Methods - substr

String: "Hello World"

substr(0, 5): Expected: [see test code above] | Actual:

substr(6): Expected: [see test code above] | Actual:

substr(6, 3): Expected: [see test code above] | Actual:

Graceful Failure (ECMAScript)

These rows document deliberate faults. Many are EXPECTED to report failure or to skip code; the browser must remain stable and later sections of this page must still run.

ES131: SCRIPT parse error isolated — EXPECT: following paragraph still appears

The next SCRIPT block contains a syntax error. If this explanation text is visible after loading, the parser did not abort the entire document.

ES131 recovery line: visible means markup after broken SCRIPT still rendered.

ES132: SCRIPT after broken SCRIPT — EXPECT: variable neg_es132_ok is 1

neg_es132_ok = Expected: 1 | Actual:

ES133: eval() syntax error caught — EXPECT: Reference or Syntax error name

Error name: Expected: SyntaxError (or similar) | Actual:

ES134: ReferenceError caught — EXPECT: ReferenceError

Error name: Expected: ReferenceError | Actual:

ES135: TypeError caught — EXPECT: TypeError

Error name: Expected: TypeError | Actual:

Compatibility Summary

This page tests ECMAScript 3 core language features only. For browser extension tests (window, document, forms, events), see javascript_test.html.

Back to top