From 2751f119b423b316be7621f8794faba4d5fa492c Mon Sep 17 00:00:00 2001 From: Gustavo Martins Date: Wed, 30 Apr 2025 22:55:58 -0300 Subject: [PATCH 1/2] test: improve test coverage from 83% to 96% Co-authored-by: Mattok Co-authored-by: Kaike Co-authored-by: Girotto --- .../CalculatorTest.java | 158 +++++++++++------- 1 file changed, 99 insertions(+), 59 deletions(-) diff --git a/src/simplejavacalculatorTest/CalculatorTest.java b/src/simplejavacalculatorTest/CalculatorTest.java index 1ea20f7..1330463 100755 --- a/src/simplejavacalculatorTest/CalculatorTest.java +++ b/src/simplejavacalculatorTest/CalculatorTest.java @@ -5,115 +5,155 @@ import static java.lang.Double.NaN; import java.lang.Math; - import simplejavacalculator.Calculator; class CalculatorTest { - + + // Teste da operação "Elevado a" @Test - void calculateBiNormalTest() { + void calculateBiXPowerYTest() { Calculator calculator = new Calculator(); - calculator.calculateBi(Calculator.BiOperatorModes.normal, 2.0); - Assertions.assertEquals(NaN, calculator.calculateBi(Calculator.BiOperatorModes.normal, 3.0)); - } - + calculator.calculateBi(Calculator.BiOperatorModes.xpowerofy, 2.0); + Assertions.assertEquals(8.0, calculator.calculateBi(Calculator.BiOperatorModes.normal, 3.0)); // 2^3 + } + + // Teste da operação Ln @Test - void calculateBiAddTest() { + void calculateMonoLnTest() { Calculator calculator = new Calculator(); - calculator.calculateBi(Calculator.BiOperatorModes.add, 3.0); - Assertions.assertEquals(5.5, calculator.calculateBi(Calculator.BiOperatorModes.normal, 2.5)); + Assertions.assertEquals(0, calculator.calculateMono(Calculator.MonoOperatorModes.ln, 1.0)); // ln1 } - + + // Teste da operação Tangente resultando em NaN @Test - void calculateBiMinusTest() { + void calculateMonoTanUndefinedTest() { Calculator calculator = new Calculator(); - calculator.calculateBi(Calculator.BiOperatorModes.minus, 3.1415); - Assertions.assertEquals(2.0415, calculator.calculateBi(Calculator.BiOperatorModes.normal, 1.1)); + Assertions.assertEquals(NaN, calculator.calculateMono(Calculator.MonoOperatorModes.tan, 90.0)); // tan(90) } + // Teste da operação Tangente de zero resultando em zero @Test - void calculateBiMultiplyTest() { + void calculateMonoTanZeroZeroTest() { Calculator calculator = new Calculator(); - calculator.calculateBi(Calculator.BiOperatorModes.multiply, 3.2); - Assertions.assertEquals(6.4, calculator.calculateBi(Calculator.BiOperatorModes.normal, 2.0)); + Assertions.assertEquals(0.0, calculator.calculateMono(Calculator.MonoOperatorModes.tan, 0.0)); // tan(0) } - + + // Teste da operação Tangente de 180 resultando em zero @Test - void calculateBiDivideTest() { + void calculateMonoTan180ZeroTest() { Calculator calculator = new Calculator(); - calculator.calculateBi(Calculator.BiOperatorModes.divide, 6.4); - Assertions.assertEquals(3.2, calculator.calculateBi(Calculator.BiOperatorModes.normal, 2.0)); + Assertions.assertEquals(0.0, calculator.calculateMono(Calculator.MonoOperatorModes.tan, 180.0)); // tan(180) } - + + // Teste da operação Log com o valor 0 @Test - void calculateEqualTest() { + void calculateMonoLogZeroTest() { 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)); + Assertions.assertEquals(Double.NEGATIVE_INFINITY, calculator.calculateMono(Calculator.MonoOperatorModes.log, 0.0)); // log0 } - + + // Teste da operação Log com valor negativo @Test - void resetTest() { + void calculateMonoLogNegativeTest() { 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()); + Assertions.assertEquals(NaN, calculator.calculateMono(Calculator.MonoOperatorModes.log, -2.0)); // log-2 } - + + // Teste da operação ln com valor negativo @Test - void CalculateMonoSquareTest() { + void calculateMonoLnNegativeTest() { Calculator calculator = new Calculator(); - Assertions.assertEquals(9.0, calculator.calculateMono(Calculator.MonoOperatorModes.square, 3.0)); + Assertions.assertEquals(NaN, calculator.calculateMono(Calculator.MonoOperatorModes.ln, -3.0)); // ln-3 } - + + // Teste da operação ln com o valor 0 @Test - void CalculateMonoSquareRootTest() { + void calculateMonoLnZeroTest() { Calculator calculator = new Calculator(); - Assertions.assertEquals(5.0, calculator.calculateMono(Calculator.MonoOperatorModes.squareRoot, 25.0)); + Assertions.assertEquals(Double.NEGATIVE_INFINITY, calculator.calculateMono(Calculator.MonoOperatorModes.ln, 0.0)); // ln0 } - + + // Teste da operação "um dividido por" por 0 @Test - void CalculateMonoOneDividedByTest() { + void calculateMonoDivideByZeroTest() { Calculator calculator = new Calculator(); - Assertions.assertEquals(0.10, calculator.calculateMono(Calculator.MonoOperatorModes.oneDividedBy, 10.0)); + Assertions.assertEquals(NaN, calculator.calculateMono(Calculator.MonoOperatorModes.oneDividedBy, 0.0)); // 1/0 } - + + // Teste da operação de divisão por 0 @Test - void CalculateMonoSinTest() { + void calculateBiDivideTest() { Calculator calculator = new Calculator(); - Assertions.assertEquals(0.5, calculator.calculateMono(Calculator.MonoOperatorModes.sin, java.lang.Math.PI / 6), 0.0000000001); + calculator.calculateBi(Calculator.BiOperatorModes.divide, 10.0); + Assertions.assertEquals(NaN, calculator.calculateBi(Calculator.BiOperatorModes.normal, 0.0)); // 10/0 } - + + // Teste de multiplas operações @Test - void CalculateMonoCosTest() { + void testMultipleOperationsChain() { Calculator calculator = new Calculator(); - Assertions.assertEquals(0.5, calculator.calculateMono(Calculator.MonoOperatorModes.cos, java.lang.Math.PI / 3), 0.0000000001); + calculator.calculateBi(Calculator.BiOperatorModes.add, 2.0); // 2 + calculator.calculateBi(Calculator.BiOperatorModes.multiply, 3.0); // * 3 = 6 + Assertions.assertEquals(18.0, calculator.calculateEqual(3.0)); // * 3 = 18 (Vezes novamente por ser o ultimo + // operador) } - + + // Teste da operação raiz quadrada com valor negativo +@Test +void calculateMonoSqrtNegativeTest() { + Calculator calculator = new Calculator(); + Assertions.assertEquals(NaN, calculator.calculateMono(Calculator.MonoOperatorModes.squareRoot, -9.0)); //sqrt(-9) +} + + // Teste de unica entrada e operação "Igual" + @Test - void CalculateMonoTanTest() { + void testEqualAfterAddition() { Calculator calculator = new Calculator(); - Assertions.assertEquals(1.0, calculator.calculateMono(Calculator.MonoOperatorModes.tan, java.lang.Math.PI / 4), 0.0000000001); + calculator.calculateBi(Calculator.BiOperatorModes.add, 5.0); + Assertions.assertEquals(10.0, calculator.calculateEqual(5.0)); // 5 + 5 } - + @Test - void CalculateMonoLogTest() { + void testEqualAfterSubtraction() { Calculator calculator = new Calculator(); - Assertions.assertEquals(2.0, calculator.calculateMono(Calculator.MonoOperatorModes.log, 100.0)); + calculator.calculateBi(Calculator.BiOperatorModes.minus, 8.0); + Assertions.assertEquals(3.0, calculator.calculateEqual(5.0)); // 8 - 5 } - + @Test - void CalculateMonoRateTest() { + void testEqualAfterMultiplication() { Calculator calculator = new Calculator(); - Assertions.assertEquals(.75, calculator.calculateMono(Calculator.MonoOperatorModes.rate, 75.0)); + calculator.calculateBi(Calculator.BiOperatorModes.multiply, 4.0); + Assertions.assertEquals(20.0, calculator.calculateEqual(5.0)); // 4 * 5 } - + + @Test + void testEqualAfterDivision() { + Calculator calculator = new Calculator(); + calculator.calculateBi(Calculator.BiOperatorModes.divide, 10.0); + Assertions.assertEquals(2.0, calculator.calculateEqual(5.0)); // 10 / 5 + } + @Test - void CalculateMonoAbsTest() { + void testEqualAfterPower() { 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)); + calculator.calculateBi(Calculator.BiOperatorModes.xpowerofy, 2.0); + Assertions.assertEquals(32.0, calculator.calculateEqual(5.0)); // 2^5 } + @Test + void testNormalOperation() { + Calculator calculator = new Calculator(); + calculator.calculateBi(Calculator.BiOperatorModes.normal, 5.0); + Assertions.assertEquals(NaN, calculator.calculateEqual(5.0)); + } + + @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)); + } + } From 8f79f31248faf997ac3e237ca986939aeba3a6d2 Mon Sep 17 00:00:00 2001 From: Gustavo Martins Date: Wed, 30 Apr 2025 23:17:33 -0300 Subject: [PATCH 2/2] style: improve comments and tab --- .../CalculatorTest.java | 278 +++++++++--------- 1 file changed, 140 insertions(+), 138 deletions(-) diff --git a/src/simplejavacalculatorTest/CalculatorTest.java b/src/simplejavacalculatorTest/CalculatorTest.java index 1330463..849f29a 100755 --- a/src/simplejavacalculatorTest/CalculatorTest.java +++ b/src/simplejavacalculatorTest/CalculatorTest.java @@ -3,157 +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 { - // Teste da operação "Elevado a" - @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 - } - - // Teste da operação Ln - @Test - void calculateMonoLnTest() { - Calculator calculator = new Calculator(); - Assertions.assertEquals(0, calculator.calculateMono(Calculator.MonoOperatorModes.ln, 1.0)); // ln1 - } - - // Teste da operação Tangente resultando em NaN - @Test - void calculateMonoTanUndefinedTest() { - Calculator calculator = new Calculator(); - Assertions.assertEquals(NaN, calculator.calculateMono(Calculator.MonoOperatorModes.tan, 90.0)); // tan(90) - } - - // Teste da operação Tangente de zero resultando em zero - @Test - void calculateMonoTanZeroZeroTest() { - Calculator calculator = new Calculator(); - Assertions.assertEquals(0.0, calculator.calculateMono(Calculator.MonoOperatorModes.tan, 0.0)); // tan(0) - } - - // Teste da operação Tangente de 180 resultando em zero - @Test - void calculateMonoTan180ZeroTest() { - Calculator calculator = new Calculator(); - Assertions.assertEquals(0.0, calculator.calculateMono(Calculator.MonoOperatorModes.tan, 180.0)); // tan(180) - } - - // Teste da operação Log com o valor 0 - @Test - void calculateMonoLogZeroTest() { - Calculator calculator = new Calculator(); - Assertions.assertEquals(Double.NEGATIVE_INFINITY, calculator.calculateMono(Calculator.MonoOperatorModes.log, 0.0)); // log0 - } - - // Teste da operação Log com valor negativo - @Test - void calculateMonoLogNegativeTest() { - Calculator calculator = new Calculator(); - Assertions.assertEquals(NaN, calculator.calculateMono(Calculator.MonoOperatorModes.log, -2.0)); // log-2 - } - - // Teste da operação ln com valor negativo - @Test - void calculateMonoLnNegativeTest() { - Calculator calculator = new Calculator(); - Assertions.assertEquals(NaN, calculator.calculateMono(Calculator.MonoOperatorModes.ln, -3.0)); // ln-3 - } - - // Teste da operação ln com o valor 0 - @Test - void calculateMonoLnZeroTest() { - Calculator calculator = new Calculator(); - Assertions.assertEquals(Double.NEGATIVE_INFINITY, calculator.calculateMono(Calculator.MonoOperatorModes.ln, 0.0)); // ln0 - } - - // Teste da operação "um dividido por" por 0 - @Test - void calculateMonoDivideByZeroTest() { - Calculator calculator = new Calculator(); - Assertions.assertEquals(NaN, calculator.calculateMono(Calculator.MonoOperatorModes.oneDividedBy, 0.0)); // 1/0 - } - - // Teste da operação de divisão por 0 - @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 - } - - // Teste de multiplas operações - @Test - void testMultipleOperationsChain() { - Calculator calculator = new Calculator(); - calculator.calculateBi(Calculator.BiOperatorModes.add, 2.0); // 2 - calculator.calculateBi(Calculator.BiOperatorModes.multiply, 3.0); // * 3 = 6 - Assertions.assertEquals(18.0, calculator.calculateEqual(3.0)); // * 3 = 18 (Vezes novamente por ser o ultimo - // operador) - } - - // Teste da operação raiz quadrada com valor negativo -@Test -void calculateMonoSqrtNegativeTest() { - Calculator calculator = new Calculator(); - Assertions.assertEquals(NaN, calculator.calculateMono(Calculator.MonoOperatorModes.squareRoot, -9.0)); //sqrt(-9) -} + // 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 + } - // Teste de unica entrada e operação "Igual" - - @Test - void testEqualAfterAddition() { - Calculator calculator = new Calculator(); - calculator.calculateBi(Calculator.BiOperatorModes.add, 5.0); - Assertions.assertEquals(10.0, calculator.calculateEqual(5.0)); // 5 + 5 - } - - @Test - void testEqualAfterSubtraction() { - Calculator calculator = new Calculator(); - calculator.calculateBi(Calculator.BiOperatorModes.minus, 8.0); - Assertions.assertEquals(3.0, calculator.calculateEqual(5.0)); // 8 - 5 - } - - @Test - void testEqualAfterMultiplication() { - Calculator calculator = new Calculator(); - calculator.calculateBi(Calculator.BiOperatorModes.multiply, 4.0); - Assertions.assertEquals(20.0, calculator.calculateEqual(5.0)); // 4 * 5 - } - - @Test - void testEqualAfterDivision() { - Calculator calculator = new Calculator(); - calculator.calculateBi(Calculator.BiOperatorModes.divide, 10.0); - Assertions.assertEquals(2.0, calculator.calculateEqual(5.0)); // 10 / 5 - } - - @Test - void testEqualAfterPower() { - Calculator calculator = new Calculator(); - calculator.calculateBi(Calculator.BiOperatorModes.xpowerofy, 2.0); - Assertions.assertEquals(32.0, calculator.calculateEqual(5.0)); // 2^5 - } - - @Test + // 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)); - } + } - @Test + // 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)); + Assertions.assertEquals(2.5, calculator.calculateBi(Calculator.BiOperatorModes.normal, 0.0)); // 2.5 + 0 } - }