/*
 * Copyright 2015 The Kythe 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.kythe.extractors.java;

import static com.google.common.truth.Truth.assertThat;
import static java.nio.file.StandardCopyOption.REPLACE_EXISTING;

import com.google.common.base.Optional;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
import com.google.devtools.kythe.extractors.shared.CompilationDescription;
import com.google.devtools.kythe.extractors.shared.ExtractorUtils;
import com.google.devtools.kythe.proto.Analysis.CompilationUnit;
import com.google.devtools.kythe.proto.Analysis.CompilationUnit.FileInput;
import com.google.devtools.kythe.proto.Analysis.FileInfo;
import com.google.devtools.kythe.proto.Java.JavaDetails;
import com.google.protobuf.Any;
import com.google.protobuf.InvalidProtocolBufferException;
import java.io.File;
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.stream.Collectors;
import java.util.stream.Stream;
import junit.framework.TestCase;

/** Tests for {@link JavaCompilationExtractor}. */
// TODO(schroederc): replace asserts with Truth#assertThat
public class JavaExtractorTest extends TestCase {

  private static final String TEST_DATA_DIR =
      "kythe/javatests/com/google/devtools/kythe/extractors/java/testdata";

  private static final String CORPUS = "testCorpus";
  private static final String TARGET1 = "target1";

  private static final ImmutableList<String> EMPTY = ImmutableList.of();

  private static final FileInfo GENERATED_ANNOTATION_CLASS =
      FileInfo.newBuilder()
          .setPath(join("!CLASS_PATH_JAR!", "javax/annotation/Generated.class"))
          // This digest depends on the external javax_annotation_jsr250_api dependency.  If it is
          // updated, this will also need to change.
          .setDigest("e5ee743f5c6df4923a934cba33c73d3d73e19d277c8ddec5c4e7ac59788fc674")
          .build();

  // Due to the nature of the jsr250 dependency, this class is incidentally
  // included in some compilation environments but not others.
  // In order to distinguish these dependencies from "true" dependencies, use this name.
  private static final FileInfo JDK_ANNOTATION_CLASS = GENERATED_ANNOTATION_CLASS;
  private static final String JDK_ANNOTATION_PATH = "!CLASS_PATH_JAR!";

  /** Tests the basic case of indexing a java compilation with two sources. */
  public void testJavaExtractorSimple() throws Exception {
    JavaCompilationUnitExtractor java = new JavaCompilationUnitExtractor(CORPUS);

    List<String> sources =
        Lists.newArrayList(join(TEST_DATA_DIR, "/pkg/A.java"), join(TEST_DATA_DIR, "/pkg/B.java"));

    // Index the specified sources
    CompilationDescription description =
        java.extract(
            TARGET1,
            sources,
            EMPTY,
            EMPTY,
            EMPTY,
            EMPTY,
            EMPTY,
            Optional.absent(),
            EMPTY,
            "output");

    CompilationUnit unit = description.getCompilationUnit();
    assertThat(unit).isNotNull();
    assertThat(unit.getVName().getSignature()).isEqualTo(TARGET1);

    // With the expected sources as explicit sources.
    assertThat(unit.getSourceFileCount()).isEqualTo(2);
    assertThat(unit.getSourceFileList()).containsExactly(sources.get(0), sources.get(1)).inOrder();

    // With the expected sources as required inputs.
    assertThat(getInfos(unit.getRequiredInputList()))
        .containsExactlyElementsIn(getExpectedInfos(sources, JDK_ANNOTATION_CLASS));

    // And the correct sourcepath set to replay the compilation.
    JavaDetails details = getJavaDetails(unit);
    assertThat(details.getSourcepathList()).containsExactly(TEST_DATA_DIR);
    assertThat(details.getClasspathList()).containsExactly(JDK_ANNOTATION_PATH);
  }

  /** Tests that metadata is included when a file specifies it. */
  public void testJavaExtractorMetadata() throws Exception {
    JavaCompilationUnitExtractor java = new JavaCompilationUnitExtractor(CORPUS);

    List<String> sources = Lists.newArrayList(join(TEST_DATA_DIR, "/pkg/M.java"));
    List<String> dependencies =
        Lists.newArrayList(
            join(TEST_DATA_DIR, "/pkg/M.java"), join(TEST_DATA_DIR, "/pkg/M.java.meta"));

    // Index the specified sources
    CompilationDescription description =
        java.extract(
            TARGET1,
            sources,
            EMPTY,
            EMPTY,
            EMPTY,
            EMPTY,
            EMPTY,
            Optional.absent(),
            EMPTY,
            "output");

    CompilationUnit unit = description.getCompilationUnit();
    assertThat(unit).isNotNull();
    assertThat(unit.getVName().getSignature()).isEqualTo(TARGET1);

    // With the expected sources as explicit sources.
    assertThat(unit.getSourceFileCount()).isEqualTo(1);
    assertThat(unit.getSourceFileList()).containsExactly(sources.get(0));

    // With the expected dependencies as required inputs.
    assertThat(getInfos(unit.getRequiredInputList()))
        .containsExactlyElementsIn(getExpectedInfos(dependencies, GENERATED_ANNOTATION_CLASS));

    // And the correct sourcepath set to replay the compilation.
    JavaDetails details = getJavaDetails(unit);
    assertThat(details.getSourcepathList()).containsExactly(TEST_DATA_DIR);
    assertThat(details.getClasspathList()).containsExactly("!CLASS_PATH_JAR!");
  }

  /** Tests indexing within a symlink root. */
  public void testJavaExtractorSymlinkRoot() throws Exception {
    Path symlinkRoot = Paths.get(System.getenv("TEST_TMPDIR"), "symlinkRoot");
    symlinkRoot.toFile().delete();
    Files.createSymbolicLink(symlinkRoot, Paths.get(".").toAbsolutePath());
    symlinkRoot.toFile().deleteOnExit();

    JavaCompilationUnitExtractor java =
        new JavaCompilationUnitExtractor(CORPUS, symlinkRoot.toString());

    List<String> sources =
        Lists.newArrayList(join(TEST_DATA_DIR, "/pkg/A.java"), join(TEST_DATA_DIR, "/pkg/B.java"));

    // Index the specified sources
    CompilationDescription description =
        java.extract(
            TARGET1,
            sources,
            EMPTY,
            EMPTY,
            EMPTY,
            EMPTY,
            EMPTY,
            Optional.absent(),
            EMPTY,
            "output");

    CompilationUnit unit = description.getCompilationUnit();
    assertThat(unit).isNotNull();
    assertThat(unit.getVName().getSignature()).isEqualTo(TARGET1);

    // With the expected sources as explicit sources.
    assertThat(unit.getSourceFileList()).containsExactlyElementsIn(sources).inOrder();

    // With the expected sources as required inputs.
    assertThat(getInfos(unit.getRequiredInputList()))
        .containsExactlyElementsIn(getExpectedInfos(sources, JDK_ANNOTATION_CLASS));

    // And the correct sourcepath set to replay the compilation.
    JavaDetails details = getJavaDetails(unit);
    assertThat(details.getSourcepathList()).containsExactly(TEST_DATA_DIR);
    assertThat(details.getClasspathList()).containsExactly(JDK_ANNOTATION_PATH);
  }

  /**
   * Tests the basic case of indexing a java compilation where the sources live in different folders
   * eventhough they're in the same package.
   */
  public void testJavaExtractorTwoSourceDirs() throws Exception {
    JavaCompilationUnitExtractor java = new JavaCompilationUnitExtractor(CORPUS);

    // Pick two sources in the same package that live in different directories.
    List<String> sources =
        Lists.newArrayList(
            join(TEST_DATA_DIR, "one/pkg/A.java"), join(TEST_DATA_DIR, "two/pkg/B.java"));

    // Index the specified sources
    CompilationDescription description =
        java.extract(
            TARGET1,
            sources,
            EMPTY,
            EMPTY,
            EMPTY,
            EMPTY,
            EMPTY,
            Optional.absent(),
            EMPTY,
            "output");

    CompilationUnit unit = description.getCompilationUnit();
    assertThat(unit).isNotNull();
    assertThat(unit.getVName().getSignature()).isEqualTo(TARGET1);

    // With the expected sources as explicit sources.
    assertThat(unit.getSourceFileCount()).isEqualTo(2);
    assertThat(unit.getSourceFileList()).containsExactly(sources.get(0), sources.get(1)).inOrder();

    assertThat(getInfos(unit.getRequiredInputList()))
        .containsExactlyElementsIn(getExpectedInfos(sources, JDK_ANNOTATION_CLASS));

    // And the correct sourcepath set to replay the compilation for both sources.
    JavaDetails details = getJavaDetails(unit);
    assertThat(details.getSourcepathList())
        .containsExactly(join(TEST_DATA_DIR, "one"), join(TEST_DATA_DIR, "two"));
    assertThat(details.getClasspathList()).containsExactly(JDK_ANNOTATION_PATH);
  }

  /**
   * Tests java compilation with classfiles in the classpath. Test ensures that only used classfiles
   * are stored.
   */
  public void testJavaExtractorClassFiles() throws Exception {
    JavaCompilationUnitExtractor java = new JavaCompilationUnitExtractor(CORPUS);

    // Index the specified sources
    List<String> sources = Lists.newArrayList(join(TEST_DATA_DIR, "child/derived/B.java"));

    String parentCp = join(TEST_DATA_DIR, "parent") + "/";
    List<String> classpath = Lists.newArrayList(parentCp);
    String classFile = join(parentCp, "base/A.class");

    // Index the specified sources and classes from the classpath
    CompilationDescription description =
        java.extract(
            TARGET1,
            sources,
            classpath,
            EMPTY,
            EMPTY,
            EMPTY,
            EMPTY,
            Optional.absent(),
            EMPTY,
            "output");

    CompilationUnit unit = description.getCompilationUnit();
    assertThat(unit).isNotNull();
    assertThat(unit.getVName().getSignature()).isEqualTo(TARGET1);
    assertThat(unit.getSourceFileCount()).isEqualTo(1);
    assertThat(unit.getSourceFileList()).containsExactly(sources.get(0)).inOrder();

    // Ensure the right class files are picked up from the classpath.
    assertThat(getInfos(unit.getRequiredInputList()))
        .containsExactlyElementsIn(getExpectedInfos(Arrays.asList(sources.get(0), classFile)));

    JavaDetails details = getJavaDetails(unit);
    assertThat(details.getSourcepathList()).containsExactly(join(TEST_DATA_DIR, "child"));
    // Ensure the classpath is set for replay.
    assertThat(details.getClasspathList()).containsExactly(parentCp);
  }

  /**
   * Tests java compilation with classfiles in a jarfile on the classpath. Ensures that only used
   * classfiles are stored.
   */
  public void testJavaExtractorJar() throws Exception {
    JavaCompilationUnitExtractor java = new JavaCompilationUnitExtractor(CORPUS);

    // Index the specified sources.
    List<String> sources = Lists.newArrayList(join(TEST_DATA_DIR, "child/derived/B.java"));

    String parentCp = join(TEST_DATA_DIR, "jarred.jar");
    List<String> classpath = Lists.newArrayList(parentCp);

    // Index the specified sources and classes from inside jar on the classpath.
    CompilationDescription description =
        java.extract(
            TARGET1,
            sources,
            classpath,
            EMPTY,
            EMPTY,
            EMPTY,
            EMPTY,
            Optional.absent(),
            EMPTY,
            "output");

    CompilationUnit unit = description.getCompilationUnit();
    assertThat(unit).isNotNull();
    assertThat(unit.getVName().getSignature()).isEqualTo(TARGET1);
    assertThat(unit.getSourceFileList()).containsExactlyElementsIn(sources).inOrder();

    // The classpath is adjusted to start wit !CLASS_PATH_JAR!
    String classFile = join("!CLASS_PATH_JAR!", "base/A.class");

    // Ensure the right class files are picked up from the classpath from within the jar.
    assertThat(getInfos(unit.getRequiredInputList()))
        .containsExactly(
            makeFileInfo(sources.get(0)),
            makeFileInfo(classFile, join(TEST_DATA_DIR, "parent/base/A.class")));

    JavaDetails details = getJavaDetails(unit);
    assertThat(details.getSourcepathList()).hasSize(1);
    assertThat(details.getSourcepathList().get(0)).isEqualTo(join(TEST_DATA_DIR, "child"));
    // Ensure the magic !CLASS_PATH_JAR! classpath is added.
    assertThat(details.getClasspathList()).containsExactly("!CLASS_PATH_JAR!");
  }

  /**
   * Tests case where compile errors exist in the sources under compilation. Compilation should
   * still be created.
   */
  public void testJavaExtractorCompileError() throws Exception {
    JavaCompilationUnitExtractor java = new JavaCompilationUnitExtractor(CORPUS);

    List<String> sources = Lists.newArrayList(join(TEST_DATA_DIR, "/error/Crash.java"));

    // Index the specified sources, reporting compilation failure.
    CompilationDescription description =
        java.extract(
            TARGET1,
            sources,
            EMPTY,
            EMPTY,
            EMPTY,
            EMPTY,
            EMPTY,
            Optional.absent(),
            EMPTY,
            "output");

    CompilationUnit unit = description.getCompilationUnit();
    assertThat(unit).isNotNull();
    assertThat(unit.getVName().getSignature()).isEqualTo(TARGET1);
    assertThat(unit.getRequiredInputCount()).isEqualTo(1);
    assertThat(unit.getRequiredInput(0).getInfo().getPath()).isEqualTo(sources.get(0));
    assertThat(unit.getRequiredInput(0).getInfo().getDigest())
        .isEqualTo(ExtractorUtils.digestForPath(sources.get(0)));
    assertThat(unit.getSourceFileCount()).isEqualTo(1);
    assertThat(unit.getSourceFileList()).containsExactly(sources.get(0)).inOrder();

    JavaDetails details = getJavaDetails(unit);
    assertThat(details.getSourcepathList()).hasSize(1);
    assertThat(details.getSourcepathList().get(0)).isEqualTo(TEST_DATA_DIR);
    assertThat(details.getClasspathList()).isEmpty();
  }

  /** Tests that dependent files are ordered correctly. */
  public void testJavaExtractorOrderedDependencies() throws Exception {
    JavaCompilationUnitExtractor java = new JavaCompilationUnitExtractor(CORPUS);

    List<String> sources =
        Lists.newArrayList(
            join(TEST_DATA_DIR, "/deps/A.java"),
            join(TEST_DATA_DIR, "/deps/C.java"),
            join(TEST_DATA_DIR, "/deps/B.java"));

    // Index the specified sources
    CompilationDescription description =
        java.extract(
            TARGET1,
            sources,
            EMPTY,
            EMPTY,
            EMPTY,
            EMPTY,
            EMPTY,
            Optional.absent(),
            EMPTY,
            "output");

    CompilationUnit unit = description.getCompilationUnit();
    assertThat(unit).isNotNull();
    assertThat(unit.getVName().getSignature()).isEqualTo(TARGET1);
    assertThat(unit.getSourceFileCount()).isEqualTo(3);
    assertThat(unit.getSourceFileList())
        .containsExactly(sources.get(0), sources.get(1), sources.get(2))
        .inOrder();

    // With the expected sources as required inputs.
    assertThat(getInfos(unit.getRequiredInputList()))
        .containsExactly(
            JDK_ANNOTATION_CLASS,
            makeFileInfo(sources.get(0)),
            makeFileInfo(sources.get(2)),
            makeFileInfo(sources.get(1)))
        .inOrder();
  }

  /**
   * Tests the case where one of the sources doesn't follow the java pattern of naming the path to
   * the source file after the package name.
   */
  public void testJavaExtractorNonConformingPath() throws Exception {
    JavaCompilationUnitExtractor java = new JavaCompilationUnitExtractor(CORPUS);

    List<String> sources =
        Lists.newArrayList(
            join(TEST_DATA_DIR, "/path/sub/A.java"), join(TEST_DATA_DIR, "/path/B.java"));

    // Index the specified sources
    CompilationDescription description =
        java.extract(
            TARGET1,
            sources,
            EMPTY,
            EMPTY,
            EMPTY,
            EMPTY,
            EMPTY,
            Optional.absent(),
            EMPTY,
            "output");

    CompilationUnit unit = description.getCompilationUnit();
    assertThat(unit).isNotNull();
    assertThat(unit.getVName().getSignature()).isEqualTo(TARGET1);
    assertThat(unit.getSourceFileCount()).isEqualTo(2);
    assertThat(unit.getSourceFileList()).containsExactly(sources.get(0), sources.get(1)).inOrder();

    // With the expected sources as required inputs.
    assertThat(getInfos(unit.getRequiredInputList()))
        .containsExactlyElementsIn(getExpectedInfos(sources, JDK_ANNOTATION_CLASS));

    // And the correct sourcepath set to replay the compilation.
    JavaDetails details = getJavaDetails(unit);
    assertThat(details.getSourcepathList()).hasSize(1);
    assertThat(details.getSourcepathList().get(0)).isEqualTo(TEST_DATA_DIR);
    assertThat(details.getClasspathList()).containsExactly(JDK_ANNOTATION_PATH);
  }

  /**
   * Tests the case where one of the sources defines a package only type that is not conforming to
   * the classname matching the filename.
   */
  public void testJavaExtractorAdditionalTypeDefinitions() throws Exception {
    JavaCompilationUnitExtractor java = new JavaCompilationUnitExtractor(CORPUS);

    List<String> sources =
        Lists.newArrayList(
            join(TEST_DATA_DIR, "/hitchhikers/A.java"), join(TEST_DATA_DIR, "/hitchhikers/B.java"));

    // Index the specified sources
    CompilationDescription description =
        java.extract(
            TARGET1,
            sources,
            EMPTY,
            EMPTY,
            EMPTY,
            EMPTY,
            EMPTY,
            Optional.absent(),
            EMPTY,
            "output");

    CompilationUnit unit = description.getCompilationUnit();
    assertThat(unit).isNotNull();
    assertThat(unit.getVName().getSignature()).isEqualTo(TARGET1);
    assertThat(unit.getSourceFileCount()).isEqualTo(2);
    assertThat(unit.getSourceFileList()).containsExactly(sources.get(0), sources.get(1)).inOrder();

    // With the expected sources as required inputs.
    assertThat(getInfos(unit.getRequiredInputList()))
        .containsExactlyElementsIn(getExpectedInfos(sources, JDK_ANNOTATION_CLASS));

    // And the correct sourcepath set to replay the compilation.
    JavaDetails details = getJavaDetails(unit);
    assertThat(details.getSourcepathList()).containsExactly(TEST_DATA_DIR);
    assertThat(details.getClasspathList()).containsExactly(JDK_ANNOTATION_PATH);
  }

  /**
   * Tests that unsupported flags do not crash the extractor and source/header destination options
   * are not present in the resulting {@link CompilationUnit}.
   */
  public void testJavaExtractorArguments() throws Exception {
    String testDir = System.getenv("TEST_TMPDIR");
    JavaCompilationUnitExtractor java = new JavaCompilationUnitExtractor(CORPUS, testDir);

    File processorFile =
        Paths.get(
                "kythe/javatests/com/google/devtools/kythe/extractors/java/SillyProcessor_deploy.jar")
            .toFile();
    if (!processorFile.exists()) {
      throw new AssertionError("SillyProcessor_deploy.jar does not exist");
    }

    List<String> origSources = testFiles("processor/Silly.java", "processor/SillyUser.java");

    List<Path> outputDirs =
        Arrays.asList(
            Paths.get(testDir, "output-gensrc.jar.files"),
            Paths.get(testDir, "output-genhdr.jar.files"),
            Paths.get(testDir, "classes"));

    List<String> processorpath = Arrays.asList(processorFile.getPath());
    List<String> processors = Arrays.asList("processor.SillyProcessor");
    List<String> options =
        Arrays.asList(
            "-Xdoclint:-Xdoclint:all/private", // ensure this unsupported flag is saved
            "-s",
            outputDirs.get(0).toString(),
            "-h",
            outputDirs.get(1).toString(),
            "-g:lines", // ensure this conjoined arg is handled correctly
            "-d",
            outputDirs.get(2).toString());

    for (Path dir : outputDirs) {
      dir.toFile().mkdir();
    }

    // Copy sources from runfiles into test dir
    List<String> testSources = new ArrayList<>();
    for (String source : origSources) {
      Path destFile = Paths.get(testDir).resolve(source);
      Files.createDirectories(destFile.getParent());
      Files.copy(Paths.get(source), destFile, REPLACE_EXISTING);
      testSources.add(destFile.toString());
    }

    // Index the specified sources
    CompilationDescription description =
        java.extract(
            TARGET1,
            testSources,
            EMPTY,
            EMPTY,
            EMPTY,
            processorpath,
            processors,
            Optional.absent(),
            options,
            "output");

    CompilationUnit unit = description.getCompilationUnit();
    assertThat(unit).isNotNull();

    // Check that the -s, and -h flags have been removed from the compilation's arguments, but -d
    // preserved (it is required by modular builds).
    assertThat(unit.getArgumentList())
        .containsExactly("-Xdoclint:-Xdoclint:all/private", "-g:lines")
        .inOrder();
  }

  /** Tests that targets that contain annotation processors are indexed correctly. */
  public void testJavaExtractorAnnotationProcessing() throws Exception {
    String testDir = System.getenv("TEST_TMPDIR");
    JavaCompilationUnitExtractor java = new JavaCompilationUnitExtractor(CORPUS, testDir);

    File processorFile =
        Paths.get(
                "kythe/javatests/com/google/devtools/kythe/extractors/java/SillyProcessor_deploy.jar")
            .toFile();
    if (!processorFile.exists()) {
      throw new AssertionError("SillyProcessor_deploy.jar does not exist");
    }

    List<String> origSources = testFiles("processor/Silly.java", "processor/SillyUser.java");

    List<String> processorpath = Arrays.asList(processorFile.getPath());
    List<String> processors = Arrays.asList("processor.SillyProcessor");
    Path genSrcDir = Paths.get(testDir, "output-gensrc.jar.files");
    List<String> options = Arrays.asList("-s", genSrcDir.toString());
    genSrcDir.toFile().mkdir();

    // Copy sources from runfiles into test dir
    List<String> testSources = new ArrayList<>();
    for (String source : origSources) {
      Path destFile = Paths.get(testDir).resolve(source);
      Files.createDirectories(destFile.getParent());
      Files.copy(Paths.get(source), destFile, REPLACE_EXISTING);
      testSources.add(destFile.toString());
    }

    // Index the specified sources
    CompilationDescription description =
        java.extract(
            TARGET1,
            testSources,
            EMPTY,
            EMPTY,
            EMPTY,
            processorpath,
            processors,
            Optional.of(genSrcDir),
            options,
            "output");

    CompilationUnit unit = description.getCompilationUnit();
    assertThat(unit).isNotNull();
    assertThat(unit.getVName().getSignature()).isEqualTo(TARGET1);

    String sillyGenerated = "output-gensrc.jar.files/processor/SillyGenerated.java";
    assertThat(unit.getSourceFileList())
        .containsExactly(origSources.get(0), origSources.get(1), sillyGenerated)
        .inOrder();

    // With the expected sources as required inputs.
    assertThat(getInfos(unit.getRequiredInputList()))
        .containsExactly(
            JDK_ANNOTATION_CLASS,
            makeFileInfo(origSources.get(0)),
            makeFileInfo(origSources.get(1)),
            makeFileInfo(sillyGenerated, Paths.get(testDir, sillyGenerated).toString()));

    // And the correct sourcepath set to replay the compilation.
    JavaDetails details = getJavaDetails(unit);
    assertThat(details.getSourcepathList()).hasSize(2);
    assertThat(details.getSourcepathList())
        .containsExactly(TEST_DATA_DIR, "output-gensrc.jar.files");
    assertThat(details.getClasspathList()).containsExactly(JDK_ANNOTATION_PATH);
  }

  /** Tests that the extractor doesn't fall over when it's provided with no sources. */
  public void testNoSources() throws Exception {
    JavaCompilationUnitExtractor java = new JavaCompilationUnitExtractor(CORPUS);

    List<String> sources = Collections.emptyList();
    List<String> bootclasspath = testFiles("empty/fake-rt.jar");

    // Index the specified sources
    CompilationDescription description =
        java.extract(
            TARGET1,
            sources,
            EMPTY,
            bootclasspath,
            EMPTY,
            EMPTY,
            EMPTY,
            Optional.absent(),
            EMPTY,
            "output");

    CompilationUnit unit = description.getCompilationUnit();

    assertThat(unit).isNotNull();
    assertThat(unit.getVName().getSignature()).isEqualTo(TARGET1);
    assertThat(unit.getSourceFileCount()).isEqualTo(0);
    assertThat(unit.getRequiredInputCount()).isEqualTo(0);

    // And the correct classpath set to replay the compilation.
    JavaDetails details = getJavaDetails(unit);
    assertThat(details.getSourcepathList()).isEmpty();
    assertThat(details.getClasspathList()).isEmpty();
  }

  /**
   * Tests the case where one of the sources defines a package only type that is not conforming to
   * the classname matching the filename.
   */
  public void testEmptyCompilationUnit() throws Exception {
    JavaCompilationUnitExtractor java = new JavaCompilationUnitExtractor(CORPUS);

    List<String> sources = testFiles("empty/Empty.java");
    List<String> bootclasspath = testFiles("empty/fake-rt.jar");

    // Index the specified sources
    CompilationDescription description =
        java.extract(
            TARGET1,
            sources,
            EMPTY,
            bootclasspath,
            EMPTY,
            EMPTY,
            EMPTY,
            Optional.absent(),
            EMPTY,
            "output");

    CompilationUnit unit = description.getCompilationUnit();
    assertThat(unit).isNotNull();
    assertThat(unit.getVName().getSignature()).isEqualTo(TARGET1);
    assertThat(unit.getSourceFileCount()).isEqualTo(1);
    assertThat(unit.getSourceFileList()).containsExactly(sources.get(0)).inOrder();

    assertThat(unit.getRequiredInputCount()).isEqualTo(3);
    List<String> requiredPaths = new ArrayList<>();
    for (FileInput input : unit.getRequiredInputList()) {
      requiredPaths.add(input.getInfo().getPath());
    }
    assertThat(requiredPaths)
        .containsExactly(
            sources.get(0),
            "!PLATFORM_CLASS_PATH_JAR!/java/lang/Fake.class",
            "!CLASS_PATH_JAR!/javax/annotation/Generated.class");

    assertThat(unit.getArgumentList())
        .containsNoneOf("-bootclasspath", "-sourcepath", "-cp", "-classpath");

    // And the correct source/class locations set to replay the compilation.
    JavaDetails details = getJavaDetails(unit);
    assertThat(details.getSourcepathList()).isEmpty();
    assertThat(details.getClasspathList()).containsExactly("!CLASS_PATH_JAR!");
    assertThat(details.getBootclasspathList()).containsExactly("!PLATFORM_CLASS_PATH_JAR!");
  }

  private List<String> testFiles(String... files) {
    List<String> res = new ArrayList<>();
    for (String file : files) {
      res.add(join(TEST_DATA_DIR, file));
    }
    return res;
  }

  private static List<FileInfo> getInfos(List<FileInput> files) {
    return Lists.transform(files, FileInput::getInfo);
  }

  private static List<FileInfo> getExpectedInfos(List<String> files, FileInfo... extra) {
    return Stream.concat(files.stream().map(JavaExtractorTest::makeFileInfo), Stream.of(extra))
        .collect(Collectors.toList());
  }

  private static FileInfo makeFileInfo(String path) {
    try {
      return FileInfo.newBuilder()
          .setPath(path)
          .setDigest(ExtractorUtils.digestForPath(path))
          .build();
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }

  private static FileInfo makeFileInfo(String path, String localPath) {
    try {
      return FileInfo.newBuilder()
          .setPath(path)
          .setDigest(ExtractorUtils.digestForPath(localPath))
          .build();
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }

  private JavaDetails getJavaDetails(CompilationUnit unit) throws InvalidProtocolBufferException {
    for (Any any : unit.getDetailsList()) {
      if (any.getTypeUrl().equals(JavaCompilationUnitExtractor.JAVA_DETAILS_URL)) {
        return JavaDetails.parseFrom(any.getValue());
      }
    }
    return null;
  }

  private static String join(String base, String... paths) {
    return Paths.get(base, paths).toString();
  }
}