public void StructToString()
{
var converter = new TestObjectConverter();
Assert.Equal("(1,2)", converter.Convert(new StructType {
X = 1, Y = 2
}, typeof(string)));
Assert.True(converter.UsedOnly <ToStringConverterFactory>());
}
public void StringToNullableUShort()
{
var converter = new TestObjectConverter();
Assert.Equal(UInt16.MinValue, converter.Convert(UInt16.MinValue.ToString(), typeof(ushort?)));
Assert.Equal(UInt16.MaxValue, converter.Convert(UInt16.MaxValue.ToString(), typeof(ushort?)));
Assert.Null(converter.Convert(string.Empty, typeof(ushort?)));
Assert.True(converter.UsedOnly <NumericParseConverterFactory>());
}
public void StringToInt()
{
var converter = new TestObjectConverter();
Assert.Equal(Int32.MinValue, converter.Convert(Int32.MinValue.ToString(), typeof(int)));
Assert.Equal(Int32.MaxValue, converter.Convert(Int32.MaxValue.ToString(), typeof(int)));
Assert.Equal(default(int), converter.Convert(string.Empty, typeof(int)));
Assert.True(converter.UsedOnly <NumericParseConverterFactory>());
}
public void StringToDouble()
{
var converter = new TestObjectConverter();
Assert.Equal(Double.MinValue, converter.Convert(Double.MinValue.ToString("R"), typeof(double)));
Assert.Equal(Double.MaxValue, converter.Convert(Double.MaxValue.ToString("R"), typeof(double)));
Assert.Equal(default(double), converter.Convert(string.Empty, typeof(double)));
Assert.True(converter.UsedOnly <NumericParseConverterFactory>());
}
public void StringToNullableFloat()
{
var converter = new TestObjectConverter();
Assert.Equal(Single.MinValue, converter.Convert(Single.MinValue.ToString("R"), typeof(float?)));
Assert.Equal(Single.MaxValue, converter.Convert(Single.MaxValue.ToString("R"), typeof(float?)));
Assert.Null(converter.Convert(string.Empty, typeof(float?)));
Assert.True(converter.UsedOnly <NumericParseConverterFactory>());
}
public void DecimalToUInt()
{
var converter = new TestObjectConverter();
Assert.Equal(0U, converter.Convert(Decimal.Zero, typeof(uint)));
Assert.Equal(1U, converter.Convert(Decimal.One, typeof(uint)));
Assert.Equal(default(uint), converter.Convert(Decimal.MaxValue, typeof(uint)));
Assert.True(converter.UsedOnly <DecimalConverterFactory>());
}
public void DecimalToNullableBoolean()
{
var converter = new TestObjectConverter();
Assert.False((bool)converter.Convert(0m, typeof(bool?)));
Assert.True((bool)converter.Convert(1m, typeof(bool?)));
Assert.True((bool)converter.Convert(-1m, typeof(bool?)));
Assert.True(converter.UsedOnly <BooleanConverterFactory>());
}
public void DecimalToByte()
{
var converter = new TestObjectConverter();
Assert.Equal((byte)0, converter.Convert(Decimal.Zero, typeof(byte)));
Assert.Equal((byte)1, converter.Convert(Decimal.One, typeof(byte)));
Assert.Equal(default(byte), converter.Convert(Decimal.MaxValue, typeof(byte)));
Assert.True(converter.UsedOnly <DecimalConverterFactory>());
}
public void FloatToBoolean()
{
var converter = new TestObjectConverter();
Assert.False((bool)converter.Convert(0f, typeof(bool)));
Assert.True((bool)converter.Convert(1f, typeof(bool)));
Assert.True((bool)converter.Convert(-1f, typeof(bool)));
Assert.True(converter.UsedOnly <BooleanConverterFactory>());
}
public void ShortToNullableBoolean()
{
var converter = new TestObjectConverter();
Assert.False((bool)converter.Convert((short)0, typeof(bool?)));
Assert.True((bool)converter.Convert((short)1, typeof(bool?)));
Assert.True((bool)converter.Convert((short)-1, typeof(bool?)));
Assert.True(converter.UsedOnly <BooleanConverterFactory>());
}
public void SByteToBoolean()
{
var converter = new TestObjectConverter();
Assert.False((bool)converter.Convert((sbyte)0, typeof(bool)));
Assert.True((bool)converter.Convert((sbyte)1, typeof(bool)));
Assert.True((bool)converter.Convert((sbyte)-1, typeof(bool)));
Assert.True(converter.UsedOnly <BooleanConverterFactory>());
}
public void ConvertExplicitToInt()
{
var converter = new TestObjectConverter();
Assert.Equal(1, converter.Convert <int>(new ExplicitType {
Value = 1
}));
Assert.True(converter.UsedOnly <ConversionOperatorConverterFactory>());
}
public void StringToEnum()
{
var converter = new TestObjectConverter();
Assert.Equal(Enum1Type.Zero, converter.Convert("Zero", typeof(Enum1Type)));
Assert.Equal(Enum1Type.One, converter.Convert("One", typeof(Enum1Type)));
Assert.Equal(Enum1Type.Zero, converter.Convert("0", typeof(Enum1Type)));
Assert.Equal(Enum1Type.One, converter.Convert("1", typeof(Enum1Type)));
Assert.True(converter.UsedOnly <EnumConverterFactory>());
}
public void EnumerableToSameElementArray()
{
var converter = new TestObjectConverter();
var source = new[] { 0, 1 }.Select(x => x);
var destination = (int[])converter.Convert(source, typeof(int[]));
Assert.Equal(2, destination.Length);
Assert.Equal(0, destination[0]);
Assert.Equal(1, destination[1]);
Assert.True(converter.UsedOnly <EnumerableConverterFactory>());
}
public void EnumerableToSameElementReadOnlyCollection()
{
var converter = new TestObjectConverter();
var source = new[] { 0, 1 }.Select(x => x);
var destination = (ReadOnlyCollection <int>)converter.Convert(source, typeof(ReadOnlyCollection <int>));
Assert.Equal(2, destination.Count);
Assert.Equal(0, destination[0]);
Assert.Equal(1, destination[1]);
Assert.True(converter.UsedOnly <EnumerableConverterFactory>());
}
public void CollectionToOtherElementReadOnlyCollection()
{
var converter = new TestObjectConverter();
var source = new WrapperCollection <int>(new[] { 0, 1 });
var destination = (ReadOnlyCollection <string>)converter.Convert(source, typeof(ReadOnlyCollection <string>));
Assert.Equal(2, destination.Count);
Assert.Equal("0", destination[0]);
Assert.Equal("1", destination[1]);
Assert.True(converter.UsedIn(typeof(EnumerableConverterFactory), typeof(ToStringConverterFactory)));
}
public void EnumerableToOtherElementArray()
{
var converter = new TestObjectConverter();
var source = new[] { 0, 1 }.Select(x => x);
var destination = (string[])converter.Convert(source, typeof(string[]));
Assert.Equal(2, destination.Length);
Assert.Equal("0", destination[0]);
Assert.Equal("1", destination[1]);
Assert.True(converter.UsedIn(typeof(EnumerableConverterFactory), typeof(ToStringConverterFactory)));
}
public void EnumerableToSameElementConcurrentStack()
{
var converter = new TestObjectConverter();
var source = new[] { 0, 1 }.Select(x => x);
var destination = (ConcurrentStack <int>)converter.Convert(source, typeof(ConcurrentStack <int>));
Assert.Equal(2, destination.Count);
Assert.Contains(0, destination);
Assert.Contains(1, destination);
Assert.True(converter.UsedOnly <EnumerableConverterFactory>());
}
public void CollectionToSameElementStack()
{
var converter = new TestObjectConverter();
var source = new WrapperCollection <int>(new[] { 0, 1 });
var destination = (Stack <int>)converter.Convert(source, typeof(Stack <int>));
Assert.Equal(2, destination.Count);
Assert.Contains(0, destination);
Assert.Contains(1, destination);
Assert.True(converter.UsedOnly <EnumerableConverterFactory>());
}
public void CollectionToOtherElementConcurrentStack()
{
var converter = new TestObjectConverter();
var source = new WrapperCollection <int>(new[] { 0, 1 });
var destination = (ConcurrentStack <string>)converter.Convert(source, typeof(ConcurrentStack <string>));
Assert.Equal(2, destination.Count);
Assert.Contains("0", destination);
Assert.Contains("1", destination);
Assert.True(converter.UsedIn(typeof(EnumerableConverterFactory), typeof(ToStringConverterFactory)));
}
public void LinkedListToOtherElementLinkedList()
{
var converter = new TestObjectConverter();
var source = new WrapperList <int>(new[] { 0, 1 });
var destination = (LinkedList <string>)converter.Convert(source, typeof(LinkedList <string>));
Assert.Equal(2, destination.Count);
Assert.Contains("0", destination);
Assert.Contains("1", destination);
Assert.True(converter.UsedIn(typeof(EnumerableConverterFactory), typeof(ToStringConverterFactory)));
}
public void EnumerableToOtherElementStack()
{
var converter = new TestObjectConverter();
var source = new[] { 0, 1 }.Select(x => x);
var destination = (Stack <string>)converter.Convert(source, typeof(Stack <string>));
Assert.Equal(2, destination.Count);
Assert.Contains("0", destination);
Assert.Contains("1", destination);
Assert.True(converter.UsedIn(typeof(EnumerableConverterFactory), typeof(ToStringConverterFactory)));
}
public void ArrayToOtherElementQueue()
{
var converter = new TestObjectConverter();
var source = new[] { 0, 1 };
var destination = (Queue <string>)converter.Convert(source, typeof(Queue <string>));
Assert.Equal(2, destination.Count);
Assert.Contains("0", destination);
Assert.Contains("1", destination);
Assert.True(converter.UsedIn(typeof(EnumerableConverterFactory), typeof(ToStringConverterFactory)));
}
public void ArrayToSameElementLinkedList()
{
var converter = new TestObjectConverter();
var source = new[] { 0, 1 };
var destination = (LinkedList <int>)converter.Convert(source, typeof(LinkedList <int>));
Assert.Equal(2, destination.Count);
Assert.Contains(0, destination);
Assert.Contains(1, destination);
Assert.True(converter.UsedOnly <EnumerableConverterFactory>());
}
public void ListToSameElementConcurrentBag()
{
var converter = new TestObjectConverter();
var source = new WrapperList <int>(new[] { 0, 1 });
var destination = (ConcurrentBag <int>)converter.Convert(source, typeof(ConcurrentBag <int>));
Assert.Equal(2, destination.Count);
Assert.Contains(0, destination);
Assert.Contains(1, destination);
Assert.True(converter.UsedOnly <EnumerableConverterFactory>());
}
public void ConvertNullableImplicitToIntNullable()
{
var converter = new TestObjectConverter();
Assert.Equal(1, converter.Convert <int?>(new NullableImplicitType {
Value = 1
}));
Assert.Null(converter.Convert <int?>(new NullableImplicitType {
Value = null
}));
Assert.True(converter.UsedOnly <ConversionOperatorConverterFactory>());
}
public void CanNotConvertFromList()
{
var converter = new TestObjectConverter();
Assert.False(converter.CanConvert(typeof(List <int>), typeof(StructType)));
}
public void CanNotConvertFromEnum()
{
var converter = new TestObjectConverter();
Assert.False(converter.CanConvert(typeof(Enum1Type), typeof(StructType)));
}
public void NotAssignable()
{
var converter = new TestObjectConverter();
Assert.Throws <ObjectConverterException>(() => converter.Convert(new BaseType(), typeof(DeliveredType)));
}
public void DateTimeCanNotCovert()
{
var converter = new TestObjectConverter();
Assert.False(converter.CanConvert(typeof(DateTime), typeof(StructType)));
}
