public void TestDateTime()
{
DateTime arg = new DateTime(2010, 1, 2, 3, 4, 5, 6);
Variant v1 = new Variant(arg);
Assert.AreEqual(v1.Type, Variant.EnumType.DateTime);
Assert.IsTrue(v1.Is(Variant.EnumType.DateTime));
Assert.IsTrue(v1.Is<DateTime>());
Assert.AreEqual(v1.As<DateTime>(), arg);
Assert.AreEqual(Convert.ToDateTime(v1), arg);
Assert.AreEqual(v1.ToString(), "2010-01-02T03:04:05.006");
Variant v2 = new Variant(v1);
Assert.IsTrue(v1.Equals(v2));
}
public void TestTSConstruction()
{
Variant v = new Variant(Variant.EnumType.TimeSeries);
Assert.AreEqual(v.Type, Variant.EnumType.TimeSeries);
Assert.IsTrue(v.Is(Variant.EnumType.TimeSeries));
Assert.AreEqual(v.Count, 0);
Assert.IsTrue(v.Empty);
}
public void TestBoolean()
{
Variant vTrue = new Variant(true);
Assert.AreEqual(vTrue.Type, Variant.EnumType.Boolean);
Assert.IsTrue(vTrue.Is(Variant.EnumType.Boolean));
Assert.IsTrue(vTrue.Is<bool>());
Assert.IsTrue(vTrue.As<bool>());
Assert.IsTrue(Convert.ToBoolean(vTrue));
Assert.AreEqual(vTrue.ToString(), "true");
Variant vFalse = new Variant(false);
Assert.AreEqual(vFalse.Type, Variant.EnumType.Boolean);
Assert.IsTrue(vFalse.Is(Variant.EnumType.Boolean));
Assert.IsTrue(vFalse.Is<bool>());
Assert.IsFalse(vFalse.As<bool>());
Assert.IsFalse(Convert.ToBoolean(vFalse));
Assert.AreEqual(vFalse.ToString(), "false");
Variant v1 = new Variant(vTrue);
Assert.IsTrue(v1.Equals(vTrue));
Variant v2 = new Variant(vFalse);
Assert.IsTrue(v2.Equals(vFalse));
}
public void TestAny()
{
Variant v1 = new Variant(Variant.EnumType.Any, "1.0");
Assert.AreEqual(v1.Type, Variant.EnumType.Any);
Assert.IsTrue(v1.Is(Variant.EnumType.Any));
Assert.AreEqual(1.0, v1.As<double>());
Variant v2 = new Variant(v1);
Assert.IsTrue(v1.Equals(v2));
// Enumerating an Any variant with content should throw an exception
Assert.Throws<VariantException>(delegate { v1.GetEnumerator(); });
// We should be able to enumerate an Any variant with no content as this is a common occurance when reading untyped XML
Variant v3 = new Variant(Variant.EnumType.Any);
IEnumerator<VariantItem> enumerator = v3.GetEnumerator();
Assert.IsFalse(enumerator.MoveNext());
Assert.Throws<VariantException>(delegate { VariantItem item = enumerator.Current; });
}
public void TestBagConstruction()
{
Variant v = new Variant(Variant.EnumType.Bag);
Assert.AreEqual(v.Type, Variant.EnumType.Bag);
Assert.IsTrue(v.Is(Variant.EnumType.Bag));
Assert.AreEqual(v.Count, 0);
Assert.IsTrue(v.Empty);
}
public void TestConstruction()
{
System.Data.DataTable dt1 = new DataTable();
dt1.Columns.Add(new DataColumn("Double", typeof(double)));
dt1.Columns.Add(new DataColumn("String", typeof(string)));
DataRow dr = dt1.NewRow();
dr[0] = 1.0;
dr[1] = "value";
dt1.Rows.Add(dr);
Variant v1 = new Variant(dt1);
Assert.AreEqual(v1.Type, Variant.EnumType.DataTable);
Assert.IsTrue(v1.Is(Variant.EnumType.DataTable));
Assert.DoesNotThrow(delegate { v1.AsDataTable(); });
Assert.Throws<VariantException>(delegate { v1.As<int>(); });
}
void WriteInstruction(Variant instruction)
{
if (instruction.Is(VariantBase.EnumType.Mapping) && instruction.ContainsKey(XmlConst.Target) && instruction.ContainsKey(XmlConst.Data))
{
m_writer.WriteProcessingInstruction(instruction[XmlConst.Target].As<string>(), instruction[XmlConst.Data].As<string>());
}
else
{
throw new VariantException(string.Format("Expecting dictionary containing '{0}' and '{1}' for processing instruction", XmlConst.Target, XmlConst.Data));
}
}
void WriteDocument(Variant document)
{
if ((m_mode & XmlMode.NoHeader) == 0)
{
WriteHeader();
}
if ((m_mode & XmlMode.Preserve)!=0)
{
string rootName = "";
if (document.Is(VariantBase.EnumType.Mapping))
{
foreach (VariantItem item in document)
{
if (item.Key == XmlConst.Text)
{
throw new VariantException("Encountered text in document node");
}
else if (item.Key == XmlConst.Attributes)
{
throw new VariantException("Encountered attributes in document node");
}
else if (item.Key == XmlConst.Instruction)
{
WriteInstruction(item.Value);
}
else if (item.Key == XmlConst.Comment)
{
WriteComment(item.Value);
}
else
{
if (rootName.Length==0)
{
rootName = item.Key;
}
else
{
throw new VariantException(string.Format("Illegal element {0} encountered in document, expecting single element {1} at root", item.Key, rootName));
}
Push(rootName);
WriteElement(item.Value);
Pop();
}
}
}
else
{
throw new VariantException("Invalid document structure, root node must be a Dictionary or Bag");
}
}
else
{
Push();
WriteVariant(document);
Pop();
}
}
public void TestDouble()
{
Variant v1 = new Variant((double)5.0);
Assert.AreEqual(v1.Type, Variant.EnumType.Double);
Assert.IsTrue(v1.Is(Variant.EnumType.Double));
Assert.IsTrue(v1.Is<double>());
Assert.AreEqual(v1.As<double>(), 5.0);
Assert.AreEqual(Convert.ToDouble(v1), 5.0);
Assert.AreEqual(v1.ToString(), "5");
Variant vNaN = new Variant(double.NaN);
Assert.AreEqual(vNaN.ToString(), "NaN");
Variant vINF = new Variant(double.PositiveInfinity);
Assert.AreEqual(vINF.ToString(), "INF");
Variant vNEGINF = new Variant(double.NegativeInfinity);
Assert.AreEqual(vNEGINF.ToString(), "-INF");
Variant v2 = new Variant(v1);
Assert.IsTrue(v1.Equals(v2));
}
public void TestUInt64()
{
Variant v1 = new Variant((UInt64)4);
Assert.AreEqual(v1.Type, Variant.EnumType.UInt64);
Assert.IsTrue(v1.Is(Variant.EnumType.UInt64));
Assert.IsTrue(v1.Is<UInt64>());
Assert.AreEqual(v1.As<UInt64>(), 4);
Assert.AreEqual(Convert.ToUInt64(v1), 4);
Assert.AreEqual(v1.ToString(), "4");
Variant v2 = new Variant(v1);
Assert.IsTrue(v1.Equals(v2));
}
public void TestTime()
{
TimeSpan arg = new TimeSpan(0, 2, 3, 4, 5);
Variant v1 = new Variant(arg);
Assert.AreEqual(v1.Type, Variant.EnumType.Time);
Assert.IsTrue(v1.Is(Variant.EnumType.Time));
Assert.IsTrue(v1.Is<TimeSpan>());
Assert.AreEqual(v1.As<TimeSpan>(), arg);
Assert.AreEqual(v1.ToString(), "02:03:04.005");
Variant v2 = new Variant(v1);
Assert.IsTrue(v1.Equals(v2));
}
public void TestString()
{
Variant v1 = new Variant("test string");
Assert.AreEqual(v1.Type, Variant.EnumType.String);
Assert.IsTrue(v1.Is(Variant.EnumType.String));
Assert.IsTrue(v1.Is<string>());
Assert.AreEqual(v1.As<string>(), "test string");
Assert.AreEqual(Convert.ToString(v1), "test string");
Variant v2 = new Variant(v1);
Assert.IsTrue(v1.Equals(v2));
}
public void TestNone()
{
Variant v1 = new Variant();
Assert.AreEqual(v1.Type, Variant.EnumType.None);
Assert.IsTrue(v1.Is(Variant.EnumType.None));
Variant v2 = new Variant(Variant.EnumType.None);
Assert.AreEqual(v2.Type, Variant.EnumType.None);
Assert.IsTrue(v2.Is(Variant.EnumType.None));
Variant v3 = new Variant(v1);
Assert.IsTrue(v1.Equals(v3));
}
public void TestInt64()
{
Variant v1 = new Variant((Int64)3);
Assert.AreEqual(v1.Type, Variant.EnumType.Int64);
Assert.IsTrue(v1.Is(Variant.EnumType.Int64));
Assert.IsTrue(v1.Is<Int64>());
Assert.AreEqual(v1.As<Int64>(), 3);
Assert.AreEqual(Convert.ToInt64(v1), 3);
Assert.AreEqual(v1.ToString(), "3");
Variant v2 = new Variant(v1);
Assert.IsTrue(v1.Equals(v2));
}
public void TestInt32()
{
Variant v1 = new Variant((Int32)1);
Assert.AreEqual(v1.Type, Variant.EnumType.Int32);
Assert.IsTrue(v1.Is(Variant.EnumType.Int32));
Assert.IsTrue(v1.Is<Int32>());
Assert.AreEqual(v1.As<Int32>(), 1);
Assert.AreEqual(Convert.ToInt32(v1), 1);
Assert.AreEqual(v1.ToString(), "1");
Variant v2 = new Variant(v1);
Assert.IsTrue(v1.Equals(v2));
}
public void TestTupleConstruction()
{
Variant v = new Variant(Variant.EnumType.Tuple, 2);
Assert.AreEqual(v.Type, Variant.EnumType.Tuple);
Assert.IsTrue(v.Is(Variant.EnumType.Tuple));
Assert.AreEqual(v.Count, 2);
Assert.IsFalse(v.Empty);
}
