diff --git a/Tests/NFUnitTestConversions/UnitTestConvertTests.cs b/Tests/NFUnitTestConversions/UnitTestConvertTests.cs
index 709de6b..5cbdb05 100644
--- a/Tests/NFUnitTestConversions/UnitTestConvertTests.cs
+++ b/Tests/NFUnitTestConversions/UnitTestConvertTests.cs
@@ -96,17 +96,17 @@ public void Convert_Negative()
             string number = "-12";
             int actualNumber = -12;
             sbyte value_sb = Convert.ToSByte(number);
-            Assert.AreEqual(value_sb, (sbyte)actualNumber, "Test1");
-            Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { byte value_b = Convert.ToByte(number); }, "Test2");
+            Assert.AreEqual(value_sb, (sbyte)actualNumber);
+            Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { Convert.ToByte(number); });
             short value_s16 = Convert.ToInt16(number);
-            Assert.AreEqual(value_s16, (short)actualNumber, "Test3");
-            Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { ushort value_u16 = Convert.ToUInt16(number); }, "Test4");
+            Assert.AreEqual(value_s16, (short)actualNumber);
+            Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { Convert.ToUInt16(number); });
             int value_s32 = Convert.ToInt32(number);
-            Assert.AreEqual(value_s32, actualNumber, "Test5");
-            Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { uint value_u32 = Convert.ToUInt32(number); }, "Test6");
+            Assert.AreEqual(value_s32, actualNumber);
+            Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { Convert.ToUInt32(number); });
             long value_s64 = Convert.ToInt32(number);
-            Assert.AreEqual(value_s64, actualNumber, "Test7");
-            Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { ulong value_u64 = Convert.ToUInt64(number); }, "Test8");
+            Assert.AreEqual(value_s64, actualNumber);
+            Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { Convert.ToUInt64(number); });
         }
 
         [TestMethod]
@@ -118,8 +118,8 @@ public void Convert_Double()
             double value_dd = Convert.ToDouble(number);
             Assert.AreEqual(value_dd, actualNumber);
 
-            Assert.AreEqual(-129, Convert.ToDouble("-129"), "The value '-129' did not parse to -129");  // can't handle not having a decimal point!
-            Assert.AreEqual(-123.456, Convert.ToDouble("-123.456"), "The value -123.456 did not parse to -123.456");
+            Assert.AreEqual(-129, Convert.ToDouble("-129"));  // can't handle not having a decimal point!
+            Assert.AreEqual(-123.456, Convert.ToDouble("-123.456"));
         }
 
         [TestMethod]
diff --git a/Tests/NFUnitTestSystemLib/UnitTestDateTime.cs b/Tests/NFUnitTestSystemLib/UnitTestDateTime.cs
index 1867171..f9ede95 100644
--- a/Tests/NFUnitTestSystemLib/UnitTestDateTime.cs
+++ b/Tests/NFUnitTestSystemLib/UnitTestDateTime.cs
@@ -23,7 +23,7 @@ public void DateTime_ConstructorTest1()
             OutputHelper.WriteLine(dt.ToString());
             Type type = dt.GetType();
             // Verifying its type
-            Assert.IsType(type, Type.GetType("System.DateTime"));
+            Assert.IsInstanceOfType(type, Type.GetType("System.DateTime"));
         }
 
         [TestMethod]
@@ -49,7 +49,7 @@ public void DateTime_ConstructorTest2()
                         dt.Hour + ":" + dt.Minute + ":" + dt.Second + ":" + dt.Millisecond + "'");
                 }
                 Type t = dt.GetType();
-                Assert.IsType(t, Type.GetType("System.DateTime"));
+                Assert.IsInstanceOfType(t, Type.GetType("System.DateTime"));
             }
         }
 
@@ -301,7 +301,6 @@ public void DateTime_ToStringTest10()
                 // expected format is dddd, dd MMMM yyyy HH:mm
 
                 int minLength = 25;
-                int actualLength = dtOutput1.Length;
 
                 // check length
                 Assert.IsTrue(dtOutput1.Length >= minLength, $"Wrong output1 length: {dtOutput1.Length}, should have been at least {minLength}");
@@ -386,7 +385,6 @@ public void DateTime_ToStringTest11()
                 // expected format is dddd, dd MMMM yyyy HH:mm:ss
 
                 int minLength = 26;
-                int actualLength = dtOutput1.Length;
 
                 // check length
                 Assert.IsTrue(dtOutput1.Length >= minLength, $"Wrong output1 length: {dtOutput1.Length}, should have been at least {minLength}");
@@ -1774,10 +1772,10 @@ public void DateTime_AddTicks_PositiveTest20()
             for (int i = 0; i < dt1Arr.Length; i++)
             {
                 DateTime dt1 = dt1Arr[i];
-                long ticks = (long)random.Next(1000);
+                long ticksVAlue = random.Next(1000);
                 // Adding '" + ticks + "' ticks to '" + dt1.ToString() + "'
-                DateTime dt2 = dt1.AddTicks(ticks);
-                Assert.AreEqual(dt2.Ticks, (dt1.Ticks + ticks));
+                DateTime dt2 = dt1.AddTicks(ticksVAlue);
+                Assert.AreEqual(dt2.Ticks, (dt1.Ticks + ticksVAlue));
             }
         }
 
@@ -1795,10 +1793,10 @@ public void DateTime_AddTicks_NegativeTest21()
             for (int i = 0; i < 10; i++)
             {
                 DateTime dt1 = dt1Arr[i];
-                long ticks = -(long)random.Next(1000);
+                long ticksValue = -(long)random.Next(1000);
                 // Adding '" + ticks + "' ticks to '" + dt1.ToString() + "'
-                DateTime dt2 = dt1.AddTicks(ticks);
-                Assert.AreEqual(dt2.Ticks, (dt1.Ticks + ticks));
+                DateTime dt2 = dt1.AddTicks(ticksValue);
+                Assert.AreEqual(dt2.Ticks, (dt1.Ticks + ticksValue));
             }
         }
 
@@ -2113,7 +2111,7 @@ public void DateTime_DateTest41()
             DateTime dt = GetRandomDateTime();
             DateTime _date = dt.Date;
             if ((_date.Year != dt.Year) || (_date.Month != dt.Month) || (_date.Day != dt.Day) ||
-                (_date.Hour != 0) || (_date.Minute != 0) | (_date.Second != 0) || (_date.Millisecond != 0))
+                (_date.Hour != 0) || (_date.Minute != 0) || (_date.Second != 0) || (_date.Millisecond != 0))
             {
                 throw new Exception("Failure : expected Date(mm/dd/yr/hr/mn/sec/msec) = '" + dt.Month + "/" + dt.Day +
                     "/" + dt.Year + "/0:0:0:0' but got '" + _date.Month + "/" + _date.Day + "/" +
@@ -2272,7 +2270,7 @@ public void DateTime_BelowMinDateTime_ArgumentOutOfRangeExceptionTest58()
         {
             // Creating a DateTime with -ve Ticks and,
             // verifying ArgumentOutOfRangeException is thrown
-            Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { DateTime dt = new DateTime(-(new Random().Next(10) + 1)); });
+            Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { _ = new DateTime(-(new Random().Next(10) + 1)); });
         }
 
         [TestMethod]
@@ -2280,8 +2278,8 @@ public void DateTime_AboveMaxDatTime_ArgumentOutOfRangeExceptionTest59()
         {
             // Creating a DateTime later than DateTime.MaxValue and,
             // verifying ArgumentOutOfRangeException is thrown
-            Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { DateTime dt1 = new DateTime(DateTime.MaxValue.Ticks + 1); });
-            Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { DateTime dt2 = new DateTime(10000, 1, 1, 0, 0, 0, 0); });
+            Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { _ = new DateTime(DateTime.MaxValue.Ticks + 1); });
+            Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { _ = new DateTime(10000, 1, 1, 0, 0, 0, 0); });
         }
 
         [TestMethod]
diff --git a/Tests/NFUnitTestSystemLib/UnitTestDouble.cs b/Tests/NFUnitTestSystemLib/UnitTestDouble.cs
index de6a49c..45c0fe2 100644
--- a/Tests/NFUnitTestSystemLib/UnitTestDouble.cs
+++ b/Tests/NFUnitTestSystemLib/UnitTestDouble.cs
@@ -46,19 +46,26 @@ public void Epsilon()
         [TestMethod]
         public void NaN()
         {
+            // Identical expressions should not be used on both sides of operators
+            // on purpose to test the NaN value
+#pragma warning disable S1764 
             Assert.IsTrue(double.NaN.Equals(0.0d / 0.0d));
+            Assert.IsTrue(double.IsNaN(0.0d / 0.0d));
+#pragma warning restore S1764 // Identical expressions should not be used on both sides of operators
         }
 
         [TestMethod]
         public void NegativeInfinity()
         {
             Assert.AreEqual(-1.0 / 0.0, double.NegativeInfinity);
+            Assert.IsTrue(double.IsNegativeInfinity(-1.0 / 0.0));
         }
 
         [TestMethod]
         public void PositiveInfinity()
         {
             Assert.AreEqual(1.0 / 0.0, double.PositiveInfinity);
+            Assert.IsTrue(double.IsPositiveInfinity(1.0 / 0.0));
         }
 
         [TestMethod]
@@ -66,33 +73,84 @@ public void Equals()
         {
             DoubleTestData[] testData = new DoubleTestData[]
             {
-                new DoubleTestData((double)789, (double)789, true),
-                new DoubleTestData((double)789, (double)-789, false),
-                new DoubleTestData((double)789, (double)0, false),
-                new DoubleTestData(double.NaN, double.NaN, true),
-                new DoubleTestData(double.NaN, -double.NaN, true),
-                new DoubleTestData((double)789, (float)789, false),
-                new DoubleTestData((double)789, "789", false)
+                new DoubleTestData(
+                    (double)789,
+                    (double)789,
+                    true,
+                    "789 should be equal to 789"),
+                new DoubleTestData(
+                    (double)789,
+                    (double)-789,
+                    false,
+                    "789 should not be equal to -789"),
+                new DoubleTestData(
+                    (double)789,
+                    (double)0,
+                    false,
+                    "789 should not be equal to 0"),
+                new DoubleTestData(
+                    double.NaN,
+                    double.NaN,
+                    true,
+                    "NaN should be equal to NaN"),
+                new DoubleTestData(
+                    double.NaN,
+                    -double.NaN,
+                    true,
+                    "NaN should be equal to -NaN"),
+                new DoubleTestData(
+                    (double)789,
+                    (float)789,
+                    false,
+                    "789 should not be equal to 789f"),
+                new DoubleTestData(
+                    (double)789,
+                    "789",
+                    false,
+                    "789(double) should not be equal to '789' (string)"),
+                new DoubleTestData(
+                    (0.0d),
+                    (-0.0d),
+                    true,
+                    "0.0d should be equal to -0.0d")
+
             };
 
+            // Floating point numbers should not be tested for equality
+            // intended as this is a unit test
+#pragma warning disable S1244
+
             foreach (var test in testData)
             {
                 if (test.Value is double d2)
                 {
-                    Assert.AreEqual(test.Expected, test.D1.Equals(d2));
+                    Assert.AreEqual(
+                        test.Expected,
+                        test.D1.Equals(d2),
+                        test.AssertMessage);
 
                     if (double.IsNaN((double)test.D1) && double.IsNaN(d2))
                     {
-                        Assert.AreEqual(!test.Expected, (double)test.D1 == d2);
-                        Assert.AreEqual(test.Expected, (double)test.D1 != d2);
+                        Assert.AreEqual(
+                            !test.Expected,
+                            (double)test.D1 == d2);
+                        Assert.AreEqual(
+                            test.Expected,
+                            (double)test.D1 != d2);
                     }
                     else
                     {
-                        Assert.AreEqual(test.Expected, (double)test.D1 == d2);
-                        Assert.AreEqual(!test.Expected, (double)test.D1 != d2);
+                        Assert.AreEqual(
+                            test.Expected,
+                            (double)test.D1 == d2);
+                        Assert.AreEqual(
+                            !test.Expected,
+                            (double)test.D1 != d2);
                     }
 
-                    Assert.AreEqual(test.Expected, test.D1.GetHashCode().Equals(d2.GetHashCode()));
+                    Assert.AreEqual(
+                        test.Expected,
+                        test.D1.GetHashCode().Equals(d2.GetHashCode()));
                 }
 
                 if (test.Expected)
@@ -104,6 +162,9 @@ public void Equals()
                     Assert.IsFalse(test.D1.Equals(test.Value));
                 }
             }
+
+#pragma warning restore S1244
+
         }
 
         private sealed class DoubleTestData
@@ -111,12 +172,18 @@ private sealed class DoubleTestData
             public object D1 { get; }
             public object Value { get; }
             public bool Expected { get; }
+            public string AssertMessage { get; }
 
-            public DoubleTestData(object d1, object value, bool expected)
+            public DoubleTestData(
+                object d1,
+                object value,
+                bool expected,
+                string assertMessage = "")
             {
                 D1 = d1;
                 Value = value;
                 Expected = expected;
+                AssertMessage = assertMessage;
             }
         }
     }
diff --git a/Tests/NFUnitTestSystemLib/UnitTestReflectionMemberTest.cs b/Tests/NFUnitTestSystemLib/UnitTestReflectionMemberTest.cs
index 54b56ec..5ca1b40 100644
--- a/Tests/NFUnitTestSystemLib/UnitTestReflectionMemberTest.cs
+++ b/Tests/NFUnitTestSystemLib/UnitTestReflectionMemberTest.cs
@@ -24,9 +24,9 @@ public void SystemReflectionMemberTests_Properties_Test0()
             Assert.IsFalse(mi.IsPublic);
             Assert.IsFalse(mi.IsStatic);
             Assert.IsFalse(mi.IsVirtual);
-            Assert.IsType(mi.ReturnType, typeof(object));
+            Assert.IsInstanceOfType(mi.ReturnType, typeof(object));
             Assert.IsTrue(mi.Invoke(tst, new object[] { 3 }) == null);
-            Assert.IsType(mi.DeclaringType, typeof(AbsTestClass));
+            Assert.IsInstanceOfType(mi.DeclaringType, typeof(AbsTestClass));
 
             mi = typeof(AbsTestClass).GetMethod("AbstractPublicMethod", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
             Assert.IsTrue(mi.IsAbstract);
@@ -34,9 +34,9 @@ public void SystemReflectionMemberTests_Properties_Test0()
             Assert.IsTrue(mi.IsPublic);
             Assert.IsFalse(mi.IsStatic);
             Assert.IsTrue(mi.IsVirtual);
-            Assert.IsType(mi.ReturnType, typeof(float));
+            Assert.IsInstanceOfType(mi.ReturnType, typeof(float));
             Assert.IsTrue((float)mi.Invoke(tst, new object[] { 3 }) == 38.4f);
-            Assert.IsType(mi.DeclaringType, typeof(AbsTestClass));
+            Assert.IsInstanceOfType(mi.DeclaringType, typeof(AbsTestClass));
 
             mi = typeof(TestClass).GetMethod("VirtualInternalMethod", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
             Assert.IsFalse(mi.IsAbstract);
@@ -44,9 +44,9 @@ public void SystemReflectionMemberTests_Properties_Test0()
             Assert.IsFalse(mi.IsPublic);
             Assert.IsFalse(mi.IsStatic);
             Assert.IsTrue(mi.IsVirtual);
-            Assert.IsType(mi.ReturnType, typeof(int));
+            Assert.IsInstanceOfType(mi.ReturnType, typeof(int));
             Assert.IsTrue((int)mi.Invoke(tst, new object[] { true }) == 34);
-            Assert.IsType(mi.DeclaringType, typeof(TestClass));
+            Assert.IsInstanceOfType(mi.DeclaringType, typeof(TestClass));
 
             mi = typeof(TestClass).GetMethod("SealedPublicMethod", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
             Assert.IsFalse(mi.IsAbstract);
@@ -54,9 +54,9 @@ public void SystemReflectionMemberTests_Properties_Test0()
             Assert.IsTrue(mi.IsPublic);
             Assert.IsFalse(mi.IsStatic);
             Assert.IsTrue(mi.IsVirtual);
-            Assert.IsType(mi.ReturnType, typeof(bool));
+            Assert.IsInstanceOfType(mi.ReturnType, typeof(bool));
             Assert.IsTrue((bool)mi.Invoke(tst, new object[] { }));
-            Assert.IsType(mi.DeclaringType, typeof(TestClass));
+            Assert.IsInstanceOfType(mi.DeclaringType, typeof(TestClass));
 
             mi = typeof(TestClass).GetMethod("StaticPrivateAbsMethod", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
             Assert.IsFalse(mi.IsAbstract);
@@ -64,11 +64,11 @@ public void SystemReflectionMemberTests_Properties_Test0()
             Assert.IsFalse(mi.IsPublic);
             Assert.IsTrue(mi.IsStatic);
             Assert.IsFalse(mi.IsVirtual);
-            Assert.IsType(mi.ReturnType, typeof(void));
+            Assert.IsInstanceOfType(mi.ReturnType, typeof(void));
             TestClass.s_WasStaticMethodCalled = false;
             mi.Invoke(tst, new object[] { });
             Assert.IsTrue(TestClass.s_WasStaticMethodCalled);
-            Assert.IsType(mi.DeclaringType, typeof(AbsTestClass));
+            Assert.IsInstanceOfType(mi.DeclaringType, typeof(AbsTestClass));
 
             mi = typeof(TestClass).GetMethod("PublicMethod", BindingFlags.Instance | BindingFlags.Public);
             Assert.IsFalse(mi.IsAbstract);
@@ -76,9 +76,9 @@ public void SystemReflectionMemberTests_Properties_Test0()
             Assert.IsTrue(mi.IsPublic);
             Assert.IsFalse(mi.IsStatic);
             Assert.IsTrue(mi.IsVirtual);
-            Assert.IsType(mi.ReturnType, typeof(void));
+            Assert.IsInstanceOfType(mi.ReturnType, typeof(void));
             mi.Invoke(tst, new object[] { });
-            Assert.IsType(mi.DeclaringType, typeof(TestClass));
+            Assert.IsInstanceOfType(mi.DeclaringType, typeof(TestClass));
 
             mi = typeof(TestClass).GetMethod("InternalMethod", BindingFlags.Instance | BindingFlags.NonPublic);
             Assert.IsFalse(mi.IsAbstract);
@@ -86,9 +86,9 @@ public void SystemReflectionMemberTests_Properties_Test0()
             Assert.IsFalse(mi.IsPublic);
             Assert.IsFalse(mi.IsStatic);
             Assert.IsFalse(mi.IsVirtual);
-            Assert.IsType(mi.ReturnType, typeof(int));
+            Assert.IsInstanceOfType(mi.ReturnType, typeof(int));
             Assert.IsTrue(1 == (int)mi.Invoke(tst, new object[] { 90.3f }));
-            Assert.IsType(mi.DeclaringType, typeof(TestClass));
+            Assert.IsInstanceOfType(mi.DeclaringType, typeof(TestClass));
 
             mi = typeof(TestClass).GetMethod("PrivateMethod", BindingFlags.Instance | BindingFlags.NonPublic);
             Assert.IsFalse(mi.IsAbstract);
@@ -96,9 +96,9 @@ public void SystemReflectionMemberTests_Properties_Test0()
             Assert.IsFalse(mi.IsPublic);
             Assert.IsFalse(mi.IsStatic);
             Assert.IsFalse(mi.IsVirtual);
-            Assert.IsType(mi.ReturnType, typeof(float));
+            Assert.IsInstanceOfType(mi.ReturnType, typeof(float));
             Assert.IsTrue(3.3f == (float)mi.Invoke(tst, new object[] { 92 }));
-            Assert.IsType(mi.DeclaringType, typeof(TestClass));
+            Assert.IsInstanceOfType(mi.DeclaringType, typeof(TestClass));
         }
 
         [TestMethod]
@@ -117,9 +117,9 @@ public void SystemReflectionMemberTests_DelegateMethod_Test1()
             Assert.IsFalse(mi.IsAbstract);
             Assert.IsFalse(mi.IsFinal);
             Assert.AreEqual(mi.Name, "MyDelegateImpl");
-            Assert.IsType(mi.ReturnType, typeof(bool));
+            Assert.IsInstanceOfType(mi.ReturnType, typeof(bool));
             Assert.IsTrue((bool)mi.Invoke(null, new object[] { 1, 3.3f }));
-            Assert.IsType(mi.DeclaringType, typeof(UnitTestReflectionMemberTest));
+            Assert.IsInstanceOfType(mi.DeclaringType, typeof(UnitTestReflectionMemberTest));
         }
 
         [TestMethod]
@@ -138,7 +138,7 @@ public void SystemReflectionMemberTests_ConstructorInfo_Test2()
             ci = typeof(AbsTestClass).GetConstructor(new Type[] { typeof(float) });
             Assert.IsFalse(ci.IsPublic);
             Assert.IsFalse(ci.IsStatic);
-            Assert.IsType(ci.DeclaringType, typeof(AbsTestClass));
+            Assert.IsInstanceOfType(ci.DeclaringType, typeof(AbsTestClass));
             AbsTestClass tst = ci.Invoke(new object[] { 1.2f }) as AbsTestClass;
             Assert.IsNotNull(tst);
 
@@ -162,20 +162,20 @@ public void SystemReflectionMemberTests_FieldInfo_Test3()
 
             Type t = typeof(TestClass);
             FieldInfo fi = t.GetField("AbsPrivateField", BindingFlags.Instance | BindingFlags.NonPublic);
-            Assert.IsType(fi.FieldType, typeof(int));
-            Assert.IsType(fi.DeclaringType, typeof(AbsTestClass));
+            Assert.IsInstanceOfType(fi.FieldType, typeof(int));
+            Assert.IsInstanceOfType(fi.DeclaringType, typeof(AbsTestClass));
 
             fi = t.GetField("PublicField");
-            Assert.IsType(fi.FieldType, typeof(int));
-            Assert.IsType(fi.DeclaringType, typeof(TestClass));
+            Assert.IsInstanceOfType(fi.FieldType, typeof(int));
+            Assert.IsInstanceOfType(fi.DeclaringType, typeof(TestClass));
 
             fi = t.GetField("IntProtectedField", BindingFlags.Instance | BindingFlags.NonPublic);
-            Assert.IsType(fi.FieldType, typeof(float));
-            Assert.IsType(fi.DeclaringType, t);
+            Assert.IsInstanceOfType(fi.FieldType, typeof(float));
+            Assert.IsInstanceOfType(fi.DeclaringType, t);
 
             fi = t.GetField("BoolPrivateField", BindingFlags.Static | BindingFlags.NonPublic);
-            Assert.IsType(fi.FieldType, typeof(bool));
-            Assert.IsType(fi.DeclaringType, t);
+            Assert.IsInstanceOfType(fi.FieldType, typeof(bool));
+            Assert.IsInstanceOfType(fi.DeclaringType, t);
 
         }
 
diff --git a/Tests/NFUnitTestSystemLib/UnitTestReflectionTypeTest.cs b/Tests/NFUnitTestSystemLib/UnitTestReflectionTypeTest.cs
index ad60549..709f212 100644
--- a/Tests/NFUnitTestSystemLib/UnitTestReflectionTypeTest.cs
+++ b/Tests/NFUnitTestSystemLib/UnitTestReflectionTypeTest.cs
@@ -17,27 +17,27 @@ class UnitTestReflectionTypeTest
         public void SystemReflectionType_ObjectGetType_Test0()
         {
             object o = (object)1;
-            Assert.IsType(o.GetType(), typeof(int));
+            Assert.IsInstanceOfType(o.GetType(), typeof(int));
 
             o = (object)typeof(Type);
-            Assert.IsType(o.GetType(), typeof(Type).GetType());
+            Assert.IsInstanceOfType(o.GetType(), typeof(Type).GetType());
 
             //o = AppDomain.CurrentDomain.GetAssemblies();
             //fRes &= o.GetType() == typeof(Assembly[]);
 
             o = new TestClass();
-            Assert.IsType(o.GetType(), typeof(TestClass));
+            Assert.IsInstanceOfType(o.GetType(), typeof(TestClass));
 
             o = new TestStruct();
-            Assert.IsType(o.GetType(), typeof(TestStruct));
+            Assert.IsInstanceOfType(o.GetType(), typeof(TestStruct));
 
             o = new MyDelegate(MyDelegateImpl);
-            Assert.IsType(o.GetType(), typeof(MyDelegate));
+            Assert.IsInstanceOfType(o.GetType(), typeof(MyDelegate));
 
             o = (new MyDelegate(MyDelegateImpl)).Method;
 
             MethodInfo mi = typeof(UnitTestReflectionTypeTest).GetMethod("MyDelegateImpl", BindingFlags.Static | BindingFlags.NonPublic);
-            Assert.IsType(o.GetType(), mi.GetType());
+            Assert.IsInstanceOfType(o.GetType(), mi.GetType());
         }
 
 
@@ -60,7 +60,7 @@ public void SystemReflectionType_RuntimeType_Test1()
             Assert.AreEqual(asm.GetName().Name, "NFUnitTest");
             Assert.AreEqual(t.Name, "TestClass");
             Assert.AreEqual(t.FullName, "NFUnitTestSystemLib.UnitTestReflectionTypeTest+TestClass");
-            Assert.IsType(t.BaseType, typeof(object));
+            Assert.IsInstanceOfType(t.BaseType, typeof(object));
             Assert.IsNull(t.GetElementType());
 
             MethodInfo[] mis = t.GetMethods();
@@ -94,7 +94,7 @@ public void SystemReflectionType_RuntimeType_Test1()
             Assert.AreEqual(asm.GetName().Name, "NFUnitTest");
             Assert.AreEqual(t.Name, "TestStruct");
             Assert.AreEqual(t.FullName, "NFUnitTestSystemLib.UnitTestReflectionTypeTest+TestStruct");
-            Assert.IsType(t.BaseType, typeof(ValueType));
+            Assert.IsInstanceOfType(t.BaseType, typeof(ValueType));
             Assert.AreEqual(t.GetInterfaces().Length, 0);
             Assert.IsNull(t.GetElementType());
             i++;
@@ -108,7 +108,7 @@ public void SystemReflectionType_RuntimeType_Test1()
             //Assert.AreEqual(asm.GetName().Name, "mscorlib");
             //Assert.AreEqual(t.Name, "Assembly");
             //Assert.AreEqual(t.FullName, "System.Reflection.Assembly");
-            //Assert.IsType(t.BaseType, typeof(Object));
+            //Assert.IsInstanceOfType(t.BaseType, typeof(Object));
             //Assert.AreEqual(t.GetInterfaces().Length, 0);
             //Assert.IsNull(t.GetElementType());
 
@@ -116,7 +116,7 @@ public void SystemReflectionType_RuntimeType_Test1()
             t = mis.GetType();
             Assert.AreEqual(t.Name, "RuntimeMethodInfo[]");
             Assert.AreEqual(t.FullName, "System.Reflection.RuntimeMethodInfo[]");
-            Assert.IsType(t.BaseType, typeof(Array));
+            Assert.IsInstanceOfType(t.BaseType, typeof(Array));
             Assert.IsTrue(t.GetInterfaces().Length > 0);
             Assert.AreEqual(t.GetElementType().Name, "RuntimeMethodInfo");
 
@@ -125,12 +125,12 @@ public void SystemReflectionType_RuntimeType_Test1()
             t = del.GetType();
             Assert.IsNotNull(t.DeclaringType);
             Assert.AreEqual(t.Name, "MyDelegate");
-            Assert.IsType(t.BaseType, typeof(MulticastDelegate));
+            Assert.IsInstanceOfType(t.BaseType, typeof(MulticastDelegate));
 
             // test Type members for an enum
             TestEnum en = TestEnum.Item1;
             t = en.GetType();
-            Assert.IsType(t.DeclaringType, typeof(UnitTestReflectionTypeTest));
+            Assert.IsInstanceOfType(t.DeclaringType, typeof(UnitTestReflectionTypeTest));
             Assert.IsTrue(t.IsEnum);
             Assert.IsFalse(t.IsAbstract);
             Assert.IsFalse(t.IsClass);
diff --git a/Tests/NFUnitTestSystemLib/UnitTestSingle.cs b/Tests/NFUnitTestSystemLib/UnitTestSingle.cs
index 6d9eea6..5b09009 100644
--- a/Tests/NFUnitTestSystemLib/UnitTestSingle.cs
+++ b/Tests/NFUnitTestSystemLib/UnitTestSingle.cs
@@ -43,35 +43,111 @@ public void Epsilon()
             Assert.AreEqual((float)1.4e-45, float.Epsilon);
         }
 
+        [TestMethod]
+        public void NaN()
+        {
+            // Identical expressions should not be used on both sides of operators
+            // on purpose to test the NaN value
+#pragma warning disable S1764 
+            Assert.IsTrue(float.NaN.Equals(0.0f / 0.0f));
+            Assert.IsTrue(float.IsNaN(0.0f / 0.0f));
+#pragma warning restore S1764 // Identical expressions should not be used on both sides of operators
+        }
+
+        [TestMethod]
+        public void NegativeInfinity()
+        {
+            Assert.AreEqual(-1.0f / 0.0f, float.NegativeInfinity);
+            Assert.IsTrue(float.IsNegativeInfinity(-1.0f / 0.0f));
+        }
+
+        [TestMethod]
+        public void PositiveInfinity()
+        {
+            Assert.AreEqual(1.0f / 0.0f, float.PositiveInfinity);
+            Assert.IsTrue(float.IsPositiveInfinity(1.0f / 0.0f));
+        }
+
         [TestMethod]
         public void Equals()
         {
             SingleTestData[] testData = new SingleTestData[]
             {
-                new SingleTestData((float)789, (float)789, true),
-                new SingleTestData((float)789, (float)-789, false),
-                new SingleTestData((float)789, (float)0, false),
-                new SingleTestData((float)float.NaN, float.NaN, true),
-                new SingleTestData((float)float.NaN, -float.NaN, true),
-                new SingleTestData((float)789, (double)789, false),
-                new SingleTestData((float)789, "789", false),
+                new SingleTestData(
+                    (float)789,
+                    (float)789,
+                    true,
+                    "789 should be equal to 789"),
+                new SingleTestData(
+                    (float)789,
+                    (float)-789,
+                    false,
+                    "789 should not be equal to -789"),
+                new SingleTestData(
+                    (float)789,
+                    (float)0,
+                    false,
+                    "789 should not be equal to 0"),
+                new SingleTestData(
+                    float.NaN,
+                    float.NaN,
+                    true,
+                    "NaN should be equal to NaN"),
+                new SingleTestData(
+                    float.NaN,
+                    -float.NaN,
+                    true,
+                    "NaN should be equal to -NaN"),
+                new SingleTestData(
+                    (float)789,
+                    (double)789,
+                    false,
+                    "789(float) should not be equal to 789(double)"),
+                new SingleTestData(
+                    (float)789,
+                    "789",
+                    false,
+                    "789(float) should not be equal to '789' (string)"),
+                new SingleTestData(
+                    (0.0F),
+                    (-0.0F),
+                    true,
+                    "0.0F should be equal to -0.0F")
             };
 
+            // Floating point numbers should not be tested for equality
+            // intended as this is a unit test
+#pragma warning disable S1244
+
+
             foreach (var test in testData)
             {
                 if (test.Value is float f2)
                 {
-                    Assert.AreEqual(test.Expected, test.F1.Equals(f2));
+                    Assert.AreEqual(
+                        test.Expected,
+                        test.F1.Equals(f2),
+                        test.AssertMessage);
 
                     if (float.IsNaN((float)test.F1) && float.IsNaN(f2))
                     {
-                        Assert.AreEqual(!test.Expected, (float)test.F1 == f2);
-                        Assert.AreEqual(test.Expected, (float)test.F1 != f2);
+                        Assert.AreEqual(
+                            !test.Expected,
+                            (float)test.F1 == f2);
+
+                        Assert.AreEqual(
+                            test.Expected,
+                            (float)test.F1 != f2);
                     }
                     else
                     {
-                        Assert.AreEqual(test.Expected, (float)test.F1 == f2);
-                        Assert.AreEqual(!test.Expected, (float)test.F1 != f2);
+                        Assert.AreEqual(
+                            test.Expected,
+                            (float)test.F1 == f2);
+
+                        Assert.AreEqual(
+                            !test.Expected,
+                            (float)test.F1 != f2);
                     }
 
                     Assert.AreEqual(test.Expected, test.F1.GetHashCode().Equals(f2.GetHashCode()));
@@ -79,6 +155,9 @@ public void Equals()
 
                 Assert.AreEqual(test.Expected, test.F1.Equals(test.Value));
             }
+
+#pragma warning restore S1244
+
         }
 
         private sealed class SingleTestData
@@ -86,12 +165,18 @@ private sealed class SingleTestData
             public object F1 { get; }
             public object Value { get; }
             public bool Expected { get; }
+            public string AssertMessage { get; }
 
-            public SingleTestData(object f1, object value, bool expected)
+            public SingleTestData(
+                object f1,
+                object value,
+                bool expected,
+                string assertMessage = "")
             {
                 F1 = f1;
                 Value = value;
                 Expected = expected;
+                AssertMessage = assertMessage;
             }
         }
     }
diff --git a/Tests/NFUnitTestSystemLib/UnitTestTimeSpan.cs b/Tests/NFUnitTestSystemLib/UnitTestTimeSpan.cs
index 99472af..25282eb 100644
--- a/Tests/NFUnitTestSystemLib/UnitTestTimeSpan.cs
+++ b/Tests/NFUnitTestSystemLib/UnitTestTimeSpan.cs
@@ -145,12 +145,22 @@ public void CtorHelper(int[] vals)
             Int64 i64 = 0;
 
             string str = "";
+
             if (vals.Length == 3)
+            {
                 str = "0 : ";
+            }
+
             for (int i = 0; i < vals.Length; i++)
+            {
                 str += vals[i].ToString() + " : ";
+            }
+
             for (int i = vals.Length; i < 5; i++)
+            {
                 str += "0 : ";
+            }
+
             OutputHelper.WriteLine(str);
 
             switch (vals.Length)
@@ -380,7 +390,6 @@ public void ToString_Test7()
             Random random = new Random();
             for (int i = 0; i < 5; i++)
             {
-                bool b = true;
                 int hours = random.Next(23);
                 int minutes = random.Next(59);
                 int seconds = random.Next(59);
diff --git a/Tests/NFUnitTestSystemLib/UnitTestTypeTests.cs b/Tests/NFUnitTestSystemLib/UnitTestTypeTests.cs
index 90f09b2..cfefc29 100644
--- a/Tests/NFUnitTestSystemLib/UnitTestTypeTests.cs
+++ b/Tests/NFUnitTestSystemLib/UnitTestTypeTests.cs
@@ -190,30 +190,30 @@ public void SystemType1_GetTypeNew_Test()
             // This tests the Assembly.GetType(String) by passing \"Namespace.Class\"
             Type myType0 = Int32Assm.GetType("System.Int32");
             OutputHelper.WriteLine("The full name is " + myType0.FullName);
-            Assert.IsType(myType0, testInt32.GetType());
+            Assert.IsInstanceOfType(myType0, testInt32.GetType());
 
             // This tests the Type.GetType(String) by passing \"Namespace.Class\"
             Type myType1 = Type.GetType("System.Int32");
             OutputHelper.WriteLine("The full name is " + myType1.FullName);
-            Assert.IsType(myType1, testInt32.GetType());
+            Assert.IsInstanceOfType(myType1, testInt32.GetType());
 
             // This tests the Type.GetType(String) by passing \"Namespace.Class, assembly\"
             Type myType2 = Type.GetType("System.Int32, mscorlib");
             OutputHelper.WriteLine("The full name is " + myType2.FullName);
-            Assert.IsType(myType2, testInt32.GetType());
+            Assert.IsInstanceOfType(myType2, testInt32.GetType());
 
             // This tests the Type.GetType(String) by passing \"Namespace.Class, assembly, Version=\"a.b.c.d\"\"
             string typeName3 = "System.Int32, mscorlib, Version=" + Int32Assm.GetName().Version.ToString();
             Type myType3 = Type.GetType(typeName3);
             OutputHelper.WriteLine("The full name is " + myType3.FullName);
-            Assert.IsType(myType3, testInt32.GetType());
+            Assert.IsInstanceOfType(myType3, testInt32.GetType());
 
 
             // This tests the Type.GetType() method for nested classes
             TestObject1 testTestObject1 = new TestObject1();
             Type myType4 = testTestObject1.GetType();
             OutputHelper.WriteLine("The full name is " + myType4.FullName);
-            Assert.IsType(myType4, Type.GetType("NFUnitTestSystemLib.UnitTestTypeTests+TestObject1"));
+            Assert.IsInstanceOfType(myType4, Type.GetType("NFUnitTestSystemLib.UnitTestTypeTests+TestObject1"));
 
 
             // Since NoneSuch does not exist in this assembly, 
@@ -234,7 +234,7 @@ public void SystemType1_Type_Names_Test()
             Type myType0 = Int32Assm.GetType("System.Int32");
             Type myType1 = Type.GetType("System.Int32");
 
-            Assert.IsType(myType0, myType1);
+            Assert.IsInstanceOfType(myType0, myType1);
 
             // names must be compatible and composable
             Assert.AreEqual(myType0.Name, myType1.Name);
@@ -283,12 +283,12 @@ public void SystemType3_BaseType_Test()
             testInt32++;
             Type myType1 = Type.GetType("System.Int32");
             OutputHelper.WriteLine("The full name is " + myType1.FullName);
-            Assert.IsType(myType1.BaseType, Type.GetType("System.ValueType"));
+            Assert.IsInstanceOfType(myType1.BaseType, Type.GetType("System.ValueType"));
 
             TestObject1 testTestObject1 = new TestObject1();
             Type myType2 = testTestObject1.GetType();
             OutputHelper.WriteLine("The full name is " + myType2.FullName);
-            Assert.IsType(myType2.BaseType, Type.GetType("System.Object"));
+            Assert.IsInstanceOfType(myType2.BaseType, Type.GetType("System.Object"));
         }
 
         [TestMethod]
@@ -309,7 +309,7 @@ public void SystemType4_DeclaringType_Test()
             //Type myType2 = testTestObject1.GetType();
             //OutputHelper.WriteLine("The full name is " + myType2.FullName);
             //Type myType3 = this.GetType();
-            //Assert.IsType(myType2.DeclaringType , myType3);
+            //Assert.IsInstanceOfType(myType2.DeclaringType , myType3);
         }
 
         [TestMethod]
@@ -339,7 +339,7 @@ public void SystemType6_GetElementType_Test()
             OutputHelper.WriteLine("The full name is " + myType1.FullName);
             int[] int32Arr = new int[] { };
             Type int32ArrType = int32Arr.GetType();
-            Assert.IsType(myType1, int32ArrType.GetElementType());
+            Assert.IsInstanceOfType(myType1, int32ArrType.GetElementType());
 
             Assert.IsTrue(myType1.GetElementType() == null);
         }
@@ -361,7 +361,7 @@ public void SystemType7_GetField_Test()
             OutputHelper.WriteLine("The full name is " + myType2.FullName);
 
             //  Check that type of m_data is Int32
-            Assert.IsType(myType2.GetField("m_data", BindingFlags.GetField |
+            Assert.IsInstanceOfType(myType2.GetField("m_data", BindingFlags.GetField |
                 BindingFlags.Public | BindingFlags.Instance).FieldType, myType1);
 
             //  Check that value in m_data is 5 ( becuase we called new TestObject2(5))
@@ -408,7 +408,7 @@ public void SystemType8_GetFields_Test()
             TestObject2 testTestObject2 = new TestObject2(5);
             Type myType2 = testTestObject2.GetType();
             OutputHelper.WriteLine("The full name is " + myType2.FullName);
-            Assert.IsType(myType2.GetField("m_data").FieldType, myType1);
+            Assert.IsInstanceOfType(myType2.GetField("m_data").FieldType, myType1);
             Assert.AreEqual((int)myType2.GetField("m_data").GetValue(testTestObject2), 5);
             Assert.IsTrue(myType2.GetField("m_data").MemberType == MemberTypes.Field);
             Assert.AreEqual(myType2.GetField("m_data").Name, "m_data");
@@ -431,7 +431,7 @@ public void SystemType9_GetInterfaces_Test()
             OutputHelper.WriteLine("The full name is " + myType2.FullName);
             Type myType3 =
                 Type.GetType("NFUnitTestSystemLib.UnitTestTypeTests+iEmpty");
-            Assert.IsType(myType2.GetInterfaces()[0], myType3);
+            Assert.IsInstanceOfType(myType2.GetInterfaces()[0], myType3);
         }
 
         [TestMethod]
@@ -454,8 +454,8 @@ public void SystemType10_GetMethod_Test()
             Assert.AreEqual(methodInfo1.IsVirtual, false);
             Assert.IsTrue(methodInfo1.MemberType == MemberTypes.Method);
             Assert.AreEqual(methodInfo1.Name, "Method2");
-            Assert.IsType(methodInfo1.ReturnType, I.GetType());
-            Assert.IsType(methodInfo1.DeclaringType, myType2);
+            Assert.IsInstanceOfType(methodInfo1.ReturnType, I.GetType());
+            Assert.IsInstanceOfType(methodInfo1.DeclaringType, myType2);
             Assert.AreEqual((int)(methodInfo1.Invoke(testTestObject2, new object[] { 1 })), 1);
         }
 
@@ -492,8 +492,8 @@ public void SystemType11_GetMethods_Test()
             Assert.AreEqual(methodInfo1.IsVirtual, false);
             Assert.IsTrue(methodInfo1.MemberType == MemberTypes.Method);
             Assert.AreEqual(methodInfo1.Name, "Method2");
-            Assert.IsType(methodInfo1.ReturnType, I.GetType());
-            Assert.IsType(methodInfo1.DeclaringType, myType2);
+            Assert.IsInstanceOfType(methodInfo1.ReturnType, I.GetType());
+            Assert.IsInstanceOfType(methodInfo1.DeclaringType, myType2);
             Assert.AreEqual((int)(methodInfo1.Invoke(testTestObject2, new object[] { 1 })), 1);
         }
 
diff --git a/Tests/NFUnitTestTypes/UnitTestObjectTypeTests.cs b/Tests/NFUnitTestTypes/UnitTestObjectTypeTests.cs
index b4e464f..a8dfcdd 100644
--- a/Tests/NFUnitTestTypes/UnitTestObjectTypeTests.cs
+++ b/Tests/NFUnitTestTypes/UnitTestObjectTypeTests.cs
@@ -14,7 +14,9 @@ public void TestCtor()
             // Test of Object constructor
 
             object o = new();
+#pragma warning disable S3236 // Caller information arguments should not be provided explicitly
             Assert.IsNotNull(o, "failed to create an Object");
+#pragma warning restore S3236 // Caller information arguments should not be provided explicitly
         }
 
         [TestMethod]
@@ -25,6 +27,11 @@ public void TestEquals_01()
             object objectX = new();
             object objectY = new();
 
+            // Caller information arguments should not be provided explicitly
+            // Identical expressions should not be used on both sides of operators
+            // on purpose to test the Equals overload
+#pragma warning disable S3236 
+#pragma warning disable S1764 
             Assert.IsTrue(objectX.Equals(objectX), "Object should equal itself");
             Assert.IsTrue(!objectX.Equals(null), "object should not equal null");
             Assert.IsTrue(!objectX.Equals(objectY), "Different objects should not equal 1");
@@ -33,6 +40,8 @@ public void TestEquals_01()
             double doubleX = double.NaN;
             double doubleY = double.NaN;
             Assert.IsTrue(((object)doubleX).Equals(doubleY), "NaNs should always equal each other");
+#pragma warning restore S1764 // Identical expressions should not be used on both sides of operators
+#pragma warning restore S3236 // Caller information arguments should not be provided explicitly
         }
 
         [TestMethod]
@@ -43,17 +52,26 @@ public void TestEquals_02()
             object objectX = new();
             object objectY = new();
 
+            // Caller information arguments should not be provided explicitly
+            // Identical expressions should not be used on both sides of operators
+            // on purpose to test the Equals overload
+#pragma warning disable S3236 
+#pragma warning disable S1764 
             Assert.IsTrue(Equals(objectX, objectX), "Object should equal itself");
             Assert.IsTrue(!Equals(objectX, null), "object should not equal null");
             Assert.IsTrue(!Equals(null, objectX), "null should not equal object");
             Assert.IsTrue(!Equals(objectX, objectY), "Different objects should not equal 1");
             Assert.IsTrue(!Equals(objectY, objectX), "Different objects should not equal 2");
             Assert.IsTrue(Equals(null, null), "null should equal null");
+#pragma warning restore S1764 // Identical expressions should not be used on both sides of operators
+#pragma warning restore S3236 // Caller information arguments should not be provided explicitly
 
 
             double doubleX = double.NaN;
             double doubleY = double.NaN;
+#pragma warning disable S3236 // Caller information arguments should not be provided explicitly
             Assert.IsTrue(Equals(doubleX, doubleY), "NaNs should always equal each other");
+#pragma warning restore S3236 // Caller information arguments should not be provided explicitly
         }
 
         [TestMethod]
@@ -62,7 +80,9 @@ public void TestGetHashCode()
             // Test Object HashCode
 
             object objectX = new();
+#pragma warning disable S3236 // Caller information arguments should not be provided explicitly
             Assert.AreEqual(objectX.GetHashCode(), objectX.GetHashCode(), "Object's hash code should not change");
+#pragma warning restore S3236 // Caller information arguments should not be provided explicitly
         }
 
         [TestMethod]
@@ -72,8 +92,12 @@ public void TestGetType()
 
             object objectX = new();
 
+#pragma warning disable S3236 // Caller information arguments should not be provided explicitly
             Assert.IsNotNull(objectX.GetType(), "Should get a type for Object");
+#pragma warning restore S3236 // Caller information arguments should not be provided explicitly
+#pragma warning disable S3236 // Caller information arguments should not be provided explicitly
             Assert.AreEqual(objectX.GetType().ToString(), "System.Object", "Wrong ToString from Object type");
+#pragma warning restore S3236 // Caller information arguments should not be provided explicitly
         }
 
         [TestMethod]
@@ -84,12 +108,16 @@ public void TestReferenceEquals()
             object objectX = new();
             object objectY = new();
 
+            // Caller information arguments should not be provided explicitly
+            // on purpose to test the ReferenceEquals overload
+#pragma warning disable S3236 
             Assert.IsTrue(ReferenceEquals(objectX, objectX), "Object should equal itself");
             Assert.IsTrue(!ReferenceEquals(objectX, null), "object should not equal null");
             Assert.IsTrue(!ReferenceEquals(null, objectX), "null should not equal object");
             Assert.IsTrue(!ReferenceEquals(objectX, objectY), "Different objects should not equal 1");
             Assert.IsTrue(!ReferenceEquals(objectY, objectX), "Different objects should not equal 2");
             Assert.IsTrue(ReferenceEquals(null, null), "null should not equal null");
+#pragma warning restore S3236 // Caller information arguments should not be provided explicitly
         }
 
         [TestMethod]
@@ -100,7 +128,9 @@ public void TestToString()
             object objectX = new();
             object objectY = new();
 
+#pragma warning disable S3236 // Caller information arguments should not be provided explicitly
             Assert.AreEqual(objectX.ToString(), objectY.ToString(), "All Objects should have same string representation");
+#pragma warning restore S3236 // Caller information arguments should not be provided explicitly
         }
     }
 }
diff --git a/Tests/NFUnitTestTypes/UnitTestValueArrayTypess.cs b/Tests/NFUnitTestTypes/UnitTestValueArrayTypess.cs
index f1d16d2..39ee499 100644
--- a/Tests/NFUnitTestTypes/UnitTestValueArrayTypess.cs
+++ b/Tests/NFUnitTestTypes/UnitTestValueArrayTypess.cs
@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
@@ -112,7 +112,7 @@ public static void testMethod()
             {
                 byte[] b = { 0 };
                 Type compareType = Type.GetType("System.Byte[]");
-                Assert.IsType(compareType, b, $"The type {compareType.Name} is not equal to {b.GetType().Name}");
+                Assert.IsInstanceOfType(b, compareType, $"The type {compareType.Name} is not equal to {b.GetType().Name}");
             }
         }
         public class ValueArrayTestClass02
@@ -120,7 +120,7 @@ public class ValueArrayTestClass02
             public static void testMethod()
             {
                 char[] c = { 'a' };
-                Assert.IsType(Type.GetType("System.Char[]"), c);
+                Assert.IsInstanceOfType(c, Type.GetType("System.Char[]"));
             }
         }
         public class ValueArrayTestClass03
@@ -128,7 +128,7 @@ public class ValueArrayTestClass03
             public static void testMethod()
             {
                 short[] s = { 0 };
-                Assert.IsType(Type.GetType("System.Int16[]"), s);
+                Assert.IsInstanceOfType(s, Type.GetType("System.Int16[]"));
             }
         }
         public class ValueArrayTestClass04
@@ -136,7 +136,7 @@ public class ValueArrayTestClass04
             public static void testMethod()
             {
                 int[] i = { 0 };
-                Assert.IsType(Type.GetType("System.Int32[]"), i);
+                Assert.IsInstanceOfType(i, Type.GetType("System.Int32[]"));
             }
         }
         public class ValueArrayTestClass05
@@ -144,7 +144,7 @@ public class ValueArrayTestClass05
             public static void testMethod()
             {
                 long[] l = { 0L };
-                Assert.IsType(Type.GetType("System.Int64[]"), l);
+                Assert.IsInstanceOfType(l, Type.GetType("System.Int64[]"));
             }
         }
         public class ValueArrayTestClass06
@@ -152,7 +152,7 @@ public class ValueArrayTestClass06
             public static void testMethod()
             {
                 float[] f = { 0.0f };
-                Assert.IsType(Type.GetType("System.Single[]"), f);
+                Assert.IsInstanceOfType(f, Type.GetType("System.Single[]"));
             }
         }
         public class ValueArrayTestClass07
@@ -160,7 +160,7 @@ public class ValueArrayTestClass07
             public static void testMethod()
             {
                 double[] d = { 0.0d };
-                Assert.IsType(Type.GetType("System.Double[]"), d);
+                Assert.IsInstanceOfType(d, Type.GetType("System.Double[]"));
             }
         }
         public class ValueArrayTestClass09
@@ -168,7 +168,7 @@ public class ValueArrayTestClass09
             public static void testMethod()
             {
                 bool[] b = { true };
-                Assert.IsType(Type.GetType("System.Boolean[]"), b);
+                Assert.IsInstanceOfType(b, Type.GetType("System.Boolean[]"));
             }
         }
 
@@ -177,7 +177,7 @@ public class ValueArrayTestClass12
             public static void testMethod()
             {
                 string[] strArray = { "string" };
-                Assert.IsType(Type.GetType("System.String[]"), strArray);
+                Assert.IsInstanceOfType(strArray, Type.GetType("System.String[]"));
             }
         }
         public class ValueArrayTestClass13
@@ -185,7 +185,7 @@ public class ValueArrayTestClass13
             public static void testMethod()
             {
                 sbyte[] sb = { 0 };
-                Assert.IsType(Type.GetType("System.SByte[]"), sb);
+                Assert.IsInstanceOfType(sb, Type.GetType("System.SByte[]"));
             }
         }
         public class ValueArrayTestClass14
@@ -193,7 +193,7 @@ public class ValueArrayTestClass14
             public static void testMethod()
             {
                 ushort[] us = { 0 };
-                Assert.IsType(Type.GetType("System.UInt16[]"), us);
+                Assert.IsInstanceOfType(us, Type.GetType("System.UInt16[]"));
             }
         }
         public class ValueArrayTestClass15
@@ -201,8 +201,9 @@ public class ValueArrayTestClass15
             public static void testMethod()
             {
                 uint[] ui = { 0 };
-                Assert.IsType(Type.GetType("System.UInt32[]"), ui);
+                Assert.IsInstanceOfType(ui, Type.GetType("System.UInt32[]"));
             }
         }
+
     }
 }
diff --git a/Tests/NFUnitTestTypes/UnitTestValueFloatTests.cs b/Tests/NFUnitTestTypes/UnitTestValueFloatTests.cs
index 5c9cdd9..4e5e721 100644
--- a/Tests/NFUnitTestTypes/UnitTestValueFloatTests.cs
+++ b/Tests/NFUnitTestTypes/UnitTestValueFloatTests.cs
@@ -211,16 +211,16 @@ public static void testMethod()
                 long l1 = 5L;
                 char c1 = (char)6;
 
-                Assert.IsType((f1 + s1).GetType(), f1.GetType());
-                Assert.IsType((s1 + f1).GetType(), f1.GetType());
-                Assert.IsType((f1 + b1).GetType(), f1.GetType());
-                Assert.IsType((b1 + f1).GetType(), f1.GetType());
-                Assert.IsType((f1 + i1).GetType(), f1.GetType());
-                Assert.IsType((i1 + f1).GetType(), f1.GetType());
-                Assert.IsType((f1 + l1).GetType(), f1.GetType());
-                Assert.IsType((l1 + f1).GetType(), f1.GetType());
-                Assert.IsType((f1 + c1).GetType(), f1.GetType());
-                Assert.IsType((c1 + f1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((f1 + s1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((s1 + f1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((f1 + b1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((b1 + f1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((f1 + i1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((i1 + f1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((f1 + l1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((l1 + f1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((f1 + c1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((c1 + f1).GetType(), f1.GetType());
             }
         }
         public class ValueFloatTestClass05
@@ -234,16 +234,16 @@ public static void testMethod()
                 long l1 = 5L;
                 char c1 = (char)6;
 
-                Assert.IsType((d1 + s1).GetType(), d1.GetType());
-                Assert.IsType((s1 + d1).GetType(), d1.GetType());
-                Assert.IsType((d1 + b1).GetType(), d1.GetType());
-                Assert.IsType((b1 + d1).GetType(), d1.GetType());
-                Assert.IsType((d1 + i1).GetType(), d1.GetType());
-                Assert.IsType((i1 + d1).GetType(), d1.GetType());
-                Assert.IsType((d1 + l1).GetType(), d1.GetType());
-                Assert.IsType((l1 + d1).GetType(), d1.GetType());
-                Assert.IsType((d1 + c1).GetType(), d1.GetType());
-                Assert.IsType((c1 + d1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((d1 + s1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((s1 + d1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((d1 + b1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((b1 + d1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((d1 + i1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((i1 + d1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((d1 + l1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((l1 + d1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((d1 + c1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((c1 + d1).GetType(), d1.GetType());
             }
         }
         public class ValueFloatTestClass06
@@ -257,16 +257,16 @@ public static void testMethod()
                 long l1 = 5L;
                 char c1 = (char)6;
 
-                Assert.IsType((f1 - s1).GetType(), f1.GetType());
-                Assert.IsType((s1 - f1).GetType(), f1.GetType());
-                Assert.IsType((f1 - b1).GetType(), f1.GetType());
-                Assert.IsType((b1 - f1).GetType(), f1.GetType());
-                Assert.IsType((f1 - i1).GetType(), f1.GetType());
-                Assert.IsType((i1 - f1).GetType(), f1.GetType());
-                Assert.IsType((f1 - l1).GetType(), f1.GetType());
-                Assert.IsType((l1 - f1).GetType(), f1.GetType());
-                Assert.IsType((f1 - c1).GetType(), f1.GetType());
-                Assert.IsType((c1 - f1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((f1 - s1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((s1 - f1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((f1 - b1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((b1 - f1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((f1 - i1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((i1 - f1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((f1 - l1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((l1 - f1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((f1 - c1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((c1 - f1).GetType(), f1.GetType());
             }
         }
         public class ValueFloatTestClass07
@@ -280,16 +280,16 @@ public static void testMethod()
                 long l1 = 5L;
                 char c1 = (char)6;
 
-                Assert.IsType((d1 - s1).GetType(), d1.GetType());
-                Assert.IsType((s1 - d1).GetType(), d1.GetType());
-                Assert.IsType((d1 - b1).GetType(), d1.GetType());
-                Assert.IsType((b1 - d1).GetType(), d1.GetType());
-                Assert.IsType((d1 - i1).GetType(), d1.GetType());
-                Assert.IsType((i1 - d1).GetType(), d1.GetType());
-                Assert.IsType((d1 - l1).GetType(), d1.GetType());
-                Assert.IsType((l1 - d1).GetType(), d1.GetType());
-                Assert.IsType((d1 - c1).GetType(), d1.GetType());
-                Assert.IsType((c1 - d1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((d1 - s1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((s1 - d1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((d1 - b1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((b1 - d1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((d1 - i1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((i1 - d1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((d1 - l1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((l1 - d1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((d1 - c1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((c1 - d1).GetType(), d1.GetType());
             }
         }
         public class ValueFloatTestClass08
@@ -303,16 +303,16 @@ public static void testMethod()
                 long l1 = 5L;
                 char c1 = (char)6;
 
-                Assert.IsType((f1 * s1).GetType(), f1.GetType());
-                Assert.IsType((s1 * f1).GetType(), f1.GetType());
-                Assert.IsType((f1 * b1).GetType(), f1.GetType());
-                Assert.IsType((b1 * f1).GetType(), f1.GetType());
-                Assert.IsType((f1 * i1).GetType(), f1.GetType());
-                Assert.IsType((i1 * f1).GetType(), f1.GetType());
-                Assert.IsType((f1 * l1).GetType(), f1.GetType());
-                Assert.IsType((l1 * f1).GetType(), f1.GetType());
-                Assert.IsType((f1 * c1).GetType(), f1.GetType());
-                Assert.IsType((c1 * f1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((f1 * s1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((s1 * f1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((f1 * b1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((b1 * f1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((f1 * i1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((i1 * f1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((f1 * l1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((l1 * f1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((f1 * c1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((c1 * f1).GetType(), f1.GetType());
             }
         }
         public class ValueFloatTestClass09
@@ -326,16 +326,16 @@ public static void testMethod()
                 long l1 = 5L;
                 char c1 = (char)6;
 
-                Assert.IsType((d1 * s1).GetType(), d1.GetType());
-                Assert.IsType((s1 * d1).GetType(), d1.GetType());
-                Assert.IsType((d1 * b1).GetType(), d1.GetType());
-                Assert.IsType((b1 * d1).GetType(), d1.GetType());
-                Assert.IsType((d1 * i1).GetType(), d1.GetType());
-                Assert.IsType((i1 * d1).GetType(), d1.GetType());
-                Assert.IsType((d1 * l1).GetType(), d1.GetType());
-                Assert.IsType((l1 * d1).GetType(), d1.GetType());
-                Assert.IsType((d1 * c1).GetType(), d1.GetType());
-                Assert.IsType((c1 * d1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((d1 * s1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((s1 * d1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((d1 * b1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((b1 * d1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((d1 * i1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((i1 * d1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((d1 * l1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((l1 * d1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((d1 * c1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((c1 * d1).GetType(), d1.GetType());
             }
         }
         public class ValueFloatTestClass10
@@ -349,16 +349,16 @@ public static void testMethod()
                 long l1 = 5L;
                 char c1 = (char)6;
 
-                Assert.IsType((f1 / s1).GetType(), f1.GetType());
-                Assert.IsType((s1 / f1).GetType(), f1.GetType());
-                Assert.IsType((f1 / b1).GetType(), f1.GetType());
-                Assert.IsType((b1 / f1).GetType(), f1.GetType());
-                Assert.IsType((f1 / i1).GetType(), f1.GetType());
-                Assert.IsType((i1 / f1).GetType(), f1.GetType());
-                Assert.IsType((f1 / l1).GetType(), f1.GetType());
-                Assert.IsType((l1 / f1).GetType(), f1.GetType());
-                Assert.IsType((f1 / c1).GetType(), f1.GetType());
-                Assert.IsType((c1 / f1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((f1 / s1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((s1 / f1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((f1 / b1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((b1 / f1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((f1 / i1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((i1 / f1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((f1 / l1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((l1 / f1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((f1 / c1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((c1 / f1).GetType(), f1.GetType());
             }
         }
         public class ValueFloatTestClass11
@@ -372,16 +372,16 @@ public static void testMethod()
                 long l1 = 5L;
                 char c1 = (char)6;
 
-                Assert.IsType((d1 / s1).GetType(), d1.GetType());
-                Assert.IsType((s1 / d1).GetType(), d1.GetType());
-                Assert.IsType((d1 / b1).GetType(), d1.GetType());
-                Assert.IsType((b1 / d1).GetType(), d1.GetType());
-                Assert.IsType((d1 / i1).GetType(), d1.GetType());
-                Assert.IsType((i1 / d1).GetType(), d1.GetType());
-                Assert.IsType((d1 / l1).GetType(), d1.GetType());
-                Assert.IsType((l1 / d1).GetType(), d1.GetType());
-                Assert.IsType((d1 / c1).GetType(), d1.GetType());
-                Assert.IsType((c1 / d1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((d1 / s1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((s1 / d1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((d1 / b1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((b1 / d1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((d1 / i1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((i1 / d1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((d1 / l1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((l1 / d1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((d1 / c1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((c1 / d1).GetType(), d1.GetType());
             }
         }
         public class ValueFloatTestClass12
@@ -395,16 +395,16 @@ public static void testMethod()
                 long l1 = 5L;
                 char c1 = (char)6;
 
-                Assert.IsType((f1 % s1).GetType(), f1.GetType());
-                Assert.IsType((s1 % f1).GetType(), f1.GetType());
-                Assert.IsType((f1 % b1).GetType(), f1.GetType());
-                Assert.IsType((b1 % f1).GetType(), f1.GetType());
-                Assert.IsType((f1 % i1).GetType(), f1.GetType());
-                Assert.IsType((i1 % f1).GetType(), f1.GetType());
-                Assert.IsType((f1 % l1).GetType(), f1.GetType());
-                Assert.IsType((l1 % f1).GetType(), f1.GetType());
-                Assert.IsType((f1 % c1).GetType(), f1.GetType());
-                Assert.IsType((c1 % f1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((f1 % s1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((s1 % f1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((f1 % b1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((b1 % f1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((f1 % i1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((i1 % f1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((f1 % l1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((l1 % f1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((f1 % c1).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((c1 % f1).GetType(), f1.GetType());
             }
         }
         public class ValueFloatTestClass13
@@ -418,16 +418,16 @@ public static void testMethod()
                 long l1 = 5L;
                 char c1 = (char)6;
 
-                Assert.IsType((d1 % s1).GetType(), d1.GetType());
-                Assert.IsType((s1 % d1).GetType(), d1.GetType());
-                Assert.IsType((d1 % b1).GetType(), d1.GetType());
-                Assert.IsType((b1 % d1).GetType(), d1.GetType());
-                Assert.IsType((d1 % i1).GetType(), d1.GetType());
-                Assert.IsType((i1 % d1).GetType(), d1.GetType());
-                Assert.IsType((d1 % l1).GetType(), d1.GetType());
-                Assert.IsType((l1 % d1).GetType(), d1.GetType());
-                Assert.IsType((d1 % c1).GetType(), d1.GetType());
-                Assert.IsType((c1 % d1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((d1 % s1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((s1 % d1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((d1 % b1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((b1 % d1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((d1 % i1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((i1 % d1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((d1 % l1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((l1 % d1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((d1 % c1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((c1 % d1).GetType(), d1.GetType());
             }
         }
         public class ValueFloatTestClass14
@@ -442,16 +442,16 @@ public static void testMethod()
                 long l1 = 5L;
                 char c1 = (char)6;
 
-                Assert.IsType((f1 == s1).GetType(), b.GetType());
-                Assert.IsType((s1 == f1).GetType(), b.GetType());
-                Assert.IsType((f1 == b1).GetType(), b.GetType());
-                Assert.IsType((b1 == f1).GetType(), b.GetType());
-                Assert.IsType((f1 == i1).GetType(), b.GetType());
-                Assert.IsType((i1 == f1).GetType(), b.GetType());
-                Assert.IsType((f1 == l1).GetType(), b.GetType());
-                Assert.IsType((l1 == f1).GetType(), b.GetType());
-                Assert.IsType((f1 == c1).GetType(), b.GetType());
-                Assert.IsType((c1 == f1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 == s1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s1 == f1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 == b1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b1 == f1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 == i1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i1 == f1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 == l1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l1 == f1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 == c1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((c1 == f1).GetType(), b.GetType());
             }
         }
         public class ValueFloatTestClass15
@@ -466,16 +466,16 @@ public static void testMethod()
                 long l1 = 5L;
                 char c1 = (char)6;
 
-                Assert.IsType((d1 == s1).GetType(), b.GetType());
-                Assert.IsType((s1 == d1).GetType(), b.GetType());
-                Assert.IsType((d1 == b1).GetType(), b.GetType());
-                Assert.IsType((b1 == d1).GetType(), b.GetType());
-                Assert.IsType((d1 == i1).GetType(), b.GetType());
-                Assert.IsType((i1 == d1).GetType(), b.GetType());
-                Assert.IsType((d1 == l1).GetType(), b.GetType());
-                Assert.IsType((l1 == d1).GetType(), b.GetType());
-                Assert.IsType((d1 == c1).GetType(), b.GetType());
-                Assert.IsType((c1 == d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 == s1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s1 == d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 == b1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b1 == d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 == i1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i1 == d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 == l1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l1 == d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 == c1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((c1 == d1).GetType(), b.GetType());
             }
         }
         public class ValueFloatTestClass16
@@ -490,16 +490,16 @@ public static void testMethod()
                 long l1 = 5L;
                 char c1 = (char)6;
 
-                Assert.IsType((f1 != s1).GetType(), b.GetType());
-                Assert.IsType((s1 != f1).GetType(), b.GetType());
-                Assert.IsType((f1 != b1).GetType(), b.GetType());
-                Assert.IsType((b1 != f1).GetType(), b.GetType());
-                Assert.IsType((f1 != i1).GetType(), b.GetType());
-                Assert.IsType((i1 != f1).GetType(), b.GetType());
-                Assert.IsType((f1 != l1).GetType(), b.GetType());
-                Assert.IsType((l1 != f1).GetType(), b.GetType());
-                Assert.IsType((f1 != c1).GetType(), b.GetType());
-                Assert.IsType((c1 != f1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 != s1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s1 != f1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 != b1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b1 != f1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 != i1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i1 != f1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 != l1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l1 != f1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 != c1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((c1 != f1).GetType(), b.GetType());
             }
         }
         public class ValueFloatTestClass17
@@ -514,16 +514,16 @@ public static void testMethod()
                 long l1 = 5L;
                 char c1 = (char)6;
 
-                Assert.IsType((d1 != s1).GetType(), b.GetType());
-                Assert.IsType((s1 != d1).GetType(), b.GetType());
-                Assert.IsType((d1 != b1).GetType(), b.GetType());
-                Assert.IsType((b1 != d1).GetType(), b.GetType());
-                Assert.IsType((d1 != i1).GetType(), b.GetType());
-                Assert.IsType((i1 != d1).GetType(), b.GetType());
-                Assert.IsType((d1 != l1).GetType(), b.GetType());
-                Assert.IsType((l1 != d1).GetType(), b.GetType());
-                Assert.IsType((d1 != c1).GetType(), b.GetType());
-                Assert.IsType((c1 != d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 != s1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s1 != d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 != b1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b1 != d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 != i1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i1 != d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 != l1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l1 != d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 != c1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((c1 != d1).GetType(), b.GetType());
             }
         }
         public class ValueFloatTestClass18
@@ -538,16 +538,16 @@ public static void testMethod()
                 long l1 = 5L;
                 char c1 = (char)6;
 
-                Assert.IsType((f1 > s1).GetType(), b.GetType());
-                Assert.IsType((s1 > f1).GetType(), b.GetType());
-                Assert.IsType((f1 > b1).GetType(), b.GetType());
-                Assert.IsType((b1 > f1).GetType(), b.GetType());
-                Assert.IsType((f1 > i1).GetType(), b.GetType());
-                Assert.IsType((i1 > f1).GetType(), b.GetType());
-                Assert.IsType((f1 > l1).GetType(), b.GetType());
-                Assert.IsType((l1 > f1).GetType(), b.GetType());
-                Assert.IsType((f1 > c1).GetType(), b.GetType());
-                Assert.IsType((c1 > f1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 > s1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s1 > f1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 > b1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b1 > f1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 > i1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i1 > f1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 > l1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l1 > f1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 > c1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((c1 > f1).GetType(), b.GetType());
             }
         }
         public class ValueFloatTestClass19
@@ -562,16 +562,16 @@ public static void testMethod()
                 long l1 = 5L;
                 char c1 = (char)6;
 
-                Assert.IsType((d1 > s1).GetType(), b.GetType());
-                Assert.IsType((s1 > d1).GetType(), b.GetType());
-                Assert.IsType((d1 > b1).GetType(), b.GetType());
-                Assert.IsType((b1 > d1).GetType(), b.GetType());
-                Assert.IsType((d1 > i1).GetType(), b.GetType());
-                Assert.IsType((i1 > d1).GetType(), b.GetType());
-                Assert.IsType((d1 > l1).GetType(), b.GetType());
-                Assert.IsType((l1 > d1).GetType(), b.GetType());
-                Assert.IsType((d1 > c1).GetType(), b.GetType());
-                Assert.IsType((c1 > d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 > s1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s1 > d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 > b1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b1 > d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 > i1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i1 > d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 > l1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l1 > d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 > c1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((c1 > d1).GetType(), b.GetType());
             }
         }
         public class ValueFloatTestClass20
@@ -586,16 +586,16 @@ public static void testMethod()
                 long l1 = 5L;
                 char c1 = (char)6;
 
-                Assert.IsType((f1 < s1).GetType(), b.GetType());
-                Assert.IsType((s1 < f1).GetType(), b.GetType());
-                Assert.IsType((f1 < b1).GetType(), b.GetType());
-                Assert.IsType((b1 < f1).GetType(), b.GetType());
-                Assert.IsType((f1 < i1).GetType(), b.GetType());
-                Assert.IsType((i1 < f1).GetType(), b.GetType());
-                Assert.IsType((f1 < l1).GetType(), b.GetType());
-                Assert.IsType((l1 < f1).GetType(), b.GetType());
-                Assert.IsType((f1 < c1).GetType(), b.GetType());
-                Assert.IsType((c1 < f1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 < s1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s1 < f1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 < b1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b1 < f1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 < i1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i1 < f1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 < l1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l1 < f1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 < c1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((c1 < f1).GetType(), b.GetType());
             }
         }
         public class ValueFloatTestClass21
@@ -610,16 +610,16 @@ public static void testMethod()
                 long l1 = 5L;
                 char c1 = (char)6;
 
-                Assert.IsType((d1 < s1).GetType(), b.GetType());
-                Assert.IsType((s1 < d1).GetType(), b.GetType());
-                Assert.IsType((d1 < b1).GetType(), b.GetType());
-                Assert.IsType((b1 < d1).GetType(), b.GetType());
-                Assert.IsType((d1 < i1).GetType(), b.GetType());
-                Assert.IsType((i1 < d1).GetType(), b.GetType());
-                Assert.IsType((d1 < l1).GetType(), b.GetType());
-                Assert.IsType((l1 < d1).GetType(), b.GetType());
-                Assert.IsType((d1 < c1).GetType(), b.GetType());
-                Assert.IsType((c1 < d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 < s1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s1 < d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 < b1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b1 < d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 < i1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i1 < d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 < l1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l1 < d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 < c1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((c1 < d1).GetType(), b.GetType());
             }
         }
         public class ValueFloatTestClass22
@@ -634,16 +634,16 @@ public static void testMethod()
                 long l1 = 5L;
                 char c1 = (char)6;
 
-                Assert.IsType((f1 >= s1).GetType(), b.GetType());
-                Assert.IsType((s1 >= f1).GetType(), b.GetType());
-                Assert.IsType((f1 >= b1).GetType(), b.GetType());
-                Assert.IsType((b1 >= f1).GetType(), b.GetType());
-                Assert.IsType((f1 >= i1).GetType(), b.GetType());
-                Assert.IsType((i1 >= f1).GetType(), b.GetType());
-                Assert.IsType((f1 >= l1).GetType(), b.GetType());
-                Assert.IsType((l1 >= f1).GetType(), b.GetType());
-                Assert.IsType((f1 >= c1).GetType(), b.GetType());
-                Assert.IsType((c1 >= f1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 >= s1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s1 >= f1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 >= b1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b1 >= f1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 >= i1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i1 >= f1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 >= l1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l1 >= f1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 >= c1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((c1 >= f1).GetType(), b.GetType());
             }
         }
         public class ValueFloatTestClass23
@@ -658,16 +658,16 @@ public static void testMethod()
                 long l1 = 5L;
                 char c1 = (char)6;
 
-                Assert.IsType((d1 >= s1).GetType(), b.GetType());
-                Assert.IsType((s1 >= d1).GetType(), b.GetType());
-                Assert.IsType((d1 >= b1).GetType(), b.GetType());
-                Assert.IsType((b1 >= d1).GetType(), b.GetType());
-                Assert.IsType((d1 >= i1).GetType(), b.GetType());
-                Assert.IsType((i1 >= d1).GetType(), b.GetType());
-                Assert.IsType((d1 >= l1).GetType(), b.GetType());
-                Assert.IsType((l1 >= d1).GetType(), b.GetType());
-                Assert.IsType((d1 >= c1).GetType(), b.GetType());
-                Assert.IsType((c1 >= d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 >= s1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s1 >= d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 >= b1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b1 >= d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 >= i1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i1 >= d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 >= l1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l1 >= d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 >= c1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((c1 >= d1).GetType(), b.GetType());
             }
         }
         public class ValueFloatTestClass24
@@ -682,16 +682,16 @@ public static void testMethod()
                 long l1 = 5L;
                 char c1 = (char)6;
 
-                Assert.IsType((f1 <= s1).GetType(), b.GetType());
-                Assert.IsType((s1 <= f1).GetType(), b.GetType());
-                Assert.IsType((f1 <= b1).GetType(), b.GetType());
-                Assert.IsType((b1 <= f1).GetType(), b.GetType());
-                Assert.IsType((f1 <= i1).GetType(), b.GetType());
-                Assert.IsType((i1 <= f1).GetType(), b.GetType());
-                Assert.IsType((f1 <= l1).GetType(), b.GetType());
-                Assert.IsType((l1 <= f1).GetType(), b.GetType());
-                Assert.IsType((f1 <= c1).GetType(), b.GetType());
-                Assert.IsType((c1 <= f1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 <= s1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s1 <= f1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 <= b1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b1 <= f1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 <= i1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i1 <= f1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 <= l1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l1 <= f1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 <= c1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((c1 <= f1).GetType(), b.GetType());
             }
         }
         public class ValueFloatTestClass25
@@ -706,16 +706,16 @@ public static void testMethod()
                 long l1 = 5L;
                 char c1 = (char)6;
 
-                Assert.IsType((d1 <= s1).GetType(), b.GetType());
-                Assert.IsType((s1 <= d1).GetType(), b.GetType());
-                Assert.IsType((d1 <= b1).GetType(), b.GetType());
-                Assert.IsType((b1 <= d1).GetType(), b.GetType());
-                Assert.IsType((d1 <= i1).GetType(), b.GetType());
-                Assert.IsType((i1 <= d1).GetType(), b.GetType());
-                Assert.IsType((d1 <= l1).GetType(), b.GetType());
-                Assert.IsType((l1 <= d1).GetType(), b.GetType());
-                Assert.IsType((d1 <= c1).GetType(), b.GetType());
-                Assert.IsType((c1 <= d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 <= s1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s1 <= d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 <= b1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b1 <= d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 <= i1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i1 <= d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 <= l1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l1 <= d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 <= c1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((c1 <= d1).GetType(), b.GetType());
             }
         }
         public class ValueFloatTestClass26
@@ -725,21 +725,21 @@ public static void testMethod()
                 double d1 = 11.0d;
                 float f1 = 12.0f;
 
-                Assert.IsType((d1 + f1).GetType(), d1.GetType());
-                Assert.IsType((f1 + d1).GetType(), d1.GetType());
-                Assert.IsType((d1 + d1).GetType(), d1.GetType());
-                Assert.IsType((d1 - f1).GetType(), d1.GetType());
-                Assert.IsType((f1 - d1).GetType(), d1.GetType());
-                Assert.IsType((d1 - d1).GetType(), d1.GetType());
-                Assert.IsType((d1 * f1).GetType(), d1.GetType());
-                Assert.IsType((f1 * d1).GetType(), d1.GetType());
-                Assert.IsType((d1 * d1).GetType(), d1.GetType());
-                Assert.IsType((d1 / f1).GetType(), d1.GetType());
-                Assert.IsType((f1 / d1).GetType(), d1.GetType());
-                Assert.IsType((d1 / d1).GetType(), d1.GetType());
-                Assert.IsType((d1 % f1).GetType(), d1.GetType());
-                Assert.IsType((f1 % d1).GetType(), d1.GetType());
-                Assert.IsType((d1 % d1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((d1 + f1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((f1 + d1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((d1 + d1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((d1 - f1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((f1 - d1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((d1 - d1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((d1 * f1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((f1 * d1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((d1 * d1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((d1 / f1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((f1 / d1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((d1 / d1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((d1 % f1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((f1 % d1).GetType(), d1.GetType());
+                Assert.IsInstanceOfType((d1 % d1).GetType(), d1.GetType());
             }
         }
         public class ValueFloatTestClass27
@@ -749,24 +749,24 @@ public static void testMethod()
                 double d1 = 11.0d;
                 float f1 = 12.0f;
                 bool b = false;
-                Assert.IsType((d1 == f1).GetType(), b.GetType());
-                Assert.IsType((f1 == d1).GetType(), b.GetType());
-                Assert.IsType((d1 == d1).GetType(), b.GetType());
-                Assert.IsType((d1 != f1).GetType(), b.GetType());
-                Assert.IsType((f1 != d1).GetType(), b.GetType());
-                Assert.IsType((d1 != d1).GetType(), b.GetType());
-                Assert.IsType((d1 > f1).GetType(), b.GetType());
-                Assert.IsType((f1 > d1).GetType(), b.GetType());
-                Assert.IsType((d1 > d1).GetType(), b.GetType());
-                Assert.IsType((d1 < f1).GetType(), b.GetType());
-                Assert.IsType((f1 < d1).GetType(), b.GetType());
-                Assert.IsType((d1 < d1).GetType(), b.GetType());
-                Assert.IsType((d1 >= f1).GetType(), b.GetType());
-                Assert.IsType((f1 >= d1).GetType(), b.GetType());
-                Assert.IsType((d1 >= d1).GetType(), b.GetType());
-                Assert.IsType((d1 <= f1).GetType(), b.GetType());
-                Assert.IsType((f1 <= d1).GetType(), b.GetType());
-                Assert.IsType((d1 <= d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 == f1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 == d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 == d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 != f1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 != d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 != d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 > f1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 > d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 > d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 < f1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 < d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 < d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 >= f1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 >= d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 >= d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 <= f1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 <= d1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((d1 <= d1).GetType(), b.GetType());
             }
         }
         public class ValueFloatTestClass28
@@ -776,11 +776,11 @@ public static void testMethod()
                 float f1 = 11.0f;
                 float f2 = 12.0f;
 
-                Assert.IsType((f1 + f2).GetType(), f1.GetType());
-                Assert.IsType((f1 - f2).GetType(), f1.GetType());
-                Assert.IsType((f1 * f2).GetType(), f1.GetType());
-                Assert.IsType((f1 / f2).GetType(), f1.GetType());
-                Assert.IsType((f1 % f2).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((f1 + f2).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((f1 - f2).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((f1 * f2).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((f1 / f2).GetType(), f1.GetType());
+                Assert.IsInstanceOfType((f1 % f2).GetType(), f1.GetType());
             }
         }
         public class ValueFloatTestClass29
@@ -790,12 +790,12 @@ public static void testMethod()
                 double f1 = 11.0d;
                 float f2 = 12.0f;
                 bool b = false;
-                Assert.IsType((f1 == f2).GetType(), b.GetType());
-                Assert.IsType((f1 != f2).GetType(), b.GetType());
-                Assert.IsType((f1 > f2).GetType(), b.GetType());
-                Assert.IsType((f1 < f2).GetType(), b.GetType());
-                Assert.IsType((f1 >= f2).GetType(), b.GetType());
-                Assert.IsType((f1 <= f2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 == f2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 != f2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 > f2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 < f2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 >= f2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((f1 <= f2).GetType(), b.GetType());
             }
         }
         public class ValueFloatTestClass30
diff --git a/Tests/NFUnitTestTypes/UnitTestValueIntegralTests.cs b/Tests/NFUnitTestTypes/UnitTestValueIntegralTests.cs
index e35203f..0ed82ae 100644
--- a/Tests/NFUnitTestTypes/UnitTestValueIntegralTests.cs
+++ b/Tests/NFUnitTestTypes/UnitTestValueIntegralTests.cs
@@ -517,25 +517,25 @@ public static void testMethod()
                 long l1 = 5L;
                 char c1 = (char)6;
                 //short
-                Assert.IsType((s1 + s1).GetType(), i1.GetType());
-                Assert.IsType((s1 + b1).GetType(), i1.GetType());
-                Assert.IsType((s1 + i1).GetType(), i1.GetType());
-                Assert.IsType((s1 + l1).GetType(), l1.GetType());
-                Assert.IsType((s1 + c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s1 + s1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s1 + b1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s1 + i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s1 + l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((s1 + c1).GetType(), i1.GetType());
                 //byte
-                Assert.IsType((b1 + b1).GetType(), i1.GetType());
-                Assert.IsType((b1 + i1).GetType(), i1.GetType());
-                Assert.IsType((b1 + l1).GetType(), l1.GetType());
-                Assert.IsType((b1 + c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b1 + b1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b1 + i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b1 + l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((b1 + c1).GetType(), i1.GetType());
                 //int
-                Assert.IsType((i1 + i1).GetType(), i1.GetType());
-                Assert.IsType((i1 + l1).GetType(), l1.GetType());
-                Assert.IsType((i1 + c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((i1 + i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((i1 + l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i1 + c1).GetType(), i1.GetType());
                 //long
-                Assert.IsType((l1 + l1).GetType(), l1.GetType());
-                Assert.IsType((l1 + c1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((l1 + l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((l1 + c1).GetType(), l1.GetType());
                 //char
-                Assert.IsType((c1 + c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((c1 + c1).GetType(), i1.GetType());
             }
         }
         public class ValueIntegralTestClass14
@@ -548,25 +548,25 @@ public static void testMethod()
                 long l1 = 5L;
                 char c1 = (char)6;
                 //short
-                Assert.IsType((s1 - s1).GetType(), i1.GetType());
-                Assert.IsType((s1 - b1).GetType(), i1.GetType());
-                Assert.IsType((s1 - i1).GetType(), i1.GetType());
-                Assert.IsType((s1 - l1).GetType(), l1.GetType());
-                Assert.IsType((s1 - c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s1 - s1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s1 - b1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s1 - i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s1 - l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((s1 - c1).GetType(), i1.GetType());
                 //byte
-                Assert.IsType((b1 - b1).GetType(), i1.GetType());
-                Assert.IsType((b1 - i1).GetType(), i1.GetType());
-                Assert.IsType((b1 - l1).GetType(), l1.GetType());
-                Assert.IsType((b1 - c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b1 - b1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b1 - i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b1 - l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((b1 - c1).GetType(), i1.GetType());
                 //int
-                Assert.IsType((i1 - i1).GetType(), i1.GetType());
-                Assert.IsType((i1 - l1).GetType(), l1.GetType());
-                Assert.IsType((i1 - c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((i1 - i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((i1 - l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i1 - c1).GetType(), i1.GetType());
                 //long
-                Assert.IsType((l1 - l1).GetType(), l1.GetType());
-                Assert.IsType((l1 - c1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((l1 - l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((l1 - c1).GetType(), l1.GetType());
                 //char
-                Assert.IsType((c1 - c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((c1 - c1).GetType(), i1.GetType());
             }
         }
         public class ValueIntegralTestClass15
@@ -579,25 +579,25 @@ public static void testMethod()
                 long l1 = 5L;
                 char c1 = (char)6;
                 //short
-                Assert.IsType((s1 * s1).GetType(), i1.GetType());
-                Assert.IsType((s1 * b1).GetType(), i1.GetType());
-                Assert.IsType((s1 * i1).GetType(), i1.GetType());
-                Assert.IsType((s1 * l1).GetType(), l1.GetType());
-                Assert.IsType((s1 * c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s1 * s1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s1 * b1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s1 * i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s1 * l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((s1 * c1).GetType(), i1.GetType());
                 //byte                                            
-                Assert.IsType((b1 * b1).GetType(), i1.GetType());
-                Assert.IsType((b1 * i1).GetType(), i1.GetType());
-                Assert.IsType((b1 * l1).GetType(), l1.GetType());
-                Assert.IsType((b1 * c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b1 * b1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b1 * i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b1 * l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((b1 * c1).GetType(), i1.GetType());
                 //int                                             
-                Assert.IsType((i1 * i1).GetType(), i1.GetType());
-                Assert.IsType((i1 * l1).GetType(), l1.GetType());
-                Assert.IsType((i1 * c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((i1 * i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((i1 * l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i1 * c1).GetType(), i1.GetType());
                 //long
-                Assert.IsType((l1 * l1).GetType(), l1.GetType());
-                Assert.IsType((l1 * c1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((l1 * l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((l1 * c1).GetType(), l1.GetType());
                 //char
-                Assert.IsType((c1 * c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((c1 * c1).GetType(), i1.GetType());
             }
         }
         public class ValueIntegralTestClass16
@@ -609,21 +609,21 @@ public static void testMethod()
                 int i1 = 4;
                 long l1 = 5L;
                 char c1 = (char)6;
-                Assert.IsType((s1 / s1).GetType(), i1.GetType());
-                Assert.IsType((s1 / b1).GetType(), i1.GetType());
-                Assert.IsType((s1 / i1).GetType(), i1.GetType());
-                Assert.IsType((s1 / l1).GetType(), l1.GetType());
-                Assert.IsType((s1 / c1).GetType(), i1.GetType());
-                Assert.IsType((b1 / b1).GetType(), i1.GetType());
-                Assert.IsType((b1 / i1).GetType(), i1.GetType());
-                Assert.IsType((b1 / l1).GetType(), l1.GetType());
-                Assert.IsType((b1 / c1).GetType(), i1.GetType());
-                Assert.IsType((i1 / i1).GetType(), i1.GetType());
-                Assert.IsType((i1 / l1).GetType(), l1.GetType());
-                Assert.IsType((i1 / c1).GetType(), i1.GetType());
-                Assert.IsType((l1 / l1).GetType(), l1.GetType());
-                Assert.IsType((l1 / c1).GetType(), l1.GetType());
-                Assert.IsType((c1 / c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s1 / s1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s1 / b1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s1 / i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s1 / l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((s1 / c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b1 / b1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b1 / i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b1 / l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((b1 / c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((i1 / i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((i1 / l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i1 / c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((l1 / l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((l1 / c1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((c1 / c1).GetType(), i1.GetType());
             }
         }
         public class ValueIntegralTestClass17
@@ -636,21 +636,21 @@ public static void testMethod()
                 long l1 = 5L;
                 char c1 = (char)6;
                 //short
-                Assert.IsType((s1 % s1).GetType(), i1.GetType());
-                Assert.IsType((s1 % b1).GetType(), i1.GetType());
-                Assert.IsType((s1 % i1).GetType(), i1.GetType());
-                Assert.IsType((s1 % l1).GetType(), l1.GetType());
-                Assert.IsType((s1 % c1).GetType(), i1.GetType());
-                Assert.IsType((b1 % b1).GetType(), i1.GetType());
-                Assert.IsType((b1 % i1).GetType(), i1.GetType());
-                Assert.IsType((b1 % l1).GetType(), l1.GetType());
-                Assert.IsType((b1 % c1).GetType(), i1.GetType());
-                Assert.IsType((i1 % i1).GetType(), i1.GetType());
-                Assert.IsType((i1 % l1).GetType(), l1.GetType());
-                Assert.IsType((i1 % c1).GetType(), i1.GetType());
-                Assert.IsType((l1 % l1).GetType(), l1.GetType());
-                Assert.IsType((l1 % c1).GetType(), l1.GetType());
-                Assert.IsType((c1 % c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s1 % s1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s1 % b1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s1 % i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s1 % l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((s1 % c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b1 % b1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b1 % i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b1 % l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((b1 % c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((i1 % i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((i1 % l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i1 % c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((l1 % l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((l1 % c1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((c1 % c1).GetType(), i1.GetType());
             }
         }
         public class ValueIntegralTestClass18
@@ -663,21 +663,21 @@ public static void testMethod()
                 long l1 = 5L;
                 char c1 = (char)6;
                 //short
-                Assert.IsType((s1 & s1).GetType(), i1.GetType());
-                Assert.IsType((s1 & b1).GetType(), i1.GetType());
-                Assert.IsType((s1 & i1).GetType(), i1.GetType());
-                Assert.IsType((s1 & l1).GetType(), l1.GetType());
-                Assert.IsType((s1 & c1).GetType(), i1.GetType());
-                Assert.IsType((b1 & b1).GetType(), i1.GetType());
-                Assert.IsType((b1 & i1).GetType(), i1.GetType());
-                Assert.IsType((b1 & l1).GetType(), l1.GetType());
-                Assert.IsType((b1 & c1).GetType(), i1.GetType());
-                Assert.IsType((i1 & i1).GetType(), i1.GetType());
-                Assert.IsType((i1 & l1).GetType(), l1.GetType());
-                Assert.IsType((i1 & c1).GetType(), i1.GetType());
-                Assert.IsType((l1 & l1).GetType(), l1.GetType());
-                Assert.IsType((l1 & c1).GetType(), l1.GetType());
-                Assert.IsType((c1 & c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s1 & s1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s1 & b1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s1 & i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s1 & l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((s1 & c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b1 & b1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b1 & i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b1 & l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((b1 & c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((i1 & i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((i1 & l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i1 & c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((l1 & l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((l1 & c1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((c1 & c1).GetType(), i1.GetType());
             }
         }
         public class ValueIntegralTestClass19
@@ -690,21 +690,21 @@ public static void testMethod()
                 long l1 = 5L;
                 char c1 = (char)6;
                 //short
-                Assert.IsType((s1 ^ s1).GetType(), i1.GetType());
-                Assert.IsType((s1 ^ b1).GetType(), i1.GetType());
-                Assert.IsType((s1 ^ i1).GetType(), i1.GetType());
-                Assert.IsType((s1 ^ l1).GetType(), l1.GetType());
-                Assert.IsType((s1 ^ c1).GetType(), i1.GetType());
-                Assert.IsType((b1 ^ b1).GetType(), i1.GetType());
-                Assert.IsType((b1 ^ i1).GetType(), i1.GetType());
-                Assert.IsType((b1 ^ l1).GetType(), l1.GetType());
-                Assert.IsType((b1 ^ c1).GetType(), i1.GetType());
-                Assert.IsType((i1 ^ i1).GetType(), i1.GetType());
-                Assert.IsType((i1 ^ l1).GetType(), l1.GetType());
-                Assert.IsType((i1 ^ c1).GetType(), i1.GetType());
-                Assert.IsType((l1 ^ l1).GetType(), l1.GetType());
-                Assert.IsType((l1 ^ c1).GetType(), l1.GetType());
-                Assert.IsType((c1 ^ c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s1 ^ s1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s1 ^ b1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s1 ^ i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s1 ^ l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((s1 ^ c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b1 ^ b1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b1 ^ i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b1 ^ l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((b1 ^ c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((i1 ^ i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((i1 ^ l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i1 ^ c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((l1 ^ l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((l1 ^ c1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((c1 ^ c1).GetType(), i1.GetType());
             }
         }
         public class ValueIntegralTestClass20
@@ -717,21 +717,21 @@ public static void testMethod()
                 long l1 = 5L;
                 char c1 = (char)6;
                 //short
-                Assert.IsType((s1 | s1).GetType(), i1.GetType());
-                Assert.IsType((s1 | b1).GetType(), i1.GetType());
-                Assert.IsType((s1 | i1).GetType(), i1.GetType());
-                Assert.IsType((s1 | l1).GetType(), l1.GetType());
-                Assert.IsType((s1 | c1).GetType(), i1.GetType());
-                Assert.IsType((b1 | b1).GetType(), i1.GetType());
-                Assert.IsType((b1 | i1).GetType(), i1.GetType());
-                Assert.IsType((b1 | l1).GetType(), l1.GetType());
-                Assert.IsType((b1 | c1).GetType(), i1.GetType());
-                Assert.IsType((i1 | i1).GetType(), i1.GetType());
-                Assert.IsType((i1 | l1).GetType(), l1.GetType());
-                Assert.IsType((i1 | c1).GetType(), i1.GetType());
-                Assert.IsType((l1 | l1).GetType(), l1.GetType());
-                Assert.IsType((l1 | c1).GetType(), l1.GetType());
-                Assert.IsType((c1 | c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s1 | s1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s1 | b1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s1 | i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s1 | l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((s1 | c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b1 | b1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b1 | i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b1 | l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((b1 | c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((i1 | i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((i1 | l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i1 | c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((l1 | l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((l1 | c1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((c1 | c1).GetType(), i1.GetType());
             }
         }
         public class ValueIntegralTestClass21
@@ -745,21 +745,21 @@ public static void testMethod()
                 long l1 = 5L;
                 char c1 = (char)6;
                 //short
-                Assert.IsType((s1 == s1).GetType(), TestBool.GetType());
-                Assert.IsType((s1 == b1).GetType(), TestBool.GetType());
-                Assert.IsType((s1 == i1).GetType(), TestBool.GetType());
-                Assert.IsType((s1 == l1).GetType(), TestBool.GetType());
-                Assert.IsType((s1 == c1).GetType(), TestBool.GetType());
-                Assert.IsType((b1 == b1).GetType(), TestBool.GetType());
-                Assert.IsType((b1 == i1).GetType(), TestBool.GetType());
-                Assert.IsType((b1 == l1).GetType(), TestBool.GetType());
-                Assert.IsType((b1 == c1).GetType(), TestBool.GetType());
-                Assert.IsType((i1 == i1).GetType(), TestBool.GetType());
-                Assert.IsType((i1 == l1).GetType(), TestBool.GetType());
-                Assert.IsType((i1 == c1).GetType(), TestBool.GetType());
-                Assert.IsType((l1 == l1).GetType(), TestBool.GetType());
-                Assert.IsType((l1 == c1).GetType(), TestBool.GetType());
-                Assert.IsType((c1 == c1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((s1 == s1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((s1 == b1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((s1 == i1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((s1 == l1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((s1 == c1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((b1 == b1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((b1 == i1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((b1 == l1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((b1 == c1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((i1 == i1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((i1 == l1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((i1 == c1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((l1 == l1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((l1 == c1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((c1 == c1).GetType(), TestBool.GetType());
             }
         }
         public class ValueIntegralTestClass22
@@ -773,21 +773,21 @@ public static void testMethod()
                 long l1 = 5L;
                 char c1 = (char)6;
                 //short
-                Assert.IsType((s1 != s1).GetType(), TestBool.GetType());
-                Assert.IsType((s1 != b1).GetType(), TestBool.GetType());
-                Assert.IsType((s1 != i1).GetType(), TestBool.GetType());
-                Assert.IsType((s1 != l1).GetType(), TestBool.GetType());
-                Assert.IsType((s1 != c1).GetType(), TestBool.GetType());
-                Assert.IsType((b1 != b1).GetType(), TestBool.GetType());
-                Assert.IsType((b1 != i1).GetType(), TestBool.GetType());
-                Assert.IsType((b1 != l1).GetType(), TestBool.GetType());
-                Assert.IsType((b1 != c1).GetType(), TestBool.GetType());
-                Assert.IsType((i1 != i1).GetType(), TestBool.GetType());
-                Assert.IsType((i1 != l1).GetType(), TestBool.GetType());
-                Assert.IsType((i1 != c1).GetType(), TestBool.GetType());
-                Assert.IsType((l1 != l1).GetType(), TestBool.GetType());
-                Assert.IsType((l1 != c1).GetType(), TestBool.GetType());
-                Assert.IsType((c1 != c1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((s1 != s1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((s1 != b1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((s1 != i1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((s1 != l1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((s1 != c1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((b1 != b1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((b1 != i1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((b1 != l1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((b1 != c1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((i1 != i1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((i1 != l1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((i1 != c1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((l1 != l1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((l1 != c1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((c1 != c1).GetType(), TestBool.GetType());
             }
         }
         public class ValueIntegralTestClass23
@@ -801,21 +801,21 @@ public static void testMethod()
                 long l1 = 5L;
                 char c1 = (char)6;
                 //short
-                Assert.IsType((s1 > s1).GetType(), TestBool.GetType());
-                Assert.IsType((s1 > b1).GetType(), TestBool.GetType());
-                Assert.IsType((s1 > i1).GetType(), TestBool.GetType());
-                Assert.IsType((s1 > l1).GetType(), TestBool.GetType());
-                Assert.IsType((s1 > c1).GetType(), TestBool.GetType());
-                Assert.IsType((b1 > b1).GetType(), TestBool.GetType());
-                Assert.IsType((b1 > i1).GetType(), TestBool.GetType());
-                Assert.IsType((b1 > l1).GetType(), TestBool.GetType());
-                Assert.IsType((b1 > c1).GetType(), TestBool.GetType());
-                Assert.IsType((i1 > i1).GetType(), TestBool.GetType());
-                Assert.IsType((i1 > l1).GetType(), TestBool.GetType());
-                Assert.IsType((i1 > c1).GetType(), TestBool.GetType());
-                Assert.IsType((l1 > l1).GetType(), TestBool.GetType());
-                Assert.IsType((l1 > c1).GetType(), TestBool.GetType());
-                Assert.IsType((c1 > c1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((s1 > s1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((s1 > b1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((s1 > i1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((s1 > l1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((s1 > c1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((b1 > b1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((b1 > i1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((b1 > l1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((b1 > c1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((i1 > i1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((i1 > l1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((i1 > c1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((l1 > l1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((l1 > c1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((c1 > c1).GetType(), TestBool.GetType());
             }
         }
         public class ValueIntegralTestClass24
@@ -829,21 +829,21 @@ public static void testMethod()
                 long l1 = 5L;
                 char c1 = (char)6;
                 //short
-                Assert.IsType((s1 < s1).GetType(), TestBool.GetType());
-                Assert.IsType((s1 < b1).GetType(), TestBool.GetType());
-                Assert.IsType((s1 < i1).GetType(), TestBool.GetType());
-                Assert.IsType((s1 < l1).GetType(), TestBool.GetType());
-                Assert.IsType((s1 < c1).GetType(), TestBool.GetType());
-                Assert.IsType((b1 < b1).GetType(), TestBool.GetType());
-                Assert.IsType((b1 < i1).GetType(), TestBool.GetType());
-                Assert.IsType((b1 < l1).GetType(), TestBool.GetType());
-                Assert.IsType((b1 < c1).GetType(), TestBool.GetType());
-                Assert.IsType((i1 < i1).GetType(), TestBool.GetType());
-                Assert.IsType((i1 < l1).GetType(), TestBool.GetType());
-                Assert.IsType((i1 < c1).GetType(), TestBool.GetType());
-                Assert.IsType((l1 < l1).GetType(), TestBool.GetType());
-                Assert.IsType((l1 < c1).GetType(), TestBool.GetType());
-                Assert.IsType((c1 < c1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((s1 < s1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((s1 < b1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((s1 < i1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((s1 < l1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((s1 < c1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((b1 < b1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((b1 < i1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((b1 < l1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((b1 < c1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((i1 < i1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((i1 < l1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((i1 < c1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((l1 < l1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((l1 < c1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((c1 < c1).GetType(), TestBool.GetType());
             }
         }
         public class ValueIntegralTestClass25
@@ -857,21 +857,21 @@ public static void testMethod()
                 long l1 = 5L;
                 char c1 = (char)6;
                 //short
-                Assert.IsType((s1 >= s1).GetType(), TestBool.GetType());
-                Assert.IsType((s1 >= b1).GetType(), TestBool.GetType());
-                Assert.IsType((s1 >= i1).GetType(), TestBool.GetType());
-                Assert.IsType((s1 >= l1).GetType(), TestBool.GetType());
-                Assert.IsType((s1 >= c1).GetType(), TestBool.GetType());
-                Assert.IsType((b1 >= b1).GetType(), TestBool.GetType());
-                Assert.IsType((b1 >= i1).GetType(), TestBool.GetType());
-                Assert.IsType((b1 >= l1).GetType(), TestBool.GetType());
-                Assert.IsType((b1 >= c1).GetType(), TestBool.GetType());
-                Assert.IsType((i1 >= i1).GetType(), TestBool.GetType());
-                Assert.IsType((i1 >= l1).GetType(), TestBool.GetType());
-                Assert.IsType((i1 >= c1).GetType(), TestBool.GetType());
-                Assert.IsType((l1 >= l1).GetType(), TestBool.GetType());
-                Assert.IsType((l1 >= c1).GetType(), TestBool.GetType());
-                Assert.IsType((c1 >= c1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((s1 >= s1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((s1 >= b1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((s1 >= i1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((s1 >= l1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((s1 >= c1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((b1 >= b1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((b1 >= i1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((b1 >= l1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((b1 >= c1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((i1 >= i1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((i1 >= l1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((i1 >= c1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((l1 >= l1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((l1 >= c1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((c1 >= c1).GetType(), TestBool.GetType());
             }
         }
         public class ValueIntegralTestClass26
@@ -885,21 +885,21 @@ public static void testMethod()
                 long l1 = 5L;
                 char c1 = (char)6;
                 //short
-                Assert.IsType((s1 <= s1).GetType(), TestBool.GetType());
-                Assert.IsType((s1 <= b1).GetType(), TestBool.GetType());
-                Assert.IsType((s1 <= i1).GetType(), TestBool.GetType());
-                Assert.IsType((s1 <= l1).GetType(), TestBool.GetType());
-                Assert.IsType((s1 <= c1).GetType(), TestBool.GetType());
-                Assert.IsType((b1 <= b1).GetType(), TestBool.GetType());
-                Assert.IsType((b1 <= i1).GetType(), TestBool.GetType());
-                Assert.IsType((b1 <= l1).GetType(), TestBool.GetType());
-                Assert.IsType((b1 <= c1).GetType(), TestBool.GetType());
-                Assert.IsType((i1 <= i1).GetType(), TestBool.GetType());
-                Assert.IsType((i1 <= l1).GetType(), TestBool.GetType());
-                Assert.IsType((i1 <= c1).GetType(), TestBool.GetType());
-                Assert.IsType((l1 <= l1).GetType(), TestBool.GetType());
-                Assert.IsType((l1 <= c1).GetType(), TestBool.GetType());
-                Assert.IsType((c1 <= c1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((s1 <= s1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((s1 <= b1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((s1 <= i1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((s1 <= l1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((s1 <= c1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((b1 <= b1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((b1 <= i1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((b1 <= l1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((b1 <= c1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((i1 <= i1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((i1 <= l1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((i1 <= c1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((l1 <= l1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((l1 <= c1).GetType(), TestBool.GetType());
+                Assert.IsInstanceOfType((c1 <= c1).GetType(), TestBool.GetType());
             }
         }
         public class ValueIntegralTestClass27
@@ -911,11 +911,11 @@ public static void testMethod()
                 int i1 = 4;
                 long l1 = 5L;
                 char c1 = (char)6;
-                Assert.IsType((s1 << 1).GetType(), i1.GetType());
-                Assert.IsType((b1 << 1).GetType(), i1.GetType());
-                Assert.IsType((i1 << 1).GetType(), i1.GetType());
-                Assert.IsType((l1 << 1).GetType(), l1.GetType());
-                Assert.IsType((c1 << 1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s1 << 1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b1 << 1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((i1 << 1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((l1 << 1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((c1 << 1).GetType(), i1.GetType());
             }
         }
         public class ValueIntegralTestClass28
@@ -927,11 +927,11 @@ public static void testMethod()
                 int i1 = 4;
                 long l1 = 5L;
                 char c1 = (char)6;
-                Assert.IsType((s1 >> 1).GetType(), i1.GetType());
-                Assert.IsType((b1 >> 1).GetType(), i1.GetType());
-                Assert.IsType((i1 >> 1).GetType(), i1.GetType());
-                Assert.IsType((l1 >> 1).GetType(), l1.GetType());
-                Assert.IsType((c1 >> 1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s1 >> 1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b1 >> 1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((i1 >> 1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((l1 >> 1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((c1 >> 1).GetType(), i1.GetType());
             }
         }
         public class ValueIntegralTestClass38
@@ -1013,37 +1013,37 @@ public static void testMethod()
                 uint i2 = 9;
                 ulong l2 = 10;
                 //ushort
-                Assert.IsType((s2 + s1).GetType(), i1.GetType());
-                Assert.IsType((s2 + b1).GetType(), i1.GetType());
-                Assert.IsType((s2 + i1).GetType(), i1.GetType());
-                Assert.IsType((s2 + l1).GetType(), l1.GetType());
-                Assert.IsType((s2 + c1).GetType(), i1.GetType());
-                Assert.IsType((s2 + s2).GetType(), i1.GetType());
-                Assert.IsType((s2 + b2).GetType(), i1.GetType());
-                Assert.IsType((s2 + i2).GetType(), i2.GetType());
-                Assert.IsType((s2 + l2).GetType(), l2.GetType());
-                Assert.IsType((b2 + s1).GetType(), i1.GetType());
-                Assert.IsType((b2 + b1).GetType(), i1.GetType());
-                Assert.IsType((b2 + i1).GetType(), i1.GetType());
-                Assert.IsType((b2 + l1).GetType(), l1.GetType());
-                Assert.IsType((b2 + c1).GetType(), i1.GetType());
-                Assert.IsType((b2 + s2).GetType(), i1.GetType());
-                Assert.IsType((b2 + b2).GetType(), i1.GetType());
-                Assert.IsType((b2 + i2).GetType(), l1.GetType());
-                Assert.IsType((i2 + s1).GetType(), l1.GetType());
-                Assert.IsType((i2 + b1).GetType(), i2.GetType());
-                Assert.IsType((i2 + i1).GetType(), l1.GetType());
-                Assert.IsType((i2 + l1).GetType(), l1.GetType());
-                Assert.IsType((i2 + c1).GetType(), i2.GetType());
-                Assert.IsType((i2 + s2).GetType(), i2.GetType());
-                Assert.IsType((i2 + b2).GetType(), l1.GetType());
-                Assert.IsType((i2 + i2).GetType(), i2.GetType());
-                Assert.IsType((i2 + l2).GetType(), l2.GetType());
-                Assert.IsType((l2 + b1).GetType(), l2.GetType());
-                Assert.IsType((l2 + c1).GetType(), l2.GetType());
-                Assert.IsType((l2 + s2).GetType(), l2.GetType());
-                Assert.IsType((l2 + i2).GetType(), l2.GetType());
-                Assert.IsType((l2 + l2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((s2 + s1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 + b1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 + i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 + l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((s2 + c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 + s2).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 + b2).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 + i2).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((s2 + l2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((b2 + s1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 + b1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 + i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 + l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((b2 + c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 + s2).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 + b2).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 + i2).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 + s1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 + b1).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((i2 + i1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 + l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 + c1).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((i2 + s2).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((i2 + b2).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 + i2).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((i2 + l2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 + b1).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 + c1).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 + s2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 + i2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 + l2).GetType(), l2.GetType());
             }
         }
         public class ValueIntegralTestClass50
@@ -1060,36 +1060,36 @@ public static void testMethod()
                 uint i2 = 9;
                 ulong l2 = 10;
                 //ushort
-                Assert.IsType((s2 - s1).GetType(), i1.GetType());
-                Assert.IsType((s2 - i1).GetType(), i1.GetType());
-                Assert.IsType((s2 - l1).GetType(), l1.GetType());
-                Assert.IsType((s2 - c1).GetType(), i1.GetType());
-                Assert.IsType((s2 - s2).GetType(), i1.GetType());
-                Assert.IsType((s2 - b2).GetType(), i1.GetType());
-                Assert.IsType((s2 - i2).GetType(), i2.GetType());
-                Assert.IsType((s2 - l2).GetType(), l2.GetType());
-                Assert.IsType((b2 - s1).GetType(), i1.GetType());
-                Assert.IsType((b2 - b1).GetType(), i1.GetType());
-                Assert.IsType((b2 - i1).GetType(), i1.GetType());
-                Assert.IsType((b2 - l1).GetType(), l1.GetType());
-                Assert.IsType((b2 - c1).GetType(), i1.GetType());
-                Assert.IsType((b2 - s2).GetType(), i1.GetType());
-                Assert.IsType((b2 - b2).GetType(), i1.GetType());
-                Assert.IsType((b2 - i2).GetType(), l1.GetType());
-                Assert.IsType((i2 - s1).GetType(), l1.GetType());
-                Assert.IsType((i2 - b1).GetType(), i2.GetType());
-                Assert.IsType((i2 - i1).GetType(), l1.GetType());
-                Assert.IsType((i2 - l1).GetType(), l1.GetType());
-                Assert.IsType((i2 - c1).GetType(), i2.GetType());
-                Assert.IsType((i2 - s2).GetType(), i2.GetType());
-                Assert.IsType((i2 - b2).GetType(), l1.GetType());
-                Assert.IsType((i2 - i2).GetType(), i2.GetType());
-                Assert.IsType((i2 - l2).GetType(), l2.GetType());
-                Assert.IsType((l2 - b1).GetType(), l2.GetType());
-                Assert.IsType((l2 - c1).GetType(), l2.GetType());
-                Assert.IsType((l2 - s2).GetType(), l2.GetType());
-                Assert.IsType((l2 - i2).GetType(), l2.GetType());
-                Assert.IsType((l2 - l2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((s2 - s1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 - i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 - l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((s2 - c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 - s2).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 - b2).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 - i2).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((s2 - l2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((b2 - s1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 - b1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 - i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 - l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((b2 - c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 - s2).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 - b2).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 - i2).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 - s1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 - b1).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((i2 - i1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 - l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 - c1).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((i2 - s2).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((i2 - b2).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 - i2).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((i2 - l2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 - b1).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 - c1).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 - s2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 - i2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 - l2).GetType(), l2.GetType());
             }
         }
         public class ValueIntegralTestClass51
@@ -1106,37 +1106,37 @@ public static void testMethod()
                 uint i2 = 9;
                 ulong l2 = 10;
                 //ushort
-                Assert.IsType((s2 * s1).GetType(), i1.GetType());
-                Assert.IsType((s2 * b1).GetType(), i1.GetType());
-                Assert.IsType((s2 * i1).GetType(), i1.GetType());
-                Assert.IsType((s2 * l1).GetType(), l1.GetType());
-                Assert.IsType((s2 * c1).GetType(), i1.GetType());
-                Assert.IsType((s2 * s2).GetType(), i1.GetType());
-                Assert.IsType((s2 * b2).GetType(), i1.GetType());
-                Assert.IsType((s2 * i2).GetType(), i2.GetType());
-                Assert.IsType((s2 * l2).GetType(), l2.GetType());
-                Assert.IsType((b2 * s1).GetType(), i1.GetType());
-                Assert.IsType((b2 * b1).GetType(), i1.GetType());
-                Assert.IsType((b2 * i1).GetType(), i1.GetType());
-                Assert.IsType((b2 * l1).GetType(), l1.GetType());
-                Assert.IsType((b2 * c1).GetType(), i1.GetType());
-                Assert.IsType((b2 * s2).GetType(), i1.GetType());
-                Assert.IsType((b2 * b2).GetType(), i1.GetType());
-                Assert.IsType((b2 * i2).GetType(), l1.GetType());
-                Assert.IsType((i2 * s1).GetType(), l1.GetType());
-                Assert.IsType((i2 * b1).GetType(), i2.GetType());
-                Assert.IsType((i2 * i1).GetType(), l1.GetType());
-                Assert.IsType((i2 * l1).GetType(), l1.GetType());
-                Assert.IsType((i2 * c1).GetType(), i2.GetType());
-                Assert.IsType((i2 * s2).GetType(), i2.GetType());
-                Assert.IsType((i2 * b2).GetType(), l1.GetType());
-                Assert.IsType((i2 * i2).GetType(), i2.GetType());
-                Assert.IsType((i2 * l2).GetType(), l2.GetType());
-                Assert.IsType((l2 * b1).GetType(), l2.GetType());
-                Assert.IsType((l2 * c1).GetType(), l2.GetType());
-                Assert.IsType((l2 * s2).GetType(), l2.GetType());
-                Assert.IsType((l2 * i2).GetType(), l2.GetType());
-                Assert.IsType((l2 * l2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((s2 * s1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 * b1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 * i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 * l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((s2 * c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 * s2).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 * b2).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 * i2).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((s2 * l2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((b2 * s1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 * b1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 * i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 * l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((b2 * c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 * s2).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 * b2).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 * i2).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 * s1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 * b1).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((i2 * i1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 * l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 * c1).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((i2 * s2).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((i2 * b2).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 * i2).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((i2 * l2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 * b1).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 * c1).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 * s2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 * i2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 * l2).GetType(), l2.GetType());
             }
         }
         public class ValueIntegralTestClass52
@@ -1153,37 +1153,37 @@ public static void testMethod()
                 uint i2 = 9;
                 ulong l2 = 10;
                 //ushort
-                Assert.IsType((s2 / s1).GetType(), i1.GetType());
-                Assert.IsType((s2 / b1).GetType(), i1.GetType());
-                Assert.IsType((s2 / i1).GetType(), i1.GetType());
-                Assert.IsType((s2 / l1).GetType(), l1.GetType());
-                Assert.IsType((s2 / c1).GetType(), i1.GetType());
-                Assert.IsType((s2 / s2).GetType(), i1.GetType());
-                Assert.IsType((s2 / b2).GetType(), i1.GetType());
-                Assert.IsType((s2 / i2).GetType(), i2.GetType());
-                Assert.IsType((s2 / l2).GetType(), l2.GetType());
-                Assert.IsType((b2 / s1).GetType(), i1.GetType());
-                Assert.IsType((b2 / b1).GetType(), i1.GetType());
-                Assert.IsType((b2 / i1).GetType(), i1.GetType());
-                Assert.IsType((b2 / l1).GetType(), l1.GetType());
-                Assert.IsType((b2 / c1).GetType(), i1.GetType());
-                Assert.IsType((b2 / s2).GetType(), i1.GetType());
-                Assert.IsType((b2 / b2).GetType(), i1.GetType());
-                Assert.IsType((b2 / i2).GetType(), l1.GetType());
-                Assert.IsType((i2 / s1).GetType(), l1.GetType());
-                Assert.IsType((i2 / b1).GetType(), i2.GetType());
-                Assert.IsType((i2 / i1).GetType(), l1.GetType());
-                Assert.IsType((i2 / l1).GetType(), l1.GetType());
-                Assert.IsType((i2 / c1).GetType(), i2.GetType());
-                Assert.IsType((i2 / s2).GetType(), i2.GetType());
-                Assert.IsType((i2 / b2).GetType(), l1.GetType());
-                Assert.IsType((i2 / i2).GetType(), i2.GetType());
-                Assert.IsType((i2 / l2).GetType(), l2.GetType());
-                Assert.IsType((l2 / b1).GetType(), l2.GetType());
-                Assert.IsType((l2 / c1).GetType(), l2.GetType());
-                Assert.IsType((l2 / s2).GetType(), l2.GetType());
-                Assert.IsType((l2 / i2).GetType(), l2.GetType());
-                Assert.IsType((l2 / l2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((s2 / s1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 / b1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 / i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 / l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((s2 / c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 / s2).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 / b2).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 / i2).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((s2 / l2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((b2 / s1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 / b1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 / i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 / l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((b2 / c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 / s2).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 / b2).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 / i2).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 / s1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 / b1).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((i2 / i1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 / l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 / c1).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((i2 / s2).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((i2 / b2).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 / i2).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((i2 / l2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 / b1).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 / c1).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 / s2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 / i2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 / l2).GetType(), l2.GetType());
             }
         }
         public class ValueIntegralTestClass53
@@ -1200,37 +1200,37 @@ public static void testMethod()
                 uint i2 = 9;
                 ulong l2 = 10;
                 //ushort
-                Assert.IsType((s2 % s1).GetType(), i1.GetType());
-                Assert.IsType((s2 % b1).GetType(), i1.GetType());
-                Assert.IsType((s2 % i1).GetType(), i1.GetType());
-                Assert.IsType((s2 % l1).GetType(), l1.GetType());
-                Assert.IsType((s2 % c1).GetType(), i1.GetType());
-                Assert.IsType((s2 % s2).GetType(), i1.GetType());
-                Assert.IsType((s2 % b2).GetType(), i1.GetType());
-                Assert.IsType((s2 % i2).GetType(), i2.GetType());
-                Assert.IsType((s2 % l2).GetType(), l2.GetType());
-                Assert.IsType((b2 % s1).GetType(), i1.GetType());
-                Assert.IsType((b2 % b1).GetType(), i1.GetType());
-                Assert.IsType((b2 % i1).GetType(), i1.GetType());
-                Assert.IsType((b2 % l1).GetType(), l1.GetType());
-                Assert.IsType((b2 % c1).GetType(), i1.GetType());
-                Assert.IsType((b2 % s2).GetType(), i1.GetType());
-                Assert.IsType((b2 % b2).GetType(), i1.GetType());
-                Assert.IsType((b2 % i2).GetType(), l1.GetType());
-                Assert.IsType((i2 % s1).GetType(), l1.GetType());
-                Assert.IsType((i2 % b1).GetType(), i2.GetType());
-                Assert.IsType((i2 % i1).GetType(), l1.GetType());
-                Assert.IsType((i2 % l1).GetType(), l1.GetType());
-                Assert.IsType((i2 % c1).GetType(), i2.GetType());
-                Assert.IsType((i2 % s2).GetType(), i2.GetType());
-                Assert.IsType((i2 % b2).GetType(), l1.GetType());
-                Assert.IsType((i2 % i2).GetType(), i2.GetType());
-                Assert.IsType((i2 % l2).GetType(), l2.GetType());
-                Assert.IsType((l2 % b1).GetType(), l2.GetType());
-                Assert.IsType((l2 % c1).GetType(), l2.GetType());
-                Assert.IsType((l2 % s2).GetType(), l2.GetType());
-                Assert.IsType((l2 % i2).GetType(), l2.GetType());
-                Assert.IsType((l2 % l2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((s2 % s1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 % b1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 % i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 % l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((s2 % c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 % s2).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 % b2).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 % i2).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((s2 % l2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((b2 % s1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 % b1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 % i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 % l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((b2 % c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 % s2).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 % b2).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 % i2).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 % s1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 % b1).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((i2 % i1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 % l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 % c1).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((i2 % s2).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((i2 % b2).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 % i2).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((i2 % l2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 % b1).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 % c1).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 % s2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 % i2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 % l2).GetType(), l2.GetType());
             }
         }
         public class ValueIntegralTestClass54
@@ -1247,37 +1247,37 @@ public static void testMethod()
                 uint i2 = 9;
                 ulong l2 = 10;
                 //ushort
-                Assert.IsType((s2 & s1).GetType(), i1.GetType());
-                Assert.IsType((s2 & b1).GetType(), i1.GetType());
-                Assert.IsType((s2 & i1).GetType(), i1.GetType());
-                Assert.IsType((s2 & l1).GetType(), l1.GetType());
-                Assert.IsType((s2 & c1).GetType(), i1.GetType());
-                Assert.IsType((s2 & s2).GetType(), i1.GetType());
-                Assert.IsType((s2 & b2).GetType(), i1.GetType());
-                Assert.IsType((s2 & i2).GetType(), i2.GetType());
-                Assert.IsType((s2 & l2).GetType(), l2.GetType());
-                Assert.IsType((b2 & s1).GetType(), i1.GetType());
-                Assert.IsType((b2 & b1).GetType(), i1.GetType());
-                Assert.IsType((b2 & i1).GetType(), i1.GetType());
-                Assert.IsType((b2 & l1).GetType(), l1.GetType());
-                Assert.IsType((b2 & c1).GetType(), i1.GetType());
-                Assert.IsType((b2 & s2).GetType(), i1.GetType());
-                Assert.IsType((b2 & b2).GetType(), i1.GetType());
-                Assert.IsType((b2 & i2).GetType(), l1.GetType());
-                Assert.IsType((i2 & s1).GetType(), l1.GetType());
-                Assert.IsType((i2 & b1).GetType(), i2.GetType());
-                Assert.IsType((i2 & i1).GetType(), l1.GetType());
-                Assert.IsType((i2 & l1).GetType(), l1.GetType());
-                Assert.IsType((i2 & c1).GetType(), i2.GetType());
-                Assert.IsType((i2 & s2).GetType(), i2.GetType());
-                Assert.IsType((i2 & b2).GetType(), l1.GetType());
-                Assert.IsType((i2 & i2).GetType(), i2.GetType());
-                Assert.IsType((i2 & l2).GetType(), l2.GetType());
-                Assert.IsType((l2 & b1).GetType(), l2.GetType());
-                Assert.IsType((l2 & c1).GetType(), l2.GetType());
-                Assert.IsType((l2 & s2).GetType(), l2.GetType());
-                Assert.IsType((l2 & i2).GetType(), l2.GetType());
-                Assert.IsType((l2 & l2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((s2 & s1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 & b1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 & i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 & l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((s2 & c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 & s2).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 & b2).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 & i2).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((s2 & l2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((b2 & s1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 & b1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 & i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 & l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((b2 & c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 & s2).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 & b2).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 & i2).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 & s1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 & b1).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((i2 & i1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 & l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 & c1).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((i2 & s2).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((i2 & b2).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 & i2).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((i2 & l2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 & b1).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 & c1).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 & s2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 & i2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 & l2).GetType(), l2.GetType());
             }
         }
         public class ValueIntegralTestClass55
@@ -1294,37 +1294,37 @@ public static void testMethod()
                 uint i2 = 9;
                 ulong l2 = 10;
                 //ushort
-                Assert.IsType((s2 ^ s1).GetType(), i1.GetType());
-                Assert.IsType((s2 ^ b1).GetType(), i1.GetType());
-                Assert.IsType((s2 ^ i1).GetType(), i1.GetType());
-                Assert.IsType((s2 ^ l1).GetType(), l1.GetType());
-                Assert.IsType((s2 ^ c1).GetType(), i1.GetType());
-                Assert.IsType((s2 ^ s2).GetType(), i1.GetType());
-                Assert.IsType((s2 ^ b2).GetType(), i1.GetType());
-                Assert.IsType((s2 ^ i2).GetType(), i2.GetType());
-                Assert.IsType((s2 ^ l2).GetType(), l2.GetType());
-                Assert.IsType((b2 ^ s1).GetType(), i1.GetType());
-                Assert.IsType((b2 ^ b1).GetType(), i1.GetType());
-                Assert.IsType((b2 ^ i1).GetType(), i1.GetType());
-                Assert.IsType((b2 ^ l1).GetType(), l1.GetType());
-                Assert.IsType((b2 ^ c1).GetType(), i1.GetType());
-                Assert.IsType((b2 ^ s2).GetType(), i1.GetType());
-                Assert.IsType((b2 ^ b2).GetType(), i1.GetType());
-                Assert.IsType((b2 ^ i2).GetType(), l1.GetType());
-                Assert.IsType((i2 ^ s1).GetType(), l1.GetType());
-                Assert.IsType((i2 ^ b1).GetType(), i2.GetType());
-                Assert.IsType((i2 ^ i1).GetType(), l1.GetType());
-                Assert.IsType((i2 ^ l1).GetType(), l1.GetType());
-                Assert.IsType((i2 ^ c1).GetType(), i2.GetType());
-                Assert.IsType((i2 ^ s2).GetType(), i2.GetType());
-                Assert.IsType((i2 ^ b2).GetType(), l1.GetType());
-                Assert.IsType((i2 ^ i2).GetType(), i2.GetType());
-                Assert.IsType((i2 ^ l2).GetType(), l2.GetType());
-                Assert.IsType((l2 ^ b1).GetType(), l2.GetType());
-                Assert.IsType((l2 ^ c1).GetType(), l2.GetType());
-                Assert.IsType((l2 ^ s2).GetType(), l2.GetType());
-                Assert.IsType((l2 ^ i2).GetType(), l2.GetType());
-                Assert.IsType((l2 ^ l2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((s2 ^ s1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 ^ b1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 ^ i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 ^ l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((s2 ^ c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 ^ s2).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 ^ b2).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 ^ i2).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((s2 ^ l2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((b2 ^ s1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 ^ b1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 ^ i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 ^ l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((b2 ^ c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 ^ s2).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 ^ b2).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 ^ i2).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 ^ s1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 ^ b1).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((i2 ^ i1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 ^ l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 ^ c1).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((i2 ^ s2).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((i2 ^ b2).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 ^ i2).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((i2 ^ l2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 ^ b1).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 ^ c1).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 ^ s2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 ^ i2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 ^ l2).GetType(), l2.GetType());
             }
         }
         public class ValueIntegralTestClass56
@@ -1341,37 +1341,37 @@ public static void testMethod()
                 uint i2 = 9;
                 ulong l2 = 10;
                 //ushort
-                Assert.IsType((s2 | s1).GetType(), i1.GetType());
-                Assert.IsType((s2 | b1).GetType(), i1.GetType());
-                Assert.IsType((s2 | i1).GetType(), i1.GetType());
-                Assert.IsType((s2 | l1).GetType(), l1.GetType());
-                Assert.IsType((s2 | c1).GetType(), i1.GetType());
-                Assert.IsType((s2 | s2).GetType(), i1.GetType());
-                Assert.IsType((s2 | b2).GetType(), i1.GetType());
-                Assert.IsType((s2 | i2).GetType(), i2.GetType());
-                Assert.IsType((s2 | l2).GetType(), l2.GetType());
-                Assert.IsType((b2 | s1).GetType(), i1.GetType());
-                Assert.IsType((b2 | b1).GetType(), i1.GetType());
-                Assert.IsType((b2 | i1).GetType(), i1.GetType());
-                Assert.IsType((b2 | l1).GetType(), l1.GetType());
-                Assert.IsType((b2 | c1).GetType(), i1.GetType());
-                Assert.IsType((b2 | s2).GetType(), i1.GetType());
-                Assert.IsType((b2 | b2).GetType(), i1.GetType());
-                Assert.IsType((b2 | i2).GetType(), l1.GetType());
-                Assert.IsType((i2 | s1).GetType(), l1.GetType());
-                Assert.IsType((i2 | b1).GetType(), i2.GetType());
-                Assert.IsType((i2 | i1).GetType(), l1.GetType());
-                Assert.IsType((i2 | l1).GetType(), l1.GetType());
-                Assert.IsType((i2 | c1).GetType(), i2.GetType());
-                Assert.IsType((i2 | s2).GetType(), i2.GetType());
-                Assert.IsType((i2 | b2).GetType(), l1.GetType());
-                Assert.IsType((i2 | i2).GetType(), i2.GetType());
-                Assert.IsType((i2 | l2).GetType(), l2.GetType());
-                Assert.IsType((l2 | b1).GetType(), l2.GetType());
-                Assert.IsType((l2 | c1).GetType(), l2.GetType());
-                Assert.IsType((l2 | s2).GetType(), l2.GetType());
-                Assert.IsType((l2 | i2).GetType(), l2.GetType());
-                Assert.IsType((l2 | l2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((s2 | s1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 | b1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 | i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 | l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((s2 | c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 | s2).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 | b2).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((s2 | i2).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((s2 | l2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((b2 | s1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 | b1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 | i1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 | l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((b2 | c1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 | s2).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 | b2).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((b2 | i2).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 | s1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 | b1).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((i2 | i1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 | l1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 | c1).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((i2 | s2).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((i2 | b2).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((i2 | i2).GetType(), i2.GetType());
+                Assert.IsInstanceOfType((i2 | l2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 | b1).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 | c1).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 | s2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 | i2).GetType(), l2.GetType());
+                Assert.IsInstanceOfType((l2 | l2).GetType(), l2.GetType());
             }
         }
         public class ValueIntegralTestClass57
@@ -1389,37 +1389,37 @@ public static void testMethod()
                 ulong l2 = 10;
                 bool b = true;
                 //ushort
-                Assert.IsType((s2 == s1).GetType(), b.GetType());
-                Assert.IsType((s2 == b1).GetType(), b.GetType());
-                Assert.IsType((s2 == i1).GetType(), b.GetType());
-                Assert.IsType((s2 == l1).GetType(), b.GetType());
-                Assert.IsType((s2 == c1).GetType(), b.GetType());
-                Assert.IsType((s2 == s2).GetType(), b.GetType());
-                Assert.IsType((s2 == b2).GetType(), b.GetType());
-                Assert.IsType((s2 == i2).GetType(), b.GetType());
-                Assert.IsType((s2 == l2).GetType(), b.GetType());
-                Assert.IsType((b2 == s1).GetType(), b.GetType());
-                Assert.IsType((b2 == b1).GetType(), b.GetType());
-                Assert.IsType((b2 == i1).GetType(), b.GetType());
-                Assert.IsType((b2 == l1).GetType(), b.GetType());
-                Assert.IsType((b2 == c1).GetType(), b.GetType());
-                Assert.IsType((b2 == s2).GetType(), b.GetType());
-                Assert.IsType((b2 == b2).GetType(), b.GetType());
-                Assert.IsType((b2 == i2).GetType(), b.GetType());
-                Assert.IsType((i2 == s1).GetType(), b.GetType());
-                Assert.IsType((i2 == b1).GetType(), b.GetType());
-                Assert.IsType((i2 == i1).GetType(), b.GetType());
-                Assert.IsType((i2 == l1).GetType(), b.GetType());
-                Assert.IsType((i2 == c1).GetType(), b.GetType());
-                Assert.IsType((i2 == s2).GetType(), b.GetType());
-                Assert.IsType((i2 == b2).GetType(), b.GetType());
-                Assert.IsType((i2 == i2).GetType(), b.GetType());
-                Assert.IsType((i2 == l2).GetType(), b.GetType());
-                Assert.IsType((l2 == b1).GetType(), b.GetType());
-                Assert.IsType((l2 == c1).GetType(), b.GetType());
-                Assert.IsType((l2 == s2).GetType(), b.GetType());
-                Assert.IsType((l2 == i2).GetType(), b.GetType());
-                Assert.IsType((l2 == l2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 == s1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 == b1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 == i1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 == l1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 == c1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 == s2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 == b2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 == i2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 == l2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 == s1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 == b1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 == i1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 == l1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 == c1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 == s2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 == b2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 == i2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 == s1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 == b1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 == i1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 == l1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 == c1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 == s2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 == b2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 == i2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 == l2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l2 == b1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l2 == c1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l2 == s2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l2 == i2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l2 == l2).GetType(), b.GetType());
             }
         }
         public class ValueIntegralTestClass58
@@ -1437,37 +1437,37 @@ public static void testMethod()
                 ulong l2 = 10;
                 bool b = true;
                 //ushort
-                Assert.IsType((s2 != s1).GetType(), b.GetType());
-                Assert.IsType((s2 != b1).GetType(), b.GetType());
-                Assert.IsType((s2 != i1).GetType(), b.GetType());
-                Assert.IsType((s2 != l1).GetType(), b.GetType());
-                Assert.IsType((s2 != c1).GetType(), b.GetType());
-                Assert.IsType((s2 != s2).GetType(), b.GetType());
-                Assert.IsType((s2 != b2).GetType(), b.GetType());
-                Assert.IsType((s2 != i2).GetType(), b.GetType());
-                Assert.IsType((s2 != l2).GetType(), b.GetType());
-                Assert.IsType((b2 != s1).GetType(), b.GetType());
-                Assert.IsType((b2 != b1).GetType(), b.GetType());
-                Assert.IsType((b2 != i1).GetType(), b.GetType());
-                Assert.IsType((b2 != l1).GetType(), b.GetType());
-                Assert.IsType((b2 != c1).GetType(), b.GetType());
-                Assert.IsType((b2 != s2).GetType(), b.GetType());
-                Assert.IsType((b2 != b2).GetType(), b.GetType());
-                Assert.IsType((b2 != i2).GetType(), b.GetType());
-                Assert.IsType((i2 != s1).GetType(), b.GetType());
-                Assert.IsType((i2 != b1).GetType(), b.GetType());
-                Assert.IsType((i2 != i1).GetType(), b.GetType());
-                Assert.IsType((i2 != l1).GetType(), b.GetType());
-                Assert.IsType((i2 != c1).GetType(), b.GetType());
-                Assert.IsType((i2 != s2).GetType(), b.GetType());
-                Assert.IsType((i2 != b2).GetType(), b.GetType());
-                Assert.IsType((i2 != i2).GetType(), b.GetType());
-                Assert.IsType((i2 != l2).GetType(), b.GetType());
-                Assert.IsType((l2 != b1).GetType(), b.GetType());
-                Assert.IsType((l2 != c1).GetType(), b.GetType());
-                Assert.IsType((l2 != s2).GetType(), b.GetType());
-                Assert.IsType((l2 != i2).GetType(), b.GetType());
-                Assert.IsType((l2 != l2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 != s1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 != b1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 != i1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 != l1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 != c1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 != s2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 != b2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 != i2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 != l2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 != s1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 != b1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 != i1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 != l1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 != c1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 != s2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 != b2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 != i2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 != s1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 != b1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 != i1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 != l1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 != c1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 != s2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 != b2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 != i2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 != l2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l2 != b1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l2 != c1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l2 != s2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l2 != i2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l2 != l2).GetType(), b.GetType());
             }
         }
         public class ValueIntegralTestClass59
@@ -1485,37 +1485,37 @@ public static void testMethod()
                 ulong l2 = 10;
                 bool b = true;
                 //ushort
-                Assert.IsType((s2 > s1).GetType(), b.GetType());
-                Assert.IsType((s2 > b1).GetType(), b.GetType());
-                Assert.IsType((s2 > i1).GetType(), b.GetType());
-                Assert.IsType((s2 > l1).GetType(), b.GetType());
-                Assert.IsType((s2 > c1).GetType(), b.GetType());
-                Assert.IsType((s2 > s2).GetType(), b.GetType());
-                Assert.IsType((s2 > b2).GetType(), b.GetType());
-                Assert.IsType((s2 > i2).GetType(), b.GetType());
-                Assert.IsType((s2 > l2).GetType(), b.GetType());
-                Assert.IsType((b2 > s1).GetType(), b.GetType());
-                Assert.IsType((b2 > b1).GetType(), b.GetType());
-                Assert.IsType((b2 > i1).GetType(), b.GetType());
-                Assert.IsType((b2 > l1).GetType(), b.GetType());
-                Assert.IsType((b2 > c1).GetType(), b.GetType());
-                Assert.IsType((b2 > s2).GetType(), b.GetType());
-                Assert.IsType((b2 > b2).GetType(), b.GetType());
-                Assert.IsType((b2 > i2).GetType(), b.GetType());
-                Assert.IsType((i2 > s1).GetType(), b.GetType());
-                Assert.IsType((i2 > b1).GetType(), b.GetType());
-                Assert.IsType((i2 > i1).GetType(), b.GetType());
-                Assert.IsType((i2 > l1).GetType(), b.GetType());
-                Assert.IsType((i2 > c1).GetType(), b.GetType());
-                Assert.IsType((i2 > s2).GetType(), b.GetType());
-                Assert.IsType((i2 > b2).GetType(), b.GetType());
-                Assert.IsType((i2 > i2).GetType(), b.GetType());
-                Assert.IsType((i2 > l2).GetType(), b.GetType());
-                Assert.IsType((l2 > b1).GetType(), b.GetType());
-                Assert.IsType((l2 > c1).GetType(), b.GetType());
-                Assert.IsType((l2 > s2).GetType(), b.GetType());
-                Assert.IsType((l2 > i2).GetType(), b.GetType());
-                Assert.IsType((l2 > l2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 > s1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 > b1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 > i1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 > l1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 > c1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 > s2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 > b2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 > i2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 > l2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 > s1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 > b1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 > i1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 > l1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 > c1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 > s2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 > b2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 > i2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 > s1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 > b1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 > i1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 > l1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 > c1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 > s2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 > b2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 > i2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 > l2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l2 > b1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l2 > c1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l2 > s2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l2 > i2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l2 > l2).GetType(), b.GetType());
             }
         }
         public class ValueIntegralTestClass60
@@ -1533,37 +1533,37 @@ public static void testMethod()
                 ulong l2 = 10;
                 bool b = true;
                 //ushort
-                Assert.IsType((s2 < s1).GetType(), b.GetType());
-                Assert.IsType((s2 < b1).GetType(), b.GetType());
-                Assert.IsType((s2 < i1).GetType(), b.GetType());
-                Assert.IsType((s2 < l1).GetType(), b.GetType());
-                Assert.IsType((s2 < c1).GetType(), b.GetType());
-                Assert.IsType((s2 < s2).GetType(), b.GetType());
-                Assert.IsType((s2 < b2).GetType(), b.GetType());
-                Assert.IsType((s2 < i2).GetType(), b.GetType());
-                Assert.IsType((s2 < l2).GetType(), b.GetType());
-                Assert.IsType((b2 < s1).GetType(), b.GetType());
-                Assert.IsType((b2 < b1).GetType(), b.GetType());
-                Assert.IsType((b2 < i1).GetType(), b.GetType());
-                Assert.IsType((b2 < l1).GetType(), b.GetType());
-                Assert.IsType((b2 < c1).GetType(), b.GetType());
-                Assert.IsType((b2 < s2).GetType(), b.GetType());
-                Assert.IsType((b2 < b2).GetType(), b.GetType());
-                Assert.IsType((b2 < i2).GetType(), b.GetType());
-                Assert.IsType((i2 < s1).GetType(), b.GetType());
-                Assert.IsType((i2 < b1).GetType(), b.GetType());
-                Assert.IsType((i2 < i1).GetType(), b.GetType());
-                Assert.IsType((i2 < l1).GetType(), b.GetType());
-                Assert.IsType((i2 < c1).GetType(), b.GetType());
-                Assert.IsType((i2 < s2).GetType(), b.GetType());
-                Assert.IsType((i2 < b2).GetType(), b.GetType());
-                Assert.IsType((i2 < i2).GetType(), b.GetType());
-                Assert.IsType((i2 < l2).GetType(), b.GetType());
-                Assert.IsType((l2 < b1).GetType(), b.GetType());
-                Assert.IsType((l2 < c1).GetType(), b.GetType());
-                Assert.IsType((l2 < s2).GetType(), b.GetType());
-                Assert.IsType((l2 < i2).GetType(), b.GetType());
-                Assert.IsType((l2 < l2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 < s1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 < b1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 < i1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 < l1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 < c1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 < s2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 < b2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 < i2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 < l2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 < s1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 < b1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 < i1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 < l1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 < c1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 < s2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 < b2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 < i2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 < s1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 < b1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 < i1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 < l1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 < c1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 < s2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 < b2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 < i2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 < l2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l2 < b1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l2 < c1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l2 < s2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l2 < i2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l2 < l2).GetType(), b.GetType());
             }
         }
         public class ValueIntegralTestClass61
@@ -1581,37 +1581,37 @@ public static void testMethod()
                 ulong l2 = 10;
                 bool b = true;
                 //ushort
-                Assert.IsType((s2 >= s1).GetType(), b.GetType());
-                Assert.IsType((s2 >= b1).GetType(), b.GetType());
-                Assert.IsType((s2 >= i1).GetType(), b.GetType());
-                Assert.IsType((s2 >= l1).GetType(), b.GetType());
-                Assert.IsType((s2 >= c1).GetType(), b.GetType());
-                Assert.IsType((s2 >= s2).GetType(), b.GetType());
-                Assert.IsType((s2 >= b2).GetType(), b.GetType());
-                Assert.IsType((s2 >= i2).GetType(), b.GetType());
-                Assert.IsType((s2 >= l2).GetType(), b.GetType());
-                Assert.IsType((b2 >= s1).GetType(), b.GetType());
-                Assert.IsType((b2 >= b1).GetType(), b.GetType());
-                Assert.IsType((b2 >= i1).GetType(), b.GetType());
-                Assert.IsType((b2 >= l1).GetType(), b.GetType());
-                Assert.IsType((b2 >= c1).GetType(), b.GetType());
-                Assert.IsType((b2 >= s2).GetType(), b.GetType());
-                Assert.IsType((b2 >= b2).GetType(), b.GetType());
-                Assert.IsType((b2 >= i2).GetType(), b.GetType());
-                Assert.IsType((i2 >= s1).GetType(), b.GetType());
-                Assert.IsType((i2 >= b1).GetType(), b.GetType());
-                Assert.IsType((i2 >= i1).GetType(), b.GetType());
-                Assert.IsType((i2 >= l1).GetType(), b.GetType());
-                Assert.IsType((i2 >= c1).GetType(), b.GetType());
-                Assert.IsType((i2 >= s2).GetType(), b.GetType());
-                Assert.IsType((i2 >= b2).GetType(), b.GetType());
-                Assert.IsType((i2 >= i2).GetType(), b.GetType());
-                Assert.IsType((i2 >= l2).GetType(), b.GetType());
-                Assert.IsType((l2 >= b1).GetType(), b.GetType());
-                Assert.IsType((l2 >= c1).GetType(), b.GetType());
-                Assert.IsType((l2 >= s2).GetType(), b.GetType());
-                Assert.IsType((l2 >= i2).GetType(), b.GetType());
-                Assert.IsType((l2 >= l2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 >= s1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 >= b1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 >= i1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 >= l1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 >= c1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 >= s2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 >= b2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 >= i2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 >= l2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 >= s1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 >= b1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 >= i1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 >= l1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 >= c1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 >= s2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 >= b2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 >= i2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 >= s1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 >= b1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 >= i1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 >= l1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 >= c1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 >= s2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 >= b2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 >= i2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 >= l2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l2 >= b1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l2 >= c1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l2 >= s2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l2 >= i2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l2 >= l2).GetType(), b.GetType());
             }
         }
         public class ValueIntegralTestClass62
@@ -1629,37 +1629,37 @@ public static void testMethod()
                 ulong l2 = 10;
                 bool b = true;
                 //ushort
-                Assert.IsType((s2 <= s1).GetType(), b.GetType());
-                Assert.IsType((s2 <= b1).GetType(), b.GetType());
-                Assert.IsType((s2 <= i1).GetType(), b.GetType());
-                Assert.IsType((s2 <= l1).GetType(), b.GetType());
-                Assert.IsType((s2 <= c1).GetType(), b.GetType());
-                Assert.IsType((s2 <= s2).GetType(), b.GetType());
-                Assert.IsType((s2 <= b2).GetType(), b.GetType());
-                Assert.IsType((s2 <= i2).GetType(), b.GetType());
-                Assert.IsType((s2 <= l2).GetType(), b.GetType());
-                Assert.IsType((b2 <= s1).GetType(), b.GetType());
-                Assert.IsType((b2 <= b1).GetType(), b.GetType());
-                Assert.IsType((b2 <= i1).GetType(), b.GetType());
-                Assert.IsType((b2 <= l1).GetType(), b.GetType());
-                Assert.IsType((b2 <= c1).GetType(), b.GetType());
-                Assert.IsType((b2 <= s2).GetType(), b.GetType());
-                Assert.IsType((b2 <= b2).GetType(), b.GetType());
-                Assert.IsType((b2 <= i2).GetType(), b.GetType());
-                Assert.IsType((i2 <= s1).GetType(), b.GetType());
-                Assert.IsType((i2 <= b1).GetType(), b.GetType());
-                Assert.IsType((i2 <= i1).GetType(), b.GetType());
-                Assert.IsType((i2 <= l1).GetType(), b.GetType());
-                Assert.IsType((i2 <= c1).GetType(), b.GetType());
-                Assert.IsType((i2 <= s2).GetType(), b.GetType());
-                Assert.IsType((i2 <= b2).GetType(), b.GetType());
-                Assert.IsType((i2 <= i2).GetType(), b.GetType());
-                Assert.IsType((i2 <= l2).GetType(), b.GetType());
-                Assert.IsType((l2 <= b1).GetType(), b.GetType());
-                Assert.IsType((l2 <= c1).GetType(), b.GetType());
-                Assert.IsType((l2 <= s2).GetType(), b.GetType());
-                Assert.IsType((l2 <= i2).GetType(), b.GetType());
-                Assert.IsType((l2 <= l2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 <= s1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 <= b1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 <= i1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 <= l1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 <= c1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 <= s2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 <= b2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 <= i2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((s2 <= l2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 <= s1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 <= b1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 <= i1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 <= l1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 <= c1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 <= s2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 <= b2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((b2 <= i2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 <= s1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 <= b1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 <= i1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 <= l1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 <= c1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 <= s2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 <= b2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 <= i2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((i2 <= l2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l2 <= b1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l2 <= c1).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l2 <= s2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l2 <= i2).GetType(), b.GetType());
+                Assert.IsInstanceOfType((l2 <= l2).GetType(), b.GetType());
             }
         }
         public class ValueIntegralTestClass63
@@ -1672,10 +1672,10 @@ public static void testMethod()
                 ulong l1 = 5L;
                 int i = 1;
 
-                Assert.IsType((s1 << 1).GetType(), i.GetType());
-                Assert.IsType((b1 << 1).GetType(), i.GetType());
-                Assert.IsType((i1 << 1).GetType(), i1.GetType());
-                Assert.IsType((l1 << 1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((s1 << 1).GetType(), i.GetType());
+                Assert.IsInstanceOfType((b1 << 1).GetType(), i.GetType());
+                Assert.IsInstanceOfType((i1 << 1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((l1 << 1).GetType(), l1.GetType());
             }
         }
         public class ValueIntegralTestClass64
@@ -1688,10 +1688,10 @@ public static void testMethod()
                 ulong l1 = 5L;
                 int i = 1;
 
-                Assert.IsType((s1 >> 1).GetType(), i.GetType());
-                Assert.IsType((b1 >> 1).GetType(), i.GetType());
-                Assert.IsType((i1 >> 1).GetType(), i1.GetType());
-                Assert.IsType((l1 >> 1).GetType(), l1.GetType());
+                Assert.IsInstanceOfType((s1 >> 1).GetType(), i.GetType());
+                Assert.IsInstanceOfType((b1 >> 1).GetType(), i.GetType());
+                Assert.IsInstanceOfType((i1 >> 1).GetType(), i1.GetType());
+                Assert.IsInstanceOfType((l1 >> 1).GetType(), l1.GetType());
             }
         }
         public class ValueIntegralTestClass70
diff --git a/Tests/NFUnitTestTypes/UnitTestValueSimpleTests.cs b/Tests/NFUnitTestTypes/UnitTestValueSimpleTests.cs
index 803e6ca..8dcb704 100644
--- a/Tests/NFUnitTestTypes/UnitTestValueSimpleTests.cs
+++ b/Tests/NFUnitTestTypes/UnitTestValueSimpleTests.cs
@@ -110,64 +110,56 @@ public class ValueSimpleTestClass01
         {
             public static void testMethod()
             {
-                byte b = 0;
-                Assert.IsType(Type.GetType("System.Byte"), b);
+                Assert.IsInstanceOfType(Type.GetType("System.Byte"), typeof(byte));
             }
         }
         public class ValueSimpleTestClass02
         {
             public static void testMethod()
             {
-                char c = 'a';
-                Assert.IsType(Type.GetType("System.Char"), c);
+                Assert.IsInstanceOfType(Type.GetType("System.Char"), typeof(char));
             }
         }
         public class ValueSimpleTestClass03
         {
             public static void testMethod()
             {
-                short s = 0;
-                Assert.IsType(Type.GetType("System.Int16"), s);
+                Assert.IsInstanceOfType(Type.GetType("System.Int16"), typeof(short));
             }
         }
         public class ValueSimpleTestClass04
         {
             public static void testMethod()
             {
-                int i = 0;
-                Assert.IsType(Type.GetType("System.Int32"), i);
+                Assert.IsInstanceOfType(Type.GetType("System.Int32"), typeof(int));
             }
         }
         public class ValueSimpleTestClass05
         {
             public static void testMethod()
             {
-                long l = 0L;
-                Assert.IsType(Type.GetType("System.Int64"), l);
+                Assert.IsInstanceOfType(Type.GetType("System.Int64"), typeof(long));
             }
         }
         public class ValueSimpleTestClass06
         {
             public static void testMethod()
             {
-                float f = 0.0f;
-                Assert.IsType(Type.GetType("System.Single"), f);
+                Assert.IsInstanceOfType(Type.GetType("System.Single"), typeof(float));
             }
         }
         public class ValueSimpleTestClass07
         {
             public static void testMethod()
             {
-                double d = 0.0d;
-                Assert.IsType(Type.GetType("System.Double"), d);
+                Assert.IsInstanceOfType(Type.GetType("System.Double"), typeof(double));
             }
         }
         public class ValueSimpleTestClass09
         {
             public static void testMethod()
             {
-                bool b = true;
-                Assert.IsType(Type.GetType("System.Boolean"), b);
+                Assert.IsInstanceOfType(Type.GetType("System.Boolean"), typeof(bool));
             }
         }
         public class ValueSimpleTestClass11
@@ -197,24 +189,21 @@ public class ValueSimpleTestClass13
         {
             public static void testMethod()
             {
-                sbyte sb = 0;
-                Assert.IsType(Type.GetType("System.SByte"), sb);
+                Assert.IsInstanceOfType(Type.GetType("System.SByte"), typeof(sbyte));
             }
         }
         public class ValueSimpleTestClass14
         {
             public static void testMethod()
             {
-                ushort us = 0;
-                Assert.IsType(Type.GetType("System.UInt16"), us);
+                Assert.IsInstanceOfType(Type.GetType("System.UInt16"), typeof(ushort));
             }
         }
         public class ValueSimpleTestClass15
         {
             public static void testMethod()
             {
-                uint ui = 0;
-                Assert.IsType(Type.GetType("System.UInt32"), ui);
+                Assert.IsInstanceOfType(Type.GetType("System.UInt32"), typeof(uint));
             }
         }