From aab82c4cf37b486de85a1b97953d5ed2931e233b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jos=C3=A9=20Sim=C3=B5es?= Date: Wed, 17 May 2023 01:43:36 +0100 Subject: [PATCH] Fixing several unit tests --- Tests/NFUnitTestArithmetic/UnitTestFormat.cs | 211 ++++++++++-------- .../UnitTestConvertTests.cs | 189 +++++++--------- Tests/NFUnitTestSystemLib/UnitTestDateTime.cs | 2 +- Tests/NFUnitTestSystemLib/UnitTestDouble.cs | 9 +- .../NFUnitTestSystemLib/UnitTestTypeTests.cs | 74 +++--- 5 files changed, 245 insertions(+), 240 deletions(-) diff --git a/Tests/NFUnitTestArithmetic/UnitTestFormat.cs b/Tests/NFUnitTestArithmetic/UnitTestFormat.cs index fb840c30..49b4b2a0 100644 --- a/Tests/NFUnitTestArithmetic/UnitTestFormat.cs +++ b/Tests/NFUnitTestArithmetic/UnitTestFormat.cs @@ -128,9 +128,9 @@ public void FixedFormat() // the E format can be used with all number types [DataRow("0", "E", "0.000000E+000", true, true, true)] [DataRow("0", "E4", "0.0000E+000", true, true, true)] - [DataRow("12345.6789", "E", "1.234567E+004", true, true, false)] - [DataRow("12345.678", "E6", "1.234567E+004", true, true, false)] - [DataRow("12345.6789", "e4", "1.2345e+004", true, true, false)] + [DataRow("12345.6789", "E", "1.234568E+004", true, true, false)] + [DataRow("12345.678", "E6", "1.234568E+004", true, true, false)] + [DataRow("12345.6789", "e4", "1.2346e+004", true, true, false)] [DataRow("123", "E", "1.230000E+002", true, true, true)] [DataRow("-123", "E", "-1.230000E+002", true, true, true)] [DataRow("1.2345e-9", "E", "1.234500E-009", true, false, false)] @@ -176,36 +176,64 @@ public void ExponentialFormat(string valueStr, string formatString, string expec [TestMethod] // the G format can be used with all number types - public void GeneralFormat() + [DataRow("0", "G", "0", false, false, true)] + [DataRow("0", "G4", "0", false, false, true)] + [DataRow("123", "G", "123", false, false, true)] + [DataRow("129", "G", "129", false, false, true)] + [DataRow("-129", "G", "-129", false, false, true)] + [DataRow("128", "G", "128", false, false, true)] + [DataRow("128", "G4", "128", false, false, true)] + [DataRow("-128", "G", "-128", false, false, true)] + [DataRow("-128", "G2", "-1.3E+02", false, false, true)] + [DataRow("1234", "G2", "1.2E+03", false, false, false)] + [DataRow("-1234", "G", "-1234", true, false, true)] + [DataRow("1234", "G6", "1234", true, false, true)] + [DataRow("-1234", "G6", "-1234", true, false, true)] + [DataRow("123.78", "G3", "124", true, true, false)] + [DataRow("123.7841", "G5", "123.78", true, true, false)] + [DataRow("123.7851", "G5", "123.79", true, true, false)] + [DataRow("123.78", "G5", "123.78", true, true, false)] + [DataRow("123.78", "G4", "123.8", true, true, false)] + [DataRow("1234.8999", "G5", "1234.9", true, true, false)] + [DataRow("1234.8999", "G6", "1234.9", true, true, false)] + [DataRow("1234.8999", "G7", "1234.9", true, true, false)] + [DataRow("-1234.901", "G7", "-1234.901", true, true, false)] + [DataRow("1.2345E-09", "G", "1.2345E-09", true, false, false)] + [DataRow("1.7976931348623157E+275", "G", "1.7976931348623157E+275", true, false, false)] + [DataRow("-1.7976931348623157E+275", "G", "-1.7976931348623157E+275", true, false, false)] + public void GeneralFormat(string valueStr, string formatString, string expectedResult, bool testDouble, bool testSingle, bool testIntegers) { - sampleDisplay = new SampleDisplay(); + double value = double.Parse(valueStr); - TestFormat("0", "G", "0"); - TestFormat("0", "G4", "0"); - TestFormat("123", "G", "123"); - TestFormat("129", "G", "129"); - TestFormat("-129", "G", "-129"); - TestFormat("128", "G", "128"); - TestFormat("128", "G4", "128"); - TestFormat("-128", "G", "-128"); - TestFormat("-128", "G2", "-1.3E+02"); - TestFormat("1234", "G2", "1.2E+03"); - TestFormat("-1234", "G", "-1234"); - TestFormat("1234", "G6", "1234"); - TestFormat("-1234", "G6", "-1234"); - TestFormat("123.78", "G3", "124"); - TestFormat("123.7841", "G5", "123.78"); - TestFormat("123.7851", "G5", "123.79"); - TestFormat("123.78", "G5", "123.78"); - TestFormat("123.78", "G4", "123.8"); - TestFormat("1234.8999", "G5", "1234.9"); - TestFormat("1234.8999", "G6", "1234.9"); - TestFormat("1234.8999", "G7", "1234.9"); - TestFormat("-1234.901", "G7", "-1234.901"); - TestFormat("1.2345E-9", "G", "1.2345E-09"); - sampleDisplay.WriteOutput(); + if (testDouble) + { + CheckValue(double.Parse(valueStr), valueStr, formatString, expectedResult, ColumnType.Double, null); + Assert.IsTrue(double.TryParse(valueStr, out double result), $"TryParse failed for double {valueStr}"); + CheckValue(result, valueStr, formatString, expectedResult, ColumnType.Double, null); + } + + if (testSingle) + { + CheckValue(float.Parse(valueStr), valueStr, formatString, expectedResult, ColumnType.Single, null); + Assert.IsTrue(float.TryParse(valueStr, out float result), $"TryParse failed for float {valueStr}"); + CheckValue(result, valueStr, formatString, expectedResult, ColumnType.Single, null); + } + if (testIntegers) + { + // can't test negative values with UInt64 + if (value > 0) + { + CheckValue(ulong.Parse(valueStr), valueStr, formatString, expectedResult, ColumnType.UInt64, null); + Assert.IsTrue(ulong.TryParse(valueStr, out ulong result), $"TryParse failed for ulong {valueStr}"); + CheckValue(result, valueStr, formatString, expectedResult, ColumnType.UInt64, null); + } + + CheckValue(long.Parse(valueStr), valueStr, formatString, expectedResult, ColumnType.Int64, null); + Assert.IsTrue(long.TryParse(valueStr, out long result1), $"TryParse failed for long {valueStr}"); + CheckValue(result1, valueStr, formatString, expectedResult, ColumnType.Int64, null); + } } [TestMethod] @@ -235,7 +263,7 @@ public void NumberFormat() [TestMethod] // the X format can only be used with integer number types - public void HexFormat() + public void HexFormat_00() { sampleDisplay = new SampleDisplay(); @@ -248,9 +276,7 @@ public void HexFormat() TestFormat(" 127", "X", "7F"); TestFormat(" 129", "X", "81"); - TestFormat(" 128", "X4", "0080"); TestFormat(" 1234", "X", "4D2"); - TestFormat(" 1234", "X6", "0004D2"); TestFormat(" -127", "X", "81"); TestFormat(" -128", "X", "80"); TestFormat(" -128", "X4", "80"); @@ -261,11 +287,18 @@ public void HexFormat() sampleDisplay.WriteOutput(); } + [TestMethod] + // the X format can only be used with integer number types + public void HexFormat_01() + { + Assert.AreEqual("0080", int.Parse(" 128").ToString("X4"), "Wrong output for 128 X4"); + Assert.AreEqual("0004D2", int.Parse(" 1234").ToString("X6"), "Wrong output for 1234 X6"); + } #region Helper functions private void TestFormat(string valueStr, string formatString, string expectedResult, Case formatCase = Case.Both) { - double value = Double.Parse(valueStr); // !!! does not return a negative number when parsed if string value does not contain a decimal point + double value = double.Parse(valueStr); // !!! does not return a negative number when parsed if string value does not contain a decimal point bool isNegative = false; NumType numType = NumType.All; @@ -311,120 +344,120 @@ private void TestFormat(string valueStr, string formatString, string expectedRes private void TestFormatInner(string valueStr, string formatString, string expectedResult, NumType numType, bool isNegative) { - SampleDisplay.RowData rowData = sampleDisplay.AddRow(valueStr, formatString); - double value = Double.Parse(valueStr); - if (value <= SByte.MaxValue - && value >= SByte.MinValue + RowData rowData = sampleDisplay.AddRow(valueStr, formatString); + double value = double.Parse(valueStr); + if (value <= sbyte.MaxValue + && value >= sbyte.MinValue && (numType == NumType.IntOnly || numType == NumType.All) ) { - CheckValue(sbyte.Parse(valueStr), valueStr, formatString, expectedResult, SampleDisplay.ColumnType.SByte, rowData); + CheckValue(sbyte.Parse(valueStr), valueStr, formatString, expectedResult, ColumnType.SByte, rowData); Assert.IsTrue(sbyte.TryParse(valueStr, out sbyte result), $"TryParse failed for sbyte {valueStr}"); - CheckValue(result, valueStr, formatString, expectedResult, SampleDisplay.ColumnType.SByte, rowData); + CheckValue(result, valueStr, formatString, expectedResult, ColumnType.SByte, rowData); } - if (value <= Int16.MaxValue - && value >= Int16.MinValue + if (value <= short.MaxValue + && value >= short.MinValue && (numType == NumType.IntOnly || numType == NumType.All) ) { - CheckValue(short.Parse(valueStr), valueStr, formatString, expectedResult, SampleDisplay.ColumnType.Int16, rowData); + CheckValue(short.Parse(valueStr), valueStr, formatString, expectedResult, ColumnType.Int16, rowData); Assert.IsTrue(short.TryParse(valueStr, out short result), $"TryParse failed for short {valueStr}"); - CheckValue(result, valueStr, formatString, expectedResult, SampleDisplay.ColumnType.Int16, rowData); + CheckValue(result, valueStr, formatString, expectedResult, ColumnType.Int16, rowData); } - if (value <= Int32.MaxValue - && value >= Int32.MinValue + if (value <= int.MaxValue + && value >= int.MinValue && (numType == NumType.IntOnly || numType == NumType.All) ) { - CheckValue(int.Parse(valueStr), valueStr, formatString, expectedResult, SampleDisplay.ColumnType.Int32, rowData); + CheckValue(int.Parse(valueStr), valueStr, formatString, expectedResult, ColumnType.Int32, rowData); Assert.IsTrue(int.TryParse(valueStr, out int result), $"TryParse failed for int {valueStr}"); - CheckValue(result, valueStr, formatString, expectedResult, SampleDisplay.ColumnType.Int32, rowData); + CheckValue(result, valueStr, formatString, expectedResult, ColumnType.Int32, rowData); } - if (value <= Int64.MaxValue - && value >= Int64.MinValue + if (value <= long.MaxValue + && value >= long.MinValue && (numType == NumType.IntOnly || numType == NumType.All) ) { - CheckValue(long.Parse(valueStr), valueStr, formatString, expectedResult, SampleDisplay.ColumnType.Int64, rowData); + CheckValue(long.Parse(valueStr), valueStr, formatString, expectedResult, ColumnType.Int64, rowData); Assert.IsTrue(long.TryParse(valueStr, out long result), $"TryParse failed for long {valueStr}"); - CheckValue(result, valueStr, formatString, expectedResult, SampleDisplay.ColumnType.Int64, rowData); + CheckValue(result, valueStr, formatString, expectedResult, ColumnType.Int64, rowData); } - if (value <= Byte.MaxValue - && value >= Byte.MinValue + if (value <= byte.MaxValue + && value >= byte.MinValue && (numType == NumType.IntOnly || numType == NumType.All) && !isNegative) { - CheckValue(byte.Parse(valueStr), valueStr, formatString, expectedResult, SampleDisplay.ColumnType.Byte, rowData); + CheckValue(byte.Parse(valueStr), valueStr, formatString, expectedResult, ColumnType.Byte, rowData); Assert.IsTrue(byte.TryParse(valueStr, out byte result), $"TryParse failed for byte {valueStr}"); - CheckValue(result, valueStr, formatString, expectedResult, SampleDisplay.ColumnType.Byte, rowData); + CheckValue(result, valueStr, formatString, expectedResult, ColumnType.Byte, rowData); } - if (value <= UInt16.MaxValue - && value >= UInt16.MinValue + if (value <= ushort.MaxValue + && value >= ushort.MinValue && (numType == NumType.IntOnly || numType == NumType.All) && !isNegative) { - CheckValue(ushort.Parse(valueStr), valueStr, formatString, expectedResult, SampleDisplay.ColumnType.UInt16, rowData); - + CheckValue(ushort.Parse(valueStr), valueStr, formatString, expectedResult, ColumnType.UInt16, rowData); + Assert.IsTrue(ushort.TryParse(valueStr, out ushort result), $"TryParse failed for ushort {valueStr}"); - CheckValue(result, valueStr, formatString, expectedResult, SampleDisplay.ColumnType.UInt16, rowData); + CheckValue(result, valueStr, formatString, expectedResult, ColumnType.UInt16, rowData); } - if (value <= UInt32.MaxValue - && value >= UInt32.MinValue + if (value <= uint.MaxValue + && value >= uint.MinValue && (numType == NumType.IntOnly || numType == NumType.All) && !isNegative) { - CheckValue(uint.Parse(valueStr), valueStr, formatString, expectedResult, SampleDisplay.ColumnType.UInt32, rowData); + CheckValue(uint.Parse(valueStr), valueStr, formatString, expectedResult, ColumnType.UInt32, rowData); Assert.IsTrue(uint.TryParse(valueStr, out uint result), $"TryParse failed for uint {valueStr}"); - CheckValue(result, valueStr, formatString, expectedResult, SampleDisplay.ColumnType.UInt32, rowData); + CheckValue(result, valueStr, formatString, expectedResult, ColumnType.UInt32, rowData); } - if (value <= UInt64.MaxValue - && value >= UInt64.MinValue + if (value <= ulong.MaxValue + && value >= ulong.MinValue && (numType == NumType.IntOnly || numType == NumType.All) && !isNegative) { - CheckValue(ulong.Parse(valueStr), valueStr, formatString, expectedResult, SampleDisplay.ColumnType.UInt64, rowData); + CheckValue(ulong.Parse(valueStr), valueStr, formatString, expectedResult, ColumnType.UInt64, rowData); Assert.IsTrue(ulong.TryParse(valueStr, out ulong result), $"TryParse failed for ulong {valueStr}"); - CheckValue(result, valueStr, formatString, expectedResult, SampleDisplay.ColumnType.UInt64, rowData); + CheckValue(result, valueStr, formatString, expectedResult, ColumnType.UInt64, rowData); } - if (value <= Single.MaxValue - && value >= Single.MinValue + if (value <= float.MaxValue + && value >= float.MinValue && (numType == NumType.FloatDoubleOnly || numType == NumType.All) ) { - CheckValue(float.Parse(valueStr), valueStr, formatString, expectedResult, SampleDisplay.ColumnType.Single, rowData); + CheckValue(float.Parse(valueStr), valueStr, formatString, expectedResult, ColumnType.Single, rowData); Assert.IsTrue(float.TryParse(valueStr, out float result), $"TryParse failed for float {valueStr}"); - CheckValue(result, valueStr, formatString, expectedResult, SampleDisplay.ColumnType.Single, rowData); + CheckValue(result, valueStr, formatString, expectedResult, ColumnType.Single, rowData); } - if (value <= Double.MaxValue - && value >= Double.MinValue + if (value <= double.MaxValue + && value >= double.MinValue && (numType == NumType.FloatDoubleOnly || numType == NumType.All) ) { - CheckValue(double.Parse(valueStr), valueStr, formatString, expectedResult, SampleDisplay.ColumnType.Double, rowData); + CheckValue(double.Parse(valueStr), valueStr, formatString, expectedResult, ColumnType.Double, rowData); Assert.IsTrue(double.TryParse(valueStr, out double result), $"TryParse failed for double {valueStr}"); - CheckValue(result, valueStr, formatString, expectedResult, SampleDisplay.ColumnType.Double, rowData); + CheckValue(result, valueStr, formatString, expectedResult, ColumnType.Double, rowData); } } - private void CheckValue(object value, string valueStr, string formatString, string expectedResult, SampleDisplay.ColumnType columnType, SampleDisplay.RowData rowData) + private void CheckValue(object value, string valueStr, string formatString, string expectedResult, ColumnType columnType, RowData rowData) { string result = string.Format($"{{0:{formatString}}}", new object[] { value }); // for format of X if the number is negative there will be extra F's in the front depending on integer size. @@ -471,18 +504,18 @@ public ColumnInfo(string columnHeader) public SampleDisplay() { - AddColumn("Value", SampleDisplay.ColumnType.Value); - AddColumn("Format", SampleDisplay.ColumnType.FormatString); - AddColumn("SByte", SampleDisplay.ColumnType.SByte); - AddColumn("Int16", SampleDisplay.ColumnType.Int16); - AddColumn("Int32", SampleDisplay.ColumnType.Int32); - AddColumn("Int64", SampleDisplay.ColumnType.Int64); - AddColumn("Byte", SampleDisplay.ColumnType.Byte); - AddColumn("UInt16", SampleDisplay.ColumnType.UInt16); - AddColumn("UInt32", SampleDisplay.ColumnType.UInt32); - AddColumn("UInt64", SampleDisplay.ColumnType.UInt64); - AddColumn("Single", SampleDisplay.ColumnType.Single); - AddColumn("Double", SampleDisplay.ColumnType.Double); + AddColumn("Value", ColumnType.Value); + AddColumn("Format", ColumnType.FormatString); + AddColumn("SByte", ColumnType.SByte); + AddColumn("Int16", ColumnType.Int16); + AddColumn("Int32", ColumnType.Int32); + AddColumn("Int64", ColumnType.Int64); + AddColumn("Byte", ColumnType.Byte); + AddColumn("UInt16", ColumnType.UInt16); + AddColumn("UInt32", ColumnType.UInt32); + AddColumn("UInt64", ColumnType.UInt64); + AddColumn("Single", ColumnType.Single); + AddColumn("Double", ColumnType.Double); } public ColumnInfo GetColumnInfo(ColumnType columnType) diff --git a/Tests/NFUnitTestConversions/UnitTestConvertTests.cs b/Tests/NFUnitTestConversions/UnitTestConvertTests.cs index eee53f0d..2bd030b7 100644 --- a/Tests/NFUnitTestConversions/UnitTestConvertTests.cs +++ b/Tests/NFUnitTestConversions/UnitTestConvertTests.cs @@ -29,15 +29,15 @@ public void Cast_FloatingPoint() { u1 = (uint)rand.Next(); - d1 = (double)u1; // Does not work correctly (d1 is close to 0) + d1 = u1; // Does not work correctly (d1 is close to 0) u2 = (uint)d1; Assert.AreEqual(d1, u1); Assert.AreEqual(u2, u1); - f1 = (float)u1; // Same problem + f1 = u1; // Same problem Assert.AreEqual(f1, u1); - l1 = (long)u1; + l1 = u1; u2 = (uint)l1; Assert.AreEqual(l1, u1); Assert.AreEqual(u2, u1); @@ -53,44 +53,44 @@ public void Cast_FloatingPoint() public void Convert_Positive() { string number = "12"; - SByte value_sb = Convert.ToSByte(number); + sbyte value_sb = Convert.ToSByte(number); Assert.AreEqual(value_sb, (byte)12); - Byte value_b = Convert.ToByte(number); + byte value_b = Convert.ToByte(number); Assert.AreEqual(value_b, (byte)12); - Int16 value_s16 = Convert.ToInt16(number); + short value_s16 = Convert.ToInt16(number); Assert.AreEqual(value_s16, (short)12); - UInt16 value_u16 = Convert.ToUInt16(number); + ushort value_u16 = Convert.ToUInt16(number); Assert.AreEqual(value_u16, (ushort)12); - Int32 value_s32 = Convert.ToInt32(number); - Assert.AreEqual(value_s32, (int)12); - UInt32 value_u32 = Convert.ToUInt32(number); - Assert.AreEqual(value_u32, (uint)12); - Int64 value_s64 = Convert.ToInt32(number); - Assert.AreEqual(value_s64, (long)12); - UInt64 value_u64 = Convert.ToUInt64(number); - Assert.AreEqual(value_u64, (ulong)12); + int value_s32 = Convert.ToInt32(number); + Assert.AreEqual(value_s32, 12); + uint value_u32 = Convert.ToUInt32(number); + Assert.AreEqual(value_u32, 12); + long value_s64 = Convert.ToInt32(number); + Assert.AreEqual(value_s64, 12); + ulong value_u64 = Convert.ToUInt64(number); + Assert.AreEqual(value_u64, 12); } [TestMethod] public void Convert_PositivePlus() { string number = "+12"; - SByte value_sb = Convert.ToSByte(number); + sbyte value_sb = Convert.ToSByte(number); Assert.AreEqual(value_sb, (byte)12); - Byte value_b = Convert.ToByte(number); + byte value_b = Convert.ToByte(number); Assert.AreEqual(value_b, (byte)12); - Int16 value_s16 = Convert.ToInt16(number); + short value_s16 = Convert.ToInt16(number); Assert.AreEqual(value_s16, (short)12); - UInt16 value_u16 = Convert.ToUInt16(number); + ushort value_u16 = Convert.ToUInt16(number); Assert.AreEqual(value_u16, (ushort)12); - Int32 value_s32 = Convert.ToInt32(number); - Assert.AreEqual(value_s32, (int)12); - UInt32 value_u32 = Convert.ToUInt32(number); - Assert.AreEqual(value_u32, (uint)12); - Int64 value_s64 = Convert.ToInt32(number); - Assert.AreEqual(value_s64, (long)12); - UInt64 value_u64 = Convert.ToUInt64(number); - Assert.AreEqual(value_u64, (ulong)12); + int value_s32 = Convert.ToInt32(number); + Assert.AreEqual(value_s32, 12); + uint value_u32 = Convert.ToUInt32(number); + Assert.AreEqual(value_u32, 12); + long value_s64 = Convert.ToInt32(number); + Assert.AreEqual(value_s64, 12); + ulong value_u64 = Convert.ToUInt64(number); + Assert.AreEqual(value_u64, 12); } @@ -99,18 +99,18 @@ public void Convert_Negative() { string number = "-12"; int actualNumber = -12; - SByte value_sb = Convert.ToSByte(number); + sbyte value_sb = Convert.ToSByte(number); Assert.AreEqual(value_sb, (sbyte)actualNumber, "Test1"); - Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { Byte value_b = Convert.ToByte(number); }, "Test2"); - Int16 value_s16 = Convert.ToInt16(number); + Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { byte value_b = Convert.ToByte(number); }, "Test2"); + short value_s16 = Convert.ToInt16(number); Assert.AreEqual(value_s16, (short)actualNumber, "Test3"); - Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { UInt16 value_u16 = Convert.ToUInt16(number); }, "Test4"); - Int32 value_s32 = Convert.ToInt32(number); - Assert.AreEqual(value_s32, (int)actualNumber, "Test5"); - Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { UInt32 value_u32 = Convert.ToUInt32(number); }, "Test6"); - Int64 value_s64 = Convert.ToInt32(number); - Assert.AreEqual(value_s64, (long)actualNumber, "Test7"); - Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { UInt64 value_u64 = Convert.ToUInt64(number); }, "Test8"); + Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { ushort value_u16 = Convert.ToUInt16(number); }, "Test4"); + int value_s32 = Convert.ToInt32(number); + Assert.AreEqual(value_s32, actualNumber, "Test5"); + Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { uint value_u32 = Convert.ToUInt32(number); }, "Test6"); + long value_s64 = Convert.ToInt32(number); + Assert.AreEqual(value_s64, actualNumber, "Test7"); + Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { ulong value_u64 = Convert.ToUInt64(number); }, "Test8"); } [TestMethod] @@ -179,7 +179,7 @@ public void Convert_DoubleNormalizeNeg() // Examples of how we can get differences due to differences between the compiler parser, and the native parser // And differences caused by the native parsers "fast speed" causing rounding errors - string num1 = "+0.000000004848747585e-3"; + string num1 = "+0.000000004848747585e-3"; string num2 = "4.848747585e-12"; // same number as above, but we've moved the digits over a bit and adjusted the exponent double dnum1Roslyn = +0.000000004848747585e-3; // Roslyn compiler will parse the value and put it into the double at compile time double dnum1Native = Convert.ToDouble(num1); // Native code will parse the value and put it into the double at run time @@ -224,101 +224,66 @@ public void Convert_HexInt() public void Convert_BoundaryValues() { - //*** - //* Boundary tests - tests of the min and max values for double, float and int's. - //* Note for double/float - the ToString() function is limited to a range around 2^64 and 2^-64 - otherwise you get a string of 'oor' or '-oor' (oor = out-of-range) - // Boundary tests for double/float include the numbers that are around the edge of where out-of-range is produced. - //*** - - const string OUT_OF_RANGE = "oor"; // nanoPrintf can only print up to 2^64-2 as a max value for double/floating - const string OUT_OF_RANGE_NEG = "-oor"; // nanoPrintf can only print down to -2^64+2 as a min value for double/floating - - const string DOUBLE_MAX_VAL = "1.7976931348623157E+308"; // will get 'oor' when printed - const string DOUBLE_MAX_HEX = "0x7FEFFFFFFFFFFFFF"; // value from IEEE 574 - const string DOUBLE_MIN_VAL = "-1.7976931348623157E+308"; // will get '-oor' when printed - const string DOUBLE_MIN_HEX = "0xFFEFFFFFFFFFFFFF"; // value from IEEE 574 + const string OUT_OF_RANGE = "1.7976931348623157E+308"; + const string OUT_OF_RANGE_NEG = "-1.7976931348623157E+308"; + + const string DOUBLE_MAX_VAL = "1.7976931348623157E+308"; + const string DOUBLE_MAX_HEX = "0x7FEFFFFFFFFFFFFF"; // value from IEEE 574 + const string DOUBLE_MIN_VAL = "-1.7976931348623157E+308"; + const string DOUBLE_MIN_HEX = "0xFFEFFFFFFFFFFFFF"; // value from IEEE 574 const string DOUBLE_ZERO_HEX = "0x0000000000000000"; - const string DOUBLE_LARGEST_PRINT = "1.84467440737095E+19"; // this is the largest number you can ask for ToString() and get a response - const string DOUBLE_LARGESTINVALID_PRINT = "1.8446744073709552E+19"; // first positive value that will get the response 'oor' when printed - const string DOUBLE_SMALLEST_PRINT = "-1.32585973029787E+19"; // this is the smallest number you can ask for ToString() and get a response - const string DOUBLE_SMALLESTINVALID_PRINT = "-1.8446744073709552E+19"; // first negative value that will get the response '-oor' when printed const string FLOAT_MAX_VAL = "3.40282347E+38"; - const string FLOAT_MAX_HEX = "0x7F7FFFFF"; // will get 'oor' when printed + const string FLOAT_MAX_HEX = "0x7F7FFFFF"; const string FLOAT_MIN_VAL = "-3.40282347E+38"; - const string FLOAT_MIN_HEX = "0xFF7FFFFF"; // will get '-oor' when printed + const string FLOAT_MIN_HEX = "0xFF7FFFFF"; const string FLOAT_ZERO_HEX = "0x00000000"; - const string FLOAT_LARGEST_PRINT = "1.844674E+19"; // this is the largest number you can ask for ToString() and get a response - const string FLOAT_LARGESTINVALID_PRINT = "1.8446744E+19"; // first positive value that will get the response 'oor' when printed - const string FLOAT_SMALLEST_PRINT = "-1.844674E+19"; // this is the smallest number you can ask for ToString() and get a response - const string FLOAT_SMALLESTINVALID_PRINT = "-1.8446744E+19"; // first negative value that will get the response '-oor' when printed // boundary: double max - string time = DateTime.UtcNow.ToString("hh:mm:ss"); double doubleMax = double.MaxValue; - Assert.AreEqual(doubleMax.ToString(), OUT_OF_RANGE, "nanoPrintf returns oor for double > 2^64-2"); - Assert.AreEqual(DoubleToHex(doubleMax), DOUBLE_MAX_HEX, "Hex value to double max value does not match"); - Assert.AreEqual(DoubleToHex(Convert.ToDouble(DOUBLE_MAX_VAL)), DOUBLE_MAX_HEX, "Parsing double max value does not return correct hex value"); + Assert.AreEqual(OUT_OF_RANGE, doubleMax.ToString(), "double.MaxValue value failed"); + Assert.AreEqual(DOUBLE_MAX_HEX, DoubleToHex(doubleMax), "Hex value to double max value does not match"); + Assert.AreEqual(DOUBLE_MAX_HEX, DoubleToHex(Convert.ToDouble(DOUBLE_MAX_VAL)), "Parsing double max value does not return correct hex value"); + + doubleMax = Convert.ToDouble(DOUBLE_MAX_VAL); + Assert.AreEqual(doubleMax.ToString(), OUT_OF_RANGE, "Double.ToString did not return 'oor' for first out-of-range value"); // boundary: double min double doubleMin = double.MinValue; - Assert.AreEqual(doubleMin.ToString(), OUT_OF_RANGE_NEG, "nanoPrintf returns oor for double < -2^64+2"); - Assert.AreEqual(DoubleToHex(doubleMin), DOUBLE_MIN_HEX,"Hex value to double min value does not match"); - Assert.AreEqual(DoubleToHex(Convert.ToDouble(DOUBLE_MIN_VAL)), DOUBLE_MIN_HEX, "Parsing double min value does not return correct hex value"); + Assert.AreEqual(OUT_OF_RANGE_NEG, doubleMin.ToString()); + Assert.AreEqual(DOUBLE_MIN_HEX, DoubleToHex(doubleMin), "Hex value to double min value does not match"); + Assert.AreEqual(DOUBLE_MIN_HEX, DoubleToHex(Convert.ToDouble(DOUBLE_MIN_VAL)), "Parsing double min value does not return correct hex value"); + + doubleMin = Convert.ToDouble(DOUBLE_MIN_VAL); + Assert.AreEqual(doubleMin.ToString(), doubleMin.ToString(), "Double.ToString did not return the correct value for smallest in range value"); // boundary: double zero double doubleZero = 0; // test that zero gets a zero exponent and a value like 1023 the exponent bias used in floating point math Assert.AreEqual(doubleZero.ToString(), "0", "ToString of a double with zero value formats incorrectly"); - Assert.AreEqual(DoubleToHex(doubleZero), DOUBLE_ZERO_HEX, "Double with zero value returns the wrong hex value"); - - // boundary: double largest-in-range - double doubleInRange = Convert.ToDouble(DOUBLE_LARGEST_PRINT); - Assert.AreEqual(doubleInRange.ToString(), DOUBLE_LARGEST_PRINT, "Double.ToString did not return the correct value for largest in range value"); - - // boundary: double largest-out-of-range - double doubleOutRange = Convert.ToDouble(DOUBLE_LARGESTINVALID_PRINT); - Assert.AreEqual(doubleOutRange.ToString(), OUT_OF_RANGE, "Double.ToString did not return 'oor' for first out-of-range value"); - - // boundary: double smallest-in-range - double doubleInRangeNeg = Convert.ToDouble(DOUBLE_SMALLEST_PRINT); - Assert.AreEqual(doubleInRangeNeg.ToString(), DOUBLE_SMALLEST_PRINT, "Double.ToString did not return the correct value for smallest in range value"); - - // boundary: double smallest-out-of-range - double doubleOutRangeNeg = Convert.ToDouble(DOUBLE_SMALLESTINVALID_PRINT); - Assert.AreEqual(doubleOutRangeNeg.ToString(), OUT_OF_RANGE_NEG, "Double.ToString did not return 'oor' for smallest out-of-range value"); + Assert.AreEqual(DOUBLE_ZERO_HEX, DoubleToHex(doubleZero), "Double with zero value returns the wrong hex value"); // boundary: float max float floatMax = float.MaxValue; - Assert.AreEqual(floatMax.ToString(), OUT_OF_RANGE, "nanoPrintf return oor for float > 2^64-2"); - Assert.AreEqual(FloatToHex(floatMax), FLOAT_MAX_HEX, "Hex value to float max values does not match"); - Assert.AreEqual(FloatToHex((float)Convert.ToDouble(FLOAT_MAX_VAL)), FLOAT_MAX_HEX, "Parsing float max value does not return correct hex value"); + Assert.AreEqual(FLOAT_MAX_VAL, floatMax.ToString(), "floatMax.ToString()"); + Assert.AreEqual(FLOAT_MAX_HEX, FloatToHex(floatMax), "Hex value to float max values does not match"); + Assert.AreEqual(FLOAT_MAX_HEX, FloatToHex((float)Convert.ToDouble(FLOAT_MAX_VAL)), "Parsing float max value does not return correct hex value"); + + floatMax = Convert.ToSingle(FLOAT_MAX_VAL); + Assert.AreEqual(FLOAT_MAX_VAL, floatMax.ToString(), "floatOutRange.ToString() did not return 'oor' for first out-of-range value"); // boundary: float min float floatMin = float.MinValue; - Assert.AreEqual(floatMin.ToString(), OUT_OF_RANGE_NEG, "nanoPrintf returns oor for float < -2^64+2"); - Assert.AreEqual(FloatToHex(floatMin), FLOAT_MIN_HEX, "Hex value to double min value does not match"); - Assert.AreEqual(FloatToHex((float)Convert.ToDouble(FLOAT_MIN_VAL)), FLOAT_MIN_HEX, "Parsing float min value does not return correct hex value"); + Assert.AreEqual(FLOAT_MIN_VAL, floatMin.ToString(), "floatMin.ToString()"); + Assert.AreEqual(FLOAT_MIN_HEX, FloatToHex(floatMin), "Hex value to double min value does not match"); + Assert.AreEqual(FLOAT_MIN_HEX, FloatToHex((float)Convert.ToDouble(FLOAT_MIN_VAL)), "Parsing float min value does not return correct hex value"); + + floatMin = Convert.ToSingle(FLOAT_MIN_VAL); + Assert.AreEqual(FLOAT_MIN_VAL, floatMin.ToString(), "Float.ToString did not return 'oor' for smallest out-of-range value"); //boundary: float zero float floatZero = 0; // test that zero gets a zero exponent and not a value like 1023 the exponent bias used in floating point math - Assert.AreEqual(floatZero.ToString(), "0", "ToString of a string with zero value formats incorrectly"); - Assert.AreEqual(FloatToHex(floatZero), FLOAT_ZERO_HEX, "Float with zero value returns the wrong hex value"); - - // boundary: float largest-in-range - float floatInRange = (float)Convert.ToDouble(FLOAT_LARGEST_PRINT); - Assert.AreEqual(floatInRange.ToString(), FLOAT_LARGEST_PRINT, "Float.ToString did not return the correct value for largest in range value"); - - // boundary: float largest-out-of-range - float floatOutRange = (float)Convert.ToDouble(FLOAT_LARGESTINVALID_PRINT); - Assert.AreEqual(floatOutRange.ToString(), OUT_OF_RANGE, "Float.ToString did not return 'oor' for first out-of-range value"); - - // boundary: float smallest-in-range - float floatInRangeNeg = (float)Convert.ToDouble(FLOAT_SMALLEST_PRINT); - Assert.AreEqual(floatInRangeNeg.ToString(), FLOAT_SMALLEST_PRINT, "Float.ToString did not return the correct value for smallest in range value"); - - // boundary: float smallest-out-of-range - float floatOutRangeNeg = (float)Convert.ToDouble(FLOAT_SMALLESTINVALID_PRINT); - Assert.AreEqual(floatOutRangeNeg.ToString(), OUT_OF_RANGE_NEG, "Float.ToString did not return 'oor' for smallest out-of-range value"); + Assert.AreEqual("0", floatZero.ToString(), "ToString of a string with zero value formats incorrectly"); + Assert.AreEqual(FLOAT_ZERO_HEX, FloatToHex(floatZero), "Float with zero value returns the wrong hex value"); long lMax = long.MaxValue; string numMax = lMax.ToString(); @@ -387,7 +352,7 @@ public void Convert_BoundaryValues() Assert.AreEqual(bMax, Convert.ToByte(numMax)); Assert.AreEqual(bMin, Convert.ToByte(numMin)); - + } @@ -511,7 +476,7 @@ public static string FloatToHex(float f) return "-Infinity"; if (float.IsNaN(f)) return "NaN"; - string returnValue = string.Format("0x{0:X8}", BitConverter.ToInt32(BitConverter.GetBytes(f),0)); // CoreLibrary/mscorlib does not implement SingleToInt32Bits + string returnValue = string.Format("0x{0:X8}", BitConverter.ToInt32(BitConverter.GetBytes(f), 0)); // CoreLibrary/mscorlib does not implement SingleToInt32Bits return returnValue; } @@ -564,7 +529,7 @@ public void Convert_ToFromBase64() cnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmq q6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj 5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w=="; - + string base64EncodedString_WithoutLineBreaks = "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w=="; string base64string1 = Convert.ToBase64String( diff --git a/Tests/NFUnitTestSystemLib/UnitTestDateTime.cs b/Tests/NFUnitTestSystemLib/UnitTestDateTime.cs index baf13d93..976266d5 100644 --- a/Tests/NFUnitTestSystemLib/UnitTestDateTime.cs +++ b/Tests/NFUnitTestSystemLib/UnitTestDateTime.cs @@ -303,7 +303,7 @@ public void DateTime_ToStringTest10() // expected format is dddd, dd MMMM yyyy HH:mm - int minLength = 26; + int minLength = 25; int actualLength = dtOutput1.Length; // check length diff --git a/Tests/NFUnitTestSystemLib/UnitTestDouble.cs b/Tests/NFUnitTestSystemLib/UnitTestDouble.cs index 0391f3a9..7b847c30 100644 --- a/Tests/NFUnitTestSystemLib/UnitTestDouble.cs +++ b/Tests/NFUnitTestSystemLib/UnitTestDouble.cs @@ -98,7 +98,14 @@ public void Equals() Assert.AreEqual(test.Expected, test.D1.GetHashCode().Equals(d2.GetHashCode())); } - Assert.AreEqual(test.Expected, test.D1.Equals(test.Value)); + if(test.Expected) + { + Assert.IsTrue(test.D1.Equals(test.Value)); + } + else + { + Assert.IsFalse(test.D1.Equals(test.Value)); + } } } diff --git a/Tests/NFUnitTestSystemLib/UnitTestTypeTests.cs b/Tests/NFUnitTestSystemLib/UnitTestTypeTests.cs index 0260963e..609697c2 100644 --- a/Tests/NFUnitTestSystemLib/UnitTestTypeTests.cs +++ b/Tests/NFUnitTestSystemLib/UnitTestTypeTests.cs @@ -21,9 +21,9 @@ class TestObject1 { } class TestObject2 : iEmpty { - public TestObject2(Int32 i) + public TestObject2(int i) { - m_data = (int)i; + m_data = i; } public int m_data; class m_subTestObject @@ -34,7 +34,7 @@ public void Method1() { } - public Int32 Method2(Int32 I) + public int Method2(int I) { return I; } @@ -51,9 +51,9 @@ public void Number_ToString_Test() Assert.AreEqual("fffd", ((short)-3).ToString("x04")); Assert.AreEqual("3049", ((ushort)0x3049).ToString("x4")); Assert.AreEqual("fc00", ((short)-1024).ToString("x02")); - Assert.AreEqual("fffffffc", ((int)-4).ToString("x8")); + Assert.AreEqual("fffffffc", (-4).ToString("x8")); Assert.AreEqual("00004494", ((uint)0x4494).ToString("x8")); - Assert.AreEqual("fffffffc", ((int)-4).ToString("x04")); + Assert.AreEqual("fffffffc", (-4).ToString("x04")); Assert.AreEqual("fffffffffffffffb", ((long)-5).ToString("x016")); Assert.AreEqual("1234567890123456", ((ulong)0x1234567890123456).ToString("x16")); // you should not be able to truncate the value only leading zeros @@ -94,11 +94,11 @@ public void Number_ToString_Test() Assert.AreEqual("NaN", float.NaN.ToString()); Assert.AreEqual("Infinity", float.PositiveInfinity.ToString()); - //Assert.AreEqual("-Infinity", float.NegativeInfinity.ToString(), "float negative infinity test"); + Assert.AreEqual("-Infinity", float.NegativeInfinity.ToString(), "float negative infinity test"); Assert.AreEqual("NaN", double.NaN.ToString()); Assert.AreEqual("Infinity", double.PositiveInfinity.ToString()); - //Assert.AreEqual("-Infinity", double.NegativeInfinity.ToString(), "double negative infinity"); + Assert.AreEqual("-Infinity", double.NegativeInfinity.ToString(), "double negative infinity"); Assert.AreEqual("Da1x", (1).ToString("Da1x")); Assert.AreEqual("1", (1).ToString("D")); @@ -107,18 +107,18 @@ public void Number_ToString_Test() Assert.AreEqual("-1234", (-1234).ToString("D")); Assert.AreEqual("001234", (1234).ToString("D6")); Assert.AreEqual("-001234", (-1234).ToString("D6")); - Assert.AreEqual("2147483647", (Int32.MaxValue).ToString("D")); - Assert.AreEqual("-2147483648", (Int32.MinValue).ToString("D")); - Assert.AreEqual("000000000002147483647", (Int32.MaxValue).ToString("D21")); - Assert.AreEqual("-000000000002147483648", (Int32.MinValue).ToString("D21")); - Assert.AreEqual("9223372036854775807", (Int64.MaxValue).ToString("D")); - Assert.AreEqual("-9223372036854775808", (Int64.MinValue).ToString("D")); - Assert.AreEqual("009223372036854775807", (Int64.MaxValue).ToString("D21")); - Assert.AreEqual("-009223372036854775808", (Int64.MinValue).ToString("D21")); - Assert.AreEqual("2147483747", ((Int64)Int32.MaxValue + 100).ToString("D")); - Assert.AreEqual("-2147483748", ((Int64)Int32.MinValue - 100).ToString("D")); - Assert.AreEqual("000000000002147483747", ((Int64)Int32.MaxValue + 100).ToString("D21")); - Assert.AreEqual("-000000000002147483748", ((Int64)Int32.MinValue - 100).ToString("D21")); + Assert.AreEqual("2147483647", (int.MaxValue).ToString("D")); + Assert.AreEqual("-2147483648", (int.MinValue).ToString("D")); + Assert.AreEqual("000000000002147483647", (int.MaxValue).ToString("D21")); + Assert.AreEqual("-000000000002147483648", (int.MinValue).ToString("D21")); + Assert.AreEqual("9223372036854775807", (long.MaxValue).ToString("D")); + Assert.AreEqual("-9223372036854775808", (long.MinValue).ToString("D")); + Assert.AreEqual("009223372036854775807", (long.MaxValue).ToString("D21")); + Assert.AreEqual("-009223372036854775808", (long.MinValue).ToString("D21")); + Assert.AreEqual("2147483747", ((long)int.MaxValue + 100).ToString("D")); + Assert.AreEqual("-2147483748", ((long)int.MinValue - 100).ToString("D")); + Assert.AreEqual("000000000002147483747", ((long)int.MaxValue + 100).ToString("D21")); + Assert.AreEqual("-000000000002147483748", ((long)int.MinValue - 100).ToString("D21")); Assert.AreEqual("1234.57", (1234.567).ToString("F")); Assert.AreEqual("-1234.57", (-1234.567).ToString("F")); @@ -133,12 +133,12 @@ public void Number_ToString_Test() Assert.AreEqual("1234.0", (1234.0056).ToString("F1")); Assert.AreEqual("-1234.0", (-1234.0056).ToString("F1")); Assert.AreEqual("1", (1).ToString()); - Assert.AreEqual("1", (1).ToString((string)null)); - Assert.AreEqual("1", (1).ToString(String.Empty)); + Assert.AreEqual("1", (1).ToString(null)); + Assert.AreEqual("1", (1).ToString(string.Empty)); Assert.AreEqual("1234.567", (1234.567).ToString()); - Assert.AreEqual("123.456", (123.456).ToString("G")); + Assert.AreEqual("123.456", (123.456).ToString("G"), "123.456 (G)"); Assert.AreEqual("-123.456", (-123.456).ToString("G")); - Assert.AreEqual("1.2E+02", (123.4546).ToString("G2")); + Assert.AreEqual("1.2E+02", (123.4546).ToString("G2"), "1.2E+02 (G2)"); Assert.AreEqual("-1.2E+02", (-123.4546).ToString("G2")); Assert.AreEqual("123.5", (123.4546).ToString("G4")); Assert.AreEqual("-123.5", (-123.4546).ToString("G4")); @@ -169,25 +169,25 @@ public void Number_ToString_Test() Assert.AreEqual("-34,561,234.560", (-34561234.56).ToString("N3")); Assert.AreEqual("FF", (255).ToString("X")); - Assert.AreEqual("1", ((Int32)1).ToString("X")); - Assert.AreEqual("ffffffff", ((Int32)(-1)).ToString("x")); + Assert.AreEqual("1", 1.ToString("X")); + Assert.AreEqual("ffffffff", (-1).ToString("x")); Assert.AreEqual("1", (unchecked((byte)1)).ToString("x")); Assert.AreEqual("ff", (unchecked((byte)(-1))).ToString("x")); Assert.AreEqual("1", ((short)1).ToString("x")); Assert.AreEqual("01", ((short)1).ToString("x2")); Assert.AreEqual("ffff", ((short)(-1)).ToString("x")); Assert.AreEqual("00ff", (255).ToString("x4")); - Assert.AreEqual("FFFFFFFF", ((Int32)(-1)).ToString("X4")); - Assert.AreEqual("7ffffffffffffff5", (Int64.MaxValue - 10).ToString("x")); - Assert.AreEqual("a", ((Int64)10).ToString("x")); - Assert.AreEqual("0000a", ((Int64)10).ToString("x5")); + Assert.AreEqual("FFFFFFFF", (-1).ToString("X4")); + Assert.AreEqual("7ffffffffffffff5", (long.MaxValue - 10).ToString("x")); + Assert.AreEqual("a", ((long)10).ToString("x")); + Assert.AreEqual("0000a", ((long)10).ToString("x5")); } [TestMethod] public void SystemType1_GetTypeNew_Test() { - Int32 testInt32 = 0; + int testInt32 = 0; Assembly Int32Assm = Assembly.Load("mscorlib"); @@ -264,7 +264,7 @@ public void SystemType2_Assembly_Test() OutputHelper.WriteLine("This tests the Assembly property"); //Assigned and manipulated to avoid compiler warning - Int32 testInt32 = -1; + int testInt32 = -1; testInt32++; Type myType1 = Type.GetType("System.Int32"); @@ -283,7 +283,7 @@ public void SystemType3_BaseType_Test() OutputHelper.WriteLine("This tests the BaseType() method"); //Assigned and manipulated to avoid compiler warning - Int32 testInt32 = -1; + int testInt32 = -1; testInt32++; Type myType1 = Type.GetType("System.Int32"); OutputHelper.WriteLine("The full name is " + myType1.FullName); @@ -301,7 +301,7 @@ public void SystemType4_DeclaringType_Test() OutputHelper.WriteLine("This tests the DeclaringType property"); //Assigned and manipulated to avoid compiler warning - Int32 testInt32 = -1; + int testInt32 = -1; testInt32++; Type myType1 = Type.GetType("System.Int32"); @@ -336,12 +336,12 @@ public void SystemType6_GetElementType_Test() OutputHelper.WriteLine("This tests the GetElementType() method"); //Assigned and manipulated to avoid compiler warning - Int32 testInt32 = -1; + int testInt32 = -1; testInt32++; Type myType1 = Type.GetType("System.Int32"); OutputHelper.WriteLine("The full name is " + myType1.FullName); - Int32[] int32Arr = new Int32[] { }; + int[] int32Arr = new int[] { }; Type int32ArrType = int32Arr.GetType(); Assert.IsType(myType1, int32ArrType.GetElementType()); @@ -445,7 +445,7 @@ public void SystemType10_GetMethod_Test() OutputHelper.WriteLine("This test must be re-written once BindingFlags is working, "); OutputHelper.WriteLine("see 17246 for more details."); - Int32 I = 0; + int I = 0; I++; TestObject2 testTestObject2 = new TestObject2(5); Type myType2 = testTestObject2.GetType(); @@ -471,7 +471,7 @@ public void SystemType11_GetMethods_Test() OutputHelper.WriteLine("see 17246 for more details."); //Assigned and manipulated to avoid compiler warning - Int32 I = 0; + int I = 0; I++; TestObject2 testTestObject2 = new TestObject2(5);