public void Properties() { EcmaValue iterator = RegExp.Construct(".").Invoke(Symbol.MatchAll, ""); EcmaValue proto = Object.Invoke("getPrototypeOf", iterator); That(proto, Has.OwnProperty(WellKnownSymbol.ToStringTag, "RegExp String Iterator", EcmaPropertyAttributes.Configurable)); }
public void Properties() { EcmaValue iterator = Map.Construct().Invoke(Symbol.Iterator); EcmaValue proto = Object.Invoke("getPrototypeOf", iterator); That(proto, Has.OwnProperty(WellKnownSymbol.ToStringTag, "Map Iterator", EcmaPropertyAttributes.Configurable)); }
public void ByteLength(RuntimeFunction byteLength) { IsUnconstructableFunctionWLength(byteLength, "get byteLength", 0); That(SharedArrayBuffer.Prototype, Has.OwnProperty("byteLength", EcmaPropertyAttributes.Configurable)); That(SharedArrayBuffer.Prototype.GetOwnProperty("byteLength").Set, Is.Undefined); It("should throw a TypeError when this is not an object", () => { Case(Undefined, Throws.TypeError); Case(Null, Throws.TypeError); Case(false, Throws.TypeError); Case(0, Throws.TypeError); Case("", Throws.TypeError); Case(new Symbol(), Throws.TypeError); }); It("should throw a TypeError exception when `this` does not have a [[ArrayBufferData]]", () => { Case(SharedArrayBuffer.Prototype, Throws.TypeError); Case(Object.Construct(), Throws.TypeError); Case(EcmaArray.Of(), Throws.TypeError); Case(Global.Int8Array.Construct(8), Throws.TypeError); Case(Global.DataView.Construct(SharedArrayBuffer.Construct(8), 0), Throws.TypeError); }); It("should throw a TypeError if `this` is a ArrayBuffer", () => { Case(Global.ArrayBuffer.Construct(0), Throws.TypeError); }); It("should return value from [[ByteLength]] internal slot", () => { Case(SharedArrayBuffer.Construct(0), 0); Case(SharedArrayBuffer.Construct(42), 42); }); }
public void Instance() { It("should support indexing notation to look up non numeric property names", () => { EcmaValue str = "hello world"; That(str[0], Is.EqualTo("h")); That(str["foo"], Is.Undefined); That(str[-1], Is.Undefined); That(str[11], Is.Undefined); That(str[NaN], Is.Undefined); That(str[Infinity], Is.Undefined); EcmaValue strObj = String.Construct(str); strObj["foo"] = 1; That(strObj["foo"], Is.EqualTo(1)); EcmaValue strObj2 = String.Construct(str); That(strObj2["foo"], Is.Undefined); }); It("should have the \"length\" property", () => { That(String.Construct(""), Has.OwnProperty("length", 0, EcmaPropertyAttributes.None)); That(String.Construct(" "), Has.OwnProperty("length", 1, EcmaPropertyAttributes.None)); That(String.Construct(" \b "), Has.OwnProperty("length", 3, EcmaPropertyAttributes.None)); That(String.Construct("\ud834\udf06"), Has.OwnProperty("length", 2, EcmaPropertyAttributes.None)); }); It("should have property descriptor for numeric own properties of an exotic String object", () => { EcmaValue str = String.Construct("abc"); That(str, Has.OwnProperty("0", "a", EcmaPropertyAttributes.Enumerable)); That(str, Has.OwnProperty("1", "b", EcmaPropertyAttributes.Enumerable)); That(str, Has.OwnProperty("2", "c", EcmaPropertyAttributes.Enumerable)); }); }
public void Properties() { That(BigInt, Has.OwnProperty("prototype", BigInt.Prototype, EcmaPropertyAttributes.None)); That(BigInt.Prototype, Has.OwnProperty("constructor", BigInt, EcmaPropertyAttributes.Writable | EcmaPropertyAttributes.Configurable)); That(BigInt.Prototype, Has.OwnProperty(WellKnownSymbol.ToStringTag, "BigInt", EcmaPropertyAttributes.Configurable)); That(BigInt.Prototype.GetPrototypeOf(), Is.EqualTo(Object.Prototype)); }
public void Properties() { That(Object.Invoke("getPrototypeOf", Reflect), Is.EqualTo(Object.Prototype)); That(GlobalThis, Has.OwnProperty("Reflect", Reflect, EcmaPropertyAttributes.Writable | EcmaPropertyAttributes.Configurable)); That(() => Reflect.Call(), Throws.TypeError); That(() => Reflect.Construct(), Throws.TypeError); }
public void Properties() { That(GlobalThis, Has.OwnProperty("JSON", Global.Json, EcmaPropertyAttributes.Writable | EcmaPropertyAttributes.Configurable)); That(Global.Json, Has.OwnProperty(WellKnownSymbol.ToStringTag, "JSON", EcmaPropertyAttributes.Configurable)); That(Global.Json, Is.TypeOf("object")); That(() => Global.Json.Call(This), Throws.TypeError); That(() => Global.Json.Construct(), Throws.TypeError); }
public void Properties() { That(SharedArrayBuffer, Has.OwnProperty("prototype", SharedArrayBuffer.Prototype, EcmaPropertyAttributes.None)); That(SharedArrayBuffer.Prototype, Has.OwnProperty("constructor", SharedArrayBuffer, EcmaPropertyAttributes.Writable | EcmaPropertyAttributes.Configurable)); That(SharedArrayBuffer.Prototype, Has.OwnProperty(WellKnownSymbol.ToStringTag, "SharedArrayBuffer", EcmaPropertyAttributes.Configurable)); That(SharedArrayBuffer.Prototype.GetPrototypeOf(), Is.EqualTo(Object.Prototype)); That(Object.Prototype.Get("toString").Call(SharedArrayBuffer.Prototype), Is.EqualTo("[object SharedArrayBuffer]")); }
public void Properties() { That(Symbol.Prototype, Has.OwnProperty("constructor", Symbol, EcmaPropertyAttributes.Writable | EcmaPropertyAttributes.Configurable)); That(Symbol.Prototype.GetPrototypeOf(), Is.EqualTo(Object.Prototype)); That(Object.Prototype.Get("toString").Call(Symbol.Prototype), Is.EqualTo("[object Symbol]"), "Symbol prototype object: its [[Class]] must be 'Symbol'"); That(Symbol.Prototype, Has.OwnProperty(WellKnownSymbol.ToStringTag, "Symbol", EcmaPropertyAttributes.Configurable)); }
public void Properties() { That(Promise, Has.OwnProperty("prototype", Promise.Prototype, EcmaPropertyAttributes.None)); That(Promise.Prototype, Has.OwnProperty("constructor", Promise, EcmaPropertyAttributes.Writable | EcmaPropertyAttributes.Configurable)); That(Promise.Prototype, Has.OwnProperty(WellKnownSymbol.ToStringTag, "Promise", EcmaPropertyAttributes.Configurable)); That(Promise.Prototype.GetPrototypeOf(), Is.EqualTo(Object.Prototype)); That(Object.Prototype.Get("toString").Call(Promise.Prototype), Is.EqualTo("[object Promise]")); That(() => Promise.Prototype["then"].Call(Promise.Prototype, Noop, Noop), Throws.TypeError, "Promise.prototype does not have a [[PromiseState]] internal slot"); }
public void Properties() { EcmaValue AsyncFunction = FunctionLiteral(async() => { })["constructor"]; EcmaValue AsyncFunctionPrototype = AsyncFunction["prototype"]; That(Object.Invoke("isExtensible", AsyncFunctionPrototype), Is.True, "The initial value of the [[Extensible]] internal slot of the AsyncFunction prototype object is true"); That(Object.Invoke("getPrototypeOf", AsyncFunctionPrototype), Is.EqualTo(Function.Prototype)); That(AsyncFunctionPrototype, Has.OwnProperty(Symbol.ToStringTag, "AsyncFunction", EcmaPropertyAttributes.Configurable)); That(AsyncFunctionPrototype, Has.OwnProperty("constructor", AsyncFunction, EcmaPropertyAttributes.Configurable)); That(AsyncFunction, Has.OwnProperty("prototype", AsyncFunctionPrototype, EcmaPropertyAttributes.None)); }
public void Apply(RuntimeFunction apply) { IsUnconstructableFunctionWLength(apply, "apply", 3); That(Reflect, Has.OwnProperty("apply", apply, EcmaPropertyAttributes.DefaultMethodProperty)); It("should return abrupt if argumentsList is not an ArrayLike object", () => { EcmaValue fn = Function.Construct(); EcmaValue o = CreateObject(("length", get: ThrowTest262Exception, set: null)); Case((_, fn, 1, o), Throws.Test262); Case((_, fn, 1, 1), Throws.TypeError); });
public void Properties() { EcmaValue GeneratorFunctionPrototype = Object.Invoke("getPrototypeOf", new GeneratorFunction(EmptyGenerator)); EcmaValue GeneratorFunction = GeneratorFunctionPrototype["constructor"]; That(Object.Invoke("isExtensible", GeneratorFunctionPrototype), Is.True, "The initial value of the [[Extensible]] internal slot of the GeneratorFunction prototype object is true"); That(GeneratorFunctionPrototype, Has.OwnProperty(Symbol.ToStringTag, "GeneratorFunction", EcmaPropertyAttributes.Configurable)); That(GeneratorFunctionPrototype, Has.OwnProperty("prototype", (RuntimeObject)WellKnownObject.GeneratorPrototype, EcmaPropertyAttributes.Configurable)); That(GeneratorFunctionPrototype, Has.OwnProperty("constructor", GeneratorFunction, EcmaPropertyAttributes.Configurable)); That(GeneratorFunction, Has.OwnProperty("prototype", GeneratorFunctionPrototype, EcmaPropertyAttributes.None)); }
public void Properties() { RuntimeRealm realm = new RuntimeRealm(); EcmaValue Symbol = Global.Symbol; EcmaValue OSymbol = realm.GetRuntimeObject(WellKnownObject.SymbolConstructor); foreach (var i in new[] { "asyncIterator", "hasInstance", "isConcatSpreadable", "iterator", "match", "matchAll", "replace", "search", "species", "split", "toPrimitive", "toStringTag", "unscopables" }) { That(Symbol, Has.OwnProperty(i, EcmaPropertyAttributes.None), "Symbol.{0} descriptor", i); That(Symbol[i], Is.EqualTo(OSymbol[i]), "well-known symbols values are shared by all realms"); } }
public void Species(RuntimeFunction species) { That(SharedArrayBuffer, Has.OwnProperty(WellKnownSymbol.Species, EcmaPropertyAttributes.Configurable)); That(SharedArrayBuffer.GetOwnProperty(WellKnownSymbol.Species).Set, Is.Undefined); IsUnconstructableFunctionWLength(species, "get [Symbol.species]", 0); Case(SharedArrayBuffer, Is.EqualTo(SharedArrayBuffer)); EcmaValue thisValue = new EcmaObject(); Case(thisValue, Is.EqualTo(thisValue)); }
public void Iterator(RuntimeFunction iterator) { IsUnconstructableFunctionWLength(iterator, "[Symbol.iterator]", 0); EcmaValue iterProto = Object.Invoke("getPrototypeOf", Object.Invoke("getPrototypeOf", Array.Construct().Invoke(Symbol.Iterator))); That(iterProto, Has.OwnProperty(Symbol.Iterator, iterator, EcmaPropertyAttributes.DefaultMethodProperty)); EcmaValue thisValue = Object.Construct(); Case(thisValue, thisValue); }
public void AsyncIterator(RuntimeFunction asyncIterator) { IsUnconstructableFunctionWLength(asyncIterator, "[Symbol.asyncIterator]", 0); AsyncGeneratorFunction generator = new AsyncGeneratorFunction(EmptyGenerator); EcmaValue iterProto = Object.Invoke("getPrototypeOf", Object.Invoke("getPrototypeOf", generator.Prototype)); That(iterProto, Has.OwnProperty(Symbol.AsyncIterator, asyncIterator, EcmaPropertyAttributes.DefaultMethodProperty)); EcmaValue thisValue = Object.Construct(); Case(thisValue, thisValue); }
public void DerivedConstructor() { foreach (string derived in new[] { "EvalError", "RangeError", "ReferenceError", "SyntaxError", "TypeError", "URIError" }) { That(GlobalThis[derived], Is.TypeOf("function")); RuntimeFunction ctor = (RuntimeFunction)GlobalThis[derived].ToObject(); WellKnownObject protoType = (WellKnownObject)System.Enum.Parse(typeof(WellKnownObject), derived + "Prototype", true); IsConstructorWLength(ctor, derived, 1, ctor.Realm.GetRuntimeObject(protoType), Error); IsAbruptedFromToPrimitive(ctor.Bind(_)); That(ctor.Call(), Is.InstanceOf(ctor)); That(Object.Prototype["toString"].Call(ctor.Construct()), Is.EqualTo("[object Error]")); It("should coerce first argument to string", () => { That(ctor.Construct(Null)["message"], Is.EqualTo("null")); That(ctor.Construct(0)["message"], Is.EqualTo("0")); That(ctor.Construct(true)["message"], Is.EqualTo("true")); That(ctor.Construct(Object.Construct())["message"], Is.EqualTo("[object Object]")); That(ctor.Construct(CreateObject(toString: () => "foo"))["message"], Is.EqualTo("foo")); That(ctor.Construct(CreateObject(toString: () => Object.Construct(), valueOf: () => 1))["message"], Is.EqualTo("1")); That(ctor.Construct(CreateObject(toPrimitive: () => "foo"))["message"], Is.EqualTo("foo")); That(() => ctor.Construct(new Symbol()), Throws.TypeError); That(() => ctor.Construct(CreateObject(toString: () => Object.Construct(), valueOf: () => Object.Construct())), Throws.TypeError); }); It("should define own message property if first argument is not undefined", () => { That(ctor.Call(_, "msg1")["message"], Is.EqualTo("msg1")); That(ctor.Construct("msg1")["message"], Is.EqualTo("msg1")); That(ctor.Construct().HasOwnProperty("message"), Is.EqualTo(false)); That(ctor.Construct(Undefined).HasOwnProperty("message"), Is.EqualTo(false)); That(ctor.Construct(Null).HasOwnProperty("message"), Is.EqualTo(true)); That(ctor.Construct("").HasOwnProperty("message"), Is.EqualTo(true)); }); It("should define own stack property", () => { That(ctor.Construct(), Has.OwnProperty("stack", EcmaPropertyAttributes.Writable | EcmaPropertyAttributes.Configurable)); That(ctor.Construct()["stack"], Is.Not.EqualTo(Undefined)); }); It("should derive [[Prototype]] value from realm of newTarget", () => { RuntimeRealm realm = new RuntimeRealm(); EcmaValue fn = realm.GetRuntimeObject(WellKnownObject.FunctionConstructor).Construct(); fn["prototype"] = Null; EcmaValue other = Reflect.Invoke("construct", ctor, EcmaArray.Of(), fn); That(Object.Invoke("getPrototypeOf", other), Is.EqualTo(realm.GetRuntimeObject(protoType))); }); } }
public void Constructor(RuntimeFunction ctor) { IsConstructorWLength(ctor, "Proxy", 2, null); That(GlobalThis, Has.OwnProperty("Proxy", ctor, EcmaPropertyAttributes.DefaultMethodProperty)); That(TypeOf(ctor.Construct(Object.Construct(), Object.Construct())), Is.EqualTo("object")); That(() => ctor.Call(Object.Construct(), Object.Construct()), Throws.TypeError); EcmaValue revocable = Proxy.Invoke("revocable", Object.Construct(), Object.Construct()); revocable.Invoke("revoke"); That(() => ctor.Construct(Object.Construct(), revocable["proxy"]), Throws.TypeError); That(() => ctor.Construct(Object.Construct(), Undefined), Throws.TypeError); That(() => ctor.Construct(Object.Construct(), Null), Throws.TypeError); That(() => ctor.Construct(Object.Construct(), 0), Throws.TypeError); That(() => ctor.Construct(Object.Construct(), false), Throws.TypeError); That(() => ctor.Construct(Object.Construct(), ""), Throws.TypeError); That(() => ctor.Construct(Object.Construct(), new Symbol()), Throws.TypeError); That(() => ctor.Construct(revocable["proxy"], Object.Construct()), Throws.TypeError); That(() => ctor.Construct(Undefined, Object.Construct()), Throws.TypeError); That(() => ctor.Construct(Null, Object.Construct()), Throws.TypeError); That(() => ctor.Construct(0, Object.Construct()), Throws.TypeError); That(() => ctor.Construct(false, Object.Construct()), Throws.TypeError); That(() => ctor.Construct("", Object.Construct()), Throws.TypeError); That(() => ctor.Construct(new Symbol(), Object.Construct()), Throws.TypeError); // A Proxy exotic object is only callable if the given target is callable. EcmaValue p1 = Proxy.Construct(Object.Construct(), Object.Construct()); That(() => p1.Call(_), Throws.TypeError); // A Proxy exotic object only accepts a constructor call if target is constructor. EcmaValue p2 = Proxy.Construct(GlobalThis["parseInt"], Object.Construct()); That(() => p2.Call(_), Throws.Nothing); That(() => p2.Construct(_), Throws.TypeError); // The realm of a proxy exotic object is the realm of its target function RuntimeRealm realm = new RuntimeRealm(); EcmaValue C = realm.GetRuntimeObject(WellKnownObject.FunctionConstructor).Construct(); C["prototype"] = Null; EcmaValue P = Proxy.Construct(C, Object.Construct()); That(Object.Invoke("getPrototypeOf", P.Construct()), Is.EqualTo(realm.GetRuntimeObject(WellKnownObject.ObjectPrototype)), "The realm of a proxy exotic object is the realm of its target function"); P = Proxy.Construct(P, Object.Construct()); That(Object.Invoke("getPrototypeOf", P.Construct()), Is.EqualTo(realm.GetRuntimeObject(WellKnownObject.ObjectPrototype)), "GetFunctionRealm is called recursively"); }
public void ToPrimitive(RuntimeFunction toPrimitive) { IsUnconstructableFunctionWLength(toPrimitive, "[Symbol.toPrimitive]", 1); That(Symbol.Prototype, Has.OwnProperty(WellKnownSymbol.ToPrimitive, EcmaPropertyAttributes.Configurable)); Case(Symbol["toPrimitive"], Symbol["toPrimitive"]); Case(Object.Call(Object, Symbol["toPrimitive"]), Symbol["toPrimitive"]); Case(Undefined, Throws.TypeError); Case(Null, Throws.TypeError); Case(123, Throws.TypeError); Case("test", Throws.TypeError); Case(true, Throws.TypeError); Case(Object.Construct(), Throws.TypeError); }
public void Properties() { That(Object, Has.OwnProperty("prototype", Object.Prototype, EcmaPropertyAttributes.None)); That(Object.Prototype, Has.OwnProperty("constructor", Object, EcmaPropertyAttributes.Writable | EcmaPropertyAttributes.Configurable)); That(Object.Invoke("getPrototypeOf", Object.Prototype), Is.EqualTo(Null)); That(Object.Prototype.Get("toString").Call(Object.Prototype), Is.EqualTo("[object Object]"), "Boolean prototype object: its [[Class]] must be 'Object'"); That(() => Object.Prototype.Call(), Throws.TypeError); That(() => Object.Prototype.Construct(), Throws.TypeError); That(Object.Construct()["constructor"], Is.EqualTo(Object)); That(Object.Prototype.Invoke("isPrototypeOf", Object.Construct()), Is.EqualTo(true)); That(Object.Invoke("isExtensible", Object.Prototype), Is.EqualTo(true)); }
public void Constructor(RuntimeFunction ctor) { IsConstructorWLength(ctor, "WeakMap", 0, WeakMap.Prototype); That(GlobalThis, Has.OwnProperty("WeakMap", ctor, EcmaPropertyAttributes.Writable | EcmaPropertyAttributes.Configurable)); It("must be called as constructor", () => { That(() => WeakMap.Call(This), Throws.TypeError); That(() => WeakMap.Call(This, EcmaArray.Of()), Throws.TypeError); }); It("should return a new WeakMap object if iterable is undefined or null", () => { That(Object.Invoke("getPrototypeOf", WeakMap.Construct()), Is.EqualTo(WeakMap.Prototype)); That(Object.Invoke("getPrototypeOf", WeakMap.Construct(Undefined)), Is.EqualTo(WeakMap.Prototype)); That(Object.Invoke("getPrototypeOf", WeakMap.Construct(Null)), Is.EqualTo(WeakMap.Prototype)); }); It("should throw a TypeError if object is not iterable", () => { That(() => WeakMap.Construct(Object.Construct()), Throws.TypeError); }); It("should throw a TypeError if iterable items are not Objects", () => { That(() => WeakMap.Construct(EcmaArray.Of(Undefined, 1)), Throws.TypeError); That(() => WeakMap.Construct(EcmaArray.Of(Null, 1)), Throws.TypeError); That(() => WeakMap.Construct(EcmaArray.Of(1, 1)), Throws.TypeError); That(() => WeakMap.Construct(EcmaArray.Of("", 1)), Throws.TypeError); That(() => WeakMap.Construct(EcmaArray.Of(true, 1)), Throws.TypeError); That(() => WeakMap.Construct(EcmaArray.Of(new Symbol(), 1)), Throws.TypeError); That(() => WeakMap.Construct(EcmaArray.Of(EcmaArray.Of("a", 1), 2)), Throws.TypeError); }); It("should throw TypeError if set is not callable only when iterable is not undefined or null", () => { using (TempProperty(WeakMap.Prototype, "set", Null)) { That(() => WeakMap.Construct(EcmaArray.Of()), Throws.TypeError); That(() => WeakMap.Construct(), Throws.Nothing); That(() => WeakMap.Construct(Undefined), Throws.Nothing); That(() => WeakMap.Construct(Null), Throws.Nothing); } }); It("should return abrupt from getting set mehod only when iterable is not undefined or null", () => { using (TempProperty(WeakMap.Prototype, "set", EcmaPropertyDescriptor.FromValue(CreateObject(("get", ThrowTest262Exception), ("configurable", true))))) { That(() => WeakMap.Construct(EcmaArray.Of()), Throws.Test262); That(() => WeakMap.Construct(), Throws.Nothing); That(() => WeakMap.Construct(Undefined), Throws.Nothing); That(() => WeakMap.Construct(Null), Throws.Nothing); } });
public void Constructor(RuntimeFunction ctor) { IsConstructorWLength(ctor, "Error", 1, Error.Prototype); IsAbruptedFromToPrimitive(ctor.Bind(_)); That(ctor.Call(), Is.InstanceOf(ctor)); That(Object.Prototype["toString"].Call(ctor.Construct()), Is.EqualTo("[object Error]")); It("should coerce first argument to string", () => { That(ctor.Construct(Null)["message"], Is.EqualTo("null")); That(ctor.Construct(0)["message"], Is.EqualTo("0")); That(ctor.Construct(true)["message"], Is.EqualTo("true")); That(ctor.Construct(Object.Construct())["message"], Is.EqualTo("[object Object]")); That(ctor.Construct(CreateObject(toString: () => "foo"))["message"], Is.EqualTo("foo")); That(ctor.Construct(CreateObject(toString: () => Object.Construct(), valueOf: () => 1))["message"], Is.EqualTo("1")); That(ctor.Construct(CreateObject(toPrimitive: () => "foo"))["message"], Is.EqualTo("foo")); That(() => ctor.Construct(new Symbol()), Throws.TypeError); That(() => ctor.Construct(CreateObject(toString: () => Object.Construct(), valueOf: () => Object.Construct())), Throws.TypeError); }); It("should define own message property if first argument is not undefined", () => { That(ctor.Call(_, "msg1"), Has.OwnProperty("message", "msg1", EcmaPropertyAttributes.Writable | EcmaPropertyAttributes.Configurable)); That(ctor.Construct("msg1"), Has.OwnProperty("message", "msg1", EcmaPropertyAttributes.Writable | EcmaPropertyAttributes.Configurable)); That(ctor.Construct().HasOwnProperty("message"), Is.EqualTo(false)); That(ctor.Construct(Undefined).HasOwnProperty("message"), Is.EqualTo(false)); That(ctor.Construct(Null).HasOwnProperty("message"), Is.EqualTo(true)); That(ctor.Construct("").HasOwnProperty("message"), Is.EqualTo(true)); }); It("should define own stack property", () => { That(ctor.Construct(), Has.OwnProperty("stack", EcmaPropertyAttributes.Writable | EcmaPropertyAttributes.Configurable)); That(ctor.Construct()["stack"], Is.Not.EqualTo(Undefined)); }); It("should derive [[Prototype]] value from realm of newTarget", () => { RuntimeRealm realm = new RuntimeRealm(); EcmaValue fn = realm.GetRuntimeObject(WellKnownObject.FunctionConstructor).Construct(); fn["prototype"] = Null; EcmaValue other = Reflect.Invoke("construct", ctor, EcmaArray.Of(), fn); That(Object.Invoke("getPrototypeOf", other), Is.EqualTo(realm.GetRuntimeObject(WellKnownObject.ErrorPrototype))); }); }
public void Catch(RuntimeFunction @catch) { IsUnconstructableFunctionWLength(@catch, "catch", 1); IsAbruptedFromToObject(@catch); That(Promise.Prototype, Has.OwnProperty("catch", @catch, EcmaPropertyAttributes.DefaultMethodProperty)); It("should invoke then method", () => { EcmaValue target = new EcmaObject(); EcmaValue returnValue = new EcmaObject(); EcmaValue thisValue = Null; EcmaValue args = Null; target["then"] = Intercept((a, b) => { thisValue = This; args = Arguments; return(returnValue); }); Case((target, 1, 2, 3), returnValue, "Returns the result of the invocation of `then`"); That(Logs.Count, Is.EqualTo(1), "Invokes `then` method exactly once"); That(thisValue, Is.EqualTo(target), "Invokes `then` method with the instance as the `this` value"); That(args, Is.EquivalentTo(new[] { Undefined, 1 })); using (TempProperty(Boolean.Prototype, "then", Intercept(_ => _))) { Logs.Clear(); @catch.Call(true); That(Logs.Count, Is.EqualTo(1)); } using (TempProperty(Number.Prototype, "then", Intercept(_ => _))) { Logs.Clear(); @catch.Call(34); That(Logs.Count, Is.EqualTo(1)); } using (TempProperty(String.Prototype, "then", Intercept(_ => _))) { Logs.Clear(); @catch.Call(""); That(Logs.Count, Is.EqualTo(1)); } using (TempProperty(Global.Symbol.Prototype, "then", Intercept(_ => _))) { Logs.Clear(); @catch.Call(new Symbol()); That(Logs.Count, Is.EqualTo(1)); } });
public void Constructor(RuntimeFunction ctor) { IsConstructorWLength(Symbol, "Symbol", 0, Symbol.Prototype); That(GlobalThis, Has.OwnProperty("Symbol", Symbol, EcmaPropertyAttributes.Writable | EcmaPropertyAttributes.Configurable)); It("should return a unique value", () => { That(ctor.Call(_), Is.Not.EqualTo(ctor.Call(_))); That(ctor.Call(_, ""), Is.Not.EqualTo(ctor.Call(_, ""))); That(ctor.Call(_, "x"), Is.Not.EqualTo(ctor.Call(_, "x"))); That(ctor.Call(_, Null), Is.Not.EqualTo(ctor.Call(_, Null))); }); It("should coerce first argument to a string value", () => { That(() => ctor.Call(_, ctor.Call(_, "1")), Throws.TypeError); Logs.Clear(); ctor.Call(_, CreateObject(toString: Intercept(() => Object.Construct(), "toString"), valueOf: Intercept(() => Undefined, "valueOf"))); That(Logs, Is.EquivalentTo(new[] { "toString", "valueOf" })); Logs.Clear(); ctor.Call(_, CreateObject(toString: Intercept(() => Undefined, "toString"), valueOf: Intercept(() => Undefined, "valueOf"))); That(Logs, Is.EquivalentTo(new[] { "toString" })); Logs.Clear(); ctor.Call(_, CreateObject(new { toString = Null, valueOf = Intercept(() => Undefined, "valueOf") })); That(Logs, Is.EquivalentTo(new[] { "valueOf" })); Logs.Clear(); That(() => ctor.Call(_, CreateObject(new { toString = Null, valueOf = Intercept(() => Object.Construct(), "valueOf") })), Throws.TypeError); That(Logs, Is.EquivalentTo(new[] { "valueOf" })); Logs.Clear(); That(() => ctor.Call(_, CreateObject(toString: Intercept(() => Object.Construct(), "toString"), valueOf: Intercept(() => Object.Construct(), "valueOf"))), Throws.TypeError); That(Logs, Is.EquivalentTo(new[] { "toString", "valueOf" })); }); It("should not be invoked with new", () => { That(() => ctor.Construct(), Throws.TypeError); That(() => ctor.Construct(""), Throws.TypeError); }); }
public void Revocable(RuntimeFunction revocable) { IsUnconstructableFunctionWLength(revocable, "revocable", 2); That(Proxy, Has.OwnProperty("revocable", revocable, EcmaPropertyAttributes.DefaultMethodProperty)); It("The returned object has a proxy property which is the created Proxy object built with the given target and handler given parameters", () => { EcmaValue target = CreateObject(new { attr = "foo" }); EcmaValue r = revocable.Call(_, target, CreateObject(new { get = FunctionLiteral((t, prop) => t[prop] + "!") })); That(r["proxy"]["attr"], Is.EqualTo("foo!")); }); It("The property of Proxy Revocation functions", () => { EcmaValue revocationFunction = revocable.Call(_, Object.Construct(), Object.Construct())["revoke"]; IsUnconstructableFunctionWLength(revocationFunction, null, 0); That(Object.Invoke("isExtensible", revocationFunction), Is.EqualTo(true)); EcmaValue r = revocable.Call(_, Object.Construct(), Object.Construct()); That(r.Invoke("revoke"), Is.Undefined); That(r.Invoke("revoke"), Is.Undefined); }); }
public void Properties() { That(Error.Prototype, Has.OwnProperty("constructor", Error, EcmaPropertyAttributes.Writable | EcmaPropertyAttributes.Configurable)); That(Error.Prototype.GetPrototypeOf(), Is.EqualTo(Object.Prototype)); That(Object.Prototype.Get("toString").Call(Error.Prototype), Is.EqualTo("[object Object]"), "The value of the internal [[Class]] property of Error prototype object is 'Object'"); That(Error.Prototype, Has.OwnProperty("name", "Error", EcmaPropertyAttributes.Writable | EcmaPropertyAttributes.Configurable)); That(Error.Prototype, Has.OwnProperty("message", "", EcmaPropertyAttributes.Writable | EcmaPropertyAttributes.Configurable)); foreach (string derived in new[] { "EvalError", "RangeError", "ReferenceError", "SyntaxError", "TypeError", "URIError" }) { RuntimeFunction CDerived = (RuntimeFunction)GlobalThis[derived].ToObject(); That(CDerived.Prototype, Has.OwnProperty("constructor", CDerived, EcmaPropertyAttributes.Writable | EcmaPropertyAttributes.Configurable)); That(CDerived.Prototype.GetPrototypeOf(), Is.EqualTo(Error.Prototype)); That(Object.Prototype.Get("toString").Call(CDerived.Prototype), Is.EqualTo("[object Object]"), "Each NativeError prototype object is an ordinary object. It is not an Error instance and does not have an [[ErrorData]] internal slot."); That(CDerived.Prototype, Has.OwnProperty("name", derived, EcmaPropertyAttributes.Writable | EcmaPropertyAttributes.Configurable)); That(CDerived.Prototype, Has.OwnProperty("message", "", EcmaPropertyAttributes.Writable | EcmaPropertyAttributes.Configurable)); } }
public void Properties() { That(Math.GetPrototypeOf(), Is.EqualTo(Object.Prototype)); That(() => Math.Call(), Throws.TypeError); That(() => Math.Construct(), Throws.TypeError); That(Math, Has.OwnProperty("E", EcmaPropertyAttributes.None)); That(Math.Get("E"), Is.TypeOf("number")); That(Math.Get("E"), Is.Not.EqualTo(NaN)); That(Math, Has.OwnProperty("LN10", EcmaPropertyAttributes.None)); That(Math.Get("LN10"), Is.TypeOf("number")); That(Math.Get("LN10"), Is.Not.EqualTo(NaN)); That(Math, Has.OwnProperty("LN2", EcmaPropertyAttributes.None)); That(Math.Get("LN2"), Is.TypeOf("number")); That(Math.Get("LN2"), Is.Not.EqualTo(NaN)); That(Math, Has.OwnProperty("LOG10E", EcmaPropertyAttributes.None)); That(Math.Get("LOG10E"), Is.TypeOf("number")); That(Math.Get("LOG10E"), Is.Not.EqualTo(NaN)); That(Math, Has.OwnProperty("LOG2E", EcmaPropertyAttributes.None)); That(Math.Get("LOG2E"), Is.TypeOf("number")); That(Math.Get("LOG2E"), Is.Not.EqualTo(NaN)); That(Math, Has.OwnProperty("PI", EcmaPropertyAttributes.None)); That(Math.Get("PI"), Is.TypeOf("number")); That(Math.Get("PI"), Is.Not.EqualTo(NaN)); That(Math, Has.OwnProperty("SQRT1_2", EcmaPropertyAttributes.None)); That(Math.Get("SQRT1_2"), Is.TypeOf("number")); That(Math.Get("SQRT1_2"), Is.Not.EqualTo(NaN)); That(Math, Has.OwnProperty("SQRT2", EcmaPropertyAttributes.None)); That(Math.Get("SQRT2"), Is.TypeOf("number")); That(Math.Get("SQRT2"), Is.Not.EqualTo(NaN)); That(Math, Has.OwnProperty(WellKnownSymbol.ToStringTag, "Math", EcmaPropertyAttributes.Configurable)); }
public void ToString(RuntimeFunction toString) { IsUnconstructableFunctionWLength(toString, "toString", 0); That(BigInt.Prototype, Has.OwnProperty("toString", toString, EcmaPropertyAttributes.DefaultMethodProperty)); It("should throw a TypeError if the this value is not a BigInt", () => { Case(Undefined, Throws.TypeError); Case(Null, Throws.TypeError); Case(false, Throws.TypeError); Case(true, Throws.TypeError); Case("", Throws.TypeError); Case("1n", Throws.TypeError); Case(0, Throws.TypeError); Case(1, Throws.TypeError); Case(NaN, Throws.TypeError); Case(new Symbol(), Throws.TypeError); Case(EcmaArray.Of(BigIntLiteral(1)), Throws.TypeError); Case(CreateObject(new { x = BigIntLiteral(1) }), Throws.TypeError); Case(CreateObject(valueOf: ThrowTest262Exception, toString: ThrowTest262Exception, toPrimitive: ThrowTest262Exception), Throws.TypeError); }); It("should throw a RangeError if radix is invalid", () => { Case((BigIntLiteral(0), 0), Throws.RangeError); Case((BigIntLiteral(-1), 0), Throws.RangeError); Case((BigIntLiteral(1), 0), Throws.RangeError); Case((BigIntLiteral(0), 1), Throws.RangeError); Case((BigIntLiteral(-1), 1), Throws.RangeError); Case((BigIntLiteral(1), 1), Throws.RangeError); Case((BigIntLiteral(0), 37), Throws.RangeError); Case((BigIntLiteral(-1), 37), Throws.RangeError); Case((BigIntLiteral(1), 37), Throws.RangeError); Case((BigIntLiteral(0), Null), Throws.RangeError); Case((BigIntLiteral(-1), Null), Throws.RangeError); Case((BigIntLiteral(1), Null), Throws.RangeError); });
public void Constructor(RuntimeFunction ctor) { IsConstructorWLength(ctor, "Set", 0, Set.Prototype); That(GlobalThis, Has.OwnProperty("Set", ctor, EcmaPropertyAttributes.Writable | EcmaPropertyAttributes.Configurable)); It("must be called as constructor", () => { That(() => Set.Call(This), Throws.TypeError); That(() => Set.Call(This, EcmaArray.Of()), Throws.TypeError); }); It("should throw a TypeError if object is not iterable", () => { That(() => Set.Construct(Object.Construct()), Throws.TypeError); }); It("should construct an empty set if iterable is undefined or null", () => { That(Set.Construct()["size"], Is.EqualTo(0)); That(Set.Construct(Undefined)["size"], Is.EqualTo(0)); That(Set.Construct(Null)["size"], Is.EqualTo(0)); }); It("should throw TypeError if add is not callable only when iterable is not undefined or null", () => { using (TempProperty(Set.Prototype, "add", Null)) { That(() => Set.Construct(EcmaArray.Of()), Throws.TypeError); That(() => Set.Construct(), Throws.Nothing); That(() => Set.Construct(Undefined), Throws.Nothing); That(() => Set.Construct(Null), Throws.Nothing); } }); It("should return abrupt from getting add mehod only when iterable is not undefined or null", () => { using (TempProperty(Set.Prototype, "add", EcmaPropertyDescriptor.FromValue(CreateObject(("get", ThrowTest262Exception), ("configurable", true))))) { That(() => Set.Construct(EcmaArray.Of()), Throws.Test262); That(() => Set.Construct(), Throws.Nothing); That(() => Set.Construct(Undefined), Throws.Nothing); That(() => Set.Construct(Null), Throws.Nothing); } });