diff --git a/pom.xml b/pom.xml
index 2332fa5..e77a263 100644
--- a/pom.xml
+++ b/pom.xml
@@ -36,6 +36,12 @@
util
acc6c30
+
+
+ joda-time
+ joda-time
+ 2.10.13
+
diff --git a/src/main/java/github/weichware10/analyse/Analyse.java b/src/main/java/github/weichware10/analyse/Analyse.java
new file mode 100644
index 0000000..45ae959
--- /dev/null
+++ b/src/main/java/github/weichware10/analyse/Analyse.java
@@ -0,0 +1,31 @@
+package github.weichware10.analyse;
+
+import github.weichware10.util.Data;
+import java.util.List;
+
+/**
+ * beinhaltet Methoden die zur Analyse benötigt werden.
+ */
+public abstract class Analyse {
+
+ /**
+ * berechnet die relativen Häufigkeiten der Bildkoordinaten.
+ *
+ * @return Liste mit den relativen Häufigkeiten der Bildkoordinaten
+ */
+ protected List> calcRelFreq(Data data) {
+ return null;
+ }
+
+ /**
+ * erstellt eine Tabelle mit den Zeitpunkten und dazugehörigen Bildkoordinaten
+ * bzw. Zoomstärken
+ *
+ * @return Tabelle mit Zeitpunkten und dazugehörigen Bildkoordinaten bzw.
+ * Zoomstärken
+ */
+ protected List> createTimeTable(Data data) {
+ return null;
+ }
+
+}
diff --git a/src/main/java/github/weichware10/analyse/AnalyseType.java b/src/main/java/github/weichware10/analyse/AnalyseType.java
new file mode 100644
index 0000000..b5238f6
--- /dev/null
+++ b/src/main/java/github/weichware10/analyse/AnalyseType.java
@@ -0,0 +1,12 @@
+package github.weichware10.analyse;
+
+/**
+ * Enum der möglichen Analyse-Typen.
+ */
+public enum AnalyseType {
+ HEATPMAP,
+ COMPHEATMAP,
+ VERLAUF,
+ RELFRQIMGAREA,
+ VIEWTIMEDISTR
+}
diff --git a/src/main/java/github/weichware10/analyse/Client.java b/src/main/java/github/weichware10/analyse/Client.java
new file mode 100644
index 0000000..32d1cf1
--- /dev/null
+++ b/src/main/java/github/weichware10/analyse/Client.java
@@ -0,0 +1,158 @@
+package github.weichware10.analyse;
+
+import github.weichware10.util.Data;
+import github.weichware10.util.Enums.ToolType;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import org.joda.time.DateTime;
+
+/**
+ * Grundlegende Klasse für den Analyse-Client.
+ */
+public class Client {
+ private Data data;
+ private Data dataForComp;
+ private List analyseTypes;
+ private List analyzedData;
+ private ConfigHeatmap confHm;
+ private ConfigDiagramm confDia;
+
+ public Client() {
+ analyseTypes = new ArrayList();
+ analyzedData = new ArrayList();
+ }
+
+ /**
+ * setzt die ausgewählten Analyse-Typen.
+ *
+ * @param selectedAnalyseTypes - die ausgewählten Analyse-Typen
+ * @return
+ * true, falls Analyse-Typen gesetzt wurden;
+ * false, falls keine Analyse-Typen gesetzt wurden
+ */
+ public boolean setAnalyseTypes(List selectedAnalyseTypes) {
+ if (selectedAnalyseTypes.isEmpty()) {
+ return false;
+ }
+ this.analyseTypes = selectedAnalyseTypes;
+ return true;
+ }
+
+ /**
+ * gibt die Anaylse-Typen zurück.
+ *
+ * @return Analyse-Typen
+ */
+ public List getAnalyseTypes() {
+ return this.analyseTypes;
+ }
+
+ /**
+ * holt die angeforderten Daten vom Speichermedium, falls diese existieren.
+ *
+ * @param start - Startzeitpunkt der benötigten Daten
+ * @param end - Endzeitpunkt der benötigten Daten
+ * @param dataType - Tool-Typ der benötigten Daten
+ * @return
+ * true, falls benötigte Daten gefunden und gesetzt wurden;
+ * false, falls benötigte Daten nicht gefunden wurden
+ */
+ public boolean getData(DateTime start, DateTime end, ToolType dataType) {
+ if (start.isAfter(end) || start.isAfter(DateTime.now()) || end.isAfter(DateTime.now())) {
+ return false;
+ }
+
+ // * Provisorische Lösung für Test, da er sonst nicht funktionieren würde
+ int amountData = 3;
+ List dataStart = new ArrayList(Arrays.asList(
+ new DateTime(2021, 11, 28, 16, 0, 0), new DateTime(2021, 11, 28, 15, 0, 0),
+ new DateTime(2021, 11, 28, 19, 0, 0)));
+ List dataEnd = new ArrayList(Arrays.asList(
+ new DateTime(2021, 11, 28, 19, 0, 0), new DateTime(2021, 11, 28, 18, 0, 0),
+ new DateTime(2021, 11, 28, 20, 0, 0)));
+ List dataToolType = new ArrayList(Arrays.asList(
+ ToolType.ZOOM, ToolType.EYETRACKING, ToolType.CODECHARTS));
+
+ for (int id = 0; id < amountData; id++) {
+ if (dataStart.get(id).equals(start) && dataEnd.get(id).equals(end)
+ && dataToolType.get(id).equals(dataType)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * holt die angeforderten Daten zum Vergleich vom Speichermedium, falls diese
+ * existieren.
+ *
+ * @param start - Startzeitpunkt der benötigten Daten zum Vergleich
+ * @param end - Endzeitpunkt der benötigten Daten zum Vergleich
+ * @return
+ * true, falls benötigte Daten zum Vergleich gefunden und gesetzt
+ * wurden;
+ * false, falls benötigte Daten zum Vergleich nicht gefunden wurden
+ */
+ public boolean getDataForComp(DateTime start, DateTime end) {
+ if (start.isAfter(end) || start.isAfter(DateTime.now()) || end.isAfter(DateTime.now())) {
+ return false;
+ }
+ return true;
+ }
+
+ /**
+ * verändert die Standard-Konfiguration für die Heatmap-Analyse.
+ *
+ * @param confHm - Konfiguration der Heatmap-Analyse
+ */
+ public void setConfigAnalyseHm(ConfigHeatmap confHm) {
+ this.confHm = confHm;
+ }
+
+ /**
+ * verändert die Standard-Konfiguration für die Diagramm-Analyse.
+ *
+ * @param confDia - Konfiguration der Diagramm-Analyse
+ */
+ public void setConfigAnalyseDia(ConfigDiagramm confDia) {
+ this.confDia = confDia;
+ }
+
+ /**
+ * führt die ausgewählten Analysen durch.
+ */
+ public void analyseData() {
+ ;
+ }
+
+ /**
+ * zeigt die analysierten Daten an.
+ */
+ public void displayAnalyzedData() {
+ ;
+ }
+
+ /**
+ * exportiert die analysierten Daten.
+ *
+ * @return
+ * true, wenn Export erfolreich war;
+ * false, wenn Fehler aufgetreten ist
+ */
+ public boolean export() {
+ return true;
+ }
+
+ /**
+ * exportiert die rohen Daten der Analyse.
+ *
+ * @return
+ * true, wenn Export erfolreich war;
+ * false, wenn Fehler aufgetreten ist
+ */
+ public boolean exportRaw() {
+ return true;
+ }
+
+}
diff --git a/src/main/java/github/weichware10/analyse/ClientGui.java b/src/main/java/github/weichware10/analyse/ClientGui.java
new file mode 100644
index 0000000..bdcfed2
--- /dev/null
+++ b/src/main/java/github/weichware10/analyse/ClientGui.java
@@ -0,0 +1,25 @@
+package github.weichware10.analyse;
+
+/**
+ * verantwortliche für die graphische Benutzeroberfläche des Clients mit Ein-
+ * und Ausgabe.
+ */
+public class ClientGui {
+ private Client client;
+
+ /**
+ * verantwortliche für die graphische Benutzeroberfläche des Clients mit Ein-
+ * und Ausgabe.
+ */
+ public ClientGui() {
+ this.client = new Client();
+ }
+
+ /**
+ * zeigt die graphische Benutzeroberfläche an.
+ */
+ public void showGui() {
+ ;
+ }
+
+}
diff --git a/src/main/java/github/weichware10/analyse/ConfigDiagramm.java b/src/main/java/github/weichware10/analyse/ConfigDiagramm.java
new file mode 100644
index 0000000..74332db
--- /dev/null
+++ b/src/main/java/github/weichware10/analyse/ConfigDiagramm.java
@@ -0,0 +1,119 @@
+package github.weichware10.analyse;
+
+/**
+ * Speicherung der Konfiguration der Diagramm-Analysemethoden.
+ */
+public class ConfigDiagramm {
+ private int amountAreas; // * 2,4,6,8
+ private float minTime; // * >= 0 Länge | Zoomstufe
+ private float maxTime; // * <= 10 Länge | Zoomstufe
+ private int stepsBetween; // * [1,10], minTime=maxTime: steps = 0
+
+ /**
+ * Speicherung der Konfiguration der Diagramm-Analysemethoden.
+ */
+ public ConfigDiagramm() {
+ this.amountAreas = 4;
+ this.minTime = 0.5f;
+ this.maxTime = 2.5f;
+ this.stepsBetween = 4;
+ }
+
+ /**
+ * setzt neue Anzahl der Felder.
+ *
+ * @param amountAreas - neue Anzahl der Felder
+ * @return
+ * true, falls neue Anzahl erfolgreich gesetzt wurde;
+ * false, falls neue Anzahl nicht gesetzt wurde
+ */
+ public boolean setAmountAreas(int amountAreas) {
+ if (amountAreas % 2 == 0 && amountAreas >= 2 && amountAreas <= 8) {
+ this.amountAreas = amountAreas;
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ /**
+ * gibt die Anzahl der Felder zurück.
+ *
+ * @return Anzahl der Felder
+ */
+ public int getAmountAreas() {
+ return amountAreas;
+ }
+
+ /**
+ * setzt neue minimale und maximale Zeit.
+ *
+ * @param minTime - neue minimale Zeit
+ * @param maxTime - neue maximale Zeit
+ * @return
+ * true, falls neue min. und max. Zeit erfolgreich gesetzt wurden;
+ * false, falls neue min. und max. Zeit nicht gesetzt wurden
+ */
+ public boolean setNewTime(float minTime, float maxTime) {
+ if (minTime >= 0.0f && maxTime <= 10.0f && minTime <= maxTime) {
+ this.minTime = minTime;
+ this.maxTime = maxTime;
+ if (this.maxTime == this.minTime) {
+ this.stepsBetween = 0;
+ }
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ /**
+ * gibt die minimale Zeit zurück.
+ *
+ * @return minimale Zeit
+ */
+ public float getMinTime() {
+ return minTime;
+ }
+
+ /**
+ * gibt die maximale Zeit zurück.
+ *
+ * @return maximale Zeit
+ */
+ public float getMaxTime() {
+ return maxTime;
+ }
+
+ /**
+ * setzt neue Anzahl an Zwischenschritten.
+ *
+ * @param stepsBetween - neue Anzahl Zwischenschritte
+ * @return
+ * true, falls neue Anzahl an Zwischenschritten erfolgreich gesetzt
+ * wurde;
+ * false, falls neue Anzahl an Zwischenschritten nicht gesetzt
+ * wurde
+ */
+ public boolean setStepsBetween(int stepsBetween) {
+ if (this.getMinTime() == this.getMaxTime()) {
+ this.stepsBetween = 0;
+ return true;
+ } else if (stepsBetween <= 10 && stepsBetween >= 1) {
+ this.stepsBetween = stepsBetween;
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ /**
+ * gibt die Anzahl der Zwischenschritte zurück.
+ *
+ * @return Anzahl der Zwischenschritte
+ */
+ public int getStepsBetween() {
+ return stepsBetween;
+ }
+
+}
diff --git a/src/main/java/github/weichware10/analyse/ConfigHeatmap.java b/src/main/java/github/weichware10/analyse/ConfigHeatmap.java
new file mode 100644
index 0000000..32a7f88
--- /dev/null
+++ b/src/main/java/github/weichware10/analyse/ConfigHeatmap.java
@@ -0,0 +1,171 @@
+package github.weichware10.analyse;
+
+/**
+ * Speicherung der Konfiguration der Heatmap-Analysemethoden.
+ */
+public class ConfigHeatmap {
+ private float[] minColor;
+ private float[] maxColor;
+ private boolean grid;
+ private boolean image;
+ private float[] minDiff;
+ private float[] maxDiff;
+
+ /**
+ * Speicherung der Konfiguration der Heatmap-Analysemethoden.
+ */
+ public ConfigHeatmap() {
+ this.minColor = new float[] { 0, 0, 1 };
+ this.maxColor = new float[] { 1, 0, 0 };
+ this.grid = true;
+ this.image = true;
+ this.minDiff = new float[] { 1, 0, 1 };
+ this.maxDiff = new float[] { 1, 1, 0 };
+ }
+
+ /**
+ * setzt neue minimale Farbe.
+ *
+ * @param minColor - neue minimale Farbe
+ * @return
+ * true, falls neue minimale Farbe erfolgreich gesetzt wird;
+ * false, falls neue minimale Farbe nicht gesetzt wird
+ */
+ public boolean setMinColor(float[] minColor) {
+ if (minColor[0] > 1 || minColor[0] < 0 || minColor[1] > 1
+ || minColor[1] < 0 || minColor[2] > 1 || minColor[2] < 0) {
+ return false;
+ } else {
+ this.minColor = minColor;
+ return true;
+ }
+ }
+
+ /**
+ * gibt minimale Farbe zurück.
+ *
+ * @return minimale Farbe
+ */
+ public float[] getMinColor() {
+ return minColor;
+ }
+
+ /**
+ * setzt neue maximale Farbe.
+ *
+ * @param maxColor - neue maximale Farbe
+ * @return
+ * true, falls neue maximale Farbe erfolgreich gesetzt wird;
+ * false, falls neue maximale Farbe nicht gesetzt wird
+ */
+ public boolean setMaxColor(float[] maxColor) {
+ if (maxColor[0] > 1 || maxColor[0] < 0 || maxColor[1] > 1
+ || maxColor[1] < 0 || maxColor[2] > 1 || maxColor[2] < 0) {
+ return false;
+ } else {
+ this.maxColor = maxColor;
+ return true;
+ }
+ }
+
+ /**
+ * gibt maximale Farbe zurück.
+ *
+ * @return maximale Farbe
+ */
+ public float[] getMaxColor() {
+ return maxColor;
+ }
+
+ /**
+ * aktiviert bzw. deaktiviert die Anzeige des Rasters.
+ *
+ * @param grid - Anzeige Raster aktivieren bzw. deaktivieren
+ */
+ public void setGrid(boolean grid) {
+ this.grid = grid;
+ }
+
+ /**
+ * gibt zurück ob das Raster angezeigt wird.
+ *
+ * @return Wert von grid
+ */
+ public boolean isGrid() {
+ return grid;
+ }
+
+ /**
+ * aktiviert bzw. deaktiviert die Anzeige des Bildes.
+ *
+ * @param image - Anzeige Bild aktivieren bzw. deaktivieren
+ */
+ public void setImage(boolean image) {
+ this.image = image;
+ }
+
+ /**
+ * gibt zurück ob das Bild angezeigt wird.
+ *
+ * @return Wert von image
+ */
+ public boolean isImage() {
+ return image;
+ }
+
+ /**
+ * setzt neue minimale Farbe für Vergleich.
+ *
+ * @param minDiff - neue minimale Farbe für Vergleich
+ * @return
+ * true, falls neue minimale Farbe für Vergleich erfolgreich gesetzt
+ * wird;
+ * false, falls neue minimale Farbe für Vergleich nicht gesetzt wird
+ */
+ public boolean setMinDiff(float[] minDiff) {
+ if (minDiff[0] > 1 || minDiff[0] < 0 || minDiff[1] > 1
+ || minDiff[1] < 0 || minDiff[2] > 1 || minDiff[2] < 0) {
+ return false;
+ } else {
+ this.minDiff = minDiff;
+ return true;
+ }
+ }
+
+ /**
+ * gibt minimale Farbe für Vergleich zurück.
+ *
+ * @return minimale Farbe für Vergleich
+ */
+ public float[] getMinDiff() {
+ return minDiff;
+ }
+
+ /**
+ * setzt neue maximale Farbe für Vergleich.
+ *
+ * @param maxDiff - neue maximale Farbe für Vergleich
+ * @return
+ * true, falls neue maximale Farbe für Vergleich erfolgreich gesetzt
+ * wird;
+ * false, falls neue maximale Farbe für Vergleich nicht gesetzt wird
+ */
+ public boolean setMaxDiff(float[] maxDiff) {
+ if (maxDiff[0] > 1 || maxDiff[0] < 0 || maxDiff[1] > 1
+ || maxDiff[1] < 0 || maxDiff[2] > 1 || maxDiff[2] < 0) {
+ return false;
+ } else {
+ this.maxDiff = maxDiff;
+ return true;
+ }
+ }
+
+ /**
+ * gibt maximale Farbe für Vergleich zurück.
+ *
+ * @return maximale Farbe für Vergleich
+ */
+ public float[] getMaxDiff() {
+ return maxDiff;
+ }
+}
diff --git a/src/main/java/github/weichware10/analyse/DELETEME.txt b/src/main/java/github/weichware10/analyse/DELETEME.txt
deleted file mode 100644
index 0d5cd94..0000000
--- a/src/main/java/github/weichware10/analyse/DELETEME.txt
+++ /dev/null
@@ -1 +0,0 @@
-bitte löschen sobald andere Dateien erstellt wurden
diff --git a/src/main/java/github/weichware10/analyse/Diagramm.java b/src/main/java/github/weichware10/analyse/Diagramm.java
new file mode 100644
index 0000000..08c322f
--- /dev/null
+++ b/src/main/java/github/weichware10/analyse/Diagramm.java
@@ -0,0 +1,67 @@
+package github.weichware10.analyse;
+
+import github.weichware10.util.Data;
+import java.util.List;
+
+/**
+ * verantwortlich für die Erstellung der Diagramm-Diagramme.
+ */
+public class Diagramm extends Analyse {
+ private final Data data;
+ private final ConfigDiagramm confDia;
+
+ /**
+ * verantwortlich für die Erstellung der Diagramm-Diagramme.
+ *
+ * @param data - Daten die zur Erstellung der Diagramme benötigt werden
+ * @param confDia - Konfigurationen für die Diagrammarten
+ */
+ public Diagramm(Data data, ConfigDiagramm confDia) {
+ this.data = data;
+ this.confDia = confDia;
+ }
+
+ /**
+ * erstellt Diagramm, welches die relativen Häufigkeiten pro Bildbereich
+ * darstellt.
+ *
+ * @return Pfad des Bildes des erstellten Diagramms
+ */
+ public String createRelFreqImgArea() {
+ return drawDiagramm(null, DiagrammType.RELFRQIMGAREA);
+ }
+
+ /**
+ * erstellt Diagramm, welches die relativen Häufigkeiten der Blickedauer bzw.
+ * Zoomstärken darstellt.
+ *
+ * @return Pfad des Bildes des erstellten Diagramms
+ */
+ public String createViewTimeDistr() {
+ return drawDiagramm(null, DiagrammType.VIEWTIMEDISTR);
+ }
+
+ /**
+ * berechnet die relativen Häufigkeiten der Blickdauer bzw. Zoomstärken
+ *
+ * @param timeTableData - Tabelle mit Zeitpunkt und Bildkoordinate bzw.
+ * Zoomstärke
+ * @return Daten für die Erstellung des Diagramms
+ */
+ private List calcViewTimeDistr(List> timeTableData) {
+ return null;
+ }
+
+ /**
+ * zeichnet das Diagramm.
+ *
+ * @param diagrammData - Daten die zur Erstellung des Diagramms benötigt werden
+ * @param type - Diagramm-Typ des zu erstellenden Diagramms
+ * @return Pfad des Bildes des erstellten Diagramms
+ */
+ private String drawDiagramm(List diagrammData, DiagrammType type) {
+ return ".../diagramm/" + type + "_" + this.data.tooltype.toString()
+ + "_" + this.data.configId + ".jpg";
+ }
+
+}
diff --git a/src/main/java/github/weichware10/analyse/DiagrammType.java b/src/main/java/github/weichware10/analyse/DiagrammType.java
new file mode 100644
index 0000000..7b87266
--- /dev/null
+++ b/src/main/java/github/weichware10/analyse/DiagrammType.java
@@ -0,0 +1,9 @@
+package github.weichware10.analyse;
+
+/**
+ * Enum der möglichen Diagramm-Typen.
+ */
+public enum DiagrammType {
+ RELFRQIMGAREA,
+ VIEWTIMEDISTR
+}
diff --git a/src/main/java/github/weichware10/analyse/Heatmap.java b/src/main/java/github/weichware10/analyse/Heatmap.java
new file mode 100644
index 0000000..1a93f6d
--- /dev/null
+++ b/src/main/java/github/weichware10/analyse/Heatmap.java
@@ -0,0 +1,48 @@
+package github.weichware10.analyse;
+
+import github.weichware10.util.Data;
+import java.util.List;
+
+/**
+ * verantwortlich für die Erstellung der Heatmap.
+ */
+public class Heatmap extends Analyse {
+ private final Data data;
+ private final ConfigHeatmap confHm;
+ private List> heatmap;
+
+ /**
+ * verantwortlich für die Erstellung der Heatmap.
+ *
+ * @param data - Daten die zur Erstellung der Heatmaps benötigt werden
+ * @param confHm - Konfiguration der Heatmap
+ */
+ public Heatmap(Data data, ConfigHeatmap confHm) {
+ this.data = data;
+ this.confHm = confHm;
+ }
+
+ /**
+ * erstellt die Heatmap, welche die relativen Häufigkeiten der betrachteten
+ * Bildkoordinaten darstellt.
+ *
+ * @return Pfad des Bildes der erstellten Heatmap
+ */
+ public String createHeatmap() {
+ return ".../heatmap/HEATMAP_" + this.data.tooltype.toString()
+ + "_" + this.data.configId + ".jpg";
+ }
+
+ /**
+ * vergleicht zwei Heatmaps und erstellt aus dem Vergleich eine Heatmap.
+ *
+ * @param heatmap1 - erste Heatmap für den Vergleich
+ * @param heatmap2 - zweite Heatmap für den Vergleich
+ * @return Pfad des Bildes der erstellten Heatmap
+ */
+ public static String compHeatmaps(Heatmap heatmap1, Heatmap heatmap2) {
+ return ".../heatmap/COMPHEATMAP_" + heatmap1.data.tooltype.toString()
+ + "_" + heatmap1.data.configId + "_" + heatmap2.data.tooltype.toString()
+ + "_" + heatmap2.data.configId + ".jpg";
+ }
+}
diff --git a/src/main/java/github/weichware10/analyse/Verlauf.java b/src/main/java/github/weichware10/analyse/Verlauf.java
new file mode 100644
index 0000000..ea8005b
--- /dev/null
+++ b/src/main/java/github/weichware10/analyse/Verlauf.java
@@ -0,0 +1,42 @@
+package github.weichware10.analyse;
+
+import github.weichware10.util.Data;
+import java.util.List;
+
+/**
+ * verantwortlich für die Erstellung des Verlauf-Diagramms.
+ */
+public class Verlauf extends Analyse {
+ private final Data data;
+
+ /**
+ * verantwortlich für die Erstellung des Verlauf-Diagramms.
+ *
+ * @param data - Daten die zur Erstellung des Diagramms benötigt werden
+ */
+ public Verlauf(Data data) {
+ this.data = data;
+ }
+
+ /**
+ * erstellt Diagramm, welches den Verlauf der betrachteten Bildkoordinaten
+ * darstellt.
+ *
+ * @return Pfad des Bildes des erstellten Diagramms
+ */
+ public String createVerlauf() {
+ return drawDiagramm(null);
+ }
+
+ /**
+ * zeichnet das Diagramm.
+ *
+ * @param diagrammData - Daten die zur Erstellung des Diagramms benötigt werden
+ * @return Pfad des Bildes des erstellten Diagramms
+ */
+ private String drawDiagramm(List> diagrammData) {
+ return ".../verlauf/VERLAUF_" + this.data.tooltype.toString()
+ + "_" + this.data.configId + ".jpg";
+ }
+
+}
diff --git a/src/test/java/github/weichware10/analyse/ClientTest.java b/src/test/java/github/weichware10/analyse/ClientTest.java
new file mode 100644
index 0000000..a59d007
--- /dev/null
+++ b/src/test/java/github/weichware10/analyse/ClientTest.java
@@ -0,0 +1,186 @@
+package github.weichware10.analyse;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import github.weichware10.util.Enums.ToolType;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import org.joda.time.DateTime;
+import org.junit.Test;
+
+/**
+ * Unit Test für Klasse Client.
+ */
+public class ClientTest {
+
+ /**
+ * Testet, ob Analyse-Typen gesetzt werden.
+ */
+ @Test
+ public void analyseTypesShouldBeSet() {
+ // * Nichtleere Liste wird übergeben
+ Client client1 = new Client();
+ List list1 = new ArrayList(
+ Arrays.asList(AnalyseType.HEATPMAP));
+ assertTrue("setAnalyseTypes sollte True zurückgeben", client1.setAnalyseTypes(list1));
+ assertTrue("Vergleich sollte True zurückgeben", client1.getAnalyseTypes().equals(list1));
+ assertFalse("Test auf leere Liste sollte False sein", client1.getAnalyseTypes().isEmpty());
+
+ Client client2 = new Client();
+ List list2 = new ArrayList(
+ Arrays.asList(AnalyseType.VERLAUF));
+ assertTrue("setAnalyseTypes sollte True zurückgeben", client2.setAnalyseTypes(list2));
+ assertTrue("Vergleich sollte True zurückgeben", client2.getAnalyseTypes().equals(list2));
+ assertFalse("Test auf leere Liste sollte False sein", client2.getAnalyseTypes().isEmpty());
+
+ Client client3 = new Client();
+ List list3 = new ArrayList(
+ Arrays.asList(AnalyseType.RELFRQIMGAREA));
+ assertTrue("setAnalyseTypes sollte True zurückgeben", client3.setAnalyseTypes(list3));
+ assertTrue("Vergleich sollte True zurückgeben", client3.getAnalyseTypes().equals(list3));
+ assertFalse("Test auf leere Liste sollte False sein", client3.getAnalyseTypes().isEmpty());
+
+ assertFalse("Vergleich sollte False zurückgeben", client1.getAnalyseTypes().equals(list2));
+ assertFalse("Vergleich sollte False zurückgeben", client1.getAnalyseTypes().equals(list3));
+ assertFalse("Vergleich sollte False zurückgeben", client2.getAnalyseTypes().equals(list3));
+
+ // * Leere Liste wird übergeben
+ Client client4 = new Client();
+ assertFalse("setAnalyseTypes sollte False zurückgeben, da leere Liste",
+ client4.setAnalyseTypes(new ArrayList()));
+ }
+
+ /**
+ * Testet, ob Daten gesetzt werden.
+ */
+ @Test
+ public void dataShouldBeSet() {
+ // * Korrekte Zeiteingabe und Daten zu Tool-Typ vorhanden
+ Client client1 = new Client();
+ assertTrue("getData sollte True zurückgeben", client1.getData(
+ new DateTime(2021, 11, 28, 16, 0, 0),
+ new DateTime(2021, 11, 28, 19, 0, 0), ToolType.ZOOM));
+
+ Client client2 = new Client();
+ assertTrue("getData sollte True zurückgeben", client2.getData(
+ new DateTime(2021, 11, 28, 15, 0, 0),
+ new DateTime(2021, 11, 28, 18, 0, 0), ToolType.EYETRACKING));
+
+ Client client3 = new Client();
+ assertTrue("getData sollte True zurückgeben", client3.getData(
+ new DateTime(2021, 11, 28, 19, 0, 0),
+ new DateTime(2021, 11, 28, 20, 0, 0), ToolType.CODECHARTS));
+
+ // * Korrekte Zeiteingabe, aber Daten zu Tool-Typ nicht vorhanden
+ Client client4 = new Client();
+ assertFalse(client4.getData(new DateTime(2021, 11, 28, 15, 0, 0),
+ new DateTime(2021, 11, 28, 16, 0, 0), ToolType.ZOOM));
+
+ Client client5 = new Client();
+ assertFalse(client5.getData(new DateTime(2021, 11, 28, 15, 0, 0),
+ new DateTime(2021, 11, 28, 16, 0, 0), ToolType.EYETRACKING));
+
+ Client client6 = new Client();
+ assertFalse(client6.getData(new DateTime(2021, 11, 28, 15, 0, 0),
+ new DateTime(2021, 11, 28, 16, 0, 0), ToolType.CODECHARTS));
+
+ // * Falsche Zeiteingabe
+ Client client7 = new Client();
+ assertFalse("getData sollte False zurückgeben", client7.getData(
+ new DateTime(2021, 11, 28, 18, 0, 0),
+ new DateTime(2021, 11, 28, 17, 0, 0), ToolType.ZOOM));
+
+ Client client8 = new Client();
+ assertFalse("getData sollte False zurückgeben", client8.getData(
+ new DateTime(2021, 11, 28, 18, 0, 0),
+ new DateTime(2021, 11, 28, 17, 0, 0), ToolType.EYETRACKING));
+
+ Client client9 = new Client();
+ assertFalse("getData sollte False zurückgeben", client9.getData(
+ new DateTime(2021, 11, 28, 18, 0, 0),
+ new DateTime(2021, 11, 28, 17, 0, 0), ToolType.CODECHARTS));
+
+ // * Zeitpunkt in der Zunkunft
+ Client client10 = new Client();
+ assertFalse("getData sollte False zurückgeben", client10.getData(
+ new DateTime(2021, 11, 28, 18, 0, 0),
+ DateTime.now().plusMinutes(5), ToolType.ZOOM));
+
+ Client client11 = new Client();
+ assertFalse("getData sollte False zurückgeben", client11.getData(
+ DateTime.now().plusMinutes(5),
+ DateTime.now().plusMinutes(10), ToolType.EYETRACKING));
+ }
+
+ /**
+ * Testet, ob Daten gesetzt werden.
+ */
+ @Test
+ public void dataForCompShouldBeSet() {
+ // * Korrekte Zeiteingabe und Daten zu Tool-Typ vorhanden
+ Client client1 = new Client();
+ assertTrue("getDataForComp sollte True zurückgeben", client1.getDataForComp(
+ new DateTime(2021, 11, 28, 16, 0, 0),
+ new DateTime(2021, 11, 28, 19, 0, 0)));
+
+ Client client2 = new Client();
+ assertTrue("getDataForComp sollte True zurückgeben", client2.getDataForComp(
+ new DateTime(2021, 11, 28, 15, 0, 0),
+ new DateTime(2021, 11, 28, 18, 0, 0)));
+
+ Client client3 = new Client();
+ assertTrue("getDataForComp sollte True zurückgeben", client3.getDataForComp(
+ new DateTime(2021, 11, 28, 19, 0, 0),
+ new DateTime(2021, 11, 28, 20, 0, 0)));
+
+ // * Falsche Zeiteingabe
+ Client client7 = new Client();
+ assertFalse("getDataForComp sollte False zurückgeben", client7.getDataForComp(
+ new DateTime(2021, 11, 28, 18, 0, 0),
+ new DateTime(2021, 11, 28, 17, 0, 0)));
+
+ Client client8 = new Client();
+ assertFalse("getDataForComp sollte False zurückgeben", client8.getDataForComp(
+ new DateTime(2021, 11, 28, 18, 0, 0),
+ new DateTime(2021, 11, 28, 17, 0, 0)));
+
+ Client client9 = new Client();
+ assertFalse("getDataForComp sollte False zurückgeben", client9.getDataForComp(
+ new DateTime(2021, 11, 28, 18, 0, 0),
+ new DateTime(2021, 11, 28, 17, 0, 0)));
+
+ // * Zeitpunkt in der Zunkunft
+ Client client10 = new Client();
+ assertFalse("getDataForComp sollte False zurückgeben", client10.getDataForComp(
+ new DateTime(2021, 11, 28, 18, 0, 0),
+ DateTime.now().plusMinutes(5)));
+
+ Client client11 = new Client();
+ assertFalse("getDataForComp sollte False zurückgeben", client11.getDataForComp(
+ DateTime.now().plusMinutes(5),
+ DateTime.now().plusMinutes(10)));
+ }
+
+ // ? Woher kommen Daten für den Export?
+ /**
+ * Testet, ob Export der analysierten Daten funktioniert.
+ */
+ @Test
+ public void exportShouldWork() {
+ Client client1 = new Client();
+ assertTrue("export sollte True zurückgeben", client1.export());
+ }
+
+ // ? Woher kommen Daten für den Export?
+ /**
+ * Testet, ob Export der rohen Daten der Analyse funktioniert.
+ */
+ @Test
+ public void exportRawShouldWork() {
+ Client client1 = new Client();
+ assertTrue("exportRaw sollte True zurückgeben", client1.exportRaw());
+ }
+
+}
diff --git a/src/test/java/github/weichware10/analyse/ConfigDiagrammTest.java b/src/test/java/github/weichware10/analyse/ConfigDiagrammTest.java
new file mode 100644
index 0000000..009cd31
--- /dev/null
+++ b/src/test/java/github/weichware10/analyse/ConfigDiagrammTest.java
@@ -0,0 +1,111 @@
+package github.weichware10.analyse;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+/**
+ * Unit Test für Klasse ConfigDiagramm.
+ */
+public class ConfigDiagrammTest {
+ /**
+ * Testet, ob Anzahl Felder gesetzt wird.
+ */
+ @Test
+ public void amountAreasShouldBeSet() {
+ ConfigDiagramm confDia1 = new ConfigDiagramm();
+ assertEquals("getAmountAreas sollte 4 sein", 4, confDia1.getAmountAreas());
+
+ ConfigDiagramm confDia2 = new ConfigDiagramm();
+ assertTrue("setAmountAreas sollte True zurückgeben", confDia2.setAmountAreas(6));
+
+ ConfigDiagramm confDia3 = new ConfigDiagramm();
+ confDia3.setAmountAreas(2);
+ assertEquals("getAmountAreas sollte 2 sein", 2, confDia3.getAmountAreas());
+
+ ConfigDiagramm confDia4 = new ConfigDiagramm();
+ assertFalse("setAmountAreas sollte False zurückgeben", confDia4.setAmountAreas(10));
+
+ ConfigDiagramm confDia5 = new ConfigDiagramm();
+ assertFalse("setAmountAreas sollte False zurückgeben", confDia5.setAmountAreas(-2));
+ }
+
+ /**
+ * Testet, ob minimale Zeit gesetzt wird.
+ */
+ @Test
+ public void minTimeShouldBeSet() {
+ ConfigDiagramm confDia1 = new ConfigDiagramm();
+ assertEquals("getMinTime sollte 0.5 zurückgeben", 0.5f, confDia1.getMinTime(), 0.00001f);
+
+ ConfigDiagramm confDia2 = new ConfigDiagramm();
+ assertTrue("setNewTime sollte True zurückgeben", confDia2.setNewTime(1.0f, 2.5f));
+
+ ConfigDiagramm confDia3 = new ConfigDiagramm();
+ confDia3.setNewTime(2.0f, 2.5f);
+ assertEquals("getMinTime sollte 2.0 zurückgeben", 2.0f, confDia3.getMinTime(), 0.00001f);
+
+ ConfigDiagramm confDia4 = new ConfigDiagramm();
+ assertFalse("setNewTime sollte False zurückgeben", confDia4.setNewTime(3.0f, 2.5f));
+
+ ConfigDiagramm confDia5 = new ConfigDiagramm();
+ assertFalse("setNewTime sollte False zurückgeben", confDia5.setNewTime(-1.0f, 2.5f));
+ }
+
+ /**
+ * Testet, ob maximale Zeit gesetzt wird.
+ */
+ @Test
+ public void maxTimeShouldBeSet() {
+ ConfigDiagramm confDia1 = new ConfigDiagramm();
+ assertEquals("getMaxTime sollte 2.5 zurückgeben", 2.5f, confDia1.getMaxTime(), 0.00001f);
+
+ ConfigDiagramm confDia2 = new ConfigDiagramm();
+ assertTrue("setNewTime sollte True zurückgeben", confDia2.setNewTime(0.5f, 3.0f));
+
+ ConfigDiagramm confDia3 = new ConfigDiagramm();
+ confDia3.setNewTime(0.5f, 1.0f);
+ assertEquals("getMaxTime sollte 1.0 zurückgeben", 1.0f, confDia3.getMaxTime(), 0.00001f);
+
+ ConfigDiagramm confDia4 = new ConfigDiagramm();
+ assertFalse("setNewTime sollte False zurückgeben", confDia4.setNewTime(0.5f, 0.2f));
+
+ ConfigDiagramm confDia5 = new ConfigDiagramm();
+ assertFalse("setNewTime sollte False zurückgeben", confDia5.setNewTime(0.5f, 12.5f));
+ }
+
+ /**
+ * Testet, ob Zwischenschritte gesetzt werden.
+ */
+ @Test
+ public void stepsBetweenShouldBeSet() {
+ ConfigDiagramm confDia1 = new ConfigDiagramm();
+ assertEquals("getStepsBetween sollte 4 zurückgeben", 4, confDia1.getStepsBetween());
+
+ ConfigDiagramm confDia2 = new ConfigDiagramm();
+ assertTrue("setStepsBetween sollte True zurückgeben", confDia2.setStepsBetween(8));
+
+ ConfigDiagramm confDia3 = new ConfigDiagramm();
+ confDia3.setStepsBetween(1);
+ assertEquals("getStepsBetween sollte 1 zurückgeben", 1, confDia3.getStepsBetween());
+
+ ConfigDiagramm confDia4 = new ConfigDiagramm();
+ assertFalse("setStepsBetween sollte False zurückgeben", confDia4.setStepsBetween(12));
+
+ ConfigDiagramm confDia5 = new ConfigDiagramm();
+ assertFalse("setStepsBetween sollte False zurückgeben", confDia5.setStepsBetween(-2));
+
+ ConfigDiagramm confDia6 = new ConfigDiagramm();
+ confDia6.setNewTime(3.0f, 3.0f);
+ confDia6.setStepsBetween(5);
+ assertEquals("getStepsBetween sollte 0 zurückgeben", 0, confDia6.getStepsBetween());
+
+ ConfigDiagramm confDia7 = new ConfigDiagramm();
+ confDia7.setStepsBetween(10);
+ confDia7.setNewTime(3.0f, 3.0f);
+ assertEquals("getStepsBetween sollte 0 zurückgeben", 0, confDia7.getStepsBetween());
+ }
+
+}
diff --git a/src/test/java/github/weichware10/analyse/ConfigHeatmapTest.java b/src/test/java/github/weichware10/analyse/ConfigHeatmapTest.java
new file mode 100644
index 0000000..dbcaf3a
--- /dev/null
+++ b/src/test/java/github/weichware10/analyse/ConfigHeatmapTest.java
@@ -0,0 +1,192 @@
+package github.weichware10.analyse;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+/**
+ * Unit Test für Klasse ConfigHeatmap.
+ */
+public class ConfigHeatmapTest {
+ /**
+ * Testet, ob minimale Farbe gesetzt wird.
+ */
+ @Test
+ public void minColorShouldBeSet() {
+ ConfigHeatmap confHm1 = new ConfigHeatmap();
+ // assertEquals(new float[] { 1, 0, 0 }, confHm1.getMinColor());
+ assertEquals("getMinColor[0] sollte 0 zurückgeben", 0, confHm1.getMinColor()[0], 0.0001f);
+ assertEquals("getMinColor[1] sollte 0 zurückgeben", 0, confHm1.getMinColor()[1], 0.0001f);
+ assertEquals("getMinColor[2] sollte 1 zurückgeben", 1, confHm1.getMinColor()[2], 0.0001f);
+
+ ConfigHeatmap confHm2 = new ConfigHeatmap();
+ assertTrue("setMinColor sollte True zurückgeben",
+ confHm2.setMinColor(new float[] { 0, 1, 0.5f }));
+
+ ConfigHeatmap confHm3 = new ConfigHeatmap();
+ confHm3.setMinColor(new float[] { 0.25f, 0.1f, 1 });
+ assertEquals("getMinColor[0] sollte 0.25 zurückgeben",
+ 0.25f, confHm3.getMinColor()[0], 0.0001f);
+ assertEquals("getMinColor[1] sollte 0.1 zurückgeben",
+ 0.1f, confHm3.getMinColor()[1], 0.0001f);
+ assertEquals("getMinColor[2] sollte 1 zurückgeben",
+ 1, confHm3.getMinColor()[2], 0.0001f);
+
+ ConfigHeatmap confHm4 = new ConfigHeatmap();
+ assertFalse("setMinColor sollte False zurückgeben",
+ confHm4.setMinColor(new float[] { -1, 0, 1 }));
+
+ ConfigHeatmap confHm5 = new ConfigHeatmap();
+ assertFalse("setMinColor sollte False zurückgeben",
+ confHm5.setMinColor(new float[] { 0.5f, 1.3f, 1 }));
+
+ ConfigHeatmap confHm6 = new ConfigHeatmap();
+ assertFalse("setMinColor sollte False zurückgeben",
+ confHm6.setMinColor(new float[] { 0.5f, 1.3f, -1 }));
+ }
+
+ /**
+ * Testet, ob maximale Farbe gesetzt wird.
+ */
+ @Test
+ public void maxColorShouldBeSet() {
+ ConfigHeatmap confHm1 = new ConfigHeatmap();
+ assertEquals("getMaxColor[0] sollte 1 zurückgeben", 1, confHm1.getMaxColor()[0], 0.0001f);
+ assertEquals("getMaxColor[1] sollte 0 zurückgeben", 0, confHm1.getMaxColor()[1], 0.0001f);
+ assertEquals("getMaxColor[2] sollte 0 zurückgeben", 0, confHm1.getMaxColor()[2], 0.0001f);
+
+ ConfigHeatmap confHm2 = new ConfigHeatmap();
+ assertTrue("setMaxColor sollte True zurückgeben",
+ confHm2.setMaxColor(new float[] { 0.6f, 0.15f, 1.0f }));
+
+ ConfigHeatmap confHm3 = new ConfigHeatmap();
+ confHm3.setMaxColor(new float[] { 0.1f, 1.0f, 0.45f });
+ assertEquals("getMaxColor[0] sollte 0.1 zurückgeben",
+ 0.1f, confHm3.getMaxColor()[0], 0.0001f);
+ assertEquals("getMaxColor[1] sollte 1.0 zurückgeben",
+ 1.0f, confHm3.getMaxColor()[1], 0.0001f);
+ assertEquals("getMaxColor[2] sollte 0.45 zurückgeben",
+ 0.45f, confHm3.getMaxColor()[2], 0.0001f);
+
+ ConfigHeatmap confHm4 = new ConfigHeatmap();
+ assertFalse("setMaxColor sollte False zurückgeben",
+ confHm4.setMaxColor(new float[] { 0.2f, -0.85f, 0.0f }));
+
+ ConfigHeatmap confHm5 = new ConfigHeatmap();
+ assertFalse("setMaxColor sollte False zurückgeben",
+ confHm5.setMaxColor(new float[] { 0.2f, 0.16f, 3.0f }));
+
+ ConfigHeatmap confHm6 = new ConfigHeatmap();
+ assertFalse("setMaxColor sollte False zurückgeben",
+ confHm6.setMaxColor(new float[] { 1.2f, 0.16f, -3.0f }));
+ }
+
+ /**
+ * Testet, ob Raster aktiviert oder deaktiviert wird.
+ */
+ @Test
+ public void gridShouldBeSet() {
+ ConfigHeatmap confHm1 = new ConfigHeatmap();
+ assertTrue("isGrid sollte true zurückgeben", confHm1.isGrid());
+
+ ConfigHeatmap confHm2 = new ConfigHeatmap();
+ confHm2.setGrid(false);
+ assertFalse("isGrid sollte false zurückgeben", confHm2.isGrid());
+
+ ConfigHeatmap confHm3 = new ConfigHeatmap();
+ confHm3.setGrid(true);
+ assertTrue("isGrid sollte true zurückgeben", confHm3.isGrid());
+ }
+
+ /**
+ * Testet, ob Bild aktiviert oder deaktiviert wird.
+ */
+ @Test
+ public void imageShouldBeSet() {
+ ConfigHeatmap confHm1 = new ConfigHeatmap();
+ assertTrue("isImage sollte true zurückgeben", confHm1.isImage());
+
+ ConfigHeatmap confHm2 = new ConfigHeatmap();
+ confHm2.setImage(false);
+ assertFalse("isImage sollte false zurückgeben", confHm2.isImage());
+
+ ConfigHeatmap confHm3 = new ConfigHeatmap();
+ confHm3.setImage(true);
+ assertTrue("isImage sollte true zurückgeben", confHm3.isImage());
+ }
+
+ /**
+ * Testet, ob minimale Farbe für Vergleich gesetzt wird.
+ */
+ @Test
+ public void minDiffShouldBeSet() {
+ ConfigHeatmap confHm1 = new ConfigHeatmap();
+ assertEquals("getMinDiff[0] sollte 1 zurückgeben", 1, confHm1.getMinDiff()[0], 0.0001f);
+ assertEquals("getMinDiff[1] sollte 0 zurückgeben", 0, confHm1.getMinDiff()[1], 0.0001f);
+ assertEquals("getMinDiff[2] sollte 1 zurückgeben", 1, confHm1.getMinDiff()[2], 0.0001f);
+
+ ConfigHeatmap confHm2 = new ConfigHeatmap();
+ assertTrue("setMinDiff sollte True zurückgeben",
+ confHm2.setMinDiff(new float[] { 0.5f, 0.3f, 1.0f }));
+
+ ConfigHeatmap confHm3 = new ConfigHeatmap();
+ confHm3.setMinDiff(new float[] { 0.75f, 0.2f, 0.5f });
+ assertEquals("getMinDiff[0] sollte 0.75 zurückgeben",
+ 0.75f, confHm3.getMinDiff()[0], 0.0001f);
+ assertEquals("getMinDiff[1] sollte 0.2 zurückgeben",
+ 0.2f, confHm3.getMinDiff()[1], 0.0001f);
+ assertEquals("getMinDiff[2] sollte 0.5 zurückgeben",
+ 0.5f, confHm3.getMinDiff()[2], 0.0001f);
+
+ ConfigHeatmap confHm4 = new ConfigHeatmap();
+ assertFalse("setMinDiff sollte False zurückgeben",
+ confHm4.setMinDiff(new float[] { -1, 0, 1 }));
+
+ ConfigHeatmap confHm5 = new ConfigHeatmap();
+ assertFalse("setMinDiff sollte False zurückgeben",
+ confHm5.setMinDiff(new float[] { 0.5f, 1.3f, 1 }));
+
+ ConfigHeatmap confHm6 = new ConfigHeatmap();
+ assertFalse("setMinDiff sollte False zurückgeben",
+ confHm6.setMinDiff(new float[] { 0.5f, 1.3f, -1 }));
+ }
+
+ /**
+ * Testet, ob maximale Farbe für Vergleich gesetzt wird.
+ */
+ @Test
+ public void maxDiffShouldBeSet() {
+ ConfigHeatmap confHm1 = new ConfigHeatmap();
+ assertEquals("getMaxDiff[0] sollte 1 zurückgeben", 1, confHm1.getMaxDiff()[0], 0.0001f);
+ assertEquals("getMaxDiff[1] sollte 1 zurückgeben", 1, confHm1.getMaxDiff()[1], 0.0001f);
+ assertEquals("getMaxDiff[2] sollte 0 zurückgeben", 0, confHm1.getMaxDiff()[2], 0.0001f);
+
+ ConfigHeatmap confHm2 = new ConfigHeatmap();
+ assertTrue("setMaxDiff sollte True zurückgeben",
+ confHm2.setMaxDiff(new float[] { 0.0f, 0.65f, 0.2f }));
+
+ ConfigHeatmap confHm3 = new ConfigHeatmap();
+ confHm3.setMaxDiff(new float[] { 0.2f, 1.0f, 0.5f });
+ assertEquals("getMaxDiff[0] sollte 0.2 zurückgeben",
+ 0.2f, confHm3.getMaxDiff()[0], 0.0001f);
+ assertEquals("getMaxDiff[1] sollte 1 zurückgeben",
+ 1.0f, confHm3.getMaxDiff()[1], 0.0001f);
+ assertEquals("getMaxDiff[2] sollte 0.5 zurückgeben",
+ 0.5f, confHm3.getMaxDiff()[2], 0.0001f);
+
+ ConfigHeatmap confHm4 = new ConfigHeatmap();
+ assertFalse("setMaxDiff sollte False zurückgeben",
+ confHm4.setMaxDiff(new float[] { -1, 0, 1 }));
+
+ ConfigHeatmap confHm5 = new ConfigHeatmap();
+ assertFalse("setMaxDiff sollte False zurückgeben",
+ confHm5.setMaxDiff(new float[] { 0.5f, 1.3f, 1 }));
+
+ ConfigHeatmap confHm6 = new ConfigHeatmap();
+ assertFalse("setMaxDiff sollte False zurückgeben",
+ confHm6.setMaxDiff(new float[] { 0.5f, 1.3f, -1 }));
+ }
+
+}
diff --git a/src/test/java/github/weichware10/analyse/DELETEME.txt b/src/test/java/github/weichware10/analyse/DELETEME.txt
deleted file mode 100644
index 0d5cd94..0000000
--- a/src/test/java/github/weichware10/analyse/DELETEME.txt
+++ /dev/null
@@ -1 +0,0 @@
-bitte löschen sobald andere Dateien erstellt wurden
diff --git a/src/test/java/github/weichware10/analyse/DiagrammTest.java b/src/test/java/github/weichware10/analyse/DiagrammTest.java
new file mode 100644
index 0000000..ac2ca17
--- /dev/null
+++ b/src/test/java/github/weichware10/analyse/DiagrammTest.java
@@ -0,0 +1,59 @@
+package github.weichware10.analyse;
+
+import static org.junit.Assert.assertEquals;
+
+import github.weichware10.util.Data;
+import github.weichware10.util.Enums.ToolType;
+import org.junit.Test;
+
+/**
+ * Unit Test für Klasse Diagramm.
+ */
+public class DiagrammTest {
+ /**
+ * Testet, ob String erstellt und ausgegeben wird.
+ */
+ @Test
+ public void createRelFreqImgAreaShouldWork() {
+ Diagramm dia1 = new Diagramm(new Data(ToolType.ZOOM, 1), new ConfigDiagramm());
+ assertEquals(
+ "createRelFreqImgAre sollte .../diagramm/RELFRQIMGAREA_ZOOM_1 zurückgeben",
+ ".../diagramm/RELFRQIMGAREA_ZOOM_1.jpg",
+ dia1.createRelFreqImgArea());
+
+ Diagramm dia2 = new Diagramm(new Data(ToolType.EYETRACKING, 5), new ConfigDiagramm());
+ assertEquals(
+ "createRelFreqImgAre sollte .../diagramm/RELFRQIMGAREA_EYETRACKING_5 zurückgeben",
+ ".../diagramm/RELFRQIMGAREA_EYETRACKING_5.jpg",
+ dia2.createRelFreqImgArea());
+
+ Diagramm dia3 = new Diagramm(new Data(ToolType.CODECHARTS, 132), new ConfigDiagramm());
+ assertEquals(
+ "createRelFreqImgAre sollte .../diagramm/RELFRQIMGAREA_CODECHARTS_132 zurückgeben",
+ ".../diagramm/RELFRQIMGAREA_CODECHARTS_132.jpg",
+ dia3.createRelFreqImgArea());
+ }
+
+ /**
+ * Testet, ob String erstellt und ausgegeben wird.
+ */
+ @Test
+ public void createViewTimeDistrSouldWork() {
+ Diagramm dia1 = new Diagramm(new Data(ToolType.ZOOM, 1), new ConfigDiagramm());
+ assertEquals("createViewTimeDistr sollte .../diagramm/VIEWTIMEDISTR_ZOOM_1 zurückgeben",
+ ".../diagramm/VIEWTIMEDISTR_ZOOM_1.jpg",
+ dia1.createViewTimeDistr());
+
+ Diagramm dia2 = new Diagramm(new Data(ToolType.EYETRACKING, 5), new ConfigDiagramm());
+ assertEquals(
+ "createViewTimeDistr sollte .../diagramm/VIEWTIMEDISTR_EYETRACKING_5 zurückgeben",
+ ".../diagramm/VIEWTIMEDISTR_EYETRACKING_5.jpg",
+ dia2.createViewTimeDistr());
+
+ Diagramm dia3 = new Diagramm(new Data(ToolType.CODECHARTS, 132), new ConfigDiagramm());
+ assertEquals(
+ "createViewTimeDistr sollte .../diagramm/VIEWTIMEDISTR_CODECHARTS_132 zurückgeben",
+ ".../diagramm/VIEWTIMEDISTR_CODECHARTS_132.jpg",
+ dia3.createViewTimeDistr());
+ }
+}
diff --git a/src/test/java/github/weichware10/analyse/HeatmapTest.java b/src/test/java/github/weichware10/analyse/HeatmapTest.java
new file mode 100644
index 0000000..d968f75
--- /dev/null
+++ b/src/test/java/github/weichware10/analyse/HeatmapTest.java
@@ -0,0 +1,57 @@
+package github.weichware10.analyse;
+
+import static org.junit.Assert.assertEquals;
+
+import github.weichware10.util.Data;
+import github.weichware10.util.Enums.ToolType;
+import org.junit.Test;
+
+/**
+ * Unit Test für Klasse Heatmap.
+ */
+public class HeatmapTest {
+ /**
+ * Teset, ob String erstellt und ausgegeben wird.
+ */
+ @Test
+ public void createHeatmapShouldWork() {
+ Heatmap hm1 = new Heatmap(new Data(ToolType.ZOOM, 1), new ConfigHeatmap());
+ assertEquals("createHeatMap sollte .../heatmap/HEATMAP_ZOOM_1.jpg ausgeben",
+ ".../heatmap/HEATMAP_ZOOM_1.jpg", hm1.createHeatmap());
+
+ Heatmap hm2 = new Heatmap(new Data(ToolType.EYETRACKING, 7), new ConfigHeatmap());
+ assertEquals("createHeatMap sollte .../heatmap/HEATMAP_EYETRACKING_7.jpg ausgeben",
+ ".../heatmap/HEATMAP_EYETRACKING_7.jpg", hm2.createHeatmap());
+
+ Heatmap hm3 = new Heatmap(new Data(ToolType.CODECHARTS, 3), new ConfigHeatmap());
+ assertEquals("createHeatMap sollte .../heatmap/HEATMAP_CODECHARTS_3.jpg ausgeben",
+ ".../heatmap/HEATMAP_CODECHARTS_3.jpg", hm3.createHeatmap());
+ }
+
+ /**
+ * Testet, ob String erstellt und ausgegeben wird.
+ */
+ @Test
+ public void compHeatmapsShouldWork() {
+ Heatmap hm1 = new Heatmap(new Data(ToolType.CODECHARTS, 4), new ConfigHeatmap());
+ Heatmap hm2 = new Heatmap(new Data(ToolType.EYETRACKING, 2), new ConfigHeatmap());
+ assertEquals(
+ "compHeatmaps sollte .../heatmap/COMPHEATMAP_CODECHARTS_1_EYETRACKING_2.jpg ausgeb",
+ ".../heatmap/COMPHEATMAP_CODECHARTS_4_EYETRACKING_2.jpg",
+ Heatmap.compHeatmaps(hm1, hm2));
+
+ Heatmap hm3 = new Heatmap(new Data(ToolType.ZOOM, 1), new ConfigHeatmap());
+ Heatmap hm4 = new Heatmap(new Data(ToolType.CODECHARTS, 6), new ConfigHeatmap());
+ assertEquals(
+ "compHeatmaps sollte .../heatmap/COMPHEATMAP_ZOOM_1_CODECHARTS_6.jpg ausgeben",
+ ".../heatmap/COMPHEATMAP_ZOOM_1_CODECHARTS_6.jpg",
+ Heatmap.compHeatmaps(hm3, hm4));
+
+ Heatmap hm5 = new Heatmap(new Data(ToolType.EYETRACKING, 8), new ConfigHeatmap());
+ Heatmap hm6 = new Heatmap(new Data(ToolType.ZOOM, 12), new ConfigHeatmap());
+ assertEquals(
+ "compHeatmaps sollte .../heatmap/COMPHEATMAP_EYETRACKING_8_ZOOM_12.jpg ausgeben",
+ ".../heatmap/COMPHEATMAP_EYETRACKING_8_ZOOM_12.jpg",
+ Heatmap.compHeatmaps(hm5, hm6));
+ }
+}
diff --git a/src/test/java/github/weichware10/analyse/VerlaufTest.java b/src/test/java/github/weichware10/analyse/VerlaufTest.java
new file mode 100644
index 0000000..34edc3f
--- /dev/null
+++ b/src/test/java/github/weichware10/analyse/VerlaufTest.java
@@ -0,0 +1,32 @@
+package github.weichware10.analyse;
+
+import static org.junit.Assert.assertEquals;
+
+import github.weichware10.util.Data;
+import github.weichware10.util.Enums.ToolType;
+import org.junit.Test;
+
+/**
+ * Unit Test für Klasse Verlauf.
+ */
+public class VerlaufTest {
+ /**
+ * Testet, ob String erstellt und ausgegeben wird.
+ */
+ @Test
+ public void createVerlaufShouldWork() {
+ Verlauf verlauf1 = new Verlauf(new Data(ToolType.ZOOM, 1));
+ assertEquals("createVerlauf sollte .../verlauf/VERLAUF_ZOOM_1.jpg ausgeben",
+ ".../verlauf/VERLAUF_ZOOM_1.jpg", verlauf1.createVerlauf());
+
+ Verlauf verlauf2 = new Verlauf(new Data(ToolType.EYETRACKING, 6));
+ assertEquals("createVerlauf sollte .../verlauf/VERLAUF_EYETRACKING_6.jpg ausgeben",
+ ".../verlauf/VERLAUF_EYETRACKING_6.jpg",
+ verlauf2.createVerlauf());
+
+ Verlauf verlauf3 = new Verlauf(new Data(ToolType.CODECHARTS, 20));
+ assertEquals("createVerlauf sollte .../verlauf/VERLAUF_CODECHARTS_20.jpg ausgeben",
+ ".../verlauf/VERLAUF_CODECHARTS_20.jpg",
+ verlauf3.createVerlauf());
+ }
+}