/*
 * Copyright 2017 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.idea.blaze.cpp;

import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

import com.google.common.collect.ImmutableList;
import com.google.idea.blaze.base.BlazeTestCase;
import com.google.idea.blaze.base.async.executor.BlazeExecutor;
import com.google.idea.blaze.base.async.executor.MockBlazeExecutor;
import com.google.idea.blaze.base.bazel.BazelBuildSystemProvider;
import com.google.idea.blaze.base.bazel.BuildSystemProvider;
import com.google.idea.blaze.base.ideinfo.ArtifactLocation;
import com.google.idea.blaze.base.ideinfo.CIdeInfo;
import com.google.idea.blaze.base.ideinfo.CToolchainIdeInfo;
import com.google.idea.blaze.base.ideinfo.TargetIdeInfo;
import com.google.idea.blaze.base.ideinfo.TargetMap;
import com.google.idea.blaze.base.ideinfo.TargetMapBuilder;
import com.google.idea.blaze.base.io.VirtualFileSystemProvider;
import com.google.idea.blaze.base.model.BlazeProjectData;
import com.google.idea.blaze.base.model.MockBlazeProjectDataBuilder;
import com.google.idea.blaze.base.model.primitives.ExecutionRootPath;
import com.google.idea.blaze.base.model.primitives.Kind;
import com.google.idea.blaze.base.model.primitives.TargetExpression;
import com.google.idea.blaze.base.model.primitives.WorkspacePath;
import com.google.idea.blaze.base.model.primitives.WorkspaceRoot;
import com.google.idea.blaze.base.projectview.ProjectView;
import com.google.idea.blaze.base.projectview.ProjectViewSet;
import com.google.idea.blaze.base.projectview.section.ListSection;
import com.google.idea.blaze.base.projectview.section.sections.DirectoryEntry;
import com.google.idea.blaze.base.projectview.section.sections.DirectorySection;
import com.google.idea.blaze.base.projectview.section.sections.TargetSection;
import com.google.idea.blaze.base.scope.BlazeContext;
import com.google.idea.blaze.base.scope.ErrorCollector;
import com.google.idea.blaze.base.scope.output.IssueOutput;
import com.google.idea.blaze.base.settings.BlazeImportSettings;
import com.google.idea.blaze.base.settings.BlazeImportSettingsManager;
import com.intellij.openapi.progress.ProgressManager;
import com.intellij.openapi.progress.impl.ProgressManagerImpl;
import com.intellij.openapi.vfs.LocalFileSystem;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.openapi.vfs.VirtualFileManager;
import com.jetbrains.cidr.lang.OCLanguageKind;
import com.jetbrains.cidr.lang.workspace.OCResolveConfiguration;
import com.jetbrains.cidr.lang.workspace.OCResolveRootAndConfiguration;
import java.io.File;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.stream.Collectors;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;

/** Tests for {@link BlazeConfigurationResolver}. */
@RunWith(JUnit4.class)
public class BlazeConfigurationResolverTest extends BlazeTestCase {
  private final BlazeContext context = new BlazeContext();
  private final ErrorCollector errorCollector = new ErrorCollector();
  private final WorkspaceRoot workspaceRoot = new WorkspaceRoot(new File("/root"));

  private BlazeConfigurationResolver resolver;
  private BlazeConfigurationResolverResult resolverResult;
  private MockCompilerVersionChecker compilerVersionChecker;
  private LocalFileSystem mockFileSystem;

  @Override
  protected void initTest(Container applicationServices, Container projectServices) {
    super.initTest(applicationServices, projectServices);
    applicationServices.register(BlazeExecutor.class, new MockBlazeExecutor());
    compilerVersionChecker = new MockCompilerVersionChecker("1234");
    applicationServices.register(CompilerVersionChecker.class, compilerVersionChecker);
    applicationServices.register(ProgressManager.class, new ProgressManagerImpl());
    applicationServices.register(VirtualFileManager.class, mock(VirtualFileManager.class));
    mockFileSystem = mock(LocalFileSystem.class);
    applicationServices.register(
        VirtualFileSystemProvider.class, mock(VirtualFileSystemProvider.class));
    when(VirtualFileSystemProvider.getInstance().getSystem()).thenReturn(mockFileSystem);

    projectServices.register(BlazeImportSettingsManager.class, new BlazeImportSettingsManager());
    BuildSystemProvider buildSystemProvider = new BazelBuildSystemProvider();
    registerExtensionPoint(BuildSystemProvider.EP_NAME, BuildSystemProvider.class)
        .registerExtension(buildSystemProvider);
    BlazeImportSettingsManager.getInstance(getProject())
        .setImportSettings(
            new BlazeImportSettings("", "", "", "", buildSystemProvider.buildSystem()));

    context.addOutputSink(IssueOutput.class, errorCollector);

    resolver = new BlazeConfigurationResolver(project);
    resolverResult = BlazeConfigurationResolverResult.empty(project);
  }

  @Test
  public void testEmptyProject() {
    ProjectView projectView = projectView(directories(), targets());
    TargetMap targetMap = TargetMapBuilder.builder().build();
    assertThatResolving(projectView, targetMap).producesNoConfigurations();
  }

  @Test
  public void testTargetWithoutSources() {
    ProjectView projectView = projectView(directories("foo/bar"), targets("//foo/bar:library"));
    TargetMap targetMap =
        TargetMapBuilder.builder()
            .addTarget(createCcToolchain())
            .addTarget(createCcTarget("//foo/bar:library", Kind.CC_LIBRARY, ImmutableList.of()))
            .build();
    assertThatResolving(projectView, targetMap).producesNoConfigurations();
  }

  @Test
  public void testTargetWithGeneratedSources() {
    ProjectView projectView = projectView(directories("foo/bar"), targets("//foo/bar:library"));
    TargetMap targetMap =
        TargetMapBuilder.builder()
            .addTarget(createCcToolchain())
            .addTarget(
                createCcTarget(
                    "//foo/bar:library",
                    Kind.CC_LIBRARY,
                    ImmutableList.of(gen("foo/bar/library.cc"))))
            .build();
    assertThatResolving(projectView, targetMap).producesNoConfigurations();
  }

  @Test
  public void testTargetWithMixedSources() {
    ProjectView projectView = projectView(directories("foo/bar"), targets("//foo/bar:binary"));
    TargetMap targetMap =
        TargetMapBuilder.builder()
            .addTarget(createCcToolchain())
            .addTarget(
                createCcTarget(
                    "//foo/bar:binary",
                    Kind.CC_BINARY,
                    ImmutableList.of(src("foo/bar/binary.cc"), gen("foo/bar/generated.cc"))))
            .build();
    assertThatResolving(projectView, targetMap).producesConfigurationsFor("//foo/bar:binary");
  }

  @Test
  public void testSingleSourceTarget() {
    ProjectView projectView = projectView(directories("foo/bar"), targets("//foo/bar:binary"));
    TargetMap targetMap =
        TargetMapBuilder.builder()
            .addTarget(createCcToolchain())
            .addTarget(
                createCcTarget(
                    "//foo/bar:binary", Kind.CC_BINARY, ImmutableList.of(src("foo/bar/binary.cc"))))
            .build();
    assertThatResolving(projectView, targetMap).producesConfigurationsFor("//foo/bar:binary");
  }

  @Test
  public void testSingleSourceTargetWithLibraryDependencies() {
    ProjectView projectView = projectView(directories("foo/bar"), targets("//foo/bar:binary"));
    TargetMap targetMap =
        TargetMapBuilder.builder()
            .addTarget(createCcToolchain())
            .addTarget(
                createCcTarget(
                        "//foo/bar:binary",
                        Kind.CC_BINARY,
                        ImmutableList.of(src("foo/bar/binary.cc")))
                    .addDependency("//bar/baz:library")
                    .addDependency("//third_party:library"))
            .addTarget(
                createCcTarget(
                    "//bar/baz:library",
                    Kind.CC_LIBRARY,
                    ImmutableList.of(src("bar/baz/library.cc"))))
            .addTarget(
                createCcTarget(
                    "//third_party:library",
                    Kind.CC_LIBRARY,
                    ImmutableList.of(src("third_party/library.cc"))))
            .build();
    assertThatResolving(projectView, targetMap).producesConfigurationsFor("//foo/bar:binary");
  }

  @Test
  public void testSingleSourceTargetWithSourceDependencies() {
    ProjectView projectView = projectView(directories("foo/bar"), targets("//foo/bar:binary"));
    TargetMap targetMap =
        TargetMapBuilder.builder()
            .addTarget(createCcToolchain())
            .addTarget(
                createCcTarget(
                        "//foo/bar:binary",
                        Kind.CC_BINARY,
                        ImmutableList.of(src("foo/bar/binary.cc")))
                    .addDependency("//foo/bar:library")
                    .addDependency("//third_party:library"))
            .addTarget(
                createCcTarget(
                    "//foo/bar:library",
                    Kind.CC_LIBRARY,
                    ImmutableList.of(src("foo/bar/library.cc")),
                    ImmutableList.of("SOME_DEFINE=1")))
            .addTarget(
                createCcTarget(
                    "//third_party:library",
                    Kind.CC_LIBRARY,
                    ImmutableList.of(src("third_party/library.cc"))))
            .build();
    assertThatResolving(projectView, targetMap)
        .producesConfigurationsFor("//foo/bar:binary", "//foo/bar:library");
  }

  @Test
  public void testComplexProject() {
    ProjectView projectView =
        projectView(
            directories("foo/bar", "foo/baz"),
            targets("//foo:test", "//foo/bar:binary", "//foo/baz:test"));
    TargetMap targetMap =
        TargetMapBuilder.builder()
            .addTarget(createCcToolchain())
            .addTarget(
                createCcTarget("//foo:test", Kind.CC_TEST, ImmutableList.of(src("foo/test.cc")))
                    .addDependency("//foo:library")
                    .addDependency("//foo/bar:library")
                    .addDependency("//third_party:library"))
            .addTarget(
                createCcTarget(
                    "//foo:library", Kind.CC_TEST, ImmutableList.of(src("foo/library.cc"))))
            .addTarget(
                createCcTarget(
                        "//foo/bar:binary",
                        Kind.CC_BINARY,
                        ImmutableList.of(src("foo/bar/binary.cc")),
                        ImmutableList.of("SOME_DEFINE=1"))
                    .addDependency("//foo/bar:library")
                    .addDependency("//foo/bar:empty")
                    .addDependency("//foo/bar:generated")
                    .addDependency("//foo/bar:mixed")
                    .addDependency("//third_party:library"))
            .addTarget(
                createCcTarget(
                    "//foo/bar:library",
                    Kind.CC_LIBRARY,
                    ImmutableList.of(src("foo/bar/library.cc")),
                    ImmutableList.of("SOME_DEFINE=2")))
            .addTarget(createCcTarget("//foo/bar:empty", Kind.CC_LIBRARY, ImmutableList.of()))
            .addTarget(
                createCcTarget(
                    "//foo/bar:generated",
                    Kind.CC_LIBRARY,
                    ImmutableList.of(gen("foo/bar/generated.cc"))))
            .addTarget(
                createCcTarget(
                    "//foo/bar:mixed",
                    Kind.CC_LIBRARY,
                    ImmutableList.of(src("foo/bar/mixed_src.cc"), gen("foo/bar/mixed_gen.cc")),
                    ImmutableList.of("SOME_DEFINE=3")))
            .addTarget(
                createCcTarget(
                        "//foo/baz:test",
                        Kind.CC_TEST,
                        ImmutableList.of(src("foo/baz/test.cc")),
                        ImmutableList.of("SOME_DEFINE=4"))
                    .addDependency("//foo/baz:binary")
                    .addDependency("//foo/baz:library")
                    .addDependency("//foo/qux:library"))
            .addTarget(
                createCcTarget(
                    "//foo/baz:binary",
                    Kind.CC_BINARY,
                    ImmutableList.of(src("foo/baz/binary.cc")),
                    ImmutableList.of("SOME_DEFINE=5")))
            .addTarget(
                createCcTarget(
                    "//foo/baz:library",
                    Kind.CC_LIBRARY,
                    ImmutableList.of(src("foo/baz/library.cc")),
                    ImmutableList.of("SOME_DEFINE=6")))
            .addTarget(
                createCcTarget(
                    "//foo/qux:library",
                    Kind.CC_LIBRARY,
                    ImmutableList.of(src("foo/qux/library.cc"))))
            .addTarget(
                createCcTarget(
                    "//third_party:library",
                    Kind.CC_LIBRARY,
                    ImmutableList.of(src("third_party/library.cc"))))
            .build();
    assertThatResolving(projectView, targetMap)
        .producesConfigurationsFor(
            "//foo/bar:binary",
            "//foo/bar:library",
            "//foo/bar:mixed",
            "//foo/baz:test",
            "//foo/baz:binary",
            "//foo/baz:library");
  }

  @Test
  public void firstResolve_testNotIncremental() {
    ProjectView projectView = projectView(directories("foo/bar"), targets("//foo/bar:binary"));
    TargetMap targetMap =
        TargetMapBuilder.builder()
            .addTarget(createCcToolchain())
            .addTarget(
                createCcTarget(
                    "//foo/bar:binary", Kind.CC_BINARY, ImmutableList.of(src("foo/bar/binary.cc"))))
            .build();
    ImmutableList<BlazeResolveConfiguration> noReusedConfigurations = ImmutableList.of();
    assertThatResolving(projectView, targetMap)
        .reusedConfigurations(noReusedConfigurations, "//foo/bar:binary");
  }

  @Test
  public void identicalTargets_testIncrementalUpdateFullReuse() {
    ProjectView projectView = projectView(directories("foo/bar"), targets("//foo/bar:binary"));
    TargetMap targetMap =
        TargetMapBuilder.builder()
            .addTarget(createCcToolchain())
            .addTarget(
                createCcTarget(
                    "//foo/bar:binary", Kind.CC_BINARY, ImmutableList.of(src("foo/bar/binary.cc"))))
            .build();

    assertThatResolving(projectView, targetMap).producesConfigurationsFor("//foo/bar:binary");
    Collection<BlazeResolveConfiguration> initialConfigurations =
        resolverResult.getAllConfigurations();

    assertThatResolving(projectView, targetMap).reusedConfigurations(initialConfigurations);
  }

  @Test
  public void newTarget_testIncrementalUpdatePartlyReused() {
    ProjectView projectView = projectView(directories("foo/bar"), targets("//foo/bar:*"));
    TargetMapBuilder targetMapBuilder =
        TargetMapBuilder.builder()
            .addTarget(createCcToolchain())
            .addTarget(
                createCcTarget(
                    "//foo/bar:binary",
                    Kind.CC_BINARY,
                    ImmutableList.of(src("foo/bar/binary.cc"))));
    assertThatResolving(projectView, targetMapBuilder.build())
        .producesConfigurationsFor("//foo/bar:binary");
    Collection<BlazeResolveConfiguration> initialConfigurations =
        resolverResult.getAllConfigurations();

    targetMapBuilder.addTarget(
        createCcTarget(
            "//foo/bar:library",
            Kind.CC_LIBRARY,
            ImmutableList.of(src("foo/bar/library.cc")),
            ImmutableList.of("OTHER=1")));

    assertThatResolving(projectView, targetMapBuilder.build())
        .reusedConfigurations(initialConfigurations, "//foo/bar:library");
  }

  @Test
  public void afterQueryingConfiguration_newTarget_testIncrementalUpdatePartlyReused() {
    ProjectView projectView = projectView(directories("foo/bar"), targets("//foo/bar:*"));
    TargetMapBuilder targetMapBuilder =
        TargetMapBuilder.builder()
            .addTarget(createCcToolchain())
            .addTarget(
                createCcTarget(
                    "//foo/bar:binary",
                    Kind.CC_BINARY,
                    ImmutableList.of(src("foo/bar/binary.cc"))));
    assertThatResolving(projectView, targetMapBuilder.build())
        .producesConfigurationsFor("//foo/bar:binary");
    Collection<BlazeResolveConfiguration> initialConfigurations =
        resolverResult.getAllConfigurations();

    // Make sure that if we *query* the configuration in some way, it doesn't affect its
    // compatibility / reusability. There may be caches attached to the configuration and those
    // should not be compared when checking equivalence.
    OCResolveConfiguration firstConfiguration = initialConfigurations.iterator().next();
    firstConfiguration.getLibraryHeadersRoots(
        new OCResolveRootAndConfiguration(firstConfiguration, OCLanguageKind.CPP));

    targetMapBuilder.addTarget(
        createCcTarget(
            "//foo/bar:library",
            Kind.CC_LIBRARY,
            ImmutableList.of(src("foo/bar/library.cc")),
            ImmutableList.of("OTHER=1")));

    assertThatResolving(projectView, targetMapBuilder.build())
        .reusedConfigurations(initialConfigurations, "//foo/bar:library");
  }

  @Test
  public void completelyDifferentTargetsSameProjectView_testIncrementalUpdateNoReuse() {
    ProjectView projectView = projectView(directories("foo/bar"), targets("//foo/bar:*"));
    TargetMap targetMap =
        TargetMapBuilder.builder()
            .addTarget(createCcToolchain())
            .addTarget(
                createCcTarget(
                    "//foo/bar:binary", Kind.CC_BINARY, ImmutableList.of(src("foo/bar/binary.cc"))))
            .build();
    ImmutableList<BlazeResolveConfiguration> noReusedConfigurations = ImmutableList.of();
    assertThatResolving(projectView, targetMap)
        .reusedConfigurations(noReusedConfigurations, "//foo/bar:binary");

    TargetMap targetMap2 =
        TargetMapBuilder.builder()
            .addTarget(createCcToolchain())
            .addTarget(
                createCcTarget(
                    "//foo/bar:library",
                    Kind.CC_LIBRARY,
                    ImmutableList.of(src("foo/bar/library.cc")),
                    ImmutableList.of("OTHER=1")))
            .build();
    assertThatResolving(projectView, targetMap2)
        .reusedConfigurations(noReusedConfigurations, "//foo/bar:library");
  }

  @Test
  public void completelyDifferentTargetsDifferentProjectView_testIncrementalUpdateNoReuse() {
    ProjectView projectView = projectView(directories("foo/bar"), targets("//foo/bar:binary"));
    TargetMap targetMap =
        TargetMapBuilder.builder()
            .addTarget(createCcToolchain())
            .addTarget(
                createCcTarget(
                    "//foo/bar:binary", Kind.CC_BINARY, ImmutableList.of(src("foo/bar/binary.cc"))))
            .build();
    ImmutableList<BlazeResolveConfiguration> noReusedConfigurations = ImmutableList.of();
    assertThatResolving(projectView, targetMap)
        .reusedConfigurations(noReusedConfigurations, "//foo/bar:binary");

    ProjectView projectView2 = projectView(directories("foo/zoo"), targets("//foo/zoo:library"));
    TargetMap targetMap2 =
        TargetMapBuilder.builder()
            .addTarget(createCcToolchain())
            .addTarget(
                createCcTarget(
                    "//foo/zoo:library",
                    Kind.CC_LIBRARY,
                    ImmutableList.of(src("foo/zoo/library.cc")),
                    ImmutableList.of("OTHER=1")))
            .build();
    assertThatResolving(projectView2, targetMap2)
        .reusedConfigurations(noReusedConfigurations, "//foo/zoo:library");
  }

  @Test
  public void changeCompilerVersion_testIncrementalUpdateNoReuse() {
    ProjectView projectView = projectView(directories("foo/bar"), targets("//foo/bar:binary"));
    TargetMap targetMap =
        TargetMapBuilder.builder()
            .addTarget(createCcToolchain())
            .addTarget(
                createCcTarget(
                    "//foo/bar:binary", Kind.CC_BINARY, ImmutableList.of(src("foo/bar/binary.cc"))))
            .build();

    ImmutableList<BlazeResolveConfiguration> noReusedConfigurations = ImmutableList.of();
    assertThatResolving(projectView, targetMap)
        .reusedConfigurations(noReusedConfigurations, "//foo/bar:binary");

    compilerVersionChecker.setCompilerVersion("cc modified version");
    assertThatResolving(projectView, targetMap)
        .reusedConfigurations(noReusedConfigurations, "//foo/bar:binary");
  }

  @Test
  public void noChange_testIncrementalUpdateGetChangedFiles() {
    ProjectView projectView = projectView(directories("foo/bar"), targets("//foo/bar:binary"));
    TargetMap targetMap =
        TargetMapBuilder.builder()
            .addTarget(createCcToolchain())
            .addTarget(
                createCcTarget(
                    "//foo/bar:binary", Kind.CC_BINARY, ImmutableList.of(src("foo/bar/binary.cc"))))
            .build();
    assertThatResolving(projectView, targetMap).producesConfigurationsFor("//foo/bar:binary");

    assertThatResolving(projectView, targetMap).hasChangedRemovedFiles(ImmutableList.of(), false);
  }

  @Test
  public void addFiles_testIncrementalUpdateGetChangedFiles() {
    ProjectView projectView = projectView(directories("foo/bar"), targets("//foo/bar:*"));
    TargetMapBuilder targetMapBuilder =
        TargetMapBuilder.builder()
            .addTarget(createCcToolchain())
            .addTarget(
                createCcTarget(
                    "//foo/bar:binary",
                    Kind.CC_BINARY,
                    ImmutableList.of(src("foo/bar/binary.cc"))));
    TargetMap targetMap = targetMapBuilder.build();
    createVirtualFile("/root/foo/bar/binary.cc");
    assertThatResolving(projectView, targetMap).producesConfigurationsFor("//foo/bar:binary");

    TargetMap targetMap2 =
        targetMapBuilder
            .addTarget(
                createCcTarget(
                    "//foo/bar:library",
                    Kind.CC_LIBRARY,
                    ImmutableList.of(src("foo/bar/library.cc"))))
            .build();
    VirtualFile libraryCc = createVirtualFile("/root/foo/bar/library.cc");
    assertThatResolving(projectView, targetMap2)
        .hasChangedRemovedFiles(ImmutableList.of(libraryCc.getPath()), true);
  }

  @Test
  public void removeFiles_testIncrementalUpdateGetChangedFiles() {
    ProjectView projectView = projectView(directories("foo/bar"), targets("//foo/bar:*"));
    TargetMap targetMap =
        TargetMapBuilder.builder()
            .addTarget(createCcToolchain())
            .addTarget(
                createCcTarget(
                    "//foo/bar:binary", Kind.CC_BINARY, ImmutableList.of(src("foo/bar/binary.cc"))))
            .addTarget(
                createCcTarget(
                    "//foo/bar:library",
                    Kind.CC_LIBRARY,
                    ImmutableList.of(src("foo/bar/library.cc")),
                    ImmutableList.of("SOME_DEFINE=1")))
            .build();
    createVirtualFile("/root/foo/bar/binary.cc");
    createVirtualFile("/root/foo/bar/library.cc");
    assertThatResolving(projectView, targetMap)
        .producesConfigurationsFor("//foo/bar:binary", "//foo/bar:library");

    TargetMap targetMap2 =
        TargetMapBuilder.builder()
            .addTarget(createCcToolchain())
            .addTarget(
                createCcTarget(
                    "//foo/bar:binary", Kind.CC_BINARY, ImmutableList.of(src("foo/bar/binary.cc"))))
            .build();
    assertThatResolving(projectView, targetMap2).hasChangedRemovedFiles(ImmutableList.of(), true);
  }

  private static ArtifactLocation src(String path) {
    return ArtifactLocation.builder().setRelativePath(path).setIsSource(true).build();
  }

  private static ArtifactLocation gen(String path) {
    return ArtifactLocation.builder().setRelativePath(path).setIsSource(false).build();
  }

  private static TargetIdeInfo.Builder createCcTarget(
      String label, Kind kind, ImmutableList<ArtifactLocation> sources) {
    return createCcTarget(label, kind, sources, ImmutableList.of());
  }

  private static TargetIdeInfo.Builder createCcTarget(
      String label,
      Kind kind,
      ImmutableList<ArtifactLocation> sources,
      ImmutableList<String> defines) {
    TargetIdeInfo.Builder targetInfo =
        TargetIdeInfo.builder().setLabel(label).setKind(kind).addDependency("//:toolchain");
    sources.forEach(targetInfo::addSource);
    return targetInfo.setCInfo(CIdeInfo.builder().addSources(sources).addLocalDefines(defines));
  }

  private static TargetIdeInfo.Builder createCcToolchain() {
    return TargetIdeInfo.builder()
        .setLabel("//:toolchain")
        .setKind(Kind.CC_TOOLCHAIN)
        .setCToolchainInfo(
            CToolchainIdeInfo.builder().setCppExecutable(new ExecutionRootPath("cc")));
  }

  private static ListSection<DirectoryEntry> directories(String... directories) {
    return ListSection.builder(DirectorySection.KEY)
        .addAll(
            Arrays.stream(directories)
                .map(directory -> DirectoryEntry.include(WorkspacePath.createIfValid(directory)))
                .collect(Collectors.toList()))
        .build();
  }

  private static ListSection<TargetExpression> targets(String... targets) {
    return ListSection.builder(TargetSection.KEY)
        .addAll(
            Arrays.stream(targets).map(TargetExpression::fromString).collect(Collectors.toList()))
        .build();
  }

  private static ProjectView projectView(
      ListSection<DirectoryEntry> directories, ListSection<TargetExpression> targets) {
    return ProjectView.builder().add(directories).add(targets).build();
  }

  private VirtualFile createVirtualFile(String path) {
    VirtualFile mockFile = mock(VirtualFile.class);
    when(mockFile.getPath()).thenReturn(path);
    when(mockFileSystem.findFileByIoFile(new File(path))).thenReturn(mockFile);
    return mockFile;
  }

  private Subject assertThatResolving(ProjectView projectView, TargetMap targetMap) {
    BlazeProjectData blazeProjectData =
        MockBlazeProjectDataBuilder.builder(workspaceRoot).setTargetMap(targetMap).build();
    resolverResult =
        resolver.update(
            context,
            workspaceRoot,
            ProjectViewSet.builder().add(projectView).build(),
            blazeProjectData,
            resolverResult);
    errorCollector.assertNoIssues();
    return new Subject() {
      @Override
      public void producesConfigurationsFor(String... expected) {
        List<String> targets =
            resolverResult
                .getAllConfigurations()
                .stream()
                .map(configuration -> configuration.getDisplayName(false))
                .collect(Collectors.toList());
        assertThat(targets).containsExactly((Object[]) expected);
      }

      @Override
      public void producesNoConfigurations() {
        assertThat(resolverResult.getAllConfigurations()).isEmpty();
      }

      @Override
      public void reusedConfigurations(
          Collection<BlazeResolveConfiguration> expectedReused, String... expectedNotReused) {
        Collection<BlazeResolveConfiguration> currentConfigurations =
            resolverResult.getAllConfigurations();
        assertContainsAllInIdentity(expectedReused, currentConfigurations);
        List<String> notReusedTargets =
            currentConfigurations
                .stream()
                .filter(
                    configuration ->
                        expectedReused
                            .stream()
                            .noneMatch(reusedConfig -> configuration == reusedConfig))
                .map(configuration -> configuration.getDisplayName(false))
                .collect(Collectors.toList());
        assertThat(notReusedTargets).containsExactly((Object[]) expectedNotReused);
      }

      @Override
      public void hasChangedRemovedFiles(
          ImmutableList<String> expectedChangedFiles, boolean expectedHasChanges) {
        BlazeConfigurationResolverDiff diff = resolverResult.getConfigurationDiff();
        assertThat(diff).isNotNull();
        List<String> changedFileNames =
            diff.getChangedFiles().stream().map(VirtualFile::getPath).collect(Collectors.toList());
        assertThat(changedFileNames).containsExactlyElementsIn(expectedChangedFiles);
        assertThat(diff.hasChanges()).isEqualTo(expectedHasChanges);
      }

      // In newer truth libraries, we could use:
      // assertThat(actual).comparingElementsUsing(IdentityCorrespondence).containsAllIn(expected)
      // but that isn't available in truth 0.30 from older plugin APIs.
      private <T> void assertContainsAllInIdentity(Collection<T> expected, Collection<T> actual) {
        for (T expectedItem : expected) {
          assertThat(actual.stream().anyMatch(actualItem -> actualItem == expectedItem)).isTrue();
        }
      }
    };
  }

  private interface Subject {
    void producesConfigurationsFor(String... expected);

    void producesNoConfigurations();

    void reusedConfigurations(Collection<BlazeResolveConfiguration> reused, String... notReused);

    void hasChangedRemovedFiles(
        ImmutableList<String> expectedChangedFiles, boolean hasRemovedFiles);
  }
}