New SkyFunction: PathCasingLookupFunction
The new PathCasingLookupFunction is a SkyFunction
that can validate the casing of a path.
On case-insensitive filesystems if "foo/BUILD"
exists then "FOO/BUILD" also exists (because they
mean the same file), but this should not imply
that the "//foo" and "//FOO" packages both exist.
The new SkyFunction can validate whether
"FOO/BUILD" is the correct casing. The casing is
correct if the file's name in its parent
directory's listing is exactly the same
(case-sensitively) as the expected name.
In a later PR we can change the
PackageLookupFunction to deny loading if the path
is not correctly cased.
Motivation: https://github.com/bazelbuild/bazel/issues/8799
Change-Id: Ibb2a5f4f6c6041bdfc537b33d0c6fc55e568b998
Closes #10362.
Change-Id: Ie25b9b202a1aef3b2594064b4842fc0f2fb2776b
PiperOrigin-RevId: 283939452
diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/PathCasingLookupFunction.java b/src/main/java/com/google/devtools/build/lib/skyframe/PathCasingLookupFunction.java
new file mode 100644
index 0000000..644fe24
--- /dev/null
+++ b/src/main/java/com/google/devtools/build/lib/skyframe/PathCasingLookupFunction.java
@@ -0,0 +1,116 @@
+// Copyright 2019 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.skyframe;
+
+import com.google.common.base.Preconditions;
+import com.google.common.base.Strings;
+import com.google.common.collect.ImmutableList;
+import com.google.devtools.build.lib.actions.FileValue;
+import com.google.devtools.build.lib.vfs.Dirent;
+import com.google.devtools.build.lib.vfs.RootedPath;
+import com.google.devtools.build.lib.vfs.RootedPathAndCasing;
+import com.google.devtools.build.skyframe.SkyFunction;
+import com.google.devtools.build.skyframe.SkyFunctionException;
+import com.google.devtools.build.skyframe.SkyKey;
+import com.google.devtools.build.skyframe.SkyValue;
+import java.io.IOException;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+/** SkyFunction for {@link PathCasingLookupValue}s. */
+public final class PathCasingLookupFunction implements SkyFunction {
+
+ @Override
+ public PathCasingLookupValue compute(SkyKey skyKey, Environment env)
+ throws PathComponentIsNotDirectoryException, InterruptedException {
+ RootedPathAndCasing arg = (RootedPathAndCasing) skyKey.argument();
+ if (arg.getPath().getRootRelativePath().isEmpty()) {
+ // This is a Root, e.g. "[/foo/bar]/[]".
+ // As of 2019-12-04, PathCasingLookupValue is not used anywhere. But it's planned to be used
+ // in PackageLookupFunction to validate the package part's casing, so the RootedPath's Root's
+ // casing doesn't even matter, so if the relative part is empty then for our use case this is
+ // a correctly cased RootedPath.
+ return PathCasingLookupValue.GOOD;
+ }
+
+ RootedPath parent = arg.getPath().getParentDirectory();
+ Preconditions.checkNotNull(parent, arg.getPath());
+ Preconditions.checkNotNull(parent.getRootRelativePath(), arg.getPath());
+
+ SkyKey parentCasingKey = PathCasingLookupValue.key(parent);
+ SkyKey parentFileKey = FileValue.key(parent);
+ SkyKey childFileKey = FileValue.key(arg.getPath());
+ Map<SkyKey, SkyValue> values =
+ env.getValues(ImmutableList.of(parentCasingKey, parentFileKey, childFileKey));
+ if (env.valuesMissing()) {
+ return null;
+ }
+ if (!((PathCasingLookupValue) values.get(parentCasingKey)).isCorrect()) {
+ // Parent's casing is bad, so this path's casing is also bad.
+ return PathCasingLookupValue.BAD;
+ }
+
+ FileValue parentFile = (FileValue) values.get(parentFileKey);
+ if (!parentFile.exists()) {
+ // Parent's casing is good, because it's missing.
+ // That means this path is also missing, so by definition its casing is good.
+ return PathCasingLookupValue.GOOD;
+ }
+ if (!parentFile.isDirectory()) {
+ // Parent's casing is good, but it's not a directory.
+ throw new PathComponentIsNotDirectoryException(
+ new IOException(
+ "Cannot check path casing of "
+ + arg.getPath()
+ + ": its parent exists but is not a directory"));
+ }
+
+ FileValue childFile = (FileValue) values.get(childFileKey);
+ if (!childFile.exists()) {
+ // Parent's casing is good, but this file is missing.
+ // That means this path is missing, so by definition its casing is good.
+ return PathCasingLookupValue.GOOD;
+ }
+
+ // The parent file must exist, otherwise the DirectoryListingFunction will throw.
+ SkyKey parentListingKey = DirectoryListingValue.key(parent);
+ DirectoryListingValue parentList = (DirectoryListingValue) env.getValue(parentListingKey);
+ if (parentList == null) {
+ return null;
+ }
+
+ String expected = arg.getPath().getRootRelativePath().getBaseName();
+ // We already handled RootedPaths with empty relative part.
+ Preconditions.checkState(!Strings.isNullOrEmpty(expected), arg.getPath());
+
+ Dirent child = parentList.getDirents().maybeGetDirent(expected);
+ return (child != null && expected.equals(child.getName()))
+ ? PathCasingLookupValue.GOOD
+ : PathCasingLookupValue.BAD;
+ }
+
+ @Nullable
+ @Override
+ public String extractTag(SkyKey skyKey) {
+ return null;
+ }
+
+ /** Thrown if a non-terminal path component exists, but it's not a directory. */
+ public static final class PathComponentIsNotDirectoryException extends SkyFunctionException {
+ public PathComponentIsNotDirectoryException(IOException e) {
+ super(e, Transience.PERSISTENT);
+ }
+ }
+}
diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/PathCasingLookupValue.java b/src/main/java/com/google/devtools/build/lib/skyframe/PathCasingLookupValue.java
new file mode 100644
index 0000000..0248da7
--- /dev/null
+++ b/src/main/java/com/google/devtools/build/lib/skyframe/PathCasingLookupValue.java
@@ -0,0 +1,115 @@
+// Copyright 2019 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.skyframe;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Interner;
+import com.google.devtools.build.lib.concurrent.BlazeInterners;
+import com.google.devtools.build.lib.skyframe.serialization.autocodec.AutoCodec;
+import com.google.devtools.build.lib.vfs.RootedPath;
+import com.google.devtools.build.lib.vfs.RootedPathAndCasing;
+import com.google.devtools.build.skyframe.AbstractSkyKey;
+import com.google.devtools.build.skyframe.SkyFunctionName;
+import com.google.devtools.build.skyframe.SkyKey;
+import com.google.devtools.build.skyframe.SkyValue;
+
+/**
+ * Value that represents whether a certain path is correctly cased.
+ *
+ * <p>Most filesystems preserve uppercase and lowercase letters when creating entries: {@code
+ * mkdir("Abc1")} creates the directory "Abc1", and not "ABC1" nor "abc1".
+ *
+ * <p>Some filesystems differentiate casing when looking up entries, but some don't. Suppose we have
+ * an empty directory and create the file "Abc1" underneath it. Then, calling {@code exists("Abc1")}
+ * succeeds and {@code exists("ABC1")} fails on ext4 (Linux) but both calls succeed on APFS (macOS)
+ * and NTFS (Windows). Reason for this difference is that ext4 is case-sensitive, so "Abc1" and
+ * "ABC1" mean different files, but APFS and NTFS are case-ignoring (or case-insensitive), so both
+ * paths mean the same file.
+ *
+ * <p>This object represents whether an existing path on a case-ignoring filesystem (APFS and NTFS)
+ * is correctly or incorrectly cased, i.e. whether the exact use of upper and lower case letters
+ * matches the entry on disk. In the previous example, "Abc1" is correctly cased while "ABC1" is
+ * incorrectly cased.
+ *
+ * <p>Paths on case-sensitive filesystems (ext4) are always correctly cased, because the filesystem
+ * requires exact case matching when accessing files.
+ */
+public abstract class PathCasingLookupValue implements SkyValue {
+
+ @AutoCodec public static final BadPathCasing BAD = new BadPathCasing();
+
+ @AutoCodec public static final CorrectPathCasing GOOD = new CorrectPathCasing();
+
+ /** Singleton {@link PathCasingLookupValue} instance for incorrectly cased paths. */
+ public static class BadPathCasing extends PathCasingLookupValue {
+ @Override
+ public boolean isCorrect() {
+ return false;
+ }
+ }
+
+ /** Singleton {@link PathCasingLookupValue} instance for correctly cased paths. */
+ public static class CorrectPathCasing extends PathCasingLookupValue {
+ @Override
+ public boolean isCorrect() {
+ return true;
+ }
+ }
+
+ /**
+ * Creates a {@code SkyKey} to request this {@code PathCasingLookupValue} from Skyframe.
+ *
+ * <p>The argument is a {@link RootedPath} and not a {@link Path} for two reasons:
+ *
+ * <ul>
+ * <li>as of 2019-12-04 the {@code PathCasingLookupFunction} depends on {@code
+ * DirectoryListingValue} whose {@code SkyKey} requires a {@code RootedPath}
+ * <li>as of 2019-12-04 the {@code PathCasingLookupValue} is only used to validate that a
+ * package label is correctly cased, and package labels are always relative to a package
+ * root, so using a {@code RootedPath} is adequate and the Root part of it doesn't even have
+ * to be correctly cased.
+ * </ul>
+ */
+ public static SkyKey key(RootedPath path) {
+ return Key.create(RootedPathAndCasing.create(path));
+ }
+
+ private PathCasingLookupValue() {}
+
+ public abstract boolean isCorrect();
+
+ /** {@link SkyKey} for {@link PathCasingLookupValue} computation. */
+ @AutoCodec.VisibleForSerialization
+ @AutoCodec
+ public static class Key extends AbstractSkyKey<RootedPathAndCasing> {
+ private static final Interner<Key> interner = BlazeInterners.newWeakInterner();
+
+ private Key(RootedPathAndCasing arg) {
+ super(arg);
+ }
+
+ @AutoCodec.VisibleForSerialization
+ @AutoCodec.Instantiator
+ static Key create(RootedPathAndCasing arg) {
+ Preconditions.checkNotNull(arg);
+ return interner.intern(new Key(arg));
+ }
+
+ @Override
+ public SkyFunctionName functionName() {
+ return SkyFunctions.PATH_CASING_LOOKUP;
+ }
+ }
+}
diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/SkyFunctions.java b/src/main/java/com/google/devtools/build/lib/skyframe/SkyFunctions.java
index 3c732ee..d8f9a1f 100644
--- a/src/main/java/com/google/devtools/build/lib/skyframe/SkyFunctions.java
+++ b/src/main/java/com/google/devtools/build/lib/skyframe/SkyFunctions.java
@@ -107,6 +107,8 @@
public static final SkyFunctionName ACTION_EXECUTION = ActionLookupData.NAME;
public static final SkyFunctionName ARTIFACT_NESTED_SET =
SkyFunctionName.createHermetic("ARTIFACT_NESTED_SET");
+ public static final SkyFunctionName PATH_CASING_LOOKUP =
+ SkyFunctionName.createHermetic("PATH_CASING_LOOKUP");
@VisibleForTesting
public static final SkyFunctionName RECURSIVE_FILESYSTEM_TRAVERSAL =
diff --git a/src/test/java/com/google/devtools/build/lib/BUILD b/src/test/java/com/google/devtools/build/lib/BUILD
index fdc155a..03bd599 100644
--- a/src/test/java/com/google/devtools/build/lib/BUILD
+++ b/src/test/java/com/google/devtools/build/lib/BUILD
@@ -9,6 +9,7 @@
)
# Tests for Windows-specific functionality that can run cross-platform.
+# These don't need to run on Windows, they merely use Windows- and case-insensitive path semantics.
CROSS_PLATFORM_WINDOWS_TESTS = [
"util/DependencySetWindowsTest.java",
"vfs/PathFragmentWindowsTest.java",
diff --git a/src/test/java/com/google/devtools/build/lib/skyframe/BUILD b/src/test/java/com/google/devtools/build/lib/skyframe/BUILD
index b380cac..61db0e4 100644
--- a/src/test/java/com/google/devtools/build/lib/skyframe/BUILD
+++ b/src/test/java/com/google/devtools/build/lib/skyframe/BUILD
@@ -12,6 +12,12 @@
visibility = ["//src/test/java/com/google/devtools/build/lib:__pkg__"],
)
+# Tests for Windows-specific functionality that can run cross-platform.
+# These don't need to run on Windows, they merely use Windows- and case-insensitive path semantics.
+CROSS_PLATFORM_WINDOWS_TESTS = [
+ "PathCasingLookupFunctionTest.java",
+]
+
java_library(
name = "testutil",
srcs = glob([
@@ -53,11 +59,17 @@
java_test(
name = "SkyframeTests",
srcs = select({
- "//src/conditions:darwin": glob(["*.java"]),
- "//src/conditions:darwin_x86_64": glob(["*.java"]),
+ "//src/conditions:darwin": glob(
+ ["*.java"],
+ exclude = CROSS_PLATFORM_WINDOWS_TESTS,
+ ),
+ "//src/conditions:darwin_x86_64": glob(
+ ["*.java"],
+ exclude = CROSS_PLATFORM_WINDOWS_TESTS,
+ ),
"//conditions:default": glob(
["*.java"],
- exclude = ["MacOSXFsEventsDiffAwarenessTest.java"],
+ exclude = ["MacOSXFsEventsDiffAwarenessTest.java"] + CROSS_PLATFORM_WINDOWS_TESTS,
),
}),
shard_count = 20,
@@ -117,6 +129,41 @@
],
)
+# Tests that exercise Windows-specific (or case-insensitive-filesystem specific) functionality.
+# These don't need to run on Windows, they merely use Windows- and case-insensitive path semantics.
+java_test(
+ name = "windows_test",
+ srcs = CROSS_PLATFORM_WINDOWS_TESTS,
+ jvm_flags = [
+ "-Dblaze.os=Windows",
+ "-Dbazel.windows_unix_root=C:/fake/msys",
+ ],
+ tags = ["skyframe"],
+ test_class = "com.google.devtools.build.lib.AllTests",
+ deps = [
+ ":testutil",
+ "//src/main/java/com/google/devtools/build/lib:build-base",
+ "//src/main/java/com/google/devtools/build/lib:events",
+ "//src/main/java/com/google/devtools/build/lib:packages-internal",
+ "//src/main/java/com/google/devtools/build/lib/actions",
+ "//src/main/java/com/google/devtools/build/lib/cmdline",
+ "//src/main/java/com/google/devtools/build/lib/skyframe/serialization",
+ "//src/main/java/com/google/devtools/build/lib/skyframe/serialization/autocodec",
+ "//src/main/java/com/google/devtools/build/lib/skyframe/serialization/testutils",
+ "//src/main/java/com/google/devtools/build/lib/vfs",
+ "//src/main/java/com/google/devtools/build/lib/vfs/inmemoryfs",
+ "//src/main/java/com/google/devtools/build/skyframe",
+ "//src/main/java/com/google/devtools/build/skyframe:skyframe-objects",
+ "//src/test/java/com/google/devtools/build/lib:analysis_testutil",
+ "//src/test/java/com/google/devtools/build/lib:testutil",
+ "//third_party:guava",
+ "//third_party:guava-testlib",
+ "//third_party:jsr305",
+ "//third_party:junit4",
+ "//third_party:truth",
+ ],
+)
+
test_suite(
name = "windows_tests",
tags = [
diff --git a/src/test/java/com/google/devtools/build/lib/skyframe/PathCasingLookupFunctionTest.java b/src/test/java/com/google/devtools/build/lib/skyframe/PathCasingLookupFunctionTest.java
new file mode 100644
index 0000000..0058570
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/skyframe/PathCasingLookupFunctionTest.java
@@ -0,0 +1,228 @@
+// Copyright 2019 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.skyframe;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.collect.ImmutableList;
+import com.google.devtools.build.lib.actions.FileStateValue;
+import com.google.devtools.build.lib.actions.FileValue;
+import com.google.devtools.build.lib.analysis.BlazeDirectories;
+import com.google.devtools.build.lib.analysis.ServerDirectories;
+import com.google.devtools.build.lib.analysis.util.AnalysisMock;
+import com.google.devtools.build.lib.events.NullEventHandler;
+import com.google.devtools.build.lib.pkgcache.PathPackageLocator;
+import com.google.devtools.build.lib.skyframe.ExternalFilesHelper.ExternalFileAction;
+import com.google.devtools.build.lib.testutil.FoundationTestCase;
+import com.google.devtools.build.lib.vfs.Path;
+import com.google.devtools.build.lib.vfs.PathFragment;
+import com.google.devtools.build.lib.vfs.Root;
+import com.google.devtools.build.lib.vfs.RootedPath;
+import com.google.devtools.build.lib.vfs.RootedPathAndCasing;
+import com.google.devtools.build.lib.vfs.UnixGlob;
+import com.google.devtools.build.skyframe.EvaluationContext;
+import com.google.devtools.build.skyframe.EvaluationResult;
+import com.google.devtools.build.skyframe.InMemoryMemoizingEvaluator;
+import com.google.devtools.build.skyframe.RecordingDifferencer;
+import com.google.devtools.build.skyframe.SequencedRecordingDifferencer;
+import com.google.devtools.build.skyframe.SequentialBuildDriver;
+import com.google.devtools.build.skyframe.SkyFunction;
+import com.google.devtools.build.skyframe.SkyFunctionName;
+import com.google.devtools.build.skyframe.SkyKey;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Tests for {@link PathCasingLookupFunction}. */
+@RunWith(JUnit4.class)
+public final class PathCasingLookupFunctionTest extends FoundationTestCase {
+
+ private SequentialBuildDriver driver;
+ private RecordingDifferencer differencer;
+
+ @Before
+ public final void setUp() {
+ AtomicReference<PathPackageLocator> pkgLocator =
+ new AtomicReference<>(
+ new PathPackageLocator(
+ outputBase,
+ ImmutableList.of(Root.fromPath(rootDirectory)),
+ BazelSkyframeExecutorConstants.BUILD_FILES_BY_PRIORITY));
+ BlazeDirectories directories =
+ new BlazeDirectories(
+ new ServerDirectories(rootDirectory, outputBase, rootDirectory),
+ rootDirectory,
+ null,
+ AnalysisMock.get().getProductName());
+ ExternalFilesHelper externalFilesHelper =
+ ExternalFilesHelper.createForTesting(
+ pkgLocator,
+ ExternalFileAction.DEPEND_ON_EXTERNAL_PKG_FOR_EXTERNAL_REPO_PATHS,
+ directories);
+
+ AtomicReference<UnixGlob.FilesystemCalls> syscalls =
+ new AtomicReference<>(UnixGlob.DEFAULT_SYSCALLS);
+ Map<SkyFunctionName, SkyFunction> skyFunctions = new HashMap<>();
+ skyFunctions.put(
+ FileStateValue.FILE_STATE,
+ new FileStateFunction(new AtomicReference<>(), syscalls, externalFilesHelper));
+ skyFunctions.put(FileValue.FILE, new FileFunction(pkgLocator));
+ skyFunctions.put(SkyFunctions.DIRECTORY_LISTING, new DirectoryListingFunction());
+ skyFunctions.put(
+ SkyFunctions.DIRECTORY_LISTING_STATE,
+ new DirectoryListingStateFunction(externalFilesHelper, syscalls));
+ skyFunctions.put(SkyFunctions.PATH_CASING_LOOKUP, new PathCasingLookupFunction());
+
+ differencer = new SequencedRecordingDifferencer();
+ driver =
+ new SequentialBuildDriver(new InMemoryMemoizingEvaluator(skyFunctions, differencer, null));
+ }
+
+ private RootedPath rootedPath(String relative) {
+ return RootedPath.toRootedPath(Root.fromPath(rootDirectory), PathFragment.create(relative));
+ }
+
+ @Test
+ public void testSanityCheckFilesystemIsCaseInsensitive() {
+ Path p1 = rootDirectory.getRelative("Foo/Bar");
+ Path p2 = rootDirectory.getRelative("FOO/BAR");
+ Path p3 = rootDirectory.getRelative("control");
+ assertThat(p1).isNotSameInstanceAs(p2);
+ assertThat(p1).isNotSameInstanceAs(p3);
+ assertThat(p2).isNotSameInstanceAs(p3);
+ assertThat(p1).isEqualTo(p2);
+ assertThat(p1).isNotEqualTo(p3);
+ }
+
+ @Test
+ public void testPathCasingLookup() throws Exception {
+ RootedPath a = rootedPath("Foo/Bar/Baz");
+ RootedPath b = rootedPath("fOO/baR/BAZ");
+ createFile(a);
+ assertThat(a).isEqualTo(b);
+ assertThat(RootedPathAndCasing.create(a)).isNotEqualTo(RootedPathAndCasing.create(b));
+ assertThat(expectEvalSuccess(a).isCorrect()).isTrue();
+ assertThat(expectEvalSuccess(b).isCorrect()).isFalse();
+ }
+
+ @Test
+ public void testNonExistentPath() throws Exception {
+ RootedPath file = rootedPath("Foo/Bar/Baz.txt");
+ createFile(file);
+ RootedPath missing1 = rootedPath("Foo/Bar/x/y");
+ RootedPath missing2 = rootedPath("Foo/BAR/x/y");
+ // Non-existent paths are correct if their existing part is correct.
+ assertThat(expectEvalSuccess(missing1).isCorrect()).isTrue();
+ assertThat(expectEvalSuccess(missing2).isCorrect()).isFalse();
+ // Non-existent paths are illegal if their parent exists but is not a directory.
+ RootedPath bad = rootedPath("Foo/Bar/Baz.txt/x/y");
+ Exception e = expectEvalFailure(bad);
+ assertThat(e).hasMessageThat().contains("its parent exists but is not a directory");
+ }
+
+ @Test
+ public void testNonExistentPathThatComesIntoExistence() throws Exception {
+ RootedPath a = rootedPath("Foo/Bar/Baz");
+ RootedPath b = rootedPath("fOO/baR/BAZ");
+ assertThat(a).isEqualTo(b);
+ // Expecting RootedPath.toRootedPath not to intern instances, otherwise 'a' would be the same
+ // instance as 'b' which would nullify this test.
+ assertThat(a).isNotSameInstanceAs(b);
+ assertThat(a.toString()).isNotEqualTo(b.toString());
+ assertThat(RootedPathAndCasing.create(a)).isNotEqualTo(RootedPathAndCasing.create(b));
+ // Path does not exist, so both casings are correct!
+ assertThat(expectEvalSuccess(a).isCorrect()).isTrue();
+ assertThat(expectEvalSuccess(b).isCorrect()).isTrue();
+ // Path comes into existence.
+ createFile(a);
+ // Now only one casing is correct.
+ assertThat(expectEvalSuccess(a).isCorrect()).isTrue();
+ assertThat(expectEvalSuccess(b).isCorrect()).isFalse();
+ }
+
+ @Test
+ public void testExistingPathThatIsThenDeleted() throws Exception {
+ RootedPath a = rootedPath("Foo/Bar/Baz");
+ RootedPath b = rootedPath("Foo/Bar/BAZ");
+ createFile(a);
+ // Path exists, so only one casing is correct.
+ assertThat(expectEvalSuccess(a).isCorrect()).isTrue();
+ assertThat(expectEvalSuccess(b).isCorrect()).isFalse();
+ // Path no longer exists, both casings are correct.
+ deleteFile(a);
+ assertThat(expectEvalSuccess(a).isCorrect()).isTrue();
+ assertThat(expectEvalSuccess(b).isCorrect()).isTrue();
+ }
+
+ private void createFile(RootedPath p) throws IOException {
+ Path path = p.asPath();
+ if (!path.getParentDirectory().exists()) {
+ scratch.dir(path.getParentDirectory().getPathString());
+ }
+ scratch.file(path.getPathString());
+ invalidateFileAndParents(p);
+ }
+
+ private void deleteFile(RootedPath p) throws IOException {
+ Path path = p.asPath();
+ scratch.deleteFile(path.getPathString());
+ invalidateFileAndParents(p);
+ }
+
+ private EvaluationResult<PathCasingLookupValue> evaluate(SkyKey key) throws Exception {
+ EvaluationContext evaluationContext =
+ EvaluationContext.newBuilder()
+ .setKeepGoing(false)
+ .setNumThreads(SkyframeExecutor.DEFAULT_THREAD_COUNT)
+ .setEventHander(NullEventHandler.INSTANCE)
+ .build();
+ return driver.evaluate(ImmutableList.of(key), evaluationContext);
+ }
+
+ private PathCasingLookupValue expectEvalSuccess(RootedPath path) throws Exception {
+ SkyKey key = PathCasingLookupValue.key(path);
+ EvaluationResult<PathCasingLookupValue> result = evaluate(key);
+ assertThat(result.hasError()).isFalse();
+ return result.get(key);
+ }
+
+ private Exception expectEvalFailure(RootedPath path) throws Exception {
+ SkyKey key = PathCasingLookupValue.key(path);
+ EvaluationResult<PathCasingLookupValue> result = evaluate(key);
+ assertThat(result.hasError()).isTrue();
+ return result.getError().getException();
+ }
+
+ private void invalidateFile(RootedPath path) {
+ differencer.invalidate(ImmutableList.of(FileStateValue.key(path)));
+ }
+
+ private void invalidateDirectory(RootedPath path) {
+ invalidateFile(path);
+ differencer.invalidate(ImmutableList.of(DirectoryListingStateValue.key(path)));
+ }
+
+ private void invalidateFileAndParents(RootedPath p) {
+ invalidateFile(p);
+ do {
+ p = p.getParentDirectory();
+ invalidateDirectory(p);
+ } while (!p.getRootRelativePath().isEmpty());
+ }
+}
