Skip to content

Commit 19c42ee

Browse files
josesimoesjosesimoes
authored
Fixing several unit tests (#204)
***NO_CI***
1 parent eabb50f commit 19c42ee

File tree

5 files changed

+245
-240
lines changed

5 files changed

+245
-240
lines changed

‎Tests/NFUnitTestArithmetic/UnitTestFormat.cs

Lines changed: 122 additions & 89 deletions
Original file line numberDiff line numberDiff line change
@@ -128,9 +128,9 @@ public void FixedFormat()
128128
// the E format can be used with all number types
129129
[DataRow("0", "E", "0.000000E+000", true, true, true)]
130130
[DataRow("0", "E4", "0.0000E+000", true, true, true)]
131-
[DataRow("12345.6789", "E", "1.234567E+004", true, true, false)]
132-
[DataRow("12345.678", "E6", "1.234567E+004", true, true, false)]
133-
[DataRow("12345.6789", "e4", "1.2345e+004", true, true, false)]
131+
[DataRow("12345.6789", "E", "1.234568E+004", true, true, false)]
132+
[DataRow("12345.678", "E6", "1.234568E+004", true, true, false)]
133+
[DataRow("12345.6789", "e4", "1.2346e+004", true, true, false)]
134134
[DataRow("123", "E", "1.230000E+002", true, true, true)]
135135
[DataRow("-123", "E", "-1.230000E+002", true, true, true)]
136136
[DataRow("1.2345e-9", "E", "1.234500E-009", true, false, false)]
@@ -176,36 +176,64 @@ public void ExponentialFormat(string valueStr, string formatString, string expec
176176

177177
[TestMethod]
178178
// the G format can be used with all number types
179-
public void GeneralFormat()
179+
[DataRow("0", "G", "0", false, false, true)]
180+
[DataRow("0", "G4", "0", false, false, true)]
181+
[DataRow("123", "G", "123", false, false, true)]
182+
[DataRow("129", "G", "129", false, false, true)]
183+
[DataRow("-129", "G", "-129", false, false, true)]
184+
[DataRow("128", "G", "128", false, false, true)]
185+
[DataRow("128", "G4", "128", false, false, true)]
186+
[DataRow("-128", "G", "-128", false, false, true)]
187+
[DataRow("-128", "G2", "-1.3E+02", false, false, true)]
188+
[DataRow("1234", "G2", "1.2E+03", false, false, false)]
189+
[DataRow("-1234", "G", "-1234", true, false, true)]
190+
[DataRow("1234", "G6", "1234", true, false, true)]
191+
[DataRow("-1234", "G6", "-1234", true, false, true)]
192+
[DataRow("123.78", "G3", "124", true, true, false)]
193+
[DataRow("123.7841", "G5", "123.78", true, true, false)]
194+
[DataRow("123.7851", "G5", "123.79", true, true, false)]
195+
[DataRow("123.78", "G5", "123.78", true, true, false)]
196+
[DataRow("123.78", "G4", "123.8", true, true, false)]
197+
[DataRow("1234.8999", "G5", "1234.9", true, true, false)]
198+
[DataRow("1234.8999", "G6", "1234.9", true, true, false)]
199+
[DataRow("1234.8999", "G7", "1234.9", true, true, false)]
200+
[DataRow("-1234.901", "G7", "-1234.901", true, true, false)]
201+
[DataRow("1.2345E-09", "G", "1.2345E-09", true, false, false)]
202+
[DataRow("1.7976931348623157E+275", "G", "1.7976931348623157E+275", true, false, false)]
203+
[DataRow("-1.7976931348623157E+275", "G", "-1.7976931348623157E+275", true, false, false)]
204+
public void GeneralFormat(string valueStr, string formatString, string expectedResult, bool testDouble, bool testSingle, bool testIntegers)
180205
{
181-
sampleDisplay = new SampleDisplay();
206+
double value = double.Parse(valueStr);
182207

183-
TestFormat("0", "G", "0");
184-
TestFormat("0", "G4", "0");
185-
TestFormat("123", "G", "123");
186-
TestFormat("129", "G", "129");
187-
TestFormat("-129", "G", "-129");
188-
TestFormat("128", "G", "128");
189-
TestFormat("128", "G4", "128");
190-
TestFormat("-128", "G", "-128");
191-
TestFormat("-128", "G2", "-1.3E+02");
192-
TestFormat("1234", "G2", "1.2E+03");
193-
TestFormat("-1234", "G", "-1234");
194-
TestFormat("1234", "G6", "1234");
195-
TestFormat("-1234", "G6", "-1234");
196-
TestFormat("123.78", "G3", "124");
197-
TestFormat("123.7841", "G5", "123.78");
198-
TestFormat("123.7851", "G5", "123.79");
199-
TestFormat("123.78", "G5", "123.78");
200-
TestFormat("123.78", "G4", "123.8");
201-
TestFormat("1234.8999", "G5", "1234.9");
202-
TestFormat("1234.8999", "G6", "1234.9");
203-
TestFormat("1234.8999", "G7", "1234.9");
204-
TestFormat("-1234.901", "G7", "-1234.901");
205-
TestFormat("1.2345E-9", "G", "1.2345E-09");
206208

207-
sampleDisplay.WriteOutput();
209+
if (testDouble)
210+
{
211+
CheckValue(double.Parse(valueStr), valueStr, formatString, expectedResult, ColumnType.Double, null);
212+
Assert.IsTrue(double.TryParse(valueStr, out double result), $"TryParse failed for double {valueStr}");
213+
CheckValue(result, valueStr, formatString, expectedResult, ColumnType.Double, null);
214+
}
215+
216+
if (testSingle)
217+
{
218+
CheckValue(float.Parse(valueStr), valueStr, formatString, expectedResult, ColumnType.Single, null);
219+
Assert.IsTrue(float.TryParse(valueStr, out float result), $"TryParse failed for float {valueStr}");
220+
CheckValue(result, valueStr, formatString, expectedResult, ColumnType.Single, null);
221+
}
208222

223+
if (testIntegers)
224+
{
225+
// can't test negative values with UInt64
226+
if (value > 0)
227+
{
228+
CheckValue(ulong.Parse(valueStr), valueStr, formatString, expectedResult, ColumnType.UInt64, null);
229+
Assert.IsTrue(ulong.TryParse(valueStr, out ulong result), $"TryParse failed for ulong {valueStr}");
230+
CheckValue(result, valueStr, formatString, expectedResult, ColumnType.UInt64, null);
231+
}
232+
233+
CheckValue(long.Parse(valueStr), valueStr, formatString, expectedResult, ColumnType.Int64, null);
234+
Assert.IsTrue(long.TryParse(valueStr, out long result1), $"TryParse failed for long {valueStr}");
235+
CheckValue(result1, valueStr, formatString, expectedResult, ColumnType.Int64, null);
236+
}
209237
}
210238

211239
[TestMethod]
@@ -235,7 +263,7 @@ public void NumberFormat()
235263

236264
[TestMethod]
237265
// the X format can only be used with integer number types
238-
public void HexFormat()
266+
public void HexFormat_00()
239267
{
240268
sampleDisplay = new SampleDisplay();
241269

@@ -248,9 +276,7 @@ public void HexFormat()
248276
TestFormat(" 127", "X", "7F");
249277
TestFormat(" 129", "X", "81");
250278

251-
TestFormat(" 128", "X4", "0080");
252279
TestFormat(" 1234", "X", "4D2");
253-
TestFormat(" 1234", "X6", "0004D2");
254280
TestFormat(" -127", "X", "81");
255281
TestFormat(" -128", "X", "80");
256282
TestFormat(" -128", "X4", "80");
@@ -261,11 +287,18 @@ public void HexFormat()
261287
sampleDisplay.WriteOutput();
262288
}
263289

290+
[TestMethod]
291+
// the X format can only be used with integer number types
292+
public void HexFormat_01()
293+
{
294+
Assert.AreEqual("0080", int.Parse(" 128").ToString("X4"), "Wrong output for 128 X4");
295+
Assert.AreEqual("0004D2", int.Parse(" 1234").ToString("X6"), "Wrong output for 1234 X6");
296+
}
264297

265298
#region Helper functions
266299
private void TestFormat(string valueStr, string formatString, string expectedResult, Case formatCase = Case.Both)
267300
{
268-
double value = Double.Parse(valueStr); // !!! does not return a negative number when parsed if string value does not contain a decimal point
301+
double value = double.Parse(valueStr); // !!! does not return a negative number when parsed if string value does not contain a decimal point
269302
bool isNegative = false;
270303
NumType numType = NumType.All;
271304

@@ -311,120 +344,120 @@ private void TestFormat(string valueStr, string formatString, string expectedRes
311344

312345
private void TestFormatInner(string valueStr, string formatString, string expectedResult, NumType numType, bool isNegative)
313346
{
314-
SampleDisplay.RowData rowData = sampleDisplay.AddRow(valueStr, formatString);
315-
double value = Double.Parse(valueStr);
316-
if (value <= SByte.MaxValue
317-
&& value >= SByte.MinValue
347+
RowData rowData = sampleDisplay.AddRow(valueStr, formatString);
348+
double value = double.Parse(valueStr);
349+
if (value <= sbyte.MaxValue
350+
&& value >= sbyte.MinValue
318351
&& (numType == NumType.IntOnly || numType == NumType.All)
319352
)
320353
{
321-
CheckValue(sbyte.Parse(valueStr), valueStr, formatString, expectedResult, SampleDisplay.ColumnType.SByte, rowData);
354+
CheckValue(sbyte.Parse(valueStr), valueStr, formatString, expectedResult, ColumnType.SByte, rowData);
322355

323356
Assert.IsTrue(sbyte.TryParse(valueStr, out sbyte result), $"TryParse failed for sbyte {valueStr}");
324-
CheckValue(result, valueStr, formatString, expectedResult, SampleDisplay.ColumnType.SByte, rowData);
357+
CheckValue(result, valueStr, formatString, expectedResult, ColumnType.SByte, rowData);
325358
}
326359

327-
if (value <= Int16.MaxValue
328-
&& value >= Int16.MinValue
360+
if (value <= short.MaxValue
361+
&& value >= short.MinValue
329362
&& (numType == NumType.IntOnly || numType == NumType.All)
330363
)
331364
{
332-
CheckValue(short.Parse(valueStr), valueStr, formatString, expectedResult, SampleDisplay.ColumnType.Int16, rowData);
365+
CheckValue(short.Parse(valueStr), valueStr, formatString, expectedResult, ColumnType.Int16, rowData);
333366

334367
Assert.IsTrue(short.TryParse(valueStr, out short result), $"TryParse failed for short {valueStr}");
335-
CheckValue(result, valueStr, formatString, expectedResult, SampleDisplay.ColumnType.Int16, rowData);
368+
CheckValue(result, valueStr, formatString, expectedResult, ColumnType.Int16, rowData);
336369
}
337370

338-
if (value <= Int32.MaxValue
339-
&& value >= Int32.MinValue
371+
if (value <= int.MaxValue
372+
&& value >= int.MinValue
340373
&& (numType == NumType.IntOnly || numType == NumType.All)
341374
)
342375
{
343-
CheckValue(int.Parse(valueStr), valueStr, formatString, expectedResult, SampleDisplay.ColumnType.Int32, rowData);
376+
CheckValue(int.Parse(valueStr), valueStr, formatString, expectedResult, ColumnType.Int32, rowData);
344377

345378
Assert.IsTrue(int.TryParse(valueStr, out int result), $"TryParse failed for int {valueStr}");
346-
CheckValue(result, valueStr, formatString, expectedResult, SampleDisplay.ColumnType.Int32, rowData);
379+
CheckValue(result, valueStr, formatString, expectedResult, ColumnType.Int32, rowData);
347380
}
348381

349-
if (value <= Int64.MaxValue
350-
&& value >= Int64.MinValue
382+
if (value <= long.MaxValue
383+
&& value >= long.MinValue
351384
&& (numType == NumType.IntOnly || numType == NumType.All)
352385
)
353386
{
354-
CheckValue(long.Parse(valueStr), valueStr, formatString, expectedResult, SampleDisplay.ColumnType.Int64, rowData);
387+
CheckValue(long.Parse(valueStr), valueStr, formatString, expectedResult, ColumnType.Int64, rowData);
355388

356389
Assert.IsTrue(long.TryParse(valueStr, out long result), $"TryParse failed for long {valueStr}");
357-
CheckValue(result, valueStr, formatString, expectedResult, SampleDisplay.ColumnType.Int64, rowData);
390+
CheckValue(result, valueStr, formatString, expectedResult, ColumnType.Int64, rowData);
358391
}
359392

360-
if (value <= Byte.MaxValue
361-
&& value >= Byte.MinValue
393+
if (value <= byte.MaxValue
394+
&& value >= byte.MinValue
362395
&& (numType == NumType.IntOnly || numType == NumType.All)
363396
&& !isNegative)
364397
{
365-
CheckValue(byte.Parse(valueStr), valueStr, formatString, expectedResult, SampleDisplay.ColumnType.Byte, rowData);
398+
CheckValue(byte.Parse(valueStr), valueStr, formatString, expectedResult, ColumnType.Byte, rowData);
366399

367400
Assert.IsTrue(byte.TryParse(valueStr, out byte result), $"TryParse failed for byte {valueStr}");
368-
CheckValue(result, valueStr, formatString, expectedResult, SampleDisplay.ColumnType.Byte, rowData);
401+
CheckValue(result, valueStr, formatString, expectedResult, ColumnType.Byte, rowData);
369402
}
370403

371-
if (value <= UInt16.MaxValue
372-
&& value >= UInt16.MinValue
404+
if (value <= ushort.MaxValue
405+
&& value >= ushort.MinValue
373406
&& (numType == NumType.IntOnly || numType == NumType.All)
374407
&& !isNegative)
375408
{
376-
CheckValue(ushort.Parse(valueStr), valueStr, formatString, expectedResult, SampleDisplay.ColumnType.UInt16, rowData);
377-
409+
CheckValue(ushort.Parse(valueStr), valueStr, formatString, expectedResult, ColumnType.UInt16, rowData);
410+
378411
Assert.IsTrue(ushort.TryParse(valueStr, out ushort result), $"TryParse failed for ushort {valueStr}");
379-
CheckValue(result, valueStr, formatString, expectedResult, SampleDisplay.ColumnType.UInt16, rowData);
412+
CheckValue(result, valueStr, formatString, expectedResult, ColumnType.UInt16, rowData);
380413
}
381414

382-
if (value <= UInt32.MaxValue
383-
&& value >= UInt32.MinValue
415+
if (value <= uint.MaxValue
416+
&& value >= uint.MinValue
384417
&& (numType == NumType.IntOnly || numType == NumType.All)
385418
&& !isNegative)
386419
{
387-
CheckValue(uint.Parse(valueStr), valueStr, formatString, expectedResult, SampleDisplay.ColumnType.UInt32, rowData);
420+
CheckValue(uint.Parse(valueStr), valueStr, formatString, expectedResult, ColumnType.UInt32, rowData);
388421

389422
Assert.IsTrue(uint.TryParse(valueStr, out uint result), $"TryParse failed for uint {valueStr}");
390-
CheckValue(result, valueStr, formatString, expectedResult, SampleDisplay.ColumnType.UInt32, rowData);
423+
CheckValue(result, valueStr, formatString, expectedResult, ColumnType.UInt32, rowData);
391424
}
392425

393-
if (value <= UInt64.MaxValue
394-
&& value >= UInt64.MinValue
426+
if (value <= ulong.MaxValue
427+
&& value >= ulong.MinValue
395428
&& (numType == NumType.IntOnly || numType == NumType.All)
396429
&& !isNegative)
397430
{
398-
CheckValue(ulong.Parse(valueStr), valueStr, formatString, expectedResult, SampleDisplay.ColumnType.UInt64, rowData);
431+
CheckValue(ulong.Parse(valueStr), valueStr, formatString, expectedResult, ColumnType.UInt64, rowData);
399432

400433
Assert.IsTrue(ulong.TryParse(valueStr, out ulong result), $"TryParse failed for ulong {valueStr}");
401-
CheckValue(result, valueStr, formatString, expectedResult, SampleDisplay.ColumnType.UInt64, rowData);
434+
CheckValue(result, valueStr, formatString, expectedResult, ColumnType.UInt64, rowData);
402435
}
403436

404-
if (value <= Single.MaxValue
405-
&& value >= Single.MinValue
437+
if (value <= float.MaxValue
438+
&& value >= float.MinValue
406439
&& (numType == NumType.FloatDoubleOnly || numType == NumType.All)
407440
)
408441
{
409-
CheckValue(float.Parse(valueStr), valueStr, formatString, expectedResult, SampleDisplay.ColumnType.Single, rowData);
442+
CheckValue(float.Parse(valueStr), valueStr, formatString, expectedResult, ColumnType.Single, rowData);
410443

411444
Assert.IsTrue(float.TryParse(valueStr, out float result), $"TryParse failed for float {valueStr}");
412-
CheckValue(result, valueStr, formatString, expectedResult, SampleDisplay.ColumnType.Single, rowData);
445+
CheckValue(result, valueStr, formatString, expectedResult, ColumnType.Single, rowData);
413446
}
414447

415-
if (value <= Double.MaxValue
416-
&& value >= Double.MinValue
448+
if (value <= double.MaxValue
449+
&& value >= double.MinValue
417450
&& (numType == NumType.FloatDoubleOnly || numType == NumType.All)
418451
)
419452
{
420-
CheckValue(double.Parse(valueStr), valueStr, formatString, expectedResult, SampleDisplay.ColumnType.Double, rowData);
453+
CheckValue(double.Parse(valueStr), valueStr, formatString, expectedResult, ColumnType.Double, rowData);
421454

422455
Assert.IsTrue(double.TryParse(valueStr, out double result), $"TryParse failed for double {valueStr}");
423-
CheckValue(result, valueStr, formatString, expectedResult, SampleDisplay.ColumnType.Double, rowData);
456+
CheckValue(result, valueStr, formatString, expectedResult, ColumnType.Double, rowData);
424457
}
425458
}
426459

427-
private void CheckValue(object value, string valueStr, string formatString, string expectedResult, SampleDisplay.ColumnType columnType, SampleDisplay.RowData rowData)
460+
private void CheckValue(object value, string valueStr, string formatString, string expectedResult, ColumnType columnType, RowData rowData)
428461
{
429462
string result = string.Format($"{{0:{formatString}}}", new object[] { value });
430463
// 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)
471504

472505
public SampleDisplay()
473506
{
474-
AddColumn("Value", SampleDisplay.ColumnType.Value);
475-
AddColumn("Format", SampleDisplay.ColumnType.FormatString);
476-
AddColumn("SByte", SampleDisplay.ColumnType.SByte);
477-
AddColumn("Int16", SampleDisplay.ColumnType.Int16);
478-
AddColumn("Int32", SampleDisplay.ColumnType.Int32);
479-
AddColumn("Int64", SampleDisplay.ColumnType.Int64);
480-
AddColumn("Byte", SampleDisplay.ColumnType.Byte);
481-
AddColumn("UInt16", SampleDisplay.ColumnType.UInt16);
482-
AddColumn("UInt32", SampleDisplay.ColumnType.UInt32);
483-
AddColumn("UInt64", SampleDisplay.ColumnType.UInt64);
484-
AddColumn("Single", SampleDisplay.ColumnType.Single);
485-
AddColumn("Double", SampleDisplay.ColumnType.Double);
507+
AddColumn("Value", ColumnType.Value);
508+
AddColumn("Format", ColumnType.FormatString);
509+
AddColumn("SByte", ColumnType.SByte);
510+
AddColumn("Int16", ColumnType.Int16);
511+
AddColumn("Int32", ColumnType.Int32);
512+
AddColumn("Int64", ColumnType.Int64);
513+
AddColumn("Byte", ColumnType.Byte);
514+
AddColumn("UInt16", ColumnType.UInt16);
515+
AddColumn("UInt32", ColumnType.UInt32);
516+
AddColumn("UInt64", ColumnType.UInt64);
517+
AddColumn("Single", ColumnType.Single);
518+
AddColumn("Double", ColumnType.Double);
486519
}
487520

488521
public ColumnInfo GetColumnInfo(ColumnType columnType)

0 commit comments

Comments
 (0)