blob: af4ae862932462680e4e9bcb27546aa0658b333d [file] [log] [blame]
//-------------------------------------------------------------------------------------------------------
// Copyright (C) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
//-------------------------------------------------------------------------------------------------------
function write(v) { WScript.Echo(v + ""); }
var errorCount = 0;
var r;
function verify(scen, act, exp) {
write(scen + " : " + act);
if (act !== exp) {
write("FAILED : " + scen + " exp: " + exp + " act : " + act);
errorCount++;
} else {
write("PASSED : " + scen + " exp: " + exp + " act : " + act);
}
}
// --------------------------------------------------------------------------------------------------
function Test1(a, b) {
write(arguments.hasOwnProperty("0"));
write(arguments.hasOwnProperty("length"));
return arguments[0] + arguments[1];
}
r = Test1(10, 20);
verify("Test1", r, 30);
// --------------------------------------------------------------------------------------------------
function Test2(a, b) {
a = 100;
verify("Test2 arguments[0]", arguments[0], 100);
b = 200;
verify("Test2 arguments[1]", arguments[1], 200);
arguments[0] = 300;
verify("Test2 a", a, 300);
arguments[1] = 400;
verify("Test2 b", b, 400);
return a + b + arguments[0] + arguments[1];
}
r = Test2(10, 20);
verify("Test2", r, 1400);
// --------------------------------------------------------------------------------------------------
function Test3(a, b) {
var arguments = new Object();
if (arguments[0] == a)
verify("Test3 a", a);
if (arguments[1] == b)
verify("Test3 b", b);
arguments[0] = a;
arguments[1] = b;
a = a + 1;
b = b + 1;
if (arguments[0] == a)
verify("Test3 a1", a);
if (arguments[1] == b)
verify("Test3 b1", b);
return 0;
}
r = Test3(10, 20);
verify("Test3", r, 0);
// --------------------------------------------------------------------------------------------------
function Test4(a, b, arguments) {
if (arguments[0] == a)
verify("Test4 a", a);
if (arguments[1] == b)
verify("Test4 b", b);
arguments[0] = a;
arguments[1] = b;
a = a + 1;
b = b + 1;
if (arguments[0] == a)
verify("Test4 a1", a);
if (arguments[1] == b)
verify("Test4 b1", b);
return 0;
}
r = Test4(10, 20, new Object());
verify("Test4", r, 0);
// --------------------------------------------------------------------------------------------------
function Test5(a, b) {
var count = 0;
arguments[0] = 100;
arguments[1] = 200;
for (var i in arguments) {
count++;
}
return count;
}
r = Test5(10);
verify("Test5 1", r, 2);
r = Test5(10, 20);
verify("Test5 2", r, 2);
r = Test5(10, 20, 30);
verify("Test5 3", r, 3);
// --------------------------------------------------------------------------------------------------
function Test6(a, b) {
var count = 0;
for (var i in arguments) {
count = count + 1;
}
return count;
}
r = Test6(10);
verify("Test6 1", r, 1);
r = Test6(10, 20);
verify("Test6 2", r, 2);
r = Test6(10, 20, 30);
verify("Test6 3", r, 3);
// --------------------------------------------------------------------------------------------------
function Test7() {
return arguments.length;
}
r = Test7();
verify("Test7", r, 0);
r = Test7(10, 20);
verify("Test7", r, 2);
// --------------------------------------------------------------------------------------------------
var callCount = 5;
function Test8() {
var calledCount = 0;
write("Test8 : " + callCount);
if (callCount != 0) {
callCount = callCount - 1;
calledCount = arguments.callee() + 1;
}
return calledCount;
}
r = Test8();
verify("Test8", r, 5);
// --------------------------------------------------------------------------------------------------
function Test9() {
write(arguments.hasOwnProperty("length"));
write(arguments[0] + " " + arguments[1] + " " + arguments.length);
arguments.length = "test";
write(arguments[0] + " " + arguments[1] + " " + arguments.length);
write(arguments.hasOwnProperty("0"));
write(arguments.hasOwnProperty("length"));
return arguments.length;
}
r = Test9();
verify("Test9", r, "test");
r = Test9(10);
verify("Test9", r, "test");
r = Test9(10, 20);
verify("Test9", r, "test");
r = Test9(10, 20, 30);
verify("Test9", r, "test");
// --------------------------------------------------------------------------------------------------
// Test arguments for-in enumeration
function dump_props(obj) {
var s = "";
for (p in obj) {
if (!s) {
s = "[" + p + ": " + obj[p];
} else {
s += ", " + p + ": " + obj[p];
}
}
if (s) {
s += "]";
} else {
s = "[]";
}
return s;
}
//
// simply dump args
//
var dump_args = function (a, b) {
return dump_props(arguments);
}
verify("Test10.1",
dump_args(),
"[]");
verify("Test10.1",
dump_args(13),
"[0: 13]");
verify("Test10.1",
dump_args(13, 24),
"[0: 13, 1: 24]");
verify("Test10.1",
dump_args(13, 24, "string", true),
"[0: 13, 1: 24, 2: string, 3: true]");
//
// make some changes then dump
//
dump_args = function (a, b) {
arguments[0] = 98;
b = 54;
arguments[8] = false;
arguments[10] = 21;
arguments.foo = 'bar';
return dump_props(arguments);
}
verify("Test10.2",
dump_args(),
"[0: 98, 8: false, 10: 21, foo: bar]");
verify("Test10.2",
dump_args(13),
"[0: 98, 8: false, 10: 21, foo: bar]");
verify("Test10.2",
dump_args(13, 24),
"[0: 98, 1: 54, 8: false, 10: 21, foo: bar]");
verify("Test10.2",
dump_args(13, 24, "string", true),
"[0: 98, 1: 54, 2: string, 3: true, 8: false, 10: 21, foo: bar]");
//
// delete and dump
//
var get_args = function (a0, a1, a2, a3, a4) {
return arguments;
}
var delete_args_test = function (args, exp_del, exp_set) {
delete args[1];
delete args[3];
verify("Test10.3.1", dump_props(args), exp_del);
args.foo = "bar";
args[6] = "arg6";
args[2] = "arg2";
args[1] = "arg1";
verify("Test10.3.2", dump_props(args), exp_set);
}
delete_args_test(get_args(),
"[]",
"[1: arg1, 2: arg2, 6: arg6, foo: bar]"
);
delete_args_test(get_args(13),
"[0: 13]",
"[0: 13, 1: arg1, 2: arg2, 6: arg6, foo: bar]"
);
delete_args_test(get_args(13, 24),
"[0: 13]", //[1] deleted
"[0: 13, 1: arg1, 2: arg2, 6: arg6, foo: bar]"
// [1] set after formal args
);
delete_args_test(get_args(13, 24, "string", true),
"[0: 13, 2: string]", //[1][3] deleted
"[0: 13, 2: arg2, 1: arg1, 6: arg6, foo: bar]"
//[1] set after formal args [0][2]
);
function Test11() {
var _t11;
function inner11() {
arguments.valueOf = function() { _t11 = this; }
var x = arguments++;
return x;
}
inner11("sentinel");
verify("Test11 args", _t11[0], "sentinel");
}
Test11();
function Test12() {
function inner12() {
throw arguments;
}
try {
inner12("sentinel");
} catch (e) {
verify("Test12 args", e[0], "sentinel");
}
}
Test12();
function Test13() {
var _t13;
function inner13() {
arguments.capture = function() { _t13 = this }
with(arguments)
capture();
}
inner13("sentinel");
verify("Test13 args", _t13[0], "sentinel");
}
Test13();
function TestBuiltInProperty(propName) {
write("");
write("-------Testing built-in " + propName + " Implementation----");
verify("HasOwnProperty() test", arguments.hasOwnProperty(propName), true);
verify("IsEnumerable() test", arguments.propertyIsEnumerable(propName), false);
arguments[propName] = 40;
verify("Overriding value test", arguments[propName], 40);
delete arguments[propName];
verify("HasOwnProperty() after deletion test", arguments.hasOwnProperty(propName), false);
verify("Value after deletion test", arguments[propName], undefined);
}
TestBuiltInProperty("callee");
TestBuiltInProperty("length");
function Test15() {
var count = 0;
arguments.length += 10;
arguments.length -= 10;
arguments[0] = 100;
arguments[1] = 200;
for (var i in arguments) {
count++;
}
verify("Test15", count, 2);
}
Test15();
function Test16() {
verify("Test16", arguments.length, 3);
function Test16_inner() {
eval("");
}
}
Test16(1, 2, 3);
function Test17(a) {
verify("Test17.1", arguments.length, 1);
verify("Test17.2", a, "Feb20");
function Test17_inner() {
eval("");
}
}
Test17("Feb20");
// Test that changing arguments in one function is reflected in the caller
function Test18_Helper() {
Test18_Helper.caller.arguments.Test18_Value = "Test 18 Value";
}
function Test18() {
verify("Test18.1", arguments.Test18_Value, undefined);
Test18_Helper();
verify("Test18.2", arguments.Test18_Value, undefined);
}
Test18();
function Test19(flag)
{
if (flag)
{
write("test19 called");
}
else
{
Test19_Helper();
}
}
function Test19_Helper()
{
arguments.callee.caller(true);
}
Test19();
// --------------------------------------------------------------------------------------------------
if (errorCount > 0) {
write(errorCount + " Tests ");
throw new Error(errorCount);
}