[mono-config] use right type for result of strlen

[mono.git] / mcs / class / corlib / Test / System / ObjectTest.cs

diff --git a/mcs/class/corlib/Test/System/ObjectTest.cs b/mcs/class/corlib/Test/System/ObjectTest.cs
index ee87075f65a49c44d0991507feb0690ecdbd894f..4dd5a480fe628b5576c8017700689fec2d10057f 100644 (file)
--- a/mcs/class/corlib/Test/System/ObjectTest.cs
+++ b/mcs/class/corlib/Test/System/ObjectTest.cs
@@ -12,113 +12,111 @@ using System.Globalization;
 namespace MonoTests.System
 {
 
-public class ObjectTest : TestCase
+[TestFixture]
+public class ObjectTest
 {
        public ObjectTest() {}
 
-       protected override void SetUp() 
-       {
-       }
-
-       protected override void TearDown() 
-       {
-       }
-
+       [Test]
        public void TestCtor() {
                Object o = new Object();
-               AssertNotNull("Can I at least get an _Object_, please?", o);
+               Assert.IsNotNull(o, "Can I at least get an _Object_, please?");
        }
 
+       [Test]
        public void TestEquals1() {
                {
                        Object x = new Object();
                        Object y = new Object();
-                       Assert("Object should equal itself",
-                              x.Equals(x));
-                       Assert("object should not equal null",
-                              !x.Equals(null));
-                       Assert("Different objects should not equal 1",
-                              !x.Equals(y));
-                       Assert("Different objects should not equal 2",
-                              !y.Equals(x));
+                       Assert.IsTrue(x.Equals(x), "Object should equal itself");
+                              
+                       Assert.IsTrue(!x.Equals(null), "object should not equal null");
+                              
+                       Assert.IsTrue(!x.Equals(y), "Different objects should not equal 1");
+                              
+                       Assert.IsTrue(!y.Equals(x), "Different objects should not equal 2");
+                              
                }
                {
                        double x = Double.NaN;
                        double y = Double.NaN;
-                       Assert("NaNs should always equal each other",
-                              ((Object)x).Equals(y));
+                       Assert.IsTrue(((Object)x).Equals(y), "NaNs should always equal each other");
+                              
                }
        }
+
+       [Test]
        public void TestEquals2() {
                {
                        Object x = new Object();
                        Object y = new Object();
-                       Assert("Object should equal itself",
-                              Object.Equals(x,x));
-                       Assert("object should not equal null",
-                              !Object.Equals(x,null));
-                       Assert("null should not equal object",
-                              !Object.Equals(null,x));
-                       Assert("Different objects should not equal 1",
-                              !Object.Equals(x,y));
-                       Assert("Different objects should not equal 2",
-                              !Object.Equals(y,x));
-                       Assert("null should not equal null",
-                              Object.Equals(null,null));
+                       Assert.IsTrue(Object.Equals(x,x), "Object should equal itself");
+                              
+                       Assert.IsTrue(!Object.Equals(x,null), "object should not equal null");
+                              
+                       Assert.IsTrue(!Object.Equals(null,x), "null should not equal object");
+                              
+                       Assert.IsTrue(!Object.Equals(x,y), "Different objects should not equal 1");
+                              
+                       Assert.IsTrue(!Object.Equals(y,x), "Different objects should not equal 2");
+                              
+                       Assert.IsTrue(Object.Equals(null,null), "null should equal null");
+                              
                }
                {
                        double x = Double.NaN;
                        double y = Double.NaN;
-                       Assert("NaNs should always equal each other",
-                              Object.Equals(x,y));
+                       Assert.IsTrue(Object.Equals(x,y), "NaNs should always equal each other");
+                              
                }
        }
 
+       [Test]
        public void TestGetHashCode() {
                Object x = new Object();
-               AssertEquals("Object's hash code should not change",
-                            x.GetHashCode(), x.GetHashCode());
+               Assert.AreEqual(x.GetHashCode(), x.GetHashCode(), "Object's hash code should not change");
        }
 
+       [Test]
        public void TestGetType() {
                Object x = new Object();
-               AssertNotNull("Should get a type for Object", x.GetType());
-               AssertEquals("Bad name for Object type", "System.Object",
-                            x.GetType().ToString());
+               Assert.IsNotNull(x.GetType(), "Should get a type for Object");
+               Assert.AreEqual(x.GetType().ToString(), "System.Object", "Bad name for Object type");
+                            
        }
 
+       [Test]
        public void TestReferenceEquals() {
                Object x = new Object();
                Object y = new Object();
-               Assert("Object should equal itself",
-                      Object.ReferenceEquals(x,x));
-               Assert("object should not equal null",
-                      !Object.ReferenceEquals(x,null));
-               Assert("null should not equal object",
-                      !Object.ReferenceEquals(null,x));
-               Assert("Different objects should not equal 1",
-                      !Object.ReferenceEquals(x,y));
-               Assert("Different objects should not equal 2",
-                      !Object.ReferenceEquals(y,x));
-               Assert("null should not equal null",
-                      Object.ReferenceEquals(null,null));
+               Assert.IsTrue(Object.ReferenceEquals(x,x), "Object should equal itself");
+                      
+               Assert.IsTrue(!Object.ReferenceEquals(x,null), "object should not equal null");
+                      
+               Assert.IsTrue(!Object.ReferenceEquals(null,x), "null should not equal object");
+                      
+               Assert.IsTrue(!Object.ReferenceEquals(x,y), "Different objects should not equal 1");
+                      
+               Assert.IsTrue(!Object.ReferenceEquals(y,x), "Different objects should not equal 2");
+                      
+               Assert.IsTrue(Object.ReferenceEquals(null,null), "null should not equal null");
+                      
        }
 
+       [Test]
        public void TestToString() {
                Object x = new Object();
                Object y = new Object();
-               AssertEquals("All Objects should have same string rep",
-                            x.ToString(), y.ToString());
+               Assert.AreEqual(x.ToString(), y.ToString(), "All Objects should have same string rep");
        }
-#if NET_2_0
        class Foo<T> {}
 
+       [Test]
        public void TestToStringOnGenericInstances ()
        {
                Foo<Object> foo = new Foo<Object> ();
-               AssertEquals ("Bad ToString of generic instance",
-                       "MonoTests.System.Foo`1[System.Object]", foo.ToString ());
+               Assert.AreEqual ("MonoTests.System.ObjectTest+Foo`1[System.Object]", foo.ToString (), "Bad ToString of generic instance");
+                       
        }
-#endif
 }
 }