public void GetClonedToString() { IObject cloned = new DerivedObject(this.obj); string text = cloned.ToString(); Assert.IsTrue(text.StartsWith("Object_")); }
public void TestCacheAsMostDerivedType() { var baseObject = new BaseObject { TestValue = 1 }; var derivedObject = new DerivedObject { TestValue = 2 }; var dependencies = new DependencyContainer(); dependencies.Cache(baseObject); dependencies.Cache(derivedObject); BaseObject receivedBase = null; BaseObject receivedDerived = null; var receiver = new Receiver1 { OnLoad = (b, d) => { receivedBase = b; receivedDerived = d; } }; dependencies.Inject(receiver); Assert.AreEqual(typeof(BaseObject), receivedBase.GetType()); Assert.AreEqual(typeof(DerivedObject), receivedDerived.GetType()); Assert.AreEqual(1, receivedBase.TestValue); Assert.AreEqual(2, receivedDerived.TestValue); }
public void We_should_go_through_the_list_quickly() { DerivedObject obj = new DerivedObject("Chris", "Patterson", "Pimp"); DerivedObject obj2 = new DerivedObject("Joe", "Blow", "Daddy"); //IObjectFormatter fomatter = new XmlObjectFormatter(); MemoryStream mstream = new MemoryStream(); using(IObjectFormatter formatter = new BEncodeObjectFormatter(mstream)) using(IObjectSerializer serializer = new BasicObjectSerializer(formatter)) { serializer.Serialize(formatter, obj); serializer.Serialize(formatter, obj2); } Debug.WriteLine("DATA: " + Encoding.UTF8.GetString(mstream.ToArray())); MemoryStream mdecode = new MemoryStream(mstream.ToArray()); using(BDecode decoder = new BDecode(mdecode)) { object newObj = decoder.Read(TimeSpan.FromSeconds(200)); Assert.That(newObj, Is.Not.Null); Assert.That(newObj, Is.TypeOf(typeof(DerivedObject)), "Invalid Type Received"); object newObj2 = decoder.Read(TimeSpan.FromSeconds(200)); Assert.That(newObj2, Is.Not.Null); Assert.That(newObj2, Is.TypeOf(typeof(DerivedObject)), "Invalid Type Received"); } }
static (GCHandle handle, WeakReference <DerivedObject>) GetWeakReference() { DerivedObject obj = new DerivedObject(TestComWrappers.TrackerSupportInstance); // We use an explicit weak GC handle here to enable us to validate that we are using "weak" GCHandle // semantics with the weak reference. return(GCHandle.Alloc(obj, GCHandleType.Weak), new WeakReference <DerivedObject>(obj)); }
static void Main(string[] args) { var baseClass = new BaseObject(); baseClass.Execute(); var derivedClass = new DerivedObject(); derivedClass.Execute(); Console.ReadKey(); }
public void CloneObject() { Message message = new Message("clone"); object result = message.Send(null, this.obj); Assert.IsNotNull(result); Assert.IsInstanceOfType(result, typeof(IObject)); Assert.IsInstanceOfType(result, typeof(DerivedObject)); DerivedObject obj2 = (DerivedObject)result; Assert.AreEqual(obj, obj2.Parent); }
public static void GotDerivedEvent() { var x = new RaisingClass(); var args = new DerivedObject(); var evt = Assert.RaisesAny <object>( h => x.Completed += h, h => x.Completed -= h, () => x.RaiseWithArgs(args) ); Assert.NotNull(evt); Assert.Equal(x, evt.Sender); Assert.Equal(args, evt.Arguments); }
static void Main() { DerivedDynamic instance1 = new DerivedDynamic(); instance1.Value = "Some string..."; instance1.Value = 20; Console.WriteLine(42 + instance1.Value); DerivedObject instance2 = new DerivedObject(); instance2.Value = "Some string..."; Console.WriteLine(42 + instance2.Value.ToString()); // Delay. Console.ReadKey(); }
/// <summary> /// A child object is not equal to the parent object as it should expect /// a component to compare for equality that the parent object will not have. /// Therefore, when Equals is used to test the equality between a child and parent object, /// it should return false. /// Both base.Equals(derived) and derived.Equals(base) should be false. /// What about the case where Derived does not override GetEqualityComponents? This is also false. /// </summary> /// <returns>The given scenario.</returns> public static TheoryData <ValueObject, ValueObject, string> DerivedObjectsAreNotEqualScenarios() { var baseObject = new BaseObject(); var derivedObject = new DerivedObject(); var derivedObjectNoEqualityComponents = new DerivedObjectNoEqualityComponents(); var differentEqualityComponentsMessage = "Base Object is a different type to Derived Object and has different equality components"; var differentTypesMessage = "Base Object is a different type to Derived Object"; return(new TheoryData <ValueObject, ValueObject, string> { { baseObject, derivedObject, differentEqualityComponentsMessage }, { baseObject, derivedObjectNoEqualityComponents, differentTypesMessage }, { derivedObject, baseObject, differentEqualityComponentsMessage }, { derivedObject, derivedObjectNoEqualityComponents, differentTypesMessage }, { derivedObjectNoEqualityComponents, baseObject, differentTypesMessage }, { derivedObjectNoEqualityComponents, derivedObject, differentTypesMessage } }); }
public static void TestApplyMissingProperty() { var start = new DerivedObject { a = 1, b = 2, c = 3 }; var end = new DerivedObject { a = 2, b = 2, c = 5 }; var delta = new SavedObjectDelta(new SavedObject(start), new SavedObject(end)); var simpleObj = new SimpleObject() { b = 20 }; delta.ApplyChanges(ref simpleObj); Assert.AreEqual(start.a, simpleObj.a); Assert.AreEqual(20, simpleObj.b); }
private void load(BaseObject baseObject, DerivedObject derivedObject) => OnLoad?.Invoke(baseObject, derivedObject);