javatests/dagger/internal/codegen/ModuleValidationTest.java - platform/external/dagger2 - Git at Google

 /*
  * Copyright (C) 2016 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 static dagger.internal.codegen.DaggerModuleMethodSubject.Factory.assertThatModuleMethod;

 import androidx.room.compiler.processing.XProcessingEnv;
 import androidx.room.compiler.processing.util.Source;
 import dagger.Module;
 import dagger.producers.ProducerModule;
 import dagger.testing.compile.CompilerTests;
 import java.lang.annotation.Annotation;
 import java.util.Arrays;
 import java.util.Collection;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;

 @RunWith(Parameterized.class)
 public final class ModuleValidationTest {

   @Parameterized.Parameters(name = "{0}")
   public static Collection<Object[]> parameters() {
     return Arrays.asList(new Object[][] {{ModuleType.MODULE}, {ModuleType.PRODUCER_MODULE}});
   }

   private enum ModuleType {
     MODULE(Module.class),
     PRODUCER_MODULE(ProducerModule.class),
     ;

     private final Class<? extends Annotation> annotation;

     ModuleType(Class<? extends Annotation> annotation) {
       this.annotation = annotation;
     }

     String annotationWithSubcomponent(String subcomponent) {
       return String.format("@%s(subcomponents = %s)", annotation.getSimpleName(), subcomponent);
     }

     String importStatement() {
       return String.format("import %s;", annotation.getName());
     }

     String simpleName() {
       return annotation.getSimpleName();
     }
   }

   private final ModuleType moduleType;

   public ModuleValidationTest(ModuleType moduleType) {
     this.moduleType = moduleType;
   }

   @Test
   public void moduleSubcomponents_notASubcomponent() {
     Source module =
         CompilerTests.javaSource(
             "test.TestModule",
             "package test;",
             "",
             moduleType.importStatement(),
             "",
             moduleType.annotationWithSubcomponent("NotASubcomponent.class"),
             "class TestModule {}");
     Source notASubcomponent =
         CompilerTests.javaSource(
             "test.NotASubcomponent",
             "package test;",
             "",
             "class NotASubcomponent {}");
     CompilerTests.daggerCompiler(module, notASubcomponent)
         .compile(
             subject -> {
               subject.hasErrorCount(1);
               subject.hasErrorContaining(
                       "test.NotASubcomponent is not a @Subcomponent or @ProductionSubcomponent")
                   .onSource(module)
                   .onLine(5);
             });
   }

   @Test
   public void moduleSubcomponents_listsSubcomponentBuilder() {
     Source module =
         CompilerTests.javaSource(
             "test.TestModule",
             "package test;",
             "",
             moduleType.importStatement(),
             "",
             moduleType.annotationWithSubcomponent("Sub.Builder.class"),
             "class TestModule {}");
     Source subcomponent =
         CompilerTests.javaSource(
             "test.Sub",
             "package test;",
             "",
             "import dagger.Subcomponent;",
             "",
             "@Subcomponent",
             "interface Sub {",
             "  @Subcomponent.Builder",
             "  interface Builder {",
             "    Sub build();",
             "  }",
             "}");
     CompilerTests.daggerCompiler(module, subcomponent)
         .compile(
             subject -> {
               subject.hasErrorCount(1);
               subject.hasErrorContaining(
                       "test.Sub.Builder is a @Subcomponent.Builder. Did you mean to use test.Sub?")
                   .onSource(module)
                   .onLine(5);
             });
   }

   @Test
   public void moduleSubcomponents_listsSubcomponentFactory() {
     Source module =
         CompilerTests.javaSource(
             "test.TestModule",
             "package test;",
             "",
             moduleType.importStatement(),
             "",
             moduleType.annotationWithSubcomponent("Sub.Factory.class"),
             "class TestModule {}");
     Source subcomponent =
         CompilerTests.javaSource(
             "test.Sub",
             "package test;",
             "",
             "import dagger.Subcomponent;",
             "",
             "@Subcomponent",
             "interface Sub {",
             "  @Subcomponent.Factory",
             "  interface Factory {",
             "    Sub creator();",
             "  }",
             "}");
     CompilerTests.daggerCompiler(module, subcomponent)
         .compile(
             subject -> {
               subject.hasErrorCount(1);
               subject.hasErrorContaining(
                       "test.Sub.Factory is a @Subcomponent.Factory. Did you mean to use test.Sub?")
                   .onSource(module)
                   .onLine(5);
             });
   }

   @Test
   public void moduleSubcomponents_listsProductionSubcomponentBuilder() {
     Source module =
         CompilerTests.javaSource(
             "test.TestModule",
             "package test;",
             "",
             moduleType.importStatement(),
             "",
             moduleType.annotationWithSubcomponent("Sub.Builder.class"),
             "class TestModule {}");
     Source subcomponent =
         CompilerTests.javaSource(
             "test.Sub",
             "package test;",
             "",
             "import dagger.producers.ProductionSubcomponent;",
             "",
             "@ProductionSubcomponent",
             "interface Sub {",
             "  @ProductionSubcomponent.Builder",
             "  interface Builder {",
             "    Sub build();",
             "  }",
             "}");
     CompilerTests.daggerCompiler(module, subcomponent)
         .compile(
             subject -> {
               subject.hasErrorCount(1);
               subject.hasErrorContaining(
                       "test.Sub.Builder is a @ProductionSubcomponent.Builder. "
                           + "Did you mean to use test.Sub?")
                   .onSource(module)
                   .onLine(5);
             });
   }

   @Test
   public void moduleSubcomponents_listsProductionSubcomponentFactory() {
     Source module =
         CompilerTests.javaSource(
             "test.TestModule",
             "package test;",
             "",
             moduleType.importStatement(),
             "",
             moduleType.annotationWithSubcomponent("Sub.Factory.class"),
             "class TestModule {}");
     Source subcomponent =
         CompilerTests.javaSource(
             "test.Sub",
             "package test;",
             "",
             "import dagger.producers.ProductionSubcomponent;",
             "",
             "@ProductionSubcomponent",
             "interface Sub {",
             "  @ProductionSubcomponent.Factory",
             "  interface Factory {",
             "    Sub create();",
             "  }",
             "}");
     CompilerTests.daggerCompiler(module, subcomponent)
         .compile(
             subject -> {
               subject.hasErrorCount(1);
               subject.hasErrorContaining(
                       "test.Sub.Factory is a @ProductionSubcomponent.Factory. "
                           + "Did you mean to use test.Sub?")
                   .onSource(module)
                   .onLine(5);
             });
   }

   @Test
   public void moduleSubcomponents_noSubcomponentCreator() {
     Source module =
         CompilerTests.javaSource(
             "test.TestModule",
             "package test;",
             "",
             moduleType.importStatement(),
             "",
             moduleType.annotationWithSubcomponent("NoBuilder.class"),
             "class TestModule {}");
     Source subcomponent =
         CompilerTests.javaSource(
             "test.NoBuilder",
             "package test;",
             "",
             "import dagger.Subcomponent;",
             "",
             "@Subcomponent",
             "interface NoBuilder {}");
     CompilerTests.daggerCompiler(module, subcomponent)
         .compile(
             subject -> {
               subject.hasErrorCount(1);
               subject.hasErrorContaining(
                       "test.NoBuilder doesn't have a @Subcomponent.Builder or "
                           + "@Subcomponent.Factory, which is required when used with @"
                           + moduleType.simpleName()
                           + ".subcomponents")
                   .onSource(module)
                   .onLine(5);
             });
   }

   @Test
   public void moduleSubcomponents_noProductionSubcomponentCreator() {
     Source module =
         CompilerTests.javaSource(
             "test.TestModule",
             "package test;",
             "",
             moduleType.importStatement(),
             "",
             moduleType.annotationWithSubcomponent("NoBuilder.class"),
             "class TestModule {}");
     Source subcomponent =
         CompilerTests.javaSource(
             "test.NoBuilder",
             "package test;",
             "",
             "import dagger.producers.ProductionSubcomponent;",
             "",
             "@ProductionSubcomponent",
             "interface NoBuilder {}");
     CompilerTests.daggerCompiler(module, subcomponent)
         .compile(
             subject -> {
               subject.hasErrorCount(1);
               subject.hasErrorContaining(
                       "test.NoBuilder doesn't have a @ProductionSubcomponent.Builder or "
                           + "@ProductionSubcomponent.Factory, which is required when used with @"
                           + moduleType.simpleName()
                           + ".subcomponents")
                   .onSource(module)
                   .onLine(5);
             });
   }

   @Test
   public void moduleSubcomponentsAreTypes() {
     Source module =
         CompilerTests.javaSource(
             "test.TestModule",
             "package test;",
             "",
             "import dagger.Module;",
             "",
             "@Module(subcomponents = int.class)",
             "class TestModule {}");
     CompilerTests.daggerCompiler(module)
         .compile(
             subject -> {
               subject.hasErrorCount(1);
               switch (CompilerTests.backend(subject)) {
                 case JAVAC:
                   subject.hasErrorContaining("int is not a valid subcomponent type")
                       .onSource(module)
                       .onLine(5);
                   break;
                 case KSP:
                   // TODO(b/245954367): Remove this pathway once this bug is fixed.
                   // KSP interprets the int.class type as a boxed type so we get a slightly
                   // different error message for now.
                   subject.hasErrorContaining(
                           "java.lang.Integer is not a @Subcomponent or @ProductionSubcomponent")
                       .onSource(module)
                       .onLine(5);
                   break;
               }
             });
   }

   @Test
   public void tooManyAnnotations() {
     assertThatModuleMethod(
             "@BindsOptionalOf @Multibinds abstract Set<Object> tooManyAnnotations();")
         .hasError("is annotated with more than one of");
   }

   @Test
   public void invalidIncludedModule() {
     Source badModule =
         CompilerTests.javaSource(
             "test.BadModule",
             "package test;",
             "",
             "import dagger.Binds;",
             "import dagger.Module;",
             "",
             "@Module",
             "abstract class BadModule {",
             "  @Binds abstract Object noParameters();",
             "}");
     Source module =
         CompilerTests.javaSource(
             "test.IncludesBadModule",
             "package test;",
             "",
             "import dagger.Module;",
             "",
             "@Module(includes = BadModule.class)",
             "abstract class IncludesBadModule {}");
     CompilerTests.daggerCompiler(badModule, module)
         .compile(
             subject -> {
               subject.hasErrorCount(2);
               subject.hasErrorContaining("test.BadModule has errors")
                   .onSource(module)
                   .onLine(5);
               subject.hasErrorContaining(
                       "@Binds methods must have exactly one parameter, whose type is "
                           + "assignable to the return type")
                   .onSource(badModule)
                   .onLine(8);
             });
   }

   @Test
   public void scopeOnModule() {
     Source badModule =
         CompilerTests.javaSource(
             "test.BadModule",
             "package test;",
             "",
             "import dagger.Module;",
             "import javax.inject.Singleton;",
             "",
             "@Singleton",
             "@Module",
             "interface BadModule {}");
     CompilerTests.daggerCompiler(badModule)
         .compile(
             subject -> {
               subject.hasErrorCount(1);
               subject.hasErrorContaining("@Modules cannot be scoped")
                   .onSource(badModule)
                   .onLineContaining("@Singleton");
             });
   }

   @Test
   public void moduleIncludesSelfCycle() {
     Source module =
         CompilerTests.javaSource(
             "test.TestModule",
             "package test;",
             "",
             moduleType.importStatement(),
             "import dagger.Provides;",
             "",
             String.format("@%s(", moduleType.simpleName()),
             "  includes = {",
             "      TestModule.class, // first",
             "      OtherModule.class,",
             "      TestModule.class, // second",
             "  }",
             ")",
             "class TestModule {",
             "  @Provides int i() { return 0; }",
             "}");

     Source otherModule =
         CompilerTests.javaSource(
             "test.OtherModule",
             "package test;",
             "",
             "import dagger.Module;",
             "",
             "@Module",
             "class OtherModule {}");

     CompilerTests.daggerCompiler(module, otherModule)
         .compile(
             subject -> {
               subject.hasErrorCount(2);
               String error =
                   String.format("@%s cannot include themselves", moduleType.simpleName());
               switch (CompilerTests.backend(subject)) {
                 case JAVAC:
                   subject.hasErrorContaining(error).onSource(module).onLineContaining("// first");
                   subject.hasErrorContaining(error).onSource(module).onLineContaining("// second");
                   break;
                 case KSP:
                   // KSP doesn't support reporting errors on individual annotation values, so both
                   // errors will be reported on the annotation itself.
                   subject.hasErrorContaining(error)
                       .onSource(module)
                       .onLineContaining("@" + moduleType.simpleName());
                   break;
               }
             });
   }

   // Regression test for b/264618194.
   @Test
   public void objectModuleInheritsInstanceBindingFails() {
     Source objectModule =
         CompilerTests.kotlinSource(
             "test.ObjectModule.kt",
             "package test",
             "",
             "import dagger.Module",
             "import dagger.Provides",
             "",
             "@Module",
             "object ObjectModule : ClassModule() {",
             "  @Provides fun provideString(): String = \"\"",
             "}");
     Source classModule =
         CompilerTests.kotlinSource(
             "test.ClassModule.kt",
             "package test",
             "",
             "import dagger.Module",
             "import dagger.Provides",
             "",
             "@Module",
             "abstract class ClassModule {",
             "  @Provides fun provideInt(): Int = 1",
             "}");
     Source component =
         CompilerTests.kotlinSource(
             "test.TestComponent.kt",
             "package test",
             "",
             "import dagger.Component",
             "",
             "@Component(modules = [ObjectModule::class])",
             "interface TestComponent {",
             "  fun getInt(): Int",
             "  fun getString(): String",
             "}");

     CompilerTests.daggerCompiler(component, objectModule, classModule)
         .compile(
             subject -> {
               subject.hasErrorCount(2);
               subject.hasErrorContaining("test.ObjectModule has errors")
                   .onSource(component)
                   .onLineContaining("ObjectModule::class");
               subject.hasErrorContaining(
                       "@Module-annotated Kotlin object cannot inherit instance "
                           + "(i.e. non-abstract, non-JVM static) binding method: "
                           + "@Provides int test.ClassModule.provideInt()")
                   .onSource(objectModule)
                   .onLineContaining(
                       // TODO(b/267223703): KAPT incorrectly reports the error on the annotation.
                       CompilerTests.backend(subject) == XProcessingEnv.Backend.JAVAC
                           ? "@Module"
                           : "object ObjectModule");
             });
   }

   // Regression test for b/264618194.
   @Test
   public void objectModuleInheritsNonInstanceBindingSucceeds() {
     Source objectModule =
         CompilerTests.kotlinSource(
             "test.ObjectModule.kt",
             "package test",
             "",
             "import dagger.Module",
             "import dagger.Provides",
             "",
             "@Module",
             "object ObjectModule : ClassModule() {",
             "  @Provides fun provideString(): String = \"\"",
             "}");
     Source classModule =
         CompilerTests.javaSource(
             "test.ClassModule",
             "package test;",
             "",
             "import dagger.Binds;",
             "import dagger.Module;",
             "import dagger.Provides;",
             "",
             "@Module",
             "public abstract class ClassModule {",
             "  // A non-binding instance method is okay.",
             "  public int nonBindingMethod() {",
             "    return 1;",
             "  }",
             "",
             "  // A static binding method is also okay.",
             "  @Provides",
             "  public static int provideInt() {",
             "    return 1;",
             "  }",
             "}");
     Source component =
         CompilerTests.kotlinSource(
             "test.TestComponent.kt",
             "package test",
             "",
             "import dagger.Component",
             "",
             "@Component(modules = [ObjectModule::class])",
             "interface TestComponent {",
             "  fun getInt(): Int",
             "  fun getString(): String",
             "}");
     CompilerTests.daggerCompiler(component, objectModule, classModule)
         .compile(subject -> subject.hasErrorCount(0));
   }
 }
	/*
	* Copyright (C) 2016 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 static dagger.internal.codegen.DaggerModuleMethodSubject.Factory.assertThatModuleMethod;

	import androidx.room.compiler.processing.XProcessingEnv;
	import androidx.room.compiler.processing.util.Source;
	import dagger.Module;
	import dagger.producers.ProducerModule;
	import dagger.testing.compile.CompilerTests;
	import java.lang.annotation.Annotation;
	import java.util.Arrays;
	import java.util.Collection;
	import org.junit.Test;
	import org.junit.runner.RunWith;
	import org.junit.runners.Parameterized;

	@RunWith(Parameterized.class)
	public final class ModuleValidationTest {

	@Parameterized.Parameters(name = "{0}")
	public static Collection<Object[]> parameters() {
	return Arrays.asList(new Object[][] {{ModuleType.MODULE}, {ModuleType.PRODUCER_MODULE}});
	}

	private enum ModuleType {
	MODULE(Module.class),
	PRODUCER_MODULE(ProducerModule.class),
	;

	private final Class<? extends Annotation> annotation;

	ModuleType(Class<? extends Annotation> annotation) {
	this.annotation = annotation;
	}

	String annotationWithSubcomponent(String subcomponent) {
	return String.format("@%s(subcomponents = %s)", annotation.getSimpleName(), subcomponent);
	}

	String importStatement() {
	return String.format("import %s;", annotation.getName());
	}

	String simpleName() {
	return annotation.getSimpleName();
	}
	}

	private final ModuleType moduleType;

	public ModuleValidationTest(ModuleType moduleType) {
	this.moduleType = moduleType;
	}

	@Test
	public void moduleSubcomponents_notASubcomponent() {
	Source module =
	CompilerTests.javaSource(
	"test.TestModule",
	"package test;",
	"",
	moduleType.importStatement(),
	"",
	moduleType.annotationWithSubcomponent("NotASubcomponent.class"),
	"class TestModule {}");
	Source notASubcomponent =
	CompilerTests.javaSource(
	"test.NotASubcomponent",
	"package test;",
	"",
	"class NotASubcomponent {}");
	CompilerTests.daggerCompiler(module, notASubcomponent)
	.compile(
	subject -> {
	subject.hasErrorCount(1);
	subject.hasErrorContaining(
	"test.NotASubcomponent is not a @Subcomponent or @ProductionSubcomponent")
	.onSource(module)
	.onLine(5);
	});
	}

	@Test
	public void moduleSubcomponents_listsSubcomponentBuilder() {
	Source module =
	CompilerTests.javaSource(
	"test.TestModule",
	"package test;",
	"",
	moduleType.importStatement(),
	"",
	moduleType.annotationWithSubcomponent("Sub.Builder.class"),
	"class TestModule {}");
	Source subcomponent =
	CompilerTests.javaSource(
	"test.Sub",
	"package test;",
	"",
	"import dagger.Subcomponent;",
	"",
	"@Subcomponent",
	"interface Sub {",
	" @Subcomponent.Builder",
	" interface Builder {",
	" Sub build();",
	" }",
	"}");
	CompilerTests.daggerCompiler(module, subcomponent)
	.compile(
	subject -> {
	subject.hasErrorCount(1);
	subject.hasErrorContaining(
	"test.Sub.Builder is a @Subcomponent.Builder. Did you mean to use test.Sub?")
	.onSource(module)
	.onLine(5);
	});
	}

	@Test
	public void moduleSubcomponents_listsSubcomponentFactory() {
	Source module =
	CompilerTests.javaSource(
	"test.TestModule",
	"package test;",
	"",
	moduleType.importStatement(),
	"",
	moduleType.annotationWithSubcomponent("Sub.Factory.class"),
	"class TestModule {}");
	Source subcomponent =
	CompilerTests.javaSource(
	"test.Sub",
	"package test;",
	"",
	"import dagger.Subcomponent;",
	"",
	"@Subcomponent",
	"interface Sub {",
	" @Subcomponent.Factory",
	" interface Factory {",
	" Sub creator();",
	" }",
	"}");
	CompilerTests.daggerCompiler(module, subcomponent)
	.compile(
	subject -> {
	subject.hasErrorCount(1);
	subject.hasErrorContaining(
	"test.Sub.Factory is a @Subcomponent.Factory. Did you mean to use test.Sub?")
	.onSource(module)
	.onLine(5);
	});
	}

	@Test
	public void moduleSubcomponents_listsProductionSubcomponentBuilder() {
	Source module =
	CompilerTests.javaSource(
	"test.TestModule",
	"package test;",
	"",
	moduleType.importStatement(),
	"",
	moduleType.annotationWithSubcomponent("Sub.Builder.class"),
	"class TestModule {}");
	Source subcomponent =
	CompilerTests.javaSource(
	"test.Sub",
	"package test;",
	"",
	"import dagger.producers.ProductionSubcomponent;",
	"",
	"@ProductionSubcomponent",
	"interface Sub {",
	" @ProductionSubcomponent.Builder",
	" interface Builder {",
	" Sub build();",
	" }",
	"}");
	CompilerTests.daggerCompiler(module, subcomponent)
	.compile(
	subject -> {
	subject.hasErrorCount(1);
	subject.hasErrorContaining(
	"test.Sub.Builder is a @ProductionSubcomponent.Builder. "
	+ "Did you mean to use test.Sub?")
	.onSource(module)
	.onLine(5);
	});
	}

	@Test
	public void moduleSubcomponents_listsProductionSubcomponentFactory() {
	Source module =
	CompilerTests.javaSource(
	"test.TestModule",
	"package test;",
	"",
	moduleType.importStatement(),
	"",
	moduleType.annotationWithSubcomponent("Sub.Factory.class"),
	"class TestModule {}");
	Source subcomponent =
	CompilerTests.javaSource(
	"test.Sub",
	"package test;",
	"",
	"import dagger.producers.ProductionSubcomponent;",
	"",
	"@ProductionSubcomponent",
	"interface Sub {",
	" @ProductionSubcomponent.Factory",
	" interface Factory {",
	" Sub create();",
	" }",
	"}");
	CompilerTests.daggerCompiler(module, subcomponent)
	.compile(
	subject -> {
	subject.hasErrorCount(1);
	subject.hasErrorContaining(
	"test.Sub.Factory is a @ProductionSubcomponent.Factory. "
	+ "Did you mean to use test.Sub?")
	.onSource(module)
	.onLine(5);
	});
	}

	@Test
	public void moduleSubcomponents_noSubcomponentCreator() {
	Source module =
	CompilerTests.javaSource(
	"test.TestModule",
	"package test;",
	"",
	moduleType.importStatement(),
	"",
	moduleType.annotationWithSubcomponent("NoBuilder.class"),
	"class TestModule {}");
	Source subcomponent =
	CompilerTests.javaSource(
	"test.NoBuilder",
	"package test;",
	"",
	"import dagger.Subcomponent;",
	"",
	"@Subcomponent",
	"interface NoBuilder {}");
	CompilerTests.daggerCompiler(module, subcomponent)
	.compile(
	subject -> {
	subject.hasErrorCount(1);
	subject.hasErrorContaining(
	"test.NoBuilder doesn't have a @Subcomponent.Builder or "
	+ "@Subcomponent.Factory, which is required when used with @"
	+ moduleType.simpleName()
	+ ".subcomponents")
	.onSource(module)
	.onLine(5);
	});
	}

	@Test
	public void moduleSubcomponents_noProductionSubcomponentCreator() {
	Source module =
	CompilerTests.javaSource(
	"test.TestModule",
	"package test;",
	"",
	moduleType.importStatement(),
	"",
	moduleType.annotationWithSubcomponent("NoBuilder.class"),
	"class TestModule {}");
	Source subcomponent =
	CompilerTests.javaSource(
	"test.NoBuilder",
	"package test;",
	"",
	"import dagger.producers.ProductionSubcomponent;",
	"",
	"@ProductionSubcomponent",
	"interface NoBuilder {}");
	CompilerTests.daggerCompiler(module, subcomponent)
	.compile(
	subject -> {
	subject.hasErrorCount(1);
	subject.hasErrorContaining(
	"test.NoBuilder doesn't have a @ProductionSubcomponent.Builder or "
	+ "@ProductionSubcomponent.Factory, which is required when used with @"
	+ moduleType.simpleName()
	+ ".subcomponents")
	.onSource(module)
	.onLine(5);
	});
	}

	@Test
	public void moduleSubcomponentsAreTypes() {
	Source module =
	CompilerTests.javaSource(
	"test.TestModule",
	"package test;",
	"",
	"import dagger.Module;",
	"",
	"@Module(subcomponents = int.class)",
	"class TestModule {}");
	CompilerTests.daggerCompiler(module)
	.compile(
	subject -> {
	subject.hasErrorCount(1);
	switch (CompilerTests.backend(subject)) {
	case JAVAC:
	subject.hasErrorContaining("int is not a valid subcomponent type")
	.onSource(module)
	.onLine(5);
	break;
	case KSP:
	// TODO(b/245954367): Remove this pathway once this bug is fixed.
	// KSP interprets the int.class type as a boxed type so we get a slightly
	// different error message for now.
	subject.hasErrorContaining(
	"java.lang.Integer is not a @Subcomponent or @ProductionSubcomponent")
	.onSource(module)
	.onLine(5);
	break;
	}
	});
	}

	@Test
	public void tooManyAnnotations() {
	assertThatModuleMethod(
	"@BindsOptionalOf @Multibinds abstract Set<Object> tooManyAnnotations();")
	.hasError("is annotated with more than one of");
	}

	@Test
	public void invalidIncludedModule() {
	Source badModule =
	CompilerTests.javaSource(
	"test.BadModule",
	"package test;",
	"",
	"import dagger.Binds;",
	"import dagger.Module;",
	"",
	"@Module",
	"abstract class BadModule {",
	" @Binds abstract Object noParameters();",
	"}");
	Source module =
	CompilerTests.javaSource(
	"test.IncludesBadModule",
	"package test;",
	"",
	"import dagger.Module;",
	"",
	"@Module(includes = BadModule.class)",
	"abstract class IncludesBadModule {}");
	CompilerTests.daggerCompiler(badModule, module)
	.compile(
	subject -> {
	subject.hasErrorCount(2);
	subject.hasErrorContaining("test.BadModule has errors")
	.onSource(module)
	.onLine(5);
	subject.hasErrorContaining(
	"@Binds methods must have exactly one parameter, whose type is "
	+ "assignable to the return type")
	.onSource(badModule)
	.onLine(8);
	});
	}

	@Test
	public void scopeOnModule() {
	Source badModule =
	CompilerTests.javaSource(
	"test.BadModule",
	"package test;",
	"",
	"import dagger.Module;",
	"import javax.inject.Singleton;",
	"",
	"@Singleton",
	"@Module",
	"interface BadModule {}");
	CompilerTests.daggerCompiler(badModule)
	.compile(
	subject -> {
	subject.hasErrorCount(1);
	subject.hasErrorContaining("@Modules cannot be scoped")
	.onSource(badModule)
	.onLineContaining("@Singleton");
	});
	}

	@Test
	public void moduleIncludesSelfCycle() {
	Source module =
	CompilerTests.javaSource(
	"test.TestModule",
	"package test;",
	"",
	moduleType.importStatement(),
	"import dagger.Provides;",
	"",
	String.format("@%s(", moduleType.simpleName()),
	" includes = {",
	" TestModule.class, // first",
	" OtherModule.class,",
	" TestModule.class, // second",
	" }",
	")",
	"class TestModule {",
	" @Provides int i() { return 0; }",
	"}");

	Source otherModule =
	CompilerTests.javaSource(
	"test.OtherModule",
	"package test;",
	"",
	"import dagger.Module;",
	"",
	"@Module",
	"class OtherModule {}");

	CompilerTests.daggerCompiler(module, otherModule)
	.compile(
	subject -> {
	subject.hasErrorCount(2);
	String error =
	String.format("@%s cannot include themselves", moduleType.simpleName());
	switch (CompilerTests.backend(subject)) {
	case JAVAC:
	subject.hasErrorContaining(error).onSource(module).onLineContaining("// first");
	subject.hasErrorContaining(error).onSource(module).onLineContaining("// second");
	break;
	case KSP:
	// KSP doesn't support reporting errors on individual annotation values, so both
	// errors will be reported on the annotation itself.
	subject.hasErrorContaining(error)
	.onSource(module)
	.onLineContaining("@" + moduleType.simpleName());
	break;
	}
	});
	}

	// Regression test for b/264618194.
	@Test
	public void objectModuleInheritsInstanceBindingFails() {
	Source objectModule =
	CompilerTests.kotlinSource(
	"test.ObjectModule.kt",
	"package test",
	"",
	"import dagger.Module",
	"import dagger.Provides",
	"",
	"@Module",
	"object ObjectModule : ClassModule() {",
	" @Provides fun provideString(): String = \"\"",
	"}");
	Source classModule =
	CompilerTests.kotlinSource(
	"test.ClassModule.kt",
	"package test",
	"",
	"import dagger.Module",
	"import dagger.Provides",
	"",
	"@Module",
	"abstract class ClassModule {",
	" @Provides fun provideInt(): Int = 1",
	"}");
	Source component =
	CompilerTests.kotlinSource(
	"test.TestComponent.kt",
	"package test",
	"",
	"import dagger.Component",
	"",
	"@Component(modules = [ObjectModule::class])",
	"interface TestComponent {",
	" fun getInt(): Int",
	" fun getString(): String",
	"}");

	CompilerTests.daggerCompiler(component, objectModule, classModule)
	.compile(
	subject -> {
	subject.hasErrorCount(2);
	subject.hasErrorContaining("test.ObjectModule has errors")
	.onSource(component)
	.onLineContaining("ObjectModule::class");
	subject.hasErrorContaining(
	"@Module-annotated Kotlin object cannot inherit instance "
	+ "(i.e. non-abstract, non-JVM static) binding method: "
	+ "@Provides int test.ClassModule.provideInt()")
	.onSource(objectModule)
	.onLineContaining(
	// TODO(b/267223703): KAPT incorrectly reports the error on the annotation.
	CompilerTests.backend(subject) == XProcessingEnv.Backend.JAVAC
	? "@Module"
	: "object ObjectModule");
	});
	}

	// Regression test for b/264618194.
	@Test
	public void objectModuleInheritsNonInstanceBindingSucceeds() {
	Source objectModule =
	CompilerTests.kotlinSource(
	"test.ObjectModule.kt",
	"package test",
	"",
	"import dagger.Module",
	"import dagger.Provides",
	"",
	"@Module",
	"object ObjectModule : ClassModule() {",
	" @Provides fun provideString(): String = \"\"",
	"}");
	Source classModule =
	CompilerTests.javaSource(
	"test.ClassModule",
	"package test;",
	"",
	"import dagger.Binds;",
	"import dagger.Module;",
	"import dagger.Provides;",
	"",
	"@Module",
	"public abstract class ClassModule {",
	" // A non-binding instance method is okay.",
	" public int nonBindingMethod() {",
	" return 1;",
	" }",
	"",
	" // A static binding method is also okay.",
	" @Provides",
	" public static int provideInt() {",
	" return 1;",
	" }",
	"}");
	Source component =
	CompilerTests.kotlinSource(
	"test.TestComponent.kt",
	"package test",
	"",
	"import dagger.Component",
	"",
	"@Component(modules = [ObjectModule::class])",
	"interface TestComponent {",
	" fun getInt(): Int",
	" fun getString(): String",
	"}");
	CompilerTests.daggerCompiler(component, objectModule, classModule)
	.compile(subject -> subject.hasErrorCount(0));
	}
	}