| /* |
| * Copyright (C) 2020 The Dagger Authors. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package dagger.internal.codegen; |
| |
| import androidx.room.compiler.processing.util.Source; |
| import com.google.common.collect.ImmutableCollection; |
| import dagger.testing.compile.CompilerTests; |
| import org.junit.Test; |
| import org.junit.runner.RunWith; |
| import org.junit.runners.Parameterized; |
| import org.junit.runners.Parameterized.Parameters; |
| |
| @RunWith(Parameterized.class) |
| public class AssistedFactoryErrorsTest { |
| @Parameters(name = "{0}") |
| public static ImmutableCollection<Object[]> parameters() { |
| return CompilerMode.TEST_PARAMETERS; |
| } |
| |
| private final CompilerMode compilerMode; |
| |
| public AssistedFactoryErrorsTest(CompilerMode compilerMode) { |
| this.compilerMode = compilerMode; |
| } |
| |
| @Test |
| public void testFactoryNotAbstract() { |
| Source foo = |
| CompilerTests.javaSource( |
| "test.Factory", |
| "package test;", |
| "", |
| "import dagger.assisted.AssistedFactory;", |
| "", |
| "@AssistedFactory class Factory {}"); |
| |
| CompilerTests.daggerCompiler(foo) |
| .withProcessingOptions(compilerMode.processorOptions()) |
| .compile( |
| subject -> { |
| subject.hasErrorCount(1); |
| subject.hasErrorContaining( |
| "The @AssistedFactory-annotated type must be either an abstract class or " |
| + "interface."); |
| }); |
| } |
| |
| @Test |
| public void testNestedFactoryNotStatic() { |
| Source foo = |
| CompilerTests.javaSource( |
| "test.Foo", |
| "package test;", |
| "", |
| "import dagger.assisted.Assisted;", |
| "import dagger.assisted.AssistedInject;", |
| "import dagger.assisted.AssistedFactory;", |
| "", |
| "class Foo {", |
| " @AssistedInject", |
| " Foo(@Assisted int i) {}", |
| "", |
| " @AssistedFactory", |
| " abstract class Factory {", |
| " abstract Foo create(int i);", |
| " }", |
| "}"); |
| |
| CompilerTests.daggerCompiler(foo) |
| .withProcessingOptions(compilerMode.processorOptions()) |
| .compile( |
| subject -> { |
| subject.hasErrorCount(1); |
| subject.hasErrorContaining("Nested @AssistedFactory-annotated types must be static."); |
| }); |
| } |
| |
| @Test |
| public void testFactoryMissingAbstractMethod() { |
| Source factory = |
| CompilerTests.javaSource( |
| "test.Factory", |
| "package test;", |
| "", |
| "import dagger.assisted.AssistedFactory;", |
| "", |
| "@AssistedFactory interface Factory {}"); |
| |
| CompilerTests.daggerCompiler(factory) |
| .withProcessingOptions(compilerMode.processorOptions()) |
| .compile( |
| subject -> { |
| subject.hasErrorCount(1); |
| subject.hasErrorContaining( |
| "The @AssistedFactory-annotated type is missing an abstract, non-default method " |
| + "whose return type matches the assisted injection type."); |
| }); |
| } |
| |
| @Test |
| public void testFactoryReturnsNonDeclaredType() { |
| Source noInject = |
| CompilerTests.javaSource( |
| "test.NoInject", |
| "package test;", |
| "", |
| "final class NoInject {}"); |
| |
| Source noAssistedParam = |
| CompilerTests.javaSource( |
| "test.NoAssistedParam", |
| "package test;", |
| "", |
| "import dagger.assisted.AssistedInject;", |
| "", |
| "final class NoAssistedParam {", |
| " @AssistedInject NoAssistedParam() {}", |
| "}"); |
| |
| Source factory = |
| CompilerTests.javaSource( |
| "test.Factory", |
| "package test;", |
| "", |
| "import dagger.assisted.AssistedFactory;", |
| "", |
| "@AssistedFactory", |
| "interface Factory<T> {", |
| " int createInt();", // Fails return type not @AssistedInject |
| "", |
| " NoInject createNoInject();", // Fails return type not @AssistedInject |
| "", |
| " NoAssistedParam createNoAssistedParam();", // Succeeds |
| "", |
| " T createT();", // Fails return type not @AssistedInject |
| "}"); |
| |
| CompilerTests.daggerCompiler(factory, noInject, noAssistedParam) |
| .withProcessingOptions(compilerMode.processorOptions()) |
| .compile( |
| subject -> { |
| subject.hasErrorCount(4); |
| subject.hasErrorContaining( |
| "The @AssistedFactory-annotated type should contain a single abstract, " |
| + "non-default method but found multiple: [" |
| + "test.Factory.createInt(), " |
| + "test.Factory.createNoInject(), " |
| + "test.Factory.createNoAssistedParam(), " |
| + "test.Factory.createT()" |
| + "]") |
| .onSource(factory) |
| .onLine(6); |
| subject.hasErrorContaining( |
| "Invalid return type: int. " |
| + "An assisted factory's abstract method must return a type with an " |
| + "@AssistedInject-annotated constructor.") |
| .onSource(factory) |
| .onLine(7); |
| subject.hasErrorContaining( |
| "Invalid return type: test.NoInject. " |
| + "An assisted factory's abstract method must return a type with an " |
| + "@AssistedInject-annotated constructor.") |
| .onSource(factory) |
| .onLine(9); |
| subject.hasErrorContaining( |
| "Invalid return type: T. " |
| + "An assisted factory's abstract method must return a type with an " |
| + "@AssistedInject-annotated constructor.") |
| .onSource(factory) |
| .onLine(13); |
| }); |
| } |
| |
| @Test |
| public void testFactoryMultipleAbstractMethods() { |
| Source foo = |
| CompilerTests.javaSource( |
| "test.Foo", |
| "package test;", |
| "", |
| "import dagger.assisted.Assisted;", |
| "import dagger.assisted.AssistedInject;", |
| "", |
| "class Foo {", |
| " @AssistedInject Foo(@Assisted int i) {}", |
| "}"); |
| |
| Source fooFactoryInterface = |
| CompilerTests.javaSource( |
| "test.FooFactoryInterface", |
| "package test;", |
| "", |
| "interface FooFactoryInterface {", |
| " Foo createFoo1(int i);", |
| "}"); |
| |
| Source fooFactory = |
| CompilerTests.javaSource( |
| "test.FooFactory", |
| "package test;", |
| "", |
| "import dagger.assisted.AssistedFactory;", |
| "", |
| "@AssistedFactory", |
| "interface FooFactory extends FooFactoryInterface {", |
| " Foo createFoo2(int i);", |
| "", |
| " Foo createFoo3(int i);", |
| "}"); |
| |
| CompilerTests.daggerCompiler(foo, fooFactory, fooFactoryInterface) |
| .withProcessingOptions(compilerMode.processorOptions()) |
| .compile( |
| subject -> { |
| subject.hasErrorCount(1); |
| subject.hasErrorContaining( |
| "The @AssistedFactory-annotated type should contain a single abstract, " |
| + "non-default method but found multiple: [" |
| + "test.FooFactoryInterface.createFoo1(int), " |
| + "test.FooFactory.createFoo2(int), " |
| + "test.FooFactory.createFoo3(int)" |
| + "]"); |
| }); |
| } |
| |
| @Test |
| public void testFactoryMismatchingParameter() { |
| Source foo = |
| CompilerTests.javaSource( |
| "test.Foo", |
| "package test;", |
| "", |
| "import dagger.assisted.Assisted;", |
| "import dagger.assisted.AssistedInject;", |
| "", |
| "class Foo {", |
| " @AssistedInject Foo(@Assisted int i) {}", |
| "}"); |
| |
| Source fooFactory = |
| CompilerTests.javaSource( |
| "test.FooFactory", |
| "package test;", |
| "", |
| "import dagger.assisted.AssistedFactory;", |
| "", |
| "@AssistedFactory", |
| "interface FooFactory {", |
| " Foo create(String i);", |
| "}"); |
| |
| CompilerTests.daggerCompiler(foo, fooFactory) |
| .withProcessingOptions(compilerMode.processorOptions()) |
| .compile( |
| subject -> { |
| subject.hasErrorCount(1); |
| subject.hasErrorContaining( |
| "The parameters in the factory method must match the @Assisted parameters in " |
| + "test.Foo."); |
| subject.hasErrorContaining(" Actual: test.FooFactory#create(java.lang.String)"); |
| subject.hasErrorContaining("Expected: test.FooFactory#create(int)"); |
| }); |
| } |
| |
| @Test |
| public void testFactoryMismatchingGenericParameter() { |
| Source foo = |
| CompilerTests.javaSource( |
| "test.Foo", |
| "package test;", |
| "", |
| "import dagger.assisted.Assisted;", |
| "import dagger.assisted.AssistedInject;", |
| "", |
| "class Foo<T> {", |
| " @AssistedInject Foo(@Assisted T t) {}", |
| "}"); |
| |
| Source fooFactory = |
| CompilerTests.javaSource( |
| "test.FooFactory", |
| "package test;", |
| "", |
| "import dagger.assisted.AssistedFactory;", |
| "", |
| "@AssistedFactory", |
| "interface FooFactory<T> {", |
| " Foo<T> create(String str);", |
| "}"); |
| |
| CompilerTests.daggerCompiler(foo, fooFactory) |
| .withProcessingOptions(compilerMode.processorOptions()) |
| .compile( |
| subject -> { |
| subject.hasErrorCount(1); |
| subject.hasErrorContaining( |
| "The parameters in the factory method must match the @Assisted parameters in " |
| + "test.Foo<T>."); |
| subject.hasErrorContaining(" Actual: test.FooFactory#create(java.lang.String)"); |
| subject.hasErrorContaining("Expected: test.FooFactory#create(T)"); |
| }); |
| } |
| |
| @Test |
| public void testFactoryDuplicateGenericParameter() { |
| Source foo = |
| CompilerTests.javaSource( |
| "test.Foo", |
| "package test;", |
| "", |
| "import dagger.assisted.Assisted;", |
| "import dagger.assisted.AssistedInject;", |
| "", |
| "class Foo<T> {", |
| " @AssistedInject Foo(@Assisted String str, @Assisted T t) {}", |
| "}"); |
| |
| Source fooFactory = |
| CompilerTests.javaSource( |
| "test.FooFactory", |
| "package test;", |
| "", |
| "import dagger.assisted.AssistedFactory;", |
| "", |
| "@AssistedFactory", |
| "interface FooFactory {", |
| " Foo<String> create(String str1, String str2);", |
| "}"); |
| |
| CompilerTests.daggerCompiler(foo, fooFactory) |
| .withProcessingOptions(compilerMode.processorOptions()) |
| .compile( |
| subject -> { |
| subject.hasErrorCount(1); |
| subject.hasErrorContaining( |
| "@AssistedFactory method has duplicate @Assisted types: " |
| + "@Assisted java.lang.String"); |
| }); |
| } |
| |
| @Test |
| public void testAssistedInjectionRequest() { |
| Source foo = |
| CompilerTests.javaSource( |
| "test.Foo", |
| "package test;", |
| "", |
| "import dagger.assisted.Assisted;", |
| "import dagger.assisted.AssistedInject;", |
| "", |
| "class Foo {", |
| " @AssistedInject Foo(@Assisted String str) {}", |
| "}"); |
| |
| Source bar = |
| CompilerTests.javaSource( |
| "test.Bar", |
| "package test;", |
| "", |
| "import javax.inject.Inject;", |
| "import javax.inject.Provider;", |
| "", |
| "class Bar {", |
| " @Inject", |
| " Bar(Foo foo, Provider<Foo> fooProvider) {}", |
| "}"); |
| |
| Source module = |
| CompilerTests.javaSource( |
| "test.FooModule", |
| "package test;", |
| "", |
| "import dagger.Module;", |
| "import dagger.Provides;", |
| "import javax.inject.Provider;", |
| "", |
| "@Module", |
| "class FooModule {", |
| " @Provides", |
| " static int provideInt(Foo foo, Provider<Foo> fooProvider) {", |
| " return 0;", |
| " }", |
| "}"); |
| |
| Source component = |
| CompilerTests.javaSource( |
| "test.FooComponent", |
| "package test;", |
| "", |
| "import dagger.Component;", |
| "import javax.inject.Provider;", |
| "", |
| "@Component", |
| "interface FooComponent {", |
| " Foo foo();", |
| "", |
| " Provider<Foo> fooProvider();", |
| "}"); |
| |
| CompilerTests.daggerCompiler(foo, bar, module, component) |
| .withProcessingOptions(compilerMode.processorOptions()) |
| .compile( |
| subject -> { |
| subject.hasErrorCount(6); |
| |
| String fooError = |
| "Dagger does not support injecting @AssistedInject type, test.Foo. " |
| + "Did you mean to inject its assisted factory type instead?"; |
| subject.hasErrorContaining(fooError).onSource(bar).onLine(8); |
| subject.hasErrorContaining(fooError).onSource(module).onLine(10); |
| subject.hasErrorContaining(fooError).onSource(component).onLine(8); |
| |
| String fooProviderError = |
| "Dagger does not support injecting @AssistedInject type, " |
| + "javax.inject.Provider<test.Foo>. " |
| + "Did you mean to inject its assisted factory type instead?"; |
| subject.hasErrorContaining(fooProviderError).onSource(bar).onLine(8); |
| subject.hasErrorContaining(fooProviderError).onSource(module).onLine(10); |
| subject.hasErrorContaining(fooProviderError).onSource(component).onLine(10); |
| }); |
| } |
| |
| @Test |
| public void testProvidesAssistedBindings() { |
| Source foo = |
| CompilerTests.javaSource( |
| "test.Foo", |
| "package test;", |
| "", |
| "import dagger.assisted.Assisted;", |
| "import dagger.assisted.AssistedInject;", |
| "import dagger.assisted.AssistedFactory;", |
| "", |
| "class Foo {", |
| " @AssistedInject Foo(@Assisted int i) {}", |
| "", |
| " @AssistedFactory", |
| " interface Factory {", |
| " Foo create(int i);", |
| " }", |
| "}"); |
| |
| Source module = |
| CompilerTests.javaSource( |
| "test.FooModule", |
| "package test;", |
| "", |
| "import dagger.Module;", |
| "import dagger.Provides;", |
| "import javax.inject.Provider;", |
| "", |
| "@Module", |
| "class FooModule {", |
| " @Provides", |
| " static Foo provideFoo() {", |
| " return null;", |
| " }", |
| "", |
| " @Provides", |
| " static Foo.Factory provideFooFactory() {", |
| " return null;", |
| " }", |
| "}"); |
| |
| CompilerTests.daggerCompiler(foo, module) |
| .withProcessingOptions(compilerMode.processorOptions()) |
| .compile( |
| subject -> { |
| subject.hasErrorCount(2); |
| subject.hasErrorContaining( |
| "[test.Foo] Dagger does not support providing @AssistedInject types.") |
| .onSource(module) |
| .onLine(10); |
| subject.hasErrorContaining( |
| "[test.Foo.Factory] Dagger does not support providing @AssistedFactory " |
| + "types.") |
| .onSource(module) |
| .onLine(15); |
| }); |
| } |
| |
| @Test |
| public void testProvidesAssistedBindingsAsFactoryBindsInstance() { |
| Source foo = |
| CompilerTests.javaSource( |
| "test.Foo", |
| "package test;", |
| "", |
| "import dagger.assisted.Assisted;", |
| "import dagger.assisted.AssistedInject;", |
| "import dagger.assisted.AssistedFactory;", |
| "", |
| "class Foo {", |
| " @AssistedInject Foo(@Assisted int i) {}", |
| "", |
| " @AssistedFactory", |
| " interface Factory {", |
| " Foo create(int i);", |
| " }", |
| "}"); |
| |
| Source component = |
| CompilerTests.javaSource( |
| "test.FooComponent", |
| "package test;", |
| "", |
| "import dagger.Component;", |
| "import dagger.BindsInstance;", |
| "", |
| "@Component", |
| "interface FooComponent {", |
| " @Component.Factory", |
| " interface Factory {", |
| " FooComponent create(", |
| " @BindsInstance Foo foo,", |
| " @BindsInstance Foo.Factory fooFactory);", |
| " }", |
| "}"); |
| |
| CompilerTests.daggerCompiler(foo, component) |
| .withProcessingOptions(compilerMode.processorOptions()) |
| .compile( |
| subject -> { |
| subject.hasErrorCount(2); |
| subject.hasErrorContaining( |
| "[test.Foo] Dagger does not support providing @AssistedInject types.") |
| .onSource(component) |
| .onLine(11); |
| subject.hasErrorContaining( |
| "[test.Foo.Factory] Dagger does not support providing @AssistedFactory " |
| + "types.") |
| .onSource(component) |
| .onLine(12); |
| }); |
| } |
| |
| @Test |
| public void testProvidesAssistedBindingsAsBuilderBindsInstance() { |
| Source foo = |
| CompilerTests.javaSource( |
| "test.Foo", |
| "package test;", |
| "", |
| "import dagger.assisted.Assisted;", |
| "import dagger.assisted.AssistedInject;", |
| "import dagger.assisted.AssistedFactory;", |
| "", |
| "class Foo {", |
| " @AssistedInject Foo(@Assisted int i) {}", |
| "", |
| " @AssistedFactory", |
| " interface Factory {", |
| " Foo create(int i);", |
| " }", |
| "}"); |
| |
| Source component = |
| CompilerTests.javaSource( |
| "test.FooComponent", |
| "package test;", |
| "", |
| "import dagger.Component;", |
| "import dagger.BindsInstance;", |
| "", |
| "@Component", |
| "interface FooComponent {", |
| " @Component.Builder", |
| " interface Builder {", |
| " @BindsInstance Builder foo(Foo foo);", |
| " @BindsInstance Builder fooFactory(Foo.Factory fooFactory);", |
| " FooComponent build();", |
| " }", |
| "}"); |
| |
| CompilerTests.daggerCompiler(foo, component) |
| .withProcessingOptions(compilerMode.processorOptions()) |
| .compile( |
| subject -> { |
| subject.hasErrorCount(2); |
| subject.hasErrorContaining( |
| "[test.Foo] Dagger does not support providing @AssistedInject types.") |
| .onSource(component) |
| .onLine(10); |
| subject.hasErrorContaining( |
| "[test.Foo.Factory] Dagger does not support providing @AssistedFactory " |
| + "types.") |
| .onSource(component) |
| .onLine(11); |
| }); |
| } |
| |
| @Test |
| public void testProvidesAssistedBindingsAsOptional() { |
| Source foo = |
| CompilerTests.javaSource( |
| "test.Foo", |
| "package test;", |
| "", |
| "import dagger.assisted.Assisted;", |
| "import dagger.assisted.AssistedInject;", |
| "import dagger.assisted.AssistedFactory;", |
| "", |
| "class Foo {", |
| " @AssistedInject Foo() {}", |
| "", |
| " @AssistedFactory", |
| " interface Factory {", |
| " Foo create();", |
| " }", |
| "}"); |
| |
| Source module = |
| CompilerTests.javaSource( |
| "test.FooModule", |
| "package test;", |
| "", |
| "import dagger.BindsOptionalOf;", |
| "import dagger.Module;", |
| "import dagger.Provides;", |
| "", |
| "@Module", |
| "interface FooModule {", |
| " @BindsOptionalOf Foo optionalFoo();", |
| "", |
| " @BindsOptionalOf Foo.Factory optionalFooFactory();", |
| "}"); |
| |
| CompilerTests.daggerCompiler(foo, module) |
| .withProcessingOptions(compilerMode.processorOptions()) |
| .compile( |
| subject -> { |
| subject.hasErrorCount(2); |
| subject.hasErrorContaining( |
| "[test.Foo] Dagger does not support providing @AssistedInject types.") |
| .onSource(module) |
| .onLine(9); |
| subject.hasErrorContaining( |
| "[test.Foo.Factory] Dagger does not support providing @AssistedFactory " |
| + "types.") |
| .onSource(module) |
| .onLine(11); |
| }); |
| } |
| |
| @Test |
| public void testInjectsLazyOfAssistedFactory() { |
| Source foo = |
| CompilerTests.javaSource( |
| "test.Foo", |
| "package test;", |
| "", |
| "import dagger.assisted.Assisted;", |
| "import dagger.assisted.AssistedInject;", |
| "import dagger.assisted.AssistedFactory;", |
| "", |
| "class Foo {", |
| " @AssistedInject Foo(@Assisted int i) {}", |
| "", |
| " @AssistedFactory", |
| " interface Factory {", |
| " Foo create(int i);", |
| " }", |
| "}"); |
| |
| Source bar = |
| CompilerTests.javaSource( |
| "test.Bar", |
| "package test;", |
| "", |
| "import dagger.Lazy;", |
| "import javax.inject.Inject;", |
| "", |
| "class Bar {", |
| " @Inject", |
| " Bar(Foo.Factory fooFactory, Lazy<Foo.Factory> fooFactoryLazy) {}", |
| "}"); |
| |
| |
| CompilerTests.daggerCompiler(foo, bar) |
| .withProcessingOptions(compilerMode.processorOptions()) |
| .compile( |
| subject -> { |
| subject.hasErrorCount(1); |
| subject.hasErrorContaining( |
| "Dagger does not support injecting Lazy<T>, Producer<T>, or Produced<T> " |
| + "when T is an @AssistedFactory-annotated type such as test.Foo.Factory") |
| .onSource(bar) |
| .onLine(8); |
| }); |
| } |
| |
| @Test |
| public void testScopedAssistedInjection() { |
| Source foo = |
| CompilerTests.javaSource( |
| "test.Foo", |
| "package test;", |
| "", |
| "import dagger.assisted.Assisted;", |
| "import dagger.assisted.AssistedInject;", |
| "import dagger.assisted.AssistedFactory;", |
| "import javax.inject.Singleton;", |
| "", |
| "@Singleton", |
| "class Foo {", |
| " @AssistedInject", |
| " Foo(@Assisted int i) {}", |
| "", |
| " @AssistedFactory", |
| " interface Factory {", |
| " Foo create(int i);", |
| " }", |
| "}"); |
| |
| CompilerTests.daggerCompiler(foo) |
| .withProcessingOptions(compilerMode.processorOptions()) |
| .compile( |
| subject -> |
| // Don't assert on the number of errors as Foo_Factory_Impl can also be created |
| // and have errors from the missing Foo_Factory. |
| // TODO(erichang): don't generate the factory impls if there are errors with the |
| // assisted type |
| subject |
| .hasErrorContaining( |
| "A type with an @AssistedInject-annotated constructor cannot be scoped") |
| .onSource(foo) |
| .onLine(8)); |
| } |
| |
| @Test |
| public void testMultipleInjectAnnotations() { |
| Source foo = |
| CompilerTests.javaSource( |
| "test.Foo", |
| "package test;", |
| "", |
| "import dagger.assisted.Assisted;", |
| "import dagger.assisted.AssistedInject;", |
| "import javax.inject.Inject;", |
| "", |
| "class Foo {", |
| " @Inject", |
| " @AssistedInject", |
| " Foo(@Assisted int i) {}", |
| "}"); |
| |
| CompilerTests.daggerCompiler(foo) |
| .withProcessingOptions(compilerMode.processorOptions()) |
| .compile( |
| subject -> { |
| subject.hasErrorCount(1); |
| subject.hasErrorContaining( |
| "Constructors cannot be annotated with both @Inject and @AssistedInject"); |
| }); |
| } |
| |
| @Test |
| public void testAssistedInjectWithNoAssistedParametersIsNotInjectable() { |
| Source foo = |
| CompilerTests.javaSource( |
| "test.Foo", |
| "package test;", |
| "", |
| "import javax.inject.Inject;", |
| "", |
| "class Foo {", |
| " @Inject", |
| " Foo(Bar bar) {}", |
| "}"); |
| |
| Source bar = |
| CompilerTests.javaSource( |
| "test.Bar", |
| "package test;", |
| "", |
| "import dagger.assisted.AssistedInject;", |
| "import javax.inject.Inject;", |
| "", |
| "class Bar {", |
| " @AssistedInject", |
| " Bar() {}", |
| "}"); |
| |
| Source component = |
| CompilerTests.javaSource( |
| "test.FooComponent", |
| "package test;", |
| "", |
| "import dagger.Component;", |
| "", |
| "@Component", |
| "interface FooComponent {", |
| " Foo foo();", |
| "}"); |
| |
| |
| CompilerTests.daggerCompiler(foo, bar, component) |
| .withProcessingOptions(compilerMode.processorOptions()) |
| .compile( |
| subject -> { |
| subject.hasErrorCount(2); |
| subject.hasErrorContaining( |
| "Dagger does not support injecting @AssistedInject type, test.Bar. " |
| + "Did you mean to inject its assisted factory type instead?") |
| .onSource(foo) |
| .onLine(7); |
| subject.hasErrorContaining( |
| "\033[1;31m[Dagger/MissingBinding]\033[0m " |
| + "Foo cannot be provided without an @Inject constructor or an " |
| + "@Provides-annotated method."); |
| }); |
| } |
| |
| @Test |
| public void testInaccessibleFoo() { |
| Source foo = |
| CompilerTests.javaSource( |
| "test.subpackage.InaccessibleFoo", |
| "package test.subpackage;", |
| "", |
| "import dagger.assisted.Assisted;", |
| "import dagger.assisted.AssistedInject;", |
| "", |
| "class InaccessibleFoo {", |
| " @AssistedInject InaccessibleFoo(@Assisted int i) {}", |
| "}"); |
| |
| Source fooFactory = |
| CompilerTests.javaSource( |
| "test.subpackage.InaccessibleFooFactory", |
| "package test.subpackage;", |
| "", |
| "import dagger.assisted.AssistedFactory;", |
| "", |
| "@AssistedFactory", |
| "public interface InaccessibleFooFactory {", |
| " InaccessibleFoo create(int i);", |
| "}"); |
| |
| Source component = |
| CompilerTests.javaSource( |
| "test.FooFactoryComponent", |
| "package test;", |
| "", |
| "import dagger.Component;", |
| "import test.subpackage.InaccessibleFooFactory;", |
| "", |
| "@Component", |
| "interface FooFactoryComponent {", |
| " InaccessibleFooFactory inaccessibleFooFactory();", |
| "}"); |
| |
| CompilerTests.DaggerCompiler daggerCompiler = |
| CompilerTests.daggerCompiler(foo, fooFactory, component) |
| .withProcessingOptions(compilerMode.processorOptions()); |
| |
| if (compilerMode == CompilerMode.FAST_INIT_MODE) { |
| // TODO(bcorso): Remove once we fix inaccessible assisted factory imlementation for fastInit. |
| daggerCompiler.compile( |
| subject -> { |
| // TODO(bcorso): We don't report the error count here because javac reports |
| // the error once, whereas ksp reports the error twice. |
| subject |
| .hasErrorContaining( |
| "test.subpackage.InaccessibleFoo is not public in test.subpackage; cannot be " |
| + "accessed from outside package"); |
| }); |
| } else { |
| daggerCompiler.compile(subject -> subject.hasErrorCount(0)); |
| } |
| } |
| |
| @Test |
| public void testAssistedFactoryMethodWithTypeParametersFails() { |
| Source foo = |
| CompilerTests.javaSource( |
| "test.Foo", |
| "package test;", |
| "", |
| "import dagger.assisted.AssistedInject;", |
| "import dagger.assisted.AssistedFactory;", |
| "", |
| "class Foo<T> {", |
| " @AssistedInject", |
| " Foo() {}", |
| "", |
| " @AssistedFactory", |
| " interface FooFactory {", |
| " <T> Foo<T> create();", |
| " }", |
| "}"); |
| |
| CompilerTests.daggerCompiler(foo) |
| .withProcessingOptions(compilerMode.processorOptions()) |
| .compile( |
| subject -> { |
| subject.hasErrorCount(1); |
| subject.hasErrorContaining( |
| "@AssistedFactory does not currently support type parameters in the creator " |
| + "method.") |
| .onSource(foo) |
| .onLine(12); |
| }); |
| } |
| } |
