Index: /trunk/java-utils-test/.classpath =================================================================== --- /trunk/java-utils-test/.classpath (revision 436) +++ /trunk/java-utils-test/.classpath (revision 436) @@ -0,0 +1,14 @@ + + + + + + + + + + + + + + Index: /trunk/java-utils-test/.project =================================================================== --- /trunk/java-utils-test/.project (revision 436) +++ /trunk/java-utils-test/.project (revision 436) @@ -0,0 +1,17 @@ + + + JavaHelperLibTest + + + + + + org.eclipse.jdt.core.javabuilder + + + + + + org.eclipse.jdt.core.javanature + + Index: /trunk/java-utils-test/.settings/org.eclipse.jdt.core.prefs =================================================================== --- /trunk/java-utils-test/.settings/org.eclipse.jdt.core.prefs (revision 436) +++ /trunk/java-utils-test/.settings/org.eclipse.jdt.core.prefs (revision 436) @@ -0,0 +1,4 @@ +#Fri Oct 07 20:16:06 EDT 2011 +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.compliance=1.6 +org.eclipse.jdt.core.compiler.source=1.6 Index: /trunk/java-utils-test/src/de/ugoe/cs/util/ArrayToolsTest.java =================================================================== --- /trunk/java-utils-test/src/de/ugoe/cs/util/ArrayToolsTest.java (revision 436) +++ /trunk/java-utils-test/src/de/ugoe/cs/util/ArrayToolsTest.java (revision 436) @@ -0,0 +1,189 @@ +package de.ugoe.cs.util; + +import org.junit.*; +import static org.junit.Assert.*; + +/** + * The class ArrayToolsTest contains tests for the class + * {@link ArrayTools}. + * + * @author Steffen Herbold + * @version 1.0 + */ +public class ArrayToolsTest { + + Integer array[]; + + @Test + public void testFindIndex_1() throws Exception { + Integer target = 3; + int expected = 3; + + int result = ArrayTools.findIndex(array, target); + + assertEquals(expected, result); + } + + @Test + public void testFindIndex_2() throws Exception { + Integer target = 4; + int expected = 4; + + int result = ArrayTools.findIndex(array, target); + + assertEquals(expected, result); + } + + @Test + public void testFindIndex_3() throws Exception { + Integer target = 7; + + int result = ArrayTools.findIndex(array, target); + int expected = -1; + + assertEquals(expected, result); + } + + @Test + public void testFindIndex_4() throws Exception { + Integer target = null; + int result = ArrayTools.findIndex(array, target); + int expected = 7; + assertEquals(expected, result); + } + + @Test + public void testFindIndex_5() throws Exception { + Object[] array = new Object[0]; + Object other = new Object(); + + int result = ArrayTools.findIndex(array, other); + + assertEquals(-1, result); + } + + @Test + public void testFindMax_1() throws Exception { + int expected = 8; + + int result = ArrayTools.findMax(array); + + assertEquals(expected, result); + } + + @Test + public void testFindMax_2() throws Exception { + Integer[] arrayUnsorted = new Integer[]{2,3,6,1,8,9,1,1,3,15,4,0,-1}; + int expected = 9; + + int result = ArrayTools.findMax(arrayUnsorted); + + assertEquals(expected, result); + } + + @Test + public void testFindMax_3() throws Exception { + Integer[] arrayUnsorted = new Integer[]{2,3,6,1,8,9,1,1,3,15,4,15,-1}; + int expected = 9; + + int result = ArrayTools.findMax(arrayUnsorted); + + assertEquals(expected, result); + } + + @Test + public void testFindMax_4() throws Exception { + Integer[] arrayNoLenght = new Integer[]{}; + int expected = -1; + + int result = ArrayTools.findMax(arrayNoLenght); + + assertEquals(expected, result); + } + + @Test + public void testFindMax_5() throws Exception { + Integer[] arrayNulls = new Integer[]{null, null}; + int expected = -1; + + int result = ArrayTools.findMax(arrayNulls); + + assertEquals(expected, result); + } + + @Test + public void testFindMax_6() throws Exception { + int expected = -1; + + int result = ArrayTools.findMax(null); + + assertEquals(expected, result); + } + + @Test + public void testFindMin_1() throws Exception { + int expected = 0; + + int result = ArrayTools.findMin(array); + + assertEquals(expected, result); + } + + @Test + public void testFindMin_2() throws Exception { + Integer[] arrayUnsorted = new Integer[]{2,3,6,1,8,9,1,1,-3,15,4,0,-1}; + int expected = 8; + + int result = ArrayTools.findMin(arrayUnsorted); + + assertEquals(expected, result); + } + + @Test + public void testFindMin_3() throws Exception { + Integer[] arrayUnsorted = new Integer[]{2,3,6,1,8,9,1,-1,3,15,4,15,-1}; + int expected = 7; + + int result = ArrayTools.findMin(arrayUnsorted); + + assertEquals(expected, result); + } + + @Test + public void testFindMin_4() throws Exception { + Integer[] arrayNoLenght = new Integer[]{}; + int expected = -1; + + int result = ArrayTools.findMin(arrayNoLenght); + + assertEquals(expected, result); + } + + @Test + public void testFindMin_5() throws Exception { + Integer[] arrayNulls = new Integer[]{null, null}; + int expected = -1; + + int result = ArrayTools.findMin(arrayNulls); + + assertEquals(expected, result); + } + + @Test + public void testFindMin_6() throws Exception { + int expected = -1; + + int result = ArrayTools.findMin(null); + + assertEquals(expected, result); + } + + @Before + public void setUp() throws Exception { + array = new Integer[] { 0, 1, 2, 3, 4, 4, 5, null, 6 }; + } + + public static void main(String[] args) { + new org.junit.runner.JUnitCore().run(ArrayToolsTest.class); + } +} Index: /trunk/java-utils-test/src/de/ugoe/cs/util/FileToolsTest.java =================================================================== --- /trunk/java-utils-test/src/de/ugoe/cs/util/FileToolsTest.java (revision 436) +++ /trunk/java-utils-test/src/de/ugoe/cs/util/FileToolsTest.java (revision 436) @@ -0,0 +1,64 @@ +package de.ugoe.cs.util; + +import org.junit.*; +import static org.junit.Assert.*; + +/** + * The class FileToolsTest contains tests for the class + * {@link FileTools}. + * + * @author Steffen Herbold + * @version 1.0 + */ +public class FileToolsTest { + + final static String filenameNoCR = "testdata/de.ugoe.cs.util.FileToolsTest/testdata-nocr.txt"; + final static String filenameCR = "testdata/de.ugoe.cs.util.FileToolsTest/testdata-cr.txt"; + final static String filenameNotExists = "testdata/de.ugoe.cs.util.FileToolsTest/doesnotexist.txt"; + + final static String[] expectedLines = { "line1", "line2", "line3", "", + "line5" }; + + final static String[] expectedLinesCR = { "line1\r", "line2\r", "line3\r", + "\r", "line5" }; + + final static String[] expectedWrongCR = { "line1\nline2\nline3\n\nline5" }; + + @Test + public void testGetLinesFromFile_1() throws Exception { + String[] result = FileTools.getLinesFromFile(filenameCR, true); + assertArrayEquals(expectedLines, result); + } + + @Test + public void testGetLinesFromFile_2() throws Exception { + String[] result = FileTools.getLinesFromFile(filenameNoCR, true); + assertArrayEquals(expectedWrongCR, result); + } + + @Test + public void testGetLinesFromFile_3() throws Exception { + String[] result = FileTools.getLinesFromFile(filenameNoCR, false); + assertArrayEquals(expectedLines, result); + } + + @Test + public void testGetLinesFromFile_4() throws Exception { + String[] result = FileTools.getLinesFromFile(filenameCR, false); + assertArrayEquals(expectedLinesCR, result); + } + + @Test(expected = java.io.FileNotFoundException.class) + public void testGetLinesFromFile_5() throws Exception { + FileTools.getLinesFromFile(filenameNotExists, true); + } + + @Test(expected = java.io.FileNotFoundException.class) + public void testGetLinesFromFile_6() throws Exception { + FileTools.getLinesFromFile(filenameNotExists, false); + } + + public static void main(String[] args) { + new org.junit.runner.JUnitCore().run(FileToolsTest.class); + } +} Index: /trunk/java-utils-test/src/de/ugoe/cs/util/StringToolsTest.java =================================================================== --- /trunk/java-utils-test/src/de/ugoe/cs/util/StringToolsTest.java (revision 436) +++ /trunk/java-utils-test/src/de/ugoe/cs/util/StringToolsTest.java (revision 436) @@ -0,0 +1,136 @@ +package de.ugoe.cs.util; + +import org.junit.*; +import static org.junit.Assert.*; + +/** + * The class StringToolsTest contains tests for the class + * {@link StringTools}. + * + * @author Steffen Herbold + * @version 1.0 + */ +public class StringToolsTest { + + @Test + public void testXmlEntityReplacement_1() throws Exception { + String str = "abc"; + + String result = StringTools.xmlEntityReplacement(str); + + // add additional test code here + assertEquals("abc", result); + } + + @Test + public void testXmlEntityReplacement_2() throws Exception { + String str = "a&bc"; + String result = StringTools.xmlEntityReplacement(str); + assertEquals("a&bc", result); + } + + @Test + public void testXmlEntityReplacement_3() throws Exception { + String str = "a\"bc"; + String result = StringTools.xmlEntityReplacement(str); + assertEquals("a"bc", result); + } + + @Test + public void testXmlEntityReplacement_4() throws Exception { + String str = "a'bc"; + String result = StringTools.xmlEntityReplacement(str); + assertEquals("a'bc", result); + } + + @Test + public void testXmlEntityReplacement_5() throws Exception { + String str = "aTestAll builds a suite that can be used to run all + * of the tests within its package as well as within any subpackages of its + * package. + * + * @author Steffen Herbold + * @version 1.0 + */ +@RunWith(Suite.class) +@Suite.SuiteClasses({ + StringToolsTest.class, + FileToolsTest.class, + ArrayToolsTest.class, + de.ugoe.cs.util.console.TestAll.class +}) +public class TestAll { + + public static void main(String[] args) { + JUnitCore.runClasses(new Class[] { TestAll.class }); + } +} Index: /trunk/java-utils-test/src/de/ugoe/cs/util/console/CommandExecuterTest.java =================================================================== --- /trunk/java-utils-test/src/de/ugoe/cs/util/console/CommandExecuterTest.java (revision 436) +++ /trunk/java-utils-test/src/de/ugoe/cs/util/console/CommandExecuterTest.java (revision 436) @@ -0,0 +1,101 @@ +package de.ugoe.cs.util.console; + +import org.junit.*; + +import de.ugoe.cs.util.console.mock.MockOutputListener; +import static org.junit.Assert.*; + +/** + * The class CommandExecuterTest contains tests for the class + * {@link CommandExecuter}. + * + * @author Steffen Herbold + * @version 1.0 + */ +public class CommandExecuterTest { + + @Test(expected=java.security.InvalidParameterException.class) + public void testAddCommandPackage_1() + throws Exception { + CommandExecuter fixture = CommandExecuter.getInstance(); + + fixture.addCommandPackage(""); + } + + @Test(expected=java.security.InvalidParameterException.class) + public void testAddCommandPackage_2() + throws Exception { + CommandExecuter fixture = CommandExecuter.getInstance(); + + fixture.addCommandPackage(null); + } + + @Test + public void testExec_1() + throws Exception { + CommandExecuter fixture = CommandExecuter.getInstance(); + MockOutputListener mockListener = new MockOutputListener(); + Console.getInstance().registerOutputListener(mockListener); + fixture.addCommandPackage("de.ugoe.cs.util.console.mock.commands"); + String command = "mockCommand"; + String expected = "mock command: run" + System.getProperty("line.separator"); + + fixture.exec(command); + + assertEquals(expected, mockListener.getLastOutput()); + } + + @Test + public void testExec_2() + throws Exception { + CommandExecuter fixture = CommandExecuter.getInstance(); + MockOutputListener mockListener = new MockOutputListener(); + Console.getInstance().registerOutputListener(mockListener); + fixture.addCommandPackage("de.ugoe.cs.util.console.mock.commands"); + String command = "mockCommand param1"; + String expected = "mock command: help" + System.getProperty("line.separator"); + + fixture.exec(command); + + assertEquals(expected, mockListener.getLastOutput()); + } + + @Test(expected = java.lang.RuntimeException.class) + public void testExec_3() + throws Exception { + CommandExecuter fixture = CommandExecuter.getInstance(); + MockOutputListener mockListener = new MockOutputListener(); + Console.getInstance().registerOutputListener(mockListener); + fixture.addCommandPackage("de.ugoe.cs.util.console.mock.commands"); + String command = "mockCommand param1 param2"; + + fixture.exec(command); + } + + @Test + public void testExec_4() + throws Exception { + CommandExecuter fixture = CommandExecuter.getInstance(); + MockOutputListener mockListener = new MockOutputListener(); + Console.getInstance().registerOutputListener(mockListener); + fixture.addCommandPackage("de.ugoe.cs.util.console.mock.commands"); + String command = "mockCommandddd"; + String expected = "Unknown command" + System.getProperty("line.separator"); + + fixture.exec(command); + + assertEquals(expected, mockListener.getLastOutput()); + } + + @Test + public void testGetInstance_1() + throws Exception { + CommandExecuter result = CommandExecuter.getInstance(); + + assertNotNull(result); + } + + public static void main(String[] args) { + new org.junit.runner.JUnitCore().run(CommandExecuterTest.class); + } +} Index: /trunk/java-utils-test/src/de/ugoe/cs/util/console/CommandParserTest.java =================================================================== --- /trunk/java-utils-test/src/de/ugoe/cs/util/console/CommandParserTest.java (revision 436) +++ /trunk/java-utils-test/src/de/ugoe/cs/util/console/CommandParserTest.java (revision 436) @@ -0,0 +1,255 @@ +package de.ugoe.cs.util.console; + +import java.util.ArrayList; +import java.util.List; +import org.junit.*; +import static org.junit.Assert.*; + +/** + * The class CommandParserTest contains tests for the class + * {@link CommandParser}. + * + * @author Steffen Herbold + * @version 1.0 + */ +public class CommandParserTest { + + @Test + public void testCommandParser_1() throws Exception { + + CommandParser result = new CommandParser(); + + // add additional test code here + assertNotNull(result); + assertEquals("", result.getCommandName()); + assertTrue(result.getParameters().isEmpty()); + } + + @Test + public void testGetParameters_1() throws Exception { + CommandParser fixture = new CommandParser(); + + List result = fixture.getParameters(); + + // add additional test code here + assertNotNull(result); + assertEquals(0, result.size()); + } + + @Test + public void testParse_1() throws Exception { + CommandParser commandParser = new CommandParser(); + String command = "test"; + commandParser.parse(command); + + assertEquals("test", commandParser.getCommandName()); + assertTrue(commandParser.getParameters().isEmpty()); + } + + @Test + public void testParse_2() throws Exception { + CommandParser commandParser = new CommandParser(); + String command = "test param1"; + List expectedParameters = new ArrayList(); + expectedParameters.add("param1"); + + commandParser.parse(command); + + assertEquals("test", commandParser.getCommandName()); + assertArrayEquals(expectedParameters.toArray(), commandParser + .getParameters().toArray()); + } + + @Test + public void testParse_3() throws Exception { + CommandParser commandParser = new CommandParser(); + String command = "test param1 param2"; + List expectedParameters = new ArrayList(); + expectedParameters.add("param1"); + expectedParameters.add("param2"); + + commandParser.parse(command); + + assertEquals("test", commandParser.getCommandName()); + assertArrayEquals(expectedParameters.toArray(), commandParser + .getParameters().toArray()); + } + + @Test + public void testParse_4() throws Exception { + CommandParser commandParser = new CommandParser(); + String command = "test [array1]"; + List expectedParameters = new ArrayList(); + expectedParameters.add(new String[] { "array1" }); + + commandParser.parse(command); + + assertEquals("test", commandParser.getCommandName()); + assertArrayEquals(expectedParameters.toArray(), commandParser + .getParameters().toArray()); + } + + @Test + public void testParse_5() throws Exception { + CommandParser commandParser = new CommandParser(); + String command = "test [array1 array2]"; + List expectedParameters = new ArrayList(); + expectedParameters.add(new String[] { "array1", "array2" }); + + commandParser.parse(command); + + assertEquals("test", commandParser.getCommandName()); + assertArrayEquals(expectedParameters.toArray(), commandParser + .getParameters().toArray()); + } + + @Test + public void testParse_6() throws Exception { + CommandParser commandParser = new CommandParser(); + String command = "test [array1] param1"; + List expectedParameters = new ArrayList(); + expectedParameters.add(new String[] { "array1" }); + expectedParameters.add("param1"); + + commandParser.parse(command); + + assertEquals("test", commandParser.getCommandName()); + assertArrayEquals(expectedParameters.toArray(), commandParser + .getParameters().toArray()); + } + + @Test + public void testParse_7() throws Exception { + CommandParser commandParser = new CommandParser(); + String command = "test 'param 1'"; + List expectedParameters = new ArrayList(); + expectedParameters.add("param 1"); + + commandParser.parse(command); + + assertEquals("test", commandParser.getCommandName()); + assertArrayEquals(expectedParameters.toArray(), commandParser + .getParameters().toArray()); + } + + @Test + public void testParse_8() throws Exception { + CommandParser commandParser = new CommandParser(); + String command = "test ['array 1']"; + List expectedParameters = new ArrayList(); + expectedParameters.add(new String[] { "array 1" }); + + commandParser.parse(command); + + assertEquals("test", commandParser.getCommandName()); + assertArrayEquals(expectedParameters.toArray(), commandParser + .getParameters().toArray()); + } + + @Test + public void testParse_9() throws Exception { + CommandParser commandParser = new CommandParser(); + String command = "test ['array 1' array2]"; + List expectedParameters = new ArrayList(); + expectedParameters.add(new String[] { "array 1", "array2" }); + + commandParser.parse(command); + + assertEquals("test", commandParser.getCommandName()); + assertArrayEquals(expectedParameters.toArray(), commandParser + .getParameters().toArray()); + } + + @Test + public void testParse_10() throws Exception { + CommandParser commandParser = new CommandParser(); + String command = "test [array1 array2]"; + List expectedParameters = new ArrayList(); + expectedParameters.add(new String[] { "array1", "array2" }); + + commandParser.parse(command); + + assertEquals("test", commandParser.getCommandName()); + assertArrayEquals(expectedParameters.toArray(), commandParser + .getParameters().toArray()); + } + + @Test + public void testParse_11() throws Exception { + CommandParser commandParser = new CommandParser(); + String command = "test 'param 1"; + List expectedParameters = new ArrayList(); + expectedParameters.add("param 1"); + + commandParser.parse(command); + + assertEquals("test", commandParser.getCommandName()); + assertArrayEquals(expectedParameters.toArray(), commandParser + .getParameters().toArray()); + } + + @Test + public void testParse_12() throws Exception { + CommandParser commandParser = new CommandParser(); + String command = "test 'param1 [array1]"; + List expectedParameters = new ArrayList(); + expectedParameters.add("param1 [array1]"); + + commandParser.parse(command); + + assertEquals("test", commandParser.getCommandName()); + assertArrayEquals(expectedParameters.toArray(), commandParser + .getParameters().toArray()); + } + + @Test + public void testParse_13() throws Exception { + CommandParser commandParser = new CommandParser(); + String command = "test param1' [array1]"; + List expectedParameters = new ArrayList(); + expectedParameters.add("param1'"); + expectedParameters.add(new String[] { "array1" }); + + commandParser.parse(command); + + assertEquals("test", commandParser.getCommandName()); + assertArrayEquals(expectedParameters.toArray(), commandParser + .getParameters().toArray()); + } + + @Test + public void testParse_14() throws Exception { + CommandParser commandParser = new CommandParser(); + String command = ""; + commandParser.parse(command); + assertEquals("", commandParser.getCommandName()); + assertTrue(commandParser.getParameters().isEmpty()); + } + + @Test + public void testParse_15() throws Exception { + CommandParser commandParser = new CommandParser(); + String command = null; + commandParser.parse(command); + assertEquals("", commandParser.getCommandName()); + assertTrue(commandParser.getParameters().isEmpty()); + } + + @Test + public void testParse_16() throws Exception { + CommandParser commandParser = new CommandParser(); + String command = "test param1 param2"; + List expectedParameters = new ArrayList(); + expectedParameters.add("param1"); + expectedParameters.add("param2"); + + commandParser.parse(command); + assertEquals("test", commandParser.getCommandName()); + assertArrayEquals(expectedParameters.toArray(), commandParser + .getParameters().toArray()); + } + + public static void main(String[] args) { + new org.junit.runner.JUnitCore().run(CommandParserTest.class); + } +} Index: /trunk/java-utils-test/src/de/ugoe/cs/util/console/ConsoleTest.java =================================================================== --- /trunk/java-utils-test/src/de/ugoe/cs/util/console/ConsoleTest.java (revision 436) +++ /trunk/java-utils-test/src/de/ugoe/cs/util/console/ConsoleTest.java (revision 436) @@ -0,0 +1,364 @@ +package de.ugoe.cs.util.console; + +import org.junit.*; +import de.ugoe.cs.util.console.mock.MockCommandListener; +import de.ugoe.cs.util.console.mock.MockErrorListener; +import de.ugoe.cs.util.console.mock.MockExceptionListener; +import de.ugoe.cs.util.console.mock.MockObserver; +import de.ugoe.cs.util.console.mock.MockOutputListener; +import de.ugoe.cs.util.console.mock.MockTraceListener; +import static org.junit.Assert.*; + +/** + * The class ConsoleTest contains tests for the class {@link Console}. + * + * @author Steffen Herbold + * @version 1.0 + */ +public class ConsoleTest { + + private static final String ENDLINE = System.getProperty("line.separator"); + + @Test + public void testCommandNotification_1() + throws Exception { + String command = "test"; + + MockCommandListener commandListener1 = new MockCommandListener(); + MockCommandListener commandListener2 = new MockCommandListener(); + + Console.getInstance().registerCommandListener(commandListener1); + Console.getInstance().registerCommandListener(commandListener2); + Console.commandNotification(command); + + assertEquals(command, commandListener1.getLastCommand()); + assertEquals(command, commandListener2.getLastCommand()); + } + + @SuppressWarnings("deprecation") + @Test + public void testDeleteObserver_1() + throws Exception { + Console fixture = Console.getInstance(); + + MockObserver mockObserver1 = new MockObserver(); + MockObserver mockObserver2 = new MockObserver(); + fixture.registerObserver(mockObserver1); + fixture.registerObserver(mockObserver2); + + fixture.deleteObserver(mockObserver1); + + assertFalse(fixture.hasCommandListener(mockObserver1)); + assertFalse(fixture.hasErrorListener(mockObserver1)); + assertFalse(fixture.hasExceptionListener(mockObserver1)); + assertFalse(fixture.hasOutputListener(mockObserver1)); + assertFalse(fixture.hasTraceListener(mockObserver1)); + + assertTrue(fixture.hasCommandListener(mockObserver2)); + assertTrue(fixture.hasErrorListener(mockObserver2)); + assertTrue(fixture.hasExceptionListener(mockObserver2)); + assertTrue(fixture.hasOutputListener(mockObserver2)); + assertTrue(fixture.hasTraceListener(mockObserver2)); + + // add additional test code here + } + + @Test + public void testGetInstance() + throws Exception { + + Console result = Console.getInstance(); + assertNotNull(result); + } + + @Test + public void testLogException() + throws Exception { + Exception e = new Exception(); + MockExceptionListener mockExceptionListener1 = new MockExceptionListener(); + MockExceptionListener mockExceptionListener2 = new MockExceptionListener(); + + Console.getInstance().registerExceptionListener(mockExceptionListener1); + Console.getInstance().registerExceptionListener(mockExceptionListener2); + + Console.logException(e); + + assertEquals(e, mockExceptionListener1.getLastException()); + assertEquals(e, mockExceptionListener2.getLastException()); + } + + @Test + public void testPrint_1() + throws Exception { + String msg = "test"; + + MockOutputListener mockOutputListener1 = new MockOutputListener(); + MockOutputListener mockOutputListener2 = new MockOutputListener(); + + Console.getInstance().registerOutputListener(mockOutputListener1); + Console.getInstance().registerOutputListener(mockOutputListener2); + + Console.print(msg); + + assertEquals(msg, mockOutputListener1.getLastOutput()); + assertEquals(msg, mockOutputListener2.getLastOutput()); + } + + @Test + public void testPrinterr_1() + throws Exception { + String errMsg = "test"; + + MockErrorListener mockErrorListener1 = new MockErrorListener(); + MockErrorListener mockErrorListener2 = new MockErrorListener(); + + Console.getInstance().registerErrorListener(mockErrorListener1); + Console.getInstance().registerErrorListener(mockErrorListener2); + + Console.printerr(errMsg); + + assertEquals(errMsg, mockErrorListener1.getLastError()); + assertEquals(errMsg, mockErrorListener2.getLastError()); + } + + @Test + public void testPrinterrln_1() + throws Exception { + String errMsg = "test"; + + MockErrorListener mockErrorListener1 = new MockErrorListener(); + MockErrorListener mockErrorListener2 = new MockErrorListener(); + + Console.getInstance().registerErrorListener(mockErrorListener1); + Console.getInstance().registerErrorListener(mockErrorListener2); + + Console.printerrln(errMsg); + + assertEquals(errMsg+ENDLINE, mockErrorListener1.getLastError()); + assertEquals(errMsg+ENDLINE, mockErrorListener2.getLastError()); + } + + + @Test + public void testPrintln_1() + throws Exception { + String msg = "test"; + + MockOutputListener mockOutputListener1 = new MockOutputListener(); + MockOutputListener mockOutputListener2 = new MockOutputListener(); + + Console.getInstance().registerOutputListener(mockOutputListener1); + Console.getInstance().registerOutputListener(mockOutputListener2); + + Console.println(msg); + + assertEquals(msg+ENDLINE, mockOutputListener1.getLastOutput()); + assertEquals(msg+ENDLINE, mockOutputListener2.getLastOutput()); + } + + + @Test + public void testRegisterCommandListener_1() + throws Exception { + Console fixture = Console.getInstance(); + MockCommandListener mockCommandListener = new MockCommandListener(); + + fixture.registerCommandListener(mockCommandListener); + + assertTrue(fixture.hasCommandListener(mockCommandListener)); + } + + @Test + public void testRegisterErrorListener_1() + throws Exception { + Console fixture = Console.getInstance(); + + MockErrorListener mockErrorListener = new MockErrorListener(); + + fixture.registerErrorListener(mockErrorListener); + + assertTrue(fixture.hasErrorListener(mockErrorListener)); + } + + @Test + public void testRegisterExceptionListener_1() + throws Exception { + Console fixture = Console.getInstance(); + + MockExceptionListener mockExceptionListener = new MockExceptionListener(); + + fixture.registerExceptionListener(mockExceptionListener); + + assertTrue(fixture.hasExceptionListener(mockExceptionListener)); + } + + @SuppressWarnings("deprecation") + @Test + public void testRegisterObserver_1() + throws Exception { + Console fixture = Console.getInstance(); + + MockObserver mockObserver = new MockObserver(); + + fixture.registerObserver(mockObserver); + + assertTrue(fixture.hasCommandListener(mockObserver)); + assertTrue(fixture.hasErrorListener(mockObserver)); + assertTrue(fixture.hasExceptionListener(mockObserver)); + assertTrue(fixture.hasOutputListener(mockObserver)); + assertTrue(fixture.hasTraceListener(mockObserver)); + } + + @Test + public void testRegisterOutputListener_1() + throws Exception { + Console fixture = Console.getInstance(); + + MockOutputListener mockOutputListener = new MockOutputListener(); + + fixture.registerOutputListener(mockOutputListener); + + assertTrue(fixture.hasOutputListener(mockOutputListener)); + } + + @Test + public void testRegisterTraceListener_1() + throws Exception { + Console fixture = Console.getInstance(); + + MockTraceListener mockTraceListener = new MockTraceListener(); + + fixture.registerTraceListener(mockTraceListener); + + assertTrue(fixture.hasTraceListener(mockTraceListener)); + } + + @Test + public void testRemoveCommandListener_1() + throws Exception { + Console fixture = Console.getInstance(); + + MockCommandListener mockCommandListener1 = new MockCommandListener(); + MockCommandListener mockCommandListener2 = new MockCommandListener(); + fixture.registerCommandListener(mockCommandListener1); + fixture.registerCommandListener(mockCommandListener2); + + fixture.removeCommandListener(mockCommandListener1); + + assertFalse(fixture.hasCommandListener(mockCommandListener1)); + assertTrue(fixture.hasCommandListener(mockCommandListener2)); + } + + @Test + public void testRemoveErrorListener_1() + throws Exception { + Console fixture = Console.getInstance(); + + MockErrorListener mockErrorListener1 = new MockErrorListener(); + MockErrorListener mockErrorListener2 = new MockErrorListener(); + fixture.registerErrorListener(mockErrorListener1); + fixture.registerErrorListener(mockErrorListener2); + + fixture.removeErrorListener(mockErrorListener1); + + assertFalse(fixture.hasErrorListener(mockErrorListener1)); + assertTrue(fixture.hasErrorListener(mockErrorListener2)); + } + + @Test + public void testRemoveExceptionListener_1() + throws Exception { + Console fixture = Console.getInstance(); + + MockExceptionListener mockExceptionListener1 = new MockExceptionListener(); + MockExceptionListener mockExceptionListener2 = new MockExceptionListener(); + + fixture.registerExceptionListener(mockExceptionListener1); + fixture.registerExceptionListener(mockExceptionListener2); + + fixture.removeExceptionListener(mockExceptionListener1); + + assertFalse(fixture.hasExceptionListener(mockExceptionListener1)); + assertTrue(fixture.hasExceptionListener(mockExceptionListener2)); + } + + @Test + public void testRemoveOutputListener_1() + throws Exception { + Console fixture = Console.getInstance(); + + MockOutputListener mockOutputListener1 = new MockOutputListener(); + MockOutputListener mockOutputListener2 = new MockOutputListener(); + + fixture.registerOutputListener(mockOutputListener1); + fixture.registerOutputListener(mockOutputListener2); + + fixture.removeOutputListener(mockOutputListener1); + + assertFalse(fixture.hasOutputListener(mockOutputListener1)); + assertTrue(fixture.hasOutputListener(mockOutputListener2)); + } + + @Test + public void testRemoveTraceListener_1() + throws Exception { + Console fixture = Console.getInstance(); + + MockTraceListener mockTraceListener1 = new MockTraceListener(); + MockTraceListener mockTraceListener2 = new MockTraceListener(); + + fixture.registerTraceListener(mockTraceListener1); + fixture.registerTraceListener(mockTraceListener2); + + fixture.removeTraceListener(mockTraceListener1); + + assertFalse(fixture.hasTraceListener(mockTraceListener1)); + assertTrue(fixture.hasTraceListener(mockTraceListener2)); + } + + @Test + public void testTrace_1() + throws Exception { + String traceMsg = "test"; + + MockTraceListener mockTraceListener1 = new MockTraceListener(); + MockTraceListener mockTraceListener2 = new MockTraceListener(); + + Console.getInstance().registerTraceListener(mockTraceListener1); + Console.getInstance().registerTraceListener(mockTraceListener2); + + Console.trace(traceMsg); + + assertEquals(traceMsg, mockTraceListener1.getLastTrace()); + assertEquals(traceMsg, mockTraceListener2.getLastTrace()); + } + + @Test + public void testTraceln_1() + throws Exception { + String traceMsg = "test"; + + MockTraceListener mockTraceListener1 = new MockTraceListener(); + MockTraceListener mockTraceListener2 = new MockTraceListener(); + + Console.getInstance().registerTraceListener(mockTraceListener1); + Console.getInstance().registerTraceListener(mockTraceListener2); + + Console.traceln(traceMsg); + + assertEquals(traceMsg+ENDLINE, mockTraceListener1.getLastTrace()); + assertEquals(traceMsg+ENDLINE, mockTraceListener2.getLastTrace()); + + // add additional test code here + } + + @Before + public void setUp() + throws Exception { + Console.reset(); + } + + public static void main(String[] args) { + new org.junit.runner.JUnitCore().run(ConsoleTest.class); + } +} Index: /trunk/java-utils-test/src/de/ugoe/cs/util/console/FileOutputListenerTest.java =================================================================== --- /trunk/java-utils-test/src/de/ugoe/cs/util/console/FileOutputListenerTest.java (revision 436) +++ /trunk/java-utils-test/src/de/ugoe/cs/util/console/FileOutputListenerTest.java (revision 436) @@ -0,0 +1,98 @@ +package de.ugoe.cs.util.console; + +import java.io.File; + +import junitx.framework.FileAssert; + +import org.junit.*; +import static org.junit.Assert.*; + +/** + * The class FileOutputListenerTest contains tests for the class {@link FileOutputListener}. + * + * @author Steffen Herbold + * @version 1.0 + */ +public class FileOutputListenerTest { + + String expectedOutputFilename = "testdata/de.ugoe.cs.util.FileOutputListenerTest/expected.log"; + String testOutputPath = "testoutput/"; + String testFilename = testOutputPath + "listener.log"; + + FileOutputListener listener; + + @Test + public void testFileOutputListener_1() + throws Exception { + String filename = "filename"; + + FileOutputListener result = new FileOutputListener(filename); + + assertNotNull(result); + assertEquals(filename, result.getFilename()); + } + + @Test + public void testOutputMsg_1() + throws Exception { + String message = "test"; + + listener.start(); + listener.outputMsg(message); + listener.stop(); + + FileAssert.assertEquals(new File(expectedOutputFilename), new File(testFilename)); + } + + @Test + public void testStart_1() + throws Exception { + FileOutputListener fixture = new FileOutputListener(testFilename); + + fixture.start(); + + File file = new File(testFilename); + assertTrue(file.exists()); + } + + @Test + public void testStart_2() + throws Exception { + FileOutputListener fixture = new FileOutputListener(""); + + fixture.start(); + + assertNull(fixture.writer); + } + + @Test + public void testStop_1() + throws Exception { + listener.stop(); + assertNull(listener.writer); + } + + @Before + public void setUp() + throws Exception { + // add additional set up code here + Console.reset(); + listener = new FileOutputListener(testFilename); + File file = new File(testFilename); + if( file.exists() ) { + file.delete(); + } + } + + @After + public void tearDown() + throws Exception { + if( listener.writer!=null ) { + listener.writer.close(); + } + } + + public static void main(String[] args) { + new org.junit.runner.JUnitCore().run(FileOutputListenerTest.class); + } +} Index: /trunk/java-utils-test/src/de/ugoe/cs/util/console/TestAll.java =================================================================== --- /trunk/java-utils-test/src/de/ugoe/cs/util/console/TestAll.java (revision 436) +++ /trunk/java-utils-test/src/de/ugoe/cs/util/console/TestAll.java (revision 436) @@ -0,0 +1,29 @@ +package de.ugoe.cs.util.console; + +import org.junit.runner.JUnitCore; +import org.junit.runner.RunWith; +import org.junit.runners.Suite; + +/** + * The class TestAll builds a suite that can be used to run all + * of the tests within its package as well as within any subpackages of its + * package. + * + * @author Steffen Herbold + * @version 1.0 + */ +@RunWith(Suite.class) +@Suite.SuiteClasses({ + CommandParserTest.class, + FileOutputListenerTest.class, + TextConsoleTest.class, + ConsoleTest.class, + CommandExecuterTest.class, + de.ugoe.cs.util.console.defaultcommands.TestAll.class +}) +public class TestAll { + + public static void main(String[] args) { + JUnitCore.runClasses(new Class[] { TestAll.class }); + } +} Index: /trunk/java-utils-test/src/de/ugoe/cs/util/console/TextConsoleTest.java =================================================================== --- /trunk/java-utils-test/src/de/ugoe/cs/util/console/TextConsoleTest.java (revision 436) +++ /trunk/java-utils-test/src/de/ugoe/cs/util/console/TextConsoleTest.java (revision 436) @@ -0,0 +1,103 @@ +package de.ugoe.cs.util.console; + +import java.io.ByteArrayOutputStream; +import java.io.PrintStream; + +import org.junit.*; +import static org.junit.Assert.*; + +/** + * The class TextConsoleTest contains tests for the class + * {@link TextConsole}. + * + * @author Steffen Herbold + * @version 1.0 + */ +public class TextConsoleTest { + + private final static String ENDLINE = System.getProperty("line.separator"); + + private final ByteArrayOutputStream outContent = new ByteArrayOutputStream(); + private final ByteArrayOutputStream errContent = new ByteArrayOutputStream(); + + @Test + public void testTextConsole_1() throws Exception { + + Console.reset(); + TextConsole result = new TextConsole(); + + assertNotNull(result); + assertTrue(Console.getInstance().hasErrorListener(result)); + assertTrue(Console.getInstance().hasExceptionListener(result)); + assertTrue(Console.getInstance().hasOutputListener(result)); + assertTrue(Console.getInstance().hasTraceListener(result)); + } + + @Test + public void testErrorMsg_1() throws Exception { + TextConsole fixture = new TextConsole(); + String errMessage = "test"; + + fixture.errorMsg(errMessage); + + assertEquals(errMessage, errContent.toString()); + } + + @Test + public void testLogException_1() throws Exception { + TextConsole fixture = new TextConsole(); + Exception e = new Exception("test"); + ; + + fixture.logException(e); + assertEquals(e.getMessage() + ENDLINE, errContent.toString()); + } + + @Test + public void testOutputMsg_1() throws Exception { + TextConsole fixture = new TextConsole(); + String newMessage = "test"; + + fixture.outputMsg(newMessage); + + assertEquals(newMessage, outContent.toString()); + } + + @Test + public void testTraceMsg_1() throws Exception { + TextConsole fixture = new TextConsole(); + fixture.setDebug(true); + String traceMessage = "test"; + + fixture.traceMsg(traceMessage); + + assertEquals(traceMessage, outContent.toString()); + } + + @Test + public void testTraceMsg_2() throws Exception { + TextConsole fixture = new TextConsole(); + fixture.setDebug(false); + String traceMessage = "test"; + + fixture.traceMsg(traceMessage); + + assertEquals("", outContent.toString()); + } + + @Before + public void setUp() throws Exception { + System.setOut(new PrintStream(outContent)); + System.setErr(new PrintStream(errContent)); + } + + @After + public void tearDown() throws Exception { + System.setOut(null); + System.setErr(null); + } + + public static void main(String[] args) { + new org.junit.runner.JUnitCore().run(TextConsoleTest.class); + } +} Index: /trunk/java-utils-test/src/de/ugoe/cs/util/console/defaultcommands/CMDexecTest.java =================================================================== --- /trunk/java-utils-test/src/de/ugoe/cs/util/console/defaultcommands/CMDexecTest.java (revision 436) +++ /trunk/java-utils-test/src/de/ugoe/cs/util/console/defaultcommands/CMDexecTest.java (revision 436) @@ -0,0 +1,115 @@ +package de.ugoe.cs.util.console.defaultcommands; + +import java.util.ArrayList; +import java.util.List; +import org.junit.*; + +import de.ugoe.cs.util.console.Console; +import de.ugoe.cs.util.console.mock.MockCommandListener; +import de.ugoe.cs.util.console.mock.MockOutputListener; +import de.ugoe.cs.util.console.mock.MockTraceListener; +import static org.junit.Assert.*; + +/** + * The class CMDexecTest contains tests for the class + * {@link CMDexec}. + * + * @author Steffen Herbold + * @version 1.0 + */ +public class CMDexecTest { + + final static String ENDLINE = System.getProperty("line.separator"); + + @Test + public void testHelp_1() throws Exception { + CMDexec fixture = new CMDexec(); + MockOutputListener mockListener = new MockOutputListener(); + Console.getInstance().registerOutputListener(mockListener); + String expected = "Usage: exec " + ENDLINE; + + fixture.help(); + + assertEquals(expected, mockListener.getLastOutput()); + } + + @Test + public void testRun_1() throws Exception { + CMDexec fixture = new CMDexec(); + MockCommandListener mockCommandListener = new MockCommandListener(); + MockTraceListener mockTraceListener = new MockTraceListener(); + Console.getInstance().registerCommandListener(mockCommandListener); + Console.getInstance().registerTraceListener(mockTraceListener); + List parameters = new ArrayList(); + parameters + .add("testdata/de.ugoe.cs.util.console.defaultcommands.CMDexecTest/script1"); + String expected = "mockCommand"; + + fixture.run(parameters); + + assertEquals(expected, mockCommandListener.getLastCommand()); + assertEquals(expected + ENDLINE, mockTraceListener.getLastTrace()); + } + + @Test + public void testRun_2() throws Exception { + CMDexec fixture = new CMDexec(); + MockCommandListener mockCommandListener = new MockCommandListener(); + MockTraceListener mockTraceListener = new MockTraceListener(); + Console.getInstance().registerCommandListener(mockCommandListener); + Console.getInstance().registerTraceListener(mockTraceListener); + List parameters = new ArrayList(); + parameters + .add("testdata/de.ugoe.cs.util.console.defaultcommands.CMDexecTest/script2"); + String expected = "mockCommand param1"; + + fixture.run(parameters); + + assertEquals(expected, mockCommandListener.getLastCommand()); + assertEquals(expected + ENDLINE, mockTraceListener.getLastTrace()); + } + + @Test(expected = java.security.InvalidParameterException.class) + public void testRun_3() throws Exception { + CMDexec fixture = new CMDexec(); + MockCommandListener mockCommandListener = new MockCommandListener(); + MockTraceListener mockTraceListener = new MockTraceListener(); + Console.getInstance().registerCommandListener(mockCommandListener); + Console.getInstance().registerTraceListener(mockTraceListener); + List parameters = new ArrayList(); + + fixture.run(parameters); + } + + @Test + public void testRun_4() throws Exception { + CMDexec fixture = new CMDexec(); + MockCommandListener mockCommandListener = new MockCommandListener(); + MockTraceListener mockTraceListener = new MockTraceListener(); + Console.getInstance().registerCommandListener(mockCommandListener); + Console.getInstance().registerTraceListener(mockTraceListener); + List parameters = new ArrayList(); + parameters + .add("testdata/de.ugoe.cs.util.console.defaultcommands.CMDexecTest/script2"); + parameters.add(Integer.parseInt("1")); + String expected = "mockCommand param1"; + + fixture.run(parameters); + + assertEquals(expected, mockCommandListener.getLastCommand()); + assertEquals(expected + ENDLINE, mockTraceListener.getLastTrace()); + } + + @Test(expected = java.security.InvalidParameterException.class) + public void testRun_5() throws Exception { + CMDexec fixture = new CMDexec(); + List parameters = new ArrayList(); + parameters.add(Integer.parseInt("1")); + + fixture.run(parameters); + } + + public static void main(String[] args) { + new org.junit.runner.JUnitCore().run(CMDexecTest.class); + } +} Index: /trunk/java-utils-test/src/de/ugoe/cs/util/console/defaultcommands/CMDexitTest.java =================================================================== --- /trunk/java-utils-test/src/de/ugoe/cs/util/console/defaultcommands/CMDexitTest.java (revision 436) +++ /trunk/java-utils-test/src/de/ugoe/cs/util/console/defaultcommands/CMDexitTest.java (revision 436) @@ -0,0 +1,87 @@ +package de.ugoe.cs.util.console.defaultcommands; + +import java.security.Permission; +import java.util.ArrayList; +import java.util.List; +import org.junit.*; + +import de.ugoe.cs.util.console.Console; +import de.ugoe.cs.util.console.mock.MockOutputListener; +import static org.junit.Assert.*; + +/** + * The class CMDexitTest contains tests for the class + * {@link CMDexit}. + * + * @author Steffen Herbold + * @version 1.0 + */ +public class CMDexitTest { + + final static String ENDLINE = System.getProperty("line.separator"); + + private static class ExitException extends SecurityException { + private static final long serialVersionUID = 1L; + } + + private static class NoExitSecurityManager extends SecurityManager { + @Override + public void checkPermission(Permission perm) { + // allow anything. + } + + @Override + public void checkPermission(Permission perm, Object context) { + // allow anything. + } + + @Override + public void checkExit(int status) { + super.checkExit(status); + throw new ExitException(); + } + } + + @Test + public void testHelp_1() throws Exception { + CMDexit fixture = new CMDexit(); + MockOutputListener mockListener = new MockOutputListener(); + Console.getInstance().registerOutputListener(mockListener); + String expected = "Usage: exit" + ENDLINE; + + fixture.help(); + + assertEquals(expected, mockListener.getLastOutput()); + } + + @Test(expected = ExitException.class) + public void testRun_1() throws Exception { + CMDexit fixture = new CMDexit(); + List parameters = new ArrayList(); + + fixture.run(parameters); + } + + @Test(expected = ExitException.class) + public void testRun_2() throws Exception { + CMDexit fixture = new CMDexit(); + List parameters = new ArrayList(); + parameters.add("test"); + + fixture.run(parameters); + } + + @Before + public void setUp() throws Exception { + System.setSecurityManager(new NoExitSecurityManager()); + } + + @After + public void tearDown() throws Exception { + System.setSecurityManager(null); + } + + public static void main(String[] args) { + new org.junit.runner.JUnitCore().run(CMDexitTest.class); + } +} Index: /trunk/java-utils-test/src/de/ugoe/cs/util/console/defaultcommands/TestAll.java =================================================================== --- /trunk/java-utils-test/src/de/ugoe/cs/util/console/defaultcommands/TestAll.java (revision 436) +++ /trunk/java-utils-test/src/de/ugoe/cs/util/console/defaultcommands/TestAll.java (revision 436) @@ -0,0 +1,25 @@ +package de.ugoe.cs.util.console.defaultcommands; + +import org.junit.runner.JUnitCore; +import org.junit.runner.RunWith; +import org.junit.runners.Suite; + +/** + * The class TestAll builds a suite that can be used to run all of + * the tests within its package as well as within any subpackages of its + * package. + * + * @author Steffen Herbold + * @version 1.0 + */ +@RunWith(Suite.class) +@Suite.SuiteClasses({ + CMDexecTest.class, + CMDexitTest.class +}) +public class TestAll { + + public static void main(String[] args) { + JUnitCore.runClasses(new Class[] { TestAll.class }); + } +} Index: /trunk/java-utils-test/src/de/ugoe/cs/util/console/mock/MockCommandListener.java =================================================================== --- /trunk/java-utils-test/src/de/ugoe/cs/util/console/mock/MockCommandListener.java (revision 436) +++ /trunk/java-utils-test/src/de/ugoe/cs/util/console/mock/MockCommandListener.java (revision 436) @@ -0,0 +1,16 @@ +package de.ugoe.cs.util.console.mock; + +import de.ugoe.cs.util.console.listener.ICommandListener; + +public class MockCommandListener implements ICommandListener { + private String lastCommand = null; + + public String getLastCommand() { + return lastCommand; + } + + @Override + public void commandNotification(String command) { + lastCommand = command; + } +} Index: /trunk/java-utils-test/src/de/ugoe/cs/util/console/mock/MockErrorListener.java =================================================================== --- /trunk/java-utils-test/src/de/ugoe/cs/util/console/mock/MockErrorListener.java (revision 436) +++ /trunk/java-utils-test/src/de/ugoe/cs/util/console/mock/MockErrorListener.java (revision 436) @@ -0,0 +1,14 @@ +package de.ugoe.cs.util.console.mock; + +import de.ugoe.cs.util.console.listener.IErrorListener; + +public class MockErrorListener implements IErrorListener { + private String lastError = null; + public String getLastError() { + return lastError; + } + @Override + public void errorMsg(String errMessage) { + lastError = errMessage; + } +} Index: /trunk/java-utils-test/src/de/ugoe/cs/util/console/mock/MockExceptionListener.java =================================================================== --- /trunk/java-utils-test/src/de/ugoe/cs/util/console/mock/MockExceptionListener.java (revision 436) +++ /trunk/java-utils-test/src/de/ugoe/cs/util/console/mock/MockExceptionListener.java (revision 436) @@ -0,0 +1,16 @@ +package de.ugoe.cs.util.console.mock; + +import de.ugoe.cs.util.console.listener.IExceptionListener; + +public class MockExceptionListener implements IExceptionListener { + + private Exception lastException = null; + public Exception getLastException() { + return lastException; + } + + @Override + public void logException(Exception e) { + lastException = e; + } +} Index: /trunk/java-utils-test/src/de/ugoe/cs/util/console/mock/MockObserver.java =================================================================== --- /trunk/java-utils-test/src/de/ugoe/cs/util/console/mock/MockObserver.java (revision 436) +++ /trunk/java-utils-test/src/de/ugoe/cs/util/console/mock/MockObserver.java (revision 436) @@ -0,0 +1,23 @@ +package de.ugoe.cs.util.console.mock; + +import de.ugoe.cs.util.console.ConsoleObserver; + +@SuppressWarnings("deprecation") +public class MockObserver implements ConsoleObserver { + + @Override + public void commandNotification(String command) { + } + @Override + public void errorMsg(String errMessage) { + } + @Override + public void logException(Exception e) { + } + @Override + public void outputMsg(String newMessage) { + } + @Override + public void traceMsg(String traceMessage) { + } +} Index: /trunk/java-utils-test/src/de/ugoe/cs/util/console/mock/MockOutputListener.java =================================================================== --- /trunk/java-utils-test/src/de/ugoe/cs/util/console/mock/MockOutputListener.java (revision 436) +++ /trunk/java-utils-test/src/de/ugoe/cs/util/console/mock/MockOutputListener.java (revision 436) @@ -0,0 +1,22 @@ +package de.ugoe.cs.util.console.mock; + +import de.ugoe.cs.util.console.listener.IOutputListener; + +public class MockOutputListener implements IOutputListener { + private String secondLastOutput = null; + private String lastOutput = null; + public String getLastOutput() { + return lastOutput; + } + public String getSecondLastOutput() { + return secondLastOutput; + } + @Override + public void outputMsg(String newMessage) { + if( lastOutput!=null ) { + secondLastOutput=lastOutput; + } + lastOutput = newMessage; + + } +} Index: /trunk/java-utils-test/src/de/ugoe/cs/util/console/mock/MockTraceListener.java =================================================================== --- /trunk/java-utils-test/src/de/ugoe/cs/util/console/mock/MockTraceListener.java (revision 436) +++ /trunk/java-utils-test/src/de/ugoe/cs/util/console/mock/MockTraceListener.java (revision 436) @@ -0,0 +1,14 @@ +package de.ugoe.cs.util.console.mock; + +import de.ugoe.cs.util.console.listener.ITraceListener; + +public class MockTraceListener implements ITraceListener { + private String lastTrace = null; + public String getLastTrace() { + return lastTrace; + } + @Override + public void traceMsg(String traceMessage) { + lastTrace = traceMessage; + } +} Index: /trunk/java-utils-test/src/de/ugoe/cs/util/console/mock/commands/CMDmockCommand.java =================================================================== --- /trunk/java-utils-test/src/de/ugoe/cs/util/console/mock/commands/CMDmockCommand.java (revision 436) +++ /trunk/java-utils-test/src/de/ugoe/cs/util/console/mock/commands/CMDmockCommand.java (revision 436) @@ -0,0 +1,29 @@ +package de.ugoe.cs.util.console.mock.commands; + +import java.security.InvalidParameterException; +import java.util.List; + +import de.ugoe.cs.util.console.Command; +import de.ugoe.cs.util.console.Console; + +public class CMDmockCommand implements Command { + + @Override + public void run(List parameters) { + switch (parameters.size()) { + case 0: + Console.println("mock command: run"); + break; + case 1: + throw new InvalidParameterException(); + default: + throw new RuntimeException(); + } + } + + @Override + public void help() { + Console.println("mock command: help"); + } + +} Index: /trunk/java-utils-test/testdata/de.ugoe.cs.util.FileOutputListenerTest/expected.log =================================================================== --- /trunk/java-utils-test/testdata/de.ugoe.cs.util.FileOutputListenerTest/expected.log (revision 436) +++ /trunk/java-utils-test/testdata/de.ugoe.cs.util.FileOutputListenerTest/expected.log (revision 436) @@ -0,0 +1,1 @@ +test Index: /trunk/java-utils-test/testdata/de.ugoe.cs.util.FileToolsTest/testdata-cr.txt =================================================================== --- /trunk/java-utils-test/testdata/de.ugoe.cs.util.FileToolsTest/testdata-cr.txt (revision 436) +++ /trunk/java-utils-test/testdata/de.ugoe.cs.util.FileToolsTest/testdata-cr.txt (revision 436) @@ -0,0 +1,5 @@ +line1 +line2 +line3 + +line5 Index: /trunk/java-utils-test/testdata/de.ugoe.cs.util.FileToolsTest/testdata-nocr.txt =================================================================== --- /trunk/java-utils-test/testdata/de.ugoe.cs.util.FileToolsTest/testdata-nocr.txt (revision 436) +++ /trunk/java-utils-test/testdata/de.ugoe.cs.util.FileToolsTest/testdata-nocr.txt (revision 436) @@ -0,0 +1,5 @@ +line1 +line2 +line3 + +line5 Index: /trunk/java-utils-test/testdata/de.ugoe.cs.util.console.defaultcommands.CMDexecTest/script1 =================================================================== --- /trunk/java-utils-test/testdata/de.ugoe.cs.util.console.defaultcommands.CMDexecTest/script1 (revision 436) +++ /trunk/java-utils-test/testdata/de.ugoe.cs.util.console.defaultcommands.CMDexecTest/script1 (revision 436) @@ -0,0 +1,1 @@ +mockCommand Index: /trunk/java-utils-test/testdata/de.ugoe.cs.util.console.defaultcommands.CMDexecTest/script2 =================================================================== --- /trunk/java-utils-test/testdata/de.ugoe.cs.util.console.defaultcommands.CMDexecTest/script2 (revision 436) +++ /trunk/java-utils-test/testdata/de.ugoe.cs.util.console.defaultcommands.CMDexecTest/script2 (revision 436) @@ -0,0 +1,2 @@ +mockCommand +mockCommand param1