public void RegisterWellKnownType() { TcpChannel chn = null; try { chn = new TcpChannel(1234); ChannelServices.RegisterChannel(chn); // register the SAO if(RemotingConfiguration.ApplicationName == null) RemotingConfiguration.ApplicationName = "RemotingConfigurationTest"; RemotingConfiguration.RegisterWellKnownServiceType(typeof(DerivedWellKnownObject), "WellKnownObject.rem", WellKnownObjectMode.Singleton); // get the registered services WellKnownServiceTypeEntry[] ast = RemotingConfiguration.GetRegisteredWellKnownServiceTypes(); bool IsServerRegistered = false; foreach(WellKnownServiceTypeEntry aste in ast) { if(aste.ObjectType == typeof(DerivedWellKnownObject)) { IsServerRegistered = true; break; } } Assert.IsTrue(IsServerRegistered, "#A02"); // register the client RemotingConfiguration.RegisterWellKnownClientType(typeof(WellKnownObject), "tcp://localhost:1234/"+RemotingConfiguration.ApplicationName+"/WellKnownObject.rem"); // get the registered client WellKnownClientTypeEntry[] act = RemotingConfiguration.GetRegisteredWellKnownClientTypes(); bool IsClientRegistered = false; foreach(WellKnownClientTypeEntry acte in act) { if(acte.ObjectType == typeof(WellKnownObject)) { IsClientRegistered = true; break; } } Assert.IsTrue(IsClientRegistered, "#A03"); WellKnownObject objWellKnown = new WellKnownObject(); Assert.IsTrue(objWellKnown != null, "#A04"); Assert.IsTrue(RemotingServices.IsTransparentProxy(objWellKnown), "#A05"); objWellKnown.Method1(); Assert.IsTrue(objWellKnown.Method1Called, "#A06"); } finally { ChannelServices.UnregisterChannel(chn); } }
private TypedArrayInfo(TypedArrayKind kind, WellKnownObject defaultConstructor, WellKnownObject proto, int elementSize, string typeName) { this.ArrayKind = kind; this.DefaultConstructor = defaultConstructor; this.DefaultPrototype = proto; this.ElementSize = elementSize; this.TypedArrayName = typeName; }
public EcmaIterator(object target, EcmaIteratorResultKind kind, WellKnownObject proto) : base(proto) { Guard.ArgumentNotNull(target, "target"); this.iterator = GetEnumerator(target); this.IteratedObject = target; this.ResultKind = kind; }
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 static bool IsIntrinsicFunction(this RuntimeObject obj, WellKnownObject type, EcmaPropertyKey name) { if (obj is IntrinsicFunction fn) { return(fn.IsIntrinsicFunction(type, name)); } Guard.ArgumentNotNull(obj, "obj"); if (!obj.IsCallable) { return(false); } RuntimeObject sourceObj = RuntimeRealm.SharedRealm.GetRuntimeObject(type).GetMethod(name); return(obj.Realm.ResolveRuntimeObjectInRealm(sourceObj) == obj); }
protected ArrayBuffer(WellKnownObject proto, long size) : base(proto) { Init(size); }
public StatefulIterator(WellKnownObject proto) : base(proto) { }
public static bool IsWellknownObject(this RuntimeObject obj, WellKnownObject type) { Guard.ArgumentNotNull(obj, "obj"); return(obj == obj.Realm.GetRuntimeObject(type)); }
public PrimitiveObject(EcmaValue value, WellKnownObject defaultProto, RuntimeObject constructor) : base(defaultProto, constructor) { this.value = value; }
public NativeRuntimeFunction(string name, MethodInfo method, bool containUseStrict, WellKnownObject proto) : base(proto) { Guard.ArgumentNotNull(method, "method"); this.method = method; Type runtimeObjectType = null; if (method.HasAttribute(out IntrinsicConstructorAttribute attribute)) { constraint = attribute.Constraint; containUseStrict = true; runtimeObjectType = attribute.ObjectType; if (attribute.Prototype is Enum protoEnum) { defaultProto = RuntimeRealm.GetSharedObjectHandle(protoEnum); } } else if (method.HasAttribute(out IntrinsicMemberAttribute a2)) { constraint = NativeRuntimeFunctionConstraint.DenyConstruct; containUseStrict = true; if (name == null) { name = a2.Name; } } else { SetPrototypeInternal(new EcmaObject()); } if (name == null) { name = ""; } this.Source = "function " + name + "() { [native code] }"; InitProperty(name, GetFuncLength(method), containUseStrict); constructThisValue = runtimeObjectType == null || runtimeObjectType == typeof(EcmaObject) ? createFromConstructorDefault : createFromConstructor.MakeGenericMethod(runtimeObjectType); }
public bool IsIntrinsicFunction(WellKnownObject obj, EcmaPropertyKey name) { return(parentObject == obj && propertyKey == name); }
public IntrinsicFunction(string name, MethodInfo method, WellKnownObject parentObject, EcmaPropertyKey propertyKey) : base(name, method, true) { this.parentObject = parentObject; this.propertyKey = propertyKey; }
internal GeneratorBase(RuntimeFunctionInvocation invocation, IGeneratorEnumerator iterator, WellKnownObject proto) : base(proto) { this.invocation = invocation; this.iterator = iterator; invocation.Generator = this; invocation.SuspendOnDispose = true; SetPrototypeOf(invocation.FunctionObject.Get(WellKnownProperty.Prototype).ToObject()); iterator.Init(this); }
public DelegateRuntimeFunction(string name, Delegate callback, WellKnownObject proto) : base(name, GetInvokeMethod(callback, out _target), false, proto) { target = _target; }
public RuntimeObject GetRuntimeObject(WellKnownObject type) { return(GetSharedObject(0, (int)type)); }
public RuntimeFunctionInjectionAttribute(WellKnownObject type, WellKnownSymbol property) { this.Type = type; this.Name = property; }
public PrimitiveObject(EcmaValue value, WellKnownObject defaultProto) : base(defaultProto) { this.value = value; }
public RuntimeFunction(WellKnownObject proto) : base(proto) { }
public EcmaMapBase(WellKnownObject proto) : base(proto) { }
protected ArrayBuffer(WellKnownObject proto, byte[] buffer) : base(proto) { Guard.ArgumentNotNull(buffer, "buffer"); this.buffer.Buffer = buffer; }
protected ArrayBuffer(WellKnownObject proto) : base(proto) { }
protected ArrayBuffer(WellKnownObject proto, RuntimeObject constructor) : base(proto, constructor) { }
internal SharedObjectHandle(WellKnownObject knownObject) { this.HandleValue = (int)knownObject; }
public TransientPrimitiveObject(EcmaValue value, WellKnownObject defaultProto) : base(value, defaultProto) { }