Add transform tests and error handling.

src/main/java/edu/ntnu/stud/chaosgame/game/ChaosGameDescription.java

@@ -12,8 +12,8 @@ public class ChaosGameDescription {
 
     /**
      * Constructor for ChaosGameDescription
-     * @param minCoords Inputs a {@link Vector2D} vector of minimum coordinates for the chaos game.
-     * @param maxCoords Inputs a {@link Vector2D} vector of maximum coordinates for the chaos game.
+     * @param minCoords Inputs a {@link Vector2D} vector of lower left coordinates for the chaos game.
+     * @param maxCoords Inputs a {@link Vector2D} vector of upper right coordinates for the chaos game.
      * @param transforms Inputs a list of transformations {@link Transform2D} used in the chaos game.
      */
     public ChaosGameDescription(Vector2D minCoords, Vector2D maxCoords, List<Transform2D> transforms) {

src/main/java/edu/ntnu/stud/chaosgame/transformations/JuliaTransform.java

@@ -35,11 +35,19 @@ public class JuliaTransform extends Transform2D {
      * @return The transformed point, represented by a vector {@link Vector2D}
      */
     public Vector2D transform(Vector2D point){
-        Vector2D temp1 = new Vector2D();
+        if (point == null) {
+            throw new IllegalArgumentException("Point should not be null");
+        }
+        Vector2D temp1;
+
         if (sign > 0){
         temp1 = point.add(c1);}
         else if (sign < 0){
             temp1 = point.subtract(c1);
+        } else {
+            // Maybe replace with logger based on SolarLint
+            System.out.println("Sign is zero. No transformation performed");
+            return new Complex(point.getX0(),point.getX1());
         }
         return new Complex(temp1.getX0(), temp1.getX1()).sqrt();
     }

src/test/java/edu/ntnu/stud/chaosgame/game/ChaosGameDescriptionTest.java

+package edu.ntnu.stud.chaosgame.game;
+
+import edu.ntnu.stud.chaosgame.model.Complex;
+import edu.ntnu.stud.chaosgame.model.Matrix2x2;
+import edu.ntnu.stud.chaosgame.model.Vector2D;
+import edu.ntnu.stud.chaosgame.transformations.AffineTransform2D;
+import edu.ntnu.stud.chaosgame.transformations.JuliaTransform;
+import edu.ntnu.stud.chaosgame.transformations.Transform2D;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class ChaosGameDescriptionTest {
+    private Vector2D minCoords;
+
+    private Vector2D maxCoords;
+
+    private List<Transform2D> transforms2D;
+    private ChaosGameDescription description;
+
+    Complex complex;
+    Matrix2x2 matrix2x2;
+
+    Vector2D vector2D;
+
+    @BeforeEach
+    void setUp() {
+        minCoords = new Vector2D(0, 1);
+        maxCoords = new Vector2D(1,0);
+        complex = new Complex(0.3,0.6);
+        matrix2x2 = new Matrix2x2(0.5,1,1,0.5);
+        vector2D = new Vector2D(3,1);
+        transforms2D = new ArrayList<>();
+        transforms2D.add(new AffineTransform2D(matrix2x2,vector2D));
+        transforms2D.add(new JuliaTransform(complex,1));
+        description = new ChaosGameDescription(minCoords,maxCoords,transforms2D);
+    }
+
+    @Test
+    void getTransforms() {
+        assertInstanceOf(AffineTransform2D.class, description.getTransforms().getFirst());
+        assertInstanceOf(JuliaTransform.class, description.getTransforms().get(1));
+    }
+
+    @Test
+    void getMinCoords() {
+        assertEquals(0,minCoords.getX0());
+        assertEquals(1,minCoords.getX1());
+    }
+
+    @Test
+    void getMaxCoords() {
+        assertEquals(1,maxCoords.getX0());
+        assertEquals(0,maxCoords.getX1());
+    }
+
+    @Test
+    void testConstructorValues(){
+        assertEquals(minCoords,description.getMinCoords());
+        assertEquals(maxCoords,description.getMaxCoords());
+        assertEquals(transforms2D, description.getTransforms());
+    }
+}
\ No newline at end of file

src/test/java/edu/ntnu/stud/chaosgame/game/ChaosGameFileHandlerTest.java

+import static org.junit.jupiter.api.Assertions.*;
+class ChaosGameFileHandlerTest {
+  
+}
\ No newline at end of file

src/test/java/edu/ntnu/stud/chaosgame/transformations/AffineTransform2DTest.java

+package edu.ntnu.stud.chaosgame.transformations;
+
+import edu.ntnu.stud.chaosgame.model.Matrix2x2;
+import edu.ntnu.stud.chaosgame.model.Vector2D;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+class AffineTransform2DTest {
+
+
+
+
+    Matrix2x2 matrix2x2;
+    Vector2D vector2D;
+    AffineTransform2D affineTransform2D;
+
+    @BeforeEach
+    void setUp() {
+
+
+        matrix2x2 = new Matrix2x2(0.5,1,1,0.5);
+        vector2D = new Vector2D(3,1);
+        affineTransform2D = new AffineTransform2D(matrix2x2,vector2D);
+
+    }
+    @Nested
+    @DisplayName("Positive Affine Transform Tests")
+    class PositiveAffineTransform2DTest{
+        @Test
+        void transform() {
+            Vector2D point = new Vector2D(1, 1);
+            Vector2D expected = new Vector2D(4.5,2.5);
+            Vector2D actual = affineTransform2D.transform(point);
+            System.out.println(expected.getX0());
+            System.out.println(expected.getX1());
+            assertEquals(expected.getX0(), actual.getX0(), "The transform method should correctly transform the X0 component");
+            assertEquals(expected.getX1(), actual.getX1(), "The transform method should correctly transform the X1 component");
+
+        }
+
+        @Test
+        void getMatrix() {
+            Matrix2x2 actual = affineTransform2D.getMatrix();
+            assertEquals(matrix2x2, actual, "The getMatrix method should return the correct matrix");
+        }
+
+        @Test
+        void getVector() {
+            Vector2D actual = affineTransform2D.getVector();
+            assertEquals(vector2D, actual, "The getVector method should return the correct vector");
+        }
+    }
+}
\ No newline at end of file

src/test/java/edu/ntnu/stud/chaosgame/transformations/JuliaTransformTest.java

+package edu.ntnu.stud.chaosgame.transformations;
+
+import edu.ntnu.stud.chaosgame.model.Complex;
+import edu.ntnu.stud.chaosgame.model.Matrix2x2;
+import edu.ntnu.stud.chaosgame.model.Vector2D;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+class JuliaTransformTest {
+
+
+    Complex complex;
+    Matrix2x2 matrix2x2;
+    Vector2D vector2D;
+    JuliaTransform juliaTransform;
+
+    @BeforeEach
+    void setUp() {
+
+        complex = new Complex(0.3,0.6);
+        vector2D = new Vector2D(3,1);
+        juliaTransform = new JuliaTransform(complex,1);
+
+    }
+    @Nested
+    @DisplayName("Positive Tests for Julia Transformations")
+    class JuliaTransformPositiveTests{
+        @Test
+        void getC1(){
+            Complex actual = juliaTransform.getC1();
+            assertEquals(complex,actual,"The getC1 should return the correct complex number");
+
+        }
+        @Test
+        void transform(){
+            Vector2D expected = new Vector2D(1.866,0.428);
+            Vector2D actual = juliaTransform.transform(vector2D);
+            assertEquals(expected.getX0(),actual.getX0(),0.01);
+            assertEquals(expected.getX1(),actual.getX1(),0.01);
+
+        }
+    }
+    @Nested
+    @DisplayName("Negative Tests for Julia Transformations")
+    class JuliaTransformNegativeTests{
+        @Test
+        void transformZeroSign(){
+             JuliaTransform juliaTransformZeroSign = new JuliaTransform(complex,0);
+             assertEquals(vector2D.getX0(),juliaTransformZeroSign.transform(vector2D).getX0());
+             assertEquals(vector2D.getX1(),juliaTransformZeroSign.transform(vector2D).getX1());
+
+
+
+        }
+    }
+}
\ No newline at end of file