mirror of https://github.com/tc39/test262.git
Remove unnecessary files containing whitelist and blacklist (#2701)
This commit is contained in:
Rick Waldron
GitHub
parent
8575a6eb1d
commit
28ec03f454
File diff suppressed because it is too large
Load Diff
|
|
@ -1,739 +0,0 @@
|
|||
// Copyright 2014 the V8 project authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style license that can be
|
||||
// found in the LICENSE file.
|
||||
|
||||
var global = this;
|
||||
var globalProto = Object.getPrototypeOf(global);
|
||||
|
||||
// Number of objects being tested. There is an assert ensuring this is correct.
|
||||
var objectCount = 21;
|
||||
|
||||
|
||||
function runTest(f) {
|
||||
function restore(object, oldProto) {
|
||||
delete object[Symbol.unscopables];
|
||||
delete object.x;
|
||||
delete object.x_;
|
||||
delete object.y;
|
||||
delete object.z;
|
||||
Object.setPrototypeOf(object, oldProto);
|
||||
}
|
||||
|
||||
function getObject(i) {
|
||||
var objects = [
|
||||
{},
|
||||
[],
|
||||
function() {},
|
||||
function() {
|
||||
return arguments;
|
||||
}(),
|
||||
function() {
|
||||
'use strict';
|
||||
return arguments;
|
||||
}(),
|
||||
Object(1),
|
||||
Object(true),
|
||||
Object('bla'),
|
||||
new Date,
|
||||
new RegExp,
|
||||
new Set,
|
||||
new Map,
|
||||
new WeakMap,
|
||||
new WeakSet,
|
||||
new ArrayBuffer(10),
|
||||
new Int32Array(5),
|
||||
Object,
|
||||
Function,
|
||||
Date,
|
||||
RegExp,
|
||||
global
|
||||
];
|
||||
|
||||
assertEquals(objectCount, objects.length);
|
||||
return objects[i];
|
||||
}
|
||||
|
||||
// Tests depends on this not being there to start with.
|
||||
delete Array.prototype[Symbol.unscopables];
|
||||
|
||||
if (f.length === 1) {
|
||||
for (var i = 0; i < objectCount; i++) {
|
||||
var object = getObject(i);
|
||||
var oldObjectProto = Object.getPrototypeOf(object);
|
||||
f(object);
|
||||
restore(object, oldObjectProto);
|
||||
}
|
||||
} else {
|
||||
for (var i = 0; i < objectCount; i++) {
|
||||
for (var j = 0; j < objectCount; j++) {
|
||||
var object = getObject(i);
|
||||
var proto = getObject(j);
|
||||
if (object === proto) {
|
||||
continue;
|
||||
}
|
||||
var oldObjectProto = Object.getPrototypeOf(object);
|
||||
var oldProtoProto = Object.getPrototypeOf(proto);
|
||||
f(object, proto);
|
||||
restore(object, oldObjectProto);
|
||||
restore(proto, oldProtoProto);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Test array first, since other tests are changing
|
||||
// Array.prototype[Symbol.unscopables].
|
||||
function TestArrayPrototypeUnscopables() {
|
||||
var descr = Object.getOwnPropertyDescriptor(Array.prototype,
|
||||
Symbol.unscopables);
|
||||
assertFalse(descr.enumerable);
|
||||
assertFalse(descr.writable);
|
||||
assertTrue(descr.configurable);
|
||||
assertEquals(null, Object.getPrototypeOf(descr.value));
|
||||
|
||||
var copyWithin = 'local copyWithin';
|
||||
var entries = 'local entries';
|
||||
var fill = 'local fill';
|
||||
var find = 'local find';
|
||||
var findIndex = 'local findIndex';
|
||||
var flat = 'local flat';
|
||||
var flatMap = 'local flatMap';
|
||||
var keys = 'local keys';
|
||||
var includes = 'local includes';
|
||||
var values = 'local values';
|
||||
|
||||
var array = [];
|
||||
array.toString = 42;
|
||||
|
||||
with (array) {
|
||||
assertEquals('local copyWithin', copyWithin);
|
||||
assertEquals('local entries', entries);
|
||||
assertEquals('local fill', fill);
|
||||
assertEquals('local find', find);
|
||||
assertEquals('local findIndex', findIndex);
|
||||
assertEquals('local flat', flat);
|
||||
assertEquals('local flatMap', flatMap);
|
||||
assertEquals('local includes', includes);
|
||||
assertEquals('local keys', keys);
|
||||
assertEquals('local values', values);
|
||||
assertEquals(42, toString);
|
||||
}
|
||||
}
|
||||
TestArrayPrototypeUnscopables();
|
||||
|
||||
|
||||
|
||||
function TestBasics(object) {
|
||||
var x = 1;
|
||||
var y = 2;
|
||||
var z = 3;
|
||||
object.x = 4;
|
||||
object.y = 5;
|
||||
|
||||
with (object) {
|
||||
assertEquals(4, x);
|
||||
assertEquals(5, y);
|
||||
assertEquals(3, z);
|
||||
}
|
||||
|
||||
var truthyValues = [true, 1, 'x', {}, Symbol()];
|
||||
for (var truthyValue of truthyValues) {
|
||||
object[Symbol.unscopables] = {x: truthyValue};
|
||||
with (object) {
|
||||
assertEquals(1, x);
|
||||
assertEquals(5, y);
|
||||
assertEquals(3, z);
|
||||
}
|
||||
}
|
||||
|
||||
var falsyValues = [false, 0, -0, NaN, '', null, undefined];
|
||||
for (var falsyValue of falsyValues) {
|
||||
object[Symbol.unscopables] = {x: falsyValue, y: true};
|
||||
with (object) {
|
||||
assertEquals(4, x);
|
||||
assertEquals(2, y);
|
||||
assertEquals(3, z);
|
||||
}
|
||||
}
|
||||
|
||||
for (var xFalsy of falsyValues) {
|
||||
for (var yFalsy of falsyValues) {
|
||||
object[Symbol.unscopables] = {x: xFalsy, y: yFalsy};
|
||||
with (object) {
|
||||
assertEquals(4, x);
|
||||
assertEquals(5, y);
|
||||
assertEquals(3, z);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
runTest(TestBasics);
|
||||
|
||||
|
||||
function TestUnscopableChain(object) {
|
||||
var x = 1;
|
||||
object.x = 2;
|
||||
|
||||
with (object) {
|
||||
assertEquals(2, x);
|
||||
}
|
||||
|
||||
object[Symbol.unscopables] = {
|
||||
__proto__: {x: true}
|
||||
};
|
||||
with (object) {
|
||||
assertEquals(1, x);
|
||||
}
|
||||
|
||||
object[Symbol.unscopables] = {
|
||||
__proto__: {x: undefined}
|
||||
};
|
||||
with (object) {
|
||||
assertEquals(2, x);
|
||||
}
|
||||
}
|
||||
runTest(TestUnscopableChain);
|
||||
|
||||
|
||||
function TestBasicsSet(object) {
|
||||
var x = 1;
|
||||
object.x = 2;
|
||||
|
||||
with (object) {
|
||||
assertEquals(2, x);
|
||||
}
|
||||
|
||||
object[Symbol.unscopables] = {x: true};
|
||||
with (object) {
|
||||
assertEquals(1, x);
|
||||
x = 3;
|
||||
assertEquals(3, x);
|
||||
}
|
||||
|
||||
assertEquals(3, x);
|
||||
assertEquals(2, object.x);
|
||||
}
|
||||
runTest(TestBasicsSet);
|
||||
|
||||
|
||||
function TestOnProto(object, proto) {
|
||||
var x = 1;
|
||||
var y = 2;
|
||||
var z = 3;
|
||||
proto.x = 4;
|
||||
|
||||
Object.setPrototypeOf(object, proto);
|
||||
object.y = 5;
|
||||
|
||||
with (object) {
|
||||
assertEquals(4, x);
|
||||
assertEquals(5, y);
|
||||
assertEquals(3, z);
|
||||
}
|
||||
|
||||
proto[Symbol.unscopables] = {x: true};
|
||||
with (object) {
|
||||
assertEquals(1, x);
|
||||
assertEquals(5, y);
|
||||
assertEquals(3, z);
|
||||
}
|
||||
|
||||
object[Symbol.unscopables] = {y: true};
|
||||
with (object) {
|
||||
assertEquals(4, x);
|
||||
assertEquals(2, y);
|
||||
assertEquals(3, z);
|
||||
}
|
||||
|
||||
proto[Symbol.unscopables] = {y: true};
|
||||
object[Symbol.unscopables] = {x: true};
|
||||
with (object) {
|
||||
assertEquals(1, x);
|
||||
assertEquals(5, y);
|
||||
assertEquals(3, z);
|
||||
}
|
||||
|
||||
proto[Symbol.unscopables] = {y: true};
|
||||
object[Symbol.unscopables] = {x: true, y: undefined};
|
||||
with (object) {
|
||||
assertEquals(1, x);
|
||||
assertEquals(5, y);
|
||||
assertEquals(3, z);
|
||||
}
|
||||
}
|
||||
runTest(TestOnProto);
|
||||
|
||||
|
||||
function TestSetBlockedOnProto(object, proto) {
|
||||
var x = 1;
|
||||
object.x = 2;
|
||||
|
||||
with (object) {
|
||||
assertEquals(2, x);
|
||||
}
|
||||
|
||||
Object.setPrototypeOf(object, proto);
|
||||
proto[Symbol.unscopables] = {x: true};
|
||||
with (object) {
|
||||
assertEquals(1, x);
|
||||
x = 3;
|
||||
assertEquals(3, x);
|
||||
}
|
||||
|
||||
assertEquals(3, x);
|
||||
assertEquals(2, object.x);
|
||||
}
|
||||
runTest(TestSetBlockedOnProto);
|
||||
|
||||
|
||||
function TestNonObject(object) {
|
||||
var x = 1;
|
||||
var y = 2;
|
||||
object.x = 3;
|
||||
object.y = 4;
|
||||
|
||||
object[Symbol.unscopables] = 'xy';
|
||||
with (object) {
|
||||
assertEquals(3, x);
|
||||
assertEquals(4, y);
|
||||
}
|
||||
|
||||
object[Symbol.unscopables] = null;
|
||||
with (object) {
|
||||
assertEquals(3, x);
|
||||
assertEquals(4, y);
|
||||
}
|
||||
}
|
||||
runTest(TestNonObject);
|
||||
|
||||
|
||||
function TestChangeDuringWith(object) {
|
||||
var x = 1;
|
||||
var y = 2;
|
||||
object.x = 3;
|
||||
object.y = 4;
|
||||
|
||||
with (object) {
|
||||
assertEquals(3, x);
|
||||
assertEquals(4, y);
|
||||
object[Symbol.unscopables] = {x: true};
|
||||
assertEquals(1, x);
|
||||
assertEquals(4, y);
|
||||
}
|
||||
}
|
||||
runTest(TestChangeDuringWith);
|
||||
|
||||
|
||||
function TestChangeDuringWithWithPossibleOptimization(object) {
|
||||
var x = 1;
|
||||
object.x = 2;
|
||||
with (object) {
|
||||
for (var i = 0; i < 1000; i++) {
|
||||
if (i === 500) object[Symbol.unscopables] = {x: true};
|
||||
assertEquals(i < 500 ? 2: 1, x);
|
||||
}
|
||||
}
|
||||
}
|
||||
TestChangeDuringWithWithPossibleOptimization({});
|
||||
|
||||
|
||||
function TestChangeDuringWithWithPossibleOptimization2(object) {
|
||||
var x = 1;
|
||||
object.x = 2;
|
||||
object[Symbol.unscopables] = {x: true};
|
||||
with (object) {
|
||||
for (var i = 0; i < 1000; i++) {
|
||||
if (i === 500) delete object[Symbol.unscopables];
|
||||
assertEquals(i < 500 ? 1 : 2, x);
|
||||
}
|
||||
}
|
||||
}
|
||||
TestChangeDuringWithWithPossibleOptimization2({});
|
||||
|
||||
|
||||
function TestChangeDuringWithWithPossibleOptimization3(object) {
|
||||
var x = 1;
|
||||
object.x = 2;
|
||||
object[Symbol.unscopables] = {};
|
||||
with (object) {
|
||||
for (var i = 0; i < 1000; i++) {
|
||||
if (i === 500) object[Symbol.unscopables].x = true;
|
||||
assertEquals(i < 500 ? 2 : 1, x);
|
||||
}
|
||||
}
|
||||
}
|
||||
TestChangeDuringWithWithPossibleOptimization3({});
|
||||
|
||||
|
||||
function TestChangeDuringWithWithPossibleOptimization4(object) {
|
||||
var x = 1;
|
||||
object.x = 2;
|
||||
object[Symbol.unscopables] = {x: true};
|
||||
with (object) {
|
||||
for (var i = 0; i < 1000; i++) {
|
||||
if (i === 500) delete object[Symbol.unscopables].x;
|
||||
assertEquals(i < 500 ? 1 : 2, x);
|
||||
}
|
||||
}
|
||||
}
|
||||
TestChangeDuringWithWithPossibleOptimization4({});
|
||||
|
||||
|
||||
function TestChangeDuringWithWithPossibleOptimization4(object) {
|
||||
var x = 1;
|
||||
object.x = 2;
|
||||
object[Symbol.unscopables] = {x: true};
|
||||
with (object) {
|
||||
for (var i = 0; i < 1000; i++) {
|
||||
if (i === 500) object[Symbol.unscopables].x = undefined;
|
||||
assertEquals(i < 500 ? 1 : 2, x);
|
||||
}
|
||||
}
|
||||
}
|
||||
TestChangeDuringWithWithPossibleOptimization4({});
|
||||
|
||||
|
||||
function TestAccessorReceiver(object, proto) {
|
||||
var x = 'local';
|
||||
|
||||
Object.defineProperty(proto, 'x', {
|
||||
get: function() {
|
||||
assertEquals(object, this);
|
||||
return this.x_;
|
||||
},
|
||||
configurable: true
|
||||
});
|
||||
proto.x_ = 'proto';
|
||||
|
||||
Object.setPrototypeOf(object, proto);
|
||||
proto.x_ = 'object';
|
||||
|
||||
with (object) {
|
||||
assertEquals('object', x);
|
||||
}
|
||||
}
|
||||
runTest(TestAccessorReceiver);
|
||||
|
||||
|
||||
function TestUnscopablesGetter(object) {
|
||||
// This test gets really messy when object is the global since the assert
|
||||
// functions are properties on the global object and the call count gets
|
||||
// completely different.
|
||||
if (object === global) return;
|
||||
|
||||
var x = 'local';
|
||||
object.x = 'object';
|
||||
|
||||
var callCount = 0;
|
||||
Object.defineProperty(object, Symbol.unscopables, {
|
||||
get: function() {
|
||||
callCount++;
|
||||
return {};
|
||||
},
|
||||
configurable: true
|
||||
});
|
||||
with (object) {
|
||||
assertEquals('object', x);
|
||||
}
|
||||
// Once for HasBinding
|
||||
assertEquals(1, callCount);
|
||||
|
||||
callCount = 0;
|
||||
Object.defineProperty(object, Symbol.unscopables, {
|
||||
get: function() {
|
||||
callCount++;
|
||||
return {x: true};
|
||||
},
|
||||
configurable: true
|
||||
});
|
||||
with (object) {
|
||||
assertEquals('local', x);
|
||||
}
|
||||
// Once for HasBinding
|
||||
assertEquals(1, callCount);
|
||||
|
||||
callCount = 0;
|
||||
Object.defineProperty(object, Symbol.unscopables, {
|
||||
get: function() {
|
||||
callCount++;
|
||||
return callCount == 1 ? {} : {x: true};
|
||||
},
|
||||
configurable: true
|
||||
});
|
||||
with (object) {
|
||||
x = 1;
|
||||
}
|
||||
// Once for HasBinding
|
||||
assertEquals(1, callCount);
|
||||
assertEquals(1, object.x);
|
||||
assertEquals('local', x);
|
||||
with (object) {
|
||||
x = 2;
|
||||
}
|
||||
// One more HasBinding.
|
||||
assertEquals(2, callCount);
|
||||
assertEquals(1, object.x);
|
||||
assertEquals(2, x);
|
||||
}
|
||||
runTest(TestUnscopablesGetter);
|
||||
|
||||
|
||||
var global = this;
|
||||
function TestUnscopablesGetter2() {
|
||||
var x = 'local';
|
||||
|
||||
var globalProto = Object.getPrototypeOf(global);
|
||||
var protos = [{}, [], function() {}, global];
|
||||
var objects = [{}, [], function() {}];
|
||||
|
||||
protos.forEach(function(proto) {
|
||||
objects.forEach(function(object) {
|
||||
Object.defineProperty(proto, 'x', {
|
||||
get: function() {
|
||||
assertEquals(object, this);
|
||||
return 'proto';
|
||||
},
|
||||
configurable: true
|
||||
});
|
||||
|
||||
object.__proto__ = proto;
|
||||
Object.defineProperty(object, 'x', {
|
||||
get: function() {
|
||||
assertEquals(object, this);
|
||||
return 'object';
|
||||
},
|
||||
configurable: true
|
||||
});
|
||||
|
||||
with (object) {
|
||||
assertEquals('object', x);
|
||||
}
|
||||
|
||||
object[Symbol.unscopables] = {x: true};
|
||||
with (object) {
|
||||
assertEquals('local', x);
|
||||
}
|
||||
|
||||
delete proto[Symbol.unscopables];
|
||||
delete object[Symbol.unscopables];
|
||||
});
|
||||
});
|
||||
|
||||
delete global.x;
|
||||
Object.setPrototypeOf(global, globalProto);
|
||||
}
|
||||
TestUnscopablesGetter2();
|
||||
|
||||
|
||||
function TestSetterOnBlacklisted(object, proto) {
|
||||
var x = 'local';
|
||||
Object.defineProperty(proto, 'x', {
|
||||
set: function(x) {
|
||||
assertUnreachable();
|
||||
},
|
||||
get: function() {
|
||||
return 'proto';
|
||||
},
|
||||
configurable: true
|
||||
});
|
||||
Object.setPrototypeOf(object, proto);
|
||||
Object.defineProperty(object, 'x', {
|
||||
get: function() {
|
||||
return this.x_;
|
||||
},
|
||||
set: function(x) {
|
||||
this.x_ = x;
|
||||
},
|
||||
configurable: true
|
||||
});
|
||||
object.x_ = 1;
|
||||
|
||||
with (object) {
|
||||
x = 2;
|
||||
assertEquals(2, x);
|
||||
}
|
||||
|
||||
assertEquals(2, object.x);
|
||||
|
||||
object[Symbol.unscopables] = {x: true};
|
||||
|
||||
with (object) {
|
||||
x = 3;
|
||||
assertEquals(3, x);
|
||||
}
|
||||
|
||||
assertEquals(2, object.x);
|
||||
}
|
||||
runTest(TestSetterOnBlacklisted);
|
||||
|
||||
|
||||
function TestObjectsAsUnscopables(object, unscopables) {
|
||||
var x = 1;
|
||||
object.x = 2;
|
||||
|
||||
with (object) {
|
||||
assertEquals(2, x);
|
||||
object[Symbol.unscopables] = unscopables;
|
||||
assertEquals(2, x);
|
||||
}
|
||||
}
|
||||
runTest(TestObjectsAsUnscopables);
|
||||
|
||||
|
||||
function TestAccessorOnUnscopables(object) {
|
||||
var x = 1;
|
||||
object.x = 2;
|
||||
|
||||
var calls = 0;
|
||||
var unscopables = {
|
||||
get x() {
|
||||
calls++;
|
||||
return calls === 1 ? true : undefined;
|
||||
}
|
||||
};
|
||||
|
||||
with (object) {
|
||||
assertEquals(2, x);
|
||||
object[Symbol.unscopables] = unscopables;
|
||||
assertEquals(1, x);
|
||||
assertEquals(2, x);
|
||||
}
|
||||
assertEquals(2, calls);
|
||||
}
|
||||
runTest(TestAccessorOnUnscopables);
|
||||
|
||||
|
||||
function TestLengthUnscopables(object, proto) {
|
||||
var length = 2;
|
||||
with (object) {
|
||||
assertEquals(1, length);
|
||||
object[Symbol.unscopables] = {length: true};
|
||||
assertEquals(2, length);
|
||||
delete object[Symbol.unscopables];
|
||||
assertEquals(1, length);
|
||||
}
|
||||
}
|
||||
TestLengthUnscopables([1], Array.prototype);
|
||||
TestLengthUnscopables(function(x) {}, Function.prototype);
|
||||
TestLengthUnscopables(new String('x'), String.prototype);
|
||||
|
||||
|
||||
function TestFunctionNameUnscopables(object) {
|
||||
var name = 'local';
|
||||
with (object) {
|
||||
assertEquals('f', name);
|
||||
object[Symbol.unscopables] = {name: true};
|
||||
assertEquals('local', name);
|
||||
delete object[Symbol.unscopables];
|
||||
assertEquals('f', name);
|
||||
}
|
||||
}
|
||||
TestFunctionNameUnscopables(function f() {});
|
||||
|
||||
|
||||
function TestFunctionPrototypeUnscopables() {
|
||||
var prototype = 'local';
|
||||
var f = function() {};
|
||||
var g = function() {};
|
||||
Object.setPrototypeOf(f, g);
|
||||
var fp = f.prototype;
|
||||
var gp = g.prototype;
|
||||
with (f) {
|
||||
assertEquals(fp, prototype);
|
||||
f[Symbol.unscopables] = {prototype: true};
|
||||
assertEquals('local', prototype);
|
||||
delete f[Symbol.unscopables];
|
||||
assertEquals(fp, prototype);
|
||||
}
|
||||
}
|
||||
TestFunctionPrototypeUnscopables(function() {});
|
||||
|
||||
|
||||
function TestFunctionArgumentsUnscopables() {
|
||||
var func = function() {
|
||||
var arguments = 'local';
|
||||
var args = func.arguments;
|
||||
with (func) {
|
||||
assertEquals(args, arguments);
|
||||
func[Symbol.unscopables] = {arguments: true};
|
||||
assertEquals('local', arguments);
|
||||
delete func[Symbol.unscopables];
|
||||
assertEquals(args, arguments);
|
||||
}
|
||||
}
|
||||
func(1);
|
||||
}
|
||||
TestFunctionArgumentsUnscopables();
|
||||
|
||||
|
||||
function TestArgumentsLengthUnscopables() {
|
||||
var func = function() {
|
||||
var length = 'local';
|
||||
with (arguments) {
|
||||
assertEquals(1, length);
|
||||
arguments[Symbol.unscopables] = {length: true};
|
||||
assertEquals('local', length);
|
||||
}
|
||||
}
|
||||
func(1);
|
||||
}
|
||||
TestArgumentsLengthUnscopables();
|
||||
|
||||
|
||||
function TestFunctionCallerUnscopables() {
|
||||
var func = function() {
|
||||
var caller = 'local';
|
||||
with (func) {
|
||||
assertEquals(TestFunctionCallerUnscopables, caller);
|
||||
func[Symbol.unscopables] = {caller: true};
|
||||
assertEquals('local', caller);
|
||||
delete func[Symbol.unscopables];
|
||||
assertEquals(TestFunctionCallerUnscopables, caller);
|
||||
}
|
||||
}
|
||||
func(1);
|
||||
}
|
||||
TestFunctionCallerUnscopables();
|
||||
|
||||
|
||||
function TestGetUnscopablesGetterThrows() {
|
||||
var object = {
|
||||
get x() {
|
||||
assertUnreachable();
|
||||
}
|
||||
};
|
||||
function CustomError() {}
|
||||
Object.defineProperty(object, Symbol.unscopables, {
|
||||
get: function() {
|
||||
throw new CustomError();
|
||||
}
|
||||
});
|
||||
assertThrows(function() {
|
||||
with (object) {
|
||||
x;
|
||||
}
|
||||
}, CustomError);
|
||||
}
|
||||
TestGetUnscopablesGetterThrows();
|
||||
|
||||
|
||||
function TestGetUnscopablesGetterThrows2() {
|
||||
var object = {
|
||||
get x() {
|
||||
assertUnreachable();
|
||||
}
|
||||
};
|
||||
function CustomError() {}
|
||||
|
||||
object[Symbol.unscopables] = {
|
||||
get x() {
|
||||
throw new CustomError();
|
||||
}
|
||||
};
|
||||
assertThrows(function() {
|
||||
with (object) {
|
||||
x;
|
||||
}
|
||||
}, CustomError);
|
||||
}
|
||||
TestGetUnscopablesGetterThrows();
|
||||
|
|
@ -1,283 +0,0 @@
|
|||
# Copyright 2008 the V8 project authors. All rights reserved.
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions are
|
||||
# met:
|
||||
#
|
||||
# * Redistributions of source code must retain the above copyright
|
||||
# notice, this list of conditions and the following disclaimer.
|
||||
# * Redistributions in binary form must reproduce the above
|
||||
# copyright notice, this list of conditions and the following
|
||||
# disclaimer in the documentation and/or other materials provided
|
||||
# with the distribution.
|
||||
# * Neither the name of Google Inc. nor the names of its
|
||||
# contributors may be used to endorse or promote products derived
|
||||
# from this software without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
from collections import OrderedDict
|
||||
import itertools
|
||||
import os
|
||||
import re
|
||||
|
||||
from testrunner.local import statusfile
|
||||
from testrunner.local import testsuite
|
||||
from testrunner.objects import testcase
|
||||
from testrunner.outproc import base as outproc
|
||||
|
||||
FILES_PATTERN = re.compile(r"//\s+Files:(.*)")
|
||||
ENV_PATTERN = re.compile(r"//\s+Environment Variables:(.*)")
|
||||
SELF_SCRIPT_PATTERN = re.compile(r"//\s+Env: TEST_FILE_NAME")
|
||||
MODULE_PATTERN = re.compile(r"^// MODULE$", flags=re.MULTILINE)
|
||||
NO_HARNESS_PATTERN = re.compile(r"^// NO HARNESS$", flags=re.MULTILINE)
|
||||
|
||||
|
||||
# Flags known to misbehave when combining arbitrary mjsunit tests. Can also
|
||||
# be compiled regular expressions.
|
||||
COMBINE_TESTS_FLAGS_BLACKLIST = [
|
||||
'--check-handle-count',
|
||||
'--enable-tracing',
|
||||
re.compile('--experimental.*'),
|
||||
'--expose-trigger-failure',
|
||||
re.compile('--harmony.*'),
|
||||
'--mock-arraybuffer-allocator',
|
||||
'--print-ast',
|
||||
re.compile('--trace.*'),
|
||||
'--wasm-lazy-compilation',
|
||||
]
|
||||
|
||||
class TestSuite(testsuite.TestSuite):
|
||||
def ListTests(self):
|
||||
tests = []
|
||||
for dirname, dirs, files in os.walk(self.root, followlinks=True):
|
||||
for dotted in [x for x in dirs if x.startswith('.')]:
|
||||
dirs.remove(dotted)
|
||||
dirs.sort()
|
||||
files.sort()
|
||||
for filename in files:
|
||||
if (filename.endswith(".js") and
|
||||
filename != "mjsunit.js" and
|
||||
filename != "mjsunit_suppressions.js"):
|
||||
fullpath = os.path.join(dirname, filename)
|
||||
relpath = fullpath[len(self.root) + 1 : -3]
|
||||
testname = relpath.replace(os.path.sep, "/")
|
||||
test = self._create_test(testname)
|
||||
tests.append(test)
|
||||
return tests
|
||||
|
||||
def _test_combiner_class(self):
|
||||
return TestCombiner
|
||||
|
||||
def _test_class(self):
|
||||
return TestCase
|
||||
|
||||
|
||||
class TestCase(testcase.D8TestCase):
|
||||
def __init__(self, *args, **kwargs):
|
||||
super(TestCase, self).__init__(*args, **kwargs)
|
||||
|
||||
source = self.get_source()
|
||||
|
||||
files_list = [] # List of file names to append to command arguments.
|
||||
files_match = FILES_PATTERN.search(source);
|
||||
# Accept several lines of 'Files:'.
|
||||
while True:
|
||||
if files_match:
|
||||
files_list += files_match.group(1).strip().split()
|
||||
files_match = FILES_PATTERN.search(source, files_match.end())
|
||||
else:
|
||||
break
|
||||
files = [ os.path.normpath(os.path.join(self.suite.root, '..', '..', f))
|
||||
for f in files_list ]
|
||||
testfilename = os.path.join(self.suite.root,
|
||||
self.path + self._get_suffix())
|
||||
if SELF_SCRIPT_PATTERN.search(source):
|
||||
files = (
|
||||
["-e", "TEST_FILE_NAME=\"%s\"" % testfilename.replace("\\", "\\\\")] +
|
||||
files)
|
||||
|
||||
if NO_HARNESS_PATTERN.search(source):
|
||||
mjsunit_files = []
|
||||
else:
|
||||
mjsunit_files = [os.path.join(self.suite.root, "mjsunit.js")]
|
||||
|
||||
files_suffix = []
|
||||
if MODULE_PATTERN.search(source):
|
||||
files_suffix.append("--module")
|
||||
files_suffix.append(testfilename)
|
||||
|
||||
self._source_files = files
|
||||
self._source_flags = self._parse_source_flags(source)
|
||||
self._mjsunit_files = mjsunit_files
|
||||
self._files_suffix = files_suffix
|
||||
self._env = self._parse_source_env(source)
|
||||
|
||||
def _parse_source_env(self, source):
|
||||
env_match = ENV_PATTERN.search(source)
|
||||
env = {}
|
||||
if env_match:
|
||||
for env_pair in env_match.group(1).strip().split():
|
||||
var, value = env_pair.split('=')
|
||||
env[var] = value
|
||||
return env
|
||||
|
||||
def _get_source_flags(self):
|
||||
return self._source_flags
|
||||
|
||||
def _get_files_params(self):
|
||||
files = list(self._source_files)
|
||||
if not self._test_config.no_harness:
|
||||
files += self._mjsunit_files
|
||||
files += self._files_suffix
|
||||
if self._test_config.isolates:
|
||||
files += ['--isolate'] + files
|
||||
|
||||
return files
|
||||
|
||||
def _get_cmd_env(self):
|
||||
return self._env
|
||||
|
||||
def _get_source_path(self):
|
||||
return os.path.join(self.suite.root, self.path + self._get_suffix())
|
||||
|
||||
|
||||
class TestCombiner(testsuite.TestCombiner):
|
||||
def get_group_key(self, test):
|
||||
"""Combine tests with the same set of flags.
|
||||
Ignore:
|
||||
1. Some special cases where it's not obvious what to pass in the command.
|
||||
2. Tests with flags that can cause failure even inside try-catch wrapper.
|
||||
3. Tests that use async functions. Async functions can be scheduled after
|
||||
exiting from try-catch wrapper and cause failure.
|
||||
"""
|
||||
if (len(test._files_suffix) > 1 or
|
||||
test._env or
|
||||
not test._mjsunit_files or
|
||||
test._source_files):
|
||||
return None
|
||||
|
||||
source_flags = test._get_source_flags()
|
||||
if ('--expose-trigger-failure' in source_flags or
|
||||
'--throws' in source_flags):
|
||||
return None
|
||||
|
||||
source_code = test.get_source()
|
||||
# Maybe we could just update the tests to await all async functions they
|
||||
# call?
|
||||
if 'async' in source_code:
|
||||
return None
|
||||
|
||||
# TODO(machenbach): Remove grouping if combining tests in a flag-independent
|
||||
# way works well.
|
||||
return 1
|
||||
|
||||
def _combined_test_class(self):
|
||||
return CombinedTest
|
||||
|
||||
|
||||
class CombinedTest(testcase.D8TestCase):
|
||||
"""Behaves like normal mjsunit tests except:
|
||||
1. Expected outcome is always PASS
|
||||
2. Instead of one file there is a try-catch wrapper with all combined tests
|
||||
passed as arguments.
|
||||
"""
|
||||
def __init__(self, name, tests):
|
||||
super(CombinedTest, self).__init__(tests[0].suite, '', name,
|
||||
tests[0]._test_config)
|
||||
self._tests = tests
|
||||
|
||||
def _prepare_outcomes(self, force_update=True):
|
||||
self._statusfile_outcomes = outproc.OUTCOMES_PASS_OR_TIMEOUT
|
||||
self.expected_outcomes = outproc.OUTCOMES_PASS_OR_TIMEOUT
|
||||
|
||||
def _get_shell_flags(self):
|
||||
"""In addition to standard set of shell flags it appends:
|
||||
--disable-abortjs: %AbortJS can abort the test even inside
|
||||
trycatch-wrapper, so we disable it.
|
||||
--es-staging: We blacklist all harmony flags due to false positives,
|
||||
but always pass the staging flag to cover the mature features.
|
||||
--omit-quit: Calling quit() in JS would otherwise early terminate.
|
||||
--quiet-load: suppress any stdout from load() function used by
|
||||
trycatch-wrapper.
|
||||
"""
|
||||
return [
|
||||
'--test',
|
||||
'--disable-abortjs',
|
||||
'--es-staging',
|
||||
'--omit-quit',
|
||||
'--quiet-load',
|
||||
]
|
||||
|
||||
def _get_cmd_params(self):
|
||||
return (
|
||||
super(CombinedTest, self)._get_cmd_params() +
|
||||
['tools/testrunner/trycatch_loader.js', '--'] +
|
||||
self._tests[0]._mjsunit_files +
|
||||
['--'] +
|
||||
[t._files_suffix[0] for t in self._tests]
|
||||
)
|
||||
|
||||
def _merge_flags(self, flags):
|
||||
"""Merges flags from a list of flags.
|
||||
|
||||
Flag values not starting with '-' are merged with the preceeding flag,
|
||||
e.g. --foo 1 will become --foo=1. All other flags remain the same.
|
||||
|
||||
Returns: A generator of flags.
|
||||
"""
|
||||
if not flags:
|
||||
return
|
||||
# Iterate over flag pairs. ['-'] is a sentinel value for the last iteration.
|
||||
for flag1, flag2 in itertools.izip(flags, flags[1:] + ['-']):
|
||||
if not flag2.startswith('-'):
|
||||
assert '=' not in flag1
|
||||
yield flag1 + '=' + flag2
|
||||
elif flag1.startswith('-'):
|
||||
yield flag1
|
||||
|
||||
def _is_flag_blacklisted(self, flag):
|
||||
for item in COMBINE_TESTS_FLAGS_BLACKLIST:
|
||||
if isinstance(item, basestring):
|
||||
if item == flag:
|
||||
return True
|
||||
elif item.match(flag):
|
||||
return True
|
||||
return False
|
||||
|
||||
def _get_combined_flags(self, flags_gen):
|
||||
"""Combines all flags - dedupes, keeps order and filters some flags.
|
||||
|
||||
Args:
|
||||
flags_gen: Generator for flag lists.
|
||||
Returns: A list of flags.
|
||||
"""
|
||||
merged_flags = self._merge_flags(list(itertools.chain(*flags_gen)))
|
||||
unique_flags = OrderedDict((flag, True) for flag in merged_flags).keys()
|
||||
return [
|
||||
flag for flag in unique_flags
|
||||
if not self._is_flag_blacklisted(flag)
|
||||
]
|
||||
|
||||
def _get_source_flags(self):
|
||||
# Combine flags from all source files.
|
||||
return self._get_combined_flags(
|
||||
test._get_source_flags() for test in self._tests)
|
||||
|
||||
def _get_statusfile_flags(self):
|
||||
# Combine flags from all status file entries.
|
||||
return self._get_combined_flags(
|
||||
test._get_statusfile_flags() for test in self._tests)
|
||||
|
||||
|
||||
def GetSuite(*args, **kwargs):
|
||||
return TestSuite(*args, **kwargs)
|
||||
Loading…
Reference in New Issue