Skip to content

Commit

Permalink
Add messages to unit test assertions. (#1357)
Browse files Browse the repository at this point in the history
  • Loading branch information
@Jimmy-653
Jimmy-653 committed Oct 13, 2020
1 parent 166ef91 commit f131fa1
Show file tree
Hide file tree
Showing 5 changed files with 95 additions and 95 deletions.
2 changes: 1 addition & 1 deletion oshi-core/src/test/java/oshi/SystemInfoTest.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -76,7 +76,7 @@ public class SystemInfoTest {
*/
@Test
public void testPlatformEnum() {
assertNotEquals(PlatformEnum.UNKNOWN, SystemInfo.getCurrentPlatformEnum());
assertNotEquals("Test if this OS is supported.", PlatformEnum.UNKNOWN, SystemInfo.getCurrentPlatformEnum());
// Exercise the main method
main(null);
}
Expand Down
44 changes: 22 additions & 22 deletions oshi-core/src/test/java/oshi/util/EdidUtilTest.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -61,15 +61,15 @@ public class EdidUtilTest {

@Test
public void testGetEdidAttrs() {
assertEquals("A", EdidUtil.getManufacturerID(EDID));
assertEquals("9227", EdidUtil.getProductID(EDID));
assertEquals("162C0C25", EdidUtil.getSerialNo(EDID));
assertEquals((byte) 44, EdidUtil.getWeek(EDID));
assertEquals(2012, EdidUtil.getYear(EDID));
assertEquals("1.4", EdidUtil.getVersion(EDID));
assertTrue(EdidUtil.isDigital(EDID));
assertEquals(60, EdidUtil.getHcm(EDID));
assertEquals(34, EdidUtil.getVcm(EDID));
assertEquals("Parse manufacturerId.", "A", EdidUtil.getManufacturerID(EDID));
assertEquals("Parse productId.", "9227", EdidUtil.getProductID(EDID));
assertEquals("Parse serialNo.", "162C0C25", EdidUtil.getSerialNo(EDID));
assertEquals("Parse week.", (byte) 44, EdidUtil.getWeek(EDID));
assertEquals("Parse year.", 2012, EdidUtil.getYear(EDID));
assertEquals("Parse version.", "1.4", EdidUtil.getVersion(EDID));
assertTrue("Parse \"isDigital\".", EdidUtil.isDigital(EDID));
assertEquals("Parse hcm.", 60, EdidUtil.getHcm(EDID));
assertEquals("Parse vcm.",34, EdidUtil.getVcm(EDID));
}

@Test
Expand All @@ -81,23 +81,23 @@ public void testGetDescriptors() {
String range = EdidUtil.getDescriptorRangeLimits(descs[i]);
switch (i) {
case 0:
assertEquals(0x565E00A0, type);
assertEquals("Clock 241MHz, Active Pixels 2560x1440 ", timing);
assertEquals("Field Rate -96-41 Hz vertical, 80-48 Hz horizontal, Max clock: 320 MHz", range);
assertEquals("Parse first type.",0x565E00A0, type);
assertEquals("Parse first timing.","Clock 241MHz, Active Pixels 2560x1440 ", timing);
assertEquals("Parse first range.","Field Rate -96-41 Hz vertical, 80-48 Hz horizontal, Max clock: 320 MHz", range);
break;
case 1:
assertEquals(0x1A1D0080, type);
assertEquals("Clock 74MHz, Active Pixels 1280x720 ", timing);
assertEquals("Field Rate -48-28 Hz vertical, 32-64 Hz horizontal, Max clock: -1280 MHz", range);
assertEquals("Parse second type.",0x1A1D0080, type);
assertEquals("Parse second timing.","Clock 74MHz, Active Pixels 1280x720 ", timing);
assertEquals("Parse second range.","Field Rate -48-28 Hz vertical, 32-64 Hz horizontal, Max clock: -1280 MHz", range);
break;
case 2:
assertEquals(0xFF, type);
assertEquals("C02JM2PFF2GC", EdidUtil.getDescriptorText(descs[i]));
assertEquals(EDID_DESC3, ParseUtil.byteArrayToHexString(descs[i]));
assertEquals("Parse third type.",0xFF, type);
assertEquals("Parse third descriptorText.","C02JM2PFF2GC", EdidUtil.getDescriptorText(descs[i]));
assertEquals("Parse third descriptors completely.",EDID_DESC3, ParseUtil.byteArrayToHexString(descs[i]));
break;
case 3:
assertEquals(0xFC, type);
assertEquals("Thunderbolt", EdidUtil.getDescriptorText(descs[i]));
assertEquals("Parse fourth type.",0xFC, type);
assertEquals("Parse fourth descriptorText.","Thunderbolt", EdidUtil.getDescriptorText(descs[i]));
break;
default:
}
Expand All @@ -107,8 +107,8 @@ public void testGetDescriptors() {
@Test
public void testToString() {
String[] toString = EdidUtil.toString(EDID).split("\\n");
assertEquals(6, toString.length);
assertEquals("Parse edId toString.",6, toString.length);
toString = EdidUtil.toString(ParseUtil.hexStringToByteArray(EDID_STR2)).split("\\n");
assertEquals(6, toString.length);
assertEquals("Parse edId2 toString.",6, toString.length);
};
}
10 changes: 5 additions & 5 deletions oshi-core/src/test/java/oshi/util/ExecutingCommandTest.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -46,11 +46,11 @@ public class ExecutingCommandTest {
@Test
public void testRunNative() {
List<String> test = ExecutingCommand.runNative(ECHO);
assertEquals(1, test.size());
assertEquals("Test", test.get(0));
assertEquals("Test", ExecutingCommand.getFirstAnswer(ECHO));
assertEquals("Test command line returned expected number of outputs.",1, test.size());
assertEquals("Test command line returned expected string.","Test", test.get(0));
assertEquals("Test command line \"getFirstAnswer\" returned first output.","Test", ExecutingCommand.getFirstAnswer(ECHO));

assertTrue(ExecutingCommand.runNative(BAD_COMMAND).isEmpty());
assertTrue(ExecutingCommand.getFirstAnswer(BAD_COMMAND).isEmpty());
assertTrue("Test command line execution failed.",ExecutingCommand.runNative(BAD_COMMAND).isEmpty());
assertTrue("Test command line execution failed and didn't return a result.",ExecutingCommand.getFirstAnswer(BAD_COMMAND).isEmpty());
}
}
40 changes: 20 additions & 20 deletions oshi-core/src/test/java/oshi/util/FileUtilTest.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -23,15 +23,15 @@
*/
package oshi.util;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import org.junit.Test;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;

import org.junit.Test;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;

/**
* Tests FileUtil
Expand All @@ -55,7 +55,7 @@ public void testReadFile() {
List<String> thisFile = null;
// Try file not found
thisFile = FileUtil.readFile(NO_FILE);
assertEquals(0, thisFile.size());
assertEquals("Check that invalid file doesn't exists.", 0, thisFile.size());
// Try this file
thisFile = FileUtil.readFile(THISCLASS);
// Comment ONE line
Expand All @@ -73,28 +73,28 @@ public void testReadFile() {
break;
}
}
assertEquals(2, lineTwo - lineOne);
assertEquals("Check line numbers could be correctly read.", 2, lineTwo - lineOne);
}

/**
* Test get*FromFile
*/
@Test
public void testGetFromFile() {
assertEquals(123L, FileUtil.getUnsignedLongFromFile(INT_FILE));
assertEquals(0L, FileUtil.getUnsignedLongFromFile(STRING_FILE));
assertEquals(0L, FileUtil.getUnsignedLongFromFile(NO_FILE));
assertEquals("Read unsigned long from integer file.", 123L, FileUtil.getUnsignedLongFromFile(INT_FILE));
assertEquals("Read unsigned long from string file.", 0L, FileUtil.getUnsignedLongFromFile(STRING_FILE));
assertEquals("Read unsigned long from invalid file.", 0L, FileUtil.getUnsignedLongFromFile(NO_FILE));

assertEquals(123L, FileUtil.getLongFromFile(INT_FILE));
assertEquals(0L, FileUtil.getLongFromFile(STRING_FILE));
assertEquals(0L, FileUtil.getLongFromFile(NO_FILE));
assertEquals("Read long from integer file.", 123L, FileUtil.getLongFromFile(INT_FILE));
assertEquals("Read long from string file.", 0L, FileUtil.getLongFromFile(STRING_FILE));
assertEquals("Read long from invalid file.", 0L, FileUtil.getLongFromFile(NO_FILE));

assertEquals(123, FileUtil.getIntFromFile(INT_FILE));
assertEquals(0, FileUtil.getIntFromFile(STRING_FILE));
assertEquals(0, FileUtil.getIntFromFile(NO_FILE));
assertEquals("Read int from integer file.", 123, FileUtil.getIntFromFile(INT_FILE));
assertEquals("Read int from string file.", 0, FileUtil.getIntFromFile(STRING_FILE));
assertEquals("Read int from invalid file.", 0, FileUtil.getIntFromFile(NO_FILE));

assertEquals("123", FileUtil.getStringFromFile(INT_FILE));
assertEquals("", FileUtil.getStringFromFile(NO_FILE));
assertEquals("Read string from integer file.", "123", FileUtil.getStringFromFile(INT_FILE));
assertEquals("Read string from invalid file.", "", FileUtil.getStringFromFile(NO_FILE));
}

@Test
Expand All @@ -108,17 +108,17 @@ public void testReadProcIo() {
expected.put("write_bytes", "124780544");
expected.put("cancelled_write_bytes", "42");
Map<String, String> actual = FileUtil.getKeyValueMapFromFile(PROCIO_FILE, ":");
assertEquals(expected.size(), actual.size());
assertEquals("Check key-value file returned correct number of items.", expected.size(), actual.size());
for (String key : expected.keySet()) {
assertEquals(expected.get(key), actual.get(key));
assertEquals("Check key-value item equals the test value.", expected.get(key), actual.get(key));
}
}

@Test
public void testReadProperties() {
Properties props = FileUtil.readPropertiesFromFilename("simplelogger.properties");
assertEquals("INFO", props.getProperty("org.slf4j.simpleLogger.defaultLogLevel"));
assertEquals("Check properties file was read correctly.", "INFO", props.getProperty("org.slf4j.simpleLogger.defaultLogLevel"));
props = FileUtil.readPropertiesFromFilename("this.file.does.not.exist");
assertFalse(props.elements().hasMoreElements());
assertFalse("Check properties could not be read from invalid file.", props.elements().hasMoreElements());
}
}
94 changes: 47 additions & 47 deletions oshi-core/src/test/java/oshi/util/FormatUtilTest.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -53,12 +53,12 @@ public static void setUpClass() {
*/
@Test
public void testFormatBytes() {
assertEquals("0 bytes", FormatUtil.formatBytes(0));
assertEquals("1 byte", FormatUtil.formatBytes(1));
assertEquals("532 bytes", FormatUtil.formatBytes(532));
assertEquals("1 KiB", FormatUtil.formatBytes(1024));
assertEquals("1 GiB", FormatUtil.formatBytes(1024 * 1024 * 1024));
assertEquals("1 TiB", FormatUtil.formatBytes(1099511627776L));
assertEquals("Test format bytes.", "0 bytes", FormatUtil.formatBytes(0));
assertEquals("Test format byte.", "1 byte", FormatUtil.formatBytes(1));
assertEquals("Test format bytes.","532 bytes", FormatUtil.formatBytes(532));
assertEquals("Test format KiByte.","1 KiB", FormatUtil.formatBytes(1024));
assertEquals("Test format GiByte.","1 GiB", FormatUtil.formatBytes(1024 * 1024 * 1024));
assertEquals("Test format TiByte.","1 TiB", FormatUtil.formatBytes(1099511627776L));
}

/**
Expand All @@ -72,25 +72,25 @@ public void testFormatBytesWithDecimalSeparator() {
String expected4 = "1" + DECIMAL_SEPARATOR + "1 TiB";
String expected5 = "1" + DECIMAL_SEPARATOR + "1 PiB";
String expected6 = "1" + DECIMAL_SEPARATOR + "1 EiB";
assertEquals(expected1, FormatUtil.formatBytes(1340));
assertEquals(expected2, FormatUtil.formatBytes(2400016));
assertEquals(expected3, FormatUtil.formatBytes(2400000000L));
assertEquals(expected4, FormatUtil.formatBytes(1099511627776L + 109951162777L));
assertEquals(expected5, FormatUtil.formatBytes(1125899906842624L + 112589990684262L));
assertEquals(expected6, FormatUtil.formatBytes(1152921504606846976L + 115292150460684698L));
assertEquals("Test format KiBytes with decimal separator.",expected1, FormatUtil.formatBytes(1340));
assertEquals("Test format MiBytes with decimal separator.",expected2, FormatUtil.formatBytes(2400016));
assertEquals("Test format GiBytes with decimal separator.",expected3, FormatUtil.formatBytes(2400000000L));
assertEquals("Test format TiBytes with decimal separator.",expected4, FormatUtil.formatBytes(1099511627776L + 109951162777L));
assertEquals("Test format PiBytes with decimal separator.",expected5, FormatUtil.formatBytes(1125899906842624L + 112589990684262L));
assertEquals("Test format EiBytes with decimal separator.",expected6, FormatUtil.formatBytes(1152921504606846976L + 115292150460684698L));
}

/**
* Test format decimal bytes.
*/
@Test
public void testFormatBytesDecimal() {
assertEquals("0 bytes", FormatUtil.formatBytesDecimal(0));
assertEquals("1 byte", FormatUtil.formatBytesDecimal(1));
assertEquals("532 bytes", FormatUtil.formatBytesDecimal(532));
assertEquals("1 KB", FormatUtil.formatBytesDecimal(1000));
assertEquals("1 GB", FormatUtil.formatBytesDecimal(1000 * 1000 * 1000));
assertEquals("1 TB", FormatUtil.formatBytesDecimal(1000000000000L));
assertEquals("Test format bytesDecimal.", "0 bytes", FormatUtil.formatBytesDecimal(0));
assertEquals("Test format byteDecimal.", "1 byte", FormatUtil.formatBytesDecimal(1));
assertEquals("Test format bytesDecimal.", "532 bytes", FormatUtil.formatBytesDecimal(532));
assertEquals("Test format KbytesDecimal.", "1 KB", FormatUtil.formatBytesDecimal(1000));
assertEquals("Test format GbytesDecimal.", "1 GB", FormatUtil.formatBytesDecimal(1000 * 1000 * 1000));
assertEquals("Test format TbytesDecimal.", "1 TB", FormatUtil.formatBytesDecimal(1000000000000L));
}

/**
Expand All @@ -104,77 +104,77 @@ public void testFormatBytesDecimalWithDecimalSeparator() {
String expected4 = "1" + DECIMAL_SEPARATOR + "1 TB";
String expected5 = "3" + DECIMAL_SEPARATOR + "4 PB";
String expected6 = "5" + DECIMAL_SEPARATOR + "6 EB";
assertEquals(expected1, FormatUtil.formatBytesDecimal(1300));
assertEquals(expected2, FormatUtil.formatBytesDecimal(2300000));
assertEquals(expected3, FormatUtil.formatBytesDecimal(2200000000L));
assertEquals(expected4, FormatUtil.formatBytesDecimal(1100000000000L));
assertEquals(expected5, FormatUtil.formatBytesDecimal(3400000000000000L));
assertEquals(expected6, FormatUtil.formatBytesDecimal(5600000000000000000L));
assertEquals("Test format KBytes with decimal separator.", expected1, FormatUtil.formatBytesDecimal(1300));
assertEquals("Test format MBytes with decimal separator.", expected2, FormatUtil.formatBytesDecimal(2300000));
assertEquals("Test format GBytes with decimal separator.", expected3, FormatUtil.formatBytesDecimal(2200000000L));
assertEquals("Test format TBytes with decimal separator.", expected4, FormatUtil.formatBytesDecimal(1100000000000L));
assertEquals("Test format PBytes with decimal separator.", expected5, FormatUtil.formatBytesDecimal(3400000000000000L));
assertEquals("Test format EBytes with decimal separator.", expected6, FormatUtil.formatBytesDecimal(5600000000000000000L));
}

/**
* Test format hertz.
*/
@Test
public void testFormatHertz() {
assertEquals("0 Hz", FormatUtil.formatHertz(0));
assertEquals("1 Hz", FormatUtil.formatHertz(1));
assertEquals("999 Hz", FormatUtil.formatHertz(999));
assertEquals("1 KHz", FormatUtil.formatHertz(1000));
assertEquals("1 MHz", FormatUtil.formatHertz(1000 * 1000));
assertEquals("1 GHz", FormatUtil.formatHertz(1000 * 1000 * 1000));
assertEquals("1 THz", FormatUtil.formatHertz(1000L * 1000L * 1000L * 1000L));
assertEquals("Test format zero Hertz.", "0 Hz", FormatUtil.formatHertz(0));
assertEquals("Test format one Hertz.", "1 Hz", FormatUtil.formatHertz(1));
assertEquals("Test format many Hertz.", "999 Hz", FormatUtil.formatHertz(999));
assertEquals("Test format KHertz.", "1 KHz", FormatUtil.formatHertz(1000));
assertEquals("Test format MHertz.", "1 MHz", FormatUtil.formatHertz(1000 * 1000));
assertEquals("Test format GHertz.", "1 GHz", FormatUtil.formatHertz(1000 * 1000 * 1000));
assertEquals("Test format THertz.", "1 THz", FormatUtil.formatHertz(1000L * 1000L * 1000L * 1000L));
}

/**
* Test format elapsed secs
*/
@Test
public void testFormatElapsedSecs() {
assertEquals("0 days, 00:00:00", FormatUtil.formatElapsedSecs(0));
assertEquals("0 days, 03:25:45", FormatUtil.formatElapsedSecs(12345));
assertEquals("1 days, 10:17:36", FormatUtil.formatElapsedSecs(123456));
assertEquals("14 days, 06:56:07", FormatUtil.formatElapsedSecs(1234567));
assertEquals("Test format 0 elapsed seconds.", "0 days, 00:00:00", FormatUtil.formatElapsedSecs(0));
assertEquals("Test format many elapsed seconds.", "0 days, 03:25:45", FormatUtil.formatElapsedSecs(12345));
assertEquals("Test format elapsed day in seconds.", "1 days, 10:17:36", FormatUtil.formatElapsedSecs(123456));
assertEquals("Test format elapsed days in seconds.", "14 days, 06:56:07", FormatUtil.formatElapsedSecs(1234567));
}

/**
* Test round.
*/
@Test
public void testRound() {
assertEquals(42.42, FormatUtil.round(42.423f, 2), 0.00001f);
assertEquals(42.43, FormatUtil.round(42.425f, 2), 0.00001f);
assertEquals(42.5, FormatUtil.round(42.499f, 2), 0.00001f);
assertEquals(42, FormatUtil.round(42, 2), 0.00001f);
assertEquals("Test round down.", 42.42, FormatUtil.round(42.423f, 2), 0.00001f);
assertEquals("Test round up.", 42.43, FormatUtil.round(42.425f, 2), 0.00001f);
assertEquals("Test round double up.", 42.5, FormatUtil.round(42.499f, 2), 0.00001f);
assertEquals("Test round none.", 42, FormatUtil.round(42, 2), 0.00001f);
}

/**
* Test unsigned int to long.
*/
@Test
public void testGetUnsignedInt() {
assertEquals(4294967295L, FormatUtil.getUnsignedInt(-1));
assertEquals("Return unsigned int.",4294967295L, FormatUtil.getUnsignedInt(-1));
}

/**
* Test unsigned string
*/
@Test
public void testToUnsignedString() {
assertEquals("1", FormatUtil.toUnsignedString(0x00000001));
assertEquals("2147483648", FormatUtil.toUnsignedString(0x80000000));
assertEquals("4294967295", FormatUtil.toUnsignedString(0xffffffff));
assertEquals("Integer to unsigned string.", "1", FormatUtil.toUnsignedString(0x00000001));
assertEquals("Big Integer to unsigned string.", "2147483648", FormatUtil.toUnsignedString(0x80000000));
assertEquals("INT_MAX to unsigned string.", "4294967295", FormatUtil.toUnsignedString(0xffffffff));

assertEquals("1", FormatUtil.toUnsignedString(0x0000000000000001L));
assertEquals("9223372036854775808", FormatUtil.toUnsignedString(0x8000000000000000L));
assertEquals("18446744073709551615", FormatUtil.toUnsignedString(0xffffffffffffffffL));
assertEquals("Long to unsigned string.", "1", FormatUtil.toUnsignedString(0x0000000000000001L));
assertEquals("Big Long to unsigned string.", "9223372036854775808", FormatUtil.toUnsignedString(0x8000000000000000L));
assertEquals("LONG_MAX to unsigned string.", "18446744073709551615", FormatUtil.toUnsignedString(0xffffffffffffffffL));
}

/**
* Test format error
*/
@Test
public void testFormatError() {
assertEquals("0xB66A00A8", FormatUtil.formatError(-1234567000));
assertEquals("Format error code.", "0xB66A00A8", FormatUtil.formatError(-1234567000));
}
}

0 comments on commit f131fa1

Please sign in to comment.