diff --git a/Klausuren/Sd1/2016winter/Exam/.gitignore b/Klausuren/Sd1/2016winter/Exam/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..a1c3ab4d08c0f9f91918f21c730272a4711885e8
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/Exam/.gitignore
@@ -0,0 +1,4 @@
+/target/
+/.settings/
+.classpath
+.project
diff --git a/Klausuren/Sd1/2016winter/Exam/pom.xml b/Klausuren/Sd1/2016winter/Exam/pom.xml
new file mode 100644
index 0000000000000000000000000000000000000000..24ebc666988f34e76ee1828847949fb7e1b8e3bb
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/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_2016winter_solve</artifactId>
+ <version>0.9</version>
+ <packaging>jar</packaging>
+
+ <name>sd1_2016winter_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.eval.ShowReachedPoints</mainClass>
+ </manifest>
+ </archive>
+ </configuration>
+ </execution>
+ </executions>
+ </plugin>
+
+ </plugins>
+ </build>
+</project>
diff --git a/Klausuren/Sd1/2016winter/Exam/src/main/assembly/assembly.xml b/Klausuren/Sd1/2016winter/Exam/src/main/assembly/assembly.xml
new file mode 100644
index 0000000000000000000000000000000000000000..8320b9ab496077983148947fdf084b42722c746f
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/Exam/src/main/assembly/assembly.xml
@@ -0,0 +1,28 @@
+<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>
+ </fileSets>
+</assembly>
diff --git a/Klausuren/Sd1/2016winter/Exam/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/Differenzen.java b/Klausuren/Sd1/2016winter/Exam/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/Differenzen.java
new file mode 100644
index 0000000000000000000000000000000000000000..541d69991210823c7e9c499431bbb6573c079a85
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/Exam/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/Differenzen.java
@@ -0,0 +1,45 @@
+package de.hdm_stuttgart.mi.sd1.aufgabe1;
+
+/**
+ * <p>Betragsdifferenzen von Zahlenfolgen.</p>
+ *
+ */
+public class Differenzen {
+ /**
+ * <p>Summe der beiden Betragsdifferenzen von ersten und zweitem
+ * bzw. zweitem und drittem Wert.</p>
+ *
+ * <p>Beispiele</p>
+ *
+ * <ul>
+ * <li> (1, 3, 7), dann ist 3-1 == 2 und 7-3 == 4, ergebnis == 2 + 4, also 6</li>
+ * <li> (2, -3, 5), dann ist -3-2 == -5 und 5-(-3)==8, ergebnis == |-5| + 8, also 13.</li>
+ * </ul>
+ *
+ * @param a Erster Wert
+ * @param b Zweiter Wert
+ * @param c Dritter Wert
+ * @return |b - a| + |c - b|
+ */
+ static public int getDifferenzBetraege (int a, int b, int c) {
+ return 4711; // TODO: Implementiere mich
+ }
+
+ /**
+ * <p>Summe der Betragsdifferenzen eines Arrays aus Ganzzahlen analog zu
+ * {@link #getDifferenzBetraege(int, int, int)}.</p>
+ *
+ * <p>Beispiel:</p>
+ *
+ * <p>werte == {1, 5, 2, 7}, dann haben wir das Ergebnis zu |5 - 1| + |2 - 5| + |7 - 2| == 4 + 3 + 5 == 12</p>
+ *
+ * @param werte Ein Array aus Ganzzahlen oder null
+ * @return <ul>
+ * <li>0, falls null == werte oder werte.length < 2 gilt</li>
+ * <li>Die Summe der Betragsdifferenzen analog zu {@link #getDifferenzBetraege(int, int, int)}</li>
+ * </ul>
+ */
+ static public int getDifferenzBetraege (int[] werte) {
+ return 4711; // TODO: Implementiere mich
+ }
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2016winter/Exam/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/Enthalten.java b/Klausuren/Sd1/2016winter/Exam/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/Enthalten.java
new file mode 100644
index 0000000000000000000000000000000000000000..cf8850808dd66dcd3e030d9395db905f17deadbe
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/Exam/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/Enthalten.java
@@ -0,0 +1,79 @@
+package de.hdm_stuttgart.mi.sd1.aufgabe1;
+
+/**
+ * <p>Sind Zeichenketten gleich oder ineinander enthalten?</p>
+ */
+public class Enthalten {
+
+ /**
+ * Linke Zeichenkette ist in rechter Zeichenkette enthalten
+ */
+ static public final int LINKS_IN_RECHTS_ENTHALTEN = 1;
+ /**
+ * Rechte Zeichenkette ist in linker Zeichenkette enthalten
+ */
+ static public final int RECHTS_IN_LINKS_ENTHALTEN = 2;
+ /**
+ * Zeichenketten sind gleich
+ */
+ static public final int GLEICH = 3;
+ /**
+ * Die Zeichenketten sind nicht ineinander enthalten
+ */
+ static public final int NICHT_ENTHALTEN = 4;
+
+ /**
+ * <p>Ist (mindestens) eine der beiden Zeichenketten in der jeweils anderen
+ * ohne Beachtung von Groß- und Kleinschreibung enthalten?</p>
+ *
+ * <p>Es sind folgende Fälle möglich:</p>
+ *
+ * <ol>
+ * <li>Beide Zeichenketten sind gleich.</li>
+ * <li>Die linke Zeichenkette ist in der rechten enthalten.</li>
+ * <li>Die rechte Zeichenkette ist in der linken enthalten.</li>
+ * <li>Beide Zeichenketten sind nicht ineinander enthalten.</li>
+ * </ol>
+ *
+ * <p>Beispiel zur Verwendung (»Fach«, kleingeschrieben »fach«, ist in »Einfacher« enthalten):</p>
+ *
+ * <blockquote><pre>{@code final String s1 = "Einfacher Test",
+ * s2 = "Fach";
+ *
+ * switch(Helper.istEnthalten(s1, s2)) {
+ * case Helper.RECHTS_IN_LINKS_ENTHALTEN:
+ * System.out.println(s2 + " ist in " + s1 + " enthalten");
+ * break;
+ * ...
+ * }
+ *}</pre></blockquote>
+ *
+ * <p>Für die Ermittlung des Ergebnisses wird die oben aufgeführte Reihenfolge verwendet: Wenn beide Zeichenketten gleich sind,
+ * so sind sie auch in beiden Richtungen ineinander enthalten. Der Wert {@link #GLEICH} wird also
+ * gegenüber {@link #RECHTS_IN_LINKS_ENTHALTEN} und {@link #LINKS_IN_RECHTS_ENTHALTEN} bevorzugt.</p>
+ *
+ *
+ * @param links Die linke, von <code>null</code> verschiedene Zeichenkette.
+ * @param rechts Die rechte, von <code>null</code> verschiedene Zeichenkette.
+ * @return <blockquote><p>Genau einen der Werte mit nachfolgend genannten Prioritäten:</p>
+ * <ol>
+ * <li><p>{@link #GLEICH}</p></li>
+ * <li>
+ * <ul>
+ * <li>{@link #LINKS_IN_RECHTS_ENTHALTEN}</li>
+ * <li>{@link #RECHTS_IN_LINKS_ENTHALTEN}</li>
+ * <li>{@link #NICHT_ENTHALTEN}</li>
+ * </ul>
+ * </li>
+ * </ol></blockquote>
+ * @throws NullPointerException falls mindestens eines der Argumente <code>links</code> oder <code>rechts</code> <code>null</code> ist.
+ */
+
+ public static int istEnthalten(final String links, final String rechts) {
+
+ // Tip: Konvertieren Sie beide Strings einheitlich entweder zur Klein- oder zur Großschreibung
+ // In der java.lag.String Klasse gibt es dafür eine passende Methode.
+
+ return 4711; // TODO: Implementiere mich
+ }
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2016winter/Exam/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/Gaspreise.java b/Klausuren/Sd1/2016winter/Exam/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/Gaspreise.java
new file mode 100644
index 0000000000000000000000000000000000000000..7fe0b6bb0a1a2adc210d346be3c63ac5fc36ad51
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/Exam/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/Gaspreise.java
@@ -0,0 +1,88 @@
+package de.hdm_stuttgart.mi.sd1.aufgabe1;
+
+/**
+ * <p>Jährliche Tarifberechnung für Gasverbraucher. Die Angabe von Gasmengen erfolgt
+ * in Kilowattstunden (kwh).</p>
+ *
+ * <p>Es werden zwei Tarifmodelle angeboten:</p>
+ *
+ * <dl>
+ *
+ * <dt>Kleinverbraucher:</dt>
+ * <dd>
+ * <p>Der jährliche {@link #KLEINVERBRAUCHER_GRUNDPREIS}
+ * ist niedriger als bei Großverbrauchern. Dafür ist der pro
+ * verbrauchter Kilowattstunde berechnete
+ * {@link #KLEINVERBRAUCHER_ARBEITSPREIS} höher.</p>
+ *
+ * <p>Beispiel: Für einen Jahresverbrauch von 5000 Kilowattstunden ergeben sich
+ * die Gesamtkosten zu 50,00€ Grundgebühr + 5000 * 0,12€ = 650,00€</p>
+ * </dd>
+ *
+ * <dt>Großverbraucher:</dt>
+ * <dd>
+ * <p>Der {@link #GROSSVERBRAUCHER_GRUNDPREIS} ist höher als bei Kleinverbrauchern.
+ * Dafür ist der pro verbrauchter Kilowattstunde berechnete
+ * {@link #GROSSVERBRAUCHER_ARBEITSPREIS} niedriger.</p>
+ *
+ * <p>Beispiel: Für einen Jahresverbrauch von 30000 Kilowattstunden ergeben sich
+ * die Gesamtkosten zu 400,00€ Grundgebühr + 30000 * 0,04€ = 1600,00€</p>
+ * </dd>
+ * </dl>
+ *
+ */
+public class Gaspreise {
+
+ /**
+ * Jährlicher Grundpreis in € für Kleinverbraucher.
+ */
+ static public final double KLEINVERBRAUCHER_GRUNDPREIS = 50.00;
+
+ /**
+ * Kosten in € pro Kilowattstunde für Kleinverbraucher.
+ */
+ static public final double KLEINVERBRAUCHER_ARBEITSPREIS = 0.12;
+
+ /**
+ * Jährlicher Grundpreis in € für Großverbraucher.
+ */
+ static public final double GROSSVERBRAUCHER_GRUNDPREIS = 400.00;
+
+ /**
+ * Kosten in € pro Kilowattstunde Großverbraucher.
+ */
+ static public final double GROSSVERBRAUCHER_ARBEITSPREIS = .04;
+
+
+ /**
+ * <p>Gesamtkosten pro Jahr auf Basis des Tarifs für Kleinverbraucher.</p>
+ *
+ * @param kilowattstunden Jahresgasverbrauch
+ * @return Zu zahlender Gesamtbetrag.
+ */
+ static public double getKostenKleinverbrauch(int kilowattstunden) {
+ return 4711; // TODO: Implementiere mich
+ }
+
+ /**
+ * <p>Gesamtkosten pro Jahr auf Basis des Tarifs für Großverbraucher.</p>
+ *
+ * @param kilowattstunden Jahresgasverbrauch
+ * @return Zu zahlender Gesamtbetrag.
+ */
+ static public double getKostenGrossverbrauch(int kilowattstunden) {
+ return 4711; // TODO: Implementiere mich
+ }
+
+ /**
+ * <p>Gesamtkosten pro Jahr auf Basis des günstigsten Tarifs.</p>
+ *
+ * <p>In Abhängigkeit vom Verbrauch wird automatisch der günstigste Tarif ausgewählt.</p>
+ *
+ * @param kilowattstunden Jahresgasverbrauch
+ * @return Zu zahlender Gesamtbetrag.
+ */
+ static public double getKostenGuenstigsterTarif(int kilowattstunden) {
+ return 4711; // TODO: Implementiere mich
+ }
+}
diff --git a/Klausuren/Sd1/2016winter/Exam/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/InternetShop.java b/Klausuren/Sd1/2016winter/Exam/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/InternetShop.java
new file mode 100644
index 0000000000000000000000000000000000000000..091ea48fbd8afbfa9beea82412bcf10ca2e4edf1
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/Exam/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/InternetShop.java
@@ -0,0 +1,68 @@
+package de.hdm_stuttgart.mi.sd1.aufgabe1;
+
+/**
+ * <p>Rabatt- und Versandkostenberechnung.</p>
+ *
+ * <p>Bei Bestellungen müssen folgende Punkte berücksichtigt werden:</p>
+ *
+ * <ul>
+ * <li>Oberhalb eines Mindestbestellwerts erhalten Kunden
+ * einen Rabatt.</li>
+ *
+ * <li>Oberhalb eines (ggf. abweichenden) Mindestbestellwertes
+ * entfallen die Versandkosten.</li>
+ * </ul>
+ *
+ */
+public class InternetShop {
+
+ /**
+ * <p>Ab diesem Betrag wird ein prozentualer Rabatt in
+ * Höhe von {@link #PROZENTUALER_RABATT} gewährt.</p>
+ */
+ static public final double RABATTGRENZE = 300.00;
+ /**
+ * <p>Ab diesem unrabattiertem Bestellwert erfolgt ein
+ * kostenfreier Versand.</p>
+ */
+ static public final double GRENZE_VERSANDFREI = 300.00;
+ /**
+ * <p>Dieser prozentuale Rabatt wird auf Bestellungen gewährt, deren
+ * Summe den Wert von {@link #RABATTGRENZE} erreicht.</p>
+ */
+ static public final double PROZENTUALER_RABATT = 5.0;
+ /**
+ * <p>Versandkosten fallen an für Bestellwerte unterhalb von
+ * {@link #GRENZE_VERSANDFREI}.</p>
+ */
+ static public final double VERSANDKOSTEN = 3.50;
+
+ /**
+ * <p>Berechnung der Gesamtkosten einer Internetbestellung.</p>
+ *
+ * <p>Die Gesamtkosten einer Bestellung werden in folgender Reihenfolge berechnet:</p>
+ *
+ * <ol>
+ *
+ * <li>Falls der Bestellwert mindestens {@link #RABATTGRENZE} beträgt, wird
+ * anteilmäßig {@link #PROZENTUALER_RABATT} vom Bestellwert abgezogen.</li>
+ *
+ * <li>Falls der <b>originale unrabattierte</b> Bestellwert unter
+ * {@link #GRENZE_VERSANDFREI} liegt, wird der in {@link #VERSANDKOSTEN}
+ * hinterlegte Wert addiert.</li>
+ *
+ * </ol>
+ *
+ * <p>Beispiel: Der Kunde bestellt für 400,00 €. Da dies über der Rabattgrenze liegt,
+ * werden zunächst 5% entsprechend 20,00€ abgezogen. Da der unrabattierte
+ * Betrag über der Grenze für kostenfreien Versand liegt, ist 380,00€ zugleich
+ * auch der Endbetrag.</p>
+ *
+ * @param bestellwert Die unrabattierte Summe aller bestellten Artikel.
+ * @return Der Gesamtpreis gemäß Erläuterung.
+ */
+ static public double getGesamtpreis(double bestellwert) {
+
+ return 4711.;// TODO: Implementiere mich
+ }
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2016winter/Exam/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/Vielfache.java b/Klausuren/Sd1/2016winter/Exam/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/Vielfache.java
new file mode 100644
index 0000000000000000000000000000000000000000..8460dccf75db7a5b6393a13d4713500187a376c6
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/Exam/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/Vielfache.java
@@ -0,0 +1,43 @@
+package de.hdm_stuttgart.mi.sd1.aufgabe1;
+
+/**
+ * Stehen zwei Ganzzahlen in der Beziehung »ist Vielfaches von« ?
+ */
+public class Vielfache {
+ /**
+ * <p>Ist <code>a</code> ein <strong>echtes</strong> Vielfaches von <code>b</code>?</p>
+ *
+ * <p>Definition: Für zwei vorzeichenbehaftete Ganzzahlen a und b
+ * gilt: a ist ein <strong>echtes</strong> Vielfaches von b,
+ * wenn es eine Ganzzahl k mit Betrag echt größer 1 gibt,
+ * so dass a = k * b gilt.</p>
+ *
+ * <p>Beispiele:</p>
+ *
+ * <ul>
+ * <li>6 ist echtes Vielfaches von 3 (k == 2)</li>
+ * <li>-10 ist echtes Vielfaches von 2 (k == -5, Betrag 5 )</li>
+ * <li>5 ist kein Vielfaches von 3</li>
+ * <li>3 ist kein echtes Vielfaches von 3 (k == 1, Betrag nicht größer 1)</li>
+ * <li>2 ist kein echtes Vielfaches von -2 (k == -1, Betrag nicht größer 1)</li>
+ * <li>0 ist echtes Vielfaches von 0 (k mit Betrag größer 1 beliebig wählbar)</li>
+ * <li>0 ist kein echtes Vielfaches von Ganzzahlen ungleich 0 (k == 0, Betrag nicht größer 1)</li>
+ * </ul>
+ *
+ * @param a Ist dieser Wert gleich k * b mit 1 < |k| ?
+ * @param b Gibt es ein k mit 1 < |k| so dass k * b den Wert von
+ * a ergibt?
+ * @return <code>true</code> genau dann, wenn entweder
+ * <code>a</code> ein Vielfaches von <code>b</code> oder
+ * umgekehrt <code>b</code> ein Vielfaches von
+ * <code>a</code> ist. Ansonsten <code>false</code>.
+ *
+ * <p style="color: red;font-weight: bold;">Tip: Beachten den
+ * »%«Operator zur Restbildung.</p>
+ */
+ static public boolean istEchtesVielfachesVon(final int a, final int b) {
+ // Tip: Beachten Sie den % Operator zur Restbildung
+
+ return false; // TODO: Implementiere mich
+ }
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2016winter/Exam/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe2/Konto.java b/Klausuren/Sd1/2016winter/Exam/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe2/Konto.java
new file mode 100644
index 0000000000000000000000000000000000000000..2c75838fdd490f554bf4067dc0a5daff57cd73ca
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/Exam/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe2/Konto.java
@@ -0,0 +1,91 @@
+package de.hdm_stuttgart.mi.sd1.aufgabe2;
+
+import java.util.Arrays;
+
+/**
+ * <p>Verwaltung ganzzahliger Geldbeträge. Auf ein Konto können Zu- und
+ * Abbuchungen erfolgen.</p>
+ *
+ * <p>Erfolgreiche Zu- und Abbuchungen werden intern protokolliert, um
+ * Entscheidungen über die Zulässigkeit von Abbuchungen treffen
+ * zu können.</p>
+ *
+ * <p>Hinweis: Die Methode void neueBuchung(final int betrag)
+ * implementiert bereits eine Protokollierung von Zu- und
+ * Abbuchungen durch das Array
+ * <code>zurueckliegendeBuchungen</code>.</p>
+ *
+ */
+public class Konto {
+
+ /**
+ * Bis zu diesem Wert darf ein Konto überzogen werden.
+ */
+ static public final int DISPOLIMIT = 3000;
+
+ int [] zurueckliegendeBuchungen = new int[0];
+
+ /**
+ * Neues Konto mit Anfangsbetrag 0.
+ */
+ public Konto() {
+ // TODO: Implementiere mich
+ }
+
+ /**
+ * <p>Neues Konto mit gegebenem Anfangsbetrag.</p>
+ *
+ * <p>Ein Anfangsbetrag wird nicht als Buchung gewertet.</p>
+ *
+ * @param kontostand Anfangsbetrag des neu erstellten Kontos.
+ */
+ public Konto(final int kontostand) {
+ // TODO: Implementiere mich
+ }
+
+ /**
+ * <p>Zubuchen eines Betrags zum Konto.</p>
+ *
+ * @param betrag Der zuzubuchende Betrag muss positiv sein.
+ * @return true, falls 0 < betrag gilt, sonst false. In letzterem Fall
+ * erfolgt keine Änderung des Kontostands.
+ */
+ public boolean zubuchen(final int betrag) {
+ return true; // TODO: Implementiere mich
+ }
+
+ /**
+ * <p>Abbuchung eines Betrags vom Konto</p>
+ *
+ * <p>Abbuchungen können genau dann erfolgen, wenn nachfolgend beschriebene Bedingungen gelten:</p>
+ *
+ * <ol>
+ * <li>Der abzubuchende Betrag muss positiv sein.</li>
+ * <li>Durch die Abbuchung darf das Dispolimit von 3000 nicht unterschritten werden.</li>
+ * <li>Es sind maximal 5 aufeinanderfolgende erfolgreiche Abbuchungen möglich. Danach muss vor
+ * einer weiteren Abbuchung erst eine <b>erfolgreiche</b> Zubuchung erfolgen.</li>
+ * </ol>
+ *
+ * @param betrag <blockquote>Der abzubuchende Betrag muss positiv sein.</blockquote>
+ * @return <blockquote>true, falls die genannten Bedingungen gelten, sonst false. In letzterem Fall
+ * erfolgt keine Änderung des Kontostands.</blockquote>
+ */
+ public boolean abbuchen(final int betrag) {
+ return false; // TODO: Implementiere mich
+ }
+
+ /**
+ * Aktueller Kontostand.
+ * @return <blockquote>Guthaben sind positiv, Schulden negativ.</blockquote>
+ */
+ public int getKontostand() {
+ return 4711; // TODO: Implementiere mich
+ }
+
+ void neueBuchung(final int betrag) {
+ // Simpel, aber imperformant und verschwenderisch in Bezug
+ // auf Speichernutzung.
+ zurueckliegendeBuchungen = Arrays.copyOf(zurueckliegendeBuchungen, zurueckliegendeBuchungen.length + 1);
+ zurueckliegendeBuchungen[zurueckliegendeBuchungen.length - 1] = betrag;
+ }
+}
diff --git a/Klausuren/Sd1/2016winter/Exam/src/main/resources/log4j2.xml b/Klausuren/Sd1/2016winter/Exam/src/main/resources/log4j2.xml
new file mode 100644
index 0000000000000000000000000000000000000000..130f87a144c4eb0107a846e580c8fa7f5e819fc1
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/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/2016winter/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/ShowReachedPoints.java b/Klausuren/Sd1/2016winter/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/ShowReachedPoints.java
new file mode 100644
index 0000000000000000000000000000000000000000..a9be38a6058e17dbc8030c190f89dec080aaab13
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/ShowReachedPoints.java
@@ -0,0 +1,25 @@
+package de.hdm_stuttgart.mi.sd1.test.aufgabe1;
+
+import de.hdm_stuttgart.mi.exam.unitmarking.RunTests;
+
+/**
+ * On execution both reached and reachable points will be displayed
+ *
+ */
+public class ShowReachedPoints {
+
+ /**
+ * Execution reveals the number of reached points.
+ *
+ * @param args Unused
+ */
+ public static void main(String[] args) {
+
+ RunTests.exec(
+ "Aufgabe 1", Test_Differenzen.class
+ , Test_Enthalten.class
+ , Test_Gaspreise.class
+ , Test_InternetShop.class
+ , Test_Vielfache.class);
+ }
+}
diff --git a/Klausuren/Sd1/2016winter/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_Differenzen.java b/Klausuren/Sd1/2016winter/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_Differenzen.java
new file mode 100644
index 0000000000000000000000000000000000000000..d4b16542374b98522a281cc004d1e7103cefcb7b
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_Differenzen.java
@@ -0,0 +1,93 @@
+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.Differenzen;
+
+/**
+ * <p>Testen von {@link Differenzen#getDifferenzBetraege(int, int, int)}
+ * und {@link Differenzen#getDifferenzBetraege(int[])}.
+ *
+ */
+@SuppressWarnings({"static-method"})
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class Test_Differenzen extends ExaminationTestDefaults {
+
+ /**
+ * Positive Betragsdifferenz
+ */
+ @Test
+ @Marking(points=2)
+ public void test_100_positiveBetragsdifferenz() {
+ Assert.assertEquals(
+ 9, //4 +5
+ Differenzen.getDifferenzBetraege(1, 5, 10));
+ }
+ /**
+ * Gemischte Betragsdifferenz
+ */
+ @Test
+ @Marking(points=2)
+ public void test_110_gemischteBetragsdifferenz() {
+ // |-1 - 4| + |3 - (-1)| == 5 + 4 == 9
+ Assert.assertEquals(
+ 9, // 5 +4
+ Differenzen.getDifferenzBetraege(4, -1, 3));
+ }
+
+ /**
+ * Sonderfall identischer Werte
+ */
+ @Test
+ public void test_130_identischeWerte() {
+ Assert.assertEquals(
+ 0, // 0 +0
+ Differenzen.getDifferenzBetraege(-5, -5, -5));
+ }
+
+ /**
+ * Betragsdifferenz positiver Werte.
+ */
+ @Test
+ public void test_200_positiveWerte() {
+ Assert.assertEquals(
+ 12, // 4 +3 +5
+ Differenzen.getDifferenzBetraege(new int[]{1, 5, 2, 7}));
+ }
+
+ /**
+ * Betragsdifferenz gemischter Werte.
+ */
+ @Test
+ public void test_210_gemischteWerte() {
+
+ Assert.assertEquals(
+ 48, // 6 +7 + 9+15 +11
+ Differenzen.getDifferenzBetraege(new int[]{1, -5, 2, -7, 8, -3}));
+ }
+
+ /**
+ * Sonderfall null.
+ */
+ @Test
+ public void test_220_null() {
+
+ Assert.assertEquals(
+ 0,
+ Differenzen.getDifferenzBetraege(null));
+ }
+
+ /**
+ * Sonderfall Arraylänge kleiner 2.
+ */
+ @Test
+ public void test_230_laengeKleinerZwei() {
+ Assert.assertEquals(0, Differenzen.getDifferenzBetraege(new int[]{}));
+ Assert.assertEquals(0, Differenzen.getDifferenzBetraege(new int[]{-14}));
+ }
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2016winter/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_Enthalten.java b/Klausuren/Sd1/2016winter/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_Enthalten.java
new file mode 100644
index 0000000000000000000000000000000000000000..840d515d97cfa2f3b9a38cb694e14dc0e413c072
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_Enthalten.java
@@ -0,0 +1,96 @@
+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.Enthalten;
+
+/**
+ * Testen von {@link Enthalten}.
+ *
+ */
+@SuppressWarnings({"static-method"})
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class Test_Enthalten extends ExaminationTestDefaults {
+
+ /**
+ * Die linke Zeichenkette ist in der Rechten enthalten. Diese sind aber nicht gleich.
+ *
+ */
+ @Test
+ public void test_100_inZweitemEnthalten() {
+ Assert.assertEquals(Enthalten.LINKS_IN_RECHTS_ENTHALTEN, Enthalten.istEnthalten("Ist", "Das ist richtig"));
+ }
+
+ /**
+ * Die rechte Zeichenkette ist in der linken enthalten. Diese sind aber nicht gleich.
+ *
+ */
+ @Test
+ public void test_110_inErstemEnthalten() {
+ Assert.assertEquals(Enthalten.RECHTS_IN_LINKS_ENTHALTEN, Enthalten.istEnthalten("eins ZwEi drei", "zWei"));
+ }
+
+ /**
+ * Bis auf Groß- und Kleinschreibung sind beide Zeichenketten gleich.
+ */
+ @Test
+ @Marking(points=2)
+ public void test_130_EqualsGrossKleinSchreibung() {
+ Assert.assertEquals(Enthalten.GLEICH, Enthalten.istEnthalten("Test", "test"));
+ }
+
+ /**
+ * Zwei unterschiedliche Zeichenketten, welche wechselseitig nicht ineinander enthalten sind.
+ *
+ */
+ @Test
+ public void test_140_Verschieden() {
+ Assert.assertEquals(Enthalten.NICHT_ENTHALTEN, Enthalten.istEnthalten("Dieses", "und etwas anderes"));
+ }
+
+ /**
+ * Wenn mindestens eine der beiden Zeichenketten null ist, muss
+ * eine NullPointerException geworfen werden.
+ */
+ @Test
+ public void test_150_ErwarteteNullPointerException() {
+
+ final String keineExceptionMeldung = "Die erwartete " + NullPointerException.class.getName() +
+ " wurde nicht geworfen.";
+
+ { // Zweiter Wert null
+ boolean exceptionGeworfen = false;
+ try {
+ Enthalten.istEnthalten("Test", null);
+ } catch (@SuppressWarnings("unused") final NullPointerException e) {
+ exceptionGeworfen = true;
+ }
+ Assert.assertTrue(keineExceptionMeldung, exceptionGeworfen);
+ }
+
+ { // Erster Wert null
+ boolean exceptionGeworfen = false;
+ try {
+ Enthalten.istEnthalten(null, "Test");
+ } catch (@SuppressWarnings("unused") final NullPointerException e) {
+ exceptionGeworfen = true;
+ }
+ Assert.assertTrue(keineExceptionMeldung, exceptionGeworfen);
+ }
+
+ { // Beide Werte null
+ boolean exceptionGeworfen = false;
+ try {
+ Enthalten.istEnthalten(null, null);
+ } catch (@SuppressWarnings("unused") final NullPointerException e) {
+ exceptionGeworfen = true;
+ }
+ Assert.assertTrue(keineExceptionMeldung, exceptionGeworfen);
+ }
+ }
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2016winter/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_Gaspreise.java b/Klausuren/Sd1/2016winter/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_Gaspreise.java
new file mode 100644
index 0000000000000000000000000000000000000000..bda5231df4ad0e4f4c1285ef381e5332255d2d9f
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_Gaspreise.java
@@ -0,0 +1,95 @@
+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.Gaspreise;
+
+/**
+ * Teste Jährliche Gaspreise basierend auf Verbrauchsangaben.
+ *
+ */
+@SuppressWarnings({"static-method"})
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class Test_Gaspreise extends ExaminationTestDefaults {
+
+ /**
+ * Toleranz bei Rundungsfehlern in double Vergleichen. Erläuterung
+ * siehe z.B. {@link Assert#assertEquals(double, double, double)}.
+ */
+ static public final double testDelta = 1.E-10;
+
+
+ /**
+ * Geringverbrauchertarif, Nullverbrauch
+ */
+ @Test
+ public void test_010_geringverbrauchNullGasabnahme() {
+ Assert.assertEquals(Gaspreise.KLEINVERBRAUCHER_GRUNDPREIS,
+ Gaspreise.getKostenKleinverbrauch(0),
+ testDelta);
+ }
+
+ /**
+ * Geringverbrauchertarif, Verbrauch 1500 und 3000
+ */
+ @Test
+ public void test_012_gerinverbrauchZweiWerte() {
+ double erwartet = Gaspreise.KLEINVERBRAUCHER_GRUNDPREIS
+ + Gaspreise.KLEINVERBRAUCHER_ARBEITSPREIS * 1500;
+ Assert.assertEquals(erwartet,
+ Gaspreise.getKostenKleinverbrauch(1500),
+ testDelta);
+
+ erwartet = Gaspreise.KLEINVERBRAUCHER_GRUNDPREIS
+ + Gaspreise.KLEINVERBRAUCHER_ARBEITSPREIS * 3000;
+ Assert.assertEquals(erwartet,
+ Gaspreise.getKostenKleinverbrauch(3000),
+ testDelta);
+ }
+
+ /**
+ * Großverbrauchertarif, Nullverbrauch
+ */
+ @Test
+ public void test_020_grossverbrauchNullGasabnahme() {
+ Assert.assertEquals(Gaspreise.GROSSVERBRAUCHER_GRUNDPREIS,
+ Gaspreise.getKostenGrossverbrauch(0),
+ testDelta);
+ }
+
+
+ /**
+ * Großverbrauchertarif, Verbrauch 20000 und 60000
+ */
+ @Test
+ public void test_022_grossverbrauchZweiWerte() {
+ double erwartet = Gaspreise.GROSSVERBRAUCHER_GRUNDPREIS
+ + Gaspreise.GROSSVERBRAUCHER_ARBEITSPREIS * 20000;
+ Assert.assertEquals(erwartet,
+ Gaspreise.getKostenGrossverbrauch(20000),
+ testDelta);
+
+ erwartet = Gaspreise.GROSSVERBRAUCHER_GRUNDPREIS
+ + Gaspreise.GROSSVERBRAUCHER_ARBEITSPREIS * 60000;
+
+ Assert.assertEquals(erwartet,
+ Gaspreise.getKostenGrossverbrauch(60000),
+ testDelta);
+}
+/**
+ * Gleichheit beider Tarife bei 4375 Kilowattstunden Verbrauch.
+ */
+ @Test
+ @Marking(points=2)
+ public void test_080_tarifeIdentisch() {
+ Assert.assertEquals(Gaspreise.getKostenGrossverbrauch(4375),
+ Gaspreise.getKostenKleinverbrauch(4375),
+ testDelta);
+ }
+
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2016winter/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_InternetShop.java b/Klausuren/Sd1/2016winter/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_InternetShop.java
new file mode 100644
index 0000000000000000000000000000000000000000..a65014a66aecf0532774ba592612294af1857b03
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_InternetShop.java
@@ -0,0 +1,55 @@
+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.InternetShop;
+
+/**
+ * Testen von Hilfsmethoden aus der Klasse {@link InternetShop}.
+ *
+ */
+@SuppressWarnings({"static-method"})
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class Test_InternetShop extends ExaminationTestDefaults {
+
+ /**
+ * Toleranz bei Rundungsfehlern in double Vergleichen. Erläuterung
+ * siehe z.B. {@link Assert#assertEquals(double, double, double)}.
+ */
+ static public final double testDelta = 1.E-10;
+
+ /**
+ * Mit Rabatt, ohne Versandkosten.
+ */
+ @Test
+ @Marking(points=2)
+ public void test_10_rabattKeineVersandkosten() {
+ final double wert=400;
+ Assert.assertEquals(wert * (100 - InternetShop.PROZENTUALER_RABATT) / 100, InternetShop.getGesamtpreis(400), testDelta);
+ }
+
+ /**
+ * Ohne Rabatt, ohne Versandkosten
+ */
+ @Test
+ @Marking(points=2)
+ public void test_11_keinRabattKeineVersandkosten() {
+ final double wert = 200;
+ Assert.assertEquals(wert, InternetShop.getGesamtpreis(wert), testDelta);
+ }
+
+ /**
+ * Ohne Rabatt, mit Versandkosten
+ */
+ @Test
+ @Marking(points=2)
+ public void test_12_keinRabattMitVersandkosten() {
+ final double wert = 80;
+ Assert.assertEquals(wert + InternetShop.VERSANDKOSTEN, InternetShop.getGesamtpreis(wert), testDelta);
+ }
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2016winter/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_Vielfache.java b/Klausuren/Sd1/2016winter/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_Vielfache.java
new file mode 100644
index 0000000000000000000000000000000000000000..6de62c8aa1b38de5404813bcaac4e12805f56d52
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_Vielfache.java
@@ -0,0 +1,82 @@
+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.sd1.aufgabe1.Vielfache;
+
+/**
+ * Testen von {@link Vielfache#istEchtesVielfachesVon(int, int)}
+ *
+ */
+@SuppressWarnings({"static-method"})
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class Test_Vielfache extends ExaminationTestDefaults {
+ /**
+ * Positive echte Vielfache
+ */
+ @Test
+ public void test_300_positivIstVielfaches() {
+ Assert.assertTrue(Vielfache.istEchtesVielfachesVon(6, 2));
+ Assert.assertTrue(Vielfache.istEchtesVielfachesVon(3, 1));
+ }
+ /**
+ * Negative echte Vielfache
+ */
+ @Test
+ public void test_310_negativIstVielfaches() {
+ Assert.assertTrue(Vielfache.istEchtesVielfachesVon(-9, -3));
+ Assert.assertTrue(Vielfache.istEchtesVielfachesVon(-7, -1));
+ }
+
+ /**
+ * Positiv- / Negativwerte gemischt.
+ */
+ @Test
+ public void test_330_gemischtIstVielfaches() {
+ Assert.assertTrue(Vielfache.istEchtesVielfachesVon(12, -4));
+ Assert.assertTrue(Vielfache.istEchtesVielfachesVon(-18, 6));
+ Assert.assertTrue(Vielfache.istEchtesVielfachesVon(-21, 1));
+ Assert.assertTrue(Vielfache.istEchtesVielfachesVon(17, -1));
+ }
+
+ /**
+ * Nicht-Vielfache positiv/positiv oder negativ/negativ
+ */
+ @Test
+ public void test_340_positivKeinVielfaches() {
+ Assert.assertFalse(Vielfache.istEchtesVielfachesVon(8, 3));
+ Assert.assertFalse(Vielfache.istEchtesVielfachesVon(2, 7));
+ Assert.assertFalse(Vielfache.istEchtesVielfachesVon(-8, -3));
+ Assert.assertFalse(Vielfache.istEchtesVielfachesVon(-2, -7));
+ }
+ /**
+ * Nicht-Vielfache gemischt.
+ */
+ @Test
+ public void test_350_gemischtKeinVielfaches() {
+ Assert.assertFalse(Vielfache.istEchtesVielfachesVon(-8, 3));
+ Assert.assertFalse(Vielfache.istEchtesVielfachesVon(-2, 5));
+ Assert.assertFalse(Vielfache.istEchtesVielfachesVon(8, -3));
+ Assert.assertFalse(Vielfache.istEchtesVielfachesVon(2, -5));
+ }
+ /**
+ * Sonderfall 0 und 0.
+ */
+ @Test
+ public void test_340_nullNullIstVielfaches() {
+ Assert.assertTrue(Vielfache.istEchtesVielfachesVon(0, 0));
+ }
+
+ /**
+ * Sonderfall ungleich 0 mit 0.
+ */
+ @Test
+ public void test_350_ungleichNullUndNullKeinVielfaches() {
+ Assert.assertFalse(Vielfache.istEchtesVielfachesVon(5, 0));
+ Assert.assertFalse(Vielfache.istEchtesVielfachesVon(-7, 0));
+ }
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2016winter/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe2/ShowReachedPoints.java b/Klausuren/Sd1/2016winter/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe2/ShowReachedPoints.java
new file mode 100644
index 0000000000000000000000000000000000000000..468267ffd2fb81f72a17fcb7e213c61bbfc06343
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe2/ShowReachedPoints.java
@@ -0,0 +1,20 @@
+package de.hdm_stuttgart.mi.sd1.test.aufgabe2;
+
+import de.hdm_stuttgart.mi.exam.unitmarking.RunTests;
+
+/**
+ * On execution both reached and reachable points will be displayed
+ *
+ */
+public class ShowReachedPoints {
+
+ /**
+ * Execution reveals the number of reached points.
+ *
+ * @param args Unused
+ */
+ public static void main(String[] args) {
+
+ RunTests.exec("Aufgabe 2", Test_Konto.class);
+ }
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2016winter/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe2/Test_Konto.java b/Klausuren/Sd1/2016winter/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe2/Test_Konto.java
new file mode 100644
index 0000000000000000000000000000000000000000..ae2a5dee84d07fb5257588d21364db64f50ac5de
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/Exam/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe2/Test_Konto.java
@@ -0,0 +1,150 @@
+package de.hdm_stuttgart.mi.sd1.test.aufgabe2;
+
+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.Konto;
+
+/**
+ * Teste Verhalten bei Kontoerzeugung, Zu- und Abbuchungen.
+ *
+ */
+@SuppressWarnings({"static-method"})
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class Test_Konto extends ExaminationTestDefaults {
+
+ /**
+ * Korrekter Anfangskontostand und einzelne Zubuchung.
+ */
+ @Test
+ @Marking(points=2)
+ public void testZubuchenDefault() {
+ final Konto konto = new Konto();
+ Assert.assertEquals(0, konto.getKontostand());
+
+ konto.zubuchen(2000);
+ Assert.assertEquals(2000, konto.getKontostand());
+ }
+
+ /**
+ * Anfangsstand negativ und sofortige Abbuchung unterhalb
+ * von {@link Konto#DISPOLIMIT}.
+ */
+ @Test
+ @Marking(points=3)
+ public void testAbbuchenNegativ() {
+ final Konto konto = new Konto(-300);
+ Assert.assertEquals(-300, konto.getKontostand());
+
+ Assert.assertTrue(konto.abbuchen(2000));
+ Assert.assertEquals(-2300, konto.getKontostand());
+ }
+ /**
+ * Nach 5 aufeinanderfolgenden erfolgreichen Abbuchungen ist
+ * keine weitere Abbuchung möglich. Danach erfolgt eine
+ * einzelne Zubuchung gefolgt von einer weiteren Abbuchung.
+ */
+ @Test
+ @Marking(points=2)
+ public void testVerweigereFolge5() {
+ final Konto konto = new Konto();
+ Assert.assertEquals(0, konto.getKontostand());
+
+ // 1. Abbuchung in Folge
+ Assert.assertTrue(konto.abbuchen(100));
+ Assert.assertEquals(-100, konto.getKontostand());
+
+ // 2. Abbuchung in Folge
+ Assert.assertTrue(konto.abbuchen(100));
+ Assert.assertEquals(-200, konto.getKontostand());
+
+ // 3. Abbuchung in Folge
+ Assert.assertTrue(konto.abbuchen(100));
+ Assert.assertEquals(-300, konto.getKontostand());
+
+ // 4. Abbuchung in Folge
+ Assert.assertTrue(konto.abbuchen(100));
+ Assert.assertEquals(-400, konto.getKontostand());
+
+ // 5. Abbuchung in Folge
+ Assert.assertTrue(konto.abbuchen(100));
+ Assert.assertEquals(-500, konto.getKontostand());
+
+ // 6. Abbuchung in Folge, sollte scheitern
+ Assert.assertFalse(konto.abbuchen(100));
+ Assert.assertEquals(-500, konto.getKontostand());
+
+ // 7. Erfolglose Zubuchung (Wert muss positiv sein)
+ Assert.assertFalse(konto.zubuchen(0));
+ Assert.assertEquals(-500, konto.getKontostand());
+
+ // 8. Erfolgreiche Zubuchung
+ Assert.assertTrue(konto.zubuchen(1));
+ Assert.assertEquals(-499, konto.getKontostand());
+
+ // 9. Abbuchung, davor erfolgte eine Zubuchung
+ Assert.assertTrue(konto.abbuchen(100));
+ Assert.assertEquals(-599, konto.getKontostand());
+ }
+
+ /**
+ * Abbuchungen dürfen nur für positive Werte erfolgen. Abbuchungen mit
+ * negativen Werten scheitern und werden nicht erfasst.
+ */
+ @Test
+ @Marking(points=1)
+ public void testFolge5() {
+ final Konto konto = new Konto();
+ Assert.assertEquals(0, konto.getKontostand());
+
+ // 1. erfolglose Abbuchung in Folge
+ Assert.assertFalse(konto.abbuchen(0));
+ Assert.assertEquals(0, konto.getKontostand());
+
+ // 2. erfolglose Abbuchung in Folge
+ Assert.assertFalse(konto.abbuchen(0));
+ Assert.assertEquals(0, konto.getKontostand());
+
+ // 3. erfolglose Abbuchung in Folge
+ Assert.assertFalse(konto.abbuchen(0));
+ Assert.assertEquals(0, konto.getKontostand());
+
+ // 4. erfolglose Abbuchung in Folge
+ Assert.assertFalse(konto.abbuchen(0));
+ Assert.assertEquals(0, konto.getKontostand());
+
+ // 5. erfolglose Abbuchung in Folge
+ Assert.assertFalse(konto.abbuchen(0));
+ Assert.assertEquals(0, konto.getKontostand());
+
+ // Abbuchung nach 5 erfolglosen Abbuchungen.
+ Assert.assertTrue(konto.abbuchen(100));
+ Assert.assertEquals(-100, konto.getKontostand());
+ }
+
+ /**
+ * Abbuchungen an der Grenze zu {@link Konto#DISPOLIMIT}.
+ */
+ @Test
+ @Marking(points=2)
+ public void testDispolimit() {
+ final Konto konto = new Konto(-3000);
+ Assert.assertEquals(-3000, konto.getKontostand());
+
+ // 1. Abbuchung, sollte am Dispolimit scheitern
+ Assert.assertFalse(konto.abbuchen(1));
+ Assert.assertEquals(-3000, konto.getKontostand());
+
+ // 2. Zubuchung
+ Assert.assertTrue(konto.zubuchen(1));
+ Assert.assertEquals(-2999, konto.getKontostand());
+
+ // 3. Abbuchung
+ Assert.assertTrue(konto.abbuchen(1));
+ Assert.assertEquals(-3000, konto.getKontostand());
+ }
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2016winter/Solution/.gitignore b/Klausuren/Sd1/2016winter/Solution/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..a1c3ab4d08c0f9f91918f21c730272a4711885e8
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/Solution/.gitignore
@@ -0,0 +1,4 @@
+/target/
+/.settings/
+.classpath
+.project
diff --git a/Klausuren/Sd1/2016winter/Solution/Doc/a.xhtml b/Klausuren/Sd1/2016winter/Solution/Doc/a.xhtml
new file mode 100644
index 0000000000000000000000000000000000000000..b4b96c71bad60af319d8c6d7d2da1b090daf60b4
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/Solution/Doc/a.xhtml
@@ -0,0 +1,84 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE html>
+<html lang="de" xmlns="http://www.w3.org/1999/xhtml">
+ <head>
+ <title>Klassenmethoden</title>
+ </head>
+
+ <body><h2>Vorbereitung</h2><p>Entpacken Sie das oben sichtbare Archiv
+ <b>exam.zip</b> und importieren Sie den resultierenden Ordner
+ <code>Exam</code> als <span lang="en">Maven</span> Projekt in Ihren <span
+ lang="en">Eclipse Workspace</span>.</p><h2>Aufgabe</h2><p>Vervollständigen
+ Sie die Implementierung aller Methoden aus folgenden Klassen:</p><ul>
+ <li><p><code>de.hdm_stuttgart.mi.sd1.aufgabe1.Differenzen</code></p><p>Zugehörige
+ Junit Tests in
+ <code>de.hdm_stuttgart.mi.sd1.test.aufgabe1.Test_Differenzen</code>.</p></li>
+
+ <li><p><code>de.hdm_stuttgart.mi.sd1.aufgabe1.Enthalten</code></p><p>Zugehörige
+ Junit Tests in
+ <code>de.hdm_stuttgart.mi.sd1.test.aufgabe1.Test_Enthalten</code>.</p></li>
+
+ <li><p><code>de.hdm_stuttgart.mi.sd1.aufgabe1.Gaspreise</code></p><p>Zugehörige
+ Junit Tests in
+ <code>de.hdm_stuttgart.mi.sd1.test.aufgabe1.Test_Gaspreise</code>.</p></li>
+
+ <li><p><code>de.hdm_stuttgart.mi.sd1.aufgabe1.InternetShop</code></p><p>Zugehörige
+ Junit Tests in
+ <code>de.hdm_stuttgart.mi.sd1.test.aufgabe1.Test_InternetShop</code>.</p></li>
+
+ <li><p><code>de.hdm_stuttgart.mi.sd1.aufgabe1.Vielfache</code></p><p>Zugehörige
+ Junit Tests in
+ <code>de.hdm_stuttgart.mi.sd1.test.aufgabe1.Test_Vielfache</code>.</p></li>
+ </ul><h2>Allgemeine Hinweise</h2><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 Test lediglich „fast richtig“ ist.
+ Daher im Zweifelsfall weniger Methoden implementieren, diese dafür aber
+ vollständig.</p></li>
+
+ <li><p>Die Javadoc Kommentare der jeweiligen Methoden beschreiben das
+ gewünschte Verhalten. Unter <a
+ href="https://freedocs.mi.hdm-stuttgart.de/webhelp/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 <b>sehr
+ genau</b>.</p></li>
+
+ <li><p>Beachten Sie alle Sonderfälle. Dazu zählen insbesondere
+ <code><code>null</code></code> Werte übergebener Variablen oder
+ enthaltene null Werte in übergebenen Arrays.</p></li>
+
+ <li><p>Tip: Nutzen Sie den Debugger oder logging Statements im Fall
+ fehlgeschlagener Testfälle, falls Sie zugrundeliegende Probleme nicht
+ unmittelbar lösen können.</p></li>
+ </ul><h2 id="upload">Hochladen Ihrer Lösung in das
+ Klausursystem</h2><p>Exportieren Sie Ihre Implementierung dieser und
+ weiterer Programmieraufgaben per Rechtsklick im Package Explorer Ihres
+ Eclipse Projekts. Wählen Sie im Kontextmenü unter
+ »Export-->General-->Archive File« einen auf <code>.zip</code> endenden
+ Archivnamen. Exportieren Sie Ihr Projekt in dieses <code>.zip</code> Archiv
+ und laden Sie es in das Ilias Klausursystem hoch (unteres Seitenende) und
+ beachten Sie:</p><ul>
+ <li style="color: red;">Die hochgeladene .zip Datei muss im
+ Klausursystem sichtbar sein.</li>
+
+ <li style="color: red;">Reservieren Sie ausreichend Zeit vor Klausurende
+ für den Vorgang des Hochladens. Projekte, welche sich lediglich auf dem
+ Arbeitsplatzrechner befinden, werden nicht gewertet.</li>
+
+ <li style="color: red;">Laden Sie keine Projekte mit Java Syntaxfehlern
+ hoch, diese werden nicht bewertet!</li>
+
+ <li style="color: red;">Exportieren Sie Ihr Projekt <b>nicht</b> als
+ „.tgz“, „.java“, „.tar.gz“ o.ä. Das Klausursystem akzeptiert nur Archive
+ mit der Endung „.zip“.</li>
+ </ul><p>Alternativ können Sie auch sofort nachfolgende Aufgaben bearbeiten
+ und diese gemeinsam mit der Lösung der aktuellen Aufgabe hochladen.
+ Nachfolgende Programmieraufgaben enthalten keine separate Möglichkeit zum
+ Hochladen.</p><p>Falls Sie mehrere Archive hochladen, wird nur das zuletzt
+ hochgeladene Archiv bewertet. Sie können hochgeladene Archive
+ löschen.</p></body>
+</html>
diff --git a/Klausuren/Sd1/2016winter/Solution/Doc/b.xhtml b/Klausuren/Sd1/2016winter/Solution/Doc/b.xhtml
new file mode 100644
index 0000000000000000000000000000000000000000..4d2ede0f23b60e8e908a664a3fa8f8ae06a38e73
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/Solution/Doc/b.xhtml
@@ -0,0 +1,71 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE html>
+<html lang="de" xmlns="http://www.w3.org/1999/xhtml">
+ <head>
+ <title>Konto Buchungseinschränkungen</title>
+ </head>
+
+ <body><h2>Hinweis zur Bewertung</h2><p>Diese Aufgabe erbringt im Vergleich
+ zur ihrer Schwierigkeit eine geringere Punktzahl als die Aufgabe „Helper
+ Methodenâ€.</p><h2>Beschreibung</h2><p>In einer Klasse
+ <code>de.hdm_stuttgart.mi.sd1.konto.Konto</code> soll Folgendes
+ implementiert werden:</p><ol>
+ <li>Einschränkungen in Bezug auf Zu- und Abbuchungen</li>
+
+ <li>Zugriff auf den jeweils aktuellen Kontostand.</li>
+
+ <li>Vorgabe eines Anfangsbetrags beim Erstellen eines neuen Kontos.</li>
+ </ol><p>Die Klasse ist bereits teilweise implementiert: Für ein Konto
+ können unbeschränkt Zu- und Abbuchungen erfolgen. Bei jeder Buchung wird ein
+ Array kopiert und um eine Position vergrößert, um die jeweils neue Buchung
+ aufnehmen zu können.</p><h2>Vorbereitung</h2><p>Sollten Sie die Aufgabe
+ „Helper Methoden†nicht bearbeitet haben, so lesen Sie bitte die dortige
+ Anleitung zum Eclipse Maven Projektimport und weitere allgemeine Hinweise.
+ Ansonsten arbeiten Sie mit Ihrem Eclipse Maven Projekt
+ weiter.</p><h2>Erläuterung</h2><p>Konten sollen mit einem Anfangsbetrag
+ angelegt werden können. Für Instanzen von
+ <code>de.hdm_stuttgart.mi.sd1.aufgabe2.Konto</code> können bislang beliebige
+ Zu- und Abbuchungen durchgeführt werden. Sie sollen diese Zugriffe durch
+ Regeln eingeschränken.</p><p>Der Einfachheit halber werden nur ganzzahlige
+ Beträge vom Typ <code>int</code> betrachtet.</p><p>Sie finden eine
+ detaillierte Beschreibung der gewünschten Einschränkungen in den Javadoc
+ Kommentaren sowohl der Klasse selbst als auch ihrer <code>public</code>
+ Methoden. Diese Regeln sind noch nicht implementiert: Beispielsweise können
+ bislang beliebig hohe Beträge abgehoben
+ werden.</p><h2>Aufgabe</h2><p>Korrigieren Sie die Implementierung der Klasse
+ <code>de.hdm_stuttgart.mi.sd1.aufgabe2.Konto</code>. In den Javadoc
+ Kommentaren werden die gewünschten Regeln beschrieben.</p><p>Hinweis: Die
+ Archivierung der Kontohistorie ist bereits in der Methode <code>void
+ de.hdm_stuttgart.mi.sd1.aufgabe2.Konto.neueBuchung(int betrag)</code>
+ vorbereitet. Die Werte werden im Array <code>int[]
+ de.hdm_stuttgart.mi.sd1.aufgabe2.Konto.zurueckliegendeBuchungen</code> zu
+ Ihrer Unterstützung geführt.</p><h2>Allgemeine Hinweise</h2><ul>
+ <li><p>Für jede Methode stehen Ihnen in
+ <code>de.hdm_stuttgart.mi.sd1.test.aufgabe2.Test_Konto</code> passende
+ Junit Tests zur Verfügung. Nutzen Sie diese!</p></li>
+
+ <li><p>Die Javadoc Kommentare der jeweiligen Methoden beschreiben das
+ gewünschte Verhalten. Unter <a
+ href="https://freedocs.mi.hdm-stuttgart.de/webhelp/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 <b>sehr
+ genau</b>.</p></li>
+
+ <li><p>Beachten Sie die detaillierten Erläuterungen und Tips in den
+ Javadoc Köpfen.</p></li>
+
+ <li>Die „<code>//TODO</code>†Kommentare weisen auf zu ergänzende
+ Codepassagen hin.</li>
+ </ul><h2>Hochladen Ihrer Lösung in das Klausursystem</h2><p>Laden Sie Ihre
+ Lösung als gemeinsamen Projekt Export in der ersten Aufgabe
+ »Klassenmethoden« gemäß den dortigen Hinweisen hoch. Falls Sie diese Aufgabe
+ ebenfalls bearbeiten, enthält Ihr Upload die Lösungen beider
+ Aufgaben.</p><p>Tragen Sie im unten stehenden Freitextfeld genau einen der
+ beiden Texte ein:</p><ol>
+ <li><b>Ich habe die aktuelle Aufgabe bearbeitet und erhoffe dafür
+ Punkte.</b></li>
+
+ <li><b>Ich habe die aktuelle Aufgabe nicht bearbeitet.</b></li>
+ </ol></body>
+</html>
diff --git a/Klausuren/Sd1/2016winter/Solution/Doc/c.xhtml b/Klausuren/Sd1/2016winter/Solution/Doc/c.xhtml
new file mode 100644
index 0000000000000000000000000000000000000000..6f468be20a68f79f3c9d03a27cc25a45363903ca
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/Solution/Doc/c.xhtml
@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE html>
+<html xml:lang="de" xmlns="http://www.w3.org/1999/xhtml">
+ <head>
+ <title></title>
+ </head>
+
+ <body><p>Wir betrachten folgendes Fragment:</p><pre
+ style="color:#000000;background:#ffffff;">...
+<span style="color:#008c00;">08 </span><span
+ style="color:#800000; font-weight:bold; ">final</span> int length = s.length()<span
+ style="color:#808030; ">;</span>
+<span style="color:#008c00;">08 </span>
+<span style="color:#008c00;">10 </span>if (null == s) <span
+ style="color:#800080; ">{</span>
+<span style="border-bottom: 3px solid #FCF1CA;"><span style="color:#008c00;">11 </span> <span
+ style="color:#bb7977; font-weight:bold; ">System</span><span
+ style="color:#808030; ">.</span>out<span style="color:#808030; ">.</span>println<span
+ style="color:#808030; ">(</span><span style="color:#0000e6; ">"String value is null"</span><span
+ style="color:#808030; ">)</span><span style="color:#800080; ">;</span> <b><span
+ style="color:#696969; ">// "Dead code" Warnung</span></b></span>
+<span style="color:#800080; "><span style="color:#008c00;">12 </span>}</span> else <span
+ style="color:#800080; ">{</span>
+<span style="color:#008c00;">13 </span> <span
+ style="color:#bb7977; font-weight:bold; ">System</span><span
+ style="color:#808030; ">.</span>out<span style="color:#808030; ">.</span>println<span
+ style="color:#808030; ">(</span><span style="color:#0000e6; ">"String length is "</span> <span
+ style="color:#808030; ">+</span> length<span style="color:#808030; ">)</span><span
+ style="color:#800080; ">;</span>
+<span style="color:#800080; "><span style="color:#008c00;">14 </span>}</span>
+ ...
+</pre><p>Der Java Compiler liefert für die Zeile 11 eine »Dead code« Warnung.
+ Diese Zeile kann also nie erreicht werden.</p><p>Warum ist das so? Erklären
+ Sie die Ursache.</p><p>Tip: Die Anweisung in Zeile 8 ist
+ wesentlich.</p></body>
+</html>
diff --git a/Klausuren/Sd1/2016winter/Solution/Doc/d.xhtml b/Klausuren/Sd1/2016winter/Solution/Doc/d.xhtml
new file mode 100644
index 0000000000000000000000000000000000000000..9430e79aec19f0a7af4f6f1379099268c4a451df
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/Solution/Doc/d.xhtml
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE html>
+<html xml:lang="de" xmlns="http://www.w3.org/1999/xhtml">
+ <head>
+ <title></title>
+ </head>
+
+ <body><p>Wir betrachten folgendes Fragment:</p><pre
+ style="color:#000000;background:#ffffff;"><span style="color:#008c00;">03 </span><span
+ style="color:#800000; font-weight:bold; ">public</span> <span
+ style="color:#800000; font-weight:bold; ">class</span> Assign <span
+ style="color:#800080; ">{</span>
+<span style="color:#008c00;">04 </span> <span
+ style="color:#800000; font-weight:bold; ">final</span> <span
+ style="color:#bb7977; font-weight:bold; ">Byte</span> a <span
+ style="color:#808030; ">=</span> <span style="color:#008c00; ">200</span> <span
+ style="color:#808030; ">-</span> <span style="color:#008c00; ">100</span><span
+ style="color:#800080; ">;</span>
+<span style="color:#008c00;">05 </span><span
+ style="border-bottom: 2px solid red;"><span
+ style="color:#800000; font-weight:bold; ">final</span> <span
+ style="color:#bb7977; font-weight:bold; ">Byte</span> b <span
+ style="color:#808030; ">=</span> <span style="color:#008c00; ">200</span> <span
+ style="color:#808030; ">+</span> <span style="color:#008c00; ">100</span><span
+ style="color:#800080; ">;</span></span> <b><span
+ style="color:#696969; ">//Type mismatch: cannot convert from int to Byte</span></b>
+<span style="color:#800080; "><span style="color:#008c00;">06 </span>}</span>
+</pre><p>Der Java Compiler liefert für die Zeile 5 eine »Type mismatch: cannot
+ convert from int to Byte« Fehlermeldung.</p><p>Erläutern Sie die Ursache des
+ Fehler und erklären Sie, weshalb die Deklaration in Zeile 4 problemlos
+ akzeptiert wird.</p></body>
+</html>
diff --git a/Klausuren/Sd1/2016winter/Solution/pom.xml b/Klausuren/Sd1/2016winter/Solution/pom.xml
new file mode 100644
index 0000000000000000000000000000000000000000..24ebc666988f34e76ee1828847949fb7e1b8e3bb
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/Solution/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_2016winter_solve</artifactId>
+ <version>0.9</version>
+ <packaging>jar</packaging>
+
+ <name>sd1_2016winter_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.eval.ShowReachedPoints</mainClass>
+ </manifest>
+ </archive>
+ </configuration>
+ </execution>
+ </executions>
+ </plugin>
+
+ </plugins>
+ </build>
+</project>
diff --git a/Klausuren/Sd1/2016winter/Solution/src/main/assembly/assembly.xml b/Klausuren/Sd1/2016winter/Solution/src/main/assembly/assembly.xml
new file mode 100644
index 0000000000000000000000000000000000000000..8320b9ab496077983148947fdf084b42722c746f
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/Solution/src/main/assembly/assembly.xml
@@ -0,0 +1,28 @@
+<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>
+ </fileSets>
+</assembly>
diff --git a/Klausuren/Sd1/2016winter/Solution/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/Differenzen.java b/Klausuren/Sd1/2016winter/Solution/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/Differenzen.java
new file mode 100644
index 0000000000000000000000000000000000000000..0809d39485fbddec16d6dd9633b9517733b80475
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/Solution/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/Differenzen.java
@@ -0,0 +1,53 @@
+package de.hdm_stuttgart.mi.sd1.aufgabe1;
+
+/**
+ * <p>Betragsdifferenzen von Zahlenfolgen.</p>
+ *
+ */
+public class Differenzen {
+ /**
+ * <p>Summe der beiden Betragsdifferenzen von ersten und zweitem
+ * bzw. zweitem und drittem Wert.</p>
+ *
+ * <p>Beispiele</p>
+ *
+ * <ul>
+ * <li> (1, 3, 7), dann ist 3-1 == 2 und 7-3 == 4, ergebnis == 2 + 4, also 6</li>
+ * <li> (2, -3, 5), dann ist -3-2 == -5 und 5-(-3)==8, ergebnis == |-5| + 8, also 13.</li>
+ * </ul>
+ *
+ * @param a Erster Wert
+ * @param b Zweiter Wert
+ * @param c Dritter Wert
+ * @return |b - a| + |c - b|
+ */
+ static public int getDifferenzBetraege (int a, int b, int c) {
+ return Math.abs(b - a) + Math.abs(c - b);
+ }
+
+ /**
+ * <p>Summe der Betragsdifferenzen eines Arrays aus Ganzzahlen analog zu
+ * {@link #getDifferenzBetraege(int, int, int)}.</p>
+ *
+ * <p>Beispiel:</p>
+ *
+ * <p>werte == {1, 5, 2, 7}, dann haben wir das Ergebnis zu |5 - 1| + |2 - 5| + |7 - 2| == 4 + 3 + 5 == 12</p>
+ *
+ * @param werte Ein Array aus Ganzzahlen oder null
+ * @return <ul>
+ * <li>0, falls null == werte oder werte.length < 2 gilt</li>
+ * <li>Die Summe der Betragsdifferenzen analog zu {@link #getDifferenzBetraege(int, int, int)}</li>
+ * </ul>
+ */
+ static public int getDifferenzBetraege (int[] werte) {
+ if (null == werte || werte.length < 2) {
+ return 0;
+ } else {
+ int summe = 0;
+ for (int i = 1; i < werte.length; i++) {
+ summe += Math.abs(werte[i] - werte[i - 1]);
+ }
+ return summe;
+ }
+ }
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2016winter/Solution/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/Enthalten.java b/Klausuren/Sd1/2016winter/Solution/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/Enthalten.java
new file mode 100644
index 0000000000000000000000000000000000000000..a2d9a5f7383996158295bf4c0d35ea232e509741
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/Solution/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/Enthalten.java
@@ -0,0 +1,95 @@
+package de.hdm_stuttgart.mi.sd1.aufgabe1;
+
+/**
+ * <p>Sind Zeichenketten gleich oder ineinander enthalten?</p>
+ */
+public class Enthalten {
+
+ /**
+ * Linke Zeichenkette ist in rechter Zeichenkette enthalten
+ */
+ static public final int LINKS_IN_RECHTS_ENTHALTEN = 1;
+ /**
+ * Rechte Zeichenkette ist in linker Zeichenkette enthalten
+ */
+ static public final int RECHTS_IN_LINKS_ENTHALTEN = 2;
+ /**
+ * Zeichenketten sind gleich
+ */
+ static public final int GLEICH = 3;
+ /**
+ * Die Zeichenketten sind nicht ineinander enthalten
+ */
+ static public final int NICHT_ENTHALTEN = 4;
+
+ /**
+ * <p>Ist (mindestens) eine der beiden Zeichenketten in der jeweils anderen
+ * ohne Beachtung von Groß- und Kleinschreibung enthalten?</p>
+ *
+ * <p>Es sind folgende Fälle möglich:</p>
+ *
+ * <ol>
+ * <li>Beide Zeichenketten sind gleich.</li>
+ * <li>Die linke Zeichenkette ist in der rechten enthalten.</li>
+ * <li>Die rechte Zeichenkette ist in der linken enthalten.</li>
+ * <li>Beide Zeichenketten sind nicht ineinander enthalten.</li>
+ * </ol>
+ *
+ * <p>Beispiel zur Verwendung (»Fach«, kleingeschrieben »fach«, ist in »Einfacher« enthalten):</p>
+ *
+ * <blockquote><pre>{@code final String s1 = "Einfacher Test",
+ * s2 = "Fach";
+ *
+ * switch(Helper.istEnthalten(s1, s2)) {
+ * case Helper.RECHTS_IN_LINKS_ENTHALTEN:
+ * System.out.println(s2 + " ist in " + s1 + " enthalten");
+ * break;
+ * ...
+ * }
+ *}</pre></blockquote>
+ *
+ * <p>Für die Ermittlung des Ergebnisses wird die oben aufgeführte Reihenfolge verwendet: Wenn beide Zeichenketten gleich sind,
+ * so sind sie auch in beiden Richtungen ineinander enthalten. Der Wert {@link #GLEICH} wird also
+ * gegenüber {@link #RECHTS_IN_LINKS_ENTHALTEN} und {@link #LINKS_IN_RECHTS_ENTHALTEN} bevorzugt.</p>
+ *
+ *
+ * @param links Die linke, von <code>null</code> verschiedene Zeichenkette.
+ * @param rechts Die rechte, von <code>null</code> verschiedene Zeichenkette.
+ * @return <blockquote><p>Genau einen der Werte mit nachfolgend genannten Prioritäten:</p>
+ * <ol>
+ * <li><p>{@link #GLEICH}</p></li>
+ * <li>
+ * <ul>
+ * <li>{@link #LINKS_IN_RECHTS_ENTHALTEN}</li>
+ * <li>{@link #RECHTS_IN_LINKS_ENTHALTEN}</li>
+ * <li>{@link #NICHT_ENTHALTEN}</li>
+ * </ul>
+ * </li>
+ * </ol></blockquote>
+ * @throws NullPointerException falls mindestens eines der Argumente <code>links</code> oder <code>rechts</code> <code>null</code> ist.
+ */
+
+ public static int istEnthalten(final String links, final String rechts) {
+
+ // Tip: Konvertieren Sie beide Strings einheitlich entweder zur Klein- oder zur Großschreibung
+ // In der java.lag.String Klasse gibt es dafür eine passende Methode.
+
+ if (links == null || rechts == null) {
+ throw new NullPointerException();
+ } else {
+
+ final String linksKlein = links.toLowerCase(),
+ rechtsKlein = rechts.toLowerCase();
+
+ if (linksKlein.equals(rechtsKlein)) {
+ return GLEICH;
+ } else if(rechtsKlein.contains(linksKlein)) {
+ return LINKS_IN_RECHTS_ENTHALTEN;
+ } else if (linksKlein.contains(rechtsKlein)) {
+ return RECHTS_IN_LINKS_ENTHALTEN;
+ } else {
+ return NICHT_ENTHALTEN;
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2016winter/Solution/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/Gaspreise.java b/Klausuren/Sd1/2016winter/Solution/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/Gaspreise.java
new file mode 100644
index 0000000000000000000000000000000000000000..9daadaa0df8c14d9f24e42e8d5441fd30296c197
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/Solution/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/Gaspreise.java
@@ -0,0 +1,88 @@
+package de.hdm_stuttgart.mi.sd1.aufgabe1;
+
+/**
+ * <p>Jährliche Tarifberechnung für Gasverbraucher. Die Angabe von Gasmengen erfolgt
+ * in Kilowattstunden (kwh).</p>
+ *
+ * <p>Es werden zwei Tarifmodelle angeboten:</p>
+ *
+ * <dl>
+ *
+ * <dt>Kleinverbraucher:</dt>
+ * <dd>
+ * <p>Der jährliche {@link #KLEINVERBRAUCHER_GRUNDPREIS}
+ * ist niedriger als bei Großverbrauchern. Dafür ist der pro
+ * verbrauchter Kilowattstunde berechnete
+ * {@link #KLEINVERBRAUCHER_ARBEITSPREIS} höher.</p>
+ *
+ * <p>Beispiel: Für einen Jahresverbrauch von 5000 Kilowattstunden ergeben sich
+ * die Gesamtkosten zu 50,00€ Grundgebühr + 5000 * 0,12€ = 650,00€</p>
+ * </dd>
+ *
+ * <dt>Großverbraucher:</dt>
+ * <dd>
+ * <p>Der {@link #GROSSVERBRAUCHER_GRUNDPREIS} ist höher als bei Kleinverbrauchern.
+ * Dafür ist der pro verbrauchter Kilowattstunde berechnete
+ * {@link #GROSSVERBRAUCHER_ARBEITSPREIS} niedriger.</p>
+ *
+ * <p>Beispiel: Für einen Jahresverbrauch von 30000 Kilowattstunden ergeben sich
+ * die Gesamtkosten zu 400,00€ Grundgebühr + 30000 * 0,04€ = 1600,00€</p>
+ * </dd>
+ * </dl>
+ *
+ */
+public class Gaspreise {
+
+ /**
+ * Jährlicher Grundpreis in € für Kleinverbraucher.
+ */
+ static public final double KLEINVERBRAUCHER_GRUNDPREIS = 50.00;
+
+ /**
+ * Kosten in € pro Kilowattstunde für Kleinverbraucher.
+ */
+ static public final double KLEINVERBRAUCHER_ARBEITSPREIS = 0.12;
+
+ /**
+ * Jährlicher Grundpreis in € für Großverbraucher.
+ */
+ static public final double GROSSVERBRAUCHER_GRUNDPREIS = 400.00;
+
+ /**
+ * Kosten in € pro Kilowattstunde Großverbraucher.
+ */
+ static public final double GROSSVERBRAUCHER_ARBEITSPREIS = .04;
+
+
+ /**
+ * <p>Gesamtkosten pro Jahr auf Basis des Tarifs für Kleinverbraucher.</p>
+ *
+ * @param kilowattstunden Jahresgasverbrauch
+ * @return Zu zahlender Gesamtbetrag.
+ */
+ static public double getKostenKleinverbrauch(int kilowattstunden) {
+ return KLEINVERBRAUCHER_GRUNDPREIS + kilowattstunden * KLEINVERBRAUCHER_ARBEITSPREIS;
+ }
+
+ /**
+ * <p>Gesamtkosten pro Jahr auf Basis des Tarifs für Großverbraucher.</p>
+ *
+ * @param kilowattstunden Jahresgasverbrauch
+ * @return Zu zahlender Gesamtbetrag.
+ */
+ static public double getKostenGrossverbrauch(int kilowattstunden) {
+ return GROSSVERBRAUCHER_GRUNDPREIS + kilowattstunden * GROSSVERBRAUCHER_ARBEITSPREIS;
+ }
+
+ /**
+ * <p>Gesamtkosten pro Jahr auf Basis des günstigsten Tarifs.</p>
+ *
+ * <p>In Abhängigkeit vom Verbrauch wird automatisch der günstigste Tarif ausgewählt.</p>
+ *
+ * @param kilowattstunden Jahresgasverbrauch
+ * @return Zu zahlender Gesamtbetrag.
+ */
+ static public double getKostenGuenstigsterTarif(int kilowattstunden) {
+ return Math.min(getKostenKleinverbrauch(kilowattstunden), getKostenGrossverbrauch(kilowattstunden));
+ }
+}
diff --git a/Klausuren/Sd1/2016winter/Solution/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/InternetShop.java b/Klausuren/Sd1/2016winter/Solution/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/InternetShop.java
new file mode 100644
index 0000000000000000000000000000000000000000..8fe5d76f47e5a9f5150252da34116604e047a577
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/Solution/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/InternetShop.java
@@ -0,0 +1,78 @@
+package de.hdm_stuttgart.mi.sd1.aufgabe1;
+
+/**
+ * <p>Rabatt- und Versandkostenberechnung.</p>
+ *
+ * <p>Bei Bestellungen müssen folgende Punkte berücksichtigt werden:</p>
+ *
+ * <ul>
+ * <li>Oberhalb eines Mindestbestellwerts erhalten Kunden
+ * einen Rabatt.</li>
+ *
+ * <li>Oberhalb eines (ggf. abweichenden) Mindestbestellwertes
+ * entfallen die Versandkosten.</li>
+ * </ul>
+ *
+ */
+public class InternetShop {
+
+ /**
+ * <p>Ab diesem Betrag wird ein prozentualer Rabatt in
+ * Höhe von {@link #PROZENTUALER_RABATT} gewährt.</p>
+ */
+ static public final double RABATTGRENZE = 300.00;
+ /**
+ * <p>Ab diesem unrabattiertem Bestellwert erfolgt ein
+ * kostenfreier Versand.</p>
+ */
+ static public final double GRENZE_VERSANDFREI = 300.00;
+ /**
+ * <p>Dieser prozentuale Rabatt wird auf Bestellungen gewährt, deren
+ * Summe den Wert von {@link #RABATTGRENZE} erreicht.</p>
+ */
+ static public final double PROZENTUALER_RABATT = 5.0;
+ /**
+ * <p>Versandkosten fallen an für Bestellwerte unterhalb von
+ * {@link #GRENZE_VERSANDFREI}.</p>
+ */
+ static public final double VERSANDKOSTEN = 3.50;
+
+ /**
+ * <p>Berechnung der Gesamtkosten einer Internetbestellung.</p>
+ *
+ * <p>Die Gesamtkosten einer Bestellung werden in folgender Reihenfolge berechnet:</p>
+ *
+ * <ol>
+ *
+ * <li>Falls der Bestellwert mindestens {@link #RABATTGRENZE} beträgt, wird
+ * anteilmäßig {@link #PROZENTUALER_RABATT} vom Bestellwert abgezogen.</li>
+ *
+ * <li>Falls der <b>originale unrabattierte</b> Bestellwert unter
+ * {@link #GRENZE_VERSANDFREI} liegt, wird der in {@link #VERSANDKOSTEN}
+ * hinterlegte Wert addiert.</li>
+ *
+ * </ol>
+ *
+ * <p>Beispiel: Der Kunde bestellt für 400,00 €. Da dies über der Rabattgrenze liegt,
+ * werden zunächst 5% entsprechend 20,00€ abgezogen. Da der unrabattierte
+ * Betrag über der Grenze für kostenfreien Versand liegt, ist 380,00€ zugleich
+ * auch der Endbetrag.</p>
+ *
+ * @param bestellwert Die unrabattierte Summe aller bestellten Artikel.
+ * @return Der Gesamtpreis gemäß Erläuterung.
+ */
+ static public double getGesamtpreis(double bestellwert) {
+
+ final double endpreis ;
+ if (300 <= bestellwert) {
+ endpreis = ((100 - PROZENTUALER_RABATT) * bestellwert) / 100;
+ } else {
+ endpreis = bestellwert;
+ }
+ if (100 <= bestellwert) {
+ return endpreis;
+ } else {
+ return endpreis + VERSANDKOSTEN;
+ }
+ }
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2016winter/Solution/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/Vielfache.java b/Klausuren/Sd1/2016winter/Solution/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/Vielfache.java
new file mode 100644
index 0000000000000000000000000000000000000000..13a3d2fcb6aa404e53801212331be418af5832b6
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/Solution/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe1/Vielfache.java
@@ -0,0 +1,47 @@
+package de.hdm_stuttgart.mi.sd1.aufgabe1;
+
+/**
+ * Stehen zwei Ganzzahlen in der Beziehung »ist Vielfaches von« ?
+ */
+public class Vielfache {
+ /**
+ * <p>Ist <code>a</code> ein <strong>echtes</strong> Vielfaches von <code>b</code>?</p>
+ *
+ * <p>Definition: Für zwei vorzeichenbehaftete Ganzzahlen a und b
+ * gilt: a ist ein <strong>echtes</strong> Vielfaches von b,
+ * wenn es eine Ganzzahl k mit Betrag echt größer 1 gibt,
+ * so dass a = k * b gilt.</p>
+ *
+ * <p>Beispiele:</p>
+ *
+ * <ul>
+ * <li>6 ist echtes Vielfaches von 3 (k == 2)</li>
+ * <li>-10 ist echtes Vielfaches von 2 (k == -5, Betrag 5 )</li>
+ * <li>5 ist kein Vielfaches von 3</li>
+ * <li>3 ist kein echtes Vielfaches von 3 (k == 1, Betrag nicht größer 1)</li>
+ * <li>2 ist kein echtes Vielfaches von -2 (k == -1, Betrag nicht größer 1)</li>
+ * <li>0 ist echtes Vielfaches von 0 (k mit Betrag größer 1 beliebig wählbar)</li>
+ * <li>0 ist kein echtes Vielfaches von Ganzzahlen ungleich 0 (k == 0, Betrag nicht größer 1)</li>
+ * </ul>
+ *
+ * @param a Ist dieser Wert gleich k * b mit 1 < |k| ?
+ * @param b Gibt es ein k mit 1 < |k| so dass k * b den Wert von
+ * a ergibt?
+ * @return <code>true</code> genau dann, wenn entweder
+ * <code>a</code> ein Vielfaches von <code>b</code> oder
+ * umgekehrt <code>b</code> ein Vielfaches von
+ * <code>a</code> ist. Ansonsten <code>false</code>.
+ *
+ * <p style="color: red;font-weight: bold;">Tip: Beachten den
+ * »%«Operator zur Restbildung.</p>
+ */
+ static public boolean istEchtesVielfachesVon(final int a, final int b) {
+ // Tip: Beachten Sie den % Operator zur Restbildung
+
+ if (0 == b) {
+ return a == 0;
+ } else {
+ return 0 == a % b && 1 < Math.abs(a / b);
+ }
+ }
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2016winter/Solution/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe2/Konto.java b/Klausuren/Sd1/2016winter/Solution/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe2/Konto.java
new file mode 100644
index 0000000000000000000000000000000000000000..4257d61f8b8759a586f2074e77600d85e4e40e02
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/Solution/src/main/java/de/hdm_stuttgart/mi/sd1/aufgabe2/Konto.java
@@ -0,0 +1,120 @@
+package de.hdm_stuttgart.mi.sd1.aufgabe2;
+
+import java.util.Arrays;
+
+/**
+ * <p>Verwaltung ganzzahliger Geldbeträge. Auf ein Konto können Zu- und
+ * Abbuchungen erfolgen.</p>
+ *
+ * <p>Erfolgreiche Zu- und Abbuchungen werden intern protokolliert, um
+ * Entscheidungen über die Zulässigkeit von Abbuchungen treffen
+ * zu können.</p>
+ *
+ * <p>Hinweis: Die Methode void neueBuchung(final int betrag)
+ * implementiert bereits eine Protokollierung von Zu- und
+ * Abbuchungen durch das Array
+ * <code>zurueckliegendeBuchungen</code>.</p>
+ *
+ */
+public class Konto {
+
+ /**
+ * Bis zu diesem Wert darf ein Konto überzogen werden.
+ */
+ static public final int DISPOLIMIT = 3000;
+
+ int [] zurueckliegendeBuchungen = new int[0];
+
+ int kontostand;
+
+ /**
+ * Neues Konto mit Anfangsbetrag 0.
+ */
+ public Konto() {
+ kontostand = 0;
+ }
+
+ /**
+ * <p>Neues Konto mit gegebenem Anfangsbetrag.</p>
+ *
+ * <p>Ein Anfangsbetrag wird nicht als Buchung gewertet.</p>
+ *
+ * @param kontostand Anfangsbetrag des neu erstellten Kontos.
+ */
+ public Konto(final int kontostand) {
+ this.kontostand = kontostand;
+ }
+
+ /**
+ * <p>Zubuchen eines Betrags zum Konto.</p>
+ *
+ * @param betrag Der zuzubuchende Betrag muss positiv sein.
+ * @return true, falls 0 < betrag gilt, sonst false. In letzterem Fall
+ * erfolgt keine Änderung des Kontostands.
+ */
+ public boolean zubuchen(final int betrag) {
+
+ if (0 < betrag) {
+ neueBuchung(betrag);
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ /**
+ * <p>Abbuchung eines Betrags vom Konto</p>
+ *
+ * <p>Abbuchungen können genau dann erfolgen, wenn nachfolgend beschriebene Bedingungen gelten:</p>
+ *
+ * <ol>
+ * <li>Der abzubuchende Betrag muss positiv sein.</li>
+ * <li>Durch die Abbuchung darf das Dispolimit von 3000 nicht unterschritten werden.</li>
+ * <li>Es sind maximal 5 aufeinanderfolgende erfolgreiche Abbuchungen möglich. Danach muss vor
+ * einer weiteren Abbuchung erst eine <b>erfolgreiche</b> Zubuchung erfolgen.</li>
+ * </ol>
+ *
+ * @param betrag <blockquote>Der abzubuchende Betrag muss positiv sein.</blockquote>
+ * @return <blockquote>true, falls die genannten Bedingungen gelten, sonst false. In letzterem Fall
+ * erfolgt keine Änderung des Kontostands.</blockquote>
+ */
+ public boolean abbuchen(final int betrag) {
+ if (0 < betrag &&
+ -DISPOLIMIT <= kontostand - betrag &&
+ (anzahlAbbuchungenInFolge() < 5) ) {
+ neueBuchung(-betrag);
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ private int anzahlAbbuchungenInFolge() {
+
+ int anzahlAbbuchungen = 0;
+ for (int i = zurueckliegendeBuchungen.length - 1; 0 <= i; i--) {
+ if (zurueckliegendeBuchungen[i] < 0) {
+ anzahlAbbuchungen++;
+ } else {
+ return anzahlAbbuchungen;
+ }
+ }
+ return anzahlAbbuchungen;
+ }
+
+ /**
+ * Aktueller Kontostand.
+ * @return <blockquote>Guthaben sind positiv, Schulden negativ.</blockquote>
+ */
+ public int getKontostand() {
+ return kontostand;
+ }
+
+ void neueBuchung(final int betrag) {
+ // Simpel, aber imperformant und verschwenderisch in Bezug
+ // auf Speichernutzung.
+ zurueckliegendeBuchungen = Arrays.copyOf(zurueckliegendeBuchungen, zurueckliegendeBuchungen.length + 1);
+ zurueckliegendeBuchungen[zurueckliegendeBuchungen.length - 1] = betrag;
+ kontostand += betrag;
+ }
+}
diff --git a/Klausuren/Sd1/2016winter/Solution/src/main/resources/log4j2.xml b/Klausuren/Sd1/2016winter/Solution/src/main/resources/log4j2.xml
new file mode 100644
index 0000000000000000000000000000000000000000..130f87a144c4eb0107a846e580c8fa7f5e819fc1
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/Solution/src/main/resources/log4j2.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Configuration>
+ <Appenders>
+ <File name="A1" fileName="A1.log" append="false">
+ <PatternLayout pattern="%t %-5p %c{2} - %m%n"/>
+ </File>
+ <Console name="STDOUT" target="SYSTEM_OUT">
+ <PatternLayout pattern="%d %-5p [%t] %C{2} (%F:%L) - %m%n"/>
+ </Console>
+ </Appenders>
+ <Loggers>
+
+ <!-- You my want to define class or package level per-logger rules -->
+ <Logger name="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/2016winter/Solution/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/ShowReachedPoints.java b/Klausuren/Sd1/2016winter/Solution/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/ShowReachedPoints.java
new file mode 100644
index 0000000000000000000000000000000000000000..a9be38a6058e17dbc8030c190f89dec080aaab13
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/Solution/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/ShowReachedPoints.java
@@ -0,0 +1,25 @@
+package de.hdm_stuttgart.mi.sd1.test.aufgabe1;
+
+import de.hdm_stuttgart.mi.exam.unitmarking.RunTests;
+
+/**
+ * On execution both reached and reachable points will be displayed
+ *
+ */
+public class ShowReachedPoints {
+
+ /**
+ * Execution reveals the number of reached points.
+ *
+ * @param args Unused
+ */
+ public static void main(String[] args) {
+
+ RunTests.exec(
+ "Aufgabe 1", Test_Differenzen.class
+ , Test_Enthalten.class
+ , Test_Gaspreise.class
+ , Test_InternetShop.class
+ , Test_Vielfache.class);
+ }
+}
diff --git a/Klausuren/Sd1/2016winter/Solution/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_Differenzen.java b/Klausuren/Sd1/2016winter/Solution/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_Differenzen.java
new file mode 100644
index 0000000000000000000000000000000000000000..d4b16542374b98522a281cc004d1e7103cefcb7b
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/Solution/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_Differenzen.java
@@ -0,0 +1,93 @@
+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.Differenzen;
+
+/**
+ * <p>Testen von {@link Differenzen#getDifferenzBetraege(int, int, int)}
+ * und {@link Differenzen#getDifferenzBetraege(int[])}.
+ *
+ */
+@SuppressWarnings({"static-method"})
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class Test_Differenzen extends ExaminationTestDefaults {
+
+ /**
+ * Positive Betragsdifferenz
+ */
+ @Test
+ @Marking(points=2)
+ public void test_100_positiveBetragsdifferenz() {
+ Assert.assertEquals(
+ 9, //4 +5
+ Differenzen.getDifferenzBetraege(1, 5, 10));
+ }
+ /**
+ * Gemischte Betragsdifferenz
+ */
+ @Test
+ @Marking(points=2)
+ public void test_110_gemischteBetragsdifferenz() {
+ // |-1 - 4| + |3 - (-1)| == 5 + 4 == 9
+ Assert.assertEquals(
+ 9, // 5 +4
+ Differenzen.getDifferenzBetraege(4, -1, 3));
+ }
+
+ /**
+ * Sonderfall identischer Werte
+ */
+ @Test
+ public void test_130_identischeWerte() {
+ Assert.assertEquals(
+ 0, // 0 +0
+ Differenzen.getDifferenzBetraege(-5, -5, -5));
+ }
+
+ /**
+ * Betragsdifferenz positiver Werte.
+ */
+ @Test
+ public void test_200_positiveWerte() {
+ Assert.assertEquals(
+ 12, // 4 +3 +5
+ Differenzen.getDifferenzBetraege(new int[]{1, 5, 2, 7}));
+ }
+
+ /**
+ * Betragsdifferenz gemischter Werte.
+ */
+ @Test
+ public void test_210_gemischteWerte() {
+
+ Assert.assertEquals(
+ 48, // 6 +7 + 9+15 +11
+ Differenzen.getDifferenzBetraege(new int[]{1, -5, 2, -7, 8, -3}));
+ }
+
+ /**
+ * Sonderfall null.
+ */
+ @Test
+ public void test_220_null() {
+
+ Assert.assertEquals(
+ 0,
+ Differenzen.getDifferenzBetraege(null));
+ }
+
+ /**
+ * Sonderfall Arraylänge kleiner 2.
+ */
+ @Test
+ public void test_230_laengeKleinerZwei() {
+ Assert.assertEquals(0, Differenzen.getDifferenzBetraege(new int[]{}));
+ Assert.assertEquals(0, Differenzen.getDifferenzBetraege(new int[]{-14}));
+ }
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2016winter/Solution/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_Enthalten.java b/Klausuren/Sd1/2016winter/Solution/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_Enthalten.java
new file mode 100644
index 0000000000000000000000000000000000000000..840d515d97cfa2f3b9a38cb694e14dc0e413c072
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/Solution/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_Enthalten.java
@@ -0,0 +1,96 @@
+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.Enthalten;
+
+/**
+ * Testen von {@link Enthalten}.
+ *
+ */
+@SuppressWarnings({"static-method"})
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class Test_Enthalten extends ExaminationTestDefaults {
+
+ /**
+ * Die linke Zeichenkette ist in der Rechten enthalten. Diese sind aber nicht gleich.
+ *
+ */
+ @Test
+ public void test_100_inZweitemEnthalten() {
+ Assert.assertEquals(Enthalten.LINKS_IN_RECHTS_ENTHALTEN, Enthalten.istEnthalten("Ist", "Das ist richtig"));
+ }
+
+ /**
+ * Die rechte Zeichenkette ist in der linken enthalten. Diese sind aber nicht gleich.
+ *
+ */
+ @Test
+ public void test_110_inErstemEnthalten() {
+ Assert.assertEquals(Enthalten.RECHTS_IN_LINKS_ENTHALTEN, Enthalten.istEnthalten("eins ZwEi drei", "zWei"));
+ }
+
+ /**
+ * Bis auf Groß- und Kleinschreibung sind beide Zeichenketten gleich.
+ */
+ @Test
+ @Marking(points=2)
+ public void test_130_EqualsGrossKleinSchreibung() {
+ Assert.assertEquals(Enthalten.GLEICH, Enthalten.istEnthalten("Test", "test"));
+ }
+
+ /**
+ * Zwei unterschiedliche Zeichenketten, welche wechselseitig nicht ineinander enthalten sind.
+ *
+ */
+ @Test
+ public void test_140_Verschieden() {
+ Assert.assertEquals(Enthalten.NICHT_ENTHALTEN, Enthalten.istEnthalten("Dieses", "und etwas anderes"));
+ }
+
+ /**
+ * Wenn mindestens eine der beiden Zeichenketten null ist, muss
+ * eine NullPointerException geworfen werden.
+ */
+ @Test
+ public void test_150_ErwarteteNullPointerException() {
+
+ final String keineExceptionMeldung = "Die erwartete " + NullPointerException.class.getName() +
+ " wurde nicht geworfen.";
+
+ { // Zweiter Wert null
+ boolean exceptionGeworfen = false;
+ try {
+ Enthalten.istEnthalten("Test", null);
+ } catch (@SuppressWarnings("unused") final NullPointerException e) {
+ exceptionGeworfen = true;
+ }
+ Assert.assertTrue(keineExceptionMeldung, exceptionGeworfen);
+ }
+
+ { // Erster Wert null
+ boolean exceptionGeworfen = false;
+ try {
+ Enthalten.istEnthalten(null, "Test");
+ } catch (@SuppressWarnings("unused") final NullPointerException e) {
+ exceptionGeworfen = true;
+ }
+ Assert.assertTrue(keineExceptionMeldung, exceptionGeworfen);
+ }
+
+ { // Beide Werte null
+ boolean exceptionGeworfen = false;
+ try {
+ Enthalten.istEnthalten(null, null);
+ } catch (@SuppressWarnings("unused") final NullPointerException e) {
+ exceptionGeworfen = true;
+ }
+ Assert.assertTrue(keineExceptionMeldung, exceptionGeworfen);
+ }
+ }
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2016winter/Solution/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_Gaspreise.java b/Klausuren/Sd1/2016winter/Solution/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_Gaspreise.java
new file mode 100644
index 0000000000000000000000000000000000000000..bda5231df4ad0e4f4c1285ef381e5332255d2d9f
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/Solution/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_Gaspreise.java
@@ -0,0 +1,95 @@
+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.Gaspreise;
+
+/**
+ * Teste Jährliche Gaspreise basierend auf Verbrauchsangaben.
+ *
+ */
+@SuppressWarnings({"static-method"})
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class Test_Gaspreise extends ExaminationTestDefaults {
+
+ /**
+ * Toleranz bei Rundungsfehlern in double Vergleichen. Erläuterung
+ * siehe z.B. {@link Assert#assertEquals(double, double, double)}.
+ */
+ static public final double testDelta = 1.E-10;
+
+
+ /**
+ * Geringverbrauchertarif, Nullverbrauch
+ */
+ @Test
+ public void test_010_geringverbrauchNullGasabnahme() {
+ Assert.assertEquals(Gaspreise.KLEINVERBRAUCHER_GRUNDPREIS,
+ Gaspreise.getKostenKleinverbrauch(0),
+ testDelta);
+ }
+
+ /**
+ * Geringverbrauchertarif, Verbrauch 1500 und 3000
+ */
+ @Test
+ public void test_012_gerinverbrauchZweiWerte() {
+ double erwartet = Gaspreise.KLEINVERBRAUCHER_GRUNDPREIS
+ + Gaspreise.KLEINVERBRAUCHER_ARBEITSPREIS * 1500;
+ Assert.assertEquals(erwartet,
+ Gaspreise.getKostenKleinverbrauch(1500),
+ testDelta);
+
+ erwartet = Gaspreise.KLEINVERBRAUCHER_GRUNDPREIS
+ + Gaspreise.KLEINVERBRAUCHER_ARBEITSPREIS * 3000;
+ Assert.assertEquals(erwartet,
+ Gaspreise.getKostenKleinverbrauch(3000),
+ testDelta);
+ }
+
+ /**
+ * Großverbrauchertarif, Nullverbrauch
+ */
+ @Test
+ public void test_020_grossverbrauchNullGasabnahme() {
+ Assert.assertEquals(Gaspreise.GROSSVERBRAUCHER_GRUNDPREIS,
+ Gaspreise.getKostenGrossverbrauch(0),
+ testDelta);
+ }
+
+
+ /**
+ * Großverbrauchertarif, Verbrauch 20000 und 60000
+ */
+ @Test
+ public void test_022_grossverbrauchZweiWerte() {
+ double erwartet = Gaspreise.GROSSVERBRAUCHER_GRUNDPREIS
+ + Gaspreise.GROSSVERBRAUCHER_ARBEITSPREIS * 20000;
+ Assert.assertEquals(erwartet,
+ Gaspreise.getKostenGrossverbrauch(20000),
+ testDelta);
+
+ erwartet = Gaspreise.GROSSVERBRAUCHER_GRUNDPREIS
+ + Gaspreise.GROSSVERBRAUCHER_ARBEITSPREIS * 60000;
+
+ Assert.assertEquals(erwartet,
+ Gaspreise.getKostenGrossverbrauch(60000),
+ testDelta);
+}
+/**
+ * Gleichheit beider Tarife bei 4375 Kilowattstunden Verbrauch.
+ */
+ @Test
+ @Marking(points=2)
+ public void test_080_tarifeIdentisch() {
+ Assert.assertEquals(Gaspreise.getKostenGrossverbrauch(4375),
+ Gaspreise.getKostenKleinverbrauch(4375),
+ testDelta);
+ }
+
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2016winter/Solution/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_InternetShop.java b/Klausuren/Sd1/2016winter/Solution/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_InternetShop.java
new file mode 100644
index 0000000000000000000000000000000000000000..a65014a66aecf0532774ba592612294af1857b03
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/Solution/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_InternetShop.java
@@ -0,0 +1,55 @@
+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.InternetShop;
+
+/**
+ * Testen von Hilfsmethoden aus der Klasse {@link InternetShop}.
+ *
+ */
+@SuppressWarnings({"static-method"})
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class Test_InternetShop extends ExaminationTestDefaults {
+
+ /**
+ * Toleranz bei Rundungsfehlern in double Vergleichen. Erläuterung
+ * siehe z.B. {@link Assert#assertEquals(double, double, double)}.
+ */
+ static public final double testDelta = 1.E-10;
+
+ /**
+ * Mit Rabatt, ohne Versandkosten.
+ */
+ @Test
+ @Marking(points=2)
+ public void test_10_rabattKeineVersandkosten() {
+ final double wert=400;
+ Assert.assertEquals(wert * (100 - InternetShop.PROZENTUALER_RABATT) / 100, InternetShop.getGesamtpreis(400), testDelta);
+ }
+
+ /**
+ * Ohne Rabatt, ohne Versandkosten
+ */
+ @Test
+ @Marking(points=2)
+ public void test_11_keinRabattKeineVersandkosten() {
+ final double wert = 200;
+ Assert.assertEquals(wert, InternetShop.getGesamtpreis(wert), testDelta);
+ }
+
+ /**
+ * Ohne Rabatt, mit Versandkosten
+ */
+ @Test
+ @Marking(points=2)
+ public void test_12_keinRabattMitVersandkosten() {
+ final double wert = 80;
+ Assert.assertEquals(wert + InternetShop.VERSANDKOSTEN, InternetShop.getGesamtpreis(wert), testDelta);
+ }
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2016winter/Solution/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_Vielfache.java b/Klausuren/Sd1/2016winter/Solution/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_Vielfache.java
new file mode 100644
index 0000000000000000000000000000000000000000..6de62c8aa1b38de5404813bcaac4e12805f56d52
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/Solution/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe1/Test_Vielfache.java
@@ -0,0 +1,82 @@
+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.sd1.aufgabe1.Vielfache;
+
+/**
+ * Testen von {@link Vielfache#istEchtesVielfachesVon(int, int)}
+ *
+ */
+@SuppressWarnings({"static-method"})
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class Test_Vielfache extends ExaminationTestDefaults {
+ /**
+ * Positive echte Vielfache
+ */
+ @Test
+ public void test_300_positivIstVielfaches() {
+ Assert.assertTrue(Vielfache.istEchtesVielfachesVon(6, 2));
+ Assert.assertTrue(Vielfache.istEchtesVielfachesVon(3, 1));
+ }
+ /**
+ * Negative echte Vielfache
+ */
+ @Test
+ public void test_310_negativIstVielfaches() {
+ Assert.assertTrue(Vielfache.istEchtesVielfachesVon(-9, -3));
+ Assert.assertTrue(Vielfache.istEchtesVielfachesVon(-7, -1));
+ }
+
+ /**
+ * Positiv- / Negativwerte gemischt.
+ */
+ @Test
+ public void test_330_gemischtIstVielfaches() {
+ Assert.assertTrue(Vielfache.istEchtesVielfachesVon(12, -4));
+ Assert.assertTrue(Vielfache.istEchtesVielfachesVon(-18, 6));
+ Assert.assertTrue(Vielfache.istEchtesVielfachesVon(-21, 1));
+ Assert.assertTrue(Vielfache.istEchtesVielfachesVon(17, -1));
+ }
+
+ /**
+ * Nicht-Vielfache positiv/positiv oder negativ/negativ
+ */
+ @Test
+ public void test_340_positivKeinVielfaches() {
+ Assert.assertFalse(Vielfache.istEchtesVielfachesVon(8, 3));
+ Assert.assertFalse(Vielfache.istEchtesVielfachesVon(2, 7));
+ Assert.assertFalse(Vielfache.istEchtesVielfachesVon(-8, -3));
+ Assert.assertFalse(Vielfache.istEchtesVielfachesVon(-2, -7));
+ }
+ /**
+ * Nicht-Vielfache gemischt.
+ */
+ @Test
+ public void test_350_gemischtKeinVielfaches() {
+ Assert.assertFalse(Vielfache.istEchtesVielfachesVon(-8, 3));
+ Assert.assertFalse(Vielfache.istEchtesVielfachesVon(-2, 5));
+ Assert.assertFalse(Vielfache.istEchtesVielfachesVon(8, -3));
+ Assert.assertFalse(Vielfache.istEchtesVielfachesVon(2, -5));
+ }
+ /**
+ * Sonderfall 0 und 0.
+ */
+ @Test
+ public void test_340_nullNullIstVielfaches() {
+ Assert.assertTrue(Vielfache.istEchtesVielfachesVon(0, 0));
+ }
+
+ /**
+ * Sonderfall ungleich 0 mit 0.
+ */
+ @Test
+ public void test_350_ungleichNullUndNullKeinVielfaches() {
+ Assert.assertFalse(Vielfache.istEchtesVielfachesVon(5, 0));
+ Assert.assertFalse(Vielfache.istEchtesVielfachesVon(-7, 0));
+ }
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2016winter/Solution/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe2/ShowReachedPoints.java b/Klausuren/Sd1/2016winter/Solution/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe2/ShowReachedPoints.java
new file mode 100644
index 0000000000000000000000000000000000000000..468267ffd2fb81f72a17fcb7e213c61bbfc06343
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/Solution/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe2/ShowReachedPoints.java
@@ -0,0 +1,20 @@
+package de.hdm_stuttgart.mi.sd1.test.aufgabe2;
+
+import de.hdm_stuttgart.mi.exam.unitmarking.RunTests;
+
+/**
+ * On execution both reached and reachable points will be displayed
+ *
+ */
+public class ShowReachedPoints {
+
+ /**
+ * Execution reveals the number of reached points.
+ *
+ * @param args Unused
+ */
+ public static void main(String[] args) {
+
+ RunTests.exec("Aufgabe 2", Test_Konto.class);
+ }
+}
\ No newline at end of file
diff --git a/Klausuren/Sd1/2016winter/Solution/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe2/Test_Konto.java b/Klausuren/Sd1/2016winter/Solution/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe2/Test_Konto.java
new file mode 100644
index 0000000000000000000000000000000000000000..ae2a5dee84d07fb5257588d21364db64f50ac5de
--- /dev/null
+++ b/Klausuren/Sd1/2016winter/Solution/src/test/java/de/hdm_stuttgart/mi/sd1/test/aufgabe2/Test_Konto.java
@@ -0,0 +1,150 @@
+package de.hdm_stuttgart.mi.sd1.test.aufgabe2;
+
+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.Konto;
+
+/**
+ * Teste Verhalten bei Kontoerzeugung, Zu- und Abbuchungen.
+ *
+ */
+@SuppressWarnings({"static-method"})
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class Test_Konto extends ExaminationTestDefaults {
+
+ /**
+ * Korrekter Anfangskontostand und einzelne Zubuchung.
+ */
+ @Test
+ @Marking(points=2)
+ public void testZubuchenDefault() {
+ final Konto konto = new Konto();
+ Assert.assertEquals(0, konto.getKontostand());
+
+ konto.zubuchen(2000);
+ Assert.assertEquals(2000, konto.getKontostand());
+ }
+
+ /**
+ * Anfangsstand negativ und sofortige Abbuchung unterhalb
+ * von {@link Konto#DISPOLIMIT}.
+ */
+ @Test
+ @Marking(points=3)
+ public void testAbbuchenNegativ() {
+ final Konto konto = new Konto(-300);
+ Assert.assertEquals(-300, konto.getKontostand());
+
+ Assert.assertTrue(konto.abbuchen(2000));
+ Assert.assertEquals(-2300, konto.getKontostand());
+ }
+ /**
+ * Nach 5 aufeinanderfolgenden erfolgreichen Abbuchungen ist
+ * keine weitere Abbuchung möglich. Danach erfolgt eine
+ * einzelne Zubuchung gefolgt von einer weiteren Abbuchung.
+ */
+ @Test
+ @Marking(points=2)
+ public void testVerweigereFolge5() {
+ final Konto konto = new Konto();
+ Assert.assertEquals(0, konto.getKontostand());
+
+ // 1. Abbuchung in Folge
+ Assert.assertTrue(konto.abbuchen(100));
+ Assert.assertEquals(-100, konto.getKontostand());
+
+ // 2. Abbuchung in Folge
+ Assert.assertTrue(konto.abbuchen(100));
+ Assert.assertEquals(-200, konto.getKontostand());
+
+ // 3. Abbuchung in Folge
+ Assert.assertTrue(konto.abbuchen(100));
+ Assert.assertEquals(-300, konto.getKontostand());
+
+ // 4. Abbuchung in Folge
+ Assert.assertTrue(konto.abbuchen(100));
+ Assert.assertEquals(-400, konto.getKontostand());
+
+ // 5. Abbuchung in Folge
+ Assert.assertTrue(konto.abbuchen(100));
+ Assert.assertEquals(-500, konto.getKontostand());
+
+ // 6. Abbuchung in Folge, sollte scheitern
+ Assert.assertFalse(konto.abbuchen(100));
+ Assert.assertEquals(-500, konto.getKontostand());
+
+ // 7. Erfolglose Zubuchung (Wert muss positiv sein)
+ Assert.assertFalse(konto.zubuchen(0));
+ Assert.assertEquals(-500, konto.getKontostand());
+
+ // 8. Erfolgreiche Zubuchung
+ Assert.assertTrue(konto.zubuchen(1));
+ Assert.assertEquals(-499, konto.getKontostand());
+
+ // 9. Abbuchung, davor erfolgte eine Zubuchung
+ Assert.assertTrue(konto.abbuchen(100));
+ Assert.assertEquals(-599, konto.getKontostand());
+ }
+
+ /**
+ * Abbuchungen dürfen nur für positive Werte erfolgen. Abbuchungen mit
+ * negativen Werten scheitern und werden nicht erfasst.
+ */
+ @Test
+ @Marking(points=1)
+ public void testFolge5() {
+ final Konto konto = new Konto();
+ Assert.assertEquals(0, konto.getKontostand());
+
+ // 1. erfolglose Abbuchung in Folge
+ Assert.assertFalse(konto.abbuchen(0));
+ Assert.assertEquals(0, konto.getKontostand());
+
+ // 2. erfolglose Abbuchung in Folge
+ Assert.assertFalse(konto.abbuchen(0));
+ Assert.assertEquals(0, konto.getKontostand());
+
+ // 3. erfolglose Abbuchung in Folge
+ Assert.assertFalse(konto.abbuchen(0));
+ Assert.assertEquals(0, konto.getKontostand());
+
+ // 4. erfolglose Abbuchung in Folge
+ Assert.assertFalse(konto.abbuchen(0));
+ Assert.assertEquals(0, konto.getKontostand());
+
+ // 5. erfolglose Abbuchung in Folge
+ Assert.assertFalse(konto.abbuchen(0));
+ Assert.assertEquals(0, konto.getKontostand());
+
+ // Abbuchung nach 5 erfolglosen Abbuchungen.
+ Assert.assertTrue(konto.abbuchen(100));
+ Assert.assertEquals(-100, konto.getKontostand());
+ }
+
+ /**
+ * Abbuchungen an der Grenze zu {@link Konto#DISPOLIMIT}.
+ */
+ @Test
+ @Marking(points=2)
+ public void testDispolimit() {
+ final Konto konto = new Konto(-3000);
+ Assert.assertEquals(-3000, konto.getKontostand());
+
+ // 1. Abbuchung, sollte am Dispolimit scheitern
+ Assert.assertFalse(konto.abbuchen(1));
+ Assert.assertEquals(-3000, konto.getKontostand());
+
+ // 2. Zubuchung
+ Assert.assertTrue(konto.zubuchen(1));
+ Assert.assertEquals(-2999, konto.getKontostand());
+
+ // 3. Abbuchung
+ Assert.assertTrue(konto.abbuchen(1));
+ Assert.assertEquals(-3000, konto.getKontostand());
+ }
+}
\ No newline at end of file