Feedback Ruiz

Dear Angry Nerds Team. 

Here you are the feedback for your project. BTW: Very good your application offer English and German language!

README.md

@@ -1 +1,70 @@
-# team02-AngryNerds-projekt2-turnierverwaltung
+# team02-AngryNerds-projekt2-turnierverwaltung
+
+## Tournament administration
+### Documentation
+
+> Our Tournament Administration Tool is available in german and english,
+> to change the language click on start in the top left corner and then select your 
+> desired language under 'Sprache' or 'Language' (documentation is only provided in english).
+
+Once you start the Programm you will be presented with the possibility to either create a new tournament or load one if one has already been saved.
+
+>To create a new tournament simply type in the name of it and press create
+
+>To load a tournament select the tournament on the list and click open
+
+>You can also delete a tournament by selecting it and then clicking delete
+
+Once a tournament has been created you will be sent to the tournament screen.
+Your next step should be adding a place or players you can do so vie Edit Participants or Edit Locations.
+
+Once you have enough Players(min 4 and only number that are 2^n e.g. 4, 8, 16...), you can click the Create game schedule button and the schedule will be created
+
+you can then input the location where a game takes place and as well the points a team scored
+the winning team will then automatically advance in the tree.
+
+The Programm automatically saves, so no worries you won't lose your progress.
+
+# Startup and Testing
+To Start the Programm use the command
+>./gradlew run
+
+To run the tests use the command
+>./gradlew test
+
+# Branching Model
+We used a simple branching model, for each new functionality or working step a new branch would be created, once a segment was finished the branch would then be reviewed by peers and be pushed into the main branch via a pull request, no direct work is usually done in the main branch. 
+
+# Class Diagramm
+Our class Diagramm can be found [here](https://github.zhaw.ch/PM2-IT21bWIN-ruiz-mach-krea/team02-AngryNerds-projekt2-turnierverwaltung/blob/main/ClassDiagram.png)
+# Architecture
+
+Our Model View Pattern has been set, so  that the class Tournament acts as the Model.
+Each View has its own unique controller assigned
+For Comprehensive Reasons all Controller Classes inherit from the abstract super class FX Controller.
+
+The Class Tournament decorator has the purpose of communication of the controller classes with the Model of the tournament, the same Decorator also communicates with the FileIO and inherits the task of saving or importing save files into the program.
+
+The Class Tournament Decorator always stores the Tournament that is opened in a data field.
+The Factory and its associated Factory Decorators are responsible to load all the views if application is started. And to switch between the views while using the application.
+
+The Factory decorator is placed between the controllers and the factory to enable the communication.
+
+The Model tournament saves a List of all participants, all places and all games. Participants are implemented as an interface, since we want to be able to save a team or a single player as participant (in the prototype it is not possible to create a team).
+
+To refresh the view of the tournament tree, each game has its own game decorator with a list of listeners.
+
+To realize the tree there are listeners placed in the game decorators of the previous round to gather the winner and calculate the new participants of a game. Listeners are only placed 
+
+Loggers are implemented in all relevant classes
+Each class creates its own logger a root logger is created in the LogConfiguration class and two Handlers are specified for use, one File Handler and one Console Handler.
+The setting of those handlers can be set in the file log.properties.
+
+We choose this architecture since it gives us the advantage to add more views without having any more code duplication.
+We also think it is an advantage that the saving automatically takes place and the user does not have to take into consideration to save from time to time.
+It also closely resembles what we learned already in lectures we had previously, so we were able to implement it accordingly.
+
+# Notable Pullrequests
+[Number 1](https://github.zhaw.ch/PM2-IT21bWIN-ruiz-mach-krea/team02-AngryNerds-projekt2-turnierverwaltung/pull/22)
+[Number 2](https://github.zhaw.ch/PM2-IT21bWIN-ruiz-mach-krea/team02-AngryNerds-projekt2-turnierverwaltung/pull/20)
+

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/App.java

@@ -11,9 +11,11 @@ import java.io.IOException;
 public class App {
     public static void main(String[] args) {
         try {
-            new LogConfiguration(System.getProperty("user.dir") + System.getProperty("file.separator") + "tournierverwaltung_angrynerds",
-                    "ch" + System.getProperty("file.separator") + "zhaw" + System.getProperty("file.separator") + "projekt2" + System.getProperty("file.separator") +
-                    "turnierverwaltung" + System.getProperty("file.separator") + "logging" + System.getProperty("file.separator") + "log.properties");
+            new LogConfiguration(System.getProperty("user.dir") + System.getProperty("file.separator") +
+                    "tournierverwaltung_angrynerds", "ch" + System.getProperty("file.separator") + "zhaw" +
+                    System.getProperty("file.separator") + "projekt2" + System.getProperty("file.separator") +
+                    "turnierverwaltung" + System.getProperty("file.separator") + "logging" +
+                    System.getProperty("file.separator") + "log.properties");
         } catch (IOException e) {
             throw new RuntimeException(e);
         }

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/Factory.java

@@ -8,28 +8,42 @@ import javafx.scene.control.Label;
 import javafx.scene.layout.*;
 import javafx.scene.paint.Color;
 import javafx.scene.text.Font;
-
 import java.io.IOException;
+import java.util.logging.Logger;
 
+/**
+ * Class to load the views from FXML Files and switch between the views.
+ */
 public class Factory {
     private TournamentDecorator tournamentDecorator;
     private FileIO fileIO;
     private static LanguageConfigurator languageConfigurator;
 
+    private static final Logger logger = Logger.getLogger(Factory.class.getCanonicalName());
+
+    /**
+     * Contructor to create Factory instance.
+     * @param fileIO the fileIO instance which saves and reads the tournament from files.
+     * @param tournamentDecorator the touramanetDecorator class to access the tournament.
+     */
     public Factory(FileIO fileIO, TournamentDecorator tournamentDecorator, LanguageConfigurator languageConfigurator) {
         this.fileIO = fileIO;
         this.tournamentDecorator = tournamentDecorator;
         this.languageConfigurator = languageConfigurator;
     }
 
-    public TournamentDecorator getTournamentDecorator() {
-        return tournamentDecorator;
-    }
-
+    /**
+     * Setter Method of tournament
+     * @param tournament the new tournament Object.
+     */
     public void setTournament(Tournament tournament) {
         this.tournamentDecorator.setTournament(tournament);
     }
 
+    /**
+     * Method to load the main Window (without the content in the center)
+     * @return the boarder Pane which is loaded.
+     */
     public BorderPane loadMainWindow() {
         FXMLLoader loader = new FXMLLoader(getClass().getResource("MainWindow.fxml"));
         try {
@@ -38,64 +52,106 @@ public class Factory {
             controller.setup(languageConfigurator);
             return pane;
         } catch (IOException e) {
+            logger.warning("Fatal error program can not continue after this: " + e );
             e.printStackTrace();
-            //TODO handle and logging
         }
         return null;
     }
 
+    /**
+     * Class which loads all views of Enum View
+     * @param factoryDecorator the FactoryDecorator which is used to setup the controller.
+     * @param pane the pane where the loaded view will be visible
+     */
     public void loadAllViews(FactoryDecorator factoryDecorator, BorderPane pane){
         for(View view : View.values()){
             try {
                 view.loadView(tournamentDecorator, fileIO, factoryDecorator, pane);
             } catch (IOException e) {
                 e.printStackTrace();
-                //TODO Handle and logging.
+                logger.warning("failed to load views.");
             }
         }
     }
 
-    public void showTournamentList(BorderPane pane, FactoryDecorator factoryDecorator) {
+    /**
+     * Method to show the view TournamentList
+     * @param pane the Pane where the View will be visible
+     */
+    public void showTournamentList(BorderPane pane) {
         tournamentDecorator.setTournament(null);
         setCenterOfBorderPane(pane, View.tournamentList);
+        logger.fine("showing Tournament List");
     }
 
-    //Can be used to Open new Scene in same Stage.
-    //This way possible to later give object to Controller
-    public void showParticipantFormular(BorderPane pane, FactoryDecorator factoryDecorator) {
+    /**
+     * Method to show the view ParticipantFormular
+     * @param pane the Pane where the View will be visible
+     */
+    public void showParticipantFormular(BorderPane pane) {
         setCenterOfBorderPane(pane, View.participantFormular);
+        logger.fine("showing Participant Formular");
     }
 
-    public void showPlacesFormular(BorderPane pane, FactoryDecorator factoryDecorator) {
+    /**
+     * Method to show the view PlacesFormular
+     * @param pane the Pane where the View will be visible
+     */
+    public void showPlacesFormular(BorderPane pane) {
         setCenterOfBorderPane(pane, View.placesFormular);
+        logger.fine("showing Places Formular");
     }
 
-    public void showGameScheduler(BorderPane pane, FactoryDecorator factoryDecorator) {
+    /**
+     * Method to show the view GameScheduler
+     * @param pane the Pane where the View will be visible
+     */
+    public void showGameScheduler(BorderPane pane) {
         setCenterOfBorderPane(pane, View.gameScheduler);
+        logger.fine("showing Game Scheduler");
     }
 
+    /**
+     * Method to change the view in the center of the boarder pane in the mainWindow
+     * @param pane the Pane where the View will be visible
+     * @param view the view which should be visible
+     */
     private void setCenterOfBorderPane(BorderPane pane, View view) {
         FXController controller = null;
         pane.setCenter(view.getPane());
         resetFooter(pane, true);
     }
 
-
+    /**
+     * Method to load a Game View
+     * @param box the box where the game view should be added.
+     * @param gameDecorator the gameDecorator instance of the game.
+     * @param factoryDecorator the factoryDecorator instance.
+     * @return the controller of the GameView
+     */
     public GameController loadGameView(VBox box, GameDecorator gameDecorator, FactoryDecorator factoryDecorator) {
         try {
             FXMLLoader loader = new FXMLLoader(getClass().getResource("gameScheduleView/Game.fxml"));
             box.getChildren().add(loader.load());
             GameController controller = loader.getController();
             controller.setup(tournamentDecorator, fileIO, factoryDecorator, box, gameDecorator, languageConfigurator);
+            logger.fine("loaded game view");
             return controller;
         } catch (IOException e) {
+            logger.warning("Fatal error program can not continue after this: " + e );
             e.printStackTrace();
-            //TODO LOGGER
         }
         return null;
     }
 
+    /**
+     * Method to print information for the user to the footer of mainwindow.
+     * @param pane the pane where the footer should be shown.
+     * @param msg the text to show.
+     * @param error true if it's a error message.
+     */
     public void printMessageToFooter(BorderPane pane, String msg, boolean error) {
+        logger.fine("message is printed to footer of window.");
         VBox bottom = (VBox) pane.getBottom();
         Label label = new Label();
         VBox innerVbox;
@@ -118,11 +174,15 @@ public class Factory {
             innerVbox.getChildren().add(label);
 
         }
-
-
     }
 
+    /**
+     * Method to remove the messages in the footer.
+     * @param pane the pane were the footer should be reseted
+     * @param error true if the error message should be cleared.
+     */
     public void resetFooter(BorderPane pane,boolean error) {
+        logger.fine("messages are removed from footer of window.");
         VBox bottom = (VBox) pane.getBottom();
         VBox vBox;
         if (error) {
@@ -134,10 +194,14 @@ public class Factory {
         vBox.setBorder(null);
     }
 
+
     public LanguageConfigurator getLanguageConfigurator() {
         return languageConfigurator;
     }
 
+      /**
+     * Enum of all views which can be set to the center of the mainwindow.
+     */
     public enum View {
         tournamentList("tournamentList/tournamentList.fxml"),
         participantFormular("participantAddFormular/participantFormular.fxml"),
@@ -147,6 +211,10 @@ public class Factory {
         private String fxmlFileName;
         private Pane pane;
 
+        /**
+         * Constructor of View
+         * @param fxmlFileName The name of the FXML File to load.
+         */
         private View(String fxmlFileName) {
             this.fxmlFileName = fxmlFileName;
         }
@@ -155,6 +223,14 @@ public class Factory {
             return pane;
         }
 
+        /**
+         * Method to laod the view
+         * @param tournamentDecorator the tournamentDecorator object which will be passed to the controller.
+         * @param fileIO the fileIO object which will be passed to the controller.
+         * @param factoryDecorator the factoryDecorator object which will be passed to the controller.
+         * @param borderPane the borderPane object which will be passed to the controller.
+         * @throws IOException if the fxml file is not found or can not be loaded correctly.
+         */
         public void loadView(TournamentDecorator tournamentDecorator, FileIO fileIO, FactoryDecorator factoryDecorator, BorderPane borderPane) throws IOException {
             FXMLLoader loader = new FXMLLoader(getClass().getResource(fxmlFileName));
             this.pane = loader.load();

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/FactoryDecorator.java

@@ -12,77 +12,153 @@ import javafx.scene.shape.Line;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.logging.Logger;
 
-public class FactoryDecorator implements IsObservable{
+/**
+ * Factory Decorator Class giving additional functionality to the factory and holding the listeners in itself.
+ */
+public class FactoryDecorator implements IsObservable {
     private Factory factory;
     private FileIO fileIO;
     private Pane pane;
-    private List<IsObserver> listener = new ArrayList<>();
+    private final List<IsObserver> listener = new ArrayList<>();
 
-    public FactoryDecorator(FileIO fileIO, Factory factory, Pane pane){
+    private static final Logger logger = Logger.getLogger(FactoryDecorator.class.getCanonicalName());
+
+    /**
+     * Setup of Factory Decorator with needed classes
+     *
+     * @param fileIO  for Reading and Saving Files
+     * @param factory factory which this class adds additional functionality to
+     * @param pane    standard pane
+     */
+    public FactoryDecorator(FileIO fileIO, Factory factory, Pane pane) {
+        logger.fine("Setting up the Factory decorator");
         setFactory(factory);
         setFileIO(fileIO);
         setPane(pane);
     }
 
+    /**
+     * Setting the File IO Class for its functionality
+     *
+     * @param fileIO for reading and saving to and from a file
+     */
     public void setFileIO(FileIO fileIO) {
+        logger.finer("Setting the FileIO to the FactoryDecorator");
         this.fileIO = fileIO;
     }
 
+    /**
+     * Setting the main class
+     *
+     * @param factory needed for the main functionality
+     */
     public void setFactory(Factory factory) {
+        logger.finer("Setting the factory to the FactoryDecorator");
         this.factory = factory;
     }
 
+    /**
+     * Setting of the given pane to the factory decorator
+     *
+     * @param pane that will be set
+     */
     public void setPane(Pane pane) {
+        logger.finer("Setting the pane to the FactoryDecorator");
         this.pane = pane;
     }
 
+    /**
+     * Method adds a new Listener to the listener list
+     *
+     * @param observer that is being added to the Listener List
+     */
     @Override
     public void addListener(IsObserver observer) {
+        logger.fine("Adding Listener: " + observer);
         listener.add(observer);
     }
 
+    /**
+     * Removes a Listener from the Listener List
+     *
+     * @param observer the Listener to be removed
+     */
     @Override
     public void removeListener(IsObserver observer) {
+        logger.fine("Removing Listener: " + observer);
         listener.remove(observer);
     }
 
-    public void openTournament(FileIO.TournamentFile tournamentFile){
+    /**
+     * Opens a tournament File in connection with the File IO Class, shows error Message if error occurs while opening
+     * it.
+     *
+     * @param tournamentFile the File to be opened
+     */
+    public void openTournament(FileIO.TournamentFile tournamentFile) {
+        logger.finer("Trying to open tournament file:" + tournamentFile);
         try {
             factory.setTournament(fileIO.loadTournament(tournamentFile));
             openScheduleView();
             clearMessage(false);
+            logger.fine("Opened tournament file successfully");
         } catch (IOException | ClassNotFoundException e) {
             e.printStackTrace();
+            logger.warning("Failed to open tournament file Error: " + e);
+            printMessageToFooter("Fehler beim lesen der Datei.", true);
             String msg = factory.getLanguageConfigurator().getSelectedLanguage("IOException");
+            logger.warning("Failed to open tournament file Error: " + e);
             printMessageToFooter(msg, true);
-        }  //TODO handle and logging
+        }
     }
 
+    /**
+     * Initializes the display of the Tournament list view
+     */
     public void openTournamentList() {
-        factory.showTournamentList((BorderPane) pane, this);
+        logger.fine("Showing TournamentList view");
+        factory.showTournamentList((BorderPane) pane);
         informListener();
     }
 
-    public void openParticipantFormular() {
-        factory.showParticipantFormular((BorderPane) pane, this);
+    /**
+     * Initializes the view of the participant form
+     */
+    public void openParticipantForm() {
+        logger.fine("Showing participant form view");
+        factory.showParticipantFormular((BorderPane) pane);
         informListener();
     }
 
-    public void openPlacesFormular() {
-        factory.showPlacesFormular((BorderPane) pane, this);
+    /**
+     * Initializes the view of the places form
+     */
+    public void openPlacesForm() {
+        logger.fine("Showing places form view");
+        factory.showPlacesFormular((BorderPane) pane);
         informListener();
     }
 
+    /**
+     * Initializes the view of gameSchedule
+     */
     public void openScheduleView() {
-        factory.showGameScheduler((BorderPane) pane, this);
+        factory.showGameScheduler((BorderPane) pane);
         informListener();
     }
 
+    /**
+     * Method to load all game views to show.
+     * @param hBoxCenter the box where the games should be shown.
+     * @param tournamentDecorator the tournamentDecorator to communicate to tournament
+     * @param treeView true if the games should be arranged like a tree.
+     */
     public void loadGameList(HBox hBoxCenter, TournamentDecorator tournamentDecorator, boolean treeView) {
         hBoxCenter.getChildren().clear();
 
-        if(tournamentDecorator.getTournament() == null){
+        if (tournamentDecorator.getTournament() == null) {
             return;
         }
 
@@ -94,7 +170,7 @@ public class FactoryDecorator implements IsObservable{
         for (int i = 0; i < gameList.size(); i++) {
             List<GameDecorator> newGameDecoratorsList = new ArrayList<>();
             VBox vBox = new VBox();
-            if(treeView){
+            if (treeView) {
                 vBox.setAlignment(Pos.CENTER);
                 vBox.setSpacing(gameBoxHeight * spacingFactor);
             } else {
@@ -104,12 +180,12 @@ public class FactoryDecorator implements IsObservable{
             for (int j = 0; j < gameList.get(i).size(); j++) {
                 GameDecorator gameDecorator = new GameDecorator(gameList.get(i).get(j));
                 newGameDecoratorsList.add(gameDecorator);
-                GameController gameController = openGameView(vBox,gameDecorator);
-                if(i>0){
-                    gameController.addListener(gameDecoratorsList.get(j*2));
-                    gameController.addListener(gameDecoratorsList.get(j*2+1));
-                } else if(gameBoxHeight == 0) {
-                    gameBoxHeight = gameController.getGameBoxHeigth();
+                GameController gameController = openGameView(vBox, gameDecorator);
+                if (i > 0) {
+                    gameController.addListener(gameDecoratorsList.get(j * 2));
+                    gameController.addListener(gameDecoratorsList.get(j * 2 + 1));
+                } else if (gameBoxHeight == 0) {
+                    gameBoxHeight = gameController.getGameBoxHeight();
                 }
                 gameDecorator.addListener(new IsObserver() {
                     @Override
@@ -120,28 +196,35 @@ public class FactoryDecorator implements IsObservable{
                 gameController.loadContent();
             }
             hBoxCenter.getChildren().add(vBox);
-            if(treeView){
-                if(i+1 < gameList.size())
-                hBoxCenter.getChildren().add(drawLines(vBox, gameBoxHeight, 30));
+            if (treeView) {
+                if (i + 1 < gameList.size())
+                    hBoxCenter.getChildren().add(drawLines(vBox, gameBoxHeight, 30));
             }
             gameDecoratorsList = newGameDecoratorsList;
         }
     }
 
-    public VBox drawLines(VBox gameVBox, double gameBoxHeight, double lineLength){
+    /**
+     * Method to draw the lines between the game views in the tree view.
+     * @param gameVBox the box with the games where lines should be drawn.
+     * @param gameBoxHeight the heigth of a single game box.
+     * @param lineLength the length of the horizontal lines.
+     * @return a box which contains the drawn lines.
+     */
+    public VBox drawLines(VBox gameVBox, double gameBoxHeight, double lineLength) {
         VBox completeLineVBox = new VBox();
         completeLineVBox.setAlignment(Pos.CENTER_LEFT);
         double lineSpacing = gameVBox.getSpacing() + gameBoxHeight - 1;
         completeLineVBox.setSpacing(lineSpacing);
-        for(int i = 0; i < gameVBox.getChildren().size(); i+=2){
+        for (int i = 0; i < gameVBox.getChildren().size(); i += 2) {
             HBox lineBox = new HBox();
             lineBox.setAlignment(Pos.CENTER);
 
             //add Lines from left Game to center
             VBox vBox = new VBox();
             vBox.setSpacing(lineSpacing);
-            vBox.getChildren().add(new Line(0,0,lineLength,0));
-            vBox.getChildren().add(new Line(0,0,lineLength,0));
+            vBox.getChildren().add(new Line(0, 0, lineLength, 0));
+            vBox.getChildren().add(new Line(0, 0, lineLength, 0));
             lineBox.getChildren().add(vBox);
 
 
@@ -158,24 +241,51 @@ public class FactoryDecorator implements IsObservable{
         return completeLineVBox;
     }
 
+    /**
+     * Method Initializes the Game View, in order to do that a vbox is needed and the gameDecorator
+     * @param vBox used for display
+     * @param gameDecorator the gameDecorator Object to communicate with game
+     * @return the controller of the loaded game view.
+     */
     public GameController openGameView(VBox vBox, GameDecorator gameDecorator) {
-        return factory.loadGameView(vBox ,gameDecorator, this);
+
+        return factory.loadGameView(vBox, gameDecorator, this);
     }
 
+    /**
+     * Method that initializes a new Message to be written on the footer, if it's an error boolean can be set.
+     *
+     * @param msg The message to be written
+     * @param error true if an error false if not
+     */
     public void printMessageToFooter(String msg, boolean error) {
-        factory.printMessageToFooter((BorderPane) pane,msg,error);
+        logger.fine("Initializes to write message: " + msg + " on the footer");
+        factory.printMessageToFooter((BorderPane) pane, msg, error);
     }
 
-    public void clearMessage(boolean error){
+    /**
+     * Method used to clear Messages shown on the footer
+     * @param error true if an error false if not
+     */
+    public void clearMessage(boolean error) {
+        logger.fine("Initializing to clear messages from the footer");
         factory.resetFooter((BorderPane) pane, error);
     }
 
+    /**
+     * getter Method of languageConfigurator
+     * @return the languageConfigurator object.
+     */
     public LanguageConfigurator getLanguageConfigurator() {
         return factory.getLanguageConfigurator();
     }
 
+    /**
+     * Method that informs all listeners of an update.
+     */
     public void informListener() {
-        for(IsObserver observer : listener) {
+
+        for (IsObserver observer : listener) {
             observer.update();
         }
     }

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/FileIO.java

@@ -4,7 +4,14 @@ package ch.zhaw.projekt2.turnierverwaltung;
 import javafx.collections.FXCollections;
 import javafx.collections.ObservableList;
 
-import java.io.*;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
 import java.net.URI;
 import java.util.logging.Logger;
 
@@ -12,8 +19,8 @@ import java.util.logging.Logger;
  * Class in Charge of Reading and Writing files
  */
 public class FileIO {
-    private File mainDir;
-    private File saves;
+    private final File mainDir;
+    private final File saves;
 
     private static final Logger logger = Logger.getLogger(FileIO.class.getCanonicalName());
 
@@ -57,13 +64,14 @@ public class FileIO {
 
     /**
      * Method to check if a tournament with the existing name already exists.
+     *
      * @param name that is being checked
      * @return true if the name exists already false if the name is unique
      */
     public boolean tournamentExists(String name) {
         logger.finer("checking for duplicate name in tournament List");
         for (TournamentFile file : getList()) {
-            if (file.toString().toLowerCase().equals(name.toLowerCase())) {
+            if (file.toString().equalsIgnoreCase(name)) {
                 logger.fine(name + " is an already existing name in the list");
                 return true;
             }
@@ -73,10 +81,10 @@ public class FileIO {
     }
 
     /**
-     * Loads and returns a tournament from a given File which contains the serialiazed tournament.
+     * Loads and returns a tournament from a given File which contains the serialized tournament.
      *
      * @param tournamentFile The tournament file where the data should be read from.
-     * @return Tournament that is returned when succefully being read from the file
+     * @return Tournament that is returned when successfully being read from the file
      * @throws ClassNotFoundException No definition for the class with the specified name could be found
      * @throws IOException            File not readable
      * @throws FileNotFoundException  File not found
@@ -119,7 +127,7 @@ public class FileIO {
     }
 
     /**
-     * Serializables and saves the receiving tournament file to a txt file.
+     * Serializable and saves the receiving tournament file to a txt file.
      *
      * @param tournament the receiving tournament.
      * @throws IOException           File not readable
@@ -181,14 +189,14 @@ public class FileIO {
     }
 
     /**
-     * TournamentFile Class is in use to add missing functionality that is
+     * TournamentFile Class is in used to add missing functionality that is
      */
-    public class TournamentFile extends File {
+    public static class TournamentFile extends File {
 
         /**
          * Only job the constructor got is to initialize it via its superclass. See java.io.File Documentation for more info.
          *
-         * @param uri abstract pathname needed for its superclass to intialize the file accordingly.
+         * @param uri abstract pathname needed for its superclass to initialize the file accordingly.
          */
         public TournamentFile(URI uri) {
             super(uri);

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/Game.java

@@ -1,77 +1,171 @@
 package ch.zhaw.projekt2.turnierverwaltung;
 
 import java.io.Serializable;
+import java.util.logging.Logger;
 
+/**
+ * Class Representing a game, implements Serializable to be saved inside a tournament
+ * Holding the data and points for a single match
+ */
 public class Game implements Serializable {
     private Participant participant1, participant2;
     private int points1, points2;
     private Place place;
     private Game previousGame1, previousGame2;
 
+    private static final Logger logger = Logger.getLogger(Game.class.getCanonicalName());
 
+    /**
+     * Constructor to initialize a new game.
+     * Two participants are needed.
+     *
+     * @param participant1 that is added to the game
+     * @param participant2 that is added to the game
+     */
     public Game(Participant participant1, Participant participant2) {
+        logger.fine("initializing a new game with the participants: " + participant1 + ", " + participant2);
         this.participant1 = participant1;
         this.participant2 = participant2;
     }
 
-    public Game(Game previousGame1, Game previousGame2){
+    /**
+     * Constructor to initialize a game with two previous games.
+     *
+     * @param previousGame1 previous game (connecting to this game in the hierarchy)
+     * @param previousGame2 other previous game (connecting to this game in the hierarchy)
+     */
+    public Game(Game previousGame1, Game previousGame2) {
+        logger.fine("initializing a new game with the previous games: " + previousGame1 + ", " + previousGame2);
         this.previousGame1 = previousGame1;
         this.previousGame2 = previousGame2;
     }
 
+    /**
+     * Method to get the points of the first participant
+     *
+     * @return points of participant 1
+     */
     public int getPoints1() {
+        logger.fine("Returning points of: " + participant1 + ", holding: " + points1 + " points");
         return points1;
     }
 
+    /**
+     * Method to set the points of the first participant
+     *
+     * @param points1 to be set for the first participant
+     */
     public void setPoints1(int points1) {
+        logger.fine("Setting points of: " + participant1 + ", to " + points1 + " points");
         this.points1 = points1;
     }
 
+    /**
+     * Method to get the points of the second participant
+     *
+     * @return points of participant 2
+     */
     public int getPoints2() {
+        logger.fine("Returning points of: " + participant2 + ", holding: " + points2 + " points");
         return points2;
     }
 
+    /**
+     * Method to set the points of the second participant
+     *
+     * @param points2 to be set for the second participant
+     */
     public void setPoints2(int points2) {
+        logger.fine("Setting points of: " + participant2 + ", to " + points2 + " points");
         this.points2 = points2;
     }
 
+    /**
+     * Method to get the first Participant
+     *
+     * @return the first Participant
+     */
     public Participant getParticipant1() {
+        logger.fine("Returning the first participant: " + participant1);
         return participant1;
     }
 
+    /**
+     * Method to set the first participant
+     *
+     * @param participant1 to be set as the first participant
+     */
     public void setParticipant1(Participant participant1) {
+        logger.fine("Setting the first Participant as: " + participant1);
         this.participant1 = participant1;
     }
 
+    /**
+     * Method to set the second participant
+     *
+     * @param participant2 to be set as the second participant
+     */
     public void setParticipant2(Participant participant2) {
+        logger.fine("Setting the second Participant as: " + participant2);
         this.participant2 = participant2;
     }
 
+    /**
+     * Method to get the second Participant
+     *
+     * @return the second participant
+     */
     public Participant getParticipant2() {
+        logger.fine("Returning the second participant: " + participant2);
         return participant2;
     }
 
+    /**
+     * Method to set the place of a game
+     *
+     * @param place to be set for the game
+     */
     public void setPlace(Place place) {
+        logger.fine("Setting the location of the game " + this + " to: " + place);
         this.place = place;
     }
 
+    /**
+     * Method to get the place of a game
+     *
+     * @return the place of the game
+     */
     public Place getPlace() {
+        logger.fine("Returning the place of the game, current Location: " + place);
         return place;
     }
 
-    public Participant getWinner(){
-        if(points1 > points2){
+    /**
+     * Method to determine the winner of a game, if there is a draw null will be returned.
+     *
+     * @return the winner of the game or null if draw
+     */
+    public Participant getWinner() {
+        logger.finer("Determining winner of game");
+        if (points1 > points2) {
+            logger.fine(participant1 + "has won the game");
             return participant1;
-        } else if(points2 > points1){
+        } else if (points2 > points1) {
+            logger.fine(participant2 + "has won the game");
             return participant2;
         } else {
+            logger.fine("There is no winner");
             return null;
         }
     }
 
-    public void refreshParticipants(){
+    /**
+     * Method that gets the winner of previous games and sets them as the participants of this game.
+     */
+    public void refreshParticipants() {
         participant1 = previousGame1.getWinner();
         participant2 = previousGame2.getWinner();
+        logger.fine("Refreshed Participants, new Participants: " + participant1 + ", " + participant2);
     }
 
 }

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/InvalidNameException.java

@@ -1,10 +1,15 @@
 package ch.zhaw.projekt2.turnierverwaltung;
 
+/**
+ * Invalid NameException is used to indicate when a given name does not follow the correct formatting.
+ */
 public class InvalidNameException extends Exception {
-    public InvalidNameException() {
-        super();
-    }
-
+    /**
+     * Constructor to throw the InvalidNameException, receives a String as input to define reason for throwing
+     * the error.
+     *
+     * @param errorMessage to be displayed with the exception
+     */
     public InvalidNameException(String errorMessage) {
         super(errorMessage);
     }

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/IsObservable.java

@@ -2,18 +2,17 @@ package ch.zhaw.projekt2.turnierverwaltung;
 
 /**
  * Most basic interface for observing an object
- * @author bles
  *
+ * @author bles
  */
 public interface IsObservable {
     /**
      * Add an observer that listens for updates
-     * @param observer
      */
     void addListener(IsObserver observer);
+
     /**
      * Remove an observer from the list
-     * @param observer
      */
     void removeListener(IsObserver observer);
 }

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/IsObserver.java

@@ -1,11 +1,12 @@
 package ch.zhaw.projekt2.turnierverwaltung;
 
 /**
- * Most basic interface for beeing an observer
- * @author bles
+ * Most basic interface for being an observer
  *
+ * @author bles
  */
 public interface IsObserver {
+
     /**
      * This method is always called when an observed object
      * changes

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/LanguageConfigurator.java

@@ -2,7 +2,6 @@ package ch.zhaw.projekt2.turnierverwaltung;
 
 import javafx.scene.control.Labeled;
 import javafx.scene.control.MenuItem;
-
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
@@ -103,11 +102,9 @@ public class LanguageConfigurator {
         englishDictionary.put("participantNotExist","Participant does not exist");
         germanDictionary.put("placeNotExist","Teilnehmer existiert nicht");
         englishDictionary.put("placeNotExist","Participant does not exist");
-
         //SaveMsg
         germanDictionary.put("save","Zuletzt gespeichert: ");
         englishDictionary.put("save","Last saved: ");
-
         //Alert
         germanDictionary.put("yes","Ja");
         englishDictionary.put("yes","Yes");
@@ -119,7 +116,6 @@ public class LanguageConfigurator {
         englishDictionary.put("headerDelete","Delete Tournament?");
         germanDictionary.put("contentDelete","Sind Sie sicher, dass sie das Turnier entfernen wollen?\nNach diesem Vorgang kann es nicht wiederhergestellt werden.");
         englishDictionary.put("contentDelete","Are you shure you want to delete the tournament?\nAfter that there is no way to restore.");
-
         germanDictionary.put("titleSchedule","Neu erstellen");
         englishDictionary.put("titleSchedule","Create new");
         germanDictionary.put("headerSchedule","Spielplan neu erstellen?");

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/LogConfiguration.java

@@ -3,18 +3,30 @@ package ch.zhaw.projekt2.turnierverwaltung;
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
-import java.util.logging.*;
-
+import java.util.logging.LogManager;
+import java.util.logging.Logger;
 
+/**
+ * Class in charge of setting up the Logging functionality properly
+ * For further Log settings look into the properties.log file
+ */
 public class LogConfiguration {
     private static final Logger logger = Logger.getLogger(LogConfiguration.class.getCanonicalName());
     private final File mainDir;
 
-    public LogConfiguration(String saveLocation, String logFileLocation) throws IOException {
+    /**
+     * Constructor of LogConfiguration, does the whole setup including reading the properties and setting up a
+     * directory for the log files also starts the root logger.
+     *
+     * @param saveLocation   where the log files should be placed in
+     * @param propertiesPath location of the properties.log file
+     * @throws IOException if error occurs while reading the log file
+     */
+    public LogConfiguration(String saveLocation, String propertiesPath) throws IOException {
         logger.fine("Starts setting up a main directory in which a folder with the log files will be placed, if not already exists");
         this.mainDir = new File(saveLocation);
         if (!mainDir.exists()) {
-            logger.fine("Creating main directory for log ordner in given path" + saveLocation);
+            logger.fine("Creating main directory for log folder in given path" + saveLocation);
             mainDir.mkdir();
         } else {
             logger.finer("main directory for log folder already exists");
@@ -25,17 +37,14 @@ public class LogConfiguration {
             saves.mkdir();
             logger.fine("Creating log save directory");
         } else {
-            logger.finer("log save directory already exists");
+            logger.finer("Log save directory already exists");
         }
 
-        String propertiesPath = "ch" + System.getProperty("file.separator") + "zhaw" + System.getProperty("file.separator") + "projekt2" + System.getProperty("file.separator") +
-                "turnierverwaltung" + System.getProperty("file.separator") + "logging" + System.getProperty("file.separator") + "log.properties";
-
-        logger.fine("Getting and reading logconfig file from " + propertiesPath);
+        logger.fine("Getting and reading log config file from: " + propertiesPath);
         InputStream logConfig = this.getClass().getClassLoader().getResourceAsStream(propertiesPath);
         LogManager.getLogManager().readConfiguration(logConfig);
 
-
         Logger.getLogger(LogConfiguration.class.getPackageName());
+        logger.fine("Finished setting up Logging functionality");
     }
 }

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/Person.java

@@ -14,7 +14,7 @@ public class Person implements Serializable {
     private String firstName;
     private String phoneNumber;
 
-    private static final Logger logger = Logger.getLogger(FileIO.class.getCanonicalName());
+    private static final Logger logger = Logger.getLogger(Person.class.getCanonicalName());
 
 
     /**

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/Place.java

@@ -10,7 +10,7 @@ public class Place implements Serializable {
     private final String NAME_MATCHING_REGEX = "[a-zA-Z0-9]{1,20}";
     private String name;
 
-    private static final Logger logger = Logger.getLogger(FileIO.class.getCanonicalName());
+    private static final Logger logger = Logger.getLogger(Place.class.getCanonicalName());
 
     /**
      * Constructor of a place initializes it and checks if name is in valid format

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/Player.java

@@ -12,7 +12,7 @@ public class Player extends Person implements Participant {
 
     private LocalDate dateOfBirth;
 
-    private static final Logger logger = Logger.getLogger(FileIO.class.getCanonicalName());
+    private static final Logger logger = Logger.getLogger(Player.class.getCanonicalName());
 
     /**
      * Constructor of player initializes a new player setting sever attributes like firstname, name birthdate usw.

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/Team.java

@@ -4,7 +4,6 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.logging.Logger;
 
-
 /**
  * Class Team represents a team that can be added to a tournament
  * (in the prototype there is no functionality for the team)
@@ -14,7 +13,7 @@ public class Team implements Participant {
     private List<Player> players;
     private Person contactPerson;
 
-    private static final Logger logger = Logger.getLogger(FileIO.class.getCanonicalName());
+    private static final Logger logger = Logger.getLogger(Team.class.getCanonicalName());
 
     /**
      * Constructor to initiate a team, sets its name
@@ -22,7 +21,7 @@ public class Team implements Participant {
      * @param name the new name to be set
      */
     public Team(String name) {
-        logger.fine("Setting the new  name of the team as: " + name);
+        logger.fine("Setting the new name of the team as: " + name);
         setName(name);
         players = new ArrayList<>();
     }

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/Tournament.java

@@ -22,7 +22,7 @@ public class Tournament implements Serializable {
     private final List<Place> places;
     private List<List<Game>> gameList;
 
-    private static final Logger logger = Logger.getLogger(FileIO.class.getCanonicalName());
+    private static final Logger logger = Logger.getLogger(Tournament.class.getCanonicalName());
 
 
     /**

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/TournamentDecorator.java

@@ -1,7 +1,6 @@
 package ch.zhaw.projekt2.turnierverwaltung;
 
 import javafx.application.Platform;
-
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Date;
@@ -9,6 +8,8 @@ import java.util.List;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
+import java.util.logging.Logger;
+
 
 public class TournamentDecorator implements IsObservable{
     private Tournament tournament;
@@ -17,48 +18,84 @@ public class TournamentDecorator implements IsObservable{
     private ExecutorService executorService;
     private FactoryDecorator factoryDecorator;
 
+    private static final Logger logger = Logger.getLogger(TournamentDecorator.class.getCanonicalName());
+
+    /**
+     * Constructor to initialize TournamentDecorator
+     * adds a listener to save the tournament every time if something is changed.
+     * creates a executer service to do the saving process in separate thread for better performance.
+     * @param fileIO
+     */
     public TournamentDecorator(FileIO fileIO){
+        logger.fine("initializing TournamentDecorator");
         setFileIO(fileIO);
         addListener(new IsObserver() {
             @Override
             public void update() {
                 if(tournament != null){
-
                     saveTournament();
+                    logger.fine("listener to save tournament was added");
                 }
             }
         });
         executorService = Executors.newFixedThreadPool(1);
     }
 
+    /**
+     * Setter method of FactoryDecorator
+     * @param factoryDecorator the factory decorator to load different views.
+     */
     public void setFactoryDecorator(FactoryDecorator factoryDecorator) {
         this.factoryDecorator = factoryDecorator;
     }
 
+    /**
+     * Setter Method of FileIO
+     * @param fileIO the fileIO object to read and save to files.
+     */
     public void setFileIO(FileIO fileIO) {
         this.fileIO = fileIO;
     }
 
+    /**
+     * setter Method of Tournament
+     * @param tournament the new Tournament Object which was selected by user.
+     */
     public void setTournament(Tournament tournament) {
         this.tournament = tournament;
     }
 
+    /**
+     * getter Method of Tournament
+     * @return the actual tournament which is open.
+     */
     public Tournament getTournament() {
         return tournament;
     }
 
+    /**
+     * Method to add a listener in list.
+     * @param observer the observer object which should be informed.
+     */
     @Override
     public void addListener(IsObserver observer) {
         listener.add(observer);
     }
 
+    /**
+     * Method to remove a listener from list.
+     * @param observer the object to remove.
+     */
     @Override
     public void removeListener(IsObserver observer) {
         listener.remove(observer);
     }
 
-
+    /**
+     * Method to save the actual tournament to files.
+     */
     public void saveTournament(){
+        logger.fine("Saving Tournament to File.");
         executorService.execute(new saveTask());
         factoryDecorator.clearMessage(false);
         String msg = factoryDecorator.getLanguageConfigurator().getSelectedLanguage("save");
@@ -66,40 +103,49 @@ public class TournamentDecorator implements IsObservable{
     }
 
 
-
+    /**
+     * Method to create a new Tournament. It checks if the name is valid, creates a new instance of Tournament and calls
+     * FileIO to save the new Tournament.
+     * @param name The name which was entered by the user.
+     * @param type The type of Tournament
+     */
     public void createTournament(String name, Tournament.Type type){
-
         try {
             if(fileIO.tournamentExists(name)){
-                //TODO:Logger
+                logger.warning("a tournament with name " + name + "exists already.");
                 String msg = factoryDecorator.getLanguageConfigurator().getSelectedLanguage("tournamentExists");
                 factoryDecorator.printMessageToFooter(msg, true);
                 return;
             }
             Tournament tournament = new Tournament(name, type);
+            logger.fine("new tournament instance was created.");
             fileIO.saveTournament(tournament);
+            logger.fine("new Tournament File is saved.");
             factoryDecorator.clearMessage(true);
             informListener();
         } catch (InvalidNameException e) {
             e.printStackTrace();
-            //TODO: Logger
+            logger.warning("The name which was entered is invalid.");
             String msg = factoryDecorator.getLanguageConfigurator().getSelectedLanguage("invalidName");
             factoryDecorator.printMessageToFooter(msg, true);
         } catch (Tournament.InvalidTypeException e) {
             e.printStackTrace();
-            //TODO: Logger
+            logger.warning("The selected type of tournament is not valid.");
             String msg = factoryDecorator.getLanguageConfigurator().getSelectedLanguage("invalidMode");
             factoryDecorator.printMessageToFooter(msg, true);
-
         } catch (IOException e) {
             e.printStackTrace();
-            //TODO: Logger
+            logger.warning("Creating a new Tournament File was failed.");
             String msg = factoryDecorator.getLanguageConfigurator().getSelectedLanguage("IOException");
             factoryDecorator.printMessageToFooter(msg, true);
         }
 
     }
 
+    /**
+     * Method to delete a Tournament File
+     * @param tournamentFile The File which should be deleted.
+     */
     public void deleteTournament(FileIO.TournamentFile tournamentFile){
         try {
             fileIO.deleteTournament(tournamentFile);
@@ -112,8 +158,11 @@ public class TournamentDecorator implements IsObservable{
         }
     }
 
+    /**
+     * Method to create the list of games. The participants are entered in random order.
+     */
     public void createNewGameSchedule() {
-        //TODO: logging
+        logger.fine("Creating new Game Schedule");
         try {
             tournament.createGameSchedule();
             factoryDecorator.clearMessage(true);
@@ -121,6 +170,7 @@ public class TournamentDecorator implements IsObservable{
             e.printStackTrace();
             String msg = factoryDecorator.getLanguageConfigurator().getSelectedLanguage("numberParticipant");
             factoryDecorator.printMessageToFooter(msg, true);
+            logger.warning("Failed to create Game Schedule. The number of Participants is invalid.");
         }
         informListener();
     }
@@ -193,6 +243,7 @@ public class TournamentDecorator implements IsObservable{
         executorService.awaitTermination(2000, TimeUnit.MILLISECONDS);
     }
 
+
     private class saveTask implements Runnable {
 
         @Override

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/MainWindow.java

@@ -2,26 +2,34 @@ package ch.zhaw.projekt2.turnierverwaltung.main;
 
 import ch.zhaw.projekt2.turnierverwaltung.*;
 import javafx.application.Application;
-import javafx.event.EventHandler;
-import javafx.fxml.FXMLLoader;
 import javafx.scene.Scene;
 import javafx.scene.layout.BorderPane;
 import javafx.stage.Stage;
-import javafx.stage.WindowEvent;
 
 import java.util.logging.Logger;
 
-
+/**
+ * Class Main window is used to initialize the GUI Elements, Creating several Decorators and also getting the Factories
+ * ready
+ */
 public class MainWindow extends Application {
-    private FileIO fileIO = new FileIO(System.getProperty("user.dir") + System.getProperty("file.separator") + "tournierverwaltung_angrynerds");
+    private final FileIO fileIO = new FileIO(System.getProperty("user.dir") +
+            System.getProperty("file.separator") + "tournierverwaltung_angrynerds");
     private FactoryDecorator factoryDecorator;
     private TournamentDecorator tournamentDecorator = new TournamentDecorator(fileIO);
     private LanguageConfigurator languageConfigurator = new LanguageConfigurator();
     private Factory factory = new Factory(fileIO, tournamentDecorator, languageConfigurator);
     private static final Logger logger = Logger.getLogger(FileIO.class.getCanonicalName());
 
+    /**
+     * Start method used to initialize the main window and load it's needed component
+     * Also sets the scene and set some values like min width and height
+     *
+     * @param primaryStage to be displayed
+     */
     @Override
-    public void start(Stage primaryStage) throws Exception {
+    public void start(Stage primaryStage) {
+        logger.fine("Starting up the main window with the primary Stage");
         BorderPane pane = factory.loadMainWindow();
         factoryDecorator = new FactoryDecorator(fileIO, factory, pane);
         factory.loadAllViews(factoryDecorator, pane);
@@ -39,6 +47,9 @@ public class MainWindow extends Application {
         primaryStage.show();
     }
 
+    /**
+     * Method used to safely shut down the application
+     */
     @Override
     public void stop() {
         try {

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/MainWindowController.java

@@ -3,14 +3,25 @@ package ch.zhaw.projekt2.turnierverwaltung.main;
 import ch.zhaw.projekt2.turnierverwaltung.FXController;
 import ch.zhaw.projekt2.turnierverwaltung.LanguageConfigurator;
 import javafx.application.Platform;
-import javafx.event.ActionEvent;
 import javafx.fxml.FXML;
 import javafx.scene.control.Label;
 import javafx.scene.control.Menu;
 import javafx.scene.control.MenuItem;
+import java.util.logging.Logger;
 
+import java.util.logging.Logger;
+
+
+/**
+ * Main WindowController Class in charge of the Controller Functions of it
+ * Since not much is directly in the main window only the top bar functionality is represented (language setting and
+ * close option).
+ */
 public class MainWindowController extends FXController {
 
+
+    private static final Logger logger = Logger.getLogger(MainWindowController.class.getCanonicalName());
+      
     @FXML
     private MenuItem closeBtn;
 
@@ -20,21 +31,33 @@ public class MainWindowController extends FXController {
     @FXML
     private Menu menuItemLanguage;
 
+    /**
+     * Method changes the language Setting to german
+     */
     @FXML
-    void changeLangToGerman(ActionEvent event) {
+    void changeLangToGerman() {
         getLanguageConfigurator().changeLanguage(LanguageConfigurator.Language.GERMAN);
+        logger.fine("language setting changed to german");
     }
 
     @FXML
-    void changeLangToEnglish(ActionEvent event) {
+    void changeLangToEnglish() {
         getLanguageConfigurator().changeLanguage(LanguageConfigurator.Language.ENGLISH);
+        logger.fine("language setting changed to english");
     }
 
+    /**
+     * This Method initializes the
+     */
     @FXML
-    void closeApplication(ActionEvent event) {
+    void closeApplication() {
+        logger.fine("");
         Platform.exit();
     }
 
+    /**
+     * There is no content to load
+     */
     @Override
     public void shareGUIElementWithLanguageConfigurator() {
         getLanguageConfigurator().recieveLabel(mainTitle);
@@ -43,9 +66,10 @@ public class MainWindowController extends FXController {
     }
 
 
-
+    /**
+     * There is no content to load
+     */
     @Override
     public void loadContent() {
-
     }
 }

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/gameScheduleView/AlertNewSchedule.java

@@ -1,10 +1,21 @@
 package ch.zhaw.projekt2.turnierverwaltung.main.gameScheduleView;
 
+
+import ch.zhaw.projekt2.turnierverwaltung.FileIO;
 import ch.zhaw.projekt2.turnierverwaltung.LanguageConfigurator;
 import javafx.scene.control.Alert;
 import javafx.scene.control.ButtonBar;
 import javafx.scene.control.ButtonType;
+/**
+ * Class that is used to display the popup window to confirm a sensitive action of the user.
+ */
 
+import java.util.logging.Logger;
+
+
+/**
+ * Class that is used to display the popup window to confirm a sensitive action of the user.
+ */
 public class AlertNewSchedule extends Alert {
     private ButtonType yesButton;
     private ButtonType noButton;
@@ -15,6 +26,9 @@ public class AlertNewSchedule extends Alert {
     private String headerDelete;
     private String contentDelete;
 
+    /**
+     * Popup to ask the user if he is sure that he wants to reshuffle the game board.
+     */
     public AlertNewSchedule(LanguageConfigurator languageConfigurator){
         super(Alert.AlertType.WARNING);
         yes = languageConfigurator.getSelectedLanguage("yes");
@@ -30,6 +44,11 @@ public class AlertNewSchedule extends Alert {
         getButtonTypes().setAll(yesButton, noButton);
     }
 
+    /**
+     * Result gathered from previous question popup window
+     *
+     * @return boolean true if yes button is pressed and false if no is pressed
+     */
     public boolean showAndGetResult() {
         showAndWait().ifPresent(input -> {
             result = input == yesButton;

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/gameScheduleView/GameController.java

@@ -10,6 +10,9 @@ import javafx.scene.control.TextField;
 import javafx.scene.layout.Pane;
 import javafx.scene.layout.VBox;
 
+/**
+ * Class GameController in Charge of the Controller Element of the Schedule view.
+ */
 public class GameController extends FXController{
 
     private GameDecorator gameDecorator;
@@ -33,6 +36,7 @@ public class GameController extends FXController{
     private TextField pointsTeamTwo;
 
     @FXML
+
     private Label locationLabel;
 
     @Override
@@ -41,7 +45,7 @@ public class GameController extends FXController{
     }
 
     @FXML
-    void saveGameResult(Event event) {
+    void saveGameResult() {
         gameDecorator.saveGameResult(pointsTeamOne.getText(), pointsTeamTwo.getText());
     }
 
@@ -50,7 +54,7 @@ public class GameController extends FXController{
         gameDecorator.saveGamePlace(newPlace);
     }
 
-    public double getGameBoxHeigth(){
+    public double getGameBoxHeight(){
         return mainVBox.getPrefHeight();
     }
 

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/gameScheduleView/GameDecorator.java

@@ -1,29 +1,51 @@
 package ch.zhaw.projekt2.turnierverwaltung.main.gameScheduleView;
 
 import ch.zhaw.projekt2.turnierverwaltung.*;
-
 import java.util.ArrayList;
 import java.util.List;
 
-
+/**
+ * This Class is used by the GameController for additional functionality and holds the listeners and the Model Game
+ */
 public class GameDecorator implements IsObservable{
     private Game game;
     private List<IsObserver> listener = new ArrayList<>();
 
+    /**
+     * Setup the GameDecorator
+     *
+     * @param game Model for the Controller
+     */
     public GameDecorator (Game game) {
         this.game = game;
     }
 
+    /**
+     * Method adds a new Listener to the listener list
+     *
+     * @param observer that is being added to the Listener List
+     */
     @Override
     public void addListener(IsObserver observer) {
         listener.add(observer);
     }
 
+    /**
+     * Removes a Listener from the Listener List
+     *
+     * @param observer the Listener to be removed
+     */
     @Override
     public void removeListener(IsObserver observer) {
         listener.remove(observer);
     }
 
+    /**
+     * Saves the Gameresult in the model
+     *
+     * @param points1 points achieved in textfield one
+     * @param points2 points achieved in textfield two
+     */
     public void saveGameResult(String points1, String points2){
         if(points1.length() > 0){
             game.setPoints1(Integer.parseInt(points1));
@@ -38,19 +60,35 @@ public class GameDecorator implements IsObservable{
         informListener();
     }
 
+    /**
+     * Saves the Place in the Model
+     *
+     * @param place
+     */
     public void saveGamePlace(Place place){
         game.setPlace(place);
         informListener();
     }
 
+    /**
+     * @return game points from player one
+     */
     public String getPoints1() {
        return String.valueOf(game.getPoints1());
     }
 
+    /**
+     *
+     *@return game points from player two
+     */
     public String getPoints2() {
         return String.valueOf(game.getPoints2());
     }
 
+    /**
+     *
+     * @return returns Gameparticipant one
+     */
     public String getParticipantOne() {
         if (game.getParticipant1() != null) {
             return game.getParticipant1().toString();
@@ -58,6 +96,10 @@ public class GameDecorator implements IsObservable{
         return "1";
     }
 
+    /**
+     *
+     * @return returns Gameparticipant two
+     */
     public String getParticipantTwo() {
         if (game.getParticipant2() != null) {
             return game.getParticipant2().toString();
@@ -65,15 +107,25 @@ public class GameDecorator implements IsObservable{
         return "2";
     }
 
+    /**
+     * calls method in model to refresh participant
+     */
     public void refreshParticipants(){
         game.refreshParticipants();
         informListener();
     }
 
+    /**
+     *
+     * @return place
+     */
     public Place getPlace() {
         return game.getPlace();
     }
 
+    /**
+     * Method that informs all listeners of an update.
+     */
     public void informListener() {
         for(IsObserver observer : listener) {
             observer.update();

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/gameScheduleView/GameScheduleController.java

@@ -51,12 +51,12 @@ public class GameScheduleController extends FXController {
 
     @FXML
     void openPlacesFormular(ActionEvent event) {
-        getFactoryDecorator().openPlacesFormular();
+        getFactoryDecorator().openPlacesForm();
     }
 
     @FXML
     void openParticipantFormular(ActionEvent event) {
-        getFactoryDecorator().openParticipantFormular();
+        getFactoryDecorator().openParticipantForm();
     }
 
     @FXML

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/participantAddFormular/ParticipantFormularController.java

@@ -14,6 +14,11 @@ import javafx.scene.input.MouseEvent;
 import javafx.scene.layout.GridPane;
 import javafx.scene.layout.VBox;
 
+import java.util.logging.Logger;
+
+/**
+ * Controller of Participant
+ */
 public class ParticipantFormularController extends FXController {
 
     @FXML
@@ -68,8 +73,14 @@ public class ParticipantFormularController extends FXController {
     @FXML
     private Button saveBtn;
 
+    private static final Logger logger = Logger.getLogger(ParticipantFormularController.class.getCanonicalName());
+
+    /**
+     * Shares GUI Elements with the LanguageConfigurator
+     */
     @Override
     public void shareGUIElementWithLanguageConfigurator() {
+        logger.fine("sharing GUI Elements");
         getLanguageConfigurator().recieveLabel(participantListTitle);
         getLanguageConfigurator().recieveLabel(closeBtn);
         getLanguageConfigurator().recieveLabel(deleteBtn);
@@ -81,8 +92,11 @@ public class ParticipantFormularController extends FXController {
         getLanguageConfigurator().recieveLabel(saveBtn);
     }
 
+    /**
+     * Changes the current selection
+     */
     @FXML
-    void changedSelection(MouseEvent event){
+    void changedSelection(){
         Player participant = (Player) participantListView.getSelectionModel().getSelectedItems().get(0);
         participantNameTextField.setText(participant.getName());
         firstNameTextField.setText(participant.getFirstName());
@@ -90,12 +104,18 @@ public class ParticipantFormularController extends FXController {
         birthDateTextField.setText(participant.getFormattedDateOfBirth());
     }
 
+    /**
+     * Saves a new Participant and clears form
+     */
     @FXML
-    void saveParticipant(ActionEvent event) {
+    void saveParticipant() {
         getTournamentDecorator().savePlayer(firstNameTextField.getText(), participantNameTextField.getText(), phoneNumberTextField.getText(), birthDateTextField.getText());
         clearFormular();
     }
 
+    /**
+     * Clears current form
+     */
     private void clearFormular() {
         firstNameTextField.clear();
         participantNameTextField.clear();
@@ -103,19 +123,30 @@ public class ParticipantFormularController extends FXController {
         birthDateTextField.clear();
     }
 
+    /**
+     * Deletes the selected participant.
+     */
     @FXML
-    void delete(ActionEvent event) {
+    void delete() {
         Participant participant = participantListView.getSelectionModel().getSelectedItems().get(0);
+        logger.fine("deleting participant:" + participant);
         getTournamentDecorator().deleteParticipant(participant);
     }
 
+    /**
+     * Closes the participant form
+     */
     @FXML
-    void close(ActionEvent event) {
+    void close() {
         getFactoryDecorator().openScheduleView();
     }
 
+    /**
+     * Loads the previously saved content and puts it in the list
+     */
     @Override
     public void loadContent() {
+        logger.fine("loading and placing it into the list");
         Tournament tournament = getTournamentDecorator().getTournament();
         if(tournament != null){
             participantListView.setItems(tournament.getParticipants());

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/placesAddFormular/PlacesFormularController.java

@@ -2,16 +2,22 @@ package ch.zhaw.projekt2.turnierverwaltung.main.placesAddFormular;
 
 import ch.zhaw.projekt2.turnierverwaltung.FXController;
 import ch.zhaw.projekt2.turnierverwaltung.Place;
-import ch.zhaw.projekt2.turnierverwaltung.Player;
 import ch.zhaw.projekt2.turnierverwaltung.Tournament;
-import javafx.event.ActionEvent;
 import javafx.fxml.FXML;
 import javafx.scene.control.Button;
 import javafx.scene.control.Label;
 import javafx.scene.control.ListView;
 import javafx.scene.control.TextField;
+import javafx.scene.layout.GridPane;
+import javafx.scene.layout.VBox;
+
 import javafx.scene.input.MouseEvent;
 
+import java.util.logging.Logger;
+
+/**
+ * Controller of the places form, in charge of its functionality.
+ */
 public class PlacesFormularController extends FXController {
 
 
@@ -39,6 +45,10 @@ public class PlacesFormularController extends FXController {
     @FXML
     private Button saveBtn;
 
+
+    private static final Logger logger = Logger.getLogger(PlacesFormularController.class.getCanonicalName());
+
+
     @Override
     public void shareGUIElementWithLanguageConfigurator() {
         getLanguageConfigurator().recieveLabel(placeListTitle);
@@ -50,37 +60,61 @@ public class PlacesFormularController extends FXController {
 
     }
 
+      /**
+     * Selects an item (place) from the List view
+     */
     @FXML
-    void changedSelection(MouseEvent event){
+    void changedSelection() {
         Place place = placeListView.getSelectionModel().getSelectedItems().get(0);
+        logger.finer("Selected new Place from list: " + place);
         placeNameTextField.setText(place.getName());
     }
 
+    /**
+     * Saves the name of a new place into the list and clears the form
+     */
     @FXML
-    void savePlace(ActionEvent event) {
+    void savePlace() {
         getTournamentDecorator().savePlace(placeNameTextField.getText());
-        clearFormular();
+        logger.fine("Saved " + placeNameTextField + " to the list of places");
+        clearForm();
     }
 
-    private void clearFormular() {
+    /**
+     * Method clears the input field
+     */
+    private void clearForm() {
+        logger.finer("Clearing input text field");
         placeNameTextField.clear();
     }
 
+    /**
+     * Method deletes the currently selected place from the list.
+     */
     @FXML
-    void delete(ActionEvent event) {
+    void delete() {
         Place place = placeListView.getSelectionModel().getSelectedItems().get(0);
+        logger.fine("Deleting " + place + "from place list");
         getTournamentDecorator().deletePlace(place);
     }
 
+    /**
+     * Closes the current Place view, going back to previous view
+     */
     @FXML
-    void close(ActionEvent event) {
+    void close() {
+        logger.fine("Closing place form");
         getFactoryDecorator().openScheduleView();
     }
 
+    /**
+     * Loads the already saved places and displays them on the places list.
+     */
     @Override
     public void loadContent() {
+        logger.fine("Getting the Saved tournaments into the Places list");
         Tournament tournament = getTournamentDecorator().getTournament();
-        if(tournament != null){
+        if (tournament != null) {
             placeListView.setItems(tournament.getPlaces());
         } else {
             placeListView.getItems().clear();

app/src/test/java/ch/zhaw/projekt2/turnierverwaltung/FactoryDecoratorTest.java

@@ -0,0 +1,38 @@
+package ch.zhaw.projekt2.turnierverwaltung;
+
+import javafx.scene.layout.BorderPane;
+import javafx.scene.layout.Pane;
+import org.junit.jupiter.api.Test;
+import org.mockito.InOrder;
+import org.mockito.Mockito;
+import java.io.IOException;
+
+import static org.junit.jupiter.api.Assertions.fail;
+import static org.mockito.Mockito.inOrder;
+
+public class FactoryDecoratorTest {
+
+    private FactoryDecorator factoryDecorator;
+
+    @Test
+    void test() {
+        FileIO io = Mockito.mock(FileIO.class);
+        Factory fc = Mockito.mock(Factory.class);
+        Pane pn = Mockito.mock(BorderPane.class);
+        FileIO.TournamentFile tf = Mockito.mock(FileIO.TournamentFile.class);
+
+        factoryDecorator = new FactoryDecorator(io,fc,pn);
+        factoryDecorator.openTournament(tf);
+
+        InOrder order = inOrder(io,fc,pn);
+
+        try {
+            order.verify(fc).setTournament(io.loadTournament(tf));
+            order.verify(fc).showGameScheduler((BorderPane) pn);
+
+        } catch (IOException | ClassNotFoundException e) {
+            e.printStackTrace();
+            fail();
+        }
+    }
+}

app/src/test/java/ch/zhaw/projekt2/turnierverwaltung/FileIOTest.java

@@ -1,6 +1,6 @@
 package ch.zhaw.projekt2.turnierverwaltung;
 
-import org.junit.jupiter.api.Assertions;
+
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
@@ -12,10 +12,13 @@ import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.Comparator;
 import java.util.List;
-import java.util.logging.Logger;
+
 
 import static org.junit.jupiter.api.Assertions.*;
 
+/**
+ * FileIO Test Class
+ */
 class FileIOTest {
 
     String RESOURCES_DIR = "./src/test/resources/ch/zhaw/projekt2/turnierverwaltung/";
@@ -23,6 +26,11 @@ class FileIOTest {
     String saveDir;
     FileIO io;
 
+    /**
+     * Method checks if a new directory is set up correctly and can be accessed.
+     *
+     * @throws IOException Exceptions should not be thrown
+     */
     @Test
     void FileIONewDir() throws IOException {
         mainDir = RESOURCES_DIR + "FileIONew";
@@ -50,14 +58,23 @@ class FileIOTest {
         assertFalse(saveDirFile.exists());
     }
 
+    /**
+     * Method tests the read behavior and if a file is read correctly
+     */
     @Nested
     class Read{
+        /**
+         *  Sets up a directory
+         */
         @BeforeEach
         void init() {
             mainDir = RESOURCES_DIR + "FileIORead";
             io = new FileIO(mainDir);
         }
 
+        /**
+         * Test if the list is displayed correctly when getting it via getList
+         */
         @Test
         void getList() {
             List<FileIO.TournamentFile> tournaments = io.getList();
@@ -65,6 +82,9 @@ class FileIOTest {
             assertEquals("test1.txt", tournaments.get(1).getName());
         }
 
+        /**
+         * Test behaviour when the list is empty
+         */
         @Test
         void getListEmpty() {
             mainDir = RESOURCES_DIR + "FileIOEmpty";
@@ -72,6 +92,12 @@ class FileIOTest {
             assertEquals(0, io.getList().size());
         }
 
+        /**
+         * Tests behavior when loading a tournament that exists.
+         *
+         * @throws IOException Exceptions should not be thrown
+         * @throws ClassNotFoundException Exceptions should not be thrown
+         */
         @Test
         void loadTournament() throws IOException, ClassNotFoundException {
             mainDir = RESOURCES_DIR + "FileIORead";
@@ -80,6 +106,9 @@ class FileIOTest {
             assertEquals("test1", tournament.getName());
         }
 
+        /**
+         * Test behavior when trying to load non-existent tournament
+         */
         @Test
         void loadTournamentNotExisting(){
             File file = new File("Not-existing-File");
@@ -88,11 +117,17 @@ class FileIOTest {
             assertFalse(file.exists());
         }
 
+        /**
+         * Tests behavior when trying to load an empty tournament.
+         */
         @Test
         void loadTournamentEmpty(){
             assertThrows(IOException.class, () -> io.loadTournament(new File(mainDir + "/saves/empty.txt")));
         }
 
+        /**
+         * Tests behavior when the tournamentfile input is null
+         */
         @Test
         void loadTournamentFileNull(){
             assertThrows(IllegalArgumentException.class, () -> io.loadTournament(null));
@@ -107,6 +142,13 @@ class FileIOTest {
             io = new FileIO(mainDir);
         }
 
+        /**
+         * Saves the Saving mechanism and deletion
+         *
+         * @throws IOException Exceptions should not be thrown
+         * @throws InvalidNameException Exceptions should not be thrown
+         * @throws Tournament.InvalidTypeException Exceptions should not be thrown
+         */
         @Test
         void saveTournament() throws IOException, InvalidNameException, Tournament.InvalidTypeException {
             Tournament tournament = null;
@@ -118,6 +160,9 @@ class FileIOTest {
             assertFalse(file.exists());
         }
 
+        /**
+         * Tests behavior when a tournament is being saved that is only null
+         */
         @Test
         void saveTournamentNull(){
             assertThrows(IllegalArgumentException.class, () -> io.saveTournament(null));
@@ -132,6 +177,10 @@ class FileIOTest {
             io = new FileIO(mainDir);
         }
 
+        /**
+         *  Test if tournament that does exist can be deleted
+         * @throws IOException Exceptions should not be thrown
+         */
         @Test
         void deleteTournament() throws IOException {
             File file = new File(mainDir + "/saves/test1.txt");
@@ -141,6 +190,11 @@ class FileIOTest {
             assertFalse(file.exists());
         }
 
+        /**
+         * Testing if tournament that does not exist can be deleted
+         *
+         * @throws IOException Exception should not be thrown only checking for FileNotFoundException
+         */
         @Test
         void deleteTournamentNotExisting() throws IOException {
             File file = new File("Not-existing-File");
@@ -149,6 +203,9 @@ class FileIOTest {
             assertFalse(file.exists());
         }
 
+        /**
+         * Tests if a tournament that is null can be deleted
+         */
         @Test
         void deleteTournamentNull(){
             assertThrows(IllegalArgumentException.class, () -> io.deleteTournament(null));

app/src/test/java/ch/zhaw/projekt2/turnierverwaltung/GameTest.java

@@ -0,0 +1,41 @@
+package ch.zhaw.projekt2.turnierverwaltung;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+
+public class GameTest {
+
+    private Game game;
+
+    @Test
+    @DisplayName("TestWinner")
+    void testWinnerFunction() {
+        Participant one = Mockito.mock(Player.class);
+        Participant two = Mockito.mock(Player.class);
+        game = new Game(one,two);
+        game.setPoints1(1);
+        Assertions.assertEquals(one,game.getWinner());
+        game.setPoints2(2);
+        Assertions.assertEquals(two,game.getWinner());
+    }
+
+    @Test
+    @DisplayName("Test refresh Participant")
+    void refreshTest() {
+        Participant one = Mockito.mock(Player.class);
+        Participant two = Mockito.mock(Player.class);
+        Game game1 = new Game(one,two);
+        Game game2 = new Game(one,two);
+        game = new Game(game1,game2);
+        game1.setPoints1(2);
+        game2.setPoints2(2);
+        Assertions.assertNull(game.getParticipant1());
+        Assertions.assertNull(game.getParticipant2());
+        game.refreshParticipants();
+        Assertions.assertEquals(one,game.getParticipant1());
+        Assertions.assertEquals(two,game.getParticipant2());
+
+    }
+}

app/src/test/java/ch/zhaw/projekt2/turnierverwaltung/LanguageTest.java

@@ -0,0 +1,18 @@
+package ch.zhaw.projekt2.turnierverwaltung;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+public class LanguageTest {
+
+    @Test
+    @DisplayName("Test Dictionary")
+    void test() {
+        LanguageConfigurator languageConfigurator = new LanguageConfigurator();
+        Assertions.assertEquals("Ja",languageConfigurator.getSelectedLanguage("yes"));
+        languageConfigurator.changeLanguage(LanguageConfigurator.Language.ENGLISH);
+        Assertions.assertEquals("Yes",languageConfigurator.getSelectedLanguage("yes"));
+
+    }
+}

app/src/test/java/ch/zhaw/projekt2/turnierverwaltung/PersonTest.java

@@ -0,0 +1,25 @@
+package ch.zhaw.projekt2.turnierverwaltung;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class PersonTest {
+    private Person person;
+
+    @Test
+    @DisplayName("Test invalid Parameter")
+    void invalidParams() {
+        try {
+            assertThrows(Person.InvalidPhoneNumberException.class,()->new Person("A","a",".sad"));
+            person = new Person("A","A","");
+            assertEquals("A", person.getFirstName());
+            assertEquals("A", person.getName());
+            assertEquals("", person.getPhoneNumber());
+        } catch (InvalidNameException | Person.InvalidPhoneNumberException e) {
+            fail();
+        }
+    }
+
+}

app/src/test/java/ch/zhaw/projekt2/turnierverwaltung/PlaceTest.java

@@ -0,0 +1,36 @@
+package ch.zhaw.projekt2.turnierverwaltung;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class PlaceTest {
+    private Place place;
+
+    @Test
+    @DisplayName("Test Params")
+    void paramTest() {
+        Assertions.assertThrows(InvalidNameException.class, () -> new Place("*"));
+        try {
+            place = new Place("placeA");
+            assertEquals("placeA", place.getName());
+        } catch (InvalidNameException e) {
+            fail();
+        }
+    }
+
+    @Test
+    @DisplayName("Place Equals Test")
+    void testEqual() {
+        try {
+            place = new Place("placeA");
+            assertTrue(place.equals(place));
+            assertTrue(place.equals(new Place("placeA")));
+            assertFalse(place.equals(new Place("nads")));
+        } catch (InvalidNameException e) {
+            fail();
+        }
+    }
+}

app/src/test/java/ch/zhaw/projekt2/turnierverwaltung/PlayerTest.java

@@ -0,0 +1,39 @@
+package ch.zhaw.projekt2.turnierverwaltung;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class PlayerTest {
+    private Player player;
+
+    @Test
+    @DisplayName("Test invalid Parameter")
+    void invalidParams() {
+        try {
+            assertThrows(Person.InvalidPhoneNumberException.class,()->new Player("A","a",".sad",""));
+            assertThrows(Player.InvalidDateException.class,()->new Player("A","a","","a"));
+            player = new Player("A","A","","");
+            assertEquals("A",player.getFirstName());
+            assertEquals("A",player.getName());
+            assertEquals("",player.getPhoneNumber());
+            assertNull(player.getDateOfBirth());
+        } catch (InvalidNameException | Person.InvalidPhoneNumberException | Player.InvalidDateException e) {
+            fail();
+        }
+    }
+
+    @Test
+    @DisplayName("Test equals")
+    void equalsTest() {
+        try {
+            player = new Player("A","A","","");
+            assertTrue(player.equals(player));
+            assertFalse(player.equals(new Player("B", "D", "", "")));
+            assertTrue(player.equals(new Player("A", "A", "", "")));
+        } catch (InvalidNameException | Person.InvalidPhoneNumberException | Player.InvalidDateException e) {
+            e.printStackTrace();
+        }
+    }
+}

app/src/test/java/ch/zhaw/projekt2/turnierverwaltung/TeamTest.java

@@ -0,0 +1,31 @@
+package ch.zhaw.projekt2.turnierverwaltung;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+
+public class TeamTest {
+
+    private Team team;
+
+    @Test
+    @DisplayName("Team Params")
+    void testParams() {
+        Player player = Mockito.mock(Player.class);
+        team = new Team("Team1");
+        for (int i = 0; i < 3; i++) {
+            Assertions.assertEquals(i,team.getPlayers().size());
+            team.addPlayer(player);
+        }
+    }
+
+    @Test
+    @DisplayName("Team Equals")
+    void equalTeam() {
+        team = new Team("A");
+        Assertions.assertTrue(team.equals(team));
+        Assertions.assertTrue(team.equals(new Team("A")));
+        Assertions.assertFalse(team.equals(new Team("B")));
+    }
+}

app/src/test/java/ch/zhaw/projekt2/turnierverwaltung/TournamentTest.java

@@ -44,20 +44,21 @@ public class TournamentTest {
             //Checks if one Participant gets added
             Participant participantOne = Mockito.mock(Player.class);
             when(participantOne.equals(any(Participant.class))).thenReturn(false);
-
-            assertEquals(0, tournament.getParticipants().size());
-            tournament.saveParticipant(participantOne);
-            assertEquals(1, tournament.getParticipants().size());
-
-            //Checks if a second Participant gets added
-            Participant participantTwo = Mockito.mock(Player.class);
-            tournament.saveParticipant(participantTwo);
-            assertEquals(2, tournament.getParticipants().size());
-
-            //Checks if a allready added Particpant does not get added
-            when(participantOne.equals(any(Participant.class))).thenReturn(true);
-            tournament.saveParticipant(participantTwo);
-            assertEquals(2, tournament.getParticipants().size());
+            try {
+                assertEquals(0, tournament.getParticipants().size());
+                tournament.saveParticipant(participantOne);
+                assertEquals(1, tournament.getParticipants().size());
+                //Checks if a second Participant gets added
+                Participant participantTwo = Mockito.mock(Player.class);
+                tournament.saveParticipant(participantTwo);
+                assertEquals(2, tournament.getParticipants().size());
+                //Checks if a allready added Particpant does not get added
+                when(participantOne.equals(any(Participant.class))).thenReturn(true);
+                tournament.saveParticipant(participantTwo);
+                assertEquals(2, tournament.getParticipants().size());
+            } catch (Person.InvalidPhoneNumberException e) {
+                fail();
+            }
 
         }
 
@@ -69,13 +70,13 @@ public class TournamentTest {
             //Checks if Error is thrown if Participant not in list
             assertThrows(Tournament.ParticipantNotExistsException.class, () -> tournament.removeParticipant(participant));
 
-            //Checks if participant gets removed
-            tournament.saveParticipant(participant);
-            assertEquals(1, tournament.getParticipants().size());
             try {
+                //Checks if participant gets removed
+                tournament.saveParticipant(participant);
+                assertEquals(1, tournament.getParticipants().size());
                 tournament.removeParticipant(participant);
                 assertEquals(0, tournament.getParticipants().size());
-            } catch (Tournament.ParticipantNotExistsException e) {
+            } catch (Tournament.ParticipantNotExistsException | Person.InvalidPhoneNumberException e) {
                 fail();
             }
         }
@@ -126,13 +127,18 @@ public class TournamentTest {
                         tournament.createGameSchedule();
                         assertEquals(2, tournament.getGameList().size());
                         tournament.saveParticipant(participant);
-                    } catch (Tournament.NumberOfParticipantInvalidException e) {
+                    } catch (Tournament.NumberOfParticipantInvalidException | Person.InvalidPhoneNumberException e) {
                         fail();
                     }
 
                 } else {
+
                     assertThrows(Tournament.NumberOfParticipantInvalidException.class, () -> tournament.createGameSchedule());
-                    tournament.saveParticipant(participant);
+                    try {
+                        tournament.saveParticipant(participant);
+                    } catch (Person.InvalidPhoneNumberException e) {
+                        e.printStackTrace();
+                    }
                 }
             }
             try {