src/test/java/com/google/devtools/build/android/r8/CompatDxTest.java

// Copyright 2020 The Bazel Authors. All rights reserved.
//
// 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.google.devtools.build.android.r8;

import static com.google.common.truth.Truth.assertThat;
import static com.google.common.truth.Truth.assertWithMessage;
import static java.nio.charset.StandardCharsets.UTF_8;
import static java.util.stream.Collectors.toList;
import static java.util.stream.Collectors.toSet;

import com.google.common.base.Joiner;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import java.io.IOException;
import java.net.URI;
import java.nio.file.FileSystem;
import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.nio.file.StandardOpenOption;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.stream.Stream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;

/** Test for CompatDx. */
@RunWith(JUnit4.class)
public class CompatDxTest {
  private static final String EXAMPLE_JAR_FILE_1 = System.getProperty("CompatDxTests.arithmetic");
  private static final String EXAMPLE_JAR_FILE_2 = System.getProperty("CompatDxTests.barray");

  private static final String NO_LOCALS = "--no-locals";
  private static final String NO_POSITIONS = "--positions=none";
  private static final String MULTIDEX = "--multi-dex";
  private static final String NUM_THREADS_5 = "--num-threads=5";

  @Rule public TemporaryFolder temp = new TemporaryFolder();

  @Test
  public void noFilesTest() throws IOException {
    runDexer("--no-files");
  }

  @Test
  public void noOutputTest() throws IOException {
    runDexerWithoutOutput(NO_POSITIONS, NO_LOCALS, MULTIDEX, EXAMPLE_JAR_FILE_1);
  }

  @Test
  public void singleJarInputFile() throws IOException {
    runDexer(NO_POSITIONS, NO_LOCALS, MULTIDEX, EXAMPLE_JAR_FILE_1);
  }

  @Test
  public void multipleJarInputFiles() throws IOException {
    runDexer(NO_POSITIONS, NO_LOCALS, MULTIDEX, EXAMPLE_JAR_FILE_1, EXAMPLE_JAR_FILE_2);
  }

  @Test
  public void outputZipFile() throws IOException {
    runDexerWithOutput("foo.dex.zip", NO_POSITIONS, NO_LOCALS, MULTIDEX, EXAMPLE_JAR_FILE_1);
  }

  @Test
  public void useMultipleThreads() throws IOException {
    runDexer(NUM_THREADS_5, NO_POSITIONS, NO_LOCALS, EXAMPLE_JAR_FILE_1);
  }

  @Test
  public void withPositions() throws IOException {
    runDexer(NO_LOCALS, MULTIDEX, EXAMPLE_JAR_FILE_1);
  }

  @Test
  public void withLocals() throws IOException {
    runDexer(NO_POSITIONS, MULTIDEX, EXAMPLE_JAR_FILE_1);
  }

  @Test
  public void withoutMultidex() throws IOException {
    runDexer(NO_POSITIONS, NO_LOCALS, EXAMPLE_JAR_FILE_1);
  }

  @Test
  public void writeToNamedDexFile() throws IOException {
    runDexerWithOutput("named-output.dex", EXAMPLE_JAR_FILE_1);
  }

  @Test
  public void keepClassesSingleDexTest() throws IOException {
    runDexerWithOutput("out.zip", "--keep-classes", EXAMPLE_JAR_FILE_1);
  }

  @Test
  public void keepClassesMultiDexTest() throws IOException {
    runDexerWithOutput("out.zip", "--keep-classes", "--multi-dex", EXAMPLE_JAR_FILE_1);
  }

  @Test
  public void ignoreDexInArchiveTest() throws IOException {
    // Create a JAR with both a .class and a .dex file (the .dex file is just empty).
    Path jarWithClassesAndDex = temp.newFile("test.jar").toPath();
    Files.copy(
        Paths.get(EXAMPLE_JAR_FILE_1), jarWithClassesAndDex, StandardCopyOption.REPLACE_EXISTING);
    jarWithClassesAndDex.toFile().setWritable(true);
    URI uri = URI.create("jar:" + jarWithClassesAndDex.toUri());
    try (FileSystem fileSystem =
        FileSystems.newFileSystem(uri, ImmutableMap.of("create", "true"))) {
      Path dexFile = fileSystem.getPath("classes.dex");
      Files.newOutputStream(dexFile, StandardOpenOption.CREATE).close();
    }

    // Only test this with CompatDx, as dx does not like the empty .dex file.
    List<String> d8Args =
        ImmutableList.of("--output=" + temp.newFolder("out"), jarWithClassesAndDex.toString());
    CompatDx.main(d8Args.toArray(new String[0]));
  }

  private void runDexer(String... args) throws IOException {
    runDexerWithOutput("", args);
  }

  private void runDexerWithoutOutput(String... args) throws IOException {
    runDexerWithOutput(null, args);
  }

  private Path getOutputD8() {
    return temp.getRoot().toPath().resolve("d8-out");
  }

  private Path getOutputDX() {
    return temp.getRoot().toPath().resolve("dx-out");
  }

  private void runDexerWithOutput(String out, String... args) throws IOException {
    Path d8Out = null;
    Path dxOut = null;
    if (out != null) {
      Path baseD8 = getOutputD8();
      Path baseDX = getOutputDX();
      Files.createDirectory(baseD8);
      Files.createDirectory(baseDX);
      d8Out = baseD8.resolve(out);
      dxOut = baseDX.resolve(out);
      assertThat(dxOut.toString()).isNotEqualTo(d8Out.toString());
    }

    List<String> d8Args = new ArrayList<>();
    d8Args.add("--dex");
    if (d8Out != null) {
      d8Args.add("--output=" + d8Out);
    }
    Collections.addAll(d8Args, args);
    System.out.println("running: d8 " + Joiner.on(" ").join(d8Args));
    CompatDx.main(d8Args.toArray(new String[0]));

    List<String> dxArgs = new ArrayList<>();
    dxArgs.add("--dex");
    if (dxOut != null) {
      dxArgs.add("--output=" + dxOut);
    }
    Collections.addAll(dxArgs, args);
    System.out.println("running: dx " + Joiner.on(" ").join(dxArgs));
    com.android.dx.command.Main.main(dxArgs.toArray(new String[0]));

    if (out == null) {
      // Can't check output if explicitly not writing any.
      return;
    }

    List<Path> d8Files;
    try (Stream<Path> d8FilesStream =
        Files.list(Files.isDirectory(d8Out) ? d8Out : d8Out.getParent())) {
      d8Files = d8FilesStream.sorted().collect(toList());
    }
    List<Path> dxFiles;
    try (Stream<Path> dxFilesStream =
        Files.list(Files.isDirectory(dxOut) ? dxOut : dxOut.getParent())) {
      dxFiles = dxFilesStream.sorted().collect(toList());
    }
    assertWithMessage("Out file names differ")
        .that(
            Joiner.on(System.lineSeparator())
                .join(d8Files.stream().map(Path::getFileName).iterator()))
        .isEqualTo(
            Joiner.on(System.lineSeparator())
                .join(dxFiles.stream().map(Path::getFileName).iterator()));
    for (int i = 0; i < d8Files.size(); i++) {
      if (FileUtils.isArchive(d8Files.get(i))) {
        compareArchiveFiles(d8Files.get(i), dxFiles.get(i));
      }
    }
  }

  private static void compareArchiveFiles(Path d8File, Path dxFile) throws IOException {
    ZipFile d8Zip = new ZipFile(d8File.toFile(), UTF_8);
    ZipFile dxZip = new ZipFile(dxFile.toFile(), UTF_8);
    // TODO(zerny): This should test resource containment too once supported.
    Set<String> d8Content = d8Zip.stream().map(ZipEntry::getName).collect(toSet());
    Set<String> dxContent =
        dxZip.stream()
            .map(ZipEntry::getName)
            .filter(
                name ->
                    name.endsWith(FileUtils.DEX_EXTENSION)
                        || name.endsWith(FileUtils.CLASS_EXTENSION))
            .collect(toSet());
    assertWithMessage("Expected dx and d8 output to contain same DEX anf class file entries")
        .that(d8Content)
        .containsExactlyElementsIn(dxContent);
  }
}