From ae119d71e1c389a197acff1ef38aa652af5ae4da Mon Sep 17 00:00:00 2001
From: Martin Goik <goik@hdm-stuttgart.de>
Date: Mon, 7 Mar 2016 20:48:15 +0100
Subject: [PATCH] Sd1 Klausur

---
 Klausuren/Sd1/Ws2015/Exam/pom.xml             |  49 ++++++
 .../de/hdm_stuttgart/sw1/klausur/Helper.java  |  86 ++++++++++
 .../de/hdm_stuttgart/sw1/klausur/Spielen.java |  27 +++
 .../Ws2015/Exam/src/main/resources/log4j2.xml |  21 +++
 .../mi/bitte_ignorieren/Marking.java          |  14 ++
 .../mi/bitte_ignorieren/MarkingTest.java      |  29 ++++
 .../mi/bitte_ignorieren/ResultCollector.java  | 157 ++++++++++++++++++
 .../mi/bitte_ignorieren/TestResult.java       |  19 +++
 .../hdm_stuttgart/mi/runtests/AllTests.java   |   9 +
 .../mi/runtests/DetailedTestResults.java      |  21 +++
 .../mi/runtests/ReachedPoints.java            |  30 ++++
 .../sw1/klausur/test/Test_Helper.java         | 154 +++++++++++++++++
 .../klausur/test/Test_SpielNaechsteRunde.java | 109 ++++++++++++
 Klausuren/Sd1/Ws2015/Solution/Doc/a.xhtml     |  74 +++++++++
 Klausuren/Sd1/Ws2015/Solution/Doc/b.xhtml     |  89 ++++++++++
 .../Sd1/Ws2015/Solution/beschreibung.xhtml    | 138 +++++++++++++++
 Klausuren/Sd1/Ws2015/Solution/pom.xml         |  49 ++++++
 .../de/hdm_stuttgart/sw1/klausur/Helper.java  | 107 ++++++++++++
 .../de/hdm_stuttgart/sw1/klausur/Spielen.java |  61 +++++++
 .../Solution/src/main/resources/log4j2.xml    |  21 +++
 .../mi/bitte_ignorieren/Marking.java          |  14 ++
 .../mi/bitte_ignorieren/MarkingTest.java      |  29 ++++
 .../mi/bitte_ignorieren/ResultCollector.java  | 157 ++++++++++++++++++
 .../mi/bitte_ignorieren/TestResult.java       |  19 +++
 .../hdm_stuttgart/mi/runtests/AllTests.java   |   9 +
 .../mi/runtests/DetailedTestResults.java      |  21 +++
 .../mi/runtests/ReachedPoints.java            |  30 ++++
 .../sw1/klausur/test/Test_Helper.java         | 154 +++++++++++++++++
 .../klausur/test/Test_SpielNaechsteRunde.java | 109 ++++++++++++
 29 files changed, 1806 insertions(+)
 create mode 100644 Klausuren/Sd1/Ws2015/Exam/pom.xml
 create mode 100644 Klausuren/Sd1/Ws2015/Exam/src/main/java/de/hdm_stuttgart/sw1/klausur/Helper.java
 create mode 100644 Klausuren/Sd1/Ws2015/Exam/src/main/java/de/hdm_stuttgart/sw1/klausur/Spielen.java
 create mode 100644 Klausuren/Sd1/Ws2015/Exam/src/main/resources/log4j2.xml
 create mode 100644 Klausuren/Sd1/Ws2015/Exam/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/Marking.java
 create mode 100644 Klausuren/Sd1/Ws2015/Exam/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/MarkingTest.java
 create mode 100644 Klausuren/Sd1/Ws2015/Exam/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/ResultCollector.java
 create mode 100644 Klausuren/Sd1/Ws2015/Exam/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/TestResult.java
 create mode 100644 Klausuren/Sd1/Ws2015/Exam/src/test/java/de/hdm_stuttgart/mi/runtests/AllTests.java
 create mode 100644 Klausuren/Sd1/Ws2015/Exam/src/test/java/de/hdm_stuttgart/mi/runtests/DetailedTestResults.java
 create mode 100644 Klausuren/Sd1/Ws2015/Exam/src/test/java/de/hdm_stuttgart/mi/runtests/ReachedPoints.java
 create mode 100644 Klausuren/Sd1/Ws2015/Exam/src/test/java/de/hdm_stuttgart/sw1/klausur/test/Test_Helper.java
 create mode 100644 Klausuren/Sd1/Ws2015/Exam/src/test/java/de/hdm_stuttgart/sw1/klausur/test/Test_SpielNaechsteRunde.java
 create mode 100644 Klausuren/Sd1/Ws2015/Solution/Doc/a.xhtml
 create mode 100644 Klausuren/Sd1/Ws2015/Solution/Doc/b.xhtml
 create mode 100644 Klausuren/Sd1/Ws2015/Solution/beschreibung.xhtml
 create mode 100644 Klausuren/Sd1/Ws2015/Solution/pom.xml
 create mode 100644 Klausuren/Sd1/Ws2015/Solution/src/main/java/de/hdm_stuttgart/sw1/klausur/Helper.java
 create mode 100644 Klausuren/Sd1/Ws2015/Solution/src/main/java/de/hdm_stuttgart/sw1/klausur/Spielen.java
 create mode 100644 Klausuren/Sd1/Ws2015/Solution/src/main/resources/log4j2.xml
 create mode 100644 Klausuren/Sd1/Ws2015/Solution/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/Marking.java
 create mode 100644 Klausuren/Sd1/Ws2015/Solution/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/MarkingTest.java
 create mode 100644 Klausuren/Sd1/Ws2015/Solution/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/ResultCollector.java
 create mode 100644 Klausuren/Sd1/Ws2015/Solution/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/TestResult.java
 create mode 100644 Klausuren/Sd1/Ws2015/Solution/src/test/java/de/hdm_stuttgart/mi/runtests/AllTests.java
 create mode 100644 Klausuren/Sd1/Ws2015/Solution/src/test/java/de/hdm_stuttgart/mi/runtests/DetailedTestResults.java
 create mode 100644 Klausuren/Sd1/Ws2015/Solution/src/test/java/de/hdm_stuttgart/mi/runtests/ReachedPoints.java
 create mode 100644 Klausuren/Sd1/Ws2015/Solution/src/test/java/de/hdm_stuttgart/sw1/klausur/test/Test_Helper.java
 create mode 100644 Klausuren/Sd1/Ws2015/Solution/src/test/java/de/hdm_stuttgart/sw1/klausur/test/Test_SpielNaechsteRunde.java

diff --git a/Klausuren/Sd1/Ws2015/Exam/pom.xml b/Klausuren/Sd1/Ws2015/Exam/pom.xml
new file mode 100644
index 000000000..96765567d
--- /dev/null
+++ b/Klausuren/Sd1/Ws2015/Exam/pom.xml
@@ -0,0 +1,49 @@
+<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>sw1Exam</artifactId>
+	<version>0.8</version>
+	<packaging>jar</packaging>
+
+	<name>sw1ExamWs2016</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>
+		</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/Ws2015/Exam/src/main/java/de/hdm_stuttgart/sw1/klausur/Helper.java b/Klausuren/Sd1/Ws2015/Exam/src/main/java/de/hdm_stuttgart/sw1/klausur/Helper.java
new file mode 100644
index 000000000..e4e34d28d
--- /dev/null
+++ b/Klausuren/Sd1/Ws2015/Exam/src/main/java/de/hdm_stuttgart/sw1/klausur/Helper.java
@@ -0,0 +1,86 @@
+package de.hdm_stuttgart.sw1.klausur;
+
+public class Helper {
+	
+	/**
+	 * Durchsuche ein Array nach der Häufigkeit des Auftretens eines gegebenen Werts.
+	 * 
+	 * Beispiel: Der Wert 3 taucht im Array {1, -5, 3, 0, 3} zweifach auf.
+	 * 
+	 * Sonderfall: Das Array ist null oder leer, dann ist das Ergebnis 0
+	 * 
+	 * 
+	 * @param candidate Wert, dessen Häufigkeit im Array zu bestimmen ist
+	 * @param werte Werte, welche durchsucht werden
+	 * @return Die Häufigkeit des aufgetretenen Werts.
+	 */
+	static public int getHaeufigkeit(final int candidate, final int [] werte) {
+		
+		// Tip: Beachte die Sonderfälle und führe
+		// die Tests nach der Implementierung aus.
+		
+		return -14; // TODO: implementiere mich richtig!
+	}
+	
+	/**
+	 * Durchsuche ein Array nach aufeinanderfolgendem Auftreten identischer Werte und gebe ggf.
+	 * den Index des ersten Werts der ersten Gruppe zurück.
+	 * 
+	 *  Beispiel: Das Array {-4, 2, 3, 3, 3, -1, 7, 4, 4, 5} enthält zwei Gruppen benachbarter identischer Werte,
+	 *  nämlich {3, 3, 3} und {4, 4}. Da {3, 3, 3} die erste Gruppe ist, lautet der gesuchte Index 2.
+	 *  
+	 *  Falls keine Gruppe existiert, soll ein Wert kleiner 0 zurückgegeben werden.
+	 * 
+	 * @param werte Die zu durchsuchenden Werte
+	 * @return Index des Beginns der ersten gefundenen Gruppe, oder < 0, falls keine Gruppe vorhanden.
+	 */
+	static public int getErstenGruppenIndex(final int [] werte) {
+
+		// Tip: Führe die Tests nach der Implementierung aus.
+		
+		return -14; // TODO: implementiere mich richtig!
+	}
+	
+	/**
+	 * Wie oft tritt ein gegebenes Zeichen in einer Zeichenkette unter Ignorieren von Groß- und Kleinschreibung auf?
+	 * 
+	 * Beispiel: 'k' ist in "Klausur Softwareentwicklung" zweifach enthalten.
+	 * 
+	 * @param c Ein beliebiges Zeichen
+	 * @param s Eine beliebige Zeichenkette.
+	 * @return Die Anzahl des Auftretens von c in der Zeichenkette s ohne Beachtung von Groß- und Kleinschreibung.
+	 */
+	static public int getZeichenHaeufigkeit(final char c, final String s) {
+		// Tip: Führe die Tests nach der Implementierung aus.
+		
+		return -14; // TODO: implementiere mich richtig!
+	}
+	
+	
+	/**
+	 * Bildung der Schnittmenge zweier Wortmengen bei Beachtung von Groß/ und Kleinschreibung.
+	 * 
+	 * Beispiel:
+	 * first = {"Haus", "laufen"}, second = {"Urlaub", "Klausur", "Haus", "Esel"}
+	 * 
+	 * Die Schnittmenge von first und second lautet {"Haus"}
+	 * 
+	 * @param first Die erste Wortmenge
+	 * @param second Die zweite Wortmenge
+	 * @return Die Wortmenge des Durchschnitts beider Wortmengen.
+	 */
+	static public String[] schnittmenge(final String[] first, final String[] second) {
+
+		// Tips:
+		//
+		// 1. Man kann für jede Zeichenkette aus first alle Zeichenketten aus second auf Gleichheit
+		//    prüfen (String.equals, nicht '=='). Dies ergibt zwei verschachtelte Schleifen. 
+		//
+		// 2. Das String Array zur Rückgabe ist maximal so groß wie first. Lege zunächst ein ungefülltes
+		//    String[] Array dieser Größe an und fülle es mit den Elementen der Schnittmenge. Vor der Rückgabe
+		//    kann dann ein erneutes Umkopieren in ein neu zu erzeugendes Array passender Größe erfolgen.
+		//
+			
+		return new String[]{"Müll"}; // TODO: implementiere mich richtig!
+	}	
+}
diff --git a/Klausuren/Sd1/Ws2015/Exam/src/main/java/de/hdm_stuttgart/sw1/klausur/Spielen.java b/Klausuren/Sd1/Ws2015/Exam/src/main/java/de/hdm_stuttgart/sw1/klausur/Spielen.java
new file mode 100644
index 000000000..77baf25fc
--- /dev/null
+++ b/Klausuren/Sd1/Ws2015/Exam/src/main/java/de/hdm_stuttgart/sw1/klausur/Spielen.java
@@ -0,0 +1,27 @@
+package de.hdm_stuttgart.sw1.klausur;
+
+public class Spielen {
+
+
+	/**
+	 * Bestimme alle Spieler der nächsten Runde zusammen mit ihrem jeweiligen Punktestand.
+	 * 
+	 * @param aktuelleRunde Die Punkte aller Teilnehmer der aktuellen Runde.  
+	 * @return Die Punktestände aller Teilnehmer, welche mindestens so viele Punkte haben,
+	 * wie ihr(e) Nachbar(n) oder null, falls null == aktuelleRunde. Gibt es nur einen Teilnehmer,
+	 * so wird dieser zurückgeliefert.
+	 */
+	public static int[] getTeilnehmerNaechsteRunde(final int [] aktuelleRunde) {
+
+		// Tips:
+		// 1. Die Spieler sitzen kreisförmig. Ein Array hat dagegen ein Start und ein Ende.
+		//    Ãœberlege, welchen Index die jeweils rechten bzw. linken Nachbarn der Spieler
+		//    an den Enden des Arrays haben.
+		// 
+		// 2. Die Anzahl der zu ermittelnden Spieler ist zu Beginn unklar. Man kann aber zunächst ein
+		//    int[] Array maximaler Größe erzeugen, und aus diesem nach Eintrag aller "überlebenden"    
+		//    Spieler nochmals das endgültige Array mit korrekter Größe erzeugen.
+		
+		return new int[]{18}; // TODO: implementiere mich richtig!
+	}
+}
diff --git a/Klausuren/Sd1/Ws2015/Exam/src/main/resources/log4j2.xml b/Klausuren/Sd1/Ws2015/Exam/src/main/resources/log4j2.xml
new file mode 100644
index 000000000..e4bd6e388
--- /dev/null
+++ b/Klausuren/Sd1/Ws2015/Exam/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/Ws2015/Exam/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/Marking.java b/Klausuren/Sd1/Ws2015/Exam/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/Marking.java
new file mode 100644
index 000000000..b9b00c7cf
--- /dev/null
+++ b/Klausuren/Sd1/Ws2015/Exam/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/Ws2015/Exam/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/MarkingTest.java b/Klausuren/Sd1/Ws2015/Exam/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/MarkingTest.java
new file mode 100644
index 000000000..fe99181ad
--- /dev/null
+++ b/Klausuren/Sd1/Ws2015/Exam/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/Ws2015/Exam/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/ResultCollector.java b/Klausuren/Sd1/Ws2015/Exam/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/ResultCollector.java
new file mode 100644
index 000000000..63f497581
--- /dev/null
+++ b/Klausuren/Sd1/Ws2015/Exam/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/Ws2015/Exam/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/TestResult.java b/Klausuren/Sd1/Ws2015/Exam/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/TestResult.java
new file mode 100644
index 000000000..d32e9e9de
--- /dev/null
+++ b/Klausuren/Sd1/Ws2015/Exam/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/Ws2015/Exam/src/test/java/de/hdm_stuttgart/mi/runtests/AllTests.java b/Klausuren/Sd1/Ws2015/Exam/src/test/java/de/hdm_stuttgart/mi/runtests/AllTests.java
new file mode 100644
index 000000000..05883ffe6
--- /dev/null
+++ b/Klausuren/Sd1/Ws2015/Exam/src/test/java/de/hdm_stuttgart/mi/runtests/AllTests.java
@@ -0,0 +1,9 @@
+package de.hdm_stuttgart.mi.runtests;
+
+import org.junit.runner.JUnitCore;
+
+public class AllTests {
+  public static void main(String[] args) {
+    JUnitCore.runClasses(ReachedPoints.class);
+  }
+}
diff --git a/Klausuren/Sd1/Ws2015/Exam/src/test/java/de/hdm_stuttgart/mi/runtests/DetailedTestResults.java b/Klausuren/Sd1/Ws2015/Exam/src/test/java/de/hdm_stuttgart/mi/runtests/DetailedTestResults.java
new file mode 100644
index 000000000..6e6d58d54
--- /dev/null
+++ b/Klausuren/Sd1/Ws2015/Exam/src/test/java/de/hdm_stuttgart/mi/runtests/DetailedTestResults.java
@@ -0,0 +1,21 @@
+package de.hdm_stuttgart.mi.runtests;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+
+import de.hdm_stuttgart.mi.bitte_ignorieren.MarkingTest;
+
+
+public class DetailedTestResults extends ReachedPoints {
+	
+	@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/Ws2015/Exam/src/test/java/de/hdm_stuttgart/mi/runtests/ReachedPoints.java b/Klausuren/Sd1/Ws2015/Exam/src/test/java/de/hdm_stuttgart/mi/runtests/ReachedPoints.java
new file mode 100644
index 000000000..55976ae32
--- /dev/null
+++ b/Klausuren/Sd1/Ws2015/Exam/src/test/java/de/hdm_stuttgart/mi/runtests/ReachedPoints.java
@@ -0,0 +1,30 @@
+package de.hdm_stuttgart.mi.runtests;
+
+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_Helper;
+import de.hdm_stuttgart.sw1.klausur.test.Test_SpielNaechsteRunde;
+
+
+
+
+@RunWith(Suite.class)
+@Suite.SuiteClasses({
+	Test_Helper.class,
+	Test_SpielNaechsteRunde.class,
+})
+
+public class ReachedPoints {
+	
+	@BeforeClass public static void init() {
+		MarkingTest.provideExtraInfo = false;
+	}
+	
+	@AfterClass public static void showResults() {
+		System.out.println("myGoikKlausurMarker:" + MarkingTest.globalresultCollector.getReachedPoints());
+	}
+}
diff --git a/Klausuren/Sd1/Ws2015/Exam/src/test/java/de/hdm_stuttgart/sw1/klausur/test/Test_Helper.java b/Klausuren/Sd1/Ws2015/Exam/src/test/java/de/hdm_stuttgart/sw1/klausur/test/Test_Helper.java
new file mode 100644
index 000000000..2a2eda216
--- /dev/null
+++ b/Klausuren/Sd1/Ws2015/Exam/src/test/java/de/hdm_stuttgart/sw1/klausur/test/Test_Helper.java
@@ -0,0 +1,154 @@
+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.Helper.*;
+
+@SuppressWarnings({"javadoc"})
+public class Test_Helper  extends MarkingTest {
+
+	// Abschnitt getHaeufigkeit
+	@Test
+	public void test_getHaeufigkeitNullBehandlung () {
+		Assert.assertEquals(
+				0, 
+				getHaeufigkeit(3, null));
+	}
+
+	@Test
+	public void test_getHaeufigkeitLeerBehandlung () {
+		Assert.assertEquals(
+				0, 
+				getHaeufigkeit(3, new int[]{}));
+	}
+
+	@Test
+	public void test_getHaeufigkeitEinzelnPositiv () {
+		Assert.assertEquals(
+				1, 
+				getHaeufigkeit(3, new int[]{3}));
+	}
+
+	@Test
+	public void test_getHaeufigkeitDreiLinks() {
+		Assert.assertEquals(
+				1, 
+				getHaeufigkeit(2, new int[]{2, -1, 5}));
+	}
+
+	@Test
+	public void test_getHaeufigkeitDreiMitte() {
+		Assert.assertEquals(
+				1, 
+				getHaeufigkeit(2, new int[]{-1, 2, 15}));
+	}
+
+	@Test
+	public void test_getHaeufigkeitDreiRechts() {
+		Assert.assertEquals(
+				1, 
+				getHaeufigkeit(2, new int[]{-1, -1, 2}));
+	}
+
+	@Test
+	public void test_getHaeufigkeitDreiAlle() {
+		Assert.assertEquals(
+				3, 
+				getHaeufigkeit(2, new int[]{2, 2, 2}));
+	}
+
+	@Test
+	public void test_getHaeufigkeitZehn() {
+		Assert.assertEquals(
+				5, 
+				getHaeufigkeit(2, new int[]{2, 2, 2, -1, 5, 77, 22, 2, 11, 2}));
+	}
+	
+	// Abschnitt getErstenPaarIndex
+	
+	
+	@Test
+	public void test_getErstenPaarIndexLeer() {
+		Assert.assertTrue(getErstenGruppenIndex( new int[]{}) < 0);
+	}
+
+	@Test
+	public void test_getErstenPaarIndexSingle() {
+		Assert.assertTrue(getErstenGruppenIndex( new int[]{3}) < 0);
+	}
+
+	@Test
+	public void test_getErstenPaarIndexZweiNegativ() {
+		Assert.assertTrue(getErstenGruppenIndex( new int[]{3, -1}) < 0);
+	}
+
+	@Test
+	public void test_getErstenPaarIndexZweiPositiv() {
+		Assert.assertEquals(0, getErstenGruppenIndex( new int[]{-4, -4}));
+	}
+
+	@Test
+	public void test_getErstenPaarIndexA() {
+		Assert.assertTrue(getErstenGruppenIndex( new int[]{1, 2, 3, 4, 3, 2, 1}) < 0);
+	}
+
+	@Test
+	public void test_getErstenPaarIndexB() {
+		Assert.assertEquals(2, getErstenGruppenIndex( new int[]{-4, 2, 3, 3, 3, -1, 7, 4, 4, 5}));
+	}
+	
+
+	// Abschnitt getZeichenHaeufigkeit
+	public void test_getHaeufigkeitLeer() {
+		Assert.assertEquals(4, getZeichenHaeufigkeit('b', ""));
+	}
+	
+	@Test
+	public void test_getHaeufigkeitEinsPositiv() {
+		Assert.assertEquals(1, getZeichenHaeufigkeit('a', "Ein Anton"));
+	}
+	
+	@Test
+	public void test_getHaeufigkeitEinsNegativ() {
+		Assert.assertEquals(0, getZeichenHaeufigkeit('a', "Nix geht!"));
+	}
+	
+	@Test
+	public void test_getHaeufigkeitMehrfach() {
+			Assert.assertEquals(4, getZeichenHaeufigkeit('b', "Bald bleibt alles beim Alten!"));
+	}
+	
+	// Abschnitt schnittmenge
+	@Test
+	public void test_schnittmengeLeer1() {
+			Assert.assertArrayEquals(
+					new String[]{}, 
+					schnittmenge(new String[]{}, new String[]{}));
+	}
+		
+	@Test
+	public void test_schnittmengeLeer2() {
+			Assert.assertArrayEquals(
+					new String[]{}, 
+					schnittmenge(new String[]{"Bau"}, new String[]{"Urlaub", "Klausur", "Haus", "Esel"}));
+	}
+		
+	@Test
+	public void test_schnittmenge() {
+			Assert.assertArrayEquals(
+					new String[]{"Haus"}, 
+					schnittmenge(new String[]{"Haus", "laufen"}, new String[]{"Urlaub", "Klausur", "Haus", "Esel"}));
+	}
+		
+	@Test
+	public void test_schnittmengeAll() {
+		final String[] menge = new String[]{"eins", "zwei", "drei", "vier"};
+			Assert.assertArrayEquals(
+					menge, 
+					schnittmenge(menge, menge));
+	}
+		
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/Ws2015/Exam/src/test/java/de/hdm_stuttgart/sw1/klausur/test/Test_SpielNaechsteRunde.java b/Klausuren/Sd1/Ws2015/Exam/src/test/java/de/hdm_stuttgart/sw1/klausur/test/Test_SpielNaechsteRunde.java
new file mode 100644
index 000000000..1d76ce21c
--- /dev/null
+++ b/Klausuren/Sd1/Ws2015/Exam/src/test/java/de/hdm_stuttgart/sw1/klausur/test/Test_SpielNaechsteRunde.java
@@ -0,0 +1,109 @@
+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.Marking;
+import de.hdm_stuttgart.mi.bitte_ignorieren.MarkingTest;
+import static de.hdm_stuttgart.sw1.klausur.Spielen.getTeilnehmerNaechsteRunde;
+
+@SuppressWarnings({"javadoc"})
+public class Test_SpielNaechsteRunde  extends MarkingTest {
+
+	@Test
+	public void nullBehandlung () {
+		Assert.assertEquals(
+				null, 
+				getTeilnehmerNaechsteRunde(null));
+	}
+
+	@Test
+	public void einzelnerTeilnehmer () {
+		final int[] punkte= {44};
+		Assert.assertArrayEquals(
+				punkte, 
+				getTeilnehmerNaechsteRunde(punkte));
+	}
+	
+	@Test
+	public void zweiSpielerGleich () {
+		final int[] punkte= {2, 2};
+		Assert.assertArrayEquals(
+				punkte, 
+				getTeilnehmerNaechsteRunde(punkte));
+	}
+	
+	@Test
+	public void zweiSpielerUngleich () {
+		final int[] punkte= {2, 1};
+		Assert.assertArrayEquals(
+				new int[]{2}, 
+				getTeilnehmerNaechsteRunde(punkte));
+	}
+	
+	@Test
+	public void identischerPunktstand () {
+		final int[] punkte= {2, 2, 2};
+		Assert.assertArrayEquals(
+				punkte, 
+				getTeilnehmerNaechsteRunde(punkte));
+	}
+	
+	@Test
+	public void dreiSpielerZweiGewinnerLinks () {
+		final int[] 
+				aktuell = {3, 3, 2},
+				naechste= {3, 3} ;
+		Assert.assertArrayEquals(naechste, getTeilnehmerNaechsteRunde(aktuell));
+	}
+	
+	@Test
+	public void dreiSpielerZweiGewinnerRechts () {
+		final int[] 
+				aktuell = {2, 3, 3},
+				naechste= {3, 3} ;
+		Assert.assertArrayEquals(naechste, getTeilnehmerNaechsteRunde(aktuell));
+	}
+	
+	@Test
+	public void dreiSpielerLinks () {
+		final int[] 
+				aktuell = {3, 2, 2},
+				naechste= {3} ;
+		Assert.assertArrayEquals(naechste, getTeilnehmerNaechsteRunde(aktuell));
+	}
+	
+	@Test
+	public void dreiSpielerMitte () {
+		final int[] 
+				aktuell = {2, 3, 2},
+				naechste= {3} ;
+		Assert.assertArrayEquals(naechste, getTeilnehmerNaechsteRunde(aktuell));
+	}
+	
+	@Test
+	public void dreiSpielerRechts () {
+		final int[] 
+				aktuell = {2, 2, 3},
+				naechste= {3} ;
+		Assert.assertArrayEquals(naechste, getTeilnehmerNaechsteRunde(aktuell));
+	}
+	
+	@Test
+	public void vierSpieler () {
+		final int[] 
+				aktuell = {1,2,3,2},
+				naechste= {3} ;
+		Assert.assertArrayEquals(naechste, getTeilnehmerNaechsteRunde(aktuell));
+	}
+	
+	@Test
+	@Marking(points=2)
+	public void siebenSpielerDreiGewinner () {
+		final int[] 
+				aktuell = {5, 1, 1, 2, 1, 1, 5},
+				naechste= {5, 2, 5} ;
+		Assert.assertArrayEquals(naechste, getTeilnehmerNaechsteRunde(aktuell));
+	}
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/Ws2015/Solution/Doc/a.xhtml b/Klausuren/Sd1/Ws2015/Solution/Doc/a.xhtml
new file mode 100644
index 000000000..4495ea741
--- /dev/null
+++ b/Klausuren/Sd1/Ws2015/Solution/Doc/a.xhtml
@@ -0,0 +1,74 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE html>
+<html lang="de" xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <title></title>
+  </head>
+
+  <body><h1 id="t1">Eine Helper
+  Klasse</h1><h2>Beschreibung</h2><p>Implementierung von Hilfsmethoden. In
+  dieser Aufgaben sollen die in der Klasse
+  <code>de.hdm_stuttgart.sw1.klausur.Helper</code> bereits vorbereiteten Dummy
+  Methoden implementieren.</p><h3>Vorbereitung</h3><p>Entpacken Sie das Archiv
+  <a
+  href="../files/goik/Klausur/Ws2015/Sd1/cxadFFgdhJYY_c342Pq--QQas/exam.zip">exam.zip</a>
+  und importieren Sie den resultierenden Ordner <code>Exam</code> als <span
+  lang="en">Maven</span> Projekt in Ihren <span lang="en">Eclipse
+  Workspace</span>. Das <span lang="en">Package</span>
+  <code>de.hdm_stuttgart.mi.bitte_ignorieren</code> enthält Klassen, deren
+  Ausführung als Junit Test (Rechtsklick) Ihnen die bereits erreichten Punkte
+  anzeigen. Bitte beachten: Dazu zählen auch Tests zu nachfolgende Aufgaben,
+  welche Sie ggf. noch nicht bearbeitet
+  haben.</p><h3>Aufgabe</h3><p>Vervollständigen Sie die Implementierung aller
+  Methoden in der Klasse <code>de.hdm_stuttgart.sw1.klausur.Helper</code>. Die
+  Javadoc Kommentare der jeweiligen Methoden beschreiben das gewünschte
+  Verhalten. Lesen Sie diese bitte <strong>sehr genau</strong>, dies spart
+  meistens Zeit.</p><h3>Allgemeine Hinweise</h3><ul>
+      <li><p>Für jede Methode aus der Klasse
+      <code>de.hdm_stuttgart.sw1.klausur.Helper</code> stehen Ihnen in der
+      Testklasse <code>de.hdm_stuttgart.sw1.klausur.test.Test_Helper</code>
+      des Junit Test Zweigs <code>src/test/java</code> korrespondierende Tests
+      zur Verfügung. Nutzen Sie diese!</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, diese dafür aber vollständig
+      implementieren.</p></li>
+
+      <li>In manchen Methoden finden Sie im Rumpf (hoffentlich) hilfreiche
+      Kommentare. Sie können diese gerne ignorieren und eine völlig andere
+      Strategie wählen, haupsache die Unit Tests passen.</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 im Fall
+      fehlgeschlagener Testfälle, falls Sie das zugrundeliegende Problem nicht
+      unmittelbar lösen können.</p></li>
+    </ul><h3 id="upload">Hochladen Ihrer Lösung in das
+  Klausursystem</h3><p>Sobald Sie die Aufgabe beendet haben (und möglichst
+  alle Tests erfolgreich sind), exportieren Sie bitte Ihre Implementierung per
+  Rechtsklick im Package Explorer auf Ihr Eclipse Projekt. Sie können dann im
+  Kontextmenü sukzessive »Export--&gt;General--&gt;Archive File« auswählen und
+  einen auf <code>.zip</code> endenden Archivnamen festlegen. Laden Sie dieses
+  <code>.zip</code> Archiv in das Ilias Klausursystem hoch (unteres
+  Seitenende). Zur Kontrolle: Die hochgeladene .zip Datei muss im
+  Klausursystem sichtbar sein.</p><ul>
+      <li style="color: red;">Laden Sie keine Projekte mit Syntaxfehlern hoch,
+      diese werden nicht bewertet!</li>
+
+      <li style="color: red;">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.</li>
+
+      <li style="color: red;">Reservieren Sie ausreichend Zeit vor Klausurende
+      für den Vorgang des Hochladens. Projekte, welche sich lediglich auf dem
+      Arbeitsplatzrechner befinden, werden nicht gewertet.</li>
+    </ul><p>Alternativ können Sie auch gleich nachfolgende Aufgaben bearbeiten
+  und gemeinsam mit der Lösung der aktuellen Aufgabe in einem Archiv in dieser
+  Aufgabe 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.</p></body>
+</html>
diff --git a/Klausuren/Sd1/Ws2015/Solution/Doc/b.xhtml b/Klausuren/Sd1/Ws2015/Solution/Doc/b.xhtml
new file mode 100644
index 000000000..f754f9b42
--- /dev/null
+++ b/Klausuren/Sd1/Ws2015/Solution/Doc/b.xhtml
@@ -0,0 +1,89 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE html>
+<html lang="de" xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <title></title>
+  </head>
+
+  <body><h1 id="t1">Eine Spielerunde</h1><h2>Beschreibung</h2><p>Bildung einer
+  Auswahl von Spielern, welche die nächste Runde
+  erreichen.</p><h3>Vorbereitung</h3><p>So Sie dies nicht bereits in der
+  ersten Aufgabe erledigt haben, entpacken Sie das Archiv <a
+  href="../files/goik/Klausur/Ws2015/Sd1/cxadFFgdhJYY_c342Pq--QQas/exam.zip">exam.zip</a>
+  und importieren Sie den resultierenden Ordner <code>Exam</code> als <span
+  lang="en">Maven</span> Projekt in Ihren <span lang="en">Eclipse
+  Workspace</span>. Das <span lang="en">Package</span>
+  <code>de.hdm_stuttgart.mi.bitte_ignorieren</code> enthält Klassen, deren
+  Ausführung als Junit Test (Rechtsklick) Ihnen die bereits erreichten Punkte
+  anzeigen. Bitte beachten: Dazu zählen auch Tests zu anderen Aufgaben, welche
+  Sie ggf. noch nicht bearbeitet haben.</p><h2>Erläuterung des
+  Spiels</h2><p>Wir betrachten ein Spiel, bei dem eine gegebene Anzahl von
+  Soielern kreisförmig um einen runden Tisch angeordnet ist. Zumindest für
+  drei oder mehr Spieler hat jeder einen rechten und linken
+  Nachbarn.</p><p>Die Details des Soiels sind für diese Aufgabe unwichtig. Wir
+  gehen davon aus, dass jeder Spieler am Ende einer Runde individuell eine
+  ganzzahlige Anzahl von Punkten bekommt, z.B. 15.</p><p>Es geht nun um die
+  Frage, welche der Spieler auf Basis ihrer jeweiligen Punkte die nächste
+  Runde erreichen. Für drei oder mehr Soieler soll die folgende Regel
+  gelten:</p><ul>
+      <li>Nur wer mindestens soviele Punkte sowohl wie sein rechter als auch
+      sein linker Nachbar besitzt, erreicht die nächste Runde.</li>
+    </ul><p>Wenn beispielsweise alle Spieler eine identische Punktzahl haben,
+  kommen auch alle in die nächste Runde.</p><p>Die Idee ist, die Spieler
+  mitsamt Ihren Punkten als <code>int[]</code> Array zu modellieren. Wir
+  betrachten als Beispiel drei Spieler mit den Punkten 1, 3, und 1. Diese
+  werden als Array in der Form <code>int [] a = new int[] {1, 3, 1}</code>
+  abgebildet. (Im Beispiel würde nur der mittlere Spieler in die nächste Runde
+  kommen.)</p><p>Weitere Kommentare, insbesondere über Spezialfälle, wie einen
+  einzelnen Spieler, finden Sie in der Dummy Methode
+  <code>de.hdm_stuttgart.sw1.klausur.Spielen.getTeilnehmerNaechsteRunde(int[]
+  aktuelleRunde)</code>. </p><h3>Aufgabe</h3><p>Vervollständigen Sie die
+  Implementierung der Methode
+  <code>de.hdm_stuttgart.sw1.klausur.Spielen.getTeilnehmerNaechsteRunde(int[]
+  aktuelleRunde)</code>. Die enthaltenen (Javadoc) Kommentare beschreiben das
+  gewünschte Verhalten. Lesen Sie diese bitte <strong>sehr genau</strong>,
+  dies spart meistens Zeit.</p><h3>Allgemeine Hinweise</h3><ul>
+      <li><p>Für die Methode stehen Ihnen in der Testklasse
+      <code>de.hdm_stuttgart.sw1.klausur.test.Test_SpielNaechsteRunde</code>
+      des Junit Test Zweigs <code>src/test/java</code> korrespondierende Tests
+      zur Verfügung. Nutzen Sie diese!</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 auf möglichst viele erfolgreiche Tests
+      hinarbeiten.</p></li>
+
+      <li>Sie können die Kommetare zur möglichen Lösung gerne ignorieren und
+      eine völlig andere Strategie wählen, haupsache die Unit Tests
+      passen.</li>
+
+      <li><p>Tip: Nutzen Sie den Debugger oder logging Statements im Fall
+      fehlgeschlagener Testfälle, falls Sie das zugrundeliegende Problem nicht
+      unmittelbar lösen können.</p></li>
+    </ul><h3 id="upload">Hochladen Ihrer Lösung in das
+  Klausursystem</h3><p>Sobald Sie die Aufgabe beendet haben (und möglichst
+  alle Tests erfolgreich sind), exportieren Sie bitte Ihre Implementierung per
+  Rechtsklick im Package Explorer auf Ihr Eclipse Projekt. Sie können dann im
+  Kontextmenü sukzessive »Export--&gt;General--&gt;Archive File« auswählen und
+  einen auf <code>.zip</code> endenden Archivnamen festlegen. Laden Sie dieses
+  <code>.zip</code> Archiv über die erste Aufgabe in das Ilias Klausursystem
+  hoch (unteres Seitenende) und tragen Sie im Textfeld dieser Aufgabe
+  "bearbeitet" ein. Zur Kontrolle: Die hochgeladene .zip Datei muss im
+  Klausursystem sichtbar sein.</p><ul>
+      <li style="color: red;">Laden Sie keine Projekte mit Syntaxfehlern hoch,
+      diese werden nicht bewertet!</li>
+
+      <li style="color: red;">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.</li>
+
+      <li style="color: red;">Reservieren Sie ausreichend Zeit vor Klausurende
+      für den Vorgang des Hochladens. Projekte, welche sich lediglich auf dem
+      Arbeitsplatzrechner befinden, werden nicht gewertet.</li>
+    </ul><p>Alternativ können Sie auch gleich andere Aufgaben bearbeiten und
+  gemeinsam mit der Lösung der aktuellen Aufgabe in einem Archiv in die erste
+  Aufgabe 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.</p></body>
+</html>
diff --git a/Klausuren/Sd1/Ws2015/Solution/beschreibung.xhtml b/Klausuren/Sd1/Ws2015/Solution/beschreibung.xhtml
new file mode 100644
index 000000000..f261dcba1
--- /dev/null
+++ b/Klausuren/Sd1/Ws2015/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/Ws2015/Solution/pom.xml b/Klausuren/Sd1/Ws2015/Solution/pom.xml
new file mode 100644
index 000000000..3d911ddb9
--- /dev/null
+++ b/Klausuren/Sd1/Ws2015/Solution/pom.xml
@@ -0,0 +1,49 @@
+<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>sw1Solution</artifactId>
+	<version>0.9</version>
+	<packaging>jar</packaging>
+
+	<name>sw1Solution</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>
+		</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/Ws2015/Solution/src/main/java/de/hdm_stuttgart/sw1/klausur/Helper.java b/Klausuren/Sd1/Ws2015/Solution/src/main/java/de/hdm_stuttgart/sw1/klausur/Helper.java
new file mode 100644
index 000000000..f9906f242
--- /dev/null
+++ b/Klausuren/Sd1/Ws2015/Solution/src/main/java/de/hdm_stuttgart/sw1/klausur/Helper.java
@@ -0,0 +1,107 @@
+package de.hdm_stuttgart.sw1.klausur;
+
+import java.util.Arrays;
+
+public class Helper {
+	
+	/**
+	 * Durchsuche ein Array nach der Häufigkeit des Auftretens eines gegebenen Werts.
+	 * 
+	 * Beispiel: Der Wert 3 taucht im Array {1, -5, 3, 0, 3} zweifach auf.
+	 * 
+	 * Sonderfall: Das Array ist null oder leer, dann ist das Ergebnis 0
+	 * 
+	 * 
+	 * @param candidate Wert, dessen Häufigkeit im Array zu bestimmen ist
+	 * @param werte Werte, welche durchsucht werden
+	 * @return Die Häufigkeit des aufgetretenen Werts.
+	 */
+	static public int getHaeufigkeit(final int candidate, final int [] werte) {
+		
+		if (null == werte) {
+			return 0;
+		} else {
+			int count = 0;
+			for (final int w: werte) {
+				if (candidate == w) {
+					count++;
+				}
+			}
+			return count;
+		}
+	}
+	
+	/**
+	 * Durchsuche ein Array nach aufeinanderfolgendem Auftreten identischer Werte und gebe ggf.
+	 * den Index des ersten Werts der ersten Gruppe zurück.
+	 * 
+	 *  Beispiel: Das Array {-4, 2, 3, 3, 3, -1, 7, 4, 4, 5} enthält zwei Gruppen benachbarter identischer Werte,
+	 *  nämlich {3, 3, 3} und {4, 4}. Da {3, 3, 3} die erste Gruppe ist, lautet der gesuchte Index 2.
+	 *  
+	 *  Falls keine Gruppe existiert, soll ein Wert kleiner 0 zurückgegeben werden.
+	 * 
+	 * @param werte Die zu durchsuchenden Werte
+	 * @return Index des Beginns der ersten gefundenen Gruppe, oder < 0, falls keine Gruppe vorhanden.
+	 */
+	static public int getErstenGruppenIndex(final int [] werte) {
+		for (int i = 0; i < werte.length - 1; i++) {
+			if (werte[i] == werte[i + 1]) {
+				return i;
+			}
+		}
+		return -1;
+	}
+	
+	/**
+	 * Wie oft tritt ein gegebenes Zeichen in einer Zeichenkette unter Ignorieren von Groß- und Kleinschreibung auf?
+	 * 
+	 * Beispiel: 'k' ist in "Klausur Softwareentwicklung" zweifach enthalten.
+	 * 
+	 * @param c Ein beliebiges Zeichen
+	 * @param s Eine beliebige Zeichenkette.
+	 * @return Die Anzahl des Auftretens von c in der Zeichenkette s ohne Beachtung von Groß- und Kleinschreibung.
+	 */
+	static public int getZeichenHaeufigkeit(final char c, final String s) {
+		final char cLower = Character.toLowerCase(c);
+		int haeufigkeit = 0;
+		for (final char x: s.toLowerCase().toCharArray()){
+			if (cLower == x) {
+				haeufigkeit++;
+			}
+		}
+		return haeufigkeit;
+	}
+	
+	
+	/**
+	 * Bildung der Schnittmenge zweier Wortmengen bei Beachtung von Groß/ und Kleinschreibung.
+	 * 
+	 * Beispiel:
+	 * first = {"Haus", "laufen"}, second = {"Urlaub", "Klausur", "Haus", "Esel"}
+	 * 
+	 * Die Schnittmenge von first und second lautet {"Haus"}
+	 * 
+	 * @param first Die erste Wortmenge
+	 * @param second Die zweite Wortmenge
+	 * @return Die Wortmenge des Durchschnitts beider Wortmengen.
+	 */
+	static public String[] schnittmenge(final String[] first, final String[] second) {
+		
+		if (null == first ) {
+			return new String[]{};
+		} else if (null == second){
+			return new String[]{};
+		} else {
+			final String[] ret = new String[first.length];
+			int gefundenIndex = 0;
+			for (final String f: first) {
+				for (final String s: second) {
+					if (f.equals(s)) {
+						ret[gefundenIndex++] = f;
+					}
+				}
+			}
+			return Arrays.copyOf(ret, gefundenIndex);
+		}
+	}	
+}
diff --git a/Klausuren/Sd1/Ws2015/Solution/src/main/java/de/hdm_stuttgart/sw1/klausur/Spielen.java b/Klausuren/Sd1/Ws2015/Solution/src/main/java/de/hdm_stuttgart/sw1/klausur/Spielen.java
new file mode 100644
index 000000000..a98e14f65
--- /dev/null
+++ b/Klausuren/Sd1/Ws2015/Solution/src/main/java/de/hdm_stuttgart/sw1/klausur/Spielen.java
@@ -0,0 +1,61 @@
+package de.hdm_stuttgart.sw1.klausur;
+
+import java.util.Arrays;
+
+public class Spielen {
+
+
+	/**
+	 * Bestimme alle Spieler der nächsten Runde zusammen mit ihrem jeweiligen Punktestand.
+	 * 
+	 * @param aktuelleRunde Die Punkte aller Teilnehmer der aktuellen Runde.  
+	 * @return Die Punktestände aller Teilnehmer, welche mindestens so viele Punkte haben,
+	 * wie ihr(e) Nachbar(n) oder null, falls null == aktuelleRunde. Gibt es nur einen Teilnehmer,
+	 * so wird dieser zurückgeliefert.
+	 */
+	public static int[] getTeilnehmerNaechsteRunde(final int [] aktuelleRunde) {
+
+		if (null == aktuelleRunde) {
+			return null;
+		} else {
+			final int anzahlTeilnehmer = aktuelleRunde.length;
+			switch(anzahlTeilnehmer) {
+			case 0: return aktuelleRunde;
+			default:
+
+				int indexTeilnehmerNaechsteRunde = 0;
+				// Vermutlich zu groß, es sei denn, alle Teilnehmer kommen
+				// in die nächste Runde.
+				final int[] teilnehmerNaechsteRunde = new int[aktuelleRunde.length];
+				for (int i = 0; i < anzahlTeilnehmer; i++) {
+					final int punkte = aktuelleRunde[i];
+					if(
+							aktuelleRunde[getLinkenNachbarn(i, anzahlTeilnehmer)] <= punkte
+							&& aktuelleRunde[getRechtenNachbarn(i, anzahlTeilnehmer)] <= punkte){
+						teilnehmerNaechsteRunde[indexTeilnehmerNaechsteRunde++] = punkte;
+					}
+				}
+				// Reduziere auf tatsächliche Größe. Verzicht auf Arrays.copyOf
+				// möglich durch separate Schleife.
+				return Arrays.copyOf(teilnehmerNaechsteRunde, indexTeilnehmerNaechsteRunde);
+			}
+		}
+	}
+
+	static int getLinkenNachbarn(final int index, final int anzahlTeilnehmer) {
+		if (0 == index) {
+			return anzahlTeilnehmer - 1;
+		} else {
+			return index - 1;
+		}
+	}
+
+	static int getRechtenNachbarn(final int index, final int anzahlTeilnehmer) {
+
+		if (index == anzahlTeilnehmer - 1) {
+			return 0;
+		} else {
+			return index + 1;
+		}
+	}
+}
diff --git a/Klausuren/Sd1/Ws2015/Solution/src/main/resources/log4j2.xml b/Klausuren/Sd1/Ws2015/Solution/src/main/resources/log4j2.xml
new file mode 100644
index 000000000..e4bd6e388
--- /dev/null
+++ b/Klausuren/Sd1/Ws2015/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/Ws2015/Solution/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/Marking.java b/Klausuren/Sd1/Ws2015/Solution/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/Marking.java
new file mode 100644
index 000000000..b9b00c7cf
--- /dev/null
+++ b/Klausuren/Sd1/Ws2015/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/Ws2015/Solution/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/MarkingTest.java b/Klausuren/Sd1/Ws2015/Solution/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/MarkingTest.java
new file mode 100644
index 000000000..fe99181ad
--- /dev/null
+++ b/Klausuren/Sd1/Ws2015/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/Ws2015/Solution/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/ResultCollector.java b/Klausuren/Sd1/Ws2015/Solution/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/ResultCollector.java
new file mode 100644
index 000000000..63f497581
--- /dev/null
+++ b/Klausuren/Sd1/Ws2015/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/Ws2015/Solution/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/TestResult.java b/Klausuren/Sd1/Ws2015/Solution/src/test/java/de/hdm_stuttgart/mi/bitte_ignorieren/TestResult.java
new file mode 100644
index 000000000..d32e9e9de
--- /dev/null
+++ b/Klausuren/Sd1/Ws2015/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/Ws2015/Solution/src/test/java/de/hdm_stuttgart/mi/runtests/AllTests.java b/Klausuren/Sd1/Ws2015/Solution/src/test/java/de/hdm_stuttgart/mi/runtests/AllTests.java
new file mode 100644
index 000000000..05883ffe6
--- /dev/null
+++ b/Klausuren/Sd1/Ws2015/Solution/src/test/java/de/hdm_stuttgart/mi/runtests/AllTests.java
@@ -0,0 +1,9 @@
+package de.hdm_stuttgart.mi.runtests;
+
+import org.junit.runner.JUnitCore;
+
+public class AllTests {
+  public static void main(String[] args) {
+    JUnitCore.runClasses(ReachedPoints.class);
+  }
+}
diff --git a/Klausuren/Sd1/Ws2015/Solution/src/test/java/de/hdm_stuttgart/mi/runtests/DetailedTestResults.java b/Klausuren/Sd1/Ws2015/Solution/src/test/java/de/hdm_stuttgart/mi/runtests/DetailedTestResults.java
new file mode 100644
index 000000000..6e6d58d54
--- /dev/null
+++ b/Klausuren/Sd1/Ws2015/Solution/src/test/java/de/hdm_stuttgart/mi/runtests/DetailedTestResults.java
@@ -0,0 +1,21 @@
+package de.hdm_stuttgart.mi.runtests;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+
+import de.hdm_stuttgart.mi.bitte_ignorieren.MarkingTest;
+
+
+public class DetailedTestResults extends ReachedPoints {
+	
+	@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/Ws2015/Solution/src/test/java/de/hdm_stuttgart/mi/runtests/ReachedPoints.java b/Klausuren/Sd1/Ws2015/Solution/src/test/java/de/hdm_stuttgart/mi/runtests/ReachedPoints.java
new file mode 100644
index 000000000..55976ae32
--- /dev/null
+++ b/Klausuren/Sd1/Ws2015/Solution/src/test/java/de/hdm_stuttgart/mi/runtests/ReachedPoints.java
@@ -0,0 +1,30 @@
+package de.hdm_stuttgart.mi.runtests;
+
+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_Helper;
+import de.hdm_stuttgart.sw1.klausur.test.Test_SpielNaechsteRunde;
+
+
+
+
+@RunWith(Suite.class)
+@Suite.SuiteClasses({
+	Test_Helper.class,
+	Test_SpielNaechsteRunde.class,
+})
+
+public class ReachedPoints {
+	
+	@BeforeClass public static void init() {
+		MarkingTest.provideExtraInfo = false;
+	}
+	
+	@AfterClass public static void showResults() {
+		System.out.println("myGoikKlausurMarker:" + MarkingTest.globalresultCollector.getReachedPoints());
+	}
+}
diff --git a/Klausuren/Sd1/Ws2015/Solution/src/test/java/de/hdm_stuttgart/sw1/klausur/test/Test_Helper.java b/Klausuren/Sd1/Ws2015/Solution/src/test/java/de/hdm_stuttgart/sw1/klausur/test/Test_Helper.java
new file mode 100644
index 000000000..2a2eda216
--- /dev/null
+++ b/Klausuren/Sd1/Ws2015/Solution/src/test/java/de/hdm_stuttgart/sw1/klausur/test/Test_Helper.java
@@ -0,0 +1,154 @@
+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.Helper.*;
+
+@SuppressWarnings({"javadoc"})
+public class Test_Helper  extends MarkingTest {
+
+	// Abschnitt getHaeufigkeit
+	@Test
+	public void test_getHaeufigkeitNullBehandlung () {
+		Assert.assertEquals(
+				0, 
+				getHaeufigkeit(3, null));
+	}
+
+	@Test
+	public void test_getHaeufigkeitLeerBehandlung () {
+		Assert.assertEquals(
+				0, 
+				getHaeufigkeit(3, new int[]{}));
+	}
+
+	@Test
+	public void test_getHaeufigkeitEinzelnPositiv () {
+		Assert.assertEquals(
+				1, 
+				getHaeufigkeit(3, new int[]{3}));
+	}
+
+	@Test
+	public void test_getHaeufigkeitDreiLinks() {
+		Assert.assertEquals(
+				1, 
+				getHaeufigkeit(2, new int[]{2, -1, 5}));
+	}
+
+	@Test
+	public void test_getHaeufigkeitDreiMitte() {
+		Assert.assertEquals(
+				1, 
+				getHaeufigkeit(2, new int[]{-1, 2, 15}));
+	}
+
+	@Test
+	public void test_getHaeufigkeitDreiRechts() {
+		Assert.assertEquals(
+				1, 
+				getHaeufigkeit(2, new int[]{-1, -1, 2}));
+	}
+
+	@Test
+	public void test_getHaeufigkeitDreiAlle() {
+		Assert.assertEquals(
+				3, 
+				getHaeufigkeit(2, new int[]{2, 2, 2}));
+	}
+
+	@Test
+	public void test_getHaeufigkeitZehn() {
+		Assert.assertEquals(
+				5, 
+				getHaeufigkeit(2, new int[]{2, 2, 2, -1, 5, 77, 22, 2, 11, 2}));
+	}
+	
+	// Abschnitt getErstenPaarIndex
+	
+	
+	@Test
+	public void test_getErstenPaarIndexLeer() {
+		Assert.assertTrue(getErstenGruppenIndex( new int[]{}) < 0);
+	}
+
+	@Test
+	public void test_getErstenPaarIndexSingle() {
+		Assert.assertTrue(getErstenGruppenIndex( new int[]{3}) < 0);
+	}
+
+	@Test
+	public void test_getErstenPaarIndexZweiNegativ() {
+		Assert.assertTrue(getErstenGruppenIndex( new int[]{3, -1}) < 0);
+	}
+
+	@Test
+	public void test_getErstenPaarIndexZweiPositiv() {
+		Assert.assertEquals(0, getErstenGruppenIndex( new int[]{-4, -4}));
+	}
+
+	@Test
+	public void test_getErstenPaarIndexA() {
+		Assert.assertTrue(getErstenGruppenIndex( new int[]{1, 2, 3, 4, 3, 2, 1}) < 0);
+	}
+
+	@Test
+	public void test_getErstenPaarIndexB() {
+		Assert.assertEquals(2, getErstenGruppenIndex( new int[]{-4, 2, 3, 3, 3, -1, 7, 4, 4, 5}));
+	}
+	
+
+	// Abschnitt getZeichenHaeufigkeit
+	public void test_getHaeufigkeitLeer() {
+		Assert.assertEquals(4, getZeichenHaeufigkeit('b', ""));
+	}
+	
+	@Test
+	public void test_getHaeufigkeitEinsPositiv() {
+		Assert.assertEquals(1, getZeichenHaeufigkeit('a', "Ein Anton"));
+	}
+	
+	@Test
+	public void test_getHaeufigkeitEinsNegativ() {
+		Assert.assertEquals(0, getZeichenHaeufigkeit('a', "Nix geht!"));
+	}
+	
+	@Test
+	public void test_getHaeufigkeitMehrfach() {
+			Assert.assertEquals(4, getZeichenHaeufigkeit('b', "Bald bleibt alles beim Alten!"));
+	}
+	
+	// Abschnitt schnittmenge
+	@Test
+	public void test_schnittmengeLeer1() {
+			Assert.assertArrayEquals(
+					new String[]{}, 
+					schnittmenge(new String[]{}, new String[]{}));
+	}
+		
+	@Test
+	public void test_schnittmengeLeer2() {
+			Assert.assertArrayEquals(
+					new String[]{}, 
+					schnittmenge(new String[]{"Bau"}, new String[]{"Urlaub", "Klausur", "Haus", "Esel"}));
+	}
+		
+	@Test
+	public void test_schnittmenge() {
+			Assert.assertArrayEquals(
+					new String[]{"Haus"}, 
+					schnittmenge(new String[]{"Haus", "laufen"}, new String[]{"Urlaub", "Klausur", "Haus", "Esel"}));
+	}
+		
+	@Test
+	public void test_schnittmengeAll() {
+		final String[] menge = new String[]{"eins", "zwei", "drei", "vier"};
+			Assert.assertArrayEquals(
+					menge, 
+					schnittmenge(menge, menge));
+	}
+		
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/Ws2015/Solution/src/test/java/de/hdm_stuttgart/sw1/klausur/test/Test_SpielNaechsteRunde.java b/Klausuren/Sd1/Ws2015/Solution/src/test/java/de/hdm_stuttgart/sw1/klausur/test/Test_SpielNaechsteRunde.java
new file mode 100644
index 000000000..1d76ce21c
--- /dev/null
+++ b/Klausuren/Sd1/Ws2015/Solution/src/test/java/de/hdm_stuttgart/sw1/klausur/test/Test_SpielNaechsteRunde.java
@@ -0,0 +1,109 @@
+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.Marking;
+import de.hdm_stuttgart.mi.bitte_ignorieren.MarkingTest;
+import static de.hdm_stuttgart.sw1.klausur.Spielen.getTeilnehmerNaechsteRunde;
+
+@SuppressWarnings({"javadoc"})
+public class Test_SpielNaechsteRunde  extends MarkingTest {
+
+	@Test
+	public void nullBehandlung () {
+		Assert.assertEquals(
+				null, 
+				getTeilnehmerNaechsteRunde(null));
+	}
+
+	@Test
+	public void einzelnerTeilnehmer () {
+		final int[] punkte= {44};
+		Assert.assertArrayEquals(
+				punkte, 
+				getTeilnehmerNaechsteRunde(punkte));
+	}
+	
+	@Test
+	public void zweiSpielerGleich () {
+		final int[] punkte= {2, 2};
+		Assert.assertArrayEquals(
+				punkte, 
+				getTeilnehmerNaechsteRunde(punkte));
+	}
+	
+	@Test
+	public void zweiSpielerUngleich () {
+		final int[] punkte= {2, 1};
+		Assert.assertArrayEquals(
+				new int[]{2}, 
+				getTeilnehmerNaechsteRunde(punkte));
+	}
+	
+	@Test
+	public void identischerPunktstand () {
+		final int[] punkte= {2, 2, 2};
+		Assert.assertArrayEquals(
+				punkte, 
+				getTeilnehmerNaechsteRunde(punkte));
+	}
+	
+	@Test
+	public void dreiSpielerZweiGewinnerLinks () {
+		final int[] 
+				aktuell = {3, 3, 2},
+				naechste= {3, 3} ;
+		Assert.assertArrayEquals(naechste, getTeilnehmerNaechsteRunde(aktuell));
+	}
+	
+	@Test
+	public void dreiSpielerZweiGewinnerRechts () {
+		final int[] 
+				aktuell = {2, 3, 3},
+				naechste= {3, 3} ;
+		Assert.assertArrayEquals(naechste, getTeilnehmerNaechsteRunde(aktuell));
+	}
+	
+	@Test
+	public void dreiSpielerLinks () {
+		final int[] 
+				aktuell = {3, 2, 2},
+				naechste= {3} ;
+		Assert.assertArrayEquals(naechste, getTeilnehmerNaechsteRunde(aktuell));
+	}
+	
+	@Test
+	public void dreiSpielerMitte () {
+		final int[] 
+				aktuell = {2, 3, 2},
+				naechste= {3} ;
+		Assert.assertArrayEquals(naechste, getTeilnehmerNaechsteRunde(aktuell));
+	}
+	
+	@Test
+	public void dreiSpielerRechts () {
+		final int[] 
+				aktuell = {2, 2, 3},
+				naechste= {3} ;
+		Assert.assertArrayEquals(naechste, getTeilnehmerNaechsteRunde(aktuell));
+	}
+	
+	@Test
+	public void vierSpieler () {
+		final int[] 
+				aktuell = {1,2,3,2},
+				naechste= {3} ;
+		Assert.assertArrayEquals(naechste, getTeilnehmerNaechsteRunde(aktuell));
+	}
+	
+	@Test
+	@Marking(points=2)
+	public void siebenSpielerDreiGewinner () {
+		final int[] 
+				aktuell = {5, 1, 1, 2, 1, 1, 5},
+				naechste= {5, 2, 5} ;
+		Assert.assertArrayEquals(naechste, getTeilnehmerNaechsteRunde(aktuell));
+	}
+}
\ No newline at end of file
-- 
GitLab