String Calculator

pereta/src/NegativesNotAllowedException.java

@@ -0,0 +1,9 @@
+
+public class NegativesNotAllowedException extends RuntimeException{
+
+	private static final long serialVersionUID = 8671376334681410320L;
+
+	public NegativesNotAllowedException(String msg) {
+		super(msg);
+	}
+}

pereta/src/ParserOperands.java

@@ -0,0 +1,47 @@
+import java.util.ArrayList;
+import java.util.List;
+
+
+public class ParserOperands {
+
+	private static final String DEFAULT_REGEX_DELIMITER = ",|\n";
+	private static final String DEFAULT_START_CUSTOM_DELIMITER = "//[";
+	private static final String DEFAULT_END_CUSTOM_DELIMITER = "]\n";
+	private static final String DEFAULT_CUSTOM_DELIMITER_UNION = "\\]\\[";
+	private static final String NEW_LINE = "\n";
+	private static final String UNION = "|";
+
+	private String stringToWork;
+
+	public ParserOperands(){
+		stringToWork = null;
+	}
+
+	public List<String> parse(String string){		
+		this.stringToWork = new String(string);
+
+		List<String> operandos = new ArrayList<String>();
+		if(stringToWork.isEmpty())
+			return operandos;
+
+		String regexDelimiters = parseDelimiters();
+		String[]arrayOperandos = stringToWork.split(regexDelimiters);
+
+		for (String operando : arrayOperandos) {
+			operandos.add(operando);
+		}
+		return operandos;
+	}
+
+	private String parseDelimiters(){
+		if(stringToWork.startsWith(DEFAULT_START_CUSTOM_DELIMITER)){
+			int indexBegin = DEFAULT_START_CUSTOM_DELIMITER.length();
+			int indexEnd = stringToWork.indexOf(DEFAULT_END_CUSTOM_DELIMITER);
+			String delimiter = stringToWork.substring(indexBegin, indexEnd);
+			delimiter = delimiter.replaceAll(DEFAULT_CUSTOM_DELIMITER_UNION, UNION);
+			this.stringToWork = stringToWork.substring(stringToWork.indexOf(NEW_LINE)+1);
+			return delimiter;			
+		}
+		return DEFAULT_REGEX_DELIMITER;
+	}
+}

pereta/src/StringCalculator.java

@@ -0,0 +1,38 @@
+import java.util.ArrayList;
+import java.util.List;
+
+
+public class StringCalculator {
+
+	private ParserOperands parserOperandos;
+	private static final int MAX = 1000;
+
+	public StringCalculator(){
+		parserOperandos = new ParserOperands();
+	}
+
+	public int add(String string) {
+		int result = 0;
+		List<String> operandos = parserOperandos.parse(string);
+
+		checkNegatives(operandos);
+
+		for (String operando : operandos) {
+			if(Integer.parseInt(operando) <= MAX)
+				result += Integer.parseInt(operando);
+		}
+
+		return result;
+	}
+
+	private void checkNegatives(List<String> operandos) {
+		List<String> negatives = new ArrayList<String>();
+		for (String operando : operandos) {
+			if(Integer.parseInt(operando) < 0)
+				negatives.add(operando);
+		}
+		if(negatives.size() > 0){
+			throw new NegativesNotAllowedException("Negatives not allowed " + negatives.toString());
+		}
+	}
+}

pereta/test/StringCalculatorTest.java

@@ -0,0 +1,118 @@
+
+import static org.junit.Assert.*;
+
+import org.junit.Before;
+import org.junit.Test;
+
+public class StringCalculatorTest {
+
+	private StringCalculator calculator;
+
+	@Before
+	public void setUp() throws Exception {
+		calculator = new StringCalculator();
+	}
+
+	@Test
+	public void emptyStringReturnZero(){	
+		int expected = 0;
+
+		int actual = calculator.add("");
+
+		assertEquals(expected, actual);
+	}
+
+	@Test
+	public void addWithANumber(){
+		int expected = 2;
+		int expected2 = 35;
+
+		int actual = this.calculator.add("2");
+		int actual2 = this.calculator.add("35");
+
+		assertEquals(expected, actual);
+		assertEquals(expected2, actual2);
+	}
+
+	@Test
+	public void addWithTwoNumbers(){
+		int expected = 3;
+		int expected2 = 8;
+
+		int actual = this.calculator.add("2,1");
+		int actual2 = this.calculator.add("3,5");
+
+		assertEquals(expected, actual);
+		assertEquals(expected2, actual2);
+	}
+
+	@Test
+	public void addWithUnknownNumbers(){
+		int expected = 4;
+		int expected2 = 54;
+
+		int actual = this.calculator.add("2,1,1");
+		int actual2 = this.calculator.add("3,5,5,41");
+
+		assertEquals(expected, actual);
+		assertEquals(expected2, actual2);
+	}
+
+	@Test
+	public void addWithMultipleDelimiters(){
+		int expected = 4;
+		int expected2 = 54;
+
+		int actual = this.calculator.add("2\n1\n1");
+		int actual2 = this.calculator.add("3,5,5\n41");
+
+		assertEquals(expected, actual);
+		assertEquals(expected2, actual2);
+	}
+
+	@Test
+	public void addWithCustomDelimiter(){
+		String withCustomDelimiter = "//[pereta]\n1pereta2pereta2";
+		int expected = 5;
+
+		int actual = calculator.add(withCustomDelimiter);
+
+		assertEquals(expected, actual);	
+	}
+
+	@Test(expected = NegativesNotAllowedException.class)
+	public void addWithNegativeNumbers(){
+		calculator.add("5,1,-4,-77");	
+	}
+
+	@Test
+	public void addWithNegativeNumbersMessage(){
+		try{
+			calculator.add("5,1,-4,-77");
+		}
+		catch (NegativesNotAllowedException ne) {
+			assertTrue(ne.getMessage().contains("-4") && ne.getMessage().contains("-77"));
+			return;
+		}
+		fail(NegativesNotAllowedException.class.getName()+" deberia haber sido lanzada.");
+	}
+
+	@Test
+	public void addWithMaxNumber(){
+		int expected = 2;
+
+		int actual = this.calculator.add("2,1001");
+
+		assertEquals(expected, actual);
+	}
+
+	@Test
+	public void addWithMultipleCustomDelimiters(){
+		String withMultipleCustomDelimiter = "//[pereta][hola]\n30pereta20pereta2hola5";
+		int expected = 57;
+
+		int actual = calculator.add(withMultipleCustomDelimiter);
+
+		assertEquals(expected, actual);	
+	}
+}