/*
 * Copyright (C) 2015 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.CompilerMode.DEFAULT_MODE;
import static dagger.internal.codegen.base.ComponentCreatorAnnotation.SUBCOMPONENT_BUILDER;
import static dagger.internal.codegen.base.ComponentCreatorAnnotation.SUBCOMPONENT_FACTORY;
import static dagger.internal.codegen.base.ComponentCreatorKind.BUILDER;
import static dagger.internal.codegen.base.ComponentCreatorKind.FACTORY;
import static dagger.internal.codegen.base.ComponentKind.SUBCOMPONENT;
import static dagger.internal.codegen.binding.ErrorMessages.ComponentCreatorMessages.moreThanOneRefToSubcomponent;
import static dagger.internal.codegen.binding.ErrorMessages.componentMessagesFor;

import androidx.room.compiler.processing.util.Source;
import com.google.common.collect.ImmutableList;
import dagger.internal.codegen.base.ComponentCreatorAnnotation;
import dagger.testing.compile.CompilerTests;
import java.util.Collection;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;

/** Tests for {@link dagger.Subcomponent.Builder} validation. */
@RunWith(Parameterized.class)
public class SubcomponentCreatorValidationTest extends ComponentCreatorTestHelper {
  @Parameters(name = "creatorKind={0}")
  public static Collection<Object[]> parameters() {
    return ImmutableList.copyOf(new Object[][] {{SUBCOMPONENT_BUILDER}, {SUBCOMPONENT_FACTORY}});
  }

  public SubcomponentCreatorValidationTest(ComponentCreatorAnnotation componentCreatorAnnotation) {
    super(DEFAULT_MODE, componentCreatorAnnotation);
  }

  @Test
  public void testRefSubcomponentAndSubCreatorFails() {
    Source componentFile =
        preprocessedJavaSource(
            "test.ParentComponent",
            "package test;",
            "",
            "import dagger.Component;",
            "import javax.inject.Provider;",
            "",
            "@Component",
            "interface ParentComponent {",
            "  ChildComponent child();",
            "  ChildComponent.Builder childComponentBuilder();",
            "}");
    Source childComponentFile = preprocessedJavaSource("test.ChildComponent",
        "package test;",
        "",
        "import dagger.Subcomponent;",
        "",
        "@Subcomponent",
        "interface ChildComponent {",
        "  @Subcomponent.Builder",
        "  static interface Builder {",
        "    ChildComponent build();",
        "  }",
        "}");
    CompilerTests.daggerCompiler(componentFile, childComponentFile)
        .compile(
            subject -> {
              subject.hasErrorCount(1);
              subject.hasErrorContaining(
                      String.format(
                          moreThanOneRefToSubcomponent(),
                          "test.ChildComponent",
                          process("["
                              + "test.ParentComponent.child(), "
                              + "test.ParentComponent.childComponentBuilder()"
                              + "]")))
                  .onSource(componentFile);
            });
  }

  @Test
  public void testRefSubCreatorTwiceFails() {
    Source componentFile = preprocessedJavaSource("test.ParentComponent",
        "package test;",
        "",
        "import dagger.Component;",
        "import javax.inject.Provider;",
        "",
        "@Component",
        "interface ParentComponent {",
        "  ChildComponent.Builder builder1();",
        "  ChildComponent.Builder builder2();",
        "}");
    Source childComponentFile = preprocessedJavaSource("test.ChildComponent",
        "package test;",
        "",
        "import dagger.Subcomponent;",
        "",
        "@Subcomponent",
        "interface ChildComponent {",
        "  @Subcomponent.Builder",
        "  static interface Builder {",
        "    ChildComponent build();",
        "  }",
        "}");
    CompilerTests.daggerCompiler(componentFile, childComponentFile)
        .compile(
            subject -> {
              subject.hasErrorCount(1);
              subject.hasErrorContaining(
                      String.format(
                          moreThanOneRefToSubcomponent(),
                          "test.ChildComponent",
                          process("["
                              + "test.ParentComponent.builder1(), "
                              + "test.ParentComponent.builder2()"
                              + "]")))
                  .onSource(componentFile);
            });
  }

  @Test
  public void testMoreThanOneCreatorFails() {
    Source componentFile = preprocessedJavaSource("test.ParentComponent",
        "package test;",
        "",
        "import dagger.Component;",
        "import javax.inject.Provider;",
        "",
        "@Component",
        "interface ParentComponent {",
        "  ChildComponent.Builder1 build();",
        "}");
    Source childComponentFile = preprocessedJavaSource("test.ChildComponent",
        "package test;",
        "",
        "import dagger.Subcomponent;",
        "",
        "@Subcomponent",
        "interface ChildComponent {",
        "  @Subcomponent.Builder",
        "  static interface Builder1 {",
        "    ChildComponent build();",
        "  }",
        "",
        "  @Subcomponent.Builder",
        "  static interface Builder2 {",
        "    ChildComponent build();",
        "  }",
        "}");
    CompilerTests.daggerCompiler(componentFile, childComponentFile)
        .compile(
            subject -> {
              subject.hasErrorCount(1);
              subject.hasErrorContaining(
                      String.format(
                          componentMessagesFor(SUBCOMPONENT).moreThanOne(),
                          process("[test.ChildComponent.Builder1, test.ChildComponent.Builder2]")))
                  .onSource(childComponentFile);
            });
  }

  @Test
  public void testMoreThanOneCreatorFails_differentTypes() {
    Source componentFile = preprocessedJavaSource("test.ParentComponent",
        "package test;",
        "",
        "import dagger.Component;",
        "import javax.inject.Provider;",
        "",
        "@Component",
        "interface ParentComponent {",
        "  ChildComponent.Builder build();",
        "}");
    Source childComponentFile =
        CompilerTests.javaSource("test.ChildComponent",
        "package test;",
        "",
        "import dagger.Subcomponent;",
        "",
        "@Subcomponent",
        "interface ChildComponent {",
        "  @Subcomponent.Builder",
        "  static interface Builder {",
        "    ChildComponent build();",
        "  }",
        "",
        "  @Subcomponent.Factory",
        "  static interface Factory {",
        "    ChildComponent create();",
        "  }",
        "}");
    CompilerTests.daggerCompiler(componentFile, childComponentFile)
        .compile(
            subject -> {
              subject.hasErrorCount(1);
              subject.hasErrorContaining(
                      String.format(
                          componentMessagesFor(SUBCOMPONENT).moreThanOne(),
                          "[test.ChildComponent.Builder, test.ChildComponent.Factory]"))
                  .onSource(childComponentFile);
            });
  }

  @Test
  public void testCreatorGenericsFails() {
    Source componentFile = preprocessedJavaSource("test.ParentComponent",
        "package test;",
        "",
        "import dagger.Component;",
        "import javax.inject.Provider;",
        "",
        "@Component",
        "interface ParentComponent {",
        "  ChildComponent.Builder build();",
        "}");
    Source childComponentFile = preprocessedJavaSource("test.ChildComponent",
        "package test;",
        "",
        "import dagger.Subcomponent;",
        "",
        "@Subcomponent",
        "interface ChildComponent {",
        "  @Subcomponent.Builder",
        "  interface Builder<T> {",
        "     ChildComponent build();",
        "  }",
        "}");
    CompilerTests.daggerCompiler(componentFile, childComponentFile)
        .compile(
            subject -> {
              subject.hasErrorCount(1);
              subject.hasErrorContaining(messages.generics()).onSource(childComponentFile);
            });
  }

  @Test
  public void testCreatorNotInComponentFails() {
    Source builder = preprocessedJavaSource("test.Builder",
        "package test;",
        "",
        "import dagger.Subcomponent;",
        "",
        "@Subcomponent.Builder",
        "interface Builder {}");
    CompilerTests.daggerCompiler(builder)
        .compile(
            subject -> {
              subject.hasErrorCount(1);
              subject.hasErrorContaining(messages.mustBeInComponent()).onSource(builder);
            });
  }

  @Test
  public void testCreatorMissingFactoryMethodFails() {
    Source componentFile =
        preprocessedJavaSource(
            "test.ParentComponent",
            "package test;",
            "",
            "import dagger.Component;",
            "import javax.inject.Provider;",
            "",
            "@Component",
            "interface ParentComponent {",
            "  ChildComponent.Builder childComponentBuilder();",
            "}");
    Source childComponentFile = preprocessedJavaSource("test.ChildComponent",
        "package test;",
        "",
        "import dagger.Subcomponent;",
        "",
        "@Subcomponent",
        "interface ChildComponent {",
        "  @Subcomponent.Builder",
        "  interface Builder {}",
        "}");
    CompilerTests.daggerCompiler(componentFile, childComponentFile)
        .compile(
            subject -> {
              subject.hasErrorCount(1);
              subject.hasErrorContaining(messages.missingFactoryMethod())
                  .onSource(childComponentFile);
            });
  }

  @Test
  public void testPrivateCreatorFails() {
    Source childComponentFile = preprocessedJavaSource("test.ChildComponent",
        "package test;",
        "",
        "import dagger.Subcomponent;",
        "",
        "@Subcomponent",
        "abstract class ChildComponent {",
        "  @Subcomponent.Builder",
        "  private interface Builder {}",
        "}");
    CompilerTests.daggerCompiler(childComponentFile)
        .compile(
            subject -> {
              subject.hasErrorCount(1);
              subject.hasErrorContaining(messages.isPrivate()).onSource(childComponentFile);
            });
  }

  @Test
  public void testNonStaticCreatorFails() {
    Source childComponentFile = preprocessedJavaSource("test.ChildComponent",
        "package test;",
        "",
        "import dagger.Subcomponent;",
        "",
        "@Subcomponent",
        "abstract class ChildComponent {",
        "  @Subcomponent.Builder",
        "  abstract class Builder {}",
        "}");
    CompilerTests.daggerCompiler(childComponentFile)
        .compile(
            subject -> {
              subject.hasErrorCount(1);
              subject.hasErrorContaining(messages.mustBeStatic()).onSource(childComponentFile);
            });
  }

  @Test
  public void testNonAbstractCreatorFails() {
    Source childComponentFile = preprocessedJavaSource("test.ChildComponent",
        "package test;",
        "",
        "import dagger.Subcomponent;",
        "",
        "@Subcomponent",
        "abstract class ChildComponent {",
        "  @Subcomponent.Builder",
        "  static class Builder {}",
        "}");
    CompilerTests.daggerCompiler(childComponentFile)
        .compile(
            subject -> {
              subject.hasErrorCount(1);
              subject.hasErrorContaining(messages.mustBeAbstract())
                  .onSource(childComponentFile);
            });
  }

  @Test
  public void testCreatorOneConstructorWithArgsFails() {
    Source childComponentFile = preprocessedJavaSource("test.ChildComponent",
        "package test;",
        "",
        "import dagger.Subcomponent;",
        "",
        "@Subcomponent",
        "abstract class ChildComponent {",
        "  @Subcomponent.Builder",
        "  static abstract class Builder {",
        "    Builder(String unused) {}",
        "    abstract ChildComponent build();",
        "  }",
        "}");
    CompilerTests.daggerCompiler(childComponentFile)
        .compile(
            subject -> {
              subject.hasErrorCount(1);
              subject.hasErrorContaining(messages.invalidConstructor())
                  .onSource(childComponentFile);
            });
  }

  @Test
  public void testCreatorMoreThanOneConstructorFails() {
    Source childComponentFile = preprocessedJavaSource("test.ChildComponent",
        "package test;",
        "",
        "import dagger.Subcomponent;",
        "",
        "@Subcomponent",
        "abstract class ChildComponent {",
        "  @Subcomponent.Builder",
        "  static abstract class Builder {",
        "    Builder() {}",
        "    Builder(String unused) {}",
        "    abstract ChildComponent build();",
        "  }",
        "}");
    CompilerTests.daggerCompiler(childComponentFile)
        .compile(
            subject -> {
              subject.hasErrorCount(1);
              subject.hasErrorContaining(messages.invalidConstructor())
                  .onSource(childComponentFile);
            });
  }

  @Test
  public void testCreatorEnumFails() {
    Source childComponentFile = preprocessedJavaSource("test.ChildComponent",
        "package test;",
        "",
        "import dagger.Subcomponent;",
        "",
        "@Subcomponent",
        "abstract class ChildComponent {",
        "  @Subcomponent.Builder",
        "  enum Builder {}",
        "}");
    CompilerTests.daggerCompiler(childComponentFile)
        .compile(
            subject -> {
              subject.hasErrorCount(1);
              subject.hasErrorContaining(messages.mustBeClassOrInterface())
                  .onSource(childComponentFile);
            });
  }

  @Test
  public void testCreatorFactoryMethodReturnsWrongTypeFails() {
    Source childComponentFile = preprocessedJavaSource("test.ChildComponent",
        "package test;",
        "",
        "import dagger.Subcomponent;",
        "",
        "@Subcomponent",
        "abstract class ChildComponent {",
        "  @Subcomponent.Builder",
        "  interface Builder {",
        "    String build();",
        "  }",
        "}");
    CompilerTests.daggerCompiler(childComponentFile)
        .compile(
            subject -> {
              subject.hasErrorCount(1);
              subject.hasErrorContaining(messages.factoryMethodMustReturnComponentType())
                  .onSource(childComponentFile)
                  .onLine(9);
            });
  }

  @Test
  public void testInheritedCreatorFactoryMethodReturnsWrongTypeFails() {
    Source childComponentFile = preprocessedJavaSource("test.ChildComponent",
        "package test;",
        "",
        "import dagger.Subcomponent;",
        "",
        "@Subcomponent",
        "abstract class ChildComponent {",
        "  interface Parent {",
        "    String build();",
        "  }",
        "",
        "  @Subcomponent.Builder",
        "  interface Builder extends Parent {}",
        "}");

    CompilerTests.daggerCompiler(childComponentFile)
        .compile(
            subject -> {
              subject.hasErrorCount(1);
              subject.hasErrorContaining(
                      String.format(
                          messages.inheritedFactoryMethodMustReturnComponentType(),
                          process("String test.ChildComponent.Parent.build()")))
                  .onSource(childComponentFile)
                  .onLine(12);
            });
  }

  @Test
  public void testTwoFactoryMethodsFails() {
    Source childComponentFile = preprocessedJavaSource("test.ChildComponent",
        "package test;",
        "",
        "import dagger.Subcomponent;",
        "",
        "@Subcomponent",
        "abstract class ChildComponent {",
        "  @Subcomponent.Builder",
        "  interface Builder {",
        "    ChildComponent build();",
        "    ChildComponent build1();",
        "  }",
        "}");

    CompilerTests.daggerCompiler(childComponentFile)
        .compile(
            subject -> {
              subject.hasErrorCount(1);
              subject.hasErrorContaining(
                      String.format(
                          messages.twoFactoryMethods(),
                          process("test.ChildComponent test.ChildComponent.Builder.build()")))
                  .onSource(childComponentFile)
                  .onLine(10);
            });
  }

  @Test
  public void testInheritedTwoFactoryMethodsFails() {
    Source childComponentFile = preprocessedJavaSource("test.ChildComponent",
        "package test;",
        "",
        "import dagger.Subcomponent;",
        "",
        "@Subcomponent",
        "abstract class ChildComponent {",
        "  interface Parent {",
        "    ChildComponent build();",
        "    ChildComponent build1();",
        "  }",
        "",
        "  @Subcomponent.Builder",
        "  interface Builder extends Parent {}",
        "}");

    CompilerTests.daggerCompiler(childComponentFile)
        .compile(
            subject -> {
              subject.hasErrorCount(1);
              subject.hasErrorContaining(
                      String.format(
                          messages.inheritedTwoFactoryMethods(),
                          process("test.ChildComponent test.ChildComponent.Parent.build()"),
                          process("test.ChildComponent test.ChildComponent.Parent.build1()")))
                  .onSource(childComponentFile)
                  .onLine(13);
            });
  }

  @Test
  public void testMultipleSettersPerTypeFails() {
    Source moduleFile =
        CompilerTests.javaSource(
            "test.TestModule",
            "package test;",
            "",
            "import dagger.Module;",
            "import dagger.Provides;",
            "",
            "@Module",
            "final class TestModule {",
            "  @Provides String s() { return \"\"; }",
            "}");
    Source componentFile =
        preprocessedJavaSource(
            "test.ParentComponent",
            "package test;",
            "",
            "import dagger.Component;",
            "",
            "@Component",
            "interface ParentComponent {",
            "  ChildComponent.Builder childComponentBuilder();",
            "}");
    Source childComponentFile =
        javaFileBuilder("test.ChildComponent")
            .addLines(
                "package test;",
                "",
                "import dagger.Subcomponent;",
                "import javax.inject.Provider;",
                "",
                "@Subcomponent(modules = TestModule.class)",
                "abstract class ChildComponent {",
                "  abstract String s();",
                "")
            .addLinesIf(
                BUILDER,
                "  @Subcomponent.Builder",
                "  interface Builder {",
                "    ChildComponent build();",
                "    void set1(TestModule s);",
                "    void set2(TestModule s);",
                "  }")
            .addLinesIf(
                FACTORY,
                "  @Subcomponent.Factory",
                "  interface Factory {",
                "    ChildComponent create(TestModule m1, TestModule m2);",
                "  }")
            .addLines( //
                "}")
            .buildSource();

    String elements =
        creatorKind.equals(BUILDER)
            ? "[void test.ChildComponent.Builder.set1(test.TestModule), "
                + "void test.ChildComponent.Builder.set2(test.TestModule)]"
            : "[test.TestModule m1, test.TestModule m2]";
    CompilerTests.daggerCompiler(moduleFile, componentFile, childComponentFile)
        .compile(
            subject -> {
              subject.hasErrorCount(1);
              subject.hasErrorContaining(
                  String.format(
                      messages.multipleSettersForModuleOrDependencyType(),
                      "test.TestModule",
                      elements))
                  .onSource(childComponentFile)
                  .onLine(11);
            });
  }

  @Test
  public void testMultipleSettersPerTypeIncludingResolvedGenericsFails() {
    Source moduleFile =
        CompilerTests.javaSource(
            "test.TestModule",
            "package test;",
            "",
            "import dagger.Module;",
            "import dagger.Provides;",
            "",
            "@Module",
            "final class TestModule {",
            "  @Provides String s() { return \"\"; }",
            "}");
    Source componentFile =
        preprocessedJavaSource(
            "test.ParentComponent",
            "package test;",
            "",
            "import dagger.Component;",
            "",
            "@Component",
            "interface ParentComponent {",
            "  ChildComponent.Builder childComponentBuilder();",
            "}");
    Source childComponentFile =
        javaFileBuilder("test.ChildComponent")
            .addLines(
                "package test;",
                "",
                "import dagger.Subcomponent;",
                "import javax.inject.Provider;",
                "",
                "@Subcomponent(modules = TestModule.class)",
                "abstract class ChildComponent {",
                "  abstract String s();",
                "")
            .addLinesIf(
                BUILDER,
                "  interface Parent<T> {",
                "    void set1(T t);",
                "  }",
                "",
                "  @Subcomponent.Builder",
                "  interface Builder extends Parent<TestModule> {",
                "    ChildComponent build();",
                "    void set2(TestModule s);",
                "  }")
            .addLinesIf(
                FACTORY,
                "  interface Parent<C, T> {",
                "    C create(TestModule m1, T t);",
                "  }",
                "",
                "  @Subcomponent.Factory",
                "  interface Factory extends Parent<ChildComponent, TestModule> {}")
            .addLines( //
                "}")
            .buildSource();

    String elements =
        creatorKind.equals(BUILDER)
            ? "[void test.ChildComponent.Builder.set1(test.TestModule), "
                + "void test.ChildComponent.Builder.set2(test.TestModule)]"
            : "[test.TestModule m1, test.TestModule t]";
    CompilerTests.daggerCompiler(moduleFile, componentFile, childComponentFile)
        .compile(
            subject -> {
              subject.hasErrorCount(1);
              subject.hasErrorContaining(
                  String.format(
                      messages.multipleSettersForModuleOrDependencyType(),
                      "test.TestModule",
                      elements))
                  .onSource(childComponentFile)
                  .onLine(15);
            });
  }

  @Test
  public void testMultipleSettersPerBoundInstanceTypeFails() {
    Source componentFile =
        preprocessedJavaSource(
            "test.ParentComponent",
            "package test;",
            "",
            "import dagger.Component;",
            "",
            "@Component",
            "interface ParentComponent {",
            "  ChildComponent.Builder childComponentBuilder();",
            "}");
    Source childComponentFile =
        javaFileBuilder("test.ChildComponent")
            .addLines(
                "package test;",
                "",
                "import dagger.BindsInstance;",
                "import dagger.Subcomponent;",
                "",
                "@Subcomponent",
                "abstract class ChildComponent {",
                "  abstract String s();",
                "")
            .addLinesIf(
                BUILDER,
                "  @Subcomponent.Builder",
                "  interface Builder {",
                "    ChildComponent build();",
                "    @BindsInstance void set1(String s);",
                "    @BindsInstance void set2(String s);",
                "  }")
            .addLinesIf(
                FACTORY,
                "  @Subcomponent.Factory",
                "  interface Factory {",
                "    ChildComponent create(",
                "        @BindsInstance String s1, @BindsInstance String s2);",
                "  }")
            .addLines( //
                "}")
            .buildSource();

    String firstBinding = creatorKind.equals(FACTORY)
        ? "ChildComponent.Factory.create(s1, …)"
        : "@BindsInstance void ChildComponent.Builder.set1(String)";
    String secondBinding = creatorKind.equals(FACTORY)
        ? "ChildComponent.Factory.create(…, s2)"
        : "@BindsInstance void ChildComponent.Builder.set2(String)";
    CompilerTests.daggerCompiler(componentFile, childComponentFile)
        .compile(
            subject -> {
              subject.hasErrorCount(1);
              subject.hasErrorContaining("String is bound multiple times:");
              subject.hasErrorContaining("    " + firstBinding);
              subject.hasErrorContaining("    " + secondBinding);
              subject.hasErrorContaining("    in component: [ParentComponent → ChildComponent]")
                  .onSource(componentFile)
                  .onLineContaining("interface ParentComponent {");
            });
  }

  @Test
  public void testExtraSettersFails() {
    Source componentFile = preprocessedJavaSource("test.ParentComponent",
        "package test;",
        "",
        "import dagger.Component;",
        "import javax.inject.Provider;",
        "",
        "@Component",
        "interface ParentComponent {",
        "  ChildComponent.Builder build();",
        "}");
    Source childComponentFile =
        javaFileBuilder("test.ChildComponent")
            .addLines(
                "package test;",
                "",
                "import dagger.Subcomponent;",
                "import javax.inject.Provider;",
                "",
                "@Subcomponent",
                "abstract class ChildComponent {")
            .addLinesIf(
                BUILDER,
                "  @Subcomponent.Builder",
                "  interface Builder {",
                "    ChildComponent build();",
                "    void set1(String s);",
                "    void set2(Integer s);",
                "  }")
            .addLinesIf(
                FACTORY,
                "  @Subcomponent.Factory",
                "  interface Factory {",
                "    ChildComponent create(String s, Integer i);",
                "  }")
            .addLines("}")
            .buildSource();

    String elements =
        creatorKind.equals(FACTORY)
            ? "[String s, Integer i]"
            : "[void test.ChildComponent.Builder.set1(String),"
                + " void test.ChildComponent.Builder.set2(Integer)]";
    CompilerTests.daggerCompiler(componentFile, childComponentFile)
        .compile(
            subject -> {
              subject.hasErrorCount(1);
              subject.hasErrorContaining(String.format(messages.extraSetters(), elements))
                  .onSource(childComponentFile)
                  .onLine(9);
            });
  }

  @Test
  public void testMissingSettersFail() {
    Source moduleFile =
        CompilerTests.javaSource(
            "test.TestModule",
            "package test;",
            "",
            "import dagger.Module;",
            "import dagger.Provides;",
            "",
            "@Module",
            "final class TestModule {",
            "  TestModule(String unused) {}",
            "  @Provides String s() { return null; }",
            "}");
    Source module2File =
        CompilerTests.javaSource(
            "test.Test2Module",
            "package test;",
            "",
            "import dagger.Module;",
            "import dagger.Provides;",
            "",
            "@Module",
            "final class Test2Module {",
            "  @Provides Integer i() { return null; }",
            "}");
    Source module3File =
        CompilerTests.javaSource(
            "test.Test3Module",
            "package test;",
            "",
            "import dagger.Module;",
            "import dagger.Provides;",
            "",
            "@Module",
            "final class Test3Module {",
            "  Test3Module(String unused) {}",
            "  @Provides Double d() { return null; }",
            "}");
    Source componentFile =
        preprocessedJavaSource(
            "test.ParentComponent",
            "package test;",
            "",
            "import dagger.Component;",
            "import javax.inject.Provider;",
            "",
            "@Component",
            "interface ParentComponent {",
            "  ChildComponent.Builder build();",
            "}");
    Source childComponentFile =
        preprocessedJavaSource(
            "test.ChildComponent",
            "package test;",
            "",
            "import dagger.Subcomponent;",
            "",
            "@Subcomponent(modules = {TestModule.class, Test2Module.class, Test3Module.class})",
            "interface ChildComponent {",
            "  String string();",
            "  Integer integer();",
            "",
            "  @Subcomponent.Builder",
            "  interface Builder {",
            "    ChildComponent build();",
            "  }",
            "}");

    CompilerTests.daggerCompiler(
            moduleFile, module2File, module3File, componentFile, childComponentFile)
        .compile(
            subject -> {
              subject.hasErrorCount(1);
              subject.hasErrorContaining(
                      // Ignores Test2Module because we can construct it ourselves.
                      // TODO(sameb): Ignore Test3Module because it's not used within transitive
                      // dependencies.
                      String.format(
                          messages.missingSetters(),
                          "[test.TestModule, test.Test3Module]"))
                  .onSource(childComponentFile)
                  .onLine(11);
            });
  }

  @Test
  public void covariantFactoryMethodReturnType() {
    Source foo =
        CompilerTests.javaSource(
            "test.Foo",
            "package test;",
            "",
            "import javax.inject.Inject;",
            "",
            "class Foo {",
            "  @Inject Foo() {}",
            "}");
    Source supertype =
        CompilerTests.javaSource(
            "test.Supertype",
            "package test;",
            "",
            "interface Supertype {",
            "  Foo foo();",
            "}");

    Source subcomponent =
        preprocessedJavaSource(
            "test.HasSupertype",
            "package test;",
            "",
            "import dagger.Subcomponent;",
            "",
            "@Subcomponent",
            "interface HasSupertype extends Supertype {",
            "  @Subcomponent.Builder",
            "  interface Builder {",
            "    Supertype build();",
            "  }",
            "}");

    CompilerTests.daggerCompiler(foo, supertype, subcomponent)
        .compile(
            subject -> {
              subject.hasErrorCount(0);
              subject.hasWarningCount(0);
            });
  }

  @Test
  public void covariantFactoryMethodReturnType_hasNewMethod() {
    Source foo =
        CompilerTests.javaSource(
            "test.Foo",
            "package test;",
            "",
            "import javax.inject.Inject;",
            "",
            "class Foo {",
            "  @Inject Foo() {}",
            "}");
    Source bar =
        CompilerTests.javaSource(
            "test.Bar",
            "package test;",
            "",
            "import javax.inject.Inject;",
            "",
            "class Bar {",
            "  @Inject Bar() {}",
            "}");
    Source supertype =
        CompilerTests.javaSource(
            "test.Supertype",
            "package test;",
            "",
            "interface Supertype {",
            "  Foo foo();",
            "}");

    Source subcomponent =
        preprocessedJavaSource(
            "test.HasSupertype",
            "package test;",
            "",
            "import dagger.Subcomponent;",
            "",
            "@Subcomponent",
            "interface HasSupertype extends Supertype {",
            "  Bar bar();",
            "",
            "  @Subcomponent.Builder",
            "  interface Builder {",
            "    Supertype build();",
            "  }",
            "}");

    CompilerTests.daggerCompiler(foo, bar, supertype, subcomponent)
        .compile(
            subject -> {
              subject.hasErrorCount(0);
              subject.hasWarningCount(1);
              subject.hasWarningContaining(
                      process(
                          "test.HasSupertype.Builder.build() returns test.Supertype, but "
                              + "test.HasSupertype declares additional component method(s): bar(). "
                              + "In order to provide type-safe access to these methods, override "
                              + "build() to return test.HasSupertype"))
                  .onSource(subcomponent)
                  .onLine(11);
            });
  }

  @Test
  public void covariantFactoryMethodReturnType_hasNewMethod_buildMethodInherited() {
    Source foo =
        CompilerTests.javaSource(
            "test.Foo",
            "package test;",
            "",
            "import javax.inject.Inject;",
            "",
            "class Foo {",
            "  @Inject Foo() {}",
            "}");
    Source bar =
        CompilerTests.javaSource(
            "test.Bar",
            "package test;",
            "",
            "import javax.inject.Inject;",
            "",
            "class Bar {",
            "  @Inject Bar() {}",
            "}");
    Source supertype =
        CompilerTests.javaSource(
            "test.Supertype",
            "package test;",
            "",
            "interface Supertype {",
            "  Foo foo();",
            "}");

    Source creatorSupertype =
        preprocessedJavaSource(
            "test.CreatorSupertype",
            "package test;",
            "",
            "interface CreatorSupertype {",
            "  Supertype build();",
            "}");

    Source subcomponent =
        preprocessedJavaSource(
            "test.HasSupertype",
            "package test;",
            "",
            "import dagger.Subcomponent;",
            "",
            "@Subcomponent",
            "interface HasSupertype extends Supertype {",
            "  Bar bar();",
            "",
            "  @Subcomponent.Builder",
            "  interface Builder extends CreatorSupertype {}",
            "}");

    CompilerTests.daggerCompiler(foo, bar, supertype, creatorSupertype, subcomponent)
        .compile(
            subject -> {
              subject.hasErrorCount(0);
              subject.hasWarningCount(1);
              subject.hasWarningContaining(
                  process(
                      "[test.CreatorSupertype.build()] test.HasSupertype.Builder.build() returns "
                          + "test.Supertype, but test.HasSupertype declares additional component "
                          + "method(s): bar(). In order to provide type-safe access to these "
                          + "methods, override build() to return test.HasSupertype"));
            });
  }
}