[Mono-devel-list] Upgrading of NUnit 1.x tests
Martin Willemoes Hansen
mwh at sysrq.dk
Mon Mar 10 15:43:00 EST 2003
On Mon, 2003-03-10 at 16:50, Martin Willemoes Hansen wrote:
> On Mon, 2003-03-10 at 16:40, Martin Willemoes Hansen wrote:
>
> > 2. I converted CollectionTest.cs is the modifications okay?
>
> Nice replying to myself, umh I see many of the method signatures in this
> class should have Test removed from it also the Clear method should be
> update a bit, but I can allways do that, now I just would like to know
> if the basic modifications are okay and ill do it for the rest of this
> assembly and post changes here for final aprovement.
Oh well converted all of the tests in the Microsoft.VisualBasic
assembly, okay to commit?
Should I also just remove AllTests.cs?
Microsoft.VisualBasic_test.build seems to use the old unit testing
framework, should it also be removed?
--
Martin Willemoes Hansen
--------------------------------------------------------
E-Mail mwh at sysrq.dk Website mwh.sysrq.dk
IRC MWH, freenode.net
--------------------------------------------------------
-------------- next part --------------
16,17c16,17
<
< public class CollectionTest : TestCase
---
> [TestFixture]
> public class CollectionTest
19,30c19,24
<
< public CollectionTest() : base ("Microsoft.VisualBasic.Collection") {}
< public CollectionTest(string name) : base(name) {}
<
< protected override void SetUp() {}
< protected override void TearDown() {}
<
< public static ITest Suite {
< get {
< return new TestSuite(typeof(CollectionTest));
< }
< }
---
>
> [SetUp]
> public void GetReady() {}
>
> [TearDown]
> public void Clean() {}
33c27,28
< public void TestNew ()
---
> [Test]
> public void New ()
39,40c34,35
< AssertNotNull("#N01", c);
< AssertEquals("#N02", 0, c.Count);
---
> Assertion.AssertNotNull("#N01", c);
> Assertion.AssertEquals("#N02", 0, c.Count);
44c39,40
< public void TestAddNoKey ()
---
> [Test]
> public void AddNoKey ()
54c50
< AssertEquals("#ANK01", 3, c.Count);
---
> Assertion.AssertEquals("#ANK01", 3, c.Count);
57c53
< AssertEquals("#ANK02", typeof(string), c[3]);
---
> Assertion.AssertEquals("#ANK02", typeof(string), c[3]);
62c58,59
< public void TestAddKey ()
---
> [Test]
> public void AddKey ()
73c70
< AssertEquals("#AK01", 4, c.Count);
---
> Assertion.AssertEquals("#AK01", 4, c.Count);
76,77c73,74
< AssertEquals("#AK02", "Baseball", c[1]);
< AssertEquals("#AK03", "Volleyball", c["Volley"]);
---
> Assertion.AssertEquals("#AK02", "Baseball", c[1]);
> Assertion.AssertEquals("#AK03", "Volleyball", c["Volley"]);
82c79,80
< public void TestAddBeforeNoKey ()
---
> [Test]
> public void AddBeforeNoKey ()
93c91
< AssertEquals("#ABNK01", 4, c.Count);
---
> Assertion.AssertEquals("#ABNK01", 4, c.Count);
96,98c94,96
< AssertEquals("#ABNK02", typeof(int), c[4]);
< AssertEquals("#ABNK03", typeof(double), c[1]);
< AssertEquals("#ABNK04", typeof(object), c[2]);
---
> Assertion.AssertEquals("#ABNK02", typeof(int), c[4]);
> Assertion.AssertEquals("#ABNK03", typeof(double), c[1]);
> Assertion.AssertEquals("#ABNK04", typeof(object), c[2]);
103c101,102
< public void TestAddBeforeKey ()
---
> [Test]
> public void AddBeforeKey ()
114,118c113,117
< AssertEquals("#ABK01", 4, c.Count);
< AssertEquals("#ABK02", "Basketball", c[1]);
< AssertEquals("#ABK03", "Baseball", c[4]);
< AssertEquals("#ABK04", "Volleyball", c["Volley"]);
< AssertEquals("#ABK05", "Football", c["Foot"]);
---
> Assertion.AssertEquals("#ABK01", 4, c.Count);
> Assertion.AssertEquals("#ABK02", "Basketball", c[1]);
> Assertion.AssertEquals("#ABK03", "Baseball", c[4]);
> Assertion.AssertEquals("#ABK04", "Volleyball", c["Volley"]);
> Assertion.AssertEquals("#ABK05", "Football", c["Foot"]);
123c122,123
< public void TestAddAfterNoKey ()
---
> [Test]
> public void AddAfterNoKey ()
134c134
< AssertEquals("#AANK01", 4, c.Count);
---
> Assertion.AssertEquals("#AANK01", 4, c.Count);
137,139c137,139
< AssertEquals("#AANK02", typeof(object), c[4]);
< AssertEquals("#AANK03", typeof(int), c[1]);
< AssertEquals("#AANK04", typeof(string), c[2]);
---
> Assertion.AssertEquals("#AANK02", typeof(object), c[4]);
> Assertion.AssertEquals("#AANK03", typeof(int), c[1]);
> Assertion.AssertEquals("#AANK04", typeof(string), c[2]);
144c144,145
< public void TestAddAfterKey ()
---
> [Test]
> public void AddAfterKey ()
155c156
< AssertEquals("#AAK01", 4, c.Count);
---
> Assertion.AssertEquals("#AAK01", 4, c.Count);
158,161c159,162
< AssertEquals("#AAK02", "Baseball", c[1]);
< AssertEquals("#AAK03", "Football", c[4]);
< AssertEquals("#AAK04", "Basketball", c["Basket"]);
< AssertEquals("#AAK05", "Volleyball", c["Volley"]);
---
> Assertion.AssertEquals("#AAK02", "Baseball", c[1]);
> Assertion.AssertEquals("#AAK03", "Football", c[4]);
> Assertion.AssertEquals("#AAK04", "Basketball", c["Basket"]);
> Assertion.AssertEquals("#AAK05", "Volleyball", c["Volley"]);
165c166,167
< public void TestGetEnumerator ()
---
> [Test]
> public void GetEnumerator ()
182c184
< AssertNotNull("#GE01", e);
---
> Assertion.AssertNotNull("#GE01", e);
185c187
< AssertEquals("#GE02." + i.ToString(), o[i], e.Current);
---
> Assertion.AssertEquals("#GE02." + i.ToString(), o[i], e.Current);
192c194
< AssertEquals("#GE03", o[0], e.Current);
---
> Assertion.AssertEquals("#GE03", o[0], e.Current);
197c199,200
< public void Testforeach ()
---
> [Test]
> public void Foreach ()
213c216
< AssertEquals("#fe01." + i.ToString(), o[i], item);
---
> Assertion.AssertEquals("#fe01." + i.ToString(), o[i], item);
220c223,224
< public void TestRemoveNoKey ()
---
> [Test]
> public void RemoveNoKey ()
231c235
< AssertEquals("#RNK01", 4, c.Count);
---
> Assertion.AssertEquals("#RNK01", 4, c.Count);
235c239
< AssertEquals("#RNK02", 3, c.Count);
---
> Assertion.AssertEquals("#RNK02", 3, c.Count);
238c242
< AssertEquals("#RNK03", typeof(object), c[3]);
---
> Assertion.AssertEquals("#RNK03", typeof(object), c[3]);
242,244c246,248
< AssertEquals("#RNK04", 2, c.Count);
< AssertEquals("#RNK05", typeof(double), c[1]);
< AssertEquals("#RNK06", typeof(object), c[2]);
---
> Assertion.AssertEquals("#RNK04", 2, c.Count);
> Assertion.AssertEquals("#RNK05", typeof(double), c[1]);
> Assertion.AssertEquals("#RNK06", typeof(object), c[2]);
248,249c252,253
< AssertEquals("#RNK07", 1, c.Count);
< AssertEquals("#RNK08", typeof(double), c[1]);
---
> Assertion.AssertEquals("#RNK07", 1, c.Count);
> Assertion.AssertEquals("#RNK08", typeof(double), c[1]);
253c257
< AssertEquals("#RNK09", 0, c.Count);
---
> Assertion.AssertEquals("#RNK09", 0, c.Count);
258c262,263
< public void TestRemoveKey ()
---
> [Test]
> public void RemoveKey ()
269c274
< AssertEquals("#RK01", 4, c.Count);
---
> Assertion.AssertEquals("#RK01", 4, c.Count);
273,274c278,279
< AssertEquals("#RK02", 3, c.Count);
< AssertEquals("#RK03", "Basketball", c["Basket"]);
---
> Assertion.AssertEquals("#RK02", 3, c.Count);
> Assertion.AssertEquals("#RK03", "Basketball", c["Basket"]);
277c282
< AssertEquals("#RK04", "Volleyball", c[3]);
---
> Assertion.AssertEquals("#RK04", "Volleyball", c[3]);
281,283c286,288
< AssertEquals("#RK05", 2, c.Count);
< AssertEquals("#RK06", "Basketball", c[1]);
< AssertEquals("#RK07", "Volleyball", c["Volley"]);
---
> Assertion.AssertEquals("#RK05", 2, c.Count);
> Assertion.AssertEquals("#RK06", "Basketball", c[1]);
> Assertion.AssertEquals("#RK07", "Volleyball", c["Volley"]);
287,289c292,294
< AssertEquals("#RK08", 1, c.Count);
< AssertEquals("#RK09", "Basketball", c[1]);
< AssertEquals("#RK10", "Basketball", c["Basket"]);
---
> Assertion.AssertEquals("#RK08", 1, c.Count);
> Assertion.AssertEquals("#RK09", "Basketball", c[1]);
> Assertion.AssertEquals("#RK10", "Basketball", c["Basket"]);
293c298
< AssertEquals("#RK11", 0, c.Count);
---
> Assertion.AssertEquals("#RK11", 0, c.Count);
297c302,303
< public void TestException ()
---
> [Test]
> public void Exception ()
309c315
< AssertEquals("#E01", typeof(IndexOutOfRangeException), e.GetType());
---
> Assertion.AssertEquals("#E01", typeof(IndexOutOfRangeException), e.GetType());
313c319
< AssertEquals("#E02", true, caughtException);
---
> Assertion.AssertEquals("#E02", true, caughtException);
327c333
< AssertEquals("#E03", typeof(IndexOutOfRangeException), e.GetType());
---
> Assertion.AssertEquals("#E03", typeof(IndexOutOfRangeException), e.GetType());
331c337
< AssertEquals("#E04", true, caughtException);
---
> Assertion.AssertEquals("#E04", true, caughtException);
340c346
< AssertEquals("#E05", typeof(IndexOutOfRangeException), e.GetType());
---
> Assertion.AssertEquals("#E05", typeof(IndexOutOfRangeException), e.GetType());
344c350
< AssertEquals("#E06", true, caughtException);
---
> Assertion.AssertEquals("#E06", true, caughtException);
356,357c362,363
< // AssertEquals("#E07", typeof(IndexOutOfRangeException), e.GetType());
< AssertEquals("#E07", typeof(ArgumentException), e.GetType());
---
> // Assertion.AssertEquals("#E07", typeof(IndexOutOfRangeException), e.GetType());
> Assertion.AssertEquals("#E07", typeof(ArgumentException), e.GetType());
361c367
< AssertEquals("#E08", true, caughtException);
---
> Assertion.AssertEquals("#E08", true, caughtException);
370c376
< AssertEquals("#E09", typeof(ArgumentException), e.GetType());
---
> Assertion.AssertEquals("#E09", typeof(ArgumentException), e.GetType());
374c380
< AssertEquals("#E10", true, caughtException);
---
> Assertion.AssertEquals("#E10", true, caughtException);
383c389
< AssertEquals("#E11", typeof(ArgumentException), e.GetType());
---
> Assertion.AssertEquals("#E11", typeof(ArgumentException), e.GetType());
387c393
< AssertEquals("#E12", true, caughtException);
---
> Assertion.AssertEquals("#E12", true, caughtException);
396c402
< AssertEquals("#E13", typeof(ArgumentException), e.GetType());
---
> Assertion.AssertEquals("#E13", typeof(ArgumentException), e.GetType());
400c406
< AssertEquals("#E14", true, caughtException);
---
> Assertion.AssertEquals("#E14", true, caughtException);
409c415
< AssertEquals("#E15", typeof(InvalidCastException), e.GetType());
---
> Assertion.AssertEquals("#E15", typeof(InvalidCastException), e.GetType());
413c419
< AssertEquals("#E16", true, caughtException);
---
> Assertion.AssertEquals("#E16", true, caughtException);
422c428
< AssertEquals("#E17", typeof(InvalidCastException), e.GetType());
---
> Assertion.AssertEquals("#E17", typeof(InvalidCastException), e.GetType());
426c432
< AssertEquals("#E18", true, caughtException);
---
> Assertion.AssertEquals("#E18", true, caughtException);
435c441
< AssertEquals("#E19", typeof(ArgumentException), e.GetType());
---
> Assertion.AssertEquals("#E19", typeof(ArgumentException), e.GetType());
439c445
< AssertEquals("#E20", true, caughtException);
---
> Assertion.AssertEquals("#E20", true, caughtException);
448c454
< AssertEquals("#E21", typeof(ArgumentException), e.GetType());
---
> Assertion.AssertEquals("#E21", typeof(ArgumentException), e.GetType());
452c458
< AssertEquals("#E22", true, caughtException);
---
> Assertion.AssertEquals("#E22", true, caughtException);
461c467
< AssertEquals("#E23", typeof(IndexOutOfRangeException), e.GetType());
---
> Assertion.AssertEquals("#E23", typeof(IndexOutOfRangeException), e.GetType());
465c471
< AssertEquals("#E24", true, caughtException);
---
> Assertion.AssertEquals("#E24", true, caughtException);
479,480c485,486
< // AssertEquals("#E25", typeof(InvalidOperationException), e.GetType());
< AssertEquals("#E25", typeof(IndexOutOfRangeException), e.GetType());
---
> // Assertion.AssertEquals("#E25", typeof(InvalidOperationException), e.GetType());
> Assertion.AssertEquals("#E25", typeof(IndexOutOfRangeException), e.GetType());
484c490
< AssertEquals("#E26", true, caughtException);
---
> Assertion.AssertEquals("#E26", true, caughtException);
500c506
< AssertEquals("#E27", typeof(InvalidOperationException), e.GetType());
---
> Assertion.AssertEquals("#E27", typeof(InvalidOperationException), e.GetType());
506,507c512,513
< // AssertEquals("#E28", true, caughtException);
< AssertEquals("#E28", false, caughtException);
---
> // Assertion.AssertEquals("#E28", true, caughtException);
> Assertion.AssertEquals("#E28", false, caughtException);
523c529
< AssertEquals("#E29", typeof(InvalidOperationException), e.GetType());
---
> Assertion.AssertEquals("#E29", typeof(InvalidOperationException), e.GetType());
529,530c535,536
< // AssertEquals("#E30", true, caughtException);
< AssertEquals("#E30", false, caughtException);
---
> // Assertion.AssertEquals("#E30", true, caughtException);
> Assertion.AssertEquals("#E30", false, caughtException);
-------------- next part --------------
16c16,17
< public class ConversionTest : TestCase
---
> [TestFixture]
> public class ConversionTest
19,20c20,21
< public ConversionTest() : base ("Microsoft.VisualBasic.Conversion") {}
< public ConversionTest(string name) : base(name) {}
---
> [SetUp]
> public void GetReady() {}
22,23c23,24
< protected override void SetUp() {}
< protected override void TearDown() {}
---
> [TearDown]
> public void Clear() {}
25,31c26,27
< public static ITest Suite {
< get {
< return new TestSuite(typeof(ConversionTest));
< }
< }
<
< public void TestErrorToStringEmpty() {
---
> [Test]
> public void ErrorToStringEmpty() {
35c31,32
< public void TestErrorToStringNumber() {
---
> [Test]
> public void ErrorToStringNumber() {
40c37,38
< public void TestFix() {
---
> [Test]
> public void Fix() {
47,58c45,56
< AssertEquals("#F01", System.Int16.MaxValue, Conversion.Fix(System.Int16.MaxValue));
< AssertEquals("#F02", System.Int16.MinValue, Conversion.Fix(System.Int16.MinValue));
< AssertEquals("#F03", System.Int32.MaxValue, Conversion.Fix(System.Int32.MaxValue));
< AssertEquals("#F04", System.Int32.MinValue, Conversion.Fix(System.Int32.MinValue));
< AssertEquals("#F05", System.Int64.MaxValue, Conversion.Fix(System.Int64.MaxValue));
< AssertEquals("#F06", System.Int64.MinValue, Conversion.Fix(System.Int64.MinValue));
< AssertEquals("#F07", (System.Single)Math.Floor(System.Single.MaxValue), Conversion.Fix(System.Single.MaxValue));
< AssertEquals("#F08", -1 * (System.Single)Math.Floor(-1 * System.Single.MinValue), Conversion.Fix(System.Single.MinValue));
< AssertEquals("#F09", Math.Floor(System.Double.MaxValue), Conversion.Fix(System.Double.MaxValue));
< AssertEquals("#F10", -1 * Math.Floor(-1 * System.Double.MinValue), Conversion.Fix(System.Double.MinValue));
< AssertEquals("#F11", Decimal.Floor(System.Decimal.MaxValue), Conversion.Fix(System.Decimal.MaxValue));
< AssertEquals("#F12", -1 * Decimal.Floor(-1 * System.Decimal.MinValue), Conversion.Fix(System.Decimal.MinValue));
---
> Assertion.AssertEquals("#F01", System.Int16.MaxValue, Conversion.Fix(System.Int16.MaxValue));
> Assertion.AssertEquals("#F02", System.Int16.MinValue, Conversion.Fix(System.Int16.MinValue));
> Assertion.AssertEquals("#F03", System.Int32.MaxValue, Conversion.Fix(System.Int32.MaxValue));
> Assertion.AssertEquals("#F04", System.Int32.MinValue, Conversion.Fix(System.Int32.MinValue));
> Assertion.AssertEquals("#F05", System.Int64.MaxValue, Conversion.Fix(System.Int64.MaxValue));
> Assertion.AssertEquals("#F06", System.Int64.MinValue, Conversion.Fix(System.Int64.MinValue));
> Assertion.AssertEquals("#F07", (System.Single)Math.Floor(System.Single.MaxValue), Conversion.Fix(System.Single.MaxValue));
> Assertion.AssertEquals("#F08", -1 * (System.Single)Math.Floor(-1 * System.Single.MinValue), Conversion.Fix(System.Single.MinValue));
> Assertion.AssertEquals("#F09", Math.Floor(System.Double.MaxValue), Conversion.Fix(System.Double.MaxValue));
> Assertion.AssertEquals("#F10", -1 * Math.Floor(-1 * System.Double.MinValue), Conversion.Fix(System.Double.MinValue));
> Assertion.AssertEquals("#F11", Decimal.Floor(System.Decimal.MaxValue), Conversion.Fix(System.Decimal.MaxValue));
> Assertion.AssertEquals("#F12", -1 * Decimal.Floor(-1 * System.Decimal.MinValue), Conversion.Fix(System.Decimal.MinValue));
62c60
< AssertEquals("#F13", 99F, Conversion.Fix(Sng));
---
> Assertion.AssertEquals("#F13", 99F, Conversion.Fix(Sng));
66c64
< AssertEquals("#F14", 99F, Conversion.Fix(Sng));
---
> Assertion.AssertEquals("#F14", 99F, Conversion.Fix(Sng));
70c68
< AssertEquals("#F15", -99F, Conversion.Fix(Sng));
---
> Assertion.AssertEquals("#F15", -99F, Conversion.Fix(Sng));
74c72
< AssertEquals("#F16", -99F, Conversion.Fix(Sng));
---
> Assertion.AssertEquals("#F16", -99F, Conversion.Fix(Sng));
78c76
< AssertEquals("#F17", 99D, Conversion.Fix(Dbl));
---
> Assertion.AssertEquals("#F17", 99D, Conversion.Fix(Dbl));
82c80
< AssertEquals("#F18", 99D, Conversion.Fix(Dbl));
---
> Assertion.AssertEquals("#F18", 99D, Conversion.Fix(Dbl));
86c84
< AssertEquals("#F19", -99D, Conversion.Fix(Dbl));
---
> Assertion.AssertEquals("#F19", -99D, Conversion.Fix(Dbl));
90c88
< AssertEquals("#F20", -99D, Conversion.Fix(Dbl));
---
> Assertion.AssertEquals("#F20", -99D, Conversion.Fix(Dbl));
94c92
< AssertEquals("#F21", 99M, Conversion.Fix(Dec));
---
> Assertion.AssertEquals("#F21", 99M, Conversion.Fix(Dec));
98c96
< AssertEquals("#F22", 99M, Conversion.Fix(Dec));
---
> Assertion.AssertEquals("#F22", 99M, Conversion.Fix(Dec));
102c100
< AssertEquals("#F23", -99M, Conversion.Fix(Dec));
---
> Assertion.AssertEquals("#F23", -99M, Conversion.Fix(Dec));
106c104
< AssertEquals("#F24", -99M, Conversion.Fix(Dec));
---
> Assertion.AssertEquals("#F24", -99M, Conversion.Fix(Dec));
111c109
< AssertEquals("#F25", 99D, Conversion.Fix(S));
---
> Assertion.AssertEquals("#F25", 99D, Conversion.Fix(S));
116c114
< AssertEquals("#F26", 99D, Conversion.Fix(S));
---
> Assertion.AssertEquals("#F26", 99D, Conversion.Fix(S));
121c119
< AssertEquals("#F27", -99D, Conversion.Fix(S));
---
> Assertion.AssertEquals("#F27", -99D, Conversion.Fix(S));
126c124
< AssertEquals("#F28", -99D, Conversion.Fix(S));
---
> Assertion.AssertEquals("#F28", -99D, Conversion.Fix(S));
131c129
< AssertEquals("#F29", 99D, Conversion.Fix(O));
---
> Assertion.AssertEquals("#F29", 99D, Conversion.Fix(O));
136c134
< AssertEquals("#F30", (System.Object)99F, Conversion.Fix(O));
---
> Assertion.AssertEquals("#F30", (System.Object)99F, Conversion.Fix(O));
141c139
< AssertEquals("#F31", -99D, Conversion.Fix(O));
---
> Assertion.AssertEquals("#F31", -99D, Conversion.Fix(O));
146c144
< AssertEquals("#F32", (System.Object)(-99M), Conversion.Fix(O));
---
> Assertion.AssertEquals("#F32", (System.Object)(-99M), Conversion.Fix(O));
156c154
< AssertEquals("#F33", typeof(ArgumentException), e.GetType());
---
> Assertion.AssertEquals("#F33", typeof(ArgumentException), e.GetType());
160c158
< AssertEquals("#F34", true, caughtException);
---
> Assertion.AssertEquals("#F34", true, caughtException);
167c165
< AssertEquals("#F35", typeof(ArgumentNullException), e.GetType());
---
> Assertion.AssertEquals("#F35", typeof(ArgumentNullException), e.GetType());
171c169
< AssertEquals("#F36", true, caughtException);
---
> Assertion.AssertEquals("#F36", true, caughtException);
176c174,175
< public void TestInt() {
---
> [Test]
> public void Int() {
183,194c182,193
< AssertEquals("#I01", System.Int16.MaxValue, Conversion.Int(System.Int16.MaxValue));
< AssertEquals("#I02", System.Int16.MinValue, Conversion.Int(System.Int16.MinValue));
< AssertEquals("#I03", System.Int32.MaxValue, Conversion.Int(System.Int32.MaxValue));
< AssertEquals("#I04", System.Int32.MinValue, Conversion.Int(System.Int32.MinValue));
< AssertEquals("#I05", System.Int64.MaxValue, Conversion.Int(System.Int64.MaxValue));
< AssertEquals("#I06", System.Int64.MinValue, Conversion.Int(System.Int64.MinValue));
< AssertEquals("#I07", (System.Single)Math.Floor(System.Single.MaxValue), Conversion.Int(System.Single.MaxValue));
< AssertEquals("#I08", (System.Single)Math.Floor(System.Single.MinValue), Conversion.Int(System.Single.MinValue));
< AssertEquals("#I09", Math.Floor(System.Double.MaxValue), Conversion.Int(System.Double.MaxValue));
< AssertEquals("#I10", Math.Floor(System.Double.MinValue), Conversion.Int(System.Double.MinValue));
< AssertEquals("#I11", Decimal.Floor(System.Decimal.MaxValue), Conversion.Int(System.Decimal.MaxValue));
< AssertEquals("#I12", Decimal.Floor(System.Decimal.MinValue), Conversion.Int(System.Decimal.MinValue));
---
> Assertion.AssertEquals("#I01", System.Int16.MaxValue, Conversion.Int(System.Int16.MaxValue));
> Assertion.AssertEquals("#I02", System.Int16.MinValue, Conversion.Int(System.Int16.MinValue));
> Assertion.AssertEquals("#I03", System.Int32.MaxValue, Conversion.Int(System.Int32.MaxValue));
> Assertion.AssertEquals("#I04", System.Int32.MinValue, Conversion.Int(System.Int32.MinValue));
> Assertion.AssertEquals("#I05", System.Int64.MaxValue, Conversion.Int(System.Int64.MaxValue));
> Assertion.AssertEquals("#I06", System.Int64.MinValue, Conversion.Int(System.Int64.MinValue));
> Assertion.AssertEquals("#I07", (System.Single)Math.Floor(System.Single.MaxValue), Conversion.Int(System.Single.MaxValue));
> Assertion.AssertEquals("#I08", (System.Single)Math.Floor(System.Single.MinValue), Conversion.Int(System.Single.MinValue));
> Assertion.AssertEquals("#I09", Math.Floor(System.Double.MaxValue), Conversion.Int(System.Double.MaxValue));
> Assertion.AssertEquals("#I10", Math.Floor(System.Double.MinValue), Conversion.Int(System.Double.MinValue));
> Assertion.AssertEquals("#I11", Decimal.Floor(System.Decimal.MaxValue), Conversion.Int(System.Decimal.MaxValue));
> Assertion.AssertEquals("#I12", Decimal.Floor(System.Decimal.MinValue), Conversion.Int(System.Decimal.MinValue));
198c197
< AssertEquals("#I13", 99F, Conversion.Int(Sng));
---
> Assertion.AssertEquals("#I13", 99F, Conversion.Int(Sng));
202c201
< AssertEquals("#I14", 99F, Conversion.Int(Sng));
---
> Assertion.AssertEquals("#I14", 99F, Conversion.Int(Sng));
206c205
< AssertEquals("#I15", -100F, Conversion.Int(Sng));
---
> Assertion.AssertEquals("#I15", -100F, Conversion.Int(Sng));
210c209
< AssertEquals("#I16", -100F, Conversion.Int(Sng));
---
> Assertion.AssertEquals("#I16", -100F, Conversion.Int(Sng));
214c213
< AssertEquals("#I17", 99D, Conversion.Int(Dbl));
---
> Assertion.AssertEquals("#I17", 99D, Conversion.Int(Dbl));
218c217
< AssertEquals("#I18", 99D, Conversion.Int(Dbl));
---
> Assertion.AssertEquals("#I18", 99D, Conversion.Int(Dbl));
222c221
< AssertEquals("#I19", -100D, Conversion.Int(Dbl));
---
> Assertion.AssertEquals("#I19", -100D, Conversion.Int(Dbl));
226c225
< AssertEquals("#I20", -100D, Conversion.Int(Dbl));
---
> Assertion.AssertEquals("#I20", -100D, Conversion.Int(Dbl));
230c229
< AssertEquals("#I21", 99M, Conversion.Int(Dec));
---
> Assertion.AssertEquals("#I21", 99M, Conversion.Int(Dec));
234c233
< AssertEquals("#I22", 99M, Conversion.Int(Dec));
---
> Assertion.AssertEquals("#I22", 99M, Conversion.Int(Dec));
238c237
< AssertEquals("#I23", -100M, Conversion.Int(Dec));
---
> Assertion.AssertEquals("#I23", -100M, Conversion.Int(Dec));
242c241
< AssertEquals("#I24", -100M, Conversion.Int(Dec));
---
> Assertion.AssertEquals("#I24", -100M, Conversion.Int(Dec));
247c246
< AssertEquals("#I25", 99D, Conversion.Int(S));
---
> Assertion.AssertEquals("#I25", 99D, Conversion.Int(S));
252c251
< AssertEquals("#I26", 99D, Conversion.Int(S));
---
> Assertion.AssertEquals("#I26", 99D, Conversion.Int(S));
257c256
< AssertEquals("#I27", -100D, Conversion.Int(S));
---
> Assertion.AssertEquals("#I27", -100D, Conversion.Int(S));
262c261
< AssertEquals("#I28", -100D, Conversion.Int(S));
---
> Assertion.AssertEquals("#I28", -100D, Conversion.Int(S));
267c266
< AssertEquals("#I29", 99D, Conversion.Int(O));
---
> Assertion.AssertEquals("#I29", 99D, Conversion.Int(O));
272c271
< AssertEquals("#I30", 99F, Conversion.Int(O));
---
> Assertion.AssertEquals("#I30", 99F, Conversion.Int(O));
277c276
< AssertEquals("#I31", -100D, Conversion.Int(O));
---
> Assertion.AssertEquals("#I31", -100D, Conversion.Int(O));
282c281
< AssertEquals("#I32", -100M, Conversion.Int(O));
---
> Assertion.AssertEquals("#I32", -100M, Conversion.Int(O));
293c292
< AssertEquals("#I33", typeof(ArgumentException), e.GetType());
---
> Assertion.AssertEquals("#I33", typeof(ArgumentException), e.GetType());
297c296
< AssertEquals("#I34", true, caughtException);
---
> Assertion.AssertEquals("#I34", true, caughtException);
304c303
< AssertEquals("#I35", typeof(ArgumentNullException), e.GetType());
---
> Assertion.AssertEquals("#I35", typeof(ArgumentNullException), e.GetType());
308c307
< AssertEquals("#I36", true, caughtException);
---
> Assertion.AssertEquals("#I36", true, caughtException);
314,322c313,322
< public void TestHex() {
< AssertEquals("#H01", "FF", Conversion.Hex(System.Byte.MaxValue));
< AssertEquals("#H02", "0", Conversion.Hex(System.Byte.MinValue));
< AssertEquals("#H03", "7FFF", Conversion.Hex(System.Int16.MaxValue));
< AssertEquals("#H04", "8000", Conversion.Hex(System.Int16.MinValue));
< AssertEquals("#H05", "7FFFFFFF", Conversion.Hex(System.Int32.MaxValue));
< AssertEquals("#H06", "80000000", Conversion.Hex(System.Int32.MinValue));
< AssertEquals("#H07", "7FFFFFFFFFFFFFFF", Conversion.Hex(System.Int64.MaxValue));
< AssertEquals("#H08", "8000000000000000", Conversion.Hex(System.Int64.MinValue));
---
> [Test]
> public void Hex() {
> Assertion.AssertEquals("#H01", "FF", Conversion.Hex(System.Byte.MaxValue));
> Assertion.AssertEquals("#H02", "0", Conversion.Hex(System.Byte.MinValue));
> Assertion.AssertEquals("#H03", "7FFF", Conversion.Hex(System.Int16.MaxValue));
> Assertion.AssertEquals("#H04", "8000", Conversion.Hex(System.Int16.MinValue));
> Assertion.AssertEquals("#H05", "7FFFFFFF", Conversion.Hex(System.Int32.MaxValue));
> Assertion.AssertEquals("#H06", "80000000", Conversion.Hex(System.Int32.MinValue));
> Assertion.AssertEquals("#H07", "7FFFFFFFFFFFFFFF", Conversion.Hex(System.Int64.MaxValue));
> Assertion.AssertEquals("#H08", "8000000000000000", Conversion.Hex(System.Int64.MinValue));
332c332
< AssertEquals("#H09", "F", Conversion.Hex(UI8));
---
> Assertion.AssertEquals("#H09", "F", Conversion.Hex(UI8));
335c335
< AssertEquals("#H10", "FF", Conversion.Hex(I16));
---
> Assertion.AssertEquals("#H10", "FF", Conversion.Hex(I16));
338c338
< AssertEquals("#H11", "FF00", Conversion.Hex(I16));
---
> Assertion.AssertEquals("#H11", "FF00", Conversion.Hex(I16));
341c341
< AssertEquals("#H12", "FFFE", Conversion.Hex(I16));
---
> Assertion.AssertEquals("#H12", "FFFE", Conversion.Hex(I16));
344c344
< AssertEquals("#H13", "FFFF", Conversion.Hex(I32));
---
> Assertion.AssertEquals("#H13", "FFFF", Conversion.Hex(I32));
347c347
< AssertEquals("#H14", "FFFF0000", Conversion.Hex(I32));
---
> Assertion.AssertEquals("#H14", "FFFF0000", Conversion.Hex(I32));
350c350
< AssertEquals("#H15", "FFFFFFFE", Conversion.Hex(I32));
---
> Assertion.AssertEquals("#H15", "FFFFFFFE", Conversion.Hex(I32));
353c353
< AssertEquals("#H16", "FFFFFFFF", Conversion.Hex(I64));
---
> Assertion.AssertEquals("#H16", "FFFFFFFF", Conversion.Hex(I64));
356c356
< AssertEquals("#H17", "FFFFFFFF00000000", Conversion.Hex(I64));
---
> Assertion.AssertEquals("#H17", "FFFFFFFF00000000", Conversion.Hex(I64));
359c359
< AssertEquals("#H18", "FFFFFFFFFFFFFFFE", Conversion.Hex(I64));
---
> Assertion.AssertEquals("#H18", "FFFFFFFFFFFFFFFE", Conversion.Hex(I64));
363c363
< AssertEquals("#H19", "FF", Conversion.Hex(S));
---
> Assertion.AssertEquals("#H19", "FF", Conversion.Hex(S));
367c367
< AssertEquals("#H20", "FFFFFF00", Conversion.Hex(S));
---
> Assertion.AssertEquals("#H20", "FFFFFF00", Conversion.Hex(S));
371c371
< AssertEquals("#H21", "FFFFFFFF", Conversion.Hex(S));
---
> Assertion.AssertEquals("#H21", "FFFFFFFF", Conversion.Hex(S));
375c375
< AssertEquals("#H22", "FFFF", Conversion.Hex(S));
---
> Assertion.AssertEquals("#H22", "FFFF", Conversion.Hex(S));
379c379
< AssertEquals("#H23", "FFFF0000", Conversion.Hex(S));
---
> Assertion.AssertEquals("#H23", "FFFF0000", Conversion.Hex(S));
383c383
< AssertEquals("#H24", "FFFFFFFE", Conversion.Hex(S));
---
> Assertion.AssertEquals("#H24", "FFFFFFFE", Conversion.Hex(S));
387c387
< AssertEquals("#H25", "FFFFFFFF", Conversion.Hex(S));
---
> Assertion.AssertEquals("#H25", "FFFFFFFF", Conversion.Hex(S));
391c391
< AssertEquals("#H26", "FFFFFFFF00000000", Conversion.Hex(S));
---
> Assertion.AssertEquals("#H26", "FFFFFFFF00000000", Conversion.Hex(S));
395c395
< AssertEquals("#H27", "FF", Conversion.Hex(O));
---
> Assertion.AssertEquals("#H27", "FF", Conversion.Hex(O));
399c399
< AssertEquals("#H28", "FF", Conversion.Hex(O));
---
> Assertion.AssertEquals("#H28", "FF", Conversion.Hex(O));
403c403
< AssertEquals("#H29", "FF00", Conversion.Hex(O));
---
> Assertion.AssertEquals("#H29", "FF00", Conversion.Hex(O));
407c407
< AssertEquals("#H30", "FFFE", Conversion.Hex(O));
---
> Assertion.AssertEquals("#H30", "FFFE", Conversion.Hex(O));
411c411
< AssertEquals("#H31", "FFFF", Conversion.Hex(O));
---
> Assertion.AssertEquals("#H31", "FFFF", Conversion.Hex(O));
415c415
< AssertEquals("#H32", "FFFF0000", Conversion.Hex(O));
---
> Assertion.AssertEquals("#H32", "FFFF0000", Conversion.Hex(O));
419c419
< AssertEquals("#H33", "FFFFFFFE", Conversion.Hex(O));
---
> Assertion.AssertEquals("#H33", "FFFFFFFE", Conversion.Hex(O));
423c423
< AssertEquals("#H34", "FFFFFFFF", Conversion.Hex(O));
---
> Assertion.AssertEquals("#H34", "FFFFFFFF", Conversion.Hex(O));
427c427
< AssertEquals("#H35", "FFFFFFFF00000000", Conversion.Hex(O));
---
> Assertion.AssertEquals("#H35", "FFFFFFFF00000000", Conversion.Hex(O));
432c432
< //AssertEquals("#H35", "FFFFFFFFFFFFFFFE", Conversion.Hex(O));
---
> //Assertion.AssertEquals("#H35", "FFFFFFFFFFFFFFFE", Conversion.Hex(O));
441c441
< AssertEquals("#H36", typeof(ArgumentException), e.GetType());
---
> Assertion.AssertEquals("#H36", typeof(ArgumentException), e.GetType());
445c445
< AssertEquals("#H37", true, caughtException);
---
> Assertion.AssertEquals("#H37", true, caughtException);
453c453
< AssertEquals("#H38", typeof(ArgumentNullException), e.GetType());
---
> Assertion.AssertEquals("#H38", typeof(ArgumentNullException), e.GetType());
457c457
< AssertEquals("#H39", true, caughtException);
---
> Assertion.AssertEquals("#H39", true, caughtException);
461,469c461,470
< public void TestOct() {
< AssertEquals("#O01", "377", Conversion.Oct(System.Byte.MaxValue));
< AssertEquals("#O02", "0", Conversion.Oct(System.Byte.MinValue));
< AssertEquals("#O03", "77777", Conversion.Oct(System.Int16.MaxValue));
< AssertEquals("#O04", "100000", Conversion.Oct(System.Int16.MinValue));
< AssertEquals("#O05", "17777777777", Conversion.Oct(System.Int32.MaxValue));
< AssertEquals("#O06", "20000000000", Conversion.Oct(System.Int32.MinValue));
< AssertEquals("#O07", "777777777777777777777", Conversion.Oct(System.Int64.MaxValue));
< //AssertEquals("#O08", "1000000000000000000000", Conversion.Oct(System.Int64.MinValue));
---
> [Test]
> public void Oct() {
> Assertion.AssertEquals("#O01", "377", Conversion.Oct(System.Byte.MaxValue));
> Assertion.AssertEquals("#O02", "0", Conversion.Oct(System.Byte.MinValue));
> Assertion.AssertEquals("#O03", "77777", Conversion.Oct(System.Int16.MaxValue));
> Assertion.AssertEquals("#O04", "100000", Conversion.Oct(System.Int16.MinValue));
> Assertion.AssertEquals("#O05", "17777777777", Conversion.Oct(System.Int32.MaxValue));
> Assertion.AssertEquals("#O06", "20000000000", Conversion.Oct(System.Int32.MinValue));
> Assertion.AssertEquals("#O07", "777777777777777777777", Conversion.Oct(System.Int64.MaxValue));
> //Assertion.AssertEquals("#O08", "1000000000000000000000", Conversion.Oct(System.Int64.MinValue));
479c480
< AssertEquals("#O09", "17", Conversion.Oct(UI8));
---
> Assertion.AssertEquals("#O09", "17", Conversion.Oct(UI8));
482c483
< AssertEquals("#O10", "377", Conversion.Oct(I16));
---
> Assertion.AssertEquals("#O10", "377", Conversion.Oct(I16));
485c486
< AssertEquals("#O11", "177400", Conversion.Oct(I16));
---
> Assertion.AssertEquals("#O11", "177400", Conversion.Oct(I16));
488c489
< AssertEquals("#O12", "177776", Conversion.Oct(I16));
---
> Assertion.AssertEquals("#O12", "177776", Conversion.Oct(I16));
491c492
< AssertEquals("#O13", "177777", Conversion.Oct(I32));
---
> Assertion.AssertEquals("#O13", "177777", Conversion.Oct(I32));
494c495
< AssertEquals("#O14", "37777600000", Conversion.Oct(I32));
---
> Assertion.AssertEquals("#O14", "37777600000", Conversion.Oct(I32));
497c498
< AssertEquals("#O15", "37777777776", Conversion.Oct(I32));
---
> Assertion.AssertEquals("#O15", "37777777776", Conversion.Oct(I32));
500c501
< AssertEquals("#O16", "37777777777", Conversion.Oct(I64));
---
> Assertion.AssertEquals("#O16", "37777777777", Conversion.Oct(I64));
503c504
< AssertEquals("#O17", "1777777777740000000000", Conversion.Oct(I64));
---
> Assertion.AssertEquals("#O17", "1777777777740000000000", Conversion.Oct(I64));
506c507
< AssertEquals("#O18", "1777777777777777777776", Conversion.Oct(I64));
---
> Assertion.AssertEquals("#O18", "1777777777777777777776", Conversion.Oct(I64));
510c511
< AssertEquals("#O19", "377", Conversion.Oct(S));
---
> Assertion.AssertEquals("#O19", "377", Conversion.Oct(S));
514c515
< AssertEquals("#O20", "37777777400", Conversion.Oct(S));
---
> Assertion.AssertEquals("#O20", "37777777400", Conversion.Oct(S));
518c519
< AssertEquals("#O21", "37777777776", Conversion.Oct(S));
---
> Assertion.AssertEquals("#O21", "37777777776", Conversion.Oct(S));
522c523
< AssertEquals("#O22", "177777", Conversion.Oct(S));
---
> Assertion.AssertEquals("#O22", "177777", Conversion.Oct(S));
526c527
< AssertEquals("#O23", "37777600000", Conversion.Oct(S));
---
> Assertion.AssertEquals("#O23", "37777600000", Conversion.Oct(S));
530c531
< AssertEquals("#O24", "37777777776", Conversion.Oct(S));
---
> Assertion.AssertEquals("#O24", "37777777776", Conversion.Oct(S));
534c535
< AssertEquals("#O25", "37777777777", Conversion.Oct(S));
---
> Assertion.AssertEquals("#O25", "37777777777", Conversion.Oct(S));
538c539
< AssertEquals("#O26", "1777777777740000000000", Conversion.Oct(S));
---
> Assertion.AssertEquals("#O26", "1777777777740000000000", Conversion.Oct(S));
542c543
< AssertEquals("#O27", "377", Conversion.Oct(O));
---
> Assertion.AssertEquals("#O27", "377", Conversion.Oct(O));
546c547
< AssertEquals("#O28", "377", Conversion.Oct(O));
---
> Assertion.AssertEquals("#O28", "377", Conversion.Oct(O));
550c551
< AssertEquals("#O29", "177400", Conversion.Oct(O));
---
> Assertion.AssertEquals("#O29", "177400", Conversion.Oct(O));
554c555
< AssertEquals("#O29", "177776", Conversion.Oct(O));
---
> Assertion.AssertEquals("#O29", "177776", Conversion.Oct(O));
558c559
< AssertEquals("#O30", "177777", Conversion.Oct(O));
---
> Assertion.AssertEquals("#O30", "177777", Conversion.Oct(O));
562c563
< AssertEquals("#O31", "37777600000", Conversion.Oct(O));
---
> Assertion.AssertEquals("#O31", "37777600000", Conversion.Oct(O));
566c567
< AssertEquals("#O32", "37777777776", Conversion.Oct(O));
---
> Assertion.AssertEquals("#O32", "37777777776", Conversion.Oct(O));
570c571
< AssertEquals("#O33", "37777777777", Conversion.Oct(O));
---
> Assertion.AssertEquals("#O33", "37777777777", Conversion.Oct(O));
574c575
< AssertEquals("#O34", "1777777777740000000000", Conversion.Oct(O));
---
> Assertion.AssertEquals("#O34", "1777777777740000000000", Conversion.Oct(O));
580c581
< // AssertEquals("#O35", "1777777777777777777776", Conversion.Oct(O));
---
> // Assertion.AssertEquals("#O35", "1777777777777777777776", Conversion.Oct(O));
589c590
< AssertEquals("#O36", typeof(ArgumentException), e.GetType());
---
> Assertion.AssertEquals("#O36", typeof(ArgumentException), e.GetType());
593c594
< AssertEquals("#O37", true, caughtException);
---
> Assertion.AssertEquals("#O37", true, caughtException);
601c602
< AssertEquals("#O38", typeof(ArgumentNullException), e.GetType());
---
> Assertion.AssertEquals("#O38", typeof(ArgumentNullException), e.GetType());
605c606
< AssertEquals("#O39", true, caughtException);
---
> Assertion.AssertEquals("#O39", true, caughtException);
609,611c610,613
< public void TestStr() {
< AssertEquals("#S01", "-1", Conversion.Str(-1));
< AssertEquals("#S02", " 1", Conversion.Str(1));
---
> [Test]
> public void Str() {
> Assertion.AssertEquals("#S01", "-1", Conversion.Str(-1));
> Assertion.AssertEquals("#S02", " 1", Conversion.Str(1));
620c622
< AssertEquals("#S03", typeof(InvalidCastException), e.GetType());
---
> Assertion.AssertEquals("#S03", typeof(InvalidCastException), e.GetType());
624c626
< AssertEquals("#S04", true, caughtException);
---
> Assertion.AssertEquals("#S04", true, caughtException);
632c634
< AssertEquals("#S05", typeof(ArgumentNullException), e.GetType());
---
> Assertion.AssertEquals("#S05", typeof(ArgumentNullException), e.GetType());
638,642c640,645
< public void TestVal() {
< AssertEquals("#V01", 4, Conversion.Val('4'));
< AssertEquals("#V02", -3542.76, Conversion.Val(" - 3 5 .4 2 7 6E+ 0 0 2 "));
< AssertEquals("#V03", 255D, Conversion.Val("&HFF"));
< AssertEquals("#V04", 255D, Conversion.Val("&o377"));
---
> [Test]
> public void Val() {
> Assertion.AssertEquals("#V01", 4, Conversion.Val('4'));
> Assertion.AssertEquals("#V02", -3542.76, Conversion.Val(" - 3 5 .4 2 7 6E+ 0 0 2 "));
> Assertion.AssertEquals("#V03", 255D, Conversion.Val("&HFF"));
> Assertion.AssertEquals("#V04", 255D, Conversion.Val("&o377"));
646c649
< AssertEquals("#V05", -35476D, Conversion.Val(O));
---
> Assertion.AssertEquals("#V05", -35476D, Conversion.Val(O));
656c659
< AssertEquals("#V06", typeof(OverflowException), e.GetType());
---
> Assertion.AssertEquals("#V06", typeof(OverflowException), e.GetType());
660c663
< AssertEquals("#V07", true, caughtException);
---
> Assertion.AssertEquals("#V07", true, caughtException);
668c671
< AssertEquals("#V08", typeof(ArgumentException), e.GetType());
---
> Assertion.AssertEquals("#V08", typeof(ArgumentException), e.GetType());
671c674
< AssertEquals("#V09", true, caughtException);
---
> Assertion.AssertEquals("#V09", true, caughtException);
-------------- next part --------------
17,18c17,18
<
< public class DateAndTimeTest : TestCase {
---
> [TestFixture]
> public class DateAndTimeTest {
21,23d20
<
< public DateAndTimeTest() : base ("Microsoft.VisualBasic.DateAndTime") {}
< public DateAndTimeTest(string name) : base(name) {}
25c22,23
< protected override void SetUp()
---
> [SetUp]
> public void GetReady()
32c30,31
< protected override void TearDown ()
---
> [TearDown]
> public void Clear()
37,43c36,38
< public static ITest Suite {
< get {
< return new TestSuite(typeof(DateAndTimeTest));
< }
< }
<
< public void TestDateString() {
---
> [Test]
> public void DateString()
> {
46c41
< AssertEquals("#DS01", dtNow.ToShortDateString(), DateTime.Parse(s).ToShortDateString());
---
> Assertion.AssertEquals("#DS01", dtNow.ToShortDateString(), DateTime.Parse(s).ToShortDateString());
51,52c46,49
< public void TestToday() {
< AssertEquals("#TO01", DateTime.Today, DateAndTime.Today);
---
> [Test]
> public void Today()
> {
> Assertion.AssertEquals("#TO01", DateTime.Today, DateAndTime.Today);
57c54,56
< public void TestTimer() {
---
> [Test]
> public void Timer()
> {
70,71c69,70
< Assert("#TI01", secNow >= secTimer);
< Assert("#TI02: SecTimer2=" + secTimer2 + " secNow=" + secNow, secTimer2 >= secNow);
---
> Assertion.Assert("#TI01", secNow >= secTimer);
> Assertion.Assert("#TI02: SecTimer2=" + secTimer2 + " secNow=" + secNow, secTimer2 >= secNow);
74c73
< Assert("#TI03", secTimer3 > secTimer);
---
> Assertion.Assert("#TI03", secTimer3 > secTimer);
77c76,78
< public void TestNow() {
---
> [Test]
> public void Now()
> {
82,83c83,84
< Assert("#N01", dtTest >= dtNow);
< Assert("#N02", dtNow2 >= dtTest);
---
> Assertion.Assert("#N01", dtTest >= dtNow);
> Assertion.Assert("#N02", dtNow2 >= dtTest);
86c87,89
< public void TestTimeOfDay() {
---
> [Test]
> public void TimeOfDay()
> {
94,95c97,98
< Assert("#TOD01", tsTest.Ticks >= tsNow.Ticks);
< Assert("#TOD02", tsNow2.Ticks >= tsTest.Ticks);
---
> Assertion.Assert("#TOD01", tsTest.Ticks >= tsNow.Ticks);
> Assertion.Assert("#TOD02", tsNow2.Ticks >= tsTest.Ticks);
100c103,105
< public void TestTimeString() {
---
> [Test]
> public void TimeString()
> {
109,110c114,115
< Assert("#TS01", tsTest.Ticks >= tsNow.Ticks);
< Assert("#TS02", tsNow2.Ticks >= tsTest.Ticks);
---
> Assertion.Assert("#TS01", tsTest.Ticks >= tsNow.Ticks);
> Assertion.Assert("#TS02", tsNow2.Ticks >= tsTest.Ticks);
115c120,122
< public void TestDateAdd() {
---
> [Test]
> public void DateAdd()
> {
118,119c125,126
< AssertEquals("#DA01", dtNow.AddYears(1), DateAndTime.DateAdd(DateInterval.Year, 1, dtNow));
< AssertEquals("#DA02", dtNow.AddYears(-1), DateAndTime.DateAdd("yyyy", -1, dtNow));
---
> Assertion.AssertEquals("#DA01", dtNow.AddYears(1), DateAndTime.DateAdd(DateInterval.Year, 1, dtNow));
> Assertion.AssertEquals("#DA02", dtNow.AddYears(-1), DateAndTime.DateAdd("yyyy", -1, dtNow));
128c135
< AssertEquals("#DA03", e.GetType(), typeof(ArgumentException));
---
> Assertion.AssertEquals("#DA03", e.GetType(), typeof(ArgumentException));
132c139
< AssertEquals("#DA04", caughtException, true);
---
> Assertion.AssertEquals("#DA04", caughtException, true);
134,135c141,142
< AssertEquals("#DA05", dtNow.AddMonths(6), DateAndTime.DateAdd(DateInterval.Quarter, 2, dtNow));
< AssertEquals("#DA06", dtNow.AddMonths(-6), DateAndTime.DateAdd("q", -2, dtNow));
---
> Assertion.AssertEquals("#DA05", dtNow.AddMonths(6), DateAndTime.DateAdd(DateInterval.Quarter, 2, dtNow));
> Assertion.AssertEquals("#DA06", dtNow.AddMonths(-6), DateAndTime.DateAdd("q", -2, dtNow));
137,138c144,145
< AssertEquals("#DA07", dtNow.AddMonths(3), DateAndTime.DateAdd(DateInterval.Month, 3, dtNow));
< AssertEquals("#DA08", dtNow.AddMonths(-3), DateAndTime.DateAdd("m", -3, dtNow));
---
> Assertion.AssertEquals("#DA07", dtNow.AddMonths(3), DateAndTime.DateAdd(DateInterval.Month, 3, dtNow));
> Assertion.AssertEquals("#DA08", dtNow.AddMonths(-3), DateAndTime.DateAdd("m", -3, dtNow));
140,141c147,148
< AssertEquals("#DA09", dtNow.AddDays(28), DateAndTime.DateAdd(DateInterval.WeekOfYear, 4, dtNow));
< AssertEquals("#DA10", dtNow.AddDays(-28), DateAndTime.DateAdd("ww", -4, dtNow));
---
> Assertion.AssertEquals("#DA09", dtNow.AddDays(28), DateAndTime.DateAdd(DateInterval.WeekOfYear, 4, dtNow));
> Assertion.AssertEquals("#DA10", dtNow.AddDays(-28), DateAndTime.DateAdd("ww", -4, dtNow));
143,144c150,151
< AssertEquals("#DA11", dtNow.AddDays(5), DateAndTime.DateAdd(DateInterval.Weekday, 5, dtNow));
< AssertEquals("#DA12", dtNow.AddDays(-5), DateAndTime.DateAdd("w", -5, dtNow));
---
> Assertion.AssertEquals("#DA11", dtNow.AddDays(5), DateAndTime.DateAdd(DateInterval.Weekday, 5, dtNow));
> Assertion.AssertEquals("#DA12", dtNow.AddDays(-5), DateAndTime.DateAdd("w", -5, dtNow));
146,147c153,154
< AssertEquals("#DA13", dtNow.AddDays(6), DateAndTime.DateAdd(DateInterval.DayOfYear, 6, dtNow));
< AssertEquals("#DA14", dtNow.AddDays(-6), DateAndTime.DateAdd("y", -6, dtNow));
---
> Assertion.AssertEquals("#DA13", dtNow.AddDays(6), DateAndTime.DateAdd(DateInterval.DayOfYear, 6, dtNow));
> Assertion.AssertEquals("#DA14", dtNow.AddDays(-6), DateAndTime.DateAdd("y", -6, dtNow));
149,150c156,157
< AssertEquals("#DA15", dtNow.AddDays(7), DateAndTime.DateAdd(DateInterval.Day, 7, dtNow));
< AssertEquals("#DA16", dtNow.AddDays(-7), DateAndTime.DateAdd("d", -7, dtNow));
---
> Assertion.AssertEquals("#DA15", dtNow.AddDays(7), DateAndTime.DateAdd(DateInterval.Day, 7, dtNow));
> Assertion.AssertEquals("#DA16", dtNow.AddDays(-7), DateAndTime.DateAdd("d", -7, dtNow));
152,153c159,160
< AssertEquals("#DA17", dtNow.AddHours(8), DateAndTime.DateAdd(DateInterval.Hour, 8, dtNow));
< AssertEquals("#DA18", dtNow.AddHours(-8), DateAndTime.DateAdd(DateInterval.Hour, -8, dtNow));
---
> Assertion.AssertEquals("#DA17", dtNow.AddHours(8), DateAndTime.DateAdd(DateInterval.Hour, 8, dtNow));
> Assertion.AssertEquals("#DA18", dtNow.AddHours(-8), DateAndTime.DateAdd(DateInterval.Hour, -8, dtNow));
155,156c162,163
< AssertEquals("#DA19", dtNow.AddMinutes(9), DateAndTime.DateAdd(DateInterval.Minute, 9, dtNow));
< AssertEquals("#DA20", dtNow.AddMinutes(-9), DateAndTime.DateAdd("n", -9, dtNow));
---
> Assertion.AssertEquals("#DA19", dtNow.AddMinutes(9), DateAndTime.DateAdd(DateInterval.Minute, 9, dtNow));
> Assertion.AssertEquals("#DA20", dtNow.AddMinutes(-9), DateAndTime.DateAdd("n", -9, dtNow));
158,159c165,166
< AssertEquals("#DA21", dtNow.AddSeconds(10), DateAndTime.DateAdd(DateInterval.Second, 10, dtNow));
< AssertEquals("#DA22", dtNow.AddSeconds(-10), DateAndTime.DateAdd("s", -10, dtNow));
---
> Assertion.AssertEquals("#DA21", dtNow.AddSeconds(10), DateAndTime.DateAdd(DateInterval.Second, 10, dtNow));
> Assertion.AssertEquals("#DA22", dtNow.AddSeconds(-10), DateAndTime.DateAdd("s", -10, dtNow));
168c175
< AssertEquals("#DA23", e.GetType(), typeof(Exception));
---
> Assertion.AssertEquals("#DA23", e.GetType(), typeof(Exception));
171c178
< // AssertEquals("#DA24", caughtException, true);
---
> // Assertion.AssertEquals("#DA24", caughtException, true);
174c181,183
< public void TestDateDiff () {
---
> [Test]
> public void DateDiff ()
> {
181c190
< AssertEquals("#DD01", dtNow, dtOld.AddYears((int)diff));
---
> Assertion.AssertEquals("#DD01", dtNow, dtOld.AddYears((int)diff));
188c197
< AssertEquals("#DD02", 1L, diff);
---
> Assertion.AssertEquals("#DD02", 1L, diff);
192c201
< AssertEquals("#DD03", 1L, diff);
---
> Assertion.AssertEquals("#DD03", 1L, diff);
196c205
< AssertEquals("#DD04", 1L, diff);
---
> Assertion.AssertEquals("#DD04", 1L, diff);
204c213
< AssertEquals ("#DD05", 0L, WD);
---
> Assertion.AssertEquals ("#DD05", 0L, WD);
208c217
< AssertEquals ("#DD06", 1L, WY);
---
> Assertion.AssertEquals ("#DD06", 1L, WY);
211c220,222
< public void TestDatePart () {
---
> [Test]
> public void DatePart ()
> {
216,230c227,241
< AssertEquals("#DP01", 2001, DateAndTime.DatePart(DateInterval.Year, dtJan4, FirstDayOfWeek.System, FirstWeekOfYear.System));
< AssertEquals("#DP02", 1, DateAndTime.DatePart(DateInterval.Quarter, dtJan4, FirstDayOfWeek.System, FirstWeekOfYear.System));
< AssertEquals("#DP03", 1, DateAndTime.DatePart(DateInterval.Month, dtJan4, FirstDayOfWeek.System, FirstWeekOfYear.System));
< AssertEquals("#DP04", 1, DateAndTime.DatePart(DateInterval.WeekOfYear, dtJan4, FirstDayOfWeek.System, FirstWeekOfYear.FirstFourDays));
< AssertEquals("#DP05", 53, DateAndTime.DatePart(DateInterval.WeekOfYear, dtJan4, FirstDayOfWeek.System, FirstWeekOfYear.FirstFullWeek));
< AssertEquals("#DP06", 1, DateAndTime.DatePart(DateInterval.WeekOfYear, dtJan4, FirstDayOfWeek.System, FirstWeekOfYear.Jan1));
< AssertEquals("#DP07", 1, DateAndTime.DatePart(DateInterval.WeekOfYear, dtJan4, FirstDayOfWeek.System, FirstWeekOfYear.System));
< AssertEquals("#DP08", 5, DateAndTime.DatePart(DateInterval.Weekday, dtJan4, FirstDayOfWeek.Friday, FirstWeekOfYear.FirstFourDays));
< AssertEquals("#DP09", 5, DateAndTime.DatePart(DateInterval.Weekday, dtJan4, FirstDayOfWeek.Saturday, FirstWeekOfYear.FirstFourDays));
< AssertEquals("#DP10", 5, DateAndTime.DatePart(DateInterval.Weekday, dtJan4, FirstDayOfWeek.Sunday, FirstWeekOfYear.FirstFourDays));
< AssertEquals("#DP11", 5, DateAndTime.DatePart(DateInterval.Weekday, dtJan4, FirstDayOfWeek.Monday, FirstWeekOfYear.FirstFourDays));
< AssertEquals("#DP12", 5, DateAndTime.DatePart(DateInterval.Weekday, dtJan4, FirstDayOfWeek.Tuesday, FirstWeekOfYear.FirstFourDays));
< AssertEquals("#DP13", 5, DateAndTime.DatePart(DateInterval.Weekday, dtJan4, FirstDayOfWeek.Wednesday, FirstWeekOfYear.FirstFourDays));
< AssertEquals("#DP14", 5, DateAndTime.DatePart(DateInterval.Weekday, dtJan4, FirstDayOfWeek.Thursday, FirstWeekOfYear.FirstFourDays));
< AssertEquals("#DP15", 5, DateAndTime.DatePart(DateInterval.Weekday, dtJan4, FirstDayOfWeek.System, FirstWeekOfYear.FirstFourDays));
---
> Assertion.AssertEquals("#DP01", 2001, DateAndTime.DatePart(DateInterval.Year, dtJan4, FirstDayOfWeek.System, FirstWeekOfYear.System));
> Assertion.AssertEquals("#DP02", 1, DateAndTime.DatePart(DateInterval.Quarter, dtJan4, FirstDayOfWeek.System, FirstWeekOfYear.System));
> Assertion.AssertEquals("#DP03", 1, DateAndTime.DatePart(DateInterval.Month, dtJan4, FirstDayOfWeek.System, FirstWeekOfYear.System));
> Assertion.AssertEquals("#DP04", 1, DateAndTime.DatePart(DateInterval.WeekOfYear, dtJan4, FirstDayOfWeek.System, FirstWeekOfYear.FirstFourDays));
> Assertion.AssertEquals("#DP05", 53, DateAndTime.DatePart(DateInterval.WeekOfYear, dtJan4, FirstDayOfWeek.System, FirstWeekOfYear.FirstFullWeek));
> Assertion.AssertEquals("#DP06", 1, DateAndTime.DatePart(DateInterval.WeekOfYear, dtJan4, FirstDayOfWeek.System, FirstWeekOfYear.Jan1));
> Assertion.AssertEquals("#DP07", 1, DateAndTime.DatePart(DateInterval.WeekOfYear, dtJan4, FirstDayOfWeek.System, FirstWeekOfYear.System));
> Assertion.AssertEquals("#DP08", 5, DateAndTime.DatePart(DateInterval.Weekday, dtJan4, FirstDayOfWeek.Friday, FirstWeekOfYear.FirstFourDays));
> Assertion.AssertEquals("#DP09", 5, DateAndTime.DatePart(DateInterval.Weekday, dtJan4, FirstDayOfWeek.Saturday, FirstWeekOfYear.FirstFourDays));
> Assertion.AssertEquals("#DP10", 5, DateAndTime.DatePart(DateInterval.Weekday, dtJan4, FirstDayOfWeek.Sunday, FirstWeekOfYear.FirstFourDays));
> Assertion.AssertEquals("#DP11", 5, DateAndTime.DatePart(DateInterval.Weekday, dtJan4, FirstDayOfWeek.Monday, FirstWeekOfYear.FirstFourDays));
> Assertion.AssertEquals("#DP12", 5, DateAndTime.DatePart(DateInterval.Weekday, dtJan4, FirstDayOfWeek.Tuesday, FirstWeekOfYear.FirstFourDays));
> Assertion.AssertEquals("#DP13", 5, DateAndTime.DatePart(DateInterval.Weekday, dtJan4, FirstDayOfWeek.Wednesday, FirstWeekOfYear.FirstFourDays));
> Assertion.AssertEquals("#DP14", 5, DateAndTime.DatePart(DateInterval.Weekday, dtJan4, FirstDayOfWeek.Thursday, FirstWeekOfYear.FirstFourDays));
> Assertion.AssertEquals("#DP15", 5, DateAndTime.DatePart(DateInterval.Weekday, dtJan4, FirstDayOfWeek.System, FirstWeekOfYear.FirstFourDays));
235c246,248
< public void TestDateSerial () {
---
> [Test]
> public void DateSerial ()
> {
239c252
< AssertEquals("#DS01", dtJan4, dtSerial);
---
> Assertion.AssertEquals("#DS01", dtJan4, dtSerial);
242c255,257
< public void TestTimeSerial () {
---
> [Test]
> public void TimeSerial ()
> {
249c264
< AssertEquals("#TS01", e.GetType(), typeof(ArgumentOutOfRangeException));
---
> Assertion.AssertEquals("#TS01", e.GetType(), typeof(ArgumentOutOfRangeException));
252c267
< AssertEquals("#TS02", true, caughtException);
---
> Assertion.AssertEquals("#TS02", true, caughtException);
254c269
< AssertEquals("#TS03", new DateTime(1, 1, 1, 1, 1, 1), DateAndTime.TimeSerial(1, 1, 1));
---
> Assertion.AssertEquals("#TS03", new DateTime(1, 1, 1, 1, 1, 1), DateAndTime.TimeSerial(1, 1, 1));
258c273,275
< public void TestDateValue () {
---
> [Test]
> public void DateValue ()
> {
266c283
< Fail ("Unexpected exception:" + e);
---
> Assertion.Fail ("Unexpected exception:" + e);
268c285
< AssertEquals("#DV03", new DateTime(1969, 2, 12), DateAndTime.DateValue("February 12, 1969"));
---
> Assertion.AssertEquals("#DV03", new DateTime(1969, 2, 12), DateAndTime.DateValue("February 12, 1969"));
271c288,290
< public void TestTimeValue () {
---
> [Test]
> public void TimeValue ()
> {
279c298
< Fail ("Unexpected exception:" + e);
---
> Assertion.Fail ("Unexpected exception:" + e);
281c300
< AssertEquals("#TV03", new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, 16, 35, 17), DateAndTime.TimeValue("4:35:17 PM"));
---
> Assertion.AssertEquals("#TV03", new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, 16, 35, 17), DateAndTime.TimeValue("4:35:17 PM"));
284c303,305
< public void TestYear () {
---
> [Test]
> public void Year ()
> {
286c307
< AssertEquals("#Y01", jan1.Year, DateAndTime.Year(jan1));
---
> Assertion.AssertEquals("#Y01", jan1.Year, DateAndTime.Year(jan1));
289c310,312
< public void TestMonth () {
---
> [Test]
> public void Month ()
> {
291c314
< AssertEquals("#MO01", jan1.Month, DateAndTime.Month(jan1));
---
> Assertion.AssertEquals("#MO01", jan1.Month, DateAndTime.Month(jan1));
294c317,319
< public void TestDay () {
---
> [Test]
> public void Day ()
> {
296c321
< AssertEquals("#D01", jan1.Day, DateAndTime.Day(jan1));
---
> Assertion.AssertEquals("#D01", jan1.Day, DateAndTime.Day(jan1));
299c324,326
< public void TestHour () {
---
> [Test]
> public void Hour ()
> {
301c328
< AssertEquals("#H01", jan1.Hour, DateAndTime.Hour(jan1));
---
> Assertion.AssertEquals("#H01", jan1.Hour, DateAndTime.Hour(jan1));
304c331,333
< public void TestMinute () {
---
> [Test]
> public void Minute ()
> {
306c335
< AssertEquals("#MI01", jan1.Minute, DateAndTime.Minute(jan1));
---
> Assertion.AssertEquals("#MI01", jan1.Minute, DateAndTime.Minute(jan1));
309c338,340
< public void TestSecond () {
---
> [Test]
> public void Second ()
> {
311c342
< AssertEquals("#S01", jan1.Second, DateAndTime.Second(jan1));
---
> Assertion.AssertEquals("#S01", jan1.Second, DateAndTime.Second(jan1));
314c345,347
< public void TestWeekday () {
---
> [Test]
> public void Weekday ()
> {
316c349
< AssertEquals("#W01", (int)jan1.DayOfWeek + 1, DateAndTime.Weekday(jan1, FirstDayOfWeek.System));
---
> Assertion.AssertEquals("#W01", (int)jan1.DayOfWeek + 1, DateAndTime.Weekday(jan1, FirstDayOfWeek.System));
319c352,354
< public void TestMonthName () {
---
> [Test]
> public void MonthName ()
> {
321c356
< AssertEquals("#MN01", CultureInfo.CurrentCulture.DateTimeFormat.GetAbbreviatedMonthName(jan1.Month),
---
> Assertion.AssertEquals("#MN01", CultureInfo.CurrentCulture.DateTimeFormat.GetAbbreviatedMonthName(jan1.Month),
323c358
< AssertEquals("#MN02", CultureInfo.CurrentCulture.DateTimeFormat.GetMonthName(jan1.Month),
---
> Assertion.AssertEquals("#MN02", CultureInfo.CurrentCulture.DateTimeFormat.GetMonthName(jan1.Month),
332c367
< AssertEquals("#MN03", typeof(ArgumentException), e.GetType());
---
> Assertion.AssertEquals("#MN03", typeof(ArgumentException), e.GetType());
335c370
< AssertEquals("#MN04", true, caughtException);
---
> Assertion.AssertEquals("#MN04", true, caughtException);
343c378
< AssertEquals("#MN05", typeof(ArgumentException), e.GetType());
---
> Assertion.AssertEquals("#MN05", typeof(ArgumentException), e.GetType());
346c381
< AssertEquals("#MN06", true, caughtException);
---
> Assertion.AssertEquals("#MN06", true, caughtException);
348c383
< //AssertEquals("#MN07", "", DateAndTime.MonthName(13, false));
---
> //Assertion.AssertEquals("#MN07", "", DateAndTime.MonthName(13, false));
351c386,388
< public void TestWeekdayName () {
---
> [Test]
> public void WeekdayName ()
> {
353c390
< AssertEquals("#WN01", "Tue",
---
> Assertion.AssertEquals("#WN01", "Tue",
355c392
< AssertEquals("#WN02", "Tuesday",
---
> Assertion.AssertEquals("#WN02", "Tuesday",
364c401
< AssertEquals("#WN03", typeof(ArgumentException), e.GetType());
---
> Assertion.AssertEquals("#WN03", typeof(ArgumentException), e.GetType());
367c404
< AssertEquals("#WN04", true, caughtException);
---
> Assertion.AssertEquals("#WN04", true, caughtException);
375c412
< AssertEquals("#WN05", typeof(ArgumentException), e.GetType());
---
> Assertion.AssertEquals("#WN05", typeof(ArgumentException), e.GetType());
378c415
< AssertEquals("#WN06", true, caughtException);
---
> Assertion.AssertEquals("#WN06", true, caughtException);
380c417
< AssertEquals("#WN07", "Tuesday", DateAndTime.WeekdayName((int)jan1.DayOfWeek + 1, false, FirstDayOfWeek.System));
---
> Assertion.AssertEquals("#WN07", "Tuesday", DateAndTime.WeekdayName((int)jan1.DayOfWeek + 1, false, FirstDayOfWeek.System));
382,386d418
<
<
<
<
<
-------------- next part --------------
A non-text attachment was scrubbed...
Name: makefile.gnu
Type: text/x-makefile
Size: 629 bytes
Desc: not available
Url : http://lists.ximian.com/pipermail/mono-devel-list/attachments/20030310/68c99061/attachment.bin
-------------- next part --------------
CollectionTest.cs
ConversionTest.cs
DateAndTimeTest.cs
More information about the Mono-devel-list
mailing list