diff --git a/bin/CalculatorUtils.class b/bin/CalculatorUtils.class new file mode 100644 index 0000000..f10f1f5 Binary files /dev/null and b/bin/CalculatorUtils.class differ diff --git a/bin/NumberObject.class b/bin/NumberObject.class new file mode 100644 index 0000000..b440539 Binary files /dev/null and b/bin/NumberObject.class differ diff --git a/bin/StringCalculator.class b/bin/StringCalculator.class index a937b0c..e3f94ff 100644 Binary files a/bin/StringCalculator.class and b/bin/StringCalculator.class differ diff --git a/bin/StringCalculatorTest.class b/bin/StringCalculatorTest.class index d44b83f..2d9b3d1 100644 Binary files a/bin/StringCalculatorTest.class and b/bin/StringCalculatorTest.class differ diff --git a/src/CalculatorUtils.java b/src/CalculatorUtils.java new file mode 100644 index 0000000..494035f --- /dev/null +++ b/src/CalculatorUtils.java @@ -0,0 +1,27 @@ +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +// Refactor: Extract method + +public class CalculatorUtils { + + // Beautify this class and handle errors + public static String[] convertToNumberStringArray(String numbers) { + + String[] arrayOfNumbers = numbers.split("\\s*,\\s*"); + + return arrayOfNumbers; + } + + public static String[] removeEmptyStrings(String[] numbersArray) { + + List myList = new ArrayList(Arrays.asList(numbersArray)); + myList.remove(""); + + String[] myStrArray = myList.toArray(new String[0]); + + return myStrArray; + } + +} diff --git a/src/NumberObject.java b/src/NumberObject.java new file mode 100644 index 0000000..8662812 --- /dev/null +++ b/src/NumberObject.java @@ -0,0 +1,59 @@ + +// Refactor: Introduce Parameter Object +public class NumberObject { + private String numbersStr; + private int value; + private String[] numbersArray; + + public NumberObject(String numbersStr) { + this.numbersStr = numbersStr; + this.value = 0; + this.numbersArray = null; + } + + public String getNumbersStr() { + return this.numbersStr; + } + + public String[] getNumbersArray() { + return this.numbersArray; + } + + public void setNumbersArray(String[] numbersArray) { + this.numbersArray = numbersArray; + } + + public int getValue() { + return this.value; + } + + public void setValue(int value) { + this.value = value; + } + + // Refactor: BAD SMELL, JDEADORANT MOVED + public boolean isNumberStrValid() { + return getNumbersStr() != null && getNumbersStr() != ""; + } + + // Refactor: Extract method + // Refactor: BAD SMELL, JDEADORANT MOVED + public int calculate() throws StringCalculatorException { + try { + // Remove the "" from the list + setNumbersArray(CalculatorUtils.convertToNumberStringArray(getNumbersStr())); + setNumbersArray(CalculatorUtils.removeEmptyStrings(getNumbersArray())); + + int val = 0; + for (String numberString : getNumbersArray()) { + val += Integer.parseInt(numberString); + } + setValue(val); + } + catch (IllegalArgumentException e) { + throw new StringCalculatorException(); + } + return getValue(); + } + +} \ No newline at end of file diff --git a/src/StringCalculator.java b/src/StringCalculator.java index 487916b..897ef33 100644 --- a/src/StringCalculator.java +++ b/src/StringCalculator.java @@ -1,9 +1,26 @@ +/* +Implement a simple String calculator with a method int Add(string numbers) +1. The method can take 0, 1 or 2 numbers, and will return their sum (for an empty string it will +return 0) for example “” or “1” or “1,2” +2. Add method to handle an unknown amount of numbers +3. Add method to handle new lines between numbers (instead of commas). +1. the following input is ok: “1\n2,3” (will equal 6) +2. the following input is NOT ok: “1,\n” +4. Calling Add with a negative numbers or invalid input (not numbers) will throw an +StringCalculatorException +*/ public class StringCalculator { - public int add(String numbersStr) { - // Returns the sum of the numbers given in numbersStr + // Main function + public int add(String numbersStr) throws StringCalculatorException { - // not yet implemented - return 0; + NumberObject numberObject = new NumberObject(numbersStr); + + int val = 0; + if (numberObject.isNumberStrValid()) { + val = numberObject.calculate(); + } + return val; } + } diff --git a/tests/StringCalculatorTest.java b/tests/StringCalculatorTest.java index 4ec9afe..b5b0c23 100644 --- a/tests/StringCalculatorTest.java +++ b/tests/StringCalculatorTest.java @@ -3,10 +3,122 @@ import org.junit.Test; public class StringCalculatorTest { + + @Test + public void test_add_valid() throws StringCalculatorException{ + // Arrange + StringCalculator calculator = new StringCalculator(); + String testString = "11, 2, , 3, 31"; + + // Act + int returnedValue = calculator.add(testString); + + // Assert + assertEquals(47, returnedValue); + } @Test - public void test() { - fail("Not yet implemented"); + public void test_add_with_zero() throws StringCalculatorException{ + // Arrange + StringCalculator calculator = new StringCalculator(); + String testString = "0, 2, , 3"; + + // Act + int returnedValue = calculator.add(testString); + + // Assert + assertEquals(5, returnedValue); + } + + @Test + public void test_add_zero() throws StringCalculatorException{ + // Arrange + StringCalculator calculator = new StringCalculator(); + String testString = "0, "; + + // Act + int returnedValue = calculator.add(testString); + + // Assert + assertEquals(0, returnedValue); } + @Test (expected = StringCalculatorException.class) + public void test_add_empty() throws StringCalculatorException{ + // Arrange + StringCalculator calculator = new StringCalculator(); + String testString = " "; + + // Act + calculator.add(testString); + } + + @Test + public void test_add_null() throws StringCalculatorException{ + // Arrange + StringCalculator calculator = new StringCalculator(); + + // Act + int returnedValue = calculator.add(null); + + // Assert + assertEquals(0, returnedValue); + } + + @Test + public void test_removeEmptyString() { + // Arrange + String[] testArray = {"21", "1", "", "15"}; + + // Act + String[] returnedArray = CalculatorUtils.removeEmptyStrings(testArray); + + // Assert + String[] expectedArray = {"21", "1", "15"}; + assertArrayEquals(returnedArray, expectedArray); + } + + @Test + public void test_convertToArray() { + // Arrange + String testString = "1,15\n , ,3"; + + // Act + String[] returnedArray = CalculatorUtils.convertToNumberStringArray(testString); + + // Assert + String[] expectedArray = {"1", "15", "", "3"}; + assertArrayEquals(returnedArray, expectedArray); + } + + + @Test + public void test_add_plainString() throws StringCalculatorException{ + // Arrange + StringCalculator calculator = new StringCalculator(); + String testString = "1,40\n, 3"; + + // Act + int returnedValue = calculator.add(testString); + + // Assert + int expected = 44; + assertEquals(expected, returnedValue); + + } + + @Test + public void test_add_plainStringWithEmpty() throws StringCalculatorException{ + // Arrange + StringCalculator calculator = new StringCalculator(); + String testString = " , 2\n , , , , "; + + // Act + int returnedValue = calculator.add(testString); + + // Assert + int expected = 2; + assertEquals(expected, returnedValue); + + } }