public void ChangeType_Numerics()
{
var ics = new DeepConvertSettings
{
Provider = CultureInfo.InvariantCulture,
Format = "0.00"
};
var decs = new DeepConvertSettings
{
Provider = CultureInfo.GetCultureInfo("de-DE"),
Format = "0.00"
};
Assert.AreEqual(20, DeepConvert.ChangeType <byte>(20));
Assert.AreEqual("20", DeepConvert.ChangeType <string>(20.0));
Assert.AreEqual("20.00", DeepConvert.ChangeType <string>(20.0, ics));
Assert.AreEqual("20,00", DeepConvert.ChangeType <string>(20.0, decs));
Assert.AreEqual(false, DeepConvert.ChangeType <bool>(0));
Assert.AreEqual(true, DeepConvert.ChangeType <bool>(20));
Assert.AreEqual(false, DeepConvert.ChangeType <bool>(0.0));
Assert.AreEqual(true, DeepConvert.ChangeType <bool>(20.0));
Assert.AreEqual(1, DeepConvert.ChangeType <byte>(true));
Assert.AreEqual(100, DeepConvert.ChangeType <float>(100));
Assert.AreEqual(100, DeepConvert.ChangeType <float>("100"));
Assert.AreEqual(100, DeepConvert.ChangeType <float>("100.0", ics));
Assert.AreEqual(100, DeepConvert.ChangeType <double>("100"));
Assert.AreEqual(100, DeepConvert.ChangeType <double>("100.0", ics));
Assert.AreEqual(100, DeepConvert.ChangeType <decimal>("100"));
Assert.AreEqual(100, DeepConvert.ChangeType <decimal>("100.0", ics));
Assert.AreEqual(100, DeepConvert.ChangeTypeInvariant <decimal>("100.0"));
Assert.AreEqual(100, DeepConvert.ChangeTypeInvariant <decimal>("100.0", decs));
}
public void ChangeType_StringToBytes()
{
string str = "Aöbc€";
var bytes = DeepConvert.ChangeType <List <byte> >(str); // default UTF-8
Assert.AreEqual(8, bytes.Count);
Assert.AreEqual(0x41, bytes[0]); // A
Assert.AreEqual(0xc3, bytes[1]); // ö
Assert.AreEqual(0xb6, bytes[2]);
Assert.AreEqual(0x62, bytes[3]); // b
Assert.AreEqual(0x63, bytes[4]); // c
Assert.AreEqual(0xe2, bytes[5]); // €
Assert.AreEqual(0x82, bytes[6]);
Assert.AreEqual(0xac, bytes[7]);
byte[] bytesArr = DeepConvert.ChangeType <byte[]>(str, new DeepConvertSettings {
Encoding = Encoding.Unicode
});
Assert.AreEqual(10, bytesArr.Length);
Assert.AreEqual(0x41, bytesArr[0]); // A
Assert.AreEqual(0, bytesArr[1]);
Assert.AreEqual(0xf6, bytesArr[2]); // ö
Assert.AreEqual(0, bytesArr[3]);
Assert.AreEqual(0x62, bytesArr[4]); // b
Assert.AreEqual(0, bytesArr[5]);
Assert.AreEqual(0x63, bytesArr[6]); // c
Assert.AreEqual(0, bytesArr[7]);
Assert.AreEqual(0xac, bytesArr[8]); // €
Assert.AreEqual(0x20, bytesArr[9]);
}
public void ToDateTime_NumericDefault()
{
var date = DeepConvert.ToDateTime(TimeSpan.TicksPerDay);
Assert.AreEqual(new DateTime(1, 1, 2, 0, 0, 0), date);
Assert.AreEqual(DateTimeKind.Unspecified, date.Kind);
}
public void ChangeType_Nullable()
{
Assert.AreEqual(4, DeepConvert.ChangeType <int>(4));
Assert.AreEqual(null, DeepConvert.ChangeType <int?>(null));
Assert.AreEqual(null, DeepConvert.ChangeType <int?>(""));
Assert.AreEqual(null, DeepConvert.ChangeType <bool?>(""));
Assert.AreEqual(4, DeepConvert.ChangeType <int?>(4));
}
public void ChangeType_ArrayToListWithNull()
{
var stringList = DeepConvert.ChangeType <List <string> >(new object[] { null, "item2" });
Assert.AreEqual(typeof(List <string>), stringList.GetType());
Assert.AreEqual(2, stringList.Count);
Assert.AreEqual(null, stringList[0]);
Assert.AreEqual("item2", stringList[1]);
}
public void ToDateTime_StringFormatLocal()
{
var date = DeepConvert.ToDateTime("18.02.03 04.05.06", new DeepConvertSettings {
Format = "yy.MM.dd HH.mm.ss", DateTimeStyles = DateTimeStyles.AssumeLocal
});
Assert.AreEqual(new DateTime(2018, 2, 3, 4, 5, 6), date);
Assert.AreEqual(DateTimeKind.Local, date.Kind);
}
public void ToDateTime_StringLocalToUtc()
{
var date = DeepConvert.ToDateTime("2018-02-03 04:05:06", new DeepConvertSettings {
DateTimeStyles = DateTimeStyles.AssumeLocal | DateTimeStyles.AdjustToUniversal
});
Assert.AreEqual(new DateTime(2018, 2, 3, 4, 5, 6, DateTimeKind.Local).ToUniversalTime(), date);
Assert.AreEqual(DateTimeKind.Utc, date.Kind);
}
public void ToDateTime_StringFormat()
{
var date = DeepConvert.ToDateTime("18.02.03 04.05.06", new DeepConvertSettings {
Format = "yy.MM.dd HH.mm.ss"
});
Assert.AreEqual(new DateTime(2018, 2, 3, 4, 5, 6), date);
Assert.AreEqual(DateTimeKind.Unspecified, date.Kind);
}
public void ChangeType_ArrayToList()
{
var intList = DeepConvert.ChangeType <List <int> >(new[] { "1", "2" });
Assert.AreEqual(typeof(List <int>), intList.GetType());
Assert.AreEqual(2, intList.Count);
Assert.AreEqual(1, intList[0]);
Assert.AreEqual(2, intList[1]);
}
public void ToDateTime_NumericUnixSeconds()
{
var date = DeepConvert.ToDateTime(2 * 86400, new DeepConvertSettings {
DateNumericKind = DateNumericKind.UnixSeconds
});
Assert.AreEqual(new DateTime(1970, 1, 3, 0, 0, 0), date);
Assert.AreEqual(DateTimeKind.Utc, date.Kind);
}
public void ToDateTime_DoubleUnixMilliseconds()
{
var date = DeepConvert.ToDateTime(3.5 * 86400 * 1000, new DeepConvertSettings {
DateNumericKind = DateNumericKind.UnixMilliseconds
});
Assert.AreEqual(new DateTime(1970, 1, 4, 12, 0, 0), date);
Assert.AreEqual(DateTimeKind.Utc, date.Kind);
}
public void ChangeType_EnumerableToQueue()
{
var intQueue = DeepConvert.ChangeType <Queue <int> >(new[] { 1 }.Concat(new[] { 2 }));
Assert.AreEqual(typeof(Queue <int>), intQueue.GetType());
Assert.AreEqual(2, intQueue.Count);
Assert.AreEqual(1, intQueue.ElementAt(0));
Assert.AreEqual(2, intQueue.ElementAt(1));
}
public void ChangeType_ArrayToLongerTuple()
{
var tuple = DeepConvert.ChangeType <Tuple <long, string, char, bool> >(new object[] { "1", 2 });
Assert.AreEqual(typeof(Tuple <long, string, char, bool>), tuple.GetType());
Assert.AreEqual(1, tuple.Item1);
Assert.AreEqual("2", tuple.Item2);
Assert.AreEqual('\0', tuple.Item3);
Assert.AreEqual(false, tuple.Item4);
}
public void ChangeType_ArrayToArray()
{
int[] intArray = DeepConvert.ChangeType <int[]>(new object[] { "1", 2, 3.0, '\u0004' });
Assert.AreEqual(typeof(int[]), intArray.GetType());
Assert.AreEqual(4, intArray.Length);
Assert.AreEqual(1, intArray[0]);
Assert.AreEqual(2, intArray[1]);
Assert.AreEqual(3, intArray[2]);
Assert.AreEqual(4, intArray[3]);
}
public void ChangeType_ArrayToTuple()
{
var tuple = DeepConvert.ChangeType <Tuple <short, long, string, char, bool> >(new object[] { "1", "2", 3, 4, 5, 6 });
Assert.AreEqual(typeof(Tuple <short, long, string, char, bool>), tuple.GetType());
Assert.AreEqual(1, tuple.Item1);
Assert.AreEqual(2, tuple.Item2);
Assert.AreEqual("3", tuple.Item3);
Assert.AreEqual('\u0004', tuple.Item4);
Assert.AreEqual(true, tuple.Item5);
}
public void ChangeType_DictionaryObjectArray()
{
var dict = new Dictionary <object, object>
{
["a"] = new object[0]
};
var result = DeepConvert.ChangeType <Dictionary <string, object> >(dict);
Assert.AreEqual(1, result.Count);
Assert.AreEqual(typeof(object[]), result["a"].GetType());
Assert.AreEqual(0, ((object[])result["a"]).Length);
}
public void ChangeType_Enums()
{
Assert.AreEqual(Enum2.One2, DeepConvert.ChangeType <Enum2>(Enum1.One1));
Assert.AreEqual(Enum2.One2, DeepConvert.ChangeType <Enum2>(1));
Assert.AreEqual(Enum2.One2, DeepConvert.ChangeType <Enum2?>(1));
Assert.AreEqual(Enum1.One1, DeepConvert.ChangeType <Enum1?>(Enum1.One1));
Assert.AreEqual(Enum1.One1, DeepConvert.ChangeType <Enum1?>(true));
Assert.AreEqual(Enum1.Zero1, DeepConvert.ChangeType <Enum1?>(false));
Assert.AreEqual(Enum1.One1, DeepConvert.ChangeType <Enum1?>(new BigInteger(1)));
Assert.AreEqual(Enum1.Zero1, DeepConvert.ChangeType <Enum1>(null));
Assert.AreEqual(null, DeepConvert.ChangeType <Enum1?>(null));
}
public void ChangeType_TimeSpan()
{
var timeSpan = TimeSpan.FromSeconds(62);
Assert.AreEqual("00:01:02", DeepConvert.ChangeType <string>(timeSpan));
Assert.AreEqual("00:01:02", DeepConvert.ChangeType <string>(timeSpan, new DeepConvertSettings {
Format = "c"
}));
Assert.AreEqual("1:02.000", DeepConvert.ChangeType <string>(timeSpan, new DeepConvertSettings {
Format = @"m\:ss\.fff"
}));
}
public void ChangeType_StringToChars()
{
string str = "Aöbc€";
var chars = DeepConvert.ChangeType <List <char> >(str);
Assert.AreEqual(5, chars.Count);
Assert.AreEqual('A', chars[0]);
Assert.AreEqual('ö', chars[1]);
Assert.AreEqual('b', chars[2]);
Assert.AreEqual('c', chars[3]);
Assert.AreEqual('€', chars[4]);
}
public void ChangeType_BytesToString()
{
byte[] bytes = new byte[] { /*A*/ 0x41, /*ö*/ 0xc3, 0xb6, /*b*/ 0x62, /*c*/ 0x63, /*€*/ 0xe2, 0x82, 0xac };
string str = DeepConvert.ChangeType <string>(bytes); // default UTF-8
Assert.AreEqual("Aöbc€", str);
bytes = new byte[] { /*A*/ 0x41, 0, /*ö*/ 0xf6, 0, /*b*/ 0x62, 0, /*c*/ 0x63, 0, /*€*/ 0xac, 0x20 };
str = DeepConvert.ChangeType <string>(bytes, new DeepConvertSettings {
Encoding = Encoding.Unicode
});
Assert.AreEqual("Aöbc€", str);
}
public void ChangeType_Boolean()
{
Assert.AreEqual(false, DeepConvert.ChangeType <bool>(0));
Assert.AreEqual(true, DeepConvert.ChangeType <bool>(1));
Assert.AreEqual(true, DeepConvert.ChangeType <bool>(1.2));
Assert.AreEqual(false, DeepConvert.ChangeType <bool>("false"));
Assert.AreEqual(false, DeepConvert.ChangeType <bool>("no"));
Assert.AreEqual(false, DeepConvert.ChangeType <bool>("off"));
Assert.AreEqual(false, DeepConvert.ChangeType <bool>("nein"));
Assert.AreEqual(false, DeepConvert.ChangeType <bool>(""));
Assert.AreEqual(true, DeepConvert.ChangeType <bool>("true"));
Assert.AreEqual(true, DeepConvert.ChangeType <bool>("123"));
Assert.AreEqual(true, DeepConvert.ChangeType <bool>("abc"));
}
public void ChangeType_CharsToString()
{
char[] chars = new char[] { 'A', 'ö', 'b', 'c', '€' };
string str = DeepConvert.ChangeType <string>(chars);
Assert.AreEqual("Aöbc€", str);
int[] numbers = new int[] { 0x41, 0xf6, 0x62, 0x63, 0x20ac };
str = DeepConvert.ChangeType <string>(numbers);
Assert.AreEqual("Aöbc€", str);
object[] mixed = new object[] { "A", 'ö', 0x62, "c", "€" }; // numeric strings not supported, must be single characters
str = DeepConvert.ChangeType <string>(mixed);
Assert.AreEqual("Aöbc€", str);
}
public void ToDateTime_NoSeparators()
{
var date = DeepConvert.ChangeType <DateTime>(
"20100101000003",
new DeepConvertSettings
{
Provider = CultureInfo.InvariantCulture,
Format = "yyyyMMddHHmmss",
DateNumericKind = DateNumericKind.None,
DateTimeStyles = DateTimeStyles.None
});
Assert.AreEqual(typeof(DateTime), date.GetType());
Assert.AreEqual(new DateTime(2010, 1, 1, 0, 0, 3), date);
Assert.AreEqual(DateTimeKind.Unspecified, date.Kind);
}
public void ChangeType_Exponential()
{
var ics = new DeepConvertSettings
{
Provider = CultureInfo.InvariantCulture
};
var decs = new DeepConvertSettings
{
Provider = new CultureInfo("de-DE")
};
Assert.AreEqual(100, DeepConvert.ChangeType <float>("1.00E+02", ics));
Assert.AreEqual(100, DeepConvert.ChangeType <double>("1.00E+02", ics));
Assert.AreEqual(100, DeepConvert.ChangeType <decimal>("1.00E+02", ics));
Assert.AreEqual(100, DeepConvert.ChangeType <decimal>("1,00E+02", decs));
}
public void ConvertToDictionary()
{
var data = new DataClass
{
Flag = true,
Number = 42,
Text = "Hello",
Numbers = new[] { 1, 2, 4 },
Floats = new List <float> {
3.14f, 2.71f
},
Sub = new SubClass
{
IsInitialized = true,
Dict = new Dictionary <string, string>
{
["A"] = "1",
["B"] = "2",
["C"] = "3"
}
}
};
//var dict = DeepConvert.ConvertToDictionary(data);
var dict = DeepConvert.ChangeType <Dictionary <string, object> >(data);
Assert.AreEqual(true, dict["Flag"]);
Assert.AreEqual(42, dict["Number"]);
Assert.AreEqual("Hello", dict["Text"]);
Assert.AreEqual(3, ((int[])dict["Numbers"]).Length);
Assert.AreEqual(1, ((int[])dict["Numbers"])[0]);
Assert.AreEqual(2, ((int[])dict["Numbers"])[1]);
Assert.AreEqual(4, ((int[])dict["Numbers"])[2]);
Assert.AreEqual(2, ((List <float>)dict["Floats"]).Count);
Assert.AreEqual(3.14f, ((List <float>)dict["Floats"])[0]);
Assert.AreEqual(2.71f, ((List <float>)dict["Floats"])[1]);
var sub = (SubClass)dict["Sub"];
Assert.AreEqual(true, sub.IsInitialized);
Assert.AreEqual(3, sub.Dict.Count);
Assert.AreEqual("1", sub.Dict["A"]);
Assert.AreEqual("2", sub.Dict["B"]);
Assert.AreEqual("3", sub.Dict["C"]);
}
public void ConvertToObject()
{
var dict = new Dictionary <object, object>
{
["flag"] = true,
["number"] = 42,
["Text"] = "Hello",
["Numbers"] = new[] { 1.0, 2.0, 3.6 },
["Floats"] = new[] { "3.14", "2.71" },
["Sub"] = new Dictionary <string, object>
{
["IsInitialized"] = true,
["Dict"] = new Dictionary <string, object>
{
["A"] = 1,
["B"] = 2,
["C"] = 3
}
}
};
//var data = DeepConvert.ConvertToObject<DataClass>(dict, new DeepConvertSettings { Provider = CultureInfo.InvariantCulture });
var data = DeepConvert.ChangeType <DataClass>(dict, new DeepConvertSettings {
Provider = CultureInfo.InvariantCulture
});
Assert.AreEqual(true, data.Flag);
Assert.AreEqual(42, data.Number);
Assert.AreEqual("Hello", data.Text);
Assert.AreEqual(3, data.Numbers.Length);
Assert.AreEqual(1, data.Numbers[0]);
Assert.AreEqual(2, data.Numbers[1]);
Assert.AreEqual(4, data.Numbers[2]);
Assert.AreEqual(2, data.Floats.Count);
Assert.AreEqual(3.14f, data.Floats[0]);
Assert.AreEqual(2.71f, data.Floats[1]);
Assert.AreEqual(true, data.Sub.IsInitialized);
Assert.AreEqual(3, data.Sub.Dict.Count);
Assert.AreEqual("1", data.Sub.Dict["A"]);
Assert.AreEqual("2", data.Sub.Dict["B"]);
Assert.AreEqual("3", data.Sub.Dict["C"]);
}
public void ToDateTime_NestedStringFormatLocal()
{
var dateList = DeepConvert.ChangeType <List <DateTime> >(
new object[] { 10 * 86400, "18.02.03 04.05.06" },
new DeepConvertSettings
{
Format = "yy.MM.dd HH.mm.ss",
DateNumericKind = DateNumericKind.UnixSeconds,
DateTimeStyles = DateTimeStyles.AssumeLocal
});
Assert.AreEqual(typeof(List <DateTime>), dateList.GetType());
Assert.AreEqual(2, dateList.Count);
Assert.AreEqual(new DateTime(1970, 1, 11, 0, 0, 0), dateList[0]);
Assert.AreEqual(DateTimeKind.Utc, dateList[0].Kind);
Assert.AreEqual(new DateTime(2018, 2, 3, 4, 5, 6), dateList[1]);
Assert.AreEqual(DateTimeKind.Local, dateList[1].Kind);
}
public void ConvertBetweenObjects()
{
var data = new DataClass
{
Flag = true,
Number = 42,
Text = "Hello",
Numbers = new[] { 1, 2, 4 },
Floats = new List <float> {
3.14f, 2.71f
},
Sub = new SubClass
{
IsInitialized = true,
Dict = new Dictionary <string, string>
{
["A"] = "1",
["B"] = "2",
["C"] = "3"
}
}
};
var data2 = DeepConvert.ChangeType <DataClass2>(data);
Assert.AreEqual(1, data2.flag);
Assert.AreEqual(42, data2.number);
Assert.AreEqual("Hello", data2.Text);
Assert.AreEqual(true, data2.Add);
Assert.AreEqual(2, data2.Floats.Length);
Assert.AreEqual(3.14f, data2.Floats[0]);
Assert.AreEqual(2.71f, data2.Floats[1]);
Assert.AreEqual(1, data2.Sub.IsInitialized);
Assert.AreEqual(1, data2.Sub.Dict.A);
Assert.AreEqual(2, data2.Sub.Dict.B);
Assert.AreEqual(3, data2.Sub.Dict.C);
}
