values() {
32 | return Arrays.asList(new Object[][] { { 1, 1, 2 }, { 2, 2, 4 }, { 2, 2, 5 } });
33 | }
34 |
35 | @Test
36 | public void testSum() {
37 | Sum s = new Sum();
38 | assertEquals(s.sum(s1, s2), erg);
39 | }
40 | }
41 |
--------------------------------------------------------------------------------
/lecture/quality/src/junit4/Test4.java:
--------------------------------------------------------------------------------
1 | package junit4;
2 |
3 | import org.junit.Test;
4 |
5 | import static org.junit.Assert.assertEquals;
6 |
7 | /**
8 | * Beispiel-Test mit JUnit 4
9 | */
10 |
11 | public class Test4 {
12 | @Test
13 | public void testSum() {
14 | Sum s = new Sum();
15 | assertEquals(6, s.sum(2, 4));
16 | }
17 | }
18 |
--------------------------------------------------------------------------------
/lecture/quality/src/junit4/TestAssume.java:
--------------------------------------------------------------------------------
1 | package junit4;
2 |
3 | import org.junit.Test;
4 |
5 | import static org.junit.Assert.assertEquals;
6 | import static org.junit.Assume.assumeTrue;
7 |
8 | public class TestAssume {
9 | @Test
10 | public void testStudi() {
11 | Studi s = new Studi();
12 | int cps = 2;
13 | // cps = -5;
14 |
15 | // assumeTrue(cps > 0);
16 |
17 | s.addToCredits(cps);
18 | assertEquals(cps, s.getCredits());
19 | }
20 | }
21 |
--------------------------------------------------------------------------------
/lecture/quality/src/junit5/Test5.java:
--------------------------------------------------------------------------------
1 | package junit5;
2 |
3 | import org.junit.jupiter.api.Tag;
4 | import org.junit.jupiter.api.Test;
5 |
6 | import static org.junit.jupiter.api.Assertions.assertEquals;
7 |
8 | /**
9 | * Beispiel-Test mit JUnit 5
10 | */
11 |
12 | class Test5 {
13 | @Test
14 | @Tag("junit5")
15 | void testSum() {
16 | assertEquals(6, 2 + 4);
17 | }
18 | }
19 |
--------------------------------------------------------------------------------
/lecture/quality/src/junit5/TestMethodSource.java:
--------------------------------------------------------------------------------
1 | package junit5;
2 |
3 | import org.junit.jupiter.api.Tag;
4 | import org.junit.jupiter.params.ParameterizedTest;
5 | import org.junit.jupiter.params.provider.MethodSource;
6 |
7 | import static org.junit.jupiter.api.Assertions.assertEquals;
8 |
9 | /**
10 | * Beispiel-Test (parametrisiert, Variante @MethodSource) mit JUnit 5
11 | */
12 |
13 | public class TestMethodSource {
14 | public static int[][] values() {
15 | return new int[][] { { 1, 1, 2 }, { 2, 2, 4 }, { 2, 2, 5 } };
16 | }
17 |
18 | @ParameterizedTest
19 | @MethodSource("values")
20 | @Tag("junit5")
21 | void testSum(int[] data) {
22 | assertEquals(data[0] + data[1], data[2]);
23 | }
24 | }
25 |
--------------------------------------------------------------------------------
/lecture/quality/src/junit5/TestValueSource.java:
--------------------------------------------------------------------------------
1 | package junit5;
2 |
3 | import org.junit.jupiter.api.Tag;
4 | import org.junit.jupiter.params.ParameterizedTest;
5 | import org.junit.jupiter.params.provider.ValueSource;
6 |
7 | import static org.junit.jupiter.api.Assertions.assertTrue;
8 |
9 | /**
10 | * Beispiel-Test (parametrisiert, Variante @ValueSource) mit JUnit 5
11 | */
12 |
13 | public class TestValueSource {
14 | @ParameterizedTest
15 | @ValueSource(strings = { "wuppie", "fluppie", "foo" })
16 | @Tag("junit5")
17 | void testWuppie(String candidate) {
18 | assertTrue(candidate.equals("wuppie"));
19 | }
20 | }
21 |
--------------------------------------------------------------------------------
/lecture/quality/src/logging/LoggingDemo.java:
--------------------------------------------------------------------------------
1 | package logging;
2 |
3 | import java.util.logging.Level;
4 | import java.util.logging.Logger;
5 |
6 | public class LoggingDemo {
7 | private static final Logger log = Logger.getLogger(LoggingDemo.class.getName());
8 |
9 | public static void main(String[] argv) {
10 | log.info("Und los ...");
11 |
12 | try {
13 | log.log(Level.WARNING, "Vorsicht!");
14 | int x = 0 / 0;
15 | } catch (Exception e) {
16 | log.log(Level.SEVERE, "Mift! Das ging schief: ", e);
17 | }
18 |
19 | log.info("Wuppie Fluppie :-))");
20 | }
21 | }
22 |
--------------------------------------------------------------------------------
/lecture/quality/src/logging/LoggingHandler.java:
--------------------------------------------------------------------------------
1 | package logging;
2 |
3 | import java.util.logging.ConsoleHandler;
4 | import java.util.logging.Level;
5 | import java.util.logging.Logger;
6 |
7 | public class LoggingHandler {
8 | private static final Logger log = Logger.getLogger(LoggingHandler.class.getName());
9 |
10 | public static void main(String[] argv) {
11 | log.setUseParentHandlers(false); // ??? :-)
12 |
13 | // log.setLevel(Level.FINE);
14 | // log.setLevel(Level.ALL);
15 |
16 | ConsoleHandler handlerA = new ConsoleHandler();
17 | handlerA.setLevel(Level.ALL);
18 | handlerA.setFormatter(new MyFormatter("A"));
19 | log.addHandler(handlerA);
20 |
21 | ConsoleHandler handlerB = new ConsoleHandler();
22 | handlerB.setLevel(Level.FINER);
23 | handlerB.setFormatter(new MyFormatter("B"));
24 | log.addHandler(handlerB);
25 |
26 | log.finest("finest");
27 | log.finer("finer");
28 | log.fine("fine");
29 | log.info("info");
30 | log.warning("warning");
31 | log.severe("severe");
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/lecture/quality/src/logging/LoggingLevel.java:
--------------------------------------------------------------------------------
1 | package logging;
2 |
3 | import java.util.logging.Level;
4 | import java.util.logging.Logger;
5 |
6 | public class LoggingLevel {
7 | private static final Logger log = Logger.getLogger(LoggingLevel.class.getName());
8 |
9 | public static void main(String[] argv) {
10 | // log.setLevel(Level.WARNING);
11 | // log.setLevel(Level.OFF);
12 | // log.setLevel(Level.ALL); // ??? :-)
13 |
14 | log.finest("level finest");
15 | log.finer("level finer");
16 | log.fine("level fine");
17 | log.config("level config");
18 | log.info("level info");
19 | log.warning("level warning");
20 | log.severe("level severe");
21 | log.log(Level.INFO, "log() mit info-level");
22 | }
23 | }
24 |
--------------------------------------------------------------------------------
/lecture/quality/src/logging/MyFormatter.java:
--------------------------------------------------------------------------------
1 | package logging;
2 |
3 | import java.util.logging.LogRecord;
4 | import java.util.logging.SimpleFormatter;
5 |
6 | class MyFormatter extends SimpleFormatter {
7 | private final String name;
8 |
9 | public MyFormatter(String n) {
10 | name = n;
11 | }
12 |
13 | @Override
14 | public String format(LogRecord record) {
15 | return "---- " + name + " ::" + record.getMessage() + ":: " + name + " ----\n";
16 | }
17 | }
18 |
--------------------------------------------------------------------------------
/lecture/quality/src/mockito/.gitattributes:
--------------------------------------------------------------------------------
1 | #
2 | # https://help.github.com/articles/dealing-with-line-endings/
3 | #
4 | # These are explicitly windows files and should use crlf
5 | *.bat text eol=crlf
6 |
7 |
--------------------------------------------------------------------------------
/lecture/quality/src/mockito/.gitignore:
--------------------------------------------------------------------------------
1 | # Ignore Gradle project-specific cache directory
2 | .gradle
3 |
4 | # Ignore Gradle build output directory
5 | build
6 |
--------------------------------------------------------------------------------
/lecture/quality/src/mockito/build.gradle:
--------------------------------------------------------------------------------
1 | plugins {
2 | id "java"
3 | id "checkstyle"
4 | id "com.diffplug.spotless" version "6.25.0"
5 | id "com.github.spotbugs" version "6.0.15"
6 | }
7 |
8 | repositories {
9 | mavenCentral()
10 | }
11 |
12 | dependencies {
13 | testImplementation 'junit:junit:4.13.2'
14 | testImplementation 'org.mockito:mockito-core:5.12.0'
15 | }
16 |
17 | checkstyle {
18 | configFile file('checkstyle.xml')
19 | toolVersion '10.19.0'
20 | }
21 |
22 | spotless {
23 | java {
24 | googleJavaFormat().aosp()
25 | }
26 | }
27 |
28 | spotbugs {
29 | ignoreFailures = true
30 | showStackTraces = false
31 | toolVersion = '4.8.5'
32 | }
33 | spotbugsMain {
34 | reports {
35 | html {
36 | required = true
37 | outputLocation = file("$buildDir/reports/spotbugs/spotbugs.html")
38 | }
39 | }
40 | }
41 |
--------------------------------------------------------------------------------
/lecture/quality/src/mockito/gradle.properties:
--------------------------------------------------------------------------------
1 |
2 | org.gradle.daemon=true
3 | org.gradle.configureondemand=false
4 | org.gradle.jvmargs=-Xms128m -Xmx2048m \
5 | --add-exports jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED \
6 | --add-exports jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED \
7 | --add-exports jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED \
8 | --add-exports jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED \
9 | --add-exports jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED
10 | # The "add-exports" options are a workaround to use the "google-java-format" plugin with Java 17 and Gradle 7.2.
11 | # See also here:
12 | # https://github.com/google/google-java-format#jdk-16
13 | # https://github.com/diffplug/spotless/tree/main/plugin-gradle#google-java-format
14 |
--------------------------------------------------------------------------------
/lecture/quality/src/mockito/gradle/wrapper/gradle-wrapper.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Programmiermethoden-CampusMinden/Prog2-Lecture/bba3ae3786a25142d0d1b553996547cd2f02edfe/lecture/quality/src/mockito/gradle/wrapper/gradle-wrapper.jar
--------------------------------------------------------------------------------
/lecture/quality/src/mockito/gradle/wrapper/gradle-wrapper.properties:
--------------------------------------------------------------------------------
1 | distributionBase=GRADLE_USER_HOME
2 | distributionPath=wrapper/dists
3 | distributionUrl=https\://services.gradle.org/distributions/gradle-8.10.2-bin.zip
4 | networkTimeout=10000
5 | validateDistributionUrl=true
6 | zipStoreBase=GRADLE_USER_HOME
7 | zipStorePath=wrapper/dists
8 |
--------------------------------------------------------------------------------
/lecture/quality/src/mockito/src/main/java/hsbi/LSF.java:
--------------------------------------------------------------------------------
1 | package hsbi;
2 |
3 | public class LSF {
4 | /**
5 | * Melde einen Studi in einem Modul zur Prüfung an.
6 | *
7 | * @param name Name des anzumeldenden Studis
8 | * @param modul Modul, in dem der Studi angemeldet wird
9 | * @return true, wenn die Anmeldung erfolgreich war; sonst false
10 | */
11 | public boolean anmelden(String name, String modul) {
12 | throw new UnsupportedOperationException();
13 | }
14 |
15 | /**
16 | * Finde die Punkte heraus, die ein Studi in einer Modulprüfung erreicht hat
17 | *
18 | * Um den Profs das Leben leichter zu machen, werden die Prüfungen automatisch mit einer
19 | * zufälligen Zahl von Punkten zwischen 0 und 100 bewertet.
20 | *
21 | * @param name Name des Studis
22 | * @param modul Modul, für das die Ergebnisse abgefragt werden
23 | * @return Anzahl der Punkte: [0,100]
24 | */
25 | public int ergebnis(String name, String modul) {
26 | throw new UnsupportedOperationException();
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/lecture/quality/src/mockito/src/main/java/hsbi/Studi.java:
--------------------------------------------------------------------------------
1 | package hsbi;
2 |
3 | public class Studi {
4 | String name;
5 | LSF lsf;
6 |
7 | public Studi(String name, LSF lsf) {
8 | this.name = name;
9 | this.lsf = lsf;
10 | }
11 |
12 | /**
13 | * Melde den Studi zur Prüfung an.
14 | *
15 | * @param modul In diesem Modul will sich der Studi anmelden
16 | * @return true, wenn Anmeldung erfolgreich; sonst false
17 | */
18 | public boolean anmelden(String modul) {
19 | return lsf.anmelden(name, modul);
20 | }
21 |
22 | /**
23 | * Nehme an der Klausureinsicht teil und reagiere auf das Ergebnis.
24 | *
25 | * @param modul Für dieses Modul soll die Einsicht erfolgen
26 | * @return true, falls mehr als 50 Punkte (bestanden); sonst false
27 | */
28 | public boolean einsicht(String modul) {
29 | return lsf.ergebnis(name, modul) > 50;
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/lecture/quality/src/mockito/src/main/java/wuppie/mock/IWuppiWarenlager.java:
--------------------------------------------------------------------------------
1 | package wuppie.mock;
2 |
3 | import java.util.List;
4 |
5 | /**
6 | * Das Warenlager für die Wuppis gibt es noch gar nicht, es befindet sich derzeit aber bereits im
7 | * Bau. Später sollen darüber alle Wuppis bestellt werden können.
8 | */
9 | public interface IWuppiWarenlager {
10 | /**
11 | * Gibt alle im Warenlager befindlichen Wuppis als Liste zurück.
12 | *
13 | * @return Eine Liste mit Wuppis des Warenlagers.
14 | */
15 | List getAlleWuppis();
16 | }
17 |
--------------------------------------------------------------------------------
/lecture/quality/src/mockito/src/main/java/wuppie/mock/WuppiStore.java:
--------------------------------------------------------------------------------
1 | package wuppie.mock;
2 |
3 | import java.util.List;
4 |
5 | /**
6 | * Über unsere brandheißen WuppiStores verkaufen wir dann alle Wuppis aus dem Wuppi-Warenlager (wenn
7 | * es mal fertiggestellt ist).
8 | */
9 | public class WuppiStore {
10 | public IWuppiWarenlager lager;
11 |
12 | public WuppiStore(IWuppiWarenlager lager) {
13 | this.lager = lager;
14 | }
15 |
16 | /**
17 | * Bestellt alle Wuppis aus dem angegebenen Warenlager
18 | *
19 | * @param lager Das Lager, aus dem die Wuppis geordert werden.
20 | * @return Eine Liste mit allen Wuppis, die bestellt wurden.
21 | */
22 | public List bestelleAlleWuppis(IWuppiWarenlager lager) {
23 | return lager.getAlleWuppis();
24 | }
25 | }
26 |
--------------------------------------------------------------------------------
/lecture/quality/src/mockito/src/main/java/wuppie/spy/IWuppiWarenlager.java:
--------------------------------------------------------------------------------
1 | package wuppie.spy;
2 |
3 | import java.util.List;
4 |
5 | /**
6 | * Das Warenlager für die Wuppis gibt es noch gar nicht, es befindet sich derzeit aber bereits im
7 | * Bau. Später sollen darüber alle Wuppis bestellt werden können.
8 | */
9 | public interface IWuppiWarenlager {
10 | /**
11 | * Gibt alle im Warenlager befindlichen Wuppis als Liste zurück.
12 | *
13 | * @return Eine Liste mit Wuppis des Warenlagers.
14 | */
15 | List getAlleWuppis();
16 |
17 | /**
18 | * Fügt dem Warenlager den übergebenen Wuppi hinzu.
19 | *
20 | * @param wuppi Der Wuppi der dem Lager hinzugefügt werden soll.
21 | */
22 | void addWuppi(Wuppi wuppi);
23 | }
24 |
--------------------------------------------------------------------------------
/lecture/quality/src/mockito/src/main/java/wuppie/spy/Wuppi.java:
--------------------------------------------------------------------------------
1 | package wuppie.spy;
2 |
3 | /** Ein einfacher Wuppi */
4 | public class Wuppi {
5 | String name;
6 |
7 | /**
8 | * Erzeugt einen neuen Wuppi mit dem übergebenen Namen.
9 | *
10 | * @param name Der Name des Wuppis
11 | */
12 | Wuppi(String name) {
13 | this.name = name;
14 | }
15 | }
16 |
--------------------------------------------------------------------------------
/lecture/quality/src/mockito/src/main/java/wuppie/spy/WuppiStore.java:
--------------------------------------------------------------------------------
1 | package wuppie.spy;
2 |
3 | import java.util.List;
4 |
5 | /**
6 | * Über unsere brandheißen WuppiStores verkaufen wir dann alle Wuppis aus dem Wuppi-Warenlager (wenn
7 | * es mal fertiggestellt ist).
8 | */
9 | public class WuppiStore {
10 | public IWuppiWarenlager lager;
11 |
12 | public WuppiStore(IWuppiWarenlager lager) {
13 | this.lager = lager;
14 | }
15 |
16 | /**
17 | * Bestellt alle Wuppis aus dem angegebenen Warenlager
18 | *
19 | * @param lager Das lager aus dem die Wuppis geordert werden.
20 | * @return Eine Liste mit allen Wuppis die bestellt wurden.
21 | */
22 | public List bestelleAlleWuppis(IWuppiWarenlager lager) {
23 | return lager.getAlleWuppis();
24 | }
25 | }
26 |
--------------------------------------------------------------------------------
/lecture/quality/src/mockito/src/main/java/wuppie/spy/WuppiWarenlager.java:
--------------------------------------------------------------------------------
1 | package wuppie.spy;
2 |
3 | import java.util.ArrayList;
4 | import java.util.List;
5 |
6 | public class WuppiWarenlager implements IWuppiWarenlager {
7 | List lager = new ArrayList<>();
8 |
9 | /** @inheritDoc */
10 | @Override
11 | public List getAlleWuppis() {
12 | return this.lager;
13 | }
14 |
15 | /** @inheritDoc */
16 | @Override
17 | public void addWuppi(Wuppi wuppi) {
18 | this.lager.add(wuppi);
19 | }
20 | }
21 |
--------------------------------------------------------------------------------
/lecture/quality/src/mockito/src/main/java/wuppie/stub/IWuppiWarenlager.java:
--------------------------------------------------------------------------------
1 | package wuppie.stub;
2 |
3 | import java.util.List;
4 |
5 | /**
6 | * Das Warenlager für die Wuppis gibt es noch gar nicht, es befindet sich derzeit aber bereits im
7 | * Bau. Später sollen darüber alle Wuppis bestellt werden können.
8 | */
9 | public interface IWuppiWarenlager {
10 | /**
11 | * Gibt alle im Warenlager befindlichen Wuppis als Liste zurück.
12 | *
13 | * @return Eine Liste mit Wuppis des Warenlagers.
14 | */
15 | List getAlleWuppis();
16 | }
17 |
--------------------------------------------------------------------------------
/lecture/quality/src/mockito/src/main/java/wuppie/stub/WuppiStore.java:
--------------------------------------------------------------------------------
1 | package wuppie.stub;
2 |
3 | import java.util.List;
4 |
5 | /**
6 | * Über unsere brandheißen WuppiStores verkaufen wir dann alle Wuppis aus dem Wuppi-Warenlager (wenn
7 | * es mal fertiggestellt ist).
8 | */
9 | public class WuppiStore {
10 | public IWuppiWarenlager lager;
11 |
12 | public WuppiStore(IWuppiWarenlager lager) {
13 | this.lager = lager;
14 | }
15 |
16 | /**
17 | * Bestellt alle Wuppis aus dem angegebenen Warenlager
18 | *
19 | * @param lager Das Lager, aus dem die Wuppis geordert werden.
20 | * @return Eine Liste mit allen Wuppis, die bestellt wurden.
21 | */
22 | public List bestelleAlleWuppis(IWuppiWarenlager lager) {
23 | return lager.getAlleWuppis();
24 | }
25 | }
26 |
--------------------------------------------------------------------------------
/lecture/quality/src/mockito/src/main/java/wuppie/stub/WuppiWarenlagerStub.java:
--------------------------------------------------------------------------------
1 | package wuppie.stub;
2 |
3 | import java.util.Arrays;
4 | import java.util.List;
5 |
6 | /**
7 | * Da es noch kein funktionierendes Lager mit Wuppis gibt, wir aber trotzdem schon einmal unser
8 | * Kassensystem erstellen wollen, mit denen dann alle Wuppis bestellt werden können, erzeugen wir
9 | * uns einfach einen Stub des später einmal existierenden Warenlagers, um die Funktionalität des
10 | * Lagers testen zu können.
11 | */
12 | public class WuppiWarenlagerStub implements IWuppiWarenlager {
13 | /** @inheritDoc */
14 | public List getAlleWuppis() {
15 | return Arrays.asList("GruenerWuppi", "RoterWuppi");
16 | }
17 | }
18 |
--------------------------------------------------------------------------------
/lecture/quality/src/mockito/src/main/java/wuppie/verify/FluppisListe.java:
--------------------------------------------------------------------------------
1 | package wuppie.verify;
2 |
3 | import java.util.AbstractList;
4 |
5 | public class FluppisListe extends AbstractList {
6 | @Override
7 | public String get(int index) {
8 | return null;
9 | }
10 |
11 | @Override
12 | public int size() {
13 | return 0;
14 | }
15 | }
16 |
--------------------------------------------------------------------------------
/lecture/quality/src/mockito/src/test/java/hsbi/StudiStubTest.java:
--------------------------------------------------------------------------------
1 | package hsbi;
2 |
3 | import org.junit.Before;
4 | import org.junit.Test;
5 |
6 | import static org.junit.Assert.assertTrue;
7 |
8 | public class StudiStubTest {
9 | Studi studi;
10 | LSF lsf;
11 |
12 | @Before
13 | public void setUp() {
14 | lsf = new LsfStub();
15 | studi = new Studi("Harald", lsf);
16 | }
17 |
18 | @Test
19 | public void testAnmelden() {
20 | assertTrue(studi.anmelden("PM-Dungeon"));
21 | }
22 |
23 | @Test
24 | public void testEinsicht() {
25 | assertTrue(studi.einsicht("PM-Dungeon"));
26 | }
27 |
28 | // Stub für das noch nicht fertige LSF
29 | class LsfStub extends LSF {
30 | public boolean anmelden(String name, String modul) {
31 | return true;
32 | }
33 |
34 | public int ergebnis(String name, String modul) {
35 | return 80;
36 | }
37 | }
38 | }
39 |
--------------------------------------------------------------------------------
/lecture/quality/src/mockito/src/test/java/hsbi/VerifyTest.java:
--------------------------------------------------------------------------------
1 | package hsbi;
2 |
3 | import org.junit.Test;
4 |
5 | import static org.junit.Assert.assertTrue;
6 | import static org.mockito.Mockito.*;
7 |
8 | public class VerifyTest {
9 | @Test
10 | public void testAnmelden() {
11 | LSF lsf = mock(LSF.class);
12 | Studi studi = new Studi("Harald", lsf);
13 |
14 | when(lsf.anmelden("Harald", "PM-Dungeon")).thenReturn(true);
15 |
16 | assertTrue(studi.anmelden("PM-Dungeon"));
17 |
18 | verify(lsf).anmelden("Harald", "PM-Dungeon");
19 |
20 | verify(lsf, times(1)).anmelden("Harald", "PM-Dungeon");
21 | verify(lsf, atLeast(1)).anmelden("Harald", "PM-Dungeon");
22 | verify(lsf, atMost(1)).anmelden("Harald", "PM-Dungeon");
23 |
24 | verify(lsf, never()).ergebnis("Harald", "PM-Dungeon");
25 |
26 | verifyNoMoreInteractions(lsf);
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/lecture/quality/src/refactoring/Kurs.java:
--------------------------------------------------------------------------------
1 | package refactoring;
2 |
3 | public class Kurs {
4 | public int cps;
5 | public String descr;
6 |
7 | public Kurs(String descr, int cps) {
8 | this.descr = descr;
9 | this.cps = cps;
10 | }
11 | }
12 |
--------------------------------------------------------------------------------
/lecture/quality/src/refactoring/KursTest.java:
--------------------------------------------------------------------------------
1 | package refactoring;
2 |
3 | import org.junit.Test;
4 |
5 | import static org.junit.Assert.assertEquals;
6 |
7 | public class KursTest {
8 | @Test
9 | public void testKurs() {
10 | Kurs k = new Kurs("Test", 42);
11 |
12 | assertEquals("Test", k.descr);
13 | assertEquals(42, k.cps);
14 | }
15 | }
16 |
--------------------------------------------------------------------------------
/lecture/quality/src/refactoring/Person.java:
--------------------------------------------------------------------------------
1 | package refactoring;
2 |
3 | public class Person {
4 | }
5 |
--------------------------------------------------------------------------------
/lecture/quality/src/refactoring/PersonTest.java:
--------------------------------------------------------------------------------
1 | package refactoring;
2 |
3 | import org.junit.Test;
4 |
5 | import static org.junit.Assert.assertNotNull;
6 | import static org.junit.Assume.assumeTrue;
7 |
8 | public class PersonTest {
9 | @Test
10 | public void testPerson() {
11 | Person p = new Person();
12 |
13 | assertNotNull(p);
14 | }
15 | }
16 |
--------------------------------------------------------------------------------
/lecture/quality/src/refactoring/StudiTest.java:
--------------------------------------------------------------------------------
1 | package refactoring;
2 |
3 | import org.junit.Test;
4 |
5 | import static org.junit.Assert.assertEquals;
6 |
7 | public class StudiTest {
8 | @Test
9 | public void testStudi() {
10 | Kurs k = new Kurs("myKurs", 9);
11 | Studi s = new Studi("Werner", 3, k);
12 |
13 | assertEquals("Werner", s.n);
14 | assertEquals(3, s.c);
15 | assertEquals(k, s.k);
16 | }
17 |
18 | @Test
19 | public void testChangeNme() {
20 | Kurs k = new Kurs("myKurs", 9);
21 | Studi s = new Studi("Werner", 3, k);
22 |
23 | assertEquals("Werner", s.n);
24 |
25 | s.n = "Heini";
26 | assertEquals("Heini", s.n);
27 | assertEquals(3, s.c);
28 | assertEquals(k, s.k);
29 | }
30 |
31 | @Test
32 | public void testPrtIf() {
33 | Kurs k = new Kurs("myKurs", 9);
34 | Studi s = new Studi("Werner", 3, k);
35 | }
36 | }
37 |
--------------------------------------------------------------------------------
/lecture/quality/src/spotbugs/.gitattributes:
--------------------------------------------------------------------------------
1 | #
2 | # https://help.github.com/articles/dealing-with-line-endings/
3 | #
4 | # These are explicitly windows files and should use crlf
5 | *.bat text eol=crlf
6 |
7 |
--------------------------------------------------------------------------------
/lecture/quality/src/spotbugs/.gitignore:
--------------------------------------------------------------------------------
1 | # Ignore Gradle project-specific cache directory
2 | .gradle
3 |
4 | # Ignore Gradle build output directory
5 | build
6 |
--------------------------------------------------------------------------------
/lecture/quality/src/spotbugs/build.gradle:
--------------------------------------------------------------------------------
1 | plugins {
2 | id "java"
3 | id "application"
4 | id "com.github.spotbugs" version "6.0.15"
5 | }
6 |
7 | repositories {
8 | mavenCentral()
9 | }
10 |
11 | dependencies {
12 | }
13 |
14 | spotbugs {
15 | ignoreFailures = true
16 | showStackTraces = false
17 | toolVersion = '4.8.5'
18 | }
19 | spotbugsMain {
20 | reports {
21 | html {
22 | required = true
23 | outputLocation = file("$buildDir/reports/spotbugs/spotbugs.html")
24 | }
25 | }
26 | }
27 |
28 | application {
29 | mainClass = 'wuppie.deeplearning.strategy.MyWuppieStudi'
30 | }
31 |
--------------------------------------------------------------------------------
/lecture/quality/src/spotbugs/gradle/wrapper/gradle-wrapper.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Programmiermethoden-CampusMinden/Prog2-Lecture/bba3ae3786a25142d0d1b553996547cd2f02edfe/lecture/quality/src/spotbugs/gradle/wrapper/gradle-wrapper.jar
--------------------------------------------------------------------------------
/lecture/quality/src/spotbugs/gradle/wrapper/gradle-wrapper.properties:
--------------------------------------------------------------------------------
1 | distributionBase=GRADLE_USER_HOME
2 | distributionPath=wrapper/dists
3 | distributionUrl=https\://services.gradle.org/distributions/gradle-8.10.1-bin.zip
4 | networkTimeout=10000
5 | validateDistributionUrl=true
6 | zipStoreBase=GRADLE_USER_HOME
7 | zipStorePath=wrapper/dists
8 |
--------------------------------------------------------------------------------
/lecture/quality/src/spotbugs/src/main/java/wuppie/deeplearning/strategy/MyWuppieStudi.java:
--------------------------------------------------------------------------------
1 | package wuppie.deeplearning.strategy;
2 |
3 | /**
4 | * Demonstriert den Einsatz von AOSP/Google Java Style ................. Umbruch nach 100 Zeichen |
5 | */
6 | public class MyWuppieStudi implements Comparable {
7 | private static String lastName;
8 | private static MyWuppieStudi studi;
9 |
10 | private MyWuppieStudi() {}
11 |
12 | /** Erzeugt ein neues Exemplar der MyWuppieStudi-Spezies (max. 40 Zeilen) */
13 | public static MyWuppieStudi getMyWuppieStudi(String name) {
14 | if (studi == null) {
15 | new MyWuppieStudi();
16 | }
17 | if (lastName == name || true) lastName = name;
18 |
19 | return studi;
20 | }
21 |
22 | @Override
23 | public int compareTo(MyWuppieStudi o) {
24 | return lastName.compareTo(lastName);
25 | }
26 |
27 | public static void main(String[] args) {
28 | MyWuppieStudi.getMyWuppieStudi("Hello World");
29 | System.out.println("Hello World");
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/lecture/quality/src/tdd/PasswordChecker.java:
--------------------------------------------------------------------------------
1 | package tdd;
2 |
3 | public class PasswordChecker {
4 | public static boolean isValid(String pw) {
5 | if (pw == null) {
6 | return false;
7 | }
8 | return !pw.isEmpty() && pw.length() > 3 && pw.length() <= 10;
9 | }
10 | }
11 |
--------------------------------------------------------------------------------
/lecture/quality/src/tdd/anforderungen.md:
--------------------------------------------------------------------------------
1 | # Passwort-Prüfer
2 |
3 | + Passwort ist ein String
4 | + Passwort darf nicht leer sein
5 | + Passwort muss länger als 4 Zeichen sein
6 | + Passwort darf nicht länger als 10 Zeichen sein
7 |
--------------------------------------------------------------------------------
/lecture/readme.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: "Vorlesungsunterlagen"
3 | no_pdf: true
4 | no_beamer: true
5 | ---
6 |
--------------------------------------------------------------------------------
/pm.yaml:
--------------------------------------------------------------------------------
1 | # language
2 | lang: de-DE
3 |
4 | # author information
5 | institute: "Unless otherwise noted, this work is licensed under CC BY-SA 4.0."
6 |
7 | # bibtex file
8 | bibliography: pm.bib
9 |
10 | # collect references (for use in filter/template)
11 | refs: |
12 | ::: {#refs}
13 | :::
14 |
15 | # root document
16 | root_doc: readme.md
17 | indexMD: readme
18 |
19 | # license footer
20 | license_footer: |
21 | {width="10%"}
22 |
23 | Unless otherwise noted, this work is licensed under CC BY-SA 4.0.
24 |
--------------------------------------------------------------------------------