src/test/java/com/android/tools/r8/D8IncrementalRunExamplesAndroidOTest.java - r8 - Git at Google

 // Copyright (c) 2017, the R8 project authors. Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.

 package com.android.tools.r8;

 import static com.android.tools.r8.utils.FileUtils.JAR_EXTENSION;
 import static org.junit.Assert.assertEquals;

 import com.android.tools.r8.errors.CompilationError;
 import com.android.tools.r8.errors.InternalCompilerError;
 import com.android.tools.r8.errors.Unimplemented;
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.OffOrAuto;
 import com.android.tools.r8.utils.OutputMode;
 import com.beust.jcommander.internal.Lists;
 import com.google.common.io.Closer;
 import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.nio.file.DirectoryStream;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.SortedMap;
 import java.util.TreeMap;
 import java.util.function.UnaryOperator;
 import org.junit.Assert;
 import org.junit.Test;

 public abstract class D8IncrementalRunExamplesAndroidOTest
     extends RunExamplesAndroidOTest<D8Command.Builder> {

   abstract class D8IncrementalTestRunner extends TestRunner {

     D8IncrementalTestRunner(String testName, String packageName, String mainClass) {
       super(testName, packageName, mainClass);
     }

     @Override
     TestRunner withMinApiLevel(int minApiLevel) {
       return withBuilderTransformation(builder -> builder.setMinApiLevel(minApiLevel));
     }

     @Override
     void build(Path testJarFile, Path out) throws Throwable {
       Map<String, Resource> files = compileClassesTogether(testJarFile, null);
       mergeClassFiles(Lists.newArrayList(files.values()), out);
     }

     // Dex classes separately.
     SortedMap<String, Resource> compileClassesSeparately(Path testJarFile) throws Throwable {
       TreeMap<String, Resource> fileToResource = new TreeMap<>();
       List<String> classFiles = collectClassFiles(testJarFile);
       for (String classFile : classFiles) {
         AndroidApp app = compileClassFiles(
             testJarFile, Collections.singletonList(classFile), null, OutputMode.Indexed);
         assert app.getDexProgramResources().size() == 1;
         fileToResource.put(
             makeRelative(testJarFile, Paths.get(classFile)).toString(),
             app.getDexProgramResources().get(0));
       }
       return fileToResource;
     }

     // Dex classes in one D8 invocation.
     SortedMap<String, Resource> compileClassesTogether(
         Path testJarFile, Path output) throws Throwable {
       TreeMap<String, Resource> fileToResource = new TreeMap<>();
       List<String> classFiles = collectClassFiles(testJarFile);
       AndroidApp app = compileClassFiles(
           testJarFile, classFiles, output, OutputMode.FilePerClass);
       for (Resource resource : app.getDexProgramResources()) {
         Set<String> descriptors = resource.getClassDescriptors();
         Assert.assertNotNull(descriptors);
         Assert.assertEquals(1, descriptors.size());
         String classDescriptor = descriptors.iterator().next();
         classDescriptor = classDescriptor.substring(1, classDescriptor.length() - 1);
         String classFilePath = classDescriptor + ".class";
         if (File.separatorChar != '/') {
           classFilePath = classFilePath.replace('/', File.separatorChar);
         }
         fileToResource.put(classFilePath, resource);
       }
       return fileToResource;
     }

     private Path makeRelative(Path testJarFile, Path classFile) {
       Path regularParent =
           testJarFile.getParent().resolve(Paths.get("classes"));
       Path legacyParent = regularParent.resolve(Paths.get("..",
           regularParent.getFileName().toString() + "Legacy", "classes"));

       if (classFile.startsWith(regularParent)) {
         return regularParent.relativize(classFile);
       }
       Assert.assertTrue(classFile.startsWith(legacyParent));
       return legacyParent.relativize(classFile);
     }

     private List<String> collectClassFiles(Path testJarFile) {
       List<String> result = new ArrayList<>();
       // Collect Java 8 classes.
       collectClassFiles(getClassesRoot(testJarFile), result);
       // Collect legacy classes.
       collectClassFiles(getLegacyClassesRoot(testJarFile), result);
       Collections.sort(result);
       return result;
     }

     Path getClassesRoot(Path testJarFile) {
       Path parent = testJarFile.getParent();
       return parent.resolve(Paths.get("classes", packageName));
     }

     Path getLegacyClassesRoot(Path testJarFile) {
       Path parent = testJarFile.getParent();
       Path legacyPath = Paths.get("..",
           parent.getFileName().toString() + "Legacy", "classes", packageName);
       return parent.resolve(legacyPath);
     }

     private void collectClassFiles(Path dir, List<String> result) {
       if (Files.exists(dir)) {
         try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir)) {
           for (Path entry: stream) {
             if (Files.isDirectory(entry)) {
               collectClassFiles(entry, result);
             } else {
               result.add(entry.toString());
             }
           }
         } catch (IOException x) {
           throw new AssertionError(x);
         }
       }
     }

     AndroidApp compileClassFiles(Path testJarFile,
         List<String> inputFiles, Path output, OutputMode outputMode) throws Throwable {
       D8Command.Builder builder = D8Command.builder();
       addClasspathReference(testJarFile, builder);
       for (String inputFile : inputFiles) {
         builder = builder.addProgramFiles(Paths.get(inputFile));
       }
       for (UnaryOperator<D8Command.Builder> transformation : builderTransformations) {
         builder = transformation.apply(builder);
       }
       builder = builder.setOutputMode(outputMode);
       builder = builder.addLibraryFiles(
           Paths.get(ToolHelper.getAndroidJar(builder.getMinApiLevel())));
       if (output != null) {
         builder = builder.setOutputPath(output);
       }
       addLibraryReference(builder, Paths.get(ToolHelper.getAndroidJar(builder.getMinApiLevel())));
       D8Command command = builder.build();
       try {
         return ToolHelper.runD8(command, this::combinedOptionConsumer);
       } catch (Unimplemented | CompilationError | InternalCompilerError re) {
         throw re;
       } catch (RuntimeException re) {
         throw re.getCause() == null ? re : re.getCause();
       }
     }

     Resource mergeClassFiles(List<Resource> dexFiles, Path out) throws Throwable {
       D8Command.Builder builder = D8Command.builder();
       for (Resource dexFile : dexFiles) {
         builder.addDexProgramData(readFromResource(dexFile));
       }
       for (UnaryOperator<D8Command.Builder> transformation : builderTransformations) {
         builder = transformation.apply(builder);
       }
       if (out != null) {
         builder = builder.setOutputPath(out);
       }
       D8Command command = builder.build();
       try {
         AndroidApp app = ToolHelper.runD8(command, this::combinedOptionConsumer);
         assert app.getDexProgramResources().size() == 1;
         return app.getDexProgramResources().get(0);
       } catch (Unimplemented | CompilationError | InternalCompilerError re) {
         throw re;
       } catch (RuntimeException re) {
         throw re.getCause() == null ? re : re.getCause();
       }
     }

     abstract void addClasspathReference(
         Path testJarFile, D8Command.Builder builder) throws IOException;

     abstract void addLibraryReference(
         D8Command.Builder builder, Path location) throws IOException;
   }

   @Test
   public void dexPerClassFileNoDesugaring() throws Throwable {
     String testName = "dexPerClassFileNoDesugaring";
     String testPackage = "incremental";
     String mainClass = "IncrementallyCompiled";

     Path inputJarFile = Paths.get(EXAMPLE_DIR, testPackage + JAR_EXTENSION);

     D8IncrementalTestRunner test = test(testName, testPackage, mainClass);

     Map<String, Resource> compiledSeparately = test.compileClassesSeparately(inputJarFile);
     Map<String, Resource> compiledTogether = test.compileClassesTogether(inputJarFile, null);
     Assert.assertEquals(compiledSeparately.size(), compiledTogether.size());

     for (Map.Entry<String, Resource> entry : compiledSeparately.entrySet()) {
       Resource otherResource = compiledTogether.get(entry.getKey());
       Assert.assertNotNull(otherResource);
       Assert.assertArrayEquals(readFromResource(entry.getValue()), readFromResource(otherResource));
     }

     Resource mergedFromCompiledSeparately =
         test.mergeClassFiles(Lists.newArrayList(compiledSeparately.values()), null);
     Resource mergedFromCompiledTogether =
         test.mergeClassFiles(Lists.newArrayList(compiledTogether.values()), null);
     Assert.assertArrayEquals(
         readFromResource(mergedFromCompiledSeparately),
         readFromResource(mergedFromCompiledTogether));
   }

   @Test
   public void dexPerClassFileWithDesugaring() throws Throwable {
     String testName = "dexPerClassFileWithDesugaring";
     String testPackage = "lambdadesugaringnplus";
     String mainClass = "LambdasWithStaticAndDefaultMethods";

     Path inputJarFile = Paths.get(EXAMPLE_DIR, testPackage + JAR_EXTENSION);

     D8IncrementalTestRunner test = test(testName, testPackage, mainClass);
     test.withInterfaceMethodDesugaring(OffOrAuto.Auto);

     Resource mergedFromCompiledSeparately =
         test.mergeClassFiles(Lists.newArrayList(
             test.compileClassesSeparately(inputJarFile).values()), null);
     Resource mergedFromCompiledTogether =
         test.mergeClassFiles(Lists.newArrayList(
             test.compileClassesTogether(inputJarFile, null).values()), null);

     Assert.assertArrayEquals(
         readFromResource(mergedFromCompiledSeparately),
         readFromResource(mergedFromCompiledTogether));
   }

   @Test
   public void dexPerClassFileOutputFiles() throws Throwable {
     String testName = "dexPerClassFileNoDesugaring";
     String testPackage = "incremental";
     String mainClass = "IncrementallyCompiled";

     Path out = temp.getRoot().toPath();

     Path inputJarFile = Paths.get(EXAMPLE_DIR, testPackage + JAR_EXTENSION);

     D8IncrementalTestRunner test = test(testName, testPackage, mainClass);
     test.compileClassesTogether(inputJarFile, out);


     String[] topLevelDir = out.toFile().list();
     assert topLevelDir != null;
     assertEquals(1, topLevelDir.length);
     assertEquals("incremental", topLevelDir[0]);

     String[] dexFiles = out.resolve(topLevelDir[0]).toFile().list();
     assert dexFiles != null;
     Arrays.sort(dexFiles);

     String[] expectedFileNames = {
         "IncrementallyCompiled$A$AB.dex",
         "IncrementallyCompiled$A.dex",
         "IncrementallyCompiled$B$BA.dex",
         "IncrementallyCompiled$B.dex",
         "IncrementallyCompiled$C.dex",
         "IncrementallyCompiled.dex"
     };
     Arrays.sort(expectedFileNames);

     Assert.assertArrayEquals(expectedFileNames, dexFiles);
   }

   abstract D8IncrementalTestRunner test(String testName, String packageName, String mainClass);

   static byte[] readFromResource(Resource resource) throws IOException {
     ByteArrayOutputStream output = new ByteArrayOutputStream();
     byte[] buffer = new byte[16384];
     try (Closer closer = Closer.create()) {
       InputStream stream = closer.register(resource.getStream());
       int read;
       while ((read = stream.read(buffer, 0, buffer.length)) != -1) {
         output.write(buffer, 0, read);
       }
     }
     return output.toByteArray();
   }
 }
	// Copyright (c) 2017, the R8 project authors. Please see the AUTHORS file
	// for details. All rights reserved. Use of this source code is governed by a
	// BSD-style license that can be found in the LICENSE file.

	package com.android.tools.r8;

	import static com.android.tools.r8.utils.FileUtils.JAR_EXTENSION;
	import static org.junit.Assert.assertEquals;

	import com.android.tools.r8.errors.CompilationError;
	import com.android.tools.r8.errors.InternalCompilerError;
	import com.android.tools.r8.errors.Unimplemented;
	import com.android.tools.r8.utils.AndroidApp;
	import com.android.tools.r8.utils.OffOrAuto;
	import com.android.tools.r8.utils.OutputMode;
	import com.beust.jcommander.internal.Lists;
	import com.google.common.io.Closer;
	import java.io.ByteArrayOutputStream;
	import java.io.File;
	import java.io.IOException;
	import java.io.InputStream;
	import java.nio.file.DirectoryStream;
	import java.nio.file.Files;
	import java.nio.file.Path;
	import java.nio.file.Paths;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Collections;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;
	import java.util.SortedMap;
	import java.util.TreeMap;
	import java.util.function.UnaryOperator;
	import org.junit.Assert;
	import org.junit.Test;

	public abstract class D8IncrementalRunExamplesAndroidOTest
	extends RunExamplesAndroidOTest<D8Command.Builder> {

	abstract class D8IncrementalTestRunner extends TestRunner {

	D8IncrementalTestRunner(String testName, String packageName, String mainClass) {
	super(testName, packageName, mainClass);
	}

	@Override
	TestRunner withMinApiLevel(int minApiLevel) {
	return withBuilderTransformation(builder -> builder.setMinApiLevel(minApiLevel));
	}

	@Override
	void build(Path testJarFile, Path out) throws Throwable {
	Map<String, Resource> files = compileClassesTogether(testJarFile, null);
	mergeClassFiles(Lists.newArrayList(files.values()), out);
	}

	// Dex classes separately.
	SortedMap<String, Resource> compileClassesSeparately(Path testJarFile) throws Throwable {
	TreeMap<String, Resource> fileToResource = new TreeMap<>();
	List<String> classFiles = collectClassFiles(testJarFile);
	for (String classFile : classFiles) {
	AndroidApp app = compileClassFiles(
	testJarFile, Collections.singletonList(classFile), null, OutputMode.Indexed);
	assert app.getDexProgramResources().size() == 1;
	fileToResource.put(
	makeRelative(testJarFile, Paths.get(classFile)).toString(),
	app.getDexProgramResources().get(0));
	}
	return fileToResource;
	}

	// Dex classes in one D8 invocation.
	SortedMap<String, Resource> compileClassesTogether(
	Path testJarFile, Path output) throws Throwable {
	TreeMap<String, Resource> fileToResource = new TreeMap<>();
	List<String> classFiles = collectClassFiles(testJarFile);
	AndroidApp app = compileClassFiles(
	testJarFile, classFiles, output, OutputMode.FilePerClass);
	for (Resource resource : app.getDexProgramResources()) {
	Set<String> descriptors = resource.getClassDescriptors();
	Assert.assertNotNull(descriptors);
	Assert.assertEquals(1, descriptors.size());
	String classDescriptor = descriptors.iterator().next();
	classDescriptor = classDescriptor.substring(1, classDescriptor.length() - 1);
	String classFilePath = classDescriptor + ".class";
	if (File.separatorChar != '/') {
	classFilePath = classFilePath.replace('/', File.separatorChar);
	}
	fileToResource.put(classFilePath, resource);
	}
	return fileToResource;
	}

	private Path makeRelative(Path testJarFile, Path classFile) {
	Path regularParent =
	testJarFile.getParent().resolve(Paths.get("classes"));
	Path legacyParent = regularParent.resolve(Paths.get("..",
	regularParent.getFileName().toString() + "Legacy", "classes"));

	if (classFile.startsWith(regularParent)) {
	return regularParent.relativize(classFile);
	}
	Assert.assertTrue(classFile.startsWith(legacyParent));
	return legacyParent.relativize(classFile);
	}

	private List<String> collectClassFiles(Path testJarFile) {
	List<String> result = new ArrayList<>();
	// Collect Java 8 classes.
	collectClassFiles(getClassesRoot(testJarFile), result);
	// Collect legacy classes.
	collectClassFiles(getLegacyClassesRoot(testJarFile), result);
	Collections.sort(result);
	return result;
	}

	Path getClassesRoot(Path testJarFile) {
	Path parent = testJarFile.getParent();
	return parent.resolve(Paths.get("classes", packageName));
	}

	Path getLegacyClassesRoot(Path testJarFile) {
	Path parent = testJarFile.getParent();
	Path legacyPath = Paths.get("..",
	parent.getFileName().toString() + "Legacy", "classes", packageName);
	return parent.resolve(legacyPath);
	}

	private void collectClassFiles(Path dir, List<String> result) {
	if (Files.exists(dir)) {
	try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir)) {
	for (Path entry: stream) {
	if (Files.isDirectory(entry)) {
	collectClassFiles(entry, result);
	} else {
	result.add(entry.toString());
	}
	}
	} catch (IOException x) {
	throw new AssertionError(x);
	}
	}
	}

	AndroidApp compileClassFiles(Path testJarFile,
	List<String> inputFiles, Path output, OutputMode outputMode) throws Throwable {
	D8Command.Builder builder = D8Command.builder();
	addClasspathReference(testJarFile, builder);
	for (String inputFile : inputFiles) {
	builder = builder.addProgramFiles(Paths.get(inputFile));
	}
	for (UnaryOperator<D8Command.Builder> transformation : builderTransformations) {
	builder = transformation.apply(builder);
	}
	builder = builder.setOutputMode(outputMode);
	builder = builder.addLibraryFiles(
	Paths.get(ToolHelper.getAndroidJar(builder.getMinApiLevel())));
	if (output != null) {
	builder = builder.setOutputPath(output);
	}
	addLibraryReference(builder, Paths.get(ToolHelper.getAndroidJar(builder.getMinApiLevel())));
	D8Command command = builder.build();
	try {
	return ToolHelper.runD8(command, this::combinedOptionConsumer);
	} catch (Unimplemented \| CompilationError \| InternalCompilerError re) {
	throw re;
	} catch (RuntimeException re) {
	throw re.getCause() == null ? re : re.getCause();
	}
	}

	Resource mergeClassFiles(List<Resource> dexFiles, Path out) throws Throwable {
	D8Command.Builder builder = D8Command.builder();
	for (Resource dexFile : dexFiles) {
	builder.addDexProgramData(readFromResource(dexFile));
	}
	for (UnaryOperator<D8Command.Builder> transformation : builderTransformations) {
	builder = transformation.apply(builder);
	}
	if (out != null) {
	builder = builder.setOutputPath(out);
	}
	D8Command command = builder.build();
	try {
	AndroidApp app = ToolHelper.runD8(command, this::combinedOptionConsumer);
	assert app.getDexProgramResources().size() == 1;
	return app.getDexProgramResources().get(0);
	} catch (Unimplemented \| CompilationError \| InternalCompilerError re) {
	throw re;
	} catch (RuntimeException re) {
	throw re.getCause() == null ? re : re.getCause();
	}
	}

	abstract void addClasspathReference(
	Path testJarFile, D8Command.Builder builder) throws IOException;

	abstract void addLibraryReference(
	D8Command.Builder builder, Path location) throws IOException;
	}

	@Test
	public void dexPerClassFileNoDesugaring() throws Throwable {
	String testName = "dexPerClassFileNoDesugaring";
	String testPackage = "incremental";
	String mainClass = "IncrementallyCompiled";

	Path inputJarFile = Paths.get(EXAMPLE_DIR, testPackage + JAR_EXTENSION);

	D8IncrementalTestRunner test = test(testName, testPackage, mainClass);

	Map<String, Resource> compiledSeparately = test.compileClassesSeparately(inputJarFile);
	Map<String, Resource> compiledTogether = test.compileClassesTogether(inputJarFile, null);
	Assert.assertEquals(compiledSeparately.size(), compiledTogether.size());

	for (Map.Entry<String, Resource> entry : compiledSeparately.entrySet()) {
	Resource otherResource = compiledTogether.get(entry.getKey());
	Assert.assertNotNull(otherResource);
	Assert.assertArrayEquals(readFromResource(entry.getValue()), readFromResource(otherResource));
	}

	Resource mergedFromCompiledSeparately =
	test.mergeClassFiles(Lists.newArrayList(compiledSeparately.values()), null);
	Resource mergedFromCompiledTogether =
	test.mergeClassFiles(Lists.newArrayList(compiledTogether.values()), null);
	Assert.assertArrayEquals(
	readFromResource(mergedFromCompiledSeparately),
	readFromResource(mergedFromCompiledTogether));
	}

	@Test
	public void dexPerClassFileWithDesugaring() throws Throwable {
	String testName = "dexPerClassFileWithDesugaring";
	String testPackage = "lambdadesugaringnplus";
	String mainClass = "LambdasWithStaticAndDefaultMethods";

	Path inputJarFile = Paths.get(EXAMPLE_DIR, testPackage + JAR_EXTENSION);

	D8IncrementalTestRunner test = test(testName, testPackage, mainClass);
	test.withInterfaceMethodDesugaring(OffOrAuto.Auto);

	Resource mergedFromCompiledSeparately =
	test.mergeClassFiles(Lists.newArrayList(
	test.compileClassesSeparately(inputJarFile).values()), null);
	Resource mergedFromCompiledTogether =
	test.mergeClassFiles(Lists.newArrayList(
	test.compileClassesTogether(inputJarFile, null).values()), null);

	Assert.assertArrayEquals(
	readFromResource(mergedFromCompiledSeparately),
	readFromResource(mergedFromCompiledTogether));
	}

	@Test
	public void dexPerClassFileOutputFiles() throws Throwable {
	String testName = "dexPerClassFileNoDesugaring";
	String testPackage = "incremental";
	String mainClass = "IncrementallyCompiled";

	Path out = temp.getRoot().toPath();

	Path inputJarFile = Paths.get(EXAMPLE_DIR, testPackage + JAR_EXTENSION);

	D8IncrementalTestRunner test = test(testName, testPackage, mainClass);
	test.compileClassesTogether(inputJarFile, out);


	String[] topLevelDir = out.toFile().list();
	assert topLevelDir != null;
	assertEquals(1, topLevelDir.length);
	assertEquals("incremental", topLevelDir[0]);

	String[] dexFiles = out.resolve(topLevelDir[0]).toFile().list();
	assert dexFiles != null;
	Arrays.sort(dexFiles);

	String[] expectedFileNames = {
	"IncrementallyCompiled$A$AB.dex",
	"IncrementallyCompiled$A.dex",
	"IncrementallyCompiled$B$BA.dex",
	"IncrementallyCompiled$B.dex",
	"IncrementallyCompiled$C.dex",
	"IncrementallyCompiled.dex"
	};
	Arrays.sort(expectedFileNames);

	Assert.assertArrayEquals(expectedFileNames, dexFiles);
	}

	abstract D8IncrementalTestRunner test(String testName, String packageName, String mainClass);

	static byte[] readFromResource(Resource resource) throws IOException {
	ByteArrayOutputStream output = new ByteArrayOutputStream();
	byte[] buffer = new byte[16384];
	try (Closer closer = Closer.create()) {
	InputStream stream = closer.register(resource.getStream());
	int read;
	while ((read = stream.read(buffer, 0, buffer.length)) != -1) {
	output.write(buffer, 0, read);
	}
	}
	return output.toByteArray();
	}
	}