code stringlengths 1 2.08M | language stringclasses 1
value |
|---|---|
class LetInClass {
get z() {
let let_z = 10;
return let_z;
}
set z(v) {
let let_zv = v;
}
distance() {
let dist = this.y - this.x;
return dist;
}
}
// ----------------------------------------------------------------------------
| JavaScript |
// Should not compile.
// Options: --blockBinding=false
{
let x = 42;
}
| JavaScript |
var x = 1;
{
let x;
assertEquals(undefined, x);
x = 2;
assertEquals(2, x);
}
assertEquals(1, x);
| JavaScript |
// Should not compile.
for (let i = 0 in {}) {
}
| JavaScript |
let result = [];
for (let a = 1; a < 3; a++) {
result.push(
function() { return 'for ' + a; }
);
}
// ----------------------------------------------------------------------------
assertEquals('for 1', result[0]());
assertEquals('for 2', result[1]());
assertEquals(2, result.length);
| JavaScript |
for (var x = 0; x < 10; x ++) {
let y = 'let y';
if (x % 2 == 0) {
break;
}
}
// ----------------------------------------------------------------------------
| JavaScript |
// Should not compile.
const x = 1, y; // Missing initializer!
| JavaScript |
var a = 'var a';
{
var b = 'var b';
{
var c = 'var c';
let d = 'let d';
}
}
// ----------------------------------------------------------------------------
| JavaScript |
var a = 'var a';
{
var b = 'var b';
{
let c = 'let c';
{
const d = 'const d';
}
}
}
// ----------------------------------------------------------------------------
| JavaScript |
// Should not compile.
// Error: functionExpression is not defined
{
(function functionExpression() {
return 'inner';
});
functionExpression; // function expression doesn't add name to the scope.
}
| JavaScript |
function f() {
return 'outer';
}
{
var f = function f() {
return 'inner';
};
assertEquals('inner', f());
}
assertEquals('inner', f());
| JavaScript |
let sum = 0;
let a = [1,2,3];
for (let x in a) {
sum = sum + a[x];
}
// ----------------------------------------------------------------------------
| JavaScript |
function f() {
return 'outer';
}
{
function f() {
return 'inner';
}
assertEquals('inner', f());
}
assertEquals('outer', f());
| JavaScript |
let x = 'let';
var y = 'var';
// ----------------------------------------------------------------------------
assertEquals('let', x);
assertEquals('var', y);
| JavaScript |
var f1, f2;
{
let z = 'z1 value';
f1 = function() { return z; };
}
{
let z = 'z2 value';
f2 = function() { return z; };
}
// ----------------------------------------------------------------------------
assertEquals('z1 value', f1());
assertEquals('z2 value', f2());
| JavaScript |
let x2;
assertEquals(undefined, x2);
x2 = 2;
assertEquals(2, x2);
| JavaScript |
// Should not compile.
function* gen() {
yield 1;
}
for (let i = 0 of gen()) {
}
| JavaScript |
function blockTest() {
{
let x = 'let x value';
function g() {
return x;
}
return g;
}
}
// ----------------------------------------------------------------------------
assertEquals('let x value', blockTest()());
| JavaScript |
let result = [];
for (let i = 1; i < 3; i ++) {
for (let j = 9; j > 7; j --) {
result.push(
function() { return i + ':' + j; }
);
}
}
// ----------------------------------------------------------------------------
assertEquals('1:9', result[0]());
assertEquals('1:8', result[1]());
assertEquals('2:9... | JavaScript |
outer:
for (var x = 0; x < 10; x ++) {
for (var y = 0; y < 10; y ++) {
let z = 'let z';
if (x == 7) {
continue outer;
}
}
}
// ----------------------------------------------------------------------------
| JavaScript |
for (var x = 0; x < 10; x++) {
let let_y = 'let y';
for (var for_z = 0; for_z < 2; for_z ++) {
break;
}
}
// ----------------------------------------------------------------------------
| JavaScript |
if (true) {
let [a,b] = [1,2];
const [c,d] = [4,5];
}
if (true) {
let {x: [{e}, f], g} = {x: [{e:4}, 5], g: 6};
const a = 0, [b, {c, x: [d]}] = [1, {c: 2, x: [3]}];
}
// ----------------------------------------------------------------------------
| JavaScript |
var x = 'var';
{
let y = 'let 1';
}
{
let y = 'let 2';
}
// ----------------------------------------------------------------------------
| JavaScript |
// Should not compile.
var i = 0;
for (const x; i < 3; i++) {
}
| JavaScript |
let result = [];
let obj = {a : 'hello a', b : 'hello b', c : 'hello c' };
for (let x in obj) {
result.push(
function() { return obj[x]; }
);
}
// ----------------------------------------------------------------------------
assertEquals('hello a', result[0]());
assertEquals('hello b', result[1]());
assertEqua... | JavaScript |
for (var x = 0; x < 10; x ++) {
for (var y = 0; y < 10; y ++) {
let z = 'let z';
if (x == 7) {
break;
}
}
}
// ----------------------------------------------------------------------------
| JavaScript |
var result;
{
let let_result = [];
let let_array = ['one', 'two', 'three'];
for (var index = 1 in let_array) {
let let_index = index;
let let_value = let_array[let_index];
let_result.push(
function() {
return [let_index, let_value];
});
}
result = let_result;
}
// ------... | JavaScript |
for (let x = 1; x < 10; x ++) {
console.log(x);
}
// ----------------------------------------------------------------------------
| JavaScript |
for (let x = 1, y = x + 1; x < 10 && y != 0; x ++, y *= 2) {
if (y > 300) {
continue;
}
}
// ----------------------------------------------------------------------------
| JavaScript |
for (var x = 0; x < 10; x ++) {
let y = 'let y';
if (x % 2 == 0) {
continue;
}
}
// ----------------------------------------------------------------------------
| JavaScript |
// Should not compile.
// Error: let/const in for-in statement may not have initializer
for (const i = 0 in {}) {
}
| JavaScript |
let x = 'let';
const y = 'const';
// ----------------------------------------------------------------------------
assertEquals('let', x);
assertEquals('const', y);
| JavaScript |
function nestedFunction3() {
let let_x = 'let x';
function function_foo() { }
}
// ----------------------------------------------------------------------------
| JavaScript |
// Should not compile.
function* gen() {
yield 1;
}
for (var i = 0 of gen()) {
}
| JavaScript |
var var_a;
{
var var_b;
{
let let_c = 'let c';
{
var var_d;
}
}
}
// ----------------------------------------------------------------------------
| JavaScript |
function nestedFunction1() {
return function() {
let let_x = 'let x';
}
}
// ----------------------------------------------------------------------------
| JavaScript |
let x = 'let';
// ----------------------------------------------------------------------------
assertEquals(x, 'let'); | JavaScript |
for (let x = 1, y = 2, z = 3; x < 10; x ++) {
y++;
z++;
}
// ----------------------------------------------------------------------------
| JavaScript |
outer:
for (var x = 0; x < 10; x ++) {
for (var y = 0; y < 10; y ++) {
let z = 'let z';
if (x == 7) {
break outer;
}
}
}
// ----------------------------------------------------------------------------
| JavaScript |
var x = 0;
// ES5 allows this.
for (var i = (x = 1) in {}) {
}
assertEquals(1, x);
| JavaScript |
// Should not compile.
// Error: inner is not defined
function testBlock() {
{
let inner = 'inner value';
}
var x = inner;
}
// ----------------------------------------------------------------------------
| JavaScript |
function testBlock() {
// Test function expressions.
{
var x = function g() { return 'g'; } || function h() { return 'h'; };
return x;
}
}
// ----------------------------------------------------------------------------
var result = testBlock();
assertEquals('g', result());
| JavaScript |
function nestedFunction2() {
let let_func = function() {
let let_x = 'let x';
}
return let_func;
}
// ----------------------------------------------------------------------------
| JavaScript |
for (var i = 0; i < 5; i ++) {
let let_x = 'let x';
switch (i) {
case 0:
continue;
case 2:
break;
default:
break;
}
}
// ----------------------------------------------------------------------------
| JavaScript |
var object = {
get x() {
while (true) {
let let_x = 'let x';
return let_x;
}
},
set x(v) {
do {
let let_v = v;
this.v = let_v;
} while (false);
}
}
// ----------------------------------------------------------------------------
| JavaScript |
// Should not compile.
function* gen() {
yield 1;
}
for (const i = 0 of gen()) {
}
| JavaScript |
for (var x in [1,2,3]) {
let let_y = x;
for (var for_in_z in [4,5,6]) {
continue;
}
}
// ----------------------------------------------------------------------------
| JavaScript |
class Empty {}
class EmptyB extends Empty {
}
// ----------------------------------------------------------------------------
var e = new Empty();
assertNotNull(e);
for (var element in e) {
assertEquals('constructor', element);
}
for (var element in Empty) {
fail('Empty contains static member : ' + element);
}... | JavaScript |
class ImmutablePoint {
get x () { return this.x_; }
get y () { return this.y_; }
}
class MutablePoint {
get x () { return this.x_; }
set x (x) { this.x_ = x; }
get y () { return this.y_; }
set y (y) { this.y_ = y; }
}
// ----------------------------------------------------------------------------
var imm... | JavaScript |
// Skip. Not implemented.
// Only in browser.
class CustomBlockquote extends HTMLBlockquoteElement {
constructor() {
this.custom = 42;
}
}
var customBlockquote = new CustomBlockquote;
assertEquals(42, customBlockquote.custom);
assertEquals('BLOCKQUOTE', customBlockquote.tagName);
assertTrue(customBlockquote i... | JavaScript |
// Should not compile.
// Options: --classes=false
class C {}
| JavaScript |
// Skip. Not implemented.
// Only in browser.
class CustomButton extends HTMLButtonElement {
constructor() {
this.value = 'Custom Button';
}
}
class CustomSelect extends HTMLSelectElement {}
class CustomInput extends HTMLInputElement {}
class CustomDiv extends HTMLDivElement {}
class CustomUIEvent extends UIE... | JavaScript |
var baseContainer = {
base: function() {}
}
baseContainer.base.prototype = {
x: 'proto x',
constructor: function() {
this.y = 'base y';
}
}
class MemberExprBase extends baseContainer.base {
constructor(w) {
super();
this.z = 'var z';
this.w = w;
}
}
// ------------------------------------... | JavaScript |
var b = {
x: 42,
m() {
return 'b.m';
}
};
class C extends b {
get x() {
return super.x;
}
m() {
return super.m();
}
}
// ----------------------------------------------------------------------------
var c = new C;
assertTrue(c instanceof C);
assertEquals(Object.getPrototypeOf(c), C.prototype... | JavaScript |
class MissingSuperA {}
class MissingSuperB extends MissingSuperA {
method() {
return super.foo();
}
field() {
return super.foo;
}
}
// ----------------------------------------------------------------------------
// Collect the expected values.
var expectedF;
var expectedM;
var actualF;
var actualM;
... | JavaScript |
class B {
constructor() {
this._y = {v: 321};
this._z = 1;
}
set x(value) {
this._x = value;
}
get x() {
return this._y;
}
getX() {
return this._x;
}
getV() {
return this._y.v
}
set z(v) {
this._z = v;
}
get z() {
return this._z;
}
}
class C extends B {
co... | JavaScript |
class Point {
constructor() {
this.x = 0;
this.y = 0;
}
}
// ----------------------------------------------------------------------------
var p = new Point();
var keys = [];
for (var key in p) {
keys.push(key);
}
assertTrue(keys.indexOf('x') !== -1);
assertTrue(keys.indexOf('y') !== -1);
assertTrue(ke... | JavaScript |
class C extends null {}
// ----------------------------------------------------------------------------
var c = new C;
assertTrue(c instanceof C);
assertFalse(c instanceof Object);
// Closure testing framework tries to toString the object and fails.
assertTrue(Object.getPrototypeOf(c) === C.prototype);
assertTrue(Ob... | JavaScript |
class SuperBase {
m() { return 40; }
get x () { return this.baseX; }
set x (value) { this.baseX = value; }
constructor() {
this.baseC = 2;
this.baseX = 4;
}
}
class SuperDerived extends SuperBase {
m() { return 41; }
superM() { return super.m(); }
superX() { return super.x; }
constructor() {
... | JavaScript |
class SimpleBase {}
class SimpleDerived extends SimpleBase {}
// ----------------------------------------------------------------------------
var derived = new SimpleDerived();
assertTrue(derived instanceof SimpleDerived);
assertTrue(derived instanceof SimpleBase);
assertTrue(derived instanceof Object);
| JavaScript |
// This requires manually constructed classes.
function fieldLookupA() { }
fieldLookupA.prototype = {
foo : "A.value",
get bar() {
return "A.get.bar";
},
set bar(value) { },
boo : "A.boo.value",
baz : undefined
}
function fieldLookupB() { }
fieldLookupB.prototype = {
__proto__ : fieldLookupA.prototy... | JavaScript |
class Point2D {
constructor() {
this.x = 1;
this.y = 2;
}
}
class Point3D extends Point2D {
constructor() {
super();
this.z = 3;
}
}
// ----------------------------------------------------------------------------
var a = new Point2D();
assertTrue(a.hasOwnProperty('x'));
assertTrue(a.hasOwnPro... | JavaScript |
class Universe {
answer() {
return 42;
}
}
// ----------------------------------------------------------------------------
var universe = new Universe();
assertEquals(42, universe.answer());
var keys = [];
for (var key in universe) {
keys.push(key);
}
assertTrue(keys.indexOf('answer') === -1);
assertTrue(k... | JavaScript |
class ElementHolder {
getElement() { return this.element; }
makeFilterCapturedThis() {
var capturedThis = this;
return function (x) {
return x == capturedThis.element;
}
}
makeFilterLostThis() {
return function () { return this; }
}
makeFilterHidden(element) {
return function (x... | JavaScript |
function noClassA() {}
noClassA.prototype = {
ma: function() { return 'ma'; }
}
class NoClassB extends noClassA {
mb() {
return 'mb ' + super.ma();
}
}
// ----------------------------------------------------------------------------
var b = new NoClassB;
assertTrue(b instanceof noClassA);
assertEquals('ma',... | JavaScript |
class Point {
constructor() {
this.x = 0;
this.y = 0;
}
}
// ----------------------------------------------------------------------------
var p = new Point();
assertEquals(0, p.x);
assertEquals(0, p.y);
p.x = 1;
assertEquals(1, p.x);
var p2 = new Point();
assertEquals(0, p2.x);
assertEquals(0, p2.y);
ass... | JavaScript |
class Point {
constructor(x, y) {
this.x = x;
this.y = y;
}
}
// ----------------------------------------------------------------------------
var p = new Point(1, 2);
assertEquals(1, p.x);
assertEquals(2, p.y);
var p2 = new Point(3, 4);
assertEquals(3, p2.x);
assertEquals(4, p2.y);
assertEquals(1, p.x);
... | JavaScript |
class OptionalParams {
constructor(opt = 1) {
this.opt = opt;
}
instanceMethod(opt = 2) {
return opt;
}
}
// ----------------------------------------------------------------------------
var obj = new OptionalParams();
assertEquals(1, obj.opt);
assertEquals(2, obj.instanceMethod());
assertEquals(3, obj... | JavaScript |
class GetterA {
get x() { return 'getter x'; }
get y() { return 'getter y'; }
}
class GetterB extends GetterA {
get x() { return super.x; }
}
class GetterC extends GetterB {
get y() { return super.y; }
}
// ----------------------------------------------------------------------------
var b = new GetterB();
v... | JavaScript |
class ConstructorA {
constructor(x) {
this.x = x;
}
}
class ConstructorB extends ConstructorA {
constructor(x, y) {
super(x);
this.y = y;
}
}
// ----------------------------------------------------------------------------
var a = new ConstructorA('ax');
assertEquals('ax', a.x);
assertFalse(a.hasO... | JavaScript |
class NameBindingBase {}
class NameBindingDerived extends NameBindingBase {
getX() { return this.x; }
}
// ----------------------------------------------------------------------------
var derived = new NameBindingDerived();
derived.x = 12;
assertEquals(12, derived.getX());
| JavaScript |
class ConstructorMember {
constructor() {}
}
class DerivedConstructorMember extends ConstructorMember {
constructor() {}
}
// ----------------------------------------------------------------------------
var cm = new ConstructorMember;
assertEquals(cm.constructor, ConstructorMember.prototype.constructor);
assertT... | JavaScript |
class DerivedFromObject extends Object {
}
// ----------------------------------------------------------------------------
// TODO(rnystrom): No tests for this?
| JavaScript |
function B() {}
B.b = function() {
return 'B.b';
};
class C extends B {}
assertEquals(Object.getPrototypeOf(C), B);
assertEquals(Object.getPrototypeOf(C.prototype), B.prototype);
assertEquals(C.b(), 'B.b');
| JavaScript |
class MethodsA {
ma() {}
}
class MethodsB extends MethodsA {
mb() {}
}
class MethodsC extends MethodsB {
mc() {}
}
// ----------------------------------------------------------------------------
var a = new MethodsA();
var b = new MethodsB();
var c = new MethodsC();
var pa = Object.getPrototypeOf(a);
var pb ... | JavaScript |
class RestParams {
constructor(...rest) {
this.rest = rest;
}
instanceMethod(...rest) {
return rest;
}
}
// ----------------------------------------------------------------------------
var obj = new RestParams(0, 1, 2);
assertArrayEquals([0, 1, 2], obj.rest);
assertArrayEquals([3, 4, 5], obj.instanceM... | JavaScript |
class MethodLookupA {
foo() {
return 'A.foo()';
}
get bar() {
return 'A.get.bar';
}
set bar(value) { }
}
class MethodLookupB extends MethodLookupA {
get foo() {
return 'B.foo.get';
}
set foo(value) { }
bar() {
return 'B.bar()';
}
}
class MethodLookupC extends MethodLookupB {
x() ... | JavaScript |
class ChainA {
foo() {
return 'A';
}
}
class ChainB extends ChainA {
foo() {
return super.foo() + ' B';
}
}
class ChainC extends ChainB {
foo() {
return super.foo() + ' C';
}
}
class ChainD extends ChainC {
foo() {
return super.foo() + ' D';
}
}
// -----------------------------------... | JavaScript |
// Should not compile.
// Options: --isExpression=false
42 is 42;
| JavaScript |
assertTrue(1 is 1);
assertTrue(0 is 0);
assertTrue(-0 is -0);
assertTrue(NaN is NaN);
assertTrue(Infinity is Infinity);
assertTrue(-Infinity is -Infinity);
assertTrue(0 isnt -0);
assertTrue(-0 isnt 0);
assertFalse(0 is -0);
assertFalse(-0 is 0);
assertTrue(Infinity isnt -Infinity);
assertTrue(-Infinity isnt Infinity);... | JavaScript |
assertTrue(Object.is(1, 1));
assertTrue(Object.is(0, 0));
assertTrue(Object.is(-0, -0));
assertTrue(Object.is(NaN, NaN));
assertTrue(Object.is(Infinity, Infinity));
assertTrue(Object.is(-Infinity, -Infinity));
assertFalse(Object.is(0, -0));
assertFalse(Object.is(-0, 0));
assertFalse(Object.is(Infinity, -Infinity));
as... | JavaScript |
// Should not compile.
assertTrue(42
is 42);
assertTrue(42 // no line break allowed.
is 42);
assertTrue(42 /* no line break allowed. */
is 42);
| JavaScript |
{
let lastX;
function is(x) {
lastX = x;
return x + 1;
}
// OK since is is defined
42
is
42
assertTrue(42 is
42); // line terminator OK after is.
assertTrue(1 is (1));
assertTrue(lastX === undefined);
let x = 1
is (2);
assertTrue(x === 1);
assertTrue(lastX === ... | JavaScript |
// Should not compile.
// Options: --propertyNameShorthand=false
var x = 42;
var object = {x};
| JavaScript |
var x = 42;
var y = 43;
var object = {x, y};
// ----------------------------------------------------------------------------
assertEquals(42, object.x);
assertEquals(43, object.y);
| JavaScript |
// Should not compile.
// Error: missingVar is not defined
var object = {missingVar};
| JavaScript |
// Should not compile.
var object = {var};
| JavaScript |
// Should not compile.
// Options: --deferredFunctions=false
function asyncComplete() {
var task = new Deferred();
task.callback('complete');
return task.createPromise();
}
// ----------------------------------------------------------------------------
(function() {
var value;
await value = asyncComplete()... | JavaScript |
function asyncValue(value) {
if (true)
return value;
await asyncYield();
}
function asyncYield() {
return asyncTimeout(0);
}
function asyncTimeout(ms) {
var task = new Deferred();
messageQueue.push(function() {
task.callback(undefined);
});
return task.createPromise();
}
var done = false;
var m... | JavaScript |
function asyncComplete() {
var task = new Deferred();
task.callback('complete');
return task.createPromise();
}
// ----------------------------------------------------------------------------
(function() {
var value;
await value = asyncComplete();
assertEquals('complete', value);
})();
| JavaScript |
function asyncThrow(e) {
if (true)
throw e;
await asyncYield();
}
function asyncYield() {
return asyncTimeout(0);
}
function asyncTimeout(ms) {
var task = new Deferred();
messageQueue.push(function() {
task.callback(undefined);
});
return task.createPromise();
}
var done = false;
var messageQue... | JavaScript |
function asyncYield() {
return asyncTimeout(0);
}
function asyncTimeout(ms) {
var task = new Deferred();
messageQueue.push(function() {
task.callback(undefined);
});
return task.createPromise();
}
var done = false;
var messageQueue = [];
function run(f) {
return function() {
done = false;
f()... | JavaScript |
var finallyVisited = false;
var d = new Deferred;
var v;
function test() {
try {
await v = d;
} finally {
finallyVisited = true;
}
}
test();
assertFalse(finallyVisited);
d.callback(42)
assertEquals(42, v);
assertTrue(finallyVisited)
| JavaScript |
function asyncTimeout(ms) {
var task = new Deferred();
messageQueue.push(function() {
task.callback(undefined);
});
return task.createPromise();
}
var done = false;
var messageQueue = [];
function run(f) {
return function() {
done = false;
f();
while (dequeue()) {
// intentionally empt... | JavaScript |
// Options: --cascade-expression=false
// Should not compile.
var object = {};
object.{
a = 0;
b = 1;
};
| JavaScript |
var object = {
a: 'A',
c: [0, 1, 2],
d: {
e: 'E'
},
f: function() {
this.F = 'F';
},
g: function(x) {
this.G = x;
}
};
var result = object.{
a = 'A2';
b = 'B' // ASI
c[1] = 11;
f();
g('G');
d.{
e = 'E2'
};
h = 'H';
}.{
i = 'I'
};
assertEquals(object, result);
assertE... | JavaScript |
// Should not compile.
var object = {};
object.{
'a' = 'a';
1 = 1;
true = true;
null = null;
}; | JavaScript |
{
var object = {};
var self = {};
function f() {
object.{
self = this;
}
}
f.call(self);
assertEquals(self, object.self);
}
| JavaScript |
// Should not compile.
var object = {};
object.{
['a'] = 'a';
[1] = 1;
(1 + 2) = 3;
}; | JavaScript |
{
var object = {};
function f() {
object.{
arguments = arguments;
}
}
f(0, 1);
assertEquals(0, object.arguments[0]);
assertEquals(1, object.arguments[1]);
}
| JavaScript |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.