diff --git a/javatests/dagger/internal/codegen/HjarTest.java b/javatests/dagger/internal/codegen/HjarTest.java index 6c65d806417..88bee334538 100644 --- a/javatests/dagger/internal/codegen/HjarTest.java +++ b/javatests/dagger/internal/codegen/HjarTest.java @@ -17,9 +17,12 @@ package dagger.internal.codegen; import androidx.room3.compiler.processing.util.Source; +import com.google.common.base.Joiner; import com.google.common.collect.ImmutableMap; import dagger.testing.compile.CompilerTests; import dagger.testing.compile.CompilerTests.DaggerCompiler; +import dagger.testing.golden.GoldenFileRule; +import org.junit.Rule; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; @@ -27,12 +30,28 @@ /** Tests compilation with the {@code experimental_turbine_hjar} flag enabled. */ @RunWith(JUnit4.class) public class HjarTest { + private static final Joiner NEWLINES = Joiner.on('\n'); + + @Rule public GoldenFileRule goldenFileRule = new GoldenFileRule(); + /** Returns a {@link DaggerCompiler} with hjar generation enabled. */ private static DaggerCompiler daggerCompiler(Source... sources) { return CompilerTests.daggerCompiler(sources) .withProcessingOptions(ImmutableMap.of("experimental_turbine_hjar", "")); } + /** + * Returns a {@link DaggerCompiler} with both hjar generation and {@code + * generatedClassExtendsComponent} enabled. + */ + private static DaggerCompiler daggerCompilerExtendingComponent(Source... sources) { + return CompilerTests.daggerCompiler(sources) + .withProcessingOptions( + ImmutableMap.of( + "experimental_turbine_hjar", "", + "dagger.generatedClassExtendsComponent", "ENABLED")); + } + @Test public void componentTest() { Source component = @@ -48,7 +67,156 @@ public void componentTest() { " int getInt();", " void inject(String str);", "}"); - daggerCompiler(component).compile(subject -> subject.hasErrorCount(0)); + daggerCompiler(component) + .compile( + subject -> { + subject.hasErrorCount(0); + subject.generatedSource(goldenFileRule.goldenSource("test/DaggerMyComponent")); + }); + } + + @Test + public void componentWithModuleTest() { + Source module = + CompilerTests.javaSource( + "test.MyModule", + "package test;", + "", + "import dagger.Module;", + "import dagger.Provides;", + "", + "@Module", + "public final class MyModule {", + " private final String value;", + " public MyModule(String value) { this.value = value; }", + " @Provides String provideString() { return value; }", + "}"); + Source component = + CompilerTests.javaSource( + "test.MyComponent", + "package test;", + "", + "import dagger.Component;", + "", + "@Component(modules = MyModule.class)", + "public interface MyComponent {", + " String getString();", + "}"); + daggerCompiler(module, component) + .compile( + subject -> { + subject.hasErrorCount(0); + subject.generatedSource(goldenFileRule.goldenSource("test/DaggerMyComponent")); + }); + } + + @Test + public void componentExtendsInterface_allReturnTypesTest() { + Source component = + CompilerTests.javaSource( + "test.MyComponent", + "package test;", + "", + "import dagger.Component;", + "", + "@Component", + "interface MyComponent {", + " boolean getBoolean();", + // `char` is tested separately in componentExtendsInterface_charReturnTypeTest. + " byte getByte();", + " short getShort();", + " int getInt();", + " long getLong();", + " float getFloat();", + " double getDouble();", + " String getString();", + " Void getBoxedVoid();", + " int[] getIntArray();", + " void inject(String str);", + "}"); + daggerCompilerExtendingComponent(component) + .compile( + subject -> { + subject.hasErrorCount(0); + subject.generatedSource(goldenFileRule.goldenSource("test/DaggerMyComponent")); + }); + } + + @Test + public void componentExtendsInterface_charReturnTypeTest() { + Source component = + CompilerTests.javaSource( + "test.MyComponent", + "package test;", + "", + "import dagger.Component;", + "", + "@Component", + "interface MyComponent {", + " char getChar();", + "}"); + daggerCompilerExtendingComponent(component) + .compile( + subject -> { + subject.hasErrorCount(0); + // Use a targeted assertion instead of a golden file because HjarGenerator emits a + // literal NUL byte (U+0000) for char's default value, which causes diff/golden + // tooling to treat a golden file as binary or replace it with U+FFFD. + subject + .generatedSourceFileWithPath("test/DaggerMyComponent.java") + .contains( + NEWLINES.join( + " @Override", + " public char getChar() {", + " return '\0';", + " }")); + }); + } + + @Test + public void componentExtendsAbstractClass_requiresSuperCallTest() { + Source component = + CompilerTests.javaSource( + "test.MyComponent", + "package test;", + "", + "import dagger.Component;", + "", + "@Component", + "abstract class MyComponent {", + " private MyComponent() {}", + " protected MyComponent(String s, int i, boolean b) {}", + " abstract String getString();", + "}"); + daggerCompilerExtendingComponent(component) + .compile( + subject -> { + subject.hasErrorCount(0); + subject.generatedSource(goldenFileRule.goldenSource("test/DaggerMyComponent")); + }); + } + + @Test + public void componentExtendsAbstractClass_noArgConstructorOmitsSuperCallTest() { + Source component = + CompilerTests.javaSource( + "test.MyComponent", + "package test;", + "", + "import dagger.Component;", + "", + "@Component", + "abstract class MyComponent {", + " MyComponent() {}", + " MyComponent(String s) {}", + " abstract String getString();", + "}"); + daggerCompilerExtendingComponent(component) + .compile( + subject -> { + subject.hasErrorCount(0); + subject.generatedSource(goldenFileRule.goldenSource("test/DaggerMyComponent")); + }); } @Test diff --git a/javatests/dagger/internal/codegen/goldens/HjarTest/componentExtendsAbstractClass_noArgConstructorOmitsSuperCallTest/test.DaggerMyComponent b/javatests/dagger/internal/codegen/goldens/HjarTest/componentExtendsAbstractClass_noArgConstructorOmitsSuperCallTest/test.DaggerMyComponent new file mode 100644 index 00000000000..0556ab41909 --- /dev/null +++ b/javatests/dagger/internal/codegen/goldens/HjarTest/componentExtendsAbstractClass_noArgConstructorOmitsSuperCallTest/test.DaggerMyComponent @@ -0,0 +1,45 @@ +package test; + +import dagger.internal.DaggerGenerated; +import javax.annotation.processing.Generated; + +@DaggerGenerated +@Generated( + value = "dagger.internal.codegen.ComponentProcessor", + comments = "https://dagger.dev" +) +@SuppressWarnings({ + "unchecked", + "rawtypes", + "KotlinInternal", + "KotlinInternalInJava", + "cast", + "deprecation", + "nullness:initialization.field.uninitialized" +}) +final class DaggerMyComponent extends MyComponent { + private DaggerMyComponent() { + } + + @Override + String getString() { + return null; + } + + public static Builder builder() { + return null; + } + + public static MyComponent create() { + return null; + } + + static final class Builder { + private Builder() { + } + + public MyComponent build() { + return null; + } + } +} diff --git a/javatests/dagger/internal/codegen/goldens/HjarTest/componentExtendsAbstractClass_requiresSuperCallTest/test.DaggerMyComponent b/javatests/dagger/internal/codegen/goldens/HjarTest/componentExtendsAbstractClass_requiresSuperCallTest/test.DaggerMyComponent new file mode 100644 index 00000000000..654815a46c0 --- /dev/null +++ b/javatests/dagger/internal/codegen/goldens/HjarTest/componentExtendsAbstractClass_requiresSuperCallTest/test.DaggerMyComponent @@ -0,0 +1,46 @@ +package test; + +import dagger.internal.DaggerGenerated; +import javax.annotation.processing.Generated; + +@DaggerGenerated +@Generated( + value = "dagger.internal.codegen.ComponentProcessor", + comments = "https://dagger.dev" +) +@SuppressWarnings({ + "unchecked", + "rawtypes", + "KotlinInternal", + "KotlinInternalInJava", + "cast", + "deprecation", + "nullness:initialization.field.uninitialized" +}) +final class DaggerMyComponent extends MyComponent { + private DaggerMyComponent() { + super(null, 0, false); + } + + @Override + String getString() { + return null; + } + + public static Builder builder() { + return null; + } + + public static MyComponent create() { + return null; + } + + static final class Builder { + private Builder() { + } + + public MyComponent build() { + return null; + } + } +} diff --git a/javatests/dagger/internal/codegen/goldens/HjarTest/componentExtendsInterface_allReturnTypesTest/test.DaggerMyComponent b/javatests/dagger/internal/codegen/goldens/HjarTest/componentExtendsInterface_allReturnTypesTest/test.DaggerMyComponent new file mode 100644 index 00000000000..94b8fd591c3 --- /dev/null +++ b/javatests/dagger/internal/codegen/goldens/HjarTest/componentExtendsInterface_allReturnTypesTest/test.DaggerMyComponent @@ -0,0 +1,94 @@ +package test; + +import dagger.internal.DaggerGenerated; +import javax.annotation.processing.Generated; + +@DaggerGenerated +@Generated( + value = "dagger.internal.codegen.ComponentProcessor", + comments = "https://dagger.dev" +) +@SuppressWarnings({ + "unchecked", + "rawtypes", + "KotlinInternal", + "KotlinInternalInJava", + "cast", + "deprecation", + "nullness:initialization.field.uninitialized" +}) +final class DaggerMyComponent implements MyComponent { + private DaggerMyComponent() { + } + + @Override + public boolean getBoolean() { + return false; + } + + @Override + public byte getByte() { + return 0; + } + + @Override + public short getShort() { + return 0; + } + + @Override + public int getInt() { + return 0; + } + + @Override + public long getLong() { + return 0L; + } + + @Override + public float getFloat() { + return 0.0f; + } + + @Override + public double getDouble() { + return 0.0d; + } + + @Override + public String getString() { + return null; + } + + @Override + public Void getBoxedVoid() { + return null; + } + + @Override + public int[] getIntArray() { + return null; + } + + @Override + public void inject(String str) { + } + + public static Builder builder() { + return null; + } + + public static MyComponent create() { + return null; + } + + static final class Builder { + private Builder() { + } + + public MyComponent build() { + return null; + } + } +} diff --git a/javatests/dagger/internal/codegen/goldens/HjarTest/componentTest/test.DaggerMyComponent b/javatests/dagger/internal/codegen/goldens/HjarTest/componentTest/test.DaggerMyComponent new file mode 100644 index 00000000000..9dc735a3529 --- /dev/null +++ b/javatests/dagger/internal/codegen/goldens/HjarTest/componentTest/test.DaggerMyComponent @@ -0,0 +1,40 @@ +package test; + +import dagger.internal.DaggerGenerated; +import javax.annotation.processing.Generated; + +@DaggerGenerated +@Generated( + value = "dagger.internal.codegen.ComponentProcessor", + comments = "https://dagger.dev" +) +@SuppressWarnings({ + "unchecked", + "rawtypes", + "KotlinInternal", + "KotlinInternalInJava", + "cast", + "deprecation", + "nullness:initialization.field.uninitialized" +}) +final class DaggerMyComponent { + private DaggerMyComponent() { + } + + public static Builder builder() { + return null; + } + + public static MyComponent create() { + return null; + } + + static final class Builder { + private Builder() { + } + + public MyComponent build() { + return null; + } + } +} diff --git a/javatests/dagger/internal/codegen/goldens/HjarTest/componentWithModuleTest/test.DaggerMyComponent b/javatests/dagger/internal/codegen/goldens/HjarTest/componentWithModuleTest/test.DaggerMyComponent new file mode 100644 index 00000000000..9628cc0f68b --- /dev/null +++ b/javatests/dagger/internal/codegen/goldens/HjarTest/componentWithModuleTest/test.DaggerMyComponent @@ -0,0 +1,40 @@ +package test; + +import dagger.internal.DaggerGenerated; +import javax.annotation.processing.Generated; + +@DaggerGenerated +@Generated( + value = "dagger.internal.codegen.ComponentProcessor", + comments = "https://dagger.dev" +) +@SuppressWarnings({ + "unchecked", + "rawtypes", + "KotlinInternal", + "KotlinInternalInJava", + "cast", + "deprecation", + "nullness:initialization.field.uninitialized" +}) +public final class DaggerMyComponent { + private DaggerMyComponent() { + } + + public static Builder builder() { + return null; + } + + public static final class Builder { + private Builder() { + } + + public Builder myModule(MyModule myModule) { + return null; + } + + public MyComponent build() { + return null; + } + } +}