2003-05-29 Nick Drochak <[email protected]>

	* BinaryReaderTest.cs: fix my oversight
	* BinaryWriterTest.cs: cleanups
	* BufferedStreamTest.cs: cleanups
	* DirectoryInfoTest.cs: cleanups
	* DirectoryTest.cs: cleanups
	* FileStreamTest.cs: cleanups

svn path=/trunk/mcs/; revision=14994

mcs/class/corlib/Test/System.IO/BinaryReaderTest.cs

@@ -12,18 +12,12 @@ using System.Text;
 
 namespace MonoTests.System.IO
 {
+	[TestFixture]
 	public class BinaryReaderTest : Assertion
 	{		
 		static string TempFolder = Path.Combine (Path.GetTempPath (), "MonoTests.System.IO.Tests");
-		private string _codeFileName = TempFolder + Path.DirectorySeparatorChar + "AFile.txt";
+		static string _codeFileName = TempFolder + Path.DirectorySeparatorChar + "AFile.txt";
 			
-                [TearDown]
-		public void TearDown ()
-		{
-			if (Directory.Exists (TempFolder))
-				Directory.Delete (TempFolder, true);
-		}
-
                 [SetUp]
 		public void SetUp() {
 			if (Directory.Exists (TempFolder))
@@ -33,6 +27,13 @@ namespace MonoTests.System.IO
 				File.Create (_codeFileName).Close ();
                 }
 
+                [TearDown]
+		public void TearDown ()
+		{
+			if (Directory.Exists (TempFolder))
+				Directory.Delete (TempFolder, true);
+		}
+
 		public void TestCtor1() 
 		{
 			{

mcs/class/corlib/Test/System.IO/BinaryWriterTest.cs

@@ -15,7 +15,7 @@ using System;
 namespace MonoTests.System.IO {
 
 [TestFixture]
-public class BinaryWriterTest {
+public class BinaryWriterTest : Assertion {
 	
 	
 	string TempFolder = Path.Combine (Path.GetTempPath (), "MonoTests.System.IO.Tests");
@@ -39,14 +39,14 @@ public class BinaryWriterTest {
 	{
 		MemoryStream stream = new MemoryStream ();
 		BinaryWriter writer = new BinaryWriter (stream);
-		Assertion.AssertEquals ("test#01", true, writer.BaseStream.CanRead);
-		Assertion.AssertEquals ("test#02", true, writer.BaseStream.CanSeek);
-		Assertion.AssertEquals ("test#03", true, writer.BaseStream.CanWrite);
+		AssertEquals ("test#01", true, writer.BaseStream.CanRead);
+		AssertEquals ("test#02", true, writer.BaseStream.CanSeek);
+		AssertEquals ("test#03", true, writer.BaseStream.CanWrite);
 		
 		writer = new BinaryWriter (stream, new ASCIIEncoding ());
-		Assertion.AssertEquals ("test#04", true, writer.BaseStream.CanRead);
-		Assertion.AssertEquals ("test#05", true, writer.BaseStream.CanSeek);
-		Assertion.AssertEquals ("test#06", true, writer.BaseStream.CanWrite);			
+		AssertEquals ("test#04", true, writer.BaseStream.CanRead);
+		AssertEquals ("test#05", true, writer.BaseStream.CanSeek);
+		AssertEquals ("test#06", true, writer.BaseStream.CanWrite);			
 		
 	}
 
@@ -87,7 +87,7 @@ public class BinaryWriterTest {
 	/// Throws an exception if stream does not support writing
 	/// </summary>
 	[Test]
-	[ExpectedException(typeof(ArgumentException))]
+	[ExpectedException(typeof(IOException))]
 	public void CtorArgumentExceptionStreamCannotWrite ()
 	{
 		string path = TempFolder + "/BinaryWriterTest.1";
@@ -107,55 +107,55 @@ public class BinaryWriterTest {
 		writer.Write ("t*st");
 		
 		byte [] bytes = stream.GetBuffer ();
-		Assertion.AssertEquals ("test#01", 4, bytes [0]);
-		Assertion.AssertEquals ("test#02", 116, bytes [1]);
-		Assertion.AssertEquals ("test#03", 42, bytes [2]);
-		Assertion.AssertEquals ("test#04", 115, bytes [3]);
-		Assertion.AssertEquals ("test#05", 116, bytes [4]);
-		Assertion.AssertEquals ("test#06", 0, bytes [5]);
+		AssertEquals ("test#01", 4, bytes [0]);
+		AssertEquals ("test#02", 116, bytes [1]);
+		AssertEquals ("test#03", 42, bytes [2]);
+		AssertEquals ("test#04", 115, bytes [3]);
+		AssertEquals ("test#05", 116, bytes [4]);
+		AssertEquals ("test#06", 0, bytes [5]);
 		
 		stream = new MemoryStream ();
 		writer = new BinaryWriter (stream, new UnicodeEncoding ());
 		writer.Write ("t*st");
 		
 		bytes = stream.GetBuffer ();
-		Assertion.AssertEquals ("test#07", 8, bytes [0]);
-		Assertion.AssertEquals ("test#08", 116, bytes [1]);
-		Assertion.AssertEquals ("test#09", 0, bytes [2]);
-		Assertion.AssertEquals ("test#10", 42, bytes [3]);
-		Assertion.AssertEquals ("test#11", 0, bytes [4]);
-		Assertion.AssertEquals ("test#12", 115, bytes [5]);
-		Assertion.AssertEquals ("test#13", 0, bytes [6]);
-		Assertion.AssertEquals ("test#14", 116, bytes [7]);
-		Assertion.AssertEquals ("test#15", 0, bytes [8]);
+		AssertEquals ("test#07", 8, bytes [0]);
+		AssertEquals ("test#08", 116, bytes [1]);
+		AssertEquals ("test#09", 0, bytes [2]);
+		AssertEquals ("test#10", 42, bytes [3]);
+		AssertEquals ("test#11", 0, bytes [4]);
+		AssertEquals ("test#12", 115, bytes [5]);
+		AssertEquals ("test#13", 0, bytes [6]);
+		AssertEquals ("test#14", 116, bytes [7]);
+		AssertEquals ("test#15", 0, bytes [8]);
 
 		stream = new MemoryStream ();
 		writer = new BinaryWriter (stream, new UTF7Encoding ());
 		writer.Write ("t*st");
 		
 		bytes = stream.GetBuffer ();
-		Assertion.AssertEquals ("test#16", 8, bytes [0]);
-		Assertion.AssertEquals ("test#17", 116, bytes [1]);
-		Assertion.AssertEquals ("test#18", 43, bytes [2]);
-		Assertion.AssertEquals ("test#19", 65, bytes [3]);
-		Assertion.AssertEquals ("test#21", 67, bytes [4]);
-		Assertion.AssertEquals ("test#22", 111, bytes [5]);
-		Assertion.AssertEquals ("test#23", 45, bytes [6]);
-		Assertion.AssertEquals ("test#24", 115, bytes [7]);
-		Assertion.AssertEquals ("test#25", 116, bytes [8]);
-		Assertion.AssertEquals ("test#26", 0, bytes [9]);
-		Assertion.AssertEquals ("test#27", 0, bytes [10]);		
+		AssertEquals ("test#16", 8, bytes [0]);
+		AssertEquals ("test#17", 116, bytes [1]);
+		AssertEquals ("test#18", 43, bytes [2]);
+		AssertEquals ("test#19", 65, bytes [3]);
+		AssertEquals ("test#21", 67, bytes [4]);
+		AssertEquals ("test#22", 111, bytes [5]);
+		AssertEquals ("test#23", 45, bytes [6]);
+		AssertEquals ("test#24", 115, bytes [7]);
+		AssertEquals ("test#25", 116, bytes [8]);
+		AssertEquals ("test#26", 0, bytes [9]);
+		AssertEquals ("test#27", 0, bytes [10]);		
 
 		stream = new MemoryStream ();
 		writer = new BinaryWriter (stream, new ASCIIEncoding ());
 		writer.Write ("t*st");
 		bytes = stream.GetBuffer ();
-		Assertion.AssertEquals ("test#28", 4, bytes [0]);
-		Assertion.AssertEquals ("test#29", 116, bytes [1]);
-		Assertion.AssertEquals ("test#30", 42, bytes [2]);
-		Assertion.AssertEquals ("test#31", 115, bytes [3]);
-		Assertion.AssertEquals ("test#32", 116, bytes [4]);
-		Assertion.AssertEquals ("test#33", 0, bytes [5]);
+		AssertEquals ("test#28", 4, bytes [0]);
+		AssertEquals ("test#29", 116, bytes [1]);
+		AssertEquals ("test#30", 42, bytes [2]);
+		AssertEquals ("test#31", 115, bytes [3]);
+		AssertEquals ("test#32", 116, bytes [4]);
+		AssertEquals ("test#33", 0, bytes [5]);
 	}
 	
 	[Test]
@@ -194,9 +194,9 @@ public class BinaryWriterTest {
 		MemoryStream stream = new MemoryStream ();
 		BinaryWriter writer = new BinaryWriter (stream, new ASCIIEncoding ());
 		writer.Close ();
-		Assertion.AssertEquals ("test#01", false, writer.BaseStream.CanRead);
-		Assertion.AssertEquals ("test#01", false, writer.BaseStream.CanWrite);
-		Assertion.AssertEquals ("test#01", false, writer.BaseStream.CanSeek);		
+		AssertEquals ("test#01", false, writer.BaseStream.CanRead);
+		AssertEquals ("test#01", false, writer.BaseStream.CanWrite);
+		AssertEquals ("test#01", false, writer.BaseStream.CanSeek);		
 	}
 	
 	[Test]
@@ -216,21 +216,21 @@ public class BinaryWriterTest {
 		writer.Write ("-");
 		
 		byte [] bytes = stream.GetBuffer ();
-		Assertion.AssertEquals ("test#01", 512, bytes.Length);
-		Assertion.AssertEquals ("test#02", 4, bytes [0]);
-		Assertion.AssertEquals ("test#03", 84, bytes [1]);
-		Assertion.AssertEquals ("test#04", 1, bytes [2]);
-		Assertion.AssertEquals ("test#05", 45, bytes [3]);
-		Assertion.AssertEquals ("test#06", 116, bytes [4]);
-		Assertion.AssertEquals ("test#07", 0, bytes [5]);
-		Assertion.AssertEquals ("test#08", 0, bytes [6]);
-		Assertion.AssertEquals ("test#09", 0, bytes [7]);
-		Assertion.AssertEquals ("test#10", 1, bytes [8]);
-		Assertion.AssertEquals ("test#11", 45, bytes [9]);
-		Assertion.AssertEquals ("test#12", 0, bytes [10]);
-		Assertion.AssertEquals ("test#13", 0, bytes [11]);
-		Assertion.AssertEquals ("test#14", 0, bytes [12]);
-		Assertion.AssertEquals ("test#15", 1, bytes [400]);				
+		AssertEquals ("test#01", 512, bytes.Length);
+		AssertEquals ("test#02", 4, bytes [0]);
+		AssertEquals ("test#03", 84, bytes [1]);
+		AssertEquals ("test#04", 1, bytes [2]);
+		AssertEquals ("test#05", 45, bytes [3]);
+		AssertEquals ("test#06", 116, bytes [4]);
+		AssertEquals ("test#07", 0, bytes [5]);
+		AssertEquals ("test#08", 0, bytes [6]);
+		AssertEquals ("test#09", 0, bytes [7]);
+		AssertEquals ("test#10", 1, bytes [8]);
+		AssertEquals ("test#11", 45, bytes [9]);
+		AssertEquals ("test#12", 0, bytes [10]);
+		AssertEquals ("test#13", 0, bytes [11]);
+		AssertEquals ("test#14", 0, bytes [12]);
+		AssertEquals ("test#15", 1, bytes [400]);				
 	}
 	
 	[Test]
@@ -255,21 +255,21 @@ public class BinaryWriterTest {
 
 		byte [] bytes = stream.GetBuffer ();
 		
-		Assertion.AssertEquals ("test#01", 256, bytes.Length);
-		Assertion.AssertEquals ("test#02", 109, bytes [0]);
-		Assertion.AssertEquals ("test#03", 111, bytes [1]);
-		Assertion.AssertEquals ("test#04", 110, bytes [2]);
-		Assertion.AssertEquals ("test#05", 111, bytes [3]);
-		Assertion.AssertEquals ("test#06", 58, bytes [4]);
-		Assertion.AssertEquals ("test#07", 58, bytes [5]);
-		Assertion.AssertEquals ("test#08", 58, bytes [6]);
-		Assertion.AssertEquals ("test#09", 58, bytes [7]);
-		Assertion.AssertEquals ("test#10", 79, bytes [8]);
-		Assertion.AssertEquals ("test#11", 78, bytes [9]);
-		Assertion.AssertEquals ("test#12", 79, bytes [10]);
-		Assertion.AssertEquals ("test#13", 77, bytes [11]);
-		Assertion.AssertEquals ("test#14", 0, bytes [12]);
-		Assertion.AssertEquals ("test#15", 0, bytes [13]);		
+		AssertEquals ("test#01", 256, bytes.Length);
+		AssertEquals ("test#02", 109, bytes [0]);
+		AssertEquals ("test#03", 111, bytes [1]);
+		AssertEquals ("test#04", 110, bytes [2]);
+		AssertEquals ("test#05", 111, bytes [3]);
+		AssertEquals ("test#06", 58, bytes [4]);
+		AssertEquals ("test#07", 58, bytes [5]);
+		AssertEquals ("test#08", 58, bytes [6]);
+		AssertEquals ("test#09", 58, bytes [7]);
+		AssertEquals ("test#10", 79, bytes [8]);
+		AssertEquals ("test#11", 78, bytes [9]);
+		AssertEquals ("test#12", 79, bytes [10]);
+		AssertEquals ("test#13", 77, bytes [11]);
+		AssertEquals ("test#14", 0, bytes [12]);
+		AssertEquals ("test#15", 0, bytes [13]);		
 	}
 	
 	[Test]
@@ -282,21 +282,21 @@ public class BinaryWriterTest {
 		writer.Write (new byte [] {6, 5, 4, 3, 2, 1});
 
 		byte [] bytes = stream.GetBuffer ();		
-		Assertion.AssertEquals ("test#01", 256, bytes.Length);
-		Assertion.AssertEquals ("test#02", 1, bytes [0]);
-		Assertion.AssertEquals ("test#03", 2, bytes [1]);
-		Assertion.AssertEquals ("test#04", 3, bytes [2]);
-		Assertion.AssertEquals ("test#05", 4, bytes [3]);
-		Assertion.AssertEquals ("test#06", 5, bytes [4]);
-		Assertion.AssertEquals ("test#07", 6, bytes [5]);
-		Assertion.AssertEquals ("test#08", 6, bytes [6]);
-		Assertion.AssertEquals ("test#09", 5, bytes [7]);
-		Assertion.AssertEquals ("test#10", 4, bytes [8]);
-		Assertion.AssertEquals ("test#11", 3, bytes [9]);
-		Assertion.AssertEquals ("test#12", 2, bytes [10]);
-		Assertion.AssertEquals ("test#13", 1, bytes [11]);
-		Assertion.AssertEquals ("test#14", 0, bytes [12]);
-		Assertion.AssertEquals ("test#15", 0, bytes [13]);		
+		AssertEquals ("test#01", 256, bytes.Length);
+		AssertEquals ("test#02", 1, bytes [0]);
+		AssertEquals ("test#03", 2, bytes [1]);
+		AssertEquals ("test#04", 3, bytes [2]);
+		AssertEquals ("test#05", 4, bytes [3]);
+		AssertEquals ("test#06", 5, bytes [4]);
+		AssertEquals ("test#07", 6, bytes [5]);
+		AssertEquals ("test#08", 6, bytes [6]);
+		AssertEquals ("test#09", 5, bytes [7]);
+		AssertEquals ("test#10", 4, bytes [8]);
+		AssertEquals ("test#11", 3, bytes [9]);
+		AssertEquals ("test#12", 2, bytes [10]);
+		AssertEquals ("test#13", 1, bytes [11]);
+		AssertEquals ("test#14", 0, bytes [12]);
+		AssertEquals ("test#15", 0, bytes [13]);		
 		
 	}
 
@@ -312,31 +312,31 @@ public class BinaryWriterTest {
 		writer.Write (s);
 		byte [] bytes;
 		bytes = stream.GetBuffer ();
-		Assertion.AssertEquals ("test#01", 256, bytes.Length);
-		Assertion.AssertEquals ("test#02", 64, bytes [0]);
-		Assertion.AssertEquals ("test#03", 0, bytes [1]);
+		AssertEquals ("test#01", 256, bytes.Length);
+		AssertEquals ("test#02", 64, bytes [0]);
+		AssertEquals ("test#03", 0, bytes [1]);
 		
 		writer.Write (i);
 		bytes = stream.GetBuffer ();
-		Assertion.AssertEquals ("test#04", 256, bytes.Length);
-		Assertion.AssertEquals ("test#05", 64, bytes [0]);
-		Assertion.AssertEquals ("test#06", 0, bytes [1]);
-		Assertion.AssertEquals ("test#07", 64, bytes [2]);
-		Assertion.AssertEquals ("test#08", 109, bytes [3]);
-		Assertion.AssertEquals ("test#09", 218, bytes [4]);
-		Assertion.AssertEquals ("test#10", 3, bytes [5]);
-		Assertion.AssertEquals ("test#11", 0, bytes [6]);
+		AssertEquals ("test#04", 256, bytes.Length);
+		AssertEquals ("test#05", 64, bytes [0]);
+		AssertEquals ("test#06", 0, bytes [1]);
+		AssertEquals ("test#07", 64, bytes [2]);
+		AssertEquals ("test#08", 109, bytes [3]);
+		AssertEquals ("test#09", 218, bytes [4]);
+		AssertEquals ("test#10", 3, bytes [5]);
+		AssertEquals ("test#11", 0, bytes [6]);
 
 		writer.Write (l);
 		bytes = stream.GetBuffer ();
-		Assertion.AssertEquals ("test#12", 256, bytes.Length);
-		Assertion.AssertEquals ("test#13", 255, bytes [6]);
-		Assertion.AssertEquals ("test#14", 159, bytes [7]);
-		Assertion.AssertEquals ("test#15", 114, bytes [8]);
-		Assertion.AssertEquals ("test#16", 78, bytes [9]);
-		Assertion.AssertEquals ("test#17", 24, bytes [10]);
-		Assertion.AssertEquals ("test#18", 9, bytes [11]);
-		Assertion.AssertEquals ("test#19", 0, bytes [12]);
+		AssertEquals ("test#12", 256, bytes.Length);
+		AssertEquals ("test#13", 255, bytes [6]);
+		AssertEquals ("test#14", 159, bytes [7]);
+		AssertEquals ("test#15", 114, bytes [8]);
+		AssertEquals ("test#16", 78, bytes [9]);
+		AssertEquals ("test#17", 24, bytes [10]);
+		AssertEquals ("test#18", 9, bytes [11]);
+		AssertEquals ("test#19", 0, bytes [12]);
 	}
 	
 	[Test]
@@ -352,54 +352,54 @@ public class BinaryWriterTest {
 		writer.Write (d2);
 		byte [] bytes = stream.GetBuffer ();
 		
-		Assertion.AssertEquals ("test#01", 256, bytes.Length);
-		Assertion.AssertEquals ("test#02", 192, bytes [0]);
-		Assertion.AssertEquals ("test#03", 18, bytes [1]);
-		Assertion.AssertEquals ("test#04", 151, bytes [2]);
-		Assertion.AssertEquals ("test#05", 95, bytes [3]);
-		Assertion.AssertEquals ("test#06", 209, bytes [4]);
-		Assertion.AssertEquals ("test#07", 20, bytes [5]);
-		Assertion.AssertEquals ("test#08", 7, bytes [6]);
-		Assertion.AssertEquals ("test#09", 0, bytes [7]);
-		Assertion.AssertEquals ("test#10", 0, bytes [8]);
-		Assertion.AssertEquals ("test#11", 0, bytes [9]);
-		Assertion.AssertEquals ("test#12", 0, bytes [10]);
-		Assertion.AssertEquals ("test#13", 0, bytes [11]);
-		Assertion.AssertEquals ("test#14", 0, bytes [12]);
-		Assertion.AssertEquals ("test#15", 0, bytes [13]);
-		Assertion.AssertEquals ("test#16", 2, bytes [14]);
-		Assertion.AssertEquals ("test#17", 0, bytes [15]);
-		Assertion.AssertEquals ("test#18", 125, bytes [16]);
-		Assertion.AssertEquals ("test#19", 149, bytes [17]);
-		Assertion.AssertEquals ("test#20", 217, bytes [18]);
-		Assertion.AssertEquals ("test#21", 172, bytes [19]);
-		Assertion.AssertEquals ("test#22", 239, bytes [20]);
-		Assertion.AssertEquals ("test#23", 244, bytes [21]);
-		Assertion.AssertEquals ("test#24", 31, bytes [22]);
-		Assertion.AssertEquals ("test#25", 0, bytes [23]);
-		Assertion.AssertEquals ("test#26", 0, bytes [24]);
-		Assertion.AssertEquals ("test#27", 0, bytes [25]);
-		Assertion.AssertEquals ("test#28", 0, bytes [26]);		
-		Assertion.AssertEquals ("test#29", 0, bytes [27]);
-		Assertion.AssertEquals ("test#30", 0, bytes [28]);
-		Assertion.AssertEquals ("test#31", 0, bytes [29]);
-		Assertion.AssertEquals ("test#32", 0, bytes [30]);
-		Assertion.AssertEquals ("test#33", 128, bytes [31]);
-		Assertion.AssertEquals ("test#34", 0, bytes [32]);
-		Assertion.AssertEquals ("test#35", 0, bytes [33]);
-		Assertion.AssertEquals ("test#36", 0, bytes [34]);
-		Assertion.AssertEquals ("test#37", 0, bytes [35]);
-		Assertion.AssertEquals ("test#38", 0, bytes [36]);
-		Assertion.AssertEquals ("test#39", 0, bytes [37]);
-		Assertion.AssertEquals ("test#40", 0, bytes [38]);
-		Assertion.AssertEquals ("test#41", 0, bytes [39]);
-		Assertion.AssertEquals ("test#42", 0, bytes [40]);
-		Assertion.AssertEquals ("test#43", 0, bytes [41]);
-		Assertion.AssertEquals ("test#44", 0, bytes [42]);
-		Assertion.AssertEquals ("test#45", 0, bytes [43]);
-		Assertion.AssertEquals ("test#46", 0, bytes [44]);
-		Assertion.AssertEquals ("test#47", 0, bytes [45]);
-		Assertion.AssertEquals ("test#48", 0, bytes [46]);		
+		AssertEquals ("test#01", 256, bytes.Length);
+		AssertEquals ("test#02", 192, bytes [0]);
+		AssertEquals ("test#03", 18, bytes [1]);
+		AssertEquals ("test#04", 151, bytes [2]);
+		AssertEquals ("test#05", 95, bytes [3]);
+		AssertEquals ("test#06", 209, bytes [4]);
+		AssertEquals ("test#07", 20, bytes [5]);
+		AssertEquals ("test#08", 7, bytes [6]);
+		AssertEquals ("test#09", 0, bytes [7]);
+		AssertEquals ("test#10", 0, bytes [8]);
+		AssertEquals ("test#11", 0, bytes [9]);
+		AssertEquals ("test#12", 0, bytes [10]);
+		AssertEquals ("test#13", 0, bytes [11]);
+		AssertEquals ("test#14", 0, bytes [12]);
+		AssertEquals ("test#15", 0, bytes [13]);
+		AssertEquals ("test#16", 2, bytes [14]);
+		AssertEquals ("test#17", 0, bytes [15]);
+		AssertEquals ("test#18", 125, bytes [16]);
+		AssertEquals ("test#19", 149, bytes [17]);
+		AssertEquals ("test#20", 217, bytes [18]);
+		AssertEquals ("test#21", 172, bytes [19]);
+		AssertEquals ("test#22", 239, bytes [20]);
+		AssertEquals ("test#23", 244, bytes [21]);
+		AssertEquals ("test#24", 31, bytes [22]);
+		AssertEquals ("test#25", 0, bytes [23]);
+		AssertEquals ("test#26", 0, bytes [24]);
+		AssertEquals ("test#27", 0, bytes [25]);
+		AssertEquals ("test#28", 0, bytes [26]);		
+		AssertEquals ("test#29", 0, bytes [27]);
+		AssertEquals ("test#30", 0, bytes [28]);
+		AssertEquals ("test#31", 0, bytes [29]);
+		AssertEquals ("test#32", 0, bytes [30]);
+		AssertEquals ("test#33", 128, bytes [31]);
+		AssertEquals ("test#34", 0, bytes [32]);
+		AssertEquals ("test#35", 0, bytes [33]);
+		AssertEquals ("test#36", 0, bytes [34]);
+		AssertEquals ("test#37", 0, bytes [35]);
+		AssertEquals ("test#38", 0, bytes [36]);
+		AssertEquals ("test#39", 0, bytes [37]);
+		AssertEquals ("test#40", 0, bytes [38]);
+		AssertEquals ("test#41", 0, bytes [39]);
+		AssertEquals ("test#42", 0, bytes [40]);
+		AssertEquals ("test#43", 0, bytes [41]);
+		AssertEquals ("test#44", 0, bytes [42]);
+		AssertEquals ("test#45", 0, bytes [43]);
+		AssertEquals ("test#46", 0, bytes [44]);
+		AssertEquals ("test#47", 0, bytes [45]);
+		AssertEquals ("test#48", 0, bytes [46]);		
 	}
 	
 	[Test]
@@ -413,17 +413,17 @@ public class BinaryWriterTest {
 		writer.Write (f2);
 		
 		byte [] bytes = stream.GetBuffer ();
-		Assertion.AssertEquals ("test#01", 256, bytes.Length);
-		Assertion.AssertEquals ("test#02", 199, bytes [0]);
-		Assertion.AssertEquals ("test#03", 236, bytes [1]);
-		Assertion.AssertEquals ("test#04", 101, bytes [2]);
-		Assertion.AssertEquals ("test#05", 80, bytes [3]);
-		Assertion.AssertEquals ("test#06", 10, bytes [4]);
-		Assertion.AssertEquals ("test#07", 245, bytes [5]);
-		Assertion.AssertEquals ("test#08", 33, bytes [6]);
-		Assertion.AssertEquals ("test#09", 183, bytes [7]);
-		Assertion.AssertEquals ("test#10", 0, bytes [8]);
-		Assertion.AssertEquals ("test#11", 0, bytes [9]);		
+		AssertEquals ("test#01", 256, bytes.Length);
+		AssertEquals ("test#02", 199, bytes [0]);
+		AssertEquals ("test#03", 236, bytes [1]);
+		AssertEquals ("test#04", 101, bytes [2]);
+		AssertEquals ("test#05", 80, bytes [3]);
+		AssertEquals ("test#06", 10, bytes [4]);
+		AssertEquals ("test#07", 245, bytes [5]);
+		AssertEquals ("test#08", 33, bytes [6]);
+		AssertEquals ("test#09", 183, bytes [7]);
+		AssertEquals ("test#10", 0, bytes [8]);
+		AssertEquals ("test#11", 0, bytes [9]);		
 	}
 
 	[Test]
@@ -437,24 +437,24 @@ public class BinaryWriterTest {
 		writer.Write (d2);
 		
 		byte [] bytes = stream.GetBuffer ();
-		Assertion.AssertEquals ("test#01", 256, bytes.Length);
-		Assertion.AssertEquals ("test#02", 49, bytes [0]);
-		Assertion.AssertEquals ("test#03", 69, bytes [1]);
-		Assertion.AssertEquals ("test#04", 15, bytes [2]);
-		Assertion.AssertEquals ("test#05", 157, bytes [3]);
-		Assertion.AssertEquals ("test#06", 211, bytes [4]);
-		Assertion.AssertEquals ("test#07", 55, bytes [5]);
-		Assertion.AssertEquals ("test#08", 188, bytes [6]);
-		Assertion.AssertEquals ("test#09", 84, bytes [7]);
-		Assertion.AssertEquals ("test#10", 76, bytes [8]);
-		Assertion.AssertEquals ("test#11", 59, bytes [9]);
-		Assertion.AssertEquals ("test#12", 59, bytes [10]);
-		Assertion.AssertEquals ("test#13", 60, bytes [11]);
-		Assertion.AssertEquals ("test#14", 4, bytes [12]);
-		Assertion.AssertEquals ("test#15", 196, bytes [13]);
-		Assertion.AssertEquals ("test#16", 90, bytes [14]);
-		Assertion.AssertEquals ("test#17", 165, bytes [15]);
-		Assertion.AssertEquals ("test#18", 0, bytes [16]);
+		AssertEquals ("test#01", 256, bytes.Length);
+		AssertEquals ("test#02", 49, bytes [0]);
+		AssertEquals ("test#03", 69, bytes [1]);
+		AssertEquals ("test#04", 15, bytes [2]);
+		AssertEquals ("test#05", 157, bytes [3]);
+		AssertEquals ("test#06", 211, bytes [4]);
+		AssertEquals ("test#07", 55, bytes [5]);
+		AssertEquals ("test#08", 188, bytes [6]);
+		AssertEquals ("test#09", 84, bytes [7]);
+		AssertEquals ("test#10", 76, bytes [8]);
+		AssertEquals ("test#11", 59, bytes [9]);
+		AssertEquals ("test#12", 59, bytes [10]);
+		AssertEquals ("test#13", 60, bytes [11]);
+		AssertEquals ("test#14", 4, bytes [12]);
+		AssertEquals ("test#15", 196, bytes [13]);
+		AssertEquals ("test#16", 90, bytes [14]);
+		AssertEquals ("test#17", 165, bytes [15]);
+		AssertEquals ("test#18", 0, bytes [16]);
 	}
 	
 	[Test]
@@ -472,12 +472,12 @@ public class BinaryWriterTest {
 		writer.Write (c2);
 		
 		byte [] bytes = stream.GetBuffer ();
-		Assertion.AssertEquals ("test#01", 256, bytes.Length);
-		Assertion.AssertEquals ("test#02", 12, bytes [0]);
-		Assertion.AssertEquals ("test#03", 45, bytes [1]);
-		Assertion.AssertEquals ("test#04", 64, bytes [2]);
-		Assertion.AssertEquals ("test#05", 77, bytes [3]);
-		Assertion.AssertEquals ("test#06", 0, bytes [4]);
+		AssertEquals ("test#01", 256, bytes.Length);
+		AssertEquals ("test#02", 12, bytes [0]);
+		AssertEquals ("test#03", 45, bytes [1]);
+		AssertEquals ("test#04", 64, bytes [2]);
+		AssertEquals ("test#05", 77, bytes [3]);
+		AssertEquals ("test#06", 0, bytes [4]);
 	}
 	
 	[Test]
@@ -491,17 +491,17 @@ public class BinaryWriterTest {
 		writer.Write (s2);
 
 		byte [] bytes = stream.GetBuffer ();
-		Assertion.AssertEquals ("test#01", 256, bytes.Length);
-		Assertion.AssertEquals ("test#02", 3, bytes [0]);
-		Assertion.AssertEquals ("test#03", 97, bytes [1]);
-		Assertion.AssertEquals ("test#04", 98, bytes [2]);
-		Assertion.AssertEquals ("test#05", 99, bytes [3]);
-		Assertion.AssertEquals ("test#06", 4, bytes [4]);
-		Assertion.AssertEquals ("test#07", 68, bytes [5]);
-		Assertion.AssertEquals ("test#08", 101, bytes [6]);
-		Assertion.AssertEquals ("test#09", 70, bytes [7]);
-		Assertion.AssertEquals ("test#10", 10, bytes [8]);
-		Assertion.AssertEquals ("test#11", 0, bytes [9]);		
+		AssertEquals ("test#01", 256, bytes.Length);
+		AssertEquals ("test#02", 3, bytes [0]);
+		AssertEquals ("test#03", 97, bytes [1]);
+		AssertEquals ("test#04", 98, bytes [2]);
+		AssertEquals ("test#05", 99, bytes [3]);
+		AssertEquals ("test#06", 4, bytes [4]);
+		AssertEquals ("test#07", 68, bytes [5]);
+		AssertEquals ("test#08", 101, bytes [6]);
+		AssertEquals ("test#09", 70, bytes [7]);
+		AssertEquals ("test#10", 10, bytes [8]);
+		AssertEquals ("test#11", 0, bytes [9]);		
 	}
 
 	private void DeleteFile (string path)

mcs/class/corlib/Test/System.IO/BufferedStreamTest.cs

@@ -15,14 +15,8 @@ using System;
 namespace MonoTests.System.IO {
 
 [TestFixture]
-public class BufferedStreamTest {
+public class BufferedStreamTest : Assertion {
 	
-	
-	public BufferedStreamTest () 
-	{
-		;
-	}
-
 	private MemoryStream mem;
 	
         [SetUp]
@@ -45,11 +39,11 @@ public class BufferedStreamTest {
 		str.Write (new byte [] {1, 2, 3, 4, 5, 6}, 0, 6);
 		BufferedStream stream = new BufferedStream (str);
 		
-		Assertion.AssertEquals ("test#01", true, stream.CanRead);
-		Assertion.AssertEquals ("test#02", true, stream.CanSeek);
-		Assertion.AssertEquals ("test#03", true, stream.CanWrite);
-		Assertion.AssertEquals ("test#04", 6, stream.Length);
-		Assertion.AssertEquals ("test#05", 6, stream.Position);
+		AssertEquals ("test#01", true, stream.CanRead);
+		AssertEquals ("test#02", true, stream.CanSeek);
+		AssertEquals ("test#03", true, stream.CanWrite);
+		AssertEquals ("test#04", 6, stream.Length);
+		AssertEquals ("test#05", 6, stream.Position);
 		
 		string path = Path.GetTempFileName ();
 		if (File.Exists (path))
@@ -57,11 +51,11 @@ public class BufferedStreamTest {
 		
 		FileStream file = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Write);
 		stream = new BufferedStream (file);		
-		Assertion.AssertEquals ("test#06", false, stream.CanRead);
-		Assertion.AssertEquals ("test#07", true, stream.CanSeek);
-		Assertion.AssertEquals ("test#08", true, stream.CanWrite);
-		Assertion.AssertEquals ("test#09", 0, stream.Length);
-		Assertion.AssertEquals ("test#10", 0, stream.Position);		
+		AssertEquals ("test#06", false, stream.CanRead);
+		AssertEquals ("test#07", true, stream.CanSeek);
+		AssertEquals ("test#08", true, stream.CanWrite);
+		AssertEquals ("test#09", 0, stream.Length);
+		AssertEquals ("test#10", 0, stream.Position);		
 		file.Close ();
 		
 		if (File.Exists (path))
@@ -69,11 +63,11 @@ public class BufferedStreamTest {
 		
 		file = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Write);
 		stream = new BufferedStream (file, 12);		
-		Assertion.AssertEquals ("test#11", false, stream.CanRead);
-		Assertion.AssertEquals ("test#12", true, stream.CanSeek);
-		Assertion.AssertEquals ("test#13", true, stream.CanWrite);
-		Assertion.AssertEquals ("test#14", 0, stream.Length);
-		Assertion.AssertEquals ("test#15", 0, stream.Position);		
+		AssertEquals ("test#11", false, stream.CanRead);
+		AssertEquals ("test#12", true, stream.CanSeek);
+		AssertEquals ("test#13", true, stream.CanWrite);
+		AssertEquals ("test#14", 0, stream.Length);
+		AssertEquals ("test#15", 0, stream.Position);		
 
 		file.Close ();
 		if (File.Exists (path))
@@ -134,9 +128,9 @@ public class BufferedStreamTest {
 	{
 		BufferedStream stream = new BufferedStream (mem);
 		stream.Close ();
-		Assertion.AssertEquals ("test#01", false, stream.CanRead);
-		Assertion.AssertEquals ("test#02", false, stream.CanSeek);
-		Assertion.AssertEquals ("test#03", false, stream.CanWrite);
+		AssertEquals ("test#01", false, stream.CanRead);
+		AssertEquals ("test#02", false, stream.CanSeek);
+		AssertEquals ("test#03", false, stream.CanWrite);
 	}
 
 	[Test]	
@@ -192,28 +186,28 @@ public class BufferedStreamTest {
 
 		byte [] bytes = new byte [10];
 		stream.Read (bytes, 0, 3);
-		Assertion.AssertEquals ("test#01", 0, bytes [0]);
-		Assertion.AssertEquals ("test#02", 0, bytes [1]);
-		Assertion.AssertEquals ("test#03", 0, bytes [2]);
+		AssertEquals ("test#01", 0, bytes [0]);
+		AssertEquals ("test#02", 0, bytes [1]);
+		AssertEquals ("test#03", 0, bytes [2]);
 
 		stream.Seek (0, SeekOrigin.Begin);
 		stream.Read (bytes, 0, 3);
-		Assertion.AssertEquals ("test#04", 0, bytes [0]);
-		Assertion.AssertEquals ("test#05", 1, bytes [1]);
-		Assertion.AssertEquals ("test#06", 2, bytes [2]);
-		Assertion.AssertEquals ("test#07", 0, bytes [0]);		
+		AssertEquals ("test#04", 0, bytes [0]);
+		AssertEquals ("test#05", 1, bytes [1]);
+		AssertEquals ("test#06", 2, bytes [2]);
+		AssertEquals ("test#07", 0, bytes [0]);		
 
 		stream.Read (bytes, 5, 3);
-		Assertion.AssertEquals ("test#08", 3, bytes [5]);
-		Assertion.AssertEquals ("test#09", 4, bytes [6]);
-		Assertion.AssertEquals ("test#10", 5, bytes [7]);
-		Assertion.AssertEquals ("test#11", 0, bytes [8]);		
+		AssertEquals ("test#08", 3, bytes [5]);
+		AssertEquals ("test#09", 4, bytes [6]);
+		AssertEquals ("test#10", 5, bytes [7]);
+		AssertEquals ("test#11", 0, bytes [8]);		
 
 		stream.Read (bytes, 0, 10);
-		Assertion.AssertEquals ("test#12", 3, bytes [5]);
-		Assertion.AssertEquals ("test#13", 4, bytes [6]);
-		Assertion.AssertEquals ("test#14", 5, bytes [7]);
-		Assertion.AssertEquals ("test#15", 0, bytes [9]);				
+		AssertEquals ("test#12", 3, bytes [5]);
+		AssertEquals ("test#13", 4, bytes [6]);
+		AssertEquals ("test#14", 5, bytes [7]);
+		AssertEquals ("test#15", 0, bytes [9]);				
 	}
 	
 	[Test]
@@ -243,15 +237,15 @@ public class BufferedStreamTest {
 		mem.Write (new byte [] {0, 1, 2, 3, 4, 5, 6, 7}, 0, 8);
 		BufferedStream stream = new BufferedStream (mem);
 
-		Assertion.AssertEquals ("test#01", -1, stream.ReadByte ());
-		Assertion.AssertEquals ("test#02", -1, stream.ReadByte ());
-		Assertion.AssertEquals ("test#03", -1, stream.ReadByte ());
+		AssertEquals ("test#01", -1, stream.ReadByte ());
+		AssertEquals ("test#02", -1, stream.ReadByte ());
+		AssertEquals ("test#03", -1, stream.ReadByte ());
 
 		stream.Seek (0, SeekOrigin.Begin);
-		Assertion.AssertEquals ("test#04", 0, stream.ReadByte ());
-		Assertion.AssertEquals ("test#05", 1, stream.ReadByte ());
-		Assertion.AssertEquals ("test#06", 2, stream.ReadByte ());
-		Assertion.AssertEquals ("test#07", 3, stream.ReadByte ());		
+		AssertEquals ("test#04", 0, stream.ReadByte ());
+		AssertEquals ("test#05", 1, stream.ReadByte ());
+		AssertEquals ("test#06", 2, stream.ReadByte ());
+		AssertEquals ("test#07", 3, stream.ReadByte ());		
 	}
 	
 	[Test]
@@ -260,26 +254,26 @@ public class BufferedStreamTest {
 		BufferedStream stream = new BufferedStream (mem);
 		
 		stream.Write (new byte [] {0, 1, 2, 3, 4}, 0, 4);
-		Assertion.AssertEquals ("test#01", 4, stream.Length);
+		AssertEquals ("test#01", 4, stream.Length);
 		byte [] bytes = mem.GetBuffer ();
-		Assertion.AssertEquals ("test#02", 0, bytes [0]);
-		Assertion.AssertEquals ("test#03", 1, bytes [1]);
-		Assertion.AssertEquals ("test#04", 2, bytes [2]);
-		Assertion.AssertEquals ("test#05", 3, bytes [3]);
+		AssertEquals ("test#02", 0, bytes [0]);
+		AssertEquals ("test#03", 1, bytes [1]);
+		AssertEquals ("test#04", 2, bytes [2]);
+		AssertEquals ("test#05", 3, bytes [3]);
 
 		bytes = new byte [] {1, 4, 3};
 		stream.Write (bytes, 0, 3);
 		stream.Flush ();
 		bytes = mem.GetBuffer ();		
-		Assertion.AssertEquals ("test#06", 0, bytes [0]);
-		Assertion.AssertEquals ("test#07", 1, bytes [1]);
-		Assertion.AssertEquals ("test#08", 2, bytes [2]);
-		Assertion.AssertEquals ("test#09", 3, bytes [3]);
-		Assertion.AssertEquals ("test#10", 1, bytes [4]);
-		Assertion.AssertEquals ("test#11", 4, bytes [5]);
-		Assertion.AssertEquals ("test#10", 3, bytes [6]);
-		Assertion.AssertEquals ("test#11", 0, bytes [7]);
-		Assertion.AssertEquals ("test#12", 7, stream.Length);
+		AssertEquals ("test#06", 0, bytes [0]);
+		AssertEquals ("test#07", 1, bytes [1]);
+		AssertEquals ("test#08", 2, bytes [2]);
+		AssertEquals ("test#09", 3, bytes [3]);
+		AssertEquals ("test#10", 1, bytes [4]);
+		AssertEquals ("test#11", 4, bytes [5]);
+		AssertEquals ("test#10", 3, bytes [6]);
+		AssertEquals ("test#11", 0, bytes [7]);
+		AssertEquals ("test#12", 7, stream.Length);
 	}
 		
 	[Test]
@@ -306,11 +300,11 @@ public class BufferedStreamTest {
 		stream.WriteByte (2);
 		stream.WriteByte (3);
 		stream.Flush ();
-		Assertion.AssertEquals ("test#01", 256, mem.GetBuffer ().Length);
-		Assertion.AssertEquals ("test#02", 3, stream.Length);
-		Assertion.AssertEquals ("test#03", 1, mem.GetBuffer () [0]);
-		Assertion.AssertEquals ("test#04", 2, mem.GetBuffer () [1]);
-		Assertion.AssertEquals ("test#05", 3, mem.GetBuffer () [2]);		
+		AssertEquals ("test#01", 256, mem.GetBuffer ().Length);
+		AssertEquals ("test#02", 3, stream.Length);
+		AssertEquals ("test#03", 1, mem.GetBuffer () [0]);
+		AssertEquals ("test#04", 2, mem.GetBuffer () [1]);
+		AssertEquals ("test#05", 3, mem.GetBuffer () [2]);		
 	}
 	
 	[Test]
@@ -321,36 +315,36 @@ public class BufferedStreamTest {
 		stream.WriteByte (2);
 		
 		byte [] bytes = mem.GetBuffer ();
-		Assertion.AssertEquals ("test#01", 0, bytes.Length);
+		AssertEquals ("test#01", 0, bytes.Length);
 		stream.Flush ();
 		
 		bytes = mem.GetBuffer ();
-		Assertion.AssertEquals ("test#02", 256, bytes.Length);
-		Assertion.AssertEquals ("test#03", 1, bytes [0]);
-		Assertion.AssertEquals ("test#04", 2, bytes [1]);
+		AssertEquals ("test#02", 256, bytes.Length);
+		AssertEquals ("test#03", 1, bytes [0]);
+		AssertEquals ("test#04", 2, bytes [1]);
 		mem.Close ();
 		mem = new MemoryStream ();
 		bytes = new byte [] {0, 1, 2, 3, 4, 5};
 		stream = new BufferedStream (mem);
 		stream.Write (bytes, 0, 2);
-		Assertion.AssertEquals ("test#05", 2, stream.Length);
+		AssertEquals ("test#05", 2, stream.Length);
 		bytes = mem.GetBuffer ();
-		Assertion.AssertEquals ("test#06", 256, bytes.Length);
+		AssertEquals ("test#06", 256, bytes.Length);
 
-		Assertion.AssertEquals ("test#07", 0, bytes [0]);
-		Assertion.AssertEquals ("test#08", 1, bytes [1]);
+		AssertEquals ("test#07", 0, bytes [0]);
+		AssertEquals ("test#08", 1, bytes [1]);
 		
 		stream.Write (bytes, 0, 2);
 		
 		bytes = mem.GetBuffer ();
-		Assertion.AssertEquals ("test#09", 0, bytes [0]);
-		Assertion.AssertEquals ("test#10", 1, bytes [1]);
-		Assertion.AssertEquals ("test#11", 0, bytes [2]);
-		Assertion.AssertEquals ("test#12", 0, bytes [3]);
+		AssertEquals ("test#09", 0, bytes [0]);
+		AssertEquals ("test#10", 1, bytes [1]);
+		AssertEquals ("test#11", 0, bytes [2]);
+		AssertEquals ("test#12", 0, bytes [3]);
 		stream.Flush ();
 		bytes = mem.GetBuffer ();
-		Assertion.AssertEquals ("test#13", 0, bytes [2]);
-		Assertion.AssertEquals ("test#14", 1, bytes [3]);
+		AssertEquals ("test#13", 0, bytes [2]);
+		AssertEquals ("test#14", 1, bytes [3]);
 	}
 	
 	[Test]
@@ -359,16 +353,16 @@ public class BufferedStreamTest {
 		BufferedStream stream = new BufferedStream (mem);
 		stream.Write (new byte [] {0, 1, 2, 3, 4, 5}, 0, 6);
 		
-		Assertion.AssertEquals ("test#01", 6, stream.Position);
+		AssertEquals ("test#01", 6, stream.Position);
 		
 		stream.Seek (-5, SeekOrigin.End);		
-		Assertion.AssertEquals ("test#02", 1, stream.Position);
+		AssertEquals ("test#02", 1, stream.Position);
 		
 		stream.Seek (3, SeekOrigin.Current);
-		Assertion.AssertEquals ("test#03", 4, stream.Position);
+		AssertEquals ("test#03", 4, stream.Position);
 		
 		stream.Seek (300, SeekOrigin.Current);		
-		Assertion.AssertEquals ("test#04", 304, stream.Position);		
+		AssertEquals ("test#04", 304, stream.Position);		
 	}
 	
 	[Test]
@@ -385,12 +379,12 @@ public class BufferedStreamTest {
 		BufferedStream stream = new BufferedStream (mem);
 		stream.Write (new byte [] {0,1,2,3,4,5}, 0, 6);
 		
-		Assertion.AssertEquals ("test#01", 6, stream.Length);
+		AssertEquals ("test#01", 6, stream.Length);
 		stream.SetLength (60);
-		Assertion.AssertEquals ("test#02", 60, stream.Length);
+		AssertEquals ("test#02", 60, stream.Length);
 		
 		stream.SetLength (2);
-		Assertion.AssertEquals ("test#03", 2, stream.Length);	
+		AssertEquals ("test#03", 2, stream.Length);	
 	}
 	
 	 [Test]

mcs/class/corlib/Test/System.IO/ChangeLog

@@ -1,3 +1,13 @@
+2003-05-29  Nick Drochak <[email protected]>
+
+	* ms_run_test.sh: added .NET verion of helper script
+	* BinaryReaderTest.cs: fix my oversight
+	* BinaryWriterTest.cs: cleanups
+	* BufferedStreamTest.cs: cleanups
+	* DirectoryInfoTest.cs: cleanups
+	* DirectoryTest.cs: cleanups
+	* FileStreamTest.cs: cleanups
+
 2003-05-29  Nick Drochak <[email protected]>
 
 	* BinaryReaderTest.cs:

mcs/class/corlib/Test/System.IO/DirectoryInfoTest.cs

@@ -10,7 +10,7 @@ using System.IO;
 namespace MonoTests.System.IO
 {
 	[TestFixture]
-    	public class DirectoryInfoTest
+    	public class DirectoryInfoTest : Assertion
     	{
 		string TempFolder = Path.Combine (Path.GetTempPath (), "MonoTests.System.IO.Tests");
 
@@ -34,10 +34,10 @@ namespace MonoTests.System.IO
         		DeleteDir (path);
             	
         	    	FileInfo info = new FileInfo (path);
-        	    	Assertion.AssertEquals ("test#01", true, info.DirectoryName.EndsWith (".Tests"));
-        	    	Assertion.AssertEquals ("test#02", false, info.Exists);
-        	    	Assertion.AssertEquals ("test#03", ".Test", info.Extension);
-        	    	Assertion.AssertEquals ("test#05", "DIT.Ctr.Test", info.Name);            
+        	    	AssertEquals ("test#01", true, info.DirectoryName.EndsWith (".Tests"));
+        	    	AssertEquals ("test#02", false, info.Exists);
+        	    	AssertEquals ("test#03", ".Test", info.Extension);
+        	    	AssertEquals ("test#05", "DIT.Ctr.Test", info.Name);            
         	}
 
         	[Test]
@@ -80,12 +80,12 @@ namespace MonoTests.System.IO
             
             	try {
             	    	DirectoryInfo info = new DirectoryInfo (path);
-                	Assertion.AssertEquals ("test#01", false, info.Exists);
+                	AssertEquals ("test#01", false, info.Exists);
             
                 	Directory.CreateDirectory (path);
-                	Assertion.AssertEquals ("test#02", false, info.Exists);
+                	AssertEquals ("test#02", false, info.Exists);
                 	info = new DirectoryInfo (path);
-                	Assertion.AssertEquals ("test#03", true, info.Exists);            
+                	AssertEquals ("test#03", true, info.Exists);            
             	} finally {
                 	DeleteDir (path);
             	}
@@ -99,10 +99,10 @@ namespace MonoTests.System.IO
         		
         		try {
         			DirectoryInfo info = new DirectoryInfo (path);        			
-        			Assertion.AssertEquals ("test#01", "DIT.Name.Test", info.Name);
+        			AssertEquals ("test#01", "DIT.Name.Test", info.Name);
         			
         			info = Directory.CreateDirectory (path);
-        			Assertion.AssertEquals ("test#02", "DIT.Name.Test", info.Name);
+        			AssertEquals ("test#02", "DIT.Name.Test", info.Name);
         			
         			
         		} finally {
@@ -118,10 +118,10 @@ namespace MonoTests.System.IO
         		
         		try {
         			DirectoryInfo info = new DirectoryInfo (path);
-        			Assertion.AssertEquals ("test#01", "MonoTests.System.IO.Tests", info.Parent.Name);
+        			AssertEquals ("test#01", "MonoTests.System.IO.Tests", info.Parent.Name);
         			
         			info = Directory.CreateDirectory (path);
-        			Assertion.AssertEquals ("test#02", "MonoTests.System.IO.Tests", info.Parent.Name);
+        			AssertEquals ("test#02", "MonoTests.System.IO.Tests", info.Parent.Name);
         			        			
         		} finally {
         			DeleteDir (path);
@@ -136,11 +136,11 @@ namespace MonoTests.System.IO
             
             	try {
                 	DirectoryInfo info = new DirectoryInfo (path);
-                	Assertion.AssertEquals ("test#01", false, info.Exists);
+                	AssertEquals ("test#01", false, info.Exists);
                 	info.Create ();                
-                	Assertion.AssertEquals ("test#02", false, info.Exists);
+                	AssertEquals ("test#02", false, info.Exists);
                 	info = new DirectoryInfo (path);
-                	Assertion.AssertEquals ("test#03", true, info.Exists);
+                	AssertEquals ("test#03", true, info.Exists);
             	} finally {
                 	DeleteDir (path);
             	}
@@ -155,13 +155,13 @@ namespace MonoTests.System.IO
 			try {
 				Directory.CreateDirectory (path);
 				DirectoryInfo info = new DirectoryInfo (path);
-				Assertion.AssertEquals ("test#01", true, info.Exists);
+				AssertEquals ("test#01", true, info.Exists);
 				
 				info.Delete ();
-				Assertion.AssertEquals ("test#02", true, info.Exists);
+				AssertEquals ("test#02", true, info.Exists);
 				
 				info = new DirectoryInfo (path);
-				Assertion.AssertEquals ("test#03", false, info.Exists);
+				AssertEquals ("test#03", false, info.Exists);
 			} finally {
 				DeleteDir (path);
 			}
@@ -177,13 +177,13 @@ namespace MonoTests.System.IO
 				Directory.CreateDirectory (path);
 				File.Create (path + "/test").Close ();
 				DirectoryInfo info = new DirectoryInfo (path);
-				Assertion.AssertEquals ("test#01", true, info.Exists);
+				AssertEquals ("test#01", true, info.Exists);
 				
 				info.Delete (true);
-				Assertion.AssertEquals ("test#02", true, info.Exists);
+				AssertEquals ("test#02", true, info.Exists);
 				
 				info = new DirectoryInfo (path);
-				Assertion.AssertEquals ("test#03", false, info.Exists);
+				AssertEquals ("test#03", false, info.Exists);
 			} finally {
 				DeleteDir (path);
 			}
@@ -230,15 +230,15 @@ namespace MonoTests.System.IO
 			
 			try {
 				DirectoryInfo info = Directory.CreateDirectory (path);
-				Assertion.AssertEquals ("test#01", 0, info.GetDirectories ().Length);
+				AssertEquals ("test#01", 0, info.GetDirectories ().Length);
 				
 				Directory.CreateDirectory (path + "/" + "1");
 				Directory.CreateDirectory (path + "/" + "2");				
 				File.Create (path + "/" + "filetest").Close ();
-				Assertion.AssertEquals ("test#02", 2, info.GetDirectories ().Length);
+				AssertEquals ("test#02", 2, info.GetDirectories ().Length);
 				
 				Directory.Delete (path + "/" + 2);
-				Assertion.AssertEquals ("test#02", 1, info.GetDirectories ().Length);				
+				AssertEquals ("test#02", 1, info.GetDirectories ().Length);				
 				
 			} finally {
 				DeleteDir (path);
@@ -252,7 +252,7 @@ namespace MonoTests.System.IO
 			
 			try {
 				DirectoryInfo info = Directory.CreateDirectory (path);
-				Assertion.AssertEquals ("test#01", 0, info.GetDirectories ("*").Length);
+				AssertEquals ("test#01", 0, info.GetDirectories ("*").Length);
 				
 				Directory.CreateDirectory (path + "/" + "test120");
 				Directory.CreateDirectory (path + "/" + "test210");
@@ -260,13 +260,13 @@ namespace MonoTests.System.IO
 				Directory.CreateDirectory (path + "/" + "test220");
 				File.Create (path + "/" + "filetest").Close ();
 				
-				Assertion.AssertEquals ("test#02", 4, info.GetDirectories ("*").Length);
-				Assertion.AssertEquals ("test#03", 3, info.GetDirectories ("test*").Length);
-				Assertion.AssertEquals ("test#04", 2, info.GetDirectories ("test?20").Length);
-				Assertion.AssertEquals ("test#05", 0, info.GetDirectories ("test?").Length);
-				Assertion.AssertEquals ("test#06", 0, info.GetDirectories ("test[12]*").Length);
-				Assertion.AssertEquals ("test#07", 2, info.GetDirectories ("test2*0").Length);
-				Assertion.AssertEquals ("test#08", 4, info.GetDirectories ("*test*").Length);
+				AssertEquals ("test#02", 4, info.GetDirectories ("*").Length);
+				AssertEquals ("test#03", 3, info.GetDirectories ("test*").Length);
+				AssertEquals ("test#04", 2, info.GetDirectories ("test?20").Length);
+				AssertEquals ("test#05", 0, info.GetDirectories ("test?").Length);
+				AssertEquals ("test#06", 0, info.GetDirectories ("test[12]*").Length);
+				AssertEquals ("test#07", 2, info.GetDirectories ("test2*0").Length);
+				AssertEquals ("test#08", 4, info.GetDirectories ("*test*").Length);
 				
 			} finally {
 				DeleteDir (path);
@@ -326,11 +326,11 @@ namespace MonoTests.System.IO
 			
 			try {
 				DirectoryInfo info = Directory.CreateDirectory (path);
-				Assertion.AssertEquals ("test#01", 0, info.GetFiles ().Length);
+				AssertEquals ("test#01", 0, info.GetFiles ().Length);
 				File.Create (path + "/" + "file1").Close ();
 				File.Create (path + "/" + "file2").Close ();
 				Directory.CreateDirectory (path + "/" + "directory1");
-				Assertion.AssertEquals ("test#02", 2, info.GetFiles ().Length);
+				AssertEquals ("test#02", 2, info.GetFiles ().Length);
 				                        
 			} finally {
 				DeleteDir (path);
@@ -345,7 +345,7 @@ namespace MonoTests.System.IO
 			
 			try {
 				DirectoryInfo info = Directory.CreateDirectory (path);
-				Assertion.AssertEquals ("test#01", 0, info.GetFiles ("*").Length);
+				AssertEquals ("test#01", 0, info.GetFiles ("*").Length);
 				File.Create (path + "/" + "file120file").Close ();
 				File.Create (path + "/" + "file220file").Close ();
 				File.Create (path + "/" + "afile330file").Close ();
@@ -354,12 +354,12 @@ namespace MonoTests.System.IO
 				File.Create (path + "/" + "test.abcdef").Close ();				
 				Directory.CreateDirectory (path + "/" + "dir");
 				
-				Assertion.AssertEquals ("test#02", 6, info.GetFiles ("*").Length);
-				Assertion.AssertEquals ("test#03", 2, info.GetFiles ("file*file").Length);
-				Assertion.AssertEquals ("test#04", 3, info.GetFiles ("*file*").Length);
-				Assertion.AssertEquals ("test#05", 2, info.GetFiles ("file?20file").Length);
-				Assertion.AssertEquals ("test#07", 1, info.GetFiles ("*.abcd").Length);
-				Assertion.AssertEquals ("test#08", 2, info.GetFiles ("*.abcd*").Length);				                        
+				AssertEquals ("test#02", 6, info.GetFiles ("*").Length);
+				AssertEquals ("test#03", 2, info.GetFiles ("file*file").Length);
+				AssertEquals ("test#04", 3, info.GetFiles ("*file*").Length);
+				AssertEquals ("test#05", 2, info.GetFiles ("file?20file").Length);
+				AssertEquals ("test#07", 1, info.GetFiles ("*.abcd").Length);
+				AssertEquals ("test#08", 2, info.GetFiles ("*.abcd*").Length);				                        
 			} finally {
 				DeleteDir (path);
 			}
@@ -424,17 +424,17 @@ namespace MonoTests.System.IO
 				DirectoryInfo info1 = Directory.CreateDirectory (path1);
 				DirectoryInfo info2 = new DirectoryInfo (path2);
 				
-				Assertion.AssertEquals ("test#01", true, info1.Exists);
-				Assertion.AssertEquals ("test#02", false, info2.Exists);
+				AssertEquals ("test#01", true, info1.Exists);
+				AssertEquals ("test#02", false, info2.Exists);
 												
 				info1.MoveTo (path2);				
-				Assertion.AssertEquals ("test#03", true, info1.Exists);
-				Assertion.AssertEquals ("test#04", false, info2.Exists);
+				AssertEquals ("test#03", true, info1.Exists);
+				AssertEquals ("test#04", false, info2.Exists);
 				
 				info1 = new DirectoryInfo (path1);
 				info2 = new DirectoryInfo (path2);
-				Assertion.AssertEquals ("test#05", false, info1.Exists);
-				Assertion.AssertEquals ("test#06", true, info2.Exists);
+				AssertEquals ("test#05", false, info1.Exists);
+				AssertEquals ("test#06", true, info2.Exists);
 				
 			} finally {
 				DeleteDir (path1);

mcs/class/corlib/Test/System.IO/DirectoryTest.cs

@@ -17,7 +17,7 @@ using System.Threading;
 namespace MonoTests.System.IO {
 
 [TestFixture]
-public class DirectoryTest {
+public class DirectoryTest : Assertion {
 	
 	string TempFolder = Path.Combine (Path.GetTempPath (), "MonoTests.System.IO.Tests");
 	
@@ -44,10 +44,10 @@ public class DirectoryTest {
 		DeleteDirectory (path);
 		
 		DirectoryInfo info = Directory.CreateDirectory (path);
-		Assertion.AssertEquals ("test#01", true, info.Exists);
-		Assertion.AssertEquals ("test#02", ".1", info.Extension);
-		Assertion.AssertEquals ("test#03", true, info.FullName.EndsWith ("DirectoryTest.Test.1"));
-		Assertion.AssertEquals ("test#04", "DirectoryTest.Test.1", info.Name);
+		AssertEquals ("test#01", true, info.Exists);
+		AssertEquals ("test#02", ".1", info.Extension);
+		AssertEquals ("test#03", true, info.FullName.EndsWith ("DirectoryTest.Test.1"));
+		AssertEquals ("test#04", "DirectoryTest.Test.1", info.Name);
 
 		DeleteDirectory (path);		
 	}
@@ -103,27 +103,27 @@ public class DirectoryTest {
 		DeleteDirectory (path);
 		
 		Directory.CreateDirectory (path);
-		Assertion.AssertEquals ("test#01", true, Directory.Exists (path));
+		AssertEquals ("test#01", true, Directory.Exists (path));
 		
 		Directory.CreateDirectory (path + "/DirectoryTest.Test.Delete.1.2");
-		Assertion.AssertEquals ("test#02", true, Directory.Exists (path + "/DirectoryTest.Test.Delete.1.2"));
+		AssertEquals ("test#02", true, Directory.Exists (path + "/DirectoryTest.Test.Delete.1.2"));
 		
 		Directory.Delete (path + "/DirectoryTest.Test.Delete.1.2");
-		Assertion.AssertEquals ("test#03", false, Directory.Exists (path + "/DirectoryTest.Test.Delete.1.2"));
-		Assertion.AssertEquals ("test#04", true, Directory.Exists (path));
+		AssertEquals ("test#03", false, Directory.Exists (path + "/DirectoryTest.Test.Delete.1.2"));
+		AssertEquals ("test#04", true, Directory.Exists (path));
 		
 		Directory.Delete (path);
-		Assertion.AssertEquals ("test#05", false, Directory.Exists (path + "/DirectoryTest.Test.Delete.1.2"));
-		Assertion.AssertEquals ("test#06", false, Directory.Exists (path));		
+		AssertEquals ("test#05", false, Directory.Exists (path + "/DirectoryTest.Test.Delete.1.2"));
+		AssertEquals ("test#06", false, Directory.Exists (path));		
 	
 		Directory.CreateDirectory (path);
 		Directory.CreateDirectory (path + "/DirectoryTest.Test.Delete.1.2");
-		Assertion.AssertEquals ("test#07", true, Directory.Exists (path + "/DirectoryTest.Test.Delete.1.2"));
-		Assertion.AssertEquals ("test#08", true, Directory.Exists (path));
+		AssertEquals ("test#07", true, Directory.Exists (path + "/DirectoryTest.Test.Delete.1.2"));
+		AssertEquals ("test#08", true, Directory.Exists (path));
 		
 		Directory.Delete (path, true);
-		Assertion.AssertEquals ("test#09", false, Directory.Exists (path + "/DirectoryTest.Test.Delete.1.2"));
-		Assertion.AssertEquals ("test#10", false, Directory.Exists (path));
+		AssertEquals ("test#09", false, Directory.Exists (path + "/DirectoryTest.Test.Delete.1.2"));
+		AssertEquals ("test#10", false, Directory.Exists (path));
 	}
 
 	[Test]	
@@ -184,7 +184,7 @@ public class DirectoryTest {
 	[Test]
 	public void Exists ()
 	{
-		Assertion.AssertEquals ("test#01", false, Directory.Exists (null as string));
+		AssertEquals ("test#01", false, Directory.Exists (null as string));
 	}
 	
 	[Test]
@@ -424,11 +424,11 @@ public class DirectoryTest {
 		
 		Directory.CreateDirectory (path);
 		Directory.CreateDirectory (path + "/" + "dir");
-		Assertion.AssertEquals ("test#01", true, Directory.Exists (path + "/" + "dir"));
+		AssertEquals ("test#01", true, Directory.Exists (path + "/" + "dir"));
 		
 		Directory.Move (path, path2);
-		Assertion.AssertEquals ("test#02", false, Directory.Exists (path + "/" + "dir"));		
-		Assertion.AssertEquals ("test#03", true, Directory.Exists (path2 + "/" + "dir"));
+		AssertEquals ("test#02", false, Directory.Exists (path + "/" + "dir"));		
+		AssertEquals ("test#03", true, Directory.Exists (path2 + "/" + "dir"));
 		
 		if (Directory.Exists (path2 + "/" + "dir"))
 			Directory.Delete (path2 + "/" + "dir", true);
@@ -524,37 +524,37 @@ public class DirectoryTest {
 		Directory.SetCreationTime (path, new DateTime (2003, 6, 4, 6, 4, 0));
 
 		DateTime time = Directory.GetCreationTime (path);		
-		Assertion.AssertEquals ("test#01", 2003, time.Year);
-		Assertion.AssertEquals ("test#02", 6, time.Month);
-		Assertion.AssertEquals ("test#03", 4, time.Day);
-		Assertion.AssertEquals ("test#04", 6, time.Hour);
-		Assertion.AssertEquals ("test#05", 4, time.Minute);
-		Assertion.AssertEquals ("test#06", 0, time.Second);
+		AssertEquals ("test#01", 2003, time.Year);
+		AssertEquals ("test#02", 6, time.Month);
+		AssertEquals ("test#03", 4, time.Day);
+		AssertEquals ("test#04", 6, time.Hour);
+		AssertEquals ("test#05", 4, time.Minute);
+		AssertEquals ("test#06", 0, time.Second);
 		
 		time = TimeZone.CurrentTimeZone.ToLocalTime (Directory.GetCreationTimeUtc (path));
-		Assertion.AssertEquals ("test#07", 2003, time.Year);
-		Assertion.AssertEquals ("test#08", 6, time.Month);
-		Assertion.AssertEquals ("test#09", 4, time.Day);
-		Assertion.AssertEquals ("test#10", 6, time.Hour);
-		Assertion.AssertEquals ("test#11", 4, time.Minute);
-		Assertion.AssertEquals ("test#12", 0, time.Second);
+		AssertEquals ("test#07", 2003, time.Year);
+		AssertEquals ("test#08", 6, time.Month);
+		AssertEquals ("test#09", 4, time.Day);
+		AssertEquals ("test#10", 6, time.Hour);
+		AssertEquals ("test#11", 4, time.Minute);
+		AssertEquals ("test#12", 0, time.Second);
 
 		Directory.SetCreationTimeUtc (path, new DateTime (2003, 6, 4, 6, 4, 0));
 		time = TimeZone.CurrentTimeZone.ToUniversalTime (Directory.GetCreationTime (path));
-		Assertion.AssertEquals ("test#13", 2003, time.Year);
-		Assertion.AssertEquals ("test#14", 6, time.Month);
-		Assertion.AssertEquals ("test#15", 4, time.Day);
-		Assertion.AssertEquals ("test#16", 6, time.Hour);
-		Assertion.AssertEquals ("test#17", 4, time.Minute);
-		Assertion.AssertEquals ("test#18", 0, time.Second);
+		AssertEquals ("test#13", 2003, time.Year);
+		AssertEquals ("test#14", 6, time.Month);
+		AssertEquals ("test#15", 4, time.Day);
+		AssertEquals ("test#16", 6, time.Hour);
+		AssertEquals ("test#17", 4, time.Minute);
+		AssertEquals ("test#18", 0, time.Second);
 
 		time = Directory.GetCreationTimeUtc (path);		
-		Assertion.AssertEquals ("test#19", 2003, time.Year);
-		Assertion.AssertEquals ("test#20", 6, time.Month);
-		Assertion.AssertEquals ("test#21", 4, time.Day);
-		Assertion.AssertEquals ("test#22", 6, time.Hour);
-		Assertion.AssertEquals ("test#23", 4, time.Minute);
-		Assertion.AssertEquals ("test#24", 0, time.Second);
+		AssertEquals ("test#19", 2003, time.Year);
+		AssertEquals ("test#20", 6, time.Month);
+		AssertEquals ("test#21", 4, time.Day);
+		AssertEquals ("test#22", 6, time.Hour);
+		AssertEquals ("test#23", 4, time.Minute);
+		AssertEquals ("test#24", 0, time.Second);
 
 		DeleteDirectory (path);	
 	}
@@ -569,37 +569,37 @@ public class DirectoryTest {
 		Directory.SetLastAccessTime (path, new DateTime (2003, 6, 4, 6, 4, 0));
 
 		DateTime time = Directory.GetLastAccessTime (path);		
-		Assertion.AssertEquals ("test#01", 2003, time.Year);
-		Assertion.AssertEquals ("test#02", 6, time.Month);
-		Assertion.AssertEquals ("test#03", 4, time.Day);
-		Assertion.AssertEquals ("test#04", 6, time.Hour);
-		Assertion.AssertEquals ("test#05", 4, time.Minute);
-		Assertion.AssertEquals ("test#06", 0, time.Second);
+		AssertEquals ("test#01", 2003, time.Year);
+		AssertEquals ("test#02", 6, time.Month);
+		AssertEquals ("test#03", 4, time.Day);
+		AssertEquals ("test#04", 6, time.Hour);
+		AssertEquals ("test#05", 4, time.Minute);
+		AssertEquals ("test#06", 0, time.Second);
 		
 		time = TimeZone.CurrentTimeZone.ToLocalTime (Directory.GetLastAccessTimeUtc (path));
-		Assertion.AssertEquals ("test#07", 2003, time.Year);
-		Assertion.AssertEquals ("test#08", 6, time.Month);
-		Assertion.AssertEquals ("test#09", 4, time.Day);
-		Assertion.AssertEquals ("test#10", 6, time.Hour);
-		Assertion.AssertEquals ("test#11", 4, time.Minute);
-		Assertion.AssertEquals ("test#12", 0, time.Second);
+		AssertEquals ("test#07", 2003, time.Year);
+		AssertEquals ("test#08", 6, time.Month);
+		AssertEquals ("test#09", 4, time.Day);
+		AssertEquals ("test#10", 6, time.Hour);
+		AssertEquals ("test#11", 4, time.Minute);
+		AssertEquals ("test#12", 0, time.Second);
 
 		Directory.SetLastAccessTimeUtc (path, new DateTime (2003, 6, 4, 6, 4, 0));
 		time = TimeZone.CurrentTimeZone.ToUniversalTime (Directory.GetLastAccessTime (path));
-		Assertion.AssertEquals ("test#13", 2003, time.Year);
-		Assertion.AssertEquals ("test#14", 6, time.Month);
-		Assertion.AssertEquals ("test#15", 4, time.Day);
-		Assertion.AssertEquals ("test#16", 6, time.Hour);
-		Assertion.AssertEquals ("test#17", 4, time.Minute);
-		Assertion.AssertEquals ("test#18", 0, time.Second);
+		AssertEquals ("test#13", 2003, time.Year);
+		AssertEquals ("test#14", 6, time.Month);
+		AssertEquals ("test#15", 4, time.Day);
+		AssertEquals ("test#16", 6, time.Hour);
+		AssertEquals ("test#17", 4, time.Minute);
+		AssertEquals ("test#18", 0, time.Second);
 
 		time = Directory.GetLastAccessTimeUtc (path);		
-		Assertion.AssertEquals ("test#19", 2003, time.Year);
-		Assertion.AssertEquals ("test#20", 6, time.Month);
-		Assertion.AssertEquals ("test#21", 4, time.Day);
-		Assertion.AssertEquals ("test#22", 6, time.Hour);
-		Assertion.AssertEquals ("test#23", 4, time.Minute);
-		Assertion.AssertEquals ("test#24", 0, time.Second);
+		AssertEquals ("test#19", 2003, time.Year);
+		AssertEquals ("test#20", 6, time.Month);
+		AssertEquals ("test#21", 4, time.Day);
+		AssertEquals ("test#22", 6, time.Hour);
+		AssertEquals ("test#23", 4, time.Minute);
+		AssertEquals ("test#24", 0, time.Second);
 
 		DeleteDirectory (path);
 	}
@@ -614,37 +614,37 @@ public class DirectoryTest {
 		Directory.SetLastWriteTime (path, new DateTime (2003, 6, 4, 6, 4, 0));
 
 		DateTime time = Directory.GetLastWriteTime (path);		
-		Assertion.AssertEquals ("test#01", 2003, time.Year);
-		Assertion.AssertEquals ("test#02", 6, time.Month);
-		Assertion.AssertEquals ("test#03", 4, time.Day);
-		Assertion.AssertEquals ("test#04", 6, time.Hour);
-		Assertion.AssertEquals ("test#05", 4, time.Minute);
-		Assertion.AssertEquals ("test#06", 0, time.Second);
+		AssertEquals ("test#01", 2003, time.Year);
+		AssertEquals ("test#02", 6, time.Month);
+		AssertEquals ("test#03", 4, time.Day);
+		AssertEquals ("test#04", 6, time.Hour);
+		AssertEquals ("test#05", 4, time.Minute);
+		AssertEquals ("test#06", 0, time.Second);
 		
 		time = TimeZone.CurrentTimeZone.ToLocalTime (Directory.GetLastWriteTimeUtc (path));
-		Assertion.AssertEquals ("test#07", 2003, time.Year);
-		Assertion.AssertEquals ("test#08", 6, time.Month);
-		Assertion.AssertEquals ("test#09", 4, time.Day);
-		Assertion.AssertEquals ("test#10", 6, time.Hour);
-		Assertion.AssertEquals ("test#11", 4, time.Minute);
-		Assertion.AssertEquals ("test#12", 0, time.Second);
+		AssertEquals ("test#07", 2003, time.Year);
+		AssertEquals ("test#08", 6, time.Month);
+		AssertEquals ("test#09", 4, time.Day);
+		AssertEquals ("test#10", 6, time.Hour);
+		AssertEquals ("test#11", 4, time.Minute);
+		AssertEquals ("test#12", 0, time.Second);
 
 		Directory.SetLastWriteTimeUtc (path, new DateTime (2003, 6, 4, 6, 4, 0));
 		time = TimeZone.CurrentTimeZone.ToUniversalTime (Directory.GetLastWriteTime (path));
-		Assertion.AssertEquals ("test#13", 2003, time.Year);
-		Assertion.AssertEquals ("test#14", 6, time.Month);
-		Assertion.AssertEquals ("test#15", 4, time.Day);
-		Assertion.AssertEquals ("test#16", 6, time.Hour);
-		Assertion.AssertEquals ("test#17", 4, time.Minute);
-		Assertion.AssertEquals ("test#18", 0, time.Second);
+		AssertEquals ("test#13", 2003, time.Year);
+		AssertEquals ("test#14", 6, time.Month);
+		AssertEquals ("test#15", 4, time.Day);
+		AssertEquals ("test#16", 6, time.Hour);
+		AssertEquals ("test#17", 4, time.Minute);
+		AssertEquals ("test#18", 0, time.Second);
 
 		time = Directory.GetLastWriteTimeUtc (path);		
-		Assertion.AssertEquals ("test#19", 2003, time.Year);
-		Assertion.AssertEquals ("test#20", 6, time.Month);
-		Assertion.AssertEquals ("test#21", 4, time.Day);
-		Assertion.AssertEquals ("test#22", 6, time.Hour);
-		Assertion.AssertEquals ("test#23", 4, time.Minute);
-		Assertion.AssertEquals ("test#24", 0, time.Second);
+		AssertEquals ("test#19", 2003, time.Year);
+		AssertEquals ("test#20", 6, time.Month);
+		AssertEquals ("test#21", 4, time.Day);
+		AssertEquals ("test#22", 6, time.Hour);
+		AssertEquals ("test#23", 4, time.Minute);
+		AssertEquals ("test#24", 0, time.Second);
 
 		DeleteDirectory (path);		
 	}
@@ -1002,7 +1002,7 @@ public class DirectoryTest {
 					return;
 			}
 		
-			Assertion.Assert ("Directory Not Found", false);
+			Assert ("Directory Not Found", false);
 		} finally {
 			DeleteDirectory (DirPath);
 		}
@@ -1025,7 +1025,7 @@ public class DirectoryTest {
 					return;
 			}
 		
-			Assertion.Assert ("File Not Found", false);
+			Assert ("File Not Found", false);
 		} finally {
 			if (File.Exists (DirPath))
 				File.Delete (DirPath);

mcs/class/corlib/Test/System.IO/FileStreamTest.cs

@@ -17,6 +17,7 @@ using System.Text;
 
 namespace MonoTests.System.IO
 {
+	[TestFixture]
         public class FileStreamTest : Assertion
         {
 		string TempFolder = Path.Combine (Path.GetTempPath (), "MonoTests.System.IO.Tests");

mcs/class/corlib/Test/System.IO/FileSystemInfoTest.cs

@@ -14,7 +14,6 @@ using System.Threading;
 
 namespace MonoTests.System.IO
 {
-
 	[TestFixture]
         public class FileSystemInfoTest : Assertion
 	{

mcs/class/corlib/Test/System.IO/MemoryStreamTest.cs

@@ -16,7 +16,7 @@ using System.Text;
 namespace MonoTests.System.IO
 {
 	[TestFixture]
-	public class MemoryStreamTest
+	public class MemoryStreamTest : Assertion
 	{
 		MemoryStream testStream;
 		byte [] testStreamData;
@@ -39,7 +39,7 @@ namespace MonoTests.System.IO
 		void VerifyTestData (string id, byte [] testBytes, int start, int count)
 		{
 			if (testBytes == null)
-				Assertion.Fail (id + "+1 testBytes is null");
+				Fail (id + "+1 testBytes is null");
 
 			if (start < 0 ||
 			    count < 0  ||
@@ -57,7 +57,7 @@ namespace MonoTests.System.IO
 							start + test,
 							testBytes [test],
 							testStreamData [start + test]);
-				Assertion.Fail (id + "-3" + failStr);
+				Fail (id + "-3" + failStr);
 			}
 		}
 
@@ -66,9 +66,9 @@ namespace MonoTests.System.IO
 		{
 			MemoryStream ms = new MemoryStream();
 
-			Assertion.AssertEquals ("#01", 0L, ms.Length);
-			Assertion.AssertEquals ("#02", 0, ms.Capacity);
-			Assertion.AssertEquals ("#03", true, ms.CanWrite);
+			AssertEquals ("#01", 0L, ms.Length);
+			AssertEquals ("#02", 0, ms.Capacity);
+			AssertEquals ("#03", true, ms.CanWrite);
 		}
 
 		[Test]
@@ -76,16 +76,16 @@ namespace MonoTests.System.IO
 		{
 			MemoryStream ms = new MemoryStream (10);
 
-			Assertion.AssertEquals ("#01", 0L, ms.Length);
-			Assertion.AssertEquals ("#02", 10, ms.Capacity);
+			AssertEquals ("#01", 0L, ms.Length);
+			AssertEquals ("#02", 10, ms.Capacity);
 			ms.Capacity = 0;
 			byte [] buffer = ms.GetBuffer ();
 			// Begin: wow!!!
-			Assertion.AssertEquals ("#03", -1, ms.ReadByte ());
-			Assertion.AssertEquals ("#04", null, buffer); // <--
+			AssertEquals ("#03", -1, ms.ReadByte ());
+			AssertEquals ("#04", null, buffer); // <--
 			ms.Read (new byte [5], 0, 5);
-			Assertion.AssertEquals ("#05", 0, ms.Position);
-			Assertion.AssertEquals ("#06", 0, ms.Length);
+			AssertEquals ("#05", 0, ms.Position);
+			AssertEquals ("#06", 0, ms.Length);
 			// End
 		}
 
@@ -93,21 +93,21 @@ namespace MonoTests.System.IO
 		public void ConstructorsThree ()
 		{
 			MemoryStream ms = new MemoryStream (testStreamData);
-			Assertion.AssertEquals ("#01", 100, ms.Length);
-			Assertion.AssertEquals ("#02", 0, ms.Position);
+			AssertEquals ("#01", 100, ms.Length);
+			AssertEquals ("#02", 0, ms.Position);
 		}
 
 		[Test]
 		public void ConstructorsFour ()
 		{
 			MemoryStream ms = new MemoryStream (testStreamData, true);
-			Assertion.AssertEquals ("#01", 100, ms.Length);
-			Assertion.AssertEquals ("#02", 0, ms.Position);
+			AssertEquals ("#01", 100, ms.Length);
+			AssertEquals ("#02", 0, ms.Position);
 			ms.Position = 50;
 			byte saved = testStreamData [50];
 			try {
 				ms.WriteByte (23);
-				Assertion.AssertEquals ("#03", testStreamData [50], 23);
+				AssertEquals ("#03", testStreamData [50], 23);
 			} finally {
 				testStreamData [50] = saved;
 			}
@@ -117,21 +117,21 @@ namespace MonoTests.System.IO
 			} catch (Exception) {
 				return;
 			}
-			Assertion.Fail ("#04");
+			Fail ("#04");
 		}
 
 		[Test]
 		public void ConstructorsFive ()
 		{
 			MemoryStream ms = new MemoryStream (testStreamData, 50, 50);
-			Assertion.AssertEquals ("#01", 50, ms.Length);
-			Assertion.AssertEquals ("#02", 0, ms.Position);
-			Assertion.AssertEquals ("#03", 50, ms.Capacity);
+			AssertEquals ("#01", 50, ms.Length);
+			AssertEquals ("#02", 0, ms.Position);
+			AssertEquals ("#03", 50, ms.Capacity);
 			ms.Position = 1;
 			byte saved = testStreamData [51];
 			try {
 				ms.WriteByte (23);
-				Assertion.AssertEquals ("#04", testStreamData [51], 23);
+				AssertEquals ("#04", testStreamData [51], 23);
 			} finally {
 				testStreamData [51] = saved;
 			}
@@ -144,7 +144,7 @@ namespace MonoTests.System.IO
 			}
 
 			if (!gotException)
-				Assertion.Fail ("#05");
+				Fail ("#05");
 
 			gotException = false;
 			try {
@@ -154,7 +154,7 @@ namespace MonoTests.System.IO
 			}
 
 			if (!gotException)
-				Assertion.Fail ("#06");
+				Fail ("#06");
 
 			ms.Capacity = 100; // Allowed. It's the same as the one in the ms.
 					   // This is lame, as the length is 50!!!
@@ -167,9 +167,9 @@ namespace MonoTests.System.IO
 			}
 
 			if (!gotException)
-				Assertion.Fail ("#07");
+				Fail ("#07");
 
-			Assertion.AssertEquals ("#08", 50, ms.ToArray ().Length);
+			AssertEquals ("#08", 50, ms.ToArray ().Length);
 		}
 
 		[Test]
@@ -202,7 +202,7 @@ namespace MonoTests.System.IO
 			VerifyTestData ("R3", readBytes, 80, 20);
 
 			int readByte = testStream.ReadByte();
-			Assertion.AssertEquals (-1, readByte);
+			AssertEquals (-1, readByte);
 		}
 
 		[Test]
@@ -232,7 +232,7 @@ namespace MonoTests.System.IO
 			testStream.Read (readBytes, 0, 100);
 			VerifyTestData ("WB1", readBytes, 0, 100);
 			byte[] arrayBytes = testStream.ToArray();
-			Assertion.AssertEquals ("#01", 100, arrayBytes.Length);
+			AssertEquals ("#01", 100, arrayBytes.Length);
 			VerifyTestData ("WB2", arrayBytes, 0, 100);
 		}
 
@@ -243,10 +243,10 @@ namespace MonoTests.System.IO
 			ms.Position = 4;
 			ms.WriteByte ((byte) 'M');
 			ms.WriteByte ((byte) 'O');
-			Assertion.AssertEquals ("#01", 6, ms.Length);
-			Assertion.AssertEquals ("#02", 6, ms.Position);
+			AssertEquals ("#01", 6, ms.Length);
+			AssertEquals ("#02", 6, ms.Position);
 			ms.Position = 0;
-			Assertion.AssertEquals ("#03", 0, ms.Position);
+			AssertEquals ("#03", 0, ms.Position);
 		}
 
 		[Test]
@@ -255,8 +255,8 @@ namespace MonoTests.System.IO
 		{
 			MemoryStream ms = new MemoryStream (testStreamData);
 			ms.Position = 101;
-			Assertion.AssertEquals ("#01", 101, ms.Position);
-			Assertion.AssertEquals ("#02", 100, ms.Length);
+			AssertEquals ("#01", 101, ms.Position);
+			AssertEquals ("#02", 100, ms.Length);
 			ms.WriteByte (1); // This should throw the exception
 		}
 
@@ -265,7 +265,7 @@ namespace MonoTests.System.IO
 		{
 			MemoryStream ms = new MemoryStream ();
 			byte [] buffer = ms.GetBuffer ();
-			Assertion.AssertEquals ("#01", 0, buffer.Length);
+			AssertEquals ("#01", 0, buffer.Length);
 		}
 
 		[Test]
@@ -273,13 +273,13 @@ namespace MonoTests.System.IO
 		{
 			MemoryStream ms = new MemoryStream (100);
 			byte [] buffer = ms.GetBuffer ();
-			Assertion.AssertEquals ("#01", 100, buffer.Length);
+			AssertEquals ("#01", 100, buffer.Length);
 
 			ms.Write (testStreamData, 0, 100);
 			ms.Write (testStreamData, 0, 100);
-			Assertion.AssertEquals ("#02", 200, ms.Length);
+			AssertEquals ("#02", 200, ms.Length);
 			buffer = ms.GetBuffer ();
-			Assertion.AssertEquals ("#03", 256, buffer.Length); // Minimun size after writing
+			AssertEquals ("#03", 256, buffer.Length); // Minimun size after writing
 		}
 
 		[Test]
@@ -295,7 +295,7 @@ namespace MonoTests.System.IO
 			}
 
 			if (!thrown)
-				Assertion.Fail ("#01");
+				Fail ("#01");
 
 			thrown = false;
 			try {
@@ -305,7 +305,7 @@ namespace MonoTests.System.IO
 			}
 
 			if (!thrown)
-				Assertion.Fail ("#02");
+				Fail ("#02");
 
 			// The first exception thrown is ObjectDisposed, not ArgumentNull
 			thrown = false;
@@ -316,7 +316,7 @@ namespace MonoTests.System.IO
 			}
 
 			if (!thrown)
-				Assertion.Fail ("#03");
+				Fail ("#03");
 
 			thrown = false;
 			try {
@@ -326,7 +326,7 @@ namespace MonoTests.System.IO
 			}
 
 			if (!thrown)
-				Assertion.Fail ("#03");
+				Fail ("#03");
 		}
 
 		[Test]
@@ -347,7 +347,7 @@ namespace MonoTests.System.IO
 				thrown = true;
 			}
 			if (!thrown)
-				Assertion.Fail ("#01");
+				Fail ("#01");
 			
 			thrown = false;
 			try {
@@ -357,7 +357,7 @@ namespace MonoTests.System.IO
 			}
 
 			if (!thrown)
-				Assertion.Fail ("#02");
+				Fail ("#02");
 
 			thrown=false;
 			try {
@@ -368,26 +368,26 @@ namespace MonoTests.System.IO
 			}
 
 			if (!thrown)
-				Assertion.Fail ("#03");
+				Fail ("#03");
 
 			ms=new MemoryStream (256);
 
 			ms.Write (testStreamData, 0, 100);
 			ms.Position=0;
-			Assertion.AssertEquals ("#01", 100, ms.Length);
-			Assertion.AssertEquals ("#02", 0, ms.Position);
+			AssertEquals ("#01", 100, ms.Length);
+			AssertEquals ("#02", 0, ms.Position);
 
 			ms.Position=128;
-			Assertion.AssertEquals ("#03", 100, ms.Length);
-			Assertion.AssertEquals ("#04", 128, ms.Position);
+			AssertEquals ("#03", 100, ms.Length);
+			AssertEquals ("#04", 128, ms.Position);
 
 			ms.Position=768;
-			Assertion.AssertEquals ("#05", 100, ms.Length);
-			Assertion.AssertEquals ("#06", 768, ms.Position);
+			AssertEquals ("#05", 100, ms.Length);
+			AssertEquals ("#06", 768, ms.Position);
 
 			ms.WriteByte (0);
-			Assertion.AssertEquals ("#07", 769, ms.Length);
-			Assertion.AssertEquals ("#08", 769, ms.Position);
+			AssertEquals ("#07", 769, ms.Length);
+			AssertEquals ("#08", 769, ms.Position);
 		}
 
 		[Test]
@@ -397,11 +397,11 @@ namespace MonoTests.System.IO
 			ms.Write (testStreamData, 0, 100);
 			ms.Position = 100;
 			ms.SetLength (150);
-			Assertion.AssertEquals ("#01", 150, ms.Length);
-			Assertion.AssertEquals ("#02", 100, ms.Position);
+			AssertEquals ("#01", 150, ms.Length);
+			AssertEquals ("#02", 100, ms.Position);
 			ms.SetLength (80);
-			Assertion.AssertEquals ("#03", 80, ms.Length);
-			Assertion.AssertEquals ("#04", 80, ms.Position);
+			AssertEquals ("#03", 80, ms.Length);
+			AssertEquals ("#04", 80, ms.Position);
 		}
 
 		[Test]
@@ -428,15 +428,15 @@ namespace MonoTests.System.IO
 			ms.Write (testStreamData, 0, 100);
 			ms.Position = 100;
 			ms.WriteByte (101);
-			Assertion.AssertEquals ("#01", 101, ms.Position);
-			Assertion.AssertEquals ("#02", 101, ms.Length);
-			Assertion.AssertEquals ("#03", 256, ms.Capacity);
+			AssertEquals ("#01", 101, ms.Position);
+			AssertEquals ("#02", 101, ms.Length);
+			AssertEquals ("#03", 256, ms.Capacity);
 			ms.Write (testStreamData, 0, 100);
 			ms.Write (testStreamData, 0, 100);
 			// 301
-			Assertion.AssertEquals ("#04", 301, ms.Position);
-			Assertion.AssertEquals ("#05", 301, ms.Length);
-			Assertion.AssertEquals ("#06", 512, ms.Capacity);
+			AssertEquals ("#04", 301, ms.Position);
+			AssertEquals ("#05", 301, ms.Length);
+			AssertEquals ("#06", 512, ms.Capacity);
 		}
 
 		[Test]
@@ -445,21 +445,21 @@ namespace MonoTests.System.IO
 			BinaryWriter writer=new BinaryWriter (ms);
 
 			writer.Write ((byte)'1');
-			Assertion.AssertEquals ("#01", 1, ms.Length);
-			Assertion.AssertEquals ("#02", 256, ms.Capacity);
+			AssertEquals ("#01", 1, ms.Length);
+			AssertEquals ("#02", 256, ms.Capacity);
 			
 			writer.Write ((ushort)0);
-			Assertion.AssertEquals ("#03", 3, ms.Length);
-			Assertion.AssertEquals ("#04", 256, ms.Capacity);
+			AssertEquals ("#03", 3, ms.Length);
+			AssertEquals ("#04", 256, ms.Capacity);
 
 			writer.Write (testStreamData, 0, 23);
-			Assertion.AssertEquals ("#05", 26, ms.Length);
-			Assertion.AssertEquals ("#06", 256, ms.Capacity);
+			AssertEquals ("#05", 26, ms.Length);
+			AssertEquals ("#06", 256, ms.Capacity);
 
 			writer.Write (testStreamData);
 			writer.Write (testStreamData);
 			writer.Write (testStreamData);
-			Assertion.AssertEquals ("#07", 326, ms.Length);
+			AssertEquals ("#07", 326, ms.Length);
 		}
 	}
 }

mcs/class/corlib/Test/System.IO/PathTest.cs

@@ -35,7 +35,8 @@ namespace MonoTests.System.IO
 	}
 
 #if NUNIT
-	public class PathTest : TestCase
+	[TestFixture]
+	public class PathTest : Assertion
 	{
 #else
 	public class PathTest
@@ -48,7 +49,8 @@ namespace MonoTests.System.IO
 		static char DSC = Path.DirectorySeparatorChar;
 	     
 #if NUNIT
-		protected override void SetUp ()
+		[SetUp]
+		public void SetUp ()
 		{
 #else
 		static PathTest ()

mcs/class/corlib/Test/System.IO/StringReaderTest.cs

@@ -14,7 +14,8 @@ using System;
 
 namespace MonoTests.System.IO {
 
-public class StringReaderTest : TestCase {
+[TestFixture]
+public class StringReaderTest : Assertion {
 	public  void TestReadLine() {
 		string testme = "a\nb\nc\n";
 		StringReader sr = new StringReader (testme);

mcs/class/corlib/Test/System.IO/StringWriterTest.cs

@@ -16,14 +16,15 @@ using System.Text;
 
 namespace MonoTests.System.IO {
 
-public class StringWriterTest : TestCase {
+[TestFixture]
+public class StringWriterTest : Assertion {
 	public void TestConstructors() {
                 StringBuilder sb = new StringBuilder("Test String");
 
                 StringWriter writer = new StringWriter( sb );
                 AssertEquals( sb, writer.GetStringBuilder() );
-        }
-	
+        }
+
         public void TestCultureInfoConstructor() {
 
 		StringWriter writer = new StringWriter(CultureInfo.InvariantCulture);