package be.nikiroo.utils.test;
+import java.io.File;
+import java.util.Arrays;
+import java.util.Collections;
import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import be.nikiroo.utils.IOUtils;
/**
* A {@link TestCase} that can be run with {@link TestLauncher}.
this.name = name;
}
+ /**
+ * This constructor can be used if you require a no-param constructor. In
+ * this case, you are allowed to set the name manually via
+ * {@link TestCase#setName}.
+ */
+ protected TestCase() {
+ this("no name");
+ }
+
/**
* Setup the test (called before the test is run).
*
* @throws Exception
* in case of error
*/
- @SuppressWarnings("unused")
public void setUp() throws Exception {
}
* @throws Exception
* in case of error
*/
- @SuppressWarnings("unused")
public void tearDown() throws Exception {
}
return name;
}
+ /**
+ * The test name.
+ *
+ * @param name
+ * the new name (internal use only)
+ *
+ * @return this (so we can chain and so we can initialize it in a member
+ * variable if this is an anonymous inner class)
+ */
+ protected TestCase setName(String name) {
+ this.name = name;
+ return this;
+ }
+
/**
* Actually do the test.
*
*
* @param reason
* the failure reason
+ *
* @throws AssertException
* every time
*/
public void fail(String reason) throws AssertException {
+ fail(reason, null);
+ }
+
+ /**
+ * Force a failure.
+ *
+ * @param reason
+ * the failure reason
+ * @param e
+ * the exception that caused the failure (can be NULL)
+ *
+ * @throws AssertException
+ * every time
+ */
+ public void fail(String reason, Exception e) throws AssertException {
throw new AssertException("Failed!" + //
- reason != null ? "\n" + reason : "");
+ reason != null ? "\n" + reason : "", e);
}
/**
*/
public void assertEquals(List<?> expected, List<?> actual)
throws AssertException {
+ assertEquals("Assertion failed", expected, actual);
+ }
- assertEquals("The 2 lists don't contain the same number of items",
- expected.size(), actual.size());
+ /**
+ * Check that 2 {@link List}s are equals.
+ *
+ * @param errorMessage
+ * the error message to display if they differ
+ * @param expected
+ * the expected value
+ * @param actual
+ * the actual value
+ *
+ * @throws AssertException
+ * in case they differ
+ */
+ public void assertEquals(String errorMessage, List<?> expected,
+ List<?> actual) throws AssertException {
+
+ if (expected.size() != actual.size()) {
+ assertEquals(errorMessage + ": not same number of items",
+ list(expected), list(actual));
+ }
int size = expected.size();
for (int i = 0; i < size; i++) {
- assertEquals("Line " + i + " (0-based) is not correct",
- expected.get(i), actual.get(i));
+ assertEquals(errorMessage + ": item " + i
+ + " (0-based) is not correct", expected.get(i),
+ actual.get(i));
+ }
+ }
+
+ /**
+ * Check that 2 {@link File}s are equals, by doing a line-by-line
+ * comparison.
+ *
+ * @param expected
+ * the expected value
+ * @param actual
+ * the actual value
+ * @param errorMessage
+ * the error message to display if they differ
+ *
+ * @throws AssertException
+ * in case they differ
+ */
+ public void assertEquals(File expected, File actual) throws AssertException {
+ assertEquals(generateAssertMessage(expected, actual), expected, actual);
+ }
+
+ /**
+ * Check that 2 {@link File}s are equals, by doing a line-by-line
+ * comparison.
+ *
+ * @param errorMessage
+ * the error message to display if they differ
+ * @param expected
+ * the expected value
+ * @param actual
+ * the actual value
+ *
+ * @throws AssertException
+ * in case they differ
+ */
+ public void assertEquals(String errorMessage, File expected, File actual)
+ throws AssertException {
+ assertEquals(errorMessage, expected, actual, null);
+ }
+
+ /**
+ * Check that 2 {@link File}s are equals, by doing a line-by-line
+ * comparison.
+ *
+ * @param errorMessage
+ * the error message to display if they differ
+ * @param expected
+ * the expected value
+ * @param actual
+ * the actual value
+ * @param skipCompare
+ * skip the lines starting with some values for the given files
+ * (relative path from base directory in recursive mode)
+ *
+ * @throws AssertException
+ * in case they differ
+ */
+ public void assertEquals(String errorMessage, File expected, File actual,
+ Map<String, List<String>> skipCompare) throws AssertException {
+ assertEquals(errorMessage, expected, actual, skipCompare, null);
+ }
+
+ private void assertEquals(String errorMessage, File expected, File actual,
+ Map<String, List<String>> skipCompare, String removeFromName)
+ throws AssertException {
+
+ if (expected.isDirectory() || actual.isDirectory()) {
+ assertEquals(errorMessage + ": type mismatch: expected a "
+ + (expected.isDirectory() ? "directory" : "file")
+ + ", received a "
+ + (actual.isDirectory() ? "directory" : "file"),
+ expected.isDirectory(), actual.isDirectory());
+
+ List<String> expectedFiles = Arrays.asList(expected.list());
+ Collections.sort(expectedFiles);
+ List<String> actualFiles = Arrays.asList(actual.list());
+ Collections.sort(actualFiles);
+
+ assertEquals(errorMessage, expectedFiles, actualFiles);
+ for (int i = 0; i < actualFiles.size(); i++) {
+ File expectedFile = new File(expected, expectedFiles.get(i));
+ File actualFile = new File(actual, actualFiles.get(i));
+
+ assertEquals(errorMessage, expectedFile, actualFile,
+ skipCompare, expected.getAbsolutePath());
+ }
+ } else {
+ try {
+ List<String> expectedLines = Arrays.asList(IOUtils
+ .readSmallFile(expected).split("\n"));
+ List<String> resultLines = Arrays.asList(IOUtils.readSmallFile(
+ actual).split("\n"));
+
+ String name = expected.getAbsolutePath();
+ if (removeFromName != null && name.startsWith(removeFromName)) {
+ name = expected.getName()
+ + name.substring(removeFromName.length());
+ }
+
+ assertEquals(errorMessage + ": " + name
+ + ": the number of lines is not the same",
+ expectedLines.size(), resultLines.size());
+
+ for (int j = 0; j < expectedLines.size(); j++) {
+ String expectedLine = expectedLines.get(j);
+ String resultLine = resultLines.get(j);
+
+ boolean skip = false;
+ if (skipCompare != null) {
+ for (Entry<String, List<String>> skipThose : skipCompare
+ .entrySet()) {
+ for (String skipStart : skipThose.getValue()) {
+ if (name.endsWith(skipThose.getKey())
+ && expectedLine.startsWith(skipStart)
+ && resultLine.startsWith(skipStart)) {
+ skip = true;
+ }
+ }
+ }
+ }
+
+ if (skip) {
+ continue;
+ }
+
+ assertEquals(errorMessage + ": line " + (j + 1)
+ + " is not the same in file " + name, expectedLine,
+ resultLine);
+ }
+ } catch (Exception e) {
+ throw new AssertException(errorMessage, e);
+ }
}
}
return String.format("" //
+ "Assertion failed!%n" //
+ "Expected value: [%s]%n" //
- + "Actual value: [%s]", expected, actual);
+ + "Actual value: [%s]", expected, actual);
+ }
+
+ private static String list(List<?> items) {
+ StringBuilder builder = new StringBuilder();
+ for (Object item : items) {
+ if (builder.length() == 0) {
+ builder.append(items.size() + " item(s): ");
+ } else {
+ builder.append(", ");
+ }
+
+ builder.append("" + item);
+
+ if (builder.length() > 60) {
+ builder.setLength(57);
+ builder.append("...");
+ break;
+ }
+ }
+
+ return builder.toString();
}
}
git://git.nikiroo.be / nikiroo-utils.git / blobdiff