fix checkstyle errors in tests #58

Author: arnaud-m

src/test/java/cryptator/AdaptiveTest.java

@@ -20,7 +20,7 @@
 
 public class AdaptiveTest {
 
-    public final CryptaSolvingTester t = new CryptaSolvingTester(new AdaptiveSolver());
+    private final CryptaSolvingTester t = new CryptaSolvingTester(new AdaptiveSolver());
 
     public AdaptiveTest() {
     }

src/test/java/cryptator/BignumTest.java

@@ -18,7 +18,7 @@
 
 public class BignumTest {
 
-    public final CryptaSolvingTester t = new CryptaSolvingTester(new CryptaSolver(true));
+    private final CryptaSolvingTester t = new CryptaSolvingTester(new CryptaSolver(true));
 
     public BignumTest() {
     }

src/test/java/cryptator/CommandTest.java

@@ -44,7 +44,7 @@ public void testCryptagen() throws FileNotFoundException {
 
     @Test
     public void testCryptagenDoublyTrue() throws FileNotFoundException {
-        String[] args = {"-c", "FALSE", "-g", "FALSE", "-v", "FALSE", "3", "4",};
+        String[] args = {"-c", "FALSE", "-g", "FALSE", "-v", "FALSE", "3", "4"};
         assertEquals(0, Cryptagen.doMain(args));
     }
 

src/test/java/cryptator/EngineTest.java

@@ -30,13 +30,13 @@
 
 public class EngineTest {
 
-    public CryptaConfig config = new CryptaConfig();
+    private CryptaConfig config = new CryptaConfig();
 
-    public final CryptaParserWrapper parser = new CryptaParserWrapper();
+    private final CryptaParserWrapper parser = new CryptaParserWrapper();
 
-    public final CryptaModeler modeler = new CryptaModeler();
+    private final CryptaModeler modeler = new CryptaModeler();
 
-    public final CryptaGameEngine engine = new CryptaGameEngine();
+    private final CryptaGameEngine engine = new CryptaGameEngine();
 
     public EngineTest() {
     }
@@ -77,23 +77,25 @@ public final void testInvalidDecisionsParser() {
         assertNull(CryptaGameDecision.parseDecision("x = x"));
     }
 
-    private void setUpEngine(String cryptarithm) throws CryptaModelException, CryptaGameException {
+    private void setUpEngine(final String cryptarithm) throws CryptaModelException, CryptaGameException {
         final ICryptaNode node = parser.parse(cryptarithm);
         final CryptaModel model = modeler.model(node, config);
         engine.setUp(model);
     }
 
-    private final void testGoodDecision(char symbol, CryptaOperator reOperator, int value) throws CryptaGameException {
+    private void testGoodDecision(final char symbol, final CryptaOperator reOperator, final int value)
+            throws CryptaGameException {
         assertTrue(engine.takeDecision(new CryptaGameDecision(symbol, reOperator, value)));
         assertFalse(engine.isSolved());
     }
 
-    private final void testBadDecision(char symbol, CryptaOperator reOperator, int value) throws CryptaGameException {
+    private void testBadDecision(final char symbol, final CryptaOperator reOperator, final int value)
+            throws CryptaGameException {
         assertFalse(engine.takeDecision(new CryptaGameDecision(symbol, reOperator, value)));
         assertFalse(engine.isSolved());
     }
 
-    private final void testGoodLastDecision(char symbol, CryptaOperator reOperator, int value)
+    private void testGoodLastDecision(final char symbol, final CryptaOperator reOperator, final int value)
             throws CryptaGameException {
         assertTrue(engine.takeDecision(new CryptaGameDecision(symbol, reOperator, value)));
         assertTrue(engine.isSolved());

src/test/java/cryptator/EvaluationTest.java

@@ -31,21 +31,22 @@
 
 public class EvaluationTest {
 
-    public final CryptaParserWrapper parser = new CryptaParserWrapper();
+    private final CryptaParserWrapper parser = new CryptaParserWrapper();
 
-    public final ICryptaEvaluation eval = new CryptaEvaluation();
+    private final ICryptaEvaluation eval = new CryptaEvaluation();
 
     public EvaluationTest() {
     }
 
-    private void testInSolution(ICryptaSolution s, char symbol, int digit) throws CryptaSolutionException {
+    private void testInSolution(final ICryptaSolution s, final char symbol, final int digit)
+            throws CryptaSolutionException {
         assertTrue(s.hasDigit(symbol));
         assertTrue(s.hasDomain(symbol));
         assertEquals(digit, s.getDigit(symbol));
         assertNotNull(s.getDomain(symbol));
     }
 
-    private void testNotInSolution(ICryptaSolution s, char symbol) throws CryptaSolutionException {
+    private void testNotInSolution(final ICryptaSolution s, final char symbol) throws CryptaSolutionException {
         assertFalse(s.hasDigit(symbol));
         assertFalse(s.hasDomain(symbol));
         assertNotNull(s.getDomain(symbol));
@@ -90,12 +91,12 @@ public void testInvalidSolutionParser3() throws CryptaSolutionException {
         CryptaSolutionMap.parseSolution("A 1 B");
     }
 
-    private void assertTrueEval(ICryptaNode cryptarithm, ICryptaSolution solution, int base)
+    private void assertTrueEval(final ICryptaNode cryptarithm, final ICryptaSolution solution, final int base)
             throws CryptaEvaluationException {
         assertEquals(BigInteger.ONE, eval.evaluate(cryptarithm, solution, base));
     }
 
-    private void assertFalseEval(ICryptaNode cryptarithm, ICryptaSolution solution, int base)
+    private void assertFalseEval(final ICryptaNode cryptarithm, final ICryptaSolution solution, final int base)
             throws CryptaEvaluationException {
         assertEquals(BigInteger.ZERO, eval.evaluate(cryptarithm, solution, base));
     }
@@ -188,7 +189,7 @@ public void testEvaluation9() throws CryptaParserException, CryptaSolutionExcept
         assertTrueEval(cryptarithm, solution, 4);
     }
 
-    public void testPartialSolution(String cryptarithm, String partialSolution)
+    public void testPartialSolution(final String cryptarithm, final String partialSolution)
             throws CryptaParserException, CryptaSolutionException, CryptaEvaluationException {
         final ICryptaNode node = parser.parse(cryptarithm);
         final ICryptaSolution solution = CryptaSolutionMap.parseSolution(partialSolution);

src/test/java/cryptator/ExportTest.java

@@ -23,11 +23,11 @@
 
 public class ExportTest {
 
+    private final CryptaParserWrapper parser = new CryptaParserWrapper();
+
     public ExportTest() {
     }
 
-    public final CryptaParserWrapper parser = new CryptaParserWrapper();
-
     @Test
     public void testExport1() throws CryptaParserException, CryptaSolutionException, CryptaEvaluationException {
         final ICryptaNode cryptarithm = parser.parse("SEND+MORE=MONEY");

src/test/java/cryptator/ExtensiveTesting.java

@@ -21,7 +21,7 @@
 
 public class ExtensiveTesting {
 
-    public final CryptaSolvingTester t = new CryptaSolvingTester(new CryptaSolver(false));
+    private final CryptaSolvingTester t = new CryptaSolvingTester(new CryptaSolver(false));
 
     public ExtensiveTesting() {
     }

src/test/java/cryptator/Failing.java

@@ -24,7 +24,7 @@
 
 public class Failing {
 
-    public final CryptaSolvingTester t = new CryptaSolvingTester(new CryptaSolver(false));
+    private final CryptaSolvingTester t = new CryptaSolvingTester(new CryptaSolver(false));
 
     public Failing() {
     }

src/test/java/cryptator/FeaturesTest.java

@@ -21,7 +21,7 @@
 
 public class FeaturesTest {
 
-    public final CryptaParserWrapper parser = new CryptaParserWrapper();
+    private final CryptaParserWrapper parser = new CryptaParserWrapper();
 
     public FeaturesTest() {
     }

src/test/java/cryptator/GenModelTest.java

@@ -35,18 +35,18 @@ public void buildGenModels() {
         }
     }
 
-    private void postMaxWordCountConstraint(ICryptaGenModel model, int maxWordCount) {
+    private void postMaxWordCountConstraint(final ICryptaGenModel model, final int maxWordCount) {
         model.getWordCount().le(maxWordCount).post();
     }
 
-    private void testGenModels(int expectedSolutionCount, int maxWordCount) {
+    private void testGenModels(final int expectedSolutionCount, final int maxWordCount) {
         for (ICryptaGenModel m : models) {
             postMaxWordCountConstraint(m, maxWordCount);
             testGenModel(m, expectedSolutionCount);
         }
     }
 
-    private void testGenModel(ICryptaGenModel model, int expectedSolutionCount) {
+    private void testGenModel(final ICryptaGenModel model, final int expectedSolutionCount) {
         assertEquals(expectedSolutionCount, model.getModel().getSolver().streamSolutions().count());
     }