From 625757a9622f8f9c4da0cf2402734b7e2c3ba685 Mon Sep 17 00:00:00 2001 From: Robert Jordan Date: Fri, 26 Jun 2009 21:29:00 +0000 Subject: [PATCH] 2009-06-26 Robert Jordan * StringTest.cs: Convert all tests to new-style nunit classes/methods. svn path=/trunk/mcs/; revision=137011 --- mcs/class/corlib/Test/System/ChangeLog | 5 + mcs/class/corlib/Test/System/StringTest.cs | 3366 ++++++++++---------- 2 files changed, 1656 insertions(+), 1715 deletions(-) diff --git a/mcs/class/corlib/Test/System/ChangeLog b/mcs/class/corlib/Test/System/ChangeLog index 1a7566fd807..65aa2f27ded 100644 --- a/mcs/class/corlib/Test/System/ChangeLog +++ b/mcs/class/corlib/Test/System/ChangeLog @@ -1,3 +1,8 @@ +2009-06-26 Robert Jordan + + * StringTest.cs: Convert all tests to new-style nunit + classes/methods. + 2009-06-26 Zoltan Varga * NumberFormatterTest.cs: Convert all tests to new-style nunit diff --git a/mcs/class/corlib/Test/System/StringTest.cs b/mcs/class/corlib/Test/System/StringTest.cs index a7197c2ba09..681295bcfe2 100644 --- a/mcs/class/corlib/Test/System/StringTest.cs +++ b/mcs/class/corlib/Test/System/StringTest.cs @@ -22,17 +22,19 @@ namespace MonoTests.System { [TestFixture] -public class StringTest : TestCase +public class StringTest { private CultureInfo orgCulture; - protected override void SetUp () + [SetUp] + public void SetUp () { // save current culture orgCulture = CultureInfo.CurrentCulture; } - protected override void TearDown () + [TearDown] + public void TearDown () { // restore original culture Thread.CurrentThread.CurrentCulture = orgCulture; @@ -43,17 +45,17 @@ public class StringTest : TestCase [Test] // ctor (Char []) public unsafe void Constructor2 () { - AssertEquals ("#1", String.Empty, new String ((char[]) null)); - AssertEquals ("#2", String.Empty, new String (new Char [0])); - AssertEquals ("#3", "A", new String (new Char [1] {'A'})); + Assert.AreEqual (String.Empty, new String ((char[]) null), "#1"); + Assert.AreEqual (String.Empty, new String (new Char [0]), "#2"); + Assert.AreEqual ("A", new String (new Char [1] {'A'}), "#3"); } #endif [Test] // ctor (Char, Int32) public void Constructor4 () { - AssertEquals (string.Empty, new String ('A', 0)); - AssertEquals ("AAA", new String ('A', 3)); + Assert.AreEqual (string.Empty, new String ('A', 0)); + Assert.AreEqual (new String ('A', 3), "AAA"); } [Test] // ctor (Char, Int32) @@ -61,13 +63,13 @@ public class StringTest : TestCase { try { new String ('A', -1); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // 'count' must be non-negative - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "count", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("count", ex.ParamName, "#5"); } } @@ -75,9 +77,9 @@ public class StringTest : TestCase public void Constructor6 () { char [] arr = new char [3] { 'A', 'B', 'C' }; - AssertEquals ("#1", "ABC", new String (arr, 0, arr.Length)); - AssertEquals ("#2", "BC", new String (arr, 1, 2)); - AssertEquals ("#3", string.Empty, new String (arr, 2, 0)); + Assert.AreEqual ("ABC", new String (arr, 0, arr.Length), "#1"); + Assert.AreEqual ("BC", new String (arr, 1, 2), "#2"); + Assert.AreEqual (string.Empty, new String (arr, 2, 0), "#3"); } [Test] // ctor (Char [], Int32, Int32) @@ -87,13 +89,13 @@ public class StringTest : TestCase try { new String (arr, 0, -1); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // Length cannot be less than zero - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "length", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("length", ex.ParamName, "#5"); } } @@ -104,14 +106,14 @@ public class StringTest : TestCase try { new String (arr, 1, 3); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // Index was out of range. Must be non-negative and // less than the size of the collection - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#5"); } } @@ -122,13 +124,13 @@ public class StringTest : TestCase try { new String (arr, -1, 0); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // StartIndex cannot be less than zero - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#5"); } } @@ -137,12 +139,12 @@ public class StringTest : TestCase { try { new String ((char []) null, 0, 0); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentNullException ex) { - AssertEquals ("#2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "value", ex.ParamName); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("value", ex.ParamName, "#5"); } } @@ -150,8 +152,8 @@ public class StringTest : TestCase [Test] public unsafe void CharPtrConstructor () { - AssertEquals ("char*", String.Empty, new String ((char*) null)); - AssertEquals ("char*,int,int", String.Empty, new String ((char*) null, 0, 0)); + Assert.AreEqual (String.Empty, new String ((char*) null), "char*"); + Assert.AreEqual (String.Empty, new String ((char*) null, 0, 0), "char*,int,int"); } [Test] @@ -162,7 +164,7 @@ public class StringTest : TestCase byte[] bytes = encoding.GetBytes (s); fixed (byte* bytePtr = bytes) - AssertEquals (s, new String ((sbyte*) bytePtr, 0, bytes.Length, encoding)); + Assert.AreEqual (s, new String ((sbyte*) bytePtr, 0, bytes.Length, encoding)); } [Test] @@ -184,17 +186,17 @@ public class StringTest : TestCase fixed (byte* bytePtr = bytes) { - AssertEquals (s.Substring (0, s.Length - 1), new String ((sbyte*) bytePtr)); - AssertEquals (s, new String ((sbyte*) bytePtr, 0, bytes.Length)); - AssertEquals (s, new String ((sbyte*) bytePtr, 0, bytes.Length, null)); - AssertEquals (s, new String ((sbyte*) bytePtr, 0, bytes.Length, encoding)); + Assert.AreEqual (s.Substring (0, s.Length - 1), new String ((sbyte*) bytePtr)); + Assert.AreEqual (s, new String ((sbyte*) bytePtr, 0, bytes.Length)); + Assert.AreEqual (s, new String ((sbyte*) bytePtr, 0, bytes.Length, null)); + Assert.AreEqual (s, new String ((sbyte*) bytePtr, 0, bytes.Length, encoding)); } } [Test] // ctor (SByte*) public unsafe void Constructor3_Value_Null () { - AssertEquals (String.Empty, new String ((sbyte*) null)); + Assert.AreEqual (String.Empty, new String ((sbyte*) null)); } [Test] // ctor (SByte*) @@ -202,14 +204,14 @@ public class StringTest : TestCase { try { new String ((sbyte*) (-1)); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // Pointer startIndex and length do not refer to a // valid string - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "ptr", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("ptr", ex.ParamName, "#5"); } } @@ -218,13 +220,13 @@ public class StringTest : TestCase { try { new String ((sbyte*) null, 0, -1); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // Length cannot be less than zero - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "length", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("length", ex.ParamName, "#5"); } } @@ -233,13 +235,13 @@ public class StringTest : TestCase { try { new String ((sbyte*) null, -1, 0); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // StartIndex cannot be less than zero - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#5"); } } @@ -248,26 +250,26 @@ public class StringTest : TestCase { try { new String ((sbyte*) (-1), 1, 0); - Fail ("#A1"); + Assert.Fail ("#A1"); } catch (ArgumentOutOfRangeException ex) { // Pointer startIndex and length do not refer to a // valid string - AssertEquals ("#A2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#A3", ex.InnerException); - AssertNotNull ("#A4", ex.Message); - AssertEquals ("#A5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2"); + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#A5"); } try { new String ((sbyte*) (-1), 1, 1); - Fail ("#B1"); + Assert.Fail ("#B1"); } catch (ArgumentOutOfRangeException ex) { // Pointer startIndex and length do not refer to a // valid string - AssertEquals ("#B2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#B3", ex.InnerException); - AssertNotNull ("#B4", ex.Message); - AssertEquals ("#B5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2"); + Assert.IsNull (ex.InnerException, "#B3"); + Assert.IsNotNull (ex.Message, "#B4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#B5"); } } @@ -276,14 +278,14 @@ public class StringTest : TestCase { try { new String ((sbyte*) (-1), 0, 1); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // Pointer startIndex and length do not refer to a // valid string - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "ptr", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("ptr", ex.ParamName, "#5"); } } @@ -293,43 +295,43 @@ public class StringTest : TestCase #if NET_2_0 try { new String ((sbyte*) null, 0, 0); - Fail ("#A1"); + Assert.Fail ("#A1"); } catch (ArgumentNullException ex) { - AssertEquals ("#A2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#A3", ex.InnerException); - AssertNotNull ("#A4", ex.Message); - AssertEquals ("#A5", "value", ex.ParamName); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2"); + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); + Assert.AreEqual ("value", ex.ParamName, "#A5"); } #else - AssertEquals ("#A", String.Empty, new String ((sbyte*) null, 0, 0)); + Assert.AreEqual (String.Empty, new String ((sbyte*) null, 0, 0), "#A"); #endif #if NET_2_0 try { new String ((sbyte*) null, 0, 1); - Fail ("#B1"); + Assert.Fail ("#B1"); } catch (ArgumentNullException ex) { - AssertEquals ("#B2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#B3", ex.InnerException); - AssertNotNull ("#B4", ex.Message); - AssertEquals ("#B5", "value", ex.ParamName); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2"); + Assert.IsNull (ex.InnerException, "#B3"); + Assert.IsNotNull (ex.Message, "#B4"); + Assert.AreEqual ("value", ex.ParamName, "#B5"); } #else - AssertEquals ("#B", String.Empty, new String ((sbyte*) null, 0, 1)); + Assert.AreEqual (String.Empty, new String ((sbyte*) null, 0, 1), "#B"); #endif #if NET_2_0 try { new String ((sbyte*) null, 1, 0); - Fail ("#C1"); + Assert.Fail ("#C1"); } catch (ArgumentNullException ex) { - AssertEquals ("#C2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#C3", ex.InnerException); - AssertNotNull ("#C4", ex.Message); - AssertEquals ("#C5", "value", ex.ParamName); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#C2"); + Assert.IsNull (ex.InnerException, "#C3"); + Assert.IsNotNull (ex.Message, "#C4"); + Assert.AreEqual ("value", ex.ParamName, "#C5"); } #else - AssertEquals ("#C", String.Empty, new String ((sbyte*) null, 1, 0)); + Assert.AreEqual (String.Empty, new String ((sbyte*) null, 1, 0), "#C"); #endif } @@ -338,24 +340,24 @@ public class StringTest : TestCase { try { new String ((sbyte*) null, 0, -1, null); - Fail ("#A1"); + Assert.Fail ("#A1"); } catch (ArgumentOutOfRangeException ex) { // Length cannot be less than zero - AssertEquals ("#A2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#A3", ex.InnerException); - AssertNotNull ("#A4", ex.Message); - AssertEquals ("#A5", "length", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2"); + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); + Assert.AreEqual ("length", ex.ParamName, "#A5"); } try { new String ((sbyte*) null, 0, -1, Encoding.Default); - Fail ("#B1"); + Assert.Fail ("#B1"); } catch (ArgumentOutOfRangeException ex) { // Non-negative number required - AssertEquals ("#B2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#B3", ex.InnerException); - AssertNotNull ("#B4", ex.Message); - AssertEquals ("#B5", "length", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2"); + Assert.IsNull (ex.InnerException, "#B3"); + Assert.IsNotNull (ex.Message, "#B4"); + Assert.AreEqual ("length", ex.ParamName, "#B5"); } } @@ -364,24 +366,24 @@ public class StringTest : TestCase { try { new String ((sbyte*) null, -1, 0, null); - Fail ("#A1"); + Assert.Fail ("#A1"); } catch (ArgumentOutOfRangeException ex) { // StartIndex cannot be less than zero - AssertEquals ("#A2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#A3", ex.InnerException); - AssertNotNull ("#A4", ex.Message); - AssertEquals ("#A5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2"); + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#A5"); } try { new String ((sbyte*) null, -1, 0, Encoding.Default); - Fail ("#B1"); + Assert.Fail ("#B1"); } catch (ArgumentOutOfRangeException ex) { // StartIndex cannot be less than zero - AssertEquals ("#B2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#B3", ex.InnerException); - AssertNotNull ("#B4", ex.Message); - AssertEquals ("#B5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2"); + Assert.IsNull (ex.InnerException, "#B3"); + Assert.IsNotNull (ex.Message, "#B4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#B5"); } } @@ -390,50 +392,50 @@ public class StringTest : TestCase { try { new String ((sbyte*) (-1), 1, 0, null); - Fail ("#A1"); + Assert.Fail ("#A1"); } catch (ArgumentOutOfRangeException ex) { // Pointer startIndex and length do not refer to a // valid string - AssertEquals ("#A2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#A3", ex.InnerException); - AssertNotNull ("#A4", ex.Message); - AssertEquals ("#A5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2"); + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#A5"); } try { new String ((sbyte*) (-1), 1, 1, null); - Fail ("#B1"); + Assert.Fail ("#B1"); } catch (ArgumentOutOfRangeException ex) { // Pointer startIndex and length do not refer to a // valid string - AssertEquals ("#B2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#B3", ex.InnerException); - AssertNotNull ("#B4", ex.Message); - AssertEquals ("#B5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2"); + Assert.IsNull (ex.InnerException, "#B3"); + Assert.IsNotNull (ex.Message, "#B4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#B5"); } try { new String ((sbyte*) (-1), 1, 0, Encoding.Default); - Fail ("#C1"); + Assert.Fail ("#C1"); } catch (ArgumentOutOfRangeException ex) { // Pointer startIndex and length do not refer to a // valid string - AssertEquals ("#C2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#C3", ex.InnerException); - AssertNotNull ("#C4", ex.Message); - AssertEquals ("#C5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2"); + Assert.IsNull (ex.InnerException, "#C3"); + Assert.IsNotNull (ex.Message, "#C4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#C5"); } try { new String ((sbyte*) (-1), 1, 1, Encoding.Default); - Fail ("#D1"); + Assert.Fail ("#D1"); } catch (ArgumentOutOfRangeException ex) { // Pointer startIndex and length do not refer to a // valid string - AssertEquals ("#D2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#D3", ex.InnerException); - AssertNotNull ("#D4", ex.Message); - AssertEquals ("#D5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#D2"); + Assert.IsNull (ex.InnerException, "#D3"); + Assert.IsNotNull (ex.Message, "#D4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#D5"); } } @@ -442,14 +444,14 @@ public class StringTest : TestCase { try { new String ((sbyte*) (-1), 0, 1, null); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // Pointer startIndex and length do not refer to a // valid string - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "ptr", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("ptr", ex.ParamName, "#5"); } } @@ -471,68 +473,68 @@ public class StringTest : TestCase #if NET_2_0 try { new String ((sbyte*) null, 0, 0, null); - Fail ("#A1"); + Assert.Fail ("#A1"); } catch (ArgumentNullException ex) { - AssertEquals ("#A2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#A3", ex.InnerException); - AssertNotNull ("#A4", ex.Message); - AssertEquals ("#A5", "value", ex.ParamName); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2"); + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); + Assert.AreEqual ("value", ex.ParamName, "#A5"); } #else - AssertEquals ("#A", String.Empty, new String ((sbyte*) null, 0, 0, null)); + Assert.AreEqual (String.Empty, new String ((sbyte*) null, 0, 0, null), "#A"); #endif #if NET_2_0 try { new String ((sbyte*) null, 0, 1, null); - Fail ("#B1"); + Assert.Fail ("#B1"); } catch (ArgumentNullException ex) { - AssertEquals ("#B2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#B3", ex.InnerException); - AssertNotNull ("#B4", ex.Message); - AssertEquals ("#B5", "value", ex.ParamName); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2"); + Assert.IsNull (ex.InnerException, "#B3"); + Assert.IsNotNull (ex.Message, "#B4"); + Assert.AreEqual ("value", ex.ParamName, "#B5"); } #else - AssertEquals ("#B", String.Empty, new String ((sbyte*) null, 0, 1, null)); + Assert.AreEqual (String.Empty, new String ((sbyte*) null, 0, 1, null), "#B"); #endif #if NET_2_0 try { new String ((sbyte*) null, 1, 0, null); - Fail ("#C1"); + Assert.Fail ("#C1"); } catch (ArgumentNullException ex) { - AssertEquals ("#C2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#C3", ex.InnerException); - AssertNotNull ("#C4", ex.Message); - AssertEquals ("#C5", "value", ex.ParamName); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#C2"); + Assert.IsNull (ex.InnerException, "#C3"); + Assert.IsNotNull (ex.Message, "#C4"); + Assert.AreEqual ("value", ex.ParamName, "#C5"); } #else - AssertEquals ("#C", String.Empty, new String ((sbyte*) null, 1, 0, null)); + Assert.AreEqual (String.Empty, new String ((sbyte*) null, 1, 0, null), "#C"); #endif - AssertEquals ("#D", String.Empty, new String ((sbyte*) null, 0, 0, Encoding.Default)); + Assert.AreEqual (String.Empty, new String ((sbyte*) null, 0, 0, Encoding.Default), "#D"); try { new String ((sbyte*) null, 0, 1, Encoding.Default); - Fail ("#E1"); + Assert.Fail ("#E1"); #if NET_2_0 } catch (ArgumentOutOfRangeException ex) { // Pointer startIndex and length do not refer to a // valid string - AssertEquals ("#E2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#E3", ex.InnerException); - AssertNotNull ("#E4", ex.Message); - //AssertEquals ("#E5", "value", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#E2"); + Assert.IsNull (ex.InnerException, "#E3"); + Assert.IsNotNull (ex.Message, "#E4"); + //Assert.AreEqual ("value", ex.ParamName, "#E5"); } #else } catch (NullReferenceException ex) { - AssertEquals ("#E2", typeof (NullReferenceException), ex.GetType ()); - AssertNull ("#E3", ex.InnerException); - AssertNotNull ("#E4", ex.Message); + Assert.AreEqual (typeof (NullReferenceException), ex.GetType (), "#E2"); + Assert.IsNull (ex.InnerException, "#E3"); + Assert.IsNotNull (ex.Message, "#E4"); } #endif - AssertEquals ("#F", String.Empty, new String ((sbyte*) null, 1, 0, Encoding.Default)); + Assert.AreEqual (String.Empty, new String ((sbyte*) null, 1, 0, Encoding.Default), "#F"); } #endif @@ -541,26 +543,26 @@ public class StringTest : TestCase { string str = "test string"; - AssertEquals("wrong length", 11, str.Length); + Assert.AreEqual (11, str.Length, "wrong length"); } [Test] public void Clone () { string s1 = "oRiGiNal"; - AssertEquals ("#A1", s1, s1.Clone ()); - AssertSame ("#A2", s1, s1.Clone ()); + Assert.AreEqual (s1, s1.Clone (), "#A1"); + Assert.AreSame (s1, s1.Clone (), "#A2"); string s2 = new DateTime (2000, 6, 3).ToString (); - AssertEquals ("#B1", s2, s2.Clone ()); - AssertSame ("#B2", s2, s2.Clone ()); + Assert.AreEqual (s2, s2.Clone (), "#B1"); + Assert.AreSame (s2, s2.Clone (), "#B2"); } [Test] // bug #316666 public void CompareNotWorking () { - AssertEquals ("A03", String.Compare ("A", "a"), 1); - AssertEquals ("A04", String.Compare ("a", "A"), -1); + Assert.AreEqual (String.Compare ("A", "a"), 1, "A03"); + Assert.AreEqual (String.Compare ("a", "A"), -1, "A04"); } [Test] @@ -568,11 +570,10 @@ public class StringTest : TestCase { string needle = "ab"; string haystack = "abbcbacab"; - AssertEquals("basic substring check #9", 0, - String.Compare(needle, 0, haystack, 0, 2, false)); + Assert.AreEqual (0, String.Compare(needle, 0, haystack, 0, 2, false), "basic substring check #9"); for (int i = 1; i <= (haystack.Length - needle.Length); i++) { if (i != 7) { - AssertEquals("loop substring check #8/" + i, -1, String.Compare(needle, 0, haystack, i, 2, false)); + Assert.AreEqual (-1, String.Compare(needle, 0, haystack, i, 2, false), "loop substring check #8/" + i); } } } @@ -585,62 +586,54 @@ public class StringTest : TestCase string greater = "xyz"; string caps = "ABC"; - AssertEquals(0, String.Compare (null, null)); - AssertEquals(1, String.Compare (lesser, null)); + Assert.AreEqual (0, String.Compare (null, null)); + Assert.AreEqual (1, String.Compare (lesser, null)); - Assert (String.Compare (lesser, greater) < 0); - Assert (String.Compare (greater, lesser) > 0); - Assert (String.Compare (lesser, lesser) == 0); - Assert (String.Compare (lesser, medium) < 0); + Assert.IsTrue (String.Compare (lesser, greater) < 0); + Assert.IsTrue (String.Compare (greater, lesser) > 0); + Assert.IsTrue (String.Compare (lesser, lesser) == 0); + Assert.IsTrue (String.Compare (lesser, medium) < 0); - Assert (String.Compare (lesser, caps, true) == 0); - Assert (String.Compare (lesser, caps, false) != 0); - AssertEquals ("A01", String.Compare ("a", "b"), -1); - AssertEquals ("A02", String.Compare ("b", "a"), 1); + Assert.IsTrue (String.Compare (lesser, caps, true) == 0); + Assert.IsTrue (String.Compare (lesser, caps, false) != 0); + Assert.AreEqual (String.Compare ("a", "b"), -1, "A01"); + Assert.AreEqual (String.Compare ("b", "a"), 1, "A02"); // TODO - test with CultureInfo string needle = "ab"; string haystack = "abbcbacab"; - AssertEquals("basic substring check #1", 0, - String.Compare(needle, 0, haystack, 0, 2)); - AssertEquals("basic substring check #2", -1, - String.Compare(needle, 0, haystack, 0, 3)); - AssertEquals("basic substring check #3", 0, - String.Compare("ab", 0, "ab", 0, 2)); - AssertEquals("basic substring check #4", 0, - String.Compare("ab", 0, "ab", 0, 3)); - AssertEquals("basic substring check #5", 0, - String.Compare("abc", 0, "ab", 0, 2)); - AssertEquals("basic substring check #6", 1, - String.Compare("abc", 0, "ab", 0, 5)); - AssertEquals("basic substring check #7", -1, - String.Compare("ab", 0, "abc", 0, 5)); + Assert.AreEqual (0, String.Compare(needle, 0, haystack, 0, 2), "basic substring check #1"); + Assert.AreEqual (-1, String.Compare(needle, 0, haystack, 0, 3), "basic substring check #2"); + Assert.AreEqual (0, String.Compare("ab", 0, "ab", 0, 2), "basic substring check #3"); + Assert.AreEqual (0, String.Compare("ab", 0, "ab", 0, 3), "basic substring check #4"); + Assert.AreEqual (0, String.Compare("abc", 0, "ab", 0, 2), "basic substring check #5"); + Assert.AreEqual (1, String.Compare("abc", 0, "ab", 0, 5), "basic substring check #6"); + Assert.AreEqual (-1, String.Compare("ab", 0, "abc", 0, 5), "basic substring check #7"); for (int i = 1; i <= (haystack.Length - needle.Length); i++) { if (i != 7) { - Assert("loop substring check #1/" + i, String.Compare(needle, 0, haystack, i, 2) != 0); - Assert("loop substring check #2/" + i, String.Compare(needle, 0, haystack, i, 3) != 0); + Assert.IsTrue (String.Compare(needle, 0, haystack, i, 2) != 0, "loop substring check #1/" + i); + Assert.IsTrue (String.Compare(needle, 0, haystack, i, 3) != 0, "loop substring check #2/" + i); } else { - AssertEquals("loop substring check #3/" + i, 0, String.Compare(needle, 0, haystack, i, 2)); - AssertEquals("loop substring check #4/" + i, 0, String.Compare(needle, 0, haystack, i, 3)); + Assert.AreEqual (0, String.Compare(needle, 0, haystack, i, 2), "loop substring check #3/" + i); + Assert.AreEqual (0, String.Compare(needle, 0, haystack, i, 3), "loop substring check #4/" + i); } } needle = "AB"; - AssertEquals("basic substring check #8", 0, - String.Compare(needle, 0, haystack, 0, 2, true)); + Assert.AreEqual (0, String.Compare(needle, 0, haystack, 0, 2, true), "basic substring check #8"); for (int i = 1; i <= (haystack.Length - needle.Length); i++) { if (i != 7) { - Assert("loop substring check #5/" + i, String.Compare(needle, 0, haystack, i, 2, true) != 0); - Assert("loop substring check #6/" + i, String.Compare(needle, 0, haystack, i, 2, false) != 0); + Assert.IsTrue (String.Compare(needle, 0, haystack, i, 2, true) != 0, "loop substring check #5/" + i); + Assert.IsTrue (String.Compare(needle, 0, haystack, i, 2, false) != 0, "loop substring check #6/" + i); } else { - AssertEquals("loop substring check #7/" + i, 0, String.Compare(needle, 0, haystack, i, 2, true)); + Assert.AreEqual (0, String.Compare(needle, 0, haystack, i, 2, true), "loop substring check #7/" + i); } } - AssertEquals ("Compare with 0 length", 0, String.Compare (needle, 0, haystack, 0, 0)); + Assert.AreEqual (0, String.Compare (needle, 0, haystack, 0, 0), "Compare with 0 length"); // TODO - extended format call with CultureInfo } @@ -652,27 +645,25 @@ public class StringTest : TestCase string medium = "abcd"; string greater = "xyz"; - AssertEquals(0, String.CompareOrdinal (null, null)); - AssertEquals(1, String.CompareOrdinal (lesser, null)); + Assert.AreEqual (0, String.CompareOrdinal (null, null)); + Assert.AreEqual (1, String.CompareOrdinal (lesser, null)); - Assert ("#1", String.CompareOrdinal (lesser, greater) < 0); - Assert ("#2", String.CompareOrdinal (greater, lesser) > 0); - Assert ("#3", String.CompareOrdinal (lesser, lesser) == 0); - Assert ("#4", String.CompareOrdinal (lesser, medium) < 0); + Assert.IsTrue (String.CompareOrdinal (lesser, greater) < 0, "#1"); + Assert.IsTrue (String.CompareOrdinal (greater, lesser) > 0, "#2"); + Assert.IsTrue (String.CompareOrdinal (lesser, lesser) == 0, "#3"); + Assert.IsTrue (String.CompareOrdinal (lesser, medium) < 0, "#4"); string needle = "ab"; string haystack = "abbcbacab"; - AssertEquals("basic substring check", 0, - String.CompareOrdinal(needle, 0, haystack, 0, 2)); - AssertEquals("basic substring miss", -1, - String.CompareOrdinal(needle, 0, haystack, 0, 3)); + Assert.AreEqual (0, String.CompareOrdinal(needle, 0, haystack, 0, 2), "basic substring check"); + Assert.AreEqual (-1, String.CompareOrdinal(needle, 0, haystack, 0, 3), "basic substring miss"); for (int i = 1; i <= (haystack.Length - needle.Length); i++) { if (i != 7) { - Assert("loop substring check " + i, String.CompareOrdinal(needle, 0, haystack, i, 2) != 0); - Assert("loop substring check " + i, String.CompareOrdinal(needle, 0, haystack, i, 3) != 0); + Assert.IsTrue (String.CompareOrdinal(needle, 0, haystack, i, 2) != 0, "loop substring check " + i); + Assert.IsTrue (String.CompareOrdinal(needle, 0, haystack, i, 3) != 0, "loop substring check " + i); } else { - AssertEquals("loop substring check " + i, 0, String.CompareOrdinal(needle, 0, haystack, i, 2)); - AssertEquals("loop substring check " + i, 0, String.CompareOrdinal(needle, 0, haystack, i, 3)); + Assert.AreEqual (0, String.CompareOrdinal(needle, 0, haystack, i, 2), "loop substring check " + i); + Assert.AreEqual (0, String.CompareOrdinal(needle, 0, haystack, i, 3), "loop substring check " + i); } } } @@ -684,9 +675,9 @@ public class StringTest : TestCase string greater = "xyz"; string lesser = "abc"; - Assert (lower.CompareTo (greater) < 0); - Assert (lower.CompareTo (lower) == 0); - Assert (greater.CompareTo (lesser) > 0); + Assert.IsTrue (lower.CompareTo (greater) < 0); + Assert.IsTrue (lower.CompareTo (lower) == 0); + Assert.IsTrue (greater.CompareTo (lesser) > 0); } class WeirdToString @@ -704,22 +695,22 @@ public class StringTest : TestCase string string2 = "string2"; string concat = "string1string2"; - Assert (String.Concat (string1, string2) == concat); + Assert.IsTrue (String.Concat (string1, string2) == concat); - AssertEquals (string1, String.Concat (string1, null)); - AssertEquals (string1, String.Concat (null, string1)); - AssertEquals (string.Empty, String.Concat (null, null)); + Assert.AreEqual (string1, String.Concat (string1, null)); + Assert.AreEqual (string1, String.Concat (null, string1)); + Assert.AreEqual (string.Empty, String.Concat (null, null)); WeirdToString wts = new WeirdToString (); - AssertEquals (string1, String.Concat (string1, wts)); - AssertEquals (string1, String.Concat (wts, string1)); - AssertEquals (string.Empty, String.Concat (wts, wts)); + Assert.AreEqual (string1, String.Concat (string1, wts)); + Assert.AreEqual (string1, String.Concat (wts, string1)); + Assert.AreEqual (string.Empty, String.Concat (wts, wts)); string [] allstr = new string []{ string1, null, string2, concat }; object [] allobj = new object []{ string1, null, string2, concat }; string astr = String.Concat (allstr); - AssertEquals ("string1string2string1string2", astr); + Assert.AreEqual ("string1string2string1string2", astr); string ostr = String.Concat (allobj); - AssertEquals (astr, ostr); + Assert.AreEqual (astr, ostr); } [Test] @@ -727,8 +718,8 @@ public class StringTest : TestCase { string s1 = "original"; string s2 = String.Copy(s1); - AssertEquals("#1", s1, s2); - Assert ("#2", !object.ReferenceEquals (s1, s2)); + Assert.AreEqual (s1, s2, "#1"); + Assert.IsTrue (!object.ReferenceEquals (s1, s2), "#2"); } [Test] @@ -736,12 +727,12 @@ public class StringTest : TestCase { try { String.Copy ((string) null); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentNullException ex) { - AssertEquals ("#2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "str", ex.ParamName); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("str", ex.ParamName, "#5"); } } @@ -751,12 +742,12 @@ public class StringTest : TestCase string s1 = "original"; char[] c1 = new char[s1.Length]; string s2 = new String(c1); - Assert("#1", !s1.Equals(s2)); + Assert.IsTrue (!s1.Equals(s2), "#1"); for (int i = 0; i < s1.Length; i++) { s1.CopyTo(i, c1, i, 1); } s2 = new String(c1); - AssertEquals("#2", s1, s2); + Assert.AreEqual (s1, s2, "#2"); } [Test] @@ -765,13 +756,13 @@ public class StringTest : TestCase char [] dest = new char [4]; try { "Mono".CopyTo (0, dest, 0, -1); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // Count cannot be less than zero - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "count", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("count", ex.ParamName, "#5"); } } @@ -781,14 +772,14 @@ public class StringTest : TestCase char [] dest = new char [4]; try { "Mono".CopyTo (0, dest, 0, Int32.MaxValue); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // Index and count must refer to a location within the // string - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "sourceIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("sourceIndex", ex.ParamName, "#5"); } } @@ -799,12 +790,12 @@ public class StringTest : TestCase try { s.CopyTo (0, (char []) null, 0, s.Length); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentNullException ex) { - AssertEquals ("#2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "destination", ex.ParamName); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("destination", ex.ParamName, "#5"); } } @@ -814,14 +805,14 @@ public class StringTest : TestCase char [] dest = new char [4]; try { "Mono".CopyTo (0, dest, -1, 4); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // Index and count must refer to a location within the // string - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "destinationIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("destinationIndex", ex.ParamName, "#5"); } } @@ -831,14 +822,14 @@ public class StringTest : TestCase char [] dest = new char [4]; try { "Mono".CopyTo (0, dest, Int32.MaxValue, 4); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // Index and count must refer to a location within the // string - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "destinationIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("destinationIndex", ex.ParamName, "#5"); } } @@ -848,14 +839,14 @@ public class StringTest : TestCase char [] dest = new char [4]; try { "Mono".CopyTo (-1, dest, 0, 4); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // Index was out of range. Must be non-negative and // less than the size of the collection - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "sourceIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("sourceIndex", ex.ParamName, "#5"); } } @@ -865,14 +856,14 @@ public class StringTest : TestCase char[] dest = new char [4]; try { "Mono".CopyTo (Int32.MaxValue, dest, 0, 4); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // Index and count must refer to a location within the // string - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "sourceIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("sourceIndex", ex.ParamName, "#5"); } } @@ -884,34 +875,34 @@ public class StringTest : TestCase Thread.CurrentThread.CurrentCulture = new CultureInfo ("tr-TR"); s = "AbC"; - Assert ("#A1", s.EndsWith ("bC")); - Assert ("#A1", !s.EndsWith ("bc")); - Assert ("#A2", !s.EndsWith ("dc")); - Assert ("#A3", !s.EndsWith ("LAbC")); - Assert ("#A4", s.EndsWith (string.Empty)); - Assert ("#A5", !s.EndsWith ("Ab")); - Assert ("#A6", !s.EndsWith ("Abc")); - Assert ("#A7", s.EndsWith ("AbC")); + Assert.IsTrue (s.EndsWith ("bC"), "#A1"); + Assert.IsTrue (!s.EndsWith ("bc"), "#A1"); + Assert.IsTrue (!s.EndsWith ("dc"), "#A2"); + Assert.IsTrue (!s.EndsWith ("LAbC"), "#A3"); + Assert.IsTrue (s.EndsWith (string.Empty), "#A4"); + Assert.IsTrue (!s.EndsWith ("Ab"), "#A5"); + Assert.IsTrue (!s.EndsWith ("Abc"), "#A6"); + Assert.IsTrue (s.EndsWith ("AbC"), "#A7"); s = "Tai"; - Assert ("#B1", s.EndsWith ("ai")); - Assert ("#B2", !s.EndsWith ("AI")); - Assert ("#B3", !s.EndsWith ("LTai")); - Assert ("#B4", s.EndsWith (string.Empty)); - Assert ("#B5", !s.EndsWith ("Ta")); - Assert ("#B6", !s.EndsWith ("tai")); - Assert ("#B7", s.EndsWith ("Tai")); + Assert.IsTrue (s.EndsWith ("ai"), "#B1"); + Assert.IsTrue (!s.EndsWith ("AI"), "#B2"); + Assert.IsTrue (!s.EndsWith ("LTai"), "#B3"); + Assert.IsTrue (s.EndsWith (string.Empty), "#B4"); + Assert.IsTrue (!s.EndsWith ("Ta"), "#B5"); + Assert.IsTrue (!s.EndsWith ("tai"), "#B6"); + Assert.IsTrue (s.EndsWith ("Tai"), "#B7"); Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US"); - Assert ("#C1", s.EndsWith ("ai")); - Assert ("#C2", !s.EndsWith ("AI")); - Assert ("#C3", !s.EndsWith ("LTai")); - Assert ("#C4", s.EndsWith (string.Empty)); - Assert ("#C5", !s.EndsWith ("Ta")); - Assert ("#C6", !s.EndsWith ("tai")); - Assert ("#C7", s.EndsWith ("Tai")); + Assert.IsTrue (s.EndsWith ("ai"), "#C1"); + Assert.IsTrue (!s.EndsWith ("AI"), "#C2"); + Assert.IsTrue (!s.EndsWith ("LTai"), "#C3"); + Assert.IsTrue (s.EndsWith (string.Empty), "#C4"); + Assert.IsTrue (!s.EndsWith ("Ta"), "#C5"); + Assert.IsTrue (!s.EndsWith ("tai"), "#C6"); + Assert.IsTrue (s.EndsWith ("Tai"), "#C7"); } [Test] // EndsWith (String) @@ -919,12 +910,12 @@ public class StringTest : TestCase { try { "ABC".EndsWith ((string) null); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentNullException ex) { - AssertEquals ("#2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "value", ex.ParamName); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("value", ex.ParamName, "#5"); } } @@ -934,14 +925,14 @@ public class StringTest : TestCase { try { "ABC".EndsWith ("C", (StringComparison) 80); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentException ex) { // The string comparison type passed in is currently // not supported - AssertEquals ("#2", typeof (ArgumentException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "comparisonType", ex.ParamName); + Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("comparisonType", ex.ParamName, "#5"); } } @@ -950,12 +941,12 @@ public class StringTest : TestCase { try { "ABC".EndsWith ((string) null, StringComparison.CurrentCulture); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentNullException ex) { - AssertEquals ("#2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "value", ex.ParamName); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("value", ex.ParamName, "#5"); } } @@ -971,85 +962,85 @@ public class StringTest : TestCase culture = null; ignorecase = false; - Assert ("#A1", !s.EndsWith ("bc", ignorecase, culture)); - Assert ("#A2", !s.EndsWith ("dc", ignorecase, culture)); - Assert ("#A3", !s.EndsWith ("LAbC", ignorecase, culture)); - Assert ("#A4", s.EndsWith (string.Empty, ignorecase, culture)); - Assert ("#A5", !s.EndsWith ("Ab", ignorecase, culture)); - Assert ("#A6", !s.EndsWith ("Abc", ignorecase, culture)); - Assert ("#A7", s.EndsWith ("AbC", ignorecase, culture)); + Assert.IsTrue (!s.EndsWith ("bc", ignorecase, culture), "#A1"); + Assert.IsTrue (!s.EndsWith ("dc", ignorecase, culture), "#A2"); + Assert.IsTrue (!s.EndsWith ("LAbC", ignorecase, culture), "#A3"); + Assert.IsTrue (s.EndsWith (string.Empty, ignorecase, culture), "#A4"); + Assert.IsTrue (!s.EndsWith ("Ab", ignorecase, culture), "#A5"); + Assert.IsTrue (!s.EndsWith ("Abc", ignorecase, culture), "#A6"); + Assert.IsTrue (s.EndsWith ("AbC", ignorecase, culture), "#A7"); ignorecase = true; - Assert ("#B1", s.EndsWith ("bc", ignorecase, culture)); - Assert ("#B2", !s.EndsWith ("dc", ignorecase, culture)); - Assert ("#B3", !s.EndsWith ("LAbC", ignorecase, culture)); - Assert ("#B4", s.EndsWith (string.Empty, ignorecase, culture)); - Assert ("#B5", !s.EndsWith ("Ab", ignorecase, culture)); - Assert ("#B6", s.EndsWith ("Abc", ignorecase, culture)); - Assert ("#B7", s.EndsWith ("AbC", ignorecase, culture)); + Assert.IsTrue (s.EndsWith ("bc", ignorecase, culture), "#B1"); + Assert.IsTrue (!s.EndsWith ("dc", ignorecase, culture), "#B2"); + Assert.IsTrue (!s.EndsWith ("LAbC", ignorecase, culture), "#B3"); + Assert.IsTrue (s.EndsWith (string.Empty, ignorecase, culture), "#B4"); + Assert.IsTrue (!s.EndsWith ("Ab", ignorecase, culture), "#B5"); + Assert.IsTrue (s.EndsWith ("Abc", ignorecase, culture), "#B6"); + Assert.IsTrue (s.EndsWith ("AbC", ignorecase, culture), "#B7"); s = "Tai"; culture = null; ignorecase = false; - Assert ("#C1", s.EndsWith ("ai", ignorecase, culture)); - Assert ("#C2", !s.EndsWith ("AI", ignorecase, culture)); - Assert ("#C3", !s.EndsWith ("LTai", ignorecase, culture)); - Assert ("#C4", s.EndsWith (string.Empty, ignorecase, culture)); - Assert ("#C5", !s.EndsWith ("Ta", ignorecase, culture)); - Assert ("#C6", !s.EndsWith ("tai", ignorecase, culture)); - Assert ("#C7", s.EndsWith ("Tai", ignorecase, culture)); + Assert.IsTrue (s.EndsWith ("ai", ignorecase, culture), "#C1"); + Assert.IsTrue (!s.EndsWith ("AI", ignorecase, culture), "#C2"); + Assert.IsTrue (!s.EndsWith ("LTai", ignorecase, culture), "#C3"); + Assert.IsTrue (s.EndsWith (string.Empty, ignorecase, culture), "#C4"); + Assert.IsTrue (!s.EndsWith ("Ta", ignorecase, culture), "#C5"); + Assert.IsTrue (!s.EndsWith ("tai", ignorecase, culture), "#C6"); + Assert.IsTrue (s.EndsWith ("Tai", ignorecase, culture), "#C7"); ignorecase = true; - Assert ("#D1", s.EndsWith ("ai", ignorecase, culture)); - Assert ("#D2", !s.EndsWith ("AI", ignorecase, culture)); - Assert ("#D3", !s.EndsWith ("LTai", ignorecase, culture)); - Assert ("#D4", s.EndsWith (string.Empty, ignorecase, culture)); - Assert ("#D5", !s.EndsWith ("Ta", ignorecase, culture)); - Assert ("#D6", s.EndsWith ("tai", ignorecase, culture)); - Assert ("#D7", s.EndsWith ("Tai", ignorecase, culture)); + Assert.IsTrue (s.EndsWith ("ai", ignorecase, culture), "#D1"); + Assert.IsTrue (!s.EndsWith ("AI", ignorecase, culture), "#D2"); + Assert.IsTrue (!s.EndsWith ("LTai", ignorecase, culture), "#D3"); + Assert.IsTrue (s.EndsWith (string.Empty, ignorecase, culture), "#D4"); + Assert.IsTrue (!s.EndsWith ("Ta", ignorecase, culture), "#D5"); + Assert.IsTrue (s.EndsWith ("tai", ignorecase, culture), "#D6"); + Assert.IsTrue (s.EndsWith ("Tai", ignorecase, culture), "#D7"); s = "Tai"; culture = new CultureInfo ("en-US"); ignorecase = false; - Assert ("#E1", s.EndsWith ("ai", ignorecase, culture)); - Assert ("#E2", !s.EndsWith ("AI", ignorecase, culture)); - Assert ("#E3", !s.EndsWith ("LTai", ignorecase, culture)); - Assert ("#E4", s.EndsWith (string.Empty, ignorecase, culture)); - Assert ("#E5", !s.EndsWith ("Ta", ignorecase, culture)); - Assert ("#E6", !s.EndsWith ("tai", ignorecase, culture)); - Assert ("#E7", s.EndsWith ("Tai", ignorecase, culture)); + Assert.IsTrue (s.EndsWith ("ai", ignorecase, culture), "#E1"); + Assert.IsTrue (!s.EndsWith ("AI", ignorecase, culture), "#E2"); + Assert.IsTrue (!s.EndsWith ("LTai", ignorecase, culture), "#E3"); + Assert.IsTrue (s.EndsWith (string.Empty, ignorecase, culture), "#E4"); + Assert.IsTrue (!s.EndsWith ("Ta", ignorecase, culture), "#E5"); + Assert.IsTrue (!s.EndsWith ("tai", ignorecase, culture), "#E6"); + Assert.IsTrue (s.EndsWith ("Tai", ignorecase, culture), "#E7"); ignorecase = true; - Assert ("#F1", s.EndsWith ("ai", ignorecase, culture)); - Assert ("#F2", s.EndsWith ("AI", ignorecase, culture)); - Assert ("#F3", !s.EndsWith ("LTai", ignorecase, culture)); - Assert ("#F4", s.EndsWith (string.Empty, ignorecase, culture)); - Assert ("#F5", !s.EndsWith ("Ta", ignorecase, culture)); - Assert ("#F6", s.EndsWith ("tai", ignorecase, culture)); - Assert ("#F7", s.EndsWith ("Tai", ignorecase, culture)); + Assert.IsTrue (s.EndsWith ("ai", ignorecase, culture), "#F1"); + Assert.IsTrue (s.EndsWith ("AI", ignorecase, culture), "#F2"); + Assert.IsTrue (!s.EndsWith ("LTai", ignorecase, culture), "#F3"); + Assert.IsTrue (s.EndsWith (string.Empty, ignorecase, culture), "#F4"); + Assert.IsTrue (!s.EndsWith ("Ta", ignorecase, culture), "#F5"); + Assert.IsTrue (s.EndsWith ("tai", ignorecase, culture), "#F6"); + Assert.IsTrue (s.EndsWith ("Tai", ignorecase, culture), "#F7"); Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US"); culture = null; ignorecase = false; - Assert ("#G1", s.EndsWith ("ai", ignorecase, culture)); - Assert ("#G2", !s.EndsWith ("AI", ignorecase, culture)); - Assert ("#G3", !s.EndsWith ("LTai", ignorecase, culture)); - Assert ("#G4", s.EndsWith (string.Empty, ignorecase, culture)); - Assert ("#G5", !s.EndsWith ("Ta", ignorecase, culture)); - Assert ("#G6", !s.EndsWith ("tai", ignorecase, culture)); - Assert ("#G7", s.EndsWith ("Tai", ignorecase, culture)); + Assert.IsTrue (s.EndsWith ("ai", ignorecase, culture), "#G1"); + Assert.IsTrue (!s.EndsWith ("AI", ignorecase, culture), "#G2"); + Assert.IsTrue (!s.EndsWith ("LTai", ignorecase, culture), "#G3"); + Assert.IsTrue (s.EndsWith (string.Empty, ignorecase, culture), "#G4"); + Assert.IsTrue (!s.EndsWith ("Ta", ignorecase, culture), "#G5"); + Assert.IsTrue (!s.EndsWith ("tai", ignorecase, culture), "#G6"); + Assert.IsTrue (s.EndsWith ("Tai", ignorecase, culture), "#G7"); ignorecase = true; - Assert ("#H1", s.EndsWith ("ai", ignorecase, culture)); - Assert ("#H2", s.EndsWith ("AI", ignorecase, culture)); - Assert ("#H3", !s.EndsWith ("LTai", ignorecase, culture)); - Assert ("#H4", s.EndsWith (string.Empty, ignorecase, culture)); - Assert ("#H5", !s.EndsWith ("Ta", ignorecase, culture)); - Assert ("#H6", s.EndsWith ("tai", ignorecase, culture)); - Assert ("#H7", s.EndsWith ("Tai", ignorecase, culture)); + Assert.IsTrue (s.EndsWith ("ai", ignorecase, culture), "#H1"); + Assert.IsTrue (s.EndsWith ("AI", ignorecase, culture), "#H2"); + Assert.IsTrue (!s.EndsWith ("LTai", ignorecase, culture), "#H3"); + Assert.IsTrue (s.EndsWith (string.Empty, ignorecase, culture), "#H4"); + Assert.IsTrue (!s.EndsWith ("Ta", ignorecase, culture), "#H5"); + Assert.IsTrue (s.EndsWith ("tai", ignorecase, culture), "#H6"); + Assert.IsTrue (s.EndsWith ("Tai", ignorecase, culture), "#H7"); } [Test] // EndsWith (String, Boolean, CultureInfo) @@ -1057,12 +1048,12 @@ public class StringTest : TestCase { try { "ABC".EndsWith ((string) null, true, null); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentNullException ex) { - AssertEquals ("#2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "value", ex.ParamName); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("value", ex.ParamName, "#5"); } } #endif @@ -1076,34 +1067,34 @@ public class StringTest : TestCase string no = "copy"; string s1s1 = s1 + s1; - Assert("No match for null", !s1.Equals (null)); - Assert("Should match object", s1.Equals (y)); - Assert("Should match", s1.Equals (yes)); - Assert("Shouldn't match", !s1.Equals (no)); + Assert.IsTrue (!s1.Equals (null), "No match for null"); + Assert.IsTrue (s1.Equals (y), "Should match object"); + Assert.IsTrue (s1.Equals (yes), "Should match"); + Assert.IsTrue (!s1.Equals (no), "Shouldn't match"); - Assert("Static nulls should match", String.Equals (null, null)); - Assert("Should match", String.Equals (s1, yes)); - Assert("Shouldn't match", !String.Equals (s1, no)); + Assert.IsTrue (String.Equals (null, null), "Static nulls should match"); + Assert.IsTrue (String.Equals (s1, yes), "Should match"); + Assert.IsTrue (!String.Equals (s1, no), "Shouldn't match"); - AssertEquals ("Equals (object)", false, s1s1.Equals (y)); + Assert.AreEqual (false, s1s1.Equals (y), "Equals (object)"); } [Test] public void TestFormat () { - AssertEquals ("Empty format string.", string.Empty, String.Format (string.Empty, 0)); - AssertEquals ("Single argument.", "100", String.Format ("{0}", 100)); - AssertEquals ("Single argument, right justified.", "X 37X", String.Format ("X{0,5}X", 37)); - AssertEquals ("Single argument, left justified.", "X37 X", String.Format ("X{0,-5}X", 37)); - AssertEquals ("Whitespace in specifier", " 7d", String.Format ("{0, 4:x}", 125)); - AssertEquals ("Two arguments.", "The 3 wise men.", String.Format ("The {0} wise {1}.", 3, "men")); - AssertEquals ("Three arguments.", "do re me fa so.", String.Format ("{0} re {1} fa {2}.", "do", "me", "so")); - AssertEquals ("Formatted argument.", "###00c0ffee#", String.Format ("###{0:x8}#", 0xc0ffee)); - AssertEquals ("Formatted argument, right justified.", "# 033#", String.Format ("#{0,5:x3}#", 0x33)); - AssertEquals ("Formatted argument, left justified.", "#033 #", String.Format ("#{0,-5:x3}#", 0x33)); - AssertEquals ("Escaped bracket", "typedef struct _MonoObject { ... } MonoObject;", String.Format ("typedef struct _{0} {{ ... }} MonoObject;", "MonoObject")); - AssertEquals ("With Slash", "Could not find file \"a/b\"", String.Format ("Could not find file \"{0}\"", "a/b")); - AssertEquals ("With BackSlash", "Could not find file \"a\\b\"", String.Format ("Could not find file \"{0}\"", "a\\b")); + Assert.AreEqual (string.Empty, String.Format (string.Empty, 0), "Empty format string."); + Assert.AreEqual ("100", String.Format ("{0}", 100), "Single argument."); + Assert.AreEqual ("X 37X", String.Format ("X{0,5}X", 37), "Single argument, right justified."); + Assert.AreEqual ("X37 X", String.Format ("X{0,-5}X", 37), "Single argument, left justified."); + Assert.AreEqual (" 7d", String.Format ("{0, 4:x}", 125), "Whitespace in specifier"); + Assert.AreEqual ("The 3 wise men.", String.Format ("The {0} wise {1}.", 3, "men"), "Two arguments."); + Assert.AreEqual ("do re me fa so.", String.Format ("{0} re {1} fa {2}.", "do", "me", "so"), "Three arguments."); + Assert.AreEqual ("###00c0ffee#", String.Format ("###{0:x8}#", 0xc0ffee), "Formatted argument."); + Assert.AreEqual ("# 033#", String.Format ("#{0,5:x3}#", 0x33), "Formatted argument, right justified."); + Assert.AreEqual ("#033 #", String.Format ("#{0,-5:x3}#", 0x33), "Formatted argument, left justified."); + Assert.AreEqual ("typedef struct _MonoObject { ... } MonoObject;", String.Format ("typedef struct _{0} {{ ... }} MonoObject;", "MonoObject"), "Escaped bracket"); + Assert.AreEqual ("Could not find file \"a/b\"", String.Format ("Could not find file \"{0}\"", "a/b"), "With Slash"); + Assert.AreEqual ("Could not find file \"a\\b\"", String.Format ("Could not find file \"{0}\"", "a\\b"), "With BackSlash"); } [Test] // Format (String, Object) @@ -1111,12 +1102,12 @@ public class StringTest : TestCase { try { String.Format (null, 1); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentNullException ex) { - AssertEquals ("#2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "format", ex.ParamName); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("format", ex.ParamName, "#5"); } } @@ -1125,12 +1116,12 @@ public class StringTest : TestCase { try { String.Format (null, new object [] { 2 }); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentNullException ex) { - AssertEquals ("#2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "format", ex.ParamName); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("format", ex.ParamName, "#5"); } } @@ -1139,12 +1130,12 @@ public class StringTest : TestCase { try { String.Format ("text", (object []) null); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentNullException ex) { - AssertEquals ("#2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "args", ex.ParamName); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("args", ex.ParamName, "#5"); } } @@ -1154,12 +1145,12 @@ public class StringTest : TestCase try { String.Format (CultureInfo.InvariantCulture, null, new object [] { 3 }); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentNullException ex) { - AssertEquals ("#2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "format", ex.ParamName); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("format", ex.ParamName, "#5"); } } @@ -1169,12 +1160,12 @@ public class StringTest : TestCase try { String.Format (CultureInfo.InvariantCulture, "text", (object []) null); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentNullException ex) { - AssertEquals ("#2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "args", ex.ParamName); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("args", ex.ParamName, "#5"); } } @@ -1183,12 +1174,12 @@ public class StringTest : TestCase { try { String.Format (null, 4, 5); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentNullException ex) { - AssertEquals ("#2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "format", ex.ParamName); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("format", ex.ParamName, "#5"); } } @@ -1197,12 +1188,12 @@ public class StringTest : TestCase { try { String.Format (null, 4, 5, 6); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentNullException ex) { - AssertEquals ("#2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "format", ex.ParamName); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("format", ex.ParamName, "#5"); } } @@ -1212,16 +1203,16 @@ public class StringTest : TestCase string s1 = "original"; char[] c1 = new char[s1.Length]; string s2 = new String(c1); - Assert("pre-enumerated string should not match", !s1.Equals(s2)); + Assert.IsTrue (!s1.Equals(s2), "pre-enumerated string should not match"); CharEnumerator en = s1.GetEnumerator(); - AssertNotNull("null enumerator", en); + Assert.IsNotNull (en, "null enumerator"); for (int i = 0; i < s1.Length; i++) { en.MoveNext(); c1[i] = en.Current; } s2 = new String(c1); - AssertEquals("enumerated string should match", s1, s2); + Assert.AreEqual (s1, s2, "enumerated string should match"); } [Test] @@ -1229,22 +1220,21 @@ public class StringTest : TestCase { string s1 = "original"; // TODO - weak test, currently. Just verifies determinicity. - AssertEquals("same string, same hash code", - s1.GetHashCode(), s1.GetHashCode()); + Assert.AreEqual (s1.GetHashCode(), s1.GetHashCode(), "same string, same hash code"); } [Test] public void TestGetType () { string s1 = "original"; - AssertEquals("String type", "System.String", s1.GetType().ToString()); + Assert.AreEqual ("System.String", s1.GetType().ToString(), "String type"); } [Test] public void TestGetTypeCode () { string s1 = "original"; - Assert(s1.GetTypeCode().Equals(TypeCode.String)); + Assert.IsTrue (s1.GetTypeCode().Equals(TypeCode.String)); } [Test] @@ -1254,83 +1244,69 @@ public class StringTest : TestCase try { s1.IndexOf ('q', s1.Length + 1); - Fail ("#A1"); + Assert.Fail ("#A1"); } catch (ArgumentOutOfRangeException ex) { - AssertEquals ("#A2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#A3", ex.InnerException); - AssertNotNull ("#A4", ex.Message); - AssertEquals ("#A5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2"); + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#A5"); } try { s1.IndexOf ('q', s1.Length + 1, 1); - Fail ("#B1"); + Assert.Fail ("#B1"); } catch (ArgumentOutOfRangeException ex) { - AssertEquals ("#B2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#B3", ex.InnerException); - AssertNotNull ("#B4", ex.Message); - AssertEquals ("#B5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2"); + Assert.IsNull (ex.InnerException, "#B3"); + Assert.IsNotNull (ex.Message, "#B4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#B5"); } try { s1.IndexOf ("huh", s1.Length + 1); - Fail ("#C1"); + Assert.Fail ("#C1"); } catch (ArgumentOutOfRangeException ex) { - AssertEquals ("#C2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#C3", ex.InnerException); - AssertNotNull ("#C4", ex.Message); - AssertEquals ("#C5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2"); + Assert.IsNull (ex.InnerException, "#C3"); + Assert.IsNotNull (ex.Message, "#C4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#C5"); } - AssertEquals("basic char index", 1, s1.IndexOf('r')); - AssertEquals("basic char index 2", 2, s1.IndexOf('i')); - AssertEquals("basic char index - no", -1, s1.IndexOf('q')); + Assert.AreEqual (1, s1.IndexOf('r'), "basic char index"); + Assert.AreEqual (2, s1.IndexOf('i'), "basic char index 2"); + Assert.AreEqual (-1, s1.IndexOf('q'), "basic char index - no"); - AssertEquals("basic string index", 1, s1.IndexOf("rig")); - AssertEquals("basic string index 2", 2, s1.IndexOf("i")); - AssertEquals("basic string index 3", 0, string.Empty.IndexOf(string.Empty)); - AssertEquals("basic string index 4", 0, "ABC".IndexOf(string.Empty)); - AssertEquals("basic string index - no", -1, s1.IndexOf("rag")); - - AssertEquals("stepped char index", 1, s1.IndexOf('r', 1)); - AssertEquals("stepped char index 2", 2, s1.IndexOf('i', 1)); - AssertEquals("stepped char index 3", 4, s1.IndexOf('i', 3)); - AssertEquals("stepped char index 4", -1, s1.IndexOf('i', 5)); - AssertEquals("stepped char index 5", -1, s1.IndexOf('l', s1.Length)); - - AssertEquals("stepped limited char index", - 1, s1.IndexOf('r', 1, 1)); - AssertEquals("stepped limited char index", - -1, s1.IndexOf('r', 0, 1)); - AssertEquals("stepped limited char index", - 2, s1.IndexOf('i', 1, 3)); - AssertEquals("stepped limited char index", - 4, s1.IndexOf('i', 3, 3)); - AssertEquals("stepped limited char index", - -1, s1.IndexOf('i', 5, 3)); + Assert.AreEqual (1, s1.IndexOf("rig"), "basic string index"); + Assert.AreEqual (2, s1.IndexOf("i"), "basic string index 2"); + Assert.AreEqual (0, string.Empty.IndexOf(string.Empty), "basic string index 3"); + Assert.AreEqual (0, "ABC".IndexOf(string.Empty), "basic string index 4"); + Assert.AreEqual (-1, s1.IndexOf("rag"), "basic string index - no"); + + Assert.AreEqual (1, s1.IndexOf('r', 1), "stepped char index"); + Assert.AreEqual (2, s1.IndexOf('i', 1), "stepped char index 2"); + Assert.AreEqual (4, s1.IndexOf('i', 3), "stepped char index 3"); + Assert.AreEqual (-1, s1.IndexOf('i', 5), "stepped char index 4"); + Assert.AreEqual (-1, s1.IndexOf('l', s1.Length), "stepped char index 5"); + + Assert.AreEqual (1, s1.IndexOf('r', 1, 1), "stepped limited char index"); + Assert.AreEqual (-1, s1.IndexOf('r', 0, 1), "stepped limited char index"); + Assert.AreEqual (2, s1.IndexOf('i', 1, 3), "stepped limited char index"); + Assert.AreEqual (4, s1.IndexOf('i', 3, 3), "stepped limited char index"); + Assert.AreEqual (-1, s1.IndexOf('i', 5, 3), "stepped limited char index"); s1 = "original original"; - AssertEquals("stepped string index 1", - 0, s1.IndexOf("original", 0)); - AssertEquals("stepped string index 2", - 9, s1.IndexOf("original", 1)); - AssertEquals("stepped string index 3", - -1, s1.IndexOf("original", 10)); - AssertEquals("stepped string index 4", - 3, s1.IndexOf(string.Empty, 3)); - AssertEquals("stepped limited string index 1", - 1, s1.IndexOf("rig", 0, 5)); - AssertEquals("stepped limited string index 2", - -1, s1.IndexOf("rig", 0, 3)); - AssertEquals("stepped limited string index 3", - 10, s1.IndexOf("rig", 2, 15)); - AssertEquals("stepped limited string index 4", - -1, s1.IndexOf("rig", 2, 3)); - AssertEquals("stepped limited string index 5", - 2, s1.IndexOf(string.Empty, 2, 3)); + Assert.AreEqual (0, s1.IndexOf("original", 0), "stepped string index 1"); + Assert.AreEqual (9, s1.IndexOf("original", 1), "stepped string index 2"); + Assert.AreEqual (-1, s1.IndexOf("original", 10), "stepped string index 3"); + Assert.AreEqual (3, s1.IndexOf(string.Empty, 3), "stepped string index 4"); + Assert.AreEqual (1, s1.IndexOf("rig", 0, 5), "stepped limited string index 1"); + Assert.AreEqual (-1, s1.IndexOf("rig", 0, 3), "stepped limited string index 2"); + Assert.AreEqual (10, s1.IndexOf("rig", 2, 15), "stepped limited string index 3"); + Assert.AreEqual (-1, s1.IndexOf("rig", 2, 3), "stepped limited string index 4"); + Assert.AreEqual (2, s1.IndexOf(string.Empty, 2, 3), "stepped limited string index 5"); string s2 = "QBitArray::bitarr_data"; - AssertEquals ("bug #62160", 9, s2.IndexOf ("::")); + Assert.AreEqual (9, s2.IndexOf ("::"), "bug #62160"); } [Test] // IndexOf (String) @@ -1338,17 +1314,17 @@ public class StringTest : TestCase { try { "Mono".IndexOf ((string) null); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentNullException ex) { - AssertEquals ("#2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); #if NET_2_0 - AssertEquals ("#5", "value", ex.ParamName); + Assert.AreEqual ("value", ex.ParamName, "#5"); #else //Fixme: Does it really make sense to check for obsolete // parameter names. Then case this in string. - //AssertEquals ("#5", "string2", ex.ParamName); + //Assert.AreEqual ("string2", ex.ParamName, "#5"); #endif } } @@ -1360,25 +1336,25 @@ public class StringTest : TestCase Thread.CurrentThread.CurrentCulture = new CultureInfo ("tr-TR"); - AssertEquals ("#A1", -1, s.IndexOf ('a', s.Length)); - AssertEquals ("#A2", -1, s.IndexOf ('6', s.Length)); - AssertEquals ("#A3", -1, s.IndexOf ('t', s.Length)); - AssertEquals ("#A4", -1, s.IndexOf ('T', s.Length)); - AssertEquals ("#A5", -1, s.IndexOf ('i', s.Length)); - AssertEquals ("#A6", -1, s.IndexOf ('I', s.Length)); - AssertEquals ("#A7", -1, s.IndexOf ('q', s.Length)); - AssertEquals ("#A8", -1, s.IndexOf ('3', s.Length)); + Assert.AreEqual (-1, s.IndexOf ('a', s.Length), "#A1"); + Assert.AreEqual (-1, s.IndexOf ('6', s.Length), "#A2"); + Assert.AreEqual (-1, s.IndexOf ('t', s.Length), "#A3"); + Assert.AreEqual (-1, s.IndexOf ('T', s.Length), "#A4"); + Assert.AreEqual (-1, s.IndexOf ('i', s.Length), "#A5"); + Assert.AreEqual (-1, s.IndexOf ('I', s.Length), "#A6"); + Assert.AreEqual (-1, s.IndexOf ('q', s.Length), "#A7"); + Assert.AreEqual (-1, s.IndexOf ('3', s.Length), "#A8"); Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US"); - AssertEquals ("#B1", -1, s.IndexOf ('a', s.Length)); - AssertEquals ("#B2", -1, s.IndexOf ('6', s.Length)); - AssertEquals ("#B3", -1, s.IndexOf ('t', s.Length)); - AssertEquals ("#B4", -1, s.IndexOf ('T', s.Length)); - AssertEquals ("#B5", -1, s.IndexOf ('i', s.Length)); - AssertEquals ("#B6", -1, s.IndexOf ('I', s.Length)); - AssertEquals ("#B7", -1, s.IndexOf ('q', s.Length)); - AssertEquals ("#B8", -1, s.IndexOf ('3', s.Length)); + Assert.AreEqual (-1, s.IndexOf ('a', s.Length), "#B1"); + Assert.AreEqual (-1, s.IndexOf ('6', s.Length), "#B2"); + Assert.AreEqual (-1, s.IndexOf ('t', s.Length), "#B3"); + Assert.AreEqual (-1, s.IndexOf ('T', s.Length), "#B4"); + Assert.AreEqual (-1, s.IndexOf ('i', s.Length), "#B5"); + Assert.AreEqual (-1, s.IndexOf ('I', s.Length), "#B6"); + Assert.AreEqual (-1, s.IndexOf ('q', s.Length), "#B7"); + Assert.AreEqual (-1, s.IndexOf ('3', s.Length), "#B8"); } [Test] // IndexOf (String, Int32) @@ -1386,15 +1362,15 @@ public class StringTest : TestCase { string s = "testing123456"; - AssertEquals ("#1", -1, s.IndexOf ("IN", 3)); - AssertEquals ("#2", 4, s.IndexOf ("in", 3)); - AssertEquals ("#3", -1, s.IndexOf ("in", 5)); - AssertEquals ("#4", 7, s.IndexOf ("1", 5)); - AssertEquals ("#5", 12, s.IndexOf ("6", 12)); - AssertEquals ("#6", 0, s.IndexOf ("testing123456", 0)); - AssertEquals ("#7", -1, s.IndexOf ("testing123456", 1)); - AssertEquals ("#8", 5, s.IndexOf (string.Empty, 5)); - AssertEquals ("#9", 0, s.IndexOf (string.Empty, 0)); + Assert.AreEqual (-1, s.IndexOf ("IN", 3), "#1"); + Assert.AreEqual (4, s.IndexOf ("in", 3), "#2"); + Assert.AreEqual (-1, s.IndexOf ("in", 5), "#3"); + Assert.AreEqual (7, s.IndexOf ("1", 5), "#4"); + Assert.AreEqual (12, s.IndexOf ("6", 12), "#5"); + Assert.AreEqual (0, s.IndexOf ("testing123456", 0), "#6"); + Assert.AreEqual (-1, s.IndexOf ("testing123456", 1), "#7"); + Assert.AreEqual (5, s.IndexOf (string.Empty, 5), "#8"); + Assert.AreEqual (0, s.IndexOf (string.Empty, 0), "#9"); } [Test] // IndexOf (String, Int32) @@ -1402,15 +1378,15 @@ public class StringTest : TestCase { try { "Mono".IndexOf ((string) null, 1); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentNullException ex) { - AssertEquals ("#2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); #if NET_2_0 - AssertEquals ("#5", "value", ex.ParamName); + Assert.AreEqual ("value", ex.ParamName, "#5"); #else - AssertEquals ("#5", "string2", ex.ParamName); + Assert.AreEqual ("string2", ex.ParamName, "#5"); #endif } } @@ -1425,140 +1401,140 @@ public class StringTest : TestCase Thread.CurrentThread.CurrentCulture = new CultureInfo ("tr-TR"); comparison_type = StringComparison.CurrentCulture; - AssertEquals ("#A1", 7, s.IndexOf ("123", comparison_type)); - AssertEquals ("#A2", -1, s.IndexOf ("NG", comparison_type)); - AssertEquals ("#A3", -1, s.IndexOf ("nga", comparison_type)); - AssertEquals ("#A4", 0, s.IndexOf ("t", comparison_type)); - AssertEquals ("#A5", -1, s.IndexOf ("T", comparison_type)); - AssertEquals ("#A6", 12, s.IndexOf ("6", comparison_type)); - AssertEquals ("#A7", 3, s.IndexOf ("tin", comparison_type)); - AssertEquals ("#A8", -1, s.IndexOf ("TIN", comparison_type)); - AssertEquals ("#A9", 0, s.IndexOf (string.Empty, comparison_type)); + Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#A1"); + Assert.AreEqual (-1, s.IndexOf ("NG", comparison_type), "#A2"); + Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#A3"); + Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#A4"); + Assert.AreEqual (-1, s.IndexOf ("T", comparison_type), "#A5"); + Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#A6"); + Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#A7"); + Assert.AreEqual (-1, s.IndexOf ("TIN", comparison_type), "#A8"); + Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#A9"); comparison_type = StringComparison.CurrentCultureIgnoreCase; - AssertEquals ("#B1", 7, s.IndexOf ("123", comparison_type)); - AssertEquals ("#B2", 5, s.IndexOf ("NG", comparison_type)); - AssertEquals ("#B3", -1, s.IndexOf ("nga", comparison_type)); - AssertEquals ("#B4", 0, s.IndexOf ("t", comparison_type)); - AssertEquals ("#B5", 0, s.IndexOf ("T", comparison_type)); - AssertEquals ("#B6", 12, s.IndexOf ("6", comparison_type)); - AssertEquals ("#B7", 3, s.IndexOf ("tin", comparison_type)); - AssertEquals ("#B8", -1, s.IndexOf ("TIN", comparison_type)); - AssertEquals ("#B9", 0, s.IndexOf (string.Empty, comparison_type)); + Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#B1"); + Assert.AreEqual (5, s.IndexOf ("NG", comparison_type), "#B2"); + Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#B3"); + Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#B4"); + Assert.AreEqual (0, s.IndexOf ("T", comparison_type), "#B5"); + Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#B6"); + Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#B7"); + Assert.AreEqual (-1, s.IndexOf ("TIN", comparison_type), "#B8"); + Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#B9"); comparison_type = StringComparison.InvariantCulture; - AssertEquals ("#C1", 7, s.IndexOf ("123", comparison_type)); - AssertEquals ("#C2", -1, s.IndexOf ("NG", comparison_type)); - AssertEquals ("#C3", -1, s.IndexOf ("nga", comparison_type)); - AssertEquals ("#C4", 0, s.IndexOf ("t", comparison_type)); - AssertEquals ("#C5", -1, s.IndexOf ("T", comparison_type)); - AssertEquals ("#C6", 12, s.IndexOf ("6", comparison_type)); - AssertEquals ("#C7", 3, s.IndexOf ("tin", comparison_type)); - AssertEquals ("#C8", -1, s.IndexOf ("TIN", comparison_type)); - AssertEquals ("#C9", 0, s.IndexOf (string.Empty, comparison_type)); + Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#C1"); + Assert.AreEqual (-1, s.IndexOf ("NG", comparison_type), "#C2"); + Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#C3"); + Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#C4"); + Assert.AreEqual (-1, s.IndexOf ("T", comparison_type), "#C5"); + Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#C6"); + Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#C7"); + Assert.AreEqual (-1, s.IndexOf ("TIN", comparison_type), "#C8"); + Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#C9"); comparison_type = StringComparison.InvariantCultureIgnoreCase; - AssertEquals ("#D1", 7, s.IndexOf ("123", comparison_type)); - AssertEquals ("#D2", 5, s.IndexOf ("NG", comparison_type)); - AssertEquals ("#D3", -1, s.IndexOf ("nga", comparison_type)); - AssertEquals ("#D4", 0, s.IndexOf ("t", comparison_type)); - AssertEquals ("#D5", 0, s.IndexOf ("T", comparison_type)); - AssertEquals ("#D6", 12, s.IndexOf ("6", comparison_type)); - AssertEquals ("#D7", 3, s.IndexOf ("tin", comparison_type)); - AssertEquals ("#D8", 3, s.IndexOf ("TIN", comparison_type)); - AssertEquals ("#D9", 0, s.IndexOf (string.Empty, comparison_type)); + Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#D1"); + Assert.AreEqual (5, s.IndexOf ("NG", comparison_type), "#D2"); + Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#D3"); + Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#D4"); + Assert.AreEqual (0, s.IndexOf ("T", comparison_type), "#D5"); + Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#D6"); + Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#D7"); + Assert.AreEqual (3, s.IndexOf ("TIN", comparison_type), "#D8"); + Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#D9"); comparison_type = StringComparison.Ordinal; - AssertEquals ("#E1", 7, s.IndexOf ("123", comparison_type)); - AssertEquals ("#E2", -1, s.IndexOf ("NG", comparison_type)); - AssertEquals ("#E3", -1, s.IndexOf ("nga", comparison_type)); - AssertEquals ("#E4", 0, s.IndexOf ("t", comparison_type)); - AssertEquals ("#E5", -1, s.IndexOf ("T", comparison_type)); - AssertEquals ("#E6", 12, s.IndexOf ("6", comparison_type)); - AssertEquals ("#E7", 3, s.IndexOf ("tin", comparison_type)); - AssertEquals ("#E8", -1, s.IndexOf ("TIN", comparison_type)); - AssertEquals ("#E9", 0, s.IndexOf (string.Empty, comparison_type)); + Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#E1"); + Assert.AreEqual (-1, s.IndexOf ("NG", comparison_type), "#E2"); + Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#E3"); + Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#E4"); + Assert.AreEqual (-1, s.IndexOf ("T", comparison_type), "#E5"); + Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#E6"); + Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#E7"); + Assert.AreEqual (-1, s.IndexOf ("TIN", comparison_type), "#E8"); + Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#E9"); comparison_type = StringComparison.OrdinalIgnoreCase; - AssertEquals ("#F1", 7, s.IndexOf ("123", comparison_type)); - AssertEquals ("#F2", 5, s.IndexOf ("NG", comparison_type)); - AssertEquals ("#F3", -1, s.IndexOf ("nga", comparison_type)); - AssertEquals ("#F4", 0, s.IndexOf ("t", comparison_type)); - AssertEquals ("#F5", 0, s.IndexOf ("T", comparison_type)); - AssertEquals ("#F6", 12, s.IndexOf ("6", comparison_type)); - AssertEquals ("#F7", 3, s.IndexOf ("tin", comparison_type)); - AssertEquals ("#F8", 3, s.IndexOf ("TIN", comparison_type)); - AssertEquals ("#F9", 0, s.IndexOf (string.Empty, comparison_type)); + Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#F1"); + Assert.AreEqual (5, s.IndexOf ("NG", comparison_type), "#F2"); + Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#F3"); + Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#F4"); + Assert.AreEqual (0, s.IndexOf ("T", comparison_type), "#F5"); + Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#F6"); + Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#F7"); + Assert.AreEqual (3, s.IndexOf ("TIN", comparison_type), "#F8"); + Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#F9"); Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US"); comparison_type = StringComparison.CurrentCulture; - AssertEquals ("#G1", 7, s.IndexOf ("123", comparison_type)); - AssertEquals ("#G2", -1, s.IndexOf ("NG", comparison_type)); - AssertEquals ("#G3", -1, s.IndexOf ("nga", comparison_type)); - AssertEquals ("#G4", 0, s.IndexOf ("t", comparison_type)); - AssertEquals ("#G5", -1, s.IndexOf ("T", comparison_type)); - AssertEquals ("#G6", 12, s.IndexOf ("6", comparison_type)); - AssertEquals ("#G7", 3, s.IndexOf ("tin", comparison_type)); - AssertEquals ("#G8", -1, s.IndexOf ("TIN", comparison_type)); - AssertEquals ("#G9", 0, s.IndexOf (string.Empty, comparison_type)); + Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#G1"); + Assert.AreEqual (-1, s.IndexOf ("NG", comparison_type), "#G2"); + Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#G3"); + Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#G4"); + Assert.AreEqual (-1, s.IndexOf ("T", comparison_type), "#G5"); + Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#G6"); + Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#G7"); + Assert.AreEqual (-1, s.IndexOf ("TIN", comparison_type), "#G8"); + Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#G9"); comparison_type = StringComparison.CurrentCultureIgnoreCase; - AssertEquals ("#H1", 7, s.IndexOf ("123", comparison_type)); - AssertEquals ("#H2", 5, s.IndexOf ("NG", comparison_type)); - AssertEquals ("#H3", -1, s.IndexOf ("nga", comparison_type)); - AssertEquals ("#H4", 0, s.IndexOf ("t", comparison_type)); - AssertEquals ("#H5", 0, s.IndexOf ("T", comparison_type)); - AssertEquals ("#H6", 12, s.IndexOf ("6", comparison_type)); - AssertEquals ("#H7", 3, s.IndexOf ("tin", comparison_type)); - AssertEquals ("#H8", 3, s.IndexOf ("TIN", comparison_type)); - AssertEquals ("#H9", 0, s.IndexOf (string.Empty, comparison_type)); + Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#H1"); + Assert.AreEqual (5, s.IndexOf ("NG", comparison_type), "#H2"); + Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#H3"); + Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#H4"); + Assert.AreEqual (0, s.IndexOf ("T", comparison_type), "#H5"); + Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#H6"); + Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#H7"); + Assert.AreEqual (3, s.IndexOf ("TIN", comparison_type), "#H8"); + Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#H9"); comparison_type = StringComparison.InvariantCulture; - AssertEquals ("#I1", 7, s.IndexOf ("123", comparison_type)); - AssertEquals ("#I2", -1, s.IndexOf ("NG", comparison_type)); - AssertEquals ("#I3", -1, s.IndexOf ("nga", comparison_type)); - AssertEquals ("#I4", 0, s.IndexOf ("t", comparison_type)); - AssertEquals ("#I5", -1, s.IndexOf ("T", comparison_type)); - AssertEquals ("#I6", 12, s.IndexOf ("6", comparison_type)); - AssertEquals ("#I7", 3, s.IndexOf ("tin", comparison_type)); - AssertEquals ("#I8", -1, s.IndexOf ("TIN", comparison_type)); - AssertEquals ("#I9", 0, s.IndexOf (string.Empty, comparison_type)); + Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#I1"); + Assert.AreEqual (-1, s.IndexOf ("NG", comparison_type), "#I2"); + Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#I3"); + Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#I4"); + Assert.AreEqual (-1, s.IndexOf ("T", comparison_type), "#I5"); + Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#I6"); + Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#I7"); + Assert.AreEqual (-1, s.IndexOf ("TIN", comparison_type), "#I8"); + Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#I9"); comparison_type = StringComparison.InvariantCultureIgnoreCase; - AssertEquals ("#J1", 7, s.IndexOf ("123", comparison_type)); - AssertEquals ("#J2", 5, s.IndexOf ("NG", comparison_type)); - AssertEquals ("#J3", -1, s.IndexOf ("nga", comparison_type)); - AssertEquals ("#J4", 0, s.IndexOf ("t", comparison_type)); - AssertEquals ("#J5", 0, s.IndexOf ("T", comparison_type)); - AssertEquals ("#J6", 12, s.IndexOf ("6", comparison_type)); - AssertEquals ("#J7", 3, s.IndexOf ("tin", comparison_type)); - AssertEquals ("#J8", 3, s.IndexOf ("TIN", comparison_type)); - AssertEquals ("#J9", 0, s.IndexOf (string.Empty, comparison_type)); + Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#J1"); + Assert.AreEqual (5, s.IndexOf ("NG", comparison_type), "#J2"); + Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#J3"); + Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#J4"); + Assert.AreEqual (0, s.IndexOf ("T", comparison_type), "#J5"); + Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#J6"); + Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#J7"); + Assert.AreEqual (3, s.IndexOf ("TIN", comparison_type), "#J8"); + Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#J9"); comparison_type = StringComparison.Ordinal; - AssertEquals ("#K1", 7, s.IndexOf ("123", comparison_type)); - AssertEquals ("#K2", -1, s.IndexOf ("NG", comparison_type)); - AssertEquals ("#K3", -1, s.IndexOf ("nga", comparison_type)); - AssertEquals ("#K4", 0, s.IndexOf ("t", comparison_type)); - AssertEquals ("#K5", -1, s.IndexOf ("T", comparison_type)); - AssertEquals ("#K6", 12, s.IndexOf ("6", comparison_type)); - AssertEquals ("#K7", 3, s.IndexOf ("tin", comparison_type)); - AssertEquals ("#K8", -1, s.IndexOf ("TIN", comparison_type)); - AssertEquals ("#K9", 0, s.IndexOf (string.Empty, comparison_type)); + Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#K1"); + Assert.AreEqual (-1, s.IndexOf ("NG", comparison_type), "#K2"); + Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#K3"); + Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#K4"); + Assert.AreEqual (-1, s.IndexOf ("T", comparison_type), "#K5"); + Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#K6"); + Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#K7"); + Assert.AreEqual (-1, s.IndexOf ("TIN", comparison_type), "#K8"); + Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#K9"); comparison_type = StringComparison.OrdinalIgnoreCase; - AssertEquals ("#L1", 7, s.IndexOf ("123", comparison_type)); - AssertEquals ("#L2", 5, s.IndexOf ("NG", comparison_type)); - AssertEquals ("#L3", -1, s.IndexOf ("nga", comparison_type)); - AssertEquals ("#L4", 0, s.IndexOf ("t", comparison_type)); - AssertEquals ("#L5", 0, s.IndexOf ("T", comparison_type)); - AssertEquals ("#L6", 12, s.IndexOf ("6", comparison_type)); - AssertEquals ("#L7", 3, s.IndexOf ("tin", comparison_type)); - AssertEquals ("#L8", 3, s.IndexOf ("TIN", comparison_type)); - AssertEquals ("#L9", 0, s.IndexOf (string.Empty, comparison_type)); + Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#L1"); + Assert.AreEqual (5, s.IndexOf ("NG", comparison_type), "#L2"); + Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#L3"); + Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#L4"); + Assert.AreEqual (0, s.IndexOf ("T", comparison_type), "#L5"); + Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#L6"); + Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#L7"); + Assert.AreEqual (3, s.IndexOf ("TIN", comparison_type), "#L8"); + Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#L9"); - AssertEquals ("#M", 0, string.Empty.IndexOf (string.Empty, comparison_type)); + Assert.AreEqual (0, string.Empty.IndexOf (string.Empty, comparison_type), "#M"); } [Test] // IndexOf (String, StringComparison) @@ -1566,14 +1542,14 @@ public class StringTest : TestCase { try { "Mono".IndexOf (string.Empty, (StringComparison) Int32.MinValue); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentException ex) { // The string comparison type passed in is currently // not supported - AssertEquals ("#2", typeof (ArgumentException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "comparisonType", ex.ParamName); + Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("comparisonType", ex.ParamName, "#5"); } } @@ -1582,12 +1558,12 @@ public class StringTest : TestCase { try { "Mono".IndexOf ((string) null, StringComparison.Ordinal); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentNullException ex) { - AssertEquals ("#2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "value", ex.ParamName); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("value", ex.ParamName, "#5"); } } @@ -1626,71 +1602,71 @@ public class StringTest : TestCase string text2 = "123"; string text3 = "NG"; string text4 = "t"; - AssertEquals ("#1-1", 7, text.IndexOf (text2, StringComparison.Ordinal)); - AssertEquals ("#2-1", 5, text.IndexOf (text3, StringComparison.OrdinalIgnoreCase)); + Assert.AreEqual (7, text.IndexOf (text2, StringComparison.Ordinal), "#1-1"); + Assert.AreEqual (5, text.IndexOf (text3, StringComparison.OrdinalIgnoreCase), "#2-1"); - AssertEquals ("#1-2", 7, text.IndexOf (text2, 0, StringComparison.Ordinal)); - AssertEquals ("#2-2", 5, text.IndexOf (text3, 0, StringComparison.OrdinalIgnoreCase)); + Assert.AreEqual (7, text.IndexOf (text2, 0, StringComparison.Ordinal), "#1-2"); + Assert.AreEqual (5, text.IndexOf (text3, 0, StringComparison.OrdinalIgnoreCase), "#2-2"); - AssertEquals ("#1-3", 7, text.IndexOf (text2, 1, StringComparison.Ordinal)); - AssertEquals ("#2-3", 5, text.IndexOf (text3, 1, StringComparison.OrdinalIgnoreCase)); + Assert.AreEqual (7, text.IndexOf (text2, 1, StringComparison.Ordinal), "#1-3"); + Assert.AreEqual (5, text.IndexOf (text3, 1, StringComparison.OrdinalIgnoreCase), "#2-3"); - AssertEquals ("#1-4", 7, text.IndexOf (text2, 6, StringComparison.Ordinal)); - AssertEquals ("#2-4", -1, text.IndexOf (text3, 6, StringComparison.OrdinalIgnoreCase)); + Assert.AreEqual (7, text.IndexOf (text2, 6, StringComparison.Ordinal), "#1-4"); + Assert.AreEqual (-1, text.IndexOf (text3, 6, StringComparison.OrdinalIgnoreCase), "#2-4"); - AssertEquals ("#1-5", 7, text.IndexOf (text2, 7, 3, StringComparison.Ordinal)); - AssertEquals ("#2-5", -1, text.IndexOf (text3, 7, 3, StringComparison.OrdinalIgnoreCase)); + Assert.AreEqual (7, text.IndexOf (text2, 7, 3, StringComparison.Ordinal), "#1-5"); + Assert.AreEqual (-1, text.IndexOf (text3, 7, 3, StringComparison.OrdinalIgnoreCase), "#2-5"); - AssertEquals ("#1-6", -1, text.IndexOf (text2, 6, 0, StringComparison.Ordinal)); - AssertEquals ("#2-6", -1, text.IndexOf (text3, 5, 0, StringComparison.OrdinalIgnoreCase)); + Assert.AreEqual (-1, text.IndexOf (text2, 6, 0, StringComparison.Ordinal), "#1-6"); + Assert.AreEqual (-1, text.IndexOf (text3, 5, 0, StringComparison.OrdinalIgnoreCase), "#2-6"); - AssertEquals ("#1-7", -1, text.IndexOf (text2, 7, 1, StringComparison.Ordinal)); - AssertEquals ("#2-7", -1, text.IndexOf (text3, 5, 1, StringComparison.OrdinalIgnoreCase)); + Assert.AreEqual (-1, text.IndexOf (text2, 7, 1, StringComparison.Ordinal), "#1-7"); + Assert.AreEqual (-1, text.IndexOf (text3, 5, 1, StringComparison.OrdinalIgnoreCase), "#2-7"); - AssertEquals ("#3-1", 0, text.IndexOf (text4, 0, StringComparison.Ordinal)); - AssertEquals ("#3-2", 0, text.IndexOf (text4, 0, StringComparison.OrdinalIgnoreCase)); + Assert.AreEqual (0, text.IndexOf (text4, 0, StringComparison.Ordinal), "#3-1"); + Assert.AreEqual (0, text.IndexOf (text4, 0, StringComparison.OrdinalIgnoreCase), "#3-2"); - AssertEquals ("#4-1", -1, text.IndexOf (text4, 13, StringComparison.Ordinal)); - AssertEquals ("#4-2", -1, text.IndexOf (text4, 13, StringComparison.OrdinalIgnoreCase)); + Assert.AreEqual (-1, text.IndexOf (text4, 13, StringComparison.Ordinal), "#4-1"); + Assert.AreEqual (-1, text.IndexOf (text4, 13, StringComparison.OrdinalIgnoreCase), "#4-2"); - AssertEquals ("#4-1", -1, text.IndexOf (text4, 13, 0, StringComparison.Ordinal)); - AssertEquals ("#4-2", -1, text.IndexOf (text4, 13, 0, StringComparison.OrdinalIgnoreCase)); + Assert.AreEqual (-1, text.IndexOf (text4, 13, 0, StringComparison.Ordinal), "#4-1"); + Assert.AreEqual (-1, text.IndexOf (text4, 13, 0, StringComparison.OrdinalIgnoreCase), "#4-2"); - AssertEquals ("#5-1", 12, text.IndexOf ("6", 12, 1, StringComparison.Ordinal)); - AssertEquals ("#5-2", 12, text.IndexOf ("6", 12, 1, StringComparison.OrdinalIgnoreCase)); + Assert.AreEqual (12, text.IndexOf ("6", 12, 1, StringComparison.Ordinal), "#5-1"); + Assert.AreEqual (12, text.IndexOf ("6", 12, 1, StringComparison.OrdinalIgnoreCase), "#5-2"); } [Test] public void IndexOfStringComparisonOrdinal () { string text = "testing123456"; - AssertEquals ("#1", 10, text.IndexOf ("456", StringComparison.Ordinal)); - AssertEquals ("#2", -1, text.IndexOf ("4567", StringComparison.Ordinal)); - AssertEquals ("#3", 0, text.IndexOf ("te", StringComparison.Ordinal)); - AssertEquals ("#4", 2, text.IndexOf ("s", StringComparison.Ordinal)); - AssertEquals ("#5", -1, text.IndexOf ("ates", StringComparison.Ordinal)); - AssertEquals ("#6", -1, text.IndexOf ("S", StringComparison.Ordinal)); + Assert.AreEqual (10, text.IndexOf ("456", StringComparison.Ordinal), "#1"); + Assert.AreEqual (-1, text.IndexOf ("4567", StringComparison.Ordinal), "#2"); + Assert.AreEqual (0, text.IndexOf ("te", StringComparison.Ordinal), "#3"); + Assert.AreEqual (2, text.IndexOf ("s", StringComparison.Ordinal), "#4"); + Assert.AreEqual (-1, text.IndexOf ("ates", StringComparison.Ordinal), "#5"); + Assert.AreEqual (-1, text.IndexOf ("S", StringComparison.Ordinal), "#6"); } [Test] public void IndexOfStringComparisonOrdinalIgnoreCase () { string text = "testing123456"; - AssertEquals ("#1", 10, text.IndexOf ("456", StringComparison.OrdinalIgnoreCase)); - AssertEquals ("#2", -1, text.IndexOf ("4567", StringComparison.OrdinalIgnoreCase)); - AssertEquals ("#3", 0, text.IndexOf ("te", StringComparison.OrdinalIgnoreCase)); - AssertEquals ("#4", 2, text.IndexOf ("s", StringComparison.OrdinalIgnoreCase)); - AssertEquals ("#5", -1, text.IndexOf ("ates", StringComparison.OrdinalIgnoreCase)); - AssertEquals ("#6", 2, text.IndexOf ("S", StringComparison.OrdinalIgnoreCase)); + Assert.AreEqual (10, text.IndexOf ("456", StringComparison.OrdinalIgnoreCase), "#1"); + Assert.AreEqual (-1, text.IndexOf ("4567", StringComparison.OrdinalIgnoreCase), "#2"); + Assert.AreEqual (0, text.IndexOf ("te", StringComparison.OrdinalIgnoreCase), "#3"); + Assert.AreEqual (2, text.IndexOf ("s", StringComparison.OrdinalIgnoreCase), "#4"); + Assert.AreEqual (-1, text.IndexOf ("ates", StringComparison.OrdinalIgnoreCase), "#5"); + Assert.AreEqual (2, text.IndexOf ("S", StringComparison.OrdinalIgnoreCase), "#6"); } [Test] public void IndexOfOrdinalCountSmallerThanValueString () { - AssertEquals ("#1", -1, "Test".IndexOf ("ST", 2, 1, StringComparison.Ordinal)); - AssertEquals ("#2", -1, "Test".IndexOf ("ST", 2, 1, StringComparison.OrdinalIgnoreCase)); - AssertEquals ("#3", -1, "Test".LastIndexOf ("ST", 2, 1, StringComparison.Ordinal)); - AssertEquals ("#4", -1, "Test".LastIndexOf ("ST", 2, 1, StringComparison.OrdinalIgnoreCase)); + Assert.AreEqual (-1, "Test".IndexOf ("ST", 2, 1, StringComparison.Ordinal), "#1"); + Assert.AreEqual (-1, "Test".IndexOf ("ST", 2, 1, StringComparison.OrdinalIgnoreCase), "#2"); + Assert.AreEqual (-1, "Test".LastIndexOf ("ST", 2, 1, StringComparison.Ordinal), "#3"); + Assert.AreEqual (-1, "Test".LastIndexOf ("ST", 2, 1, StringComparison.OrdinalIgnoreCase), "#4"); } #endif @@ -1699,14 +1675,14 @@ public class StringTest : TestCase { try { "Mono".IndexOf ('o', 1, -1); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // Count must be positive and count must refer to a // location within the string/array/collection - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "count", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("count", ex.ParamName, "#5"); } } @@ -1715,14 +1691,14 @@ public class StringTest : TestCase { try { "Mono".IndexOf ('o', 1, Int32.MaxValue); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // Count must be positive and count must refer to a // location within the string/array/collection - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "count", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("count", ex.ParamName, "#5"); } } @@ -1731,14 +1707,14 @@ public class StringTest : TestCase { try { "Mono".IndexOf ('o', -1, 1); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // Index was out of range. Must be non-negative and // less than the size of the collection - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#5"); } } @@ -1749,14 +1725,14 @@ public class StringTest : TestCase try { s.IndexOf ('o', s.Length + 1, 1); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // Index was out of range. Must be non-negative and // less than the size of the collection - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#5"); } } @@ -1767,85 +1743,85 @@ public class StringTest : TestCase Thread.CurrentThread.CurrentCulture = new CultureInfo ("tr-TR"); - AssertEquals ("#A1", -1, s.IndexOf ("123", 4, 5)); - AssertEquals ("#A2", 7, s.IndexOf ("123", 4, 6)); - AssertEquals ("#A3", -1, s.IndexOf ("123", 5, 4)); - AssertEquals ("#A4", 7, s.IndexOf ("123", 5, 5)); - AssertEquals ("#A5", 7, s.IndexOf ("123", 0, s.Length)); - AssertEquals ("#A6", -1, s.IndexOf ("123", s.Length, 0)); - - AssertEquals ("#B1", -1, s.IndexOf ("tin", 2, 3)); - AssertEquals ("#B2", 3, s.IndexOf ("tin", 3, 3)); - AssertEquals ("#B3", -1, s.IndexOf ("tin", 2, 2)); - AssertEquals ("#B4", -1, s.IndexOf ("tin", 1, 4)); - AssertEquals ("#B5", 3, s.IndexOf ("tin", 0, s.Length)); - AssertEquals ("#B6", -1, s.IndexOf ("tin", s.Length, 0)); - - AssertEquals ("#C1", 6, s.IndexOf ("g12", 4, 5)); - AssertEquals ("#C2", -1, s.IndexOf ("g12", 5, 2)); - AssertEquals ("#C3", -1, s.IndexOf ("g12", 5, 3)); - AssertEquals ("#C4", 6, s.IndexOf ("g12", 6, 4)); - AssertEquals ("#C5", 6, s.IndexOf ("g12", 0, s.Length)); - AssertEquals ("#C6", -1, s.IndexOf ("g12", s.Length, 0)); - - AssertEquals ("#D1", 1, s.IndexOf ("est", 0, 5)); - AssertEquals ("#D2", -1, s.IndexOf ("est", 1, 2)); - AssertEquals ("#D3", -1, s.IndexOf ("est", 2, 10)); - AssertEquals ("#D4", 14, s.IndexOf ("est", 7, 10)); - AssertEquals ("#D5", 1, s.IndexOf ("est", 0, s.Length)); - AssertEquals ("#D6", -1, s.IndexOf ("est", s.Length, 0)); - - AssertEquals ("#E1", -1, s.IndexOf ("T", 0, s.Length)); - AssertEquals ("#E2", 4, s.IndexOf ("i", 0, s.Length)); - AssertEquals ("#E3", -1, s.IndexOf ("I", 0, s.Length)); - AssertEquals ("#E4", 12, s.IndexOf ("6", 0, s.Length)); - AssertEquals ("#E5", 0, s.IndexOf ("testing123456", 0, s.Length)); - AssertEquals ("#E6", -1, s.IndexOf ("testing1234567", 0, s.Length)); - AssertEquals ("#E7", 0, s.IndexOf (string.Empty, 0, 0)); - AssertEquals ("#E8", 4, s.IndexOf (string.Empty, 4, 3)); - AssertEquals ("#E9", 0, string.Empty.IndexOf (string.Empty, 0, 0)); - AssertEquals ("#E10", -1, string.Empty.IndexOf ("abc", 0, 0)); + Assert.AreEqual (-1, s.IndexOf ("123", 4, 5), "#A1"); + Assert.AreEqual (7, s.IndexOf ("123", 4, 6), "#A2"); + Assert.AreEqual (-1, s.IndexOf ("123", 5, 4), "#A3"); + Assert.AreEqual (7, s.IndexOf ("123", 5, 5), "#A4"); + Assert.AreEqual (7, s.IndexOf ("123", 0, s.Length), "#A5"); + Assert.AreEqual (-1, s.IndexOf ("123", s.Length, 0), "#A6"); + + Assert.AreEqual (-1, s.IndexOf ("tin", 2, 3), "#B1"); + Assert.AreEqual (3, s.IndexOf ("tin", 3, 3), "#B2"); + Assert.AreEqual (-1, s.IndexOf ("tin", 2, 2), "#B3"); + Assert.AreEqual (-1, s.IndexOf ("tin", 1, 4), "#B4"); + Assert.AreEqual (3, s.IndexOf ("tin", 0, s.Length), "#B5"); + Assert.AreEqual (-1, s.IndexOf ("tin", s.Length, 0), "#B6"); + + Assert.AreEqual (6, s.IndexOf ("g12", 4, 5), "#C1"); + Assert.AreEqual (-1, s.IndexOf ("g12", 5, 2), "#C2"); + Assert.AreEqual (-1, s.IndexOf ("g12", 5, 3), "#C3"); + Assert.AreEqual (6, s.IndexOf ("g12", 6, 4), "#C4"); + Assert.AreEqual (6, s.IndexOf ("g12", 0, s.Length), "#C5"); + Assert.AreEqual (-1, s.IndexOf ("g12", s.Length, 0), "#C6"); + + Assert.AreEqual (1, s.IndexOf ("est", 0, 5), "#D1"); + Assert.AreEqual (-1, s.IndexOf ("est", 1, 2), "#D2"); + Assert.AreEqual (-1, s.IndexOf ("est", 2, 10), "#D3"); + Assert.AreEqual (14, s.IndexOf ("est", 7, 10), "#D4"); + Assert.AreEqual (1, s.IndexOf ("est", 0, s.Length), "#D5"); + Assert.AreEqual (-1, s.IndexOf ("est", s.Length, 0), "#D6"); + + Assert.AreEqual (-1, s.IndexOf ("T", 0, s.Length), "#E1"); + Assert.AreEqual (4, s.IndexOf ("i", 0, s.Length), "#E2"); + Assert.AreEqual (-1, s.IndexOf ("I", 0, s.Length), "#E3"); + Assert.AreEqual (12, s.IndexOf ("6", 0, s.Length), "#E4"); + Assert.AreEqual (0, s.IndexOf ("testing123456", 0, s.Length), "#E5"); + Assert.AreEqual (-1, s.IndexOf ("testing1234567", 0, s.Length), "#E6"); + Assert.AreEqual (0, s.IndexOf (string.Empty, 0, 0), "#E7"); + Assert.AreEqual (4, s.IndexOf (string.Empty, 4, 3), "#E8"); + Assert.AreEqual (0, string.Empty.IndexOf (string.Empty, 0, 0), "#E9"); + Assert.AreEqual (-1, string.Empty.IndexOf ("abc", 0, 0), "#E10"); Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US"); - AssertEquals ("#F1", -1, s.IndexOf ("123", 4, 5)); - AssertEquals ("#F2", 7, s.IndexOf ("123", 4, 6)); - AssertEquals ("#F3", -1, s.IndexOf ("123", 5, 4)); - AssertEquals ("#F4", 7, s.IndexOf ("123", 5, 5)); - AssertEquals ("#F5", 7, s.IndexOf ("123", 0, s.Length)); - AssertEquals ("#F6", -1, s.IndexOf ("123", s.Length, 0)); - - AssertEquals ("#G1", -1, s.IndexOf ("tin", 2, 3)); - AssertEquals ("#G2", 3, s.IndexOf ("tin", 3, 3)); - AssertEquals ("#G3", -1, s.IndexOf ("tin", 2, 2)); - AssertEquals ("#G4", -1, s.IndexOf ("tin", 1, 4)); - AssertEquals ("#G5", 3, s.IndexOf ("tin", 0, s.Length)); - AssertEquals ("#G6", -1, s.IndexOf ("tin", s.Length, 0)); - - AssertEquals ("#H1", 6, s.IndexOf ("g12", 4, 5)); - AssertEquals ("#H2", -1, s.IndexOf ("g12", 5, 2)); - AssertEquals ("#H3", -1, s.IndexOf ("g12", 5, 3)); - AssertEquals ("#H4", 6, s.IndexOf ("g12", 6, 4)); - AssertEquals ("#H5", 6, s.IndexOf ("g12", 0, s.Length)); - AssertEquals ("#H6", -1, s.IndexOf ("g12", s.Length, 0)); - - AssertEquals ("#I1", 1, s.IndexOf ("est", 0, 5)); - AssertEquals ("#I2", -1, s.IndexOf ("est", 1, 2)); - AssertEquals ("#I3", -1, s.IndexOf ("est", 2, 10)); - AssertEquals ("#I4", 14, s.IndexOf ("est", 7, 10)); - AssertEquals ("#I5", 1, s.IndexOf ("est", 0, s.Length)); - AssertEquals ("#I6", -1, s.IndexOf ("est", s.Length, 0)); - - AssertEquals ("#J1", -1, s.IndexOf ("T", 0, s.Length)); - AssertEquals ("#J2", 4, s.IndexOf ("i", 0, s.Length)); - AssertEquals ("#J3", -1, s.IndexOf ("I", 0, s.Length)); - AssertEquals ("#J4", 12, s.IndexOf ("6", 0, s.Length)); - AssertEquals ("#J5", 0, s.IndexOf ("testing123456", 0, s.Length)); - AssertEquals ("#J6", -1, s.IndexOf ("testing1234567", 0, s.Length)); - AssertEquals ("#J7", 0, s.IndexOf (string.Empty, 0, 0)); - AssertEquals ("#J8", 4, s.IndexOf (string.Empty, 4, 3)); - AssertEquals ("#J9", 0, string.Empty.IndexOf (string.Empty, 0, 0)); - AssertEquals ("#J10", -1, string.Empty.IndexOf ("abc", 0, 0)); + Assert.AreEqual (-1, s.IndexOf ("123", 4, 5), "#F1"); + Assert.AreEqual (7, s.IndexOf ("123", 4, 6), "#F2"); + Assert.AreEqual (-1, s.IndexOf ("123", 5, 4), "#F3"); + Assert.AreEqual (7, s.IndexOf ("123", 5, 5), "#F4"); + Assert.AreEqual (7, s.IndexOf ("123", 0, s.Length), "#F5"); + Assert.AreEqual (-1, s.IndexOf ("123", s.Length, 0), "#F6"); + + Assert.AreEqual (-1, s.IndexOf ("tin", 2, 3), "#G1"); + Assert.AreEqual (3, s.IndexOf ("tin", 3, 3), "#G2"); + Assert.AreEqual (-1, s.IndexOf ("tin", 2, 2), "#G3"); + Assert.AreEqual (-1, s.IndexOf ("tin", 1, 4), "#G4"); + Assert.AreEqual (3, s.IndexOf ("tin", 0, s.Length), "#G5"); + Assert.AreEqual (-1, s.IndexOf ("tin", s.Length, 0), "#G6"); + + Assert.AreEqual (6, s.IndexOf ("g12", 4, 5), "#H1"); + Assert.AreEqual (-1, s.IndexOf ("g12", 5, 2), "#H2"); + Assert.AreEqual (-1, s.IndexOf ("g12", 5, 3), "#H3"); + Assert.AreEqual (6, s.IndexOf ("g12", 6, 4), "#H4"); + Assert.AreEqual (6, s.IndexOf ("g12", 0, s.Length), "#H5"); + Assert.AreEqual (-1, s.IndexOf ("g12", s.Length, 0), "#H6"); + + Assert.AreEqual (1, s.IndexOf ("est", 0, 5), "#I1"); + Assert.AreEqual (-1, s.IndexOf ("est", 1, 2), "#I2"); + Assert.AreEqual (-1, s.IndexOf ("est", 2, 10), "#I3"); + Assert.AreEqual (14, s.IndexOf ("est", 7, 10), "#I4"); + Assert.AreEqual (1, s.IndexOf ("est", 0, s.Length), "#I5"); + Assert.AreEqual (-1, s.IndexOf ("est", s.Length, 0), "#I6"); + + Assert.AreEqual (-1, s.IndexOf ("T", 0, s.Length), "#J1"); + Assert.AreEqual (4, s.IndexOf ("i", 0, s.Length), "#J2"); + Assert.AreEqual (-1, s.IndexOf ("I", 0, s.Length), "#J3"); + Assert.AreEqual (12, s.IndexOf ("6", 0, s.Length), "#J4"); + Assert.AreEqual (0, s.IndexOf ("testing123456", 0, s.Length), "#J5"); + Assert.AreEqual (-1, s.IndexOf ("testing1234567", 0, s.Length), "#J6"); + Assert.AreEqual (0, s.IndexOf (string.Empty, 0, 0), "#J7"); + Assert.AreEqual (4, s.IndexOf (string.Empty, 4, 3), "#J8"); + Assert.AreEqual (0, string.Empty.IndexOf (string.Empty, 0, 0), "#J9"); + Assert.AreEqual (-1, string.Empty.IndexOf ("abc", 0, 0), "#J10"); } [Test] // IndexOf (String, Int32, Int32) @@ -1853,14 +1829,14 @@ public class StringTest : TestCase { try { "Mono".IndexOf ("no", 1, -1); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // Count must be positive and count must refer to a // location within the string/array/collection - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "count", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("count", ex.ParamName, "#5"); } } @@ -1871,47 +1847,47 @@ public class StringTest : TestCase try { s.IndexOf ("no", 1, s.Length); - Fail ("#A1"); + Assert.Fail ("#A1"); } catch (ArgumentOutOfRangeException ex) { // Count must be positive and count must refer to a // location within the string/array/collection - AssertEquals ("#A2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#A3", ex.InnerException); - AssertNotNull ("#A4", ex.Message); - AssertEquals ("#A5", "count", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2"); + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); + Assert.AreEqual ("count", ex.ParamName, "#A5"); } try { s.IndexOf ("no", 1, s.Length + 1); - Fail ("#B1"); + Assert.Fail ("#B1"); } catch (ArgumentOutOfRangeException ex) { // Count must be positive and count must refer to a // location within the string/array/collection - AssertEquals ("#B2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#B3", ex.InnerException); - AssertNotNull ("#B4", ex.Message); - AssertEquals ("#B5", "count", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2"); + Assert.IsNull (ex.InnerException, "#B3"); + Assert.IsNotNull (ex.Message, "#B4"); + Assert.AreEqual ("count", ex.ParamName, "#B5"); } try { s.IndexOf ("no", 1, int.MaxValue); - Fail ("#C1"); + Assert.Fail ("#C1"); } catch (ArgumentOutOfRangeException ex) { #if NET_2_0 // Count must be positive and count must refer to a // location within the string/array/collection - AssertEquals ("#C2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#C3", ex.InnerException); - AssertNotNull ("#C4", ex.Message); - AssertEquals ("#C5", "count", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2"); + Assert.IsNull (ex.InnerException, "#C3"); + Assert.IsNotNull (ex.Message, "#C4"); + Assert.AreEqual ("count", ex.ParamName, "#C5"); #else // Index was out of range. Must be non-negative and // less than the size of the collection - AssertEquals ("#C2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#C3", ex.InnerException); - AssertNotNull ("#C4", ex.Message); - AssertNotNull ("#C5", ex.ParamName); - //AssertEquals ("#C5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2"); + Assert.IsNull (ex.InnerException, "#C3"); + Assert.IsNotNull (ex.Message, "#C4"); + Assert.IsNotNull (ex.ParamName, "#C5"); + //Assert.AreEqual ("startIndex", ex.ParamName, "#C5"); #endif } } @@ -1921,14 +1897,14 @@ public class StringTest : TestCase { try { "Mono".IndexOf ("no", -1, 1); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // Index was out of range. Must be non-negative and // less than the size of the collection - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#5"); } } @@ -1939,31 +1915,31 @@ public class StringTest : TestCase try { s.IndexOf ("no", s.Length + 1, 1); - Fail ("#A1"); + Assert.Fail ("#A1"); } catch (ArgumentOutOfRangeException ex) { // Index was out of range. Must be non-negative and // less than the size of the collection - AssertEquals ("#A2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#A3", ex.InnerException); - AssertNotNull ("#A4", ex.Message); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2"); + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); #if NET_2_0 - AssertEquals ("#A5", "startIndex", ex.ParamName); + Assert.AreEqual ("startIndex", ex.ParamName, "#A5"); #else - AssertNotNull ("#A5", ex.ParamName); - //AssertEquals ("#A5", "count", ex.ParamName); + Assert.IsNotNull (ex.ParamName, "#A5"); + //Assert.AreEqual ("count", ex.ParamName, "#A5"); #endif } try { s.IndexOf ("no", int.MaxValue, 1); - Fail ("#B1"); + Assert.Fail ("#B1"); } catch (ArgumentOutOfRangeException ex) { // Index was out of range. Must be non-negative and // less than the size of the collection - AssertEquals ("#B2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#B3", ex.InnerException); - AssertNotNull ("#B4", ex.Message); - AssertEquals ("#B5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2"); + Assert.IsNull (ex.InnerException, "#B3"); + Assert.IsNotNull (ex.Message, "#B4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#B5"); } } @@ -1972,15 +1948,15 @@ public class StringTest : TestCase { try { "Mono".IndexOf ((string) null, 0, 1); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentNullException ex) { - AssertEquals ("#2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); #if NET_2_0 - AssertEquals ("#5", "value", ex.ParamName); + Assert.AreEqual ("value", ex.ParamName, "#5"); #else - AssertEquals ("#5", "string2", ex.ParamName); + Assert.AreEqual ("string2", ex.ParamName, "#5"); #endif } } @@ -1991,14 +1967,14 @@ public class StringTest : TestCase { try { "Mono".IndexOf (string.Empty, 1, (StringComparison) Int32.MinValue); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentException ex) { // The string comparison type passed in is currently // not supported - AssertEquals ("#2", typeof (ArgumentException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "comparisonType", ex.ParamName); + Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("comparisonType", ex.ParamName, "#5"); } } @@ -2007,14 +1983,14 @@ public class StringTest : TestCase { try { "Mono".IndexOf ("o", -1, StringComparison.Ordinal); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // Index was out of range. Must be non-negative and // less than the size of the collection - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#5"); } } @@ -2023,14 +1999,14 @@ public class StringTest : TestCase { try { "Mono".IndexOf (string.Empty, 0, 1, (StringComparison) Int32.MinValue); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentException ex) { // The string comparison type passed in is currently // not supported - AssertEquals ("#2", typeof (ArgumentException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "comparisonType", ex.ParamName); + Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("comparisonType", ex.ParamName, "#5"); } } @@ -2039,15 +2015,15 @@ public class StringTest : TestCase { try { "Mono".IndexOf ("o", 1, -1, StringComparison.Ordinal); - Fail ("#1"); - Fail ("#1"); + Assert.Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // Count must be positive and count must refer to a // location within the string/array/collection - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "count", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("count", ex.ParamName, "#5"); } } @@ -2056,14 +2032,14 @@ public class StringTest : TestCase { try { "Mono".IndexOf ("o", -1, 0, StringComparison.Ordinal); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // Index was out of range. Must be non-negative and // less than the size of the collection - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#5"); } } #endif @@ -2075,13 +2051,13 @@ public class StringTest : TestCase char[] c; c = new char [] {'a', 'e', 'i', 'o', 'u'}; - AssertEquals ("#1", 0, s.IndexOfAny (c)); + Assert.AreEqual (0, s.IndexOfAny (c), "#1"); c = new char [] { 'd', 'z' }; - AssertEquals ("#1", 3, s.IndexOfAny (c)); + Assert.AreEqual (3, s.IndexOfAny (c), "#1"); c = new char [] { 'q', 'm', 'z' }; - AssertEquals ("#2", 12, s.IndexOfAny (c)); + Assert.AreEqual (12, s.IndexOfAny (c), "#2"); c = new char [0]; - AssertEquals ("#3", -1, s.IndexOfAny (c)); + Assert.AreEqual (-1, s.IndexOfAny (c), "#3"); } @@ -2090,12 +2066,12 @@ public class StringTest : TestCase { try { "mono".IndexOfAny ((char []) null); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentNullException ex) { - AssertEquals ("#2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertNull ("#5", ex.ParamName); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.IsNull (ex.ParamName, "#5"); } } @@ -2106,30 +2082,30 @@ public class StringTest : TestCase char [] c; c = new char [] { 'a', 'e', 'i', 'o', 'u' }; - AssertEquals ("#A1", 0, s.IndexOfAny (c, 0)); - AssertEquals ("#A1", 4, s.IndexOfAny (c, 1)); - AssertEquals ("#A2", -1, s.IndexOfAny (c, 9)); - AssertEquals ("#A3", -1, s.IndexOfAny (c, s.Length)); + Assert.AreEqual (0, s.IndexOfAny (c, 0), "#A1"); + Assert.AreEqual (4, s.IndexOfAny (c, 1), "#A1"); + Assert.AreEqual (-1, s.IndexOfAny (c, 9), "#A2"); + Assert.AreEqual (-1, s.IndexOfAny (c, s.Length), "#A3"); c = new char [] { 'd', 'z' }; - AssertEquals ("#B1", 3, s.IndexOfAny (c, 0)); - AssertEquals ("#B2", 3, s.IndexOfAny (c, 3)); - AssertEquals ("#B3", 13, s.IndexOfAny (c, 4)); - AssertEquals ("#B4", 13, s.IndexOfAny (c, 9)); - AssertEquals ("#B5", -1, s.IndexOfAny (c, s.Length)); - AssertEquals ("#B6", 13, s.IndexOfAny (c, s.Length - 1)); + Assert.AreEqual (3, s.IndexOfAny (c, 0), "#B1"); + Assert.AreEqual (3, s.IndexOfAny (c, 3), "#B2"); + Assert.AreEqual (13, s.IndexOfAny (c, 4), "#B3"); + Assert.AreEqual (13, s.IndexOfAny (c, 9), "#B4"); + Assert.AreEqual (-1, s.IndexOfAny (c, s.Length), "#B5"); + Assert.AreEqual (13, s.IndexOfAny (c, s.Length - 1), "#B6"); c = new char [] { 'q', 'm', 'z' }; - AssertEquals ("#C1", 12, s.IndexOfAny (c, 0)); - AssertEquals ("#C2", 12, s.IndexOfAny (c, 4)); - AssertEquals ("#C3", 12, s.IndexOfAny (c, 12)); - AssertEquals ("#C4", -1, s.IndexOfAny (c, s.Length)); + Assert.AreEqual (12, s.IndexOfAny (c, 0), "#C1"); + Assert.AreEqual (12, s.IndexOfAny (c, 4), "#C2"); + Assert.AreEqual (12, s.IndexOfAny (c, 12), "#C3"); + Assert.AreEqual (-1, s.IndexOfAny (c, s.Length), "#C4"); c = new char [0]; - AssertEquals ("#D1", -1, s.IndexOfAny (c, 0)); - AssertEquals ("#D2", -1, s.IndexOfAny (c, 4)); - AssertEquals ("#D3", -1, s.IndexOfAny (c, 9)); - AssertEquals ("#D4", -1, s.IndexOfAny (c, s.Length)); + Assert.AreEqual (-1, s.IndexOfAny (c, 0), "#D1"); + Assert.AreEqual (-1, s.IndexOfAny (c, 4), "#D2"); + Assert.AreEqual (-1, s.IndexOfAny (c, 9), "#D3"); + Assert.AreEqual (-1, s.IndexOfAny (c, s.Length), "#D4"); } [Test] // IndexOfAny (Char [], Int32) @@ -2137,12 +2113,12 @@ public class StringTest : TestCase { try { "mono".IndexOfAny ((char []) null, 0); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentNullException ex) { - AssertEquals ("#2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertNull ("#5", ex.ParamName); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.IsNull (ex.ParamName, "#5"); } } @@ -2153,14 +2129,14 @@ public class StringTest : TestCase try { s.IndexOfAny (new char [1] { 'd' }, -1, 1); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // Specified argument was out of the range of valid // values - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertNull ("#5", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.IsNull (ex.ParamName, "#5"); } } @@ -2171,14 +2147,14 @@ public class StringTest : TestCase try { s.IndexOfAny (new char [1] { 'd' }, s.Length + 1); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // Specified argument was out of the range of valid // values - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertNull ("#5", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.IsNull (ex.ParamName, "#5"); } } @@ -2189,32 +2165,32 @@ public class StringTest : TestCase char [] c; c = new char [] { 'a', 'e', 'i', 'o', 'u' }; - AssertEquals ("#A1", 0, s.IndexOfAny (c, 0, 2)); - AssertEquals ("#A2", -1, s.IndexOfAny (c, 1, 2)); - AssertEquals ("#A3", -1, s.IndexOfAny (c, 1, 3)); - AssertEquals ("#A3", 4, s.IndexOfAny (c, 1, 4)); - AssertEquals ("#A4", 4, s.IndexOfAny (c, 1, s.Length - 1)); + Assert.AreEqual (0, s.IndexOfAny (c, 0, 2), "#A1"); + Assert.AreEqual (-1, s.IndexOfAny (c, 1, 2), "#A2"); + Assert.AreEqual (-1, s.IndexOfAny (c, 1, 3), "#A3"); + Assert.AreEqual (4, s.IndexOfAny (c, 1, 4), "#A3"); + Assert.AreEqual (4, s.IndexOfAny (c, 1, s.Length - 1), "#A4"); c = new char [] { 'd', 'z' }; - AssertEquals ("#B1", -1, s.IndexOfAny (c, 0, 2)); - AssertEquals ("#B2", -1, s.IndexOfAny (c, 1, 2)); - AssertEquals ("#B3", 3, s.IndexOfAny (c, 1, 3)); - AssertEquals ("#B4", 3, s.IndexOfAny (c, 0, s.Length)); - AssertEquals ("#B5", 3, s.IndexOfAny (c, 1, s.Length - 1)); - AssertEquals ("#B6", -1, s.IndexOfAny (c, s.Length, 0)); + Assert.AreEqual (-1, s.IndexOfAny (c, 0, 2), "#B1"); + Assert.AreEqual (-1, s.IndexOfAny (c, 1, 2), "#B2"); + Assert.AreEqual (3, s.IndexOfAny (c, 1, 3), "#B3"); + Assert.AreEqual (3, s.IndexOfAny (c, 0, s.Length), "#B4"); + Assert.AreEqual (3, s.IndexOfAny (c, 1, s.Length - 1), "#B5"); + Assert.AreEqual (-1, s.IndexOfAny (c, s.Length, 0), "#B6"); c = new char [] { 'q', 'm', 'z' }; - AssertEquals ("#C1", -1, s.IndexOfAny (c, 0, 10)); - AssertEquals ("#C2", 12, s.IndexOfAny (c, 10, 4)); - AssertEquals ("#C3", -1, s.IndexOfAny (c, 1, 3)); - AssertEquals ("#C4", 12, s.IndexOfAny (c, 0, s.Length)); - AssertEquals ("#C5", 12, s.IndexOfAny (c, 1, s.Length - 1)); + Assert.AreEqual (-1, s.IndexOfAny (c, 0, 10), "#C1"); + Assert.AreEqual (12, s.IndexOfAny (c, 10, 4), "#C2"); + Assert.AreEqual (-1, s.IndexOfAny (c, 1, 3), "#C3"); + Assert.AreEqual (12, s.IndexOfAny (c, 0, s.Length), "#C4"); + Assert.AreEqual (12, s.IndexOfAny (c, 1, s.Length - 1), "#C5"); c = new char [0]; - AssertEquals ("#D1", -1, s.IndexOfAny (c, 0, 3)); - AssertEquals ("#D2", -1, s.IndexOfAny (c, 4, 9)); - AssertEquals ("#D3", -1, s.IndexOfAny (c, 9, 5)); - AssertEquals ("#D4", -1, s.IndexOfAny (c, 13, 1)); + Assert.AreEqual (-1, s.IndexOfAny (c, 0, 3), "#D1"); + Assert.AreEqual (-1, s.IndexOfAny (c, 4, 9), "#D2"); + Assert.AreEqual (-1, s.IndexOfAny (c, 9, 5), "#D3"); + Assert.AreEqual (-1, s.IndexOfAny (c, 13, 1), "#D4"); } [Test] // IndexOfAny (Char [], Int32, Int32) @@ -2222,12 +2198,12 @@ public class StringTest : TestCase { try { "mono".IndexOfAny ((char []) null, 0, 0); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentNullException ex) { - AssertEquals ("#2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertNull ("#5", ex.ParamName); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.IsNull (ex.ParamName, "#5"); } } @@ -2236,14 +2212,14 @@ public class StringTest : TestCase { try { "Mono".IndexOfAny (new char [1] { 'o' }, 1, -1); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // Count must be positive and count must refer to a // location within the string/array/collection - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "count", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("count", ex.ParamName, "#5"); } } @@ -2254,14 +2230,14 @@ public class StringTest : TestCase try { s.IndexOfAny (new char [1] { 'd' }, 1, s.Length); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // Count must be positive and count must refer to a // location within the string/array/collection - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "count", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("count", ex.ParamName, "#5"); } } @@ -2270,14 +2246,14 @@ public class StringTest : TestCase { try { "Mono".IndexOfAny (new char [1] { 'o' }, -1, 1); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // Specified argument was out of the range of valid // values - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertNull ("#5", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.IsNull (ex.ParamName, "#5"); } } @@ -2288,14 +2264,14 @@ public class StringTest : TestCase try { s.IndexOfAny (new char [1] { 'o' }, s.Length + 1, 1); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // Specified argument was out of the range of valid // values - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertNull ("#5", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.IsNull (ex.ParamName, "#5"); } } @@ -2303,10 +2279,10 @@ public class StringTest : TestCase [Test] public void Contains () { - Assert ("ABC".Contains (string.Empty)); - Assert ("ABC".Contains ("ABC")); - Assert ("ABC".Contains ("AB")); - Assert (!"ABC".Contains ("AD")); + Assert.IsTrue ("ABC".Contains (string.Empty)); + Assert.IsTrue ("ABC".Contains ("ABC")); + Assert.IsTrue ("ABC".Contains ("AB")); + Assert.IsTrue (!"ABC".Contains ("AD")); } [Test] @@ -2314,25 +2290,25 @@ public class StringTest : TestCase { try { "ABC".Contains (null); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentNullException ex) { - AssertEquals ("#2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "value", ex.ParamName); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("value", ex.ParamName, "#5"); } } [Test] public void IsNullOrEmpty () { - Assert (String.IsNullOrEmpty (null)); - Assert (String.IsNullOrEmpty (String.Empty)); - Assert (String.IsNullOrEmpty ("")); - Assert (!String.IsNullOrEmpty ("A")); - Assert (!String.IsNullOrEmpty (" ")); - Assert (!String.IsNullOrEmpty ("\t")); - Assert (!String.IsNullOrEmpty ("\n")); + Assert.IsTrue (String.IsNullOrEmpty (null)); + Assert.IsTrue (String.IsNullOrEmpty (String.Empty)); + Assert.IsTrue (String.IsNullOrEmpty ("")); + Assert.IsTrue (!String.IsNullOrEmpty ("A")); + Assert.IsTrue (!String.IsNullOrEmpty (" ")); + Assert.IsTrue (!String.IsNullOrEmpty ("\t")); + Assert.IsTrue (!String.IsNullOrEmpty ("\n")); } #endif @@ -2343,46 +2319,46 @@ public class StringTest : TestCase try { s1.Insert (0, null); - Fail ("#A1"); + Assert.Fail ("#A1"); } catch (ArgumentNullException ex) { - AssertEquals ("#A2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#A3", ex.InnerException); - AssertNotNull ("#A4", ex.Message); - AssertEquals ("#A5", "value", ex.ParamName); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2"); + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); + Assert.AreEqual ("value", ex.ParamName, "#A5"); } try { s1.Insert (s1.Length + 1, "Hi!"); - Fail ("#B1"); + Assert.Fail ("#B1"); } catch (ArgumentOutOfRangeException ex) { - AssertEquals ("#B2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#B3", ex.InnerException); - AssertNotNull ("#B4", ex.Message); - AssertEquals ("#B5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2"); + Assert.IsNull (ex.InnerException, "#B3"); + Assert.IsNotNull (ex.Message, "#B4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#B5"); } - AssertEquals("#C1", "Hi!original", s1.Insert (0, "Hi!")); - AssertEquals("#C2", "originalHi!", s1.Insert (s1.Length, "Hi!")); - AssertEquals("#C3", "origHi!inal", s1.Insert (4, "Hi!")); + Assert.AreEqual ("Hi!original", s1.Insert (0, "Hi!"), "#C1"); + Assert.AreEqual ("originalHi!", s1.Insert (s1.Length, "Hi!"), "#C2"); + Assert.AreEqual ("origHi!inal", s1.Insert (4, "Hi!"), "#C3"); } [Test] public void Intern () { string s1 = "original"; - AssertSame ("#A1", s1, String.Intern (s1)); - AssertSame ("#A2", String.Intern(s1), String.Intern(s1)); + Assert.AreSame (s1, String.Intern (s1), "#A1"); + Assert.AreSame (String.Intern(s1), String.Intern(s1), "#A2"); string s2 = "originally"; - AssertSame ("#B1", s2, String.Intern (s2)); - Assert ("#B2", String.Intern(s1) != String.Intern(s2)); + Assert.AreSame (s2, String.Intern (s2), "#B1"); + Assert.IsTrue (String.Intern(s1) != String.Intern(s2), "#B2"); string s3 = new DateTime (2000, 3, 7).ToString (); - AssertNull ("#C1", String.IsInterned (s3)); - AssertSame ("#C2", s3, String.Intern (s3)); - AssertSame ("#C3", s3, String.IsInterned (s3)); - AssertSame ("#C4", s3, String.IsInterned (new DateTime (2000, 3, 7).ToString ())); - AssertSame ("#C5", s3, String.Intern (new DateTime (2000, 3, 7).ToString ())); + Assert.IsNull (String.IsInterned (s3), "#C1"); + Assert.AreSame (s3, String.Intern (s3), "#C2"); + Assert.AreSame (s3, String.IsInterned (s3), "#C3"); + Assert.AreSame (s3, String.IsInterned (new DateTime (2000, 3, 7).ToString ()), "#C4"); + Assert.AreSame (s3, String.Intern (new DateTime (2000, 3, 7).ToString ()), "#C5"); } [Test] @@ -2390,21 +2366,21 @@ public class StringTest : TestCase { try { String.Intern (null); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentNullException ex) { - AssertEquals ("#2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "str", ex.ParamName); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("str", ex.ParamName, "#5"); } } [Test] public void IsInterned () { - AssertNull ("#1", String.IsInterned (new DateTime (2000, 3, 6).ToString ())); + Assert.IsNull (String.IsInterned (new DateTime (2000, 3, 6).ToString ()), "#1"); string s1 = "original"; - AssertSame("#2", s1, String.IsInterned (s1)); + Assert.AreSame (s1, String.IsInterned (s1), "#2"); } [Test] @@ -2412,12 +2388,12 @@ public class StringTest : TestCase { try { String.IsInterned (null); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentNullException ex) { - AssertEquals ("#2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "str", ex.ParamName); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("str", ex.ParamName, "#5"); } } @@ -2426,35 +2402,30 @@ public class StringTest : TestCase { try { string s = String.Join(" ", null); - Fail ("#A1"); + Assert.Fail ("#A1"); } catch (ArgumentNullException ex) { - AssertEquals ("#A2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#A3", ex.InnerException); - AssertNotNull ("#A4", ex.Message); - AssertEquals ("#A5", "value", ex.ParamName); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2"); + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); + Assert.AreEqual ("value", ex.ParamName, "#A5"); } string[] chunks = {"this", "is", "a", "test"}; - AssertEquals("Basic join", "this is a test", - String.Join(" ", chunks)); - AssertEquals("Basic join", "this.is.a.test", - String.Join(".", chunks)); + Assert.AreEqual ("this is a test", String.Join(" ", chunks), "Basic join"); + Assert.AreEqual ("this.is.a.test", String.Join(".", chunks), "Basic join"); - AssertEquals("Subset join", "is a", - String.Join(" ", chunks, 1, 2)); - AssertEquals("Subset join", "is.a", - String.Join(".", chunks, 1, 2)); - AssertEquals("Subset join", "is a test", - String.Join(" ", chunks, 1, 3)); + Assert.AreEqual ("is a", String.Join(" ", chunks, 1, 2), "Subset join"); + Assert.AreEqual ("is.a", String.Join(".", chunks, 1, 2), "Subset join"); + Assert.AreEqual ("is a test", String.Join(" ", chunks, 1, 3), "Subset join"); try { string s = String.Join(" ", chunks, 2, 3); - Fail ("#C1"); + Assert.Fail ("#C1"); } catch (ArgumentOutOfRangeException ex) { - AssertEquals ("#C2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#C3", ex.InnerException); - AssertNotNull ("#C4", ex.Message); - AssertEquals ("#C5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2"); + Assert.IsNull (ex.InnerException, "#C3"); + Assert.IsNotNull (ex.Message, "#C4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#C5"); } } @@ -2462,27 +2433,27 @@ public class StringTest : TestCase public void Join_SeparatorNull () { string[] chunks = {"this", "is", "a", "test"}; - AssertEquals ("SeparatorNull", "thisisatest", String.Join (null, chunks)); + Assert.AreEqual ("thisisatest", String.Join (null, chunks), "SeparatorNull"); } [Test] public void Join_ValuesNull () { string[] chunks1 = {null, "is", "a", null}; - AssertEquals ("SomeNull", " is a ", String.Join (" ", chunks1)); + Assert.AreEqual (" is a ", String.Join (" ", chunks1), "SomeNull"); string[] chunks2 = {null, "is", "a", null}; - AssertEquals ("Some+Sep=Null", "isa", String.Join (null, chunks2)); + Assert.AreEqual ("isa", String.Join (null, chunks2), "Some+Sep=Null"); string[] chunks3 = {null, null, null, null}; - AssertEquals ("AllValuesNull", " ", String.Join (" ", chunks3)); + Assert.AreEqual (" ", String.Join (" ", chunks3), "AllValuesNull"); } [Test] public void Join_AllNull () { string[] chunks = {null, null, null}; - AssertEquals ("AllNull", string.Empty, String.Join (null, chunks)); + Assert.AreEqual (string.Empty, String.Join (null, chunks), "AllNull"); } [Test] @@ -2491,12 +2462,12 @@ public class StringTest : TestCase string[] values = { "Mo", "no" }; try { String.Join ("o", values, -1, 1); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#5"); } } @@ -2506,12 +2477,12 @@ public class StringTest : TestCase string[] values = { "Mo", "no" }; try { String.Join ("o", values, Int32.MaxValue, 1); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#5"); } } @@ -2521,12 +2492,12 @@ public class StringTest : TestCase string[] values = { "Mo", "no" }; try { String.Join ("o", values, 1, -1); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "count", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("count", ex.ParamName, "#5"); } } @@ -2536,12 +2507,12 @@ public class StringTest : TestCase string[] values = { "Mo", "no" }; try { String.Join ("o", values, 1, Int32.MaxValue); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#5"); } } @@ -2552,145 +2523,125 @@ public class StringTest : TestCase try { s1.LastIndexOf ('q', -1); - Fail ("#A1"); + Assert.Fail ("#A1"); } catch (ArgumentOutOfRangeException ex) { - AssertEquals ("#A2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#A3", ex.InnerException); - AssertNotNull ("#A4", ex.Message); - AssertEquals ("#A5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2"); + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#A5"); } try { s1.LastIndexOf ('q', -1, 1); - Fail ("#B1"); + Assert.Fail ("#B1"); } catch (ArgumentOutOfRangeException ex) { - AssertEquals ("#B2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#B3", ex.InnerException); - AssertNotNull ("#B4", ex.Message); - AssertEquals ("#B5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2"); + Assert.IsNull (ex.InnerException, "#B3"); + Assert.IsNotNull (ex.Message, "#B4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#B5"); } try { s1.LastIndexOf ("huh", s1.Length + 1); - Fail ("#C1"); + Assert.Fail ("#C1"); } catch (ArgumentOutOfRangeException ex) { - AssertEquals ("#C2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#C3", ex.InnerException); - AssertNotNull ("#C4", ex.Message); - AssertEquals ("#C5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2"); + Assert.IsNull (ex.InnerException, "#C3"); + Assert.IsNotNull (ex.Message, "#C4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#C5"); } try { int i = s1.LastIndexOf ("huh", s1.Length + 1, 3); - Fail ("#D1"); + Assert.Fail ("#D1"); } catch (ArgumentOutOfRangeException ex) { - AssertEquals ("#D2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#D3", ex.InnerException); - AssertNotNull ("#D4", ex.Message); - AssertEquals ("#D5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#D2"); + Assert.IsNull (ex.InnerException, "#D3"); + Assert.IsNotNull (ex.Message, "#D4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#D5"); } try { s1.LastIndexOf (null); - Fail ("#E1"); + Assert.Fail ("#E1"); } catch (ArgumentNullException ex) { - AssertEquals ("#E2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#E3", ex.InnerException); - AssertNotNull ("#E4", ex.Message); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#E2"); + Assert.IsNull (ex.InnerException, "#E3"); + Assert.IsNotNull (ex.Message, "#E4"); #if NET_2_0 - AssertEquals ("#E5", "value", ex.ParamName); + Assert.AreEqual ("value", ex.ParamName, "#E5"); #else - AssertEquals ("#E5", "string2", ex.ParamName); + Assert.AreEqual ("string2", ex.ParamName, "#E5"); #endif } try { s1.LastIndexOf (null, 0); - Fail ("#F1"); + Assert.Fail ("#F1"); } catch (ArgumentNullException ex) { - AssertEquals ("#F2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#F3", ex.InnerException); - AssertNotNull ("#F4", ex.Message); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#F2"); + Assert.IsNull (ex.InnerException, "#F3"); + Assert.IsNotNull (ex.Message, "#F4"); #if NET_2_0 - AssertEquals ("#F5", "value", ex.ParamName); + Assert.AreEqual ("value", ex.ParamName, "#F5"); #else - AssertEquals ("#F5", "string2", ex.ParamName); + Assert.AreEqual ("string2", ex.ParamName, "#F5"); #endif } try { s1.LastIndexOf (null, 0, 1); - Fail ("#G1"); + Assert.Fail ("#G1"); } catch (ArgumentNullException ex) { - AssertEquals ("#G2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#G3", ex.InnerException); - AssertNotNull ("#G4", ex.Message); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#G2"); + Assert.IsNull (ex.InnerException, "#G3"); + Assert.IsNotNull (ex.Message, "#G4"); #if NET_2_0 - AssertEquals ("#G5", "value", ex.ParamName); + Assert.AreEqual ("value", ex.ParamName, "#G5"); #else - AssertEquals ("#G5", "string2", ex.ParamName); + Assert.AreEqual ("string2", ex.ParamName, "#G5"); #endif } - AssertEquals("basic char index", 1, s1.LastIndexOf('r')); - AssertEquals("basic char index", 4, s1.LastIndexOf('i')); - AssertEquals("basic char index - no", -1, s1.LastIndexOf('q')); - - AssertEquals("basic string index", 7, s1.LastIndexOf(string.Empty)); - AssertEquals("basic string index", 1, s1.LastIndexOf("rig")); - AssertEquals("basic string index", 4, s1.LastIndexOf("i")); - AssertEquals("basic string index - no", -1, - s1.LastIndexOf("rag")); - - AssertEquals("stepped char index", 1, - s1.LastIndexOf('r', s1.Length-1)); - AssertEquals("stepped char index", 4, - s1.LastIndexOf('i', s1.Length-1)); - AssertEquals("stepped char index", 2, - s1.LastIndexOf('i', 3)); - AssertEquals("stepped char index", -1, - s1.LastIndexOf('i', 1)); - - AssertEquals("stepped limited char index", - 1, s1.LastIndexOf('r', 1, 1)); - AssertEquals("stepped limited char index", - -1, s1.LastIndexOf('r', 0, 1)); - AssertEquals("stepped limited char index", - 4, s1.LastIndexOf('i', 6, 3)); - AssertEquals("stepped limited char index", - 2, s1.LastIndexOf('i', 3, 3)); - AssertEquals("stepped limited char index", - -1, s1.LastIndexOf('i', 1, 2)); + Assert.AreEqual (1, s1.LastIndexOf('r'), "basic char index"); + Assert.AreEqual (4, s1.LastIndexOf('i'), "basic char index"); + Assert.AreEqual (-1, s1.LastIndexOf('q'), "basic char index - no"); + + Assert.AreEqual (7, s1.LastIndexOf(string.Empty), "basic string index"); + Assert.AreEqual (1, s1.LastIndexOf("rig"), "basic string index"); + Assert.AreEqual (4, s1.LastIndexOf("i"), "basic string index"); + Assert.AreEqual (-1, s1.LastIndexOf("rag"), "basic string index - no"); + + Assert.AreEqual (1, s1.LastIndexOf('r', s1.Length-1), "stepped char index"); + Assert.AreEqual (4, s1.LastIndexOf('i', s1.Length-1), "stepped char index"); + Assert.AreEqual (2, s1.LastIndexOf('i', 3), "stepped char index"); + Assert.AreEqual (-1, s1.LastIndexOf('i', 1), "stepped char index"); + + Assert.AreEqual (1, s1.LastIndexOf('r', 1, 1), "stepped limited char index"); + Assert.AreEqual (-1, s1.LastIndexOf('r', 0, 1), "stepped limited char index"); + Assert.AreEqual (4, s1.LastIndexOf('i', 6, 3), "stepped limited char index"); + Assert.AreEqual (2, s1.LastIndexOf('i', 3, 3), "stepped limited char index"); + Assert.AreEqual (-1, s1.LastIndexOf('i', 1, 2), "stepped limited char index"); s1 = "original original"; - AssertEquals("stepped string index #1", - 9, s1.LastIndexOf("original", s1.Length)); - AssertEquals("stepped string index #2", - 0, s1.LastIndexOf("original", s1.Length-2)); - AssertEquals("stepped string index #3", - -1, s1.LastIndexOf("original", s1.Length-11)); - AssertEquals("stepped string index #4", - -1, s1.LastIndexOf("translator", 2)); - AssertEquals("stepped string index #5", - 0, string.Empty.LastIndexOf(string.Empty, 0)); + Assert.AreEqual (9, s1.LastIndexOf("original", s1.Length), "stepped string index #1"); + Assert.AreEqual (0, s1.LastIndexOf("original", s1.Length-2), "stepped string index #2"); + Assert.AreEqual (-1, s1.LastIndexOf("original", s1.Length-11), "stepped string index #3"); + Assert.AreEqual (-1, s1.LastIndexOf("translator", 2), "stepped string index #4"); + Assert.AreEqual (0, string.Empty.LastIndexOf(string.Empty, 0), "stepped string index #5"); #if !TARGET_JVM - AssertEquals("stepped string index #6", - -1, string.Empty.LastIndexOf("A", -1)); + Assert.AreEqual (-1, string.Empty.LastIndexOf("A", -1), "stepped string index #6"); #endif - AssertEquals("stepped limited string index #1", - 10, s1.LastIndexOf("rig", s1.Length-1, 10)); - AssertEquals("stepped limited string index #2", - -1, s1.LastIndexOf("rig", s1.Length, 3)); - AssertEquals("stepped limited string index #3", - 10, s1.LastIndexOf("rig", s1.Length-2, 15)); - AssertEquals("stepped limited string index #4", - -1, s1.LastIndexOf("rig", s1.Length-2, 3)); + Assert.AreEqual (10, s1.LastIndexOf("rig", s1.Length-1, 10), "stepped limited string index #1"); + Assert.AreEqual (-1, s1.LastIndexOf("rig", s1.Length, 3), "stepped limited string index #2"); + Assert.AreEqual (10, s1.LastIndexOf("rig", s1.Length-2, 15), "stepped limited string index #3"); + Assert.AreEqual (-1, s1.LastIndexOf("rig", s1.Length-2, 3), "stepped limited string index #4"); string s2 = "QBitArray::bitarr_data"; - AssertEquals ("bug #62160", 9, s2.LastIndexOf ("::")); + Assert.AreEqual (9, s2.LastIndexOf ("::"), "bug #62160"); string s3 = "test123"; - AssertEquals ("bug #77412", 0, s3.LastIndexOf ("test123")); + Assert.AreEqual (0, s3.LastIndexOf ("test123"), "bug #77412"); } #if NET_2_0 @@ -2736,65 +2687,65 @@ public class StringTest : TestCase string text2 = "123"; string text3 = "NG"; string text4 = "t"; - AssertEquals ("#1-1", 7, text.LastIndexOf (text2, StringComparison.Ordinal)); - AssertEquals ("#2-1", 5, text.LastIndexOf (text3, StringComparison.OrdinalIgnoreCase)); + Assert.AreEqual (7, text.LastIndexOf (text2, StringComparison.Ordinal), "#1-1"); + Assert.AreEqual (5, text.LastIndexOf (text3, StringComparison.OrdinalIgnoreCase), "#2-1"); - AssertEquals ("#1-2", 7, text.LastIndexOf (text2, 12, StringComparison.Ordinal)); - AssertEquals ("#2-2", 5, text.LastIndexOf (text3, 12, StringComparison.OrdinalIgnoreCase)); + Assert.AreEqual (7, text.LastIndexOf (text2, 12, StringComparison.Ordinal), "#1-2"); + Assert.AreEqual (5, text.LastIndexOf (text3, 12, StringComparison.OrdinalIgnoreCase), "#2-2"); - AssertEquals ("#1-3", -1, text.LastIndexOf (text2, 0, StringComparison.Ordinal)); - AssertEquals ("#2-3", -1, text.LastIndexOf (text3, 0, StringComparison.OrdinalIgnoreCase)); + Assert.AreEqual (-1, text.LastIndexOf (text2, 0, StringComparison.Ordinal), "#1-3"); + Assert.AreEqual (-1, text.LastIndexOf (text3, 0, StringComparison.OrdinalIgnoreCase), "#2-3"); - AssertEquals ("#1-4", -1, text.LastIndexOf (text2, 6, StringComparison.Ordinal)); - AssertEquals ("#2-4", 5, text.LastIndexOf (text3, 6, StringComparison.OrdinalIgnoreCase)); + Assert.AreEqual (-1, text.LastIndexOf (text2, 6, StringComparison.Ordinal), "#1-4"); + Assert.AreEqual (5, text.LastIndexOf (text3, 6, StringComparison.OrdinalIgnoreCase), "#2-4"); - AssertEquals ("#1-5", -1, text.LastIndexOf (text2, 7, 3, StringComparison.Ordinal)); - AssertEquals ("#2-5", 5, text.LastIndexOf (text3, 7, 3, StringComparison.OrdinalIgnoreCase)); + Assert.AreEqual (-1, text.LastIndexOf (text2, 7, 3, StringComparison.Ordinal), "#1-5"); + Assert.AreEqual (5, text.LastIndexOf (text3, 7, 3, StringComparison.OrdinalIgnoreCase), "#2-5"); - AssertEquals ("#1-6", -1, text.LastIndexOf (text2, 6, 0, StringComparison.Ordinal)); - AssertEquals ("#2-6", -1, text.LastIndexOf (text3, 5, 0, StringComparison.OrdinalIgnoreCase)); + Assert.AreEqual (-1, text.LastIndexOf (text2, 6, 0, StringComparison.Ordinal), "#1-6"); + Assert.AreEqual (-1, text.LastIndexOf (text3, 5, 0, StringComparison.OrdinalIgnoreCase), "#2-6"); - AssertEquals ("#1-7", -1, text.LastIndexOf (text2, 7, 1, StringComparison.Ordinal)); - AssertEquals ("#2-7", -1, text.LastIndexOf (text3, 5, 1, StringComparison.OrdinalIgnoreCase)); + Assert.AreEqual (-1, text.LastIndexOf (text2, 7, 1, StringComparison.Ordinal), "#1-7"); + Assert.AreEqual (-1, text.LastIndexOf (text3, 5, 1, StringComparison.OrdinalIgnoreCase), "#2-7"); - AssertEquals ("#3-1", 0, text.LastIndexOf (text4, 0, StringComparison.Ordinal)); - AssertEquals ("#3-2", 0, text.LastIndexOf (text4, 0, StringComparison.OrdinalIgnoreCase)); + Assert.AreEqual (0, text.LastIndexOf (text4, 0, StringComparison.Ordinal), "#3-1"); + Assert.AreEqual (0, text.LastIndexOf (text4, 0, StringComparison.OrdinalIgnoreCase), "#3-2"); - AssertEquals ("#4-1", 3, text.LastIndexOf (text4, 13, StringComparison.Ordinal)); - AssertEquals ("#4-2", 3, text.LastIndexOf (text4, 13, StringComparison.OrdinalIgnoreCase)); + Assert.AreEqual (3, text.LastIndexOf (text4, 13, StringComparison.Ordinal), "#4-1"); + Assert.AreEqual (3, text.LastIndexOf (text4, 13, StringComparison.OrdinalIgnoreCase), "#4-2"); - AssertEquals ("#4-1", 3, text.LastIndexOf (text4, 13, 14, StringComparison.Ordinal)); - AssertEquals ("#4-2", 3, text.LastIndexOf (text4, 13, 14, StringComparison.OrdinalIgnoreCase)); + Assert.AreEqual (3, text.LastIndexOf (text4, 13, 14, StringComparison.Ordinal), "#4-1"); + Assert.AreEqual (3, text.LastIndexOf (text4, 13, 14, StringComparison.OrdinalIgnoreCase), "#4-2"); - AssertEquals ("#5-1", 0, text.LastIndexOf (text4, 1, 2, StringComparison.Ordinal)); - AssertEquals ("#5-2", 0, text.LastIndexOf (text4, 1, 2, StringComparison.OrdinalIgnoreCase)); + Assert.AreEqual (0, text.LastIndexOf (text4, 1, 2, StringComparison.Ordinal), "#5-1"); + Assert.AreEqual (0, text.LastIndexOf (text4, 1, 2, StringComparison.OrdinalIgnoreCase), "#5-2"); - AssertEquals (-1, "".LastIndexOf ("FOO", StringComparison.Ordinal)); - AssertEquals (0, "".LastIndexOf ("", StringComparison.Ordinal)); + Assert.AreEqual (-1, "".LastIndexOf ("FOO", StringComparison.Ordinal)); + Assert.AreEqual (0, "".LastIndexOf ("", StringComparison.Ordinal)); } [Test] public void LastIndexOfStringComparisonOrdinal () { string text = "testing123456"; - AssertEquals ("#1", 10, text.LastIndexOf ("456", StringComparison.Ordinal)); - AssertEquals ("#2", -1, text.LastIndexOf ("4567", StringComparison.Ordinal)); - AssertEquals ("#3", 0, text.LastIndexOf ("te", StringComparison.Ordinal)); - AssertEquals ("#4", 2, text.LastIndexOf ("s", StringComparison.Ordinal)); - AssertEquals ("#5", -1, text.LastIndexOf ("ates", StringComparison.Ordinal)); - AssertEquals ("#6", -1, text.LastIndexOf ("S", StringComparison.Ordinal)); + Assert.AreEqual (10, text.LastIndexOf ("456", StringComparison.Ordinal), "#1"); + Assert.AreEqual (-1, text.LastIndexOf ("4567", StringComparison.Ordinal), "#2"); + Assert.AreEqual (0, text.LastIndexOf ("te", StringComparison.Ordinal), "#3"); + Assert.AreEqual (2, text.LastIndexOf ("s", StringComparison.Ordinal), "#4"); + Assert.AreEqual (-1, text.LastIndexOf ("ates", StringComparison.Ordinal), "#5"); + Assert.AreEqual (-1, text.LastIndexOf ("S", StringComparison.Ordinal), "#6"); } [Test] public void LastIndexOfStringComparisonOrdinalIgnoreCase () { string text = "testing123456"; - AssertEquals ("#1", 10, text.LastIndexOf ("456", StringComparison.OrdinalIgnoreCase)); - AssertEquals ("#2", -1, text.LastIndexOf ("4567", StringComparison.OrdinalIgnoreCase)); - AssertEquals ("#3", 0, text.LastIndexOf ("te", StringComparison.OrdinalIgnoreCase)); - AssertEquals ("#4", 2, text.LastIndexOf ("s", StringComparison.OrdinalIgnoreCase)); - AssertEquals ("#5", -1, text.LastIndexOf ("ates", StringComparison.OrdinalIgnoreCase)); - AssertEquals ("#6", 2, text.LastIndexOf ("S", StringComparison.OrdinalIgnoreCase)); + Assert.AreEqual (10, text.LastIndexOf ("456", StringComparison.OrdinalIgnoreCase), "#1"); + Assert.AreEqual (-1, text.LastIndexOf ("4567", StringComparison.OrdinalIgnoreCase), "#2"); + Assert.AreEqual (0, text.LastIndexOf ("te", StringComparison.OrdinalIgnoreCase), "#3"); + Assert.AreEqual (2, text.LastIndexOf ("s", StringComparison.OrdinalIgnoreCase), "#4"); + Assert.AreEqual (-1, text.LastIndexOf ("ates", StringComparison.OrdinalIgnoreCase), "#5"); + Assert.AreEqual (2, text.LastIndexOf ("S", StringComparison.OrdinalIgnoreCase), "#6"); } #endif @@ -2804,12 +2755,12 @@ public class StringTest : TestCase string s = "Mono"; try { s.LastIndexOf ('n', s.Length, 1); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#5"); } // this works for string but not for a char } @@ -2819,12 +2770,12 @@ public class StringTest : TestCase { try { "Mono".LastIndexOf ('o', Int32.MaxValue, 1); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#5"); } } @@ -2833,12 +2784,12 @@ public class StringTest : TestCase { try { "Mono".LastIndexOf ('o', 1, Int32.MaxValue); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "count", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("count", ex.ParamName, "#5"); } } @@ -2846,7 +2797,7 @@ public class StringTest : TestCase public void LastIndexOf_String_StartIndexStringLength () { string s = "Mono"; - AssertEquals (-1, s.LastIndexOf ("n", s.Length, 1)); + Assert.AreEqual (-1, s.LastIndexOf ("n", s.Length, 1)); // this works for string but not for a char } @@ -2856,12 +2807,12 @@ public class StringTest : TestCase string s = "Mono"; try { s.LastIndexOf ("n", s.Length + 1, 1); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#5"); } } @@ -2870,12 +2821,12 @@ public class StringTest : TestCase { try { "Mono".LastIndexOf ("no", Int32.MaxValue, 1); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#5"); } } @@ -2884,12 +2835,12 @@ public class StringTest : TestCase { try { "Mono".LastIndexOf ("no", 1, Int32.MaxValue); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "count", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("count", ex.ParamName, "#5"); } } @@ -2900,63 +2851,63 @@ public class StringTest : TestCase try { s1.LastIndexOfAny (null); - Fail ("#A1"); + Assert.Fail ("#A1"); } catch (ArgumentNullException ex) { - AssertEquals ("#A2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#A3", ex.InnerException); - AssertNotNull ("#A4", ex.Message); - AssertNull ("#A5", ex.ParamName); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2"); + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); + Assert.IsNull (ex.ParamName, "#A5"); } try { s1.LastIndexOfAny (null, s1.Length); - Fail ("#B1"); + Assert.Fail ("#B1"); } catch (ArgumentNullException ex) { - AssertEquals ("#B2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#B3", ex.InnerException); - AssertNotNull ("#B4", ex.Message); - AssertNull ("#B5", ex.ParamName); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2"); + Assert.IsNull (ex.InnerException, "#B3"); + Assert.IsNotNull (ex.Message, "#B4"); + Assert.IsNull (ex.ParamName, "#B5"); } try { s1.LastIndexOfAny (null, s1.Length, 1); - Fail ("#C1"); + Assert.Fail ("#C1"); } catch (ArgumentNullException ex) { - AssertEquals ("#C2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#C3", ex.InnerException); - AssertNotNull ("#C4", ex.Message); - AssertNull ("#C5", ex.ParamName); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#C2"); + Assert.IsNull (ex.InnerException, "#C3"); + Assert.IsNotNull (ex.Message, "#C4"); + Assert.IsNull (ex.ParamName, "#C5"); } char[] c1 = {'a', 'e', 'i', 'o', 'u'}; - AssertEquals("#D1", 8, s1.LastIndexOfAny (c1)); - AssertEquals("#D2", 4, s1.LastIndexOfAny (c1, 7)); - AssertEquals("#D3", -1, s1.LastIndexOfAny (c1, 3)); - AssertEquals("#D4", 4, s1.LastIndexOfAny (c1, s1.Length - 6, 4)); - AssertEquals("#D5", -1, s1.LastIndexOfAny (c1, s1.Length - 6, 3)); + Assert.AreEqual (8, s1.LastIndexOfAny (c1), "#D1"); + Assert.AreEqual (4, s1.LastIndexOfAny (c1, 7), "#D2"); + Assert.AreEqual (-1, s1.LastIndexOfAny (c1, 3), "#D3"); + Assert.AreEqual (4, s1.LastIndexOfAny (c1, s1.Length - 6, 4), "#D4"); + Assert.AreEqual (-1, s1.LastIndexOfAny (c1, s1.Length - 6, 3), "#D5"); try { s1.LastIndexOfAny (c1, -1); - Fail ("#E1"); + Assert.Fail ("#E1"); } catch (ArgumentOutOfRangeException ex) { // Index was out of range. Must be non-negative and // less than the size of the collection - AssertEquals ("#E2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#E3", ex.InnerException); - AssertNotNull ("#E4", ex.Message); - AssertEquals ("#E5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#E2"); + Assert.IsNull (ex.InnerException, "#E3"); + Assert.IsNotNull (ex.Message, "#E4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#E5"); } try { s1.LastIndexOfAny (c1, -1, 1); - Fail ("#F1"); + Assert.Fail ("#F1"); } catch (ArgumentOutOfRangeException ex) { // Index was out of range. Must be non-negative and // less than the size of the collection - AssertEquals ("#F2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#F3", ex.InnerException); - AssertNotNull ("#F4", ex.Message); - AssertEquals ("#F5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#F2"); + Assert.IsNull (ex.InnerException, "#F3"); + Assert.IsNotNull (ex.Message, "#F4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#F5"); } } @@ -2965,14 +2916,14 @@ public class StringTest : TestCase { try { "Mono".LastIndexOfAny (new char [1] { 'o' }, 1, Int32.MaxValue); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // Count must be positive and count must refer to a // location within the string/array/collection - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "count", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("count", ex.ParamName, "#5"); } } @@ -2981,14 +2932,14 @@ public class StringTest : TestCase { try { "Mono".LastIndexOfAny (new char [1] { 'o' }, Int32.MaxValue, 1); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // Index was out of range. Must be non-negative and // less than the size of the collection - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#5"); } } @@ -2999,17 +2950,17 @@ public class StringTest : TestCase string result; result = s1.PadLeft (0); - AssertSame ("#A", s1, result); + Assert.AreSame (s1, result, "#A"); result = s1.PadLeft (s1.Length - 1); - AssertSame ("#B", s1, result); + Assert.AreSame (s1, result, "#B"); result = s1.PadLeft (s1.Length); - AssertEquals ("#C1", s1, result); - Assert ("#C2", !object.ReferenceEquals (s1, result)); + Assert.AreEqual (s1, result, "#C1"); + Assert.IsTrue (!object.ReferenceEquals (s1, result), "#C2"); result = s1.PadLeft (s1.Length + 1); - AssertEquals("#D", " Hi!", result); + Assert.AreEqual (" Hi!", result, "#D"); } [Test] // PadLeft (Int32) @@ -3017,12 +2968,12 @@ public class StringTest : TestCase { try { "Mono".PadLeft (-1); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "totalWidth", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("totalWidth", ex.ParamName, "#5"); } } @@ -3033,17 +2984,17 @@ public class StringTest : TestCase string result; result = s1.PadRight (0); - AssertSame ("#A", s1, result); + Assert.AreSame (s1, result, "#A"); result = s1.PadRight (s1.Length - 1); - AssertSame ("#B", s1, result); + Assert.AreSame (s1, result, "#B"); result = s1.PadRight (s1.Length); - AssertEquals ("#C1", s1, result); - Assert ("#C2", !object.ReferenceEquals (s1, result)); + Assert.AreEqual (s1, result, "#C1"); + Assert.IsTrue (!object.ReferenceEquals (s1, result), "#C2"); result = s1.PadRight (s1.Length + 1); - AssertEquals("#D", "Hi! ", result); + Assert.AreEqual ("Hi! ", result, "#D"); } [Test] // PadRight1 (Int32) @@ -3051,12 +3002,12 @@ public class StringTest : TestCase { try { "Mono".PadRight (-1); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "totalWidth", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("totalWidth", ex.ParamName, "#5"); } } @@ -3067,43 +3018,43 @@ public class StringTest : TestCase try { s1.Remove (-1, 1); - Fail ("#A1"); + Assert.Fail ("#A1"); } catch (ArgumentOutOfRangeException ex) { // StartIndex cannot be less than zero - AssertEquals ("#A2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#A3", ex.InnerException); - AssertNotNull ("#A4", ex.Message); - AssertEquals ("#A5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2"); + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#A5"); } try { s1.Remove (1,-1); - Fail ("#B1"); + Assert.Fail ("#B1"); } catch (ArgumentOutOfRangeException ex) { // Count cannot be less than zero - AssertEquals ("#B2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#B3", ex.InnerException); - AssertNotNull ("#B4", ex.Message); - AssertEquals ("#B5", "count", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2"); + Assert.IsNull (ex.InnerException, "#B3"); + Assert.IsNotNull (ex.Message, "#B4"); + Assert.AreEqual ("count", ex.ParamName, "#B5"); } try { s1.Remove (s1.Length, s1.Length); - Fail ("#C1"); + Assert.Fail ("#C1"); } catch (ArgumentOutOfRangeException ex) { // Index and count must refer to a location within the // string - AssertEquals ("#C2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#C3", ex.InnerException); - AssertNotNull ("#C4", ex.Message); - AssertEquals ("#C5", "count", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2"); + Assert.IsNull (ex.InnerException, "#C3"); + Assert.IsNotNull (ex.Message, "#C4"); + Assert.AreEqual ("count", ex.ParamName, "#C5"); } - AssertEquals ("#D1", "oinal", s1.Remove(1, 3)); - AssertEquals ("#D2", s1, s1.Remove (0, 0)); - Assert ("#D3", !object.ReferenceEquals (s1, s1.Remove (0, 0))); - AssertEquals ("#D4", "riginal", s1.Remove (0, 1)); - AssertEquals ("#D5", "origina", s1.Remove (7, 1)); + Assert.AreEqual ("oinal", s1.Remove(1, 3), "#D1"); + Assert.AreEqual (s1, s1.Remove (0, 0), "#D2"); + Assert.IsTrue (!object.ReferenceEquals (s1, s1.Remove (0, 0)), "#D3"); + Assert.AreEqual ("riginal", s1.Remove (0, 1), "#D4"); + Assert.AreEqual ("origina", s1.Remove (7, 1), "#D5"); } [Test] // Remove (Int32, Int32) @@ -3111,14 +3062,14 @@ public class StringTest : TestCase { try { "Mono".Remove (1, Int32.MaxValue); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // Index and count must refer to a location within the // string - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "count", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("count", ex.ParamName, "#5"); } } @@ -3127,14 +3078,14 @@ public class StringTest : TestCase { try { "Mono".Remove (Int32.MaxValue, 1); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // Index and count must refer to a location within the // string - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "count", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("count", ex.ParamName, "#5"); } } @@ -3144,13 +3095,13 @@ public class StringTest : TestCase { try { "ABC".Remove (-1); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // StartIndex cannot be less than zero - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#5"); } } @@ -3159,13 +3110,13 @@ public class StringTest : TestCase { try { "ABC".Remove (3); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // startIndex must be less than length of string - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#5"); } } @@ -3174,9 +3125,9 @@ public class StringTest : TestCase { string s = "ABC"; - AssertEquals ("#1", "AB", s.Remove (2)); - AssertEquals ("#2", string.Empty, s.Remove (0)); - AssertEquals ("#3", "A", s.Remove (1)); + Assert.AreEqual ("AB", s.Remove (2), "#1"); + Assert.AreEqual (string.Empty, s.Remove (0), "#2"); + Assert.AreEqual ("A", s.Remove (1), "#3"); } #endif @@ -3185,9 +3136,9 @@ public class StringTest : TestCase { string s1 = "original"; - AssertEquals("non-hit char", s1, s1.Replace('q','s')); - AssertEquals("single char", "oxiginal", s1.Replace('r', 'x')); - AssertEquals("double char", "orxgxnal", s1.Replace('i', 'x')); + Assert.AreEqual (s1, s1.Replace('q', 's'), "non-hit char"); + Assert.AreEqual ("oxiginal", s1.Replace('r', 'x'), "single char"); + Assert.AreEqual ("orxgxnal", s1.Replace('i', 'x'), "double char"); bool errorThrown = false; try { @@ -3195,34 +3146,30 @@ public class StringTest : TestCase } catch (ArgumentNullException) { errorThrown = true; } - Assert("should get null arg exception", errorThrown); + Assert.IsTrue (errorThrown, "should get null arg exception"); - AssertEquals("replace as remove", "ornal", - s1.Replace("igi", null)); - AssertEquals("non-hit string", s1, s1.Replace("spam", "eggs")); - AssertEquals("single string", "orirumal", - s1.Replace("gin", "rum")); - AssertEquals("double string", "oreigeinal", - s1.Replace("i", "ei")); + Assert.AreEqual ("ornal", s1.Replace("igi", null), "replace as remove"); + Assert.AreEqual (s1, s1.Replace("spam", "eggs"), "non-hit string"); + Assert.AreEqual ("orirumal", s1.Replace("gin", "rum"), "single string"); + Assert.AreEqual ("oreigeinal", s1.Replace("i", "ei"), "double string"); - AssertEquals("start", "ooriginal", s1.Replace("o", "oo")); - AssertEquals("end", "originall", s1.Replace("l", "ll")); + Assert.AreEqual ("ooriginal", s1.Replace("o", "oo"), "start"); + Assert.AreEqual ("originall", s1.Replace("l", "ll"), "end"); - AssertEquals("start empty", "riginal", s1.Replace("o", string.Empty)); - AssertEquals("end empty", "origina", s1.Replace("l", string.Empty)); + Assert.AreEqual ("riginal", s1.Replace("o", string.Empty), "start empty"); + Assert.AreEqual ("origina", s1.Replace("l", string.Empty), "end empty"); - AssertEquals("replace bigger that original", "original", s1.Replace("original2", "original3")); + Assert.AreEqual ("original", s1.Replace("original2", "original3"), "replace bigger that original"); - AssertEquals ("result longer", ":!:", "::".Replace ("::", ":!:")); + Assert.AreEqual (":!:", "::".Replace ("::", ":!:"), "result longer"); // Test overlapping matches (bug #54988) string s2 = "...aaaaaaa.bbbbbbbbb,............ccccccc.u..."; - AssertEquals ("..aaaaaaa.bbbbbbbbb,......ccccccc.u..", s2.Replace("..", ".")); + Assert.AreEqual (s2.Replace("..", "."), "..aaaaaaa.bbbbbbbbb,......ccccccc.u.."); // Test replacing null characters (bug #67395) #if !TARGET_JVM //bug #7276 - AssertEquals ("should not strip content after nullchar", - "is this ok ?", "is \0 ok ?".Replace ("\0", "this")); + Assert.AreEqual ("is this ok ?", "is \0 ok ?".Replace ("\0", "this"), "should not strip content after nullchar"); #endif } @@ -3231,16 +3178,16 @@ public class StringTest : TestCase { string s1 = "original"; - AssertEquals ("#1", "riginal", s1.Replace ("o", "")); - AssertEquals ("#2", "origina", s1.Replace ("l", "")); - AssertEquals ("#3", "ariginal", s1.Replace ("o", "a")); - AssertEquals ("#4", "originaa", s1.Replace ("l", "a")); - AssertEquals ("#5", "aariginal", s1.Replace ("o", "aa")); - AssertEquals ("#6", "originaaa", s1.Replace ("l", "aa")); - AssertEquals ("#7", "original", s1.Replace ("o", "o")); - AssertEquals ("#8", "original", s1.Replace ("l", "l")); - AssertEquals ("#9", "original", s1.Replace ("original", "original")); - AssertEquals ("#10", "", s1.Replace ("original", "")); + Assert.AreEqual ("riginal", s1.Replace ("o", ""), "#1"); + Assert.AreEqual ("origina", s1.Replace ("l", ""), "#2"); + Assert.AreEqual ("ariginal", s1.Replace ("o", "a"), "#3"); + Assert.AreEqual ("originaa", s1.Replace ("l", "a"), "#4"); + Assert.AreEqual ("aariginal", s1.Replace ("o", "aa"), "#5"); + Assert.AreEqual ("originaaa", s1.Replace ("l", "aa"), "#6"); + Assert.AreEqual ("original", s1.Replace ("o", "o"), "#7"); + Assert.AreEqual ("original", s1.Replace ("l", "l"), "#8"); + Assert.AreEqual ("original", s1.Replace ("original", "original"), "#9"); + Assert.AreEqual ("", s1.Replace ("original", ""), "#10"); } [Test] @@ -3249,24 +3196,24 @@ public class StringTest : TestCase string prev = new String ('o', 300); string s1 = prev + "riginal"; - AssertEquals ("#1", "riginal", s1.Replace ("o", "")); - AssertEquals ("#2", prev + "rigina", s1.Replace ("l", "")); - AssertEquals ("#3", new String ('a', 300) + "riginal", s1.Replace ("o", "a")); - AssertEquals ("#4", prev + "riginaa", s1.Replace ("l", "a")); - AssertEquals ("#5", new String ('a', 600) + "riginal", s1.Replace ("o", "aa")); - AssertEquals ("#6", prev + "riginaaa", s1.Replace ("l", "aa")); - AssertEquals ("#7", s1, s1.Replace ("o", "o")); - AssertEquals ("#8", s1, s1.Replace ("l", "l")); - AssertEquals ("#9", s1, s1.Replace (s1, s1)); - AssertEquals ("#10", "", s1.Replace (prev + "riginal", "")); + Assert.AreEqual ("riginal", s1.Replace ("o", ""), "#1"); + Assert.AreEqual (prev + "rigina", s1.Replace ("l", ""), "#2"); + Assert.AreEqual (new String ('a', 300) + "riginal", s1.Replace ("o", "a"), "#3"); + Assert.AreEqual (prev + "riginaa", s1.Replace ("l", "a"), "#4"); + Assert.AreEqual (new String ('a', 600) + "riginal", s1.Replace ("o", "aa"), "#5"); + Assert.AreEqual (prev + "riginaaa", s1.Replace ("l", "aa"), "#6"); + Assert.AreEqual (s1, s1.Replace ("o", "o"), "#7"); + Assert.AreEqual (s1, s1.Replace ("l", "l"), "#8"); + Assert.AreEqual (s1, s1.Replace (s1, s1), "#9"); + Assert.AreEqual ("", s1.Replace (prev + "riginal", ""), "#10"); } [Test] public void ReplaceStringOffByOne () { - AssertEquals ("#-1", "", new String ('o', 199).Replace ("o", "")); - AssertEquals ("#0", "", new String ('o', 200).Replace ("o", "")); - AssertEquals ("#+1", "", new String ('o', 201).Replace ("o", "")); + Assert.AreEqual ("", new String ('o', 199).Replace ("o", ""), "#-1"); + Assert.AreEqual ("", new String ('o', 200).Replace ("o", ""), "#0"); + Assert.AreEqual ("", new String ('o', 201).Replace ("o", ""), "#+1"); } [Test] @@ -3278,7 +3225,7 @@ public class StringTest : TestCase CultureInfo old = Thread.CurrentThread.CurrentCulture; Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US"); - AssertEquals ("#1", "AE", "AE".Replace ("\u00C6", "check")); + Assert.AreEqual ("AE", "AE".Replace ("\u00C6", "check"), "#1"); Thread.CurrentThread.CurrentCulture = old; } @@ -3287,12 +3234,12 @@ public class StringTest : TestCase { string s1 = "original"; - Assert ("#1", s1.StartsWith ("o")); - Assert ("#2", s1.StartsWith ("orig")); - Assert ("#3", !s1.StartsWith ("rig")); - Assert ("#4", s1.StartsWith (String.Empty)); - Assert ("#5", String.Empty.StartsWith (String.Empty)); - Assert ("#6", !String.Empty.StartsWith ("rig")); + Assert.IsTrue (s1.StartsWith ("o"), "#1"); + Assert.IsTrue (s1.StartsWith ("orig"), "#2"); + Assert.IsTrue (!s1.StartsWith ("rig"), "#3"); + Assert.IsTrue (s1.StartsWith (String.Empty), "#4"); + Assert.IsTrue (String.Empty.StartsWith (String.Empty), "#5"); + Assert.IsTrue (!String.Empty.StartsWith ("rig"), "#6"); } [Test] // StartsWith (String) @@ -3300,12 +3247,12 @@ public class StringTest : TestCase { try { "A".StartsWith (null); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentNullException ex) { - AssertEquals ("#2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "value", ex.ParamName); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("value", ex.ParamName, "#5"); } } @@ -3315,14 +3262,14 @@ public class StringTest : TestCase { try { "ABC".StartsWith ("A", (StringComparison) 80); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentException ex) { // The string comparison type passed in is currently // not supported - AssertEquals ("#2", typeof (ArgumentException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "comparisonType", ex.ParamName); + Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("comparisonType", ex.ParamName, "#5"); } } @@ -3331,12 +3278,12 @@ public class StringTest : TestCase { try { "A".StartsWith (null, StringComparison.CurrentCulture); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentNullException ex) { - AssertEquals ("#2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "value", ex.ParamName); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("value", ex.ParamName, "#5"); } } @@ -3355,13 +3302,13 @@ public class StringTest : TestCase { string s = "original"; - AssertEquals("#1", "inal", s.Substring (4)); - AssertEquals ("#2", string.Empty, s.Substring (s.Length)); + Assert.AreEqual ("inal", s.Substring (4), "#1"); + Assert.AreEqual (string.Empty, s.Substring (s.Length), "#2"); #if NET_2_0 - AssertSame ("#3", s, s.Substring (0)); + Assert.AreSame (s, s.Substring (0), "#3"); #else - AssertEquals ("#3a", s, s.Substring (0)); - Assert ("#3b", !object.ReferenceEquals (s, s.Substring (0))); + Assert.AreEqual (s, s.Substring (0), "#3a"); + Assert.IsTrue (!object.ReferenceEquals (s, s.Substring (0)), "#3b"); #endif } @@ -3372,13 +3319,13 @@ public class StringTest : TestCase try { s.Substring (-1); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // StartIndex cannot be less than zero - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#5"); } } @@ -3389,16 +3336,16 @@ public class StringTest : TestCase try { s.Substring (s.Length + 1); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // startIndex cannot be larger than length of string - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); #if NET_2_0 - AssertEquals ("#5", "startIndex", ex.ParamName); + Assert.AreEqual ("startIndex", ex.ParamName, "#5"); #else - AssertEquals ("#5", "length", ex.ParamName); + Assert.AreEqual ("length", ex.ParamName, "#5"); #endif } } @@ -3408,14 +3355,14 @@ public class StringTest : TestCase { string s = "original"; - AssertEquals ("#1", "igin", s.Substring (2, 4)); - AssertEquals ("#2", string.Empty, s.Substring (s.Length, 0)); - AssertEquals ("#3", "origina", s.Substring (0, s.Length - 1)); - AssertEquals ("#4", s, s.Substring (0, s.Length)); + Assert.AreEqual ("igin", s.Substring (2, 4), "#1"); + Assert.AreEqual (string.Empty, s.Substring (s.Length, 0), "#2"); + Assert.AreEqual ("origina", s.Substring (0, s.Length - 1), "#3"); + Assert.AreEqual (s, s.Substring (0, s.Length), "#4"); #if NET_2_0 - AssertSame ("#5", s, s.Substring (0, s.Length)); + Assert.AreSame (s, s.Substring (0, s.Length), "#5"); #else - Assert ("#5", !object.ReferenceEquals (s, s.Substring (0, s.Length))); + Assert.IsTrue (!object.ReferenceEquals (s, s.Substring (0, s.Length)), "#5"); #endif } @@ -3426,13 +3373,13 @@ public class StringTest : TestCase try { s.Substring (1, -1); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // Length cannot be less than zero - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "length", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("length", ex.ParamName, "#5"); } } @@ -3443,38 +3390,38 @@ public class StringTest : TestCase try { s.Substring (s.Length, 1); - Fail ("#A1"); + Assert.Fail ("#A1"); } catch (ArgumentOutOfRangeException ex) { // Index and length must refer to a location within // the string - AssertEquals ("#A2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#A3", ex.InnerException); - AssertNotNull ("#A4", ex.Message); - AssertEquals ("#A5", "length", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2"); + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); + Assert.AreEqual ("length", ex.ParamName, "#A5"); } try { s.Substring (1, s.Length); - Fail ("#B1"); + Assert.Fail ("#B1"); } catch (ArgumentOutOfRangeException ex) { // Index and length must refer to a location within // the string - AssertEquals ("#B2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#B3", ex.InnerException); - AssertNotNull ("#B4", ex.Message); - AssertEquals ("#B5", "length", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2"); + Assert.IsNull (ex.InnerException, "#B3"); + Assert.IsNotNull (ex.Message, "#B4"); + Assert.AreEqual ("length", ex.ParamName, "#B5"); } try { s.Substring (1, Int32.MaxValue); - Fail ("#C1"); + Assert.Fail ("#C1"); } catch (ArgumentOutOfRangeException ex) { // Index and length must refer to a location within // the string - AssertEquals ("#C2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#C3", ex.InnerException); - AssertNotNull ("#C4", ex.Message); - AssertEquals ("#C5", "length", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2"); + Assert.IsNull (ex.InnerException, "#C3"); + Assert.IsNotNull (ex.Message, "#C4"); + Assert.AreEqual ("length", ex.ParamName, "#C5"); } } @@ -3485,13 +3432,13 @@ public class StringTest : TestCase try { s.Substring (-1, 1); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // StartIndex cannot be less than zero - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#5"); } } @@ -3502,31 +3449,31 @@ public class StringTest : TestCase try { s.Substring (s.Length + 1, 0); - Fail ("#A1"); + Assert.Fail ("#A1"); } catch (ArgumentOutOfRangeException ex) { // startIndex cannot be larger than length of string - AssertEquals ("#A2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#A3", ex.InnerException); - AssertNotNull ("#A4", ex.Message); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2"); + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); #if NET_2_0 - AssertEquals ("#A5", "startIndex", ex.ParamName); + Assert.AreEqual ("startIndex", ex.ParamName, "#A5"); #else - AssertEquals ("#A5", "length", ex.ParamName); + Assert.AreEqual ("length", ex.ParamName, "#A5"); #endif } try { "Mono".Substring (Int32.MaxValue, 1); - Fail ("#B1"); + Assert.Fail ("#B1"); } catch (ArgumentOutOfRangeException ex) { // startIndex cannot be larger than length of string - AssertEquals ("#B2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#B3", ex.InnerException); - AssertNotNull ("#B4", ex.Message); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2"); + Assert.IsNull (ex.InnerException, "#B3"); + Assert.IsNotNull (ex.Message, "#B4"); #if NET_2_0 - AssertEquals ("#B5", "startIndex", ex.ParamName); + Assert.AreEqual ("startIndex", ex.ParamName, "#B5"); #else - AssertEquals ("#B5", "length", ex.ParamName); + Assert.AreEqual ("length", ex.ParamName, "#B5"); #endif } } @@ -3538,32 +3485,32 @@ public class StringTest : TestCase char [] c; c = s.ToCharArray (); - AssertEquals ("#A1", s.Length, c.Length); - AssertEquals ("#A2", s, new String (c)); + Assert.AreEqual (s.Length, c.Length, "#A1"); + Assert.AreEqual (s, new String (c), "#A2"); c = s.ToCharArray (0, s.Length); - AssertEquals ("#B1", s.Length, c.Length); - AssertEquals ("#B2", s, new String (c)); + Assert.AreEqual (s.Length, c.Length, "#B1"); + Assert.AreEqual (s, new String (c), "#B2"); c = s.ToCharArray (1, s.Length - 1); - AssertEquals ("#C1", 7, c.Length); - AssertEquals ("#C2", "riginal", new String (c)); + Assert.AreEqual (7, c.Length, "#C1"); + Assert.AreEqual ("riginal", new String (c), "#C2"); c = s.ToCharArray (0, 3); - AssertEquals ("#D1", 3, c.Length); - AssertEquals ("#D2", "ori", new String (c)); + Assert.AreEqual (3, c.Length, "#D1"); + Assert.AreEqual ("ori", new String (c), "#D2"); c = s.ToCharArray (2, 0); - AssertEquals ("#E1", 0, c.Length); - AssertEquals ("#E2", string.Empty, new String (c)); + Assert.AreEqual (0, c.Length, "#E1"); + Assert.AreEqual (string.Empty, new String (c), "#E2"); c = s.ToCharArray (3, 2); - AssertEquals ("#F1", 2, c.Length); - AssertEquals ("#F2", "gi", new String (c)); + Assert.AreEqual (2, c.Length, "#F1"); + Assert.AreEqual ("gi", new String (c), "#F2"); c = s.ToCharArray (s.Length, 0); - AssertEquals ("#G1", 0, c.Length); - AssertEquals ("#G2", string.Empty, new String (c)); + Assert.AreEqual (0, c.Length, "#G1"); + Assert.AreEqual (string.Empty, new String (c), "#G2"); } [Test] @@ -3573,12 +3520,12 @@ public class StringTest : TestCase try { s.ToCharArray (1, -1); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "length", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("length", ex.ParamName, "#5"); } } @@ -3589,26 +3536,26 @@ public class StringTest : TestCase try { s.ToCharArray (1, s.Length); - Fail ("#A1"); + Assert.Fail ("#A1"); } catch (ArgumentOutOfRangeException ex) { // Index was out of range. Must be non-negative and // less than the size of the collection - AssertEquals ("#A2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#A3", ex.InnerException); - AssertNotNull ("#A4", ex.Message); - AssertEquals ("#A5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2"); + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#A5"); } try { s.ToCharArray (1, Int32.MaxValue); - Fail ("#B1"); + Assert.Fail ("#B1"); } catch (ArgumentOutOfRangeException ex) { // Index was out of range. Must be non-negative and // less than the size of the collection - AssertEquals ("#B2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#B3", ex.InnerException); - AssertNotNull ("#B4", ex.Message); - AssertEquals ("#B5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2"); + Assert.IsNull (ex.InnerException, "#B3"); + Assert.IsNotNull (ex.Message, "#B4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#B5"); } } @@ -3619,14 +3566,14 @@ public class StringTest : TestCase try { s.ToCharArray (-1, 1); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // Index was out of range. Must be non-negative and // less than the size of the collection - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#5"); } } @@ -3637,26 +3584,26 @@ public class StringTest : TestCase try { s.ToCharArray (s.Length, 1); - Fail ("#A1"); + Assert.Fail ("#A1"); } catch (ArgumentOutOfRangeException ex) { // Index was out of range. Must be non-negative and // less than the size of the collection - AssertEquals ("#A2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#A3", ex.InnerException); - AssertNotNull ("#A4", ex.Message); - AssertEquals ("#A5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2"); + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#A5"); } try { s.ToCharArray (Int32.MaxValue, 1); - Fail ("#B1"); + Assert.Fail ("#B1"); } catch (ArgumentOutOfRangeException ex) { // Index was out of range. Must be non-negative and // less than the size of the collection - AssertEquals ("#B2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#B3", ex.InnerException); - AssertNotNull ("#B4", ex.Message); - AssertEquals ("#B5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2"); + Assert.IsNull (ex.InnerException, "#B3"); + Assert.IsNotNull (ex.Message, "#B4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#B5"); } } @@ -3667,11 +3614,11 @@ public class StringTest : TestCase Thread.CurrentThread.CurrentCulture = new CultureInfo ("tr-TR"); - AssertEquals ("#1", "\u006f\u0072\u0131\u0067\u0131\u006e\u0061\u006c\u0069", s.ToLower()); + Assert.AreEqual ("\u006f\u0072\u0131\u0067\u0131\u006e\u0061\u006c\u0069", s.ToLower(), "#1"); Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US"); - AssertEquals ("#2", "originali", s.ToLower ()); + Assert.AreEqual ("originali", s.ToLower (), "#2"); } [Test] // ToLower (CultureInfo) @@ -3681,19 +3628,17 @@ public class StringTest : TestCase Thread.CurrentThread.CurrentCulture = new CultureInfo ("tr-TR"); - AssertEquals ("#A1", "originali", s.ToLower (new CultureInfo ("en-US"))); - AssertEquals ("#A2", "\u006f\u0072\u0131\u0067\u0131\u006e\u0061\u006c\u0069", - s.ToLower (new CultureInfo ("tr-TR"))); - AssertEquals ("#A3", string.Empty, string.Empty.ToLower (new CultureInfo ("en-US"))); - AssertEquals ("#A4", string.Empty, string.Empty.ToLower (new CultureInfo ("tr-TR"))); + Assert.AreEqual ("originali", s.ToLower (new CultureInfo ("en-US")), "#A1"); + Assert.AreEqual ("\u006f\u0072\u0131\u0067\u0131\u006e\u0061\u006c\u0069", s.ToLower (new CultureInfo ("tr-TR")), "#A2"); + Assert.AreEqual (string.Empty, string.Empty.ToLower (new CultureInfo ("en-US")), "#A3"); + Assert.AreEqual (string.Empty, string.Empty.ToLower (new CultureInfo ("tr-TR")), "#A4"); Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US"); - AssertEquals ("#B1", "originali", s.ToLower (new CultureInfo ("en-US"))); - AssertEquals ("#B2", "\u006f\u0072\u0131\u0067\u0131\u006e\u0061\u006c\u0069", - s.ToLower (new CultureInfo ("tr-TR"))); - AssertEquals ("#B3", string.Empty, string.Empty.ToLower (new CultureInfo ("en-US"))); - AssertEquals ("#B4", string.Empty, string.Empty.ToLower (new CultureInfo ("tr-TR"))); + Assert.AreEqual ("originali", s.ToLower (new CultureInfo ("en-US")), "#B1"); + Assert.AreEqual ("\u006f\u0072\u0131\u0067\u0131\u006e\u0061\u006c\u0069", s.ToLower (new CultureInfo ("tr-TR")), "#B2"); + Assert.AreEqual (string.Empty, string.Empty.ToLower (new CultureInfo ("en-US")), "#B3"); + Assert.AreEqual (string.Empty, string.Empty.ToLower (new CultureInfo ("tr-TR")), "#B4"); } [Test] // ToLower (CultureInfo) @@ -3703,22 +3648,22 @@ public class StringTest : TestCase try { s.ToLower ((CultureInfo) null); - Fail ("#A1"); + Assert.Fail ("#A1"); } catch (ArgumentNullException ex) { - AssertEquals ("#A2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#A3", ex.InnerException); - AssertNotNull ("#A4", ex.Message); - AssertEquals ("#A5", "culture", ex.ParamName); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2"); + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); + Assert.AreEqual ("culture", ex.ParamName, "#A5"); } try { string.Empty.ToLower ((CultureInfo) null); - Fail ("#B1"); + Assert.Fail ("#B1"); } catch (ArgumentNullException ex) { - AssertEquals ("#B2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#B3", ex.InnerException); - AssertNotNull ("#B4", ex.Message); - AssertEquals ("#B5", "culture", ex.ParamName); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2"); + Assert.IsNull (ex.InnerException, "#B3"); + Assert.IsNotNull (ex.Message, "#B4"); + Assert.AreEqual ("culture", ex.ParamName, "#B5"); } } @@ -3726,7 +3671,7 @@ public class StringTest : TestCase public void TestToString () { string s1 = "OrIgInAli"; - AssertEquals("ToString failed!", s1, s1.ToString()); + Assert.AreEqual (s1, s1.ToString(), "ToString failed!"); } [Test] // ToUpper () @@ -3736,11 +3681,11 @@ public class StringTest : TestCase Thread.CurrentThread.CurrentCulture = new CultureInfo ("tr-TR"); - AssertEquals ("#1", "ORIGINAL\u0130", s.ToUpper ()); + Assert.AreEqual ("ORIGINAL\u0130", s.ToUpper (), "#1"); Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US"); - AssertEquals ("#2", "ORIGINALI", s.ToUpper ()); + Assert.AreEqual ("ORIGINALI", s.ToUpper (), "#2"); } [Test] // ToUpper (CultureInfo) @@ -3750,17 +3695,17 @@ public class StringTest : TestCase Thread.CurrentThread.CurrentCulture = new CultureInfo ("tr-TR"); - AssertEquals ("#A1", "ORIGINALI", s.ToUpper (new CultureInfo ("en-US"))); - AssertEquals ("#A2", "ORIGINAL\u0130", s.ToUpper (new CultureInfo ("tr-TR"))); - AssertEquals ("#A3", string.Empty, string.Empty.ToUpper (new CultureInfo ("en-US"))); - AssertEquals ("#A4", string.Empty, string.Empty.ToUpper (new CultureInfo ("tr-TR"))); + Assert.AreEqual ("ORIGINALI", s.ToUpper (new CultureInfo ("en-US")), "#A1"); + Assert.AreEqual ("ORIGINAL\u0130", s.ToUpper (new CultureInfo ("tr-TR")), "#A2"); + Assert.AreEqual (string.Empty, string.Empty.ToUpper (new CultureInfo ("en-US")), "#A3"); + Assert.AreEqual (string.Empty, string.Empty.ToUpper (new CultureInfo ("tr-TR")), "#A4"); Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US"); - AssertEquals ("#B1", "ORIGINALI", s.ToUpper (new CultureInfo ("en-US"))); - AssertEquals ("#B2", "ORIGINAL\u0130", s.ToUpper (new CultureInfo ("tr-TR"))); - AssertEquals ("#B3", string.Empty, string.Empty.ToUpper (new CultureInfo ("en-US"))); - AssertEquals ("#B4", string.Empty, string.Empty.ToUpper (new CultureInfo ("tr-TR"))); + Assert.AreEqual ("ORIGINALI", s.ToUpper (new CultureInfo ("en-US")), "#B1"); + Assert.AreEqual ("ORIGINAL\u0130", s.ToUpper (new CultureInfo ("tr-TR")), "#B2"); + Assert.AreEqual (string.Empty, string.Empty.ToUpper (new CultureInfo ("en-US")), "#B3"); + Assert.AreEqual (string.Empty, string.Empty.ToUpper (new CultureInfo ("tr-TR")), "#B4"); } [Test] // ToUpper (CultureInfo) @@ -3770,22 +3715,22 @@ public class StringTest : TestCase try { s.ToUpper ((CultureInfo) null); - Fail ("#A1"); + Assert.Fail ("#A1"); } catch (ArgumentNullException ex) { - AssertEquals ("#A2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#A3", ex.InnerException); - AssertNotNull ("#A4", ex.Message); - AssertEquals ("#A5", "culture", ex.ParamName); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2"); + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); + Assert.AreEqual ("culture", ex.ParamName, "#A5"); } try { string.Empty.ToUpper ((CultureInfo) null); - Fail ("#B1"); + Assert.Fail ("#B1"); } catch (ArgumentNullException ex) { - AssertEquals ("#B2", typeof (ArgumentNullException), ex.GetType ()); - AssertNull ("#B3", ex.InnerException); - AssertNotNull ("#B4", ex.Message); - AssertEquals ("#B5", "culture", ex.ParamName); + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2"); + Assert.IsNull (ex.InnerException, "#B3"); + Assert.IsNotNull (ex.Message, "#B4"); + Assert.AreEqual ("culture", ex.ParamName, "#B5"); } } @@ -3793,25 +3738,24 @@ public class StringTest : TestCase public void TestTrim () { string s1 = " original\t\n"; - AssertEquals("basic trim failed", "original", s1.Trim()); - AssertEquals("basic trim failed", "original", s1.Trim(null)); + Assert.AreEqual ("original", s1.Trim(), "basic trim failed"); + Assert.AreEqual ("original", s1.Trim(null), "basic trim failed"); s1 = "original"; - AssertEquals("basic trim failed", "original", s1.Trim()); - AssertEquals("basic trim failed", "original", s1.Trim(null)); + Assert.AreEqual ("original", s1.Trim(), "basic trim failed"); + Assert.AreEqual ("original", s1.Trim(null), "basic trim failed"); s1 = " \t \n "; - AssertEquals("empty trim failed", string.Empty, s1.Trim()); - AssertEquals("empty trim failed", string.Empty, s1.Trim(null)); + Assert.AreEqual (string.Empty, s1.Trim(), "empty trim failed"); + Assert.AreEqual (string.Empty, s1.Trim(null), "empty trim failed"); s1 = "aaaoriginalbbb"; char[] delims = {'a', 'b'}; - AssertEquals("custom trim failed", - "original", s1.Trim(delims)); + Assert.AreEqual ("original", s1.Trim(delims), "custom trim failed"); #if NET_2_0 - AssertEquals ("net_2_0 additional char#1", "original", "\u2028original\u2029".Trim ()); - AssertEquals ("net_2_0 additional char#2", "original", "\u0085original\u1680".Trim ()); + Assert.AreEqual ("original", "\u2028original\u2029".Trim (), "net_2_0 additional char#1"); + Assert.AreEqual ("original", "\u0085original\u1680".Trim (), "net_2_0 additional char#2"); #endif } @@ -3819,42 +3763,34 @@ public class StringTest : TestCase public void TestTrimEnd () { string s1 = " original\t\n"; - AssertEquals("basic TrimEnd failed", - " original", s1.TrimEnd(null)); + Assert.AreEqual (" original", s1.TrimEnd(null), "basic TrimEnd failed"); s1 = " original"; - AssertEquals("basic TrimEnd failed", - " original", s1.TrimEnd(null)); + Assert.AreEqual (" original", s1.TrimEnd(null), "basic TrimEnd failed"); s1 = " \t \n \n "; - AssertEquals("empty TrimEnd failed", - string.Empty, s1.TrimEnd(null)); + Assert.AreEqual (string.Empty, s1.TrimEnd(null), "empty TrimEnd failed"); s1 = "aaaoriginalbbb"; char[] delims = {'a', 'b'}; - AssertEquals("custom TrimEnd failed", - "aaaoriginal", s1.TrimEnd(delims)); + Assert.AreEqual ("aaaoriginal", s1.TrimEnd(delims), "custom TrimEnd failed"); } [Test] public void TestTrimStart () { string s1 = " original\t\n"; - AssertEquals("basic TrimStart failed", - "original\t\n", s1.TrimStart(null)); + Assert.AreEqual ("original\t\n", s1.TrimStart(null), "basic TrimStart failed"); s1 = "original\t\n"; - AssertEquals("basic TrimStart failed", - "original\t\n", s1.TrimStart(null)); + Assert.AreEqual ("original\t\n", s1.TrimStart(null), "basic TrimStart failed"); s1 = " \t \n \n "; - AssertEquals("empty TrimStart failed", - string.Empty, s1.TrimStart(null)); + Assert.AreEqual (string.Empty, s1.TrimStart(null), "empty TrimStart failed"); s1 = "aaaoriginalbbb"; char[] delims = {'a', 'b'}; - AssertEquals("custom TrimStart failed", - "originalbbb", s1.TrimStart(delims)); + Assert.AreEqual ("originalbbb", s1.TrimStart(delims), "custom TrimStart failed"); } [Test] @@ -3865,21 +3801,21 @@ public class StringTest : TestCase s = string.Empty; try { char c = s [0]; - Fail ("#A1:" + c); + Assert.Fail ("#A1:" + c); } catch (IndexOutOfRangeException ex) { - AssertEquals ("#A2", typeof (IndexOutOfRangeException), ex.GetType ()); - AssertNull ("#A3", ex.InnerException); - AssertNotNull ("#A4", ex.Message); + Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#A2"); + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); } s = "A"; try { char c = s [-1]; - Fail ("#B1:" + c); + Assert.Fail ("#B1:" + c); } catch (IndexOutOfRangeException ex) { - AssertEquals ("#B2", typeof (IndexOutOfRangeException), ex.GetType ()); - AssertNull ("#B3", ex.InnerException); - AssertNotNull ("#B4", ex.Message); + Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#B2"); + Assert.IsNull (ex.InnerException, "#B3"); + Assert.IsNotNull (ex.Message, "#B4"); } } @@ -3887,7 +3823,7 @@ public class StringTest : TestCase public void TestComparePeriod () { // according to bug 63981, this behavior is for all cultures - AssertEquals ("#1", -1, String.Compare ("foo.obj", "foobar.obj", false)); + Assert.AreEqual (-1, String.Compare ("foo.obj", "foobar.obj", false), "#1"); } [Test] @@ -3897,12 +3833,12 @@ public class StringTest : TestCase char [] k = { 'M' }; try { mono.LastIndexOfAny (k, mono.Length, 1); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "startIndex", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("startIndex", ex.ParamName, "#5"); } } @@ -3911,14 +3847,14 @@ public class StringTest : TestCase { string s1 = "abcdefghijklm"; char[] c1 = {'q', 'r'}; - AssertEquals("No splitters", s1, (s1.Split(c1))[0]); + Assert.AreEqual (s1, (s1.Split(c1))[0], "No splitters"); char[] c2 = {'a', 'e', 'i', 'o', 'u'}; string[] chunks = s1.Split(c2); - AssertEquals("First chunk", string.Empty, chunks[0]); - AssertEquals("Second chunk", "bcd", chunks[1]); - AssertEquals("Third chunk", "fgh", chunks[2]); - AssertEquals("Fourth chunk", "jklm", chunks[3]); + Assert.AreEqual (string.Empty, chunks[0], "First chunk"); + Assert.AreEqual ("bcd", chunks[1], "Second chunk"); + Assert.AreEqual ("fgh", chunks[2], "Third chunk"); + Assert.AreEqual ("jklm", chunks[3], "Fourth chunk"); { bool errorThrown = false; @@ -3927,71 +3863,71 @@ public class StringTest : TestCase } catch (ArgumentOutOfRangeException) { errorThrown = true; } - Assert("Split out of range", errorThrown); + Assert.IsTrue (errorThrown, "Split out of range"); } chunks = s1.Split(c2, 2); - AssertEquals("Limited chunk", 2, chunks.Length); - AssertEquals("First limited chunk", string.Empty, chunks[0]); - AssertEquals("Second limited chunk", "bcdefghijklm", chunks[1]); + Assert.AreEqual (2, chunks.Length, "Limited chunk"); + Assert.AreEqual (string.Empty, chunks[0], "First limited chunk"); + Assert.AreEqual ("bcdefghijklm", chunks[1], "Second limited chunk"); string s3 = "1.0"; char[] c3 = {'.'}; chunks = s3.Split(c3,2); - AssertEquals("1.0 split length", 2, chunks.Length); - AssertEquals("1.0 split first chunk", "1", chunks[0]); - AssertEquals("1.0 split second chunk", "0", chunks[1]); + Assert.AreEqual (2, chunks.Length, "1.0 split length"); + Assert.AreEqual ("1", chunks[0], "1.0 split first chunk"); + Assert.AreEqual ("0", chunks[1], "1.0 split second chunk"); string s4 = "1.0.0"; char[] c4 = {'.'}; chunks = s4.Split(c4,2); - AssertEquals("1.0.0 split length", 2, chunks.Length); - AssertEquals("1.0.0 split first chunk", "1", chunks[0]); - AssertEquals("1.0.0 split second chunk", "0.0", chunks[1]); + Assert.AreEqual (2, chunks.Length, "1.0.0 split length"); + Assert.AreEqual ("1", chunks[0], "1.0.0 split first chunk"); + Assert.AreEqual ("0.0", chunks[1], "1.0.0 split second chunk"); string s5 = ".0.0"; char[] c5 = {'.'}; chunks = s5.Split (c5, 2); - AssertEquals(".0.0 split length", 2, chunks.Length); - AssertEquals(".0.0 split first chunk", string.Empty, chunks[0]); - AssertEquals(".0.0 split second chunk", "0.0", chunks[1]); + Assert.AreEqual (2, chunks.Length, ".0.0 split length"); + Assert.AreEqual (string.Empty, chunks[0], ".0.0 split first chunk"); + Assert.AreEqual ("0.0", chunks[1], ".0.0 split second chunk"); string s6 = ".0"; char[] c6 = {'.'}; chunks = s6.Split (c6, 2); - AssertEquals(".0 split length", 2, chunks.Length); - AssertEquals(".0 split first chunk", string.Empty, chunks[0]); - AssertEquals(".0 split second chunk", "0", chunks[1]); + Assert.AreEqual (2, chunks.Length, ".0 split length"); + Assert.AreEqual (string.Empty, chunks[0], ".0 split first chunk"); + Assert.AreEqual ("0", chunks[1], ".0 split second chunk"); string s7 = "0."; char[] c7 = {'.'}; chunks = s7.Split (c7, 2); - AssertEquals("0. split length", 2, chunks.Length); - AssertEquals("0. split first chunk", "0", chunks[0]); - AssertEquals("0. split second chunk", string.Empty, chunks[1]); + Assert.AreEqual (2, chunks.Length, "0. split length"); + Assert.AreEqual ("0", chunks[0], "0. split first chunk"); + Assert.AreEqual (string.Empty, chunks[1], "0. split second chunk"); string s8 = "0.0000"; char[] c8 = {'.'}; chunks = s8.Split (c8, 2); - AssertEquals("0.0000/2 split length", 2, chunks.Length); - AssertEquals("0.0000/2 split first chunk", "0", chunks[0]); - AssertEquals("0.0000/2 split second chunk", "0000", chunks[1]); + Assert.AreEqual (2, chunks.Length, "0.0000/2 split length"); + Assert.AreEqual ("0", chunks[0], "0.0000/2 split first chunk"); + Assert.AreEqual ("0000", chunks[1], "0.0000/2 split second chunk"); chunks = s8.Split (c8, 3); - AssertEquals("0.0000/3 split length", 2, chunks.Length); - AssertEquals("0.0000/3 split first chunk", "0", chunks[0]); - AssertEquals("0.0000/3 split second chunk", "0000", chunks[1]); + Assert.AreEqual (2, chunks.Length, "0.0000/3 split length"); + Assert.AreEqual ("0", chunks[0], "0.0000/3 split first chunk"); + Assert.AreEqual ("0000", chunks[1], "0.0000/3 split second chunk"); chunks = s8.Split (c8, 1); - AssertEquals("0.0000/1 split length", 1, chunks.Length); - AssertEquals("0.0000/1 split first chunk", "0.0000", chunks[0]); + Assert.AreEqual (1, chunks.Length, "0.0000/1 split length"); + Assert.AreEqual ("0.0000", chunks[0], "0.0000/1 split first chunk"); chunks = s1.Split(c2, 1); - AssertEquals("Single split", 1, chunks.Length); - AssertEquals("Single chunk", s1, chunks[0]); + Assert.AreEqual (1, chunks.Length, "Single split"); + Assert.AreEqual (s1, chunks[0], "Single chunk"); chunks = s1.Split(c2, 0); - AssertEquals("Zero split", 0, chunks.Length); + Assert.AreEqual (0, chunks.Length, "Zero split"); } [Test] @@ -3999,9 +3935,9 @@ public class StringTest : TestCase { string test = "123 456 789"; string [] st = test.Split (); - AssertEquals ("#01", "123", st [0]); + Assert.AreEqual ("123", st [0], "#01"); st = test.Split (null); - AssertEquals ("#02", "123", st [0]); + Assert.AreEqual ("123", st [0], "#02"); } #if NET_2_0 @@ -4010,14 +3946,14 @@ public class StringTest : TestCase { try { "A B".Split (new Char [] { 'A' }, (StringSplitOptions) 4096); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentException ex) { // Illegal enum value: 4096 - AssertEquals ("#2", typeof (ArgumentException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - Assert ("#5", ex.Message.IndexOf ("4096") != 1); - AssertNull ("#6", ex.ParamName); + Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.IsTrue (ex.Message.IndexOf ("4096") != 1, "#5"); + Assert.IsNull (ex.ParamName, "#6"); } } @@ -4026,14 +3962,14 @@ public class StringTest : TestCase { try { "A B".Split (new String [] { "A" }, (StringSplitOptions) 4096); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentException ex) { // Illegal enum value: 4096 - AssertEquals ("#2", typeof (ArgumentException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - Assert ("#5", ex.Message.IndexOf ("4096") != 1); - AssertNull ("#6", ex.ParamName); + Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.IsTrue (ex.Message.IndexOf ("4096") != 1, "#5"); + Assert.IsNull (ex.ParamName, "#6"); } } @@ -4042,14 +3978,14 @@ public class StringTest : TestCase { try { "A B".Split (new Char [] { 'A' }, 0, (StringSplitOptions) 4096); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentException ex) { // Illegal enum value: 4096 - AssertEquals ("#2", typeof (ArgumentException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - Assert ("#5", ex.Message.IndexOf ("4096") != 1); - AssertNull ("#6", ex.ParamName); + Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.IsTrue (ex.Message.IndexOf ("4096") != 1, "#5"); + Assert.IsNull (ex.ParamName, "#6"); } } @@ -4058,12 +3994,12 @@ public class StringTest : TestCase { try { "A B".Split (new String [] { "A" }, -1, StringSplitOptions.None); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { - AssertEquals ("#2", typeof (ArgumentOutOfRangeException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - AssertEquals ("#5", "count", ex.ParamName); + Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.AreEqual ("count", ex.ParamName, "#5"); } } @@ -4072,14 +4008,14 @@ public class StringTest : TestCase { try { "A B".Split (new String [] { "A" }, 0, (StringSplitOptions) 4096); - Fail ("#1"); + Assert.Fail ("#1"); } catch (ArgumentException ex) { // Illegal enum value: 4096 - AssertEquals ("#2", typeof (ArgumentException), ex.GetType ()); - AssertNull ("#3", ex.InnerException); - AssertNotNull ("#4", ex.Message); - Assert ("#5", ex.Message.IndexOf ("4096") != 1); - AssertNull ("#6", ex.ParamName); + Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.IsTrue (ex.Message.IndexOf ("4096") != 1, "#5"); + Assert.IsNull (ex.ParamName, "#6"); } } @@ -4090,77 +4026,77 @@ public class StringTest : TestCase // count == 0 res = "A B C".Split (new String [] { "A" }, 0, StringSplitOptions.None); - AssertEquals (0, res.Length); + Assert.AreEqual (0, res.Length); // empty and RemoveEmpty res = string.Empty.Split (new String [] { "A" }, StringSplitOptions.RemoveEmptyEntries); - AssertEquals (0, res.Length); + Assert.AreEqual (0, res.Length); // Not found res = "A B C".Split (new String [] { "D" }, StringSplitOptions.None); - AssertEquals (1, res.Length); - AssertEquals ("A B C", res [0]); + Assert.AreEqual (1, res.Length); + Assert.AreEqual ("A B C", res [0]); // A normal test res = "A B C DD E".Split (new String[] { "B", "D" }, StringSplitOptions.None); - AssertEquals (4, res.Length); - AssertEquals ("A ", res [0]); - AssertEquals (" C ", res [1]); - AssertEquals (string.Empty, res [2]); - AssertEquals (" E", res [3]); + Assert.AreEqual (4, res.Length); + Assert.AreEqual ("A ", res [0]); + Assert.AreEqual (" C ", res [1]); + Assert.AreEqual (string.Empty, res [2]); + Assert.AreEqual (" E", res [3]); // Same with RemoveEmptyEntries res = "A B C DD E".Split (new String[] { "B", "D" }, StringSplitOptions.RemoveEmptyEntries); - AssertEquals (3, res.Length); - AssertEquals ("A ", res [0]); - AssertEquals (" C ", res [1]); - AssertEquals (" E", res [2]); + Assert.AreEqual (3, res.Length); + Assert.AreEqual ("A ", res [0]); + Assert.AreEqual (" C ", res [1]); + Assert.AreEqual (" E", res [2]); // Delimiter matches once at the beginning of the string res = "A B".Split (new String [] { "A" }, StringSplitOptions.RemoveEmptyEntries); - AssertEquals (1, res.Length); - AssertEquals (" B", res [0]); + Assert.AreEqual (1, res.Length); + Assert.AreEqual (" B", res [0]); // Delimiter at the beginning and at the end res = "B C DD B".Split (new String[] { "B" }, StringSplitOptions.None); - AssertEquals (3, res.Length); - AssertEquals (string.Empty, res [0]); - AssertEquals (" C DD ", res [1]); - AssertEquals (string.Empty, res [2]); + Assert.AreEqual (3, res.Length); + Assert.AreEqual (string.Empty, res [0]); + Assert.AreEqual (" C DD ", res [1]); + Assert.AreEqual (string.Empty, res [2]); res = "B C DD B".Split (new String[] { "B" }, StringSplitOptions.RemoveEmptyEntries); - AssertEquals (1, res.Length); - AssertEquals (" C DD ", res [0]); + Assert.AreEqual (1, res.Length); + Assert.AreEqual (" C DD ", res [0]); // count res = "A B C DD E".Split (new String[] { "B", "D" }, 2, StringSplitOptions.None); - AssertEquals (2, res.Length); - AssertEquals ("A ", res [0]); - AssertEquals (" C DD E", res [1]); + Assert.AreEqual (2, res.Length); + Assert.AreEqual ("A ", res [0]); + Assert.AreEqual (" C DD E", res [1]); // Ordering res = "ABCDEF".Split (new String[] { "EF", "BCDE" }, StringSplitOptions.None); - AssertEquals (2, res.Length); - AssertEquals ("A", res [0]); - AssertEquals ("F", res [1]); + Assert.AreEqual (2, res.Length); + Assert.AreEqual ("A", res [0]); + Assert.AreEqual ("F", res [1]); res = "ABCDEF".Split (new String[] { "BCD", "BC" }, StringSplitOptions.None); - AssertEquals (2, res.Length); - AssertEquals ("A", res [0]); - AssertEquals ("EF", res [1]); + Assert.AreEqual (2, res.Length); + Assert.AreEqual ("A", res [0]); + Assert.AreEqual ("EF", res [1]); // Whitespace res = "A B\nC".Split ((String[])null, StringSplitOptions.None); - AssertEquals (3, res.Length); - AssertEquals ("A", res [0]); - AssertEquals ("B", res [1]); - AssertEquals ("C", res [2]); + Assert.AreEqual (3, res.Length); + Assert.AreEqual ("A", res [0]); + Assert.AreEqual ("B", res [1]); + Assert.AreEqual ("C", res [2]); res = "A B\nC".Split (new String [0], StringSplitOptions.None); - AssertEquals (3, res.Length); - AssertEquals ("A", res [0]); - AssertEquals ("B", res [1]); - AssertEquals ("C", res [2]); + Assert.AreEqual (3, res.Length); + Assert.AreEqual ("A", res [0]); + Assert.AreEqual ("B", res [1]); + Assert.AreEqual ("C", res [2]); } [Test] @@ -4170,102 +4106,102 @@ public class StringTest : TestCase // count == 0 res = "..A..B..".Split (new Char[] { '.' }, 0, StringSplitOptions.None); - AssertEquals ("#01-01", 0, res.Length); + Assert.AreEqual (0, res.Length, "#01-01"); // count == 1 res = "..A..B..".Split (new Char[] { '.' }, 1, StringSplitOptions.None); - AssertEquals ("#02-01", 1, res.Length); - AssertEquals ("#02-02", "..A..B..", res [0]); + Assert.AreEqual (1, res.Length, "#02-01"); + Assert.AreEqual ("..A..B..", res [0], "#02-02"); // count == 1 + RemoveEmpty res = "..A..B..".Split (new Char[] { '.' }, 1, StringSplitOptions.RemoveEmptyEntries); - AssertEquals ("#03-01", 1, res.Length); - AssertEquals ("#03-02", "..A..B..", res [0]); + Assert.AreEqual (1, res.Length, "#03-01"); + Assert.AreEqual ("..A..B..", res [0], "#03-02"); // Strange Case A+B A res = "...".Split (new Char[] { '.' }, 1, StringSplitOptions.RemoveEmptyEntries); - AssertEquals ("#ABA-01", 1, res.Length); - AssertEquals ("#ABA-02", "...", res [0]); + Assert.AreEqual (1, res.Length, "#ABA-01"); + Assert.AreEqual ("...", res [0], "#ABA-02"); // Strange Case A+B B res = "...".Split (new Char[] { '.' }, 2, StringSplitOptions.RemoveEmptyEntries); - AssertEquals ("#ABB-01", 0, res.Length); + Assert.AreEqual (0, res.Length, "#ABB-01"); // Keeping Empties and multipe split chars res = "..A;.B.;".Split (new Char[] { '.', ';' }, StringSplitOptions.None); - AssertEquals ("#04-01", 7, res.Length); - AssertEquals ("#04-02", string.Empty, res [0]); - AssertEquals ("#04-03", string.Empty, res [1]); - AssertEquals ("#04-04", "A", res [2]); - AssertEquals ("#04-05", string.Empty, res [3]); - AssertEquals ("#04-06", "B", res [4]); - AssertEquals ("#04-07", string.Empty, res [5]); - AssertEquals ("#04-08", string.Empty, res [6]); + Assert.AreEqual (7, res.Length, "#04-01"); + Assert.AreEqual (string.Empty, res [0], "#04-02"); + Assert.AreEqual (string.Empty, res [1], "#04-03"); + Assert.AreEqual ("A", res [2], "#04-04"); + Assert.AreEqual (string.Empty, res [3], "#04-05"); + Assert.AreEqual ("B", res [4], "#04-06"); + Assert.AreEqual (string.Empty, res [5], "#04-07"); + Assert.AreEqual (string.Empty, res [6], "#04-08"); // Trimming (3 tests) res = "..A".Split (new Char[] { '.' }, 2, StringSplitOptions.RemoveEmptyEntries); - AssertEquals ("#05-01", 1, res.Length); - AssertEquals ("#05-02", "A", res [0]); + Assert.AreEqual (1, res.Length, "#05-01"); + Assert.AreEqual ("A", res [0], "#05-02"); res = "A..".Split (new Char[] { '.' }, 2, StringSplitOptions.RemoveEmptyEntries); - AssertEquals ("#06-01", 1, res.Length); - AssertEquals ("#06-02", "A", res [0]); + Assert.AreEqual (1, res.Length, "#06-01"); + Assert.AreEqual ("A", res [0], "#06-02"); res = "..A..".Split (new Char[] { '.' }, 2, StringSplitOptions.RemoveEmptyEntries); - AssertEquals ("#07-01", 1, res.Length); - AssertEquals ("#07-02", "A", res [0]); + Assert.AreEqual (1, res.Length, "#07-01"); + Assert.AreEqual ("A", res [0], "#07-02"); // Lingering Tail res = "..A..B..".Split (new Char[] { '.' }, 2, StringSplitOptions.RemoveEmptyEntries); - AssertEquals ("#08-01", 2, res.Length); - AssertEquals ("#08-02", "A", res [0]); - AssertEquals ("#08-03", "B..", res [1]); + Assert.AreEqual (2, res.Length, "#08-01"); + Assert.AreEqual ("A", res [0], "#08-02"); + Assert.AreEqual ("B..", res [1], "#08-03"); // Whitespace and Long split chain (removing empty chars) res = " A\tBC\n\rDEF GHI ".Split ((Char[])null, StringSplitOptions.RemoveEmptyEntries); - AssertEquals ("#09-01", 4, res.Length); - AssertEquals ("#09-02", "A", res [0]); - AssertEquals ("#09-03", "BC", res [1]); - AssertEquals ("#09-04", "DEF", res [2]); - AssertEquals ("#09-05", "GHI", res [3]); + Assert.AreEqual (4, res.Length, "#09-01"); + Assert.AreEqual ("A", res [0], "#09-02"); + Assert.AreEqual ("BC", res [1], "#09-03"); + Assert.AreEqual ("DEF", res [2], "#09-04"); + Assert.AreEqual ("GHI", res [3], "#09-05"); // Nothing but separators res = "..,.;.,".Split (new Char[]{'.',',',';'},2,StringSplitOptions.RemoveEmptyEntries); - AssertEquals ("#10-01", 0, res.Length); + Assert.AreEqual (0, res.Length, "#10-01"); // Complete testseries char[] dash = new Char[] { '/' }; StringSplitOptions o = StringSplitOptions.RemoveEmptyEntries; - AssertEquals ("#11-01", "hi", "hi".Split (dash, o)[0]); - AssertEquals ("#11-02", "hi", "hi/".Split (dash, o)[0]); - AssertEquals ("#11-03", "hi", "/hi".Split (dash, o)[0]); + Assert.AreEqual ("hi", "hi".Split (dash, o)[0], "#11-01"); + Assert.AreEqual ("hi", "hi/".Split (dash, o)[0], "#11-02"); + Assert.AreEqual ("hi", "/hi".Split (dash, o)[0], "#11-03"); - AssertEquals ("#11-04-1", "hi..", "hi../".Split (dash, o)[0]); - AssertEquals ("#11-04-2", "hi..", "/hi..".Split (dash, o)[0]); + Assert.AreEqual ("hi..", "hi../".Split (dash, o)[0], "#11-04-1"); + Assert.AreEqual ("hi..", "/hi..".Split (dash, o)[0], "#11-04-2"); res = "/hi/..".Split (dash, o); - AssertEquals ("#11-05-1", "hi", res[0]); - AssertEquals ("#11-05-2", "..", res[1]); - AssertEquals ("#11-09-3", 2, res.Length); + Assert.AreEqual ("hi", res[0], "#11-05-1"); + Assert.AreEqual ("..", res[1], "#11-05-2"); + Assert.AreEqual (2, res.Length, "#11-09-3"); res = "hi/..".Split (dash, o); - AssertEquals ("#11-06-1", "hi", res[0]); - AssertEquals ("#11-06-2", "..", res[1]); - AssertEquals ("#11-09-3", 2, res.Length); + Assert.AreEqual ("hi", res[0], "#11-06-1"); + Assert.AreEqual ("..", res[1], "#11-06-2"); + Assert.AreEqual (2, res.Length, "#11-09-3"); res = "hi/../".Split (dash, o); - AssertEquals ("#11-07-1", "hi", res[0]); - AssertEquals ("#11-07-2", "..", res[1]); - AssertEquals ("#11-07-3", 2, res.Length); + Assert.AreEqual ("hi", res[0], "#11-07-1"); + Assert.AreEqual ("..", res[1], "#11-07-2"); + Assert.AreEqual (2, res.Length, "#11-07-3"); res = "/hi../".Split (dash, o); - AssertEquals ("#11-08-1", "hi..", res[0]); - AssertEquals ("#11-08-2", 1, res.Length); + Assert.AreEqual ("hi..", res[0], "#11-08-1"); + Assert.AreEqual (1, res.Length, "#11-08-2"); res = "/hi/../".Split (dash, o); - AssertEquals ("#11-09-1", "hi", res[0]); - AssertEquals ("#11-09-2", "..", res[1]); - AssertEquals ("#11-09-3", 2, res.Length); + Assert.AreEqual ("hi", res[0], "#11-09-1"); + Assert.AreEqual ("..", res[1], "#11-09-2"); + Assert.AreEqual (2, res.Length, "#11-09-3"); } [Test] @@ -4275,10 +4211,10 @@ public class StringTest : TestCase // .NET does not combine them into U+1F80 // seealso: http://demo.icu-project.org/icu-bin/nbrowser?t=\u03B1\u0313\u0345 string s = "\u03B1\u0313\u0345"; - Assert ("#1", !s.IsNormalized (NormalizationForm.FormC)); - Assert ("#2", !s.IsNormalized (NormalizationForm.FormKC)); - AssertEquals ("#3", "\u1F80", s.Normalize (NormalizationForm.FormC)); - AssertEquals ("#4", "\u1F80", s.Normalize (NormalizationForm.FormKC)); + Assert.IsTrue (!s.IsNormalized (NormalizationForm.FormC), "#1"); + Assert.IsTrue (!s.IsNormalized (NormalizationForm.FormKC), "#2"); + Assert.AreEqual ("\u1F80", s.Normalize (NormalizationForm.FormC), "#3"); + Assert.AreEqual ("\u1F80", s.Normalize (NormalizationForm.FormKC), "#4"); } [Test] @@ -4289,8 +4225,8 @@ public class StringTest : TestCase string s2 = "\u00e1bc"; // .NET does not combine \u0061\0301 into \u00E1 // seealso: http://demo.icu-project.org/icu-bin/nbrowser?t=\u0061\u0301bc - AssertEquals ("#1", s2, s1.Normalize (NormalizationForm.FormC)); - AssertEquals ("#2", s2, s1.Normalize (NormalizationForm.FormKC)); + Assert.AreEqual (s2, s1.Normalize (NormalizationForm.FormC), "#1"); + Assert.AreEqual (s2, s1.Normalize (NormalizationForm.FormKC), "#2"); } #endif } -- 2.25.1