From 89bc18d5d2e12d001018f26d136fe2e0d5a3ece4 Mon Sep 17 00:00:00 2001 From: Tobias Stamann Date: Sat, 14 Jul 2018 03:11:17 +0200 Subject: [PATCH] Get rid of tools.jar dependency. Remove usage of compile tools in AnnotationValueUtils. --- .../tools/AnnotationValueUtils.java | 228 ++++++++++++++---- .../tools/AnnotationValueUtilsTest.java | 74 +++++- common/pom.xml | 1 - .../ToolingProvider.java | 3 +- .../ToolingProviderTest.java | 2 - testhelper/pom.xml | 1 - 6 files changed, 246 insertions(+), 63 deletions(-) diff --git a/annotationprocessor/src/main/java/io/toolisticon/annotationprocessortoolkit/tools/AnnotationValueUtils.java b/annotationprocessor/src/main/java/io/toolisticon/annotationprocessortoolkit/tools/AnnotationValueUtils.java index 72e4c504..e17c538e 100644 --- a/annotationprocessor/src/main/java/io/toolisticon/annotationprocessortoolkit/tools/AnnotationValueUtils.java +++ b/annotationprocessor/src/main/java/io/toolisticon/annotationprocessortoolkit/tools/AnnotationValueUtils.java @@ -1,13 +1,12 @@ package io.toolisticon.annotationprocessortoolkit.tools; -import com.sun.tools.javac.code.Attribute; -import com.sun.tools.javac.util.List; - import javax.lang.model.element.AnnotationMirror; import javax.lang.model.element.AnnotationValue; import javax.lang.model.element.VariableElement; +import javax.lang.model.type.DeclaredType; import javax.lang.model.type.TypeMirror; import java.lang.reflect.Array; +import java.util.List; /** * Utility class which helps to handle different {@link AnnotationValue} related tasks. @@ -286,8 +285,8 @@ public static AnnotationMirror getAnnotationValue(AnnotationValue annotationValu * @param annotationValue the value to get the value from. * @return the annotationValues value casted as List of Attributes, or null if value has not the correct type. */ - public static List getArrayValue(AnnotationValue annotationValue) { - return !isArray(annotationValue) ? null : (List) annotationValue.getValue(); + public static List getArrayValue(AnnotationValue annotationValue) { + return !isArray(annotationValue) ? null : (List) annotationValue.getValue(); } @@ -312,11 +311,13 @@ public static TypeMirror[] getTypeAttributeValueArray(AnnotationValue annotation * @param annotationValues the annotation values to be converted to a TypeMirror array * @return */ - public static TypeMirror[] getTypeAttributeValueArray(List annotationValues) { + public static TypeMirror[] getTypeAttributeValueArray(List annotationValues) { TypeMirror[] result = new TypeMirror[annotationValues.size()]; for (int i = 0; i < annotationValues.size(); i++) { - result[i] = (TypeMirror) annotationValues.get(i).type.getTypeArguments().get(0); + + result[i] = (DeclaredType) annotationValues.get(i).getValue(); + } return result; @@ -332,7 +333,7 @@ public static TypeMirror[] getTypeAttributeValueArray(List annotation * @return an array of passed type containing all casted elements of passed annotatedValues list or null if passed annotatedValues are null. * @throws ClassCastException will be thrown if Attributes of List cannot be cast to passed type */ - public static T[] convertAndCastAttributeValueListToArray(List annotatedValues, Class type) { + public static T[] convertAndCastAttributeValueListToArray(List annotatedValues, Class type) { if (type == null) { throw new IllegalArgumentException("passed type must not be null!"); @@ -364,15 +365,15 @@ public static Long[] getLongValueArray(AnnotationValue annotationValue) { /** * Convenience method to get long value array from annotation value. * - * @param attributes + * @param annotationValues * @return the long array containing the attributes's values, or null if passed attributes list is null */ - public static Long[] getLongValueArray(List attributes) { - if (attributes == null) { + public static Long[] getLongValueArray(List annotationValues) { + if (annotationValues == null || !isAnnotationValueArray(annotationValues, Long.class)) { return null; } - return convertAndCastAttributeValueListToArray(attributes, Long.class); + return convertAndCastAttributeValueListToArray(annotationValues, Long.class); } /** @@ -388,15 +389,15 @@ public static Integer[] getIntegerValueArray(AnnotationValue annotationValue) { /** * Convenience method to get integer value array from annotation value. * - * @param attributes + * @param annotationValues * @return the integer array containing the attributes's values, or null if passed attributes list is null */ - public static Integer[] getIntegerValueArray(List attributes) { - if (attributes == null) { + public static Integer[] getIntegerValueArray(List annotationValues) { + if (annotationValues == null || !isAnnotationValueArray(annotationValues, Integer.class)) { return null; } - return convertAndCastAttributeValueListToArray(attributes, Integer.class); + return convertAndCastAttributeValueListToArray(annotationValues, Integer.class); } /** @@ -412,15 +413,15 @@ public static Double[] getDoubleValueArray(AnnotationValue annotationValue) { /** * Convenience method to get double value array from annotation value. * - * @param attributes - * @return the double array containing the attributes's values, or null if passed attributes list is null + * @param annotationValues + * @return the double array containing the annotationValues's values, or null if passed annotationValues list is null */ - public static Double[] getDoubleValueArray(List attributes) { - if (attributes == null) { + public static Double[] getDoubleValueArray(List annotationValues) { + if (annotationValues == null || !isAnnotationValueArray(annotationValues, Double.class)) { return null; } - return convertAndCastAttributeValueListToArray(attributes, Double.class); + return convertAndCastAttributeValueListToArray(annotationValues, Double.class); } /** @@ -436,15 +437,15 @@ public static Float[] getFloatValueArray(AnnotationValue annotationValue) { /** * Convenience method to get float value array from annotation value. * - * @param attributes + * @param annotationValues * @return the float array containing the attributes's values, or null if passed attributes list is null */ - public static Float[] getFloatValueArray(List attributes) { - if (attributes == null) { + public static Float[] getFloatValueArray(List annotationValues) { + if (annotationValues == null || !isAnnotationValueArray(annotationValues, Float.class)) { return null; } - return convertAndCastAttributeValueListToArray(attributes, Float.class); + return convertAndCastAttributeValueListToArray(annotationValues, Float.class); } /** @@ -460,15 +461,15 @@ public static Boolean[] getBooleanValueArray(AnnotationValue annotationValue) { /** * Convenience method to get boolean value array from annotation value. * - * @param attributes + * @param annotationValues * @return the boolean array containing the attributes's values, or null if passed attributes list is null */ - public static Boolean[] getBooleanValueArray(List attributes) { - if (attributes == null) { + public static Boolean[] getBooleanValueArray(List annotationValues) { + if (annotationValues == null || !isAnnotationValueArray(annotationValues, Boolean.class)) { return null; } - return convertAndCastAttributeValueListToArray(attributes, Boolean.class); + return convertAndCastAttributeValueListToArray(annotationValues, Boolean.class); } /** @@ -484,15 +485,15 @@ public static Character[] getCharValueArray(AnnotationValue annotationValue) { /** * Convenience method to get char value array from annotation value. * - * @param attributes + * @param annotationValues * @return the char array containing the attributes's values, or null if passed attributes list is null */ - public static Character[] getCharValueArray(List attributes) { - if (attributes == null) { + public static Character[] getCharValueArray(List annotationValues) { + if (annotationValues == null || !isAnnotationValueArray(annotationValues, Character.class)) { return null; } - return convertAndCastAttributeValueListToArray(attributes, Character.class); + return convertAndCastAttributeValueListToArray(annotationValues, Character.class); } /** @@ -508,15 +509,15 @@ public static String[] getStringValueArray(AnnotationValue annotationValue) { /** * Convenience method to get String value array from annotation value. * - * @param attributes + * @param annotationValues * @return the String array containing the attributes's values, or null if passed attributes list is null */ - public static String[] getStringValueArray(List attributes) { - if (attributes == null) { + public static String[] getStringValueArray(List annotationValues) { + if (annotationValues == null || !isAnnotationValueArray(annotationValues, String.class)) { return null; } - return convertAndCastAttributeValueListToArray(attributes, String.class); + return convertAndCastAttributeValueListToArray(annotationValues, String.class); } /** @@ -533,15 +534,15 @@ public static VariableElement[] getEnumValueArray(AnnotationValue annotationValu /** * Convenience method to get enum value array from annotation value. * - * @param attributes + * @param annotationValues * @return the enum array containing the attributes's values, or null if passed attributes list is null */ - public static VariableElement[] getEnumValueArray(List attributes) { - if (attributes == null) { + public static VariableElement[] getEnumValueArray(List annotationValues) { + if (annotationValues == null || !isAnnotationValueArray(annotationValues, VariableElement.class)) { return null; } - return convertAndCastAttributeValueListToArray(attributes, VariableElement.class); + return convertAndCastAttributeValueListToArray(annotationValues, VariableElement.class); } /** @@ -557,15 +558,150 @@ public static AnnotationMirror[] getAnnotationValueArray(AnnotationValue annotat /** * Convenience method to get annotation value array from annotation value. * - * @param attributes - * @return the annotation array containing the attributes's values, or null if passed attributes list is null + * @param annotationValues + * @return the annotation array containing the annotationValues's values, or null if passed annotationValues list is null */ - public static AnnotationMirror[] getAnnotationValueArray(List attributes) { - if (attributes == null) { + public static AnnotationMirror[] getAnnotationValueArray(List annotationValues) { + if (annotationValues == null || !isAnnotationValueArray(annotationValues, AnnotationMirror.class)) { return null; } - return convertAndCastAttributeValueListToArray(attributes, AnnotationMirror.class); + return convertAndCastAttributeValueListToArray(annotationValues, AnnotationMirror.class); + } + + + // ----------------------------------------------------------------------------------------- + // -- Array value functions + // ----------------------------------------------------------------------------------------- + + + /** + * Checks if passed annotation value is of type Integer. + * + * @param annotationValue the value to check + * @return true, if passed annotation is of type Integer, otherwise false + */ + public static boolean isIntegerArray(AnnotationValue annotationValue) { + return isAnnotationValueArray(annotationValue, Integer.class); + } + + /** + * Checks if passed annotation value is of type Integer. + * + * @param annotationValue the value to check + * @return true, if passed annotation is of type Integer, otherwise false + */ + public static boolean isLongArray(AnnotationValue annotationValue) { + return isAnnotationValueArray(annotationValue, Long.class); + } + + + /** + * Checks if passed annotation value is of type Boolean. + * + * @param annotationValue the value to check + * @return true, if passed annotation is of type Boolean, otherwise false + */ + public static boolean isBooleanArray(AnnotationValue annotationValue) { + return isAnnotationValueArray(annotationValue, Boolean.class); + } + + /** + * Checks if passed annotation value is of type Float. + * + * @param annotationValue the value to check + * @return true, if passed annotation is of type Float, otherwise false + */ + public static boolean isFloatArray(AnnotationValue annotationValue) { + return isAnnotationValueArray(annotationValue, Float.class); } + /** + * Checks if passed annotation value is of type Integer. + * + * @param annotationValue the value to check + * @return true, if passed annotation is of type Integer, otherwise false + */ + public static boolean isDoubleArray(AnnotationValue annotationValue) { + return isAnnotationValueArray(annotationValue, Double.class); + } + + /** + * Checks if passed annotation value is of type String. + * + * @param annotationValue the value to check + * @return true, if passed annotation is of type String, otherwise false + */ + public static boolean isStringArray(AnnotationValue annotationValue) { + return isAnnotationValueArray(annotationValue, String.class); + } + + /** + * Checks if passed annotation value is of type String. + * + * @param annotationValue the value to check + * @return true, if passed annotation is of type String, otherwise false + */ + public static boolean isCharArray(AnnotationValue annotationValue) { + return isAnnotationValueArray(annotationValue, Character.class); + } + + /** + * Checks if passed annotation value is an enum. + * + * @param annotationValue the value to check + * @return true, if passed annotation is of type Integer, otherwise false + */ + public static boolean isEnumArray(AnnotationValue annotationValue) { + return isAnnotationValueArray(annotationValue, VariableElement.class); + } + + /** + * Checks if passed annotation value is of type AnnotationValue. + * + * @param annotationValue the value to check + * @return true, if passed annotation is of type AnnotationValue, otherwise false + */ + public static boolean isClassArray(AnnotationValue annotationValue) { + return isAnnotationValueArray(annotationValue, TypeMirror.class); + } + + /** + * Checks if passed annotation value is an array. + * + * @param annotationValue the value to check + * @return true, if passed annotation is an array, otherwise false + */ + public static boolean isArrayArray(AnnotationValue annotationValue) { + return isAnnotationValueArray(annotationValue, List.class); + } + + + /** + * Checks if passed annotation value is an AnnotationValue. + * + * @param annotationValue the value to check + * @return true, if passed annotation is of type AnnotationValue, otherwise false + */ + public static boolean isAnnotationArray(AnnotationValue annotationValue) { + return isAnnotationValueArray(annotationValue, AnnotationMirror.class); + } + + + public static boolean isAnnotationValueArray(AnnotationValue annotationValue, Class type) { + + return annotationValue != null && type != null + && annotationValue.getValue() instanceof List + && isAnnotationValueArray((List) annotationValue.getValue(), type); + } + + + public static boolean isAnnotationValueArray(List annotationValues, Class type) { + + return annotationValues != null && type != null + && annotationValues.size() >= 1 + && hasAnnotationValueOneOfPassedTypes(annotationValues.get(0), type); + } + + } diff --git a/annotationprocessor/src/test/java/io/toolisticon/annotationprocessortoolkit/tools/AnnotationValueUtilsTest.java b/annotationprocessor/src/test/java/io/toolisticon/annotationprocessortoolkit/tools/AnnotationValueUtilsTest.java index 1dab9a64..e415f718 100644 --- a/annotationprocessor/src/test/java/io/toolisticon/annotationprocessortoolkit/tools/AnnotationValueUtilsTest.java +++ b/annotationprocessor/src/test/java/io/toolisticon/annotationprocessortoolkit/tools/AnnotationValueUtilsTest.java @@ -1,13 +1,11 @@ package io.toolisticon.annotationprocessortoolkit.tools; import com.google.testing.compile.JavaFileObjects; -import com.sun.tools.javac.code.Attribute; import io.toolisticon.annotationprocessortoolkit.testhelper.AbstractAnnotationProcessorUnitTest; import io.toolisticon.annotationprocessortoolkit.testhelper.unittest.AbstractUnitTestAnnotationProcessorClass; import io.toolisticon.annotationprocessortoolkit.testhelper.unittest.AnnotationProcessorUnitTestConfiguration; import io.toolisticon.annotationprocessortoolkit.testhelper.unittest.AnnotationProcessorUnitTestConfigurationBuilder; import io.toolisticon.annotationprocessortoolkit.tools.annotationvalueutilstestclasses.AnnotationValueTestAnnotation; -import io.toolisticon.annotationprocessortoolkit.tools.matcher.Matcher; import org.hamcrest.MatcherAssert; import org.hamcrest.Matchers; import org.junit.Test; @@ -1021,15 +1019,15 @@ protected void testCase(TypeElement element) { // test null safety - MatcherAssert.assertThat(AnnotationValueUtils.getLongValueArray((com.sun.tools.javac.util.List) null), Matchers.nullValue()); - MatcherAssert.assertThat(AnnotationValueUtils.getIntegerValueArray((com.sun.tools.javac.util.List) null), Matchers.nullValue()); - MatcherAssert.assertThat(AnnotationValueUtils.getBooleanValueArray((com.sun.tools.javac.util.List) null), Matchers.nullValue()); - MatcherAssert.assertThat(AnnotationValueUtils.getFloatValueArray((com.sun.tools.javac.util.List) null), Matchers.nullValue()); - MatcherAssert.assertThat(AnnotationValueUtils.getDoubleValueArray((com.sun.tools.javac.util.List) null), Matchers.nullValue()); - MatcherAssert.assertThat(AnnotationValueUtils.getStringValueArray((com.sun.tools.javac.util.List) null), Matchers.nullValue()); - MatcherAssert.assertThat(AnnotationValueUtils.getCharValueArray((com.sun.tools.javac.util.List) null), Matchers.nullValue()); - MatcherAssert.assertThat(AnnotationValueUtils.getEnumValueArray((com.sun.tools.javac.util.List) null), Matchers.nullValue()); - MatcherAssert.assertThat(AnnotationValueUtils.getAnnotationValueArray((com.sun.tools.javac.util.List) null), Matchers.nullValue()); + MatcherAssert.assertThat(AnnotationValueUtils.getLongValueArray((List) null), Matchers.nullValue()); + MatcherAssert.assertThat(AnnotationValueUtils.getIntegerValueArray((List) null), Matchers.nullValue()); + MatcherAssert.assertThat(AnnotationValueUtils.getBooleanValueArray((List) null), Matchers.nullValue()); + MatcherAssert.assertThat(AnnotationValueUtils.getFloatValueArray((List) null), Matchers.nullValue()); + MatcherAssert.assertThat(AnnotationValueUtils.getDoubleValueArray((List) null), Matchers.nullValue()); + MatcherAssert.assertThat(AnnotationValueUtils.getStringValueArray((List) null), Matchers.nullValue()); + MatcherAssert.assertThat(AnnotationValueUtils.getCharValueArray((List) null), Matchers.nullValue()); + MatcherAssert.assertThat(AnnotationValueUtils.getEnumValueArray((List) null), Matchers.nullValue()); + MatcherAssert.assertThat(AnnotationValueUtils.getAnnotationValueArray((List) null), Matchers.nullValue()); MatcherAssert.assertThat(AnnotationValueUtils.getLongValueArray((AnnotationValue) null), Matchers.nullValue()); @@ -1051,6 +1049,60 @@ protected void testCase(TypeElement element) { }, + { + "AnnotationValueUtils test - isXXXArray", + AnnotationProcessorUnitTestConfigurationBuilder.createTestConfig() + .compilationShouldSucceed() + .setProcessor(new AbstractUnitTestAnnotationProcessorClass() { + @Override + protected void testCase(TypeElement element) { + + AnnotationMirror annotationMirror = AnnotationUtils.getAnnotationMirror(element, AnnotationValueTestAnnotation.class); + + MatcherAssert.assertThat(AnnotationValueUtils.isLongArray(AnnotationUtils.getAnnotationValueOfAttribute(annotationMirror, "longArrayValue")), Matchers.is(true)); + MatcherAssert.assertThat(AnnotationValueUtils.isIntegerArray(AnnotationUtils.getAnnotationValueOfAttribute(annotationMirror, "intArrayValue")), Matchers.is(true)); + MatcherAssert.assertThat(AnnotationValueUtils.isBooleanArray(AnnotationUtils.getAnnotationValueOfAttribute(annotationMirror, "booleanArrayValue")), Matchers.is(true)); + MatcherAssert.assertThat(AnnotationValueUtils.isFloatArray(AnnotationUtils.getAnnotationValueOfAttribute(annotationMirror, "floatArrayValue")), Matchers.is(true)); + MatcherAssert.assertThat(AnnotationValueUtils.isDoubleArray(AnnotationUtils.getAnnotationValueOfAttribute(annotationMirror, "doubleArrayValue")), Matchers.is(true)); + MatcherAssert.assertThat(AnnotationValueUtils.isStringArray(AnnotationUtils.getAnnotationValueOfAttribute(annotationMirror, "stringArrayValue")), Matchers.is(true)); + MatcherAssert.assertThat(AnnotationValueUtils.isCharArray(AnnotationUtils.getAnnotationValueOfAttribute(annotationMirror, "charArrayValue")), Matchers.is(true)); + MatcherAssert.assertThat(AnnotationValueUtils.isEnumArray(AnnotationUtils.getAnnotationValueOfAttribute(annotationMirror, "enumArrayValue")), Matchers.is(true)); + MatcherAssert.assertThat(AnnotationValueUtils.isClassArray(AnnotationUtils.getAnnotationValueOfAttribute(annotationMirror, "classArrayValue")), Matchers.is(true)); + MatcherAssert.assertThat(AnnotationValueUtils.isAnnotationArray(AnnotationUtils.getAnnotationValueOfAttribute(annotationMirror, "annotationArrayValue")), Matchers.is(true)); + + MatcherAssert.assertThat(AnnotationValueUtils.isLongArray(AnnotationUtils.getAnnotationValueOfAttribute(annotationMirror, "intArrayValue")), Matchers.is(false)); + MatcherAssert.assertThat(AnnotationValueUtils.isIntegerArray(AnnotationUtils.getAnnotationValueOfAttribute(annotationMirror, "booleanArrayValue")), Matchers.is(false)); + MatcherAssert.assertThat(AnnotationValueUtils.isBooleanArray(AnnotationUtils.getAnnotationValueOfAttribute(annotationMirror, "floatArrayValue")), Matchers.is(false)); + MatcherAssert.assertThat(AnnotationValueUtils.isFloatArray(AnnotationUtils.getAnnotationValueOfAttribute(annotationMirror, "doubleArrayValue")), Matchers.is(false)); + MatcherAssert.assertThat(AnnotationValueUtils.isDoubleArray(AnnotationUtils.getAnnotationValueOfAttribute(annotationMirror, "stringArrayValue")), Matchers.is(false)); + MatcherAssert.assertThat(AnnotationValueUtils.isStringArray(AnnotationUtils.getAnnotationValueOfAttribute(annotationMirror, "charArrayValue")), Matchers.is(false)); + MatcherAssert.assertThat(AnnotationValueUtils.isCharArray(AnnotationUtils.getAnnotationValueOfAttribute(annotationMirror, "enumArrayValue")), Matchers.is(false)); + MatcherAssert.assertThat(AnnotationValueUtils.isEnumArray(AnnotationUtils.getAnnotationValueOfAttribute(annotationMirror, "classArrayValue")), Matchers.is(false)); + MatcherAssert.assertThat(AnnotationValueUtils.isClassArray(AnnotationUtils.getAnnotationValueOfAttribute(annotationMirror, "annotationArrayValue")), Matchers.is(false)); + MatcherAssert.assertThat(AnnotationValueUtils.isAnnotationArray(AnnotationUtils.getAnnotationValueOfAttribute(annotationMirror, "floatArrayValue")), Matchers.is(false)); + + + MatcherAssert.assertThat(AnnotationValueUtils.isLongArray(null), Matchers.is(false)); + MatcherAssert.assertThat(AnnotationValueUtils.isIntegerArray(null), Matchers.is(false)); + MatcherAssert.assertThat(AnnotationValueUtils.isBooleanArray(null), Matchers.is(false)); + MatcherAssert.assertThat(AnnotationValueUtils.isFloatArray(null), Matchers.is(false)); + MatcherAssert.assertThat(AnnotationValueUtils.isDoubleArray(null), Matchers.is(false)); + MatcherAssert.assertThat(AnnotationValueUtils.isStringArray(null), Matchers.is(false)); + MatcherAssert.assertThat(AnnotationValueUtils.isCharArray(null), Matchers.is(false)); + MatcherAssert.assertThat(AnnotationValueUtils.isEnumArray(null), Matchers.is(false)); + MatcherAssert.assertThat(AnnotationValueUtils.isClassArray(null), Matchers.is(false)); + MatcherAssert.assertThat(AnnotationValueUtils.isAnnotationArray(null), Matchers.is(false)); + + + + } + } + ) + .build() + + + }, + } ); diff --git a/common/pom.xml b/common/pom.xml index 27ebb6fe..76346fb6 100644 --- a/common/pom.xml +++ b/common/pom.xml @@ -80,7 +80,6 @@ io.toolisticon.annotationprocessortoolkit:* com.google.testing.compile:compile-testing - com.sun:tools:* *:*:*:*:test:* *:*:*:*:provided:* diff --git a/common/src/main/java/io/toolisticon/annotationprocessortoolkit/ToolingProvider.java b/common/src/main/java/io/toolisticon/annotationprocessortoolkit/ToolingProvider.java index 73b31f4c..cf0b9b11 100644 --- a/common/src/main/java/io/toolisticon/annotationprocessortoolkit/ToolingProvider.java +++ b/common/src/main/java/io/toolisticon/annotationprocessortoolkit/ToolingProvider.java @@ -1,8 +1,6 @@ package io.toolisticon.annotationprocessortoolkit; -import com.sun.source.util.Trees; - import javax.annotation.processing.Filer; import javax.annotation.processing.Messager; import javax.annotation.processing.ProcessingEnvironment; @@ -106,6 +104,7 @@ public Types getTypes() { /** * Gets the processing environment. + * * @return the processing environment */ public ProcessingEnvironment getProcessingEnvironment() { diff --git a/common/src/test/java/io/toolisticon/annotationprocessortoolkit/ToolingProviderTest.java b/common/src/test/java/io/toolisticon/annotationprocessortoolkit/ToolingProviderTest.java index da4995fa..9f23c85d 100644 --- a/common/src/test/java/io/toolisticon/annotationprocessortoolkit/ToolingProviderTest.java +++ b/common/src/test/java/io/toolisticon/annotationprocessortoolkit/ToolingProviderTest.java @@ -130,6 +130,4 @@ public void testToolingProviderClearTooling_Types() { } - - } diff --git a/testhelper/pom.xml b/testhelper/pom.xml index cb5dbb56..f0d7535e 100644 --- a/testhelper/pom.xml +++ b/testhelper/pom.xml @@ -84,7 +84,6 @@ io.toolisticon.annotationprocessortoolkit:* com.google.testing.compile:compile-testing - com.sun:tools:* *:*:*:*:test:* *:*:*:*:provided:*