Reformat ArraySegment test

diff --git a/mcs/class/corlib/Test/System/ArraySegmentTest.cs b/mcs/class/corlib/Test/System/ArraySegmentTest.cs
index 4da59275fdbb6125964e12a8453777eab09cc89e..3f09a2f34d2aca5b4fadefa83b22a57ca8a56e00 100644 (file)
--- a/mcs/class/corlib/Test/System/ArraySegmentTest.cs
+++ b/mcs/class/corlib/Test/System/ArraySegmentTest.cs
@@ -7,160 +7,151 @@
 // Copyright (C) 2006 Novell, Inc (http://www.novell.com)
 // 
 
-#if NET_2_0
 using NUnit.Framework;
 using System;
 using System.Collections.Generic;
 
 namespace MonoTests.System
 {
-
-[TestFixture]
-public class ArraySegmentTest
-{
-       public ArraySegmentTest() {}
-
-       [Test]
-       public void CtorTest1 () 
-       {
-               byte [] b_arr = new byte [4096];
-               Array arr;
-
-               ArraySegment<byte> seg = new ArraySegment<byte> (b_arr, 0, b_arr.Length);
-               Assert.AreEqual (seg.Count, b_arr.Length, "#1");
-               Assert.AreEqual (seg.Offset, 0, "#2");
-               
-               arr = seg.Array;
-               Assert.AreEqual (arr.Length, 4096, "#5");
-               
-               seg = new ArraySegment<byte> (b_arr, 100, b_arr.Length - 100);
-               Assert.AreEqual (seg.Count, b_arr.Length - 100, "#3");
-               Assert.AreEqual (seg.Offset, 100, "#4");
-               
-               arr = seg.Array;
-               Assert.AreEqual (arr.Length, 4096, "#5");
-       }
-
-       [Test]
-       public void CtorTest2 ()
+       [TestFixture]
+       public class ArraySegmentTest
        {
-               byte [] b_arr = new byte [4096];
-               ArraySegment<byte> seg = new ArraySegment<byte> (b_arr);
-               Assert.AreEqual (seg.Count, b_arr.Length, "#6");
-               Assert.AreEqual (seg.Offset, 0, "#7");
-               
-               Array arr = seg.Array;
-               Assert.AreEqual (arr.Length, 4096, "#8");
+               [Test]
+               public void CtorTest1 ()
+               {
+                       byte[] b_arr = new byte[4096];
+                       Array arr;
+
+                       ArraySegment<byte> seg = new ArraySegment<byte> (b_arr, 0, b_arr.Length);
+                       Assert.AreEqual (seg.Count, b_arr.Length, "#1");
+                       Assert.AreEqual (seg.Offset, 0, "#2");
+
+                       arr = seg.Array;
+                       Assert.AreEqual (arr.Length, 4096, "#5");
+
+                       seg = new ArraySegment<byte> (b_arr, 100, b_arr.Length - 100);
+                       Assert.AreEqual (seg.Count, b_arr.Length - 100, "#3");
+                       Assert.AreEqual (seg.Offset, 100, "#4");
+
+                       arr = seg.Array;
+                       Assert.AreEqual (arr.Length, 4096, "#5");
+               }
+
+               [Test]
+               public void CtorTest2 ()
+               {
+                       byte[] b_arr = new byte[4096];
+                       ArraySegment<byte> seg = new ArraySegment<byte> (b_arr);
+                       Assert.AreEqual (seg.Count, b_arr.Length, "#6");
+                       Assert.AreEqual (seg.Offset, 0, "#7");
+
+                       Array arr = seg.Array;
+                       Assert.AreEqual (arr.Length, 4096, "#8");
+               }
+
+               [Test]
+               public void CtorTest3 ()
+               {
+                       EmptyArraySegTest (0);
+                       EmptyArraySegTest (10);
+               }
+
+               private void EmptyArraySegTest (int len)
+               {
+                       byte[] b_arr = new byte[len];
+
+                       ArraySegment<byte> seg = new ArraySegment<byte> (b_arr, 0, b_arr.Length);
+
+                       Assert.AreEqual (seg.Count, b_arr.Length, "#1 [array len {0}] ", len);
+                       Assert.AreEqual (seg.Offset, 0, "#2 [array len {0}] ", len);
+                       Array arr = seg.Array;
+                       Assert.AreEqual (arr.Length, len, "#3 [array len {0}] ", len);
+
+                       seg = new ArraySegment<byte> (b_arr, b_arr.Length, 0);
+                       Assert.AreEqual (seg.Count, 0, "#4 [array len {0}] ", len);
+                       Assert.AreEqual (seg.Offset, b_arr.Length, "#5 [array len {0}] ", len);
+                       arr = seg.Array;
+                       Assert.AreEqual (arr.Length, len, "#6 [array len {0}] ", len);
+
+                       seg = new ArraySegment<byte> (b_arr);
+                       Assert.AreEqual (seg.Count, b_arr.Length, "#7 [array len {0}] ", len);
+                       Assert.AreEqual (seg.Offset, 0, "#8 [array len {0}] ", len);
+                       arr = seg.Array;
+                       Assert.AreEqual (arr.Length, len, "#9 [array len {0}] ", len);
+               }
+
+               [Test]
+               [ExpectedException (typeof (ArgumentException))]
+               public void CtorErrorTest ()
+               {
+                       byte[] arr = new byte[4096];
+                       ArraySegment<byte> seg = new ArraySegment<byte> (arr, 1, arr.Length);
+               }
+
+               [Test]
+               [ExpectedException (typeof (ArgumentException))]
+               public void CtorErrorTest2 ()
+               {
+                       byte[] arr = new byte[4096];
+                       ArraySegment<byte> seg = new ArraySegment<byte> (arr, 0, arr.Length + 2);
+               }
+
+               [Test]
+               [ExpectedException (typeof (ArgumentOutOfRangeException))]
+               public void CtorErrorTest3 ()
+               {
+                       byte[] arr = new byte[4096];
+                       ArraySegment<byte> seg = new ArraySegment<byte> (arr, -1, arr.Length);
+               }
+
+               [Test]
+               [ExpectedException (typeof (ArgumentOutOfRangeException))]
+               public void CtorErrorTest4 ()
+               {
+                       byte[] arr = new byte[4096];
+                       ArraySegment<byte> seg = new ArraySegment<byte> (arr, 2, -1);
+               }
+
+               [Test]
+               [ExpectedException (typeof (ArgumentException))]
+               public void CtorErrorTest5 ()
+               {
+                       byte[] arr = new byte[4096];
+                       ArraySegment<byte> seg = new ArraySegment<byte> (arr, 0, arr.Length + 2);
+               }
+
+               [Test]
+               [ExpectedException (typeof (ArgumentNullException))]
+               public void CtorNullTest1 ()
+               {
+                       ArraySegment<byte> seg = new ArraySegment<byte> (null, 0, 1);
+               }
+
+               [Test]
+               [ExpectedException (typeof (ArgumentNullException))]
+               public void CtorNullTest2 ()
+               {
+                       ArraySegment<byte> seg = new ArraySegment<byte> (null);
+               }
+
+               [Test]
+               public void TestArraySegmentEqual ()
+               {
+                       string[] myArr_1 = { "The", "good" };
+                       string[] myArr_2 = { "The", "good" };
+
+                       ArraySegment<string> myArrSeg_1 = new ArraySegment<string> (myArr_1);
+                       ArraySegment<string> myArrSeg_2 = new ArraySegment<string> (myArr_2);
+
+                       // Should return true.
+                       Assert.AreEqual (myArrSeg_1.Equals (myArrSeg_1), true);
+
+                       // Should return false. Allthough the strings are the same.
+                       Assert.AreEqual (myArrSeg_1.Equals (myArrSeg_2), false);
+                       Assert.AreEqual (myArrSeg_1 == myArrSeg_2, false);
+
+                       // Should return true.
+                       Assert.AreEqual (myArrSeg_1 != myArrSeg_2, true);
+               }
        }
-
-       [Test]
-       public void CtorTest3 ()
-       {
-               EmptyArraySegTest (0);
-               EmptyArraySegTest (10);
-       }
-
-       private void EmptyArraySegTest (int len)
-       {
-               byte [] b_arr = new byte [len];
-
-               ArraySegment<byte> seg = new ArraySegment<byte> (b_arr, 0, b_arr.Length);
-
-               Assert.AreEqual (seg.Count, b_arr.Length, "#1 [array len {0}] ", len);
-               Assert.AreEqual (seg.Offset, 0, "#2 [array len {0}] ", len);
-               Array arr = seg.Array;
-               Assert.AreEqual (arr.Length, len, "#3 [array len {0}] ", len);
-               
-               seg = new ArraySegment<byte> (b_arr, b_arr.Length, 0);
-               Assert.AreEqual (seg.Count, 0, "#4 [array len {0}] ", len);
-               Assert.AreEqual (seg.Offset, b_arr.Length, "#5 [array len {0}] ", len);
-               arr = seg.Array;
-               Assert.AreEqual (arr.Length, len, "#6 [array len {0}] ", len);
-
-               seg = new ArraySegment<byte> (b_arr);
-               Assert.AreEqual (seg.Count, b_arr.Length, "#7 [array len {0}] ", len);
-               Assert.AreEqual (seg.Offset, 0, "#8 [array len {0}] ", len);
-               arr = seg.Array;
-               Assert.AreEqual (arr.Length, len, "#9 [array len {0}] ", len);
-       }
-
-       [Test]
-       [ExpectedException (typeof (ArgumentException))]
-       public void CtorErrorTest ()
-       {
-               byte [] arr = new byte [4096];  
-               ArraySegment<byte> seg = new ArraySegment<byte> (arr, 1, arr.Length);
-       }
-       
-       [Test]
-       [ExpectedException (typeof (ArgumentException))]
-       public void CtorErrorTest2 ()
-       {
-               byte [] arr = new byte [4096];  
-               ArraySegment<byte> seg = new ArraySegment<byte> (arr, 0, arr.Length + 2);
-       }
-
-       [Test]
-       [ExpectedException (typeof (ArgumentOutOfRangeException))]
-       public void CtorErrorTest3 ()
-       {
-               byte [] arr = new byte [4096];  
-               ArraySegment<byte> seg = new ArraySegment<byte> (arr, -1, arr.Length);
-       }
-
-       [Test]
-       [ExpectedException (typeof (ArgumentOutOfRangeException))]
-       public void CtorErrorTest4 ()
-       {
-               byte [] arr = new byte [4096];  
-               ArraySegment<byte> seg = new ArraySegment<byte> (arr, 2, -1);
-       }
-
-       [Test]
-       [ExpectedException (typeof (ArgumentException))]
-       public void CtorErrorTest5 ()
-       {
-               byte [] arr = new byte [4096];
-               ArraySegment<byte> seg = new ArraySegment<byte> (arr, 0, arr.Length + 2);
-       }
-
-       [Test]
-       [ExpectedException (typeof (ArgumentNullException))]
-       public void CtorNullTest1 ()
-       {
-               ArraySegment<byte> seg = new ArraySegment<byte> (null, 0 , 1);
-       }
-
-       [Test]
-       [ExpectedException (typeof (ArgumentNullException))]
-       public void CtorNullTest2 ()
-       {
-               ArraySegment<byte> seg = new ArraySegment<byte> (null);
-       }
-
-#pragma warning disable 1718
-       [Test]
-       public void TestArraySegmentEqual ()
-       {
-           string[] myArr_1 = { "The", "good" };
-           string[] myArr_2 = { "The", "good" };
-           
-           ArraySegment<string> myArrSeg_1 = new ArraySegment<string>(myArr_1);
-           ArraySegment<string> myArrSeg_2 = new ArraySegment<string>(myArr_2);
-           
-           // Should return true.
-           Assert.AreEqual(myArrSeg_1.Equals(myArrSeg_1), true);
-           Assert.AreEqual(myArrSeg_1 == myArrSeg_1, true);
-           
-           // Should return false. Allthough the strings are the same.
-           Assert.AreEqual(myArrSeg_1.Equals(myArrSeg_2), false);
-           Assert.AreEqual(myArrSeg_1 == myArrSeg_2, false);
-           
-           // Should return true.
-           Assert.AreEqual(myArrSeg_1 != myArrSeg_2, true);
-       }
-#pragma warning restore 1718
-}
-
 }
-#endif