= Fix and refactor tests

- Removes huge amount of code duplication

== Renames AbstractTestParent to AbstractTest

Fix and refactor the file, removing code duplication and providing new methods for test classes.

== Fix and refactor TagTest
== Fix and refactor InterfaceTest
== Fix and refactor Methods Tests

- Split tests for each Method file inside the simpledata package into different test classes
- Create AbstractMethodTest class to provide utility methods to remove the huge amount of code duplication

== Renames files Method1.java, Method2.java and Method3.java to MethodsA, MethodsB and MethodsC

Since files such as Method1 has methods named method1, method2 and so on, while file Method2 has methods with the same names, that was causing confusion.

Signed-off-by: Manoel Campos <manoelcampos@gmail.com>

Author: manoelcampos

src/main/java/com/github/markusbernhardt/xmldoclet/XmlDoclet.java

@@ -33,7 +33,7 @@ public final class XmlDoclet implements Doclet {
     /**
      * The parsed object model. Used in unit tests.
      */
-    private Root root;
+    private static Root root;
 
     /**
      * The Options instance to parse command line strings, that defines the supported XMLDoclet {@link #options}.
@@ -263,4 +263,8 @@ public CommandLine parseCommandLine(final String[][] optionsMatrix) {
             return CommandLine.builder().build();
         }
     }
+
+    public static Root getRoot() {
+        return root;
+    }
 }

src/test/java/com/github/markusbernhardt/xmldoclet/AbstractMethodsTest.java

@@ -0,0 +1,93 @@
+package com.github.markusbernhardt.xmldoclet;
+
+import com.github.markusbernhardt.xmldoclet.xjc.Method;
+import com.github.markusbernhardt.xmldoclet.xjc.MethodParameter;
+import com.github.markusbernhardt.xmldoclet.xjc.TypeInfo;
+
+import java.util.List;
+
+import static org.junit.Assert.*;
+
+/**
+ * Base class for implementing tests for methods.
+ */
+abstract class AbstractMethodsTest extends AbstractTest {
+    protected final List<Method> testMethods;
+
+    public AbstractMethodsTest(final String sourceFileName) {
+        final var javadocElemenets = newJavaDocElements(sourceFileName);
+        this.testMethods = javadocElemenets.classNode().getMethod();
+    }
+
+    /**
+     * Short way of finding methodNodes. It's meant to only be used for methodNodes that do not
+     * share the same name in the same class. In fact, this class will junit assert that there is
+     * only 1 methodNode matching this name in the supplied <code>list</code>
+     * methodParameterNodeeter.
+     *
+     * @param methodNodeName the shortname of the methodNode
+     * @return The matching methodNode
+     */
+    protected Method findByMethodName(final String methodNodeName) {
+        for (final Method methodNode : testMethods) {
+            if (methodNode.getName().equals(methodNodeName)) {
+                return methodNode;
+            }
+        }
+
+        fail();
+        return null;
+    }
+
+    protected static void checkParamType(final TypeInfo methodParamType, final String fullQualifiedParamType) {
+        assertEquals(methodParamType.getQualified(), fullQualifiedParamType);
+    }
+
+    protected Method assertMethodSignature(
+            final String methodName, final int paramCount, final String paramTypeList) {
+        final Method methodNode = findByMethodName(methodName);
+        assertEquals(methodNode.getParameter().size(), paramCount);
+        assertEquals(methodNode.getSignature(), paramTypeList);
+        return methodNode;
+    }
+
+    /**
+     * Asserts that the first parameter of the given method has the provided full qualified name
+     * @param method method to check
+     * @param fullQualifiedParamType full qualified name of the first parameter
+     * @return the method's first parameter
+     */
+    protected MethodParameter assertParamTypes(final Method method, final String fullQualifiedParamType) {
+        assertParamTypes(method, new String[] {fullQualifiedParamType});
+        return method.getParameter().getFirst();
+    }
+
+    /**
+     * Asserts that the parameters of the given method have the provided full qualified names
+     * @param method method to check
+     * @param fullQualifiedParamTypes full qualified names of the method's parameters
+     */
+    protected void assertParamTypes(final Method method, final String... fullQualifiedParamTypes) {
+        for (int i = 0; i < fullQualifiedParamTypes.length; i++) {
+            final String paramType = fullQualifiedParamTypes[i];
+            final var methodParameter = method.getParameter().get(i);
+            assertEquals(methodParameter.getType().getQualified(), paramType);
+        }
+    }
+
+    protected static void paramHasNoGenericsNoDimensionNoWildcard(final TypeInfo paramTypeInfo) {
+        paramHasNoDimensionNoWildcard(paramTypeInfo, 0);
+    }
+
+    /**
+     * Asserts that a method parameter has no dimension, no wildcard and a given number of
+     * generic types (types between &lt; and &gt;).
+     * @param paramTypeInfo type information for a method parameter
+     * @param paramGenericTypes number of generic types expected for the parameter type
+     */
+    protected static void paramHasNoDimensionNoWildcard(final TypeInfo paramTypeInfo, final int paramGenericTypes) {
+        assertNull(paramTypeInfo.getDimension());
+        assertNull(paramTypeInfo.getWildcard());
+        assertEquals(paramTypeInfo.getGeneric().size(), paramGenericTypes);
+    }
+}

src/test/java/com/github/markusbernhardt/xmldoclet/AbstractTest.java

@@ -0,0 +1,197 @@
+package com.github.markusbernhardt.xmldoclet;
+
+import com.github.markusbernhardt.xmldoclet.xjc.Class;
+import com.github.markusbernhardt.xmldoclet.xjc.Package;
+import com.github.markusbernhardt.xmldoclet.xjc.Root;
+import org.junit.Test;
+
+import java.io.File;
+import java.io.PrintWriter;
+import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.spi.ToolProvider;
+
+import static java.util.Arrays.stream;
+
+/**
+ * Base class for all tests.
+ *
+ * @author markus
+ */
+abstract class AbstractTest {
+    private final static Logger LOGGER = Logger.getLogger(AbstractTest.class.getName());
+
+    protected static final String[] TEST_DIR = { "./src/test/java/" };
+    protected static final String SIMPLE_DATA_PACKAGE = "com.github.markusbernhardt.xmldoclet.simpledata";
+    protected static final String SIMPLE_DATA_DIR = TEST_DIR[0] + SIMPLE_DATA_PACKAGE.replaceAll("\\.", "/");
+
+    protected static final String[] ARGS = { "-dryrun" };
+    protected static final String[] SUB_PACKAGES = { "com" };
+
+    /**
+     * Gets the first {@link Package} and {@link Class} from a JavaDoc {@link Root} element.
+     * @param sourceFileName Name of a source files inside the {@link #SIMPLE_DATA_DIR} to test.
+     */
+    public JavaDocElements newJavaDocElements(final String ...sourceFileName) {
+        final var sourceFiles = stream(sourceFileName).map(this::getFilePathFromSimpleDataDir).toArray(String[]::new);
+        final var rootNode = executeJavadoc(null, null, null, sourceFiles, null, ARGS);
+
+        final var packageNode = rootNode.getPackage().getFirst();
+        final var classNode = packageNode.getClazz().getFirst();
+        return new JavaDocElements(rootNode, packageNode, classNode);
+    }
+
+    /**
+     * Rigourous Parser :-)
+     */
+    @Test
+    public void testSampledoc() {
+        executeJavadoc(".", TEST_DIR, null, null, SUB_PACKAGES, ARGS);
+    }
+
+    /**
+     * Processes the source code using javadoc.
+     *
+     * @param extendedClassPath Any classpath information required to help along javadoc. Javadoc
+     *        will actually compile the source code you specify; so if there are any jars or classes
+     *        that are referenced by the source code to process, then including those compiled items
+     *        in the classpath will give you more complete data in the resulting XML.
+     * @param sourcePaths Usually sourcePaths is specified in conjunction with either/both packages &
+     *        subpackages. The sourcepaths value should be the path of the source files right before
+     *        the standard package-based folder layout of projects begins. For example, if you have
+     *        code that exists in package foo.bar, and your code is physically in /MyFolder/foo/bar/,
+     *        then the sourcePaths would be /MyFolder
+     * @param packages Use if you want to detail specific packages to process (contrast with
+     *        subpackages, which is probably the easiest/most brute force way of using xml-doclet).
+     *        If you have within your code two packages, foo.bar and bar.foo, but only wanted
+     *        foo.bar processed, then specify just 'foo.bar' for this argument.
+     * @param sourceFiles You can specify source files individually. This usually is used instead of
+     *        sourcePaths/subPackages/packages. If you use this parameter, specify the full path of
+     *        any java file you want processed.
+     * @param subPackages You can specify 'subPackages', which simply gives one an easy way to
+     *        specify the root package, and have javadoc recursively look through everything under
+     *        that package. So for instance, if you had foo.bar, foo.bar.bar, and bar.foo,
+     *        specifying 'foo' will process foo.bar and foo.bar.bar packages, but not bar.foo
+     *        (unless you specify 'bar' as a subpackage, too)
+     * @param additionalArguments Additional Arguments.
+     * @return XStream compatible data structure
+     */
+    public Root executeJavadoc(
+            final String extendedClassPath, final String[] sourcePaths, final String[] packages,
+            final String[] sourceFiles, final String[] subPackages, final String[] additionalArguments) {
+        try {
+
+            final var errorWriter = new PrintWriter(System.err, true, Charset.defaultCharset());
+            final var infoWriter = new PrintWriter(System.out, true, Charset.defaultCharset());
+
+            // aggregate arguments and packages
+            final var argumentList = new ArrayList<String>();
+
+            // by setting this to 'private', nothing is omitted in the parsing
+            argumentList.add("-private");
+
+            final String classPath = getClassPath(extendedClassPath);
+            argumentList.add("-classpath");
+            argumentList.add(classPath);
+
+            if (sourcePaths != null) {
+                final String concatedSourcePaths = join(File.pathSeparator, sourcePaths);
+                if (!concatedSourcePaths.isEmpty()) {
+                    argumentList.add("-sourcepath");
+                    argumentList.add(concatedSourcePaths);
+                }
+            }
+
+            if (subPackages != null) {
+                final String concatedSubPackages = join(";", subPackages);
+                if (!concatedSubPackages.isEmpty()) {
+                    argumentList.add("-subpackages");
+                    argumentList.add(concatedSubPackages);
+                }
+            }
+
+            if (packages != null) {
+                argumentList.addAll(Arrays.asList(packages));
+            }
+
+            if (sourceFiles != null) {
+                argumentList.addAll(Arrays.asList(sourceFiles));
+            }
+
+            if (additionalArguments != null) {
+                argumentList.addAll(Arrays.asList(additionalArguments));
+            }
+
+            LOGGER.info("Executing doclet with arguments: " + join(" ", argumentList));
+
+            final var javadoc = ToolProvider.findFirst("javadoc").orElseThrow();
+            final String[] arguments = argumentList.toArray(new String[] {});
+            javadoc.run(infoWriter, errorWriter, arguments);
+
+            LOGGER.info("done with doclet processing");
+        } catch (Exception e) {
+            LOGGER.log(Level.SEVERE, "doclet exception", e);
+        } catch (Error e) {
+            LOGGER.log(Level.SEVERE, "doclet error", e);
+        }
+
+        return XmlDoclet.getRoot();
+    }
+
+    private static String getClassPath(final String extendedClassPath) {
+        final String classPath = System.getProperty("java.class.path", ".");
+        return extendedClassPath == null ? classPath : classPath + File.pathSeparator + extendedClassPath;
+
+    }
+
+    /**
+     * Helper method to concat strings.
+     *
+     * @param glue the separator.
+     * @param strings the strings to concat.
+     * @return concatenated string
+     */
+    public static String join(final String glue, final String[] strings) {
+        return join(glue, Arrays.asList(strings));
+    }
+
+    /**
+     * Helper method to concat strings.
+     *
+     * @param glue the separator.
+     * @param strings the strings to concat.
+     * @return concatenated string
+     */
+    public static String join(final String glue, final List<String> strings) {
+        if (strings == null) {
+            return null;
+        }
+
+        return String.join(glue, strings);
+    }
+
+
+    /**
+     * {@return the path (separated by /) to a source file in the {@link #SIMPLE_DATA_DIR}}
+     * @param sourceFileName the name of the file to get its full path from the {@link #SIMPLE_DATA_DIR}
+     */
+    protected String getFilePathFromSimpleDataDir(final String sourceFileName) {
+        return join("/", List.of(SIMPLE_DATA_DIR, sourceFileName));
+    }
+
+    /**
+     * {@return the full qualified name of a class, interface, record, enum or even some other element inside
+     * those ones (separated by .) in the {@link #SIMPLE_DATA_PACKAGE}}
+     * Those internal elements can be something such as fields, methods, constructors, etc.
+     * @param elementName the name of the element (class, interface, record, method, etc.) to get its
+     *                    full qualified name from the {@link #SIMPLE_DATA_PACKAGE}
+     */
+    protected static String getElementPathFromSimpleDataPackage(final String elementName) {
+        return join(".", List.of(SIMPLE_DATA_PACKAGE, elementName));
+    }
+
+}