Skip to content

Fixing several unit tests #204

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
May 17, 2023
Merged

Fixing several unit tests #204

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
211 changes: 122 additions & 89 deletions Tests/NFUnitTestArithmetic/UnitTestFormat.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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)]
Expand Down Expand Up @@ -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]
Expand Down Expand Up @@ -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();

Expand All @@ -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");
Expand All @@ -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;

Expand Down Expand Up @@ -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.
Expand Down Expand Up @@ -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)
Expand Down
Loading