addition of tests

src/main/java/no/uib/inf101/calculator/textAnswers/TextAnswers.java

@@ -9,22 +9,22 @@ public class TextAnswers {
      * Hvor høy prosent mutation coverage har klassen BinaryExpression.java
      * i pakken calculator.expression?
      */
-    static final int q1 = 0;
+    static final int q1 = 81;
 
     /**
      * Hvor mange mutasjoner gjøres i klassen Multiplication.java i pakken
      * calculator.operations?
      */
-    static final int q2 = 0;
+    static final int q2 = 4;
 
     /**
      * Hvor høy prosent line coverage har pakken calculator.expression?
      */
-    static final int q3 = 0;
+    static final int q3 = 90;
 
     /**
      * True or false: mutasjonen på linje 12 i klassen Addition.java i pakken
      * calculator.operations går ut på å bytte ut returstrengen med en tom streng.
      */
-    static final Boolean q4 = null;
+    static final Boolean q4 = true;
 }

src/test/java/no/uib/inf101/calculator/operations/UnaryOperatorsTest.java

+package no.uib.inf101.calculator.operations;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class UnaryOperatorsTest {
+
+    private Factorial factorialOperator;
+    private Ln lnOperator;
+    private Log logOperator;
+    private Root rootOperator;
+
+    private final int num1 = 6;
+    private final int num1Factorial = 720;
+    private final int num2 = 7;
+    private final int num2Factorial = 5040;
+    private final double DELTA = 0.0000001;
+
+    @BeforeEach
+    void setUp() {
+        factorialOperator = new Factorial();
+        lnOperator = new Ln();
+        logOperator = new Log();
+        rootOperator = new Root();
+    }
+
+    // Factorial tests
+    @Test
+    void factorialGetSymbolTest() {  
+        assertEquals("!", factorialOperator.getSymbol());
+    }
+
+    @Test
+    void factorialTest() {  
+        assertEquals(num1Factorial, factorialOperator.calculate(num1));
+        assertEquals(num2Factorial, factorialOperator.calculate(num2));
+    }
+
+    @Test
+    void factorialDescriptionTest() {  
+        assertTrue(!factorialOperator.getDescription().isEmpty());
+    }
+
+    // Ln tests
+    @Test
+    void lnGetSymbolTest() {  
+        assertEquals("ln", lnOperator.getSymbol());
+    }
+
+    @Test
+    void lnTest() {  
+        assertEquals(0, lnOperator.calculate(1), DELTA);
+        assertEquals(1, lnOperator.calculate(2.718281828459045), DELTA);
+    }
+
+    @Test
+    void lnDescriptionTest() {  
+        assertTrue(!lnOperator.getDescription().isEmpty());
+    }
+
+    // Log tests
+    @Test
+    void logGetSymbolTest() {  
+        assertEquals("log", logOperator.getSymbol());
+    }
+
+    @Test
+    void logTest() {  
+        assertEquals(0, logOperator.calculate(1), DELTA);
+        assertEquals(1, logOperator.calculate(10), DELTA);
+        assertEquals(2, logOperator.calculate(100), DELTA);
+    }
+    
+    @Test
+    void logDescriptionTest() {  
+        assertTrue(!logOperator.getDescription().isEmpty());
+    }
+
+    // Root tests
+    @Test
+    void rootGetSymbolTest() {  
+        assertEquals("√", rootOperator.getSymbol());
+    }
+
+    @Test
+    void rootTest() {  
+        assertEquals(2, rootOperator.calculate(4), DELTA);
+        assertEquals(5.1961524227066, rootOperator.calculate(27), DELTA);
+        assertEquals(16, rootOperator.calculate(256), DELTA);
+    }
+
+    @Test
+    void rootDescriptionTest() {  
+        assertTrue(!rootOperator.getDescription().isEmpty());
+    }
+
+}