Convert hamming and two-fer unit tests to golden tests

src/main/java/analyzer/Main.java

@@ -40,7 +40,12 @@ private static Options validateOptions(String... args) {
     }
 
     private static List<CompilationUnit> parseInput(Options options) throws IOException {
-        var sourceRoot = new SourceRoot(Path.of(options.inputDirectory, "src/main/java"));
+        var sourceDirectory = Path.of(options.inputDirectory, "src/main/java");
+        if (!sourceDirectory.toFile().exists()) {
+            return List.of();
+        }
+
+        var sourceRoot = new SourceRoot(sourceDirectory);
         var compilationUnits = new ArrayList<CompilationUnit>();
         for (ParseResult<CompilationUnit> parseResult : sourceRoot.tryToParse()) {
             compilationUnits.add(parseResult.getResult().get());

src/main/java/analyzer/exercises/hamming/HammingAnalyzer.java

@@ -20,16 +20,6 @@ public void analyze(List<CompilationUnit> compilationUnits, Analysis analysis) {
 
         compilationUnits.forEach(cu -> cu.walk(ClassOrInterfaceDeclaration.class, walker));
 
-        if (!walker.hasHammingClass()) {
-            analysis.addComment(new UseProperClassName("Hamming"));
-            return;
-        }
-
-        if (!walker.hasGetHammingDistanceMethod()) {
-            analysis.addComment(new UseProperMethodName("getHammingDistance"));
-            return;
-        }
-
         if (!walker.hasConstructor()) {
             analysis.addComment(new MustUseConstructor());
             return;

src/main/java/analyzer/exercises/hamming/HammingWalker.java

@@ -1,7 +1,5 @@
 package analyzer.exercises.hamming;
 
-import static com.google.common.collect.ImmutableSet.toImmutableSet;
-
 import com.github.javaparser.Range;
 import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
 import com.github.javaparser.ast.body.ConstructorDeclaration;
@@ -10,37 +8,32 @@
 import com.github.javaparser.ast.expr.LambdaExpr;
 import com.github.javaparser.ast.expr.MethodCallExpr;
 import com.github.javaparser.ast.nodeTypes.NodeWithRange;
-import com.github.javaparser.ast.stmt.BlockStmt;
-import com.github.javaparser.ast.stmt.ForEachStmt;
-import com.github.javaparser.ast.stmt.ForStmt;
-import com.github.javaparser.ast.stmt.Statement;
-import com.github.javaparser.ast.stmt.ThrowStmt;
-import com.github.javaparser.ast.stmt.WhileStmt;
+import com.github.javaparser.ast.stmt.*;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableListMultimap;
 import com.google.common.collect.ListMultimap;
 import com.google.common.collect.Multimaps;
 
-import static com.google.common.collect.MoreCollectors.toOptional;
-
 import java.util.HashSet;
 import java.util.List;
 import java.util.Optional;
 import java.util.Set;
 import java.util.function.Consumer;
 import java.util.stream.Stream;
 
+import static com.google.common.collect.ImmutableSet.toImmutableSet;
+import static com.google.common.collect.MoreCollectors.toOptional;
+
 class HammingWalker implements Consumer<ClassOrInterfaceDeclaration> {
     private ClassOrInterfaceDeclaration hammingClass;
     private List<ConstructorDeclaration> constructors = ImmutableList.of();
     private ConstructorDeclaration constructor;
     private ListMultimap<String, MethodDeclaration> methods = ImmutableListMultimap.of();
-    private Set<String> methodsCalledByConstructor = new HashSet<>();
+    private final Set<String> methodsCalledByConstructor = new HashSet<>();
     private boolean constructorHasIfStatements;
     private boolean constructorThrowsIllegalArgumentDirectly;
     private boolean constructorMayCalculateDistanceDirectly;
-    private MethodDeclaration getHammingDistanceMethod;
-    private Set<String> methodsCalledByGetHammingDistance = new HashSet<>();
+    private final Set<String> methodsCalledByGetHammingDistance = new HashSet<>();
     private boolean getHammingDistanceMayCalculateDistanceDirectly;
 
     @Override
@@ -128,8 +121,6 @@ private Optional<MethodDeclaration> findGetHammingDistanceMethod() {
     }
 
     private void walkGetHammingDistanceMethod(MethodDeclaration getHammingDistanceMethod) {
-        this.getHammingDistanceMethod = getHammingDistanceMethod;
-
         getHammingDistanceMethod.getBody().ifPresent(this::walkGetHammingDistanceMethod);
     }
 
@@ -178,14 +169,6 @@ private Stream<String> getMethodsCalledBy(BlockStmt body) {
             .flatMap(this::getMethodCallNames);
     }
 
-    public boolean hasHammingClass() {
-        return hammingClass != null;
-    }
-
-    public boolean hasGetHammingDistanceMethod() {
-        return getHammingDistanceMethod != null;
-    }
-
     public boolean hasConstructor() {
         return constructor != null;
     }

src/main/java/analyzer/exercises/twofer/TwoferAnalyzer.java

@@ -17,11 +17,7 @@ public void analyze(List<CompilationUnit> compilationUnits, Analysis analysis) {
 
         compilationUnits.forEach(cu -> cu.walk(walker));
 
-        if (!walker.hasClassTwofer) {
-            analysis.addComment(new UseProperClassName("Twofer"));
-        } else if (!walker.hasMethodTwofer) {
-            analysis.addComment(new UseProperMethodName("twofer"));
-        } else if (walker.hasHardCodedTestCases) {
+        if (walker.hasHardCodedTestCases) {
             analysis.addComment(new AvoidHardCodedTestCases());
         } else if (walker.usesLambda) {
             // could be used later for additional comments?

src/main/java/analyzer/exercises/twofer/TwoferWalker.java

@@ -1,15 +1,15 @@
 package analyzer.exercises.twofer;
 
 import com.github.javaparser.ast.Node;
-import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
-import com.github.javaparser.ast.body.MethodDeclaration;
-import com.github.javaparser.ast.expr.*;
+import com.github.javaparser.ast.expr.ConditionalExpr;
+import com.github.javaparser.ast.expr.LambdaExpr;
+import com.github.javaparser.ast.expr.MethodCallExpr;
+import com.github.javaparser.ast.expr.StringLiteralExpr;
 import com.github.javaparser.ast.stmt.*;
+
 import java.util.function.Consumer;
 
 class TwoferWalker implements Consumer<Node> {
-    boolean hasClassTwofer;
-    boolean hasMethodTwofer;
     boolean hasHardCodedTestCases;
     boolean usesIfStatement;
     boolean usesConditional;
@@ -21,11 +21,7 @@ class TwoferWalker implements Consumer<Node> {
 
     @Override
     public void accept(Node node) {
-        if (node instanceof ClassOrInterfaceDeclaration) {
-            this.hasClassTwofer = ((ClassOrInterfaceDeclaration) node).getName().toString().equals("Twofer");
-        } else if (node instanceof MethodDeclaration methodDeclaration && methodDeclaration.getNameAsString().equals("twofer")) {
-            this.hasMethodTwofer = true;
-        } else if (node instanceof StringLiteralExpr && !this.hasHardCodedTestCases) {
+        if (node instanceof StringLiteralExpr && !this.hasHardCodedTestCases) {
             this.hasHardCodedTestCases = node.toString().contains("Alice") || node.toString().contains("Bob");
         } else if (node instanceof ReturnStmt) {
             this.returnCount++;

src/test/java/analyzer/AnalyzerTest.java

@@ -1,25 +1,15 @@
 package analyzer;
 
 import com.github.javaparser.StaticJavaParser;
-import com.github.javaparser.ast.CompilationUnit;
 
 import java.util.List;
 
 public abstract class AnalyzerTest {
     protected abstract Analyzer getAnalyzer();
 
-    protected Analysis analyzeResourceFile(String resourceFileName) {
-        var resource = getClass().getResourceAsStream(resourceFileName);
-        return analyze(StaticJavaParser.parse(resource));
-    }
-
-    protected Analysis analyzeString(String javaCode) {
-        return analyze(StaticJavaParser.parse(javaCode));
-    }
-
-    private Analysis analyze(CompilationUnit compilationUnit) {
+    protected Analysis analyze(String javaCode) {
         var analysis = new Analysis();
-        getAnalyzer().analyze(List.of(compilationUnit), analysis);
+        getAnalyzer().analyze(List.of(StaticJavaParser.parse(javaCode)), analysis);
         return analysis;
     }
 }

src/test/java/analyzer/exercises/GlobalAnalyzerTest.java

@@ -20,7 +20,7 @@ protected Analyzer getAnalyzer() {
     @MethodSource
     @ParameterizedTest
     public void solutionsWithMainMethod(String solution) {
-        var actual = analyzeString(solution);
+        var actual = analyze(solution);
         assertThat(actual.getComments()).contains(new DoNotUseMainMethod());
     }
 
@@ -44,7 +44,7 @@ public static void main(String[] args) {}
     @MethodSource
     @ParameterizedTest
     public void solutionsWithPrintStatements(String solution) {
-        var actual = analyzeString(solution);
+        var actual = analyze(solution);
         assertThat(actual.getComments()).contains(new AvoidPrintStatements());
     }