xref: /aosp_15_r20/external/dagger2/javatests/dagger/internal/codegen/DuplicateBindingsValidationTest.java (revision f585d8a307d0621d6060bd7e80091fdcbf94fe27)

/*
 * Copyright (C) 2018 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.TestUtils.message;
import static org.junit.Assume.assumeFalse;

import androidx.room.compiler.processing.XProcessingEnv;
import androidx.room.compiler.processing.util.Source;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
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 DuplicateBindingsValidationTest {

  @Parameters(name = "fullBindingGraphValidation={0}")
  public static ImmutableList<Object[]> parameters() {
    return ImmutableList.copyOf(new Object[][] {{false}, {true}});
  }

  private final boolean fullBindingGraphValidation;

  public DuplicateBindingsValidationTest(boolean fullBindingGraphValidation) {
    this.fullBindingGraphValidation = fullBindingGraphValidation;
  }

  @Test public void duplicateExplicitBindings_ProvidesAndComponentProvision() {
    assumeFalse(fullBindingGraphValidation);

    Source component =
        CompilerTests.javaSource(
            "test.Outer",
            "package test;",
            "",
            "import dagger.Component;",
            "import dagger.Module;",
            "import dagger.Provides;",
            "",
            "final class Outer {",
            "  interface A {}",
            "",
            "  interface B {}",
            "",
            "  @Module",
            "  static class AModule {",
            "    @Provides String provideString() { return \"\"; }",
            "    @Provides A provideA(String s) { return new A() {}; }",
            "  }",
            "",
            "  @Component(modules = AModule.class)",
            "  interface Parent {",
            "    A getA();",
            "  }",
            "",
            "  @Module",
            "  static class BModule {",
            "    @Provides B provideB(A a) { return new B() {}; }",
            "  }",
            "",
            "  @Component(dependencies = Parent.class, modules = { BModule.class, AModule.class})",
            "  interface Child {",
            "    B getB();",
            "  }",
            "}");

    CompilerTests.daggerCompiler(component)
        .withProcessingOptions(
            ImmutableMap.<String, String>builder()
                .putAll(fullBindingGraphValidationOption())
                .buildOrThrow())
        .compile(
            subject -> {
              subject.hasErrorCount(1);
              subject.hasErrorContaining(
                      message(
                          "Outer.A is bound multiple times:",
                          "    @Provides Outer.A Outer.AModule.provideA(String)",
                          "    Outer.A Outer.Parent.getA()"))
                  .onSource(component)
                  .onLineContaining("interface Child");
            });
  }

  @Test public void duplicateExplicitBindings_TwoProvidesMethods() {
    Source component =
        CompilerTests.javaSource(
            "test.Outer",
            "package test;",
            "",
            "import dagger.Component;",
            "import dagger.Module;",
            "import dagger.Provides;",
            "import javax.inject.Inject;",
            "",
            "final class Outer {",
            "  interface A {}",
            "",
            "  static class B {",
            "    @Inject B(A a) {}",
            "  }",
            "",
            "  @Module",
            "  static class Module1 {",
            "    @Provides A provideA1() { return new A() {}; }",
            "  }",
            "",
            "  @Module",
            "  static class Module2 {",
            "    @Provides String provideString() { return \"\"; }",
            "    @Provides A provideA2(String s) { return new A() {}; }",
            "  }",
            "",
            "  @Module(includes = { Module1.class, Module2.class})",
            "  abstract static class Module3 {}",
            "",
            "  @Component(modules = { Module1.class, Module2.class})",
            "  interface TestComponent {",
            "    A getA();",
            "    B getB();",
            "  }",
            "}");

    CompilerTests.daggerCompiler(component)
        .withProcessingOptions(
            ImmutableMap.<String, String>builder()
                .putAll(fullBindingGraphValidationOption())
                .buildOrThrow())
        .compile(
            subject -> {
              // The duplicate bindngs are also requested from B, but we don't want to report them
              // again.
              subject.hasErrorCount(fullBindingGraphValidation ? 2 : 1);

              subject.hasErrorContaining(
                      message(
                          "Outer.A is bound multiple times:",
                          "    @Provides Outer.A Outer.Module1.provideA1()",
                          "    @Provides Outer.A Outer.Module2.provideA2(String)"))
                  .onSource(component)
                  .onLineContaining("interface TestComponent");

              if (fullBindingGraphValidation) {
                subject.hasErrorContaining(
                        message(
                            "Outer.A is bound multiple times:",
                            "    @Provides Outer.A Outer.Module1.provideA1()",
                            "    @Provides Outer.A Outer.Module2.provideA2(String)"))
                    .onSource(component)
                    .onLineContaining("class Module3");
              }
            });
  }

  @Test
  public void duplicateExplicitBindings_ProvidesVsBinds() {
    Source component =
        CompilerTests.javaSource(
            "test.Outer",
            "package test;",
            "",
            "import dagger.Binds;",
            "import dagger.Component;",
            "import dagger.Module;",
            "import dagger.Provides;",
            "import javax.inject.Inject;",
            "",
            "final class Outer {",
            "  interface A {}",
            "",
            "  static final class B implements A {",
            "    @Inject B() {}",
            "  }",
            "",
            "  @Module",
            "  static class Module1 {",
            "    @Provides A provideA1() { return new A() {}; }",
            "  }",
            "",
            "  @Module",
            "  static abstract class Module2 {",
            "    @Binds abstract A bindA2(B b);",
            "  }",
            "",
            "  @Module(includes = { Module1.class, Module2.class})",
            "  abstract static class Module3 {}",
            "",
            "  @Component(modules = { Module1.class, Module2.class})",
            "  interface TestComponent {",
            "    A getA();",
            "  }",
            "}");

    CompilerTests.daggerCompiler(component)
        .withProcessingOptions(
            ImmutableMap.<String, String>builder()
                .putAll(fullBindingGraphValidationOption())
                .buildOrThrow())
        .compile(
            subject -> {
              String errorMessage =
                  message(
                      "Outer.A is bound multiple times:",
                      "    @Provides Outer.A Outer.Module1.provideA1()",
                      "    @Binds Outer.A Outer.Module2.bindA2(Outer.B)");
              if (fullBindingGraphValidation) {
                subject.hasErrorCount(2);
                subject.hasErrorContaining(errorMessage)
                    .onSource(component)
                    .onLineContaining("class Module3");
                subject.hasErrorContaining(errorMessage)
                    .onSource(component)
                    .onLineContaining("interface TestComponent");
              } else {
                subject.hasErrorCount(1);
                subject.hasErrorContaining(errorMessage)
                    .onSource(component)
                    .onLineContaining("interface TestComponent");
              }
            });
  }

  @Test
  public void duplicateExplicitBindings_multibindingsAndExplicitSets() {
    Source component =
        CompilerTests.javaSource(
            "test.Outer",
            "package test;",
            "",
            "import dagger.Binds;",
            "import dagger.Component;",
            "import dagger.Module;",
            "import dagger.Provides;",
            "import dagger.multibindings.IntoSet;",
            "import java.util.HashSet;",
            "import java.util.Set;",
            "import javax.inject.Qualifier;",
            "",
            "final class Outer {",
            "  @Qualifier @interface SomeQualifier {}",
            "",
            "  @Module",
            "  abstract static class TestModule1 {",
            "    @Provides @IntoSet static String stringSetElement() { return \"\"; }",
            "",
            "    @Binds",
            "    @IntoSet abstract String bindStringSetElement(@SomeQualifier String value);",
            "",
            "    @Provides @SomeQualifier",
            "    static String provideSomeQualifiedString() { return \"\"; }",
            "  }",
            "",
            "  @Module",
            "  static class TestModule2 {",
            "    @Provides Set<String> stringSet() { return new HashSet<String>(); }",
            "  }",
            "",
            "  @Module(includes = { TestModule1.class, TestModule2.class})",
            "  abstract static class TestModule3 {}",
            "",
            "  @Component(modules = { TestModule1.class, TestModule2.class })",
            "  interface TestComponent {",
            "    Set<String> getStringSet();",
            "  }",
            "}");

    CompilerTests.daggerCompiler(component)
        .withProcessingOptions(
            ImmutableMap.<String, String>builder()
                .putAll(fullBindingGraphValidationOption())
                .buildOrThrow())
        .compile(
            subject -> {
              String errorMessage =
                  message(
                      "Set<String> has incompatible bindings or declarations:",
                      "    Set bindings and declarations:",
                      "        @Binds @IntoSet String "
                          + "Outer.TestModule1.bindStringSetElement(@Outer.SomeQualifier String)",
                      "        @Provides @IntoSet String "
                          + "Outer.TestModule1.stringSetElement()",
                      "    Unique bindings and declarations:",
                      "        @Provides Set<String> Outer.TestModule2.stringSet()");
              if (fullBindingGraphValidation) {
                subject.hasErrorCount(2);
                subject.hasErrorContaining(errorMessage)
                    .onSource(component)
                    .onLineContaining("class TestModule3");
                subject.hasErrorContaining(errorMessage)
                    .onSource(component)
                    .onLineContaining("interface TestComponent");
              } else {
                subject.hasErrorCount(1);
                subject.hasErrorContaining(errorMessage)
                    .onSource(component)
                    .onLineContaining("interface TestComponent");
              }
            });
  }

  @Test
  public void duplicateExplicitBindings_multibindingsAndExplicitMaps() {
    Source component =
        CompilerTests.javaSource(
            "test.Outer",
            "package test;",
            "",
            "import dagger.Binds;",
            "import dagger.Component;",
            "import dagger.Module;",
            "import dagger.Provides;",
            "import dagger.multibindings.IntoMap;",
            "import dagger.multibindings.StringKey;",
            "import java.util.HashMap;",
            "import java.util.Map;",
            "import javax.inject.Qualifier;",
            "",
            "final class Outer {",
            "  @Qualifier @interface SomeQualifier {}",
            "",
            "  @Module",
            "  abstract static class TestModule1 {",
            "    @Provides @IntoMap",
            "    @StringKey(\"foo\")",
            "    static String stringMapEntry() { return \"\"; }",
            "",
            "    @Binds @IntoMap @StringKey(\"bar\")",
            "    abstract String bindStringMapEntry(@SomeQualifier String value);",
            "",
            "    @Provides @SomeQualifier",
            "    static String provideSomeQualifiedString() { return \"\"; }",
            "  }",
            "",
            "  @Module",
            "  static class TestModule2 {",
            "    @Provides Map<String, String> stringMap() {",
            "      return new HashMap<String, String>();",
            "    }",
            "  }",
            "",
            "  @Module(includes = { TestModule1.class, TestModule2.class})",
            "  abstract static class TestModule3 {}",
            "",
            "  @Component(modules = { TestModule1.class, TestModule2.class })",
            "  interface TestComponent {",
            "    Map<String, String> getStringMap();",
            "  }",
            "}");

    CompilerTests.daggerCompiler(component)
        .withProcessingOptions(
            ImmutableMap.<String, String>builder()
                .putAll(fullBindingGraphValidationOption())
                .buildOrThrow())
        .compile(
            subject -> {
              String errorMessage =
                  message(
                      "Map<String,String> has incompatible bindings or declarations:",
                      "    Map bindings and declarations:",
                      "        @Binds @IntoMap @StringKey(\"bar\") String"
                          + " Outer.TestModule1.bindStringMapEntry(@Outer.SomeQualifier String)",
                      "        @Provides @IntoMap @StringKey(\"foo\") String"
                          + " Outer.TestModule1.stringMapEntry()",
                      "    Unique bindings and declarations:",
                      "        @Provides Map<String,String> Outer.TestModule2.stringMap()");
              if (fullBindingGraphValidation) {
                subject.hasErrorCount(2);
                subject.hasErrorContaining(errorMessage)
                    .onSource(component)
                    .onLineContaining("class TestModule3");
                subject.hasErrorContaining(errorMessage)
                    .onSource(component)
                    .onLineContaining("interface TestComponent");
              } else {
                subject.hasErrorCount(1);
                subject.hasErrorContaining(errorMessage)
                    .onSource(component)
                    .onLineContaining("interface TestComponent");
              }
            });
  }

  @Test
  public void duplicateExplicitBindings_UniqueBindingAndMultibindingDeclaration_Set() {
    Source component =
        CompilerTests.javaSource(
            "test.Outer",
            "package test;",
            "",
            "import dagger.Component;",
            "import dagger.Module;",
            "import dagger.Provides;",
            "import dagger.multibindings.Multibinds;",
            "import java.util.HashSet;",
            "import java.util.Set;",
            "",
            "final class Outer {",
            "  @Module",
            "  abstract static class TestModule1 {",
            "    @Multibinds abstract Set<String> stringSet();",
            "  }",
            "",
            "  @Module",
            "  static class TestModule2 {",
            "    @Provides Set<String> stringSet() { return new HashSet<String>(); }",
            "  }",
            "",
            "  @Module(includes = { TestModule1.class, TestModule2.class})",
            "  abstract static class TestModule3 {}",
            "",
            "  @Component(modules = { TestModule1.class, TestModule2.class })",
            "  interface TestComponent {",
            "    Set<String> getStringSet();",
            "  }",
            "}");

    CompilerTests.daggerCompiler(component)
        .withProcessingOptions(
            ImmutableMap.<String, String>builder()
                .putAll(fullBindingGraphValidationOption())
                .buildOrThrow())
        .compile(
            subject -> {
              String errorMessage =
                  message(
                      "Set<String> has incompatible bindings or declarations:",
                      "    Set bindings and declarations:",
                      "        @Multibinds Set<String> Outer.TestModule1.stringSet()",
                      "    Unique bindings and declarations:",
                      "        @Provides Set<String> Outer.TestModule2.stringSet()");
              if (fullBindingGraphValidation) {
                subject.hasErrorCount(2);
                subject.hasErrorContaining(errorMessage)
                    .onSource(component)
                    .onLineContaining("class TestModule3");
                subject.hasErrorContaining(errorMessage)
                    .onSource(component)
                    .onLineContaining("interface TestComponent");
              } else {
                subject.hasErrorCount(1);
                subject.hasErrorContaining(errorMessage)
                    .onSource(component)
                    .onLineContaining("interface TestComponent");
              }
            });
  }

  @Test
  public void duplicateExplicitBindings_UniqueBindingAndMultibindingDeclaration_Map() {
    Source component =
        CompilerTests.javaSource(
            "test.Outer",
            "package test;",
            "",
            "import dagger.Component;",
            "import dagger.Module;",
            "import dagger.Provides;",
            "import dagger.multibindings.Multibinds;",
            "import java.util.HashMap;",
            "import java.util.Map;",
            "",
            "final class Outer {",
            "  @Module",
            "  abstract static class TestModule1 {",
            "    @Multibinds abstract Map<String, String> stringMap();",
            "  }",
            "",
            "  @Module",
            "  static class TestModule2 {",
            "    @Provides Map<String, String> stringMap() {",
            "      return new HashMap<String, String>();",
            "    }",
            "  }",
            "",
            "  @Module(includes = { TestModule1.class, TestModule2.class})",
            "  abstract static class TestModule3 {}",
            "",
            "  @Component(modules = { TestModule1.class, TestModule2.class })",
            "  interface TestComponent {",
            "    Map<String, String> getStringMap();",
            "  }",
            "}");

    CompilerTests.daggerCompiler(component)
        .withProcessingOptions(
            ImmutableMap.<String, String>builder()
                .putAll(fullBindingGraphValidationOption())
                .buildOrThrow())
        .compile(
            subject -> {
              String errorMessage =
                  message(
                      "Map<String,String> has incompatible bindings or declarations:",
                      "    Map bindings and declarations:",
                      "        @Multibinds Map<String,String> Outer.TestModule1.stringMap()",
                      "    Unique bindings and declarations:",
                      "        @Provides Map<String,String> Outer.TestModule2.stringMap()");
              if (fullBindingGraphValidation) {
                subject.hasErrorCount(2);
                subject.hasErrorContaining(errorMessage)
                    .onSource(component)
                    .onLineContaining("class TestModule3");
                subject.hasErrorContaining(errorMessage)
                    .onSource(component)
                    .onLineContaining("interface TestComponent");
              } else {
                subject.hasErrorCount(1);
                subject.hasErrorContaining(errorMessage)
                    .onSource(component)
                    .onLineContaining("interface TestComponent");
              }
            });
  }

  @Test public void duplicateBindings_TruncateAfterLimit() {
    Source component =
        CompilerTests.javaSource(
            "test.Outer",
            "package test;",
            "",
            "import dagger.Component;",
            "import dagger.Module;",
            "import dagger.Provides;",
            "import javax.inject.Inject;",
            "",
            "final class Outer {",
            "  interface A {}",
            "",
            "  @Module",
            "  static class Module01 {",
            "    @Provides A provideA() { return new A() {}; }",
            "  }",
            "",
            "  @Module",
            "  static class Module02 {",
            "    @Provides A provideA() { return new A() {}; }",
            "  }",
            "",
            "  @Module",
            "  static class Module03 {",
            "    @Provides A provideA() { return new A() {}; }",
            "  }",
            "",
            "  @Module",
            "  static class Module04 {",
            "    @Provides A provideA() { return new A() {}; }",
            "  }",
            "",
            "  @Module",
            "  static class Module05 {",
            "    @Provides A provideA() { return new A() {}; }",
            "  }",
            "",
            "  @Module",
            "  static class Module06 {",
            "    @Provides A provideA() { return new A() {}; }",
            "  }",
            "",
            "  @Module",
            "  static class Module07 {",
            "    @Provides A provideA() { return new A() {}; }",
            "  }",
            "",
            "  @Module",
            "  static class Module08 {",
            "    @Provides A provideA() { return new A() {}; }",
            "  }",
            "",
            "  @Module",
            "  static class Module09 {",
            "    @Provides A provideA() { return new A() {}; }",
            "  }",
            "",
            "  @Module",
            "  static class Module10 {",
            "    @Provides A provideA() { return new A() {}; }",
            "  }",
            "",
            "  @Module",
            "  static class Module11 {",
            "    @Provides A provideA() { return new A() {}; }",
            "  }",
            "",
            "  @Module",
            "  static class Module12 {",
            "    @Provides A provideA() { return new A() {}; }",
            "  }",
            "",
            "  @Module(includes = {",
            "    Module01.class,",
            "    Module02.class,",
            "    Module03.class,",
            "    Module04.class,",
            "    Module05.class,",
            "    Module06.class,",
            "    Module07.class,",
            "    Module08.class,",
            "    Module09.class,",
            "    Module10.class,",
            "    Module11.class,",
            "    Module12.class",
            "  })",
            "  abstract static class Modules {}",
            "",
            "  @Component(modules = {",
            "    Module01.class,",
            "    Module02.class,",
            "    Module03.class,",
            "    Module04.class,",
            "    Module05.class,",
            "    Module06.class,",
            "    Module07.class,",
            "    Module08.class,",
            "    Module09.class,",
            "    Module10.class,",
            "    Module11.class,",
            "    Module12.class",
            "  })",
            "  interface TestComponent {",
            "    A getA();",
            "  }",
            "}");

    CompilerTests.daggerCompiler(component)
        .withProcessingOptions(
            ImmutableMap.<String, String>builder()
                .putAll(fullBindingGraphValidationOption())
                .buildOrThrow())
        .compile(
            subject -> {
              subject.hasErrorCount(fullBindingGraphValidation ? 2 : 1);
              String errorMessage =
                  message(
                      "Outer.A is bound multiple times:",
                      "    @Provides Outer.A Outer.Module01.provideA()",
                      "    @Provides Outer.A Outer.Module02.provideA()",
                      "    @Provides Outer.A Outer.Module03.provideA()",
                      "    @Provides Outer.A Outer.Module04.provideA()",
                      "    @Provides Outer.A Outer.Module05.provideA()",
                      "    @Provides Outer.A Outer.Module06.provideA()",
                      "    @Provides Outer.A Outer.Module07.provideA()",
                      "    @Provides Outer.A Outer.Module08.provideA()",
                      "    @Provides Outer.A Outer.Module09.provideA()",
                      "    @Provides Outer.A Outer.Module10.provideA()",
                      "    and 2 others");

              subject.hasErrorContaining(errorMessage)
                  .onSource(component)
                  .onLineContaining("interface TestComponent");

              if (fullBindingGraphValidation) {
                subject.hasErrorContaining(errorMessage)
                    .onSource(component)
                    .onLineContaining("class Modules");
              }
            });
  }

  @Test
  public void childBindingConflictsWithParent() {
    Source aComponent =
        CompilerTests.javaSource(
            "test.A",
            "package test;",
            "",
            "import dagger.Component;",
            "import dagger.Module;",
            "import dagger.Provides;",
            "",
            "@Component(modules = A.AModule.class)",
            "interface A {",
            "  Object conflict();",
            "",
            "  B.Builder b();",
            "",
            "  @Module(subcomponents = B.class)",
            "  static class AModule {",
            "    @Provides static Object abConflict() {",
            "      return \"a\";",
            "    }",
            "  }",
            "}");
    Source bComponent =
        CompilerTests.javaSource(
            "test.B",
            "package test;",
            "",
            "import dagger.Module;",
            "import dagger.Provides;",
            "import dagger.Subcomponent;",
            "",
            "@Subcomponent(modules = B.BModule.class)",
            "interface B {",
            "  Object conflict();",
            "",
            "  @Subcomponent.Builder",
            "  interface Builder {",
            "    B build();",
            "  }",
            "",
            "  @Module",
            "  static class BModule {",
            "    @Provides static Object abConflict() {",
            "      return \"b\";",
            "    }",
            "  }",
            "}");

    CompilerTests.daggerCompiler(aComponent, bComponent)
        .withProcessingOptions(
            ImmutableMap.<String, String>builder()
                .putAll(fullBindingGraphValidationOption())
                .buildOrThrow())
        .compile(
            subject -> {
              String errorMessage =
                  message(
                      "Object is bound multiple times:",
                      "    @Provides Object test.A.AModule.abConflict()",
                      "    @Provides Object test.B.BModule.abConflict()");
              if (fullBindingGraphValidation) {
                subject.hasErrorCount(2);
                subject.hasErrorContaining("test.A.AModule has errors")
                    .onSource(aComponent)
                    .onLineContaining("@Component(");
                subject.hasErrorContaining(errorMessage)
                    .onSource(aComponent)
                    .onLineContaining("class AModule");
              } else {
                subject.hasErrorCount(1);
                subject.hasErrorContaining(errorMessage)
                    .onSource(aComponent)
                    .onLineContaining("interface A {");
              }
            });
  }

  @Test
  public void grandchildBindingConflictsWithGrandparent() {
    Source aComponent =
        CompilerTests.javaSource(
            "test.A",
            "package test;",
            "",
            "import dagger.Component;",
            "import dagger.Module;",
            "import dagger.Provides;",
            "",
            "@Component(modules = A.AModule.class)",
            "interface A {",
            "  Object conflict();",
            "",
            "  B.Builder b();",
            "",
            "  @Module(subcomponents = B.class)",
            "  static class AModule {",
            "    @Provides static Object acConflict() {",
            "      return \"a\";",
            "    }",
            "  }",
            "}");
    Source bComponent =
        CompilerTests.javaSource(
            "test.B",
            "package test;",
            "",
            "import dagger.Subcomponent;",
            "",
            "@Subcomponent",
            "interface B {",
            "  C.Builder c();",
            "",
            "  @Subcomponent.Builder",
            "  interface Builder {",
            "    B build();",
            "  }",
            "}");
    Source cComponent =
        CompilerTests.javaSource(
            "test.C",
            "package test;",
            "",
            "import dagger.Module;",
            "import dagger.Provides;",
            "import dagger.Subcomponent;",
            "",
            "@Subcomponent(modules = C.CModule.class)",
            "interface C {",
            "  Object conflict();",
            "",
            "  @Subcomponent.Builder",
            "  interface Builder {",
            "    C build();",
            "  }",
            "",
            "  @Module",
            "  static class CModule {",
            "    @Provides static Object acConflict() {",
            "      return \"c\";",
            "    }",
            "  }",
            "}");

    CompilerTests.daggerCompiler(aComponent, bComponent, cComponent)
        .withProcessingOptions(
            ImmutableMap.<String, String>builder()
                .putAll(fullBindingGraphValidationOption())
                .buildOrThrow())
        .compile(
            subject -> {
              String errorMessage =
                  message(
                      "Object is bound multiple times:",
                      "    @Provides Object test.A.AModule.acConflict()",
                      "    @Provides Object test.C.CModule.acConflict()");
              if (fullBindingGraphValidation) {
                subject.hasErrorCount(2);
                subject.hasErrorContaining("test.A.AModule has errors")
                    .onSource(aComponent)
                    .onLineContaining("@Component(");
                subject.hasErrorContaining(errorMessage)
                    .onSource(aComponent)
                    .onLineContaining("class AModule");
              } else {
                subject.hasErrorCount(1);
                subject.hasErrorContaining(errorMessage)
                    .onSource(aComponent)
                    .onLineContaining("interface A {");
              }
            });
  }

  @Test
  public void grandchildBindingConflictsWithChild() {
    Source aComponent =
        CompilerTests.javaSource(
            "test.A",
            "package test;",
            "",
            "import dagger.Component;",
            "",
            "@Component",
            "interface A {",
            "  B b();",
            "}");
    Source bComponent =
        CompilerTests.javaSource(
            "test.B",
            "package test;",
            "",
            "import dagger.Module;",
            "import dagger.Provides;",
            "import dagger.Subcomponent;",
            "",
            "@Subcomponent(modules = B.BModule.class)",
            "interface B {",
            "  Object conflict();",
            "",
            "  C.Builder c();",
            "",
            "  @Module(subcomponents = C.class)",
            "  static class BModule {",
            "    @Provides static Object bcConflict() {",
            "      return \"b\";",
            "    }",
            "  }",
            "}");
    Source cComponent =
        CompilerTests.javaSource(
            "test.C",
            "package test;",
            "",
            "import dagger.Module;",
            "import dagger.Provides;",
            "import dagger.Subcomponent;",
            "",
            "@Subcomponent(modules = C.CModule.class)",
            "interface C {",
            "  Object conflict();",
            "",
            "  @Subcomponent.Builder",
            "  interface Builder {",
            "    C build();",
            "  }",
            "",
            "  @Module",
            "  static class CModule {",
            "    @Provides static Object bcConflict() {",
            "      return \"c\";",
            "    }",
            "  }",
            "}");

    CompilerTests.daggerCompiler(aComponent, bComponent, cComponent)
        .withProcessingOptions(
            ImmutableMap.<String, String>builder()
                .putAll(fullBindingGraphValidationOption())
                .buildOrThrow())
        .compile(
            subject -> {
              String errorMessage =
                  message(
                      "Object is bound multiple times:",
                      "    @Provides Object test.B.BModule.bcConflict()",
                      "    @Provides Object test.C.CModule.bcConflict()");
              if (fullBindingGraphValidation) {
                subject.hasErrorCount(2);
                subject.hasErrorContaining("test.B.BModule has errors")
                    .onSource(bComponent)
                    .onLineContaining("@Subcomponent(modules = B.BModule.class)");
                subject.hasErrorContaining(errorMessage)
                    .onSource(bComponent)
                    .onLineContaining("class BModule");
              } else {
                subject.hasErrorCount(1);
                subject.hasErrorContaining(errorMessage)
                    .onSource(aComponent)
                    .onLineContaining("interface A {");
              }
            });
  }

  @Test
  public void childProvidesConflictsWithParentInjects() {
    assumeFalse(fullBindingGraphValidation);

    Source foo =
        CompilerTests.javaSource(
            "test.Foo",
            "package test;",
            "",
            "import java.util.Set;",
            "import javax.inject.Inject;",
            "",
            "final class Foo {",
            "  @Inject Foo(Set<String> strings) {}",
            "}");
    Source injected1 =
        CompilerTests.javaSource(
            "test.Injected1",
            "package test;",
            "",
            "import dagger.Component;",
            "import dagger.Module;",
            "import dagger.Provides;",
            "import dagger.multibindings.IntoSet;",
            "import java.util.Set;",
            "",
            "@Component(modules = Injected1.Injected1Module.class)",
            "interface Injected1 {",
            "  Foo foo();",
            "  Injected2 injected2();",
            "",
            "  @Module",
            "  interface Injected1Module {",
            "    @Provides @IntoSet static String string() {",
            "      return \"injected1\";",
            "    }",
            "  }",
            "}");
    Source injected2 =
        CompilerTests.javaSource(
            "test.Injected2",
            "package test;",
            "",
            "import dagger.Module;",
            "import dagger.Provides;",
            "import dagger.Subcomponent;",
            "import dagger.multibindings.IntoSet;",
            "import java.util.Set;",
            "",
            "@Subcomponent(modules = Injected2.Injected2Module.class)",
            "interface Injected2 {",
            "  Foo foo();",
            "  Provided1 provided1();",
            "",
            "  @Module",
            "  interface Injected2Module {",
            "    @Provides @IntoSet static String string() {",
            "      return \"injected2\";",
            "    }",
            "  }",
            "}");
    Source provided1 =
        CompilerTests.javaSource(
            "test.Provided1",
            "package test;",
            "",
            "import dagger.Module;",
            "import dagger.Provides;",
            "import dagger.Subcomponent;",
            "import dagger.multibindings.IntoSet;",
            "import java.util.Set;",
            "",
            "@Subcomponent(modules = Provided1.Provided1Module.class)",
            "interface Provided1 {",
            "  Foo foo();",
            "  Provided2 provided2();",
            "",
            "  @Module",
            "  static class Provided1Module {",
            "    @Provides static Foo provideFoo(Set<String> strings) {",
            "      return new Foo(strings);",
            "    }",
            "",
            "    @Provides @IntoSet static String string() {",
            "      return \"provided1\";",
            "    }",
            "  }",
            "}");
    Source provided2 =
        CompilerTests.javaSource(
            "test.Provided2",
            "package test;",
            "",
            "import dagger.Module;",
            "import dagger.Provides;",
            "import dagger.Subcomponent;",
            "import dagger.multibindings.IntoSet;",
            "",
            "@Subcomponent(modules = Provided2.Provided2Module.class)",
            "interface Provided2 {",
            "  Foo foo();",
            "",
            "  @Module",
            "  static class Provided2Module {",
            "    @Provides @IntoSet static String string() {",
            "      return \"provided2\";",
            "    }",
            "  }",
            "}");

    CompilerTests.daggerCompiler(foo, injected1, injected2, provided1, provided2)
        .compile(
            subject -> {
              subject.hasErrorCount(1);
              subject.hasErrorContaining(
                      message(
                          "Foo is bound multiple times:",
                          "    @Inject Foo(Set<String>) [Injected1]",
                          "    @Provides Foo Provided1.Provided1Module.provideFoo(Set<String>) "
                              + "[Injected1 → Injected2 → Provided1]"))
                  .onSource(injected1)
                  .onLineContaining("interface Injected1 {");
            });
  }

  @Test
  public void grandchildBindingConflictsWithParentWithNullableViolationAsWarning() {
    Source parentConflictsWithChild =
        CompilerTests.javaSource(
            "test.ParentConflictsWithChild",
            "package test;",
            "",
            "import dagger.Component;",
            "import dagger.Module;",
            "import dagger.Provides;",
            "import javax.annotation.Nullable;",
            "",
            "@Component(modules = ParentConflictsWithChild.ParentModule.class)",
            "interface ParentConflictsWithChild {",
            "  Child.Builder child();",
            "",
            "  @Module(subcomponents = Child.class)",
            "  static class ParentModule {",
            "    @Provides @Nullable static Object nullableParentChildConflict() {",
            "      return \"parent\";",
            "    }",
            "  }",
            "}");
    Source child =
        CompilerTests.javaSource(
            "test.Child",
            "package test;",
            "",
            "import dagger.Module;",
            "import dagger.Provides;",
            "import dagger.Subcomponent;",
            "",
            "@Subcomponent(modules = Child.ChildModule.class)",
            "interface Child {",
            "  Object parentChildConflictThatViolatesNullability();",
            "",
            "  @Subcomponent.Builder",
            "  interface Builder {",
            "    Child build();",
            "  }",
            "",
            "  @Module",
            "  static class ChildModule {",
            "    @Provides static Object nonNullableParentChildConflict() {",
            "      return \"child\";",
            "    }",
            "  }",
            "}");

    CompilerTests.daggerCompiler(parentConflictsWithChild, child)
        .withProcessingOptions(
            ImmutableMap.<String, String>builder()
                .put("dagger.nullableValidation", "WARNING")
                .putAll(fullBindingGraphValidationOption())
                .buildOrThrow())
        .compile(
            subject -> {
              String errorMessage =
                  message(
                      "Object is bound multiple times:",
                      "    @Provides Object Child.ChildModule.nonNullableParentChildConflict()",
                      "    @Provides @Nullable Object"
                          + " ParentConflictsWithChild.ParentModule.nullableParentChildConflict()");
              if (fullBindingGraphValidation) {
                subject.hasErrorCount(2);
                subject.hasErrorContaining(errorMessage)
                    .onSource(parentConflictsWithChild)
                    .onLineContaining("class ParentModule");
                subject.hasErrorContaining(
                        "Object is not nullable, but is being provided by @Provides @Nullable "
                            + "Object")
                    .onSource(parentConflictsWithChild)
                    .onLineContaining("class ParentModule");
              } else {
                subject.hasErrorCount(1);
                subject.hasErrorContaining(errorMessage)
                    .onSource(parentConflictsWithChild)
                    .onLineContaining("interface ParentConflictsWithChild");
              }
            });
  }

  private ImmutableMap<String, String> fullBindingGraphValidationOption() {
    return ImmutableMap.of(
        "dagger.fullBindingGraphValidation",
        fullBindingGraphValidation ? "ERROR" : "NONE");
  }

  @Test
  public void reportedInParentAndChild() {
    Source parent =
        CompilerTests.javaSource(
            "test.Parent",
            "package test;",
            "",
            "import dagger.Component;",
            "",
            "@Component(modules = ParentModule.class)",
            "interface Parent {",
            "  Child.Builder childBuilder();",
            "  String duplicated();",
            "}");
    Source parentModule =
        CompilerTests.javaSource(
            "test.ParentModule",
            "package test;",
            "",
            "import dagger.BindsOptionalOf;",
            "import dagger.Module;",
            "import dagger.Provides;",
            "import java.util.Optional;",
            "",
            "@Module",
            "interface ParentModule {",
            "  @Provides static String one(Optional<Object> optional) { return \"one\"; }",
            "  @Provides static String two() { return \"two\"; }",
            "  @BindsOptionalOf Object optional();",
            "}");
    Source child =
        CompilerTests.javaSource(
            "test.Child",
            "package test;",
            "",
            "import dagger.Subcomponent;",
            "",
            "@Subcomponent(modules = ChildModule.class)",
            "interface Child {",
            "  String duplicated();",
            "",
            "  @Subcomponent.Builder",
            "  interface Builder {",
            "    Child build();",
            "  }",
            "}");
    Source childModule =
        CompilerTests.javaSource(
            "test.ChildModule",
            "package test;",
            "",
            "import dagger.Module;",
            "import dagger.Provides;",
            "import java.util.Optional;",
            "",
            "@Module",
            "interface ChildModule {",
            "  @Provides static Object object() { return \"object\"; }",
            "}");
    CompilerTests.daggerCompiler(parent, parentModule, child, childModule)
        .compile(
            subject -> {
              subject.hasErrorCount(1);
              subject.hasErrorContaining("String is bound multiple times")
                  .onSource(parent)
                  .onLineContaining("interface Parent");
            });
  }

  // Tests the format of the error for a somewhat complex binding method.
  @Test
  public void formatTest() {
    Source modules =
        CompilerTests.javaSource(
            "test.Modules",
            "package test;",
            "",
            "import com.google.common.collect.ImmutableList;",
            "import dagger.Module;",
            "import dagger.Provides;",
            "import javax.inject.Singleton;",
            "",
            "interface Modules {",
            "  @interface Foo {",
            "    Class<?> bar();",
            "  }",
            "",
            "  @Module",
            "  interface Module1 {",
            "    @Provides",
            "    @Singleton",
            "    @Foo(bar = String.class)",
            "    static String foo(",
            "        @SuppressWarnings(\"unused\") int a,",
            "        @SuppressWarnings(\"unused\") ImmutableList<Boolean> blah) {",
            "      return \"\";",
            "    }",
            "  }",
            "",
            "  @Module",
            "  interface Module2 {",
            "    @Provides",
            "    @Singleton",
            "    @Foo(bar = String.class)",
            "    static String foo(",
            "        @SuppressWarnings(\"unused\") int a,",
            "        @SuppressWarnings(\"unused\") ImmutableList<Boolean> blah) {",
            "      return \"\";",
            "    }",
            "  }",
            "}");
    Source component =
        CompilerTests.javaSource(
            "test.TestComponent",
            "package test;",
            "",
            "import dagger.BindsInstance;",
            "import dagger.Component;",
            "import javax.inject.Singleton;",
            "",
            "@Singleton",
            "@Component(modules = {Modules.Module1.class, Modules.Module2.class})",
            "interface TestComponent {",
            "  @Modules.Foo(bar = String.class) String foo();",
            "}");
    CompilerTests.daggerCompiler(modules, component)
        .compile(
            subject -> {
              subject.hasErrorCount(1);
              subject.hasErrorContaining(
                  String.format(
                      String.join(
                          "\n",
                          "String is bound multiple times:",
                          "    @Provides @Singleton @Modules.Foo(%1$s) String "
                              + "Modules.Module1.foo(int, ImmutableList<Boolean>)",
                          "    @Provides @Singleton @Modules.Foo(%1$s) String "
                              + "Modules.Module2.foo(int, ImmutableList<Boolean>)"),
                      // TODO(b/241293838): KSP and java should match after this is fixed.
                      CompilerTests.backend(subject) == XProcessingEnv.Backend.KSP
                          ? "bar=String"
                          : "bar = String.class"));
            });
  }
}