java/dagger/hilt/android/plugin/src/test/kotlin/IncrementalProcessorTest.kt - platform/external/dagger2 - Git at Google

 /*
  * Copyright (C) 2020 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.
  */

 import com.google.common.truth.Expect
 import java.io.File
 import org.gradle.testkit.runner.BuildResult
 import org.gradle.testkit.runner.GradleRunner
 import org.gradle.testkit.runner.TaskOutcome
 import org.junit.Before
 import org.junit.Rule
 import org.junit.Test
 import org.junit.rules.TemporaryFolder

 /**
  * Tests to verify Gradle annotation processor incremental compilation.
  *
  * To run these tests first deploy artifacts to local maven via util/install-local-snapshot.sh.
  */
 class IncrementalProcessorTest {

   @get:Rule
   val testProjectDir = TemporaryFolder()

   @get:Rule
   val expect: Expect = Expect.create()

   // Original source files
   private lateinit var srcApp: File
   private lateinit var srcActivity1: File
   private lateinit var srcActivity2: File
   private lateinit var srcModule1: File
   private lateinit var srcModule2: File

   // Generated source files
   private lateinit var genHiltApp: File
   private lateinit var genHiltActivity1: File
   private lateinit var genHiltActivity2: File
   private lateinit var genAppInjector: File
   private lateinit var genActivityInjector1: File
   private lateinit var genActivityInjector2: File
   private lateinit var genAppInjectorDeps: File
   private lateinit var genActivityInjectorDeps1: File
   private lateinit var genActivityInjectorDeps2: File
   private lateinit var genModuleDeps1: File
   private lateinit var genModuleDeps2: File
   private lateinit var genHiltComponents: File
   private lateinit var genDaggerHiltApplicationComponent: File

   // Compiled classes
   private lateinit var classSrcApp: File
   private lateinit var classSrcActivity1: File
   private lateinit var classSrcActivity2: File
   private lateinit var classSrcModule1: File
   private lateinit var classSrcModule2: File
   private lateinit var classGenHiltApp: File
   private lateinit var classGenHiltActivity1: File
   private lateinit var classGenHiltActivity2: File
   private lateinit var classGenAppInjector: File
   private lateinit var classGenActivityInjector1: File
   private lateinit var classGenActivityInjector2: File
   private lateinit var classGenAppInjectorDeps: File
   private lateinit var classGenActivityInjectorDeps1: File
   private lateinit var classGenActivityInjectorDeps2: File
   private lateinit var classGenModuleDeps1: File
   private lateinit var classGenModuleDeps2: File
   private lateinit var classGenHiltComponents: File
   private lateinit var classGenDaggerHiltApplicationComponent: File

   // Timestamps of files
   private lateinit var fileToTimestampMap: Map<File, Long>

   // Sets of files that have changed/not changed/deleted
   private lateinit var changedFiles: Set<File>
   private lateinit var unchangedFiles: Set<File>
   private lateinit var deletedFiles: Set<File>

   @Before
   fun setup() {
     val projectRoot = testProjectDir.root
     // copy test project
     File("src/test/data/simple-project").copyRecursively(projectRoot)

     // set up build file
     File(projectRoot, "build.gradle").writeText(
       """
       buildscript {
         repositories {
           google()
           jcenter()
         }
         dependencies {
           classpath 'com.android.tools.build:gradle:3.5.3'
         }
       }

       plugins {
         id 'com.android.application'
       }

       android {
         compileSdkVersion 30
         buildToolsVersion "30.0.2"

         defaultConfig {
           applicationId "hilt.simple"
           minSdkVersion 21
           targetSdkVersion 30
         }

         compileOptions {
             sourceCompatibility 1.8
             targetCompatibility 1.8
         }
       }

       repositories {
         mavenLocal()
         google()
         jcenter()
       }

       dependencies {
         implementation 'androidx.appcompat:appcompat:1.1.0'
         implementation 'com.google.dagger:dagger:LOCAL-SNAPSHOT'
         annotationProcessor 'com.google.dagger:dagger-compiler:LOCAL-SNAPSHOT'
         implementation 'com.google.dagger:hilt-android:LOCAL-SNAPSHOT'
         annotationProcessor 'com.google.dagger:hilt-compiler:LOCAL-SNAPSHOT'
       }
       """.trimIndent()
     )

     // Compute file paths
     srcApp = File(projectRoot, "$SRC_DIR/simple/SimpleApp.java")
     srcActivity1 = File(projectRoot, "$SRC_DIR/simple/Activity1.java")
     srcActivity2 = File(projectRoot, "$SRC_DIR/simple/Activity2.java")
     srcModule1 = File(projectRoot, "$SRC_DIR/simple/Module1.java")
     srcModule2 = File(projectRoot, "$SRC_DIR/simple/Module2.java")

     genHiltApp = File(projectRoot, "$GEN_SRC_DIR/simple/Hilt_SimpleApp.java")
     genHiltActivity1 = File(projectRoot, "$GEN_SRC_DIR/simple/Hilt_Activity1.java")
     genHiltActivity2 = File(projectRoot, "$GEN_SRC_DIR/simple/Hilt_Activity2.java")
     genAppInjector = File(projectRoot, "$GEN_SRC_DIR/simple/SimpleApp_GeneratedInjector.java")
     genActivityInjector1 = File(projectRoot, "$GEN_SRC_DIR/simple/Activity1_GeneratedInjector.java")
     genActivityInjector2 = File(projectRoot, "$GEN_SRC_DIR/simple/Activity2_GeneratedInjector.java")
     genAppInjectorDeps = File(
       projectRoot,
       "$GEN_SRC_DIR/hilt_aggregated_deps/simple_SimpleApp_GeneratedInjectorModuleDeps.java"
     )
     genActivityInjectorDeps1 = File(
       projectRoot,
       "$GEN_SRC_DIR/hilt_aggregated_deps/simple_Activity1_GeneratedInjectorModuleDeps.java"
     )
     genActivityInjectorDeps2 = File(
       projectRoot,
       "$GEN_SRC_DIR/hilt_aggregated_deps/simple_Activity2_GeneratedInjectorModuleDeps.java"
     )
     genModuleDeps1 = File(
       projectRoot,
       "$GEN_SRC_DIR/hilt_aggregated_deps/simple_Module1ModuleDeps.java"
     )
     genModuleDeps2 = File(
       projectRoot,
       "$GEN_SRC_DIR/hilt_aggregated_deps/simple_Module2ModuleDeps.java"
     )
     genHiltComponents = File(
       projectRoot,
       "$GEN_SRC_DIR/simple/SimpleApp_HiltComponents.java"
     )
     genDaggerHiltApplicationComponent = File(
       projectRoot,
       "$GEN_SRC_DIR/simple/DaggerSimpleApp_HiltComponents_SingletonC.java"
     )

     classSrcApp = File(projectRoot, "$CLASS_DIR/simple/SimpleApp.class")
     classSrcActivity1 = File(projectRoot, "$CLASS_DIR/simple/Activity1.class")
     classSrcActivity2 = File(projectRoot, "$CLASS_DIR/simple/Activity2.class")
     classSrcModule1 = File(projectRoot, "$CLASS_DIR/simple/Module1.class")
     classSrcModule2 = File(projectRoot, "$CLASS_DIR/simple/Module2.class")
     classGenHiltApp = File(projectRoot, "$CLASS_DIR/simple/Hilt_SimpleApp.class")
     classGenHiltActivity1 = File(projectRoot, "$CLASS_DIR/simple/Hilt_Activity1.class")
     classGenHiltActivity2 = File(projectRoot, "$CLASS_DIR/simple/Hilt_Activity2.class")
     classGenAppInjector = File(projectRoot, "$CLASS_DIR/simple/SimpleApp_GeneratedInjector.class")
     classGenActivityInjector1 = File(
       projectRoot,
       "$CLASS_DIR/simple/Activity1_GeneratedInjector.class"
     )
     classGenActivityInjector2 = File(
       projectRoot,
       "$CLASS_DIR/simple/Activity2_GeneratedInjector.class"
     )
     classGenAppInjectorDeps = File(
       projectRoot,
       "$CLASS_DIR/hilt_aggregated_deps/simple_SimpleApp_GeneratedInjectorModuleDeps.class"
     )
     classGenActivityInjectorDeps1 = File(
       projectRoot,
       "$CLASS_DIR/hilt_aggregated_deps/simple_Activity1_GeneratedInjectorModuleDeps.class"
     )
     classGenActivityInjectorDeps2 = File(
       projectRoot,
       "$CLASS_DIR/hilt_aggregated_deps/simple_Activity2_GeneratedInjectorModuleDeps.class"
     )
     classGenModuleDeps1 = File(
       projectRoot,
       "$CLASS_DIR/hilt_aggregated_deps/simple_Module1ModuleDeps.class"
     )
     classGenModuleDeps2 = File(
       projectRoot,
       "$CLASS_DIR/hilt_aggregated_deps/simple_Module2ModuleDeps.class"
     )
     classGenHiltComponents = File(
       projectRoot,
       "$CLASS_DIR/simple/SimpleApp_HiltComponents.class"
     )
     classGenDaggerHiltApplicationComponent = File(
       projectRoot,
       "$CLASS_DIR/simple/DaggerSimpleApp_HiltComponents_SingletonC.class"
     )
   }

   @Test
   fun firstFullBuild() {
     // This test verifies the results of the first full (non-incremental) build. The other tests
     // verify the results of the second incremental build based on different change scenarios.
     val result = runFullBuild()
     expect.that(result.task(COMPILE_TASK)!!.outcome).isEqualTo(TaskOutcome.SUCCESS)

     // Check annotation processing outputs
     assertFilesExist(
       genHiltApp,
       genHiltActivity1,
       genHiltActivity2,
       genAppInjector,
       genActivityInjector1,
       genActivityInjector2,
       genAppInjectorDeps,
       genActivityInjectorDeps1,
       genActivityInjectorDeps2,
       genModuleDeps1,
       genModuleDeps2,
       genHiltComponents,
       genDaggerHiltApplicationComponent
     )

     // Check compilation outputs
     assertFilesExist(
       classSrcApp,
       classSrcActivity1,
       classSrcActivity2,
       classSrcModule1,
       classSrcModule2,
       classGenHiltApp,
       classGenHiltActivity1,
       classGenHiltActivity2,
       classGenAppInjector,
       classGenActivityInjector1,
       classGenActivityInjector2,
       classGenAppInjectorDeps,
       classGenActivityInjectorDeps1,
       classGenActivityInjectorDeps2,
       classGenModuleDeps1,
       classGenModuleDeps2,
       classGenHiltComponents,
       classGenDaggerHiltApplicationComponent
     )
   }

   @Test
   fun changeActivitySource() {
     runFullBuild()

     // Change Activity 1 source
     searchAndReplace(
       srcActivity1, "// Insert-change",
       """
       @Override
       public void onResume() {
         super.onResume();
       }
       """.trimIndent()
     )

     val result = runIncrementalBuild()
     expect.that(result.task(COMPILE_TASK)!!.outcome).isEqualTo(TaskOutcome.SUCCESS)

     // Check annotation processing outputs
     // * Only activity 1 sources are re-generated, isolation in modules and from other activities
     // * Root classes along with components are always re-generated (aggregated processor)
     assertChangedFiles(
       FileType.JAVA,
       genHiltApp,
       genHiltActivity1,
       genAppInjector,
       genActivityInjector1,
       genAppInjectorDeps,
       genActivityInjectorDeps1,
       genHiltComponents,
       genDaggerHiltApplicationComponent
     )

     // Check compilation outputs
     // * Gen sources from activity 1 are re-compiled
     // * All aggregating processor gen sources are re-compiled
     assertChangedFiles(
       FileType.CLASS,
       classSrcActivity1,
       classGenHiltApp,
       classGenHiltActivity1,
       classGenAppInjector,
       classGenActivityInjector1,
       classGenAppInjectorDeps,
       classGenActivityInjectorDeps1,
       classGenHiltComponents,
       classGenDaggerHiltApplicationComponent
     )
   }

   @Test
   fun changeModuleSource() {
     runFullBuild()

     // Change Module 1 source
     searchAndReplace(
       srcModule1, "// Insert-change",
       """
       @Provides
       static double provideDouble() {
         return 10.10;
       }
       """.trimIndent()
     )

     val result = runIncrementalBuild()
     expect.that(result.task(COMPILE_TASK)!!.outcome).isEqualTo(TaskOutcome.SUCCESS)

     // Check annotation processing outputs
     // * Only module 1 sources are re-generated, isolation from other modules
     // * Root classes along with components are always re-generated (aggregated processor)
     assertChangedFiles(
       FileType.JAVA,
       genHiltApp,
       genAppInjector,
       genAppInjectorDeps,
       genModuleDeps1,
       genHiltComponents,
       genDaggerHiltApplicationComponent
     )

     // Check compilation outputs
     // * Gen sources from module 1 are re-compiled
     // * All aggregating processor gen sources are re-compiled
     assertChangedFiles(
       FileType.CLASS,
       classSrcModule1,
       classGenHiltApp,
       classGenAppInjector,
       classGenAppInjectorDeps,
       classGenModuleDeps1,
       classGenHiltComponents,
       classGenDaggerHiltApplicationComponent
     )
   }

   @Test
   fun changeAppSource() {
     runFullBuild()

     // Change Application source
     searchAndReplace(
       srcApp, "// Insert-change",
       """
       @Override
       public void onCreate() {
         super.onCreate();
       }
       """.trimIndent()
     )

     val result = runIncrementalBuild()
     expect.that(result.task(COMPILE_TASK)!!.outcome).isEqualTo(TaskOutcome.SUCCESS)

     // Check annotation processing outputs
     // * No modules or activities (or any other non-root) classes should be generated
     // * Root classes along with components are always re-generated (aggregated processor)
     assertChangedFiles(
       FileType.JAVA,
       genHiltApp,
       genAppInjector,
       genAppInjectorDeps,
       genHiltComponents,
       genDaggerHiltApplicationComponent
     )

     // Check compilation outputs
     // * All aggregating processor gen sources are re-compiled
     assertChangedFiles(
       FileType.CLASS,
       classSrcApp, // re-compiles because superclass re-compiled
       classGenHiltApp,
       classGenAppInjector,
       classGenAppInjectorDeps,
       classGenHiltComponents,
       classGenDaggerHiltApplicationComponent
     )
   }

   @Test
   fun deleteActivitySource() {
     runFullBuild()

     srcActivity2.delete()

     val result = runIncrementalBuild()
     expect.that(result.task(COMPILE_TASK)!!.outcome).isEqualTo(TaskOutcome.SUCCESS)

     // Check annotation processing outputs
     // * All related gen classes from activity 2 should be deleted
     // * Unrelated activities and modules are in isolation and should be unchanged
     // * Root classes along with components are always re-generated (aggregated processor)
     assertDeletedFiles(
       genHiltActivity2,
       genActivityInjector2,
       genActivityInjectorDeps2
     )
     assertChangedFiles(
       FileType.JAVA,
       genHiltApp,
       genAppInjector,
       genAppInjectorDeps,
       genHiltComponents,
       genDaggerHiltApplicationComponent
     )

     // Check compilation outputs
     // * All compiled classes from activity 2 should be deleted
     // * Unrelated activities and modules are in isolation and should be unchanged
     assertDeletedFiles(
       classSrcActivity2,
       classGenHiltActivity2,
       classGenActivityInjector2,
       classGenActivityInjectorDeps2
     )
     assertChangedFiles(
       FileType.CLASS,
       classGenHiltApp,
       classGenAppInjector,
       classGenAppInjectorDeps,
       classGenHiltComponents,
       classGenDaggerHiltApplicationComponent
     )
   }

   @Test
   fun deleteModuleSource() {
     runFullBuild()

     srcModule2.delete()

     val result = runIncrementalBuild()
     expect.that(result.task(COMPILE_TASK)!!.outcome).isEqualTo(TaskOutcome.SUCCESS)

     // Check annotation processing outputs
     // * All related gen classes from module 2 should be deleted
     // * Unrelated activities and modules are in isolation and should be unchanged
     // * Root classes along with components are always re-generated (aggregated processor)
     assertDeletedFiles(
       genModuleDeps2
     )
     assertChangedFiles(
       FileType.JAVA,
       genHiltApp,
       genAppInjector,
       genAppInjectorDeps,
       genHiltComponents,
       genDaggerHiltApplicationComponent
     )

     // Check compilation outputs
     // * All compiled classes from module 2 should be deleted
     // * Unrelated activities and modules are in isolation and should be unchanged
     assertDeletedFiles(
       classSrcModule2,
       classGenModuleDeps2
     )
     assertChangedFiles(
       FileType.CLASS,
       classGenHiltApp,
       classGenAppInjector,
       classGenAppInjectorDeps,
       classGenHiltComponents,
       classGenDaggerHiltApplicationComponent
     )
   }

   private fun runGradleTasks(vararg args: String): BuildResult {
     return GradleRunner.create()
       .withProjectDir(testProjectDir.root)
       .withArguments(*args)
       .withPluginClasspath()
       .forwardOutput()
       .build()
   }

   private fun runFullBuild(): BuildResult {
     val result = runGradleTasks(CLEAN_TASK, COMPILE_TASK)
     recordTimestamps()
     return result
   }

   private fun runIncrementalBuild(): BuildResult {
     val result = runGradleTasks(COMPILE_TASK)
     recordFileChanges()
     return result
   }
   private fun recordTimestamps() {
     val files = listOf(
       genHiltApp,
       genHiltActivity1,
       genHiltActivity2,
       genAppInjector,
       genActivityInjector1,
       genActivityInjector2,
       genAppInjectorDeps,
       genActivityInjectorDeps1,
       genActivityInjectorDeps2,
       genModuleDeps1,
       genModuleDeps2,
       genHiltComponents,
       genDaggerHiltApplicationComponent,
       classSrcApp,
       classSrcActivity1,
       classSrcActivity2,
       classSrcModule1,
       classSrcModule2,
       classGenHiltApp,
       classGenHiltActivity1,
       classGenHiltActivity2,
       classGenAppInjector,
       classGenActivityInjector1,
       classGenActivityInjector2,
       classGenAppInjectorDeps,
       classGenActivityInjectorDeps1,
       classGenActivityInjectorDeps2,
       classGenModuleDeps1,
       classGenModuleDeps2,
       classGenHiltComponents,
       classGenDaggerHiltApplicationComponent
     )

     fileToTimestampMap = mutableMapOf<File, Long>().apply {
       for (file in files) {
         this[file] = file.lastModified()
       }
     }
   }

   private fun recordFileChanges() {
     changedFiles = fileToTimestampMap.filter { (file, previousTimestamp) ->
       file.exists() && file.lastModified() != previousTimestamp
     }.keys

     unchangedFiles = fileToTimestampMap.filter { (file, previousTimestamp) ->
       file.exists() && file.lastModified() == previousTimestamp
     }.keys

     deletedFiles = fileToTimestampMap.filter { (file, _) -> !file.exists() }.keys
   }

   private fun assertFilesExist(vararg files: File) {
     expect.withMessage("Existing files")
       .that(files.filter { it.exists() })
       .containsExactlyElementsIn(files)
   }

   private fun assertChangedFiles(type: FileType, vararg files: File) {
     expect.withMessage("Changed files")
       .that(changedFiles.filter { it.name.endsWith(type.extension) })
       .containsExactlyElementsIn(files)
   }

   private fun assertDeletedFiles(vararg files: File) {
     expect.withMessage("Deleted files").that(deletedFiles).containsAtLeastElementsIn(files)
   }

   private fun searchAndReplace(file: File, search: String, replace: String) {
     file.writeText(file.readText().replace(search, replace))
   }

   enum class FileType(val extension: String) {
     JAVA(".java"),
     CLASS(".class"),
   }

   companion object {
     private const val SRC_DIR = "src/main/java"
     private const val GEN_SRC_DIR = "build/generated/ap_generated_sources/debug/out/"
     private const val CLASS_DIR = "build/intermediates/javac/debug/classes"

     private const val CLEAN_TASK = ":clean"
     private const val COMPILE_TASK = ":compileDebugJavaWithJavac"
   }
 }
	/*
	* Copyright (C) 2020 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.
	*/

	import com.google.common.truth.Expect
	import java.io.File
	import org.gradle.testkit.runner.BuildResult
	import org.gradle.testkit.runner.GradleRunner
	import org.gradle.testkit.runner.TaskOutcome
	import org.junit.Before
	import org.junit.Rule
	import org.junit.Test
	import org.junit.rules.TemporaryFolder

	/**
	* Tests to verify Gradle annotation processor incremental compilation.
	*
	* To run these tests first deploy artifacts to local maven via util/install-local-snapshot.sh.
	*/
	class IncrementalProcessorTest {

	@get:Rule
	val testProjectDir = TemporaryFolder()

	@get:Rule
	val expect: Expect = Expect.create()

	// Original source files
	private lateinit var srcApp: File
	private lateinit var srcActivity1: File
	private lateinit var srcActivity2: File
	private lateinit var srcModule1: File
	private lateinit var srcModule2: File

	// Generated source files
	private lateinit var genHiltApp: File
	private lateinit var genHiltActivity1: File
	private lateinit var genHiltActivity2: File
	private lateinit var genAppInjector: File
	private lateinit var genActivityInjector1: File
	private lateinit var genActivityInjector2: File
	private lateinit var genAppInjectorDeps: File
	private lateinit var genActivityInjectorDeps1: File
	private lateinit var genActivityInjectorDeps2: File
	private lateinit var genModuleDeps1: File
	private lateinit var genModuleDeps2: File
	private lateinit var genHiltComponents: File
	private lateinit var genDaggerHiltApplicationComponent: File

	// Compiled classes
	private lateinit var classSrcApp: File
	private lateinit var classSrcActivity1: File
	private lateinit var classSrcActivity2: File
	private lateinit var classSrcModule1: File
	private lateinit var classSrcModule2: File
	private lateinit var classGenHiltApp: File
	private lateinit var classGenHiltActivity1: File
	private lateinit var classGenHiltActivity2: File
	private lateinit var classGenAppInjector: File
	private lateinit var classGenActivityInjector1: File
	private lateinit var classGenActivityInjector2: File
	private lateinit var classGenAppInjectorDeps: File
	private lateinit var classGenActivityInjectorDeps1: File
	private lateinit var classGenActivityInjectorDeps2: File
	private lateinit var classGenModuleDeps1: File
	private lateinit var classGenModuleDeps2: File
	private lateinit var classGenHiltComponents: File
	private lateinit var classGenDaggerHiltApplicationComponent: File

	// Timestamps of files
	private lateinit var fileToTimestampMap: Map<File, Long>

	// Sets of files that have changed/not changed/deleted
	private lateinit var changedFiles: Set<File>
	private lateinit var unchangedFiles: Set<File>
	private lateinit var deletedFiles: Set<File>

	@Before
	fun setup() {
	val projectRoot = testProjectDir.root
	// copy test project
	File("src/test/data/simple-project").copyRecursively(projectRoot)

	// set up build file
	File(projectRoot, "build.gradle").writeText(
	"""
	buildscript {
	repositories {
	google()
	jcenter()
	}
	dependencies {
	classpath 'com.android.tools.build:gradle:3.5.3'
	}
	}

	plugins {
	id 'com.android.application'
	}

	android {
	compileSdkVersion 30
	buildToolsVersion "30.0.2"

	defaultConfig {
	applicationId "hilt.simple"
	minSdkVersion 21
	targetSdkVersion 30
	}

	compileOptions {
	sourceCompatibility 1.8
	targetCompatibility 1.8
	}
	}

	repositories {
	mavenLocal()
	google()
	jcenter()
	}

	dependencies {
	implementation 'androidx.appcompat:appcompat:1.1.0'
	implementation 'com.google.dagger:dagger:LOCAL-SNAPSHOT'
	annotationProcessor 'com.google.dagger:dagger-compiler:LOCAL-SNAPSHOT'
	implementation 'com.google.dagger:hilt-android:LOCAL-SNAPSHOT'
	annotationProcessor 'com.google.dagger:hilt-compiler:LOCAL-SNAPSHOT'
	}
	""".trimIndent()
	)

	// Compute file paths
	srcApp = File(projectRoot, "$SRC_DIR/simple/SimpleApp.java")
	srcActivity1 = File(projectRoot, "$SRC_DIR/simple/Activity1.java")
	srcActivity2 = File(projectRoot, "$SRC_DIR/simple/Activity2.java")
	srcModule1 = File(projectRoot, "$SRC_DIR/simple/Module1.java")
	srcModule2 = File(projectRoot, "$SRC_DIR/simple/Module2.java")

	genHiltApp = File(projectRoot, "$GEN_SRC_DIR/simple/Hilt_SimpleApp.java")
	genHiltActivity1 = File(projectRoot, "$GEN_SRC_DIR/simple/Hilt_Activity1.java")
	genHiltActivity2 = File(projectRoot, "$GEN_SRC_DIR/simple/Hilt_Activity2.java")
	genAppInjector = File(projectRoot, "$GEN_SRC_DIR/simple/SimpleApp_GeneratedInjector.java")
	genActivityInjector1 = File(projectRoot, "$GEN_SRC_DIR/simple/Activity1_GeneratedInjector.java")
	genActivityInjector2 = File(projectRoot, "$GEN_SRC_DIR/simple/Activity2_GeneratedInjector.java")
	genAppInjectorDeps = File(
	projectRoot,
	"$GEN_SRC_DIR/hilt_aggregated_deps/simple_SimpleApp_GeneratedInjectorModuleDeps.java"
	)
	genActivityInjectorDeps1 = File(
	projectRoot,
	"$GEN_SRC_DIR/hilt_aggregated_deps/simple_Activity1_GeneratedInjectorModuleDeps.java"
	)
	genActivityInjectorDeps2 = File(
	projectRoot,
	"$GEN_SRC_DIR/hilt_aggregated_deps/simple_Activity2_GeneratedInjectorModuleDeps.java"
	)
	genModuleDeps1 = File(
	projectRoot,
	"$GEN_SRC_DIR/hilt_aggregated_deps/simple_Module1ModuleDeps.java"
	)
	genModuleDeps2 = File(
	projectRoot,
	"$GEN_SRC_DIR/hilt_aggregated_deps/simple_Module2ModuleDeps.java"
	)
	genHiltComponents = File(
	projectRoot,
	"$GEN_SRC_DIR/simple/SimpleApp_HiltComponents.java"
	)
	genDaggerHiltApplicationComponent = File(
	projectRoot,
	"$GEN_SRC_DIR/simple/DaggerSimpleApp_HiltComponents_SingletonC.java"
	)

	classSrcApp = File(projectRoot, "$CLASS_DIR/simple/SimpleApp.class")
	classSrcActivity1 = File(projectRoot, "$CLASS_DIR/simple/Activity1.class")
	classSrcActivity2 = File(projectRoot, "$CLASS_DIR/simple/Activity2.class")
	classSrcModule1 = File(projectRoot, "$CLASS_DIR/simple/Module1.class")
	classSrcModule2 = File(projectRoot, "$CLASS_DIR/simple/Module2.class")
	classGenHiltApp = File(projectRoot, "$CLASS_DIR/simple/Hilt_SimpleApp.class")
	classGenHiltActivity1 = File(projectRoot, "$CLASS_DIR/simple/Hilt_Activity1.class")
	classGenHiltActivity2 = File(projectRoot, "$CLASS_DIR/simple/Hilt_Activity2.class")
	classGenAppInjector = File(projectRoot, "$CLASS_DIR/simple/SimpleApp_GeneratedInjector.class")
	classGenActivityInjector1 = File(
	projectRoot,
	"$CLASS_DIR/simple/Activity1_GeneratedInjector.class"
	)
	classGenActivityInjector2 = File(
	projectRoot,
	"$CLASS_DIR/simple/Activity2_GeneratedInjector.class"
	)
	classGenAppInjectorDeps = File(
	projectRoot,
	"$CLASS_DIR/hilt_aggregated_deps/simple_SimpleApp_GeneratedInjectorModuleDeps.class"
	)
	classGenActivityInjectorDeps1 = File(
	projectRoot,
	"$CLASS_DIR/hilt_aggregated_deps/simple_Activity1_GeneratedInjectorModuleDeps.class"
	)
	classGenActivityInjectorDeps2 = File(
	projectRoot,
	"$CLASS_DIR/hilt_aggregated_deps/simple_Activity2_GeneratedInjectorModuleDeps.class"
	)
	classGenModuleDeps1 = File(
	projectRoot,
	"$CLASS_DIR/hilt_aggregated_deps/simple_Module1ModuleDeps.class"
	)
	classGenModuleDeps2 = File(
	projectRoot,
	"$CLASS_DIR/hilt_aggregated_deps/simple_Module2ModuleDeps.class"
	)
	classGenHiltComponents = File(
	projectRoot,
	"$CLASS_DIR/simple/SimpleApp_HiltComponents.class"
	)
	classGenDaggerHiltApplicationComponent = File(
	projectRoot,
	"$CLASS_DIR/simple/DaggerSimpleApp_HiltComponents_SingletonC.class"
	)
	}

	@Test
	fun firstFullBuild() {
	// This test verifies the results of the first full (non-incremental) build. The other tests
	// verify the results of the second incremental build based on different change scenarios.
	val result = runFullBuild()
	expect.that(result.task(COMPILE_TASK)!!.outcome).isEqualTo(TaskOutcome.SUCCESS)

	// Check annotation processing outputs
	assertFilesExist(
	genHiltApp,
	genHiltActivity1,
	genHiltActivity2,
	genAppInjector,
	genActivityInjector1,
	genActivityInjector2,
	genAppInjectorDeps,
	genActivityInjectorDeps1,
	genActivityInjectorDeps2,
	genModuleDeps1,
	genModuleDeps2,
	genHiltComponents,
	genDaggerHiltApplicationComponent
	)

	// Check compilation outputs
	assertFilesExist(
	classSrcApp,
	classSrcActivity1,
	classSrcActivity2,
	classSrcModule1,
	classSrcModule2,
	classGenHiltApp,
	classGenHiltActivity1,
	classGenHiltActivity2,
	classGenAppInjector,
	classGenActivityInjector1,
	classGenActivityInjector2,
	classGenAppInjectorDeps,
	classGenActivityInjectorDeps1,
	classGenActivityInjectorDeps2,
	classGenModuleDeps1,
	classGenModuleDeps2,
	classGenHiltComponents,
	classGenDaggerHiltApplicationComponent
	)
	}

	@Test
	fun changeActivitySource() {
	runFullBuild()

	// Change Activity 1 source
	searchAndReplace(
	srcActivity1, "// Insert-change",
	"""
	@Override
	public void onResume() {
	super.onResume();
	}
	""".trimIndent()
	)

	val result = runIncrementalBuild()
	expect.that(result.task(COMPILE_TASK)!!.outcome).isEqualTo(TaskOutcome.SUCCESS)

	// Check annotation processing outputs
	// * Only activity 1 sources are re-generated, isolation in modules and from other activities
	// * Root classes along with components are always re-generated (aggregated processor)
	assertChangedFiles(
	FileType.JAVA,
	genHiltApp,
	genHiltActivity1,
	genAppInjector,
	genActivityInjector1,
	genAppInjectorDeps,
	genActivityInjectorDeps1,
	genHiltComponents,
	genDaggerHiltApplicationComponent
	)

	// Check compilation outputs
	// * Gen sources from activity 1 are re-compiled
	// * All aggregating processor gen sources are re-compiled
	assertChangedFiles(
	FileType.CLASS,
	classSrcActivity1,
	classGenHiltApp,
	classGenHiltActivity1,
	classGenAppInjector,
	classGenActivityInjector1,
	classGenAppInjectorDeps,
	classGenActivityInjectorDeps1,
	classGenHiltComponents,
	classGenDaggerHiltApplicationComponent
	)
	}

	@Test
	fun changeModuleSource() {
	runFullBuild()

	// Change Module 1 source
	searchAndReplace(
	srcModule1, "// Insert-change",
	"""
	@Provides
	static double provideDouble() {
	return 10.10;
	}
	""".trimIndent()
	)

	val result = runIncrementalBuild()
	expect.that(result.task(COMPILE_TASK)!!.outcome).isEqualTo(TaskOutcome.SUCCESS)

	// Check annotation processing outputs
	// * Only module 1 sources are re-generated, isolation from other modules
	// * Root classes along with components are always re-generated (aggregated processor)
	assertChangedFiles(
	FileType.JAVA,
	genHiltApp,
	genAppInjector,
	genAppInjectorDeps,
	genModuleDeps1,
	genHiltComponents,
	genDaggerHiltApplicationComponent
	)

	// Check compilation outputs
	// * Gen sources from module 1 are re-compiled
	// * All aggregating processor gen sources are re-compiled
	assertChangedFiles(
	FileType.CLASS,
	classSrcModule1,
	classGenHiltApp,
	classGenAppInjector,
	classGenAppInjectorDeps,
	classGenModuleDeps1,
	classGenHiltComponents,
	classGenDaggerHiltApplicationComponent
	)
	}

	@Test
	fun changeAppSource() {
	runFullBuild()

	// Change Application source
	searchAndReplace(
	srcApp, "// Insert-change",
	"""
	@Override
	public void onCreate() {
	super.onCreate();
	}
	""".trimIndent()
	)

	val result = runIncrementalBuild()
	expect.that(result.task(COMPILE_TASK)!!.outcome).isEqualTo(TaskOutcome.SUCCESS)

	// Check annotation processing outputs
	// * No modules or activities (or any other non-root) classes should be generated
	// * Root classes along with components are always re-generated (aggregated processor)
	assertChangedFiles(
	FileType.JAVA,
	genHiltApp,
	genAppInjector,
	genAppInjectorDeps,
	genHiltComponents,
	genDaggerHiltApplicationComponent
	)

	// Check compilation outputs
	// * All aggregating processor gen sources are re-compiled
	assertChangedFiles(
	FileType.CLASS,
	classSrcApp, // re-compiles because superclass re-compiled
	classGenHiltApp,
	classGenAppInjector,
	classGenAppInjectorDeps,
	classGenHiltComponents,
	classGenDaggerHiltApplicationComponent
	)
	}

	@Test
	fun deleteActivitySource() {
	runFullBuild()

	srcActivity2.delete()

	val result = runIncrementalBuild()
	expect.that(result.task(COMPILE_TASK)!!.outcome).isEqualTo(TaskOutcome.SUCCESS)

	// Check annotation processing outputs
	// * All related gen classes from activity 2 should be deleted
	// * Unrelated activities and modules are in isolation and should be unchanged
	// * Root classes along with components are always re-generated (aggregated processor)
	assertDeletedFiles(
	genHiltActivity2,
	genActivityInjector2,
	genActivityInjectorDeps2
	)
	assertChangedFiles(
	FileType.JAVA,
	genHiltApp,
	genAppInjector,
	genAppInjectorDeps,
	genHiltComponents,
	genDaggerHiltApplicationComponent
	)

	// Check compilation outputs
	// * All compiled classes from activity 2 should be deleted
	// * Unrelated activities and modules are in isolation and should be unchanged
	assertDeletedFiles(
	classSrcActivity2,
	classGenHiltActivity2,
	classGenActivityInjector2,
	classGenActivityInjectorDeps2
	)
	assertChangedFiles(
	FileType.CLASS,
	classGenHiltApp,
	classGenAppInjector,
	classGenAppInjectorDeps,
	classGenHiltComponents,
	classGenDaggerHiltApplicationComponent
	)
	}

	@Test
	fun deleteModuleSource() {
	runFullBuild()

	srcModule2.delete()

	val result = runIncrementalBuild()
	expect.that(result.task(COMPILE_TASK)!!.outcome).isEqualTo(TaskOutcome.SUCCESS)

	// Check annotation processing outputs
	// * All related gen classes from module 2 should be deleted
	// * Unrelated activities and modules are in isolation and should be unchanged
	// * Root classes along with components are always re-generated (aggregated processor)
	assertDeletedFiles(
	genModuleDeps2
	)
	assertChangedFiles(
	FileType.JAVA,
	genHiltApp,
	genAppInjector,
	genAppInjectorDeps,
	genHiltComponents,
	genDaggerHiltApplicationComponent
	)

	// Check compilation outputs
	// * All compiled classes from module 2 should be deleted
	// * Unrelated activities and modules are in isolation and should be unchanged
	assertDeletedFiles(
	classSrcModule2,
	classGenModuleDeps2
	)
	assertChangedFiles(
	FileType.CLASS,
	classGenHiltApp,
	classGenAppInjector,
	classGenAppInjectorDeps,
	classGenHiltComponents,
	classGenDaggerHiltApplicationComponent
	)
	}

	private fun runGradleTasks(vararg args: String): BuildResult {
	return GradleRunner.create()
	.withProjectDir(testProjectDir.root)
	.withArguments(*args)
	.withPluginClasspath()
	.forwardOutput()
	.build()
	}

	private fun runFullBuild(): BuildResult {
	val result = runGradleTasks(CLEAN_TASK, COMPILE_TASK)
	recordTimestamps()
	return result
	}

	private fun runIncrementalBuild(): BuildResult {
	val result = runGradleTasks(COMPILE_TASK)
	recordFileChanges()
	return result
	}
	private fun recordTimestamps() {
	val files = listOf(
	genHiltApp,
	genHiltActivity1,
	genHiltActivity2,
	genAppInjector,
	genActivityInjector1,
	genActivityInjector2,
	genAppInjectorDeps,
	genActivityInjectorDeps1,
	genActivityInjectorDeps2,
	genModuleDeps1,
	genModuleDeps2,
	genHiltComponents,
	genDaggerHiltApplicationComponent,
	classSrcApp,
	classSrcActivity1,
	classSrcActivity2,
	classSrcModule1,
	classSrcModule2,
	classGenHiltApp,
	classGenHiltActivity1,
	classGenHiltActivity2,
	classGenAppInjector,
	classGenActivityInjector1,
	classGenActivityInjector2,
	classGenAppInjectorDeps,
	classGenActivityInjectorDeps1,
	classGenActivityInjectorDeps2,
	classGenModuleDeps1,
	classGenModuleDeps2,
	classGenHiltComponents,
	classGenDaggerHiltApplicationComponent
	)

	fileToTimestampMap = mutableMapOf<File, Long>().apply {
	for (file in files) {
	this[file] = file.lastModified()
	}
	}
	}

	private fun recordFileChanges() {
	changedFiles = fileToTimestampMap.filter { (file, previousTimestamp) ->
	file.exists() && file.lastModified() != previousTimestamp
	}.keys

	unchangedFiles = fileToTimestampMap.filter { (file, previousTimestamp) ->
	file.exists() && file.lastModified() == previousTimestamp
	}.keys

	deletedFiles = fileToTimestampMap.filter { (file, _) -> !file.exists() }.keys
	}

	private fun assertFilesExist(vararg files: File) {
	expect.withMessage("Existing files")
	.that(files.filter { it.exists() })
	.containsExactlyElementsIn(files)
	}

	private fun assertChangedFiles(type: FileType, vararg files: File) {
	expect.withMessage("Changed files")
	.that(changedFiles.filter { it.name.endsWith(type.extension) })
	.containsExactlyElementsIn(files)
	}

	private fun assertDeletedFiles(vararg files: File) {
	expect.withMessage("Deleted files").that(deletedFiles).containsAtLeastElementsIn(files)
	}

	private fun searchAndReplace(file: File, search: String, replace: String) {
	file.writeText(file.readText().replace(search, replace))
	}

	enum class FileType(val extension: String) {
	JAVA(".java"),
	CLASS(".class"),
	}

	companion object {
	private const val SRC_DIR = "src/main/java"
	private const val GEN_SRC_DIR = "build/generated/ap_generated_sources/debug/out/"
	private const val CLASS_DIR = "build/intermediates/javac/debug/classes"

	private const val CLEAN_TASK = ":clean"
	private const val COMPILE_TASK = ":compileDebugJavaWithJavac"
	}
	}