@Test public void testOptimisticFactoryCreationForSingleton_shouldFailTheBuild_whenThereIsNoDefaultConstructor() { JavaFileObject source = JavaFileObjects.forSourceString("test.TestOptimisticFactoryCreationForSingleton", Joiner.on('\n').join(// "package test;", // "import javax.inject.Inject;", // "import javax.inject.Singleton;", // "@Singleton", // "public class TestOptimisticFactoryCreationForSingleton {", // " TestOptimisticFactoryCreationForSingleton(int a) { }", // "}")); assert_().about(javaSource()) .that(source) .processedWith(ProcessorTestUtilities.factoryProcessorsFailingOnNonInjectableClasses()) .failsToCompile(); }
@Test public void testPrivateConstructor() { JavaFileObject source = JavaFileObjects.forSourceString("test.TestPrivateConstructor", Joiner.on('\n').join(// "package test;", // "import javax.inject.Inject;", // "public class TestPrivateConstructor {", // " @Inject private TestPrivateConstructor() {}", // "}" // )); assert_().about(javaSource()) .that(source) .processedWith(ProcessorTestUtilities.factoryProcessors()) .failsToCompile() .withErrorContaining("@Inject constructors must not be private in class test.TestPrivateConstructor"); }
@Test public void testRelaxedFactoryCreationForInjectedField_shouldFail_WhenFieldIsPrivate() { JavaFileObject source = JavaFileObjects.forSourceString("test.TestRelaxedFactoryCreationForInjectField", Joiner.on('\n').join(// "package test;", // "import javax.inject.Inject;", // "public class TestRelaxedFactoryCreationForInjectField {", // " @Inject private Foo foo;", // "}", // " class Foo {}")); assert_().about(javaSource()) .that(source) .processedWith(ProcessorTestUtilities.factoryAndMemberInjectorProcessors()) .failsToCompile() .withErrorContaining("@Inject annotated fields must be non private : test.TestRelaxedFactoryCreationForInjectField#foo"); }
@Test public void testAbstractClassWithInjectedConstructor() { JavaFileObject source = JavaFileObjects.forSourceString("test.TestInvalidClassConstructor", Joiner.on('\n').join(// "package test;", // "import javax.inject.Inject;", // "public abstract class TestInvalidClassConstructor {", // " @Inject public TestInvalidClassConstructor() {}", // "}" // )); assert_().about(javaSource()) .that(source) .processedWith(ProcessorTestUtilities.factoryProcessors()) .failsToCompile() .withErrorContaining("The class test.TestInvalidClassConstructor is abstract or private. It cannot have an injected constructor."); }
@Test public void testInjectedMethod_shouldNotFailTheBuild_whenMethodIsPublicButAnnotated() { JavaFileObject source = JavaFileObjects.forSourceString("test.TestWarningVisibleInjectedMethod", Joiner.on('\n').join(// "package test;", // "import javax.inject.Inject;", // "import javax.inject.Singleton;", // "public class TestWarningVisibleInjectedMethod {", // " @SuppressWarnings(\"visible\")", // " @Inject public void init() {}", // "}")); assert_().about(javaSource()) .that(source) .processedWith(memberInjectorProcessorsFailingWhenMethodIsNotPackageVisible()) .compilesWithoutError(); }
protected void assertThatCompileWithoutErrorButNoFactoryIsCreated(JavaFileObject source, String noFactoryPackageName, String noFactoryClass) { try { assert_().about(javaSource()) .that(source) .processedWith(ProcessorTestUtilities.factoryAndMemberInjectorProcessors()) .compilesWithoutError() .and() .generatesFileNamed(StandardLocation.locationFor("CLASS_OUTPUT"), "test", noFactoryClass + "$$Factory.class"); fail("A factory was created when it shouldn't."); } catch (AssertionError e) { assertThat(e.getMessage(), containsString( String.format("generated the file named \"%s$$Factory.class\" in package \"%s\";", noFactoryClass, noFactoryPackageName))); } } }
@Test public void testRelaxedFactoryCreationForInjectedMethod_shouldFail_WhenMethodIsPrivate() { JavaFileObject source = JavaFileObjects.forSourceString("test.TestRelaxedFactoryCreationForInjectMethod", Joiner.on('\n').join(// "package test;", // "import javax.inject.Inject;", // "public class TestRelaxedFactoryCreationForInjectMethod {", // " @Inject private void m(Foo foo) {}", // "}", // " class Foo {}")); assert_().about(javaSource()) .that(source) .processedWith(ProcessorTestUtilities.factoryAndMemberInjectorProcessors()) .failsToCompile() .withErrorContaining("@Inject annotated methods must not be private : test.TestRelaxedFactoryCreationForInjectMethod#m"); }
@Test public void testOptimisticFactoryCreationWithInjectedMembers_shouldFailTheBuild_whenThereIsNoDefaultConstructor() { JavaFileObject source = JavaFileObjects.forSourceString("test.TestOptimisticFactoryCreationForSingleton", Joiner.on('\n').join(// "package test;", // "import javax.inject.Inject;", // "public class TestOptimisticFactoryCreationForSingleton {", // " @Inject String s;", // " TestOptimisticFactoryCreationForSingleton(int a) { }", // "}")); assert_().about(javaSource()) .that(source) .processedWith(ProcessorTestUtilities.factoryProcessorsFailingOnNonInjectableClasses()) .failsToCompile(); }
@Test public void testInjectedMethod_shouldFailTheBuild_whenMethodIsPublic() { JavaFileObject source = JavaFileObjects.forSourceString("test.TestWarningVisibleInjectedMethod", Joiner.on('\n').join(// "package test;", // "import javax.inject.Inject;", // "import javax.inject.Singleton;", // "public class TestWarningVisibleInjectedMethod {", // " @Inject public void init() {}", // "}")); assert_().about(javaSource()) .that(source) .processedWith(memberInjectorProcessorsFailingWhenMethodIsNotPackageVisible()) .failsToCompile(); }
@Test public void testInjectedMethod_shouldFailTheBuild_whenMethodIsProtected() { JavaFileObject source = JavaFileObjects.forSourceString("test.TestWarningVisibleInjectedMethod", Joiner.on('\n').join(// "package test;", // "import javax.inject.Inject;", // "import javax.inject.Singleton;", // "public class TestWarningVisibleInjectedMethod {", // " @Inject protected void init() {}", // "}")); assert_().about(javaSource()) .that(source) .processedWith(memberInjectorProcessorsFailingWhenMethodIsNotPackageVisible()) .failsToCompile(); }
@Test public void correct() { JavaFileObject file = JavaFileObjects .forResource("inputs/RangeVariableMethodAnnotationTest/Correct.java"); Truth.assert_().about(JavaSourceSubjectFactory.javaSource()) .that(file) .processedWith(allProcessors) .compilesWithoutError() .and() .generatesSources(JavaFileObjects .forResource("outputs/RangeVariableMethodAnnotationTest/Correct.java")); } }
@Test public void buildsAndFixesInitialValue() { JavaFileObject file = JavaFileObjects .forResource("inputs/ColorListVariableMethodAnnotationTest/FixesInitialValue.java"); Truth.assert_().about(JavaSourceSubjectFactory.javaSource()) .that(file) .processedWith(allProcessors) .compilesWithoutError() .and() .generatesSources(JavaFileObjects .forResource("outputs/ColorListVariableMethodAnnotationTest/FixesInitialValue.java")); } }
@Test public void buildsCorrectFile() { JavaFileObject file = JavaFileObjects .forResource("inputs/RemixerAnnotationProcessorTest/Correct.java"); Truth.assert_().about(JavaSourceSubjectFactory.javaSource()) .that(file) .processedWith(allProcessors) .compilesWithoutError() .and() .generatesSources(JavaFileObjects .forResource("outputs/RemixerAnnotationProcessorTest/Correct.java")); } }
@Test public void buildsAndFixesInitialValue() { JavaFileObject file = JavaFileObjects .forResource("inputs/StringListVariableMethodAnnotationTest/FixesInitialValue.java"); Truth.assert_().about(JavaSourceSubjectFactory.javaSource()) .that(file) .processedWith(allProcessors) .compilesWithoutError() .and() .generatesSources(JavaFileObjects .forResource("outputs/StringListVariableMethodAnnotationTest/FixesInitialValue.java")); } }
@Test public void buildsCorrect() { JavaFileObject file = JavaFileObjects .forResource("inputs/BooleanVariableMethodAnnotationTest/Correct.java"); Truth.assert_().about(JavaSourceSubjectFactory.javaSource()) .that(file) .processedWith(allProcessors) .compilesWithoutError() .and() .generatesSources(JavaFileObjects .forResource("outputs/BooleanVariableMethodAnnotationTest/Correct.java")); } }
@Test public void buildsCorrect() { JavaFileObject file = JavaFileObjects .forResource("inputs/StringVariableMethodAnnotationTest/Correct.java"); Truth.assert_().about(JavaSourceSubjectFactory.javaSource()) .that(file) .processedWith(allProcessors) .compilesWithoutError() .and() .generatesSources(JavaFileObjects .forResource("outputs/StringVariableMethodAnnotationTest/Correct.java")); } }
@Test public void buildsAndFixesInitialValue() { JavaFileObject file = JavaFileObjects .forResource("inputs/NumberListVariableMethodAnnotationTest/FixesInitialValue.java"); Truth.assert_().about(JavaSourceSubjectFactory.javaSource()) .that(file) .processedWith(allProcessors) .compilesWithoutError() .and() .generatesSources(JavaFileObjects .forResource("outputs/NumberListVariableMethodAnnotationTest/FixesInitialValue.java")); } }
@Test public void failsOnMethodWithMultipleParameters() { JavaFileObject file = JavaFileObjects .forResource("inputs/RemixerAnnotationProcessorTest/MethodWithMultipleParameters.java"); Truth.assert_().about(JavaSourceSubjectFactory.javaSource()) .that(file) .processedWith(allProcessors) .failsToCompile() .withErrorContaining("This method must have exactly 1 parameter(s)") .in(file); }
@Test public void failsEmptyList() { JavaFileObject file = JavaFileObjects .forResource("inputs/NumberListVariableMethodAnnotationTest/EmptyList.java"); Truth.assert_().about(JavaSourceSubjectFactory.javaSource()) .that(file) .processedWith(allProcessors) .failsToCompile() .withErrorContaining("List of limited to values cannot be empty") .in(file); }
@Test public void failsMethodWithWrongParameter() { JavaFileObject file = JavaFileObjects .forResource( "inputs/NumberListVariableMethodAnnotationTest/MethodWithWrongParameter.java"); Truth.assert_().about(JavaSourceSubjectFactory.javaSource()) .that(file) .processedWith(allProcessors) .failsToCompile() .withErrorContaining("Float") .in(file); }