diff --git a/src/simplejavacalculatorTest/CalculatorTest.java b/src/simplejavacalculatorTest/CalculatorTest.java
index 1ea20f7..849f29a 100755
--- a/src/simplejavacalculatorTest/CalculatorTest.java
+++ b/src/simplejavacalculatorTest/CalculatorTest.java
@@ -3,117 +3,159 @@
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 import static java.lang.Double.NaN;
-import java.lang.Math;
-
 
 import simplejavacalculator.Calculator;
 
 class CalculatorTest {
-	
-	@Test
-	void calculateBiNormalTest() {
-		Calculator calculator = new Calculator();
-		calculator.calculateBi(Calculator.BiOperatorModes.normal, 2.0);
-		Assertions.assertEquals(NaN, calculator.calculateBi(Calculator.BiOperatorModes.normal, 3.0));
-    }
-	
-	@Test
-	void calculateBiAddTest() {
-		Calculator calculator = new Calculator();
-		calculator.calculateBi(Calculator.BiOperatorModes.add, 3.0);
-		Assertions.assertEquals(5.5, calculator.calculateBi(Calculator.BiOperatorModes.normal, 2.5));
-	}
-	
-	@Test
-	void calculateBiMinusTest() {
-		Calculator calculator = new Calculator();
-		calculator.calculateBi(Calculator.BiOperatorModes.minus, 3.1415);
-		Assertions.assertEquals(2.0415, calculator.calculateBi(Calculator.BiOperatorModes.normal, 1.1));
-	}
-	
-	@Test
-	void calculateBiMultiplyTest() {
-		Calculator calculator = new Calculator();
-		calculator.calculateBi(Calculator.BiOperatorModes.multiply, 3.2);
-		Assertions.assertEquals(6.4, calculator.calculateBi(Calculator.BiOperatorModes.normal, 2.0));
-	}
-	
-	@Test
-	void calculateBiDivideTest() {
-		Calculator calculator = new Calculator();
-		calculator.calculateBi(Calculator.BiOperatorModes.divide, 6.4);
-		Assertions.assertEquals(3.2, calculator.calculateBi(Calculator.BiOperatorModes.normal, 2.0));
-	}
-	
-	@Test
-	void calculateEqualTest() {
-		Calculator calculator = new Calculator();
-		calculator.calculateBi(Calculator.BiOperatorModes.add, 6.4);
-		calculator.calculateBi(Calculator.BiOperatorModes.add, 2.0);
-		Assertions.assertEquals(11.4, calculator.calculateEqual(3.0));
-	}
-	
-	@Test
-	void resetTest() {
-		Calculator calculator = new Calculator();
-		calculator.calculateBi(Calculator.BiOperatorModes.add, 6.4);
-		Assertions.assertEquals(8.4, calculator.calculateBi(Calculator.BiOperatorModes.add, 2.0));
-		Assertions.assertEquals(NaN, calculator.reset());		
-	}
-	
-	@Test
-	void CalculateMonoSquareTest() {
-		Calculator calculator = new Calculator();
-		Assertions.assertEquals(9.0, calculator.calculateMono(Calculator.MonoOperatorModes.square, 3.0));
-	}
-	
-	@Test
-	void CalculateMonoSquareRootTest() {
-		Calculator calculator = new Calculator();
-		Assertions.assertEquals(5.0, calculator.calculateMono(Calculator.MonoOperatorModes.squareRoot, 25.0));
-	}
-	
-	@Test
-	void CalculateMonoOneDividedByTest() {
-		Calculator calculator = new Calculator();
-		Assertions.assertEquals(0.10, calculator.calculateMono(Calculator.MonoOperatorModes.oneDividedBy, 10.0));
-	}
-	
-	@Test
-	void CalculateMonoSinTest() {
-		Calculator calculator = new Calculator();
-		Assertions.assertEquals(0.5, calculator.calculateMono(Calculator.MonoOperatorModes.sin, java.lang.Math.PI / 6), 0.0000000001);
-	}
-	
-	@Test
-	void CalculateMonoCosTest() {
-		Calculator calculator = new Calculator();
-		Assertions.assertEquals(0.5, calculator.calculateMono(Calculator.MonoOperatorModes.cos, java.lang.Math.PI / 3), 0.0000000001);
-	}
-	
-	@Test
-	void CalculateMonoTanTest() {
-		Calculator calculator = new Calculator();
-		Assertions.assertEquals(1.0, calculator.calculateMono(Calculator.MonoOperatorModes.tan, java.lang.Math.PI / 4), 0.0000000001);
-	}
-	
-	@Test
-	void CalculateMonoLogTest() {
-		Calculator calculator = new Calculator();
-		Assertions.assertEquals(2.0, calculator.calculateMono(Calculator.MonoOperatorModes.log, 100.0));
-	}
-	
-	@Test
-	void CalculateMonoRateTest() {
-		Calculator calculator = new Calculator();
-		Assertions.assertEquals(.75, calculator.calculateMono(Calculator.MonoOperatorModes.rate, 75.0));
-	}
-	
-	@Test
-	void CalculateMonoAbsTest() {
-		Calculator calculator = new Calculator();
-		Assertions.assertEquals(3.0, calculator.calculateMono(Calculator.MonoOperatorModes.abs, -3.0));
-		Assertions.assertEquals(3.0, calculator.calculateMono(Calculator.MonoOperatorModes.abs, 3.0));
-	}
 
+    // Tests the "x to the power of y" binary operation
+    @Test
+    void calculateBiXPowerYTest() {
+        Calculator calculator = new Calculator();
+        calculator.calculateBi(Calculator.BiOperatorModes.xpowerofy, 2.0);
+        Assertions.assertEquals(8.0, calculator.calculateBi(Calculator.BiOperatorModes.normal, 3.0)); // 2^3
+    }
+
+    // Tests natural logarithm (ln) of 1, which should be 0
+    @Test
+    void calculateMonoLnTest() {
+        Calculator calculator = new Calculator();
+        Assertions.assertEquals(0, calculator.calculateMono(Calculator.MonoOperatorModes.ln, 1.0)); // ln(1)
+    }
+
+    // Tests tangent of 90 degrees, which is undefined (NaN)
+    @Test
+    void calculateMonoTanUndefinedTest() {
+        Calculator calculator = new Calculator();
+        Assertions.assertEquals(NaN, calculator.calculateMono(Calculator.MonoOperatorModes.tan, 90.0)); // tan(90)
+    }
+
+    // Tests tangent of 0, which should be 0
+    @Test
+    void calculateMonoTanZeroZeroTest() {
+        Calculator calculator = new Calculator();
+        Assertions.assertEquals(0.0, calculator.calculateMono(Calculator.MonoOperatorModes.tan, 0.0)); // tan(0)
+    }
+
+    // Tests tangent of 180, which should be 0
+    @Test
+    void calculateMonoTan180ZeroTest() {
+        Calculator calculator = new Calculator();
+        Assertions.assertEquals(0.0, calculator.calculateMono(Calculator.MonoOperatorModes.tan, 180.0)); // tan(180)
+    }
+
+    // Tests logarithm base 10 of 0, which should be negative infinity
+    @Test
+    void calculateMonoLogZeroTest() {
+        Calculator calculator = new Calculator();
+        Assertions.assertEquals(Double.NEGATIVE_INFINITY, calculator.calculateMono(Calculator.MonoOperatorModes.log, 0.0)); // log(0)
+    }
+
+    // Tests logarithm base 10 of a negative number, which is undefined (NaN)
+    @Test
+    void calculateMonoLogNegativeTest() {
+        Calculator calculator = new Calculator();
+        Assertions.assertEquals(NaN, calculator.calculateMono(Calculator.MonoOperatorModes.log, -2.0)); // log(-2)
+    }
+
+    // Tests natural logarithm of a negative number, which is undefined (NaN)
+    @Test
+    void calculateMonoLnNegativeTest() {
+        Calculator calculator = new Calculator();
+        Assertions.assertEquals(NaN, calculator.calculateMono(Calculator.MonoOperatorModes.ln, -3.0)); // ln(-3)
+    }
+
+    // Tests natural logarithm of 0, which should be negative infinity
+    @Test
+    void calculateMonoLnZeroTest() {
+        Calculator calculator = new Calculator();
+        Assertions.assertEquals(Double.NEGATIVE_INFINITY, calculator.calculateMono(Calculator.MonoOperatorModes.ln, 0.0)); // ln(0)
+    }
+
+    // Tests reciprocal operation (1/x) with 0, which is undefined (NaN)
+    @Test
+    void calculateMonoDivideByZeroTest() {
+        Calculator calculator = new Calculator();
+        Assertions.assertEquals(NaN, calculator.calculateMono(Calculator.MonoOperatorModes.oneDividedBy, 0.0)); // 1/0
+    }
+
+    // Tests division by 0 using binary operation, which is undefined (NaN)
+    @Test
+    void calculateBiDivideTest() {
+        Calculator calculator = new Calculator();
+        calculator.calculateBi(Calculator.BiOperatorModes.divide, 10.0);
+        Assertions.assertEquals(NaN, calculator.calculateBi(Calculator.BiOperatorModes.normal, 0.0)); // 10/0
+    }
+
+    // Tests a sequence of binary operations ending with multiplication
+    @Test
+    void testMultipleOperationsChain() {
+        Calculator calculator = new Calculator();
+        calculator.calculateBi(Calculator.BiOperatorModes.add, 2.0);       // 2
+        calculator.calculateBi(Calculator.BiOperatorModes.multiply, 3.0);  // 2 * 3 = 6
+        Assertions.assertEquals(18.0, calculator.calculateEqual(3.0));     // 6 * 3 = 18
+    }
+
+    // Tests square root of a negative number, which is undefined (NaN)
+    @Test
+    void calculateMonoSqrtNegativeTest() {
+        Calculator calculator = new Calculator();
+        Assertions.assertEquals(NaN, calculator.calculateMono(Calculator.MonoOperatorModes.squareRoot, -9.0)); // sqrt(-9)
+    }
+
+    // Tests equality after addition
+    @Test
+    void testEqualAfterAddition() {
+        Calculator calculator = new Calculator();
+        calculator.calculateBi(Calculator.BiOperatorModes.add, 5.0);
+        Assertions.assertEquals(10.0, calculator.calculateEqual(5.0)); // 5 + 5
+    }
+
+    // Tests equality after subtraction
+    @Test
+    void testEqualAfterSubtraction() {
+        Calculator calculator = new Calculator();
+        calculator.calculateBi(Calculator.BiOperatorModes.minus, 8.0);
+        Assertions.assertEquals(3.0, calculator.calculateEqual(5.0)); // 8 - 5
+    }
+
+    // Tests equality after multiplication
+    @Test
+    void testEqualAfterMultiplication() {
+        Calculator calculator = new Calculator();
+        calculator.calculateBi(Calculator.BiOperatorModes.multiply, 4.0);
+        Assertions.assertEquals(20.0, calculator.calculateEqual(5.0)); // 4 * 5
+    }
+
+    // Tests equality after division
+    @Test
+    void testEqualAfterDivision() {
+        Calculator calculator = new Calculator();
+        calculator.calculateBi(Calculator.BiOperatorModes.divide, 10.0);
+        Assertions.assertEquals(2.0, calculator.calculateEqual(5.0)); // 10 / 5
+    }
+
+    // Tests equality after exponentiation
+    @Test
+    void testEqualAfterPower() {
+        Calculator calculator = new Calculator();
+        calculator.calculateBi(Calculator.BiOperatorModes.xpowerofy, 2.0);
+        Assertions.assertEquals(32.0, calculator.calculateEqual(5.0)); // 2^5
+    }
+
+    // Tests normal binary operation mode (should return NaN)
+    @Test
+    void testNormalOperation() {
+        Calculator calculator = new Calculator();
+        calculator.calculateBi(Calculator.BiOperatorModes.normal, 5.0);
+        Assertions.assertEquals(NaN, calculator.calculateEqual(5.0));
+    }
+
+    // Tests addition followed by immediate evaluation (normal mode)
+    @Test
+    void calculateBiAddTest() {
+        Calculator calculator = new Calculator();
+        calculator.calculateBi(Calculator.BiOperatorModes.add, 2.5);
+        Assertions.assertEquals(2.5, calculator.calculateBi(Calculator.BiOperatorModes.normal, 0.0)); // 2.5 + 0
+    }
 }