Initial project version

diff --git a/.gitignore b/.gitignore
new file mode 100644 (file)
index 0000000..9aac7d9
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,5 @@
+.classpath
+.project
+.settings
+bin
+target

diff --git a/pom.xml b/pom.xml
new file mode 100644 (file)
index 0000000..75b7244
--- /dev/null
+++ b/pom.xml
@@ -0,0 +1,44 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+       <modelVersion>4.0.0</modelVersion>
+       <groupId>de.laktatnebel.libs</groupId>
+       <artifactId>utillib</artifactId>
+       <version>2.1.1-SNAPSHOT</version>
+
+       <name>UtilLib</name>
+
+       <parent>
+               <groupId>de.laktatnebel.maven</groupId>
+               <artifactId>laktatnebellib</artifactId>
+               <version>2.1.7</version>
+       </parent>
+
+       <properties>
+               <slf4j.version>1.6.4</slf4j.version>
+       </properties>
+
+       <dependencyManagement>
+               <dependencies>
+                       <dependency>
+                               <groupId>org.slf4j</groupId>
+                               <artifactId>slf4j-api</artifactId>
+                               <version>${slf4j.version}</version>
+                       </dependency>
+                       <dependency>
+                               <groupId>org.slf4j</groupId>
+                               <artifactId>slf4j-log4j12</artifactId>
+                               <version>${slf4j.version}</version>
+                       </dependency>
+               </dependencies>
+       </dependencyManagement>
+
+       <dependencies>
+               <dependency>
+                       <groupId>org.slf4j</groupId>
+                       <artifactId>slf4j-api</artifactId>
+               </dependency>
+               <dependency>
+                       <groupId>org.slf4j</groupId>
+                       <artifactId>slf4j-log4j12</artifactId>
+               </dependency>
+       </dependencies>
+</project>

diff --git a/src/main/java/de/laktatnebel/libs/utillib/collection/AbstractCollectionConsoleOutput.java b/src/main/java/de/laktatnebel/libs/utillib/collection/AbstractCollectionConsoleOutput.java
new file mode 100644 (file)
index 0000000..ca88dc2
--- /dev/null
+++ b/src/main/java/de/laktatnebel/libs/utillib/collection/AbstractCollectionConsoleOutput.java
@@ -0,0 +1,27 @@
+package de.laktatnebel.libs.utillib.collection;\r
+\r
+import org.slf4j.Logger;\r
+\r
+import de.laktatnebel.libs.utillib.logging.StaticLogger;\r
+\r
+/**\r
+* @author oleb\r
+ *\r
+ */\r
+public abstract class AbstractCollectionConsoleOutput {\r
+\r
+    /**\r
+     *\r
+     * @param array Object[] Object-Array\r
+     */\r
+    protected static void getArrayLoop(Object[] array) {\r
+        Logger logger = StaticLogger.getLogger(CollectionConsoleOutputList.class);\r
+\r
+        for (Object obj : array) {\r
+            if (obj != null) {\r
+                StaticLogger.log(logger, obj.toString());\r
+            }\r
+        }\r
+    }\r
+\r
+}\r

diff --git a/src/main/java/de/laktatnebel/libs/utillib/collection/CollectionConsoleOutputList.java b/src/main/java/de/laktatnebel/libs/utillib/collection/CollectionConsoleOutputList.java
new file mode 100644 (file)
index 0000000..dca3b79
--- /dev/null
+++ b/src/main/java/de/laktatnebel/libs/utillib/collection/CollectionConsoleOutputList.java
@@ -0,0 +1,46 @@
+package de.laktatnebel.libs.utillib.collection;\r
+\r
+import java.util.List;\r
+\r
+import de.laktatnebel.libs.utillib.exception.CollectionOutputException;\r
+\r
+/**\r
+ * \r
+ * @author oleb\r
+ */\r
+public class CollectionConsoleOutputList extends\r
+               AbstractCollectionConsoleOutput {\r
+\r
+\r
+       /**\r
+        * @param list List<?>\r
+        * @throws CollectionOutputException\r
+        * void\r
+        */\r
+       public static void getStringListToConsole(final List<String> list)\r
+                       throws CollectionOutputException {\r
+               if (list == null) {\r
+                       throw new CollectionOutputException("Parameter \"list\" null!");\r
+               }\r
+\r
+               final Object[] array = list.toArray();\r
+\r
+               AbstractCollectionConsoleOutput.getArrayLoop(array);\r
+       }\r
+\r
+\r
+       /**\r
+        * @param list List<String> list\r
+        * @throws CollectionOutputException\r
+        */\r
+       public static void getListToConsole(final List<?> list)\r
+                       throws CollectionOutputException {\r
+               if (list == null) {\r
+                       throw new CollectionOutputException("Parameter \"list\" null!");\r
+               }\r
+\r
+               final Object[] array = list.toArray();\r
+\r
+               AbstractCollectionConsoleOutput.getArrayLoop(array);\r
+       }\r
+}\r

diff --git a/src/main/java/de/laktatnebel/libs/utillib/collection/CollectionConsoleOutputMap.java b/src/main/java/de/laktatnebel/libs/utillib/collection/CollectionConsoleOutputMap.java
new file mode 100644 (file)
index 0000000..ca37fb7
--- /dev/null
+++ b/src/main/java/de/laktatnebel/libs/utillib/collection/CollectionConsoleOutputMap.java
@@ -0,0 +1,47 @@
+package de.laktatnebel.libs.utillib.collection;\r
+\r
+import java.util.Map;\r
+import java.util.Map.Entry;\r
+import java.util.Set;\r
+\r
+import org.slf4j.Logger;\r
+\r
+import de.laktatnebel.libs.utillib.constants.NullVal;\r
+import de.laktatnebel.libs.utillib.exception.CollectionOutputException;\r
+import de.laktatnebel.libs.utillib.logging.StaticLogger;\r
+\r
+/**\r
+ * \r
+* @author oleb\r
+ */\r
+public class CollectionConsoleOutputMap extends AbstractCollectionConsoleOutput {\r
+\r
+       /**\r
+        * @param map Map<?, ?>\r
+        * @param keysOnly boolean\r
+        * @param delim String\r
+        * @throws CollectionOutputException   CollectionOutputException \r
+        */\r
+       public static void getMapToStringToConsole(final Map<?, ?> map, final boolean keysOnly, final String delim) throws CollectionOutputException  {\r
+               if (map == null) {\r
+                       throw new CollectionOutputException("Parameter \"map\" null!");\r
+               }\r
+\r
+               if (keysOnly) {\r
+\r
+                       CollectionConsoleOutputSet.getSetToConsole(map.keySet());\r
+               } else {\r
+                       final Set<?> entrySet = map.entrySet();\r
+\r
+                       final Logger logger = StaticLogger.getLogger(CollectionConsoleOutputMap.class);\r
+\r
+                       for (final Object entryObj : entrySet) {\r
+\r
+                               Entry<?, ?> entry = (Entry<?, ?>) entryObj;\r
+                               final Object key = entry.getKey();\r
+                               final Object value = entry.getValue();\r
+                               StaticLogger.log(logger, (key == null ? NullVal.STRING : key.toString()) + (delim == null ? NullVal.STRING : delim) + (value == null ? NullVal.STRING : value.toString()));\r
+                       }\r
+               }\r
+       }\r
+}\r

diff --git a/src/main/java/de/laktatnebel/libs/utillib/collection/CollectionConsoleOutputSet.java b/src/main/java/de/laktatnebel/libs/utillib/collection/CollectionConsoleOutputSet.java
new file mode 100644 (file)
index 0000000..d500eea
--- /dev/null
+++ b/src/main/java/de/laktatnebel/libs/utillib/collection/CollectionConsoleOutputSet.java
@@ -0,0 +1,41 @@
+package de.laktatnebel.libs.utillib.collection;\r
+\r
+import java.util.Set;\r
+\r
+import de.laktatnebel.libs.utillib.exception.CollectionOutputException;\r
+\r
+/**\r
+ * \r
+* @author oleb\r
+ */\r
+public class CollectionConsoleOutputSet extends AbstractCollectionConsoleOutput {\r
+\r
+       /**\r
+        * \r
+        * @param set Set<String>\r
+        * @throws CollectionOutputException CollectionOutputException \r
+        */\r
+       public static void getStringSetToConsole(final Set<String> set) throws CollectionOutputException {\r
+               if (set == null) {\r
+                       throw new CollectionOutputException("Parameter \"set\" null!");\r
+               }\r
+\r
+               final Object[] array = set.toArray();\r
+\r
+               AbstractCollectionConsoleOutput.getArrayLoop(array);\r
+       }\r
+\r
+       /**\r
+        * \r
+        * @param set Set<?>\r
+        * @throws CollectionOutputException CollectionOutputException \r
+        */\r
+       public static void getSetToConsole(final Set<?> set) throws CollectionOutputException {\r
+               if (set == null) {\r
+                       throw new CollectionOutputException("Parameter \"set\" null!");\r
+               }\r
+               final Object[] array = set.toArray();\r
+\r
+               AbstractCollectionConsoleOutput.getArrayLoop(array);\r
+       }\r
+}\r

diff --git a/src/main/java/de/laktatnebel/libs/utillib/collection/CollectionOutputList.java b/src/main/java/de/laktatnebel/libs/utillib/collection/CollectionOutputList.java
new file mode 100644 (file)
index 0000000..42d1ef7
--- /dev/null
+++ b/src/main/java/de/laktatnebel/libs/utillib/collection/CollectionOutputList.java
@@ -0,0 +1,86 @@
+package de.laktatnebel.libs.utillib.collection;\r
+\r
+import java.util.Iterator;\r
+import java.util.List;\r
+\r
+import de.laktatnebel.libs.utillib.exception.CollectionOutputException;\r
+\r
+/**\r
+ * \r
+* @author oleb\r
+ */\r
+public class CollectionOutputList {\r
+\r
+    /**\r
+     * \r
+* @param list List<String>\r
+     * @return StringBuffer\r
+     * @throws CollectionOutputException   CollectionOutputException \r
+     */\r
+    public static StringBuffer getStringListToString(List<String> list) throws CollectionOutputException  {\r
+        if (list == null) {\r
+            throw new CollectionOutputException("Parameter \"list\" null!");\r
+        }\r
+\r
+        StringBuffer sb = new StringBuffer();\r
+\r
+        for (String string : list) {\r
+            sb.append(string);\r
+            sb.append("\n");\r
+        }\r
+\r
+        return sb;\r
+    }\r
+\r
+    /**\r
+     * \r
+* @param list List<?>\r
+     * @return StringBuffer\r
+     * @throws CollectionOutputException   CollectionOutputException \r
+     */\r
+    public static StringBuffer getListToString(List<?> list) throws CollectionOutputException  {\r
+        if (list == null) {\r
+            throw new CollectionOutputException("Parameter \"list\" null!");\r
+        }\r
+\r
+        StringBuffer sb = new StringBuffer();\r
+\r
+        for (Object obj : list) {\r
+            if (obj != null) {\r
+                sb.append(obj.toString());\r
+            }\r
+            sb.append("\n");\r
+        }\r
+\r
+        return sb;\r
+    }\r
+\r
+    /**\r
+     * @param stringList\r
+     * @return\r
+     * String\r
+     */\r
+    public static String getStringListFromList(final List<String> stringList) {\r
+               return getStringListFromList(stringList, " ");\r
+       }\r
+\r
+    /**\r
+     * @param stringList\r
+     * @param seperatorString\r
+     * @return\r
+     * String\r
+     */\r
+    public static String getStringListFromList(final List<String> stringList, String seperatorString) {\r
+               if (stringList == null || stringList.isEmpty()) {\r
+                       return null;\r
+               }\r
+               \r
+               Iterator<String> iterator = stringList.iterator();\r
+               String returnString = "";\r
+               while (iterator.hasNext()) {\r
+                       returnString  += iterator.next() + seperatorString;\r
+               }\r
+               \r
+               return returnString;\r
+       }\r
+}\r

diff --git a/src/main/java/de/laktatnebel/libs/utillib/collection/CollectionOutputMap.java b/src/main/java/de/laktatnebel/libs/utillib/collection/CollectionOutputMap.java
new file mode 100644 (file)
index 0000000..bd1e73b
--- /dev/null
+++ b/src/main/java/de/laktatnebel/libs/utillib/collection/CollectionOutputMap.java
@@ -0,0 +1,51 @@
+\r
+package de.laktatnebel.libs.utillib.collection;\r
+\r
+import java.util.Map;\r
+import java.util.Map.Entry;\r
+import java.util.Set;\r
+\r
+import de.laktatnebel.libs.utillib.constants.NullVal;\r
+import de.laktatnebel.libs.utillib.exception.CollectionOutputException;\r
+\r
+/**\r
+ *\r
+* @author oleb\r
+ */\r
+public class CollectionOutputMap {\r
+\r
+    /**\r
+     * @param map Map<?, ?>\r
+     * @param keysOnly boolean\r
+     * @param delim String\r
+     * @return StringBuffer\r
+     * @throws CollectionOutputException CollectionOutputException \r
+     */\r
+    public static StringBuffer getMapToString(Map<?, ?> map, boolean keysOnly, String delim) throws CollectionOutputException  {\r
+        if (map == null) {\r
+            throw new CollectionOutputException("Parameter \"map\" null!");\r
+        }\r
+\r
+        StringBuffer sb = new StringBuffer();\r
+\r
+        if (keysOnly) {\r
+\r
+            return CollectionOutputSet.getSetToString(map.keySet());\r
+        } else {\r
+            Set<?> entrySet = map.entrySet();\r
+\r
+            for (Object entryObj : entrySet) {\r
+\r
+                Entry<?, ?> entry = (Entry<?, ?>) entryObj;\r
+                               \r
+                sb.append(entry.getKey());\r
+                sb.append(delim == null ? NullVal.STRING : delim);\r
+                sb.append(entry.getValue());\r
+\r
+                sb.append("\n");\r
+            }\r
+        }\r
+\r
+        return sb;\r
+    }\r
+}\r

diff --git a/src/main/java/de/laktatnebel/libs/utillib/collection/CollectionOutputSet.java b/src/main/java/de/laktatnebel/libs/utillib/collection/CollectionOutputSet.java
new file mode 100644 (file)
index 0000000..26afe50
--- /dev/null
+++ b/src/main/java/de/laktatnebel/libs/utillib/collection/CollectionOutputSet.java
@@ -0,0 +1,57 @@
+\r
+package de.laktatnebel.libs.utillib.collection;\r
+\r
+import java.util.Set;\r
+\r
+import de.laktatnebel.libs.utillib.exception.CollectionOutputException;\r
+\r
+/**\r
+ *\r
+* @author oleb\r
+ */\r
+public class CollectionOutputSet {\r
+\r
+    /**\r
+     * \r
+     * @param set Set<String> set\r
+     * @return StringBuffer\r
+     * @throws CollectionOutputException CollectionOutputException \r
+     */\r
+    public static StringBuffer getStringSetToString(Set<String> set) throws CollectionOutputException {\r
+        if (set == null) {\r
+            throw new CollectionOutputException("Parameter \"set\" null!");\r
+        }\r
+\r
+        StringBuffer sb = new StringBuffer();\r
+\r
+        for (String string : set) {\r
+            sb.append(string);\r
+            sb.append("\n");\r
+        }\r
+\r
+        return sb;\r
+    }\r
+\r
+    /**\r
+     * \r
+     * @param set Set<Objet> set\r
+     * @return StringBuffer\r
+     * @throws CollectionOutputException CollectionOutputException \r
+     */\r
+    public static StringBuffer getSetToString(Set<?> set) throws CollectionOutputException {\r
+        if (set == null) {\r
+            throw new CollectionOutputException("Parameter \"set\" null!");\r
+        }\r
+\r
+        StringBuffer sb = new StringBuffer();\r
+\r
+        for (Object obj : set) {\r
+            if (obj != null) {\r
+                sb.append(obj.toString());\r
+            }\r
+            sb.append("\n");\r
+        }\r
+\r
+        return sb;\r
+    }\r
+}\r

diff --git a/src/main/java/de/laktatnebel/libs/utillib/collection/CollectionSort.java b/src/main/java/de/laktatnebel/libs/utillib/collection/CollectionSort.java
new file mode 100755 (executable)
index 0000000..3bdecd9
--- /dev/null
+++ b/src/main/java/de/laktatnebel/libs/utillib/collection/CollectionSort.java
@@ -0,0 +1,50 @@
+package de.laktatnebel.libs.utillib.collection;\r
+\r
+import java.util.Map;\r
+import java.util.Set;\r
+import java.util.TreeMap;\r
+import java.util.TreeSet;\r
+\r
+import de.laktatnebel.libs.utillib.exception.CollectionOutputException;\r
+\r
+/**\r
+ * @author oleb\r
+ *\r
+ */\r
+public class CollectionSort {\r
+\r
+       /**\r
+        * @param <V>\r
+        * @param <K>\r
+        * @param map\r
+        * @return\r
+        * @throws CollectionOutputException\r
+        */\r
+       public static <V, K> Map<K, V> mapSort(Map<K, V> map) throws CollectionOutputException {\r
+               \r
+               if (map.containsKey(null)) {\r
+                       throw new CollectionOutputException("Ungleiche Typen in KeySet von Parameter \"map\"!");\r
+               }\r
+\r
+               Map<K, V> sortedMap = new TreeMap<K, V>(map);\r
+\r
+               return sortedMap;\r
+       }\r
+\r
+\r
+       /**\r
+        * @param set\r
+        * @return\r
+        * @throws CollectionOutputException\r
+        */\r
+       public static Set<?> setSort(Set<?> set) throws CollectionOutputException {\r
+               \r
+               if (set.contains(null)) {\r
+                       throw new CollectionOutputException("Ungleiche Typen im Set von Parameter \"set\"!");\r
+               }\r
+               \r
+               Set<Object> sortedSet = new TreeSet<Object>(set);\r
+               \r
+               return sortedSet;\r
+       }\r
+}\r

diff --git a/src/main/java/de/laktatnebel/libs/utillib/collection/ListComp.java b/src/main/java/de/laktatnebel/libs/utillib/collection/ListComp.java
new file mode 100644 (file)
index 0000000..55184fc
--- /dev/null
+++ b/src/main/java/de/laktatnebel/libs/utillib/collection/ListComp.java
@@ -0,0 +1,169 @@
+package de.laktatnebel.libs.utillib.collection;\r
+\r
+import java.io.BufferedReader;\r
+import java.io.FileReader;\r
+import java.io.FileWriter;\r
+import java.io.IOException;\r
+import java.io.PrintWriter;\r
+import java.util.ArrayList;\r
+import java.util.List;\r
+\r
+import de.laktatnebel.libs.utillib.exception.AbstractUtilLibException;\r
+import de.laktatnebel.libs.utillib.exception.ListCompException;\r
+import de.laktatnebel.libs.utillib.logging.StaticLogger;\r
+\r
+/**\r
+ * @author oleb\r
+ *\r
+ */\r
+public class ListComp {\r
+\r
+       /**\r
+        * @author oleb\r
+        *\r
+        */\r
+       enum TypeOfSet {\r
+               IN_FIRST_ONLY, IN_LAST_ONLY, IN_BOTH\r
+       }\r
+\r
+       /**\r
+        * \r
+        * @param args String[]\r
+        * @throws Exception\r
+        */\r
+       public static void main(String[] args) throws Exception {\r
+\r
+               StaticLogger.getLogger(ListComp.class).info("START");\r
+\r
+               String fileOne = args[0];\r
+               String fileTwo = args[1];\r
+               String fileBoth = args[0]+args[1];\r
+\r
+               if (fileOne == null || fileTwo == null) {\r
+                       throw new ListCompException("Es fehlen Eingebaparameter!");\r
+               }\r
+\r
+               StaticLogger.getLogger(ListComp.class).info("Liste 1:\t" + fileOne);\r
+               StaticLogger.getLogger(ListComp.class).info("Liste 2:\t" + fileTwo);\r
+\r
+               ArrayList<String> listOne = readFile(fileOne);\r
+               ArrayList<String> listTwo = readFile(fileTwo);\r
+\r
+               StringBuffer onlyInListOne = getStringBufferFromCompare(listOne,\r
+                               listTwo, TypeOfSet.IN_FIRST_ONLY);\r
+               \r
+               StringBuffer onlyInListTwo = getStringBufferFromCompare(listOne,\r
+                               listTwo, TypeOfSet.IN_LAST_ONLY);\r
+               \r
+               StringBuffer inBothLists = getStringBufferFromCompare(listOne,\r
+                               listTwo, TypeOfSet.IN_BOTH);\r
+               \r
+\r
+               writeFile(onlyInListOne, fileOne);\r
+               writeFile(onlyInListTwo, fileTwo);\r
+               writeFile(inBothLists, fileBoth);\r
+\r
+       }\r
+\r
+       /**\r
+        * @param listOne ArrayList<String>\r
+        * @param listTwo ArrayList<String>\r
+        * @param typeOfSet typeOfSet\r
+        * @return StringBuffer\r
+        * @throws AbstractUtilLibException  AbstractUtilLibException\r
+        */\r
+       @SuppressWarnings("unchecked")\r
+       private static StringBuffer getStringBufferFromCompare(\r
+                       ArrayList<String> listOne, ArrayList<String> listTwo, TypeOfSet typeOfSet)\r
+                       throws AbstractUtilLibException {\r
+               List<Object> onlyInListOne = new ArrayList<Object>();\r
+               onlyInListOne = (List<Object>) compare(listOne, listTwo, typeOfSet);\r
+               StringBuffer listToString = CollectionOutputList.getListToString(onlyInListOne);\r
+               return listToString;\r
+       }\r
+\r
+       /**\r
+        * @param sb StringBuffer\r
+        * @param fileName String\r
+        * @throws ListCompException\r
+        */\r
+       private static void writeFile(StringBuffer sb, String fileName)\r
+                       throws ListCompException {\r
+\r
+               PrintWriter printWriter = null;\r
+               String deltaFileName = fileName + ".delta";\r
+               try {\r
+                       printWriter = new PrintWriter(new FileWriter(deltaFileName));\r
+\r
+                       String string = sb.toString();\r
+                       printWriter.print(string.substring(0, string.length() - 1));\r
+               } catch (IOException ioe) {\r
+                       throw new ListCompException("Fehler  beim Schreiben von \""\r
+                                       + deltaFileName + "\"", ioe);\r
+               } finally {\r
+                       if (printWriter != null) {\r
+                               printWriter.close();\r
+                       }\r
+               }\r
+               StaticLogger.getLogger(ListComp.class).info(\r
+                               "File \"" + deltaFileName + "\" geschrieben.");\r
+       }\r
+\r
+       /**\r
+        * \r
+        * @param fileName String\r
+        * @throws ListCompException\r
+        */\r
+       private static ArrayList<String> readFile(String fileName)\r
+                       throws ListCompException {\r
+               ArrayList<String> lines = new ArrayList<String>();\r
+               BufferedReader in = null;\r
+               try {\r
+                       in = new BufferedReader(new FileReader(fileName));\r
+                       String zeile = null;\r
+                       while ((zeile = in.readLine()) != null) {\r
+                               lines.add(zeile.trim());\r
+                       }\r
+               } catch (IOException ioe) {\r
+                       throw new ListCompException("Fehler  beim Einlesen von \""\r
+                                       + fileName + "\"", ioe);\r
+               } finally {\r
+                       try {\r
+                               in.close();\r
+                       } catch (IOException ioe) {\r
+                               throw new ListCompException("Fehler  beim Schliessen von \""\r
+                                               + fileName + "\"", ioe);\r
+                       }\r
+               }\r
+               StaticLogger.getLogger(ListComp.class).info(\r
+                               lines.size() + " gelesene Zeilen in File \"" + fileName + "\"");\r
+               return lines;\r
+       }\r
+\r
+       /**\r
+        * @param first\r
+        * @param last\r
+        * @param typeOfSet\r
+        * @return\r
+        */\r
+       public static List<?> compare(List<?> first, List<?> last, TypeOfSet typeOfSet) {\r
+               \r
+               List<Object> same = new ArrayList<Object>();\r
+\r
+               for (Object element : first) {\r
+                       if (last.contains(element)) {\r
+                               same.add(element);\r
+                       }\r
+               }\r
+               \r
+               if (typeOfSet.equals(ListComp.TypeOfSet.IN_FIRST_ONLY)) {\r
+                       first.removeAll(same);\r
+                       return (List<?>) first;\r
+               } else if (typeOfSet.equals(ListComp.TypeOfSet.IN_LAST_ONLY)) {\r
+                       last.removeAll(same);\r
+                       return (List<?>) last;\r
+               }\r
+               \r
+               return same;\r
+       }\r
+}\r

diff --git a/src/main/java/de/laktatnebel/libs/utillib/constants/NullVal.java b/src/main/java/de/laktatnebel/libs/utillib/constants/NullVal.java
new file mode 100644 (file)
index 0000000..090c172
--- /dev/null
+++ b/src/main/java/de/laktatnebel/libs/utillib/constants/NullVal.java
@@ -0,0 +1,11 @@
+package de.laktatnebel.libs.utillib.constants;\r
+\r
+/**\r
+* @author oleb\r
+ *\r
+ */\r
+public final class NullVal {\r
+\r
+       public static final String STRING = "";\r
+\r
+}\r

diff --git a/src/main/java/de/laktatnebel/libs/utillib/exception/AbstractUtilLibException.java b/src/main/java/de/laktatnebel/libs/utillib/exception/AbstractUtilLibException.java
new file mode 100644 (file)
index 0000000..3ec732c
--- /dev/null
+++ b/src/main/java/de/laktatnebel/libs/utillib/exception/AbstractUtilLibException.java
@@ -0,0 +1,36 @@
+package de.laktatnebel.libs.utillib.exception;
+
+/**
+* @author oleb
+ *
+ */
+public abstract class AbstractUtilLibException extends Exception {
+
+       /**
+        * 
+        */
+       private static final long       serialVersionUID        = -4226434342611199020L;
+
+       /**
+        * @param t Throwable
+        */
+       public AbstractUtilLibException(final Throwable t) {
+               super(t);
+       }
+
+       /**
+        * @param message String
+        * @param t Throwable
+        */
+       public AbstractUtilLibException(final String message, final Throwable t) {
+               super(message, t);
+       }
+
+       /**
+        * @param message String
+        */
+       public AbstractUtilLibException(final String message) {
+               super(message);
+       }
+
+}

diff --git a/src/main/java/de/laktatnebel/libs/utillib/exception/CollectionOutputException.java b/src/main/java/de/laktatnebel/libs/utillib/exception/CollectionOutputException.java
new file mode 100644 (file)
index 0000000..f4042e7
--- /dev/null
+++ b/src/main/java/de/laktatnebel/libs/utillib/exception/CollectionOutputException.java
@@ -0,0 +1,36 @@
+package de.laktatnebel.libs.utillib.exception;\r
+\r
+import de.laktatnebel.libs.utillib.exception.AbstractUtilLibException;\r
+\r
+/**\r
+* @author oleb\r
+ *\r
+ */\r
+public class CollectionOutputException extends AbstractUtilLibException {\r
+\r
+       /** long serialVersionUID field */\r
+       private static final long       serialVersionUID        = 2923278519379485647L;\r
+\r
+       /**\r
+        * @param t Throwable\r
+        */\r
+       public CollectionOutputException(final Throwable t) {\r
+               super(t);\r
+       }\r
+\r
+       /**\r
+        * @param message String\r
+        * @param t Throwable\r
+        */\r
+       public CollectionOutputException(final String message, final Throwable t) {\r
+               super(message, t);\r
+       }\r
+\r
+       /**\r
+        * @param message String\r
+        */\r
+       public CollectionOutputException(final String message) {\r
+               super(message);\r
+       }\r
+\r
+}\r

diff --git a/src/main/java/de/laktatnebel/libs/utillib/exception/ListCompException.java b/src/main/java/de/laktatnebel/libs/utillib/exception/ListCompException.java
new file mode 100644 (file)
index 0000000..5c05bec
--- /dev/null
+++ b/src/main/java/de/laktatnebel/libs/utillib/exception/ListCompException.java
@@ -0,0 +1,28 @@
+package de.laktatnebel.libs.utillib.exception;\r
+\r
+\r
+/**\r
+* @author oleb\r
+ *\r
+ */\r
+public class ListCompException extends Exception {\r
+\r
+    /** long serialVersionUID field */\r
+    private static final long serialVersionUID = -6086330098400406481L;\r
+\r
+    /**\r
+     * @param message String\r
+     */\r
+    public ListCompException(String message) {\r
+        super(message);\r
+    }\r
+\r
+    /**\r
+     * @param message String\r
+     * @param t Throwable\r
+     */\r
+    public ListCompException(String message, Throwable t) {\r
+        super(message, t);\r
+    }\r
+\r
+}\r

diff --git a/src/main/java/de/laktatnebel/libs/utillib/logging/Loglevel.java b/src/main/java/de/laktatnebel/libs/utillib/logging/Loglevel.java
new file mode 100644 (file)
index 0000000..968399a
--- /dev/null
+++ b/src/main/java/de/laktatnebel/libs/utillib/logging/Loglevel.java
@@ -0,0 +1,34 @@
+package de.laktatnebel.libs.utillib.logging;\r
+\r
+/**\r
+* @author oleb\r
+ *\r
+ */\r
+public enum Loglevel {\r
+\r
+       /**\r
+        * \r
+        */\r
+       ALL, /**\r
+        * \r
+        */\r
+       TRACE, /**\r
+        * \r
+        */\r
+       DEBUG, /**\r
+        * \r
+        */\r
+       INFO, /**\r
+        * \r
+        */\r
+       WARN, /**\r
+        * \r
+        */\r
+       ERROR, /**\r
+        * \r
+        */\r
+       FATAL, /**\r
+        * \r
+        */\r
+       OFF;\r
+}\r

diff --git a/src/main/java/de/laktatnebel/libs/utillib/logging/StaticLogger.java b/src/main/java/de/laktatnebel/libs/utillib/logging/StaticLogger.java
new file mode 100644 (file)
index 0000000..4f53301
--- /dev/null
+++ b/src/main/java/de/laktatnebel/libs/utillib/logging/StaticLogger.java
@@ -0,0 +1,46 @@
+package de.laktatnebel.libs.utillib.logging;\r
+\r
+import org.slf4j.Logger;\r
+import org.slf4j.LoggerFactory;\r
+\r
+/**\r
+* @author oleb\r
+ *\r
+ */\r
+public class StaticLogger {\r
+       /** Logger logger field */\r
+       private static Logger logger = LoggerFactory.getLogger(StaticLogger.class);\r
+\r
+       {\r
+               logger = null;\r
+       }\r
+\r
+       /**\r
+        * @param clazz Class\r
+        * @return Logger\r
+        */\r
+       public static Logger getLogger(Class<?> clazz) {\r
+               if (StaticLogger.logger == null) {\r
+                       StaticLogger.logger = LoggerFactory.getLogger(clazz);\r
+               }\r
+               return StaticLogger.logger;\r
+       }\r
+       /**\r
+        *\r
+        * @param logger Logger\r
+        * @param string String\r
+        */\r
+       public static void log(Logger logger, String string) {\r
+               if (logger.isTraceEnabled()) {\r
+                       logger.trace(string);\r
+               } else if (logger.isDebugEnabled()) {\r
+                       logger.debug(string);\r
+               } else if (logger.isInfoEnabled()) {\r
+                       logger.info(string);\r
+               } else if (logger.isWarnEnabled()) {\r
+                       logger.warn(string);\r
+               } else if (logger.isErrorEnabled()) {\r
+                       logger.error(string);\r
+               }\r
+       }\r
+}\r

diff --git a/src/test/java/de/laktatnebel/libs/utillib/collection/AbstractCollectionOutputTest.java b/src/test/java/de/laktatnebel/libs/utillib/collection/AbstractCollectionOutputTest.java
new file mode 100644 (file)
index 0000000..f6e05c6
--- /dev/null
+++ b/src/test/java/de/laktatnebel/libs/utillib/collection/AbstractCollectionOutputTest.java
@@ -0,0 +1,222 @@
+package de.laktatnebel.libs.utillib.collection;\r
+\r
+import java.util.ArrayList;\r
+import java.util.HashMap;\r
+import java.util.HashSet;\r
+import java.util.List;\r
+import java.util.Map;\r
+import java.util.Set;\r
+\r
+import org.junit.AfterClass;\r
+import org.junit.Assert;\r
+import org.junit.BeforeClass;\r
+\r
+import de.laktatnebel.libs.utillib.logging.StaticLogger;\r
+\r
+/**\r
+* @author oleb\r
+ *\r
+ */\r
+public abstract class AbstractCollectionOutputTest {\r
+\r
+       protected static final String                   PARAMETER_MAP_NULL                                      = "Parameter \"map\" null!";\r
+       protected static final String                   PARAMETER_MAP_KEYS_NOT_EQUAL_TYPE       = "Ungleiche Typen in KeySet von Parameter \"map\"!";\r
+       protected static final String                   PARAMETER_MAP_KEYS_NULL                         = "Parameter \"map\" has keys == null!";\r
+       protected static final String                   PARAMETER_SET_NULL                                      = "Parameter \"set\" null!";\r
+       protected static final String                   PARAMETER_SET_KEYS_NOT_EQUAL_TYPE       = "Ungleiche Typen im Set von Parameter \"set\"!";\r
+       protected static final String                   PARAMETER_LIST_NULL                                     = "Parameter \"list\" null!";\r
+       protected static final String                   JAVA_LANG_STRING                                        = "java.lang.String";\r
+       protected static final String                   MUST_FAIL                                                       = "Must fail!";\r
+       protected static final String                   MUST_NOT_FAIL                                           = "Must not fail!";\r
+\r
+       protected static List<Object>                   testObjectList                                          = new ArrayList<Object>();\r
+       protected static Map<Object, Object>    testObjectMap                                           = new HashMap<Object, Object>();\r
+       protected static Map<Object, Object>    testObjectMapFloat                                      = new HashMap<Object, Object>();\r
+       protected static Map<Object, Object>    testObjectMapString                                     = new HashMap<Object, Object>();\r
+       protected static Set<Object>                    testObjectSet                                           = new HashSet<Object>();\r
+       protected static Set<Object>                    testObjectSetFloat                                      = new HashSet<Object>();\r
+       protected static List<String>                   testStringList                                          = new ArrayList<String>();\r
+       protected static Set<String>                    testStringSet                                           = new HashSet<String>();\r
+\r
+       @BeforeClass\r
+       public static void fillData() {\r
+               testStringList.add("A");\r
+               testStringList.add("B");\r
+               testStringList.add("D");\r
+               testStringList.add("H");\r
+               testStringList.add(new String());\r
+               testStringList.add(null);\r
+               testStringList.add("");\r
+\r
+               testObjectList.add(new String("_"));\r
+               testObjectList.add(new Integer(5));\r
+               testObjectList.add(new Boolean(false));\r
+               testObjectList.add(null);\r
+               testObjectList.add(new Object());\r
+\r
+               testStringSet.add("A");\r
+               testStringSet.add("B");\r
+               testStringSet.add("D");\r
+               testStringSet.add("H");\r
+               testStringSet.add(new String());\r
+               testStringSet.add(null);\r
+               testStringSet.add("");\r
+\r
+               testObjectSet.add(new String("_"));\r
+               testObjectSet.add(new Integer(5));\r
+               testObjectSet.add(new Boolean(false));\r
+               testObjectSet.add(null);\r
+               testObjectSet.add(new Object());\r
+\r
+               testObjectSetFloat.add(new Float(-18.3));\r
+               testObjectSetFloat.add(new Float(5));\r
+               testObjectSetFloat.add(new Float(-0.13));\r
+               testObjectSetFloat.add(new Float(5));\r
+               testObjectSetFloat.add(new Float(0));\r
+               testObjectSetFloat.add(new Float(100.4));\r
+\r
+               testObjectMap.put(new Integer(3), null);\r
+               testObjectMap.put(null, null);\r
+               testObjectMap.put(null, "Value");\r
+               testObjectMap.put(new Boolean(false), "false");\r
+               testObjectMap.put("Key", Boolean.TRUE);\r
+               testObjectMap.put(new Object(), "Object");\r
+\r
+               testObjectMapFloat.put(new Float(-18.3f), null);\r
+               testObjectMapFloat.put(new Float(5f), null);\r
+               testObjectMapFloat.put(new Float(-0.13f), "Value");\r
+               testObjectMapFloat.put(new Float(5f), "false");\r
+               testObjectMapFloat.put(new Float(0f), Boolean.TRUE);\r
+               testObjectMapFloat.put(new Float(100.4f), "Object");\r
+\r
+               testObjectMapString.put("Hund", new Integer(3));\r
+               testObjectMapString.put("Elefant", new Boolean(false));\r
+               testObjectMapString.put("Pferd", "Value");\r
+               testObjectMapString.put("Maus", null);\r
+               testObjectMapString.put("Katze", Boolean.TRUE);\r
+               testObjectMapString.put("Fisch", "Object");\r
+       }\r
+\r
+       @AfterClass\r
+       public static void killData() {\r
+               testStringList.clear();\r
+               testObjectList.clear();\r
+               testStringSet.clear();\r
+               testObjectSet.clear();\r
+               testObjectSetFloat.clear();\r
+               testObjectMap.clear();\r
+               testObjectMapFloat.clear();\r
+               testObjectMapString.clear();\r
+       }\r
+\r
+       /**\r
+        *\r
+        * @return  Map<Object, Object>\r
+        */\r
+       protected Map<Object, Object> removeKeysNullFromMap() {\r
+               final Map<Object, Object> testObjectMapSpecial = new HashMap<Object, Object>();\r
+\r
+               final Set<Object> keySet = testObjectMap.keySet();\r
+               for (final Object key : keySet) {\r
+                       if (key != null) {\r
+                               testObjectMapSpecial.put(key, testObjectMap.get(key));\r
+                       }\r
+               }\r
+               return testObjectMapSpecial;\r
+       }\r
+\r
+       /**\r
+        * \r
+        * @return  Set<Object>\r
+        */\r
+       protected Set<Object> removeValuesNullFromSet() {\r
+               final Set<Object> testObjectSetSpecial = new HashSet<Object>();\r
+\r
+               for (final Object key : testObjectSet) {\r
+                       if (key != null) {\r
+                               testObjectSetSpecial.add(key);\r
+                       }\r
+               }\r
+               return testObjectSetSpecial;\r
+       }\r
+\r
+       /**\r
+        * \r
+        * @return List<Object\r
+        */\r
+       protected List<Object> removeValuesNullFromList() {\r
+               final List<Object> testObjectListSpecial = new ArrayList<Object>();\r
+\r
+               for (final Object element : testObjectSet) {\r
+                       if (element != null) {\r
+                               testObjectListSpecial.add(element);\r
+                       }\r
+               }\r
+               return testObjectListSpecial;\r
+       }\r
+\r
+       /**\r
+        * \r
+        * @return Set<String>\r
+        */\r
+       protected Set<String> removeValuesNoStringFromSet() {\r
+               final Set<String> testObjectSetSpecial = new HashSet<String>();\r
+\r
+               for (final Object key : testStringSet) {\r
+                       if ((key != null) && (key.getClass().getCanonicalName() == JAVA_LANG_STRING)) {\r
+                               testObjectSetSpecial.add((String) key);\r
+                       }\r
+               }\r
+               return testObjectSetSpecial;\r
+       }\r
+\r
+       /**\r
+        * \r
+        * @return List<String>\r
+        */\r
+       protected List<String> removeValuesNoStringFromList() {\r
+               final List<String> testObjectListSpecial = new ArrayList<String>();\r
+\r
+               for (final Object element : testObjectMapString.keySet()) {\r
+                       if ((element != null) && (element.getClass().getCanonicalName() == JAVA_LANG_STRING)) {\r
+                               testObjectListSpecial.add((String) element);\r
+                       }\r
+               }\r
+               return testObjectListSpecial;\r
+       }\r
+\r
+       /**\r
+        * @param clazz Class\r
+        * @param expected int\r
+        * @param sb StringBuffer\r
+        */\r
+       protected void assertStringLength(final Class<?> clazz, final int expected, final StringBuffer sb) {\r
+               final int length = sb.length();\r
+               StaticLogger.getLogger(clazz).debug("Length:\t" + length);\r
+               Assert.assertEquals(expected, length);\r
+       }\r
+\r
+       /**\r
+        * @param clazz Class\r
+        * @param expected int\r
+        * @param delta int\r
+        * @param sb StringBuffer\r
+        */\r
+       protected void assertStringLengthDelta(final Class<?> clazz, final int expected, final int delta, final StringBuffer sb) {\r
+               final int length = sb.length();\r
+               StaticLogger.getLogger(clazz).debug("Length:\t" + length);\r
+               Assert.assertTrue((length == expected) || (length == (expected + delta)) || (length == (expected - delta)));\r
+       }\r
+\r
+       /**\r
+        * @param expectedStringArray String[]\r
+        * @param string String\r
+        */\r
+       protected void assertStringContains(final String[] expectedStringArray, final String string) {\r
+\r
+               for (final String element : expectedStringArray) {\r
+                       Assert.assertTrue(string.contains(element));\r
+               }\r
+       }\r
+\r
+}\r

diff --git a/src/test/java/de/laktatnebel/libs/utillib/collection/CollectionConsoleOutputListTest.java b/src/test/java/de/laktatnebel/libs/utillib/collection/CollectionConsoleOutputListTest.java
new file mode 100644 (file)
index 0000000..f9c2b67
--- /dev/null
+++ b/src/test/java/de/laktatnebel/libs/utillib/collection/CollectionConsoleOutputListTest.java
@@ -0,0 +1,69 @@
+package de.laktatnebel.libs.utillib.collection;\r
+\r
+import org.junit.Assert;\r
+import org.junit.Test;\r
+\r
+import de.laktatnebel.libs.utillib.exception.AbstractUtilLibException;\r
+import de.laktatnebel.libs.utillib.logging.StaticLogger;\r
+\r
+/**\r
+* @author oleb\r
+ *\r
+ */\r
+public class CollectionConsoleOutputListTest extends AbstractCollectionOutputTest {\r
+\r
+       private Class<CollectionConsoleOutputListTest> clazz = CollectionConsoleOutputListTest.class;\r
+\r
+       @Test\r
+       public void testGetListToConsoleNull() {\r
+               StaticLogger.getLogger(clazz).debug(new Throwable().getStackTrace()[0].getClassName() + "." + new Throwable().getStackTrace()[0].getMethodName() + "() running.");\r
+\r
+               try {\r
+                       CollectionConsoleOutputList.getListToConsole(null);\r
+\r
+                       Assert.fail(MUST_FAIL);\r
+               } catch (final AbstractUtilLibException aule) {\r
+                       StaticLogger.getLogger(clazz).debug(aule.getMessage());\r
+               }\r
+       }\r
+\r
+       @Test\r
+       public void testGetStringListToConsoleNull() {\r
+               StaticLogger.getLogger(clazz).debug(new Throwable().getStackTrace()[0].getClassName() + "." + new Throwable().getStackTrace()[0].getMethodName() + "() running.");\r
+\r
+               try {\r
+                       CollectionConsoleOutputList.getStringListToConsole(null);\r
+\r
+                       Assert.fail(MUST_FAIL);\r
+               } catch (final AbstractUtilLibException aule) {\r
+                       StaticLogger.getLogger(clazz).debug(aule.getMessage());\r
+               }\r
+       }\r
+\r
+       @Test\r
+       public void testGetListToConsole() {\r
+               StaticLogger.getLogger(clazz).debug(new Throwable().getStackTrace()[0].getClassName() + "." + new Throwable().getStackTrace()[0].getMethodName() + "() running.");\r
+\r
+               try {\r
+                       CollectionConsoleOutputList.getListToConsole(AbstractCollectionOutputTest.testObjectList);\r
+\r
+               } catch (final AbstractUtilLibException aule) {\r
+                       StaticLogger.getLogger(clazz).debug(aule.getMessage());\r
+                       Assert.fail(MUST_NOT_FAIL);\r
+               }\r
+       }\r
+\r
+       @Test\r
+       public void testGetStringListToConsole() {\r
+               StaticLogger.getLogger(clazz).debug(new Throwable().getStackTrace()[0].getClassName() + "." + new Throwable().getStackTrace()[0].getMethodName() + "() running.");\r
+\r
+               try {\r
+                       CollectionConsoleOutputList.getStringListToConsole(AbstractCollectionOutputTest.testStringList);\r
+\r
+               } catch (final AbstractUtilLibException aule) {\r
+                       StaticLogger.getLogger(clazz).debug(aule.getMessage());\r
+                       Assert.fail(MUST_NOT_FAIL);\r
+               }\r
+       }\r
+\r
+}\r

diff --git a/src/test/java/de/laktatnebel/libs/utillib/collection/CollectionConsoleOutputMapTest.java b/src/test/java/de/laktatnebel/libs/utillib/collection/CollectionConsoleOutputMapTest.java
new file mode 100644 (file)
index 0000000..82742eb
--- /dev/null
+++ b/src/test/java/de/laktatnebel/libs/utillib/collection/CollectionConsoleOutputMapTest.java
@@ -0,0 +1,56 @@
+package de.laktatnebel.libs.utillib.collection;\r
+\r
+import org.junit.Assert;\r
+import org.junit.Test;\r
+\r
+import de.laktatnebel.libs.utillib.exception.AbstractUtilLibException;\r
+import de.laktatnebel.libs.utillib.logging.StaticLogger;\r
+\r
+/**\r
+* @author oleb\r
+ *\r
+ */\r
+public class CollectionConsoleOutputMapTest extends AbstractCollectionOutputTest {\r
+\r
+       private Class<CollectionConsoleOutputMapTest> clazz = CollectionConsoleOutputMapTest.class;\r
+\r
+    @Test\r
+    public void testGetMapToConsoleNull() {\r
+        StaticLogger.getLogger(clazz).debug(new Throwable().getStackTrace()[0].getClassName() + "." + new Throwable().getStackTrace()[0].getMethodName() + "() running.");\r
+\r
+        try {\r
+            CollectionConsoleOutputMap.getMapToStringToConsole(null, false, "--");\r
+\r
+            Assert.fail(MUST_FAIL);\r
+        } catch (AbstractUtilLibException aule) {\r
+            StaticLogger.getLogger(clazz).debug(aule.getMessage());\r
+        }\r
+    }\r
+\r
+    @Test\r
+    public void testGetMapToConsole() {\r
+        StaticLogger.getLogger(clazz).debug(new Throwable().getStackTrace()[0].getClassName() + "." + new Throwable().getStackTrace()[0].getMethodName() + "() running.");\r
+\r
+        try {\r
+            CollectionConsoleOutputMap.getMapToStringToConsole(testObjectMap, false, "<-->");\r
+\r
+        } catch (AbstractUtilLibException aule) {\r
+            StaticLogger.getLogger(clazz).debug(aule.getMessage());\r
+            Assert.fail(MUST_NOT_FAIL);\r
+        }\r
+    }\r
+\r
+    @Test\r
+    public void testGetMapToConsoleKeysOnly() {\r
+        StaticLogger.getLogger(clazz).debug(new Throwable().getStackTrace()[0].getClassName() + "." + new Throwable().getStackTrace()[0].getMethodName() + "() running.");\r
+\r
+        try {\r
+            CollectionConsoleOutputMap.getMapToStringToConsole(testObjectMap, true, null);\r
+\r
+        } catch (AbstractUtilLibException aule) {\r
+            StaticLogger.getLogger(clazz).debug(aule.getMessage());\r
+            Assert.fail(MUST_NOT_FAIL);\r
+        }\r
+    }\r
+    \r
+}\r

diff --git a/src/test/java/de/laktatnebel/libs/utillib/collection/CollectionConsoleOutputSetTest.java b/src/test/java/de/laktatnebel/libs/utillib/collection/CollectionConsoleOutputSetTest.java
new file mode 100644 (file)
index 0000000..461a6f0
--- /dev/null
+++ b/src/test/java/de/laktatnebel/libs/utillib/collection/CollectionConsoleOutputSetTest.java
@@ -0,0 +1,69 @@
+package de.laktatnebel.libs.utillib.collection;\r
+\r
+import org.junit.Assert;\r
+import org.junit.Test;\r
+\r
+import de.laktatnebel.libs.utillib.exception.AbstractUtilLibException;\r
+import de.laktatnebel.libs.utillib.logging.StaticLogger;\r
+\r
+/**\r
+* @author oleb\r
+ *\r
+ */\r
+public class CollectionConsoleOutputSetTest extends AbstractCollectionOutputTest {\r
+\r
+       private Class<CollectionConsoleOutputSetTest> clazz = CollectionConsoleOutputSetTest.class;\r
+       \r
+       @Test\r
+       public void testGetSetToConsoleNull() {\r
+               StaticLogger.getLogger(clazz).debug(new Throwable().getStackTrace()[0].getClassName() + "." + new Throwable().getStackTrace()[0].getMethodName() + "() running.");\r
+\r
+               try {\r
+                       CollectionConsoleOutputSet.getSetToConsole(null);\r
+\r
+                       Assert.fail(MUST_FAIL);\r
+               } catch (final AbstractUtilLibException aule) {\r
+                       StaticLogger.getLogger(clazz).debug(aule.getMessage());\r
+               }\r
+       }\r
+\r
+       @Test\r
+       public void testGetStringSetToConsoleNull() {\r
+               StaticLogger.getLogger(clazz).debug(new Throwable().getStackTrace()[0].getClassName() + "." + new Throwable().getStackTrace()[0].getMethodName() + "() running.");\r
+\r
+               try {\r
+                       CollectionConsoleOutputSet.getStringSetToConsole(null);\r
+\r
+                       Assert.fail(MUST_FAIL);\r
+               } catch (final AbstractUtilLibException aule) {\r
+                       StaticLogger.getLogger(clazz).debug(aule.getMessage());\r
+               }\r
+       }\r
+\r
+       @Test\r
+       public void testGetSetToConsole() {\r
+               StaticLogger.getLogger(clazz).debug(new Throwable().getStackTrace()[0].getClassName() + "." + new Throwable().getStackTrace()[0].getMethodName() + "() running.");\r
+\r
+               try {\r
+                       CollectionConsoleOutputSet.getSetToConsole(AbstractCollectionOutputTest.testObjectSet);\r
+\r
+               } catch (final AbstractUtilLibException aule) {\r
+                       StaticLogger.getLogger(clazz).debug(aule.getMessage());\r
+                       Assert.fail(MUST_NOT_FAIL);\r
+               }\r
+       }\r
+\r
+       @Test\r
+       public void testGetStringSetToConsole() {\r
+               StaticLogger.getLogger(clazz).debug(new Throwable().getStackTrace()[0].getClassName() + "." + new Throwable().getStackTrace()[0].getMethodName() + "() running.");\r
+\r
+               try {\r
+                       CollectionConsoleOutputSet.getStringSetToConsole(AbstractCollectionOutputTest.testStringSet);\r
+\r
+               } catch (final AbstractUtilLibException aule) {\r
+                       StaticLogger.getLogger(clazz).debug(aule.getMessage());\r
+                       Assert.fail(MUST_NOT_FAIL);\r
+               }\r
+       }\r
+\r
+}\r

diff --git a/src/test/java/de/laktatnebel/libs/utillib/collection/CollectionOutputListTest.java b/src/test/java/de/laktatnebel/libs/utillib/collection/CollectionOutputListTest.java
new file mode 100644 (file)
index 0000000..216dce6
--- /dev/null
+++ b/src/test/java/de/laktatnebel/libs/utillib/collection/CollectionOutputListTest.java
@@ -0,0 +1,89 @@
+package de.laktatnebel.libs.utillib.collection;\r
+\r
+import org.junit.Assert;\r
+import org.junit.Test;\r
+\r
+import de.laktatnebel.libs.utillib.exception.AbstractUtilLibException;\r
+import de.laktatnebel.libs.utillib.logging.StaticLogger;\r
+\r
+/**\r
+* @author oleb\r
+ *\r
+ */\r
+public class CollectionOutputListTest extends AbstractCollectionOutputTest {\r
+\r
+       private Class<CollectionOutputListTest> clazz = CollectionOutputListTest.class;\r
+       \r
+       @Test\r
+       public void testGetStringListToString() {\r
+               StaticLogger.getLogger(clazz).debug(new Throwable().getStackTrace()[0].getClassName() + "." + new Throwable().getStackTrace()[0].getMethodName() + "() running.");\r
+\r
+               int expectedStringLength = 15;\r
+\r
+               StringBuffer sb = new StringBuffer();\r
+               \r
+               try {\r
+                       sb = CollectionOutputList.getStringListToString(AbstractCollectionOutputTest.testStringList);\r
+               } catch (final AbstractUtilLibException aule) {\r
+                       StaticLogger.getLogger(clazz).debug(aule.getMessage());\r
+                       Assert.fail();\r
+               }\r
+\r
+               assertStringLength(clazz, expectedStringLength, sb);\r
+\r
+               StaticLogger.getLogger(clazz).debug("toString:\t" + sb.toString());\r
+               Assert.assertEquals("A\nB\nD\nH\n\nnull\n\n", sb.toString());\r
+       }\r
+\r
+       @Test\r
+       public void testGetListToString() {\r
+               StaticLogger.getLogger(clazz).debug(new Throwable().getStackTrace()[0].getClassName() + "." + new Throwable().getStackTrace()[0].getMethodName() + "() running.");\r
+\r
+               int expectedStringLength = 36;\r
+               int expectedStringLengthDelta = 1;\r
+               String expectedStringArray [] = {"5", "false", "_", "java.lang.Object@"};\r
+\r
+               StringBuffer sb = new StringBuffer();\r
+               \r
+               try {\r
+                       sb = CollectionOutputList.getListToString(AbstractCollectionOutputTest.testObjectList);\r
+               } catch (final AbstractUtilLibException aule) {\r
+                       StaticLogger.getLogger(clazz).debug(aule.getMessage());\r
+                       Assert.fail();\r
+               }\r
+\r
+               assertStringLengthDelta(clazz, expectedStringLength, expectedStringLengthDelta, sb);\r
+\r
+               final String string = sb.toString();\r
+               StaticLogger.getLogger(clazz).debug("toString:\t" + string);\r
+               assertStringContains(expectedStringArray, string);\r
+       }\r
+\r
+       @Test\r
+       public void testGetStringListToStringNull() {\r
+               StaticLogger.getLogger(clazz).debug(new Throwable().getStackTrace()[0].getClassName() + "." + new Throwable().getStackTrace()[0].getMethodName() + "() running.");\r
+\r
+               try {\r
+                       CollectionOutputList.getStringListToString(null);\r
+                       Assert.fail(MUST_FAIL);\r
+               } catch (final AbstractUtilLibException aule) {\r
+                       final String message = aule.getMessage();\r
+                       StaticLogger.getLogger(clazz).debug(message);\r
+                       Assert.assertEquals(PARAMETER_LIST_NULL, message);\r
+               }\r
+       }\r
+\r
+       @Test\r
+       public void testGetListToStringNull() {\r
+               StaticLogger.getLogger(clazz).debug(new Throwable().getStackTrace()[0].getClassName() + "." + new Throwable().getStackTrace()[0].getMethodName() + "() running.");\r
+\r
+               try {\r
+                       CollectionOutputList.getListToString(null);\r
+                       Assert.fail(MUST_FAIL);\r
+               } catch (final AbstractUtilLibException aule) {\r
+                       final String message = aule.getMessage();\r
+                       StaticLogger.getLogger(clazz).debug(message);\r
+                       Assert.assertEquals(PARAMETER_LIST_NULL, message);\r
+               }\r
+       }\r
+}\r

diff --git a/src/test/java/de/laktatnebel/libs/utillib/collection/CollectionOutputMapTest.java b/src/test/java/de/laktatnebel/libs/utillib/collection/CollectionOutputMapTest.java
new file mode 100644 (file)
index 0000000..42a2680
--- /dev/null
+++ b/src/test/java/de/laktatnebel/libs/utillib/collection/CollectionOutputMapTest.java
@@ -0,0 +1,105 @@
+package de.laktatnebel.libs.utillib.collection;\r
+\r
+import org.junit.Assert;\r
+import org.junit.Test;\r
+\r
+import de.laktatnebel.libs.utillib.exception.AbstractUtilLibException;\r
+import de.laktatnebel.libs.utillib.logging.StaticLogger;\r
+\r
+/**\r
+* @author oleb\r
+ *\r
+ */\r
+public class CollectionOutputMapTest extends AbstractCollectionOutputTest {\r
+\r
+       private Class<CollectionOutputMapTest> clazz = CollectionOutputMapTest.class;\r
+\r
+       @Test\r
+       public void testGetMapToStringKeysOnly() {\r
+               StaticLogger.getLogger(CollectionConsoleOutputSetTest.class).debug(new Throwable().getStackTrace()[0].getClassName() + "." + new Throwable().getStackTrace()[0].getMethodName() + "() running.");\r
+\r
+               int expectedStringLength = 38;\r
+               int expectedStringLengthDelta = 1;\r
+               String expectedStringArray [] = {"3", "false", "Key", "java.lang.Object@"};\r
+\r
+               StringBuffer sb = new StringBuffer();\r
+               \r
+               try {\r
+                       sb = CollectionOutputMap.getMapToString(AbstractCollectionOutputTest.testObjectMap, true, "-");\r
+               } catch (final AbstractUtilLibException aule) {\r
+                       StaticLogger.getLogger(clazz).debug(aule.getMessage());\r
+                       Assert.fail();\r
+               }\r
+\r
+               assertStringLengthDelta(clazz, expectedStringLength, expectedStringLengthDelta, sb);\r
+\r
+               final String string = sb.toString();\r
+               StaticLogger.getLogger(clazz).debug("toString:\t" + string);\r
+\r
+               assertStringContains(expectedStringArray, string);\r
+       }\r
+\r
+       @Test\r
+       public void testGetMapToString() {\r
+               StaticLogger.getLogger(CollectionConsoleOutputSetTest.class).debug(new Throwable().getStackTrace()[0].getClassName() + "." + new Throwable().getStackTrace()[0].getMethodName() + "() running.");\r
+\r
+               int expectedStringLength = 71;\r
+               int expectedStringLengthDelta = 1;\r
+               String expectedStringArray [] = {"3", "false", "Key", "java.lang.Object@"};\r
+\r
+               StringBuffer sb = new StringBuffer();\r
+               \r
+               try {\r
+                       sb = CollectionOutputMap.getMapToString(AbstractCollectionOutputTest.testObjectMap, false, "-");\r
+               } catch (final AbstractUtilLibException aule) {\r
+                       StaticLogger.getLogger(clazz).debug(aule.getMessage());\r
+                       Assert.fail();\r
+               }\r
+\r
+               assertStringLengthDelta(clazz, expectedStringLength, expectedStringLengthDelta, sb);\r
+\r
+               final String string = sb.toString();\r
+               StaticLogger.getLogger(clazz).debug("toString:\t" + string);\r
+\r
+               assertStringContains(expectedStringArray, string);\r
+       }\r
+\r
+       @Test\r
+       public void testGetMapToStringDelimNull() {\r
+               StaticLogger.getLogger(CollectionConsoleOutputSetTest.class).debug(new Throwable().getStackTrace()[0].getClassName() + "." + new Throwable().getStackTrace()[0].getMethodName() + "() running.");\r
+\r
+               int expectedStringLength = 66;\r
+               int expectedStringLengthDelta = 1;\r
+               String expectedStringArray [] = {"3", "false", "Key", "java.lang.Object@"};\r
+\r
+               StringBuffer sb = new StringBuffer();\r
+\r
+               try {\r
+                       sb = CollectionOutputMap.getMapToString(AbstractCollectionOutputTest.testObjectMap, false, null);\r
+               } catch (final AbstractUtilLibException aule) {\r
+                       StaticLogger.getLogger(clazz).debug(aule.getMessage());\r
+                       Assert.fail();\r
+               }\r
+\r
+               assertStringLengthDelta(clazz, expectedStringLength, expectedStringLengthDelta, sb);\r
+\r
+               final String string = sb.toString();\r
+               StaticLogger.getLogger(clazz).debug("toString:\t" + string);\r
+               \r
+               assertStringContains(expectedStringArray, string);\r
+       }\r
+\r
+       @Test\r
+       public void testGetMapToStringNull() {\r
+               StaticLogger.getLogger(CollectionConsoleOutputSetTest.class).debug(new Throwable().getStackTrace()[0].getClassName() + "." + new Throwable().getStackTrace()[0].getMethodName() + "() running.");\r
+\r
+               try {\r
+                       CollectionOutputMap.getMapToString(null, true, "-");\r
+                       Assert.fail();\r
+               } catch (final AbstractUtilLibException aule) {\r
+                       final String message = aule.getMessage();\r
+                       StaticLogger.getLogger(clazz).debug(message);\r
+                       Assert.assertEquals(PARAMETER_MAP_NULL, message);\r
+               }\r
+       }\r
+}\r

diff --git a/src/test/java/de/laktatnebel/libs/utillib/collection/CollectionOutputSetTest.java b/src/test/java/de/laktatnebel/libs/utillib/collection/CollectionOutputSetTest.java
new file mode 100644 (file)
index 0000000..c465504
--- /dev/null
+++ b/src/test/java/de/laktatnebel/libs/utillib/collection/CollectionOutputSetTest.java
@@ -0,0 +1,93 @@
+package de.laktatnebel.libs.utillib.collection;\r
+\r
+import org.junit.Assert;\r
+import org.junit.Test;\r
+\r
+import de.laktatnebel.libs.utillib.exception.AbstractUtilLibException;\r
+import de.laktatnebel.libs.utillib.logging.StaticLogger;\r
+\r
+/**\r
+* @author oleb\r
+ *\r
+ */\r
+public class CollectionOutputSetTest extends AbstractCollectionOutputTest {\r
+\r
+       private Class<CollectionOutputSetTest> clazz = CollectionOutputSetTest.class;\r
+\r
+       @Test\r
+       public void testGetStringSetToString() {\r
+               StaticLogger.getLogger(clazz).debug(new Throwable().getStackTrace()[0].getClassName() + "." + new Throwable().getStackTrace()[0].getMethodName() + "() running.");\r
+\r
+               int expectedStringLength = 14;\r
+               String expectedStringArray [] = {"A", "B", "D", "H", "null"};\r
+\r
+               StringBuffer sb = new StringBuffer();\r
+               \r
+               try {\r
+                       sb = CollectionOutputSet.getStringSetToString(AbstractCollectionOutputTest.testStringSet);\r
+               } catch (final AbstractUtilLibException aule) {\r
+                       StaticLogger.getLogger(clazz).debug(aule.getMessage());\r
+                       Assert.fail();\r
+               }\r
+\r
+               assertStringLength(clazz, expectedStringLength, sb);\r
+\r
+               final String string = sb.toString();\r
+               StaticLogger.getLogger(clazz).debug("toString:\t" + string);\r
+               \r
+               assertStringContains(expectedStringArray, string);\r
+       }\r
+\r
+       @Test\r
+       public void testGetSetToString() {\r
+               StaticLogger.getLogger(clazz).debug(new Throwable().getStackTrace()[0].getClassName() + "." + new Throwable().getStackTrace()[0].getMethodName() + "() running.");\r
+\r
+               int expectedStringLength = 36;\r
+               int expectedStringLengthDelta = 1;\r
+               String expectedStringArray [] = {"5", "false", "_", "java.lang.Object@"};\r
+\r
+               StringBuffer sb = new StringBuffer();\r
+\r
+               try {\r
+                       sb = CollectionOutputSet.getSetToString(AbstractCollectionOutputTest.testObjectSet);\r
+               } catch (final AbstractUtilLibException aule) {\r
+                       StaticLogger.getLogger(clazz).debug(aule.getMessage());\r
+                       Assert.fail();\r
+               }\r
+\r
+               assertStringLengthDelta(clazz, expectedStringLength, expectedStringLengthDelta, sb);\r
+\r
+               final String string = sb.toString();\r
+               StaticLogger.getLogger(clazz).debug("toString:\t" + string);\r
+               \r
+               assertStringContains(expectedStringArray, string);\r
+       }\r
+\r
+       @Test\r
+       public void testGetStringSetToStringNull() {\r
+               StaticLogger.getLogger(clazz).debug(new Throwable().getStackTrace()[0].getClassName() + "." + new Throwable().getStackTrace()[0].getMethodName() + "() running.");\r
+\r
+               try {\r
+                       CollectionOutputSet.getStringSetToString(null);\r
+                       Assert.fail(MUST_FAIL);\r
+               } catch (final AbstractUtilLibException aule) {\r
+                       final String message = aule.getMessage();\r
+                       StaticLogger.getLogger(clazz).debug(message);\r
+                       Assert.assertEquals(PARAMETER_SET_NULL, message);\r
+               }\r
+       }\r
+\r
+       @Test\r
+       public void testGetSetToStringNull() {\r
+               StaticLogger.getLogger(clazz).debug(new Throwable().getStackTrace()[0].getClassName() + "." + new Throwable().getStackTrace()[0].getMethodName() + "() running.");\r
+\r
+               try {\r
+                       CollectionOutputSet.getSetToString(null);\r
+                       Assert.fail(MUST_FAIL);\r
+               } catch (final AbstractUtilLibException aule) {\r
+                       final String message = aule.getMessage();\r
+                       StaticLogger.getLogger(clazz).debug(message);\r
+                       Assert.assertEquals(PARAMETER_SET_NULL, message);\r
+               }\r
+       }\r
+}\r

diff --git a/src/test/java/de/laktatnebel/libs/utillib/collection/CollectionSortTest.java b/src/test/java/de/laktatnebel/libs/utillib/collection/CollectionSortTest.java
new file mode 100755 (executable)
index 0000000..7c8a171
--- /dev/null
+++ b/src/test/java/de/laktatnebel/libs/utillib/collection/CollectionSortTest.java
@@ -0,0 +1,110 @@
+package de.laktatnebel.libs.utillib.collection;\r
+\r
+import java.util.Map;\r
+import java.util.Set;\r
+\r
+import org.junit.Assert;\r
+import org.junit.Test;\r
+\r
+import de.laktatnebel.libs.utillib.exception.CollectionOutputException;\r
+import de.laktatnebel.libs.utillib.logging.StaticLogger;\r
+\r
+public class CollectionSortTest extends AbstractCollectionOutputTest {\r
+\r
+       private Class<CollectionSortTest> clazz = CollectionSortTest.class;\r
+\r
+       /**\r
+        * \r
+        */\r
+       @Test\r
+       public void testSetSort() {\r
+               StaticLogger.getLogger(clazz).debug(\r
+                               new Throwable().getStackTrace()[0].getClassName() + "."\r
+                                               + new Throwable().getStackTrace()[0].getMethodName()\r
+                                               + "() running.");\r
+\r
+               StringBuffer setToString = null;\r
+               try {\r
+                       Set<?> setSort = CollectionSort\r
+                                       .setSort(AbstractCollectionOutputTest.testObjectSetFloat);\r
+\r
+                       setToString = CollectionOutputSet.getSetToString(setSort);\r
+               } catch (CollectionOutputException coe) {\r
+                       StaticLogger.getLogger(clazz).debug(coe.getMessage());\r
+                       Assert.fail();\r
+               }\r
+\r
+               StaticLogger.getLogger(clazz).debug(setToString.toString());\r
+               Assert.assertEquals("-18.3\n-0.13\n0.0\n5.0\n100.4\n",\r
+                               setToString.toString());\r
+       }\r
+\r
+       /**\r
+        * \r
+        */\r
+       @Test\r
+       public void testSetSortWithNullKey() {\r
+               StaticLogger.getLogger(clazz).debug(\r
+                               new Throwable().getStackTrace()[0].getClassName() + "."\r
+                                               + new Throwable().getStackTrace()[0].getMethodName()\r
+                                               + "() running.");\r
+\r
+               try {\r
+                       CollectionSort.setSort(AbstractCollectionOutputTest.testObjectSet);\r
+\r
+                       Assert.fail(MUST_FAIL);\r
+               } catch (CollectionOutputException coe) {\r
+                       final String message = coe.getMessage();\r
+                       StaticLogger.getLogger(clazz).debug(message);\r
+                       Assert.assertEquals(PARAMETER_SET_KEYS_NOT_EQUAL_TYPE, message);\r
+               }\r
+       }\r
+\r
+       /**\r
+        * \r
+        */\r
+       @Test\r
+       public void testMapSort() {\r
+               StaticLogger.getLogger(clazz).debug(\r
+                               new Throwable().getStackTrace()[0].getClassName() + "."\r
+                                               + new Throwable().getStackTrace()[0].getMethodName()\r
+                                               + "() running.");\r
+\r
+               StringBuffer mapToString = null;\r
+               try {\r
+                       Map<Object, Object> mapSort = CollectionSort\r
+                                       .mapSort(AbstractCollectionOutputTest.testObjectMapFloat);\r
+\r
+                       mapToString = CollectionOutputMap.getMapToString(mapSort, true,\r
+                                       null);\r
+               } catch (CollectionOutputException coe) {\r
+                       StaticLogger.getLogger(clazz).debug(coe.getMessage());\r
+                       Assert.fail();\r
+               }\r
+\r
+               StaticLogger.getLogger(clazz).debug(mapToString.toString());\r
+               Assert.assertEquals("-18.3\n-0.13\n0.0\n5.0\n100.4\n",\r
+                               mapToString.toString());\r
+       }\r
+\r
+       /**\r
+        * \r
+        */\r
+       @Test\r
+       public void testMapSortWithNullKey() {\r
+               StaticLogger.getLogger(clazz).debug(\r
+                               new Throwable().getStackTrace()[0].getClassName() + "."\r
+                                               + new Throwable().getStackTrace()[0].getMethodName()\r
+                                               + "() running.");\r
+\r
+               try {\r
+                       CollectionSort.mapSort(AbstractCollectionOutputTest.testObjectMap);\r
+\r
+                       Assert.fail(MUST_FAIL);\r
+               } catch (CollectionOutputException coe) {\r
+                       final String message = coe.getMessage();\r
+                       StaticLogger.getLogger(clazz).debug(message);\r
+                       Assert.assertEquals(PARAMETER_MAP_KEYS_NOT_EQUAL_TYPE, message);\r
+               }\r
+       }\r
+}\r

diff --git a/src/test/java/de/laktatnebel/libs/utillib/collection/ListCompTest.java b/src/test/java/de/laktatnebel/libs/utillib/collection/ListCompTest.java
new file mode 100755 (executable)
index 0000000..21e8dc6
--- /dev/null
+++ b/src/test/java/de/laktatnebel/libs/utillib/collection/ListCompTest.java
@@ -0,0 +1,214 @@
+package de.laktatnebel.libs.utillib.collection;\r
+\r
+import java.util.ArrayList;\r
+import java.util.List;\r
+\r
+import org.junit.After;\r
+import org.junit.Assert;\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+\r
+/**\r
+* @author oleb\r
+ *\r
+ */\r
+public class ListCompTest {\r
+       \r
+       private static List<Integer> primzahlen = new ArrayList<Integer>();\r
+       private static List<Integer> fibonacci = new ArrayList<Integer>();\r
+       private static List<Integer> gleich = new ArrayList<Integer>();\r
+       private static List<Integer> negativ = new ArrayList<Integer>();\r
+\r
+       List<?> result = null;\r
+       Object[] resultExpected;\r
+       int expected;\r
+       \r
+    @Before\r
+    public void fillData() {\r
+       primzahlen.add(new Integer(19));\r
+       primzahlen.add(new Integer(2));\r
+       primzahlen.add(new Integer(5));\r
+       primzahlen.add(new Integer(11));\r
+       primzahlen.add(new Integer(23));\r
+       primzahlen.add(new Integer(13));\r
+       primzahlen.add(new Integer(3));\r
+       primzahlen.add(new Integer(7));\r
+       primzahlen.add(new Integer(17));\r
+\r
+       fibonacci.add(new Integer(1));\r
+       fibonacci.add(new Integer(21));\r
+       fibonacci.add(new Integer(2));\r
+       fibonacci.add(new Integer(55));\r
+       fibonacci.add(new Integer(5));\r
+       fibonacci.add(new Integer(1));\r
+       fibonacci.add(new Integer(8));\r
+       fibonacci.add(new Integer(34));\r
+       fibonacci.add(new Integer(13));\r
+       fibonacci.add(new Integer(3));\r
+       \r
+       gleich.add(new Integer(2));\r
+       gleich.add(new Integer(3));\r
+       gleich.add(new Integer(5));\r
+\r
+       negativ.add(new Integer(-1));\r
+       negativ.add(new Integer(-18));\r
+       negativ.add(new Integer(-12));\r
+    }\r
+\r
+    @After\r
+    public void killData() {\r
+       primzahlen.clear();\r
+       fibonacci.clear();\r
+       gleich.clear();\r
+       negativ.clear();\r
+    }\r
+    \r
+       @Test\r
+       public void testTeilmengeFirst1() {\r
+               \r
+               result = ListComp.compare(gleich, fibonacci, ListComp.TypeOfSet.IN_FIRST_ONLY);\r
+               expected = 0;\r
+               Assert.assertEquals("Erwartet: " + expected, expected, result.size());\r
+               \r
+               resultExpected = new Integer[]{};\r
+               assertArrayElements(resultExpected, result);\r
+       }\r
+       \r
+       @Test\r
+       public void testTeilmengeFirst2() {\r
+               \r
+               result = ListComp.compare(primzahlen, gleich, ListComp.TypeOfSet.IN_FIRST_ONLY);\r
+               expected = 6;\r
+               Assert.assertEquals("Erwartet: " + expected, expected, result.size());\r
+               \r
+               resultExpected = new Integer[]{7,11,17,19,23};\r
+               assertArrayElements(resultExpected, result);\r
+       }\r
+\r
+       @Test\r
+       public void testTeilmengeLast1() {\r
+               \r
+               result = ListComp.compare(gleich, fibonacci, ListComp.TypeOfSet.IN_LAST_ONLY);\r
+               expected = 7;\r
+               Assert.assertEquals("Erwartet: " + expected, expected, result.size());\r
+\r
+               resultExpected = new Integer[]{1,1,8,13,21,34,55};\r
+               assertArrayElements(resultExpected, result);\r
+       }\r
+       \r
+       @Test\r
+       public void testTeilmengeLast2() {\r
+               \r
+               result = ListComp.compare(primzahlen, gleich, ListComp.TypeOfSet.IN_LAST_ONLY);\r
+               expected = 0;\r
+               Assert.assertEquals("Erwartet: " + expected, expected, result.size());\r
+               \r
+               resultExpected = new Integer[]{};\r
+               assertArrayElements(resultExpected, result);\r
+       }\r
+       \r
+       @Test\r
+       public void testTeilmenge() {\r
+               \r
+               result = ListComp.compare(primzahlen, gleich, ListComp.TypeOfSet.IN_BOTH);\r
+               expected = 3;\r
+               Assert.assertEquals("Erwartet: " + expected, expected, result.size());\r
+               \r
+               resultExpected = new Integer[]{2,3,5};\r
+               assertArrayElements(resultExpected, result);\r
+       }\r
+       \r
+       @Test\r
+       public void testTeilmengeGleich1() {\r
+               \r
+               result = ListComp.compare(gleich, gleich, ListComp.TypeOfSet.IN_BOTH);\r
+               expected = 3;\r
+               Assert.assertEquals("Erwartet: " + expected, expected, result.size());\r
+\r
+               resultExpected = new Integer[]{2,3,5};\r
+               assertArrayElements(resultExpected, result);\r
+       }\r
+       \r
+       @Test\r
+       public void testTeilmengeGleich2() {\r
+               \r
+               result = ListComp.compare(gleich, gleich, ListComp.TypeOfSet.IN_LAST_ONLY);\r
+               expected = 0;\r
+               Assert.assertEquals("Erwartet: " + expected, expected, result.size());\r
+               \r
+               resultExpected = new Integer[]{};\r
+               assertArrayElements(resultExpected, result);\r
+       }\r
+       \r
+       @Test\r
+       public void testSchnittmengeFirst() {\r
+               \r
+               result = ListComp.compare(primzahlen, fibonacci, ListComp.TypeOfSet.IN_FIRST_ONLY);\r
+               expected = 5;\r
+               Assert.assertEquals("Erwartet: " + expected, expected, result.size());\r
+               \r
+               resultExpected = new Integer[]{7,11,17,19,23};\r
+               assertArrayElements(resultExpected, result);\r
+       }\r
+       \r
+       @Test\r
+       public void testSchnittmengeLast() {\r
+               \r
+               result = ListComp.compare(primzahlen, fibonacci, ListComp.TypeOfSet.IN_LAST_ONLY);\r
+               expected = 6;\r
+               Assert.assertEquals("Erwartet: " + expected, expected, result.size());\r
+               \r
+               resultExpected = new Integer[]{1,1,8,21,34,55};\r
+               assertArrayElements(resultExpected, result);\r
+       }\r
+       \r
+       @Test\r
+       public void testSchnittmenge() {\r
+               \r
+               result = ListComp.compare(primzahlen, fibonacci, ListComp.TypeOfSet.IN_BOTH);\r
+               expected = 4;\r
+               Assert.assertEquals("Erwartet: " + expected, expected, result.size());\r
+               \r
+               resultExpected = new Integer[]{2,3,5,13};\r
+               assertArrayElements(resultExpected, result);\r
+       }\r
+       \r
+       @Test\r
+       public void testKeineSchnittmengeFirst() {\r
+               \r
+               result = ListComp.compare(primzahlen, negativ, ListComp.TypeOfSet.IN_FIRST_ONLY);\r
+               expected = 9;\r
+               Assert.assertEquals("Erwartet: " + expected, expected, result.size());\r
+               \r
+               resultExpected = new Integer[]{2,3,5,7,11,13,17,19,23};\r
+               assertArrayElements(resultExpected, result);\r
+       }\r
+       \r
+       @Test\r
+       public void testKeineSchnittmengeLast() {\r
+                               \r
+               result = ListComp.compare(primzahlen, negativ, ListComp.TypeOfSet.IN_LAST_ONLY);\r
+               expected = 3;\r
+               Assert.assertEquals("Erwartet: " + expected, expected, result.size());\r
+               \r
+               resultExpected = new Integer[]{-1,-12,-18};\r
+               assertArrayElements(resultExpected, result);\r
+       }\r
+       \r
+       @Test\r
+       public void testKeineSchnittmengeBoth() {\r
+               \r
+               result = ListComp.compare(primzahlen, negativ, ListComp.TypeOfSet.IN_BOTH);\r
+               expected = 0;\r
+               Assert.assertEquals("Erwartet: " + expected, expected, result.size());\r
+               \r
+               resultExpected = new Integer[]{};\r
+               assertArrayElements(resultExpected, result);\r
+       }\r
+\r
+       private void assertArrayElements(Object[] resultExpected, List<?> result) {\r
+               for (Object object : resultExpected) {\r
+                       Assert.assertTrue(object + " sollte enthalten sein", result.contains(object));\r
+               }\r
+       }\r
+}\r

diff --git a/src/test/resources/log4j.xml b/src/test/resources/log4j.xml
new file mode 100644 (file)
index 0000000..f04bbed
--- /dev/null
+++ b/src/test/resources/log4j.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8" ?>\r
+<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">\r
+\r
+<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">\r
+\r
+       <appender name="appender" class="org.apache.log4j.ConsoleAppender">\r
+               <layout class="org.apache.log4j.PatternLayout">\r
+                       <param name="ConversionPattern" value="%d [%t] %p - %m%n" />\r
+               </layout>\r
+       </appender>\r
+\r
+       <root>\r
+               <priority value="trace" />\r
+               <appender-ref ref="appender" />\r
+       </root>\r
+\r
+</log4j:configuration>\r