Commit 54082824 authored by Dr. Martin Goik's avatar Dr. Martin Goik

Sda1 + Sd1 Exams

parent 2bac61c1
/.classpath
/.project
/.settings
/.idea
/*.iml
<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_2017winter_exam</artifactId>
<version>0.8</version>
<packaging>jar</packaging>
<name>sd1_2017winter_exam</name>
<url>http://www.mi.hdm-stuttgart.de/freedocs/topic/de.hdm_stuttgart.mi.lectures/sd1SectUsingMaven.html</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<repositories>
<repository>
<id>hdm-mi-internal-maven-repo</id>
<url>https://maven.mi.hdm-stuttgart.de/artifacts</url>
</repository>
</repositories>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-core</artifactId>
<version>2.6</version>
</dependency>
<dependency>
<groupId>de.hdm_stuttgart.mi.exam</groupId>
<artifactId>unitmarking</artifactId>
<version>0.9</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.5.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-javadoc-plugin</artifactId>
<version>2.10.3</version>
<configuration />
</plugin>
<plugin>
<artifactId>maven-assembly-plugin</artifactId>
<version>2.3</version>
<configuration>
<descriptor>src/main/assembly/assembly.xml</descriptor>
</configuration>
<executions>
<execution>
<id>make-assembly</id>
<phase>package</phase>
<goals>
<goal>single</goal>
</goals>
<configuration>
<archive>
<manifest>
<mainClass>de.hdm_stuttgart.mi.sd1.test.ShowReachedPoints</mainClass>
</manifest>
</archive>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>
<assembly
xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.3"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.3 http://maven.apache.org/xsd/assembly-1.1.3.xsd">
<id>fat-tests</id>
<formats>
<format>jar</format>
</formats>
<includeBaseDirectory>false</includeBaseDirectory>
<dependencySets>
<dependencySet>
<outputDirectory>/</outputDirectory>
<useProjectArtifact>true</useProjectArtifact>
<unpack>true</unpack>
<scope>test</scope>
</dependencySet>
</dependencySets>
<fileSets>
<fileSet>
<directory>${project.build.directory}/test-classes</directory>
<outputDirectory>/</outputDirectory>
<includes>
<include>**/*.class</include>
</includes>
<useDefaultExcludes>true</useDefaultExcludes>
</fileSet>
<fileSet>
<directory>${project.build.directory}/classes</directory>
<outputDirectory>/</outputDirectory>
<includes>
<include>**/*.class</include>
</includes>
<useDefaultExcludes>true</useDefaultExcludes>
</fileSet>
</fileSets>
</assembly>
package de.hdm_stuttgart.mi.sd1.aufgabe1;
/**
* <p>Ein Fitnesstudio bietet folgende Tarife:</p>
*
* <ul>
* <li>Jährliche Einmalzahlung, siehe {@link #TARIFTYP_JAHRESVORAUSZAHLUNG}.</li>
* <li>Flextarif, siehe {@link #TARIFTYP_FLEX}.</li>
* <li>Einmalbesuch ohne gebuchten Tarif, siehe {@link #TARIFTYP_PRO_BESUCH}.</li>
* </ul>
*
* Der Rechner bietet Methoden zur Ermittlung sowohl von Kosten als auch des günstigsten Tarifs auf Basis
* der Anzahl von Besuchen pro Jahr.
*/
public class FitnessTarifRechner {
/* Tariftypen */
/**
* <p>Für einen Jahresbeitrag von {@link #kostenJahrestarif} € kann man das Studio beliebig oft besuchen.</p>
*/
static public final byte TARIFTYP_JAHRESVORAUSZAHLUNG = 1;
/**
* <p>Pro Besuch des Studios werden {@link #kostenEinmaligFlextarif} € fällig. Zusätzlich fällt eine
* einmalige Jahresgebühr von {@link #basiskostenFlextarif} € an.</p>
*/
static public final byte TARIFTYP_FLEX = 2;
/**
* <p>Ein einmaliger Besuch ohne vorab gebuchten Tarif kostet {@link #kostenEimaligOhneTarif} €.</p>
*/
static public final byte TARIFTYP_PRO_BESUCH = 3;
/* Kostenangaben */
/**
* Kosten eines Ganzjahrestickets.
*/
static public final int kostenJahrestarif = 800;
/**
* Jährliche Grundkosten Flextarif.
*/
static public final int basiskostenFlextarif = 150;
/**
* Kosten pro Besuch im Flextarif.
*/
static public final int kostenEinmaligFlextarif = 5;
/**
* Kosten pro Besuch ohne jeglichen Tarif.
*/
static public final int kostenEimaligOhneTarif = 12;
/**
* Kosten pro Jahr bei vorheriger Buchung des Flextarifs {@link #TARIFTYP_FLEX}.
*
* @param anzahlBesucheProJahr Anzahl der jährlichen Besuche im Studio. Negative Werte werden als
* 0 Besuche gewertet.
* @return Die Jahresgesamtkosten für alle Besuche im Jahr.
*/
static public int getKostenFlextarif(final int anzahlBesucheProJahr) {
return -12345; // TODO: Implementiere mich richtig!
}
/**
* Kosten pro Jahr ohne Buchung eines Tarifs.
*
* @param anzahlBesucheProJahr Anzahl der jährlichen Besuche im Studio. Negative Werte werden als
* 0 Besuche gewertet.
* @return Die Jahresgesamtkosten für alle Besuche im Jahr.
*/
static public int getKostenOhneTarif(final short anzahlBesucheProJahr) {
return -12345; // TODO: Implementiere mich richtig!
}
/**
* <p>Optimaler Tariftyp basierend auf der Anzahl von Besuchsterminen pro Jahr.</p>
*
* <p>Beispiel: Ein Nutzer besucht das Studio an 200 Tagen im Jahr. Dies ergibt folgende
* Gesamtkosten in den drei Tariftypen:</p>
*
* <dl>
* <dt>{@link #TARIFTYP_JAHRESVORAUSZAHLUNG}</dt>
* <dd><code>{@link #kostenJahrestarif}</code></dd>
*
* <dt>{@link #TARIFTYP_FLEX}</dt>
* <dd>{@link #basiskostenFlextarif} + 200 * {@link #kostenEinmaligFlextarif}</dd>
*
* <dt>{@link #TARIFTYP_PRO_BESUCH}</dt>
* <dd> 200 * {@link #kostenEimaligOhneTarif}</dd>
*
* </dl>
*
* @param anzahlBesucheProJahr Anzahl der jährlichen Besuche im Studio.
*
* @return <p>Der günstigste Tariftyp entsprechend der Anzahl an Besuchen. Falls sich für verschiedene Tariftypen
* identische Kosten ergeben, so gilt folgende Prioritätenfolge:</p>
* <ol>
* <li>{@link #TARIFTYP_PRO_BESUCH}</li>
* <li>{@link #TARIFTYP_FLEX}</li>
* <li>{@link #TARIFTYP_JAHRESVORAUSZAHLUNG}</li>
* </ol>
*
*/
static public byte getOptimalenTariftyp(final short anzahlBesucheProJahr) {
return (byte) -14; // TODO: Implementiere mich richtig!
}
}
\ No newline at end of file
package de.hdm_stuttgart.mi.sd1.aufgabe1;
import java.util.Arrays;
/**
* Hilfsmethoden.
*
*/
public class Helper {
/**
* <p>Notenberechnung: In aufsteigender Abhängigkeit von erreichten Punkten sollen folgende Noten vergeben werden:</p>
*
* <dl>
* <dt>Unter 50 Punkten</dt>
* <dd><code>"mangelhaft"</code></dd>
*
* <dt>Ab 50 Punkten:</dt>
* <dd><code>"ausreichend"</code></dd>
*
* <dt>Ab 65 Punkten:</dt>
* <dd><code>"befriedigend"</code></dd>
*
* <dt>Ab 80 Punkten:</dt>
* <dd><code>"gut"</code></dd>
*
* <dt>Ab 95 Punkten:</dt>
* <dd><code>"sehr gut"</code></dd>
*
* </dl>
*
* @param punkte In einer Prüfung erreichte Punkte.
*
* @return Die erreichte Note in Textform gemäß Beschreibung.
*/
static public String berechneNote(int punkte) {
return "cfsdf3qw4"; // TODO: Implementiere mich richtig!
}
/**
* Maximal mögliche Stellenzahl eines <code>long</code> Wertes: Long.MAX_VALUE==9223372036854775807
*/
static private final int maxLongPositions = Long.toString(Long.MAX_VALUE).length();
/**
* <p>Zerlegung eines Wertes in ein Array aus Einer, Zehner, Hunderter usw. Anteilen. Beispiele:</p>
* <dl>
* <dt><code>0</code>:</dt>
* <dd><code>int[] result = {0}</code></dd>
*
* <dt><code>123</code>:</dt>
* <dd><code>int[] result = {1, 20, 300}</code></dd>
*
* <dt><code>43090</code>:</dt>
* <dd><code>int[] result = {0, 90, 0, 3000, 40000}</code></dd>
*
* </dl>
* @param wert Der zu zerlegende Wert
* @return Das Array der Zerlegung in Einer, Zehner, Hunderter usw. Anteile.
*/
static public long[] dezimalZerlegung(long wert) {
return null; // TODO: Implementiere mich richtig!
}
/**
* <p>Vertausche zwei Werte eines Arrays an den Indexpositionen <code>position</code> und
* <code>position + 1</code>. Beispiel:</p>
*
* <p><code>values = {1, 2, 3, 4, 5}</code> und <code>position = 2</code>. Dann werden die Werte 3 und 4 an den
* Indexpositionen 2 und 3 vertauscht, das Ergebnis lautet <code>{1, 2, 4, 3, 5}</code>.</p>.
*
* Falls das Array und der Wert von <code>position</code> eine Vertauschung zulassen, ist der Rückgabewert
* <code>true</code>, ansonsten <code>false</code>.
*
* @param werte Ein Array aus Werten oder <code>null</code>.
* @param position <p>Der Index des Werts, welcher mit dem Wert an der nächsthöheren Indexposition vertauscht werden
* soll.</p>
* <p>Bei negativem oder sonst für eine Vertauschung unpassendem Wert erfolgt keine Veränderung, der
* Rückgabewert ist in diesem Fall <code>false</code>.</p>
*
* @return <code>true</code>, falls das Array nicht null ist, mindestens zwei Werte enthält und eine Vertauschung
* der Werte an den Indexpositionen <code>position</code> und <code>position + 1</code> erlaubt. Ansonsten
* <code>false</code>.
*/
static public boolean swap(final int[] werte, final int position) {
return true; // TODO: Implementiere mich richtig!
}
/**
* <p>Umwandlung jedes Wortanfangs in einen Großbuchstaben. Beispiel:</p>
*
* <p> <code>"Ein schöner warmer Sommer steht an."</code> wird zu
* <code>"Ein Schöner Warmer Sommer Steht An."</code></p>
*
* @param input Eine Satz aus Worten mit gemischter Groß- und Kleinschreibung.
* @return Der Satz mit Großschreibung aller Wortanfänge oder <code>null</code>,
* falls die Eingabe <code>null</code> ist.
*/
static public String getWortanfangGross(final String input) {
return "noch nix Rechtes"; // TODO: Implementiere mich richtig!
}
}
\ No newline at end of file
package de.hdm_stuttgart.mi.sd1.aufgabe1;
/**
* <p>Bewertungen für das Würfelspiel »Mäxchen« (Schwäbisch »Mäxle«). Gespielt wird mit zwei
* Würfeln, jeweils mit Augenzahl 1 bis 6.</p>
*
* <p>Die Schreibweise (5|2) bedeutet eine Augenzahl 2 für den ersten und eine Augenzahl 5 für den zweiten
* Würfel. Neben solchen »normalen« Ereignissen gibt es folgende Sonderfälle:</p>
*
* <dl>
* <dt>(1|1), (2|2),... (6|6), </dt>
* <dd>Haben beide Würfel dieselbe Augenzahl, so handelt es sich um einen Pasch.</dd>
*
* <dt>(2|1) bzw. (1|2)</dt>
* <dd>Dieser Sonderfall ist ein »Mäxchen« bzw. schwäbisch ein »Mäxle«.</dd>
*
* </dl>
*/
public class Maexchen {
/**
* Haben beide Würfel eine identische Augenzahl, so handelt es sich um einen Pasch.
*
* @param wuerfel1 Die Augenzahl des ersten Würfels.
* @param wuerfel2 Die Augenzahl des zweiten Würfels.
* @return <code>true</code>, falls es sich um einen Pasch handelt, ansonsten <code>false</code>.
*/
static public boolean istPasch(final int wuerfel1, final int wuerfel2) {
return true; // TODO: Implementiere mich richtig!
}
/**
* Das Ereignis (1|2) bzw. (2|1) stellt ein »Mäxchen« dar.
*
* @param wuerfel1 Die Augenzahl des ersten Würfels.
* @param wuerfel2 Die Augenzahl des zweiten Würfels.
* @return <code>true</code>, falls es sich um ein »Mäxchen« handelt, ansonsten <code>false</code>.
*/
static public boolean istMaexchen(final int wuerfel1, final int wuerfel2) {
return false; // TODO: Implementiere mich richtig!
}
/**
* <p>Ereignisse wie (1|3), (5|2) usw. sind keine Sonderfälle. Wie in der Einleitung beschrieben,
* gelten alle »Pasch« Würfe sowie das »Mäxchen« / »Mäxle« als Sonderfälle.</p>
*
* @param wuerfel1 Die Augenzahl des ersten Würfels.
* @param wuerfel2 Die Augenzahl des zweiten Würfels.
* @return <code>true</code>, falls es sich um keinen Sonderfall handelt, ansonsten <code>false</code>.
*/
static public boolean istKeinSonderfall(final int wuerfel1, final int wuerfel2) {
return false; // TODO: Implementiere mich richtig!
}
}
\ No newline at end of file
package de.hdm_stuttgart.mi.sd1.aufgabe2;
import de.hdm_stuttgart.mi.sd1.aufgabe1.Maexchen;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
/**
* <p>Darstellung eines Mäxchen Wurfs, z.B. (3|2), siehe auch {@link Maexchen}.</p>
*/
public class MaexleWurf {
static private Logger log = LogManager.getLogger(MaexleWurf.class);
public MaexleWurf(final int wuerfel1, final int wuerfel2) {
// TODO: Implementiere mich richtig!
}
/**
* <p>Vergleiche den aktuellen Wurf mit einem anderen Wurf: Welcher Wurf ist höher?</p>
*
* <table border="1" style="border-collapse: collapse;">
* <tr>
* <th colspan="14">Normalwerte</th>
* <th colspan="6">Pasch</th>
* <th>Mäxle</th>
* </tr>
* <tr>
* <td>(1|3)</td>
* <td>(1|4)</td>
* <td>(1|5)</td>
* <td>(1|6)</td>
* <td>(2|3)</td>
* <td>(2|4)</td>
* <td>(2|5)</td>
* <td>(2|6)</td>
* <td>(3|4)</td>
* <td>(3|5)</td>
* <td>(3|6)</td>
* <td>(4|5)</td>
* <td>(4|6)</td>
* <td>(5|6)</td>
*
* <td>(1|1)</td>
* <td>(2|2)</td>
* <td>(3|3)</td>
* <td>(4|4)</td>
* <td>(5|5)</td>
* <td>(6|6)</td>
*
* <td>(1|2)</td>
* </tr>
* <tr>
* <td>Niedrigster Wert</td>
* <td colspan="19"></td>
* <td>Höchster Wert</td>
* </tr>
* <caption>Reihenfolge gewürfelter Augenpaare in aufsteigender Folge im Mäxchen Spiel.</caption>
*
* </table>
*
* <p>Beispiele:</p>
*
* <ul>
* <li><code>(2| 5)</code> gleich <code>(5| 2)</code> wird »52« gesprochen und ist größer als (4| 3), gesprochen
* »43«</li>
*
* <li><code>(2| 2)</code> ist als höher als alle nicht-Pasch / nicht-Mäxchen Werte wie z.B. <code>(5| 6)</code>,
* aber niedriger als das Mäxchen <code>(1|2)</code>.</li>
*
* </ul>
*
* @param other Ein im Spiel geworfener Wert bestehend aus den Augenzahlen zweier Würfel, mit welchem der atuelle
* Wert verglichen wird.
* @return <ul>
* <li>positives Ergebnis, falls fremder Wert höher liegt.</li>
* <li>0, falls fremder Wert gleich ist</li>
* <li>negatives Ergebnis, falls fremder Wert niedriger liegt.</li>
* </ul>
*/
public int compareTo(final MaexleWurf other) {
// Auskommentieren und mit sinnvoller Ausgabe versehen:
//log.info(this + " compareTo(" + other + ")");
return -12345; // TODO: Implementiere mich richtig!
}
}
\ No newline at end of file
<?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
package de.hdm_stuttgart.mi.sd1.test;
import de.hdm_stuttgart.mi.exam.unitmarking.RunTests;
import de.hdm_stuttgart.mi.sd1.test.aufgabe1.Test_FitnessTarifRechner;
import de.hdm_stuttgart.mi.sd1.test.aufgabe1.Test_Helper;
import de.hdm_stuttgart.mi.sd1.test.aufgabe1.Test_Maexchen;
import de.hdm_stuttgart.mi.sd1.test.aufgabe2.Test_MaexchenVergleich;
public class ShowReachedPoints {
/**
* Execution reveals the number of reached points.
*
* @param args Unused
*/
public static void main(String[] args) {
RunTests.exec(
"Aufgabe 1"
, Test_FitnessTarifRechner.class
, Test_Helper.class
, Test_Maexchen.class);
RunTests.exec("Aufgabe 2", Test_MaexchenVergleich.class);
}
}
\ No newline at end of file
package de.hdm_stuttgart.mi.sd1.test.aufgabe1;
import de.hdm_stuttgart.mi.exam.unitmarking.Marking;
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.FitnessTarifRechner;
/**
* <p>Kostenrechner Fitnessstudio.</p>
*/
@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class Test_FitnessTarifRechner extends ExaminationTestDefaults {
/**
* Kosten ohne Tarifbindung
*/
@Test public void test_200() {
Assert.assertEquals(0, FitnessTarifRechner.getKostenOhneTarif((short) 0));
}
@Test @Marking(points = 2) public void test_220() {
Assert.assertEquals(1020, FitnessTarifRechner.getKostenOhneTarif((short) 85));
}
@Test @Marking(points = 2) public void test_240() {
Assert.assertEquals(0, FitnessTarifRechner.getKostenOhneTarif((short) -13));
}
/**
* Kosten im Flextarif
*/
@Test public void test_260() {
Assert.assertEquals(FitnessTarifRechner.basiskostenFlextarif, FitnessTarifRechner.getKostenFlextarif((short) 0));
}
@Test public void test_280() {
Assert.assertEquals(260, FitnessTarifRechner.getKostenFlextarif((short) 22));
Assert.assertEquals(655, FitnessTarifRechner.getKostenFlextarif((short) 101));
}
@Test public void test_300() {
Assert.assertEquals(FitnessTarifRechner.basiskostenFlextarif, FitnessTarifRechner.getKostenFlextarif((short) -14));
}
// Abschnitt optimale Tarifbestimmung.
/**
* Höchste Besuchszahl, bei welcher sich kein Tarifabschluss lohnt.
*/
@Test
public void test_400() {
Assert.assertEquals(FitnessTarifRechner.TARIFTYP_PRO_BESUCH, FitnessTarifRechner.getOptimalenTariftyp((short) 21));
}
/**
* Niedrigste Besuchszahl, bei welcher sich der Flextarif lohnt.
*/
@Test
public void test_420() {
Assert.assertEquals(FitnessTarifRechner.TARIFTYP_FLEX, FitnessTarifRechner.getOptimalenTariftyp((short) 22));
}
/**
* Grenztest: 800€ sowohl für Flex- als auch Ganzjahrestarif.
*/
@Test public void test_480() {
Assert.assertEquals(FitnessTarifRechner.TARIFTYP_FLEX, FitnessTarifRechner.getOptimalenTariftyp((short) 130));
}
/**
* Grenztest: 800€ sowohl für Flex- als auch Ganzjahrestarif.
*/
@Test public void test_500() {
Assert.assertEquals(FitnessTarifRechner.TARIFTYP_JAHRESVORAUSZAHLUNG, FitnessTarifRechner.getOptimalenTariftyp((short) 131));
}
}
\ No newline at end of file
package de.hdm_stuttgart.mi.sd1.test.aufgabe1;
import org.junit.Assert;
import org.junit.FixMethodOrder;
import org.junit.Test;
import org.junit.runners.MethodSorters;
import de.hdm_stuttgart.mi.exam.unitmarking.ExaminationTestDefaults;
import de.hdm_stuttgart.mi.exam.unitmarking.Marking;
import de.hdm_stuttgart.mi.sd1.aufgabe1.Helper;
@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class Test_Helper extends ExaminationTestDefaults {
/**
* Nicht bestanden.
*/
@Test @Marking(points = 3) public void test_410() {
Assert.assertEquals("nicht bestanden", Helper.berechneNote(-100));
Assert.assertEquals("nicht bestanden", Helper.berechneNote(0));
Assert.assertEquals("nicht bestanden", Helper.berechneNote(49));
}
/**
* Ausreichend.
*/
@Test @Marking(points = 3) public void test_430() {
Assert.assertEquals("ausreichend", Helper.<