diff options
Diffstat (limited to 'common/src/test/java')
10 files changed, 872 insertions, 568 deletions
diff --git a/common/src/test/java/com/google/auto/common/AnnotationMirrorsTest.java b/common/src/test/java/com/google/auto/common/AnnotationMirrorsTest.java index dfc043ab..b1dfe3b3 100644 --- a/common/src/test/java/com/google/auto/common/AnnotationMirrorsTest.java +++ b/common/src/test/java/com/google/auto/common/AnnotationMirrorsTest.java @@ -22,12 +22,17 @@ import static com.google.common.truth.Truth.assertThat; import static com.google.testing.compile.CompilationSubject.assertThat; import static org.junit.Assert.fail; +import com.google.common.collect.ImmutableSet; import com.google.common.testing.EquivalenceTester; +import com.google.common.truth.Correspondence; import com.google.testing.compile.CompilationRule; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; import java.util.Map; import javax.lang.model.element.AnnotationMirror; import javax.lang.model.element.AnnotationValue; import javax.lang.model.element.ExecutableElement; +import javax.lang.model.element.TypeElement; import javax.lang.model.element.VariableElement; import javax.lang.model.util.Elements; import javax.lang.model.util.SimpleAnnotationValueVisitor6; @@ -46,110 +51,134 @@ public class AnnotationMirrorsTest { private Elements elements; - @Before public void setUp() { + @Before + public void setUp() { this.elements = compilationRule.getElements(); } @interface SimpleAnnotation {} - @SimpleAnnotation class SimplyAnnotated {} - @SimpleAnnotation class AlsoSimplyAnnotated {} + @SimpleAnnotation + static class SimplyAnnotated {} + + @SimpleAnnotation + static class AlsoSimplyAnnotated {} enum SimpleEnum { - BLAH, FOO + BLAH, + FOO } @interface Outer { SimpleEnum value(); } - @Outer(BLAH) static class TestClassBlah {} - @Outer(BLAH) static class TestClassBlah2 {} - @Outer(FOO) static class TestClassFoo {} + @Outer(BLAH) + static class TestClassBlah {} + + @Outer(BLAH) + static class TestClassBlah2 {} + + @Outer(FOO) + static class TestClassFoo {} @interface DefaultingOuter { SimpleEnum value() default SimpleEnum.BLAH; } - @DefaultingOuter class TestWithDefaultingOuterDefault {} - @DefaultingOuter(BLAH) class TestWithDefaultingOuterBlah {} - @DefaultingOuter(FOO) class TestWithDefaultingOuterFoo {} + @DefaultingOuter + static class TestWithDefaultingOuterDefault {} + + @DefaultingOuter(BLAH) + static class TestWithDefaultingOuterBlah {} + + @DefaultingOuter(FOO) + static class TestWithDefaultingOuterFoo {} @interface AnnotatedOuter { DefaultingOuter value(); } - @AnnotatedOuter(@DefaultingOuter) class TestDefaultNestedAnnotated {} - @AnnotatedOuter(@DefaultingOuter(BLAH)) class TestBlahNestedAnnotated {} - @AnnotatedOuter(@DefaultingOuter(FOO)) class TestFooNestedAnnotated {} + @AnnotatedOuter(@DefaultingOuter) + static class TestDefaultNestedAnnotated {} + + @AnnotatedOuter(@DefaultingOuter(BLAH)) + static class TestBlahNestedAnnotated {} + + @AnnotatedOuter(@DefaultingOuter(FOO)) + static class TestFooNestedAnnotated {} @interface OuterWithValueArray { DefaultingOuter[] value() default {}; } - @OuterWithValueArray class TestValueArrayWithDefault {} - @OuterWithValueArray({}) class TestValueArrayWithEmpty {} + @OuterWithValueArray + static class TestValueArrayWithDefault {} + + @OuterWithValueArray({}) + static class TestValueArrayWithEmpty {} - @OuterWithValueArray({@DefaultingOuter}) class TestValueArrayWithOneDefault {} - @OuterWithValueArray(@DefaultingOuter(BLAH)) class TestValueArrayWithOneBlah {} - @OuterWithValueArray(@DefaultingOuter(FOO)) class TestValueArrayWithOneFoo {} + @OuterWithValueArray({@DefaultingOuter}) + static class TestValueArrayWithOneDefault {} + + @OuterWithValueArray(@DefaultingOuter(BLAH)) + static class TestValueArrayWithOneBlah {} + + @OuterWithValueArray(@DefaultingOuter(FOO)) + static class TestValueArrayWithOneFoo {} @OuterWithValueArray({@DefaultingOuter(FOO), @DefaultingOuter}) class TestValueArrayWithFooAndDefaultBlah {} + @OuterWithValueArray({@DefaultingOuter(FOO), @DefaultingOuter(BLAH)}) class TestValueArrayWithFooBlah {} + @OuterWithValueArray({@DefaultingOuter(FOO), @DefaultingOuter(BLAH)}) class TestValueArrayWithFooBlah2 {} // Different instances than on TestValueArrayWithFooBlah. + @OuterWithValueArray({@DefaultingOuter(BLAH), @DefaultingOuter(FOO)}) class TestValueArrayWithBlahFoo {} - @Test public void testEquivalences() { + @Test + public void testEquivalences() { EquivalenceTester<AnnotationMirror> tester = EquivalenceTester.of(AnnotationMirrors.equivalence()); tester.addEquivalenceGroup( - annotationOn(SimplyAnnotated.class), - annotationOn(AlsoSimplyAnnotated.class)); + annotationOn(SimplyAnnotated.class), annotationOn(AlsoSimplyAnnotated.class)); tester.addEquivalenceGroup( - annotationOn(TestClassBlah.class), - annotationOn(TestClassBlah2.class)); + annotationOn(TestClassBlah.class), annotationOn(TestClassBlah2.class)); - tester.addEquivalenceGroup( - annotationOn(TestClassFoo.class)); + tester.addEquivalenceGroup(annotationOn(TestClassFoo.class)); tester.addEquivalenceGroup( annotationOn(TestWithDefaultingOuterDefault.class), annotationOn(TestWithDefaultingOuterBlah.class)); - tester.addEquivalenceGroup( - annotationOn(TestWithDefaultingOuterFoo.class)); + tester.addEquivalenceGroup(annotationOn(TestWithDefaultingOuterFoo.class)); tester.addEquivalenceGroup( annotationOn(TestDefaultNestedAnnotated.class), annotationOn(TestBlahNestedAnnotated.class)); - tester.addEquivalenceGroup( - annotationOn(TestFooNestedAnnotated.class)); + tester.addEquivalenceGroup(annotationOn(TestFooNestedAnnotated.class)); tester.addEquivalenceGroup( - annotationOn(TestValueArrayWithDefault.class), - annotationOn(TestValueArrayWithEmpty.class)); + annotationOn(TestValueArrayWithDefault.class), annotationOn(TestValueArrayWithEmpty.class)); tester.addEquivalenceGroup( annotationOn(TestValueArrayWithOneDefault.class), annotationOn(TestValueArrayWithOneBlah.class)); - tester.addEquivalenceGroup( - annotationOn(TestValueArrayWithOneFoo.class)); + tester.addEquivalenceGroup(annotationOn(TestValueArrayWithOneFoo.class)); tester.addEquivalenceGroup( annotationOn(TestValueArrayWithFooAndDefaultBlah.class), annotationOn(TestValueArrayWithFooBlah.class), annotationOn(TestValueArrayWithFooBlah2.class)); - tester.addEquivalenceGroup( - annotationOn(TestValueArrayWithBlahFoo.class)); + tester.addEquivalenceGroup(annotationOn(TestValueArrayWithBlahFoo.class)); tester.test(); } @@ -158,44 +187,61 @@ public class AnnotationMirrorsTest { String value() default "default"; } - @Stringy class StringyUnset {} - @Stringy("foo") class StringySet {} + @Stringy + static class StringyUnset {} + + @Stringy("foo") + static class StringySet {} - @Test public void testGetDefaultValuesUnset() { + @Test + public void testGetDefaultValuesUnset() { assertThat(annotationOn(StringyUnset.class).getElementValues()).isEmpty(); - Iterable<AnnotationValue> values = AnnotationMirrors.getAnnotationValuesWithDefaults( - annotationOn(StringyUnset.class)).values(); - String value = getOnlyElement(values).accept(new SimpleAnnotationValueVisitor6<String, Void>() { - @Override public String visitString(String value, Void ignored) { - return value; - } - }, null); + Iterable<AnnotationValue> values = + AnnotationMirrors.getAnnotationValuesWithDefaults(annotationOn(StringyUnset.class)) + .values(); + String value = + getOnlyElement(values) + .accept( + new SimpleAnnotationValueVisitor6<String, Void>() { + @Override + public String visitString(String value, Void ignored) { + return value; + } + }, + null); assertThat(value).isEqualTo("default"); } - @Test public void testGetDefaultValuesSet() { - Iterable<AnnotationValue> values = AnnotationMirrors.getAnnotationValuesWithDefaults( - annotationOn(StringySet.class)).values(); - String value = getOnlyElement(values).accept(new SimpleAnnotationValueVisitor6<String, Void>() { - @Override public String visitString(String value, Void ignored) { - return value; - } - }, null); + @Test + public void testGetDefaultValuesSet() { + Iterable<AnnotationValue> values = + AnnotationMirrors.getAnnotationValuesWithDefaults(annotationOn(StringySet.class)).values(); + String value = + getOnlyElement(values) + .accept( + new SimpleAnnotationValueVisitor6<String, Void>() { + @Override + public String visitString(String value, Void ignored) { + return value; + } + }, + null); assertThat(value).isEqualTo("foo"); } - @Test public void testGetValueEntry() { + @Test + public void testGetValueEntry() { Map.Entry<ExecutableElement, AnnotationValue> elementValue = - AnnotationMirrors.getAnnotationElementAndValue( - annotationOn(TestClassBlah.class), "value"); + AnnotationMirrors.getAnnotationElementAndValue(annotationOn(TestClassBlah.class), "value"); assertThat(elementValue.getKey().getSimpleName().toString()).isEqualTo("value"); assertThat(elementValue.getValue().getValue()).isInstanceOf(VariableElement.class); - AnnotationValue value = AnnotationMirrors.getAnnotationValue( - annotationOn(TestClassBlah.class), "value"); + AnnotationValue value = + AnnotationMirrors.getAnnotationValue(annotationOn(TestClassBlah.class), "value"); assertThat(value.getValue()).isInstanceOf(VariableElement.class); } - @Test public void testGetValueEntryFailure() { + @Test + public void testGetValueEntryFailure() { try { AnnotationMirrors.getAnnotationValue(annotationOn(TestClassBlah.class), "a"); } catch (IllegalArgumentException e) { @@ -212,4 +258,52 @@ public class AnnotationMirrorsTest { return getOnlyElement(elements.getTypeElement(clazz.getCanonicalName()).getAnnotationMirrors()); } + @Retention(RetentionPolicy.RUNTIME) + private @interface AnnotatingAnnotation {} + + @AnnotatingAnnotation + @Retention(RetentionPolicy.RUNTIME) + private @interface AnnotatedAnnotation1 {} + + @AnnotatingAnnotation + @Retention(RetentionPolicy.RUNTIME) + private @interface AnnotatedAnnotation2 {} + + @Retention(RetentionPolicy.RUNTIME) + private @interface NotAnnotatedAnnotation {} + + @AnnotatedAnnotation1 + @NotAnnotatedAnnotation + @AnnotatedAnnotation2 + private static final class AnnotatedClass {} + + @Test + public void getAnnotatedAnnotations() { + TypeElement element = elements.getTypeElement(AnnotatedClass.class.getCanonicalName()); + + // Test Class API + getAnnotatedAnnotationsAsserts( + AnnotationMirrors.getAnnotatedAnnotations(element, AnnotatingAnnotation.class)); + + // Test String API + String annotatingAnnotationName = AnnotatingAnnotation.class.getCanonicalName(); + getAnnotatedAnnotationsAsserts( + AnnotationMirrors.getAnnotatedAnnotations(element, annotatingAnnotationName)); + + // Test TypeElement API + TypeElement annotatingAnnotationElement = elements.getTypeElement(annotatingAnnotationName); + getAnnotatedAnnotationsAsserts( + AnnotationMirrors.getAnnotatedAnnotations(element, annotatingAnnotationElement)); + } + + private void getAnnotatedAnnotationsAsserts( + ImmutableSet<? extends AnnotationMirror> annotatedAnnotations) { + assertThat(annotatedAnnotations) + .comparingElementsUsing( + Correspondence.transforming( + (AnnotationMirror a) -> MoreTypes.asTypeElement(a.getAnnotationType()), "has type")) + .containsExactly( + elements.getTypeElement(AnnotatedAnnotation1.class.getCanonicalName()), + elements.getTypeElement(AnnotatedAnnotation2.class.getCanonicalName())); + } } diff --git a/common/src/test/java/com/google/auto/common/GeneratedAnnotationsTest.java b/common/src/test/java/com/google/auto/common/GeneratedAnnotationsTest.java index 1c816c10..f9426527 100644 --- a/common/src/test/java/com/google/auto/common/GeneratedAnnotationsTest.java +++ b/common/src/test/java/com/google/auto/common/GeneratedAnnotationsTest.java @@ -18,6 +18,7 @@ package com.google.auto.common; import static com.google.common.truth.Truth.assertThat; import static java.nio.charset.StandardCharsets.UTF_8; +import static java.util.Objects.requireNonNull; import static org.junit.Assume.assumeTrue; import com.google.common.collect.ImmutableList; @@ -31,6 +32,7 @@ import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.net.URI; import java.nio.file.Files; +import java.util.Objects; import java.util.Set; import javax.annotation.processing.AbstractProcessor; import javax.annotation.processing.RoundEnvironment; @@ -44,6 +46,7 @@ import javax.tools.SimpleJavaFileObject; import javax.tools.StandardJavaFileManager; import javax.tools.StandardLocation; import javax.tools.ToolProvider; +import org.checkerframework.checker.nullness.qual.Nullable; import org.junit.Rule; import org.junit.Test; import org.junit.rules.TemporaryFolder; @@ -99,12 +102,12 @@ public class GeneratedAnnotationsTest { * Run {@link TestProcessor} in a compilation with the given {@code options}, and prevent the * compilation from accessing classes with the qualified names in {@code maskFromClasspath}. */ - private String runProcessor(ImmutableList<String> options, String packageToMask) + private String runProcessor(ImmutableList<String> options, @Nullable String packageToMask) throws IOException { File tempDir = temporaryFolder.newFolder(); JavaCompiler compiler = ToolProvider.getSystemJavaCompiler(); StandardJavaFileManager standardFileManager = - compiler.getStandardFileManager(/* diagnostics= */ null, /* locale= */ null, UTF_8); + compiler.getStandardFileManager(/* diagnosticListener= */ null, /* locale= */ null, UTF_8); standardFileManager.setLocation(StandardLocation.CLASS_OUTPUT, ImmutableList.of(tempDir)); StandardJavaFileManager proxyFileManager = Reflection.newProxy( @@ -142,18 +145,20 @@ public class GeneratedAnnotationsTest { */ private static class FileManagerInvocationHandler implements InvocationHandler { private final StandardJavaFileManager fileManager; - private final String packageToMask; + private final @Nullable String packageToMask; - FileManagerInvocationHandler(StandardJavaFileManager fileManager, String packageToMask) { + FileManagerInvocationHandler( + StandardJavaFileManager fileManager, @Nullable String packageToMask) { this.fileManager = fileManager; this.packageToMask = packageToMask; } @Override - public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { + public Object invoke(Object proxy, Method method, @Nullable Object @Nullable [] args) + throws Throwable { if (method.getName().equals("list")) { - String packageName = (String) args[1]; - if (packageName.equals(packageToMask)) { + String packageName = (String) requireNonNull(args)[1]; + if (Objects.equals(packageName, packageToMask)) { return ImmutableList.of(); } } @@ -187,8 +192,7 @@ public class GeneratedAnnotationsTest { // An alternative would be to delete this test method. JDK8 always has // javax.annotation.Generated so it isn't really meaningful to test it without. ImmutableList<String> options = ImmutableList.of("-source", "8", "-target", "8"); - String generated = - runProcessor(options, "javax.annotation"); + String generated = runProcessor(options, "javax.annotation"); assertThat(generated).doesNotContain(JAVAX_ANNOTATION_GENERATED); assertThat(generated).doesNotContain(JAVAX_ANNOTATION_PROCESSING_GENERATED); } diff --git a/common/src/test/java/com/google/auto/common/MoreElementsTest.java b/common/src/test/java/com/google/auto/common/MoreElementsTest.java index 95043cf3..b98b79b9 100644 --- a/common/src/test/java/com/google/auto/common/MoreElementsTest.java +++ b/common/src/test/java/com/google/auto/common/MoreElementsTest.java @@ -18,6 +18,7 @@ package com.google.auto.common; import static com.google.common.collect.Iterables.getOnlyElement; import static com.google.common.truth.Truth.assertThat; import static com.google.common.truth.Truth.assertWithMessage; +import static java.util.Objects.requireNonNull; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; @@ -58,13 +59,14 @@ public class MoreElementsTest { @Rule public CompilationRule compilation = new CompilationRule(); @Rule public Expect expect = Expect.create(); + private Elements elements; private PackageElement javaLangPackageElement; private TypeElement objectElement; private TypeElement stringElement; @Before public void initializeTestElements() { - Elements elements = compilation.getElements(); + this.elements = compilation.getElements(); this.javaLangPackageElement = elements.getPackageElement("java.lang"); this.objectElement = elements.getTypeElement(Object.class.getCanonicalName()); this.stringElement = elements.getTypeElement(String.class.getCanonicalName()); @@ -80,8 +82,7 @@ public class MoreElementsTest { @Test public void asPackage() { - assertThat(MoreElements.asPackage(javaLangPackageElement)) - .isEqualTo(javaLangPackageElement); + assertThat(MoreElements.asPackage(javaLangPackageElement)).isEqualTo(javaLangPackageElement); } @Test @@ -89,19 +90,20 @@ public class MoreElementsTest { try { MoreElements.asPackage(stringElement); fail(); - } catch (IllegalArgumentException expected) {} + } catch (IllegalArgumentException expected) { + } } - @Test public void asTypeElement() { - Element typeElement = - compilation.getElements().getTypeElement(String.class.getCanonicalName()); + @Test + public void asTypeElement() { + Element typeElement = elements.getTypeElement(String.class.getCanonicalName()); assertTrue(MoreElements.isType(typeElement)); assertThat(MoreElements.asType(typeElement)).isEqualTo(typeElement); } - @Test public void asTypeElement_notATypeElement() { - TypeElement typeElement = - compilation.getElements().getTypeElement(String.class.getCanonicalName()); + @Test + public void asTypeElement_notATypeElement() { + TypeElement typeElement = elements.getTypeElement(String.class.getCanonicalName()); for (ExecutableElement e : ElementFilter.methodsIn(typeElement.getEnclosedElements())) { assertFalse(MoreElements.isType(e)); try { @@ -143,7 +145,8 @@ public class MoreElementsTest { try { MoreElements.asType(javaLangPackageElement); fail(); - } catch (IllegalArgumentException expected) {} + } catch (IllegalArgumentException expected) { + } } @Test @@ -158,7 +161,8 @@ public class MoreElementsTest { try { MoreElements.asVariable(javaLangPackageElement); fail(); - } catch (IllegalArgumentException expected) {} + } catch (IllegalArgumentException expected) { + } } @Test @@ -166,8 +170,8 @@ public class MoreElementsTest { for (Element methodElement : ElementFilter.methodsIn(stringElement.getEnclosedElements())) { assertThat(MoreElements.asExecutable(methodElement)).isEqualTo(methodElement); } - for (Element methodElement - : ElementFilter.constructorsIn(stringElement.getEnclosedElements())) { + for (Element methodElement : + ElementFilter.constructorsIn(stringElement.getEnclosedElements())) { assertThat(MoreElements.asExecutable(methodElement)).isEqualTo(methodElement); } } @@ -177,7 +181,8 @@ public class MoreElementsTest { try { MoreElements.asExecutable(javaLangPackageElement); fail(); - } catch (IllegalArgumentException expected) {} + } catch (IllegalArgumentException expected) { + } } @Retention(RetentionPolicy.RUNTIME) @@ -190,39 +195,90 @@ public class MoreElementsTest { @Test public void isAnnotationPresent() { TypeElement annotatedAnnotationElement = - compilation.getElements().getTypeElement(AnnotatedAnnotation.class.getCanonicalName()); - assertThat(MoreElements.isAnnotationPresent(annotatedAnnotationElement, Documented.class)) - .isTrue(); - assertThat(MoreElements.isAnnotationPresent(annotatedAnnotationElement, InnerAnnotation.class)) - .isTrue(); - assertThat(MoreElements.isAnnotationPresent(annotatedAnnotationElement, SuppressWarnings.class)) - .isFalse(); + elements.getTypeElement(AnnotatedAnnotation.class.getCanonicalName()); + + // Test Class API + isAnnotationPresentAsserts( + MoreElements.isAnnotationPresent(annotatedAnnotationElement, Documented.class), + MoreElements.isAnnotationPresent(annotatedAnnotationElement, InnerAnnotation.class), + MoreElements.isAnnotationPresent(annotatedAnnotationElement, SuppressWarnings.class)); + + // Test String API + String documentedName = Documented.class.getCanonicalName(); + String innerAnnotationName = InnerAnnotation.class.getCanonicalName(); + String suppressWarningsName = SuppressWarnings.class.getCanonicalName(); + isAnnotationPresentAsserts( + MoreElements.isAnnotationPresent(annotatedAnnotationElement, documentedName), + MoreElements.isAnnotationPresent(annotatedAnnotationElement, innerAnnotationName), + MoreElements.isAnnotationPresent(annotatedAnnotationElement, suppressWarningsName)); + + // Test TypeElement API + TypeElement documentedElement = elements.getTypeElement(documentedName); + TypeElement innerAnnotationElement = elements.getTypeElement(innerAnnotationName); + TypeElement suppressWarningsElement = elements.getTypeElement(suppressWarningsName); + isAnnotationPresentAsserts( + MoreElements.isAnnotationPresent(annotatedAnnotationElement, documentedElement), + MoreElements.isAnnotationPresent(annotatedAnnotationElement, innerAnnotationElement), + MoreElements.isAnnotationPresent(annotatedAnnotationElement, suppressWarningsElement)); + } + + private void isAnnotationPresentAsserts( + boolean isDocumentedPresent, + boolean isInnerAnnotationPresent, + boolean isSuppressWarningsPresent) { + assertThat(isDocumentedPresent).isTrue(); + assertThat(isInnerAnnotationPresent).isTrue(); + assertThat(isSuppressWarningsPresent).isFalse(); } @Test public void getAnnotationMirror() { TypeElement element = - compilation.getElements().getTypeElement(AnnotatedAnnotation.class.getCanonicalName()); - - Optional<AnnotationMirror> documented = - MoreElements.getAnnotationMirror(element, Documented.class); - Optional<AnnotationMirror> innerAnnotation = - MoreElements.getAnnotationMirror(element, InnerAnnotation.class); - Optional<AnnotationMirror> suppressWarnings = - MoreElements.getAnnotationMirror(element, SuppressWarnings.class); - + elements.getTypeElement(AnnotatedAnnotation.class.getCanonicalName()); + + // Test Class API + getAnnotationMirrorAsserts( + MoreElements.getAnnotationMirror(element, Documented.class), + MoreElements.getAnnotationMirror(element, InnerAnnotation.class), + MoreElements.getAnnotationMirror(element, SuppressWarnings.class)); + + // Test String API + String documentedName = Documented.class.getCanonicalName(); + String innerAnnotationName = InnerAnnotation.class.getCanonicalName(); + String suppressWarningsName = SuppressWarnings.class.getCanonicalName(); + getAnnotationMirrorAsserts( + MoreElements.getAnnotationMirror(element, documentedName), + MoreElements.getAnnotationMirror(element, innerAnnotationName), + MoreElements.getAnnotationMirror(element, suppressWarningsName)); + + // Test TypeElement API + TypeElement documentedElement = elements.getTypeElement(documentedName); + TypeElement innerAnnotationElement = elements.getTypeElement(innerAnnotationName); + TypeElement suppressWarningsElement = elements.getTypeElement(suppressWarningsName); + getAnnotationMirrorAsserts( + MoreElements.getAnnotationMirror(element, documentedElement), + MoreElements.getAnnotationMirror(element, innerAnnotationElement), + MoreElements.getAnnotationMirror(element, suppressWarningsElement)); + } + + private void getAnnotationMirrorAsserts( + Optional<AnnotationMirror> documented, + Optional<AnnotationMirror> innerAnnotation, + Optional<AnnotationMirror> suppressWarnings) { expect.that(documented).isPresent(); expect.that(innerAnnotation).isPresent(); expect.that(suppressWarnings).isAbsent(); Element annotationElement = documented.get().getAnnotationType().asElement(); expect.that(MoreElements.isType(annotationElement)).isTrue(); - expect.that(MoreElements.asType(annotationElement).getQualifiedName().toString()) + expect + .that(MoreElements.asType(annotationElement).getQualifiedName().toString()) .isEqualTo(Documented.class.getCanonicalName()); annotationElement = innerAnnotation.get().getAnnotationType().asElement(); expect.that(MoreElements.isType(annotationElement)).isTrue(); - expect.that(MoreElements.asType(annotationElement).getQualifiedName().toString()) + expect + .that(MoreElements.asType(annotationElement).getQualifiedName().toString()) .isEqualTo(InnerAnnotation.class.getCanonicalName()); } @@ -231,6 +287,7 @@ public class MoreElementsTest { abstract String foo(); + @SuppressWarnings("unused") private void privateMethod() {} } @@ -259,7 +316,6 @@ public class MoreElementsTest { @Test public void getLocalAndInheritedMethods_Old() { - Elements elements = compilation.getElements(); Types types = compilation.getTypes(); TypeMirror intMirror = types.getPrimitiveType(TypeKind.INT); TypeMirror longMirror = types.getPrimitiveType(TypeKind.LONG); @@ -270,19 +326,20 @@ public class MoreElementsTest { Set<ExecutableElement> objectMethods = visibleMethodsFromObject(); assertThat(childTypeMethods).containsAtLeastElementsIn(objectMethods); Set<ExecutableElement> nonObjectMethods = Sets.difference(childTypeMethods, objectMethods); - assertThat(nonObjectMethods).containsExactly( + assertThat(nonObjectMethods) + .containsExactly( getMethod(ParentInterface.class, "bar", longMirror), getMethod(ParentClass.class, "foo"), getMethod(Child.class, "bar"), getMethod(Child.class, "baz"), getMethod(Child.class, "buh", intMirror), getMethod(Child.class, "buh", intMirror, intMirror)) - .inOrder();; + .inOrder(); + ; } @Test public void getLocalAndInheritedMethods() { - Elements elements = compilation.getElements(); Types types = compilation.getTypes(); TypeMirror intMirror = types.getPrimitiveType(TypeKind.INT); TypeMirror longMirror = types.getPrimitiveType(TypeKind.LONG); @@ -293,7 +350,8 @@ public class MoreElementsTest { Set<ExecutableElement> objectMethods = visibleMethodsFromObject(); assertThat(childTypeMethods).containsAtLeastElementsIn(objectMethods); Set<ExecutableElement> nonObjectMethods = Sets.difference(childTypeMethods, objectMethods); - assertThat(nonObjectMethods).containsExactly( + assertThat(nonObjectMethods) + .containsExactly( getMethod(ParentInterface.class, "bar", longMirror), getMethod(ParentClass.class, "foo"), getMethod(Child.class, "bar"), @@ -305,7 +363,6 @@ public class MoreElementsTest { @Test public void getAllMethods() { - Elements elements = compilation.getElements(); Types types = compilation.getTypes(); TypeMirror intMirror = types.getPrimitiveType(TypeKind.INT); TypeMirror longMirror = types.getPrimitiveType(TypeKind.LONG); @@ -316,7 +373,8 @@ public class MoreElementsTest { Set<ExecutableElement> objectMethods = allMethodsFromObject(); assertThat(childTypeMethods).containsAtLeastElementsIn(objectMethods); Set<ExecutableElement> nonObjectMethods = Sets.difference(childTypeMethods, objectMethods); - assertThat(nonObjectMethods).containsExactly( + assertThat(nonObjectMethods) + .containsExactly( getMethod(ParentInterface.class, "staticMethod"), getMethod(ParentInterface.class, "bar", longMirror), getMethod(ParentClass.class, "staticMethod"), @@ -355,10 +413,9 @@ public class MoreElementsTest { // Example from https://github.com/williamlian/daggerbug @Test public void getLocalAndInheritedMethods_DaggerBug() { - Elements elementUtils = compilation.getElements(); - TypeElement main = elementUtils.getTypeElement(Main.ParentComponent.class.getCanonicalName()); - Set<ExecutableElement> methods = MoreElements.getLocalAndInheritedMethods( - main, compilation.getTypes(), elementUtils); + TypeElement main = elements.getTypeElement(Main.ParentComponent.class.getCanonicalName()); + Set<ExecutableElement> methods = + MoreElements.getLocalAndInheritedMethods(main, compilation.getTypes(), elements); assertThat(methods).hasSize(1); ExecutableElement method = methods.iterator().next(); assertThat(method.getSimpleName().toString()).isEqualTo("injectable"); @@ -404,7 +461,7 @@ public class MoreElementsTest { } private ExecutableElement getMethod(Class<?> c, String methodName, TypeMirror... parameterTypes) { - TypeElement type = compilation.getElements().getTypeElement(c.getCanonicalName()); + TypeElement type = elements.getTypeElement(c.getCanonicalName()); Types types = compilation.getTypes(); ExecutableElement found = null; for (ExecutableElement method : ElementFilter.methodsIn(type.getEnclosedElements())) { @@ -423,7 +480,7 @@ public class MoreElementsTest { } } assertWithMessage(methodName + Arrays.toString(parameterTypes)).that(found).isNotNull(); - return found; + return requireNonNull(found); } private abstract static class AbstractAbstractList extends AbstractList<String> {} @@ -458,8 +515,6 @@ public class MoreElementsTest { // are implemented in AbstractList. @Test public void getLocalAndInheritedMethods_AbstractList() { - Elements elements = compilation.getElements(); - TypeElement abstractType = elements.getTypeElement(AbstractAbstractList.class.getCanonicalName()); Set<ExecutableElement> abstractTypeMethods = diff --git a/common/src/test/java/com/google/auto/common/MoreTypesIsTypeOfTest.java b/common/src/test/java/com/google/auto/common/MoreTypesIsTypeOfTest.java index 05a0a119..7cd7865d 100644 --- a/common/src/test/java/com/google/auto/common/MoreTypesIsTypeOfTest.java +++ b/common/src/test/java/com/google/auto/common/MoreTypesIsTypeOfTest.java @@ -43,13 +43,15 @@ public class MoreTypesIsTypeOfTest { private Elements elements; - @Before public void setUp() { + @Before + public void setUp() { this.elements = compilationRule.getElements(); } private interface TestType {} - @Test public void isTypeOf_DeclaredType() { + @Test + public void isTypeOf_declaredType() { assertTrue(MoreTypes.isType(typeElementFor(TestType.class).asType())); assertWithMessage("mirror represents the TestType") .that(MoreTypes.isTypeOf(TestType.class, typeElementFor(TestType.class).asType())) @@ -63,7 +65,8 @@ public class MoreTypesIsTypeOfTest { String[] array(); } - @Test public void isTypeOf_ArrayType() { + @Test + public void isTypeOf_arrayType() { assertTrue(MoreTypes.isType(typeElementFor(ArrayType.class).asType())); TypeMirror type = extractReturnTypeFromHolder(typeElementFor(ArrayType.class)); assertWithMessage("array mirror represents an array Class object") @@ -75,7 +78,8 @@ public class MoreTypesIsTypeOfTest { boolean method(); } - @Test public void isTypeOf_PrimitiveBoolean() { + @Test + public void isTypeOf_primitiveBoolean() { assertTrue(MoreTypes.isType(typeElementFor(PrimitiveBoolean.class).asType())); TypeMirror type = extractReturnTypeFromHolder(typeElementFor(PrimitiveBoolean.class)); assertWithMessage("mirror of a boolean").that(MoreTypes.isTypeOf(Boolean.TYPE, type)).isTrue(); @@ -85,7 +89,8 @@ public class MoreTypesIsTypeOfTest { byte method(); } - @Test public void isTypeOf_PrimitiveByte() { + @Test + public void isTypeOf_primitiveByte() { assertTrue(MoreTypes.isType(typeElementFor(PrimitiveByte.class).asType())); TypeMirror type = extractReturnTypeFromHolder(typeElementFor(PrimitiveByte.class)); assertWithMessage("mirror of a byte").that(MoreTypes.isTypeOf(Byte.TYPE, type)).isTrue(); @@ -95,7 +100,8 @@ public class MoreTypesIsTypeOfTest { char method(); } - @Test public void isTypeOf_PrimitiveChar() { + @Test + public void isTypeOf_primitiveChar() { assertTrue(MoreTypes.isType(typeElementFor(PrimitiveChar.class).asType())); TypeMirror type = extractReturnTypeFromHolder(typeElementFor(PrimitiveChar.class)); assertWithMessage("mirror of a char").that(MoreTypes.isTypeOf(Character.TYPE, type)).isTrue(); @@ -105,7 +111,8 @@ public class MoreTypesIsTypeOfTest { double method(); } - @Test public void isTypeOf_PrimitiveDouble() { + @Test + public void isTypeOf_primitiveDouble() { assertTrue(MoreTypes.isType(typeElementFor(PrimitiveDouble.class).asType())); TypeMirror type = extractReturnTypeFromHolder(typeElementFor(PrimitiveDouble.class)); assertWithMessage("mirror of a double").that(MoreTypes.isTypeOf(Double.TYPE, type)).isTrue(); @@ -115,7 +122,8 @@ public class MoreTypesIsTypeOfTest { float method(); } - @Test public void isTypeOf_PrimitiveFloat() { + @Test + public void isTypeOf_primitiveFloat() { assertTrue(MoreTypes.isType(typeElementFor(PrimitiveFloat.class).asType())); TypeMirror type = extractReturnTypeFromHolder(typeElementFor(PrimitiveFloat.class)); assertWithMessage("mirror of a float").that(MoreTypes.isTypeOf(Float.TYPE, type)).isTrue(); @@ -125,7 +133,8 @@ public class MoreTypesIsTypeOfTest { int method(); } - @Test public void isTypeOf_PrimitiveInt() { + @Test + public void isTypeOf_primitiveInt() { assertTrue(MoreTypes.isType(typeElementFor(PrimitiveInt.class).asType())); TypeMirror type = extractReturnTypeFromHolder(typeElementFor(PrimitiveInt.class)); assertWithMessage("mirror of a int").that(MoreTypes.isTypeOf(Integer.TYPE, type)).isTrue(); @@ -135,7 +144,8 @@ public class MoreTypesIsTypeOfTest { long method(); } - @Test public void isTypeOf_PrimitiveLong() { + @Test + public void isTypeOf_primitiveLong() { assertTrue(MoreTypes.isType(typeElementFor(PrimitiveLong.class).asType())); TypeMirror type = extractReturnTypeFromHolder(typeElementFor(PrimitiveLong.class)); assertWithMessage("mirror of a long").that(MoreTypes.isTypeOf(Long.TYPE, type)).isTrue(); @@ -145,7 +155,8 @@ public class MoreTypesIsTypeOfTest { short method(); } - @Test public void isTypeOf_PrimitiveShort() { + @Test + public void isTypeOf_primitiveShort() { assertTrue(MoreTypes.isType(typeElementFor(PrimitiveShort.class).asType())); TypeMirror type = extractReturnTypeFromHolder(typeElementFor(PrimitiveShort.class)); assertWithMessage("mirror of a short").that(MoreTypes.isTypeOf(Short.TYPE, type)).isTrue(); @@ -155,7 +166,8 @@ public class MoreTypesIsTypeOfTest { void method(); } - @Test public void isTypeOf_void() { + @Test + public void isTypeOf_primitiveVoid() { assertTrue(MoreTypes.isType(typeElementFor(PrimitiveVoid.class).asType())); TypeMirror primitive = extractReturnTypeFromHolder(typeElementFor(PrimitiveVoid.class)); assertWithMessage("mirror of a void").that(MoreTypes.isTypeOf(Void.TYPE, primitive)).isTrue(); @@ -165,21 +177,25 @@ public class MoreTypesIsTypeOfTest { Void method(); } - @Test public void isTypeOf_Void() { + @Test + public void isTypeOf_declaredVoid() { assertTrue(MoreTypes.isType(typeElementFor(DeclaredVoid.class).asType())); TypeMirror declared = extractReturnTypeFromHolder(typeElementFor(DeclaredVoid.class)); assertWithMessage("mirror of a void").that(MoreTypes.isTypeOf(Void.class, declared)).isTrue(); } - @Test public void isTypeOf_fail() { - assertFalse(MoreTypes.isType( - getOnlyElement(typeElementFor(DeclaredVoid.class).getEnclosedElements()).asType())); + @Test + public void isTypeOf_fail() { + assertFalse( + MoreTypes.isType( + getOnlyElement(typeElementFor(DeclaredVoid.class).getEnclosedElements()).asType())); TypeMirror method = getOnlyElement(typeElementFor(DeclaredVoid.class).getEnclosedElements()).asType(); try { MoreTypes.isTypeOf(String.class, method); fail(); - } catch (IllegalArgumentException expected) {} + } catch (IllegalArgumentException expected) { + } } // Utility methods for this test. diff --git a/common/src/test/java/com/google/auto/common/MoreTypesTest.java b/common/src/test/java/com/google/auto/common/MoreTypesTest.java index 3cd360db..b8e84e08 100644 --- a/common/src/test/java/com/google/auto/common/MoreTypesTest.java +++ b/common/src/test/java/com/google/auto/common/MoreTypesTest.java @@ -16,11 +16,12 @@ package com.google.auto.common; import static com.google.common.truth.Truth.assertThat; +import static java.util.Objects.requireNonNull; import static javax.lang.model.type.TypeKind.NONE; import static javax.lang.model.type.TypeKind.VOID; +import static org.junit.Assert.assertThrows; import static org.junit.Assert.fail; -import com.google.common.base.Function; import com.google.common.base.Optional; import com.google.common.collect.FluentIterable; import com.google.common.collect.ImmutableList; @@ -49,6 +50,7 @@ import javax.lang.model.type.WildcardType; import javax.lang.model.util.ElementFilter; import javax.lang.model.util.Elements; import javax.lang.model.util.Types; +import org.checkerframework.checker.nullness.qual.Nullable; import org.junit.Rule; import org.junit.Test; import org.junit.runner.RunWith; @@ -90,48 +92,51 @@ public class MoreTypesTest { DeclaredType containerOfString = types.getDeclaredType(container, stringType); TypeMirror containedInObject = types.asMemberOf(containerOfObject, contained); TypeMirror containedInString = types.asMemberOf(containerOfString, contained); - EquivalenceTester<TypeMirror> tester = EquivalenceTester.<TypeMirror>of(MoreTypes.equivalence()) - .addEquivalenceGroup(types.getNullType()) - .addEquivalenceGroup(types.getNoType(NONE)) - .addEquivalenceGroup(types.getNoType(VOID)) - .addEquivalenceGroup(objectType) - .addEquivalenceGroup(stringType) - .addEquivalenceGroup(containedInObject) - .addEquivalenceGroup(containedInString) - .addEquivalenceGroup(funkyBounds.asType()) - .addEquivalenceGroup(funkyBounds2.asType()) - .addEquivalenceGroup(funkierBounds.asType()) - .addEquivalenceGroup(funkyBoundsVar, funkyBounds2Var) - .addEquivalenceGroup(funkierBoundsVar) - // Enum<E extends Enum<E>> - .addEquivalenceGroup(enumElement.asType()) - // Map<K, V> - .addEquivalenceGroup(mapType) - .addEquivalenceGroup(mapOfObjectToObjectType) - // Map<?, ?> - .addEquivalenceGroup(types.getDeclaredType(mapElement, wildcard, wildcard)) - // Map - .addEquivalenceGroup(types.erasure(mapType), types.erasure(mapOfObjectToObjectType)) - .addEquivalenceGroup(types.getDeclaredType(mapElement, objectType, stringType)) - .addEquivalenceGroup(types.getDeclaredType(mapElement, stringType, objectType)) - .addEquivalenceGroup(types.getDeclaredType(mapElement, stringType, stringType)) - .addEquivalenceGroup(setOfSetOfObject) - .addEquivalenceGroup(setOfSetOfString) - .addEquivalenceGroup(setOfSetOfSetOfObject) - .addEquivalenceGroup(setOfSetOfSetOfString) - .addEquivalenceGroup(wildcard) - // ? extends Object - .addEquivalenceGroup(types.getWildcardType(objectType, null)) - // ? extends String - .addEquivalenceGroup(types.getWildcardType(stringType, null)) - // ? super String - .addEquivalenceGroup(types.getWildcardType(null, stringType)) - // Map<String, Map<String, Set<Object>>> - .addEquivalenceGroup(types.getDeclaredType(mapElement, stringType, - types.getDeclaredType(mapElement, stringType, - types.getDeclaredType(setElement, objectType)))) - .addEquivalenceGroup(FAKE_ERROR_TYPE) - ; + EquivalenceTester<TypeMirror> tester = + EquivalenceTester.<TypeMirror>of(MoreTypes.equivalence()) + .addEquivalenceGroup(types.getNullType()) + .addEquivalenceGroup(types.getNoType(NONE)) + .addEquivalenceGroup(types.getNoType(VOID)) + .addEquivalenceGroup(objectType) + .addEquivalenceGroup(stringType) + .addEquivalenceGroup(containedInObject) + .addEquivalenceGroup(containedInString) + .addEquivalenceGroup(funkyBounds.asType()) + .addEquivalenceGroup(funkyBounds2.asType()) + .addEquivalenceGroup(funkierBounds.asType()) + .addEquivalenceGroup(funkyBoundsVar, funkyBounds2Var) + .addEquivalenceGroup(funkierBoundsVar) + // Enum<E extends Enum<E>> + .addEquivalenceGroup(enumElement.asType()) + // Map<K, V> + .addEquivalenceGroup(mapType) + .addEquivalenceGroup(mapOfObjectToObjectType) + // Map<?, ?> + .addEquivalenceGroup(types.getDeclaredType(mapElement, wildcard, wildcard)) + // Map + .addEquivalenceGroup(types.erasure(mapType), types.erasure(mapOfObjectToObjectType)) + .addEquivalenceGroup(types.getDeclaredType(mapElement, objectType, stringType)) + .addEquivalenceGroup(types.getDeclaredType(mapElement, stringType, objectType)) + .addEquivalenceGroup(types.getDeclaredType(mapElement, stringType, stringType)) + .addEquivalenceGroup(setOfSetOfObject) + .addEquivalenceGroup(setOfSetOfString) + .addEquivalenceGroup(setOfSetOfSetOfObject) + .addEquivalenceGroup(setOfSetOfSetOfString) + .addEquivalenceGroup(wildcard) + // ? extends Object + .addEquivalenceGroup(types.getWildcardType(objectType, null)) + // ? extends String + .addEquivalenceGroup(types.getWildcardType(stringType, null)) + // ? super String + .addEquivalenceGroup(types.getWildcardType(null, stringType)) + // Map<String, Map<String, Set<Object>>> + .addEquivalenceGroup( + types.getDeclaredType( + mapElement, + stringType, + types.getDeclaredType( + mapElement, stringType, types.getDeclaredType(setElement, objectType)))) + .addEquivalenceGroup(FAKE_ERROR_TYPE); for (TypeKind kind : TypeKind.values()) { if (kind.isPrimitive()) { @@ -144,20 +149,18 @@ public class MoreTypesTest { } } - ImmutableSet<Class<?>> testClasses = ImmutableSet.of( - ExecutableElementsGroupA.class, - ExecutableElementsGroupB.class, - ExecutableElementsGroupC.class, - ExecutableElementsGroupD.class, - ExecutableElementsGroupE.class); + ImmutableSet<Class<?>> testClasses = + ImmutableSet.of( + ExecutableElementsGroupA.class, + ExecutableElementsGroupB.class, + ExecutableElementsGroupC.class, + ExecutableElementsGroupD.class, + ExecutableElementsGroupE.class); for (Class<?> testClass : testClasses) { - ImmutableList<TypeMirror> equivalenceGroup = FluentIterable.from( - elements.getTypeElement(testClass.getCanonicalName()).getEnclosedElements()) - .transform(new Function<Element, TypeMirror>() { - @Override public TypeMirror apply(Element input) { - return input.asType(); - } - }) + ImmutableList<TypeMirror> equivalenceGroup = + FluentIterable.from( + elements.getTypeElement(testClass.getCanonicalName()).getEnclosedElements()) + .transform(Element::asType) .toList(); tester.addEquivalenceGroup(equivalenceGroup); } @@ -168,35 +171,45 @@ public class MoreTypesTest { @SuppressWarnings("unused") private static final class ExecutableElementsGroupA { ExecutableElementsGroupA() {} + void a() {} + public static void b() {} } @SuppressWarnings("unused") private static final class ExecutableElementsGroupB { ExecutableElementsGroupB(String s) {} + void a(String s) {} + public static void b(String s) {} } @SuppressWarnings("unused") private static final class ExecutableElementsGroupC { ExecutableElementsGroupC() throws Exception {} + void a() throws Exception {} + public static void b() throws Exception {} } @SuppressWarnings("unused") private static final class ExecutableElementsGroupD { ExecutableElementsGroupD() throws RuntimeException {} + void a() throws RuntimeException {} + public static void b() throws RuntimeException {} } @SuppressWarnings("unused") private static final class ExecutableElementsGroupE { <T> ExecutableElementsGroupE() {} + <T> void a() {} + public static <T> void b() {} } @@ -214,53 +227,44 @@ public class MoreTypesTest { @SuppressWarnings("unused") private static final class FunkierBounds<T extends Number & Comparable<T> & Cloneable> {} - @Test public void testReferencedTypes() { + @Test + public void testReferencedTypes() { Elements elements = compilationRule.getElements(); - TypeElement testDataElement = elements - .getTypeElement(ReferencedTypesTestData.class.getCanonicalName()); + TypeElement testDataElement = + elements.getTypeElement(ReferencedTypesTestData.class.getCanonicalName()); ImmutableMap<String, VariableElement> fieldIndex = FluentIterable.from(ElementFilter.fieldsIn(testDataElement.getEnclosedElements())) - .uniqueIndex(new Function<VariableElement, String>() { - @Override public String apply(VariableElement input) { - return input.getSimpleName().toString(); - } - }); - - TypeElement objectElement = - elements.getTypeElement(Object.class.getCanonicalName()); - TypeElement stringElement = - elements.getTypeElement(String.class.getCanonicalName()); - TypeElement integerElement = - elements.getTypeElement(Integer.class.getCanonicalName()); - TypeElement setElement = - elements.getTypeElement(Set.class.getCanonicalName()); - TypeElement mapElement = - elements.getTypeElement(Map.class.getCanonicalName()); + .uniqueIndex(input -> input.getSimpleName().toString()); + + TypeElement objectElement = elements.getTypeElement(Object.class.getCanonicalName()); + TypeElement stringElement = elements.getTypeElement(String.class.getCanonicalName()); + TypeElement integerElement = elements.getTypeElement(Integer.class.getCanonicalName()); + TypeElement setElement = elements.getTypeElement(Set.class.getCanonicalName()); + TypeElement mapElement = elements.getTypeElement(Map.class.getCanonicalName()); TypeElement charSequenceElement = elements.getTypeElement(CharSequence.class.getCanonicalName()); - assertThat(MoreTypes.referencedTypes(fieldIndex.get("f1").asType())) - .containsExactly(objectElement); - assertThat(MoreTypes.referencedTypes(fieldIndex.get("f2").asType())) - .containsExactly(setElement, stringElement); - assertThat(MoreTypes.referencedTypes(fieldIndex.get("f3").asType())) + assertThat(referencedTypes(fieldIndex, "f1")).containsExactly(objectElement); + assertThat(referencedTypes(fieldIndex, "f2")).containsExactly(setElement, stringElement); + assertThat(referencedTypes(fieldIndex, "f3")) .containsExactly(mapElement, stringElement, objectElement); - assertThat(MoreTypes.referencedTypes(fieldIndex.get("f4").asType())) - .containsExactly(integerElement); - assertThat(MoreTypes.referencedTypes(fieldIndex.get("f5").asType())) - .containsExactly(setElement); - assertThat(MoreTypes.referencedTypes(fieldIndex.get("f6").asType())) - .containsExactly(setElement, charSequenceElement); - assertThat(MoreTypes.referencedTypes(fieldIndex.get("f7").asType())) + assertThat(referencedTypes(fieldIndex, "f4")).containsExactly(integerElement); + assertThat(referencedTypes(fieldIndex, "f5")).containsExactly(setElement); + assertThat(referencedTypes(fieldIndex, "f6")).containsExactly(setElement, charSequenceElement); + assertThat(referencedTypes(fieldIndex, "f7")) .containsExactly(mapElement, stringElement, setElement, charSequenceElement); - assertThat(MoreTypes.referencedTypes(fieldIndex.get("f8").asType())) - .containsExactly(stringElement); - assertThat(MoreTypes.referencedTypes(fieldIndex.get("f9").asType())) - .containsExactly(stringElement); - assertThat(MoreTypes.referencedTypes(fieldIndex.get("f10").asType())).isEmpty(); - assertThat(MoreTypes.referencedTypes(fieldIndex.get("f11").asType())).isEmpty(); - assertThat(MoreTypes.referencedTypes(fieldIndex.get("f12").asType())) - .containsExactly(setElement, stringElement); + assertThat(referencedTypes(fieldIndex, "f8")).containsExactly(stringElement); + assertThat(referencedTypes(fieldIndex, "f9")).containsExactly(stringElement); + assertThat(referencedTypes(fieldIndex, "f10")).isEmpty(); + assertThat(referencedTypes(fieldIndex, "f11")).isEmpty(); + assertThat(referencedTypes(fieldIndex, "f12")).containsExactly(setElement, stringElement); + } + + private static ImmutableSet<TypeElement> referencedTypes( + ImmutableMap<String, VariableElement> fieldIndex, String fieldName) { + VariableElement field = fieldIndex.get(fieldName); + requireNonNull(field, fieldName); + return MoreTypes.referencedTypes(field.asType()); } @SuppressWarnings("unused") // types used in compiler tests @@ -280,20 +284,23 @@ public class MoreTypesTest { } private static class Parent<T> {} + private static class ChildA extends Parent<Number> {} + private static class ChildB extends Parent<String> {} + private static class GenericChild<T> extends Parent<T> {} + private interface InterfaceType {} @Test public void asElement_throws() { - TypeMirror javaDotLang = - compilationRule.getElements().getPackageElement("java.lang").asType(); + TypeMirror javaDotLang = compilationRule.getElements().getPackageElement("java.lang").asType(); try { MoreTypes.asElement(javaDotLang); fail(); - } catch (IllegalArgumentException expected) {} - + } catch (IllegalArgumentException expected) { + } } @Test @@ -301,8 +308,9 @@ public class MoreTypesTest { Elements elements = compilationRule.getElements(); TypeElement stringElement = elements.getTypeElement("java.lang.String"); assertThat(MoreTypes.asElement(stringElement.asType())).isEqualTo(stringElement); - TypeParameterElement setParameterElement = Iterables.getOnlyElement( - compilationRule.getElements().getTypeElement("java.util.Set").getTypeParameters()); + TypeParameterElement setParameterElement = + Iterables.getOnlyElement( + compilationRule.getElements().getTypeElement("java.util.Set").getTypeParameters()); assertThat(MoreTypes.asElement(setParameterElement.asType())).isEqualTo(setParameterElement); // we don't test error types because those are very hard to get predictably } @@ -320,8 +328,7 @@ public class MoreTypesTest { TypeElement genericChild = elements.getTypeElement(GenericChild.class.getCanonicalName()); TypeMirror genericChildOfNumber = types.getDeclaredType(genericChild, numberType); TypeMirror genericChildOfInteger = types.getDeclaredType(genericChild, integerType); - TypeMirror objectType = - elements.getTypeElement(Object.class.getCanonicalName()).asType(); + TypeMirror objectType = elements.getTypeElement(Object.class.getCanonicalName()).asType(); TypeMirror interfaceType = elements.getTypeElement(InterfaceType.class.getCanonicalName()).asType(); @@ -343,18 +350,20 @@ public class MoreTypesTest { Optional<DeclaredType> parentOfGenericChildOfInteger = MoreTypes.nonObjectSuperclass(types, elements, (DeclaredType) genericChildOfInteger); - EquivalenceTester<TypeMirror> tester = EquivalenceTester.<TypeMirror>of(MoreTypes.equivalence()) - .addEquivalenceGroup(parentOfChildA.get(), - types.getDeclaredType(parent, numberType), - parentOfGenericChildOfNumber.get()) - .addEquivalenceGroup(parentOfChildB.get(), types.getDeclaredType(parent, stringType)) - .addEquivalenceGroup(parentOfGenericChild.get(), parent.asType()) - .addEquivalenceGroup(parentOfGenericChildOfInteger.get(), - types.getDeclaredType(parent, integerType)); + EquivalenceTester<TypeMirror> tester = + EquivalenceTester.<TypeMirror>of(MoreTypes.equivalence()) + .addEquivalenceGroup( + parentOfChildA.get(), + types.getDeclaredType(parent, numberType), + parentOfGenericChildOfNumber.get()) + .addEquivalenceGroup(parentOfChildB.get(), types.getDeclaredType(parent, stringType)) + .addEquivalenceGroup(parentOfGenericChild.get(), parent.asType()) + .addEquivalenceGroup( + parentOfGenericChildOfInteger.get(), types.getDeclaredType(parent, integerType)); tester.test(); } - + @Test public void testAsMemberOf_variableElement() { Types types = compilationRule.getTypes(); @@ -364,11 +373,13 @@ public class MoreTypesTest { TypeMirror integerType = elements.getTypeElement(Integer.class.getCanonicalName()).asType(); TypeElement paramsElement = elements.getTypeElement(Params.class.getCanonicalName()); - VariableElement tParam = Iterables.getOnlyElement(Iterables.getOnlyElement( - ElementFilter.methodsIn(paramsElement.getEnclosedElements())).getParameters()); + VariableElement tParam = + Iterables.getOnlyElement( + Iterables.getOnlyElement(ElementFilter.methodsIn(paramsElement.getEnclosedElements())) + .getParameters()); VariableElement tField = - Iterables.getOnlyElement(ElementFilter.fieldsIn(paramsElement.getEnclosedElements())); - + Iterables.getOnlyElement(ElementFilter.fieldsIn(paramsElement.getEnclosedElements())); + DeclaredType numberParams = (DeclaredType) elements.getTypeElement(NumberParams.class.getCanonicalName()).asType(); DeclaredType stringParams = @@ -376,7 +387,7 @@ public class MoreTypesTest { TypeElement genericParams = elements.getTypeElement(GenericParams.class.getCanonicalName()); DeclaredType genericParamsOfNumber = types.getDeclaredType(genericParams, numberType); DeclaredType genericParamsOfInteger = types.getDeclaredType(genericParams, integerType); - + TypeMirror fieldOfNumberParams = MoreTypes.asMemberOf(types, numberParams, tField); TypeMirror paramOfNumberParams = MoreTypes.asMemberOf(types, numberParams, tParam); TypeMirror fieldOfStringParams = MoreTypes.asMemberOf(types, stringParams, tField); @@ -388,62 +399,76 @@ public class MoreTypesTest { TypeMirror paramOfGenericOfInteger = MoreTypes.asMemberOf(types, genericParamsOfInteger, tParam); - EquivalenceTester<TypeMirror> tester = EquivalenceTester.<TypeMirror>of(MoreTypes.equivalence()) - .addEquivalenceGroup(fieldOfNumberParams, paramOfNumberParams, fieldOfGenericOfNumber, - paramOfGenericOfNumber, numberType) - .addEquivalenceGroup(fieldOfStringParams, paramOfStringParams, stringType) - .addEquivalenceGroup(fieldOfGenericOfInteger, paramOfGenericOfInteger, integerType); + EquivalenceTester<TypeMirror> tester = + EquivalenceTester.<TypeMirror>of(MoreTypes.equivalence()) + .addEquivalenceGroup( + fieldOfNumberParams, + paramOfNumberParams, + fieldOfGenericOfNumber, + paramOfGenericOfNumber, + numberType) + .addEquivalenceGroup(fieldOfStringParams, paramOfStringParams, stringType) + .addEquivalenceGroup(fieldOfGenericOfInteger, paramOfGenericOfInteger, integerType); tester.test(); } - - private static class Params<T> { - @SuppressWarnings("unused") T t; - @SuppressWarnings("unused") void add(T t) {} - } - private static class NumberParams extends Params<Number> {} - private static class StringParams extends Params<String> {} - private static class GenericParams<T> extends Params<T> {} - - private static final ErrorType FAKE_ERROR_TYPE = new ErrorType() { - @Override - public TypeKind getKind() { - return TypeKind.ERROR; - } - @Override - public <R, P> R accept(TypeVisitor<R, P> v, P p) { - return v.visitError(this, p); - } - - @Override - public List<? extends TypeMirror> getTypeArguments() { - return ImmutableList.of(); - } - - @Override - public TypeMirror getEnclosingType() { - return null; - } + private static class Params<T> { + @SuppressWarnings("unused") + T t; - @Override - public Element asElement() { - return null; - } + @SuppressWarnings("unused") + void add(T t) {} + } - // JDK8 Compatibility: + private static class NumberParams extends Params<Number> {} - public <A extends Annotation> A[] getAnnotationsByType(Class<A> annotationType) { - return null; - } + private static class StringParams extends Params<String> {} - public <A extends Annotation> A getAnnotation(Class<A> annotationType) { - return null; - } + private static class GenericParams<T> extends Params<T> {} - public List<? extends AnnotationMirror> getAnnotationMirrors() { - return null; - } - }; + private static final ErrorType FAKE_ERROR_TYPE = + new ErrorType() { + @Override + public TypeKind getKind() { + return TypeKind.ERROR; + } + + @Override + public <R, P> R accept(TypeVisitor<R, P> v, P p) { + return v.visitError(this, p); + } + + @Override + public ImmutableList<? extends TypeMirror> getTypeArguments() { + return ImmutableList.of(); + } + + @Override + public @Nullable TypeMirror getEnclosingType() { + return null; + } + + @Override + public @Nullable Element asElement() { + return null; + } + + @Override + public <A extends Annotation> A @Nullable [] getAnnotationsByType(Class<A> annotationType) { + return null; + } + + @Override + public <A extends Annotation> @Nullable A getAnnotation(Class<A> annotationType) { + return null; + } + + @Override + @SuppressWarnings("MutableMethodReturnType") + public List<? extends AnnotationMirror> getAnnotationMirrors() { + return ImmutableList.of(); + } + }; @Test public void testIsConversionFromObjectUnchecked_yes() { @@ -471,6 +496,21 @@ public class MoreTypesTest { } } + @Test + public void testIsTypeOf() { + Types types = compilationRule.getTypes(); + PrimitiveType intType = types.getPrimitiveType(TypeKind.INT); + TypeMirror integerType = types.boxedClass(intType).asType(); + WildcardType wildcardType = types.getWildcardType(null, null); + expect.that(MoreTypes.isTypeOf(int.class, intType)).isTrue(); + expect.that(MoreTypes.isTypeOf(Integer.class, integerType)).isTrue(); + expect.that(MoreTypes.isTypeOf(Integer.class, intType)).isFalse(); + expect.that(MoreTypes.isTypeOf(int.class, integerType)).isFalse(); + expect.that(MoreTypes.isTypeOf(Integer.class, FAKE_ERROR_TYPE)).isFalse(); + assertThrows( + IllegalArgumentException.class, () -> MoreTypes.isTypeOf(Integer.class, wildcardType)); + } + // The type of every field here is such that casting to it provokes an "unchecked" warning. @SuppressWarnings("unused") private static class Unchecked<T> { diff --git a/common/src/test/java/com/google/auto/common/OverridesTest.java b/common/src/test/java/com/google/auto/common/OverridesTest.java index afb79760..c5ccc5f6 100644 --- a/common/src/test/java/com/google/auto/common/OverridesTest.java +++ b/common/src/test/java/com/google/auto/common/OverridesTest.java @@ -17,6 +17,7 @@ package com.google.auto.common; import static com.google.common.truth.Truth.assertThat; import static java.nio.charset.StandardCharsets.UTF_8; +import static java.util.Objects.requireNonNull; import static javax.lang.model.util.ElementFilter.methodsIn; import com.google.common.base.Converter; @@ -57,6 +58,7 @@ import javax.tools.JavaFileObject; import javax.tools.StandardJavaFileManager; import javax.tools.StandardLocation; import org.eclipse.jdt.internal.compiler.tool.EclipseCompiler; +import org.checkerframework.checker.nullness.qual.Nullable; import org.junit.Before; import org.junit.Rule; import org.junit.Test; @@ -103,6 +105,7 @@ public class OverridesTest { abstract void initUtils(OverridesTest test); } + private final CompilerType compilerType; private Types typeUtils; @@ -126,12 +129,15 @@ public class OverridesTest { static class TypesForInheritance { interface One { void m(); + void m(String x); + void n(); } interface Two { void m(); + void m(int x); } @@ -142,28 +148,50 @@ public class OverridesTest { static class ChildOfParent extends Parent {} static class ChildOfOne implements One { - @Override public void m() {} - @Override public void m(String x) {} - @Override public void n() {} + @Override + public void m() {} + + @Override + public void m(String x) {} + + @Override + public void n() {} } static class ChildOfOneAndTwo implements One, Two { - @Override public void m() {} - @Override public void m(String x) {} - @Override public void m(int x) {} - @Override public void n() {} + @Override + public void m() {} + + @Override + public void m(String x) {} + + @Override + public void m(int x) {} + + @Override + public void n() {} } static class ChildOfParentAndOne extends Parent implements One { - @Override public void m() {} - @Override public void m(String x) {} - @Override public void n() {} + @Override + public void m() {} + + @Override + public void m(String x) {} + + @Override + public void n() {} } static class ChildOfParentAndOneAndTwo extends Parent implements One, Two { - @Override public void m(String x) {} - @Override public void m(int x) {} - @Override public void n() {} + @Override + public void m(String x) {} + + @Override + public void m(int x) {} + + @Override + public void n() {} } abstract static class AbstractChildOfOne implements One {} @@ -194,14 +222,20 @@ public class OverridesTest { abstract static class BindingDeclaration implements HasKey { abstract Optional<Element> bindingElement(); + abstract Optional<TypeElement> contributingModule(); } - abstract static class MultibindingDeclaration - extends BindingDeclaration implements HasBindingType, HasContributionType { - @Override public abstract Key key(); - @Override public abstract ContributionType contributionType(); - @Override public abstract BindingType bindingType(); + abstract static class MultibindingDeclaration extends BindingDeclaration + implements HasBindingType, HasContributionType { + @Override + public abstract Key key(); + + @Override + public abstract ContributionType contributionType(); + + @Override + public abstract BindingType bindingType(); } } @@ -221,16 +255,26 @@ public class OverridesTest { } static class TypesForGenerics { - interface XCollection<E> { + interface GCollection<E> { boolean add(E x); } - interface XList<E> extends XCollection<E> { - @Override public boolean add(E x); + interface GList<E> extends GCollection<E> { + @Override + boolean add(E x); } - static class StringList implements XList<String> { - @Override public boolean add(String x) { + static class StringList implements GList<String> { + @Override + public boolean add(String x) { + return false; + } + } + + @SuppressWarnings("rawtypes") + static class RawList implements GList { + @Override + public boolean add(Object x) { return false; } } @@ -243,7 +287,8 @@ public class OverridesTest { } static class RawChildOfRaw extends RawParent { - @Override void frob(List x) {} + @Override + void frob(List x) {} } static class NonRawParent { @@ -251,7 +296,8 @@ public class OverridesTest { } static class RawChildOfNonRaw extends NonRawParent { - @Override void frob(List x) {} + @Override + void frob(List x) {} } } @@ -291,8 +337,9 @@ public class OverridesTest { // since the two Es are not the same. @Test public void overridesDiamond() { - checkOverridesInSet(ImmutableSet.<Class<?>>of( - Collection.class, List.class, AbstractCollection.class, AbstractList.class)); + checkOverridesInSet( + ImmutableSet.<Class<?>>of( + Collection.class, List.class, AbstractCollection.class, AbstractList.class)); } private void checkOverridesInContainedClasses(Class<?> container) { @@ -324,10 +371,13 @@ public class OverridesTest { expect .withMessage( "%s.%s overrides %s.%s in %s: javac says %s, we say %s", - overrider.getEnclosingElement(), overrider, - overridden.getEnclosingElement(), overridden, + overrider.getEnclosingElement(), + overrider, + overridden.getEnclosingElement(), + overridden, in, - javacSays, weSay) + javacSays, + weSay) .fail(); } } @@ -355,7 +405,7 @@ public class OverridesTest { } } assertThat(found).isNotNull(); - return found; + return requireNonNull(found); } // These skeletal parallels to the real collection classes ensure that the test is independent @@ -375,8 +425,8 @@ public class OverridesTest { } } - private abstract static class XAbstractList<E> - extends XAbstractCollection<E> implements XList<E> { + private abstract static class XAbstractList<E> extends XAbstractCollection<E> + implements XList<E> { @Override public boolean add(E e) { return true; @@ -440,7 +490,7 @@ public class OverridesTest { extends Converter<String, Range<T>> { @Override protected String doBackward(Range<T> b) { - return null; + return ""; } } @@ -470,9 +520,8 @@ public class OverridesTest { explicitOverrides.methodFromSuperclasses(xAbstractStringList, add); assertThat(addInAbstractStringList).isNull(); - ExecutableElement addInStringList = - explicitOverrides.methodFromSuperclasses(xStringList, add); - assertThat(addInStringList.getEnclosingElement()).isEqualTo(xAbstractList); + ExecutableElement addInStringList = explicitOverrides.methodFromSuperclasses(xStringList, add); + assertThat(requireNonNull(addInStringList).getEnclosingElement()).isEqualTo(xAbstractList); } @Test @@ -487,20 +536,21 @@ public class OverridesTest { ExecutableElement addInAbstractStringList = explicitOverrides.methodFromSuperinterfaces(xAbstractStringList, add); - assertThat(addInAbstractStringList.getEnclosingElement()).isEqualTo(xCollection); + assertThat(requireNonNull(addInAbstractStringList).getEnclosingElement()) + .isEqualTo(xCollection); ExecutableElement addInNumberList = explicitOverrides.methodFromSuperinterfaces(xNumberList, add); - assertThat(addInNumberList.getEnclosingElement()).isEqualTo(xAbstractList); + assertThat(requireNonNull(addInNumberList).getEnclosingElement()).isEqualTo(xAbstractList); - ExecutableElement addInList = - explicitOverrides.methodFromSuperinterfaces(xList, add); - assertThat(addInList.getEnclosingElement()).isEqualTo(xCollection); + ExecutableElement addInList = explicitOverrides.methodFromSuperinterfaces(xList, add); + assertThat(requireNonNull(addInList).getEnclosingElement()).isEqualTo(xCollection); } - private void assertTypeListsEqual(List<TypeMirror> actual, List<TypeMirror> expected) { - assertThat(actual.size()).isEqualTo(expected.size()); - for (int i = 0; i < actual.size(); i++) { + private void assertTypeListsEqual(@Nullable List<TypeMirror> actual, List<TypeMirror> expected) { + requireNonNull(actual); + assertThat(actual).hasSize(expected.size()); + for (int i = 0; i < actual.size(); i++) { assertThat(typeUtils.isSameType(actual.get(i), expected.get(i))).isTrue(); } } @@ -552,10 +602,11 @@ public class OverridesTest { // it hard for ecj to find the boot class path. Elsewhere it is unnecessary but harmless. File rtJar = new File(StandardSystemProperty.JAVA_HOME.value() + "/lib/rt.jar"); if (rtJar.exists()) { - List<File> bootClassPath = ImmutableList.<File>builder() - .add(rtJar) - .addAll(fileManager.getLocation(StandardLocation.PLATFORM_CLASS_PATH)) - .build(); + List<File> bootClassPath = + ImmutableList.<File>builder() + .add(rtJar) + .addAll(fileManager.getLocation(StandardLocation.PLATFORM_CLASS_PATH)) + .build(); fileManager.setLocation(StandardLocation.PLATFORM_CLASS_PATH, bootClassPath); } Iterable<? extends JavaFileObject> sources = fileManager.getJavaFileObjects(dummySourceFile); @@ -583,8 +634,7 @@ public class OverridesTest { } @Override - public boolean process( - Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) { + public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) { if (roundEnv.processingOver()) { ecjCompilation.elements = processingEnv.getElementUtils(); ecjCompilation.types = processingEnv.getTypeUtils(); @@ -643,24 +693,24 @@ public class OverridesTest { private static final TypeVisitor<String, Void> ERASED_STRING_TYPE_VISITOR = new SimpleTypeVisitor6<String, Void>() { - @Override - protected String defaultAction(TypeMirror e, Void p) { - return e.toString(); - } + @Override + protected String defaultAction(TypeMirror e, Void p) { + return e.toString(); + } - @Override - public String visitArray(ArrayType t, Void p) { - return visit(t.getComponentType()) + "[]"; - } + @Override + public String visitArray(ArrayType t, Void p) { + return visit(t.getComponentType()) + "[]"; + } - @Override - public String visitDeclared(DeclaredType t, Void p) { - return MoreElements.asType(t.asElement()).getQualifiedName().toString(); - } + @Override + public String visitDeclared(DeclaredType t, Void p) { + return MoreElements.asType(t.asElement()).getQualifiedName().toString(); + } - @Override - public String visitTypeVariable(TypeVariable t, Void p) { - return visit(t.getUpperBound()); - } - }; + @Override + public String visitTypeVariable(TypeVariable t, Void p) { + return visit(t.getUpperBound()); + } + }; } diff --git a/common/src/test/java/com/google/auto/common/SimpleAnnotationMirrorTest.java b/common/src/test/java/com/google/auto/common/SimpleAnnotationMirrorTest.java index d73e1b6c..0bad83db 100644 --- a/common/src/test/java/com/google/auto/common/SimpleAnnotationMirrorTest.java +++ b/common/src/test/java/com/google/auto/common/SimpleAnnotationMirrorTest.java @@ -46,6 +46,7 @@ public class SimpleAnnotationMirrorTest { @interface MultipleValues { int value1(); + int value2(); } diff --git a/common/src/test/java/com/google/auto/common/SimpleTypeAnnotationValueTest.java b/common/src/test/java/com/google/auto/common/SimpleTypeAnnotationValueTest.java index 4fc61b51..ea85365b 100644 --- a/common/src/test/java/com/google/auto/common/SimpleTypeAnnotationValueTest.java +++ b/common/src/test/java/com/google/auto/common/SimpleTypeAnnotationValueTest.java @@ -28,6 +28,7 @@ import javax.lang.model.type.TypeMirror; import javax.lang.model.util.Elements; import javax.lang.model.util.SimpleAnnotationValueVisitor8; import javax.lang.model.util.Types; +import org.checkerframework.checker.nullness.qual.Nullable; import org.junit.Before; import org.junit.Rule; import org.junit.Test; @@ -70,18 +71,21 @@ public class SimpleTypeAnnotationValueTest { @Test public void visitorMethod() { - SimpleTypeAnnotationValue.of(objectType).accept(new SimpleAnnotationValueVisitor8<Void, Void>(){ - @Override - public Void visitType(TypeMirror typeMirror, Void aVoid) { - // do nothing, expected case - return null; - } + SimpleTypeAnnotationValue.of(objectType) + .accept( + new SimpleAnnotationValueVisitor8<@Nullable Void, @Nullable Void>() { + @Override + public @Nullable Void visitType(TypeMirror typeMirror, @Nullable Void aVoid) { + // do nothing, expected case + return null; + } - @Override - protected Void defaultAction(Object o, Void aVoid) { - throw new AssertionError(); - } - }, null); + @Override + protected @Nullable Void defaultAction(Object o, @Nullable Void aVoid) { + throw new AssertionError(); + } + }, + null); } @Test diff --git a/common/src/test/java/com/google/auto/common/SuperficialValidationTest.java b/common/src/test/java/com/google/auto/common/SuperficialValidationTest.java index 15e54fff..c9bcf778 100644 --- a/common/src/test/java/com/google/auto/common/SuperficialValidationTest.java +++ b/common/src/test/java/com/google/auto/common/SuperficialValidationTest.java @@ -35,231 +35,263 @@ import org.junit.runners.JUnit4; public class SuperficialValidationTest { @Test public void missingReturnType() { - JavaFileObject javaFileObject = JavaFileObjects.forSourceLines( - "test.TestClass", - "package test;", - "", - "abstract class TestClass {", - " abstract MissingType blah();", - "}"); + JavaFileObject javaFileObject = + JavaFileObjects.forSourceLines( + "test.TestClass", + "package test;", + "", + "abstract class TestClass {", + " abstract MissingType blah();", + "}"); assertAbout(javaSource()) .that(javaFileObject) - .processedWith(new AssertingProcessor() { - @Override void runAssertions() { - TypeElement testClassElement = - processingEnv.getElementUtils().getTypeElement("test.TestClass"); - assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse(); - } - }) + .processedWith( + new AssertingProcessor() { + @Override + void runAssertions() { + TypeElement testClassElement = + processingEnv.getElementUtils().getTypeElement("test.TestClass"); + assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse(); + } + }) .failsToCompile(); } @Test public void missingGenericReturnType() { - JavaFileObject javaFileObject = JavaFileObjects.forSourceLines( - "test.TestClass", - "package test;", - "", - "abstract class TestClass {", - " abstract MissingType<?> blah();", - "}"); + JavaFileObject javaFileObject = + JavaFileObjects.forSourceLines( + "test.TestClass", + "package test;", + "", + "abstract class TestClass {", + " abstract MissingType<?> blah();", + "}"); assertAbout(javaSource()) .that(javaFileObject) - .processedWith(new AssertingProcessor() { - @Override void runAssertions() { - TypeElement testClassElement = - processingEnv.getElementUtils().getTypeElement("test.TestClass"); - assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse(); - } - }) + .processedWith( + new AssertingProcessor() { + @Override + void runAssertions() { + TypeElement testClassElement = + processingEnv.getElementUtils().getTypeElement("test.TestClass"); + assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse(); + } + }) .failsToCompile(); } @Test public void missingReturnTypeTypeParameter() { - JavaFileObject javaFileObject = JavaFileObjects.forSourceLines( - "test.TestClass", - "package test;", - "", - "import java.util.Map;", - "import java.util.Set;", - "", - "abstract class TestClass {", - " abstract Map<Set<?>, MissingType<?>> blah();", - "}"); + JavaFileObject javaFileObject = + JavaFileObjects.forSourceLines( + "test.TestClass", + "package test;", + "", + "import java.util.Map;", + "import java.util.Set;", + "", + "abstract class TestClass {", + " abstract Map<Set<?>, MissingType<?>> blah();", + "}"); assertAbout(javaSource()) .that(javaFileObject) - .processedWith(new AssertingProcessor() { - @Override void runAssertions() { - TypeElement testClassElement = - processingEnv.getElementUtils().getTypeElement("test.TestClass"); - assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse(); - } - }) + .processedWith( + new AssertingProcessor() { + @Override + void runAssertions() { + TypeElement testClassElement = + processingEnv.getElementUtils().getTypeElement("test.TestClass"); + assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse(); + } + }) .failsToCompile(); } @Test public void missingTypeParameter() { - JavaFileObject javaFileObject = JavaFileObjects.forSourceLines( - "test.TestClass", - "package test;", - "", - "class TestClass<T extends MissingType> {}"); + JavaFileObject javaFileObject = + JavaFileObjects.forSourceLines( + "test.TestClass", // + "package test;", + "", + "class TestClass<T extends MissingType> {}"); assertAbout(javaSource()) .that(javaFileObject) - .processedWith(new AssertingProcessor() { - @Override void runAssertions() { - TypeElement testClassElement = - processingEnv.getElementUtils().getTypeElement("test.TestClass"); - assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse(); - } - }) + .processedWith( + new AssertingProcessor() { + @Override + void runAssertions() { + TypeElement testClassElement = + processingEnv.getElementUtils().getTypeElement("test.TestClass"); + assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse(); + } + }) .failsToCompile(); } @Test public void missingParameterType() { - JavaFileObject javaFileObject = JavaFileObjects.forSourceLines( - "test.TestClass", - "package test;", - "", - "abstract class TestClass {", - " abstract void foo(MissingType x);", - "}"); + JavaFileObject javaFileObject = + JavaFileObjects.forSourceLines( + "test.TestClass", + "package test;", + "", + "abstract class TestClass {", + " abstract void foo(MissingType x);", + "}"); assertAbout(javaSource()) .that(javaFileObject) - .processedWith(new AssertingProcessor() { - @Override void runAssertions() { - TypeElement testClassElement = - processingEnv.getElementUtils().getTypeElement("test.TestClass"); - assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse(); - } - }) + .processedWith( + new AssertingProcessor() { + @Override + void runAssertions() { + TypeElement testClassElement = + processingEnv.getElementUtils().getTypeElement("test.TestClass"); + assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse(); + } + }) .failsToCompile(); } @Test public void missingAnnotation() { - JavaFileObject javaFileObject = JavaFileObjects.forSourceLines( - "test.TestClass", - "package test;", - "", - "@MissingAnnotation", - "class TestClass {}"); + JavaFileObject javaFileObject = + JavaFileObjects.forSourceLines( + "test.TestClass", // + "package test;", + "", + "@MissingAnnotation", + "class TestClass {}"); assertAbout(javaSource()) .that(javaFileObject) - .processedWith(new AssertingProcessor() { - @Override void runAssertions() { - TypeElement testClassElement = - processingEnv.getElementUtils().getTypeElement("test.TestClass"); - assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse(); - } - }) + .processedWith( + new AssertingProcessor() { + @Override + void runAssertions() { + TypeElement testClassElement = + processingEnv.getElementUtils().getTypeElement("test.TestClass"); + assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse(); + } + }) .failsToCompile(); } @Test public void handlesRecursiveTypeParams() { - JavaFileObject javaFileObject = JavaFileObjects.forSourceLines( - "test.TestClass", - "package test;", - "", - "class TestClass<T extends Comparable<T>> {}"); + JavaFileObject javaFileObject = + JavaFileObjects.forSourceLines( + "test.TestClass", // + "package test;", + "", + "class TestClass<T extends Comparable<T>> {}"); assertAbout(javaSource()) .that(javaFileObject) - .processedWith(new AssertingProcessor() { - @Override void runAssertions() { - TypeElement testClassElement = - processingEnv.getElementUtils().getTypeElement("test.TestClass"); - assertThat(SuperficialValidation.validateElement(testClassElement)).isTrue(); - } - }) + .processedWith( + new AssertingProcessor() { + @Override + void runAssertions() { + TypeElement testClassElement = + processingEnv.getElementUtils().getTypeElement("test.TestClass"); + assertThat(SuperficialValidation.validateElement(testClassElement)).isTrue(); + } + }) .compilesWithoutError(); } @Test public void handlesRecursiveType() { - JavaFileObject javaFileObject = JavaFileObjects.forSourceLines( - "test.TestClass", - "package test;", - "", - "abstract class TestClass {", - " abstract TestClass foo(TestClass x);", - "}"); + JavaFileObject javaFileObject = + JavaFileObjects.forSourceLines( + "test.TestClass", + "package test;", + "", + "abstract class TestClass {", + " abstract TestClass foo(TestClass x);", + "}"); assertAbout(javaSource()) .that(javaFileObject) - .processedWith(new AssertingProcessor() { - @Override void runAssertions() { - TypeElement testClassElement = - processingEnv.getElementUtils().getTypeElement("test.TestClass"); - assertThat(SuperficialValidation.validateElement(testClassElement)).isTrue(); - } - }) + .processedWith( + new AssertingProcessor() { + @Override + void runAssertions() { + TypeElement testClassElement = + processingEnv.getElementUtils().getTypeElement("test.TestClass"); + assertThat(SuperficialValidation.validateElement(testClassElement)).isTrue(); + } + }) .compilesWithoutError(); } @Test public void missingWildcardBound() { - JavaFileObject javaFileObject = JavaFileObjects.forSourceLines( - "test.TestClass", - "package test;", - "", - "import java.util.Set;", - "", - "class TestClass {", - " Set<? extends MissingType> extendsTest() {", - " return null;", - " }", - "", - " Set<? super MissingType> superTest() {", - " return null;", - " }", - "}"); + JavaFileObject javaFileObject = + JavaFileObjects.forSourceLines( + "test.TestClass", + "package test;", + "", + "import java.util.Set;", + "", + "class TestClass {", + " Set<? extends MissingType> extendsTest() {", + " return null;", + " }", + "", + " Set<? super MissingType> superTest() {", + " return null;", + " }", + "}"); assertAbout(javaSource()) .that(javaFileObject) - .processedWith(new AssertingProcessor() { - @Override void runAssertions() { - TypeElement testClassElement = - processingEnv.getElementUtils().getTypeElement("test.TestClass"); - assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse(); - } - }) + .processedWith( + new AssertingProcessor() { + @Override + void runAssertions() { + TypeElement testClassElement = + processingEnv.getElementUtils().getTypeElement("test.TestClass"); + assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse(); + } + }) .failsToCompile(); } @Test public void missingIntersection() { - JavaFileObject javaFileObject = JavaFileObjects.forSourceLines( - "test.TestClass", - "package test;", - "", - "class TestClass<T extends Number & Missing> {}"); + JavaFileObject javaFileObject = + JavaFileObjects.forSourceLines( + "test.TestClass", + "package test;", + "", + "class TestClass<T extends Number & Missing> {}"); assertAbout(javaSource()) .that(javaFileObject) - .processedWith(new AssertingProcessor() { - @Override void runAssertions() { - TypeElement testClassElement = - processingEnv.getElementUtils().getTypeElement("test.TestClass"); - assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse(); - } - }) + .processedWith( + new AssertingProcessor() { + @Override + void runAssertions() { + TypeElement testClassElement = + processingEnv.getElementUtils().getTypeElement("test.TestClass"); + assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse(); + } + }) .failsToCompile(); } @Test public void invalidAnnotationValue() { - JavaFileObject javaFileObject = JavaFileObjects.forSourceLines("test.Outer", - "package test;", - "", - "final class Outer {", - " @interface TestAnnotation {", - " Class[] classes();", - " }", - "", - " @TestAnnotation(classes = Foo)", - " static class TestClass {}", - "}"); + JavaFileObject javaFileObject = + JavaFileObjects.forSourceLines( + "test.Outer", + "package test;", + "", + "final class Outer {", + " @interface TestAnnotation {", + " Class[] classes();", + " }", + "", + " @TestAnnotation(classes = Foo)", + " static class TestClass {}", + "}"); assertAbout(javaSource()) .that(javaFileObject) .processedWith( diff --git a/common/src/test/java/com/google/auto/common/VisibilityTest.java b/common/src/test/java/com/google/auto/common/VisibilityTest.java index 6a80b7af..fc5e630b 100644 --- a/common/src/test/java/com/google/auto/common/VisibilityTest.java +++ b/common/src/test/java/com/google/auto/common/VisibilityTest.java @@ -39,9 +39,10 @@ public class VisibilityTest { public void packageVisibility() { assertThat(Visibility.ofElement(compilation.getElements().getPackageElement("java.lang"))) .isEqualTo(PUBLIC); - assertThat(Visibility.ofElement( - compilation.getElements().getPackageElement("com.google.auto.common"))) - .isEqualTo(PUBLIC); + assertThat( + Visibility.ofElement( + compilation.getElements().getPackageElement("com.google.auto.common"))) + .isEqualTo(PUBLIC); } @Test @@ -61,32 +62,44 @@ public class VisibilityTest { @SuppressWarnings("unused") public static class PublicClass { public static class NestedPublicClass {} + protected static class NestedProtectedClass {} + static class NestedDefaultClass {} + private static class NestedPrivateClass {} } @SuppressWarnings("unused") protected static class ProtectedClass { public static class NestedPublicClass {} + protected static class NestedProtectedClass {} + static class NestedDefaultClass {} + private static class NestedPrivateClass {} } @SuppressWarnings("unused") static class DefaultClass { public static class NestedPublicClass {} + protected static class NestedProtectedClass {} + static class NestedDefaultClass {} + private static class NestedPrivateClass {} } @SuppressWarnings("unused") private static class PrivateClass { public static class NestedPublicClass {} + protected static class NestedProtectedClass {} + static class NestedDefaultClass {} + private static class NestedPrivateClass {} } @@ -94,21 +107,25 @@ public class VisibilityTest { public void classVisibility() { assertThat(Visibility.ofElement(compilation.getElements().getTypeElement("java.util.Map"))) .isEqualTo(PUBLIC); - assertThat(Visibility.ofElement( - compilation.getElements().getTypeElement("java.util.Map.Entry"))) - .isEqualTo(PUBLIC); - assertThat(Visibility.ofElement( - compilation.getElements().getTypeElement(PublicClass.class.getCanonicalName()))) - .isEqualTo(PUBLIC); - assertThat(Visibility.ofElement( - compilation.getElements().getTypeElement(ProtectedClass.class.getCanonicalName()))) - .isEqualTo(PROTECTED); - assertThat(Visibility.ofElement( - compilation.getElements().getTypeElement(DefaultClass.class.getCanonicalName()))) - .isEqualTo(DEFAULT); - assertThat(Visibility.ofElement( - compilation.getElements().getTypeElement(PrivateClass.class.getCanonicalName()))) - .isEqualTo(PRIVATE); + assertThat( + Visibility.ofElement(compilation.getElements().getTypeElement("java.util.Map.Entry"))) + .isEqualTo(PUBLIC); + assertThat( + Visibility.ofElement( + compilation.getElements().getTypeElement(PublicClass.class.getCanonicalName()))) + .isEqualTo(PUBLIC); + assertThat( + Visibility.ofElement( + compilation.getElements().getTypeElement(ProtectedClass.class.getCanonicalName()))) + .isEqualTo(PROTECTED); + assertThat( + Visibility.ofElement( + compilation.getElements().getTypeElement(DefaultClass.class.getCanonicalName()))) + .isEqualTo(DEFAULT); + assertThat( + Visibility.ofElement( + compilation.getElements().getTypeElement(PrivateClass.class.getCanonicalName()))) + .isEqualTo(PRIVATE); } @Test @@ -118,14 +135,11 @@ public class VisibilityTest { assertThat(effectiveVisiblityOfClass(DefaultClass.class)).isEqualTo(DEFAULT); assertThat(effectiveVisiblityOfClass(PrivateClass.class)).isEqualTo(PRIVATE); - assertThat(effectiveVisiblityOfClass(PublicClass.NestedPublicClass.class)) - .isEqualTo(PUBLIC); + assertThat(effectiveVisiblityOfClass(PublicClass.NestedPublicClass.class)).isEqualTo(PUBLIC); assertThat(effectiveVisiblityOfClass(PublicClass.NestedProtectedClass.class)) .isEqualTo(PROTECTED); - assertThat(effectiveVisiblityOfClass(PublicClass.NestedDefaultClass.class)) - .isEqualTo(DEFAULT); - assertThat(effectiveVisiblityOfClass(PublicClass.NestedPrivateClass.class)) - .isEqualTo(PRIVATE); + assertThat(effectiveVisiblityOfClass(PublicClass.NestedDefaultClass.class)).isEqualTo(DEFAULT); + assertThat(effectiveVisiblityOfClass(PublicClass.NestedPrivateClass.class)).isEqualTo(PRIVATE); assertThat(effectiveVisiblityOfClass(ProtectedClass.NestedPublicClass.class)) .isEqualTo(PROTECTED); @@ -136,23 +150,17 @@ public class VisibilityTest { assertThat(effectiveVisiblityOfClass(ProtectedClass.NestedPrivateClass.class)) .isEqualTo(PRIVATE); - assertThat(effectiveVisiblityOfClass(DefaultClass.NestedPublicClass.class)) - .isEqualTo(DEFAULT); + assertThat(effectiveVisiblityOfClass(DefaultClass.NestedPublicClass.class)).isEqualTo(DEFAULT); assertThat(effectiveVisiblityOfClass(DefaultClass.NestedProtectedClass.class)) .isEqualTo(DEFAULT); - assertThat(effectiveVisiblityOfClass(DefaultClass.NestedDefaultClass.class)) - .isEqualTo(DEFAULT); - assertThat(effectiveVisiblityOfClass(DefaultClass.NestedPrivateClass.class)) - .isEqualTo(PRIVATE); + assertThat(effectiveVisiblityOfClass(DefaultClass.NestedDefaultClass.class)).isEqualTo(DEFAULT); + assertThat(effectiveVisiblityOfClass(DefaultClass.NestedPrivateClass.class)).isEqualTo(PRIVATE); - assertThat(effectiveVisiblityOfClass(PrivateClass.NestedPublicClass.class)) - .isEqualTo(PRIVATE); + assertThat(effectiveVisiblityOfClass(PrivateClass.NestedPublicClass.class)).isEqualTo(PRIVATE); assertThat(effectiveVisiblityOfClass(PrivateClass.NestedProtectedClass.class)) .isEqualTo(PRIVATE); - assertThat(effectiveVisiblityOfClass(PrivateClass.NestedDefaultClass.class)) - .isEqualTo(PRIVATE); - assertThat(effectiveVisiblityOfClass(PrivateClass.NestedPrivateClass.class)) - .isEqualTo(PRIVATE); + assertThat(effectiveVisiblityOfClass(PrivateClass.NestedDefaultClass.class)).isEqualTo(PRIVATE); + assertThat(effectiveVisiblityOfClass(PrivateClass.NestedPrivateClass.class)).isEqualTo(PRIVATE); } private Visibility effectiveVisiblityOfClass(Class<?> clazz) { |