diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..27ad3e8 --- /dev/null +++ b/.gitignore @@ -0,0 +1,22 @@ +## Maven specific +target/ +pom.xml.tag +pom.xml.releaseBackup +pom.xml.versionsBackup +pom.xml.next +release.properties + +## Java specific +*.class +*.jar +*.war +*.ear +hs_err_pid* + +## JetBrains IntelliJ +/*.iml +.idea/ +out/ +*.ipr +*.iws + diff --git a/README.md b/README.md index 9561a11..146ac12 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,19 @@ -single +Single ====== + +Traditional Operative Systems have several sources of input: keyboard, mouse, track pad, video camera, microphone etc. + +Such a massive amount of different inputs is used to perform several actions from the OS. However, there are some +people that, for several health reasons, could not easily control such input devices. + +We decided to go design an application that could handle the bare minimum input information. Single is going to be +designed to respond to a single boolean input per time. + +The idea is to construct a flexible framework that could host several application, the initial idea is to introduce a +set of application to improve the life quality of the users: + 1) Write, will allowed the user to compose texts using a single input. + 2) Play some musics + 3) Play a movie + 4) Browser internet + +In future step will be to integrate the application with the most famous social media. \ No newline at end of file diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..ea05398 --- /dev/null +++ b/pom.xml @@ -0,0 +1,54 @@ + + + 4.0.0 + + org.single + single + 1.0-SNAPSHOT + + + + UTF-8 + + 4.11 + + 3.1 + 1.7 + 1.7 + + + + + + junit + junit + ${junit.version} + test + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + ${maven-compiler-plugin.version} + + ${maven-compiler-plugin.source} + ${maven-compiler-plugin.target} + + + + org.apache.maven.plugins + maven-surefire-plugin + 2.17 + + methods + 10 + + + + + diff --git a/src/Position.java b/src/Position.java deleted file mode 100644 index 74f60e3..0000000 --- a/src/Position.java +++ /dev/null @@ -1,29 +0,0 @@ -public class Position { - - private final int x; - private final int y; - private final static int MINIMUM_VALUE = -1; - - public Position(int x, int y){ - RunTimeChecks.checkGreaterThan(x,MINIMUM_VALUE,"Negative value are not allowed for x axis"); - RunTimeChecks.checkGreaterThan(y,MINIMUM_VALUE,"Negative value are not allowed for y axis"); - this.x = x; - this.y = y; - } - - public int getX(){ - return x; - } - - public int getY(){ - return y; - } - - @Override - public String toString() { - return "Position{" + - "x=" + x + - ", y=" + y + - '}'; - } -} diff --git a/src/RunTimeChecks.java b/src/RunTimeChecks.java deleted file mode 100644 index 61bbafc..0000000 --- a/src/RunTimeChecks.java +++ /dev/null @@ -1,51 +0,0 @@ - -public class RunTimeChecks { - - public static void suppressUnusedVariableGitWarning(Object obj){ - checkNotNull(obj,""); - } - - static private String hereAt(int levelUpInTheStack) { - StackTraceElement ste = Thread.currentThread().getStackTrace()[levelUpInTheStack]; - return ste.toString(); - } - - public static void checkNotNull(Object toCheck,String message) { - int levelUpInTheStack = 3; - if (toCheck == null) { - throw new NullPointerException(hereAt(levelUpInTheStack) + " error: " + message); - } - } - - public static void checkGreaterThan(int runtimeValue,int constraint,String message){ - if (runtimeValue <= constraint){ - throw new IntegerDomainError( - message.concat(": the runtime value ").concat(String.valueOf(runtimeValue)). - concat(" has to be greater than constraint ").concat(String.valueOf(constraint)), - runtimeValue, - constraint); - } - } - - public static void checkWithinIntervalInclusive(int runtimeValue,int minValue,int maxValue,String message){ - if (minValue > maxValue){ - throw new IntegerDomainError( - "Invalid inclusive interval, min value greater than max value",minValue,maxValue); - } - if (runtimeValue < minValue){ - throw new IntegerDomainError( - message.concat("Invalid run time value ").concat(String.valueOf(runtimeValue)) - .concat(" is less then ").concat(String.valueOf(minValue)), - runtimeValue, - minValue); - } - if (runtimeValue > maxValue){ - throw new IntegerDomainError( - message.concat("Invalid run time value ").concat(String.valueOf(runtimeValue)) - .concat(" is greater then ").concat(String.valueOf(maxValue)), - runtimeValue, - maxValue); - - } - } -} diff --git a/src/Scanner.java b/src/Scanner.java deleted file mode 100644 index e376484..0000000 --- a/src/Scanner.java +++ /dev/null @@ -1,12 +0,0 @@ -public interface Scanner { - - public Position next(); - - public Position reset(); - - public void setNewPosition(Position position); - - public Position getCurrentPosition(); - - public Position switchScanningAxis(); -} diff --git a/src/main/java/org/single/core/Axis.java b/src/main/java/org/single/core/Axis.java new file mode 100644 index 0000000..d0cf511 --- /dev/null +++ b/src/main/java/org/single/core/Axis.java @@ -0,0 +1,19 @@ +package org.single.core; + +public enum Axis { + X("X"), + Y("Y"); + + private String value; + + private Axis(String value){ + this.value = value; + } + + @Override + public String toString() { + return "Axis{" + + "String=" + value + + '}'; + } +} diff --git a/src/IntegerDomainError.java b/src/main/java/org/single/core/IntegerDomainError.java similarity index 77% rename from src/IntegerDomainError.java rename to src/main/java/org/single/core/IntegerDomainError.java index cbbdb1c..29e38ca 100644 --- a/src/IntegerDomainError.java +++ b/src/main/java/org/single/core/IntegerDomainError.java @@ -1,9 +1,12 @@ +package org.single.core; + + public class IntegerDomainError extends RuntimeException { private final int runtimeValue; private final int constraint; - public IntegerDomainError(String message,int runtimeValue, int constraint){ + public IntegerDomainError(String message, int runtimeValue, int constraint) { super(message); this.runtimeValue = runtimeValue; this.constraint = constraint; diff --git a/src/OneDimensionScanner.java b/src/main/java/org/single/core/OneDimensionScanner.java similarity index 82% rename from src/OneDimensionScanner.java rename to src/main/java/org/single/core/OneDimensionScanner.java index b06ef16..094481e 100644 --- a/src/OneDimensionScanner.java +++ b/src/main/java/org/single/core/OneDimensionScanner.java @@ -1,9 +1,12 @@ +package org.single.core; + public class OneDimensionScanner implements Scanner { private static final int VALUE_Y = 0; private final Position maxPosition; private Position current; private final Position startPosition; + private Axis scanningAxis = Axis.X; public OneDimensionScanner(int numberOfCells,int initialPosition){ RunTimeChecks.checkGreaterThan(numberOfCells, 0, "Error with the number of cells"); @@ -19,9 +22,7 @@ public OneDimensionScanner(int numberOfCells,int initialPosition){ @Override public Position next() { - int nextX = current.getX()+1; - if (nextX > maxPosition.getX()) - nextX = 0; + int nextX = moveNextOneDimension(current.getX(),maxPosition.getX()); current = new Position(nextX,current.getY()); return current; } @@ -49,8 +50,8 @@ public Position getCurrentPosition() { } @Override - public Position switchScanningAxis() { - return current; + public Axis switchScanningAxis() { + return scanningAxis; } @Override @@ -61,4 +62,12 @@ public String toString() { ", startPosition=" + startPosition + '}'; } + + static int moveNextOneDimension(int current,int maxPosition){ + int nextX = current+1; + if (nextX > maxPosition){ + nextX = 0; + } + return nextX; + } } diff --git a/src/main/java/org/single/core/Position.java b/src/main/java/org/single/core/Position.java new file mode 100644 index 0000000..877973d --- /dev/null +++ b/src/main/java/org/single/core/Position.java @@ -0,0 +1,32 @@ +package org.single.core; + + +public class Position { + + private static final int MINIMUM_VALUE = -1; + private final int x; + private final int y; + + public Position(int x, int y) { + RunTimeChecks.checkGreaterThan(x, MINIMUM_VALUE, "Negative value are not allowed for x axis"); + RunTimeChecks.checkGreaterThan(y, MINIMUM_VALUE, "Negative value are not allowed for y axis"); + this.x = x; + this.y = y; + } + + public int getX() { + return x; + } + + public int getY() { + return y; + } + + @Override + public String toString() { + return "Position{" + + "x=" + x + + ", y=" + y + + '}'; + } +} diff --git a/src/main/java/org/single/core/RunTimeChecks.java b/src/main/java/org/single/core/RunTimeChecks.java new file mode 100644 index 0000000..13fab8b --- /dev/null +++ b/src/main/java/org/single/core/RunTimeChecks.java @@ -0,0 +1,56 @@ +package org.single.core; + + +public final class RunTimeChecks { + + private RunTimeChecks(){ + } + + public static void suppressUnusedVariableGitWarning(Object obj) { + checkNotNull(obj, ""); + } + + private static String hereAt(int levelUpInTheStack) { + StackTraceElement ste = Thread.currentThread().getStackTrace()[levelUpInTheStack]; + return ste.toString(); + } + + public static void checkNotNull(Object toCheck, String message) { + final int levelUpInTheStack = 3; + if (toCheck == null) { + throw new IllegalArgumentException(hereAt(levelUpInTheStack) + " error: " + message); + } + } + + public static void checkGreaterThan(int runtimeValue, int constraint, String message) { + if (runtimeValue <= constraint) { + throw new IntegerDomainError( + message.concat(": the runtime value ").concat(String.valueOf(runtimeValue)). + concat(" has to be greater than constraint ").concat(String.valueOf(constraint)), + runtimeValue, + constraint); + } + } + + public static void checkWithinIntervalInclusive(int runtimeValue, int minValue, int maxValue, String message) { + if (minValue > maxValue) { + throw new IntegerDomainError( + "Invalid inclusive interval, min value greater than max value", minValue, maxValue); + } + if (runtimeValue < minValue) { + throw new IntegerDomainError( + message.concat("Invalid run time value ").concat(String.valueOf(runtimeValue)) + .concat(" is less then ").concat(String.valueOf(minValue)), + runtimeValue, + minValue); + } + if (runtimeValue > maxValue) { + throw new IntegerDomainError( + message.concat("Invalid run time value ").concat(String.valueOf(runtimeValue)) + .concat(" is greater then ").concat(String.valueOf(maxValue)), + runtimeValue, + maxValue); + + } + } +} diff --git a/src/main/java/org/single/core/Scanner.java b/src/main/java/org/single/core/Scanner.java new file mode 100644 index 0000000..8e1b3d9 --- /dev/null +++ b/src/main/java/org/single/core/Scanner.java @@ -0,0 +1,14 @@ +package org.single.core; + +public interface Scanner { + + Position next(); + + Position reset(); + + void setNewPosition(Position position); + + Position getCurrentPosition(); + + Axis switchScanningAxis(); +} diff --git a/src/main/java/org/single/core/TwoDimensionsScanner.java b/src/main/java/org/single/core/TwoDimensionsScanner.java new file mode 100644 index 0000000..9bfdfae --- /dev/null +++ b/src/main/java/org/single/core/TwoDimensionsScanner.java @@ -0,0 +1,84 @@ +package org.single.core; + +public class TwoDimensionsScanner implements Scanner { + + private final Position startPosition; + private final Position maxPosition; + private Position current; + private Axis scanningAxis = Axis.X; + + TwoDimensionsScanner(Position initialPosition,Position maxPosition){ + RunTimeChecks.checkNotNull(initialPosition,"Initial Position Object is null"); + RunTimeChecks.checkNotNull(initialPosition,"Max Position Object is null"); + RunTimeChecks.checkWithinIntervalInclusive( + initialPosition.getX(), + 0, + maxPosition.getX(), + "The initial position must be less than the max position for the axis X"); + RunTimeChecks.checkWithinIntervalInclusive( + initialPosition.getY(), + 0, + maxPosition.getY(), + "The initial position must be less than the max position for the axis Y"); + this.startPosition = initialPosition; + this.maxPosition = maxPosition; + this.current = initialPosition; + } + + @Override + public Position next() { + if (scanningAxis==Axis.X){ + return nextOnAxisX(); + } + return nextOnAxisY(); + } + + private Position nextOnAxisX() { + int nextX = OneDimensionScanner.moveNextOneDimension(current.getX(),maxPosition.getX()); + current = new Position(nextX,current.getY()); + return current; + } + + private Position nextOnAxisY() { + int nextY = OneDimensionScanner.moveNextOneDimension(current.getY(),maxPosition.getY()); + current = new Position(current.getX(),nextY); + return current; + } + + @Override + public Position reset() { + current = startPosition; + return current; + } + + @Override + public void setNewPosition(Position position) { + RunTimeChecks.checkNotNull(position,"Input Position object is null"); + RunTimeChecks.checkWithinIntervalInclusive( + position.getX(), + 0, + maxPosition.getX(), + "The initial position must be less than the max position for the axis X"); + RunTimeChecks.checkWithinIntervalInclusive( + position.getY(), + 0, + maxPosition.getY(), + "The initial position must be less than the max position for the axis Y"); + current = position; + } + + @Override + public Position getCurrentPosition() { + return current; + } + + @Override + public Axis switchScanningAxis() { + if (scanningAxis==Axis.X){ + scanningAxis = Axis.Y; + } else{ + scanningAxis = Axis.X; + } + return scanningAxis; + } +} diff --git a/src/test/java/org/single/core/IntegerDomainErrorTest.java b/src/test/java/org/single/core/IntegerDomainErrorTest.java new file mode 100644 index 0000000..3b2514b --- /dev/null +++ b/src/test/java/org/single/core/IntegerDomainErrorTest.java @@ -0,0 +1,20 @@ +package org.single.core; + +import org.junit.Test; + +import static org.junit.Assert.assertEquals; + + +public class IntegerDomainErrorTest { + + @Test + public void integerDomainErrorTest() { + String errorMessage = "Error message"; + IntegerDomainError integerDomainError = new IntegerDomainError(errorMessage, 5, 7); + + assertEquals("Check error message", errorMessage, integerDomainError.getMessage()); + assertEquals("Check runtime value", 5, integerDomainError.getRuntimeValue()); + assertEquals("Check error message", 7, integerDomainError.getConstraint()); + } +} + diff --git a/src/test/java/org/single/core/OneDimensionScannerTest.java b/src/test/java/org/single/core/OneDimensionScannerTest.java new file mode 100644 index 0000000..33cdb1a --- /dev/null +++ b/src/test/java/org/single/core/OneDimensionScannerTest.java @@ -0,0 +1,145 @@ +package org.single.core; + +import org.junit.Test; + +import static org.junit.Assert.assertEquals; + + +public class OneDimensionScannerTest { + + @Test(expected = IntegerDomainError.class) + public void oneDimensionScannerConstructorExceptionCellsNumberTest() { + Scanner oneDimensionScanner = new OneDimensionScanner(0, 5); + RunTimeChecks.suppressUnusedVariableGitWarning(oneDimensionScanner); //this line will never be executed + } + + @Test(expected = IntegerDomainError.class) + public void oneDimensionScannerConstructorExceptionPositionLessTest() { + Scanner oneDimensionScanner = new OneDimensionScanner(10, -1); + RunTimeChecks.suppressUnusedVariableGitWarning(oneDimensionScanner); //this line will never be executed + } + + @Test(expected = IntegerDomainError.class) + public void oneDimensionScannerConstructorExceptionPositionMoreTest() { + Scanner oneDimensionScanner = new OneDimensionScanner(10, 11); + RunTimeChecks.suppressUnusedVariableGitWarning(oneDimensionScanner); //this line will never be executed + } + + @Test + public void oneDimensionScannerInitialSetTest() { + Scanner oneDimensionScanner = new OneDimensionScanner(10, 0); + assertEquals("Check initial current position", 0, oneDimensionScanner.getCurrentPosition().getX()); + assertEquals("Check initial current position", 0, oneDimensionScanner.getCurrentPosition().getY()); + + Scanner oneDimensionScanner1 = new OneDimensionScanner(10, 4); + assertEquals("Check initial current position", 4, oneDimensionScanner1.getCurrentPosition().getX()); + assertEquals("Check initial current position", 0, oneDimensionScanner1.getCurrentPosition().getY()); + + Scanner oneDimensionScanner2 = new OneDimensionScanner(10, 9); + assertEquals("Check initial current position", 9, oneDimensionScanner2.getCurrentPosition().getX()); + assertEquals("Check initial current position", 0, oneDimensionScanner2.getCurrentPosition().getY()); + } + + @Test(expected = IntegerDomainError.class) + public void oneDimensionScannerSetNewPositionInvalidTooBigTest() { + Scanner oneDimensionScanner = new OneDimensionScanner(10, 0); + Position newPosition = new Position(10, 0); + oneDimensionScanner.setNewPosition(newPosition); + } + + @Test + public void oneDimensionScannerSetNewPositionTest() { + Scanner oneDimensionScanner = new OneDimensionScanner(10, 0); + + assertEquals("Check initial current position", 0, oneDimensionScanner.getCurrentPosition().getX()); + assertEquals("Check initial current position", 0, oneDimensionScanner.getCurrentPosition().getY()); + + Position newPosition = new Position(4, 0); + oneDimensionScanner.setNewPosition(newPosition); + + assertEquals("Check new set position", 4, oneDimensionScanner.getCurrentPosition().getX()); + assertEquals("Check new set position", 0, oneDimensionScanner.getCurrentPosition().getY()); + + newPosition = new Position(6, 0); + + assertEquals("Check new set position", 4, oneDimensionScanner.getCurrentPosition().getX()); + assertEquals("Check new set position", 0, oneDimensionScanner.getCurrentPosition().getY()); + + oneDimensionScanner.setNewPosition(newPosition); + + assertEquals("Check new set position", 6, oneDimensionScanner.getCurrentPosition().getX()); + assertEquals("Check new set position", 0, oneDimensionScanner.getCurrentPosition().getY()); + } + + @Test + public void oneDimensionScannerNextTest() { + Scanner oneDimensionScanner = new OneDimensionScanner(5, 2); + + assertEquals("Check initial current position", 2, oneDimensionScanner.getCurrentPosition().getX()); + assertEquals("Check initial current position", 0, oneDimensionScanner.getCurrentPosition().getY()); + + Position position = oneDimensionScanner.next(); + assertEquals("Check incremented position", 3, position.getX()); + assertEquals("Check incremented position", 0, position.getY()); + + assertEquals("Check incremented against current", + position.getX(), + oneDimensionScanner.getCurrentPosition().getX()); + assertEquals("Check incremented against current", + position.getY(), + oneDimensionScanner.getCurrentPosition().getY()); + + position = oneDimensionScanner.next(); + assertEquals("Check incremented position", 4, position.getX()); + assertEquals("Check incremented position", 0, position.getY()); + + position = oneDimensionScanner.next(); + assertEquals("Check incremented position", 0, position.getX()); + assertEquals("Check incremented position", 0, position.getY()); + + position = oneDimensionScanner.next(); + assertEquals("Check incremented position", 1, position.getX()); + assertEquals("Check incremented position", 0, position.getY()); + + position = oneDimensionScanner.next(); + assertEquals("Check incremented position", 2, position.getX()); + assertEquals("Check incremented position", 0, position.getY()); + + position = oneDimensionScanner.next(); + assertEquals("Check incremented position", 3, position.getX()); + assertEquals("Check incremented position", 0, position.getY()); + } + + @Test + public void oneDimensionScannerResetTest() { + Scanner oneDimensionScanner = new OneDimensionScanner(5, 2); + + assertEquals("Check initial current position", 2, oneDimensionScanner.getCurrentPosition().getX()); + assertEquals("Check initial current position", 0, oneDimensionScanner.getCurrentPosition().getY()); + + Position position = oneDimensionScanner.next(); + assertEquals("Check incremented position", 3, position.getX()); + assertEquals("Check incremented position", 0, position.getY()); + + position = oneDimensionScanner.reset(); + assertEquals("Check incremented position", 2, position.getX()); + assertEquals("Check incremented position", 0, position.getY()); + } + + @Test + public void oneDimensionScannerToStringTest() { + Scanner oneDimensionScanner = new OneDimensionScanner(5, 2); + String oneDimensionalScannerText = + "OneDimensionScanner{maxPosition=Position{x=4, y=0}, " + + "current=Position{x=2, y=0}, startPosition=Position{x=2, y=0}}"; + + assertEquals("Check toString method", oneDimensionScanner.toString(), oneDimensionalScannerText); + } + + @Test + public void oneDimensionScannerSwitchScanningAxis() { + Scanner oneDimensionScanner = new OneDimensionScanner(5, 2); + assertEquals("Check after switch scanning axis", oneDimensionScanner.switchScanningAxis(),Axis.X); + assertEquals("Check after switch scanning axis", oneDimensionScanner.switchScanningAxis(),Axis.X); + } +} diff --git a/src/test/java/org/single/core/PositionTest.java b/src/test/java/org/single/core/PositionTest.java new file mode 100644 index 0000000..b9e584d --- /dev/null +++ b/src/test/java/org/single/core/PositionTest.java @@ -0,0 +1,41 @@ +package org.single.core; + +import org.junit.Test; + +import static org.junit.Assert.assertEquals; + + +public class PositionTest { + + @Test(expected = IntegerDomainError.class) + public void positionConstructorExceptionXTest() { + Position position = new Position(-3, 5); + RunTimeChecks.suppressUnusedVariableGitWarning(position); //this line will never be executed + } + + @Test(expected = IntegerDomainError.class) + public void positionConstructorExceptionYTest() { + Position position = new Position(5, -2); + RunTimeChecks.suppressUnusedVariableGitWarning(position); //this line will never be executed + } + + @Test + public void positionGetterTest() { + Position position = new Position(4, 5); + assertEquals("Check x getter", 4, position.getX()); + assertEquals("Check y getter", 5, position.getY()); + } + + @Test + public void positionZeroTest() { + Position position = new Position(0, 0); + assertEquals("Check x getter", 0, position.getX()); + assertEquals("Check y getter", 0, position.getY()); + } + + @Test + public void positionToStringTest() { + Position position = new Position(4, 5); + assertEquals("Check toString method", "Position{x=4, y=5}", position.toString()); + } +} diff --git a/src/test/java/org/single/core/RunTimeChecksTest.java b/src/test/java/org/single/core/RunTimeChecksTest.java new file mode 100644 index 0000000..fcc1e42 --- /dev/null +++ b/src/test/java/org/single/core/RunTimeChecksTest.java @@ -0,0 +1,77 @@ +package org.single.core; + +import org.junit.Test; + +import static org.junit.Assert.assertTrue; + + +public class RunTimeChecksTest { + + private static final String message = "The object is null"; + private static final String invalidRuntimeValue = "Invalid runtime value"; + + @Test(expected = IllegalArgumentException.class) + public void checkNotNullThrowingExceptionTest() { + RunTimeChecks.checkNotNull(null, message); + } + + @Test + public void checkNotNullPositiveResultTest() { + RunTimeChecks.checkNotNull("Any string", message); + } + + @Test + public void checkNotNullExceptionMessage() { + try { + RunTimeChecks.checkNotNull(null, message); + } catch (Exception ex) { + String exMessage = ex.getMessage(); + /* The following tests will be break if any, even not harmful + * modification will be perform on RuntimeCheckTests file, this is not + * ideal, however it is the only truly way to test the error message generated. + * The alternative is to skip the tests, but this is even more less + * desirable outcome. + */ + //Assert that class name is in the error message + assertTrue(exMessage.contains("RunTimeChecksTest")); + //Assert that the function name is in the error message + assertTrue(exMessage.contains("checkNotNullExceptionMessage")); + //Assert that the file name is in the error message + assertTrue(exMessage.contains("RunTimeChecksTest.java")); + //Assert that the line number is in the error message + assertTrue(exMessage.contains("26")); + } + } + + @Test(expected = IntegerDomainError.class) + public void checkGreaterThanTestLessCase() { + RunTimeChecks.checkGreaterThan(5, 6, invalidRuntimeValue); + } + + @Test(expected = IntegerDomainError.class) + public void checkGreaterThanTestEqualCase() { + RunTimeChecks.checkGreaterThan(5, 5, invalidRuntimeValue); + } + + @Test + public void checkGreaterThanTestGreaterCase() { + RunTimeChecks.checkGreaterThan(6, 5, invalidRuntimeValue); + } + + @Test(expected = IntegerDomainError.class) + public void checkWithinIntervalInclusiveLessThanMin() { + RunTimeChecks.checkWithinIntervalInclusive(5, 7, 10, invalidRuntimeValue); + } + + @Test(expected = IntegerDomainError.class) + public void checkWithinIntervalInclusiveGreaterThanMax() { + RunTimeChecks.checkWithinIntervalInclusive(11, 7, 10, invalidRuntimeValue); + } + + @Test + public void checkWithinIntervalInclusiveWithin() { + RunTimeChecks.checkWithinIntervalInclusive(7, 7, 10, invalidRuntimeValue); + RunTimeChecks.checkWithinIntervalInclusive(9, 7, 10, invalidRuntimeValue); + RunTimeChecks.checkWithinIntervalInclusive(10, 7, 10, invalidRuntimeValue); + } +} diff --git a/src/test/java/org/single/core/TwoDimensionsScannerTests.java b/src/test/java/org/single/core/TwoDimensionsScannerTests.java new file mode 100644 index 0000000..1c632ca --- /dev/null +++ b/src/test/java/org/single/core/TwoDimensionsScannerTests.java @@ -0,0 +1,148 @@ +package org.single.core; + +import org.junit.Test; +import static org.junit.Assert.assertEquals; + +public class TwoDimensionsScannerTests { + + @Test (expected = IntegerDomainError.class) + public void constructorExceptionXTest(){ + Scanner scanner = new TwoDimensionsScanner(new Position(10,0),new Position(5,4)); + RunTimeChecks.suppressUnusedVariableGitWarning(scanner); + } + + @Test (expected = IntegerDomainError.class) + public void constructorExceptionYTest(){ + Scanner scanner = new TwoDimensionsScanner(new Position(3,5),new Position(5,4)); + RunTimeChecks.suppressUnusedVariableGitWarning(scanner); + } + + @Test (expected = IllegalArgumentException.class) + public void constructorExceptionNullInitialPositionTest(){ + Scanner scanner = new TwoDimensionsScanner(null,new Position(5,4)); + RunTimeChecks.suppressUnusedVariableGitWarning(scanner); + } + + @Test (expected = NullPointerException.class) + public void constructorExceptionNullMaxPositionTest(){ + Scanner scanner = new TwoDimensionsScanner(new Position(5,4),null); + RunTimeChecks.suppressUnusedVariableGitWarning(scanner); + } + + @Test + public void setNewPositionTest(){ + Scanner scanner = new TwoDimensionsScanner(new Position(1,2),new Position(5,4)); + + assertEquals("Check initial Position",1,scanner.getCurrentPosition().getX()); + assertEquals("Check initial Position",2,scanner.getCurrentPosition().getY()); + + scanner.setNewPosition(new Position(3,2)); + + assertEquals("Check initial Position",3,scanner.getCurrentPosition().getX()); + assertEquals("Check initial Position",2,scanner.getCurrentPosition().getY()); + } + + @Test (expected = IllegalArgumentException.class) + public void setNewPositionNullExceptionTest(){ + Scanner scanner = new TwoDimensionsScanner(new Position(1,2),new Position(5,4)); + + assertEquals("Check initial Position",1,scanner.getCurrentPosition().getX()); + assertEquals("Check initial Position",2,scanner.getCurrentPosition().getY()); + + scanner.setNewPosition(null); + } + + @Test (expected = IntegerDomainError.class) + public void setNewPositionOutOfBoundXTest(){ + Scanner scanner = new TwoDimensionsScanner(new Position(1,2),new Position(5,4)); + + assertEquals("Check initial Position",1,scanner.getCurrentPosition().getX()); + assertEquals("Check initial Position",2,scanner.getCurrentPosition().getY()); + + scanner.setNewPosition(new Position(6,4)); + } + + @Test (expected = IntegerDomainError.class) + public void setNewPositionOutOfBoundYTest(){ + Scanner scanner = new TwoDimensionsScanner(new Position(1,2),new Position(5,4)); + + assertEquals("Check initial Position",1,scanner.getCurrentPosition().getX()); + assertEquals("Check initial Position",2,scanner.getCurrentPosition().getY()); + + scanner.setNewPosition(new Position(4,6)); + } + + @Test + public void resetTest(){ + Scanner scanner = new TwoDimensionsScanner(new Position(1,2),new Position(5,4)); + + assertEquals("Check initial Position",1,scanner.getCurrentPosition().getX()); + assertEquals("Check initial Position",2,scanner.getCurrentPosition().getY()); + + scanner.setNewPosition(new Position(3,2)); + + assertEquals("Check initial Position",3,scanner.getCurrentPosition().getX()); + assertEquals("Check initial Position",2,scanner.getCurrentPosition().getY()); + + Position resetPosition = scanner.reset(); + + assertEquals("Check initial Position",1,scanner.getCurrentPosition().getX()); + assertEquals("Check initial Position",2,scanner.getCurrentPosition().getY()); + + assertEquals("Check initial Position", scanner.getCurrentPosition().getX(), resetPosition.getX()); + assertEquals("Check initial Position", scanner.getCurrentPosition().getY(), resetPosition.getY()); + } + + @Test + public void switchScanningAxisTest(){ + Scanner scanner = new TwoDimensionsScanner(new Position(1,2),new Position(5,4)); + + assertEquals("Scanner axis",scanner.switchScanningAxis(),Axis.Y); + assertEquals("Scanner axis",scanner.switchScanningAxis(),Axis.X); + assertEquals("Scanner axis",scanner.switchScanningAxis(),Axis.Y); + assertEquals("Scanner axis",scanner.switchScanningAxis(),Axis.X); + } + + @Test + public void next(){ + Scanner scanner = new TwoDimensionsScanner(new Position(1,2),new Position(5,4)); + Position position = scanner.next(); + assertEquals("Check next logic",2,position.getX()); + assertEquals("Check next logic",2,position.getY()); + position = scanner.next(); + assertEquals("Check next logic",3,position.getX()); + assertEquals("Check next logic",2,position.getY()); + position = scanner.next(); + assertEquals("Check next logic",4,position.getX()); + assertEquals("Check next logic",2,position.getY()); + position = scanner.next(); + assertEquals("Check next logic",5,position.getX()); + assertEquals("Check next logic",2,position.getY()); + position = scanner.next(); + assertEquals("Check next logic",0,position.getX()); + assertEquals("Check next logic",2,position.getY()); + position = scanner.next(); + assertEquals("Check next logic",1,position.getX()); + assertEquals("Check next logic",2,position.getY()); + + scanner.switchScanningAxis(); + assertEquals("Check next logic",1,position.getX()); + assertEquals("Check next logic", 2, position.getY()); + + position = scanner.next(); + assertEquals("Check next logic",1,position.getX()); + assertEquals("Check next logic",3,position.getY()); + + position = scanner.next(); + assertEquals("Check next logic",1,position.getX()); + assertEquals("Check next logic",4,position.getY()); + + position = scanner.next(); + assertEquals("Check next logic",1,position.getX()); + assertEquals("Check next logic",0,position.getY()); + + position = scanner.next(); + assertEquals("Check next logic",1,position.getX()); + assertEquals("Check next logic",1,position.getY()); + } +} diff --git a/tests/IntegerDomainErrorTest.java b/tests/IntegerDomainErrorTest.java deleted file mode 100644 index d1298fe..0000000 --- a/tests/IntegerDomainErrorTest.java +++ /dev/null @@ -1,16 +0,0 @@ -import org.junit.Test; -import static junit.framework.Assert.assertEquals; - -public class IntegerDomainErrorTest { - - @Test - public void integerDomainErrorTest(){ - String errorMessage = "Error message"; - IntegerDomainError integerDomainError = new IntegerDomainError(errorMessage,5,7); - - assertEquals("Check error message",integerDomainError.getMessage(),errorMessage); - assertEquals("Check runtime value",integerDomainError.getRuntimeValue(),5); - assertEquals("Check error message",integerDomainError.getConstraint(),7); - } -} - diff --git a/tests/OneDimensionScannerTests.java b/tests/OneDimensionScannerTests.java deleted file mode 100644 index dbfd9e2..0000000 --- a/tests/OneDimensionScannerTests.java +++ /dev/null @@ -1,146 +0,0 @@ -import org.junit.Test; - -import static org.junit.Assert.assertEquals; - -public class OneDimensionScannerTests { - - @Test (expected = IntegerDomainError.class) - public void oneDimensionScannerConstructorExceptionCellsNumberTest(){ - Scanner oneDimensionScanner = new OneDimensionScanner(0,5); - RunTimeChecks.suppressUnusedVariableGitWarning(oneDimensionScanner); //this line will never be executed - } - - @Test (expected = IntegerDomainError.class) - public void oneDimensionScannerConstructorExceptionPositionLessTest(){ - Scanner oneDimensionScanner = new OneDimensionScanner(10,-1); - RunTimeChecks.suppressUnusedVariableGitWarning(oneDimensionScanner); //this line will never be executed - } - - @Test (expected = IntegerDomainError.class) - public void oneDimensionScannerConstructorExceptionPositionMoreTest(){ - Scanner oneDimensionScanner = new OneDimensionScanner(10,11); - RunTimeChecks.suppressUnusedVariableGitWarning(oneDimensionScanner); //this line will never be executed - } - - @Test - public void oneDimensionScannerInitialSetTest(){ - Scanner oneDimensionScanner = new OneDimensionScanner(10,0); - assertEquals("Check initial current position",0,oneDimensionScanner.getCurrentPosition().getX()); - assertEquals("Check initial current position",0,oneDimensionScanner.getCurrentPosition().getY()); - - Scanner oneDimensionScanner1 = new OneDimensionScanner(10,4); - assertEquals("Check initial current position",4,oneDimensionScanner1.getCurrentPosition().getX()); - assertEquals("Check initial current position",0,oneDimensionScanner1.getCurrentPosition().getY()); - - Scanner oneDimensionScanner2 = new OneDimensionScanner(10,9); - assertEquals("Check initial current position",9,oneDimensionScanner2.getCurrentPosition().getX()); - assertEquals("Check initial current position",0,oneDimensionScanner2.getCurrentPosition().getY()); - } - - @Test (expected = IntegerDomainError.class) - public void oneDimensionScannerSetNewPositionInvalidTooBigTest(){ - Scanner oneDimensionScanner = new OneDimensionScanner(10,0); - Position newPosition = new Position(10,0); - oneDimensionScanner.setNewPosition(newPosition); - } - - @Test - public void oneDimensionScannerSetNewPositionTest(){ - Scanner oneDimensionScanner = new OneDimensionScanner(10,0); - - assertEquals("Check initial current position",0,oneDimensionScanner.getCurrentPosition().getX()); - assertEquals("Check initial current position",0,oneDimensionScanner.getCurrentPosition().getY()); - - Position newPosition = new Position(4,0); - oneDimensionScanner.setNewPosition(newPosition); - - assertEquals("Check new set position",4,oneDimensionScanner.getCurrentPosition().getX()); - assertEquals("Check new set position",0,oneDimensionScanner.getCurrentPosition().getY()); - - newPosition = new Position(6,0); - - assertEquals("Check new set position",4,oneDimensionScanner.getCurrentPosition().getX()); - assertEquals("Check new set position",0,oneDimensionScanner.getCurrentPosition().getY()); - - oneDimensionScanner.setNewPosition(newPosition); - - assertEquals("Check new set position",6,oneDimensionScanner.getCurrentPosition().getX()); - assertEquals("Check new set position",0,oneDimensionScanner.getCurrentPosition().getY()); - } - - @Test - public void oneDimensionScannerNextTest(){ - Scanner oneDimensionScanner = new OneDimensionScanner(5,2); - - assertEquals("Check initial current position",2,oneDimensionScanner.getCurrentPosition().getX()); - assertEquals("Check initial current position",0,oneDimensionScanner.getCurrentPosition().getY()); - - Position position = oneDimensionScanner.next(); - assertEquals("Check incremented position",3,position.getX()); - assertEquals("Check incremented position",0,position.getY()); - - assertEquals("Check incremented against current", - position.getX(), - oneDimensionScanner.getCurrentPosition().getX()); - assertEquals("Check incremented against current", - position.getY(), - oneDimensionScanner.getCurrentPosition().getY()); - - position = oneDimensionScanner.next(); - assertEquals("Check incremented position",4,position.getX()); - assertEquals("Check incremented position",0,position.getY()); - - position = oneDimensionScanner.next(); - assertEquals("Check incremented position",0,position.getX()); - assertEquals("Check incremented position",0,position.getY()); - - position = oneDimensionScanner.next(); - assertEquals("Check incremented position",1,position.getX()); - assertEquals("Check incremented position",0,position.getY()); - - position = oneDimensionScanner.next(); - assertEquals("Check incremented position",2,position.getX()); - assertEquals("Check incremented position",0,position.getY()); - - position = oneDimensionScanner.next(); - assertEquals("Check incremented position",3,position.getX()); - assertEquals("Check incremented position",0,position.getY()); - } - - @Test - public void oneDimensionScannerResetTest(){ - Scanner oneDimensionScanner = new OneDimensionScanner(5,2); - - assertEquals("Check initial current position",2,oneDimensionScanner.getCurrentPosition().getX()); - assertEquals("Check initial current position",0,oneDimensionScanner.getCurrentPosition().getY()); - - Position position = oneDimensionScanner.next(); - assertEquals("Check incremented position",3,position.getX()); - assertEquals("Check incremented position",0,position.getY()); - - position = oneDimensionScanner.reset(); - assertEquals("Check incremented position",2,position.getX()); - assertEquals("Check incremented position",0,position.getY()); - } - - @Test - public void oneDimensionScannerToStringTest(){ - Scanner oneDimensionScanner = new OneDimensionScanner(5,2); - String oneDimensionalScannerText = - "OneDimensionScanner{maxPosition=Position{x=4, y=0}, " + - "current=Position{x=2, y=0}, startPosition=Position{x=2, y=0}}"; - - assertEquals("Check toString method",oneDimensionScanner.toString(),oneDimensionalScannerText); - } - - @Test - public void oneDimensionScannerSwitchScanningAxis(){ - Scanner oneDimensionScanner = new OneDimensionScanner(5,2); - - Position position = oneDimensionScanner.getCurrentPosition(); - Position afterSwitchPosition = oneDimensionScanner.switchScanningAxis(); - - assertEquals("Check after switch scanning axis",afterSwitchPosition.getX(),position.getX()); - assertEquals("Check after switch scanning axis",afterSwitchPosition.getY(),position.getY()); - } -} diff --git a/tests/PositionTests.java b/tests/PositionTests.java deleted file mode 100644 index fa11e92..0000000 --- a/tests/PositionTests.java +++ /dev/null @@ -1,37 +0,0 @@ -import org.junit.Test; -import static junit.framework.Assert.assertEquals; - -public class PositionTests { - - @Test (expected = IntegerDomainError.class) - public void positionConstructorExceptionXTest(){ - Position position = new Position(-3,5); - RunTimeChecks.suppressUnusedVariableGitWarning(position); //this line will never be executed - } - - @Test (expected = IntegerDomainError.class) - public void positionConstructorExceptionYTest(){ - Position position = new Position(5,-2); - RunTimeChecks.suppressUnusedVariableGitWarning(position); //this line will never be executed - } - - @Test - public void positionGetterTest(){ - Position position = new Position(4,5); - assertEquals("Check x getter",4,position.getX()); - assertEquals("Check y getter",5,position.getY()); - } - - @Test - public void positionZeroTest(){ - Position position = new Position(0,0); - assertEquals("Check x getter",0,position.getX()); - assertEquals("Check y getter",0,position.getY()); - } - - @Test - public void positionToStringTest(){ - Position position = new Position(4,5); - assertEquals("Check toString method","Position{x=4, y=5}",position.toString()); - } -} diff --git a/tests/RunTimeChecksTests.java b/tests/RunTimeChecksTests.java deleted file mode 100644 index 6337152..0000000 --- a/tests/RunTimeChecksTests.java +++ /dev/null @@ -1,73 +0,0 @@ -import org.junit.Test; -import static junit.framework.Assert.assertTrue; - -public class RunTimeChecksTests { - - private static final String message = "The object is null"; - private static final String invalidRuntimeValue = "Invalid runtime value"; - - @Test (expected = NullPointerException.class) - public void checkNotNullThrowingExceptionTest(){ - RunTimeChecks.checkNotNull(null, message); - } - - @Test - public void checkNotNullPositiveResultTest(){ - RunTimeChecks.checkNotNull("Any string", message); - } - - @Test - public void checkNotNullExceptionMessage(){ - try{ - RunTimeChecks.checkNotNull(null, message); - } catch (Exception ex){ - String exMessage = ex.getMessage(); - /* The following tests will be break if any, even not harmful - * modification will be perform on RuntimeCheckTests file, this is not - * ideal, however it is the only truly way to test the error message generated. - * The alternative is to skip the tests, but this is even more less - * desirable outcome. - */ - //Assert that class name is in the error message - assertTrue(exMessage.contains("RunTimeChecksTests")); - //Assert that the function name is in the error message - assertTrue(exMessage.contains("checkNotNullExceptionMessage")); - //Assert that the file name is in the error message - assertTrue(exMessage.contains("RunTimeChecksTests.java")); - //Assert that the line number is in the error message - assertTrue(exMessage.contains("22")); - } - } - - @Test (expected = IntegerDomainError.class) - public void checkGreaterThanTestLessCase(){ - RunTimeChecks.checkGreaterThan(5,6,invalidRuntimeValue); - } - - @Test (expected = IntegerDomainError.class) - public void checkGreaterThanTestEqualCase(){ - RunTimeChecks.checkGreaterThan(5,5,invalidRuntimeValue); - } - - @Test - public void checkGreaterThanTestGreaterCase(){ - RunTimeChecks.checkGreaterThan(6,5,invalidRuntimeValue); - } - - @Test (expected = IntegerDomainError.class) - public void checkWithinIntervalInclusiveLessThanMin(){ - RunTimeChecks.checkWithinIntervalInclusive(5,7,10,invalidRuntimeValue); - } - - @Test (expected = IntegerDomainError.class) - public void checkWithinIntervalInclusiveGreaterThanMax(){ - RunTimeChecks.checkWithinIntervalInclusive(11,7,10,invalidRuntimeValue); - } - - @Test - public void checkWithinIntervalInclusiveWithin(){ - RunTimeChecks.checkWithinIntervalInclusive(7,7,10,invalidRuntimeValue); - RunTimeChecks.checkWithinIntervalInclusive(9,7,10,invalidRuntimeValue); - RunTimeChecks.checkWithinIntervalInclusive(10,7,10,invalidRuntimeValue); - } -}