diff --git a/Klausuren/Sd1/2017Summer/Exam/pom.xml b/Klausuren/Sd1/2017Summer/Exam/pom.xml
new file mode 100644
index 0000000000000000000000000000000000000000..141cc934f28144ee0bccb32b271e21326abd5539
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Exam/pom.xml
@@ -0,0 +1,94 @@
+<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.mi.sd1</groupId>
+ <artifactId>sd1_2017sommer_exam</artifactId>
+ <version>0.9</version>
+ <packaging>jar</packaging>
+
+ <name>sd1_2017sommer_exam</name>
+
+ <url>http://www.mi.hdm-stuttgart.de/freedocs/topic/de.hdm_stuttgart.mi.lectures/sd1SectUsingMaven.html</url>
+
+ <properties>
+ <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+ </properties>
+
+ <repositories>
+ <repository>
+ <id>hdm-mi-internal-maven-repo</id>
+ <url>https://maven.mi.hdm-stuttgart.de/artifacts</url>
+ </repository>
+ </repositories>
+
+
+ <dependencies>
+ <dependency>
+ <groupId>junit</groupId>
+ <artifactId>junit</artifactId>
+ <version>4.12</version>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.apache.logging.log4j</groupId>
+ <artifactId>log4j-core</artifactId>
+ <version>2.6</version>
+ </dependency>
+
+ <dependency>
+ <groupId>de.hdm_stuttgart.mi.exam</groupId>
+ <artifactId>unitmarking</artifactId>
+ <version>0.9</version>
+ </dependency>
+
+ </dependencies>
+
+ <build>
+ <plugins>
+
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-compiler-plugin</artifactId>
+ <version>3.5.1</version>
+ <configuration>
+ <source>1.8</source>
+ <target>1.8</target>
+ </configuration>
+ </plugin>
+
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-javadoc-plugin</artifactId>
+ <version>2.10.3</version>
+ <configuration />
+ </plugin>
+
+ <plugin>
+ <artifactId>maven-assembly-plugin</artifactId>
+ <version>2.3</version>
+ <configuration>
+ <descriptor>src/main/assembly/assembly.xml</descriptor>
+ </configuration>
+ <executions>
+ <execution>
+ <id>make-assembly</id>
+ <phase>package</phase>
+ <goals>
+ <goal>single</goal>
+ </goals>
+ <configuration>
+ <archive>
+ <manifest>
+ <mainClass>de.hdm_stuttgart.mi.sd1.test.ShowReachedPoints</mainClass>
+ </manifest>
+ </archive>
+ </configuration>
+ </execution>
+ </executions>
+ </plugin>
+
+ </plugins>
+ </build>
+</project>
diff --git a/Klausuren/Sd1/2017Summer/Exam/src/main/assembly/assembly.xml b/Klausuren/Sd1/2017Summer/Exam/src/main/assembly/assembly.xml
new file mode 100644
index 0000000000000000000000000000000000000000..1a2cd6054a519cef9fe38484b72ae28aba730bc5
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Exam/src/main/assembly/assembly.xml
@@ -0,0 +1,36 @@
+<assembly
+ xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.3"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.3 http://maven.apache.org/xsd/assembly-1.1.3.xsd">
+ <id>fat-tests</id>
+ <formats>
+ <format>jar</format>
+ </formats>
+ <includeBaseDirectory>false</includeBaseDirectory>
+ <dependencySets>
+ <dependencySet>
+ <outputDirectory>/</outputDirectory>
+ <useProjectArtifact>true</useProjectArtifact>
+ <unpack>true</unpack>
+ <scope>test</scope>
+ </dependencySet>
+ </dependencySets>
+ <fileSets>
+ <fileSet>
+ <directory>${project.build.directory}/test-classes</directory>
+ <outputDirectory>/</outputDirectory>
+ <includes>
+ <include>**/*.class</include>
+ </includes>
+ <useDefaultExcludes>true</useDefaultExcludes>
+ </fileSet>
+ <fileSet>
+ <directory>${project.build.directory}/classes</directory>
+ <outputDirectory>/</outputDirectory>
+ <includes>
+ <include>**/*.class</include>
+ </includes>
+ <useDefaultExcludes>true</useDefaultExcludes>
+ </fileSet>
+ </fileSets>
+</assembly>
diff --git a/Klausuren/Sd1/2017Summer/Exam/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/HandyAbrechnung.java b/Klausuren/Sd1/2017Summer/Exam/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/HandyAbrechnung.java
new file mode 100644
index 0000000000000000000000000000000000000000..646704c8eb9c555dc5a36e5934f2b3e1406d2a42
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Exam/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/HandyAbrechnung.java
@@ -0,0 +1,41 @@
+package de.hdm_stuttgart.mi.sd1.aufgabe1;
+
+/**
+ * Monatliche Abrechnung von Handykosten. Es gelten folgende Regeln:
+ *
+ */
+public class HandyAbrechnung {
+
+ /**
+ * Minutenkosten Inland in Euro-Cent.
+ */
+ static public final int inlandPreisProMinute = 9;
+
+ /**
+ * Minutenkosten Ausland (Roaming) in Euro-Cent.
+ */
+ static public final int auslandPreisProMinute = 89;
+
+ /**
+ * Anzahl der kostenlosen Freiminuten für Inlandsgespräche.
+ */
+ static public final int freiminutenInland = 100;
+
+ /**
+ * @param inlandMinuten Anzahl der im Abrechnungszeitraum telefonierten Minuten im Inland.
+ *
+ * @param auslandMinuten Anzahl der im Abrechnungszeitraum telefonierten Minuten im Ausland (Roaming).
+ *
+ * @return Zu zahlender Betrag in Cent. Es gelten folgende Regeln:
+ * <ul>
+ * <li>Von den Inlandsminuten werden zunächst die Freiminuten {@link #freiminutenInland} abgezogen. Bleiben
+ * dann noch Gesprächsminuten übrig, so werden diese mit {@link #inlandPreisProMinute} berechnet.</li>
+ *
+ * <li>Auslandsminuten werden gemäß {@link #auslandPreisProMinute} berechnet.</li>
+ * </ul>
+ *
+ */
+ public static int getMonatskosten (final int inlandMinuten, final int auslandMinuten) {
+ return 12345; // TODO: Implementiere mich korrekt!
+ }
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2017Summer/Exam/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/Helper.java b/Klausuren/Sd1/2017Summer/Exam/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/Helper.java
new file mode 100644
index 0000000000000000000000000000000000000000..62cbd9b6b835842923a2793c72f6f51086076f47
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Exam/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/Helper.java
@@ -0,0 +1,69 @@
+package de.hdm_stuttgart.mi.sd1.aufgabe1;
+
+/**
+ * Hilfsmethoden.
+ *
+ */
+public class Helper {
+
+ /**
+ * Spezialwert: Es gibt keinen Index mit den geforderten Eigenschaften. Dies ist konsistent, da ein
+ * »echter« Arrayindex mindestens den Wert 0 haben muss.
+ */
+ static public final int INDEX_NOEXIST = -1;
+
+
+ /**
+ * Erzeuge in Abhängigkeit vom übergebenen Wert eine Zeichenkette.
+ *
+ * @param n Der bestimmende Eingangswert.
+ *
+ * @return In Abhängigkeit vom Eingangswert:
+ *
+ * <ul>
+ * <li>"Toll", falls der Eingangswert durch 3 aber nicht durch 5 teilbar ist.</li>
+ * <li>"Super", falls der Eingangswert durch 5, aber nicht durch 3 teilbar ist.</li>
+ * <li>Der Zahlenwert als String (z.B. "7"), falls der Wert weder durch 3 noch durch 5 teilbar ist.</li>
+ * <li>"Supertoll", falls der Eingangswert sowohl durch 3 als auch durch 5 teilbar ist.</li>
+ * </ul>
+ */
+ static public String getSuperToll(int n) {
+ return "Ziemlicher Unsinn";// TODO: Implementiere mich korrekt!
+ }
+
+ /**
+ * <p>Der Index des ersten Arrayelements, welches echt größer ist als
+ * die Summe aller Vorgänger.</p>
+ *
+ * <p>Beispiel: Im Array {-1, 2, 1, 5, -3, 22} ist der Index »3« zum Wert 5 gesucht,
+ * da der zugehörige Arraywert »5« noch vor der »22« größer wird, als die Summe
+ * -1 + 2 + 1 == 2 seiner Vorgänger.</p>
+ *
+ * @param werte null oder ein beliebiges Array aus Ganzzahlen.
+ *
+ * @return Falls das Array null ist, weniger als zwei Elemente enthält oder es keinen Index mit der
+ * geforderten Eigenschaft gibt, wird der
+ * Spezialwert {@link #INDEX_NOEXIST} zurückgegeben. Ansonsten der Index des ersten gefundenen Werts
+ * gemäß Beschreibung.
+ *
+ */
+ static public int maxVorgaenger(final int[] werte) {
+ return 12345; // TODO: Implementiere mich korrekt!
+ }
+
+ /**
+ * Finde das n-te ungerade Element einer Wertefolge.
+ *
+ * <p>Beispiel: Im Array {3, 2, 0, 1, 4} ist der Wert »1« an der Indexposition »3« das zweite
+ * ungerade Element.</p>
+ *
+ * @param werte Die zu durchsuchenden Werte. Alle Werte sind von null verschieden.
+ * @param n Die gewünschte Position, Start bei 1.
+ *
+ * @return Den Index des n-ten ungeraden Wertes falls es mindestens n ungerade Werte gibt, ansonsten
+ {@link #INDEX_NOEXIST}.
+ */
+ static public int getNtesUngeradesElement(final int[] werte, final int n) {
+ return 12345; // TODO: Implementiere mich korrekt!
+ }
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2017Summer/Exam/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/StringHaeufigkeiten.java b/Klausuren/Sd1/2017Summer/Exam/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/StringHaeufigkeiten.java
new file mode 100644
index 0000000000000000000000000000000000000000..dee8b4b28840fec1f5b4f33553e4919e53466546
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Exam/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/StringHaeufigkeiten.java
@@ -0,0 +1,28 @@
+package de.hdm_stuttgart.mi.sd1.aufgabe1;
+
+/**
+ * <p>Betragsdifferenzen von Zahlenfolgen.</p>
+ *
+ */
+public class StringHaeufigkeiten {
+ /**
+ * <p>Wie oft ist eine Zeichenkette in einem vorgegebenen String enthalten?</p>
+ *
+ * <p>Beispiele:</p>
+ *
+ * <ul>
+ * <li>"in" tritt im String "in innerer Windeseile" dreifach auf.</li>
+ * <li> "aua" tritt in "auaua" einmal (nicht doppelt!) auf.</li>
+ * </ul>
+ * @param vorgegeben Der zu durchsuchende String. Die Werte null und leere Zeichenkette ("") sind
+ * ausgeschlossen.
+ * @param enthalten Der potentiell mehrfach enthaltene Teil- String. Der Wert null ist ausgeschlossen.
+ * @return Anzahl des Auftretens des enthaltenen im vorgegebenen String.
+ *
+ * Hinweis: Die Methode {@link String#indexOf(String, int)} leistet gute Dienste.
+ *
+ */
+ static public int getAnzahlAuftreten (final String vorgegeben, final String enthalten) {
+ return 12345; // TODO: Implementiere mich korrekt!
+ }
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2017Summer/Exam/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe2/Ersatzteil.java b/Klausuren/Sd1/2017Summer/Exam/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe2/Ersatzteil.java
new file mode 100644
index 0000000000000000000000000000000000000000..f41c117cfe2847fcc99cabf6b8b7d90e026f9705
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Exam/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe2/Ersatzteil.java
@@ -0,0 +1,18 @@
+package de.hdm_stuttgart.mi.sd1.aufgabe2;
+
+/**
+ * <p>Ersatzteile.</p>
+ *
+ */
+public class Ersatzteil {
+
+ /**
+ * Neues Ersatzteil mit Teilenummer und informeller Bezeichnung
+ *
+ * @param teilenummer
+ * @param bezeichnung
+ */
+ public Ersatzteil(final int teilenummer, final String bezeichnung) {
+ // TODO: Implementiere mich!
+ }
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2017Summer/Exam/src/main/resources/log4j2.xml b/Klausuren/Sd1/2017Summer/Exam/src/main/resources/log4j2.xml
new file mode 100644
index 0000000000000000000000000000000000000000..130f87a144c4eb0107a846e580c8fa7f5e819fc1
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/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="de.hdm_stuttgart.mi.sd1.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/2017Summer/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/ShowReachedPoints.java b/Klausuren/Sd1/2017Summer/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/ShowReachedPoints.java
new file mode 100644
index 0000000000000000000000000000000000000000..5c0e3efcfa4faabc1633b3f91c7cd8ad8c4ebc0c
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/ShowReachedPoints.java
@@ -0,0 +1,25 @@
+package de.hdm_stuttgart.mi.sd1.test;
+
+import de.hdm_stuttgart.mi.exam.unitmarking.RunTests;
+import de.hdm_stuttgart.mi.sd1.test.aufgabe1.Test_HandyAbrechnung;
+import de.hdm_stuttgart.mi.sd1.test.aufgabe1.Test_Helper;
+import de.hdm_stuttgart.mi.sd1.test.aufgabe1.Test_StringHaeufigkeiten;
+import de.hdm_stuttgart.mi.sd1.test.aufgabe2.Test_Ersatzteil;
+
+public class ShowReachedPoints {
+
+ /**
+ * Execution reveals the number of reached points.
+ *
+ * @param args Unused
+ */
+ public static void main(String[] args) {
+ RunTests.exec(
+ "Aufgabe 1"
+ , Test_HandyAbrechnung.class
+ , Test_Helper.class
+ , Test_StringHaeufigkeiten.class);
+
+ RunTests.exec("Aufgabe 2", Test_Ersatzteil.class);
+ }
+}
diff --git a/Klausuren/Sd1/2017Summer/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_HandyAbrechnung.java b/Klausuren/Sd1/2017Summer/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_HandyAbrechnung.java
new file mode 100644
index 0000000000000000000000000000000000000000..5c5f816b5d653e21badb00f1452a0e17ef78cc44
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_HandyAbrechnung.java
@@ -0,0 +1,76 @@
+package de.hdm_stuttgart.mi.sd1.test.aufgabe1;
+
+import org.junit.Assert;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runners.MethodSorters;
+
+import de.hdm_stuttgart.mi.exam.unitmarking.ExaminationTestDefaults;
+import de.hdm_stuttgart.mi.exam.unitmarking.Marking;
+import de.hdm_stuttgart.mi.sd1.aufgabe1.HandyAbrechnung;
+
+/**
+ * <p>Testen des Auftretens eines Teil-String in einem vorgegebenen String.</p>
+ *
+ */
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class Test_HandyAbrechnung extends ExaminationTestDefaults {
+
+ /**
+ * Nur Inland, in Freigrenze
+ */
+ @Test
+ @Marking(points=1)
+ public void test_200() {
+ Assert.assertEquals(0, HandyAbrechnung.getMonatskosten(0, 0));
+ Assert.assertEquals(0, HandyAbrechnung.getMonatskosten(99, 0));
+ Assert.assertEquals(0, HandyAbrechnung.getMonatskosten(100, 0));
+ }
+
+ /**
+ * nur Inland, Ãœber Freigrenze
+ */
+ @Test
+ @Marking(points=2)
+ public void test_220() {
+
+ Assert.assertEquals(HandyAbrechnung.inlandPreisProMinute, HandyAbrechnung.getMonatskosten(101, 0));
+ Assert.assertEquals(7 * HandyAbrechnung.inlandPreisProMinute, HandyAbrechnung.getMonatskosten(107, 0));
+ Assert.assertEquals(123 * HandyAbrechnung.inlandPreisProMinute, HandyAbrechnung.getMonatskosten(223, 0));
+ }
+
+ /**
+ * Nur Ausland
+ */
+ @Test
+ @Marking(points=2)
+ public void test_240() {
+ Assert.assertEquals(HandyAbrechnung.auslandPreisProMinute, HandyAbrechnung.getMonatskosten(0, 1));
+ Assert.assertEquals(22 * HandyAbrechnung.auslandPreisProMinute, HandyAbrechnung.getMonatskosten(0, 22));
+ }
+
+ /**
+ * Kombiniert Inland unter Freigrenze + Ausland
+ */
+ @Test
+ @Marking(points=2)
+ public void test_260() {
+ Assert.assertEquals(14 * HandyAbrechnung.auslandPreisProMinute, HandyAbrechnung.getMonatskosten(99, 14));
+ Assert.assertEquals(15 * HandyAbrechnung.auslandPreisProMinute, HandyAbrechnung.getMonatskosten(100, 15));
+ }
+
+ /**
+ * Kombiniert Inland über Freigrenze + Ausland
+ */
+ @Test
+ @Marking(points=3)
+ public void test_280() {
+ Assert.assertEquals(
+ HandyAbrechnung.inlandPreisProMinute + 14 * HandyAbrechnung.auslandPreisProMinute,
+ HandyAbrechnung.getMonatskosten(101, 14));
+
+ Assert.assertEquals(
+ 125 * HandyAbrechnung.inlandPreisProMinute + 23 * HandyAbrechnung.auslandPreisProMinute,
+ HandyAbrechnung.getMonatskosten(225, 23));
+ }
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2017Summer/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_Helper.java b/Klausuren/Sd1/2017Summer/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_Helper.java
new file mode 100644
index 0000000000000000000000000000000000000000..12454cc410408d235fe49ca72d3ea8e30b91706f
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_Helper.java
@@ -0,0 +1,223 @@
+package de.hdm_stuttgart.mi.sd1.test.aufgabe1;
+
+import org.junit.Assert;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runners.MethodSorters;
+
+import de.hdm_stuttgart.mi.exam.unitmarking.ExaminationTestDefaults;
+import de.hdm_stuttgart.mi.exam.unitmarking.Marking;
+import de.hdm_stuttgart.mi.sd1.aufgabe1.Helper;
+
+
+/**************************
+ * Abschnitt maxVorgaenger *
+ **************************/
+
+/**
+ * <p>Testen des Auftretens eines Teil-Strings in einem vorgegebenen String.</p>
+ *
+ */
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class Test_Helper extends ExaminationTestDefaults {
+
+ /************************
+ * Abschnitt getSuperToll*
+ ************************/
+
+ /**
+ * Weder noch.
+ */
+ @Test
+ @Marking(points=3)
+ public void test_080() {
+ Assert.assertEquals("2", Helper.getSuperToll(2));
+ Assert.assertEquals("7", Helper.getSuperToll(7));
+ }
+
+ /**
+ * Nur durch 3, aber nicht durch 5 teilbar
+ */
+ @Test
+ @Marking(points=3)
+ public void test_090() {
+ Assert.assertEquals("Toll", Helper.getSuperToll(3));
+ Assert.assertEquals("Toll", Helper.getSuperToll(6));
+ Assert.assertEquals("Toll", Helper.getSuperToll(9));
+ Assert.assertEquals("Toll", Helper.getSuperToll(18));
+ Assert.assertEquals("Toll", Helper.getSuperToll(21));
+ }
+
+ /**
+ * Nur durch 5, aber nicht durch 3 teilbar.
+ */
+ @Test
+ @Marking(points=3)
+ public void test_100() {
+ Assert.assertEquals("Super", Helper.getSuperToll(5));
+ Assert.assertEquals("Super", Helper.getSuperToll(10));
+ Assert.assertEquals("Super", Helper.getSuperToll(20));
+ Assert.assertEquals("Super", Helper.getSuperToll(35));
+ Assert.assertEquals("Super", Helper.getSuperToll(40));
+ }
+
+ /**
+ * Sowohl durch 3 als auch durch 5 teilbar
+ */
+ @Test
+ @Marking(points=3)
+ public void test_110() {
+ Assert.assertEquals("Supertoll", Helper.getSuperToll(0));
+ Assert.assertEquals("Supertoll", Helper.getSuperToll(15));
+ Assert.assertEquals("Supertoll", Helper.getSuperToll(45));
+ }
+
+
+ /***************************
+ * Abschnitt maxVorgaenger *
+ **************************/
+
+ /**
+ * maxVorgaenger(null).
+ */
+ @Test
+ @Marking(points=1)
+ public void test_120() {
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.maxVorgaenger(null));
+ }
+
+ /**
+ * maxVorgaenger Array mit weniger als zwei Werten.
+ */
+ @Test
+ @Marking(points=1)
+ public void test_140() {
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.maxVorgaenger(new int[]{ }));
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.maxVorgaenger(new int[]{ 554 }));
+ }
+
+ /**
+ * maxVorgaenger Zwei Werte, ohne Erfolg.
+ */
+ @Test
+ @Marking(points=2)
+ public void test_160() {
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.maxVorgaenger(new int[]{ 2, 2 }));
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.maxVorgaenger(new int[]{ 3, 2 }));
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.maxVorgaenger(new int[]{ 0, 0 }));
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.maxVorgaenger(new int[]{-3, -3 }));
+ }
+
+ /**
+ * maxVorgaenger Zwei Werte, mit Erfolg.
+ */
+ @Test
+ @Marking(points=2)
+ public void test_180() {
+ Assert.assertEquals(1, Helper.maxVorgaenger(new int[]{ 0, 1 }));
+ Assert.assertEquals(1, Helper.maxVorgaenger(new int[]{ 0, 3 }));
+ Assert.assertEquals(1, Helper.maxVorgaenger(new int[]{ -10, -9 }));
+ Assert.assertEquals(1, Helper.maxVorgaenger(new int[]{ -10, 10 }));
+ Assert.assertEquals(1, Helper.maxVorgaenger(new int[]{ 223, 225 }));
+ }
+
+ /**
+ * Mehrere Werte, kein Erfolg
+ */
+ @Test
+ @Marking(points=2)
+ public void test_200() {
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.maxVorgaenger(new int[]{ 2, 1, 3, -2, 2, 6, 1 }));
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.maxVorgaenger(new int[]{ -5, -7, -12, -25 }));
+ }
+
+ /**
+ * Mehrere Werte, Erfolg
+ */
+ @Test
+ @Marking(points=2)
+ public void test_220() {
+ Assert.assertEquals(5, Helper.maxVorgaenger(new int[]{ 2, -1, 0, 1, 2, 5, 4, 40 }));
+ Assert.assertEquals(3, Helper.maxVorgaenger(new int[]{ 0, -1, -2, -2, 2, 6, 1 }));
+ Assert.assertEquals(3, Helper.maxVorgaenger(new int[]{ 0, 0, 0, 1, 20 }));
+ }
+
+ /************************************
+ * Abschnitt getNtesUngeradesElement *
+ ************************************/
+
+ /**
+ * Leer
+ */
+ @Test
+ @Marking(points=1)
+ public void test_300() {
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.getNtesUngeradesElement(new int[]{}, 1));
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.getNtesUngeradesElement(new int[]{}, 4));
+ }
+
+ /**
+ * Ein Element, negativ
+ */
+ @Test
+ @Marking(points=1)
+ public void test_320() {
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.getNtesUngeradesElement(new int[]{6}, 1));
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.getNtesUngeradesElement(new int[]{6}, 1));
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.getNtesUngeradesElement(new int[]{1}, 2));
+ }
+
+ /**
+ * Ein Element, positiv
+ */
+ @Test
+ @Marking(points=1)
+ public void test_340() {
+ Assert.assertEquals(0, Helper.getNtesUngeradesElement(new int[]{1}, 1));
+ }
+
+ /**
+ * Zwei Elemente, negativ
+ */
+ @Test
+ @Marking(points=1)
+ public void test_30() {
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.getNtesUngeradesElement(new int[]{8, 2}, 1));
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.getNtesUngeradesElement(new int[]{8, 2}, 2));
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.getNtesUngeradesElement(new int[]{1, 4}, 2));
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.getNtesUngeradesElement(new int[]{1, 5}, 3));
+ }
+
+ /**
+ * Zwei Elemente, positiv
+ */
+ @Test
+ @Marking(points=2)
+ public void test_360() {
+ Assert.assertEquals(0, Helper.getNtesUngeradesElement(new int[]{1, 2}, 1));
+ Assert.assertEquals(1, Helper.getNtesUngeradesElement(new int[]{1, 1}, 2));
+ }
+
+ /**
+ * Mehrere Elemente, negativ
+ */
+ @Test
+ @Marking(points=1)
+ public void test_380() {
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.getNtesUngeradesElement(new int[]{-4, 6, 0, -2, 8}, 1));
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.getNtesUngeradesElement(new int[]{-4, 6, 0, -2, 8}, 2));
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.getNtesUngeradesElement(new int[]{ 1, 3, -2, 5, -11}, 5));
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.getNtesUngeradesElement(new int[]{ 1, 3, -2, 5, -11}, 20));
+ }
+
+ /**
+ * Mehrere Elemente, positiv
+ */
+ @Test
+ @Marking(points=1)
+ public void test_400() {
+ Assert.assertEquals(2, Helper.getNtesUngeradesElement(new int[]{-4, 6, 1, -2, 8}, 1));
+ Assert.assertEquals(4, Helper.getNtesUngeradesElement(new int[]{-4, 6, 1, -2, 3}, 2));
+ Assert.assertEquals(0, Helper.getNtesUngeradesElement(new int[]{-3, 6, 1, -2, 3}, 1));
+ }
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2017Summer/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_StringHaeufigkeiten.java b/Klausuren/Sd1/2017Summer/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_StringHaeufigkeiten.java
new file mode 100644
index 0000000000000000000000000000000000000000..7a29d642a1f94eaac7e7c116a6deb245f5b696b8
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_StringHaeufigkeiten.java
@@ -0,0 +1,79 @@
+package de.hdm_stuttgart.mi.sd1.test.aufgabe1;
+
+import org.junit.Assert;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runners.MethodSorters;
+
+import de.hdm_stuttgart.mi.exam.unitmarking.ExaminationTestDefaults;
+import de.hdm_stuttgart.mi.exam.unitmarking.Marking;
+import de.hdm_stuttgart.mi.sd1.aufgabe1.StringHaeufigkeiten;
+
+/**
+ * <p>Testen des Auftretens eines Teil-String in einem vorgegebenen String.</p>
+ *
+ */
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class Test_StringHaeufigkeiten extends ExaminationTestDefaults {
+
+ /**
+ * Dreifaches Auftreten von "in" im String "in innerer Windeseile"
+ */
+ @Test
+ @Marking(points=3)
+ public void test_200() {
+ Assert.assertEquals(
+ 3,
+ StringHaeufigkeiten.getAnzahlAuftreten("in innerer Windeseile", "in"));
+ }
+ /**
+ * Einfaches Auftreten von "aua" im String "auaua"
+ */
+ @Test
+ @Marking(points=2)
+ public void test_220() {
+ Assert.assertEquals(
+ 1,
+ StringHaeufigkeiten.getAnzahlAuftreten("auaua", "aua"));
+ }
+ /**
+ * "aua" tritt in "auaua" einmal (überlappungsfrei) auf.
+ */
+ @Test
+ @Marking(points=2)
+ public void test_240() {
+ Assert.assertEquals(
+ 1,
+ StringHaeufigkeiten.getAnzahlAuftreten("auaua", "aua"));
+ }
+ /**
+ *
+ */
+ @Test
+ @Marking(points=1)
+ public void test_260() {
+ Assert.assertEquals(
+ 0,
+ StringHaeufigkeiten.getAnzahlAuftreten("", "aua"));
+ }
+ /**
+ *
+ */
+ @Test
+ @Marking(points=1)
+ public void test_280() {
+ Assert.assertEquals(
+ 0,
+ StringHaeufigkeiten.getAnzahlAuftreten("abcdefghi", "uups"));
+ }
+ /**
+ *
+ */
+ @Test
+ @Marking(points=1)
+ public void test_300() {
+ Assert.assertEquals(
+ 1,
+ StringHaeufigkeiten.getAnzahlAuftreten("tim", "tim"));
+ }
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2017Summer/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe2/Test_Ersatzteil.java b/Klausuren/Sd1/2017Summer/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe2/Test_Ersatzteil.java
new file mode 100644
index 0000000000000000000000000000000000000000..3d361d709eb036f5173d94f0efddf419453e364b
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe2/Test_Ersatzteil.java
@@ -0,0 +1,200 @@
+package de.hdm_stuttgart.mi.sd1.test.aufgabe2;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Modifier;
+
+import javax.management.relation.RelationNotFoundException;
+
+import org.junit.Assert;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runners.MethodSorters;
+
+import de.hdm_stuttgart.mi.exam.unitmarking.ExaminationTestDefaults;
+import de.hdm_stuttgart.mi.exam.unitmarking.Marking;
+import de.hdm_stuttgart.mi.sd1.aufgabe2.Ersatzteil;
+import de.hdm_stuttgart.mi.sd1.test.helper.ReflectClass;
+import de.hdm_stuttgart.mi.sd1.test.helper.ReflectionHelper;
+
+/**
+ * Teste Ersatzteile.
+ *
+ */
+
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class Test_Ersatzteil extends ExaminationTestDefaults {
+
+ final ReflectionHelper rHelper = new ReflectionHelper();
+
+ /**
+ * Korrekte toString() Redefinition.
+ */
+ @Test
+ @Marking(points = 2)
+ public void test_010_toString() {
+ Assert.assertEquals("Holzbalken, Teilenummer:123", new Ersatzteil(123, "Holzbalken").toString());
+ }
+ /**
+ * Korrekte toString() Redefinition.
+ */
+ @Test
+ @Marking(points = 1)
+ public void test_015_toString() {
+ Assert.assertEquals("Bezeichnung unbekannt, Teilenummer:123", new Ersatzteil(123, null).toString());
+ }
+ /**
+ * Objektgleichheit positiv, gleiche Bezeichnung
+ */
+ @Test
+ @Marking(points = 2)
+ public void test_020_equal() {
+ Assert.assertEquals("Keine (geeignete) Ersatzteil.equals() Methode vorhanden! ",
+ null,
+ rHelper.ersatzteil_equals.getRecursiveErrorMsg());
+ Assert.assertEquals(true, new Ersatzteil(23, "Mutter").equals(
+ new Ersatzteil(23, "Mutter")));
+ }
+ /**
+ * Objektgleichheit positiv, ungleiche Bezeichnung
+ */
+ @Test
+ @Marking(points = 2)
+ public void test_030_equalBezeichnungAnders() {
+ Assert.assertEquals("Keine (geeignete) Ersatzteil.equals() Methode vorhanden! ",
+ null,
+ rHelper.ersatzteil_equals.getRecursiveErrorMsg());
+ Assert.assertEquals(true, new Ersatzteil(23, "Mutter").equals(
+ new Ersatzteil(23, "Schraube")));
+ }
+ /**
+ * Objektgleichheit negativ, gleiche Bezeichnung
+ */
+ @Test
+ @Marking(points = 1)
+ public void test_040_verschieden() {
+
+ Assert.assertNull(rHelper.ersatzteil_equals.getRecursiveErrorMsg());
+ Assert.assertNull(rHelper.ersatzteil_equals.assertIsDefinedIn(Ersatzteil.class));
+
+ Assert.assertEquals(false, new Ersatzteil(23, "Mutter").equals(
+ new Ersatzteil(24, "Mutter")));
+ }
+ /**
+ * Objektgleichheit negativ, ungleiche Bezeichnung
+ */
+ @Test
+ @Marking(points = 2)
+ public void test_050_verschiedenBezeichnung() {
+ Assert.assertNull(rHelper.ersatzteil_equals.getRecursiveErrorMsg());
+ Assert.assertNull(rHelper.ersatzteil_equals.assertIsDefinedIn(Ersatzteil.class));
+
+ Assert.assertEquals(false, new Ersatzteil(23, "Mutter").equals(
+ new Ersatzteil(24, "Schraube")));
+ }
+ /**
+ * Objektgleichheit negativ, Vergleich mit null
+ */
+ @Test
+ @Marking(points = 2)
+ public void test_060_verschiedenNull() {
+ Assert.assertNull(rHelper.ersatzteil_equals.getRecursiveErrorMsg());
+ Assert.assertNull(rHelper.ersatzteil_equals.assertIsDefinedIn(Ersatzteil.class));
+
+ Assert.assertEquals(false, new Ersatzteil(23, "Mutter").equals(null));
+ }
+ /**
+ * Objektgleichheit negativ, Vergleich mit String
+ */
+ @Test
+ @Marking(points = 1)
+ public void test_070_verschiedenString() {
+ Assert.assertNull(rHelper.ersatzteil_equals.getRecursiveErrorMsg());
+ Assert.assertNull(rHelper.ersatzteil_equals.assertIsDefinedIn(Ersatzteil.class));
+
+ Assert.assertEquals(false, new Ersatzteil(23, "Mutter").equals("irgendwas"));
+ }
+
+ /**
+ * Alle Ersatzteil Attribute sollen private sein.
+ */
+ @Test
+ @Marking(points = 1)
+ public void test_075_attrib_ersatzteil_private() {
+
+ Assert.assertTrue("Die Klassse 'Ersatzteil' hat kein Attribut", 0 < Ersatzteil.class.getDeclaredFields().length);
+
+ final String nonPrivateAttribs = ReflectClass.getNonPrivateAttributes(Ersatzteil.class);
+ Assert.assertEquals("Folgende Attribute in der Klasse 'Ersatzteil' sind nicht 'private': " + nonPrivateAttribs + ". ",
+ null,
+ nonPrivateAttribs);
+ }
+
+ /**
+ * Definition class Reifen {...}
+ */
+ @Test
+ @Marking(points = 1)
+ public void test_080_classReifen() {
+ Assert.assertEquals(null, rHelper.reifenKlasse.msg);
+ }
+
+ /** modifier & method.getModifiers();
+
+ * Konstruktor Definition public Reifen (int, int){...}
+ */
+ @Test
+ @Marking(points = 1)
+ public void test_200_reifenKonstruktor() {
+ Assert.assertEquals(null, rHelper.reifen_constructor_int_int.getRecursiveMsg());
+ }
+
+ /**
+ * Methode Ersatzteil.equals() in Ersatzteil darf nicht redefinierbar sein
+ */
+ @Test
+ @Marking(points = 1)
+ public void test_077_equalsNichtRedefinierbar() {
+ Assert.assertNull(rHelper.ersatzteil_equals.getRecursiveErrorMsg());
+ Assert.assertNull(rHelper.ersatzteil_equals.assertIsDefinedIn(Ersatzteil.class));
+ Assert.assertNull(rHelper.ersatzteil_equals.assertModifierIsPresent(Modifier.FINAL, "Methode Ersatzteil.equals() darf nicht redefinierbar sein"));
+
+ }
+
+ /**
+ * Methode Reifen.toString() mit korrekter Signatur definiert
+ */
+ @Test
+ @Marking(points = 1)
+ public void test_220_Reifen_toString() {
+ Assert.assertEquals(null, rHelper.reifen_toString.getRecursiveErrorMsg());
+
+ Assert.assertNull(rHelper.reifen_toString.assertIsDefinedIn("de.hdm_stuttgart.mi.sd1.aufgabe2.Reifen"));
+ Assert.assertNull(rHelper.reifen_toString.assertModifierIsPresent(Modifier.PUBLIC));
+
+ }
+
+ /**
+ * Erzeugung Instanz Reifen(final int number) und pruefung toString()
+ */
+ @Test
+ @Marking(points = 2)
+ public void test_400_konstruktorReifen() {
+ Assert.assertEquals(null, rHelper.reifenKlasse.msg);
+ Assert.assertEquals(null, rHelper.reifen_constructor_int_int.getRecursiveMsg());
+
+ Object reifen = null;
+ try {
+ reifen = rHelper.reifen_constructor_int_int.constructor.newInstance(new Object[] {1132, 160});
+ } catch (InstantiationException | IllegalAccessException | IllegalArgumentException
+ | InvocationTargetException e) {
+ Assert.fail("Konnte 'new Reifen(1132, 160)' nicht aufrufen.");
+ return;
+ }
+ try {
+ Assert.assertEquals("Reifen, Teilenummer:1132, Maximalgeschwindigkeit:160 Kmh", rHelper.reifen_toString.method.invoke(reifen, new Object[] {}));
+ } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+ Assert.fail("Konnte 'toString()' für 'new Reifen(1132, 160)' nicht aufrufen.");
+ return;
+ }
+ }
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2017Summer/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/helper/ReflectClass.java b/Klausuren/Sd1/2017Summer/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/helper/ReflectClass.java
new file mode 100644
index 0000000000000000000000000000000000000000..9f317715f26212c22eb35eb443b9bb05ed4a984a
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/helper/ReflectClass.java
@@ -0,0 +1,107 @@
+package de.hdm_stuttgart.mi.sd1.test.helper;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.Arrays;
+import java.util.stream.Collectors;
+
+
+public class ReflectClass {
+ public ReflectClass(final String className) {
+ this.className = className;
+ Class<?> classTmp = null;
+ String tmpMsg = null;
+ try {
+ classTmp = Class.forName(className);
+ } catch (final ClassNotFoundException e) {
+ tmpMsg = "Die Klasse '" + className + "' wurde nicht gefunden:";
+ }
+ classZ = classTmp;
+ msg = tmpMsg;
+ }
+ public final String className;
+ public final Class<?> classZ;
+ public final String msg;
+
+ /**
+ * @param arguments
+ * @return Class names joined by ',', possibly stripped of "java.lang" component
+ */
+ public static String formatArguments(final Class<?>[] arguments) {
+
+ return Arrays.stream(arguments).
+ map(c -> normalizeClassname(c)).
+ collect(Collectors.joining(", ")).
+ toString();
+ }
+
+ /**
+ *
+ * @param classz
+ * @return The classname possible stripped of "java.lang" component
+ */
+ public static String normalizeClassname(final Class<?> classz) {
+ final Package javaDotLang = Package.getPackage("java.lang"),
+ hostingPackage = classz.getPackage();
+
+ if (null == hostingPackage || !hostingPackage.equals(javaDotLang)) {
+ return classz.getName();
+ } else {
+ return classz.getSimpleName();
+ }
+ }
+
+ /**
+ *
+ * @param classz
+ * @return A string containing all non-private attribute names
+ */
+ public static String getNonPrivateAttributes(final Class<?> classz) {
+
+ final Field[] fields = classz.getDeclaredFields();
+ final StringBuffer results = new StringBuffer();
+ boolean found = false;
+ for (final Field f: fields) {
+ if (0 == (Modifier.PRIVATE & f.getModifiers())) {
+ if (found) {
+ results.append(", ");
+ }
+ results.append(f.getName());
+ found = true;
+ }
+ }
+ if (found) {
+ return results.toString();
+ }
+ return null;
+ }
+ /**
+ * Get modifier cleartext name according to
+ * https://docs.oracle.com/javase/8/docs/api/java/lang/reflect/Modifier.html#field.summary
+ *
+ * @param modifier
+ * @return Clear text name e.g. "final"
+ */
+ static public String getModifierString(final int modifier) {
+
+ switch (modifier) {
+ case Modifier.ABSTRACT: return "abstract";
+ case Modifier.FINAL: return "final";
+ case Modifier.INTERFACE: return "interface";
+ case Modifier.NATIVE: return "native";
+ case Modifier.PRIVATE: return "private";
+ case Modifier.PROTECTED: return "protected";
+ case Modifier.PUBLIC: return "public";
+ case Modifier.STATIC: return "static";
+ case Modifier.STRICT: return "strict";
+ case Modifier.SYNCHRONIZED: return "synchronized";
+ case Modifier.TRANSIENT: return "transient";
+ case Modifier.VOLATILE: return "volatile";
+
+ default:
+ return "Unknown modifier value " + modifier;
+ }
+
+ }
+
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2017Summer/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/helper/ReflectConstructor.java b/Klausuren/Sd1/2017Summer/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/helper/ReflectConstructor.java
new file mode 100644
index 0000000000000000000000000000000000000000..967f619465b790ea3d93171e21e245190234b754
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/helper/ReflectConstructor.java
@@ -0,0 +1,38 @@
+package de.hdm_stuttgart.mi.sd1.test.helper;
+
+import java.lang.reflect.Constructor;
+
+public class ReflectConstructor {
+
+ public ReflectConstructor(final ReflectClass reflectClass, final Class<?>[] argumentMeta) {
+ this.definingClass = reflectClass;
+ Constructor<?> constructorTmp = null;
+ String tmpMsg = null;
+ if (null == reflectClass.classZ) {
+ tmpMsg = "Folgefehler: Klasse '" + reflectClass.className + "' nicht definiert";
+ } else {
+ try {
+ constructorTmp = reflectClass.classZ.getConstructor(argumentMeta);
+ } catch (NoSuchMethodException | SecurityException e) {
+ tmpMsg = "Kein Konstruktor '" +
+ reflectClass.classZ.getSimpleName() + "(" +
+ ReflectClass.formatArguments(argumentMeta) +
+ ")' in Klasse '" +
+ reflectClass.className + "' gefunden";
+ }
+ }
+ constructor = constructorTmp;
+ msg = tmpMsg;
+ }
+ public String getRecursiveMsg() {
+ if (null == definingClass.msg) {
+ return msg;
+ } else {
+ return "Folgefehler: " + definingClass.msg;
+ }
+ }
+
+ public final ReflectClass definingClass;
+ public final Constructor<?> constructor;
+ private final String msg;
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2017Summer/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/helper/ReflectMethod.java b/Klausuren/Sd1/2017Summer/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/helper/ReflectMethod.java
new file mode 100644
index 0000000000000000000000000000000000000000..9ffddb78e739128de21622cc39c2d4e231fe02d2
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/helper/ReflectMethod.java
@@ -0,0 +1,120 @@
+package de.hdm_stuttgart.mi.sd1.test.helper;
+
+import java.lang.reflect.Method;
+
+
+/**
+ * Describing a method to be instantiated by its string name within a given class
+ *
+ */
+public class ReflectMethod {
+
+ /**
+ * Metainfo about a method being defined in a given class.
+ *
+ * @param reflectClass Describing the class in question
+ * @param reflectMethodName The method's name.
+ * @param argumentMeta The method's arguments
+ */
+ public ReflectMethod(final ReflectClass reflectClass, final String reflectMethodName, final Class<?>[] argumentMeta) {
+ this.definingReflectClass = reflectClass;
+ Method methodTmp = null;
+ String tmpMsg = null;
+ if (null == reflectClass.classZ) {
+ tmpMsg = "Folgefehler: Klasse '" + reflectClass.className + "' nicht definiert";
+ } else {
+ try {
+ methodTmp = reflectClass.classZ.getMethod(reflectMethodName, argumentMeta);
+ } catch (NoSuchMethodException | SecurityException e) {
+ tmpMsg = "Keine Methode '" + reflectMethodName + "(" + ")' in Klasse '" + reflectClass.className + "' gefunden";
+ }
+ }
+ method = methodTmp;
+ msg = tmpMsg;
+ }
+
+ /**
+ * Ausgangsklasse, in welcher die Methode vorhanden ist.
+ */
+ public final ReflectClass definingReflectClass;
+
+ /**
+ *
+ */
+ public final Method method;
+ private final String msg;
+
+
+ /**
+ * Providing error message in case the searched method was not found
+ * @return Explanation if method was not found, null otherwise
+ */
+ public String getRecursiveErrorMsg() {
+ if (null == definingReflectClass.msg) {
+ return msg;
+ } else {
+ return "Folgefehler: " + definingReflectClass.msg;
+ }
+ }
+
+ /**
+ * Assert whether the method is being defined in a given class.
+ *
+ * @param expectedClass
+ * @return null if defined in expected class, error message otherwise
+ */
+ public String assertIsDefinedIn(final String expectedClass) {
+ final Class<?> definingClass = method.getDeclaringClass();
+
+ if (expectedClass.equals(definingClass.getName())) {
+ return null;
+ } else {
+ return "equals(...) ist in '" + definingClass.getName() + "' definiert, aber nicht in '"+ expectedClass + "'";
+ }
+ }
+
+ /**
+ * Assert whether the method is being defined in a given class.
+ *
+ * @param expectedClass
+ * @return null if defined in expected class, error message otherwise
+ */
+ public String assertIsDefinedIn(final Class<?> expectedClass) {
+ final Class<?> definingClass = method.getDeclaringClass();
+
+ if (expectedClass.equals(definingClass)) {
+ return null;
+ } else {
+ return "equals(...) ist in '" + definingClass.getName() + "' definiert, aber nicht in '"+ expectedClass.getName() + "'";
+ }
+ }
+
+ /**
+ * Check for presence of mandatory modifier.
+ * @param modifier
+ * @return null if desired modifier is present, descriptive message otherwise.
+ *
+ */
+ public String assertModifierIsPresent(final int modifier) {
+
+ if (0 == (modifier & method.getModifiers())) {
+ return "Modifier '" + ReflectClass.getModifierString(modifier) + "' not present";
+ } else {
+ return null;
+ }
+ }
+ /**
+ * Check for presence of mandatory modifier.
+ * @param modifier
+ * @return null if desired modifier is present, descriptive message otherwise.
+ *
+ */
+ public String assertModifierIsPresent(final int modifier, final String msg) {
+
+ if (0 == (modifier & method.getModifiers())) {
+ return msg;
+ } else {
+ return null;
+ }
+ }
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2017Summer/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/helper/ReflectionHelper.java b/Klausuren/Sd1/2017Summer/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/helper/ReflectionHelper.java
new file mode 100644
index 0000000000000000000000000000000000000000..f51c9cb80217af14d8a02c65cf878ab3f3fcd23f
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/helper/ReflectionHelper.java
@@ -0,0 +1,35 @@
+package de.hdm_stuttgart.mi.sd1.test.helper;
+
+public class ReflectionHelper {
+
+ public static final String ersatzteilKlassenName = "de.hdm_stuttgart.mi.sd1.aufgabe2.Ersatzteil",
+ reifenKlassenName = "de.hdm_stuttgart.mi.sd1.aufgabe2.Reifen";
+
+ public ReflectionHelper() {
+
+ // Ersatzteil
+ //
+ ersatzteilKlasse = new ReflectClass(ersatzteilKlassenName);
+ ersatzteil_toString = new ReflectMethod(ersatzteilKlasse, "toString", new Class[]{});
+ ersatzteil_equals = new ReflectMethod(ersatzteilKlasse, "equals", new Class[]{Object.class});
+
+ // Reifen
+ //
+ reifenKlasse = new ReflectClass(reifenKlassenName);
+ reifen_constructor_int_int = new ReflectConstructor(reifenKlasse, new Class[]{Integer.TYPE, Integer.TYPE});
+ reifen_toString = new ReflectMethod(reifenKlasse, "toString", new Class[]{});
+ reifen_equals = new ReflectMethod(reifenKlasse, "equals", new Class[]{Object.class});
+ }
+
+ // Ersatzteil
+ //
+ public final ReflectClass ersatzteilKlasse;
+ public final ReflectMethod ersatzteil_toString, ersatzteil_equals;
+
+ // Reifen
+ //
+ public final ReflectClass reifenKlasse;
+ public final ReflectConstructor reifen_constructor_int_int;
+ public final ReflectMethod reifen_toString, reifen_equals;
+
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2017Summer/Extras/.gitignore b/Klausuren/Sd1/2017Summer/Extras/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..a1c3ab4d08c0f9f91918f21c730272a4711885e8
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Extras/.gitignore
@@ -0,0 +1,4 @@
+/target/
+/.settings/
+.classpath
+.project
diff --git a/Klausuren/Sd1/2017Summer/Extras/pom.xml b/Klausuren/Sd1/2017Summer/Extras/pom.xml
new file mode 100644
index 0000000000000000000000000000000000000000..089df6501f63c42ebc00338b697d2e40b1db892c
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Extras/pom.xml
@@ -0,0 +1,80 @@
+<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.mi.sd1</groupId>
+ <artifactId>sd1_sose2017_extras</artifactId>
+ <version>0.0.1-SNAPSHOT</version>
+ <packaging>jar</packaging>
+
+ <name>sd1_sose2017_Extras</name>
+
+ <url>http://www.mi.hdm-stuttgart.de/freedocs/topic/de.hdm_stuttgart.mi.lectures/sd1SectUsingMaven.html</url>
+
+ <properties>
+ <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+ </properties>
+
+ <dependencies>
+ <dependency>
+ <groupId>junit</groupId>
+ <artifactId>junit</artifactId>
+ <version>4.12</version>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.apache.logging.log4j</groupId>
+ <artifactId>log4j-core</artifactId>
+ <version>2.6</version>
+ </dependency>
+
+ </dependencies>
+
+ <build>
+ <plugins>
+
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-compiler-plugin</artifactId>
+ <version>3.5.1</version>
+ <configuration>
+ <source>1.8</source>
+ <target>1.8</target>
+ </configuration>
+ </plugin>
+
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-javadoc-plugin</artifactId>
+ <version>2.10.3</version>
+ <configuration />
+ </plugin>
+
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-shade-plugin</artifactId>
+ <version>2.4.3</version>
+ <configuration>
+ <transformers>
+ <transformer
+ implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
+ <manifestEntries>
+ <Main-Class>de.hdm_stuttgart.mi.sd1.sd1_sose2017.App</Main-Class>
+ </manifestEntries>
+ </transformer>
+ </transformers>
+ </configuration>
+ <executions>
+ <execution>
+ <phase>package</phase>
+ <goals>
+ <goal>shade</goal>
+ </goals>
+ </execution>
+ </executions>
+ </plugin>
+
+ </plugins>
+ </build>
+</project>
diff --git a/Klausuren/Sd1/2017Summer/Extras/src/main/java/de/hdm_stuttgart/mi/sd1/sd1_sose2017/App.java b/Klausuren/Sd1/2017Summer/Extras/src/main/java/de/hdm_stuttgart/mi/sd1/sd1_sose2017/App.java
new file mode 100644
index 0000000000000000000000000000000000000000..95709015200545a3a9ff95082732e247802fc4ea
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Extras/src/main/java/de/hdm_stuttgart/mi/sd1/sd1_sose2017/App.java
@@ -0,0 +1,29 @@
+package de.hdm_stuttgart.mi.sd1.sd1_sose2017;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+
+/**
+ * A simple http://logging.apache.org/log4j/2.x demo,
+ * see file log4j2.xml for configuration options.
+ *
+ */
+public class App {
+ private static Logger log = LogManager.getLogger(App.class);
+
+ /**
+ * @param args Unused
+ */
+
+ public App() {
+
+ }
+ public static void main( String[] args ) {
+ System.out.println( "Hello World!" );
+
+ final String test = "in windes inner in";
+ System.out.println(test.indexOf("in", 17));
+
+ }
+}
diff --git a/Klausuren/Sd1/2017Summer/Extras/src/main/java/de/hdm_stuttgart/mi/sd1/sd1_sose2017/IntProblem.java b/Klausuren/Sd1/2017Summer/Extras/src/main/java/de/hdm_stuttgart/mi/sd1/sd1_sose2017/IntProblem.java
new file mode 100644
index 0000000000000000000000000000000000000000..035f395bda34559401f396dc3098b6d8f857464a
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Extras/src/main/java/de/hdm_stuttgart/mi/sd1/sd1_sose2017/IntProblem.java
@@ -0,0 +1,10 @@
+package de.hdm_stuttgart.mi.sd1.sd1_sose2017;
+
+public class IntProblem {
+
+ public static void main(String[] args) {
+ System.out.println(2.5 * 50 / 100);
+ System.out.println(50 / 100 * 2.5);
+ }
+
+}
diff --git a/Klausuren/Sd1/2017Summer/Extras/src/main/java/de/hdm_stuttgart/mi/sd1/sd1_sose2017/StringCreation.java b/Klausuren/Sd1/2017Summer/Extras/src/main/java/de/hdm_stuttgart/mi/sd1/sd1_sose2017/StringCreation.java
new file mode 100644
index 0000000000000000000000000000000000000000..0b10bb7a5069a65f1ae4bce87beab6ff5df09fe3
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Extras/src/main/java/de/hdm_stuttgart/mi/sd1/sd1_sose2017/StringCreation.java
@@ -0,0 +1,13 @@
+package de.hdm_stuttgart.mi.sd1.sd1_sose2017;
+
+public class StringCreation {
+
+ public static void main(String[] args) {
+ String s = "Java";
+ s = s.concat(" SE 7");
+ s.toLowerCase();
+ System.out.print(s);
+
+ // Wieviele Strings wurden erzeugt?
+ }
+}
diff --git a/Klausuren/Sd1/2017Summer/Extras/src/main/resources/log4j2.xml b/Klausuren/Sd1/2017Summer/Extras/src/main/resources/log4j2.xml
new file mode 100644
index 0000000000000000000000000000000000000000..0f9edbc70ed5eacdb7bb3fbe8aa76bb9b7812b74
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Extras/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="de.hdm_stuttgart.mi.sd1.sd1_sose2017.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/2017Summer/Extras/src/test/java/de/hdm_stuttgart/mi/sd1/sd1_sose2017/AppTest.java b/Klausuren/Sd1/2017Summer/Extras/src/test/java/de/hdm_stuttgart/mi/sd1/sd1_sose2017/AppTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..1548a2bd64306f9c40022d768e85e0df2a268ce3
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Extras/src/test/java/de/hdm_stuttgart/mi/sd1/sd1_sose2017/AppTest.java
@@ -0,0 +1,17 @@
+package de.hdm_stuttgart.mi.sd1.sd1_sose2017;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * Unit test for simple App.
+ */
+public class AppTest {
+ /**
+ * Dummy test method
+ */
+ @Test
+ public void testApp() {
+ Assert.assertTrue( true );
+ }
+}
diff --git a/Klausuren/Sd1/2017Summer/Solve/.gitignore b/Klausuren/Sd1/2017Summer/Solve/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..a1c3ab4d08c0f9f91918f21c730272a4711885e8
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Solve/.gitignore
@@ -0,0 +1,4 @@
+/target/
+/.settings/
+.classpath
+.project
diff --git a/Klausuren/Sd1/2017Summer/Solve/Doc/klausur.xml b/Klausuren/Sd1/2017Summer/Solve/Doc/klausur.xml
new file mode 100644
index 0000000000000000000000000000000000000000..e9960879de8287c06a7100928e4a9e06ebb13fb7
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Solve/Doc/klausur.xml
@@ -0,0 +1,264 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<book version="5.0" xml:id="klausur_SoSe_2017" xml:lang="de" xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xila="http://www.w3.org/2001/XInclude/local-attributes" xmlns:xi="http://www.w3.org/2001/XInclude" xmlns:trans="http://docbook.org/ns/transclusion" xmlns:svg="http://www.w3.org/2000/svg" xmlns:m="http://www.w3.org/1998/Math/MathML" xmlns:html="http://www.w3.org/1999/xhtml" xmlns:db="http://docbook.org/ns/docbook">
+ <!-- saxon9he-xslt -s:klausur.xml -xsl:/usr/share/hdm-docbook-xsl/CustomLayer/Klausur/docbook2klausur.xsl -->
+
+ <info>
+ <title/>
+
+ <author>
+ <personname/>
+ </author>
+
+ <pubdate/>
+ </info>
+
+ <chapter xml:id="task1">
+ <title>Klassenmethoden</title>
+
+ <!-- Hier gemeinsames zip Archiv hochladen, auch von anderen Aufgaben. -->
+
+ <section xml:id="aufgabe1_prepare">
+ <title>Vorbereitung</title>
+
+ <para>Entpacken Sie das oben sichtbare Archiv <filename>exam.zip</filename> und importieren Sie den resultierenden Ordner <filename>Exam</filename> als <productname>Maven</productname> Projekt in Ihren <productname>Eclipse</productname> <foreignphrase xml:lang="en">Workspace</foreignphrase>.</para>
+ </section>
+
+ <section xml:id="aufgabe1_descr">
+ <title>Beschreibung</title>
+
+ <para>Implementierung vorbereiteter Methoden gemäß <productname>Javadoc</productname> Beschreibungen und nachfolgend beschriebener Funktionalitäten. Sie bekommen bei unvollständiger Implementierung Teilpunkte.</para>
+ </section>
+
+ <section xml:id="aufgabe1_task">
+ <title>Aufgabe</title>
+
+ <para>Vervollständigen Sie die Implementierung aller Methoden aus folgenden Klassen im <foreignphrase xml:lang="en">package</foreignphrase> <package>de.hdm_stuttgart.mi.sd1.aufgabe1</package>:</para>
+
+ <itemizedlist>
+ <listitem>
+ <para><classname>HandyAbrechnung</classname></para>
+ </listitem>
+
+ <listitem>
+ <para><classname>Helper</classname></para>
+ </listitem>
+
+ <listitem>
+ <para><classname>StringHaeufigkeiten</classname></para>
+ </listitem>
+ </itemizedlist>
+
+ <tip>
+ <para>Das <foreignphrase xml:lang="en">package</foreignphrase> <package>de.hdm_stuttgart.mi.sd1.aufgabe1</package> im Test Zweig Ihres Projekts enthält drei zugehörige <productname>Junit</productname> Testklassen:</para>
+
+ <itemizedlist>
+ <listitem>
+ <para><classname>Test_HandyAbrechnung</classname></para>
+ </listitem>
+
+ <listitem>
+ <para><classname>Test_Helper</classname></para>
+ </listitem>
+
+ <listitem>
+ <para><classname>Test_StringHaeufigkeiten</classname></para>
+ </listitem>
+ </itemizedlist>
+ </tip>
+ </section>
+
+ <section xml:id="aufgabe1_commonHints">
+ <title>Allgemeine Hinweise</title>
+
+ <itemizedlist>
+ <listitem>
+ <para>Für jede Methode stehen Ihnen in der zugehörigen Testklasse korrespondierende Tests zur Verfügung. Nutzen Sie diese!</para>
+ </listitem>
+
+ <listitem>
+ <para>Die von Ihnen erreichte Punktzahl richtet sich nach der Anzahl positiv bestandener Tests. Sie bekommen keine Punkte, wenn Ihre Implementierung in Bezug auf einen einzelnen Test lediglich <quote>fast richtig</quote> ist. Implementieren Sie im Zweifelsfall weniger Methoden, diese dafür aber vollständig.</para>
+ </listitem>
+
+ <listitem>
+ <para>Die <productname>Javadoc</productname> Kommentare der jeweiligen Methoden beschreiben das gewünschte Verhalten. Unter <link xlink:href="https://freedocs.mi.hdm-stuttgart.de/sd1SectMavenGenerateJavadoc.html">Generating Javadoc™ project documentation</link> finden Sie eine Anleitung zur Umwandlung in das HTML Format zwecks besserer Lesbarkeit.</para>
+
+ <para>Lesen Sie die (generierte) Dokumentation <emphasis role="bold">sehr genau</emphasis>.</para>
+ </listitem>
+
+ <listitem>
+ <para>Beachten Sie alle Sonderfälle. Dazu zählen insbesondere <code>null</code> Werte von Variablen oder enthaltene <code>null</code> Werte in <foreignphrase xml:lang="en">Arrays</foreignphrase>.</para>
+ </listitem>
+
+ <listitem>
+ <para>Nutzen Sie den <foreignphrase xml:lang="en">Debugger</foreignphrase> oder logging <foreignphrase xml:lang="en">Statements</foreignphrase> im Fall fehlgeschlagener Testfälle.</para>
+ </listitem>
+
+ <listitem>
+ <para>Die Ausführung von <package>de.hdm_stuttgart.mi.sd1.test</package>.<classname>ShowAllReachedPoints</classname> im Testzweig Ihres Projekts als <productname>Java</productname> Anwendung (nicht als Junit Test!) zeigt Ihnen zu jedem Zeitpunkt die in allen Programmieraufgaben bislang erreichten Punkte.</para>
+ </listitem>
+ </itemizedlist>
+ </section>
+
+ <section version="5.1" xml:id="uploadFirst" xml:lang="de">
+ <title>Hochladen Ihrer Lösung in das Klausursystem</title>
+
+ <para>Exportieren Sie Ihre Implementierung dieser und weiterer Programmieraufgaben per Rechtsklick im <foreignphrase xml:lang="en">Package Explorer</foreignphrase> Ihres <productname>Eclipse</productname> Projekts. Klicken Sie im <foreignphrase xml:lang="en">Package Explorer</foreignphrase> (Maus Rechtsklick) auf Ihre Projektwurzel und exportieren Sie über das Kontextmenü <quote>Export</quote> → <quote>General</quote> → <quote>Archive File</quote> einen auf <filename>.zip</filename> endenden Archivnamen, z.B. <filename>solution_1.zip</filename>. Laden Sie danach <filename>solution_1.zip</filename> über die <quote><foreignphrase xml:lang="en">Upload</foreignphrase> File</quote> Funktion am unteren Seitenende des <productname>Ilias</productname> Klausursystems hoch. Wichtige Punkte:</para>
+
+ <itemizedlist>
+ <listitem>
+ <para>Achten Sie auf vollständigen Export. Im Exportmenü können Sie (versehentlich) einzelne Ordner, wie z.B. <filename>src</filename>, abwählen. In diesem Fall wird Ihr Quellcode nicht in das Archiv <filename>solution_1.zip</filename> exportiert.</para>
+ </listitem>
+
+ <listitem>
+ <para>Wählen Sie beim Hochladen nicht die falsche Datei, etwa das Ausgangsarchiv <filename>exam.zip</filename> oder eine ältere Version Ihres Projekts.</para>
+ </listitem>
+
+ <listitem>
+ <para>Kontrollieren Sie nach dem Hochladen die Sichtbarkeit Ihres <filename>solution_1.zip</filename> Archivs im Klausursystem.</para>
+ </listitem>
+
+ <listitem>
+ <para>Sie können mehrere Versionen <filename>solution_2.zip</filename> ... hochladen und bei Bedarf ältere im <productname>Ilias</productname> System löschen. Nur die zuletzt hochgeladene Version wird bewertet.</para>
+ </listitem>
+ </itemizedlist>
+
+ <caution>
+ <itemizedlist>
+ <listitem>
+ <para>Reservieren Sie für den Vorgang des Hochladens ausreichend Zeit vor Klausurende.</para>
+ </listitem>
+
+ <listitem>
+ <para>Bearbeitungen, welche sich nach Klausurende lediglich auf Ihrem Arbeitsplatzrechner befinden, werden nicht gewertet.</para>
+ </listitem>
+
+ <listitem>
+ <para>Laden Sie keine Projekte mit <productname>Java</productname> Syntaxfehlern hoch, diese werden nicht bewertet!</para>
+ </listitem>
+
+ <listitem>
+ <para>Exportieren Sie Ihr Projekt nicht als <filename>.tgz</filename>, <filename>.java</filename>, <filename>.tar.gz</filename> <acronym>o.ä.</acronym>. Das Klausursystem akzeptiert nur Archive mit der Endung <filename>.zip</filename>.</para>
+ </listitem>
+ </itemizedlist>
+ </caution>
+ </section>
+ </chapter>
+
+ <chapter xml:id="task2">
+ <title>Ersatzteile</title>
+
+ <section xml:id="aufgabe2_prepare">
+ <title>Vorbereitung</title>
+
+ <para>Falls Sie die erste Aufgabe »<xref linkend="task1"/>« bearbeitet haben, arbeiten Sie einfach an Ihrem <productname>Maven</productname> Projekt weiter. Ansonsten lesen Sie bitte die Anleitung in der Aufgabe »<xref linkend="task1"/>« zum <productname>Eclipse</productname> <productname>Maven</productname> Projektimport sowie weitere Hinweise zum Hochladen in das <productname>Ilias</productname> System.</para>
+ </section>
+
+ <section xml:id="aufgabe2_descr">
+ <title>Beschreibung</title>
+
+ <para>Implementierung von Methoden und einer neuen Klasse zur Verwaltung von Ersatzteilen.</para>
+
+ <para>Das <productname>Maven</productname> Projektskelett enthält eine Klasse <classname>Ersatzteil</classname> im <foreignphrase xml:lang="en">Package</foreignphrase> <package>de.hdm_stuttgart.mi.sd1.aufgabe2</package>.</para>
+
+ <para>Implementieren Sie die nachfolgend beschriebenen Funktionalitäten. Sie bekommen bei unvollständiger Implementierung Teilpunkte. Nutzen Sie zum Test Ihrer Implementierung die <productname>Junit</productname> Tests in <package>de.hdm_stuttgart.mi.sd1.test.aufgabe2</package>.<classname>Test_Ersatzteil</classname>.</para>
+ </section>
+
+ <section xml:id="aufgabe2_task">
+ <title>Aufgaben</title>
+
+ <orderedlist>
+ <listitem>
+ <para>Ein Ersatzteil soll durch Angabe einer Teilenummer und einer Bezeichnung erstellt werden können. Wir betrachten ein Beispiel für das gewünschte Verhalten:</para>
+
+ <programlisting language="java">final Ersatzteil kurbelwelle =
+ new Ersatzteil(12345, "Kurbelwelle");
+System.out.println(kurbelwelle);
+
+final Ersatzteil brandneu = // Bezeichnung noch
+ new Ersatzteil(54321, null); // unbekannt.
+System.out.println(brandneu);</programlisting>
+
+ <para>Dies soll folgende Ausgabe liefern:</para>
+
+ <screen>Kurbelwelle, Teilenummer:12345
+Bezeichnung unbekannt, Teilenummer:54321</screen>
+
+ <para>Ergänzen Sie die Klasse <classname>Ersatzteil</classname> um einen passenden Konstruktor, <code>private</code> Attribute und eine <methodname xlink:href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#toString--">toString()</methodname> Methode.</para>
+
+ <tip>
+ <itemizedlist>
+ <listitem>
+ <para>Das Kontextmenü <quote><foreignphrase xml:lang="en">Source</foreignphrase></quote> → <quote>Override/Implement <foreignphrase xml:lang="en">Methods</foreignphrase>...</quote> in <productname>Eclipse</productname> und die <interfacename xlink:href="https://docs.oracle.com/javase/8/docs/api/java/lang/Override.html">@Override</interfacename> Annotation sind Ihre Freunde.</para>
+ </listitem>
+
+ <listitem>
+ <para>Achten Sie im Hinblick auf die <productname>Junit</productname> Tests sehr genau auf Leerzeichen, Groß/Kleinschreibung etc. in der erzeugten Zeichenkette. Erbsenzähler[innen] sind im Vorteil!</para>
+ </listitem>
+ </itemizedlist>
+ </tip>
+ </listitem>
+
+ <listitem>
+ <para>Zwei Ersatzteil Instanzen sollen bezüglich <methodname>equals()</methodname> genau dann gleich sein, wenn ihre Teilenummern gleich sind. Die Bezeichnung der Teile soll irrelevant sein. Wir betrachten ein Beispiel für das gewünschte Verhalten:</para>
+
+ <programlisting language="java">final Ersatzteil
+ kurbelwelle = new Ersatzteil(12345, "Kurbelwelle"),
+ schwurbelwelle = new Ersatzteil(12345, "Schwurbelwelle"), // Tippfehler?
+ lenkrad = new Ersatzteil(54321, "Lenkrad");
+
+System.out.println("kurbelwelle gleich schwurbelwelle? " +
+ kurbelwelle.equals(schwurbelwelle));
+
+System.out.println("kurbelwelle gleich lenkrad? " +
+ kurbelwelle.equals(lenkrad));</programlisting>
+
+ <para>Dies soll folgende Ausgabe liefern:</para>
+
+ <screen>kurbelwelle gleich schwurbelwelle? true
+kurbelwelle gleich lenkrad? false</screen>
+ </listitem>
+
+ <listitem>
+ <para>Definieren Sie die <classname>Ersatzteil</classname>.<methodname>equals()</methodname> Methode dergestalt, dass sie in abgeleiteten Klassen nicht überschrieben werden <emphasis role="bold">kann</emphasis>.</para>
+ </listitem>
+
+ <listitem>
+ <para>Leiten Sie eine Klasse <classname>Reifen</classname> von <classname>Ersatzteil</classname> im selben <foreignphrase xml:lang="en">Package</foreignphrase> (<emphasis>wichtig für zugehörige <productname>Junit</productname> Tests!</emphasis>) ab.</para>
+
+ <para>Für die Erzeugung von <classname>Reifen</classname> Instanzen soll neben der Teilenummer die maximal erlaubte Fahrgeschwindigkeit angegeben werden müssen. Die Teilebezeichnung in der Basisklasse <classname>Ersatzteil</classname> soll automatisch auf <code>"Reifen"</code> gesetzt werden:</para>
+
+ <programlisting language="java">final Reifen reifen = // Reifen mit Teilenummer 1234 und Maximalgeschwindigkeit 160 Km pro Stunde,
+ new Reifen(1234, 160); // Die feste Teilebezeichnung <emphasis role="bold">"Reifen"</emphasis> wird in der
+ // Basisklasse <classname>Ersatzteil</classname> automatisch gesetzt.
+System.out.println(reifen);</programlisting>
+
+ <para>Nutzen Sie Ihre zuvor implementierte <classname>Ersatzteil</classname>.<methodname>toString()</methodname> Methode und überschreiben Sie diese in der Klasse <classname>Reifen</classname> geeignet, damit Sie folgende Ausgabe erhalten:</para>
+
+ <screen>Reifen, Teilenummer:1234, Maximalgeschwindigkeit:160 Kmh</screen>
+
+ <tip>
+ <para>Achten Sie auch diesmal sehr genau auf Leerzeichen, Groß/Kleinschreibung etc. in der erzeugten Zeichenkette. Erbsenzähler[innen] sind weiterhin im Vorteil!</para>
+ </tip>
+ </listitem>
+ </orderedlist>
+ </section>
+
+ <section version="5.1" xml:id="uploadFollow" xml:lang="de">
+ <title>Hochladen Ihrer Lösung in das Klausursystem</title>
+
+ <para>Laden Sie die Lösung dieser Aufgabe als gemeinsamen Projekt Export mit der ersten Aufgabe <xref linkend="task1"/> gemäß den dortigen Hinweisen hoch. Falls Sie die Aufgabe »<xref linkend="task1"/>« ebenfalls bearbeitet haben, enthält Ihr <foreignphrase xml:lang="en">Upload</foreignphrase> die Lösungen zu beiden Aufgaben.</para>
+
+ <para>Tragen Sie im Freitextfeld weiter unten genau einen der beiden Texte ein:</para>
+
+ <itemizedlist>
+ <listitem>
+ <para>Ich habe die aktuelle Aufgabe bearbeitet und erhoffe dafür Punkte.</para>
+ </listitem>
+
+ <listitem>
+ <para>Ich habe die aktuelle Aufgabe nicht bearbeitet.</para>
+ </listitem>
+ </itemizedlist>
+ </section>
+ </chapter>
+</book>
diff --git a/Klausuren/Sd1/2017Summer/Solve/Doc/task1.html b/Klausuren/Sd1/2017Summer/Solve/Doc/task1.html
new file mode 100644
index 0000000000000000000000000000000000000000..78792820f2eedc45f215c85c5d15e5f843fd6fb8
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Solve/Doc/task1.html
@@ -0,0 +1,131 @@
+<html xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xila="http://www.w3.org/2001/XInclude/local-attributes" xmlns:xi="http://www.w3.org/2001/XInclude" xmlns:trans="http://docbook.org/ns/transclusion" xmlns:svg="http://www.w3.org/2000/svg" xmlns:m="http://www.w3.org/1998/Math/MathML" xmlns:html="http://www.w3.org/1999/xhtml" xmlns:db="http://docbook.org/ns/docbook"><body>
+
+
+
+
+
+ <h1>Vorbereitung</h1>
+
+ <p>Entpacken Sie das oben sichtbare Archiv <span style="color: #810000;">exam.zip</span> und importieren Sie den resultierenden Ordner <span style="color: #810000;">Exam</span> als <emph>Maven</emph> Projekt in Ihren <emph>Eclipse</emph><span> </span><emph>Workspace</emph>.</p>
+
+
+
+ <h1>Beschreibung</h1>
+
+ <p>Implementierung vorbereiteter Methoden gemäß <emph>Javadoc</emph> Beschreibungen und nachfolgend beschriebener Funktionalitäten. Sie bekommen bei unvollständiger Implementierung Teilpunkte.</p>
+
+
+
+ <h1>Aufgabe</h1>
+
+ <p>Vervollständigen Sie die Implementierung aller Methoden aus folgenden Klassen im <emph>package</emph><span> </span><span style="font-size:90%; font-family: 'Lucida Console', Monaco, monospace; color: #FB6019;">de.hdm_stuttgart.mi.sd1.aufgabe1</span>:</p>
+
+ <ul>
+ <li>
+ <p><span style="font-size:90%; font-family: 'Lucida Console', Monaco, monospace;color: #FB9C19;">HandyAbrechnung</span></p>
+ </li>
+
+ <li>
+ <p><span style="font-size:90%; font-family: 'Lucida Console', Monaco, monospace;color: #FB9C19;">Helper</span></p>
+ </li>
+
+ <li>
+ <p><span style="font-size:90%; font-family: 'Lucida Console', Monaco, monospace;color: #FB9C19;">StringHaeufigkeiten</span></p>
+ </li>
+ </ul>
+
+ <div style="display: block; width: fit-content; border-radius: 10px; padding: 5px; border-style: solid; border-color: #CCCCCC; border-width: 1px; background-color: #DEFBDE;"><p>Hinweis:</p>
+ <p>Das <emph>package</emph><span> </span><span style="font-size:90%; font-family: 'Lucida Console', Monaco, monospace; color: #FB6019;">de.hdm_stuttgart.mi.sd1.aufgabe1</span> im Test Zweig Ihres Projekts enthält drei zugehörige <emph>Junit</emph> Testklassen:</p>
+
+ <ul>
+ <li>
+ <p><span style="font-size:90%; font-family: 'Lucida Console', Monaco, monospace;color: #FB9C19;">Test_HandyAbrechnung</span></p>
+ </li>
+
+ <li>
+ <p><span style="font-size:90%; font-family: 'Lucida Console', Monaco, monospace;color: #FB9C19;">Test_Helper</span></p>
+ </li>
+
+ <li>
+ <p><span style="font-size:90%; font-family: 'Lucida Console', Monaco, monospace;color: #FB9C19;">Test_StringHaeufigkeiten</span></p>
+ </li>
+ </ul>
+ </div>
+
+
+
+ <h1>Allgemeine Hinweise</h1>
+
+ <ul>
+ <li>
+ <p>Für jede Methode stehen Ihnen in der zugehörigen Testklasse 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 einzelnen Test lediglich »fast richtig« ist. Implementieren Sie im Zweifelsfall weniger Methoden, diese dafür aber vollständig.</p>
+ </li>
+
+ <li>
+ <p>Die <emph>Javadoc</emph> Kommentare der jeweiligen Methoden beschreiben das gewünschte Verhalten. Unter <a href="https://freedocs.mi.hdm-stuttgart.de/sd1SectMavenGenerateJavadoc.html" target="_blank">Generating Javadoc™ project documentation</a> finden Sie eine Anleitung zur Umwandlung in das HTML Format zwecks besserer Lesbarkeit.</p>
+
+ <p>Lesen Sie die (generierte) Dokumentation <strong>sehr genau</strong>.</p>
+ </li>
+
+ <li>
+ <p>Beachten Sie alle Sonderfälle. Dazu zählen insbesondere <code style="font-size:90%; color:black; font-family: "Lucida Console", Monaco, monospace; background-color: #F3ECFF;">null</code> Werte von Variablen oder enthaltene <code style="font-size:90%; color:black; font-family: "Lucida Console", Monaco, monospace; background-color: #F3ECFF;">null</code> Werte in <emph>Arrays</emph>.</p>
+ </li>
+
+ <li>
+ <p>Nutzen Sie den <emph>Debugger</emph> oder logging <emph>Statements</emph> im Fall fehlgeschlagener Testfälle.</p>
+ </li>
+
+ <li>
+ <p>Die Ausführung von <span style="font-size:90%; font-family: 'Lucida Console', Monaco, monospace; color: #FB6019;">de.hdm_stuttgart.mi.sd1.test</span>.<span style="font-size:90%; font-family: 'Lucida Console', Monaco, monospace;color: #FB9C19;">ShowAllReachedPoints</span> im Testzweig Ihres Projekts als <emph>Java</emph> Anwendung (nicht als Junit Test!) zeigt Ihnen zu jedem Zeitpunkt die in allen Programmieraufgaben bislang erreichten Punkte.</p>
+ </li>
+ </ul>
+
+
+
+ <h1>Hochladen Ihrer Lösung in das Klausursystem</h1>
+
+ <p>Exportieren Sie Ihre Implementierung dieser und weiterer Programmieraufgaben per Rechtsklick im <emph>Package Explorer</emph> Ihres <emph>Eclipse</emph> Projekts. Klicken Sie im <emph>Package Explorer</emph> (Maus Rechtsklick) auf Ihre Projektwurzel und exportieren Sie über das Kontextmenü »Export« → »General« → »Archive File« einen auf <span style="color: #810000;">.zip</span> endenden Archivnamen, z.B. <span style="color: #810000;">solution_1.zip</span>. Laden Sie danach <span style="color: #810000;">solution_1.zip</span> über die »<emph>Upload</emph> File« Funktion am unteren Seitenende des <emph>Ilias</emph> Klausursystems hoch. Wichtige Punkte:</p>
+
+ <ul>
+ <li>
+ <p>Achten Sie auf vollständigen Export. Im Exportmenü können Sie (versehentlich) einzelne Ordner, wie z.B. <span style="color: #810000;">src</span>, abwählen. In diesem Fall wird Ihr Quellcode nicht in das Archiv <span style="color: #810000;">solution_1.zip</span> exportiert.</p>
+ </li>
+
+ <li>
+ <p>Wählen Sie beim Hochladen nicht die falsche Datei, etwa das Ausgangsarchiv <span style="color: #810000;">exam.zip</span> oder eine ältere Version Ihres Projekts.</p>
+ </li>
+
+ <li>
+ <p>Kontrollieren Sie nach dem Hochladen die Sichtbarkeit Ihres <span style="color: #810000;">solution_1.zip</span> Archivs im Klausursystem.</p>
+ </li>
+
+ <li>
+ <p>Sie können mehrere Versionen <span style="color: #810000;">solution_2.zip</span> ... hochladen und bei Bedarf ältere im <emph>Ilias</emph> System löschen. Nur die zuletzt hochgeladene Version wird bewertet.</p>
+ </li>
+ </ul>
+
+ <div style="display: block; width: fit-content; border-radius: 10px; padding: 5px; border-style: solid; border-color: #CCCCCC; border-width: 1px; background-color: #FFDFDF;"><p>Achtung:</p>
+ <ul>
+ <li>
+ <p>Reservieren Sie für den Vorgang des Hochladens ausreichend Zeit vor Klausurende.</p>
+ </li>
+
+ <li>
+ <p>Bearbeitungen, welche sich nach Klausurende lediglich auf Ihrem Arbeitsplatzrechner befinden, werden nicht gewertet.</p>
+ </li>
+
+ <li>
+ <p>Laden Sie keine Projekte mit <emph>Java</emph> Syntaxfehlern hoch, diese werden nicht bewertet!</p>
+ </li>
+
+ <li>
+ <p>Exportieren Sie Ihr Projekt nicht als <span style="color: #810000;">.tgz</span>, <span style="color: #810000;">.java</span>, <span style="color: #810000;">.tar.gz</span><span> </span><strong>o.ä.</strong>. Das Klausursystem akzeptiert nur Archive mit der Endung <span style="color: #810000;">.zip</span>.</p>
+ </li>
+ </ul>
+ </div>
+
+ </body></html>
\ No newline at end of file
diff --git a/Klausuren/Sd1/2017Summer/Solve/Doc/task2.html b/Klausuren/Sd1/2017Summer/Solve/Doc/task2.html
new file mode 100644
index 0000000000000000000000000000000000000000..67480852d60f579ec10f16d75e0fc2d3731106bc
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Solve/Doc/task2.html
@@ -0,0 +1,117 @@
+<html xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xila="http://www.w3.org/2001/XInclude/local-attributes" xmlns:xi="http://www.w3.org/2001/XInclude" xmlns:trans="http://docbook.org/ns/transclusion" xmlns:svg="http://www.w3.org/2000/svg" xmlns:m="http://www.w3.org/1998/Math/MathML" xmlns:html="http://www.w3.org/1999/xhtml" xmlns:db="http://docbook.org/ns/docbook"><body>
+
+
+
+ <h1>Vorbereitung</h1>
+
+ <p>Falls Sie die erste Aufgabe »<span style="font-weight: bold;">Klassenmethoden</span>« bearbeitet haben, arbeiten Sie einfach an Ihrem <emph>Maven</emph> Projekt weiter. Ansonsten lesen Sie bitte die Anleitung in der Aufgabe »<span style="font-weight: bold;">Klassenmethoden</span>« zum <emph>Eclipse</emph><span> </span><emph>Maven</emph> Projektimport sowie weitere Hinweise zum Hochladen in das <emph>Ilias</emph> System.</p>
+
+
+
+ <h1>Beschreibung</h1>
+
+ <p>Implementierung von Methoden und einer neuen Klasse zur Verwaltung von Ersatzteilen.</p>
+
+ <p>Das <emph>Maven</emph> Projektskelett enthält eine Klasse <span style="font-size:90%; font-family: 'Lucida Console', Monaco, monospace;color: #FB9C19;">Ersatzteil</span> im <emph>Package</emph><span> </span><span style="font-size:90%; font-family: 'Lucida Console', Monaco, monospace; color: #FB6019;">de.hdm_stuttgart.mi.sd1.aufgabe2</span>.</p>
+
+ <p>Implementieren Sie die nachfolgend beschriebenen Funktionalitäten. Sie bekommen bei unvollständiger Implementierung Teilpunkte. Nutzen Sie zum Test Ihrer Implementierung die <emph>Junit</emph> Tests in <span style="font-size:90%; font-family: 'Lucida Console', Monaco, monospace; color: #FB6019;">de.hdm_stuttgart.mi.sd1.test.aufgabe2</span>.<span style="font-size:90%; font-family: 'Lucida Console', Monaco, monospace;color: #FB9C19;">Test_Ersatzteil</span>.</p>
+
+
+
+ <h1>Aufgaben</h1>
+
+ <ol>
+ <li>
+ <p>Ein Ersatzteil soll durch Angabe einer Teilenummer und einer Bezeichnung erstellt werden können. Wir betrachten ein Beispiel für das gewünschte Verhalten:</p>
+
+ <pre style="display: block; width: fit-content; border-radius: 10px; padding: 5px; font-size:90%; font-family: 'Lucida Console', Monaco, monospace; background-color: #F3ECFF;">final Ersatzteil kurbelwelle =
+ new Ersatzteil(12345, "Kurbelwelle");
+System.out.println(kurbelwelle);
+
+final Ersatzteil brandneu = // Bezeichnung noch
+ new Ersatzteil(54321, null); // unbekannt.
+System.out.println(brandneu);</pre>
+
+ <p>Dies soll folgende Ausgabe liefern:</p>
+
+ <pre style="display: block; width: fit-content; border-radius: 10px; padding: 5px; font-size:90%; font-family: 'Lucida Console', Monaco, monospace; background-color: #E7FFFE;">Kurbelwelle, Teilenummer:12345
+Bezeichnung unbekannt, Teilenummer:54321</pre>
+
+ <p>Ergänzen Sie die Klasse <span style="font-size:90%; font-family: 'Lucida Console', Monaco, monospace;color: #FB9C19;">Ersatzteil</span> um einen passenden Konstruktor, <code style="font-size:90%; color:black; font-family: "Lucida Console", Monaco, monospace; background-color: #F3ECFF;">private</code> Attribute und eine <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#toString--" target="_blank"><span style="font-size:90%; font-family: 'Lucida Console', Monaco, monospace;color: #C29B07;">toString()</span></a> Methode.</p>
+
+ <div style="display: block; width: fit-content; border-radius: 10px; padding: 5px; border-style: solid; border-color: #CCCCCC; border-width: 1px; background-color: #DEFBDE;"><p>Hinweis:</p>
+ <ul>
+ <li>
+ <p>Das Kontextmenü »<emph>Source</emph>« → »Override/Implement <emph>Methods</emph>...« in <emph>Eclipse</emph> und die <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Override.html" target="_blank"><span style="font-size:90%; font-family: 'Lucida Console', Monaco, monospace;color: #B9B505;">@Override</span></a> Annotation sind Ihre Freunde.</p>
+ </li>
+
+ <li>
+ <p>Achten Sie im Hinblick auf die <emph>Junit</emph> Tests sehr genau auf Leerzeichen, Groß/Kleinschreibung etc. in der erzeugten Zeichenkette. Erbsenzähler[innen] sind im Vorteil!</p>
+ </li>
+ </ul>
+ </div>
+ </li>
+
+ <li>
+ <p>Zwei Ersatzteil Instanzen sollen bezüglich <span style="font-size:90%; font-family: 'Lucida Console', Monaco, monospace;color: #C29B07;">equals()</span> genau dann gleich sein, wenn ihre Teilenummern gleich sind. Die Bezeichnung der Teile soll irrelevant sein. Wir betrachten ein Beispiel für das gewünschte Verhalten:</p>
+
+ <pre style="display: block; width: fit-content; border-radius: 10px; padding: 5px; font-size:90%; font-family: 'Lucida Console', Monaco, monospace; background-color: #F3ECFF;">final Ersatzteil
+ kurbelwelle = new Ersatzteil(12345, "Kurbelwelle"),
+ schwurbelwelle = new Ersatzteil(12345, "Schwurbelwelle"), // Tippfehler?
+ lenkrad = new Ersatzteil(54321, "Lenkrad");
+
+System.out.println("kurbelwelle gleich schwurbelwelle? " +
+ kurbelwelle.equals(schwurbelwelle));
+
+System.out.println("kurbelwelle gleich lenkrad? " +
+ kurbelwelle.equals(lenkrad));</pre>
+
+ <p>Dies soll folgende Ausgabe liefern:</p>
+
+ <pre style="display: block; width: fit-content; border-radius: 10px; padding: 5px; font-size:90%; font-family: 'Lucida Console', Monaco, monospace; background-color: #E7FFFE;">kurbelwelle gleich schwurbelwelle? true
+kurbelwelle gleich lenkrad? false</pre>
+ </li>
+
+ <li>
+ <p>Definieren Sie die <span style="font-size:90%; font-family: 'Lucida Console', Monaco, monospace;color: #FB9C19;">Ersatzteil</span>.<span style="font-size:90%; font-family: 'Lucida Console', Monaco, monospace;color: #C29B07;">equals()</span> Methode dergestalt, dass sie in abgeleiteten Klassen nicht überschrieben werden <strong>kann</strong>.</p>
+ </li>
+
+ <li>
+ <p>Leiten Sie eine Klasse <span style="font-size:90%; font-family: 'Lucida Console', Monaco, monospace;color: #FB9C19;">Reifen</span> von <span style="font-size:90%; font-family: 'Lucida Console', Monaco, monospace;color: #FB9C19;">Ersatzteil</span> im selben <emph>Package</emph> (<strong>wichtig für zugehörige <emph>Junit</emph> Tests!</strong>) ab.</p>
+
+ <p>Für die Erzeugung von <span style="font-size:90%; font-family: 'Lucida Console', Monaco, monospace;color: #FB9C19;">Reifen</span> Instanzen soll neben der Teilenummer die maximal erlaubte Fahrgeschwindigkeit angegeben werden müssen. Die Teilebezeichnung in der Basisklasse <span style="font-size:90%; font-family: 'Lucida Console', Monaco, monospace;color: #FB9C19;">Ersatzteil</span> soll automatisch auf <code style="font-size:90%; color:black; font-family: "Lucida Console", Monaco, monospace; background-color: #F3ECFF;">"Reifen"</code> gesetzt werden:</p>
+
+ <pre style="display: block; width: fit-content; border-radius: 10px; padding: 5px; font-size:90%; font-family: 'Lucida Console', Monaco, monospace; background-color: #F3ECFF;">final Reifen reifen = // Reifen mit Teilenummer 1234 und Maximalgeschwindigkeit 160 Km pro Stunde,
+ new Reifen(1234, 160); // Die feste Teilebezeichnung <strong>"Reifen"</strong> wird in der
+ // Basisklasse <span style="font-size:90%; font-family: 'Lucida Console', Monaco, monospace;color: #FB9C19;">Ersatzteil</span> automatisch gesetzt.
+System.out.println(reifen);</pre>
+
+ <p>Nutzen Sie Ihre zuvor implementierte <span style="font-size:90%; font-family: 'Lucida Console', Monaco, monospace;color: #FB9C19;">Ersatzteil</span>.<span style="font-size:90%; font-family: 'Lucida Console', Monaco, monospace;color: #C29B07;">toString()</span> Methode und überschreiben Sie diese in der Klasse <span style="font-size:90%; font-family: 'Lucida Console', Monaco, monospace;color: #FB9C19;">Reifen</span> geeignet, damit Sie folgende Ausgabe erhalten:</p>
+
+ <pre style="display: block; width: fit-content; border-radius: 10px; padding: 5px; font-size:90%; font-family: 'Lucida Console', Monaco, monospace; background-color: #E7FFFE;">Reifen, Teilenummer:1234, Maximalgeschwindigkeit:160 Kmh</pre>
+
+ <div style="display: block; width: fit-content; border-radius: 10px; padding: 5px; border-style: solid; border-color: #CCCCCC; border-width: 1px; background-color: #DEFBDE;"><p>Hinweis:</p>
+ <p>Achten Sie auch diesmal sehr genau auf Leerzeichen, Groß/Kleinschreibung etc. in der erzeugten Zeichenkette. Erbsenzähler[innen] sind weiterhin im Vorteil!</p>
+ </div>
+ </li>
+ </ol>
+
+
+
+ <h1>Hochladen Ihrer Lösung in das Klausursystem</h1>
+
+ <p>Laden Sie die Lösung dieser Aufgabe als gemeinsamen Projekt Export mit der ersten Aufgabe <span style="font-weight: bold;">Klassenmethoden</span> gemäß den dortigen Hinweisen hoch. Falls Sie die Aufgabe »<span style="font-weight: bold;">Klassenmethoden</span>« ebenfalls bearbeitet haben, enthält Ihr <emph>Upload</emph> die Lösungen zu beiden Aufgaben.</p>
+
+ <p>Tragen Sie im Freitextfeld weiter unten genau einen der beiden Texte ein:</p>
+
+ <ul>
+ <li>
+ <p>Ich habe die aktuelle Aufgabe bearbeitet und erhoffe dafür Punkte.</p>
+ </li>
+
+ <li>
+ <p>Ich habe die aktuelle Aufgabe nicht bearbeitet.</p>
+ </li>
+ </ul>
+
+ </body></html>
diff --git a/Klausuren/Sd1/2017Summer/Solve/pom.xml b/Klausuren/Sd1/2017Summer/Solve/pom.xml
new file mode 100644
index 0000000000000000000000000000000000000000..3267b88e9bcfb14c981b55938a001878e7a0053a
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Solve/pom.xml
@@ -0,0 +1,94 @@
+<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.mi.sd1</groupId>
+ <artifactId>sd1_2017sommer_solve</artifactId>
+ <version>0.9</version>
+ <packaging>jar</packaging>
+
+ <name>sd1_2017sommer_solve</name>
+
+ <url>http://www.mi.hdm-stuttgart.de/freedocs/topic/de.hdm_stuttgart.mi.lectures/sd1SectUsingMaven.html</url>
+
+ <properties>
+ <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+ </properties>
+
+ <repositories>
+ <repository>
+ <id>hdm-mi-internal-maven-repo</id>
+ <url>https://maven.mi.hdm-stuttgart.de/artifacts</url>
+ </repository>
+ </repositories>
+
+
+ <dependencies>
+ <dependency>
+ <groupId>junit</groupId>
+ <artifactId>junit</artifactId>
+ <version>4.12</version>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.apache.logging.log4j</groupId>
+ <artifactId>log4j-core</artifactId>
+ <version>2.6</version>
+ </dependency>
+
+ <dependency>
+ <groupId>de.hdm_stuttgart.mi.exam</groupId>
+ <artifactId>unitmarking</artifactId>
+ <version>0.9</version>
+ </dependency>
+
+ </dependencies>
+
+ <build>
+ <plugins>
+
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-compiler-plugin</artifactId>
+ <version>3.5.1</version>
+ <configuration>
+ <source>1.8</source>
+ <target>1.8</target>
+ </configuration>
+ </plugin>
+
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-javadoc-plugin</artifactId>
+ <version>2.10.3</version>
+ <configuration />
+ </plugin>
+
+ <plugin>
+ <artifactId>maven-assembly-plugin</artifactId>
+ <version>2.3</version>
+ <configuration>
+ <descriptor>src/main/assembly/assembly.xml</descriptor>
+ </configuration>
+ <executions>
+ <execution>
+ <id>make-assembly</id>
+ <phase>package</phase>
+ <goals>
+ <goal>single</goal>
+ </goals>
+ <configuration>
+ <archive>
+ <manifest>
+ <mainClass>de.hdm_stuttgart.mi.sd1.test.ShowReachedPoints</mainClass>
+ </manifest>
+ </archive>
+ </configuration>
+ </execution>
+ </executions>
+ </plugin>
+
+ </plugins>
+ </build>
+</project>
diff --git a/Klausuren/Sd1/2017Summer/Solve/src/main/assembly/assembly.xml b/Klausuren/Sd1/2017Summer/Solve/src/main/assembly/assembly.xml
new file mode 100644
index 0000000000000000000000000000000000000000..1a2cd6054a519cef9fe38484b72ae28aba730bc5
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Solve/src/main/assembly/assembly.xml
@@ -0,0 +1,36 @@
+<assembly
+ xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.3"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.3 http://maven.apache.org/xsd/assembly-1.1.3.xsd">
+ <id>fat-tests</id>
+ <formats>
+ <format>jar</format>
+ </formats>
+ <includeBaseDirectory>false</includeBaseDirectory>
+ <dependencySets>
+ <dependencySet>
+ <outputDirectory>/</outputDirectory>
+ <useProjectArtifact>true</useProjectArtifact>
+ <unpack>true</unpack>
+ <scope>test</scope>
+ </dependencySet>
+ </dependencySets>
+ <fileSets>
+ <fileSet>
+ <directory>${project.build.directory}/test-classes</directory>
+ <outputDirectory>/</outputDirectory>
+ <includes>
+ <include>**/*.class</include>
+ </includes>
+ <useDefaultExcludes>true</useDefaultExcludes>
+ </fileSet>
+ <fileSet>
+ <directory>${project.build.directory}/classes</directory>
+ <outputDirectory>/</outputDirectory>
+ <includes>
+ <include>**/*.class</include>
+ </includes>
+ <useDefaultExcludes>true</useDefaultExcludes>
+ </fileSet>
+ </fileSets>
+</assembly>
diff --git a/Klausuren/Sd1/2017Summer/Solve/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/HandyAbrechnung.java b/Klausuren/Sd1/2017Summer/Solve/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/HandyAbrechnung.java
new file mode 100644
index 0000000000000000000000000000000000000000..e82266899f905a7493c2d68f1b6b42059f68c467
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Solve/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/HandyAbrechnung.java
@@ -0,0 +1,48 @@
+package de.hdm_stuttgart.mi.sd1.aufgabe1;
+
+/**
+ * Monatliche Abrechnung von Handykosten. Es gelten folgende Regeln:
+ *
+ */
+public class HandyAbrechnung {
+
+ /**
+ * Minutenkosten Inland in Euro-Cent.
+ */
+ static public final int inlandPreisProMinute = 9;
+
+ /**
+ * Minutenkosten Ausland (Roaming) in Euro-Cent.
+ */
+ static public final int auslandPreisProMinute = 89;
+
+ /**
+ * Anzahl der kostenlosen Freiminuten für Inlandsgespräche.
+ */
+ static public final int freiminutenInland = 100;
+
+ /**
+ * @param inlandMinuten Anzahl der im Abrechnungszeitraum telefonierten Minuten im Inland.
+ *
+ * @param auslandMinuten Anzahl der im Abrechnungszeitraum telefonierten Minuten im Ausland (Roaming).
+ *
+ * @return Zu zahlender Betrag in Cent. Es gelten folgende Regeln:
+ * <ul>
+ * <li>Von den Inlandsminuten werden zunächst die Freiminuten {@link #freiminutenInland} abgezogen. Bleiben
+ * dann noch Gesprächsminuten übrig, so werden diese mit {@link #inlandPreisProMinute} berechnet.</li>
+ *
+ * <li>Auslandsminuten werden gemäß {@link #auslandPreisProMinute} berechnet.</li>
+ * </ul>
+ *
+ */
+ public static int getMonatskosten (final int inlandMinuten, final int auslandMinuten) {
+
+ final int auslandKosten = auslandMinuten * auslandPreisProMinute;
+
+ if (freiminutenInland < inlandMinuten) {
+ return auslandKosten + (inlandMinuten - freiminutenInland) * inlandPreisProMinute;
+ } else {
+ return auslandKosten;
+ }
+ }
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2017Summer/Solve/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/Helper.java b/Klausuren/Sd1/2017Summer/Solve/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/Helper.java
new file mode 100644
index 0000000000000000000000000000000000000000..769643dd36cf7611064a34f6efedfe210b558d7c
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Solve/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/Helper.java
@@ -0,0 +1,97 @@
+package de.hdm_stuttgart.mi.sd1.aufgabe1;
+
+/**
+ * Hilfsmethoden.
+ *
+ */
+public class Helper {
+
+ /**
+ * Spezialwert: Es gibt keinen Index mit den geforderten Eigenschaften. Dies ist konsistent, da ein
+ * »echter« Arrayindex mindestens den Wert 0 haben muss.
+ */
+ static public final int INDEX_NOEXIST = -1;
+
+
+ /**
+ * Erzeuge in Abhängigkeit vom übergebenen Wert eine Zeichenkette.
+ *
+ * @param n Der bestimmende Eingangswert.
+ *
+ * @return In Abhängigkeit vom Eingangswert:
+ *
+ * <ul>
+ * <li>"Toll", falls der Eingangswert durch 3 aber nicht durch 5 teilbar ist.</li>
+ * <li>"Super", falls der Eingangswert durch 5, aber nicht durch 3 teilbar ist.</li>
+ * <li>Der Zahlenwert als String (z.B. "7"), falls der Wert weder durch 3 noch durch 5 teilbar ist.</li>
+ * <li>"Supertoll", falls der Eingangswert sowohl durch 3 als auch durch 5 teilbar ist.</li>
+ * </ul>
+ */
+ static public String getSuperToll(int n) {
+ if (0 == n % 5 && 0 == n % 3) {
+ return "Supertoll";
+ } else if (n % 5 == 0) {
+ return "Super";
+ } else if (n % 3 == 0) {
+ return "Toll";
+ } else {
+ return Integer.toString(n);
+ }
+ }
+
+ /**
+ * <p>Der Index des ersten Arrayelements, welches echt größer ist als
+ * die Summe aller Vorgänger.</p>
+ *
+ * <p>Beispiel: Im Array {-1, 2, 1, 5, -3, 22} ist der Index »3« zum Wert 5 gesucht,
+ * da der zugehörige Arraywert »5« noch vor der »22« größer wird, als die Summe
+ * -1 + 2 + 1 == 2 seiner Vorgänger.</p>
+ *
+ * @param werte null oder ein beliebiges Array aus Ganzzahlen.
+ *
+ * @return Falls das Array null ist, weniger als zwei Elemente enthält oder es keinen Index mit der
+ * geforderten Eigenschaft gibt, wird der
+ * Spezialwert {@link #INDEX_NOEXIST} zurückgegeben. Ansonsten der Index des ersten gefundenen Werts
+ * gemäß Beschreibung.
+ *
+ */
+ static public int maxVorgaenger(final int[] werte) {
+ if (null != werte && 2 <= werte.length) {
+ int summe = werte[0];
+ for (int i = 1; i < werte.length; i++) {
+ if (summe < werte[i]) {
+ return i;
+ } else {
+ summe += werte[i];
+ }
+ }
+ }
+ return INDEX_NOEXIST;// Nix gefunden oder null oder weniger als 2 Werte
+ }
+
+ /**
+ * Finde das n-te ungerade Element einer Wertefolge.
+ *
+ * <p>Beispiel: Im Array {3, 2, 0, 1, 4} ist der Wert »1« an der Indexposition »3« das zweite
+ * ungerade Element.</p>
+ *
+ * @param werte Die zu durchsuchenden Werte. Alle Werte sind von null verschieden.
+ * @param n Die gewünschte Position, Start bei 1.
+ *
+ * @return Den Index des n-ten ungeraden Wertes falls es mindestens n ungerade Werte gibt, ansonsten
+ {@link #INDEX_NOEXIST}.
+ */
+ static public int getNtesUngeradesElement(final int[] werte, final int n) {
+ int anzahlUngerade = 0;
+
+ for (int i = 0; i < werte.length; i++) {
+ if (0 != werte[i] % 2) {
+ anzahlUngerade++;
+ if (n == anzahlUngerade) {
+ return i;
+ }
+ }
+ }
+ return INDEX_NOEXIST;
+ }
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2017Summer/Solve/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/StringHaeufigkeiten.java b/Klausuren/Sd1/2017Summer/Solve/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/StringHaeufigkeiten.java
new file mode 100644
index 0000000000000000000000000000000000000000..680751ffdb84405f73cbf6527703bf822c664a22
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Solve/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/StringHaeufigkeiten.java
@@ -0,0 +1,35 @@
+package de.hdm_stuttgart.mi.sd1.aufgabe1;
+
+/**
+ * <p>Betragsdifferenzen von Zahlenfolgen.</p>
+ *
+ */
+public class StringHaeufigkeiten {
+ /**
+ * <p>Wie oft ist eine Zeichenkette in einem vorgegebenen String enthalten?</p>
+ *
+ * <p>Beispiele:</p>
+ *
+ * <ul>
+ * <li>"in" tritt im String "in innerer Windeseile" dreifach auf.</li>
+ * <li> "aua" tritt in "auaua" einmal (nicht doppelt!) auf.</li>
+ * </ul>
+ * @param vorgegeben Der zu durchsuchende String. Die Werte null und leere Zeichenkette ("") sind
+ * ausgeschlossen.
+ * @param enthalten Der potentiell mehrfach enthaltene Teil- String. Der Wert null ist ausgeschlossen.
+ * @return Anzahl des Auftretens des enthaltenen im vorgegebenen String.
+ *
+ * Hinweis: Die Methode {@link String#indexOf(String, int)} leistet gute Dienste.
+ *
+ */
+ static public int getAnzahlAuftreten (final String vorgegeben, final String enthalten) {
+ int anzahl= 0;
+
+ for (int index = 0;
+ 0 <= (index = vorgegeben.indexOf(enthalten, index));
+ index += enthalten.length()) {
+ anzahl++;
+ }
+ return anzahl;
+ }
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2017Summer/Solve/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe2/EqualsExample.java b/Klausuren/Sd1/2017Summer/Solve/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe2/EqualsExample.java
new file mode 100644
index 0000000000000000000000000000000000000000..4aec34aa8e563a40eeb58e95d2c5011c46ea9498
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Solve/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe2/EqualsExample.java
@@ -0,0 +1,33 @@
+package de.hdm_stuttgart.mi.sd1.aufgabe2;
+
+
+public class EqualsExample {
+ public static void main(String[] args) {
+
+final Ersatzteil
+ kurbelwelle = new Ersatzteil(12345, "Kurbelwelle"),
+ schwurbelwelle = new Ersatzteil(12345, "Schwurbelwelle"), // Tippfehler?
+ lenkrad = new Ersatzteil(54321, "Lenkrad");
+
+System.out.println("kurbelwelle gleich schwurbelwelle? " +
+ kurbelwelle.equals(schwurbelwelle));
+
+System.out.println("kurbelwelle gleich lenkrad? " +
+ kurbelwelle.equals(lenkrad));
+
+
+ System.out.println("--------------------------------");
+ reifenToString();
+ }
+
+
+ static void reifenToString() {
+
+
+final Reifen reifen = // Reifen mit Teilenummer 1234 und Maximalgeschwindigkeit 160 Km pro Stunde,
+ new Reifen(1234, 160); // Die feste Teilebezeichnung "Reifen" wird in der
+ // Basisklasse Ersatzteil automatisch gesetzt.
+System.out.println(reifen);
+ }
+
+}
diff --git a/Klausuren/Sd1/2017Summer/Solve/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe2/Ersatzteil.java b/Klausuren/Sd1/2017Summer/Solve/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe2/Ersatzteil.java
new file mode 100644
index 0000000000000000000000000000000000000000..48481e3e628fe534e0a452c4e462e4c501583002
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Solve/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe2/Ersatzteil.java
@@ -0,0 +1,36 @@
+package de.hdm_stuttgart.mi.sd1.aufgabe2;
+
+/**
+ * <p>Ersatzteile.</p>
+ *
+ */
+public class Ersatzteil {
+ private int teilenummer;
+ private String bezeichnung;
+
+ /**
+ * Neues Ersatzteil mit Teilenummer und informeller Bezeichnung
+ *
+ * @param teilenummer
+ * @param bezeichnung
+ */
+ public Ersatzteil(final int teilenummer, final String bezeichnung) {
+ this.teilenummer = teilenummer;
+ this.bezeichnung = bezeichnung;
+ }
+
+ @Override
+ public final boolean equals(Object obj) {
+
+ if (obj instanceof Ersatzteil) {
+ return ((Ersatzteil) obj).teilenummer == teilenummer;
+ } else {
+ return false;
+ }
+ }
+
+ @Override
+ public String toString() {
+ return (null == bezeichnung? "Bezeichnung unbekannt" : bezeichnung) + ", Teilenummer:" + teilenummer;
+ }
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2017Summer/Solve/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe2/Reifen.java b/Klausuren/Sd1/2017Summer/Solve/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe2/Reifen.java
new file mode 100644
index 0000000000000000000000000000000000000000..1c0c1f542693bce1918a799083424c3cf12565a6
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Solve/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe2/Reifen.java
@@ -0,0 +1,22 @@
+package de.hdm_stuttgart.mi.sd1.aufgabe2;
+
+public class Reifen extends Ersatzteil {
+
+ final int maxGeschwindigkeit;
+
+ /**
+ *
+ * @param teilenummer
+ * @param maxGeschwindigkeit Höchstzulässige Geschwindigkeit des Reifens
+ */
+ public Reifen(final int teilenummer, final int maxGeschwindigkeit) {
+ super(teilenummer, "Reifen");
+ this.maxGeschwindigkeit = maxGeschwindigkeit;
+ }
+
+ @Override
+ public String toString() {
+ return super.toString() + ", Maximalgeschwindigkeit:" + maxGeschwindigkeit + " Kmh";
+ }
+
+}
diff --git a/Klausuren/Sd1/2017Summer/Solve/src/main/resources/log4j2.xml b/Klausuren/Sd1/2017Summer/Solve/src/main/resources/log4j2.xml
new file mode 100644
index 0000000000000000000000000000000000000000..130f87a144c4eb0107a846e580c8fa7f5e819fc1
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Solve/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="de.hdm_stuttgart.mi.sd1.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/2017Summer/Solve/src/test/java/de/hdm_stuttgart/mi/sd1/test/ShowReachedPoints.java b/Klausuren/Sd1/2017Summer/Solve/src/test/java/de/hdm_stuttgart/mi/sd1/test/ShowReachedPoints.java
new file mode 100644
index 0000000000000000000000000000000000000000..5c0e3efcfa4faabc1633b3f91c7cd8ad8c4ebc0c
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Solve/src/test/java/de/hdm_stuttgart/mi/sd1/test/ShowReachedPoints.java
@@ -0,0 +1,25 @@
+package de.hdm_stuttgart.mi.sd1.test;
+
+import de.hdm_stuttgart.mi.exam.unitmarking.RunTests;
+import de.hdm_stuttgart.mi.sd1.test.aufgabe1.Test_HandyAbrechnung;
+import de.hdm_stuttgart.mi.sd1.test.aufgabe1.Test_Helper;
+import de.hdm_stuttgart.mi.sd1.test.aufgabe1.Test_StringHaeufigkeiten;
+import de.hdm_stuttgart.mi.sd1.test.aufgabe2.Test_Ersatzteil;
+
+public class ShowReachedPoints {
+
+ /**
+ * Execution reveals the number of reached points.
+ *
+ * @param args Unused
+ */
+ public static void main(String[] args) {
+ RunTests.exec(
+ "Aufgabe 1"
+ , Test_HandyAbrechnung.class
+ , Test_Helper.class
+ , Test_StringHaeufigkeiten.class);
+
+ RunTests.exec("Aufgabe 2", Test_Ersatzteil.class);
+ }
+}
diff --git a/Klausuren/Sd1/2017Summer/Solve/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_HandyAbrechnung.java b/Klausuren/Sd1/2017Summer/Solve/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_HandyAbrechnung.java
new file mode 100644
index 0000000000000000000000000000000000000000..5c5f816b5d653e21badb00f1452a0e17ef78cc44
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Solve/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_HandyAbrechnung.java
@@ -0,0 +1,76 @@
+package de.hdm_stuttgart.mi.sd1.test.aufgabe1;
+
+import org.junit.Assert;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runners.MethodSorters;
+
+import de.hdm_stuttgart.mi.exam.unitmarking.ExaminationTestDefaults;
+import de.hdm_stuttgart.mi.exam.unitmarking.Marking;
+import de.hdm_stuttgart.mi.sd1.aufgabe1.HandyAbrechnung;
+
+/**
+ * <p>Testen des Auftretens eines Teil-String in einem vorgegebenen String.</p>
+ *
+ */
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class Test_HandyAbrechnung extends ExaminationTestDefaults {
+
+ /**
+ * Nur Inland, in Freigrenze
+ */
+ @Test
+ @Marking(points=1)
+ public void test_200() {
+ Assert.assertEquals(0, HandyAbrechnung.getMonatskosten(0, 0));
+ Assert.assertEquals(0, HandyAbrechnung.getMonatskosten(99, 0));
+ Assert.assertEquals(0, HandyAbrechnung.getMonatskosten(100, 0));
+ }
+
+ /**
+ * nur Inland, Ãœber Freigrenze
+ */
+ @Test
+ @Marking(points=2)
+ public void test_220() {
+
+ Assert.assertEquals(HandyAbrechnung.inlandPreisProMinute, HandyAbrechnung.getMonatskosten(101, 0));
+ Assert.assertEquals(7 * HandyAbrechnung.inlandPreisProMinute, HandyAbrechnung.getMonatskosten(107, 0));
+ Assert.assertEquals(123 * HandyAbrechnung.inlandPreisProMinute, HandyAbrechnung.getMonatskosten(223, 0));
+ }
+
+ /**
+ * Nur Ausland
+ */
+ @Test
+ @Marking(points=2)
+ public void test_240() {
+ Assert.assertEquals(HandyAbrechnung.auslandPreisProMinute, HandyAbrechnung.getMonatskosten(0, 1));
+ Assert.assertEquals(22 * HandyAbrechnung.auslandPreisProMinute, HandyAbrechnung.getMonatskosten(0, 22));
+ }
+
+ /**
+ * Kombiniert Inland unter Freigrenze + Ausland
+ */
+ @Test
+ @Marking(points=2)
+ public void test_260() {
+ Assert.assertEquals(14 * HandyAbrechnung.auslandPreisProMinute, HandyAbrechnung.getMonatskosten(99, 14));
+ Assert.assertEquals(15 * HandyAbrechnung.auslandPreisProMinute, HandyAbrechnung.getMonatskosten(100, 15));
+ }
+
+ /**
+ * Kombiniert Inland über Freigrenze + Ausland
+ */
+ @Test
+ @Marking(points=3)
+ public void test_280() {
+ Assert.assertEquals(
+ HandyAbrechnung.inlandPreisProMinute + 14 * HandyAbrechnung.auslandPreisProMinute,
+ HandyAbrechnung.getMonatskosten(101, 14));
+
+ Assert.assertEquals(
+ 125 * HandyAbrechnung.inlandPreisProMinute + 23 * HandyAbrechnung.auslandPreisProMinute,
+ HandyAbrechnung.getMonatskosten(225, 23));
+ }
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2017Summer/Solve/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_Helper.java b/Klausuren/Sd1/2017Summer/Solve/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_Helper.java
new file mode 100644
index 0000000000000000000000000000000000000000..12454cc410408d235fe49ca72d3ea8e30b91706f
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Solve/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_Helper.java
@@ -0,0 +1,223 @@
+package de.hdm_stuttgart.mi.sd1.test.aufgabe1;
+
+import org.junit.Assert;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runners.MethodSorters;
+
+import de.hdm_stuttgart.mi.exam.unitmarking.ExaminationTestDefaults;
+import de.hdm_stuttgart.mi.exam.unitmarking.Marking;
+import de.hdm_stuttgart.mi.sd1.aufgabe1.Helper;
+
+
+/**************************
+ * Abschnitt maxVorgaenger *
+ **************************/
+
+/**
+ * <p>Testen des Auftretens eines Teil-Strings in einem vorgegebenen String.</p>
+ *
+ */
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class Test_Helper extends ExaminationTestDefaults {
+
+ /************************
+ * Abschnitt getSuperToll*
+ ************************/
+
+ /**
+ * Weder noch.
+ */
+ @Test
+ @Marking(points=3)
+ public void test_080() {
+ Assert.assertEquals("2", Helper.getSuperToll(2));
+ Assert.assertEquals("7", Helper.getSuperToll(7));
+ }
+
+ /**
+ * Nur durch 3, aber nicht durch 5 teilbar
+ */
+ @Test
+ @Marking(points=3)
+ public void test_090() {
+ Assert.assertEquals("Toll", Helper.getSuperToll(3));
+ Assert.assertEquals("Toll", Helper.getSuperToll(6));
+ Assert.assertEquals("Toll", Helper.getSuperToll(9));
+ Assert.assertEquals("Toll", Helper.getSuperToll(18));
+ Assert.assertEquals("Toll", Helper.getSuperToll(21));
+ }
+
+ /**
+ * Nur durch 5, aber nicht durch 3 teilbar.
+ */
+ @Test
+ @Marking(points=3)
+ public void test_100() {
+ Assert.assertEquals("Super", Helper.getSuperToll(5));
+ Assert.assertEquals("Super", Helper.getSuperToll(10));
+ Assert.assertEquals("Super", Helper.getSuperToll(20));
+ Assert.assertEquals("Super", Helper.getSuperToll(35));
+ Assert.assertEquals("Super", Helper.getSuperToll(40));
+ }
+
+ /**
+ * Sowohl durch 3 als auch durch 5 teilbar
+ */
+ @Test
+ @Marking(points=3)
+ public void test_110() {
+ Assert.assertEquals("Supertoll", Helper.getSuperToll(0));
+ Assert.assertEquals("Supertoll", Helper.getSuperToll(15));
+ Assert.assertEquals("Supertoll", Helper.getSuperToll(45));
+ }
+
+
+ /***************************
+ * Abschnitt maxVorgaenger *
+ **************************/
+
+ /**
+ * maxVorgaenger(null).
+ */
+ @Test
+ @Marking(points=1)
+ public void test_120() {
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.maxVorgaenger(null));
+ }
+
+ /**
+ * maxVorgaenger Array mit weniger als zwei Werten.
+ */
+ @Test
+ @Marking(points=1)
+ public void test_140() {
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.maxVorgaenger(new int[]{ }));
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.maxVorgaenger(new int[]{ 554 }));
+ }
+
+ /**
+ * maxVorgaenger Zwei Werte, ohne Erfolg.
+ */
+ @Test
+ @Marking(points=2)
+ public void test_160() {
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.maxVorgaenger(new int[]{ 2, 2 }));
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.maxVorgaenger(new int[]{ 3, 2 }));
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.maxVorgaenger(new int[]{ 0, 0 }));
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.maxVorgaenger(new int[]{-3, -3 }));
+ }
+
+ /**
+ * maxVorgaenger Zwei Werte, mit Erfolg.
+ */
+ @Test
+ @Marking(points=2)
+ public void test_180() {
+ Assert.assertEquals(1, Helper.maxVorgaenger(new int[]{ 0, 1 }));
+ Assert.assertEquals(1, Helper.maxVorgaenger(new int[]{ 0, 3 }));
+ Assert.assertEquals(1, Helper.maxVorgaenger(new int[]{ -10, -9 }));
+ Assert.assertEquals(1, Helper.maxVorgaenger(new int[]{ -10, 10 }));
+ Assert.assertEquals(1, Helper.maxVorgaenger(new int[]{ 223, 225 }));
+ }
+
+ /**
+ * Mehrere Werte, kein Erfolg
+ */
+ @Test
+ @Marking(points=2)
+ public void test_200() {
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.maxVorgaenger(new int[]{ 2, 1, 3, -2, 2, 6, 1 }));
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.maxVorgaenger(new int[]{ -5, -7, -12, -25 }));
+ }
+
+ /**
+ * Mehrere Werte, Erfolg
+ */
+ @Test
+ @Marking(points=2)
+ public void test_220() {
+ Assert.assertEquals(5, Helper.maxVorgaenger(new int[]{ 2, -1, 0, 1, 2, 5, 4, 40 }));
+ Assert.assertEquals(3, Helper.maxVorgaenger(new int[]{ 0, -1, -2, -2, 2, 6, 1 }));
+ Assert.assertEquals(3, Helper.maxVorgaenger(new int[]{ 0, 0, 0, 1, 20 }));
+ }
+
+ /************************************
+ * Abschnitt getNtesUngeradesElement *
+ ************************************/
+
+ /**
+ * Leer
+ */
+ @Test
+ @Marking(points=1)
+ public void test_300() {
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.getNtesUngeradesElement(new int[]{}, 1));
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.getNtesUngeradesElement(new int[]{}, 4));
+ }
+
+ /**
+ * Ein Element, negativ
+ */
+ @Test
+ @Marking(points=1)
+ public void test_320() {
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.getNtesUngeradesElement(new int[]{6}, 1));
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.getNtesUngeradesElement(new int[]{6}, 1));
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.getNtesUngeradesElement(new int[]{1}, 2));
+ }
+
+ /**
+ * Ein Element, positiv
+ */
+ @Test
+ @Marking(points=1)
+ public void test_340() {
+ Assert.assertEquals(0, Helper.getNtesUngeradesElement(new int[]{1}, 1));
+ }
+
+ /**
+ * Zwei Elemente, negativ
+ */
+ @Test
+ @Marking(points=1)
+ public void test_30() {
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.getNtesUngeradesElement(new int[]{8, 2}, 1));
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.getNtesUngeradesElement(new int[]{8, 2}, 2));
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.getNtesUngeradesElement(new int[]{1, 4}, 2));
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.getNtesUngeradesElement(new int[]{1, 5}, 3));
+ }
+
+ /**
+ * Zwei Elemente, positiv
+ */
+ @Test
+ @Marking(points=2)
+ public void test_360() {
+ Assert.assertEquals(0, Helper.getNtesUngeradesElement(new int[]{1, 2}, 1));
+ Assert.assertEquals(1, Helper.getNtesUngeradesElement(new int[]{1, 1}, 2));
+ }
+
+ /**
+ * Mehrere Elemente, negativ
+ */
+ @Test
+ @Marking(points=1)
+ public void test_380() {
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.getNtesUngeradesElement(new int[]{-4, 6, 0, -2, 8}, 1));
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.getNtesUngeradesElement(new int[]{-4, 6, 0, -2, 8}, 2));
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.getNtesUngeradesElement(new int[]{ 1, 3, -2, 5, -11}, 5));
+ Assert.assertEquals(Helper.INDEX_NOEXIST, Helper.getNtesUngeradesElement(new int[]{ 1, 3, -2, 5, -11}, 20));
+ }
+
+ /**
+ * Mehrere Elemente, positiv
+ */
+ @Test
+ @Marking(points=1)
+ public void test_400() {
+ Assert.assertEquals(2, Helper.getNtesUngeradesElement(new int[]{-4, 6, 1, -2, 8}, 1));
+ Assert.assertEquals(4, Helper.getNtesUngeradesElement(new int[]{-4, 6, 1, -2, 3}, 2));
+ Assert.assertEquals(0, Helper.getNtesUngeradesElement(new int[]{-3, 6, 1, -2, 3}, 1));
+ }
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2017Summer/Solve/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_StringHaeufigkeiten.java b/Klausuren/Sd1/2017Summer/Solve/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_StringHaeufigkeiten.java
new file mode 100644
index 0000000000000000000000000000000000000000..7a29d642a1f94eaac7e7c116a6deb245f5b696b8
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Solve/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_StringHaeufigkeiten.java
@@ -0,0 +1,79 @@
+package de.hdm_stuttgart.mi.sd1.test.aufgabe1;
+
+import org.junit.Assert;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runners.MethodSorters;
+
+import de.hdm_stuttgart.mi.exam.unitmarking.ExaminationTestDefaults;
+import de.hdm_stuttgart.mi.exam.unitmarking.Marking;
+import de.hdm_stuttgart.mi.sd1.aufgabe1.StringHaeufigkeiten;
+
+/**
+ * <p>Testen des Auftretens eines Teil-String in einem vorgegebenen String.</p>
+ *
+ */
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class Test_StringHaeufigkeiten extends ExaminationTestDefaults {
+
+ /**
+ * Dreifaches Auftreten von "in" im String "in innerer Windeseile"
+ */
+ @Test
+ @Marking(points=3)
+ public void test_200() {
+ Assert.assertEquals(
+ 3,
+ StringHaeufigkeiten.getAnzahlAuftreten("in innerer Windeseile", "in"));
+ }
+ /**
+ * Einfaches Auftreten von "aua" im String "auaua"
+ */
+ @Test
+ @Marking(points=2)
+ public void test_220() {
+ Assert.assertEquals(
+ 1,
+ StringHaeufigkeiten.getAnzahlAuftreten("auaua", "aua"));
+ }
+ /**
+ * "aua" tritt in "auaua" einmal (überlappungsfrei) auf.
+ */
+ @Test
+ @Marking(points=2)
+ public void test_240() {
+ Assert.assertEquals(
+ 1,
+ StringHaeufigkeiten.getAnzahlAuftreten("auaua", "aua"));
+ }
+ /**
+ *
+ */
+ @Test
+ @Marking(points=1)
+ public void test_260() {
+ Assert.assertEquals(
+ 0,
+ StringHaeufigkeiten.getAnzahlAuftreten("", "aua"));
+ }
+ /**
+ *
+ */
+ @Test
+ @Marking(points=1)
+ public void test_280() {
+ Assert.assertEquals(
+ 0,
+ StringHaeufigkeiten.getAnzahlAuftreten("abcdefghi", "uups"));
+ }
+ /**
+ *
+ */
+ @Test
+ @Marking(points=1)
+ public void test_300() {
+ Assert.assertEquals(
+ 1,
+ StringHaeufigkeiten.getAnzahlAuftreten("tim", "tim"));
+ }
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2017Summer/Solve/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe2/Test_Ersatzteil.java b/Klausuren/Sd1/2017Summer/Solve/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe2/Test_Ersatzteil.java
new file mode 100644
index 0000000000000000000000000000000000000000..3d361d709eb036f5173d94f0efddf419453e364b
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Solve/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe2/Test_Ersatzteil.java
@@ -0,0 +1,200 @@
+package de.hdm_stuttgart.mi.sd1.test.aufgabe2;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Modifier;
+
+import javax.management.relation.RelationNotFoundException;
+
+import org.junit.Assert;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runners.MethodSorters;
+
+import de.hdm_stuttgart.mi.exam.unitmarking.ExaminationTestDefaults;
+import de.hdm_stuttgart.mi.exam.unitmarking.Marking;
+import de.hdm_stuttgart.mi.sd1.aufgabe2.Ersatzteil;
+import de.hdm_stuttgart.mi.sd1.test.helper.ReflectClass;
+import de.hdm_stuttgart.mi.sd1.test.helper.ReflectionHelper;
+
+/**
+ * Teste Ersatzteile.
+ *
+ */
+
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class Test_Ersatzteil extends ExaminationTestDefaults {
+
+ final ReflectionHelper rHelper = new ReflectionHelper();
+
+ /**
+ * Korrekte toString() Redefinition.
+ */
+ @Test
+ @Marking(points = 2)
+ public void test_010_toString() {
+ Assert.assertEquals("Holzbalken, Teilenummer:123", new Ersatzteil(123, "Holzbalken").toString());
+ }
+ /**
+ * Korrekte toString() Redefinition.
+ */
+ @Test
+ @Marking(points = 1)
+ public void test_015_toString() {
+ Assert.assertEquals("Bezeichnung unbekannt, Teilenummer:123", new Ersatzteil(123, null).toString());
+ }
+ /**
+ * Objektgleichheit positiv, gleiche Bezeichnung
+ */
+ @Test
+ @Marking(points = 2)
+ public void test_020_equal() {
+ Assert.assertEquals("Keine (geeignete) Ersatzteil.equals() Methode vorhanden! ",
+ null,
+ rHelper.ersatzteil_equals.getRecursiveErrorMsg());
+ Assert.assertEquals(true, new Ersatzteil(23, "Mutter").equals(
+ new Ersatzteil(23, "Mutter")));
+ }
+ /**
+ * Objektgleichheit positiv, ungleiche Bezeichnung
+ */
+ @Test
+ @Marking(points = 2)
+ public void test_030_equalBezeichnungAnders() {
+ Assert.assertEquals("Keine (geeignete) Ersatzteil.equals() Methode vorhanden! ",
+ null,
+ rHelper.ersatzteil_equals.getRecursiveErrorMsg());
+ Assert.assertEquals(true, new Ersatzteil(23, "Mutter").equals(
+ new Ersatzteil(23, "Schraube")));
+ }
+ /**
+ * Objektgleichheit negativ, gleiche Bezeichnung
+ */
+ @Test
+ @Marking(points = 1)
+ public void test_040_verschieden() {
+
+ Assert.assertNull(rHelper.ersatzteil_equals.getRecursiveErrorMsg());
+ Assert.assertNull(rHelper.ersatzteil_equals.assertIsDefinedIn(Ersatzteil.class));
+
+ Assert.assertEquals(false, new Ersatzteil(23, "Mutter").equals(
+ new Ersatzteil(24, "Mutter")));
+ }
+ /**
+ * Objektgleichheit negativ, ungleiche Bezeichnung
+ */
+ @Test
+ @Marking(points = 2)
+ public void test_050_verschiedenBezeichnung() {
+ Assert.assertNull(rHelper.ersatzteil_equals.getRecursiveErrorMsg());
+ Assert.assertNull(rHelper.ersatzteil_equals.assertIsDefinedIn(Ersatzteil.class));
+
+ Assert.assertEquals(false, new Ersatzteil(23, "Mutter").equals(
+ new Ersatzteil(24, "Schraube")));
+ }
+ /**
+ * Objektgleichheit negativ, Vergleich mit null
+ */
+ @Test
+ @Marking(points = 2)
+ public void test_060_verschiedenNull() {
+ Assert.assertNull(rHelper.ersatzteil_equals.getRecursiveErrorMsg());
+ Assert.assertNull(rHelper.ersatzteil_equals.assertIsDefinedIn(Ersatzteil.class));
+
+ Assert.assertEquals(false, new Ersatzteil(23, "Mutter").equals(null));
+ }
+ /**
+ * Objektgleichheit negativ, Vergleich mit String
+ */
+ @Test
+ @Marking(points = 1)
+ public void test_070_verschiedenString() {
+ Assert.assertNull(rHelper.ersatzteil_equals.getRecursiveErrorMsg());
+ Assert.assertNull(rHelper.ersatzteil_equals.assertIsDefinedIn(Ersatzteil.class));
+
+ Assert.assertEquals(false, new Ersatzteil(23, "Mutter").equals("irgendwas"));
+ }
+
+ /**
+ * Alle Ersatzteil Attribute sollen private sein.
+ */
+ @Test
+ @Marking(points = 1)
+ public void test_075_attrib_ersatzteil_private() {
+
+ Assert.assertTrue("Die Klassse 'Ersatzteil' hat kein Attribut", 0 < Ersatzteil.class.getDeclaredFields().length);
+
+ final String nonPrivateAttribs = ReflectClass.getNonPrivateAttributes(Ersatzteil.class);
+ Assert.assertEquals("Folgende Attribute in der Klasse 'Ersatzteil' sind nicht 'private': " + nonPrivateAttribs + ". ",
+ null,
+ nonPrivateAttribs);
+ }
+
+ /**
+ * Definition class Reifen {...}
+ */
+ @Test
+ @Marking(points = 1)
+ public void test_080_classReifen() {
+ Assert.assertEquals(null, rHelper.reifenKlasse.msg);
+ }
+
+ /** modifier & method.getModifiers();
+
+ * Konstruktor Definition public Reifen (int, int){...}
+ */
+ @Test
+ @Marking(points = 1)
+ public void test_200_reifenKonstruktor() {
+ Assert.assertEquals(null, rHelper.reifen_constructor_int_int.getRecursiveMsg());
+ }
+
+ /**
+ * Methode Ersatzteil.equals() in Ersatzteil darf nicht redefinierbar sein
+ */
+ @Test
+ @Marking(points = 1)
+ public void test_077_equalsNichtRedefinierbar() {
+ Assert.assertNull(rHelper.ersatzteil_equals.getRecursiveErrorMsg());
+ Assert.assertNull(rHelper.ersatzteil_equals.assertIsDefinedIn(Ersatzteil.class));
+ Assert.assertNull(rHelper.ersatzteil_equals.assertModifierIsPresent(Modifier.FINAL, "Methode Ersatzteil.equals() darf nicht redefinierbar sein"));
+
+ }
+
+ /**
+ * Methode Reifen.toString() mit korrekter Signatur definiert
+ */
+ @Test
+ @Marking(points = 1)
+ public void test_220_Reifen_toString() {
+ Assert.assertEquals(null, rHelper.reifen_toString.getRecursiveErrorMsg());
+
+ Assert.assertNull(rHelper.reifen_toString.assertIsDefinedIn("de.hdm_stuttgart.mi.sd1.aufgabe2.Reifen"));
+ Assert.assertNull(rHelper.reifen_toString.assertModifierIsPresent(Modifier.PUBLIC));
+
+ }
+
+ /**
+ * Erzeugung Instanz Reifen(final int number) und pruefung toString()
+ */
+ @Test
+ @Marking(points = 2)
+ public void test_400_konstruktorReifen() {
+ Assert.assertEquals(null, rHelper.reifenKlasse.msg);
+ Assert.assertEquals(null, rHelper.reifen_constructor_int_int.getRecursiveMsg());
+
+ Object reifen = null;
+ try {
+ reifen = rHelper.reifen_constructor_int_int.constructor.newInstance(new Object[] {1132, 160});
+ } catch (InstantiationException | IllegalAccessException | IllegalArgumentException
+ | InvocationTargetException e) {
+ Assert.fail("Konnte 'new Reifen(1132, 160)' nicht aufrufen.");
+ return;
+ }
+ try {
+ Assert.assertEquals("Reifen, Teilenummer:1132, Maximalgeschwindigkeit:160 Kmh", rHelper.reifen_toString.method.invoke(reifen, new Object[] {}));
+ } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+ Assert.fail("Konnte 'toString()' für 'new Reifen(1132, 160)' nicht aufrufen.");
+ return;
+ }
+ }
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2017Summer/Solve/src/test/java/de/hdm_stuttgart/mi/sd1/test/helper/ReflectClass.java b/Klausuren/Sd1/2017Summer/Solve/src/test/java/de/hdm_stuttgart/mi/sd1/test/helper/ReflectClass.java
new file mode 100644
index 0000000000000000000000000000000000000000..9f317715f26212c22eb35eb443b9bb05ed4a984a
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Solve/src/test/java/de/hdm_stuttgart/mi/sd1/test/helper/ReflectClass.java
@@ -0,0 +1,107 @@
+package de.hdm_stuttgart.mi.sd1.test.helper;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.Arrays;
+import java.util.stream.Collectors;
+
+
+public class ReflectClass {
+ public ReflectClass(final String className) {
+ this.className = className;
+ Class<?> classTmp = null;
+ String tmpMsg = null;
+ try {
+ classTmp = Class.forName(className);
+ } catch (final ClassNotFoundException e) {
+ tmpMsg = "Die Klasse '" + className + "' wurde nicht gefunden:";
+ }
+ classZ = classTmp;
+ msg = tmpMsg;
+ }
+ public final String className;
+ public final Class<?> classZ;
+ public final String msg;
+
+ /**
+ * @param arguments
+ * @return Class names joined by ',', possibly stripped of "java.lang" component
+ */
+ public static String formatArguments(final Class<?>[] arguments) {
+
+ return Arrays.stream(arguments).
+ map(c -> normalizeClassname(c)).
+ collect(Collectors.joining(", ")).
+ toString();
+ }
+
+ /**
+ *
+ * @param classz
+ * @return The classname possible stripped of "java.lang" component
+ */
+ public static String normalizeClassname(final Class<?> classz) {
+ final Package javaDotLang = Package.getPackage("java.lang"),
+ hostingPackage = classz.getPackage();
+
+ if (null == hostingPackage || !hostingPackage.equals(javaDotLang)) {
+ return classz.getName();
+ } else {
+ return classz.getSimpleName();
+ }
+ }
+
+ /**
+ *
+ * @param classz
+ * @return A string containing all non-private attribute names
+ */
+ public static String getNonPrivateAttributes(final Class<?> classz) {
+
+ final Field[] fields = classz.getDeclaredFields();
+ final StringBuffer results = new StringBuffer();
+ boolean found = false;
+ for (final Field f: fields) {
+ if (0 == (Modifier.PRIVATE & f.getModifiers())) {
+ if (found) {
+ results.append(", ");
+ }
+ results.append(f.getName());
+ found = true;
+ }
+ }
+ if (found) {
+ return results.toString();
+ }
+ return null;
+ }
+ /**
+ * Get modifier cleartext name according to
+ * https://docs.oracle.com/javase/8/docs/api/java/lang/reflect/Modifier.html#field.summary
+ *
+ * @param modifier
+ * @return Clear text name e.g. "final"
+ */
+ static public String getModifierString(final int modifier) {
+
+ switch (modifier) {
+ case Modifier.ABSTRACT: return "abstract";
+ case Modifier.FINAL: return "final";
+ case Modifier.INTERFACE: return "interface";
+ case Modifier.NATIVE: return "native";
+ case Modifier.PRIVATE: return "private";
+ case Modifier.PROTECTED: return "protected";
+ case Modifier.PUBLIC: return "public";
+ case Modifier.STATIC: return "static";
+ case Modifier.STRICT: return "strict";
+ case Modifier.SYNCHRONIZED: return "synchronized";
+ case Modifier.TRANSIENT: return "transient";
+ case Modifier.VOLATILE: return "volatile";
+
+ default:
+ return "Unknown modifier value " + modifier;
+ }
+
+ }
+
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2017Summer/Solve/src/test/java/de/hdm_stuttgart/mi/sd1/test/helper/ReflectConstructor.java b/Klausuren/Sd1/2017Summer/Solve/src/test/java/de/hdm_stuttgart/mi/sd1/test/helper/ReflectConstructor.java
new file mode 100644
index 0000000000000000000000000000000000000000..967f619465b790ea3d93171e21e245190234b754
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Solve/src/test/java/de/hdm_stuttgart/mi/sd1/test/helper/ReflectConstructor.java
@@ -0,0 +1,38 @@
+package de.hdm_stuttgart.mi.sd1.test.helper;
+
+import java.lang.reflect.Constructor;
+
+public class ReflectConstructor {
+
+ public ReflectConstructor(final ReflectClass reflectClass, final Class<?>[] argumentMeta) {
+ this.definingClass = reflectClass;
+ Constructor<?> constructorTmp = null;
+ String tmpMsg = null;
+ if (null == reflectClass.classZ) {
+ tmpMsg = "Folgefehler: Klasse '" + reflectClass.className + "' nicht definiert";
+ } else {
+ try {
+ constructorTmp = reflectClass.classZ.getConstructor(argumentMeta);
+ } catch (NoSuchMethodException | SecurityException e) {
+ tmpMsg = "Kein Konstruktor '" +
+ reflectClass.classZ.getSimpleName() + "(" +
+ ReflectClass.formatArguments(argumentMeta) +
+ ")' in Klasse '" +
+ reflectClass.className + "' gefunden";
+ }
+ }
+ constructor = constructorTmp;
+ msg = tmpMsg;
+ }
+ public String getRecursiveMsg() {
+ if (null == definingClass.msg) {
+ return msg;
+ } else {
+ return "Folgefehler: " + definingClass.msg;
+ }
+ }
+
+ public final ReflectClass definingClass;
+ public final Constructor<?> constructor;
+ private final String msg;
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2017Summer/Solve/src/test/java/de/hdm_stuttgart/mi/sd1/test/helper/ReflectMethod.java b/Klausuren/Sd1/2017Summer/Solve/src/test/java/de/hdm_stuttgart/mi/sd1/test/helper/ReflectMethod.java
new file mode 100644
index 0000000000000000000000000000000000000000..9ffddb78e739128de21622cc39c2d4e231fe02d2
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Solve/src/test/java/de/hdm_stuttgart/mi/sd1/test/helper/ReflectMethod.java
@@ -0,0 +1,120 @@
+package de.hdm_stuttgart.mi.sd1.test.helper;
+
+import java.lang.reflect.Method;
+
+
+/**
+ * Describing a method to be instantiated by its string name within a given class
+ *
+ */
+public class ReflectMethod {
+
+ /**
+ * Metainfo about a method being defined in a given class.
+ *
+ * @param reflectClass Describing the class in question
+ * @param reflectMethodName The method's name.
+ * @param argumentMeta The method's arguments
+ */
+ public ReflectMethod(final ReflectClass reflectClass, final String reflectMethodName, final Class<?>[] argumentMeta) {
+ this.definingReflectClass = reflectClass;
+ Method methodTmp = null;
+ String tmpMsg = null;
+ if (null == reflectClass.classZ) {
+ tmpMsg = "Folgefehler: Klasse '" + reflectClass.className + "' nicht definiert";
+ } else {
+ try {
+ methodTmp = reflectClass.classZ.getMethod(reflectMethodName, argumentMeta);
+ } catch (NoSuchMethodException | SecurityException e) {
+ tmpMsg = "Keine Methode '" + reflectMethodName + "(" + ")' in Klasse '" + reflectClass.className + "' gefunden";
+ }
+ }
+ method = methodTmp;
+ msg = tmpMsg;
+ }
+
+ /**
+ * Ausgangsklasse, in welcher die Methode vorhanden ist.
+ */
+ public final ReflectClass definingReflectClass;
+
+ /**
+ *
+ */
+ public final Method method;
+ private final String msg;
+
+
+ /**
+ * Providing error message in case the searched method was not found
+ * @return Explanation if method was not found, null otherwise
+ */
+ public String getRecursiveErrorMsg() {
+ if (null == definingReflectClass.msg) {
+ return msg;
+ } else {
+ return "Folgefehler: " + definingReflectClass.msg;
+ }
+ }
+
+ /**
+ * Assert whether the method is being defined in a given class.
+ *
+ * @param expectedClass
+ * @return null if defined in expected class, error message otherwise
+ */
+ public String assertIsDefinedIn(final String expectedClass) {
+ final Class<?> definingClass = method.getDeclaringClass();
+
+ if (expectedClass.equals(definingClass.getName())) {
+ return null;
+ } else {
+ return "equals(...) ist in '" + definingClass.getName() + "' definiert, aber nicht in '"+ expectedClass + "'";
+ }
+ }
+
+ /**
+ * Assert whether the method is being defined in a given class.
+ *
+ * @param expectedClass
+ * @return null if defined in expected class, error message otherwise
+ */
+ public String assertIsDefinedIn(final Class<?> expectedClass) {
+ final Class<?> definingClass = method.getDeclaringClass();
+
+ if (expectedClass.equals(definingClass)) {
+ return null;
+ } else {
+ return "equals(...) ist in '" + definingClass.getName() + "' definiert, aber nicht in '"+ expectedClass.getName() + "'";
+ }
+ }
+
+ /**
+ * Check for presence of mandatory modifier.
+ * @param modifier
+ * @return null if desired modifier is present, descriptive message otherwise.
+ *
+ */
+ public String assertModifierIsPresent(final int modifier) {
+
+ if (0 == (modifier & method.getModifiers())) {
+ return "Modifier '" + ReflectClass.getModifierString(modifier) + "' not present";
+ } else {
+ return null;
+ }
+ }
+ /**
+ * Check for presence of mandatory modifier.
+ * @param modifier
+ * @return null if desired modifier is present, descriptive message otherwise.
+ *
+ */
+ public String assertModifierIsPresent(final int modifier, final String msg) {
+
+ if (0 == (modifier & method.getModifiers())) {
+ return msg;
+ } else {
+ return null;
+ }
+ }
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2017Summer/Solve/src/test/java/de/hdm_stuttgart/mi/sd1/test/helper/ReflectionHelper.java b/Klausuren/Sd1/2017Summer/Solve/src/test/java/de/hdm_stuttgart/mi/sd1/test/helper/ReflectionHelper.java
new file mode 100644
index 0000000000000000000000000000000000000000..f51c9cb80217af14d8a02c65cf878ab3f3fcd23f
--- /dev/null
+++ b/Klausuren/Sd1/2017Summer/Solve/src/test/java/de/hdm_stuttgart/mi/sd1/test/helper/ReflectionHelper.java
@@ -0,0 +1,35 @@
+package de.hdm_stuttgart.mi.sd1.test.helper;
+
+public class ReflectionHelper {
+
+ public static final String ersatzteilKlassenName = "de.hdm_stuttgart.mi.sd1.aufgabe2.Ersatzteil",
+ reifenKlassenName = "de.hdm_stuttgart.mi.sd1.aufgabe2.Reifen";
+
+ public ReflectionHelper() {
+
+ // Ersatzteil
+ //
+ ersatzteilKlasse = new ReflectClass(ersatzteilKlassenName);
+ ersatzteil_toString = new ReflectMethod(ersatzteilKlasse, "toString", new Class[]{});
+ ersatzteil_equals = new ReflectMethod(ersatzteilKlasse, "equals", new Class[]{Object.class});
+
+ // Reifen
+ //
+ reifenKlasse = new ReflectClass(reifenKlassenName);
+ reifen_constructor_int_int = new ReflectConstructor(reifenKlasse, new Class[]{Integer.TYPE, Integer.TYPE});
+ reifen_toString = new ReflectMethod(reifenKlasse, "toString", new Class[]{});
+ reifen_equals = new ReflectMethod(reifenKlasse, "equals", new Class[]{Object.class});
+ }
+
+ // Ersatzteil
+ //
+ public final ReflectClass ersatzteilKlasse;
+ public final ReflectMethod ersatzteil_toString, ersatzteil_equals;
+
+ // Reifen
+ //
+ public final ReflectClass reifenKlasse;
+ public final ReflectConstructor reifen_constructor_int_int;
+ public final ReflectMethod reifen_toString, reifen_equals;
+
+}
\ No newline at end of file