public void TestDateTimeCoverter()
{
var errMessages = new List <string>();
var fn = new Action <DateTime, string, string>((inputValue, format, expectedDisplayValue) =>
{
var varInfo = new DateTimeDataValue(new DataValue(new Variant(inputValue)));
varInfo.FormatSelectedItem = format;
var convVal = varInfo.ConvertValue();
try
{
Assert.AreEqual(convVal, expectedDisplayValue);
}
catch (Exception e)
{
errMessages.Add(e.Message);
}
});
fn(DateTime.MinValue, FormatType.DATE_AND_TIME, "0001-01-01 00:00:00.000");
fn(DateTime.MaxValue, FormatType.DATE_AND_TIME, "9999-12-31 23:59:59.999");
if (errMessages.Count != 0)
{
var messages = "\n";
foreach (var msg in errMessages)
{
messages += string.Format(" - {0}\n", msg);
}
Assert.Fail(messages);
}
}
public void TestDateTimeBackCoverter()
{
var errMessages = new List <string>();
var fn = new Action <string, string, DateTime>((inputValue, format, expectedDisplayValue) =>
{
var varInfo = new DateTimeDataValue(new DataValue(new Variant((Int64)0)));
varInfo.FormatSelectedItem = format;
varInfo.ConvertValueBack(inputValue);
try
{
Assert.AreEqual(varInfo.GetRawValue(), expectedDisplayValue);
}
catch (Exception e)
{
errMessages.Add(e.Message);
}
});
fn("0001-01-01 00:00:00.000", FormatType.DATE_AND_TIME, DateTime.MinValue);
fn("9999-12-31 23:59:59.999", FormatType.DATE_AND_TIME, new DateTime(9999, 12, 31, 23, 59, 59, 999));
if (errMessages.Count != 0)
{
var messages = "\n";
foreach (var msg in errMessages)
{
messages += string.Format(" - {0}\n", msg);
}
Assert.Fail(messages);
}
}
private static object GetObject(DataNode root, Type baseType, Dictionary <Guid, Type> derivedTypes, object parent)
{
object ret = null;
if (typeof(DataNode).IsAssignableFrom(baseType))
{
ret = root.CloneNode();
}
else if (baseType == typeof(byte[]))
{
ret = root.ToArray();
}
else if (baseType == typeof(char[]))
{
ret = root.ToDataString().ToCharArray();
}
else if (baseType == typeof(string))
{
ret = root.ToDataString();
}
else if (typeof(IPrimitiveValue).IsAssignableFrom(baseType))
{
IPrimitiveValue prim = (IPrimitiveValue)Activator.CreateInstance(baseType);
DataValue value = root as DataValue;
if (value == null)
{
throw new ArgumentException(Properties.Resources.ObjectConverter_GetObjectPrimitive);
}
prim.Value = value.Value;
ret = prim;
}
else if (baseType == typeof(DateTime))
{
DateTimeDataValue value = root as DateTimeDataValue;
if (value == null)
{
throw new ArgumentException(Properties.Resources.ObjectConverter_GetObjectDateTime);
}
ret = value.Value;
}
else if (baseType == typeof(BigInteger))
{
BigIntegerDataValue value = root as BigIntegerDataValue;
if (value != null)
{
ret = value.Value;
}
else
{
ret = new BigInteger(root.ToArray());
}
}
else if (baseType.IsPrimitive)
{
DataValue value = root as DataValue;
if (value == null)
{
throw new ArgumentException(Properties.Resources.ObjectConverter_GetObjectPrimitive);
}
ret = Convert.ChangeType(value.Value, baseType);
}
else if (baseType.IsArray)
{
DataKey key = root as DataKey;
if (key == null)
{
throw new ArgumentException(Properties.Resources.ObjectConverter_GetObjectArray);
}
ret = GetArray(key, baseType.GetElementType(), derivedTypes, parent);
}
else if (baseType.IsEnum)
{
DataValue value = root as DataValue;
if (value != null)
{
Type valueType = value.Value.GetType();
if (valueType == typeof(string))
{
ret = Enum.Parse(baseType, value.Value.ToString());
}
else if (valueType == typeof(PortableEnum))
{
ret = Enum.ToObject(baseType, Convert.ChangeType(value.Value.Value, baseType.GetEnumUnderlyingType()));
}
else if (valueType.IsPrimitive)
{
ret = Enum.ToObject(baseType, Convert.ChangeType(value.Value, baseType.GetEnumUnderlyingType()));
}
else
{
throw new ArgumentException(Properties.Resources.ObjectConverter_GetObjectEnum);
}
}
}
else if (baseType == typeof(IPAddress))
{
ret = new IPAddress(root.ToArray());
}
else
{
try
{
Type createType = GetTypeFromNode(baseType, root, derivedTypes);
if (createType.IsAbstract)
{
throw new ArgumentException(String.Format(Properties.Resources.ObjectConverter_GetObjectAbstract, createType));
}
ret = Activator.CreateInstance(createType);
}
catch (MissingMethodException ex)
{
throw new ArgumentException(String.Format(Properties.Resources.ObjectConverter_GetObjectCouldntCreate, baseType), ex);
}
INodeInitializer converter = ret as INodeInitializer;
if (converter != null)
{
converter.FromNode(root);
}
else
{
DataKey key = root as DataKey;
if (key == null)
{
throw new ArgumentException(Properties.Resources.ObjectConverter_GetObjectComplex);
}
PopulateObject(key, ret, derivedTypes);
}
}
SetParent(ret, parent);
return(ret);
}
