public void decodeURI()
{
Assert.AreEqual("abc", TestUtils.Evaluate("decodeURI('abc')"));
Assert.AreEqual("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789;/?:@&=+$,-_.!~*'()#",
TestUtils.Evaluate("decodeURI('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789;/?:@&=+$,-_.!~*\\'()#')"));
Assert.AreEqual("%3F", TestUtils.Evaluate("decodeURI('%3F')"));
Assert.AreEqual("%2f", TestUtils.Evaluate("decodeURI('%2f')"));
Assert.AreEqual("%23", TestUtils.Evaluate("decodeURI('%23')"));
Assert.AreEqual("!", TestUtils.Evaluate("decodeURI('%21')"));
Assert.AreEqual("^", TestUtils.Evaluate("decodeURI('%5e')"));
Assert.AreEqual("^", TestUtils.Evaluate("decodeURI('^')"));
Assert.AreEqual("Ҧ", TestUtils.Evaluate("decodeURI('Ҧ')"));
Assert.AreEqual("Ҧ", TestUtils.Evaluate("decodeURI('%D2%A6')"));
Assert.AreEqual("Ҧa", TestUtils.Evaluate("decodeURI('%D2%A6a')"));
Assert.AreEqual("ᵝ", TestUtils.Evaluate("decodeURI('%E1%B5%9D')"));
Assert.AreEqual("\U0001D11E", TestUtils.Evaluate("decodeURI('%F0%9D%84%9E')"));
Assert.AreEqual("URIError", TestUtils.EvaluateExceptionType("decodeURI('%B')"));
Assert.AreEqual("URIError", TestUtils.EvaluateExceptionType("decodeURI('%H5')"));
Assert.AreEqual("URIError", TestUtils.EvaluateExceptionType("decodeURI('%B5')"));
Assert.AreEqual("URIError", TestUtils.EvaluateExceptionType("decodeURI('%F8')"));
Assert.AreEqual("URIError", TestUtils.EvaluateExceptionType("decodeURI('%E1')"));
Assert.AreEqual("URIError", TestUtils.EvaluateExceptionType("decodeURI('%E1%B5')"));
Assert.AreEqual("URIError", TestUtils.EvaluateExceptionType("decodeURI('%E1%E1%9D')"));
if (TestUtils.Engine != JSEngine.JScript)
{
Assert.AreEqual("URIError", TestUtils.EvaluateExceptionType("decodeURI('%C0%A6')")); // Test is buggy in JScript.
}
}
public void Do()
{
Assert.AreEqual(7, TestUtils.Evaluate("x = 1; do { x = x + 3 } while (x < 5); x"));
Assert.AreEqual(9, TestUtils.Evaluate("x = 6; do { x = x + 3 } while (x < 5); x"));
Assert.AreEqual(5, TestUtils.Evaluate("x = 1; do { x = x + 1 } while (x < 5)"));
Assert.AreEqual(5, TestUtils.Evaluate("5; do { } while(false)"));
}
public void eval()
{
Assert.AreEqual(Undefined.Value, TestUtils.Evaluate("eval()"));
Assert.AreEqual(5, TestUtils.Evaluate("eval(5)"));
Assert.AreEqual(true, TestUtils.Evaluate("var x = {}; eval(x) === x;"));
Assert.AreEqual(true, TestUtils.Evaluate("var x = {}; e = eval; e(x) === x;"));
Assert.AreEqual(1, TestUtils.Evaluate("eval('Math.abs(-1)')"));
// The lexical environment does not change inside an eval if it is a direct call.
Assert.AreEqual(5, TestUtils.Evaluate("(function() { var a = 5; return eval('a'); })()"));
Assert.AreEqual(6, TestUtils.Evaluate("(function() { var a = 5; eval('a = 6'); return a; })()"));
// Variables should not be reinitialized.
Assert.AreEqual(0, TestUtils.Evaluate("var x = 0; eval('var x'); x"));
// Eval() can introduce new variables into a function scope.
Assert.AreEqual(5, TestUtils.Evaluate("b = 1; (function() { var a = 5; eval('var b = a'); return b; })()"));
Assert.AreEqual(1, TestUtils.Evaluate("b = 1; (function() { var a = 5; eval('var b = a'); b = 4; })(); b;"));
Assert.AreEqual(8, TestUtils.Evaluate("(function() { eval('var b = 8'); return eval('b'); })();"));
// The global lexical environment is used for a non-direct call.
Assert.AreEqual(5, TestUtils.Evaluate("e = eval; (function() { var a = 5; e('a = 6'); return a; })()"));
Assert.AreEqual(1, TestUtils.Evaluate("e = eval; a = 1; (function() { var a = 5; return e('a'); })()"));
Assert.AreEqual(3, TestUtils.Evaluate("e = eval; a = 3; b = 2; (function() { var a = 5; e('var b = a'); return b; })()"));
Assert.AreEqual(3, TestUtils.Evaluate("e = eval; a = 3; b = 2; (function() { var a = 5; e('var b = a'); })(); b"));
// Strict mode: eval has it's own scope.
TestUtils.Evaluate("delete a");
Assert.AreEqual("undefined", TestUtils.Evaluate("'use strict'; eval('var a = false'); typeof a"));
Assert.AreEqual("undefined", TestUtils.Evaluate(@"eval(""'use strict'; var a = false""); typeof a"));
// Return is not allowed.
Assert.AreEqual("SyntaxError", TestUtils.EvaluateExceptionType("e = eval; (function() { var a = 5; e('return a'); })()"));
}
public void hasOwnProperty()
{
Assert.AreEqual(true, TestUtils.Evaluate("String.prototype.hasOwnProperty('split')"));
Assert.AreEqual(false, TestUtils.Evaluate("new String('test').hasOwnProperty('split')"));
TestUtils.Evaluate("var x = new String('sdf');");
TestUtils.Evaluate("x.testing = 5;");
Assert.AreEqual(true, TestUtils.Evaluate("x.hasOwnProperty('testing')"));
Assert.AreEqual(false, TestUtils.Evaluate("x.hasOwnProperty('Testing')"));
Assert.AreEqual(false, TestUtils.Evaluate("x.hasOwnProperty('split')"));
Assert.AreEqual(true, TestUtils.Evaluate("Math.hasOwnProperty('cos')"));
Assert.AreEqual(true, TestUtils.Evaluate("Math.hasOwnProperty('E')"));
Assert.AreEqual(true, TestUtils.Evaluate("x = function() { this.a = 5; }; x.prototype = { b: 2 }; y = new x(); y.hasOwnProperty('a')"));
Assert.AreEqual(false, TestUtils.Evaluate("x = function() { this.a = 5; }; x.prototype = { b: 2 }; y = new x(); y.hasOwnProperty('b')"));
Assert.AreEqual(true, TestUtils.Evaluate("Math.hasOwnProperty({toString: function() { return 'max' }})"));
// length
Assert.AreEqual(1, TestUtils.Evaluate("Math.hasOwnProperty.length"));
// "this" object must be convertible to object.
Assert.AreEqual("TypeError", TestUtils.EvaluateExceptionType("Math.hasOwnProperty.call(undefined, 'max')"));
Assert.AreEqual("TypeError", TestUtils.EvaluateExceptionType("Math.hasOwnProperty.call(null, 'max')"));
// First parameter must be convertible to string.
Assert.AreEqual("Error", TestUtils.EvaluateExceptionType("Math.hasOwnProperty({toString: function() { throw new Error('test') }})"));
Assert.AreEqual("Error", TestUtils.EvaluateExceptionType("Math.hasOwnProperty.call(undefined, {toString: function() { throw new Error('test') }})"));
}
public void Call()
{
// RegExp
Assert.AreEqual("", TestUtils.Evaluate("RegExp().source"));
Assert.AreEqual("", TestUtils.Evaluate("RegExp(undefined).source"));
// RegExp(pattern)
TestUtils.Evaluate("var x = RegExp('abc')");
Assert.AreEqual("abc", TestUtils.Evaluate("x.source"));
Assert.AreEqual(false, TestUtils.Evaluate("x.global"));
Assert.AreEqual(false, TestUtils.Evaluate("x.ignoreCase"));
Assert.AreEqual(false, TestUtils.Evaluate("x.multiline"));
Assert.AreEqual(0, TestUtils.Evaluate("x.lastIndex"));
// RegExp(pattern, flags)
TestUtils.Evaluate("var x = RegExp('abc', 'g')");
Assert.AreEqual("abc", TestUtils.Evaluate("x.source"));
Assert.AreEqual(true, TestUtils.Evaluate("x.global"));
Assert.AreEqual(false, TestUtils.Evaluate("x.ignoreCase"));
Assert.AreEqual(false, TestUtils.Evaluate("x.multiline"));
Assert.AreEqual(0, TestUtils.Evaluate("x.lastIndex"));
// RegExp(regExp)
TestUtils.Evaluate("var x = RegExp(new RegExp('abc', 'g'))");
Assert.AreEqual("abc", TestUtils.Evaluate("x.source"));
Assert.AreEqual(true, TestUtils.Evaluate("x.global"));
Assert.AreEqual(false, TestUtils.Evaluate("x.ignoreCase"));
Assert.AreEqual(false, TestUtils.Evaluate("x.multiline"));
Assert.AreEqual(true, TestUtils.Evaluate("x === RegExp(x)"));
Assert.AreEqual(0, TestUtils.Evaluate("x.lastIndex"));
// RegExp(regExp, flags)
Assert.AreEqual(TestUtils.Engine == JSEngine.JScript ? "RegExpError" : "TypeError",
TestUtils.EvaluateExceptionType("RegExp(new RegExp('abc', 'g'), 'i')"));
}
public void toExponential()
{
Assert.AreEqual("0e+0", TestUtils.Evaluate("0 .toExponential()"));
Assert.AreEqual("0.00e+0", TestUtils.Evaluate("0 .toExponential(2)"));
Assert.AreEqual("7.71234e+1", TestUtils.Evaluate("77.1234.toExponential()"));
Assert.AreEqual("7.7123e+1", TestUtils.Evaluate("77.1234.toExponential(4)"));
Assert.AreEqual("7.71e+1", TestUtils.Evaluate("77.1234.toExponential(2)"));
Assert.AreEqual("8e+1", TestUtils.Evaluate("77.1234.toExponential(0)"));
Assert.AreEqual("7.71234e+1", TestUtils.Evaluate("77.1234.toExponential()"));
Assert.AreEqual("8e+1", TestUtils.Evaluate("77.1234.toExponential(0)"));
Assert.AreEqual("7.7e+1", TestUtils.Evaluate("77 .toExponential()"));
Assert.AreEqual("5e-16", TestUtils.Evaluate("5e-16.toExponential()"));
Assert.AreEqual("5.000e-16", TestUtils.Evaluate("5e-16.toExponential(3)"));
Assert.AreEqual("1e+1", TestUtils.Evaluate("9.9.toExponential(0)"));
Assert.AreEqual("1.2345678901234568e+18", TestUtils.Evaluate("1234567890123456789 .toExponential()"));
Assert.AreEqual("1.23456789012345676800e+18", TestUtils.Evaluate("1234567890123456789 .toExponential(20)"));
Assert.AreEqual("5e-324", TestUtils.Evaluate("Number.MIN_VALUE.toExponential()"));
Assert.AreEqual("4.94e-324", TestUtils.Evaluate("Number.MIN_VALUE.toExponential(2)"));
Assert.AreEqual("1.80e+308", TestUtils.Evaluate("Number.MAX_VALUE.toExponential(2)"));
Assert.AreEqual("Infinity", TestUtils.Evaluate("Number.POSITIVE_INFINITY.toExponential()"));
Assert.AreEqual("-Infinity", TestUtils.Evaluate("Number.NEGATIVE_INFINITY.toExponential()"));
Assert.AreEqual("NaN", TestUtils.Evaluate("NaN.toExponential()"));
// Negative tests.
Assert.AreEqual("RangeError", TestUtils.EvaluateExceptionType("77.1234.toExponential(-1)"));
Assert.AreEqual("RangeError", TestUtils.EvaluateExceptionType("77.1234.toExponential(21)"));
// length
Assert.AreEqual(1, TestUtils.Evaluate("NaN.toExponential.length"));
}
public void TypeInference1()
{
// Simple type inference: both "i" and "x" can be inferred to be integers.
Assert.AreEqual(4, TestUtils.Evaluate(@"
function f() {
var x = 5;
for (var i = 1; i < 10; i ++)
x = x ^ i;
return x;
}
f()"));
// Simple type inference:
// "i" can be inferred to be an integer.
// "x" can be inferred to be a number.
Assert.AreEqual(362880, TestUtils.Evaluate(@"
function f() {
var x = 1;
for (var i = 1; i < 10; i ++)
x = x * i;
return x;
}
f()"));
Assert.AreEqual(362880, TestUtils.Evaluate(@"
function f(x) {
for (var i = 1; i < 10; i ++)
x = x * i;
return x;
}
f(1)"));
// "x" can be inferred to be a number, but only by analysing the whole function and
// not just the loop.
Assert.AreEqual(19, TestUtils.Evaluate(@"
function f() {
var x = 1;
for (var i = 1; i < 10; i ++)
x = x + 2;
return x;
}
f()"));
// Now "x" cannot be inferred without whole-program analysis.
Assert.AreEqual(19, TestUtils.Evaluate(@"
function f(x) {
for (var i = 1; i < 10; i ++)
x = x + 2;
return x;
}
f(1)"));
// "x" can be inferred to be a string.
Assert.AreEqual("1*********", TestUtils.Evaluate(@"
function f(x) {
for (var i = 1; i < 10; i ++)
x = x + '*';
return x;
}
f(1)"));
}
public void Properties()
{
// Number constants.
Assert.AreEqual(double.MaxValue, TestUtils.Evaluate("Number.MAX_VALUE"));
Assert.AreEqual(double.Epsilon, TestUtils.Evaluate("Number.MIN_VALUE"));
Assert.AreEqual(double.NaN, TestUtils.Evaluate("Number.NaN"));
Assert.AreEqual(double.NegativeInfinity, TestUtils.Evaluate("Number.NEGATIVE_INFINITY"));
Assert.AreEqual(double.PositiveInfinity, TestUtils.Evaluate("Number.POSITIVE_INFINITY"));
// Constants are non-enumerable, non-configurable, non-writable.
Assert.AreEqual(double.MaxValue, TestUtils.Evaluate("Number.MAX_VALUE = 5; Number.MAX_VALUE"));
Assert.AreEqual(false, TestUtils.Evaluate("delete Number.MAX_VALUE"));
Assert.AreEqual(double.MaxValue, TestUtils.Evaluate("delete Number.MAX_VALUE; Number.MAX_VALUE"));
// Constructor and __proto__
Assert.AreEqual(true, TestUtils.Evaluate("new Number().constructor === Number"));
if (TestUtils.Engine != JSEngine.JScript)
{
Assert.AreEqual(true, TestUtils.Evaluate("Object.getPrototypeOf(new Number()) === Number.prototype"));
}
// No initial enumerable properties.
Assert.AreEqual("", TestUtils.Evaluate("y = ''; for (var x in Number) { y += x } y"));
Assert.AreEqual("", TestUtils.Evaluate("y = ''; for (var x in new Number(5)) { y += x } y"));
Assert.AreEqual("", TestUtils.Evaluate("y = ''; for (var x in 5) { y += x } y"));
}
public void Constructor()
{
// Construct
Assert.AreEqual(0, TestUtils.Evaluate("new Number().valueOf()"));
Assert.AreEqual(double.NaN, TestUtils.Evaluate("new Number(undefined).valueOf()"));
Assert.AreEqual(0, TestUtils.Evaluate("new Number(null).valueOf()"));
Assert.AreEqual(1, TestUtils.Evaluate("new Number(true).valueOf()"));
Assert.AreEqual(5, TestUtils.Evaluate("new Number(5).valueOf()"));
Assert.AreEqual(5.1, TestUtils.Evaluate("new Number(5.1).valueOf()"));
Assert.AreEqual(double.NaN, TestUtils.Evaluate("new Number(NaN).valueOf()"));
Assert.AreEqual(123, TestUtils.Evaluate("new Number('123').valueOf()"));
// Call
Assert.AreEqual(0, TestUtils.Evaluate("Number()"));
Assert.AreEqual(double.NaN, TestUtils.Evaluate("Number(undefined)"));
Assert.AreEqual(0, TestUtils.Evaluate("Number(null)"));
Assert.AreEqual(1, TestUtils.Evaluate("Number(true)"));
Assert.AreEqual(5, TestUtils.Evaluate("Number(5)"));
Assert.AreEqual(5.1, TestUtils.Evaluate("Number(5.1)"));
Assert.AreEqual(double.NaN, TestUtils.Evaluate("Number(NaN)"));
Assert.AreEqual(123, TestUtils.Evaluate("Number('123')"));
Assert.AreEqual(0, TestUtils.Evaluate("Number('')"));
Assert.AreEqual(0, TestUtils.Evaluate("Number(' ')"));
Assert.AreEqual(0, TestUtils.Evaluate("Number('\u00A0')"));
// toString and valueOf.
Assert.AreEqual("function Number() { [native code] }", TestUtils.Evaluate("Number.toString()"));
Assert.AreEqual(true, TestUtils.Evaluate("Number.valueOf() === Number"));
// length
Assert.AreEqual(1, TestUtils.Evaluate("Number.length"));
}
public void toLocaleString()
{
if (TestUtils.Engine != JSEngine.JScript)
{
Assert.AreEqual("77", TestUtils.Evaluate("77 .toLocaleString()"));
Assert.AreEqual("77.5", TestUtils.Evaluate("77.5.toLocaleString()"));
// English.
Assert.AreEqual("77.123", TestUtils.ChangeLocale("en-NZ", () => TestUtils.Evaluate("77.123.toLocaleString()")));
Assert.AreEqual("7.7e+101", TestUtils.ChangeLocale("en-NZ", () => TestUtils.Evaluate("77e100 .toLocaleString()")));
Assert.AreEqual("123456789", TestUtils.ChangeLocale("en-NZ", () => TestUtils.Evaluate("123456789 .toLocaleString()")));
Assert.AreEqual("-500", TestUtils.ChangeLocale("en-NZ", () => TestUtils.Evaluate("(-500).toLocaleString()")));
// Spanish.
Assert.AreEqual("77,123", TestUtils.ChangeLocale("es-ES", () => TestUtils.Evaluate("77.123.toLocaleString()")));
Assert.AreEqual("7,7e+101", TestUtils.ChangeLocale("es-ES", () => TestUtils.Evaluate("77e100 .toLocaleString()")));
Assert.AreEqual("123456789", TestUtils.ChangeLocale("es-ES", () => TestUtils.Evaluate("123456789 .toLocaleString()")));
Assert.AreEqual("-500", TestUtils.ChangeLocale("es-ES", () => TestUtils.Evaluate("(-500).toLocaleString()")));
}
Assert.AreEqual("Infinity", TestUtils.Evaluate("Infinity.toLocaleString()"));
Assert.AreEqual("-Infinity", TestUtils.Evaluate("(-Infinity).toLocaleString()"));
Assert.AreEqual("NaN", TestUtils.Evaluate("NaN.toLocaleString()"));
// length
Assert.AreEqual(0, TestUtils.Evaluate("NaN.toLocaleString.length"));
}
public void ForIn()
{
// for (x in <expression>)
Assert.AreEqual("ab", TestUtils.Evaluate("y = ''; for (x in {a: 1, b: 2}) { y += x } y"));
Assert.AreEqual("1", TestUtils.Evaluate("y = 0; for (x in [7, 5]) { y = x } y"));
Assert.AreEqual(0, TestUtils.Evaluate("x = 0; for (x in null) { x = 1 } x"));
Assert.AreEqual(0, TestUtils.Evaluate("x = 0; for (x in undefined) { x = 1 } x"));
Assert.AreEqual("ReferenceError", TestUtils.EvaluateExceptionType("for (5 in [1, 2]) {}"));
// for (var x in <expression>)
Assert.AreEqual("1", TestUtils.Evaluate("y = 0; for (var x in [7, 5]) { y = x } y"));
Assert.AreEqual("01234", TestUtils.Evaluate("y = ''; for (var x in 'hello') { y += x } y"));
Assert.AreEqual("SyntaxError", TestUtils.EvaluateExceptionType("for (var 5 in [1, 2])"));
// All properties in the prototype chain should be enumerated, but the same property
// name is never enumerated twice. Properties in the prototype chain with the same
// name are shadowed and therefore are not enumerated.
Assert.AreEqual("b,c", TestUtils.Evaluate("y = []; for (var x in Object.create({a:1, b:2, c:3}, {a:{value:4}, b:{value:5, enumerable:true}})) { y.push(x) } y.toString()"));
// Properties are not enumerated if they have been deleted.
Assert.AreEqual("a,b", TestUtils.Evaluate("y = []; z = {a:1, b:2, c:3}; for (var x in z) { y.push(x); delete z.c; } y.toString()"));
// Adding a property while enumerating it should return the keys as they were originally.
Assert.AreEqual("bc", TestUtils.Evaluate("var a = {b: 2, c: 3}; var keys = ''; for (var x in a) { a.d = 5; keys += x; }"));
// Strict mode: the name "eval" is not allowed in strict mode.
Assert.AreEqual("SyntaxError", TestUtils.EvaluateExceptionType("'use strict'; for (var eval in {a:1}) {}"));
}
public new void ToString()
{
var engine = new ScriptEngine();
Assert.AreEqual("undefined", TypeConverter.ToString(Undefined.Value));
Assert.AreEqual("undefined", TypeConverter.ToString(null));
Assert.AreEqual("null", TypeConverter.ToString(Null.Value));
Assert.AreEqual("false", TypeConverter.ToString(false));
Assert.AreEqual("true", TypeConverter.ToString(true));
Assert.AreEqual("0", TypeConverter.ToString(+0.0));
Assert.AreEqual("0", TypeConverter.ToString(-0.0));
Assert.AreEqual("1", TypeConverter.ToString(1.0));
Assert.AreEqual("13.9", TypeConverter.ToString(13.9));
Assert.AreEqual("6442450954", TypeConverter.ToString(6442450954.0));
Assert.AreEqual("NaN", TypeConverter.ToString(double.NaN));
Assert.AreEqual("", TypeConverter.ToString(""));
Assert.AreEqual("false", TypeConverter.ToString(engine.Boolean.Construct(false)));
Assert.AreEqual("true", TypeConverter.ToString(engine.Boolean.Construct(true)));
Assert.AreEqual(TestUtils.Evaluate("new Date(0).toString()"), TypeConverter.ToString(engine.Date.Construct(0.0))); // Note: exact string is time-zone specific.
Assert.AreEqual("Invalid Date", TypeConverter.ToString(engine.Date.Construct(double.NaN)));
Assert.AreEqual("0", TypeConverter.ToString(engine.Number.Construct(0.0)));
Assert.AreEqual("1", TypeConverter.ToString(engine.Number.Construct(1.0)));
Assert.AreEqual("[object Object]", TypeConverter.ToString(engine.Object.Construct()));
Assert.AreEqual("", TypeConverter.ToString(engine.String.Construct("")));
Assert.AreEqual("test", TypeConverter.ToString(engine.String.Construct("test")));
}
public void parseArray()
{
// Arrays
Assert.AreEqual("", TestUtils.Evaluate("JSON.parse('[]').toString()"));
Assert.AreEqual(0, TestUtils.Evaluate("JSON.parse('[]').length"));
Assert.AreEqual("1,2,3", TestUtils.Evaluate("JSON.parse('[1, 2, 3]').toString()"));
Assert.AreEqual(3, TestUtils.Evaluate("JSON.parse('[1,2,3]').length"));
// Nested arrays
Assert.AreEqual("1,2", TestUtils.Evaluate("JSON.parse('[[1 , 2]]').toString()"));
Assert.AreEqual(1, TestUtils.Evaluate("JSON.parse('[[1 , 2]]').length"));
Assert.AreEqual(2, TestUtils.Evaluate("JSON.parse('[[1 , 2]]')[0].length"));
// With reviver.
Assert.AreEqual("2,3,41", TestUtils.Evaluate(@"JSON.parse('[1,2,3]', function(name, value) { return this[name] + 1 })"));
Assert.AreEqual("2,3,41", TestUtils.Evaluate(@"JSON.parse('[1,2,3]', function(name, value) { return value + 1 })"));
Assert.AreEqual("1,,3", TestUtils.Evaluate(@"JSON.parse('[1,2,3]', function(name, value) { return value == 2 ? undefined : value }).toString()"));
// Invalid arrays
Assert.AreEqual("SyntaxError", TestUtils.EvaluateExceptionType("JSON.parse('[')"));
Assert.AreEqual("SyntaxError", TestUtils.EvaluateExceptionType("JSON.parse('[5')"));
Assert.AreEqual("SyntaxError", TestUtils.EvaluateExceptionType("JSON.parse('[,]')"));
Assert.AreEqual("SyntaxError", TestUtils.EvaluateExceptionType("JSON.parse('[5,]')"));
Assert.AreEqual("SyntaxError", TestUtils.EvaluateExceptionType("JSON.parse('[,5]')"));
Assert.AreEqual("SyntaxError", TestUtils.EvaluateExceptionType("JSON.parse('[5,,5]')"));
}
public void getTimezoneOffset()
{
var offsetInMinutes = (int)-TimeZoneInfo.Local.GetUtcOffset(new DateTime(2010, 4, 24, 23, 59, 57)).TotalMinutes;
Assert.AreEqual(offsetInMinutes, TestUtils.Evaluate("new Date('24 Apr 2010 23:59:57').getTimezoneOffset()"));
Assert.AreEqual(0, TestUtils.Evaluate("new Date('24 Apr 2010 23:59:57').getTimezoneOffset.length"));
}
public void pow()
{
Assert.AreEqual(4, TestUtils.Evaluate("Math.pow(2, 2)"));
Assert.AreEqual(Math.Pow(2.5, 2.5), TestUtils.Evaluate("Math.pow(2.5, 2.5)"));
Assert.AreEqual(1, TestUtils.Evaluate("Math.pow(0, 0)"));
Assert.AreEqual(1, TestUtils.Evaluate("Math.pow(1, 0)"));
Assert.AreEqual(double.PositiveInfinity, TestUtils.Evaluate("Math.pow(0, -1)"));
Assert.AreEqual(1, TestUtils.Evaluate("Math.pow(-1, 0)"));
Assert.AreEqual(0, TestUtils.Evaluate("Math.pow(0, 1)"));
Assert.AreEqual(0, TestUtils.Evaluate("Math.pow(0, Infinity)"));
Assert.AreEqual(double.NaN, TestUtils.Evaluate("Math.pow(1, Infinity)"));
Assert.AreEqual(double.NaN, TestUtils.Evaluate("Math.pow(1, -Infinity)"));
Assert.AreEqual(double.NaN, TestUtils.Evaluate("Math.pow(-1, Infinity)"));
Assert.AreEqual(double.NaN, TestUtils.Evaluate("Math.pow(-1, -Infinity)"));
Assert.AreEqual(double.PositiveInfinity, TestUtils.Evaluate("Math.pow(2, Infinity)"));
Assert.AreEqual(0, TestUtils.Evaluate("Math.pow(2, -Infinity)"));
Assert.AreEqual(double.PositiveInfinity, TestUtils.Evaluate("Math.pow(Infinity, Infinity)"));
Assert.AreEqual(0, TestUtils.Evaluate("Math.pow(Infinity, -Infinity)"));
Assert.AreEqual(1, TestUtils.Evaluate("Math.pow(Infinity, 0)"));
Assert.AreEqual(1, TestUtils.Evaluate("Math.pow(-Infinity, 0)"));
Assert.AreEqual(1, TestUtils.Evaluate("Math.pow(NaN, 0)"));
Assert.AreEqual(double.NaN, TestUtils.Evaluate("Math.pow(NaN, 1)"));
Assert.AreEqual(double.NaN, TestUtils.Evaluate("Math.pow(0, NaN)"));
Assert.AreEqual(double.NaN, TestUtils.Evaluate("Math.pow(0, undefined)"));
Assert.AreEqual(double.NaN, TestUtils.Evaluate("Math.pow('bob', 'bob')"));
}
public void round()
{
Assert.AreEqual(1, TestUtils.Evaluate("Math.round(0.5)"));
Assert.AreEqual(1, TestUtils.Evaluate("Math.round(1.0)"));
Assert.AreEqual(1, TestUtils.Evaluate("Math.round(1.2)"));
Assert.AreEqual(2, TestUtils.Evaluate("Math.round(1.6)"));
Assert.AreEqual(2, TestUtils.Evaluate("Math.round(1.5)"));
Assert.AreEqual(3, TestUtils.Evaluate("Math.round(2.5)"));
Assert.AreEqual(0, TestUtils.Evaluate("Math.round(-0.5)"));
Assert.AreEqual(-1, TestUtils.Evaluate("Math.round(-1.0)"));
Assert.AreEqual(-1, TestUtils.Evaluate("Math.round(-1.2)"));
Assert.AreEqual(-2, TestUtils.Evaluate("Math.round(-1.6)"));
Assert.AreEqual(-1, TestUtils.Evaluate("Math.round(-1.5)"));
Assert.AreEqual(-2, TestUtils.Evaluate("Math.round(-2.5)"));
// -0.1 rounds to -0, 0.1 rounds to +0
Assert.AreEqual(double.PositiveInfinity, TestUtils.Evaluate("1 / Math.round(0.1)"));
Assert.AreEqual(double.NegativeInfinity, TestUtils.Evaluate("1 / Math.round(-0.1)"));
Assert.AreEqual(double.PositiveInfinity, TestUtils.Evaluate("1 / Math.round(0)"));
Assert.AreEqual(double.NegativeInfinity, TestUtils.Evaluate("1 / Math.round(-0)"));
Assert.AreEqual(0, TestUtils.Evaluate("Math.round(0)"));
Assert.AreEqual(double.PositiveInfinity, TestUtils.Evaluate("Math.round(Infinity)"));
Assert.AreEqual(double.NegativeInfinity, TestUtils.Evaluate("Math.round(-Infinity)"));
Assert.AreEqual(double.NaN, TestUtils.Evaluate("Math.round(NaN)"));
Assert.AreEqual(double.NaN, TestUtils.Evaluate("Math.round(undefined)"));
Assert.AreEqual(double.NaN, TestUtils.Evaluate("Math.round('bob')"));
}
public void Identifiers()
{
Assert.AreEqual(5, TestUtils.Evaluate("delete $; $ = 5; $"));
Assert.AreEqual(6, TestUtils.Evaluate("delete dung; d\\u0075ng = 6; dung"));
Assert.AreEqual(7, TestUtils.Evaluate("delete another; \\u0061nother = 7; another"));
Assert.AreEqual("SyntaxError", TestUtils.EvaluateExceptionType("ident\\u0020ifier"));
}
public void min()
{
Assert.AreEqual(double.PositiveInfinity, TestUtils.Evaluate("Math.min()"));
Assert.AreEqual(1, TestUtils.Evaluate("Math.min(1)"));
Assert.AreEqual(1, TestUtils.Evaluate("Math.min(1, 2)"));
Assert.AreEqual(1, TestUtils.Evaluate("Math.min(1, 2, 3)"));
Assert.AreEqual(1, TestUtils.Evaluate("Math.min(3, 2, 1)"));
Assert.AreEqual(1, TestUtils.Evaluate("Math.min(1, 3, 2)"));
Assert.AreEqual(1, TestUtils.Evaluate("Math.min(1, 3.5, 2)"));
Assert.AreEqual(1.1, TestUtils.Evaluate("Math.min(1.1, 3.5, 2.1)"));
Assert.AreEqual(double.PositiveInfinity, TestUtils.Evaluate("Math.min(Infinity)"));
Assert.AreEqual(double.NegativeInfinity, TestUtils.Evaluate("Math.min(-Infinity)"));
Assert.AreEqual(double.NaN, TestUtils.Evaluate("Math.min(NaN)"));
Assert.AreEqual(double.NaN, TestUtils.Evaluate("Math.min(1, NaN, 2)"));
if (TestUtils.Engine != JSEngine.JScript)
{
// The spec says call ToNumber() on each parameter - JScript does not do this.
Assert.AreEqual(double.NaN, TestUtils.Evaluate("Math.min(undefined)"));
Assert.AreEqual(double.NaN, TestUtils.Evaluate("Math.min('bob')"));
Assert.AreEqual(double.NaN, TestUtils.Evaluate("Math.min('bob', 'dick', 'harry')"));
}
// length
Assert.AreEqual(2, TestUtils.Evaluate("Math.min.length"));
}
public void prototype()
{
// Prototype
if (TestUtils.Engine != JSEngine.JScript)
{
// prototype of built-in object.
Assert.AreEqual(PropertyAttributes.Sealed, TestUtils.EvaluateAccessibility("Function", "prototype"));
// prototype of new function.
Assert.AreEqual(PropertyAttributes.Writable, TestUtils.EvaluateAccessibility("new Function()", "prototype"));
// prototype of empty function.
Assert.AreEqual(true, TestUtils.Evaluate("Object.getPrototypeOf(Function).prototype === undefined"));
// [[Prototype]]
Assert.AreEqual(true, TestUtils.Evaluate("Object.getPrototypeOf(new Function()) === Function.prototype"));
Assert.AreEqual(true, TestUtils.Evaluate("Object.getPrototypeOf(Function.prototype) === Object.prototype"));
Assert.AreEqual(true, TestUtils.Evaluate("Object.getPrototypeOf(new Function().prototype) === Object.prototype"));
Assert.AreEqual(true, TestUtils.Evaluate("Object.getPrototypeOf((function() {}).prototype) === Object.prototype"));
}
// prototype of built-in functions should be undefined.
Assert.AreEqual(Undefined.Value, TestUtils.Evaluate("Math.sin.prototype"));
// prototype of new functions should be a new object.
Assert.AreEqual(true, TestUtils.Evaluate("Function('a+b').prototype !== Object.prototype"));
Assert.AreEqual("object", TestUtils.Evaluate("typeof(Function('a+b').prototype)"));
// The prototype property becomes the prototype of new objects (as long as the prototype property is an object).
Assert.AreEqual(true, TestUtils.Evaluate("f = function() { }; x = {}; f.prototype = x; Object.getPrototypeOf(new f()) === x"));
Assert.AreEqual(true, TestUtils.Evaluate("f = function() { }; x = 5; f.prototype = x; Object.getPrototypeOf(new f()) === Object.prototype"));
}
public void OctalNumbers()
{
// Octal numbers and escape sequences are not supported in strict mode.
Assert.AreEqual(0, TestUtils.Evaluate("'use strict'; 0"));
Assert.AreEqual("SyntaxError", TestUtils.EvaluateExceptionType("'use strict'; 05"));
Assert.AreEqual("SyntaxError", TestUtils.EvaluateExceptionType("'use strict'; 011"));
Assert.AreEqual("SyntaxError", TestUtils.EvaluateExceptionType("'use strict'; 0123456701234567"));
Assert.AreEqual("SyntaxError", TestUtils.EvaluateExceptionType("'use strict'; 09"));
// Octal numbers and escape sequences are supported in ECMAScript 5 mode.
Assert.AreEqual(0, TestUtils.Evaluate("0"));
Assert.AreEqual(5, TestUtils.Evaluate("05"));
Assert.AreEqual(9, TestUtils.Evaluate("011"));
Assert.AreEqual(5744368105847.0, TestUtils.Evaluate("0123456701234567"));
Assert.AreEqual("SyntaxError", TestUtils.EvaluateExceptionType("09"));
// And they are supported in compatibility mode.
TestUtils.CompatibilityMode = CompatibilityMode.ECMAScript3;
try
{
Assert.AreEqual(0, TestUtils.Evaluate("0"));
Assert.AreEqual(5, TestUtils.Evaluate("05"));
Assert.AreEqual(9, TestUtils.Evaluate("011"));
Assert.AreEqual(5744368105847.0, TestUtils.Evaluate("0123456701234567"));
Assert.AreEqual("SyntaxError", TestUtils.EvaluateExceptionType("09"));
}
finally
{
TestUtils.CompatibilityMode = CompatibilityMode.Latest;
}
}
public void Constructor()
{
// Constructor
Assert.AreEqual(Undefined.Value, TestUtils.Evaluate("f = new Function('', ''); f()"));
Assert.AreEqual(4, TestUtils.Evaluate("f = new Function('a', 'b', 'return a+b'); f(1, 3)"));
Assert.AreEqual(4, TestUtils.Evaluate("f = new Function('a,b', 'return a+b'); f(1, 3)"));
Assert.AreEqual("SyntaxError", TestUtils.EvaluateExceptionType("f = new Function('a, ,b', 'return a+b')"));
Assert.AreEqual("SyntaxError", TestUtils.EvaluateExceptionType("f = new Function('a,15,b', 'return a+b')"));
Assert.AreEqual("SyntaxError", TestUtils.EvaluateExceptionType("f = new Function('a,this,b', 'return a+b')"));
Assert.AreEqual("SyntaxError", TestUtils.EvaluateExceptionType("f = new Function('a,c d,b', 'return a+b')"));
Assert.AreEqual("SyntaxError", TestUtils.EvaluateExceptionType("f = new Function('a,c d,b', 'return a+b }')"));
// Call
Assert.AreEqual(4, TestUtils.Evaluate("f = Function('a', 'b', 'return a+b'); f(1, 3)"));
// toString
if (TestUtils.Engine != JSEngine.JScript)
{
Assert.AreEqual("function Function() { [native code] }", TestUtils.Evaluate("Function.toString()"));
}
// length
Assert.AreEqual(1, TestUtils.Evaluate("Function.length"));
// no enumerable properties
Assert.AreEqual("", TestUtils.Evaluate("y = ''; for (var x in Function) { y += x } y"));
Assert.AreEqual("", TestUtils.Evaluate("y = ''; for (var x in new Function()) { y += x } y"));
}
public void toFixed()
{
Assert.AreEqual("0", TestUtils.Evaluate("0 .toFixed()"));
Assert.AreEqual("0.00", TestUtils.Evaluate("0 .toFixed(2)"));
Assert.AreEqual("77", TestUtils.Evaluate("77.1274.toFixed()"));
Assert.AreEqual("77.1274", TestUtils.Evaluate("77.1274.toFixed(4)"));
Assert.AreEqual("77.13", TestUtils.Evaluate("77.1274.toFixed(2)"));
Assert.AreEqual("77", TestUtils.Evaluate("77.1274.toFixed(0)"));
Assert.AreEqual("77", TestUtils.Evaluate("77.1234.toFixed()"));
Assert.AreEqual("77.13", TestUtils.Evaluate("77.1274.toFixed(2)"));
Assert.AreEqual("77.00", TestUtils.Evaluate("77 .toFixed(2)"));
Assert.AreEqual("0.1", TestUtils.Evaluate("0.09.toFixed(1)"));
Assert.AreEqual("0.2", TestUtils.Evaluate("0.19.toFixed(1)"));
Assert.AreEqual("0.0", TestUtils.Evaluate("0.03.toFixed(1)"));
Assert.AreEqual("-1", TestUtils.Evaluate("(-0.7).toFixed()"));
Assert.AreEqual("1000000000000000", TestUtils.Evaluate("1e+15.toFixed()"));
Assert.AreEqual("1e+21", TestUtils.Evaluate("1e21.toFixed()"));
Assert.AreEqual("1e+21", TestUtils.Evaluate("1e21.toFixed(15)"));
Assert.AreEqual("1000000000000000.00000000000000000000", TestUtils.Evaluate("1e+15.toFixed(20)"));
Assert.AreEqual("0", TestUtils.Evaluate("1e-15.toFixed()"));
Assert.AreEqual("0.00000000000000100000", TestUtils.Evaluate("1e-15.toFixed(20)"));
Assert.AreEqual("1234567890123456768", TestUtils.Evaluate("1234567890123456789 .toFixed(0)"));
Assert.AreEqual("77.12739999999999440661", TestUtils.Evaluate("77.1274.toFixed(20)"));
Assert.AreEqual("Infinity", TestUtils.Evaluate("Number.POSITIVE_INFINITY.toFixed()"));
Assert.AreEqual("-Infinity", TestUtils.Evaluate("Number.NEGATIVE_INFINITY.toFixed()"));
Assert.AreEqual("NaN", TestUtils.Evaluate("NaN.toFixed()"));
// Negative tests.
Assert.AreEqual("RangeError", TestUtils.EvaluateExceptionType("77.1274.toFixed(-1)"));
Assert.AreEqual("RangeError", TestUtils.EvaluateExceptionType("77.1274.toFixed(21)"));
// length
Assert.AreEqual(1, TestUtils.Evaluate("NaN.toFixed.length"));
}
public void parseNumber()
{
// Numbers
Assert.AreEqual(0, TestUtils.Evaluate("JSON.parse('0')"));
Assert.AreEqual(5, TestUtils.Evaluate("JSON.parse('5')"));
Assert.AreEqual(-5, TestUtils.Evaluate("JSON.parse('-5')"));
Assert.AreEqual(5.6, TestUtils.Evaluate("JSON.parse('5.6')"));
Assert.AreEqual(-5.6, TestUtils.Evaluate("JSON.parse('-5.6')"));
Assert.AreEqual(560, TestUtils.Evaluate("JSON.parse('5.6e2')"));
Assert.AreEqual(1, TestUtils.Evaluate("JSON.parse('100e-2')"));
Assert.AreEqual(500, TestUtils.Evaluate("JSON.parse('5E2')"));
Assert.AreEqual(5, TestUtils.Evaluate("JSON.parse('5E0')"));
Assert.AreEqual(-500, TestUtils.Evaluate("JSON.parse('-5E+2')"));
// With reviver.
Assert.AreEqual(6, TestUtils.Evaluate(@"JSON.parse('5', function(name, value) { return value + 1 })"));
Assert.AreEqual(Undefined.Value, TestUtils.Evaluate(@"JSON.parse('5', function(name, value) { })"));
// Invalid numbers
Assert.AreEqual("SyntaxError", TestUtils.EvaluateExceptionType("JSON.parse('05')"));
Assert.AreEqual("SyntaxError", TestUtils.EvaluateExceptionType("JSON.parse('.5')"));
Assert.AreEqual("SyntaxError", TestUtils.EvaluateExceptionType("JSON.parse('.e5')"));
Assert.AreEqual("SyntaxError", TestUtils.EvaluateExceptionType("JSON.parse('-.5')"));
Assert.AreEqual("SyntaxError", TestUtils.EvaluateExceptionType("JSON.parse('5.')"));
Assert.AreEqual("SyntaxError", TestUtils.EvaluateExceptionType("JSON.parse('5e')"));
Assert.AreEqual("SyntaxError", TestUtils.EvaluateExceptionType("JSON.parse('5e+')"));
Assert.AreEqual("SyntaxError", TestUtils.EvaluateExceptionType("JSON.parse('5e-')"));
Assert.AreEqual("SyntaxError", TestUtils.EvaluateExceptionType("JSON.parse('+5')"));
Assert.AreEqual("SyntaxError", TestUtils.EvaluateExceptionType("JSON.parse('5e05')"));
Assert.AreEqual("SyntaxError", TestUtils.EvaluateExceptionType("JSON.parse('12\\t\\r\\n 34')"));
}
public void Switch()
{
Assert.AreEqual(5, TestUtils.Evaluate("x = 5; switch (x) { }"));
Assert.AreEqual(6, TestUtils.Evaluate("x = 5; switch (x) { case 5: 6 }"));
Assert.AreEqual(5, TestUtils.Evaluate("x = 5; switch (x) { case 4: 6 }"));
Assert.AreEqual(6, TestUtils.Evaluate("x = 5; switch (x) { default: 6 }"));
Assert.AreEqual(6, TestUtils.Evaluate("x = 5; switch (x) { case 4: case 5: 6 }"));
Assert.AreEqual(7, TestUtils.Evaluate("x = 5; switch (x) { case 5: 6; case 6: 7; }"));
Assert.AreEqual(6, TestUtils.Evaluate("x = 5; switch (x) { case 5: 6; break; 7 }"));
Assert.AreEqual(6, TestUtils.Evaluate("x = 5; switch (x) { case 5: 6; break; case 6: 7 }"));
Assert.AreEqual(8, TestUtils.Evaluate("x = 5; switch (x) { case 4: 6; case 5: 7; default: 8 }"));
Assert.AreEqual(1, TestUtils.Evaluate("switch (5) { default: 3; case 4: 1 }"));
Assert.AreEqual(5, TestUtils.Evaluate("(function(x) { switch (x) { case 8: return 4; case 9: return 5; default: return 7 } })(9)"));
// If there identical clauses, pick the first that matches.
Assert.AreEqual(1, TestUtils.Evaluate("x = 5; switch (x) { case 5: 1; break; case 5: 2; }"));
// Switch expression is evaluated first, then all the clauses.
Assert.AreEqual(6, TestUtils.Evaluate("x = 5; switch (x ++) { } x"));
Assert.AreEqual(4, TestUtils.Evaluate("x = 0; switch (x = 1) { case x = 2: x = 3; break; case x = 4: x = 5; } x"));
Assert.AreEqual(2, TestUtils.Evaluate("x = 0; switch (x = 1, 2) { case x = 2: break; case x = 4: x = 5; } x"));
Assert.AreEqual(3, TestUtils.Evaluate("x = 0; switch (x = 1, 2) { case x = 2: x = 3; break; case x = 4: x = 5; } x"));
// Multiple default clauses are not allowed.
Assert.AreEqual("SyntaxError", TestUtils.EvaluateExceptionType("x = 5; switch (x) { default: 6; default: 7 }"));
}
public void With()
{
Assert.AreEqual(234, TestUtils.Evaluate("x = { a: 234 }; with (x) { a }"));
Assert.AreEqual(234, TestUtils.Evaluate("x = { a: 234 }; a = 5; with (x) { a }"));
Assert.AreEqual(15, TestUtils.Evaluate("x = { a: 234 }; b = 15; with (x) { b }"));
Assert.AreEqual(1, TestUtils.Evaluate("x = { a: 234 }; a = 1; b = 2; with (x) { a = 12, b = 13 } a"));
Assert.AreEqual(13, TestUtils.Evaluate("x = { a: 234 }; a = 1; b = 2; with (x) { a = 12, b = 13 } b"));
Assert.AreEqual(12, TestUtils.Evaluate("x = { a: 234 }; a = 1; b = 2; with (x) { a = 12, b = 13 } x.a"));
Assert.AreEqual(6, TestUtils.Evaluate("b = 5; with (x) { y = b; x.b = 6; b; }"));
Assert.AreEqual(3, TestUtils.Evaluate("x = Object.create({b: 3}); b = 2; with (x) { b }"));
Assert.AreEqual(Undefined.Value, TestUtils.Evaluate("x = { a: 234 }; a = 1; b = 2; with (x) { a = 12, b = 13 } x.b"));
Assert.AreEqual("number", TestUtils.Evaluate("x = { a: 234 }; a = 1; b = 2; with (x) { a = 12, typeof(b) }"));
// Implicit this.
// corrected test case to account for time zone differences
int baseYear = 1970;
if ((DateTime.Now - DateTime.UtcNow).Ticks < 0)
{
baseYear = 1969;
}
Assert.AreEqual(baseYear, TestUtils.Evaluate("x = new Date(5); x.f = x.getFullYear; with (x) { f() }"));
Assert.AreEqual(true, TestUtils.Evaluate("x = { a: 1, b: 2 }; with (x) { (function() { return this })() === this }"));
Assert.AreEqual("TypeError", TestUtils.EvaluateExceptionType("x = new Date(5); f = x.getFullYear; with (x) { f() }"));
Assert.AreEqual(baseYear, TestUtils.Evaluate("x = new Date(5); x.f = x.getFullYear; with (x) { (function b() { return f() })() }"));
// With and var.
Assert.AreEqual(5, TestUtils.Evaluate("x = { a: 234 }; with (x) { var a = 5; } x.a"));
Assert.AreEqual(0, TestUtils.Evaluate("a = 0; x = { a: 234 }; with (x) { var a = 5; } a"));
Assert.AreEqual(5, TestUtils.Evaluate("b = 0; x = { a: 234 }; with (x) { var b = 5; } b"));
Assert.AreEqual(4, TestUtils.Evaluate("foo = {x: 4}; with (foo) { var x; x }"));
Assert.AreEqual(1123, TestUtils.Evaluate("with ({}) { var with_unique_1 = 1123; } with_unique_1"));
// With and prototype chains.
Assert.AreEqual(10, TestUtils.Evaluate("x = Object.create({ b: 5 }); with (x) { b = 10 } x.b"));
Assert.AreEqual(5, TestUtils.Evaluate("x = Object.create({ b: 5 }); with (x) { b = 10 } Object.getPrototypeOf(x).b"));
// With inside a function.
Assert.AreEqual(1, TestUtils.Evaluate("function foo() { with ({ a: 1 }) { return a; } } foo()"));
Assert.AreEqual(1, TestUtils.Evaluate("x = { a: 1 }; function foo() { with (x) { return a; } } foo()"));
Assert.AreEqual(2, TestUtils.Evaluate("x = { a: 1 }; function foo() { with (x) { a = 2; } } foo(); x.a"));
Assert.AreEqual(2, TestUtils.Evaluate("x = { a: 1 }; var foo = function() { with (x) { a = 2; } }; foo(); x.a"));
Assert.AreEqual(2, TestUtils.Evaluate("x = { a: 1 }; y = 2; function foo() { with (x) { return y; } } foo()"));
Assert.AreEqual(1, TestUtils.Evaluate("x = { a: 1 }; y = 2; function foo() { with (x) { y = a; } } foo(); y"));
Assert.AreEqual(1, TestUtils.Evaluate(@"var x = { eval: 1 }; var f = function(){ with(x){ return st_eval = eval; } }; f();"));
// With and object literals.
Assert.AreEqual(42, TestUtils.Evaluate("delete a; x = { a: 42 }; with (x) { y = { get z() { return a; }} } y.z"));
// With and function declarations.
Assert.AreEqual("ReferenceError", TestUtils.EvaluateExceptionType("delete a; x = { a: 43 }; with (x) { function y() { return a } } y()"));
Assert.AreEqual("function", TestUtils.Evaluate("result = typeof _f; with ({a: 2}) { function _f() { return 5 } } result"));
// With statements are syntax errors in strict mode.
Assert.AreEqual("SyntaxError", TestUtils.EvaluateExceptionType("'use strict'; var x = {}; with (x) { }"));
Assert.AreEqual("SyntaxError", TestUtils.EvaluateExceptionType(@"eval(""'use strict'; var o = {}; with (o) {}"")"));
Assert.AreEqual("SyntaxError", TestUtils.EvaluateExceptionType(@"'use strict'; eval(""var o = {}; with (o) {}"")"));
Assert.AreEqual("SyntaxError", TestUtils.EvaluateExceptionType(@"eval(""function f() { 'use strict'; var o = {}; with (o) {} }"")"));
}
public void Constructor()
{
// toString
Assert.AreEqual("[object Global]", TestUtils.Evaluate("this.toString()"));
// valueOf()
Assert.AreEqual(true, TestUtils.Evaluate("this.valueOf() === this"));
}
public void setTime()
{
TestUtils.Evaluate("var x = new Date('24 Apr 2010 23:59:57')");
Assert.AreEqual((int)ToJSDate(new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)), TestUtils.Evaluate("x.setTime(0)"));
Assert.AreEqual((int)ToJSDate(new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)), TestUtils.Evaluate("x.valueOf()"));
Assert.AreEqual(double.NaN, TestUtils.Evaluate("x.setTime(NaN)"));
Assert.AreEqual(1, TestUtils.Evaluate("x.setTime.length"));
}
public void toString()
{
Assert.AreEqual("false", TestUtils.Evaluate("false.toString()"));
Assert.AreEqual("true", TestUtils.Evaluate("true.toString()"));
Assert.AreEqual("false", TestUtils.Evaluate("new Boolean(false).toString()"));
Assert.AreEqual("true", TestUtils.Evaluate("new Boolean(true).toString()"));
Assert.AreEqual(0, TestUtils.Evaluate("Boolean.prototype.toString.length"));
}
public void prototype()
{
Assert.AreEqual(double.NaN, TestUtils.Evaluate("Date.prototype.valueOf()"));
if (TestUtils.Engine != JSEngine.JScript)
{
Assert.AreEqual(true, TestUtils.Evaluate("Object.getPrototypeOf(new Date()) === Date.prototype"));
}
}
public void valueOf()
{
Assert.AreEqual(true, TestUtils.Evaluate("Object.valueOf() === Object"));
Assert.AreEqual(true, TestUtils.Evaluate("new String('test').valueOf() === 'test'"));
Assert.AreEqual(true, TestUtils.Evaluate("new Number(5).valueOf() === 5"));
// length
Assert.AreEqual(0, TestUtils.Evaluate("Object.valueOf.length"));
}
