diff --git a/.besouro/20161007164022502/actions.txt b/.besouro/20161007164022502/actions.txt new file mode 100644 index 0000000..d4838de --- /dev/null +++ b/.besouro/20161007164022502/actions.txt @@ -0,0 +1,36 @@ +FileOpenedAction 1475847622795 SpreadsheetTest.java 452 2 7 2 +UnitTestCaseAction 1475847638127 SpreadsheetTest.java OK +UnitTestSessionAction 1475847638127 SpreadsheetTest.java OK +EditAction 1475847712375 SpreadsheetTest.java 441 2 3 1 +CompilationAction 1475847712519 SpreadsheetTest.java +CompilationAction 1475847713842 SpreadsheetTest.java +UnitTestCaseAction 1475847717539 SpreadsheetTest.java FAIL +UnitTestSessionAction 1475847717539 SpreadsheetTest.java FAIL +EditAction 1475847741840 Spreadsheet.java 432 4 4 0 +UnitTestCaseAction 1475847745278 SpreadsheetTest.java OK +UnitTestSessionAction 1475847745278 SpreadsheetTest.java OK +RefactoringAction 1475847752473 SpreadsheetTest.java ADD void test_NumberHandlingNegative()/2 METHOD +RefactoringAction 1475847758984 SpreadsheetTest.java RENAME test_NumberHandlingNegative()/2=>void test_NumberHandlingPositive() METHOD +EditAction 1475847765757 SpreadsheetTest.java 623 3 9 3 +UnitTestCaseAction 1475847769128 SpreadsheetTest.java FAIL +UnitTestSessionAction 1475847769128 SpreadsheetTest.java FAIL +EditAction 1475847827739 Spreadsheet.java 446 4 4 0 +RefactoringAction 1475847835528 SpreadsheetTest.java ADD void test_NumberHandlingPositive()/2 METHOD +RefactoringAction 1475847842539 SpreadsheetTest.java RENAME test_NumberHandlingPositive()/2=>void test_NumberHandlingSigned() METHOD +EditAction 1475847842969 SpreadsheetTest.java 804 4 12 4 +EditAction 1475847850100 SpreadsheetTest.java 807 4 12 4 +UnitTestCaseAction 1475848217412 SpreadsheetTest.java OK +UnitTestSessionAction 1475848217413 SpreadsheetTest.java OK +RefactoringAction 1475848312589 SpreadsheetTest.java ADD void test_NumberHandlingSigned()/2 METHOD +RefactoringAction 1475848317103 SpreadsheetTest.java RENAME test_NumberHandlingSigned()/2=>void test_NumberHandling() METHOD +RefactoringAction 1475848321116 SpreadsheetTest.java RENAME test_NumberHandling()=>void test_NumberHandlingTwoCells() METHOD +RefactoringAction 1475848331127 SpreadsheetTest.java REMOVE test_NumberHandlingTwoCells() METHOD +RefactoringAction 1475848348140 SpreadsheetTest.java ADD void test_NumberHandlingSigned()/2 METHOD +RefactoringAction 1475848355159 SpreadsheetTest.java RENAME test_NumberHandlingSigned()/2=>void test_Incorrect() METHOD +RefactoringAction 1475848357175 SpreadsheetTest.java RENAME test_Incorrect()=>void test_IncorrectInteger() METHOD +EditAction 1475848357363 SpreadsheetTest.java 989 5 15 5 +EditAction 1475848375863 SpreadsheetTest.java 990 5 15 5 +EditAction 1475848394837 SpreadsheetTest.java 995 5 15 5 +UnitTestCaseAction 1475848398079 SpreadsheetTest.java FAIL +UnitTestSessionAction 1475848398080 SpreadsheetTest.java FAIL +EditAction 1475848492364 Spreadsheet.java 449 4 4 0 diff --git a/.besouro/20161007164022502/besouroEpisodes.txt b/.besouro/20161007164022502/besouroEpisodes.txt new file mode 100644 index 0000000..103771c --- /dev/null +++ b/.besouro/20161007164022502/besouroEpisodes.txt @@ -0,0 +1,6 @@ +1475847638127 regression 1 15 true +1475847745278 refactoring 1A 32 true +1475848217413 test-first 3 464 true +1475848217414 test-first 3 464 true +1475848217415 test-last 1 464 false +1475848217416 test-last 1 464 false diff --git a/.besouro/20161007164022502/disagreements.txt b/.besouro/20161007164022502/disagreements.txt new file mode 100644 index 0000000..e69de29 diff --git a/.besouro/20161007164022502/randomHeuristicEpisodes.txt b/.besouro/20161007164022502/randomHeuristicEpisodes.txt new file mode 100644 index 0000000..91084ce --- /dev/null +++ b/.besouro/20161007164022502/randomHeuristicEpisodes.txt @@ -0,0 +1,3 @@ +1475847638127 regression 1 15 true +1475847745278 refactoring 1A 32 true +1475848217413 test-first 3 464 true diff --git a/.besouro/20161007164022502/userComments.txt b/.besouro/20161007164022502/userComments.txt new file mode 100644 index 0000000..e69de29 diff --git a/.besouro/20161007164022502/zorroEpisodes.txt b/.besouro/20161007164022502/zorroEpisodes.txt new file mode 100644 index 0000000..b77b0b2 --- /dev/null +++ b/.besouro/20161007164022502/zorroEpisodes.txt @@ -0,0 +1,3 @@ +1475847638127 regression 1 15 true +1475847745278 refactoring 1A 107 true +1475848217413 test-first 3 472 true diff --git a/bin/.gitignore b/bin/.gitignore new file mode 100644 index 0000000..2079672 --- /dev/null +++ b/bin/.gitignore @@ -0,0 +1,2 @@ +/Spreadsheet.class +/SpreadsheetTest.class diff --git a/bin/Spreadsheet.class b/bin/Spreadsheet.class index 92b411f..394df25 100644 Binary files a/bin/Spreadsheet.class and b/bin/Spreadsheet.class differ diff --git a/bin/SpreadsheetTest.class b/bin/SpreadsheetTest.class index e7086bd..a5cbea2 100644 Binary files a/bin/SpreadsheetTest.class and b/bin/SpreadsheetTest.class differ diff --git a/src/Spreadsheet.java b/src/Spreadsheet.java index e4f120b..7f1094e 100644 --- a/src/Spreadsheet.java +++ b/src/Spreadsheet.java @@ -1,18 +1,82 @@ +import java.util.*; public class Spreadsheet { + + private HashMap cells; + + public Spreadsheet(){ + cells = new HashMap(); + } public String get(String cell) { // to be implemented - return null; + return cells.get(cell); } public void set(String cell, String value) { + // to be implemented + cells.put(cell, value); } public String evaluate(String cell) { // to be implemented - return null; + String ev = cells.get(cell); + if(checkEquation(ev)){ + ev = ev.substring(1); + if(ev.charAt(0) != '\''){ + if(isCircular(cell, cells.get(ev))){ + return "#Circular"; + } + ev = evaluate(ev); + } + } + if(checkFormat(ev)){ + if(ev.charAt(0) == '\''){ + ev = ev.substring(1, ev.length() - 1); + return ev; + } + return ev; + } + return "#Error"; + } + public boolean checkFormat(String cell){ + for(int i = 0; i < cell.length(); i++){ + if(cell.charAt(0) == '-'){ + continue; + } + else if(cell.charAt(0) == '\'' && + cell.charAt(cell.length() - 1) == '\''){ + return true; + } + else if(cell.charAt(i) >= '0' && cell.charAt(i) <= '9'){ + continue; + } + else{ + return false; + } + } + return true; + } + public boolean checkEquation(String cell){ + if(cell.charAt(0) == '='){ + return true; + } + return false; + } + public boolean isCircular(String current, String next){ + boolean circular = false; + if(checkEquation(next)){ + next = next.substring(1); + } + if(current.equals(next)){ + return true; + } + + + return circular; + + } } diff --git a/tests/SpreadsheetTest.java b/tests/SpreadsheetTest.java index 9e0936a..73ebd49 100644 --- a/tests/SpreadsheetTest.java +++ b/tests/SpreadsheetTest.java @@ -7,9 +7,113 @@ public class SpreadsheetTest { @Test - public void test() { - fail("Not yet implemented"); + public void test_SetAndGet() { + Spreadsheet n = new Spreadsheet(); + n.set("A1", "2"); + assertEquals("Should return 2", "2", n.get("A1")); + + } + @Test + public void test_NumberHandlingNegative() { + Spreadsheet n = new Spreadsheet(); + n.set("A1", "-1"); + + assertEquals("Evaluation is not correct", "-1", n.evaluate("A1")); + } + @Test + public void test_NumberHandlingPositive() { + Spreadsheet n = new Spreadsheet(); + n.set("A1", "1"); + + assertEquals("Evaluation is not correct", "1", n.evaluate("A1")); + } + @Test + public void test_NumberHandlingSigned() { + Spreadsheet n = new Spreadsheet(); + + n.set("A1", "1"); + + assertEquals("Evaluation is not correct", "1", n.evaluate("A1")); + } + @Test + public void test_IncorrectInteger() { + Spreadsheet n = new Spreadsheet(); + + n.set("A1", "5A"); + + assertEquals("Evaluation is not correct", "#Error", n.evaluate("A1")); + } + @Test + public void test_String() { + Spreadsheet n = new Spreadsheet(); + + n.set("A1", "'This is correct'"); + + assertEquals("Evaluation is not correct", "This is correct", n.evaluate("A1")); + } + @Test + public void test_StringUnquated() { + Spreadsheet n = new Spreadsheet(); + + n.set("A1", "'This is incorrect"); + + assertEquals("Evaluation is not correct", "#Error", n.evaluate("A1")); + } + @Test + public void test_SimpleFormulas() { + Spreadsheet n = new Spreadsheet(); + + n.set("A1", "='a string'"); + + assertEquals("Evaluation is not correct", "a string", n.evaluate("A1")); + } + @Test + public void test_SimpleFormulasError() { + Spreadsheet n = new Spreadsheet(); + + n.set("A1", "='a string"); + + assertEquals("Evaluation is not correct", "#Error", n.evaluate("A1")); + } + @Test + public void test_CellReference() { + Spreadsheet n = new Spreadsheet(); + + n.set("A2", "5"); + n.set("A1", "=A2"); + + assertEquals("Evaluation is not correct", "5", n.evaluate("A1")); + } + @Test + public void test_CellReferenceError() { + Spreadsheet n = new Spreadsheet(); + + n.set("A2", "k5"); + n.set("A1", "=A2"); + + assertEquals("Evaluation is not correct", "#Error", n.evaluate("A1")); + } + @Test + public void test_CircularReference() { + Spreadsheet n = new Spreadsheet(); + + n.set("A2", "=A1"); + n.set("A1", "=A2"); + + assertEquals("Evaluation is not correct", "#Circular", n.evaluate("A1")); + } + @Test + public void test_IntegerOperations() { + Spreadsheet n = new Spreadsheet(); + + n.set("A2", "=A1"); + n.set("A1", "=A2"); + + assertEquals("Evaluation is not correct", "#Circular", n.evaluate("A1")); } + + + }