First version

Author: leifgehrmann

.eslintrc.json

@@ -0,0 +1,11 @@
+{
+  "env": {
+    "node": true,
+    "es6": true,
+    "jest": true
+  },
+  "parserOptions": {
+    "ecmaVersion": 2017
+  },
+  "extends": "airbnb-base"
+}

.gitignore

@@ -0,0 +1,4 @@
+.idea
+node_modules
+coverage
+tests/testCases/actual

ParameterizedTest.java

@@ -0,0 +1,11 @@
+package x.x.x;
+
+import org.junit.Test;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD})
+public @interface ParameterizedTest {
+    Class<? extends Throwable> expected() default Test.None.class;
+}

README.md

@@ -0,0 +1,101 @@
+# junit4-parameterized-tests-generator
+
+[![Build Status](https://github.com/leifgehrmann/junit4-parameterized-tests-generator/workflows/Tests/badge.svg?branch=master)](https://github.com/leifgehrmann/junit4-parameterized-tests-generator/actions)
+
+Script to generate parameterized JUnit-4 tests for test runners that do not
+support parameterized tests.
+
+## Purpose
+
+JUnit-4 has a design flaw where [test runners] cannot be combined to perform
+multiple behaviours. For example, JUnit's [`Parameterized`] test runner cannot
+be combined with [`RobolectricTestRunner`], or any other test runner because
+only one `@RunWith` annotation is permitted per class.
+
+[test runners]: https://github.com/junit-team/junit4/wiki/Test-runners
+[`Parameterized`]: https://github.com/junit-team/junit4/wiki/Parameterized-tests
+[`RobolectricTestRunner`]: http://robolectric.org
+
+`generateParameterizedTests.js` solves this by parsing special comments in the
+test...
+
+```java
+class StepUnitFormatterTests {
+    //> Zero(0, "0 steps")
+    //> Singular(1, "1 step")
+    //> Plural(2, "2 steps")
+    //> 999(999, "999 steps")
+    //> Thousand(1000, "1,000 steps")
+    //> Million(1000000, "1,000,000 steps")
+    //> Decimal(3.3, "3 steps")
+    //> Negative(-5, "0 steps")
+    @ParameterizedTest
+    public void testFormat(double numberOfSteps, String expected) {
+        Assert.assertEquals(expected, StepUnitFormatter().format(numberOfSteps));
+    }
+}
+```
+
+...and converting them to individual tests, which get appended to the end of
+the file like this:
+
+```java
+    // DO NOT EDIT BELOW THIS LINE 
+
+    @Test
+    public void testFormatZero() {
+        testFormat(0, "0 steps")
+    }
+
+    @Test
+    public void testFormatSingular() {
+        testFormat(1, "1 step")
+    }
+    
+    @Test
+    public void testFormatPlural() {
+        testFormat(2, "2 steps")
+    }
+    
+    // Etc.
+}
+```
+
+## Installation
+
+1. Copy `generateParameterizedTests.js` anywhere into your Java project.
+2. Copy `ParameterizedTest.java` into your test source code folder.
+3. Update `package x.x.x;` in `ParameterizedTest.java` to reflect your
+   project's package structure.
+
+## Running
+
+Node must be installed, but `npm install` is not required. To generate the
+parameterized tests, run the following:
+
+```shell script
+$ node generateParameterizedTests.js path/to/tests 
+```
+
+### Running automatically using Gradle
+
+To avoid having to run the generator manually, a task can be added to your
+`build.gradle` file to run the script on `preBuild`, or any other preferred
+gradle task.
+
+```gradle
+task generateParameterizedTests(type: Exec) {
+    executable "sh"
+    args "-c", "node scripts/generateParameterizedTests.js src/test"
+}
+
+preBuild.dependsOn generateParameterizedTests
+```  
+
+## Attribution
+
+This code is dedicated to the public domain, so no attribution is needed.
+
+This script is based on [a similar implementation by Elliot Chance for
+generating parameterized tests in Swift](
+https://medium.com/@elliotchance/parameterized-data-driven-tests-in-swift-3b9a46891801).

UNLICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <https://unlicense.org>

generateParameterizedTests.js

@@ -0,0 +1,176 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Returns an array of files (absolute path) matching a file extension in a
+ * directory.
+ *
+ * @param {string} directory
+ * @param {string} extension
+ *
+ * @returns {string[]}
+ */
+function getFilesWithExtension(directory, extension) {
+  const matchedFiles = [];
+
+  if (!fs.existsSync(directory)) {
+    throw new Error(`Directory "${directory}" does not exist`);
+  }
+
+  const files = fs.readdirSync(directory);
+  for (let i = 0; i < files.length; i += 1) {
+    const filename = path.join(directory, files[i]);
+    const stat = fs.lstatSync(filename);
+    if (stat.isDirectory()) {
+      // Recurse
+      const nestedMatchedFiles = getFilesWithExtension(filename, extension);
+      matchedFiles.push(...nestedMatchedFiles);
+    } else if (filename.endsWith(extension)) {
+      matchedFiles.push(filename);
+    }
+  }
+
+  return matchedFiles;
+}
+
+/**
+ * @param {string} line
+ *
+ * @returns {null|{testCaseName: string, testCaseArguments: string}}
+ */
+function parseParameterizedTestCase(line) {
+  const regex = /^\s*\/\/>\s*(\w*)(.*)\s*$/m;
+  const matches = regex.exec(line);
+  if (matches === null) {
+    return null;
+  }
+  return {
+    testCaseName: matches[1],
+    testCaseArguments: matches[2],
+  };
+}
+
+/**
+ * @param {string} line
+ *
+ * @returns {null|string}
+ */
+function parseParameterizedTestAnnotation(line) {
+  const regex = /^\s*@ParameterizedTest(.*)$/m;
+  const matches = regex.exec(line);
+  if (matches === null) {
+    return null;
+  }
+  return matches[1];
+}
+
+/**
+ * @param {string} line
+ *
+ * @returns {null|string}
+ */
+function parseTestFunction(line) {
+  const regex = /^\s*public\s*void\s*([a-zA-Z0-9_]*)(.*)$/m;
+  const matches = regex.exec(line);
+  if (matches === null) {
+    return null;
+  }
+  return matches[1];
+}
+
+/**
+ * @param {string} testName
+ * @param {string} testAnnotation
+ * @param {{testCaseName: string, testCaseArguments: string}[]} testCases
+ *
+ * @returns {string[]}
+ */
+function generateTestsForParameterizedTest(testName, testAnnotation, testCases) {
+  return testCases.map((testCase) => `
+    @Test${testAnnotation}
+    public void ${testName + testCase.testCaseName}() {
+        ${testName + testCase.testCaseArguments};
+    }`);
+}
+
+/**
+ * @param {string} filepath
+ */
+function processFile(filepath) {
+  const dividingLine = '\n    // DO NOT EDIT BELOW THIS LINE\n';
+  const generatedTests = [];
+
+  // Keep track of various tokens while processing the file
+  let parameterizedTestCases = [];
+  let parameterizedTestAnnotation = null;
+
+  // Read contents of the file
+  const fileContent = fs.readFileSync(filepath, 'UTF-8');
+  const lines = fileContent.split(/\r?\n/);
+
+  // For each line in the file
+  lines.forEach((line) => {
+    // Find parameterized test cases
+    const parsedParameterizedTestCase = parseParameterizedTestCase(line);
+    if (parsedParameterizedTestCase !== null) {
+      parameterizedTestCases.push(parsedParameterizedTestCase);
+      return;
+    }
+
+    // Find parameterized test annotations, which may include "expected=..."
+    // attributes
+    const parsedParameterizedTestAnnotation = parseParameterizedTestAnnotation(
+      line,
+    );
+    if (parsedParameterizedTestAnnotation !== null) {
+      parameterizedTestAnnotation = parsedParameterizedTestAnnotation;
+      return;
+    }
+
+    // Find the parameterized test name
+    const parsedParameterizedTestName = parseTestFunction(line);
+    if (parsedParameterizedTestName !== null) {
+      if (
+        parameterizedTestCases.length > 0
+        && parameterizedTestAnnotation !== null
+      ) {
+        generatedTests.push(
+          ...generateTestsForParameterizedTest(
+            parsedParameterizedTestName,
+            parameterizedTestAnnotation,
+            parameterizedTestCases,
+          ),
+        );
+      }
+      parameterizedTestCases = [];
+      parameterizedTestAnnotation = null;
+    }
+  });
+
+  // If no parameterized tests were found, do not change anything
+  if (generatedTests.length === 0) {
+    return;
+  }
+
+  // Determine where to append the generated tests
+  let newFileContent;
+  const dividingLinePosition = fileContent.indexOf(dividingLine);
+  if (dividingLinePosition === -1) {
+    // Find the last '}' at the end of the file
+    newFileContent = fileContent.replace(/\s*}\s*$/g, '\n');
+  } else {
+    // Find the dividing line position
+    newFileContent = fileContent.substring(0, dividingLinePosition);
+  }
+
+  // Append generated tests to end of file
+  newFileContent += dividingLine;
+  newFileContent += generatedTests.join('\n');
+  newFileContent += '\n}\n';
+  fs.writeFileSync(filepath, newFileContent);
+}
+
+const testDir = `${process.cwd()}/${process.argv[2]}`;
+getFilesWithExtension(testDir, '.java').forEach((filepath) => {
+  processFile(filepath);
+});

jestconfig.json

@@ -0,0 +1,5 @@
+{
+  "testRegex": "/tests/.*\\.(test|spec)?\\.(js|jsx)$",
+  "collectCoverage": true,
+  "collectCoverageFrom": ["generateParameterizedTests.js"]
+}