[fanfix.git] / src / be / nikiroo / utils / test / TestCase.java

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}.
 * 
 * @author niki
 */
abstract public class TestCase {
	/**
	 * The type of {@link Exception} used to signal a failed assertion or a
	 * force-fail.
	 * 
	 * @author niki
	 */
	class AssertException extends Exception {
		private static final long serialVersionUID = 1L;

		public AssertException(String reason, Exception source) {
			super(reason, source);
		}

		public AssertException(String reason) {
			super(reason);
		}
	}

	private String name;

	/**
	 * Create a new {@link TestCase}.
	 * 
	 * @param name
	 *            the test name
	 */
	public TestCase(String name) {
		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
	 */
	public void setUp() throws Exception {
	}

	/**
	 * Tear-down the test (called when the test has been ran).
	 * 
	 * @throws Exception
	 *             in case of error
	 */
	public void tearDown() throws Exception {
	}

	/**
	 * The test name.
	 * 
	 * @return the name
	 */
	public String getName() {
		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.
	 * 
	 * @throws Exception
	 *             in case of error
	 */
	abstract public void test() throws Exception;

	/**
	 * Force a failure.
	 * 
	 * @throws AssertException
	 *             every time
	 */
	public void fail() throws AssertException {
		fail(null);
	}

	/**
	 * Force a failure.
	 * 
	 * @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 : "", e);
	}

	/**
	 * Check that 2 {@link Object}s are equals.
	 * 
	 * @param expected
	 *            the expected value
	 * @param actual
	 *            the actual value
	 * 
	 * @throws AssertException
	 *             in case they differ
	 */
	public void assertEquals(Object expected, Object actual)
			throws AssertException {
		assertEquals(null, expected, actual);
	}

	/**
	 * Check that 2 {@link Object}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, Object expected, Object actual)
			throws AssertException {
		if ((expected == null && actual != null)
				|| (expected != null && !expected.equals(actual))) {
			if (errorMessage == null) {
				throw new AssertException(generateAssertMessage(expected,
						actual));
			}

			throw new AssertException(errorMessage, new AssertException(
					generateAssertMessage(expected, actual)));
		}
	}

	/**
	 * Check that 2 longs are equals.
	 * 
	 * @param expected
	 *            the expected value
	 * @param actual
	 *            the actual value
	 * 
	 * @throws AssertException
	 *             in case they differ
	 */
	public void assertEquals(long expected, long actual) throws AssertException {
		assertEquals(Long.valueOf(expected), Long.valueOf(actual));
	}

	/**
	 * Check that 2 longs 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, long expected, long actual)
			throws AssertException {
		assertEquals(errorMessage, Long.valueOf(expected), Long.valueOf(actual));
	}

	/**
	 * Check that 2 booleans are equals.
	 * 
	 * @param expected
	 *            the expected value
	 * @param actual
	 *            the actual value
	 * 
	 * @throws AssertException
	 *             in case they differ
	 */
	public void assertEquals(boolean expected, boolean actual)
			throws AssertException {
		assertEquals(Boolean.valueOf(expected), Boolean.valueOf(actual));
	}

	/**
	 * Check that 2 booleans 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, boolean expected,
			boolean actual) throws AssertException {
		assertEquals(errorMessage, Boolean.valueOf(expected),
				Boolean.valueOf(actual));
	}

	/**
	 * Check that 2 doubles are equals.
	 * 
	 * @param expected
	 *            the expected value
	 * @param actual
	 *            the actual value
	 * 
	 * @throws AssertException
	 *             in case they differ
	 */
	public void assertEquals(double expected, double actual)
			throws AssertException {
		assertEquals(Double.valueOf(expected), Double.valueOf(actual));
	}

	/**
	 * Check that 2 doubles 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, double expected, double actual)
			throws AssertException {
		assertEquals(errorMessage, Double.valueOf(expected),
				Double.valueOf(actual));
	}

	/**
	 * 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(List<?> expected, List<?> actual)
			throws AssertException {
		assertEquals("Assertion failed", expected, actual);
	}

	/**
	 * 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(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);
			}
		}
	}

	/**
	 * Check that given {@link Object} is not NULL.
	 * 
	 * @param errorMessage
	 *            the error message to display if it is NULL
	 * @param actual
	 *            the actual value
	 * 
	 * @throws AssertException
	 *             in case they differ
	 */
	public void assertNotNull(String errorMessage, Object actual)
			throws AssertException {
		if (actual == null) {
			String defaultReason = String.format("" //
					+ "Assertion failed!%n" //
					+ "Object should not have been NULL");

			if (errorMessage == null) {
				throw new AssertException(defaultReason);
			}

			throw new AssertException(errorMessage, new AssertException(
					defaultReason));
		}
	}

	/**
	 * Generate the default assert message for 2 different values that were
	 * supposed to be equals.
	 * 
	 * @param expected
	 *            the expected value
	 * @param actual
	 *            the actual value
	 * 
	 * @return the message
	 */
	public static String generateAssertMessage(Object expected, Object actual) {
		return String.format("" //
				+ "Assertion failed!%n" //
				+ "Expected value: [%s]%n" //
				+ "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();
	}
}
Commit	Line	Data
	1	package be.nikiroo.utils.test;
	2
	3	import java.io.File;
	4	import java.util.Arrays;
	5	import java.util.Collections;
	6	import java.util.List;
	7	import java.util.Map;
	8	import java.util.Map.Entry;
	9
	10	import be.nikiroo.utils.IOUtils;
	11
	12	/**
	13	* A {@link TestCase} that can be run with {@link TestLauncher}.
	14	*
	15	* @author niki
	16	*/
	17	abstract public class TestCase {
	18	/**
	19	* The type of {@link Exception} used to signal a failed assertion or a
	20	* force-fail.
	21	*
	22	* @author niki
	23	*/
	24	class AssertException extends Exception {
	25	private static final long serialVersionUID = 1L;
	26
	27	public AssertException(String reason, Exception source) {
	28	super(reason, source);
	29	}
	30
	31	public AssertException(String reason) {
	32	super(reason);
	33	}
	34	}
	35
	36	private String name;
	37
	38	/**
	39	* Create a new {@link TestCase}.
	40	*
	41	* @param name
	42	* the test name
	43	*/
	44	public TestCase(String name) {
	45	this.name = name;
	46	}
	47
	48	/**
	49	* This constructor can be used if you require a no-param constructor. In
	50	* this case, you are allowed to set the name manually via
	51	* {@link TestCase#setName}.
	52	*/
	53	protected TestCase() {
	54	this("no name");
	55	}
	56
	57	/**
	58	* Setup the test (called before the test is run).
	59	*
	60	* @throws Exception
	61	* in case of error
	62	*/
	63	public void setUp() throws Exception {
	64	}
	65
	66	/**
	67	* Tear-down the test (called when the test has been ran).
	68	*
	69	* @throws Exception
	70	* in case of error
	71	*/
	72	public void tearDown() throws Exception {
	73	}
	74
	75	/**
	76	* The test name.
	77	*
	78	* @return the name
	79	*/
	80	public String getName() {
	81	return name;
	82	}
	83
	84	/**
	85	* The test name.
	86	*
	87	* @param name
	88	* the new name (internal use only)
	89	*
	90	* @return this (so we can chain and so we can initialize it in a member
	91	* variable if this is an anonymous inner class)
	92	*/
	93	protected TestCase setName(String name) {
	94	this.name = name;
	95	return this;
	96	}
	97
	98	/**
	99	* Actually do the test.
	100	*
	101	* @throws Exception
	102	* in case of error
	103	*/
	104	abstract public void test() throws Exception;
	105
	106	/**
	107	* Force a failure.
	108	*
	109	* @throws AssertException
	110	* every time
	111	*/
	112	public void fail() throws AssertException {
	113	fail(null);
	114	}
	115
	116	/**
	117	* Force a failure.
	118	*
	119	* @param reason
	120	* the failure reason
	121	*
	122	* @throws AssertException
	123	* every time
	124	*/
	125	public void fail(String reason) throws AssertException {
	126	fail(reason, null);
	127	}
	128
	129	/**
	130	* Force a failure.
	131	*
	132	* @param reason
	133	* the failure reason
	134	* @param e
	135	* the exception that caused the failure (can be NULL)
	136	*
	137	* @throws AssertException
	138	* every time
	139	*/
	140	public void fail(String reason, Exception e) throws AssertException {
	141	throw new AssertException("Failed!" + //
	142	reason != null ? "\n" + reason : "", e);
	143	}
	144
	145	/**
	146	* Check that 2 {@link Object}s are equals.
	147	*
	148	* @param expected
	149	* the expected value
	150	* @param actual
	151	* the actual value
	152	*
	153	* @throws AssertException
	154	* in case they differ
	155	*/
	156	public void assertEquals(Object expected, Object actual)
	157	throws AssertException {
	158	assertEquals(null, expected, actual);
	159	}
	160
	161	/**
	162	* Check that 2 {@link Object}s are equals.
	163	*
	164	* @param errorMessage
	165	* the error message to display if they differ
	166	* @param expected
	167	* the expected value
	168	* @param actual
	169	* the actual value
	170	*
	171	* @throws AssertException
	172	* in case they differ
	173	*/
	174	public void assertEquals(String errorMessage, Object expected, Object actual)
	175	throws AssertException {
	176	if ((expected == null && actual != null)
	177	\|\| (expected != null && !expected.equals(actual))) {
	178	if (errorMessage == null) {
	179	throw new AssertException(generateAssertMessage(expected,
	180	actual));
	181	}
	182
	183	throw new AssertException(errorMessage, new AssertException(
	184	generateAssertMessage(expected, actual)));
	185	}
	186	}
	187
	188	/**
	189	* Check that 2 longs are equals.
	190	*
	191	* @param expected
	192	* the expected value
	193	* @param actual
	194	* the actual value
	195	*
	196	* @throws AssertException
	197	* in case they differ
	198	*/
	199	public void assertEquals(long expected, long actual) throws AssertException {
	200	assertEquals(Long.valueOf(expected), Long.valueOf(actual));
	201	}
	202
	203	/**
	204	* Check that 2 longs are equals.
	205	*
	206	* @param errorMessage
	207	* the error message to display if they differ
	208	* @param expected
	209	* the expected value
	210	* @param actual
	211	* the actual value
	212	*
	213	* @throws AssertException
	214	* in case they differ
	215	*/
	216	public void assertEquals(String errorMessage, long expected, long actual)
	217	throws AssertException {
	218	assertEquals(errorMessage, Long.valueOf(expected), Long.valueOf(actual));
	219	}
	220
	221	/**
	222	* Check that 2 booleans are equals.
	223	*
	224	* @param expected
	225	* the expected value
	226	* @param actual
	227	* the actual value
	228	*
	229	* @throws AssertException
	230	* in case they differ
	231	*/
	232	public void assertEquals(boolean expected, boolean actual)
	233	throws AssertException {
	234	assertEquals(Boolean.valueOf(expected), Boolean.valueOf(actual));
	235	}
	236
	237	/**
	238	* Check that 2 booleans are equals.
	239	*
	240	* @param errorMessage
	241	* the error message to display if they differ
	242	* @param expected
	243	* the expected value
	244	* @param actual
	245	* the actual value
	246	*
	247	* @throws AssertException
	248	* in case they differ
	249	*/
	250	public void assertEquals(String errorMessage, boolean expected,
	251	boolean actual) throws AssertException {
	252	assertEquals(errorMessage, Boolean.valueOf(expected),
	253	Boolean.valueOf(actual));
	254	}
	255
	256	/**
	257	* Check that 2 doubles are equals.
	258	*
	259	* @param expected
	260	* the expected value
	261	* @param actual
	262	* the actual value
	263	*
	264	* @throws AssertException
	265	* in case they differ
	266	*/
	267	public void assertEquals(double expected, double actual)
	268	throws AssertException {
	269	assertEquals(Double.valueOf(expected), Double.valueOf(actual));
	270	}
	271
	272	/**
	273	* Check that 2 doubles are equals.
	274	*
	275	* @param errorMessage
	276	* the error message to display if they differ
	277	* @param expected
	278	* the expected value
	279	* @param actual
	280	* the actual value
	281	*
	282	* @throws AssertException
	283	* in case they differ
	284	*/
	285	public void assertEquals(String errorMessage, double expected, double actual)
	286	throws AssertException {
	287	assertEquals(errorMessage, Double.valueOf(expected),
	288	Double.valueOf(actual));
	289	}
	290
	291	/**
	292	* Check that 2 {@link List}s are equals.
	293	*
	294	* @param errorMessage
	295	* the error message to display if they differ
	296	* @param expected
	297	* the expected value
	298	* @param actual
	299	* the actual value
	300	*
	301	* @throws AssertException
	302	* in case they differ
	303	*/
	304	public void assertEquals(List<?> expected, List<?> actual)
	305	throws AssertException {
	306	assertEquals("Assertion failed", expected, actual);
	307	}
	308
	309	/**
	310	* Check that 2 {@link List}s are equals.
	311	*
	312	* @param errorMessage
	313	* the error message to display if they differ
	314	* @param expected
	315	* the expected value
	316	* @param actual
	317	* the actual value
	318	*
	319	* @throws AssertException
	320	* in case they differ
	321	*/
	322	public void assertEquals(String errorMessage, List<?> expected,
	323	List<?> actual) throws AssertException {
	324
	325	if (expected.size() != actual.size()) {
	326	assertEquals(errorMessage + ": not same number of items",
	327	list(expected), list(actual));
	328	}
	329
	330	int size = expected.size();
	331	for (int i = 0; i < size; i++) {
	332	assertEquals(errorMessage + ": item " + i
	333	+ " (0-based) is not correct", expected.get(i),
	334	actual.get(i));
	335	}
	336	}
	337
	338	/**
	339	* Check that 2 {@link File}s are equals, by doing a line-by-line
	340	* comparison.
	341	*
	342	* @param expected
	343	* the expected value
	344	* @param actual
	345	* the actual value
	346	* @param errorMessage
	347	* the error message to display if they differ
	348	*
	349	* @throws AssertException
	350	* in case they differ
	351	*/
	352	public void assertEquals(File expected, File actual) throws AssertException {
	353	assertEquals(generateAssertMessage(expected, actual), expected, actual);
	354	}
	355
	356	/**
	357	* Check that 2 {@link File}s are equals, by doing a line-by-line
	358	* comparison.
	359	*
	360	* @param errorMessage
	361	* the error message to display if they differ
	362	* @param expected
	363	* the expected value
	364	* @param actual
	365	* the actual value
	366	*
	367	* @throws AssertException
	368	* in case they differ
	369	*/
	370	public void assertEquals(String errorMessage, File expected, File actual)
	371	throws AssertException {
	372	assertEquals(errorMessage, expected, actual, null);
	373	}
	374
	375	/**
	376	* Check that 2 {@link File}s are equals, by doing a line-by-line
	377	* comparison.
	378	*
	379	* @param errorMessage
	380	* the error message to display if they differ
	381	* @param expected
	382	* the expected value
	383	* @param actual
	384	* the actual value
	385	* @param skipCompare
	386	* skip the lines starting with some values for the given files
	387	* (relative path from base directory in recursive mode)
	388	*
	389	* @throws AssertException
	390	* in case they differ
	391	*/
	392	public void assertEquals(String errorMessage, File expected, File actual,
	393	Map<String, List<String>> skipCompare) throws AssertException {
	394	assertEquals(errorMessage, expected, actual, skipCompare, null);
	395	}
	396
	397	private void assertEquals(String errorMessage, File expected, File actual,
	398	Map<String, List<String>> skipCompare, String removeFromName)
	399	throws AssertException {
	400
	401	if (expected.isDirectory() \|\| actual.isDirectory()) {
	402	assertEquals(errorMessage + ": type mismatch: expected a "
	403	+ (expected.isDirectory() ? "directory" : "file")
	404	+ ", received a "
	405	+ (actual.isDirectory() ? "directory" : "file"),
	406	expected.isDirectory(), actual.isDirectory());
	407
	408	List<String> expectedFiles = Arrays.asList(expected.list());
	409	Collections.sort(expectedFiles);
	410	List<String> actualFiles = Arrays.asList(actual.list());
	411	Collections.sort(actualFiles);
	412
	413	assertEquals(errorMessage, expectedFiles, actualFiles);
	414	for (int i = 0; i < actualFiles.size(); i++) {
	415	File expectedFile = new File(expected, expectedFiles.get(i));
	416	File actualFile = new File(actual, actualFiles.get(i));
	417
	418	assertEquals(errorMessage, expectedFile, actualFile,
	419	skipCompare, expected.getAbsolutePath());
	420	}
	421	} else {
	422	try {
	423	List<String> expectedLines = Arrays.asList(IOUtils
	424	.readSmallFile(expected).split("\n"));
	425	List<String> resultLines = Arrays.asList(IOUtils.readSmallFile(
	426	actual).split("\n"));
	427
	428	String name = expected.getAbsolutePath();
	429	if (removeFromName != null && name.startsWith(removeFromName)) {
	430	name = expected.getName()
	431	+ name.substring(removeFromName.length());
	432	}
	433
	434	assertEquals(errorMessage + ": " + name
	435	+ ": the number of lines is not the same",
	436	expectedLines.size(), resultLines.size());
	437
	438	for (int j = 0; j < expectedLines.size(); j++) {
	439	String expectedLine = expectedLines.get(j);
	440	String resultLine = resultLines.get(j);
	441
	442	boolean skip = false;
	443	if (skipCompare != null) {
	444	for (Entry<String, List<String>> skipThose : skipCompare
	445	.entrySet()) {
	446	for (String skipStart : skipThose.getValue()) {
	447	if (name.endsWith(skipThose.getKey())
	448	&& expectedLine.startsWith(skipStart)
	449	&& resultLine.startsWith(skipStart)) {
	450	skip = true;
	451	}
	452	}
	453	}
	454	}
	455
	456	if (skip) {
	457	continue;
	458	}
	459
	460	assertEquals(errorMessage + ": line " + (j + 1)
	461	+ " is not the same in file " + name, expectedLine,
	462	resultLine);
	463	}
	464	} catch (Exception e) {
	465	throw new AssertException(errorMessage, e);
	466	}
	467	}
	468	}
	469
	470	/**
	471	* Check that given {@link Object} is not NULL.
	472	*
	473	* @param errorMessage
	474	* the error message to display if it is NULL
	475	* @param actual
	476	* the actual value
	477	*
	478	* @throws AssertException
	479	* in case they differ
	480	*/
	481	public void assertNotNull(String errorMessage, Object actual)
	482	throws AssertException {
	483	if (actual == null) {
	484	String defaultReason = String.format("" //
	485	+ "Assertion failed!%n" //
	486	+ "Object should not have been NULL");
	487
	488	if (errorMessage == null) {
	489	throw new AssertException(defaultReason);
	490	}
	491
	492	throw new AssertException(errorMessage, new AssertException(
	493	defaultReason));
	494	}
	495	}
	496
	497	/**
	498	* Generate the default assert message for 2 different values that were
	499	* supposed to be equals.
	500	*
	501	* @param expected
	502	* the expected value
	503	* @param actual
	504	* the actual value
	505	*
	506	* @return the message
	507	*/
	508	public static String generateAssertMessage(Object expected, Object actual) {
	509	return String.format("" //
	510	+ "Assertion failed!%n" //
	511	+ "Expected value: [%s]%n" //
	512	+ "Actual value: [%s]", expected, actual);
	513	}
	514
	515	private static String list(List<?> items) {
	516	StringBuilder builder = new StringBuilder();
	517	for (Object item : items) {
	518	if (builder.length() == 0) {
	519	builder.append(items.size() + " item(s): ");
	520	} else {
	521	builder.append(", ");
	522	}
	523
	524	builder.append("" + item);
	525
	526	if (builder.length() > 60) {
	527	builder.setLength(57);
	528	builder.append("...");
	529	break;
	530	}
	531	}
	532
	533	return builder.toString();
	534	}
	535	}