javatests/dagger/functional/kotlinsrc/builder/BuilderTest.kt - platform/external/dagger2 - Git at Google

 /*
  * Copyright (C) 2022 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.functional.kotlinsrc.builder

 import com.google.common.truth.Truth.assertThat
 import dagger.Component
 import dagger.Module
 import dagger.Provides
 import dagger.Subcomponent
 import java.lang.annotation.Retention
 import java.lang.annotation.RetentionPolicy
 import javax.inject.Inject
 import javax.inject.Provider
 import javax.inject.Scope
 import javax.inject.Singleton
 import org.junit.Assert.fail
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.junit.runners.JUnit4

 @RunWith(JUnit4::class)
 class BuilderTest {
   @Subcomponent(
     modules =
       [
         StringModule::class,
         IntModuleIncludingDoubleAndFloat::class,
         LongModule::class,
         ByteModule::class
       ]
   )
   internal interface TestChildComponentWithBuilderAbstractClass {
     fun s(): String
     fun i(): Int
     fun l(): Long
     fun f(): Float
     fun d(): Double
     fun b(): Byte
     abstract class SharedBuilder<B, C, M1, M2> {
       abstract fun build(): C // Test resolving return type of build()
       abstract fun setM1(m1: M1): B // Test resolving return type & param of setter
       abstract fun setM2(m2: M2): SharedBuilder<B, C, M1, M2> // Test being overridden
       abstract fun setM3(doubleModule: DoubleModule) // Test being overridden
       abstract fun set(
         floatModule: FloatModule
       ): SharedBuilder<B, C, M1, M2> // Test returning supertype.
     }

     @Subcomponent.Builder
     abstract class Builder :
       TestChildComponentWithBuilderAbstractClass.SharedBuilder<
         Builder,
         TestChildComponentWithBuilderAbstractClass,
         StringModule,
         IntModuleIncludingDoubleAndFloat
       >() {
       abstract override fun setM2(m2: IntModuleIncludingDoubleAndFloat): Builder // Test covariance
       abstract override fun setM3(doubleModule: DoubleModule) // Test simple overrides allowed
       abstract fun set(byteModule: ByteModule) // Note we're missing LongModule -- it's implicit
     }
   }

   @Subcomponent(
     modules =
       [
         StringModule::class,
         IntModuleIncludingDoubleAndFloat::class,
         LongModule::class,
         ByteModule::class
       ]
   )
   internal interface TestChildComponentWithBuilderInterface {
     fun s(): String
     fun i(): Int
     fun l(): Long
     fun f(): Float
     fun d(): Double
     fun b(): Byte
     interface SharedBuilder<B, C, M1, M2> {
       fun build(): C // Test resolving return type of build()
       fun setM1(m1: M1): B // Test resolving return type & param of setter
       fun setM2(m2: M2): SharedBuilder<B, C, M1, M2> // Test being overridden
       fun setM3(doubleModule: DoubleModule) // Test being overridden
       fun set(
         floatModule: FloatModule
       ): SharedBuilder<B, C, M1, M2> // Test return type is supertype.
     }

     @Subcomponent.Builder
     interface Builder :
       TestChildComponentWithBuilderInterface.SharedBuilder<
         Builder,
         TestChildComponentWithBuilderInterface,
         StringModule,
         IntModuleIncludingDoubleAndFloat
       > {
       override fun setM2(m2: IntModuleIncludingDoubleAndFloat): Builder // Test covariant overrides
       override fun setM3(doubleModule: DoubleModule) // Test simple overrides allowed
       fun set(byteModule: ByteModule) // Note we're missing LongModule -- it's implicit
     }
   }

   @Component(
     modules = [StringModule::class, IntModuleIncludingDoubleAndFloat::class, LongModule::class],
     dependencies = [DepComponent::class]
   )
   internal abstract class TestComponentWithBuilderAbstractClass {
     abstract fun s(): String
     abstract fun i(): Int
     abstract fun l(): Long
     abstract fun f(): Float
     abstract fun d(): Double
     internal abstract class SharedBuilder {
       // Make sure we use the overriding signature.
       abstract fun build(): Any
       open fun stringModule(stringModule: StringModule): Any? = null
       @Suppress("UNUSED_PARAMETER")
       fun ignoredLongModule(longModule: LongModule): SharedBuilder? = null
     }

     @Component.Builder
     internal abstract class Builder : TestComponentWithBuilderAbstractClass.SharedBuilder() {
       abstract override fun build(): TestComponentWithBuilderAbstractClass // Narrowing return type
       abstract override fun stringModule(stringModule: StringModule): Builder // Abstract & narrow
       abstract fun intModule(intModule: IntModuleIncludingDoubleAndFloat): Builder
       abstract fun doubleModule(doubleModule: DoubleModule) // Module w/o args
       abstract fun depComponent(depComponent: DepComponent)
       // Note we're missing LongModule & FloatModule -- they/re implicit
       @Suppress("UNUSED_PARAMETER")
       fun ignoredIntModule(intModule: IntModuleIncludingDoubleAndFloat): Builder? = null
     }

     companion object {
       fun builder(): Builder = DaggerBuilderTest_TestComponentWithBuilderAbstractClass.builder()
     }
   }

   @Component(
     modules = [StringModule::class, IntModuleIncludingDoubleAndFloat::class, LongModule::class],
     dependencies = [DepComponent::class]
   )
   internal interface TestComponentWithBuilderInterface {
     fun s(): String
     fun i(): Int
     fun l(): Long
     fun f(): Float
     fun d(): Double
     interface SharedBuilder {
       // Make sure we use the overriding signature.
       fun build(): Any
       fun stringModule(m1: StringModule): Any
     }

     @Component.Builder
     interface Builder : TestComponentWithBuilderInterface.SharedBuilder {
       override fun build(): TestComponentWithBuilderInterface // Narrowing return type
       override fun stringModule(m1: StringModule): Builder // Narrowing return type
       fun intModule(intModule: IntModuleIncludingDoubleAndFloat): Builder
       fun doubleModule(doubleModule: DoubleModule) // Module w/o args
       fun depComponent(
         depComponent: DepComponent
       ) // Note we're missing LongModule & FloatModule -- they/re implicit
     }
   }

   @Component(
     modules = [StringModule::class, IntModuleIncludingDoubleAndFloat::class, LongModule::class],
     dependencies = [DepComponent::class]
   )
   internal interface TestComponentWithGenericBuilderAbstractClass {
     fun s(): String
     fun i(): Int
     fun l(): Long
     fun f(): Float
     fun d(): Double
     abstract class SharedBuilder<B, C, M1, M2> {
       abstract fun build(): C // Test resolving return type of build()
       abstract fun setM1(m1: M1): B // Test resolving return type & param of setter
       abstract fun setM2(m2: M2): SharedBuilder<B, C, M1, M2> // Test being overridden
       abstract fun doubleModule(doubleModule: DoubleModule) // Test being overridden
       abstract fun depComponent(
         floatModule: FloatModule
       ): SharedBuilder<B, C, M1, M2> // Test return type
     }

     @Component.Builder
     abstract class Builder :
       TestComponentWithGenericBuilderAbstractClass.SharedBuilder<
         Builder,
         TestComponentWithGenericBuilderAbstractClass,
         StringModule,
         IntModuleIncludingDoubleAndFloat
       >() {
       abstract override fun setM2(
         m2: IntModuleIncludingDoubleAndFloat
       ): Builder // Test covariant overrides
       abstract override fun doubleModule(
         doubleModule: DoubleModule
       ) // Test simple overrides allowed
       abstract fun depComponent(
         depComponent: DepComponent
       ) // Note we're missing LongModule & FloatModule -- they're implicit
     }
   }

   @Component(
     modules = [StringModule::class, IntModuleIncludingDoubleAndFloat::class, LongModule::class],
     dependencies = [DepComponent::class]
   )
   internal interface TestComponentWithGenericBuilderInterface {
     fun s(): String
     fun i(): Int
     fun l(): Long
     fun f(): Float
     fun d(): Double
     interface SharedBuilder<B, C, M1, M2> {
       fun build(): C // Test resolving return type of build()
       fun setM1(m1: M1): B // Test resolving return type & param of setter
       fun setM2(m2: M2): SharedBuilder<B, C, M1, M2> // Test being overridden
       fun doubleModule(doubleModule: DoubleModule) // Test being overridden
       fun set(
         floatModule: FloatModule
       ): SharedBuilder<B, C, M1, M2> // Test return type is supertype.
     }

     @Component.Builder
     interface Builder :
       TestComponentWithGenericBuilderInterface.SharedBuilder<
         Builder,
         TestComponentWithGenericBuilderInterface,
         StringModule,
         IntModuleIncludingDoubleAndFloat
       > {
       override fun setM2(
         m2: IntModuleIncludingDoubleAndFloat
       ): Builder // Test covariant overrides allowed
       override fun doubleModule(doubleModule: DoubleModule) // Test simple overrides allowed
       fun depComponent(depComponent: DepComponent) // Note we're missing M5 -- that's implicit.
     }
   }

   @Component internal interface DepComponent

   @Singleton
   @Component
   internal interface ParentComponent {
     fun childAbstractClassBuilder(): TestChildComponentWithBuilderAbstractClass.Builder
     fun childInterfaceBuilder(): TestChildComponentWithBuilderInterface.Builder
     fun middleBuilder(): MiddleChild.Builder
     fun otherBuilder(): OtherMiddleChild.Builder
     fun requiresMiddleChildBuilder(): RequiresSubcomponentBuilder<MiddleChild.Builder>
   }

   @Scope internal annotation class MiddleScope

   @MiddleScope
   @Subcomponent(modules = [StringModule::class])
   internal interface MiddleChild {
     fun s(): String
     fun grandchildBuilder(): Grandchild.Builder
     fun requiresGrandchildBuilder(): RequiresSubcomponentBuilder<Grandchild.Builder>

     @Subcomponent.Builder
     interface Builder {
       fun build(): MiddleChild
       fun set(stringModule: StringModule): Builder
     }
   }

   internal class RequiresSubcomponentBuilder<B>
   @Inject
   constructor(
     private val subcomponentBuilderProvider: Provider<B>,
     private val subcomponentBuilder: B
   ) {
     fun subcomponentBuilderProvider() = subcomponentBuilderProvider
     fun subcomponentBuilder() = subcomponentBuilder
   }

   @MiddleScope
   @Subcomponent(modules = [StringModule::class, LongModule::class])
   internal interface OtherMiddleChild {
     fun l(): Long
     fun s(): String
     fun grandchildBuilder(): Grandchild.Builder

     @Subcomponent.Builder
     interface Builder {
       fun build(): OtherMiddleChild
       fun set(stringModule: StringModule): Builder
     }
   }

   @Component(modules = [StringModule::class])
   @Singleton
   internal interface ParentOfGenericComponent : GenericParent<Grandchild.Builder>

   @Subcomponent(modules = [IntModuleIncludingDoubleAndFloat::class])
   internal interface Grandchild {
     fun i(): Int
     fun s(): String

     @Subcomponent.Builder
     interface Builder {
       fun build(): Grandchild
       fun set(intModule: IntModuleIncludingDoubleAndFloat): Builder
     }
   }

   internal interface GenericParent<B> {
     fun subcomponentBuilder(): B
   }

   @Module
   internal class ByteModule(private val b: Byte) {
     @Provides fun b(): Byte = b
   }

   @Module
   internal class DoubleModule {
     @Provides fun d(): Double = 4.2
   }

   @Module
   internal class LongModule {
     @Provides fun l(): Long = 6L
   }

   @Module
   internal class FloatModule {
     @Provides fun f(): Float = 5.5f
   }

   @Module
   internal class StringModule(private val string: String) {
     @Provides fun string(): String = string
   }

   @Module(includes = [DoubleModule::class, FloatModule::class])
   internal class IntModuleIncludingDoubleAndFloat(private val integer: Int) {
     @Provides fun integer(): Int = integer
   }

   @Test
   fun interfaceBuilder() {
     val builder = DaggerBuilderTest_TestComponentWithBuilderInterface.builder()

     // Make sure things fail if we don't set our required modules.
     try {
       builder.build()
       fail()
     } catch (expected: IllegalStateException) {}

     builder
       .intModule(IntModuleIncludingDoubleAndFloat(1))
       .stringModule(StringModule("sam"))
       .depComponent(object : DepComponent {})
     builder.doubleModule(DoubleModule())

     // Don't set other modules -- make sure it works.
     val component = builder.build()
     assertThat(component.s()).isEqualTo("sam")
     assertThat(component.i()).isEqualTo(1)
     assertThat(component.d()).isEqualTo(4.2)
     assertThat(component.f()).isEqualTo(5.5f)
     assertThat(component.l()).isEqualTo(6L)
   }

   @Test
   fun abstractClassBuilder() {
     val builder = TestComponentWithBuilderAbstractClass.builder()

     // Make sure things fail if we don't set our required modules.
     try {
       builder.build()
       fail()
     } catch (expected: IllegalStateException) {}

     builder
       .intModule(IntModuleIncludingDoubleAndFloat(1))
       .stringModule(StringModule("sam"))
       .depComponent(object : DepComponent {})
     builder.doubleModule(DoubleModule())

     // Don't set other modules -- make sure it works.
     val component = builder.build()
     assertThat(component.s()).isEqualTo("sam")
     assertThat(component.i()).isEqualTo(1)
     assertThat(component.d()).isEqualTo(4.2)
     assertThat(component.f()).isEqualTo(5.5f)
     assertThat(component.l()).isEqualTo(6L)
   }

   @Test
   fun interfaceGenericBuilder() {
     val builder = DaggerBuilderTest_TestComponentWithGenericBuilderInterface.builder()

     // Make sure things fail if we don't set our required modules.
     try {
       builder.build()
       fail()
     } catch (expected: IllegalStateException) {}

     builder
       .setM2(IntModuleIncludingDoubleAndFloat(1))
       .setM1(StringModule("sam"))
       .depComponent(object : DepComponent {})
     builder.doubleModule(DoubleModule())

     // Don't set other modules -- make sure it works.
     val component = builder.build()
     assertThat(component.s()).isEqualTo("sam")
     assertThat(component.i()).isEqualTo(1)
     assertThat(component.d()).isEqualTo(4.2)
     assertThat(component.f()).isEqualTo(5.5f)
     assertThat(component.l()).isEqualTo(6L)
   }

   @Test
   fun abstractClassGenericBuilder() {
     val builder = DaggerBuilderTest_TestComponentWithGenericBuilderAbstractClass.builder()

     // Make sure things fail if we don't set our required modules.
     try {
       builder.build()
       fail()
     } catch (expected: IllegalStateException) {}

     builder
       .setM2(IntModuleIncludingDoubleAndFloat(1))
       .setM1(StringModule("sam"))
       .depComponent(object : DepComponent {})
     builder.doubleModule(DoubleModule())

     // Don't set other modules -- make sure it works.
     val component = builder.build()
     assertThat(component.s()).isEqualTo("sam")
     assertThat(component.i()).isEqualTo(1)
     assertThat(component.d()).isEqualTo(4.2)
     assertThat(component.f()).isEqualTo(5.5f)
     assertThat(component.l()).isEqualTo(6L)
   }

   @Test
   fun subcomponents_interface() {
     val parent = DaggerBuilderTest_ParentComponent.create()
     val builder1 = parent.childInterfaceBuilder()

     try {
       builder1.build()
       fail()
     } catch (expected: IllegalStateException) {}

     builder1
       .setM2(IntModuleIncludingDoubleAndFloat(1))
       .setM1(StringModule("sam"))
       .set(ByteModule(7.toByte()))
     builder1.set(FloatModule())

     val child1 = builder1.build()
     assertThat(child1.s()).isEqualTo("sam")
     assertThat(child1.i()).isEqualTo(1)
     assertThat(child1.d()).isEqualTo(4.2)
     assertThat(child1.f()).isEqualTo(5.5f)
     assertThat(child1.l()).isEqualTo(6L)
     assertThat(child1.b()).isEqualTo(7.toByte())
   }

   @Test
   fun subcomponents_abstractclass() {
     val parent = DaggerBuilderTest_ParentComponent.create()
     val builder2 = parent.childAbstractClassBuilder()

     try {
       builder2.build()
       fail()
     } catch (expected: IllegalStateException) {}

     builder2
       .setM2(IntModuleIncludingDoubleAndFloat(10))
       .setM1(StringModule("tara"))
       .set(ByteModule(70.toByte()))
     builder2.set(FloatModule())

     val child2 = builder2.build()
     assertThat(child2.s()).isEqualTo("tara")
     assertThat(child2.i()).isEqualTo(10)
     assertThat(child2.d()).isEqualTo(4.2)
     assertThat(child2.f()).isEqualTo(5.5f)
     assertThat(child2.l()).isEqualTo(6L)
     assertThat(child2.b()).isEqualTo(70.toByte())
   }

   @Test
   fun grandchildren() {
     val parent = DaggerBuilderTest_ParentComponent.create()
     val middle1 = parent.middleBuilder().set(StringModule("sam")).build()
     val grandchild1 = middle1.grandchildBuilder().set(IntModuleIncludingDoubleAndFloat(21)).build()
     val grandchild2 = middle1.grandchildBuilder().set(IntModuleIncludingDoubleAndFloat(22)).build()
     assertThat(middle1.s()).isEqualTo("sam")
     assertThat(grandchild1.i()).isEqualTo(21)
     assertThat(grandchild1.s()).isEqualTo("sam")
     assertThat(grandchild2.i()).isEqualTo(22)
     assertThat(grandchild2.s()).isEqualTo("sam")

     // Make sure grandchildren from newer children have no relation to the older ones.
     val middle2 = parent.middleBuilder().set(StringModule("tara")).build()
     val grandchild3 = middle2.grandchildBuilder().set(IntModuleIncludingDoubleAndFloat(23)).build()
     val grandchild4 = middle2.grandchildBuilder().set(IntModuleIncludingDoubleAndFloat(24)).build()
     assertThat(middle2.s()).isEqualTo("tara")
     assertThat(grandchild3.i()).isEqualTo(23)
     assertThat(grandchild3.s()).isEqualTo("tara")
     assertThat(grandchild4.i()).isEqualTo(24)
     assertThat(grandchild4.s()).isEqualTo("tara")
   }

   @Test
   fun diamondGrandchildren() {
     val parent = DaggerBuilderTest_ParentComponent.create()
     val middle = parent.middleBuilder().set(StringModule("sam")).build()
     val other = parent.otherBuilder().set(StringModule("tara")).build()
     val middlegrand = middle.grandchildBuilder().set(IntModuleIncludingDoubleAndFloat(21)).build()
     val othergrand = other.grandchildBuilder().set(IntModuleIncludingDoubleAndFloat(22)).build()
     assertThat(middle.s()).isEqualTo("sam")
     assertThat(other.s()).isEqualTo("tara")
     assertThat(middlegrand.s()).isEqualTo("sam")
     assertThat(othergrand.s()).isEqualTo("tara")
     assertThat(middlegrand.i()).isEqualTo(21)
     assertThat(othergrand.i()).isEqualTo(22)
   }

   @Test
   fun genericSubcomponentMethod() {
     val parent =
       DaggerBuilderTest_ParentOfGenericComponent.builder().stringModule(StringModule("sam")).build()
     val builder = parent.subcomponentBuilder()
     val child = builder.set(IntModuleIncludingDoubleAndFloat(21)).build()
     assertThat(child.s()).isEqualTo("sam")
     assertThat(child.i()).isEqualTo(21)
   }

   @Test
   fun requireSubcomponentBuilderProviders() {
     val parent = DaggerBuilderTest_ParentComponent.create()
     val middle =
       parent
         .requiresMiddleChildBuilder()
         .subcomponentBuilderProvider()
         .get()
         .set(StringModule("sam"))
         .build()
     val grandchild =
       middle
         .requiresGrandchildBuilder()
         .subcomponentBuilderProvider()
         .get()
         .set(IntModuleIncludingDoubleAndFloat(12))
         .build()
     assertThat(middle.s()).isEqualTo("sam")
     assertThat(grandchild.i()).isEqualTo(12)
     assertThat(grandchild.s()).isEqualTo("sam")
   }

   @Test
   fun requireSubcomponentBuilders() {
     val parent = DaggerBuilderTest_ParentComponent.create()
     val middle =
       parent.requiresMiddleChildBuilder().subcomponentBuilder().set(StringModule("sam")).build()
     val grandchild =
       middle
         .requiresGrandchildBuilder()
         .subcomponentBuilder()
         .set(IntModuleIncludingDoubleAndFloat(12))
         .build()
     assertThat(middle.s()).isEqualTo("sam")
     assertThat(grandchild.i()).isEqualTo(12)
     assertThat(grandchild.s()).isEqualTo("sam")
   }
 }
	/*
	* Copyright (C) 2022 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.functional.kotlinsrc.builder

	import com.google.common.truth.Truth.assertThat
	import dagger.Component
	import dagger.Module
	import dagger.Provides
	import dagger.Subcomponent
	import java.lang.annotation.Retention
	import java.lang.annotation.RetentionPolicy
	import javax.inject.Inject
	import javax.inject.Provider
	import javax.inject.Scope
	import javax.inject.Singleton
	import org.junit.Assert.fail
	import org.junit.Test
	import org.junit.runner.RunWith
	import org.junit.runners.JUnit4

	@RunWith(JUnit4::class)
	class BuilderTest {
	@Subcomponent(
	modules =
	[
	StringModule::class,
	IntModuleIncludingDoubleAndFloat::class,
	LongModule::class,
	ByteModule::class
	]
	)
	internal interface TestChildComponentWithBuilderAbstractClass {
	fun s(): String
	fun i(): Int
	fun l(): Long
	fun f(): Float
	fun d(): Double
	fun b(): Byte
	abstract class SharedBuilder<B, C, M1, M2> {
	abstract fun build(): C // Test resolving return type of build()
	abstract fun setM1(m1: M1): B // Test resolving return type & param of setter
	abstract fun setM2(m2: M2): SharedBuilder<B, C, M1, M2> // Test being overridden
	abstract fun setM3(doubleModule: DoubleModule) // Test being overridden
	abstract fun set(
	floatModule: FloatModule
	): SharedBuilder<B, C, M1, M2> // Test returning supertype.
	}

	@Subcomponent.Builder
	abstract class Builder :
	TestChildComponentWithBuilderAbstractClass.SharedBuilder<
	Builder,
	TestChildComponentWithBuilderAbstractClass,
	StringModule,
	IntModuleIncludingDoubleAndFloat
	>() {
	abstract override fun setM2(m2: IntModuleIncludingDoubleAndFloat): Builder // Test covariance
	abstract override fun setM3(doubleModule: DoubleModule) // Test simple overrides allowed
	abstract fun set(byteModule: ByteModule) // Note we're missing LongModule -- it's implicit
	}
	}

	@Subcomponent(
	modules =
	[
	StringModule::class,
	IntModuleIncludingDoubleAndFloat::class,
	LongModule::class,
	ByteModule::class
	]
	)
	internal interface TestChildComponentWithBuilderInterface {
	fun s(): String
	fun i(): Int
	fun l(): Long
	fun f(): Float
	fun d(): Double
	fun b(): Byte
	interface SharedBuilder<B, C, M1, M2> {
	fun build(): C // Test resolving return type of build()
	fun setM1(m1: M1): B // Test resolving return type & param of setter
	fun setM2(m2: M2): SharedBuilder<B, C, M1, M2> // Test being overridden
	fun setM3(doubleModule: DoubleModule) // Test being overridden
	fun set(
	floatModule: FloatModule
	): SharedBuilder<B, C, M1, M2> // Test return type is supertype.
	}

	@Subcomponent.Builder
	interface Builder :
	TestChildComponentWithBuilderInterface.SharedBuilder<
	Builder,
	TestChildComponentWithBuilderInterface,
	StringModule,
	IntModuleIncludingDoubleAndFloat
	> {
	override fun setM2(m2: IntModuleIncludingDoubleAndFloat): Builder // Test covariant overrides
	override fun setM3(doubleModule: DoubleModule) // Test simple overrides allowed
	fun set(byteModule: ByteModule) // Note we're missing LongModule -- it's implicit
	}
	}

	@Component(
	modules = [StringModule::class, IntModuleIncludingDoubleAndFloat::class, LongModule::class],
	dependencies = [DepComponent::class]
	)
	internal abstract class TestComponentWithBuilderAbstractClass {
	abstract fun s(): String
	abstract fun i(): Int
	abstract fun l(): Long
	abstract fun f(): Float
	abstract fun d(): Double
	internal abstract class SharedBuilder {
	// Make sure we use the overriding signature.
	abstract fun build(): Any
	open fun stringModule(stringModule: StringModule): Any? = null
	@Suppress("UNUSED_PARAMETER")
	fun ignoredLongModule(longModule: LongModule): SharedBuilder? = null
	}

	@Component.Builder
	internal abstract class Builder : TestComponentWithBuilderAbstractClass.SharedBuilder() {
	abstract override fun build(): TestComponentWithBuilderAbstractClass // Narrowing return type
	abstract override fun stringModule(stringModule: StringModule): Builder // Abstract & narrow
	abstract fun intModule(intModule: IntModuleIncludingDoubleAndFloat): Builder
	abstract fun doubleModule(doubleModule: DoubleModule) // Module w/o args
	abstract fun depComponent(depComponent: DepComponent)
	// Note we're missing LongModule & FloatModule -- they/re implicit
	@Suppress("UNUSED_PARAMETER")
	fun ignoredIntModule(intModule: IntModuleIncludingDoubleAndFloat): Builder? = null
	}

	companion object {
	fun builder(): Builder = DaggerBuilderTest_TestComponentWithBuilderAbstractClass.builder()
	}
	}

	@Component(
	modules = [StringModule::class, IntModuleIncludingDoubleAndFloat::class, LongModule::class],
	dependencies = [DepComponent::class]
	)
	internal interface TestComponentWithBuilderInterface {
	fun s(): String
	fun i(): Int
	fun l(): Long
	fun f(): Float
	fun d(): Double
	interface SharedBuilder {
	// Make sure we use the overriding signature.
	fun build(): Any
	fun stringModule(m1: StringModule): Any
	}

	@Component.Builder
	interface Builder : TestComponentWithBuilderInterface.SharedBuilder {
	override fun build(): TestComponentWithBuilderInterface // Narrowing return type
	override fun stringModule(m1: StringModule): Builder // Narrowing return type
	fun intModule(intModule: IntModuleIncludingDoubleAndFloat): Builder
	fun doubleModule(doubleModule: DoubleModule) // Module w/o args
	fun depComponent(
	depComponent: DepComponent
	) // Note we're missing LongModule & FloatModule -- they/re implicit
	}
	}

	@Component(
	modules = [StringModule::class, IntModuleIncludingDoubleAndFloat::class, LongModule::class],
	dependencies = [DepComponent::class]
	)
	internal interface TestComponentWithGenericBuilderAbstractClass {
	fun s(): String
	fun i(): Int
	fun l(): Long
	fun f(): Float
	fun d(): Double
	abstract class SharedBuilder<B, C, M1, M2> {
	abstract fun build(): C // Test resolving return type of build()
	abstract fun setM1(m1: M1): B // Test resolving return type & param of setter
	abstract fun setM2(m2: M2): SharedBuilder<B, C, M1, M2> // Test being overridden
	abstract fun doubleModule(doubleModule: DoubleModule) // Test being overridden
	abstract fun depComponent(
	floatModule: FloatModule
	): SharedBuilder<B, C, M1, M2> // Test return type
	}

	@Component.Builder
	abstract class Builder :
	TestComponentWithGenericBuilderAbstractClass.SharedBuilder<
	Builder,
	TestComponentWithGenericBuilderAbstractClass,
	StringModule,
	IntModuleIncludingDoubleAndFloat
	>() {
	abstract override fun setM2(
	m2: IntModuleIncludingDoubleAndFloat
	): Builder // Test covariant overrides
	abstract override fun doubleModule(
	doubleModule: DoubleModule
	) // Test simple overrides allowed
	abstract fun depComponent(
	depComponent: DepComponent
	) // Note we're missing LongModule & FloatModule -- they're implicit
	}
	}

	@Component(
	modules = [StringModule::class, IntModuleIncludingDoubleAndFloat::class, LongModule::class],
	dependencies = [DepComponent::class]
	)
	internal interface TestComponentWithGenericBuilderInterface {
	fun s(): String
	fun i(): Int
	fun l(): Long
	fun f(): Float
	fun d(): Double
	interface SharedBuilder<B, C, M1, M2> {
	fun build(): C // Test resolving return type of build()
	fun setM1(m1: M1): B // Test resolving return type & param of setter
	fun setM2(m2: M2): SharedBuilder<B, C, M1, M2> // Test being overridden
	fun doubleModule(doubleModule: DoubleModule) // Test being overridden
	fun set(
	floatModule: FloatModule
	): SharedBuilder<B, C, M1, M2> // Test return type is supertype.
	}

	@Component.Builder
	interface Builder :
	TestComponentWithGenericBuilderInterface.SharedBuilder<
	Builder,
	TestComponentWithGenericBuilderInterface,
	StringModule,
	IntModuleIncludingDoubleAndFloat
	> {
	override fun setM2(
	m2: IntModuleIncludingDoubleAndFloat
	): Builder // Test covariant overrides allowed
	override fun doubleModule(doubleModule: DoubleModule) // Test simple overrides allowed
	fun depComponent(depComponent: DepComponent) // Note we're missing M5 -- that's implicit.
	}
	}

	@Component internal interface DepComponent

	@Singleton
	@Component
	internal interface ParentComponent {
	fun childAbstractClassBuilder(): TestChildComponentWithBuilderAbstractClass.Builder
	fun childInterfaceBuilder(): TestChildComponentWithBuilderInterface.Builder
	fun middleBuilder(): MiddleChild.Builder
	fun otherBuilder(): OtherMiddleChild.Builder
	fun requiresMiddleChildBuilder(): RequiresSubcomponentBuilder<MiddleChild.Builder>
	}

	@Scope internal annotation class MiddleScope

	@MiddleScope
	@Subcomponent(modules = [StringModule::class])
	internal interface MiddleChild {
	fun s(): String
	fun grandchildBuilder(): Grandchild.Builder
	fun requiresGrandchildBuilder(): RequiresSubcomponentBuilder<Grandchild.Builder>

	@Subcomponent.Builder
	interface Builder {
	fun build(): MiddleChild
	fun set(stringModule: StringModule): Builder
	}
	}

	internal class RequiresSubcomponentBuilder<B>
	@Inject
	constructor(
	private val subcomponentBuilderProvider: Provider<B>,
	private val subcomponentBuilder: B
	) {
	fun subcomponentBuilderProvider() = subcomponentBuilderProvider
	fun subcomponentBuilder() = subcomponentBuilder
	}

	@MiddleScope
	@Subcomponent(modules = [StringModule::class, LongModule::class])
	internal interface OtherMiddleChild {
	fun l(): Long
	fun s(): String
	fun grandchildBuilder(): Grandchild.Builder

	@Subcomponent.Builder
	interface Builder {
	fun build(): OtherMiddleChild
	fun set(stringModule: StringModule): Builder
	}
	}

	@Component(modules = [StringModule::class])
	@Singleton
	internal interface ParentOfGenericComponent : GenericParent<Grandchild.Builder>

	@Subcomponent(modules = [IntModuleIncludingDoubleAndFloat::class])
	internal interface Grandchild {
	fun i(): Int
	fun s(): String

	@Subcomponent.Builder
	interface Builder {
	fun build(): Grandchild
	fun set(intModule: IntModuleIncludingDoubleAndFloat): Builder
	}
	}

	internal interface GenericParent<B> {
	fun subcomponentBuilder(): B
	}

	@Module
	internal class ByteModule(private val b: Byte) {
	@Provides fun b(): Byte = b
	}

	@Module
	internal class DoubleModule {
	@Provides fun d(): Double = 4.2
	}

	@Module
	internal class LongModule {
	@Provides fun l(): Long = 6L
	}

	@Module
	internal class FloatModule {
	@Provides fun f(): Float = 5.5f
	}

	@Module
	internal class StringModule(private val string: String) {
	@Provides fun string(): String = string
	}

	@Module(includes = [DoubleModule::class, FloatModule::class])
	internal class IntModuleIncludingDoubleAndFloat(private val integer: Int) {
	@Provides fun integer(): Int = integer
	}

	@Test
	fun interfaceBuilder() {
	val builder = DaggerBuilderTest_TestComponentWithBuilderInterface.builder()

	// Make sure things fail if we don't set our required modules.
	try {
	builder.build()
	fail()
	} catch (expected: IllegalStateException) {}

	builder
	.intModule(IntModuleIncludingDoubleAndFloat(1))
	.stringModule(StringModule("sam"))
	.depComponent(object : DepComponent {})
	builder.doubleModule(DoubleModule())

	// Don't set other modules -- make sure it works.
	val component = builder.build()
	assertThat(component.s()).isEqualTo("sam")
	assertThat(component.i()).isEqualTo(1)
	assertThat(component.d()).isEqualTo(4.2)
	assertThat(component.f()).isEqualTo(5.5f)
	assertThat(component.l()).isEqualTo(6L)
	}

	@Test
	fun abstractClassBuilder() {
	val builder = TestComponentWithBuilderAbstractClass.builder()

	// Make sure things fail if we don't set our required modules.
	try {
	builder.build()
	fail()
	} catch (expected: IllegalStateException) {}

	builder
	.intModule(IntModuleIncludingDoubleAndFloat(1))
	.stringModule(StringModule("sam"))
	.depComponent(object : DepComponent {})
	builder.doubleModule(DoubleModule())

	// Don't set other modules -- make sure it works.
	val component = builder.build()
	assertThat(component.s()).isEqualTo("sam")
	assertThat(component.i()).isEqualTo(1)
	assertThat(component.d()).isEqualTo(4.2)
	assertThat(component.f()).isEqualTo(5.5f)
	assertThat(component.l()).isEqualTo(6L)
	}

	@Test
	fun interfaceGenericBuilder() {
	val builder = DaggerBuilderTest_TestComponentWithGenericBuilderInterface.builder()

	// Make sure things fail if we don't set our required modules.
	try {
	builder.build()
	fail()
	} catch (expected: IllegalStateException) {}

	builder
	.setM2(IntModuleIncludingDoubleAndFloat(1))
	.setM1(StringModule("sam"))
	.depComponent(object : DepComponent {})
	builder.doubleModule(DoubleModule())

	// Don't set other modules -- make sure it works.
	val component = builder.build()
	assertThat(component.s()).isEqualTo("sam")
	assertThat(component.i()).isEqualTo(1)
	assertThat(component.d()).isEqualTo(4.2)
	assertThat(component.f()).isEqualTo(5.5f)
	assertThat(component.l()).isEqualTo(6L)
	}

	@Test
	fun abstractClassGenericBuilder() {
	val builder = DaggerBuilderTest_TestComponentWithGenericBuilderAbstractClass.builder()

	// Make sure things fail if we don't set our required modules.
	try {
	builder.build()
	fail()
	} catch (expected: IllegalStateException) {}

	builder
	.setM2(IntModuleIncludingDoubleAndFloat(1))
	.setM1(StringModule("sam"))
	.depComponent(object : DepComponent {})
	builder.doubleModule(DoubleModule())

	// Don't set other modules -- make sure it works.
	val component = builder.build()
	assertThat(component.s()).isEqualTo("sam")
	assertThat(component.i()).isEqualTo(1)
	assertThat(component.d()).isEqualTo(4.2)
	assertThat(component.f()).isEqualTo(5.5f)
	assertThat(component.l()).isEqualTo(6L)
	}

	@Test
	fun subcomponents_interface() {
	val parent = DaggerBuilderTest_ParentComponent.create()
	val builder1 = parent.childInterfaceBuilder()

	try {
	builder1.build()
	fail()
	} catch (expected: IllegalStateException) {}

	builder1
	.setM2(IntModuleIncludingDoubleAndFloat(1))
	.setM1(StringModule("sam"))
	.set(ByteModule(7.toByte()))
	builder1.set(FloatModule())

	val child1 = builder1.build()
	assertThat(child1.s()).isEqualTo("sam")
	assertThat(child1.i()).isEqualTo(1)
	assertThat(child1.d()).isEqualTo(4.2)
	assertThat(child1.f()).isEqualTo(5.5f)
	assertThat(child1.l()).isEqualTo(6L)
	assertThat(child1.b()).isEqualTo(7.toByte())
	}

	@Test
	fun subcomponents_abstractclass() {
	val parent = DaggerBuilderTest_ParentComponent.create()
	val builder2 = parent.childAbstractClassBuilder()

	try {
	builder2.build()
	fail()
	} catch (expected: IllegalStateException) {}

	builder2
	.setM2(IntModuleIncludingDoubleAndFloat(10))
	.setM1(StringModule("tara"))
	.set(ByteModule(70.toByte()))
	builder2.set(FloatModule())

	val child2 = builder2.build()
	assertThat(child2.s()).isEqualTo("tara")
	assertThat(child2.i()).isEqualTo(10)
	assertThat(child2.d()).isEqualTo(4.2)
	assertThat(child2.f()).isEqualTo(5.5f)
	assertThat(child2.l()).isEqualTo(6L)
	assertThat(child2.b()).isEqualTo(70.toByte())
	}

	@Test
	fun grandchildren() {
	val parent = DaggerBuilderTest_ParentComponent.create()
	val middle1 = parent.middleBuilder().set(StringModule("sam")).build()
	val grandchild1 = middle1.grandchildBuilder().set(IntModuleIncludingDoubleAndFloat(21)).build()
	val grandchild2 = middle1.grandchildBuilder().set(IntModuleIncludingDoubleAndFloat(22)).build()
	assertThat(middle1.s()).isEqualTo("sam")
	assertThat(grandchild1.i()).isEqualTo(21)
	assertThat(grandchild1.s()).isEqualTo("sam")
	assertThat(grandchild2.i()).isEqualTo(22)
	assertThat(grandchild2.s()).isEqualTo("sam")

	// Make sure grandchildren from newer children have no relation to the older ones.
	val middle2 = parent.middleBuilder().set(StringModule("tara")).build()
	val grandchild3 = middle2.grandchildBuilder().set(IntModuleIncludingDoubleAndFloat(23)).build()
	val grandchild4 = middle2.grandchildBuilder().set(IntModuleIncludingDoubleAndFloat(24)).build()
	assertThat(middle2.s()).isEqualTo("tara")
	assertThat(grandchild3.i()).isEqualTo(23)
	assertThat(grandchild3.s()).isEqualTo("tara")
	assertThat(grandchild4.i()).isEqualTo(24)
	assertThat(grandchild4.s()).isEqualTo("tara")
	}

	@Test
	fun diamondGrandchildren() {
	val parent = DaggerBuilderTest_ParentComponent.create()
	val middle = parent.middleBuilder().set(StringModule("sam")).build()
	val other = parent.otherBuilder().set(StringModule("tara")).build()
	val middlegrand = middle.grandchildBuilder().set(IntModuleIncludingDoubleAndFloat(21)).build()
	val othergrand = other.grandchildBuilder().set(IntModuleIncludingDoubleAndFloat(22)).build()
	assertThat(middle.s()).isEqualTo("sam")
	assertThat(other.s()).isEqualTo("tara")
	assertThat(middlegrand.s()).isEqualTo("sam")
	assertThat(othergrand.s()).isEqualTo("tara")
	assertThat(middlegrand.i()).isEqualTo(21)
	assertThat(othergrand.i()).isEqualTo(22)
	}

	@Test
	fun genericSubcomponentMethod() {
	val parent =
	DaggerBuilderTest_ParentOfGenericComponent.builder().stringModule(StringModule("sam")).build()
	val builder = parent.subcomponentBuilder()
	val child = builder.set(IntModuleIncludingDoubleAndFloat(21)).build()
	assertThat(child.s()).isEqualTo("sam")
	assertThat(child.i()).isEqualTo(21)
	}

	@Test
	fun requireSubcomponentBuilderProviders() {
	val parent = DaggerBuilderTest_ParentComponent.create()
	val middle =
	parent
	.requiresMiddleChildBuilder()
	.subcomponentBuilderProvider()
	.get()
	.set(StringModule("sam"))
	.build()
	val grandchild =
	middle
	.requiresGrandchildBuilder()
	.subcomponentBuilderProvider()
	.get()
	.set(IntModuleIncludingDoubleAndFloat(12))
	.build()
	assertThat(middle.s()).isEqualTo("sam")
	assertThat(grandchild.i()).isEqualTo(12)
	assertThat(grandchild.s()).isEqualTo("sam")
	}

	@Test
	fun requireSubcomponentBuilders() {
	val parent = DaggerBuilderTest_ParentComponent.create()
	val middle =
	parent.requiresMiddleChildBuilder().subcomponentBuilder().set(StringModule("sam")).build()
	val grandchild =
	middle
	.requiresGrandchildBuilder()
	.subcomponentBuilder()
	.set(IntModuleIncludingDoubleAndFloat(12))
	.build()
	assertThat(middle.s()).isEqualTo("sam")
	assertThat(grandchild.i()).isEqualTo(12)
	assertThat(grandchild.s()).isEqualTo("sam")
	}
	}