/*
 * 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 com.google.common.truth.Truth.assertWithMessage;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

import com.google.common.collect.ImmutableCollection;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Iterables;
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.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.mock.MockPsiManager;
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.intellij.openapi.vfs.newvfs.impl.StubVirtualFile;
import com.intellij.psi.PsiManager;
import com.jetbrains.cidr.lang.OCLanguageKind;
import com.jetbrains.cidr.lang.workspace.OCResolveRootAndConfiguration;
import com.jetbrains.cidr.lang.workspace.headerRoots.HeadersSearchRoot;
import com.jetbrains.cidr.lang.workspace.headerRoots.IncludedHeadersRoot;
import java.io.File;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;

/** Tests that we group equivalent {@link BlazeResolveConfiguration}s. */
@RunWith(JUnit4.class)
public class BlazeResolveConfigurationEquivalenceTest 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 LocalFileSystem mockFileSystem;

  @Override
  protected void initTest(Container applicationServices, Container projectServices) {
    super.initTest(applicationServices, projectServices);
    applicationServices.register(BlazeExecutor.class, new MockBlazeExecutor());
    applicationServices.register(
        CompilerVersionChecker.class, new MockCompilerVersionChecker("1234"));

    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(PsiManager.class, new MockPsiManager(project));
    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 testEmptyConfigurations() {
    ProjectView projectView =
        projectView(
            directories("foo/bar"), targets("//foo/bar:one", "//foo/bar:two", "//foo/bar:three"));
    TargetMap targetMap =
        TargetMapBuilder.builder()
            .addTarget(createCcToolchain())
            .addTarget(
                createCcTarget(
                    "//foo/bar:one",
                    Kind.CC_BINARY,
                    sources("foo/bar/one.cc"),
                    defines(),
                    includes()))
            .addTarget(
                createCcTarget(
                    "//foo/bar:two",
                    Kind.CC_BINARY,
                    sources("foo/bar/two.cc"),
                    defines(),
                    includes()))
            .addTarget(
                createCcTarget(
                    "//foo/bar:three",
                    Kind.CC_BINARY,
                    sources("foo/bar/three.cc"),
                    defines(),
                    includes()))
            .build();
    List<BlazeResolveConfiguration> configurations = resolve(projectView, targetMap);
    assertThat(configurations).hasSize(1);
    assertThat(get(configurations, "//foo/bar:one and 2 other target(s)")).isNotNull();
    for (BlazeResolveConfiguration configuration : configurations) {
      assertThat(configuration.getProjectHeadersRoots().getRoots()).isEmpty();
      assertThat(getHeaders(configuration, OCLanguageKind.CPP)).isEmpty();
      assertThat(configuration.getCompilerMacros()).isEqualTo(macros());
    }
  }

  @Test
  public void testDefines() {
    ProjectView projectView =
        projectView(
            directories("foo/bar"), targets("//foo/bar:one", "//foo/bar:two", "//foo/bar:three"));
    TargetMap targetMap =
        TargetMapBuilder.builder()
            .addTarget(createCcToolchain())
            .addTarget(
                createCcTarget(
                    "//foo/bar:one",
                    Kind.CC_BINARY,
                    sources("foo/bar/one.cc"),
                    defines("SAME=1"),
                    includes()))
            .addTarget(
                createCcTarget(
                    "//foo/bar:two",
                    Kind.CC_BINARY,
                    sources("foo/bar/two.cc"),
                    defines("SAME=1"),
                    includes()))
            .addTarget(
                createCcTarget(
                    "//foo/bar:three",
                    Kind.CC_BINARY,
                    sources("foo/bar/three.cc"),
                    defines("DIFFERENT=1"),
                    includes()))
            .build();
    List<BlazeResolveConfiguration> configurations = resolve(projectView, targetMap);
    assertThat(configurations).hasSize(2);
    assertThat(get(configurations, "//foo/bar:one and 1 other target(s)").getCompilerMacros())
        .isEqualTo(macros("SAME=1"));
    assertThat(get(configurations, "//foo/bar:three").getCompilerMacros())
        .isEqualTo(macros("DIFFERENT=1"));
    for (BlazeResolveConfiguration configuration : configurations) {
      assertThat(configuration.getProjectHeadersRoots().getRoots()).isEmpty();
      assertThat(getHeaders(configuration, OCLanguageKind.CPP)).isEmpty();
    }
  }

  @Test
  public void testIncludes() {
    ProjectView projectView =
        projectView(
            directories("foo/bar"), targets("//foo/bar:one", "//foo/bar:two", "//foo/bar:three"));
    TargetMap targetMap =
        TargetMapBuilder.builder()
            .addTarget(createCcToolchain())
            .addTarget(
                createCcTarget(
                    "//foo/bar:one",
                    Kind.CC_BINARY,
                    sources("foo/bar/one.cc"),
                    defines(),
                    includes("foo/same")))
            .addTarget(
                createCcTarget(
                    "//foo/bar:two",
                    Kind.CC_BINARY,
                    sources("foo/bar/two.cc"),
                    defines(),
                    includes("foo/same")))
            .addTarget(
                createCcTarget(
                    "//foo/bar:three",
                    Kind.CC_BINARY,
                    sources("foo/bar/three.cc"),
                    defines(),
                    includes("foo/different")))
            .build();
    VirtualFile includeSame = createVirtualFile("/root/foo/same");
    VirtualFile includeDifferent = createVirtualFile("/root/foo/different");
    List<BlazeResolveConfiguration> configurations = resolve(projectView, targetMap);
    assertThat(configurations).hasSize(2);
    assertThat(
            getHeaders(
                get(configurations, "//foo/bar:one and 1 other target(s)"), OCLanguageKind.CPP))
        .containsExactly(header(includeSame));
    assertThat(getHeaders(get(configurations, "//foo/bar:three"), OCLanguageKind.CPP))
        .containsExactly(header(includeDifferent));
    for (BlazeResolveConfiguration configuration : configurations) {
      assertThat(configuration.getProjectHeadersRoots().getRoots()).isEmpty();
      assertThat(configuration.getCompilerMacros()).isEqualTo(macros());
    }
  }

  // Test a series of permutations of labels a, b, c, d.
  // Initial state is {a=1, b=1, c=1, d=0}, and we flip some of the 1 to 0.
  private TargetMap incrementalUpdateTestCaseInitialTargetMap() {
    return TargetMapBuilder.builder()
        .addTarget(createCcToolchain())
        .addTarget(
            createCcTarget(
                "//foo/bar:a",
                Kind.CC_BINARY,
                sources("foo/bar/a.cc"),
                defines("SAME=1"),
                includes()))
        .addTarget(
            createCcTarget(
                "//foo/bar:b",
                Kind.CC_BINARY,
                sources("foo/bar/b.cc"),
                defines("SAME=1"),
                includes()))
        .addTarget(
            createCcTarget(
                "//foo/bar:c",
                Kind.CC_BINARY,
                sources("foo/bar/c.cc"),
                defines("SAME=1"),
                includes()))
        .addTarget(
            createCcTarget(
                "//foo/bar:d",
                Kind.CC_BINARY,
                sources("foo/bar/d.cc"),
                defines("DIFFERENT=1"),
                includes()))
        .build();
  }

  // TODO(jvoung): This could be a separate Parameterized test.
  private static final Map<List<String>, ReusedConfigurationExpectations>
      permutationsAndExpectations =
          ImmutableMap.<List<String>, ReusedConfigurationExpectations>builder()
              .put(
                  ImmutableList.of("a"),
                  // Since we already had a config at 1 and one at 0, flipping any 1 to 0 will
                  // always
                  // result in reuse. The old configurations will get renamed.
                  new ReusedConfigurationExpectations(
                      ImmutableList.of(
                          "//foo/bar:a and 1 other target(s)", "//foo/bar:b and 1 other target(s)"),
                      ImmutableList.of()))
              .put(
                  ImmutableList.of("b"),
                  new ReusedConfigurationExpectations(
                      ImmutableList.of(
                          "//foo/bar:a and 1 other target(s)", "//foo/bar:b and 1 other target(s)"),
                      ImmutableList.of()))
              .put(
                  ImmutableList.of("c"),
                  new ReusedConfigurationExpectations(
                      ImmutableList.of(
                          "//foo/bar:a and 1 other target(s)", "//foo/bar:c and 1 other target(s)"),
                      ImmutableList.of()))
              .put(
                  ImmutableList.of("a", "b"),
                  new ReusedConfigurationExpectations(
                      ImmutableList.of("//foo/bar:a and 2 other target(s)", "//foo/bar:c"),
                      ImmutableList.of()))
              .put(
                  ImmutableList.of("b", "c"),
                  new ReusedConfigurationExpectations(
                      ImmutableList.of("//foo/bar:a", "//foo/bar:b and 2 other target(s)"),
                      ImmutableList.of()))
              .put(
                  ImmutableList.of("a", "c"),
                  new ReusedConfigurationExpectations(
                      ImmutableList.of("//foo/bar:a and 2 other target(s)", "//foo/bar:b"),
                      ImmutableList.of()))
              .put(
                  ImmutableList.of("a", "b", "c"),
                  new ReusedConfigurationExpectations(
                      ImmutableList.of("//foo/bar:a and 3 other target(s)"), ImmutableList.of()))
              .build();

  @Test
  public void changeDefines_testIncrementalUpdate_0() {
    Map.Entry<List<String>, ReusedConfigurationExpectations> testCase =
        Iterables.get(permutationsAndExpectations.entrySet(), 0);
    do_changeDefines_testIncrementalUpdate(testCase.getKey(), testCase.getValue());
  }

  @Test
  public void changeDefines_testIncrementalUpdate_1() {
    Map.Entry<List<String>, ReusedConfigurationExpectations> testCase =
        Iterables.get(permutationsAndExpectations.entrySet(), 1);
    do_changeDefines_testIncrementalUpdate(testCase.getKey(), testCase.getValue());
  }

  @Test
  public void changeDefines_testIncrementalUpdate_2() {
    Map.Entry<List<String>, ReusedConfigurationExpectations> testCase =
        Iterables.get(permutationsAndExpectations.entrySet(), 2);
    do_changeDefines_testIncrementalUpdate(testCase.getKey(), testCase.getValue());
  }

  @Test
  public void changeDefines_testIncrementalUpdate_3() {
    Map.Entry<List<String>, ReusedConfigurationExpectations> testCase =
        Iterables.get(permutationsAndExpectations.entrySet(), 3);
    do_changeDefines_testIncrementalUpdate(testCase.getKey(), testCase.getValue());
  }

  @Test
  public void changeDefines_testIncrementalUpdate_4() {
    Map.Entry<List<String>, ReusedConfigurationExpectations> testCase =
        Iterables.get(permutationsAndExpectations.entrySet(), 4);
    do_changeDefines_testIncrementalUpdate(testCase.getKey(), testCase.getValue());
  }

  @Test
  public void changeDefines_testIncrementalUpdate_5() {
    Map.Entry<List<String>, ReusedConfigurationExpectations> testCase =
        Iterables.get(permutationsAndExpectations.entrySet(), 5);
    do_changeDefines_testIncrementalUpdate(testCase.getKey(), testCase.getValue());
  }

  @Test
  public void changeDefines_testIncrementalUpdate_6() {
    Map.Entry<List<String>, ReusedConfigurationExpectations> testCase =
        Iterables.get(permutationsAndExpectations.entrySet(), 6);
    do_changeDefines_testIncrementalUpdate(testCase.getKey(), testCase.getValue());
    assertThat(permutationsAndExpectations.size()).isEqualTo(7);
  }

  private void do_changeDefines_testIncrementalUpdate(
      List<String> labelsToFlip, ReusedConfigurationExpectations expectation) {
    ProjectView projectView = projectView(directories("foo/bar"), targets("//foo/bar:...:all"));
    List<BlazeResolveConfiguration> configurations =
        resolve(projectView, incrementalUpdateTestCaseInitialTargetMap());
    assertThat(configurations).hasSize(2);
    assertThat(get(configurations, "//foo/bar:a and 2 other target(s)")).isNotNull();
    assertThat(get(configurations, "//foo/bar:d")).isNotNull();

    TargetMapBuilder targetMapBuilder = TargetMapBuilder.builder().addTarget(createCcToolchain());
    for (String target : ImmutableList.of("a", "b", "c")) {
      if (labelsToFlip.contains(target)) {
        targetMapBuilder.addTarget(
            createCcTarget(
                String.format("//foo/bar:%s", target),
                Kind.CC_BINARY,
                sources(String.format("foo/bar/%s.cc", target)),
                defines("DIFFERENT=1"),
                includes()));
      } else {
        targetMapBuilder.addTarget(
            createCcTarget(
                String.format("//foo/bar:%s", target),
                Kind.CC_BINARY,
                sources(String.format("foo/bar/%s.cc", target)),
                defines("SAME=1"),
                includes()));
      }
    }
    targetMapBuilder.addTarget(
        createCcTarget(
            "//foo/bar:d",
            Kind.CC_BINARY,
            sources("foo/bar/d.cc"),
            defines("DIFFERENT=1"),
            includes()));
    List<BlazeResolveConfiguration> newConfigurations =
        resolve(projectView, targetMapBuilder.build());
    assertReusedConfigs(configurations, newConfigurations, expectation);
  }

  @Test
  public void changeDefinesWithSameStructure_testIncrementalUpdate() {
    ProjectView projectView = projectView(directories("foo/bar"), targets("//foo/bar:...:all"));
    TargetMap targetMap = incrementalUpdateTestCaseInitialTargetMap();
    List<BlazeResolveConfiguration> configurations = resolve(projectView, targetMap);
    assertThat(configurations).hasSize(2);
    assertThat(get(configurations, "//foo/bar:a and 2 other target(s)")).isNotNull();
    assertThat(get(configurations, "//foo/bar:d")).isNotNull();

    targetMap =
        TargetMapBuilder.builder()
            .addTarget(createCcToolchain())
            .addTarget(
                createCcTarget(
                    "//foo/bar:a",
                    Kind.CC_BINARY,
                    sources("foo/bar/a.cc"),
                    defines("CHANGED=1"),
                    includes()))
            .addTarget(
                createCcTarget(
                    "//foo/bar:b",
                    Kind.CC_BINARY,
                    sources("foo/bar/b.cc"),
                    defines("CHANGED=1"),
                    includes()))
            .addTarget(
                createCcTarget(
                    "//foo/bar:c",
                    Kind.CC_BINARY,
                    sources("foo/bar/c.cc"),
                    defines("CHANGED=1"),
                    includes()))
            .addTarget(
                createCcTarget(
                    "//foo/bar:d",
                    Kind.CC_BINARY,
                    sources("foo/bar/d.cc"),
                    defines("DIFFERENT=1"),
                    includes()))
            .build();
    List<BlazeResolveConfiguration> newConfigurations = resolve(projectView, targetMap);
    assertThat(newConfigurations).hasSize(2);
    assertReusedConfigs(
        configurations,
        newConfigurations,
        new ReusedConfigurationExpectations(
            ImmutableList.of("//foo/bar:d"),
            ImmutableList.of("//foo/bar:a and 2 other target(s)")));
  }

  @Test
  public void changeDefinesMakeAllSame_testIncrementalUpdate() {
    ProjectView projectView = projectView(directories("foo/bar"), targets("//foo/bar:...:all"));
    TargetMap targetMap = incrementalUpdateTestCaseInitialTargetMap();
    List<BlazeResolveConfiguration> configurations = resolve(projectView, targetMap);
    assertThat(configurations).hasSize(2);
    assertThat(get(configurations, "//foo/bar:a and 2 other target(s)")).isNotNull();
    assertThat(get(configurations, "//foo/bar:d")).isNotNull();

    targetMap =
        TargetMapBuilder.builder()
            .addTarget(createCcToolchain())
            .addTarget(
                createCcTarget(
                    "//foo/bar:a",
                    Kind.CC_BINARY,
                    sources("foo/bar/a.cc"),
                    defines("SAME=1"),
                    includes()))
            .addTarget(
                createCcTarget(
                    "//foo/bar:b",
                    Kind.CC_BINARY,
                    sources("foo/bar/b.cc"),
                    defines("SAME=1"),
                    includes()))
            .addTarget(
                createCcTarget(
                    "//foo/bar:c",
                    Kind.CC_BINARY,
                    sources("foo/bar/c.cc"),
                    defines("SAME=1"),
                    includes()))
            .addTarget(
                createCcTarget(
                    "//foo/bar:d",
                    Kind.CC_BINARY,
                    sources("foo/bar/d.cc"),
                    defines("SAME=1"),
                    includes()))
            .build();
    List<BlazeResolveConfiguration> newConfigurations = resolve(projectView, targetMap);
    assertThat(newConfigurations).hasSize(1);
    // What used to be "//foo/bar:a and 2 other target(s)" will be renamed to
    // "//foo/bar:a and 3 other target(s)" and reused.
    assertReusedConfigs(
        configurations,
        newConfigurations,
        new ReusedConfigurationExpectations(
            ImmutableList.of("//foo/bar:a and 3 other target(s)"), ImmutableList.of()));
  }

  private static List<ArtifactLocation> sources(String... paths) {
    return Arrays.stream(paths)
        .map(path -> ArtifactLocation.builder().setRelativePath(path).setIsSource(true).build())
        .collect(Collectors.toList());
  }

  private static List<String> defines(String... defines) {
    return Arrays.asList(defines);
  }

  private static List<ExecutionRootPath> includes(String... paths) {
    return Arrays.stream(paths).map(ExecutionRootPath::new).collect(Collectors.toList());
  }

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

  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 List<BlazeResolveConfiguration> resolve(ProjectView projectView, TargetMap targetMap) {
    resolverResult =
        resolver.update(
            context,
            workspaceRoot,
            ProjectViewSet.builder().add(projectView).build(),
            MockBlazeProjectDataBuilder.builder(workspaceRoot).setTargetMap(targetMap).build(),
            resolverResult);
    errorCollector.assertNoIssues();
    return resolverResult.getAllConfigurations();
  }

  private static BlazeResolveConfiguration get(
      List<BlazeResolveConfiguration> configurations, String name) {
    List<BlazeResolveConfiguration> filteredConfigurations =
        configurations
            .stream()
            .filter(c -> c.getDisplayName(false).equals(name))
            .collect(Collectors.toList());
    assertWithMessage(
            String.format(
                "%s contains %s",
                configurations
                    .stream()
                    .map(c -> c.getDisplayName(false))
                    .collect(Collectors.toList()),
                name))
        .that(filteredConfigurations)
        .hasSize(1);
    return filteredConfigurations.get(0);
  }

  private BlazeCompilerMacros macros(String... defines) {
    return new BlazeCompilerMacros(
        project, null, null, ImmutableList.copyOf(defines), ImmutableMap.of());
  }

  private HeadersSearchRoot header(VirtualFile include) {
    return new IncludedHeadersRoot(project, include, false, true);
  }

  private static List<HeadersSearchRoot> getHeaders(
      BlazeResolveConfiguration configuration, OCLanguageKind languageKind) {
    return configuration
        .getLibraryHeadersRoots(new OCResolveRootAndConfiguration(configuration, languageKind))
        .getRoots();
  }

  private VirtualFile createVirtualFile(String path) {
    VirtualFile stub = new StubVirtualFile();
    when(mockFileSystem.findFileByIoFile(new File(path))).thenReturn(stub);
    return stub;
  }

  private static void assertReusedConfigs(
      List<BlazeResolveConfiguration> oldConfigurations,
      List<BlazeResolveConfiguration> newConfigurations,
      ReusedConfigurationExpectations expected) {
    for (String label : expected.reusedLabels) {
      assertWithMessage(String.format("Checking that %s is reused", label))
          .that(get(newConfigurations, label))
          .isSameAs(get(oldConfigurations, label));
    }
    for (String label : expected.notReusedLabels) {
      assertWithMessage(String.format("Checking that %s is NOT reused", label))
          .that(get(newConfigurations, label))
          .isNotSameAs(get(oldConfigurations, label));
    }
  }

  private static class ReusedConfigurationExpectations {
    final ImmutableCollection<String> reusedLabels;
    final ImmutableCollection<String> notReusedLabels;

    ReusedConfigurationExpectations(
        ImmutableCollection<String> reusedLabels, ImmutableCollection<String> notReusedLabels) {
      this.reusedLabels = reusedLabels;
      this.notReusedLabels = notReusedLabels;
    }
  }
}