Add methods for filtering LocalResourceContainer

Dynamically Configured Resource Filtering change 1/6

To enable dynamically configured resource filtering, we'll need to be able to
pass filtered resources into resource processing code used by android_library
targets. The resource parsing action, used only in android_library targets,
takes the LocalResourceContainer as an input, unlike android_binary processing
code which never used it directly.

Abstract the code for actually building the collection of resource roots out of the withResources method, and create an additional method for calling it from resource filtering.

Also, split some common test code out of ResourceFilterTestBase to make a ResourceTestBase class for testing changes to this (and eventually, other) resource-oriented classes, and create LocalResourceContainerTest for this class in particular.

RELNOTES: none
PiperOrigin-RevId: 160640192

1 files changed, 172 insertions, 0 deletions

diff --git a/src/test/java/com/google/devtools/build/lib/rules/android/LocalResourceContainerTest.java b/src/test/java/com/google/devtools/build/lib/rules/android/LocalResourceContainerTest.java
new file mode 100644
index 0000000000..6f397bf5fb
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/rules/android/LocalResourceContainerTest.java
@@ -0,0 +1,172 @@
+// 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.devtools.build.lib.rules.android;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.Truth.assertWithMessage;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.devtools.build.lib.actions.Artifact;
+import com.google.devtools.build.lib.packages.RuleClass.ConfiguredTargetFactory.RuleErrorException;
+import com.google.devtools.build.lib.packages.RuleErrorConsumer;
+import com.google.devtools.build.lib.vfs.PathFragment;
+import java.util.Map;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Tests {@link LocalResourceContainer} */
+@RunWith(JUnit4.class)
+public class LocalResourceContainerTest extends ResourceTestBase {
+  private static final PathFragment DEFAULT_RESOURCE_ROOT = PathFragment.create(RESOURCE_ROOT);
+  private static final ImmutableList<PathFragment> RESOURCES_ROOTS =
+      ImmutableList.of(DEFAULT_RESOURCE_ROOT);
+
+  @Before
+  @Test
+  public void testGetResourceRootsNoResources() throws Exception {
+    assertThat(getResourceRoots()).isEmpty();
+  }
+
+  @Test
+  public void testGetResourceRootsInvalidResourceDirectory() throws Exception {
+    try {
+      getResourceRoots("is-this-drawable-or-values/foo.xml");
+      assertWithMessage("Expected exception not thrown!").fail();
+    } catch (RuleErrorException e) {
+      // expected
+    }
+
+    errorConsumer.assertAttributeError(
+        "resources", "is not in the expected resource directory structure");
+  }
+
+  @Test
+  public void testGetResourceRootsMultipleRoots() throws Exception {
+    try {
+      getResourceRoots("subdir/values/foo.xml", "otherdir/values/bar.xml");
+      assertWithMessage("Expected exception not thrown!").fail();
+    } catch (RuleErrorException e) {
+      // expected
+    }
+
+    errorConsumer.assertAttributeError(
+        "resources", "All resources must share a common directory");
+  }
+
+  @Test
+  public void testGetResourceRoots() throws Exception {
+    assertThat(getResourceRoots("values-hdpi/foo.xml", "values-mdpi/bar.xml"))
+        .isEqualTo(RESOURCES_ROOTS);
+  }
+
+  @Test
+  public void testGetResourceRootsCommonSubdirectory() throws Exception {
+    assertThat(getResourceRoots("subdir/values-hdpi/foo.xml", "subdir/values-mdpi/bar.xml"))
+        .containsExactly(DEFAULT_RESOURCE_ROOT.getRelative("subdir"));
+  }
+
+  private ImmutableList<PathFragment> getResourceRoots(String... pathResourceStrings)
+      throws Exception {
+    return getResourceRoots(getResources(pathResourceStrings));
+  }
+
+  private ImmutableList<PathFragment> getResourceRoots(ImmutableList<Artifact> artifacts)
+      throws Exception {
+    return LocalResourceContainer.getResourceRoots(errorConsumer, artifacts);
+  }
+
+  @Test
+  public void testFilterEmpty() throws Exception {
+    assertFilter(ImmutableList.<Artifact>of(), ImmutableList.<Artifact>of());
+  }
+
+  @Test
+  public void testFilterNoop() throws Exception {
+    ImmutableList<Artifact> resources = getResources("values-en/foo.xml", "values-es/bar.xml");
+    assertFilter(resources, resources);
+  }
+
+  @Test
+  public void testFilterToEmpty() throws Exception {
+    assertFilter(
+        getResources("values-en/foo.xml", "values-es/bar.xml"), ImmutableList.<Artifact>of());
+  }
+
+  @Test
+  public void testPartiallyFilter() throws Exception {
+    Artifact keptResource = getResource("values-en/foo.xml");
+    assertFilter(
+        ImmutableList.of(keptResource, getResource("values-es/bar.xml")),
+        ImmutableList.of(keptResource));
+  }
+
+  private void assertFilter(
+      ImmutableList<Artifact> unfilteredResources, ImmutableList<Artifact> filteredResources)
+      throws Exception {
+    ResourceFilter filter =
+        new FakeResourceFilter(ImmutableMap.of(unfilteredResources, filteredResources));
+    ImmutableList<PathFragment> unfilteredResourcesRoots = getResourceRoots(unfilteredResources);
+    LocalResourceContainer unfiltered =
+        new LocalResourceContainer(
+            unfilteredResources,
+            unfilteredResourcesRoots,
+            unfilteredResources,
+            unfilteredResourcesRoots);
+
+    LocalResourceContainer filtered = unfiltered.filter(errorConsumer, filter);
+
+    if (unfilteredResources.equals(filteredResources)) {
+      // The filtering was a no-op; the original object, not a copy, should be returned
+      assertThat(filtered).isSameAs(unfiltered);
+    } else {
+      // The resources and their roots should be filtered
+      assertThat(filtered.getResources()).containsExactlyElementsIn(filteredResources).inOrder();
+      assertThat(filtered.getResourceRoots())
+          .containsExactlyElementsIn(getResourceRoots(filteredResources))
+          .inOrder();
+
+      // The assets and their roots should not be filtered; the original objects, not a copy, should
+      // be returned.
+      assertThat(filtered.getAssets()).isSameAs(unfiltered.getAssets());
+      assertThat(filtered.getAssetRoots()).isSameAs(unfiltered.getAssetRoots());
+    }
+  }
+
+  private static class FakeResourceFilter extends ResourceFilter {
+    private final Map<ImmutableList<Artifact>, ImmutableList<Artifact>> filterInputToOutputMap;
+
+    FakeResourceFilter(
+        Map<ImmutableList<Artifact>, ImmutableList<Artifact>> filterInputToOutputMap) {
+      super(
+          ImmutableList.<String>of(),
+          ImmutableList.<String>of(),
+          FilterBehavior.FILTER_IN_ANALYSIS);
+      this.filterInputToOutputMap = filterInputToOutputMap;
+    }
+
+    @Override
+    public ImmutableList<Artifact> filter(
+        RuleErrorConsumer errorConsumer, ImmutableList<Artifact> artifacts) {
+      if (filterInputToOutputMap.containsKey(artifacts)) {
+        return filterInputToOutputMap.get(artifacts);
+      }
+
+      assertWithMessage("Called with unexpected input: " + artifacts).fail();
+      return artifacts;
+    }
+  }
+}