public void Deserialize_CompatibilityWithPersistedData()
{
ITest t1 = new ClassWithInterface()
{
a = 1, b = 11
};
ITest t2 = new ClassWithInterface()
{
a = 2, b = 22
};
var orig = new ITest[] { t1, t2 };
var data = @"<?xml version=""1.0"" encoding=""utf-16""?>
<ArrayOfUtilityTest.ClassWithInterface xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"" xmlns=""http://schemas.datacontract.org/2004/07/Rhetos.Utilities.Test"">
<XmlUtilityTest.ClassWithInterface>
<a>1</a>
<b>11</b>
</XmlUtilityTest.ClassWithInterface>
<XmlUtilityTest.ClassWithInterface>
<a>2</a>
<b>22</b>
</XmlUtilityTest.ClassWithInterface>
</ArrayOfUtilityTest.ClassWithInterface>";
var copy = _xmlUtility.DeserializeArrayFromXml <ClassWithInterface>(data);
string msg = "It should be possible to deserialize the old serialized concepts (in table Rhetos.AppliedConcept) with a new version of the class, if its interface is backward compatible.";
Assert.AreEqual(orig.Length, copy.Length, msg);
Assert.AreEqual(orig[0].a, copy[0].a, msg);
Assert.AreEqual(orig[1].a, copy[1].a, msg);
Assert.AreEqual(((ClassWithInterface)orig[0]).b, ((ClassWithInterface)copy[0]).b, msg);
Assert.AreEqual(((ClassWithInterface)orig[1]).b, ((ClassWithInterface)copy[1]).b, msg);
}
private ClassWithDependancies GetClassWithDependancies()
{
ClassWithInterface classWithInterface = new ClassWithInterface();
ClassDependingOnInterface classDependingOnInterface = new ClassDependingOnInterface(classWithInterface);
ClassWithDependancies classWithDependancies = new ClassWithDependancies(classDependingOnInterface);
return(classWithDependancies);
}
public void WhenCreatingClassWithImplementationShouldGenerateSameImplementation()
{
var mapper = new BsonMapper();
ClassWithInterface objWithImpl1 = CreateModel(new Impl1());
ClassWithInterface mappedObjectWithImpl1 = MapAndDemapObject(mapper, objWithImpl1);
Assert.AreEqual(objWithImpl1.myInterface.getName(), mappedObjectWithImpl1.myInterface.getName());
}
public void RegisterSingleton_Object()
{
var obj = new ClassWithInterface();
_builder.RegisterSingleton(obj);
var container = _builder.Build();
container.Resolve <ClassWithInterface>().Should().Be(obj);
}
private ClassWithInterface CreateModel(MyInterface implementation)
{
var c = new ClassWithInterface
{
name = "Test",
myInterface = implementation
};
return(c);
}
public void SerializeToXml_Interface()
{
ITest orig = new ClassWithInterface {
a = 1, b = 2
};
var copy = SerializeDeserialize <ClassWithInterface>(orig);
Assert.AreEqual(1, copy.a);
Assert.AreEqual(2, copy.b);
}
public void Register_Interface_Class_Then_Singleton_ResolveSigleton()
{
var obj = new ClassWithInterface();
_builder.Register <IClassWithInterface, ClassWithInterface>();
_builder.RegisterSingleton <IClassWithInterface>(obj);
var container = _builder.Build();
container.Resolve <IClassWithInterface>().Should().Be(obj);
}
public void Get_ContractIsSingleton_ShouldReturnRegisteredInstance()
{
var container = new DIContainer();
var registeredInstance = new ClassWithInterface();
container.RegisterSingleton <IClassWithInterface>(registeredInstance);
var instance = container.Get <IClassWithInterface>();
Assert.AreEqual(registeredInstance, instance);
}
public void WhenCreatingImplementWithPropertyShouldKeepProperty()
{
var mapper = new BsonMapper();
ClassWithInterface objWithImpl = CreateModel(new ImplWithProperty()
{
name = RANDOM_NAME
});
ClassWithInterface mappedObjectWithImpl = MapAndDemapObject(mapper, objWithImpl);
Assert.AreEqual(RANDOM_NAME, mappedObjectWithImpl.myInterface.getName());
}
public void WhenCreatingTwoImplementsShouldHaveDifferentMethods()
{
var mapper = new BsonMapper();
ClassWithInterface objWithImpl1 = CreateModel(new Impl1());
ClassWithInterface mappedObjectWithImpl1 = MapAndDemapObject(mapper, objWithImpl1);
ClassWithInterface objWithImpl2 = CreateModel(new Impl2());
ClassWithInterface mappedObjectWithImpl2 = MapAndDemapObject(mapper, objWithImpl2);
Assert.AreNotEqual(mappedObjectWithImpl1.myInterface.getName(), mappedObjectWithImpl2.myInterface.getName());
}
public static void Module8Test3()
{
IActions daughter1 = new Daughter1();
IActions classWithInterface = new ClassWithInterface();
daughter1.DoSomething();
classWithInterface.DoSomething();
//(daughter1 as Daughter1).DoSomething()
//(daughter1 as Mother).DoSomething();
Console.ReadLine();
}
public void RegisterObjectAndSingleton_GetSingleton()
{
var obj = new ClassWithInterface();
_builder.RegisterSingleton <IClassWithInterface>(obj);
_builder.Register <IClassWithInterface, ClassWithInterface>();
var container = _builder.Build();
container.Resolve <IClassWithInterface>().Should().BeOfType(typeof(ClassWithInterface));
container.Resolve <IClassWithInterface>().Should().NotBe(obj);
}
public void GetComInterfaceForObject_NonGenericCustomQueryInterfaceModeWithValidClass_ReturnsExpected(CustomQueryInterfaceMode mode)
{
var o = new ClassWithInterface();
IntPtr iUnknown = Marshal.GetComInterfaceForObject(o, typeof(INonGenericInterface), mode);
try
{
Assert.NotEqual(IntPtr.Zero, iUnknown);
}
finally
{
Marshal.Release(iUnknown);
}
}
public void GetComInterfaceForObject_GenericWithValidClass_ReturnsExpected()
{
var o = new ClassWithInterface();
IntPtr iUnknown = Marshal.GetComInterfaceForObject <ClassWithInterface, INonGenericInterface>(o);
try
{
Assert.NotEqual(IntPtr.Zero, iUnknown);
}
finally
{
Marshal.Release(iUnknown);
}
}
public void SerializeToXml_PolimorphismNative()
{
ITest t1 = new ClassWithInterface()
{
a = 1, b = 11
};
ITest t2 = new ClassWithInterface()
{
a = 2, b = 22
};
var orig = new ITest[] { t1, t2 };
var data = _xmlUtility.SerializeArrayToXml <ITest>(orig);
Console.WriteLine(data);
var copy = _xmlUtility.DeserializeArrayFromXml <ITest>(data);
Assert.AreEqual(orig.Length, copy.Length);
Assert.AreEqual(orig[0].a, copy[0].a);
Assert.AreEqual(orig[1].a, copy[1].a);
Assert.AreEqual(((ClassWithInterface)orig[0]).b, ((ClassWithInterface)copy[0]).b);
Assert.AreEqual(((ClassWithInterface)orig[1]).b, ((ClassWithInterface)copy[1]).b);
}
private ClassWithInterface MapAndDemapObject(BsonMapper mapper, ClassWithInterface obj)
{
return(mapper.ToObject <ClassWithInterface>(mapper.ToDocument(obj)));
}
public static IEnumerable <object[]> GetNativeVariantForObject_NonRoundtrippingPrimitives_TestData()
{
// GetNativeVariantForObject supports char, but internally recognizes it the same as ushort
// because the native variant type uses mscorlib type VarEnum to store what type it contains.
// To get back the original char, use GetObjectForNativeVariant<ushort> and cast to char.
yield return(new object[] { 'a', VarEnum.VT_UI2, (IntPtr)'a', (ushort)97 });
yield return(new object[] { new char[] { 'a', 'b', 'c' }, (VarEnum.VT_ARRAY | VarEnum.VT_UI2), (IntPtr)(-1), new ushort[] { 'a', 'b', 'c' } });
// IntPtr/UIntPtr objects are _always_ converted to int/uint respectively.
// See OleVariant::MarshalOleVariantForObject conversion from ELEMENT_TYPE_I/ELEMENT_TYPE_U to VT_INT/VT_UINT
yield return(new object[] { (IntPtr)10, VarEnum.VT_INT, (IntPtr)10, 10 });
yield return(new object[] { (UIntPtr)10, VarEnum.VT_UINT, (IntPtr)10, (uint)10 });
// IntPtr/UIntPtr objects in arrays are converted to the appropriate pointer width.
// See OleVariant::GetVarTypeForTypeHandle conversion from IntPtr/UIntPtr to VT_INT/VT_UINT or VT_I8/VT_UI8 based on bitness
if (IntPtr.Size == 4)
{
yield return(new object[] { new IntPtr[] { (IntPtr)10, (IntPtr)11, (IntPtr)12 }, (VarEnum.VT_ARRAY | VarEnum.VT_INT), (IntPtr)(-1), new int[] { 10, 11, 12 } });
yield return(new object[] { new UIntPtr[] { (UIntPtr)10, (UIntPtr)11, (UIntPtr)12 }, (VarEnum.VT_ARRAY | VarEnum.VT_UINT), (IntPtr)(-1), new uint[] { 10, 11, 12 } });
}
else
{
yield return(new object[] { new IntPtr[] { (IntPtr)10, (IntPtr)11, (IntPtr)12 }, (VarEnum.VT_ARRAY | VarEnum.VT_I8), (IntPtr)(-1), new long[] { 10, 11, 12 } });
yield return(new object[] { new UIntPtr[] { (UIntPtr)10, (UIntPtr)11, (UIntPtr)12 }, (VarEnum.VT_ARRAY | VarEnum.VT_UI8), (IntPtr)(-1), new ulong[] { 10, 11, 12 } });
}
// DateTime is converted to VT_DATE which is offset from December 30, 1899.
DateTime earlyDateTime = new DateTime(1899, 12, 30);
yield return(new object[] { earlyDateTime, VarEnum.VT_DATE, IntPtr.Zero, new DateTime(1899, 12, 30) });
// Wrappers.
yield return(new object[] { new UnknownWrapper(10), VarEnum.VT_UNKNOWN, IntPtr.Zero, null });
yield return(new object[] { new DispatchWrapper[] { new DispatchWrapper(null), new DispatchWrapper(null) }, (VarEnum.VT_ARRAY | VarEnum.VT_DISPATCH), (IntPtr)(-1), new object[] { null, null } });
yield return(new object[] { new ErrorWrapper(10), VarEnum.VT_ERROR, (IntPtr)10, 10 });
yield return(new object[] { new CurrencyWrapper(10), VarEnum.VT_CY, (IntPtr)100000, 10m });
yield return(new object[] { new BStrWrapper("a"), VarEnum.VT_BSTR, (IntPtr)(-1), "a" });
yield return(new object[] { new BStrWrapper(null), VarEnum.VT_BSTR, IntPtr.Zero, null });
yield return(new object[] { new UnknownWrapper[] { new UnknownWrapper(null), new UnknownWrapper(10) }, (VarEnum.VT_ARRAY | VarEnum.VT_UNKNOWN), (IntPtr)(-1), new object[] { null, 10 } });
yield return(new object[] { new ErrorWrapper[] { new ErrorWrapper(10) }, (VarEnum.VT_ARRAY | VarEnum.VT_ERROR), (IntPtr)(-1), new uint[] { 10 } });
yield return(new object[] { new CurrencyWrapper[] { new CurrencyWrapper(10) }, (VarEnum.VT_ARRAY | VarEnum.VT_CY), (IntPtr)(-1), new decimal[] { 10 } });
yield return(new object[] { new BStrWrapper[] { new BStrWrapper("a"), new BStrWrapper(null), new BStrWrapper("c") }, (VarEnum.VT_ARRAY | VarEnum.VT_BSTR), (IntPtr)(-1), new string[] { "a", null, "c" } });
// Objects.
var nonGenericClass = new NonGenericClass();
yield return(new object[] { new NonGenericClass[] { nonGenericClass, null }, (VarEnum.VT_ARRAY | VarEnum.VT_DISPATCH), (IntPtr)(-1), new object[] { nonGenericClass, null } });
var genericClass = new GenericClass <string>();
yield return(new object[] { new GenericClass <string>[] { genericClass, null }, (VarEnum.VT_ARRAY | VarEnum.VT_UNKNOWN), (IntPtr)(-1), new object[] { genericClass, null } });
var classWithInterface = new ClassWithInterface();
var structWithInterface = new StructWithInterface();
yield return(new object[] { new ClassWithInterface[] { classWithInterface, null }, (VarEnum.VT_ARRAY | VarEnum.VT_DISPATCH), (IntPtr)(-1), new object[] { classWithInterface, null } });
yield return(new object[] { new INonGenericInterface[] { classWithInterface, structWithInterface, null }, (VarEnum.VT_ARRAY | VarEnum.VT_DISPATCH), (IntPtr)(-1), new object[] { classWithInterface, structWithInterface, null } });
// Enums.
yield return(new object[] { SByteEnum.Value2, VarEnum.VT_I1, (IntPtr)1, (sbyte)1 });
yield return(new object[] { Int16Enum.Value2, VarEnum.VT_I2, (IntPtr)1, (short)1 });
yield return(new object[] { Int32Enum.Value2, VarEnum.VT_I4, (IntPtr)1, 1 });
yield return(new object[] { Int64Enum.Value2, VarEnum.VT_I8, (IntPtr)1, (long)1 });
yield return(new object[] { ByteEnum.Value2, VarEnum.VT_UI1, (IntPtr)1, (byte)1 });
yield return(new object[] { UInt16Enum.Value2, VarEnum.VT_UI2, (IntPtr)1, (ushort)1 });
yield return(new object[] { UInt32Enum.Value2, VarEnum.VT_UI4, (IntPtr)1, (uint)1 });
yield return(new object[] { UInt64Enum.Value2, VarEnum.VT_UI8, (IntPtr)1, (ulong)1 });
yield return(new object[] { new SByteEnum[] { SByteEnum.Value2 }, (VarEnum.VT_ARRAY | VarEnum.VT_I1), (IntPtr)(-1), new sbyte[] { 1 } });
yield return(new object[] { new Int16Enum[] { Int16Enum.Value2 }, (VarEnum.VT_ARRAY | VarEnum.VT_I2), (IntPtr)(-1), new short[] { 1 } });
yield return(new object[] { new Int32Enum[] { Int32Enum.Value2 }, (VarEnum.VT_ARRAY | VarEnum.VT_I4), (IntPtr)(-1), new int[] { 1 } });
yield return(new object[] { new Int64Enum[] { Int64Enum.Value2 }, (VarEnum.VT_ARRAY | VarEnum.VT_I8), (IntPtr)(-1), new long[] { 1 } });
yield return(new object[] { new ByteEnum[] { ByteEnum.Value2 }, (VarEnum.VT_ARRAY | VarEnum.VT_UI1), (IntPtr)(-1), new byte[] { 1 } });
yield return(new object[] { new UInt16Enum[] { UInt16Enum.Value2 }, (VarEnum.VT_ARRAY | VarEnum.VT_UI2), (IntPtr)(-1), new ushort[] { 1 } });
yield return(new object[] { new UInt32Enum[] { UInt32Enum.Value2 }, (VarEnum.VT_ARRAY | VarEnum.VT_UI4), (IntPtr)(-1), new uint[] { 1 } });
yield return(new object[] { new UInt64Enum[] { UInt64Enum.Value2 }, (VarEnum.VT_ARRAY | VarEnum.VT_UI8), (IntPtr)(-1), new ulong[] { 1 } });
// Color is converted to uint.
yield return(new object[] { Color.FromArgb(10), VarEnum.VT_UI4, (IntPtr)655360, (uint)655360 });
}
public static IEnumerable <object[]> GetNativeVariantForObject_NonRoundtrippingPrimitives_TestData()
{
// GetNativeVariantForObject supports char, but internally recognizes it the same as ushort
// because the native variant type uses mscorlib type VarEnum to store what type it contains.
// To get back the original char, use GetObjectForNativeVariant<ushort> and cast to char.
yield return(new object[] { 'a', VarEnum.VT_UI2, (IntPtr)'a', (ushort)97 });
yield return(new object[] { new char[] { 'a', 'b', 'c' }, (VarEnum)8210, (IntPtr)(-1), new ushort[] { 'a', 'b', 'c' } });
// IntPtr/UIntPtr objects are converted to int/uint respectively.
yield return(new object[] { (IntPtr)10, VarEnum.VT_INT, (IntPtr)10, 10 });
yield return(new object[] { (UIntPtr)10, VarEnum.VT_UINT, (IntPtr)10, (uint)10 });
yield return(new object[] { new IntPtr[] { (IntPtr)10, (IntPtr)11, (IntPtr)12 }, (VarEnum)8212, (IntPtr)(-1), new long[] { 10, 11, 12 } });
yield return(new object[] { new UIntPtr[] { (UIntPtr)10, (UIntPtr)11, (UIntPtr)12 }, (VarEnum)8213, (IntPtr)(-1), new ulong[] { 10, 11, 12 } });
// DateTime is converted to VT_DATE which is offset from December 30, 1899.
DateTime earlyDateTime = new DateTime(1899, 12, 30);
yield return(new object[] { earlyDateTime, VarEnum.VT_DATE, IntPtr.Zero, new DateTime(1899, 12, 30) });
// Wrappers.
yield return(new object[] { new UnknownWrapper(10), VarEnum.VT_UNKNOWN, IntPtr.Zero, null });
if (!PlatformDetection.IsNetCore)
{
yield return(new object[] { new DispatchWrapper(10), VarEnum.VT_DISPATCH, IntPtr.Zero, null });
}
else
{
Assert.Throws <PlatformNotSupportedException>(() => new DispatchWrapper(10));
}
yield return(new object[] { new ErrorWrapper(10), VarEnum.VT_ERROR, (IntPtr)10, 10 });
yield return(new object[] { new CurrencyWrapper(10), VarEnum.VT_CY, (IntPtr)100000, 10m });
yield return(new object[] { new BStrWrapper("a"), VarEnum.VT_BSTR, (IntPtr)(-1), "a" });
yield return(new object[] { new BStrWrapper(null), VarEnum.VT_BSTR, IntPtr.Zero, null });
yield return(new object[] { new UnknownWrapper[] { new UnknownWrapper(null), new UnknownWrapper(10) }, (VarEnum)8205, (IntPtr)(-1), new object[] { null, 10 } });
if (!PlatformDetection.IsNetCore)
{
yield return(new object[] { new DispatchWrapper[] { new DispatchWrapper(null), new DispatchWrapper(10) }, (VarEnum)8201, (IntPtr)(-1), new object[] { null, 10 } });
}
else
{
Assert.Throws <PlatformNotSupportedException>(() => new DispatchWrapper(10));
}
yield return(new object[] { new ErrorWrapper[] { new ErrorWrapper(10) }, (VarEnum)8202, (IntPtr)(-1), new uint[] { 10 } });
yield return(new object[] { new CurrencyWrapper[] { new CurrencyWrapper(10) }, (VarEnum)8198, (IntPtr)(-1), new decimal[] { 10 } });
yield return(new object[] { new BStrWrapper[] { new BStrWrapper("a"), new BStrWrapper(null), new BStrWrapper("c") }, (VarEnum)8200, (IntPtr)(-1), new string[] { "a", null, "c" } });
// Objects.
var nonGenericClass = new NonGenericClass();
yield return(new object[] { new NonGenericClass[] { nonGenericClass, null }, (VarEnum)8201, (IntPtr)(-1), new object[] { nonGenericClass, null } });
var genericClass = new GenericClass <string>();
yield return(new object[] { new GenericClass <string>[] { genericClass, null }, (VarEnum)8205, (IntPtr)(-1), new object[] { genericClass, null } });
var nonGenericStruct = new NonGenericStruct();
yield return(new object[] { new NonGenericStruct[] { nonGenericStruct }, (VarEnum)8228, (IntPtr)(-1), new NonGenericStruct[] { nonGenericStruct } });
var classWithInterface = new ClassWithInterface();
var structWithInterface = new StructWithInterface();
yield return(new object[] { new ClassWithInterface[] { classWithInterface, null }, (VarEnum)8201, (IntPtr)(-1), new object[] { classWithInterface, null } });
yield return(new object[] { new StructWithInterface[] { structWithInterface }, (VarEnum)8228, (IntPtr)(-1), new StructWithInterface[] { structWithInterface } });
yield return(new object[] { new INonGenericInterface[] { classWithInterface, structWithInterface, null }, (VarEnum)8201, (IntPtr)(-1), new object[] { classWithInterface, structWithInterface, null } });
// Enums.
yield return(new object[] { SByteEnum.Value2, VarEnum.VT_I1, (IntPtr)1, (sbyte)1 });
yield return(new object[] { Int16Enum.Value2, VarEnum.VT_I2, (IntPtr)1, (short)1 });
yield return(new object[] { Int32Enum.Value2, VarEnum.VT_I4, (IntPtr)1, 1 });
yield return(new object[] { Int64Enum.Value2, VarEnum.VT_I8, (IntPtr)1, (long)1 });
yield return(new object[] { ByteEnum.Value2, VarEnum.VT_UI1, (IntPtr)1, (byte)1 });
yield return(new object[] { UInt16Enum.Value2, VarEnum.VT_UI2, (IntPtr)1, (ushort)1 });
yield return(new object[] { UInt32Enum.Value2, VarEnum.VT_UI4, (IntPtr)1, (uint)1 });
yield return(new object[] { UInt64Enum.Value2, VarEnum.VT_UI8, (IntPtr)1, (ulong)1 });
yield return(new object[] { new SByteEnum[] { SByteEnum.Value2 }, (VarEnum)8208, (IntPtr)(-1), new sbyte[] { 1 } });
yield return(new object[] { new Int16Enum[] { Int16Enum.Value2 }, (VarEnum)8194, (IntPtr)(-1), new short[] { 1 } });
yield return(new object[] { new Int32Enum[] { Int32Enum.Value2 }, (VarEnum)8195, (IntPtr)(-1), new int[] { 1 } });
yield return(new object[] { new Int64Enum[] { Int64Enum.Value2 }, (VarEnum)8212, (IntPtr)(-1), new long[] { 1 } });
yield return(new object[] { new ByteEnum[] { ByteEnum.Value2 }, (VarEnum)8209, (IntPtr)(-1), new byte[] { 1 } });
yield return(new object[] { new UInt16Enum[] { UInt16Enum.Value2 }, (VarEnum)8210, (IntPtr)(-1), new ushort[] { 1 } });
yield return(new object[] { new UInt32Enum[] { UInt32Enum.Value2 }, (VarEnum)8211, (IntPtr)(-1), new uint[] { 1 } });
yield return(new object[] { new UInt64Enum[] { UInt64Enum.Value2 }, (VarEnum)8213, (IntPtr)(-1), new ulong[] { 1 } });
// Color is converted to uint.
yield return(new object[] { Color.FromArgb(10), VarEnum.VT_UI4, (IntPtr)655360, (uint)655360 });
}
