diff --git a/Klausuren/Sd1/SoSe2015/StringFunctions/pom.xml b/Klausuren/Sd1/SoSe2015/StringFunctions/pom.xml
new file mode 100644
index 0000000000000000000000000000000000000000..77f6ee743ce0824fc5cfc3dfe8059e720944be0c
--- /dev/null
+++ b/Klausuren/Sd1/SoSe2015/StringFunctions/pom.xml
@@ -0,0 +1,50 @@
+<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.hdm-stuttgart.sw1.klausur</groupId>
+	<artifactId>sw1klausur</artifactId>
+	<version>0.9</version>
+	<packaging>jar</packaging>
+
+	<name>sw1klausur</name>
+	<url>http://maven.apache.org</url>
+
+	<properties>
+		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+	</properties>
+	<build>
+		<plugins>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-compiler-plugin</artifactId>
+				<version>3.2</version>
+				<configuration>
+					<source>1.8</source>
+					<target>1.8</target>
+				</configuration>
+			</plugin>
+		</plugins>
+	</build>
+
+	<dependencies>
+		<dependency>
+			<groupId>junit</groupId>
+			<artifactId>junit</artifactId>
+			<version>4.11</version>
+			<scope>test</scope>
+		</dependency>
+		
+		<dependency>
+      <groupId>org.apache.logging.log4j</groupId>
+      <artifactId>log4j-api</artifactId>
+      <version>2.1</version>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.logging.log4j</groupId>
+      <artifactId>log4j-core</artifactId>
+      <version>2.1</version>
+    </dependency>
+    
+	</dependencies>
+</project>
diff --git a/Klausuren/Sd1/SoSe2015/StringFunctions/src/main/java/de/hdm_stuttgart/sw1/klausur/StringTransforms.java b/Klausuren/Sd1/SoSe2015/StringFunctions/src/main/java/de/hdm_stuttgart/sw1/klausur/StringTransforms.java
new file mode 100644
index 0000000000000000000000000000000000000000..90462942a810771ce4f03fd8418ec11a558126c0
--- /dev/null
+++ b/Klausuren/Sd1/SoSe2015/StringFunctions/src/main/java/de/hdm_stuttgart/sw1/klausur/StringTransforms.java
@@ -0,0 +1,80 @@
+package de.hdm_stuttgart.sw1.klausur;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+/**
+ * @author goik
+ *
+ */
+public class StringTransforms {
+	private static Logger log = LogManager.getLogger(StringTransforms.class);
+
+	/**
+	 * Eine urbane Legende attestiert Chinesen das Problem der Aussprache des
+	 * Buchstabens "r". Sie würden stattdessen ein "l" verwenden.
+	 * 
+	 * Die Methode ersetzt alle Buchstaben 'r' durch 'l' bzw. 'R' durch 'L'.
+	 * 
+	 * Beispiel:
+	 * 
+	 * Aus "Der arme Richard" wird "Del alme Lichald"
+	 * 
+	 * @param input
+	 *  Eine beliebige, von null verschiedene Zeichenkette
+	 *            
+	 * @return
+	 * 	Die Ersetzung der Zeichenkette gemäß {'r' zu 'l', 'R' zu 'L'}
+	 */
+	public static String chinesischerAkzent(final String input) {
+		
+		log.info("Bei Bedarf zur Fehlersuche logging Statements nutzen");
+
+		return "Blödsinn";// TODO implement me
+	}
+
+	/**
+	 * Sprachwissenschaftler sind der Ansicht, dass auch nach dem Entfernen von
+	 * Vokalen der Text lesbar bleibt. Beispiel: "Die Anden" wird zu "D ndn"
+	 * 
+	 * @param input
+	 *            Eine beliebige Zeichenkette oder null
+	 * 
+	 * @return null, falls Eingabe null, sonst der Eingabestring ohne Vokale {aeiouAEIOU}
+	 */
+	public static String entferneVokale(final String input) {
+		log.info("Bei Bedarf zur Fehlersuche logging Statements nutzen");
+
+		return "Blödsinn";// TODO implement me
+	}
+
+	/**
+	 * Umwandlung eines Wortes (ohne Leerzeichen) in Morsezeichen gemäß dem Morse Alphabet als
+	 * Folge langer (-) und kurzer (.) durch Pausen (Leerzeichen) getrennter Töne:
+	 * 
+	 * 		A .-    D -..  G --.  J .--- M --
+	 *		B -...  E .    H .... K -.-  N -.
+	 *		C -.-.  F ..-. I ..   L .-.. 
+	 *      Buchstaben O bis Z sowie Ziffern 0 bis 9 aus Platzgründen weggelassen. Diese brauchen
+	 *      in der Klausur aus Zeitgründen nicht implementiert zu werden.
+	 *  
+	 *  Regeln:
+	 *   -Kleinbuchstaben werden zunächst in Großbuchstaben umgewandelt
+	 *   -Pro Buchstabe / Ziffer wird nach der Morse Zeichenfolge eine Pause (Leerzeichen) eingefügt.
+	 *  
+	 *  Beispiel (Leerzeichen beachten, auch am Ende des Morsecodes):
+	 *   Aus "Abend" wird ".- -... . -. -.. "
+	 * 
+	 * @param input
+	 * 		Das Klartextwort, welches durch Morsezeichen kodiert werden soll.
+	 * @return
+	 * 		Die Ãœbersetzung in das Morsealphabet.
+	 */
+	public static String morsen(final String input) {
+
+		log.info("Bei Bedarf zur Fehlersuche logging Statements nutzen");
+
+		return "Blödsinn";// TODO implement me
+	}
+
+}
diff --git a/Klausuren/Sd1/SoSe2015/StringFunctions/src/main/resources/log4j2.xml b/Klausuren/Sd1/SoSe2015/StringFunctions/src/main/resources/log4j2.xml
new file mode 100644
index 0000000000000000000000000000000000000000..e4bd6e38899c495a0a6c363b44847059063a2e23
--- /dev/null
+++ b/Klausuren/Sd1/SoSe2015/StringFunctions/src/main/resources/log4j2.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Configuration>
+    <Appenders>
+        <File name="A1" fileName="A1.log" append="false">
+            <PatternLayout pattern="%t %-5p %c{2} - %m%n"/>
+        </File>
+        <Console name="STDOUT" target="SYSTEM_OUT">
+            <PatternLayout pattern="%d %-5p [%t] %C{2} (%F:%L) - %m%n"/>
+        </Console>
+    </Appenders>
+    <Loggers>
+
+        <!-- You my want to define class or package level per-logger rules -->
+        <Logger name="q.w.App" level="debug">
+            <AppenderRef ref="A1"/>
+        </Logger>
+        <Root level="info">
+            <AppenderRef ref="STDOUT"/>
+        </Root>
+    </Loggers>
+</Configuration>
\ No newline at end of file
diff --git a/Klausuren/Sd1/SoSe2015/StringFunctions/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/Marking.java b/Klausuren/Sd1/SoSe2015/StringFunctions/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/Marking.java
new file mode 100644
index 0000000000000000000000000000000000000000..b9b00c7cf68432896a94c4d34767ad0ab1c3ee37
--- /dev/null
+++ b/Klausuren/Sd1/SoSe2015/StringFunctions/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/Marking.java
@@ -0,0 +1,14 @@
+package de.hdm_stuttgart.mi.bitte_ignorieren;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+
+@Retention( value = RetentionPolicy.RUNTIME)
+@Target( value = { ElementType.METHOD})
+public @interface Marking {
+
+	int points ();
+}
diff --git a/Klausuren/Sd1/SoSe2015/StringFunctions/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/MarkingTest.java b/Klausuren/Sd1/SoSe2015/StringFunctions/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/MarkingTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..fe99181ad6a7bde7020e56efaf3969fba4d2f7ee
--- /dev/null
+++ b/Klausuren/Sd1/SoSe2015/StringFunctions/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/MarkingTest.java
@@ -0,0 +1,29 @@
+package de.hdm_stuttgart.mi.bitte_ignorieren;
+
+import org.junit.AfterClass;
+import org.junit.Rule;
+import org.junit.runner.Description;
+
+public class MarkingTest {
+	
+	static public Description currentTestClass = null;
+	
+	static public boolean provideExtraInfo = false;
+	
+	public final static ResultCollector globalresultCollector = new ResultCollector();
+	
+	@Rule
+	public ResultCollector collectedResults = globalresultCollector;
+
+	@AfterClass public static void showResults() {
+		if (provideExtraInfo) {
+			System.out.println("Local:----------------------------------");
+			System.out.println(globalresultCollector.currentToString());
+			System.out.println("Global:++++++++++++++++++++++++++++++++++");
+			System.out.println("Global:++++++++++++++++++++++++++++++++++");
+			System.out.println(globalresultCollector.toString());
+			System.out.println("Global:++++++++++++++++++++++++++++++++++");
+			System.out.println("Global:++++++++++++++++++++++++++++++++++");
+		}
+	}
+}
diff --git a/Klausuren/Sd1/SoSe2015/StringFunctions/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/ResultCollector.java b/Klausuren/Sd1/SoSe2015/StringFunctions/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/ResultCollector.java
new file mode 100644
index 0000000000000000000000000000000000000000..32c6f036b9ec9f338c5e03458bc668023ad3c50a
--- /dev/null
+++ b/Klausuren/Sd1/SoSe2015/StringFunctions/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/ResultCollector.java
@@ -0,0 +1,147 @@
+package de.hdm_stuttgart.mi.bitte_ignorieren;
+
+import java.lang.annotation.Annotation;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Vector;
+
+import org.junit.rules.TestWatcher;
+import org.junit.runner.Description;
+
+public class ResultCollector extends TestWatcher {
+
+	public final Map<String, List<TestResult>> 
+	failedByDescription = new HashMap<String,  List<TestResult>>(),
+	successByDescription = new HashMap<String, List<TestResult>>();
+
+	@Override
+	protected void starting(Description description) {
+		MarkingTest.currentTestClass = description;
+	}
+
+	@Override
+	protected void failed(final Throwable e, final Description description) {
+		putAppend(failedByDescription, description.getClassName(), new TestResult(description,
+				getMarking(description), false));
+	}
+
+	@Override
+	protected void succeeded(final Description description) {
+		putAppend(successByDescription, description.getClassName(), new TestResult(description,
+				getMarking(description), true));
+	}
+
+	private static void putAppend(final Map<String, List<TestResult>> map, final String key, final TestResult testresult) {
+		List<TestResult> results = map.get(key);
+		if (null == results) {
+			results = new Vector<TestResult>();
+			map.put(key, results);
+		}
+		results.add(testresult);
+	}
+	private static Marking getMarking(final Description description) {
+
+		final Marking marking = description.getAnnotation(Marking.class);
+		if (null == marking) { // Default values: 1 point
+			return new Marking() {
+
+				@Override
+				public Class<? extends Annotation> annotationType() {
+					return Marking.class;
+				}
+
+				@Override
+				public int points() {
+					return 1;
+				}
+			};
+
+		}
+		return marking;
+	}
+
+	public String currentToString() {
+		
+		final String currentTestClassName = MarkingTest.currentTestClass.getClassName();
+
+		int reachablePoints = 0, reachedPoints = 0, numSuccessfulTests = 0;
+
+		final List<TestResult> successfulTestResults = successByDescription.get(currentTestClassName);
+
+		if (null != successfulTestResults) {
+			for (final TestResult t : successfulTestResults) {
+				reachablePoints += t.marking.points();
+				reachedPoints += t.marking.points();
+				numSuccessfulTests++;
+			}
+		}
+
+		final StringBuffer failBuffer = new StringBuffer();
+
+		final List<TestResult> failedTestResults = failedByDescription.get(currentTestClassName);
+
+		if (null != failedTestResults) {
+			for (final TestResult t : failedTestResults) {
+				reachablePoints += t.marking.points();
+				failBuffer.append("  -" + t.testMethodDisplayName + "\n");
+			}
+		}
+
+		final StringBuffer buffer = new StringBuffer();
+
+		buffer.append(currentTestClassName + ":\nYou have reached " + reachedPoints + " of "
+				+ reachablePoints + " possible points in " + numSuccessfulTests + " successful tests. ");
+
+		if (null != failedTestResults) {
+
+			final int numFailed = failedTestResults.size();
+			if (1 == numFailed) {
+				buffer.append(" The following test still fails:\n");
+			} else if (1 <  numFailed) {
+				buffer.append("\n\nThe following " + numFailed + " tests still fail:\n");
+			}
+			buffer.append(failBuffer + "\n");
+		}
+		buffer.append("\n");
+		return buffer.toString();
+	}
+
+	@Override
+	public String toString() {
+
+		int reachablePoints = 0, reachedPoints = 0, successfulTests = 0, failedTests = 0;
+
+		for (final Entry<String, List<TestResult>> successEntries: successByDescription.entrySet()) {
+			for (final TestResult t : successEntries.getValue()) {
+				successfulTests++;
+				reachablePoints += t.marking.points();
+				reachedPoints += t.marking.points();
+			}
+		}
+
+		final StringBuffer failBuffer = new StringBuffer();
+		for (final Entry<String, List<TestResult>> failEntries: failedByDescription.entrySet()) {
+			for (final TestResult t : failEntries.getValue()) {
+				failedTests++;
+				reachablePoints += t.marking.points();
+				failBuffer.append("  -" + t.testMethodDisplayName + "\n");
+			}
+		}
+
+		final StringBuffer buffer = new StringBuffer();
+
+		buffer.append("You have reached " + reachedPoints + " of "
+				+ reachablePoints + " possible points in "
+				+ successfulTests + " successful tests\n");
+		if (1 == failedTests) {
+			buffer.append("\n\nThe following test still fails:\n");
+		} else if (1 < failedTests) {
+			buffer.append("\n\nThe following " + failedTests
+					+ " tests still fail:\n");
+		}
+		buffer.append(failBuffer + "\n");
+		return buffer.toString();
+	}
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/SoSe2015/StringFunctions/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/TestResult.java b/Klausuren/Sd1/SoSe2015/StringFunctions/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/TestResult.java
new file mode 100644
index 0000000000000000000000000000000000000000..d32e9e9deaa575b872989e6a0b676b47709f12b4
--- /dev/null
+++ b/Klausuren/Sd1/SoSe2015/StringFunctions/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/TestResult.java
@@ -0,0 +1,19 @@
+package de.hdm_stuttgart.mi.bitte_ignorieren;
+
+import org.junit.runner.Description;
+
+public class TestResult {
+
+	public final Description testMethodDisplayName;
+	public final Marking marking;
+	public final boolean success;
+	
+	public TestResult(final Description testMethodDisplayName,
+			final Marking marking,
+			final boolean success) {
+		
+		this.testMethodDisplayName = testMethodDisplayName;
+		this.marking = marking;
+		this.success = success;
+	}
+}
diff --git a/Klausuren/Sd1/SoSe2015/StringFunctions/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/eval/Aufgabe.java b/Klausuren/Sd1/SoSe2015/StringFunctions/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/eval/Aufgabe.java
new file mode 100644
index 0000000000000000000000000000000000000000..6619498715af3e20bffec9e94dc6acff9f1a679b
--- /dev/null
+++ b/Klausuren/Sd1/SoSe2015/StringFunctions/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/eval/Aufgabe.java
@@ -0,0 +1,29 @@
+package de.hdm_stuttgart.mi.bitte_ignorieren.eval;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+
+import de.hdm_stuttgart.mi.bitte_ignorieren.MarkingTest;
+import de.hdm_stuttgart.sw1.klausur.test.Test_MorseExceptions;
+import de.hdm_stuttgart.sw1.klausur.test.Test_StringTransforms;
+
+@RunWith(Suite.class)
+@Suite.SuiteClasses({
+	Test_StringTransforms.class,	
+	Test_MorseExceptions.class,	
+})
+
+public class Aufgabe {
+	
+	@BeforeClass public static void init() {
+		MarkingTest.provideExtraInfo = true;
+	}
+	
+	@AfterClass public static void showResults() {
+		System.out.println("---final------------------");
+		System.out.println(MarkingTest.globalresultCollector.toString());
+	}
+	
+}
diff --git a/Klausuren/Sd1/SoSe2015/StringFunctions/src/test/java/de/hdm_stuttgart/sw1/klausur/test/Test_MorseExceptions.java b/Klausuren/Sd1/SoSe2015/StringFunctions/src/test/java/de/hdm_stuttgart/sw1/klausur/test/Test_MorseExceptions.java
new file mode 100644
index 0000000000000000000000000000000000000000..37550b957bdabd2cb8c56d1a9621a3b91f3df02f
--- /dev/null
+++ b/Klausuren/Sd1/SoSe2015/StringFunctions/src/test/java/de/hdm_stuttgart/sw1/klausur/test/Test_MorseExceptions.java
@@ -0,0 +1,35 @@
+package de.hdm_stuttgart.sw1.klausur.test;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import de.hdm_stuttgart.mi.bitte_ignorieren.Marking;
+import de.hdm_stuttgart.mi.bitte_ignorieren.MarkingTest;
+import static de.hdm_stuttgart.sw1.klausur.StringTransforms.morsen;
+
+@SuppressWarnings({"static-method", "javadoc"})
+public class Test_MorseExceptions  extends MarkingTest {
+	
+	@Test
+	@Marking(points=5)
+	public void morsen_Exception () {
+		try {
+			final String text = "Ab+en_d";
+			morsen("Ab+en_d");
+			Assert.fail("String " + text + " sollte Exception zur Folge haben");
+		} catch (final Exception ex) {}
+	}
+	
+	@Test
+	@Marking(points=2)
+	public void morsen_ExceptionMessage() {
+		final String text = "Ab+en_d";
+		try {
+			morsen(text);
+			Assert.fail("String " + text + " sollte Exception zur Folge haben");
+		} catch (final Exception ex) {
+			Assert.assertEquals("Eingabezeichenkette '" + text + 
+					"' enthält nicht-Morsezeichen '+'.", ex.getMessage());
+		}
+	}
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/SoSe2015/StringFunctions/src/test/java/de/hdm_stuttgart/sw1/klausur/test/Test_StringTransforms.java b/Klausuren/Sd1/SoSe2015/StringFunctions/src/test/java/de/hdm_stuttgart/sw1/klausur/test/Test_StringTransforms.java
new file mode 100644
index 0000000000000000000000000000000000000000..ceb88a6ec4545a506bb27d39c5655d6d61ffa833
--- /dev/null
+++ b/Klausuren/Sd1/SoSe2015/StringFunctions/src/test/java/de/hdm_stuttgart/sw1/klausur/test/Test_StringTransforms.java
@@ -0,0 +1,85 @@
+package de.hdm_stuttgart.sw1.klausur.test;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import de.hdm_stuttgart.mi.bitte_ignorieren.Marking;
+import de.hdm_stuttgart.mi.bitte_ignorieren.MarkingTest;
+import static de.hdm_stuttgart.sw1.klausur.StringTransforms.chinesischerAkzent;
+import static de.hdm_stuttgart.sw1.klausur.StringTransforms.entferneVokale;
+import static de.hdm_stuttgart.sw1.klausur.StringTransforms.morsen;
+
+@SuppressWarnings({"static-method", "javadoc"})
+public class Test_StringTransforms extends MarkingTest {
+
+
+	// Tests zu chinesischerAkzent(final String input)
+	//
+	@Test
+	public void chinesischerAkzent_EmptyString () {
+		Assert.assertEquals("", chinesischerAkzent(""));
+	}
+
+	@Test
+	@Marking(points=2)
+	public void chinesischerAkzent_Identisch() {
+		final String ohne_r_buchstaben = "Es geht auch ohne!";
+		Assert.assertEquals(ohne_r_buchstaben, chinesischerAkzent(ohne_r_buchstaben));
+	}
+
+	@Test
+	@Marking(points=2)
+	public void chinesischerAkzent_Multiple() {
+		Assert.assertEquals("Almes Lumänien", chinesischerAkzent("Armes Rumänien"));
+	}
+
+	// Tests zu entferneVokale(final String input)
+	//
+	@Test
+	@Marking(points=4)
+	public void entferneVokale_NullInput () {
+		Assert.assertNull(entferneVokale(null));
+	}
+
+	@Test
+	@Marking(points=2)
+	public void entferneVokale_EmptyString() {
+		Assert.assertEquals("", entferneVokale(""));
+	}
+
+	@Test
+	public void entferneVokale_Einzelvokal() {
+		Assert.assertEquals("", entferneVokale("E"));
+	}
+
+	@Test
+	public void entferneVokale_Einzelkonsonant() {
+		Assert.assertEquals("k", entferneVokale("k"));
+	}
+
+	@Test
+	@Marking(points=2)
+	public void entferneVokale_NixZuTun () {
+		final String textOhneVokale = "dffGl1883KQW_+";
+		Assert.assertEquals(textOhneVokale, entferneVokale(textOhneVokale));
+	}
+
+	@Test
+	@Marking(points=5)
+	public void entferneVokale_Multiple(){
+		Assert.assertEquals("Bssr chtng f lls!", entferneVokale("Besser Achtung auf alles!"));
+	}
+
+	// Tests zu morsen(final String input)
+	//
+	@Test
+	public void morsen_Leer () {
+		Assert.assertEquals("", morsen(""));
+	}
+
+	@Test
+	@Marking(points=2)
+	public void morsen_Abend () {
+		Assert.assertEquals(".- -... . -. -.. ", morsen("Abend"));
+	}
+}
diff --git a/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/beschreibung.xhtml b/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/beschreibung.xhtml
new file mode 100644
index 0000000000000000000000000000000000000000..f261dcba125d147c95404ff52b1ffa40a8fddf7a
--- /dev/null
+++ b/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/beschreibung.xhtml
@@ -0,0 +1,138 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE html>
+<html xml:lang="de" xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <title></title>
+  </head>
+
+  <body><h1 id="toc">Ãœbersicht</h1> <ul>
+      <li><a href="#t1">Aufgabenteil 1: String Transformationen</a></li>
+
+      <li><a href="#t2">Aufgabenteil 2: Exceptions beim Morsen</a></li>
+    </ul> <hr /><!-- +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+  <h1 id="t1">Aufgabenteil 1: <span lang="en">String</span>
+  Transformationen</h1> <h3>Beschreibung</h3> <p>In diesem Aufgabenteil sollen
+  mehrere Methoden zur Transformation von Zeichenketten (Strings)
+  implementiert werden.</p><h3>Vorbereitung</h3><p>Entpacken Sie das Archiv <a
+  href="/files/goik/Klausur/SoSe2015/cjdhcwj776RRRR_QDSww3/sw1.zip">sw1.zip</a>
+  und importieren Sie den resultierenden Ordner <code>Klausur</code> als <span
+  lang="en">Maven</span> Projekt in Ihren <span lang="en">Eclipse
+  Workspace</span>. Ignorieren Sie bitte das <span lang="en">Package</span>
+  <code>de.hdm_stuttgart.mi.bitte_ignorieren</code> im Junit Test Zweig des
+  Projekts und ändern Sie <strong>nichts</strong> an den Tests.</p>
+  <h3>Aufgabe</h3><p>Vervollständigen Sie die Implementierung der folgenden
+  Methoden in der Klasse
+  <code>de.hdm_stuttgart.sw1.klausur.StringTransforms</code>:</p> <ol>
+      <li><code>chinesischerAkzent(final String input)</code></li>
+
+      <li><code>entferneVokale(final String input)</code></li>
+
+      <li><code>morsen(final String input)</code></li>
+    </ol> <p>Die Javadoc Kommentare der jeweiligen Methoden beschreiben das
+  gewünschte Verhalten. Lesen Sie diese bitte <strong>sehr genau</strong>.</p>
+  <h3>Allgemeine Hinweise</h3> <ul>
+      <li><p>Erwägen Sie die Verwendung von <code><a
+      href="https://docs.oracle.com/javase/8/docs/api/java/lang/StringBuffer.html"
+      target="_blank">StringBuffer</a></code> Instanzen.</p></li>
+
+      <li><p>Für jede Methode aus der Klasse <code>StringTransforms</code>
+      stehen Ihnen in der Testklasse
+      <code>de.hdm_stuttgart.sw1.klausur.test.Test_StringTransforms</code> des
+      Junit Test Zweigs <code>src/test/java</code> korrespondierende Tests zur
+      Verfügung.</p> <p>So definiert beispielsweise
+      <code>de.hdm_stuttgart.sw1.klausur.test.Test_StringTransforms.chinesischerAkzent_Identisch()</code>
+      einen Test der Methode
+      <code>de.hdm_stuttgart.sw1.klausur.StringTransforms.chinesischerAkzent(String
+      input)</code>.</p></li>
+
+      <li><p>Die von Ihnen erreichte Punktzahl richtet sich nach der Anzahl
+      positiv bestandener Tests. Sie bekommen keine Punkte, wenn Ihre
+      Implementierung in Bezug auf einen Test lediglich „fast richtig“ ist.
+      Daher im Zweifelsfall weniger Methoden vollständig
+      implementieren.</p></li>
+
+      <li><p>Beachten Sie alle Sonderfälle. Dazu zählen insbesondere
+      <code><code>null</code></code> Werte übergebener Variablen oder
+      enthaltene null Werte in übergebenen Arrays.</p></li>
+
+      <li><p>Tip: Nutzen Sie den Debugger oder logging Statements (Beispiele
+      sind im Code vorhanden) im Fall fehlgeschlagener Testfälle, bei denen
+      Sie das zugrundeliegende Problem nicht unmittelbar lösen
+      können.</p></li>
+    </ul> <h3>Methodenspezifische Hinweise</h3> <dl>
+      <dt><code>chinesischerAkzent(final String input)</code></dt>
+
+      <dd><p>Sie können einen String durch die Methode <code><a
+      href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html#toCharArray--"
+      target="_blank">toCharArray()</a></code> in seine Zeichen
+      zerlegen.</p></dd>
+
+      <dt><code>entferneVokale(final String input)</code></dt>
+
+      <dd><p>Bedenken Sie auch den Sonderfall eines <code>null</code>
+      Arguments.</p></dd>
+
+      <dt><code>morsen(final String input)</code></dt>
+
+      <dd><p>Das in diesem Aufgabenteil zu betrachtende Morsealphabet wird auf
+      die Zeichen <code>A</code> bis <code>N</code> beschränkt, um Ihnen
+      Tipparbeit zu sparen. Ihre Lösung sollte aber problemlos um die
+      fehlenden Zeichen erweiterbar sein.</p></dd>
+    </dl> <h3 id="upload">Hochladen Ihrer Lösung in das Klausursystem</h3>
+  <p>Sobald Sie die Aufgabe beendet haben (und möglichst wenige Tests
+  scheitern), exportieren Sie bitte Ihre Implementierung durch Rechtklick auf
+  das Eclipse Projekt.</p> <p>Wählen Sie dazu durch Rechtsklick auf Ihr
+  Projekt im Package Explorer aus dem Kontextmenü sukzessive die Punkte
+  »Export--&gt;General--&gt;Archive File« und legen Sie einen auf
+  <code>.zip</code> endenden Archivnamen fest. Laden Sie das resultierende
+  <code>.zip</code> Archiv in das Ilias Klausursystem hoch (unteres
+  Seitenende). Zur Kontrolle: Die hochgeladene .zip Datei muss im
+  Klausursystem sichtbar sein.</p> <p style="color: red;">Achtung: Exportieren
+  Sie Ihr Projekt als „.zip“ Datei (und nicht als „.tgz“, „.tar.gz“ o.ä). Sie
+  können nur Archive mit der Endung „.zip“ in das Klausursystem hochladen.</p>
+  <p>Alternativ können Sie auch gleich den folgenden <a
+  href="#t2">Aufgabenteil 2</a> bearbeiten und dann beide Aufgabenteile
+  gemeinsam in einem Archiv hochladen.</p> <p>Hinweis: Falls Sie mehrere
+  Archive hochladen, wird nur das zuletzt hochgeladene Archiv bewertet. Sie
+  können bei Bedarf hochgeladene Archive löschen, ich rate zur Vorsicht.</p>
+  <hr /><!-- +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+  <h1 id="t2">Aufgabenteil 2: Exceptions beim Morsen</h1>
+  <h3>Beschreibung</h3> <p>Das Morsealphabet kennt lediglich die Zeichen
+  <code>A-Z</code> sowie die Ziffern <code>0-9</code>. Was passiert, wenn das
+  Argument von <code>morsen(final String input)</code> beispielsweise ein
+  "<code>+</code>" Zeichen enthält? Dieses Problem sollen Sie behandeln.</p>
+  <h3>Aufgabe</h3> <p>Erstellen Sie eine geeignete unchecked Exception Klasse.
+  Werfen Sie eine Instanz mit entsprechender Fehlermeldung, falls sich ein
+  nicht-Morsezeichen in der Eingabe befindet.</p> <p>Ihre Exception soll per
+  Konstruktor eine Meldung (Message) erhalten. Wir betrachten folgendes
+  Beispiel:</p> <pre>try {
+      morsen("Ab+en_d");
+    } catch (final Exception ex) {
+      System.out.println(ex.getMessage());
+    }</pre> <p>Dies sollte folgende Meldung erzeugen:</p>
+  <code>Eingabezeichenkette 'Ab+en_d' enthält nicht-Morsezeichen '+'.</code>
+  <h3>Hinweise</h3> <ul>
+      <li><p>Ihre Lösung soll die Tests in
+      <code>de.hdm_stuttgart.sw1.klausur.test.Test_MorseExceptions</code>
+      bestehen.</p></li>
+
+      <li><p>In der Fehlermeldung soll stets das <strong>erste</strong>
+      nicht-Morsezeichen genannt werden.</p></li>
+
+      <li><p>Erzeugen Sie die Fehlermeldung exakt in der zuvor angegebenen
+      Form, ansonsten wird der entsprechende Unit Test scheitern.</p></li>
+
+      <li><p>Die Klasse <a
+      href="https://docs.oracle.com/javase/8/docs/api/java/lang/IllegalArgumentException.html"
+      target="_blank">IllegalArgumentException</a> kann Sinn stiftend
+      verwendet werden.</p></li>
+
+      <li><p>Beachten Sie, dass Ihre Erweiterung nicht die Tests des ersten
+      Aufgabenteils stört und führen Sie diese zur Sicherheit erneut
+      aus.</p></li>
+    </ul> <p>Vergessen Sie nicht, das <a href="#upload">Prozedere zum
+  Hochladen Ihres Projekts</a> erneut auszuführen. Wie oben erwähnt, wird nur
+  das zuletzt hochgeladene Archiv bewertet. Achten Sie daher darauf, dass Ihre
+  Code-Erweiterung den ersten Teil nicht stört und führen Sie die Tests zum <a
+  href="#t1">Teil 1</a> zur Sicherheit ebenfalls aus.</p></body>
+</html>
diff --git a/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/pom.xml b/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/pom.xml
new file mode 100644
index 0000000000000000000000000000000000000000..f2989d9726d7106450580b295f7b8ed455d56edc
--- /dev/null
+++ b/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/pom.xml
@@ -0,0 +1,95 @@
+<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.hdm-stuttgart.sw1.klausur</groupId>
+	<artifactId>sw1klausur</artifactId>
+	<version>0.9</version>
+	<packaging>jar</packaging>
+
+	<name>sw1klausur</name>
+	<url>http://maven.apache.org</url>
+
+	<properties>
+		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+	</properties>
+	<build>
+		<plugins>
+
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-shade-plugin</artifactId>
+				<version>2.4.1</version>
+				<executions>
+					<execution>
+						<phase>package</phase>
+						<goals>
+							<goal>shade</goal>
+						</goals>
+						<configuration>
+
+							<transformers>
+								<transformer
+									implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
+									<mainClass>de.hdm_stuttgart.mi.bitte_ignorieren.eval.Run</mainClass>
+								</transformer>
+							</transformers>
+						</configuration>
+					</execution>
+				</executions>
+			</plugin>
+			<plugin>
+				<groupId>org.codehaus.mojo</groupId>
+				<artifactId>build-helper-maven-plugin</artifactId>
+				<version>1.9.1</version>
+				<executions>
+
+					<execution>
+						<id>add-source</id>
+						<phase>generate-sources</phase>
+						<goals>
+							<goal>add-source</goal>
+						</goals>
+						<configuration>
+							<sources>
+								<source>${project.basedir}/src/test/java/</source>
+							</sources>
+						</configuration>
+					</execution>
+
+				</executions>
+			</plugin>
+
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-compiler-plugin</artifactId>
+				<version>3.2</version>
+				<configuration>
+					<source>1.8</source>
+					<target>1.8</target>
+				</configuration>
+			</plugin>
+
+		</plugins>
+	</build>
+
+	<dependencies>
+		<dependency>
+			<groupId>junit</groupId>
+			<artifactId>junit</artifactId>
+			<version>4.11</version>
+		</dependency>
+
+		<dependency>
+			<groupId>org.apache.logging.log4j</groupId>
+			<artifactId>log4j-api</artifactId>
+			<version>2.1</version>
+		</dependency>
+		<dependency>
+			<groupId>org.apache.logging.log4j</groupId>
+			<artifactId>log4j-core</artifactId>
+			<version>2.1</version>
+		</dependency>
+
+	</dependencies>
+</project>
diff --git a/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/src/main/java/de/hdm_stuttgart/sw1/klausur/IllegalMorseCharacterException.java b/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/src/main/java/de/hdm_stuttgart/sw1/klausur/IllegalMorseCharacterException.java
new file mode 100644
index 0000000000000000000000000000000000000000..05405c4481da946599195b399840ee7a69377da5
--- /dev/null
+++ b/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/src/main/java/de/hdm_stuttgart/sw1/klausur/IllegalMorseCharacterException.java
@@ -0,0 +1,11 @@
+package de.hdm_stuttgart.sw1.klausur;
+
+public class IllegalMorseCharacterException extends IllegalArgumentException {
+
+	private static final long serialVersionUID = 3788551071353114962L;
+	
+	public IllegalMorseCharacterException(final String message) {
+		super(message);
+	}
+
+}
diff --git a/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/src/main/java/de/hdm_stuttgart/sw1/klausur/StringTransforms.java b/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/src/main/java/de/hdm_stuttgart/sw1/klausur/StringTransforms.java
new file mode 100644
index 0000000000000000000000000000000000000000..df2c2192a1be220ef11605057de02ff35a4370ed
--- /dev/null
+++ b/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/src/main/java/de/hdm_stuttgart/sw1/klausur/StringTransforms.java
@@ -0,0 +1,156 @@
+package de.hdm_stuttgart.sw1.klausur;
+
+public class StringTransforms {
+
+	/**
+	 * Eine urbane Legende attestiert Chinesen das Problem der Aussprache des
+	 * Buchstabens "r". Sie würden stattdessen ein "l" verwenden.
+	 * 
+	 * Die Methode ersetzt alle Buchstaben 'r' durch 'l' bzw. 'R' durch 'L'.
+	 * 
+	 * Beispiel:
+	 * 
+	 * "Der arme Richard" ==> "Del alme Lichald"
+	 * 
+	 * @param input
+	 *  Eine beliebige, von null verschiedene Zeichenkette
+	 *            
+	 * @return
+	 * 	Die Ersetzung der Zeichenkette gemäß {'r' ==> 'l', 'R' ==> 'L'}
+	 */
+	public static String chinesischerAkzent(final String input) {
+		
+
+		final StringBuffer ret = new StringBuffer();
+		for (final char c : input.toCharArray()) {
+			switch (c) {
+			case 'r':
+				ret.append('l');
+				break;
+			case 'R':
+				ret.append('L');
+				break;
+			default:
+				ret.append(c);
+			}
+		}
+		return ret.toString();
+	}
+
+	/**
+	 * Sprachwissenschaftler sind der Ansicht, dass auch nach dem Entfernen von
+	 * Vokalen der Text lesbar bleibt. Beispiel: "Die Anden" ==> "D ndn"
+	 * 
+	 * @param input
+	 *            Eine beliebige Zeichenkette oder null
+	 * 
+	 * @return null, falls Eingabe null, sonst der Eingabestring ohne Vokale {aeiouAEIOU}
+	 */
+	public static String entferneVokale(final String input) {
+
+		if (null == input) {
+			return null;
+		} else {
+			final StringBuffer ret = new StringBuffer();
+			for (final char c : input.toCharArray()) {
+				switch (c) {
+				case 'a':
+				case 'e':
+				case 'i':
+				case 'o':
+				case 'u':
+				case 'A':
+				case 'E':
+				case 'I':
+				case 'O':
+				case 'U':
+					break;
+				default:
+					ret.append(c);
+				}
+			}
+			return ret.toString();
+		}
+	}
+
+	/**
+	 * Umwandlung eines Wortes (ohne Leerzeichen) in Morsezeichen gemäß dem Morse Alphabet als
+	 * Folge langer (-) und kurzer (.) durch Pausen (Leerzeichen) getrennter Töne:
+	 * 
+	 * 		A .-    D -..  G --.  J .--- M --
+	 *		B -...  E .    H .... K -.-  N -.
+	 *		C -.-.  F ..-. I ..   L .-.. 
+	 *      Buchstaben O bis Z sowie Ziffern 0 bis 9 aus Platzgründen weggelassen. Diese brauchen
+	 *      in der Klausur aus Zeitgründen nicht implementiert zu werden.
+	 *  
+	 *  Regeln:
+	 *   -Kleinbuchstaben werden zunächst in Großbuchstaben umgewandelt
+	 *   -Pro Buchstabe / Ziffer wird nach der Morse Zeichenfolge eine Pause (Leerzeichen) eingefügt.
+	 *  
+	 *  Beispiel (Leerzeichen beachten, auch am Ende des Morsecodes):
+	 *   "Abend" ==> ".- -... . -. -.. "
+	 * 
+	 * @param input
+	 * 		Das Klartextwort, welches durch Morsezeichen kodiert werden soll.
+	 * @return
+	 * 		Die Ãœbersetzung in das Morsealphabet.
+	 */
+	public static String morsen(final String input) {
+
+		final String capitalizedInput = input.toUpperCase();
+
+		final StringBuffer ret = new StringBuffer();
+		for (final char c : capitalizedInput.toCharArray()) {
+			switch (c) {
+
+			case 'A':ret.append(".-");    break;
+			case 'B':ret.append("-...");  break;
+			case 'C':ret.append("-.-.");  break;
+			case 'D':ret.append("-..");   break;
+			case 'E':ret.append(".");     break;
+			case 'F':ret.append("..-.");  break;
+			case 'G':ret.append("--.");   break;
+			case 'H':ret.append("....");  break;
+			case 'I':ret.append("..");    break;
+			case 'J':ret.append(".---");  break;
+			case 'K':ret.append("-.-");   break;
+			case 'L':ret.append(".-..");  break;
+			case 'M':ret.append("--");    break;
+			case 'N':ret.append("-.");    break;
+			
+// Zu viel Tipparbeit in einer Klausur
+//			
+//			case 'O':ret.append("---");   break;
+//			case 'P':ret.append(".--.");  break;
+//			case 'Q':ret.append("--.-");  break;
+//			case 'R':ret.append(".-.");   break;
+//			case 'S':ret.append("...");   break;
+//			case 'T':ret.append("-");     break;
+//			case 'U':ret.append("..-");   break;
+//			case 'V':ret.append("...-");  break;
+//			case 'W':ret.append(".--");   break;
+//			case 'X':ret.append("-..-");  break;
+//			case 'Y':ret.append("-.--");  break;
+//			case 'Z':ret.append("--..");  break;
+//
+//			case '0':ret.append("-----"); break;
+//			case '1':ret.append(".----"); break;
+//			case '2':ret.append("..---"); break;
+//			case '3':ret.append("...--"); break;
+//			case '4':ret.append("....-"); break;
+//			case '5':ret.append("....."); break;
+//			case '6':ret.append("-...."); break;
+//			case '7':ret.append("--..."); break;
+//			case '8':ret.append("---.."); break;
+//			case '9':ret.append("----."); break;
+
+			default:
+				throw new IllegalMorseCharacterException("Eingabezeichenkette '" + input + 
+						"' enthält nicht-Morsezeichen '" + c + "'.");
+			}
+			ret.append(' ');
+		}
+		return ret.toString();
+	}
+
+}
diff --git a/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/src/main/resources/log4j2.xml b/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/src/main/resources/log4j2.xml
new file mode 100644
index 0000000000000000000000000000000000000000..e4bd6e38899c495a0a6c363b44847059063a2e23
--- /dev/null
+++ b/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/src/main/resources/log4j2.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Configuration>
+    <Appenders>
+        <File name="A1" fileName="A1.log" append="false">
+            <PatternLayout pattern="%t %-5p %c{2} - %m%n"/>
+        </File>
+        <Console name="STDOUT" target="SYSTEM_OUT">
+            <PatternLayout pattern="%d %-5p [%t] %C{2} (%F:%L) - %m%n"/>
+        </Console>
+    </Appenders>
+    <Loggers>
+
+        <!-- You my want to define class or package level per-logger rules -->
+        <Logger name="q.w.App" level="debug">
+            <AppenderRef ref="A1"/>
+        </Logger>
+        <Root level="info">
+            <AppenderRef ref="STDOUT"/>
+        </Root>
+    </Loggers>
+</Configuration>
\ No newline at end of file
diff --git a/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/Marking.java b/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/Marking.java
new file mode 100644
index 0000000000000000000000000000000000000000..b9b00c7cf68432896a94c4d34767ad0ab1c3ee37
--- /dev/null
+++ b/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/Marking.java
@@ -0,0 +1,14 @@
+package de.hdm_stuttgart.mi.bitte_ignorieren;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+
+@Retention( value = RetentionPolicy.RUNTIME)
+@Target( value = { ElementType.METHOD})
+public @interface Marking {
+
+	int points ();
+}
diff --git a/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/MarkingTest.java b/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/MarkingTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..fe99181ad6a7bde7020e56efaf3969fba4d2f7ee
--- /dev/null
+++ b/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/MarkingTest.java
@@ -0,0 +1,29 @@
+package de.hdm_stuttgart.mi.bitte_ignorieren;
+
+import org.junit.AfterClass;
+import org.junit.Rule;
+import org.junit.runner.Description;
+
+public class MarkingTest {
+	
+	static public Description currentTestClass = null;
+	
+	static public boolean provideExtraInfo = false;
+	
+	public final static ResultCollector globalresultCollector = new ResultCollector();
+	
+	@Rule
+	public ResultCollector collectedResults = globalresultCollector;
+
+	@AfterClass public static void showResults() {
+		if (provideExtraInfo) {
+			System.out.println("Local:----------------------------------");
+			System.out.println(globalresultCollector.currentToString());
+			System.out.println("Global:++++++++++++++++++++++++++++++++++");
+			System.out.println("Global:++++++++++++++++++++++++++++++++++");
+			System.out.println(globalresultCollector.toString());
+			System.out.println("Global:++++++++++++++++++++++++++++++++++");
+			System.out.println("Global:++++++++++++++++++++++++++++++++++");
+		}
+	}
+}
diff --git a/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/ResultCollector.java b/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/ResultCollector.java
new file mode 100644
index 0000000000000000000000000000000000000000..63f497581b38077420854d2657e44e705c0e6488
--- /dev/null
+++ b/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/ResultCollector.java
@@ -0,0 +1,157 @@
+package de.hdm_stuttgart.mi.bitte_ignorieren;
+
+import java.lang.annotation.Annotation;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Vector;
+
+import org.junit.rules.TestWatcher;
+import org.junit.runner.Description;
+
+public class ResultCollector extends TestWatcher {
+
+	public final Map<String, List<TestResult>> 
+	failedByDescription = new HashMap<String,  List<TestResult>>(),
+	successByDescription = new HashMap<String, List<TestResult>>();
+
+	@Override
+	protected void starting(Description description) {
+		MarkingTest.currentTestClass = description;
+	}
+
+	@Override
+	protected void failed(final Throwable e, final Description description) {
+		putAppend(failedByDescription, description.getClassName(), new TestResult(description,
+				getMarking(description), false));
+	}
+
+	@Override
+	protected void succeeded(final Description description) {
+		putAppend(successByDescription, description.getClassName(), new TestResult(description,
+				getMarking(description), true));
+	}
+
+	private static void putAppend(final Map<String, List<TestResult>> map, final String key, final TestResult testresult) {
+		List<TestResult> results = map.get(key);
+		if (null == results) {
+			results = new Vector<TestResult>();
+			map.put(key, results);
+		}
+		results.add(testresult);
+	}
+	private static Marking getMarking(final Description description) {
+
+		final Marking marking = description.getAnnotation(Marking.class);
+		if (null == marking) { // Default values: 1 point
+			return new Marking() {
+
+				@Override
+				public Class<? extends Annotation> annotationType() {
+					return Marking.class;
+				}
+
+				@Override
+				public int points() {
+					return 1;
+				}
+			};
+
+		}
+		return marking;
+	}
+
+	public String currentToString() {
+		
+		final String currentTestClassName = MarkingTest.currentTestClass.getClassName();
+
+		int reachablePoints = 0, reachedPoints = 0, numSuccessfulTests = 0;
+
+		final List<TestResult> successfulTestResults = successByDescription.get(currentTestClassName);
+
+		if (null != successfulTestResults) {
+			for (final TestResult t : successfulTestResults) {
+				reachablePoints += t.marking.points();
+				reachedPoints += t.marking.points();
+				numSuccessfulTests++;
+			}
+		}
+
+		final StringBuffer failBuffer = new StringBuffer();
+
+		final List<TestResult> failedTestResults = failedByDescription.get(currentTestClassName);
+
+		if (null != failedTestResults) {
+			for (final TestResult t : failedTestResults) {
+				reachablePoints += t.marking.points();
+				failBuffer.append("  -" + t.testMethodDisplayName + "\n");
+			}
+		}
+
+		final StringBuffer buffer = new StringBuffer();
+
+		buffer.append(currentTestClassName + ":\nYou have reached " + reachedPoints + " of "
+				+ reachablePoints + " possible points in " + numSuccessfulTests + " successful tests. ");
+
+		if (null != failedTestResults) {
+
+			final int numFailed = failedTestResults.size();
+			if (1 == numFailed) {
+				buffer.append(" The following test still fails:\n");
+			} else if (1 <  numFailed) {
+				buffer.append("\n\nThe following " + numFailed + " tests still fail:\n");
+			}
+			buffer.append(failBuffer + "\n");
+		}
+		buffer.append("\n");
+		return buffer.toString();
+	}
+	public int getReachedPoints() {
+	  int reachedPoints = 0;
+
+    for (final Entry<String, List<TestResult>> successEntries: successByDescription.entrySet()) {
+      for (final TestResult t : successEntries.getValue()) {
+        reachedPoints += t.marking.points();
+      }
+    }
+    return reachedPoints;
+	}
+	
+	@Override
+	public String toString() {
+
+		int reachablePoints = 0, reachedPoints = 0, successfulTests = 0, failedTests = 0;
+
+		for (final Entry<String, List<TestResult>> successEntries: successByDescription.entrySet()) {
+			for (final TestResult t : successEntries.getValue()) {
+				successfulTests++;
+				reachablePoints += t.marking.points();
+				reachedPoints += t.marking.points();
+			}
+		}
+
+		final StringBuffer failBuffer = new StringBuffer();
+		for (final Entry<String, List<TestResult>> failEntries: failedByDescription.entrySet()) {
+			for (final TestResult t : failEntries.getValue()) {
+				failedTests++;
+				reachablePoints += t.marking.points();
+				failBuffer.append("  -" + t.testMethodDisplayName + "\n");
+			}
+		}
+
+		final StringBuffer buffer = new StringBuffer();
+
+		buffer.append("You have reached " + reachedPoints + " of "
+				+ reachablePoints + " possible points in "
+				+ successfulTests + " successful tests\n");
+		if (1 == failedTests) {
+			buffer.append("\n\nThe following test still fails:\n");
+		} else if (1 < failedTests) {
+			buffer.append("\n\nThe following " + failedTests
+					+ " tests still fail:\n");
+		}
+		buffer.append(failBuffer + "\n");
+		return buffer.toString();
+	}
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/TestResult.java b/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/TestResult.java
new file mode 100644
index 0000000000000000000000000000000000000000..d32e9e9deaa575b872989e6a0b676b47709f12b4
--- /dev/null
+++ b/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/TestResult.java
@@ -0,0 +1,19 @@
+package de.hdm_stuttgart.mi.bitte_ignorieren;
+
+import org.junit.runner.Description;
+
+public class TestResult {
+
+	public final Description testMethodDisplayName;
+	public final Marking marking;
+	public final boolean success;
+	
+	public TestResult(final Description testMethodDisplayName,
+			final Marking marking,
+			final boolean success) {
+		
+		this.testMethodDisplayName = testMethodDisplayName;
+		this.marking = marking;
+		this.success = success;
+	}
+}
diff --git a/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/eval/DetailedTestResults.java b/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/eval/DetailedTestResults.java
new file mode 100644
index 0000000000000000000000000000000000000000..20f469f45e3f93a0e41fa1bf5d83e1aeae05a030
--- /dev/null
+++ b/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/eval/DetailedTestResults.java
@@ -0,0 +1,30 @@
+package de.hdm_stuttgart.mi.bitte_ignorieren.eval;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+
+import de.hdm_stuttgart.mi.bitte_ignorieren.MarkingTest;
+import de.hdm_stuttgart.sw1.klausur.test.Test_MorseExceptions;
+import de.hdm_stuttgart.sw1.klausur.test.Test_StringTransforms;
+
+@RunWith(Suite.class)
+@Suite.SuiteClasses({
+	Test_StringTransforms.class,	
+	Test_MorseExceptions.class,	
+})
+
+public class DetailedTestResults {
+	
+	@BeforeClass public static void init() {
+		MarkingTest.provideExtraInfo = true;
+	}
+	
+	@AfterClass public static void showResults() {
+		System.out.println("---final------------------");
+		System.out.println(MarkingTest.globalresultCollector.toString());
+		//System.out.println(MarkingTest.globalresultCollector.);
+	}
+	
+}
diff --git a/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/eval/ReachedPoints.java b/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/eval/ReachedPoints.java
new file mode 100644
index 0000000000000000000000000000000000000000..8b0cd3f1fe200baa8fb26a611dab4172685f23b8
--- /dev/null
+++ b/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/eval/ReachedPoints.java
@@ -0,0 +1,27 @@
+package de.hdm_stuttgart.mi.bitte_ignorieren.eval;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+
+import de.hdm_stuttgart.mi.bitte_ignorieren.MarkingTest;
+import de.hdm_stuttgart.sw1.klausur.test.Test_MorseExceptions;
+import de.hdm_stuttgart.sw1.klausur.test.Test_StringTransforms;
+
+@RunWith(Suite.class)
+@Suite.SuiteClasses({
+	Test_StringTransforms.class,	
+	Test_MorseExceptions.class,	
+})
+
+public class ReachedPoints {
+	
+	@BeforeClass public static void init() {
+		MarkingTest.provideExtraInfo = false;
+	}
+	
+	@AfterClass public static void showResults() {
+		System.out.println("myGoikKlausurMarkeri:" + MarkingTest.globalresultCollector.getReachedPoints());
+	}
+}
diff --git a/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/eval/Run.java b/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/eval/Run.java
new file mode 100644
index 0000000000000000000000000000000000000000..bbd8cafd129a2b8080779026aeeccab3bd17bea6
--- /dev/null
+++ b/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/eval/Run.java
@@ -0,0 +1,9 @@
+package de.hdm_stuttgart.mi.bitte_ignorieren.eval;
+
+import org.junit.runner.JUnitCore;
+
+public class Run {
+  public static void main(String[] args) {
+    JUnitCore.runClasses(ReachedPoints.class);
+  }
+}
diff --git a/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/src/test/java/de/hdm_stuttgart/sw1/klausur/test/Test_MorseExceptions.java b/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/src/test/java/de/hdm_stuttgart/sw1/klausur/test/Test_MorseExceptions.java
new file mode 100644
index 0000000000000000000000000000000000000000..37550b957bdabd2cb8c56d1a9621a3b91f3df02f
--- /dev/null
+++ b/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/src/test/java/de/hdm_stuttgart/sw1/klausur/test/Test_MorseExceptions.java
@@ -0,0 +1,35 @@
+package de.hdm_stuttgart.sw1.klausur.test;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import de.hdm_stuttgart.mi.bitte_ignorieren.Marking;
+import de.hdm_stuttgart.mi.bitte_ignorieren.MarkingTest;
+import static de.hdm_stuttgart.sw1.klausur.StringTransforms.morsen;
+
+@SuppressWarnings({"static-method", "javadoc"})
+public class Test_MorseExceptions  extends MarkingTest {
+	
+	@Test
+	@Marking(points=5)
+	public void morsen_Exception () {
+		try {
+			final String text = "Ab+en_d";
+			morsen("Ab+en_d");
+			Assert.fail("String " + text + " sollte Exception zur Folge haben");
+		} catch (final Exception ex) {}
+	}
+	
+	@Test
+	@Marking(points=2)
+	public void morsen_ExceptionMessage() {
+		final String text = "Ab+en_d";
+		try {
+			morsen(text);
+			Assert.fail("String " + text + " sollte Exception zur Folge haben");
+		} catch (final Exception ex) {
+			Assert.assertEquals("Eingabezeichenkette '" + text + 
+					"' enthält nicht-Morsezeichen '+'.", ex.getMessage());
+		}
+	}
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/src/test/java/de/hdm_stuttgart/sw1/klausur/test/Test_StringTransforms.java b/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/src/test/java/de/hdm_stuttgart/sw1/klausur/test/Test_StringTransforms.java
new file mode 100644
index 0000000000000000000000000000000000000000..ceb88a6ec4545a506bb27d39c5655d6d61ffa833
--- /dev/null
+++ b/Klausuren/Sd1/SoSe2015/StringFunctions_Solution/src/test/java/de/hdm_stuttgart/sw1/klausur/test/Test_StringTransforms.java
@@ -0,0 +1,85 @@
+package de.hdm_stuttgart.sw1.klausur.test;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import de.hdm_stuttgart.mi.bitte_ignorieren.Marking;
+import de.hdm_stuttgart.mi.bitte_ignorieren.MarkingTest;
+import static de.hdm_stuttgart.sw1.klausur.StringTransforms.chinesischerAkzent;
+import static de.hdm_stuttgart.sw1.klausur.StringTransforms.entferneVokale;
+import static de.hdm_stuttgart.sw1.klausur.StringTransforms.morsen;
+
+@SuppressWarnings({"static-method", "javadoc"})
+public class Test_StringTransforms extends MarkingTest {
+
+
+	// Tests zu chinesischerAkzent(final String input)
+	//
+	@Test
+	public void chinesischerAkzent_EmptyString () {
+		Assert.assertEquals("", chinesischerAkzent(""));
+	}
+
+	@Test
+	@Marking(points=2)
+	public void chinesischerAkzent_Identisch() {
+		final String ohne_r_buchstaben = "Es geht auch ohne!";
+		Assert.assertEquals(ohne_r_buchstaben, chinesischerAkzent(ohne_r_buchstaben));
+	}
+
+	@Test
+	@Marking(points=2)
+	public void chinesischerAkzent_Multiple() {
+		Assert.assertEquals("Almes Lumänien", chinesischerAkzent("Armes Rumänien"));
+	}
+
+	// Tests zu entferneVokale(final String input)
+	//
+	@Test
+	@Marking(points=4)
+	public void entferneVokale_NullInput () {
+		Assert.assertNull(entferneVokale(null));
+	}
+
+	@Test
+	@Marking(points=2)
+	public void entferneVokale_EmptyString() {
+		Assert.assertEquals("", entferneVokale(""));
+	}
+
+	@Test
+	public void entferneVokale_Einzelvokal() {
+		Assert.assertEquals("", entferneVokale("E"));
+	}
+
+	@Test
+	public void entferneVokale_Einzelkonsonant() {
+		Assert.assertEquals("k", entferneVokale("k"));
+	}
+
+	@Test
+	@Marking(points=2)
+	public void entferneVokale_NixZuTun () {
+		final String textOhneVokale = "dffGl1883KQW_+";
+		Assert.assertEquals(textOhneVokale, entferneVokale(textOhneVokale));
+	}
+
+	@Test
+	@Marking(points=5)
+	public void entferneVokale_Multiple(){
+		Assert.assertEquals("Bssr chtng f lls!", entferneVokale("Besser Achtung auf alles!"));
+	}
+
+	// Tests zu morsen(final String input)
+	//
+	@Test
+	public void morsen_Leer () {
+		Assert.assertEquals("", morsen(""));
+	}
+
+	@Test
+	@Marking(points=2)
+	public void morsen_Abend () {
+		Assert.assertEquals(".- -... . -. -.. ", morsen("Abend"));
+	}
+}
diff --git a/Klausuren/Sd1/WS2014/Klausur/pom.xml b/Klausuren/Sd1/Ws2014/Klausur/pom.xml
similarity index 100%
rename from Klausuren/Sd1/WS2014/Klausur/pom.xml
rename to Klausuren/Sd1/Ws2014/Klausur/pom.xml
diff --git a/Klausuren/Sd1/WS2014/Klausur/src/main/java/de/hdm_stuttgart/sw1/klausur/book/Book.java b/Klausuren/Sd1/Ws2014/Klausur/src/main/java/de/hdm_stuttgart/sw1/klausur/book/Book.java
similarity index 100%
rename from Klausuren/Sd1/WS2014/Klausur/src/main/java/de/hdm_stuttgart/sw1/klausur/book/Book.java
rename to Klausuren/Sd1/Ws2014/Klausur/src/main/java/de/hdm_stuttgart/sw1/klausur/book/Book.java
diff --git a/Klausuren/Sd1/WS2014/Klausur/src/main/java/de/hdm_stuttgart/sw1/klausur/book/Driver.java b/Klausuren/Sd1/Ws2014/Klausur/src/main/java/de/hdm_stuttgart/sw1/klausur/book/Driver.java
similarity index 100%
rename from Klausuren/Sd1/WS2014/Klausur/src/main/java/de/hdm_stuttgart/sw1/klausur/book/Driver.java
rename to Klausuren/Sd1/Ws2014/Klausur/src/main/java/de/hdm_stuttgart/sw1/klausur/book/Driver.java
diff --git a/Klausuren/Sd1/WS2014/Klausur/src/main/java/de/hdm_stuttgart/sw1/klausur/string/StringHelper.java b/Klausuren/Sd1/Ws2014/Klausur/src/main/java/de/hdm_stuttgart/sw1/klausur/string/StringHelper.java
similarity index 100%
rename from Klausuren/Sd1/WS2014/Klausur/src/main/java/de/hdm_stuttgart/sw1/klausur/string/StringHelper.java
rename to Klausuren/Sd1/Ws2014/Klausur/src/main/java/de/hdm_stuttgart/sw1/klausur/string/StringHelper.java
diff --git a/Klausuren/Sd1/WS2014/Klausur/src/test/java/de/hdm_stuttgart/mi/exam/Marking.java b/Klausuren/Sd1/Ws2014/Klausur/src/test/java/de/hdm_stuttgart/mi/exam/Marking.java
similarity index 100%
rename from Klausuren/Sd1/WS2014/Klausur/src/test/java/de/hdm_stuttgart/mi/exam/Marking.java
rename to Klausuren/Sd1/Ws2014/Klausur/src/test/java/de/hdm_stuttgart/mi/exam/Marking.java
diff --git a/Klausuren/Sd1/WS2014/Klausur/src/test/java/de/hdm_stuttgart/mi/exam/MarkingTest.java b/Klausuren/Sd1/Ws2014/Klausur/src/test/java/de/hdm_stuttgart/mi/exam/MarkingTest.java
similarity index 100%
rename from Klausuren/Sd1/WS2014/Klausur/src/test/java/de/hdm_stuttgart/mi/exam/MarkingTest.java
rename to Klausuren/Sd1/Ws2014/Klausur/src/test/java/de/hdm_stuttgart/mi/exam/MarkingTest.java
diff --git a/Klausuren/Sd1/WS2014/Klausur/src/test/java/de/hdm_stuttgart/mi/exam/ResultCollector.java b/Klausuren/Sd1/Ws2014/Klausur/src/test/java/de/hdm_stuttgart/mi/exam/ResultCollector.java
similarity index 100%
rename from Klausuren/Sd1/WS2014/Klausur/src/test/java/de/hdm_stuttgart/mi/exam/ResultCollector.java
rename to Klausuren/Sd1/Ws2014/Klausur/src/test/java/de/hdm_stuttgart/mi/exam/ResultCollector.java
diff --git a/Klausuren/Sd1/WS2014/Klausur/src/test/java/de/hdm_stuttgart/mi/exam/TestResult.java b/Klausuren/Sd1/Ws2014/Klausur/src/test/java/de/hdm_stuttgart/mi/exam/TestResult.java
similarity index 100%
rename from Klausuren/Sd1/WS2014/Klausur/src/test/java/de/hdm_stuttgart/mi/exam/TestResult.java
rename to Klausuren/Sd1/Ws2014/Klausur/src/test/java/de/hdm_stuttgart/mi/exam/TestResult.java
diff --git a/Klausuren/Sd1/WS2014/Klausur/src/test/java/de/hdm_stuttgart/sw1/klausur/test/Helper.java b/Klausuren/Sd1/Ws2014/Klausur/src/test/java/de/hdm_stuttgart/sw1/klausur/test/Helper.java
similarity index 100%
rename from Klausuren/Sd1/WS2014/Klausur/src/test/java/de/hdm_stuttgart/sw1/klausur/test/Helper.java
rename to Klausuren/Sd1/Ws2014/Klausur/src/test/java/de/hdm_stuttgart/sw1/klausur/test/Helper.java
diff --git a/Klausuren/Sd1/WS2014/Klausur/src/test/java/de/hdm_stuttgart/sw1/klausur/test/TestAnzahlZiffernString.java b/Klausuren/Sd1/Ws2014/Klausur/src/test/java/de/hdm_stuttgart/sw1/klausur/test/TestAnzahlZiffernString.java
similarity index 100%
rename from Klausuren/Sd1/WS2014/Klausur/src/test/java/de/hdm_stuttgart/sw1/klausur/test/TestAnzahlZiffernString.java
rename to Klausuren/Sd1/Ws2014/Klausur/src/test/java/de/hdm_stuttgart/sw1/klausur/test/TestAnzahlZiffernString.java
diff --git a/Klausuren/Sd1/WS2014/Klausur/src/test/java/de/hdm_stuttgart/sw1/klausur/test/TestAnzahlZiffernStringArray.java b/Klausuren/Sd1/Ws2014/Klausur/src/test/java/de/hdm_stuttgart/sw1/klausur/test/TestAnzahlZiffernStringArray.java
similarity index 100%
rename from Klausuren/Sd1/WS2014/Klausur/src/test/java/de/hdm_stuttgart/sw1/klausur/test/TestAnzahlZiffernStringArray.java
rename to Klausuren/Sd1/Ws2014/Klausur/src/test/java/de/hdm_stuttgart/sw1/klausur/test/TestAnzahlZiffernStringArray.java
diff --git a/Klausuren/Sd1/WS2014/Klausur/src/test/java/de/hdm_stuttgart/sw1/klausur/test/TestFilterSortiere.java b/Klausuren/Sd1/Ws2014/Klausur/src/test/java/de/hdm_stuttgart/sw1/klausur/test/TestFilterSortiere.java
similarity index 100%
rename from Klausuren/Sd1/WS2014/Klausur/src/test/java/de/hdm_stuttgart/sw1/klausur/test/TestFilterSortiere.java
rename to Klausuren/Sd1/Ws2014/Klausur/src/test/java/de/hdm_stuttgart/sw1/klausur/test/TestFilterSortiere.java
diff --git a/Klausuren/Sd1/WS2014/Klausur/src/test/java/de/hdm_stuttgart/sw1/klausur/test/TestSummierteWortlaenge.java b/Klausuren/Sd1/Ws2014/Klausur/src/test/java/de/hdm_stuttgart/sw1/klausur/test/TestSummierteWortlaenge.java
similarity index 100%
rename from Klausuren/Sd1/WS2014/Klausur/src/test/java/de/hdm_stuttgart/sw1/klausur/test/TestSummierteWortlaenge.java
rename to Klausuren/Sd1/Ws2014/Klausur/src/test/java/de/hdm_stuttgart/sw1/klausur/test/TestSummierteWortlaenge.java
diff --git a/Klausuren/Sd1/WS2014/Solution/beschreibung.xhtml b/Klausuren/Sd1/Ws2014/Solution/beschreibung.xhtml
similarity index 100%
rename from Klausuren/Sd1/WS2014/Solution/beschreibung.xhtml
rename to Klausuren/Sd1/Ws2014/Solution/beschreibung.xhtml
diff --git a/Klausuren/Sd1/WS2014/Solution/pom.xml b/Klausuren/Sd1/Ws2014/Solution/pom.xml
similarity index 100%
rename from Klausuren/Sd1/WS2014/Solution/pom.xml
rename to Klausuren/Sd1/Ws2014/Solution/pom.xml
diff --git a/Klausuren/Sd1/WS2014/Solution/src/main/java/de/hdm_stuttgart/sw1/klausur/book/Book.java b/Klausuren/Sd1/Ws2014/Solution/src/main/java/de/hdm_stuttgart/sw1/klausur/book/Book.java
similarity index 100%
rename from Klausuren/Sd1/WS2014/Solution/src/main/java/de/hdm_stuttgart/sw1/klausur/book/Book.java
rename to Klausuren/Sd1/Ws2014/Solution/src/main/java/de/hdm_stuttgart/sw1/klausur/book/Book.java
diff --git a/Klausuren/Sd1/WS2014/Solution/src/main/java/de/hdm_stuttgart/sw1/klausur/book/Driver.java b/Klausuren/Sd1/Ws2014/Solution/src/main/java/de/hdm_stuttgart/sw1/klausur/book/Driver.java
similarity index 100%
rename from Klausuren/Sd1/WS2014/Solution/src/main/java/de/hdm_stuttgart/sw1/klausur/book/Driver.java
rename to Klausuren/Sd1/Ws2014/Solution/src/main/java/de/hdm_stuttgart/sw1/klausur/book/Driver.java
diff --git a/Klausuren/Sd1/WS2014/Solution/src/main/java/de/hdm_stuttgart/sw1/klausur/book/SortYearAuthor.java b/Klausuren/Sd1/Ws2014/Solution/src/main/java/de/hdm_stuttgart/sw1/klausur/book/SortYearAuthor.java
similarity index 100%
rename from Klausuren/Sd1/WS2014/Solution/src/main/java/de/hdm_stuttgart/sw1/klausur/book/SortYearAuthor.java
rename to Klausuren/Sd1/Ws2014/Solution/src/main/java/de/hdm_stuttgart/sw1/klausur/book/SortYearAuthor.java
diff --git a/Klausuren/Sd1/WS2014/Solution/src/main/java/de/hdm_stuttgart/sw1/klausur/book/equal/Driver.java b/Klausuren/Sd1/Ws2014/Solution/src/main/java/de/hdm_stuttgart/sw1/klausur/book/equal/Driver.java
similarity index 100%
rename from Klausuren/Sd1/WS2014/Solution/src/main/java/de/hdm_stuttgart/sw1/klausur/book/equal/Driver.java
rename to Klausuren/Sd1/Ws2014/Solution/src/main/java/de/hdm_stuttgart/sw1/klausur/book/equal/Driver.java
diff --git a/Klausuren/Sd1/WS2014/Solution/src/main/java/de/hdm_stuttgart/sw1/klausur/string/StringHelper.java b/Klausuren/Sd1/Ws2014/Solution/src/main/java/de/hdm_stuttgart/sw1/klausur/string/StringHelper.java
similarity index 100%
rename from Klausuren/Sd1/WS2014/Solution/src/main/java/de/hdm_stuttgart/sw1/klausur/string/StringHelper.java
rename to Klausuren/Sd1/Ws2014/Solution/src/main/java/de/hdm_stuttgart/sw1/klausur/string/StringHelper.java
diff --git a/Klausuren/Sd1/WS2014/Solution/src/test/java/de/hdm_stuttgart/mi/exam/Marking.java b/Klausuren/Sd1/Ws2014/Solution/src/test/java/de/hdm_stuttgart/mi/exam/Marking.java
similarity index 100%
rename from Klausuren/Sd1/WS2014/Solution/src/test/java/de/hdm_stuttgart/mi/exam/Marking.java
rename to Klausuren/Sd1/Ws2014/Solution/src/test/java/de/hdm_stuttgart/mi/exam/Marking.java
diff --git a/Klausuren/Sd1/WS2014/Solution/src/test/java/de/hdm_stuttgart/mi/exam/MarkingTest.java b/Klausuren/Sd1/Ws2014/Solution/src/test/java/de/hdm_stuttgart/mi/exam/MarkingTest.java
similarity index 100%
rename from Klausuren/Sd1/WS2014/Solution/src/test/java/de/hdm_stuttgart/mi/exam/MarkingTest.java
rename to Klausuren/Sd1/Ws2014/Solution/src/test/java/de/hdm_stuttgart/mi/exam/MarkingTest.java
diff --git a/Klausuren/Sd1/WS2014/Solution/src/test/java/de/hdm_stuttgart/mi/exam/ResultCollector.java b/Klausuren/Sd1/Ws2014/Solution/src/test/java/de/hdm_stuttgart/mi/exam/ResultCollector.java
similarity index 100%
rename from Klausuren/Sd1/WS2014/Solution/src/test/java/de/hdm_stuttgart/mi/exam/ResultCollector.java
rename to Klausuren/Sd1/Ws2014/Solution/src/test/java/de/hdm_stuttgart/mi/exam/ResultCollector.java
diff --git a/Klausuren/Sd1/WS2014/Solution/src/test/java/de/hdm_stuttgart/mi/exam/TestResult.java b/Klausuren/Sd1/Ws2014/Solution/src/test/java/de/hdm_stuttgart/mi/exam/TestResult.java
similarity index 100%
rename from Klausuren/Sd1/WS2014/Solution/src/test/java/de/hdm_stuttgart/mi/exam/TestResult.java
rename to Klausuren/Sd1/Ws2014/Solution/src/test/java/de/hdm_stuttgart/mi/exam/TestResult.java
diff --git a/Klausuren/Sd1/WS2014/Solution/src/test/java/de/hdm_stuttgart/sw1/klausur/test/Helper.java b/Klausuren/Sd1/Ws2014/Solution/src/test/java/de/hdm_stuttgart/sw1/klausur/test/Helper.java
similarity index 100%
rename from Klausuren/Sd1/WS2014/Solution/src/test/java/de/hdm_stuttgart/sw1/klausur/test/Helper.java
rename to Klausuren/Sd1/Ws2014/Solution/src/test/java/de/hdm_stuttgart/sw1/klausur/test/Helper.java
diff --git a/Klausuren/Sd1/WS2014/Solution/src/test/java/de/hdm_stuttgart/sw1/klausur/test/RunAllTests.java b/Klausuren/Sd1/Ws2014/Solution/src/test/java/de/hdm_stuttgart/sw1/klausur/test/RunAllTests.java
similarity index 100%
rename from Klausuren/Sd1/WS2014/Solution/src/test/java/de/hdm_stuttgart/sw1/klausur/test/RunAllTests.java
rename to Klausuren/Sd1/Ws2014/Solution/src/test/java/de/hdm_stuttgart/sw1/klausur/test/RunAllTests.java
diff --git a/Klausuren/Sd1/WS2014/Solution/src/test/java/de/hdm_stuttgart/sw1/klausur/test/TestAnzahlZiffernString.java b/Klausuren/Sd1/Ws2014/Solution/src/test/java/de/hdm_stuttgart/sw1/klausur/test/TestAnzahlZiffernString.java
similarity index 100%
rename from Klausuren/Sd1/WS2014/Solution/src/test/java/de/hdm_stuttgart/sw1/klausur/test/TestAnzahlZiffernString.java
rename to Klausuren/Sd1/Ws2014/Solution/src/test/java/de/hdm_stuttgart/sw1/klausur/test/TestAnzahlZiffernString.java
diff --git a/Klausuren/Sd1/WS2014/Solution/src/test/java/de/hdm_stuttgart/sw1/klausur/test/TestAnzahlZiffernStringArray.java b/Klausuren/Sd1/Ws2014/Solution/src/test/java/de/hdm_stuttgart/sw1/klausur/test/TestAnzahlZiffernStringArray.java
similarity index 100%
rename from Klausuren/Sd1/WS2014/Solution/src/test/java/de/hdm_stuttgart/sw1/klausur/test/TestAnzahlZiffernStringArray.java
rename to Klausuren/Sd1/Ws2014/Solution/src/test/java/de/hdm_stuttgart/sw1/klausur/test/TestAnzahlZiffernStringArray.java
diff --git a/Klausuren/Sd1/WS2014/Solution/src/test/java/de/hdm_stuttgart/sw1/klausur/test/TestFilterSortiere.java b/Klausuren/Sd1/Ws2014/Solution/src/test/java/de/hdm_stuttgart/sw1/klausur/test/TestFilterSortiere.java
similarity index 100%
rename from Klausuren/Sd1/WS2014/Solution/src/test/java/de/hdm_stuttgart/sw1/klausur/test/TestFilterSortiere.java
rename to Klausuren/Sd1/Ws2014/Solution/src/test/java/de/hdm_stuttgart/sw1/klausur/test/TestFilterSortiere.java
diff --git a/Klausuren/Sd1/WS2014/Solution/src/test/java/de/hdm_stuttgart/sw1/klausur/test/TestSummierteWortlaenge.java b/Klausuren/Sd1/Ws2014/Solution/src/test/java/de/hdm_stuttgart/sw1/klausur/test/TestSummierteWortlaenge.java
similarity index 100%
rename from Klausuren/Sd1/WS2014/Solution/src/test/java/de/hdm_stuttgart/sw1/klausur/test/TestSummierteWortlaenge.java
rename to Klausuren/Sd1/Ws2014/Solution/src/test/java/de/hdm_stuttgart/sw1/klausur/test/TestSummierteWortlaenge.java