Merge branch 'radusalagean-bugfix/equation_solver_precision_dec_2020'

Merging pull request
ame0011 · Jan 12, 2021 · eb2a215 · eb2a215
2 parents 0bb2f43 + adbfb71
commit eb2a215
Show file tree

Hide file tree

Showing 3 changed files with 313 additions and 14 deletions.
diff --git a/app/build.gradle b/app/build.gradle
@@ -128,6 +128,7 @@ dependencies {
     osmImplementation 'org.osmdroid:osmdroid-android:6.1.1'
     // test dependencies (local tests)
     testImplementation 'junit:junit:4.12'
+    testImplementation 'org.mockito:mockito-core:3.6.28'
     // android test dependencies (on-device tests)
     androidTestImplementation 'junit:junit:4.12'
     androidTestImplementation 'androidx.test:core:1.2.0'

diff --git a/app/src/main/java/com/oriondev/moneywallet/utils/EquationSolver.java b/app/src/main/java/com/oriondev/moneywallet/utils/EquationSolver.java
@@ -21,11 +21,11 @@
 
 import android.os.Bundle;
 
+import androidx.annotation.VisibleForTesting;
+
 import com.oriondev.moneywallet.model.CurrencyUnit;
 
 import java.math.BigDecimal;
-import java.math.MathContext;
-import java.math.RoundingMode;
 
 /**
  * Created by andrea on 31/03/18.
@@ -39,10 +39,12 @@ public class EquationSolver {
 
     private final Controller mController;
 
-    private String mFirstNumber;
+    @VisibleForTesting
+    /*package-local*/ String mFirstNumber;
     private String mSecondNumber;
     private Operation mOperation;
-    private CurrencyUnit mCurrency;
+    @VisibleForTesting
+    /*package-local*/ CurrencyUnit mCurrency;
 
     public EquationSolver(Bundle savedInstanceState, Controller controller) {
         mController = controller;
@@ -177,17 +179,11 @@ public long getResult() {
             // Error occurred during calculation
             return 0L;
         }
-        double parsedNumber = parseNumber(mFirstNumber).doubleValue();
-        if (!Double.isInfinite(parsedNumber) && !Double.isNaN(parsedNumber)) {
-            BigDecimal number = new BigDecimal(parsedNumber, MathContext.DECIMAL64);
-            if (mCurrency != null) {
-                BigDecimal multiplier = new BigDecimal(Math.pow(10, mCurrency.getDecimals()));
-                BigDecimal result = number.multiply(multiplier);
-                return result.longValue();
-            }
-            return number.longValue();
+        BigDecimal parsedNumber = parseNumber(mFirstNumber);
+        if (mCurrency != null) {
+            return parsedNumber.movePointRight(mCurrency.getDecimals()).longValue();
         }
-        return 0L;
+        return parsedNumber.longValue();
     }
 
     private BigDecimal parseNumber(String number) {

diff --git a/app/src/test/java/com/oriondev/moneywallet/utils/EquationSolverTest.java b/app/src/test/java/com/oriondev/moneywallet/utils/EquationSolverTest.java
@@ -0,0 +1,302 @@
+package com.oriondev.moneywallet.utils;
+
+import com.oriondev.moneywallet.model.CurrencyUnit;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import static org.junit.Assert.assertEquals;
+
+@RunWith(MockitoJUnitRunner.class)
+public class EquationSolverTest {
+
+    @InjectMocks
+    private EquationSolver equationSolver;
+
+    private void mockCurrencyUnit(int decimals) {
+        equationSolver.mCurrency = new CurrencyUnit("", "", "", decimals);
+    }
+
+    /*
+    Order of tests:
+    For each supported currency based on decimal count:
+    - Test zero value input
+    - Test positive value input with expected number of decimals
+    - Test negative value input with expected number of decimals
+    - Test positive value input with the last decimal missing (except for zero decimal currency)
+    - Test negative value input with the last decimal missing (except for zero decimal currency)
+    - Test positive value input with an extra decimal
+    - Test negative value input with an extra decimal
+     */
+
+    // Zero Decimal Currency
+
+    @Test
+    public void testGetResult_zeroDecimalCurrencyAndZeroValue() {
+        mockCurrencyUnit(0);
+        equationSolver.mFirstNumber = "0";
+
+        long result = equationSolver.getResult();
+
+        assertEquals(result, 0L);
+    }
+
+    @Test
+    public void testGetResult_zeroDecimalCurrencyAndPositiveValue() {
+        mockCurrencyUnit(0);
+        equationSolver.mFirstNumber = "64";
+
+        long result = equationSolver.getResult();
+
+        assertEquals(result, 64L);
+    }
+
+    @Test
+    public void testGetResult_zeroDecimalCurrencyAndNegativeValue() {
+        mockCurrencyUnit(0);
+        equationSolver.mFirstNumber = "-64";
+
+        long result = equationSolver.getResult();
+
+        assertEquals(result, -64L);
+    }
+
+    @Test
+    public void testGetResult_zeroDecimalCurrencyAndPositiveValueWithExtraDecimal() {
+        mockCurrencyUnit(0);
+        equationSolver.mFirstNumber = "64.9";
+
+        long result = equationSolver.getResult();
+
+        assertEquals(result, 64L);
+    }
+
+    @Test
+    public void testGetResult_zeroDecimalCurrencyAndNegativeValueWithExtraDecimal() {
+        mockCurrencyUnit(0);
+        equationSolver.mFirstNumber = "-64.9";
+
+        long result = equationSolver.getResult();
+
+        assertEquals(result, -64L);
+    }
+
+    // One Decimal Currency
+
+    @Test
+    public void testGetResult_oneDecimalCurrencyAndZeroValue() {
+        mockCurrencyUnit(1);
+        equationSolver.mFirstNumber = "0";
+
+        long result = equationSolver.getResult();
+
+        assertEquals(result, 0L);
+    }
+
+    @Test
+    public void testGetResult_oneDecimalCurrencyAndPositiveValue() {
+        mockCurrencyUnit(1);
+        equationSolver.mFirstNumber = "64.9";
+
+        long result = equationSolver.getResult();
+
+        assertEquals(result, 649L);
+    }
+
+    @Test
+    public void testGetResult_oneDecimalCurrencyAndNegativeValue() {
+        mockCurrencyUnit(1);
+        equationSolver.mFirstNumber = "-64.9";
+
+        long result = equationSolver.getResult();
+
+        assertEquals(result, -649L);
+    }
+
+    @Test
+    public void testGetResult_oneDecimalCurrencyAndPositiveValueWithMissingLastDecimal() {
+        mockCurrencyUnit(1);
+        equationSolver.mFirstNumber = "64";
+
+        long result = equationSolver.getResult();
+
+        assertEquals(result, 640L);
+    }
+
+    @Test
+    public void testGetResult_oneDecimalCurrencyAndNegativeValueWithMissingLastDecimal() {
+        mockCurrencyUnit(1);
+        equationSolver.mFirstNumber = "-64";
+
+        long result = equationSolver.getResult();
+
+        assertEquals(result, -640L);
+    }
+
+    @Test
+    public void testGetResult_oneDecimalCurrencyAndPositiveValueWithExtraDecimal() {
+        mockCurrencyUnit(1);
+        equationSolver.mFirstNumber = "64.99";
+
+        long result = equationSolver.getResult();
+
+        assertEquals(result, 649L);
+    }
+
+    @Test
+    public void testGetResult_oneDecimalCurrencyAndNegativeValueWithExtraDecimal() {
+        mockCurrencyUnit(1);
+        equationSolver.mFirstNumber = "-64.99";
+
+        long result = equationSolver.getResult();
+
+        assertEquals(result, -649L);
+    }
+
+    // Two Decimal Currency
+
+    @Test
+    public void testGetResult_towDecimalCurrencyAndZeroValue() {
+        mockCurrencyUnit(2);
+        equationSolver.mFirstNumber = "0";
+
+        long result = equationSolver.getResult();
+
+        assertEquals(result, 0L);
+    }
+
+    @Test
+    public void testGetResult_towDecimalCurrencyAndPositiveValue() {
+        mockCurrencyUnit(2);
+        equationSolver.mFirstNumber = "64.99";
+
+        long result = equationSolver.getResult();
+
+        assertEquals(result, 6499L);
+    }
+
+    @Test
+    public void testGetResult_towDecimalCurrencyAndNegativeValue() {
+        mockCurrencyUnit(2);
+        equationSolver.mFirstNumber = "-64.99";
+
+        long result = equationSolver.getResult();
+
+        assertEquals(result, -6499L);
+    }
+
+    @Test
+    public void testGetResult_towDecimalCurrencyAndPositiveValueWithMissingLastDecimal() {
+        mockCurrencyUnit(2);
+        equationSolver.mFirstNumber = "64.9";
+
+        long result = equationSolver.getResult();
+
+        assertEquals(result, 6490L);
+    }
+
+    @Test
+    public void testGetResult_towDecimalCurrencyAndNegativeValueWithMissingLastDecimal() {
+        mockCurrencyUnit(2);
+        equationSolver.mFirstNumber = "-64.9";
+
+        long result = equationSolver.getResult();
+
+        assertEquals(result, -6490L);
+    }
+
+    @Test
+    public void testGetResult_towDecimalCurrencyAndPositiveValueWithExtraDecimal() {
+        mockCurrencyUnit(2);
+        equationSolver.mFirstNumber = "64.999";
+
+        long result = equationSolver.getResult();
+
+        assertEquals(result, 6499L);
+    }
+
+    @Test
+    public void testGetResult_towDecimalCurrencyAndNegativeValueWithExtraDecimal() {
+        mockCurrencyUnit(2);
+        equationSolver.mFirstNumber = "-64.999";
+
+        long result = equationSolver.getResult();
+
+        assertEquals(result, -6499L);
+    }
+
+
+    // Three Decimal Currency
+
+    @Test
+    public void testGetResult_threeDecimalCurrencyAndZeroValue() {
+        mockCurrencyUnit(3);
+        equationSolver.mFirstNumber = "0";
+
+        long result = equationSolver.getResult();
+
+        assertEquals(result, 0L);
+    }
+
+    @Test
+    public void testGetResult_threeDecimalCurrencyAndPositiveValue() {
+        mockCurrencyUnit(3);
+        equationSolver.mFirstNumber = "64.999";
+
+        long result = equationSolver.getResult();
+
+        assertEquals(result, 64999L);
+    }
+
+    @Test
+    public void testGetResult_threeDecimalCurrencyAndNegativeValue() {
+        mockCurrencyUnit(3);
+        equationSolver.mFirstNumber = "-64.999";
+
+        long result = equationSolver.getResult();
+
+        assertEquals(result, -64999L);
+    }
+
+    @Test
+    public void testGetResult_threeDecimalCurrencyAndPositiveValueWithMissingLastDecimal() {
+        mockCurrencyUnit(3);
+        equationSolver.mFirstNumber = "64.99";
+
+        long result = equationSolver.getResult();
+
+        assertEquals(result, 64990L);
+    }
+
+    @Test
+    public void testGetResult_threeDecimalCurrencyAndNegativeValueWithMissingLastDecimal() {
+        mockCurrencyUnit(3);
+        equationSolver.mFirstNumber = "-64.99";
+
+        long result = equationSolver.getResult();
+
+        assertEquals(result, -64990L);
+    }
+
+    @Test
+    public void testGetResult_threeDecimalCurrencyAndPositiveValueWithExtraDecimal() {
+        mockCurrencyUnit(3);
+        equationSolver.mFirstNumber = "64.9999";
+
+        long result = equationSolver.getResult();
+
+        assertEquals(result, 64999L);
+    }
+
+    @Test
+    public void testGetResult_threeDecimalCurrencyAndNegativeValueWithExtraDecimal() {
+        mockCurrencyUnit(3);
+        equationSolver.mFirstNumber = "-64.9999";
+
+        long result = equationSolver.getResult();
+
+        assertEquals(result, -64999L);
+    }
+}