public void Tanh(RuntimeFunction tanh)
{
IsUnconstructableFunctionWLength(tanh, "tanh", 1);
Case((_, NaN), NaN);
Case((_, -Infinity), -1);
Case((_, Infinity), 1);
Case((_, -0d), -0d);
Case((_, 0), 0);
}
public void Sinh(RuntimeFunction sinh)
{
IsUnconstructableFunctionWLength(sinh, "sinh", 1);
Case((_, NaN), NaN);
Case((_, -Infinity), -Infinity);
Case((_, Infinity), Infinity);
Case((_, -0d), -0d);
Case((_, 0), 0);
}
public void Expm1(RuntimeFunction expm1)
{
IsUnconstructableFunctionWLength(expm1, "expm1", 1);
Case((_, NaN), NaN);
Case((_, -Infinity), -1);
Case((_, Infinity), Infinity);
Case((_, -0d), -0d);
Case((_, 0), 0);
}
public void Cosh(RuntimeFunction cosh)
{
IsUnconstructableFunctionWLength(cosh, "cosh", 1);
Case((_, NaN), NaN);
Case((_, -Infinity), Infinity);
Case((_, Infinity), Infinity);
Case((_, -0d), 1);
Case((_, 0), 1);
}
public void Cbrt(RuntimeFunction cbrt)
{
IsUnconstructableFunctionWLength(cbrt, "cbrt", 1);
Case((_, NaN), NaN);
Case((_, -Infinity), -Infinity);
Case((_, Infinity), Infinity);
Case((_, -0d), -0d);
Case((_, 0), 0);
}
public void Random(RuntimeFunction random)
{
IsUnconstructableFunctionWLength(random, "random", 0);
for (int i = 0; i < 100; i++)
{
EcmaValue value = random.Call();
That(value, Is.TypeOf("number"));
That(value, Is.GreaterThanOrEqualTo(0).And.LessThan(1));
}
}
private RuntimeFunction EnsureHomedMethod(EcmaValue value, RuntimeObject target, int requiredLength, string notFunctionError, string incorrectLengthError)
{
Guard.ArgumentIsCallable(value, notFunctionError);
RuntimeFunction fn = value.GetUnderlyingObject <RuntimeFunction>();
if (fn[WellKnownProperty.Length] != requiredLength)
{
throw new EcmaSyntaxErrorException(incorrectLengthError);
}
return(fn.AsHomedMethodOf(target));
}
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 Clear(RuntimeFunction clear)
{
IsUnconstructableFunctionWLength(clear, "clear", 0);
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 when this object has no [[MapData]] internal slot", () => {
Case(EcmaArray.Of(), Throws.TypeError);
Case(Map.Prototype, Throws.TypeError);
Case(Object.Construct(), Throws.TypeError);
Case(Global.Set.Construct(), Throws.TypeError);
Case(WeakSet.Construct(), Throws.TypeError);
});
It("should clear a Map object", () => {
EcmaValue map = Map.Construct(EcmaArray.Of(
EcmaArray.Of("foo", "bar"),
EcmaArray.Of(1, 1)
));
clear.Call(map);
That(map["size"], Is.EqualTo(0));
map = Map.Construct();
map.Invoke("set", "foo", "bar");
map.Invoke("set", 1, 1);
clear.Call(map);
That(map["size"], Is.EqualTo(0));
});
It("should return undefined", () => {
EcmaValue map = Map.Construct();
Case(map, Undefined);
Case(map, Undefined);
});
It("should not break iterator", () => {
EcmaValue map = Map.Construct(EcmaArray.Of(
EcmaArray.Of("a", 1),
EcmaArray.Of("b", 2),
EcmaArray.Of("c", 3)
));
EcmaValue iterator = map.Invoke("entries");
iterator.Invoke("next");
clear.Call(map);
VerifyIteratorResult(iterator.Invoke("next"), true);
});
}
static void Main(string[] args)
{
Function.newContext();
Function.printCompilerSource = true;
//Function.turnOnAllSimplification();
Program prog = new Program();
//int T = 10;
//Function[][] X = new Function[T][];
//Function[][] U = new Function[T-1][];
//Function[] x = new Function[] {-4, 2};
//Function[] u = new Function[] {0.214285714285714, -0.285714285714286};
//Function[,] Sigma = new Function[,] { { 1, 0 }, { 0, 1 } };
Variable[] vars = new Variable[8];
for (int i = 0; i < 8; ++i)
{
vars[i] = new Variable("vars_" + i);
}
Function[] x = new Function[] { vars[0], vars[1] };
Function[] u = new Function[] { vars[2], vars[3] };
Function[,] Sigma = VM.identity <Function>(2, 0, 1);
Function[] q_t = new Function[] { vars[4], vars[5] };
Function[] r_t = new Function[] { vars[6], vars[7] };
Function[] x_tp1;
Function[,] Sigma_tp1;
prog.EKF(x, Sigma, u, q_t, r_t, out x_tp1, out Sigma_tp1);
Function[] packed = VM.concatenate <Function>(x_tp1, VM.matrixToVector <Function>(Sigma_tp1));
Function beliefvec = Function.derivative(packed);
beliefvec.printOperatorCounts();
bool[] invDynInputVarIndices;
vars = initializeInputVariables(beliefvec, vars, out invDynInputVarIndices);
beliefvec.orderVariablesInDomain(vars);
RuntimeFunction brun = beliefvec.compile();
double[] result = new double[6], varvals = { -4, 2, 0.214285714285714, -0.285714285714286, 0, 0 };
brun.eval(result, varvals);
for (int i = 0; i < 6; ++i)
{
Console.Write("b[" + i + "]: " + result[i] + " ");
}
Console.WriteLine();
Console.Read();
}
public void Sqrt(RuntimeFunction sqrt)
{
IsUnconstructableFunctionWLength(sqrt, "sqrt", 1);
Case((_, NaN), NaN);
Case((_, -Infinity), NaN);
Case((_, Infinity), Infinity);
Case((_, -0.000000000000001), NaN);
Case((_, -1), NaN);
Case((_, -0d), -0d);
Case((_, 0), 0);
}
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 EcmaValue this[EcmaPropertyKey key] {
set {
if (key == WellKnownProperty.Constructor)
{
constructor = value.GetUnderlyingObject <RuntimeFunction>();
}
else
{
EnsureBuilder(ref properties).Add(key, value);
}
}
}
public void Delete(RuntimeFunction delete)
{
IsUnconstructableFunctionWLength(delete, "delete", 1);
It("should throw a TypeError when this is not an object", () => {
Case((Undefined, 1), Throws.TypeError);
Case((Null, 1), Throws.TypeError);
Case((false, 1), Throws.TypeError);
Case((0, 1), Throws.TypeError);
Case(("", 1), Throws.TypeError);
Case((new Symbol(), 1), Throws.TypeError);
});
public void Acosh(RuntimeFunction acosh)
{
IsUnconstructableFunctionWLength(acosh, "acosh", 1);
Case((_, Infinity), Infinity);
Case((_, +1), 0, "Math.acosh should produce 0 for +1");
Case((_, NaN), NaN, "NaN");
Case((_, 0.999999), NaN, "0.999999");
Case((_, 0), NaN, "0");
Case((_, -1), NaN, "-1");
Case((_, -Infinity), NaN, "-Infinity");
}
public void Add(RuntimeFunction add)
{
IsUnconstructableFunctionWLength(add, "add", 1);
It("should throw a TypeError when this is not an object", () => {
Case((Undefined, Object.Construct()), Throws.TypeError);
Case((Null, Object.Construct()), Throws.TypeError);
Case((false, Object.Construct()), Throws.TypeError);
Case((0, Object.Construct()), Throws.TypeError);
Case(("", Object.Construct()), Throws.TypeError);
Case((new Symbol(), Object.Construct()), Throws.TypeError);
});
public void Trunc(RuntimeFunction trunc)
{
IsUnconstructableFunctionWLength(trunc, "trunc", 1);
Case((_, NaN), NaN);
Case((_, -Infinity), -Infinity);
Case((_, Infinity), Infinity);
Case((_, -0.9), -0d);
Case((_, 0.9), 0);
Case((_, 4578.584949), 4578);
Case((_, 0), 0);
Case((_, 0.02047410048544407), 0,
"Math.trunc should produce +0 for values between 0 and 1");
Case((_, 0.00000000000000001), 0,
"Math.trunc should produce +0 for values between 0 and 1");
Case((_, 0.9999999999999999), 0,
"Math.trunc should produce +0 for values between 0 and 1");
Case((_, Number.Get("EPSILON")), 0,
"Math.trunc should produce +0 for values between 0 and 1");
Case((_, Number.Get("MIN_VALUE")), 0,
"Math.trunc should produce +0 for values between 0 and 1");
Case((_, -0.02047410048544407), -0d,
"Math.trunc should produce -0 for values between -1 and 0");
Case((_, -0.00000000000000001), -0d,
"Math.trunc should produce -0 for values between -1 and 0");
Case((_, -0.9999999999999999), -0d,
"Math.trunc should produce -0 for values between -1 and 0");
Case((_, -Number.Get("EPSILON")), -0d,
"Math.trunc should produce -0 for values between -1 and 0");
Case((_, -Number.Get("MIN_VALUE")), -0d,
"Math.trunc should produce -0 for values between -1 and 0");
Case((_, Number.Get("MAX_VALUE")), Math.Invoke("floor", Number.Get("MAX_VALUE")),
"Math.trunc produces incorrect result for Number.MAX_VALUE");
Case((_, 10), Math.Invoke("floor", 10),
"Math.trunc produces incorrect result for 10");
Case((_, 3.9), Math.Invoke("floor", 3.9),
"Math.trunc produces incorrect result for 3.9");
Case((_, 4.9), Math.Invoke("floor", 4.9),
"Math.trunc produces incorrect result for 4.9");
Case((_, -Number.Get("MAX_VALUE")), Math.Invoke("ceil", -Number.Get("MAX_VALUE")),
"Math.trunc produces incorrect result for -Number.MAX_VALUE");
Case((_, -10), Math.Invoke("ceil", -10),
"Math.trunc produces incorrect result for -10");
Case((_, -3.9), Math.Invoke("ceil", -3.9),
"Math.trunc produces incorrect result for -3.9");
Case((_, -4.9), Math.Invoke("ceil", -4.9),
"Math.trunc produces incorrect result for -4.9");
}
public void Acos(RuntimeFunction acos)
{
IsUnconstructableFunctionWLength(acos, "acos", 1);
Case((_, NaN), NaN);
Case((_, 1.000000000000001), NaN, "1.000000000000001");
Case((_, 2), NaN, "2");
Case((_, Infinity), NaN, "Infinity");
Case((_, -1.000000000000001), NaN, "-1.000000000000001");
Case((_, -2), NaN, "-2");
Case((_, -Infinity), NaN, "-Infinity");
Case((_, 1), 0);
}
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 Log(RuntimeFunction log)
{
IsUnconstructableFunctionWLength(log, "log", 1);
Case((_, NaN), NaN);
Case((_, -Infinity), NaN);
Case((_, Infinity), Infinity);
Case((_, -1), NaN);
Case((_, -0.000000000000001), NaN);
Case((_, -0d), -Infinity);
Case((_, 0), -Infinity);
Case((_, 1), 0);
}
public void Log1p(RuntimeFunction log1p)
{
IsUnconstructableFunctionWLength(log1p, "log1p", 1);
Case((_, NaN), NaN);
Case((_, -Infinity), NaN);
Case((_, Infinity), Infinity);
Case((_, -2), NaN);
Case((_, -1.000001), NaN);
Case((_, -1), -Infinity);
Case((_, -0d), -0d);
Case((_, 0), -0);
}
public void Next(RuntimeFunction next)
{
IsUnconstructableFunctionWLength(next, "next", 0);
It("should throw a TypeError if this value does not have all of the internal slots of a Set Iterator Instance", () => {
EcmaValue map = Map.Construct();
foreach (var i in new EcmaPropertyKey[] { Symbol.Iterator, "keys", "entries", "values" })
{
EcmaValue iterator = map.Invoke(i);
That(() => iterator["next"].Call(Undefined), Throws.TypeError);
That(() => iterator["next"].Call(Null), Throws.TypeError);
That(() => iterator["next"].Call(1), Throws.TypeError);
That(() => iterator["next"].Call(false), Throws.TypeError);
That(() => iterator["next"].Call(""), Throws.TypeError);
That(() => iterator["next"].Call(new Symbol()), Throws.TypeError);
That(() => iterator["next"].Call(map), Throws.TypeError);
That(() => iterator["next"].Call(Object.Construct()), Throws.TypeError);
That(() => iterator["next"].Call(map.Invoke(i)), Throws.Nothing);
}
});
It("should return a valid iterator with the context as the IteratedObject", () => {
EcmaValue map = Map.Construct();
map.Invoke("set", 1, 11);
map.Invoke("set", 2, 22);
map.Invoke("set", 3, 33);
EcmaValue iterator = map.Invoke(Symbol.Iterator);
VerifyIteratorResult(iterator.Invoke("next"), false, new[] { 1, 11 });
VerifyIteratorResult(iterator.Invoke("next"), false, new[] { 2, 22 });
VerifyIteratorResult(iterator.Invoke("next"), false, new[] { 3, 33 });
VerifyIteratorResult(iterator.Invoke("next"), true);
VerifyIteratorResult(iterator.Invoke("next"), true);
});
It("should onlt visit new item if it is added before iterator is done", () => {
EcmaValue map = Map.Construct();
map.Invoke("set", 1, 11);
map.Invoke("set", 2, 22);
EcmaValue iterator = map.Invoke(Symbol.Iterator);
VerifyIteratorResult(iterator.Invoke("next"), false, new[] { 1, 11 });
map.Invoke("set", 3, 33);
VerifyIteratorResult(iterator.Invoke("next"), false, new[] { 2, 22 });
VerifyIteratorResult(iterator.Invoke("next"), false, new[] { 3, 33 });
VerifyIteratorResult(iterator.Invoke("next"), true);
map.Invoke("set", 3, 44);
VerifyIteratorResult(iterator.Invoke("next"), true);
});
}
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 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 Sign(RuntimeFunction sign)
{
IsUnconstructableFunctionWLength(sign, "sign", 1);
Case((_, NaN), NaN, "NaN");
Case((_, -0d), -0d, "-0");
Case((_, 0), 0, "0");
Case((_, -0.000001), -1, "-0.000001");
Case((_, -1), -1, "-1");
Case((_, -Infinity), -1, "-Infinity");
Case((_, 0.000001), 1, "0.000001");
Case((_, 1), 1, "1");
Case((_, Infinity), 1, "Infinity");
}
public void ValueOf(RuntimeFunction valueOf)
{
IsUnconstructableFunctionWLength(valueOf, "valueOf", 0);
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 Asin(RuntimeFunction asin)
{
IsUnconstructableFunctionWLength(asin, "asin", 1);
Case((_, NaN), NaN, "NaN");
Case((_, 1.000000000000001), NaN, "1.000000000000001");
Case((_, 2), NaN, "2");
Case((_, Infinity), NaN, "Infinity");
Case((_, -1.000000000000001), NaN, "-1.000000000000001");
Case((_, -2), NaN, "-2");
Case((_, -Infinity), NaN, "-Infinity");
Case((_, 0), 0);
Case((_, -0d), -0d);
}
public MethodSymbols GetFunctionSymbols(RuntimeFunction function)
{
MethodSymbols symbols;
if (!_cachedSymbols.TryGetValue(function.Token, out symbols))
{
var symMethod = GetSymMethod(function.Token);
if (symMethod == null)
return null;
_cachedSymbols.Add(function.Token, symbols = new MethodSymbols(function, symMethod));
}
return symbols;
}
public void Constructor(RuntimeFunction ctor)
{
IsConstructorWLength(ctor, "Array", 1, Array.Prototype);
That(Array.Construct(0)["length"], Is.EqualTo(0));
That(Array.Construct(1)["length"], Is.EqualTo(1));
That(Array.Construct(4294967295)["length"], Is.EqualTo(4294967295));
That(() => Array.Construct(-1), Throws.RangeError);
That(() => Array.Construct(4294967296), Throws.RangeError);
That(() => Array.Construct(4294967297), Throws.RangeError);
That(() => Array.Construct(NaN), Throws.RangeError);
That(() => Array.Construct(Infinity), Throws.RangeError);
That(() => Array.Construct(-Infinity), Throws.RangeError);
That(() => Array.Construct(1.5), Throws.RangeError);
That(() => Array.Construct(Number["MAX_VALUE"]), Throws.RangeError);
That(() => Array.Construct(Number["MIN_VALUE"]), Throws.RangeError);
That(Array.Construct(Null), Is.EquivalentTo(new[] { Null }));
That(Array.Construct(Undefined), Is.EquivalentTo(new[] { Undefined }));
That(Array.Construct(true), Is.EquivalentTo(new[] { true }));
That(Array.Construct("1"), Is.EquivalentTo(new[] { "1" }));
EcmaValue falseObj = Boolean.Construct(false);
That(Array.Construct(falseObj), Is.EquivalentTo(new[] { falseObj }));
EcmaValue strObj = String.Construct("0");
That(Array.Construct(strObj), Is.EquivalentTo(new[] { strObj }));
EcmaValue numObj = Number.Construct(0);
That(Array.Construct(numObj), Is.EquivalentTo(new[] { numObj }));
numObj = Number.Construct(4294967295);
That(Array.Construct(numObj), Is.EquivalentTo(new[] { numObj }));
numObj = Number.Construct(-1);
That(Array.Construct(numObj), Is.EquivalentTo(new[] { numObj }));
numObj = Number.Construct(4294967296);
That(Array.Construct(numObj), Is.EquivalentTo(new[] { numObj }));
numObj = Number.Construct(4294967297);
That(Array.Construct(numObj), Is.EquivalentTo(new[] { numObj }));
That(Array.Construct(), Is.EquivalentTo(EcmaValue.EmptyArray));
That(Array.Construct(0, 1, 0, 1), Is.EquivalentTo(new[] { 0, 1, 0, 1 }));
That(Array.Construct(Undefined, Undefined), Is.EquivalentTo(new[] { Undefined, Undefined }));
That(Array.Call().InstanceOf(Array));
That(Array.Call(), Is.EquivalentTo(EcmaValue.EmptyArray));
That(Array.Call(_, 0, 1, 0, 1), Is.EquivalentTo(new[] { 0, 1, 0, 1 }));
That(Array.Call(_, Undefined, Undefined), Is.EquivalentTo(new[] { Undefined, Undefined }));
}
public void SetUp()
{
TestMethod method = TestExecutionContext.CurrentContext.CurrentTest as TestMethod;
RuntimeFunctionInjectionAttribute attribute = method.Method.GetCustomAttributes <RuntimeFunctionInjectionAttribute>(false).FirstOrDefault();
if (attribute != null)
{
EcmaPropertyDescriptor descriptor = null;
RuntimeFunction function = null;
if (attribute.Type != 0)
{
RuntimeObject obj = RuntimeRealm.Current.GetRuntimeObject(attribute.Type);
descriptor = obj.GetOwnProperty(attribute.Name);
_ = obj;
}
else
{
string typeName = method.TypeInfo.Name;
if (typeName.EndsWith("Object"))
{
typeName = typeName.Substring(0, typeName.Length - 6);
}
object objectType;
if (Enum.TryParse(typeof(WellKnownObject), typeName, out objectType) || Enum.TryParse(typeof(WellKnownObject), typeName.Replace("Constructor", ""), out objectType))
{
RuntimeObject obj = RuntimeRealm.Current.GetRuntimeObject((WellKnownObject)objectType);
if (method.MethodName == "Constructor")
{
function = (RuntimeFunction)obj;
_ = Global.GlobalThis;
}
else
{
descriptor = obj.GetOwnProperty(Regex.Replace(method.MethodName, "^[A-Z](?=[a-z])", v => v.Value.ToLower()));
if (descriptor == null && Enum.TryParse(typeof(WellKnownSymbol), method.MethodName, out object sym))
{
descriptor = obj.GetOwnProperty((WellKnownSymbol)sym);
}
_ = obj;
}
}
}
if (descriptor != null)
{
function = (descriptor.IsDataDescriptor ? descriptor.Value : descriptor.Get).GetUnderlyingObject() as RuntimeFunction;
}
TestContext.CurrentContext.Test.Arguments[0] = function;
}
}
internal MethodSymbols(RuntimeFunction function, ISymUnmanagedMethod symMethod)
{
Function = function;
SymMethod = symMethod;
}
