NullableTypes/src/Tests NullableTimeSpanTest.cs,NONE,1.1 DBNullConvertTest.cs,1.3,1.4 NullConvertTes
Status: Inactive
Brought to you by:
lukadotnet
Menu
▾
▴
NullableTypes/src/Tests NullableTimeSpanTest.cs,NONE,1.1 DBNullConvertTest.cs,1.3,1.4 NullConvertTest.cs,1.8,1.9 Tests.csproj,1.27,1.28
|
From: Damien G. <dam...@us...> - 2005-10-06 16:05:50
|
Update of /cvsroot/nullabletypes/NullableTypes/src/Tests In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv1576/src/Tests Modified Files: DBNullConvertTest.cs NullConvertTest.cs Tests.csproj Added Files: NullableTimeSpanTest.cs Log Message: Implement NullableTimeSpan as per issue 1278920. Index: Tests.csproj =================================================================== RCS file: /cvsroot/nullabletypes/NullableTypes/src/Tests/Tests.csproj,v retrieving revision 1.27 retrieving revision 1.28 diff -C2 -d -r1.27 -r1.28 *** Tests.csproj 12 Feb 2005 03:44:34 -0000 1.27 --- Tests.csproj 6 Oct 2005 16:05:35 -0000 1.28 *************** *** 195,198 **** --- 195,203 ---- /> <File + RelPath = "NullableTimeSpanTest.cs" + SubType = "Code" + BuildAction = "Compile" + /> + <File RelPath = "NullableTypeExceptionTest.cs" SubType = "Code" Index: DBNullConvertTest.cs =================================================================== RCS file: /cvsroot/nullabletypes/NullableTypes/src/Tests/DBNullConvertTest.cs,v retrieving revision 1.3 retrieving revision 1.4 diff -C2 -d -r1.3 -r1.4 *** DBNullConvertTest.cs 23 Sep 2005 09:47:21 -0000 1.3 --- DBNullConvertTest.cs 6 Oct 2005 16:05:35 -0000 1.4 *************** *** 10,13 **** --- 10,14 ---- // 06-Oct-2003 Luca Upgrade Code upgrade: Replaced tabs with spaces // 05-Sep-2005 DamienG Upgrade Added tests for NullableGuid conversion + // 26-Sep-2005 DamienG Upgrade Added tests for NullableTimeSpan conversion // *************** *** 513,516 **** --- 514,554 ---- } + [nu.Test] + public void ToNullableTimeSpan() + { + _dbTable.Columns.Add("System.TimeSpan", typeof(sys.TimeSpan)); + + _dbTable.Rows.Add(new object[] {sys.TimeSpan.Zero}); + nua.AssertEquals( + "TestA#101", + NullableTimeSpan.Zero, + DBNullConvert.ToNullableTimeSpan(_dbTable.Rows[_dbTable.Rows.Count-1][0])); + + _dbTable.Rows.Add(new object[] {sys.DBNull.Value}); + nua.AssertEquals( + "TestA#102", + NullableTimeSpan.Null, + DBNullConvert.ToNullableTimeSpan(_dbTable.Rows[_dbTable.Rows.Count-1][0])); + + _dbTable.Rows.Add(new object[] {null}); + nua.AssertEquals( + "TestA#103", + NullableTimeSpan.Null, + DBNullConvert.ToNullableTimeSpan(_dbTable.Rows[_dbTable.Rows.Count-1][0])); + } + + + [nu.Test, nu.ExpectedException(typeof(sys.FormatException))] + public void ToNullableTimeSpanInvalidCastException() + { + DBNullConvert.ToNullableTimeSpan("invalid"); + } + + + [nu.Test, nu.ExpectedException(typeof(sys.ArgumentNullException))] + public void ToNullableTimeSpanArgumentNullException() + { + DBNullConvert.ToNullableTimeSpan(null); + } #endregion // DbValue to NullableTypes Tests - A# *************** *** 669,672 **** --- 707,723 ---- } + [nu.Test] + public void FromNullableTimeSpan() + { + nua.AssertEquals("TestB#091", + sys.DBNull.Value, + DBNullConvert.From(NullableString.Null)); + nua.AssertEquals("TestB#092", + System.TimeSpan.Zero, + DBNullConvert.From(NullableTimeSpan.Zero)); + nua.AssertEquals("TestB#093", + "4D38949B-1749-4496-9FD6-B3DA1275708C", + DBNullConvert.From(new NullableString("4D38949B-1749-4496-9FD6-B3DA1275708C"))); + } #endregion // DbValue from NullableTypes Tests - B# Index: NullConvertTest.cs =================================================================== RCS file: /cvsroot/nullabletypes/NullableTypes/src/Tests/NullConvertTest.cs,v retrieving revision 1.8 retrieving revision 1.9 diff -C2 -d -r1.8 -r1.9 *** NullConvertTest.cs 7 Oct 2003 20:32:21 -0000 1.8 --- NullConvertTest.cs 6 Oct 2005 16:05:35 -0000 1.9 *************** *** 445,449 **** NullConvert.ToNullableDateTime("9" + sys.DateTime.MaxValue.ToString("yyyy-MMM-dd"), string.Empty); } ! #endregion // Non nullable built-in types to NullableTypes #region NullableTypes to non nullable built-in types - B# --- 445,459 ---- NullConvert.ToNullableDateTime("9" + sys.DateTime.MaxValue.ToString("yyyy-MMM-dd"), string.Empty); } ! ! [nu.Test] ! public void ToNullableGuid() { ! sys.Guid conventionalNullGuid = sys.Guid.NewGuid(); ! nua.AssertEquals("TestA#210", NullableGuid.Null, NullConvert.ToNullableGuid(conventionalNullGuid, conventionalNullGuid)); ! ! sys.Guid conventionalGuid = sys.Guid.NewGuid(); ! nua.AssertEquals("TestA#211", new NullableGuid(conventionalGuid).Value, NullConvert.ToNullableGuid(conventionalGuid, conventionalNullGuid)); ! } ! ! #endregion // Non nullable built-in types to NullableTypes #region NullableTypes to non nullable built-in types - B# *************** *** 584,587 **** --- 594,607 ---- } + [nu.Test] + public void FromNullableGuid() { + sys.Guid testGuid = sys.Guid.NewGuid(); + + nua.AssertEquals("TestB#097", sys.Guid.Empty, NullConvert.From(NullableGuid.Null, sys.Guid.Empty)); + nua.AssertEquals("TestB#098", null, NullConvert.From(NullableGuid.Null, null, "")); + nua.AssertEquals("TestB#099", sys.Guid.Empty, NullConvert.From(NullableGuid.Empty, testGuid)); + nua.AssertEquals("TestB#100", testGuid, NullConvert.From(testGuid, null, "")); + } + #endregion // NullableTypes to non nullable built-in types --- NEW FILE: NullableTimeSpanTest.cs --- // // NullableTypes.Tests.NullableTimeSpanTest // // Authors: Luca Minudel (luk...@us...) // Damien Guard (dam...@us...) // // Date Author Changes Reasons // 29-Sep-2005 DamienG Create // namespace NullableTypes.Tests { using nu = NUnit.Framework; using nua = NUnit.Framework.Assertion; using sys = System; using sysXml = System.Xml; using sysXmlScm = System.Xml.Schema; [nu.TestFixture] public class NullableTimeSpanTest { NullableTimeSpan _pos; NullableTimeSpan _bigPos; NullableTimeSpan _neg; NullableTimeSpan _bigNeg; NullableTimeSpan _zero; NullableTimeSpan _null; NullableTimeSpan _min; NullableTimeSpan _max; [nu.SetUp] public void SetUp() { _pos = new NullableTimeSpan(857423345343); _bigPos = _pos + _pos; _neg = new NullableTimeSpan(-3223422343234); _bigNeg = _neg + _neg; _zero = new NullableTimeSpan(0); _null = NullableTimeSpan.Null; _min = NullableTimeSpan.MinValue; _max = NullableTimeSpan.MaxValue; } #region Field Tests - A# [nu.Test] public void FieldMax() { nua.AssertEquals("TestA#01", sys.TimeSpan.MaxValue, NullableTimeSpan.MaxValue.Value); } [nu.Test] public void FieldMin() { nua.AssertEquals("TestA#02", sys.TimeSpan.MinValue, NullableTimeSpan.MinValue.Value); } [nu.Test] public void NullField() { nua.Assert("TestA#03", NullableTimeSpan.Null.IsNull); } [nu.Test] public void ZeroField() { nua.AssertEquals("TestA#04", new sys.TimeSpan(0), NullableTimeSpan.Zero.Value); nua.AssertEquals("TestA#05", _zero.Value, NullableTimeSpan.Zero.Value); } #endregion // Field Tests - A# #region Constructor Tests - B# [nu.Test] public void Create() { sys.TimeSpan createFromTimeSpan = new System.TimeSpan(5, 6, 7, 8); NullableTimeSpan createdFromTimeSpan = new NullableTimeSpan(createFromTimeSpan); nua.AssertEquals("TestB#03", createFromTimeSpan, createdFromTimeSpan.Value); // TODO } #endregion // Constructor Tests - B# #region INullable Tests - C# public void IsNullProperty() { nua.Assert ("TestC#01", _null.IsNull); nua.Assert ("TestC#02", !_pos.IsNull); } #endregion // INullable Tests - C# #region IComparable - Ordering Tests - D# [nu.Test] public void Compare() { nua.Assert("TestD#01", (((sys.IComparable)_pos).CompareTo(_null) > 0)); nua.Assert("TestD#02", (((sys.IComparable)_pos).CompareTo(_neg) > 0)); nua.Assert("TestD#03", (((sys.IComparable)_pos).CompareTo(_bigPos) < 0)); nua.Assert("TestD#04", (((sys.IComparable)_pos).CompareTo(_pos) == 0)); nua.Assert("TestD#05", (((sys.IComparable)_null).CompareTo(_pos) < 0)); nua.Assert("TestD#06", (((sys.IComparable)_null).CompareTo(_neg) < 0)); nua.Assert("TestD#07", (((sys.IComparable)_null).CompareTo(NullableTimeSpan.Null) == 0)); nua.Assert("TestD#08", (((sys.IComparable)_neg).CompareTo(_null) > 0)); nua.Assert("TestD#09", (((sys.IComparable)_neg).CompareTo(_zero) < 0)); nua.Assert("TestD#11", (((sys.IComparable)_neg).CompareTo(_bigNeg) > 0)); nua.Assert("TestD#12", (((sys.IComparable)_neg).CompareTo(_neg) == 0)); } [nu.Test] [nu.ExpectedException(typeof(sys.ArgumentException))] public void CompareToWrongType() { ((sys.IComparable)_null).CompareTo(1); } #endregion // IComparable - Ordering Tests - D# #region Property Tests - E# // Value property [nu.Test] public void ValueProperty() { NullableTimeSpan maxTimeSpan = new NullableTimeSpan(sys.TimeSpan.MaxValue); nua.AssertEquals("TestE#01", sys.TimeSpan.MaxValue, maxTimeSpan.Value); NullableTimeSpan minTimeSpan = new NullableTimeSpan(sys.TimeSpan.MinValue); nua.AssertEquals("TestE#02", sys.TimeSpan.MinValue, minTimeSpan.Value); long i = 8276340; nua.AssertEquals("TestE#03", new sys.TimeSpan(i), new NullableTimeSpan(i).Value); } [nu.Test] [nu.ExpectedException(typeof(NullableTypes.NullableNullValueException))] public void ValuePropertyNull() { sys.TimeSpan iVal = _null.Value; } #endregion // Property Tests - E# #region Equivalence Tests - F# [nu.Test] public void StaticEqualsAndEqualityOperator() { // Case 1: either is NullableTimeSpan.Null nua.AssertEquals("TestF#01", NullableBoolean.Null, _null == _zero); nua.AssertEquals("TestF#02", NullableBoolean.Null, NullableTimeSpan.Equals(_neg, _null)); nua.AssertEquals("TestF#03", NullableBoolean.Null, NullableTimeSpan.NotEquals(_neg, _null)); // Case 2: both are NullableTimeSpan.Null nua.AssertEquals("TestF#04", NullableBoolean.Null, _null == NullableTimeSpan.Null); nua.AssertEquals("TestF#05", NullableBoolean.Null, NullableTimeSpan.Equals(NullableTimeSpan.Null, _null)); nua.AssertEquals("TestF#06", NullableBoolean.Null, NullableTimeSpan.NotEquals(NullableTimeSpan.Null, _null)); // Case 3: both are equal NullableTimeSpan x = _pos; nua.AssertEquals ("TestF#07", NullableBoolean.True, x == _pos); nua.AssertEquals ("TestF#08", NullableBoolean.True, NullableTimeSpan.Equals(_pos, x)); nua.AssertEquals ("TestF#09", NullableBoolean.False, NullableTimeSpan.NotEquals(_pos, x)); // Case 4: inequality nua.AssertEquals ("TestF#10", NullableBoolean.False, _zero == _neg); nua.AssertEquals ("TestF#11", NullableBoolean.False, NullableTimeSpan.Equals(_pos, _neg)); nua.AssertEquals ("TestF#12", NullableBoolean.True, NullableTimeSpan.NotEquals(_pos, _neg)); } [nu.Test] public void Equals() { // Case 1: either is NullableTimeSpan.Null nua.Assert("TestF#101", !_null.Equals(_zero)); nua.Assert("TestF#102", !_neg.Equals(_null)); // Case 2: both are NullableTimeSpan.Null nua.Assert("TestF#103", _null.Equals(NullableTimeSpan.Null)); nua.Assert("TestF#104", NullableTimeSpan.Null.Equals(_null)); // Case 3: both are equal NullableTimeSpan x = _pos; nua.Assert("TestF#105", x.Equals(_pos)); nua.Assert("TestF#106", _pos.Equals(x)); // Case 4: inequality nua.Assert("TestF#107", !_zero.Equals(_neg)); nua.Assert("TestF#108", !_pos.Equals(_neg)); } #endregion // Equivalence Tests - F# #region Method Tests - G# [nu.Test] public void Add() { long ix = -97643554; long iy = 20; NullableTimeSpan x = new NullableTimeSpan(ix); NullableTimeSpan y = new NullableTimeSpan(iy);; nua.AssertEquals("TestG#01", new sys.TimeSpan(ix + iy), NullableTimeSpan.Add(x,y).Value); } [nu.Test] public void GreaterThan() { long ix = -9537095; long iy = 2143; NullableTimeSpan x = new NullableTimeSpan(ix); NullableTimeSpan y = new NullableTimeSpan(iy); nua.AssertEquals ("TestG#40", ix > iy, NullableTimeSpan.GreaterThan(x,y).Value); } [nu.Test] public void GreaterThanOrEquals() { long ix = -954537095; long iy = 143; NullableTimeSpan x = new NullableTimeSpan(ix); NullableTimeSpan y = new NullableTimeSpan(iy); nua.AssertEquals ("TestG#51", ix >= iy, NullableTimeSpan.GreaterThanOrEqual(x,y).Value); nua.AssertEquals ("TestG#52", ix >= ix, NullableTimeSpan.GreaterThanOrEqual(x,x).Value); } [nu.Test] public void LessThan() { long ix = 8450; long iy = 6797346; NullableTimeSpan x = new NullableTimeSpan(ix); NullableTimeSpan y = new NullableTimeSpan(iy); nua.AssertEquals ("TestG#60", ix < iy, NullableTimeSpan.LessThan(x,y).Value); } [nu.Test] public void LessThanOrEquals() { long ix = 413236524; long iy = 143; NullableTimeSpan x = new NullableTimeSpan(ix); NullableTimeSpan y = new NullableTimeSpan(iy); nua.AssertEquals ("TestG#71", ix <= iy, NullableTimeSpan.LessThanOrEqual(x,y).Value); nua.AssertEquals ("TestG#72", ix <= ix, NullableTimeSpan.LessThanOrEqual(x,x).Value); } [nu.Test] public void Parse() { sys.TimeSpan ts = new sys.TimeSpan(-5,7,22,11,14); nua.AssertEquals ("TestG#130", ts, NullableTimeSpan.Parse(ts.ToString()).Value); } [nu.Test, nu.ExpectedException(typeof(sys.ArgumentNullException))] public void ParseArgumentNullException() { string sx = null; NullableTimeSpan.Parse(sx); } [nu.Test, nu.ExpectedException(typeof(sys.FormatException))] public void ParseFormatException() { string sx = "409'85"; NullableTimeSpan.Parse(sx); } [nu.Test, nu.ExpectedException(typeof(sys.OverflowException))] public void ParseOverflowException() { string sx = (long.MaxValue + 1M).ToString(); NullableTimeSpan.Parse(sx); } #endregion // Method Tests - G# #region Operator Tests - H# [nu.Test] public void AddOperator() { long ix = 23522342343; long iy = -122343; NullableTimeSpan nx = new NullableTimeSpan(ix); NullableTimeSpan ny = new NullableTimeSpan(iy); // Add nullable ints nua.AssertEquals("TestH#01", new sys.TimeSpan(ix + iy), (nx + ny).Value); nua.AssertEquals("TestH#02", new sys.TimeSpan(ix), (nx + _zero).Value); // Add Nulls nua.Assert("TestH#03", (nx + _null).IsNull); nua.Assert("TestH#04", (_null + ny).IsNull); nua.Assert("TestH#05", (_null + NullableTimeSpan.Null).IsNull); } [nu.Test, nu.ExpectedException(typeof(sys.OverflowException))] public void AddOperatorOverflow() { long ix = long.MaxValue; long iy = 1; NullableTimeSpan nx = new NullableTimeSpan(ix); NullableTimeSpan ny = new NullableTimeSpan(iy); NullableTimeSpan nz = nx + ny; } [nu.Test] public void GreaterThanOperator() { // GreaterThan nulls nua.Assert("TestH#51", (_pos > _null).IsNull); nua.Assert("TestH#52", (_null > _zero).IsNull); nua.Assert("TestH#53", (_null > _neg).IsNull); nua.Assert("TestH#54", (_null > NullableTimeSpan.Null).IsNull); // GreaterThan nullable ints nua.Assert("TestH#55", (_pos > _neg).IsTrue); nua.Assert("TestH#56", (_pos > _bigPos).IsFalse); nua.Assert("TestH#57", (_pos > _pos).IsFalse); nua.Assert("TestH#59", (_neg > _zero).IsFalse); nua.Assert("TestH#60", (_neg > _bigNeg).IsTrue); nua.Assert("TestH#61", (_neg > _neg).IsFalse); // GreaterThan ints nua.Assert("TestH#62", (_pos > _neg.Value).IsTrue); nua.Assert("TestH#63", (_pos > _bigPos.Value).IsFalse); nua.Assert("TestH#64", (_pos > _pos.Value).IsFalse); nua.Assert("TestH#65", (_neg > _zero.Value).IsFalse); nua.Assert("TestH#66", (_neg > _bigNeg.Value).IsTrue); nua.Assert("TestH#67", (_neg > _neg.Value).IsFalse); } [nu.Test] public void GreaterThanOrEqualsOperator() { // GreaterThanOrEquals nulls nua.Assert("TestH#71", (_pos >= _null).IsNull); nua.Assert("TestH#72", (_null >= _zero).IsNull); nua.Assert("TestH#73", (_null >= _neg).IsNull); nua.Assert("TestH#74", (_null >= NullableTimeSpan.Null).IsNull); // GreaterThanOrEquals nullable ints nua.Assert("TestH#75", (_pos >= _neg).IsTrue); nua.Assert("TestH#76", (_pos >= _bigPos).IsFalse); nua.Assert("TestH#77", (_pos >= _pos).IsTrue); nua.Assert("TestH#79", (_neg >= _zero).IsFalse); nua.Assert("TestH#80", (_neg >= _bigNeg).IsTrue); nua.Assert("TestH#81", (_neg >= _neg).IsTrue); // GreaterThanOrEquals ints nua.Assert("TestH#82", (_pos >= _neg.Value).IsTrue); nua.Assert("TestH#83", (_pos >= _bigPos.Value).IsFalse); nua.Assert("TestH#84", (_pos >= _pos.Value).IsTrue); nua.Assert("TestH#85", (_neg >= _zero.Value).IsFalse); nua.Assert("TestH#86", (_neg >= _bigNeg.Value).IsTrue); nua.Assert("TestH#87", (_neg >= _neg.Value).IsTrue); } [nu.Test] public void LessThanOperator() { // LessThan nulls nua.Assert("TestH#91", (_pos < _null).IsNull); nua.Assert("TestH#92", (_null < _zero).IsNull); nua.Assert("TestH#93", (_null < _neg).IsNull); nua.Assert("TestH#94", (_null < NullableTimeSpan.Null).IsNull); // LessThan nullable ints nua.Assert("TestH#95", (_pos < _neg).IsFalse); nua.Assert("TestH#96", (_pos < _bigPos).IsTrue); nua.Assert("TestH#97", (_pos < _pos).IsFalse); nua.Assert("TestH#99", (_neg < _zero).IsTrue); nua.Assert("TestH#100", (_neg < _bigNeg).IsFalse); nua.Assert("TestH#101", (_neg < _neg).IsFalse); // LessThan ints nua.Assert("TestH#102", (_pos < _neg.Value).IsFalse); nua.Assert("TestH#103", (_pos < _bigPos.Value).IsTrue); nua.Assert("TestH#104", (_pos < _pos.Value).IsFalse); nua.Assert("TestH#105", (_neg < _zero.Value).IsTrue); nua.Assert("TestH#106", (_neg < _bigNeg.Value).IsFalse); nua.Assert("TestH#107", (_neg < _neg.Value).IsFalse); } [nu.Test] public void LessThanOrEqualsOperator() { // LessThanOrEquals nulls nua.Assert("TestH#111", (_pos <= _null).IsNull); nua.Assert("TestH#112", (_null <= _zero).IsNull); nua.Assert("TestH#113", (_null <= _neg).IsNull); nua.Assert("TestH#114", (_null <= NullableTimeSpan.Null).IsNull); // LessThanOrEquals nullable ints nua.Assert("TestH#115", (_pos <= _neg).IsFalse); nua.Assert("TestH#116", (_pos <= _bigPos).IsTrue); nua.Assert("TestH#117", (_pos <= _pos).IsTrue); nua.Assert("TestH#119", (_neg <= _zero).IsTrue); nua.Assert("TestH#120", (_neg <= _bigNeg).IsFalse); nua.Assert("TestH#121", (_neg <= _neg).IsTrue); // LessThanOrEquals ints nua.Assert("TestH#122", (_pos <= _neg.Value).IsFalse); nua.Assert("TestH#123", (_pos <= _bigPos.Value).IsTrue); nua.Assert("TestH#124", (_pos <= _pos.Value).IsTrue); nua.Assert("TestH#125", (_neg <= _zero.Value).IsTrue); nua.Assert("TestH#126", (_neg <= _bigNeg.Value).IsFalse); nua.Assert("TestH#127", (_neg <= _neg.Value).IsTrue); } [nu.Test] public void SubtractionOperator() { sys.TimeSpan ix = new sys.TimeSpan(985); sys.TimeSpan iy = new sys.TimeSpan(-4534); NullableTimeSpan nx = new NullableTimeSpan(ix); NullableTimeSpan ny = new NullableTimeSpan(iy); // Subtraction nullable ints nua.AssertEquals("TestH#161", (ix - iy), (nx - ny).Value); nua.AssertEquals("TestH#162", ix, (nx - _zero).Value); // Subtraction Nulls nua.Assert("TestH#163", (nx - _null).IsNull); nua.Assert("TestH#164", (_null - ny).IsNull); nua.Assert("TestH#165", (_null - NullableTimeSpan.Null).IsNull); } [nu.Test, nu.ExpectedException(typeof(sys.OverflowException))] public void SubtractionOperatorOverflow() { NullableTimeSpan nz = NullableTimeSpan.MinValue - new NullableTimeSpan(1); } #endregion // Operator Tests - H# #region Conversion Operator Tests - I# [nu.Test] public void NullableStringConversionOperator() { nua.AssertEquals ("TestI#71", NullableTimeSpan.Null, (NullableTimeSpan)NullableString.Null); sys.TimeSpan ix = new sys.TimeSpan(95795); NullableString nx = new NullableString(ix.ToString()); nua.AssertEquals("TestI#72", ix, ((NullableTimeSpan)nx).Value); } [nu.Test, nu.ExpectedException(typeof(sys.OverflowException))] public void NullableStringConversionOperatorOverflowException() { NullableString nx = new NullableString((long.MaxValue + 1M).ToString()); NullableTimeSpan ny = (NullableTimeSpan)nx; } #endregion // Conversion Operator Tests - I# #region Conversion Tests - J# [nu.Test] public void ToNullableString() { sys.TimeSpan i = new sys.TimeSpan(14,07,59,11,12); NullableTimeSpan n = new NullableTimeSpan(i); nua.AssertEquals("TestJ#81", NullableString.Null, _null.ToNullableString()); nua.AssertEquals("TestJ#82", i.ToString(), n.ToNullableString().Value); nua.AssertEquals("TestJ#83", new NullableString(i.ToString()), n.ToNullableString()); } [nu.Test] public void ToStringTest() { sys.TimeSpan i = new sys.TimeSpan(12,4,234,6,999); nua.AssertEquals("TestJ#91", "Null", _null.ToString()); nua.AssertEquals("TestJ#92", i.ToString(), new NullableTimeSpan(i).ToString()); } #endregion // Conversion Tests - J# #region Serialization - K# [nu.Test] public void SerializableAttribute() { NullableTimeSpan serializedDeserialized; serializedDeserialized = SerializeDeserialize(_null); nua.Assert("TestK#01", serializedDeserialized.IsNull); nua.Assert("TestK#02", _null.Equals(serializedDeserialized)); serializedDeserialized = SerializeDeserialize(_zero); nua.Assert("TestK#03", !serializedDeserialized.IsNull); nua.AssertEquals("TestK#04", _zero.Value, serializedDeserialized.Value); nua.Assert("TestK#05", _zero.Equals(serializedDeserialized)); serializedDeserialized = SerializeDeserialize(_pos); nua.Assert("TestK#06", !serializedDeserialized.IsNull); nua.AssertEquals("TestK#07", _pos.Value, serializedDeserialized.Value); nua.Assert("TestK#08", _pos.Equals(serializedDeserialized)); serializedDeserialized = SerializeDeserialize(_neg); nua.Assert("TestK#09", !serializedDeserialized.IsNull); nua.AssertEquals("TestK#10", _neg.Value, serializedDeserialized.Value); nua.Assert("TestK#11", _neg.Equals(serializedDeserialized)); serializedDeserialized = SerializeDeserialize(_min); nua.Assert("TestK#12", !serializedDeserialized.IsNull); nua.AssertEquals("TestK#13", _min.Value, serializedDeserialized.Value); nua.Assert("TestK#14", _min.Equals(serializedDeserialized)); serializedDeserialized = SerializeDeserialize(_max); nua.Assert("TestK#15", !serializedDeserialized.IsNull); nua.AssertEquals("TestK#16", _max.Value, serializedDeserialized.Value); nua.Assert("TestK#17", _max.Equals(serializedDeserialized)); } private NullableTimeSpan SerializeDeserialize(NullableTimeSpan x) { System.Runtime.Serialization.Formatters.Soap.SoapFormatter serializer = new System.Runtime.Serialization.Formatters.Soap.SoapFormatter(); using (sys.IO.MemoryStream stream = new sys.IO.MemoryStream()) { serializer.Serialize(stream, x); // sys.Text.Decoder d = sys.Text.Encoding.Default.GetDecoder(); // char[] output = new char[d.GetCharCount(stream.GetBuffer(), 0, (int)stream.Length)]; // d.GetChars(stream.GetBuffer(), 0, (int)stream.Length, output, 0); // sys.Console.WriteLine(new string(output)); stream.Seek(0, sys.IO.SeekOrigin.Begin); // Return stream to start NullableTimeSpan y = (NullableTimeSpan)serializer.Deserialize(stream); stream.Close(); return y; } } [nu.Test] public void XmlSerializable() { NullableTimeSpan xmlSerializedDeserialized; xmlSerializedDeserialized = XmlSerializeDeserialize(_null); nua.Assert("TestK#30", xmlSerializedDeserialized.IsNull); nua.Assert("TestK#31", _null.Equals(xmlSerializedDeserialized)); xmlSerializedDeserialized = XmlSerializeDeserialize(_zero); nua.Assert("TestK#32", !xmlSerializedDeserialized.IsNull); nua.AssertEquals("TestK#33", _zero.Value, xmlSerializedDeserialized.Value); nua.Assert("TestK#34", _zero.Equals(xmlSerializedDeserialized)); xmlSerializedDeserialized = XmlSerializeDeserialize(_pos); nua.Assert("TestK#35", !xmlSerializedDeserialized.IsNull); nua.AssertEquals("TestK#36", _pos.Value, xmlSerializedDeserialized.Value); nua.Assert("TestK#37", _pos.Equals(xmlSerializedDeserialized)); xmlSerializedDeserialized = XmlSerializeDeserialize(_neg); nua.Assert("TestK#38", !xmlSerializedDeserialized.IsNull); nua.AssertEquals("TestK#39", _neg.Value, xmlSerializedDeserialized.Value); nua.Assert("TestK#40", _neg.Equals(xmlSerializedDeserialized)); xmlSerializedDeserialized = XmlSerializeDeserialize(_max); nua.Assert("TestK#41", !xmlSerializedDeserialized.IsNull); nua.AssertEquals("TestK#42", _max.Value, xmlSerializedDeserialized.Value); nua.Assert("TestK#43", _max.Equals(xmlSerializedDeserialized)); xmlSerializedDeserialized = XmlSerializeDeserialize(_min); nua.Assert("TestK#44", !xmlSerializedDeserialized.IsNull); nua.AssertEquals("TestK#45", _min.Value, xmlSerializedDeserialized.Value); nua.Assert("TestK#46", _min.Equals(xmlSerializedDeserialized)); } private NullableTimeSpan XmlSerializeDeserialize(NullableTimeSpan x) { System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(typeof(NullableTimeSpan)); using (sys.IO.MemoryStream stream = new sys.IO.MemoryStream()) { serializer.Serialize(stream, x); // sys.Text.Decoder d = sys.Text.Encoding.Default.GetDecoder(); // char[] output = new char[d.GetCharCount(stream.GetBuffer(), 0, (int)stream.Length)]; // d.GetChars(stream.GetBuffer(), 0, (int)stream.Length, output, 0); // sys.Console.WriteLine(new string(output)); stream.Seek(0, sys.IO.SeekOrigin.Begin); // Return stream to start NullableTimeSpan y = (NullableTimeSpan)serializer.Deserialize(stream); stream.Close(); return y; } } [nu.Test] public void XmlSerializableEmptyElementNil() { //<?xml version="1.0"?> //<NullableTimeSpan xsi:nil="true" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"></NullableTimeSpan> System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(typeof(NullableTimeSpan)); using (sys.IO.MemoryStream baseStream = new sys.IO.MemoryStream()) { using (sys.IO.StreamWriter stream = new System.IO.StreamWriter(baseStream)) { stream.WriteLine("<?xml version=\"1.0\"?>"); stream.WriteLine("<NullableTimeSpan xsi:nil=\"true\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"></NullableTimeSpan>"); stream.Flush(); // baseStream.Position = 0; // sys.IO.StreamReader streamReader = new System.IO.StreamReader(baseStream); // sys.Console.WriteLine(streamReader.ReadToEnd()); baseStream.Position = 0; // Return stream to start NullableTimeSpan y = (NullableTimeSpan)serializer.Deserialize(baseStream); nua.Assert(y.IsNull); baseStream.Close(); stream.Close(); } } } [nu.Test] public void XmlSerializableSchema() { sysXmlScm.XmlSchema xsd = ((sysXml.Serialization.IXmlSerializable)NullableTimeSpan.Null).GetSchema(); xsd.Compile(new sysXmlScm.ValidationEventHandler(ValidationCallBack)); ValidateXmlAgainstXmlSchema(xsd, _null); ValidateXmlAgainstXmlSchema(xsd, _min); ValidateXmlAgainstXmlSchema(xsd, _max); } private void ValidateXmlAgainstXmlSchema(sysXmlScm.XmlSchema xsd, NullableTimeSpan x) { sysXml.Serialization.XmlSerializer serializer = new sysXml.Serialization.XmlSerializer(typeof(NullableTimeSpan)); sys.IO.MemoryStream stream = null; sys.Xml.XmlValidatingReader validator = null; try { // Get the serialized NullableTimeSpan instance stream = new sys.IO.MemoryStream(); serializer.Serialize(stream, x); stream.Seek(0, sys.IO.SeekOrigin.Begin); // Return stream to start // Add the default namespace sysXml.XmlDocument doc = new sysXml.XmlDocument(); doc.Load(stream); sysXml.XmlAttribute defaultNs = doc.CreateAttribute("xmlns"); defaultNs.Value = "http://NullableTypes.SourceForge.Net/NullableTimeSpanXMLSchema"; doc.DocumentElement.Attributes.Append(defaultNs); // Validate validator = new sysXml.XmlValidatingReader(doc.OuterXml, sysXml.XmlNodeType.Document, null); validator.ValidationType = sys.Xml.ValidationType.Schema; validator.Schemas.Add(xsd); validator.ValidationEventHandler += new sys.Xml.Schema.ValidationEventHandler(ValidationCallBack); while(validator.Read()); } finally { if (validator != null) validator.Close(); if (stream != null) ((sys.IDisposable)stream).Dispose(); } } private static void ValidationCallBack(object sender, sysXmlScm.ValidationEventArgs args) { throw args.Exception; } #endregion //Serialization } } |
