clean up and added comments for understaing override of runner tags

Jana S · Jana S · commit 25fab3ff5674 · 2025-01-20T09:50:19.000Z
diff --git a/src/main/java/com/pdsl/gherkin/filter/GherkinTagFiltererAdapter.java b/src/main/java/com/pdsl/gherkin/filter/GherkinTagFiltererAdapter.java
@@ -5,14 +5,36 @@
 import java.util.Set;
 import java.util.stream.Collectors;
 
+/**
+ * This class adapts the `GherkinTagFilterer` interface to the `TagFilterer` interface. It provides
+ * a way to use the functionality of `GherkinTagFilterer` with code that expects a `TagFilterer`.
+ */
 public class GherkinTagFiltererAdapter implements TagFilterer {
 
+  /**
+   * The instance of the `GherkinTagFilterer` to be adapted.
+   */
   private final GherkinTagFilterer gherkinTagFilterer;
 
+  /**
+   * Constructor for the `GherkinTagFiltererAdapter`.
+   *
+   * @param gherkinTagFilterer The instance of the `GherkinTagFilterer` to be adapted.
+   */
   public GherkinTagFiltererAdapter(GherkinTagFilterer gherkinTagFilterer) {
     this.gherkinTagFilterer = gherkinTagFilterer;
   }
 
+  /**
+   * This method checks whether a collection of tags matches a given tag expression. It converts the
+   * collection of tags to a `Set` using a `HashSet` and then delegates the logic to the
+   * `gherkinTagFilterer.tagExpressionMatchesPickle` method.
+   *
+   * @param tags The collection of tags to be checked.
+   * @param tagExpression The tag expression to match against.
+   * @return True if the tags match the tag expression, False otherwise.
+   */
+
   @Override
   public boolean tagExpressionMatches(Collection<String> tags, String tagExpression) {
     return gherkinTagFilterer.tagExpressionMatchesPickle(new HashSet<>(tags), tagExpression);
diff --git a/src/main/java/com/pdsl/runners/PdslTestParams.java b/src/main/java/com/pdsl/runners/PdslTestParams.java
@@ -37,7 +37,13 @@ public static PdslTestParams from(
         List<String> tags,
         String[] includesResources,
         String[] excludesResources){
-        return new PdslTestParams(lexerRecognizerClass,parserRecognizerClass,interpreters,tags,includesResources,excludesResources,(tags1, tagExpression) -> true,"");
+
+         /* Creates a default tag filter that always returns true, effectively disabling tag filtering.,
+         Empty tag expression as no filtering is applied */
+        return new PdslTestParams(
+            lexerRecognizerClass, parserRecognizerClass, interpreters,
+            tags, includesResources, excludesResources,
+            (tags1, tagExpression) -> true, "");
     }
     /**
      * A visitor used to extend the behavior of the PdslTestParams obje3ct without modifying
diff --git a/src/main/java/com/pdsl/runners/SharedTestSuiteVisitor.java b/src/main/java/com/pdsl/runners/SharedTestSuiteVisitor.java
@@ -63,18 +63,32 @@ public SharedTestSuite recognizerParamsOperation(RecognizerParams recognizerPara
                 // test cases to create from each file, which parts to ignore, etc.
                 Collection<TestSpecification> specifications = getSpecifications(parser, recognizerParams, params, testResources);
                 // Convert the specificaitons into test cases
+
+                /*
+                 * Filters test cases based on tags and organizes them per interpreter.
+                 *
+                 * This code iterates through a collection of test cases for a single interpreter,
+                 * filters them based on tags using a provided `TagFilterer`, and then adds the
+                 * matched test cases to a list of test cases per interpreter. It also collects
+                 * the interpreter objects.
+                 */
                 List<TestCase> testCasesForSingleInterpreter = new ArrayList<>(getTestCases(recognizerParams.providers().testCaseFactoryProvider().get(), specifications));
                 for (TestCase testcase : testCasesForSingleInterpreter) {
                     if (testcase instanceof TaggedTestCase) {
+                        // Cast the TestCase to TaggedTestCase to access tag information.
                         TaggedTestCase test = (TaggedTestCase) testcase;
                         //Filter test cases by tags using the injected TagFilterer
+                        // Check if any of the tags on the test case match the given tag expression.
                         boolean anyMatchedTag = params.tagFilterer().tagExpressionMatches(test.getTags(), params.tagExpression());
+                        // If the test case's tags match the tag expression, add it to the matched test cases.
                         if (anyMatchedTag) {
                             matchedTestCases.add(testcase);
                         }
                     }
                 }
+                // Add the list of matched test cases for the current interpreter to the overall list.
                 testCasesPerInterpreters.add(matchedTestCases);
+                // Get the interpreter object from the parser provider and add it to the list of interpreter objects.
                 interpreterObjs.add(parser.interpreterProvider().get());
 
             }
diff --git a/src/main/java/com/pdsl/testcases/PreorderTestCaseFactory.java b/src/main/java/com/pdsl/testcases/PreorderTestCaseFactory.java
@@ -27,18 +27,16 @@ public static final class DefaultProvider implements Provider<TestCaseFactory> {
         public PreorderTestCaseFactory get() {
             return INSTANCE;
         }
-
     }
+
     public static final class DefaultSupplier implements Supplier<TestCaseFactory> {
 
         @Override
         public TestCaseFactory get() {
             return INSTANCE;
         }
-
     }
 
-
     @Override
     public Collection<TestCase> processTestSpecification(Collection<TestSpecification> testSpecifications) {
         Collection<TestCase> testCases = new ArrayList<>(testSpecifications.size()); // Will likely need to be resized regardless
@@ -80,9 +78,6 @@ private List<TestCase> recursiveWalkAndCreateOnLeaf(TestSpecification testSpecif
           if (!tags.isEmpty()) {
             testCase = new DefaultTaggedTestCase(testCase, tags);
           }
-
-
-
           List<TestCase> singleTestCase = new ArrayList<>(1);
           singleTestCase.add(testCase);
           return singleTestCase;
diff --git a/src/main/java/org/junit/jupiter/engine/descriptor/PdslTestParameter.java b/src/main/java/org/junit/jupiter/engine/descriptor/PdslTestParameter.java
@@ -205,20 +205,25 @@ public Builder withVisitor(Supplier<? extends ParseTreeVisitor<?>>  visitor) {
             return this;
         }
 
-      public Builder withTagExpression(String str) {
-        Preconditions.checkNotNull(str, "Tag expression cannot be null!");
-        String commandLineTags = System.getProperty("tags");
-        if(commandLineTags != null && !commandLineTags.isEmpty()) {
-          this.tagExpression = commandLineTags;
-          logger.info("Overriding runner tags with tags provided in the command line {%s}".formatted(commandLineTags) );
-          logger.info("Ignoring provided tag expression {%s}".formatted(str) );
-        } else {
-          this.tagExpression =str;
+        public Builder withTagExpression(String str) {
+          Preconditions.checkNotNull(str, "Tag expression cannot be null!");
+          // Check if there are tags specified using the system property "tags".
+          String commandLineTags = System.getProperty("tags");
+          if (commandLineTags != null && !commandLineTags.isEmpty()) {
+            // If command-line tags are present, use them and log a message informing the user
+            // that the provided tag expression is being ignored.
+            this.tagExpression = commandLineTags;
+            logger.info("Overriding runner tags with tags provided in the command line {%s}".formatted(
+                commandLineTags));
+            logger.info("Ignoring provided tag expression {%s}".formatted(str));
+          } else {
+            // If no command-line tags are present, use the provided tag expression.
+            this.tagExpression = str;
+          }
+
+          return this;
         }
 
-        return this;
-      }
-
         public Builder withIncludedResources(String[] resources) {
             this.includesResources = resources;
             return this;
@@ -246,52 +251,5 @@ public PdslTestParameter build() {
             return new PdslTestParameter(this);
         }
     }
-    public static PdslTestParameter createTestParameter(Supplier<ParseTreeListener> parseTreeListenerSupplier,
-        Class<? extends Lexer> lexerClass,
-        Class<? extends Parser> parserClass,
-        String[] includedResources) {
-        String defaultTagExpression = "@comment_tag#2";
-        String commandLineTags = System.getProperty("tags"); // Get the value
-
-        String effectiveTagExpression = (commandLineTags != null && !commandLineTags.isEmpty())
-            ? commandLineTags
-            : defaultTagExpression;
-
-        return new PdslTestParameter.Builder(parseTreeListenerSupplier, lexerClass, parserClass)
-            .withTagExpression(effectiveTagExpression)
-            .withIncludedResources(includedResources)
-            .build();
-    }
-
-    /**
-   * I've introduced a static factory method createTestParameter. This method handles the logic for
-   * overriding the tag expression. This keeps the builder focused on building objects and separates
-   * the configuration logic.
-   */
-  public static PdslTestParameter createTestParameter(
-      Supplier<ParseTreeListener> parseTreeListenerSupplier,
-      Class<? extends Lexer> lexerClass,
-      Class<? extends Parser> parserClass,
-      String[] includedResources, String defaultTagExpression) {
-    // retrieves the value passed from the command line (e.g., -Dtags="@smoke").
-    String commandLineTags = System.getProperty("tags");
-    // handles the logic for overriding the tag expression
-    String effectiveTagExpression = (commandLineTags != null && !commandLineTags.isEmpty())
-        ? commandLineTags
-        : defaultTagExpression;
-
-    // // String effectiveTagExpression = defaultTagExpression;  // Use default if invalid format
-    // if (commandLineTags != null && !commandLineTags.isEmpty()) {
-    //   String pattern = "^(?:@\\w+(?: and | or )?)*@\\w+$";
-    //   if (Pattern.matches(pattern, commandLineTags)) {
-    //     // ... logic to build effectiveTagExpression from commandLineTags (as shown above) ...
-    //   }
-    // }
-
-    return new PdslTestParameter.Builder(parseTreeListenerSupplier, lexerClass, parserClass)
-        .withTagExpression(effectiveTagExpression)
-        .withIncludedResources(includedResources)
-        .build();
-  }
 }
 
diff --git a/src/test/java/com/pdsl/uat/java/jupiter/OverrideRunnerTagViaCLITest.java b/src/test/java/com/pdsl/uat/java/jupiter/OverrideRunnerTagViaCLITest.java
@@ -4,27 +4,9 @@
 import com.pdsl.grammars.AllGrammarsLexer;
 import com.pdsl.grammars.AllGrammarsParser;
 import com.pdsl.grammars.AllGrammarsParserBaseVisitor;
-import com.pdsl.grammars.InterpreterAllLexer;
-import com.pdsl.grammars.InterpreterAllParser;
-import com.pdsl.grammars.MultiInterpreter2Parser;
-import com.pdsl.grammars.MultiInterpreter2Parser.ExecuteSentenceContext;
-import com.pdsl.grammars.MultiInterpreter2Parser.ParserTwoAllRulesContext;
-import com.pdsl.grammars.MultiInterpreter2ParserVisitor;
-import com.pdsl.grammars.MultiInterpreterParser.ExecutedByAllParsersContext;
-import com.pdsl.grammars.MultiInterpreterParser.FirstInterpreterContext;
-import com.pdsl.grammars.MultiInterpreterParser.IgnoreInterpreterContext;
-import com.pdsl.grammars.MultiInterpreterParser.ParseSentenceContext;
-import com.pdsl.grammars.MultiInterpreterParser.ParsedByAllInterpretersContext;
-import com.pdsl.grammars.MultiInterpreterParser.ParserOneAllRulesContext;
-import com.pdsl.grammars.MultiInterpreterParser.RecognizeInterpreterContext;
-import com.pdsl.grammars.MultiInterpreterParserVisitor;
-import com.pdsl.grammars.MultiInterpreterRecognizerLexer;
-import com.pdsl.grammars.MultiInterpreterRecognizerParser;
 import java.nio.file.Paths;
 import java.util.List;
-import java.util.logging.Logger;
 import java.util.stream.Stream;
-import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor;
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.TestTemplate;
@@ -37,23 +19,43 @@
 import org.junit.jupiter.engine.descriptor.PdslSharedInvocationContextProvider;
 import org.junit.jupiter.engine.descriptor.PdslTestParameter;
 
+/**
+ * This test class demonstrates how to override the tag expression set in the test
+ * with tags provided via the command line using the system property "tags".
+ */
 public class OverrideRunnerTagViaCLITest {
 
   private static int totalRunTests = 0;
 
+  /**
+   * This test template uses the `PdslExtension` to configure and run the test.
+   * The purpose of this test is to verify that the total number of tests run is 1.
+   */
   @TestTemplate
   @ExtendWith(PdslExtension.class)
   public void pdslGherkinTestFrameworkResources(PdslExecutable executable) {
     totalRunTests++;
   }
 
+  /**
+   * This method asserts that only one test was run. This verifies that the
+   * overridden tag expression from the command line took effect.
+   */
   @AfterAll
   public static void executeAfterAll(){
     Assertions.assertEquals(1,totalRunTests);
   }
 
   private static class PdslExtension extends PdslSharedInvocationContextProvider {
 
+    /**
+     * This method provides the test template invocation contexts.
+     * It sets the system property "tags" to "@ex_tag1" before creating the
+     * PdslConfigParameter and then clears the property afterwards.
+     *
+     * @param context The ExtensionContext for the test.
+     * @return A stream of TestTemplateInvocationContext objects.
+     */
     public Stream<TestTemplateInvocationContext> provideTestTemplateInvocationContexts(
         ExtensionContext context) {
       System.setProperty("tags", "@ex_tag1");
@@ -78,6 +80,7 @@ public Stream<TestTemplateInvocationContext> provideTestTemplateInvocationContex
                       .toUri())
               .build())
           .stream();
+      // Clear command-line tags
       System.clearProperty("tags");
       return contexts;
     }
diff --git a/src/test/java/com/pdsl/uat/java/jupiter/PdslTestParameterTest.java b/src/test/java/com/pdsl/uat/java/jupiter/PdslTestParameterTest.java

Original file line number	Diff line number	Diff line change
`@@ -27,18 +27,16 @@ public static final class DefaultProvider implements Provider<TestCaseFactory> {`
`27`	`27`	`public PreorderTestCaseFactory get() {`
`28`	`28`	`return INSTANCE;`
`29`	`29`	`}`
`30`		`-`
`31`	`30`	`}`
	`31`	`+`
`32`	`32`	`public static final class DefaultSupplier implements Supplier<TestCaseFactory> {`
`33`	`33`
`34`	`34`	`@Override`
`35`	`35`	`public TestCaseFactory get() {`
`36`	`36`	`return INSTANCE;`
`37`	`37`	`}`
`38`		`-`
`39`	`38`	`}`
`40`	`39`
`41`		`-`
`42`	`40`	`@Override`
`43`	`41`	`public Collection<TestCase> processTestSpecification(Collection<TestSpecification> testSpecifications) {`
`44`	`42`	`Collection<TestCase> testCases = new ArrayList<>(testSpecifications.size()); // Will likely need to be resized regardless`
`@@ -80,9 +78,6 @@ private List<TestCase> recursiveWalkAndCreateOnLeaf(TestSpecification testSpecif`
`80`	`78`	`if (!tags.isEmpty()) {`
`81`	`79`	`testCase = new DefaultTaggedTestCase(testCase, tags);`
`82`	`80`	`}`
`83`		`-`
`84`		`-`
`85`		`-`
`86`	`81`	`List<TestCase> singleTestCase = new ArrayList<>(1);`
`87`	`82`	`singleTestCase.add(testCase);`
`88`	`83`	`return singleTestCase;`