build-system/gradle-core/src/test/java/com/android/build/gradle/internal/transforms/DexArchiveBuilderTransformDesugaringTest.java - platform/tools/base - Git at Google

 /*
  * Copyright (C) 2017 The Android Open Source Project
  *
  * 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 com.android.build.gradle.internal.transforms;

 import static com.android.build.api.transform.Status.CHANGED;
 import static com.android.build.api.transform.Status.REMOVED;
 import static com.android.testutils.truth.PathSubject.assertThat;
 import static com.google.common.truth.Truth.assertThat;

 import com.android.annotations.NonNull;
 import com.android.annotations.Nullable;
 import com.android.build.api.transform.QualifiedContent;
 import com.android.build.api.transform.Status;
 import com.android.build.api.transform.TransformException;
 import com.android.build.api.transform.TransformInput;
 import com.android.build.api.transform.TransformInvocation;
 import com.android.build.api.transform.TransformOutputProvider;
 import com.android.build.gradle.internal.scope.VariantScope;
 import com.android.build.gradle.internal.transforms.testdata.Animal;
 import com.android.build.gradle.internal.transforms.testdata.CarbonForm;
 import com.android.build.gradle.internal.transforms.testdata.Cat;
 import com.android.build.gradle.internal.transforms.testdata.Tiger;
 import com.android.build.gradle.internal.transforms.testdata.Toy;
 import com.android.builder.core.DefaultDexOptions;
 import com.android.builder.dexing.DexerTool;
 import com.android.builder.utils.FileCache;
 import com.android.testutils.TestInputsGenerator;
 import com.android.testutils.TestUtils;
 import com.android.testutils.truth.MoreTruth;
 import com.android.utils.FileUtils;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Iterables;
 import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;

 public class DexArchiveBuilderTransformDesugaringTest {

     private TransformOutputProvider outputProvider;
     private Path out;
     @Rule public TemporaryFolder tmpDir = new TemporaryFolder();

     @Before
     public void setUp() throws IOException {
         out = tmpDir.getRoot().toPath().resolve("out");
         Files.createDirectories(out);
         outputProvider = new TestTransformOutputProvider(out);
     }

     @Test
     public void testLambdas() throws Exception {
         Path input = tmpDir.getRoot().toPath().resolve("input");
         TestInputsGenerator.pathWithClasses(
                 input, ImmutableSet.of(CarbonForm.class, Animal.class, Cat.class, Toy.class));

         TransformInput dirInput = TransformTestHelper.directoryBuilder(input.toFile()).build();

         TransformInvocation invocation =
                 TransformTestHelper.invocationBuilder()
                         .setTransformOutputProvider(outputProvider)
                         .addInput(dirInput)
                         .setIncremental(false)
                         .build();
         getTransform(null, 15, true, false).transform(invocation);

         // it should contain Cat and synthesized lambda class
         MoreTruth.assertThatDex(getDex(Cat.class)).hasClassesCount(2);
     }

     interface WithDefault {
         default void foo() {}
     }

     interface WithStatic {
         static void bar() {}
     }

     static class ImplementsWithDefault implements WithDefault {}

     static class InvokesDefault {
         public static void main(String[] args) {
             new ImplementsWithDefault().foo();
         }
     }

     @Test
     public void testDefaultMethods_minApiBelow24() throws Exception {
         Path input = tmpDir.getRoot().toPath().resolve("input");
         TestInputsGenerator.pathWithClasses(
                 input, ImmutableSet.of(WithDefault.class, WithStatic.class));

         TransformInput dirInput = TransformTestHelper.directoryBuilder(input.toFile()).build();

         TransformInvocation invocation =
                 TransformTestHelper.invocationBuilder()
                         .setTransformOutputProvider(outputProvider)
                         .addInput(dirInput)
                         .setIncremental(false)
                         .build();
         getTransform(null, 23, true, false).transform(invocation);

         // it contains both original and synthesized
         MoreTruth.assertThatDex(getDex(WithDefault.class)).hasClassesCount(2);
         MoreTruth.assertThatDex(getDex(WithStatic.class)).hasClassesCount(2);
     }

     @Test
     public void testDefaultMethods_minApiAbove24() throws Exception {
         Path input = tmpDir.getRoot().toPath().resolve("input");
         TestInputsGenerator.pathWithClasses(
                 input, ImmutableSet.of(WithDefault.class, WithStatic.class));

         TransformInput dirInput = TransformTestHelper.directoryBuilder(input.toFile()).build();

         TransformInvocation invocation =
                 TransformTestHelper.invocationBuilder()
                         .setTransformOutputProvider(outputProvider)
                         .addInput(dirInput)
                         .setIncremental(false)
                         .build();
         getTransform(null, 24, true, false).transform(invocation);

         // it contains only the original class
         MoreTruth.assertThatDex(getDex(WithDefault.class)).hasClassesCount(1);
         MoreTruth.assertThatDex(getDex(WithStatic.class)).hasClassesCount(1);
     }

     @Test
     public void testIncremental_lambdaClass() throws Exception {
         Path input = tmpDir.getRoot().toPath().resolve("input");
         TestInputsGenerator.pathWithClasses(
                 input, ImmutableSet.of(CarbonForm.class, Animal.class, Cat.class, Toy.class));

         TransformInput dirInput = TransformTestHelper.directoryBuilder(input.toFile()).build();

         TransformInvocation invocation =
                 TransformTestHelper.invocationBuilder()
                         .setTransformOutputProvider(outputProvider)
                         .addInput(dirInput)
                         .setIncremental(false)
                         .build();
         getTransform(null).transform(invocation);

         File catDex = getDex(Cat.class);
         File animalDex = getDex(Animal.class);
         long catTimestamp = catDex.lastModified();
         long animalTimestamp = animalDex.lastModified();

         TestUtils.waitForFileSystemTick();

         dirInput =
                 TransformTestHelper.directoryBuilder(input.toFile())
                         .putChangedFiles(getChangedStatusMap(input, CHANGED, Toy.class))
                         .build();
         invocation =
                 TransformTestHelper.invocationBuilder()
                         .setIncremental(true)
                         .setTransformOutputProvider(outputProvider)
                         .addInput(dirInput)
                         .build();

         getTransform(null).transform(invocation);
         catDex = getDex(Cat.class);
         animalDex = getDex(Animal.class);
         assertThat(catTimestamp).isLessThan(catDex.lastModified());
         assertThat(animalTimestamp).isEqualTo(animalDex.lastModified());
     }

     @Test
     public void testIncremental_lambdaClass_removed() throws Exception {
         Path input = tmpDir.getRoot().toPath().resolve("input");
         TestInputsGenerator.pathWithClasses(
                 input, ImmutableSet.of(CarbonForm.class, Animal.class, Cat.class, Toy.class));

         TransformInput dirInput = TransformTestHelper.directoryBuilder(input.toFile()).build();

         TransformInvocation invocation =
                 TransformTestHelper.invocationBuilder()
                         .setTransformOutputProvider(outputProvider)
                         .addInput(dirInput)
                         .setIncremental(false)
                         .build();
         getTransform(null).transform(invocation);

         File catDex = getDex(Cat.class);
         File animalDex = getDex(Animal.class);
         long catTimestamp = catDex.lastModified();
         long animalTimestamp = animalDex.lastModified();

         TestUtils.waitForFileSystemTick();

         dirInput =
                 TransformTestHelper.directoryBuilder(input.toFile())
                         .putChangedFiles(getChangedStatusMap(input, REMOVED, Toy.class))
                         .build();
         invocation =
                 TransformTestHelper.invocationBuilder()
                         .setIncremental(true)
                         .setTransformOutputProvider(outputProvider)
                         .addInput(dirInput)
                         .build();

         File toyDex = getDex(Toy.class);
         getTransform(null).transform(invocation);
         catDex = getDex(Cat.class);
         animalDex = getDex(Animal.class);
         assertThat(catTimestamp).isLessThan(catDex.lastModified());
         assertThat(animalTimestamp).isEqualTo(animalDex.lastModified());

         assertThat(toyDex).doesNotExist();
     }

     @Test
     public void testIncremental_changeSuperTypes() throws Exception {
         Path input = tmpDir.getRoot().toPath().resolve("input");
         TestInputsGenerator.pathWithClasses(
                 input,
                 ImmutableSet.of(CarbonForm.class, Animal.class, Cat.class, Tiger.class, Toy.class));

         TransformInput dirInput = TransformTestHelper.directoryBuilder(input.toFile()).build();

         TransformInvocation invocation =
                 TransformTestHelper.invocationBuilder()
                         .setTransformOutputProvider(outputProvider)
                         .addInput(dirInput)
                         .setIncremental(false)
                         .build();
         getTransform(null).transform(invocation);

         File tigerDex = getDex(Tiger.class);
         File carbonFormDex = getDex(CarbonForm.class);
         long tigerTimestamp = tigerDex.lastModified();
         long carbonFormTimestamp = carbonFormDex.lastModified();

         dirInput =
                 TransformTestHelper.directoryBuilder(input.toFile())
                         .putChangedFiles(getChangedStatusMap(input, CHANGED, Animal.class))
                         .build();
         invocation =
                 TransformTestHelper.invocationBuilder()
                         .setIncremental(true)
                         .setTransformOutputProvider(outputProvider)
                         .addInput(dirInput)
                         .build();

         TestUtils.waitForFileSystemTick();
         getTransform(null).transform(invocation);
         tigerDex = getDex(Tiger.class);
         carbonFormDex = getDex(CarbonForm.class);
         assertThat(tigerTimestamp).isLessThan(tigerDex.lastModified());
         assertThat(carbonFormTimestamp).isEqualTo(carbonFormDex.lastModified());

         dirInput =
                 TransformTestHelper.directoryBuilder(input.toFile())
                         .putChangedFiles(getChangedStatusMap(input, CHANGED, Cat.class))
                         .build();
         invocation =
                 TransformTestHelper.invocationBuilder()
                         .setIncremental(true)
                         .setTransformOutputProvider(outputProvider)
                         .addInput(dirInput)
                         .build();

         TestUtils.waitForFileSystemTick();
         getTransform(null).transform(invocation);
         tigerDex = getDex(Tiger.class);
         carbonFormDex = getDex(CarbonForm.class);
         assertThat(tigerTimestamp).isLessThan(tigerDex.lastModified());
         assertThat(carbonFormTimestamp).isEqualTo(carbonFormDex.lastModified());
     }

     @Test
     public void test_incremental_full_incremental()
             throws IOException, TransformException, InterruptedException {
         Path input = tmpDir.getRoot().toPath().resolve("input");
         TestInputsGenerator.pathWithClasses(input, ImmutableSet.of(CarbonForm.class, Animal.class));

         TransformInput dirInput =
                 TransformTestHelper.directoryBuilder(input.toFile())
                         .putChangedFiles(
                                 getChangedStatusMap(
                                         input, Status.ADDED, CarbonForm.class, Animal.class))
                         .build();
         TransformInvocation invocation =
                 TransformTestHelper.invocationBuilder()
                         .setTransformOutputProvider(outputProvider)
                         .addInput(dirInput)
                         .setIncremental(true)
                         .build();
         getTransform(null).transform(invocation);
         File animalDex = getDex(Animal.class);

         dirInput = TransformTestHelper.directoryBuilder(input.toFile()).build();
         invocation =
                 TransformTestHelper.invocationBuilder()
                         .setTransformOutputProvider(outputProvider)
                         .addInput(dirInput)
                         .setIncremental(false)
                         .build();
         getTransform(null).transform(invocation);

         dirInput =
                 TransformTestHelper.directoryBuilder(input.toFile())
                         .putChangedFiles(getChangedStatusMap(input, Status.REMOVED, Animal.class))
                         .build();
         invocation =
                 TransformTestHelper.invocationBuilder()
                         .setTransformOutputProvider(outputProvider)
                         .addInput(dirInput)
                         .setIncremental(true)
                         .build();
         getTransform(null).transform(invocation);
         assertThat(getDex(CarbonForm.class)).exists();
         assertThat(animalDex).doesNotExist();
     }

     @Test
     public void test_incremental_jarAndDir()
             throws IOException, TransformException, InterruptedException {
         Path jar = tmpDir.getRoot().toPath().resolve("input.jar");
         Path input = tmpDir.getRoot().toPath().resolve("input");
         TestInputsGenerator.pathWithClasses(jar, ImmutableSet.of(CarbonForm.class, Animal.class));
         TestInputsGenerator.pathWithClasses(
                 input, ImmutableSet.of(Toy.class, Cat.class, Tiger.class));

         TransformInput dirInput = TransformTestHelper.directoryBuilder(input.toFile()).build();
         TransformInput jarInput = TransformTestHelper.singleJarBuilder(jar.toFile()).build();
         TransformInvocation invocation =
                 TransformTestHelper.invocationBuilder()
                         .setTransformOutputProvider(outputProvider)
                         .addInput(dirInput)
                         .addInput(jarInput)
                         .setIncremental(false)
                         .build();
         getTransform(null).transform(invocation);
         long catTimestamp = getDex(Cat.class).lastModified();
         long toyTimestamp = getDex(Toy.class).lastModified();

         jarInput =
                 TransformTestHelper.singleJarBuilder(jar.toFile())
                         .setStatus(Status.CHANGED)
                         .build();
         invocation =
                 TransformTestHelper.invocationBuilder()
                         .setTransformOutputProvider(outputProvider)
                         .addInput(dirInput)
                         .addInput(jarInput)
                         .setIncremental(true)
                         .build();
         TestUtils.waitForFileSystemTick();
         getTransform(null).transform(invocation);

         assertThat(catTimestamp).isLessThan(getDex(Cat.class).lastModified());
         assertThat(toyTimestamp).isEqualTo(getDex(Toy.class).lastModified());
     }

     /** Regression test to make sure we do not add unchanged files to cache. */
     @Test
     public void test_incremental_notChangedNotAddedToCache() throws Exception {
         Path jar = tmpDir.getRoot().toPath().resolve("input.jar");
         TestInputsGenerator.pathWithClasses(jar, ImmutableSet.of(CarbonForm.class, Animal.class));

         TransformInput jarInput =
                 TransformTestHelper.singleJarBuilder(jar.toFile())
                         .setScopes(QualifiedContent.Scope.EXTERNAL_LIBRARIES)
                         .setContentTypes(QualifiedContent.DefaultContentType.CLASSES)
                         .build();
         TransformInvocation invocation =
                 TransformTestHelper.invocationBuilder()
                         .setTransformOutputProvider(outputProvider)
                         .addInput(jarInput)
                         .setIncremental(false)
                         .build();
         FileCache cache = FileCache.getInstanceWithSingleProcessLocking(tmpDir.newFolder());
         getTransform(cache).transform(invocation);
         String[] numEntries = Objects.requireNonNull(cache.getCacheDirectory().list());

         File referencedJar = tmpDir.newFile("referenced.jar");
         TestInputsGenerator.jarWithEmptyClasses(referencedJar.toPath(), ImmutableList.of("A"));
         TransformInput referencedInput =
                 TransformTestHelper.singleJarBuilder(referencedJar).build();

         jarInput =
                 TransformTestHelper.singleJarBuilder(jar.toFile())
                         .setStatus(Status.NOTCHANGED)
                         .setScopes(QualifiedContent.Scope.EXTERNAL_LIBRARIES)
                         .setContentTypes(QualifiedContent.DefaultContentType.CLASSES)
                         .build();
         invocation =
                 TransformTestHelper.invocationBuilder()
                         .setTransformOutputProvider(outputProvider)
                         .addInput(jarInput)
                         .addReferenceInput(referencedInput)
                         .setIncremental(true)
                         .build();
         getTransform(cache).transform(invocation);
         assertThat(cache.getCacheDirectory().list()).named("cache entries").isEqualTo(numEntries);
     }

     @Test
     public void test_duplicateClasspathEntries() throws Exception {

         Path lib1 = tmpDir.getRoot().toPath().resolve("lib1.jar");
         TestInputsGenerator.pathWithClasses(
                 lib1, ImmutableSet.of(ImplementsWithDefault.class, WithDefault.class));
         Path lib2 = tmpDir.getRoot().toPath().resolve("lib2.jar");
         TestInputsGenerator.pathWithClasses(lib2, ImmutableSet.of(WithDefault.class));
         Path app = tmpDir.getRoot().toPath().resolve("app");
         TestInputsGenerator.pathWithClasses(app, ImmutableSet.of(InvokesDefault.class));

         TransformInput lib1Input =
                 TransformTestHelper.singleJarBuilder(lib1.toFile())
                         .setScopes(QualifiedContent.Scope.EXTERNAL_LIBRARIES)
                         .setContentTypes(QualifiedContent.DefaultContentType.CLASSES)
                         .build();
         TransformInput lib2Input =
                 TransformTestHelper.singleJarBuilder(lib2.toFile())
                         .setScopes(QualifiedContent.Scope.EXTERNAL_LIBRARIES)
                         .setContentTypes(QualifiedContent.DefaultContentType.CLASSES)
                         .build();
         TransformInput appInput = TransformTestHelper.directoryBuilder(app.toFile()).build();

         TransformInvocation invocation =
                 TransformTestHelper.invocationBuilder()
                         .setTransformOutputProvider(outputProvider)
                         .addInput(lib1Input)
                         .addInput(lib2Input)
                         .addInput(appInput)
                         .setIncremental(false)
                         .build();
         getTransform(null, 15, true, true).transform(invocation);

         MoreTruth.assertThatDex(getDex(InvokesDefault.class)).hasClassesCount(1);
     }

     /** Regression test for b/117062425. */
     @Test
     public void test_incrementalDesugaringWithCaching() throws Exception {
         Path lib1 = tmpDir.getRoot().toPath().resolve("lib1.jar");
         TestInputsGenerator.pathWithClasses(lib1, ImmutableSet.of(ImplementsWithDefault.class));
         Path lib2 = tmpDir.getRoot().toPath().resolve("lib2.jar");
         TestInputsGenerator.pathWithClasses(lib2, ImmutableSet.of(WithDefault.class));

         TransformInput lib1Input =
                 TransformTestHelper.singleJarBuilder(lib1.toFile())
                         .setScopes(QualifiedContent.Scope.EXTERNAL_LIBRARIES)
                         .setContentTypes(QualifiedContent.DefaultContentType.CLASSES)
                         .build();
         // Mimics dex that from cache for lib1.jar. Transform invocation should remove it.
         Files.createFile(out.resolve("lib1.jar.jar"));

         TransformInput lib2Input =
                 TransformTestHelper.singleJarBuilder(lib2.toFile())
                         .setScopes(QualifiedContent.Scope.EXTERNAL_LIBRARIES)
                         .setContentTypes(QualifiedContent.DefaultContentType.CLASSES)
                         .setStatus(Status.CHANGED)
                         .build();
         TransformInvocation invocation =
                 TransformTestHelper.invocationBuilder()
                         .setTransformOutputProvider(outputProvider)
                         .addInput(lib1Input)
                         .addInput(lib2Input)
                         .setIncremental(true)
                         .build();
         getTransform(null, 15, true, true).transform(invocation);
         List<Path> lib1DexOutputs =
                 Files.list(out)
                         .filter(p -> p.getFileName().toString().startsWith("lib1.jar"))
                         .collect(Collectors.toList());
         assertThat(lib1DexOutputs).hasSize(1);
     }

     @NonNull
     private DexArchiveBuilderTransform getTransform(
             @Nullable FileCache userCache,
             int minSdkVersion,
             boolean isDebuggable,
             boolean includeAndroidJar) {
         List<File> androidJasClasspath =
                 includeAndroidJar
                         ? ImmutableList.of(TestUtils.getPlatformFile("android.jar"))
                         : ImmutableList.of();
         return new DexArchiveBuilderTransformBuilder()
                 .setAndroidJarClasspath(() -> androidJasClasspath)
                 .setDexOptions(new DefaultDexOptions())
                 .setMessageReceiver(new NoOpMessageReceiver())
                 .setUserLevelCache(userCache)
                 .setMinSdkVersion(minSdkVersion)
                 .setDexer(DexerTool.D8)
                 .setUseGradleWorkers(false)
                 .setInBufferSize(10)
                 .setOutBufferSize(10)
                 .setIsDebuggable(isDebuggable)
                 .setJava8LangSupportType(VariantScope.Java8LangSupport.D8)
                 .setProjectVariant("myVariant")
                 .setIncludeFeaturesInScope(false)
                 .setNumberOfBuckets(2)
                 .createDexArchiveBuilderTransform();
     }

     @NonNull
     private DexArchiveBuilderTransform getTransform(@Nullable FileCache userCache) {
         return getTransform(userCache, 15, true, false);
     }

     @NonNull
     private File getDex(@NonNull Class<?> clazz) {
         return Iterables.getOnlyElement(
                 FileUtils.find(
                         out.toFile(), Pattern.compile(".*" + clazz.getSimpleName() + "\\.dex")));
     }

     @NonNull
     private Map<File, Status> getChangedStatusMap(
             @NonNull Path root, @NonNull Status status, @NonNull Class<?>... classes) {
         Map<File, Status> statusMap = new HashMap<>();
         for (Class<?> clazz : classes) {
             statusMap.put(root.resolve(TestInputsGenerator.getPath(clazz)).toFile(), status);
         }
         return statusMap;
     }
 }
	/*
	* Copyright (C) 2017 The Android Open Source Project
	*
	* 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 com.android.build.gradle.internal.transforms;

	import static com.android.build.api.transform.Status.CHANGED;
	import static com.android.build.api.transform.Status.REMOVED;
	import static com.android.testutils.truth.PathSubject.assertThat;
	import static com.google.common.truth.Truth.assertThat;

	import com.android.annotations.NonNull;
	import com.android.annotations.Nullable;
	import com.android.build.api.transform.QualifiedContent;
	import com.android.build.api.transform.Status;
	import com.android.build.api.transform.TransformException;
	import com.android.build.api.transform.TransformInput;
	import com.android.build.api.transform.TransformInvocation;
	import com.android.build.api.transform.TransformOutputProvider;
	import com.android.build.gradle.internal.scope.VariantScope;
	import com.android.build.gradle.internal.transforms.testdata.Animal;
	import com.android.build.gradle.internal.transforms.testdata.CarbonForm;
	import com.android.build.gradle.internal.transforms.testdata.Cat;
	import com.android.build.gradle.internal.transforms.testdata.Tiger;
	import com.android.build.gradle.internal.transforms.testdata.Toy;
	import com.android.builder.core.DefaultDexOptions;
	import com.android.builder.dexing.DexerTool;
	import com.android.builder.utils.FileCache;
	import com.android.testutils.TestInputsGenerator;
	import com.android.testutils.TestUtils;
	import com.android.testutils.truth.MoreTruth;
	import com.android.utils.FileUtils;
	import com.google.common.collect.ImmutableList;
	import com.google.common.collect.ImmutableSet;
	import com.google.common.collect.Iterables;
	import java.io.File;
	import java.io.IOException;
	import java.nio.file.Files;
	import java.nio.file.Path;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;
	import java.util.Objects;
	import java.util.regex.Pattern;
	import java.util.stream.Collectors;
	import org.junit.Before;
	import org.junit.Rule;
	import org.junit.Test;
	import org.junit.rules.TemporaryFolder;

	public class DexArchiveBuilderTransformDesugaringTest {

	private TransformOutputProvider outputProvider;
	private Path out;
	@Rule public TemporaryFolder tmpDir = new TemporaryFolder();

	@Before
	public void setUp() throws IOException {
	out = tmpDir.getRoot().toPath().resolve("out");
	Files.createDirectories(out);
	outputProvider = new TestTransformOutputProvider(out);
	}

	@Test
	public void testLambdas() throws Exception {
	Path input = tmpDir.getRoot().toPath().resolve("input");
	TestInputsGenerator.pathWithClasses(
	input, ImmutableSet.of(CarbonForm.class, Animal.class, Cat.class, Toy.class));

	TransformInput dirInput = TransformTestHelper.directoryBuilder(input.toFile()).build();

	TransformInvocation invocation =
	TransformTestHelper.invocationBuilder()
	.setTransformOutputProvider(outputProvider)
	.addInput(dirInput)
	.setIncremental(false)
	.build();
	getTransform(null, 15, true, false).transform(invocation);

	// it should contain Cat and synthesized lambda class
	MoreTruth.assertThatDex(getDex(Cat.class)).hasClassesCount(2);
	}

	interface WithDefault {
	default void foo() {}
	}

	interface WithStatic {
	static void bar() {}
	}

	static class ImplementsWithDefault implements WithDefault {}

	static class InvokesDefault {
	public static void main(String[] args) {
	new ImplementsWithDefault().foo();
	}
	}

	@Test
	public void testDefaultMethods_minApiBelow24() throws Exception {
	Path input = tmpDir.getRoot().toPath().resolve("input");
	TestInputsGenerator.pathWithClasses(
	input, ImmutableSet.of(WithDefault.class, WithStatic.class));

	TransformInput dirInput = TransformTestHelper.directoryBuilder(input.toFile()).build();

	TransformInvocation invocation =
	TransformTestHelper.invocationBuilder()
	.setTransformOutputProvider(outputProvider)
	.addInput(dirInput)
	.setIncremental(false)
	.build();
	getTransform(null, 23, true, false).transform(invocation);

	// it contains both original and synthesized
	MoreTruth.assertThatDex(getDex(WithDefault.class)).hasClassesCount(2);
	MoreTruth.assertThatDex(getDex(WithStatic.class)).hasClassesCount(2);
	}

	@Test
	public void testDefaultMethods_minApiAbove24() throws Exception {
	Path input = tmpDir.getRoot().toPath().resolve("input");
	TestInputsGenerator.pathWithClasses(
	input, ImmutableSet.of(WithDefault.class, WithStatic.class));

	TransformInput dirInput = TransformTestHelper.directoryBuilder(input.toFile()).build();

	TransformInvocation invocation =
	TransformTestHelper.invocationBuilder()
	.setTransformOutputProvider(outputProvider)
	.addInput(dirInput)
	.setIncremental(false)
	.build();
	getTransform(null, 24, true, false).transform(invocation);

	// it contains only the original class
	MoreTruth.assertThatDex(getDex(WithDefault.class)).hasClassesCount(1);
	MoreTruth.assertThatDex(getDex(WithStatic.class)).hasClassesCount(1);
	}

	@Test
	public void testIncremental_lambdaClass() throws Exception {
	Path input = tmpDir.getRoot().toPath().resolve("input");
	TestInputsGenerator.pathWithClasses(
	input, ImmutableSet.of(CarbonForm.class, Animal.class, Cat.class, Toy.class));

	TransformInput dirInput = TransformTestHelper.directoryBuilder(input.toFile()).build();

	TransformInvocation invocation =
	TransformTestHelper.invocationBuilder()
	.setTransformOutputProvider(outputProvider)
	.addInput(dirInput)
	.setIncremental(false)
	.build();
	getTransform(null).transform(invocation);

	File catDex = getDex(Cat.class);
	File animalDex = getDex(Animal.class);
	long catTimestamp = catDex.lastModified();
	long animalTimestamp = animalDex.lastModified();

	TestUtils.waitForFileSystemTick();

	dirInput =
	TransformTestHelper.directoryBuilder(input.toFile())
	.putChangedFiles(getChangedStatusMap(input, CHANGED, Toy.class))
	.build();
	invocation =
	TransformTestHelper.invocationBuilder()
	.setIncremental(true)
	.setTransformOutputProvider(outputProvider)
	.addInput(dirInput)
	.build();

	getTransform(null).transform(invocation);
	catDex = getDex(Cat.class);
	animalDex = getDex(Animal.class);
	assertThat(catTimestamp).isLessThan(catDex.lastModified());
	assertThat(animalTimestamp).isEqualTo(animalDex.lastModified());
	}

	@Test
	public void testIncremental_lambdaClass_removed() throws Exception {
	Path input = tmpDir.getRoot().toPath().resolve("input");
	TestInputsGenerator.pathWithClasses(
	input, ImmutableSet.of(CarbonForm.class, Animal.class, Cat.class, Toy.class));

	TransformInput dirInput = TransformTestHelper.directoryBuilder(input.toFile()).build();

	TransformInvocation invocation =
	TransformTestHelper.invocationBuilder()
	.setTransformOutputProvider(outputProvider)
	.addInput(dirInput)
	.setIncremental(false)
	.build();
	getTransform(null).transform(invocation);

	File catDex = getDex(Cat.class);
	File animalDex = getDex(Animal.class);
	long catTimestamp = catDex.lastModified();
	long animalTimestamp = animalDex.lastModified();

	TestUtils.waitForFileSystemTick();

	dirInput =
	TransformTestHelper.directoryBuilder(input.toFile())
	.putChangedFiles(getChangedStatusMap(input, REMOVED, Toy.class))
	.build();
	invocation =
	TransformTestHelper.invocationBuilder()
	.setIncremental(true)
	.setTransformOutputProvider(outputProvider)
	.addInput(dirInput)
	.build();

	File toyDex = getDex(Toy.class);
	getTransform(null).transform(invocation);
	catDex = getDex(Cat.class);
	animalDex = getDex(Animal.class);
	assertThat(catTimestamp).isLessThan(catDex.lastModified());
	assertThat(animalTimestamp).isEqualTo(animalDex.lastModified());

	assertThat(toyDex).doesNotExist();
	}

	@Test
	public void testIncremental_changeSuperTypes() throws Exception {
	Path input = tmpDir.getRoot().toPath().resolve("input");
	TestInputsGenerator.pathWithClasses(
	input,
	ImmutableSet.of(CarbonForm.class, Animal.class, Cat.class, Tiger.class, Toy.class));

	TransformInput dirInput = TransformTestHelper.directoryBuilder(input.toFile()).build();

	TransformInvocation invocation =
	TransformTestHelper.invocationBuilder()
	.setTransformOutputProvider(outputProvider)
	.addInput(dirInput)
	.setIncremental(false)
	.build();
	getTransform(null).transform(invocation);

	File tigerDex = getDex(Tiger.class);
	File carbonFormDex = getDex(CarbonForm.class);
	long tigerTimestamp = tigerDex.lastModified();
	long carbonFormTimestamp = carbonFormDex.lastModified();

	dirInput =
	TransformTestHelper.directoryBuilder(input.toFile())
	.putChangedFiles(getChangedStatusMap(input, CHANGED, Animal.class))
	.build();
	invocation =
	TransformTestHelper.invocationBuilder()
	.setIncremental(true)
	.setTransformOutputProvider(outputProvider)
	.addInput(dirInput)
	.build();

	TestUtils.waitForFileSystemTick();
	getTransform(null).transform(invocation);
	tigerDex = getDex(Tiger.class);
	carbonFormDex = getDex(CarbonForm.class);
	assertThat(tigerTimestamp).isLessThan(tigerDex.lastModified());
	assertThat(carbonFormTimestamp).isEqualTo(carbonFormDex.lastModified());

	dirInput =
	TransformTestHelper.directoryBuilder(input.toFile())
	.putChangedFiles(getChangedStatusMap(input, CHANGED, Cat.class))
	.build();
	invocation =
	TransformTestHelper.invocationBuilder()
	.setIncremental(true)
	.setTransformOutputProvider(outputProvider)
	.addInput(dirInput)
	.build();

	TestUtils.waitForFileSystemTick();
	getTransform(null).transform(invocation);
	tigerDex = getDex(Tiger.class);
	carbonFormDex = getDex(CarbonForm.class);
	assertThat(tigerTimestamp).isLessThan(tigerDex.lastModified());
	assertThat(carbonFormTimestamp).isEqualTo(carbonFormDex.lastModified());
	}

	@Test
	public void test_incremental_full_incremental()
	throws IOException, TransformException, InterruptedException {
	Path input = tmpDir.getRoot().toPath().resolve("input");
	TestInputsGenerator.pathWithClasses(input, ImmutableSet.of(CarbonForm.class, Animal.class));

	TransformInput dirInput =
	TransformTestHelper.directoryBuilder(input.toFile())
	.putChangedFiles(
	getChangedStatusMap(
	input, Status.ADDED, CarbonForm.class, Animal.class))
	.build();
	TransformInvocation invocation =
	TransformTestHelper.invocationBuilder()
	.setTransformOutputProvider(outputProvider)
	.addInput(dirInput)
	.setIncremental(true)
	.build();
	getTransform(null).transform(invocation);
	File animalDex = getDex(Animal.class);

	dirInput = TransformTestHelper.directoryBuilder(input.toFile()).build();
	invocation =
	TransformTestHelper.invocationBuilder()
	.setTransformOutputProvider(outputProvider)
	.addInput(dirInput)
	.setIncremental(false)
	.build();
	getTransform(null).transform(invocation);

	dirInput =
	TransformTestHelper.directoryBuilder(input.toFile())
	.putChangedFiles(getChangedStatusMap(input, Status.REMOVED, Animal.class))
	.build();
	invocation =
	TransformTestHelper.invocationBuilder()
	.setTransformOutputProvider(outputProvider)
	.addInput(dirInput)
	.setIncremental(true)
	.build();
	getTransform(null).transform(invocation);
	assertThat(getDex(CarbonForm.class)).exists();
	assertThat(animalDex).doesNotExist();
	}

	@Test
	public void test_incremental_jarAndDir()
	throws IOException, TransformException, InterruptedException {
	Path jar = tmpDir.getRoot().toPath().resolve("input.jar");
	Path input = tmpDir.getRoot().toPath().resolve("input");
	TestInputsGenerator.pathWithClasses(jar, ImmutableSet.of(CarbonForm.class, Animal.class));
	TestInputsGenerator.pathWithClasses(
	input, ImmutableSet.of(Toy.class, Cat.class, Tiger.class));

	TransformInput dirInput = TransformTestHelper.directoryBuilder(input.toFile()).build();
	TransformInput jarInput = TransformTestHelper.singleJarBuilder(jar.toFile()).build();
	TransformInvocation invocation =
	TransformTestHelper.invocationBuilder()
	.setTransformOutputProvider(outputProvider)
	.addInput(dirInput)
	.addInput(jarInput)
	.setIncremental(false)
	.build();
	getTransform(null).transform(invocation);
	long catTimestamp = getDex(Cat.class).lastModified();
	long toyTimestamp = getDex(Toy.class).lastModified();

	jarInput =
	TransformTestHelper.singleJarBuilder(jar.toFile())
	.setStatus(Status.CHANGED)
	.build();
	invocation =
	TransformTestHelper.invocationBuilder()
	.setTransformOutputProvider(outputProvider)
	.addInput(dirInput)
	.addInput(jarInput)
	.setIncremental(true)
	.build();
	TestUtils.waitForFileSystemTick();
	getTransform(null).transform(invocation);

	assertThat(catTimestamp).isLessThan(getDex(Cat.class).lastModified());
	assertThat(toyTimestamp).isEqualTo(getDex(Toy.class).lastModified());
	}

	/** Regression test to make sure we do not add unchanged files to cache. */
	@Test
	public void test_incremental_notChangedNotAddedToCache() throws Exception {
	Path jar = tmpDir.getRoot().toPath().resolve("input.jar");
	TestInputsGenerator.pathWithClasses(jar, ImmutableSet.of(CarbonForm.class, Animal.class));

	TransformInput jarInput =
	TransformTestHelper.singleJarBuilder(jar.toFile())
	.setScopes(QualifiedContent.Scope.EXTERNAL_LIBRARIES)
	.setContentTypes(QualifiedContent.DefaultContentType.CLASSES)
	.build();
	TransformInvocation invocation =
	TransformTestHelper.invocationBuilder()
	.setTransformOutputProvider(outputProvider)
	.addInput(jarInput)
	.setIncremental(false)
	.build();
	FileCache cache = FileCache.getInstanceWithSingleProcessLocking(tmpDir.newFolder());
	getTransform(cache).transform(invocation);
	String[] numEntries = Objects.requireNonNull(cache.getCacheDirectory().list());

	File referencedJar = tmpDir.newFile("referenced.jar");
	TestInputsGenerator.jarWithEmptyClasses(referencedJar.toPath(), ImmutableList.of("A"));
	TransformInput referencedInput =
	TransformTestHelper.singleJarBuilder(referencedJar).build();

	jarInput =
	TransformTestHelper.singleJarBuilder(jar.toFile())
	.setStatus(Status.NOTCHANGED)
	.setScopes(QualifiedContent.Scope.EXTERNAL_LIBRARIES)
	.setContentTypes(QualifiedContent.DefaultContentType.CLASSES)
	.build();
	invocation =
	TransformTestHelper.invocationBuilder()
	.setTransformOutputProvider(outputProvider)
	.addInput(jarInput)
	.addReferenceInput(referencedInput)
	.setIncremental(true)
	.build();
	getTransform(cache).transform(invocation);
	assertThat(cache.getCacheDirectory().list()).named("cache entries").isEqualTo(numEntries);
	}

	@Test
	public void test_duplicateClasspathEntries() throws Exception {

	Path lib1 = tmpDir.getRoot().toPath().resolve("lib1.jar");
	TestInputsGenerator.pathWithClasses(
	lib1, ImmutableSet.of(ImplementsWithDefault.class, WithDefault.class));
	Path lib2 = tmpDir.getRoot().toPath().resolve("lib2.jar");
	TestInputsGenerator.pathWithClasses(lib2, ImmutableSet.of(WithDefault.class));
	Path app = tmpDir.getRoot().toPath().resolve("app");
	TestInputsGenerator.pathWithClasses(app, ImmutableSet.of(InvokesDefault.class));

	TransformInput lib1Input =
	TransformTestHelper.singleJarBuilder(lib1.toFile())
	.setScopes(QualifiedContent.Scope.EXTERNAL_LIBRARIES)
	.setContentTypes(QualifiedContent.DefaultContentType.CLASSES)
	.build();
	TransformInput lib2Input =
	TransformTestHelper.singleJarBuilder(lib2.toFile())
	.setScopes(QualifiedContent.Scope.EXTERNAL_LIBRARIES)
	.setContentTypes(QualifiedContent.DefaultContentType.CLASSES)
	.build();
	TransformInput appInput = TransformTestHelper.directoryBuilder(app.toFile()).build();

	TransformInvocation invocation =
	TransformTestHelper.invocationBuilder()
	.setTransformOutputProvider(outputProvider)
	.addInput(lib1Input)
	.addInput(lib2Input)
	.addInput(appInput)
	.setIncremental(false)
	.build();
	getTransform(null, 15, true, true).transform(invocation);

	MoreTruth.assertThatDex(getDex(InvokesDefault.class)).hasClassesCount(1);
	}

	/** Regression test for b/117062425. */
	@Test
	public void test_incrementalDesugaringWithCaching() throws Exception {
	Path lib1 = tmpDir.getRoot().toPath().resolve("lib1.jar");
	TestInputsGenerator.pathWithClasses(lib1, ImmutableSet.of(ImplementsWithDefault.class));
	Path lib2 = tmpDir.getRoot().toPath().resolve("lib2.jar");
	TestInputsGenerator.pathWithClasses(lib2, ImmutableSet.of(WithDefault.class));

	TransformInput lib1Input =
	TransformTestHelper.singleJarBuilder(lib1.toFile())
	.setScopes(QualifiedContent.Scope.EXTERNAL_LIBRARIES)
	.setContentTypes(QualifiedContent.DefaultContentType.CLASSES)
	.build();
	// Mimics dex that from cache for lib1.jar. Transform invocation should remove it.
	Files.createFile(out.resolve("lib1.jar.jar"));

	TransformInput lib2Input =
	TransformTestHelper.singleJarBuilder(lib2.toFile())
	.setScopes(QualifiedContent.Scope.EXTERNAL_LIBRARIES)
	.setContentTypes(QualifiedContent.DefaultContentType.CLASSES)
	.setStatus(Status.CHANGED)
	.build();
	TransformInvocation invocation =
	TransformTestHelper.invocationBuilder()
	.setTransformOutputProvider(outputProvider)
	.addInput(lib1Input)
	.addInput(lib2Input)
	.setIncremental(true)
	.build();
	getTransform(null, 15, true, true).transform(invocation);
	List<Path> lib1DexOutputs =
	Files.list(out)
	.filter(p -> p.getFileName().toString().startsWith("lib1.jar"))
	.collect(Collectors.toList());
	assertThat(lib1DexOutputs).hasSize(1);
	}

	@NonNull
	private DexArchiveBuilderTransform getTransform(
	@Nullable FileCache userCache,
	int minSdkVersion,
	boolean isDebuggable,
	boolean includeAndroidJar) {
	List<File> androidJasClasspath =
	includeAndroidJar
	? ImmutableList.of(TestUtils.getPlatformFile("android.jar"))
	: ImmutableList.of();
	return new DexArchiveBuilderTransformBuilder()
	.setAndroidJarClasspath(() -> androidJasClasspath)
	.setDexOptions(new DefaultDexOptions())
	.setMessageReceiver(new NoOpMessageReceiver())
	.setUserLevelCache(userCache)
	.setMinSdkVersion(minSdkVersion)
	.setDexer(DexerTool.D8)
	.setUseGradleWorkers(false)
	.setInBufferSize(10)
	.setOutBufferSize(10)
	.setIsDebuggable(isDebuggable)
	.setJava8LangSupportType(VariantScope.Java8LangSupport.D8)
	.setProjectVariant("myVariant")
	.setIncludeFeaturesInScope(false)
	.setNumberOfBuckets(2)
	.createDexArchiveBuilderTransform();
	}

	@NonNull
	private DexArchiveBuilderTransform getTransform(@Nullable FileCache userCache) {
	return getTransform(userCache, 15, true, false);
	}

	@NonNull
	private File getDex(@NonNull Class<?> clazz) {
	return Iterables.getOnlyElement(
	FileUtils.find(
	out.toFile(), Pattern.compile(".*" + clazz.getSimpleName() + "\\.dex")));
	}

	@NonNull
	private Map<File, Status> getChangedStatusMap(
	@NonNull Path root, @NonNull Status status, @NonNull Class<?>... classes) {
	Map<File, Status> statusMap = new HashMap<>();
	for (Class<?> clazz : classes) {
	statusMap.put(root.resolve(TestInputsGenerator.getPath(clazz)).toFile(), status);
	}
	return statusMap;
	}
	}