diff --git a/src/main/java/com/google/devtools/build/lib/cmdline/TargetPattern.java b/src/main/java/com/google/devtools/build/lib/cmdline/TargetPattern.java index 1d623bb19c1fd7..d034efdb960f1f 100644 --- a/src/main/java/com/google/devtools/build/lib/cmdline/TargetPattern.java +++ b/src/main/java/com/google/devtools/build/lib/cmdline/TargetPattern.java @@ -19,6 +19,8 @@ import com.google.common.annotations.VisibleForTesting; import com.google.common.base.Joiner; +import com.google.common.base.MoreObjects; +import com.google.common.base.MoreObjects.ToStringHelper; import com.google.common.base.Preconditions; import com.google.common.base.Splitter; import com.google.common.collect.ImmutableList; @@ -257,11 +259,17 @@ public PackageIdentifier getDirectory() { */ public abstract boolean getRulesOnly(); - private static final class SingleTarget extends TargetPattern { + protected final ToStringHelper toStringHelper() { + return MoreObjects.toStringHelper(this).add("originalPattern", originalPattern); + } + + @VisibleForTesting + static final class SingleTarget extends TargetPattern { private final Label target; - private SingleTarget(Label target, String originalPattern) { + @VisibleForTesting + SingleTarget(String originalPattern, Label target) { super(originalPattern); this.target = Preconditions.checkNotNull(target); } @@ -318,12 +326,19 @@ public boolean equals(Object o) { public int hashCode() { return Objects.hash(getType(), target); } + + @Override + public String toString() { + return toStringHelper().add("target", target).toString(); + } } - private static final class InterpretPathAsTarget extends TargetPattern { + @VisibleForTesting + static final class InterpretPathAsTarget extends TargetPattern { private final String path; - private InterpretPathAsTarget(String path, String originalPattern) { + @VisibleForTesting + InterpretPathAsTarget(String originalPattern, String path) { super(originalPattern); this.path = normalize(Preconditions.checkNotNull(path)); } @@ -403,28 +418,32 @@ public boolean equals(Object o) { public int hashCode() { return Objects.hash(getType(), path); } + + @Override + public String toString() { + return toStringHelper().add("path", path).toString(); + } } - private static final class TargetsInPackage extends TargetPattern { + @VisibleForTesting + static final class TargetsInPackage extends TargetPattern { private final PackageIdentifier packageIdentifier; private final String suffix; private final boolean wasOriginallyAbsolute; private final boolean rulesOnly; - private final boolean checkWildcardConflict; - private TargetsInPackage( + @VisibleForTesting + TargetsInPackage( String originalPattern, PackageIdentifier packageIdentifier, String suffix, boolean wasOriginallyAbsolute, - boolean rulesOnly, - boolean checkWildcardConflict) { + boolean rulesOnly) { super(originalPattern); this.packageIdentifier = packageIdentifier; this.suffix = Preconditions.checkNotNull(suffix); this.wasOriginallyAbsolute = wasOriginallyAbsolute; this.rulesOnly = rulesOnly; - this.checkWildcardConflict = checkWildcardConflict; } @Override @@ -435,12 +454,10 @@ public void eval( BatchCallback callback, Class exceptionClass) throws TargetParsingException, E, InterruptedException, InconsistentFilesystemException { - if (checkWildcardConflict) { - ResolvedTargets targets = getWildcardConflict(resolver); - if (targets != null) { - callback.process(targets.getTargets()); - return; - } + ResolvedTargets targets = getWildcardConflict(resolver); + if (targets != null) { + callback.process(targets.getTargets()); + return; } callback.process( @@ -478,7 +495,6 @@ public boolean equals(Object o) { TargetsInPackage that = (TargetsInPackage) o; return wasOriginallyAbsolute == that.wasOriginallyAbsolute && rulesOnly == that.rulesOnly - && checkWildcardConflict == that.checkWildcardConflict && getOriginalPattern().equals(that.getOriginalPattern()) && packageIdentifier.equals(that.packageIdentifier) && suffix.equals(that.suffix); @@ -492,8 +508,17 @@ public int hashCode() { packageIdentifier, suffix, wasOriginallyAbsolute, - rulesOnly, - checkWildcardConflict); + rulesOnly); + } + + @Override + public String toString() { + return toStringHelper() + .add("packageIdentifier", packageIdentifier) + .add("suffix", suffix) + .add("wasOriginallyAbsolute", wasOriginallyAbsolute) + .add("rulesOnly", rulesOnly) + .toString(); } /** @@ -547,8 +572,8 @@ public static final class TargetsBelowDirectory extends TargetPattern { private final PackageIdentifier directory; private final boolean rulesOnly; - private TargetsBelowDirectory( - String originalPattern, PackageIdentifier directory, boolean rulesOnly) { + @VisibleForTesting + TargetsBelowDirectory(String originalPattern, PackageIdentifier directory, boolean rulesOnly) { super(originalPattern); this.directory = Preconditions.checkNotNull(directory); this.rulesOnly = rulesOnly; @@ -816,6 +841,11 @@ && getOriginalPattern().equals(that.getOriginalPattern()) public int hashCode() { return Objects.hash(getType(), getOriginalPattern(), directory, rulesOnly); } + + @Override + public String toString() { + return toStringHelper().add("directory", directory).add("rulesOnly", rulesOnly).toString(); + } } @Immutable @@ -885,6 +915,9 @@ public static boolean isSimpleTargetPattern(String pattern) { /** Creates a new parser with the given offset for relative patterns. */ public Parser( PathFragment relativeDirectory, RepositoryName currentRepo, RepositoryMapping repoMapping) { + Preconditions.checkArgument( + currentRepo.isMain() || relativeDirectory.isEmpty(), + "parsing target patterns in a non-main repo with a relative directory is unsupported"); this.relativeDirectory = relativeDirectory; this.currentRepo = currentRepo; this.repoMapping = repoMapping; @@ -983,7 +1016,6 @@ public TargetPattern parse(String pattern) throws TargetParsingException { createPackageIdentifier(repository, packagePart), targetPart, wasOriginallyAbsolute, - true, true); } @@ -993,11 +1025,10 @@ public TargetPattern parse(String pattern) throws TargetParsingException { createPackageIdentifier(repository, packagePart), targetPart, wasOriginallyAbsolute, - false, - true); + false); } - if (includesRepo || wasOriginallyAbsolute || pattern.contains(":")) { + if (includesRepo || !repository.isMain() || wasOriginallyAbsolute || pattern.contains(":")) { Label label; try { label = Label.parseCanonical(repository.getNameWithAt() + "//" + pattern); @@ -1006,32 +1037,20 @@ public TargetPattern parse(String pattern) throws TargetParsingException { "invalid target format '" + originalPattern + "': " + e.getMessage(), TargetPatterns.Code.TARGET_FORMAT_INVALID); } - return new SingleTarget(label, originalPattern); + return new SingleTarget(originalPattern, label); } - // This is a stripped-down version of interpretPathAsTarget that does no I/O. We have a basic - // relative path. e.g. "foo/bar/Wiz.java". The strictest correct check we can do here (without - // I/O) is just to ensure that there is *some* prefix that is a valid package-name. It's - // sufficient to test the first segment. This is really a rather weak check; perhaps we should - // just eliminate it. - int slashIndex = pattern.indexOf('/'); - String packageName = pattern; - if (slashIndex > 0) { - packageName = pattern.substring(0, slashIndex); - } - String pkgError = LabelValidator.validatePackageName(packageName); - if (pkgError != null) { - throw new TargetParsingException( - "Bad target pattern '" + originalPattern + "': " + pkgError, - TargetPatterns.Code.LABEL_SYNTAX_ERROR); - } - return new InterpretPathAsTarget(pattern, originalPattern); + return new InterpretPathAsTarget(originalPattern, pattern); } public RepositoryMapping getRepoMapping() { return repoMapping; } + public RepositoryName getCurrentRepo() { + return currentRepo; + } + public PathFragment getRelativeDirectory() { return relativeDirectory; } diff --git a/src/test/java/com/google/devtools/build/lib/cmdline/TargetPatternTest.java b/src/test/java/com/google/devtools/build/lib/cmdline/TargetPatternTest.java index 1412e0ce8ffbfb..eaeb528a698d57 100644 --- a/src/test/java/com/google/devtools/build/lib/cmdline/TargetPatternTest.java +++ b/src/test/java/com/google/devtools/build/lib/cmdline/TargetPatternTest.java @@ -16,10 +16,15 @@ import static com.google.common.truth.Truth.assertThat; import static org.junit.Assert.assertThrows; +import static org.junit.Assert.fail; +import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; +import com.google.devtools.build.lib.cmdline.TargetPattern.InterpretPathAsTarget; +import com.google.devtools.build.lib.cmdline.TargetPattern.SingleTarget; import com.google.devtools.build.lib.cmdline.TargetPattern.TargetsBelowDirectory; import com.google.devtools.build.lib.cmdline.TargetPattern.TargetsBelowDirectory.ContainsResult; +import com.google.devtools.build.lib.cmdline.TargetPattern.TargetsInPackage; import com.google.devtools.build.lib.vfs.PathFragment; import org.junit.Test; import org.junit.runner.RunWith; @@ -28,38 +33,223 @@ /** Tests for {@link com.google.devtools.build.lib.cmdline.TargetPattern}. */ @RunWith(JUnit4.class) public class TargetPatternTest { - private void expectError(String pattern) { - assertThrows(TargetParsingException.class, () -> parse(pattern)); + private static Label label(String raw) { + return Label.parseCanonicalUnchecked(raw); + } + + private static PackageIdentifier pkg(String raw) { + try { + return PackageIdentifier.parse(raw); + } catch (LabelSyntaxException e) { + throw new RuntimeException(e); + } + } + + @Test + public void validPatterns_mainRepo_atRepoRoot() throws TargetParsingException { + TargetPattern.Parser parser = + new TargetPattern.Parser( + PathFragment.EMPTY_FRAGMENT, + RepositoryName.MAIN, + RepositoryMapping.create( + ImmutableMap.of("repo", RepositoryName.createUnvalidated("canonical_repo")), + RepositoryName.MAIN)); + + assertThat(parser.parse("foo:bar")) + .isEqualTo(new SingleTarget("foo:bar", label("@@//foo:bar"))); + assertThat(parser.parse("foo:all")) + .isEqualTo(new TargetsInPackage("foo:all", pkg("@@//foo"), "all", false, true)); + assertThat(parser.parse("foo/...:all")) + .isEqualTo(new TargetsBelowDirectory("foo/...:all", pkg("@@//foo"), true)); + assertThat(parser.parse("foo:*")) + .isEqualTo(new TargetsInPackage("foo:*", pkg("@@//foo"), "*", false, false)); + assertThat(parser.parse("foo")).isEqualTo(new InterpretPathAsTarget("foo", "foo")); + assertThat(parser.parse("...")).isEqualTo(new TargetsBelowDirectory("...", pkg("@@//"), true)); + assertThat(parser.parse("foo/bar")).isEqualTo(new InterpretPathAsTarget("foo/bar", "foo/bar")); + + assertThat(parser.parse("//foo")).isEqualTo(new SingleTarget("//foo", label("@@//foo:foo"))); + assertThat(parser.parse("//foo:bar")) + .isEqualTo(new SingleTarget("//foo:bar", label("@@//foo:bar"))); + assertThat(parser.parse("//foo:all")) + .isEqualTo(new TargetsInPackage("//foo:all", pkg("@@//foo"), "all", true, true)); + + assertThat(parser.parse("//foo/all")) + .isEqualTo(new SingleTarget("//foo/all", label("@@//foo/all:all"))); + assertThat(parser.parse("//foo/...:all")) + .isEqualTo(new TargetsBelowDirectory("//foo/...:all", pkg("@@//foo"), true)); + assertThat(parser.parse("//...")) + .isEqualTo(new TargetsBelowDirectory("//...", pkg("@@//"), true)); + + assertThat(parser.parse("@repo//foo:bar")) + .isEqualTo(new SingleTarget("@repo//foo:bar", label("@@canonical_repo//foo:bar"))); + assertThat(parser.parse("@repo//foo:all")) + .isEqualTo( + new TargetsInPackage( + "@repo//foo:all", pkg("@@canonical_repo//foo"), "all", true, true)); + assertThat(parser.parse("@repo//:bar")) + .isEqualTo(new SingleTarget("@repo//:bar", label("@@canonical_repo//:bar"))); + assertThat(parser.parse("@repo//...")) + .isEqualTo(new TargetsBelowDirectory("@repo//...", pkg("@@canonical_repo//"), true)); + assertThat(parser.parse("@@repo//foo:all")) + .isEqualTo(new TargetsInPackage("@@repo//foo:all", pkg("@@repo//foo"), "all", true, true)); + assertThat(parser.parse("@@repo//:bar")) + .isEqualTo(new SingleTarget("@@repo//:bar", label("@@repo//:bar"))); + } + + @Test + public void validPatterns_mainRepo_inSomeRelativeDirectory() throws TargetParsingException { + TargetPattern.Parser parser = + new TargetPattern.Parser( + PathFragment.create("base"), + RepositoryName.MAIN, + RepositoryMapping.create( + ImmutableMap.of("repo", RepositoryName.createUnvalidated("canonical_repo")), + RepositoryName.MAIN)); + + assertThat(parser.parse("foo:bar")) + .isEqualTo(new SingleTarget("foo:bar", label("@@//base/foo:bar"))); + assertThat(parser.parse("foo:all")) + .isEqualTo(new TargetsInPackage("foo:all", pkg("@@//base/foo"), "all", false, true)); + assertThat(parser.parse("foo/...:all")) + .isEqualTo(new TargetsBelowDirectory("foo/...:all", pkg("@@//base/foo"), true)); + assertThat(parser.parse("foo:*")) + .isEqualTo(new TargetsInPackage("foo:*", pkg("@@//base/foo"), "*", false, false)); + assertThat(parser.parse("foo")).isEqualTo(new InterpretPathAsTarget("foo", "base/foo")); + assertThat(parser.parse("...")) + .isEqualTo(new TargetsBelowDirectory("...", pkg("@@//base"), true)); + assertThat(parser.parse("foo/bar")) + .isEqualTo(new InterpretPathAsTarget("foo/bar", "base/foo/bar")); + + assertThat(parser.parse("//foo")).isEqualTo(new SingleTarget("//foo", label("@@//foo:foo"))); + assertThat(parser.parse("//foo:bar")) + .isEqualTo(new SingleTarget("//foo:bar", label("@@//foo:bar"))); + assertThat(parser.parse("//foo:all")) + .isEqualTo(new TargetsInPackage("//foo:all", pkg("@@//foo"), "all", true, true)); + + assertThat(parser.parse("//foo/all")) + .isEqualTo(new SingleTarget("//foo/all", label("@@//foo/all:all"))); + assertThat(parser.parse("//foo/...:all")) + .isEqualTo(new TargetsBelowDirectory("//foo/...:all", pkg("@@//foo"), true)); + assertThat(parser.parse("//...")) + .isEqualTo(new TargetsBelowDirectory("//...", pkg("@@//"), true)); + + assertThat(parser.parse("@repo//foo:bar")) + .isEqualTo(new SingleTarget("@repo//foo:bar", label("@@canonical_repo//foo:bar"))); + assertThat(parser.parse("@repo//foo:all")) + .isEqualTo( + new TargetsInPackage( + "@repo//foo:all", pkg("@@canonical_repo//foo"), "all", true, true)); + assertThat(parser.parse("@repo//:bar")) + .isEqualTo(new SingleTarget("@repo//:bar", label("@@canonical_repo//:bar"))); + assertThat(parser.parse("@repo//...")) + .isEqualTo(new TargetsBelowDirectory("@repo//...", pkg("@@canonical_repo//"), true)); + assertThat(parser.parse("@@repo//foo:all")) + .isEqualTo(new TargetsInPackage("@@repo//foo:all", pkg("@@repo//foo"), "all", true, true)); + assertThat(parser.parse("@@repo//:bar")) + .isEqualTo(new SingleTarget("@@repo//:bar", label("@@repo//:bar"))); + } + + @Test + public void validPatterns_nonMainRepo() throws TargetParsingException { + TargetPattern.Parser parser = + new TargetPattern.Parser( + PathFragment.EMPTY_FRAGMENT, + RepositoryName.createUnvalidated("my_repo"), + RepositoryMapping.create( + ImmutableMap.of("repo", RepositoryName.createUnvalidated("canonical_repo")), + RepositoryName.createUnvalidated("my_repo"))); + + assertThat(parser.parse("foo:bar")) + .isEqualTo(new SingleTarget("foo:bar", label("@@my_repo//foo:bar"))); + assertThat(parser.parse("foo:all")) + .isEqualTo(new TargetsInPackage("foo:all", pkg("@@my_repo//foo"), "all", false, true)); + assertThat(parser.parse("foo/...:all")) + .isEqualTo(new TargetsBelowDirectory("foo/...:all", pkg("@@my_repo//foo"), true)); + assertThat(parser.parse("foo:*")) + .isEqualTo(new TargetsInPackage("foo:*", pkg("@@my_repo//foo"), "*", false, false)); + // TODO(wyv): This is surprising. This means that in a non-main repo, + // `register_toolchains("foo")` is equivalent to `r_t("//foo:foo")`, but in the main repo, it's + // equivalent to `r_t("//:foo")` (which is the more intuitive behavior). + // Granted, nobody probably ever writes this, but we should look into fixing it nonetheless. + assertThat(parser.parse("foo")).isEqualTo(new SingleTarget("foo", label("@@my_repo//foo:foo"))); + assertThat(parser.parse("...")) + .isEqualTo(new TargetsBelowDirectory("...", pkg("@@my_repo//"), true)); + assertThat(parser.parse("foo/bar")) + .isEqualTo(new SingleTarget("foo/bar", label("@@my_repo//foo/bar:bar"))); + + assertThat(parser.parse("//foo")) + .isEqualTo(new SingleTarget("//foo", label("@@my_repo//foo:foo"))); + assertThat(parser.parse("//foo:bar")) + .isEqualTo(new SingleTarget("//foo:bar", label("@@my_repo//foo:bar"))); + assertThat(parser.parse("//foo:all")) + .isEqualTo(new TargetsInPackage("//foo:all", pkg("@@my_repo//foo"), "all", true, true)); + + assertThat(parser.parse("//foo/all")) + .isEqualTo(new SingleTarget("//foo/all", label("@@my_repo//foo/all:all"))); + assertThat(parser.parse("//foo/...:all")) + .isEqualTo(new TargetsBelowDirectory("//foo/...:all", pkg("@@my_repo//foo"), true)); + assertThat(parser.parse("//...")) + .isEqualTo(new TargetsBelowDirectory("//...", pkg("@@my_repo//"), true)); + + assertThat(parser.parse("@repo//foo:bar")) + .isEqualTo(new SingleTarget("@repo//foo:bar", label("@@canonical_repo//foo:bar"))); + assertThat(parser.parse("@repo//foo:all")) + .isEqualTo( + new TargetsInPackage( + "@repo//foo:all", pkg("@@canonical_repo//foo"), "all", true, true)); + assertThat(parser.parse("@repo//:bar")) + .isEqualTo(new SingleTarget("@repo//:bar", label("@@canonical_repo//:bar"))); + assertThat(parser.parse("@repo//...")) + .isEqualTo(new TargetsBelowDirectory("@repo//...", pkg("@@canonical_repo//"), true)); + assertThat(parser.parse("@@repo//foo:all")) + .isEqualTo(new TargetsInPackage("@@repo//foo:all", pkg("@@repo//foo"), "all", true, true)); + assertThat(parser.parse("@@repo//:bar")) + .isEqualTo(new SingleTarget("@@repo//:bar", label("@@repo//:bar"))); } @Test - public void testPassingValidations() throws TargetParsingException { - parse("foo:bar"); - parse("foo:all"); - parse("foo/...:all"); - parse("foo:*"); - - parse("//foo"); - parse("//foo:bar"); - parse("//foo:all"); - - parse("//foo/all"); - parse("java/com/google/foo/Bar.java"); - parse("//foo/...:all"); - - parse("//..."); - parse("@repo//foo:bar"); - parse("@repo//foo:all"); - parse("@repo//:bar"); - parse("@@repo//foo:all"); - parse("@@repo//:bar"); + public void invalidPatterns() throws Exception { + ImmutableList badPatterns = + ImmutableList.of("//Bar\\java", "", "@", "@foo", "@foo//", "@@", "@@foo"); + ImmutableMap repoMappingEntries = + ImmutableMap.of("repo", RepositoryName.createUnvalidated("canonical_repo")); + for (TargetPattern.Parser parser : + ImmutableList.of( + new TargetPattern.Parser( + PathFragment.EMPTY_FRAGMENT, + RepositoryName.MAIN, + RepositoryMapping.create(repoMappingEntries, RepositoryName.MAIN)), + new TargetPattern.Parser( + PathFragment.create("base"), + RepositoryName.MAIN, + RepositoryMapping.create(repoMappingEntries, RepositoryName.MAIN)), + new TargetPattern.Parser( + PathFragment.EMPTY_FRAGMENT, + RepositoryName.create("my_repo"), + RepositoryMapping.create(repoMappingEntries, RepositoryName.create("my_repo"))))) { + for (String pattern : badPatterns) { + try { + TargetPattern parsed = parser.parse(pattern); + fail( + String.format( + "parsing should have failed for pattern \"%s\" with parser in repo %s at" + + " relative directory [%s], but succeeded with the result:\n%s", + pattern, parser.getCurrentRepo(), parser.getRelativeDirectory(), parsed)); + } catch (TargetParsingException expected) { + } + } + } } @Test - public void testInvalidPatterns() throws TargetParsingException { - expectError("Bar\\java"); - expectError(""); - expectError("\\"); + public void invalidParser_nonMainRepo_nonEmptyRelativeDirectory() throws Exception { + assertThrows( + IllegalArgumentException.class, + () -> + new TargetPattern.Parser( + PathFragment.create("base"), + RepositoryName.create("my_repo"), + RepositoryMapping.ALWAYS_FALLBACK)); } @Test @@ -89,6 +279,13 @@ public void testNormalize() { assertThat(TargetPattern.normalize("a/../../../b")).isEqualTo("../../b"); } + private static TargetsBelowDirectory parseAsTBD(String pattern) throws TargetParsingException { + TargetPattern parsedPattern = TargetPattern.defaultParser().parse(pattern); + assertThat(parsedPattern.getType()).isEqualTo(TargetPattern.Type.TARGETS_BELOW_DIRECTORY); + assertThat(parsedPattern.getOriginalPattern()).isEqualTo(pattern); + return (TargetsBelowDirectory) parsedPattern; + } + @Test public void testTargetsBelowDirectoryContainsColonStar() throws Exception { // Given an outer pattern '//foo/...', that matches rules only, @@ -166,47 +363,4 @@ public void testDepotRootTargetsBelowDirectoryContainsPatterns() throws Exceptio .isEqualTo(ContainsResult.DIRECTORY_EXCLUSION_WOULD_BE_EXACT); assertThat(tbdFoo.contains(tbdDepot)).isEqualTo(ContainsResult.NOT_CONTAINED); } - - @Test - public void testRenameRepository() throws Exception { - RepositoryMapping renaming = - RepositoryMapping.createAllowingFallback( - ImmutableMap.of( - "foo", RepositoryName.create("bar"), - "myworkspace", RepositoryName.create(""))); - TargetPattern.Parser parser = - new TargetPattern.Parser( - PathFragment.EMPTY_FRAGMENT, RepositoryName.createUnvalidated("myrepo"), renaming); - - // Expecting renaming - assertThat(parser.parse("@foo//package:target").getRepository().getName()).isEqualTo("bar"); - assertThat(parser.parse("@myworkspace//package:target").getRepository().isMain()).isTrue(); - assertThat(parser.parse("@foo//foo/...").getRepository().getName()).isEqualTo("bar"); - assertThat(parser.parse("@myworkspace//foo/...").getRepository().isMain()).isTrue(); - - // No renaming should occur - assertThat(parser.parse("@//package:target").getRepository().isMain()).isTrue(); - assertThat(parser.parse("@@foo//package:target").getRepository().getName()).isEqualTo("foo"); - assertThat(parser.parse("@unrelated//package:target").getRepository().getName()) - .isEqualTo("unrelated"); - assertThat(parser.parse("foo/package:target").getRepository().getName()).isEqualTo("myrepo"); - assertThat(parser.parse("foo/...").getRepository().getName()).isEqualTo("myrepo"); - } - - private static TargetPattern parse(String pattern) throws TargetParsingException { - return TargetPattern.defaultParser().parse(pattern); - } - - private static TargetPattern parseAsExpectedType(String pattern, TargetPattern.Type expectedType) - throws TargetParsingException { - TargetPattern parsedPattern = parse(pattern); - assertThat(parsedPattern.getType()).isEqualTo(expectedType); - assertThat(parsedPattern.getOriginalPattern()).isEqualTo(pattern); - return parsedPattern; - } - - private static TargetsBelowDirectory parseAsTBD(String pattern) throws TargetParsingException { - return (TargetsBelowDirectory) - parseAsExpectedType(pattern, TargetPattern.Type.TARGETS_BELOW_DIRECTORY); - } } diff --git a/src/test/java/com/google/devtools/build/lib/pkgcache/LoadingPhaseRunnerTest.java b/src/test/java/com/google/devtools/build/lib/pkgcache/LoadingPhaseRunnerTest.java index 780a156608e9fd..29ac1530eabd0a 100644 --- a/src/test/java/com/google/devtools/build/lib/pkgcache/LoadingPhaseRunnerTest.java +++ b/src/test/java/com/google/devtools/build/lib/pkgcache/LoadingPhaseRunnerTest.java @@ -1171,9 +1171,7 @@ public void testPatternEndingWithSingleSlashIsError() { @Test public void testPatternStartingWithDotDotSlash() { - expectError( - "../foo", - "Bad target pattern '../foo': package name component contains only '.' characters"); + expectError("../foo", "couldn't determine target from filename '../foo'"); } private void runTestPackageLoadingError(boolean keepGoing, String... patterns) throws Exception {