public Machine(bool iscurrent) { if (iscurrent) this.SetCurrent(); IMetaClass meta = new BaseMetaClass(null, null, this, string.Empty); this.nilclass = (BaseClass)meta.CreateClass("UndefinedObject", string.Empty); // TODO review, nil object never receives a message, see Send in Execution block this.nilclass.DefineInstanceMethod(new BehaviorDoesNotUnderstandMethod(this, this.nilclass)); this.nilclass.DefineClassMethod(new BehaviorDoesNotUnderstandMethod(this, this.nilclass)); this.nilclass.DefineInstanceMethod(new FunctionalMethod("ifNil:", this.nilclass, this.IfNil)); this.nilclass.DefineInstanceMethod(new FunctionalMethod("ifNotNil:", this.nilclass, this.IfNotNil)); this.nilclass.DefineInstanceMethod(new FunctionalMethod("isNil", this.nilclass, this.IsNil)); this.nilclass.DefineInstanceMethod(new FunctionalMethod("isNotNil", this.nilclass, this.IsNotNil)); // Native Behaviors var nativeObjectBehavior = new NativeObjectBehavior(meta, null, this); var enumerableBehavior = new EnumerableBehavior(meta, nativeObjectBehavior, this); var booleanBehavior = new BooleanBehavior(meta, nativeObjectBehavior, this); var listBehavior = new ListBehavior(meta, enumerableBehavior, this); var stringBehavior = new StringBehavior(meta, nativeObjectBehavior, this); this.RegisterNativeBehavior(typeof(IEnumerable), enumerableBehavior); this.RegisterNativeBehavior(typeof(bool), booleanBehavior); this.RegisterNativeBehavior(typeof(IList), listBehavior); this.RegisterNativeBehavior(typeof(Block), new BlockBehavior(meta, this.nilclass, this)); this.RegisterNativeBehavior(typeof(string), stringBehavior); // Global Objects this.SetGlobalObject("UndefinedObject", this.nilclass); this.SetGlobalObject("Machine", this); this.SetGlobalObject("Smalltalk", this.environment); }
public void Create() { Machine machine = new Machine(); BaseClass bclass = new BaseClass("Class", machine); Assert.IsNotNull(bclass); Assert.AreEqual("Class", bclass.Name); Assert.AreEqual(machine, bclass.Machine); Assert.IsNull(bclass.SuperClass); Assert.AreEqual(0, bclass.NoInstanceVariables); Assert.AreSame(machine.CurrentEnvironment, bclass.Scope); }
public void CreateWithVariablesAndClass() { Machine machine = new Machine(); BaseClass cls = new BaseClass("MyClass", machine); BaseObject bo = new BaseObject(cls, new object[] { 1, 2, 3 }); Assert.AreEqual(1, bo[0]); Assert.AreEqual(2, bo[1]); Assert.AreEqual(3, bo[2]); Assert.AreEqual(cls, bo.Behavior); }
public void DefineAndCreateAgent() { Machine machine = new Machine(); BaseClass bclass = new BaseClass("Agent", machine); bclass.IsAgentClass = true; object result = bclass.NewObject(); Assert.IsNotNull(result); Assert.IsInstanceOfType(result, typeof(AgentObject)); AgentObject agent = (AgentObject)result; Assert.AreEqual(bclass, agent.Behavior); }
public void GetBehavior() { Machine machine = new Machine(); BaseClass cls = new BaseClass("MyClass", machine); BaseObject obj = new BaseObject(cls, new object[] { 1, 2, 3 }); RemoteObject ro = new RemoteObject(obj, null); Assert.AreEqual(1, ro[0]); Assert.AreEqual(2, ro[1]); Assert.AreEqual(3, ro[2]); Assert.AreEqual(cls, ro.Behavior); }
public void SerializeAndDeserializeCompositeObject() { Machine machine = new Machine(true); BaseClass cls = new BaseClass("MyClass", machine); BaseObject bso1 = new BaseObject(cls, new object[] { 1, 2, 3 }); BaseObject bso2 = new BaseObject(cls, new object[] { 2, 3, 4 }); BaseObject bso3 = new BaseObject(cls, new object[] { 4, 5, 6 }); BaseObject bo = new BaseObject(cls, new object[] { bso1, bso2, bso3, bso2 }); bso3[2] = bo; BinaryFormatter formatter = new BinaryFormatter(); BaseObject bo2; Machine machine2; BaseClass cls2; using (MemoryStream stream = new MemoryStream()) { formatter.Serialize(stream, bo); stream.Seek(0, SeekOrigin.Begin); machine2 = new Machine(true); Assert.AreSame(Machine.Current, machine2); cls2 = new BaseClass("MyClass", machine2); machine2.SetGlobalObject("MyClass", cls2); bo2 = (BaseObject)formatter.Deserialize(stream); } Assert.IsNotNull(bo2[0]); Assert.IsNotNull(bo2[1]); Assert.IsNotNull(bo2[2]); Assert.IsNotNull(bo2[3]); Assert.AreEqual(bo2[1], bo2[3]); Assert.IsNotNull(bo2.Behavior); Assert.AreSame(cls2, bo2.Behavior); Assert.IsInstanceOfType(bo2[0], typeof(BaseObject)); Assert.IsInstanceOfType(bo2[1], typeof(BaseObject)); Assert.IsInstanceOfType(bo2[2], typeof(BaseObject)); Assert.IsInstanceOfType(bo2[3], typeof(BaseObject)); BaseObject bso32 = (BaseObject)bo2[2]; Assert.AreSame(cls2, bso32.Behavior); Assert.AreSame(bo2, bso32[2]); Assert.AreEqual(cls, bo.Behavior); }
public IClass CreateClass(string name, string varnames) { if (this.classInstance != null) throw new InvalidOperationException("Metaclass has an instance class"); IBehavior super = null; if (this.SuperClass != null) { IMetaClass meta = this.SuperClass as IMetaClass; if (meta != null) super = meta.ClassInstance; } BaseClass cls = new BaseClass(this, name, super, this.Machine, varnames); this.classInstance = cls; return cls; }
public void DefineObjectMethod() { Machine machine = new Machine(); BaseClass cls = new BaseClass("MyClass", machine); BaseObject bo = (BaseObject)cls.NewObject(); Assert.AreEqual(cls, bo.Behavior); IMethod method = new Method(cls, "mymethod"); bo.DefineObjectMethod(method); Assert.AreNotEqual(cls, bo.Behavior); Assert.IsNotNull(bo.Behavior.GetInstanceMethod("mymethod")); Assert.AreEqual(method, bo.Behavior.GetInstanceMethod("mymethod")); Assert.AreNotEqual(cls, method.Behavior); Assert.AreEqual(bo.Behavior, method.Behavior); Assert.IsTrue(bo.IsPrototype); Assert.AreEqual(true, bo.SendMessage(machine, "isPrototype", null)); }
public void RaiseIfNameIsNull() { Machine machine = new Machine(); BaseClass bclass = new BaseClass(null, machine); }
public void RaiseIfMachineIsNull() { BaseClass bclass = new BaseClass("Class", null); }
public void GetSetClassVariablesInSubclass() { Machine machine = new Machine(); IClass bclass = new BaseClass("MyClass", machine); IClass bsubclass = new BaseClass(null, "MySubClass", bclass, machine, null); bclass.DefineClassVariable("Count"); bclass.DefineClassVariable("Items"); bsubclass.DefineClassVariable("Value"); int countoffset = bsubclass.GetClassVariableOffset("Count"); int itemsoffset = bsubclass.GetClassVariableOffset("Items"); int valueoffset = bsubclass.GetClassVariableOffset("Value"); Assert.AreEqual(0, countoffset); Assert.AreEqual(1, itemsoffset); Assert.AreEqual(2, valueoffset); bsubclass.SetClassVariable(countoffset, 1); bsubclass.SetClassVariable(itemsoffset, "foo"); bsubclass.SetClassVariable(valueoffset, "value"); Assert.AreEqual(1, bclass.GetClassVariable(countoffset)); Assert.AreEqual("foo", bclass.GetClassVariable(itemsoffset)); Assert.AreEqual(1, bsubclass.GetClassVariable(countoffset)); Assert.AreEqual("foo", bsubclass.GetClassVariable(itemsoffset)); Assert.AreEqual("value", bsubclass.GetClassVariable(valueoffset)); }
public void GetSetClassVariables() { Machine machine = new Machine(); IClass bclass = new BaseClass("MyClass", machine); bclass.DefineClassVariable("Count"); bclass.DefineClassVariable("Items"); int countoffset = bclass.GetClassVariableOffset("Count"); int itemsoffset = bclass.GetClassVariableOffset("Items"); Assert.AreEqual(0, countoffset); Assert.AreEqual(1, itemsoffset); bclass.SetClassVariable(countoffset, 1); bclass.SetClassVariable(itemsoffset, "foo"); Assert.AreEqual(1, bclass.GetClassVariable(countoffset)); Assert.AreEqual("foo", bclass.GetClassVariable(itemsoffset)); }
public void GetDefineString() { Machine machine = new Machine(); IMetaClass meta = BaseMetaClass.CreateMetaClass(null, machine); BaseClass bclass = new BaseClass(meta, "Class", null, machine, string.Empty); bclass.DefineInstanceVariable("x"); bclass.DefineInstanceVariable("y"); string definition = bclass.ToDefineString(); Assert.IsNotNull(definition); Assert.IsTrue(definition.Contains("subclass: #Class")); Assert.IsTrue(definition.Contains("instanceVariableNames: 'x y'")); Assert.IsTrue(definition.Contains("classVariableNames: ''")); Assert.IsTrue(definition.Contains("poolDictionaries: ''")); Assert.IsTrue(definition.Contains("category: ''")); }
public void DefineInstanceVariables() { Machine machine = new Machine(); BaseClass bclass = new BaseClass("Class", machine); bclass.DefineInstanceVariable("x"); bclass.DefineInstanceVariable("y"); Assert.AreEqual(2, bclass.NoInstanceVariables); Assert.AreEqual(0, bclass.GetInstanceVariableOffset("x")); Assert.AreEqual(1, bclass.GetInstanceVariableOffset("y")); Assert.AreEqual(-1, bclass.GetInstanceVariableOffset("z")); Assert.AreEqual("x y", bclass.GetInstanceVariableNamesAsString()); Assert.AreEqual(string.Empty, bclass.GetClassVariableNamesAsString()); Assert.AreEqual(null, bclass.GetClassVariableNames()); var result = bclass.GetInstanceVariableNames(); Assert.IsNotNull(result); Assert.AreEqual(2, result.Count); Assert.AreEqual("x", result.ElementAt(0)); Assert.AreEqual("y", result.ElementAt(1)); }
public void SetEnvironmentObject(Context environment, string objname, object value) { environment.SetValue(objname, value); if (environment != this.environment) return; if (objname == "Metaclass" && value is IClass) this.DefineMetaclass((IClass)value); else if (objname == "Class" && value is IClass) this.classclass = (IClass)value; else if (objname == "UndefinedObject" && value is IClass) this.nilclass = (BaseClass)value; }
public void SerializeAndDeserializeSimpleObject() { Machine machine = new Machine(); BaseClass cls = new BaseClass("MyClass", machine); BaseObject bo = new BaseObject(cls, new object[] { 1, 2, 3 }); BinaryFormatter formatter = new BinaryFormatter(); BaseObject bo2; Machine machine2; BaseClass cls2; using (MemoryStream stream = new MemoryStream()) { formatter.Serialize(stream, bo); stream.Seek(0, SeekOrigin.Begin); machine2 = new Machine(true); Assert.AreSame(Machine.Current, machine2); cls2 = new BaseClass("MyClass", machine2); machine2.SetGlobalObject("MyClass", cls2); bo2 = (BaseObject)formatter.Deserialize(stream); } Assert.AreEqual(1, bo2[0]); Assert.AreEqual(2, bo2[1]); Assert.AreEqual(3, bo2[2]); Assert.IsNotNull(bo2.Behavior); Assert.AreSame(cls2, bo2.Behavior); Assert.AreEqual(cls, bo.Behavior); }