build fail

.vscode/launch.json

+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "java",
+            "name": "Current File",
+            "request": "launch",
+            "mainClass": "${file}"
+        },
+        {
+            "type": "java",
+            "name": "Main",
+            "request": "launch",
+            "mainClass": "no.uib.inf101.calculator.Main",
+            "projectName": "Calculator"
+        }
+    ]
+}
\ No newline at end of file

src/main/java/no/uib/inf101/calculator/Calculator.java

@@ -35,8 +35,8 @@ public class Calculator {
         addOperator(new Root());
     }
 
-    private void addOperator(Operator operator) {
-        operators.put(operator.getSymbol(), operator);
+    private void addOperator(String operator) {
+        operators.put(operator.getSymbol(), string);
     }
 
     /**
@@ -115,5 +115,10 @@ public class Calculator {
 
         throw new IllegalArgumentException("The Expression type is not supported by the calculator: " + expression.getClass());
     }
+
+    public Integer calculate(int i, int j) {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'calculate'");
+    }
     
 }

src/main/java/no/uib/inf101/calculator/operations/Factorial.java

@@ -14,11 +14,42 @@ public class Factorial implements UnaryOperator {
 
     @Override
     public double calculate(double num) { 
-        int result = 1;
-        for (int i = 1; i <= num; i++) {
+        if (num < 0) {
+            throw new IllegalArgumentException("Factorial is undefined for negative numbers.");
+        }
+
+        if (num == 0 || num == 1) {
+            return 1;
+        } else if (num % 1 == 0) { 
+            return factorial((int) num);
+        } else {
+            throw new IllegalArgumentException("Factorial is undefined for non-integer numbers.");
+        }
+    }
+
+    private double factorial(int n) {
+        double result = 1;
+        for (int i = 2; i <= n; i++) {
             result *= i;
         }
         return result;
     }
+/*
+    private double gammaFunction(double num) {
+        double precision = 1e-6;
+        double step = precision;
+        double integral = 0.0;
+        double t = step;
+        int limit = 1000; 
+
+        while (t < limit) {
+            integral += integrand(t, num) * step;
+            t += step;
+        }
+        return integral;
+    }
 
-}
+    private double integrand(double t, double num) {
+        return Math.pow(t, num - 1) * Math.exp(-t);
+    } */
+}
\ No newline at end of file

src/test/java/no/uib/inf101/calculator/CalculatorTest.java

+package no.uib.inf101.calculator;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import org.junit.jupiter.api.Test;
+
+public class CalculatorTest {
+    
+    @Test
+    void CreateCalculator() {
+        Calculator calc = new Calculator();
+        assertNotNull(calc);
+    }
+
+    @Test
+    void testGetOperatorSymbols() {
+        Calculator calc = new Calculator();
+        List<String> symbols = calc.getOperatorSymbols();
+        assertNotNull(symbols);
+        assertTrue(symbols.contains("+"));
+        assertTrue(symbols.contains("-"));
+        assertTrue(symbols.contains("*"));
+        assertTrue(symbols.contains("^"));
+        assertTrue(symbols.contains("!"));
+        assertTrue(symbols.contains("log"));
+        assertTrue(symbols.contains("ln"));
+        assertTrue(symbols.contains("√"));
+    }
+
+    @Test
+    void testGetOperatorDescription() {
+        Calculator calc = new Calculator();
+        assertEquals("Addition: \"Combine two numbers to find their total or sum.\"", calc.getOperatorDescription("+"));
+        assertEquals("Subtraction: \"Find the difference between two numbers by taking one away from the other.\"", calc.getOperatorDescription("-"));
+        assertEquals("Multiplication: \"Calculate the result of multiplying one number by another.\"", calc.getOperatorDescription("*"));
+        assertEquals("Exponent: \"Calculate the result of raising a base number to the power of an exponent.\"", calc.getOperatorDescription("^"));
+        assertEquals("Factorial: \"The product of an integer and all the integers below it\"", calc.getOperatorDescription("!"));
+        assertEquals("Logarithm: \"The power to which a given number must be raised to produce 10\"", calc.getOperatorDescription("log"));
+        assertEquals("Logarithm: \"The power to which e must be raised to produce a given number\"", calc.getOperatorDescription("ln"));
+        assertEquals("√", calc.getOperatorDescription("√"));
+    }
+}
\ No newline at end of file

src/test/java/no/uib/inf101/calculator/expression/BinaryExpressionTest.java

 package no.uib.inf101.calculator.expression;
 
-import no.uib.inf101.calculator.expression.BinaryExpression;
-import no.uib.inf101.calculator.expression.Expression;
-import no.uib.inf101.calculator.expression.ExpressionParser;
-import no.uib.inf101.calculator.expression.Number;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
 
 class BinaryExpressionTest {
 
+
+    @Test
+    void testEquals() {
+        Expression num1 = new Number(5);
+        Expression num2 = new Number(10);
+        Expression num3 = new Number(5);
+        Expression num4 = new Number(10);
+
+        BinaryExpression expr1 = new BinaryExpression(num1, num2, "+");
+        BinaryExpression expr2 = new BinaryExpression(num3, num4, "+");
+        BinaryExpression expr3 = new BinaryExpression(num2, num1, "+"); // Different operand order
+        BinaryExpression expr4 = new BinaryExpression(num1, num2, "*"); // Different operator
+        
+        // Reflexive
+        assertEquals(expr1, expr1);
+        
+        // Symmetric
+        assertEquals(expr1, expr2);
+        assertEquals(expr2, expr1);
+        
+        // Transitive
+        BinaryExpression expr5 = new BinaryExpression(new Number(5), new Number(10), "+");
+        assertEquals(expr1, expr2);
+        assertEquals(expr2, expr5);
+        assertEquals(expr1, expr5);
+        
+        // Unequal cases
+        assertNotEquals(expr1, expr3); // Order matters in your implementation
+        assertNotEquals(expr1, expr4); // Operator matters
+        assertNotEquals(expr1, null);  // Should not be equal to null
+        assertNotEquals(expr1, new Object()); // Should not be equal to a different class
+    }
+
+    
+        
+
     @Test
     void testConstructorWithValidBinaryExpression() {
         Expression expr1 = new Number(2);
@@ -37,7 +72,7 @@ class BinaryExpressionTest {
     void testBinaryExpressionEquals() {
         BinaryExpression expr1 = new BinaryExpression(new Number(2), new Number(3), "+");
         BinaryExpression expr2 = new BinaryExpression(new Number(2), new Number(3), "+");
-
+        
         assertEquals(expr1, expr2);
     }
 

src/test/java/no/uib/inf101/calculator/expression/NumberExpressionTest.java

 package no.uib.inf101.calculator.expression;
 
-import no.uib.inf101.calculator.expression.Number;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
 
 public class NumberExpressionTest {
 
@@ -35,4 +38,26 @@ public class NumberExpressionTest {
         Number expr2 = new Number(2);
         assertNotEquals(expr1, expr2, "Two different expressions should not be equal.");
     }
+
+    @Test
+    void testClassisNumber() {
+        Number expression = new Number(5);
+
+        assertTrue(expression.isNumber());
+    }
+
+    @Test
+    void testClassEquality() {
+        Number expr1 = new Number(3);
+        Object obj = new Object();
+
+        assertNotEquals(expr1, obj, "Expressions of different classes should not be equal.");
+    }
+
+    @Test
+    void testNumberIsNull() {
+        Number expression = null;
+
+        assertNull(expression, "The number expression should be null.");
+    }
 }

src/test/java/no/uib/inf101/calculator/mutationCoverage/MutationCoverageTest.java

 package no.uib.inf101.calculator.mutationCoverage;
 
-import org.junit.jupiter.api.BeforeAll;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-
-import java.io.*;
+import java.io.BufferedReader;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
 import java.util.Properties;
 
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
 
 public class MutationCoverageTest {
 

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 static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
@@ -16,7 +17,7 @@ public class UnaryOperatorsTest {
     private final int num1Factorial = 720;
     private final int num2 = 7;
     private final int num2Factorial = 5040;
-    private final double DELTA = 0.0000001;
+    private final double DELTA = 1e-2;
 
     @BeforeEach
     void setUp() {
@@ -34,13 +35,26 @@ public class UnaryOperatorsTest {
 
     @Test
     void factorialTest() {  
-        assertEquals(num1Factorial, factorialOperator.calculate(num1));
-        assertEquals(num2Factorial, factorialOperator.calculate(num2));
+    assertEquals(num1Factorial, factorialOperator.calculate(num1));
+    assertEquals(num2Factorial, factorialOperator.calculate(num2));
+    // if desimal number is given, it should throw an exception
+
+    Throwable thrown = assertThrows(java.lang.IllegalArgumentException.class, () -> factorialOperator.calculate(1.5));
+    assertEquals("Factorial is undefined for non-integer numbers.", thrown.getMessage());
+
+    // if negative number is given, it should throw an exception
+    thrown = assertThrows(java.lang.IllegalArgumentException.class, () -> factorialOperator.calculate(-1));
+    assertEquals("Factorial is undefined for negative numbers.", thrown.getMessage());
+
+    // if 0 is given, it should return 1
+    assertEquals(1, factorialOperator.calculate(0));
+    // if 1 is given, it should return 1
+    assertEquals(1, factorialOperator.calculate(1));
     }
 
     @Test
     void factorialDescriptionTest() {  
-        assertTrue(!factorialOperator.getDescription().isEmpty());
+        assertFalse(factorialOperator.getDescription().isEmpty());
     }
 
     // Ln tests
@@ -52,12 +66,12 @@ public class UnaryOperatorsTest {
     @Test
     void lnTest() {  
         assertEquals(0, lnOperator.calculate(1), DELTA);
-        assertEquals(1, lnOperator.calculate(2.718281828459045), DELTA);
+        assertEquals(1, lnOperator.calculate(Math.E), DELTA);
     }
 
     @Test
     void lnDescriptionTest() {  
-        assertTrue(!lnOperator.getDescription().isEmpty());
+        assertFalse(lnOperator.getDescription().isEmpty());
     }
 
     // Log tests
@@ -75,7 +89,7 @@ public class UnaryOperatorsTest {
     
     @Test
     void logDescriptionTest() {  
-        assertTrue(!logOperator.getDescription().isEmpty());
+        assertFalse(logOperator.getDescription().isEmpty());
     }
 
     // Root tests
@@ -85,15 +99,20 @@ public class UnaryOperatorsTest {
     }
 
     @Test
-    void rootTest() {  
+    void rootTest() {   
         assertEquals(2, rootOperator.calculate(4), DELTA);
-        assertEquals(5.1961524227066, rootOperator.calculate(27), DELTA);
+        assertEquals(Math.sqrt(27), rootOperator.calculate(27), DELTA);
         assertEquals(16, rootOperator.calculate(256), DELTA);
     }
 
     @Test
     void rootDescriptionTest() {  
-        assertTrue(!rootOperator.getDescription().isEmpty());
+        assertFalse(rootOperator.getDescription().isEmpty());
+    }
+
+    @Test
+    void rootNegativeNumberTest() {  
+        assertEquals(Double.NaN, rootOperator.calculate(-1), DELTA);
     }
 
-}
+} 
\ No newline at end of file

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

+package no.uib.inf101.calculator;
+
+public @interface test {
+
+}