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);
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);
}
