public void TestDateTime() { Variant v1 = new Variant(DateTime.MaxValue); byte[] bytes1 = BinaryWriter.ToBytes(v1); Variant v2 = BinaryReader.FromBytes(bytes1); Assert.AreEqual(v1.As<DateTime>(), v2.As<DateTime>()); Variant v3 = new Variant(DateTime.MinValue); byte[] bytes2 = BinaryWriter.ToBytes(v3); Variant v4 = BinaryReader.FromBytes(bytes2); Assert.AreEqual(v3.As<DateTime>(), v4.As<DateTime>()); }
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 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 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 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 WriteText(Variant text) { switch(text.Type) { case VariantBase.EnumType.Any: case VariantBase.EnumType.String: { m_writer.WriteString(text.As<string>()); break; } case VariantBase.EnumType.Int32: case VariantBase.EnumType.UInt32: case VariantBase.EnumType.Int64: case VariantBase.EnumType.UInt64: case VariantBase.EnumType.Float: case VariantBase.EnumType.Double: case VariantBase.EnumType.Boolean: case VariantBase.EnumType.Date: case VariantBase.EnumType.Time: case VariantBase.EnumType.DateTime: { m_writer.WriteString(text.AnyCast().As<string>()); break; } default: throw new VariantException("Attempt to output non-primitive variant as text: " + text.Type); } }
void WriteComment(Variant comment) { m_writer.WriteComment(comment.As<string>()); }
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 TestParsing() { // Time Variant v1 = new Variant(Variant.EnumType.Any, "02:03:04.005"); Assert.AreEqual(new TimeSpan(0, 2, 3, 4, 5), v1.As<TimeSpan>()); Variant v2 = new Variant(Variant.EnumType.Any, "02:03:04"); Assert.AreEqual(new TimeSpan(2, 3, 4), v2.As<TimeSpan>()); // DateTime Variant v3 = new Variant(Variant.EnumType.Any, "2010-01-02T03:04:05.006"); Assert.AreEqual(new DateTime(2010, 1, 2, 3, 4, 5, 6), v3.As<DateTime>()); Variant v4 = new Variant(Variant.EnumType.Any, "2010-01-02T03:04:05"); Assert.AreEqual(new DateTime(2010, 1, 2, 3, 4, 5, 0), v4.As<DateTime>()); // Double Variant v5 = new Variant(Variant.EnumType.Any, "NaN"); Assert.IsTrue(double.IsNaN(v5.As<Double>())); Variant v6 = new Variant(Variant.EnumType.Any, "INF"); Assert.IsTrue(double.IsPositiveInfinity(v6.As<Double>())); Variant v7 = new Variant(Variant.EnumType.Any, "-INF"); Assert.IsTrue(double.IsNegativeInfinity(v7.As<Double>())); // String Variant v8 = new Variant(Variant.EnumType.Any, "value"); Assert.AreEqual("value", v8.As<string>()); }
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)); }
protected void WriteVariant(Variant v) { VariantBase.EnumType type = v.Type; Write((Int32)type); switch (type) { case VariantBase.EnumType.None: break; case VariantBase.EnumType.String: case VariantBase.EnumType.Any: Write(v.As<string>()); break; case VariantBase.EnumType.Float: Write(v.As<float>()); break; case VariantBase.EnumType.Double: Write(v.As<double>()); break; case VariantBase.EnumType.Int32: Write(v.As<Int32>()); break; case VariantBase.EnumType.UInt32: Write(v.As<UInt32>()); break; case VariantBase.EnumType.Int64: Write(v.As<Int64>()); break; case VariantBase.EnumType.UInt64: Write(v.As<UInt64>()); break; case VariantBase.EnumType.Boolean: Write(v.As<bool>()); break; case VariantBase.EnumType.Time: Write(v.As<TimeSpan>()); break; case VariantBase.EnumType.DateTime: Write(v.As<DateTime>()); break; case VariantBase.EnumType.List: case VariantBase.EnumType.Tuple: Write(v.Count); foreach (VariantItem item in v) { WriteVariant(item.Value); } break; case VariantBase.EnumType.Dictionary: case VariantBase.EnumType.Bag: Write(v.Count); foreach (VariantItem item in v) { Write(item.Key); WriteVariant(item.Value); } break; case VariantBase.EnumType.TimeSeries: Write(v.Count); foreach (VariantItem item in v) { Write(item.Time); WriteVariant(item.Value); } break; case VariantBase.EnumType.Object: IVariantObject o = v.AsObject(); Write(o.Class); Write(o.Version); WriteVariant(o.Deflate()); break; case VariantBase.EnumType.Exception: VariantExceptionInfo x = v.AsException(); Write(x.Class); Write(x.Message); Write(x.Source); Write(x.Stack); break; case VariantBase.EnumType.Buffer: Write(v.AsBuffer().Length); Write(v.AsBuffer(), true); break; case VariantBase.EnumType.DataTable: Write(v.AsDataTable()); break; case VariantBase.EnumType.Array: Write(v.AsArray()); break; default: throw new VariantException("Case exhaustion: " + type.ToString()); } }