Index: /tags/java-utils-test-0.1.0/.classpath =================================================================== --- /tags/java-utils-test-0.1.0/.classpath (revision 1474) +++ /tags/java-utils-test-0.1.0/.classpath (revision 1474) @@ -0,0 +1,26 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + Index: /tags/java-utils-test-0.1.0/.project =================================================================== --- /tags/java-utils-test-0.1.0/.project (revision 1474) +++ /tags/java-utils-test-0.1.0/.project (revision 1474) @@ -0,0 +1,23 @@ + + + java-utils-test + + + + + + org.eclipse.jdt.core.javabuilder + + + + + org.eclipse.m2e.core.maven2Builder + + + + + + org.eclipse.m2e.core.maven2Nature + org.eclipse.jdt.core.javanature + + Index: /tags/java-utils-test-0.1.0/.settings/org.eclipse.jdt.core.prefs =================================================================== --- /tags/java-utils-test-0.1.0/.settings/org.eclipse.jdt.core.prefs (revision 1474) +++ /tags/java-utils-test-0.1.0/.settings/org.eclipse.jdt.core.prefs (revision 1474) @@ -0,0 +1,5 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7 +org.eclipse.jdt.core.compiler.compliance=1.7 +org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning +org.eclipse.jdt.core.compiler.source=1.7 Index: /tags/java-utils-test-0.1.0/.settings/org.eclipse.m2e.core.prefs =================================================================== --- /tags/java-utils-test-0.1.0/.settings/org.eclipse.m2e.core.prefs (revision 1474) +++ /tags/java-utils-test-0.1.0/.settings/org.eclipse.m2e.core.prefs (revision 1474) @@ -0,0 +1,4 @@ +activeProfiles= +eclipse.preferences.version=1 +resolveWorkspaceProjects=true +version=1 Index: /tags/java-utils-test-0.1.0/pom.xml =================================================================== --- /tags/java-utils-test-0.1.0/pom.xml (revision 1474) +++ /tags/java-utils-test-0.1.0/pom.xml (revision 1474) @@ -0,0 +1,144 @@ + + 4.0.0 + de.ugoe.cs + java-utils-test + 0.1.0 + java-utils-test + + + The Apache Software License, Version 2.0 + http://www.apache.org/licenses/LICENSE-2.0.txt + + + + https://autoquest.informatik.uni-goettingen.de/svn/autoquest/tags/java-utils-test-0.1.0 + scm:svn:https://autoquest.informatik.uni-goettingen.de/svn/autoquest/tags/java-utils-test-0.1.0 + + + + autoquest-snapshots + https://trex.informatik.uni-goettingen.de/nexus/content/repositories/autoquest-snapshots + + + autoquest + https://trex.informatik.uni-goettingen.de/nexus/content/repositories/autoquest-releases + + + + + de.ugoe.cs + java-utils + 0.1.0 + test + + + junit + junit + 4.8.1 + test + + + junit-addons + junit-addons + 1.4 + + + + + + + org.eclipse.m2e + lifecycle-mapping + 1.0.0 + + + + + + org.apache.maven.plugins + maven-dependency-plugin + [1.0.0,) + + unpack + + + + + + + + + org.codehaus.mojo + emma-maven-plugin + [1.0-alpha-3,) + + emma + + + + + + + + + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 2.3.2 + + 1.7 + 1.7 + + + + org.apache.maven.plugins + maven-dependency-plugin + 2.4 + + + unpack + process-classes + + unpack + + + + + de.ugoe.cs + java-utils + 0.0.1-SNAPSHOT + ${project.build.directory}/classes + + + + + + + + org.apache.maven.plugins + maven-surefire-plugin + 2.12 + + -XX:-UseSplitVerifier + + + + org.apache.maven.plugins + maven-jar-plugin + 2.3.2 + + + + test-jar + + + + + + + Index: /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/ArrayToolsTest.java =================================================================== --- /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/ArrayToolsTest.java (revision 1474) +++ /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/ArrayToolsTest.java (revision 1474) @@ -0,0 +1,205 @@ +// Copyright 2012 Georg-August-Universität Göttingen, Germany +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +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 = 9; + + double[] array = {2,3,6,1,8,9,1,1,3,15,4,15,-1}; + + int result = ArrayTools.findMax(array); + + 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: /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/FileToolsTest.java =================================================================== --- /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/FileToolsTest.java (revision 1474) +++ /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/FileToolsTest.java (revision 1474) @@ -0,0 +1,144 @@ +// Copyright 2012 Georg-August-Universität Göttingen, Germany +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package de.ugoe.cs.util; + +import java.io.File; + +import junitx.framework.FileAssert; + +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); + } + + @Test + public void testWriteArrayToFile_1() throws Exception { + String[] array = new String[]{"foo", "bar"}; + String filename = "testdata/de.ugoe.cs.util.FileToolsTest/writeArrayToFile-actual_01.txt"; + String separator = ""; + boolean lineBreak = false; + + // cleanup old result + new File(filename).delete(); + + FileTools.writeArrayToFile(array, filename, separator, lineBreak); + + FileAssert.assertEquals(new File("testdata/de.ugoe.cs.util.FileToolsTest/writeArrayToFile-expected_01.txt"), new File(filename)); + + // cleanup after successful test + new File(filename).delete(); + } + + @Test + public void testWriteArrayToFile_2() throws Exception { + String[] array = new String[]{"foo", "bar"}; + String filename = "testdata/de.ugoe.cs.util.FileToolsTest/writeArrayToFile-actual_02.txt"; + String separator = " - "; + boolean lineBreak = false; + + // cleanup old result + new File(filename).delete(); + + FileTools.writeArrayToFile(array, filename, separator, lineBreak); + + FileAssert.assertEquals(new File("testdata/de.ugoe.cs.util.FileToolsTest/writeArrayToFile-expected_02.txt"), new File(filename)); + + // cleanup after successful test + new File(filename).delete(); + } + + @Test + public void testWriteArrayToFile_3() throws Exception { + String[] array = new String[]{"foo", "bar"}; + String filename = "testdata/de.ugoe.cs.util.FileToolsTest/writeArrayToFile-actual_03.txt"; + String separator = ""; + boolean lineBreak = true; + + // cleanup old result + new File(filename).delete(); + + FileTools.writeArrayToFile(array, filename, separator, lineBreak); + + String expectedFile; + if( System.getProperty("line.separator").equals("\r\n") ) { + expectedFile = "testdata/de.ugoe.cs.util.FileToolsTest/writeArrayToFile-expected_03_cr.txt"; + } else { + expectedFile = "testdata/de.ugoe.cs.util.FileToolsTest/writeArrayToFile-expected_03_nocr.txt"; + } + + FileAssert.assertEquals(new File(expectedFile), new File(filename)); + + // cleanup after successful test + new File(filename).delete(); + } + + public static void main(String[] args) { + new org.junit.runner.JUnitCore().run(FileToolsTest.class); + } +} Index: /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/StopWatchTest.java =================================================================== --- /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/StopWatchTest.java (revision 1474) +++ /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/StopWatchTest.java (revision 1474) @@ -0,0 +1,199 @@ +// Copyright 2012 Georg-August-Universität Göttingen, Germany +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package de.ugoe.cs.util; + +import static org.junit.Assert.*; + +import org.junit.Test; + +/** + * + */ +public class StopWatchTest { + + /** + * + */ + @Test + public void test_01() throws Exception { + StopWatch stopWatch = new StopWatch(); + + String id = "id1"; + stopWatch.start(id); + Thread.sleep(100); + stopWatch.stop(id); + + assertTrue((98 < stopWatch.getDuration(id)) && (stopWatch.getDuration(id) < 102)); + } + + /** + * + */ + @Test + public void test_02() throws Exception { + StopWatch stopWatch = new StopWatch(); + + String id; + for (int i = 0; i < 10; i++) { + id = "id" + i; + stopWatch.start(id); + } + + for (int i = 0; i < 10; i++) { + id = "id" + i; + stopWatch.stop(id); + } + + for (int i = 0; i < 10; i++) { + id = "id" + i; + assertTrue(stopWatch.getDuration(id) >= 0); + } + } + + /** + * + */ + @Test(expected=IllegalArgumentException.class) + public void test_03() throws Exception { + StopWatch stopWatch = new StopWatch(); + + stopWatch.stop("id1"); + } + + /** + * + */ + @Test(expected=IllegalArgumentException.class) + public void test_04() throws Exception { + StopWatch stopWatch = new StopWatch(); + + stopWatch.getDuration("id1"); + } + + /** + * + */ + @Test(expected=IllegalStateException.class) + public void test_05() throws Exception { + StopWatch stopWatch = new StopWatch(); + + String id = "id1"; + stopWatch.start(id); + stopWatch.stop(id); + + stopWatch.stop(id); + } + + /** + * + */ + @Test(expected=IllegalStateException.class) + public void test_06() throws Exception { + StopWatch stopWatch = new StopWatch(); + + String id = "id1"; + stopWatch.start(id); + stopWatch.getDuration(id); + + stopWatch.stop(id); + } + + /** + * + */ + @Test(expected=IllegalStateException.class) + public void test_07() throws Exception { + StopWatch stopWatch = new StopWatch(); + + String id = "id1"; + stopWatch.start(id); + + stopWatch.start(id); + } + + + /** + * + */ + @Test + public void test_08() throws Exception { + StopWatch stopWatch = new StopWatch(); + + String id; + // start 0 - 4 + for (int i = 0; i < 5; i++) { + id = "id" + i; + stopWatch.start(id); + } + + Thread.sleep(10); + + // stop 0 - 2 + for (int i = 0; i < 3; i++) { + id = "id" + i; + stopWatch.stop(id); + } + + // start 5 - 7 + for (int i = 5; i < 8; i++) { + id = "id" + i; + stopWatch.start(id); + } + + Thread.sleep(10); + + // stop 3 - 6 + for (int i = 3; i < 7; i++) { + id = "id" + i; + stopWatch.stop(id); + } + + // start 8 - 9 + for (int i = 8; i < 10; i++) { + id = "id" + i; + stopWatch.start(id); + } + + Thread.sleep(10); + + // start 0 - 6 + for (int i = 0; i < 7; i++) { + id = "id" + i; + stopWatch.start(id); + } + + Thread.sleep(10); + + // stop all + for (int i = 2; i < 7; i++) { + id = "id" + i; + stopWatch.stop(id); + } + + // start all + for (int i = 2; i < 7; i++) { + id = "id" + i; + stopWatch.start(id); + } + + Thread.sleep(10); + + // stop all and ensure, that durations are returned + for (int i = 2; i < 7; i++) { + id = "id" + i; + assertTrue(stopWatch.getDuration(id) >= 10); + } + } +} Index: /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/StringToolsTest.java =================================================================== --- /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/StringToolsTest.java (revision 1474) +++ /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/StringToolsTest.java (revision 1474) @@ -0,0 +1,150 @@ +// Copyright 2012 Georg-August-Universität Göttingen, Germany +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +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 = "aCommandExecuterTest contains tests for the class + * {@link CommandExecuter}. + * + * @author Steffen Herbold + * @version 1.0 + */ +public class CommandExecuterTest { + + @Test(expected=java.lang.IllegalArgumentException.class) + public void testAddCommandPackage_1() + throws Exception { + CommandExecuter fixture = CommandExecuter.getInstance(); + + fixture.addCommandPackage(""); + } + + @Test(expected=java.lang.IllegalArgumentException.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 = "Usage: mock command: help" + System.getProperty("line.separator"); + + fixture.exec(command); + + assertEquals(expected, mockListener.getLastOutput()); + } + + @Test + 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); + } + + @BeforeClass + public static void setupBeforeClass() { + Console.reset(); + } + + public static void main(String[] args) { + new org.junit.runner.JUnitCore().run(CommandExecuterTest.class); + } +} Index: /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/CommandParserTest.java =================================================================== --- /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/CommandParserTest.java (revision 1474) +++ /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/CommandParserTest.java (revision 1474) @@ -0,0 +1,269 @@ +// Copyright 2012 Georg-August-Universität Göttingen, Germany +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +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: /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/ConsoleTest.java =================================================================== --- /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/ConsoleTest.java (revision 1474) +++ /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/ConsoleTest.java (revision 1474) @@ -0,0 +1,424 @@ +// Copyright 2012 Georg-August-Universität Göttingen, Germany +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package de.ugoe.cs.util.console; + +import java.util.logging.Level; + +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)); + } + + @SuppressWarnings("deprecation") + @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(Level.INFO, mockTraceListener1.getLastLevel()); + assertEquals(traceMsg, mockTraceListener2.getLastTrace()); + assertEquals(Level.INFO, mockTraceListener2.getLastLevel()); + } + + @Test + public void testTrace_2() + throws Exception { + String traceMsg = "test"; + Level traceLevel = Level.SEVERE; + + MockTraceListener mockTraceListener1 = new MockTraceListener(); + MockTraceListener mockTraceListener2 = new MockTraceListener(); + + Console.getInstance().registerTraceListener(mockTraceListener1); + Console.getInstance().registerTraceListener(mockTraceListener2); + + Console.trace(traceLevel, traceMsg); + + assertEquals(traceMsg, mockTraceListener1.getLastTrace()); + assertEquals(traceLevel, mockTraceListener1.getLastLevel()); + assertEquals(traceMsg, mockTraceListener2.getLastTrace()); + assertEquals(traceLevel, mockTraceListener2.getLastLevel()); + } + + @SuppressWarnings("deprecation") + @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(Level.INFO, mockTraceListener1.getLastLevel()); + assertEquals(traceMsg+ENDLINE, mockTraceListener2.getLastTrace()); + assertEquals(Level.INFO, mockTraceListener1.getLastLevel()); + } + + @Test + public void testTraceln_2() + throws Exception { + String traceMsg = "test"; + Level traceLevel = Level.SEVERE; + + MockTraceListener mockTraceListener1 = new MockTraceListener(); + MockTraceListener mockTraceListener2 = new MockTraceListener(); + + Console.getInstance().registerTraceListener(mockTraceListener1); + Console.getInstance().registerTraceListener(mockTraceListener2); + + Console.traceln(traceLevel, traceMsg); + + assertEquals(traceMsg+ENDLINE, mockTraceListener1.getLastTrace()); + assertEquals(traceLevel, mockTraceListener1.getLastLevel()); + assertEquals(traceMsg+ENDLINE, mockTraceListener2.getLastTrace()); + assertEquals(traceLevel, mockTraceListener2.getLastLevel()); + } + + @Before + public void setUp() + throws Exception { + Console.reset(); + } + + public static void main(String[] args) { + new org.junit.runner.JUnitCore().run(ConsoleTest.class); + } +} Index: /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/FileOutputListenerTest.java =================================================================== --- /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/FileOutputListenerTest.java (revision 1474) +++ /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/FileOutputListenerTest.java (revision 1474) @@ -0,0 +1,112 @@ +// Copyright 2012 Georg-August-Universität Göttingen, Germany +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +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: /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/GlobalDataContainerTest.java =================================================================== --- /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/GlobalDataContainerTest.java (revision 1474) +++ /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/GlobalDataContainerTest.java (revision 1474) @@ -0,0 +1,312 @@ +// Copyright 2012 Georg-August-Universität Göttingen, Germany +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package de.ugoe.cs.util.console; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertSame; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.InputStream; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.lang.reflect.Constructor; +import java.lang.reflect.Modifier; +import java.util.Collection; +import java.util.LinkedList; + +import org.junit.Before; +import org.junit.Test; + +import de.ugoe.cs.util.console.GlobalDataContainer; + +/** + * The class WindowsEventTest contains tests for the class + * {@link WindowsEvent}. + * + * @author Steffen Herbold + * @version 1.0 + */ +public class GlobalDataContainerTest { + + private static void assertCollectionContent(Collection c1, Collection c2) { + assertEquals(c1.size(), c2.size()); + for (Object obj : c1) { + assertTrue(c2.contains(obj)); + } + } + + @Test + public void testGlobalDataContainer_1() throws Exception { + // assure that all constructors are private + Constructor[] constructors = GlobalDataContainer.class.getDeclaredConstructors(); + for (int i = 0; i < constructors.length; i++) { + int modifier = constructors[i].getModifiers(); + if (modifier != Modifier.PRIVATE) { + fail(constructors[i].getName() + " - " + Modifier.toString(modifier)); + } + } + } + + @Test + public void testGetInstance_1() throws Exception { + GlobalDataContainer instance1 = GlobalDataContainer.getInstance(); + GlobalDataContainer instance2 = GlobalDataContainer.getInstance(); + assertNotNull(instance1); + assertSame(instance1, instance2); + } + + @Test + public void testDatahandling_1() throws Exception { + // test is data can be added and retrieved as expected + GlobalDataContainer instance = GlobalDataContainer.getInstance(); + + String key1 = "key1"; + String data1 = "data1"; + String key2 = "key2"; + String data2 = "data2"; + String key3 = "key3"; + Integer data3 = 1; + String key4 = "key4"; + Integer data4 = 2; + String key5 = "key5"; + Integer data5 = 3; + + assertFalse(instance.addData(key1, data1)); + assertFalse(instance.addData(key2, data2)); + assertFalse(instance.addData(key3, data3)); + assertFalse(instance.addData(key4, data4)); + assertFalse(instance.addData(key5, data5)); + + assertEquals(data1, instance.getData(key1)); + assertEquals(data2, instance.getData(key2)); + assertEquals(data3, instance.getData(key3)); + assertEquals(data4, instance.getData(key4)); + assertEquals(data5, instance.getData(key5)); + } + + @Test + public void testDatahandling_2() throws Exception { + // test is data can be added, overwritten, and retrieved as expected + GlobalDataContainer instance = GlobalDataContainer.getInstance(); + + String key1 = "key1"; + String data1 = "data1"; + String data1changed = "data1changed"; + String key2 = "key2"; + String data2 = "data2"; + String data2changed = "data2changed"; + String key3 = "key3"; + Integer data3 = 1; + Integer data3changed = 11; + String key4 = "key4"; + Integer data4 = 2; + Integer data4changed = 22; + String key5 = "key5"; + Integer data5 = 3; + Integer data5changed = 33; + + assertFalse(instance.addData(key1, data1)); + assertFalse(instance.addData(key2, data2)); + assertFalse(instance.addData(key3, data3)); + assertFalse(instance.addData(key4, data4)); + assertFalse(instance.addData(key5, data5)); + + assertTrue(instance.addData(key1, data1changed)); + assertTrue(instance.addData(key2, data2changed)); + assertTrue(instance.addData(key3, data3changed)); + assertTrue(instance.addData(key4, data4changed)); + assertTrue(instance.addData(key5, data5changed)); + + assertEquals(data1changed, instance.getData(key1)); + assertEquals(data2changed, instance.getData(key2)); + assertEquals(data3changed, instance.getData(key3)); + assertEquals(data4changed, instance.getData(key4)); + assertEquals(data5changed, instance.getData(key5)); + } + + @Test + public void testDatahandling_3() throws Exception { + // test is data can be removed as expected + GlobalDataContainer instance = GlobalDataContainer.getInstance(); + + String key1 = "key1"; + String data1 = "data1"; + String key2 = "key2"; + String data2 = "data2"; + String key3 = "key3"; + Integer data3 = 1; + String key4 = "key4"; + Integer data4 = 2; + String key5 = "key5"; + Integer data5 = 3; + + assertFalse(instance.addData(key1, data1)); + assertFalse(instance.addData(key2, data2)); + assertFalse(instance.addData(key3, data3)); + assertFalse(instance.addData(key4, data4)); + assertFalse(instance.addData(key5, data5)); + + assertFalse(instance.removeData("keyNotFound")); + assertTrue(instance.removeData(key1)); + + assertNull(instance.getData(key1)); + } + + @Test + public void testDatahandling_4() throws Exception { + // test is data can be removed as expected + GlobalDataContainer instance = GlobalDataContainer.getInstance(); + + String key1 = "key1"; + String data1 = "data1"; + String key2 = "key2"; + String data2 = "data2"; + String key3 = "key3"; + Integer data3 = 1; + String key4 = "key4"; + Integer data4 = 2; + String key5 = "key5"; + Integer data5 = 3; + + assertFalse(instance.addData(key1, data1)); + assertFalse(instance.addData(key2, data2)); + assertFalse(instance.addData(key3, data3)); + assertFalse(instance.addData(key4, data4)); + assertFalse(instance.addData(key5, data5)); + + assertNull(instance.getData("keyNotFound")); + } + + @Test + public void testReset_1() throws Exception { + // check if data container is empty after reset + GlobalDataContainer instance = GlobalDataContainer.getInstance(); + String key1 = "key1"; + String data1 = "data1"; + String key2 = "key2"; + String data2 = "data2"; + String key3 = "key3"; + Integer data3 = 1; + String key4 = "key4"; + Integer data4 = 2; + String key5 = "key5"; + Integer data5 = 3; + + assertFalse(instance.addData(key1, data1)); + assertFalse(instance.addData(key2, data2)); + assertFalse(instance.addData(key3, data3)); + assertFalse(instance.addData(key4, data4)); + assertFalse(instance.addData(key5, data5)); + + instance.reset(); + + assertNull(instance.getData(key1)); + assertNull(instance.getData(key2)); + assertNull(instance.getData(key3)); + assertNull(instance.getData(key4)); + assertNull(instance.getData(key5)); + } + + @Test + public void testGetAllKeys_1() throws Exception { + // check if data container is empty after reset + GlobalDataContainer instance = GlobalDataContainer.getInstance(); + String key1 = "key1"; + String data1 = "data1"; + String key2 = "key2"; + String data2 = "data2"; + String key3 = "key3"; + Integer data3 = 1; + String key4 = "key4"; + Integer data4 = 2; + String key5 = "key5"; + Integer data5 = 3; + + assertFalse(instance.addData(key1, data1)); + assertFalse(instance.addData(key2, data2)); + assertFalse(instance.addData(key3, data3)); + assertFalse(instance.addData(key4, data4)); + assertFalse(instance.addData(key5, data5)); + + Collection expected = new LinkedList(); + expected.add(key1); + expected.add(key2); + expected.add(key3); + expected.add(key4); + expected.add(key5); + + assertCollectionContent(expected, instance.getAllKeys()); + } + + @Test + public void testSerialization_1() throws Exception { + GlobalDataContainer instance = GlobalDataContainer.getInstance(); + String key1 = "key1"; + String data1 = "data1"; + String key2 = "key2"; + String data2 = "data2"; + String key3 = "key3"; + Integer data3 = 1; + String key4 = "key4"; + Integer data4 = 2; + String key5 = "key5"; + Integer data5 = 3; + + String key6 = "key6"; + Double data6 = 6.0d; + + assertFalse(instance.addData(key1, data1)); + assertFalse(instance.addData(key2, data2)); + assertFalse(instance.addData(key3, data3)); + assertFalse(instance.addData(key4, data4)); + assertFalse(instance.addData(key5, data5)); + + // serialize + ByteArrayOutputStream out = new ByteArrayOutputStream(); + ObjectOutputStream oos = new ObjectOutputStream(out); + oos.writeObject(instance); + oos.close(); + + instance.reset(); + assertFalse(instance.addData(key6, data6)); + + // deserialize + byte[] pickled = out.toByteArray(); + InputStream in = new ByteArrayInputStream(pickled); + ObjectInputStream ois = new ObjectInputStream(in); + ois.readObject(); + ois.close(); + + // test the result + assertEquals(data1, instance.getData(key1)); + assertEquals(data2, instance.getData(key2)); + assertEquals(data3, instance.getData(key3)); + assertEquals(data4, instance.getData(key4)); + assertEquals(data5, instance.getData(key5)); + assertNull(instance.getData(key6)); + } + + @Before + public void setUp() { + GlobalDataContainer.getInstance().reset(); + } + +} Index: /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/TextConsoleTest.java =================================================================== --- /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/TextConsoleTest.java (revision 1474) +++ /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/TextConsoleTest.java (revision 1474) @@ -0,0 +1,136 @@ +// Copyright 2012 Georg-August-Universität Göttingen, Germany +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +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 PrintStream sysOut = null; + private PrintStream sysErr = null; + + 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(); +// String traceMessage = "test"; +// Level traceLevel = Level.WARNING; +// String expectedMessage = "[WARNING] test"; +// +// fixture.traceMsg(traceMessage, traceLevel); +// +// assertEquals(expectedMessage, outContent.toString()); +// } +// +// @Test +// public void testTraceMsg_2() throws Exception { +// TextConsole fixture = new TextConsole(Level.INFO); +// String traceMessage = "test"; +// Level traceLevel = Level.INFO; +// String expectedMessage = "[INFO] test"; +// +// fixture.traceMsg(traceMessage, traceLevel); +// +// assertEquals(expectedMessage, outContent.toString()); +// } +// +// @Test +// public void testTraceMsg_3() throws Exception { +// TextConsole fixture = new TextConsole(Level.WARNING); +// String traceMessage = "[INFO] test"; +// Level traceLevel = Level.INFO; +// +// +// fixture.traceMsg(traceMessage, traceLevel); +// +// assertEquals("", outContent.toString()); +// } + + @Before + public void setUp() throws Exception { + sysOut = new PrintStream(System.out); + sysErr = new PrintStream(System.err); + System.setOut(new PrintStream(outContent)); + System.setErr(new PrintStream(errContent)); + } + + @After + public void tearDown() throws Exception { + System.setOut(sysOut); + System.setErr(sysErr); + } + + public static void main(String[] args) { + new org.junit.runner.JUnitCore().run(TextConsoleTest.class); + } +} Index: /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/defaultcommands/CMDexecTest.java =================================================================== --- /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/defaultcommands/CMDexecTest.java (revision 1474) +++ /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/defaultcommands/CMDexecTest.java (revision 1474) @@ -0,0 +1,130 @@ +// Copyright 2012 Georg-August-Universität Göttingen, Germany +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +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 = "exec "; + + assertEquals(expected, fixture.help()); + } + + @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 exepctedCommand = "mockCommand"; + String expectedTrace = "Executing \"mockCommand\""; + + fixture.run(parameters); + + assertEquals(exepctedCommand, mockCommandListener.getLastCommand()); + assertEquals(expectedTrace + 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 expectedCommand = "mockCommand param1"; + String expectedTrace = "Executing \"mockCommand param1\""; + + fixture.run(parameters); + + assertEquals(expectedCommand, mockCommandListener.getLastCommand()); + assertEquals(expectedTrace + ENDLINE, mockTraceListener.getLastTrace()); + } + + @Test(expected = java.lang.IllegalArgumentException.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 expectedCommand = "mockCommand param1"; + String expectedTrace = "Executing \"mockCommand param1\""; + + fixture.run(parameters); + + assertEquals(expectedCommand, mockCommandListener.getLastCommand()); + assertEquals(expectedTrace + ENDLINE, mockTraceListener.getLastTrace()); + } + + @Test(expected = java.lang.IllegalArgumentException.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: /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/defaultcommands/CMDexitTest.java =================================================================== --- /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/defaultcommands/CMDexitTest.java (revision 1474) +++ /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/defaultcommands/CMDexitTest.java (revision 1474) @@ -0,0 +1,99 @@ +// Copyright 2012 Georg-August-Universität Göttingen, Germany +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +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 = "exit"; + + assertEquals(expected, fixture.help()); + } + + @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: /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/defaultcommands/CMDlistCommandsTest.java =================================================================== --- /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/defaultcommands/CMDlistCommandsTest.java (revision 1474) +++ /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/defaultcommands/CMDlistCommandsTest.java (revision 1474) @@ -0,0 +1,60 @@ +// Copyright 2012 Georg-August-Universität Göttingen, Germany +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + + +package de.ugoe.cs.util.console.defaultcommands; + +import static org.junit.Assert.*; + +import java.util.ArrayList; +import java.util.List; + +import org.junit.Before; +import org.junit.Test; + +import de.ugoe.cs.util.console.CommandExecuter; +import de.ugoe.cs.util.console.Console; +import de.ugoe.cs.util.console.defaultcommands.CMDlistCommands; +import de.ugoe.cs.util.console.listener.IOutputListener; + +public class CMDlistCommandsTest implements IOutputListener { + + private List commands = new ArrayList(); + + @Before + public void setUp() throws Exception { + Console.getInstance().registerOutputListener(this); + } + + @Test + public void test() { + CommandExecuter.getInstance().addCommandPackage("de.ugoe.cs.util.console.defaultcommands"); + CMDlistCommands command = new CMDlistCommands(); + command.run(null); + + assertTrue(commands.size() > 0); + + for (String cmd : commands) { + assertNotNull(cmd); + assertTrue(cmd.length() > 0); + System.out.print(cmd); + } + } + + @Override + public void outputMsg(String newMessage) { + commands.add(newMessage); + } + +} Index: /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/mock/MockCommandListener.java =================================================================== --- /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/mock/MockCommandListener.java (revision 1474) +++ /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/mock/MockCommandListener.java (revision 1474) @@ -0,0 +1,30 @@ +// Copyright 2012 Georg-August-Universität Göttingen, Germany +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +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: /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/mock/MockErrorListener.java =================================================================== --- /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/mock/MockErrorListener.java (revision 1474) +++ /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/mock/MockErrorListener.java (revision 1474) @@ -0,0 +1,28 @@ +// Copyright 2012 Georg-August-Universität Göttingen, Germany +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +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: /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/mock/MockExceptionListener.java =================================================================== --- /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/mock/MockExceptionListener.java (revision 1474) +++ /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/mock/MockExceptionListener.java (revision 1474) @@ -0,0 +1,30 @@ +// Copyright 2012 Georg-August-Universität Göttingen, Germany +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +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: /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/mock/MockObserver.java =================================================================== --- /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/mock/MockObserver.java (revision 1474) +++ /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/mock/MockObserver.java (revision 1474) @@ -0,0 +1,39 @@ +// Copyright 2012 Georg-August-Universität Göttingen, Germany +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package de.ugoe.cs.util.console.mock; + +import java.util.logging.Level; + +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, Level level) { + } +} Index: /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/mock/MockOutputListener.java =================================================================== --- /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/mock/MockOutputListener.java (revision 1474) +++ /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/mock/MockOutputListener.java (revision 1474) @@ -0,0 +1,36 @@ +// Copyright 2012 Georg-August-Universität Göttingen, Germany +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +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: /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/mock/MockTraceListener.java =================================================================== --- /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/mock/MockTraceListener.java (revision 1474) +++ /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/mock/MockTraceListener.java (revision 1474) @@ -0,0 +1,37 @@ +// Copyright 2012 Georg-August-Universität Göttingen, Germany +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package de.ugoe.cs.util.console.mock; + +import java.util.logging.Level; + +import de.ugoe.cs.util.console.listener.ITraceListener; + +public class MockTraceListener implements ITraceListener { + private String lastTrace = null; + private Level lastLevel = null; + public String getLastTrace() { + return lastTrace; + } + + public Level getLastLevel() { + return lastLevel; + } + + @Override + public void traceMsg(String traceMessage, Level level) { + lastTrace = traceMessage; + lastLevel = level; + } +} Index: /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/mock/commands/CMDmockCommand.java =================================================================== --- /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/mock/commands/CMDmockCommand.java (revision 1474) +++ /tags/java-utils-test-0.1.0/src/test/java/de/ugoe/cs/util/console/mock/commands/CMDmockCommand.java (revision 1474) @@ -0,0 +1,42 @@ +// Copyright 2012 Georg-August-Universität Göttingen, Germany +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package de.ugoe.cs.util.console.mock.commands; + +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 IllegalArgumentException(); + default: + throw new RuntimeException(); + } + } + + @Override + public String help() { + return "mock command: help"; + } + +} Index: /tags/java-utils-test-0.1.0/testdata/de.ugoe.cs.util.FileOutputListenerTest/expected.log =================================================================== --- /tags/java-utils-test-0.1.0/testdata/de.ugoe.cs.util.FileOutputListenerTest/expected.log (revision 1474) +++ /tags/java-utils-test-0.1.0/testdata/de.ugoe.cs.util.FileOutputListenerTest/expected.log (revision 1474) @@ -0,0 +1,1 @@ +test Index: /tags/java-utils-test-0.1.0/testdata/de.ugoe.cs.util.FileToolsTest/testdata-cr.txt =================================================================== --- /tags/java-utils-test-0.1.0/testdata/de.ugoe.cs.util.FileToolsTest/testdata-cr.txt (revision 1474) +++ /tags/java-utils-test-0.1.0/testdata/de.ugoe.cs.util.FileToolsTest/testdata-cr.txt (revision 1474) @@ -0,0 +1,5 @@ +line1 +line2 +line3 + +line5 Index: /tags/java-utils-test-0.1.0/testdata/de.ugoe.cs.util.FileToolsTest/testdata-nocr.txt =================================================================== --- /tags/java-utils-test-0.1.0/testdata/de.ugoe.cs.util.FileToolsTest/testdata-nocr.txt (revision 1474) +++ /tags/java-utils-test-0.1.0/testdata/de.ugoe.cs.util.FileToolsTest/testdata-nocr.txt (revision 1474) @@ -0,0 +1,5 @@ +line1 +line2 +line3 + +line5 Index: /tags/java-utils-test-0.1.0/testdata/de.ugoe.cs.util.FileToolsTest/writeArrayToFile-expected_01.txt =================================================================== --- /tags/java-utils-test-0.1.0/testdata/de.ugoe.cs.util.FileToolsTest/writeArrayToFile-expected_01.txt (revision 1474) +++ /tags/java-utils-test-0.1.0/testdata/de.ugoe.cs.util.FileToolsTest/writeArrayToFile-expected_01.txt (revision 1474) @@ -0,0 +1,1 @@ +foobar Index: /tags/java-utils-test-0.1.0/testdata/de.ugoe.cs.util.FileToolsTest/writeArrayToFile-expected_02.txt =================================================================== --- /tags/java-utils-test-0.1.0/testdata/de.ugoe.cs.util.FileToolsTest/writeArrayToFile-expected_02.txt (revision 1474) +++ /tags/java-utils-test-0.1.0/testdata/de.ugoe.cs.util.FileToolsTest/writeArrayToFile-expected_02.txt (revision 1474) @@ -0,0 +1,1 @@ +foo - bar Index: /tags/java-utils-test-0.1.0/testdata/de.ugoe.cs.util.FileToolsTest/writeArrayToFile-expected_03_cr.txt =================================================================== --- /tags/java-utils-test-0.1.0/testdata/de.ugoe.cs.util.FileToolsTest/writeArrayToFile-expected_03_cr.txt (revision 1474) +++ /tags/java-utils-test-0.1.0/testdata/de.ugoe.cs.util.FileToolsTest/writeArrayToFile-expected_03_cr.txt (revision 1474) @@ -0,0 +1,2 @@ +foo +bar Index: /tags/java-utils-test-0.1.0/testdata/de.ugoe.cs.util.FileToolsTest/writeArrayToFile-expected_03_nocr.txt =================================================================== --- /tags/java-utils-test-0.1.0/testdata/de.ugoe.cs.util.FileToolsTest/writeArrayToFile-expected_03_nocr.txt (revision 1474) +++ /tags/java-utils-test-0.1.0/testdata/de.ugoe.cs.util.FileToolsTest/writeArrayToFile-expected_03_nocr.txt (revision 1474) @@ -0,0 +1,2 @@ +foo +bar Index: /tags/java-utils-test-0.1.0/testdata/de.ugoe.cs.util.console.defaultcommands.CMDexecTest/script1 =================================================================== --- /tags/java-utils-test-0.1.0/testdata/de.ugoe.cs.util.console.defaultcommands.CMDexecTest/script1 (revision 1474) +++ /tags/java-utils-test-0.1.0/testdata/de.ugoe.cs.util.console.defaultcommands.CMDexecTest/script1 (revision 1474) @@ -0,0 +1,1 @@ +mockCommand Index: /tags/java-utils-test-0.1.0/testdata/de.ugoe.cs.util.console.defaultcommands.CMDexecTest/script2 =================================================================== --- /tags/java-utils-test-0.1.0/testdata/de.ugoe.cs.util.console.defaultcommands.CMDexecTest/script2 (revision 1474) +++ /tags/java-utils-test-0.1.0/testdata/de.ugoe.cs.util.console.defaultcommands.CMDexecTest/script2 (revision 1474) @@ -0,0 +1,2 @@ +mockCommand +mockCommand param1