src/test/java/com/google/devtools/build/lib/cmdline/LabelTest.java - bazel - Git at Google

 // 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.cmdline;

 import static com.google.common.truth.Truth.assertThat;
 import static org.junit.Assert.assertThrows;

 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Tables;
 import com.google.common.testing.EqualsTester;
 import com.google.devtools.build.lib.cmdline.Label.PackageContext;
 import com.google.devtools.build.lib.cmdline.Label.RepoContext;
 import com.google.devtools.build.lib.cmdline.Label.RepoMappingRecorder;
 import com.google.devtools.build.lib.packages.semantics.BuildLanguageOptions;
 import com.google.devtools.build.lib.vfs.PathFragment;
 import java.util.regex.Pattern;
 import net.starlark.java.eval.Starlark;
 import net.starlark.java.eval.StarlarkSemantics;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;

 /** Tests for {@link Label}. */
 @RunWith(JUnit4.class)
 public class LabelTest {

   private static final String INVALID_TARGET_NAME = "invalid target name";
   private static final String INVALID_PACKAGE_NAME = "invalid package name";

   @Test
   public void testAbsolute() throws Exception {
     {
       Label l = Label.parseCanonical("//foo/bar:baz");
       assertThat(l.getPackageName()).isEqualTo("foo/bar");
       assertThat(l.getName()).isEqualTo("baz");
     }
     {
       Label l = Label.parseCanonical("//foo/bar");
       assertThat(l.getPackageName()).isEqualTo("foo/bar");
       assertThat(l.getName()).isEqualTo("bar");
     }
     {
       Label l = Label.parseCanonical("//:bar");
       assertThat(l.getPackageName()).isEmpty();
       assertThat(l.getName()).isEqualTo("bar");
     }
     {
       Label l = Label.parseCanonical("@foo");
       assertThat(l.getRepository().getName()).isEqualTo("foo");
       assertThat(l.getPackageName()).isEmpty();
       assertThat(l.getName()).isEqualTo("foo");
     }
     {
       Label l = Label.parseCanonical("@foo//bar");
       assertThat(l.getRepository().getName()).isEqualTo("foo");
       assertThat(l.getPackageName()).isEqualTo("bar");
       assertThat(l.getName()).isEqualTo("bar");
     }
     {
       Label l = Label.parseCanonical("@@foo//bar");
       assertThat(l.getRepository().getName()).isEqualTo("foo");
       assertThat(l.getPackageName()).isEqualTo("bar");
       assertThat(l.getName()).isEqualTo("bar");
     }
     {
       Label l = Label.parseCanonical("//@foo");
       assertThat(l.getRepository()).isEqualTo(RepositoryName.MAIN);
       assertThat(l.getPackageName()).isEqualTo("@foo");
       assertThat(l.getName()).isEqualTo("@foo");
     }
     {
       Label l = Label.parseCanonical("//xyz/@foo:abc");
       assertThat(l.getRepository()).isEqualTo(RepositoryName.MAIN);
       assertThat(l.getPackageName()).isEqualTo("xyz/@foo");
       assertThat(l.getName()).isEqualTo("abc");
     }
   }

   @Test
   public void parseWithRepoContext() throws Exception {
     RepositoryName foo = RepositoryName.createUnvalidated("foo");
     RepositoryName bar = RepositoryName.createUnvalidated("bar");
     RepositoryName quux = RepositoryName.createUnvalidated("quux");
     RepoContext repoContext =
         RepoContext.of(foo, RepositoryMapping.create(ImmutableMap.of("bar", quux), foo));
     {
       Label l = Label.parseWithRepoContext("//lol:kek", repoContext);
       assertThat(l.getRepository()).isEqualTo(foo);
       assertThat(l.getPackageName()).isEqualTo("lol");
       assertThat(l.getName()).isEqualTo("kek");
     }
     {
       Label l = Label.parseWithRepoContext("@bar//lol:kek", repoContext);
       assertThat(l.getRepository()).isEqualTo(quux);
       assertThat(l.getPackageName()).isEqualTo("lol");
       assertThat(l.getName()).isEqualTo("kek");
     }
     {
       Label l = Label.parseWithRepoContext("@@bar//lol:kek", repoContext);
       assertThat(l.getRepository()).isEqualTo(bar);
       assertThat(l.getPackageName()).isEqualTo("lol");
       assertThat(l.getName()).isEqualTo("kek");
     }
     {
       Label l = Label.parseWithRepoContext("@quux//lol:kek", repoContext);
       assertThat(l.getRepository()).isEqualTo(quux.toNonVisible(foo));
       assertThat(l.getPackageName()).isEqualTo("lol");
       assertThat(l.getName()).isEqualTo("kek");
     }
   }

   @Test
   public void parseWithPackageContext() throws Exception {
     RepositoryName foo = RepositoryName.createUnvalidated("foo");
     RepositoryName bar = RepositoryName.createUnvalidated("bar");
     RepositoryName quux = RepositoryName.createUnvalidated("quux");
     PackageContext packageContext =
         PackageContext.of(
             PackageIdentifier.create(foo, PathFragment.create("hah")),
             RepositoryMapping.create(ImmutableMap.of("bar", quux), foo));
     {
       Label l = Label.parseWithPackageContext(":kek", packageContext);
       assertThat(l.getRepository()).isEqualTo(foo);
       assertThat(l.getPackageName()).isEqualTo("hah");
       assertThat(l.getName()).isEqualTo("kek");
     }
     {
       Label l = Label.parseWithPackageContext("//lol:kek", packageContext);
       assertThat(l.getRepository()).isEqualTo(foo);
       assertThat(l.getPackageName()).isEqualTo("lol");
       assertThat(l.getName()).isEqualTo("kek");
     }
     {
       Label l = Label.parseWithPackageContext("@bar//lol:kek", packageContext);
       assertThat(l.getRepository()).isEqualTo(quux);
       assertThat(l.getPackageName()).isEqualTo("lol");
       assertThat(l.getName()).isEqualTo("kek");
     }
     {
       Label l = Label.parseWithPackageContext("@@bar//lol:kek", packageContext);
       assertThat(l.getRepository()).isEqualTo(bar);
       assertThat(l.getPackageName()).isEqualTo("lol");
       assertThat(l.getName()).isEqualTo("kek");
     }
     {
       Label l = Label.parseWithPackageContext("@quux//lol:kek", packageContext);
       assertThat(l.getRepository()).isEqualTo(quux.toNonVisible(foo));
       assertThat(l.getPackageName()).isEqualTo("lol");
       assertThat(l.getName()).isEqualTo("kek");
     }
   }

   @Test
   public void testFactory() throws Exception {
     Label l = Label.create("foo/bar", "quux");
     assertThat(l.getPackageName()).isEqualTo("foo/bar");
     assertThat(l.getName()).isEqualTo("quux");
   }

   @Test
   public void testIdentities() throws Exception {

     Label l1 = Label.parseCanonical("//foo/bar:baz");
     Label l2 = Label.parseCanonical("//foo/bar:baz");
     Label l3 = Label.parseCanonical("//foo/bar:quux");

     new EqualsTester().addEqualityGroup(l1, l2).addEqualityGroup(l3).testEquals();
   }

   @Test
   public void testToString() throws Exception {
     {
       String s = "@//foo/bar:baz";
       Label l = Label.parseCanonical(s);
       assertThat(l.toString()).isEqualTo("//foo/bar:baz");
     }
     {
       Label l = Label.parseCanonical("//foo/bar");
       assertThat(l.toString()).isEqualTo("//foo/bar:bar");
     }
     {
       Label l = Label.parseCanonical("@foo");
       assertThat(l.toString()).isEqualTo("@@foo//:foo");
     }
   }

   @Test
   public void testDotDot() throws Exception {
     Label.parseCanonical("//foo/bar:baz..gif");
   }

   /**
    * Asserts that creating a label throws a SyntaxException.
    *
    * @param label the label to create.
    */
   private static void assertSyntaxError(String expectedError, String label) {
     LabelSyntaxException e =
         assertThrows(
             "Label '" + label + "' did not contain a syntax error, but was expected to",
             LabelSyntaxException.class,
             () -> Label.parseCanonical(label));
     assertThat(e).hasMessageThat().containsMatch(Pattern.quote(expectedError));
   }

   @Test
   public void testBadCharacters() throws Exception {
     assertSyntaxError("target names may not contain ':'", "//foo:bar:baz");
     assertSyntaxError("target names may not contain ':'", "//foo:bar:");
     assertSyntaxError("target names may not contain ':'", "//foo/bar::");
   }

   @Test
   public void testUplevelReferences() throws Exception {
     assertSyntaxError(INVALID_PACKAGE_NAME, "//foo/bar/..:baz");
     assertSyntaxError(INVALID_PACKAGE_NAME, "//foo/../baz:baz");
     assertSyntaxError(INVALID_PACKAGE_NAME, "//../bar/baz:baz");
     assertSyntaxError(INVALID_PACKAGE_NAME, "//..:foo");
     assertSyntaxError(INVALID_TARGET_NAME, "//foo:bar/../baz");
     assertSyntaxError(INVALID_TARGET_NAME, "//foo:../bar/baz");
     assertSyntaxError(INVALID_TARGET_NAME, "//foo:bar/baz/..");
     assertSyntaxError(INVALID_TARGET_NAME, "//foo:..");
   }

   @Test
   public void testDotAsAPathSegment() throws Exception {
     assertSyntaxError(INVALID_PACKAGE_NAME, "//foo/bar/.:baz");
     assertSyntaxError(INVALID_PACKAGE_NAME, "//foo/./baz:baz");
     assertSyntaxError(INVALID_PACKAGE_NAME, "//./bar/baz:baz");
     assertSyntaxError(INVALID_TARGET_NAME, "//foo:bar/./baz");
     assertSyntaxError(INVALID_TARGET_NAME, "//foo:./bar/baz");
     // TODO(bazel-team): enable when we have removed the "Workaround" in Label
     // that rewrites broken Labels by removing the trailing '.'
     // assertSyntaxError(INVALID_PACKAGE_NAME,
     //                  "//foo:bar/baz/.");
     // assertSyntaxError(INVALID_PACKAGE_NAME,
     //                  "//foo:.");
   }

   @Test
   public void testTrailingDotSegment() throws Exception {
     assertThat(Label.parseCanonical("//foo:dir")).isEqualTo(Label.parseCanonical("//foo:dir/."));
   }

   @Test
   public void testSomeOtherBadLabels() throws Exception {
     assertSyntaxError("package names may not end with '/'", "//foo/:bar");
     assertSyntaxError("package names may not start with '/'", "///p:foo");
     assertSyntaxError("package names may not contain '//' path separators", "//a//b:foo");
   }

   @Test
   public void testSomeGoodLabels() throws Exception {
     Label.parseCanonical("//foo:..bar");
     Label.parseCanonical("//Foo:..bar");
     Label.parseCanonical("//-Foo:..bar");
     Label.parseCanonical("//00:..bar");
     Label.parseCanonical("//package:foo+bar");
     Label.parseCanonical("//package:foo_bar");
     Label.parseCanonical("//package:foo=bar");
     Label.parseCanonical("//package:foo-bar");
     Label.parseCanonical("//package:foo.bar");
     Label.parseCanonical("//package:foo@bar");
     Label.parseCanonical("//package:foo~bar");
     Label.parseCanonical("//$( ):$( )");
   }

   @Test
   public void testDoubleSlashPathSeparator() throws Exception {
     assertSyntaxError("package names may not contain '//' path separators", "//foo//bar:baz");
     assertSyntaxError("target names may not contain '//' path separator", "//foo:bar//baz");
   }

   @Test
   public void testNonPrintableCharacters() throws Exception {
     assertSyntaxError(
         "target names may not contain non-printable characters: '\\x02'", "//foo:..\002bar");
   }

   /** Make sure that control characters - such as CR - are escaped on output. */
   @Test
   public void testInvalidLineEndings() throws Exception {
     assertSyntaxError(
         "invalid target name '..bar\\r': " + "target names may not end with carriage returns",
         "//foo:..bar\r");
   }

   @Test
   public void testEmptyName() throws Exception {
     assertSyntaxError("invalid target name '': empty target name", "//foo/bar:");
   }

   @Test
   public void testRepoLabel() throws Exception {
     Label label = Label.parseCanonical("@foo//bar/baz:bat/boo");
     assertThat(label.toString()).isEqualTo("@@foo//bar/baz:bat/boo");
   }

   @Test
   public void testNoRepo() throws Exception {
     Label label = Label.parseCanonical("//bar/baz:bat/boo");
     assertThat(label.toString()).isEqualTo("//bar/baz:bat/boo");
   }

   @Test
   public void testInvalidRepo() throws Exception {
     LabelSyntaxException e =
         assertThrows(
             LabelSyntaxException.class, () -> Label.parseCanonical("foo//bar/baz:bat/boo"));
     assertThat(e)
         .hasMessageThat()
         .isEqualTo(
             "invalid package name 'foo//bar/baz': package names may not contain '//' path"
                 + " separators");
   }

   @Test
   public void testInvalidRepoWithColon() throws Exception {
     LabelSyntaxException e =
         assertThrows(LabelSyntaxException.class, () -> Label.parseCanonical("@foo:xyz"));
     assertThat(e)
         .hasMessageThat()
         .containsMatch("invalid repository name 'foo:xyz': repo names may contain only");
   }

   @Test
   public void testGetWorkspaceRoot() throws Exception {
     Label label = Label.parseCanonical("//bar/baz");
     assertThat(label.getWorkspaceRootForStarlarkOnly(StarlarkSemantics.DEFAULT)).isEmpty();
     label = Label.parseCanonical("@repo//bar/baz");
     assertThat(label.getWorkspaceRootForStarlarkOnly(StarlarkSemantics.DEFAULT))
         .isEqualTo("external/repo");
   }

   @Test
   public void testGetContainingDirectory() {
     assertThat(Label.getContainingDirectory(Label.parseCanonicalUnchecked("//a:b")))
         .isEqualTo(PathFragment.create("a"));
     assertThat(Label.getContainingDirectory(Label.parseCanonicalUnchecked("//a/b:c")))
         .isEqualTo(PathFragment.create("a/b"));
     assertThat(Label.getContainingDirectory(Label.parseCanonicalUnchecked("//a:b/c")))
         .isEqualTo(PathFragment.create("a/b"));
     assertThat(Label.getContainingDirectory(Label.parseCanonicalUnchecked("//a/b/c")))
         .isEqualTo(PathFragment.create("a/b/c"));
   }

   @Test
   public void testWorkspaceName() throws Exception {
     assertThat(Label.parseCanonical("@foo//bar:baz").getWorkspaceName()).isEqualTo("foo");
     assertThat(Label.parseCanonical("//bar:baz").getWorkspaceName()).isEmpty();
     assertThat(Label.parseCanonical("@//bar:baz").getWorkspaceName()).isEmpty();
   }

   @Test
   public void testUnambiguousCanonicalForm() throws Exception {
     assertThat(Label.parseCanonical("//foo/bar:baz").getUnambiguousCanonicalForm())
         .isEqualTo("@@//foo/bar:baz");
     assertThat(Label.parseCanonical("@foo//bar:baz").getUnambiguousCanonicalForm())
         .isEqualTo("@@foo//bar:baz");
     assertThat(
             Label.create(
                     PackageIdentifier.create(
                         RepositoryName.create("foo").toNonVisible(RepositoryName.create("bar")),
                         PathFragment.create("baz")),
                     "quux")
                 .getUnambiguousCanonicalForm())
         .isEqualTo("@@[unknown repo 'foo' requested from @@bar]//baz:quux");
   }

   private static String displayFormFor(String rawLabel, RepositoryMapping repositoryMapping)
       throws Exception {
     return Label.parseCanonical(rawLabel).getDisplayForm(repositoryMapping);
   }

   @Test
   public void testDisplayForm() throws Exception {
     RepositoryName canonicalName = RepositoryName.create("canonical");
     RepositoryMapping repositoryMapping =
         RepositoryMapping.create(
             ImmutableMap.of("", RepositoryName.MAIN, "local", canonicalName), RepositoryName.MAIN);

     assertThat(displayFormFor("//foo/bar:bar", repositoryMapping)).isEqualTo("//foo/bar:bar");
     assertThat(displayFormFor("//foo/bar:baz", repositoryMapping)).isEqualTo("//foo/bar:baz");

     assertThat(displayFormFor("@canonical//bar:bar", repositoryMapping))
         .isEqualTo("@local//bar:bar");
     assertThat(displayFormFor("@canonical//bar:baz", repositoryMapping))
         .isEqualTo("@local//bar:baz");
     assertThat(displayFormFor("@canonical//:canonical", repositoryMapping))
         .isEqualTo("@local//:canonical");
     assertThat(displayFormFor("@canonical//:local", repositoryMapping)).isEqualTo("@local//:local");

     assertThat(displayFormFor("@other//bar:bar", repositoryMapping)).isEqualTo("@@other//bar:bar");
     assertThat(displayFormFor("@other//bar:baz", repositoryMapping)).isEqualTo("@@other//bar:baz");
     assertThat(displayFormFor("@other//:other", repositoryMapping)).isEqualTo("@@other//:other");
     assertThat(displayFormFor("@@other", repositoryMapping)).isEqualTo("@@other//:other");

     assertThat(
             Label.parseWithRepoContext(
                     "@bad//abc", RepoContext.of(RepositoryName.MAIN, repositoryMapping))
                 .getDisplayForm(repositoryMapping))
         .isEqualTo("@@[unknown repo 'bad' requested from @@]//abc:abc");

     assertThat(displayFormFor("@unremapped//:unremapped", RepositoryMapping.ALWAYS_FALLBACK))
         .isEqualTo("@unremapped//:unremapped");
     assertThat(displayFormFor("@unremapped", RepositoryMapping.ALWAYS_FALLBACK))
         .isEqualTo("@unremapped//:unremapped");
   }

   private static String shorthandDisplayFormFor(
       String rawLabel, RepositoryMapping repositoryMapping) throws Exception {
     return Label.parseCanonical(rawLabel).getShorthandDisplayForm(repositoryMapping);
   }

   @Test
   public void testShorthandDisplayForm() throws Exception {
     RepositoryName canonicalName = RepositoryName.create("canonical");
     RepositoryMapping repositoryMapping =
         RepositoryMapping.create(
             ImmutableMap.of("", RepositoryName.MAIN, "local", canonicalName), RepositoryName.MAIN);

     assertThat(shorthandDisplayFormFor("//foo/bar:bar", repositoryMapping)).isEqualTo("//foo/bar");
     assertThat(shorthandDisplayFormFor("//foo/bar:baz", repositoryMapping))
         .isEqualTo("//foo/bar:baz");

     assertThat(shorthandDisplayFormFor("@canonical//bar:bar", repositoryMapping))
         .isEqualTo("@local//bar");
     assertThat(shorthandDisplayFormFor("@canonical//bar:baz", repositoryMapping))
         .isEqualTo("@local//bar:baz");
     assertThat(shorthandDisplayFormFor("@canonical//:canonical", repositoryMapping))
         .isEqualTo("@local//:canonical");
     assertThat(shorthandDisplayFormFor("@canonical//:local", repositoryMapping))
         .isEqualTo("@local");

     assertThat(shorthandDisplayFormFor("@other//bar:bar", repositoryMapping))
         .isEqualTo("@@other//bar");
     assertThat(shorthandDisplayFormFor("@other//bar:baz", repositoryMapping))
         .isEqualTo("@@other//bar:baz");
     assertThat(shorthandDisplayFormFor("@other//:other", repositoryMapping)).isEqualTo("@@other");
     assertThat(shorthandDisplayFormFor("@@other", repositoryMapping)).isEqualTo("@@other");

     assertThat(
             Label.parseWithRepoContext(
                     "@bad//abc", RepoContext.of(RepositoryName.MAIN, repositoryMapping))
                 .getShorthandDisplayForm(repositoryMapping))
         .isEqualTo("@@[unknown repo 'bad' requested from @@]//abc");

     assertThat(
             shorthandDisplayFormFor("@unremapped//:unremapped", RepositoryMapping.ALWAYS_FALLBACK))
         .isEqualTo("@unremapped");
     assertThat(shorthandDisplayFormFor("@unremapped", RepositoryMapping.ALWAYS_FALLBACK))
         .isEqualTo("@unremapped");
   }

   @Test
   public void starlarkStrAndRepr() throws Exception {
     Label label = Label.parseCanonical("//x");
     assertThat(Starlark.str(label, StarlarkSemantics.DEFAULT)).isEqualTo("@@//x:x");
     assertThat(Starlark.repr(label)).isEqualTo("Label(\"//x:x\")");

     label = Label.parseCanonical("@hello//x");
     assertThat(Starlark.str(label, StarlarkSemantics.DEFAULT)).isEqualTo("@@hello//x:x");
     assertThat(Starlark.repr(label)).isEqualTo("Label(\"@@hello//x:x\")");
   }

   @Test
   public void starlarkStr_ambiguous() throws Exception {
     StarlarkSemantics semantics =
         StarlarkSemantics.builder()
             .setBool(BuildLanguageOptions.INCOMPATIBLE_UNAMBIGUOUS_LABEL_STRINGIFICATION, false)
             .setBool(BuildLanguageOptions.ENABLE_BZLMOD, false)
             .build();
     assertThat(Starlark.str(Label.parseCanonical("//x"), semantics)).isEqualTo("//x:x");
     assertThat(Starlark.str(Label.parseCanonical("@x//y"), semantics)).isEqualTo("@x//y:y");
   }

   @Test
   public void starlarkStr_canonicalLabelLiteral() throws Exception {
     StarlarkSemantics semantics =
         StarlarkSemantics.builder().setBool(BuildLanguageOptions.ENABLE_BZLMOD, true).build();
     assertThat(Starlark.str(Label.parseCanonical("//x"), semantics)).isEqualTo("@@//x:x");
     assertThat(Starlark.str(Label.parseCanonical("@x//y"), semantics)).isEqualTo("@@x//y:y");
   }

   @Test
   public void starlarkStr_ambiguousAndCanonicalLabelLiteral() throws Exception {
     StarlarkSemantics semantics =
         StarlarkSemantics.builder()
             .setBool(BuildLanguageOptions.INCOMPATIBLE_UNAMBIGUOUS_LABEL_STRINGIFICATION, false)
             .setBool(BuildLanguageOptions.ENABLE_BZLMOD, true)
             .build();
     assertThat(Starlark.str(Label.parseCanonical("//x"), semantics)).isEqualTo("//x:x");
     assertThat(Starlark.str(Label.parseCanonical("@x//y"), semantics)).isEqualTo("@@x//y:y");
   }

   @Test
   public void parseWithPackageContext_recordingRepoMapping() throws Exception {
     RepositoryName foo = RepositoryName.createUnvalidated("foo");
     RepositoryName bar = RepositoryName.createUnvalidated("bar");
     RepositoryName quux = RepositoryName.createUnvalidated("quux");
     PackageContext fooPackageContext =
         PackageContext.of(
             PackageIdentifier.create(foo, PathFragment.create("hah")),
             RepositoryMapping.create(ImmutableMap.of("bar", quux, "quux", bar), foo));
     PackageContext barPackageContext =
         PackageContext.of(
             PackageIdentifier.create(bar, PathFragment.EMPTY_FRAGMENT),
             RepositoryMapping.create(ImmutableMap.of("foo", quux, "quux", foo), bar));

     RepoMappingRecorder recorder = new RepoMappingRecorder();
     // Not recorded: no repo part
     var unused = Label.parseWithPackageContext("//foo/bar", fooPackageContext, recorder);
     // Recorded: <foo, bar, quux>
     unused = Label.parseWithPackageContext("@bar//foo/bar", fooPackageContext, recorder);
     // Recorded: <bar, quux, foo>
     unused = Label.parseWithPackageContext("@quux//foo/bar", barPackageContext, recorder);
     // Recorded: <bar, foo, quux>
     unused = Label.parseWithPackageContext("@foo//foo/bar", barPackageContext, recorder);
     // Not recorded: canonical repo name
     unused = Label.parseWithPackageContext("@@quux//foo/bar", fooPackageContext, recorder);

     // Recorded entries are sorted by row and then column
     assertThat(recorder.recordedEntries().cellSet())
         .containsExactly(
             Tables.immutableCell(bar, "foo", quux),
             Tables.immutableCell(bar, "quux", foo),
             Tables.immutableCell(foo, "bar", quux))
         .inOrder();
   }
 }
	// 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.cmdline;

	import static com.google.common.truth.Truth.assertThat;
	import static org.junit.Assert.assertThrows;

	import com.google.common.collect.ImmutableMap;
	import com.google.common.collect.Tables;
	import com.google.common.testing.EqualsTester;
	import com.google.devtools.build.lib.cmdline.Label.PackageContext;
	import com.google.devtools.build.lib.cmdline.Label.RepoContext;
	import com.google.devtools.build.lib.cmdline.Label.RepoMappingRecorder;
	import com.google.devtools.build.lib.packages.semantics.BuildLanguageOptions;
	import com.google.devtools.build.lib.vfs.PathFragment;
	import java.util.regex.Pattern;
	import net.starlark.java.eval.Starlark;
	import net.starlark.java.eval.StarlarkSemantics;
	import org.junit.Test;
	import org.junit.runner.RunWith;
	import org.junit.runners.JUnit4;

	/** Tests for {@link Label}. */
	@RunWith(JUnit4.class)
	public class LabelTest {

	private static final String INVALID_TARGET_NAME = "invalid target name";
	private static final String INVALID_PACKAGE_NAME = "invalid package name";

	@Test
	public void testAbsolute() throws Exception {
	{
	Label l = Label.parseCanonical("//foo/bar:baz");
	assertThat(l.getPackageName()).isEqualTo("foo/bar");
	assertThat(l.getName()).isEqualTo("baz");
	}
	{
	Label l = Label.parseCanonical("//foo/bar");
	assertThat(l.getPackageName()).isEqualTo("foo/bar");
	assertThat(l.getName()).isEqualTo("bar");
	}
	{
	Label l = Label.parseCanonical("//:bar");
	assertThat(l.getPackageName()).isEmpty();
	assertThat(l.getName()).isEqualTo("bar");
	}
	{
	Label l = Label.parseCanonical("@foo");
	assertThat(l.getRepository().getName()).isEqualTo("foo");
	assertThat(l.getPackageName()).isEmpty();
	assertThat(l.getName()).isEqualTo("foo");
	}
	{
	Label l = Label.parseCanonical("@foo//bar");
	assertThat(l.getRepository().getName()).isEqualTo("foo");
	assertThat(l.getPackageName()).isEqualTo("bar");
	assertThat(l.getName()).isEqualTo("bar");
	}
	{
	Label l = Label.parseCanonical("@@foo//bar");
	assertThat(l.getRepository().getName()).isEqualTo("foo");
	assertThat(l.getPackageName()).isEqualTo("bar");
	assertThat(l.getName()).isEqualTo("bar");
	}
	{
	Label l = Label.parseCanonical("//@foo");
	assertThat(l.getRepository()).isEqualTo(RepositoryName.MAIN);
	assertThat(l.getPackageName()).isEqualTo("@foo");
	assertThat(l.getName()).isEqualTo("@foo");
	}
	{
	Label l = Label.parseCanonical("//xyz/@foo:abc");
	assertThat(l.getRepository()).isEqualTo(RepositoryName.MAIN);
	assertThat(l.getPackageName()).isEqualTo("xyz/@foo");
	assertThat(l.getName()).isEqualTo("abc");
	}
	}

	@Test
	public void parseWithRepoContext() throws Exception {
	RepositoryName foo = RepositoryName.createUnvalidated("foo");
	RepositoryName bar = RepositoryName.createUnvalidated("bar");
	RepositoryName quux = RepositoryName.createUnvalidated("quux");
	RepoContext repoContext =
	RepoContext.of(foo, RepositoryMapping.create(ImmutableMap.of("bar", quux), foo));
	{
	Label l = Label.parseWithRepoContext("//lol:kek", repoContext);
	assertThat(l.getRepository()).isEqualTo(foo);
	assertThat(l.getPackageName()).isEqualTo("lol");
	assertThat(l.getName()).isEqualTo("kek");
	}
	{
	Label l = Label.parseWithRepoContext("@bar//lol:kek", repoContext);
	assertThat(l.getRepository()).isEqualTo(quux);
	assertThat(l.getPackageName()).isEqualTo("lol");
	assertThat(l.getName()).isEqualTo("kek");
	}
	{
	Label l = Label.parseWithRepoContext("@@bar//lol:kek", repoContext);
	assertThat(l.getRepository()).isEqualTo(bar);
	assertThat(l.getPackageName()).isEqualTo("lol");
	assertThat(l.getName()).isEqualTo("kek");
	}
	{
	Label l = Label.parseWithRepoContext("@quux//lol:kek", repoContext);
	assertThat(l.getRepository()).isEqualTo(quux.toNonVisible(foo));
	assertThat(l.getPackageName()).isEqualTo("lol");
	assertThat(l.getName()).isEqualTo("kek");
	}
	}

	@Test
	public void parseWithPackageContext() throws Exception {
	RepositoryName foo = RepositoryName.createUnvalidated("foo");
	RepositoryName bar = RepositoryName.createUnvalidated("bar");
	RepositoryName quux = RepositoryName.createUnvalidated("quux");
	PackageContext packageContext =
	PackageContext.of(
	PackageIdentifier.create(foo, PathFragment.create("hah")),
	RepositoryMapping.create(ImmutableMap.of("bar", quux), foo));
	{
	Label l = Label.parseWithPackageContext(":kek", packageContext);
	assertThat(l.getRepository()).isEqualTo(foo);
	assertThat(l.getPackageName()).isEqualTo("hah");
	assertThat(l.getName()).isEqualTo("kek");
	}
	{
	Label l = Label.parseWithPackageContext("//lol:kek", packageContext);
	assertThat(l.getRepository()).isEqualTo(foo);
	assertThat(l.getPackageName()).isEqualTo("lol");
	assertThat(l.getName()).isEqualTo("kek");
	}
	{
	Label l = Label.parseWithPackageContext("@bar//lol:kek", packageContext);
	assertThat(l.getRepository()).isEqualTo(quux);
	assertThat(l.getPackageName()).isEqualTo("lol");
	assertThat(l.getName()).isEqualTo("kek");
	}
	{
	Label l = Label.parseWithPackageContext("@@bar//lol:kek", packageContext);
	assertThat(l.getRepository()).isEqualTo(bar);
	assertThat(l.getPackageName()).isEqualTo("lol");
	assertThat(l.getName()).isEqualTo("kek");
	}
	{
	Label l = Label.parseWithPackageContext("@quux//lol:kek", packageContext);
	assertThat(l.getRepository()).isEqualTo(quux.toNonVisible(foo));
	assertThat(l.getPackageName()).isEqualTo("lol");
	assertThat(l.getName()).isEqualTo("kek");
	}
	}

	@Test
	public void testFactory() throws Exception {
	Label l = Label.create("foo/bar", "quux");
	assertThat(l.getPackageName()).isEqualTo("foo/bar");
	assertThat(l.getName()).isEqualTo("quux");
	}

	@Test
	public void testIdentities() throws Exception {

	Label l1 = Label.parseCanonical("//foo/bar:baz");
	Label l2 = Label.parseCanonical("//foo/bar:baz");
	Label l3 = Label.parseCanonical("//foo/bar:quux");

	new EqualsTester().addEqualityGroup(l1, l2).addEqualityGroup(l3).testEquals();
	}

	@Test
	public void testToString() throws Exception {
	{
	String s = "@//foo/bar:baz";
	Label l = Label.parseCanonical(s);
	assertThat(l.toString()).isEqualTo("//foo/bar:baz");
	}
	{
	Label l = Label.parseCanonical("//foo/bar");
	assertThat(l.toString()).isEqualTo("//foo/bar:bar");
	}
	{
	Label l = Label.parseCanonical("@foo");
	assertThat(l.toString()).isEqualTo("@@foo//:foo");
	}
	}

	@Test
	public void testDotDot() throws Exception {
	Label.parseCanonical("//foo/bar:baz..gif");
	}

	/**
	* Asserts that creating a label throws a SyntaxException.
	*
	* @param label the label to create.
	*/
	private static void assertSyntaxError(String expectedError, String label) {
	LabelSyntaxException e =
	assertThrows(
	"Label '" + label + "' did not contain a syntax error, but was expected to",
	LabelSyntaxException.class,
	() -> Label.parseCanonical(label));
	assertThat(e).hasMessageThat().containsMatch(Pattern.quote(expectedError));
	}

	@Test
	public void testBadCharacters() throws Exception {
	assertSyntaxError("target names may not contain ':'", "//foo:bar:baz");
	assertSyntaxError("target names may not contain ':'", "//foo:bar:");
	assertSyntaxError("target names may not contain ':'", "//foo/bar::");
	}

	@Test
	public void testUplevelReferences() throws Exception {
	assertSyntaxError(INVALID_PACKAGE_NAME, "//foo/bar/..:baz");
	assertSyntaxError(INVALID_PACKAGE_NAME, "//foo/../baz:baz");
	assertSyntaxError(INVALID_PACKAGE_NAME, "//../bar/baz:baz");
	assertSyntaxError(INVALID_PACKAGE_NAME, "//..:foo");
	assertSyntaxError(INVALID_TARGET_NAME, "//foo:bar/../baz");
	assertSyntaxError(INVALID_TARGET_NAME, "//foo:../bar/baz");
	assertSyntaxError(INVALID_TARGET_NAME, "//foo:bar/baz/..");
	assertSyntaxError(INVALID_TARGET_NAME, "//foo:..");
	}

	@Test
	public void testDotAsAPathSegment() throws Exception {
	assertSyntaxError(INVALID_PACKAGE_NAME, "//foo/bar/.:baz");
	assertSyntaxError(INVALID_PACKAGE_NAME, "//foo/./baz:baz");
	assertSyntaxError(INVALID_PACKAGE_NAME, "//./bar/baz:baz");
	assertSyntaxError(INVALID_TARGET_NAME, "//foo:bar/./baz");
	assertSyntaxError(INVALID_TARGET_NAME, "//foo:./bar/baz");
	// TODO(bazel-team): enable when we have removed the "Workaround" in Label
	// that rewrites broken Labels by removing the trailing '.'
	// assertSyntaxError(INVALID_PACKAGE_NAME,
	// "//foo:bar/baz/.");
	// assertSyntaxError(INVALID_PACKAGE_NAME,
	// "//foo:.");
	}

	@Test
	public void testTrailingDotSegment() throws Exception {
	assertThat(Label.parseCanonical("//foo:dir")).isEqualTo(Label.parseCanonical("//foo:dir/."));
	}

	@Test
	public void testSomeOtherBadLabels() throws Exception {
	assertSyntaxError("package names may not end with '/'", "//foo/:bar");
	assertSyntaxError("package names may not start with '/'", "///p:foo");
	assertSyntaxError("package names may not contain '//' path separators", "//a//b:foo");
	}

	@Test
	public void testSomeGoodLabels() throws Exception {
	Label.parseCanonical("//foo:..bar");
	Label.parseCanonical("//Foo:..bar");
	Label.parseCanonical("//-Foo:..bar");
	Label.parseCanonical("//00:..bar");
	Label.parseCanonical("//package:foo+bar");
	Label.parseCanonical("//package:foo_bar");
	Label.parseCanonical("//package:foo=bar");
	Label.parseCanonical("//package:foo-bar");
	Label.parseCanonical("//package:foo.bar");
	Label.parseCanonical("//package:foo@bar");
	Label.parseCanonical("//package:foo~bar");
	Label.parseCanonical("//$( ):$( )");
	}

	@Test
	public void testDoubleSlashPathSeparator() throws Exception {
	assertSyntaxError("package names may not contain '//' path separators", "//foo//bar:baz");
	assertSyntaxError("target names may not contain '//' path separator", "//foo:bar//baz");
	}

	@Test
	public void testNonPrintableCharacters() throws Exception {
	assertSyntaxError(
	"target names may not contain non-printable characters: '\\x02'", "//foo:..\002bar");
	}

	/** Make sure that control characters - such as CR - are escaped on output. */
	@Test
	public void testInvalidLineEndings() throws Exception {
	assertSyntaxError(
	"invalid target name '..bar\\r': " + "target names may not end with carriage returns",
	"//foo:..bar\r");
	}

	@Test
	public void testEmptyName() throws Exception {
	assertSyntaxError("invalid target name '': empty target name", "//foo/bar:");
	}

	@Test
	public void testRepoLabel() throws Exception {
	Label label = Label.parseCanonical("@foo//bar/baz:bat/boo");
	assertThat(label.toString()).isEqualTo("@@foo//bar/baz:bat/boo");
	}

	@Test
	public void testNoRepo() throws Exception {
	Label label = Label.parseCanonical("//bar/baz:bat/boo");
	assertThat(label.toString()).isEqualTo("//bar/baz:bat/boo");
	}

	@Test
	public void testInvalidRepo() throws Exception {
	LabelSyntaxException e =
	assertThrows(
	LabelSyntaxException.class, () -> Label.parseCanonical("foo//bar/baz:bat/boo"));
	assertThat(e)
	.hasMessageThat()
	.isEqualTo(
	"invalid package name 'foo//bar/baz': package names may not contain '//' path"
	+ " separators");
	}

	@Test
	public void testInvalidRepoWithColon() throws Exception {
	LabelSyntaxException e =
	assertThrows(LabelSyntaxException.class, () -> Label.parseCanonical("@foo:xyz"));
	assertThat(e)
	.hasMessageThat()
	.containsMatch("invalid repository name 'foo:xyz': repo names may contain only");
	}

	@Test
	public void testGetWorkspaceRoot() throws Exception {
	Label label = Label.parseCanonical("//bar/baz");
	assertThat(label.getWorkspaceRootForStarlarkOnly(StarlarkSemantics.DEFAULT)).isEmpty();
	label = Label.parseCanonical("@repo//bar/baz");
	assertThat(label.getWorkspaceRootForStarlarkOnly(StarlarkSemantics.DEFAULT))
	.isEqualTo("external/repo");
	}

	@Test
	public void testGetContainingDirectory() {
	assertThat(Label.getContainingDirectory(Label.parseCanonicalUnchecked("//a:b")))
	.isEqualTo(PathFragment.create("a"));
	assertThat(Label.getContainingDirectory(Label.parseCanonicalUnchecked("//a/b:c")))
	.isEqualTo(PathFragment.create("a/b"));
	assertThat(Label.getContainingDirectory(Label.parseCanonicalUnchecked("//a:b/c")))
	.isEqualTo(PathFragment.create("a/b"));
	assertThat(Label.getContainingDirectory(Label.parseCanonicalUnchecked("//a/b/c")))
	.isEqualTo(PathFragment.create("a/b/c"));
	}

	@Test
	public void testWorkspaceName() throws Exception {
	assertThat(Label.parseCanonical("@foo//bar:baz").getWorkspaceName()).isEqualTo("foo");
	assertThat(Label.parseCanonical("//bar:baz").getWorkspaceName()).isEmpty();
	assertThat(Label.parseCanonical("@//bar:baz").getWorkspaceName()).isEmpty();
	}

	@Test
	public void testUnambiguousCanonicalForm() throws Exception {
	assertThat(Label.parseCanonical("//foo/bar:baz").getUnambiguousCanonicalForm())
	.isEqualTo("@@//foo/bar:baz");
	assertThat(Label.parseCanonical("@foo//bar:baz").getUnambiguousCanonicalForm())
	.isEqualTo("@@foo//bar:baz");
	assertThat(
	Label.create(
	PackageIdentifier.create(
	RepositoryName.create("foo").toNonVisible(RepositoryName.create("bar")),
	PathFragment.create("baz")),
	"quux")
	.getUnambiguousCanonicalForm())
	.isEqualTo("@@[unknown repo 'foo' requested from @@bar]//baz:quux");
	}

	private static String displayFormFor(String rawLabel, RepositoryMapping repositoryMapping)
	throws Exception {
	return Label.parseCanonical(rawLabel).getDisplayForm(repositoryMapping);
	}

	@Test
	public void testDisplayForm() throws Exception {
	RepositoryName canonicalName = RepositoryName.create("canonical");
	RepositoryMapping repositoryMapping =
	RepositoryMapping.create(
	ImmutableMap.of("", RepositoryName.MAIN, "local", canonicalName), RepositoryName.MAIN);

	assertThat(displayFormFor("//foo/bar:bar", repositoryMapping)).isEqualTo("//foo/bar:bar");
	assertThat(displayFormFor("//foo/bar:baz", repositoryMapping)).isEqualTo("//foo/bar:baz");

	assertThat(displayFormFor("@canonical//bar:bar", repositoryMapping))
	.isEqualTo("@local//bar:bar");
	assertThat(displayFormFor("@canonical//bar:baz", repositoryMapping))
	.isEqualTo("@local//bar:baz");
	assertThat(displayFormFor("@canonical//:canonical", repositoryMapping))
	.isEqualTo("@local//:canonical");
	assertThat(displayFormFor("@canonical//:local", repositoryMapping)).isEqualTo("@local//:local");

	assertThat(displayFormFor("@other//bar:bar", repositoryMapping)).isEqualTo("@@other//bar:bar");
	assertThat(displayFormFor("@other//bar:baz", repositoryMapping)).isEqualTo("@@other//bar:baz");
	assertThat(displayFormFor("@other//:other", repositoryMapping)).isEqualTo("@@other//:other");
	assertThat(displayFormFor("@@other", repositoryMapping)).isEqualTo("@@other//:other");

	assertThat(
	Label.parseWithRepoContext(
	"@bad//abc", RepoContext.of(RepositoryName.MAIN, repositoryMapping))
	.getDisplayForm(repositoryMapping))
	.isEqualTo("@@[unknown repo 'bad' requested from @@]//abc:abc");

	assertThat(displayFormFor("@unremapped//:unremapped", RepositoryMapping.ALWAYS_FALLBACK))
	.isEqualTo("@unremapped//:unremapped");
	assertThat(displayFormFor("@unremapped", RepositoryMapping.ALWAYS_FALLBACK))
	.isEqualTo("@unremapped//:unremapped");
	}

	private static String shorthandDisplayFormFor(
	String rawLabel, RepositoryMapping repositoryMapping) throws Exception {
	return Label.parseCanonical(rawLabel).getShorthandDisplayForm(repositoryMapping);
	}

	@Test
	public void testShorthandDisplayForm() throws Exception {
	RepositoryName canonicalName = RepositoryName.create("canonical");
	RepositoryMapping repositoryMapping =
	RepositoryMapping.create(
	ImmutableMap.of("", RepositoryName.MAIN, "local", canonicalName), RepositoryName.MAIN);

	assertThat(shorthandDisplayFormFor("//foo/bar:bar", repositoryMapping)).isEqualTo("//foo/bar");
	assertThat(shorthandDisplayFormFor("//foo/bar:baz", repositoryMapping))
	.isEqualTo("//foo/bar:baz");

	assertThat(shorthandDisplayFormFor("@canonical//bar:bar", repositoryMapping))
	.isEqualTo("@local//bar");
	assertThat(shorthandDisplayFormFor("@canonical//bar:baz", repositoryMapping))
	.isEqualTo("@local//bar:baz");
	assertThat(shorthandDisplayFormFor("@canonical//:canonical", repositoryMapping))
	.isEqualTo("@local//:canonical");
	assertThat(shorthandDisplayFormFor("@canonical//:local", repositoryMapping))
	.isEqualTo("@local");

	assertThat(shorthandDisplayFormFor("@other//bar:bar", repositoryMapping))
	.isEqualTo("@@other//bar");
	assertThat(shorthandDisplayFormFor("@other//bar:baz", repositoryMapping))
	.isEqualTo("@@other//bar:baz");
	assertThat(shorthandDisplayFormFor("@other//:other", repositoryMapping)).isEqualTo("@@other");
	assertThat(shorthandDisplayFormFor("@@other", repositoryMapping)).isEqualTo("@@other");

	assertThat(
	Label.parseWithRepoContext(
	"@bad//abc", RepoContext.of(RepositoryName.MAIN, repositoryMapping))
	.getShorthandDisplayForm(repositoryMapping))
	.isEqualTo("@@[unknown repo 'bad' requested from @@]//abc");

	assertThat(
	shorthandDisplayFormFor("@unremapped//:unremapped", RepositoryMapping.ALWAYS_FALLBACK))
	.isEqualTo("@unremapped");
	assertThat(shorthandDisplayFormFor("@unremapped", RepositoryMapping.ALWAYS_FALLBACK))
	.isEqualTo("@unremapped");
	}

	@Test
	public void starlarkStrAndRepr() throws Exception {
	Label label = Label.parseCanonical("//x");
	assertThat(Starlark.str(label, StarlarkSemantics.DEFAULT)).isEqualTo("@@//x:x");
	assertThat(Starlark.repr(label)).isEqualTo("Label(\"//x:x\")");

	label = Label.parseCanonical("@hello//x");
	assertThat(Starlark.str(label, StarlarkSemantics.DEFAULT)).isEqualTo("@@hello//x:x");
	assertThat(Starlark.repr(label)).isEqualTo("Label(\"@@hello//x:x\")");
	}

	@Test
	public void starlarkStr_ambiguous() throws Exception {
	StarlarkSemantics semantics =
	StarlarkSemantics.builder()
	.setBool(BuildLanguageOptions.INCOMPATIBLE_UNAMBIGUOUS_LABEL_STRINGIFICATION, false)
	.setBool(BuildLanguageOptions.ENABLE_BZLMOD, false)
	.build();
	assertThat(Starlark.str(Label.parseCanonical("//x"), semantics)).isEqualTo("//x:x");
	assertThat(Starlark.str(Label.parseCanonical("@x//y"), semantics)).isEqualTo("@x//y:y");
	}

	@Test
	public void starlarkStr_canonicalLabelLiteral() throws Exception {
	StarlarkSemantics semantics =
	StarlarkSemantics.builder().setBool(BuildLanguageOptions.ENABLE_BZLMOD, true).build();
	assertThat(Starlark.str(Label.parseCanonical("//x"), semantics)).isEqualTo("@@//x:x");
	assertThat(Starlark.str(Label.parseCanonical("@x//y"), semantics)).isEqualTo("@@x//y:y");
	}

	@Test
	public void starlarkStr_ambiguousAndCanonicalLabelLiteral() throws Exception {
	StarlarkSemantics semantics =
	StarlarkSemantics.builder()
	.setBool(BuildLanguageOptions.INCOMPATIBLE_UNAMBIGUOUS_LABEL_STRINGIFICATION, false)
	.setBool(BuildLanguageOptions.ENABLE_BZLMOD, true)
	.build();
	assertThat(Starlark.str(Label.parseCanonical("//x"), semantics)).isEqualTo("//x:x");
	assertThat(Starlark.str(Label.parseCanonical("@x//y"), semantics)).isEqualTo("@@x//y:y");
	}

	@Test
	public void parseWithPackageContext_recordingRepoMapping() throws Exception {
	RepositoryName foo = RepositoryName.createUnvalidated("foo");
	RepositoryName bar = RepositoryName.createUnvalidated("bar");
	RepositoryName quux = RepositoryName.createUnvalidated("quux");
	PackageContext fooPackageContext =
	PackageContext.of(
	PackageIdentifier.create(foo, PathFragment.create("hah")),
	RepositoryMapping.create(ImmutableMap.of("bar", quux, "quux", bar), foo));
	PackageContext barPackageContext =
	PackageContext.of(
	PackageIdentifier.create(bar, PathFragment.EMPTY_FRAGMENT),
	RepositoryMapping.create(ImmutableMap.of("foo", quux, "quux", foo), bar));

	RepoMappingRecorder recorder = new RepoMappingRecorder();
	// Not recorded: no repo part
	var unused = Label.parseWithPackageContext("//foo/bar", fooPackageContext, recorder);
	// Recorded: <foo, bar, quux>
	unused = Label.parseWithPackageContext("@bar//foo/bar", fooPackageContext, recorder);
	// Recorded: <bar, quux, foo>
	unused = Label.parseWithPackageContext("@quux//foo/bar", barPackageContext, recorder);
	// Recorded: <bar, foo, quux>
	unused = Label.parseWithPackageContext("@foo//foo/bar", barPackageContext, recorder);
	// Not recorded: canonical repo name
	unused = Label.parseWithPackageContext("@@quux//foo/bar", fooPackageContext, recorder);

	// Recorded entries are sorted by row and then column
	assertThat(recorder.recordedEntries().cellSet())
	.containsExactly(
	Tables.immutableCell(bar, "foo", quux),
	Tables.immutableCell(bar, "quux", foo),
	Tables.immutableCell(foo, "bar", quux))
	.inOrder();
	}
	}