Open source the TargetPatternEvaluator tests.

--
MOS_MIGRATED_REVID=109581214

4 files changed, 1408 insertions, 0 deletions

diff --git a/src/test/java/com/google/devtools/build/lib/BUILD b/src/test/java/com/google/devtools/build/lib/BUILD
index 19dc9764e7..bd2120d13b 100644
--- a/src/test/java/com/google/devtools/build/lib/BUILD
+++ b/src/test/java/com/google/devtools/build/lib/BUILD
@@ -586,6 +586,28 @@ java_test(
 )
 
 java_test(
+    name = "pkgcache_test",
+    srcs = glob(
+        [
+            "pkgcache/*.java",
+        ],
+    ),
+    args = ["com.google.devtools.build.lib.AllTests"],
+    deps = [
+        ":packages_testutil",
+        ":test_runner",
+        "//src/main/java/com/google/devtools/build/lib:bazel-rules",
+        "//src/main/java/com/google/devtools/build/lib:build-base",
+        "//src/main/java/com/google/devtools/build/lib:packages",
+        "//src/main/java/com/google/devtools/build/skyframe",
+        "//third_party:guava",
+        "//third_party:jsr305",
+        "//third_party:junit4",
+        "//third_party:truth",
+    ],
+)
+
+java_test(
     name = "ideinfo_test",
     srcs = glob([
         "ideinfo/*.java",
diff --git a/src/test/java/com/google/devtools/build/lib/pkgcache/AbstractTargetPatternEvaluatorTest.java b/src/test/java/com/google/devtools/build/lib/pkgcache/AbstractTargetPatternEvaluatorTest.java
new file mode 100644
index 0000000000..766b85bdf6
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/pkgcache/AbstractTargetPatternEvaluatorTest.java
@@ -0,0 +1,122 @@
+// Copyright 2015 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.pkgcache;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.collect.ImmutableList;
+import com.google.devtools.build.lib.cmdline.Label;
+import com.google.devtools.build.lib.cmdline.LabelSyntaxException;
+import com.google.devtools.build.lib.cmdline.ResolvedTargets;
+import com.google.devtools.build.lib.cmdline.TargetParsingException;
+import com.google.devtools.build.lib.events.DelegatingEventHandler;
+import com.google.devtools.build.lib.events.EventHandler;
+import com.google.devtools.build.lib.packages.ConstantRuleVisibility;
+import com.google.devtools.build.lib.packages.PackageFactory;
+import com.google.devtools.build.lib.packages.Preprocessor;
+import com.google.devtools.build.lib.packages.Target;
+import com.google.devtools.build.lib.packages.util.PackageLoadingTestCase;
+import com.google.devtools.build.lib.skyframe.SkyframeExecutor;
+import com.google.devtools.build.lib.util.Pair;
+
+import org.junit.Before;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+/**
+ * Abstract framework for target pattern evaluation tests. The {@link TargetPatternEvaluatorTest}
+ * contains much of the functionality that might be needed for future tests, and its methods should
+ * be extracted here if they are needed by other classes.
+ */
+public abstract class AbstractTargetPatternEvaluatorTest extends PackageLoadingTestCase {
+  protected SkyframeExecutor skyframeExecutor;
+  protected TargetPatternEvaluator parser;
+  protected RecordingParsingListener parsingListener;
+
+  protected static ResolvedTargets<Target> parseTargetPatternList(
+      TargetPatternEvaluator parser, EventHandler eventHandler,
+      List<String> targetPatterns, boolean keepGoing)
+          throws TargetParsingException, InterruptedException {
+    return parseTargetPatternList(
+        parser, eventHandler, targetPatterns, FilteringPolicies.NO_FILTER, keepGoing);
+  }
+
+  protected static ResolvedTargets<Target> parseTargetPatternList(
+      TargetPatternEvaluator parser, EventHandler eventHandler,
+      List<String> targetPatterns, FilteringPolicy policy,
+      boolean keepGoing) throws TargetParsingException, InterruptedException {
+    return parser.parseTargetPatternList(eventHandler, targetPatterns, policy, keepGoing);
+  }
+
+  /**
+   * Method converts collection of targets to the new, mutable,
+   * lexicographically-ordered set of corresponding labels.
+   */
+  protected static Set<Label> targetsToLabels(Iterable<Target> targets) {
+    Set<Label> labels = new TreeSet<>();
+    for (Target target : targets) {
+      labels.add(target.getLabel());
+    }
+    return labels;
+  }
+
+  @Before
+  public final void initializeParser() throws Exception {
+    skyframeExecutor =
+        super.createSkyframeExecutor(ImmutableList.<PackageFactory.EnvironmentExtension>of(),
+            Preprocessor.Factory.Supplier.NullSupplier.INSTANCE, ConstantRuleVisibility.PRIVATE,
+            ruleClassProvider.getDefaultsPackageContent());
+    parser = skyframeExecutor.getPackageManager().newTargetPatternEvaluator();
+    parsingListener = new RecordingParsingListener(reporter);
+  }
+
+  protected static Set<Label> labels(String... labelStrings) throws LabelSyntaxException {
+    Set<Label> labels = new HashSet<>();
+    for (String labelString : labelStrings) {
+      labels.add(Label.parseAbsolute(labelString));
+    }
+    return labels;
+  }
+
+  protected Pair<Set<Label>, Boolean> parseListKeepGoing(String... patterns)
+      throws TargetParsingException, InterruptedException {
+    ResolvedTargets<Target> result = parseTargetPatternList(parser, parsingListener,
+            Arrays.asList(patterns), true);
+    return Pair.of(targetsToLabels(result.getTargets()), result.hasError());
+  }
+
+  /** Event handler that records all parsing errors. */
+  protected static final class RecordingParsingListener extends DelegatingEventHandler
+      implements ParseFailureListener {
+    protected final List<Pair<String, String>> events = new ArrayList<>();
+
+    private RecordingParsingListener(EventHandler delegate) {
+      super(delegate);
+    }
+
+    @Override
+    public void parsingError(String targetPattern, String message) {
+      events.add(Pair.of(targetPattern, message));
+    }
+
+    protected void assertEmpty() {
+      assertThat(events).isEmpty();
+    }
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/pkgcache/TargetPatternEvaluatorIOTest.java b/src/test/java/com/google/devtools/build/lib/pkgcache/TargetPatternEvaluatorIOTest.java
new file mode 100644
index 0000000000..3b63fbe157
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/pkgcache/TargetPatternEvaluatorIOTest.java
@@ -0,0 +1,201 @@
+// Copyright 2015 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.pkgcache;
+
+import com.google.common.truth.Truth;
+import com.google.devtools.build.lib.util.BlazeClock;
+import com.google.devtools.build.lib.vfs.Dirent;
+import com.google.devtools.build.lib.vfs.FileStatus;
+import com.google.devtools.build.lib.vfs.FileSystem;
+import com.google.devtools.build.lib.vfs.FileSystemUtils;
+import com.google.devtools.build.lib.vfs.Path;
+import com.google.devtools.build.lib.vfs.PathFragment;
+import com.google.devtools.build.lib.vfs.inmemoryfs.InMemoryContentInfo;
+import com.google.devtools.build.lib.vfs.inmemoryfs.InMemoryFileSystem;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.IOException;
+import java.util.Collection;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.annotation.Nullable;
+
+/** TargetPatternEvaluator tests that require a custom filesystem. */
+@RunWith(JUnit4.class)
+public class TargetPatternEvaluatorIOTest extends AbstractTargetPatternEvaluatorTest {
+  private static final String FS_ROOT = "/fsg";
+
+  private static class Transformer {
+    @SuppressWarnings("unused")
+    @Nullable
+    public FileStatus stat(FileStatus stat, Path path, boolean followSymlinks) throws IOException {
+      return stat;
+    }
+
+    @SuppressWarnings("unused")
+    @Nullable
+    public Collection<Dirent> readdir(Collection<Dirent> readdir, Path path, boolean followSymlinks)
+        throws IOException {
+      return readdir;
+    }
+  }
+
+  private Transformer transformer = new Transformer();
+
+  @Override
+  protected FileSystem createFileSystem() {
+    return new InMemoryFileSystem(BlazeClock.instance(), new PathFragment(FS_ROOT)) {
+      @Override
+      public FileStatus stat(Path path, boolean followSymlinks) throws IOException {
+        FileStatus defaultResult = super.stat(path, followSymlinks);
+        return transformer.stat(defaultResult, path, followSymlinks);
+      }
+
+      @Override
+      protected Collection<Dirent> readdir(Path path, boolean followSymlinks) throws IOException {
+        Collection<Dirent> defaultResult = super.readdir(path, followSymlinks);
+        return transformer.readdir(defaultResult, path, followSymlinks);
+      }
+    };
+  }
+
+  /**
+   * Test that a child with an inconsistent stat (first a directory, then not) does not prevent
+   * evaluation of the remaining packages beneath a directory and the return of a partial result.
+   */
+  @Test
+  public void testBadStatKeepGoing() throws Exception {
+    reporter.removeHandler(failFastHandler);
+    // Given a package, "parent",
+    Path parent = scratch.file("parent/BUILD", "sh_library(name = 'parent')").getParentDirectory();
+    // And a child, "badstat",
+    FileSystemUtils.createDirectoryAndParents(parent.getRelative("badstat"));
+
+    // Such that badstat first reports that it is a directory, and then reports that it isn't,
+    this.transformer = createInconsistentFileStateTransformer("parent/badstat");
+
+    // When we find all the targets beneath parent in keep_going mode, we get the valid target
+    // parent:parent, even though processing badstat threw an InconsistentFilesystemException.
+    Truth.assertThat(parseListKeepGoing("//parent/...").getFirst())
+        .containsExactlyElementsIn(labels("//parent:parent"));
+  }
+
+  /**
+   * Test that a package subdirectory that throws an IOException when it is listed via readdir
+   * does not prevent evaluation of the remaining packages beneath a directory and the return of
+   * a partial result.
+   */
+  @Test
+  public void testBadReaddirKeepGoing() throws Exception {
+    reporter.removeHandler(failFastHandler);
+    // Given a package, "parent",
+    Path parent = scratch.file("parent/BUILD", "sh_library(name = 'parent')").getParentDirectory();
+    // And a child, "badstat",
+    FileSystemUtils.createDirectoryAndParents(parent.getRelative("badstat"));
+
+    // Such that badstat reports that it is a directory, but throws an error when its Dirents are
+    // collected,
+    this.transformer = createBadDirectoryListingTransformer("parent/badstat");
+
+    // When we find all the targets beneath parent in keep_going mode, we get the valid target
+    // parent:parent, even though processing badstat threw an InconsistentFilesystemException.
+    Truth.assertThat(parseListKeepGoing("//parent/...").getFirst())
+        .containsExactlyElementsIn(labels("//parent:parent"));
+  }
+
+  private Transformer createInconsistentFileStateTransformer(final String badPathSuffix) {
+    final AtomicBoolean isDirectory = new AtomicBoolean(true);
+    return new Transformer() {
+      @Nullable
+      @Override
+      public FileStatus stat(final FileStatus stat, Path path, boolean followSymlinks)
+          throws IOException {
+        if (path.getPathString().endsWith(badPathSuffix)) {
+          return new InMemoryContentInfo(BlazeClock.instance()) {
+            @Override
+            public boolean isDirectory() {
+              // Trigger inconsistent filesystem exception.
+              return isDirectory.getAndSet(false);
+            }
+
+            @Override
+            public boolean isFile() {
+              return stat.isFile();
+            }
+
+            @Override
+            public boolean isSpecialFile() {
+              return stat.isSpecialFile();
+            }
+
+            @Override
+            public boolean isSymbolicLink() {
+              return stat.isSymbolicLink();
+            }
+
+            @Override
+            public long getSize() throws IOException {
+              return stat.getSize();
+            }
+
+            @Override
+            public synchronized long getLastModifiedTime() {
+              try {
+                return stat.getLastModifiedTime();
+              } catch (IOException e) {
+                throw new IllegalStateException(e);
+              }
+            }
+
+            @Override
+            public synchronized long getLastChangeTime() {
+              try {
+                return stat.getLastChangeTime();
+              } catch (IOException e) {
+                throw new IllegalStateException(e);
+              }
+            }
+
+            @Override
+            public long getNodeId() {
+              try {
+                return stat.getNodeId();
+              } catch (IOException e) {
+                throw new IllegalStateException(e);
+              }
+            }
+          };
+        }
+        return stat;
+      }
+    };
+  }
+
+  private Transformer createBadDirectoryListingTransformer(final String badPathSuffix) {
+    return new Transformer() {
+      @Nullable
+      @Override
+      public Collection<Dirent> readdir(Collection<Dirent> readdir, Path path,
+          boolean followSymlinks) throws IOException {
+        if (path.getPathString().endsWith(badPathSuffix)) {
+          throw new IOException("Path ended in " + badPathSuffix + ", so readdir failed.");
+        }
+        return readdir;
+      }
+    };
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/pkgcache/TargetPatternEvaluatorTest.java b/src/test/java/com/google/devtools/build/lib/pkgcache/TargetPatternEvaluatorTest.java
new file mode 100644
index 0000000000..7197650ce3
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/pkgcache/TargetPatternEvaluatorTest.java
@@ -0,0 +1,1063 @@
+// Copyright 2015 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.pkgcache;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.devtools.build.lib.pkgcache.FilteringPolicies.FILTER_TESTS;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Sets;
+import com.google.devtools.build.lib.cmdline.Label;
+import com.google.devtools.build.lib.cmdline.PackageIdentifier;
+import com.google.devtools.build.lib.cmdline.ResolvedTargets;
+import com.google.devtools.build.lib.cmdline.TargetParsingException;
+import com.google.devtools.build.lib.cmdline.TargetPattern;
+import com.google.devtools.build.lib.packages.ImplicitOutputsFunction;
+import com.google.devtools.build.lib.packages.Target;
+import com.google.devtools.build.lib.util.Pair;
+import com.google.devtools.build.lib.vfs.ModifiedFileSet;
+import com.google.devtools.build.lib.vfs.Path;
+import com.google.devtools.build.lib.vfs.PathFragment;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.Arrays;
+import java.util.Set;
+
+/** Tests for {@link TargetPatternEvaluator}. */
+@RunWith(JUnit4.class)
+public class TargetPatternEvaluatorTest extends AbstractTargetPatternEvaluatorTest {
+  private PathFragment fooOffset;
+
+  private Set<Label> rulesBeneathFoo;
+  private Set<Label> rulesBeneathFooBar;
+  private Set<Label> rulesBeneathOtherrules;
+  private Set<Label> rulesInFoo;
+  private Set<Label> rulesInFooBar;
+  private Set<Label> rulesInOtherrules;
+  private Set<Label> targetsInFoo;
+  private Set<Label> targetsInFooBar;
+  private Set<Label> targetsBeneathFoo;
+  private Set<Label> targetsInOtherrules;
+
+  @Before
+  public final void createFiles() throws Exception {
+    // TODO(ulfjack): Also disable the implicit C++ outputs in Google's internal version.
+    boolean hasImplicitCcOutputs = ruleClassProvider.getRuleClassMap().get("cc_library")
+        .getImplicitOutputsFunction() != ImplicitOutputsFunction.NONE;
+
+    scratch.file("foo/BUILD",
+        "cc_library(name = 'foo1', srcs = [ 'foo1.cc' ], hdrs = [ 'foo1.h' ])",
+        "exports_files(['baz/bang'])");
+    scratch.file("foo/bar/BUILD",
+        "cc_library(name = 'bar1', alwayslink = 1)",
+        "cc_library(name = 'bar2')",
+        "exports_files(['wiz/bang', 'wiz/all', 'baz', 'baz/bang', 'undeclared.h'])");
+
+    // 'filegroup' and 'test_suite' are rules, but 'exports_files' is not.
+    scratch.file("otherrules/BUILD",
+        "test_suite(name = 'suite1')",
+        "filegroup(name='group', srcs=['suite/somefile'])",
+        "exports_files(['suite/somefile'])",
+        "cc_library(name = 'wiz', linkstatic = 1)");
+    scratch.file("nosuchpkg/subdir/empty", "");
+
+    Path foo = scratch.dir("foo");
+    fooOffset = foo.relativeTo(rootDirectory);
+
+    rulesBeneathFoo = labels("//foo:foo1", "//foo/bar:bar1", "//foo/bar:bar2");
+    rulesBeneathFooBar = labels("//foo/bar:bar1", "//foo/bar:bar2");
+    rulesBeneathOtherrules = labels(
+        "//otherrules:suite1", "//otherrules:wiz", "//otherrules:group");
+    rulesInFoo = labels("//foo:foo1");
+    rulesInFooBar = labels("//foo/bar:bar1", "//foo/bar:bar2");
+    rulesInOtherrules = rulesBeneathOtherrules;
+
+    targetsInFoo = labels(
+        "//foo:foo1",
+        "//foo:foo1",
+        "//foo:foo1.cc",
+        "//foo:foo1.h",
+        "//foo:BUILD",
+        "//foo:baz/bang");
+    if (hasImplicitCcOutputs) {
+      targetsInFoo.addAll(labels("//foo:libfoo1.a", "//foo:libfoo1.so"));
+    }
+    targetsInFooBar = labels(
+        "//foo/bar:bar1",
+        "//foo/bar:bar2",
+        "//foo/bar:BUILD",
+        "//foo/bar:wiz/bang",
+        "//foo/bar:wiz/all",
+        "//foo/bar:baz",
+        "//foo/bar:baz/bang",
+        "//foo/bar:undeclared.h");
+    if (hasImplicitCcOutputs) {
+      targetsInFooBar.addAll(labels("//foo/bar:libbar1.lo", "//foo/bar:libbar2.a"));
+    }
+    targetsBeneathFoo = Sets.newHashSet();
+    targetsBeneathFoo.addAll(targetsInFoo);
+    targetsBeneathFoo.addAll(targetsInFooBar);
+
+    targetsInOtherrules = labels(
+        "//otherrules:group",
+        "//otherrules:wiz",
+        "//otherrules:suite1",
+        "//otherrules:BUILD",
+        "//otherrules:suite/somefile",
+        "//otherrules:wiz",
+        "//otherrules:suite1");
+    if (hasImplicitCcOutputs) {
+      targetsInOtherrules.addAll(labels("//otherrules:libwiz.a"));
+    }
+  }
+
+  private void invalidate(String file) throws InterruptedException {
+    skyframeExecutor.invalidateFilesUnderPathForTesting(reporter,
+        ModifiedFileSet.builder().modify(new PathFragment(file)).build(), rootDirectory);
+  }
+
+  private void invalidate(ModifiedFileSet modifiedFileSet) throws InterruptedException {
+    skyframeExecutor.invalidateFilesUnderPathForTesting(reporter, modifiedFileSet, rootDirectory);
+  }
+
+  private void setDeletedPackages(Set<PackageIdentifier> deletedPackages) {
+    skyframeExecutor.setDeletedPackages(deletedPackages);
+  }
+
+  private TargetPatternEvaluator shiftOffset() {
+    parser.updateOffset(fooOffset);
+    return parser;
+  }
+
+  private Set<Label> parseList(String... patterns)
+      throws TargetParsingException, InterruptedException {
+    return targetsToLabels(
+        getFailFast(parseTargetPatternList(parser, parsingListener, Arrays.asList(patterns),
+            false)));
+  }
+
+  private Set<Label> parseListKeepGoingExpectFailure(String... patterns)
+      throws TargetParsingException, InterruptedException {
+    ResolvedTargets<Target> result =
+        parseTargetPatternList(parser, parsingListener, Arrays.asList(patterns), true);
+    assertTrue(result.hasError());
+    return targetsToLabels(result.getTargets());
+  }
+
+  private Set<Label> parseList(
+      FilteringPolicy policy, String... patterns)
+      throws TargetParsingException, InterruptedException {
+    return targetsToLabels(getFailFast(
+        parseTargetPatternList(parser, parsingListener, Arrays.asList(patterns), policy, false)));
+  }
+
+  private Set<Label> parseListRelative(String... patterns)
+      throws TargetParsingException, InterruptedException {
+    return targetsToLabels(getFailFast(parseTargetPatternList(
+        shiftOffset(), parsingListener, Arrays.asList(patterns), false)));
+  }
+
+  private static Set<Target> getFailFast(ResolvedTargets<Target> result) {
+    assertFalse(result.hasError());
+    return result.getTargets();
+  }
+
+  private void expectError(TargetPatternEvaluator parser, String expectedError,
+      String target) throws InterruptedException {
+    try {
+      parser.parseTargetPattern(parsingListener, target, false);
+      fail("target='" + target + "', expected error: " + expectedError);
+    } catch (TargetParsingException e) {
+      assertThat(e.getMessage()).contains(expectedError);
+    }
+  }
+
+  private void expectError(String expectedError, String target) throws InterruptedException {
+    expectError(parser, expectedError, target);
+  }
+
+  private void expectErrorRelative(String expectedError, String target)
+      throws InterruptedException {
+    expectError(shiftOffset(), expectedError, target);
+  }
+
+  private Label parseIndividualTarget(String targetLabel) throws Exception {
+    return Iterables.getOnlyElement(
+        getFailFast(parser.parseTargetPattern(parsingListener, targetLabel, false))).getLabel();
+  }
+
+  private Label parseIndividualTargetRelative(String targetLabel) throws Exception {
+    return Iterables.getOnlyElement(
+        getFailFast(
+            shiftOffset().parseTargetPattern(parsingListener, targetLabel, false))).getLabel();
+  }
+
+  @Test
+  public void testParsingStandardLabel() throws Exception {
+    assertEquals("//foo:foo1",
+        parseIndividualTarget("//foo:foo1").toString());
+  }
+
+  @Test
+  public void testAbsolutePatternEndsWithSlashAll() throws Exception {
+    scratch.file("foo/all/BUILD", "cc_library(name = 'all')");
+    assertEquals("//foo/all:all", parseIndividualTarget("//foo/all").toString());
+    assertNoEvents();
+  }
+
+  @Test
+  public void testWildcardConflict() throws Exception {
+    scratch.file("foo/lib/BUILD",
+        "cc_library(name = 'lib1')",
+        "cc_library(name = 'lib2')",
+        "cc_library(name = 'all-targets')",
+        "cc_library(name = 'all')");
+
+    assertWildcardConflict("//foo/lib:all", ":all");
+    eventCollector.clear();
+    assertWildcardConflict("//foo/lib:all-targets", ":all-targets");
+  }
+
+  private void assertWildcardConflict(String label, String suffix) throws Exception {
+    assertEquals(label, parseIndividualTarget(label).toString());
+    assertSame(1, eventCollector.count());
+    assertContainsEvent(String.format("The target pattern '%s' is ambiguous: '%s' is both "
+        + "a wildcard, and the name of an existing cc_library rule; "
+        + "using the latter interpretation", label, suffix));
+  }
+
+  @Test
+  public void testMissingPackage() throws Exception {
+    try {
+      parseIndividualTarget("//missing:foo1");
+      fail("TargetParsingException expected");
+    } catch (TargetParsingException e) {
+      assertThat(e.getMessage()).startsWith("no such package");
+    }
+  }
+
+  @Test
+  public void testParsingStandardLabelWithRelativeParser() throws Exception {
+    assertEquals("//foo:foo1", parseIndividualTargetRelative("//foo:foo1").toString());
+  }
+
+  @Test
+  public void testMissingLabel() throws Exception {
+    try {
+      parseIndividualTarget("//foo:missing");
+      fail("TargetParsingException expected");
+    } catch (TargetParsingException e) {
+      assertThat(e.getMessage()).startsWith("no such target");
+    }
+  }
+
+  @Test
+  public void testParsingStandardLabelShorthand() throws Exception {
+    assertEquals("//foo:foo1",
+                 parseIndividualTarget("foo:foo1").toString());
+  }
+
+  @Test
+  public void testParsingStandardLabelShorthandRelative() throws Exception {
+    assertEquals("//foo:foo1", parseIndividualTargetRelative(":foo1").toString());
+  }
+
+
+  @Test
+  public void testAbsolutePathCantBeParsed() throws Exception {
+    expectError("not a relative path or label: '/absolute/path'",
+        "/absolute/path");
+  }
+
+  @Test
+  public void testAbsolutePathCantBeParsedWithRelativeParser() throws Exception {
+    expectErrorRelative("not a relative path or label: '/absolute/path'", "/absolute/path");
+  }
+
+  @Test
+  public void testUnsupportedTargets() throws Exception {
+    String expectedError = "no such target '//foo:foo': target 'foo' not declared in package 'foo'"
+        + " defined by /workspace/foo/BUILD";
+    expectError(expectedError, "foo");
+    expectError("The package part of 'foo/' should not end in a slash", "foo/");
+  }
+
+  @Test
+  public void testModifiedBuildFile() throws Exception {
+    assertThat(parseList("foo:all")).containsExactlyElementsIn(rulesInFoo);
+    assertNoEvents();
+
+    scratch.overwriteFile("foo/BUILD",
+        "cc_library(name = 'foo1', srcs = [ 'foo1.cc' ], hdrs = [ 'foo1.h' ])",
+        "cc_library(name = 'foo2', srcs = [ 'foo1.cc' ], hdrs = [ 'foo1.h' ])");
+    invalidate("foo/BUILD");
+    assertThat(parseList("foo:all")).containsExactlyElementsIn(labels("//foo:foo1", "//foo:foo2"));
+  }
+
+  @Test
+  public void testParserOffsetUpdated() throws Exception {
+    scratch.file("nest/BUILD",
+        "cc_library(name = 'nested1', srcs = [ ])");
+    scratch.file("nest/nest/BUILD",
+        "cc_library(name = 'nested2', srcs = [ ])");
+
+    updateOffset(new PathFragment("nest"));
+    assertThat(parseList(":all")).containsExactlyElementsIn(labels("//nest:nested1"));
+    updateOffset(new PathFragment("nest/nest"));
+    assertThat(parseList(":all")).containsExactlyElementsIn(labels("//nest/nest:nested2"));
+  }
+
+  protected void updateOffset(PathFragment rel) {
+    parser.updateOffset(rel);
+  }
+
+  private void runFindTargetsInPackage(String suffix) throws Exception {
+    // 'my_package:all'
+    assertThat(parseList("foo" + suffix)).containsExactlyElementsIn(rulesInFoo);
+    assertThat(parseList("foo/bar" + suffix)).containsExactlyElementsIn(rulesInFooBar);
+    assertThat(parseList("otherrules" + suffix)).containsExactlyElementsIn(rulesInOtherrules);
+    assertNoEvents();
+    String msg1 = "while parsing 'nosuchpkg" + suffix + "': no such package 'nosuchpkg': "
+        + "BUILD file not found on package path";
+    expectError(msg1, "nosuchpkg" + suffix);
+
+    String msg2 = "while parsing 'nosuchdirectory" + suffix
+        + "': no such package 'nosuchdirectory': "
+        + "BUILD file not found on package path";
+    expectError(msg2, "nosuchdirectory" + suffix);
+    assertThat(parsingListener.events).containsExactly(Pair.of("nosuchpkg" + suffix, msg1),
+        Pair.of("nosuchdirectory" + suffix, msg2));
+  }
+
+  private void runFindTargetsInPackageAbsolute(String suffix) throws Exception {
+    // '//my_package:all'
+    assertThat(parseList("//foo" + suffix)).containsExactlyElementsIn(rulesInFoo);
+    assertThat(parseList("//foo/bar" + suffix)).containsExactlyElementsIn(rulesInFooBar);
+    assertThat(parseList("//otherrules" + suffix)).containsExactlyElementsIn(rulesInOtherrules);
+    assertNoEvents();
+    expectError("while parsing 'nosuchpkg" + suffix + "': no such package 'nosuchpkg': "
+            + "BUILD file not found on package path",
+        "nosuchpkg" + suffix);
+    expectError("while parsing '//nosuchpkg" + suffix + "': no such package 'nosuchpkg': "
+            + "BUILD file not found on package path",
+        "//nosuchpkg" + suffix);
+  }
+
+  @Test
+  public void testFindRulesInPackage() throws Exception {
+    runFindTargetsInPackage(":all");
+    runFindTargetsInPackageAbsolute(":all");
+  }
+
+  private void runFindRulesRecursively(String suffix) throws Exception {
+    assertThat(parseList("foo" + suffix)).containsExactlyElementsIn(rulesBeneathFoo);
+    assertThat(parseList("//foo" + suffix)).containsExactlyElementsIn(rulesBeneathFoo);
+    assertThat(parseList("//foo/bar" + suffix)).containsExactlyElementsIn(rulesBeneathFooBar);
+    assertThat(parseList("//foo" + suffix)).containsExactlyElementsIn(rulesBeneathFoo);
+    assertThat(parseList("otherrules" + suffix)).containsExactlyElementsIn(rulesBeneathOtherrules);
+    assertThat(parseList("//foo" + suffix)).containsExactlyElementsIn(rulesBeneathFoo);
+    assertNoEvents();
+    eventCollector.clear();
+  }
+
+  @Test
+  public void testNoTargetsFoundRecursiveDirectory() throws Exception {
+    try {
+      parseList("nosuchpkg/...");
+      fail();
+    } catch (TargetParsingException e) {
+      assertThat(e).hasMessage("no targets found beneath 'nosuchpkg'");
+    }
+  }
+
+  @Test
+  public void testFindRulesRecursively() throws Exception {
+    runFindRulesRecursively("/...:all");
+    runFindRulesRecursively("/...");
+  }
+
+  private void runFindAllRules(String pattern) throws Exception {
+    assertThat(parseList(pattern))
+        .containsExactlyElementsIn(Sets.union(rulesBeneathFoo, rulesBeneathOtherrules));
+    assertNoEvents();
+    eventCollector.clear();
+  }
+
+  @Test
+  public void testFindAllRules() throws Exception {
+    runFindAllRules("//...:all");
+    runFindAllRules("//...");
+    runFindAllRules("...");
+  }
+
+  private void runFindAllTargets(String pattern) throws Exception {
+    assertThat(parseList(pattern))
+        .containsExactlyElementsIn(Sets.union(targetsBeneathFoo, targetsInOtherrules));
+    assertNoEvents();
+    eventCollector.clear();
+  }
+
+  @Test
+  public void testFindAllTargets() throws Exception {
+    runFindAllTargets("//...:all-targets");
+    runFindAllTargets("//...:*");
+    runFindAllTargets("...:*");
+  }
+
+  @Test
+  public void testFindAllRulesRecursivelyWithExperimental() throws Exception {
+    scratch.file("experimental/BUILD",
+        "cc_library(name = 'experimental', srcs = [ 'experimental.cc' ])");
+    assertThat(parseList("//..."))
+        .containsExactlyElementsIn(Sets.union(rulesBeneathFoo, rulesBeneathOtherrules));
+    assertNoEvents();
+  }
+
+  @Test
+  public void testFindAllRulesRecursivelyExperimental() throws Exception {
+    scratch.file("experimental/BUILD",
+        "cc_library(name = 'experimental', srcs = [ 'experimental.cc' ])");
+    assertThat(parseList("//experimental/..."))
+        .containsExactlyElementsIn(labels("//experimental:experimental"));
+    assertNoEvents();
+  }
+
+  @Test
+  public void testDefaultPackage() throws Exception {
+    scratch.file("experimental/BUILD",
+                "cc_library(name = 'experimental', srcs = [ 'experimental.cc' ])");
+    assertEquals("//experimental:experimental", parseIndividualTarget("//experimental").toString());
+    assertEquals("//experimental:experimental", parseIndividualTarget("experimental").toString());
+    assertNoEvents();
+  }
+
+  /**
+   * Test that the relative path label parsing behaves as stated in the target-syntax documentation.
+   */
+  @Test
+  public void testRelativePathLabel() throws Exception {
+    scratch.file("sub/BUILD", "exports_files(['dir2/dir2'])");
+    scratch.file("sub/dir/BUILD", "exports_files(['dir2'])");
+    scratch.file("sub/dir/dir/BUILD", "exports_files(['dir'])");
+    // sub/dir/dir is a package
+    assertEquals("//sub/dir/dir:dir", parseIndividualTarget("sub/dir/dir").toString());
+    // sub/dir is a package but not sub/dir/dir2
+    assertEquals("//sub/dir:dir2", parseIndividualTarget("sub/dir/dir2").toString());
+    // sub is a package but not sub/dir2
+    assertEquals("//sub:dir2/dir2", parseIndividualTarget("sub/dir2/dir2").toString());
+  }
+
+  @Test
+  public void testFindsLongestPlausiblePackageName() throws Exception {
+    assertEquals("//foo/bar:baz",
+                 parseIndividualTarget("foo/bar/baz").toString());
+    assertEquals("//foo/bar:baz/bang",
+                 parseIndividualTarget("foo/bar/baz/bang").toString());
+    assertEquals("//foo:baz/bang",
+        parseIndividualTarget("foo/baz/bang").toString());
+  }
+
+  @Test
+  public void testGivesUpIfPackageDoesNotExist() throws Exception {
+    expectError("couldn't determine target from filename 'does/not/exist'",
+        "does/not/exist");
+  }
+
+  @Test
+  public void testParsesIterableOfLabels() throws Exception {
+    Set<Label> labels = Sets.newHashSet(Label.parseAbsolute("//foo/bar:bar1"),
+        Label.parseAbsolute("//foo:foo1"));
+    assertEquals(labels, parseList("//foo/bar:bar1", "//foo:foo1"));
+    parsingListener.assertEmpty();
+  }
+
+  @Test
+  public void testParseAbsoluteWithRelativeParser() throws Exception {
+    Set<Label> labels = Sets.newHashSet(Label.parseAbsolute("//foo/bar:bar1"),
+        Label.parseAbsolute("//foo:foo1"));
+    assertEquals(labels, parseListRelative("//foo/bar:bar1", "//foo:foo1"));
+    parsingListener.assertEmpty();
+  }
+
+  @Test
+  public void testMultisegmentLabelsWithNoSlashSlash() throws Exception {
+    assertEquals("//foo/bar:wiz/bang",
+        parseIndividualTarget("foo/bar:wiz/bang").toString());
+    assertEquals("//foo/bar:wiz/all",
+        parseIndividualTarget("foo/bar:wiz/all").toString());
+  }
+
+  @Test
+  public void testMultisegmentLabelsWithNoSlashSlashRelative() throws Exception {
+    assertEquals("//foo/bar:wiz/bang",
+        parseIndividualTargetRelative("bar:wiz/bang").toString());
+    assertEquals("//foo/bar:wiz/all",
+        parseIndividualTargetRelative("bar:wiz/all").toString());
+  }
+
+  @Test
+  public void testAll() throws Exception {
+    expectError("couldn't determine target from filename 'all'", "all");
+  }
+
+  /** Regression test for a bug. */
+  @Test
+  public void testDotDotDotDoesntMatchDeletedPackages() throws Exception {
+    scratch.file("x/y/BUILD", "cc_library(name='y')");
+    scratch.file("x/z/BUILD", "cc_library(name='z')");
+    setDeletedPackages(Sets.newHashSet(PackageIdentifier.createInDefaultRepo("x/y")));
+    assertEquals(Sets.newHashSet(Label.parseAbsolute("//x/z")),
+        parseList("x/..."));
+  }
+
+  @Test
+  public void testDotDotDotDoesntMatchDeletedPackagesRelative() throws Exception {
+    scratch.file("x/y/BUILD", "cc_library(name='y')");
+    scratch.file("x/z/BUILD", "cc_library(name='z')");
+    setDeletedPackages(Sets.newHashSet(PackageIdentifier.createInDefaultRepo("x/y")));
+
+    parser.updateOffset(new PathFragment("x"));
+    assertEquals(Sets.newHashSet(Label.parseAbsolute("//x/z")),
+        targetsToLabels(getFailFast(parser.parseTargetPattern(parsingListener, "...", false))));
+  }
+
+  @Test
+  public void testDeletedPackagesIncrementality() throws Exception {
+    scratch.file("x/y/BUILD", "cc_library(name='y')");
+    scratch.file("x/z/BUILD", "cc_library(name='z')");
+
+    assertEquals(Sets.newHashSet(Label.parseAbsolute("//x/y"), Label.parseAbsolute("//x/z")),
+        parseList("x/..."));
+
+    setDeletedPackages(Sets.newHashSet(PackageIdentifier.createInDefaultRepo("x/y")));
+    assertEquals(Sets.newHashSet(Label.parseAbsolute("//x/z")), parseList("x/..."));
+
+    setDeletedPackages(ImmutableSet.<PackageIdentifier>of());
+    assertEquals(Sets.newHashSet(Label.parseAbsolute("//x/y"), Label.parseAbsolute("//x/z")),
+        parseList("x/..."));
+  }
+
+  @Test
+  public void testSequenceOfTargetPatterns_Union() throws Exception {
+    // No prefix negation operator => union.  Order is not significant.
+    assertThat(parseList("foo/...", "foo/bar/...")).containsExactlyElementsIn(rulesBeneathFoo);
+    assertThat(parseList("foo/bar/...", "foo/...")).containsExactlyElementsIn(rulesBeneathFoo);
+  }
+
+  @Test
+  public void testSequenceOfTargetPatterns_UnionRelative() throws Exception {
+    // No prefix negation operator => union.  Order is not significant.
+    assertThat(parseListRelative("...", "bar/...")).containsExactlyElementsIn(rulesBeneathFoo);
+    assertThat(parseListRelative("bar/...", "...")).containsExactlyElementsIn(rulesBeneathFoo);
+  }
+
+  @Test
+  public void testSequenceOfTargetPatterns_SetDifference() throws Exception {
+    // Prefix negation operator => set difference.  Order is significant.
+    assertThat(parseList("foo/...", "-foo/bar/...")).containsExactlyElementsIn(rulesInFoo);
+    assertThat(parseList("-foo/bar/...", "foo/...")).containsExactlyElementsIn(rulesBeneathFoo);
+  }
+
+  @Test
+  public void testSequenceOfTargetPatterns_SetDifferenceRelative() throws Exception {
+    // Prefix negation operator => set difference.  Order is significant.
+    assertThat(parseListRelative("...", "-bar/...")).containsExactlyElementsIn(rulesInFoo);
+    assertThat(parseListRelative("-bar/...", "...")).containsExactlyElementsIn(rulesBeneathFoo);
+  }
+
+  @Test
+  public void testAllTargetsWildcard() throws Exception {
+    assertThat(parseList("foo:all-targets")).containsExactlyElementsIn(targetsInFoo);
+    assertThat(parseList("foo/bar:all-targets")).containsExactlyElementsIn(targetsInFooBar);
+    assertThat(parseList("otherrules:all-targets")).containsExactlyElementsIn(targetsInOtherrules);
+    assertThat(parseList("foo/...:all-targets")).containsExactlyElementsIn(targetsBeneathFoo);
+
+    assertThat(parseList("foo:*")).containsExactlyElementsIn(targetsInFoo);
+    assertThat(parseList("foo/bar:*")).containsExactlyElementsIn(targetsInFooBar);
+    assertThat(parseList("otherrules:*")).containsExactlyElementsIn(targetsInOtherrules);
+    assertThat(parseList("foo/...:*")).containsExactlyElementsIn(targetsBeneathFoo);
+  }
+
+  @Test
+  public void testAllTargetsWildcardRelative() throws Exception {
+    assertThat(parseListRelative(":all-targets")).containsExactlyElementsIn(targetsInFoo);
+    assertThat(parseListRelative("//foo:all-targets")).containsExactlyElementsIn(targetsInFoo);
+    assertThat(parseListRelative("bar:all-targets")).containsExactlyElementsIn(targetsInFooBar);
+    assertThat(parseListRelative("//foo/bar:all-targets"))
+        .containsExactlyElementsIn(targetsInFooBar);
+    assertThat(parseListRelative("...:all-targets")).containsExactlyElementsIn(targetsBeneathFoo);
+    assertThat(parseListRelative("//foo/...:all-targets"))
+        .containsExactlyElementsIn(targetsBeneathFoo);
+
+    assertThat(parseListRelative(":*")).containsExactlyElementsIn(targetsInFoo);
+    assertThat(parseListRelative("//foo:*")).containsExactlyElementsIn(targetsInFoo);
+    assertThat(parseListRelative("bar:*")).containsExactlyElementsIn(targetsInFooBar);
+    assertThat(parseListRelative("//foo/bar:*")).containsExactlyElementsIn(targetsInFooBar);
+    assertThat(parseListRelative("...:*")).containsExactlyElementsIn(targetsBeneathFoo);
+    assertThat(parseListRelative("//foo/...:*")).containsExactlyElementsIn(targetsBeneathFoo);
+  }
+
+  @Test
+  public void testFactoryMethod() throws Exception {
+    Path workspace = scratch.dir("/client/workspace");
+    Path underWorkspace = scratch.dir("/client/workspace/foo");
+    Path notUnderWorkspace = scratch.dir("/client/otherclient");
+
+    updateOffset(workspace, underWorkspace);
+    updateOffset(workspace, workspace);
+
+    // The client must be equal to or underneath the workspace.
+    try {
+      updateOffset(workspace, notUnderWorkspace);
+      fail("Should have failed because client was not underneath the workspace");
+    } catch (IllegalArgumentException expected) {
+    }
+  }
+
+  private void updateOffset(Path workspace, Path workingDir) {
+    parser.updateOffset(workingDir.relativeTo(workspace));
+  }
+
+  private void setupSubDirectoryCircularSymlink() throws Exception {
+    Path parent = scratch.file("parent/BUILD", "sh_library(name = 'parent')").getParentDirectory();
+    Path child = parent.getRelative("child");
+    child.createDirectory();
+    Path badBuild = child.getRelative("BUILD");
+    badBuild.createSymbolicLink(badBuild);
+    reporter.removeHandler(failFastHandler);
+  }
+
+  @Test
+  public void testSubdirectoryCircularSymlinkKeepGoing() throws Exception {
+    setupSubDirectoryCircularSymlink();
+    assertThat(parseListKeepGoing("//parent/...").getFirst())
+        .containsExactlyElementsIn(labels("//parent:parent"));
+  }
+
+  @Test
+  public void testSubdirectoryCircularSymlinkNoKeepGoing() throws Exception {
+    setupSubDirectoryCircularSymlink();
+    try {
+      parseList("//parent/...");
+      fail();
+    } catch (TargetParsingException e) {
+      // Expected.
+    }
+  }
+
+  /** Regression test for bug: "Bogus 'helpful' error message" */
+  @Test
+  public void testHelpfulMessageForFileOutsideOfAnyPackage() throws Exception {
+    scratch.file("goo/wiz/file");
+    expectError("couldn't determine target from filename 'goo/wiz/file'",
+                "goo/wiz/file");
+    expectError("couldn't determine target from filename 'goo/wiz'",
+        "goo/wiz");
+  }
+
+  /** Regression test for bug: "Bogus 'helpful' error message" */
+  @Test
+  public void testHelpfulMessageForDirectoryWhichIsASubdirectoryOfAPackage() throws Exception {
+    scratch.file("bar/BUILD");
+    scratch.file("bar/quux/somefile");
+    expectError("no such target '//bar:quux': target 'quux' not declared in package 'bar'; "
+            + "however, a source directory of this name exists.  (Perhaps add "
+            + "'exports_files([\"quux\"])' to bar/BUILD, or define a filegroup?) defined by "
+            + "/workspace/bar/BUILD",
+        "bar/quux");
+  }
+
+  /** Regression test for bug: "Uplevel references in blaze target patterns cause crash" */
+  @Test
+  public void testNoCrashWhenUplevelReferencesUsed() throws Exception {
+    scratch.file("/other/workspace/project/BUILD");
+    expectError(
+        "Invalid package name '../other/workspace/project': ",
+        "../other/workspace/project/...:all");
+    expectError(
+        "Invalid package name '../other/workspace/project': ", "../other/workspace/project/...");
+    expectError(
+        "Invalid package name 'foo/../../other/workspace/project': ",
+        "foo/../../other/workspace/project/...");
+    expectError(
+        "Invalid package name '../other/workspace/project': ", "../other/workspace/project:all");
+  }
+
+  @Test
+  public void testPassingValidations() {
+    expectValidationPass("foo:bar");
+    expectValidationPass("foo:all");
+    expectValidationPass("foo/...:all");
+    expectValidationPass("foo:*");
+
+    expectValidationPass("//foo");
+    expectValidationPass("foo");
+    expectValidationPass("foo/bar");
+    expectValidationPass("//foo:bar");
+    expectValidationPass("//foo:all");
+
+    expectValidationPass("//foo/all");
+    expectValidationPass("java/com/google/foo/Bar.java");
+    expectValidationPass("//foo/...:all");
+  }
+
+  @Test
+  public void testFailingValidations() {
+    expectValidationFail("");
+    expectValidationFail("\\");
+    expectValidationFail("foo:**");
+    expectValidationFail("//foo/*");
+  }
+
+  private void expectValidationFail(String target) {
+    try {
+      TargetPattern.defaultParser().parse(target);
+      fail("TargetParsingException expected from parse(" + target + ")");
+    } catch (TargetParsingException expected) {
+      /* ignore */
+    }
+
+    // Ensure that validateTargetPattern's checking is strictly weaker than
+    // that of parseTargetPattern.
+    try {
+      parser.parseTargetPattern(parsingListener, target, false);
+      fail("parseTargetPattern(" + target + ") inconsistent with parseTargetPattern!");
+    } catch (TargetParsingException expected) {
+      /* ignore */
+    } catch (InterruptedException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  private void expectValidationPass(String target) {
+    try {
+      TargetPattern.defaultParser().parse(target);
+    } catch (TargetParsingException e) {
+      fail("Expected " + target + " to pass; got exception: " + e);
+    }
+  }
+
+  @Test
+  public void testSetOffset() throws Exception {
+    assertEquals("//foo:foo1", parseIndividualTarget("foo:foo1").toString());
+
+    parser.updateOffset(new PathFragment("foo"));
+    assertEquals("//foo:foo1", parseIndividualTarget(":foo1").toString());
+  }
+
+  @Test
+  public void testTestTargetParsing() throws Exception {
+    scratch.file("test/BUILD",
+        "cc_library(name = 'bar1', alwayslink = 1)",
+        "cc_library(name = 'bar2')",
+        "cc_test(name = 'test1', deps = ['bar1'], tags = ['local'])",
+        "cc_test(name = 'test2', deps = ['bar2'], tags = ['local'])",
+        "py_test(name = 'manual_test', tags = ['exclusive', 'manual'], srcs=['py_test.py'])",
+        "test_suite(name = 'suite1')");
+
+    Set<Label> testRules = labels("//test:test1", "//test:test2");
+    Set<Label> allTestRules =
+      labels("//test:test1", "//test:test2", "//test:manual_test");
+    assertThat(parseList(FILTER_TESTS, "test/...")).containsExactlyElementsIn(testRules);
+    assertThat(parseList(FILTER_TESTS, "test:all")).containsExactlyElementsIn(testRules);
+    assertThat(parseList(FILTER_TESTS, "test:*")).containsExactlyElementsIn(testRules);
+    assertThat(parseList(FILTER_TESTS, "test:test1", "test/test2", "//test:suite1"))
+        .containsExactlyElementsIn(testRules);
+    assertThat(parseList(FILTER_TESTS, "test:all", "//test:manual_test"))
+        .containsExactlyElementsIn(allTestRules);
+    assertThat(parseList(FILTER_TESTS, "test:all", "test/manual_test"))
+        .containsExactlyElementsIn(allTestRules);
+  }
+
+  /** Regression test for bug: "blaze test "no targets found" warning now fatal" */
+  @Test
+  public void testNoTestsInRecursivePattern() throws Exception {
+    assertThat(parseList(FILTER_TESTS, "foo/..."))
+        .containsExactlyElementsIn(labels()); // doesn't throw
+  }
+
+  @Test
+  public void testKeepGoingBadPackage() throws Exception {
+    assertKeepGoing(rulesBeneathFoo,
+        "Skipping '//missing_pkg': no such package 'missing_pkg': "
+            + "BUILD file not found on package path",
+        "//missing_pkg", "foo/...");
+  }
+
+  @Test
+  public void testKeepGoingPartiallyBadPackage() throws Exception {
+    scratch.file("x/y/BUILD",
+        "filegroup(name = 'a')",
+        "BROKEN",
+        "filegroup(name = 'b')");
+
+    reporter.removeHandler(failFastHandler);
+    Pair<Set<Label>, Boolean> result = parseListKeepGoing("//x/...");
+
+    assertContainsEvent("name 'BROKEN' is not defined");
+    assertThat(result.first)
+        .containsExactlyElementsIn(
+            Sets.newHashSet(Label.parseAbsolute("//x/y:a"), Label.parseAbsolute("//x/y:b")));
+    assertFalse(result.second);
+  }
+
+  @Test
+  public void testKeepGoingMissingRecursiveDirectory() throws Exception {
+    assertKeepGoing(rulesBeneathFoo,
+        "Skipping 'nosuchpkg/...': no targets found beneath 'nosuchpkg'",
+        "nosuchpkg/...", "foo/...");
+    eventCollector.clear();
+    assertKeepGoing(rulesBeneathFoo,
+        "Skipping 'nosuchdirectory/...': no targets found beneath 'nosuchdirectory'",
+        "nosuchdirectory/...", "foo/...");
+  }
+
+  @Test
+  public void testKeepGoingMissingTarget() throws Exception {
+    assertKeepGoing(rulesBeneathFoo,
+        "Skipping '//otherrules:missing_target': no such target "
+            + "'//otherrules:missing_target': target 'missing_target' not declared in "
+            + "package 'otherrules'",
+        "//otherrules:missing_target", "foo/...");
+  }
+
+  @Test
+  public void testKeepGoingOnAllRulesBeneath() throws Exception {
+    scratch.file("foo/bar/bad/BUILD", "invalid build file");
+
+    reporter.removeHandler(failFastHandler);
+    Pair<Set<Label>, Boolean> result = parseListKeepGoing("foo/...");
+    assertThat(result.first).containsExactlyElementsIn(rulesBeneathFoo);
+    assertContainsEvent("syntax error at 'build'");
+    assertContainsEvent("package contains errors");
+    reporter.addHandler(failFastHandler);
+
+    // Even though there was a loading error in the package, parsing the target pattern was
+    // successful.
+    assertFalse(result.second);
+  }
+
+  @Test
+  public void testKeepGoingBadFilenameTarget() throws Exception {
+    assertKeepGoing(rulesBeneathFoo,
+        "couldn't determine target from filename 'bad/filename/target'",
+        "bad/filename/target", "foo/...");
+  }
+
+  @Test
+  public void testMoreThanOneBadPatternFailFast() throws Exception {
+    try {
+      parseTargetPatternList(parser, parsingListener,
+          ImmutableList.of("bad/filename/target", "other/bad/filename/target"),
+          /*keepGoing=*/false);
+      fail();
+    } catch (TargetParsingException e) {
+      assertThat(e.getMessage()).contains("couldn't determine target from filename");
+    }
+  }
+
+  @Test
+  public void testMentioningBuildFile() throws Exception {
+    ResolvedTargets<Target> result = parseTargetPatternList(parser, parsingListener,
+        Arrays.asList("//foo/bar/BUILD"), false);
+
+    assertFalse(result.hasError());
+    assertThat(result.getTargets()).hasSize(1);
+
+    Label label = Iterables.getOnlyElement(result.getTargets()).getLabel();
+    assertEquals("BUILD", label.getName());
+    assertEquals("foo/bar", label.getPackageName());
+
+  }
+
+  /**
+   * Regression test for bug: '"Target pattern parsing failed. Continuing anyway" appears, even
+   * without --keep_going'
+   */
+  @Test
+  public void testLoadingErrorsAreNotParsingErrors() throws Exception {
+    reporter.removeHandler(failFastHandler);
+    scratch.file("loading/BUILD",
+        "cc_library(name='y', deps=['a'])",
+        "cc_library(name='a', deps=['b'])",
+        "cc_library(name='b', deps=['c'])",
+        "genrule(name='c', outs=['c.out'])");
+
+    Pair<Set<Label>, Boolean> result = parseListKeepGoing("//loading:y");
+    assertEquals(Label.parseAbsolute("//loading:y"), Iterables.getOnlyElement(result.first));
+    assertContainsEvent("missing value for mandatory attribute");
+    assertFalse(result.second);
+  }
+
+  private void assertKeepGoing(Set<Label> expectedLabels, String expectedEvent, String... toParse)
+      throws Exception {
+    reporter.removeHandler(failFastHandler);
+    assertThat(parseListKeepGoingExpectFailure(toParse)).containsExactlyElementsIn(expectedLabels);
+    assertContainsEvent(expectedEvent);
+    reporter.addHandler(failFastHandler);
+  }
+
+  /** Regression test for bug: "IllegalStateException in BuildTool.prepareToBuild()" */
+  @Test
+  public void testTestingIsSubset() throws Exception {
+    scratch.file("test/BUILD",
+        "cc_library(name = 'bar1')",
+        "cc_test(name = 'test', deps = [':bar1'], tags = ['manual'])");
+
+    assertThat(parseList(FILTER_TESTS, "//test:test", "-//test:all"))
+        .containsExactlyElementsIn(labels());
+  }
+
+  @Test
+  public void testAddedPkg() throws Exception {
+    invalidate(ModifiedFileSet.EVERYTHING_MODIFIED);
+    scratch.dir("h/i/j/k/BUILD");
+    scratch.file("h/BUILD", "sh_library(name='h')");
+    assertThat(parseList("//h/...")).containsExactlyElementsIn(labels("//h"));
+
+    scratch.file("h/i/j/BUILD", "sh_library(name='j')");
+
+    // Modifications not yet known.
+    assertThat(parseList("//h/...")).containsExactlyElementsIn(labels("//h"));
+
+    ModifiedFileSet modifiedFileSet = ModifiedFileSet.builder()
+        .modify(new PathFragment("h/i/j/BUILD")).build();
+    invalidate(modifiedFileSet);
+
+    assertThat(parseList("//h/...")).containsExactly(Label.parseAbsolute("//h/i/j:j"),
+        Label.parseAbsolute("//h"));
+  }
+
+  @Test
+  public void testAddedFilesAndDotDotDot() throws Exception {
+    invalidate(ModifiedFileSet.EVERYTHING_MODIFIED);
+    reporter.removeHandler(failFastHandler);
+    scratch.dir("h");
+    try {
+      parseList("//h/...");
+      fail("TargetParsingException expected");
+    } catch (TargetParsingException e) {
+      // expected
+    }
+
+    scratch.file("h/i/j/k/BUILD", "sh_library(name='l')");
+    ModifiedFileSet modifiedFileSet = ModifiedFileSet.builder()
+        .modify(new PathFragment("h"))
+        .modify(new PathFragment("h/i"))
+        .modify(new PathFragment("h/i/j"))
+        .modify(new PathFragment("h/i/j/k"))
+        .modify(new PathFragment("h/i/j/k/BUILD"))
+        .build();
+    invalidate(modifiedFileSet);
+    reporter.addHandler(failFastHandler);
+    Set<Label> nonEmptyResult = parseList("//h/...");
+    assertThat(nonEmptyResult).containsExactly(Label.parseAbsolute("//h/i/j/k:l"));
+  }
+
+  @Test
+  public void testBrokenSymlinkRepaired() throws Exception {
+    reporter.removeHandler(failFastHandler);
+    Path tuv = scratch.dir("t/u/v");
+    tuv.getChild("BUILD").createSymbolicLink(new PathFragment("../../BUILD"));
+
+    try {
+      parseList("//t/...");
+      fail("TargetParsingException expected");
+    } catch (TargetParsingException e) {
+      // expected
+    }
+
+    scratch.file("t/BUILD", "sh_library(name='t')");
+    ModifiedFileSet modifiedFileSet = ModifiedFileSet.builder()
+        .modify(new PathFragment("t/BUILD"))
+        .build();
+
+    invalidate(modifiedFileSet);
+    reporter.addHandler(failFastHandler);
+    Set<Label> result = parseList("//t/...");
+
+    assertThat(result).containsExactly(Label.parseAbsolute("//t:t"),
+        Label.parseAbsolute("//t/u/v:t"));
+  }
+
+  @Test
+  public void testInfiniteTreeFromSymlinks() throws Exception {
+    reporter.removeHandler(failFastHandler);
+    Path ab = scratch.dir("a/b");
+    ab.getChild("c").createSymbolicLink(new PathFragment("../b"));
+    scratch.file("a/b/BUILD", "filegroup(name='g')");
+    ResolvedTargets<Target> result = parseTargetPatternList(parser, parsingListener,
+        ImmutableList.of("//a/b/..."), true);
+    assertThat(targetsToLabels(result.getTargets())).containsExactly(
+        Label.parseAbsolute("//a/b:g"));
+  }
+
+  @Test
+  public void testSymlinkCycle() throws Exception {
+    reporter.removeHandler(failFastHandler);
+    Path ab = scratch.dir("a/b");
+    ab.getChild("c").createSymbolicLink(new PathFragment("c"));
+    scratch.file("a/b/BUILD", "filegroup(name='g')");
+    ResolvedTargets<Target> result = parseTargetPatternList(parser, parsingListener,
+        ImmutableList.of("//a/b/..."), true);
+    assertThat(targetsToLabels(result.getTargets())).contains(
+        Label.parseAbsolute("//a/b:g"));
+  }
+
+  @Test
+  public void testPerDirectorySymlinkTraversalOptOut() throws Exception {
+    scratch.dir("from-b");
+    scratch.file("from-b/BUILD", "filegroup(name = 'from-b')");
+    scratch.dir("from-c");
+    scratch.file("from-c/BUILD", "filegroup(name = 'from-c')");
+    Path ab = scratch.dir("a/b");
+    ab.getChild("symlink").createSymbolicLink(new PathFragment("../../from-b"));
+    scratch.dir("a/b/not-a-symlink");
+    scratch.file("a/b/not-a-symlink/BUILD", "filegroup(name = 'not-a-symlink')");
+    scratch.file(
+        "a/b/DONT_FOLLOW_SYMLINKS_WHEN_TRAVERSING_THIS_DIRECTORY_VIA_A_RECURSIVE_TARGET_PATTERN");
+    Path ac = scratch.dir("a/c");
+    ac.getChild("symlink").createSymbolicLink(new PathFragment("../../from-c"));
+    ResolvedTargets<Target> result = parseTargetPatternList(parser, parsingListener,
+        ImmutableList.of("//a/..."), true);
+    assertThat(targetsToLabels(result.getTargets())).containsExactly(
+        Label.parseAbsolute("//a/c/symlink:from-c"),
+        Label.parseAbsolute("//a/b/not-a-symlink:not-a-symlink"));
+  }
+
+  @Test
+  public void testDoesNotRecurseIntoSymlinksToOutputBase() throws Exception {
+    Path outputBaseBuildFile = outputBase.getRelative("workspace/test/BUILD");
+    scratch.file(outputBaseBuildFile.getPathString(), "filegroup(name='c')");
+    PathFragment targetFragment = outputBase.asFragment().getRelative("workspace/test");
+    Path d = scratch.dir("d");
+    d.getChild("c").createSymbolicLink(targetFragment);
+    rootDirectory.getChild("convenience").createSymbolicLink(targetFragment);
+    Set<Label> result = parseList("//...");
+    assertThat(result).doesNotContain(Label.parseAbsolute("//convenience:c"));
+    assertThat(result).doesNotContain(Label.parseAbsolute("//d/c:c"));
+  }
+}
+