diff --git a/src/test/java/BUILD b/src/test/java/BUILD
new file mode 100644
index 0000000..03b1481
--- /dev/null
+++ b/src/test/java/BUILD
@@ -0,0 +1,168 @@
+java_library(
+    name = "testutil",
+    srcs = glob(["com/google/devtools/build/lib/testutil/*.java"]),
+    visibility = ["//visibility:public"],
+    deps = [
+        "//src/main/java:bazel-core",
+        "//third_party:guava",
+        "//third_party:guava-testlib",
+        "//third_party:junit4",
+        "//third_party:truth",
+    ],
+)
+
+java_test(
+    name = "skyframe_test",
+    srcs = glob([
+        "com/google/devtools/build/skyframe/*.java",
+    ]),
+    args = ["com.google.devtools.build.skyframe.AllTests"],
+    deps = [
+        ":testutil",
+        "//src/main/java:bazel-core",
+        "//third_party:guava",
+        "//third_party:guava-testlib",
+        "//third_party:jsr305",
+        "//third_party:junit4",
+        "//third_party:truth",
+    ],
+)
+
+java_test(
+    name = "options_test",
+    srcs = glob([
+        "com/google/devtools/common/options/*.java",
+    ]),
+    args = ["com.google.devtools.common.options.AllTests"],
+    deps = [
+        ":testutil",
+        "//src/main/java:bazel-core",
+        "//third_party:guava",
+        "//third_party:guava-testlib",
+        "//third_party:junit4",
+        "//third_party:truth",
+    ],
+)
+
+test_prefix = "com/google/devtools/build/lib"
+
+java_library(
+    name = "foundations_testutil",
+    srcs = glob([
+        "%s/vfs/util/*.java" % test_prefix,
+    ]),
+    deps = [
+        ":testutil",
+        "//src/main/java:bazel-core",
+        "//src/main/java:shell",
+        "//third_party:guava",
+        "//third_party:guava-testlib",
+        "//third_party:junit4",
+        "//third_party:truth",
+    ],
+)
+
+java_library(
+    name = "test_runner",
+    srcs = [test_prefix + "/AllTests.java"],
+    deps = [
+        ":testutil",
+        "//third_party:junit4",
+    ],
+)
+
+java_test(
+    name = "foundations_test",
+    srcs = glob(
+        ["%s/%s" % (test_prefix, p) for p in [
+            "concurrent/*.java",
+            "collect/*.java",
+            "collect/nestedset/*.java",
+            "events/*.java",
+            "testutiltests/*.java",
+            "unix/*.java",
+            "util/*.java",
+            "util/io/*.java",
+            "vfs/*.java",
+            "vfs/inmemoryfs/*.java",
+        ]],
+        # java_rules_oss doesn't support resource loading with
+        # qualified paths.
+        exclude = [
+            test_prefix + f
+            for f in [
+                "/util/DependencySetWindowsTest.java",
+                "/util/ResourceFileLoaderTest.java",
+                "/vfs/PathFragmentWindowsTest.java",
+                "/vfs/PathWindowsTest.java",
+            ]
+        ],
+    ),
+    args = ["com.google.devtools.build.lib.AllTests"],
+    data = glob([test_prefix + "/vfs/*.zip"]) + [
+        "//src/main/native:libunix.dylib",
+        "//src/main/native:libunix.so",
+    ],
+    deps = [
+        ":foundations_testutil",
+        ":test_runner",
+        ":testutil",
+        "//src/main/java:bazel-core",
+        "//src/main/java:shell",
+        "//third_party:guava",
+        "//third_party:guava-testlib",
+        "//third_party:junit4",
+        "//third_party:truth",
+    ],
+)
+
+java_test(
+    name = "windows_test",
+    srcs = glob(["%s/%s" % (test_prefix, p) for p in [
+        "util/DependencySetWindowsTest.java",
+        "vfs/PathFragmentWindowsTest.java",
+        "vfs/PathWindowsTest.java",
+    ]]),
+    args = [
+        "com.google.devtools.build.lib.AllTests",
+    ],
+    data = [
+        "//src/main/native:libunix.dylib",
+        "//src/main/native:libunix.so",
+    ],
+    jvm_flags = ["-Dblaze.os=Windows"],
+    deps = [
+        ":foundations_testutil",
+        ":test_runner",
+        ":testutil",
+        "//src/main/java:bazel-core",
+        "//third_party:guava",
+        "//third_party:guava-testlib",
+        "//third_party:junit4",
+        "//third_party:truth",
+    ],
+)
+
+java_test(
+    name = "actions_test",
+    srcs = glob([
+        "com/google/devtools/build/lib/actions/**/*.java",
+    ]),
+    args = ["com.google.devtools.build.lib.AllTests"],
+    data = [
+        "//src/main/native:libunix.dylib",
+        "//src/main/native:libunix.so",
+    ],
+    deps = [
+        ":foundations_testutil",
+        ":test_runner",
+        ":testutil",
+        "//src/main/java:bazel-core",
+        "//third_party:guava",
+        "//third_party:guava-testlib",
+        "//third_party:jsr305",
+        "//third_party:junit4",
+        "//third_party:mockito",
+        "//third_party:truth",
+    ],
+)
diff --git a/src/test/java/com/google/devtools/build/lib/AllTests.java b/src/test/java/com/google/devtools/build/lib/AllTests.java
new file mode 100644
index 0000000..6aa19f1
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/AllTests.java
@@ -0,0 +1,25 @@
+// Copyright 2014 Google Inc. 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;
+
+import com.google.devtools.build.lib.testutil.ClasspathSuite;
+
+import org.junit.runner.RunWith;
+
+/**
+ * Test suite for options parsing framework.
+ */
+@RunWith(ClasspathSuite.class)
+public class AllTests {
+}
diff --git a/src/test/java/com/google/devtools/build/lib/actions/ActionExecutionStatusReporterTest.java b/src/test/java/com/google/devtools/build/lib/actions/ActionExecutionStatusReporterTest.java
new file mode 100644
index 0000000..8af46e4
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/actions/ActionExecutionStatusReporterTest.java
@@ -0,0 +1,293 @@
+// Copyright 2015 Google Inc. 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.actions;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.when;
+
+import com.google.common.base.Preconditions;
+import com.google.common.base.Splitter;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.eventbus.EventBus;
+import com.google.devtools.build.lib.events.EventCollector;
+import com.google.devtools.build.lib.events.EventKind;
+import com.google.devtools.build.lib.events.Reporter;
+import com.google.devtools.build.lib.util.Clock;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.Mockito;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Test for the {@link ActionExecutionStatusReporter} class.
+ */
+@RunWith(JUnit4.class)
+public class ActionExecutionStatusReporterTest {
+  private static final class MockClock implements Clock {
+    private long millis = 0;
+
+    public void advance() {
+      advanceBy(1000);
+    }
+
+    public void advanceBy(long millis) {
+      Preconditions.checkArgument(millis > 0);
+      this.millis += millis;
+    }
+
+    @Override
+    public long currentTimeMillis() {
+      return millis;
+    }
+
+    @Override
+    public long nanoTime() {
+      // There's no reason to use a nanosecond-precision for a mock clock.
+      return millis * 1000000L;
+    }
+  }
+
+  private EventCollector collector;
+  private ActionExecutionStatusReporter statusReporter;
+  private EventBus eventBus;
+  private MockClock clock = new MockClock();
+
+  private Action mockAction(String progressMessage) { return mockAction(progressMessage, false); }
+
+  private Action mockAction(String progressMessage, boolean remote) {
+    Action action = Mockito.mock(Action.class);
+    when(action.describeStrategy(null)).thenReturn(remote ? "remote" : "something else");
+    when(action.getProgressMessage()).thenReturn(progressMessage);
+    if (progressMessage == null) {
+      when(action.prettyPrint()).thenReturn("default message");
+    }
+    return action;
+  }
+
+  @Before
+  public void setUp() throws Exception {
+    collector = new EventCollector(EventKind.ALL_EVENTS);
+    Reporter reporter = new Reporter();
+    reporter.addHandler(collector);
+    statusReporter = ActionExecutionStatusReporter.create(reporter, clock);
+    eventBus = new EventBus();
+    eventBus.register(statusReporter);
+  }
+
+  private void verifyNoOutput() {
+    collector.clear();
+    statusReporter.showCurrentlyExecutingActions("");
+    assertEquals(0, collector.count());
+  }
+
+  private void verifyOutput(String... lines) throws Exception {
+    collector.clear();
+    statusReporter.showCurrentlyExecutingActions("");
+    assertThat(Splitter.on("\n").omitEmptyStrings().trimResults().split(
+        Iterables.getOnlyElement(collector).getMessage().replaceAll(" +", " ")))
+        .containsExactlyElementsIn(Arrays.asList(lines)).inOrder();
+  }
+
+  private void verifyWarningOutput(String... lines) throws Exception {
+    collector.clear();
+    statusReporter.warnAboutCurrentlyExecutingActions();
+    assertThat(Splitter.on("\n").omitEmptyStrings().trimResults().split(
+        Iterables.getOnlyElement(collector).getMessage().replaceAll(" +", " ")))
+        .containsExactlyElementsIn(Arrays.asList(lines)).inOrder();
+  }
+
+  @Test
+  public void testCategories() throws Exception {
+    verifyNoOutput();
+    verifyWarningOutput("There are no active jobs - stopping the build");
+    setPreparing(mockAction("action1"));
+    clock.advance();
+    verifyWarningOutput("Still waiting for unfinished jobs");
+    setScheduling(mockAction("action2"));
+    clock.advance();
+    setRunning(mockAction("action3", true));
+    clock.advance();
+    setRunning(mockAction("action4", false));
+    verifyOutput("Still waiting for 4 jobs to complete:",
+        "Preparing:", "action1, 3 s",
+        "Running (remote):", "action3, 1 s",
+        "Running (something else):", "action4, 0 s",
+        "Scheduling:", "action2, 2 s");
+    verifyWarningOutput("Still waiting for 3 jobs to complete:",
+        "Running (remote):", "action3, 1 s",
+        "Running (something else):", "action4, 0 s",
+        "Scheduling:", "action2, 2 s",
+        "Build will be stopped after these tasks terminate");
+  }
+
+  @Test
+  public void testSingleAction() throws Exception {
+    Action action = mockAction("action1", true);
+    verifyNoOutput();
+    setPreparing(action);
+    clock.advanceBy(1200);
+    verifyOutput("Still waiting for 1 job to complete:", "Preparing:", "action1, 1 s");
+    clock.advanceBy(5000);
+
+    setScheduling(action);
+    clock.advanceBy(1200);
+    // Only started *scheduling* 1200 ms ago, not 6200 ms ago.
+    verifyOutput("Still waiting for 1 job to complete:", "Scheduling:", "action1, 1 s");
+    setRunning(action);
+    clock.advanceBy(3000);
+    // Only started *running* 3000 ms ago, not 4200 ms ago.
+    verifyOutput("Still waiting for 1 job to complete:", "Running (remote):", "action1, 3 s");
+    statusReporter.remove(action);
+    verifyNoOutput();
+  }
+
+  @Test
+  public void testDynamicUpdate() throws Exception {
+    Action action = mockAction("action1", true);
+    verifyNoOutput();
+    setPreparing(action);
+    clock.advance();
+    verifyOutput("Still waiting for 1 job to complete:", "Preparing:", "action1, 1 s");
+    setScheduling(action);
+    clock.advance();
+    verifyOutput("Still waiting for 1 job to complete:", "Scheduling:", "action1, 1 s");
+    setRunning(action);
+    clock.advance();
+    verifyOutput("Still waiting for 1 job to complete:", "Running (remote):", "action1, 1 s");
+    clock.advance();
+
+    eventBus.post(ActionStatusMessage.analysisStrategy(action));
+    // Locality strategy was changed, so timer was reset to 0 s.
+    verifyOutput("Still waiting for 1 job to complete:", "Analyzing:", "action1, 0 s");
+    statusReporter.remove(action);
+    verifyNoOutput();
+  }
+
+  @Test
+  public void testGroups() throws Exception {
+    verifyNoOutput();
+    List<Action> actions = ImmutableList.of(
+        mockAction("remote1", true), mockAction("remote2", true), mockAction("remote3", true),
+        mockAction("local1", false), mockAction("local2", false), mockAction("local3", false));
+
+    for (Action a : actions) {
+      setScheduling(a);
+      clock.advance();
+    }
+
+    verifyOutput("Still waiting for 6 jobs to complete:",
+        "Scheduling:",
+        "remote1, 6 s", "remote2, 5 s", "remote3, 4 s",
+        "local1, 3 s", "local2, 2 s", "local3, 1 s");
+
+    for (Action a : actions) {
+      setRunning(a);
+      clock.advanceBy(2000);
+    }
+
+    // Timers got reset because now they are no longer scheduling but running.
+    verifyOutput("Still waiting for 6 jobs to complete:",
+        "Running (remote):", "remote1, 12 s", "remote2, 10 s", "remote3, 8 s",
+        "Running (something else):", "local1, 6 s", "local2, 4 s", "local3, 2 s");
+
+    statusReporter.remove(actions.get(0));
+    verifyOutput("Still waiting for 5 jobs to complete:",
+        "Running (remote):", "remote2, 10 s", "remote3, 8 s",
+        "Running (something else):", "local1, 6 s", "local2, 4 s", "local3, 2 s");
+  }
+
+  @Test
+  public void testTruncation() throws Exception {
+    verifyNoOutput();
+    List<Action> actions = new ArrayList<>();
+    for (int i = 1; i <= 100; i++) {
+      Action a = mockAction("a" + i);
+      actions.add(a);
+      setScheduling(a);
+      clock.advance();
+    }
+    verifyOutput("Still waiting for 100 jobs to complete:", "Scheduling:",
+        "a1, 100 s", "a2, 99 s", "a3, 98 s", "a4, 97 s", "a5, 96 s",
+        "a6, 95 s", "a7, 94 s", "a8, 93 s", "a9, 92 s", "... 91 more jobs");
+
+    for (int i = 0; i < 5; i++) {
+      setRunning(actions.get(i));
+      clock.advance();
+    }
+    verifyOutput("Still waiting for 100 jobs to complete:",
+        "Running (something else):", "a1, 5 s", "a2, 4 s", "a3, 3 s", "a4, 2 s", "a5, 1 s",
+        "Scheduling:", "a6, 100 s", "a7, 99 s", "a8, 98 s", "a9, 97 s", "a10, 96 s",
+        "a11, 95 s", "a12, 94 s", "a13, 93 s", "a14, 92 s", "... 86 more jobs");
+  }
+
+  @Test
+  public void testOrdering() throws Exception {
+    verifyNoOutput();
+    setScheduling(mockAction("a1"));
+    clock.advance();
+    setPreparing(mockAction("b1"));
+    clock.advance();
+    setPreparing(mockAction("b2"));
+    clock.advance();
+    setScheduling(mockAction("a2"));
+    clock.advance();
+    verifyOutput("Still waiting for 4 jobs to complete:",
+        "Preparing:", "b1, 3 s", "b2, 2 s",
+        "Scheduling:", "a1, 4 s", "a2, 1 s");
+  }
+
+  @Test
+  public void testNoProgressMessage() throws Exception {
+    verifyNoOutput();
+    setScheduling(mockAction(null));
+    verifyOutput("Still waiting for 1 job to complete:", "Scheduling:", "default message, 0 s");
+  }
+
+  @Test
+  public void testWaitTimeCalculation() throws Exception {
+    // --progress_report_interval=0
+    assertEquals(10, ActionExecutionStatusReporter.getWaitTime(0, 0));
+    assertEquals(30, ActionExecutionStatusReporter.getWaitTime(0, 10));
+    assertEquals(60, ActionExecutionStatusReporter.getWaitTime(0, 30));
+    assertEquals(60, ActionExecutionStatusReporter.getWaitTime(0, 60));
+
+    // --progress_report_interval=42
+    assertEquals(42, ActionExecutionStatusReporter.getWaitTime(42, 0));
+    assertEquals(42, ActionExecutionStatusReporter.getWaitTime(42, 42));
+
+    // --progress_report_interval=30 (looks like one of the default timeout stages)
+    assertEquals(30, ActionExecutionStatusReporter.getWaitTime(30, 0));
+    assertEquals(30, ActionExecutionStatusReporter.getWaitTime(30, 30));
+  }
+
+  private void setScheduling(ActionMetadata action) {
+    eventBus.post(ActionStatusMessage.schedulingStrategy(action));
+  }
+
+  private void setPreparing(ActionMetadata action) {
+    eventBus.post(ActionStatusMessage.preparingStrategy(action));
+  }
+
+  private void setRunning(ActionMetadata action) {
+    eventBus.post(ActionStatusMessage.runningStrategy(action));
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/actions/ArtifactFactoryTest.java b/src/test/java/com/google/devtools/build/lib/actions/ArtifactFactoryTest.java
new file mode 100644
index 0000000..71cf9c4
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/actions/ArtifactFactoryTest.java
@@ -0,0 +1,246 @@
+// Copyright 2015 Google Inc. 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.actions;
+
+
+import static com.google.devtools.build.lib.actions.util.ActionsTestUtil.NULL_ACTION_OWNER;
+import static com.google.devtools.build.lib.actions.util.ActionsTestUtil.NULL_ARTIFACT_OWNER;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Maps;
+import com.google.devtools.build.lib.actions.MutableActionGraph.ActionConflictException;
+import com.google.devtools.build.lib.actions.util.ActionsTestUtil;
+import com.google.devtools.build.lib.packages.PackageIdentifier;
+import com.google.devtools.build.lib.vfs.Path;
+import com.google.devtools.build.lib.vfs.PathFragment;
+import com.google.devtools.build.lib.vfs.util.FsApparatus;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+
+/**
+ * Tests {@link ArtifactFactory}. Also see {@link ArtifactTest} for a test
+ * of individual artifacts.
+ */
+@RunWith(JUnit4.class)
+public class ArtifactFactoryTest {
+
+  private FsApparatus scratch = FsApparatus.newInMemory();
+
+  private Path execRoot;
+  private Root clientRoot;
+  private Root clientRoRoot;
+  private Root outRoot;
+
+  private PathFragment fooPath;
+  private PackageIdentifier fooPackage;
+  private PathFragment fooRelative;
+
+  private PathFragment barPath;
+  private PackageIdentifier barPackage;
+  private PathFragment barRelative;
+
+  private ArtifactFactory artifactFactory;
+
+  @Before
+  public void setUp() throws Exception {
+    execRoot = scratch.dir("/output/workspace");
+    clientRoot = Root.asSourceRoot(scratch.dir("/client/workspace"));
+    clientRoRoot = Root.asSourceRoot(scratch.dir("/client/RO/workspace"));
+    outRoot = Root.asDerivedRoot(execRoot, execRoot.getRelative("out-root/x/bin"));
+
+    fooPath = new PathFragment("foo");
+    fooPackage = PackageIdentifier.createInDefaultRepo(fooPath);
+    fooRelative = fooPath.getRelative("foosource.txt");
+
+    barPath = new PathFragment("foo/bar");
+    barPackage = PackageIdentifier.createInDefaultRepo(barPath);
+    barRelative = barPath.getRelative("barsource.txt");
+
+    artifactFactory = new ArtifactFactory(execRoot);
+    setupRoots();
+  }
+
+  private void setupRoots() {
+    Map<PackageIdentifier, Root> packageRootMap = new HashMap<>();
+    packageRootMap.put(fooPackage, clientRoot);
+    packageRootMap.put(barPackage, clientRoRoot);
+    artifactFactory.setPackageRoots(packageRootMap);
+    artifactFactory.setDerivedArtifactRoots(ImmutableList.of(outRoot));
+  }
+
+  @Test
+  public void testGetSourceArtifactYieldsSameArtifact() throws Exception {
+    assertSame(artifactFactory.getSourceArtifact(fooRelative, clientRoot),
+               artifactFactory.getSourceArtifact(fooRelative, clientRoot));
+  }
+
+  @Test
+  public void testGetSourceArtifactUnnormalized() throws Exception {
+    assertSame(artifactFactory.getSourceArtifact(fooRelative, clientRoot),
+               artifactFactory.getSourceArtifact(new PathFragment("foo/./foosource.txt"),
+                   clientRoot));
+  }
+
+  @Test
+  public void testResolveArtifact_noDerived_simpleSource() throws Exception {
+    assertSame(artifactFactory.getSourceArtifact(fooRelative, clientRoot),
+        artifactFactory.resolveSourceArtifact(fooRelative));
+    assertSame(artifactFactory.getSourceArtifact(barRelative, clientRoRoot),
+        artifactFactory.resolveSourceArtifact(barRelative));
+  }
+
+  @Test
+  public void testResolveArtifact_noDerived_derivedRoot() throws Exception {
+    assertNull(artifactFactory.resolveSourceArtifact(
+            outRoot.getPath().getRelative(fooRelative).relativeTo(execRoot)));
+    assertNull(artifactFactory.resolveSourceArtifact(
+            outRoot.getPath().getRelative(barRelative).relativeTo(execRoot)));
+  }
+
+  @Test
+  public void testResolveArtifact_noDerived_simpleSource_other() throws Exception {
+    Artifact actual = artifactFactory.resolveSourceArtifact(fooRelative);
+    assertSame(artifactFactory.getSourceArtifact(fooRelative, clientRoot), actual);
+    actual = artifactFactory.resolveSourceArtifact(barRelative);
+    assertSame(artifactFactory.getSourceArtifact(barRelative, clientRoRoot), actual);
+  }
+
+  @Test
+  public void testClearResetsFactory() {
+    Artifact fooArtifact = artifactFactory.getSourceArtifact(fooRelative, clientRoot);
+    artifactFactory.clear();
+    setupRoots();
+    assertNotSame(fooArtifact, artifactFactory.getSourceArtifact(fooRelative, clientRoot));
+  }
+
+  @Test
+  public void testFindDerivedRoot() throws Exception {
+    assertSame(outRoot,
+        artifactFactory.findDerivedRoot(outRoot.getPath().getRelative(fooRelative)));
+    assertSame(outRoot,
+        artifactFactory.findDerivedRoot(outRoot.getPath().getRelative(barRelative)));
+  }
+
+  @Test
+  public void testSetGeneratingActionIdempotenceNewActionGraph() throws Exception {
+    Artifact a = artifactFactory.getDerivedArtifact(fooRelative, outRoot, NULL_ARTIFACT_OWNER);
+    Artifact b = artifactFactory.getDerivedArtifact(barRelative, outRoot, NULL_ARTIFACT_OWNER);
+    MutableActionGraph actionGraph = new MapBasedActionGraph();
+    Action originalAction = new ActionsTestUtil.NullAction(NULL_ACTION_OWNER, a);
+    actionGraph.registerAction(originalAction);
+
+    // Creating a second Action referring to the Artifact should create a conflict.
+    try {
+      Action action = new ActionsTestUtil.NullAction(NULL_ACTION_OWNER, a, b);
+      actionGraph.registerAction(action);
+      fail();
+    } catch (ActionConflictException e) {
+      assertSame(a, e.getArtifact());
+      assertSame(originalAction, actionGraph.getGeneratingAction(a));
+    }
+  }
+
+  @Test
+  public void testGetDerivedArtifact() throws Exception {
+    PathFragment toolPath = new PathFragment("_bin/tool");
+    Artifact artifact = artifactFactory.getDerivedArtifact(toolPath);
+    assertEquals(toolPath, artifact.getExecPath());
+    assertEquals(Root.asDerivedRoot(execRoot), artifact.getRoot());
+    assertEquals(execRoot.getRelative(toolPath), artifact.getPath());
+    assertNull(artifact.getOwner());
+  }
+
+  @Test
+  public void testGetDerivedArtifactFailsForAbsolutePath() throws Exception {
+    try {
+      artifactFactory.getDerivedArtifact(new PathFragment("/_bin/b"));
+      fail();
+    } catch (IllegalArgumentException e) {
+      // Expected exception
+    }
+  }
+
+  private static class MockPackageRootResolver implements PackageRootResolver {
+    private Map<PathFragment, Root> packageRoots = Maps.newHashMap();
+
+    public void setPackageRoots(Map<PackageIdentifier, Root> packageRoots) {
+      for (Entry<PackageIdentifier, Root> packageRoot : packageRoots.entrySet()) {
+        this.packageRoots.put(packageRoot.getKey().getPackageFragment(), packageRoot.getValue());
+      }
+    }
+
+    @Override
+    public Map<PathFragment, Root> findPackageRoots(Iterable<PathFragment> execPaths) {
+      Map<PathFragment, Root> result = new HashMap<>();
+      for (PathFragment execPath : execPaths) {
+        for (PathFragment dir = execPath.getParentDirectory(); dir != null;
+            dir = dir.getParentDirectory()) {
+          if (packageRoots.get(dir) != null) {
+            result.put(execPath, packageRoots.get(dir));
+          }
+        }
+        if (result.get(execPath) == null) {
+          result.put(execPath, null);
+        }
+      }
+      return result;
+    }
+  }
+
+  @Test
+  public void testArtifactDeserializationWithoutReusedArtifacts() throws Exception {
+    PathFragment derivedPath = outRoot.getExecPath().getRelative("fruit/banana");
+    artifactFactory.clear();
+    artifactFactory.setDerivedArtifactRoots(ImmutableList.of(outRoot));
+    MockPackageRootResolver rootResolver = new MockPackageRootResolver();
+    rootResolver.setPackageRoots(
+        ImmutableMap.of(PackageIdentifier.createInDefaultRepo(""), clientRoot));
+    Artifact artifact1 = artifactFactory.deserializeArtifact(derivedPath, rootResolver);
+    Artifact artifact2 = artifactFactory.deserializeArtifact(derivedPath, rootResolver);
+    assertEquals(artifact1, artifact2);
+    assertNull(artifact1.getOwner());
+    assertNull(artifact2.getOwner());
+    assertEquals(derivedPath, artifact1.getExecPath());
+    assertEquals(derivedPath, artifact2.getExecPath());
+
+    // Source artifacts are always reused
+    PathFragment sourcePath = clientRoot.getExecPath().getRelative("fruit/mango");
+    artifact1 = artifactFactory.deserializeArtifact(sourcePath, rootResolver);
+    artifact2 = artifactFactory.deserializeArtifact(sourcePath, rootResolver);
+    assertSame(artifact1, artifact2);
+    assertEquals(sourcePath, artifact1.getExecPath());
+  }
+
+  @Test
+  public void testDeserializationWithInvalidPath() throws Exception {
+    artifactFactory.clear();
+    PathFragment randomPath = new PathFragment("maracuja/lemon/kiwi");
+    Artifact artifact = artifactFactory.deserializeArtifact(randomPath,
+        new MockPackageRootResolver());
+    assertNull(artifact);
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/actions/ArtifactTest.java b/src/test/java/com/google/devtools/build/lib/actions/ArtifactTest.java
new file mode 100644
index 0000000..d493e42
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/actions/ArtifactTest.java
@@ -0,0 +1,312 @@
+// Copyright 2015 Google Inc. 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.actions;
+
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.devtools.build.lib.testutil.MoreAsserts.assertSameContents;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.devtools.build.lib.actions.Action.MiddlemanType;
+import com.google.devtools.build.lib.actions.util.ActionsTestUtil;
+import com.google.devtools.build.lib.actions.util.LabelArtifactOwner;
+import com.google.devtools.build.lib.rules.cpp.CppFileTypes;
+import com.google.devtools.build.lib.rules.java.JavaSemantics;
+import com.google.devtools.build.lib.syntax.Label;
+import com.google.devtools.build.lib.testutil.Scratch;
+import com.google.devtools.build.lib.vfs.Path;
+import com.google.devtools.build.lib.vfs.PathFragment;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+@RunWith(JUnit4.class)
+public class ArtifactTest {
+  private Scratch scratch;
+  private Path execDir;
+  private Root rootDir;
+
+  @Before
+  public void setUp() throws Exception {
+    scratch = new Scratch();
+    execDir = scratch.dir("/exec");
+    rootDir = Root.asDerivedRoot(scratch.dir("/exec/root"));
+  }
+
+  @Test
+  public void testConstruction_badRootDir() throws IOException {
+    Path f1 = scratch.file("/exec/dir/file.ext");
+    Path bogusDir = scratch.file("/exec/dir/bogus");
+    try {
+      new Artifact(f1, Root.asDerivedRoot(bogusDir), f1.relativeTo(execDir));
+      fail("Expected IllegalArgumentException constructing artifact with a bad root dir");
+    } catch (IllegalArgumentException expected) {}
+  }
+
+  @Test
+  public void testEquivalenceRelation() throws Exception {
+    PathFragment aPath = new PathFragment("src/a");
+    PathFragment bPath = new PathFragment("src/b");
+    assertEquals(new Artifact(aPath, rootDir),
+                 new Artifact(aPath, rootDir));
+    assertEquals(new Artifact(bPath, rootDir),
+                 new Artifact(bPath, rootDir));
+    assertFalse(new Artifact(aPath, rootDir).equals(
+                new Artifact(bPath, rootDir)));
+  }
+
+  @Test
+  public void testComparison() throws Exception {
+    PathFragment aPath = new PathFragment("src/a");
+    PathFragment bPath = new PathFragment("src/b");
+    Artifact aArtifact = new Artifact(aPath, rootDir);
+    Artifact bArtifact = new Artifact(bPath, rootDir);
+    assertEquals(-1, aArtifact.compareTo(bArtifact));
+    assertEquals(0, aArtifact.compareTo(aArtifact));
+    assertEquals(0, bArtifact.compareTo(bArtifact));
+    assertEquals(1, bArtifact.compareTo(aArtifact));
+  }
+
+  @Test
+  public void testRootPrefixedExecPath_normal() throws IOException {
+    Path f1 = scratch.file("/exec/root/dir/file.ext");
+    Artifact a1 = new Artifact(f1, rootDir, f1.relativeTo(execDir));
+    assertEquals("root:dir/file.ext", Artifact.asRootPrefixedExecPath(a1));
+  }
+
+  @Test
+  public void testRootPrefixedExecPath_noRoot() throws IOException {
+    Path f1 = scratch.file("/exec/dir/file.ext");
+    Artifact a1 = new Artifact(f1.relativeTo(execDir), Root.asDerivedRoot(execDir));
+    assertEquals(":dir/file.ext", Artifact.asRootPrefixedExecPath(a1));
+  }
+
+  @Test
+  public void testRootPrefixedExecPath_nullRootDir() throws IOException {
+    Path f1 = scratch.file("/exec/dir/file.ext");
+    try {
+      new Artifact(f1, null, f1.relativeTo(execDir));
+      fail("Expected IllegalArgumentException creating artifact with null root");
+    } catch (IllegalArgumentException expected) {}
+  }
+
+  @Test
+  public void testRootPrefixedExecPaths() throws IOException {
+    Path f1 = scratch.file("/exec/root/dir/file1.ext");
+    Path f2 = scratch.file("/exec/root/dir/dir/file2.ext");
+    Path f3 = scratch.file("/exec/root/dir/dir/dir/file3.ext");
+    Artifact a1 = new Artifact(f1, rootDir, f1.relativeTo(execDir));
+    Artifact a2 = new Artifact(f2, rootDir, f2.relativeTo(execDir));
+    Artifact a3 = new Artifact(f3, rootDir, f3.relativeTo(execDir));
+    List<String> strings = new ArrayList<>();
+    Artifact.addRootPrefixedExecPaths(Lists.newArrayList(a1, a2, a3), strings);
+    assertThat(strings).containsExactly(
+        "root:dir/file1.ext",
+        "root:dir/dir/file2.ext",
+        "root:dir/dir/dir/file3.ext").inOrder();
+  }
+
+  @Test
+  public void testGetFilename() throws Exception {
+    Root root = Root.asSourceRoot(scratch.dir("/foo"));
+    Artifact javaFile = new Artifact(scratch.file("/foo/Bar.java"), root);
+    Artifact generatedHeader = new Artifact(scratch.file("/foo/bar.proto.h"), root);
+    Artifact generatedCc = new Artifact(scratch.file("/foo/bar.proto.cc"), root);
+    Artifact aCPlusPlusFile = new Artifact(scratch.file("/foo/bar.cc"), root);
+    assertTrue(JavaSemantics.JAVA_SOURCE.matches(javaFile.getFilename()));
+    assertTrue(CppFileTypes.CPP_HEADER.matches(generatedHeader.getFilename()));
+    assertTrue(CppFileTypes.CPP_SOURCE.matches(generatedCc.getFilename()));
+    assertTrue(CppFileTypes.CPP_SOURCE.matches(aCPlusPlusFile.getFilename()));
+  }
+
+  @Test
+  public void testMangledPath() {
+    String path = "dir/sub_dir/name:end";
+    assertEquals("dir_Ssub_Udir_Sname_Cend", Actions.escapedPath(path));
+  }
+
+  private List<Artifact> getFooBarArtifacts(MutableActionGraph actionGraph, boolean collapsedList)
+      throws Exception {
+    Root root = Root.asSourceRoot(scratch.dir("/foo"));
+    Artifact aHeader1 = new Artifact(scratch.file("/foo/bar1.h"), root);
+    Artifact aHeader2 = new Artifact(scratch.file("/foo/bar2.h"), root);
+    Artifact aHeader3 = new Artifact(scratch.file("/foo/bar3.h"), root);
+    Artifact middleman = new Artifact(new PathFragment("middleman"),
+        Root.middlemanRoot(scratch.dir("/foo"), scratch.dir("/foo/out")));
+    actionGraph.registerAction(new MiddlemanAction(ActionsTestUtil.NULL_ACTION_OWNER,
+        ImmutableList.of(aHeader1, aHeader2, aHeader3), middleman, "desc",
+        MiddlemanType.AGGREGATING_MIDDLEMAN));
+    return collapsedList ? Lists.newArrayList(aHeader1, middleman) :
+        Lists.newArrayList(aHeader1, aHeader2, middleman);
+  }
+
+  @Test
+  public void testAddExecPaths() throws Exception {
+    List<String> paths = new ArrayList<>();
+    MutableActionGraph actionGraph = new MapBasedActionGraph();
+    Artifact.addExecPaths(getFooBarArtifacts(actionGraph, false), paths);
+    assertSameContents(ImmutableList.of("bar1.h", "bar2.h"), paths);
+  }
+
+  @Test
+  public void testAddExpandedExecPathStrings() throws Exception {
+    List<String> paths = new ArrayList<>();
+    MutableActionGraph actionGraph = new MapBasedActionGraph();
+    Artifact.addExpandedExecPathStrings(getFooBarArtifacts(actionGraph, true), paths,
+        ActionInputHelper.actionGraphMiddlemanExpander(actionGraph));
+    assertSameContents(ImmutableList.of("bar1.h", "bar2.h", "bar3.h"), paths);
+  }
+
+  @Test
+  public void testAddExpandedExecPaths() throws Exception {
+    List<PathFragment> paths = new ArrayList<>();
+    MutableActionGraph actionGraph = new MapBasedActionGraph();
+    Artifact.addExpandedExecPaths(getFooBarArtifacts(actionGraph, true), paths,
+        ActionInputHelper.actionGraphMiddlemanExpander(actionGraph));
+    assertSameContents(ImmutableList.of(
+        new PathFragment("bar1.h"), new PathFragment("bar2.h"), new PathFragment("bar3.h")),
+        paths);
+  }
+
+  @Test
+  public void testAddExpandedArtifacts() throws Exception {
+    List<Artifact> expanded = new ArrayList<>();
+    MutableActionGraph actionGraph = new MapBasedActionGraph();
+    List<Artifact> original = getFooBarArtifacts(actionGraph, true);
+    Artifact.addExpandedArtifacts(original, expanded,
+        ActionInputHelper.actionGraphMiddlemanExpander(actionGraph));
+
+    List<Artifact> manuallyExpanded = new ArrayList<>();
+    for (Artifact artifact : original) {
+      Action action = actionGraph.getGeneratingAction(artifact);
+      if (artifact.isMiddlemanArtifact()) {
+        Iterables.addAll(manuallyExpanded, action.getInputs());
+      } else {
+        manuallyExpanded.add(artifact);
+      }
+    }
+    assertSameContents(manuallyExpanded, expanded);
+  }
+
+  @Test
+  public void testAddExecPathsNewActionGraph() throws Exception {
+    List<String> paths = new ArrayList<>();
+    MutableActionGraph actionGraph = new MapBasedActionGraph();
+    Artifact.addExecPaths(getFooBarArtifacts(actionGraph, false), paths);
+    assertSameContents(ImmutableList.of("bar1.h", "bar2.h"), paths);
+  }
+
+  @Test
+  public void testAddExpandedExecPathStringsNewActionGraph() throws Exception {
+    List<String> paths = new ArrayList<>();
+    MutableActionGraph actionGraph = new MapBasedActionGraph();
+    Artifact.addExpandedExecPathStrings(getFooBarArtifacts(actionGraph, true), paths,
+        ActionInputHelper.actionGraphMiddlemanExpander(actionGraph));
+    assertSameContents(ImmutableList.of("bar1.h", "bar2.h", "bar3.h"), paths);
+  }
+
+  @Test
+  public void testAddExpandedExecPathsNewActionGraph() throws Exception {
+    List<PathFragment> paths = new ArrayList<>();
+    MutableActionGraph actionGraph = new MapBasedActionGraph();
+    Artifact.addExpandedExecPaths(getFooBarArtifacts(actionGraph, true), paths,
+        ActionInputHelper.actionGraphMiddlemanExpander(actionGraph));
+    assertSameContents(ImmutableList.of(
+        new PathFragment("bar1.h"), new PathFragment("bar2.h"), new PathFragment("bar3.h")),
+        paths);
+  }
+
+  @Test
+  public void testAddExpandedArtifactsNewActionGraph() throws Exception {
+    List<Artifact> expanded = new ArrayList<>();
+    MutableActionGraph actionGraph = new MapBasedActionGraph();
+    List<Artifact> original = getFooBarArtifacts(actionGraph, true);
+    Artifact.addExpandedArtifacts(original, expanded,
+        ActionInputHelper.actionGraphMiddlemanExpander(actionGraph));
+
+    List<Artifact> manuallyExpanded = new ArrayList<>();
+    for (Artifact artifact : original) {
+      Action action = actionGraph.getGeneratingAction(artifact);
+      if (artifact.isMiddlemanArtifact()) {
+        Iterables.addAll(manuallyExpanded, action.getInputs());
+      } else {
+        manuallyExpanded.add(artifact);
+      }
+    }
+    assertSameContents(manuallyExpanded, expanded);
+  }
+
+  @Test
+  public void testRootRelativePathIsSameAsExecPath() throws Exception {
+    Root root = Root.asSourceRoot(scratch.dir("/foo"));
+    Artifact a = new Artifact(scratch.file("/foo/bar1.h"), root);
+    assertSame(a.getExecPath(), a.getRootRelativePath());
+  }
+
+  @Test
+  public void testToDetailString() throws Exception {
+    Artifact a = new Artifact(scratch.file("/a/b/c"), Root.asDerivedRoot(scratch.dir("/a/b")),
+        new PathFragment("b/c"));
+    assertEquals("[[/a]b]c", a.toDetailString());
+  }
+
+  @Test
+  public void testWeirdArtifact() throws Exception {
+    try {
+      new Artifact(scratch.file("/a/b/c"), Root.asDerivedRoot(scratch.dir("/a")),
+          new PathFragment("c"));
+      fail();
+    } catch (IllegalArgumentException e) {
+      assertEquals("c: illegal execPath doesn't end with b/c at /a/b/c with root /a[derived]",
+          e.getMessage());
+    }
+  }
+
+  @Test
+  public void testSerializeToString() throws Exception {
+    assertEquals("b/c /3",
+        new Artifact(scratch.file("/a/b/c"),
+            Root.asDerivedRoot(scratch.dir("/a"))).serializeToString());
+  }
+
+  @Test
+  public void testSerializeToStringWithExecPath() throws Exception {
+    Path path = scratch.file("/aaa/bbb/ccc");
+    Root root = Root.asDerivedRoot(scratch.dir("/aaa/bbb"));
+    PathFragment execPath = new PathFragment("bbb/ccc");
+
+    assertEquals("bbb/ccc /3", new Artifact(path, root, execPath).serializeToString());
+  }
+
+  @Test
+  public void testSerializeToStringWithOwner() throws Exception {
+    assertEquals("b/c /3 //foo:bar",
+        new Artifact(scratch.file("/aa/b/c"), Root.asDerivedRoot(scratch.dir("/aa")),
+            new PathFragment("b/c"),
+            new LabelArtifactOwner(Label.parseAbsoluteUnchecked("//foo:bar"))).serializeToString());
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/actions/ConcurrentMultimapWithHeadElementTest.java b/src/test/java/com/google/devtools/build/lib/actions/ConcurrentMultimapWithHeadElementTest.java
new file mode 100644
index 0000000..28f185c
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/actions/ConcurrentMultimapWithHeadElementTest.java
@@ -0,0 +1,175 @@
+// Copyright 2015 Google Inc. 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.actions;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import com.google.common.testing.GcFinalization;
+import com.google.devtools.build.lib.concurrent.AbstractQueueVisitor;
+import com.google.devtools.build.lib.testutil.TestThread;
+import com.google.devtools.build.lib.testutil.TestUtils;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.lang.ref.WeakReference;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * Tests for ConcurrentMultimapWithHeadElement.
+ */
+@RunWith(JUnit4.class)
+public class ConcurrentMultimapWithHeadElementTest {
+  @Test
+  public void testSmoke() throws Exception {
+    ConcurrentMultimapWithHeadElement<String, String> multimap =
+        new ConcurrentMultimapWithHeadElement<String, String>();
+    assertEquals("val", multimap.putAndGet("key", "val"));
+    assertEquals("val", multimap.get("key"));
+    assertEquals("val", multimap.putAndGet("key", "val2"));
+    multimap.remove("key", "val2");
+    assertEquals("val", multimap.get("key"));
+    assertEquals("val", multimap.putAndGet("key", "val2"));
+    multimap.remove("key", "val");
+    assertEquals("val2", multimap.get("key"));
+  }
+
+  @Test
+  public void testDuplicate() throws Exception {
+    ConcurrentMultimapWithHeadElement<String, String> multimap =
+        new ConcurrentMultimapWithHeadElement<String, String>();
+    assertEquals("val", multimap.putAndGet("key", "val"));
+    assertEquals("val", multimap.get("key"));
+    assertEquals("val", multimap.putAndGet("key", "val"));
+    multimap.remove("key", "val");
+    assertEquals(null, multimap.get("key"));
+  }
+
+  @Test
+  public void testDuplicateWithEqualsObject() throws Exception {
+    ConcurrentMultimapWithHeadElement<String, String> multimap =
+        new ConcurrentMultimapWithHeadElement<>();
+    assertEquals(new String("val"), multimap.putAndGet("key", new String("val")));
+    assertEquals(new String("val"), multimap.get("key"));
+    assertEquals(new String("val"), multimap.putAndGet("key", new String("val")));
+    multimap.remove("key", new String("val"));
+    assertEquals(null, multimap.get("key"));
+  }
+
+  @Test
+  public void testFailedRemoval() throws Exception {
+    ConcurrentMultimapWithHeadElement<String, String> multimap =
+        new ConcurrentMultimapWithHeadElement<String, String>();
+    assertEquals("val", multimap.putAndGet("key", "val"));
+    multimap.remove("key", "val2");
+    assertEquals("val", multimap.get("key"));
+  }
+
+  @Test
+  public void testNotEmpty() throws Exception {
+    ConcurrentMultimapWithHeadElement<String, String> multimap =
+        new ConcurrentMultimapWithHeadElement<String, String>();
+    assertEquals("val", multimap.putAndGet("key", "val"));
+    multimap.remove("key", "val2");
+    assertEquals("val", multimap.get("key"));
+  }
+
+  @Test
+  public void testKeyRemoved() throws Exception {
+    String key = new String("key");
+    ConcurrentMultimapWithHeadElement<String, String> multimap =
+        new ConcurrentMultimapWithHeadElement<String, String>();
+    assertEquals("val", multimap.putAndGet(key, "val"));
+    WeakReference<String> weakKey = new WeakReference<String>(key);
+    multimap.remove(key, "val");
+    key = null;
+    GcFinalization.awaitClear(weakKey);
+  }
+
+  @Test
+  public void testKeyRemovedAndAddedConcurrently() throws Exception {
+    final ConcurrentMultimapWithHeadElement<String, String> multimap =
+        new ConcurrentMultimapWithHeadElement<String, String>();
+    // Because we have two threads racing, run the test many times. Before fixed, there was a 90%
+    // chance of failure in 10,000 runs.
+    for (int i = 0; i < 10000; i++) {
+      assertEquals("val", multimap.putAndGet("key", "val"));
+      final CountDownLatch threadStart = new CountDownLatch(1);
+      TestThread testThread = new TestThread() {
+        @Override
+        public void runTest() throws Exception {
+          threadStart.countDown();
+          multimap.remove("key", "val");
+        }
+      };
+      testThread.start();
+      assertTrue(threadStart.await(TestUtils.WAIT_TIMEOUT_SECONDS, TimeUnit.SECONDS));
+      assertNotNull(multimap.putAndGet("key", "val2")); // Removal may not have happened yet.
+      assertNotNull(multimap.get("key")); // If put failed, this will be null.
+      testThread.joinAndAssertState(2000);
+      multimap.clear();
+    }
+  }
+
+  private class StressTester extends AbstractQueueVisitor {
+    private final ConcurrentMultimapWithHeadElement<Boolean, Integer> multimap =
+        new ConcurrentMultimapWithHeadElement<Boolean, Integer>();
+    private final AtomicInteger actionCount = new AtomicInteger(0);
+
+    private StressTester() {
+      super(/*concurrent=*/true, 200, 200, 1, TimeUnit.SECONDS,
+          /*failFastOnException=*/true, /*failFastOnInterrupt=*/true, "action-graph-test");
+    }
+
+    private void addAndRemove(final Boolean key, final Integer add, final Integer remove) {
+      enqueue(new Runnable() {
+        @Override
+        public void run() {
+          assertNotNull(multimap.putAndGet(key, add));
+          multimap.remove(key, remove);
+          doRandom();
+        }
+      });
+    }
+
+    private Integer getRandomInt() {
+      return (int) Math.round(Math.random() * 3.0);
+    }
+
+    private void doRandom() {
+      if (actionCount.incrementAndGet() > 100000) {
+        return;
+      }
+      Boolean key = Math.random() < 0.5;
+      addAndRemove(key, getRandomInt(), getRandomInt());
+    }
+
+    private void work() throws InterruptedException {
+      work(/*failFastOnInterrupt=*/true);
+    }
+  }
+
+  @Test
+  public void testStressTest() throws Exception {
+    StressTester stressTester = new StressTester();
+    stressTester.doRandom();
+    stressTester.work();
+  }
+
+}
diff --git a/src/test/java/com/google/devtools/build/lib/actions/CustomCommandLineTest.java b/src/test/java/com/google/devtools/build/lib/actions/CustomCommandLineTest.java
new file mode 100644
index 0000000..3a7db34
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/actions/CustomCommandLineTest.java
@@ -0,0 +1,161 @@
+// Copyright 2015 Google Inc. 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.actions;
+
+
+import static org.junit.Assert.assertEquals;
+
+import com.google.common.collect.ImmutableList;
+import com.google.devtools.build.lib.analysis.actions.CustomCommandLine;
+import com.google.devtools.build.lib.analysis.actions.CustomCommandLine.CustomArgv;
+import com.google.devtools.build.lib.analysis.actions.CustomCommandLine.CustomMultiArgv;
+import com.google.devtools.build.lib.collect.nestedset.NestedSetBuilder;
+import com.google.devtools.build.lib.syntax.Label;
+import com.google.devtools.build.lib.syntax.Label.SyntaxException;
+import com.google.devtools.build.lib.testutil.Scratch;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests for CustomCommandLine.
+ */
+@RunWith(JUnit4.class)
+public class CustomCommandLineTest {
+
+  private Scratch scratch;
+  private Root rootDir;
+  private Artifact artifact1;
+  private Artifact artifact2;
+
+  @Before
+  public void setUp() throws Exception {
+    scratch = new Scratch();
+    rootDir = Root.asDerivedRoot(scratch.dir("/exec/root"));
+    artifact1 = new Artifact(scratch.file("/exec/root/dir/file1.txt"), rootDir);
+    artifact2 = new Artifact(scratch.file("/exec/root/dir/file2.txt"), rootDir);
+  }
+
+  @Test
+  public void testStringArgs() {
+    CustomCommandLine cl = CustomCommandLine.builder().add("--arg1").add("--arg2").build();
+    assertEquals(ImmutableList.of("--arg1", "--arg2"), cl.arguments());
+  }
+
+  @Test
+  public void testLabelArgs() throws SyntaxException {
+    CustomCommandLine cl = CustomCommandLine.builder().add(Label.parseAbsolute("//a:b")).build();
+    assertEquals(ImmutableList.of("//a:b"), cl.arguments());
+  }
+
+  @Test
+  public void testStringsArgs() {
+    CustomCommandLine cl = CustomCommandLine.builder().add("--arg",
+        ImmutableList.of("a", "b")).build();
+    assertEquals(ImmutableList.of("--arg", "a", "b"), cl.arguments());
+  }
+
+  @Test
+  public void testArtifactExecPathArgs() {
+    CustomCommandLine cl = CustomCommandLine.builder().addExecPath("--path", artifact1).build();
+    assertEquals(ImmutableList.of("--path", "dir/file1.txt"), cl.arguments());
+  }
+
+  @Test
+  public void testArtifactExecPathsArgs() {
+    CustomCommandLine cl = CustomCommandLine.builder().addExecPaths("--path",
+        ImmutableList.of(artifact1, artifact2)).build();
+    assertEquals(ImmutableList.of("--path", "dir/file1.txt", "dir/file2.txt"), cl.arguments());
+  }
+
+  @Test
+  public void testNestedSetArtifactExecPathsArgs() {
+    CustomCommandLine cl = CustomCommandLine.builder().addExecPaths(
+        NestedSetBuilder.<Artifact>stableOrder().add(artifact1).add(artifact2).build()).build();
+    assertEquals(ImmutableList.of("dir/file1.txt", "dir/file2.txt"), cl.arguments());
+  }
+
+  @Test
+  public void testArtifactJoinExecPathArgs() {
+    CustomCommandLine cl = CustomCommandLine.builder().addJoinExecPaths("--path", ":",
+        ImmutableList.of(artifact1, artifact2)).build();
+    assertEquals(ImmutableList.of("--path", "dir/file1.txt:dir/file2.txt"), cl.arguments());
+  }
+
+  @Test
+  public void testPathArgs() {
+    CustomCommandLine cl = CustomCommandLine.builder().addPath(artifact1.getExecPath()).build();
+    assertEquals(ImmutableList.of("dir/file1.txt"), cl.arguments());
+  }
+
+  @Test
+  public void testJoinPathArgs() {
+    CustomCommandLine cl = CustomCommandLine.builder().addJoinPaths(":",
+        ImmutableList.of(artifact1.getExecPath(), artifact2.getExecPath())).build();
+    assertEquals(ImmutableList.of("dir/file1.txt:dir/file2.txt"), cl.arguments());
+  }
+
+  @Test
+  public void testPathsArgs() {
+    CustomCommandLine cl = CustomCommandLine.builder().addPaths("%s:%s",
+        artifact1.getExecPath(), artifact1.getRootRelativePath()).build();
+    assertEquals(ImmutableList.of("dir/file1.txt:dir/file1.txt"), cl.arguments());
+  }
+
+  @Test
+  public void testCustomArgs() {
+    CustomCommandLine cl = CustomCommandLine.builder().add(new CustomArgv() {
+      @Override
+      public String argv() {
+        return "--arg";
+      }
+    }).build();
+    assertEquals(ImmutableList.of("--arg"), cl.arguments());
+  }
+
+  @Test
+  public void testCustomMultiArgs() {
+    CustomCommandLine cl = CustomCommandLine.builder().add(new CustomMultiArgv() {
+      @Override
+      public ImmutableList<String> argv() {
+        return ImmutableList.of("--arg1", "--arg2");
+      }
+    }).build();
+    assertEquals(ImmutableList.of("--arg1", "--arg2"), cl.arguments());
+  }
+
+  @Test
+  public void testCombinedArgs() {
+    CustomCommandLine cl = CustomCommandLine.builder()
+        .add("--arg")
+        .add("--args", ImmutableList.of("abc"))
+        .addExecPaths("--path1", ImmutableList.of(artifact1))
+        .addExecPath("--path2", artifact2)
+        .build();
+    assertEquals(ImmutableList.of("--arg", "--args", "abc", "--path1", "dir/file1.txt", "--path2",
+        "dir/file2.txt"), cl.arguments());
+  }
+
+  @Test
+  public void testAddNulls() {
+    CustomCommandLine cl = CustomCommandLine.builder()
+        .add("--args", null)
+        .addExecPaths(null, ImmutableList.of(artifact1))
+        .addExecPath(null, null)
+        .build();
+    assertEquals(ImmutableList.of(), cl.arguments());
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/actions/DigestUtilsTest.java b/src/test/java/com/google/devtools/build/lib/actions/DigestUtilsTest.java
new file mode 100644
index 0000000..2ed24a6
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/actions/DigestUtilsTest.java
@@ -0,0 +1,145 @@
+// Copyright 2015 Google Inc. 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.actions;
+
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertTrue;
+
+import com.google.common.base.Strings;
+import com.google.devtools.build.lib.actions.cache.DigestUtils;
+import com.google.devtools.build.lib.testutil.TestThread;
+import com.google.devtools.build.lib.testutil.TestUtils;
+import com.google.devtools.build.lib.util.BlazeClock;
+import com.google.devtools.build.lib.vfs.FileSystem;
+import com.google.devtools.build.lib.vfs.FileSystemUtils;
+import com.google.devtools.build.lib.vfs.Path;
+import com.google.devtools.build.lib.vfs.inmemoryfs.InMemoryFileSystem;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.IOException;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Tests for DigestUtils.
+ */
+@RunWith(JUnit4.class)
+public class DigestUtilsTest {
+
+  private static void assertMd5CalculationConcurrency(boolean expectConcurrent,
+      final boolean fastDigest, final int fileSize1, final int fileSize2) throws Exception {
+    final CountDownLatch barrierLatch = new CountDownLatch(2); // Used to block test threads.
+    final CountDownLatch readyLatch = new CountDownLatch(1);   // Used to block main thread.
+
+    FileSystem myfs = new InMemoryFileSystem(BlazeClock.instance()) {
+        @Override
+        protected byte[] getMD5Digest(Path path) throws IOException {
+          try {
+            barrierLatch.countDown();
+            readyLatch.countDown();
+            // Either both threads will be inside getMD5Digest at the same time or they
+            // both will be blocked.
+            barrierLatch.await();
+          } catch (Exception e) {
+            throw new IOException(e);
+          }
+          return super.getMD5Digest(path);
+        }
+
+        @Override
+        protected String getFastDigestFunctionType(Path path) {
+          return "MD5";
+        }
+
+        @Override
+        protected byte[] getFastDigest(Path path) throws IOException {
+          return fastDigest ? super.getMD5Digest(path) : null;
+        }
+    };
+
+    final Path myFile1 = myfs.getPath("/f1.dat");
+    final Path myFile2 = myfs.getPath("/f2.dat");
+    FileSystemUtils.writeContentAsLatin1(myFile1, Strings.repeat("a", fileSize1));
+    FileSystemUtils.writeContentAsLatin1(myFile2, Strings.repeat("b", fileSize2));
+
+     TestThread thread1 = new TestThread () {
+       @Override public void runTest() throws Exception {
+         DigestUtils.getDigestOrFail(myFile1, fileSize1);
+       }
+     };
+
+     TestThread thread2 = new TestThread () {
+       @Override public void runTest() throws Exception {
+         DigestUtils.getDigestOrFail(myFile2, fileSize2);
+       }
+     };
+
+     thread1.start();
+     thread2.start();
+     if (!expectConcurrent) { // Synchronized case.
+       // Wait until at least one thread reached getMD5Digest().
+       assertTrue(readyLatch.await(TestUtils.WAIT_TIMEOUT_SECONDS, TimeUnit.SECONDS));
+       // Only 1 thread should be inside getMD5Digest().
+       assertEquals(1, barrierLatch.getCount());
+       barrierLatch.countDown(); // Release barrier latch, allowing both threads to proceed.
+     }
+     // Test successful execution within 5 seconds.
+     thread1.joinAndAssertState(TestUtils.WAIT_TIMEOUT_MILLISECONDS);
+     thread2.joinAndAssertState(TestUtils.WAIT_TIMEOUT_MILLISECONDS);
+  }
+
+  /**
+   * Ensures that MD5 calculation is synchronized for files
+   * greater than 4096 bytes if MD5 is not available cheaply,
+   * so machines with rotating drives don't become unusable.
+   */
+  @Test
+  public void testMd5CalculationConcurrency() throws Exception {
+    assertMd5CalculationConcurrency(true, true, 4096, 4096);
+    assertMd5CalculationConcurrency(true, true, 4097, 4097);
+    assertMd5CalculationConcurrency(true, false, 4096, 4096);
+    assertMd5CalculationConcurrency(false, false, 4097, 4097);
+    assertMd5CalculationConcurrency(true, false, 1024, 4097);
+    assertMd5CalculationConcurrency(true, false, 1024, 1024);
+  }
+
+  @Test
+  public void testRecoverFromMalformedDigest() throws Exception {
+    final byte[] malformed = {0, 0, 0};
+    FileSystem myFS = new InMemoryFileSystem(BlazeClock.instance()) {
+      @Override
+      protected String getFastDigestFunctionType(Path path) {
+        return "MD5";
+      }
+
+      @Override
+      protected byte[] getFastDigest(Path path) throws IOException {
+        // MD5 digests are supposed to be 16 bytes.
+        return malformed;
+      }
+    };
+    Path path = myFS.getPath("/file");
+    FileSystemUtils.writeContentAsLatin1(path, "a");
+    byte[] result = DigestUtils.getDigestOrFail(path, 1);
+    assertArrayEquals(path.getMD5Digest(), result);
+    assertNotSame(malformed, result);
+    assertEquals(16, result.length);
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/actions/ExecutableSymlinkActionTest.java b/src/test/java/com/google/devtools/build/lib/actions/ExecutableSymlinkActionTest.java
new file mode 100644
index 0000000..50d0f25
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/actions/ExecutableSymlinkActionTest.java
@@ -0,0 +1,105 @@
+// Copyright 2015 Google Inc. 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.actions;
+
+
+import static com.google.devtools.build.lib.actions.util.ActionsTestUtil.NULL_ACTION_OWNER;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.devtools.build.lib.actions.util.DummyExecutor;
+import com.google.devtools.build.lib.analysis.actions.ExecutableSymlinkAction;
+import com.google.devtools.build.lib.exec.SingleBuildFileCache;
+import com.google.devtools.build.lib.testutil.Scratch;
+import com.google.devtools.build.lib.testutil.TestFileOutErr;
+import com.google.devtools.build.lib.vfs.FileSystemUtils;
+import com.google.devtools.build.lib.vfs.Path;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class ExecutableSymlinkActionTest {
+  private Scratch scratch = new Scratch();
+  private Root inputRoot;
+  private Root outputRoot;
+  TestFileOutErr outErr;
+  private Executor executor;
+
+  @Before
+  public void setUp() throws Exception {
+    final Path inputDir = scratch.dir("/in");
+    inputRoot = Root.asDerivedRoot(inputDir);
+    outputRoot = Root.asDerivedRoot(scratch.dir("/out"));
+    outErr = new TestFileOutErr();
+    executor = new DummyExecutor(inputDir);
+  }
+
+  private ActionExecutionContext createContext() {
+    Path execRoot = executor.getExecRoot();
+    return new ActionExecutionContext(
+        executor,
+        new SingleBuildFileCache(execRoot.getPathString(), execRoot.getFileSystem()),
+        null, outErr, null);
+  }
+
+  @Test
+  public void testSimple() throws Exception {
+    Path inputFile = inputRoot.getPath().getChild("some-file");
+    Path outputFile = outputRoot.getPath().getChild("some-output");
+    FileSystemUtils.createEmptyFile(inputFile);
+    inputFile.setExecutable(/*executable=*/true);
+    Artifact input = new Artifact(inputFile, inputRoot);
+    Artifact output = new Artifact(outputFile, outputRoot);
+    ExecutableSymlinkAction action = new ExecutableSymlinkAction(NULL_ACTION_OWNER, input, output);
+    action.execute(createContext());
+    assertEquals(inputFile, outputFile.resolveSymbolicLinks());
+  }
+
+  @Test
+  public void testFailIfInputIsNotAFile() throws Exception {
+    Path dir = inputRoot.getPath().getChild("some-dir");
+    FileSystemUtils.createDirectoryAndParents(dir);
+    Artifact input = new Artifact(dir, inputRoot);
+    Artifact output = new Artifact(outputRoot.getPath().getChild("some-output"), outputRoot);
+    ExecutableSymlinkAction action = new ExecutableSymlinkAction(NULL_ACTION_OWNER, input, output);
+    try {
+      action.execute(createContext());
+      fail();
+    } catch (ActionExecutionException e) {
+      assertTrue(e.getMessage().contains("'some-dir' is not a file"));
+    }
+  }
+
+  @Test
+  public void testFailIfInputIsNotExecutable() throws Exception {
+    Path file = inputRoot.getPath().getChild("some-file");
+    FileSystemUtils.createEmptyFile(file);
+    file.setExecutable(/*executable=*/false);
+    Artifact input = new Artifact(file, inputRoot);
+    Artifact output = new Artifact(outputRoot.getPath().getChild("some-output"), outputRoot);
+    ExecutableSymlinkAction action = new ExecutableSymlinkAction(NULL_ACTION_OWNER, input, output);
+    try {
+      action.execute(createContext());
+      fail();
+    } catch (ActionExecutionException e) {
+      String want = "'some-file' is not executable";
+      String got = e.getMessage();
+      assertTrue(String.format("got %s, want %s", got, want), got.contains(want));
+    }
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/actions/FailActionTest.java b/src/test/java/com/google/devtools/build/lib/actions/FailActionTest.java
new file mode 100644
index 0000000..7838fca
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/actions/FailActionTest.java
@@ -0,0 +1,81 @@
+// Copyright 2015 Google Inc. 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.actions;
+
+
+import static com.google.devtools.build.lib.actions.util.ActionsTestUtil.NULL_ACTION_OWNER;
+import static com.google.devtools.build.lib.testutil.MoreAsserts.assertSameContents;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.ImmutableList;
+import com.google.devtools.build.lib.testutil.Scratch;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.Collection;
+import java.util.Collections;
+
+@RunWith(JUnit4.class)
+public class FailActionTest {
+
+  private Scratch scratch = new Scratch();
+
+  private String errorMessage;
+  private Artifact anOutput;
+  private Collection<Artifact> outputs;
+  private FailAction failAction;
+
+  protected MutableActionGraph actionGraph = new MapBasedActionGraph();
+
+  @Before
+  public void setUp() throws Exception {
+    errorMessage = "An error just happened.";
+    anOutput = new Artifact(scratch.file("/out/foo"),
+        Root.asDerivedRoot(scratch.dir("/"), scratch.dir("/out")));
+    outputs = ImmutableList.of(anOutput);
+    failAction = new FailAction(NULL_ACTION_OWNER, outputs, errorMessage);
+    actionGraph.registerAction(failAction);
+    assertSame(failAction, actionGraph.getGeneratingAction(anOutput));
+  }
+
+  @Test
+  public void testExecutingItYieldsExceptionWithErrorMessage() {
+    try {
+      failAction.execute(null);
+      fail();
+    } catch (ActionExecutionException e) {
+      assertEquals(errorMessage, e.getMessage());
+    }
+  }
+
+  @Test
+  public void testInputsAreEmptySet() {
+    assertSameContents(Collections.emptySet(), failAction.getInputs());
+  }
+
+  @Test
+  public void testRetainsItsOutputs() {
+    assertSameContents(outputs, failAction.getOutputs());
+  }
+
+  @Test
+  public void testPrimaryOutput() {
+    assertSame(anOutput, failAction.getPrimaryOutput());
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/actions/LocalHostCapacityTest.java b/src/test/java/com/google/devtools/build/lib/actions/LocalHostCapacityTest.java
new file mode 100644
index 0000000..5e2e1a8
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/actions/LocalHostCapacityTest.java
@@ -0,0 +1,434 @@
+// Copyright 2015 Google Inc. 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.actions;
+
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import com.google.devtools.build.lib.util.Clock;
+import com.google.devtools.build.lib.util.StringUtilities;
+import com.google.devtools.build.lib.vfs.util.FsApparatus;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class LocalHostCapacityTest {
+
+  private FsApparatus scratch = FsApparatus.newNative();
+
+  @Test
+  public void testNonHyperthreadedMachine() throws Exception {
+    String cpuinfoContent = StringUtilities.joinLines(
+        "processor\t: 0",
+        "vendor_id\t: GenuineIntel",
+        "cpu family\t: 15",
+        "model\t\t: 4",
+        "model name\t:               Intel(R) Pentium(R) 4 CPU 3.40GHz",
+        "stepping\t: 10",
+        "cpu MHz\t\t: 3400.000",
+        "cache size\t: 2048 KB",
+        "fpu\t\t: yes",
+        "fpu_exception\t: yes",
+        "cpuid level\t: 5",
+        "wp\t\t: yes",
+        "flags\t\t: fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca "
+            + "cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm "
+            + "syscall nx lm constant_tsc up pni monitor ds_cpl est cid cx16 "
+            + "xtpr lahf_lm",
+        "bogomips\t: 6803.83",
+        "clflush size\t: 64",
+        "cache_alignment\t: 128",
+        "address sizes\t: 36 bits physical, 48 bits virtual",
+        "power management:"
+        );
+    String cpuinfoFile =
+        scratch.file("test_cpuinfo_nonht", cpuinfoContent).getPathString();
+    String meminfoContent = StringUtilities.joinLines(
+        "MemTotal:      3091732 kB",
+        "MemFree:       2167344 kB",
+        "Buffers:         60644 kB",
+        "Cached:         509940 kB",
+        "SwapCached:          0 kB",
+        "Active:         636892 kB",
+        "Inactive:       212760 kB",
+        "HighTotal:           0 kB",
+        "HighFree:            0 kB",
+        "LowTotal:      3091732 kB",
+        "LowFree:       2167344 kB",
+        "SwapTotal:     9124880 kB",
+        "SwapFree:      9124880 kB",
+        "Dirty:               0 kB",
+        "Writeback:           0 kB",
+        "AnonPages:      279028 kB",
+        "Mapped:          54404 kB",
+        "Slab:            42820 kB",
+        "PageTables:       5184 kB",
+        "NFS_Unstable:        0 kB",
+        "Bounce:              0 kB",
+        "CommitLimit:  10670744 kB",
+        "Committed_AS:   665840 kB",
+        "VmallocTotal: 34359738367 kB",
+        "VmallocUsed:    300484 kB",
+        "VmallocChunk: 34359437307 kB",
+        "HugePages_Total:     0",
+        "HugePages_Free:      0",
+        "HugePages_Rsvd:      0",
+        "Hugepagesize:     2048 kB"
+        );
+    String stat1Content = StringUtilities.joinLines(
+        "cpu 29793342 260290 3479274 636259369 6683218 656426 714057 0",
+        "cpu0 29793342 260290 3479274 636259369 6683218 656426 714057 0",
+        "intr 2870488853 2486517107 3 0 0 2 0 5 0 0 0 0 0 3 0 74363716 " +
+        "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 " +
+        "0 0 52483586 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 973315 0 0 0 0 0 0 0 46 " +
+        "0 0 0 0 0 0 0 98792358 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 " +
+        "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 " +
+        "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 114339590 " +
+        "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 " +
+        "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 43019122 0 0 0 0 0",
+        "ctxt 15053799843",
+        "btime 1199289688",
+        "processes 25799993",
+        "procs_running 1",
+        "procs_blocked 0"
+        );
+    String stat2Content = StringUtilities.joinLines(
+        "cpu 29794509 260290 3479474 636287862 6683283 656450 714087 0 0",
+        "cpu0 29794509 260290 3479474 636287862 6683283 656450 714087 0 0",
+        "intr 2870488853 2486517107 3 0 0 2 0 5 0 0 0 0 0 3 0 74363716 " +
+        "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 " +
+        "0 0 52483586 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 973315 0 0 0 0 0 0 0 46 " +
+        "0 0 0 0 0 0 0 98792358 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 " +
+        "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 " +
+        "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 114339590 " +
+        "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 " +
+        "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 43019122 0 0 0 0 0",
+        "ctxt 15053799843",
+        "btime 1199289688",
+        "processes 25799993",
+        "procs_running 1",
+        "procs_blocked 0"
+        );
+    String meminfoFile =
+        scratch.file("test_meminfo_nonht", meminfoContent).getPathString();
+    String stat1File =
+      scratch.file("proc_stat_1", stat1Content).getPathString();
+    String stat2File =
+      scratch.file("proc_stat_2", stat2Content).getPathString();
+    assertEquals(1, LocalHostCapacity.getLogicalCpuCount(cpuinfoContent));
+    assertEquals(1, LocalHostCapacity.getPhysicalCpuCount(cpuinfoContent, 1));
+    assertEquals(1, LocalHostCapacity.getCoresPerCpu(cpuinfoContent));
+    ResourceSet capacity =
+        LocalHostCapacity.getLocalHostCapacity(cpuinfoFile, meminfoFile);
+    assertEquals(1.0, capacity.getCpuUsage(), 0.01);
+    assertEquals(3091.732, capacity.getMemoryMb(), 0.1); // +/- 0.1MB
+    LocalHostCapacity.setLocalHostCapacity(capacity);
+    assertSame(capacity, LocalHostCapacity.getLocalHostCapacity());
+    Clock mockedClock = new Clock() {
+      private int callCount = 0;
+
+      @Override
+      public long currentTimeMillis() {
+        throw new AssertionError("unexpected method call");
+      }
+
+      @Override
+      public long nanoTime() {
+        callCount++;
+        if (callCount == 1) {
+          return 0;
+        } else if (callCount == 2) {
+          return 100 * 1000000;
+        } else if (callCount == 3) {
+          return 200 * 1000000;
+        } else {
+          throw new AssertionError("unexpected method call");
+        }
+      }
+    };
+    LocalHostCapacity.FreeResources freeStats =
+      LocalHostCapacity.getFreeResources(mockedClock, meminfoFile, stat1File, null);
+    assertNotNull(freeStats);
+    assertEquals(2356.756, freeStats.getFreeMb(), 0.001);
+    assertEquals(0.0, freeStats.getAvgFreeCpu(), 0);
+    // The next call to the mock clock returns a timestamp as if 100 ms have passed.
+    assertTrue(freeStats.getReadingAge() > 50);
+    // Fake another 100 ms going by for the next call.
+    freeStats = LocalHostCapacity.getFreeResources(mockedClock, meminfoFile, stat2File, freeStats);
+    assertNotNull(freeStats);
+    assertEquals(2356.756, freeStats.getFreeMb(), 0.001);
+    assertTrue(freeStats.getInterval() > 100);
+    assertEquals(0.95, freeStats.getAvgFreeCpu(), 0.001);
+  }
+
+  @Test
+  public void testHyperthreadedMachine() throws Exception {
+    String cpuinfoContent = StringUtilities.joinLines(
+        "processor\t: 0",
+        "vendor_id\t: GenuineIntel",
+        "cpu family\t: 15",
+        "model\t\t: 4",
+        "model name\t:               Intel(R) Pentium(R) 4 CPU 3.40GHz",
+        "stepping\t: 1",
+        "cpu MHz\t\t: 3400.245",
+        "cache size\t: 1024 KB",
+        "physical id\t: 0",
+        "siblings\t: 2",
+        "core id\t\t: 0",
+        "cpu cores\t: 1",
+        "fpu\t\t: yes",
+        "fpu_exception\t: yes",
+        "cpuid level\t: 5",
+        "wp\t\t: yes",
+        "flags\t\t: fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge "
+            + "mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm "
+            + "syscall lm constant_tsc pni monitor ds_cpl cid cx16 xtpr",
+        "bogomips\t: 6806.31",
+        "clflush size\t: 64",
+        "cache_alignment\t: 128",
+        "address sizes\t: 36 bits physical, 48 bits virtual",
+        "power management:",
+        "",
+        "processor\t: 1",
+        "vendor_id\t: GenuineIntel",
+        "cpu family\t: 15",
+        "model\t\t: 4",
+        "model name\t:               Intel(R) Pentium(R) 4 CPU 3.40GHz",
+        "stepping\t: 1",
+        "cpu MHz\t\t: 3400.245",
+        "cache size\t: 1024 KB",
+        "physical id\t: 0",
+        "siblings\t: 2",
+        "core id\t\t: 0",
+        "cpu cores\t: 1",
+        "fpu\t\t: yes",
+        "fpu_exception\t: yes",
+        "cpuid level\t: 5",
+        "wp\t\t: yes",
+        "flags\t\t: fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge "
+            + "mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm "
+            + "syscall lm constant_tsc pni monitor ds_cpl cid cx16 xtpr",
+        "bogomips\t: 6800.76",
+        "clflush size\t: 64",
+        "cache_alignment\t: 128",
+        "address sizes\t: 36 bits physical, 48 bits virtual",
+        "power management:",
+        ""
+        );
+    String cpuinfoFile =
+        scratch.file("test_cpuinfo_ht", cpuinfoContent).getPathString();
+    String meminfoContent = StringUtilities.joinLines(
+        "MemTotal:      3092004 kB",
+        "MemFree:         26124 kB",
+        "Buffers:          3836 kB",
+        "Cached:          52400 kB",
+        "SwapCached:      68204 kB",
+        "Active:        2281464 kB",
+        "Inactive:       260908 kB",
+        "HighTotal:           0 kB",
+        "HighFree:            0 kB",
+        "LowTotal:      3092004 kB",
+        "LowFree:         26124 kB",
+        "SwapTotal:     9124880 kB",
+        "SwapFree:      8264920 kB",
+        "Dirty:             616 kB",
+        "Writeback:           0 kB",
+        "AnonPages:     2466336 kB",
+        "Mapped:          37576 kB",
+        "Slab:           483004 kB",
+        "PageTables:      11912 kB",
+        "NFS_Unstable:        0 kB",
+        "Bounce:              0 kB",
+        "CommitLimit:  10670880 kB",
+        "Committed_AS:  3627984 kB",
+        "VmallocTotal: 34359738367 kB",
+        "VmallocUsed:    300460 kB",
+        "VmallocChunk: 34359437307 kB",
+        "HugePages_Total:     0",
+        "HugePages_Free:      0",
+        "HugePages_Rsvd:      0",
+        "Hugepagesize:     2048 kB"
+        );
+    String meminfoFile =
+        scratch.file("test_meminfo_ht", meminfoContent).getPathString();
+    assertEquals(2, LocalHostCapacity.getLogicalCpuCount(cpuinfoContent));
+    assertEquals(1, LocalHostCapacity.getPhysicalCpuCount(cpuinfoContent, 2));
+    assertEquals(1, LocalHostCapacity.getCoresPerCpu(cpuinfoContent));
+    ResourceSet capacity =
+        LocalHostCapacity.getLocalHostCapacity(cpuinfoFile, meminfoFile);
+    assertEquals(1.2, capacity.getCpuUsage(), .0001);
+    assertEquals(3092.004, capacity.getMemoryMb(), 0.1); // +/- 0.1MB
+  }
+
+  @Test
+  public void testAMDMachine() throws Exception {
+    String cpuinfoContent = StringUtilities.joinLines(
+        "processor\t: 0",
+        "vendor_id\t: AuthenticAMD",
+        "cpu family\t: 15",
+        "model\t\t: 65",
+        "model name\t: Dual-Core AMD Opteron(tm) Processor 8214 HE",
+        "stepping\t: 2",
+        "cpu MHz\t\t: 2200.000",
+        "cache size\t: 1024 KB",
+        "physical id\t: 0",
+        "siblings\t: 2",
+        "core id\t\t: 0",
+        "cpu cores\t: 2",
+        "fpu\t\t: yes",
+        "fpu_exception\t: yes",
+        "cpuid level\t: 1",
+        "wp\t\t: yes",
+        "flags\t\t: fpu vme de pse tsc msr pae mce cx8 apic sep mtrr "
+            + "pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ht syscall "
+            + "nx mmxext fxsr_opt rdtscp lm 3dnowext 3dnow pni cx16 lahf_lm "
+            + "cmp_legacy svm cr8_legacy",
+        "bogomips\t: 4425.84",
+        "TLB size\t: 1024 4K pages",
+        "clflush size\t: 64",
+        "cache_alignment\t: 64",
+        "address sizes\t: 40 bits physical, 48 bits virtual",
+        "power management: ts fid vid ttp tm stc",
+        "",
+        "processor\t: 1",
+        "vendor_id\t: AuthenticAMD",
+        "cpu family\t: 15",
+        "model\t\t: 65",
+        "model name\t: Dual-Core AMD Opteron(tm) Processor 8214 HE",
+        "stepping\t: 2",
+        "cpu MHz\t\t: 2200.000",
+        "cache size\t: 1024 KB",
+        "physical id\t: 0",
+        "siblings\t: 2",
+        "core id\t\t: 1",
+        "cpu cores\t: 2",
+        "fpu\t\t: yes",
+        "fpu_exception\t: yes",
+        "cpuid level\t: 1",
+        "wp\t\t: yes",
+        "flags\t\t: fpu vme de pse tsc msr pae mce cx8 apic sep mtrr "
+            + "pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ht syscall "
+            + "nx mmxext fxsr_opt rdtscp lm 3dnowext 3dnow pni cx16 lahf_lm "
+            + "cmp_legacy svm cr8_legacy",
+        "bogomips\t: 4460.61",
+        "TLB size\t: 1024 4K pages",
+        "clflush size\t: 64",
+        "cache_alignment\t: 64",
+        "address sizes\t: 40 bits physical, 48 bits virtual",
+        "power management: ts fid vid ttp tm stc",
+        "",
+        "processor\t: 2",
+        "vendor_id\t: AuthenticAMD",
+        "cpu family\t: 15",
+        "model\t\t: 65",
+        "model name\t: Dual-Core AMD Opteron(tm) Processor 8214 HE",
+        "stepping\t: 2",
+        "cpu MHz\t\t: 2200.000",
+        "cache size\t: 1024 KB",
+        "physical id\t: 1",
+        "siblings\t: 2",
+        "core id\t\t: 0",
+        "cpu cores\t: 2",
+        "fpu\t\t: yes",
+        "fpu_exception\t: yes",
+        "cpuid level\t: 1",
+        "wp\t\t: yes",
+        "flags\t\t: fpu vme de pse tsc msr pae mce cx8 apic sep mtrr "
+            + "pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ht syscall "
+            + "nx mmxext fxsr_opt rdtscp lm 3dnowext 3dnow pni cx16 lahf_lm "
+            + "cmp_legacy svm cr8_legacy",
+        "bogomips\t: 4420.45",
+        "TLB size\t: 1024 4K pages",
+        "clflush size\t: 64",
+        "cache_alignment\t: 64",
+        "address sizes\t: 40 bits physical, 48 bits virtual",
+        "power management: ts fid vid ttp tm stc",
+        "",
+        "processor\t: 3",
+        "vendor_id\t: AuthenticAMD",
+        "cpu family\t: 15",
+        "model\t\t: 65",
+        "model name\t: Dual-Core AMD Opteron(tm) Processor 8214 HE",
+        "stepping\t: 2",
+        "cpu MHz\t\t: 2200.000",
+        "cache size\t: 1024 KB",
+        "physical id\t: 1",
+        "siblings\t: 2",
+        "core id\t\t: 1",
+        "cpu cores\t: 2",
+        "fpu\t\t: yes",
+        "fpu_exception\t: yes",
+        "cpuid level\t: 1",
+        "wp\t\t: yes",
+        "flags\t\t: fpu vme de pse tsc msr pae mce cx8 apic sep mtrr "
+            + "pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ht syscall "
+            + "nx mmxext fxsr_opt rdtscp lm 3dnowext 3dnow pni cx16 lahf_lm "
+            + "cmp_legacy svm cr8_legacy",
+        "bogomips\t: 4460.39",
+        "TLB size\t: 1024 4K pages",
+        "clflush size\t: 64",
+        "cache_alignment\t: 64",
+        "address sizes\t: 40 bits physical, 48 bits virtual",
+        "power management: ts fid vid ttp tm stc",
+        ""
+        );
+    String cpuinfoFile =
+        scratch.file("test_cpuinfo_amd", cpuinfoContent).getPathString();
+    String meminfoContent = StringUtilities.joinLines(
+        "MemTotal:      8223956 kB",
+        "MemFree:       3670396 kB",
+        "Buffers:        374068 kB",
+        "Cached:        3366980 kB",
+        "SwapCached:          0 kB",
+        "Active:        3275860 kB",
+        "Inactive:       737816 kB",
+        "HighTotal:           0 kB",
+        "HighFree:            0 kB",
+        "LowTotal:      8223956 kB",
+        "LowFree:       3670396 kB",
+        "SwapTotal:     6024332 kB",
+        "SwapFree:      6024332 kB",
+        "Dirty:              84 kB",
+        "Writeback:           0 kB",
+        "AnonPages:      272308 kB",
+        "Mapped:          62604 kB",
+        "Slab:           506140 kB",
+        "PageTables:       4608 kB",
+        "NFS_Unstable:        0 kB",
+        "Bounce:              0 kB",
+        "CommitLimit:  10136308 kB",
+        "Committed_AS:   600672 kB",
+        "VmallocTotal: 34359738367 kB",
+        "VmallocUsed:    299068 kB",
+        "VmallocChunk: 34359438843 kB",
+        "HugePages_Total:     0",
+        "HugePages_Free:      0",
+        "HugePages_Rsvd:      0",
+        "Hugepagesize:     2048 kB");
+    String meminfoFile =
+        scratch.file("test_meminfo_amd", meminfoContent).getPathString();
+    assertEquals(4, LocalHostCapacity.getLogicalCpuCount(cpuinfoContent));
+    assertEquals(2, LocalHostCapacity.getPhysicalCpuCount(cpuinfoContent, 4));
+    assertEquals(2, LocalHostCapacity.getCoresPerCpu(cpuinfoContent));
+    ResourceSet capacity =
+        LocalHostCapacity.getLocalHostCapacity(cpuinfoFile, meminfoFile);
+    assertEquals(capacity.getCpuUsage(), 4.0, 0.01);
+    assertEquals(8223.956, capacity.getMemoryMb(), 0.1); // +/- 0.1MB
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/actions/MapBasedActionGraphTest.java b/src/test/java/com/google/devtools/build/lib/actions/MapBasedActionGraphTest.java
new file mode 100644
index 0000000..cde9aed3
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/actions/MapBasedActionGraphTest.java
@@ -0,0 +1,147 @@
+// Copyright 2015 Google Inc. 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.actions;
+
+
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Sets;
+import com.google.devtools.build.lib.actions.MutableActionGraph.ActionConflictException;
+import com.google.devtools.build.lib.actions.util.ActionsTestUtil.UncheckedActionConflictException;
+import com.google.devtools.build.lib.actions.util.TestAction;
+import com.google.devtools.build.lib.concurrent.AbstractQueueVisitor;
+import com.google.devtools.build.lib.util.BlazeClock;
+import com.google.devtools.build.lib.vfs.FileSystem;
+import com.google.devtools.build.lib.vfs.Path;
+import com.google.devtools.build.lib.vfs.inmemoryfs.InMemoryFileSystem;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * Tests for {@link MapBasedActionGraph}.
+ */
+@RunWith(JUnit4.class)
+public class MapBasedActionGraphTest {
+  @Test
+  public void testSmoke() throws Exception {
+    MutableActionGraph actionGraph = new MapBasedActionGraph();
+    FileSystem fileSystem = new InMemoryFileSystem(BlazeClock.instance());
+    Path path = fileSystem.getPath("/root/foo");
+    Artifact output = new Artifact(path, Root.asDerivedRoot(path));
+    Action action = new TestAction(TestAction.NO_EFFECT,
+        ImmutableSet.<Artifact>of(), ImmutableSet.of(output));
+    actionGraph.registerAction(action);
+    actionGraph.unregisterAction(action);
+    path = fileSystem.getPath("/root/bar");
+    output = new Artifact(path, Root.asDerivedRoot(path));
+    Action action2 = new TestAction(TestAction.NO_EFFECT,
+        ImmutableSet.<Artifact>of(), ImmutableSet.of(output));
+    actionGraph.registerAction(action);
+    actionGraph.registerAction(action2);
+    actionGraph.unregisterAction(action);
+  }
+
+  @Test
+  public void testNoActionConflictWhenUnregisteringSharedAction() throws Exception {
+    MutableActionGraph actionGraph = new MapBasedActionGraph();
+    FileSystem fileSystem = new InMemoryFileSystem(BlazeClock.instance());
+    Path path = fileSystem.getPath("/root/foo");
+    Artifact output = new Artifact(path, Root.asDerivedRoot(path));
+    Action action = new TestAction(TestAction.NO_EFFECT,
+        ImmutableSet.<Artifact>of(), ImmutableSet.of(output));
+    actionGraph.registerAction(action);
+    Action otherAction = new TestAction(TestAction.NO_EFFECT,
+        ImmutableSet.<Artifact>of(), ImmutableSet.of(output));
+    actionGraph.registerAction(otherAction);
+    actionGraph.unregisterAction(action);
+  }
+
+  private class ActionRegisterer extends AbstractQueueVisitor {
+    private final MutableActionGraph graph = new MapBasedActionGraph();
+    private final Artifact output;
+    // Just to occasionally add actions that were already present.
+    private final Set<Action> allActions = Sets.newConcurrentHashSet();
+    private final AtomicInteger actionCount = new AtomicInteger(0);
+
+    private ActionRegisterer() {
+      super(/*concurrent=*/true, 200, 200, 1, TimeUnit.SECONDS,
+          /*failFastOnException=*/true, /*failFastOnInterrupt=*/true, "action-graph-test");
+      FileSystem fileSystem = new InMemoryFileSystem(BlazeClock.instance());
+      Path path = fileSystem.getPath("/root/foo");
+      output = new Artifact(path, Root.asDerivedRoot(path));
+      allActions.add(new TestAction(TestAction.NO_EFFECT,
+          ImmutableSet.<Artifact>of(), ImmutableSet.of(output)));
+    }
+
+    private void registerAction(final Action action) {
+      enqueue(new Runnable() {
+        @Override
+        public void run() {
+          try {
+            graph.registerAction(action);
+          } catch (ActionConflictException e) {
+            throw new UncheckedActionConflictException(e);
+          }
+          doRandom();
+        }
+      });
+    }
+
+    private void unregisterAction(final Action action) {
+      enqueue(new Runnable() {
+        @Override
+        public void run() {
+          graph.unregisterAction(action);
+          doRandom();
+        }
+      });
+    }
+
+    private void doRandom() {
+      if (actionCount.incrementAndGet() > 10000) {
+        return;
+      }
+      Action action = null;
+      if (Math.random() < 0.5) {
+        action = Iterables.getFirst(allActions, null);
+      } else {
+        action = new TestAction(TestAction.NO_EFFECT,
+            ImmutableSet.<Artifact>of(), ImmutableSet.of(output));
+        allActions.add(action);
+      }
+      if (Math.random() < 0.5) {
+        registerAction(action);
+      } else {
+        unregisterAction(action);
+      }
+    }
+
+    private void work() throws InterruptedException {
+      work(/*failFastOnInterrupt=*/true);
+    }
+  }
+
+  @Test
+  public void testSharedActionStressTest() throws Exception {
+    ActionRegisterer actionRegisterer = new ActionRegisterer();
+    actionRegisterer.doRandom();
+    actionRegisterer.work();
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/actions/ResourceManagerTest.java b/src/test/java/com/google/devtools/build/lib/actions/ResourceManagerTest.java
new file mode 100644
index 0000000..4955288
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/actions/ResourceManagerTest.java
@@ -0,0 +1,400 @@
+// Copyright 2015 Google Inc. 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.actions;
+
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.common.eventbus.EventBus;
+import com.google.devtools.build.lib.testutil.TestThread;
+import com.google.devtools.common.options.OptionsParsingException;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.concurrent.CyclicBarrier;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import javax.annotation.Nullable;
+
+/**
+ *
+ * Tests for @{link ResourceManager}.
+ */
+@RunWith(JUnit4.class)
+public class ResourceManagerTest {
+
+  private final ActionMetadata resourceOwner = new ResourceOwnerStub();
+  private final ResourceManager rm = ResourceManager.instanceForTestingOnly();
+  private AtomicInteger counter;
+  CyclicBarrier sync;
+  CyclicBarrier sync2;
+
+  @Before
+  public void setUp() throws Exception {
+    rm.setRamUtilizationPercentage(100);
+    rm.setAvailableResources(new ResourceSet(1000, 1, 1));
+    rm.setEventBus(new EventBus());
+    counter = new AtomicInteger(0);
+    sync = new CyclicBarrier(2);
+    sync2 = new CyclicBarrier(2);
+    rm.resetResourceUsage();
+  }
+
+  private void acquire(double ram, double cpu, double io) throws InterruptedException {
+    rm.acquireResources(resourceOwner, new ResourceSet(ram, cpu, io));
+  }
+
+  private boolean acquireNonblocking(double ram, double cpu, double io) {
+    return rm.tryAcquire(resourceOwner, new ResourceSet(ram, cpu, io));
+  }
+
+  private void release(double ram, double cpu, double io) {
+    rm.releaseResources(resourceOwner, new ResourceSet(ram, cpu, io));
+  }
+
+  private void validate (int count) {
+    assertEquals(count, counter.incrementAndGet());
+  }
+
+  @Test
+  public void testIndependentLargeRequests() throws Exception {
+    // Available: 1000 RAM and 1 CPU.
+    assertFalse(rm.inUse());
+    acquire(10000, 0, 0); // Available: 0 RAM 1 CPU 1 IO.
+    acquire(0, 100, 0);   // Available: 0 RAM 0 CPU 1 IO.
+    acquire(0, 0, 1);     // Available: 0 RAM 0 CPU 0 IO.
+    assertTrue(rm.inUse());
+    release(9500, 0, 0);  // Available: 500 RAM 0 CPU 0 IO.
+    acquire(400, 0, 0);   // Available: 100 RAM 0 CPU 0 IO.
+    release(0, 99.5, 0.6);  // Available: 100 RAM 0.5 CPU 0.4 IO.
+    acquire(100, 0.5, 0.4); // Available: 0 RAM 0 CPU 0 IO.
+    release(1000, 1, 1);  // Available: 1000 RAM 1 CPU 1 IO.
+    assertFalse(rm.inUse());
+  }
+
+  @Test
+  public void testOverallocation() throws Exception {
+    // Since ResourceManager.MIN_NECESSARY_RAM_RATIO = 1.0, overallocation is
+    // enabled only for the CPU resource.
+    assertFalse(rm.inUse());
+    acquire(900, 0.5, 0.1);  // Available: 100 RAM 0.5 CPU 0.9 IO.
+    acquire(100, 0.6, 0.9);  // Available: 0 RAM 0 CPU 0 IO.
+    release(100, 0.6, 0.9);  // Available: 100 RAM 0.5 CPU 0.9 IO.
+    acquire(100, 0.1, 0.1);  // Available: 0 RAM 0.4 CPU 0.8 IO.
+    acquire(0, 0.5, 0.8);    // Available: 0 RAM 0 CPU 0.8 IO.
+    release(1020, 1.1, 1.05); // Available: 1000 RAM 1 CPU 1 IO.
+    assertFalse(rm.inUse());
+  }
+
+  @Test
+  public void testNonblocking() throws Exception {
+    assertFalse(rm.inUse());
+    assertTrue(acquireNonblocking(900, 0.5, 0));  // Available: 100 RAM 0.5 CPU 1 IO.
+    assertTrue(acquireNonblocking(100, 0.5, 0.2));  // Available: 0 RAM 0 CPU 0.8 IO.
+    assertFalse(acquireNonblocking(.1, .01, 0.0));
+    assertFalse(acquireNonblocking(0, 0, 0.9));
+    assertTrue(acquireNonblocking(0, 0, 0.8));  // Available: 0 RAM 0 CPU 0 IO.
+    release(100, 0.5, 0.1);  // Available: 100 RAM 0.5 CPU 0.1 IO.
+    assertTrue(acquireNonblocking(100, 0.1, 0.1));  // Available: 0 RAM 0.4 CPU 0 IO.
+    assertFalse(acquireNonblocking(5, .5, 0));
+    assertFalse(acquireNonblocking(0, .5, 0.1));
+    assertTrue(acquireNonblocking(0, 0.4, 0));    // Available: 0 RAM 0 CPU 0 IO.
+    release(1000, 1, 1); // Available: 1000 RAM 1 CPU 1 IO.
+    assertFalse(rm.inUse());
+  }
+
+  @Test
+  public void testHasResources() throws Exception {
+    assertFalse(rm.inUse());
+    assertFalse(rm.threadHasResources());
+    acquire(1, .1, .1);
+    assertTrue(rm.threadHasResources());
+
+    // We have resources in this thread - make sure other threads
+    // are not affected.
+    TestThread thread1 = new TestThread () {
+      @Override public void runTest() throws Exception {
+        assertFalse(rm.threadHasResources());
+        acquire(1, 0, 0);
+        assertTrue(rm.threadHasResources());
+        release(1, 0, 0);
+        assertFalse(rm.threadHasResources());
+        acquire(0, 0.1, 0);
+        assertTrue(rm.threadHasResources());
+        release(0, 0.1, 0);
+        assertFalse(rm.threadHasResources());
+        acquire(0, 0, 0.1);
+        assertTrue(rm.threadHasResources());
+        release(0, 0, 0.1);
+        assertFalse(rm.threadHasResources());
+      }
+    };
+    thread1.start();
+    thread1.joinAndAssertState(10000);
+
+    release(1, .1, .1);
+    assertFalse(rm.threadHasResources());
+    assertFalse(rm.inUse());
+  }
+
+  @Test
+  public void testConcurrentLargeRequests() throws Exception {
+    assertFalse(rm.inUse());
+    TestThread thread1 = new TestThread () {
+      @Override public void runTest() throws Exception {
+        acquire(2000, 2, 0);
+        sync.await();
+        validate(1);
+        sync.await();
+        // Wait till other thread will be locked.
+        while (rm.getWaitCount() == 0) {
+          Thread.yield();
+        }
+        release(2000, 2, 0);
+        assertEquals(0, rm.getWaitCount());
+        acquire(2000, 2, 0); // Will be blocked by the thread2.
+        validate(3);
+        release(2000, 2, 0);
+      }
+    };
+    TestThread thread2 = new TestThread () {
+      @Override public void runTest() throws Exception {
+        sync2.await();
+        assertFalse(rm.isAvailable(2000, 2, 0));
+        acquire(2000, 2, 0); // Will be blocked by the thread1.
+        validate(2);
+        sync2.await();
+        // Wait till other thread will be locked.
+        while (rm.getWaitCount() == 0) {
+          Thread.yield();
+        }
+        release(2000, 2, 0);
+      }
+    };
+
+    thread1.start();
+    thread2.start();
+    sync.await(1, TimeUnit.SECONDS);
+    assertTrue(rm.inUse());
+    assertEquals(0, rm.getWaitCount());
+    sync2.await(1, TimeUnit.SECONDS);
+    sync.await(1, TimeUnit.SECONDS);
+    sync2.await(1, TimeUnit.SECONDS);
+    thread1.joinAndAssertState(1000);
+    thread2.joinAndAssertState(1000);
+    assertFalse(rm.inUse());
+  }
+
+  @Test
+  public void testOutOfOrderAllocation() throws Exception {
+    assertFalse(rm.inUse());
+    TestThread thread1 = new TestThread () {
+      @Override public void runTest() throws Exception {
+        sync.await();
+        acquire(900, 0.5, 0); // Will be blocked by the main thread.
+        validate(5);
+        release(900, 0.5, 0);
+        sync.await();
+      }
+    };
+    TestThread thread2 = new TestThread() {
+      @Override public void runTest() throws Exception {
+        // Wait till other thread will be locked
+        while (rm.getWaitCount() == 0) {
+          Thread.yield();
+        }
+        acquire(100, 0.1, 0);
+        validate(2);
+        release(100, 0.1, 0);
+        sync2.await();
+        acquire(200, 0.5, 0);
+        validate(4);
+        sync2.await();
+        release(200, 0.5, 0);
+      }
+    };
+    acquire(900, 0.9, 0);
+    validate(1);
+    thread1.start();
+    sync.await(1, TimeUnit.SECONDS);
+    thread2.start();
+    sync2.await(1, TimeUnit.SECONDS);
+    //Waiting till both threads are locked.
+    while (rm.getWaitCount() < 2) {
+      Thread.yield();
+    }
+    validate(3); // Thread1 is now first in the queue and Thread2 is second.
+    release(100, 0.4, 0); // This allows Thread2 to continue out of order.
+    sync2.await(1, TimeUnit.SECONDS);
+    release(750, 0.3, 0); // At this point thread1 will finally acquire resources.
+    sync.await(1, TimeUnit.SECONDS);
+    release(50, 0.2, 0);
+    thread1.join();
+    thread2.join();
+    assertFalse(rm.inUse());
+  }
+
+  @Test
+  public void testSingleton() throws Exception {
+    ResourceManager.instance();
+  }
+
+  /**
+   * Checks that that resource manager
+   * can recover from LocalHostCapacity.getFreeResources() failure.
+   */
+  @Test
+  public void testAutoSenseFailure() throws Exception {
+    boolean isDisabled = LocalHostCapacity.isDisabled;
+    assertFalse(rm.inUse());
+    try {
+      rm.setAutoSensing(true);
+      // Resource manager autosense state should be enabled now if
+      // LocalHostCapacity class supports it.
+      assertEquals(rm.isAutoSensingEnabled(), !LocalHostCapacity.isDisabled);
+      rm.setAutoSensing(false);
+      assertFalse(rm.isAutoSensingEnabled());
+
+      // Emulate failure to parse /proc/* filesystem.
+      LocalHostCapacity.isDisabled = true;
+      rm.setAutoSensing(true);
+      assertFalse(rm.isAutoSensingEnabled());
+      rm.setAutoSensing(false);
+      assertFalse(rm.isAutoSensingEnabled());
+    } finally {
+      LocalHostCapacity.isDisabled = isDisabled;
+      rm.setAutoSensing(false);
+    }
+    assertFalse(rm.inUse());
+  }
+
+  @Test
+  public void testResourceSetConverter() throws Exception {
+    ResourceSet.ResourceSetConverter converter = new ResourceSet.ResourceSetConverter();
+
+    ResourceSet resources = converter.convert("1,0.5,2");
+    assertEquals(1.0, resources.getMemoryMb(), 0.01);
+    assertEquals(0.5, resources.getCpuUsage(), 0.01);
+    assertEquals(2.0, resources.getIoUsage(), 0.01);
+
+    try {
+      converter.convert("0,0,");
+      fail();
+    } catch (OptionsParsingException ope) {
+      // expected
+    }
+
+    try {
+      converter.convert("0,0,0,0");
+      fail();
+    } catch (OptionsParsingException ope) {
+      // expected
+    }
+
+    try {
+      converter.convert("-1,0,0");
+      fail();
+    } catch (OptionsParsingException ope) {
+      // expected
+    }
+  }
+
+  private static class ResourceOwnerStub implements ActionMetadata {
+
+    @Override
+    @Nullable
+    public String getProgressMessage() {
+      throw new IllegalStateException();
+    }
+
+    @Override
+    public ActionOwner getOwner() {
+      throw new IllegalStateException();
+    }
+
+    @Override
+    public String prettyPrint() {
+      throw new IllegalStateException();
+    }
+
+    @Override
+    public String getMnemonic() {
+      throw new IllegalStateException();
+    }
+
+    @Override
+    public String describeStrategy(Executor executor) {
+      throw new IllegalStateException();
+    }
+
+    @Override
+    public boolean inputsKnown() {
+      throw new IllegalStateException();
+    }
+
+    @Override
+    public boolean discoversInputs() {
+      throw new IllegalStateException();
+    }
+
+    @Override
+    public Iterable<Artifact> getInputs() {
+      throw new IllegalStateException();
+    }
+
+    @Override
+    public int getInputCount() {
+      throw new IllegalStateException();
+    }
+
+    @Override
+    public ImmutableSet<Artifact> getOutputs() {
+      throw new IllegalStateException();
+    }
+
+    @Override
+    public Artifact getPrimaryInput() {
+      throw new IllegalStateException();
+    }
+
+    @Override
+    public Artifact getPrimaryOutput() {
+      throw new IllegalStateException();
+    }
+
+    @Override
+    public Iterable<Artifact> getMandatoryInputs() {
+      throw new IllegalStateException();
+    }
+
+    @Override
+    public String getKey() {
+      throw new IllegalStateException();
+    }
+
+    @Override
+    @Nullable
+    public String describeKey() {
+      throw new IllegalStateException();
+    }
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/actions/RootTest.java b/src/test/java/com/google/devtools/build/lib/actions/RootTest.java
new file mode 100644
index 0000000..c8fc14b
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/actions/RootTest.java
@@ -0,0 +1,132 @@
+// Copyright 2015 Google Inc. 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.actions;
+
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.devtools.build.lib.testutil.Scratch;
+import com.google.devtools.build.lib.vfs.Path;
+import com.google.devtools.build.lib.vfs.PathFragment;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.IOException;
+
+/**
+ * Tests for {@link Root}.
+ */
+@RunWith(JUnit4.class)
+public class RootTest {
+  private Scratch scratch = new Scratch();
+
+  @Test
+  public void testAsSourceRoot() throws IOException {
+    Path sourceDir = scratch.dir("/source");
+    Root root = Root.asSourceRoot(sourceDir);
+    assertTrue(root.isSourceRoot());
+    assertEquals(PathFragment.EMPTY_FRAGMENT, root.getExecPath());
+    assertEquals(sourceDir, root.getPath());
+    assertEquals("/source[source]", root.toString());
+  }
+
+  @Test
+  public void testBadAsSourceRoot() {
+    try {
+      Root.asSourceRoot(null);
+      fail();
+    } catch (NullPointerException expected) {
+    }
+  }
+
+  @Test
+  public void testAsDerivedRoot() throws IOException {
+    Path execRoot = scratch.dir("/exec");
+    Path rootDir = scratch.dir("/exec/root");
+    Root root = Root.asDerivedRoot(execRoot, rootDir);
+    assertFalse(root.isSourceRoot());
+    assertEquals(new PathFragment("root"), root.getExecPath());
+    assertEquals(rootDir, root.getPath());
+    assertEquals("/exec/root[derived]", root.toString());
+  }
+
+  @Test
+  public void testBadAsDerivedRoot() throws IOException {
+    try {
+      Path execRoot = scratch.dir("/exec");
+      Path outsideDir = scratch.dir("/not_exec");
+      Root.asDerivedRoot(execRoot, outsideDir);
+      fail();
+    } catch (IllegalArgumentException expected) {
+    }
+  }
+
+  @Test
+  public void testBadAsDerivedRootSameForBoth() throws IOException {
+    try {
+      Path execRoot = scratch.dir("/exec");
+      Root.asDerivedRoot(execRoot, execRoot);
+      fail();
+    } catch (IllegalArgumentException expected) {
+    }
+  }
+
+  @Test
+  public void testBadAsDerivedRootNullDir() throws IOException {
+    try {
+      Path execRoot = scratch.dir("/exec");
+      Root.asDerivedRoot(execRoot, null);
+      fail();
+    } catch (NullPointerException expected) {
+    }
+  }
+
+  @Test
+  public void testBadAsDerivedRootNullExecRoot() throws IOException {
+    try {
+      Path execRoot = scratch.dir("/exec");
+      Root.asDerivedRoot(null, execRoot);
+      fail();
+    } catch (NullPointerException expected) {
+    }
+  }
+
+  @Test
+  public void testEquals() throws IOException {
+    Path execRoot = scratch.dir("/exec");
+    Path rootDir = scratch.dir("/exec/root");
+    Path otherRootDir = scratch.dir("/");
+    Path sourceDir = scratch.dir("/source");
+    Root rootA = Root.asDerivedRoot(execRoot, rootDir);
+    assertEqualsAndHashCode(true, rootA, Root.asDerivedRoot(execRoot, rootDir));
+    assertEqualsAndHashCode(false, rootA, Root.asSourceRoot(sourceDir));
+    assertEqualsAndHashCode(false, rootA, Root.asSourceRoot(rootDir));
+    assertEqualsAndHashCode(false, rootA, Root.asDerivedRoot(otherRootDir, rootDir));
+  }
+
+  public void assertEqualsAndHashCode(boolean expected, Object a, Object b) {
+    if (expected) {
+      assertTrue(a.equals(b));
+      assertTrue(a.hashCode() == b.hashCode());
+    } else {
+      assertFalse(a.equals(b));
+      assertFalse(a.hashCode() == b.hashCode());
+    }
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/actions/cache/CompactPersistentActionCacheTest.java b/src/test/java/com/google/devtools/build/lib/actions/cache/CompactPersistentActionCacheTest.java
new file mode 100644
index 0000000..5fc1f4f
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/actions/cache/CompactPersistentActionCacheTest.java
@@ -0,0 +1,190 @@
+// Copyright 2015 Google Inc. 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.actions.cache;
+
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import com.google.devtools.build.lib.util.Clock;
+import com.google.devtools.build.lib.vfs.Path;
+import com.google.devtools.build.lib.vfs.PathFragment;
+import com.google.devtools.build.lib.vfs.util.FsApparatus;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.IOException;
+
+/**
+ * Test for the CompactPersistentActionCache class.
+ */
+@RunWith(JUnit4.class)
+public class CompactPersistentActionCacheTest {
+
+  private static class ManualClock implements Clock {
+    private long currentTime = 0L;
+
+    ManualClock() { }
+
+    @Override public long currentTimeMillis() {
+      return currentTime;
+    }
+
+    @Override public long nanoTime() {
+      return 0;
+    }
+  }
+
+  private FsApparatus scratch = FsApparatus.newInMemory();
+  private Path dataRoot;
+  private Path mapFile;
+  private Path journalFile;
+  private ManualClock clock = new ManualClock();
+  private CompactPersistentActionCache cache;
+
+  @Before
+  public void setUp() throws Exception {
+    dataRoot = scratch.path("/cache/test.dat");
+    cache = new CompactPersistentActionCache(dataRoot, clock);
+    mapFile = CompactPersistentActionCache.cacheFile(dataRoot);
+    journalFile = CompactPersistentActionCache.journalFile(dataRoot);
+  }
+
+  @Test
+  public void testGetInvalidKey() {
+    assertNull(cache.get("key"));
+  }
+
+  @Test
+  public void testPutAndGet() {
+    String key = "key";
+    putKey(key);
+    ActionCache.Entry readentry = cache.get(key);
+    assertTrue(readentry != null);
+    assertEquals(cache.get(key).toString(), readentry.toString());
+    assertFalse(mapFile.exists());
+  }
+
+  @Test
+  public void testPutAndRemove() {
+    String key = "key";
+    putKey(key);
+    cache.remove(key);
+    assertNull(cache.get(key));
+    assertFalse(mapFile.exists());
+  }
+
+  @Test
+  public void testSave() throws IOException {
+    String key = "key";
+    putKey(key);
+    cache.save();
+    assertTrue(mapFile.exists());
+    assertFalse(journalFile.exists());
+
+    CompactPersistentActionCache newcache =
+      new CompactPersistentActionCache(dataRoot, clock);
+    ActionCache.Entry readentry = newcache.get(key);
+    assertTrue(readentry != null);
+    assertEquals(cache.get(key).toString(), readentry.toString());
+  }
+
+  @Test
+  public void testIncrementalSave() throws IOException {
+    for (int i = 0; i < 300; i++) {
+      putKey(Integer.toString(i));
+    }
+    assertFullSave();
+
+    // Add 2 entries to 300. Might as well just leave them in the journal.
+    putKey("abc");
+    putKey("123");
+    assertIncrementalSave(cache);
+
+    // Make sure we have all the entries, including those in the journal,
+    // after deserializing into a new cache.
+    CompactPersistentActionCache newcache =
+        new CompactPersistentActionCache(dataRoot, clock);
+    for (int i = 0; i < 100; i++) {
+      assertKeyEquals(cache, newcache, Integer.toString(i));
+    }
+    assertKeyEquals(cache, newcache, "abc");
+    assertKeyEquals(cache, newcache, "123");
+    putKey("xyz", newcache);
+    assertIncrementalSave(newcache);
+
+    // Make sure we can see previous journal values after a second incremental save.
+    CompactPersistentActionCache newerCache =
+        new CompactPersistentActionCache(dataRoot, clock);
+    for (int i = 0; i < 100; i++) {
+      assertKeyEquals(cache, newerCache, Integer.toString(i));
+    }
+    assertKeyEquals(cache, newerCache, "abc");
+    assertKeyEquals(cache, newerCache, "123");
+    assertNotNull(newerCache.get("xyz"));
+    assertNull(newerCache.get("not_a_key"));
+
+    // Add another 10 entries. This should not be incremental.
+    for (int i = 300; i < 310; i++) {
+      putKey(Integer.toString(i));
+    }
+    assertFullSave();
+  }
+
+  // Regression test to check that CompactActionCacheEntry.toString does not mutate the object.
+  // Mutations may result in IllegalStateException.
+  @Test
+  public void testEntryToStringIsIdempotent() throws Exception {
+    ActionCache.Entry entry = new ActionCache.Entry("actionKey");
+    entry.toString();
+    entry.addFile(new PathFragment("foo/bar"), Metadata.CONSTANT_METADATA);
+    entry.toString();
+    entry.getFileDigest();
+    entry.toString();
+  }
+
+  private static void assertKeyEquals(ActionCache cache1, ActionCache cache2, String key) {
+    Object entry = cache1.get(key);
+    assertNotNull(entry);
+    assertEquals(entry.toString(), cache2.get(key).toString());
+  }
+
+  private void assertFullSave() throws IOException {
+    cache.save();
+    assertTrue(mapFile.exists());
+    assertFalse(journalFile.exists());
+  }
+
+  private void assertIncrementalSave(ActionCache ac) throws IOException {
+    ac.save();
+    assertTrue(mapFile.exists());
+    assertTrue(journalFile.exists());
+  }
+
+  private void putKey(String key) {
+    putKey(key, cache);
+  }
+
+  private void putKey(String key, ActionCache ac) {
+    ActionCache.Entry entry = ac.createEntry(key);
+    entry.getFileDigest();
+    ac.put(key, entry);
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/actions/cache/MetadataTest.java b/src/test/java/com/google/devtools/build/lib/actions/cache/MetadataTest.java
new file mode 100644
index 0000000..fe37af2
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/actions/cache/MetadataTest.java
@@ -0,0 +1,45 @@
+// Copyright 2015 Google Inc. 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.actions.cache;
+
+
+import com.google.common.io.BaseEncoding;
+import com.google.common.testing.EqualsTester;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class MetadataTest {
+
+  private static byte[] toBytes(String hex) {
+    return BaseEncoding.base16().upperCase().decode(hex);
+  }
+
+  @Test
+  public void testEqualsAndHashCode() throws Exception {
+    // Each "equality group" is checked for equality within itself (including hashCode equality)
+    // and inequality with members of other equality groups.
+    new EqualsTester()
+        .addEqualityGroup(new Metadata(toBytes("00112233445566778899AABBCCDDEEFF")),
+                          new Metadata(toBytes("00112233445566778899AABBCCDDEEFF")))
+        .addEqualityGroup(new Metadata(1))
+        .addEqualityGroup(new Metadata(toBytes("FFFFFF00000000000000000000000000")))
+        .addEqualityGroup(new Metadata(2),
+                          new Metadata(2))
+        .addEqualityGroup("a string")
+        .testEquals();
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/actions/cache/PersistentStringIndexerTest.java b/src/test/java/com/google/devtools/build/lib/actions/cache/PersistentStringIndexerTest.java
new file mode 100644
index 0000000..7fc0cb1
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/actions/cache/PersistentStringIndexerTest.java
@@ -0,0 +1,387 @@
+// Copyright 2015 Google Inc. 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.actions.cache;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.devtools.build.lib.testutil.TestThread;
+import com.google.devtools.build.lib.util.Clock;
+import com.google.devtools.build.lib.vfs.FileSystemUtils;
+import com.google.devtools.build.lib.vfs.Path;
+import com.google.devtools.build.lib.vfs.util.FsApparatus;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.EOFException;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CountDownLatch;
+
+/**
+ * Test for the PersistentStringIndexer class.
+ */
+@RunWith(JUnit4.class)
+public class PersistentStringIndexerTest {
+
+  private static class ManualClock implements Clock {
+    private long currentTime = 0L;
+
+    ManualClock() { }
+
+    @Override public long currentTimeMillis() {
+      throw new AssertionError("unexpected method call");
+    }
+
+    @Override  public long nanoTime() {
+      return currentTime;
+    }
+
+    void advance(long time) {
+      currentTime += time;
+    }
+  }
+
+  private PersistentStringIndexer psi;
+  private Map<Integer, String> mappings = new ConcurrentHashMap<>();
+  private FsApparatus scratch = FsApparatus.newInMemory();
+  private ManualClock clock = new ManualClock();
+  private Path dataPath;
+  private Path journalPath;
+
+
+  @Before
+  public void setUp() throws Exception {
+    dataPath = scratch.path("/cache/test.dat");
+    journalPath = scratch.path("/cache/test.journal");
+    psi = PersistentStringIndexer.newPersistentStringIndexer(dataPath, clock);
+  }
+
+  private void assertSize(int expected) {
+    assertEquals(expected, psi.size());
+  }
+
+  private void assertIndex(int expected, String s) {
+    int index = psi.getOrCreateIndex(s);
+    assertEquals(expected, index);
+    mappings.put(expected, s);
+  }
+
+  private void assertContent() {
+    for (int i = 0; i < psi.size(); i++) {
+      if(mappings.get(i) != null) {
+        assertEquals(mappings.get(i), psi.getStringForIndex(i));
+      }
+    }
+  }
+
+
+  private void setupTestContent() {
+    assertSize(0);
+    assertIndex(0, "abcdefghi");  // Create leafs
+    assertIndex(1, "abcdefjkl");
+    assertIndex(2, "abcdefmno");
+    assertIndex(3, "abcdefjklpr");
+    assertIndex(3, "abcdefjklpr");
+    assertIndex(4, "abcdstr");
+    assertIndex(5, "012345");
+    assertSize(6);
+    assertIndex(6, "abcdef");  // Validate inner nodes
+    assertIndex(7, "abcd");
+    assertIndex(8, "");
+    assertSize(9);
+    assertContent();
+  }
+
+  /**
+   * Writes lots of entries with labels "fooconcurrent[int]" at the same time.
+   * The set of labels written is deterministic, but the label:index mapping is
+   * not.
+   */
+  private void writeLotsOfEntriesConcurrently(final int numToWrite) throws InterruptedException {
+    final int NUM_THREADS = 10;
+    final CountDownLatch synchronizerLatch = new CountDownLatch(NUM_THREADS);
+
+    class IndexAdder extends TestThread {
+      @Override
+      public void runTest() throws Exception {
+        for (int i = 0; i < numToWrite; i++) {
+          synchronizerLatch.countDown();
+          synchronizerLatch.await();
+
+          String value = "fooconcurrent" + i;
+          mappings.put(psi.getOrCreateIndex(value), value);
+        }
+      }
+    }
+
+    Collection<TestThread> threads = new ArrayList<>();
+    for (int i = 0; i < NUM_THREADS; i++) {
+      TestThread thread = new IndexAdder();
+      thread.start();
+      threads.add(thread);
+    }
+
+    for (TestThread thread : threads) {
+      thread.joinAndAssertState(0);
+    }
+  }
+
+  @Test
+  public void testNormalOperation() throws Exception {
+    assertFalse(dataPath.exists());
+    assertFalse(journalPath.exists());
+    setupTestContent();
+    assertFalse(dataPath.exists());
+    assertFalse(journalPath.exists());
+
+    clock.advance(4);
+    assertIndex(9, "xyzqwerty"); // This should flush journal to disk.
+    assertFalse(dataPath.exists());
+    assertTrue(journalPath.exists());
+
+    psi.save(); // Successful save will remove journal file.
+    assertTrue(dataPath.exists());
+    assertFalse(journalPath.exists());
+
+    // Now restore data from file and verify it.
+    psi = PersistentStringIndexer.newPersistentStringIndexer(dataPath, clock);
+    assertFalse(journalPath.exists());
+    clock.advance(4);
+    assertSize(10);
+    assertContent();
+    assertFalse(journalPath.exists());
+  }
+
+  @Test
+  public void testJournalRecoveryWithoutMainDataFile() throws Exception {
+    assertFalse(dataPath.exists());
+    assertFalse(journalPath.exists());
+    setupTestContent();
+    assertFalse(dataPath.exists());
+    assertFalse(journalPath.exists());
+
+    clock.advance(4);
+    assertIndex(9, "abc1234"); // This should flush journal to disk.
+    assertFalse(dataPath.exists());
+    assertTrue(journalPath.exists());
+
+    // Now restore data from file and verify it. All data should be restored from journal;
+    psi = PersistentStringIndexer.newPersistentStringIndexer(dataPath, clock);
+    assertTrue(dataPath.exists());
+    assertFalse(journalPath.exists());
+    clock.advance(4);
+    assertSize(10);
+    assertContent();
+    assertFalse(journalPath.exists());
+  }
+
+  @Test
+  public void testJournalRecovery() throws Exception {
+    assertFalse(dataPath.exists());
+    assertFalse(journalPath.exists());
+    setupTestContent();
+    psi.save();
+    assertTrue(dataPath.exists());
+    assertFalse(journalPath.exists());
+    long oldDataFileLen = dataPath.getFileSize();
+
+    clock.advance(4);
+    assertIndex(9, "another record"); // This should flush journal to disk.
+    assertSize(10);
+    assertTrue(dataPath.exists());
+    assertTrue(journalPath.exists());
+
+    // Now restore data from file and verify it. All data should be restored from journal;
+    psi = PersistentStringIndexer.newPersistentStringIndexer(dataPath, clock);
+    assertTrue(dataPath.exists());
+    assertFalse(journalPath.exists());
+    assertTrue(dataPath.getFileSize() > oldDataFileLen); // data file should have been updated
+    clock.advance(4);
+    assertSize(10);
+    assertContent();
+    assertFalse(journalPath.exists());
+  }
+
+  @Test
+  public void testConcurrentWritesJournalRecovery() throws Exception {
+    assertFalse(dataPath.exists());
+    assertFalse(journalPath.exists());
+    setupTestContent();
+    psi.save();
+    assertTrue(dataPath.exists());
+    assertFalse(journalPath.exists());
+    long oldDataFileLen = dataPath.getFileSize();
+
+    int size = psi.size();
+    int numToWrite = 50000;
+    writeLotsOfEntriesConcurrently(numToWrite);
+    assertFalse(journalPath.exists());
+    clock.advance(4);
+    assertIndex(size + numToWrite, "another record"); // This should flush journal to disk.
+    assertSize(size + numToWrite + 1);
+    assertTrue(dataPath.exists());
+    assertTrue(journalPath.exists());
+
+    // Now restore data from file and verify it. All data should be restored from journal;
+    psi = PersistentStringIndexer.newPersistentStringIndexer(dataPath, clock);
+    assertTrue(dataPath.exists());
+    assertFalse(journalPath.exists());
+    assertTrue(dataPath.getFileSize() > oldDataFileLen); // data file should have been updated
+    clock.advance(4);
+    assertSize(size + numToWrite + 1);
+    assertContent();
+    assertFalse(journalPath.exists());
+  }
+
+  @Test
+  public void testCorruptedJournal() throws Exception {
+    FileSystemUtils.createDirectoryAndParents(journalPath.getParentDirectory());
+    FileSystemUtils.writeContentAsLatin1(journalPath, "bogus content");
+    try {
+      psi = PersistentStringIndexer.newPersistentStringIndexer(dataPath, clock);
+      fail();
+    } catch (IOException e) {
+      assertThat(e.getMessage()).contains("too short: Only 13 bytes");
+    }
+
+    journalPath.delete();
+    setupTestContent();
+    assertFalse(dataPath.exists());
+    assertFalse(journalPath.exists());
+
+    clock.advance(4);
+    assertIndex(9, "abc1234"); // This should flush journal to disk.
+    assertFalse(dataPath.exists());
+    assertTrue(journalPath.exists());
+
+    byte[] journalContent = FileSystemUtils.readContent(journalPath);
+
+    // Now restore data from file and verify it. All data should be restored from journal;
+    psi = PersistentStringIndexer.newPersistentStringIndexer(dataPath, clock);
+    assertTrue(dataPath.exists());
+    assertFalse(journalPath.exists());
+
+    // Now put back truncated journal. We should get an error.
+    assertTrue(dataPath.delete());
+    FileSystemUtils.writeContent(journalPath,
+        Arrays.copyOf(journalContent, journalContent.length - 1));
+    try {
+      psi = PersistentStringIndexer.newPersistentStringIndexer(dataPath, clock);
+      fail();
+    } catch (EOFException e) {
+      // Expected.
+    }
+
+    // Corrupt the journal with a negative size value.
+    byte[] journalCopy = Arrays.copyOf(journalContent, journalContent.length);
+    // Flip this bit to make the key size negative.
+    journalCopy[95] = -2;
+    FileSystemUtils.writeContent(journalPath,  journalCopy);
+    try {
+      psi = PersistentStringIndexer.newPersistentStringIndexer(dataPath, clock);
+      fail();
+    } catch (IOException e) {
+      // Expected.
+      assertThat(e.getMessage()).contains("corrupt key length");
+    }
+
+    // Now put back corrupted journal. We should get an error.
+    journalContent[journalContent.length - 13] = 100;
+    FileSystemUtils.writeContent(journalPath,  journalContent);
+    try {
+      psi = PersistentStringIndexer.newPersistentStringIndexer(dataPath, clock);
+      fail();
+    } catch (IOException e) {
+      // Expected.
+    }
+  }
+
+  @Test
+  public void testDupeIndexCorruption() throws Exception {
+    setupTestContent();
+    assertFalse(dataPath.exists());
+    assertFalse(journalPath.exists());
+
+    assertIndex(9, "abc1234"); // This should flush journal to disk.
+    psi.save();
+    assertTrue(dataPath.exists());
+    assertFalse(journalPath.exists());
+
+    byte[] content = FileSystemUtils.readContent(dataPath);
+
+    // We remove the data file, and instead create a corrupt journal.
+    //
+    // The journal has a header followed by a sequence of (String, int) pairs, where each int is a
+    // unique value. The String is encoded by the length (as an int), and the int is simply encoded
+    // as an int. Note that the DataOutputStream class uses big endian by default, so the low-order
+    // bits are at the end.
+    //
+    // For the purpose of this test, we want to make the journal contain two entries with the same
+    // index (which is illegal). The PersistentStringIndexer assigns int values in the usual order,
+    // starting with zero, and it now contains 9 entries. We simply change the last entry to an
+    // index that is guaranteed to already exist. If it is the index 1, we change it to 2, otherwise
+    // we change it to 1 - in both cases, the code currently guarantees that the duplicate comes
+    // earlier in the stream.
+    assertTrue(dataPath.delete());
+    content[content.length - 1] = content[content.length - 1] == 1 ? (byte) 2 : (byte) 1;
+    FileSystemUtils.writeContent(journalPath, content);
+
+    try {
+      psi = PersistentStringIndexer.newPersistentStringIndexer(dataPath, clock);
+      fail();
+    } catch (IOException e) {
+      // Expected.
+      assertThat(e.getMessage()).contains("Corrupted filename index has duplicate entry");
+    }
+  }
+
+  @Test
+  public void testDeferredIOFailure() throws Exception {
+    assertFalse(dataPath.exists());
+    assertFalse(journalPath.exists());
+    setupTestContent();
+    assertFalse(dataPath.exists());
+    assertFalse(journalPath.exists());
+
+    // Ensure that journal cannot be saved.
+    FileSystemUtils.createDirectoryAndParents(journalPath);
+
+    clock.advance(4);
+    assertIndex(9, "abc1234"); // This should flush journal to disk (and fail at that).
+    assertFalse(dataPath.exists());
+
+    // Subsequent updates should succeed even though journaling is disabled at this point.
+    clock.advance(4);
+    assertIndex(10, "another record");
+    try {
+      // Save should actually save main data file but then return us deferred IO failure
+      // from failed journal write.
+      psi.save();
+      fail();
+    } catch(IOException e) {
+      assertThat(e.getMessage()).contains(journalPath.getPathString() + " (Is a directory)");
+    }
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/actions/util/ActionCacheTestHelper.java b/src/test/java/com/google/devtools/build/lib/actions/util/ActionCacheTestHelper.java
new file mode 100644
index 0000000..1db0249
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/actions/util/ActionCacheTestHelper.java
@@ -0,0 +1,42 @@
+// Copyright 2015 Google Inc. 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.actions.util;
+
+import com.google.devtools.build.lib.actions.cache.ActionCache;
+
+import java.io.PrintStream;
+
+/**
+ * Utilities for tests that use the action cache.
+ */
+public class ActionCacheTestHelper {
+  private ActionCacheTestHelper() {}
+
+  /** A cache which does not remember anything.  Causes perpetual rebuilds! */
+  public static final ActionCache AMNESIAC_CACHE =
+    new ActionCache() {
+      @Override
+      public void put(String fingerprint, Entry entry) {}
+      @Override
+      public Entry get(String fingerprint) { return null; }
+      @Override
+      public void remove(String key) {}
+      @Override
+      public Entry createEntry(String key) { return new ActionCache.Entry(key); }
+      @Override
+      public long save() { return -1; }
+      @Override
+      public void dump(PrintStream out) { }
+    };
+}
diff --git a/src/test/java/com/google/devtools/build/lib/actions/util/ActionsTestUtil.java b/src/test/java/com/google/devtools/build/lib/actions/util/ActionsTestUtil.java
new file mode 100644
index 0000000..2f601d4
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/actions/util/ActionsTestUtil.java
@@ -0,0 +1,440 @@
+// Copyright 2015 Google Inc. 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.actions.util;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.base.Joiner;
+import com.google.common.base.Predicate;
+import com.google.common.base.Predicates;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.devtools.build.lib.actions.AbstractAction;
+import com.google.devtools.build.lib.actions.AbstractActionOwner;
+import com.google.devtools.build.lib.actions.Action;
+import com.google.devtools.build.lib.actions.ActionExecutionContext;
+import com.google.devtools.build.lib.actions.ActionGraph;
+import com.google.devtools.build.lib.actions.ActionInputHelper;
+import com.google.devtools.build.lib.actions.ActionOwner;
+import com.google.devtools.build.lib.actions.Artifact;
+import com.google.devtools.build.lib.actions.ArtifactOwner;
+import com.google.devtools.build.lib.actions.Executor;
+import com.google.devtools.build.lib.actions.MutableActionGraph;
+import com.google.devtools.build.lib.actions.MutableActionGraph.ActionConflictException;
+import com.google.devtools.build.lib.actions.ResourceSet;
+import com.google.devtools.build.lib.actions.Root;
+import com.google.devtools.build.lib.actions.cache.MetadataHandler;
+import com.google.devtools.build.lib.exec.SingleBuildFileCache;
+import com.google.devtools.build.lib.syntax.Label;
+import com.google.devtools.build.lib.util.FileType;
+import com.google.devtools.build.lib.util.io.FileOutErr;
+import com.google.devtools.build.lib.vfs.Path;
+import com.google.devtools.build.lib.vfs.PathFragment;
+import com.google.devtools.build.lib.vfs.inmemoryfs.InMemoryFileSystem;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.LinkedHashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+
+import javax.annotation.Nullable;
+
+/**
+ * A bunch of utilities that are useful for test concerning actions, artifacts,
+ * etc.
+ */
+public final class ActionsTestUtil {
+
+  private final ActionGraph actionGraph;
+
+  public ActionsTestUtil(ActionGraph actionGraph) {
+    this.actionGraph = actionGraph;
+  }
+
+  private static final Label NULL_LABEL = Label.parseAbsoluteUnchecked("//null/action:owner");
+
+  public static ActionExecutionContext createContext(Executor executor, FileOutErr fileOutErr,
+      Path execRoot, MetadataHandler metadataHandler, @Nullable ActionGraph actionGraph) {
+    return new ActionExecutionContext(
+        executor,
+        new SingleBuildFileCache(execRoot.getPathString(), execRoot.getFileSystem()),
+        metadataHandler, fileOutErr,
+        actionGraph == null
+            ? null
+            : ActionInputHelper.actionGraphMiddlemanExpander(actionGraph));
+  }
+
+  /**
+   * A dummy ActionOwner implementation for use in tests.
+   */
+  public static class NullActionOwner extends AbstractActionOwner {
+    @Override
+    public Label getLabel() {
+      return NULL_LABEL;
+    }
+
+    @Override
+    public final String getConfigurationName() {
+      return "dummy-configuration";
+    }
+
+    @Override
+    public String getConfigurationMnemonic() {
+      return "dummy-configuration-mnemonic";
+    }
+
+    @Override
+    public final String getConfigurationShortCacheKey() {
+      return "dummy-configuration";
+    }
+  }
+
+  public static final Artifact DUMMY_ARTIFACT = new Artifact(
+      new PathFragment("dummy"),
+      Root.asSourceRoot(new InMemoryFileSystem().getRootDirectory()));
+
+  public static final ActionOwner NULL_ACTION_OWNER = new NullActionOwner();
+
+  public static final ArtifactOwner NULL_ARTIFACT_OWNER =
+      new ArtifactOwner() {
+        @Override
+        public Label getLabel() {
+          return NULL_LABEL;
+        }
+  };
+
+  public static class UncheckedActionConflictException extends RuntimeException {
+    public UncheckedActionConflictException(ActionConflictException e) {
+      super(e);
+    }
+  }
+
+  /**
+   * A dummy Action class for use in tests.
+   */
+  public static class NullAction extends AbstractAction {
+
+    public NullAction() {
+      super(NULL_ACTION_OWNER, Artifact.NO_ARTIFACTS, ImmutableList.of(DUMMY_ARTIFACT));
+    }
+
+    public NullAction(ActionOwner owner, Artifact... outputs) {
+      super(owner, Artifact.NO_ARTIFACTS, ImmutableList.copyOf(outputs));
+    }
+
+    public NullAction(Artifact... outputs) {
+      super(NULL_ACTION_OWNER, Artifact.NO_ARTIFACTS, ImmutableList.copyOf(outputs));
+    }
+
+    @Override
+    public String describeStrategy(Executor executor) {
+      return "";
+    }
+
+    @Override
+    public void execute(ActionExecutionContext actionExecutionContext) {
+    }
+
+    @Override protected String computeKey() { return "action"; }
+    @Override public ResourceSet estimateResourceConsumption(Executor executor) {
+      return ResourceSet.ZERO;
+    }
+    @Override
+    public String getMnemonic() {
+      return "Null";
+    }
+  }
+
+  /**
+   * For a bunch of actions, gets the basenames of the paths and accumulates
+   * them in a space separated string, like <code>foo.o bar.o baz.a</code>.
+   */
+  public static String baseNamesOf(Iterable<Artifact> artifacts) {
+    List<String> baseNames = baseArtifactNames(artifacts);
+    return Joiner.on(' ').join(baseNames);
+  }
+
+  /**
+   * For a bunch of actions, gets the basenames of the paths, sorts them in alphabetical
+   * order and accumulates them in a space separated string, for example
+   * <code>bar.o baz.a foo.o</code>.
+   */
+  public static String sortedBaseNamesOf(Iterable<Artifact> artifacts) {
+    List<String> baseNames = baseArtifactNames(artifacts);
+    Collections.sort(baseNames);
+    return Joiner.on(' ').join(baseNames);
+  }
+
+  /**
+   * For a bunch of artifacts, gets the basenames and accumulates them in a
+   * List.
+   */
+  public static List<String> baseArtifactNames(Iterable<Artifact> artifacts) {
+    List<String> baseNames = new ArrayList<>();
+    for (Artifact artifact : artifacts) {
+      baseNames.add(artifact.getExecPath().getBaseName());
+    }
+    return baseNames;
+  }
+
+  /**
+   * For a bunch of artifacts, gets the exec paths and accumulates them in a
+   * List.
+   */
+  public static List<String> execPaths(Iterable<Artifact> artifacts) {
+    List<String> names = new ArrayList<>();
+    for (Artifact artifact : artifacts) {
+      names.add(artifact.getExecPathString());
+    }
+    return names;
+  }
+
+  /**
+   * For a bunch of artifacts, gets the pretty printed names and accumulates them in a List. Note
+   * that this returns the root-relative paths, not the exec paths.
+   */
+  public static List<String> prettyArtifactNames(Iterable<Artifact> artifacts) {
+    List<String> result = new ArrayList<>();
+    for (Artifact artifact : artifacts) {
+      result.add(artifact.prettyPrint());
+    }
+    return result;
+  }
+
+  public static List<String> prettyJarNames(Iterable<Artifact> jars) {
+    List<String> result = new ArrayList<>();
+    for (Artifact jar : jars) {
+      result.add(jar.prettyPrint());
+    }
+    return result;
+  }
+
+  /**
+   * Returns the closure of the predecessors of any of the given types, joining the basenames of the
+   * artifacts into a space-separated string like "libfoo.a libbar.a libbaz.a".
+   */
+  public String predecessorClosureOf(Artifact artifact, FileType... types) {
+    return predecessorClosureOf(Collections.singleton(artifact), types);
+  }
+
+  /**
+   * Returns the closure of the predecessors of any of the given types.
+   */
+  public Collection<String> predecessorClosureAsCollection(Artifact artifact, FileType... types) {
+    return predecessorClosureAsCollection(Collections.singleton(artifact), types);
+  }
+
+  /**
+   * Returns the closure of the predecessors of any of the given types, joining the basenames of the
+   * artifacts into a space-separated string like "libfoo.a libbar.a libbaz.a".
+   */
+  public String predecessorClosureOf(Iterable<Artifact> artifacts, FileType... types) {
+    Set<Artifact> visited = artifactClosureOf(artifacts);
+    return baseNamesOf(FileType.filter(visited, types));
+  }
+
+  /**
+   * Returns the closure of the predecessors of any of the given types.
+   */
+  public Collection<String> predecessorClosureAsCollection(Iterable<Artifact> artifacts,
+      FileType... types) {
+    return baseArtifactNames(FileType.filter(artifactClosureOf(artifacts), types));
+  }
+
+  public String predecessorClosureOfJars(Iterable<Artifact> artifacts, FileType... types) {
+    return baseNamesOf(FileType.filter(artifactClosureOf(artifacts), types));
+  }
+
+  public Collection<String> predecessorClosureJarsAsCollection(Iterable<Artifact> artifacts,
+      FileType... types) {
+    Set<Artifact> visited = artifactClosureOf(artifacts);
+    return baseArtifactNames(FileType.filter(visited, types));
+  }
+
+  /**
+   * Returns the closure over the input files of an action.
+   */
+  public Set<Artifact> inputClosureOf(Action action) {
+    return artifactClosureOf(action.getInputs());
+  }
+
+  /**
+   * Returns the closure over the input files of an artifact.
+   */
+  public Set<Artifact> artifactClosureOf(Artifact artifact) {
+    return artifactClosureOf(Collections.singleton(artifact));
+  }
+
+  /**
+   * Returns the closure over the input files of an artifact, filtered by the given matcher.
+   */
+  public Set<Artifact> filteredArtifactClosureOf(Artifact artifact, Predicate<Artifact> matcher) {
+    return ImmutableSet.copyOf(Iterables.filter(artifactClosureOf(artifact), matcher));
+  }
+
+  /**
+   * Returns the closure over the input files of a set of artifacts.
+   */
+  public Set<Artifact> artifactClosureOf(Iterable<Artifact> artifacts) {
+    Set<Artifact> visited = new LinkedHashSet<>();
+    List<Artifact> toVisit = Lists.newArrayList(artifacts);
+    while (!toVisit.isEmpty()) {
+      Artifact current = toVisit.remove(0);
+      if (!visited.add(current)) {
+        continue;
+      }
+      Action generatingAction = actionGraph.getGeneratingAction(current);
+      if (generatingAction != null) {
+        Iterables.addAll(toVisit, generatingAction.getInputs());
+      }
+    }
+    return visited;
+  }
+
+  /**
+   * Returns the closure over the input files of a set of artifacts, filtered by the given matcher.
+   */
+  public Set<Artifact> filteredArtifactClosureOf(Iterable<Artifact> artifacts,
+      Predicate<Artifact> matcher) {
+    return ImmutableSet.copyOf(Iterables.filter(artifactClosureOf(artifacts), matcher));
+  }
+
+  /**
+   * Returns a predicate to match {@link Artifact}s with the given root-relative path suffix.
+   */
+  public static Predicate<Artifact> getArtifactSuffixMatcher(final String suffix) {
+    return new Predicate<Artifact>() {
+      @Override
+      public boolean apply(Artifact input) {
+        return input.getRootRelativePath().getPathString().endsWith(suffix);
+      }
+    };
+  }
+
+  /**
+   * Finds all the actions that are instances of <code>actionClass</code>
+   * in the transitive closure of prerequisites.
+   */
+  public <A extends Action> List<A> findTransitivePrerequisitesOf(Artifact artifact,
+      Class<A> actionClass, Predicate<Artifact> allowedArtifacts) {
+    List<A> actions = new ArrayList<>();
+    Set<Artifact> visited = new LinkedHashSet<>();
+    List<Artifact> toVisit = new LinkedList<>();
+    toVisit.add(artifact);
+    while (!toVisit.isEmpty()) {
+      Artifact current = toVisit.remove(0);
+      if (!visited.add(current)) {
+        continue;
+      }
+      Action generatingAction = actionGraph.getGeneratingAction(current);
+      if (generatingAction != null) {
+        Iterables.addAll(toVisit, Iterables.filter(generatingAction.getInputs(), allowedArtifacts));
+        if (actionClass.isInstance(generatingAction)) {
+          actions.add(actionClass.cast(generatingAction));
+        }
+      }
+    }
+    return actions;
+  }
+
+  public <A extends Action> List<A> findTransitivePrerequisitesOf(
+      Artifact artifact, Class<A> actionClass) {
+    return findTransitivePrerequisitesOf(artifact, actionClass, Predicates.<Artifact>alwaysTrue());
+  }
+
+  /**
+   * Looks in the given artifacts Iterable for the first Artifact whose path ends with the given
+   * suffix and returns its generating Action.
+   */
+  public Action getActionForArtifactEndingWith(Iterable<Artifact> artifacts, String suffix) {
+    Artifact a = getFirstArtifactEndingWith(artifacts, suffix);
+    return a != null ? actionGraph.getGeneratingAction(a) : null;
+  }
+
+  /**
+   * Looks in the given artifacts Iterable for the first Artifact whose path ends with the given
+   * suffix and returns the Artifact.
+   */
+  public static Artifact getFirstArtifactEndingWith(
+      Iterable<Artifact> artifacts, String suffix) {
+    for (Artifact a : artifacts) {
+      if (a.getExecPath().getPathString().endsWith(suffix)) {
+        return a;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Returns the first artifact which is an input to "action" and has the
+   * specified basename. An assertion error is raised if none is found.
+   */
+  public static Artifact getInput(Action action, String basename) {
+    for (Artifact artifact : action.getInputs()) {
+      if (artifact.getExecPath().getBaseName().equals(basename)) {
+        return artifact;
+      }
+    }
+    throw new AssertionError("No input with basename '" + basename + "' in action " + action);
+  }
+
+  /**
+   * Returns true if an artifact that is an input to "action" with the specific
+   * basename exists.
+   */
+  public static boolean hasInput(Action action, String basename) {
+    try {
+      getInput(action, basename);
+      return true;
+    } catch (AssertionError e) {
+      return false;
+    }
+  }
+
+  /**
+   * Assert that an artifact is the primary output of its generating action.
+   */
+  public void assertPrimaryInputAndOutputArtifacts(Artifact input, Artifact output) {
+    Action generatingAction = actionGraph.getGeneratingAction(output);
+    assertThat(generatingAction).isNotNull();
+    assertThat(generatingAction.getPrimaryOutput()).isEqualTo(output);
+    assertThat(generatingAction.getPrimaryInput()).isEqualTo(input);
+  }
+
+  /**
+   * Returns the first artifact which is an output of "action" and has the
+   * specified basename. An assertion error is raised if none is found.
+   */
+  public static Artifact getOutput(Action action, String basename) {
+    for (Artifact artifact : action.getOutputs()) {
+      if (artifact.getExecPath().getBaseName().equals(basename)) {
+        return artifact;
+      }
+    }
+    throw new AssertionError("No output with basename '" + basename + "' in action " + action);
+  }
+
+  public static void registerActionWith(Action action, MutableActionGraph actionGraph) {
+    try {
+      actionGraph.registerAction(action);
+    } catch (ActionConflictException e) {
+      throw new UncheckedActionConflictException(e);
+    }
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/actions/util/DummyExecutor.java b/src/test/java/com/google/devtools/build/lib/actions/util/DummyExecutor.java
new file mode 100644
index 0000000..409227d
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/actions/util/DummyExecutor.java
@@ -0,0 +1,86 @@
+// Copyright 2015 Google Inc. 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.actions.util;
+
+import com.google.common.eventbus.EventBus;
+import com.google.devtools.build.lib.actions.Executor;
+import com.google.devtools.build.lib.actions.SpawnActionContext;
+import com.google.devtools.build.lib.events.EventHandler;
+import com.google.devtools.build.lib.util.Clock;
+import com.google.devtools.build.lib.vfs.Path;
+import com.google.devtools.common.options.OptionsClassProvider;
+
+/**
+ * A dummy implementation of Executor.
+ */
+public final class DummyExecutor implements Executor {
+  private final Path inputDir;
+
+  /**
+   * @param inputDir
+   */
+  public DummyExecutor(Path inputDir) {
+    this.inputDir = inputDir;
+  }
+
+  @Override
+  public Path getExecRoot() {
+    return inputDir;
+  }
+
+  @Override
+  public Clock getClock() {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public EventBus getEventBus() {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public boolean getVerboseFailures() {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public EventHandler getEventHandler() {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public <T extends ActionContext> T getContext(Class<? extends T> type) {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public SpawnActionContext getSpawnActionContext(String mnemonic) {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public OptionsClassProvider getOptions() {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public boolean reportsSubcommands() {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public void reportSubcommand(String reason, String message) {
+    throw new UnsupportedOperationException();
+  }
+}
\ No newline at end of file
diff --git a/src/test/java/com/google/devtools/build/lib/actions/util/LabelArtifactOwner.java b/src/test/java/com/google/devtools/build/lib/actions/util/LabelArtifactOwner.java
new file mode 100644
index 0000000..8e200e73
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/actions/util/LabelArtifactOwner.java
@@ -0,0 +1,49 @@
+// Copyright 2015 Google Inc. 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.actions.util;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.devtools.build.lib.actions.ArtifactOwner;
+import com.google.devtools.build.lib.syntax.Label;
+
+import java.util.Objects;
+
+/** ArtifactOwner wrapper for Labels, for use in tests. */
+@VisibleForTesting
+public class LabelArtifactOwner implements ArtifactOwner {
+  private final Label label;
+
+  @VisibleForTesting
+  public LabelArtifactOwner(Label label) {
+    this.label = label;
+  }
+
+  @Override
+  public Label getLabel() {
+    return label;
+  }
+
+  @Override
+  public int hashCode() {
+    return label == null ? super.hashCode() : label.hashCode();
+  }
+
+  @Override
+  public boolean equals(Object that) {
+    if (!(that instanceof LabelArtifactOwner)) {
+      return false;
+    }
+    return Objects.equals(this.label, ((LabelArtifactOwner) that).label);
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/actions/util/TestAction.java b/src/test/java/com/google/devtools/build/lib/actions/util/TestAction.java
new file mode 100644
index 0000000..0861384
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/actions/util/TestAction.java
@@ -0,0 +1,176 @@
+// Copyright 2015 Google Inc. 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.actions.util;
+
+import static com.google.devtools.build.lib.actions.util.ActionsTestUtil.NULL_ACTION_OWNER;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+import com.google.devtools.build.lib.actions.AbstractAction;
+import com.google.devtools.build.lib.actions.ActionExecutionContext;
+import com.google.devtools.build.lib.actions.ActionExecutionException;
+import com.google.devtools.build.lib.actions.Artifact;
+import com.google.devtools.build.lib.actions.Executor;
+import com.google.devtools.build.lib.actions.ResourceSet;
+import com.google.devtools.build.lib.util.StringUtilities;
+import com.google.devtools.build.lib.vfs.FileSystemUtils;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.Executors;
+
+/**
+ * A dummy action for testing.  Its execution runs the specified
+ * Runnable or Callable, which is defined by the test case,
+ * and touches all the output files.
+ */
+public class TestAction extends AbstractAction {
+
+  public static final Runnable NO_EFFECT = new Runnable() { @Override public void run() {} };
+
+  private static final ResourceSet RESOURCES =
+      new ResourceSet(/*memoryMb=*/1.0, /*cpu=*/0.1, /*io=*/0.0);
+
+  private final Callable<Void> effect;
+
+  /** Use this constructor if the effect can't throw exceptions. */
+  public TestAction(Runnable effect,
+             Collection<Artifact> inputs,
+             Collection<Artifact> outputs) {
+    super(NULL_ACTION_OWNER, inputs, outputs);
+    this.effect = Executors.callable(effect, null);
+  }
+
+  /**
+   * Use this constructor if the effect can throw exceptions.
+   * Any checked exception thrown will be repackaged as an
+   * ActionExecutionException.
+   */
+  public TestAction(Callable<Void> effect,
+             Collection<Artifact> inputs,
+             Collection<Artifact> outputs) {
+    super(NULL_ACTION_OWNER, inputs, outputs);
+    this.effect = effect;
+  }
+
+  @Override
+  public Collection<Artifact> getMandatoryInputs() {
+    List<Artifact> mandatoryInputs = new ArrayList<>();
+    for (Artifact input : getInputs()) {
+      if (!input.getExecPath().getBaseName().endsWith(".optional")) {
+        mandatoryInputs.add(input);
+      }
+    }
+    return mandatoryInputs;
+  }
+
+  @Override
+  public boolean discoversInputs() {
+    for (Artifact input : getInputs()) {
+      if (!input.getExecPath().getBaseName().endsWith(".optional")) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  @Override
+  public void discoverInputs(ActionExecutionContext actionExecutionContext) {
+    Preconditions.checkState(discoversInputs(), this);
+  }
+
+  @Override
+  public void execute(ActionExecutionContext actionExecutionContext)
+      throws ActionExecutionException {
+    for (Artifact artifact : getInputs()) {
+      // Do not check *.optional artifacts - artifacts with such extension are
+      // used by tests to specify artifacts that may or may not be missing.
+      // This is used, e.g., to test Blaze behavior when action has missing
+      // input artifacts but still is successfully executed.
+      if (!artifact.getPath().exists() &&
+          !artifact.getExecPath().getBaseName().endsWith(".optional")) {
+        throw new IllegalStateException("action's input file does not exist: "
+            + artifact.getPath());
+      }
+    }
+
+    try {
+      effect.call();
+    } catch (RuntimeException | Error e) {
+      throw e;
+    } catch (Exception e) {
+      throw new ActionExecutionException("TestAction failed due to exception",
+                                         e, this, false);
+    }
+
+    try {
+      for (Artifact artifact: getOutputs()) {
+        FileSystemUtils.touchFile(artifact.getPath());
+      }
+    } catch (IOException e) {
+      throw new AssertionError(e);
+    }
+  }
+
+  @Override
+  public String describeStrategy(Executor executor) {
+    return "";
+  }
+
+  @Override
+  protected String computeKey() {
+    List<String> outputsList = new ArrayList<>();
+    for (Artifact output : getOutputs()) {
+      outputsList.add(output.getPath().getPathString());
+    }
+    // This could use a functional iterable and avoid creating a list
+    return "test " + StringUtilities.combineKeys(outputsList);
+  }
+
+  @Override
+  public String getMnemonic() { return "Test"; }
+
+  @Override
+  public ResourceSet estimateResourceConsumption(Executor executor) {
+    return RESOURCES;
+  }
+
+
+  /** No-op action that has exactly one output, and can be a middleman action. */
+  public static class DummyAction extends TestAction {
+    private static final Runnable NOOP = new Runnable() {
+      @Override
+      public void run() {}
+    };
+
+    private final MiddlemanType type;
+
+    public DummyAction(Collection<Artifact> inputs, Artifact output, MiddlemanType type) {
+      super(NOOP, inputs, ImmutableList.of(output));
+      this.type = type;
+    }
+
+    public DummyAction(Collection<Artifact> inputs, Artifact output) {
+      this(inputs, output, MiddlemanType.NORMAL);
+    }
+
+    @Override
+    public MiddlemanType getActionType() {
+      return type;
+    }
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/collect/CollectionUtilsTest.java b/src/test/java/com/google/devtools/build/lib/collect/CollectionUtilsTest.java
new file mode 100644
index 0000000..2505501
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/collect/CollectionUtilsTest.java
@@ -0,0 +1,175 @@
+// Copyright 2014 Google Inc. 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.collect;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
+import com.google.devtools.build.lib.collect.nestedset.NestedSet;
+import com.google.devtools.build.lib.collect.nestedset.NestedSetBuilder;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.EnumSet;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * Tests for {@link CollectionUtils}.
+ */
+
+@RunWith(JUnit4.class)
+public class CollectionUtilsTest {
+
+  @Test
+  public void testDuplicatedElementsOf() {
+    assertDups(ImmutableList.<Integer>of(), ImmutableSet.<Integer>of());
+    assertDups(ImmutableList.of(0), ImmutableSet.<Integer>of());
+    assertDups(ImmutableList.of(0, 0, 0), ImmutableSet.of(0));
+    assertDups(ImmutableList.of(1, 2, 3, 1, 2, 3), ImmutableSet.of(1, 2, 3));
+    assertDups(ImmutableList.of(1, 2, 3, 1, 2, 3, 4), ImmutableSet.of(1, 2, 3));
+    assertDups(ImmutableList.of(1, 2, 3, 4), ImmutableSet.<Integer>of());
+  }
+
+  private static void assertDups(List<Integer> collection, Set<Integer> dups) {
+    assertEquals(dups, CollectionUtils.duplicatedElementsOf(collection));
+  }
+
+  @Test
+  public void testIsImmutable() throws Exception {
+    assertTrue(CollectionUtils.isImmutable(ImmutableList.of(1, 2, 3)));
+    assertTrue(CollectionUtils.isImmutable(ImmutableSet.of(1, 2, 3)));
+
+    NestedSet<Integer> ns = NestedSetBuilder.<Integer>compileOrder()
+        .add(1).add(2).add(3).build();
+    assertTrue(CollectionUtils.isImmutable(ns));
+
+    NestedSet<Integer> ns2 = NestedSetBuilder.<Integer>linkOrder().add(1).add(2).add(3).build();
+    assertTrue(CollectionUtils.isImmutable(ns2));
+
+    IterablesChain<Integer> chain = IterablesChain.<Integer>builder().addElement(1).build();
+
+    assertTrue(CollectionUtils.isImmutable(chain));
+
+    assertFalse(CollectionUtils.isImmutable(Lists.newArrayList()));
+    assertFalse(CollectionUtils.isImmutable(Lists.newLinkedList()));
+    assertFalse(CollectionUtils.isImmutable(Sets.newHashSet()));
+    assertFalse(CollectionUtils.isImmutable(Sets.newLinkedHashSet()));
+
+    // The result of Iterables.concat() actually is immutable, but we have no way of checking if
+    // a given Iterable comes from concat().
+    assertFalse(CollectionUtils.isImmutable(Iterables.concat(ns, ns2)));
+
+    // We can override the check by using the ImmutableIterable wrapper.
+    assertTrue(CollectionUtils.isImmutable(
+        ImmutableIterable.from(Iterables.concat(ns, ns2))));
+  }
+
+  @Test
+  public void testCheckImmutable() throws Exception {
+    CollectionUtils.checkImmutable(ImmutableList.of(1, 2, 3));
+    CollectionUtils.checkImmutable(ImmutableSet.of(1, 2, 3));
+
+    try {
+      CollectionUtils.checkImmutable(Lists.newArrayList(1, 2, 3));
+    } catch (IllegalStateException e) {
+      return;
+    }
+    fail();
+  }
+
+  @Test
+  public void testMakeImmutable() throws Exception {
+    Iterable<Integer> immutableList = ImmutableList.of(1, 2, 3);
+    assertSame(immutableList, CollectionUtils.makeImmutable(immutableList));
+
+    Iterable<Integer> mutableList = Lists.newArrayList(1, 2, 3);
+    Iterable<Integer> converted = CollectionUtils.makeImmutable(mutableList);
+    assertNotSame(mutableList, converted);
+    assertEquals(mutableList, ImmutableList.copyOf(converted));
+  }
+
+  private static enum Small { ALPHA, BRAVO }
+  private static enum Large {
+    L0, L1, L2, L3, L4, L5, L6, L7, L8, L9,
+    L10, L11, L12, L13, L14, L15, L16, L17, L18, L19,
+    L20, L21, L22, L23, L24, L25, L26, L27, L28, L29,
+    L30, L31,
+  }
+
+  private static enum TooLarge {
+    T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
+    T10, T11, T12, T13, T14, T15, T16, T17, T18, T19,
+    T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, T31, T32,
+  }
+
+  private static enum Medium {
+    ONE, TWO, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT,
+  }
+
+  private <T extends Enum<T>> void assertAllDifferent(Class<T> clazz) throws Exception {
+    Set<EnumSet<T>> allSets = new HashSet<>();
+
+    int maxBits = 1 << clazz.getEnumConstants().length;
+    for (int i = 0; i < maxBits; i++) {
+      EnumSet<T> set = CollectionUtils.fromBits(i, clazz);
+      int back = CollectionUtils.toBits(set);
+      assertEquals(back, i);  // Assert that a roundtrip is idempotent
+      allSets.add(set);
+    }
+
+    assertEquals(maxBits, allSets.size());  // Assert that every decoded value is different
+  }
+
+  @Test
+  public void testEnumBitfields() throws Exception {
+    assertEquals(0, CollectionUtils.<Small>toBits());
+    assertEquals(EnumSet.noneOf(Small.class), CollectionUtils.fromBits(0, Small.class));
+    assertEquals(3, CollectionUtils.toBits(Small.ALPHA, Small.BRAVO));
+    assertEquals(10, CollectionUtils.toBits(Medium.TWO, Medium.FOUR));
+    assertEquals(EnumSet.of(Medium.SEVEN, Medium.EIGHT),
+        CollectionUtils.fromBits(192, Medium.class));
+
+    assertAllDifferent(Small.class);
+    assertAllDifferent(Medium.class);
+    assertAllDifferent(Large.class);
+
+    try {
+      CollectionUtils.toBits(TooLarge.T32);
+      fail();
+    } catch (IllegalArgumentException e) {
+      // good
+    }
+
+    try {
+      CollectionUtils.fromBits(0, TooLarge.class);
+      fail();
+    } catch (IllegalArgumentException e) {
+      // good
+    }
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/collect/ImmutableSortedKeyListMultimapTest.java b/src/test/java/com/google/devtools/build/lib/collect/ImmutableSortedKeyListMultimapTest.java
new file mode 100644
index 0000000..1249f6d
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/collect/ImmutableSortedKeyListMultimapTest.java
@@ -0,0 +1,352 @@
+// Copyright 2014 Google Inc. 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.collect;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.HashMultiset;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.LinkedListMultimap;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.testing.google.UnmodifiableCollectionTests;
+import com.google.common.testing.EqualsTester;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.AbstractMap.SimpleImmutableEntry;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * A test for {@link ImmutableSortedKeyListMultimap}. Started out as a copy of
+ * ImmutableListMultimapTest.
+ */
+@RunWith(JUnit4.class)
+public class ImmutableSortedKeyListMultimapTest {
+
+  @Test
+  public void builderPutAllIterable() {
+    ImmutableSortedKeyListMultimap.Builder<String, Integer> builder
+        = ImmutableSortedKeyListMultimap.builder();
+    builder.putAll("foo", Arrays.asList(1, 2, 3));
+    builder.putAll("bar", Arrays.asList(4, 5));
+    builder.putAll("foo", Arrays.asList(6, 7));
+    Multimap<String, Integer> multimap = builder.build();
+    assertEquals(Arrays.asList(1, 2, 3, 6, 7), multimap.get("foo"));
+    assertEquals(Arrays.asList(4, 5), multimap.get("bar"));
+    assertEquals(7, multimap.size());
+  }
+
+  @Test
+  public void builderPutAllVarargs() {
+    ImmutableSortedKeyListMultimap.Builder<String, Integer> builder
+        = ImmutableSortedKeyListMultimap.builder();
+    builder.putAll("foo", 1, 2, 3);
+    builder.putAll("bar", 4, 5);
+    builder.putAll("foo", 6, 7);
+    Multimap<String, Integer> multimap = builder.build();
+    assertEquals(Arrays.asList(1, 2, 3, 6, 7), multimap.get("foo"));
+    assertEquals(Arrays.asList(4, 5), multimap.get("bar"));
+    assertEquals(7, multimap.size());
+  }
+
+  @Test
+  public void builderPutAllMultimap() {
+    Multimap<String, Integer> toPut = LinkedListMultimap.create();
+    toPut.put("foo", 1);
+    toPut.put("bar", 4);
+    toPut.put("foo", 2);
+    toPut.put("foo", 3);
+    Multimap<String, Integer> moreToPut = LinkedListMultimap.create();
+    moreToPut.put("foo", 6);
+    moreToPut.put("bar", 5);
+    moreToPut.put("foo", 7);
+    ImmutableSortedKeyListMultimap.Builder<String, Integer> builder
+        = ImmutableSortedKeyListMultimap.builder();
+    builder.putAll(toPut);
+    builder.putAll(moreToPut);
+    Multimap<String, Integer> multimap = builder.build();
+    assertEquals(Arrays.asList(1, 2, 3, 6, 7), multimap.get("foo"));
+    assertEquals(Arrays.asList(4, 5), multimap.get("bar"));
+    assertEquals(7, multimap.size());
+  }
+
+  @Test
+  public void builderPutAllWithDuplicates() {
+    ImmutableSortedKeyListMultimap.Builder<String, Integer> builder
+        = ImmutableSortedKeyListMultimap.builder();
+    builder.putAll("foo", 1, 2, 3);
+    builder.putAll("bar", 4, 5);
+    builder.putAll("foo", 1, 6, 7);
+    ImmutableSortedKeyListMultimap<String, Integer> multimap = builder.build();
+    assertEquals(Arrays.asList(1, 2, 3, 1, 6, 7), multimap.get("foo"));
+    assertEquals(Arrays.asList(4, 5), multimap.get("bar"));
+    assertEquals(8, multimap.size());
+  }
+
+  @Test
+  public void builderPutWithDuplicates() {
+    ImmutableSortedKeyListMultimap.Builder<String, Integer> builder
+        = ImmutableSortedKeyListMultimap.builder();
+    builder.putAll("foo", 1, 2, 3);
+    builder.putAll("bar", 4, 5);
+    builder.put("foo", 1);
+    ImmutableSortedKeyListMultimap<String, Integer> multimap = builder.build();
+    assertEquals(Arrays.asList(1, 2, 3, 1), multimap.get("foo"));
+    assertEquals(Arrays.asList(4, 5), multimap.get("bar"));
+    assertEquals(6, multimap.size());
+  }
+
+  @Test
+  public void builderPutAllMultimapWithDuplicates() {
+    Multimap<String, Integer> toPut = LinkedListMultimap.create();
+    toPut.put("foo", 1);
+    toPut.put("bar", 4);
+    toPut.put("foo", 2);
+    toPut.put("foo", 1);
+    toPut.put("bar", 5);
+    Multimap<String, Integer> moreToPut = LinkedListMultimap.create();
+    moreToPut.put("foo", 6);
+    moreToPut.put("bar", 4);
+    moreToPut.put("foo", 7);
+    moreToPut.put("foo", 2);
+    ImmutableSortedKeyListMultimap.Builder<String, Integer> builder
+        = ImmutableSortedKeyListMultimap.builder();
+    builder.putAll(toPut);
+    builder.putAll(moreToPut);
+    Multimap<String, Integer> multimap = builder.build();
+    assertEquals(Arrays.asList(1, 2, 1, 6, 7, 2), multimap.get("foo"));
+    assertEquals(Arrays.asList(4, 5, 4), multimap.get("bar"));
+    assertEquals(9, multimap.size());
+  }
+
+  @Test
+  public void builderPutNullKey() {
+    Multimap<String, Integer> toPut = LinkedListMultimap.create();
+    toPut.put("foo", null);
+    ImmutableSortedKeyListMultimap.Builder<String, Integer> builder
+        = ImmutableSortedKeyListMultimap.builder();
+    try {
+      builder.put(null, 1);
+      fail();
+    } catch (NullPointerException expected) {}
+    try {
+      builder.putAll(null, Arrays.asList(1, 2, 3));
+      fail();
+    } catch (NullPointerException expected) {}
+    try {
+      builder.putAll(null, 1, 2, 3);
+      fail();
+    } catch (NullPointerException expected) {}
+    try {
+      builder.putAll(toPut);
+      fail();
+    } catch (NullPointerException expected) {}
+  }
+
+  @Test
+  public void builderPutNullValue() {
+    Multimap<String, Integer> toPut = LinkedListMultimap.create();
+    toPut.put(null, 1);
+    ImmutableSortedKeyListMultimap.Builder<String, Integer> builder
+        = ImmutableSortedKeyListMultimap.builder();
+    try {
+      builder.put("foo", null);
+      fail();
+    } catch (NullPointerException expected) {}
+    try {
+      builder.putAll("foo", Arrays.asList(1, null, 3));
+      fail();
+    } catch (NullPointerException expected) {}
+    try {
+      builder.putAll("foo", 1, null, 3);
+      fail();
+    } catch (NullPointerException expected) {}
+    try {
+      builder.putAll(toPut);
+      fail();
+    } catch (NullPointerException expected) {}
+  }
+
+  @Test
+  public void copyOf() {
+    ArrayListMultimap<String, Integer> input = ArrayListMultimap.create();
+    input.put("foo", 1);
+    input.put("bar", 2);
+    input.put("foo", 3);
+    Multimap<String, Integer> multimap = ImmutableSortedKeyListMultimap.copyOf(input);
+    assertEquals(multimap, input);
+    assertEquals(input, multimap);
+  }
+
+  @Test
+  public void copyOfWithDuplicates() {
+    ArrayListMultimap<String, Integer> input = ArrayListMultimap.create();
+    input.put("foo", 1);
+    input.put("bar", 2);
+    input.put("foo", 3);
+    input.put("foo", 1);
+    Multimap<String, Integer> multimap = ImmutableSortedKeyListMultimap.copyOf(input);
+    assertEquals(multimap, input);
+    assertEquals(input, multimap);
+  }
+
+  @Test
+  public void copyOfEmpty() {
+    ArrayListMultimap<String, Integer> input = ArrayListMultimap.create();
+    Multimap<String, Integer> multimap = ImmutableSortedKeyListMultimap.copyOf(input);
+    assertEquals(multimap, input);
+    assertEquals(input, multimap);
+  }
+
+  @Test
+  public void copyOfImmutableListMultimap() {
+    Multimap<String, Integer> multimap = createMultimap();
+    assertSame(multimap, ImmutableSortedKeyListMultimap.copyOf(multimap));
+  }
+
+  @Test
+  public void copyOfNullKey() {
+    ArrayListMultimap<String, Integer> input = ArrayListMultimap.create();
+    input.put(null, 1);
+    try {
+      ImmutableSortedKeyListMultimap.copyOf(input);
+      fail();
+    } catch (NullPointerException expected) {}
+  }
+
+  @Test
+  public void copyOfNullValue() {
+    ArrayListMultimap<String, Integer> input = ArrayListMultimap.create();
+    input.putAll("foo", Arrays.asList(1, null, 3));
+    try {
+      ImmutableSortedKeyListMultimap.copyOf(input);
+      fail();
+    } catch (NullPointerException expected) {}
+  }
+
+  @Test
+  public void emptyMultimapReads() {
+    Multimap<String, Integer> multimap = ImmutableSortedKeyListMultimap.of();
+    assertFalse(multimap.containsKey("foo"));
+    assertFalse(multimap.containsValue(1));
+    assertFalse(multimap.containsEntry("foo", 1));
+    assertTrue(multimap.entries().isEmpty());
+    assertTrue(multimap.equals(ArrayListMultimap.create()));
+    assertEquals(Collections.emptyList(), multimap.get("foo"));
+    assertEquals(0, multimap.hashCode());
+    assertTrue(multimap.isEmpty());
+    assertEquals(HashMultiset.create(), multimap.keys());
+    assertEquals(Collections.emptySet(), multimap.keySet());
+    assertEquals(0, multimap.size());
+    assertTrue(multimap.values().isEmpty());
+    assertEquals("{}", multimap.toString());
+  }
+
+  @Test
+  public void emptyMultimapWrites() {
+    Multimap<String, Integer> multimap = ImmutableSortedKeyListMultimap.of();
+    UnmodifiableCollectionTests.assertMultimapIsUnmodifiable(
+        multimap, "foo", 1);
+  }
+
+  private Multimap<String, Integer> createMultimap() {
+    return ImmutableSortedKeyListMultimap.<String, Integer>builder()
+        .put("foo", 1).put("bar", 2).put("foo", 3).build();
+  }
+
+  @Test
+  public void multimapReads() {
+    Multimap<String, Integer> multimap = createMultimap();
+    assertTrue(multimap.containsKey("foo"));
+    assertFalse(multimap.containsKey("cat"));
+    assertTrue(multimap.containsValue(1));
+    assertFalse(multimap.containsValue(5));
+    assertTrue(multimap.containsEntry("foo", 1));
+    assertFalse(multimap.containsEntry("cat", 1));
+    assertFalse(multimap.containsEntry("foo", 5));
+    assertFalse(multimap.entries().isEmpty());
+    assertEquals(3, multimap.size());
+    assertFalse(multimap.isEmpty());
+    assertEquals("{bar=[2], foo=[1, 3]}", multimap.toString());
+  }
+
+  @Test
+  public void multimapWrites() {
+    Multimap<String, Integer> multimap = createMultimap();
+    UnmodifiableCollectionTests.assertMultimapIsUnmodifiable(
+        multimap, "bar", 2);
+  }
+
+  @Test
+  public void multimapEquals() {
+    Multimap<String, Integer> multimap = createMultimap();
+    Multimap<String, Integer> arrayListMultimap
+        = ArrayListMultimap.create();
+    arrayListMultimap.putAll("foo", Arrays.asList(1, 3));
+    arrayListMultimap.put("bar", 2);
+
+    new EqualsTester()
+        .addEqualityGroup(multimap, createMultimap(), arrayListMultimap,
+            ImmutableSortedKeyListMultimap.<String, Integer>builder()
+                .put("bar", 2).put("foo", 1).put("foo", 3).build())
+        .addEqualityGroup(ImmutableSortedKeyListMultimap.<String, Integer>builder()
+            .put("bar", 2).put("foo", 3).put("foo", 1).build())
+        .addEqualityGroup(ImmutableSortedKeyListMultimap.<String, Integer>builder()
+            .put("foo", 2).put("foo", 3).put("foo", 1).build())
+        .addEqualityGroup(ImmutableSortedKeyListMultimap.<String, Integer>builder()
+            .put("bar", 2).put("foo", 3).build())
+        .testEquals();
+  }
+
+  @Test
+  public void asMap() {
+    ImmutableSortedKeyListMultimap.Builder<String, Integer> builder
+        = ImmutableSortedKeyListMultimap.builder();
+    builder.putAll("foo", Arrays.asList(1, 2, 3));
+    builder.putAll("bar", Arrays.asList(4, 5));
+    Map<String, Collection<Integer>> map = builder.build().asMap();
+    assertEquals(Arrays.asList(1, 2, 3), map.get("foo"));
+    assertEquals(Arrays.asList(4, 5), map.get("bar"));
+    assertEquals(2, map.size());
+    assertTrue(map.containsKey("foo"));
+    assertTrue(map.containsKey("bar"));
+    assertFalse(map.containsKey("notfoo"));
+  }
+
+  @Test
+  public void asMapEntries() {
+    ImmutableSortedKeyListMultimap.Builder<String, Integer> builder
+        = ImmutableSortedKeyListMultimap.builder();
+    builder.putAll("foo", Arrays.asList(1, 2, 3));
+    builder.putAll("bar", Arrays.asList(4, 5));
+    Set<Map.Entry<String, Collection<Integer>>> set = builder.build().asMap().entrySet();
+    Set<Map.Entry<String, Collection<Integer>>> other =
+        ImmutableSet.<Map.Entry<String, Collection<Integer>>>builder()
+        .add(new SimpleImmutableEntry<String, Collection<Integer>>("foo", Arrays.asList(1, 2, 3)))
+        .add(new SimpleImmutableEntry<String, Collection<Integer>>("bar", Arrays.asList(4, 5)))
+        .build();
+    assertEquals(other, set);
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/collect/ImmutableSortedKeyMapTest.java b/src/test/java/com/google/devtools/build/lib/collect/ImmutableSortedKeyMapTest.java
new file mode 100644
index 0000000..c712695
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/collect/ImmutableSortedKeyMapTest.java
@@ -0,0 +1,288 @@
+// Copyright 2014 Google Inc. 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.collect;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.Maps;
+import com.google.common.testing.NullPointerTester;
+import com.google.devtools.build.lib.collect.ImmutableSortedKeyMap.Builder;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.Serializable;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+
+/**
+ * A test for {@link ImmutableSortedKeyListMultimap}. Started out as a blatant copy of
+ * ImmutableListMapTest.
+ */
+@RunWith(JUnit4.class)
+public class ImmutableSortedKeyMapTest {
+
+  @Test
+  public void emptyBuilder() {
+    ImmutableSortedKeyMap<String, Integer> map
+        = ImmutableSortedKeyMap.<String, Integer>builder().build();
+    assertEquals(Collections.<String, Integer>emptyMap(), map);
+  }
+
+  @Test
+  public void singletonBuilder() {
+    ImmutableSortedKeyMap<String, Integer> map = ImmutableSortedKeyMap.<String, Integer>builder()
+        .put("one", 1)
+        .build();
+    assertMapEquals(map, "one", 1);
+  }
+
+  @Test
+  public void builder() {
+    ImmutableSortedKeyMap<String, Integer> map = ImmutableSortedKeyMap.<String, Integer>builder()
+        .put("one", 1)
+        .put("two", 2)
+        .put("three", 3)
+        .put("four", 4)
+        .put("five", 5)
+        .build();
+    assertMapEquals(map,
+        "five", 5, "four", 4, "one", 1, "three", 3, "two", 2);
+  }
+
+  @Test
+  public void builderPutAllWithEmptyMap() {
+    ImmutableSortedKeyMap<String, Integer> map = ImmutableSortedKeyMap.<String, Integer>builder()
+        .putAll(Collections.<String, Integer>emptyMap())
+        .build();
+    assertEquals(Collections.<String, Integer>emptyMap(), map);
+  }
+
+  @Test
+  public void builderPutAll() {
+    Map<String, Integer> toPut = new LinkedHashMap<>();
+    toPut.put("one", 1);
+    toPut.put("two", 2);
+    toPut.put("three", 3);
+    Map<String, Integer> moreToPut = new LinkedHashMap<>();
+    moreToPut.put("four", 4);
+    moreToPut.put("five", 5);
+
+    ImmutableSortedKeyMap<String, Integer> map = ImmutableSortedKeyMap.<String, Integer>builder()
+        .putAll(toPut)
+        .putAll(moreToPut)
+        .build();
+    assertMapEquals(map,
+        "five", 5, "four", 4, "one", 1, "three", 3, "two", 2);
+  }
+
+  @Test
+  public void builderReuse() {
+    ImmutableSortedKeyMap.Builder<String, Integer> builder =
+        ImmutableSortedKeyMap.<String, Integer>builder();
+    ImmutableSortedKeyMap<String, Integer> mapOne = builder
+        .put("one", 1)
+        .put("two", 2)
+        .build();
+    ImmutableSortedKeyMap<String, Integer> mapTwo = builder
+        .put("three", 3)
+        .put("four", 4)
+        .build();
+
+    assertMapEquals(mapOne, "one", 1, "two", 2);
+    assertMapEquals(mapTwo, "four", 4, "one", 1, "three", 3, "two", 2);
+  }
+
+  @Test
+  public void builderPutNullKey() {
+    Builder<String, Integer> builder = new Builder<>();
+    try {
+      builder.put(null, 1);
+      fail();
+    } catch (NullPointerException expected) {
+    }
+  }
+
+  @Test
+  public void builderPutNullValue() {
+    Builder<String, Integer> builder = new Builder<>();
+    try {
+      builder.put("one", null);
+      fail();
+    } catch (NullPointerException expected) {
+    }
+  }
+
+  @Test
+  public void builderPutNullKeyViaPutAll() {
+    Builder<String, Integer> builder = new Builder<>();
+    try {
+      builder.putAll(Collections.<String, Integer>singletonMap(null, 1));
+      fail();
+    } catch (NullPointerException expected) {
+    }
+  }
+
+  @Test
+  public void builderPutNullValueViaPutAll() {
+    Builder<String, Integer> builder = new Builder<>();
+    try {
+      builder.putAll(Collections.<String, Integer>singletonMap("one", null));
+      fail();
+    } catch (NullPointerException expected) {
+    }
+  }
+
+  @Test
+  public void of() {
+    assertMapEquals(
+        ImmutableSortedKeyMap.of("one", 1),
+        "one", 1);
+    assertMapEquals(
+        ImmutableSortedKeyMap.of("one", 1, "two", 2),
+        "one", 1, "two", 2);
+  }
+
+  @Test
+  public void ofNullKey() {
+    try {
+      ImmutableSortedKeyMap.of((String) null, 1);
+      fail();
+    } catch (NullPointerException expected) {
+    }
+
+    try {
+      ImmutableSortedKeyMap.of("one", 1, null, 2);
+      fail();
+    } catch (NullPointerException expected) {
+    }
+  }
+
+  @Test
+  public void ofNullValue() {
+    try {
+      ImmutableSortedKeyMap.of("one", null);
+      fail();
+    } catch (NullPointerException expected) {
+    }
+
+    try {
+      ImmutableSortedKeyMap.of("one", 1, "two", null);
+      fail();
+    } catch (NullPointerException expected) {
+    }
+  }
+
+  @Test
+  public void copyOfEmptyMap() {
+    ImmutableSortedKeyMap<String, Integer> copy
+        = ImmutableSortedKeyMap.copyOf(Collections.<String, Integer>emptyMap());
+    assertEquals(Collections.<String, Integer>emptyMap(), copy);
+    assertSame(copy, ImmutableSortedKeyMap.copyOf(copy));
+  }
+
+  @Test
+  public void copyOfSingletonMap() {
+    ImmutableSortedKeyMap<String, Integer> copy
+        = ImmutableSortedKeyMap.copyOf(Collections.singletonMap("one", 1));
+    assertMapEquals(copy, "one", 1);
+    assertSame(copy, ImmutableSortedKeyMap.copyOf(copy));
+  }
+
+  @Test
+  public void copyOf() {
+    Map<String, Integer> original = new LinkedHashMap<>();
+    original.put("one", 1);
+    original.put("two", 2);
+    original.put("three", 3);
+
+    ImmutableSortedKeyMap<String, Integer> copy = ImmutableSortedKeyMap.copyOf(original);
+    assertMapEquals(copy, "one", 1, "three", 3, "two", 2);
+    assertSame(copy, ImmutableSortedKeyMap.copyOf(copy));
+  }
+
+  @Test
+  public void nullGet() {
+    ImmutableSortedKeyMap<String, Integer> map = ImmutableSortedKeyMap.of("one", 1);
+    assertNull(map.get(null));
+  }
+
+  @Test
+  public void nullPointers() {
+    NullPointerTester tester = new NullPointerTester();
+    tester.testAllPublicStaticMethods(ImmutableSortedKeyMap.class);
+    tester.testAllPublicInstanceMethods(
+        new ImmutableSortedKeyMap.Builder<String, Object>());
+    tester.testAllPublicInstanceMethods(ImmutableSortedKeyMap.<String, Integer>of());
+    tester.testAllPublicInstanceMethods(ImmutableSortedKeyMap.of("one", 1));
+    tester.testAllPublicInstanceMethods(
+        ImmutableSortedKeyMap.of("one", 1, "two", 2));
+  }
+
+  private static <K, V> void assertMapEquals(Map<K, V> map,
+      Object... alternatingKeysAndValues) {
+    assertEquals(map.size(), alternatingKeysAndValues.length / 2);
+    int i = 0;
+    for (Entry<K, V> entry : map.entrySet()) {
+      assertEquals(alternatingKeysAndValues[i++], entry.getKey());
+      assertEquals(alternatingKeysAndValues[i++], entry.getValue());
+    }
+  }
+
+  private static class IntHolder implements Serializable {
+    public int value;
+
+    public IntHolder(int value) {
+      this.value = value;
+    }
+
+    @Override public boolean equals(Object o) {
+      return (o instanceof IntHolder) && ((IntHolder) o).value == value;
+    }
+
+    @Override public int hashCode() {
+      return value;
+    }
+
+    private static final long serialVersionUID = 5;
+  }
+
+  @Test
+  public void mutableValues() {
+    IntHolder holderA = new IntHolder(1);
+    IntHolder holderB = new IntHolder(2);
+    Map<String, IntHolder> map = ImmutableSortedKeyMap.of("a", holderA, "b", holderB);
+    holderA.value = 3;
+    assertTrue(map.entrySet().contains(
+        Maps.immutableEntry("a", new IntHolder(3))));
+    Map<String, Integer> intMap = ImmutableSortedKeyMap.of("a", 3, "b", 2);
+    assertEquals(intMap.hashCode(), map.entrySet().hashCode());
+    assertEquals(intMap.hashCode(), map.hashCode());
+  }
+
+  @Test
+  public void toStringTest() {
+    Map<String, Integer> map = ImmutableSortedKeyMap.of("a", 1, "b", 2);
+    assertEquals("{a=1, b=2}", map.toString());
+    map = ImmutableSortedKeyMap.of();
+    assertEquals("{}", map.toString());
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/collect/IterablesChainTest.java b/src/test/java/com/google/devtools/build/lib/collect/IterablesChainTest.java
new file mode 100644
index 0000000..734d801
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/collect/IterablesChainTest.java
@@ -0,0 +1,60 @@
+// Copyright 2014 Google Inc. 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.collect;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import com.google.common.collect.ImmutableList;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.Arrays;
+
+/**
+ * A test for {@link IterablesChain}.
+ */
+@RunWith(JUnit4.class)
+public class IterablesChainTest {
+
+  @Test
+  public void addElement() {
+    IterablesChain.Builder<String> builder = IterablesChain.builder();
+    builder.addElement("a");
+    builder.addElement("b");
+    assertEquals(Arrays.asList("a", "b"), ImmutableList.copyOf(builder.build()));
+  }
+
+  @Test
+  public void add() {
+    IterablesChain.Builder<String> builder = IterablesChain.builder();
+    builder.add(ImmutableList.of("a", "b"));
+    assertEquals(Arrays.asList("a", "b"), ImmutableList.copyOf(builder.build()));
+  }
+
+  @Test
+  public void isEmpty() {
+    IterablesChain.Builder<String> builder = IterablesChain.builder();
+    assertTrue(builder.isEmpty());
+    builder.addElement("a");
+    assertFalse(builder.isEmpty());
+    builder = IterablesChain.builder();
+    assertTrue(builder.isEmpty());
+    builder.add(ImmutableList.of("a"));
+    assertFalse(builder.isEmpty());
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/collect/nestedset/CompileOrderExpanderTest.java b/src/test/java/com/google/devtools/build/lib/collect/nestedset/CompileOrderExpanderTest.java
new file mode 100644
index 0000000..926ce2d
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/collect/nestedset/CompileOrderExpanderTest.java
@@ -0,0 +1,64 @@
+// Copyright 2014 Google Inc. 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.collect.nestedset;
+
+
+import com.google.common.collect.ImmutableList;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.List;
+
+/**
+ * Tests for {@link CompileOrderExpander}.
+ */
+@RunWith(JUnit4.class)
+public class CompileOrderExpanderTest extends ExpanderTestBase {
+
+  @Override
+  protected Order expanderOrder() {
+    return Order.COMPILE_ORDER;
+  }
+
+  @Override
+  protected List<String> nestedResult() {
+    return ImmutableList.of("c", "a", "e", "b", "d");
+  }
+
+  @Override
+  protected List<String> nestedDuplicatesResult() {
+    return ImmutableList.of("c", "a", "e", "b", "d");
+  }
+
+  @Override
+  protected List<String> chainResult() {
+    return ImmutableList.of("c", "b", "a");
+  }
+
+  @Override
+  protected List<String> diamondResult() {
+    return ImmutableList.of("d", "b", "c", "a");
+  }
+
+  @Override
+  protected List<String> extendedDiamondResult() {
+    return ImmutableList.of("d", "e", "b", "c", "a");
+  }
+
+  @Override
+  protected List<String> extendedDiamondRightArmResult() {
+    return ImmutableList.of("d", "e", "b", "c2", "c", "a");
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/collect/nestedset/ExpanderTestBase.java b/src/test/java/com/google/devtools/build/lib/collect/nestedset/ExpanderTestBase.java
new file mode 100644
index 0000000..25448c6
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/collect/nestedset/ExpanderTestBase.java
@@ -0,0 +1,330 @@
+// Copyright 2014 Google Inc. 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.collect.nestedset;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
+
+import junit.framework.TestCase;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Base class for tests of {@link NestedSetExpander} implementations.
+ *
+ * <p>This class provides test cases for representative nested set structures; the expected
+ * results must be provided by overriding the corresponding methods.
+ */
+public abstract class ExpanderTestBase extends TestCase  {
+
+  /**
+   * Returns the type of the expander under test.
+   */
+  protected abstract Order expanderOrder();
+
+  @Test
+  public void simple() {
+    NestedSet<String> s = prepareBuilder("c", "a", "b").build();
+
+    assertTrue(Arrays.equals(simpleResult().toArray(), s.directMembers()));
+    assertSetContents(simpleResult(), s);
+  }
+
+  @Test
+  public void simpleNoDuplicates() {
+    NestedSet<String> s = prepareBuilder("c", "a", "a", "a", "b").build();
+
+    assertTrue(Arrays.equals(simpleResult().toArray(), s.directMembers()));
+    assertSetContents(simpleResult(), s);
+  }
+
+  @Test
+  public void nesting() {
+    NestedSet<String> subset = prepareBuilder("c", "a", "e").build();
+    NestedSet<String> s = prepareBuilder("b", "d").addTransitive(subset).build();
+
+    assertSetContents(nestedResult(), s);
+  }
+
+  @Test
+  public void builderReuse() {
+    NestedSetBuilder<String> builder = prepareBuilder();
+    assertSetContents(Collections.<String>emptyList(), builder.build());
+
+    builder.add("b");
+    assertSetContents(ImmutableList.of("b"), builder.build());
+
+    builder.addAll(ImmutableList.of("d"));
+    Collection<String> expected = ImmutableList.copyOf(prepareBuilder("b", "d").build());
+    assertSetContents(expected, builder.build());
+
+    NestedSet<String> child = prepareBuilder("c", "a", "e").build();
+    builder.addTransitive(child);
+    assertSetContents(nestedResult(), builder.build());
+  }
+
+  @Test
+  public void builderChaining() {
+    NestedSet<String> s = prepareBuilder().add("b").addAll(ImmutableList.of("d"))
+        .addTransitive(prepareBuilder("c", "a", "e").build()).build();
+    assertSetContents(nestedResult(), s);
+  }
+
+  @Test
+  public void addAllOrdering() {
+    NestedSet<String> s1 = prepareBuilder().add("a").add("c").add("b").build();
+    NestedSet<String> s2 = prepareBuilder().addAll(ImmutableList.of("a", "c", "b")).build();
+
+    assertTrue(Arrays.equals(s1.directMembers(), s2.directMembers()));
+    assertCollectionsEqual(s1.toCollection(), s2.toCollection());
+    assertCollectionsEqual(s1.toList(), s2.toList());
+    assertCollectionsEqual(Lists.newArrayList(s1), Lists.newArrayList(s2));
+  }
+
+  @Test
+  public void mixedAddAllOrdering() {
+    NestedSet<String> s1 = prepareBuilder().add("a").add("b").add("c").add("d").build();
+    NestedSet<String> s2 = prepareBuilder().add("a").addAll(ImmutableList.of("b", "c")).add("d")
+        .build();
+
+    assertTrue(Arrays.equals(s1.directMembers(), s2.directMembers()));
+    assertCollectionsEqual(s1.toCollection(), s2.toCollection());
+    assertCollectionsEqual(s1.toList(), s2.toList());
+    assertCollectionsEqual(Lists.newArrayList(s1), Lists.newArrayList(s2));
+  }
+
+  @Test
+  public void transitiveDepsHandledSeparately() {
+    NestedSet<String> subset = prepareBuilder("c", "a", "e").build();
+    NestedSetBuilder<String> b = prepareBuilder();
+    // The fact that we add the transitive subset between the add("b") and add("d") calls should
+    // not change the result.
+    b.add("b");
+    b.addTransitive(subset);
+    b.add("d");
+    NestedSet<String> s = b.build();
+
+    assertSetContents(nestedResult(), s);
+  }
+
+  @Test
+  public void nestingNoDuplicates() {
+    NestedSet<String> subset = prepareBuilder("c", "a", "e").build();
+    NestedSet<String> s = prepareBuilder("b", "d", "e").addTransitive(subset).build();
+
+    assertSetContents(nestedDuplicatesResult(), s);
+  }
+
+  @Test
+  public void chain() {
+    NestedSet<String> c = prepareBuilder("c").build();
+    NestedSet<String> b = prepareBuilder("b").addTransitive(c).build();
+    NestedSet<String> a = prepareBuilder("a").addTransitive(b).build();
+
+    assertTrue(Arrays.equals(new String[]{"a"}, a.directMembers()));
+    assertSetContents(chainResult(), a);
+  }
+
+  @Test
+  public void diamond() {
+    NestedSet<String> d = prepareBuilder("d").build();
+    NestedSet<String> c = prepareBuilder("c").addTransitive(d).build();
+    NestedSet<String> b = prepareBuilder("b").addTransitive(d).build();
+    NestedSet<String> a = prepareBuilder("a").addTransitive(b).addTransitive(c).build();
+
+    assertTrue(Arrays.equals(new String[]{"a"}, a.directMembers()));
+    assertSetContents(diamondResult(), a);
+  }
+
+  @Test
+  public void extendedDiamond() {
+    NestedSet<String> d = prepareBuilder("d").build();
+    NestedSet<String> e = prepareBuilder("e").build();
+    NestedSet<String> b = prepareBuilder("b").addTransitive(d).addTransitive(e).build();
+    NestedSet<String> c = prepareBuilder("c").addTransitive(e).addTransitive(d).build();
+    NestedSet<String> a = prepareBuilder("a").addTransitive(b).addTransitive(c).build();
+    assertSetContents(extendedDiamondResult(), a);
+  }
+
+  @Test
+  public void extendedDiamondRightArm() {
+    NestedSet<String> d = prepareBuilder("d").build();
+    NestedSet<String> e = prepareBuilder("e").build();
+    NestedSet<String> b = prepareBuilder("b").addTransitive(d).addTransitive(e).build();
+    NestedSet<String> c2 = prepareBuilder("c2").addTransitive(e).addTransitive(d).build();
+    NestedSet<String> c = prepareBuilder("c").addTransitive(c2).build();
+    NestedSet<String> a = prepareBuilder("a").addTransitive(b).addTransitive(c).build();
+    assertSetContents(extendedDiamondRightArmResult(), a);
+  }
+
+  @Test
+  public void orderConflict() {
+    NestedSet<String> child1 = prepareBuilder("a", "b").build();
+    NestedSet<String> child2 = prepareBuilder("b", "a").build();
+    NestedSet<String> parent = prepareBuilder().addTransitive(child1).addTransitive(child2).build();
+    assertSetContents(orderConflictResult(), parent);
+  }
+
+  @Test
+  public void orderConflictNested() {
+    NestedSet<String> a = prepareBuilder("a").build();
+    NestedSet<String> b = prepareBuilder("b").build();
+    NestedSet<String> child1 = prepareBuilder().addTransitive(a).addTransitive(b).build();
+    NestedSet<String> child2 = prepareBuilder().addTransitive(b).addTransitive(a).build();
+    NestedSet<String> parent = prepareBuilder().addTransitive(child1).addTransitive(child2).build();
+    assertSetContents(orderConflictResult(), parent);
+  }
+
+  @Test
+  public void getOrderingEmpty() {
+    NestedSet<String> s = prepareBuilder().build();
+    assertTrue(s.isEmpty());
+    assertEquals(expanderOrder(), s.getOrder());
+  }
+
+  @Test
+  public void getOrdering() {
+    NestedSet<String> s = prepareBuilder("a", "b").build();
+    assertTrue(!s.isEmpty());
+    assertEquals(expanderOrder(), s.getOrder());
+  }
+
+  /**
+   * In case we have inner NestedSets with different order (allowed by the builder). We should
+   * maintain the order of the top-level NestedSet.
+   */
+  @Test
+  public void regressionOnOneTransitiveDep() {
+    NestedSet<String> subsub = NestedSetBuilder.<String>stableOrder().add("c").add("a").add("e")
+        .build();
+    NestedSet<String> sub = NestedSetBuilder.<String>stableOrder().add("b").add("d")
+        .addTransitive(subsub).build();
+    NestedSet<String> top = prepareBuilder().addTransitive(sub).build();
+    assertSetContents(nestedResult(), top);
+  }
+
+  @Test
+  public void nestingValidation() {
+    for (Order ordering : Order.values()) {
+      NestedSet<String> a = prepareBuilder("a", "b").build();
+      NestedSetBuilder<String> b = new NestedSetBuilder<>(ordering);
+      try {
+        b.addTransitive(a);
+        if (ordering != expanderOrder() && ordering != Order.STABLE_ORDER) {
+          fail();  // An exception was expected.
+        }
+      } catch (IllegalStateException e) {
+        if (ordering == expanderOrder() || ordering == Order.STABLE_ORDER) {
+          fail();  // No exception was expected.
+        }
+      }
+    }
+  }
+
+  private NestedSetBuilder<String> prepareBuilder(String... directMembers) {
+    NestedSetBuilder<String> builder = new NestedSetBuilder<>(expanderOrder());
+    builder.addAll(Lists.newArrayList(directMembers));
+    return builder;
+  }
+
+  protected final void assertSetContents(Collection<String> expected, NestedSet<String> set) {
+    assertEquals(expected, Lists.newArrayList(set));
+    assertEquals(expected, Lists.newArrayList(set.toCollection()));
+    assertEquals(expected, Lists.newArrayList(set.toList()));
+    assertEquals(expected, Lists.newArrayList(set.toSet()));
+  }
+
+  protected final void assertCollectionsEqual(
+      Collection<String> expected, Collection<String> actual) {
+    assertEquals(Lists.newArrayList(expected), Lists.newArrayList(actual));
+  }
+
+  /**
+   * Returns the enumeration of the nested set {"c", "a", "b"} in the
+   * implementation's enumeration order.
+   *
+   * @see #testSimple()
+   * @see #testSimpleNoDuplicates()
+   */
+  protected List<String> simpleResult() {
+    return ImmutableList.of("c", "a", "b");
+  }
+
+  /**
+   * Returns the enumeration of the nested set {"b", "d", {"c", "a", "e"}} in
+   * the implementation's enumeration order.
+   *
+   * @see #testNesting()
+   */
+  protected abstract List<String> nestedResult();
+
+  /**
+   * Returns the enumeration of the nested set {"b", "d", "e", {"c", "a", "e"}} in
+   * the implementation's enumeration order.
+   *
+   * @see #testNestingNoDuplicates()
+   */
+  protected abstract List<String> nestedDuplicatesResult();
+
+  /**
+   * Returns the enumeration of nested set {"a", {"b", {"c"}}} in the
+   * implementation's enumeration order.
+   *
+   * @see #testChain()
+   */
+  protected abstract List<String> chainResult();
+
+  /**
+   * Returns the enumeration of the nested set {"a", {"b", D}, {"c", D}}, where
+   * D is {"d"}, in the implementation's enumeration order.
+   *
+   * @see #testDiamond()
+   */
+  protected abstract List<String> diamondResult();
+
+  /**
+   * Returns the enumeration of the nested set {"a", {"b", E, D}, {"c", D, E}}, where
+   * D is {"d"} and E is {"e"}, in the implementation's enumeration order.
+   *
+   * @see #testExtendedDiamond()
+   */
+  protected abstract List<String> extendedDiamondResult();
+
+  /**
+   * Returns the enumeration of the nested set {"a", {"b", E, D}, {"c", C2}}, where
+   * D is {"d"}, E is {"e"} and C2 is {"c2", D, E}, in the implementation's enumeration order.
+   *
+   * @see #testExtendedDiamondRightArm()
+   */
+  protected abstract List<String> extendedDiamondRightArmResult();
+
+  /**
+   * Returns the enumeration of the nested set {{"a", "b"}, {"b", "a"}}.
+   *
+   * @see #testOrderConflict()
+   * @see #testOrderConflictNested()
+   */
+  protected List<String> orderConflictResult() {
+    return ImmutableList.of("a", "b");
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/collect/nestedset/LinkOrderExpanderTest.java b/src/test/java/com/google/devtools/build/lib/collect/nestedset/LinkOrderExpanderTest.java
new file mode 100644
index 0000000..5d69882
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/collect/nestedset/LinkOrderExpanderTest.java
@@ -0,0 +1,69 @@
+// Copyright 2014 Google Inc. 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.collect.nestedset;
+
+import com.google.common.collect.ImmutableList;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.List;
+
+/**
+ * Tests for {@link LinkOrderExpander}.
+ */
+@RunWith(JUnit4.class)
+public class LinkOrderExpanderTest extends ExpanderTestBase {
+
+  @Override
+  protected Order expanderOrder() {
+    return Order.LINK_ORDER;
+  }
+
+  @Override
+  protected List<String> nestedResult() {
+    return ImmutableList.of("b", "d", "c", "a", "e");
+  }
+
+  @Override
+  protected List<String> nestedDuplicatesResult() {
+    return ImmutableList.of("b", "d", "c", "a", "e");
+  }
+
+  @Override
+  protected List<String> chainResult() {
+    return ImmutableList.of("a", "b", "c");
+  }
+
+  @Override
+  protected List<String> diamondResult() {
+    return ImmutableList.of("a", "b", "c", "d");
+  }
+
+  @Override
+  protected List<String> orderConflictResult() {
+    // Rightmost branch determines the order.
+    return ImmutableList.of("b", "a");
+  }
+
+  @Override
+  protected List<String> extendedDiamondResult() {
+    return ImmutableList.of("a", "b", "c", "e", "d");
+  }
+
+  @Override
+  protected List<String> extendedDiamondRightArmResult() {
+    return ImmutableList.of("a", "b", "c", "c2", "e", "d");
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/collect/nestedset/NaiveLinkOrderExpanderTest.java b/src/test/java/com/google/devtools/build/lib/collect/nestedset/NaiveLinkOrderExpanderTest.java
new file mode 100644
index 0000000..80faf7a
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/collect/nestedset/NaiveLinkOrderExpanderTest.java
@@ -0,0 +1,70 @@
+// Copyright 2014 Google Inc. 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.collect.nestedset;
+
+import com.google.common.collect.ImmutableList;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.List;
+
+/**
+ * Tests for {@link NaiveLinkOrderExpander}.
+ */
+@RunWith(JUnit4.class)
+public class NaiveLinkOrderExpanderTest extends ExpanderTestBase {
+
+  @Override
+  protected Order expanderOrder() {
+    return Order.NAIVE_LINK_ORDER;
+  }
+
+  @Override
+  protected List<String> nestedResult() {
+    return ImmutableList.of("b", "d", "c", "a", "e");
+  }
+
+  @Override
+  protected List<String> nestedDuplicatesResult() {
+    return ImmutableList.of("b", "d", "e", "c", "a");
+  }
+
+  @Override
+  protected List<String> chainResult() {
+    return ImmutableList.of("a", "b", "c");
+  }
+
+  @Override
+  protected List<String> diamondResult() {
+    // This case illustrates why this implementation is called "naive".
+    return ImmutableList.of("a", "b", "d", "c");
+  }
+
+  @Override
+  protected List<String> orderConflictResult() {
+    // Leftmost branch determines the order.
+    return ImmutableList.of("a", "b");
+  }
+
+  @Override
+  protected List<String> extendedDiamondResult() {
+    return ImmutableList.of("a", "b", "d", "e", "c");
+  }
+
+  @Override
+  protected List<String> extendedDiamondRightArmResult() {
+    return ImmutableList.of("a", "b", "d", "e", "c", "c2");
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/collect/nestedset/NestedSetImplTest.java b/src/test/java/com/google/devtools/build/lib/collect/nestedset/NestedSetImplTest.java
new file mode 100644
index 0000000..e5cfae3
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/collect/nestedset/NestedSetImplTest.java
@@ -0,0 +1,245 @@
+// Copyright 2014 Google Inc. 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.collect.nestedset;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
+import com.google.common.testing.EqualsTester;
+
+import junit.framework.TestCase;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.Arrays;
+
+/**
+ * Tests for {@link com.google.devtools.build.lib.collect.nestedset.NestedSet}.
+ */
+@RunWith(JUnit4.class)
+public class NestedSetImplTest extends TestCase {
+  @SafeVarargs
+  private static NestedSetBuilder<String> nestedSetBuilder(String... directMembers) {
+    NestedSetBuilder<String> builder = NestedSetBuilder.stableOrder();
+    builder.addAll(Lists.newArrayList(directMembers));
+    return builder;
+  }
+
+  @Test
+  public void simple() {
+    NestedSet<String> set = nestedSetBuilder("a").build();
+
+    assertTrue(Arrays.equals(new String[]{"a"}, set.directMembers()));
+    assertEquals(0, set.transitiveSets().length);
+    assertEquals(false, set.isEmpty());
+  }
+
+  @Test
+  public void flatToString() {
+    assertEquals("{}", nestedSetBuilder().build().toString());
+    assertEquals("{a}", nestedSetBuilder("a").build().toString());
+    assertEquals("{a, b}", nestedSetBuilder("a", "b").build().toString());
+  }
+
+  @Test
+  public void nestedToString() {
+    NestedSet<String> b = nestedSetBuilder("b").build();
+    NestedSet<String> c = nestedSetBuilder("c").build();
+
+    assertEquals("{a, {b}}",
+      nestedSetBuilder("a").addTransitive(b).build().toString());
+    assertEquals("{a, {b}, {c}}",
+      nestedSetBuilder("a").addTransitive(b).addTransitive(c).build().toString());
+
+    assertEquals("{b}", nestedSetBuilder().addTransitive(b).build().toString());
+  }
+
+  @Test
+  public void isEmpty() {
+    NestedSet<String> triviallyEmpty = nestedSetBuilder().build();
+    assertTrue(triviallyEmpty.isEmpty());
+
+    NestedSet<String> emptyLevel1 = nestedSetBuilder().addTransitive(triviallyEmpty).build();
+    assertTrue(emptyLevel1.isEmpty());
+
+    NestedSet<String> emptyLevel2 = nestedSetBuilder().addTransitive(emptyLevel1).build();
+    assertTrue(emptyLevel2.isEmpty());
+
+    NestedSet<String> triviallyNonEmpty = nestedSetBuilder("mango").build();
+    assertFalse(triviallyNonEmpty.isEmpty());
+
+    NestedSet<String> nonEmptyLevel1 = nestedSetBuilder().addTransitive(triviallyNonEmpty).build();
+    assertFalse(nonEmptyLevel1.isEmpty());
+
+    NestedSet<String> nonEmptyLevel2 = nestedSetBuilder().addTransitive(nonEmptyLevel1).build();
+    assertFalse(nonEmptyLevel2.isEmpty());
+  }
+
+  @Test
+  public void canIncludeAnyOrderInStableOrderAndViceVersa() {
+    NestedSetBuilder.stableOrder()
+        .addTransitive(NestedSetBuilder.compileOrder()
+            .addTransitive(NestedSetBuilder.stableOrder().build()).build())
+        .addTransitive(NestedSetBuilder.linkOrder()
+            .addTransitive(NestedSetBuilder.stableOrder().build()).build())
+        .addTransitive(NestedSetBuilder.naiveLinkOrder()
+            .addTransitive(NestedSetBuilder.stableOrder().build()).build()).build();
+    try {
+      NestedSetBuilder.compileOrder().addTransitive(NestedSetBuilder.linkOrder().build()).build();
+      fail("Shouldn't be able to include a non-stable order inside a different non-stable order!");
+    } catch (IllegalStateException e) {
+      // Expected.
+    }
+  }
+
+  /**
+   * A handy wrapper that allows us to use EqualsTester to test shallowEquals and shallowHashCode.
+   */
+  private static class SetWrapper<E> {
+    NestedSet<E> set;
+
+    SetWrapper(NestedSet<E> wrapped) {
+      set = wrapped;
+    }
+
+    @Override
+    public int hashCode() {
+      return set.shallowHashCode();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) {
+        return true;
+      }
+      if (!(o instanceof SetWrapper)) {
+        return false;
+      }
+      try {
+        @SuppressWarnings("unchecked")
+        SetWrapper<E> other = (SetWrapper<E>) o;
+        return set.shallowEquals(other.set);
+      } catch (ClassCastException e) {
+        return false;
+      }
+    }
+  }
+
+  @SafeVarargs
+  private static <E> SetWrapper<E> flat(E... directMembers) {
+    NestedSetBuilder<E> builder = NestedSetBuilder.stableOrder();
+    builder.addAll(Lists.newArrayList(directMembers));
+    return new SetWrapper<E>(builder.build());
+  }
+
+  // Same as flat(), but allows duplicate elements.
+  @SafeVarargs
+  private static <E> SetWrapper<E> flatWithDuplicates(E... directMembers) {
+    return new SetWrapper<E>(
+        NestedSetBuilder.wrap(Order.STABLE_ORDER, ImmutableList.copyOf(directMembers)));
+  }
+
+  @SafeVarargs
+  private static <E> SetWrapper<E> nest(SetWrapper<E>... nested) {
+    NestedSetBuilder<E> builder = NestedSetBuilder.stableOrder();
+    for (SetWrapper<E> wrap : nested) {
+      builder.addTransitive(wrap.set);
+    }
+    return new SetWrapper<E>(builder.build());
+  }
+
+  @SafeVarargs
+  // Restricted to <Integer> to avoid ambiguity with the other nest() function.
+  private static SetWrapper<Integer> nest(Integer elem, SetWrapper<Integer>... nested) {
+    NestedSetBuilder<Integer> builder = NestedSetBuilder.stableOrder();
+    builder.add(elem);
+    for (SetWrapper<Integer> wrap : nested) {
+      builder.addTransitive(wrap.set);
+    }
+    return new SetWrapper<Integer>(builder.build());
+  }
+
+  @Test
+  public void shallowEquality() {
+    // Used below to check that inner nested sets can be compared by reference equality.
+    SetWrapper<Integer> myRef = nest(nest(flat(7, 8)), flat(9));
+
+    // Each "equality group" contains elements that are equal to one another
+    // (according to equals() and hashCode()), yet distinct from all elements
+    // of all other equality groups.
+    new EqualsTester()
+      .addEqualityGroup(flat(),
+                        flat(),
+                        nest(flat()))  // Empty set elision.
+      .addEqualityGroup(NestedSetBuilder.<Integer>linkOrder().build())
+      .addEqualityGroup(flat(3),
+                        flat(3),
+                        flat(3, 3))  // Element de-duplication.
+      .addEqualityGroup(flatWithDuplicates(3, 3))
+      .addEqualityGroup(flat(4),
+                        nest(flat(4))) // Automatic elision of one-element nested sets.
+      .addEqualityGroup(NestedSetBuilder.<Integer>linkOrder().add(4).build())
+      .addEqualityGroup(nestedSetBuilder("4").build())  // Like flat("4").
+      .addEqualityGroup(flat(3, 4),
+                        flat(3, 4))
+      // Shallow equality means that {{3},{5}} != {{3},{5}}.
+      .addEqualityGroup(nest(flat(3), flat(5)))
+      .addEqualityGroup(nest(flat(3), flat(5)))
+      .addEqualityGroup(nest(myRef),
+                        nest(myRef),
+                        nest(myRef, myRef))  // Set de-duplication.
+      .addEqualityGroup(nest(3, myRef))
+      .addEqualityGroup(nest(4, myRef))
+      .testEquals();
+
+    // Some things that are not tested by the above:
+    //  - ordering among direct members
+    //  - ordering among transitive sets
+  }
+
+  /** Checks that the builder always return a nested set with the correct order. */
+  @Test
+  public void correctOrder() {
+    for (Order order : Order.values()) {
+      for (int numDirects = 0; numDirects < 3; numDirects++) {
+        for (int numTransitives = 0; numTransitives < 3; numTransitives++) {
+          assertEquals(order, createNestedSet(order, numDirects, numTransitives, order).getOrder());
+          // We allow mixing orders if one of them is stable. This tests that the top level order is
+          // the correct one.
+          assertEquals(order,
+              createNestedSet(order, numDirects, numTransitives, Order.STABLE_ORDER).getOrder());
+        }
+      }
+    }
+  }
+
+  private NestedSet<Integer> createNestedSet(Order order, int numDirects, int numTransitives,
+      Order transitiveOrder) {
+    NestedSetBuilder<Integer> builder = new NestedSetBuilder<>(order);
+
+    for (int direct = 0; direct < numDirects; direct++) {
+      builder.add(direct);
+    }
+    for (int transitive = 0; transitive < numTransitives; transitive++) {
+      builder.addTransitive(new NestedSetBuilder<Integer>(transitiveOrder).add(transitive).build());
+    }
+    return builder.build();
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/collect/nestedset/RecordingUniqueifierTest.java b/src/test/java/com/google/devtools/build/lib/collect/nestedset/RecordingUniqueifierTest.java
new file mode 100644
index 0000000..9764f4d
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/collect/nestedset/RecordingUniqueifierTest.java
@@ -0,0 +1,134 @@
+// Copyright 2014 Google Inc. 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.collect.nestedset;
+
+import static org.junit.Assert.assertEquals;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+
+import junit.framework.TestCase;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Random;
+
+/**
+ * Tests for {@link RecordingUniqueifier}.
+ */
+@RunWith(JUnit4.class)
+public class RecordingUniqueifierTest extends TestCase {
+
+  private static final Random RANDOM = new Random();
+  
+  private static final int VERY_SMALL = 3; // one byte
+  private static final int SMALL = 11;     // two bytes
+  private static final int MEDIUM = 18;    // three bytes -- unmemoed
+  // For this one, the "* 8" is a bytes to bits (1 memo is 1 bit)
+  private static final int LARGE = (RecordingUniqueifier.LENGTH_THRESHOLD * 8) + 3;
+
+  private static final int[] SIZES = new int[] {VERY_SMALL, SMALL, MEDIUM, LARGE};
+  
+  private void doTest(int uniqueInputs, int deterministicHeadSize) throws Exception {
+    Preconditions.checkArgument(deterministicHeadSize <= uniqueInputs,
+        "deterministicHeadSize must be smaller than uniqueInputs");
+
+      // Setup
+
+      List<Integer> inputList = new ArrayList<>(uniqueInputs);
+      Collection<Integer> inputsDeduped = new LinkedHashSet<>(uniqueInputs);
+
+      for (int i = 0; i < deterministicHeadSize; i++) { // deterministic head
+        inputList.add(i);
+        inputsDeduped.add(i);
+      }
+
+      while (inputsDeduped.size() < uniqueInputs) { // random selectees
+        Integer i = RANDOM.nextInt(uniqueInputs);
+        inputList.add(i);
+        inputsDeduped.add(i);
+      }
+
+      // Unmemoed run
+
+      List<Integer> firstList = new ArrayList<>(uniqueInputs);
+      RecordingUniqueifier recordingUniqueifier = new RecordingUniqueifier();
+      for (Integer i : inputList) {
+        if (recordingUniqueifier.isUnique(i)) {
+          firstList.add(i);
+        }
+      }
+
+      // Potentially memo'ed run
+
+      List<Integer> secondList = new ArrayList<>(uniqueInputs);
+      Object memo = recordingUniqueifier.getMemo();
+      Uniqueifier uniqueifier = RecordingUniqueifier.createReplayUniqueifier(memo);
+      for (Integer i : inputList) {
+        if (uniqueifier.isUnique(i)) {
+          secondList.add(i);
+        }
+      }
+
+      // Evaluate results
+
+      inputsDeduped = ImmutableList.copyOf(inputsDeduped);
+      assertEquals("Unmemo'ed run has unexpected contents", inputsDeduped, firstList);
+      assertEquals("Memo'ed run has unexpected contents", inputsDeduped, secondList);
+  }
+
+  private void doTestWithLucidException(int uniqueInputs, int deterministicHeadSize)
+      throws Exception {
+    try {
+      doTest(uniqueInputs, deterministicHeadSize);
+    } catch (Exception e) {
+      throw new Exception("Failure in size: " + uniqueInputs, e);
+    }
+  }
+
+  @Test
+  public void noInputs() throws Exception {
+    doTestWithLucidException(0, 0);
+  }
+  
+  @Test
+  public void allUnique() throws Exception {
+    for (int size : SIZES) {
+      doTestWithLucidException(size, size);
+    }
+  }
+
+  @Test
+  public void fuzzedWithDeterministic2() throws Exception {
+    // The way that it is used, we know that the first two additions are not equal.
+    // Optimizations were made for this case in small memos.
+    for (int size : SIZES) {
+      doTestWithLucidException(size, 2);
+    }
+  }
+
+  @Test
+  public void fuzzedWithDeterministic2_otherSizes() throws Exception {
+    for (int i = 0; i < 100; i++) {
+      int size = RANDOM.nextInt(10000) + 2;
+      doTestWithLucidException(size, 2);
+    }
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/concurrent/AbstractQueueVisitorTest.java b/src/test/java/com/google/devtools/build/lib/concurrent/AbstractQueueVisitorTest.java
new file mode 100644
index 0000000..8a6485c
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/concurrent/AbstractQueueVisitorTest.java
@@ -0,0 +1,493 @@
+// Copyright 2014 Google Inc. 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.concurrent;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
+import com.google.common.util.concurrent.Uninterruptibles;
+import com.google.devtools.build.lib.testutil.TestThread;
+import com.google.devtools.build.lib.testutil.TestUtils;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicLong;
+
+/**
+ * Tests for AbstractQueueVisitor.
+ */
+@RunWith(JUnit4.class)
+public class AbstractQueueVisitorTest {
+
+  private static final RuntimeException THROWABLE = new RuntimeException();
+
+  @Test
+  public void simpleCounter() throws Exception {
+    CountingQueueVisitor counter = new CountingQueueVisitor();
+    counter.enqueue();
+    counter.work(false);
+    assertSame(10, counter.getCount());
+  }
+
+  @Test
+  public void callerOwnedPool() throws Exception {
+    ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 5, 0, TimeUnit.SECONDS,
+                                                         new LinkedBlockingQueue<Runnable>());
+    assertSame(0, executor.getActiveCount());
+
+    CountingQueueVisitor counter = new CountingQueueVisitor(executor);
+    counter.enqueue();
+    counter.work(false);
+    assertSame(10, counter.getCount());
+
+    executor.shutdown();
+    assertTrue(executor.awaitTermination(TestUtils.WAIT_TIMEOUT_SECONDS, TimeUnit.SECONDS));
+  }
+
+  @Test
+  public void doubleCounter() throws Exception {
+    CountingQueueVisitor counter = new CountingQueueVisitor();
+    counter.enqueue();
+    counter.enqueue();
+    counter.work(false);
+    assertSame(10, counter.getCount());
+  }
+
+  @Test
+  public void exceptionFromWorkerThread() {
+    final RuntimeException myException = new IllegalStateException();
+    ConcreteQueueVisitor visitor = new ConcreteQueueVisitor();
+    visitor.enqueue(new Runnable() {
+      @Override
+      public void run() {
+        throw myException;
+      }
+    });
+
+    try {
+      // The exception from the worker thread should be
+      // re-thrown from the main thread.
+      visitor.work(false);
+      fail();
+    } catch (Exception e) {
+      assertSame(myException, e);
+    }
+  }
+
+  // Regression test for "AbstractQueueVisitor loses track of jobs if thread allocation fails".
+  @Test
+  public void threadPoolThrowsSometimes() throws Exception {
+    // In certain cases (for example, if the address space is almost entirely consumed by a huge
+    // JVM heap), thread allocation can fail with an OutOfMemoryError. If the queue visitor
+    // does not handle this gracefully, we lose track of tasks and hang the visitor indefinitely.
+
+    ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 3, 0, TimeUnit.SECONDS,
+        new LinkedBlockingQueue<Runnable>()) {
+      private final AtomicLong count = new AtomicLong();
+
+      @Override
+      public void execute(Runnable command) {
+        long count = this.count.incrementAndGet();
+        if (count == 6) {
+          throw new Error("Could not create thread (fakeout)");
+        }
+        super.execute(command);
+      }
+    };
+
+    CountingQueueVisitor counter = new CountingQueueVisitor(executor);
+    counter.enqueue();
+    try {
+      counter.work(false);
+      fail();
+    } catch (Error expected) {
+      assertEquals("Could not create thread (fakeout)", expected.getMessage());
+    }
+    assertSame(5, counter.getCount());
+
+    executor.shutdown();
+    assertTrue(executor.awaitTermination(10, TimeUnit.SECONDS));
+  }
+
+  // Regression test to make sure that AbstractQueueVisitor doesn't swallow unchecked exceptions if
+  // it is interrupted concurrently with the unchecked exception being thrown.
+  @Test
+  public void interruptAndThrownIsInterruptedAndThrown() throws Exception {
+    final ConcreteQueueVisitor visitor = new ConcreteQueueVisitor();
+    // Use a latch to make sure the thread gets a chance to start.
+    final CountDownLatch threadStarted = new CountDownLatch(1);
+    visitor.enqueue(new Runnable() {
+      @Override
+      public void run() {
+        threadStarted.countDown();
+        assertTrue(Uninterruptibles.awaitUninterruptibly(
+            visitor.getInterruptionLatchForTestingOnly(), 2, TimeUnit.SECONDS));
+        throw THROWABLE;
+      }
+    });
+    assertTrue(threadStarted.await(TestUtils.WAIT_TIMEOUT_SECONDS, TimeUnit.SECONDS));
+    // Interrupt will not be processed until work starts.
+    Thread.currentThread().interrupt();
+    try {
+      visitor.work(/*interruptWorkers=*/true);
+      fail();
+    } catch (Exception e) {
+      assertEquals(THROWABLE, e);
+      assertTrue(Thread.interrupted());
+    }
+  }
+
+  @Test
+  public void interruptionWithoutInterruptingWorkers() throws Exception {
+    final Thread mainThread = Thread.currentThread();
+    final CountDownLatch latch1 = new CountDownLatch(1);
+    final CountDownLatch latch2 = new CountDownLatch(1);
+    final boolean[] workerThreadCompleted = { false };
+    final ConcreteQueueVisitor visitor = new ConcreteQueueVisitor();
+
+    visitor.enqueue(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          latch1.countDown();
+          latch2.await();
+          workerThreadCompleted[0] = true;
+        } catch (InterruptedException e) {
+          // Do not set workerThreadCompleted to true
+        }
+      }
+    });
+
+    TestThread interrupterThread = new TestThread() {
+      @Override
+      public void runTest() throws Exception {
+        latch1.await();
+        mainThread.interrupt();
+        assertTrue(visitor.awaitInterruptionForTestingOnly(TestUtils.WAIT_TIMEOUT_MILLISECONDS,
+            TimeUnit.MILLISECONDS));
+        latch2.countDown();
+      }
+    };
+
+    interrupterThread.start();
+
+    try {
+      visitor.work(false);
+      fail();
+    } catch (InterruptedException e) {
+      // Expected.
+    }
+
+    interrupterThread.joinAndAssertState(400);
+    assertTrue(workerThreadCompleted[0]);
+  }
+
+  @Test
+  public void interruptionWithInterruptingWorkers() throws Exception {
+    assertInterruptWorkers(null);
+
+    ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 3, 0, TimeUnit.SECONDS,
+                                                         new LinkedBlockingQueue<Runnable>());
+    assertInterruptWorkers(executor);
+    executor.shutdown();
+    executor.awaitTermination(TestUtils.WAIT_TIMEOUT_SECONDS, TimeUnit.SECONDS);
+  }
+
+  private void assertInterruptWorkers(ThreadPoolExecutor executor) throws Exception {
+    final CountDownLatch latch1 = new CountDownLatch(1);
+    final CountDownLatch latch2 = new CountDownLatch(1);
+    final boolean[] workerThreadInterrupted = { false };
+    ConcreteQueueVisitor visitor = (executor == null)
+        ? new ConcreteQueueVisitor()
+        : new ConcreteQueueVisitor(executor, true);
+
+    visitor.enqueue(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          latch1.countDown();
+          latch2.await();
+        } catch (InterruptedException e) {
+          workerThreadInterrupted[0] = true;
+        }
+      }
+    });
+
+    latch1.await();
+    Thread.currentThread().interrupt();
+
+    try {
+      visitor.work(true);
+      fail();
+    } catch (InterruptedException e) {
+      // Expected.
+    }
+
+    assertTrue(workerThreadInterrupted[0]);
+  }
+
+  @Test
+  public void failFast() throws Exception {
+    // In failFast mode, we only run actions queued before the exception.
+    assertFailFast(null, true, false, false, "a", "b");
+
+    // In !failFast mode, we complete all queued actions.
+    assertFailFast(null, false, false, false, "a", "b", "1", "2");
+
+    // Now check fail-fast on interrupt:
+    assertFailFast(null, false, true, true, "a", "b");
+    assertFailFast(null, false, false, true, "a", "b", "1", "2");
+  }
+
+  @Test
+  public void failFastNoShutdown() throws Exception {
+    ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 5, 0, TimeUnit.SECONDS,
+                                                         new LinkedBlockingQueue<Runnable>());
+    // In failFast mode, we only run actions queued before the exception.
+    assertFailFast(executor, true, false, false, "a", "b");
+
+    // In !failFast mode, we complete all queued actions.
+    assertFailFast(executor, false, false, false, "a", "b", "1", "2");
+
+    // Now check fail-fast on interrupt:
+    assertFailFast(executor, false, true, true, "a", "b");
+    assertFailFast(executor, false, false, true, "a", "b", "1", "2");
+
+    executor.shutdown();
+    assertTrue(executor.awaitTermination(TestUtils.WAIT_TIMEOUT_SECONDS, TimeUnit.SECONDS));
+  }
+
+  private void assertFailFast(ThreadPoolExecutor executor,
+                              boolean failFastOnException, boolean failFastOnInterrupt,
+                              boolean interrupt, String... expectedVisited) throws Exception {
+    assertTrue(executor == null || !executor.isShutdown());
+    AbstractQueueVisitor visitor = (executor == null)
+        ? new ConcreteQueueVisitor(failFastOnException, failFastOnInterrupt)
+        : new ConcreteQueueVisitor(executor, failFastOnException, failFastOnInterrupt);
+
+    List<String> visitedList = Collections.synchronizedList(Lists.<String>newArrayList());
+
+    // Runnable "ra" will await the uncaught exception from
+    // "throwingRunnable", then add "a" to the list and
+    // enqueue "r1". Runnable "r1" should be
+    // executed iff !failFast.
+
+    CountDownLatch latchA = new CountDownLatch(1);
+    CountDownLatch latchB = new CountDownLatch(1);
+
+    Runnable r1 = awaitAddAndEnqueueRunnable(interrupt, visitor, null, visitedList, "1", null);
+    Runnable r2 = awaitAddAndEnqueueRunnable(interrupt, visitor, null, visitedList, "2", null);
+    Runnable ra = awaitAddAndEnqueueRunnable(interrupt, visitor, latchA, visitedList, "a", r1);
+    Runnable rb = awaitAddAndEnqueueRunnable(interrupt, visitor, latchB, visitedList, "b", r2);
+
+    visitor.enqueue(ra);
+    visitor.enqueue(rb);
+    latchA.await();
+    latchB.await();
+    visitor.enqueue(interrupt ? interruptingRunnable(Thread.currentThread()) : throwingRunnable());
+
+    try {
+      visitor.work(false);
+      fail();
+    } catch (Exception e) {
+      if (interrupt) {
+        assertTrue(e instanceof InterruptedException);
+      } else {
+        assertSame(THROWABLE, e);
+      }
+    }
+    assertTrue(
+        "got: " + visitedList + "\nwant: " + Arrays.toString(expectedVisited),
+        Sets.newHashSet(visitedList).equals(Sets.newHashSet(expectedVisited)));
+
+    if (executor != null) {
+      assertFalse(executor.isShutdown());
+      assertEquals(0, visitor.getTaskCount());
+    }
+  }
+
+  @Test
+  public void jobIsInterruptedWhenOtherFails() throws Exception {
+    ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 3, 0, TimeUnit.SECONDS,
+        new LinkedBlockingQueue<Runnable>());
+
+    final QueueVisitorWithCriticalError visitor = new QueueVisitorWithCriticalError(executor);
+    final CountDownLatch latch1 = new CountDownLatch(1);
+    final AtomicBoolean wasInterrupted = new AtomicBoolean(false);
+
+    Runnable r1 = new Runnable() {
+
+      @Override
+      public void run() {
+        latch1.countDown();
+        try {
+          // Interruption is expected during a sleep. There is no sense in fail or assert call
+          // because exception is going to be swallowed inside AbstractQueueVisitior.
+          // We are using wasInterrupted flag to assert in the end of test.
+          Thread.sleep(1000);
+        } catch (InterruptedException e) {
+          wasInterrupted.set(true);
+        }
+      }
+    };
+
+    visitor.enqueue(r1);
+    latch1.await();
+    visitor.enqueue(throwingRunnable());
+
+    try {
+      visitor.work(true);
+      fail();
+    } catch (Exception e) {
+      assertSame(THROWABLE, e);
+    }
+
+    assertTrue(wasInterrupted.get());
+    assertTrue(executor.isShutdown());
+  }
+
+  private Runnable throwingRunnable() {
+    return new Runnable() {
+      @Override
+      public void run() {
+        throw THROWABLE;
+      }
+    };
+  }
+
+  private Runnable interruptingRunnable(final Thread thread) {
+    return new Runnable() {
+      @Override
+      public void run() {
+        thread.interrupt();
+      }
+    };
+  }
+
+  private static Runnable awaitAddAndEnqueueRunnable(final boolean interrupt,
+                                                     final AbstractQueueVisitor visitor,
+                                                     final CountDownLatch started,
+                                                     final List<String> list,
+                                                     final String toAdd,
+                                                     final Runnable toEnqueue) {
+    return new Runnable() {
+      @Override
+      public void run() {
+        if (started != null) {
+          started.countDown();
+        }
+
+        try {
+          assertTrue(interrupt
+                     ? visitor.awaitInterruptionForTestingOnly(1, TimeUnit.MINUTES)
+                     : visitor.getExceptionLatchForTestingOnly().await(1, TimeUnit.MINUTES));
+        } catch (InterruptedException e) {
+          // Unexpected.
+          throw new RuntimeException(e);
+        }
+        list.add(toAdd);
+        if (toEnqueue != null) {
+          visitor.enqueue(toEnqueue);
+        }
+      }
+    };
+  }
+
+  private static class CountingQueueVisitor extends AbstractQueueVisitor {
+
+    private final static String THREAD_NAME = "BlazeTest CountingQueueVisitor";
+
+    private int theInt = 0;
+    private final Object lock = new Object();
+
+    public CountingQueueVisitor() {
+      super(5, 5, 3L, TimeUnit.SECONDS, THREAD_NAME);
+    }
+
+    public CountingQueueVisitor(ThreadPoolExecutor executor) {
+      super(executor, false, true, true);
+    }
+
+    public void enqueue() {
+      super.enqueue(new Runnable() {
+        @Override
+        public void run() {
+          synchronized (lock) {
+            if (theInt < 10) {
+              theInt++;
+              enqueue();
+            }
+          }
+        }
+      });
+    }
+
+    public int getCount() {
+      return theInt;
+    }
+  }
+
+  private static class ConcreteQueueVisitor extends AbstractQueueVisitor {
+
+    private final static String THREAD_NAME = "BlazeTest ConcreteQueueVisitor";
+
+    public ConcreteQueueVisitor() {
+      super(5, 5, 3L, TimeUnit.SECONDS, THREAD_NAME);
+    }
+
+    public ConcreteQueueVisitor(boolean failFast) {
+      super(true, 5, 5, 3L, TimeUnit.SECONDS, failFast, THREAD_NAME);
+    }
+
+    public ConcreteQueueVisitor(boolean failFast, boolean failFastOnInterrupt) {
+      super(true, 5, 5, 3L, TimeUnit.SECONDS, failFast, failFastOnInterrupt, THREAD_NAME);
+    }
+
+    public ConcreteQueueVisitor(ThreadPoolExecutor executor, boolean failFast,
+        boolean failFastOnInterrupt) {
+      super(executor, /*shutdownOnCompletion=*/false, failFast, failFastOnInterrupt);
+    }
+
+    public ConcreteQueueVisitor(ThreadPoolExecutor executor, boolean failFast) {
+      super(executor, /*shutdownOnCompletion=*/false, failFast, true);
+    }
+  }
+
+  private static class QueueVisitorWithCriticalError extends AbstractQueueVisitor {
+
+    public QueueVisitorWithCriticalError(ThreadPoolExecutor executor) {
+      super(executor, false);
+    }
+
+    @Override
+    protected boolean isCriticalError(Throwable e) {
+      return true;
+    }
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/concurrent/MoreFuturesTest.java b/src/test/java/com/google/devtools/build/lib/concurrent/MoreFuturesTest.java
new file mode 100644
index 0000000..60f29ac
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/concurrent/MoreFuturesTest.java
@@ -0,0 +1,151 @@
+// Copyright 2014 Google Inc. 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.concurrent;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.util.concurrent.AbstractFuture;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
+import com.google.devtools.build.lib.testutil.TestUtils;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Tests for MoreFutures
+ */
+@RunWith(JUnit4.class)
+public class MoreFuturesTest {
+
+  private ExecutorService executorService;
+
+  @Before
+  public void setUp() throws Exception {
+    executorService = Executors.newFixedThreadPool(5);
+  }
+
+  @After
+  public void tearDown() throws Exception {
+    MoreExecutors.shutdownAndAwaitTermination(executorService, TestUtils.WAIT_TIMEOUT_SECONDS,
+        TimeUnit.SECONDS);
+
+  }
+
+  /** Test the normal path where everything is successful. */
+  @Test
+  public void allAsListOrCancelAllHappy() throws ExecutionException, InterruptedException {
+    final List<DelayedFuture> futureList = new ArrayList<>();
+    for (int i = 0; i < 5; i++) {
+      DelayedFuture future = new DelayedFuture(i);
+      executorService.execute(future);
+      futureList.add(future);
+    }
+    ListenableFuture<List<Object>> list = MoreFutures.allAsListOrCancelAll(futureList);
+    List<Object> result = list.get();
+    assertEquals(futureList.size(), result.size());
+    for (DelayedFuture delayedFuture : futureList) {
+      assertFalse(delayedFuture.wasCanceled);
+      assertFalse(delayedFuture.wasInterrupted);
+      assertNotNull(delayedFuture.get());
+      assertTrue(result.contains(delayedFuture.get()));
+    }
+  }
+
+  /** Test that if any of the futures in the list fails, we cancel all the futures immediately. */
+  @Test
+  public void allAsListOrCancelAllCancellation() throws InterruptedException {
+    final List<DelayedFuture> futureList = new ArrayList<>();
+    for (int i = 1; i < 6; i++) {
+      DelayedFuture future = new DelayedFuture(i * 1000);
+      executorService.execute(future);
+      futureList.add(future);
+    }
+    DelayedFuture toFail = new DelayedFuture(1000);
+    futureList.add(toFail);
+    toFail.makeItFail();
+    ListenableFuture<List<Object>> list = MoreFutures.allAsListOrCancelAll(futureList);
+
+    try {
+      list.get();
+      fail("This should fail");
+    } catch (InterruptedException | ExecutionException ignored) {
+    }
+    Thread.sleep(100);
+    for (DelayedFuture delayedFuture : futureList) {
+      assertTrue(delayedFuture.wasCanceled || delayedFuture == toFail);
+      assertFalse(delayedFuture.wasInterrupted);
+    }
+  }
+
+  /**
+   * A future that (if added to an executor) waits {@code delay} milliseconds before setting a
+   * response.
+   */
+  private static class DelayedFuture extends AbstractFuture<Object> implements Runnable {
+
+    private final int delay;
+    private final CountDownLatch latch = new CountDownLatch(1);
+    private boolean wasCanceled;
+    private boolean wasInterrupted;
+
+    public DelayedFuture(int delay) {
+      this.delay = delay;
+    }
+
+    @Override
+    public void run() {
+      try {
+        wasCanceled = latch.await(delay, TimeUnit.MILLISECONDS);
+        // Not canceled and not done (makeItFail sets the value, so in that case is done).
+        if (!wasCanceled && !isDone()) {
+          set(new Object());
+        }
+      } catch (InterruptedException e) {
+        wasInterrupted = true;
+      }
+    }
+
+    public void makeItFail() {
+      setException(new RuntimeException("I like to fail!!"));
+      latch.countDown();
+    }
+
+    @Override
+    public boolean cancel(boolean mayInterruptIfRunning) {
+      return super.cancel(mayInterruptIfRunning);
+    }
+
+    @Override
+    protected void interruptTask() {
+      latch.countDown();
+    }
+  }
+
+}
diff --git a/src/test/java/com/google/devtools/build/lib/concurrent/ThreadSafetyTest.java b/src/test/java/com/google/devtools/build/lib/concurrent/ThreadSafetyTest.java
new file mode 100644
index 0000000..8532bae
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/concurrent/ThreadSafetyTest.java
@@ -0,0 +1,313 @@
+// Copyright 2014 Google Inc. 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.concurrent;
+
+import com.google.devtools.build.lib.concurrent.ThreadSafety.ConditionallyThreadCompatible;
+import com.google.devtools.build.lib.concurrent.ThreadSafety.ConditionallyThreadSafe;
+import com.google.devtools.build.lib.concurrent.ThreadSafety.Immutable;
+import com.google.devtools.build.lib.concurrent.ThreadSafety.ThreadCompatible;
+import com.google.devtools.build.lib.concurrent.ThreadSafety.ThreadHostile;
+import com.google.devtools.build.lib.concurrent.ThreadSafety.ThreadSafe;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.Random;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * This file just contains some examples of the use of
+ * annotations for different categories of thread safety:
+ *   ThreadSafe
+ *   ThreadCompatible
+ *   ThreadHostile
+ *   Immutable ThreadSafe
+ *   Immutable ThreadHostile
+ *
+ * It doesn't really test much -- just that this code
+ * using those annotations compiles and runs.
+ *
+ * The main class here is annotated as being both ConditionallyThreadSafe
+ * and ConditionallyThreadCompatible, and accordingly we document here the
+ * conditions under which it is thread-safe and thread-compatible:
+ *    - it is thread-safe if you only use the testThreadSafety() method,
+ *      the ThreadSafeCounter class, and/or ImmutableThreadSafeCounter class;
+ *    - it is thread-compatible if you use only those and/or the
+ *      ThreadCompatibleCounter and/or ImmutableThreadCompatibleCounter class;
+ *    - it is thread-hostile otherwise.
+ */
+@ConditionallyThreadSafe @ConditionallyThreadCompatible
+@RunWith(JUnit4.class)
+public class ThreadSafetyTest {
+
+  @ThreadSafe
+  public static final class ThreadSafeCounter {
+
+    // A ThreadSafe class can have public mutable fields,
+    // provided they are atomic or volatile.
+
+    public volatile boolean myBool;
+    public AtomicInteger myInt;
+
+    // A ThreadSafe class can have private mutable fields,
+    // provided that access to them is synchronized.
+    private int value;
+    public ThreadSafeCounter(int value) {
+      synchronized (this) { // is this needed?
+        this.value = value;
+      }
+    }
+    public synchronized int getValue() {
+      return value;
+    }
+    public synchronized void increment() {
+      value++;
+    }
+
+    // A ThreadSafe class can have private mutable members
+    // provided that the methods of the class synchronize access
+    // to them.
+    // These members could be static...
+    private static int numFoos = 0;
+    public static synchronized void foo() {
+      numFoos++;
+    }
+    public static synchronized int getNumFoos() {
+      return numFoos;
+    }
+    // ... or non-static.
+    private int numBars = 0;
+    public synchronized void bar() {
+      numBars++;
+    }
+    public synchronized int getNumBars() {
+      return numBars;
+    }
+  }
+
+  @ThreadCompatible
+  public static final class ThreadCompatibleCounter {
+
+    // A ThreadCompatible class can have public mutable fields.
+    public int value;
+    public ThreadCompatibleCounter(int value) {
+      this.value = value;
+    }
+    public int getValue() {
+      return value;
+    }
+    public void increment() {
+      value++;
+    }
+
+    // A ThreadCompatible class can have mutable static members
+    // provided that the methods of the class synchronize access
+    // to them.
+    private static int numFoos = 0;
+    public static synchronized void foo() {
+      numFoos++;
+    }
+    public static synchronized int getNumFoos() {
+      return numFoos;
+    }
+  }
+
+  @ThreadHostile
+  public static final class ThreadHostileCounter {
+
+    // A ThreadHostile class can have public mutable fields.
+    public int value;
+    public ThreadHostileCounter(int value) {
+      this.value = value;
+    }
+    public int getValue() {
+      return value;
+    }
+    public void increment() {
+      value++;
+    }
+
+    // A ThreadHostile class can perform unsynchronized access
+    // to mutable static data.
+    private static int numFoos = 0;
+    public static void foo() {
+      numFoos++;
+    }
+    public static int getNumFoos() {
+      return numFoos;
+    }
+  }
+
+  @Immutable @ThreadSafe
+  public static final class ImmutableThreadSafeCounter {
+
+    // An Immutable ThreadSafe class can have public fields,
+    // provided they are final and immutable.
+    public final int value;
+    public ImmutableThreadSafeCounter(int value) {
+      this.value = value;
+    }
+    public int getValue() {
+      return value;
+    }
+    public ImmutableThreadSafeCounter increment() {
+      return new ImmutableThreadSafeCounter(value + 1);
+    }
+
+    // An Immutable ThreadSafe class can have immutable static members.
+    public static final int NUM_STATIC_CACHE_ENTRIES = 3;
+    private static final ImmutableThreadSafeCounter[] staticCache =
+        new ImmutableThreadSafeCounter[] {
+          new ImmutableThreadSafeCounter(0),
+          new ImmutableThreadSafeCounter(1),
+          new ImmutableThreadSafeCounter(2)
+        };
+    public static ImmutableThreadSafeCounter makeUsingStaticCache(int value) {
+      if (value < NUM_STATIC_CACHE_ENTRIES) {
+        return staticCache[value];
+      } else {
+        return new ImmutableThreadSafeCounter(value);
+      }
+    }
+
+    // An Immutable ThreadSafe class can have private mutable members
+    // provided that the methods of the class synchronize access
+    // to them.
+    // These members could be static...
+    private static int cachedValue = 0;
+    private static ImmutableThreadSafeCounter cachedCounter =
+        new ImmutableThreadSafeCounter(0);
+    public static synchronized ImmutableThreadSafeCounter
+        makeUsingDynamicCache(int value) {
+      if (value != cachedValue) {
+        cachedValue = value;
+        cachedCounter = new ImmutableThreadSafeCounter(value);
+      }
+      return cachedCounter;
+    }
+    // ... or non-static.
+    private ImmutableThreadSafeCounter incrementCache = null;
+    public synchronized ImmutableThreadSafeCounter incrementUsingCache() {
+      if (incrementCache == null) {
+        incrementCache = new ImmutableThreadSafeCounter(value + 1);
+      }
+      return incrementCache;
+    }
+    // Methods of an Immutable class need not be deterministic.
+    private static Random random = new Random();
+    public int choose() {
+      return random.nextInt(value);
+    }
+  }
+
+  @Immutable @ThreadHostile
+  public static final class ImmutableThreadHostileCounter {
+
+    // An Immutable ThreadHostile class can have public fields,
+    // provided they are final and immutable.
+    public final int value;
+    public ImmutableThreadHostileCounter(int value) {
+      this.value = value;
+    }
+    public int getValue() {
+      return value;
+    }
+    public ImmutableThreadHostileCounter increment() {
+      return new ImmutableThreadHostileCounter(value + 1);
+    }
+
+    // An Immutable ThreadHostile class can have private mutable members,
+    // and doesn't need to synchronize access to them.
+    // These members could be static...
+    private static int cachedValue = 0;
+    private static ImmutableThreadHostileCounter cachedCounter =
+        new ImmutableThreadHostileCounter(0);
+    public static ImmutableThreadHostileCounter
+        makeUsingDynamicCache(int value) {
+      if (value != cachedValue) {
+        cachedValue = value;
+        cachedCounter = new ImmutableThreadHostileCounter(value);
+      }
+      return cachedCounter;
+    }
+    // ... or non-static.
+    private ImmutableThreadHostileCounter incrementCache = null;
+    public ImmutableThreadHostileCounter incrementUsingCache() {
+      if (incrementCache == null) {
+        incrementCache = new ImmutableThreadHostileCounter(value + 1);
+      }
+      return incrementCache;
+    }
+  }
+
+  @Test
+  public void threadSafety() throws InterruptedException {
+    final ThreadSafeCounter threadSafeCounterArray[] =
+        new ThreadSafeCounter[] {
+          new ThreadSafeCounter(1),
+          new ThreadSafeCounter(2),
+          new ThreadSafeCounter(3)
+        };
+    final ThreadCompatibleCounter threadCompatibleCounterArray[] =
+        new ThreadCompatibleCounter[] {
+          new ThreadCompatibleCounter(1),
+          new ThreadCompatibleCounter(2),
+          new ThreadCompatibleCounter(3)
+        };
+    final ThreadHostileCounter threadHostileCounter =
+        new ThreadHostileCounter(1);
+
+    class MyThread implements Runnable {
+
+      ThreadCompatibleCounter threadCompatibleCounter =
+          new ThreadCompatibleCounter(1);
+
+      @Override
+      public void run() {
+
+        // ThreadSafe objects can be accessed with without synchronization
+        for (ThreadSafeCounter counter : threadSafeCounterArray) {
+          counter.increment();
+        }
+
+        // ThreadCompatible objects can be accessed with without
+        // synchronization if they are thread-local
+        threadCompatibleCounter.increment();
+
+        // Access to ThreadCompatible objects must be synchronized
+        // if they could be concurrently accessed by other threads
+        for (ThreadCompatibleCounter counter : threadCompatibleCounterArray) {
+          synchronized (counter) {
+            counter.increment();
+          }
+        }
+
+        // Access to ThreadHostile objects must be synchronized.
+        synchronized (this.getClass()) {
+          threadHostileCounter.increment();
+        }
+
+      }
+    }
+
+    Thread thread1 = new Thread(new MyThread());
+    Thread thread2 = new Thread(new MyThread());
+    thread1.start();
+    thread2.start();
+    thread1.join();
+    thread2.join();
+  }
+
+}
diff --git a/src/test/java/com/google/devtools/build/lib/events/AbstractEventHandlerTest.java b/src/test/java/com/google/devtools/build/lib/events/AbstractEventHandlerTest.java
new file mode 100644
index 0000000..7033f17
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/events/AbstractEventHandlerTest.java
@@ -0,0 +1,47 @@
+// Copyright 2014 Google Inc. 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.events;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.Set;
+
+/**
+ * Tests {@link AbstractEventHandler}.
+ */
+@RunWith(JUnit4.class)
+public class AbstractEventHandlerTest {
+
+  private static AbstractEventHandler create(Set<EventKind> mask) {
+    return new AbstractEventHandler(mask) {
+        @Override
+        public void handle(Event event) {}
+      };
+  }
+
+  @Test
+  public void retainsEventMask() {
+    assertEquals(EventKind.ALL_EVENTS,
+                 create(EventKind.ALL_EVENTS).getEventMask());
+    assertEquals(EventKind.ERRORS_AND_WARNINGS,
+                 create(EventKind.ERRORS_AND_WARNINGS).getEventMask());
+    assertEquals(EventKind.ERRORS,
+                 create(EventKind.ERRORS).getEventMask());
+  }
+
+}
diff --git a/src/test/java/com/google/devtools/build/lib/events/EventCollectorTest.java b/src/test/java/com/google/devtools/build/lib/events/EventCollectorTest.java
new file mode 100644
index 0000000..332afac
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/events/EventCollectorTest.java
@@ -0,0 +1,67 @@
+// Copyright 2014 Google Inc. 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.events;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertSame;
+
+import com.google.devtools.build.lib.events.Event;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+
+/**
+ * Tests the {@link EventCollector} class.
+ */
+@RunWith(JUnit4.class)
+public class EventCollectorTest extends EventTestTemplate {
+
+  @Test
+  public void usesPassedInCollection() {
+    Collection<Event> events = new ArrayList<>();
+    EventCollector collector =
+        new EventCollector(EventKind.ERRORS_AND_WARNINGS, events);
+    collector.handle(event);
+    Event onlyEvent = events.iterator().next();
+    assertEquals(event.getMessage(), onlyEvent.getMessage());
+    assertSame(location, onlyEvent.getLocation());
+    assertEquals(event.getKind(), onlyEvent.getKind());
+    assertEquals(event.getLocation().getStartOffset(),
+        onlyEvent.getLocation().getStartOffset());
+    assertEquals(collector.count(), 1);
+    assertEquals(events.size(), 1);
+  }
+
+  @Test
+  public void collectsEvents() {
+    EventCollector collector =
+        new EventCollector(EventKind.ERRORS_AND_WARNINGS);
+    collector.handle(event);
+    Iterator<Event> collectedEventIt = collector.iterator();
+    Event onlyEvent = collectedEventIt.next();
+    assertEquals(event.getMessage(), onlyEvent.getMessage());
+    assertSame(location, onlyEvent.getLocation());
+    assertEquals(event.getKind(), onlyEvent.getKind());
+    assertEquals(event.getLocation().getStartOffset(),
+        onlyEvent.getLocation().getStartOffset());
+    assertFalse(collectedEventIt.hasNext());
+  }
+
+}
diff --git a/src/test/java/com/google/devtools/build/lib/events/EventSensorTest.java b/src/test/java/com/google/devtools/build/lib/events/EventSensorTest.java
new file mode 100644
index 0000000..3c97b37
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/events/EventSensorTest.java
@@ -0,0 +1,74 @@
+// Copyright 2014 Google Inc. 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.events;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * A test for {@link EventSensor}.
+ */
+@RunWith(JUnit4.class)
+public class EventSensorTest extends EventTestTemplate {
+
+  @Test
+  public void sensorStartsOutWithFalse() {
+    assertFalse(new EventSensor(EventKind.ALL_EVENTS).wasTriggered());
+    assertFalse(new EventSensor(EventKind.ERRORS).wasTriggered());
+    assertFalse(new EventSensor(EventKind.ERRORS_AND_WARNINGS).wasTriggered());
+  }
+
+  @Test
+  public void sensorNoticesEventsInItsMask() {
+    EventSensor sensor = new EventSensor(EventKind.ERRORS);
+    Reporter reporter = new Reporter(sensor);
+    reporter.handle(Event.error(location, "An ERROR event."));
+    assertTrue(sensor.wasTriggered());
+  }
+
+  @Test
+  public void sensorNoticesEventsInItsMask2() {
+    EventSensor sensor = new EventSensor(EventKind.ALL_EVENTS);
+    Reporter reporter = new Reporter(sensor);
+    reporter.handle(Event.error(location, "An ERROR event."));
+    reporter.handle(Event.warn(location, "A warning event."));
+    assertTrue(sensor.wasTriggered());
+  }
+
+  @Test
+  public void sensorIgnoresEventsNotInItsMask() {
+    EventSensor sensor = new EventSensor(EventKind.ERRORS_AND_WARNINGS);
+    Reporter reporter = new Reporter(sensor);
+    reporter.handle(Event.info(location, "An INFO event."));
+    assertFalse(sensor.wasTriggered());
+  }
+
+  @Test
+  public void sensorCanCount() {
+    EventSensor sensor = new EventSensor(EventKind.ERRORS_AND_WARNINGS);
+    Reporter reporter = new Reporter(sensor);
+    reporter.handle(Event.error(location, "An ERROR event."));
+    reporter.handle(Event.error(location, "Another ERROR event."));
+    reporter.handle(Event.warn(location, "A warning event."));
+    reporter.handle(Event.info(location, "An info event.")); // not in mask
+    assertEquals(3, sensor.getTriggerCount());
+    assertTrue(sensor.wasTriggered());
+  }
+
+}
diff --git a/src/test/java/com/google/devtools/build/lib/events/EventTest.java b/src/test/java/com/google/devtools/build/lib/events/EventTest.java
new file mode 100644
index 0000000..50fe88a
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/events/EventTest.java
@@ -0,0 +1,44 @@
+// Copyright 2014 Google Inc. 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.events;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * A super simple little test for the {@link Event} class.
+ */
+@RunWith(JUnit4.class)
+public class EventTest extends EventTestTemplate {
+
+  @Test
+  public void eventRetainsEventKind() {
+    assertEquals(EventKind.WARNING, event.getKind());
+  }
+
+  @Test
+  public void eventRetainsMessage() {
+    assertEquals("This is not an error message.", event.getMessage());
+  }
+
+  @Test
+  public void eventRetainsLocation() {
+    assertEquals(21, event.getLocation().getStartOffset());
+    assertEquals(31, event.getLocation().getEndOffset());
+  }
+
+}
diff --git a/src/test/java/com/google/devtools/build/lib/events/EventTestTemplate.java b/src/test/java/com/google/devtools/build/lib/events/EventTestTemplate.java
new file mode 100644
index 0000000..612cdf0
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/events/EventTestTemplate.java
@@ -0,0 +1,46 @@
+// Copyright 2014 Google Inc. 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.events;
+
+import com.google.devtools.build.lib.events.Location.LineAndColumn;
+import com.google.devtools.build.lib.vfs.Path;
+import com.google.devtools.build.lib.vfs.util.FsApparatus;
+
+import org.junit.Before;
+
+public abstract class EventTestTemplate {
+
+  protected Event event;
+  protected Path path;
+  protected Location location;
+  protected Location locationNoPath;
+  protected Location locationNoLineInfo;
+
+  private FsApparatus scratch = FsApparatus.newInMemory();
+
+  @Before
+  public void setUp() throws Exception {
+    String message = "This is not an error message.";
+    path = scratch.path("/my/sample/path.txt");
+
+    location = Location.fromPathAndStartColumn(path, 21, 31, new LineAndColumn(3, 4));
+
+    event = new Event(EventKind.WARNING, location, message);
+
+    locationNoPath = Location.fromPathAndStartColumn(null, 21, 31, new LineAndColumn(3, 4));
+
+    locationNoLineInfo = Location.fromFileAndOffsets(path, 21, 31);
+  }
+
+}
diff --git a/src/test/java/com/google/devtools/build/lib/events/LocationTest.java b/src/test/java/com/google/devtools/build/lib/events/LocationTest.java
new file mode 100644
index 0000000..a585b0c
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/events/LocationTest.java
@@ -0,0 +1,36 @@
+// Copyright 2014 Google Inc. 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.events;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class LocationTest extends EventTestTemplate {
+
+  @Test
+  public void fromFile() throws Exception {
+    Location location = Location.fromFile(path);
+    assertEquals(path.asFragment(), location.getPath());
+    assertEquals(0, location.getStartOffset());
+    assertEquals(0, location.getEndOffset());
+    assertNull(location.getStartLineAndColumn());
+    assertNull(location.getEndLineAndColumn());
+    assertEquals(path + ":1", location.print());
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/events/PrintingEventHandlerTest.java b/src/test/java/com/google/devtools/build/lib/events/PrintingEventHandlerTest.java
new file mode 100644
index 0000000..4cdfcb4
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/events/PrintingEventHandlerTest.java
@@ -0,0 +1,43 @@
+// Copyright 2014 Google Inc. 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.events;
+
+import static org.junit.Assert.assertEquals;
+
+import com.google.devtools.build.lib.testutil.MoreAsserts;
+import com.google.devtools.build.lib.util.io.RecordingOutErr;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests the {@link PrintingEventHandler}.
+ */
+@RunWith(JUnit4.class)
+public class PrintingEventHandlerTest extends EventTestTemplate {
+
+  @Test
+  public void collectsEvents() {
+    RecordingOutErr recordingOutErr = new RecordingOutErr();
+    PrintingEventHandler handler = new PrintingEventHandler(EventKind.ERRORS_AND_WARNINGS);
+    handler.setOutErr(recordingOutErr);
+    handler.handle(event);
+    MoreAsserts.assertEqualsUnifyingLineEnds("WARNING: /my/sample/path.txt:3:4: "
+                 + "This is not an error message.\n",
+                 recordingOutErr.errAsLatin1());
+    assertEquals("", recordingOutErr.outAsLatin1());
+  }
+
+}
diff --git a/src/test/java/com/google/devtools/build/lib/events/ReporterStreamTest.java b/src/test/java/com/google/devtools/build/lib/events/ReporterStreamTest.java
new file mode 100644
index 0000000..092d940
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/events/ReporterStreamTest.java
@@ -0,0 +1,68 @@
+// Copyright 2014 Google Inc. 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.events;
+
+import static org.junit.Assert.assertEquals;
+
+import com.google.devtools.build.lib.testutil.MoreAsserts;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.PrintWriter;
+
+@RunWith(JUnit4.class)
+public class ReporterStreamTest {
+
+  private Reporter reporter;
+  private StringBuilder out;
+  private EventHandler outAppender;
+
+  @Before
+  public void setUp() throws Exception {
+    reporter = new Reporter();
+    out = new StringBuilder();
+    outAppender = new EventHandler() {
+      @Override
+      public void handle(Event event) {
+        out.append("[" + event.getKind() + ": " + event.getMessage() + "]\n");
+      }
+    };
+  }
+
+  @Test
+  public void reporterStream() throws Exception {
+    assertEquals("", out.toString());
+    reporter.addHandler(outAppender);
+    PrintWriter infoWriter = new PrintWriter(new ReporterStream(reporter, EventKind.INFO), true);
+    PrintWriter warnWriter = new PrintWriter(new ReporterStream(reporter, EventKind.WARNING), true);
+    try {
+      infoWriter.println("some info");
+      warnWriter.println("a warning");
+    } finally {
+      infoWriter.close();
+      warnWriter.close();
+    }
+    reporter.getOutErr().printOutLn("some output");
+    reporter.getOutErr().printErrLn("an error");
+    MoreAsserts.assertEqualsUnifyingLineEnds(
+        "[INFO: some info\n]\n"
+            + "[WARNING: a warning\n]\n"   
+            + "[STDOUT: some output\n]\n"
+            + "[STDERR: an error\n]\n",
+            out.toString());
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/events/ReporterTest.java b/src/test/java/com/google/devtools/build/lib/events/ReporterTest.java
new file mode 100644
index 0000000..f51451a
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/events/ReporterTest.java
@@ -0,0 +1,100 @@
+// Copyright 2014 Google Inc. 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.events;
+
+import static org.junit.Assert.assertEquals;
+
+import com.google.common.collect.ImmutableList;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests the {@link Reporter} class.
+ */
+@RunWith(JUnit4.class)
+public class ReporterTest extends EventTestTemplate {
+
+  private Reporter reporter;
+  private StringBuilder out;
+  private AbstractEventHandler outAppender;
+
+  @Before
+  public void setUp() throws Exception {
+    super.setUp();
+    reporter = new Reporter();
+    out = new StringBuilder();
+    outAppender = new AbstractEventHandler(EventKind.ERRORS) {
+      @Override
+      public void handle(Event event) {
+        out.append(event.getMessage());
+      }
+    };
+  }
+
+  @Test
+  public void reporterShowOutput() {
+    reporter.setOutputFilter(OutputFilter.RegexOutputFilter.forRegex("naughty"));
+    EventCollector collector = new EventCollector(EventKind.ALL_EVENTS);
+    reporter.addHandler(collector);
+    Event interesting = new Event(EventKind.WARNING, null, "show-me", "naughty");
+
+    reporter.handle(interesting);
+    reporter.handle(new Event(EventKind.WARNING, null, "ignore-me", "good"));
+
+    assertEquals(ImmutableList.copyOf(collector.iterator()), ImmutableList.of(interesting));
+  }
+
+  @Test
+  public void reporterCollectsEvents() {
+    ImmutableList<Event> want = ImmutableList.of(Event.warn("xyz"), Event.error("err"));
+    EventCollector collector = new EventCollector(EventKind.ALL_EVENTS);
+    reporter.addHandler(collector);
+    for (Event e : want) {
+      reporter.handle(e);
+    }
+    ImmutableList<Event> got = ImmutableList.copyOf(collector.iterator());
+    assertEquals(got, want);
+  }
+
+  @Test
+  public void reporterCopyConstructorCopiesHandlersList() {
+    reporter.addHandler(outAppender);
+    reporter.addHandler(outAppender);
+    Reporter copiedReporter = new Reporter(reporter);
+    copiedReporter.addHandler(outAppender); // Should have 3 handlers now.
+    reporter.addHandler(outAppender);
+    reporter.addHandler(outAppender); // Should have 4 handlers now.
+    copiedReporter.handle(Event.error(location, "."));
+    assertEquals("...", out.toString()); // The copied reporter has 3 handlers.
+    out = new StringBuilder();
+    reporter.handle(Event.error(location, "."));
+    assertEquals("....", out.toString()); // The old reporter has 4 handlers.
+  }
+
+  @Test
+  public void removeHandlerUndoesAddHandler() {
+    assertEquals("", out.toString());
+    reporter.addHandler(outAppender);
+    reporter.handle(Event.error(location, "Event gets registered."));
+    assertEquals("Event gets registered.", out.toString());
+    out = new StringBuilder();
+    reporter.removeHandler(outAppender);
+    reporter.handle(Event.error(location, "Event gets ignored."));
+    assertEquals("", out.toString());
+  }
+
+}
diff --git a/src/test/java/com/google/devtools/build/lib/events/SimpleReportersTest.java b/src/test/java/com/google/devtools/build/lib/events/SimpleReportersTest.java
new file mode 100644
index 0000000..deed44f
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/events/SimpleReportersTest.java
@@ -0,0 +1,47 @@
+// Copyright 2014 Google Inc. 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.events;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * A test for {@link Reporter}.
+ */
+@RunWith(JUnit4.class)
+public class SimpleReportersTest extends EventTestTemplate {
+
+  private int handlerCount = 0;
+
+  @Test
+  public void addsHandlers() {
+    EventHandler handler = new EventHandler() {
+      @Override
+      public void handle(Event event) {
+        handlerCount++;
+      }
+
+    };
+
+    Reporter reporter = new Reporter(handler);
+    reporter.handle(new Event(EventKind.INFO, location, "Add to handlerCount."));
+    reporter.handle(new Event(EventKind.INFO, location, "Add to handlerCount."));
+    reporter.handle(new Event(EventKind.INFO, location, "Add to handlerCount."));
+    assertEquals(3, handlerCount);
+  }
+
+}
diff --git a/src/test/java/com/google/devtools/build/lib/events/StoredErrorEventHandlerTest.java b/src/test/java/com/google/devtools/build/lib/events/StoredErrorEventHandlerTest.java
new file mode 100644
index 0000000..d47cf86
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/events/StoredErrorEventHandlerTest.java
@@ -0,0 +1,75 @@
+// Copyright 2014 Google Inc. 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.events;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import com.google.common.collect.ImmutableList;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.List;
+
+/**
+ * Tests the {@link StoredEventHandler} class.
+ */
+@RunWith(JUnit4.class)
+public class StoredErrorEventHandlerTest {
+
+  @Test
+  public void hasErrors() {
+    StoredEventHandler eventHandler = new StoredEventHandler();
+    assertFalse(eventHandler.hasErrors());
+    eventHandler.handle(Event.warn("warning"));
+    assertFalse(eventHandler.hasErrors());
+    eventHandler.handle(Event.info("info"));
+    assertFalse(eventHandler.hasErrors());
+    eventHandler.handle(Event.error("error"));
+    assertTrue(eventHandler.hasErrors());
+  }
+
+  @Test
+  public void replayOnWithoutEvents() {
+    StoredEventHandler eventHandler = new StoredEventHandler();
+    StoredEventHandler sink = new StoredEventHandler();
+
+    eventHandler.replayOn(sink);
+    assertTrue(sink.isEmpty());
+  }
+
+  @Test
+  public void replayOn() {
+    StoredEventHandler eventHandler = new StoredEventHandler();
+    StoredEventHandler sink = new StoredEventHandler();
+
+    List<Event> events = ImmutableList.of(
+        Event.warn("a"),
+        Event.error("b"),
+        Event.info("c"),
+        Event.warn("d"));
+    for (Event e : events) {
+      eventHandler.handle(e);
+    }
+
+    eventHandler.replayOn(sink);
+    assertEquals(events.size(), sink.getEvents().size());
+    for (int i = 0; i < events.size(); i++) {
+      assertEquals(events.get(i), sink.getEvents().get(i));
+    }
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/events/WarningsAsErrorsEventHandlerTest.java b/src/test/java/com/google/devtools/build/lib/events/WarningsAsErrorsEventHandlerTest.java
new file mode 100644
index 0000000..ce6b1a9
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/events/WarningsAsErrorsEventHandlerTest.java
@@ -0,0 +1,47 @@
+// Copyright 2014 Google Inc. 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.events;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests the {@link StoredEventHandler} class.
+ */
+@RunWith(JUnit4.class)
+public class WarningsAsErrorsEventHandlerTest {
+
+  @Test
+  public void hasErrors() {
+    ErrorSensingEventHandler delegate =
+        new ErrorSensingEventHandler(NullEventHandler.INSTANCE);
+    WarningsAsErrorsEventHandler eventHandler =
+        new WarningsAsErrorsEventHandler(delegate);
+
+    eventHandler.handle(Event.info("info"));
+    assertFalse(delegate.hasErrors());
+
+    eventHandler.handle(Event.warn("warning"));
+    assertTrue(delegate.hasErrors());
+
+    delegate.resetErrors();
+
+    eventHandler.handle(Event.error("error"));
+    assertTrue(delegate.hasErrors());
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/events/util/EventCollectionApparatus.java b/src/test/java/com/google/devtools/build/lib/events/util/EventCollectionApparatus.java
new file mode 100644
index 0000000..1513735
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/events/util/EventCollectionApparatus.java
@@ -0,0 +1,149 @@
+// Copyright 2014 Google Inc. 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.events.util;
+
+import static com.google.common.truth.Truth.assertWithMessage;
+
+import com.google.devtools.build.lib.events.Event;
+import com.google.devtools.build.lib.events.EventCollector;
+import com.google.devtools.build.lib.events.EventHandler;
+import com.google.devtools.build.lib.events.EventKind;
+import com.google.devtools.build.lib.events.PrintingEventHandler;
+import com.google.devtools.build.lib.events.Reporter;
+import com.google.devtools.build.lib.testutil.JunitTestUtils;
+import com.google.devtools.build.lib.util.io.OutErr;
+
+import java.util.List;
+import java.util.Set;
+
+/**
+ * An apparatus for reporting / collecting events. 
+ */
+public class EventCollectionApparatus {
+
+  /**
+   * The fail fast handler, which fails the test fail whenever we encounter
+   * an error event.
+   */
+  private static final EventHandler FAIL_FAST_HANDLER = new EventHandler() {
+    @Override
+    public void handle(Event event) {
+      assertWithMessage(event.toString()).that(EventKind.ERRORS_AND_WARNINGS)
+          .doesNotContain(event.getKind());
+    }
+  };
+  private Set<EventKind> customMask;
+  
+  /*
+  *  Determine which events the {@link #collector()} created by this apparatus
+   * will collect. Default: {@link EventKind#ERRORS_AND_WARNINGS}.
+   *
+  */
+  public EventCollectionApparatus(Set<EventKind> mask) {
+    this.customMask = mask;
+    
+    eventCollector = new EventCollector(customMask);
+    reporter = new Reporter(eventCollector);
+    printingEventHandler = new PrintingEventHandler(EventKind.ERRORS_AND_WARNINGS_AND_OUTPUT);
+    reporter.addHandler(printingEventHandler);
+    
+    this.setFailFast(true);
+  }
+  
+  public EventCollectionApparatus() {
+    this(EventKind.ERRORS_AND_WARNINGS);
+  }
+  
+  /* ---- Settings for the apparatus (configuration for creating state) ---- */
+
+  /* ---------- State that the apparatus initializes / operates on --------- */
+  private EventCollector eventCollector;
+  private Reporter reporter;
+  private PrintingEventHandler printingEventHandler;
+
+  /**
+   * Determine whether the {#link reporter()} created by this apparatus will
+   * fail fast, that is, throw an exception whenever we encounter an event of
+   * matching {@link EventKind#ERRORS_AND_WARNINGS}.
+   * Default: {@code true}.
+   */
+  public void setFailFast(boolean failFast) {
+    if (failFast) {
+      reporter.addHandler(FAIL_FAST_HANDLER);
+    } else {
+      reporter.removeHandler(FAIL_FAST_HANDLER);
+    }
+  }
+  
+  /**
+   * Initializes the apparatus (if it's not been initialized yet) and returns
+   * the reporter created with the settings specified by this apparatus.
+   */
+  public Reporter reporter() {
+    return reporter;
+  }
+
+  /**
+   * Initializes the apparatus (if it's not been initialized yet) and returns
+   * the collector created with the settings specified by this apparatus.
+   */
+  public EventCollector collector() {
+    return eventCollector;
+  }
+
+  /**
+   * Redirects all output to the specified OutErr stream pair.
+   * Returns the previous OutErr.
+   */
+  public OutErr setOutErr(OutErr outErr) {
+    return printingEventHandler.setOutErr(outErr);
+  }
+
+  /**
+   * Utility method: Asserts that the {@link #collector()} has not collected
+   * any events.
+   *
+   * @throws IllegalStateException If the apparatus has not yet been
+   *    initialized by calling {@link #reporter()} or {@link #collector()}.
+   */
+  public void assertNoEvents() {
+    JunitTestUtils.assertNoEvents(eventCollector);
+  }
+
+  /**
+   * Utility method: Assert that the {@link #collector()} has received an
+   * event with the {@code expectedMessage}.
+   */
+  public Event assertContainsEvent(String expectedMessage) {
+    return JunitTestUtils.assertContainsEvent(eventCollector,
+                                              expectedMessage);
+  }
+
+  public List<Event> assertContainsEventWithFrequency(String expectedMessage,
+      int expectedFrequency) {
+    return JunitTestUtils.assertContainsEventWithFrequency(eventCollector, expectedMessage,
+        expectedFrequency);
+  }
+
+  /**
+   * Utility method: Assert that the {@link #collector()} has received an
+   * event with the {@code expectedMessage} in quotes.
+   */
+
+  public Event assertContainsEventWithWordsInQuotes(String... words) {
+    return JunitTestUtils.assertContainsEventWithWordsInQuotes(
+        eventCollector, words);
+  }
+
+}
diff --git a/src/test/java/com/google/devtools/build/lib/events/util/LocationTestingUtil.java b/src/test/java/com/google/devtools/build/lib/events/util/LocationTestingUtil.java
new file mode 100644
index 0000000..66aaf30
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/events/util/LocationTestingUtil.java
@@ -0,0 +1,35 @@
+// Copyright 2014 Google Inc. 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.events.util;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.devtools.build.lib.events.Location;
+
+/**
+ * Static utility methods for testing Locations.
+ */
+public class LocationTestingUtil {
+
+  private LocationTestingUtil() {
+  }
+
+  public static void assertEqualLocations(Location expected, Location actual) {
+    assertThat(actual.getStartOffset()).isEqualTo(expected.getStartOffset());
+    assertThat(actual.getStartLineAndColumn()).isEqualTo(expected.getStartLineAndColumn());
+    assertThat(actual.getEndOffset()).isEqualTo(expected.getEndOffset());
+    assertThat(actual.getEndLineAndColumn()).isEqualTo(expected.getEndLineAndColumn());
+    assertThat(actual.getPath()).isEqualTo(expected.getPath());
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/testutil/BlazeTestSuiteBuilder.java b/src/test/java/com/google/devtools/build/lib/testutil/BlazeTestSuiteBuilder.java
new file mode 100644
index 0000000..d2f36a6
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/testutil/BlazeTestSuiteBuilder.java
@@ -0,0 +1,123 @@
+// Copyright 2014 Google Inc. 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.testutil;
+
+import com.google.common.base.Predicate;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * A base class for constructing test suites by searching the classpath for
+ * tests, possibly restricted to a predicate.
+ */
+public class BlazeTestSuiteBuilder {
+
+  /**
+   * @return a TestSuiteBuilder configured for Blaze.
+   */
+  protected TestSuiteBuilder getBuilder() {
+    return new TestSuiteBuilder()
+        .addPackageRecursive("com.google.devtools.build.lib");
+  }
+
+  /** A predicate that succeeds only for LARGE tests. */
+  public static final Predicate<Class<?>> TEST_IS_LARGE =
+      hasSize(Suite.LARGE_TESTS);
+
+  /** A predicate that succeeds only for MEDIUM tests. */
+  public static final Predicate<Class<?>> TEST_IS_MEDIUM =
+      hasSize(Suite.MEDIUM_TESTS);
+
+  /** A predicate that succeeds only for SMALL tests. */
+  public static final Predicate<Class<?>> TEST_IS_SMALL =
+      hasSize(Suite.SMALL_TESTS);
+
+  /** A predicate that succeeds only for non-flaky tests. */
+  public static final Predicate<Class<?>> TEST_IS_FLAKY = new Predicate<Class<?>>() {
+    @Override
+    public boolean apply(Class<?> testClass) {
+      return Suite.isFlaky(testClass);
+    }
+  };
+
+  private static Predicate<Class<?>> hasSize(final Suite size) {
+    return new Predicate<Class<?>>() {
+      @Override
+      public boolean apply(Class<?> testClass) {
+        return Suite.getSize(testClass) == size;
+      }
+    };
+  }
+
+  protected static Predicate<Class<?>> inSuite(final String suiteName) {
+    return new Predicate<Class<?>>() {
+      @Override
+      public boolean apply(Class<?> testClass) {
+        return Suite.getSuiteName(testClass).equalsIgnoreCase(suiteName);
+      }
+    };
+  }
+
+  /**
+   * Given a TestCase subclass, returns its designated suite annotation, if
+   * any, or the empty string otherwise.
+   */
+  public static String getSuite(Class<?> clazz) {
+    TestSpec spec = clazz.getAnnotation(TestSpec.class);
+    return spec == null ? "" : spec.suite();
+  }
+
+  /**
+   * Returns a predicate over TestCases that is true iff the TestCase has a
+   * TestSpec annotation whose suite="..." value (a comma-separated list of
+   * tags) matches all of the query operators specified in the system property
+   * {@code blaze.suite}.  The latter is also a comma-separated list, but of
+   * query operators, each of which is either the name of a tag which must be
+   * present (e.g. "foo"), or the !-prefixed name of a tag that must be absent
+   * (e.g. "!foo").
+   */
+  public static Predicate<Class<?>> matchesSuiteQuery() {
+    final String suiteProperty = System.getProperty("blaze.suite");
+    if (suiteProperty == null) {
+      throw new IllegalArgumentException("blaze.suite property not found");
+    }
+    final Set<String> queryTokens = splitCommas(suiteProperty);
+    return new Predicate<Class<?>>() {
+      @Override
+      public boolean apply(Class<?> testClass) {
+        // Return true iff every queryToken is satisfied by suiteTags.
+        Set<String> suiteTags = splitCommas(getSuite(testClass));
+        for (String queryToken : queryTokens) {
+          if (queryToken.startsWith("!")) { // forbidden tag
+            if (suiteTags.contains(queryToken.substring(1))) {
+              return false;
+            }
+          } else { // mandatory tag
+            if (!suiteTags.contains(queryToken)) {
+              return false;
+            }
+          }
+        }
+        return true;
+      }
+    };
+  }
+
+  private static Set<String> splitCommas(String s) {
+    return new HashSet<>(Arrays.asList(s.split(",")));
+  }
+
+}
diff --git a/src/test/java/com/google/devtools/build/lib/testutil/BlazeTestUtils.java b/src/test/java/com/google/devtools/build/lib/testutil/BlazeTestUtils.java
new file mode 100644
index 0000000..8588a08
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/testutil/BlazeTestUtils.java
@@ -0,0 +1,118 @@
+// Copyright 2014 Google Inc. 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.testutil;
+
+import com.google.common.base.Joiner;
+import com.google.common.base.Preconditions;
+import com.google.devtools.build.lib.analysis.BlazeDirectories;
+import com.google.devtools.build.lib.analysis.config.BinTools;
+import com.google.devtools.build.lib.vfs.FileSystemUtils;
+import com.google.devtools.build.lib.vfs.Path;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+
+/**
+ * Some static utility functions for testing Blaze code. In contrast to {@link TestUtils}, these
+ * functions are Blaze-specific.
+ */
+public class BlazeTestUtils {
+  private BlazeTestUtils() {}
+
+  /**
+   * Populates the _embedded_binaries/ directory, containing all binaries/libraries, by symlinking
+   * directories#getEmbeddedBinariesRoot() to the test's runfiles tree.
+   */
+  public static BinTools getIntegrationBinTools(BlazeDirectories directories) throws IOException {
+    Path embeddedDir = directories.getEmbeddedBinariesRoot();
+    FileSystemUtils.createDirectoryAndParents(embeddedDir);
+
+    Path runfiles = directories.getFileSystem().getPath(BlazeTestUtils.runfilesDir());
+    // Copy over everything in embedded_scripts.
+    Path embeddedScripts = runfiles.getRelative(TestConstants.EMBEDDED_SCRIPTS_PATH);
+    Collection<Path> files = new ArrayList<Path>();
+    if (embeddedScripts.exists()) {
+      files.addAll(embeddedScripts.getDirectoryEntries());
+    } else {
+      System.err.println("test does not have " + embeddedScripts);
+    }
+
+    for (Path fromFile : files) {
+      try {
+        embeddedDir.getChild(fromFile.getBaseName()).createSymbolicLink(fromFile);
+      } catch (IOException e) {
+        System.err.println("Could not symlink: " + e.getMessage());
+      }
+    }
+
+    return BinTools.forIntegrationTesting(
+        directories, embeddedDir.toString(), TestConstants.EMBEDDED_TOOLS);
+  }
+
+  /**
+   * Writes a FilesetRule to a String array.
+   *
+   * @param name the name of the rule.
+   * @param out the output directory.
+   * @param entries The FilesetEntry entries.
+   * @return the String array of the rule.  One String for each line.
+   */
+  public static String[] createFilesetRule(String name, String out, String... entries) {
+    return new String[] {
+        String.format("Fileset(name = '%s', out = '%s',", name, out),
+                      "        entries = [" +  Joiner.on(", ").join(entries) + "])"
+    };
+  }
+
+  public static File undeclaredOutputDir() {
+    String dir = System.getenv("TEST_UNDECLARED_OUTPUTS_DIR");
+    if (dir != null) {
+      return new File(dir);
+    }
+
+    return TestUtils.tmpDirFile();
+  }
+
+  public static String runfilesDir() {
+    String runfilesDirStr = TestUtils.getUserValue("TEST_SRCDIR");
+    Preconditions.checkState(runfilesDirStr != null && runfilesDirStr.length() > 0,
+        "TEST_SRCDIR unset or empty");
+    return new File(runfilesDirStr).getAbsolutePath();
+  }
+
+  /** Creates an empty file, along with all its parent directories. */
+  public static void makeEmptyFile(Path path) throws IOException {
+    FileSystemUtils.createDirectoryAndParents(path.getParentDirectory());
+    FileSystemUtils.createEmptyFile(path);
+  }
+
+  /**
+   * Changes the mtime of the file "path", which must exist.  No guarantee is
+   * made about the new mtime except that it is different from the previous one.
+   *
+   * @throws IOException if the mtime could not be read or set.
+   */
+  public static void changeModtime(Path path)
+    throws IOException {
+    long prevMtime = path.getLastModifiedTime();
+    long newMtime = prevMtime;
+    do {
+      newMtime += 1000;
+      path.setLastModifiedTime(newMtime);
+    } while (path.getLastModifiedTime() == prevMtime);
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/testutil/BuildRuleBuilder.java b/src/test/java/com/google/devtools/build/lib/testutil/BuildRuleBuilder.java
new file mode 100644
index 0000000..9f770c5
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/testutil/BuildRuleBuilder.java
@@ -0,0 +1,202 @@
+// Copyright 2014 Google Inc. 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.testutil;
+
+import com.google.common.base.Function;
+import com.google.common.base.Joiner;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.devtools.build.lib.packages.RuleClass;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Utility for quickly creating BUILD file rules for use in tests.
+ *
+ * <p>The use case for this class is writing BUILD files where simple
+ * readability for the sake of rules' relationship to the test framework
+ * is more important than detailed semantics and layout.
+ *
+ * <p>The behavior provided by this class is not meant to be exhaustive,
+ * but should handle a majority of simple cases.
+ *
+ * <p>Example:
+ *
+ * <pre>
+ *   String text = new BuildRuleBuilder("java_library", "MyRule")
+        .setSources("First.java", "Second.java", "Third.java")
+        .setDeps(":library", "//java/com/google/common/collect")
+        .setResources("schema/myschema.xsd")
+        .build();
+ * </pre>
+ *
+ */
+public class BuildRuleBuilder {
+  protected final RuleClass ruleClass;
+  protected final String ruleName;
+  private Map<String, List<String>> multiValueAttributes;
+  private Map<String, Object> singleValueAttributes;
+  protected Map<String, RuleClass> ruleClassMap;
+  
+  /**
+   * Create a new instance.
+   *
+   * @param ruleClass the rule class of the new rule
+   * @param ruleName the name of the new rule.
+   */
+  public BuildRuleBuilder(String ruleClass, String ruleName) {
+    this(ruleClass, ruleName, getDefaultRuleClassMap());
+  }
+
+  protected static Map<String, RuleClass> getDefaultRuleClassMap() {
+    return TestRuleClassProvider.getRuleClassProvider().getRuleClassMap();
+  }
+
+  public BuildRuleBuilder(String ruleClass, String ruleName, Map<String, RuleClass> ruleClassMap) {
+    this.ruleClass = ruleClassMap.get(ruleClass);
+    this.ruleName = ruleName;
+    this.multiValueAttributes = new HashMap<>();
+    this.singleValueAttributes = new HashMap<>();
+    this.ruleClassMap = ruleClassMap;
+  }
+
+  /**
+   * Sets the value of a single valued attribute
+   */
+  public BuildRuleBuilder setSingleValueAttribute(String attrName, Object value) {
+    Preconditions.checkState(!singleValueAttributes.containsKey(attrName),
+        "attribute '" + attrName + "' already set");
+    singleValueAttributes.put(attrName, value);
+    return this;
+  }
+
+  /**
+   * Sets the value of a list type attribute
+   */
+  public BuildRuleBuilder setMultiValueAttribute(String attrName, String... value) {
+    Preconditions.checkState(!multiValueAttributes.containsKey(attrName),
+        "attribute '" + attrName + "' already set");
+    multiValueAttributes.put(attrName, Lists.newArrayList(value));
+    return this;
+  }
+
+  /**
+   * Set the srcs attribute.
+   */
+  public BuildRuleBuilder setSources(String... sources) {
+    return setMultiValueAttribute("srcs", sources);
+  }
+
+  /**
+   * Set the deps attribute.
+   */
+  public BuildRuleBuilder setDeps(String... deps) {
+    return setMultiValueAttribute("deps", deps);
+  }
+
+  /**
+   * Set the resources attribute.
+   */
+  public BuildRuleBuilder setResources(String... resources) {
+    return setMultiValueAttribute("resources", resources);
+  }
+
+  /**
+   * Set the data attribute.
+   */
+  public BuildRuleBuilder setData(String... data) {
+    return setMultiValueAttribute("data", data);
+  }
+
+  /**
+   * Generate the rule
+   *
+   * @return a string representation of the rule.
+   */
+  public String build() {
+    StringBuilder sb = new StringBuilder();
+    sb.append(ruleClass.getName()).append("(");
+    printNormal(sb, "name", ruleName);
+    for (Map.Entry<String, List<String>> entry : multiValueAttributes.entrySet()) {
+      printArray(sb, entry.getKey(), entry.getValue());
+    }
+    for (Map.Entry<String, Object> entry : singleValueAttributes.entrySet()) {
+      printNormal(sb, entry.getKey(), entry.getValue());
+    }
+    sb.append(")\n");
+    return sb.toString();
+  }
+
+  private void printArray(StringBuilder sb, String attr, List<String> values) {
+    if (values == null || values.isEmpty()) {
+      return;
+    }
+    sb.append("      ").append(attr).append(" = ");
+    printList(sb, values);
+    sb.append(",");
+    sb.append("\n");
+  }
+
+  private void printNormal(StringBuilder sb, String attr, Object value) {
+    if (value == null) {
+      return;
+    }
+    sb.append("      ").append(attr).append(" = ");
+    if (value instanceof Integer) {
+      sb.append(value);
+    } else {
+      sb.append("'").append(value).append("'");
+    }
+    sb.append(",");
+    sb.append("\n");
+  }
+
+  /**
+   * Turns iterable of {a b c} into string "['a', 'b', 'c']", appends to
+   * supplied StringBuilder.
+   */
+  private void printList(StringBuilder sb, List<String> elements) {
+    sb.append("[");
+    Joiner.on(",").appendTo(sb,
+        Iterables.transform(elements, new Function<String, String>() {
+          @Override
+          public String apply(String from) {
+            return "'" + from + "'";
+          }
+        }));
+    sb.append("]");
+  }
+
+  /**
+   * Returns the transitive closure of file names need to be generated in order
+   * for this rule to build.
+   */
+  public Collection<String> getFilesToGenerate() {
+    return ImmutableList.of();
+  }
+
+  /**
+   * Returns the transitive closure of BuildRuleBuilders need to be generated in order
+   * for this rule to build.
+   */
+  public Collection<BuildRuleBuilder> getRulesToGenerate() {
+    return ImmutableList.of();
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/testutil/BuildRuleWithDefaultsBuilder.java b/src/test/java/com/google/devtools/build/lib/testutil/BuildRuleWithDefaultsBuilder.java
new file mode 100644
index 0000000..4af7ad1
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/testutil/BuildRuleWithDefaultsBuilder.java
@@ -0,0 +1,231 @@
+// Copyright 2014 Google Inc. 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.testutil;
+
+import com.google.common.base.Preconditions;
+import com.google.common.base.Predicate;
+import com.google.common.base.Predicates;
+import com.google.devtools.build.lib.packages.Attribute;
+import com.google.devtools.build.lib.packages.Attribute.AllowedValueSet;
+import com.google.devtools.build.lib.packages.RuleClass;
+import com.google.devtools.build.lib.packages.Type;
+import com.google.devtools.build.lib.util.FileTypeSet;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * A helper class to generate valid rules with filled attributes if necessary.
+ */
+public class BuildRuleWithDefaultsBuilder extends BuildRuleBuilder {
+
+  private Set<String> generateFiles;
+  private Map<String, BuildRuleBuilder> generateRules;
+
+  public BuildRuleWithDefaultsBuilder(String ruleClass, String ruleName) {
+    super(ruleClass, ruleName);
+    this.generateFiles = new HashSet<>();
+    this.generateRules = new HashMap<>();
+  }
+
+  private BuildRuleWithDefaultsBuilder(String ruleClass, String ruleName,
+      Map<String, RuleClass> ruleClassMap, Set<String> generateFiles,
+      Map<String, BuildRuleBuilder> generateRules) {
+    super(ruleClass, ruleName, ruleClassMap);
+    this.generateFiles = generateFiles;
+    this.generateRules = generateRules;
+  }
+
+  /**
+   * Creates a dummy file with the given extension in the given package and returns a valid Blaze
+   * label referring to the file. Note, the created label depends on the package of the rule.
+   */
+  private String getDummyFileLabel(String rulePkg, String filePkg, String extension,
+      Type<?> attrType) {
+    boolean isInput = (attrType == Type.LABEL || attrType == Type.LABEL_LIST);
+    String fileName = (isInput ? "dummy_input" : "dummy_output") + extension;
+    generateFiles.add(filePkg + "/" + fileName);
+    if (rulePkg.equals(filePkg)) {
+      return ":" + fileName;
+    } else {
+      return filePkg + ":" + fileName;
+    }
+  }
+
+  private String getDummyRuleLabel(String rulePkg, RuleClass referencedRuleClass) {
+    String referencedRuleName = ruleName + "_ref_" + referencedRuleClass.getName()
+        .replace("$", "").replace(":", "");
+    // The new generated rule should have the same generatedFiles and generatedRules
+    // in order to avoid duplications
+    BuildRuleWithDefaultsBuilder builder = new BuildRuleWithDefaultsBuilder(
+        referencedRuleClass.getName(), referencedRuleName, ruleClassMap, generateFiles,
+        generateRules);
+    builder.popuplateAttributes(rulePkg, true);
+    generateRules.put(referencedRuleClass.getName(), builder);
+    return referencedRuleName;
+  }
+
+  public BuildRuleWithDefaultsBuilder popuplateLabelAttribute(String pkg, Attribute attribute) {
+    return popuplateLabelAttribute(pkg, pkg, attribute);
+  }
+
+  /**
+   * Populates the label type attribute with generated values. Populates with a file if possible, or
+   * generates an appropriate rule. Note, that the rules are always generated in the same package.
+   */
+  public BuildRuleWithDefaultsBuilder popuplateLabelAttribute(String rulePkg, String filePkg,
+      Attribute attribute) {
+    Type<?> attrType = attribute.getType();
+    String label = null;
+    if (attribute.getAllowedFileTypesPredicate() != FileTypeSet.NO_FILE) {
+      // Try to populate with files first
+      String extension = null;
+      if (attribute.getAllowedFileTypesPredicate() == FileTypeSet.ANY_FILE) {
+        extension = ".txt";
+      } else {
+        FileTypeSet fileTypes = attribute.getAllowedFileTypesPredicate();
+        // This argument should always hold, if not that means a Blaze design/implementation error
+        Preconditions.checkArgument(fileTypes.getExtensions().size() > 0);
+        extension = fileTypes.getExtensions().get(0);
+      }
+      label = getDummyFileLabel(rulePkg, filePkg, extension, attrType);
+    } else {
+      Predicate<RuleClass> allowedRuleClasses = attribute.getAllowedRuleClassesPredicate();
+      if (allowedRuleClasses != Predicates.<RuleClass>alwaysFalse()) {
+        // See if there is an applicable rule among the already enqueued rules
+        BuildRuleBuilder referencedRuleBuilder = getFirstApplicableRule(allowedRuleClasses);
+        if (referencedRuleBuilder != null) {
+          label = ":" + referencedRuleBuilder.ruleName;
+        } else {
+          RuleClass referencedRuleClass = getFirstApplicableRuleClass(allowedRuleClasses);
+          if (referencedRuleClass != null) {
+            // Generate a rule with the appropriate ruleClass and a label for it in
+            // the original rule
+            label = ":" + getDummyRuleLabel(rulePkg, referencedRuleClass);
+          }
+        }
+      }
+    }
+    if (label != null) {
+      if (attrType == Type.LABEL_LIST || attrType == Type.OUTPUT_LIST) {
+        setMultiValueAttribute(attribute.getName(), label);
+      } else {
+        setSingleValueAttribute(attribute.getName(), label);
+      }
+    }
+    return this;
+  }
+
+  private BuildRuleBuilder getFirstApplicableRule(Predicate<RuleClass> allowedRuleClasses) {
+    // There is no direct way to get the set of allowedRuleClasses from the Attribute
+    // The Attribute API probably should not be modified for sole testing purposes
+    for (Map.Entry<String, BuildRuleBuilder> entry : generateRules.entrySet()) {
+      if (allowedRuleClasses.apply(ruleClassMap.get(entry.getKey()))) {
+        return entry.getValue();
+      }
+    }
+    return null;
+  }
+
+  private RuleClass getFirstApplicableRuleClass(Predicate<RuleClass> allowedRuleClasses) {
+    // See comments in getFirstApplicableRule(Predicate<RuleClass> allowedRuleClasses)
+    for (RuleClass ruleClass : ruleClassMap.values()) {
+      if (allowedRuleClasses.apply(ruleClass)) {
+        return ruleClass;
+      }
+    }
+    return null;
+  }
+
+  public BuildRuleWithDefaultsBuilder popuplateStringListAttribute(Attribute attribute) {
+    setMultiValueAttribute(attribute.getName(), "x");
+    return this;
+  }
+
+  public BuildRuleWithDefaultsBuilder popuplateStringAttribute(Attribute attribute) {
+    setSingleValueAttribute(attribute.getName(), "x");
+    return this;
+  }
+
+  public BuildRuleWithDefaultsBuilder popuplateBooleanAttribute(Attribute attribute) {
+    setSingleValueAttribute(attribute.getName(), "false");
+    return this;
+  }
+
+  public BuildRuleWithDefaultsBuilder popuplateIntegerAttribute(Attribute attribute) {
+    setSingleValueAttribute(attribute.getName(), 1);
+    return this;
+  }
+
+  public BuildRuleWithDefaultsBuilder popuplateAttributes(String rulePkg, boolean heuristics) {
+    for (Attribute attribute : ruleClass.getAttributes()) {
+      if (attribute.isMandatory()) {
+        if (attribute.getType() == Type.LABEL_LIST || attribute.getType() == Type.OUTPUT_LIST) {
+          if (attribute.isNonEmpty()) {
+            popuplateLabelAttribute(rulePkg, attribute);
+          } else {
+            // TODO(bazel-team): actually here an empty list would be fine, but BuildRuleBuilder
+            // doesn't support that, and it makes little sense anyway
+            popuplateLabelAttribute(rulePkg, attribute);
+          }
+        } else if (attribute.getType() == Type.LABEL || attribute.getType() == Type.OUTPUT) {
+          popuplateLabelAttribute(rulePkg, attribute);
+        } else {
+          // Non label type attributes
+          if (attribute.getAllowedValues() instanceof AllowedValueSet) {
+            Collection<Object> allowedValues =
+                ((AllowedValueSet) attribute.getAllowedValues()).getAllowedValues();
+            setSingleValueAttribute(attribute.getName(), allowedValues.iterator().next());
+          } else if (attribute.getType() == Type.STRING) {
+            popuplateStringAttribute(attribute);
+          } else if (attribute.getType() == Type.BOOLEAN) {
+            popuplateBooleanAttribute(attribute);
+          } else if (attribute.getType() == Type.INTEGER) {
+            popuplateIntegerAttribute(attribute);
+          } else if (attribute.getType() == Type.STRING_LIST) {
+            popuplateStringListAttribute(attribute);
+          }
+        }
+        // TODO(bazel-team): populate for other data types
+      } else if (heuristics) {
+        populateAttributesHeuristics(rulePkg, attribute);
+      }
+    }
+    return this;
+  }
+
+  // Heuristics which might help to generate valid rules.
+  // This is a bit hackish, but it helps some generated ruleclasses to pass analysis phase.
+  private void populateAttributesHeuristics(String rulePkg, Attribute attribute) {
+    if (attribute.getName().equals("srcs") && attribute.getType() == Type.LABEL_LIST) {
+      // If there is a srcs attribute it might be better to populate it even if it's not mandatory
+      popuplateLabelAttribute(rulePkg, attribute);
+    } else if (attribute.getName().equals("main_class") && attribute.getType() == Type.STRING) {
+      popuplateStringAttribute(attribute);
+    }
+  }
+
+  @Override
+  public Collection<String> getFilesToGenerate() {
+    return generateFiles;
+  }
+
+  @Override
+  public Collection<BuildRuleBuilder> getRulesToGenerate() {
+    return generateRules.values();
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/testutil/ChattyAssertsTestCase.java b/src/test/java/com/google/devtools/build/lib/testutil/ChattyAssertsTestCase.java
new file mode 100644
index 0000000..f17d81e
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/testutil/ChattyAssertsTestCase.java
@@ -0,0 +1,237 @@
+// Copyright 2014 Google Inc. 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.testutil;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.Truth.assertWithMessage;
+
+import com.google.common.collect.Sets;
+import com.google.devtools.build.lib.util.BlazeClock;
+import com.google.devtools.build.lib.util.ExitCode;
+
+import junit.framework.TestCase;
+
+import java.util.Objects;
+import java.util.Set;
+
+/**
+ * Most of this stuff is copied from junit's {@link junit.framework.Assert}
+ * class, and then customized to make the error messages a bit more informative.
+ */
+public abstract class ChattyAssertsTestCase extends TestCase {
+  private long currentTestStartTime = -1;
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    currentTestStartTime = BlazeClock.instance().currentTimeMillis();
+  }
+
+  @Override
+  protected void tearDown() throws Exception {
+    JunitTestUtils.nullifyInstanceFields(this);
+    assertFalse("tearDown without setUp!", currentTestStartTime == -1);
+
+    super.tearDown();
+  }
+
+  /**
+   * Asserts that two objects are equal. If they are not
+   * an AssertionFailedError is thrown with the given message.
+   */
+  public static void assertEquals(String message, Object expected,
+      Object actual) {
+    if (Objects.equals(expected, actual)) {
+      return;
+    }
+    chattyFailNotEquals(message, expected, actual);
+  }
+
+  /**
+   * Asserts that two objects are equal. If they are not
+   * an AssertionFailedError is thrown.
+   */
+  public static void assertEquals(Object expected, Object actual) {
+    assertEquals(null, expected, actual);
+  }
+
+  /**
+   * Asserts that two Strings are equal.
+   */
+  public static void assertEquals(String message, String expected, String actual) {
+    assertWithMessage(message).that(actual).isEqualTo(expected);
+  }
+
+  /**
+   * Asserts that two Strings are equal.
+   */
+  public static void assertEquals(String expected, String actual) {
+    assertEquals(null, expected, actual);
+  }
+
+  /**
+   * Asserts that two Strings are equal considering the line separator to be \n
+   * independently of the operating system.
+   */
+  public static void assertEqualsUnifyingLineEnds(String expected, String actual) {
+    MoreAsserts.assertEqualsUnifyingLineEnds(expected, actual);
+  }
+
+  private static void chattyFailNotEquals(String message, Object expected,
+      Object actual) {
+    fail(MoreAsserts.chattyFormat(message, expected, actual));
+  }
+
+  /**
+   * Asserts that {@code e}'s exception message contains each of {@code strings}
+   * <b>surrounded by single quotation marks</b>.
+   */
+  public static void assertMessageContainsWordsWithQuotes(Exception e,
+                                                          String... strings) {
+    assertContainsWordsWithQuotes(e.getMessage(), strings);
+  }
+
+  /**
+   * Asserts that {@code message} contains each of {@code strings}
+   * <b>surrounded by single quotation marks</b>.
+   */
+  public static void assertContainsWordsWithQuotes(String message,
+                                                   String... strings) {
+    MoreAsserts.assertContainsWordsWithQuotes(message, strings);
+  }
+
+  public static void assertNonZeroExitCode(int exitCode, String stdout, String stderr) {
+    MoreAsserts.assertNonZeroExitCode(exitCode, stdout, stderr);
+  }
+
+  public static void assertZeroExitCode(int exitCode, String stdout, String stderr) {
+    assertExitCode(0, exitCode, stdout, stderr);
+  }
+
+  public static void assertExitCode(ExitCode expectedExitCode,
+      int exitCode, String stdout, String stderr) {
+    int expectedExitCodeValue = expectedExitCode.getNumericExitCode();
+    if (exitCode != expectedExitCodeValue) {
+      fail(String.format("expected exit code '%s' <%d> but exit code was <%d> and stdout was <%s> "
+              + "and stderr was <%s>",
+              expectedExitCode.name(), expectedExitCodeValue, exitCode, stdout, stderr));
+    }
+  }
+
+  public static void assertExitCode(int expectedExitCode,
+      int exitCode, String stdout, String stderr) {
+    MoreAsserts.assertExitCode(expectedExitCode, exitCode,  stdout, stderr);
+  }
+
+  public static void assertStdoutContainsString(String expected, String stdout, String stderr) {
+    MoreAsserts.assertStdoutContainsString(expected, stdout, stderr);
+  }
+
+  public static void assertStderrContainsString(String expected, String stdout, String stderr) {
+    MoreAsserts.assertStderrContainsString(expected, stdout, stderr);
+  }
+
+  public static void assertStdoutContainsRegex(String expectedRegex,
+      String stdout, String stderr) {
+    MoreAsserts.assertStdoutContainsRegex(expectedRegex, stdout, stderr);
+  }
+
+  public static void assertStderrContainsRegex(String expectedRegex,
+      String stdout, String stderr) {
+    MoreAsserts.assertStderrContainsRegex(expectedRegex, stdout, stderr);
+  }
+
+
+
+  /********************************************************************
+   *                                                                  *
+   *       Other testing utilities (unrelated to "chattiness")        *
+   *                                                                  *
+   ********************************************************************/
+
+  /**
+   * Returns the elements from the given collection in a set.
+   */
+  protected static <T> Set<T> asSet(Iterable<T> collection) {
+    return Sets.newHashSet(collection);
+  }
+
+  /**
+   * Returns the arguments given as varargs as a set.
+   */
+  @SuppressWarnings({"unchecked", "varargs"})
+  protected static <T> Set<T> asSet(T... elements) {
+    return Sets.newHashSet(elements);
+  }
+
+  /**
+   * Returns the arguments given as varargs as a set of sorted Strings.
+   */
+  protected static Set<String> asStringSet(Iterable<?> collection) {
+    return MoreAsserts.asStringSet(collection);
+  }
+
+  /**
+   * An equivalence relation for Collection, based on mapping to Set.
+   *
+   * Oft-forgotten fact: for all x in Set, y in List, !x.equals(y) even if
+   * their elements are the same.
+   */
+  protected static <T> void
+      assertSameContents(Iterable<? extends T> expected, Iterable<? extends T> actual) {
+    MoreAsserts.assertSameContents(expected, actual);
+  }
+
+  /**
+   * Asserts the presence or absence of values in the collection.
+   */
+  protected <T> void assertPresence(Iterable<T> actual, Iterable<Presence<T>> expectedPresences) {
+    for (Presence<T> expected : expectedPresences) {
+      if (expected.presence) {
+        assertThat(actual).contains(expected.value);
+      } else {
+        assertThat(actual).doesNotContain(expected.value);
+      }
+    }
+  }
+
+  /** Creates a presence information with expected value. */
+  protected static <T> Presence<T> present(T expected) {
+    return new Presence<>(expected, true);
+  }
+
+  /** Creates an absence information with expected value. */
+  protected static <T> Presence<T> absent(T expected) {
+    return new Presence<>(expected, false);
+  }
+
+  /**
+   * Combines value with the boolean presence flag.
+   *
+   * @param <T> value type
+   */
+  protected final static class Presence <T> {
+    /** wrapped value */
+    public final T value;
+    /** boolean presence flag */
+    public final boolean presence;
+
+    /** Creates a tuple of value and a boolean presence flag. */
+    Presence(T value, boolean presence) {
+      this.value = value;
+      this.presence = presence;
+    }
+  }
+
+}
diff --git a/src/test/java/com/google/devtools/build/lib/testutil/Classpath.java b/src/test/java/com/google/devtools/build/lib/testutil/Classpath.java
new file mode 100644
index 0000000..94711ac
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/testutil/Classpath.java
@@ -0,0 +1,132 @@
+// Copyright 2014 Google Inc. 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.testutil;
+
+import com.google.common.base.Preconditions;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.Enumeration;
+import java.util.LinkedHashSet;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.regex.Pattern;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+/**
+ * A helper class to find all classes on the current classpath. This is used to automatically create
+ * JUnit 3 and 4 test suites.
+ */
+final class Classpath {
+  private static final String CLASS_EXTENSION = ".class";
+
+  /**
+   * Finds all classes that live in or below the given package.
+   */
+  static Set<Class<?>> findClasses(String packageName) {
+    Set<Class<?>> result = new LinkedHashSet<>();
+    String pathPrefix = (packageName + '.').replace('.', '/');
+    for (String entryName : getClassPath()) {
+      File classPathEntry = new File(entryName);
+      if (classPathEntry.exists()) {
+        try {
+          Set<String> classNames;
+          if (classPathEntry.isDirectory()) {
+            classNames = findClassesInDirectory(classPathEntry, pathPrefix);
+          } else {
+            classNames = findClassesInJar(classPathEntry, pathPrefix);
+          }
+          for (String className : classNames) {
+            Class<?> clazz = Class.forName(className);
+            result.add(clazz);
+          }
+        } catch (IOException e) {
+          throw new AssertionError("Can't read classpath entry "
+              + entryName + ": " + e.getMessage());
+        } catch (ClassNotFoundException e) {
+          throw new AssertionError("Class not found even though it is on the classpath "
+              + entryName + ": " + e.getMessage());
+        }
+      }
+    }
+    return result;
+  }
+
+  private static Set<String> findClassesInDirectory(File classPathEntry, String pathPrefix) {
+    Set<String> result = new TreeSet<>();
+    File directory = new File(classPathEntry, pathPrefix);
+    innerFindClassesInDirectory(result, directory, pathPrefix);
+    return result;
+  }
+
+  /**
+   * Finds all classes and sub packages in the given directory that are below the given package and
+   * add them to the respective sets.
+   *
+   * @param directory Directory to inspect
+   * @param pathPrefix Prefix for the path to the classes that are requested
+   *                   (ex: {@code com/google/foo/bar})
+   */
+  private static void innerFindClassesInDirectory(Set<String> classNames, File directory,
+      String pathPrefix) {
+    Preconditions.checkArgument(pathPrefix.endsWith("/"));
+    if (directory.exists()) {
+      for (File f : directory.listFiles()) {
+        String name = f.getName();
+        if (name.endsWith(CLASS_EXTENSION)) {
+          String clzName = getClassName(pathPrefix + name);
+          classNames.add(clzName);
+        } else if (f.isDirectory()) {
+          findClassesInDirectory(f, pathPrefix + name + "/");
+        }
+      }
+    }
+  }
+
+  /**
+   * Returns a set of all classes in the jar that start with the given prefix.
+   */
+  private static Set<String> findClassesInJar(File jarFile, String pathPrefix) throws IOException {
+    Set<String> classNames = new TreeSet<>();
+    try (ZipFile zipFile = new ZipFile(jarFile)) {
+      Enumeration<? extends ZipEntry> entries = zipFile.entries();
+      while (entries.hasMoreElements()) {
+        String entryName = entries.nextElement().getName();
+        if (entryName.startsWith(pathPrefix) && entryName.endsWith(CLASS_EXTENSION)) {
+          classNames.add(getClassName(entryName));
+        }
+      }
+    }
+    return classNames;
+  }
+
+  /**
+   * Given the absolute path of a class file, return the class name.
+   */
+  private static String getClassName(String className) {
+    int classNameEnd = className.length() - CLASS_EXTENSION.length();
+    return className.substring(0, classNameEnd).replace('/', '.');
+  }
+
+  /**
+   * Gets the class path from the System Property "java.class.path" and splits
+   * it up into the individual elements.
+   */
+  private static String[] getClassPath() {
+    String classPath = System.getProperty("java.class.path");
+    String separator = System.getProperty("path.separator", ":");
+    return classPath.split(Pattern.quote(separator));
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/testutil/ClasspathSuite.java b/src/test/java/com/google/devtools/build/lib/testutil/ClasspathSuite.java
new file mode 100644
index 0000000..ee880fc
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/testutil/ClasspathSuite.java
@@ -0,0 +1,43 @@
+// Copyright 2014 Google Inc. 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.testutil;
+
+import org.junit.runners.Suite;
+import org.junit.runners.model.RunnerBuilder;
+
+import java.util.Set;
+
+/**
+ * A suite implementation that finds all JUnit 3 and 4 classes on the current classpath in or below
+ * the package of the annotated class, except classes that are annotated with {@code ClasspathSuite}
+ * or {@link CustomSuite}.
+ *
+ * <p>If you need to specify a custom test class filter or a different package prefix, then use
+ * {@link CustomSuite} instead.
+ */
+public final class ClasspathSuite extends Suite {
+
+  /**
+   * Only called reflectively. Do not use programmatically.
+   */
+  public ClasspathSuite(Class<?> klass, RunnerBuilder builder) throws Throwable {
+    super(builder, klass, getClasses(klass));
+  }
+
+  private static Class<?>[] getClasses(Class<?> klass) {
+    Set<Class<?>> result = new TestSuiteBuilder().addPackageRecursive(klass.getPackage().getName())
+        .create();
+    return result.toArray(new Class<?>[result.size()]);
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/testutil/CustomSuite.java b/src/test/java/com/google/devtools/build/lib/testutil/CustomSuite.java
new file mode 100644
index 0000000..6e3b6c5
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/testutil/CustomSuite.java
@@ -0,0 +1,53 @@
+// Copyright 2014 Google Inc. 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.testutil;
+
+import org.junit.runners.Suite;
+import org.junit.runners.model.RunnerBuilder;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.Set;
+
+/**
+ * A JUnit4 suite implementation that delegates the class finding to a {@code suite()} method on the
+ * annotated class. To be used in combination with {@link TestSuiteBuilder}.
+ */
+public final class CustomSuite extends Suite {
+
+  /**
+   * Only called reflectively. Do not use programmatically.
+   */
+  public CustomSuite(Class<?> klass, RunnerBuilder builder) throws Throwable {
+    super(builder, klass, getClasses(klass));
+  }
+
+  private static Class<?>[] getClasses(Class<?> klass) {
+    Set<Class<?>> result = evalSuite(klass);
+    return result.toArray(new Class<?>[result.size()]);
+  }
+
+  @SuppressWarnings("unchecked") // unchecked cast to a generic type
+  private static Set<Class<?>> evalSuite(Class<?> klass) {
+    try {
+      Method m = klass.getMethod("suite");
+      if (!Modifier.isStatic(m.getModifiers())) {
+        throw new IllegalStateException("suite() must be static");
+      }
+      return (Set<Class<?>>) m.invoke(null);
+    } catch (Exception e) {
+      throw new IllegalStateException(e);
+    }
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/testutil/DebuggingEventHandler.java b/src/test/java/com/google/devtools/build/lib/testutil/DebuggingEventHandler.java
new file mode 100644
index 0000000..59fe5fb
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/testutil/DebuggingEventHandler.java
@@ -0,0 +1,41 @@
+// Copyright 2014 Google Inc. 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.testutil;
+
+import com.google.devtools.build.lib.events.Event;
+import com.google.devtools.build.lib.events.EventHandler;
+
+import java.io.PrintStream;
+
+/**
+ * Prints all errors and warnings to {@link System#out}.
+ */
+public class DebuggingEventHandler implements EventHandler {
+
+  private PrintStream out;
+
+  public DebuggingEventHandler() {
+    this.out = System.out;
+  }
+
+  @Override
+  public void handle(Event e) {
+    if (e.getLocation() != null) {
+      out.println(e.getKind() + " " + e.getLocation() + ": " + e.getMessage());
+    } else {
+      out.println(e.getKind() + " " + e.getMessage());
+    }
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/testutil/FoundationTestCase.java b/src/test/java/com/google/devtools/build/lib/testutil/FoundationTestCase.java
new file mode 100644
index 0000000..5c04612
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/testutil/FoundationTestCase.java
@@ -0,0 +1,264 @@
+// Copyright 2014 Google Inc. 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.testutil;
+
+import com.google.common.io.Files;
+import com.google.devtools.build.lib.events.Event;
+import com.google.devtools.build.lib.events.EventCollector;
+import com.google.devtools.build.lib.events.EventHandler;
+import com.google.devtools.build.lib.events.EventKind;
+import com.google.devtools.build.lib.events.Reporter;
+import com.google.devtools.build.lib.util.BlazeClock;
+import com.google.devtools.build.lib.vfs.FileSystem;
+import com.google.devtools.build.lib.vfs.Path;
+import com.google.devtools.build.lib.vfs.inmemoryfs.InMemoryFileSystem;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * This is a specialization of {@link ChattyAssertsTestCase} that's useful for
+ * implementing tests of the "foundation" library.
+ */
+public abstract class FoundationTestCase extends ChattyAssertsTestCase {
+
+  protected Path rootDirectory;
+
+  protected Path outputBase;
+
+  protected Path actionOutputBase;
+
+  // May be overridden by subclasses:
+  protected Reporter reporter;
+  protected EventCollector eventCollector;
+
+  private Scratch scratch;
+
+
+  // Individual tests can opt-out of this handler if they expect an error, by
+  // calling reporter.removeHandler(failFastHandler).
+  protected static final EventHandler failFastHandler = new EventHandler() {
+      @Override
+      public void handle(Event event) {
+        if (EventKind.ERRORS.contains(event.getKind())) {
+          fail(event.toString());
+        }
+      }
+    };
+
+  protected static final EventHandler printHandler = new EventHandler() {
+      @Override
+      public void handle(Event event) {
+        System.out.println(event);
+      }
+    };
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    scratch = new Scratch(createFileSystem());
+    outputBase = scratchDir("/usr/local/google/_blaze_jrluser/FAKEMD5/");
+    rootDirectory = scratchDir("/" + TestConstants.TEST_WORKSPACE_DIRECTORY);
+    copySkylarkFilesIfExist();
+    actionOutputBase = scratchDir("/usr/local/google/_blaze_jrluser/FAKEMD5/action_out/");
+    eventCollector = new EventCollector(EventKind.ERRORS_AND_WARNINGS);
+    reporter = new Reporter(eventCollector);
+    reporter.addHandler(failFastHandler);
+  }
+
+  /*
+   * Creates the file system; override to inject FS behavior.
+   */
+  protected FileSystem createFileSystem() {
+     return new InMemoryFileSystem(BlazeClock.instance());
+  }
+
+
+  private void copySkylarkFilesIfExist() throws IOException {
+    scratchFile(rootDirectory.getRelative("devtools/blaze/rules/BUILD").getPathString());
+    scratchFile(rootDirectory.getRelative("rules/BUILD").getPathString());
+    copySkylarkFilesIfExist("devtools/blaze/rules/staging", "devtools/blaze/rules");
+    copySkylarkFilesIfExist("devtools/blaze/bazel/base_workspace/tools/build_rules", "rules");
+  }
+
+  private void copySkylarkFilesIfExist(String from, String to) throws IOException {
+    File rulesDir = new File(from);
+    if (rulesDir.exists() && rulesDir.isDirectory()) {
+      for (String fileName : rulesDir.list()) {
+        File file = new File(from + "/" + fileName);
+        if (file.isFile() && fileName.endsWith(".bzl")) {
+          String context = loadFile(file);
+          Path path = rootDirectory.getRelative(to + "/" + fileName);
+          if (path.exists()) {
+            overwriteScratchFile(path.getPathString(), context);
+          } else {
+            scratchFile(path.getPathString(), context);
+          }
+        }
+      }
+    }
+  }
+
+  @Override
+  protected void tearDown() throws Exception {
+    Thread.interrupted(); // Clear any interrupt pending against this thread,
+                          // so that we don't cause later tests to fail.
+
+    super.tearDown();
+  }
+
+  /**
+   * A scratch filesystem that is completely in-memory. Since this file system
+   * is "cached" in a private (but *not* static) field in the test class,
+   * each testFoo method in junit sees a fresh filesystem.
+   */
+  protected FileSystem scratchFS() {
+    return scratch.getFileSystem();
+  }
+
+  /**
+   * Create a scratch file in the scratch filesystem, with the given pathName,
+   * consisting of a set of lines. The method returns a Path instance for the
+   * scratch file.
+   */
+  protected Path scratchFile(String pathName, String... lines)
+      throws IOException {
+    return scratch.file(pathName, lines);
+  }
+
+  /**
+   * Like {@code scratchFile}, but the file is first deleted if it already
+   * exists.
+   */
+  protected Path overwriteScratchFile(String pathName, String... lines) throws IOException {
+    return scratch.overwriteFile(pathName, lines);
+  }
+
+  /**
+   * Deletes the specified scratch file, using the same specification as {@link Path#delete}.
+   */
+  protected boolean deleteScratchFile(String pathName) throws IOException {
+    return scratch.deleteFile(pathName);
+  }
+
+  /**
+   * Create a scratch file in the given filesystem, with the given pathName,
+   * consisting of a set of lines. The method returns a Path instance for the
+   * scratch file.
+   */
+  protected Path scratchFile(FileSystem fs, String pathName, String... lines)
+      throws IOException {
+    return scratch.file(fs, pathName, lines);
+  }
+
+  /**
+   * Create a scratch file in the given filesystem, with the given pathName,
+   * consisting of a set of lines. The method returns a Path instance for the
+   * scratch file.
+   */
+  protected Path scratchFile(FileSystem fs, String pathName, byte[] content)
+      throws IOException {
+    return scratch.file(fs, pathName, content);
+  }
+
+  /**
+   * Create a directory in the scratch filesystem, with the given path name.
+   */
+  public Path scratchDir(String pathName) throws IOException {
+    return scratch.dir(pathName);
+  }
+
+  /**
+   * If "expectedSuffix" is not a suffix of "actual", fails with an informative
+   * assertion.
+   */
+  protected void assertEndsWith(String expectedSuffix, String actual) {
+    if (!actual.endsWith(expectedSuffix)) {
+      fail("\"" + actual + "\" does not end with "
+           + "\"" + expectedSuffix + "\"");
+    }
+  }
+
+  /**
+   * If "expectedPrefix" is not a prefix of "actual", fails with an informative
+   * assertion.
+   */
+  protected void assertStartsWith(String expectedPrefix, String actual) {
+    if (!actual.startsWith(expectedPrefix)) {
+      fail("\"" + actual + "\" does not start with "
+           + "\"" + expectedPrefix + "\"");
+    }
+  }
+
+  // Mix-in assertions:
+
+  protected void assertNoEvents() {
+    JunitTestUtils.assertNoEvents(eventCollector);
+  }
+
+  protected Event assertContainsEvent(String expectedMessage) {
+    return JunitTestUtils.assertContainsEvent(eventCollector,
+                                              expectedMessage);
+  }
+
+  protected Event assertContainsEvent(String expectedMessage, Set<EventKind> kinds) {
+    return JunitTestUtils.assertContainsEvent(eventCollector,
+                                              expectedMessage,
+                                              kinds);
+  }
+
+  protected void assertContainsEventWithFrequency(String expectedMessage,
+      int expectedFrequency) {
+    JunitTestUtils.assertContainsEventWithFrequency(eventCollector, expectedMessage,
+        expectedFrequency);
+  }
+
+  protected void assertDoesNotContainEvent(String expectedMessage) {
+    JunitTestUtils.assertDoesNotContainEvent(eventCollector,
+                                             expectedMessage);
+  }
+
+  protected Event assertContainsEventWithWordsInQuotes(String... words) {
+    return JunitTestUtils.assertContainsEventWithWordsInQuotes(
+        eventCollector, words);
+  }
+
+  protected void assertContainsEventsInOrder(String... expectedMessages) {
+    JunitTestUtils.assertContainsEventsInOrder(eventCollector, expectedMessages);
+  }
+
+  @SuppressWarnings({"unchecked", "varargs"})
+  protected static <T> void assertContainsSublist(List<T> arguments,
+                                                  T... expectedSublist) {
+    JunitTestUtils.assertContainsSublist(arguments, expectedSublist);
+  }
+
+  @SuppressWarnings({"unchecked", "varargs"})
+  protected static <T> void assertDoesNotContainSublist(List<T> arguments,
+                                                        T... expectedSublist) {
+    JunitTestUtils.assertDoesNotContainSublist(arguments, expectedSublist);
+  }
+
+  protected static <T> void assertContainsSubset(Iterable<T> arguments,
+                                                 Iterable<T> expectedSubset) {
+    JunitTestUtils.assertContainsSubset(arguments, expectedSubset);
+  }
+
+  protected String loadFile(File file) throws IOException {
+    return Files.toString(file, Charset.defaultCharset());
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/testutil/JunitTestUtils.java b/src/test/java/com/google/devtools/build/lib/testutil/JunitTestUtils.java
new file mode 100644
index 0000000..efe1599
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/testutil/JunitTestUtils.java
@@ -0,0 +1,310 @@
+// Copyright 2014 Google Inc. 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.testutil;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.Truth.assertWithMessage;
+
+import com.google.common.base.Function;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Sets;
+import com.google.devtools.build.lib.events.Event;
+import com.google.devtools.build.lib.events.EventCollector;
+import com.google.devtools.build.lib.events.EventKind;
+import com.google.devtools.build.lib.util.Pair;
+
+import junit.framework.TestCase;
+
+import java.lang.reflect.AccessibleObject;
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * This class contains a utility method {@link #nullifyInstanceFields(Object)}
+ * for setting all fields in an instance to {@code null}. This is needed for
+ * junit {@code TestCase} instances that keep expensive objects in fields.
+ * Basically junit holds onto the instances
+ * even after the test methods have run, and it creates one such instance
+ * per {@code testFoo} method.
+ */
+public class JunitTestUtils {
+
+  public static void nullifyInstanceFields(Object instance)
+      throws IllegalAccessException {
+    /**
+     * We're cleaning up this test case instance by assigning null pointers
+     * to all fields to reduce the memory overhead of test case instances
+     * staying around after the test methods have been executed. This is a
+     * bug in junit.
+     */
+    List<Field> instanceFields = new ArrayList<>();
+    for (Class<?> clazz = instance.getClass();
+         !clazz.equals(TestCase.class) && !clazz.equals(Object.class);
+         clazz = clazz.getSuperclass()) {
+      for (Field field : clazz.getDeclaredFields()) {
+        if (Modifier.isStatic(field.getModifiers())) {
+          continue;
+        }
+        if (field.getType().isPrimitive()) {
+          continue;
+        }
+        if (Modifier.isFinal(field.getModifiers())) {
+          String msg = "Please make field \"" + field + "\" non-final, or, if " +
+                       "it's very simple and truly immutable and not too " +
+                       "big, make it static.";
+          throw new AssertionError(msg);
+        }
+        instanceFields.add(field);
+      }
+    }
+    // Run setAccessible for efficiency
+    AccessibleObject.setAccessible(instanceFields.toArray(new Field[0]), true);
+    for (Field field : instanceFields) {
+      field.set(instance, null);
+    }
+  }
+
+  /********************************************************************
+   *                                                                  *
+   *                         "Mix-in methods"                         *
+   *                                                                  *
+   ********************************************************************/
+
+  // Java doesn't support mix-ins, but we need them in our tests so that we can
+  // inherit a bunch of useful methods, e.g. assertions over an EventCollector.
+  // We do this by hand, by delegating from instance methods in each TestCase
+  // to the static methods below.
+
+  /**
+   * If the specified EventCollector contains any events, an informative
+   * assertion fails in the context of the specified TestCase.
+   */
+  public static void assertNoEvents(Iterable<Event> eventCollector) {
+    String eventsString = eventsToString(eventCollector);
+    assertThat(eventsString).isEmpty();
+  }
+
+  /**
+   * If the specified EventCollector contains an unexpected number of events, an informative
+   * assertion fails in the context of the specified TestCase.
+   */
+  public static void assertEventCount(int expectedCount, EventCollector eventCollector) {
+    assertWithMessage(eventsToString(eventCollector))
+        .that(eventCollector.count()).isEqualTo(expectedCount);
+  }
+
+  /**
+   * If the specified EventCollector does not contain an event which has
+   * 'expectedEvent' as a substring, an informative assertion fails. Otherwise
+   * the matching event is returned.
+   */
+  public static Event assertContainsEvent(Iterable<Event> eventCollector,
+      String expectedEvent) {
+    return assertContainsEvent(eventCollector, expectedEvent, EventKind.ALL_EVENTS);
+  }
+
+  /**
+   * If the specified EventCollector does not contain an event of a kind of 'kinds' which has
+   * 'expectedEvent' as a substring, an informative assertion fails. Otherwise
+   * the matching event is returned.
+   */
+  public static Event assertContainsEvent(Iterable<Event> eventCollector,
+                                          String expectedEvent,
+                                          Set<EventKind> kinds) {
+    for (Event event : eventCollector) {
+      if (event.getMessage().contains(expectedEvent) && kinds.contains(event.getKind())) {
+        return event;
+      }
+    }
+    String eventsString = eventsToString(eventCollector);
+    assertWithMessage("Event '" + expectedEvent + "' not found"
+        + (eventsString.length() == 0 ? "" : ("; found these though:" + eventsString)))
+        .that(false).isTrue();
+    return null; // unreachable
+  }
+
+  /**
+   * If the specified EventCollector contains an event which has
+   * 'expectedEvent' as a substring, an informative assertion fails.
+   */
+  public static void assertDoesNotContainEvent(Iterable<Event> eventCollector,
+                                          String expectedEvent) {
+    for (Event event : eventCollector) {
+      assertWithMessage("Unexpected string '" + expectedEvent + "' matched following event:\n"
+          + event.getMessage()).that(event.getMessage()).doesNotContain(expectedEvent);
+    }
+  }
+
+  /**
+   * If the specified EventCollector does not contain an event which has
+   * each of {@code words} surrounded by single quotes as a substring, an
+   * informative assertion fails.  Otherwise the matching event is returned.
+   */
+  public static Event assertContainsEventWithWordsInQuotes(
+      Iterable<Event> eventCollector,
+      String... words) {
+    for (Event event : eventCollector) {
+      boolean found = true;
+      for (String word : words) {
+        if (!event.getMessage().contains("'" + word + "'")) {
+          found = false;
+          break;
+        }
+      }
+      if (found) {
+        return event;
+      }
+    }
+    String eventsString = eventsToString(eventCollector);
+    assertWithMessage("Event containing words " + Arrays.toString(words) + " in "
+        + "single quotes not found"
+        + (eventsString.length() == 0 ? "" : ("; found these though:" + eventsString)))
+        .that(false).isTrue();
+    return null; // unreachable
+  }
+
+  /**
+   * Returns a string consisting of each event in the specified collector,
+   * preceded by a newline.
+   */
+  private static String eventsToString(Iterable<Event> eventCollector) {
+    StringBuilder buf = new StringBuilder();
+    eventLoop: for (Event event : eventCollector) {
+      for (String ignoredPrefix : TestConstants.IGNORED_MESSAGE_PREFIXES) {
+        if (event.getMessage().startsWith(ignoredPrefix)) {
+          continue eventLoop;
+        }
+      }
+      buf.append('\n').append(event);
+    }
+    return buf.toString();
+  }
+
+  /**
+   * If "expectedSublist" is not a sublist of "arguments", an informative
+   * assertion is failed in the context of the specified TestCase.
+   *
+   * Argument order mnemonic: assert(X)ContainsSublist(Y).
+   */
+  @SuppressWarnings({"unchecked", "varargs"})
+  public static <T> void assertContainsSublist(List<T> arguments, T... expectedSublist) {
+    List<T> sublist = Arrays.asList(expectedSublist);
+    try {
+      assertThat(Collections.indexOfSubList(arguments, sublist)).isNotEqualTo(-1);
+    } catch (AssertionError e) {
+      throw new AssertionError("Did not find " + sublist + " as a sublist of " + arguments, e);
+    }
+  }
+
+  /**
+   * If "expectedSublist" is a sublist of "arguments", an informative
+   * assertion is failed in the context of the specified TestCase.
+   *
+   * Argument order mnemonic: assert(X)DoesNotContainSublist(Y).
+   */
+  @SuppressWarnings({"unchecked", "varargs"})
+  public static <T> void assertDoesNotContainSublist(List<T> arguments, T... expectedSublist) {
+    List<T> sublist = Arrays.asList(expectedSublist);
+    try {
+      assertThat(Collections.indexOfSubList(arguments, sublist)).isEqualTo(-1);
+    } catch (AssertionError e) {
+      throw new AssertionError("Found " + sublist + " as a sublist of " + arguments, e);
+    }
+  }
+
+  /**
+   * If "arguments" does not contain "expectedSubset" as a subset, an
+   * informative assertion is failed in the context of the specified TestCase.
+   *
+   * Argument order mnemonic: assert(X)ContainsSubset(Y).
+   */
+  public static <T> void assertContainsSubset(Iterable<T> arguments,
+                                              Iterable<T> expectedSubset) {
+    Set<T> argumentsSet = arguments instanceof Set<?>
+        ? (Set<T>) arguments
+        : Sets.newHashSet(arguments);
+
+    for (T x : expectedSubset) {
+      assertWithMessage("assertContainsSubset failed: did not find element " + x
+          + "\nExpected subset = " + expectedSubset + "\nArguments = " + arguments)
+          .that(argumentsSet).contains(x);
+    }
+  }
+
+  /**
+   * Check to see if each element of expectedMessages is the beginning of a message
+   * in eventCollector, in order, as in {@link #containsSublistWithGapsAndEqualityChecker}.
+   * If not, an informative assertion is failed
+   */
+  protected static void assertContainsEventsInOrder(Iterable<Event> eventCollector,
+      String... expectedMessages) {
+    String failure = containsSublistWithGapsAndEqualityChecker(
+        ImmutableList.copyOf(eventCollector),
+        new Function<Pair<Event, String>, Boolean> () {
+      @Override
+      public Boolean apply(Pair<Event, String> pair) {
+        return pair.first.getMessage().contains(pair.second);
+      }
+    }, expectedMessages);
+
+    String eventsString = eventsToString(eventCollector);
+    assertWithMessage("Event '" + failure + "' not found in proper order"
+        + (eventsString.length() == 0 ? "" : ("; found these though:" + eventsString)))
+        .that(failure).isNull();
+  }
+
+  /**
+   * Check to see if each element of expectedSublist is in arguments, according to
+   * the equalityChecker, in the same order as in expectedSublist (although with
+   * other interspersed elements in arguments allowed).
+   * @param equalityChecker function that takes a Pair<S, T> element and returns true
+   * if the elements of the pair are equal by its lights.
+   * @return first element not in arguments in order, or null if success.
+   */
+  @SuppressWarnings({"unchecked"})
+  protected static <S, T> T containsSublistWithGapsAndEqualityChecker(List<S> arguments,
+      Function<Pair<S, T>, Boolean> equalityChecker, T... expectedSublist) {
+    Iterator<S> iter = arguments.iterator();
+    outerLoop:
+    for (T expected : expectedSublist) {
+      while (iter.hasNext()) {
+        S actual = iter.next();
+        if (equalityChecker.apply(Pair.of(actual, expected))) {
+          continue outerLoop;
+        }
+      }
+      return expected;
+    }
+    return null;
+  }
+
+  public static List<Event> assertContainsEventWithFrequency(Iterable<Event> events,
+      String expectedMessage, int expectedFrequency) {
+    ImmutableList.Builder<Event> builder = ImmutableList.builder();
+    for (Event event : events) {
+      if (event.getMessage().contains(expectedMessage)) {
+        builder.add(event);
+      }
+    }
+    List<Event> foundEvents = builder.build();
+    assertWithMessage(foundEvents.toString()).that(foundEvents).hasSize(expectedFrequency);
+    return foundEvents;
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/testutil/ManualClock.java b/src/test/java/com/google/devtools/build/lib/testutil/ManualClock.java
new file mode 100644
index 0000000..d4f6058
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/testutil/ManualClock.java
@@ -0,0 +1,40 @@
+// Copyright 2014 Google Inc. 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.testutil;
+
+import com.google.devtools.build.lib.util.Clock;
+
+import java.util.concurrent.TimeUnit;
+
+/**
+ * A fake clock for testing.
+ */
+public final class ManualClock implements Clock {
+  private long currentTimeMillis = 0L;
+
+  @Override
+  public long currentTimeMillis() {
+    return currentTimeMillis;
+  }
+
+  @Override
+  public long nanoTime() {
+    return TimeUnit.MILLISECONDS.toNanos(currentTimeMillis);
+  }
+
+  public void advanceMillis(long time) {
+    currentTimeMillis += time;
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/testutil/MoreAsserts.java b/src/test/java/com/google/devtools/build/lib/testutil/MoreAsserts.java
new file mode 100644
index 0000000..9224b8a
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/testutil/MoreAsserts.java
@@ -0,0 +1,319 @@
+// Copyright 2014 Google Inc. 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.testutil;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.Truth.assertWithMessage;
+import static com.google.common.truth.Truth.assert_;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.base.Joiner;
+import com.google.common.base.Predicate;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+
+import java.lang.ref.Reference;
+import java.lang.reflect.Field;
+import java.util.Comparator;
+import java.util.Map;
+import java.util.Queue;
+import java.util.Set;
+import java.util.regex.Pattern;
+
+/**
+ * A helper class for tests providing a simple interface for asserts.
+ */
+public class MoreAsserts {
+
+  public static void assertContainsRegex(String regex, String actual) {
+    assertThat(actual).containsMatch(regex);
+  }
+
+  public static void assertContainsRegex(String msg, String regex, String actual) {
+    assertWithMessage(msg).that(actual).containsMatch(regex);
+  }
+
+  public static void assertNotContainsRegex(String regex, String actual) {
+    assertThat(actual).doesNotContainMatch(regex);
+  }
+
+  public static void assertNotContainsRegex(String msg, String regex, String actual) {
+    assertWithMessage(msg).that(actual).doesNotContainMatch(regex);
+  }
+
+  public static void assertMatchesRegex(String regex, String actual) {
+    assertThat(actual).matches(regex);
+  }
+
+  public static void assertMatchesRegex(String msg, String regex, String actual) {
+    assertWithMessage(msg).that(actual).matches(regex);
+  }
+
+  public static void assertNotMatchesRegex(String regex, String actual) {
+    assertThat(actual).doesNotMatch(regex);
+  }
+
+  public static <T> void assertEquals(T expected, T actual, Comparator<T> comp) {
+    assertThat(comp.compare(expected, actual)).isEqualTo(0);
+  }
+
+  public static <T> void assertContentsAnyOrder(
+      Iterable<? extends T> expected, Iterable<? extends T> actual,
+      Comparator<? super T> comp) {
+    assertThat(actual).hasSize(Iterables.size(expected));
+    int i = 0;
+    for (T e : expected) {
+      for (T a : actual) {
+        if (comp.compare(e, a) == 0) {
+          i++;
+        }
+      }
+    }
+    assertThat(actual).hasSize(i);
+  }
+
+  public static void assertGreaterThanOrEqual(long target, long actual) {
+    assertThat(actual).isAtLeast(target);
+  }
+
+  public static void assertGreaterThanOrEqual(String msg, long target, long actual) {
+    assertWithMessage(msg).that(actual).isAtLeast(target);
+  }
+
+  public static void assertGreaterThan(long target, long actual) {
+    assertThat(actual).isGreaterThan(target);
+  }
+
+  public static void assertGreaterThan(String msg, long target, long actual) {
+    assertWithMessage(msg).that(actual).isGreaterThan(target);
+  }
+
+  public static void assertLessThanOrEqual(long target, long actual) {
+    assertThat(actual).isAtMost(target);
+  }
+
+  public static void assertLessThanOrEqual(String msg, long target, long actual) {
+    assertWithMessage(msg).that(actual).isAtMost(target);
+  }
+
+  public static void assertLessThan(long target, long actual) {
+    assertThat(actual).isLessThan(target);
+  }
+
+  public static void assertLessThan(String msg, long target, long actual) {
+    assertWithMessage(msg).that(actual).isLessThan(target);
+  }
+
+  public static void assertEndsWith(String ending, String actual) {
+    assertThat(actual).endsWith(ending);
+  }
+
+  public static void assertStartsWith(String prefix, String actual) {
+    assertThat(actual).startsWith(prefix);
+  }
+
+  /**
+   * Scans if an instance of given class is strongly reachable from a given
+   * object.
+   * <p>Runs breadth-first search in object reachability graph to check if
+   * an instance of <code>clz</code> can be reached.
+   * <strong>Note:</strong> This method can take a long time if analyzed
+   * data structure spans across large part of heap and may need a lot of
+   * memory.
+   *
+   * @param start object to start the search from
+   * @param clazz class to look for
+   */
+  public static void assertInstanceOfNotReachable(
+      Object start, final Class<?> clazz) {
+    Predicate<Object> p = new Predicate<Object>() {
+      @Override
+      public boolean apply(Object obj) {
+        return clazz.isAssignableFrom(obj.getClass());
+      }
+    };
+    if (isRetained(p, start)) {
+      assert_().fail("Found an instance of " + clazz.getCanonicalName() +
+          " reachable from " + start.toString());
+    }
+  }
+
+  private static final Field NON_STRONG_REF;
+
+  static {
+    try {
+      NON_STRONG_REF = Reference.class.getDeclaredField("referent");
+    } catch (SecurityException e) {
+      throw new RuntimeException(e);
+    } catch (NoSuchFieldException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  static final Predicate<Field> ALL_STRONG_REFS = new Predicate<Field>() {
+    @Override
+    public boolean apply(Field field) {
+      return NON_STRONG_REF.equals(field);
+    }
+  };
+
+  private static boolean isRetained(Predicate<Object> predicate, Object start) {
+    Map<Object, Object> visited = Maps.newIdentityHashMap();
+    visited.put(start, start);
+    Queue<Object> toScan = Lists.newLinkedList();
+    toScan.add(start);
+
+    while (!toScan.isEmpty()) {
+      Object current = toScan.poll();
+      if (current.getClass().isArray()) {
+        if (current.getClass().getComponentType().isPrimitive()) {
+          continue;
+        }
+
+        for (Object ref : (Object[]) current) {
+          if (ref != null) {
+            if (predicate.apply(ref)) {
+              return true;
+            }
+            if (visited.put(ref, ref) == null) {
+              toScan.add(ref);
+            }
+          }
+        }
+      } else {
+        // iterate *all* fields (getFields() returns only accessible ones)
+        for (Class<?> clazz = current.getClass(); clazz != null;
+            clazz = clazz.getSuperclass()) {
+          for (Field f : clazz.getDeclaredFields()) {
+            if (f.getType().isPrimitive() || ALL_STRONG_REFS.apply(f)) {
+              continue;
+            }
+
+            f.setAccessible(true);
+            try {
+              Object ref = f.get(current);
+              if (ref != null) {
+                if (predicate.apply(ref)) {
+                  return true;
+                }
+                if (visited.put(ref, ref) == null) {
+                  toScan.add(ref);
+                }
+              }
+            } catch (IllegalArgumentException e) {
+              throw new IllegalStateException("Error when scanning the heap", e);
+            } catch (IllegalAccessException e) {
+              throw new IllegalStateException("Error when scanning the heap", e);
+            }
+          }
+        }
+      }
+    }
+    return false;
+  }
+
+  private static String getClassDescription(Object object) {
+    return object == null
+        ? "null"
+        : ("instance of " + object.getClass().getName());
+  }
+
+  public static String chattyFormat(String message, Object expected, Object actual) {
+    String expectedClass = getClassDescription(expected);
+    String actualClass = getClassDescription(actual);
+
+    return Joiner.on('\n').join((message != null) ? ("\n" + message) : "",
+        "  expected " + expectedClass + ": <" + expected + ">",
+        "  but was " + actualClass + ": <" + actual + ">");
+  }
+
+  public static void assertEqualsUnifyingLineEnds(String expected, String actual) {
+    if (actual != null) {
+      actual = actual.replaceAll(System.getProperty("line.separator"), "\n");
+    }
+    assertThat(actual).isEqualTo(expected);
+  }
+
+  public static void assertContainsWordsWithQuotes(String message,
+      String... strings) {
+    for (String string : strings) {
+      assertTrue(message + " should contain '" + string + "' (with quotes)",
+          message.contains("'" + string + "'"));
+    }
+  }
+
+  public static void assertNonZeroExitCode(int exitCode, String stdout, String stderr) {
+    if (exitCode == 0) {
+      fail("expected non-zero exit code but exit code was 0 and stdout was <"
+          + stdout + "> and stderr was <" + stderr + ">");
+    }
+  }
+
+  public static void assertExitCode(int expectedExitCode,
+      int exitCode, String stdout, String stderr) {
+    if (exitCode != expectedExitCode) {
+      fail(String.format("expected exit code <%d> but exit code was <%d> and stdout was <%s> "
+          + "and stderr was <%s>", expectedExitCode, exitCode, stdout, stderr));
+    }
+  }
+
+  public static void assertStdoutContainsString(String expected, String stdout, String stderr) {
+    if (!stdout.contains(expected)) {
+      fail("expected stdout to contain string <" + expected + "> but stdout was <"
+          + stdout + "> and stderr was <" + stderr + ">");
+    }
+  }
+
+  public static void assertStderrContainsString(String expected, String stdout, String stderr) {
+    if (!stderr.contains(expected)) {
+      fail("expected stderr to contain string <" + expected + "> but stdout was <"
+          + stdout + "> and stderr was <" + stderr + ">");
+    }
+  }
+
+  public static void assertStdoutContainsRegex(String expectedRegex,
+      String stdout, String stderr) {
+    if (!Pattern.compile(expectedRegex).matcher(stdout).find()) {
+      fail("expected stdout to contain regex <" + expectedRegex + "> but stdout was <"
+          + stdout + "> and stderr was <" + stderr + ">");
+    }
+  }
+
+  public static void assertStderrContainsRegex(String expectedRegex,
+      String stdout, String stderr) {
+    if (!Pattern.compile(expectedRegex).matcher(stderr).find()) {
+      fail("expected stderr to contain regex <" + expectedRegex + "> but stdout was <"
+          + stdout + "> and stderr was <" + stderr + ">");
+    }
+  }
+
+  public static Set<String> asStringSet(Iterable<?> collection) {
+    Set<String> set = Sets.newTreeSet();
+    for (Object o : collection) {
+      set.add("\"" + String.valueOf(o) + "\"");
+    }
+    return set;
+  }
+
+  public static <T> void
+  assertSameContents(Iterable<? extends T> expected, Iterable<? extends T> actual) {
+    if (!Sets.newHashSet(expected).equals(Sets.newHashSet(actual))) {
+      fail("got string set: " + asStringSet(actual).toString()
+          + "\nwant: " + asStringSet(expected).toString());
+    }
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/testutil/Scratch.java b/src/test/java/com/google/devtools/build/lib/testutil/Scratch.java
new file mode 100644
index 0000000..229d2a7
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/testutil/Scratch.java
@@ -0,0 +1,150 @@
+// Copyright 2014 Google Inc. 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.testutil;
+
+import com.google.devtools.build.lib.util.BlazeClock;
+import com.google.devtools.build.lib.vfs.FileSystem;
+import com.google.devtools.build.lib.vfs.FileSystemUtils;
+import com.google.devtools.build.lib.vfs.Path;
+import com.google.devtools.build.lib.vfs.inmemoryfs.InMemoryFileSystem;
+
+import java.io.IOException;
+
+/**
+ * Allow tests to easily manage scratch files in a FileSystem.
+ */
+public final class Scratch {
+
+  private final FileSystem fileSystem;
+
+  /**
+   * Create a new ScratchFileSystem using the {@link InMemoryFileSystem}
+   */
+  public Scratch() {
+    this(new InMemoryFileSystem(BlazeClock.instance()));
+  }
+
+  /**
+   * Create a new ScratchFileSystem using the supplied FileSystem.
+   */
+  public Scratch(FileSystem fileSystem) {
+    this.fileSystem = fileSystem;
+  }
+
+  /**
+   * Returns the FileSystem in use.
+   */
+  public FileSystem getFileSystem() {
+    return fileSystem;
+  }
+
+  /**
+   * Create a directory in the scratch filesystem, with the given path name.
+   */
+  public Path dir(String pathName) throws IOException {
+    Path dir = getFileSystem().getPath(pathName);
+    if (!dir.exists()) {
+      FileSystemUtils.createDirectoryAndParents(dir);
+    }
+    if (!dir.isDirectory()) {
+      throw new IOException("Exists, but is not a directory: " + pathName);
+    }
+    return dir;
+  }
+
+  /**
+   * Create a scratch file in the scratch filesystem, with the given pathName,
+   * consisting of a set of lines. The method returns a Path instance for the
+   * scratch file.
+   */
+  public Path file(String pathName, String... lines)
+      throws IOException {
+    Path newFile = file(getFileSystem(), pathName, lines);
+    newFile.setLastModifiedTime(-1L);
+    return newFile;
+  }
+
+  /**
+   * Like {@code scratchFile}, but the file is first deleted if it already
+   * exists.
+   */
+  public Path overwriteFile(String pathName, String... lines) throws IOException {
+    Path oldFile = getFileSystem().getPath(pathName);
+    long newMTime = oldFile.exists() ? oldFile.getLastModifiedTime() + 1 : -1;
+    oldFile.delete();
+    Path newFile = file(getFileSystem(), pathName, lines);
+    newFile.setLastModifiedTime(newMTime);
+    return newFile;
+  }
+
+  /**
+   * Deletes the specified scratch file, using the same specification as {@link Path#delete}.
+   */
+  public boolean deleteFile(String pathName) throws IOException {
+    Path file = getFileSystem().getPath(pathName);
+    return file.delete();
+  }
+
+  /**
+   * Create a scratch file in the given filesystem, with the given pathName,
+   * consisting of a set of lines. The method returns a Path instance for the
+   * scratch file.
+   */
+  public Path file(FileSystem fs, String pathName, String... lines)
+      throws IOException {
+    Path file = newScratchFile(fs, pathName);
+    FileSystemUtils.writeContentAsLatin1(file, linesAsString(lines));
+    return file;
+  }
+
+  /**
+   * Create a scratch file in the given filesystem, with the given pathName,
+   * consisting of a set of lines. The method returns a Path instance for the
+   * scratch file.
+   */
+  public Path file(FileSystem fs, String pathName, byte[] content)
+      throws IOException {
+    Path file = newScratchFile(fs, pathName);
+    FileSystemUtils.writeContent(file, content);
+    return file;
+  }
+
+  /** Creates a new scratch file, ensuring parents exist. */
+  private Path newScratchFile(FileSystem fs, String pathName) throws IOException {
+    Path file = fs.getPath(pathName);
+    Path parentDir = file.getParentDirectory();
+    if (!parentDir.exists()) {
+      FileSystemUtils.createDirectoryAndParents(parentDir);
+    }
+    if (file.exists()) {
+      throw new IOException("Could not create scratch file (file exists) "
+          + pathName);
+    }
+    return file;
+  }
+
+  /**
+   * Converts the lines into a String with linebreaks. Useful for creating
+   * in-memory input for a file, for example.
+   */
+  private static String linesAsString(String... lines) {
+    StringBuilder builder = new StringBuilder();
+    for (String line : lines) {
+      builder.append(line);
+      builder.append('\n');
+    }
+    return builder.toString();
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/testutil/Suite.java b/src/test/java/com/google/devtools/build/lib/testutil/Suite.java
new file mode 100644
index 0000000..43590d4
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/testutil/Suite.java
@@ -0,0 +1,86 @@
+// Copyright 2014 Google Inc. 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.testutil;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+/**
+ * Test annotations used to select which tests to run in a given situation.
+ */
+public enum Suite {
+
+  /**
+   * It's so blazingly fast and lightweight we run it whenever we make any
+   * build.lib change. This size is the default.
+   */
+  SMALL_TESTS,
+
+  /**
+   * It's a bit too slow to run all the time, but it still tests some
+   * unit of functionality. May run external commands such as gcc, for example.
+   */
+  MEDIUM_TESTS,
+
+  /**
+   * I don't even want to think about running this one after every edit,
+   * but I don't mind if the continuous build runs it, and I'm happy to have
+   * it before making a release.
+   */
+  LARGE_TESTS,
+
+  /**
+   * These tests take a long time. They should only ever be run manually and probably from their
+   * own Blaze test target.
+   */
+  ENORMOUS_TESTS;
+
+  /**
+   * Given a class, determine the test size.
+   */
+  public static Suite getSize(Class<?> clazz) {
+    return getAnnotationElementOrDefault(clazz, "size");
+  }
+
+  /**
+   * Given a class, determine the suite it belongs to.
+   */
+  public static String getSuiteName(Class<?> clazz) {
+    return getAnnotationElementOrDefault(clazz, "suite");
+  }
+
+  /**
+   * Given a class, determine if it is flaky.
+   */
+  public static boolean isFlaky(Class<?> clazz) {
+    return getAnnotationElementOrDefault(clazz, "flaky");
+  }
+
+  /**
+   * Returns the value of the given element in the {@link TestSpec} annotation of the given class,
+   * or the default value of that element if the class doesn't have a {@link TestSpec} annotation.
+   */
+  @SuppressWarnings("unchecked")
+  private static <T> T getAnnotationElementOrDefault(Class<?> clazz, String elementName) {
+    TestSpec spec = clazz.getAnnotation(TestSpec.class);
+    try {
+      Method method = TestSpec.class.getMethod(elementName);
+      return spec != null ? (T) method.invoke(spec) : (T) method.getDefaultValue();
+    } catch (NoSuchMethodException e) {
+      throw new IllegalStateException("no such element " + elementName, e);
+    } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+      throw new IllegalStateException("can't invoke accessor for element " + elementName, e);
+    }
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/testutil/TestConstants.java b/src/test/java/com/google/devtools/build/lib/testutil/TestConstants.java
new file mode 100644
index 0000000..d9552ad
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/testutil/TestConstants.java
@@ -0,0 +1,53 @@
+// Copyright 2014 Google Inc. 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.testutil;
+
+import com.google.common.collect.ImmutableList;
+
+/**
+ * Various constants required by the tests.
+ */
+public class TestConstants {
+  private TestConstants() {
+  }
+
+  /**
+   * A list of all embedded binaries that go into the regular Bazel binary.
+   */
+  public static final ImmutableList<String> EMBEDDED_TOOLS = ImmutableList.of(
+      "build-runfiles",
+      "process-wrapper",
+      "build_interface_so");
+
+
+  /**
+   * Location in the bazel repo where embedded binaries come from.
+   */
+  public static final String EMBEDDED_SCRIPTS_PATH = "DOES-NOT-WORK-YET";
+
+  /**
+   * Directory where we can find bazel's Java tests, relative to a test's runfiles directory.
+   */
+  public static final String JAVATESTS_ROOT = "src/test/java/";
+
+  /**
+   * The directory in InMemoryFileSystem where workspaces created during unit tests reside.
+   */
+  public static final String TEST_WORKSPACE_DIRECTORY = "bazel";
+
+  public static final String TEST_RULE_CLASS_PROVIDER =
+      "com.google.devtools.build.lib.bazel.rules.BazelRuleClassProvider";
+  public static final ImmutableList<String> IGNORED_MESSAGE_PREFIXES = ImmutableList.<String>of();
+}
diff --git a/src/test/java/com/google/devtools/build/lib/testutil/TestFileOutErr.java b/src/test/java/com/google/devtools/build/lib/testutil/TestFileOutErr.java
new file mode 100644
index 0000000..6f0494f
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/testutil/TestFileOutErr.java
@@ -0,0 +1,127 @@
+// Copyright 2014 Google Inc. 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.testutil;
+
+import com.google.devtools.build.lib.util.io.FileOutErr;
+import com.google.devtools.build.lib.util.io.RecordingOutErr;
+import com.google.devtools.build.lib.vfs.Path;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+
+/**
+ * An implementation of the FileOutErr that doesn't use a file.
+ * This is useful for tests, as they often test the action directly
+ * and would otherwise have to create files on the vfs.
+ */
+public class TestFileOutErr extends FileOutErr {
+
+  RecordingOutErr recorder;
+
+  public TestFileOutErr(TestFileOutErr arg) {
+    this(arg.getOutputStream(), arg.getErrorStream());
+  }
+
+  public TestFileOutErr() {
+    this(new ByteArrayOutputStream(), new ByteArrayOutputStream());
+  }
+
+  public TestFileOutErr(ByteArrayOutputStream stream) {
+    super(null, null); // This is a pretty brutal overloading - We're just inheriting for the type.
+    recorder = new RecordingOutErr(stream, stream);
+  }
+
+  public TestFileOutErr(ByteArrayOutputStream stream1, ByteArrayOutputStream stream2) {
+    super(null, null); // This is a pretty brutal overloading - We're just inheriting for the type.
+    recorder = new RecordingOutErr(stream1, stream2);
+  }
+
+
+  @Override
+  public Path getOutputFile() {
+    return null;
+  }
+
+  @Override
+  public Path getErrorFile() {
+    return null;
+  }
+
+  @Override
+  public ByteArrayOutputStream getOutputStream() {
+    return recorder.getOutputStream();
+  }
+
+  @Override
+  public ByteArrayOutputStream getErrorStream() {
+    return recorder.getErrorStream();
+  }
+
+  @Override
+  public void printOut(String s) {
+    recorder.printOut(s);
+  }
+
+  @Override
+  public void printErr(String s) {
+    recorder.printErr(s);
+  }
+
+  @Override
+  public String toString() {
+    return recorder.toString();
+  }
+
+  @Override
+  public boolean hasRecordedOutput() {
+    return recorder.hasRecordedOutput();
+  }
+
+  @Override
+  public String outAsLatin1() {
+    return recorder.outAsLatin1();
+  }
+
+  @Override
+  public String errAsLatin1() {
+    return recorder.errAsLatin1();
+  }
+
+  @Override
+  public void dumpOutAsLatin1(OutputStream out) {
+    try {
+      out.write(recorder.getOutputStream().toByteArray());
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  @Override
+  public void dumpErrAsLatin1(OutputStream out) {
+    try {
+      out.write(recorder.getErrorStream().toByteArray());
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  public String getRecordedOutput() {
+    return recorder.outAsLatin1() + recorder.errAsLatin1();
+  }
+
+  public void reset() {
+    recorder.reset();
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/testutil/TestRuleClassProvider.java b/src/test/java/com/google/devtools/build/lib/testutil/TestRuleClassProvider.java
new file mode 100644
index 0000000..752605c
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/testutil/TestRuleClassProvider.java
@@ -0,0 +1,84 @@
+// Copyright 2014 Google Inc. 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.testutil;
+
+import static com.google.devtools.build.lib.packages.Attribute.attr;
+import static com.google.devtools.build.lib.packages.Type.INTEGER;
+import static com.google.devtools.build.lib.packages.Type.LABEL_LIST;
+import static com.google.devtools.build.lib.packages.Type.OUTPUT_LIST;
+import static com.google.devtools.build.lib.packages.Type.STRING_LIST;
+
+import com.google.devtools.build.lib.analysis.BaseRuleClasses;
+import com.google.devtools.build.lib.analysis.BlazeRule;
+import com.google.devtools.build.lib.analysis.ConfiguredRuleClassProvider;
+import com.google.devtools.build.lib.analysis.RuleDefinition;
+import com.google.devtools.build.lib.analysis.RuleDefinitionEnvironment;
+import com.google.devtools.build.lib.packages.RuleClass;
+import com.google.devtools.build.lib.packages.RuleClass.Builder;
+import com.google.devtools.build.lib.util.FileTypeSet;
+
+import java.lang.reflect.Method;
+
+/**
+ * Helper class to provide a RuleClassProvider for tests.
+ */
+public class TestRuleClassProvider {
+  private static ConfiguredRuleClassProvider ruleProvider = null;
+
+  /**
+   * Adds all the rule classes supported internally within the build tool to the given builder.
+   */
+  public static void addStandardRules(ConfiguredRuleClassProvider.Builder builder) {
+    try {
+      Class<?> providerClass = Class.forName(TestConstants.TEST_RULE_CLASS_PROVIDER);
+      Method setupMethod = providerClass.getMethod("setup",
+          ConfiguredRuleClassProvider.Builder.class);
+      setupMethod.invoke(null, builder);
+    } catch (Exception e) {
+      throw new IllegalStateException(e);
+    }
+  }
+
+  /**
+   * Return a rule class provider.
+   */
+  public static ConfiguredRuleClassProvider getRuleClassProvider() {
+    if (ruleProvider == null) {
+      ConfiguredRuleClassProvider.Builder builder =
+          new ConfiguredRuleClassProvider.Builder();
+      addStandardRules(builder);
+      builder.addRuleDefinition(TestingDummyRule.class);
+      ruleProvider = builder.build();
+    }
+    return ruleProvider;
+  }
+
+  @BlazeRule(name = "testing_dummy_rule",
+               ancestors = { BaseRuleClasses.RuleBase.class },
+               // Instantiated only in tests
+               factoryClass = UnknownRuleConfiguredTarget.class)
+  public static final class TestingDummyRule implements RuleDefinition {
+    @Override
+    public RuleClass build(Builder builder, RuleDefinitionEnvironment env) {
+      return builder
+          .setUndocumented()
+          .add(attr("srcs", LABEL_LIST).allowedFileTypes(FileTypeSet.ANY_FILE))
+          .add(attr("outs", OUTPUT_LIST))
+          .add(attr("dummystrings", STRING_LIST))
+          .add(attr("dummyinteger", INTEGER))
+          .build();
+    }
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/testutil/TestSpec.java b/src/test/java/com/google/devtools/build/lib/testutil/TestSpec.java
new file mode 100644
index 0000000..316169c
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/testutil/TestSpec.java
@@ -0,0 +1,48 @@
+// Copyright 2014 Google Inc. 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.testutil;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * An annotation class which we use to attach a little meta data to test
+ * classes. For now, we use this to attach a {@link Suite}.
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Inherited
+public @interface TestSpec {
+
+  /**
+   * The size of the specified test, in terms of its resource consumption and
+   * execution time.
+   */
+  Suite size() default Suite.SMALL_TESTS;
+
+  /**
+   * The name of the suite to which this test belongs.  Useful for creating
+   * test suites organised by function.
+   */
+  String suite() default "";
+
+  /**
+   * If the test will pass consistently without outside changes.
+   * This should be fixed as soon as possible.
+   */
+  boolean flaky() default false;
+}
diff --git a/src/test/java/com/google/devtools/build/lib/testutil/TestSuiteBuilder.java b/src/test/java/com/google/devtools/build/lib/testutil/TestSuiteBuilder.java
new file mode 100644
index 0000000..af90c52
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/testutil/TestSuiteBuilder.java
@@ -0,0 +1,139 @@
+// Copyright 2014 Google Inc. 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.testutil;
+
+import com.google.common.base.Predicate;
+import com.google.common.base.Predicates;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Sets;
+
+import junit.framework.TestCase;
+
+import org.junit.runner.RunWith;
+
+import java.lang.reflect.Modifier;
+import java.util.Comparator;
+import java.util.LinkedHashSet;
+import java.util.Set;
+
+/**
+ * A collector for test classes, for both JUnit 3 and 4. To be used in combination with {@link
+ * CustomSuite}.
+ */
+public final class TestSuiteBuilder {
+
+  private Set<Class<?>> testClasses = Sets.newTreeSet(new TestClassNameComparator());
+  private Predicate<Class<?>> matchClassPredicate = Predicates.alwaysTrue();
+
+  /**
+   * Adds the tests found (directly) in class {@code c} to the set of tests
+   * this builder will search.
+   */
+  public TestSuiteBuilder addTestClass(Class<?> c) {
+    testClasses.add(c);
+    return this;
+  }
+
+  /**
+   * Adds all the test classes (top-level or nested) found in package
+   * {@code pkgName} or its subpackages to the set of tests this builder will
+   * search.
+   */
+  public TestSuiteBuilder addPackageRecursive(String pkgName) {
+    for (Class<?> c : getClassesRecursive(pkgName)) {
+      addTestClass(c);
+    }
+    return this;
+  }
+
+  private Set<Class<?>> getClassesRecursive(String pkgName) {
+    Set<Class<?>> result = new LinkedHashSet<>();
+    for (Class<?> clazz : Classpath.findClasses(pkgName)) {
+      if (isTestClass(clazz)) {
+        result.add(clazz);
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Specifies a predicate returns false for classes we want to exclude.
+   */
+  public TestSuiteBuilder matchClasses(Predicate<Class<?>> predicate) {
+    matchClassPredicate = predicate;
+    return this;
+  }
+
+  /**
+   * Creates and returns a TestSuite containing the tests from the given
+   * classes and/or packages which matched the given tags.
+   */
+  public Set<Class<?>> create() {
+    Set<Class<?>> result = new LinkedHashSet<>();
+    // We have some cases where the resulting test suite is empty, which some of our test
+    // infrastructure treats as an error.
+    result.add(TautologyTest.class);
+    for (Class<?> testClass : Iterables.filter(testClasses, matchClassPredicate)) {
+      result.add(testClass);
+    }
+    return result;
+  }
+
+  /**
+   * Determines if a given class is a test class.
+   *
+   * @param container class to test
+   * @return <code>true</code> if the test is a test class.
+   */
+  private static boolean isTestClass(Class<?> container) {
+    return (isJunit4Test(container) || isJunit3Test(container))
+        && !isSuite(container)
+        && Modifier.isPublic(container.getModifiers())
+        && !Modifier.isAbstract(container.getModifiers());
+  }
+
+  private static boolean isJunit4Test(Class<?> container) {
+    return container.getAnnotation(RunWith.class) != null;
+  }
+
+  private static boolean isJunit3Test(Class<?> container) {
+    return TestCase.class.isAssignableFrom(container);
+  }
+
+  /**
+   * Classes that have a {@code RunWith} annotation for {@link ClasspathSuite} or {@link
+   * CustomSuite} are automatically excluded to avoid picking up the suite class itself.
+   */
+  private static boolean isSuite(Class<?> container) {
+    RunWith runWith = container.getAnnotation(RunWith.class);
+    return (runWith != null)
+        && ((runWith.value() == ClasspathSuite.class) || (runWith.value() == CustomSuite.class));
+  }
+
+  private static class TestClassNameComparator implements Comparator<Class<?>> {
+    @Override
+    public int compare(Class<?> o1, Class<?> o2) {
+      return o1.getName().compareTo(o2.getName());
+    }
+  }
+
+  /**
+   * A test that does nothing and always passes. We have some cases where an empty test suite is
+   * treated as an error, so we use this test to make sure that the test suite is always non-empty.
+   */
+  public static class TautologyTest extends TestCase {
+    public void testThatNothingHappens() {
+    }
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/testutil/TestThread.java b/src/test/java/com/google/devtools/build/lib/testutil/TestThread.java
new file mode 100644
index 0000000..e043025
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/testutil/TestThread.java
@@ -0,0 +1,66 @@
+// Copyright 2014 Google Inc. 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.testutil;
+
+import static com.google.common.truth.Truth.assertWithMessage;
+
+/**
+ * Test thread implementation that allows the use of assertions within
+ * spawned threads.
+ *
+ * Main test method must call {@link TestThread#joinAndAssertState(long)}
+ * for each spawned test thread.
+ */
+public abstract class TestThread extends Thread {
+  Throwable testException = null;
+  boolean isSucceeded = false;
+
+  /**
+   * Specific test thread implementation overrides this method.
+   */
+  abstract public void runTest() throws Exception;
+
+  @Override public final void run() {
+    try {
+      runTest();
+      isSucceeded = true;
+    } catch (Exception e) {
+      testException = e;
+    } catch (AssertionError e) {
+      testException = e;
+    }
+  }
+
+  /**
+   * Joins test thread (waiting specified number of ms) and validates that
+   * it has been completed successfully.
+   */
+  public void joinAndAssertState(long timeout) throws InterruptedException {
+    join(timeout);
+    Throwable exception = this.testException;
+    if (isAlive()) {
+      exception = new AssertionError (
+          "Test thread " + getName() + " is still alive");
+      exception.setStackTrace(getStackTrace());
+    }
+    if(exception != null) {
+      AssertionError error = new AssertionError("Test thread " + getName() + " failed to execute");
+      error.initCause(exception);
+      throw error;
+    }
+    assertWithMessage("Test thread " + getName() + " has not run successfully").that(isSucceeded)
+        .isTrue();
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/testutil/TestUtils.java b/src/test/java/com/google/devtools/build/lib/testutil/TestUtils.java
new file mode 100644
index 0000000..2ee5972
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/testutil/TestUtils.java
@@ -0,0 +1,152 @@
+// Copyright 2014 Google Inc. 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.testutil;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.util.UUID;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadPoolExecutor;
+
+/**
+ * Some static utility functions for testing.
+ */
+public class TestUtils {
+  public static final ThreadPoolExecutor POOL =
+    (ThreadPoolExecutor) Executors.newFixedThreadPool(10);
+
+  public static final UUID ZERO_UUID = UUID.fromString("00000000-0000-0000-0000-000000000000");
+
+  /**
+   * Wait until the {@link System#currentTimeMillis} / 1000 advances.
+   *
+   * This method takes 0-1000ms to run, 500ms on average.
+   */
+  public static void advanceCurrentTimeSeconds() throws InterruptedException {
+    long currentTimeSeconds = System.currentTimeMillis() / 1000;
+    do {
+      Thread.sleep(50);
+    } while (currentTimeSeconds == System.currentTimeMillis() / 1000);
+  }
+
+  public static ThreadPoolExecutor getPool() {
+    return POOL;
+  }
+
+  public static String tmpDir() {
+    return tmpDirFile().getAbsolutePath();
+  }
+
+  static String getUserValue(String key) {
+    String value = System.getProperty(key);
+    if (value == null) {
+      value = System.getenv(key);
+    }
+    return value;
+  }
+
+  public static File tmpDirFile() {
+    File tmpDir;
+
+    // Flag value specified in environment?
+    String tmpDirStr = getUserValue("TEST_TMPDIR");
+
+    if (tmpDirStr != null && tmpDirStr.length() > 0) {
+      tmpDir = new File(tmpDirStr);
+    } else {
+      // Fallback default $TEMP/$USER/tmp/$TESTNAME
+      String baseTmpDir = System.getProperty("java.io.tmpdir");
+      tmpDir = new File(baseTmpDir).getAbsoluteFile();
+
+      // .. Add username
+      String username = System.getProperty("user.name");
+      username = username.replace('/', '_');
+      username = username.replace('\\', '_');
+      username = username.replace('\000', '_');
+      tmpDir = new File(tmpDir, username);
+      tmpDir = new File(tmpDir, "tmp");
+    }
+
+    // Ensure tmpDir exists
+    if (!tmpDir.isDirectory()) {
+      tmpDir.mkdirs();
+    }
+    return tmpDir;
+  }
+
+  public static File makeTempDir() throws IOException {
+    File dir = File.createTempFile(TestUtils.class.getName(), ".temp", tmpDirFile());
+    if (!dir.delete()) {
+      throw new IOException("Cannot remove a temporary file " + dir);
+    }
+    if (!dir.mkdir()) {
+      throw new IOException("Cannot create a temporary directory " + dir);
+    }
+    return dir;
+  }
+
+  public static int getRandomSeed() {
+    // Default value if not running under framework
+    int randomSeed = 301;
+
+    // Value specified in environment by framework?
+    String value = getUserValue("TEST_RANDOM_SEED");
+    if ((value != null) && (value.length() > 0)) {
+      try {
+        randomSeed = Integer.parseInt(value);
+      } catch (NumberFormatException e) {
+        // throw new AssertionError("TEST_RANDOM_SEED must be an integer");
+        throw new RuntimeException("TEST_RANDOM_SEED must be an integer");
+      }
+    }
+
+    return randomSeed;
+  }
+
+  public static byte[] serializeObject(Object obj) throws IOException {
+    ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+    try (ObjectOutputStream objectStream = new ObjectOutputStream(outputStream)) {
+      objectStream.writeObject(obj);
+    }
+    return outputStream.toByteArray();
+  }
+
+  public static Object deserializeObject(byte[] buf) throws IOException, ClassNotFoundException {
+    try (ObjectInputStream inStream = new ObjectInputStream(new ByteArrayInputStream(buf))) {
+      return inStream.readObject();
+    }
+  }
+
+  /**
+   * Timeouts for asserting that an arbitrary event occurs eventually.
+   *
+   * <p>In general, it's not appropriate to use a small constant timeout for an arbitrary
+   * computation since there is no guarantee that a snippet of code will execute within a given
+   * amount of time - you are at the mercy of the jvm, your machine, and your OS. In theory we
+   * could try to take all of these factors into account but instead we took the simpler and
+   * obviously correct approach of not having timeouts.
+   *
+   * <p>If a test that uses these timeout values is failing due to a "timeout" at the
+   * 'blaze test' level, it could be because of a legitimate deadlock that would have been caught
+   * if the timeout values below were small. So you can rule out such a deadlock by changing these
+   * values to small numbers (also note that the --test_timeout blaze flag may be useful).
+   */
+  public static final long WAIT_TIMEOUT_MILLISECONDS = Long.MAX_VALUE;
+  public static final long WAIT_TIMEOUT_SECONDS = WAIT_TIMEOUT_MILLISECONDS / 1000;
+}
diff --git a/src/test/java/com/google/devtools/build/lib/testutil/UnknownRuleConfiguredTarget.java b/src/test/java/com/google/devtools/build/lib/testutil/UnknownRuleConfiguredTarget.java
new file mode 100644
index 0000000..d3e5457
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/testutil/UnknownRuleConfiguredTarget.java
@@ -0,0 +1,59 @@
+// Copyright 2014 Google Inc. 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.testutil;
+
+import com.google.common.collect.ImmutableList;
+import com.google.devtools.build.lib.actions.Artifact;
+import com.google.devtools.build.lib.actions.FailAction;
+import com.google.devtools.build.lib.analysis.ConfiguredTarget;
+import com.google.devtools.build.lib.analysis.RuleConfiguredTargetBuilder;
+import com.google.devtools.build.lib.analysis.RuleContext;
+import com.google.devtools.build.lib.analysis.Runfiles;
+import com.google.devtools.build.lib.analysis.RunfilesProvider;
+import com.google.devtools.build.lib.collect.nestedset.NestedSet;
+import com.google.devtools.build.lib.collect.nestedset.NestedSetBuilder;
+import com.google.devtools.build.lib.collect.nestedset.Order;
+import com.google.devtools.build.lib.packages.Rule;
+import com.google.devtools.build.lib.rules.RuleConfiguredTargetFactory;
+
+/**
+ * A null implementation of ConfiguredTarget for rules we don't know how to build.
+ */
+public class UnknownRuleConfiguredTarget implements RuleConfiguredTargetFactory {
+
+  @Override
+  public ConfiguredTarget create(RuleContext context)  {
+    // TODO(bazel-team): (2009) why isn't this an error?  It would stop the build more promptly...
+    context.ruleWarning("cannot build " + context.getRule().getRuleClass() + " rules");
+
+    ImmutableList<Artifact> outputArtifacts = context.getOutputArtifacts();
+    NestedSet<Artifact> filesToBuild;
+    if (outputArtifacts.isEmpty()) {
+      // Gotta build *something*...
+      filesToBuild = NestedSetBuilder.create(Order.STABLE_ORDER,
+          context.createOutputArtifact());
+    } else {
+      filesToBuild = NestedSetBuilder.wrap(Order.STABLE_ORDER, outputArtifacts);
+    }
+
+    Rule rule = context.getRule();
+    context.registerAction(new FailAction(context.getActionOwner(),
+        filesToBuild, "cannot build " + rule.getRuleClass() + " rules such as " + rule.getLabel()));
+    return new RuleConfiguredTargetBuilder(context)
+        .setFilesToBuild(filesToBuild)
+        .add(RunfilesProvider.class, RunfilesProvider.simple(Runfiles.EMPTY))
+        .build();
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/testutiltests/JunitTestUtilsTest.java b/src/test/java/com/google/devtools/build/lib/testutiltests/JunitTestUtilsTest.java
new file mode 100644
index 0000000..4bfe0fa
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/testutiltests/JunitTestUtilsTest.java
@@ -0,0 +1,132 @@
+// Copyright 2014 Google Inc. 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.testutiltests;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.devtools.build.lib.testutil.JunitTestUtils.assertContainsSublist;
+import static com.google.devtools.build.lib.testutil.JunitTestUtils.assertDoesNotContainSublist;
+import static org.junit.Assert.fail;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Tests {@link com.google.devtools.build.lib.testutil.JunitTestUtils}.
+ */
+@RunWith(JUnit4.class)
+public class JunitTestUtilsTest {
+
+  @Test
+  public void testAssertContainsSublistSuccess() {
+    List<String> actual = Arrays.asList("a", "b", "c");
+
+    // All single-string combinations.
+    assertContainsSublist(actual, "a");
+    assertContainsSublist(actual, "b");
+    assertContainsSublist(actual, "c");
+
+    // All two-string combinations.
+    assertContainsSublist(actual, "a", "b");
+    assertContainsSublist(actual, "b", "c");
+
+    // The whole list.
+    assertContainsSublist(actual, "a", "b", "c");
+  }
+
+  @Test
+  public void testAssertContainsSublistFailure() {
+    List<String> actual = Arrays.asList("a", "b", "c");
+
+    try {
+      assertContainsSublist(actual, "d");
+      fail("no exception thrown");
+    } catch (AssertionError e) {
+      assertThat(e.getMessage()).startsWith("Did not find [d] as a sublist of [a, b, c]");
+    }
+
+    try {
+      assertContainsSublist(actual, "a", "c");
+      fail("no exception thrown");
+    } catch (AssertionError e) {
+      assertThat(e.getMessage()).startsWith("Did not find [a, c] as a sublist of [a, b, c]");
+    }
+
+    try {
+      assertContainsSublist(actual, "b", "c", "d");
+      fail("no exception thrown");
+    } catch (AssertionError e) {
+      assertThat(e.getMessage()).startsWith("Did not find [b, c, d] as a sublist of [a, b, c]");
+    }
+  }
+
+  @Test
+  public void testAssertDoesNotContainSublistSuccess() {
+    List<String> actual = Arrays.asList("a", "b", "c");
+    assertDoesNotContainSublist(actual, "d");
+    assertDoesNotContainSublist(actual, "a", "c");
+    assertDoesNotContainSublist(actual, "b", "c", "d");
+  }
+
+  @Test
+  public void testAssertDoesNotContainSublistFailure() {
+    List<String> actual = Arrays.asList("a", "b", "c");
+
+    // All single-string combinations.
+    try {
+      assertDoesNotContainSublist(actual, "a");
+      fail("no exception thrown");
+    } catch (AssertionError e) {
+      assertThat(e).hasMessage("Found [a] as a sublist of [a, b, c]");
+    }
+    try {
+      assertDoesNotContainSublist(actual, "b");
+      fail("no exception thrown");
+    } catch (AssertionError e) {
+      assertThat(e).hasMessage("Found [b] as a sublist of [a, b, c]");
+    }
+    try {
+      assertDoesNotContainSublist(actual, "c");
+      fail("no exception thrown");
+    } catch (AssertionError e) {
+      assertThat(e).hasMessage("Found [c] as a sublist of [a, b, c]");
+    }
+
+    // All two-string combinations.
+    try {
+      assertDoesNotContainSublist(actual, "a", "b");
+      fail("no exception thrown");
+    } catch (AssertionError e) {
+      assertThat(e).hasMessage("Found [a, b] as a sublist of [a, b, c]");
+    }
+    try {
+      assertDoesNotContainSublist(actual, "b", "c");
+      fail("no exception thrown");
+    } catch (AssertionError e) {
+      assertThat(e).hasMessage("Found [b, c] as a sublist of [a, b, c]");
+    }
+
+    // The whole list.
+    try {
+      assertDoesNotContainSublist(actual, "a", "b", "c");
+      fail("no exception thrown");
+    } catch (AssertionError e) {
+      assertThat(e).hasMessage("Found [a, b, c] as a sublist of [a, b, c]");
+    }
+  }
+
+}
diff --git a/src/test/java/com/google/devtools/build/lib/testutiltests/TestSizeAnnotationTest.java b/src/test/java/com/google/devtools/build/lib/testutiltests/TestSizeAnnotationTest.java
new file mode 100644
index 0000000..5380cba
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/testutiltests/TestSizeAnnotationTest.java
@@ -0,0 +1,141 @@
+// Copyright 2014 Google Inc. 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.testutiltests;
+
+import static com.google.devtools.build.lib.testutil.Suite.getSize;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import com.google.devtools.build.lib.testutil.Suite;
+import com.google.devtools.build.lib.testutil.TestSpec;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests {@link com.google.devtools.build.lib.testutil.Suite#getSize(Class)}.
+ */
+@RunWith(JUnit4.class)
+public class TestSizeAnnotationTest {
+
+  private static class HasNoTestSpecAnnotation {
+
+  }
+
+  @TestSpec(flaky = true)
+  private static class FlakyTestSpecAnnotation {
+
+  }
+
+  @TestSpec(suite = "foo")
+  private static class HasNoSizeAnnotationElement {
+
+  }
+
+  @TestSpec(size = Suite.SMALL_TESTS)
+  private static class IsAnnotatedWithSmallSize {
+
+  }
+
+  @TestSpec(size = Suite.MEDIUM_TESTS)
+  private static class IsAnnotatedWithMediumSize {
+
+  }
+
+  @TestSpec(size = Suite.LARGE_TESTS)
+  private static class IsAnnotatedWithLargeSize {
+
+  }
+
+  private static class SuperclassHasAnnotationButNoSizeElement
+      extends HasNoSizeAnnotationElement {
+
+  }
+
+  @TestSpec(size = Suite.LARGE_TESTS)
+  private static class HasSizeElementAndSuperclassHasAnnotationButNoSizeElement
+      extends HasNoSizeAnnotationElement {
+
+  }
+
+  private static class SuperclassHasAnnotationWithSizeElement
+      extends IsAnnotatedWithSmallSize {
+
+  }
+
+  @TestSpec(size = Suite.LARGE_TESTS)
+  private static class HasSizeElementAndSuperclassHasAnnotationWithSizeElement
+      extends IsAnnotatedWithSmallSize {
+
+  }
+
+  @Test
+  public void testHasNoTestSpecAnnotationIsSmall() {
+    assertEquals(Suite.SMALL_TESTS, getSize(HasNoTestSpecAnnotation.class));
+  }
+
+  @Test
+  public void testHasNoSizeAnnotationElementIsSmall() {
+    assertEquals(Suite.SMALL_TESTS, getSize(HasNoSizeAnnotationElement.class));
+  }
+
+  @Test
+  public void testIsAnnotatedWithSmallSizeIsSmall() {
+    assertEquals(Suite.SMALL_TESTS, getSize(IsAnnotatedWithSmallSize.class));
+  }
+
+  @Test
+  public void testIsAnnotatedWithMediumSizeIsMedium() {
+    assertEquals(Suite.MEDIUM_TESTS, getSize(IsAnnotatedWithMediumSize.class));
+  }
+
+  @Test
+  public void testIsAnnotatedWithLargeSizeIsLarge() {
+    assertEquals(Suite.LARGE_TESTS, getSize(IsAnnotatedWithLargeSize.class));
+  }
+
+  @Test
+  public void testSuperclassHasAnnotationButNoSizeElement() {
+    assertEquals(Suite.SMALL_TESTS, getSize(SuperclassHasAnnotationButNoSizeElement.class));
+  }
+
+  @Test
+  public void testHasSizeElementAndSuperclassHasAnnotationButNoSizeElement() {
+    assertEquals(Suite.LARGE_TESTS,
+        getSize(HasSizeElementAndSuperclassHasAnnotationButNoSizeElement.class));
+  }
+
+  @Test
+  public void testSuperclassHasAnnotationWithSizeElement() {
+    assertEquals(Suite.SMALL_TESTS, getSize(SuperclassHasAnnotationWithSizeElement.class));
+  }
+
+  @Test
+  public void testHasSizeElementAndSuperclassHasAnnotationWithSizeElement() {
+    assertEquals(Suite.LARGE_TESTS,
+        getSize(HasSizeElementAndSuperclassHasAnnotationWithSizeElement.class));
+  }
+
+  @Test
+  public void testIsNotFlaky() {
+    assertFalse(Suite.isFlaky(HasNoTestSpecAnnotation.class));
+  }
+  
+  @Test
+  public void testIsFlaky() {
+    assertTrue(Suite.isFlaky(FlakyTestSpecAnnotation.class));
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/unix/FilesystemUtilsTest.java b/src/test/java/com/google/devtools/build/lib/unix/FilesystemUtilsTest.java
new file mode 100644
index 0000000..48a67c1
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/unix/FilesystemUtilsTest.java
@@ -0,0 +1,76 @@
+// Copyright 2014 Google Inc. 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.unix;
+
+import static org.junit.Assert.assertEquals;
+
+import com.google.common.hash.HashCode;
+import com.google.devtools.build.lib.testutil.TestUtils;
+import com.google.devtools.build.lib.vfs.FileSystem;
+import com.google.devtools.build.lib.vfs.FileSystemUtils;
+import com.google.devtools.build.lib.vfs.Path;
+import com.google.devtools.build.lib.vfs.UnixFileSystem;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.File;
+import java.util.HashMap;
+
+/**
+ * This class tests the FilesystemUtils class.
+ */
+@RunWith(JUnit4.class)
+public class FilesystemUtilsTest {
+  private FileSystem testFS;
+  private Path workingDir;
+  private Path testFile;
+
+  @Before
+  public void setUp() throws Exception {
+    testFS = new UnixFileSystem();
+    workingDir = testFS.getPath(new File(TestUtils.tmpDir()).getCanonicalPath());
+    testFile = workingDir.getRelative("test");
+    FileSystemUtils.createEmptyFile(testFile);
+  }
+
+  /**
+   * This test validates that the md5sum() method returns hashes that match the official test
+   * vectors specified in RFC 1321, The MD5 Message-Digest Algorithm.
+   *
+   * @throws Exception
+   */
+  @Test
+  public void testValidateMd5Sum() throws Exception {
+    HashMap<String, String> testVectors = new HashMap<String, String>();
+    testVectors.put("", "d41d8cd98f00b204e9800998ecf8427e");
+    testVectors.put("a", "0cc175b9c0f1b6a831c399e269772661");
+    testVectors.put("abc", "900150983cd24fb0d6963f7d28e17f72");
+    testVectors.put("message digest", "f96b697d7cb7938d525a2f31aaf161d0");
+    testVectors.put("abcdefghijklmnopqrstuvwxyz", "c3fcd3d76192e4007dfb496cca67e13b");
+    testVectors.put("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
+        "d174ab98d277d9f5a5611c2c9f419d9f");
+    testVectors.put(
+        "12345678901234567890123456789012345678901234567890123456789012345678901234567890",
+        "57edf4a22be3c955ac49da2e2107b67a");
+
+    for (String testInput : testVectors.keySet()) {
+      FileSystemUtils.writeContentAsLatin1(testFile, testInput);
+      HashCode result = FilesystemUtils.md5sum(testFile.getPathString());
+      assertEquals(result.toString(), testVectors.get(testInput));
+    }
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/util/AnsiStrippingOutputStreamTest.java b/src/test/java/com/google/devtools/build/lib/util/AnsiStrippingOutputStreamTest.java
new file mode 100644
index 0000000..41428cb
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/util/AnsiStrippingOutputStreamTest.java
@@ -0,0 +1,84 @@
+// Copyright 2014 Google Inc. 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.util;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.ByteArrayOutputStream;
+import java.io.OutputStream;
+import java.io.PrintStream;
+
+/**
+ * Tests for {@link AnsiStrippingOutputStream}.
+ */
+@RunWith(JUnit4.class)
+public class AnsiStrippingOutputStreamTest {
+  ByteArrayOutputStream output;
+  PrintStream input;
+
+  private static final String ESCAPE = "\u001b[";
+
+  @Before
+  public void setUp() throws Exception {
+    output = new ByteArrayOutputStream();
+    OutputStream inputStream = new AnsiStrippingOutputStream(output);
+    input = new PrintStream(inputStream);
+  }
+
+  private String getOutput(String... fragments) throws Exception {
+    for (String fragment: fragments) {
+      input.print(fragment);
+    }
+
+    return new String(output.toByteArray(), "ISO8859-1");
+  }
+
+  @Test
+  public void doesNotFailHorribly() throws Exception {
+    assertEquals("Love", getOutput("Love"));
+  }
+
+  @Test
+  public void canStripAnsiCode() throws Exception {
+    assertEquals("Love", getOutput(ESCAPE + "32mLove" + ESCAPE + "m"));
+  }
+
+  @Test
+  public void recognizesAnsiCodeWhenBrokenUp() throws Exception {
+    assertEquals("Love", getOutput("\u001b", "[", "mLove"));
+  }
+
+  @Test
+  public void handlesOnlyEscCorrectly() throws Exception {
+    assertEquals("\u001bLove", getOutput("\u001bLove"));
+  }
+
+  @Test
+  public void handlesEscInPlaceOfControlCharCorrectly() throws Exception {
+    assertEquals(ESCAPE + "31;42Love",
+        getOutput(ESCAPE + "31;42" + ESCAPE + "1mLove"));
+  }
+
+  @Test
+  public void handlesTwoEscapeSequencesCorrectly() throws Exception {
+    assertEquals("Love",
+        getOutput(ESCAPE + "32m" + ESCAPE + "1m" + "Love"));
+  }
+
+}
diff --git a/src/test/java/com/google/devtools/build/lib/util/CommandBuilderTest.java b/src/test/java/com/google/devtools/build/lib/util/CommandBuilderTest.java
new file mode 100644
index 0000000..566da25
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/util/CommandBuilderTest.java
@@ -0,0 +1,104 @@
+// Copyright 2014 Google Inc. 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.util;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.ImmutableList;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.Arrays;
+
+/**
+ * Tests for the {@link CommandBuilder} class.
+ */
+@RunWith(JUnit4.class)
+public class CommandBuilderTest {
+
+  private CommandBuilder linuxBuilder() {
+    return new CommandBuilder(OS.LINUX).useTempDir();
+  }
+
+  private CommandBuilder winBuilder() {
+    return new CommandBuilder(OS.WINDOWS).useTempDir();
+  }
+
+  private void assertArgv(CommandBuilder builder, String... expected) {
+    assertThat(Arrays.asList(builder.build().getCommandLineElements())).containsExactlyElementsIn(
+        Arrays.asList(expected)).inOrder();
+  }
+
+  private void assertWinCmdArgv(CommandBuilder builder, String expected) {
+    assertArgv(builder, "CMD.EXE", "/S", "/E:ON", "/V:ON", "/D", "/C", "\"" + expected + "\"");
+  }
+
+  private void assertFailure(CommandBuilder builder, String expected) {
+    try {
+      builder.build();
+      fail("Expected exception");
+    } catch (Exception e) {
+      assertEquals(expected, e.getMessage());
+    }
+  }
+
+  @Test
+  public void linuxBuilderTest() {
+    assertArgv(linuxBuilder().addArg("abc"), "abc");
+    assertArgv(linuxBuilder().addArg("abc def"), "abc def");
+    assertArgv(linuxBuilder().addArgs("abc", "def"), "abc", "def");
+    assertArgv(linuxBuilder().addArgs(ImmutableList.of("abc", "def")), "abc", "def");
+    assertArgv(linuxBuilder().addArg("abc").useShell(true), "/bin/sh", "-c", "abc");
+    assertArgv(linuxBuilder().addArg("abc def").useShell(true), "/bin/sh", "-c", "abc def");
+    assertArgv(linuxBuilder().addArgs("abc", "def").useShell(true), "/bin/sh", "-c", "abc def");
+    assertArgv(linuxBuilder().addArgs("/bin/sh", "-c", "abc").useShell(true),
+        "/bin/sh", "-c", "abc");
+    assertArgv(linuxBuilder().addArgs("/bin/sh", "-c"), "/bin/sh", "-c");
+    assertArgv(linuxBuilder().addArgs("/bin/bash", "-c"), "/bin/bash", "-c");
+    assertArgv(linuxBuilder().addArgs("/bin/sh", "-c").useShell(true), "/bin/sh", "-c");
+    assertArgv(linuxBuilder().addArgs("/bin/bash", "-c").useShell(true), "/bin/bash", "-c");
+  }
+
+  @Test
+  public void windowsBuilderTest() {
+    assertArgv(winBuilder().addArg("abc.exe"), "abc.exe");
+    assertArgv(winBuilder().addArg("abc.exe -o"), "abc.exe -o");
+    assertArgv(winBuilder().addArg("ABC.EXE"), "ABC.EXE");
+    assertWinCmdArgv(winBuilder().addArg("abc def.exe"), "abc def.exe");
+    assertArgv(winBuilder().addArgs("abc.exe", "def"), "abc.exe", "def");
+    assertArgv(winBuilder().addArgs(ImmutableList.of("abc.exe", "def")), "abc.exe", "def");
+    assertWinCmdArgv(winBuilder().addArgs("abc.exe", "def").useShell(true), "abc.exe def");
+    assertWinCmdArgv(winBuilder().addArg("abc"), "abc");
+    assertWinCmdArgv(winBuilder().addArgs("abc", "def"), "abc def");
+    assertWinCmdArgv(winBuilder().addArgs("/bin/sh", "-c", "abc", "def"), "abc def");
+    assertWinCmdArgv(winBuilder().addArgs("/bin/sh", "-c"), "");
+    assertWinCmdArgv(winBuilder().addArgs("/bin/bash", "-c"), "");
+    assertWinCmdArgv(winBuilder().addArgs("/bin/sh", "-c").useShell(true), "");
+    assertWinCmdArgv(winBuilder().addArgs("/bin/bash", "-c").useShell(true), "");
+  }
+
+  @Test
+  public void failureScenarios() {
+    assertFailure(linuxBuilder(), "At least one argument is expected");
+    assertFailure(new CommandBuilder(OS.UNKNOWN).useTempDir().addArg("a"),
+        "Unidentified operating system");
+    assertFailure(new CommandBuilder(OS.LINUX).addArg("a"),
+        "Working directory must be set");
+  }
+
+}
diff --git a/src/test/java/com/google/devtools/build/lib/util/CommandFailureUtilsTest.java b/src/test/java/com/google/devtools/build/lib/util/CommandFailureUtilsTest.java
new file mode 100644
index 0000000..f0c2c4a
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/util/CommandFailureUtilsTest.java
@@ -0,0 +1,93 @@
+// Copyright 2014 Google Inc. 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.util;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+@RunWith(JUnit4.class)
+public class CommandFailureUtilsTest {
+
+  @Test
+  public void describeCommandError() throws Exception {
+    String[] args = new String[40];
+    args[0] = "some_command";
+    for (int i = 1; i < args.length; i++) {
+      args[i] = "arg" + i;
+    }
+    args[7] = "with spaces"; // Test embedded spaces in argument.
+    args[9] = "*";           // Test shell meta characters.
+    Map<String, String> env = new HashMap<>();
+    env.put("PATH", "/usr/bin:/bin:/sbin");
+    env.put("FOO", "foo");
+    String cwd = "/my/working/directory";
+    String message = CommandFailureUtils.describeCommandError(false, Arrays.asList(args), env, cwd);
+    String verboseMessage = CommandFailureUtils.describeCommandError(true, Arrays.asList(args), env,
+                                                                     cwd);
+    assertEquals(
+        "error executing command some_command arg1 "
+        + "arg2 arg3 arg4 arg5 arg6 'with spaces' arg8 '*' arg10 "
+        + "arg11 arg12 arg13 arg14 arg15 arg16 arg17 arg18 "
+        + "arg19 arg20 arg21 arg22 arg23 arg24 arg25 arg26 "
+        + "arg27 arg28 arg29 arg30 arg31 "
+        + "... (remaining 8 argument(s) skipped)",
+        message);
+    assertEquals(
+        "error executing command \n"
+        + "  (cd /my/working/directory && \\\n"
+        + "  exec env - \\\n"
+        + "    FOO=foo \\\n"
+        + "    PATH=/usr/bin:/bin:/sbin \\\n"
+        + "  some_command arg1 arg2 arg3 arg4 arg5 arg6 'with spaces' arg8 '*' arg10 "
+        + "arg11 arg12 arg13 arg14 arg15 arg16 arg17 arg18 "
+        + "arg19 arg20 arg21 arg22 arg23 arg24 arg25 arg26 "
+        + "arg27 arg28 arg29 arg30 arg31 arg32 arg33 arg34 "
+        + "arg35 arg36 arg37 arg38 arg39)",
+        verboseMessage);
+  }
+
+  @Test
+  public void describeCommandFailure() throws Exception {
+    String[] args = new String[3];
+    args[0] = "/bin/sh";
+    args[1] = "-c";
+    args[2] = "echo Some errors 1>&2; echo Some output; exit 42";
+    Map<String, String> env = new HashMap<>();
+    env.put("FOO", "foo");
+    env.put("PATH", "/usr/bin:/bin:/sbin");
+    String cwd = null;
+    String message = CommandFailureUtils.describeCommandFailure(false, Arrays.asList(args),
+                                                                env, cwd);
+    String verboseMessage = CommandFailureUtils.describeCommandFailure(true, Arrays.asList(args),
+                                                                       env, cwd);
+    assertEquals(
+        "sh failed: error executing command "
+        + "/bin/sh -c 'echo Some errors 1>&2; echo Some output; exit 42'",
+        message);
+    assertEquals(
+        "sh failed: error executing command \n"
+        + "  (exec env - \\\n"
+        + "    FOO=foo \\\n"
+        + "    PATH=/usr/bin:/bin:/sbin \\\n"
+        + "  /bin/sh -c 'echo Some errors 1>&2; echo Some output; exit 42')",
+        verboseMessage);
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/util/CommandUtilsTest.java b/src/test/java/com/google/devtools/build/lib/util/CommandUtilsTest.java
new file mode 100644
index 0000000..c7639a2
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/util/CommandUtilsTest.java
@@ -0,0 +1,108 @@
+// Copyright 2014 Google Inc. 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.util;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.Maps;
+import com.google.devtools.build.lib.shell.Command;
+import com.google.devtools.build.lib.shell.CommandException;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.File;
+import java.util.Map;
+
+@RunWith(JUnit4.class)
+public class CommandUtilsTest {
+
+  @Test
+  public void longCommand() throws Exception {
+    String[] args = new String[40];
+    args[0] = "this_command_will_not_be_found";
+    for (int i = 1; i < args.length; i++) {
+      args[i] = "arg" + i;
+    }
+    Map<String, String> env = Maps.newTreeMap();
+    env.put("PATH", "/usr/bin:/bin:/sbin");
+    env.put("FOO", "foo");
+    File directory = new File("/tmp");
+    try {
+      new Command(args, env, directory).execute();
+      fail();
+    } catch (CommandException exception) {
+      String message = CommandUtils.describeCommandError(false, exception.getCommand());
+      String verboseMessage = CommandUtils.describeCommandError(true, exception.getCommand());
+      assertEquals(
+          "error executing command this_command_will_not_be_found arg1 "
+          + "arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10 "
+          + "arg11 arg12 arg13 arg14 arg15 arg16 arg17 arg18 "
+          + "arg19 arg20 arg21 arg22 arg23 arg24 arg25 arg26 "
+          + "arg27 arg28 arg29 arg30 "
+          + "... (remaining 9 argument(s) skipped)",
+          message);
+      assertEquals(
+          "error executing command \n"
+          + "  (cd /tmp && \\\n"
+          + "  exec env - \\\n"
+          + "    FOO=foo \\\n"
+          + "    PATH=/usr/bin:/bin:/sbin \\\n"
+          + "  this_command_will_not_be_found arg1 "
+          + "arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10 "
+          + "arg11 arg12 arg13 arg14 arg15 arg16 arg17 arg18 "
+          + "arg19 arg20 arg21 arg22 arg23 arg24 arg25 arg26 "
+          + "arg27 arg28 arg29 arg30 arg31 arg32 arg33 arg34 "
+          + "arg35 arg36 arg37 arg38 arg39)",
+          verboseMessage);
+    }
+  }
+
+  @Test
+  public void failingCommand() throws Exception {
+    String[] args = new String[3];
+    args[0] = "/bin/sh";
+    args[1] = "-c";
+    args[2] = "echo Some errors 1>&2; echo Some output; exit 42";
+    Map<String, String> env = Maps.newTreeMap();
+    env.put("FOO", "foo");
+    env.put("PATH", "/usr/bin:/bin:/sbin");
+    try {
+      new Command(args, env, null).execute();
+      fail();
+    } catch (CommandException exception) {
+      String message = CommandUtils.describeCommandFailure(false, exception);
+      String verboseMessage = CommandUtils.describeCommandFailure(true, exception);
+      assertEquals(
+          "sh failed: error executing command " +
+          "/bin/sh -c 'echo Some errors 1>&2; echo Some output; exit 42': " +
+          "Process exited with status 42\n" +
+          "Some output\n" +
+          "Some errors\n",
+          message);
+      assertEquals(
+          "sh failed: error executing command \n" +
+          "  (exec env - \\\n" +
+          "    FOO=foo \\\n" +
+          "    PATH=/usr/bin:/bin:/sbin \\\n" +
+          "  /bin/sh -c 'echo Some errors 1>&2; echo Some output; exit 42'): " +
+          "Process exited with status 42\n" +
+          "Some output\n" +
+          "Some errors\n",
+          verboseMessage);
+    }
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/util/DependencySetTest.java b/src/test/java/com/google/devtools/build/lib/util/DependencySetTest.java
new file mode 100644
index 0000000..40edf36
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/util/DependencySetTest.java
@@ -0,0 +1,230 @@
+// Copyright 2014 Google Inc. 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.util;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.Sets;
+import com.google.devtools.build.lib.testutil.MoreAsserts;
+import com.google.devtools.build.lib.vfs.FileSystemUtils;
+import com.google.devtools.build.lib.vfs.Path;
+import com.google.devtools.build.lib.vfs.PathFragment;
+import com.google.devtools.build.lib.vfs.util.FsApparatus;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.Collection;
+
+@RunWith(JUnit4.class)
+public class DependencySetTest {
+
+  private FsApparatus scratch = FsApparatus.newInMemory();
+
+  private DependencySet newDependencySet() {
+    return new DependencySet(scratch.fs().getRootDirectory());
+  }
+
+  @Test
+  public void dotDParser_simple() throws Exception {
+    PathFragment file1 = new PathFragment("/usr/local/blah/blah/genhello/hello.cc");
+    PathFragment file2 = new PathFragment("/usr/local/blah/blah/genhello/hello.h");
+    String filename = "hello.o";
+    Path dotd = scratch.file("/tmp/foo.d",
+        filename + ": \\",
+        " " + file1 + " \\",
+        " " + file2 + " ");
+    DependencySet depset = newDependencySet().read(dotd);
+    MoreAsserts.assertSameContents(Sets.newHashSet(file1, file2),
+                       depset.getDependencies());
+    assertEquals(depset.getOutputFileName(), filename);
+  }
+
+  @Test
+  public void dotDParser_simple_crlf() throws Exception {
+    PathFragment file1 = new PathFragment("/usr/local/blah/blah/genhello/hello.cc");
+    PathFragment file2 = new PathFragment("/usr/local/blah/blah/genhello/hello.h");
+    String filename = "hello.o";
+    Path dotd = scratch.file("/tmp/foo.d",
+        filename + ": \\\r",
+        " " + file1 + " \\\r",
+        " " + file2 + " ");
+    DependencySet depset = newDependencySet().read(dotd);
+    MoreAsserts.assertSameContents(Sets.newHashSet(file1, file2),
+                       depset.getDependencies());
+    assertEquals(depset.getOutputFileName(), filename);
+  }
+
+  @Test
+  public void dotDParser_simple_cr() throws Exception {
+    PathFragment file1 = new PathFragment("/usr/local/blah/blah/genhello/hello.cc");
+    PathFragment file2 = new PathFragment("/usr/local/blah/blah/genhello/hello.h");
+    String filename = "hello.o";
+    Path dotd = scratch.file("/tmp/foo.d",
+        filename + ": \\\r"
+        + " " + file1 + " \\\r"
+        + " " + file2 + " ");
+    DependencySet depset = newDependencySet().read(dotd);
+    MoreAsserts.assertSameContents(Sets.newHashSet(file1, file2),
+                       depset.getDependencies());
+    assertEquals(depset.getOutputFileName(), filename);
+  }
+
+  @Test
+  public void dotDParser_leading_crlf() throws Exception {
+    PathFragment file1 = new PathFragment("/usr/local/blah/blah/genhello/hello.cc");
+    PathFragment file2 = new PathFragment("/usr/local/blah/blah/genhello/hello.h");
+    String filename = "hello.o";
+    Path dotd = scratch.file("/tmp/foo.d",
+        "\r\n" + filename + ": \\\r\n"
+        + " " + file1 + " \\\r\n"
+        + " " + file2 + " ");
+    DependencySet depset = newDependencySet().read(dotd);
+    MoreAsserts.assertSameContents(Sets.newHashSet(file1, file2),
+                       depset.getDependencies());
+    assertEquals(depset.getOutputFileName(), filename);
+  }
+
+  @Test
+  public void dotDParser_oddFormatting() throws Exception {
+    PathFragment file1 = new PathFragment("/usr/local/blah/blah/genhello/hello.cc");
+    PathFragment file2 = new PathFragment("/usr/local/blah/blah/genhello/hello.h");
+    PathFragment file3 = new PathFragment("/usr/local/blah/blah/genhello/other.h");
+    PathFragment file4 = new PathFragment("/usr/local/blah/blah/genhello/onemore.h");
+    String filename = "hello.o";
+    Path dotd = scratch.file("/tmp/foo.d",
+        filename + ": " + file1 + " \\",
+        " " + file2 + "\\",
+        " " + file3 + " " + file4);
+    DependencySet depset = newDependencySet().read(dotd);
+    MoreAsserts.assertSameContents(Sets.newHashSet(file1, file2, file3, file4),
+                       depset.getDependencies());
+    assertEquals(depset.getOutputFileName(), filename);
+  }
+
+  @Test
+  public void dotDParser_relativeFilenames() throws Exception {
+    PathFragment file1 = new PathFragment("hello.cc");
+    PathFragment file2 = new PathFragment("hello.h");
+    String filename = "hello.o";
+    Path dotd = scratch.file("/tmp/foo.d",
+        filename + ": \\",
+        " " + file1 + " \\",
+        " " + file2 + " ");
+    DependencySet depset = newDependencySet().read(dotd);
+    MoreAsserts.assertSameContents(Sets.newHashSet(file1, file2),
+                       depset.getDependencies());
+    assertEquals(depset.getOutputFileName(), filename);
+  }
+
+  @Test
+  public void dotDParser_emptyFile() throws Exception {
+    Path dotd = scratch.file("/tmp/empty.d");
+    DependencySet depset = newDependencySet().read(dotd);
+    Collection<PathFragment> headers = depset.getDependencies();
+    if (!headers.isEmpty()) {
+      fail("Not empty: " + headers.size() + " " + headers);
+    }
+    assertEquals(depset.getOutputFileName(), null);
+  }
+
+  @Test
+  public void dotDParser_multipleTargets() throws Exception {
+    PathFragment file1 = new PathFragment("/usr/local/blah/blah/genhello/hello.cc");
+    PathFragment file2 = new PathFragment("/usr/local/blah/blah/genhello/hello.h");
+    Path dotd = scratch.file("/tmp/foo.d",
+        "hello.o: \\",
+        " " + file1,
+        "hello2.o: \\",
+        " " + file2);
+    MoreAsserts.assertSameContents(Sets.newHashSet(file1, file2),
+        newDependencySet().read(dotd).getDependencies());
+  }
+
+  /*
+   * Regression test: if gcc fails to execute remotely, and we retry locally, then the behavior
+   * of gcc's DEPENDENCIES_OUTPUT option is to append, not overwrite, the .d file. As a result,
+   * during retry, a second stanza is written to the file.
+   *
+   * We handle this by merging all of the stanzas.
+   */
+  @Test
+  public void dotDParser_duplicateStanza() throws Exception {
+    PathFragment file1 = new PathFragment("/usr/local/blah/blah/genhello/hello.cc");
+    PathFragment file2 = new PathFragment("/usr/local/blah/blah/genhello/hello.h");
+    PathFragment file3 = new PathFragment("/usr/local/blah/blah/genhello/other.h");
+    Path dotd = scratch.file("/tmp/foo.d",
+        "hello.o: \\",
+        " " + file1 + " \\",
+        " " + file2 + " ",
+        "hello.o: \\",
+        " " + file1 + " \\",
+        " " + file3 + " ");
+    MoreAsserts.assertSameContents(Sets.newHashSet(file1, file2, file3),
+                       newDependencySet().read(dotd).getDependencies());
+  }
+
+  @Test
+  public void writeSet() throws Exception {
+    PathFragment file1 = new PathFragment("/usr/local/blah/blah/genhello/hello.cc");
+    PathFragment file2 = new PathFragment("/usr/local/blah/blah/genhello/hello.h");
+    PathFragment file3 = new PathFragment("/usr/local/blah/blah/genhello/other.h");
+    String filename = "/usr/local/blah/blah/genhello/hello.o";
+
+    DependencySet depSet1 = newDependencySet();
+    depSet1.addDependency(file1);
+    depSet1.addDependency(file2);
+    depSet1.addDependency(file3);
+    depSet1.setOutputFileName(filename);
+    
+    Path outfile = scratch.path(filename);
+    Path dotd = scratch.path("/usr/local/blah/blah/genhello/hello.d");
+    FileSystemUtils.createDirectoryAndParents(dotd.getParentDirectory());
+    depSet1.write(outfile, ".d");
+
+    String dotdContents = new String(FileSystemUtils.readContentAsLatin1(dotd));
+    String expected =
+        "usr/local/blah/blah/genhello/hello.o:  \\\n" +
+        "  /usr/local/blah/blah/genhello/hello.cc \\\n" +
+        "  /usr/local/blah/blah/genhello/hello.h \\\n" +
+        "  /usr/local/blah/blah/genhello/other.h\n";
+    assertEquals(expected, dotdContents);
+    assertEquals(filename, depSet1.getOutputFileName());
+  }
+
+  @Test
+  public void writeReadSet() throws Exception {
+    String filename = "/usr/local/blah/blah/genhello/hello.d";
+    PathFragment file1 = new PathFragment("/usr/local/blah/blah/genhello/hello.cc");
+    PathFragment file2 = new PathFragment("/usr/local/blah/blah/genhello/hello.h");
+    PathFragment file3 = new PathFragment("/usr/local/blah/blah/genhello/other.h");
+    DependencySet depSet1 = newDependencySet();
+    depSet1.addDependency(file1);
+    depSet1.addDependency(file2);
+    depSet1.addDependency(file3);
+    depSet1.setOutputFileName(filename);
+
+    Path dotd = scratch.path(filename);
+    FileSystemUtils.createDirectoryAndParents(dotd.getParentDirectory());
+    depSet1.write(dotd, ".d");
+    
+    DependencySet depSet2 = newDependencySet().read(dotd);
+    assertEquals(depSet1, depSet2);
+    // due to how pic.d files are written, absolute paths are changed into relatives
+    assertEquals(depSet1.getOutputFileName(), "/" + depSet2.getOutputFileName());
+  }
+
+}
diff --git a/src/test/java/com/google/devtools/build/lib/util/DependencySetWindowsTest.java b/src/test/java/com/google/devtools/build/lib/util/DependencySetWindowsTest.java
new file mode 100644
index 0000000..cdda6d1
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/util/DependencySetWindowsTest.java
@@ -0,0 +1,90 @@
+// Copyright 2014 Google Inc. 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.util;
+
+import com.google.common.collect.Sets;
+import com.google.devtools.build.lib.testutil.MoreAsserts;
+import com.google.devtools.build.lib.vfs.Path;
+import com.google.devtools.build.lib.vfs.PathFragment;
+import com.google.devtools.build.lib.vfs.util.FsApparatus;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.Set;
+
+@RunWith(JUnit4.class)
+public class DependencySetWindowsTest {
+
+  private FsApparatus scratch = FsApparatus.newInMemory();
+
+  private DependencySet newDependencySet() {
+    return new DependencySet(scratch.fs().getRootDirectory());
+  }
+
+  @Test
+  public void dotDParser_windowsPaths() throws Exception {
+    Path dotd = scratch.file("/tmp/foo.d",
+        "bazel-out/hello-lib/cpp/hello-lib.o: \\",
+        " cpp/hello-lib.cc cpp/hello-lib.h c:\\mingw\\include\\stdio.h \\",
+        " c:\\mingw\\include\\_mingw.h \\",
+        " c:\\mingw\\lib\\gcc\\mingw32\\4.8.1\\include\\stdarg.h");
+
+    Set<PathFragment> expected = Sets.newHashSet(
+        new PathFragment("cpp/hello-lib.cc"),
+        new PathFragment("cpp/hello-lib.h"),
+        new PathFragment("C:/mingw/include/stdio.h"),
+        new PathFragment("C:/mingw/include/_mingw.h"),
+        new PathFragment("C:/mingw/lib/gcc/mingw32/4.8.1/include/stdarg.h"));
+
+    MoreAsserts.assertSameContents(expected,
+        newDependencySet().read(dotd).getDependencies());
+  }
+
+  @Test
+  public void dotDParser_windowsPathsWithSpaces() throws Exception {
+    Path dotd = scratch.file("/tmp/foo.d",
+        "bazel-out/hello-lib/cpp/hello-lib.o: \\",
+        "C:\\Program\\ Files\\ (x86)\\LLVM\\stddef.h");
+    MoreAsserts.assertSameContents(
+        Sets.newHashSet(new PathFragment("C:/Program Files (x86)/LLVM/stddef.h")),
+        newDependencySet().read(dotd).getDependencies());
+  }
+
+  @Test
+  public void dotDParser_mixedWindowsPaths() throws Exception {
+    // This is (slightly simplified) actual output from clang. Yes, clang will happily mix
+    // forward slashes and backslashes in a single path, not to mention using backslashes as
+    // separators next to backslashes as escape characters.
+    Path dotd = scratch.file("/tmp/foo.d",
+        "bazel-out/hello-lib/cpp/hello-lib.o: \\",
+        "cpp/hello-lib.cc cpp/hello-lib.h /mingw/include\\stdio.h \\",
+        "/mingw/include\\_mingw.h \\",
+        "C:\\Program\\ Files\\ (x86)\\LLVM\\bin\\..\\lib\\clang\\3.5.0\\include\\stddef.h \\",
+        "C:\\Program\\ Files\\ (x86)\\LLVM\\bin\\..\\lib\\clang\\3.5.0\\include\\stdarg.h");
+
+    Set<PathFragment> expected = Sets.newHashSet(
+        new PathFragment("cpp/hello-lib.cc"),
+        new PathFragment("cpp/hello-lib.h"),
+        new PathFragment("/mingw/include/stdio.h"),
+        new PathFragment("/mingw/include/_mingw.h"),
+        new PathFragment("C:/Program Files (x86)/LLVM/lib/clang/3.5.0/include/stddef.h"),
+        new PathFragment("C:/Program Files (x86)/LLVM/lib/clang/3.5.0/include/stdarg.h"));
+
+    MoreAsserts.assertSameContents(expected,
+        newDependencySet().read(dotd).getDependencies());
+  }
+
+}
diff --git a/src/test/java/com/google/devtools/build/lib/util/FileTypeTest.java b/src/test/java/com/google/devtools/build/lib/util/FileTypeTest.java
new file mode 100644
index 0000000..301875c
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/util/FileTypeTest.java
@@ -0,0 +1,244 @@
+// Copyright 2014 Google Inc. 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.util;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import com.google.common.base.Joiner;
+import com.google.common.base.Predicate;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
+import com.google.devtools.build.lib.util.FileType.HasFilename;
+import com.google.devtools.build.lib.vfs.Path;
+import com.google.devtools.build.lib.vfs.PathFragment;
+import com.google.devtools.build.lib.vfs.inmemoryfs.InMemoryFileSystem;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.List;
+
+/**
+ * Test for {@link FileType} and {@link FileTypeSet}.
+ */
+@RunWith(JUnit4.class)
+public class FileTypeTest {
+  private static final FileType CFG = FileType.of(".cfg");
+  private static final FileType HTML = FileType.of(".html");
+  private static final FileType TEXT = FileType.of(".txt");
+  private static final FileType CPP_SOURCE = FileType.of(".cc", ".cpp", ".cxx", ".C");
+  private static final FileType JAVA_SOURCE = FileType.of(".java");
+  private static final FileType PYTHON_SOURCE = FileType.of(".py");
+
+  private static final class HasFilenameImpl implements HasFilename {
+    private final String path;
+
+    private HasFilenameImpl(String path) {
+      this.path = path;
+    }
+
+    @Override
+    public String getFilename() {
+      return path;
+    }
+
+    @Override
+    public String toString() {
+      return path;
+    }
+  }
+
+  @Test
+  public void simpleDotMatch() {
+    assertTrue(TEXT.matches("readme.txt"));
+  }
+
+  @Test
+  public void doubleDotMatches() {
+    assertTrue(TEXT.matches("read.me.txt"));
+  }
+
+  @Test
+  public void noExtensionMatches() {
+    assertTrue(FileType.NO_EXTENSION.matches("hello"));
+    assertTrue(FileType.NO_EXTENSION.matches("/path/to/hello"));
+  }
+
+  @Test
+  public void picksLastExtension() {
+    assertTrue(TEXT.matches("server.cfg.txt"));
+  }
+
+  @Test
+  public void onlyExtensionStillMatches() {
+    assertTrue(TEXT.matches(".txt"));
+  }
+
+  @Test
+  public void handlesPathObjects() {
+    Path readme = new InMemoryFileSystem().getPath("/readme.txt");
+    assertTrue(TEXT.matches(readme));
+  }
+
+  @Test
+  public void handlesPathFragmentObjects() {
+    PathFragment readme = new PathFragment("some/where/readme.txt");
+    assertTrue(TEXT.matches(readme));
+  }
+
+  @Test
+  public void fileTypeSetContains() {
+    FileTypeSet allowedTypes = FileTypeSet.of(TEXT, HTML);
+
+    assertTrue(allowedTypes.matches("readme.txt"));
+    assertTrue(!allowedTypes.matches("style.css"));
+  }
+
+  private List<HasFilename> getArtifacts() {
+    return Lists.<HasFilename>newArrayList(
+        new HasFilenameImpl("Foo.java"),
+        new HasFilenameImpl("bar.cc"),
+        new HasFilenameImpl("baz.py"));
+  }
+
+  private String filterAll(FileType... fileTypes) {
+    return Joiner.on(" ").join(FileType.filter(getArtifacts(), fileTypes));
+  }
+
+  @Test
+  public void justJava() {
+    assertEquals("Foo.java", filterAll(JAVA_SOURCE));
+  }
+
+  @Test
+  public void javaAndCpp() {
+    assertEquals("Foo.java bar.cc", filterAll(JAVA_SOURCE, CPP_SOURCE));
+  }
+
+  @Test
+  public void allThree() {
+    assertEquals("Foo.java bar.cc baz.py", filterAll(JAVA_SOURCE, CPP_SOURCE, PYTHON_SOURCE));
+  }
+
+  private HasFilename filename(final String name) {
+    return new HasFilename() {
+      @Override
+      public String getFilename() {
+        return name;
+      }
+    };
+  }
+
+  @Test
+  public void checkingSingleWithTypePredicate() throws Exception {
+    FileType.HasFilename item = filename("config.txt");
+
+    assertTrue(FileType.contains(item, TEXT));
+    assertFalse(FileType.contains(item, CFG));
+  }
+
+  @Test
+  public void checkingListWithTypePredicate() throws Exception {
+    ImmutableList<FileType.HasFilename> unfiltered = ImmutableList.of(
+        filename("config.txt"),
+        filename("index.html"),
+        filename("README.txt"));
+
+    assertTrue(FileType.contains(unfiltered, TEXT));
+    assertFalse(FileType.contains(unfiltered, CFG));
+  }
+
+  @Test
+  public void filteringWithTypePredicate() throws Exception {
+    ImmutableList<FileType.HasFilename> unfiltered = ImmutableList.of(
+        filename("config.txt"),
+        filename("index.html"),
+        filename("README.txt"),
+        filename("archive.zip"));
+
+    assertThat(FileType.filter(unfiltered, TEXT)).containsExactly(unfiltered.get(0),
+        unfiltered.get(2)).inOrder();
+  }
+
+  @Test
+  public void filteringWithMatcherPredicate() throws Exception {
+    ImmutableList<FileType.HasFilename> unfiltered = ImmutableList.of(
+        filename("config.txt"),
+        filename("index.html"),
+        filename("README.txt"),
+        filename("archive.zip"));
+
+    Predicate<String> textFileTypeMatcher = new Predicate<String>() {
+      @Override
+      public boolean apply(String input) {
+        return TEXT.matches(input);
+      }
+    };
+
+    assertThat(FileType.filter(unfiltered, textFileTypeMatcher)).containsExactly(unfiltered.get(0),
+        unfiltered.get(2)).inOrder();
+  }
+
+  @Test
+  public void filteringWithAlwaysFalse() throws Exception {
+    ImmutableList<FileType.HasFilename> unfiltered = ImmutableList.of(
+        filename("config.txt"),
+        filename("index.html"),
+        filename("binary"),
+        filename("archive.zip"));
+
+    assertThat(FileType.filter(unfiltered, FileTypeSet.NO_FILE)).isEmpty();
+  }
+
+  @Test
+  public void filteringWithAlwaysTrue() throws Exception {
+    ImmutableList<FileType.HasFilename> unfiltered = ImmutableList.of(
+        filename("config.txt"),
+        filename("index.html"),
+        filename("binary"),
+        filename("archive.zip"));
+
+    assertThat(FileType.filter(unfiltered, FileTypeSet.ANY_FILE)).containsExactly(unfiltered.get(0),
+        unfiltered.get(1), unfiltered.get(2), unfiltered.get(3)).inOrder();
+  }
+
+  @Test
+  public void exclusionWithTypePredicate() throws Exception {
+    ImmutableList<FileType.HasFilename> unfiltered = ImmutableList.of(
+        filename("config.txt"),
+        filename("index.html"),
+        filename("README.txt"),
+        filename("server.cfg"));
+
+    assertThat(FileType.except(unfiltered, TEXT)).containsExactly(unfiltered.get(1),
+        unfiltered.get(3)).inOrder();
+  }
+
+  @Test
+  public void listFiltering() throws Exception {
+    ImmutableList<FileType.HasFilename> unfiltered = ImmutableList.of(
+        filename("config.txt"),
+        filename("index.html"),
+        filename("README.txt"),
+        filename("server.cfg"));
+    FileTypeSet filter = FileTypeSet.of(HTML, CFG);
+
+    assertThat(FileType.filterList(unfiltered, filter)).containsExactly(unfiltered.get(1),
+        unfiltered.get(3)).inOrder();
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/util/FingerprintTest.java b/src/test/java/com/google/devtools/build/lib/util/FingerprintTest.java
new file mode 100644
index 0000000..5158019
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/util/FingerprintTest.java
@@ -0,0 +1,137 @@
+// Copyright 2014 Google Inc. 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.util;
+
+import static com.google.common.truth.Truth.assertThat;
+import static java.nio.charset.StandardCharsets.UTF_8;
+
+import com.google.common.collect.ImmutableList;
+import com.google.devtools.build.lib.vfs.Path;
+import com.google.devtools.build.lib.vfs.PathFragment;
+import com.google.devtools.build.lib.vfs.inmemoryfs.InMemoryFileSystem;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Tests for Fingerprint.
+ */
+@RunWith(JUnit4.class)
+public class FingerprintTest {
+
+  private static void assertFingerprintsDiffer(List<String> list1, List<String>list2) {
+    Fingerprint f1 = new Fingerprint();
+    Fingerprint f1Latin1 = new Fingerprint();
+    for (String s : list1) {
+      f1.addString(s);
+      f1Latin1.addStringLatin1(s);
+    }
+    Fingerprint f2 = new Fingerprint();
+    Fingerprint f2Latin1 = new Fingerprint();
+    for (String s : list2) {
+      f2.addString(s);
+      f2Latin1.addStringLatin1(s);
+    }
+    assertThat(f1.hexDigestAndReset()).isNotEqualTo(f2.hexDigestAndReset());
+    assertThat(f1Latin1.hexDigestAndReset()).isNotEqualTo(f2Latin1.hexDigestAndReset());
+  }
+
+  // You can validate the md5 of the simple string against
+  // echo -n 'Hello World!'| md5sum
+  @Test
+  public void bytesFingerprint() {
+    assertThat("ed076287532e86365e841e92bfc50d8c").isEqualTo(
+        new Fingerprint().addBytes("Hello World!".getBytes(UTF_8)).hexDigestAndReset());
+    assertThat("ed076287532e86365e841e92bfc50d8c").isEqualTo(Fingerprint.md5Digest("Hello World!"));
+  }
+
+  @Test
+  public void otherStringFingerprint() {
+    assertFingerprintsDiffer(ImmutableList.of("Hello World!"),
+                             ImmutableList.of("Goodbye World."));
+  }
+
+  @Test
+  public void multipleUpdatesDiffer() throws Exception {
+    assertFingerprintsDiffer(ImmutableList.of("Hello ", "World!"),
+                             ImmutableList.of("Hello World!"));
+  }
+
+  @Test
+  public void multipleUpdatesShiftedDiffer() throws Exception {
+    assertFingerprintsDiffer(ImmutableList.of("Hello ", "World!"),
+                             ImmutableList.of("Hello", " World!"));
+  }
+
+  @Test
+  public void listFingerprintNotSameAsIndividualElements() throws Exception {
+    Fingerprint f1 = new Fingerprint();
+    f1.addString("Hello ");
+    f1.addString("World!");
+    Fingerprint f2 = new Fingerprint();
+    f2.addStrings(ImmutableList.of("Hello ", "World!"));
+    assertThat(f1.hexDigestAndReset()).isNotEqualTo(f2.hexDigestAndReset());
+  }
+
+  @Test
+  public void mapFingerprintNotSameAsIndividualElements() throws Exception {
+    Fingerprint f1 = new Fingerprint();
+    Map<String, String> map = new HashMap<>();
+    map.put("Hello ", "World!");
+    f1.addStringMap(map);
+    Fingerprint f2 = new Fingerprint();
+    f2.addStrings(ImmutableList.of("Hello ", "World!"));
+    assertThat(f1.hexDigestAndReset()).isNotEqualTo(f2.hexDigestAndReset());
+  }
+
+  @Test
+  public void toStringTest() throws Exception {
+    Fingerprint f1 = new Fingerprint();
+    f1.addString("Hello ");
+    f1.addString("World!");
+    String fp = f1.hexDigestAndReset();
+    Fingerprint f2 = new Fingerprint();
+    f2.addString("Hello ");
+    // make sure that you can call toString on the intermediate result
+    // and continue with the operation.
+    assertThat(fp).isNotEqualTo(f2.toString());
+    f2.addString("World!");
+    assertThat(fp).isEqualTo(f2.hexDigestAndReset());
+  }
+
+  @Test
+  public void addBoolean() throws Exception {
+    String f1 = new Fingerprint().addBoolean(true).hexDigestAndReset();
+    String f2 = new Fingerprint().addBoolean(false).hexDigestAndReset();
+    String f3 = new Fingerprint().addBoolean(true).hexDigestAndReset();
+
+    assertThat(f1).isEqualTo(f3);
+    assertThat(f1).isNotEqualTo(f2);
+  }
+
+  @Test
+  public void addPath() throws Exception {
+    PathFragment pf = new PathFragment("/etc/pwd");
+    assertThat("01cc3eeea3a2f58e447e824f9f62d3d1").isEqualTo(
+        new Fingerprint().addPath(pf).hexDigestAndReset());
+    Path p = new InMemoryFileSystem(BlazeClock.instance()).getPath(pf);
+    assertThat("01cc3eeea3a2f58e447e824f9f62d3d1").isEqualTo(
+        new Fingerprint().addPath(p).hexDigestAndReset());
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/util/GroupedListTest.java b/src/test/java/com/google/devtools/build/lib/util/GroupedListTest.java
new file mode 100644
index 0000000..87cd8c9
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/util/GroupedListTest.java
@@ -0,0 +1,247 @@
+// Copyright 2014 Google Inc. 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.util;
+
+import static com.google.common.truth.Truth.assert_;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.devtools.build.lib.util.GroupedList.GroupedListHelper;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+
+@RunWith(JUnit4.class)
+public class GroupedListTest {
+  @Test
+  public void empty() {
+    createSizeN(0);
+  }
+
+  @Test
+  public void sizeOne() {
+    createSizeN(1);
+  }
+
+  @Test
+  public void sizeTwo() {
+    createSizeN(2);
+  }
+
+  @Test
+  public void sizeN() {
+    createSizeN(10);
+  }
+
+  private void createSizeN(int size) {
+    List<String> list = new ArrayList<>();
+    for (int i = 0; i < size; i++) {
+      list.add("test" + i);
+    }
+    Object compressedList = createAndCompress(list);
+    assertTrue(Iterables.elementsEqual(iterable(compressedList), list));
+    assertElementsEqual(compressedList, list);
+  }
+
+  @Test
+  public void elementsNotEqualDifferentOrder() {
+    List<String> list = Lists.newArrayList("a", "b", "c");
+    Object compressedList = createAndCompress(list);
+    ArrayList<String> reversed = new ArrayList<>(list);
+    Collections.reverse(reversed);
+    assertFalse(elementsEqual(compressedList, reversed));
+  }
+
+  @Test
+  public void elementsNotEqualDifferentSizes() {
+    for (int size1 = 0; size1 < 10; size1++) {
+      List<String> firstList = new ArrayList<>();
+      for (int i = 0; i < size1; i++) {
+        firstList.add("test" + i);
+      }
+      Object array = createAndCompress(firstList);
+      for (int size2 = 0; size2 < 10; size2++) {
+        List<String> secondList = new ArrayList<>();
+        for (int i = 0; i < size2; i++) {
+          secondList.add("test" + i);
+        }
+        assertEquals(GroupedList.create(array) + ", " + secondList + ", " + size1 + ", " + size2,
+            size1 == size2, elementsEqual(array, secondList));
+      }
+    }
+  }
+
+  @Test
+  public void group() {
+    GroupedList<String> groupedList = new GroupedList<>();
+    assertTrue(groupedList.isEmpty());
+    GroupedListHelper<String> helper = new GroupedListHelper<>();
+    List<ImmutableList<String>> elements = ImmutableList.of(
+        ImmutableList.of("1"),
+        ImmutableList.of("2a", "2b"),
+        ImmutableList.of("3"),
+        ImmutableList.of("4"),
+        ImmutableList.of("5a", "5b", "5c"),
+        ImmutableList.of("6a", "6b", "6c")
+        );
+    List<String> allElts = new ArrayList<>();
+    for (List<String> group : elements) {
+      if (group.size() > 1) {
+        helper.startGroup();
+      }
+      for (String elt : group) {
+        helper.add(elt);
+      }
+      if (group.size() > 1) {
+        helper.endGroup();
+      }
+      allElts.addAll(group);
+    }
+    groupedList.append(helper);
+    assertEquals(allElts.size(), groupedList.size());
+    assertFalse(groupedList.isEmpty());
+    Object compressed = groupedList.compress();
+    assertElementsEqual(compressed, allElts);
+    assert_().that(GroupedList.create(compressed)).containsExactlyElementsIn(elements).inOrder();
+    assert_().that(groupedList).containsExactlyElementsIn(elements).inOrder();
+  }
+
+  @Test
+  public void singletonAndEmptyGroups() {
+    GroupedList<String> groupedList = new GroupedList<>();
+    assertTrue(groupedList.isEmpty());
+    GroupedListHelper<String> helper = new GroupedListHelper<>();
+    @SuppressWarnings("unchecked") // varargs
+    List<ImmutableList<String>> elements = Lists.newArrayList(
+        ImmutableList.of("1"),
+        ImmutableList.<String>of(),
+        ImmutableList.of("2a", "2b"),
+        ImmutableList.of("3")
+        );
+    List<String> allElts = new ArrayList<>();
+    for (List<String> group : elements) {
+      helper.startGroup(); // Start a group even if the group has only one element or is empty.
+      for (String elt : group) {
+        helper.add(elt);
+      }
+      helper.endGroup();
+      allElts.addAll(group);
+    }
+    groupedList.append(helper);
+    assertEquals(allElts.size(), groupedList.size());
+    assertFalse(groupedList.isEmpty());
+    Object compressed = groupedList.compress();
+    assertElementsEqual(compressed, allElts);
+    // Get rid of empty list -- it was not stored in groupedList.
+    elements.remove(1);
+    assert_().that(GroupedList.create(compressed)).containsExactlyElementsIn(elements).inOrder();
+    assert_().that(groupedList).containsExactlyElementsIn(elements).inOrder();
+  }
+
+  @Test
+  public void removeMakesEmpty() {
+    GroupedList<String> groupedList = new GroupedList<>();
+    assertTrue(groupedList.isEmpty());
+    GroupedListHelper<String> helper = new GroupedListHelper<>();
+    @SuppressWarnings("unchecked") // varargs
+    List<List<String>> elements = Lists.newArrayList(
+        (List<String>) ImmutableList.of("1"),
+        ImmutableList.<String>of(),
+        Lists.newArrayList("2a", "2b"),
+        ImmutableList.of("3"),
+        ImmutableList.of("removedGroup1", "removedGroup2"),
+        ImmutableList.of("4")
+        );
+    List<String> allElts = new ArrayList<>();
+    for (List<String> group : elements) {
+      helper.startGroup(); // Start a group even if the group has only one element or is empty.
+      for (String elt : group) {
+        helper.add(elt);
+      }
+      helper.endGroup();
+      allElts.addAll(group);
+    }
+    groupedList.append(helper);
+    Set<String> removed = ImmutableSet.of("2a", "3", "removedGroup1", "removedGroup2");
+    groupedList.remove(removed);
+    Object compressed = groupedList.compress();
+    allElts.removeAll(removed);
+    assertElementsEqual(compressed, allElts);
+    elements.get(2).remove("2a");
+    elements.remove(ImmutableList.of("3"));
+    elements.remove(ImmutableList.of());
+    elements.remove(ImmutableList.of("removedGroup1", "removedGroup2"));
+    assert_().that(GroupedList.create(compressed)).containsExactlyElementsIn(elements).inOrder();
+    assert_().that(groupedList).containsExactlyElementsIn(elements).inOrder();
+  }
+
+  @Test
+  public void removeGroupFromSmallList() {
+    GroupedList<String> groupedList = new GroupedList<>();
+    assertTrue(groupedList.isEmpty());
+    GroupedListHelper<String> helper = new GroupedListHelper<>();
+    List<List<String>> elements = new ArrayList<>();
+    List<String> group = Lists.newArrayList("1a", "1b", "1c", "1d");
+    elements.add(group);
+    List<String> allElts = new ArrayList<>();
+    helper.startGroup();
+    for (String item : elements.get(0)) {
+      helper.add(item);
+    }
+    allElts.addAll(group);
+    helper.endGroup();
+    groupedList.append(helper);
+    Set<String> removed = ImmutableSet.of("1b", "1c");
+    groupedList.remove(removed);
+    Object compressed = groupedList.compress();
+    allElts.removeAll(removed);
+    assertElementsEqual(compressed, allElts);
+    elements.get(0).removeAll(removed);
+    assert_().that(GroupedList.create(compressed)).containsExactlyElementsIn(elements).inOrder();
+    assert_().that(groupedList).containsExactlyElementsIn(elements).inOrder();
+  }
+
+  private static Object createAndCompress(Collection<String> list) {
+    GroupedList<String> result = new GroupedList<>();
+    result.append(GroupedListHelper.create(list));
+    return result.compress();
+  }
+
+  private static Iterable<String> iterable(Object compressed) {
+    return GroupedList.<String>create(compressed).toSet();
+  }
+
+  private static boolean elementsEqual(Object compressed, Iterable<String> expected) {
+    return Iterables.elementsEqual(GroupedList.<String>create(compressed).toSet(), expected);
+  }
+
+  private static void assertElementsEqual(Object compressed, Iterable<String> expected) {
+    assert_()
+        .that(GroupedList.<String>create(compressed).toSet())
+        .containsExactlyElementsIn(expected)
+        .inOrder();
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/util/JavaClockTest.java b/src/test/java/com/google/devtools/build/lib/util/JavaClockTest.java
new file mode 100644
index 0000000..d5d39c0
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/util/JavaClockTest.java
@@ -0,0 +1,39 @@
+// Copyright 2014 Google Inc. 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.util;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests for the Clock instance based on the Java System class.
+ */
+@RunWith(JUnit4.class)
+public class JavaClockTest {
+
+  @Test
+  public void javaClockIsAdvancing() throws Exception {
+    Clock clock = new JavaClock();
+    long millis = clock.currentTimeMillis();
+    long nanos = clock.nanoTime();
+
+    Thread.sleep(10);
+
+    assertThat(clock.currentTimeMillis()).isNotEqualTo(millis);
+    assertThat(clock.nanoTime()).isNotEqualTo(nanos);
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/util/OptionsUtilsTest.java b/src/test/java/com/google/devtools/build/lib/util/OptionsUtilsTest.java
new file mode 100644
index 0000000..9888061
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/util/OptionsUtilsTest.java
@@ -0,0 +1,157 @@
+// Copyright 2014 Google Inc. 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.util;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.Lists;
+import com.google.devtools.build.lib.util.OptionsUtils.PathFragmentListConverter;
+import com.google.devtools.build.lib.vfs.PathFragment;
+import com.google.devtools.common.options.Option;
+import com.google.devtools.common.options.OptionPriority;
+import com.google.devtools.common.options.OptionsBase;
+import com.google.devtools.common.options.OptionsParser;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Test for {@link OptionsUtils}.
+ */
+@RunWith(JUnit4.class)
+public class OptionsUtilsTest {
+
+  public static class IntrospectionExample extends OptionsBase {
+    @Option(name = "alpha",
+            category = "one",
+            defaultValue = "alpha")
+    public String alpha;
+
+    @Option(name = "beta",
+            category = "one",
+            defaultValue = "beta")
+    public String beta;
+
+    @Option(name = "gamma",
+            category = "undocumented",
+            defaultValue = "gamma")
+    public String gamma;
+
+    @Option(name = "delta",
+            category = "undocumented",
+            defaultValue = "delta")
+    public String delta;
+
+    @Option(name = "echo",
+            category = "hidden",
+            defaultValue = "echo")
+    public String echo;
+  }
+
+  @Test
+  public void asStringOfExplicitOptions() throws Exception {
+    OptionsParser parser = OptionsParser.newOptionsParser(IntrospectionExample.class);
+    parser.parse("--alpha=no", "--gamma=no", "--echo=no");
+    assertEquals("--alpha=no --gamma=no", OptionsUtils.asShellEscapedString(parser));
+  }
+
+  @Test
+  public void asStringOfExplicitOptionsCorrectSortingByPriority() throws Exception {
+    OptionsParser parser = OptionsParser.newOptionsParser(IntrospectionExample.class);
+    parser.parse(OptionPriority.COMMAND_LINE, null, Arrays.asList("--alpha=no"));
+    parser.parse(OptionPriority.COMPUTED_DEFAULT, null, Arrays.asList("--beta=no"));
+    assertEquals("--beta=no --alpha=no", OptionsUtils.asShellEscapedString(parser));
+  }
+
+  public static class BooleanOpts extends OptionsBase {
+    @Option(name = "b_one",
+        category = "xyz",
+        defaultValue = "true")
+    public boolean bOne;
+
+    @Option(name = "b_two",
+        category = "123", // Not printed in usage messages!
+        defaultValue = "false")
+    public boolean bTwo;
+  }
+
+  @Test
+  public void asStringOfExplicitOptionsWithBooleans() throws Exception {
+    OptionsParser parser = OptionsParser.newOptionsParser(BooleanOpts.class);
+    parser.parse(OptionPriority.COMMAND_LINE, null, Arrays.asList("--b_one", "--nob_two"));
+    assertEquals("--b_one --nob_two", OptionsUtils.asShellEscapedString(parser));
+
+    parser = OptionsParser.newOptionsParser(BooleanOpts.class);
+    parser.parse(OptionPriority.COMMAND_LINE, null, Arrays.asList("--b_one=true", "--b_two=0"));
+    assertTrue(parser.getOptions(BooleanOpts.class).bOne);
+    assertFalse(parser.getOptions(BooleanOpts.class).bTwo);
+    assertEquals("--b_one --nob_two", OptionsUtils.asShellEscapedString(parser));
+  }
+
+  @Test
+  public void asStringOfExplicitOptionsMultipleOptionsAreMultipleTimes() throws Exception {
+    OptionsParser parser = OptionsParser.newOptionsParser(IntrospectionExample.class);
+    parser.parse(OptionPriority.COMMAND_LINE, null, Arrays.asList("--alpha=one"));
+    parser.parse(OptionPriority.COMMAND_LINE, null, Arrays.asList("--alpha=two"));
+    assertEquals("--alpha=one --alpha=two", OptionsUtils.asShellEscapedString(parser));
+  }
+
+  private static List<PathFragment> list(PathFragment... fragments) {
+    return Lists.newArrayList(fragments);
+  }
+
+  private PathFragment fragment(String string) {
+    return new PathFragment(string);
+  }
+
+  private List<PathFragment> convert(String input) throws Exception {
+    return new PathFragmentListConverter().convert(input);
+  }
+
+  @Test
+  public void emptyStringYieldsEmptyList() throws Exception {
+    assertEquals(list(), convert(""));
+  }
+
+  @Test
+  public void lonelyDotYieldsLonelyDot() throws Exception {
+    assertEquals(list(fragment(".")), convert("."));
+  }
+
+  @Test
+  public void converterSkipsEmptyStrings() throws Exception {
+    assertEquals(list(fragment("foo"), fragment("bar")), convert("foo::bar:"));
+  }
+
+  @Test
+  public void multiplePaths() throws Exception {
+    assertEquals(list(fragment("foo"), fragment("/bar/baz"), fragment("."),
+                 fragment("/tmp/bang")), convert("foo:/bar/baz:.:/tmp/bang"));
+  }
+
+  @Test
+  public void valueisUnmodifiable() throws Exception {
+    try {
+      new PathFragmentListConverter().convert("value").add(new PathFragment("other"));
+      fail("could modify value");
+    } catch (UnsupportedOperationException expected) {}
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/util/PairTest.java b/src/test/java/com/google/devtools/build/lib/util/PairTest.java
new file mode 100644
index 0000000..f82e12f
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/util/PairTest.java
@@ -0,0 +1,52 @@
+// Copyright 2014 Google Inc. 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.util;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.Objects;
+
+/**
+ * Tests for {@link Pair}.
+ */
+@RunWith(JUnit4.class)
+public class PairTest {
+
+  @Test
+  public void constructor() {
+    Object a = new Object();
+    Object b = new Object();
+    Pair<Object, Object> p = Pair.of(a, b);
+    assertSame(a, p.first);
+    assertSame(b, p.second);
+    assertEquals(Pair.of(a, b), p);
+    assertEquals(Objects.hash(a, b), p.hashCode());
+  }
+
+  @Test
+  public void nullable() {
+    Pair<Object, Object> p = Pair.of(null, null);
+    assertNull(p.first);
+    assertNull(p.second);
+    p.hashCode(); // Should not throw.
+    assertTrue(p.equals(p));
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/util/PathFragmentFilterTest.java b/src/test/java/com/google/devtools/build/lib/util/PathFragmentFilterTest.java
new file mode 100644
index 0000000..e911324
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/util/PathFragmentFilterTest.java
@@ -0,0 +1,95 @@
+// Copyright 2014 Google Inc. 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.util;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import com.google.devtools.build.lib.vfs.PathFragment;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * A test for {@link PathFragmentFilter}.
+ */
+@RunWith(JUnit4.class)
+public class PathFragmentFilterTest {
+  protected PathFragmentFilter filter = null;
+
+  protected void createFilter(String filterString) {
+    filter = new PathFragmentFilter.PathFragmentFilterConverter().convert(filterString);
+  }
+
+  protected void assertIncluded(String path) {
+    assertTrue(filter.isIncluded(new PathFragment(path)));
+  }
+
+  protected void assertExcluded(String path) {
+    assertFalse(filter.isIncluded(new PathFragment(path)));
+  }
+
+  @Test
+  public void emptyFilter() {
+    createFilter("");
+    assertIncluded("a/b/c");
+    assertIncluded("d");
+  }
+
+  @Test
+  public void inclusions() {
+    createFilter("a/b,c");
+    assertIncluded("a/b");
+    assertIncluded("a/b/c");
+    assertIncluded("c");
+    assertIncluded("c/d");
+    assertExcluded("a");
+    assertExcluded("a/c");
+    assertExcluded("d");
+    assertExcluded("e/f/g");
+  }
+
+  @Test
+  public void exclusions() {
+    createFilter("-a/b,-c");
+    assertExcluded("a/b");
+    assertExcluded("a/b/c");
+    assertExcluded("c");
+    assertExcluded("c/d");
+    assertIncluded("a");
+    assertIncluded("a/c");
+    assertIncluded("d");
+    assertIncluded("e/f/g");
+  }
+
+  @Test
+  public void inclusionsAndExclusions() {
+    createFilter("a,-c,,d,a/b/c,-a/b,a/b/d");
+    assertIncluded("a");
+    assertIncluded("a/c");
+    assertExcluded("a/b");
+    assertExcluded("a/b/c"); // Exclusions take precedence over inclusions. Order is not important.
+    assertExcluded("a/b/d"); // Exclusions take precedence over inclusions. Order is not important.
+    assertExcluded("c");
+    assertExcluded("c/d");
+    assertIncluded("d/e");
+    assertExcluded("e");
+    // When converted back to string, inclusion entries will be put first, followed by exclusion
+    // entries.
+    assertEquals("a,d,a/b/c,a/b/d,-c,-a/b", filter.toString());
+  }
+
+}
diff --git a/src/test/java/com/google/devtools/build/lib/util/PersistentMapTest.java b/src/test/java/com/google/devtools/build/lib/util/PersistentMapTest.java
new file mode 100644
index 0000000..44aa538
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/util/PersistentMapTest.java
@@ -0,0 +1,225 @@
+// Copyright 2014 Google Inc. 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.util;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import com.google.devtools.build.lib.vfs.Path;
+import com.google.devtools.build.lib.vfs.util.FsApparatus;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Unit tests for the {@link PersistentMap}.
+ */
+@RunWith(JUnit4.class)
+public class PersistentMapTest {
+  public static class PersistentStringMap extends PersistentMap<String, String> {
+    boolean updateJournal = true;
+    boolean keepJournal = false;
+
+    public PersistentStringMap(Map<String, String> map, Path mapFile,
+        Path journalFile) throws IOException {
+      super(0x0, map, mapFile, journalFile);
+      load();
+    }
+
+    @Override
+    protected String readKey(DataInputStream in) throws IOException {
+      return in.readUTF();
+    }
+    @Override
+    protected String readValue(DataInputStream in) throws IOException {
+      return in.readUTF();
+    }
+    @Override
+    protected void writeKey(String key, DataOutputStream out)
+        throws IOException {
+      out.writeUTF(key);
+    }
+    @Override
+    protected void writeValue(String value, DataOutputStream out)
+        throws IOException {
+      out.writeUTF(value);
+    }
+    @Override
+    protected boolean updateJournal() {
+      return updateJournal;
+    }
+    @Override
+    protected boolean keepJournal() {
+      return keepJournal;
+    }
+  }
+
+  private FsApparatus scratch = FsApparatus.newInMemory();
+
+  private PersistentStringMap map;
+  private Path mapFile;
+  private Path journalFile;
+
+  @Before
+  public void setUp() throws Exception {
+    mapFile = scratch.fs().getPath("/tmp/map.txt");
+    journalFile = scratch.fs().getPath("/tmp/journal.txt");
+    createMap();
+  }
+
+  private void createMap() throws Exception {
+    Map<String, String> map = new HashMap<>();
+    this.map = new PersistentStringMap(map, mapFile, journalFile);
+  }
+
+  @Test
+  public void map() throws Exception {
+    createMap();
+    map.put("foo", "bar");
+    map.put("baz", "bang");
+    assertEquals("bar", map.get("foo"));
+    assertEquals("bang", map.get("baz"));
+    assertEquals(2, map.size());
+    long size = map.save();
+    assertEquals(mapFile.getFileSize(), size);
+    assertEquals("bar", map.get("foo"));
+    assertEquals("bang", map.get("baz"));
+    assertEquals(2, map.size());
+
+    createMap(); // create a new map
+    assertEquals("bar", map.get("foo"));
+    assertEquals("bang", map.get("baz"));
+    assertEquals(2, map.size());
+  }
+
+  @Test
+  public void remove() throws Exception {
+    createMap();
+    map.put("foo", "bar");
+    map.put("baz", "bang");
+    long size = map.save();
+    assertEquals(mapFile.getFileSize(), size);
+    assertFalse(journalFile.exists());
+    map.remove("foo");
+    assertEquals(1, map.size());
+    assertTrue(journalFile.exists());
+    createMap(); // create a new map
+    assertEquals(1, map.size());
+  }
+
+  @Test
+  public void clear() throws Exception {
+    createMap();
+    map.put("foo", "bar");
+    map.put("baz", "bang");
+    map.save();
+    assertTrue(mapFile.exists());
+    assertFalse(journalFile.exists());
+    map.clear();
+    assertEquals(0, map.size());
+    assertTrue(mapFile.exists());
+    assertFalse(journalFile.exists());
+    createMap(); // create a new map
+    assertEquals(0, map.size());
+  }
+
+  @Test
+  public void noUpdateJournal() throws Exception {
+    createMap();
+    map.put("foo", "bar");
+    map.put("baz", "bang");
+    map.save();
+    assertFalse(journalFile.exists());
+    // prevent updating the journal
+    map.updateJournal = false;
+    // remove an entry
+    map.remove("foo");
+    assertEquals(1, map.size());
+    // no journal file written
+    assertFalse(journalFile.exists());
+    createMap(); // create a new map
+    // both entries are still in the map on disk
+    assertEquals(2, map.size());
+  }
+
+  @Test
+  public void keepJournal() throws Exception {
+    createMap();
+    map.put("foo", "bar");
+    map.put("baz", "bang");
+    map.save();
+    assertFalse(journalFile.exists());
+
+    // Keep the journal through the save.
+    map.updateJournal = false;
+    map.keepJournal = true;
+
+    // remove an entry
+    map.remove("foo");
+    assertEquals(1, map.size());
+    // no journal file written
+    assertFalse(journalFile.exists());
+
+    long size = map.save();
+    assertEquals(1, map.size());
+    // The journal must be serialzed on save(), even if !updateJournal.
+    assertTrue(journalFile.exists());
+    assertEquals(journalFile.getFileSize() + mapFile.getFileSize(), size);
+
+    map.load();
+    assertEquals(1, map.size());
+    assertTrue(journalFile.exists());
+
+    createMap(); // create a new map
+    assertEquals(1, map.size());
+
+    map.keepJournal = false;
+    map.save();
+    assertEquals(1, map.size());
+    assertFalse(journalFile.exists());
+  }
+
+  @Test
+  public void multipleJournalUpdates() throws Exception {
+    createMap();
+    map.put("foo", "bar");
+    map.save();
+    assertFalse(journalFile.exists());
+    // add an entry
+    map.put("baz", "bang");
+    assertEquals(2, map.size());
+    // journal file written
+    assertTrue(journalFile.exists());
+    createMap(); // create a new map
+    // both entries are still in the map on disk
+    assertEquals(2, map.size());
+    // add another entry
+    map.put("baz2", "bang2");
+    assertEquals(3, map.size());
+    // journal file written
+    assertTrue(journalFile.exists());
+    createMap(); // create a new map
+    // all three entries are still in the map on disk
+    assertEquals(3, map.size());
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/util/ProcMeminfoParserTest.java b/src/test/java/com/google/devtools/build/lib/util/ProcMeminfoParserTest.java
new file mode 100644
index 0000000..9d04f28
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/util/ProcMeminfoParserTest.java
@@ -0,0 +1,91 @@
+// Copyright 2014 Google Inc. 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.util;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+import com.google.devtools.build.lib.vfs.util.FsApparatus;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.IOException;
+
+/**
+ * Tests for ProcMeminfoParser.
+ */
+@RunWith(JUnit4.class)
+public class ProcMeminfoParserTest {
+
+  private FsApparatus scratch = FsApparatus.newNative();
+
+  @Test
+  public void memInfo() throws IOException {
+    String meminfoContent = StringUtilities.joinLines(
+        "MemTotal:      3091732 kB",
+        "MemFree:       2167344 kB",
+        "Buffers:         60644 kB",
+        "Cached:         509940 kB",
+        "SwapCached:          0 kB",
+        "Active:         636892 kB",
+        "Inactive:       212760 kB",
+        "HighTotal:           0 kB",
+        "HighFree:            0 kB",
+        "LowTotal:      3091732 kB",
+        "LowFree:       2167344 kB",
+        "SwapTotal:     9124880 kB",
+        "SwapFree:      9124880 kB",
+        "Dirty:               0 kB",
+        "Writeback:           0 kB",
+        "AnonPages:      279028 kB",
+        "Mapped:          54404 kB",
+        "Slab:            42820 kB",
+        "PageTables:       5184 kB",
+        "NFS_Unstable:        0 kB",
+        "Bounce:              0 kB",
+        "CommitLimit:  10670744 kB",
+        "Committed_AS:   665840 kB",
+        "VmallocTotal: 34359738367 kB",
+        "VmallocUsed:    300484 kB",
+        "VmallocChunk: 34359437307 kB",
+        "HugePages_Total:     0",
+        "HugePages_Free:      0",
+        "HugePages_Rsvd:      0",
+        "Hugepagesize:     2048 kB",
+        "Bogus: not_a_number",
+        "Bogus2: 1000000000000000000000000000000000000000000000000 kB"
+    );
+
+    String meminfoFile = scratch.file("test_meminfo", meminfoContent).getPathString();
+    ProcMeminfoParser memInfo = new ProcMeminfoParser(meminfoFile);
+
+    assertEquals(2356756, memInfo.getFreeRamKb());
+    assertEquals(509940, memInfo.getRamKb("Cached"));
+    assertEquals(3091732, memInfo.getTotalKb());
+    assertNotAvailable("Bogus", memInfo);
+    assertNotAvailable("Bogus2", memInfo);
+  }
+
+  private static void assertNotAvailable(String field, ProcMeminfoParser memInfo) {
+    try {
+      memInfo.getRamKb(field);
+      fail();
+    } catch (IllegalArgumentException e) {
+      // Expected.
+    }
+  }
+
+}
diff --git a/src/test/java/com/google/devtools/build/lib/util/RegexFilterTest.java b/src/test/java/com/google/devtools/build/lib/util/RegexFilterTest.java
new file mode 100644
index 0000000..bb502c7
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/util/RegexFilterTest.java
@@ -0,0 +1,141 @@
+// Copyright 2014 Google Inc. 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.util;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.testing.EqualsTester;
+import com.google.devtools.common.options.OptionsParsingException;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * A test for {@link RegexFilter}.
+ */
+@RunWith(JUnit4.class)
+public class RegexFilterTest {
+  protected RegexFilter filter = null;
+
+  protected RegexFilter createFilter(String filterString) throws OptionsParsingException {
+    filter = new RegexFilter.RegexFilterConverter().convert(filterString);
+    return filter;
+  }
+
+  protected void assertIncluded(String value) {
+    assertTrue(filter.isIncluded(value));
+  }
+
+  protected void assertExcluded(String value) {
+    assertFalse(filter.isIncluded(value));
+  }
+
+  @Test
+  public void emptyFilter() throws Exception {
+    createFilter("");
+    assertIncluded("a/b/c");
+    assertIncluded("d");
+  }
+
+  @Test
+  public void inclusions() throws Exception {
+    createFilter("a/b,+^c,_test$");
+    assertEquals("(?:(?>a/b)|(?>^c)|(?>_test$))", filter.toString());
+    assertIncluded("a/b");
+    assertIncluded("a/b/c");
+    assertIncluded("c");
+    assertIncluded("c/d");
+    assertIncluded("e/a/b");
+    assertIncluded("f/1/2/3/_test");
+    assertExcluded("a");
+    assertExcluded("a/c");
+    assertExcluded("d");
+    assertExcluded("e/f/g");
+    assertExcluded("f/_test2");
+  }
+
+  @Test
+  public void exclusions() throws Exception {
+    createFilter("-a/b,-^c,-_test$");
+    assertEquals("-(?:(?>a/b)|(?>^c)|(?>_test$))", filter.toString());
+    assertExcluded("a/b");
+    assertExcluded("a/b/c");
+    assertExcluded("c");
+    assertExcluded("c/d");
+    assertExcluded("f/a/b/d");
+    assertExcluded("f/a_test");
+    assertIncluded("a");
+    assertIncluded("a/c");
+    assertIncluded("d");
+    assertIncluded("e/f/g");
+    assertIncluded("f/a_test_case");
+  }
+
+  @Test
+  public void inclusionsAndExclusions() throws Exception {
+    createFilter("a,-^c,,-,+,d,+a/b/c,-a/b,a/b/d");
+    assertEquals("(?:(?>a)|(?>d)|(?>a/b/c)|(?>a/b/d)),-(?:(?>^c)|(?>a/b))", filter.toString());
+    assertIncluded("a");
+    assertIncluded("a/c");
+    assertExcluded("a/b");
+    assertExcluded("a/b/c"); // Exclusions take precedence over inclusions. Order is not important.
+    assertExcluded("a/b/d"); // Exclusions take precedence over inclusions. Order is not important.
+    assertExcluded("a/c/a/b/d");
+    assertExcluded("c");
+    assertExcluded("c/d");
+    assertIncluded("d/e");
+    assertExcluded("e");
+  }
+
+  @Test
+  public void commas() throws Exception {
+    createFilter("a\\,b,c\\,d");
+    assertEquals("(?:(?>a\\,b)|(?>c\\,d))", filter.toString());
+    assertIncluded("a,b");
+    assertIncluded("c,d");
+    assertExcluded("a");
+    assertExcluded("b,c");
+    assertExcluded("d");
+  }
+
+  @Test
+  public void invalidExpression() throws Exception {
+    try {
+      createFilter("*a");
+      fail(); // OptionsParsingException should be thrown.
+    } catch (OptionsParsingException e) {
+      assertThat(e.getMessage())
+          .contains("Failed to build valid regular expression: Dangling meta character '*' "
+              + "near index");
+    }
+  }
+
+  @Test
+  public void equals() throws Exception {
+    new EqualsTester()
+      .addEqualityGroup(createFilter("a,b,c"), createFilter("a,b,c"))
+      .addEqualityGroup(createFilter("a,b,c,d"))
+      .addEqualityGroup(createFilter("a,b,-c"), createFilter("a,b,-c"))
+      .addEqualityGroup(createFilter("a,b,-c,-d"))
+      .addEqualityGroup(createFilter("-a,-b,-c"), createFilter("-a,-b,-c"))
+      .addEqualityGroup(createFilter("-a,-b,-c,-d"))
+      .addEqualityGroup(createFilter(""), createFilter(""))
+      .testEquals();
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/util/ResourceFileLoaderTest.java b/src/test/java/com/google/devtools/build/lib/util/ResourceFileLoaderTest.java
new file mode 100644
index 0000000..e821ca1
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/util/ResourceFileLoaderTest.java
@@ -0,0 +1,49 @@
+// Copyright 2014 Google Inc. 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.util;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.IOException;
+
+/**
+ * A test for {@link ResourceFileLoader}.
+ */
+@RunWith(JUnit4.class)
+public class ResourceFileLoaderTest {
+
+  @Test
+  public void loader() throws IOException {
+    String message = ResourceFileLoader.loadResource(
+        ResourceFileLoaderTest.class, "ResourceFileLoaderTest.message");
+    assertEquals("Hello, world.", message);
+  }
+
+  @Test
+  public void resourceNotFound() {
+    try {
+      ResourceFileLoader.loadResource(ResourceFileLoaderTest.class,
+          "does_not_exist.txt");
+      fail();
+    } catch (IOException e) {
+      assertEquals("does_not_exist.txt not found.", e.getMessage());
+    }
+  }
+
+}
diff --git a/src/test/java/com/google/devtools/build/lib/util/ResourceFileLoaderTest.message b/src/test/java/com/google/devtools/build/lib/util/ResourceFileLoaderTest.message
new file mode 100644
index 0000000..c872090
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/util/ResourceFileLoaderTest.message
@@ -0,0 +1 @@
+Hello, world.
\ No newline at end of file
diff --git a/src/test/java/com/google/devtools/build/lib/util/ShellEscaperTest.java b/src/test/java/com/google/devtools/build/lib/util/ShellEscaperTest.java
new file mode 100644
index 0000000..ac5d413
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/util/ShellEscaperTest.java
@@ -0,0 +1,83 @@
+// Copyright 2014 Google Inc. 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.util;
+
+import static com.google.devtools.build.lib.util.ShellEscaper.escapeString;
+import static org.junit.Assert.assertEquals;
+
+import com.google.common.base.Joiner;
+import com.google.common.collect.ImmutableSet;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.Arrays;
+import java.util.Set;
+
+/**
+ * Tests for {@link ShellEscaper}.
+ *
+ * <p>Based on {@code com.google.io.base.shell.ShellUtilsTest}.
+ */
+@RunWith(JUnit4.class)
+public class ShellEscaperTest {
+
+  @Test
+  public void shellEscape() throws Exception {
+    assertEquals("''", escapeString(""));
+    assertEquals("foo", escapeString("foo"));
+    assertEquals("'foo bar'", escapeString("foo bar"));
+    assertEquals("''\\''foo'\\'''", escapeString("'foo'"));
+    assertEquals("'\\'\\''foo\\'\\'''", escapeString("\\'foo\\'"));
+    assertEquals("'${filename%.c}.o'", escapeString("${filename%.c}.o"));
+    assertEquals("'<html!>'", escapeString("<html!>"));
+  }
+
+  @Test
+  public void escapeAll() throws Exception {
+    Set<String> escaped = ImmutableSet.copyOf(
+        ShellEscaper.escapeAll(Arrays.asList("foo", "@bar", "baz'qux")));
+    assertEquals(ImmutableSet.of("foo", "@bar", "'baz'\\''qux'"), escaped);
+  }
+
+  @Test
+  public void escapeJoinAllIntoAppendable() throws Exception {
+    Appendable appendable = ShellEscaper.escapeJoinAll(
+        new StringBuilder("initial"), Arrays.asList("foo", "$BAR"));
+    assertEquals("initialfoo '$BAR'", appendable.toString());
+  }
+
+  @Test
+  public void escapeJoinAllIntoAppendableWithCustomJoiner() throws Exception {
+    Appendable appendable = ShellEscaper.escapeJoinAll(
+        new StringBuilder("initial"), Arrays.asList("foo", "$BAR"), Joiner.on('|'));
+    assertEquals("initialfoo|'$BAR'", appendable.toString());
+  }
+
+  @Test
+  public void escapeJoinAll() throws Exception {
+    String actual = ShellEscaper.escapeJoinAll(
+        Arrays.asList("foo", "@echo:-", "100", "$US", "a b", "\"qu'ot'es\"", "\"quot\"", "\\"));
+    assertEquals("foo @echo:- 100 '$US' 'a b' '\"qu'\\''ot'\\''es\"' '\"quot\"' '\\'", actual);
+  }
+
+  @Test
+  public void escapeJoinAllWithCustomJoiner() throws Exception {
+    String actual = ShellEscaper.escapeJoinAll(
+        Arrays.asList("foo", "@echo:-", "100", "$US", "a b", "\"qu'ot'es\"", "\"quot\"", "\\"),
+        Joiner.on('|'));
+    assertEquals("foo|@echo:-|100|'$US'|'a b'|'\"qu'\\''ot'\\''es\"'|'\"quot\"'|'\\'", actual);
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/util/StringCanonicalizerTest.java b/src/test/java/com/google/devtools/build/lib/util/StringCanonicalizerTest.java
new file mode 100644
index 0000000..64acddc
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/util/StringCanonicalizerTest.java
@@ -0,0 +1,42 @@
+// Copyright 2014 Google Inc. 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.util;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertSame;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests for String canonicalizer.
+ */
+@RunWith(JUnit4.class)
+public class StringCanonicalizerTest {
+
+  @Test
+  public void twoDifferentStringsAreDifferent() {
+    String stringA = StringCanonicalizer.intern("A");
+    String stringB = StringCanonicalizer.intern("B");
+    assertThat(stringA).isNotEqualTo(stringB);
+  }
+
+  @Test
+  public void twoSameStringsAreCanonicalized() {
+    String stringA1 = StringCanonicalizer.intern(new String("A"));
+    String stringA2 = StringCanonicalizer.intern(new String("A"));
+    assertSame(stringA1, stringA2);
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/util/StringIndexerTest.java b/src/test/java/com/google/devtools/build/lib/util/StringIndexerTest.java
new file mode 100644
index 0000000..693e11a
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/util/StringIndexerTest.java
@@ -0,0 +1,314 @@
+// Copyright 2014 Google Inc. 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.util;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import com.google.common.base.Function;
+import com.google.common.base.Strings;
+import com.google.common.collect.Lists;
+import com.google.common.collect.MapMaker;
+import com.google.common.collect.Maps;
+import com.google.devtools.build.lib.testutil.TestUtils;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.List;
+import java.util.SortedMap;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * Test for the StringIndexer classes.
+ */
+public abstract class StringIndexerTest {
+
+  private static final int ATTEMPTS = 1000;
+  private SortedMap<Integer, String> mappings;
+
+  protected StringIndexer indexer;
+
+  @Before
+  public void setUp() throws Exception {
+    indexer = newIndexer();
+    mappings = Maps.newTreeMap();
+  }
+
+  protected abstract StringIndexer newIndexer();
+
+  protected void assertSize(int expected) {
+    assertEquals(expected, indexer.size());
+  }
+
+  protected void assertNoIndex(String s) {
+    int size = indexer.size();
+    assertEquals(-1, indexer.getIndex(s));
+    assertEquals(size, indexer.size());
+  }
+
+  protected void assertIndex(int expected, String s) {
+    // System.out.println("Adding " + s + ", expecting " + expected);
+    int index = indexer.getOrCreateIndex(s);
+    // System.out.println(csi);
+    assertEquals(expected, index);
+    mappings.put(expected, s);
+  }
+
+  protected void assertContent() {
+    for (int i = 0; i < indexer.size(); i++) {
+      assertNotNull(mappings.get(i));
+      assertEquals(mappings.get(i), indexer.getStringForIndex(i));
+    }
+  }
+
+  private void assertConcurrentUpdates(Function<Integer, String> keyGenerator) throws Exception {
+    final AtomicInteger safeIndex = new AtomicInteger(-1);
+    List<String> keys = Lists.newArrayListWithCapacity(ATTEMPTS);
+    ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 3, 5, TimeUnit.SECONDS,
+        new ArrayBlockingQueue<Runnable>(ATTEMPTS));
+    synchronized(indexer) {
+      for (int i = 0; i < ATTEMPTS; i++) {
+        final String key = keyGenerator.apply(i);
+        keys.add(key);
+        executor.execute(new Runnable() {
+          @Override
+          public void run() {
+            int index = indexer.getOrCreateIndex(key);
+            if (safeIndex.get() < index) { safeIndex.set(index); }
+            indexer.addString(key);
+          }
+        });
+      }
+    }
+    try {
+      while(!executor.getQueue().isEmpty()) {
+        // Validate that we can execute concurrent queries too.
+        if (safeIndex.get() >= 0) {
+          int index = safeIndex.get();
+          // Retrieve string using random existing index and validate reverse mapping.
+          String key = indexer.getStringForIndex(index);
+          assertNotNull(key);
+          assertEquals(index, indexer.getIndex(key));
+        }
+      }
+    } finally {
+      executor.shutdown();
+      executor.awaitTermination(TestUtils.WAIT_TIMEOUT_SECONDS, TimeUnit.SECONDS);
+    }
+    for (String key : keys) {
+      // Validate mapping between keys and indices.
+      assertEquals(key, indexer.getStringForIndex(indexer.getIndex(key)));
+    }
+  }
+
+  @Test
+  public void concurrentAddChildNode() throws Exception {
+    assertConcurrentUpdates(new Function<Integer, String>() {
+      @Override
+      public String apply(Integer from) { return Strings.repeat("a", from + 1); }
+    });
+  }
+
+  @Test
+  public void concurrentSplitNodeSuffix() throws Exception {
+    assertConcurrentUpdates(new Function<Integer, String>() {
+      @Override
+      public String apply(Integer from) { return Strings.repeat("b", ATTEMPTS - from); }
+    });
+  }
+
+  @Test
+  public void concurrentAddBranch() throws Exception {
+    assertConcurrentUpdates(new Function<Integer, String>() {
+      @Override
+      public String apply(Integer from) { return String.format("%08o", from); }
+    });
+  }
+
+  @RunWith(JUnit4.class)
+  public static class CompactStringIndexerTest extends StringIndexerTest {
+    @Override
+    protected StringIndexer newIndexer() {
+      return new CompactStringIndexer(1);
+    }
+
+    @Test
+    public void basicOperations() {
+      assertSize(0);
+      assertNoIndex("abcdef");
+      assertIndex(0, "abcdef"); // root node creation
+      assertIndex(0, "abcdef"); // root node match
+      assertSize(1);
+      assertIndex(2, "abddef"); // node branching, index 1 went to "ab" node.
+      assertSize(3);
+      assertIndex(1, "ab");
+      assertSize(3);
+      assertIndex(3, "abcdefghik"); // new leaf creation
+      assertSize(4);
+      assertIndex(4, "abcdefgh");  // node split
+      assertSize(5);
+      assertNoIndex("a");
+      assertNoIndex("abc");
+      assertNoIndex("abcdefg");
+      assertNoIndex("abcdefghil");
+      assertNoIndex("abcdefghikl");
+      assertContent();
+      indexer.clear();
+      assertSize(0);
+      assertNull(indexer.getStringForIndex(0));
+      assertNull(indexer.getStringForIndex(1000));
+    }
+
+    @Test
+    public void parentIndexUpdate() {
+      assertSize(0);
+      assertIndex(0, "abcdefghik");  // Create 3 nodes with single common parent "abcdefgh".
+      assertIndex(2, "abcdefghlm");  // Index 1 went to "abcdefgh".
+      assertIndex(3, "abcdefghxyz");
+      assertSize(4);
+      assertIndex(5, "abcdpqr"); // Split parent. Index 4 went to "abcd".
+      assertSize(6);
+      assertIndex(1, "abcdefgh"); // Check branch node indices.
+      assertIndex(4, "abcd");
+      assertSize(6);
+      assertContent();
+    }
+
+    @Test
+    public void emptyRootNode() {
+      assertSize(0);
+      assertIndex(0, "abc");
+      assertNoIndex("");
+      assertIndex(2, "def");  // root node key is now empty string and has index 1.
+      assertSize(3);
+      assertIndex(1, "");
+      assertSize(3);
+      assertContent();
+    }
+
+    protected void setupTestContent() {
+      assertSize(0);
+      assertIndex(0, "abcdefghi");  // Create leafs
+      assertIndex(2, "abcdefjkl");
+      assertIndex(3, "abcdefmno");
+      assertIndex(4, "abcdefjklpr");
+      assertIndex(6, "abcdstr");
+      assertIndex(8, "012345");
+      assertSize(9);
+      assertIndex(1, "abcdef");  // Validate inner nodes
+      assertIndex(5, "abcd");
+      assertIndex(7, "");
+      assertSize(9);
+      assertContent();
+    }
+
+    @Test
+    public void dumpContent() {
+      indexer = newIndexer();
+      indexer.addString("abc");
+      String content = indexer.toString();
+      assertThat(content).contains("size = 1");
+      assertThat(content).contains("contentSize = 5");
+      indexer = newIndexer();
+      setupTestContent();
+      content = indexer.toString();
+      assertThat(content).contains("size = 9");
+      assertThat(content).contains("contentSize = 60");
+      System.out.println(indexer);
+    }
+
+    @Test
+    public void addStringResult() {
+      assertSize(0);
+      assertTrue(indexer.addString("abcdef"));
+      assertTrue(indexer.addString("abcdgh"));
+      assertFalse(indexer.addString("abcd"));
+      assertTrue(indexer.addString("ab"));
+    }
+  }
+
+  @RunWith(JUnit4.class)
+  public static class CanonicalStringIndexerTest extends StringIndexerTest{
+    @Override
+    protected StringIndexer newIndexer() {
+      return new CanonicalStringIndexer(new MapMaker().<String, Integer>makeMap(),
+                                        new MapMaker().<Integer, String>makeMap());
+    }
+
+    @Test
+    public void basicOperations() {
+      assertSize(0);
+      assertNoIndex("abcdef");
+      assertIndex(0, "abcdef");
+      assertIndex(0, "abcdef");
+      assertSize(1);
+      assertIndex(1, "abddef");
+      assertSize(2);
+      assertIndex(2, "ab");
+      assertSize(3);
+      assertIndex(3, "abcdefghik");
+      assertSize(4);
+      assertIndex(4, "abcdefgh");
+      assertSize(5);
+      assertNoIndex("a");
+      assertNoIndex("abc");
+      assertNoIndex("abcdefg");
+      assertNoIndex("abcdefghil");
+      assertNoIndex("abcdefghikl");
+      assertContent();
+      indexer.clear();
+      assertSize(0);
+      assertNull(indexer.getStringForIndex(0));
+      assertNull(indexer.getStringForIndex(1000));
+    }
+
+    @Test
+    public void addStringResult() {
+      assertSize(0);
+      assertTrue(indexer.addString("abcdef"));
+      assertTrue(indexer.addString("abcdgh"));
+      assertTrue(indexer.addString("abcd"));
+      assertTrue(indexer.addString("ab"));
+      assertFalse(indexer.addString("ab"));
+    }
+
+    protected void setupTestContent() {
+      assertSize(0);
+      assertIndex(0, "abcdefghi");
+      assertIndex(1, "abcdefjkl");
+      assertIndex(2, "abcdefmno");
+      assertIndex(3, "abcdefjklpr");
+      assertIndex(4, "abcdstr");
+      assertIndex(5, "012345");
+      assertSize(6);
+      assertIndex(6, "abcdef");
+      assertIndex(7, "abcd");
+      assertIndex(8, "");
+      assertIndex(2, "abcdefmno");
+      assertSize(9);
+      assertContent();
+    }
+  }
+
+}
diff --git a/src/test/java/com/google/devtools/build/lib/util/StringTrieTest.java b/src/test/java/com/google/devtools/build/lib/util/StringTrieTest.java
new file mode 100644
index 0000000..dcb9205
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/util/StringTrieTest.java
@@ -0,0 +1,70 @@
+// Copyright 2014 Google Inc. 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.util;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Unit tests for {@link StringTrie}.
+ */
+@RunWith(JUnit4.class)
+public class StringTrieTest {
+  @Test
+  public void empty() {
+    StringTrie<Integer> cut = new StringTrie<>();
+    assertNull(cut.get(""));
+    assertNull(cut.get("a"));
+    assertNull(cut.get("ab"));
+  }
+
+  @Test
+  public void simple() {
+    StringTrie<Integer> cut = new StringTrie<>();
+    cut.put("a", 1);
+    cut.put("b", 2);
+
+    assertNull(cut.get(""));
+    assertEquals(1, cut.get("a").intValue());
+    assertEquals(1, cut.get("ab").intValue());
+    assertEquals(1, cut.get("abc").intValue());
+
+    assertEquals(2, cut.get("b").intValue());
+  }
+
+  @Test
+  public void ancestors() {
+    StringTrie<Integer> cut = new StringTrie<>();
+    cut.put("abc", 3);
+    assertNull(cut.get(""));
+    assertNull(cut.get("a"));
+    assertNull(cut.get("ab"));
+    assertEquals(3, cut.get("abc").intValue());
+    assertEquals(3, cut.get("abcd").intValue());
+
+    cut.put("a", 1);
+    assertEquals(1, cut.get("a").intValue());
+    assertEquals(1, cut.get("ab").intValue());
+    assertEquals(3, cut.get("abc").intValue());
+
+    cut.put("", 0);
+    assertEquals(0, cut.get("").intValue());
+    assertEquals(0, cut.get("b").intValue());
+    assertEquals(1, cut.get("a").intValue());
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/util/StringUtilTest.java b/src/test/java/com/google/devtools/build/lib/util/StringUtilTest.java
new file mode 100644
index 0000000..96d9a53
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/util/StringUtilTest.java
@@ -0,0 +1,110 @@
+// Copyright 2014 Google Inc. 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.util;
+
+import static com.google.devtools.build.lib.util.StringUtil.capitalize;
+import static com.google.devtools.build.lib.util.StringUtil.indent;
+import static com.google.devtools.build.lib.util.StringUtil.joinEnglishList;
+import static com.google.devtools.build.lib.util.StringUtil.splitAndInternString;
+import static com.google.devtools.build.lib.util.StringUtil.stripSuffix;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertSame;
+
+import com.google.common.collect.ImmutableList;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * A test for {@link StringUtil}.
+ */
+@RunWith(JUnit4.class)
+public class StringUtilTest {
+
+  @Test
+  public void testJoinEnglishList() throws Exception {
+    assertEquals("nothing",
+        joinEnglishList(Collections.emptyList()));
+    assertEquals("one",
+        joinEnglishList(Arrays.asList("one")));
+    assertEquals("one or two",
+        joinEnglishList(Arrays.asList("one", "two")));
+    assertEquals("one and two",
+        joinEnglishList(Arrays.asList("one", "two"), "and"));
+    assertEquals("one, two or three",
+        joinEnglishList(Arrays.asList("one", "two", "three")));
+    assertEquals("one, two and three",
+        joinEnglishList(Arrays.asList("one", "two", "three"), "and"));
+    assertEquals("'one', 'two' and 'three'",
+        joinEnglishList(Arrays.asList("one", "two", "three"), "and", "'"));
+  }
+
+  @Test
+  public void splitAndIntern() throws Exception {
+    assertEquals(ImmutableList.of(), splitAndInternString("       "));
+    assertEquals(ImmutableList.of(), splitAndInternString(null));
+    List<String> list1 = splitAndInternString("    x y    z    z");
+    List<String> list2 = splitAndInternString("a z    c z");
+
+    assertEquals(ImmutableList.of("x", "y", "z", "z"), list1);
+    assertEquals(ImmutableList.of("a", "z", "c", "z"), list2);
+    assertSame(list1.get(2), list1.get(3));
+    assertSame(list1.get(2), list2.get(1));
+    assertSame(list2.get(1), list2.get(3));
+  }
+
+  @Test
+  public void listItemsWithLimit() throws Exception {
+    assertEquals("begin/a, b, c/end", StringUtil.listItemsWithLimit(
+        new StringBuilder("begin/"), 3, ImmutableList.of("a", "b", "c")).append("/end").toString());
+
+    assertEquals("begin/a, b, c ...(omitting 2 more item(s))/end", StringUtil.listItemsWithLimit(
+        new StringBuilder("begin/"), 3, ImmutableList.of("a", "b", "c", "d", "e"))
+            .append("/end").toString());
+  }
+
+  @Test
+  public void testIndent() throws Exception {
+    assertEquals("", indent("", 0));
+    assertEquals("", indent("", 1));
+    assertEquals("a", indent("a", 1));
+    assertEquals("\n  a", indent("\na", 2));
+    assertEquals("a\n  b", indent("a\nb", 2));
+    assertEquals("a\n b\n c\n d", indent("a\nb\nc\nd", 1));
+    assertEquals("\n ", indent("\n", 1));
+  }
+
+  @Test
+  public void testStripSuffix() throws Exception {
+    assertEquals("", stripSuffix("", ""));
+    assertEquals(null, stripSuffix("", "a"));
+    assertEquals("a", stripSuffix("a", ""));
+    assertEquals("a", stripSuffix("aa", "a"));
+    assertEquals(null, stripSuffix("ab", "c"));
+  }
+
+  @Test
+  public void testCapitalize() throws Exception {
+    assertEquals("", capitalize(""));
+    assertEquals("Joe", capitalize("joe"));
+    assertEquals("Joe", capitalize("Joe"));
+    assertEquals("O", capitalize("o"));
+    assertEquals("O", capitalize("O"));
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/util/StringUtilitiesTest.java b/src/test/java/com/google/devtools/build/lib/util/StringUtilitiesTest.java
new file mode 100644
index 0000000..c8ed641
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/util/StringUtilitiesTest.java
@@ -0,0 +1,195 @@
+// Copyright 2014 Google Inc. 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.util;
+
+import static com.google.devtools.build.lib.util.StringUtilities.combineKeys;
+import static com.google.devtools.build.lib.util.StringUtilities.joinLines;
+import static com.google.devtools.build.lib.util.StringUtilities.layoutTable;
+import static com.google.devtools.build.lib.util.StringUtilities.prettyPrintBytes;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.Maps;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * A test for {@link StringUtilities}.
+ */
+@RunWith(JUnit4.class)
+public class StringUtilitiesTest {
+
+  // Tests of StringUtilities.joinLines()
+
+  @Test
+  public void emptyLinesYieldsEmptyString() {
+    assertEquals("", joinLines());
+  }
+
+  @Test
+  public void twoLinesGetjoinedNicely() {
+    assertEquals("line 1\nline 2", joinLines("line 1", "line 2"));
+  }
+
+  @Test
+  public void aTrailingNewlineIsAvailableWhenYouNeedIt() {
+    assertEquals("two lines\nwith trailing newline\n",
+        joinLines("two lines", "with trailing newline", ""));
+  }
+
+  // Tests of StringUtilities.combineKeys()
+
+  /** Simple sanity test of format */
+  @Test
+  public void combineKeysFormat() {
+    assertEquals("<a><b!!c><!<d!>>", combineKeys("a", "b!c", "<d>"));
+  }
+
+  /**
+   * Test that combining different keys gives different results,
+   * i.e. that there are no collisions.
+   * We test all combinations of up to 3 keys from the test_keys
+   * array (defined below).
+   */
+  @Test
+  public void testCombineKeys() {
+    // This map is really just used as a set, but
+    // if the test fails, the values in the map may be
+    // useful for debugging.
+    Map<String,String[]> map = new HashMap<>();
+    for (int numKeys = 0; numKeys <= 3; numKeys++) {
+      testCombineKeys(map, numKeys, new String[numKeys]);
+    }
+  }
+
+  private void testCombineKeys(Map<String,String[]> map,
+        int n, String[] keys) {
+    if (n == 0) {
+      String[] keys_copy = keys.clone();
+      String combined_key = combineKeys(keys_copy);
+      String[] prev_keys = map.put(combined_key, keys_copy);
+      if (prev_keys != null) {
+        fail("combineKeys collision:\n" +
+              "key sequence 1: " + Arrays.deepToString(prev_keys) + "\n" +
+              "key sequence 2: " + Arrays.deepToString(keys_copy) + "\n" +
+              "combined key sequence 1: " + combineKeys(prev_keys) + "\n" +
+              "combined key sequence 2: " + combineKeys(keys_copy) + "\n");
+      }
+    } else {
+      for (String key : test_keys) {
+        keys[n - 1] = key;
+        testCombineKeys(map, n - 1, keys);
+      }
+    }
+  }
+
+  private static final String[] test_keys = {
+        // ordinary strings
+        "", "a", "word", "//depot/foo/bar",
+        // likely delimiter characters
+        " ", ",", "\\", "\"", "\'", "\0", "\u00ff",
+        // strings starting in special delimiter
+        " foo", ",foo", "\\foo", "\"foo", "\'foo", "\0foo", "\u00fffoo",
+        // strings ending in special delimiter
+        "bar ", "bar,", "bar\\", "bar\"", "bar\'", "bar\0", "bar\u00ff",
+        // white-box testing of the delimiters that combineKeys() uses
+        "<", ">", "!", "!<", "!>", "!!", "<!", ">!"
+  };
+
+  @Test
+  public void replaceAllLiteral() throws Exception {
+    assertEquals("ababab",
+                 StringUtilities.replaceAllLiteral("bababa", "ba", "ab"));
+    assertEquals("",
+        StringUtilities.replaceAllLiteral("bababa", "ba", ""));
+    assertEquals("bababa",
+        StringUtilities.replaceAllLiteral("bababa", "", "ab"));
+  }
+
+  @Test
+  public void testLayoutTable() throws Exception {
+    Map<String, String> data = Maps.newTreeMap();
+    data.put("foo", "bar");
+    data.put("bang", "baz");
+    data.put("lengthy key", "lengthy value");
+
+    assertEquals(joinLines("bang: baz",
+                           "foo: bar",
+                           "lengthy key: lengthy value"), layoutTable(data));
+  }
+
+  @Test
+  public void testPrettyPrintBytes() {
+    String[] expected = {
+      "2B",
+      "23B",
+      "234B",
+      "2345B",
+      "23KB",
+      "234KB",
+      "2345KB",
+      "23MB",
+      "234MB",
+      "2345MB",
+      "23456MB",
+      "234GB",
+      "2345GB",
+      "23456GB",
+    };
+    double x = 2.3456;
+    for (int ii = 0; ii < expected.length; ++ii) {
+      assertEquals(expected[ii], prettyPrintBytes((long) x));
+      x = x * 10.0;
+    }
+  }
+
+  @Test
+  public void sanitizeControlChars() {
+    assertEquals("<?>", StringUtilities.sanitizeControlChars("\000"));
+    assertEquals("<?>", StringUtilities.sanitizeControlChars("\001"));
+    assertEquals("\\r", StringUtilities.sanitizeControlChars("\r"));
+    assertEquals(" abc123", StringUtilities.sanitizeControlChars(" abc123"));
+  }
+
+  @Test
+  public void containsSubarray() {
+    assertTrue(StringUtilities.containsSubarray("abcde".toCharArray(), "ab".toCharArray()));
+    assertTrue(StringUtilities.containsSubarray("abcde".toCharArray(), "de".toCharArray()));
+    assertTrue(StringUtilities.containsSubarray("abcde".toCharArray(), "bc".toCharArray()));
+    assertTrue(StringUtilities.containsSubarray("abcde".toCharArray(), "".toCharArray()));
+  }
+
+  @Test
+  public void notContainsSubarray() {
+    assertFalse(StringUtilities.containsSubarray("abc".toCharArray(), "abcd".toCharArray()));
+    assertFalse(StringUtilities.containsSubarray("abc".toCharArray(), "def".toCharArray()));
+    assertFalse(StringUtilities.containsSubarray("abcde".toCharArray(), "bd".toCharArray()));
+  }
+
+  @Test
+  public void toPythonStyleFunctionName() {
+    assertEquals("a", StringUtilities.toPythonStyleFunctionName("a"));
+    assertEquals("a_b", StringUtilities.toPythonStyleFunctionName("aB"));
+    assertEquals("a_b_c", StringUtilities.toPythonStyleFunctionName("aBC"));
+    assertEquals("a_bc_d", StringUtilities.toPythonStyleFunctionName("aBcD"));
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/util/TargetUtilsTest.java b/src/test/java/com/google/devtools/build/lib/util/TargetUtilsTest.java
new file mode 100644
index 0000000..33b0fe3
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/util/TargetUtilsTest.java
@@ -0,0 +1,36 @@
+// Copyright 2014 Google Inc. 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.util;
+
+import static org.junit.Assert.assertEquals;
+
+import com.google.devtools.build.lib.packages.TargetUtils;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Test for {@link TargetUtils}
+ */
+@RunWith(JUnit4.class)
+public class TargetUtilsTest {
+
+  @Test
+  public void getRuleLanguage() {
+    assertEquals("java", TargetUtils.getRuleLanguage("java_binary"));
+    assertEquals("foobar", TargetUtils.getRuleLanguage("foobar"));
+    assertEquals("", TargetUtils.getRuleLanguage(""));
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/util/io/AnsiTerminalPrinterTest.java b/src/test/java/com/google/devtools/build/lib/util/io/AnsiTerminalPrinterTest.java
new file mode 100644
index 0000000..d75208f
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/util/io/AnsiTerminalPrinterTest.java
@@ -0,0 +1,94 @@
+// Copyright 2014 Google Inc. 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.util.io;
+
+import static com.google.devtools.build.lib.util.io.AnsiTerminalPrinter.Mode;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import com.google.devtools.build.lib.testutil.MoreAsserts;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.ByteArrayOutputStream;
+
+/**
+ * A test for {@link AnsiTerminalPrinter}.
+ */
+@RunWith(JUnit4.class)
+public class AnsiTerminalPrinterTest {
+  private ByteArrayOutputStream stream;
+  private AnsiTerminalPrinter printer;
+
+  @Before
+  public void setUp() throws Exception {
+    stream = new ByteArrayOutputStream(1000);
+    printer = new AnsiTerminalPrinter(stream, true);
+  }
+
+  private void setPlainPrinter() {
+    printer = new AnsiTerminalPrinter(stream, false);
+  }
+
+  private void assertString(String string) {
+    assertEquals(string, stream.toString());
+  }
+
+  private void assertRegex(String regex) {
+    MoreAsserts.assertStdoutContainsRegex(regex, stream.toString(), "");
+  }
+
+  @Test
+  public void testPlainPrinter() throws Exception {
+    setPlainPrinter();
+    printer.print("1" + Mode.INFO + "2" + Mode.ERROR + "3" + Mode.WARNING + "4"
+        + Mode.DEFAULT + "5");
+    assertString("12345");
+  }
+
+  @Test
+  public void testDefaultModeIsDefault() throws Exception {
+    printer.print("1" + Mode.DEFAULT + "2");
+    assertString("12");
+  }
+
+  @Test
+  public void testDuplicateMode() throws Exception {
+    printer.print("_A_" + Mode.INFO);
+    printer.print("_B_" + Mode.INFO + "_C_");
+    assertRegex("^_A_.+_B__C_$");
+  }
+
+  @Test
+  public void testModeCodes() throws Exception {
+    printer.print(Mode.INFO + "XXX" + Mode.ERROR + "XXX" + Mode.WARNING +"XXX" + Mode.DEFAULT
+        + "XXX" + Mode.INFO + "XXX" + Mode.ERROR + "XXX" + Mode.WARNING +"XXX" + Mode.DEFAULT);
+    String[] codes = stream.toString().split("XXX");
+    assertEquals(8, codes.length);
+    for (int i = 0; i < 4; i++) {
+      assertTrue(codes[i].length() > 0);
+      assertEquals(codes[i], codes[i+4]);
+    }
+    assertFalse(codes[0].equals(codes[1]));
+    assertFalse(codes[0].equals(codes[2]));
+    assertFalse(codes[0].equals(codes[3]));
+    assertFalse(codes[1].equals(codes[2]));
+    assertFalse(codes[1].equals(codes[3]));
+    assertFalse(codes[2].equals(codes[3]));
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/util/io/DelegatingOutErrTest.java b/src/test/java/com/google/devtools/build/lib/util/io/DelegatingOutErrTest.java
new file mode 100644
index 0000000..ed644d1
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/util/io/DelegatingOutErrTest.java
@@ -0,0 +1,72 @@
+// Copyright 2014 Google Inc. 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.util.io;
+
+import static com.google.devtools.build.lib.util.StringUtilities.joinLines;
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * A test for {@link DelegatingOutErr}.
+ */
+@RunWith(JUnit4.class)
+public class DelegatingOutErrTest {
+
+  @Test
+  public void testNewDelegateIsLikeDevNull() {
+    DelegatingOutErr delegate = new DelegatingOutErr();
+    delegate.printOut("Hello, world.\n");
+    delegate.printErr("Feel free to ignore me.\n");
+  }
+
+  @Test
+  public void testSubscribeAndUnsubscribeSink() {
+    DelegatingOutErr delegate = new DelegatingOutErr();
+    delegate.printOut("Nobody will listen to this.\n");
+    RecordingOutErr sink = new RecordingOutErr();
+    delegate.addSink(sink);
+    delegate.printOutLn("Hello, sink.");
+    delegate.removeSink(sink);
+    delegate.printOutLn("... and alone again ...");
+    delegate.addSink(sink);
+    delegate.printOutLn("How are things?");
+    assertEquals("Hello, sink.\nHow are things?\n", sink.outAsLatin1());
+  }
+
+  @Test
+  public void testSubscribeMultipleSinks() {
+    DelegatingOutErr delegate = new DelegatingOutErr();
+    RecordingOutErr left = new RecordingOutErr();
+    RecordingOutErr right = new RecordingOutErr();
+    delegate.addSink(left);
+    delegate.printOutLn("left only");
+    delegate.addSink(right);
+    delegate.printOutLn("both");
+    delegate.removeSink(left);
+    delegate.printOutLn("right only");
+    delegate.removeSink(right);
+    delegate.printOutLn("silence");
+    delegate.addSink(left);
+    delegate.addSink(right);
+    delegate.printOutLn("left and right");
+    assertEquals(joinLines("left only", "both", "left and right", ""),
+                 left.outAsLatin1());
+    assertEquals(joinLines("both", "right only", "left and right", ""),
+                 right.outAsLatin1());
+  }
+
+}
diff --git a/src/test/java/com/google/devtools/build/lib/util/io/LinePrefixingOutputStreamTest.java b/src/test/java/com/google/devtools/build/lib/util/io/LinePrefixingOutputStreamTest.java
new file mode 100644
index 0000000..b060beb
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/util/io/LinePrefixingOutputStreamTest.java
@@ -0,0 +1,88 @@
+// Copyright 2014 Google Inc. 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.util.io;
+
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+/**
+ * Tests {@link LinePrefixingOutputStream}.
+ */
+@RunWith(JUnit4.class)
+public class LinePrefixingOutputStreamTest {
+
+  private byte[] bytes(String string) {
+    return string.getBytes(UTF_8);
+  }
+
+  private String string(byte[] bytes) {
+    return new String(bytes, UTF_8);
+  }
+
+  private ByteArrayOutputStream out = new ByteArrayOutputStream();
+  private LinePrefixingOutputStream prefixOut =
+      new LinePrefixingOutputStream("Prefix: ", out);
+
+  @Test
+  public void testNoOutputUntilNewline() throws IOException {
+    prefixOut.write(bytes("We won't be seeing any output."));
+    assertEquals("", string(out.toByteArray()));
+  }
+
+  @Test
+  public void testOutputIfFlushed() throws IOException {
+    prefixOut.write(bytes("We'll flush after this line."));
+    prefixOut.flush();
+    assertEquals("Prefix: We'll flush after this line.\n",
+                 string(out.toByteArray()));
+  }
+
+  @Test
+  public void testAutoflushUponNewline() throws IOException {
+    prefixOut.write(bytes("Hello, newline.\n"));
+    assertEquals("Prefix: Hello, newline.\n", string(out.toByteArray()));
+  }
+
+  @Test
+  public void testAutoflushUponEmbeddedNewLine() throws IOException {
+    prefixOut.write(bytes("Hello line1.\nHello line2.\nHello line3.\n"));
+    assertEquals(
+        "Prefix: Hello line1.\nPrefix: Hello line2.\nPrefix: Hello line3.\n",
+        string(out.toByteArray()));
+  }
+
+  @Test
+  public void testBufferMaxLengthFlush() throws IOException {
+    String junk = "lots of characters of non-newline junk. ";
+    while (junk.length() < LineFlushingOutputStream.BUFFER_LENGTH) {
+      junk = junk + junk;
+    }
+    junk = junk.substring(0, LineFlushingOutputStream.BUFFER_LENGTH);
+
+    // Also test bug where write on a full buffer blows up
+    prefixOut.write(bytes(junk + junk));
+    prefixOut.write(bytes(junk + junk));
+    prefixOut.write(bytes("x"));
+    assertEquals("Prefix: " + junk + "\n" + "Prefix: " + junk + "\n"
+        + "Prefix: " + junk + "\n" + "Prefix: " + junk + "\n",
+        string(out.toByteArray()));
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/util/io/OutErrTest.java b/src/test/java/com/google/devtools/build/lib/util/io/OutErrTest.java
new file mode 100644
index 0000000..1419f42
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/util/io/OutErrTest.java
@@ -0,0 +1,79 @@
+// Copyright 2014 Google Inc. 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.util.io;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertSame;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.ByteArrayOutputStream;
+
+/**
+ * Tests {@link OutErr}.
+ */
+@RunWith(JUnit4.class)
+public class OutErrTest {
+
+  private ByteArrayOutputStream out = new ByteArrayOutputStream();
+  private ByteArrayOutputStream err = new ByteArrayOutputStream();
+  private OutErr outErr = OutErr.create(out, err);
+
+  @Test
+  public void testRetainsOutErr() {
+    assertSame(out, outErr.getOutputStream());
+    assertSame(err, outErr.getErrorStream());
+  }
+
+  @Test
+  public void testPrintsToOut() {
+    outErr.printOut("Hello, world.");
+    assertEquals("Hello, world.", new String(out.toByteArray()));
+  }
+
+  @Test
+  public void testPrintsToErr() {
+    outErr.printErr("Hello, moon.");
+    assertEquals("Hello, moon.", new String(err.toByteArray()));
+  }
+
+  @Test
+  public void testPrintsToOutWithANewline() {
+    outErr.printOutLn("With a newline.");
+    assertEquals("With a newline.\n", new String(out.toByteArray()));
+  }
+
+  @Test
+  public void testPrintsToErrWithANewline(){
+    outErr.printErrLn("With a newline.");
+    assertEquals("With a newline.\n", new String(err.toByteArray()));
+  }
+
+  @Test
+  public void testPrintsTwoLinesToOut() {
+    outErr.printOutLn("line 1");
+    outErr.printOutLn("line 2");
+    assertEquals("line 1\nline 2\n", new String(out.toByteArray()));
+  }
+
+  @Test
+  public void testPrintsTwoLinesToErr() {
+    outErr.printErrLn("line 1");
+    outErr.printErrLn("line 2");
+    assertEquals("line 1\nline 2\n", new String(err.toByteArray()));
+  }
+
+}
diff --git a/src/test/java/com/google/devtools/build/lib/util/io/RecordingOutErrTest.java b/src/test/java/com/google/devtools/build/lib/util/io/RecordingOutErrTest.java
new file mode 100644
index 0000000..b55eb4c
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/util/io/RecordingOutErrTest.java
@@ -0,0 +1,64 @@
+// Copyright 2014 Google Inc. 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.util.io;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.PrintWriter;
+
+/**
+ * A test for {@link RecordingOutErr}.
+ */
+@RunWith(JUnit4.class)
+public class RecordingOutErrTest {
+
+  protected RecordingOutErr getRecordingOutErr() {
+    return new RecordingOutErr();
+  }
+
+  @Test
+  public void testRecordingOutErrRecords() {
+    RecordingOutErr outErr = getRecordingOutErr();
+
+    outErr.printOut("Test");
+    outErr.printOutLn("out1");
+    PrintWriter writer = new PrintWriter(outErr.getOutputStream());
+    writer.println("Testout2");
+    writer.flush();
+
+    outErr.printErr("Test");
+    outErr.printErrLn("err1");
+    writer = new PrintWriter(outErr.getErrorStream());
+    writer.println("Testerr2");
+    writer.flush();
+
+    assertEquals(outErr.outAsLatin1(), "Testout1\nTestout2\n");
+    assertEquals(outErr.errAsLatin1(), "Testerr1\nTesterr2\n");
+
+    assertTrue(outErr.hasRecordedOutput());
+
+    outErr.reset();
+
+    assertEquals(outErr.outAsLatin1(), "");
+    assertEquals(outErr.errAsLatin1(), "");
+    assertFalse(outErr.hasRecordedOutput());
+  }
+
+}
diff --git a/src/test/java/com/google/devtools/build/lib/util/io/StreamDemultiplexerTest.java b/src/test/java/com/google/devtools/build/lib/util/io/StreamDemultiplexerTest.java
new file mode 100644
index 0000000..59277df5
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/util/io/StreamDemultiplexerTest.java
@@ -0,0 +1,150 @@
+// Copyright 2014 Google Inc. 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.util.io;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+
+import com.google.devtools.build.lib.util.StringUtilities;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.ByteArrayOutputStream;
+import java.io.OutputStream;
+import java.io.UnsupportedEncodingException;
+import java.util.Random;
+
+/**
+ * Tests {@link StreamDemultiplexer}.
+ */
+@RunWith(JUnit4.class)
+public class StreamDemultiplexerTest {
+
+  private ByteArrayOutputStream out = new ByteArrayOutputStream();
+  private ByteArrayOutputStream err = new ByteArrayOutputStream();
+  private ByteArrayOutputStream ctl = new ByteArrayOutputStream();
+
+  private byte[] lines(String... lines) {
+    try {
+      return StringUtilities.joinLines(lines).getBytes("ISO-8859-1");
+    } catch (UnsupportedEncodingException e) {
+      throw new AssertionError(e);
+    }
+  }
+
+  private String toAnsi(ByteArrayOutputStream stream) {
+    try {
+      return new String(stream.toByteArray(), "ISO-8859-1");
+    } catch (UnsupportedEncodingException e) {
+      throw new AssertionError(e);
+    }
+  }
+
+  private byte[] inAnsi(String string) {
+    try {
+      return string.getBytes("ISO-8859-1");
+    } catch (UnsupportedEncodingException e) {
+      throw new AssertionError(e);
+    }
+  }
+
+  @Test
+  public void testHelloWorldOnStandardOut() throws Exception {
+    byte[] multiplexed = lines("@1@", "Hello, world.");
+    StreamDemultiplexer demux = new StreamDemultiplexer((byte) '1', out);
+    try {
+      demux.write(multiplexed);
+      demux.flush();
+    } finally {
+      demux.close();
+    }
+    assertEquals("Hello, world.", out.toString("ISO-8859-1"));
+  }
+
+  @Test
+  public void testOutErrCtl() throws Exception {
+    byte[] multiplexed = lines("@1@", "out", "@2@", "err", "@3@", "ctl", "");
+    StreamDemultiplexer demux = new StreamDemultiplexer((byte) '1', out, err, ctl);
+    try {
+      demux.write(multiplexed);
+      demux.flush();
+    } finally {
+      demux.close();
+    }
+    assertEquals("out", toAnsi(out));
+    assertEquals("err", toAnsi(err));
+    assertEquals("ctl", toAnsi(ctl));
+  }
+
+  @Test
+  public void testWithoutLineBreaks() throws Exception {
+    byte[] multiplexed = lines("@1@", "just ", "@1@", "one ", "@1@", "line", "");
+    StreamDemultiplexer demux = new StreamDemultiplexer((byte) '1', out);
+    try {
+      demux.write(multiplexed);
+      demux.flush();
+    } finally {
+      demux.close();
+    }
+    assertEquals("just one line", out.toString("ISO-8859-1"));
+  }
+
+  @Test
+  public void testLineBreaks() throws Exception {
+    byte[] multiplexed = lines("@1", "two", "@1", "lines", "");
+    StreamDemultiplexer demux = new StreamDemultiplexer((byte) '1', out);
+    try {
+      demux.write(multiplexed);
+      demux.flush();
+      assertEquals("two\nlines\n", out.toString("ISO-8859-1"));
+    } finally {
+      demux.close();
+    }
+  }
+
+  @Test
+  public void testMultiplexAndBackWithHelloWorld() throws Exception {
+    StreamDemultiplexer demux = new StreamDemultiplexer((byte) '1', out);
+    StreamMultiplexer mux = new StreamMultiplexer(demux);
+    OutputStream out = mux.createStdout();
+    out.write(inAnsi("Hello, world."));
+    out.flush();
+    assertEquals("Hello, world.", toAnsi(this.out));
+  }
+
+  @Test
+  public void testMultiplexDemultiplexBinaryStress() throws Exception {
+    StreamDemultiplexer demux = new StreamDemultiplexer((byte) '1', out, err, ctl);
+    StreamMultiplexer mux = new StreamMultiplexer(demux);
+    OutputStream[] muxOuts = {mux.createStdout(), mux.createStderr(), mux.createControl()};
+    ByteArrayOutputStream[] expectedOuts =
+        {new ByteArrayOutputStream(), new ByteArrayOutputStream(), new ByteArrayOutputStream()};
+
+    Random random = new Random(0xdeadbeef);
+    for (int round = 0; round < 100; round++) {
+      byte[] buffer = new byte[random.nextInt(100)];
+      random.nextBytes(buffer);
+      int streamId = random.nextInt(3);
+      expectedOuts[streamId].write(buffer);
+      expectedOuts[streamId].flush();
+      muxOuts[streamId].write(buffer);
+      muxOuts[streamId].flush();
+    }
+    assertArrayEquals(expectedOuts[0].toByteArray(), out.toByteArray());
+    assertArrayEquals(expectedOuts[1].toByteArray(), err.toByteArray());
+    assertArrayEquals(expectedOuts[2].toByteArray(), ctl.toByteArray());
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/util/io/StreamMultiplexerParallelStressTest.java b/src/test/java/com/google/devtools/build/lib/util/io/StreamMultiplexerParallelStressTest.java
new file mode 100644
index 0000000..db833a5
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/util/io/StreamMultiplexerParallelStressTest.java
@@ -0,0 +1,128 @@
+// Copyright 2014 Google Inc. 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.util.io;
+
+import com.google.common.io.ByteStreams;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.OutputStream;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
+/**
+ * Exercise {@link StreamMultiplexer} in a parallel setting and ensure there's
+ * no corruption.
+ */
+@RunWith(JUnit4.class)
+public class StreamMultiplexerParallelStressTest {
+
+  /**
+   * Characters that could likely cause corruption (they're used as control
+   * characters).
+   */
+  char[] toughCharsToTry = {'\n', '@', '1', '2', '\0', '0'};
+
+  /**
+   * We use a demultiplexer as a simple sanity checker only - that is, we don't
+   * care what the demultiplexer writes, but we are taking advantage of its
+   * built in error checking.
+   */
+  OutputStream devNull  = ByteStreams.nullOutputStream();
+
+  StreamDemultiplexer demux = new StreamDemultiplexer((byte)'1',
+      devNull, devNull, devNull);
+
+  /**
+   * The multiplexer under test.
+   */
+  StreamMultiplexer mux = new StreamMultiplexer(demux);
+
+  /**
+   * Streams is the out / err / control output streams of the multiplexer which
+   * we will write to in parallel.
+   */
+  OutputStream[] streams = {
+      mux.createStdout(), mux.createStderr(), mux.createControl()};
+
+  /**
+   * We will create a bunch of threads that write random data to the streams of
+   * the mux.
+   */
+  class RandomDataPump implements Callable<Object> {
+
+    private Random random;
+
+    public RandomDataPump(int threadId) {
+      random = new Random(threadId * 0xdeadbeefL);
+    }
+
+    @Override
+    public Object call() throws Exception {
+      Thread.yield();
+      OutputStream out = streams[random.nextInt(2)];
+      for (int i = 0; i < 10000; i++) {
+          switch (random.nextInt(5)) {
+          case 0:
+            out.write(random.nextInt());
+            break;
+          case 1:
+            int index = random.nextInt(toughCharsToTry.length);
+            out.write(toughCharsToTry[index]);
+            break;
+          case 2:
+            byte[] buffer = new byte[random.nextInt(312)];
+            random.nextBytes(buffer);
+            out.write(buffer);
+            break;
+          case 3:
+            out.flush();
+            break;
+          case 4:
+            out = streams[random.nextInt(3)];
+            break;
+          }
+      }
+      return null;
+    }
+  }
+
+  @Test
+  public void testSingleThreadedStress() throws Exception {
+    new RandomDataPump(1).call();
+  }
+
+  @Test
+  public void testMultiThreadedStress()
+      throws InterruptedException, ExecutionException {
+    ExecutorService service = Executors.newFixedThreadPool(50);
+
+    List<Future<?>> futures = new ArrayList<>();
+    for (int threadId = 0; threadId < 50; threadId++) {
+      futures.add(service.submit(new RandomDataPump(threadId)));
+    }
+    for (Future<?> future : futures) {
+      future.get();
+    }
+  }
+
+}
diff --git a/src/test/java/com/google/devtools/build/lib/util/io/StreamMultiplexerTest.java b/src/test/java/com/google/devtools/build/lib/util/io/StreamMultiplexerTest.java
new file mode 100644
index 0000000..aef6da3
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/util/io/StreamMultiplexerTest.java
@@ -0,0 +1,149 @@
+// Copyright 2014 Google Inc. 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.util.io;
+
+import static com.google.devtools.build.lib.util.StringUtilities.joinLines;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+
+import com.google.common.io.ByteStreams;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.UnsupportedEncodingException;
+
+/**
+ * Test for {@link StreamMultiplexer}.
+ */
+@RunWith(JUnit4.class)
+public class StreamMultiplexerTest {
+
+  private ByteArrayOutputStream multiplexed;
+  private OutputStream out;
+  private OutputStream err;
+  private OutputStream ctl;
+
+  @Before
+  public void setUp() throws Exception {
+    multiplexed = new ByteArrayOutputStream();
+    StreamMultiplexer multiplexer = new StreamMultiplexer(multiplexed);
+    out = multiplexer.createStdout();
+    err = multiplexer.createStderr();
+    ctl = multiplexer.createControl();
+  }
+
+  @Test
+  public void testEmptyWire() throws IOException {
+    out.flush();
+    err.flush();
+    ctl.flush();
+    assertEquals(0, multiplexed.toByteArray().length);
+  }
+
+  private static byte[] getLatin(String string)
+      throws UnsupportedEncodingException {
+    return string.getBytes("ISO-8859-1");
+  }
+
+  private static String getLatin(byte[] bytes)
+      throws UnsupportedEncodingException {
+    return new String(bytes, "ISO-8859-1");
+  }
+
+  @Test
+  public void testHelloWorldOnStdOut() throws IOException {
+    out.write(getLatin("Hello, world."));
+    out.flush();
+    assertEquals(joinLines("@1@", "Hello, world.", ""),
+                 getLatin(multiplexed.toByteArray()));
+  }
+
+  @Test
+  public void testInterleavedStdoutStderrControl() throws Exception {
+    out.write(getLatin("Hello, stdout."));
+    out.flush();
+    err.write(getLatin("Hello, stderr."));
+    err.flush();
+    ctl.write(getLatin("Hello, control."));
+    ctl.flush();
+    out.write(getLatin("... and back!"));
+    out.flush();
+    assertEquals(joinLines("@1@", "Hello, stdout.",
+                           "@2@", "Hello, stderr.",
+                           "@3@", "Hello, control.",
+                           "@1@", "... and back!",
+                           ""),
+                 getLatin(multiplexed.toByteArray()));
+  }
+
+  @Test
+  public void testWillNotCommitToUnderlyingStreamUnlessFlushOrNewline()
+      throws Exception {
+    out.write(getLatin("There are no newline characters in here, so it won't" +
+                       " get written just yet."));
+    assertArrayEquals(multiplexed.toByteArray(), new byte[0]);
+  }
+
+  @Test
+  public void testNewlineTriggersFlush() throws Exception {
+    out.write(getLatin("No newline just yet, so no flushing. "));
+    assertArrayEquals(multiplexed.toByteArray(), new byte[0]);
+    out.write(getLatin("OK, here we go:\nAnd more to come."));
+
+    String expected = joinLines("@1",
+        "No newline just yet, so no flushing. OK, here we go:", "");
+
+    assertEquals(expected, getLatin(multiplexed.toByteArray()));
+
+    out.write((byte) '\n');
+    expected += joinLines("@1", "And more to come.", "");
+
+    assertEquals(expected, getLatin(multiplexed.toByteArray()));
+  }
+
+  @Test
+  public void testFlush() throws Exception {
+    out.write(getLatin("Don't forget to flush!"));
+    assertArrayEquals(new byte[0], multiplexed.toByteArray());
+    out.flush(); // now the output will appear in multiplexed.
+    assertEquals(joinLines("@1@", "Don't forget to flush!", ""),
+        getLatin(multiplexed.toByteArray()));
+  }
+
+  @Test
+  public void testByteEncoding() throws IOException {
+    OutputStream devNull = ByteStreams.nullOutputStream();
+    StreamDemultiplexer demux = new StreamDemultiplexer((byte) '1', devNull);
+    StreamMultiplexer mux = new StreamMultiplexer(demux);
+    OutputStream out = mux.createStdout();
+
+    // When we cast 266 to a byte, we get 10. So basically, we ended up
+    // comparing 266 with 10 as an integer (because out.write takes an int),
+    // and then later cast it to 10. This way we'd end up with a control
+    // character \n in the middle of the payload which would then screw things
+    // up when the real control character arrived. The fixed version of the
+    // StreamMultiplexer avoids this problem by always casting to a byte before
+    // carrying out any comparisons.
+
+    out.write(266);
+    out.write(10);
+  }
+
+}
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/FileSystemConcurrencyTest.java b/src/test/java/com/google/devtools/build/lib/vfs/FileSystemConcurrencyTest.java
new file mode 100644
index 0000000..c90de18
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/vfs/FileSystemConcurrencyTest.java
@@ -0,0 +1,97 @@
+// Copyright 2014 Google Inc. 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.vfs;
+
+import com.google.devtools.build.lib.testutil.TestUtils;
+import com.google.devtools.build.lib.vfs.util.FileSystems;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.File;
+import java.io.IOException;
+
+/**
+ * (Slow) tests of FileSystem under concurrency.
+ *
+ * These tests are nondeterministic but provide good coverage nonetheless.
+ */
+@RunWith(JUnit4.class)
+public class FileSystemConcurrencyTest {
+
+  Path workingDir;
+
+  @Before
+  public void setUp() throws Exception {
+    FileSystem testFS = FileSystems.initDefaultAsNative();
+
+    // Resolve symbolic links in the temp dir:
+    workingDir = testFS.getPath(new File(TestUtils.tmpDir()).getCanonicalPath());
+  }
+
+  @Test
+  public void testConcurrentSymlinkModifications() throws Exception {
+    final Path xFile = workingDir.getRelative("file");
+    FileSystemUtils.createEmptyFile(xFile);
+
+    final Path xLinkToFile = workingDir.getRelative("link");
+
+    // "Boxed" for pass-by-reference.
+    final boolean[] run = { true };
+    final IOException[] exception = { null };
+    Thread createThread = new Thread() {
+      @Override
+      public void run() {
+        while (run[0]) {
+          if (!xLinkToFile.exists()) {
+            try {
+              xLinkToFile.createSymbolicLink(xFile);
+            } catch (IOException e) {
+              exception[0] = e;
+              return;
+            }
+          }
+        }
+      }
+    };
+    Thread deleteThread = new Thread() {
+      @Override
+      public void run() {
+        while (run[0]) {
+          if (xLinkToFile.exists(Symlinks.NOFOLLOW)) {
+            try {
+              xLinkToFile.delete();
+            } catch (IOException e) {
+              exception[0] = e;
+              return;
+            }
+          }
+        }
+      }
+    };
+    createThread.start();
+    deleteThread.start();
+    Thread.sleep(1000);
+    run[0] = false;
+    createThread.join(0);
+    deleteThread.join(0);
+
+    if (exception[0] != null) {
+      throw exception[0];
+    }
+  }
+
+}
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/FileSystemTest.java b/src/test/java/com/google/devtools/build/lib/vfs/FileSystemTest.java
new file mode 100644
index 0000000..b6e88d8
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/vfs/FileSystemTest.java
@@ -0,0 +1,1356 @@
+// Copyright 2014 Google Inc. 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.vfs;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.base.Preconditions;
+import com.google.common.io.BaseEncoding;
+import com.google.devtools.build.lib.testutil.MoreAsserts;
+import com.google.devtools.build.lib.testutil.TestUtils;
+import com.google.devtools.build.lib.util.Fingerprint;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * This class handles the generic tests that any filesystem must pass.
+ *
+ * <p>Each filesystem-test should inherit from this class, thereby obtaining
+ * all the tests.
+ */
+public abstract class FileSystemTest {
+
+  private long savedTime;
+  protected FileSystem testFS;
+  protected boolean supportsSymlinks;
+  protected Path workingDir;
+
+  // Some useful examples of various kinds of files (mnemonic: "x" = "eXample")
+  protected Path xNothing;
+  protected Path xFile;
+  protected Path xNonEmptyDirectory;
+  protected Path xNonEmptyDirectoryFoo;
+  protected Path xEmptyDirectory;
+
+  @Before
+  public void setUp() throws Exception {
+    testFS = getFreshFileSystem();
+    workingDir = testFS.getPath(getTestTmpDir());
+    cleanUpWorkingDirectory(workingDir);
+    supportsSymlinks = testFS.supportsSymbolicLinks();
+
+    // % ls -lR
+    // -rw-rw-r-- xFile
+    // drwxrwxr-x xNonEmptyDirectory
+    // -rw-rw-r-- xNonEmptyDirectory/foo
+    // drwxrwxr-x xEmptyDirectory
+
+    xNothing = absolutize("xNothing");
+    xFile = absolutize("xFile");
+    xNonEmptyDirectory = absolutize("xNonEmptyDirectory");
+    xNonEmptyDirectoryFoo = xNonEmptyDirectory.getChild("foo");
+    xEmptyDirectory = absolutize("xEmptyDirectory");
+
+    FileSystemUtils.createEmptyFile(xFile);
+    xNonEmptyDirectory.createDirectory();
+    FileSystemUtils.createEmptyFile(xNonEmptyDirectoryFoo);
+    xEmptyDirectory.createDirectory();
+  }
+
+  @After
+  public void tearDown() throws Exception {
+    destroyFileSystem(testFS);
+  }
+
+  /**
+   * Returns an instance of the file system to test.
+   */
+  protected abstract FileSystem getFreshFileSystem() throws IOException;
+
+  protected boolean isSymbolicLink(File file) {
+    return com.google.devtools.build.lib.unix.FilesystemUtils.isSymbolicLink(file);
+  }
+
+  protected void setWritable(File file) throws IOException {
+    com.google.devtools.build.lib.unix.FilesystemUtils.setWritable(file);
+  }
+
+  protected void setExecutable(File file) throws IOException {
+    com.google.devtools.build.lib.unix.FilesystemUtils.setExecutable(file);
+  }
+
+  private static final Pattern STAT_SUBDIR_ERROR = Pattern.compile("(.*) \\(Not a directory\\)");
+
+  // Test that file is not present, using statIfFound. Base implementation throws an exception, but
+  // subclasses may override statIfFound to return null, in which case their tests should override
+  // this method.
+  @SuppressWarnings("unused") // Subclasses may throw.
+  protected void expectNotFound(Path path) throws IOException {
+    try {
+      assertNull(path.statIfFound());
+    } catch (IOException e) {
+      // May be because of a non-directory path component. Parse exception to check this.
+      Matcher matcher = STAT_SUBDIR_ERROR.matcher(e.getMessage());
+      if (!matcher.matches() || !path.getPathString().startsWith(matcher.group(1))) {
+        // Throw if this doesn't match what an ENOTDIR error looks like.
+        throw e;
+      }
+    }
+  }
+
+  /**
+   * Removes all stuff from the test filesystem.
+   */
+  protected void destroyFileSystem(FileSystem fileSystem) throws IOException {
+    Preconditions.checkArgument(fileSystem.equals(workingDir.getFileSystem()));
+    cleanUpWorkingDirectory(workingDir);
+  }
+
+  /**
+   * Cleans up the working directory by removing everything.
+   */
+  protected void cleanUpWorkingDirectory(Path workingPath)
+      throws IOException {
+    if (workingPath.exists()) {
+      removeEntireDirectory(workingPath.getPathFile()); // uses java.io.File!
+    }
+    FileSystemUtils.createDirectoryAndParents(workingPath);
+  }
+
+  /**
+   * This function removes an entire directory and all of its contents.
+   * Much like rm -rf directoryToRemove
+   */
+  protected void removeEntireDirectory(File directoryToRemove)
+      throws IOException {
+    // make sure that we do not remove anything outside the test directory
+    Path testDirPath = testFS.getPath(getTestTmpDir());
+    if (!testFS.getPath(directoryToRemove.getAbsolutePath()).startsWith(testDirPath)) {
+      throw new IOException("trying to remove files outside of the testdata directory");
+    }
+    // Some tests set the directories read-only and/or non-executable, so
+    // override that:
+    setWritable(directoryToRemove);
+    setExecutable(directoryToRemove);
+
+    File[] files = directoryToRemove.listFiles();
+    if (files != null) {
+      for (File currentFile : files) {
+        boolean isSymbolicLink = isSymbolicLink(currentFile);
+        if (!isSymbolicLink && currentFile.isDirectory()) {
+          removeEntireDirectory(currentFile);
+        } else {
+          if (!isSymbolicLink) {
+            setWritable(currentFile);
+          }
+          if (!currentFile.delete()) {
+            throw new IOException("Failed to delete '" + currentFile + "'");
+          }
+        }
+      }
+    }
+    if (!directoryToRemove.delete()) {
+      throw new IOException("Failed to delete '" + directoryToRemove + "'");
+    }
+  }
+
+  /**
+   * Returns the directory to use as the FileSystem's working directory.
+   * Canonicalized to make tests hermetic against symbolic links in TEST_TMPDIR.
+   */
+  protected final String getTestTmpDir() throws IOException {
+    return new File(TestUtils.tmpDir()).getCanonicalPath() + "/testdir";
+  }
+
+  /**
+   * Indirection to create links so we can test FileSystems that do not support
+   * link creation.  For example, JavaFileSystemTest overrides this method
+   * and creates the link with an alternate FileSystem.
+   */
+  protected void createSymbolicLink(Path link, Path target) throws IOException {
+    createSymbolicLink(link, target.asFragment());
+  }
+
+  /**
+   * Indirection to create links so we can test FileSystems that do not support
+   * link creation.  For example, JavaFileSystemTest overrides this method
+   * and creates the link with an alternate FileSystem.
+   */
+  protected void createSymbolicLink(Path link, PathFragment target) throws IOException {
+    link.createSymbolicLink(target);
+  }
+
+  /**
+   * Indirection to setReadOnly(false) on FileSystems that do not
+   * support setReadOnly(false).  For example, JavaFileSystemTest overrides this
+   * method and makes the Path writable with an alternate FileSystem.
+   */
+  protected void makeWritable(Path target) throws IOException {
+    target.setWritable(true);
+  }
+
+  /**
+   * Indirection to {@link Path#setExecutable(boolean)} on FileSystems that do
+   * not support setExecutable.  For example, JavaFileSystemTest overrides this
+   * method and makes the Path executable with an alternate FileSystem.
+   */
+  protected void setExecutable(Path target, boolean mode) throws IOException {
+    target.setExecutable(mode);
+  }
+
+  // TODO(bazel-team): (2011) Put in a setLastModifiedTime into the various objects
+  // and clobber the current time of the object we're currently handling.
+  // Otherwise testing the thing might get a little hard, depending on the clock.
+  void storeReferenceTime(long timeToMark) {
+    savedTime = timeToMark;
+  }
+
+  boolean isLaterThanreferenceTime(long testTime) {
+    return (savedTime <= testTime);
+  }
+
+  Path getTestFile() throws IOException {
+    Path tempPath = absolutize("test-file");
+    FileSystemUtils.createEmptyFile(tempPath);
+    return tempPath;
+  }
+
+  protected Path absolutize(String relativePathName) {
+    return workingDir.getRelative(relativePathName);
+  }
+
+  // Here the tests begin.
+
+  @Test
+  public void testIsFileForNonexistingPath() {
+    Path nonExistingPath = testFS.getPath("/something/strange");
+    assertFalse(nonExistingPath.isFile());
+  }
+
+  @Test
+  public void testIsDirectoryForNonexistingPath() {
+    Path nonExistingPath = testFS.getPath("/something/strange");
+    assertFalse(nonExistingPath.isDirectory());
+  }
+
+  @Test
+  public void testIsLinkForNonexistingPath() {
+    Path nonExistingPath = testFS.getPath("/something/strange");
+    assertFalse(nonExistingPath.isSymbolicLink());
+  }
+
+  @Test
+  public void testExistsForNonexistingPath() throws Exception {
+    Path nonExistingPath = testFS.getPath("/something/strange");
+    assertFalse(nonExistingPath.exists());
+    expectNotFound(nonExistingPath);
+  }
+
+  @Test
+  public void testBadPermissionsThrowsExceptionOnStatIfFound() throws Exception {
+    Path inaccessible = absolutize("inaccessible");
+    inaccessible.createDirectory();
+    Path child = inaccessible.getChild("child");
+    FileSystemUtils.createEmptyFile(child);
+    inaccessible.setExecutable(false);
+    assertFalse(child.exists());
+    try {
+      child.statIfFound();
+      fail();
+    } catch (IOException expected) {
+      // Expected.
+    }
+  }
+
+  @Test
+  public void testStatIfFoundReturnsNullForChildOfNonDir() throws Exception {
+    Path foo = absolutize("foo");
+    foo.createDirectory();
+    Path nonDir = foo.getRelative("bar");
+    FileSystemUtils.createEmptyFile(nonDir);
+    assertNull(nonDir.getRelative("file").statIfFound());
+  }
+
+  // The following tests check the handling of the current working directory.
+  @Test
+  public void testCreatePathRelativeToWorkingDirectory() {
+    Path relativeCreatedPath = absolutize("some-file");
+    Path expectedResult = workingDir.getRelative(new PathFragment("some-file"));
+
+    assertEquals(expectedResult, relativeCreatedPath);
+  }
+
+  // The following tests check the handling of the root directory
+  @Test
+  public void testRootIsDirectory() {
+    Path rootPath = testFS.getPath("/");
+    assertTrue(rootPath.isDirectory());
+  }
+
+  @Test
+  public void testRootHasNoParent() {
+    Path rootPath = testFS.getPath("/");
+    assertNull(rootPath.getParentDirectory());
+  }
+
+  // The following functions test the creation of files/links/directories.
+  @Test
+  public void testFileExists() throws Exception {
+    Path someFile = absolutize("some-file");
+    FileSystemUtils.createEmptyFile(someFile);
+    assertTrue(someFile.exists());
+    assertNotNull(someFile.statIfFound());
+  }
+
+  @Test
+  public void testFileIsFile() throws Exception {
+    Path someFile = absolutize("some-file");
+    FileSystemUtils.createEmptyFile(someFile);
+    assertTrue(someFile.isFile());
+  }
+
+  @Test
+  public void testFileIsNotDirectory() throws Exception {
+    Path someFile = absolutize("some-file");
+    FileSystemUtils.createEmptyFile(someFile);
+    assertFalse(someFile.isDirectory());
+  }
+
+  @Test
+  public void testFileIsNotSymbolicLink() throws Exception {
+    Path someFile = absolutize("some-file");
+    FileSystemUtils.createEmptyFile(someFile);
+    assertFalse(someFile.isSymbolicLink());
+  }
+
+  @Test
+  public void testDirectoryExists() throws Exception {
+    Path someDirectory = absolutize("some-dir");
+    someDirectory.createDirectory();
+    assertTrue(someDirectory.exists());
+    assertNotNull(someDirectory.statIfFound());
+  }
+
+  @Test
+  public void testDirectoryIsDirectory() throws Exception {
+    Path someDirectory = absolutize("some-dir");
+    someDirectory.createDirectory();
+    assertTrue(someDirectory.isDirectory());
+  }
+
+  @Test
+  public void testDirectoryIsNotFile() throws Exception {
+    Path someDirectory = absolutize("some-dir");
+    someDirectory.createDirectory();
+    assertFalse(someDirectory.isFile());
+  }
+
+  @Test
+  public void testDirectoryIsNotSymbolicLink() throws Exception {
+    Path someDirectory = absolutize("some-dir");
+    someDirectory.createDirectory();
+    assertFalse(someDirectory.isSymbolicLink());
+  }
+
+  @Test
+  public void testSymbolicFileLinkExists() throws Exception {
+    if (supportsSymlinks) {
+      Path someLink = absolutize("some-link");
+      someLink.createSymbolicLink(xFile);
+      assertTrue(someLink.exists());
+      assertNotNull(someLink.statIfFound());
+    }
+  }
+
+  @Test
+  public void testSymbolicFileLinkIsSymbolicLink() throws Exception {
+    if (supportsSymlinks) {
+      Path someLink = absolutize("some-link");
+      someLink.createSymbolicLink(xFile);
+      assertTrue(someLink.isSymbolicLink());
+    }
+  }
+
+  @Test
+  public void testSymbolicFileLinkIsFile() throws Exception {
+    if (supportsSymlinks) {
+      Path someLink = absolutize("some-link");
+      someLink.createSymbolicLink(xFile);
+      assertTrue(someLink.isFile());
+    }
+  }
+
+  @Test
+  public void testSymbolicFileLinkIsNotDirectory() throws Exception {
+    if (supportsSymlinks) {
+      Path someLink = absolutize("some-link");
+      someLink.createSymbolicLink(xFile);
+      assertFalse(someLink.isDirectory());
+    }
+  }
+
+  @Test
+  public void testSymbolicDirLinkExists() throws Exception {
+    if (supportsSymlinks) {
+      Path someLink = absolutize("some-link");
+      someLink.createSymbolicLink(xEmptyDirectory);
+      assertTrue(someLink.exists());
+      assertNotNull(someLink.statIfFound());
+    }
+  }
+
+  @Test
+  public void testSymbolicDirLinkIsSymbolicLink() throws Exception {
+    if (supportsSymlinks) {
+      Path someLink = absolutize("some-link");
+      someLink.createSymbolicLink(xEmptyDirectory);
+      assertTrue(someLink.isSymbolicLink());
+    }
+  }
+
+  @Test
+  public void testSymbolicDirLinkIsDirectory() throws Exception {
+    if (supportsSymlinks) {
+      Path someLink = absolutize("some-link");
+      someLink.createSymbolicLink(xEmptyDirectory);
+      assertTrue(someLink.isDirectory());
+    }
+  }
+
+  @Test
+  public void testSymbolicDirLinkIsNotFile() throws Exception {
+    if (supportsSymlinks) {
+      Path someLink = absolutize("some-link");
+      someLink.createSymbolicLink(xEmptyDirectory);
+      assertFalse(someLink.isFile());
+    }
+  }
+
+  @Test
+  public void testChildOfNonDirectory() throws Exception {
+    Path somePath = absolutize("file-name");
+    FileSystemUtils.createEmptyFile(somePath);
+    Path childOfNonDir = somePath.getChild("child");
+    assertFalse(childOfNonDir.exists());
+    expectNotFound(childOfNonDir);
+  }
+
+  @Test
+  public void testCreateDirectoryIsEmpty() throws Exception {
+    Path newPath = xEmptyDirectory.getChild("new-dir");
+    newPath.createDirectory();
+    assertEquals(newPath.getDirectoryEntries().size(), 0);
+  }
+
+  @Test
+  public void testCreateDirectoryIsOnlyChildInParent() throws Exception {
+    Path newPath = xEmptyDirectory.getChild("new-dir");
+    newPath.createDirectory();
+    assertEquals(1, newPath.getParentDirectory().getDirectoryEntries().size());
+    assertThat(newPath.getParentDirectory().getDirectoryEntries()).containsExactly(newPath);
+  }
+
+  @Test
+  public void testCreateDirectories() throws Exception {
+    Path newPath = absolutize("new-dir/sub/directory");
+    assertTrue(FileSystemUtils.createDirectoryAndParents(newPath));
+  }
+
+  @Test
+  public void testCreateDirectoriesIsDirectory() throws Exception {
+    Path newPath = absolutize("new-dir/sub/directory");
+    FileSystemUtils.createDirectoryAndParents(newPath);
+    assertTrue(newPath.isDirectory());
+  }
+
+  @Test
+  public void testCreateDirectoriesIsNotFile() throws Exception {
+    Path newPath = absolutize("new-dir/sub/directory");
+    FileSystemUtils.createDirectoryAndParents(newPath);
+    assertFalse(newPath.isFile());
+  }
+
+  @Test
+  public void testCreateDirectoriesIsNotSymbolicLink() throws Exception {
+    Path newPath = absolutize("new-dir/sub/directory");
+    FileSystemUtils.createDirectoryAndParents(newPath);
+    assertFalse(newPath.isSymbolicLink());
+  }
+
+  @Test
+  public void testCreateDirectoriesIsEmpty() throws Exception {
+    Path newPath = absolutize("new-dir/sub/directory");
+    FileSystemUtils.createDirectoryAndParents(newPath);
+    assertEquals(newPath.getDirectoryEntries().size(), 0);
+  }
+
+  @Test
+  public void testCreateDirectoriesIsOnlyChildInParent() throws Exception {
+    Path newPath = absolutize("new-dir/sub/directory");
+    FileSystemUtils.createDirectoryAndParents(newPath);
+    assertEquals(1, newPath.getParentDirectory().getDirectoryEntries().size());
+    assertThat(newPath.getParentDirectory().getDirectoryEntries()).containsExactly(newPath);
+  }
+
+  @Test
+  public void testCreateEmptyFileIsEmpty() throws Exception {
+    Path newPath = xEmptyDirectory.getChild("new-file");
+    FileSystemUtils.createEmptyFile(newPath);
+
+    assertEquals(newPath.getFileSize(), 0);
+  }
+
+  @Test
+  public void testCreateFileIsOnlyChildInParent() throws Exception {
+    Path newPath = xEmptyDirectory.getChild("new-file");
+    FileSystemUtils.createEmptyFile(newPath);
+    assertEquals(1, newPath.getParentDirectory().getDirectoryEntries().size());
+    assertThat(newPath.getParentDirectory().getDirectoryEntries()).containsExactly(newPath);
+  }
+
+  // The following functions test the behavior if errors occur during the
+  // creation of files/links/directories.
+  @Test
+  public void testCreateDirectoryWhereDirectoryAlreadyExists() throws Exception {
+    assertFalse(xEmptyDirectory.createDirectory());
+  }
+
+  @Test
+  public void testCreateDirectoryWhereFileAlreadyExists() {
+    try {
+      xFile.createDirectory();
+      fail();
+    } catch (IOException e) {
+      assertEquals(xFile + " (File exists)", e.getMessage());
+    }
+  }
+
+  @Test
+  public void testCannotCreateDirectoryWithoutExistingParent() throws Exception {
+    Path newPath = testFS.getPath("/deep/new-dir");
+    try {
+      newPath.createDirectory();
+      fail();
+    } catch (FileNotFoundException e) {
+      MoreAsserts.assertEndsWith(" (No such file or directory)", e.getMessage());
+    }
+  }
+
+  @Test
+  public void testCannotCreateDirectoryWithReadOnlyParent() throws Exception {
+    xEmptyDirectory.setWritable(false);
+    Path xChildOfReadonlyDir = xEmptyDirectory.getChild("x");
+    try {
+      xChildOfReadonlyDir.createDirectory();
+      fail();
+    } catch (IOException e) {
+      assertEquals(xChildOfReadonlyDir + " (Permission denied)", e.getMessage());
+    }
+  }
+
+  @Test
+  public void testCannotCreateFileWithoutExistingParent() throws Exception {
+    Path newPath = testFS.getPath("/non-existing-dir/new-file");
+    try {
+      FileSystemUtils.createEmptyFile(newPath);
+      fail();
+    } catch (FileNotFoundException e) {
+      MoreAsserts.assertEndsWith(" (No such file or directory)", e.getMessage());
+    }
+  }
+
+  @Test
+  public void testCannotCreateFileWithReadOnlyParent() throws Exception {
+    xEmptyDirectory.setWritable(false);
+    Path xChildOfReadonlyDir = xEmptyDirectory.getChild("x");
+    try {
+      FileSystemUtils.createEmptyFile(xChildOfReadonlyDir);
+      fail();
+    } catch (IOException e) {
+      assertEquals(xChildOfReadonlyDir + " (Permission denied)", e.getMessage());
+    }
+  }
+
+  @Test
+  public void testCannotCreateFileWithinFile() throws Exception {
+    Path newFilePath = absolutize("some-file");
+    FileSystemUtils.createEmptyFile(newFilePath);
+    Path wrongPath = absolutize("some-file/new-file");
+    try {
+      FileSystemUtils.createEmptyFile(wrongPath);
+      fail();
+    } catch (IOException e) {
+      MoreAsserts.assertEndsWith(" (Not a directory)", e.getMessage());
+    }
+  }
+
+  @Test
+  public void testCannotCreateDirectoryWithinFile() throws Exception {
+    Path newFilePath = absolutize("some-file");
+    FileSystemUtils.createEmptyFile(newFilePath);
+    Path wrongPath = absolutize("some-file/new-file");
+    try {
+      wrongPath.createDirectory();
+      fail();
+    } catch (IOException e) {
+      MoreAsserts.assertEndsWith(" (Not a directory)", e.getMessage());
+    }
+  }
+
+  // Test directory contents
+  @Test
+  public void testCreateMultipleChildren() throws Exception {
+    Path theDirectory = absolutize("foo/");
+    theDirectory.createDirectory();
+    Path newPath1 = absolutize("foo/new-file-1");
+    Path newPath2 = absolutize("foo/new-file-2");
+    Path newPath3 = absolutize("foo/new-file-3");
+
+    FileSystemUtils.createEmptyFile(newPath1);
+    FileSystemUtils.createEmptyFile(newPath2);
+    FileSystemUtils.createEmptyFile(newPath3);
+
+    assertThat(theDirectory.getDirectoryEntries()).containsExactly(newPath1, newPath2, newPath3);
+  }
+
+  @Test
+  public void testGetDirectoryEntriesThrowsExceptionWhenRunOnFile() throws Exception {
+    try {
+      xFile.getDirectoryEntries();
+      fail("No Exception thrown.");
+    } catch (IOException ex) {
+      if (ex instanceof FileNotFoundException) {
+        fail("The method should throw an object of class IOException.");
+      }
+      assertEquals(xFile + " (Not a directory)", ex.getMessage());
+    }
+  }
+
+  @Test
+  public void testGetDirectoryEntriesThrowsExceptionForNonexistingPath() {
+    Path somePath = testFS.getPath("/non-existing-path");
+    try {
+      somePath.getDirectoryEntries();
+      fail("FileNotFoundException not thrown.");
+    } catch (Exception x) {
+      assertEquals(somePath + " (No such file or directory)", x.getMessage());
+    }
+  }
+
+  // Test the removal of items
+  @Test
+  public void testDeleteDirectory() throws Exception {
+    assertTrue(xEmptyDirectory.delete());
+  }
+
+  @Test
+  public void testDeleteDirectoryIsNotDirectory() throws Exception {
+    xEmptyDirectory.delete();
+    assertFalse(xEmptyDirectory.isDirectory());
+  }
+
+  @Test
+  public void testDeleteDirectoryParentSize() throws Exception {
+    int parentSize = workingDir.getDirectoryEntries().size();
+    xEmptyDirectory.delete();
+    assertEquals(workingDir.getDirectoryEntries().size(), parentSize - 1);
+  }
+
+  @Test
+  public void testDeleteFile() throws Exception {
+    assertTrue(xFile.delete());
+  }
+
+  @Test
+  public void testDeleteFileIsNotFile() throws Exception {
+    xFile.delete();
+    assertFalse(xEmptyDirectory.isFile());
+  }
+
+  @Test
+  public void testDeleteFileParentSize() throws Exception {
+    int parentSize = workingDir.getDirectoryEntries().size();
+    xFile.delete();
+    assertEquals(workingDir.getDirectoryEntries().size(), parentSize - 1);
+  }
+
+  @Test
+  public void testDeleteRemovesCorrectFile() throws Exception {
+    Path newPath1 = xEmptyDirectory.getChild("new-file-1");
+    Path newPath2 = xEmptyDirectory.getChild("new-file-2");
+    Path newPath3 = xEmptyDirectory.getChild("new-file-3");
+
+    FileSystemUtils.createEmptyFile(newPath1);
+    FileSystemUtils.createEmptyFile(newPath2);
+    FileSystemUtils.createEmptyFile(newPath3);
+
+    assertTrue(newPath2.delete());
+    assertThat(xEmptyDirectory.getDirectoryEntries()).containsExactly(newPath1, newPath3);
+  }
+
+  @Test
+  public void testDeleteNonExistingDir() throws Exception {
+    Path path = xEmptyDirectory.getRelative("non-existing-dir");
+    assertFalse(path.delete());
+  }
+
+  @Test
+  public void testDeleteNotADirectoryPath() throws Exception {
+    Path path = xFile.getChild("new-file");
+    assertFalse(path.delete());
+  }
+
+  // Here we test the situations where delete should throw exceptions.
+  @Test
+  public void testDeleteNonEmptyDirectoryThrowsException() throws Exception {
+    try {
+      xNonEmptyDirectory.delete();
+      fail();
+    } catch (IOException e) {
+      assertEquals(xNonEmptyDirectory + " (Directory not empty)", e.getMessage());
+    }
+  }
+
+  @Test
+  public void testDeleteNonEmptyDirectoryNotDeletedDirectory() throws Exception {
+    try {
+      xNonEmptyDirectory.delete();
+      fail();
+    } catch (IOException e) {
+      // Expected
+    }
+
+    assertTrue(xNonEmptyDirectory.isDirectory());
+  }
+
+  @Test
+  public void testDeleteNonEmptyDirectoryNotDeletedFile() throws Exception {
+    try {
+      xNonEmptyDirectory.delete();
+      fail();
+    } catch (IOException e) {
+      // Expected
+    }
+
+    assertTrue(xNonEmptyDirectoryFoo.isFile());
+  }
+
+  @Test
+  public void testCannotRemoveRoot() {
+    Path rootDirectory = testFS.getRootDirectory();
+    try {
+      rootDirectory.delete();
+      fail();
+    } catch (IOException e) {
+      String msg = e.getMessage();
+      assertTrue(String.format("got %s want EBUSY or ENOTEMPTY", msg),
+          msg.endsWith(" (Directory not empty)")
+          || msg.endsWith(" (Device or resource busy)")
+          || msg.endsWith(" (Is a directory)"));  // Happens on OS X.
+    }
+  }
+
+  // Test the date functions
+  @Test
+  public void testCreateFileChangesTimeOfDirectory() throws Exception {
+    storeReferenceTime(workingDir.getLastModifiedTime());
+    Path newPath = absolutize("new-file");
+    FileSystemUtils.createEmptyFile(newPath);
+    assertTrue(isLaterThanreferenceTime(workingDir.getLastModifiedTime()));
+  }
+
+  @Test
+  public void testRemoveFileChangesTimeOfDirectory() throws Exception {
+    Path newPath = absolutize("new-file");
+    FileSystemUtils.createEmptyFile(newPath);
+    storeReferenceTime(workingDir.getLastModifiedTime());
+    newPath.delete();
+    assertTrue(isLaterThanreferenceTime(workingDir.getLastModifiedTime()));
+  }
+
+  // This test is a little bit strange, as we cannot test the progression
+  // of the time directly. As the Java time and the OS time are slightly different.
+  // Therefore, we first create an unrelated file to get a notion
+  // of the current OS time and use that as a baseline.
+  @Test
+  public void testCreateFileTimestamp() throws Exception {
+    Path syncFile = absolutize("sync-file");
+    FileSystemUtils.createEmptyFile(syncFile);
+
+    Path newFile = absolutize("new-file");
+    storeReferenceTime(syncFile.getLastModifiedTime());
+    FileSystemUtils.createEmptyFile(newFile);
+    assertTrue(isLaterThanreferenceTime(newFile.getLastModifiedTime()));
+  }
+
+  @Test
+  public void testCreateDirectoryTimestamp() throws Exception {
+    Path syncFile = absolutize("sync-file");
+    FileSystemUtils.createEmptyFile(syncFile);
+
+    Path newPath = absolutize("new-dir");
+    storeReferenceTime(syncFile.getLastModifiedTime());
+    assertTrue(newPath.createDirectory());
+    assertTrue(isLaterThanreferenceTime(newPath.getLastModifiedTime()));
+  }
+
+  @Test
+  public void testWriteChangesModifiedTime() throws Exception {
+    storeReferenceTime(xFile.getLastModifiedTime());
+    FileSystemUtils.writeContentAsLatin1(xFile, "abc19");
+    assertTrue(isLaterThanreferenceTime(xFile.getLastModifiedTime()));
+  }
+
+  @Test
+  public void testGetLastModifiedTimeThrowsExceptionForNonexistingPath() throws Exception {
+    Path newPath = testFS.getPath("/non-existing-dir");
+    try {
+      newPath.getLastModifiedTime();
+      fail("FileNotFoundException not thrown!");
+    } catch (FileNotFoundException x) {
+      assertEquals(newPath + " (No such file or directory)", x.getMessage());
+    }
+  }
+
+  // Test file size
+  @Test
+  public void testFileSizeThrowsExceptionForNonexistingPath() throws Exception {
+    Path newPath = testFS.getPath("/non-existing-file");
+    try {
+      newPath.getFileSize();
+      fail("FileNotFoundException not thrown.");
+    } catch (FileNotFoundException e) {
+      assertEquals(newPath + " (No such file or directory)", e.getMessage());
+    }
+  }
+
+  @Test
+  public void testFileSizeAfterWrite() throws Exception {
+    String testData = "abc19";
+
+    FileSystemUtils.writeContentAsLatin1(xFile, testData);
+    assertEquals(testData.length(), xFile.getFileSize());
+  }
+
+  // Testing the input/output routines
+  @Test
+  public void testFileWriteAndReadAsLatin1() throws Exception {
+    String testData = "abc19";
+
+    FileSystemUtils.writeContentAsLatin1(xFile, testData);
+    String resultData = new String(FileSystemUtils.readContentAsLatin1(xFile));
+
+    assertEquals(testData,resultData);
+  }
+
+  @Test
+  public void testInputAndOutputStreamEOF() throws Exception {
+    OutputStream outStream = xFile.getOutputStream();
+    outStream.write(1);
+    outStream.close();
+
+    InputStream inStream = xFile.getInputStream();
+    inStream.read();
+    assertEquals(-1, inStream.read());
+    inStream.close();
+  }
+
+  @Test
+  public void testInputAndOutputStream() throws Exception {
+    OutputStream outStream = xFile.getOutputStream();
+    for (int i = 33; i < 126; i++) {
+      outStream.write(i);
+    }
+    outStream.close();
+
+    InputStream inStream = xFile.getInputStream();
+    for (int i = 33; i < 126; i++) {
+      int readValue = inStream.read();
+      assertEquals(i,readValue);
+    }
+    inStream.close();
+  }
+
+  @Test
+  public void testInputAndOutputStreamAppend() throws Exception {
+    OutputStream outStream = xFile.getOutputStream();
+    for (int i = 33; i < 126; i++) {
+      outStream.write(i);
+    }
+    outStream.close();
+
+    OutputStream appendOut = xFile.getOutputStream(true);
+    for (int i = 126; i < 155; i++) {
+      appendOut.write(i);
+    }
+    appendOut.close();
+
+    InputStream inStream = xFile.getInputStream();
+    for (int i = 33; i < 155; i++) {
+      int readValue = inStream.read();
+      assertEquals(i,readValue);
+    }
+    inStream.close();
+  }
+
+  @Test
+  public void testInputAndOutputStreamNoAppend() throws Exception {
+    OutputStream outStream = xFile.getOutputStream();
+    outStream.write(1);
+    outStream.close();
+
+    OutputStream noAppendOut = xFile.getOutputStream(false);
+    noAppendOut.close();
+
+    InputStream inStream = xFile.getInputStream();
+    assertEquals(-1, inStream.read());
+    inStream.close();
+  }
+
+  @Test
+  public void testGetOutputStreamCreatesFile() throws Exception {
+    Path newFile = absolutize("does_not_exist_yet.txt");
+
+    OutputStream out = newFile.getOutputStream();
+    out.write(42);
+    out.close();
+
+    assertTrue(newFile.isFile());
+  }
+
+  @Test
+  public void testInpuStreamThrowExceptionOnDirectory() throws Exception {
+    try {
+      xEmptyDirectory.getOutputStream();
+      fail("The Exception was not thrown!");
+    } catch (IOException ex) {
+      assertEquals(xEmptyDirectory + " (Is a directory)", ex.getMessage());
+    }
+  }
+
+  @Test
+  public void testOutputStreamThrowExceptionOnDirectory() throws Exception {
+    try {
+      xEmptyDirectory.getInputStream();
+      fail("The Exception was not thrown!");
+    } catch (IOException ex) {
+      assertEquals(xEmptyDirectory + " (Is a directory)", ex.getMessage());
+    }
+  }
+
+  // Test renaming
+  @Test
+  public void testCanRenameToUnusedName() throws Exception {
+    xFile.renameTo(xNothing);
+    assertFalse(xFile.exists());
+    assertTrue(xNothing.isFile());
+  }
+
+  @Test
+  public void testCanRenameFileToExistingFile() throws Exception {
+    Path otherFile = absolutize("otherFile");
+    FileSystemUtils.createEmptyFile(otherFile);
+    xFile.renameTo(otherFile); // succeeds
+    assertFalse(xFile.exists());
+    assertTrue(otherFile.isFile());
+  }
+
+  @Test
+  public void testCanRenameDirToExistingEmptyDir() throws Exception {
+    xNonEmptyDirectory.renameTo(xEmptyDirectory); // succeeds
+    assertFalse(xNonEmptyDirectory.exists());
+    assertTrue(xEmptyDirectory.isDirectory());
+    assertFalse(xEmptyDirectory.getDirectoryEntries().isEmpty());
+  }
+
+  @Test
+  public void testCantRenameDirToExistingNonEmptyDir() throws Exception {
+    try {
+      xEmptyDirectory.renameTo(xNonEmptyDirectory);
+      fail();
+    } catch (IOException e) {
+      MoreAsserts.assertEndsWith(" (Directory not empty)", e.getMessage());
+    }
+  }
+
+  @Test
+  public void testCantRenameDirToExistingNonEmptyDirNothingChanged() throws Exception {
+    try {
+      xEmptyDirectory.renameTo(xNonEmptyDirectory);
+      fail();
+    } catch (IOException e) {
+      // Expected
+    }
+
+    assertTrue(xNonEmptyDirectory.isDirectory());
+    assertTrue(xEmptyDirectory.isDirectory());
+    assertTrue(xEmptyDirectory.getDirectoryEntries().isEmpty());
+    assertFalse(xNonEmptyDirectory.getDirectoryEntries().isEmpty());
+  }
+
+  @Test
+  public void testCantRenameDirToExistingFile() {
+    try {
+      xEmptyDirectory.renameTo(xFile);
+      fail();
+    } catch (IOException e) {
+      assertEquals(xEmptyDirectory + " -> " + xFile + " (Not a directory)", e.getMessage());
+    }
+  }
+
+  @Test
+  public void testCantRenameDirToExistingFileNothingChanged() {
+    try {
+      xEmptyDirectory.renameTo(xFile);
+      fail();
+    } catch (IOException e) {
+      // Expected
+    }
+
+    assertTrue(xEmptyDirectory.isDirectory());
+    assertTrue(xFile.isFile());
+  }
+
+  @Test
+  public void testCantRenameFileToExistingDir() {
+    try {
+      xFile.renameTo(xEmptyDirectory);
+      fail();
+    } catch (IOException e) {
+      assertEquals(xFile + " -> " + xEmptyDirectory + " (Is a directory)",
+                   e.getMessage());
+    }
+  }
+
+  @Test
+  public void testCantRenameFileToExistingDirNothingChanged() {
+    try {
+      xFile.renameTo(xEmptyDirectory);
+      fail();
+    } catch (IOException e) {
+      // Expected
+    }
+
+    assertTrue(xEmptyDirectory.isDirectory());
+    assertTrue(xFile.isFile());
+  }
+
+  @Test
+  public void testMoveOnNonExistingFileThrowsException() throws Exception {
+    Path nonExistingPath = absolutize("non-existing");
+    Path targetPath = absolutize("does-not-matter");
+    try {
+      nonExistingPath.renameTo(targetPath);
+      fail();
+    } catch (FileNotFoundException e) {
+      MoreAsserts.assertEndsWith(" (No such file or directory)", e.getMessage());
+    }
+  }
+
+  // Test the Paths
+  @Test
+  public void testGetPathOnlyAcceptsAbsolutePath() {
+    try {
+      testFS.getPath("not-absolute");
+      fail("The expected Exception was not thrown.");
+    } catch (IllegalArgumentException ex) {
+      assertEquals("not-absolute (not an absolute path)", ex.getMessage());
+    }
+  }
+
+  @Test
+  public void testGetPathOnlyAcceptsAbsolutePathFragment() {
+    try {
+      testFS.getPath(new PathFragment("not-absolute"));
+      fail("The expected Exception was not thrown.");
+    } catch (IllegalArgumentException ex) {
+      assertEquals("not-absolute (not an absolute path)", ex.getMessage());
+    }
+  }
+
+  // Test the access permissions
+  @Test
+  public void testNewFilesAreWritable() throws Exception {
+    assertTrue(xFile.isWritable());
+  }
+
+  @Test
+  public void testNewFilesAreReadable() throws Exception {
+    assertTrue(xFile.isReadable());
+  }
+
+  @Test
+  public void testNewDirsAreWritable() throws Exception {
+    assertTrue(xEmptyDirectory.isWritable());
+  }
+
+  @Test
+  public void testNewDirsAreReadable() throws Exception {
+    assertTrue(xEmptyDirectory.isReadable());
+  }
+
+  @Test
+  public void testNewDirsAreExecutable() throws Exception {
+    assertTrue(xEmptyDirectory.isExecutable());
+  }
+
+  @Test
+  public void testCannotGetExecutableOnNonexistingFile() throws Exception {
+    try {
+      xNothing.isExecutable();
+      fail("No exception thrown.");
+    } catch (FileNotFoundException ex) {
+      assertEquals(xNothing + " (No such file or directory)", ex.getMessage());
+    }
+  }
+
+  @Test
+  public void testCannotSetExecutableOnNonexistingFile() throws Exception {
+    try {
+      xNothing.setExecutable(true);
+      fail("No exception thrown.");
+    } catch (FileNotFoundException ex) {
+      assertEquals(xNothing + " (No such file or directory)", ex.getMessage());
+    }
+  }
+
+  @Test
+  public void testCannotGetWritableOnNonexistingFile() throws Exception {
+    try {
+      xNothing.isWritable();
+      fail("No exception thrown.");
+    } catch (FileNotFoundException ex) {
+      assertEquals(xNothing + " (No such file or directory)", ex.getMessage());
+    }
+  }
+
+  @Test
+  public void testCannotSetWritableOnNonexistingFile() throws Exception {
+    try {
+      xNothing.setWritable(false);
+      fail("No exception thrown.");
+    } catch (FileNotFoundException ex) {
+      assertEquals(xNothing + " (No such file or directory)", ex.getMessage());
+    }
+  }
+
+  @Test
+  public void testSetReadableOnFile() throws Exception {
+    xFile.setReadable(false);
+    assertFalse(xFile.isReadable());
+    xFile.setReadable(true);
+    assertTrue(xFile.isReadable());
+  }
+
+  @Test
+  public void testSetWritableOnFile() throws Exception {
+    xFile.setWritable(false);
+    assertFalse(xFile.isWritable());
+    xFile.setWritable(true);
+    assertTrue(xFile.isWritable());
+  }
+
+  @Test
+  public void testSetExecutableOnFile() throws Exception {
+    xFile.setExecutable(true);
+    assertTrue(xFile.isExecutable());
+    xFile.setExecutable(false);
+    assertFalse(xFile.isExecutable());
+  }
+
+  @Test
+  public void testSetExecutableOnDirectory() throws Exception {
+    setExecutable(xNonEmptyDirectory, false);
+
+    try {
+      // We can't map names->inodes in a non-executable directory:
+      xNonEmptyDirectoryFoo.isWritable(); // i.e. stat
+      fail();
+    } catch (IOException e) {
+      MoreAsserts.assertEndsWith(" (Permission denied)", e.getMessage());
+    }
+  }
+
+  @Test
+  public void testWritingToReadOnlyFileThrowsException() throws Exception {
+    xFile.setWritable(false);
+    try {
+      FileSystemUtils.writeContent(xFile, "hello, world!".getBytes());
+      fail("No exception thrown.");
+    } catch (IOException e) {
+      assertEquals(xFile + " (Permission denied)", e.getMessage());
+    }
+  }
+
+  @Test
+  public void testReadingFromUnreadableFileThrowsException() throws Exception {
+    FileSystemUtils.writeContent(xFile, "hello, world!".getBytes());
+    xFile.setReadable(false);
+    try {
+      FileSystemUtils.readContent(xFile);
+      fail("No exception thrown.");
+    } catch (IOException e) {
+      assertEquals(xFile + " (Permission denied)", e.getMessage());
+    }
+  }
+
+  @Test
+  public void testCannotCreateFileInReadOnlyDirectory() throws Exception {
+    Path xNonEmptyDirectoryBar = xNonEmptyDirectory.getChild("bar");
+    xNonEmptyDirectory.setWritable(false);
+
+    try {
+      FileSystemUtils.createEmptyFile(xNonEmptyDirectoryBar);
+      fail("No exception thrown.");
+    } catch (IOException e) {
+      assertEquals(xNonEmptyDirectoryBar + " (Permission denied)", e.getMessage());
+    }
+  }
+
+  @Test
+  public void testCannotCreateDirectoryInReadOnlyDirectory() throws Exception {
+    Path xNonEmptyDirectoryBar = xNonEmptyDirectory.getChild("bar");
+    xNonEmptyDirectory.setWritable(false);
+
+    try {
+      xNonEmptyDirectoryBar.createDirectory();
+      fail("No exception thrown.");
+    } catch (IOException e) {
+      assertEquals(xNonEmptyDirectoryBar + " (Permission denied)", e.getMessage());
+    }
+  }
+
+  @Test
+  public void testCannotMoveIntoReadOnlyDirectory() throws Exception {
+    Path xNonEmptyDirectoryBar = xNonEmptyDirectory.getChild("bar");
+    xNonEmptyDirectory.setWritable(false);
+
+    try {
+      xFile.renameTo(xNonEmptyDirectoryBar);
+      fail("No exception thrown.");
+    } catch (IOException e) {
+      MoreAsserts.assertEndsWith(" (Permission denied)", e.getMessage());
+    }
+  }
+
+  @Test
+  public void testCannotMoveFromReadOnlyDirectory() throws Exception {
+    xNonEmptyDirectory.setWritable(false);
+
+    try {
+      xNonEmptyDirectoryFoo.renameTo(xNothing);
+      fail("No exception thrown.");
+    } catch (IOException e) {
+      MoreAsserts.assertEndsWith(" (Permission denied)", e.getMessage());
+    }
+  }
+
+  @Test
+  public void testCannotDeleteInReadOnlyDirectory() throws Exception {
+    xNonEmptyDirectory.setWritable(false);
+
+    try {
+      xNonEmptyDirectoryFoo.delete();
+      fail("No exception thrown.");
+    } catch (IOException e) {
+      assertEquals(xNonEmptyDirectoryFoo + " (Permission denied)", e.getMessage());
+    }
+  }
+
+  @Test
+  public void testCannotCreatSymbolicLinkInReadOnlyDirectory() throws Exception {
+    Path xNonEmptyDirectoryBar = xNonEmptyDirectory.getChild("bar");
+    xNonEmptyDirectory.setWritable(false);
+
+    if (supportsSymlinks) {
+      try {
+        createSymbolicLink(xNonEmptyDirectoryBar, xNonEmptyDirectoryFoo);
+        fail("No exception thrown.");
+      } catch (IOException e) {
+        assertEquals(xNonEmptyDirectoryBar + " (Permission denied)", e.getMessage());
+      }
+    }
+  }
+
+  @Test
+  public void testGetMD5DigestForEmptyFile() throws Exception {
+    Fingerprint fp = new Fingerprint();
+    fp.addBytes(new byte[0]);
+    assertEquals(BaseEncoding.base16().lowerCase().encode(xFile.getMD5Digest()),
+        fp.hexDigestAndReset());
+  }
+
+  @Test
+  public void testGetMD5Digest() throws Exception {
+    byte[] buffer = new byte[500000];
+    for (int i = 0; i < buffer.length; ++i) {
+      buffer[i] = 1;
+    }
+    FileSystemUtils.writeContent(xFile, buffer);
+    Fingerprint fp = new Fingerprint();
+    fp.addBytes(buffer);
+    assertEquals(BaseEncoding.base16().lowerCase().encode(xFile.getMD5Digest()),
+        fp.hexDigestAndReset());
+  }
+
+  @Test
+  public void testStatFailsFastOnNonExistingFiles() throws Exception {
+    try {
+      xNothing.stat();
+      fail("Expected IOException");
+    } catch(IOException e) {
+      // Do nothing.
+    }
+  }
+
+  @Test
+  public void testStatNullableFailsFastOnNonExistingFiles() throws Exception {
+    assertNull(xNothing.statNullable());
+  }
+
+  @Test
+  public void testResolveSymlinks() throws Exception {
+    if (supportsSymlinks) {
+      createSymbolicLink(xNothing, xFile);
+      FileSystemUtils.createEmptyFile(xFile);
+      assertEquals(xFile.asFragment(), testFS.resolveOneLink(xNothing));
+      assertEquals(xFile, xNothing.resolveSymbolicLinks());
+    }
+  }
+
+  @Test
+  public void testResolveNonSymlinks() throws Exception {
+    if (supportsSymlinks) {
+      assertEquals(null, testFS.resolveOneLink(xFile));
+      assertEquals(xFile, xFile.resolveSymbolicLinks());
+    }
+  }
+
+}
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/FileSystemUtilsTest.java b/src/test/java/com/google/devtools/build/lib/vfs/FileSystemUtilsTest.java
new file mode 100644
index 0000000..21ca39b
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/vfs/FileSystemUtilsTest.java
@@ -0,0 +1,878 @@
+// Copyright 2014 Google Inc. 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.vfs;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.devtools.build.lib.vfs.FileSystemUtils.appendWithoutExtension;
+import static com.google.devtools.build.lib.vfs.FileSystemUtils.commonAncestor;
+import static com.google.devtools.build.lib.vfs.FileSystemUtils.copyFile;
+import static com.google.devtools.build.lib.vfs.FileSystemUtils.copyTool;
+import static com.google.devtools.build.lib.vfs.FileSystemUtils.createDirectoryAndParents;
+import static com.google.devtools.build.lib.vfs.FileSystemUtils.deleteTree;
+import static com.google.devtools.build.lib.vfs.FileSystemUtils.deleteTreesBelowNotPrefixed;
+import static com.google.devtools.build.lib.vfs.FileSystemUtils.longestPathPrefix;
+import static com.google.devtools.build.lib.vfs.FileSystemUtils.plantLinkForest;
+import static com.google.devtools.build.lib.vfs.FileSystemUtils.relativePath;
+import static com.google.devtools.build.lib.vfs.FileSystemUtils.removeExtension;
+import static com.google.devtools.build.lib.vfs.FileSystemUtils.touchFile;
+import static com.google.devtools.build.lib.vfs.FileSystemUtils.traverseTree;
+import static java.nio.charset.StandardCharsets.ISO_8859_1;
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.base.Predicate;
+import com.google.common.base.Predicates;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Lists;
+import com.google.devtools.build.lib.testutil.BlazeTestUtils;
+import com.google.devtools.build.lib.testutil.ManualClock;
+import com.google.devtools.build.lib.vfs.inmemoryfs.InMemoryFileSystem;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.PrintStream;
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * This class tests the file system utilities.
+ */
+@RunWith(JUnit4.class)
+public class FileSystemUtilsTest {
+  private ManualClock clock;
+  private FileSystem fileSystem;
+  private Path workingDir;
+
+  @Before
+  public void setUp() throws Exception {
+    clock = new ManualClock();
+    fileSystem = new InMemoryFileSystem(clock);
+    workingDir = fileSystem.getPath("/workingDir");
+  }
+
+  Path topDir;
+  Path file1;
+  Path file2;
+  Path aDir;
+  Path file3;
+  Path innerDir;
+  Path link1;
+  Path dirLink;
+  Path file4;
+
+  /*
+   * Build a directory tree that looks like:
+   *   top-dir/
+   *     file-1
+   *     file-2
+   *     a-dir/
+   *       file-3
+   *       inner-dir/
+   *         link-1 => file-4
+   *         dir-link => a-dir
+   *   file-4
+   */
+  private void createTestDirectoryTree() throws IOException {
+    topDir = fileSystem.getPath("/top-dir");
+    file1 = fileSystem.getPath("/top-dir/file-1");
+    file2 = fileSystem.getPath("/top-dir/file-2");
+    aDir = fileSystem.getPath("/top-dir/a-dir");
+    file3 = fileSystem.getPath("/top-dir/a-dir/file-3");
+    innerDir = fileSystem.getPath("/top-dir/a-dir/inner-dir");
+    link1 = fileSystem.getPath("/top-dir/a-dir/inner-dir/link-1");
+    dirLink = fileSystem.getPath("/top-dir/a-dir/inner-dir/dir-link");
+    file4 = fileSystem.getPath("/file-4");
+
+    topDir.createDirectory();
+    FileSystemUtils.createEmptyFile(file1);
+    FileSystemUtils.createEmptyFile(file2);
+    aDir.createDirectory();
+    FileSystemUtils.createEmptyFile(file3);
+    innerDir.createDirectory();
+    link1.createSymbolicLink(file4);  // simple symlink
+    dirLink.createSymbolicLink(aDir); // creates link loop
+    FileSystemUtils.createEmptyFile(file4);
+  }
+
+  private void checkTestDirectoryTreesBelow(Path toPath) throws IOException {
+    Path copiedFile1 = toPath.getChild("file-1");
+    assertTrue(copiedFile1.exists());
+    assertTrue(copiedFile1.isFile());
+
+    Path copiedFile2 = toPath.getChild("file-2");
+    assertTrue(copiedFile2.exists());
+    assertTrue(copiedFile2.isFile());
+
+    Path copiedADir = toPath.getChild("a-dir");
+    assertTrue(copiedADir.exists());
+    assertTrue(copiedADir.isDirectory());
+    Collection<Path> aDirEntries = copiedADir.getDirectoryEntries();
+    assertEquals(2, aDirEntries.size());
+
+    Path copiedFile3 = copiedADir.getChild("file-3");
+    assertTrue(copiedFile3.exists());
+    assertTrue(copiedFile3.isFile());
+
+    Path copiedInnerDir = copiedADir.getChild("inner-dir");
+    assertTrue(copiedInnerDir.exists());
+    assertTrue(copiedInnerDir.isDirectory());
+
+    Path copiedLink1 = copiedInnerDir.getChild("link-1");
+    assertTrue(copiedLink1.exists());
+    assertTrue(copiedLink1.isSymbolicLink());
+    assertEquals(copiedLink1.resolveSymbolicLinks(), file4);
+
+    Path copiedDirLink = copiedInnerDir.getChild("dir-link");
+    assertTrue(copiedDirLink.exists());
+    assertTrue(copiedDirLink.isSymbolicLink());
+    assertEquals(copiedDirLink.resolveSymbolicLinks(), aDir);
+  }
+
+  // tests
+
+  @Test
+  public void testChangeModtime() throws IOException {
+    Path file = fileSystem.getPath("/my-file");
+    try {
+      BlazeTestUtils.changeModtime(file);
+      fail();
+    } catch (FileNotFoundException e) {
+      /* ok */
+    }
+    FileSystemUtils.createEmptyFile(file);
+    long prevMtime = file.getLastModifiedTime();
+    BlazeTestUtils.changeModtime(file);
+    assertFalse(prevMtime == file.getLastModifiedTime());
+  }
+
+  @Test
+  public void testCommonAncestor() {
+    assertEquals(topDir, commonAncestor(topDir, topDir));
+    assertEquals(topDir, commonAncestor(file1, file3));
+    assertEquals(topDir, commonAncestor(file1, dirLink));
+  }
+
+  @Test
+  public void testRelativePath() throws IOException {
+    createTestDirectoryTree();
+    assertEquals("file-1", relativePath(topDir, file1).getPathString());
+    assertEquals(".", relativePath(topDir, topDir).getPathString());
+    assertEquals("a-dir/inner-dir/dir-link", relativePath(topDir, dirLink).getPathString());
+    assertEquals("../file-4", relativePath(topDir, file4).getPathString());
+    assertEquals("../../../file-4", relativePath(innerDir, file4).getPathString());
+  }
+
+  private String longestPathPrefixStr(String path, String... prefixStrs) {
+    Set<PathFragment> prefixes = new HashSet<>();
+    for (String prefix : prefixStrs) {
+      prefixes.add(new PathFragment(prefix));
+    }
+    PathFragment longest = longestPathPrefix(new PathFragment(path), prefixes);
+    return longest != null ? longest.getPathString() : null;
+  }
+
+  @Test
+  public void testLongestPathPrefix() {
+    assertEquals("A", longestPathPrefixStr("A/b", "A", "B")); // simple parent
+    assertEquals("A", longestPathPrefixStr("A", "A", "B")); // self
+    assertEquals("A/B", longestPathPrefixStr("A/B/c", "A", "A/B"));  // want longest
+    assertNull(longestPathPrefixStr("C/b", "A", "B"));  // not found in other parents
+    assertNull(longestPathPrefixStr("A", "A/B", "B"));  // not found in child
+    assertEquals("A/B/C", longestPathPrefixStr("A/B/C/d/e/f.h", "A/B/C", "B/C/d"));
+  }
+
+  @Test
+  public void testRemoveExtension_Strings() throws Exception {
+    assertEquals("foo", removeExtension("foo.c"));
+    assertEquals("a/foo", removeExtension("a/foo.c"));
+    assertEquals("a.b/foo", removeExtension("a.b/foo"));
+    assertEquals("foo", removeExtension("foo"));
+    assertEquals("foo", removeExtension("foo."));
+  }
+
+  @Test
+  public void testRemoveExtension_Paths() throws Exception {
+    assertPath("/foo", removeExtension(fileSystem.getPath("/foo.c")));
+    assertPath("/a/foo", removeExtension(fileSystem.getPath("/a/foo.c")));
+    assertPath("/a.b/foo", removeExtension(fileSystem.getPath("/a.b/foo")));
+    assertPath("/foo", removeExtension(fileSystem.getPath("/foo")));
+    assertPath("/foo", removeExtension(fileSystem.getPath("/foo.")));
+  }
+
+  private static void assertPath(String expected, PathFragment actual) {
+    assertEquals(expected, actual.getPathString());
+  }
+
+  private static void assertPath(String expected, Path actual) {
+    assertEquals(expected, actual.getPathString());
+  }
+
+  @Test
+  public void testReplaceExtension_Path() throws Exception {
+    assertPath("/foo/bar.baz",
+               FileSystemUtils.replaceExtension(fileSystem.getPath("/foo/bar"), ".baz"));
+    assertPath("/foo/bar.baz",
+               FileSystemUtils.replaceExtension(fileSystem.getPath("/foo/bar.cc"), ".baz"));
+    assertPath("/foo.baz", FileSystemUtils.replaceExtension(fileSystem.getPath("/foo/"), ".baz"));
+    assertPath("/foo.baz",
+               FileSystemUtils.replaceExtension(fileSystem.getPath("/foo.cc/"), ".baz"));
+    assertPath("/foo.baz", FileSystemUtils.replaceExtension(fileSystem.getPath("/foo"), ".baz"));
+    assertPath("/foo.baz", FileSystemUtils.replaceExtension(fileSystem.getPath("/foo.cc"), ".baz"));
+    assertPath("/.baz", FileSystemUtils.replaceExtension(fileSystem.getPath("/.cc"), ".baz"));
+    assertEquals(null, FileSystemUtils.replaceExtension(fileSystem.getPath("/"), ".baz"));
+  }
+
+  @Test
+  public void testReplaceExtension_PathFragment() throws Exception {
+    assertPath("foo/bar.baz",
+               FileSystemUtils.replaceExtension(new PathFragment("foo/bar"), ".baz"));
+    assertPath("foo/bar.baz",
+               FileSystemUtils.replaceExtension(new PathFragment("foo/bar.cc"), ".baz"));
+    assertPath("/foo/bar.baz",
+               FileSystemUtils.replaceExtension(new PathFragment("/foo/bar"), ".baz"));
+    assertPath("/foo/bar.baz",
+               FileSystemUtils.replaceExtension(new PathFragment("/foo/bar.cc"), ".baz"));
+    assertPath("foo.baz", FileSystemUtils.replaceExtension(new PathFragment("foo/"), ".baz"));
+    assertPath("foo.baz", FileSystemUtils.replaceExtension(new PathFragment("foo.cc/"), ".baz"));
+    assertPath("/foo.baz", FileSystemUtils.replaceExtension(new PathFragment("/foo/"), ".baz"));
+    assertPath("/foo.baz",
+               FileSystemUtils.replaceExtension(new PathFragment("/foo.cc/"), ".baz"));
+    assertPath("foo.baz", FileSystemUtils.replaceExtension(new PathFragment("foo"), ".baz"));
+    assertPath("foo.baz", FileSystemUtils.replaceExtension(new PathFragment("foo.cc"), ".baz"));
+    assertPath("/foo.baz", FileSystemUtils.replaceExtension(new PathFragment("/foo"), ".baz"));
+    assertPath("/foo.baz",
+               FileSystemUtils.replaceExtension(new PathFragment("/foo.cc"), ".baz"));
+    assertPath(".baz", FileSystemUtils.replaceExtension(new PathFragment(".cc"), ".baz"));
+    assertEquals(null, FileSystemUtils.replaceExtension(new PathFragment("/"), ".baz"));
+    assertEquals(null, FileSystemUtils.replaceExtension(new PathFragment(""), ".baz"));
+    assertPath("foo/bar.baz",
+        FileSystemUtils.replaceExtension(new PathFragment("foo/bar.pony"), ".baz", ".pony"));
+    assertPath("foo/bar.baz",
+        FileSystemUtils.replaceExtension(new PathFragment("foo/bar"), ".baz", ""));
+    assertEquals(null, FileSystemUtils.replaceExtension(new PathFragment(""), ".baz", ".pony"));
+    assertEquals(null,
+        FileSystemUtils.replaceExtension(new PathFragment("foo/bar.pony"), ".baz", ".unicorn"));
+  }
+
+  @Test
+  public void testAppendWithoutExtension() throws Exception {
+    assertPath("libfoo-src.jar",
+        appendWithoutExtension(new PathFragment("libfoo.jar"), "-src"));
+    assertPath("foo/libfoo-src.jar",
+        appendWithoutExtension(new PathFragment("foo/libfoo.jar"), "-src"));
+    assertPath("java/com/google/foo/libfoo-src.jar",
+        appendWithoutExtension(new PathFragment("java/com/google/foo/libfoo.jar"), "-src"));
+    assertPath("libfoo.bar-src.jar",
+        appendWithoutExtension(new PathFragment("libfoo.bar.jar"), "-src"));
+    assertPath("libfoo-src",
+        appendWithoutExtension(new PathFragment("libfoo"), "-src"));
+    assertPath("libfoo-src.jar",
+        appendWithoutExtension(new PathFragment("libfoo.jar/"), "-src"));
+    assertPath("libfoo.src.jar",
+        appendWithoutExtension(new PathFragment("libfoo.jar"), ".src"));
+    assertEquals(null, appendWithoutExtension(new PathFragment("/"), "-src"));
+    assertEquals(null, appendWithoutExtension(new PathFragment(""), "-src"));
+  }
+
+  @Test
+  public void testReplaceSegments() {
+    assertPath(
+        "poo/bar/baz.cc",
+        FileSystemUtils.replaceSegments(new PathFragment("foo/bar/baz.cc"), "foo", "poo", true));
+    assertPath(
+        "poo/poo/baz.cc",
+        FileSystemUtils.replaceSegments(new PathFragment("foo/foo/baz.cc"), "foo", "poo", true));
+    assertPath(
+        "poo/foo/baz.cc",
+        FileSystemUtils.replaceSegments(new PathFragment("foo/foo/baz.cc"), "foo", "poo", false));
+    assertPath(
+        "foo/bar/baz.cc",
+        FileSystemUtils.replaceSegments(new PathFragment("foo/bar/baz.cc"), "boo", "poo", true));
+  }
+
+  @Test
+  public void testGetWorkingDirectory() {
+    String userDir = System.getProperty("user.dir");
+
+    assertEquals(FileSystemUtils.getWorkingDirectory(fileSystem),
+        fileSystem.getPath(System.getProperty("user.dir", "/")));
+
+    System.setProperty("user.dir", "/blah/blah/blah");
+    assertEquals(FileSystemUtils.getWorkingDirectory(fileSystem),
+        fileSystem.getPath("/blah/blah/blah"));
+
+    System.setProperty("user.dir", userDir);
+  }
+
+  @Test
+  public void testResolveRelativeToFilesystemWorkingDir() {
+    PathFragment relativePath = new PathFragment("relative/path");
+    assertEquals(workingDir.getRelative(relativePath),
+                 workingDir.getRelative(relativePath));
+
+    PathFragment absolutePath = new PathFragment("/absolute/path");
+    assertEquals(fileSystem.getPath(absolutePath),
+                 workingDir.getRelative(absolutePath));
+  }
+
+  @Test
+  public void testTouchFileCreatesFile() throws IOException {
+    createTestDirectoryTree();
+    Path nonExistingFile = fileSystem.getPath("/previously-non-existing");
+    assertFalse(nonExistingFile.exists());
+    touchFile(nonExistingFile);
+
+    assertTrue(nonExistingFile.exists());
+  }
+
+  @Test
+  public void testTouchFileAdjustsFileTime() throws IOException {
+    createTestDirectoryTree();
+    Path testFile = file4;
+    long oldTime = testFile.getLastModifiedTime();
+    testFile.setLastModifiedTime(42);
+    touchFile(testFile);
+
+    assertTrue(testFile.getLastModifiedTime() >= oldTime);
+  }
+
+  @Test
+  public void testCopyFile() throws IOException {
+    createTestDirectoryTree();
+    Path originalFile = file1;
+    byte[] content = new byte[] { 'a', 'b', 'c', 23, 42 };
+    FileSystemUtils.writeContent(originalFile, content);
+
+    Path copyTarget = file2;
+
+    copyFile(originalFile, copyTarget);
+
+    assertTrue(Arrays.equals(content, FileSystemUtils.readContent(copyTarget)));
+  }
+
+  @Test
+  public void testReadContentWithLimit() throws IOException {
+    createTestDirectoryTree();
+    String str = "this is a test of readContentWithLimit method";
+    FileSystemUtils.writeContent(file1, StandardCharsets.ISO_8859_1, str);
+    assertEquals(readStringFromFile(file1, 0), "");
+    assertEquals(readStringFromFile(file1, 10), str.substring(0, 10));
+    assertEquals(readStringFromFile(file1, 1000000), str);
+  }
+
+  private String readStringFromFile(Path file, int limit) throws IOException {
+    byte[] bytes = FileSystemUtils.readContentWithLimit(file, limit);
+    return new String(bytes, StandardCharsets.ISO_8859_1);
+  }
+
+  @Test
+  public void testAppend() throws IOException {
+    createTestDirectoryTree();
+    FileSystemUtils.writeIsoLatin1(file1, "nobody says ");
+    FileSystemUtils.writeIsoLatin1(file1, "mary had");
+    FileSystemUtils.appendIsoLatin1(file1, "a little lamb");
+    assertEquals(
+        "mary had\na little lamb\n",
+        new String(FileSystemUtils.readContentAsLatin1(file1)));
+  }
+
+  @Test
+  public void testCopyFileAttributes() throws IOException {
+    createTestDirectoryTree();
+    Path originalFile = file1;
+    byte[] content = new byte[] { 'a', 'b', 'c', 23, 42 };
+    FileSystemUtils.writeContent(originalFile, content);
+    file1.setLastModifiedTime(12345L);
+    file1.setWritable(false);
+    file1.setExecutable(false);
+
+    Path copyTarget = file2;
+    copyFile(originalFile, copyTarget);
+
+    assertEquals(12345L, file2.getLastModifiedTime());
+    assertFalse(file2.isExecutable());
+    assertFalse(file2.isWritable());
+
+    file1.setWritable(true);
+    file1.setExecutable(true);
+
+    copyFile(originalFile, copyTarget);
+
+    assertEquals(12345L, file2.getLastModifiedTime());
+    assertTrue(file2.isExecutable());
+    assertTrue(file2.isWritable());
+
+  }
+
+  @Test
+  public void testCopyFileThrowsExceptionIfTargetCantBeDeleted() throws IOException {
+    createTestDirectoryTree();
+    Path originalFile = file1;
+    byte[] content = new byte[] { 'a', 'b', 'c', 23, 42 };
+    FileSystemUtils.writeContent(originalFile, content);
+
+    try {
+      copyFile(originalFile, aDir);
+      fail();
+    } catch (IOException ex) {
+      assertEquals("error copying file: couldn't delete destination: "
+                   + aDir + " (Directory not empty)",
+                   ex.getMessage());
+    }
+  }
+
+  @Test
+  public void testCopyTool() throws IOException {
+    createTestDirectoryTree();
+    Path originalFile = file1;
+    byte[] content = new byte[] { 'a', 'b', 'c', 23, 42 };
+    FileSystemUtils.writeContent(originalFile, content);
+
+    Path copyTarget = copyTool(topDir.getRelative("file-1"), aDir.getRelative("file-1"));
+
+    assertTrue(Arrays.equals(content, FileSystemUtils.readContent(copyTarget)));
+    assertEquals(file1.isWritable(), copyTarget.isWritable());
+    assertEquals(file1.isExecutable(), copyTarget.isExecutable());
+    assertEquals(file1.getLastModifiedTime(), copyTarget.getLastModifiedTime());
+  }
+
+  @Test
+  public void testCopyTreesBelow() throws IOException {
+    createTestDirectoryTree();
+    Path toPath = fileSystem.getPath("/copy-here");
+    toPath.createDirectory();
+
+    FileSystemUtils.copyTreesBelow(topDir, toPath);
+    checkTestDirectoryTreesBelow(toPath);
+  }
+
+  @Test
+  public void testCopyTreesBelowWithOverriding() throws IOException {
+    createTestDirectoryTree();
+    Path toPath = fileSystem.getPath("/copy-here");
+    toPath.createDirectory();
+    toPath.getChild("file-2");
+
+    FileSystemUtils.copyTreesBelow(topDir, toPath);
+    checkTestDirectoryTreesBelow(toPath);
+  }
+
+  @Test
+  public void testCopyTreesBelowToSubtree() throws IOException {
+    createTestDirectoryTree();
+    try {
+      FileSystemUtils.copyTreesBelow(topDir, aDir);
+      fail("Should not be able to copy a directory to a subdir");
+    } catch (IllegalArgumentException expected) {
+      assertEquals("/top-dir/a-dir is a subdirectory of /top-dir", expected.getMessage());
+    }
+  }
+
+  @Test
+  public void testCopyFileAsDirectoryTree() throws IOException {
+    createTestDirectoryTree();
+    try {
+      FileSystemUtils.copyTreesBelow(file1, aDir);
+      fail("Should not be able to copy a file with copyDirectory method");
+    } catch (IOException expected) {
+      assertEquals("/top-dir/file-1 (Not a directory)", expected.getMessage());
+    }
+  }
+
+  @Test
+  public void testCopyTreesBelowToFile() throws IOException {
+    createTestDirectoryTree();
+    Path copyDir = fileSystem.getPath("/my-dir");
+    Path copySubDir = fileSystem.getPath("/my-dir/subdir");
+    FileSystemUtils.createDirectoryAndParents(copySubDir);
+    try {
+      FileSystemUtils.copyTreesBelow(copyDir, file4);
+      fail("Should not be able to copy a directory to a file");
+    } catch (IOException expected) {
+      assertEquals("/file-4 (Not a directory)", expected.getMessage());
+    }
+  }
+
+  @Test
+  public void testCopyTreesBelowFromUnexistingDir() throws IOException {
+    createTestDirectoryTree();
+
+    try {
+      Path unexistingDir = fileSystem.getPath("/unexisting-dir");
+      FileSystemUtils.copyTreesBelow(unexistingDir, aDir);
+      fail("Should not be able to copy from an unexisting path");
+    } catch (FileNotFoundException expected) {
+      assertEquals("/unexisting-dir (No such file or directory)", expected.getMessage());
+    }
+  }
+
+  @Test
+  public void testTraverseTree() throws IOException {
+    createTestDirectoryTree();
+
+    Collection<Path> paths = traverseTree(topDir, new Predicate<Path>() {
+      @Override
+      public boolean apply(Path p) {
+        return !p.getPathString().contains("a-dir");
+      }
+    });
+    assertThat(paths).containsExactly(file1, file2);
+  }
+
+  @Test
+  public void testTraverseTreeDeep() throws IOException {
+    createTestDirectoryTree();
+
+    Collection<Path> paths = traverseTree(topDir,
+        Predicates.alwaysTrue());
+    assertThat(paths).containsExactly(aDir,
+        file3,
+        innerDir,
+        link1,
+        file1,
+        file2,
+        dirLink);
+  }
+
+  @Test
+  public void testTraverseTreeLinkDir() throws IOException {
+    // Use a new little tree for this test:
+    //  top-dir/
+    //    dir-link2 => linked-dir
+    //  linked-dir/
+    //    file
+    topDir = fileSystem.getPath("/top-dir");
+    Path dirLink2 = fileSystem.getPath("/top-dir/dir-link2");
+    Path linkedDir = fileSystem.getPath("/linked-dir");
+    Path linkedDirFile = fileSystem.getPath("/top-dir/dir-link2/file");
+
+    topDir.createDirectory();
+    linkedDir.createDirectory();
+    dirLink2.createSymbolicLink(linkedDir);  // simple symlink
+    FileSystemUtils.createEmptyFile(linkedDirFile);  // created through the link
+
+    // traverseTree doesn't follow links:
+    Collection<Path> paths = traverseTree(topDir, Predicates.alwaysTrue());
+    assertThat(paths).containsExactly(dirLink2);
+
+    paths = traverseTree(linkedDir, Predicates.alwaysTrue());
+    assertThat(paths).containsExactly(fileSystem.getPath("/linked-dir/file"));
+  }
+
+  @Test
+  public void testDeleteTreeCommandDeletesTree() throws IOException {
+    createTestDirectoryTree();
+    Path toDelete = topDir;
+    deleteTree(toDelete);
+
+    assertTrue(file4.exists());
+    assertFalse(topDir.exists());
+    assertFalse(file1.exists());
+    assertFalse(file2.exists());
+    assertFalse(aDir.exists());
+    assertFalse(file3.exists());
+  }
+
+  @Test
+  public void testDeleteTreeCommandsDeletesUnreadableDirectories() throws IOException {
+    createTestDirectoryTree();
+    Path toDelete = topDir;
+
+    try {
+      aDir.setReadable(false);
+    } catch (UnsupportedOperationException e) {
+      // For file systems that do not support setting readable attribute to
+      // false, this test is simply skipped.
+
+      return;
+    }
+
+    deleteTree(toDelete);
+    assertFalse(topDir.exists());
+    assertFalse(aDir.exists());
+
+  }
+
+  @Test
+  public void testDeleteTreeCommandDoesNotFollowLinksOut() throws IOException {
+    createTestDirectoryTree();
+    Path toDelete = topDir;
+    Path outboundLink = fileSystem.getPath("/top-dir/outbound-link");
+    outboundLink.createSymbolicLink(file4);
+
+    deleteTree(toDelete);
+
+    assertTrue(file4.exists());
+    assertFalse(topDir.exists());
+    assertFalse(file1.exists());
+    assertFalse(file2.exists());
+    assertFalse(aDir.exists());
+    assertFalse(file3.exists());
+  }
+
+  @Test
+  public void testDeleteTreesBelowNotPrefixed() throws IOException {
+    createTestDirectoryTree();
+    deleteTreesBelowNotPrefixed(topDir, new String[] { "file-"});
+    assertTrue(file1.exists());
+    assertTrue(file2.exists());
+    assertFalse(aDir.exists());
+  }
+
+  @Test
+  public void testCreateDirectories() throws IOException {
+    Path mainPath = fileSystem.getPath("/some/where/deep/in/the/hierarchy");
+    assertTrue(createDirectoryAndParents(mainPath));
+    assertTrue(mainPath.exists());
+    assertFalse(createDirectoryAndParents(mainPath));
+  }
+
+  @Test
+  public void testCreateDirectoriesWhenAncestorIsFile() throws IOException {
+    Path somewhereDeepIn = fileSystem.getPath("/somewhere/deep/in");
+    assertTrue(createDirectoryAndParents(somewhereDeepIn.getParentDirectory()));
+    FileSystemUtils.createEmptyFile(somewhereDeepIn);
+    Path theHierarchy = somewhereDeepIn.getChild("the-hierarchy");
+    try {
+      createDirectoryAndParents(theHierarchy);
+      fail();
+    } catch (IOException e) {
+      assertEquals("/somewhere/deep/in (Not a directory)", e.getMessage());
+    }
+  }
+
+  @Test
+  public void testCreateDirectoriesWhenSymlinkToDir() throws IOException {
+    Path somewhereDeepIn = fileSystem.getPath("/somewhere/deep/in");
+    assertTrue(createDirectoryAndParents(somewhereDeepIn));
+    Path realDir = fileSystem.getPath("/real/dir");
+    assertTrue(createDirectoryAndParents(realDir));
+
+    Path theHierarchy = somewhereDeepIn.getChild("the-hierarchy");
+    theHierarchy.createSymbolicLink(realDir);
+
+    assertFalse(createDirectoryAndParents(theHierarchy));
+  }
+
+  @Test
+  public void testCreateDirectoriesWhenSymlinkEmbedded() throws IOException {
+    Path somewhereDeepIn = fileSystem.getPath("/somewhere/deep/in");
+    assertTrue(createDirectoryAndParents(somewhereDeepIn));
+    Path realDir = fileSystem.getPath("/real/dir");
+    assertTrue(createDirectoryAndParents(realDir));
+
+    Path the = somewhereDeepIn.getChild("the");
+    the.createSymbolicLink(realDir);
+
+    Path theHierarchy = somewhereDeepIn.getChild("hierarchy");
+    assertTrue(createDirectoryAndParents(theHierarchy));
+  }
+
+  PathFragment createPkg(Path rootA, Path rootB, String pkg) throws IOException {
+    if (rootA != null) {
+      createDirectoryAndParents(rootA.getRelative(pkg));
+      FileSystemUtils.createEmptyFile(rootA.getRelative(pkg).getChild("file"));
+    }
+    if (rootB != null) {
+      createDirectoryAndParents(rootB.getRelative(pkg));
+      FileSystemUtils.createEmptyFile(rootB.getRelative(pkg).getChild("file"));
+    }
+    return new PathFragment(pkg);
+  }
+
+  void assertLinksTo(Path fromRoot, Path toRoot, String relpart) throws IOException {
+    assertTrue(fromRoot.getRelative(relpart).isSymbolicLink());
+    assertEquals(toRoot.getRelative(relpart).asFragment(),
+                 fromRoot.getRelative(relpart).readSymbolicLink());
+  }
+
+  void assertIsDir(Path root, String relpart) {
+    assertTrue(root.getRelative(relpart).isDirectory(Symlinks.NOFOLLOW));
+  }
+
+  void dumpTree(Path root, PrintStream out) throws IOException {
+    out.println("\n" + root);
+    for (Path p : FileSystemUtils.traverseTree(root, Predicates.alwaysTrue())) {
+      if (p.isDirectory(Symlinks.NOFOLLOW)) {
+        out.println("  " + p + "/");
+      } else if (p.isSymbolicLink()) {
+        out.println("  " + p + " => " + p.readSymbolicLink());
+      } else {
+        out.println("  " + p + " [" + p.resolveSymbolicLinks() + "]");
+      }
+    }
+  }
+
+  @Test
+  public void testPlantLinkForest() throws IOException {
+    Path rootA = fileSystem.getPath("/A");
+    Path rootB = fileSystem.getPath("/B");
+
+    ImmutableMap<PathFragment, Path> packageRootMap = ImmutableMap.<PathFragment, Path>builder()
+        .put(createPkg(rootA, rootB, "pkgA"), rootA)
+        .put(createPkg(rootA, rootB, "dir1/pkgA"), rootA)
+        .put(createPkg(rootA, rootB, "dir1/pkgB"), rootB)
+        .put(createPkg(rootA, rootB, "dir2/pkg"), rootA)
+        .put(createPkg(rootA, rootB, "dir2/pkg/pkg"), rootB)
+        .put(createPkg(rootA, rootB, "pkgB"), rootB)
+        .put(createPkg(rootA, rootB, "pkgB/dir/pkg"), rootA)
+        .put(createPkg(rootA, rootB, "pkgB/pkg"), rootA)
+        .put(createPkg(rootA, rootB, "pkgB/pkg/pkg"), rootA)
+        .build();
+    createPkg(rootA, rootB, "pkgB/dir");  // create a file in there
+
+    //dumpTree(rootA, System.err);
+    //dumpTree(rootB, System.err);
+
+    Path linkRoot = fileSystem.getPath("/linkRoot");
+    createDirectoryAndParents(linkRoot);
+    plantLinkForest(packageRootMap, linkRoot);
+
+    //dumpTree(linkRoot, System.err);
+
+    assertLinksTo(linkRoot, rootA, "pkgA");
+    assertIsDir(linkRoot, "dir1");
+    assertLinksTo(linkRoot, rootA, "dir1/pkgA");
+    assertLinksTo(linkRoot, rootB, "dir1/pkgB");
+    assertIsDir(linkRoot, "dir2");
+    assertIsDir(linkRoot, "dir2/pkg");
+    assertLinksTo(linkRoot, rootA, "dir2/pkg/file");
+    assertLinksTo(linkRoot, rootB, "dir2/pkg/pkg");
+    assertIsDir(linkRoot, "pkgB");
+    assertIsDir(linkRoot, "pkgB/dir");
+    assertLinksTo(linkRoot, rootB, "pkgB/dir/file");
+    assertLinksTo(linkRoot, rootA, "pkgB/dir/pkg");
+    assertLinksTo(linkRoot, rootA, "pkgB/pkg");
+  }
+
+  @Test
+  public void testWriteIsoLatin1() throws Exception {
+    Path file = fileSystem.getPath("/does/not/exist/yet.txt");
+    FileSystemUtils.writeIsoLatin1(file, "Line 1", "Line 2", "Line 3");
+    String expected = "Line 1\nLine 2\nLine 3\n";
+    String actual = new String(FileSystemUtils.readContentAsLatin1(file));
+    assertEquals(expected, actual);
+  }
+
+  @Test
+  public void testWriteLinesAs() throws Exception {
+    Path file = fileSystem.getPath("/does/not/exist/yet.txt");
+    FileSystemUtils.writeLinesAs(file, UTF_8, "\u00F6"); // an oe umlaut
+    byte[] expected = new byte[] {(byte) 0xC3, (byte) 0xB6, 0x0A};//"\u00F6\n";
+    byte[] actual = FileSystemUtils.readContent(file);
+    assertArrayEquals(expected, actual);
+  }
+
+  @Test
+  public void testGetFileSystem() throws Exception {
+    Path mountTable = fileSystem.getPath("/proc/mounts");
+    FileSystemUtils.writeIsoLatin1(mountTable,
+        "/dev/sda1 / ext2 blah 0 0",
+        "/dev/mapper/_dev_sda6 /usr/local/google ext3 blah 0 0",
+        "devshm /dev/shm tmpfs blah 0 0",
+        "/dev/fuse /fuse/mnt fuse blah 0 0",
+        "mtvhome22.nfs:/vol/mtvhome22/johndoe /home/johndoe nfs blah 0 0",
+        "/dev/foo /foo dummy_foo blah 0 0",
+        "/dev/foobar /foobar dummy_foobar blah 0 0",
+        "proc proc proc rw,noexec,nosuid,nodev 0 0");
+    Path path = fileSystem.getPath("/usr/local/google/_blaze");
+    FileSystemUtils.createDirectoryAndParents(path);
+    assertEquals("ext3", FileSystemUtils.getFileSystem(path));
+
+    // Should match the root "/"
+    path = fileSystem.getPath("/usr/local/tmp");
+    FileSystemUtils.createDirectoryAndParents(path);
+    assertEquals("ext2", FileSystemUtils.getFileSystem(path));
+
+    // Make sure we don't consider /foobar matches /foo
+    path = fileSystem.getPath("/foo");
+    FileSystemUtils.createDirectoryAndParents(path);
+    assertEquals("dummy_foo", FileSystemUtils.getFileSystem(path));
+    path = fileSystem.getPath("/foobar");
+    FileSystemUtils.createDirectoryAndParents(path);
+    assertEquals("dummy_foobar", FileSystemUtils.getFileSystem(path));
+
+    path = fileSystem.getPath("/dev/shm/blaze");
+    FileSystemUtils.createDirectoryAndParents(path);
+    assertEquals("tmpfs", FileSystemUtils.getFileSystem(path));
+
+    Path fusePath = fileSystem.getPath("/fuse/mnt/tmp");
+    FileSystemUtils.createDirectoryAndParents(fusePath);
+    assertEquals("fuse", FileSystemUtils.getFileSystem(fusePath));
+
+    // Create a symlink and make sure it gives the file system of the symlink target.
+    path = fileSystem.getPath("/usr/local/google/_blaze/out");
+    path.createSymbolicLink(fusePath);
+    assertEquals("fuse", FileSystemUtils.getFileSystem(path));
+
+    // Non existent path should return "unknown"
+    path = fileSystem.getPath("/does/not/exist");
+    assertEquals("unknown", FileSystemUtils.getFileSystem(path));
+  }
+
+  @Test
+  public void testStartsWithAnySuccess() throws Exception {
+    PathFragment a = new PathFragment("a");
+    assertTrue(FileSystemUtils.startsWithAny(a,
+        Arrays.asList(new PathFragment("b"), new PathFragment("a"))));
+  }
+
+  @Test
+  public void testStartsWithAnyNotFound() throws Exception {
+    PathFragment a = new PathFragment("a");
+    assertFalse(FileSystemUtils.startsWithAny(a,
+        Arrays.asList(new PathFragment("b"), new PathFragment("c"))));
+  }
+
+  @Test
+  public void testIterateLines() throws Exception {
+    Path file = fileSystem.getPath("/test.txt");
+    FileSystemUtils.writeContent(file, ISO_8859_1, "a\nb");
+    assertEquals(Arrays.asList("a", "b"),
+        Lists.newArrayList(FileSystemUtils.iterateLinesAsLatin1(file)));
+
+    FileSystemUtils.writeContent(file, ISO_8859_1, "a\rb");
+    assertEquals(Arrays.asList("a", "b"),
+        Lists.newArrayList(FileSystemUtils.iterateLinesAsLatin1(file)));
+
+    FileSystemUtils.writeContent(file, ISO_8859_1, "a\r\nb");
+    assertEquals(Arrays.asList("a", "b"),
+        Lists.newArrayList(FileSystemUtils.iterateLinesAsLatin1(file)));
+  }
+
+  @Test
+  public void testEnsureSymbolicLinkDoesNotMakeUnnecessaryChanges() throws Exception {
+    PathFragment target = new PathFragment("/b");
+    Path file = fileSystem.getPath("/a");
+    file.createSymbolicLink(target);
+    long prevTimeMillis = clock.currentTimeMillis();
+    clock.advanceMillis(1000);
+    FileSystemUtils.ensureSymbolicLink(file, target);
+    long timestamp = file.getLastModifiedTime(Symlinks.NOFOLLOW);
+    assertTrue(timestamp == prevTimeMillis);
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/FileSystemsTest.java b/src/test/java/com/google/devtools/build/lib/vfs/FileSystemsTest.java
new file mode 100644
index 0000000..88a000f
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/vfs/FileSystemsTest.java
@@ -0,0 +1,48 @@
+// Copyright 2014 Google Inc. 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.vfs;
+
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertSame;
+
+import com.google.devtools.build.lib.vfs.util.FileSystems;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * This class handles the tests for the FileSystems class.
+ */
+@RunWith(JUnit4.class)
+public class FileSystemsTest {
+
+  @Test
+  public void testFileSystemsCreatesOnlyOneDefaultNative() {
+    assertSame(FileSystems.initDefaultAsNative(),
+               FileSystems.initDefaultAsNative());
+  }
+
+  @Test
+  public void testFileSystemsCreatesOnlyOneDefaultJavaIo() {
+    assertSame(FileSystems.initDefaultAsJavaIo(),
+               FileSystems.initDefaultAsJavaIo());
+  }
+
+  @Test
+  public void testFileSystemsCanSwitchDefaults() {
+    assertNotSame(FileSystems.initDefaultAsNative(),
+                  FileSystems.initDefaultAsJavaIo());
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/GlobTest.java b/src/test/java/com/google/devtools/build/lib/vfs/GlobTest.java
new file mode 100644
index 0000000..37b7dc4
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/vfs/GlobTest.java
@@ -0,0 +1,417 @@
+// Copyright 2014 Google Inc. 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.vfs;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.base.Predicate;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Ordering;
+import com.google.devtools.build.lib.testutil.MoreAsserts;
+import com.google.devtools.build.lib.testutil.TestUtils;
+import com.google.devtools.build.lib.vfs.inmemoryfs.InMemoryFileSystem;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+
+/**
+ * Tests {@link UnixGlob}
+ */
+@RunWith(JUnit4.class)
+public class GlobTest {
+
+  private Path tmpPath;
+  private FileSystem fs;
+  @Before
+  public void setUp() throws Exception {
+    fs = new InMemoryFileSystem();
+    tmpPath = fs.getPath("/globtmp");
+    for (String dir : ImmutableList.of("foo/bar/wiz",
+                         "foo/barnacle/wiz",
+                         "food/barnacle/wiz",
+                         "fool/barnacle/wiz")) {
+      FileSystemUtils.createDirectoryAndParents(tmpPath.getRelative(dir));
+    }
+    FileSystemUtils.createEmptyFile(tmpPath.getRelative("foo/bar/wiz/file"));
+  }
+
+  @Test
+  public void testQuestionMarkMatch() throws Exception {
+    assertGlobMatches("foo?", /* => */"food", "fool");
+  }
+
+  @Test
+  public void testQuestionMarkNoMatch() throws Exception {
+    assertGlobMatches("food/bar?" /* => nothing */);
+  }
+
+  @Test
+  public void testStartsWithStar() throws Exception {
+    assertGlobMatches("*oo", /* => */"foo");
+  }
+
+  @Test
+  public void testStartsWithStarWithMiddleStar() throws Exception {
+    assertGlobMatches("*f*o", /* => */"foo");
+  }
+
+  @Test
+  public void testEndsWithStar() throws Exception {
+    assertGlobMatches("foo*", /* => */"foo", "food", "fool");
+  }
+
+  @Test
+  public void testEndsWithStarWithMiddleStar() throws Exception {
+    assertGlobMatches("f*oo*", /* => */"foo", "food", "fool");
+  }
+
+  @Test
+  public void testMiddleStar() throws Exception {
+    assertGlobMatches("f*o", /* => */"foo");
+  }
+
+  @Test
+  public void testTwoMiddleStars() throws Exception {
+    assertGlobMatches("f*o*o", /* => */"foo");
+  }
+
+  @Test
+  public void testSingleStarPatternWithNamedChild() throws Exception {
+    assertGlobMatches("*/bar", /* => */"foo/bar");
+  }
+
+  @Test
+  public void testSingleStarPatternWithChildGlob() throws Exception {
+    assertGlobMatches("*/bar*", /* => */
+        "foo/bar", "foo/barnacle", "food/barnacle", "fool/barnacle");
+  }
+
+  @Test
+  public void testSingleStarAsChildGlob() throws Exception {
+    assertGlobMatches("foo/*/wiz", /* => */"foo/bar/wiz", "foo/barnacle/wiz");
+  }
+
+  @Test
+  public void testNoAsteriskAndFilesDontExist() throws Exception {
+    // Note un-UNIX like semantics:
+    assertGlobMatches("ceci/n'est/pas/une/globbe" /* => nothing */);
+  }
+
+  @Test
+  public void testSingleAsteriskUnderNonexistentDirectory() throws Exception {
+    // Note un-UNIX like semantics:
+    assertGlobMatches("not-there/*" /* => nothing */);
+  }
+
+  @Test
+  public void testGlobWithNonExistentBase() throws Exception {
+    Collection<Path> globResult = UnixGlob.forPath(fs.getPath("/does/not/exist"))
+        .addPattern("*.txt")
+        .globInterruptible();
+    assertEquals(0, globResult.size());
+  }
+
+  @Test
+  public void testGlobUnderFile() throws Exception {
+    assertGlobMatches("foo/bar/wiz/file/*" /* => nothing */);
+  }
+
+  @Test
+  public void testSingleFileExclude() throws Exception {
+    assertGlobWithExcludeMatches("*", "food", "foo", "fool");
+  }
+
+  @Test
+  public void testExcludeAll() throws Exception {
+    assertGlobWithExcludeMatches("*", "*");
+  }
+
+  @Test
+  public void testExcludeAllButNoMatches() throws Exception {
+    assertGlobWithExcludeMatches("not-there", "*");
+  }
+
+  @Test
+  public void testSingleFileExcludeDoesntMatch() throws Exception {
+    assertGlobWithExcludeMatches("food", "foo", "food");
+  }
+
+  @Test
+  public void testSingleFileExcludeForDirectoryWithChildGlob()
+      throws Exception {
+    assertGlobWithExcludeMatches("foo/*", "foo", "foo/bar", "foo/barnacle");
+  }
+
+  @Test
+  public void testChildGlobWithChildExclude()
+      throws Exception {
+    assertGlobWithExcludeMatches("foo/*", "foo/*");
+    assertGlobWithExcludeMatches("foo/bar", "foo/*");
+    assertGlobWithExcludeMatches("foo/bar", "foo/bar");
+    assertGlobWithExcludeMatches("foo/bar", "*/bar");
+    assertGlobWithExcludeMatches("foo/bar", "*/*");
+    assertGlobWithExcludeMatches("foo/bar/wiz", "*/*/*");
+    assertGlobWithExcludeMatches("foo/bar/wiz", "foo/*/*");
+    assertGlobWithExcludeMatches("foo/bar/wiz", "foo/bar/*");
+    assertGlobWithExcludeMatches("foo/bar/wiz", "foo/bar/wiz");
+    assertGlobWithExcludeMatches("foo/bar/wiz", "*/bar/wiz");
+    assertGlobWithExcludeMatches("foo/bar/wiz", "*/*/wiz");
+    assertGlobWithExcludeMatches("foo/bar/wiz", "foo/*/wiz");
+  }
+
+  private void assertGlobMatches(String pattern, String... expecteds)
+      throws Exception {
+    assertGlobWithExcludesMatches(
+        Collections.singleton(pattern), Collections.<String>emptyList(),
+        expecteds);
+  }
+
+  private void assertGlobMatches(Collection<String> pattern,
+                                 String... expecteds)
+      throws Exception {
+    assertGlobWithExcludesMatches(pattern, Collections.<String>emptyList(),
+        expecteds);
+  }
+
+  private void assertGlobWithExcludeMatches(String pattern, String exclude,
+                                            String... expecteds)
+      throws Exception {
+    assertGlobWithExcludesMatches(
+        Collections.singleton(pattern), Collections.singleton(exclude),
+        expecteds);
+  }
+
+  private void assertGlobWithExcludesMatches(Collection<String> pattern,
+                                             Collection<String> excludes,
+                                             String... expecteds)
+      throws Exception {
+    MoreAsserts.assertSameContents(resolvePaths(expecteds),
+        new UnixGlob.Builder(tmpPath)
+            .addPatterns(pattern)
+            .addExcludes(excludes)
+            .globInterruptible());
+  }
+
+  private Set<Path> resolvePaths(String... relativePaths) {
+    Set<Path> expectedFiles = new HashSet<>();
+    for (String expected : relativePaths) {
+      Path file = expected.equals(".")
+          ? tmpPath
+          : tmpPath.getRelative(expected);
+      expectedFiles.add(file);
+    }
+    return expectedFiles;
+  }
+
+  @Test
+  public void testGlobWithoutWildcardsDoesNotCallReaddir() throws Exception {
+    UnixGlob.FilesystemCalls syscalls = new UnixGlob.FilesystemCalls() {
+      @Override
+      public FileStatus statNullable(Path path, Symlinks symlinks) {
+        return UnixGlob.DEFAULT_SYSCALLS.statNullable(path, symlinks);
+      }
+
+      @Override
+      public Collection<Dirent> readdir(Path path, Symlinks symlinks) {
+        throw new IllegalStateException();
+      }
+    };
+
+    MoreAsserts.assertSameContents(ImmutableList.of(tmpPath.getRelative("foo/bar/wiz/file")),
+        new UnixGlob.Builder(tmpPath)
+            .addPattern("foo/bar/wiz/file")
+            .setFilesystemCalls(new AtomicReference<>(syscalls))
+            .glob());
+  }
+
+  @Test
+  public void testIllegalPatterns() throws Exception {
+    assertIllegalPattern("(illegal) pattern");
+    assertIllegalPattern("[illegal pattern");
+    assertIllegalPattern("}illegal pattern");
+    assertIllegalPattern("foo**bar");
+    assertIllegalPattern("");
+    assertIllegalPattern(".");
+    assertIllegalPattern("/foo");
+    assertIllegalPattern("./foo");
+    assertIllegalPattern("foo/");
+    assertIllegalPattern("foo/./bar");
+    assertIllegalPattern("../foo/bar");
+    assertIllegalPattern("foo//bar");
+  }
+
+  /**
+   * Tests that globs can contain Java regular expression special characters
+   */
+  @Test
+  public void testSpecialRegexCharacter() throws Exception {
+    Path tmpPath2 = fs.getPath("/globtmp2");
+    FileSystemUtils.createDirectoryAndParents(tmpPath2);
+    Path aDotB = tmpPath2.getChild("a.b");
+    FileSystemUtils.createEmptyFile(aDotB);
+    FileSystemUtils.createEmptyFile(tmpPath2.getChild("aab"));
+    // Note: this contains two asterisks because otherwise a RE is not built,
+    // as an optimization.
+    assertThat(UnixGlob.forPath(tmpPath2).addPattern("*a.b*").globInterruptible()).containsExactly(
+        aDotB);
+  }
+
+  @Test
+  public void testMatchesCallWithNoCache() {
+    assertTrue(UnixGlob.matches("*a*b", "CaCb", null));
+  }
+
+  @Test
+  public void testMultiplePatterns() throws Exception {
+    assertGlobMatches(Lists.newArrayList("foo", "fool"), "foo", "fool");
+  }
+
+  @Test
+  public void testMultiplePatternsWithExcludes() throws Exception {
+    assertGlobWithExcludesMatches(Lists.newArrayList("foo", "foo?"),
+        Lists.newArrayList("fool"), "foo", "food");
+  }
+
+  @Test
+  public void testMultiplePatternsWithOverlap() throws Exception {
+    assertGlobMatchesAnyOrder(Lists.newArrayList("food", "foo?"),
+                              "food", "fool");
+    assertGlobMatchesAnyOrder(Lists.newArrayList("food", "?ood", "f??d"),
+                              "food");
+    assertThat(resolvePaths("food", "fool", "foo")).containsExactlyElementsIn(
+        new UnixGlob.Builder(tmpPath).addPatterns("food", "xxx", "*").glob());
+
+  }
+
+  private void assertGlobMatchesAnyOrder(ArrayList<String> patterns,
+                                         String... paths) throws Exception {
+    assertThat(resolvePaths(paths)).containsExactlyElementsIn(
+        new UnixGlob.Builder(tmpPath).addPatterns(patterns).globInterruptible());
+  }
+
+  /**
+   * Tests that a glob returns files in sorted order.
+   */
+  @Test
+  public void testGlobEntriesAreSorted() throws Exception {
+    Collection<Path> directoryEntries = tmpPath.getDirectoryEntries();
+    List<Path> globResult = new UnixGlob.Builder(tmpPath)
+        .addPattern("*")
+        .setExcludeDirectories(false)
+        .globInterruptible();
+    assertThat(Ordering.natural().sortedCopy(directoryEntries)).containsExactlyElementsIn(
+        globResult).inOrder();
+  }
+
+  private void assertIllegalPattern(String pattern) throws Exception {
+    try {
+      new UnixGlob.Builder(tmpPath)
+          .addPattern(pattern)
+          .globInterruptible();
+      fail();
+    } catch (IllegalArgumentException e) {
+      MoreAsserts.assertContainsRegex("in glob pattern", e.getMessage());
+    }
+  }
+
+  @Test
+  public void testHiddenFiles() throws Exception {
+    for (String dir : ImmutableList.of(".hidden", "..also.hidden", "not.hidden")) {
+      FileSystemUtils.createDirectoryAndParents(tmpPath.getRelative(dir));
+    }
+    // Note that these are not in the result: ".", ".."
+    assertGlobMatches("*", "not.hidden", "foo", "fool", "food", ".hidden", "..also.hidden");
+    assertGlobMatches("*.hidden", "not.hidden");
+  }
+
+  @Test
+  public void testCheckCanBeInterrupted() throws Exception {
+    final Thread mainThread = Thread.currentThread();
+    final ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(10);
+
+    Predicate<Path> interrupterPredicate = new Predicate<Path>() {
+      @Override
+      public boolean apply(Path input) {
+        mainThread.interrupt();
+        return true;
+      }
+    };
+
+    try {
+      new UnixGlob.Builder(tmpPath)
+          .addPattern("**")
+          .setDirectoryFilter(interrupterPredicate)
+          .setThreadPool(executor)
+          .globInterruptible();
+      fail();  // Should have received InterruptedException
+    } catch (InterruptedException e) {
+      // good
+    }
+
+    assertFalse(executor.isShutdown());
+    executor.shutdown();
+    assertTrue(executor.awaitTermination(TestUtils.WAIT_TIMEOUT_SECONDS, TimeUnit.SECONDS));
+  }
+
+  @Test
+  public void testCheckCannotBeInterrupted() throws Exception {
+    final Thread mainThread = Thread.currentThread();
+    final ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(10);
+    final AtomicBoolean sentInterrupt = new AtomicBoolean(false);
+
+    Predicate<Path> interrupterPredicate = new Predicate<Path>() {
+      @Override
+      public boolean apply(Path input) {
+        if (!sentInterrupt.getAndSet(true)) {
+          mainThread.interrupt();
+        }
+        return true;
+      }
+    };
+
+    List<Path> result = new UnixGlob.Builder(tmpPath)
+        .addPatterns("**", "*")
+        .setDirectoryFilter(interrupterPredicate).setThreadPool(executor).glob();
+
+    // In the non-interruptible case, the interrupt bit should be set, but the
+    // glob should return the correct set of full results.
+    assertTrue(Thread.interrupted());
+    MoreAsserts.assertSameContents(resolvePaths(".", "foo", "foo/bar", "foo/bar/wiz",
+        "foo/bar/wiz/file", "foo/barnacle", "foo/barnacle/wiz", "food", "food/barnacle",
+        "food/barnacle/wiz", "fool", "fool/barnacle", "fool/barnacle/wiz"), result);
+
+    assertFalse(executor.isShutdown());
+    executor.shutdown();
+    assertTrue(executor.awaitTermination(TestUtils.WAIT_TIMEOUT_SECONDS, TimeUnit.SECONDS));
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/JavaIoFileSystemTest.java b/src/test/java/com/google/devtools/build/lib/vfs/JavaIoFileSystemTest.java
new file mode 100644
index 0000000..fdb6283
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/vfs/JavaIoFileSystemTest.java
@@ -0,0 +1,40 @@
+// Copyright 2014 Google Inc. 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.vfs;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests for the {@link JavaIoFileSystem}. That file system by itself is not
+ * capable of creating symlinks; use the unix one to create them, so that the
+ * test can check that the file system handles their existence correctly.
+ */
+@RunWith(JUnit4.class)
+public class JavaIoFileSystemTest extends SymlinkAwareFileSystemTest {
+
+  @Override
+  public FileSystem getFreshFileSystem() {
+    return new JavaIoFileSystem();
+  }
+
+  // The tests are just inherited from the FileSystemTest
+
+  // JavaIoFileSystem incorrectly throws a FileNotFoundException for all IO errors. This means that
+  // statIfFound incorrectly suppresses those errors.
+  @Override
+  @Test
+  public void testBadPermissionsThrowsExceptionOnStatIfFound() {}
+}
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/ModifiedFileSetTest.java b/src/test/java/com/google/devtools/build/lib/vfs/ModifiedFileSetTest.java
new file mode 100644
index 0000000..96001df
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/vfs/ModifiedFileSetTest.java
@@ -0,0 +1,54 @@
+// Copyright 2014 Google Inc. 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.vfs;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.testing.EqualsTester;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests for {@link ModifiedFileSet}.
+ */
+@RunWith(JUnit4.class)
+public class ModifiedFileSetTest {
+
+  @Test
+  public void testHashCodeAndEqualsContract() throws Exception {
+    PathFragment fragA = new PathFragment("a");
+    PathFragment fragB = new PathFragment("b");
+
+    ModifiedFileSet empty1 = ModifiedFileSet.NOTHING_MODIFIED;
+    ModifiedFileSet empty2 = ModifiedFileSet.builder().build();
+    ModifiedFileSet empty3 = ModifiedFileSet.builder().modifyAll(
+        ImmutableList.<PathFragment>of()).build();
+
+    ModifiedFileSet nonEmpty1 = ModifiedFileSet.builder().modifyAll(
+        ImmutableList.of(fragA, fragB)).build();
+    ModifiedFileSet nonEmpty2 = ModifiedFileSet.builder().modifyAll(
+        ImmutableList.of(fragB, fragA)).build();
+    ModifiedFileSet nonEmpty3 = ModifiedFileSet.builder().modify(fragA).modify(fragB).build();
+    ModifiedFileSet nonEmpty4 = ModifiedFileSet.builder().modify(fragB).modify(fragA).build();
+
+    ModifiedFileSet everythingModified = ModifiedFileSet.EVERYTHING_MODIFIED;
+
+    new EqualsTester()
+        .addEqualityGroup(empty1, empty2, empty3)
+        .addEqualityGroup(nonEmpty1, nonEmpty2, nonEmpty3, nonEmpty4)
+        .addEqualityGroup(everythingModified)
+        .testEquals();
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/PathFragmentTest.java b/src/test/java/com/google/devtools/build/lib/vfs/PathFragmentTest.java
new file mode 100644
index 0000000..9ab9bfa
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/vfs/PathFragmentTest.java
@@ -0,0 +1,481 @@
+// Copyright 2014 Google Inc. 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.vfs;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
+import com.google.common.testing.EqualsTester;
+import com.google.devtools.build.lib.testutil.MoreAsserts;
+import com.google.devtools.build.lib.testutil.TestUtils;
+import com.google.devtools.build.lib.vfs.inmemoryfs.InMemoryFileSystem;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.File;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * This class tests the functionality of the PathFragment.
+ */
+@RunWith(JUnit4.class)
+public class PathFragmentTest {
+  @Test
+  public void testMergeFourPathsWithAbsolute() {
+    assertEquals(new PathFragment("x/y/z/a/b/c/d/e"),
+        new PathFragment(new PathFragment("x/y"), new PathFragment("z/a"),
+            new PathFragment("/b/c"), // absolute!
+            new PathFragment("d/e")));
+  }
+
+  @Test
+  public void testEqualsAndHashCode() {
+    InMemoryFileSystem filesystem = new InMemoryFileSystem();
+
+    new EqualsTester()
+        .addEqualityGroup(new PathFragment("../relative/path"),
+                          new PathFragment("../relative/path"),
+                          new PathFragment(new File("../relative/path")))
+        .addEqualityGroup(new PathFragment("something/else"))
+        .addEqualityGroup(new PathFragment("/something/else"))
+        .addEqualityGroup(new PathFragment("/"),
+                          new PathFragment("//////"))
+        .addEqualityGroup(new PathFragment(""))
+        .addEqualityGroup(filesystem.getRootDirectory())  // A Path object.
+        .testEquals();
+  }
+
+  @Test
+  public void testHashCodeCache() {
+    PathFragment relativePath = new PathFragment("../relative/path");
+    PathFragment rootPath = new PathFragment("/");
+
+    int oldResult = relativePath.hashCode();
+    int rootResult = rootPath.hashCode();
+    assertEquals(oldResult, relativePath.hashCode());
+    assertEquals(rootResult, rootPath.hashCode());
+  }
+
+  private void checkRelativeTo(String path, String base) {
+    PathFragment relative = new PathFragment(path).relativeTo(base);
+    assertEquals(new PathFragment(path), new PathFragment(base).getRelative(relative).normalize());
+  }
+
+  @Test
+  public void testRelativeTo() {
+    assertPath("bar/baz", new PathFragment("foo/bar/baz").relativeTo("foo"));
+    assertPath("bar/baz", new PathFragment("/foo/bar/baz").relativeTo("/foo"));
+    assertPath("baz", new PathFragment("foo/bar/baz").relativeTo("foo/bar"));
+    assertPath("baz", new PathFragment("/foo/bar/baz").relativeTo("/foo/bar"));
+    assertPath("foo", new PathFragment("/foo").relativeTo("/"));
+    assertPath("foo", new PathFragment("foo").relativeTo(""));
+    assertPath("foo/bar", new PathFragment("foo/bar").relativeTo(""));
+
+    checkRelativeTo("foo/bar/baz", "foo");
+    checkRelativeTo("/foo/bar/baz", "/foo");
+    checkRelativeTo("foo/bar/baz", "foo/bar");
+    checkRelativeTo("/foo/bar/baz", "/foo/bar");
+    checkRelativeTo("/foo", "/");
+    checkRelativeTo("foo", "");
+    checkRelativeTo("foo/bar", "");
+  }
+
+  @Test
+  public void testIsAbsolute() {
+    assertTrue(new PathFragment("/absolute/test").isAbsolute());
+    assertFalse(new PathFragment("relative/test").isAbsolute());
+    assertTrue(new PathFragment(new File("/absolute/test")).isAbsolute());
+    assertFalse(new PathFragment(new File("relative/test")).isAbsolute());
+  }
+
+  @Test
+  public void testIsNormalized() {
+    assertTrue(new PathFragment("/absolute/path").isNormalized());
+    assertTrue(new PathFragment("some//path").isNormalized());
+    assertFalse(new PathFragment("some/./path").isNormalized());
+    assertFalse(new PathFragment("../some/path").isNormalized());
+    assertFalse(new PathFragment("some/other/../path").isNormalized());
+    assertTrue(new PathFragment("some/other//tricky..path..").isNormalized());
+    assertTrue(new PathFragment("/some/other//tricky..path..").isNormalized());
+  }
+
+  @Test
+  public void testRootNodeReturnsRootString() {
+    PathFragment rootFragment = new PathFragment("/");
+    assertEquals("/", rootFragment.getPathString());
+  }
+
+  @Test
+  public void testGetPathFragmentDoesNotNormalize() {
+    String nonCanonicalPath = "/a/weird/noncanonical/../path/.";
+    assertEquals(nonCanonicalPath,
+        new PathFragment(nonCanonicalPath).getPathString());
+  }
+
+  @Test
+  public void testGetRelative() {
+    assertEquals("a/b", new PathFragment("a").getRelative("b").getPathString());
+    assertEquals("a/b/c/d", new PathFragment("a/b").getRelative("c/d").getPathString());
+    assertEquals("/a/b", new PathFragment("c/d").getRelative("/a/b").getPathString());
+    assertEquals("a", new PathFragment("a").getRelative("").getPathString());
+    assertEquals("/", new PathFragment("/").getRelative("").getPathString());
+  }
+
+  @Test
+  public void testGetChildWorks() {
+    PathFragment pf = new PathFragment("../some/path");
+    assertEquals(new PathFragment("../some/path/hi"), pf.getChild("hi"));
+  }
+
+  @Test
+  public void testGetChildRejectsInvalidBaseNames() {
+    PathFragment pf = new PathFragment("../some/path");
+    assertGetChildFails(pf, ".");
+    assertGetChildFails(pf, "..");
+    assertGetChildFails(pf, "x/y");
+    assertGetChildFails(pf, "/y");
+    assertGetChildFails(pf, "y/");
+    assertGetChildFails(pf, "");
+  }
+
+  private void assertGetChildFails(PathFragment pf, String baseName) {
+    try {
+      pf.getChild(baseName);
+      fail();
+    } catch (Exception e) { /* Expected. */ }
+  }
+
+  // Tests after here test the canonicalization
+  private void assertRegular(String expected, String actual) {
+    assertEquals(expected, new PathFragment(actual).getPathString()); // compare string forms
+    assertEquals(new PathFragment(expected), new PathFragment(actual)); // compare fragment forms
+  }
+
+  @Test
+  public void testEmptyPathToEmptyPath() {
+    assertRegular("/", "/");
+    assertRegular("", "");
+  }
+
+  @Test
+  public void testRedundantSlashes() {
+    assertRegular("/", "///");
+    assertRegular("/foo/bar", "/foo///bar");
+    assertRegular("/foo/bar", "////foo//bar");
+  }
+
+  @Test
+  public void testSimpleNameToSimpleName() {
+    assertRegular("/foo", "/foo");
+    assertRegular("foo", "foo");
+  }
+
+  @Test
+  public void testSimplePathToSimplePath() {
+    assertRegular("/foo/bar", "/foo/bar");
+    assertRegular("foo/bar", "foo/bar");
+  }
+
+  @Test
+  public void testStripsTrailingSlash() {
+    assertRegular("/foo/bar", "/foo/bar/");
+  }
+
+  @Test
+  public void testGetParentDirectory() {
+    PathFragment fooBarWiz = new PathFragment("foo/bar/wiz");
+    PathFragment fooBar = new PathFragment("foo/bar");
+    PathFragment foo = new PathFragment("foo");
+    PathFragment empty = new PathFragment("");
+    assertEquals(fooBar, fooBarWiz.getParentDirectory());
+    assertEquals(foo, fooBar.getParentDirectory());
+    assertEquals(empty, foo.getParentDirectory());
+    assertNull(empty.getParentDirectory());
+
+    PathFragment fooBarWizAbs = new PathFragment("/foo/bar/wiz");
+    PathFragment fooBarAbs = new PathFragment("/foo/bar");
+    PathFragment fooAbs = new PathFragment("/foo");
+    PathFragment rootAbs = new PathFragment("/");
+    assertEquals(fooBarAbs, fooBarWizAbs.getParentDirectory());
+    assertEquals(fooAbs, fooBarAbs.getParentDirectory());
+    assertEquals(rootAbs, fooAbs.getParentDirectory());
+    assertNull(rootAbs.getParentDirectory());
+
+    // Note, this is surprising but correct behavior:
+    assertEquals(fooBarAbs,
+                 new PathFragment("/foo/bar/..").getParentDirectory());
+  }
+  
+  @Test
+  public void testSegmentsCount() {
+    assertEquals(2, new PathFragment("foo/bar").segmentCount());
+    assertEquals(2, new PathFragment("/foo/bar").segmentCount());
+    assertEquals(2, new PathFragment("foo//bar").segmentCount());
+    assertEquals(2, new PathFragment("/foo//bar").segmentCount());
+    assertEquals(1, new PathFragment("foo/").segmentCount());
+    assertEquals(1, new PathFragment("/foo/").segmentCount());
+    assertEquals(1, new PathFragment("foo").segmentCount());
+    assertEquals(1, new PathFragment("/foo").segmentCount());
+    assertEquals(0, new PathFragment("/").segmentCount());
+    assertEquals(0, new PathFragment("").segmentCount());
+  }
+
+
+  @Test
+  public void testGetSegment() {
+    assertEquals("foo", new PathFragment("foo/bar").getSegment(0));
+    assertEquals("bar", new PathFragment("foo/bar").getSegment(1));
+    assertEquals("foo", new PathFragment("/foo/bar").getSegment(0));
+    assertEquals("bar", new PathFragment("/foo/bar").getSegment(1));
+    assertEquals("foo", new PathFragment("foo/").getSegment(0));
+    assertEquals("foo", new PathFragment("/foo/").getSegment(0));
+    assertEquals("foo", new PathFragment("foo").getSegment(0));
+    assertEquals("foo", new PathFragment("/foo").getSegment(0));
+  }
+
+  @Test
+  public void testBasename() throws Exception {
+    assertEquals("bar", new PathFragment("foo/bar").getBaseName());
+    assertEquals("bar", new PathFragment("/foo/bar").getBaseName());
+    assertEquals("foo", new PathFragment("foo/").getBaseName());
+    assertEquals("foo", new PathFragment("/foo/").getBaseName());
+    assertEquals("foo", new PathFragment("foo").getBaseName());
+    assertEquals("foo", new PathFragment("/foo").getBaseName());
+    assertEquals("", new PathFragment("/").getBaseName());
+    assertEquals("", new PathFragment("").getBaseName());
+  }
+
+  private static void assertPath(String expected, PathFragment actual) {
+    assertEquals(expected, actual.getPathString());
+  }
+
+  @Test
+  public void testReplaceName() throws Exception {
+    assertPath("foo/baz", new PathFragment("foo/bar").replaceName("baz"));
+    assertPath("/foo/baz", new PathFragment("/foo/bar").replaceName("baz"));
+    assertPath("foo", new PathFragment("foo/bar").replaceName(""));
+    assertPath("baz", new PathFragment("foo/").replaceName("baz"));
+    assertPath("/baz", new PathFragment("/foo/").replaceName("baz"));
+    assertPath("baz", new PathFragment("foo").replaceName("baz"));
+    assertPath("/baz", new PathFragment("/foo").replaceName("baz"));
+    assertEquals(null, new PathFragment("/").replaceName("baz"));
+    assertEquals(null, new PathFragment("/").replaceName(""));
+    assertEquals(null, new PathFragment("").replaceName("baz"));
+    assertEquals(null, new PathFragment("").replaceName(""));
+
+    assertPath("foo/bar/baz", new PathFragment("foo/bar").replaceName("bar/baz"));
+    assertPath("foo/bar/baz", new PathFragment("foo/bar").replaceName("bar/baz/"));
+
+    // Absolute path arguments will clobber the original path.
+    assertPath("/absolute", new PathFragment("foo/bar").replaceName("/absolute"));
+    assertPath("/", new PathFragment("foo/bar").replaceName("/"));
+  }
+  @Test
+  public void testSubFragment() throws Exception {
+    assertPath("/foo/bar/baz",
+               new PathFragment("/foo/bar/baz").subFragment(0, 3));
+    assertPath("foo/bar/baz",
+               new PathFragment("foo/bar/baz").subFragment(0, 3));
+    assertPath("/foo/bar",
+               new PathFragment("/foo/bar/baz").subFragment(0, 2));
+    assertPath("bar/baz",
+               new PathFragment("/foo/bar/baz").subFragment(1, 3));
+    assertPath("/foo",
+               new PathFragment("/foo/bar/baz").subFragment(0, 1));
+    assertPath("bar",
+               new PathFragment("/foo/bar/baz").subFragment(1, 2));
+    assertPath("baz", new PathFragment("/foo/bar/baz").subFragment(2, 3));
+    assertPath("/", new PathFragment("/foo/bar/baz").subFragment(0, 0));
+    assertPath("", new PathFragment("foo/bar/baz").subFragment(0, 0));
+    assertPath("", new PathFragment("foo/bar/baz").subFragment(1, 1));
+    try {
+      fail("unexpectedly succeeded: " + new PathFragment("foo/bar/baz").subFragment(3, 2));
+    } catch (IndexOutOfBoundsException e) { /* Expected. */ }
+    try {
+      fail("unexpectedly succeeded: " + new PathFragment("foo/bar/baz").subFragment(4, 4));
+    } catch (IndexOutOfBoundsException e) { /* Expected. */ }
+  }
+
+  @Test
+  public void testStartsWith() {
+    PathFragment foobar = new PathFragment("/foo/bar");
+    PathFragment foobarRelative = new PathFragment("foo/bar");
+
+    // (path, prefix) => true
+    assertTrue(foobar.startsWith(foobar));
+    assertTrue(foobar.startsWith(new PathFragment("/")));
+    assertTrue(foobar.startsWith(new PathFragment("/foo")));
+    assertTrue(foobar.startsWith(new PathFragment("/foo/")));
+    assertTrue(foobar.startsWith(new PathFragment("/foo/bar/")));  // Includes trailing slash.
+
+    // (prefix, path) => false
+    assertFalse(new PathFragment("/foo").startsWith(foobar));
+    assertFalse(new PathFragment("/").startsWith(foobar));
+
+    // (absolute, relative) => false
+    assertFalse(foobar.startsWith(foobarRelative));
+    assertFalse(foobarRelative.startsWith(foobar));
+
+    // (relative path, relative prefix) => true
+    assertTrue(foobarRelative.startsWith(foobarRelative));
+    assertTrue(foobarRelative.startsWith(new PathFragment("foo")));
+    assertTrue(foobarRelative.startsWith(new PathFragment("")));
+
+    // (path, sibling) => false
+    assertFalse(new PathFragment("/foo/wiz").startsWith(foobar));
+    assertFalse(foobar.startsWith(new PathFragment("/foo/wiz")));
+
+    // Does not normalize.
+    PathFragment foodotbar = new PathFragment("foo/./bar");
+    assertTrue(foodotbar.startsWith(foodotbar));
+    assertTrue(foodotbar.startsWith(new PathFragment("foo/.")));
+    assertTrue(foodotbar.startsWith(new PathFragment("foo/./")));
+    assertTrue(foodotbar.startsWith(new PathFragment("foo/./bar")));
+    assertFalse(foodotbar.startsWith(new PathFragment("foo/bar")));
+  }
+
+  @Test
+  public void testEndsWith() {
+    PathFragment foobar = new PathFragment("/foo/bar");
+    PathFragment foobarRelative = new PathFragment("foo/bar");
+
+    // (path, suffix) => true
+    assertTrue(foobar.endsWith(foobar));
+    assertTrue(foobar.endsWith(new PathFragment("bar")));
+    assertTrue(foobar.endsWith(new PathFragment("foo/bar")));
+    assertTrue(foobar.endsWith(new PathFragment("/foo/bar")));
+    assertFalse(foobar.endsWith(new PathFragment("/bar")));
+
+    // (prefix, path) => false
+    assertFalse(new PathFragment("/foo").endsWith(foobar));
+    assertFalse(new PathFragment("/").endsWith(foobar));
+
+    // (suffix, path) => false
+    assertFalse(new PathFragment("/bar").endsWith(foobar));
+    assertFalse(new PathFragment("bar").endsWith(foobar));
+    assertFalse(new PathFragment("").endsWith(foobar));
+
+    // (absolute, relative) => true
+    assertTrue(foobar.endsWith(foobarRelative));
+
+    // (relative, absolute) => false
+    assertFalse(foobarRelative.endsWith(foobar));
+
+    // (relative path, relative prefix) => true
+    assertTrue(foobarRelative.endsWith(foobarRelative));
+    assertTrue(foobarRelative.endsWith(new PathFragment("bar")));
+    assertTrue(foobarRelative.endsWith(new PathFragment("")));
+
+    // (path, sibling) => false
+    assertFalse(new PathFragment("/foo/wiz").endsWith(foobar));
+    assertFalse(foobar.endsWith(new PathFragment("/foo/wiz")));
+  }
+
+  static List<PathFragment> toPaths(List<String> strs) {
+    List<PathFragment> paths = Lists.newArrayList();
+    for (String s : strs) {
+      paths.add(new PathFragment(s));
+    }
+    return paths;
+  }
+
+  @Test
+  public void testCompareTo() throws Exception {
+    List<String> pathStrs = ImmutableList.of(
+        "", "/", "//", ".", "/./", "foo/.//bar", "foo", "/foo", "foo/bar", "foo/Bar", "Foo/bar");
+    List<PathFragment> paths = toPaths(pathStrs);
+    // First test that compareTo is self-consistent.
+    for (PathFragment x : paths) {
+      for (PathFragment y : paths) {
+        for (PathFragment z : paths) {
+          // Anti-symmetry
+          assertEquals(Integer.signum(x.compareTo(y)),
+                       -1 * Integer.signum(y.compareTo(x)));
+          // Transitivity
+          if (x.compareTo(y) > 0 && y.compareTo(z) > 0) {
+            MoreAsserts.assertGreaterThan(0, x.compareTo(z));
+          }
+          // "Substitutability"
+          if (x.compareTo(y) == 0) {
+            assertEquals(Integer.signum(x.compareTo(z)), Integer.signum(y.compareTo(z)));
+          }
+          // Consistency with equals
+          assertEquals((x.compareTo(y) == 0), x.equals(y));
+        }
+      }
+    }
+    // Now test that compareTo does what we expect.  The exact ordering here doesn't matter much,
+    // but there are three things to notice: 1. absolute < relative, 2. comparison is lexicographic
+    // 3. repeated slashes are ignored. (PathFragment("//") prints as "/").
+    Collections.shuffle(paths);
+    Collections.sort(paths);
+    List<PathFragment> expectedOrder = toPaths(ImmutableList.of(
+        "/", "//", "/./", "/foo", "", ".", "Foo/bar", "foo", "foo/.//bar", "foo/Bar", "foo/bar"));
+    assertEquals(expectedOrder, paths);
+  }
+
+  @Test
+  public void testGetSafePathString() {
+    assertEquals("/", new PathFragment("/").getSafePathString());
+    assertEquals("/abc", new PathFragment("/abc").getSafePathString());
+    assertEquals(".", new PathFragment("").getSafePathString());
+    assertEquals(".", PathFragment.EMPTY_FRAGMENT.getSafePathString());
+    assertEquals("abc/def", new PathFragment("abc/def").getSafePathString());
+  }
+  
+  @Test
+  public void testNormalize() {
+    assertEquals(new PathFragment("/a/b"), new PathFragment("/a/b").normalize());
+    assertEquals(new PathFragment("/a/b"), new PathFragment("/a/./b").normalize());
+    assertEquals(new PathFragment("/b"), new PathFragment("/a/../b").normalize());
+    assertEquals(new PathFragment("a/b"), new PathFragment("a/b").normalize());
+    assertEquals(new PathFragment("../b"), new PathFragment("a/../../b").normalize());
+    assertEquals(new PathFragment(".."), new PathFragment("a/../..").normalize());
+    assertEquals(new PathFragment("b"), new PathFragment("a/../b").normalize());
+    assertEquals(new PathFragment("a/b"), new PathFragment("a/b/../b").normalize());
+    assertEquals(new PathFragment("/.."), new PathFragment("/..").normalize());
+  }
+
+  @Test
+  public void testSerializationSimple() throws Exception {
+   checkSerialization("a", 91);
+  }
+
+  @Test
+  public void testSerializationAbsolute() throws Exception {
+    checkSerialization("/foo", 94);
+   }
+
+  @Test
+  public void testSerializationNested() throws Exception {
+    checkSerialization("foo/bar/baz", 101);
+  }
+
+  private void checkSerialization(String pathFragmentString, int expectedSize) throws Exception {
+    PathFragment a = new PathFragment(pathFragmentString);
+    byte[] sa = TestUtils.serializeObject(a);
+    assertEquals(expectedSize, sa.length);
+
+    PathFragment a2 = (PathFragment) TestUtils.deserializeObject(sa);
+    assertEquals(a, a2);
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/PathFragmentWindowsTest.java b/src/test/java/com/google/devtools/build/lib/vfs/PathFragmentWindowsTest.java
new file mode 100644
index 0000000..43c94d4
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/vfs/PathFragmentWindowsTest.java
@@ -0,0 +1,218 @@
+// Copyright 2014 Google Inc. 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.vfs;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.File;
+
+/**
+ * This class tests the functionality of the PathFragment.
+ */
+@RunWith(JUnit4.class)
+public class PathFragmentWindowsTest {
+  
+  @Test
+  public void testWindowsSeparator() {
+    assertEquals("bar/baz", new PathFragment("bar\\baz").toString());
+    assertEquals("C:/bar/baz", new PathFragment("c:\\bar\\baz").toString());
+  }
+
+  @Test
+  public void testIsAbsoluteWindows() {
+    assertTrue(new PathFragment("C:/").isAbsolute());
+    assertTrue(new PathFragment("C:/").isAbsolute());
+    assertTrue(new PathFragment("C:/foo").isAbsolute());
+    assertTrue(new PathFragment("d:/foo/bar").isAbsolute());
+
+    assertFalse(new PathFragment("*:/").isAbsolute());
+
+    // C: is not an absolute path, it points to the current active directory on drive C:.
+    assertFalse(new PathFragment("C:").isAbsolute());
+    assertFalse(new PathFragment("C:foo").isAbsolute());
+  }
+
+  @Test
+  public void testIsAbsoluteWindowsBackslash() {
+    assertTrue(new PathFragment(new File("C:\\blah")).isAbsolute());
+    assertTrue(new PathFragment(new File("C:\\")).isAbsolute());
+    assertTrue(new PathFragment(new File("\\blah")).isAbsolute());
+    assertTrue(new PathFragment(new File("\\")).isAbsolute());
+  }
+
+  @Test
+  public void testIsNormalizedWindows() {
+    assertTrue(new PathFragment("C:/").isNormalized());
+    assertTrue(new PathFragment("C:/absolute/path").isNormalized());
+    assertFalse(new PathFragment("C:/absolute/./path").isNormalized());
+    assertFalse(new PathFragment("C:/absolute/../path").isNormalized());
+  }
+
+  @Test
+  public void testRootNodeReturnsRootStringWindows() {
+    PathFragment rootFragment = new PathFragment("C:/");
+    assertEquals("C:/", rootFragment.getPathString());
+  }
+
+  @Test
+  public void testGetRelativeWindows() {
+    assertEquals("C:/a/b", new PathFragment("C:/a").getRelative("b").getPathString());
+    assertEquals("C:/a/b/c/d", new PathFragment("C:/a/b").getRelative("c/d").getPathString());
+    assertEquals("C:/b", new PathFragment("C:/a").getRelative("C:/b").getPathString());
+    assertEquals("C:/c/d", new PathFragment("C:/a/b").getRelative("C:/c/d").getPathString());
+    assertEquals("C:/b", new PathFragment("a").getRelative("C:/b").getPathString());
+    assertEquals("C:/c/d", new PathFragment("a/b").getRelative("C:/c/d").getPathString());
+  }
+
+  @Test
+  public void testGetRelativeMixed() {
+    assertEquals("/b", new PathFragment("C:/a").getRelative("/b").getPathString());
+    assertEquals("C:/b", new PathFragment("/a").getRelative("C:/b").getPathString());
+  }
+
+  @Test
+  public void testGetChildWorks() {
+    PathFragment pf = new PathFragment("../some/path");
+    assertEquals(new PathFragment("../some/path/hi"), pf.getChild("hi"));
+  }
+
+  // Tests after here test the canonicalization
+  private void assertRegular(String expected, String actual) {
+    assertEquals(expected, new PathFragment(actual).getPathString()); // compare string forms
+    assertEquals(new PathFragment(expected), new PathFragment(actual)); // compare fragment forms
+  }
+
+  @Test
+  public void testEmptyPathToEmptyPathWindows() {
+    assertRegular("C:/", "C:/");
+  }
+
+  @Test
+  public void testEmptyRelativePathToEmptyPathWindows() {
+    assertRegular("C:", "C:");
+  }
+
+  @Test
+  public void testWindowsVolumeUppercase() {
+    assertRegular("C:/", "c:/");
+  }
+
+  @Test
+  public void testRedundantSlashesWindows() {
+    assertRegular("C:/", "C:///");
+    assertRegular("C:/foo/bar", "C:/foo///bar");
+    assertRegular("C:/foo/bar", "C:////foo//bar");
+  }
+
+  @Test
+  public void testSimpleNameToSimpleNameWindows() {
+    assertRegular("C:/foo", "C:/foo");
+  }
+
+  @Test
+  public void testStripsTrailingSlashWindows() {
+    assertRegular("C:/foo/bar", "C:/foo/bar/");
+  }
+
+  @Test
+  public void testGetParentDirectoryWindows() {
+    PathFragment fooBarWizAbs = new PathFragment("C:/foo/bar/wiz");
+    PathFragment fooBarAbs = new PathFragment("C:/foo/bar");
+    PathFragment fooAbs = new PathFragment("C:/foo");
+    PathFragment rootAbs = new PathFragment("C:/");
+    assertEquals(fooBarAbs, fooBarWizAbs.getParentDirectory());
+    assertEquals(fooAbs, fooBarAbs.getParentDirectory());
+    assertEquals(rootAbs, fooAbs.getParentDirectory());
+    assertNull(rootAbs.getParentDirectory());
+
+    // Note, this is suprising but correct behaviour:
+    assertEquals(fooBarAbs,
+                 new PathFragment("C:/foo/bar/..").getParentDirectory());
+  }
+
+  @Test
+  public void testSegmentsCountWindows() {
+    assertEquals(1, new PathFragment("C:/foo").segmentCount());
+    assertEquals(0, new PathFragment("C:/").segmentCount());
+  }
+
+  @Test
+  public void testGetSegmentWindows() {
+    assertEquals("foo", new PathFragment("C:/foo/bar").getSegment(0));
+    assertEquals("bar", new PathFragment("C:/foo/bar").getSegment(1));
+    assertEquals("foo", new PathFragment("C:/foo/").getSegment(0));
+    assertEquals("foo", new PathFragment("C:/foo").getSegment(0));
+  }
+
+  @Test
+  public void testBasenameWindows() throws Exception {
+    assertEquals("bar", new PathFragment("C:/foo/bar").getBaseName());
+    assertEquals("foo", new PathFragment("C:/foo").getBaseName());
+    // Never return the drive name as a basename.
+    assertEquals("", new PathFragment("C:/").getBaseName());
+  }
+
+  private static void assertPath(String expected, PathFragment actual) {
+    assertEquals(expected, actual.getPathString());
+  }
+
+  @Test
+  public void testReplaceNameWindows() throws Exception {
+    assertPath("C:/foo/baz", new PathFragment("C:/foo/bar").replaceName("baz"));
+    assertEquals(null, new PathFragment("C:/").replaceName("baz"));
+  }
+
+  @Test
+  public void testStartsWithWindows() {
+    assertTrue(new PathFragment("C:/foo/bar").startsWith(new PathFragment("C:/foo")));
+    assertTrue(new PathFragment("C:/foo/bar").startsWith(new PathFragment("C:/")));
+    assertTrue(new PathFragment("C:foo/bar").startsWith(new PathFragment("C:")));
+    assertTrue(new PathFragment("C:/").startsWith(new PathFragment("C:/")));
+    assertTrue(new PathFragment("C:").startsWith(new PathFragment("C:")));
+
+    // The first path is absolute, the second is not.
+    assertFalse(new PathFragment("C:/foo/bar").startsWith(new PathFragment("C:")));
+    assertFalse(new PathFragment("C:/").startsWith(new PathFragment("C:")));
+  }
+
+  @Test
+  public void testEndsWithWindows() {
+    assertTrue(new PathFragment("C:/foo/bar").endsWith(new PathFragment("bar")));
+    assertTrue(new PathFragment("C:/foo/bar").endsWith(new PathFragment("foo/bar")));
+    assertTrue(new PathFragment("C:/foo/bar").endsWith(new PathFragment("C:/foo/bar")));
+    assertTrue(new PathFragment("C:/").endsWith(new PathFragment("C:/")));
+  }
+
+  @Test
+  public void testGetSafePathStringWindows() {
+    assertEquals("C:/", new PathFragment("C:/").getSafePathString());
+    assertEquals("C:/abc", new PathFragment("C:/abc").getSafePathString());
+    assertEquals("C:/abc/def", new PathFragment("C:/abc/def").getSafePathString());
+  }
+
+  @Test
+  public void testNormalizeWindows() {
+    assertEquals(new PathFragment("C:/a/b"), new PathFragment("C:/a/b").normalize());
+    assertEquals(new PathFragment("C:/a/b"), new PathFragment("C:/a/./b").normalize());
+    assertEquals(new PathFragment("C:/b"), new PathFragment("C:/a/../b").normalize());
+    assertEquals(new PathFragment("C:/../b"), new PathFragment("C:/../b").normalize());
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/PathTest.java b/src/test/java/com/google/devtools/build/lib/vfs/PathTest.java
new file mode 100644
index 0000000..738e454
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/vfs/PathTest.java
@@ -0,0 +1,312 @@
+// Copyright 2014 Google Inc. 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.vfs;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.Lists;
+import com.google.common.testing.EqualsTester;
+import com.google.common.testing.GcFinalization;
+import com.google.devtools.build.lib.util.BlazeClock;
+import com.google.devtools.build.lib.vfs.inmemoryfs.InMemoryFileSystem;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.lang.ref.WeakReference;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * A test for {@link Path}.
+ */
+@RunWith(JUnit4.class)
+public class PathTest {
+  private FileSystem filesystem;
+  private Path root;
+
+  @Before
+  public void setUp() throws Exception {
+    filesystem = new InMemoryFileSystem(BlazeClock.instance());
+    root = filesystem.getRootDirectory();
+    Path first = root.getChild("first");
+    first.createDirectory();
+  }
+
+  @Test
+  public void testStartsWithWorksForSelf() {
+    assertStartsWithReturns(true, "/first/child", "/first/child");
+  }
+
+  @Test
+  public void testStartsWithWorksForChild() {
+    assertStartsWithReturns(true,
+        "/first/child", "/first/child/grandchild");
+  }
+
+  @Test
+  public void testStartsWithWorksForDeepDescendant() {
+    assertStartsWithReturns(true,
+        "/first/child", "/first/child/grandchild/x/y/z");
+  }
+
+  @Test
+  public void testStartsWithFailsForParent() {
+    assertStartsWithReturns(false, "/first/child", "/first");
+  }
+
+  @Test
+  public void testStartsWithFailsForSibling() {
+    assertStartsWithReturns(false, "/first/child", "/first/child2");
+  }
+
+  @Test
+  public void testStartsWithFailsForLinkToDescendant()
+      throws Exception {
+    Path linkTarget = filesystem.getPath("/first/linked_to");
+    FileSystemUtils.createEmptyFile(linkTarget);
+    Path second = filesystem.getPath("/second/");
+    second.createDirectory();
+    second.getChild("child_link").createSymbolicLink(linkTarget);
+    assertStartsWithReturns(false, "/first", "/second/child_link");
+  }
+
+  @Test
+  public void testStartsWithFailsForNullPrefix() {
+    try {
+      filesystem.getPath("/first").startsWith(null);
+      fail();
+    } catch (Exception e) {
+    }
+  }
+
+  private void assertStartsWithReturns(boolean expected,
+                                       String ancestor,
+                                       String descendant) {
+    Path parent = filesystem.getPath(ancestor);
+    Path child = filesystem.getPath(descendant);
+    assertEquals(expected, child.startsWith(parent));
+  }
+
+  @Test
+  public void testGetChildWorks() {
+    assertGetChildWorks("second");
+    assertGetChildWorks("...");
+    assertGetChildWorks("....");
+  }
+
+  private void assertGetChildWorks(String childName) {
+    assertEquals(filesystem.getPath("/first/" + childName),
+        filesystem.getPath("/first").getChild(childName));
+  }
+
+  @Test
+  public void testGetChildFailsForChildWithSlashes() {
+    assertGetChildFails("second/third");
+    assertGetChildFails("./third");
+    assertGetChildFails("../third");
+    assertGetChildFails("second/..");
+    assertGetChildFails("second/.");
+    assertGetChildFails("/third");
+    assertGetChildFails("third/");
+  }
+
+  private void assertGetChildFails(String childName) {
+    try {
+      filesystem.getPath("/first").getChild(childName);
+      fail();
+    } catch (IllegalArgumentException e) {
+      // Expected.
+    }
+  }
+
+  @Test
+  public void testGetChildFailsForDotAndDotDot() {
+    assertGetChildFails(".");
+    assertGetChildFails("..");
+  }
+
+  @Test
+  public void testGetChildFailsForEmptyString() {
+    assertGetChildFails("");
+  }
+
+  @Test
+  public void testRelativeToWorks() {
+    assertRelativeToWorks("apple", "/fruit/apple", "/fruit");
+    assertRelativeToWorks("apple/jonagold", "/fruit/apple/jonagold", "/fruit");
+  }
+
+  @Test
+  public void testGetRelativeWithStringWorks() {
+    assertGetRelativeWorks("/first/x/y", "y");
+    assertGetRelativeWorks("/y", "/y");
+    assertGetRelativeWorks("/first/x/x", "./x");
+    assertGetRelativeWorks("/first/y", "../y");
+    assertGetRelativeWorks("/", "../../../../..");
+  }
+
+  @Test
+  public void testAsFragmentWorks() {
+    assertAsFragmentWorks("/");
+    assertAsFragmentWorks("//");
+    assertAsFragmentWorks("/first");
+    assertAsFragmentWorks("/first/x/y");
+    assertAsFragmentWorks("/first/x/y.foo");
+  }
+
+  @Test
+  public void testGetRelativeWithFragmentWorks() {
+    Path dir = filesystem.getPath("/first/x");
+    assertEquals("/first/x/y",
+                 dir.getRelative(new PathFragment("y")).toString());
+    assertEquals("/first/x/x",
+                 dir.getRelative(new PathFragment("./x")).toString());
+    assertEquals("/first/y",
+                 dir.getRelative(new PathFragment("../y")).toString());
+
+  }
+
+  @Test
+  public void testGetRelativeWithAbsoluteFragmentWorks() {
+    Path root = filesystem.getPath("/first/x");
+    assertEquals("/x/y",
+                 root.getRelative(new PathFragment("/x/y")).toString());
+  }
+
+  @Test
+  public void testGetRelativeWithAbsoluteStringWorks() {
+    Path root = filesystem.getPath("/first/x");
+    assertEquals("/x/y", root.getRelative("/x/y").toString());
+  }
+
+  @Test
+  public void testComparableSortOrder() {
+    Path zzz = filesystem.getPath("/zzz");
+    Path ZZZ = filesystem.getPath("/ZZZ");
+    Path abc = filesystem.getPath("/abc");
+    Path aBc = filesystem.getPath("/aBc");
+    Path AbC = filesystem.getPath("/AbC");
+    Path ABC = filesystem.getPath("/ABC");
+    List<Path> list = Lists.newArrayList(zzz, ZZZ, ABC, aBc, AbC, abc);
+    Collections.sort(list);
+    assertThat(list).containsExactly(ABC, AbC, ZZZ, aBc, abc, zzz).inOrder();
+  }
+
+  @Test
+  public void testParentOfRootIsRoot() {
+    assertSame(root, root.getRelative(".."));
+
+    assertSame(root.getRelative("dots"),
+               root.getRelative("broken/../../dots"));
+  }
+
+  @Test
+  public void testSingleSegmentEquivalence() {
+    assertSame(
+        root.getRelative("aSingleSegment"),
+        root.getRelative("aSingleSegment"));
+  }
+
+  @Test
+  public void testSiblingNonEquivalenceString() {
+    assertNotSame(
+        root.getRelative("aSingleSegment"),
+        root.getRelative("aDifferentSegment"));
+  }
+
+  @Test
+  public void testSiblingNonEquivalenceFragment() {
+    assertNotSame(
+        root.getRelative(new PathFragment("aSingleSegment")),
+        root.getRelative(new PathFragment("aDifferentSegment")));
+  }
+
+  @Test
+  public void testHashCodeStableAcrossGarbageCollections() {
+    Path parent = filesystem.getPath("/a");
+    PathFragment childFragment = new PathFragment("b");
+    Path child = parent.getRelative(childFragment);
+    WeakReference<Path> childRef = new WeakReference<>(child);
+    int childHashCode1 = childRef.get().hashCode();
+    assertEquals(childHashCode1, parent.getRelative(childFragment).hashCode());
+    child = null;
+    GcFinalization.awaitClear(childRef);
+    int childHashCode2 = parent.getRelative(childFragment).hashCode();
+    assertEquals(childHashCode1, childHashCode2);
+  }
+
+  @Test
+  public void testSerialization() throws Exception {
+    FileSystem oldFileSystem = Path.getFileSystemForSerialization();
+    try {
+      Path.setFileSystemForSerialization(filesystem);
+      Path root = filesystem.getPath("/");
+      Path p1 = filesystem.getPath("/foo");
+      Path p2 = filesystem.getPath("/foo/bar");
+
+      ByteArrayOutputStream bos = new ByteArrayOutputStream();
+      ObjectOutputStream oos = new ObjectOutputStream(bos);
+
+      oos.writeObject(root);
+      oos.writeObject(p1);
+      oos.writeObject(p2);
+
+      ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
+      ObjectInputStream ois = new ObjectInputStream(bis);
+
+      Path dsRoot = (Path) ois.readObject();
+      Path dsP1 = (Path) ois.readObject();
+      Path dsP2 = (Path) ois.readObject();
+
+      new EqualsTester()
+          .addEqualityGroup(root, dsRoot)
+          .addEqualityGroup(p1, dsP1)
+          .addEqualityGroup(p2, dsP2)
+          .testEquals();
+
+      assertTrue(p2.startsWith(p1));
+      assertTrue(p2.startsWith(dsP1));
+      assertTrue(dsP2.startsWith(p1));
+      assertTrue(dsP2.startsWith(dsP1));
+    } finally {
+      Path.setFileSystemForSerialization(oldFileSystem);
+    }
+  }
+
+  private void assertAsFragmentWorks(String expected) {
+    assertEquals(new PathFragment(expected), filesystem.getPath(expected).asFragment());
+  }
+
+  private void assertGetRelativeWorks(String expected, String relative) {
+    assertEquals(filesystem.getPath(expected),
+        filesystem.getPath("/first/x").getRelative(relative));
+  }
+
+  private void assertRelativeToWorks(String expected, String relative, String original) {
+    assertEquals(new PathFragment(expected),
+                 filesystem.getPath(relative).relativeTo(filesystem.getPath(original)));
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/PathWindowsTest.java b/src/test/java/com/google/devtools/build/lib/vfs/PathWindowsTest.java
new file mode 100644
index 0000000..c92fc2b
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/vfs/PathWindowsTest.java
@@ -0,0 +1,98 @@
+// Copyright 2014 Google Inc. 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.vfs;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertSame;
+
+import com.google.devtools.build.lib.util.BlazeClock;
+import com.google.devtools.build.lib.vfs.inmemoryfs.InMemoryFileSystem;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * A test for windows aspects of {@link Path}.
+ */
+@RunWith(JUnit4.class)
+public class PathWindowsTest {
+  private FileSystem filesystem;
+  private Path root;
+
+  @Before
+  public void setUp() throws Exception {
+    filesystem = new InMemoryFileSystem(BlazeClock.instance());
+    root = filesystem.getRootDirectory();
+    Path first = root.getChild("first");
+    first.createDirectory();
+  }
+
+  private void assertAsFragmentWorks(String expected) {
+    assertEquals(new PathFragment(expected), filesystem.getPath(expected).asFragment());
+  }
+
+  @Test
+  public void testWindowsPath() {
+    Path p = filesystem.getPath("C:/foo/bar");
+    assertEquals("C:/foo/bar", p.getPathString());
+    assertEquals("C:/foo/bar", p.toString());
+  }
+
+  @Test
+  public void testAsFragmentWindows() {
+    assertAsFragmentWorks("C:/");
+    assertAsFragmentWorks("C://");
+    assertAsFragmentWorks("C:/first");
+    assertAsFragmentWorks("C:/first/x/y");
+    assertAsFragmentWorks("C:/first/x/y.foo");
+  }
+
+  @Test
+  public void testGetRelativeWithFragmentWindows() {
+    Path dir = filesystem.getPath("C:/first/x");
+    assertEquals("C:/first/x/y",
+                 dir.getRelative(new PathFragment("y")).toString());
+    assertEquals("C:/first/x/x",
+                 dir.getRelative(new PathFragment("./x")).toString());
+    assertEquals("C:/first/y",
+                 dir.getRelative(new PathFragment("../y")).toString());
+    assertEquals("C:/first/y",
+        dir.getRelative(new PathFragment("../y")).toString());
+    assertEquals("C:/y",
+        dir.getRelative(new PathFragment("../../../y")).toString());
+  }
+
+  @Test
+  public void testGetRelativeWithAbsoluteFragmentWindows() {
+    Path root = filesystem.getPath("C:/first/x");
+    assertEquals("C:/x/y",
+                 root.getRelative(new PathFragment("C:/x/y")).toString());
+  }
+
+  @Test
+  public void testGetRelativeWithAbsoluteStringWorksWindows() {
+    Path root = filesystem.getPath("C:/first/x");
+    assertEquals("C:/x/y", root.getRelative("C:/x/y").toString());
+  }
+
+  @Test
+  public void testParentOfRootIsRootWindows() {
+    assertSame(root, root.getRelative(".."));
+
+    assertSame(root.getRelative("dots"),
+               root.getRelative("broken/../../dots"));
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/RecursiveGlobTest.java b/src/test/java/com/google/devtools/build/lib/vfs/RecursiveGlobTest.java
new file mode 100644
index 0000000..5e0012a
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/vfs/RecursiveGlobTest.java
@@ -0,0 +1,227 @@
+// Copyright 2014 Google Inc. 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.vfs;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.devtools.build.lib.testutil.MoreAsserts.assertSameContents;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Ordering;
+import com.google.devtools.build.lib.testutil.MoreAsserts;
+import com.google.devtools.build.lib.util.BlazeClock;
+import com.google.devtools.build.lib.vfs.inmemoryfs.InMemoryFileSystem;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * Tests {@link UnixGlob} recursive globs.
+ */
+@RunWith(JUnit4.class)
+public class RecursiveGlobTest {
+
+  private Path tmpPath;
+  private FileSystem fileSystem;
+  
+  @Before
+  public void setUp() throws Exception {
+    fileSystem = new InMemoryFileSystem(BlazeClock.instance());
+    tmpPath = fileSystem.getPath("/rglobtmp");
+    for (String dir : ImmutableList.of("foo/bar/wiz",
+                         "foo/baz/wiz",
+                         "foo/baz/quip/wiz",
+                         "food/baz/wiz",
+                         "fool/baz/wiz")) {
+      FileSystemUtils.createDirectoryAndParents(tmpPath.getRelative(dir));
+    }
+    FileSystemUtils.createEmptyFile(tmpPath.getRelative("foo/bar/wiz/file"));
+  }
+
+  @Test
+  public void testDoubleStar() throws Exception {
+    assertGlobMatches("**", ".", "foo", "foo/bar", "foo/bar/wiz", "foo/baz", "foo/baz/quip",
+                      "foo/baz/quip/wiz", "foo/baz/wiz", "foo/bar/wiz/file", "food", "food/baz",
+                      "food/baz/wiz", "fool", "fool/baz", "fool/baz/wiz");
+  }
+
+  @Test
+  public void testDoubleDoubleStar() throws Exception {
+    assertGlobMatches("**/**", ".", "foo", "foo/bar", "foo/bar/wiz", "foo/baz", "foo/baz/quip",
+                      "foo/baz/quip/wiz", "foo/baz/wiz", "foo/bar/wiz/file", "food", "food/baz",
+                      "food/baz/wiz", "fool", "fool/baz", "fool/baz/wiz");
+  }
+
+  @Test
+  public void testDirectoryWithDoubleStar() throws Exception {
+    assertGlobMatches("foo/**", "foo", "foo/bar", "foo/bar/wiz", "foo/baz", "foo/baz/quip",
+                      "foo/baz/quip/wiz", "foo/baz/wiz", "foo/bar/wiz/file");
+  }
+
+  @Test
+  public void testIllegalPatterns() throws Exception {
+    for (String prefix : Lists.newArrayList("", "*/", "**/", "ba/")) {
+      String suffix = ("/" + prefix).substring(0, prefix.length());
+      for (String pattern : Lists.newArrayList("**fo", "fo**", "**fo**", "fo**fo", "fo**fo**fo")) {
+        assertIllegalWildcard(prefix + pattern);
+        assertIllegalWildcard(pattern + suffix);
+        assertIllegalWildcard("foo", pattern + suffix);
+      }
+    }
+  }
+
+  @Test
+  public void testDoubleStarPatternWithNamedChild() throws Exception {
+    assertGlobMatches("**/bar", "foo/bar");
+  }
+
+  @Test
+  public void testDoubleStarPatternWithChildGlob() throws Exception {
+    assertGlobMatches("**/ba*",
+        "foo/bar", "foo/baz", "food/baz", "fool/baz");
+  }
+
+  @Test
+  public void testDoubleStarAsChildGlob() throws Exception {
+    assertGlobMatches("foo/**/wiz", "foo/bar/wiz", "foo/baz/quip/wiz", "foo/baz/wiz");
+  }
+
+  @Test
+  public void testDoubleStarUnderNonexistentDirectory() throws Exception {
+    assertGlobMatches("not-there/**" /* => nothing */);
+  }
+
+  @Test
+  public void testDoubleStarGlobWithNonExistentBase() throws Exception {
+    Collection<Path> globResult = UnixGlob.forPath(fileSystem.getPath("/does/not/exist"))
+        .addPattern("**")
+        .globInterruptible();
+    assertEquals(0, globResult.size());
+  }
+
+  @Test
+  public void testDoubleStarUnderFile() throws Exception {
+    assertGlobMatches("foo/bar/wiz/file/**" /* => nothing */);
+  }
+
+  @Test
+  public void testSingleFileExclude() throws Exception {
+    assertGlobWithExcludeMatches("**", "food", ".", "foo", "foo/bar", "foo/bar/wiz", "foo/baz",
+                                 "foo/baz/quip", "foo/baz/quip/wiz", "foo/baz/wiz",
+                                 "foo/bar/wiz/file", "food/baz", "food/baz/wiz", "fool", "fool/baz",
+                                 "fool/baz/wiz");
+  }
+
+  @Test
+  public void testSingleFileExcludeForDirectoryWithChildGlob()
+      throws Exception {
+    assertGlobWithExcludeMatches("foo/**", "foo", "foo/bar", "foo/bar/wiz", "foo/baz",
+                                 "foo/baz/quip", "foo/baz/quip/wiz", "foo/baz/wiz",
+                                 "foo/bar/wiz/file");
+  }
+
+  @Test
+  public void testGlobExcludeForDirectoryWithChildGlob()
+      throws Exception {
+    assertGlobWithExcludeMatches("foo/**", "foo/*", "foo", "foo/bar/wiz", "foo/baz/quip",
+                                 "foo/baz/quip/wiz", "foo/baz/wiz", "foo/bar/wiz/file");
+  }
+
+  @Test
+  public void testExcludeAll() throws Exception {
+    assertGlobWithExcludesMatches(Lists.newArrayList("**"),
+                                  Lists.newArrayList("*", "*/*", "*/*/*", "*/*/*/*"), ".");
+  }
+
+  @Test
+  public void testManualGlobExcludeForDirectoryWithChildGlob()
+      throws Exception {
+    assertGlobWithExcludesMatches(Lists.newArrayList("foo/**"),
+                                  Lists.newArrayList("foo", "foo/*", "foo/*/*", "foo/*/*/*"));
+  }
+
+  private void assertGlobMatches(String pattern, String... expecteds)
+      throws Exception {
+    assertGlobWithExcludesMatches(
+        Collections.singleton(pattern), Collections.<String>emptyList(),
+        expecteds);
+  }
+
+  private void assertGlobWithExcludeMatches(String pattern, String exclude,
+                                            String... expecteds)
+      throws Exception {
+    assertGlobWithExcludesMatches(
+        Collections.singleton(pattern), Collections.singleton(exclude),
+        expecteds);
+  }
+
+  private void assertGlobWithExcludesMatches(Collection<String> pattern,
+                                             Collection<String> excludes,
+                                             String... expecteds) throws Exception {
+    assertSameContents(resolvePaths(expecteds),
+        new UnixGlob.Builder(tmpPath)
+            .addPatterns(pattern)
+            .addExcludes(excludes)
+            .globInterruptible());
+  }
+
+  private Set<Path> resolvePaths(String... relativePaths) {
+    Set<Path> expectedFiles = new HashSet<>();
+    for (String expected : relativePaths) {
+      Path file = expected.equals(".")
+          ? tmpPath
+          : tmpPath.getRelative(expected);
+      expectedFiles.add(file);
+    }
+    return expectedFiles;
+  }
+
+  /**
+   * Tests that a recursive glob returns files in sorted order.
+   */
+  @Test
+  public void testGlobEntriesAreSorted() throws Exception {
+    List<Path> globResult = new UnixGlob.Builder(tmpPath)
+        .addPattern("**")
+        .setExcludeDirectories(false)
+        .globInterruptible();
+
+    assertThat(Ordering.natural().sortedCopy(globResult)).containsExactlyElementsIn(globResult)
+        .inOrder();
+  }
+
+  private void assertIllegalWildcard(String pattern, String... excludePatterns)
+      throws Exception {
+    try {
+      new UnixGlob.Builder(tmpPath)
+          .addPattern(pattern)
+          .addExcludes(excludePatterns)
+          .globInterruptible();
+      fail();
+    } catch (IllegalArgumentException e) {
+      MoreAsserts.assertContainsRegex("recursive wildcard must be its own segment", e.getMessage());
+    }
+  }
+
+}
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/RootedPathTest.java b/src/test/java/com/google/devtools/build/lib/vfs/RootedPathTest.java
new file mode 100644
index 0000000..46d286d
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/vfs/RootedPathTest.java
@@ -0,0 +1,56 @@
+// Copyright 2014 Google Inc. 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.vfs;
+
+import com.google.common.testing.EqualsTester;
+import com.google.devtools.build.lib.util.BlazeClock;
+import com.google.devtools.build.lib.vfs.inmemoryfs.InMemoryFileSystem;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests for {@link RootedPath}.
+ */
+@RunWith(JUnit4.class)
+public class RootedPathTest {
+  private FileSystem filesystem;
+  private Path root;
+
+  @Before
+  public void setUp() throws Exception {
+    filesystem = new InMemoryFileSystem(BlazeClock.instance());
+    root = filesystem.getRootDirectory();
+  }
+
+  @Test
+  public void testEqualsAndHashCodeContract() throws Exception {
+    Path pkgRoot1 = root.getRelative("pkgroot1");
+    Path pkgRoot2 = root.getRelative("pkgroot2");
+    RootedPath rootedPathA1 = RootedPath.toRootedPath(pkgRoot1, new PathFragment("foo/bar"));
+    RootedPath rootedPathA2 = RootedPath.toRootedPath(pkgRoot1, new PathFragment("foo/bar"));
+    RootedPath absolutePath1 = RootedPath.toRootedPath(root, new PathFragment("pkgroot1/foo/bar"));
+    RootedPath rootedPathB1 = RootedPath.toRootedPath(pkgRoot2, new PathFragment("foo/bar"));
+    RootedPath rootedPathB2 = RootedPath.toRootedPath(pkgRoot2, new PathFragment("foo/bar"));
+    RootedPath absolutePath2 = RootedPath.toRootedPath(root, new PathFragment("pkgroot2/foo/bar"));
+    new EqualsTester()
+      .addEqualityGroup(rootedPathA1, rootedPathA2)
+      .addEqualityGroup(rootedPathB1, rootedPathB2)
+      .addEqualityGroup(absolutePath1)
+      .addEqualityGroup(absolutePath2)
+      .testEquals();
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/ScopeEscapableFileSystemTest.java b/src/test/java/com/google/devtools/build/lib/vfs/ScopeEscapableFileSystemTest.java
new file mode 100644
index 0000000..6c8071f
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/vfs/ScopeEscapableFileSystemTest.java
@@ -0,0 +1,806 @@
+// Copyright 2014 Google Inc. 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.vfs;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.Collection;
+
+/**
+ * Generic tests for any file system that implements {@link ScopeEscapableFileSystem},
+ * i.e. any file system that supports symlinks that escape its scope.
+ *
+ * Each suitable file system test should inherit from this class, thereby obtaining
+ * all the tests.
+ */
+public abstract class ScopeEscapableFileSystemTest extends SymlinkAwareFileSystemTest {
+
+  /**
+   * Trivial FileSystem implementation that can record the last path passed to each method
+   * and read/write to a unified "state" variable (which can then be checked by tests) for
+   * each data type this class manipulates.
+   *
+   * The default implementation of each method throws an exception. Each test case should
+   * selectively override the methods it expects to be invoked.
+   */
+  private static class TestDelegator extends FileSystem {
+    protected Path lastPath;
+    protected boolean booleanState;
+    protected long longState;
+    protected Object objectState;
+
+    public void setState(boolean state) { booleanState = state; }
+    public void setState(long state) { longState = state; }
+    public void setState(Object state) { objectState = state; }
+
+    public boolean booleanState() { return booleanState; }
+    public long longState() { return longState; }
+    public Object objectState() { return objectState; }
+
+    public PathFragment lastPath() {
+      Path ans = lastPath;
+      // Clear this out to protect against accidental matches when testing the same path multiple
+      // consecutive times.
+      lastPath = null;
+      return ans != null ? ans.asFragment() : null;
+    }
+
+    @Override public boolean supportsModifications() { return true; }
+    @Override public boolean supportsSymbolicLinks() { return true; }
+
+    private static RuntimeException re() {
+      return new RuntimeException("This method should not be called in this context");
+    }
+
+    @Override protected boolean isReadable(Path path) { throw re(); }
+    @Override protected boolean isWritable(Path path) { throw re(); }
+    @Override protected boolean isDirectory(Path path, boolean followSymlinks) { throw re(); }
+    @Override protected boolean isFile(Path path, boolean followSymlinks) { throw re(); }
+    @Override protected boolean isExecutable(Path path) { throw re(); }
+    @Override protected boolean exists(Path path, boolean followSymlinks) {throw re(); }
+    @Override protected boolean isSymbolicLink(Path path) { throw re(); }
+    @Override protected boolean createDirectory(Path path) { throw re(); }
+    @Override protected boolean delete(Path path) { throw re(); }
+
+    @Override protected long getFileSize(Path path, boolean followSymlinks) { throw re(); }
+    @Override protected long getLastModifiedTime(Path path, boolean followSymlinks) { throw re(); }
+
+    @Override protected void setWritable(Path path, boolean writable) { throw re(); }
+    @Override protected void setExecutable(Path path, boolean executable) { throw re(); }
+    @Override protected void setReadable(Path path, boolean readable) { throw re(); }
+    @Override protected void setLastModifiedTime(Path path, long newTime) { throw re(); }
+    @Override protected void renameTo(Path sourcePath, Path targetPath) { throw re(); }
+    @Override protected void createSymbolicLink(Path linkPath, PathFragment targetFragment) {
+      throw re();
+    }
+
+    @Override protected PathFragment readSymbolicLink(Path path) { throw re(); }
+    @Override protected InputStream getInputStream(Path path) { throw re(); }
+    @Override protected Collection<Path> getDirectoryEntries(Path path) { throw re(); }
+    @Override protected OutputStream getOutputStream(Path path, boolean append)  { throw re(); }
+    @Override
+    protected FileStatus statIfFound(Path path, boolean followSymlinks) throws IOException {
+      throw re();
+    }
+  }
+
+  protected static final PathFragment SCOPE_ROOT = new PathFragment("/fs/root");
+
+  private Path fileLink;
+  private PathFragment fileLinkTarget;
+  private Path dirLink;
+  private PathFragment dirLinkTarget;
+
+  @Override
+  @Before
+  public void setUp() throws Exception {
+    super.setUp();
+
+    Preconditions.checkState(testFS instanceof ScopeEscapableFileSystem,
+        "Not ScopeEscapable: " + testFS);
+    ((ScopeEscapableFileSystem) testFS).enableScopeChecking(false);
+    for (int i = 1; i <= SCOPE_ROOT.segmentCount(); i++) {
+      testFS.getPath(SCOPE_ROOT.subFragment(0, i)).createDirectory();
+    }
+
+    fileLink = testFS.getPath(SCOPE_ROOT.getRelative("link"));
+    fileLinkTarget = new PathFragment("/should/be/delegated/fileLinkTarget");
+    testFS.createSymbolicLink(fileLink, fileLinkTarget);
+
+    dirLink = testFS.getPath(SCOPE_ROOT.getRelative("dirlink"));
+    dirLinkTarget = new PathFragment("/should/be/delegated/dirLinkTarget");
+    testFS.createSymbolicLink(dirLink, dirLinkTarget);
+  }
+
+  /**
+   * Returns the file system supplied by {@link #getFreshFileSystem}, cast to
+   * a {@link ScopeEscapableFileSystem}. Also enables scope checking within
+   * the file system (which we keep disabled for inherited tests that aren't
+   * intended to test scope boundaries).
+   */
+  private ScopeEscapableFileSystem scopedFS() {
+    ScopeEscapableFileSystem fs = (ScopeEscapableFileSystem) testFS;
+    fs.enableScopeChecking(true);
+    return fs;
+  }
+
+  // Checks that the semi-resolved path passed to the delegator matches the expected value.
+  private void checkPath(TestDelegator delegator, PathFragment expectedDelegatedPath) {
+    assertTrue(expectedDelegatedPath.equals(delegator.lastPath()));
+  }
+
+  // Asserts that the condition is false and checks that the expected path was delegated.
+  private void assertFalseWithPathCheck(boolean result, TestDelegator delegator,
+      PathFragment expectedDelegatedPath) {
+    assertFalse(result);
+    checkPath(delegator, expectedDelegatedPath);
+  }
+
+  // Asserts that the condition is true and checks that the expected path was delegated.
+  private void assertTrueWithPathCheck(boolean result, TestDelegator delegator,
+      PathFragment expectedDelegatedPath) {
+    assertTrue(result);
+    checkPath(delegator, expectedDelegatedPath);
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  // Tests:
+  /////////////////////////////////////////////////////////////////////////////
+
+  @Test
+  public void testIsReadableCallOnEscapingSymlink() throws Exception {
+    TestDelegator delegator = new TestDelegator() {
+      @Override protected boolean isReadable(Path path) {
+        lastPath = path;
+        return booleanState();
+      }
+    };
+    scopedFS().setDelegator(delegator);
+
+    delegator.setState(false);
+    assertFalseWithPathCheck(fileLink.isReadable(), delegator, fileLinkTarget);
+    assertFalseWithPathCheck(dirLink.getRelative("a").isReadable(), delegator,
+        dirLinkTarget.getRelative("a"));
+
+    delegator.setState(true);
+    assertTrueWithPathCheck(fileLink.isReadable(), delegator, fileLinkTarget);
+    assertTrueWithPathCheck(dirLink.getRelative("a").isReadable(), delegator,
+        dirLinkTarget.getRelative("a"));
+  }
+
+  @Test
+  public void testIsWritableCallOnEscapingSymlink() throws Exception {
+    TestDelegator delegator = new TestDelegator() {
+      @Override protected boolean isWritable(Path path) {
+        lastPath = path;
+        return booleanState();
+      }
+    };
+    scopedFS().setDelegator(delegator);
+
+    delegator.setState(false);
+    assertFalseWithPathCheck(fileLink.isWritable(), delegator, fileLinkTarget);
+    assertFalseWithPathCheck(dirLink.getRelative("a").isWritable(), delegator,
+        dirLinkTarget.getRelative("a"));
+
+    delegator.setState(true);
+    assertTrueWithPathCheck(fileLink.isWritable(), delegator, fileLinkTarget);
+    assertTrueWithPathCheck(dirLink.getRelative("a").isWritable(), delegator,
+        dirLinkTarget.getRelative("a"));
+  }
+
+  @Test
+  public void testisExecutableCallOnEscapingSymlink() throws Exception {
+    TestDelegator delegator = new TestDelegator() {
+      @Override protected boolean isExecutable(Path path) {
+        lastPath = path;
+        return booleanState();
+      }
+    };
+    scopedFS().setDelegator(delegator);
+
+    delegator.setState(false);
+    assertFalseWithPathCheck(fileLink.isExecutable(), delegator, fileLinkTarget);
+    assertFalseWithPathCheck(dirLink.getRelative("a").isExecutable(), delegator,
+        dirLinkTarget.getRelative("a"));
+
+    delegator.setState(true);
+    assertTrueWithPathCheck(fileLink.isExecutable(), delegator, fileLinkTarget);
+    assertTrueWithPathCheck(dirLink.getRelative("a").isExecutable(), delegator,
+        dirLinkTarget.getRelative("a"));
+  }
+
+  @Test
+  public void testIsDirectoryCallOnEscapingSymlink() throws Exception {
+    TestDelegator delegator = new TestDelegator() {
+      @Override protected boolean isDirectory(Path path, boolean followSymlinks) {
+        lastPath = path;
+        return booleanState();
+      }
+      @Override protected boolean exists(Path path, boolean followSymlinks) { return true; }
+      @Override protected long getLastModifiedTime(Path path, boolean followSymlinks) { return 0; }
+    };
+    scopedFS().setDelegator(delegator);
+
+    delegator.setState(false);
+    assertFalseWithPathCheck(fileLink.isDirectory(), delegator, fileLinkTarget);
+    assertFalseWithPathCheck(dirLink.getRelative("a").isDirectory(), delegator,
+        dirLinkTarget.getRelative("a"));
+
+    delegator.setState(true);
+    assertTrueWithPathCheck(fileLink.isDirectory(), delegator, fileLinkTarget);
+    assertTrueWithPathCheck(dirLink.getRelative("a").isDirectory(), delegator,
+        dirLinkTarget.getRelative("a"));
+  }
+
+  @Test
+  public void testIsFileCallOnEscapingSymlink() throws Exception {
+    TestDelegator delegator = new TestDelegator() {
+      @Override protected boolean isFile(Path path, boolean followSymlinks) {
+        lastPath = path;
+        return booleanState();
+      }
+      @Override protected boolean exists(Path path, boolean followSymlinks) { return true; }
+      @Override protected long getLastModifiedTime(Path path, boolean followSymlinks) { return 0; }
+    };
+    scopedFS().setDelegator(delegator);
+
+    delegator.setState(false);
+    assertFalseWithPathCheck(fileLink.isFile(), delegator, fileLinkTarget);
+    assertFalseWithPathCheck(dirLink.getRelative("a").isFile(), delegator,
+        dirLinkTarget.getRelative("a"));
+
+    delegator.setState(true);
+    assertTrueWithPathCheck(fileLink.isFile(), delegator, fileLinkTarget);
+    assertTrueWithPathCheck(dirLink.getRelative("a").isFile(), delegator,
+        dirLinkTarget.getRelative("a"));
+  }
+
+  @Test
+  public void testIsSymbolicLinkCallOnEscapingSymlink() throws Exception {
+    TestDelegator delegator = new TestDelegator() {
+      @Override protected boolean isSymbolicLink(Path path) {
+        lastPath = path;
+        return booleanState();
+      }
+      @Override protected boolean exists(Path path, boolean followSymlinks) { return true; }
+      @Override protected long getLastModifiedTime(Path path, boolean followSymlinks) { return 0; }
+      @Override protected boolean isDirectory(Path path, boolean followSymlinks) { return true; }
+    };
+    scopedFS().setDelegator(delegator);
+
+    // We shouldn't follow final-segment links, so they should never invoke the delegator.
+    delegator.setState(false);
+    assertTrue(fileLink.isSymbolicLink());
+    assertTrue(delegator.lastPath() == null);
+
+    assertFalseWithPathCheck(dirLink.getRelative("a").isSymbolicLink(), delegator,
+        dirLinkTarget.getRelative("a"));
+
+    delegator.setState(true);
+    assertTrueWithPathCheck(dirLink.getRelative("a").isSymbolicLink(), delegator,
+        dirLinkTarget.getRelative("a"));
+  }
+
+  /**
+   * Returns a test delegator that reflects info passed to Path.exists() calls.
+   */
+  private TestDelegator newExistsDelegator() {
+    return new TestDelegator() {
+      @Override protected boolean exists(Path path, boolean followSymlinks) {
+        lastPath = path;
+        return booleanState();
+      }
+      @Override protected FileStatus stat(Path path, boolean followSymlinks) throws IOException {
+        if (!exists(path, followSymlinks)) {
+          throw new IOException("Expected exception on stat of non-existent file");
+        }
+        return super.stat(path, followSymlinks);
+      }
+      @Override protected long getLastModifiedTime(Path path, boolean followSymlinks) { return 0; }
+    };
+  }
+
+  @Test
+  public void testExistsCallOnEscapingSymlink() throws Exception {
+    TestDelegator delegator = newExistsDelegator();
+    scopedFS().setDelegator(delegator);
+
+    delegator.setState(false);
+    assertFalseWithPathCheck(fileLink.exists(), delegator, fileLinkTarget);
+    assertFalseWithPathCheck(dirLink.getRelative("a").exists(), delegator,
+        dirLinkTarget.getRelative("a"));
+
+    delegator.setState(true);
+    assertTrueWithPathCheck(fileLink.exists(), delegator, fileLinkTarget);
+    assertTrueWithPathCheck(dirLink.getRelative("a").exists(), delegator,
+        dirLinkTarget.getRelative("a"));
+  }
+
+  @Test
+  public void testCreateDirectoryCallOnEscapingSymlink() throws Exception {
+    TestDelegator delegator = new TestDelegator() {
+      @Override protected boolean createDirectory(Path path) {
+        lastPath = path;
+        return booleanState();
+      }
+      @Override protected boolean isDirectory(Path path, boolean followSymlinks) { return true; }
+    };
+    scopedFS().setDelegator(delegator);
+
+    delegator.setState(false);
+    assertFalseWithPathCheck(dirLink.getRelative("a").createDirectory(), delegator,
+        dirLinkTarget.getRelative("a"));
+
+    delegator.setState(true);
+    assertTrueWithPathCheck(dirLink.getRelative("a").createDirectory(), delegator,
+        dirLinkTarget.getRelative("a"));
+  }
+
+  @Test
+  public void testDeleteCallOnEscapingSymlink() throws Exception {
+    TestDelegator delegator = new TestDelegator() {
+      @Override protected boolean delete(Path path) {
+        lastPath = path;
+        return booleanState();
+      }
+      @Override protected boolean isDirectory(Path path, boolean followSymlinks) { return true; }
+      @Override protected long getLastModifiedTime(Path path, boolean followSymlinks) { return 0; }
+    };
+    scopedFS().setDelegator(delegator);
+
+    delegator.setState(false);
+    assertTrue(fileLink.delete());
+    assertTrue(delegator.lastPath() == null);  // Deleting a link shouldn't require delegation.
+    assertFalseWithPathCheck(dirLink.getRelative("a").delete(), delegator,
+        dirLinkTarget.getRelative("a"));
+
+    delegator.setState(true);
+    assertTrueWithPathCheck(dirLink.getRelative("a").delete(), delegator,
+        dirLinkTarget.getRelative("a"));
+  }
+
+  @Test
+  public void testCallGetFileSizeOnEscapingSymlink() throws Exception {
+    TestDelegator delegator = new TestDelegator() {
+      @Override protected long getFileSize(Path path, boolean followSymlinks) {
+        lastPath = path;
+        return longState();
+      }
+      @Override protected long getLastModifiedTime(Path path, boolean followSymlinks) { return 0; }
+    };
+    scopedFS().setDelegator(delegator);
+
+    final int state1 = 10;
+    delegator.setState(state1);
+    assertEquals(state1, fileLink.getFileSize());
+    checkPath(delegator, fileLinkTarget);
+    assertEquals(state1, dirLink.getRelative("a").getFileSize());
+    checkPath(delegator, dirLinkTarget.getRelative("a"));
+
+    final int state2 = 10;
+    delegator.setState(state2);
+    assertEquals(state2, fileLink.getFileSize());
+    checkPath(delegator, fileLinkTarget);
+    assertEquals(state2, dirLink.getRelative("a").getFileSize());
+    checkPath(delegator, dirLinkTarget.getRelative("a"));
+   }
+
+  @Test
+  public void testCallGetLastModifiedTimeOnEscapingSymlink() throws Exception {
+    TestDelegator delegator = new TestDelegator() {
+      @Override protected long getLastModifiedTime(Path path, boolean followSymlinks) {
+        lastPath = path;
+        return longState();
+      }
+    };
+    scopedFS().setDelegator(delegator);
+
+    final int state1 = 10;
+    delegator.setState(state1);
+    assertEquals(state1, fileLink.getLastModifiedTime());
+    checkPath(delegator, fileLinkTarget);
+    assertEquals(state1, dirLink.getRelative("a").getLastModifiedTime());
+    checkPath(delegator, dirLinkTarget.getRelative("a"));
+
+    final int state2 = 10;
+    delegator.setState(state2);
+    assertEquals(state2, fileLink.getLastModifiedTime());
+    checkPath(delegator, fileLinkTarget);
+    assertEquals(state2, dirLink.getRelative("a").getLastModifiedTime());
+    checkPath(delegator, dirLinkTarget.getRelative("a"));
+  }
+
+  @Test
+  public void testCallSetReadableOnEscapingSymlink() throws Exception {
+    TestDelegator delegator = new TestDelegator() {
+      @Override protected void setReadable(Path path, boolean readable) {
+        lastPath = path;
+        setState(readable);
+      }
+    };
+    scopedFS().setDelegator(delegator);
+
+    delegator.setState(false);
+    fileLink.setReadable(true);
+    assertTrue(delegator.booleanState());
+    checkPath(delegator, fileLinkTarget);
+    fileLink.setReadable(false);
+    assertFalse(delegator.booleanState());
+    checkPath(delegator, fileLinkTarget);
+
+    delegator.setState(false);
+    dirLink.getRelative("a").setReadable(true);
+    assertTrue(delegator.booleanState());
+    checkPath(delegator, dirLinkTarget.getRelative("a"));
+    dirLink.getRelative("a").setReadable(false);
+    assertFalse(delegator.booleanState());
+    checkPath(delegator, dirLinkTarget.getRelative("a"));
+  }
+
+  @Test
+  public void testCallSetWritableOnEscapingSymlink() throws Exception {
+    TestDelegator delegator = new TestDelegator() {
+      @Override protected void setWritable(Path path, boolean writable) {
+        lastPath = path;
+        setState(writable);
+      }
+    };
+    scopedFS().setDelegator(delegator);
+
+    delegator.setState(false);
+    fileLink.setWritable(true);
+    assertTrue(delegator.booleanState());
+    checkPath(delegator, fileLinkTarget);
+    fileLink.setWritable(false);
+    assertFalse(delegator.booleanState());
+    checkPath(delegator, fileLinkTarget);
+
+    delegator.setState(false);
+    dirLink.getRelative("a").setWritable(true);
+    assertTrue(delegator.booleanState());
+    checkPath(delegator, dirLinkTarget.getRelative("a"));
+    dirLink.getRelative("a").setWritable(false);
+    assertFalse(delegator.booleanState());
+    checkPath(delegator, dirLinkTarget.getRelative("a"));
+  }
+
+  @Test
+  public void testCallSetExecutableOnEscapingSymlink() throws Exception {
+    TestDelegator delegator = new TestDelegator() {
+      @Override protected void setReadable(Path path, boolean readable) {
+        lastPath = path;
+        setState(readable);
+      }
+    };
+    scopedFS().setDelegator(delegator);
+
+    delegator.setState(false);
+    fileLink.setReadable(true);
+    assertTrue(delegator.booleanState());
+    checkPath(delegator, fileLinkTarget);
+    fileLink.setReadable(false);
+    assertFalse(delegator.booleanState());
+    checkPath(delegator, fileLinkTarget);
+
+    delegator.setState(false);
+    dirLink.getRelative("a").setReadable(true);
+    assertTrue(delegator.booleanState());
+    checkPath(delegator, dirLinkTarget.getRelative("a"));
+    dirLink.getRelative("a").setReadable(false);
+    assertFalse(delegator.booleanState());
+    checkPath(delegator, dirLinkTarget.getRelative("a"));
+  }
+
+  @Test
+  public void testCallSetLastModifiedTimeOnEscapingSymlink() throws Exception {
+    TestDelegator delegator = new TestDelegator() {
+      @Override protected void setLastModifiedTime(Path path, long newTime) {
+        lastPath = path;
+        setState(newTime);
+      }
+    };
+    scopedFS().setDelegator(delegator);
+
+    delegator.setState(0);
+    fileLink.setLastModifiedTime(10);
+    assertEquals(10, delegator.longState());
+    checkPath(delegator, fileLinkTarget);
+    fileLink.setLastModifiedTime(15);
+    assertEquals(15, delegator.longState());
+    checkPath(delegator, fileLinkTarget);
+
+    dirLink.getRelative("a").setLastModifiedTime(20);
+    assertEquals(20, delegator.longState());
+    checkPath(delegator, dirLinkTarget.getRelative("a"));
+    dirLink.getRelative("a").setLastModifiedTime(25);
+    assertEquals(25, delegator.longState());
+    checkPath(delegator, dirLinkTarget.getRelative("a"));
+  }
+
+  @Test
+  public void testCallRenameToOnEscapingSymlink() throws Exception {
+    TestDelegator delegator = new TestDelegator() {
+      @Override protected void renameTo(Path sourcePath, Path targetPath) {
+        lastPath = sourcePath;
+        setState(targetPath);
+      }
+      @Override protected boolean isDirectory(Path path, boolean followSymlinks) { return true; }
+    };
+    scopedFS().setDelegator(delegator);
+
+    // Renaming a link should work fine.
+    delegator.setState(null);
+    fileLink.renameTo(testFS.getPath(SCOPE_ROOT).getRelative("newname"));
+    assertEquals(null, delegator.lastPath());  // Renaming a link shouldn't require delegation.
+    assertEquals(null, delegator.objectState());
+
+    // Renaming an out-of-scope path to an in-scope path should fail due to filesystem mismatch
+    // errors.
+    Path newPath = testFS.getPath(SCOPE_ROOT.getRelative("blah"));
+    try {
+      dirLink.getRelative("a").renameTo(newPath);
+      fail("This is an attempt at a cross-filesystem renaming, which should fail");
+    } catch (IOException e) {
+      // Expected.
+    }
+
+    // Renaming an out-of-scope path to another out-of-scope path can be valid.
+    newPath = dirLink.getRelative("b");
+    dirLink.getRelative("a").renameTo(newPath);
+    assertEquals(dirLinkTarget.getRelative("a"), delegator.lastPath());
+    assertEquals(dirLinkTarget.getRelative("b"), ((Path) delegator.objectState()).asFragment());
+  }
+
+  @Test
+  public void testCallCreateSymbolicLinkOnEscapingSymlink() throws Exception {
+    TestDelegator delegator = new TestDelegator() {
+      @Override protected void createSymbolicLink(Path linkPath, PathFragment targetFragment) {
+        lastPath = linkPath;
+        setState(targetFragment);
+      }
+      @Override protected boolean isDirectory(Path path, boolean followSymlinks) { return true; }
+    };
+    scopedFS().setDelegator(delegator);
+
+    PathFragment newLinkTarget = new PathFragment("/something/else");
+    dirLink.getRelative("a").createSymbolicLink(newLinkTarget);
+    assertEquals(dirLinkTarget.getRelative("a"), delegator.lastPath());
+    assertSame(newLinkTarget, delegator.objectState());
+  }
+
+  @Test
+  public void testCallReadSymbolicLinkOnEscapingSymlink() throws Exception {
+    TestDelegator delegator = new TestDelegator() {
+      @Override protected PathFragment readSymbolicLink(Path path) {
+        lastPath = path;
+        return (PathFragment) objectState;
+      }
+      @Override protected boolean isDirectory(Path path, boolean followSymlinks) { return true; }
+    };
+    scopedFS().setDelegator(delegator);
+
+    // Since we're not following the link, this shouldn't invoke delegation.
+    delegator.setState(new PathFragment("whatever"));
+    PathFragment p = fileLink.readSymbolicLink();
+    assertEquals(null, delegator.lastPath());
+    assertNotSame(delegator.objectState(), p);
+
+    // This should.
+    p = dirLink.getRelative("a").readSymbolicLink();
+    assertEquals(dirLinkTarget.getRelative("a"), delegator.lastPath());
+    assertSame(delegator.objectState(), p);
+  }
+
+  @Test
+  public void testCallGetInputStreamOnEscapingSymlink() throws Exception {
+    TestDelegator delegator = new TestDelegator() {
+      @Override protected InputStream getInputStream(Path path) {
+        lastPath = path;
+        return (InputStream) objectState;
+      }
+    };
+    scopedFS().setDelegator(delegator);
+
+    delegator.setState(new ByteArrayInputStream("blah".getBytes()));
+    InputStream is = fileLink.getInputStream();
+    assertEquals(fileLinkTarget, delegator.lastPath());
+    assertSame(delegator.objectState(), is);
+
+    delegator.setState(new ByteArrayInputStream("blah2".getBytes()));
+    is = dirLink.getInputStream();
+    assertEquals(dirLinkTarget, delegator.lastPath());
+    assertSame(delegator.objectState(), is);
+  }
+
+  @Test
+  public void testCallGetOutputStreamOnEscapingSymlink() throws Exception {
+    TestDelegator delegator = new TestDelegator() {
+      @Override protected OutputStream getOutputStream(Path path, boolean append)  {
+        lastPath = path;
+        return (OutputStream) objectState;
+      }
+      @Override protected boolean isDirectory(Path path, boolean followSymlinks) { return true; }
+    };
+    scopedFS().setDelegator(delegator);
+
+    delegator.setState(new ByteArrayOutputStream());
+    OutputStream os = fileLink.getOutputStream();
+    assertEquals(fileLinkTarget, delegator.lastPath());
+    assertSame(delegator.objectState(), os);
+
+    delegator.setState(new ByteArrayOutputStream());
+    os = dirLink.getOutputStream();
+    assertEquals(dirLinkTarget, delegator.lastPath());
+    assertSame(delegator.objectState(), os);
+  }
+
+  @Test
+  public void testCallGetDirectoryEntriesOnEscapingSymlink() throws Exception {
+    TestDelegator delegator = new TestDelegator() {
+      @Override protected Collection<Path> getDirectoryEntries(Path path) {
+        lastPath = path;
+        return ImmutableList.of((Path) objectState);
+      }
+      @Override protected boolean isDirectory(Path path, boolean followSymlinks) { return true; }
+    };
+    scopedFS().setDelegator(delegator);
+
+    delegator.setState(testFS.getPath("/anything"));
+    Collection<Path> entries = dirLink.getDirectoryEntries();
+    assertEquals(dirLinkTarget, delegator.lastPath());
+    assertEquals(1, entries.size());
+    assertSame(delegator.objectState(), entries.iterator().next());
+  }
+
+  /**
+   * Asserts that "link" is an in-scope link that doesn't result in an out-of-FS
+   * delegation. If link is relative, its path is relative to SCOPE_ROOT.
+   *
+   * Note that we don't actually check that the canonicalized target path matches
+   * the link's target value. Such testing should be covered by
+   * SymlinkAwareFileSystemTest.
+   */
+  private void assertInScopeLink(String link, String target, TestDelegator d) throws IOException {
+    Path l = testFS.getPath(SCOPE_ROOT.getRelative(link));
+    testFS.createSymbolicLink(l, new PathFragment(target));
+    l.exists();
+    assertNull(d.lastPath());
+  }
+
+  /**
+   * Asserts that "link" is an out-of-scope link and that the re-delegated path
+   * matches expectedPath. If link is relative, its path is relative to SCOPE_ROOT.
+   */
+  private void assertOutOfScopeLink(String link, String target, String expectedPath,
+      TestDelegator d) throws IOException {
+    Path l = testFS.getPath(SCOPE_ROOT.getRelative(link));
+    testFS.createSymbolicLink(l, new PathFragment(target));
+    l.exists();
+    assertEquals(expectedPath, d.lastPath().getPathString());
+  }
+
+  /**
+   * Returns the scope root with the final n segments chopped off (or a 0-segment path
+   * if n > SCOPE_ROOT.segmentCount()).
+   */
+  private String chopScopeRoot(int n) {
+    return SCOPE_ROOT
+        .subFragment(0, n > SCOPE_ROOT.segmentCount() ? 0 : SCOPE_ROOT.segmentCount() - n)
+        .getPathString();
+  }
+
+  /**
+   * Tests that absolute symlinks with ".." and "." segments are delegated to
+   * the expected paths.
+   */
+  @Test
+  public void testAbsoluteSymlinksWithParentReferences() throws Exception {
+    TestDelegator d = newExistsDelegator();
+    scopedFS().setDelegator(d);
+    testFS.createDirectory(testFS.getPath(SCOPE_ROOT.getRelative("dir")));
+    String scopeRoot = SCOPE_ROOT.getPathString();
+    String scopeBase = SCOPE_ROOT.getBaseName();
+
+    // Symlinks that should never escape our scope.
+    assertInScopeLink("ilink1", scopeRoot, d);
+    assertInScopeLink("ilink2", scopeRoot + "/target", d);
+    assertInScopeLink("ilink3", scopeRoot + "/dir/../target", d);
+    assertInScopeLink("ilink4", scopeRoot + "/dir/../dir/dir2/../target", d);
+    assertInScopeLink("ilink5", scopeRoot + "/./dir/.././target", d);
+    assertInScopeLink("ilink6", scopeRoot + "/../" + scopeBase + "/target", d);
+    assertInScopeLink("ilink7", "/some/path/../.." + scopeRoot + "/target", d);
+
+    // Symlinks that should escape our scope.
+    assertOutOfScopeLink("olink1", scopeRoot + "/../target", chopScopeRoot(1) + "/target", d);
+    assertOutOfScopeLink("olink2", "/some/other/path", "/some/other/path", d);
+    assertOutOfScopeLink("olink3", scopeRoot + "/../target", chopScopeRoot(1) + "/target", d);
+    assertOutOfScopeLink("olink4", chopScopeRoot(1) + "/target", chopScopeRoot(1) + "/target", d);
+    assertOutOfScopeLink("olink5", scopeRoot + "/../../../../target", "/target", d);
+
+    // In-scope symlink that's not the final segment in a query.
+    Path iDirLink = testFS.getPath(SCOPE_ROOT.getRelative("ilinkdir"));
+    testFS.createSymbolicLink(iDirLink, SCOPE_ROOT.getRelative("dir"));
+    iDirLink.getRelative("file").exists();
+    assertNull(d.lastPath());
+
+    // Out-of-scope symlink that's not the final segment in a query.
+    Path oDirLink = testFS.getPath(SCOPE_ROOT.getRelative("olinkdir"));
+    testFS.createSymbolicLink(oDirLink, new PathFragment("/some/other/dir"));
+    oDirLink.getRelative("file").exists();
+    assertEquals("/some/other/dir/file", d.lastPath().getPathString());
+  }
+
+  /**
+   * Tests that relative symlinks with ".." and "." segments are delegated to
+   * the expected paths.
+   */
+  @Test
+  public void testRelativeSymlinksWithParentReferences() throws Exception {
+    TestDelegator d = newExistsDelegator();
+    scopedFS().setDelegator(d);
+    testFS.createDirectory(testFS.getPath(SCOPE_ROOT.getRelative("dir")));
+    testFS.createDirectory(testFS.getPath(SCOPE_ROOT.getRelative("dir/dir2")));
+    testFS.createDirectory(testFS.getPath(SCOPE_ROOT.getRelative("dir/dir2/dir3")));
+    String scopeRoot = SCOPE_ROOT.getPathString();
+    String scopeBase = SCOPE_ROOT.getBaseName();
+
+    // Symlinks that should never escape our scope.
+    assertInScopeLink("ilink1", "target", d);
+    assertInScopeLink("ilink2", "dir/../otherdir/target", d);
+    assertInScopeLink("dir/ilink3", "../target", d);
+    assertInScopeLink("dir/dir2/ilink4", "../../target", d);
+    assertInScopeLink("dir/dir2/ilink5", ".././../dir/./target", d);
+    assertInScopeLink("dir/dir2/ilink6", "../dir2/../../dir/dir2/dir3/../../../target", d);
+
+    // Symlinks that should escape our scope.
+    assertOutOfScopeLink("olink1", "../target", chopScopeRoot(1) + "/target", d);
+    assertOutOfScopeLink("dir/olink2", "../../target", chopScopeRoot(1) + "/target", d);
+    assertOutOfScopeLink("olink3", "../" + scopeBase + "/target", scopeRoot + "/target", d);
+    assertOutOfScopeLink("dir/dir2/olink5", "../../../target", chopScopeRoot(1) + "/target", d);
+    assertOutOfScopeLink("dir/dir2/olink6", "../dir2/../../dir/dir2/../../../target",
+        chopScopeRoot(1) + "/target", d);
+    assertOutOfScopeLink("dir/olink7", "../../../target", chopScopeRoot(2) + "target", d);
+    assertOutOfScopeLink("olink8", "../../../../../target", "/target", d);
+
+    // In-scope symlink that's not the final segment in a query.
+    Path iDirLink = testFS.getPath(SCOPE_ROOT.getRelative("dir/dir2/ilinkdir"));
+    testFS.createSymbolicLink(iDirLink, new PathFragment("../../dir"));
+    iDirLink.getRelative("file").exists();
+    assertNull(d.lastPath());
+
+    // Out-of-scope symlink that's not the final segment in a query.
+    Path oDirLink = testFS.getPath(SCOPE_ROOT.getRelative("dir/dir2/olinkdir"));
+    testFS.createSymbolicLink(oDirLink, new PathFragment("../../../other/dir"));
+    oDirLink.getRelative("file").exists();
+    assertEquals(chopScopeRoot(1) + "/other/dir/file", d.lastPath().getPathString());
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/SymlinkAwareFileSystemTest.java b/src/test/java/com/google/devtools/build/lib/vfs/SymlinkAwareFileSystemTest.java
new file mode 100644
index 0000000..a728c88
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/vfs/SymlinkAwareFileSystemTest.java
@@ -0,0 +1,717 @@
+// Copyright 2014 Google Inc. 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.vfs;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.devtools.build.lib.testutil.MoreAsserts;
+import com.google.devtools.build.lib.vfs.FileSystem.NotASymlinkException;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.Collection;
+
+/**
+ * This class handles the generic tests that any filesystem must pass.
+ *
+ * <p>Each filesystem-test should inherit from this class, thereby obtaining
+ * all the tests.
+ */
+public abstract class SymlinkAwareFileSystemTest extends FileSystemTest {
+
+  protected Path xLinkToFile;
+  protected Path xLinkToLinkToFile;
+  protected Path xLinkToDirectory;
+  protected Path xDanglingLink;
+
+  @Override
+  @Before
+  public void setUp() throws Exception {
+    super.setUp();
+
+    // % ls -lR
+    // -rw-rw-r-- xFile
+    // drwxrwxr-x xNonEmptyDirectory
+    // -rw-rw-r-- xNonEmptyDirectory/foo
+    // drwxrwxr-x xEmptyDirectory
+    // lrwxrwxr-x xLinkToFile -> xFile
+    // lrwxrwxr-x xLinkToDirectory -> xEmptyDirectory
+    // lrwxrwxr-x xLinkToLinkToFile -> xLinkToFile
+    // lrwxrwxr-x xDanglingLink -> xNothing
+
+    xLinkToFile = absolutize("xLinkToFile");
+    xLinkToLinkToFile = absolutize("xLinkToLinkToFile");
+    xLinkToDirectory = absolutize("xLinkToDirectory");
+    xDanglingLink = absolutize("xDanglingLink");
+
+    createSymbolicLink(xLinkToFile, xFile);
+    createSymbolicLink(xLinkToLinkToFile, xLinkToFile);
+    createSymbolicLink(xLinkToDirectory, xEmptyDirectory);
+    createSymbolicLink(xDanglingLink, xNothing);
+  }
+
+  @Test
+  public void testCreateLinkToFile() throws IOException {
+    Path newPath = xEmptyDirectory.getChild("new-file");
+    FileSystemUtils.createEmptyFile(newPath);
+
+    Path linkPath = xEmptyDirectory.getChild("some-link");
+
+    createSymbolicLink(linkPath, newPath);
+
+    assertTrue(linkPath.isSymbolicLink());
+
+    assertTrue(linkPath.isFile());
+    assertFalse(linkPath.isFile(Symlinks.NOFOLLOW));
+    assertTrue(linkPath.isFile(Symlinks.FOLLOW));
+
+    assertFalse(linkPath.isDirectory());
+    assertFalse(linkPath.isDirectory(Symlinks.NOFOLLOW));
+    assertFalse(linkPath.isDirectory(Symlinks.FOLLOW));
+
+    if (supportsSymlinks) {
+      assertEquals(newPath.toString().length(), linkPath.getFileSize(Symlinks.NOFOLLOW));
+      assertEquals(newPath.getFileSize(Symlinks.NOFOLLOW), linkPath.getFileSize());
+    }
+    assertEquals(2,
+                 linkPath.getParentDirectory().getDirectoryEntries().size());
+    assertThat(linkPath.getParentDirectory().getDirectoryEntries()).containsExactly(newPath,
+        linkPath);
+  }
+
+  @Test
+  public void testCreateLinkToDirectory() throws IOException {
+    Path newPath = xEmptyDirectory.getChild("new-file");
+    newPath.createDirectory();
+
+    Path linkPath = xEmptyDirectory.getChild("some-link");
+
+    createSymbolicLink(linkPath, newPath);
+
+    assertTrue(linkPath.isSymbolicLink());
+    assertFalse(linkPath.isFile());
+    assertTrue(linkPath.isDirectory());
+    assertEquals(2,
+                 linkPath.getParentDirectory().getDirectoryEntries().size());
+    assertThat(linkPath.getParentDirectory().
+      getDirectoryEntries()).containsExactly(newPath, linkPath);
+  }
+
+  @Test
+  public void testFileCanonicalPath() throws IOException {
+    Path newPath = absolutize("new-file");
+    FileSystemUtils.createEmptyFile(newPath);
+    newPath = newPath.resolveSymbolicLinks();
+
+    Path link1 = absolutize("some-link");
+    Path link2 = absolutize("some-link2");
+
+    createSymbolicLink(link1, newPath);
+    createSymbolicLink(link2, link1);
+
+    assertCanonicalPathsMatch(newPath, link1, link2);
+  }
+
+  @Test
+  public void testDirectoryCanonicalPath() throws IOException {
+    Path newPath = absolutize("new-folder");
+    newPath.createDirectory();
+    newPath = newPath.resolveSymbolicLinks();
+
+    Path newFile = newPath.getChild("file");
+    FileSystemUtils.createEmptyFile(newFile);
+
+    Path link1 = absolutize("some-link");
+    Path link2 = absolutize("some-link2");
+
+    createSymbolicLink(link1, newPath);
+    createSymbolicLink(link2, link1);
+
+    Path linkFile1 = link1.getChild("file");
+    Path linkFile2 = link2.getChild("file");
+
+    assertCanonicalPathsMatch(newFile, linkFile1, linkFile2);
+  }
+
+  private void assertCanonicalPathsMatch(Path newPath, Path link1, Path link2)
+      throws IOException {
+    assertEquals(newPath, link1.resolveSymbolicLinks());
+    assertEquals(newPath, link2.resolveSymbolicLinks());
+  }
+
+  //
+  //  createDirectory
+  //
+
+  @Test
+  public void testCreateDirectoryWhereDanglingSymlinkAlreadyExists() {
+    try {
+      xDanglingLink.createDirectory();
+      fail();
+    } catch (IOException e) {
+      assertEquals(xDanglingLink + " (File exists)", e.getMessage());
+    }
+    assertTrue(xDanglingLink.isSymbolicLink()); // still a symbolic link
+    assertFalse(xDanglingLink.isDirectory(Symlinks.FOLLOW)); // link still dangles
+  }
+
+  @Test
+  public void testCreateDirectoryWhereSymlinkAlreadyExists() {
+    try {
+      xLinkToDirectory.createDirectory();
+      fail();
+    } catch (IOException e) {
+      assertEquals(xLinkToDirectory + " (File exists)", e.getMessage());
+    }
+    assertTrue(xLinkToDirectory.isSymbolicLink()); // still a symbolic link
+    assertTrue(xLinkToDirectory.isDirectory(Symlinks.FOLLOW)); // link still points to dir
+  }
+
+  //  createSymbolicLink(PathFragment)
+
+  @Test
+  public void testCreateSymbolicLinkFromFragment() throws IOException {
+    String[] linkTargets = {
+      "foo",
+      "foo/bar",
+      ".",
+      "..",
+      "../foo",
+      "../../foo",
+      "../../../../../../../../../../../../../../../../../../../../../foo",
+      "/foo",
+      "/foo/bar",
+      "/..",
+      "/foo/../bar",
+    };
+    Path linkPath = absolutize("link");
+    for (String linkTarget : linkTargets) {
+      PathFragment relative = new PathFragment(linkTarget);
+      linkPath.delete();
+      createSymbolicLink(linkPath, relative);
+      if (supportsSymlinks) {
+        assertEquals(linkTarget.length(), linkPath.getFileSize(Symlinks.NOFOLLOW));
+        assertEquals(relative, linkPath.readSymbolicLink());
+      }
+    }
+  }
+
+  @Test
+  public void testLinkToRootResolvesCorrectly() throws IOException {
+    Path rootPath = testFS.getPath("/");
+    Path linkPath = absolutize("link");
+    createSymbolicLink(linkPath, rootPath);
+
+    // resolveSymbolicLinks requires an existing path:
+    try {
+      linkPath.getRelative("test").resolveSymbolicLinks();
+      fail();
+    } catch (FileNotFoundException e) { /* ok */ }
+
+    // The path may not be a symlink, neither on Darwin nor on Linux.
+    Path rootChild = testFS.getPath("/sbin");
+    if (!rootChild.isDirectory()) {
+      rootChild.createDirectory();
+    }
+    assertEquals(rootChild, linkPath.getRelative("sbin").resolveSymbolicLinks());
+  }
+
+  @Test
+  public void testLinkToFragmentContainingLinkResolvesCorrectly() throws IOException {
+    Path link1 = absolutize("link1");
+    PathFragment link1target = new PathFragment("link2/foo");
+    Path link2 = absolutize("link2");
+    Path link2target = xNonEmptyDirectory;
+
+    createSymbolicLink(link1, link1target); // ln -s link2/foo link1
+    createSymbolicLink(link2, link2target); // ln -s xNonEmptyDirectory link2
+    // link1 --> xNonEmptyDirectory/foo
+    assertEquals(link1.resolveSymbolicLinks(), link2target.getRelative("foo"));
+  }
+
+  //
+  //  readSymbolicLink / resolveSymbolicLinks
+  //
+
+  @Test
+  public void testRecursiveSymbolicLink() throws IOException {
+    Path link = absolutize("recursive-link");
+    createSymbolicLink(link, link);
+
+    if (supportsSymlinks) {
+      try {
+        link.resolveSymbolicLinks();
+        fail();
+      } catch (IOException e) {
+        assertEquals(link + " (Too many levels of symbolic links)",
+                     e.getMessage());
+      }
+    }
+  }
+
+  @Test
+  public void testMutuallyRecursiveSymbolicLinks() throws IOException {
+    Path link1 = absolutize("link1");
+    Path link2 = absolutize("link2");
+    createSymbolicLink(link2, link1);
+    createSymbolicLink(link1, link2);
+
+    if (supportsSymlinks) {
+      try {
+        link1.resolveSymbolicLinks();
+        fail();
+      } catch (IOException e) {
+        assertEquals(link1 + " (Too many levels of symbolic links)", e.getMessage());
+      }
+    }
+  }
+
+  @Test
+  public void testResolveSymbolicLinksENOENT() {
+    if (supportsSymlinks) {
+      try {
+        xDanglingLink.resolveSymbolicLinks();
+        fail();
+      } catch (IOException e) {
+        assertEquals(xNothing + " (No such file or directory)", e.getMessage());
+      }
+    }
+  }
+
+  @Test
+  public void testResolveSymbolicLinksENOTDIR() throws IOException {
+    if (supportsSymlinks) {
+      Path badLinkTarget = xFile.getChild("bad"); // parent is not a directory!
+      Path badLink = absolutize("badLink");
+      createSymbolicLink(badLink, badLinkTarget);
+      try {
+        badLink.resolveSymbolicLinks();
+        fail();
+      } catch (IOException e) {
+        // ok.  Ideally we would assert "(Not a directory)" in the error
+        // message, but that would require yet another stat in the
+        // implementation.
+      }
+    }
+  }
+
+  @Test
+  public void testResolveSymbolicLinksWithUplevelRefs() throws IOException {
+    if (supportsSymlinks) {
+      // Create a series of links that refer to xFile as ./xFile,
+      // ./../foo/xFile, ./../../bar/foo/xFile, etc.  They should all resolve
+      // to xFile.
+      Path ancestor = xFile;
+      String prefix = "./";
+      while ((ancestor = ancestor.getParentDirectory()) != null) {
+        xLinkToFile.delete();
+        createSymbolicLink(xLinkToFile, new PathFragment(prefix + xFile.relativeTo(ancestor)));
+        assertEquals(xFile, xLinkToFile.resolveSymbolicLinks());
+
+        prefix += "../";
+      }
+    }
+  }
+
+  @Test
+  public void testReadSymbolicLink() throws IOException {
+    if (supportsSymlinks) {
+      assertEquals(xNothing.toString(),
+                   xDanglingLink.readSymbolicLink().toString());
+    }
+
+    assertEquals(xFile.toString(),
+                 xLinkToFile.readSymbolicLink().toString());
+
+    assertEquals(xEmptyDirectory.toString(),
+                 xLinkToDirectory.readSymbolicLink().toString());
+
+    try {
+      xFile.readSymbolicLink(); // not a link
+      fail();
+    } catch (NotASymlinkException e) {
+      assertEquals(xFile.toString(), e.getMessage());
+    }
+
+    try {
+      xNothing.readSymbolicLink(); // nothing there
+      fail();
+    } catch (IOException e) {
+      assertEquals(xNothing + " (No such file or directory)", e.getMessage());
+    }
+  }
+
+  @Test
+  public void testCannotCreateSymbolicLinkWithReadOnlyParent()
+      throws IOException {
+    xEmptyDirectory.setWritable(false);
+    Path xChildOfReadonlyDir = xEmptyDirectory.getChild("x");
+    if (supportsSymlinks) {
+      try {
+        xChildOfReadonlyDir.createSymbolicLink(xNothing);
+        fail();
+      } catch (IOException e) {
+        assertEquals(xChildOfReadonlyDir + " (Permission denied)", e.getMessage());
+      }
+    }
+  }
+
+  //
+  // createSymbolicLink
+  //
+
+  @Test
+  public void testCanCreateDanglingLink() throws IOException {
+    Path newPath = absolutize("non-existing-dir/new-file");
+    Path someLink = absolutize("dangling-link");
+    createSymbolicLink(someLink, newPath);
+    assertTrue(someLink.isSymbolicLink());
+    assertTrue(someLink.exists(Symlinks.NOFOLLOW)); // the link itself exists
+    assertFalse(someLink.exists()); // ...but the referent doesn't
+    if (supportsSymlinks) {
+      try {
+        someLink.resolveSymbolicLinks();
+      } catch (FileNotFoundException e) {
+        assertEquals(newPath.getParentDirectory()
+                     + " (No such file or directory)", e.getMessage());
+      }
+    }
+  }
+
+  @Test
+  public void testCannotCreateSymbolicLinkWithoutParent() throws IOException {
+    Path xChildOfMissingDir = xNothing.getChild("x");
+    if (supportsSymlinks) {
+      try {
+        xChildOfMissingDir.createSymbolicLink(xFile);
+        fail();
+      } catch (FileNotFoundException e) {
+        MoreAsserts.assertEndsWith(" (No such file or directory)", e.getMessage());
+      }
+    }
+  }
+
+  @Test
+  public void testCreateSymbolicLinkWhereNothingExists() throws IOException {
+    createSymbolicLink(xNothing, xFile);
+    assertTrue(xNothing.isSymbolicLink());
+  }
+
+  @Test
+  public void testCreateSymbolicLinkWhereDirectoryAlreadyExists() {
+    try {
+      createSymbolicLink(xEmptyDirectory, xFile);
+      fail();
+    } catch (IOException e) { // => couldn't be created
+      assertEquals(xEmptyDirectory + " (File exists)", e.getMessage());
+    }
+    assertTrue(xEmptyDirectory.isDirectory(Symlinks.NOFOLLOW));
+  }
+
+  @Test
+  public void testCreateSymbolicLinkWhereFileAlreadyExists() {
+    try {
+      createSymbolicLink(xFile, xEmptyDirectory);
+      fail();
+    } catch (IOException e) { // => couldn't be created
+      assertEquals(xFile + " (File exists)", e.getMessage());
+    }
+    assertTrue(xFile.isFile(Symlinks.NOFOLLOW));
+  }
+
+  @Test
+  public void testCreateSymbolicLinkWhereDanglingSymlinkAlreadyExists() {
+    try {
+      createSymbolicLink(xDanglingLink, xFile);
+      fail();
+    } catch (IOException e) {
+      assertEquals(xDanglingLink + " (File exists)", e.getMessage());
+    }
+    assertTrue(xDanglingLink.isSymbolicLink()); // still a symbolic link
+    assertFalse(xDanglingLink.isDirectory()); // link still dangles
+  }
+
+  @Test
+  public void testCreateSymbolicLinkWhereSymlinkAlreadyExists() {
+    try {
+      createSymbolicLink(xLinkToDirectory, xNothing);
+      fail();
+    } catch (IOException e) {
+      assertEquals(xLinkToDirectory + " (File exists)", e.getMessage());
+    }
+    assertTrue(xLinkToDirectory.isSymbolicLink()); // still a symbolic link
+    assertTrue(xLinkToDirectory.isDirectory()); // link still points to dir
+  }
+
+  @Test
+  public void testDeleteLink() throws IOException {
+    Path newPath = xEmptyDirectory.getChild("new-file");
+    Path someLink = xEmptyDirectory.getChild("a-link");
+    FileSystemUtils.createEmptyFile(newPath);
+    createSymbolicLink(someLink, newPath);
+
+    assertEquals(xEmptyDirectory.getDirectoryEntries().size(), 2);
+
+    assertTrue(someLink.delete());
+    assertEquals(xEmptyDirectory.getDirectoryEntries().size(), 1);
+
+    assertThat(xEmptyDirectory.getDirectoryEntries()).containsExactly(newPath);
+  }
+
+  // Testing the links
+  @Test
+  public void testLinkFollowedToDirectory() throws IOException {
+    Path theDirectory = absolutize("foo/");
+    assertTrue(theDirectory.createDirectory());
+    Path newPath1 = absolutize("foo/new-file-1");
+    Path newPath2 = absolutize("foo/new-file-2");
+    Path newPath3 = absolutize("foo/new-file-3");
+
+    FileSystemUtils.createEmptyFile(newPath1);
+    FileSystemUtils.createEmptyFile(newPath2);
+    FileSystemUtils.createEmptyFile(newPath3);
+
+    Path linkPath = absolutize("link");
+    createSymbolicLink(linkPath, theDirectory);
+
+    Path resultPath1 = absolutize("link/new-file-1");
+    Path resultPath2 = absolutize("link/new-file-2");
+    Path resultPath3 = absolutize("link/new-file-3");
+    assertThat(linkPath.getDirectoryEntries()).containsExactly(resultPath1, resultPath2,
+        resultPath3);
+  }
+
+  @Test
+  public void testDanglingLinkIsNoFile() throws IOException {
+    Path newPath1 = absolutize("new-file-1");
+    Path newPath2 = absolutize("new-file-2");
+    FileSystemUtils.createEmptyFile(newPath1);
+    assertTrue(newPath2.createDirectory());
+
+    Path linkPath1 = absolutize("link1");
+    Path linkPath2 = absolutize("link2");
+    createSymbolicLink(linkPath1, newPath1);
+    createSymbolicLink(linkPath2, newPath2);
+
+    newPath1.delete();
+    newPath2.delete();
+
+    assertFalse(linkPath1.isFile());
+    assertFalse(linkPath2.isDirectory());
+  }
+
+  @Test
+  public void testWriteOnLinkChangesFile() throws IOException {
+    Path testFile = absolutize("test-file");
+    FileSystemUtils.createEmptyFile(testFile);
+    String testData = "abc19";
+
+    Path testLink = absolutize("a-link");
+    createSymbolicLink(testLink, testFile);
+
+    FileSystemUtils.writeContentAsLatin1(testLink, testData);
+    String resultData =
+      new String(FileSystemUtils.readContentAsLatin1(testFile));
+
+    assertEquals(testData,resultData);
+  }
+
+  //
+  // Symlink tests:
+  //
+
+  @Test
+  public void testExistsWithSymlinks() throws IOException {
+    Path a = absolutize("a");
+    Path b = absolutize("b");
+    FileSystemUtils.createEmptyFile(b);
+    createSymbolicLink(a, b);  // ln -sf "b" "a"
+    assertTrue(a.exists()); // = exists(FOLLOW)
+    assertTrue(b.exists()); // = exists(FOLLOW)
+    assertTrue(a.exists(Symlinks.FOLLOW));
+    assertTrue(b.exists(Symlinks.FOLLOW));
+    assertTrue(a.exists(Symlinks.NOFOLLOW));
+    assertTrue(b.exists(Symlinks.NOFOLLOW));
+    b.delete(); // "a" is now a dangling link
+    assertFalse(a.exists()); // = exists(FOLLOW)
+    assertFalse(b.exists()); // = exists(FOLLOW)
+    assertFalse(a.exists(Symlinks.FOLLOW));
+    assertFalse(b.exists(Symlinks.FOLLOW));
+
+    assertTrue(a.exists(Symlinks.NOFOLLOW)); // symlink still exists
+    assertFalse(b.exists(Symlinks.NOFOLLOW));
+  }
+
+  @Test
+  public void testIsDirectoryWithSymlinks() throws IOException {
+    Path a = absolutize("a");
+    Path b = absolutize("b");
+    b.createDirectory();
+    createSymbolicLink(a, b);  // ln -sf "b" "a"
+    assertTrue(a.isDirectory()); // = isDirectory(FOLLOW)
+    assertTrue(b.isDirectory()); // = isDirectory(FOLLOW)
+    assertTrue(a.isDirectory(Symlinks.FOLLOW));
+    assertTrue(b.isDirectory(Symlinks.FOLLOW));
+    assertFalse(a.isDirectory(Symlinks.NOFOLLOW)); // it's a link!
+    assertTrue(b.isDirectory(Symlinks.NOFOLLOW));
+    b.delete(); // "a" is now a dangling link
+    assertFalse(a.isDirectory()); // = isDirectory(FOLLOW)
+    assertFalse(b.isDirectory()); // = isDirectory(FOLLOW)
+    assertFalse(a.isDirectory(Symlinks.FOLLOW));
+    assertFalse(b.isDirectory(Symlinks.FOLLOW));
+    assertFalse(a.isDirectory(Symlinks.NOFOLLOW));
+    assertFalse(b.isDirectory(Symlinks.NOFOLLOW));
+  }
+
+  @Test
+  public void testIsFileWithSymlinks() throws IOException {
+    Path a = absolutize("a");
+    Path b = absolutize("b");
+    FileSystemUtils.createEmptyFile(b);
+    createSymbolicLink(a, b);  // ln -sf "b" "a"
+    assertTrue(a.isFile()); // = isFile(FOLLOW)
+    assertTrue(b.isFile()); // = isFile(FOLLOW)
+    assertTrue(a.isFile(Symlinks.FOLLOW));
+    assertTrue(b.isFile(Symlinks.FOLLOW));
+    assertFalse(a.isFile(Symlinks.NOFOLLOW)); // it's a link!
+    assertTrue(b.isFile(Symlinks.NOFOLLOW));
+    b.delete(); // "a" is now a dangling link
+    assertFalse(a.isFile()); // = isFile()
+    assertFalse(b.isFile()); // = isFile()
+    assertFalse(a.isFile());
+    assertFalse(b.isFile());
+    assertFalse(a.isFile(Symlinks.NOFOLLOW));
+    assertFalse(b.isFile(Symlinks.NOFOLLOW));
+  }
+
+  @Test
+  public void testGetDirectoryEntriesOnLinkToDirectory() throws Exception {
+    Path fooAlias = xNothing.getChild("foo");
+    createSymbolicLink(xNothing, xNonEmptyDirectory);
+    Collection<Path> dirents = xNothing.getDirectoryEntries();
+    assertThat(dirents).containsExactly(fooAlias);
+  }
+
+  @Test
+  public void testFilesOfLinkedDirectories() throws Exception {
+    Path child = xEmptyDirectory.getChild("child");
+    Path aliasToChild = xLinkToDirectory.getChild("child");
+
+    assertFalse(aliasToChild.exists());
+    FileSystemUtils.createEmptyFile(child);
+    assertTrue(aliasToChild.exists());
+    assertTrue(aliasToChild.isFile());
+    assertFalse(aliasToChild.isDirectory());
+
+    validateLinkedReferenceObeysReadOnly(child, aliasToChild);
+    validateLinkedReferenceObeysExecutable(child, aliasToChild);
+  }
+
+  @Test
+  public void testDirectoriesOfLinkedDirectories() throws Exception {
+    Path childDir = xEmptyDirectory.getChild("childDir");
+    Path linkToChildDir = xLinkToDirectory.getChild("childDir");
+
+    assertFalse(linkToChildDir.exists());
+    childDir.createDirectory();
+    assertTrue(linkToChildDir.exists());
+    assertTrue(linkToChildDir.isDirectory());
+    assertFalse(linkToChildDir.isFile());
+
+    validateLinkedReferenceObeysReadOnly(childDir, linkToChildDir);
+    validateLinkedReferenceObeysExecutable(childDir, linkToChildDir);
+  }
+
+  @Test
+  public void testDirectoriesOfLinkedDirectoriesOfLinkedDirectories() throws Exception {
+    Path childDir = xEmptyDirectory.getChild("childDir");
+    Path linkToLinkToDirectory = absolutize("xLinkToLinkToDirectory");
+    createSymbolicLink(linkToLinkToDirectory, xLinkToDirectory);
+    Path linkToChildDir = linkToLinkToDirectory.getChild("childDir");
+
+    assertFalse(linkToChildDir.exists());
+    childDir.createDirectory();
+    assertTrue(linkToChildDir.exists());
+    assertTrue(linkToChildDir.isDirectory());
+    assertFalse(linkToChildDir.isFile());
+
+    validateLinkedReferenceObeysReadOnly(childDir, linkToChildDir);
+    validateLinkedReferenceObeysExecutable(childDir, linkToChildDir);
+  }
+
+  private void validateLinkedReferenceObeysReadOnly(Path path, Path link) throws IOException {
+    path.setWritable(false);
+    assertFalse(path.isWritable());
+    assertFalse(link.isWritable());
+    path.setWritable(true);
+    assertTrue(path.isWritable());
+    assertTrue(link.isWritable());
+    path.setWritable(false);
+    assertFalse(path.isWritable());
+    assertFalse(link.isWritable());
+  }
+
+  private void validateLinkedReferenceObeysExecutable(Path path, Path link) throws IOException {
+    path.setExecutable(true);
+    assertTrue(path.isExecutable());
+    assertTrue(link.isExecutable());
+    path.setExecutable(false);
+    assertFalse(path.isExecutable());
+    assertFalse(link.isExecutable());
+    path.setExecutable(true);
+    assertTrue(path.isExecutable());
+    assertTrue(link.isExecutable());
+  }
+
+  @Test
+  public void testReadingFileFromLinkedDirectory() throws Exception {
+    Path linkedTo = absolutize("linkedTo");
+    linkedTo.createDirectory();
+    Path child = linkedTo.getChild("child");
+    FileSystemUtils.createEmptyFile(child);
+
+    byte[] outputData = "This is a test".getBytes();
+    FileSystemUtils.writeContent(child, outputData);
+
+    Path link = absolutize("link");
+    createSymbolicLink(link, linkedTo);
+    Path linkedChild = link.getChild("child");
+    byte[] inputData = FileSystemUtils.readContent(linkedChild);
+    assertArrayEquals(outputData, inputData);
+  }
+
+  @Test
+  public void testCreatingFileInLinkedDirectory() throws Exception {
+    Path linkedTo = absolutize("linkedTo");
+    linkedTo.createDirectory();
+    Path child = linkedTo.getChild("child");
+
+    Path link = absolutize("link");
+    createSymbolicLink(link, linkedTo);
+    Path linkedChild = link.getChild("child");
+    byte[] outputData = "This is a test".getBytes();
+    FileSystemUtils.writeContent(linkedChild, outputData);
+
+    byte[] inputData = FileSystemUtils.readContent(child);
+    assertArrayEquals(outputData, inputData);
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/UnionFileSystemTest.java b/src/test/java/com/google/devtools/build/lib/vfs/UnionFileSystemTest.java
new file mode 100644
index 0000000..396a9f8
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/vfs/UnionFileSystemTest.java
@@ -0,0 +1,330 @@
+// Copyright 2014 Google Inc. 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.vfs;
+
+import static com.google.common.truth.Truth.assertThat;
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Iterables;
+import com.google.devtools.build.lib.util.BlazeClock;
+import com.google.devtools.build.lib.util.Clock;
+import com.google.devtools.build.lib.vfs.inmemoryfs.InMemoryFileSystem;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.FileNotFoundException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+/**
+ * Tests for the UnionFileSystem, both of generic FileSystem functionality
+ * (inherited) and tests of UnionFileSystem-specific behavior.
+ */
+@RunWith(JUnit4.class)
+public class UnionFileSystemTest extends SymlinkAwareFileSystemTest {
+  private XAttrInMemoryFs inDelegate;
+  private XAttrInMemoryFs outDelegate;
+  private XAttrInMemoryFs defaultDelegate;
+  private UnionFileSystem unionfs;
+
+  private static final String XATTR_VAL = "SOME_XATTR_VAL";
+  private static final String XATTR_KEY = "SOME_XATTR_KEY";
+
+  private void setupDelegateFileSystems() {
+    inDelegate = new XAttrInMemoryFs(BlazeClock.instance());
+    outDelegate = new XAttrInMemoryFs(BlazeClock.instance());
+    defaultDelegate = new XAttrInMemoryFs(BlazeClock.instance());
+
+    unionfs = createDefaultUnionFileSystem();
+  }
+
+  private UnionFileSystem createDefaultUnionFileSystem() {
+    return createDefaultUnionFileSystem(false);
+  }
+
+  private UnionFileSystem createDefaultUnionFileSystem(boolean readOnly) {
+    return new UnionFileSystem(ImmutableMap.<PathFragment, FileSystem>of(
+        new PathFragment("/in"), inDelegate,
+        new PathFragment("/out"), outDelegate),
+        defaultDelegate, readOnly);
+  }
+
+  @Override
+  protected FileSystem getFreshFileSystem() {
+    // Executed with each new test because it is called by super.setUp().
+    setupDelegateFileSystems();
+    return unionfs;
+  }
+
+  @Override
+  public void destroyFileSystem(FileSystem fileSystem) {
+    // Nothing.
+  }
+
+  // Tests of UnionFileSystem-specific behavior below.
+
+  @Test
+  public void testBasicDelegation() throws Exception {
+    unionfs = createDefaultUnionFileSystem();
+    Path fooPath = unionfs.getPath("/foo");
+    Path inPath = unionfs.getPath("/in");
+    Path outPath = unionfs.getPath("/out/in.txt");
+    assertSame(inDelegate, unionfs.getDelegate(inPath));
+    assertSame(outDelegate, unionfs.getDelegate(outPath));
+    assertSame(defaultDelegate, unionfs.getDelegate(fooPath));
+  }
+
+  @Test
+  public void testBasicXattr() throws Exception {
+    Path fooPath = unionfs.getPath("/foo");
+    Path inPath = unionfs.getPath("/in");
+    Path outPath = unionfs.getPath("/out/in.txt");
+
+    assertArrayEquals(XATTR_VAL.getBytes(UTF_8), inPath.getxattr(XATTR_KEY));
+    assertArrayEquals(XATTR_VAL.getBytes(UTF_8), outPath.getxattr(XATTR_KEY));
+    assertArrayEquals(XATTR_VAL.getBytes(UTF_8), fooPath.getxattr(XATTR_KEY));
+    assertNull(inPath.getxattr("not_key"));
+    assertNull(outPath.getxattr("not_key"));
+    assertNull(fooPath.getxattr("not_key"));
+  }
+
+  @Test
+  public void testDefaultFileSystemRequired() throws Exception {
+    try {
+      new UnionFileSystem(ImmutableMap.<PathFragment, FileSystem>of(), null);
+      fail("Able to create a UnionFileSystem with no default!");
+    } catch (NullPointerException expected) {
+      // OK - should fail in this case.
+    }
+  }
+
+  // Check for appropriate registration and lookup of delegate filesystems based
+  // on path prefixes, including non-canonical paths.
+  @Test
+  public void testPrefixDelegation() throws Exception {
+    unionfs = new UnionFileSystem(ImmutableMap.<PathFragment, FileSystem>of(
+              new PathFragment("/foo"), inDelegate,
+              new PathFragment("/foo/bar"), outDelegate), defaultDelegate);
+
+    assertSame(inDelegate, unionfs.getDelegate(unionfs.getPath("/foo/foo.txt")));
+    assertSame(outDelegate, unionfs.getDelegate(unionfs.getPath("/foo/bar/foo.txt")));
+    assertSame(inDelegate, unionfs.getDelegate(unionfs.getPath("/foo/bar/../foo.txt")));
+    assertSame(defaultDelegate, unionfs.getDelegate(unionfs.getPath("/bar/foo.txt")));
+    assertSame(defaultDelegate, unionfs.getDelegate(unionfs.getPath("/foo/bar/../..")));
+  }
+
+  // Checks that files cannot be modified when the filesystem is created
+  // read-only, even if the delegate filesystems are read/write.
+  @Test
+  public void testModificationFlag() throws Exception {
+    assertTrue(unionfs.supportsModifications());
+    Path outPath = unionfs.getPath("/out/foo.txt");
+    assertTrue(unionfs.createDirectory(outPath.getParentDirectory()));
+    OutputStream outFile = unionfs.getOutputStream(outPath);
+    outFile.write('b');
+    outFile.close();
+
+    unionfs.setExecutable(outPath, true);
+
+    // Note that this does not destroy the underlying filesystems;
+    // UnionFileSystem is just a view.
+    unionfs = createDefaultUnionFileSystem(true);
+    assertFalse(unionfs.supportsModifications());
+
+    InputStream outFileInput = unionfs.getInputStream(outPath);
+    int outFileByte = outFileInput.read();
+    outFileInput.close();
+    assertEquals('b', outFileByte);
+
+    assertTrue(unionfs.isExecutable(outPath));
+
+    // Modifying files through the unionfs isn't permitted, even if the
+    // delegates are read/write.
+    try {
+      unionfs.setExecutable(outPath, false);
+      fail("Modification to a read-only UnionFileSystem succeeded.");
+    } catch (UnsupportedOperationException expected) {
+      // OK - should fail.
+    }
+  }
+
+  // Checks that roots of delegate filesystems are created outside of the
+  // delegate filesystems; i.e. they can be seen from the filesystem of the parent.
+  @Test
+  public void testDelegateRootDirectoryCreation() throws Exception {
+    Path foo = unionfs.getPath("/foo");
+    Path bar = unionfs.getPath("/bar");
+    Path out = unionfs.getPath("/out");
+    assertTrue(unionfs.createDirectory(foo));
+    assertTrue(unionfs.createDirectory(bar));
+    assertTrue(unionfs.createDirectory(out));
+    Path outFile = unionfs.getPath("/out/in");
+    FileSystemUtils.writeContentAsLatin1(outFile, "Out");
+
+    // FileSystemTest.setUp() silently creates the test root on the filesystem...
+    Path testDirUnderRoot = unionfs.getPath(workingDir.asFragment().subFragment(0, 1));
+    assertThat(unionfs.getDirectoryEntries(unionfs.getRootDirectory())).containsExactly(foo, bar,
+        out, testDirUnderRoot);
+    assertThat(unionfs.getDirectoryEntries(out)).containsExactly(outFile);
+
+    assertSame(unionfs.getDelegate(foo), defaultDelegate);
+    assertEquals(foo.asFragment(), unionfs.adjustPath(foo, defaultDelegate).asFragment());
+    assertSame(unionfs.getDelegate(bar), defaultDelegate);
+    assertSame(unionfs.getDelegate(outFile), outDelegate);
+    assertSame(unionfs.getDelegate(out), outDelegate);
+
+    // As a fragment (i.e. without filesystem or root info), the path name should be preserved.
+    assertEquals(outFile.asFragment(), unionfs.adjustPath(outFile, outDelegate).asFragment());
+  }
+
+  // Ensure that the right filesystem is still chosen when paths contain "..".
+  @Test
+  public void testDelegationOfUpLevelReferences() throws Exception {
+    assertSame(defaultDelegate, unionfs.getDelegate(unionfs.getPath("/in/../foo.txt")));
+    assertSame(inDelegate, unionfs.getDelegate(unionfs.getPath("/out/../in")));
+    assertSame(outDelegate, unionfs.getDelegate(unionfs.getPath("/out/../in/../out/foo.txt")));
+    assertSame(inDelegate, unionfs.getDelegate(unionfs.getPath("/in/./foo.txt")));
+  }
+
+  // Basic *explicit* cross-filesystem symlink check.
+  // Note: This does not work implicitly yet, as the next test illustrates.
+  @Test
+  public void testCrossDeviceSymlinks() throws Exception {
+    assertTrue(unionfs.createDirectory(unionfs.getPath("/out")));
+
+    // Create an "/in" directory directly on the output delegate to bypass the
+    // UnionFileSystem's mapping.
+    assertTrue(inDelegate.getPath("/in").createDirectory());
+    OutputStream outStream = inDelegate.getPath("/in/bar.txt").getOutputStream();
+    outStream.write('i');
+    outStream.close();
+
+    Path outFoo = unionfs.getPath("/out/foo");
+    unionfs.createSymbolicLink(outFoo, new PathFragment("../in/bar.txt"));
+    assertTrue(unionfs.stat(outFoo, false).isSymbolicLink());
+
+    try {
+      unionfs.stat(outFoo, true).isFile();
+      fail("Stat on cross-device symlink succeeded!");
+    } catch (FileNotFoundException expected) {
+      // OK
+    }
+
+    Path resolved = unionfs.resolveSymbolicLinks(outFoo);
+    assertSame(unionfs, resolved.getFileSystem());
+    InputStream barInput = resolved.getInputStream();
+    int barChar = barInput.read();
+    barInput.close();
+    assertEquals('i', barChar);
+  }
+
+  @Test
+  public void testNoDelegateLeakage() throws Exception {
+    assertSame(unionfs, unionfs.getPath("/in/foo.txt").getFileSystem());
+    assertSame(unionfs, unionfs.getPath("/in/foo/bar").getParentDirectory().getFileSystem());
+    unionfs.createDirectory(unionfs.getPath("/out"));
+    unionfs.createDirectory(unionfs.getPath("/out/foo"));
+    unionfs.createDirectory(unionfs.getPath("/out/foo/bar"));
+    assertSame(unionfs, Iterables.getOnlyElement(unionfs.getDirectoryEntries(
+        unionfs.getPath("/out/foo"))).getParentDirectory().getFileSystem());
+  }
+
+  // Prefix mappings can apply to files starting with a prefix within a directory.
+  @Test
+  public void testWithinDirectoryMapping() throws Exception {
+    unionfs = new UnionFileSystem(ImmutableMap.<PathFragment, FileSystem>of(
+        new PathFragment("/fruit/a"), inDelegate,
+        new PathFragment("/fruit/b"), outDelegate), defaultDelegate);
+    assertTrue(unionfs.createDirectory(unionfs.getPath("/fruit")));
+    assertTrue(defaultDelegate.getPath("/fruit").isDirectory());
+    assertTrue(inDelegate.getPath("/fruit").createDirectory());
+    assertTrue(outDelegate.getPath("/fruit").createDirectory());
+
+    Path apple = unionfs.getPath("/fruit/apple");
+    Path banana = unionfs.getPath("/fruit/banana");
+    Path cherry = unionfs.getPath("/fruit/cherry");
+    unionfs.createDirectory(apple);
+    unionfs.createDirectory(banana);
+    assertSame(inDelegate, unionfs.getDelegate(apple));
+    assertSame(outDelegate, unionfs.getDelegate(banana));
+    assertSame(defaultDelegate, unionfs.getDelegate(cherry));
+
+    FileSystemUtils.writeContentAsLatin1(apple.getRelative("table"), "penny");
+    FileSystemUtils.writeContentAsLatin1(banana.getRelative("nana"), "nanana");
+    FileSystemUtils.writeContentAsLatin1(cherry, "garcia");
+
+    assertEquals("penny", new String(
+        FileSystemUtils.readContentAsLatin1(inDelegate.getPath("/fruit/apple/table"))));
+    assertEquals("nanana", new String(
+        FileSystemUtils.readContentAsLatin1(outDelegate.getPath("/fruit/banana/nana"))));
+    assertEquals("garcia", new String(
+        FileSystemUtils.readContentAsLatin1(defaultDelegate.getPath("/fruit/cherry"))));
+  }
+
+  // Write using the VFS through a UnionFileSystem and check that the file can
+  // be read back in the same location using standard Java IO.
+  // There is a similar test in UnixFileSystem, but this is essential to ensure
+  // that paths aren't being remapped in some nasty way on the underlying FS.
+  @Test
+  public void testDelegateOperationsReflectOnLocalFilesystem() throws Exception {
+    unionfs = new UnionFileSystem(ImmutableMap.<PathFragment, FileSystem>of(
+        workingDir.getParentDirectory().asFragment(), new UnixFileSystem()),
+        defaultDelegate, false);
+    // This is a child of the current tmpdir, and doesn't exist on its own.
+    // It would be created in setup(), but of course, that didn't use a UnixFileSystem.
+    unionfs.createDirectory(workingDir);
+    Path testFile = unionfs.getPath(workingDir.getRelative("test_file").asFragment());
+    assertTrue(testFile.asFragment().startsWith(workingDir.asFragment()));
+    String testString = "This is a test file";
+    FileSystemUtils.writeContentAsLatin1(testFile, testString);
+    try {
+      assertEquals(testString, new String(FileSystemUtils.readContentAsLatin1(testFile)));
+    } finally {
+      testFile.delete();
+      assertTrue(unionfs.delete(workingDir));
+    }
+  }
+
+  // Regression test for [UnionFS: Directory creation across mapping fails.]
+  @Test
+  public void testCreateParentsAcrossMapping() throws Exception {
+    unionfs = new UnionFileSystem(ImmutableMap.<PathFragment, FileSystem>of(
+        new PathFragment("/out/dir"), outDelegate), defaultDelegate, false);
+    Path outDir = unionfs.getPath("/out/dir/biz/bang");
+    FileSystemUtils.createDirectoryAndParents(outDir);
+    assertTrue(outDir.isDirectory());
+  }
+
+  private static class XAttrInMemoryFs extends InMemoryFileSystem {
+    public XAttrInMemoryFs(Clock clock) {
+      super(clock);
+    }
+
+    @Override
+    protected byte[] getxattr(Path path, String name, boolean followSymlinks) {
+      assertSame(this, path.getFileSystem());
+      return (name.equals(XATTR_KEY)) ? XATTR_VAL.getBytes(UTF_8) : null;
+    }
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/UnixFileSystemTest.java b/src/test/java/com/google/devtools/build/lib/vfs/UnixFileSystemTest.java
new file mode 100644
index 0000000..0ded404
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/vfs/UnixFileSystemTest.java
@@ -0,0 +1,63 @@
+// Copyright 2014 Google Inc. 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.vfs;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.fail;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.IOException;
+
+/**
+ * Tests for the {@link UnixFileSystem} class.
+ */
+@RunWith(JUnit4.class)
+public class UnixFileSystemTest extends SymlinkAwareFileSystemTest {
+
+  @Override
+  protected FileSystem getFreshFileSystem() {
+    return new UnixFileSystem();
+  }
+
+  @Override
+  public void destroyFileSystem(FileSystem fileSystem) {
+    // Nothing.
+  }
+
+  @Override
+  protected void expectNotFound(Path path) throws IOException {
+    assertNull(path.statIfFound());
+  }
+
+  // Most tests are just inherited from FileSystemTest.
+
+  @Test
+  public void testCircularSymlinkFound() throws Exception {
+    Path linkA = absolutize("link-a");
+    Path linkB = absolutize("link-b");
+    linkA.createSymbolicLink(linkB);
+    linkB.createSymbolicLink(linkA);
+    assertFalse(linkA.exists(Symlinks.FOLLOW));
+    try {
+      linkA.statIfFound(Symlinks.FOLLOW);
+      fail();
+    } catch (IOException expected) {
+      // Expected.
+    }
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/UnixPathEqualityTest.java b/src/test/java/com/google/devtools/build/lib/vfs/UnixPathEqualityTest.java
new file mode 100644
index 0000000..f5f58e2
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/vfs/UnixPathEqualityTest.java
@@ -0,0 +1,118 @@
+// Copyright 2014 Google Inc. 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.vfs;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * This tests how canonical paths and non-canonical paths are equal with each
+ * other, and also how paths from different filesystems behave with each other.
+ */
+@RunWith(JUnit4.class)
+public class UnixPathEqualityTest {
+
+  private FileSystem otherUnixFs;
+  private FileSystem unixFs;
+
+  @Before
+  public void setUp() throws Exception {
+    unixFs = new UnixFileSystem();
+    otherUnixFs = new UnixFileSystem();
+    assertTrue(unixFs != otherUnixFs);
+  }
+
+  private void assertTwoWayEquals(Object obj1, Object obj2) {
+    assertTrue(obj1.equals(obj2));
+    assertTrue(obj2.equals(obj1));
+    assertEquals(obj1.hashCode(), obj2.hashCode());
+  }
+
+  private void assertTwoWayNotEquals(Object obj1, Object obj2) {
+    assertFalse(obj1.equals(obj2));
+    assertFalse(obj2.equals(obj1));
+  }
+
+  @Test
+  public void testPathsAreEqualEvenIfNotCanonical() {
+    // This path is already canonical, so there's no difference between
+    // the canonical / nonCanonical path, as far as equals is concerned
+    Path nonCanonical = unixFs.getPath("/a/canonical/unix/path");
+    Path canonical = unixFs.getPath("/a/canonical/unix/path");
+    assertTwoWayEquals(nonCanonical, canonical);
+  }
+
+  @Test
+  public void testPathsAreNeverEqualWithStrings() {
+    // Make sure that paths aren't equal to plain old strings
+    Path nonCanonical = unixFs.getPath("/a/non/../canonical/unix/path");
+    Path canonical = unixFs.getPath("/a/non/../canonical/unix/path");
+    assertTwoWayNotEquals(nonCanonical, "/a/non/../canonical/unix/path");
+    assertTwoWayNotEquals(canonical, "/a/non/../canonical/unix/path");
+  }
+
+  @Test
+  public void testCanonicalPathsFromDifferentFileSystemsAreNeverEqual() {
+    Path canonical = unixFs.getPath("/canonical/path");
+    Path otherCanonical = otherUnixFs.getPath("/canonical/path");
+    assertTwoWayNotEquals(canonical, otherCanonical);
+  }
+
+  @Test
+  public void testNonCanonicalPathsFromDifferentFileSystemsAreNeverEqual() {
+    Path nonCanonical = unixFs.getPath("/non/canonical/path");
+    Path otherNonCanonical = otherUnixFs.getPath("/non/canonical/path");
+    assertTwoWayNotEquals(nonCanonical, otherNonCanonical);
+  }
+
+  @Test
+  public void testCrossFilesystemStartsWithReturnsFalse() {
+    assertFalse(unixFs.getPath("/a").startsWith(otherUnixFs.getPath("/b")));
+  }
+
+  @Test
+  public void testCrossFilesystemOperationsForbidden() throws Exception {
+    Path a = unixFs.getPath("/a");
+    Path b = otherUnixFs.getPath("/b");
+
+    try {
+      a.renameTo(b);
+      fail();
+    } catch (IllegalArgumentException e) {
+      assertThat(e.getMessage()).contains("different filesystems");
+    }
+
+    try {
+      a.relativeTo(b);
+      fail();
+    } catch (IllegalArgumentException e) {
+      assertThat(e.getMessage()).contains("different filesystems");
+    }
+
+    try {
+      a.createSymbolicLink(b);
+      fail();
+    } catch (IllegalArgumentException e) {
+      assertThat(e.getMessage()).contains("different filesystems");
+    }
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/UnixPathGetParentTest.java b/src/test/java/com/google/devtools/build/lib/vfs/UnixPathGetParentTest.java
new file mode 100644
index 0000000..0f679c3
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/vfs/UnixPathGetParentTest.java
@@ -0,0 +1,87 @@
+// Copyright 2014 Google Inc. 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.vfs;
+
+import static org.junit.Assert.assertEquals;
+
+import com.google.devtools.build.lib.testutil.TestUtils;
+import com.google.devtools.build.lib.vfs.util.FileSystems;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.IOException;
+
+/**
+ * A test for {@link Path} in the context of {@link UnixFileSystem}.
+ */
+@RunWith(JUnit4.class)
+public class UnixPathGetParentTest {
+
+  private FileSystem unixFs;
+  private Path testRoot;
+
+  @Before
+  public void setUp() throws Exception {
+    unixFs = FileSystems.initDefaultAsNative();
+    testRoot = unixFs.getPath(TestUtils.tmpDir()).getRelative("UnixPathGetParentTest");
+    FileSystemUtils.createDirectoryAndParents(testRoot);
+  }
+
+  @After
+  public void tearDown() throws Exception {
+    FileSystemUtils.deleteTree(testRoot); // (comment out during debugging)
+  }
+
+  private Path getParent(String path) {
+    return unixFs.getPath(path).getParentDirectory();
+  }
+
+  @Test
+  public void testAbsoluteRootHasNoParent() {
+    assertEquals(null, getParent("/"));
+  }
+
+  @Test
+  public void testParentOfSimpleDirectory() {
+    assertEquals("/foo", getParent("/foo/bar").getPathString());
+  }
+
+  @Test
+  public void testParentOfDotDotInMiddleOfPathname() {
+    assertEquals("/", getParent("/foo/../bar").getPathString());
+  }
+
+  @Test
+  public void testGetPathDoesNormalizationWithoutIO() throws IOException {
+    Path tmp = testRoot.getChild("tmp");
+    Path tmpWiz = tmp.getChild("wiz");
+
+    tmp.createDirectory();
+
+    // ln -sf /tmp /tmp/wiz
+    tmpWiz.createSymbolicLink(tmp);
+
+    assertEquals(testRoot, tmp.getParentDirectory());
+
+    assertEquals(tmp, tmpWiz.getParentDirectory());
+
+    // Under UNIX, inode(/tmp/wiz/..) == inode(/).  However getPath() does not
+    // perform I/O, only string operations, so it disagrees:
+    assertEquals(tmp, tmp.getRelative(new PathFragment("wiz/..")));
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/UnixPathTest.java b/src/test/java/com/google/devtools/build/lib/vfs/UnixPathTest.java
new file mode 100644
index 0000000..b593367
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/vfs/UnixPathTest.java
@@ -0,0 +1,279 @@
+// Copyright 2014 Google Inc. 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.vfs;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.Lists;
+import com.google.devtools.build.lib.testutil.TestUtils;
+import com.google.devtools.build.lib.vfs.util.FileSystems;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+
+/**
+ * Tests for {@link Path}.
+ */
+@RunWith(JUnit4.class)
+public class UnixPathTest {
+
+  private FileSystem unixFs;
+  private File aDirectory;
+  private File aFile;
+  private File anotherFile;
+  private File tmpDir;
+
+  protected FileSystem getUnixFileSystem() {
+    return FileSystems.initDefaultAsNative();
+  }
+
+  @Before
+  public void setUp() throws Exception {
+    unixFs = getUnixFileSystem();
+    tmpDir = new File(TestUtils.tmpDir(), "tmpDir");
+    tmpDir.mkdirs();
+    aDirectory = new File(tmpDir, "a_directory");
+    aDirectory.mkdirs();
+    aFile = new File(tmpDir, "a_file");
+    new FileWriter(aFile).close();
+    anotherFile = new File(aDirectory, "another_file.txt");
+    new FileWriter(anotherFile).close();
+  }
+
+  @Test
+  public void testExists() {
+    assertTrue(unixFs.getPath(aDirectory.getPath()).exists());
+    assertTrue(unixFs.getPath(aFile.getPath()).exists());
+    assertFalse(unixFs.getPath("/does/not/exist").exists());
+  }
+
+  @Test
+  public void testDirectoryEntriesForDirectory() throws IOException {
+    Collection<Path> entries =
+        unixFs.getPath(tmpDir.getPath()).getDirectoryEntries();
+    List<Path> expectedEntries = Arrays.asList(
+      unixFs.getPath(tmpDir.getPath() + "/a_file"),
+      unixFs.getPath(tmpDir.getPath() + "/a_directory"));
+
+    assertEquals(new HashSet<Object>(expectedEntries),
+        new HashSet<Object>(entries));
+  }
+
+  @Test
+  public void testDirectoryEntriesForFileThrowsException() {
+    try {
+      unixFs.getPath(aFile.getPath()).getDirectoryEntries();
+      fail("No exception thrown.");
+    } catch (IOException x) {
+      // The expected result.
+    }
+  }
+
+  @Test
+  public void testIsFileIsTrueForFile() {
+    assertTrue(unixFs.getPath(aFile.getPath()).isFile());
+  }
+
+  @Test
+  public void testIsFileIsFalseForDirectory() {
+    assertFalse(unixFs.getPath(aDirectory.getPath()).isFile());
+  }
+
+  @Test
+  public void testBaseName() {
+    assertEquals("base", unixFs.getPath("/foo/base").getBaseName());
+  }
+
+  @Test
+  public void testBaseNameRunsAfterDotDotInterpretation() {
+    assertEquals("base", unixFs.getPath("/base/foo/..").getBaseName());
+  }
+
+  @Test
+  public void testParentOfRootIsRoot() {
+    assertEquals(unixFs.getPath("/"), unixFs.getPath("/.."));
+    assertEquals(unixFs.getPath("/"), unixFs.getPath("/../../../../../.."));
+    assertEquals(unixFs.getPath("/foo"), unixFs.getPath("/../../../foo"));
+  }
+
+  @Test
+  public void testIsDirectory() {
+    assertTrue(unixFs.getPath(aDirectory.getPath()).isDirectory());
+    assertFalse(unixFs.getPath(aFile.getPath()).isDirectory());
+    assertFalse(unixFs.getPath("/does/not/exist").isDirectory());
+  }
+
+  @Test
+  public void testListNonExistingDirectoryThrowsException() {
+    try {
+      unixFs.getPath("/does/not/exist").getDirectoryEntries();
+      fail("No exception thrown.");
+    } catch (IOException ex) {
+      // success!
+    }
+  }
+
+  private void assertPathSet(Collection<Path> actual, String... expected) {
+    List<String> actualStrings = Lists.newArrayListWithCapacity(actual.size());
+
+    for (Path path : actual) {
+      actualStrings.add(path.getPathString());
+    }
+
+    assertThat(actualStrings).containsExactlyElementsIn(Arrays.asList(expected));
+  }
+
+  @Test
+  public void testGlob() throws Exception {
+    Collection<Path> textFiles = UnixGlob.forPath(unixFs.getPath(tmpDir.getPath()))
+        .addPattern("*/*.txt")
+        .globInterruptible();
+    assertEquals(1, textFiles.size());
+    Path onlyFile = textFiles.iterator().next();
+    assertEquals(unixFs.getPath(anotherFile.getPath()), onlyFile);
+
+    Collection<Path> onlyFiles =
+        UnixGlob.forPath(unixFs.getPath(tmpDir.getPath()))
+        .addPattern("*")
+        .setExcludeDirectories(true)
+        .globInterruptible();
+    assertPathSet(onlyFiles, aFile.getPath());
+
+    Collection<Path> directoriesToo =
+        UnixGlob.forPath(unixFs.getPath(tmpDir.getPath()))
+        .addPattern("*")
+        .setExcludeDirectories(false)
+        .globInterruptible();
+    assertPathSet(directoriesToo, aFile.getPath(), aDirectory.getPath());
+  }
+
+  @Test
+  public void testGetRelative() {
+    Path relative = unixFs.getPath("/foo").getChild("bar");
+    Path expected = unixFs.getPath("/foo/bar");
+    assertEquals(expected, relative);
+  }
+
+  @Test
+  public void testEqualsAndHash() {
+    Path path = unixFs.getPath("/foo/bar");
+    Path equalPath = unixFs.getPath("/foo/bar");
+    Path differentPath = unixFs.getPath("/foo/bar/baz");
+    Object differentType = new Object();
+
+    assertEquals(path.hashCode(), equalPath.hashCode());
+    assertEquals(path, equalPath);
+    assertFalse(path.equals(differentPath));
+    assertFalse(path.equals(differentType));
+  }
+
+  @Test
+  public void testLatin1ReadAndWrite() throws IOException {
+    char[] allLatin1Chars = new char[256];
+    for (int i = 0; i < 256; i++) {
+      allLatin1Chars[i] = (char) i;
+    }
+    Path path = unixFs.getPath(aFile.getPath());
+    String latin1String = new String(allLatin1Chars);
+    FileSystemUtils.writeContentAsLatin1(path, latin1String);
+    String fileContent = new String(FileSystemUtils.readContentAsLatin1(path));
+    assertEquals(fileContent, latin1String);
+  }
+
+  /**
+   * Verify that the encoding implemented by
+   * {@link FileSystemUtils#writeContentAsLatin1(Path, String)}
+   * really is 8859-1 (latin1).
+   */
+  @Test
+  public void testVerifyLatin1() throws IOException {
+    char[] allLatin1Chars = new char[256];
+    for( int i = 0; i < 256; i++) {
+      allLatin1Chars[i] = (char)i;
+    }
+    Path path = unixFs.getPath(aFile.getPath());
+    String latin1String = new String(allLatin1Chars);
+    FileSystemUtils.writeContentAsLatin1(path, latin1String);
+    byte[] bytes = FileSystemUtils.readContent(path);
+    assertEquals(new String(bytes, "ISO-8859-1"), latin1String);
+  }
+
+  @Test
+  public void testBytesReadAndWrite() throws IOException {
+    byte[] bytes = new byte[] { (byte) 0xdeadbeef, (byte) 0xdeadbeef>>8,
+                                (byte) 0xdeadbeef>>16, (byte) 0xdeadbeef>>24 };
+    Path path = unixFs.getPath(aFile.getPath());
+    FileSystemUtils.writeContent(path, bytes);
+    byte[] content = FileSystemUtils.readContent(path);
+    assertEquals(bytes.length, content.length);
+    for (int i = 0; i < bytes.length; i++) {
+      assertEquals(bytes[i], content[i]);
+    }
+  }
+
+  @Test
+  public void testInputOutputStreams() throws IOException {
+    Path path = unixFs.getPath(aFile.getPath());
+    OutputStream out = path.getOutputStream();
+    for (int i = 0; i < 256; i++) {
+      out.write(i);
+    }
+    out.close();
+    InputStream in = path.getInputStream();
+    for (int i = 0; i < 256; i++) {
+      assertEquals(i, in.read());
+    }
+    assertEquals(-1, in.read());
+    in.close();
+  }
+
+  @Test
+  public void testAbsolutePathRoot() {
+    assertEquals("/", new Path(null).toString());
+  }
+
+  @Test
+  public void testAbsolutePath() {
+    Path segment = new Path(null, "bar.txt",
+      new Path(null, "foo", new Path(null)));
+    assertEquals("/foo/bar.txt", segment.toString());
+  }
+
+  @Test
+  public void testDerivedSegmentEquality() {
+    Path absoluteSegment = new Path(null);
+
+    Path derivedNode = absoluteSegment.getChild("derivedSegment");
+    Path otherDerivedNode = absoluteSegment.getChild("derivedSegment");
+
+    assertSame(derivedNode, otherDerivedNode);
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/ZipFileSystemTest.java b/src/test/java/com/google/devtools/build/lib/vfs/ZipFileSystemTest.java
new file mode 100644
index 0000000..9dc1276
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/vfs/ZipFileSystemTest.java
@@ -0,0 +1,233 @@
+// Copyright 2014 Google Inc. 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.vfs;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.Lists;
+import com.google.common.io.CharStreams;
+import com.google.devtools.build.lib.testutil.BlazeTestUtils;
+import com.google.devtools.build.lib.testutil.TestConstants;
+import com.google.devtools.build.lib.vfs.util.FileSystems;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+@RunWith(JUnit4.class)
+public class ZipFileSystemTest {
+
+  /**
+   * Expected listing of sample zip files, in alpha sorted order
+   */
+  private static final String[] LISTING = {
+    "/dir1",
+    "/dir1/file1a",
+    "/dir1/file1b",
+    "/dir2",
+    "/dir2/dir3",
+    "/dir2/dir3/dir4",
+    "/dir2/dir3/dir4/file4",
+    "/dir2/file2",
+    "/file0",
+  };
+
+  private FileSystem zipFS1;
+  private FileSystem zipFS2;
+
+  @Before
+  public void setUp() throws Exception {
+    FileSystem unixFs = FileSystems.initDefaultAsNative();
+    Path testdataDir = unixFs.getPath(BlazeTestUtils.runfilesDir()).getRelative(
+        TestConstants.JAVATESTS_ROOT + "/com/google/devtools/build/lib/vfs");
+    Path zPath1 = testdataDir.getChild("sample_with_dirs.zip");
+    Path zPath2 = testdataDir.getChild("sample_without_dirs.zip");
+    zipFS1 = new ZipFileSystem(zPath1);
+    zipFS2 = new ZipFileSystem(zPath2);
+  }
+
+  private void checkExists(FileSystem fs) {
+    assertTrue(fs.getPath("/dir2/dir3/dir4").exists());
+    assertTrue(fs.getPath("/dir2/dir3/dir4/file4").exists());
+    assertFalse(fs.getPath("/dir2/dir3/dir4/bogus").exists());
+  }
+
+  @Test
+  public void testExists() {
+    checkExists(zipFS1);
+    checkExists(zipFS2);
+  }
+
+  private void checkIsFile(FileSystem fs) {
+    assertFalse(fs.getPath("/dir2/dir3/dir4").isFile());
+    assertTrue(fs.getPath("/dir2/dir3/dir4/file4").isFile());
+    assertFalse(fs.getPath("/dir2/dir3/dir4/bogus").isFile());
+  }
+
+  @Test
+  public void testIsFile() {
+    checkIsFile(zipFS1);
+    checkIsFile(zipFS2);
+  }
+
+  private void checkIsDir(FileSystem fs) {
+    assertTrue(fs.getPath("/dir2/dir3/dir4").isDirectory());
+    assertFalse(fs.getPath("/dir2/dir3/dir4/file4").isDirectory());
+    assertFalse(fs.getPath("/bogus/mobogus").isDirectory());
+    assertFalse(fs.getPath("/bogus").isDirectory());
+  }
+
+  @Test
+  public void testIsDir() {
+    checkIsDir(zipFS1);
+    checkIsDir(zipFS2);
+  }
+
+  /**
+   * Recursively add the contents of a given path, rendered as strings, into a
+   * given list.
+   */
+  private static void listChildren(Path p, List<String> list)
+      throws IOException {
+    for (Path c : p.getDirectoryEntries()) {
+      list.add(c.getPathString());
+      if (c.isDirectory()) {
+        listChildren(c, list);
+      }
+    }
+  }
+
+  private void checkListing(FileSystem fs) throws Exception {
+    List<String> list = new ArrayList<>();
+    listChildren(fs.getRootDirectory(), list);
+    Collections.sort(list);
+    assertEquals(Lists.newArrayList(LISTING), list);
+  }
+
+  @Test
+  public void testListing() throws Exception {
+    checkListing(zipFS1);
+    checkListing(zipFS2);
+
+    // Regression test for: creation of a path (i.e. a file *name*)
+    // must not affect the result of getDirectoryEntries().
+    zipFS1.getPath("/dir1/notthere");
+    checkListing(zipFS1);
+  }
+
+  private void checkFileSize(FileSystem fs, String name, long expectedSize)
+      throws IOException {
+    assertEquals(expectedSize, fs.getPath(name).getFileSize());
+  }
+
+  @Test
+  public void testCanReadRoot() {
+    Path rootDirectory = zipFS1.getRootDirectory();
+    assertTrue(rootDirectory.isDirectory());
+  }
+
+  @Test
+  public void testFileSize() throws IOException {
+    checkFileSize(zipFS1, "/dir1/file1a", 5);
+    checkFileSize(zipFS2, "/dir1/file1a", 5);
+    checkFileSize(zipFS1, "/dir2/dir3/dir4/file4", 5000);
+    checkFileSize(zipFS2, "/dir2/dir3/dir4/file4", 5000);
+  }
+
+  private void checkCantGetFileSize(FileSystem fs, String name) {
+    try {
+      fs.getPath(name).getFileSize();
+      fail();
+    } catch (IOException expected) {
+      // expected
+    }
+  }
+
+  @Test
+  public void testCantGetFileSize() {
+    checkCantGetFileSize(zipFS1, "/dir2/dir3/dir4/bogus");
+    checkCantGetFileSize(zipFS2, "/dir2/dir3/dir4/bogus");
+  }
+
+  private void checkOpenFile(FileSystem fs, String name, int expectedSize)
+      throws Exception {
+    InputStream is = fs.getPath(name).getInputStream();
+    List<String> lines = CharStreams.readLines(new InputStreamReader(is, "ISO-8859-1"));
+    assertEquals(expectedSize, lines.size());
+    for (int i = 0; i < expectedSize; i++) {
+      assertEquals("body", lines.get(i));
+    }
+  }
+
+  @Test
+  public void testOpenSmallFile() throws Exception {
+    checkOpenFile(zipFS1, "/dir1/file1a", 1);
+    checkOpenFile(zipFS2, "/dir1/file1a", 1);
+  }
+
+  @Test
+  public void testOpenBigFile() throws Exception {
+    checkOpenFile(zipFS1, "/dir2/dir3/dir4/file4", 1000);
+    checkOpenFile(zipFS2, "/dir2/dir3/dir4/file4", 1000);
+  }
+
+  private void checkCantOpenFile(FileSystem fs, String name) {
+    try {
+      fs.getPath(name).getInputStream();
+      fail();
+    } catch (IOException expected) {
+      // expected
+    }
+  }
+
+  @Test
+  public void testCantOpenFile() throws Exception {
+    checkCantOpenFile(zipFS1, "/dir2/dir3/dir4/bogus");
+    checkCantOpenFile(zipFS2, "/dir2/dir3/dir4/bogus");
+  }
+
+  private void checkCantCreateAnything(FileSystem fs, String name)  {
+    Path p = fs.getPath(name);
+    try {
+      p.createDirectory();
+      fail();
+    } catch (Exception expected) {}
+    try {
+      FileSystemUtils.createEmptyFile(p);
+      fail();
+    } catch (Exception expected) {}
+    try {
+      p.createSymbolicLink(p);
+      fail();
+    } catch (Exception expected) {}
+  }
+
+  @Test
+  public void testCantCreateAnything() throws Exception {
+    checkCantCreateAnything(zipFS1, "/dir2/dir3/dir4/new");
+    checkCantCreateAnything(zipFS2, "/dir2/dir3/dir4/new");
+  }
+
+}
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/inmemoryfs/InMemoryContentInfoTest.java b/src/test/java/com/google/devtools/build/lib/vfs/inmemoryfs/InMemoryContentInfoTest.java
new file mode 100644
index 0000000..dbdd64a
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/vfs/inmemoryfs/InMemoryContentInfoTest.java
@@ -0,0 +1,73 @@
+// Copyright 2014 Google Inc. 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.vfs.inmemoryfs;
+
+import static org.junit.Assert.fail;
+
+import com.google.devtools.build.lib.util.BlazeClock;
+import com.google.devtools.build.lib.util.Clock;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class InMemoryContentInfoTest {
+
+  private Clock clock;
+
+  @Before
+  public void setUp() throws Exception {
+    clock = BlazeClock.instance();
+  }
+
+  @Test
+  public void testDirectoryCannotAddNullChild() {
+    InMemoryDirectoryInfo directory = new InMemoryDirectoryInfo(clock);
+
+    try {
+      directory.addChild("bar", null);
+      fail("NullPointerException not thrown.");
+    } catch (NullPointerException e) {
+      // success.
+    }
+  }
+
+  @Test
+  public void testDirectoryCannotAddChildTwice() {
+    InMemoryDirectoryInfo directory = new InMemoryDirectoryInfo(clock);
+    InMemoryFileInfo otherFile = new InMemoryFileInfo(clock);
+    directory.addChild("bar", otherFile);
+
+    try {
+      directory.addChild("bar", otherFile);
+      fail("IllegalArgumentException not thrown.");
+    } catch (IllegalArgumentException e) {
+      // success.
+    }
+  }
+
+  @Test
+  public void testDirectoryRemoveNonExistingChild() {
+    InMemoryDirectoryInfo directory = new InMemoryDirectoryInfo(clock);
+    try {
+      directory.removeChild("bar");
+      fail();
+    } catch (IllegalArgumentException e) {
+      // success
+    }
+  }
+
+}
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/inmemoryfs/InMemoryFileSystemTest.java b/src/test/java/com/google/devtools/build/lib/vfs/inmemoryfs/InMemoryFileSystemTest.java
new file mode 100644
index 0000000..65ea6f6
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/vfs/inmemoryfs/InMemoryFileSystemTest.java
@@ -0,0 +1,414 @@
+// Copyright 2014 Google Inc. 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.vfs.inmemoryfs;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import com.google.common.collect.Lists;
+import com.google.devtools.build.lib.testutil.TestThread;
+import com.google.devtools.build.lib.util.BlazeClock;
+import com.google.devtools.build.lib.vfs.FileSystem;
+import com.google.devtools.build.lib.vfs.Path;
+import com.google.devtools.build.lib.vfs.PathFragment;
+import com.google.devtools.build.lib.vfs.ScopeEscapableFileSystemTest;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.nio.charset.Charset;
+import java.util.Collection;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * Tests for {@link InMemoryFileSystem}. Note that most tests are inherited
+ * from {@link ScopeEscapableFileSystemTest} and ancestors. This specific
+ * file focuses only on concurrency tests.
+ *
+ */
+@RunWith(JUnit4.class)
+public class InMemoryFileSystemTest extends ScopeEscapableFileSystemTest {
+
+  @Override
+  public FileSystem getFreshFileSystem() {
+    return new InMemoryFileSystem(BlazeClock.instance(), SCOPE_ROOT);
+  }
+
+  @Override
+  public void destroyFileSystem(FileSystem fileSystem) {
+    // Nothing.
+  }
+
+  private static final int NUM_THREADS_FOR_CONCURRENCY_TESTS = 10;
+  private static final String TEST_FILE_DATA = "data";
+
+  /**
+   * Writes the given data to the given file.
+   */
+  private static void writeToFile(Path path, String data) throws IOException {
+    OutputStream out = path.getOutputStream();
+    out.write(data.getBytes(Charset.defaultCharset()));
+    out.close();
+  }
+
+  /**
+   * Tests concurrent creation of a substantial tree hierarchy including
+   * files, directories, symlinks, file contents, and permissions.
+   */
+  @Test
+  public void testConcurrentTreeConstruction() throws Exception {
+    final int NUM_TO_WRITE = 10000;
+    final AtomicInteger baseSelector = new AtomicInteger();
+
+    // 1) Define the intended path structure.
+    class PathCreator extends TestThread {
+      @Override
+      public void runTest() throws Exception {
+        Path base = testFS.getPath("/base" + baseSelector.getAndIncrement());
+        base.createDirectory();
+
+        for (int i = 0; i < NUM_TO_WRITE; i++) {
+          Path subdir1 = base.getRelative("subdir1_" + i);
+          subdir1.createDirectory();
+          Path subdir2 = base.getRelative("subdir2_" + i);
+          subdir2.createDirectory();
+
+          Path file = base.getRelative("somefile" + i);
+          writeToFile(file, TEST_FILE_DATA);
+
+          subdir1.setReadable(true);
+          subdir2.setReadable(false);
+          file.setReadable(true);
+
+          subdir1.setWritable(false);
+          subdir2.setWritable(true);
+          file.setWritable(false);
+
+          subdir1.setExecutable(false);
+          subdir2.setExecutable(true);
+          file.setExecutable(false);
+
+          subdir1.setLastModifiedTime(100);
+          subdir2.setLastModifiedTime(200);
+          file.setLastModifiedTime(300);
+
+          Path symlink = base.getRelative("symlink" + i);
+          symlink.createSymbolicLink(file);
+        }
+      }
+    }
+
+    // 2) Construct the tree.
+    Collection<TestThread> threads =
+        Lists.newArrayListWithCapacity(NUM_THREADS_FOR_CONCURRENCY_TESTS);
+    for (int i = 0; i < NUM_THREADS_FOR_CONCURRENCY_TESTS; i++) {
+      TestThread thread = new PathCreator();
+      thread.start();
+      threads.add(thread);
+    }
+    for (TestThread thread : threads) {
+      thread.joinAndAssertState(0);
+    }
+
+    // 3) Define the validation logic.
+    class PathValidator extends TestThread {
+      @Override
+      public void runTest() throws Exception {
+        Path base = testFS.getPath("/base" + baseSelector.getAndIncrement());
+        assertTrue(base.exists());
+        assertFalse(base.getRelative("notreal").exists());
+
+        for (int i = 0; i < NUM_TO_WRITE; i++) {
+          Path subdir1 = base.getRelative("subdir1_" + i);
+          assertTrue(subdir1.exists());
+          assertTrue(subdir1.isDirectory());
+          assertTrue(subdir1.isReadable());
+          assertFalse(subdir1.isWritable());
+          assertFalse(subdir1.isExecutable());
+          assertEquals(100, subdir1.getLastModifiedTime());
+
+          Path subdir2 = base.getRelative("subdir2_" + i);
+          assertTrue(subdir2.exists());
+          assertTrue(subdir2.isDirectory());
+          assertFalse(subdir2.isReadable());
+          assertTrue(subdir2.isWritable());
+          assertTrue(subdir2.isExecutable());
+          assertEquals(200, subdir2.getLastModifiedTime());
+
+          Path file = base.getRelative("somefile" + i);
+          assertTrue(file.exists());
+          assertTrue(file.isFile());
+          assertTrue(file.isReadable());
+          assertFalse(file.isWritable());
+          assertFalse(file.isExecutable());
+          assertEquals(300, file.getLastModifiedTime());
+          BufferedReader reader = new BufferedReader(
+              new InputStreamReader(file.getInputStream(), Charset.defaultCharset()));
+          assertEquals(TEST_FILE_DATA, reader.readLine());
+          assertEquals(null, reader.readLine());
+
+          Path symlink = base.getRelative("symlink" + i);
+          assertTrue(symlink.exists());
+          assertTrue(symlink.isSymbolicLink());
+          assertEquals(file.asFragment(), symlink.readSymbolicLink());
+        }
+      }
+    }
+
+    // 4) Validate the results.
+    baseSelector.set(0);
+    threads = Lists.newArrayListWithCapacity(NUM_THREADS_FOR_CONCURRENCY_TESTS);
+    for (int i = 0; i < NUM_THREADS_FOR_CONCURRENCY_TESTS; i++) {
+      TestThread thread = new PathValidator();
+      thread.start();
+      threads.add(thread);
+    }
+    for (TestThread thread : threads) {
+      thread.joinAndAssertState(0);
+    }
+  }
+
+  /**
+   * Tests concurrent creation of many files, all within the same directory.
+   */
+  @Test
+  public void testConcurrentDirectoryConstruction() throws Exception {
+   final int NUM_TO_WRITE = 10000;
+    final AtomicInteger baseSelector = new AtomicInteger();
+
+    // 1) Define the intended path structure.
+    class PathCreator extends TestThread {
+      @Override
+      public void runTest() throws Exception {
+        final int threadId = baseSelector.getAndIncrement();
+        Path base = testFS.getPath("/common_dir");
+        base.createDirectory();
+
+        for (int i = 0; i < NUM_TO_WRITE; i++) {
+          Path file = base.getRelative("somefile_" + threadId + "_" + i);
+          writeToFile(file, TEST_FILE_DATA);
+          file.setReadable(i % 2 == 0);
+          file.setWritable(i % 3 == 0);
+          file.setExecutable(i % 4 == 0);
+          file.setLastModifiedTime(i);
+          Path symlink = base.getRelative("symlink_" + threadId + "_" + i);
+          symlink.createSymbolicLink(file);
+        }
+      }
+    }
+
+    // 2) Create the files.
+    Collection<TestThread> threads =
+        Lists.newArrayListWithCapacity(NUM_THREADS_FOR_CONCURRENCY_TESTS);
+    for (int i = 0; i < NUM_THREADS_FOR_CONCURRENCY_TESTS; i++) {
+      TestThread thread = new PathCreator();
+      thread.start();
+      threads.add(thread);
+    }
+    for (TestThread thread : threads) {
+      thread.joinAndAssertState(0);
+    }
+
+    // 3) Define the validation logic.
+    class PathValidator extends TestThread {
+      @Override
+      public void runTest() throws Exception {
+        final int threadId = baseSelector.getAndIncrement();
+        Path base = testFS.getPath("/common_dir");
+        assertTrue(base.exists());
+
+        for (int i = 0; i < NUM_TO_WRITE; i++) {
+          Path file = base.getRelative("somefile_" + threadId + "_" + i);
+          assertTrue(file.exists());
+          assertTrue(file.isFile());
+          assertEquals(i % 2 == 0, file.isReadable());
+          assertEquals(i % 3 == 0, file.isWritable());
+          assertEquals(i % 4 == 0, file.isExecutable());
+          assertEquals(i, file.getLastModifiedTime());
+          if (file.isReadable()) {
+            BufferedReader reader = new BufferedReader(
+                new InputStreamReader(file.getInputStream(), Charset.defaultCharset()));
+            assertEquals(TEST_FILE_DATA, reader.readLine());
+            assertEquals(null, reader.readLine());
+          }
+
+          Path symlink = base.getRelative("symlink_" + threadId + "_" + i);
+          assertTrue(symlink.exists());
+          assertTrue(symlink.isSymbolicLink());
+          assertEquals(file.asFragment(), symlink.readSymbolicLink());
+        }
+      }
+    }
+
+    // 4) Validate the results.
+    baseSelector.set(0);
+    threads = Lists.newArrayListWithCapacity(NUM_THREADS_FOR_CONCURRENCY_TESTS);
+    for (int i = 0; i < NUM_THREADS_FOR_CONCURRENCY_TESTS; i++) {
+      TestThread thread = new PathValidator();
+      thread.start();
+      threads.add(thread);
+    }
+    for (TestThread thread : threads) {
+      thread.joinAndAssertState(0);
+    }
+  }
+
+  /**
+   * Tests concurrent file deletion.
+   */
+  @Test
+  public void testConcurrentDeletion() throws Exception {
+    final int NUM_TO_WRITE = 10000;
+    final AtomicInteger baseSelector = new AtomicInteger();
+
+    final Path base = testFS.getPath("/base");
+    base.createDirectory();
+
+    // 1) Create a bunch of files.
+    for (int i = 0; i < NUM_TO_WRITE; i++) {
+      writeToFile(base.getRelative("file" + i), TEST_FILE_DATA);
+    }
+
+    // 2) Define our deletion strategy.
+    class FileDeleter extends TestThread {
+      @Override
+      public void runTest() throws Exception {
+        for (int i = 0; i < NUM_TO_WRITE / NUM_THREADS_FOR_CONCURRENCY_TESTS; i++) {
+          int whichFile = baseSelector.getAndIncrement();
+          Path file = base.getRelative("file" + whichFile);
+          if (whichFile % 25 != 0) {
+            assertTrue(file.delete());
+          } else {
+            // Throw another concurrent access point into the mix.
+            file.setExecutable(whichFile % 2 == 0);
+          }
+          assertFalse(base.getRelative("doesnotexist" + whichFile).delete());
+        }
+      }
+    }
+
+    // 3) Delete some files.
+    Collection<TestThread> threads =
+        Lists.newArrayListWithCapacity(NUM_THREADS_FOR_CONCURRENCY_TESTS);
+    for (int i = 0; i < NUM_THREADS_FOR_CONCURRENCY_TESTS; i++) {
+      TestThread thread = new FileDeleter();
+      thread.start();
+      threads.add(thread);
+    }
+    for (TestThread thread : threads) {
+      thread.joinAndAssertState(0);
+    }
+
+    // 4) Check the results.
+    for (int i = 0; i < NUM_TO_WRITE; i++) {
+      Path file = base.getRelative("file" + i);
+      if (i % 25 != 0) {
+        assertFalse(file.exists());
+      } else {
+        assertTrue(file.exists());
+        assertEquals(i % 2 == 0, file.isExecutable());
+      }
+    }
+  }
+
+  /**
+   * Tests concurrent file renaming.
+   */
+  @Test
+  public void testConcurrentRenaming() throws Exception {
+    final int NUM_TO_WRITE = 10000;
+    final AtomicInteger baseSelector = new AtomicInteger();
+
+    final Path base = testFS.getPath("/base");
+    base.createDirectory();
+
+    // 1) Create a bunch of files.
+    for (int i = 0; i < NUM_TO_WRITE; i++) {
+      writeToFile(base.getRelative("file" + i), TEST_FILE_DATA);
+    }
+
+    // 2) Define our renaming strategy.
+    class FileDeleter extends TestThread {
+      @Override
+      public void runTest() throws Exception {
+        for (int i = 0; i < NUM_TO_WRITE / NUM_THREADS_FOR_CONCURRENCY_TESTS; i++) {
+          int whichFile = baseSelector.getAndIncrement();
+          Path file = base.getRelative("file" + whichFile);
+          if (whichFile % 25 != 0) {
+            Path newName = base.getRelative("newname" + whichFile);
+            file.renameTo(newName);
+          } else {
+            // Throw another concurrent access point into the mix.
+            file.setExecutable(whichFile % 2 == 0);
+          }
+          assertFalse(base.getRelative("doesnotexist" + whichFile).delete());
+        }
+      }
+    }
+
+    // 3) Rename some files.
+    Collection<TestThread> threads =
+        Lists.newArrayListWithCapacity(NUM_THREADS_FOR_CONCURRENCY_TESTS);
+    for (int i = 0; i < NUM_THREADS_FOR_CONCURRENCY_TESTS; i++) {
+      TestThread thread = new FileDeleter();
+      thread.start();
+      threads.add(thread);
+    }
+    for (TestThread thread : threads) {
+      thread.joinAndAssertState(0);
+    }
+
+    // 4) Check the results.
+    for (int i = 0; i < NUM_TO_WRITE; i++) {
+      Path file = base.getRelative("file" + i);
+      if (i % 25 != 0) {
+        assertFalse(file.exists());
+        assertTrue(base.getRelative("newname" + i).exists());
+      } else {
+        assertTrue(file.exists());
+        assertEquals(i % 2 == 0, file.isExecutable());
+      }
+    }
+  }
+
+  @Test
+  public void testEloop() throws Exception {
+    Path a = testFS.getPath("/a");
+    Path b = testFS.getPath("/b");
+    a.createSymbolicLink(new PathFragment("b"));
+    b.createSymbolicLink(new PathFragment("a"));
+    try {
+      a.stat();
+    } catch (IOException e) {
+      assertEquals("/a (Too many levels of symbolic links)", e.getMessage());
+    }
+  }
+
+  @Test
+  public void testEloopSelf() throws Exception {
+    Path a = testFS.getPath("/a");
+    a.createSymbolicLink(new PathFragment("a"));
+    try {
+      a.stat();
+    } catch (IOException e) {
+      assertEquals("/a (Too many levels of symbolic links)", e.getMessage());
+    }
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/sample_with_dirs.zip b/src/test/java/com/google/devtools/build/lib/vfs/sample_with_dirs.zip
new file mode 100644
index 0000000..22ff63c
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/vfs/sample_with_dirs.zip
Binary files differ
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/sample_without_dirs.zip b/src/test/java/com/google/devtools/build/lib/vfs/sample_without_dirs.zip
new file mode 100644
index 0000000..f3ec5ab
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/vfs/sample_without_dirs.zip
Binary files differ
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/util/FileSystems.java b/src/test/java/com/google/devtools/build/lib/vfs/util/FileSystems.java
new file mode 100644
index 0000000..6a79a2b
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/vfs/util/FileSystems.java
@@ -0,0 +1,93 @@
+// Copyright 2014 Google Inc. 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.vfs.util;
+
+import com.google.devtools.build.lib.concurrent.ThreadSafety.ThreadSafe;
+import com.google.devtools.build.lib.vfs.FileSystem;
+import com.google.devtools.build.lib.vfs.JavaIoFileSystem;
+import com.google.devtools.build.lib.vfs.Path;
+import com.google.devtools.build.lib.vfs.PathFragment;
+import com.google.devtools.build.lib.vfs.UnionFileSystem;
+import com.google.devtools.build.lib.vfs.UnixFileSystem;
+import com.google.devtools.build.lib.vfs.ZipFileSystem;
+
+import java.io.IOException;
+import java.util.Map;
+
+/**
+ * This static file system singleton manages access to a single default
+ * {@link FileSystem} instance created within the methods of this class.
+ */
+@ThreadSafe
+public final class FileSystems {
+
+  private FileSystems() {}
+
+  private static FileSystem defaultFileSystem;
+
+  /**
+   * Initializes the default {@link FileSystem} instance as a platform native
+   * (Unix) file system, creating one iff needed, and returns the instance.
+   *
+   * <p>This method is idempotent as long as the initialization is of the same
+   * type (Native/JavaIo/Union).
+   */
+  public static synchronized FileSystem initDefaultAsNative() {
+    if (!(defaultFileSystem instanceof UnixFileSystem)) {
+      defaultFileSystem = new UnixFileSystem();
+    }
+    return defaultFileSystem;
+  }
+
+  /**
+   * Initializes the default {@link FileSystem} instance as a java.io.File
+   * file system, creating one iff needed, and returns the instance.
+   *
+   * <p>This method is idempotent as long as the initialization is of the same
+   * type (Native/JavaIo/Union).
+   */
+  public static synchronized FileSystem initDefaultAsJavaIo() {
+    if (!(defaultFileSystem instanceof JavaIoFileSystem)) {
+      defaultFileSystem = new JavaIoFileSystem();
+    }
+    return defaultFileSystem;
+  }
+
+  /**
+   * Initializes the default {@link FileSystem} instance as a
+   * {@link UnionFileSystem}, creating one iff needed,
+   * and returns the instance.
+   *
+   * <p>This method is idempotent as long as the initialization is of the same
+   * type (Native/JavaIo/Union).
+   *
+   * @param prefixMapping the desired mapping of path prefixes to delegate file systems
+   * @param rootFileSystem the default file system for paths that don't match any prefix map
+   */
+  public static synchronized FileSystem initDefaultAsUnion(
+      Map<PathFragment, FileSystem> prefixMapping, FileSystem rootFileSystem) {
+    if (!(defaultFileSystem instanceof UnionFileSystem)) {
+      defaultFileSystem = new UnionFileSystem(prefixMapping, rootFileSystem);
+    }
+    return defaultFileSystem;
+  }
+
+  /**
+   * Returns a new instance of a simple {@link FileSystem} implementation that
+   * presents the contents of a zip file as a read-only file system view.
+   */
+  public static FileSystem newZipFileSystem(Path zipFile) throws IOException {
+    return new ZipFileSystem(zipFile);
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/util/FsApparatus.java b/src/test/java/com/google/devtools/build/lib/vfs/util/FsApparatus.java
new file mode 100644
index 0000000..5d93351
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/vfs/util/FsApparatus.java
@@ -0,0 +1,158 @@
+// Copyright 2014 Google Inc. 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.vfs.util;
+
+import com.google.devtools.build.lib.testutil.TestUtils;
+import com.google.devtools.build.lib.util.BlazeClock;
+import com.google.devtools.build.lib.util.StringUtilities;
+import com.google.devtools.build.lib.vfs.FileSystem;
+import com.google.devtools.build.lib.vfs.FileSystemUtils;
+import com.google.devtools.build.lib.vfs.Path;
+import com.google.devtools.build.lib.vfs.inmemoryfs.InMemoryFileSystem;
+
+import junit.framework.AssertionFailedError;
+
+import java.io.File;
+import java.io.IOException;
+
+/**
+ * Base class for a testing apparatus for a scratch filesystem.
+ */
+public class FsApparatus {
+
+  /* ---------- State that the apparatus initializes / operates on --------- */
+  protected FileSystem fileSystem = null;
+  protected Path workingDir = null;
+
+  public static FsApparatus newInMemory() {
+    return new FsApparatus();
+  }
+
+  // TestUtil.getTmpDir is slow, so cache the result here
+  private static final String TMP_DIR =
+      new File(TestUtils.tmpDir(), "bs").toString();
+
+
+  /**
+   * When using a Native file system, absolute paths will be treated as absolute paths on the unix
+   * file system, as opposed to paths relative to the backing temp directory. So for simplicity,
+   * you ought to only use relative paths for FsApparatus#file, FsApparatus#dir, and
+   * FsApparatus#path. Otherwise, be aware of the following issue
+   *
+   *   Path p1 = scratch.path(...);
+   *   Path p2 = scratch.path(p1.getPathString());
+   *
+   * We'd like the invariant that p1.equals(p2) regardless if scratch is in-memory or not, but this
+   * does not hold with our usage of Unix filesystems.
+   */
+  public static FsApparatus newNative() {
+    FileSystem fs = FileSystems.initDefaultAsNative();
+    Path wd = fs.getPath(TMP_DIR);
+
+    try {
+      FileSystemUtils.deleteTree(wd);
+    } catch (IOException e) {
+      throw new AssertionFailedError(e.getMessage());
+    }
+
+    return new FsApparatus(fs, wd);
+  }
+
+  private FsApparatus() {
+    fileSystem = new InMemoryFileSystem(BlazeClock.instance());
+    workingDir = fileSystem.getPath("/");
+  }
+
+  public FsApparatus(FileSystem fs, Path cwd) {
+    fileSystem = fs;
+    workingDir = cwd;
+  }
+
+  public FsApparatus(FileSystem fs) {
+    fileSystem = fs;
+    workingDir = fs.getPath("/");
+  }
+
+  public FileSystem fs() {
+    return fileSystem;
+  }
+
+  /**
+   * Initializes this apparatus (if it hasn't been initialized yet), and creates
+   * a scratch file in the scratch filesystem with the given {@code pathName}
+   * with {@code lines} being its content. The method returns a Path instance
+   * for the scratch file.
+   */
+  public Path file(String pathName, String... lines) throws IOException {
+    Path file = path(pathName);
+    Path parentDir = file.getParentDirectory();
+    if (!parentDir.exists()) {
+      FileSystemUtils.createDirectoryAndParents(parentDir);
+    }
+    if (file.exists()) {
+      throw new IOException("Could not create scratch file (file exists) "
+          + file);
+    }
+    String fileContent = StringUtilities.joinLines(lines);
+    FileSystemUtils.writeContentAsLatin1(file, fileContent);
+    return file;
+  }
+
+  /**
+   * Initializes this apparatus (if it hasn't been initialized yet), and creates
+   * a directory in the scratch filesystem, with the given {@code pathName}.
+   * Creates parent directories as necessary.
+   */
+  public Path dir(String pathName) throws IOException {
+    Path dir = path(pathName);
+    if (!dir.exists()) {
+      FileSystemUtils.createDirectoryAndParents(dir);
+    }
+    if (!dir.isDirectory()) {
+      throw new IOException("Exists, but is not a directory: " + dir);
+    }
+    return dir;
+  }
+
+  /**
+   * Initializes this apparatus (if it hasn't been initialized yet), and returns
+   * a path object describing a file, directory, or symlink pointed at by
+   * {@code pathName}. Note that this will not create any entity in the
+   * filesystem; i.e., the file that the object is describing may not exist in
+   * the filesystem.
+   */
+  public Path path(String pathName) {
+    return workingDir.getRelative(pathName);
+  }
+
+  /**
+   * Create a fresh directory in the system temporary directory, instead of the
+   * testing directory provided by the testing framework. This path is usually
+   * shorter than a path starting with TestUtil.getTmpDir(). We care about the
+   * length because of the path length restriction for Unix local socket files.
+   *
+   * Clients are responsible for deleting the directory after tests.
+   */
+  public Path createUnixTempDir() throws IOException {
+    if (fileSystem instanceof InMemoryFileSystem) {
+      throw new IOException("Can not create Unix temporary directories in "
+                            + "an in-memory file system");
+    }
+    File file = File.createTempFile("scratch", "tmp");
+    final Path path = fileSystem.getPath(file.getAbsolutePath());
+    path.delete();
+    path.createDirectory();
+    return path;
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/skyframe/AllTests.java b/src/test/java/com/google/devtools/build/skyframe/AllTests.java
new file mode 100644
index 0000000..4ea3691
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/skyframe/AllTests.java
@@ -0,0 +1,25 @@
+// Copyright 2014 Google Inc. 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.skyframe;
+
+import com.google.devtools.build.lib.testutil.ClasspathSuite;
+
+import org.junit.runner.RunWith;
+
+/**
+ * Automatically collect the tests annotated with @RunWith in this package and all subpackages.
+ */
+@RunWith(ClasspathSuite.class)
+public class AllTests {
+}
diff --git a/src/test/java/com/google/devtools/build/skyframe/ChainedFunction.java b/src/test/java/com/google/devtools/build/skyframe/ChainedFunction.java
new file mode 100644
index 0000000..4f87bb3
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/skyframe/ChainedFunction.java
@@ -0,0 +1,87 @@
+// Copyright 2014 Google Inc. 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.skyframe;
+
+import com.google.common.base.Preconditions;
+import com.google.devtools.build.skyframe.GraphTester.ValueComputer;
+import com.google.devtools.build.skyframe.ParallelEvaluator.SkyFunctionEnvironment;
+import com.google.devtools.build.skyframe.SkyFunctionException.Transience;
+
+import java.util.concurrent.CountDownLatch;
+
+import javax.annotation.Nullable;
+
+/**
+ * {@link ValueComputer} that can be chained together with others of its type to synchronize the
+ * order in which builders finish.
+ */
+final class ChainedFunction implements SkyFunction {
+  @Nullable private final SkyValue value;
+  @Nullable private final CountDownLatch notifyStart;
+  @Nullable private final CountDownLatch waitToFinish;
+  @Nullable private final CountDownLatch notifyFinish;
+  private final boolean waitForException;
+  private final Iterable<SkyKey> deps;
+
+  ChainedFunction(@Nullable CountDownLatch notifyStart, @Nullable CountDownLatch waitToFinish,
+      @Nullable CountDownLatch notifyFinish, boolean waitForException,
+      @Nullable SkyValue value, Iterable<SkyKey> deps) {
+    this.notifyStart = notifyStart;
+    this.waitToFinish = waitToFinish;
+    this.notifyFinish = notifyFinish;
+    this.waitForException = waitForException;
+    Preconditions.checkState(this.waitToFinish != null || !this.waitForException, value);
+    this.value = value;
+    this.deps = deps;
+  }
+
+  @Override
+  public SkyValue compute(SkyKey key, SkyFunction.Environment env) throws GenericFunctionException,
+      InterruptedException {
+    try {
+      if (notifyStart != null) {
+        notifyStart.countDown();
+      }
+      if (waitToFinish != null) {
+        TrackingAwaiter.waitAndMaybeThrowInterrupt(waitToFinish,
+            key + " timed out waiting to finish");
+        if (waitForException) {
+          SkyFunctionEnvironment skyEnv = (SkyFunctionEnvironment) env;
+          TrackingAwaiter.waitAndMaybeThrowInterrupt(skyEnv.getExceptionLatchForTesting(),
+              key + " timed out waiting for exception");
+        }
+      }
+      for (SkyKey dep : deps) {
+        env.getValue(dep);
+      }
+      if (value == null) {
+        throw new GenericFunctionException(new SomeErrorException("oops"),
+            Transience.PERSISTENT);
+      }
+      if (env.valuesMissing()) {
+        return null;
+      }
+      return value;
+    } finally {
+      if (notifyFinish != null) {
+        notifyFinish.countDown();
+      }
+    }
+  }
+
+  @Override
+  public String extractTag(SkyKey skyKey) {
+    throw new UnsupportedOperationException();
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/skyframe/CycleDeduperTest.java b/src/test/java/com/google/devtools/build/skyframe/CycleDeduperTest.java
new file mode 100644
index 0000000..592d95f
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/skyframe/CycleDeduperTest.java
@@ -0,0 +1,64 @@
+// Copyright 2014 Google Inc. 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.skyframe;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.ImmutableList;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Simple tests for {@link CycleDeduper}. */
+@RunWith(JUnit4.class)
+public class CycleDeduperTest {
+
+  private CycleDeduper<String> cycleDeduper = new CycleDeduper<>();
+
+  @Test
+  public void simple() throws Exception {
+    assertTrue(cycleDeduper.seen(ImmutableList.of("a", "b")));
+    assertFalse(cycleDeduper.seen(ImmutableList.of("a", "b")));
+    assertFalse(cycleDeduper.seen(ImmutableList.of("b", "a")));
+
+    assertTrue(cycleDeduper.seen(ImmutableList.of("a", "b", "c")));
+    assertFalse(cycleDeduper.seen(ImmutableList.of("b", "c", "a")));
+    assertFalse(cycleDeduper.seen(ImmutableList.of("c", "a", "b")));
+    assertTrue(cycleDeduper.seen(ImmutableList.of("b", "a", "c")));
+    assertFalse(cycleDeduper.seen(ImmutableList.of("c", "b", "a")));
+  }
+
+  @Test
+  public void badCycle_Empty() throws Exception {
+    try {
+      cycleDeduper.seen(ImmutableList.<String>of());
+      fail();
+    } catch (IllegalStateException e) {
+      // Expected.
+    }
+  }
+
+  @Test
+  public void badCycle_NonUniqueMembers() throws Exception {
+    try {
+      cycleDeduper.seen(ImmutableList.<String>of("a", "b", "a"));
+      fail();
+    } catch (IllegalStateException e) {
+      // Expected.
+    }
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/skyframe/CyclesReporterTest.java b/src/test/java/com/google/devtools/build/skyframe/CyclesReporterTest.java
new file mode 100644
index 0000000..35bda02
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/skyframe/CyclesReporterTest.java
@@ -0,0 +1,84 @@
+// Copyright 2014 Google Inc. 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.skyframe;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.collect.ImmutableList;
+import com.google.devtools.build.lib.events.EventHandler;
+import com.google.devtools.build.lib.events.NullEventHandler;
+import com.google.devtools.build.skyframe.CyclesReporter.SingleCycleReporter;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+@RunWith(JUnit4.class)
+public class CyclesReporterTest {
+
+  private static final SkyKey DUMMY_KEY = new SkyKey(SkyFunctionName.computed("func"), "key");
+
+  @Test
+  public void nullEventHandler() {
+    CyclesReporter cyclesReporter = new CyclesReporter();
+    try {
+      cyclesReporter.reportCycles(ImmutableList.<CycleInfo>of(), DUMMY_KEY, null);
+      assertThat(false).isTrue();
+    } catch (NullPointerException e) {
+      // Expected.
+    }
+  }
+
+  @Test
+  public void notReportedAssertion() {
+    SingleCycleReporter singleReporter = new SingleCycleReporter() {
+      @Override
+      public boolean maybeReportCycle(SkyKey topLevelKey, CycleInfo cycleInfo,
+          boolean alreadyReported, EventHandler eventHandler) {
+        return false;
+      }
+    };
+
+    CycleInfo cycleInfo = new CycleInfo(ImmutableList.of(DUMMY_KEY));
+    CyclesReporter cyclesReporter = new CyclesReporter(singleReporter);
+    try {
+      cyclesReporter.reportCycles(ImmutableList.of(cycleInfo), DUMMY_KEY,
+          NullEventHandler.INSTANCE);
+      assertThat(false).isTrue();
+    } catch (IllegalStateException e) {
+      // Expected.
+    }
+  }
+
+  @Test
+  public void smoke() {
+    final AtomicBoolean reported = new AtomicBoolean();
+    SingleCycleReporter singleReporter = new SingleCycleReporter() {
+      @Override
+      public boolean maybeReportCycle(SkyKey topLevelKey, CycleInfo cycleInfo,
+          boolean alreadyReported, EventHandler eventHandler) {
+        reported.set(true);
+        return true;
+      }
+    };
+
+    CycleInfo cycleInfo = new CycleInfo(ImmutableList.of(DUMMY_KEY));
+    CyclesReporter cyclesReporter = new CyclesReporter(singleReporter);
+    cyclesReporter.reportCycles(ImmutableList.of(cycleInfo), DUMMY_KEY,
+        NullEventHandler.INSTANCE);
+    assertThat(reported.get()).isTrue();
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/skyframe/DeterministicInMemoryGraph.java b/src/test/java/com/google/devtools/build/skyframe/DeterministicInMemoryGraph.java
new file mode 100644
index 0000000..8ea81d0
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/skyframe/DeterministicInMemoryGraph.java
@@ -0,0 +1,71 @@
+// Copyright 2014 Google Inc. 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.skyframe;
+
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+/** {@link NotifyingInMemoryGraph} that returns reverse deps ordered alphabetically. */
+public class DeterministicInMemoryGraph extends NotifyingInMemoryGraph {
+  public DeterministicInMemoryGraph(Listener listener) {
+    super(listener);
+  }
+
+  public DeterministicInMemoryGraph() {
+    super(Listener.NULL_LISTENER);
+  }
+
+  @Override
+  protected DeterministicValueEntry getEntry(SkyKey key) {
+    return new DeterministicValueEntry(key);
+  }
+
+  /**
+   * This class uses TreeSet to store reverse dependencies of NodeEntry. As a result all values are
+   * lexicographically sorted.
+   */
+  private class DeterministicValueEntry extends NotifyingNodeEntry {
+    private DeterministicValueEntry(SkyKey myKey) {
+      super(myKey);
+    }
+
+    final Comparator<SkyKey> valueEntryComparator = new Comparator<SkyKey>() {
+      @Override
+      public int compare(SkyKey o1, SkyKey o2) {
+        return o1.toString().compareTo(o2.toString());
+      }
+    };
+    @SuppressWarnings("unchecked")
+    @Override
+    synchronized Iterable<SkyKey> getReverseDeps() {
+      TreeSet<SkyKey> result = new TreeSet<SkyKey>(valueEntryComparator);
+      if (reverseDeps instanceof List) {
+        result.addAll((Collection<? extends SkyKey>) reverseDeps);
+      } else {
+        result.add((SkyKey) reverseDeps);
+      }
+      return result;
+    }
+
+    @Override
+    synchronized Set<SkyKey> getInProgressReverseDeps() {
+      TreeSet<SkyKey> result = new TreeSet<SkyKey>(valueEntryComparator);
+      result.addAll(buildingState.getReverseDepsToSignal());
+      return result;
+    }
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/skyframe/EagerInvalidatorTest.java b/src/test/java/com/google/devtools/build/skyframe/EagerInvalidatorTest.java
new file mode 100644
index 0000000..f12754a
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/skyframe/EagerInvalidatorTest.java
@@ -0,0 +1,616 @@
+// Copyright 2014 Google Inc. 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.skyframe;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.devtools.build.skyframe.GraphTester.CONCATENATE;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Sets;
+import com.google.common.testing.GcFinalization;
+import com.google.devtools.build.lib.events.Reporter;
+import com.google.devtools.build.lib.testutil.TestUtils;
+import com.google.devtools.build.lib.util.Pair;
+import com.google.devtools.build.skyframe.GraphTester.StringValue;
+import com.google.devtools.build.skyframe.InvalidatingNodeVisitor.DirtyingInvalidationState;
+import com.google.devtools.build.skyframe.InvalidatingNodeVisitor.InvalidationState;
+import com.google.devtools.build.skyframe.InvalidatingNodeVisitor.InvalidationType;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.experimental.runners.Enclosed;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.lang.ref.WeakReference;
+import java.util.HashSet;
+import java.util.Random;
+import java.util.Set;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+
+import javax.annotation.Nullable;
+
+/**
+ * Tests for {@link InvalidatingNodeVisitor}.
+ */
+@RunWith(Enclosed.class)
+public class EagerInvalidatorTest {
+  protected InMemoryGraph graph;
+  protected GraphTester tester = new GraphTester();
+  protected InvalidationState state = newInvalidationState();
+  protected AtomicReference<InvalidatingNodeVisitor> visitor = new AtomicReference<>();
+  protected DirtyKeyTrackerImpl dirtyKeyTracker;
+
+  private IntVersion graphVersion = new IntVersion(0);
+
+  // The following three methods should be abstract, but junit4 does not allow us to run inner
+  // classes in an abstract outer class. Thus, we provide implementations. These methods will never
+  // be run because only the inner classes, annotated with @RunWith, will actually be executed.
+  EvaluationProgressReceiver.InvalidationState expectedState() {
+    throw new UnsupportedOperationException();
+  }
+
+  @SuppressWarnings("unused") // Overridden by subclasses.
+  void invalidate(DirtiableGraph graph, EvaluationProgressReceiver invalidationReceiver,
+      SkyKey... keys) throws InterruptedException { throw new UnsupportedOperationException(); }
+
+  boolean gcExpected() { throw new UnsupportedOperationException(); }
+
+  private boolean isInvalidated(SkyKey key) {
+    NodeEntry entry = graph.get(key);
+    if (gcExpected()) {
+      return entry == null;
+    } else {
+      return entry == null || entry.isDirty();
+    }
+  }
+
+  private void assertChanged(SkyKey key) {
+    NodeEntry entry = graph.get(key);
+    if (gcExpected()) {
+      assertNull(entry);
+    } else {
+      assertTrue(entry.isChanged());
+    }
+  }
+
+  private void assertDirtyAndNotChanged(SkyKey key) {
+    NodeEntry entry = graph.get(key);
+    if (gcExpected()) {
+      assertNull(entry);
+    } else {
+      assertTrue(entry.isDirty());
+      assertFalse(entry.isChanged());
+    }
+
+  }
+
+  protected InvalidationState newInvalidationState() {
+    throw new UnsupportedOperationException("Sublcasses must override");
+  }
+
+  protected InvalidationType defaultInvalidationType() {
+    throw new UnsupportedOperationException("Sublcasses must override");
+  }
+
+  // Convenience method for eval-ing a single value.
+  protected SkyValue eval(boolean keepGoing, SkyKey key) throws InterruptedException {
+    SkyKey[] keys = { key };
+    return eval(keepGoing, keys).get(key);
+  }
+
+  protected <T extends SkyValue> EvaluationResult<T> eval(boolean keepGoing, SkyKey... keys)
+    throws InterruptedException {
+    Reporter reporter = new Reporter();
+    ParallelEvaluator evaluator = new ParallelEvaluator(graph, graphVersion,
+        ImmutableMap.of(GraphTester.NODE_TYPE, tester.createDelegatingFunction()),
+        reporter, new MemoizingEvaluator.EmittedEventState(), keepGoing, 200, null,
+        new DirtyKeyTrackerImpl());
+    graphVersion = graphVersion.next();
+    return evaluator.eval(ImmutableList.copyOf(keys));
+  }
+
+  protected void invalidateWithoutError(@Nullable EvaluationProgressReceiver invalidationReceiver,
+      SkyKey... keys) throws InterruptedException {
+    invalidate(graph, invalidationReceiver, keys);
+    assertTrue(state.isEmpty());
+  }
+
+  protected void set(String name, String value) {
+    tester.set(name, new StringValue(value));
+  }
+
+  protected SkyKey skyKey(String name) {
+    return GraphTester.toSkyKeys(name)[0];
+  }
+
+  protected void assertValueValue(String name, String expectedValue) throws InterruptedException {
+    StringValue value = (StringValue) eval(false, skyKey(name));
+    assertEquals(expectedValue, value.getValue());
+  }
+
+  @Before
+  public void setUp() throws Exception {
+    dirtyKeyTracker = new DirtyKeyTrackerImpl();
+  }
+
+  @Test
+  public void receiverWorks() throws Exception {
+    final Set<String> invalidated = Sets.newConcurrentHashSet();
+    EvaluationProgressReceiver receiver = new EvaluationProgressReceiver() {
+      @Override
+      public void invalidated(SkyValue value, InvalidationState state) {
+        Preconditions.checkState(state == expectedState());
+        invalidated.add(((StringValue) value).getValue());
+      }
+
+      @Override
+      public void enqueueing(SkyKey skyKey) {
+        throw new UnsupportedOperationException();
+      }
+
+      @Override
+      public void evaluated(SkyKey skyKey, SkyValue value, EvaluationState state) {
+        throw new UnsupportedOperationException();
+      }
+    };
+    graph = new InMemoryGraph();
+    set("a", "a");
+    set("b", "b");
+    tester.getOrCreate("ab").addDependency("a").addDependency("b")
+        .setComputedValue(CONCATENATE);
+    assertValueValue("ab", "ab");
+
+    set("a", "c");
+    invalidateWithoutError(receiver, skyKey("a"));
+    assertThat(invalidated).containsExactly("a", "ab");
+    assertValueValue("ab", "cb");
+    set("b", "d");
+    invalidateWithoutError(receiver, skyKey("b"));
+    assertThat(invalidated).containsExactly("a", "ab", "b", "cb");
+  }
+
+  @Test
+  public void receiverIsNotNotifiedAboutValuesInError() throws Exception {
+    final Set<String> invalidated = Sets.newConcurrentHashSet();
+    EvaluationProgressReceiver receiver = new EvaluationProgressReceiver() {
+      @Override
+      public void invalidated(SkyValue value, InvalidationState state) {
+        Preconditions.checkState(state == expectedState());
+        invalidated.add(((StringValue) value).getValue());
+      }
+
+      @Override
+      public void enqueueing(SkyKey skyKey) {
+        throw new UnsupportedOperationException();
+      }
+
+      @Override
+      public void evaluated(SkyKey skyKey, SkyValue value, EvaluationState state) {
+        throw new UnsupportedOperationException();
+      }
+    };
+
+    graph = new InMemoryGraph();
+    set("a", "a");
+    tester.getOrCreate("ab").addDependency("a").setHasError(true);
+    eval(false, skyKey("ab"));
+
+    invalidateWithoutError(receiver, skyKey("a"));
+    assertThat(invalidated).containsExactly("a").inOrder();
+  }
+
+  @Test
+  public void invalidateValuesNotInGraph() throws Exception {
+    final Set<String> invalidated = Sets.newConcurrentHashSet();
+    EvaluationProgressReceiver receiver = new EvaluationProgressReceiver() {
+      @Override
+      public void invalidated(SkyValue value, InvalidationState state) {
+        Preconditions.checkState(state == InvalidationState.DIRTY);
+        invalidated.add(((StringValue) value).getValue());
+      }
+
+      @Override
+      public void enqueueing(SkyKey skyKey) {
+        throw new UnsupportedOperationException();
+      }
+
+      @Override
+      public void evaluated(SkyKey skyKey, SkyValue value, EvaluationState state) {
+        throw new UnsupportedOperationException();
+      }
+    };
+    graph = new InMemoryGraph();
+    invalidateWithoutError(receiver, skyKey("a"));
+    assertThat(invalidated).isEmpty();
+    set("a", "a");
+    assertValueValue("a", "a");
+    invalidateWithoutError(receiver, skyKey("b"));
+    assertThat(invalidated).isEmpty();
+  }
+
+  @Test
+  public void invalidatedValuesAreGCedAsExpected() throws Exception {
+    SkyKey key = GraphTester.skyKey("a");
+    HeavyValue heavyValue = new HeavyValue();
+    WeakReference<HeavyValue> weakRef = new WeakReference<>(heavyValue);
+    tester.set("a", heavyValue);
+
+    graph = new InMemoryGraph();
+    eval(false, key);
+    invalidate(graph, null, key);
+
+    tester = null;
+    heavyValue = null;
+    if (gcExpected()) {
+      GcFinalization.awaitClear(weakRef);
+    } else {
+      // Not a reliable check, but better than nothing.
+      System.gc();
+      Thread.sleep(300);
+      assertNotNull(weakRef.get());
+    }
+  }
+
+  @Test
+  public void reverseDepsConsistent() throws Exception {
+    graph = new InMemoryGraph();
+    set("a", "a");
+    set("b", "b");
+    set("c", "c");
+    tester.getOrCreate("ab").addDependency("a").addDependency("b").setComputedValue(CONCATENATE);
+    tester.getOrCreate("bc").addDependency("b").addDependency("c").setComputedValue(CONCATENATE);
+    tester.getOrCreate("ab_c").addDependency("ab").addDependency("c")
+        .setComputedValue(CONCATENATE);
+    eval(false, skyKey("ab_c"), skyKey("bc"));
+
+    assertThat(graph.get(skyKey("a")).getReverseDeps()).containsExactly(skyKey("ab"));
+    assertThat(graph.get(skyKey("b")).getReverseDeps()).containsExactly(skyKey("ab"), skyKey("bc"));
+    assertThat(graph.get(skyKey("c")).getReverseDeps()).containsExactly(skyKey("ab_c"),
+        skyKey("bc"));
+
+    invalidateWithoutError(null, skyKey("ab"));
+    eval(false);
+
+    // The graph values should be gone.
+    assertTrue(isInvalidated(skyKey("ab")));
+    assertTrue(isInvalidated(skyKey("abc")));
+
+    // The reverse deps to ab and ab_c should have been removed.
+    assertThat(graph.get(skyKey("a")).getReverseDeps()).isEmpty();
+    assertThat(graph.get(skyKey("b")).getReverseDeps()).containsExactly(skyKey("bc"));
+    assertThat(graph.get(skyKey("c")).getReverseDeps()).containsExactly(skyKey("bc"));
+  }
+
+  @Test
+  public void interruptChild() throws Exception {
+    graph = new InMemoryGraph();
+    int numValues = 50; // More values than the invalidator has threads.
+    final SkyKey[] family = new SkyKey[numValues];
+    final SkyKey child = GraphTester.skyKey("child");
+    final StringValue childValue = new StringValue("child");
+    tester.set(child, childValue);
+    family[0] = child;
+    for (int i = 1; i < numValues; i++) {
+      SkyKey member = skyKey(Integer.toString(i));
+      tester.getOrCreate(member).addDependency(family[i - 1]).setComputedValue(CONCATENATE);
+      family[i] = member;
+    }
+    SkyKey parent = GraphTester.skyKey("parent");
+    tester.getOrCreate(parent).addDependency(family[numValues - 1]).setComputedValue(CONCATENATE);
+    eval(/*keepGoing=*/false, parent);
+    final Thread mainThread = Thread.currentThread();
+    final AtomicReference<SkyValue> badValue = new AtomicReference<>();
+    EvaluationProgressReceiver receiver = new EvaluationProgressReceiver() {
+      @Override
+      public void invalidated(SkyValue value, InvalidationState state) {
+        if (value == childValue) {
+          // Interrupt on the very first invalidate
+          mainThread.interrupt();
+        } else if (!childValue.equals(value)) {
+          // All other invalidations should be of the same value.
+          // Exceptions thrown here may be silently dropped, so keep track of errors ourselves.
+          badValue.set(value);
+        }
+        try {
+          assertTrue(visitor.get().awaitInterruptionForTestingOnly(2, TimeUnit.HOURS));
+        } catch (InterruptedException e) {
+          // We may well have thrown here because by the time we try to await, the main thread is
+          // already interrupted.
+        }
+      }
+
+      @Override
+      public void enqueueing(SkyKey skyKey) {
+        throw new UnsupportedOperationException();
+      }
+
+      @Override
+      public void evaluated(SkyKey skyKey, SkyValue value, EvaluationState state) {
+        throw new UnsupportedOperationException();
+      }
+    };
+    try {
+      invalidateWithoutError(receiver, child);
+      fail();
+    } catch (InterruptedException e) {
+      // Expected.
+    }
+    assertNull(badValue.get());
+    assertFalse(state.isEmpty());
+    final Set<SkyValue> invalidated = Sets.newConcurrentHashSet();
+    assertFalse(isInvalidated(parent));
+    SkyValue parentValue = graph.getValue(parent);
+    assertNotNull(parentValue);
+    receiver = new EvaluationProgressReceiver() {
+      @Override
+      public void invalidated(SkyValue value, InvalidationState state) {
+        invalidated.add(value);
+      }
+
+      @Override
+      public void enqueueing(SkyKey skyKey) {
+        throw new UnsupportedOperationException();
+      }
+
+      @Override
+      public void evaluated(SkyKey skyKey, SkyValue value, EvaluationState state) {
+        throw new UnsupportedOperationException();
+      }
+    };
+    invalidateWithoutError(receiver);
+    assertTrue(invalidated.contains(parentValue));
+    assertThat(state.getInvalidationsForTesting()).isEmpty();
+
+    // Regression test coverage:
+    // "all pending values are marked changed on interrupt".
+    assertTrue(isInvalidated(child));
+    assertChanged(child);
+    for (int i = 1; i < numValues; i++) {
+      assertDirtyAndNotChanged(family[i]);
+    }
+    assertDirtyAndNotChanged(parent);
+  }
+
+  private SkyKey[] constructLargeGraph(int size) {
+    Random random = new Random(TestUtils.getRandomSeed());
+    SkyKey[] values = new SkyKey[size];
+    for (int i = 0; i < size; i++) {
+      String iString = Integer.toString(i);
+      SkyKey iKey = GraphTester.toSkyKey(iString);
+      set(iString, iString);
+      for (int j = 0; j < i; j++) {
+        if (random.nextInt(3) == 0) {
+          tester.getOrCreate(iKey).addDependency(Integer.toString(j));
+        }
+      }
+      values[i] = iKey;
+    }
+    return values;
+  }
+
+  /** Returns a subset of {@code nodes} that are still valid and so can be invalidated. */
+  private Set<Pair<SkyKey, InvalidationType>> getValuesToInvalidate(SkyKey[] nodes) {
+    Set<Pair<SkyKey, InvalidationType>> result = new HashSet<>();
+    Random random = new Random(TestUtils.getRandomSeed());
+    for (SkyKey node : nodes) {
+      if (!isInvalidated(node)) {
+        if (result.isEmpty() || random.nextInt(3) == 0) {
+          // Add at least one node, if we can.
+          result.add(Pair.of(node, defaultInvalidationType()));
+        }
+      }
+    }
+    return result;
+  }
+
+  @Test
+  public void interruptThreadInReceiver() throws Exception {
+    Random random = new Random(TestUtils.getRandomSeed());
+    int graphSize = 1000;
+    int tries = 5;
+    graph = new InMemoryGraph();
+    SkyKey[] values = constructLargeGraph(graphSize);
+    eval(/*keepGoing=*/false, values);
+    final Thread mainThread = Thread.currentThread();
+    for (int run = 0; run < tries; run++) {
+      Set<Pair<SkyKey, InvalidationType>> valuesToInvalidate = getValuesToInvalidate(values);
+      // Find how many invalidations will actually be enqueued for invalidation in the first round,
+      // so that we can interrupt before all of them are done.
+      int validValuesToDo =
+          Sets.difference(valuesToInvalidate, state.getInvalidationsForTesting()).size();
+      for (Pair<SkyKey, InvalidationType> pair : state.getInvalidationsForTesting()) {
+        if (!isInvalidated(pair.first)) {
+          validValuesToDo++;
+        }
+      }
+      int countDownStart = validValuesToDo > 0 ? random.nextInt(validValuesToDo) : 0;
+      final CountDownLatch countDownToInterrupt = new CountDownLatch(countDownStart);
+      final EvaluationProgressReceiver receiver = new EvaluationProgressReceiver() {
+        @Override
+        public void invalidated(SkyValue value, InvalidationState state) {
+          countDownToInterrupt.countDown();
+          if (countDownToInterrupt.getCount() == 0) {
+            mainThread.interrupt();
+            try {
+              // Wait for the main thread to be interrupted uninterruptibly, because the main thread
+              // is going to interrupt us, and we don't want to get into an interrupt fight. Only
+              // if we get interrupted without the main thread also being interrupted will this
+              // throw an InterruptedException.
+              TrackingAwaiter.waitAndMaybeThrowInterrupt(
+                  visitor.get().getInterruptionLatchForTestingOnly(),
+                  "Main thread was not interrupted");
+            } catch (InterruptedException e) {
+              throw new IllegalStateException(e);
+            }
+          }
+        }
+
+        @Override
+        public void enqueueing(SkyKey skyKey) {
+          throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public void evaluated(SkyKey skyKey, SkyValue value, EvaluationState state) {
+          throw new UnsupportedOperationException();
+        }
+      };
+      try {
+        invalidate(graph, receiver,
+            Sets.newHashSet(
+                Iterables.transform(valuesToInvalidate,
+                    Pair.<SkyKey, InvalidationType>firstFunction())).toArray(new SkyKey[0]));
+        assertThat(state.getInvalidationsForTesting()).isEmpty();
+      } catch (InterruptedException e) {
+        // Expected.
+      }
+      if (state.isEmpty()) {
+        // Ran out of values to invalidate.
+        break;
+      }
+    }
+
+    eval(/*keepGoing=*/false, values);
+  }
+
+  protected void setupInvalidatableGraph() throws Exception {
+    graph = new InMemoryGraph();
+    set("a", "a");
+    set("b", "b");
+    tester.getOrCreate("ab").addDependency("a").addDependency("b").setComputedValue(CONCATENATE);
+    assertValueValue("ab", "ab");
+    set("a", "c");
+  }
+
+  private static class HeavyValue implements SkyValue {
+  }
+
+  /**
+   * Test suite for the deleting invalidator.
+   */
+  @RunWith(JUnit4.class)
+  public static class DeletingInvalidatorTest extends EagerInvalidatorTest {
+    @Override
+    protected void invalidate(DirtiableGraph graph, EvaluationProgressReceiver invalidationReceiver,
+        SkyKey... keys) throws InterruptedException {
+      InvalidatingNodeVisitor invalidatingVisitor =
+          EagerInvalidator.createVisitor(/*delete=*/true, graph, ImmutableList.copyOf(keys),
+              invalidationReceiver, state, true, dirtyKeyTracker);
+      if (invalidatingVisitor != null) {
+        visitor.set(invalidatingVisitor);
+        invalidatingVisitor.run();
+      }
+    }
+
+    @Override
+    EvaluationProgressReceiver.InvalidationState expectedState() {
+      return EvaluationProgressReceiver.InvalidationState.DELETED;
+    }
+
+    @Override
+    boolean gcExpected() {
+      return true;
+    }
+
+    @Override
+    protected InvalidationState newInvalidationState() {
+      return new InvalidatingNodeVisitor.DeletingInvalidationState();
+    }
+
+    @Override
+    protected InvalidationType defaultInvalidationType() {
+      return InvalidationType.DELETED;
+    }
+
+    @Test
+    public void dirtyKeyTrackerWorksWithDeletingInvalidator() throws Exception {
+      setupInvalidatableGraph();
+      TrackingInvalidationReceiver receiver = new TrackingInvalidationReceiver();
+
+      // Dirty the node, and ensure that the tracker is aware of it:
+      InvalidatingNodeVisitor dirtyingVisitor =
+          EagerInvalidator.createVisitor(/*delete=*/false, graph, ImmutableList.of(skyKey("a")),
+              receiver, new DirtyingInvalidationState(), true, dirtyKeyTracker);
+      dirtyingVisitor.run();
+      assertThat(dirtyKeyTracker.getDirtyKeys()).containsExactly(skyKey("a"), skyKey("ab"));
+
+      // Delete the node, and ensure that the tracker is no longer tracking it:
+      InvalidatingNodeVisitor deletingVisitor =
+          EagerInvalidator.createVisitor(/*delete=*/true, graph, ImmutableList.of(skyKey("a")),
+              receiver, state, true, dirtyKeyTracker);
+      deletingVisitor.run();
+      assertThat(dirtyKeyTracker.getDirtyKeys()).containsExactly(skyKey("ab"));
+    }
+  }
+
+  /**
+   * Test suite for the dirtying invalidator.
+   */
+  @RunWith(JUnit4.class)
+  public static class DirtyingInvalidatorTest extends EagerInvalidatorTest {
+    @Override
+    protected void invalidate(DirtiableGraph graph, EvaluationProgressReceiver invalidationReceiver,
+        SkyKey... keys) throws InterruptedException {
+      InvalidatingNodeVisitor invalidatingVisitor =
+          EagerInvalidator.createVisitor(/*delete=*/false, graph, ImmutableList.copyOf(keys),
+              invalidationReceiver, state, true, dirtyKeyTracker);
+      if (invalidatingVisitor != null) {
+        visitor.set(invalidatingVisitor);
+        invalidatingVisitor.run();
+      }
+    }
+
+    @Override
+    EvaluationProgressReceiver.InvalidationState expectedState() {
+      return EvaluationProgressReceiver.InvalidationState.DIRTY;
+    }
+
+    @Override
+    boolean gcExpected() {
+      return false;
+    }
+
+    @Override
+    protected InvalidationState newInvalidationState() {
+      return new DirtyingInvalidationState();
+    }
+
+    @Override
+    protected InvalidationType defaultInvalidationType() {
+      return InvalidationType.CHANGED;
+    }
+
+    @Test
+    public void dirtyKeyTrackerWorksWithDirtyingInvalidator() throws Exception {
+      setupInvalidatableGraph();
+      TrackingInvalidationReceiver receiver = new TrackingInvalidationReceiver();
+
+      // Dirty the node, and ensure that the tracker is aware of it:
+      invalidate(graph, receiver, skyKey("a"));
+      assertThat(dirtyKeyTracker.getDirtyKeys()).hasSize(2);
+    }
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/skyframe/GenericFunctionException.java b/src/test/java/com/google/devtools/build/skyframe/GenericFunctionException.java
new file mode 100644
index 0000000..667f213
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/skyframe/GenericFunctionException.java
@@ -0,0 +1,27 @@
+// Copyright 2014 Google Inc. 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.skyframe;
+
+/**
+ * A {@link SkyFunctionException} wrapping a {@link SomeErrorException}.
+ */
+public final class GenericFunctionException extends SkyFunctionException {
+  public GenericFunctionException(SomeErrorException e, Transience transience) {
+    super(e, transience);
+  }
+
+  public GenericFunctionException(SomeErrorException e, SkyKey childKey) {
+    super(e, childKey);
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/skyframe/GraphTester.java b/src/test/java/com/google/devtools/build/skyframe/GraphTester.java
new file mode 100644
index 0000000..6095bb8
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/skyframe/GraphTester.java
@@ -0,0 +1,340 @@
+// Copyright 2014 Google Inc. 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.skyframe;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Iterables;
+import com.google.devtools.build.lib.events.Event;
+import com.google.devtools.build.lib.util.Pair;
+import com.google.devtools.build.skyframe.SkyFunctionException.Transience;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Set;
+
+import javax.annotation.Nullable;
+
+/**
+ * A helper class to create graphs and run skyframe tests over these graphs.
+ *
+ * <p>There are two types of values, computing values, which may not be set to a constant value,
+ * and leaf values, which must be set to a constant value and may not have any dependencies.
+ *
+ * <p>Note that the value builder looks into the test values created here to determine how to
+ * behave. However, skyframe will only re-evaluate the value and call the value builder if any of
+ * its dependencies has changed. That means in order to change the set of dependencies of a value,
+ * you need to also change one of its previous dependencies to force re-evaluation. Changing a
+ * computing value does not mark it as modified.
+ */
+public class GraphTester {
+
+  // TODO(bazel-team): Split this for computing and non-computing values?
+  public static final SkyFunctionName NODE_TYPE = new SkyFunctionName("Type", false);
+
+  private final Map<SkyKey, TestFunction> values = new HashMap<>();
+  private final Set<SkyKey> modifiedValues = new LinkedHashSet<>();
+
+  public TestFunction getOrCreate(String name) {
+    return getOrCreate(skyKey(name));
+  }
+
+  public TestFunction getOrCreate(SkyKey key) {
+    return getOrCreate(key, false);
+  }
+
+  public TestFunction getOrCreate(SkyKey key, boolean markAsModified) {
+    TestFunction result = values.get(key);
+    if (result == null) {
+      result = new TestFunction();
+      values.put(key, result);
+    } else if (markAsModified) {
+      modifiedValues.add(key);
+    }
+    return result;
+  }
+
+  public TestFunction set(String key, SkyValue value) {
+    return set(skyKey(key), value);
+  }
+
+  public TestFunction set(SkyKey key, SkyValue value) {
+    return getOrCreate(key, true).setConstantValue(value);
+  }
+
+  public Collection<SkyKey> getModifiedValues() {
+    return modifiedValues;
+  }
+
+  public SkyFunction getFunction() {
+    return new SkyFunction() {
+      @Override
+      public SkyValue compute(SkyKey key, Environment env)
+          throws SkyFunctionException, InterruptedException {
+        TestFunction builder = values.get(key);
+        Preconditions.checkState(builder != null, "No TestFunction for " + key);
+        if (builder.builder != null) {
+          return builder.builder.compute(key, env);
+        }
+        if (builder.warning != null) {
+          env.getListener().handle(Event.warn(builder.warning));
+        }
+        if (builder.progress != null) {
+          env.getListener().handle(Event.progress(builder.progress));
+        }
+        Map<SkyKey, SkyValue> deps = new LinkedHashMap<>();
+        boolean oneMissing = false;
+        for (Pair<SkyKey, SkyValue> dep : builder.deps) {
+          SkyValue value;
+          if (dep.second == null) {
+            value = env.getValue(dep.first);
+          } else {
+            try {
+              value = env.getValueOrThrow(dep.first, SomeErrorException.class);
+            } catch (SomeErrorException e) {
+              value = dep.second;
+            }
+          }
+          if (value == null) {
+            oneMissing = true;
+          } else {
+            deps.put(dep.first, value);
+          }
+          Preconditions.checkState(oneMissing == env.valuesMissing());
+        }
+        if (env.valuesMissing()) {
+          return null;
+        }
+
+        if (builder.hasTransientError) {
+          throw new GenericFunctionException(new SomeErrorException(key.toString()),
+              Transience.TRANSIENT);
+        }
+        if (builder.hasError) {
+          throw new GenericFunctionException(new SomeErrorException(key.toString()),
+              Transience.PERSISTENT);
+        }
+
+        if (builder.value != null) {
+          return builder.value;
+        }
+
+        if (Thread.currentThread().isInterrupted()) {
+          throw new InterruptedException(key.toString());
+        }
+
+        return builder.computer.compute(deps, env);
+      }
+
+      @Nullable
+      @Override
+      public String extractTag(SkyKey skyKey) {
+        return values.get(skyKey).tag;
+      }
+    };
+  }
+
+  public static SkyKey skyKey(String key) {
+    return new SkyKey(NODE_TYPE, key);
+  }
+
+  /**
+   * A value in the testing graph that is constructed in the tester.
+   */
+  public class TestFunction {
+    // TODO(bazel-team): We could use a multiset here to simulate multi-pass dependency discovery.
+    private final Set<Pair<SkyKey, SkyValue>> deps = new LinkedHashSet<>();
+    private SkyValue value;
+    private ValueComputer computer;
+    private SkyFunction builder = null;
+
+    private boolean hasTransientError;
+    private boolean hasError;
+
+    private String warning;
+    private String progress;
+
+    private String tag;
+
+    public TestFunction addDependency(String name) {
+      return addDependency(skyKey(name));
+    }
+
+    public TestFunction addDependency(SkyKey key) {
+      deps.add(Pair.<SkyKey, SkyValue>of(key, null));
+      return this;
+    }
+
+    public TestFunction removeDependency(String name) {
+      return removeDependency(skyKey(name));
+    }
+
+    public TestFunction removeDependency(SkyKey key) {
+      deps.remove(Pair.<SkyKey, SkyValue>of(key, null));
+      return this;
+    }
+
+    public TestFunction addErrorDependency(String name, SkyValue altValue) {
+      return addErrorDependency(skyKey(name), altValue);
+    }
+
+    public TestFunction addErrorDependency(SkyKey key, SkyValue altValue) {
+      deps.add(Pair.of(key, altValue));
+      return this;
+    }
+
+    public TestFunction setConstantValue(SkyValue value) {
+      Preconditions.checkState(this.computer == null);
+      this.value = value;
+      return this;
+    }
+
+    public TestFunction setComputedValue(ValueComputer computer) {
+      Preconditions.checkState(this.value == null);
+      this.computer = computer;
+      return this;
+    }
+
+    public TestFunction setBuilder(SkyFunction builder) {
+      Preconditions.checkState(this.value == null);
+      Preconditions.checkState(this.computer == null);
+      Preconditions.checkState(deps.isEmpty());
+      Preconditions.checkState(!hasTransientError);
+      Preconditions.checkState(!hasError);
+      Preconditions.checkState(warning == null);
+      Preconditions.checkState(progress == null);
+      this.builder = builder;
+      return this;
+    }
+
+    public TestFunction setHasTransientError(boolean hasError) {
+      this.hasTransientError = hasError;
+      return this;
+    }
+
+    public TestFunction setHasError(boolean hasError) {
+      // TODO(bazel-team): switch to an enum for hasError.
+      this.hasError = hasError;
+      return this;
+    }
+
+    public TestFunction setWarning(String warning) {
+      this.warning = warning;
+      return this;
+    }
+
+    public TestFunction setProgress(String info) {
+      this.progress = info;
+      return this;
+    }
+
+    public TestFunction setTag(String tag) {
+      this.tag = tag;
+      return this;
+    }
+
+  }
+
+  public static SkyKey[] toSkyKeys(String... names) {
+    SkyKey[] result = new SkyKey[names.length];
+    for (int i = 0; i < names.length; i++) {
+      result[i] = new SkyKey(GraphTester.NODE_TYPE, names[i]);
+    }
+    return result;
+  }
+
+  public static SkyKey toSkyKey(String name) {
+    return toSkyKeys(name)[0];
+  }
+
+  private class DelegatingFunction implements SkyFunction {
+    @Override
+    public SkyValue compute(SkyKey skyKey, Environment env) throws SkyFunctionException,
+        InterruptedException {
+      return getFunction().compute(skyKey, env);
+    }
+
+    @Nullable
+    @Override
+    public String extractTag(SkyKey skyKey) {
+      return getFunction().extractTag(skyKey);
+    }
+  }
+
+  public DelegatingFunction createDelegatingFunction() {
+    return new DelegatingFunction();
+  }
+
+  /**
+   * Simple value class that stores strings.
+   */
+  public static class StringValue implements SkyValue {
+    private final String value;
+
+    public StringValue(String value) {
+      this.value = value;
+    }
+
+    public String getValue() {
+      return value;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (!(o instanceof StringValue)) {
+        return false;
+      }
+      return value.equals(((StringValue) o).value);
+    }
+
+    @Override
+    public int hashCode() {
+      return value.hashCode();
+    }
+
+    @Override
+    public String toString() {
+      return "StringValue: " + getValue();
+    }
+  }
+
+  /**
+   * A callback interface to provide the value computation.
+   */
+  public interface ValueComputer {
+    /** This is called when all the declared dependencies exist. It may request new dependencies. */
+    SkyValue compute(Map<SkyKey, SkyValue> deps, SkyFunction.Environment env)
+        throws InterruptedException;
+  }
+
+  public static final ValueComputer COPY = new ValueComputer() {
+    @Override
+    public SkyValue compute(Map<SkyKey, SkyValue> deps, SkyFunction.Environment env) {
+      return Iterables.getOnlyElement(deps.values());
+    }
+  };
+
+  public static final ValueComputer CONCATENATE = new ValueComputer() {
+    @Override
+    public SkyValue compute(Map<SkyKey, SkyValue> deps, SkyFunction.Environment env) {
+      StringBuilder result = new StringBuilder();
+      for (SkyValue value : deps.values()) {
+        result.append(((StringValue) value).value);
+      }
+      return new StringValue(result.toString());
+    }
+  };
+}
diff --git a/src/test/java/com/google/devtools/build/skyframe/MemoizingEvaluatorTest.java b/src/test/java/com/google/devtools/build/skyframe/MemoizingEvaluatorTest.java
new file mode 100644
index 0000000..00df824
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/skyframe/MemoizingEvaluatorTest.java
@@ -0,0 +1,2914 @@
+// Copyright 2014 Google Inc. 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.skyframe;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.Truth.assertWithMessage;
+import static com.google.devtools.build.skyframe.GraphTester.CONCATENATE;
+import static com.google.devtools.build.skyframe.GraphTester.COPY;
+import static com.google.devtools.build.skyframe.GraphTester.NODE_TYPE;
+import static com.google.devtools.build.skyframe.GraphTester.skyKey;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.base.Preconditions;
+import com.google.common.base.Predicates;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+import com.google.common.testing.GcFinalization;
+import com.google.common.util.concurrent.Uninterruptibles;
+import com.google.devtools.build.lib.events.DelegatingEventHandler;
+import com.google.devtools.build.lib.events.Event;
+import com.google.devtools.build.lib.events.EventCollector;
+import com.google.devtools.build.lib.events.EventHandler;
+import com.google.devtools.build.lib.events.EventKind;
+import com.google.devtools.build.lib.events.Reporter;
+import com.google.devtools.build.lib.testutil.JunitTestUtils;
+import com.google.devtools.build.lib.testutil.TestThread;
+import com.google.devtools.build.lib.testutil.TestUtils;
+import com.google.devtools.build.skyframe.GraphTester.StringValue;
+import com.google.devtools.build.skyframe.GraphTester.TestFunction;
+import com.google.devtools.build.skyframe.GraphTester.ValueComputer;
+import com.google.devtools.build.skyframe.NotifyingInMemoryGraph.EventType;
+import com.google.devtools.build.skyframe.NotifyingInMemoryGraph.Listener;
+import com.google.devtools.build.skyframe.NotifyingInMemoryGraph.Order;
+import com.google.devtools.build.skyframe.SkyFunctionException.Transience;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import javax.annotation.Nullable;
+
+/**
+ * Tests for {@link MemoizingEvaluator}.
+ */
+@RunWith(JUnit4.class)
+public class MemoizingEvaluatorTest {
+
+  private MemoizingEvaluatorTester tester;
+  private EventCollector eventCollector;
+  private EventHandler reporter;
+  private MemoizingEvaluator.EmittedEventState emittedEventState;
+
+  // Knobs that control the size / duration of larger tests.
+  private static final int TEST_NODE_COUNT = 100;
+  private static final int TESTED_NODES = 10;
+  private static final int RUNS = 10;
+
+  @Before
+  public void initializeTester() {
+    initializeTester(null);
+  }
+
+  public void initializeTester(@Nullable TrackingInvalidationReceiver customInvalidationReceiver) {
+    emittedEventState = new MemoizingEvaluator.EmittedEventState();
+    tester = new MemoizingEvaluatorTester();
+    if (customInvalidationReceiver != null) {
+      tester.setInvalidationReceiver(customInvalidationReceiver);
+    }
+    tester.initialize();
+  }
+
+  @Before
+  public void initializeReporter() {
+    eventCollector = new EventCollector(EventKind.ALL_EVENTS);
+    reporter = new Reporter(eventCollector);
+    tester.resetPlayedEvents();
+  }
+
+  protected static SkyKey toSkyKey(String name) {
+    return new SkyKey(NODE_TYPE, name);
+  }
+
+  @Test
+  public void smoke() throws Exception {
+    tester.set("x", new StringValue("y"));
+    StringValue value = (StringValue) tester.evalAndGet("x");
+    assertEquals("y", value.getValue());
+  }
+
+  @Test
+  public void invalidationWithNothingChanged() throws Exception {
+    tester.set("x", new StringValue("y")).setWarning("fizzlepop");
+    StringValue value = (StringValue) tester.evalAndGet("x");
+    assertEquals("y", value.getValue());
+    JunitTestUtils.assertContainsEvent(eventCollector, "fizzlepop");
+    JunitTestUtils.assertEventCount(1, eventCollector);
+
+    initializeReporter();
+    tester.invalidate();
+    value = (StringValue) tester.evalAndGet("x");
+    assertEquals("y", value.getValue());
+    JunitTestUtils.assertContainsEvent(eventCollector, "fizzlepop");
+    JunitTestUtils.assertEventCount(1, eventCollector);
+  }
+
+  private abstract static class NoExtractorFunction implements SkyFunction {
+    @Override
+    public final String extractTag(SkyKey skyKey) {
+      return null;
+    }
+  }
+
+  @Test
+  // Regression test for bug: "[skyframe-m1]: registerIfDone() crash".
+  public void bubbleRace() throws Exception {
+    // The top-level value declares dependencies on a "badValue" in error, and a "sleepyValue"
+    // which is very slow. After "badValue" fails, the builder interrupts the "sleepyValue" and
+    // attempts to re-run "top" for error bubbling. Make sure this doesn't cause a precondition
+    // failure because "top" still has an outstanding dep ("sleepyValue").
+    tester.getOrCreate("top").setBuilder(new NoExtractorFunction() {
+      @Override
+      public SkyValue compute(SkyKey skyKey, Environment env) throws InterruptedException {
+        env.getValue(toSkyKey("sleepyValue"));
+        try {
+          env.getValueOrThrow(toSkyKey("badValue"), SomeErrorException.class);
+        } catch (SomeErrorException e) {
+          // In order to trigger this bug, we need to request a dep on an already computed value.
+          env.getValue(toSkyKey("otherValue1"));
+        }
+        if (!env.valuesMissing()) {
+          throw new AssertionError("SleepyValue should always be unavailable");
+        }
+        return null;
+      }
+    });
+    tester.getOrCreate("sleepyValue").setBuilder(new NoExtractorFunction() {
+      @Override
+      public SkyValue compute(SkyKey skyKey, Environment env) throws InterruptedException {
+        Thread.sleep(99999);
+        throw new AssertionError("I should have been interrupted");
+      }
+    });
+    tester.getOrCreate("badValue").addDependency("otherValue1").setHasError(true);
+    tester.getOrCreate("otherValue1").setConstantValue(new StringValue("otherVal1"));
+
+    EvaluationResult<SkyValue> result = tester.eval(false, "top");
+    assertTrue(result.hasError());
+    assertEquals(toSkyKey("badValue"), Iterables.getOnlyElement(result.getError().getRootCauses()));
+    assertThat(result.keyNames()).isEmpty();
+  }
+
+  @Test
+  public void deleteValues() throws Exception {
+    tester.getOrCreate("top").setComputedValue(CONCATENATE)
+        .addDependency("d1").addDependency("d2").addDependency("d3");
+    tester.set("d1", new StringValue("1"));
+    StringValue d2 = new StringValue("2");
+    tester.set("d2", d2);
+    StringValue d3 = new StringValue("3");
+    tester.set("d3", d3);
+    tester.eval(true, "top");
+
+    tester.delete("d1");
+    tester.eval(true, "d3");
+
+    assertThat(tester.getDirtyValues()).isEmpty();
+    assertEquals(
+        ImmutableSet.of(new StringValue("1"), new StringValue("123")), tester.getDeletedValues());
+    assertEquals(null, tester.getExistingValue("top"));
+    assertEquals(null, tester.getExistingValue("d1"));
+    assertEquals(d2, tester.getExistingValue("d2"));
+    assertEquals(d3, tester.getExistingValue("d3"));
+  }
+
+  @Test
+  public void deleteOldNodesTest() throws Exception {
+    tester.getOrCreate("top").setComputedValue(CONCATENATE).addDependency("d1").addDependency("d2");
+    tester.set("d1", new StringValue("one"));
+    tester.set("d2", new StringValue("two"));
+    tester.eval(true, "top");
+
+    tester.set("d2", new StringValue("three"));
+    tester.invalidate();
+    tester.eval(true, "d2");
+
+    // The graph now contains the three above nodes (and ERROR_TRANSIENCE).
+    assertThat(tester.graph.getValues().keySet()).containsExactly(
+        skyKey("top"), skyKey("d1"), skyKey("d2"), ErrorTransienceValue.key());
+
+    String[] noKeys = {};
+    tester.graph.deleteDirty(2);
+    tester.eval(true, noKeys);
+
+    // The top node's value is dirty, but less than two generations old, so it wasn't deleted.
+    assertThat(tester.graph.getValues().keySet()).containsExactly(
+        skyKey("top"), skyKey("d1"), skyKey("d2"), ErrorTransienceValue.key());
+
+    tester.graph.deleteDirty(2);
+    tester.eval(true, noKeys);
+
+    // The top node's value was dirty, and was two generations old, so it was deleted.
+    assertThat(tester.graph.getValues().keySet()).containsExactly(
+        skyKey("d1"), skyKey("d2"), ErrorTransienceValue.key());
+  }
+
+  @Test
+  public void deleteNonexistentValues() throws Exception {
+    tester.getOrCreate("d1").setConstantValue(new StringValue("1"));
+    tester.delete("d1");
+    tester.delete("d2");
+    tester.eval(true, "d1");
+  }
+
+  @Test
+  public void signalValueEnqueued() throws Exception {
+    tester.getOrCreate("top1").setComputedValue(CONCATENATE)
+        .addDependency("d1").addDependency("d2");
+    tester.getOrCreate("top2").setComputedValue(CONCATENATE).addDependency("d3");
+    tester.getOrCreate("top3");
+    assertThat(tester.getEnqueuedValues()).isEmpty();
+
+    tester.set("d1", new StringValue("1"));
+    tester.set("d2", new StringValue("2"));
+    tester.set("d3", new StringValue("3"));
+    tester.eval(true, "top1");
+    assertThat(tester.getEnqueuedValues()).containsExactlyElementsIn(
+        Arrays.asList(MemoizingEvaluatorTester.toSkyKeys("top1", "d1", "d2")));
+
+    tester.eval(true, "top2");
+    assertThat(tester.getEnqueuedValues()).containsExactlyElementsIn(
+        Arrays.asList(MemoizingEvaluatorTester.toSkyKeys("top1", "d1", "d2", "top2", "d3")));
+  }
+
+  // NOTE: Some of these tests exercising errors/warnings run through a size-2 for loop in order
+  // to ensure that we are properly recording and replyaing these messages on null builds.
+  @Test
+  public void warningViaMultiplePaths() throws Exception {
+    tester.set("d1", new StringValue("d1")).setWarning("warn-d1");
+    tester.set("d2", new StringValue("d2")).setWarning("warn-d2");
+    tester.getOrCreate("top").setComputedValue(CONCATENATE).addDependency("d1").addDependency("d2");
+    for (int i = 0; i < 2; i++) {
+      initializeReporter();
+      tester.evalAndGet("top");
+      JunitTestUtils.assertContainsEvent(eventCollector, "warn-d1");
+      JunitTestUtils.assertContainsEvent(eventCollector, "warn-d2");
+      JunitTestUtils.assertEventCount(2, eventCollector);
+    }
+  }
+
+  @Test
+  public void warningBeforeErrorOnFailFastBuild() throws Exception {
+    tester.set("dep", new StringValue("dep")).setWarning("warn-dep");
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    tester.getOrCreate(topKey).setHasError(true).addDependency("dep");
+    for (int i = 0; i < 2; i++) {
+      initializeReporter();
+      EvaluationResult<StringValue> result = tester.eval(false, "top");
+      assertTrue(result.hasError());
+      assertThat(result.getError(topKey).getRootCauses()).containsExactly(topKey);
+      assertEquals(topKey.toString(), result.getError(topKey).getException().getMessage());
+      assertTrue(result.getError(topKey).getException() instanceof SomeErrorException);
+      JunitTestUtils.assertContainsEvent(eventCollector, "warn-dep");
+      JunitTestUtils.assertEventCount(1, eventCollector);
+    }
+  }
+
+  @Test
+  public void warningAndErrorOnFailFastBuild() throws Exception {
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    tester.set(topKey, new StringValue("top")).setWarning("warning msg").setHasError(true);
+    for (int i = 0; i < 2; i++) {
+      initializeReporter();
+      EvaluationResult<StringValue> result = tester.eval(false, "top");
+      assertTrue(result.hasError());
+      assertThat(result.getError(topKey).getRootCauses()).containsExactly(topKey);
+      assertEquals(topKey.toString(), result.getError(topKey).getException().getMessage());
+      assertTrue(result.getError(topKey).getException() instanceof SomeErrorException);
+      JunitTestUtils.assertContainsEvent(eventCollector, "warning msg");
+      JunitTestUtils.assertEventCount(1, eventCollector);
+    }
+  }
+
+  @Test
+  public void warningAndErrorOnFailFastBuildAfterKeepGoingBuild() throws Exception {
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    tester.set(topKey, new StringValue("top")).setWarning("warning msg").setHasError(true);
+    for (int i = 0; i < 2; i++) {
+      initializeReporter();
+      EvaluationResult<StringValue> result = tester.eval(i == 0, "top");
+      assertTrue(result.hasError());
+      assertThat(result.getError(topKey).getRootCauses()).containsExactly(topKey);
+      assertEquals(topKey.toString(), result.getError(topKey).getException().getMessage());
+      assertTrue(result.getError(topKey).getException() instanceof SomeErrorException);
+      JunitTestUtils.assertContainsEvent(eventCollector, "warning msg");
+      JunitTestUtils.assertEventCount(1, eventCollector);
+    }
+  }
+
+  @Test
+  public void twoTLTsOnOneWarningValue() throws Exception {
+    tester.set("t1", new StringValue("t1")).addDependency("dep");
+    tester.set("t2", new StringValue("t2")).addDependency("dep");
+    tester.set("dep", new StringValue("dep")).setWarning("look both ways before crossing");
+    for (int i = 0; i < 2; i++) {
+      // Make sure we see the warning exactly once.
+      initializeReporter();
+      tester.eval(/*keepGoing=*/false, "t1", "t2");
+      JunitTestUtils.assertContainsEvent(eventCollector, "look both ways before crossing");
+      JunitTestUtils.assertEventCount(1, eventCollector);
+    }
+  }
+
+  @Test
+  public void errorValueDepOnWarningValue() throws Exception {
+    tester.getOrCreate("error-value").setHasError(true).addDependency("warning-value");
+    tester.set("warning-value", new StringValue("warning-value"))
+        .setWarning("don't chew with your mouth open");
+
+    for (int i = 0; i < 2; i++) {
+      initializeReporter();
+      tester.evalAndGetError("error-value");
+      JunitTestUtils.assertContainsEvent(eventCollector, "don't chew with your mouth open");
+      JunitTestUtils.assertEventCount(1, eventCollector);
+    }
+
+    initializeReporter();
+    tester.evalAndGet("warning-value");
+    JunitTestUtils.assertContainsEvent(eventCollector, "don't chew with your mouth open");
+    JunitTestUtils.assertEventCount(1, eventCollector);
+  }
+
+  @Test
+  public void progressMessageOnlyPrintedTheFirstTime() throws Exception {
+    // The framework keeps track of warning and error messages, but not progress messages.
+    // So here we see both the progress and warning on the first build, but only the warning
+    // on the subsequent null build.
+    tester.set("x", new StringValue("y")).setWarning("fizzlepop")
+        .setProgress("just letting you know");
+
+    StringValue value = (StringValue) tester.evalAndGet("x");
+    assertEquals("y", value.getValue());
+    JunitTestUtils.assertContainsEvent(eventCollector, "fizzlepop");
+    JunitTestUtils.assertContainsEvent(eventCollector, "just letting you know");
+    JunitTestUtils.assertEventCount(2, eventCollector);
+
+    // On the rebuild, we only replay warning messages.
+    initializeReporter();
+    value = (StringValue) tester.evalAndGet("x");
+    assertEquals("y", value.getValue());
+    JunitTestUtils.assertContainsEvent(eventCollector, "fizzlepop");
+    JunitTestUtils.assertEventCount(1, eventCollector);
+  }
+
+  @Test
+  public void invalidationWithChangeAndThenNothingChanged() throws Exception {
+    tester.getOrCreate("a")
+        .addDependency("b")
+        .setComputedValue(COPY);
+    tester.set("b", new StringValue("y"));
+    StringValue original = (StringValue) tester.evalAndGet("a");
+    assertEquals("y", original.getValue());
+    tester.set("b", new StringValue("z"));
+    tester.invalidate();
+    StringValue old = (StringValue) tester.evalAndGet("a");
+    assertEquals("z", old.getValue());
+    tester.invalidate();
+    StringValue current = (StringValue) tester.evalAndGet("a");
+    assertSame(old, current);
+  }
+
+  @Test
+  public void transientErrorValueInvalidation() throws Exception {
+    // Verify that invalidating errors causes all transient error values to be rerun.
+    tester.getOrCreate("error-value").setHasTransientError(true).setProgress(
+        "just letting you know");
+
+    tester.evalAndGetError("error-value");
+    JunitTestUtils.assertContainsEvent(eventCollector, "just letting you know");
+    JunitTestUtils.assertEventCount(1, eventCollector);
+
+    // Change the progress message.
+    tester.getOrCreate("error-value").setHasTransientError(true).setProgress(
+        "letting you know more");
+
+    // Without invalidating errors, we shouldn't show the new progress message.
+    for (int i = 0; i < 2; i++) {
+      initializeReporter();
+      tester.evalAndGetError("error-value");
+      JunitTestUtils.assertNoEvents(eventCollector);
+    }
+
+    // When invalidating errors, we should show the new progress message.
+    initializeReporter();
+    tester.invalidateTransientErrors();
+    tester.evalAndGetError("error-value");
+    JunitTestUtils.assertContainsEvent(eventCollector, "letting you know more");
+    JunitTestUtils.assertEventCount(1, eventCollector);
+  }
+
+  @Test
+  public void simpleDependency() throws Exception {
+    tester.getOrCreate("ab")
+        .addDependency("a")
+        .setComputedValue(COPY);
+    tester.set("a", new StringValue("me"));
+    StringValue value = (StringValue) tester.evalAndGet("ab");
+    assertEquals("me", value.getValue());
+  }
+
+  @Test
+  public void incrementalSimpleDependency() throws Exception {
+    tester.getOrCreate("ab")
+        .addDependency("a")
+        .setComputedValue(COPY);
+    tester.set("a", new StringValue("me"));
+    tester.evalAndGet("ab");
+
+    tester.set("a", new StringValue("other"));
+    tester.invalidate();
+    StringValue value = (StringValue) tester.evalAndGet("ab");
+    assertEquals("other", value.getValue());
+  }
+
+  @Test
+  public void diamondDependency() throws Exception {
+    setupDiamondDependency();
+    tester.set("d", new StringValue("me"));
+    StringValue value = (StringValue) tester.evalAndGet("a");
+    assertEquals("meme", value.getValue());
+  }
+
+  @Test
+  public void incrementalDiamondDependency() throws Exception {
+    setupDiamondDependency();
+    tester.set("d", new StringValue("me"));
+    tester.evalAndGet("a");
+
+    tester.set("d", new StringValue("other"));
+    tester.invalidate();
+    StringValue value = (StringValue) tester.evalAndGet("a");
+    assertEquals("otherother", value.getValue());
+  }
+
+  private void setupDiamondDependency() {
+    tester.getOrCreate("a")
+        .addDependency("b")
+        .addDependency("c")
+        .setComputedValue(CONCATENATE);
+    tester.getOrCreate("b")
+        .addDependency("d")
+        .setComputedValue(COPY);
+    tester.getOrCreate("c")
+        .addDependency("d")
+        .setComputedValue(COPY);
+  }
+
+  // Regression test: ParallelEvaluator notifies ValueProgressReceiver of already-built top-level
+  // values in error: we built "top" and "mid" as top-level targets; "mid" contains an error. We
+  // make sure "mid" is built as a dependency of "top" before enqueuing mid as a top-level target
+  // (by using a latch), so that the top-level enqueuing finds that mid has already been built. The
+  // progress receiver should not be notified of any value having been evaluated.
+  @Test
+  public void alreadyAnalyzedBadTarget() throws Exception {
+    final SkyKey mid = GraphTester.toSkyKey("mid");
+    final CountDownLatch valueSet = new CountDownLatch(1);
+    final TrackingAwaiter trackingAwaiter = new TrackingAwaiter();
+    setGraphForTesting(new NotifyingInMemoryGraph(new Listener() {
+      @Override
+      public void accept(SkyKey key, EventType type, Order order, Object context) {
+        if (!key.equals(mid)) {
+          return;
+        }
+        switch (type) {
+          case ADD_REVERSE_DEP:
+            if (context == null) {
+              // Context is null when we are enqueuing this value as a top-level job.
+              trackingAwaiter.awaitLatchAndTrackExceptions(valueSet, "value not set");
+            }
+            break;
+          case SET_VALUE:
+            valueSet.countDown();
+            break;
+          default:
+            break;
+        }
+      }
+    }));
+    SkyKey top = GraphTester.skyKey("top");
+    tester.getOrCreate(top).addDependency(mid).setComputedValue(CONCATENATE);
+    tester.getOrCreate(mid).setHasError(true);
+    tester.eval(/*keepGoing=*/false, top, mid);
+    assertEquals(0L, valueSet.getCount());
+    trackingAwaiter.assertNoErrors();
+    assertThat(tester.invalidationReceiver.evaluated).isEmpty();
+  }
+
+  @Test
+  public void receiverNotToldOfVerifiedValueDependingOnCycle() throws Exception {
+    SkyKey leaf = GraphTester.toSkyKey("leaf");
+    SkyKey cycle = GraphTester.toSkyKey("cycle");
+    SkyKey top = GraphTester.toSkyKey("top");
+    tester.set(leaf, new StringValue("leaf"));
+    tester.getOrCreate(cycle).addDependency(cycle);
+    tester.getOrCreate(top).addDependency(leaf).addDependency(cycle);
+    tester.eval(/*keepGoing=*/true, top);
+    assertThat(tester.invalidationReceiver.evaluated).containsExactly(leaf).inOrder();
+    tester.invalidationReceiver.clear();
+    tester.getOrCreate(leaf, /*markAsModified=*/true);
+    tester.invalidate();
+    tester.eval(/*keepGoing=*/true, top);
+    assertThat(tester.invalidationReceiver.evaluated).containsExactly(leaf).inOrder();
+  }
+
+  @Test
+  public void incrementalAddedDependency() throws Exception {
+    tester.getOrCreate("a")
+        .addDependency("b")
+        .setComputedValue(CONCATENATE);
+    tester.set("b", new StringValue("first"));
+    tester.set("c", new StringValue("second"));
+    tester.evalAndGet("a");
+
+    tester.getOrCreate("a").addDependency("c");
+    tester.set("b", new StringValue("now"));
+    tester.invalidate();
+    StringValue value = (StringValue) tester.evalAndGet("a");
+    assertEquals("nowsecond", value.getValue());
+  }
+
+  @Test
+  public void manyValuesDependOnSingleValue() throws Exception {
+    initializeTester();
+    String[] values = new String[TEST_NODE_COUNT];
+    for (int i = 0; i < values.length; i++) {
+      values[i] = Integer.toString(i);
+      tester.getOrCreate(values[i])
+          .addDependency("leaf")
+          .setComputedValue(COPY);
+    }
+    tester.set("leaf", new StringValue("leaf"));
+
+    EvaluationResult<StringValue> result = tester.eval(/*keep_going=*/false, values);
+    for (int i = 0; i < values.length; i++) {
+      SkyValue actual = result.get(new SkyKey(GraphTester.NODE_TYPE, values[i]));
+      assertEquals(new StringValue("leaf"), actual);
+    }
+
+    for (int j = 0; j < TESTED_NODES; j++) {
+      tester.set("leaf", new StringValue("other" + j));
+      tester.invalidate();
+      result = tester.eval(/*keep_going=*/false, values);
+      for (int i = 0; i < values.length; i++) {
+        SkyValue actual = result.get(new SkyKey(GraphTester.NODE_TYPE, values[i]));
+        assertEquals("Run " + j + ", value " + i, new StringValue("other" + j), actual);
+      }
+    }
+  }
+
+  @Test
+  public void singleValueDependsOnManyValues() throws Exception {
+    initializeTester();
+    String[] values = new String[TEST_NODE_COUNT];
+    StringBuilder expected = new StringBuilder();
+    for (int i = 0; i < values.length; i++) {
+      values[i] = Integer.toString(i);
+      tester.set(values[i], new StringValue(values[i]));
+      expected.append(values[i]);
+    }
+    SkyKey rootKey = new SkyKey(GraphTester.NODE_TYPE, "root");
+    TestFunction value = tester.getOrCreate(rootKey)
+        .setComputedValue(CONCATENATE);
+    for (int i = 0; i < values.length; i++) {
+      value.addDependency(values[i]);
+    }
+
+    EvaluationResult<StringValue> result = tester.eval(/*keep_going=*/false, rootKey);
+    assertEquals(new StringValue(expected.toString()), result.get(rootKey));
+
+    for (int j = 0; j < 10; j++) {
+      expected.setLength(0);
+      for (int i = 0; i < values.length; i++) {
+        String s = "other" + i + " " + j;
+        tester.set(values[i], new StringValue(s));
+        expected.append(s);
+      }
+      tester.invalidate();
+
+      result = tester.eval(/*keep_going=*/false, rootKey);
+      assertEquals(new StringValue(expected.toString()), result.get(rootKey));
+    }
+  }
+
+  @Test
+  public void twoRailLeftRightDependencies() throws Exception {
+    initializeTester();
+    String[] leftValues = new String[TEST_NODE_COUNT];
+    String[] rightValues = new String[TEST_NODE_COUNT];
+    for (int i = 0; i < leftValues.length; i++) {
+      leftValues[i] = "left-" + i;
+      rightValues[i] = "right-" + i;
+      if (i == 0) {
+        tester.getOrCreate(leftValues[i])
+              .addDependency("leaf")
+              .setComputedValue(COPY);
+        tester.getOrCreate(rightValues[i])
+              .addDependency("leaf")
+              .setComputedValue(COPY);
+      } else {
+        tester.getOrCreate(leftValues[i])
+              .addDependency(leftValues[i - 1])
+              .addDependency(rightValues[i - 1])
+              .setComputedValue(new PassThroughSelected(toSkyKey(leftValues[i - 1])));
+        tester.getOrCreate(rightValues[i])
+              .addDependency(leftValues[i - 1])
+              .addDependency(rightValues[i - 1])
+              .setComputedValue(new PassThroughSelected(toSkyKey(rightValues[i - 1])));
+      }
+    }
+    tester.set("leaf", new StringValue("leaf"));
+
+    String lastLeft = "left-" + (TEST_NODE_COUNT - 1);
+    String lastRight = "right-" + (TEST_NODE_COUNT - 1);
+
+    EvaluationResult<StringValue> result = tester.eval(/*keep_going=*/false, lastLeft, lastRight);
+    assertEquals(new StringValue("leaf"), result.get(toSkyKey(lastLeft)));
+    assertEquals(new StringValue("leaf"), result.get(toSkyKey(lastRight)));
+
+    for (int j = 0; j < TESTED_NODES; j++) {
+      String value = "other" + j;
+      tester.set("leaf", new StringValue(value));
+      tester.invalidate();
+      result = tester.eval(/*keep_going=*/false, lastLeft, lastRight);
+      assertEquals(new StringValue(value), result.get(toSkyKey(lastLeft)));
+      assertEquals(new StringValue(value), result.get(toSkyKey(lastRight)));
+    }
+  }
+
+  @Test
+  public void noKeepGoingAfterKeepGoingCycle() throws Exception {
+    initializeTester();
+    SkyKey aKey = GraphTester.toSkyKey("a");
+    SkyKey bKey = GraphTester.toSkyKey("b");
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    SkyKey midKey = GraphTester.toSkyKey("mid");
+    SkyKey goodKey = GraphTester.toSkyKey("good");
+    StringValue goodValue = new StringValue("good");
+    tester.set(goodKey, goodValue);
+    tester.getOrCreate(topKey).addDependency(midKey);
+    tester.getOrCreate(midKey).addDependency(aKey);
+    tester.getOrCreate(aKey).addDependency(bKey);
+    tester.getOrCreate(bKey).addDependency(aKey);
+    EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/true, topKey, goodKey);
+    assertEquals(goodValue, result.get(goodKey));
+    assertEquals(null, result.get(topKey));
+    ErrorInfo errorInfo = result.getError(topKey);
+    CycleInfo cycleInfo = Iterables.getOnlyElement(errorInfo.getCycleInfo());
+    assertThat(cycleInfo.getCycle()).containsExactly(aKey, bKey).inOrder();
+    assertThat(cycleInfo.getPathToCycle()).containsExactly(topKey, midKey).inOrder();
+
+    tester.invalidate();
+    result = tester.eval(/*keepGoing=*/false, topKey, goodKey);
+    assertEquals(null, result.get(topKey));
+    errorInfo = result.getError(topKey);
+    cycleInfo = Iterables.getOnlyElement(errorInfo.getCycleInfo());
+    assertThat(cycleInfo.getCycle()).containsExactly(aKey, bKey).inOrder();
+    assertThat(cycleInfo.getPathToCycle()).containsExactly(topKey, midKey).inOrder();
+  }
+
+  @Test
+  public void changeCycle() throws Exception {
+    initializeTester();
+    SkyKey aKey = GraphTester.toSkyKey("a");
+    SkyKey bKey = GraphTester.toSkyKey("b");
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    SkyKey midKey = GraphTester.toSkyKey("mid");
+    tester.getOrCreate(topKey).addDependency(midKey).setComputedValue(COPY);
+    tester.getOrCreate(midKey).addDependency(aKey).setComputedValue(COPY);
+    tester.getOrCreate(aKey).addDependency(bKey).setComputedValue(COPY);
+    tester.getOrCreate(bKey).addDependency(aKey);
+    EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/false, topKey);
+    assertEquals(null, result.get(topKey));
+    ErrorInfo errorInfo = result.getError(topKey);
+    CycleInfo cycleInfo = Iterables.getOnlyElement(errorInfo.getCycleInfo());
+    assertThat(cycleInfo.getCycle()).containsExactly(aKey, bKey).inOrder();
+    assertThat(cycleInfo.getPathToCycle()).containsExactly(topKey, midKey).inOrder();
+
+    tester.getOrCreate(bKey).removeDependency(aKey);
+    tester.set(bKey, new StringValue("bValue"));
+    tester.invalidate();
+    result = tester.eval(/*keepGoing=*/false, topKey);
+    assertEquals(new StringValue("bValue"), result.get(topKey));
+    assertEquals(null, result.getError(topKey));
+  }
+
+  /** Regression test: "crash in cycle checker with dirty values". */
+  @Test
+  public void cycleAndSelfEdgeWithDirtyValue() throws Exception {
+    initializeTester();
+    SkyKey cycleKey1 = GraphTester.toSkyKey("cycleKey1");
+    SkyKey cycleKey2 = GraphTester.toSkyKey("cycleKey2");
+    tester.getOrCreate(cycleKey1).addDependency(cycleKey2).addDependency(cycleKey1)
+    .setComputedValue(CONCATENATE);
+    tester.getOrCreate(cycleKey2).addDependency(cycleKey1).setComputedValue(COPY);
+    EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/true, cycleKey1);
+    assertEquals(null, result.get(cycleKey1));
+    ErrorInfo errorInfo = result.getError(cycleKey1);
+    CycleInfo cycleInfo = Iterables.getOnlyElement(errorInfo.getCycleInfo());
+    assertThat(cycleInfo.getCycle()).containsExactly(cycleKey1).inOrder();
+    assertThat(cycleInfo.getPathToCycle()).isEmpty();
+    tester.getOrCreate(cycleKey1, /*markAsModified=*/true);
+    tester.invalidate();
+    result = tester.eval(/*keepGoing=*/true, cycleKey1, cycleKey2);
+    assertEquals(null, result.get(cycleKey1));
+    errorInfo = result.getError(cycleKey1);
+    cycleInfo = Iterables.getOnlyElement(errorInfo.getCycleInfo());
+    assertThat(cycleInfo.getCycle()).containsExactly(cycleKey1).inOrder();
+    assertThat(cycleInfo.getPathToCycle()).isEmpty();
+    cycleInfo =
+        Iterables.getOnlyElement(tester.graph.getExistingErrorForTesting(cycleKey2).getCycleInfo());
+    assertThat(cycleInfo.getCycle()).containsExactly(cycleKey1).inOrder();
+    assertThat(cycleInfo.getPathToCycle()).containsExactly(cycleKey2).inOrder();
+  }
+
+  /** Regression test: "crash in cycle checker with dirty values". */
+  @Test
+  public void cycleWithDirtyValue() throws Exception {
+    initializeTester();
+    SkyKey cycleKey1 = GraphTester.toSkyKey("cycleKey1");
+    SkyKey cycleKey2 = GraphTester.toSkyKey("cycleKey2");
+    tester.getOrCreate(cycleKey1).addDependency(cycleKey2).setComputedValue(COPY);
+    tester.getOrCreate(cycleKey2).addDependency(cycleKey1).setComputedValue(COPY);
+    EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/true, cycleKey1);
+    assertEquals(null, result.get(cycleKey1));
+    ErrorInfo errorInfo = result.getError(cycleKey1);
+    CycleInfo cycleInfo = Iterables.getOnlyElement(errorInfo.getCycleInfo());
+    assertThat(cycleInfo.getCycle()).containsExactly(cycleKey1, cycleKey2).inOrder();
+    assertThat(cycleInfo.getPathToCycle()).isEmpty();
+    tester.getOrCreate(cycleKey1, /*markAsModified=*/true);
+    tester.invalidate();
+    result = tester.eval(/*keepGoing=*/true, cycleKey1);
+    assertEquals(null, result.get(cycleKey1));
+    errorInfo = result.getError(cycleKey1);
+    cycleInfo = Iterables.getOnlyElement(errorInfo.getCycleInfo());
+    assertThat(cycleInfo.getCycle()).containsExactly(cycleKey1, cycleKey2).inOrder();
+    assertThat(cycleInfo.getPathToCycle()).isEmpty();
+  }
+
+  /**
+   * Regression test: IllegalStateException in BuildingState.isReady(). The ParallelEvaluator used
+   * to assume during cycle-checking that all values had been built as fully as possible -- that
+   * evaluation had not been interrupted. However, we also do cycle-checking in nokeep-going mode
+   * when a value throws an error (possibly prematurely shutting down evaluation) but that error
+   * then bubbles up into a cycle.
+   *
+   * <p>We want to achieve the following state: we are checking for a cycle; the value we examine
+   * has not yet finished checking its children to see if they are dirty; but all children checked
+   * so far have been unchanged. This value is "otherTop". We first build otherTop, then mark its
+   * first child changed (without actually changing it), and then do a second build. On the second
+   * build, we also build "top", which requests a cycle that depends on an error. We wait to signal
+   * otherTop that its first child is done until the error throws and shuts down evaluation. The
+   * error then bubbles up to the cycle, and so the bubbling is aborted. Finally, cycle checking
+   * happens, and otherTop is examined, as desired.
+   */
+  @Test
+  public void cycleAndErrorAndReady() throws Exception {
+    // This value will not have finished building on the second build when the error is thrown.
+    final SkyKey otherTop = GraphTester.toSkyKey("otherTop");
+    final SkyKey errorKey = GraphTester.toSkyKey("error");
+    // Is the graph state all set up and ready for the error to be thrown?
+    final CountDownLatch valuesReady = new CountDownLatch(3);
+    // Is evaluation being shut down? This is counted down by the exceptionMarker's builder, after
+    // it has waited for the threadpool's exception latch to be released.
+    final CountDownLatch errorThrown = new CountDownLatch(1);
+    // We don't do anything on the first build.
+    final AtomicBoolean secondBuild = new AtomicBoolean(false);
+    final TrackingAwaiter trackingAwaiter = new TrackingAwaiter();
+    setGraphForTesting(new DeterministicInMemoryGraph(new Listener() {
+      @Override
+      public void accept(SkyKey key, EventType type, Order order, Object context) {
+        if (!secondBuild.get()) {
+          return;
+        }
+        if (key.equals(errorKey) && type == EventType.SET_VALUE) {
+          // If the error is about to be thrown, make sure all listeners are ready.
+          trackingAwaiter.awaitLatchAndTrackExceptions(valuesReady, "waiting values not ready");
+          return;
+        }
+        if (key.equals(otherTop) && type == EventType.SIGNAL) {
+          // otherTop is being signaled that dep1 is done. Tell the error value that it is ready,
+          // then wait until the error is thrown, so that otherTop's builder is not re-entered.
+          valuesReady.countDown();
+          trackingAwaiter.awaitLatchAndTrackExceptions(errorThrown, "error not thrown");
+          return;
+        }
+      }
+    }));
+    final SkyKey dep1 = GraphTester.toSkyKey("dep1");
+    tester.set(dep1, new StringValue("dep1"));
+    final SkyKey dep2 = GraphTester.toSkyKey("dep2");
+    tester.set(dep2, new StringValue("dep2"));
+    // otherTop should request the deps one at a time, so that it can be in the CHECK_DEPENDENCIES
+    // state even after one dep is re-evaluated.
+    tester.getOrCreate(otherTop).setBuilder(new NoExtractorFunction() {
+      @Override
+      public SkyValue compute(SkyKey skyKey, Environment env) {
+        env.getValue(dep1);
+        if (env.valuesMissing()) {
+          return null;
+        }
+        env.getValue(dep2);
+        return env.valuesMissing() ? null : new StringValue("otherTop");
+      }
+    });
+    // Prime the graph with otherTop, so we can dirty it next build.
+    assertEquals(new StringValue("otherTop"), tester.evalAndGet(/*keepGoing=*/false, otherTop));
+    // Mark dep1 changed, so otherTop will be dirty and request re-evaluation of dep1.
+    tester.getOrCreate(dep1, /*markAsModified=*/true);
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    // Note that since DeterministicInMemoryGraph alphabetizes reverse deps, it is important that
+    // "cycle2" comes before "top".
+    final SkyKey cycle1Key = GraphTester.toSkyKey("cycle1");
+    final SkyKey cycle2Key = GraphTester.toSkyKey("cycle2");
+    tester.getOrCreate(topKey).addDependency(cycle1Key).setComputedValue(CONCATENATE);
+    tester.getOrCreate(cycle1Key).addDependency(errorKey).addDependency(cycle2Key)
+        .setComputedValue(CONCATENATE);
+    tester.getOrCreate(errorKey).setHasError(true);
+    // Make sure cycle2Key has declared its dependence on cycle1Key before error throws.
+    tester.getOrCreate(cycle2Key).setBuilder(new ChainedFunction(/*notifyStart=*/valuesReady,
+        null, null, false, new StringValue("never returned"), ImmutableList.<SkyKey>of(cycle1Key)));
+    // Value that waits until an exception is thrown to finish building. We use it just to be
+    // informed when the threadpool is shutting down.
+    final SkyKey exceptionMarker = GraphTester.toSkyKey("exceptionMarker");
+    tester.getOrCreate(exceptionMarker).setBuilder(new ChainedFunction(
+        /*notifyStart=*/valuesReady, /*waitToFinish=*/new CountDownLatch(0),
+        /*notifyFinish=*/errorThrown,
+        /*waitForException=*/true, new StringValue("exception marker"),
+        ImmutableList.<SkyKey>of()));
+    tester.invalidate();
+    secondBuild.set(true);
+    // otherTop must be first, since we check top-level values for cycles in the order in which
+    // they appear here.
+    EvaluationResult<StringValue> result =
+        tester.eval(/*keepGoing=*/false, otherTop, topKey, exceptionMarker);
+    trackingAwaiter.assertNoErrors();
+    assertThat(result.errorMap().keySet()).containsExactly(topKey);
+    Iterable<CycleInfo> cycleInfos = result.getError(topKey).getCycleInfo();
+    assertWithMessage(result.toString()).that(cycleInfos).isNotEmpty();
+    CycleInfo cycleInfo = Iterables.getOnlyElement(cycleInfos);
+    assertThat(cycleInfo.getPathToCycle()).containsExactly(topKey);
+    assertThat(cycleInfo.getCycle()).containsExactly(cycle1Key, cycle2Key);
+  }
+
+  @Test
+  public void limitEvaluatorThreads() throws Exception {
+    initializeTester();
+
+    int numKeys = 10;
+    final Object lock = new Object();
+    final AtomicInteger inProgressCount = new AtomicInteger();
+    final int[] maxValue = {0};
+
+    SkyKey topLevel = GraphTester.toSkyKey("toplevel");
+    TestFunction topLevelBuilder = tester.getOrCreate(topLevel);
+    for (int i = 0; i < numKeys; i++) {
+      topLevelBuilder.addDependency("subKey" + i);
+      tester.getOrCreate("subKey" + i).setComputedValue(new ValueComputer() {
+        @Override
+        public SkyValue compute(Map<SkyKey, SkyValue> deps, SkyFunction.Environment env) {
+          int val = inProgressCount.incrementAndGet();
+          synchronized (lock) {
+            if (val > maxValue[0]) {
+              maxValue[0] = val;
+            }
+          }
+          Uninterruptibles.sleepUninterruptibly(5, TimeUnit.SECONDS);
+
+          inProgressCount.decrementAndGet();
+          return new StringValue("abc");
+        }
+      });
+    }
+    topLevelBuilder.setConstantValue(new StringValue("xyz"));
+
+    EvaluationResult<StringValue> result = tester.eval(
+        /*keepGoing=*/true, /*numThreads=*/5, topLevel);
+    assertFalse(result.hasError());
+    assertEquals(5, maxValue[0]);
+  }
+
+  /**
+   * Regression test: error on clearMaybeDirtyValue. We do an evaluation of topKey, which registers
+   * dependencies on midKey and errorKey. midKey enqueues slowKey, and waits. errorKey throws an
+   * error, which bubbles up to topKey. If topKey does not unregister its dependence on midKey, it
+   * will have a dangling reference to midKey after unfinished values are cleaned from the graph.
+   * Note that slowKey will wait until errorKey has thrown and the threadpool has caught the
+   * exception before returning, so the Evaluator will already have stopped enqueuing new jobs, so
+   * midKey is not evaluated.
+   */
+  @Test
+  public void incompleteDirectDepsAreClearedBeforeInvalidation() throws Exception {
+    initializeTester();
+    CountDownLatch slowStart = new CountDownLatch(1);
+    CountDownLatch errorFinish = new CountDownLatch(1);
+    SkyKey errorKey = GraphTester.toSkyKey("error");
+    tester.getOrCreate(errorKey).setBuilder(
+        new ChainedFunction(/*notifyStart=*/null, /*waitToFinish=*/slowStart,
+            /*notifyFinish=*/errorFinish, /*waitForException=*/false, /*value=*/null,
+            /*deps=*/ImmutableList.<SkyKey>of()));
+    SkyKey slowKey = GraphTester.toSkyKey("slow");
+    tester.getOrCreate(slowKey).setBuilder(
+        new ChainedFunction(/*notifyStart=*/slowStart, /*waitToFinish=*/errorFinish,
+            /*notifyFinish=*/null, /*waitForException=*/true, new StringValue("slow"),
+            /*deps=*/ImmutableList.<SkyKey>of()));
+    SkyKey midKey = GraphTester.toSkyKey("mid");
+    tester.getOrCreate(midKey).addDependency(slowKey).setComputedValue(COPY);
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    tester.getOrCreate(topKey).addDependency(midKey).addDependency(errorKey)
+        .setComputedValue(CONCATENATE);
+    // slowKey starts -> errorKey finishes, written to graph -> slowKey finishes & (Visitor aborts)
+    // -> topKey builds.
+    EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/false, topKey);
+    assertThat(result.getError().getRootCauses()).containsExactly(errorKey);
+    // Make sure midKey didn't finish building.
+    assertEquals(null, tester.graph.getExistingValueForTesting(midKey));
+    // Give slowKey a nice ordinary builder.
+    tester.getOrCreate(slowKey, /*markAsModified=*/false).setBuilder(null)
+        .setConstantValue(new StringValue("slow"));
+    // Put midKey into the graph. It won't have a reverse dependence on topKey.
+    tester.evalAndGet(/*keepGoing=*/false, midKey);
+    tester.differencer.invalidate(ImmutableList.of(errorKey));
+    // topKey should not access midKey as if it were already registered as a dependency.
+    tester.eval(/*keepGoing=*/false, topKey);
+  }
+
+  /**
+   * Regression test: error on clearMaybeDirtyValue. Same as the previous test, but the second
+   * evaluation is keepGoing, which should cause an access of the children of topKey.
+   */
+  @Test
+  public void incompleteDirectDepsAreClearedBeforeKeepGoing() throws Exception {
+    initializeTester();
+    CountDownLatch slowStart = new CountDownLatch(1);
+    CountDownLatch errorFinish = new CountDownLatch(1);
+    SkyKey errorKey = GraphTester.toSkyKey("error");
+    tester.getOrCreate(errorKey).setBuilder(
+        new ChainedFunction(/*notifyStart=*/null, /*waitToFinish=*/slowStart,
+            /*notifyFinish=*/errorFinish, /*waitForException=*/false, /*value=*/null,
+            /*deps=*/ImmutableList.<SkyKey>of()));
+    SkyKey slowKey = GraphTester.toSkyKey("slow");
+    tester.getOrCreate(slowKey).setBuilder(
+        new ChainedFunction(/*notifyStart=*/slowStart, /*waitToFinish=*/errorFinish,
+            /*notifyFinish=*/null, /*waitForException=*/true, new StringValue("slow"),
+            /*deps=*/ImmutableList.<SkyKey>of()));
+    SkyKey midKey = GraphTester.toSkyKey("mid");
+    tester.getOrCreate(midKey).addDependency(slowKey).setComputedValue(COPY);
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    tester.getOrCreate(topKey).addDependency(midKey).addDependency(errorKey)
+        .setComputedValue(CONCATENATE);
+    // slowKey starts -> errorKey finishes, written to graph -> slowKey finishes & (Visitor aborts)
+    // -> topKey builds.
+    EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/false, topKey);
+    assertThat(result.getError().getRootCauses()).containsExactly(errorKey);
+    // Make sure midKey didn't finish building.
+    assertEquals(null, tester.graph.getExistingValueForTesting(midKey));
+    // Give slowKey a nice ordinary builder.
+    tester.getOrCreate(slowKey, /*markAsModified=*/false).setBuilder(null)
+        .setConstantValue(new StringValue("slow"));
+    // Put midKey into the graph. It won't have a reverse dependence on topKey.
+    tester.evalAndGet(/*keepGoing=*/false, midKey);
+    // topKey should not access midKey as if it were already registered as a dependency.
+    // We don't invalidate errors, but because topKey wasn't actually written to the graph last
+    // build, it should be rebuilt here.
+    tester.eval(/*keepGoing=*/true, topKey);
+  }
+
+  /**
+   * Regression test: tests that pass before other build actions fail yield crash in non -k builds.
+   */
+  @Test
+  public void passThenFailToBuild() throws Exception {
+    CountDownLatch blocker = new CountDownLatch(1);
+    SkyKey successKey = GraphTester.toSkyKey("success");
+    tester.getOrCreate(successKey).setBuilder(
+        new ChainedFunction(/*notifyStart=*/null, /*waitToFinish=*/null,
+            /*notifyFinish=*/blocker, /*waitForException=*/false, new StringValue("yippee"),
+            /*deps=*/ImmutableList.<SkyKey>of()));
+    SkyKey slowFailKey = GraphTester.toSkyKey("slow_then_fail");
+    tester.getOrCreate(slowFailKey).setBuilder(
+        new ChainedFunction(/*notifyStart=*/null, /*waitToFinish=*/blocker,
+            /*notifyFinish=*/null, /*waitForException=*/false, /*value=*/null,
+            /*deps=*/ImmutableList.<SkyKey>of()));
+
+    EvaluationResult<StringValue> result = tester.eval(
+        /*keepGoing=*/false, successKey, slowFailKey);
+    assertThat(result.getError().getRootCauses()).containsExactly(slowFailKey);
+    assertThat(result.values()).containsExactly(new StringValue("yippee"));
+  }
+
+  @Test
+  public void passThenFailToBuildAlternateOrder() throws Exception {
+    CountDownLatch blocker = new CountDownLatch(1);
+    SkyKey successKey = GraphTester.toSkyKey("success");
+    tester.getOrCreate(successKey).setBuilder(
+        new ChainedFunction(/*notifyStart=*/null, /*waitToFinish=*/null,
+            /*notifyFinish=*/blocker, /*waitForException=*/false, new StringValue("yippee"),
+            /*deps=*/ImmutableList.<SkyKey>of()));
+    SkyKey slowFailKey = GraphTester.toSkyKey("slow_then_fail");
+    tester.getOrCreate(slowFailKey).setBuilder(
+        new ChainedFunction(/*notifyStart=*/null, /*waitToFinish=*/blocker,
+            /*notifyFinish=*/null, /*waitForException=*/false, /*value=*/null,
+            /*deps=*/ImmutableList.<SkyKey>of()));
+
+    EvaluationResult<StringValue> result = tester.eval(
+        /*keepGoing=*/false, slowFailKey, successKey);
+    assertThat(result.getError().getRootCauses()).containsExactly(slowFailKey);
+    assertThat(result.values()).containsExactly(new StringValue("yippee"));
+  }
+
+  @Test
+  public void incompleteDirectDepsForDirtyValue() throws Exception {
+    initializeTester();
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    tester.set(topKey, new StringValue("initial"));
+    // Put topKey into graph so it will be dirtied on next run.
+    assertEquals(new StringValue("initial"), tester.evalAndGet(/*keepGoing=*/false, topKey));
+    CountDownLatch slowStart = new CountDownLatch(1);
+    CountDownLatch errorFinish = new CountDownLatch(1);
+    SkyKey errorKey = GraphTester.toSkyKey("error");
+    tester.getOrCreate(errorKey).setBuilder(
+        new ChainedFunction(/*notifyStart=*/null, /*waitToFinish=*/slowStart,
+            /*notifyFinish=*/errorFinish,
+            /*waitForException=*/false, /*value=*/null, /*deps=*/ImmutableList.<SkyKey>of()));
+    SkyKey slowKey = GraphTester.toSkyKey("slow");
+    tester.getOrCreate(slowKey).setBuilder(
+        new ChainedFunction(/*notifyStart=*/slowStart, /*waitToFinish=*/errorFinish,
+            /*notifyFinish=*/null, /*waitForException=*/true,
+            new StringValue("slow"), /*deps=*/ImmutableList.<SkyKey>of()));
+    SkyKey midKey = GraphTester.toSkyKey("mid");
+    tester.getOrCreate(midKey).addDependency(slowKey).setComputedValue(COPY);
+    tester.set(topKey, null);
+    tester.getOrCreate(topKey).addDependency(midKey).addDependency(errorKey)
+        .setComputedValue(CONCATENATE);
+    tester.invalidate();
+    // slowKey starts -> errorKey finishes, written to graph -> slowKey finishes & (Visitor aborts)
+    // -> topKey builds.
+    EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/false, topKey);
+    assertThat(result.getError().getRootCauses()).containsExactly(errorKey);
+    // Make sure midKey didn't finish building.
+    assertEquals(null, tester.graph.getExistingValueForTesting(midKey));
+    // Give slowKey a nice ordinary builder.
+    tester.getOrCreate(slowKey, /*markAsModified=*/false).setBuilder(null)
+        .setConstantValue(new StringValue("slow"));
+    // Put midKey into the graph. It won't have a reverse dependence on topKey.
+    tester.evalAndGet(/*keepGoing=*/false, midKey);
+    // topKey should not access midKey as if it were already registered as a dependency.
+    // We don't invalidate errors, but since topKey wasn't actually written to the graph before, it
+    // will be rebuilt.
+    tester.eval(/*keepGoing=*/true, topKey);
+  }
+
+  @Test
+  public void continueWithErrorDep() throws Exception {
+    initializeTester();
+    SkyKey errorKey = GraphTester.toSkyKey("my_error_value");
+    tester.getOrCreate(errorKey).setHasError(true);
+    tester.set("after", new StringValue("after"));
+    SkyKey parentKey = GraphTester.toSkyKey("parent");
+    tester.getOrCreate(parentKey).addErrorDependency(errorKey, new StringValue("recovered"))
+        .setComputedValue(CONCATENATE).addDependency("after");
+    EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/true, parentKey);
+    assertThat(result.errorMap()).isEmpty();
+    assertEquals("recoveredafter", result.get(parentKey).getValue());
+    tester.set("after", new StringValue("before"));
+    tester.invalidate();
+    result = tester.eval(/*keepGoing=*/true, parentKey);
+    assertThat(result.errorMap()).isEmpty();
+    assertEquals("recoveredbefore", result.get(parentKey).getValue());
+  }
+
+  @Test
+  public void continueWithErrorDepTurnedGood() throws Exception {
+    initializeTester();
+    SkyKey errorKey = GraphTester.toSkyKey("my_error_value");
+    tester.getOrCreate(errorKey).setHasError(true);
+    tester.set("after", new StringValue("after"));
+    SkyKey parentKey = GraphTester.toSkyKey("parent");
+    tester.getOrCreate(parentKey).addErrorDependency(errorKey, new StringValue("recovered"))
+        .setComputedValue(CONCATENATE).addDependency("after");
+    EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/true, parentKey);
+    assertThat(result.errorMap()).isEmpty();
+    assertEquals("recoveredafter", result.get(parentKey).getValue());
+    tester.set(errorKey, new StringValue("reformed")).setHasError(false);
+    tester.invalidate();
+    result = tester.eval(/*keepGoing=*/true, parentKey);
+    assertThat(result.errorMap()).isEmpty();
+    assertEquals("reformedafter", result.get(parentKey).getValue());
+  }
+
+  @Test
+  public void errorDepAlreadyThereThenTurnedGood() throws Exception {
+    initializeTester();
+    SkyKey errorKey = GraphTester.toSkyKey("my_error_value");
+    tester.getOrCreate(errorKey).setHasError(true);
+    SkyKey parentKey = GraphTester.toSkyKey("parent");
+    tester.getOrCreate(parentKey).addErrorDependency(errorKey, new StringValue("recovered"))
+        .setHasError(true);
+    // Prime the graph by putting the error value in it beforehand.
+    assertThat(tester.evalAndGetError(errorKey).getRootCauses()).containsExactly(errorKey);
+    EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/false, parentKey);
+    // Request the parent.
+    assertThat(result.getError(parentKey).getRootCauses()).containsExactly(parentKey).inOrder();
+    // Change the error value to no longer throw.
+    tester.set(errorKey, new StringValue("reformed")).setHasError(false);
+    tester.getOrCreate(parentKey, /*markAsModified=*/false).setHasError(false)
+        .setComputedValue(COPY);
+    tester.differencer.invalidate(ImmutableList.of(errorKey));
+    tester.invalidate();
+    // Request the parent again. This time it should succeed.
+    result = tester.eval(/*keepGoing=*/false, parentKey);
+    assertThat(result.errorMap()).isEmpty();
+    assertEquals("reformed", result.get(parentKey).getValue());
+    // Confirm that the parent no longer depends on the error transience value -- make it
+    // unbuildable again, but without invalidating it, and invalidate transient errors. The parent
+    // should not be rebuilt.
+    tester.getOrCreate(parentKey, /*markAsModified=*/false).setHasError(true);
+    tester.invalidateTransientErrors();
+    result = tester.eval(/*keepGoing=*/false, parentKey);
+    assertThat(result.errorMap()).isEmpty();
+    assertEquals("reformed", result.get(parentKey).getValue());
+  }
+
+  /**
+   * Regression test for 2014 bug: error transience value is registered before newly requested deps.
+   * A value requests a child, gets it back immediately, and then throws, causing the error
+   * transience value to be registered as a dep. The following build, the error is invalidated via
+   * that child.
+   */
+  @Test
+  public void doubleDepOnErrorTransienceValue() throws Exception {
+    initializeTester();
+    SkyKey leafKey = GraphTester.toSkyKey("leaf");
+    tester.set(leafKey, new StringValue("leaf"));
+    // Prime the graph by putting leaf in beforehand.
+    assertEquals(new StringValue("leaf"), tester.evalAndGet(/*keepGoing=*/false, leafKey));
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    tester.getOrCreate(topKey).addDependency(leafKey).setHasError(true);
+    // Build top -- it has an error.
+    assertThat(tester.evalAndGetError(topKey).getRootCauses()).containsExactly(topKey).inOrder();
+    // Invalidate top via leaf, and rebuild.
+    tester.set(leafKey, new StringValue("leaf2"));
+    tester.invalidate();
+    assertThat(tester.evalAndGetError(topKey).getRootCauses()).containsExactly(topKey).inOrder();
+  }
+
+  /** Regression test for crash bug. */
+  @Test
+  public void errorTransienceDepCleared() throws Exception {
+    initializeTester();
+    final SkyKey top = GraphTester.toSkyKey("top");
+    SkyKey leaf = GraphTester.toSkyKey("leaf");
+    tester.set(leaf, new StringValue("leaf"));
+    tester.getOrCreate(top).addDependency(leaf).setHasTransientError(true);
+    EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/false, top);
+    assertTrue(result.toString(), result.hasError());
+    tester.getOrCreate(leaf, /*markAsModified=*/true);
+    tester.invalidate();
+    SkyKey irrelevant = GraphTester.toSkyKey("irrelevant");
+    tester.set(irrelevant, new StringValue("irrelevant"));
+    tester.eval(/*keepGoing=*/true, irrelevant);
+    tester.invalidateTransientErrors();
+    result = tester.eval(/*keepGoing=*/true, top);
+    assertTrue(result.toString(), result.hasError());
+  }
+
+  @Test
+  public void incompleteValueAlreadyThereNotUsed() throws Exception {
+    initializeTester();
+    SkyKey errorKey = GraphTester.toSkyKey("my_error_value");
+    tester.getOrCreate(errorKey).setHasError(true);
+    SkyKey midKey = GraphTester.toSkyKey("mid");
+    tester.getOrCreate(midKey).addErrorDependency(errorKey, new StringValue("recovered"))
+        .setComputedValue(COPY);
+    SkyKey parentKey = GraphTester.toSkyKey("parent");
+    tester.getOrCreate(parentKey).addErrorDependency(midKey, new StringValue("don't use this"))
+        .setComputedValue(COPY);
+    // Prime the graph by evaluating the mid-level value. It shouldn't be stored in the graph
+    // because
+    // it was only called during the bubbling-up phase.
+    EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/false, midKey);
+    assertEquals(null, result.get(midKey));
+    assertThat(result.getError().getRootCauses()).containsExactly(errorKey);
+    // In a keepGoing build, midKey should be re-evaluated.
+    assertEquals("recovered",
+        ((StringValue) tester.evalAndGet(/*keepGoing=*/true, parentKey)).getValue());
+  }
+
+  /**
+   * "top" requests a dependency group in which the first value, called "error", throws an
+   * exception, so "mid" and "mid2", which depend on "slow", never get built.
+   */
+  @Test
+  public void errorInDependencyGroup() throws Exception {
+    initializeTester();
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    CountDownLatch slowStart = new CountDownLatch(1);
+    CountDownLatch errorFinish = new CountDownLatch(1);
+    final SkyKey errorKey = GraphTester.toSkyKey("error");
+    tester.getOrCreate(errorKey).setBuilder(
+        new ChainedFunction(/*notifyStart=*/null, /*waitToFinish=*/slowStart,
+            /*notifyFinish=*/errorFinish, /*waitForException=*/false,
+            // ChainedFunction throws when value is null.
+            /*value=*/null, /*deps=*/ImmutableList.<SkyKey>of()));
+    SkyKey slowKey = GraphTester.toSkyKey("slow");
+    tester.getOrCreate(slowKey).setBuilder(
+        new ChainedFunction(/*notifyStart=*/slowStart, /*waitToFinish=*/errorFinish,
+            /*notifyFinish=*/null, /*waitForException=*/true,
+            new StringValue("slow"), /*deps=*/ImmutableList.<SkyKey>of()));
+    final SkyKey midKey = GraphTester.toSkyKey("mid");
+    tester.getOrCreate(midKey).addDependency(slowKey).setComputedValue(COPY);
+    final SkyKey mid2Key = GraphTester.toSkyKey("mid2");
+    tester.getOrCreate(mid2Key).addDependency(slowKey).setComputedValue(COPY);
+    tester.set(topKey, null);
+    tester.getOrCreate(topKey).setBuilder(new SkyFunction() {
+      @Override
+      public SkyValue compute(SkyKey skyKey, Environment env) throws SkyFunctionException,
+          InterruptedException {
+        env.getValues(ImmutableList.of(errorKey, midKey, mid2Key));
+        if (env.valuesMissing()) {
+          return null;
+        }
+        return new StringValue("top");
+      }
+
+      @Override
+      public String extractTag(SkyKey skyKey) {
+        return null;
+      }
+    });
+
+    // Assert that build fails and "error" really is in error.
+    EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/false, topKey);
+    assertTrue(result.hasError());
+    assertThat(result.getError(topKey).getRootCauses()).containsExactly(errorKey);
+
+    // Ensure that evaluation succeeds if errorKey does not throw an error.
+    tester.getOrCreate(errorKey).setBuilder(null);
+    tester.set(errorKey, new StringValue("ok"));
+    tester.invalidate();
+    assertEquals(new StringValue("top"), tester.evalAndGet("top"));
+  }
+
+  /**
+   * Regression test -- if value top requests {depA, depB}, depC, with depA and depC there and depB
+   * absent, and then throws an exception, the stored deps should be depA, depC (in different
+   * groups), not {depA, depC} (same group).
+   */
+  @Test
+  public void valueInErrorWithGroups() throws Exception {
+    initializeTester();
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    final SkyKey groupDepA = GraphTester.toSkyKey("groupDepA");
+    final SkyKey groupDepB = GraphTester.toSkyKey("groupDepB");
+    SkyKey depC = GraphTester.toSkyKey("depC");
+    tester.set(groupDepA, new StringValue("depC"));
+    tester.set(groupDepB, new StringValue(""));
+    tester.getOrCreate(depC).setHasError(true);
+    tester.getOrCreate(topKey).setBuilder(new NoExtractorFunction() {
+      @Override
+      public SkyValue compute(SkyKey skyKey, Environment env) throws SkyFunctionException {
+        StringValue val = ((StringValue) env.getValues(
+            ImmutableList.of(groupDepA, groupDepB)).get(groupDepA));
+        if (env.valuesMissing()) {
+          return null;
+        }
+        String nextDep = val.getValue();
+        try {
+          env.getValueOrThrow(GraphTester.toSkyKey(nextDep), SomeErrorException.class);
+        } catch (SomeErrorException e) {
+          throw new GenericFunctionException(e, Transience.PERSISTENT);
+        }
+        return env.valuesMissing() ? null : new StringValue("top");
+      }
+    });
+
+    EvaluationResult<StringValue> evaluationResult = tester.eval(
+        /*keepGoing=*/true, groupDepA, depC);
+    assertTrue(evaluationResult.hasError());
+    assertEquals("depC", evaluationResult.get(groupDepA).getValue());
+    assertThat(evaluationResult.getError(depC).getRootCauses()).containsExactly(depC).inOrder();
+    evaluationResult = tester.eval(/*keepGoing=*/false, topKey);
+    assertTrue(evaluationResult.hasError());
+    assertThat(evaluationResult.getError(topKey).getRootCauses()).containsExactly(topKey).inOrder();
+
+    tester.set(groupDepA, new StringValue("groupDepB"));
+    tester.getOrCreate(depC, /*markAsModified=*/true);
+    tester.invalidate();
+    evaluationResult = tester.eval(/*keepGoing=*/false, topKey);
+    assertFalse(evaluationResult.toString(), evaluationResult.hasError());
+    assertEquals("top", evaluationResult.get(topKey).getValue());
+  }
+
+  @Test
+  public void errorOnlyEmittedOnce() throws Exception {
+    initializeTester();
+    tester.set("x", new StringValue("y")).setWarning("fizzlepop");
+    StringValue value = (StringValue) tester.evalAndGet("x");
+    assertEquals("y", value.getValue());
+    JunitTestUtils.assertContainsEvent(eventCollector, "fizzlepop");
+    JunitTestUtils.assertEventCount(1, eventCollector);
+
+    tester.invalidate();
+    value = (StringValue) tester.evalAndGet("x");
+    assertEquals("y", value.getValue());
+    // No new events emitted.
+    JunitTestUtils.assertEventCount(1, eventCollector);
+  }
+
+  /**
+   * We are checking here that we are resilient to a race condition in which a value that is
+   * checking its children for dirtiness is signaled by all of its children, putting it in a ready
+   * state, before the thread has terminated. Optionally, one of its children may throw an error,
+   * shutting down the threadpool. This is similar to
+   * {@link ParallelEvaluatorTest#slowChildCleanup}: a child about to throw signals its parent and
+   * the parent's builder restarts itself before the exception is thrown. Here, the signaling
+   * happens while dirty dependencies are being checked, as opposed to during actual evaluation, but
+   * the principle is the same. We control the timing by blocking "top"'s registering itself on its
+   * deps.
+   */
+  private void dirtyChildEnqueuesParentDuringCheckDependencies(final boolean throwError)
+      throws Exception {
+    // Value to be built. It will be signaled to rebuild before it has finished checking its deps.
+    final SkyKey top = GraphTester.toSkyKey("top");
+    // Dep that blocks before it acknowledges being added as a dep by top, so the firstKey value has
+    // time to signal top.
+    final SkyKey slowAddingDep = GraphTester.toSkyKey("dep");
+    // Don't perform any blocking on the first build.
+    final AtomicBoolean delayTopSignaling = new AtomicBoolean(false);
+    final CountDownLatch topSignaled = new CountDownLatch(1);
+    final CountDownLatch topRestartedBuild = new CountDownLatch(1);
+    final TrackingAwaiter trackingAwaiter = new TrackingAwaiter();
+    setGraphForTesting(new NotifyingInMemoryGraph(new Listener() {
+      @Override
+      public void accept(SkyKey key, EventType type, Order order, Object context) {
+        if (!delayTopSignaling.get()) {
+          return;
+        }
+        if (key.equals(top) && type == EventType.SIGNAL && order == Order.AFTER) {
+          // top is signaled by firstKey (since slowAddingDep is blocking), so slowAddingDep is now
+          // free to acknowledge top as a parent.
+          topSignaled.countDown();
+          return;
+        }
+        if (key.equals(slowAddingDep) && type == EventType.ADD_REVERSE_DEP
+            && context.equals(top) && order == Order.BEFORE) {
+          // If top is trying to declare a dep on slowAddingDep, wait until firstKey has signaled
+          // top. Then this add dep will return DONE and top will be signaled, making it ready, so
+          // it will be enqueued.
+          trackingAwaiter.awaitLatchAndTrackExceptions(topSignaled,
+              "first key didn't signal top in time");
+        }
+      }
+    }));
+    // Value that is modified on the second build. Its thread won't finish until it signals top,
+    // which will wait for the signal before it enqueues its next dep. We prevent the thread from
+    // finishing by having the listener to which it reports its warning block until top's builder
+    // starts.
+    final SkyKey firstKey = GraphTester.skyKey("first");
+    tester.set(firstKey, new StringValue("biding"));
+    tester.set(slowAddingDep, new StringValue("dep"));
+    final AtomicInteger numTopInvocations = new AtomicInteger(0);
+    tester.getOrCreate(top).setBuilder(new NoExtractorFunction() {
+      @Override
+      public SkyValue compute(SkyKey key, SkyFunction.Environment env) {
+        numTopInvocations.incrementAndGet();
+        if (delayTopSignaling.get()) {
+          // The reporter will be given firstKey's warning to emit when it is requested as a dep
+          // below, if firstKey is already built, so we release the reporter's latch beforehand.
+          topRestartedBuild.countDown();
+        }
+        // top's builder just requests both deps in a group.
+        env.getValuesOrThrow(ImmutableList.of(firstKey, slowAddingDep), SomeErrorException.class);
+        return env.valuesMissing() ? null : new StringValue("top");
+      }
+    });
+    reporter = new DelegatingEventHandler(reporter) {
+      @Override
+      public void handle(Event e) {
+        super.handle(e);
+        if (e.getKind() == EventKind.WARNING) {
+          if (!throwError) {
+            trackingAwaiter.awaitLatchAndTrackExceptions(topRestartedBuild,
+                "top's builder did not start in time");
+          }
+        }
+      }
+    };
+    // First build : just prime the graph.
+    EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/false, top);
+    assertFalse(result.hasError());
+    assertEquals(new StringValue("top"), result.get(top));
+    assertEquals(2, numTopInvocations.get());
+    // Now dirty the graph, and maybe have firstKey throw an error.
+    String warningText = "warning text";
+    tester.getOrCreate(firstKey, /*markAsModified=*/true).setHasError(throwError)
+        .setWarning(warningText);
+    tester.invalidate();
+    delayTopSignaling.set(true);
+    result = tester.eval(/*keepGoing=*/false, top);
+    trackingAwaiter.assertNoErrors();
+    if (throwError) {
+      assertTrue(result.hasError());
+      assertThat(result.keyNames()).isEmpty(); // No successfully evaluated values.
+      ErrorInfo errorInfo = result.getError(top);
+      assertThat(errorInfo.getRootCauses()).containsExactly(firstKey);
+      assertEquals("on the incremental build, top's builder should have only been used in error "
+          + "bubbling", 3, numTopInvocations.get());
+    } else {
+      assertEquals(new StringValue("top"), result.get(top));
+      assertFalse(result.hasError());
+      assertEquals("on the incremental build, top's builder should have only been executed once in "
+          + "normal evaluation", 3, numTopInvocations.get());
+    }
+    JunitTestUtils.assertContainsEvent(eventCollector, warningText);
+    assertEquals(0, topSignaled.getCount());
+    assertEquals(0, topRestartedBuild.getCount());
+  }
+
+  @Test
+  public void dirtyChildEnqueuesParentDuringCheckDependencies_ThrowDoesntEnqueue()
+      throws Exception {
+    dirtyChildEnqueuesParentDuringCheckDependencies(/*throwError=*/true);
+  }
+
+  @Test
+  public void dirtyChildEnqueuesParentDuringCheckDependencies_NoThrow() throws Exception {
+    dirtyChildEnqueuesParentDuringCheckDependencies(/*throwError=*/false);
+  }
+
+  /**
+   * The same dep is requested in two groups, but its value determines what the other dep in the
+   * second group is. When it changes, the other dep in the second group should not be requested.
+   */
+  @Test
+  public void sameDepInTwoGroups() throws Exception {
+    initializeTester();
+
+    // leaf4 should not built in the second build.
+    final SkyKey leaf4 = GraphTester.toSkyKey("leaf4");
+    final AtomicBoolean shouldNotBuildLeaf4 = new AtomicBoolean(false);
+    setGraphForTesting(new NotifyingInMemoryGraph(new Listener() {
+      @Override
+      public void accept(SkyKey key, EventType type, Order order, Object context) {
+        if (shouldNotBuildLeaf4.get() && key.equals(leaf4)) {
+          throw new IllegalStateException("leaf4 should not have been considered this build: "
+              + type + ", " + order + ", " + context);
+        }
+      }
+    }));
+    tester.set(leaf4, new StringValue("leaf4"));
+
+    // Create leaf0, leaf1 and leaf2 values with values "leaf2", "leaf3", "leaf4" respectively.
+    // These will be requested as one dependency group. In the second build, leaf2 will have the
+    // value "leaf5".
+    final List<SkyKey> leaves = new ArrayList<>();
+    for (int i = 0; i <= 2; i++) {
+      SkyKey leaf = GraphTester.toSkyKey("leaf" + i);
+      leaves.add(leaf);
+      tester.set(leaf, new StringValue("leaf" + (i + 2)));
+    }
+
+    // Create "top" value. It depends on all leaf values in two overlapping dependency groups.
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    final SkyValue topValue = new StringValue("top");
+    tester.getOrCreate(topKey).setBuilder(new NoExtractorFunction() {
+      @Override
+      public SkyValue compute(SkyKey skyKey, Environment env) throws SkyFunctionException,
+          InterruptedException {
+        // Request the first group, [leaf0, leaf1, leaf2].
+        // In the first build, it has values ["leaf2", "leaf3", "leaf4"].
+        // In the second build it has values ["leaf2", "leaf3", "leaf5"]
+        Map<SkyKey, SkyValue> values = env.getValues(leaves);
+        if (env.valuesMissing()) {
+          return null;
+        }
+
+        // Request the second group. In the first build it's [leaf2, leaf4].
+        // In the second build it's [leaf2, leaf5]
+        env.getValues(ImmutableList.of(leaves.get(2),
+            GraphTester.toSkyKey(((StringValue) values.get(leaves.get(2))).getValue())));
+        if (env.valuesMissing()) {
+          return null;
+        }
+
+        return topValue;
+      }
+    });
+
+    // First build: assert we can evaluate "top".
+    assertEquals(topValue, tester.evalAndGet(/*keepGoing=*/false, topKey));
+
+    // Second build: replace "leaf4" by "leaf5" in leaf2's value. Assert leaf4 is not requested.
+    final SkyKey leaf5 = GraphTester.toSkyKey("leaf5");
+    tester.set(leaf5, new StringValue("leaf5"));
+    tester.set(leaves.get(2), new StringValue("leaf5"));
+    tester.invalidate();
+    shouldNotBuildLeaf4.set(true);
+    assertEquals(topValue, tester.evalAndGet(/*keepGoing=*/false, topKey));
+  }
+
+  @Test
+  public void dirtyAndChanged() throws Exception {
+    initializeTester();
+    SkyKey leaf = GraphTester.toSkyKey("leaf");
+    SkyKey mid = GraphTester.toSkyKey("mid");
+    SkyKey top = GraphTester.toSkyKey("top");
+    tester.getOrCreate(top).addDependency(mid).setComputedValue(COPY);
+    tester.getOrCreate(mid).addDependency(leaf).setComputedValue(COPY);
+    tester.set(leaf, new StringValue("leafy"));
+    // For invalidation.
+    tester.set("dummy", new StringValue("dummy"));
+    StringValue topValue = (StringValue) tester.evalAndGet("top");
+    assertEquals("leafy", topValue.getValue());
+    tester.set(leaf, new StringValue("crunchy"));
+    tester.invalidate();
+    // For invalidation.
+    tester.evalAndGet("dummy");
+    tester.getOrCreate(mid, /*markAsModified=*/true);
+    tester.invalidate();
+    topValue = (StringValue) tester.evalAndGet("top");
+    assertEquals("crunchy", topValue.getValue());
+  }
+
+  /**
+   * Test whether a value that was already marked changed will be incorrectly marked dirty, not
+   * changed, if another thread tries to mark it just dirty. To exercise this, we need to have a
+   * race condition where both threads see that the value is not dirty yet, then the "changed"
+   * thread marks the value changed before the "dirty" thread marks the value dirty. To accomplish
+   * this, we use a countdown latch to make the "dirty" thread wait until the "changed" thread is
+   * done, and another countdown latch to make both of them wait until they have both checked if the
+   * value is currently clean.
+   */
+  @Test
+  public void dirtyAndChangedValueIsChanged() throws Exception {
+    final SkyKey parent = GraphTester.toSkyKey("parent");
+    final AtomicBoolean blockingEnabled = new AtomicBoolean(false);
+    final CountDownLatch waitForChanged = new CountDownLatch(1);
+    // changed thread checks value entry once (to see if it is changed). dirty thread checks twice,
+    // to see if it is changed, and if it is dirty.
+    final CountDownLatch threadsStarted = new CountDownLatch(3);
+    final TrackingAwaiter trackingAwaiter = new TrackingAwaiter();
+    setGraphForTesting(new NotifyingInMemoryGraph(new Listener() {
+      @Override
+      public void accept(SkyKey key, EventType type, Order order, Object context) {
+        if (!blockingEnabled.get()) {
+          return;
+        }
+        if (!key.equals(parent)) {
+          return;
+        }
+        if (type == EventType.IS_CHANGED && order == Order.BEFORE) {
+          threadsStarted.countDown();
+        }
+        // Dirtiness only checked by dirty thread.
+        if (type == EventType.IS_DIRTY && order == Order.BEFORE) {
+          threadsStarted.countDown();
+        }
+        if (type == EventType.MARK_DIRTY) {
+          trackingAwaiter.awaitLatchAndTrackExceptions(threadsStarted,
+              "Both threads did not query if value isChanged in time");
+          boolean isChanged = (Boolean) context;
+          if (order == Order.BEFORE && !isChanged) {
+            trackingAwaiter.awaitLatchAndTrackExceptions(waitForChanged,
+                "'changed' thread did not mark value changed in time");
+            return;
+          }
+          if (order == Order.AFTER && isChanged) {
+            waitForChanged.countDown();
+          }
+        }
+      }
+    }));
+    SkyKey leaf = GraphTester.toSkyKey("leaf");
+    tester.set(leaf, new StringValue("leaf"));
+    tester.getOrCreate(parent).addDependency(leaf).setComputedValue(CONCATENATE);
+    EvaluationResult<StringValue> result;
+    result = tester.eval(/*keepGoing=*/false, parent);
+    assertEquals("leaf", result.get(parent).getValue());
+    // Invalidate leaf, but don't actually change it. It will transitively dirty parent
+    // concurrently with parent directly dirtying itself.
+    tester.getOrCreate(leaf, /*markAsModified=*/true);
+    SkyKey other2 = GraphTester.toSkyKey("other2");
+    tester.set(other2, new StringValue("other2"));
+    // Invalidate parent, actually changing it.
+    tester.getOrCreate(parent, /*markAsModified=*/true).addDependency(other2);
+    tester.invalidate();
+    blockingEnabled.set(true);
+    result = tester.eval(/*keepGoing=*/false, parent);
+    assertEquals("leafother2", result.get(parent).getValue());
+    trackingAwaiter.assertNoErrors();
+    assertEquals(0, waitForChanged.getCount());
+    assertEquals(0, threadsStarted.getCount());
+  }
+
+  @Test
+  public void singleValueDependsOnManyDirtyValues() throws Exception {
+    initializeTester();
+    SkyKey[] values = new SkyKey[TEST_NODE_COUNT];
+    StringBuilder expected = new StringBuilder();
+    for (int i = 0; i < values.length; i++) {
+      String valueName = Integer.toString(i);
+      values[i] = GraphTester.toSkyKey(valueName);
+      tester.set(values[i], new StringValue(valueName));
+      expected.append(valueName);
+    }
+    SkyKey topKey = new SkyKey(GraphTester.NODE_TYPE, "top");
+    TestFunction value = tester.getOrCreate(topKey)
+        .setComputedValue(CONCATENATE);
+    for (int i = 0; i < values.length; i++) {
+      value.addDependency(values[i]);
+    }
+
+    EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/false, topKey);
+    assertEquals(new StringValue(expected.toString()), result.get(topKey));
+
+    for (int j = 0; j < RUNS; j++) {
+      for (int i = 0; i < values.length; i++) {
+        tester.getOrCreate(values[i], /*markAsModified=*/true);
+      }
+      // This value has an error, but we should never discover it because it is not marked changed
+      // and all of its dependencies re-evaluate to the same thing.
+      tester.getOrCreate(topKey, /*markAsModified=*/false).setHasError(true);
+      tester.invalidate();
+
+      result = tester.eval(/*keep_going=*/false, topKey);
+      assertEquals(new StringValue(expected.toString()), result.get(topKey));
+    }
+  }
+
+  /**
+   * Tests scenario where we have dirty values in the graph, and then one of them is deleted since
+   * its evaluation did not complete before an error was thrown. Can either test the graph via an
+   * evaluation of that deleted value, or an invalidation of a child, and can either remove the
+   * thrown error or throw it again on that evaluation.
+   */
+  private void dirtyValueChildrenProperlyRemovedOnEarlyBuildAbort(
+      boolean reevaluateMissingValue, boolean removeError) throws Exception {
+    initializeTester();
+    SkyKey errorKey = GraphTester.toSkyKey("error");
+    tester.set(errorKey, new StringValue("biding time"));
+    SkyKey slowKey = GraphTester.toSkyKey("slow");
+    tester.set(slowKey, new StringValue("slow"));
+    SkyKey midKey = GraphTester.toSkyKey("mid");
+    tester.getOrCreate(midKey).addDependency(slowKey).setComputedValue(COPY);
+    SkyKey lastKey = GraphTester.toSkyKey("last");
+    tester.set(lastKey, new StringValue("last"));
+    SkyKey motherKey = GraphTester.toSkyKey("mother");
+    tester.getOrCreate(motherKey).addDependency(errorKey)
+        .addDependency(midKey).addDependency(lastKey).setComputedValue(CONCATENATE);
+    SkyKey fatherKey = GraphTester.toSkyKey("father");
+    tester.getOrCreate(fatherKey).addDependency(errorKey)
+        .addDependency(midKey).addDependency(lastKey).setComputedValue(CONCATENATE);
+    EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/false, motherKey, fatherKey);
+    assertEquals("biding timeslowlast", result.get(motherKey).getValue());
+    assertEquals("biding timeslowlast", result.get(fatherKey).getValue());
+    tester.set(slowKey, null);
+    // Each parent depends on errorKey, midKey, lastKey. We keep slowKey waiting until errorKey is
+    // finished. So there is no way lastKey can be enqueued by either parent. Thus, the parent that
+    // is cleaned has not interacted with lastKey this build. Still, lastKey's reverse dep on that
+    // parent should be removed.
+    CountDownLatch errorFinish = new CountDownLatch(1);
+    tester.set(errorKey, null);
+    tester.getOrCreate(errorKey).setBuilder(
+        new ChainedFunction(/*notifyStart=*/null, /*waitToFinish=*/null,
+            /*notifyFinish=*/errorFinish, /*waitForException=*/false, /*value=*/null,
+            /*deps=*/ImmutableList.<SkyKey>of()));
+    tester.getOrCreate(slowKey).setBuilder(
+        new ChainedFunction(/*notifyStart=*/null, /*waitToFinish=*/errorFinish,
+            /*notifyFinish=*/null, /*waitForException=*/true, new StringValue("leaf2"),
+            /*deps=*/ImmutableList.<SkyKey>of()));
+    tester.invalidate();
+    // errorKey finishes, written to graph -> leafKey maybe starts+finishes & (Visitor aborts)
+    // -> one of mother or father builds. The other one should be cleaned, and no references to it
+    // left in the graph.
+    result = tester.eval(/*keepGoing=*/false, motherKey, fatherKey);
+    assertTrue(result.hasError());
+    // Only one of mother or father should be in the graph.
+    assertTrue(result.getError(motherKey) + ", " + result.getError(fatherKey),
+        (result.getError(motherKey) == null) != (result.getError(fatherKey) == null));
+    SkyKey parentKey = (reevaluateMissingValue == (result.getError(motherKey) == null))
+        ? motherKey : fatherKey;
+    // Give slowKey a nice ordinary builder.
+    tester.getOrCreate(slowKey, /*markAsModified=*/false).setBuilder(null)
+        .setConstantValue(new StringValue("leaf2"));
+    if (removeError) {
+      tester.getOrCreate(errorKey, /*markAsModified=*/true).setBuilder(null)
+          .setConstantValue(new StringValue("reformed"));
+    }
+    String lastString = "last";
+    if (!reevaluateMissingValue) {
+      // Mark the last key modified if we're not trying the absent value again. This invalidation
+      // will test if lastKey still has a reference to the absent value.
+      lastString = "last2";
+      tester.set(lastKey, new StringValue(lastString));
+    }
+    tester.invalidate();
+    result = tester.eval(/*keepGoing=*/false, parentKey);
+    if (removeError) {
+      assertEquals("reformedleaf2" + lastString, result.get(parentKey).getValue());
+    } else {
+      assertNotNull(result.getError(parentKey));
+    }
+  }
+
+  /**
+   * The following four tests (dirtyChildrenProperlyRemovedWith*) test the consistency of the graph
+   * after a failed build in which a dirty value should have been deleted from the graph. The
+   * consistency is tested via either evaluating the missing value, or the re-evaluating the present
+   * value, and either clearing the error or keeping it. To evaluate the present value, we
+   * invalidate the error value to force re-evaluation. Related to bug "skyframe m1: graph may not
+   * be properly cleaned on interrupt or failure".
+   */
+  @Test
+  public void dirtyChildrenProperlyRemovedWithInvalidateRemoveError() throws Exception {
+    dirtyValueChildrenProperlyRemovedOnEarlyBuildAbort(/*reevaluateMissingValue=*/false,
+        /*removeError=*/true);
+  }
+
+  @Test
+  public void dirtyChildrenProperlyRemovedWithInvalidateKeepError() throws Exception {
+    dirtyValueChildrenProperlyRemovedOnEarlyBuildAbort(/*reevaluateMissingValue=*/false,
+        /*removeError=*/false);
+  }
+
+  @Test
+  public void dirtyChildrenProperlyRemovedWithReevaluateRemoveError() throws Exception {
+    dirtyValueChildrenProperlyRemovedOnEarlyBuildAbort(/*reevaluateMissingValue=*/true,
+        /*removeError=*/true);
+  }
+
+  @Test
+  public void dirtyChildrenProperlyRemovedWithReevaluateKeepError() throws Exception {
+    dirtyValueChildrenProperlyRemovedOnEarlyBuildAbort(/*reevaluateMissingValue=*/true,
+        /*removeError=*/false);
+  }
+
+  /**
+   * Regression test: enqueue so many values that some of them won't have started processing, and
+   * then either interrupt processing or have a child throw an error. In the latter case, this also
+   * tests that a value that hasn't started processing can still have a child error bubble up to it.
+   * In both cases, it tests that the graph is properly cleaned of the dirty values and references
+   * to them.
+   */
+  private void manyDirtyValuesClearChildrenOnFail(boolean interrupt) throws Exception {
+    SkyKey leafKey = GraphTester.toSkyKey("leaf");
+    tester.set(leafKey, new StringValue("leafy"));
+    SkyKey lastKey = GraphTester.toSkyKey("last");
+    tester.set(lastKey, new StringValue("last"));
+    final List<SkyKey> tops = new ArrayList<>();
+    // Request far more top-level values than there are threads, so some of them will block until
+    // the
+    // leaf child is enqueued for processing.
+    for (int i = 0; i < 10000; i++) {
+      SkyKey topKey = GraphTester.toSkyKey("top" + i);
+      tester.getOrCreate(topKey).addDependency(leafKey).addDependency(lastKey)
+          .setComputedValue(CONCATENATE);
+      tops.add(topKey);
+    }
+    tester.eval(/*keepGoing=*/false, tops.toArray(new SkyKey[0]));
+    final CountDownLatch notifyStart = new CountDownLatch(1);
+    tester.set(leafKey, null);
+    if (interrupt) {
+      // leaf will wait for an interrupt if desired. We cannot use the usual ChainedFunction
+      // because we need to actually throw the interrupt.
+      final AtomicBoolean shouldSleep = new AtomicBoolean(true);
+      tester.getOrCreate(leafKey, /*markAsModified=*/true).setBuilder(
+          new NoExtractorFunction() {
+            @Override
+            public SkyValue compute(SkyKey skyKey, Environment env) throws InterruptedException {
+              notifyStart.countDown();
+              if (shouldSleep.get()) {
+                // Should be interrupted within 5 seconds.
+                Thread.sleep(5000);
+                throw new AssertionError("leaf was not interrupted");
+              }
+              return new StringValue("crunchy");
+            }
+          });
+      tester.invalidate();
+      TestThread evalThread = new TestThread() {
+        @Override
+        public void runTest() {
+          try {
+            tester.eval(/*keepGoing=*/false, tops.toArray(new SkyKey[0]));
+            Assert.fail();
+          } catch (InterruptedException e) {
+            // Expected.
+          }
+        }
+      };
+      evalThread.start();
+      assertTrue(notifyStart.await(TestUtils.WAIT_TIMEOUT_SECONDS, TimeUnit.SECONDS));
+      evalThread.interrupt();
+      evalThread.joinAndAssertState(TestUtils.WAIT_TIMEOUT_MILLISECONDS);
+      // Free leafKey to compute next time.
+      shouldSleep.set(false);
+    } else {
+      // Non-interrupt case. Just throw an error in the child.
+      tester.getOrCreate(leafKey, /*markAsModified=*/true).setHasError(true);
+      tester.invalidate();
+      // The error thrown may non-deterministically bubble up to a parent that has not yet started
+      // processing, but has been enqueued for processing.
+      tester.eval(/*keepGoing=*/false, tops.toArray(new SkyKey[0]));
+      tester.getOrCreate(leafKey, /*markAsModified=*/true).setHasError(false);
+      tester.set(leafKey, new StringValue("crunchy"));
+    }
+    // lastKey was not touched during the previous build, but its reverse deps on its parents should
+    // still be accurate.
+    tester.set(lastKey, new StringValue("new last"));
+    tester.invalidate();
+    EvaluationResult<StringValue> result =
+        tester.eval(/*keepGoing=*/false, tops.toArray(new SkyKey[0]));
+    for (SkyKey topKey : tops) {
+      assertEquals(topKey.toString(), "crunchynew last", result.get(topKey).getValue());
+    }
+  }
+
+  /**
+   * Regression test: make sure that if an evaluation fails before a dirty value starts evaluation
+   * (in particular, before it is reset), the graph remains consistent.
+   */
+  @Test
+  public void manyDirtyValuesClearChildrenOnError() throws Exception {
+    manyDirtyValuesClearChildrenOnFail(/*interrupt=*/false);
+  }
+
+  /**
+   * Regression test: Make sure that if an evaluation is interrupted before a dirty value starts
+   * evaluation (in particular, before it is reset), the graph remains consistent.
+   */
+  @Test
+  public void manyDirtyValuesClearChildrenOnInterrupt() throws Exception {
+    manyDirtyValuesClearChildrenOnFail(/*interrupt=*/true);
+  }
+
+  /**
+   * Regression test for case where the user requests that we delete nodes that are already in the
+   * queue to be dirtied. We should handle that gracefully and not complain.
+   */
+  @Test
+  public void deletingDirtyNodes() throws Exception {
+    final Thread thread = Thread.currentThread();
+    final AtomicBoolean interruptInvalidation = new AtomicBoolean(false);
+    initializeTester(new TrackingInvalidationReceiver() {
+      private final AtomicBoolean firstInvalidation = new AtomicBoolean(true);
+      @Override
+      public void invalidated(SkyValue value, InvalidationState state) {
+        if (interruptInvalidation.get() && !firstInvalidation.getAndSet(false)) {
+          thread.interrupt();
+        }
+        super.invalidated(value, state);
+      }
+    });
+    SkyKey key = null;
+    // Create a long chain of nodes. Most of them will not actually be dirtied, but the last one to
+    // be dirtied will enqueue its parent for dirtying, so it will be in the queue for the next run.
+    for (int i = 0; i < TEST_NODE_COUNT; i++) {
+      key = GraphTester.toSkyKey("node" + i);
+      if (i > 0) {
+        tester.getOrCreate(key).addDependency("node" + (i - 1)).setComputedValue(COPY);
+      } else {
+        tester.set(key, new StringValue("node0"));
+      }
+    }
+    // Seed the graph.
+    assertEquals("node0", ((StringValue) tester.evalAndGet(/*keepGoing=*/false, key)).getValue());
+    // Start the dirtying process.
+    tester.set("node0", new StringValue("new"));
+    tester.invalidate();
+    interruptInvalidation.set(true);
+    try {
+      tester.eval(/*keepGoing=*/false, key);
+      fail();
+    } catch (InterruptedException e) {
+      // Expected.
+    }
+    interruptInvalidation.set(false);
+    // Now delete all the nodes. The node that was going to be dirtied is also deleted, which we
+    // should handle.
+    tester.graph.delete(Predicates.<SkyKey>alwaysTrue());
+    assertEquals("new", ((StringValue) tester.evalAndGet(/*keepGoing=*/false, key)).getValue());
+  }
+
+  @Test
+  public void changePruning() throws Exception {
+    initializeTester();
+    SkyKey leaf = GraphTester.toSkyKey("leaf");
+    SkyKey mid = GraphTester.toSkyKey("mid");
+    SkyKey top = GraphTester.toSkyKey("top");
+    tester.getOrCreate(top).addDependency(mid).setComputedValue(COPY);
+    tester.getOrCreate(mid).addDependency(leaf).setComputedValue(COPY);
+    tester.set(leaf, new StringValue("leafy"));
+    StringValue topValue = (StringValue) tester.evalAndGet("top");
+    assertEquals("leafy", topValue.getValue());
+    // Mark leaf changed, but don't actually change it.
+    tester.getOrCreate(leaf, /*markAsModified=*/true);
+    // mid will give an error if re-evaluated, but it shouldn't be because it is not marked changed,
+    // and its dirty child will evaluate to the same element.
+    tester.getOrCreate(mid, /*markAsModified=*/false).setHasError(true);
+    tester.invalidate();
+    EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/false, top);
+    assertFalse(result.hasError());
+    topValue = result.get(top);
+    assertEquals("leafy", topValue.getValue());
+    assertThat(tester.getDirtyValues()).isEmpty();
+    assertThat(tester.getDeletedValues()).isEmpty();
+  }
+
+  @Test
+  public void changePruningWithDoneValue() throws Exception {
+    initializeTester();
+    SkyKey leaf = GraphTester.toSkyKey("leaf");
+    SkyKey mid = GraphTester.toSkyKey("mid");
+    SkyKey top = GraphTester.toSkyKey("top");
+    SkyKey suffix = GraphTester.toSkyKey("suffix");
+    StringValue suffixValue = new StringValue("suffix");
+    tester.set(suffix, suffixValue);
+    tester.getOrCreate(top).addDependency(mid).addDependency(suffix).setComputedValue(CONCATENATE);
+    tester.getOrCreate(mid).addDependency(leaf).addDependency(suffix).setComputedValue(CONCATENATE);
+    SkyValue leafyValue = new StringValue("leafy");
+    tester.set(leaf, leafyValue);
+    StringValue value = (StringValue) tester.evalAndGet("top");
+    assertEquals("leafysuffixsuffix", value.getValue());
+    // Mark leaf changed, but don't actually change it.
+    tester.getOrCreate(leaf, /*markAsModified=*/true);
+    // mid will give an error if re-evaluated, but it shouldn't be because it is not marked changed,
+    // and its dirty child will evaluate to the same element.
+    tester.getOrCreate(mid, /*markAsModified=*/false).setHasError(true);
+    tester.invalidate();
+    value = (StringValue) tester.evalAndGet("leaf");
+    assertEquals("leafy", value.getValue());
+    assertThat(tester.getDirtyValues()).containsExactly(new StringValue("leafysuffix"),
+        new StringValue("leafysuffixsuffix"));
+    assertThat(tester.getDeletedValues()).isEmpty();
+    EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/false, top);
+    assertFalse(result.hasError());
+    value = result.get(top);
+    assertEquals("leafysuffixsuffix", value.getValue());
+    assertThat(tester.getDirtyValues()).isEmpty();
+    assertThat(tester.getDeletedValues()).isEmpty();
+  }
+
+  @Test
+  public void changedChildChangesDepOfParent() throws Exception {
+    initializeTester();
+    final SkyKey buildFile = GraphTester.toSkyKey("buildFile");
+    ValueComputer authorDrink = new ValueComputer() {
+      @Override
+      public SkyValue compute(Map<SkyKey, SkyValue> deps, SkyFunction.Environment env) {
+        String author = ((StringValue) deps.get(buildFile)).getValue();
+        StringValue beverage;
+        switch (author) {
+          case "hemingway":
+            beverage = (StringValue) env.getValue(GraphTester.toSkyKey("absinthe"));
+            break;
+          case "joyce":
+            beverage = (StringValue) env.getValue(GraphTester.toSkyKey("whiskey"));
+            break;
+          default:
+              throw new IllegalStateException(author);
+        }
+        if (beverage == null) {
+          return null;
+        }
+        return new StringValue(author + " drank " + beverage.getValue());
+      }
+    };
+
+    tester.set(buildFile, new StringValue("hemingway"));
+    SkyKey absinthe = GraphTester.toSkyKey("absinthe");
+    tester.set(absinthe, new StringValue("absinthe"));
+    SkyKey whiskey = GraphTester.toSkyKey("whiskey");
+    tester.set(whiskey, new StringValue("whiskey"));
+    SkyKey top = GraphTester.toSkyKey("top");
+    tester.getOrCreate(top).addDependency(buildFile).setComputedValue(authorDrink);
+    StringValue topValue = (StringValue) tester.evalAndGet("top");
+    assertEquals("hemingway drank absinthe", topValue.getValue());
+    tester.set(buildFile, new StringValue("joyce"));
+    // Don't evaluate absinthe successfully anymore.
+    tester.getOrCreate(absinthe).setHasError(true);
+    tester.invalidate();
+    topValue = (StringValue) tester.evalAndGet("top");
+    assertEquals("joyce drank whiskey", topValue.getValue());
+    assertThat(tester.getDirtyValues()).containsExactly(new StringValue("hemingway"),
+        new StringValue("hemingway drank absinthe"));
+    assertThat(tester.getDeletedValues()).isEmpty();
+  }
+
+  @Test
+  public void dirtyDepIgnoresChildren() throws Exception {
+    initializeTester();
+    SkyKey leaf = GraphTester.toSkyKey("leaf");
+    SkyKey mid = GraphTester.toSkyKey("mid");
+    SkyKey top = GraphTester.toSkyKey("top");
+    tester.set(mid, new StringValue("ignore"));
+    tester.getOrCreate(top).addDependency(mid).setComputedValue(COPY);
+    tester.getOrCreate(mid).addDependency(leaf);
+    tester.set(leaf, new StringValue("leafy"));
+    StringValue topValue = (StringValue) tester.evalAndGet("top");
+    assertEquals("ignore", topValue.getValue());
+    assertThat(tester.getDirtyValues()).isEmpty();
+    assertThat(tester.getDeletedValues()).isEmpty();
+    // Change leaf.
+    tester.set(leaf, new StringValue("crunchy"));
+    tester.invalidate();
+    topValue = (StringValue) tester.evalAndGet("top");
+    assertEquals("ignore", topValue.getValue());
+    assertThat(tester.getDirtyValues()).containsExactly(new StringValue("leafy"));
+    assertThat(tester.getDeletedValues()).isEmpty();
+    tester.set(leaf, new StringValue("smushy"));
+    tester.invalidate();
+    topValue = (StringValue) tester.evalAndGet("top");
+    assertEquals("ignore", topValue.getValue());
+    assertThat(tester.getDirtyValues()).containsExactly(new StringValue("crunchy"));
+    assertThat(tester.getDeletedValues()).isEmpty();
+  }
+
+  private static final SkyFunction INTERRUPT_BUILDER = new SkyFunction() {
+
+    @Override
+    public SkyValue compute(SkyKey skyKey, Environment env) throws SkyFunctionException,
+        InterruptedException {
+      throw new InterruptedException();
+    }
+
+    @Override
+    public String extractTag(SkyKey skyKey) {
+      throw new UnsupportedOperationException();
+    }
+  };
+
+  /**
+   * Utility function to induce a graph clean of whatever value is requested, by trying to build
+   * this value and interrupting the build as soon as this value's function evaluation starts.
+   */
+  private void failBuildAndRemoveValue(final SkyKey value) {
+    tester.set(value, null);
+    // Evaluator will think leaf was interrupted because it threw, so it will be cleaned from graph.
+    tester.getOrCreate(value, /*markAsModified=*/true).setBuilder(INTERRUPT_BUILDER);
+    tester.invalidate();
+    try {
+      tester.eval(/*keepGoing=*/false, value);
+      Assert.fail();
+    } catch (InterruptedException e) {
+      // Expected.
+    }
+    tester.getOrCreate(value, /*markAsModified=*/false).setBuilder(null);
+  }
+
+  /**
+   * Make sure that when a dirty value is building, the fact that a child may no longer exist in the
+   * graph doesn't cause problems.
+   */
+  @Test
+  public void dirtyBuildAfterFailedBuild() throws Exception {
+    initializeTester();
+    final SkyKey leaf = GraphTester.toSkyKey("leaf");
+    SkyKey top = GraphTester.toSkyKey("top");
+    tester.getOrCreate(top).addDependency(leaf).setComputedValue(COPY);
+    tester.set(leaf, new StringValue("leafy"));
+    StringValue topValue = (StringValue) tester.evalAndGet("top");
+    assertEquals("leafy", topValue.getValue());
+    assertThat(tester.getDirtyValues()).isEmpty();
+    assertThat(tester.getDeletedValues()).isEmpty();
+    failBuildAndRemoveValue(leaf);
+    // Leaf should no longer exist in the graph. Check that this doesn't cause problems.
+    tester.set(leaf, null);
+    tester.set(leaf, new StringValue("crunchy"));
+    tester.invalidate();
+    topValue = (StringValue) tester.evalAndGet("top");
+    assertEquals("crunchy", topValue.getValue());
+  }
+
+  /**
+   * Regression test: error when clearing reverse deps on dirty value about to be rebuilt, because
+   * child values were deleted and recreated in interim, forgetting they had reverse dep on dirty
+   * value in the first place.
+   */
+  @Test
+  public void changedBuildAfterFailedThenSuccessfulBuild() throws Exception {
+    initializeTester();
+    final SkyKey leaf = GraphTester.toSkyKey("leaf");
+    SkyKey top = GraphTester.toSkyKey("top");
+    tester.getOrCreate(top).addDependency(leaf).setComputedValue(COPY);
+    tester.set(leaf, new StringValue("leafy"));
+    StringValue topValue = (StringValue) tester.evalAndGet("top");
+    assertEquals("leafy", topValue.getValue());
+    assertThat(tester.getDirtyValues()).isEmpty();
+    assertThat(tester.getDeletedValues()).isEmpty();
+    failBuildAndRemoveValue(leaf);
+    tester.set(leaf, new StringValue("crunchy"));
+    tester.invalidate();
+    tester.eval(/*keepGoing=*/false, leaf);
+    // Leaf no longer has reverse dep on top. Check that this doesn't cause problems, even if the
+    // top value is evaluated unconditionally.
+    tester.getOrCreate(top, /*markAsModified=*/true);
+    tester.invalidate();
+    topValue = (StringValue) tester.evalAndGet("top");
+    assertEquals("crunchy", topValue.getValue());
+  }
+
+  /**
+   * Regression test: child value that has been deleted since it and its parent were marked dirty no
+   * longer knows it has a reverse dep on its parent.
+   *
+   * <p>Start with:
+   * <pre>
+   *              top0  ... top1000
+   *                  \  | /
+   *                   leaf
+   * </pre>
+   * Then fail to build leaf. Now the entry for leaf should have no "memory" that it was ever
+   * depended on by tops. Now build tops, but fail again.
+   */
+  @Test
+  public void manyDirtyValuesClearChildrenOnSecondFail() throws Exception {
+    final SkyKey leafKey = GraphTester.toSkyKey("leaf");
+    tester.set(leafKey, new StringValue("leafy"));
+    SkyKey lastKey = GraphTester.toSkyKey("last");
+    tester.set(lastKey, new StringValue("last"));
+    final List<SkyKey> tops = new ArrayList<>();
+    // Request far more top-level values than there are threads, so some of them will block until
+    // the leaf child is enqueued for processing.
+    for (int i = 0; i < 10000; i++) {
+      SkyKey topKey = GraphTester.toSkyKey("top" + i);
+      tester.getOrCreate(topKey).addDependency(leafKey).addDependency(lastKey)
+          .setComputedValue(CONCATENATE);
+      tops.add(topKey);
+    }
+    tester.eval(/*keepGoing=*/false, tops.toArray(new SkyKey[0]));
+    failBuildAndRemoveValue(leafKey);
+    // Request the tops. Since leaf was deleted from the graph last build, it no longer knows that
+    // its parents depend on it. When leaf throws, at least one of its parents (hopefully) will not
+    // have re-informed leaf that the parent depends on it, exposing the bug, since the parent
+    // should then not try to clean the reverse dep from leaf.
+    tester.set(leafKey, null);
+    // Evaluator will think leaf was interrupted because it threw, so it will be cleaned from graph.
+    tester.getOrCreate(leafKey, /*markAsModified=*/true).setBuilder(INTERRUPT_BUILDER);
+    tester.invalidate();
+    try {
+      tester.eval(/*keepGoing=*/false, tops.toArray(new SkyKey[0]));
+      Assert.fail();
+    } catch (InterruptedException e) {
+      // Expected.
+    }
+  }
+
+  @Test
+  public void failedDirtyBuild() throws Exception {
+    initializeTester();
+    SkyKey leaf = GraphTester.toSkyKey("leaf");
+    SkyKey top = GraphTester.toSkyKey("top");
+    tester.getOrCreate(top).addErrorDependency(leaf, new StringValue("recover"))
+        .setComputedValue(COPY);
+    tester.set(leaf, new StringValue("leafy"));
+    StringValue topValue = (StringValue) tester.evalAndGet("top");
+    assertEquals("leafy", topValue.getValue());
+    assertThat(tester.getDirtyValues()).isEmpty();
+    assertThat(tester.getDeletedValues()).isEmpty();
+    // Change leaf.
+    tester.getOrCreate(leaf, /*markAsModified=*/true).setHasError(true);
+    tester.getOrCreate(top, /*markAsModified=*/false).setHasError(true);
+    tester.invalidate();
+    EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/false, top);
+    assertNull("value should not have completed evaluation", result.get(top));
+    assertWithMessage(
+        "The error thrown by leaf should have been swallowed by the error thrown by top")
+        .that(result.getError().getRootCauses()).containsExactly(top);
+  }
+
+  @Test
+  public void failedDirtyBuildInBuilder() throws Exception {
+    initializeTester();
+    SkyKey leaf = GraphTester.toSkyKey("leaf");
+    SkyKey secondError = GraphTester.toSkyKey("secondError");
+    SkyKey top = GraphTester.toSkyKey("top");
+    tester.getOrCreate(top).addDependency(leaf)
+        .addErrorDependency(secondError, new StringValue("recover")).setComputedValue(CONCATENATE);
+    tester.set(secondError, new StringValue("secondError")).addDependency(leaf);
+    tester.set(leaf, new StringValue("leafy"));
+    StringValue topValue = (StringValue) tester.evalAndGet("top");
+    assertEquals("leafysecondError", topValue.getValue());
+    assertThat(tester.getDirtyValues()).isEmpty();
+    assertThat(tester.getDeletedValues()).isEmpty();
+    // Invalidate leaf.
+    tester.getOrCreate(leaf, /*markAsModified=*/true);
+    tester.set(leaf, new StringValue("crunchy"));
+    tester.getOrCreate(secondError, /*markAsModified=*/true).setHasError(true);
+    tester.getOrCreate(top, /*markAsModified=*/false).setHasError(true);
+    tester.invalidate();
+    EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/false, top);
+    assertNull("value should not have completed evaluation", result.get(top));
+    assertWithMessage(
+        "The error thrown by leaf should have been swallowed by the error thrown by top")
+        .that(result.getError().getRootCauses()).containsExactly(top);
+  }
+
+  @Test
+  public void dirtyErrorTransienceValue() throws Exception {
+    initializeTester();
+    SkyKey error = GraphTester.toSkyKey("error");
+    tester.getOrCreate(error).setHasError(true);
+    assertNotNull(tester.evalAndGetError(error));
+    tester.invalidateTransientErrors();
+    SkyKey secondError = GraphTester.toSkyKey("secondError");
+    tester.getOrCreate(secondError).setHasError(true);
+    // secondError declares a new dependence on ErrorTransienceValue, but not until it has already
+    // thrown an error.
+    assertNotNull(tester.evalAndGetError(secondError));
+  }
+
+  @Test
+  public void dirtyDependsOnErrorTurningGood() throws Exception {
+    initializeTester();
+    SkyKey error = GraphTester.toSkyKey("error");
+    tester.getOrCreate(error).setHasError(true);
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    tester.getOrCreate(topKey).addDependency(error).setComputedValue(COPY);
+    EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/false, topKey);
+    assertThat(result.getError(topKey).getRootCauses()).containsExactly(error);
+    tester.getOrCreate(error).setHasError(false);
+    StringValue val = new StringValue("reformed");
+    tester.set(error, val);
+    tester.invalidate();
+    result = tester.eval(/*keepGoing=*/false, topKey);
+    assertEquals(val, result.get(topKey));
+    assertFalse(result.hasError());
+  }
+
+  /** Regression test for crash bug. */
+  @Test
+  public void dirtyWithOwnErrorDependsOnTransientErrorTurningGood() throws Exception {
+    initializeTester();
+    final SkyKey error = GraphTester.toSkyKey("error");
+    tester.getOrCreate(error).setHasTransientError(true);
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    SkyFunction errorFunction = new SkyFunction() {
+      @Override
+      public SkyValue compute(SkyKey skyKey, Environment env) throws GenericFunctionException,
+          InterruptedException {
+        try {
+          return env.getValueOrThrow(error, SomeErrorException.class);
+        } catch (SomeErrorException e) {
+          throw new GenericFunctionException(e, Transience.PERSISTENT);
+        }
+      }
+
+      @Override
+      public String extractTag(SkyKey skyKey) {
+        throw new UnsupportedOperationException();
+      }
+    };
+    tester.getOrCreate(topKey).setBuilder(errorFunction);
+    EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/false, topKey);
+    tester.invalidateTransientErrors();
+    assertThat(result.getError(topKey).getRootCauses()).containsExactly(topKey);
+    tester.getOrCreate(error).setHasTransientError(false);
+    StringValue reformed = new StringValue("reformed");
+    tester.set(error, reformed);
+    tester.getOrCreate(topKey).setBuilder(null).addDependency(error).setComputedValue(COPY);
+    tester.invalidate();
+    tester.invalidateTransientErrors();
+    result = tester.eval(/*keepGoing=*/false, topKey);
+    assertEquals(reformed, result.get(topKey));
+    assertFalse(result.hasError());
+  }
+
+  /**
+   * Make sure that when an error is thrown, it is given for handling only to parents that have
+   * already registered a dependence on the value that threw the error.
+   *
+   * <pre>
+   *  topBubbleKey  topErrorFirstKey
+   *    |       \    /
+   *  midKey  errorKey
+   *    |
+   * slowKey
+   * </pre>
+   *
+   * On the second build, errorKey throws, and the threadpool aborts before midKey finishes.
+   * topBubbleKey therefore has not yet requested errorKey this build. If errorKey bubbles up to it,
+   * topBubbleKey must be able to handle that. (The evaluator can deal with this either by not
+   * allowing errorKey to bubble up to topBubbleKey, or by dealing with that case.)
+   */
+  @Test
+  public void errorOnlyBubblesToRequestingParents() throws Exception {
+    // We need control over the order of reverse deps, so use a deterministic graph.
+    setGraphForTesting(new DeterministicInMemoryGraph());
+    SkyKey errorKey = GraphTester.toSkyKey("error");
+    tester.set(errorKey, new StringValue("biding time"));
+    SkyKey slowKey = GraphTester.toSkyKey("slow");
+    tester.set(slowKey, new StringValue("slow"));
+    SkyKey midKey = GraphTester.toSkyKey("mid");
+    tester.getOrCreate(midKey).addDependency(slowKey).setComputedValue(COPY);
+    SkyKey topErrorFirstKey = GraphTester.toSkyKey("2nd top alphabetically");
+    tester.getOrCreate(topErrorFirstKey).addDependency(errorKey).setComputedValue(CONCATENATE);
+    SkyKey topBubbleKey = GraphTester.toSkyKey("1st top alphabetically");
+    tester.getOrCreate(topBubbleKey).addDependency(midKey).addDependency(errorKey)
+        .setComputedValue(CONCATENATE);
+    // First error-free evaluation, to put all values in graph.
+    EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/false,
+        topErrorFirstKey, topBubbleKey);
+    assertEquals("biding time", result.get(topErrorFirstKey).getValue());
+    assertEquals("slowbiding time", result.get(topBubbleKey).getValue());
+    // Set up timing of child values: slowKey waits to finish until errorKey has thrown an
+    // exception that has been caught by the threadpool.
+    tester.set(slowKey, null);
+    CountDownLatch errorFinish = new CountDownLatch(1);
+    tester.set(errorKey, null);
+    tester.getOrCreate(errorKey).setBuilder(
+        new ChainedFunction(/*notifyStart=*/null, /*waitToFinish=*/null,
+            /*notifyFinish=*/errorFinish, /*waitForException=*/false, /*value=*/null,
+            /*deps=*/ImmutableList.<SkyKey>of()));
+    tester.getOrCreate(slowKey).setBuilder(
+        new ChainedFunction(/*notifyStart=*/null, /*waitToFinish=*/errorFinish,
+            /*notifyFinish=*/null, /*waitForException=*/true, new StringValue("leaf2"),
+            /*deps=*/ImmutableList.<SkyKey>of()));
+    tester.invalidate();
+    // errorKey finishes, written to graph -> slowKey maybe starts+finishes & (Visitor aborts)
+    // -> some top key builds.
+    result = tester.eval(/*keepGoing=*/false, topErrorFirstKey, topBubbleKey);
+    assertTrue(result.hasError());
+    assertNotNull(result.getError(topErrorFirstKey));
+  }
+
+  @Test
+  public void dirtyWithRecoveryErrorDependsOnErrorTurningGood() throws Exception {
+    initializeTester();
+    final SkyKey error = GraphTester.toSkyKey("error");
+    tester.getOrCreate(error).setHasError(true);
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    SkyFunction recoveryErrorFunction = new SkyFunction() {
+      @Override
+      public SkyValue compute(SkyKey skyKey, Environment env) throws SkyFunctionException,
+          InterruptedException {
+        try {
+          env.getValueOrThrow(error, SomeErrorException.class);
+        } catch (SomeErrorException e) {
+          throw new GenericFunctionException(e, Transience.PERSISTENT);
+        }
+        return null;
+      }
+
+      @Override
+      public String extractTag(SkyKey skyKey) {
+        throw new UnsupportedOperationException();
+      }
+    };
+    tester.getOrCreate(topKey).setBuilder(recoveryErrorFunction);
+    EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/false, topKey);
+    assertThat(result.getError(topKey).getRootCauses()).containsExactly(topKey);
+    tester.getOrCreate(error).setHasError(false);
+    StringValue reformed = new StringValue("reformed");
+    tester.set(error, reformed);
+    tester.getOrCreate(topKey).setBuilder(null).addDependency(error).setComputedValue(COPY);
+    tester.invalidate();
+    result = tester.eval(/*keepGoing=*/false, topKey);
+    assertEquals(reformed, result.get(topKey));
+    assertFalse(result.hasError());
+  }
+
+
+  @Test
+  public void absentParent() throws Exception {
+    initializeTester();
+    SkyKey errorKey = GraphTester.toSkyKey("my_error_value");
+    tester.set(errorKey, new StringValue("biding time"));
+    SkyKey absentParentKey = GraphTester.toSkyKey("absentParent");
+    tester.getOrCreate(absentParentKey).addDependency(errorKey).setComputedValue(CONCATENATE);
+    assertEquals(new StringValue("biding time"),
+        tester.evalAndGet(/*keepGoing=*/false, absentParentKey));
+    tester.getOrCreate(errorKey, /*markAsModified=*/true).setHasError(true);
+    SkyKey newParent = GraphTester.toSkyKey("newParent");
+    tester.getOrCreate(newParent).addDependency(errorKey).setComputedValue(CONCATENATE);
+    tester.invalidate();
+    EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/false, newParent);
+    ErrorInfo error = result.getError(newParent);
+    assertThat(error.getRootCauses()).containsExactly(errorKey);
+  }
+
+  // Tests that we have a sane implementation of error transience.
+  @Test
+  public void errorTransienceBug() throws Exception {
+    tester.getOrCreate("key").setHasTransientError(true);
+    assertNotNull(tester.evalAndGetError("key").getException());
+    StringValue value = new StringValue("hi");
+    tester.getOrCreate("key").setHasTransientError(false).setConstantValue(value);
+    tester.invalidateTransientErrors();
+    assertEquals(value, tester.evalAndGet("key"));
+    // This works because the version of the ValueEntry for the ErrorTransience value is always
+    // increased on each InMemoryMemoizingEvaluator#evaluate call. But that's not the only way to
+    // implement error transience; another valid implementation would be to unconditionally mark
+    // values depending on the ErrorTransience value as being changed (rather than merely dirtied)
+    // during invalidation.
+  }
+
+  @Test
+  public void transientErrorTurningGoodHasNoError() throws Exception {
+    initializeTester();
+    SkyKey errorKey = GraphTester.toSkyKey("my_error_value");
+    tester.getOrCreate(errorKey).setHasTransientError(true);
+    ErrorInfo errorInfo = tester.evalAndGetError(errorKey);
+    assertNotNull(errorInfo);
+    assertThat(errorInfo.getRootCauses()).containsExactly(errorKey);
+    // Re-evaluates to same thing when errors are invalidated
+    tester.invalidateTransientErrors();
+    errorInfo = tester.evalAndGetError(errorKey);
+    assertNotNull(errorInfo);
+    StringValue value = new StringValue("reformed");
+    assertThat(errorInfo.getRootCauses()).containsExactly(errorKey);
+    tester.getOrCreate(errorKey, /*markAsModified=*/false).setHasTransientError(false)
+        .setConstantValue(value);
+    tester.invalidateTransientErrors();
+    StringValue stringValue = (StringValue) tester.evalAndGet(/*keepGoing=*/true, errorKey);
+    assertSame(stringValue, value);
+    // Value builder will now throw, but we should never get to it because it isn't dirty.
+    tester.getOrCreate(errorKey, /*markAsModified=*/false).setHasTransientError(true);
+    tester.invalidateTransientErrors();
+    stringValue = (StringValue) tester.evalAndGet(/*keepGoing=*/true, errorKey);
+    assertSame(stringValue, value);
+  }
+
+  @Test
+  public void deleteInvalidatedValue() throws Exception {
+    initializeTester();
+    SkyKey top = GraphTester.toSkyKey("top");
+    SkyKey toDelete = GraphTester.toSkyKey("toDelete");
+    // Must be a concatenation -- COPY doesn't actually copy.
+    tester.getOrCreate(top).addDependency(toDelete).setComputedValue(CONCATENATE);
+    tester.set(toDelete, new StringValue("toDelete"));
+    SkyValue value = tester.evalAndGet("top");
+    SkyKey forceInvalidation = GraphTester.toSkyKey("forceInvalidation");
+    tester.set(forceInvalidation, new StringValue("forceInvalidation"));
+    tester.getOrCreate(toDelete, /*markAsModified=*/true);
+    tester.invalidate();
+    tester.eval(/*keepGoing=*/false, forceInvalidation);
+    tester.delete("toDelete");
+    WeakReference<SkyValue> ref = new WeakReference<>(value);
+    value = null;
+    tester.eval(/*keepGoing=*/false, forceInvalidation);
+    tester.invalidate(); // So that invalidation receiver doesn't hang on to reference.
+    GcFinalization.awaitClear(ref);
+  }
+
+  /**
+   * General stress/fuzz test of the evaluator with failure. Construct a large graph, and then throw
+   * exceptions during building at various points.
+   */
+  @Test
+  public void twoRailLeftRightDependenciesWithFailure() throws Exception {
+    initializeTester();
+    SkyKey[] leftValues = new SkyKey[TEST_NODE_COUNT];
+    SkyKey[] rightValues = new SkyKey[TEST_NODE_COUNT];
+    for (int i = 0; i < TEST_NODE_COUNT; i++) {
+      leftValues[i] = GraphTester.toSkyKey("left-" + i);
+      rightValues[i] = GraphTester.toSkyKey("right-" + i);
+      if (i == 0) {
+        tester.getOrCreate(leftValues[i])
+              .addDependency("leaf")
+              .setComputedValue(COPY);
+        tester.getOrCreate(rightValues[i])
+              .addDependency("leaf")
+              .setComputedValue(COPY);
+      } else {
+        tester.getOrCreate(leftValues[i])
+              .addDependency(leftValues[i - 1])
+              .addDependency(rightValues[i - 1])
+              .setComputedValue(new PassThroughSelected(leftValues[i - 1]));
+        tester.getOrCreate(rightValues[i])
+              .addDependency(leftValues[i - 1])
+              .addDependency(rightValues[i - 1])
+              .setComputedValue(new PassThroughSelected(rightValues[i - 1]));
+      }
+    }
+    tester.set("leaf", new StringValue("leaf"));
+
+    String lastLeft = "left-" + (TEST_NODE_COUNT - 1);
+    String lastRight = "right-" + (TEST_NODE_COUNT - 1);
+
+    for (int i = 0; i < TESTED_NODES; i++) {
+      try {
+        tester.getOrCreate(leftValues[i], /*markAsModified=*/true).setHasError(true);
+        tester.invalidate();
+        EvaluationResult<StringValue> result = tester.eval(
+            /*keep_going=*/false, lastLeft, lastRight);
+        assertTrue(result.hasError());
+        tester.differencer.invalidate(ImmutableList.of(leftValues[i]));
+        tester.invalidate();
+        result = tester.eval(/*keep_going=*/false, lastLeft, lastRight);
+        assertTrue(result.hasError());
+        tester.getOrCreate(leftValues[i], /*markAsModified=*/true).setHasError(false);
+        tester.invalidate();
+        result = tester.eval(/*keep_going=*/false, lastLeft, lastRight);
+        assertEquals(new StringValue("leaf"), result.get(toSkyKey(lastLeft)));
+        assertEquals(new StringValue("leaf"), result.get(toSkyKey(lastRight)));
+      } catch (Exception e) {
+        System.err.println("twoRailLeftRightDependenciesWithFailure exception on run " + i);
+        throw e;
+      }
+    }
+  }
+
+  @Test
+  public void valueInjection() throws Exception {
+    SkyKey key = GraphTester.toSkyKey("new_value");
+    SkyValue val = new StringValue("val");
+
+    tester.differencer.inject(ImmutableMap.of(key, val));
+    assertEquals(val, tester.evalAndGet("new_value"));
+  }
+
+  @Test
+  public void valueInjectionOverExistingEntry() throws Exception {
+    SkyKey key = GraphTester.toSkyKey("value");
+    SkyValue val = new StringValue("val");
+
+    tester.getOrCreate(key).setConstantValue(new StringValue("old_val"));
+    tester.differencer.inject(ImmutableMap.of(key, val));
+    assertEquals(val, tester.evalAndGet("value"));
+  }
+
+  @Test
+  public void valueInjectionOverExistingDirtyEntry() throws Exception {
+    SkyKey key = GraphTester.toSkyKey("value");
+    SkyValue val = new StringValue("val");
+
+    tester.getOrCreate(key).setConstantValue(new StringValue("old_val"));
+    tester.differencer.inject(ImmutableMap.of(key, val));
+    tester.eval(/*keepGoing=*/false, new SkyKey[0]); // Create the value.
+
+    tester.differencer.invalidate(ImmutableList.of(key));
+    tester.eval(/*keepGoing=*/false, new SkyKey[0]); // Mark value as dirty.
+
+    tester.differencer.inject(ImmutableMap.of(key, val));
+    tester.eval(/*keepGoing=*/false, new SkyKey[0]); // Inject again.
+    assertEquals(val, tester.evalAndGet("value"));
+  }
+
+  @Test
+  public void valueInjectionOverExistingEntryMarkedForInvalidation() throws Exception {
+    SkyKey key = GraphTester.toSkyKey("value");
+    SkyValue val = new StringValue("val");
+
+    tester.getOrCreate(key).setConstantValue(new StringValue("old_val"));
+    tester.differencer.invalidate(ImmutableList.of(key));
+    tester.differencer.inject(ImmutableMap.of(key, val));
+    assertEquals(val, tester.evalAndGet("value"));
+  }
+
+  @Test
+  public void valueInjectionOverExistingEntryMarkedForDeletion() throws Exception {
+    SkyKey key = GraphTester.toSkyKey("value");
+    SkyValue val = new StringValue("val");
+
+    tester.getOrCreate(key).setConstantValue(new StringValue("old_val"));
+    tester.graph.delete(Predicates.<SkyKey>alwaysTrue());
+    tester.differencer.inject(ImmutableMap.of(key, val));
+    assertEquals(val, tester.evalAndGet("value"));
+  }
+
+  @Test
+  public void valueInjectionOverExistingEqualEntryMarkedForInvalidation() throws Exception {
+    SkyKey key = GraphTester.toSkyKey("value");
+    SkyValue val = new StringValue("val");
+
+    tester.differencer.inject(ImmutableMap.of(key, val));
+    assertEquals(val, tester.evalAndGet("value"));
+
+    tester.differencer.invalidate(ImmutableList.of(key));
+    tester.differencer.inject(ImmutableMap.of(key, val));
+    assertEquals(val, tester.evalAndGet("value"));
+  }
+
+  @Test
+  public void valueInjectionOverExistingEqualEntryMarkedForDeletion() throws Exception {
+    SkyKey key = GraphTester.toSkyKey("value");
+    SkyValue val = new StringValue("val");
+
+    tester.differencer.inject(ImmutableMap.of(key, val));
+    assertEquals(val, tester.evalAndGet("value"));
+
+    tester.graph.delete(Predicates.<SkyKey>alwaysTrue());
+    tester.differencer.inject(ImmutableMap.of(key, val));
+    assertEquals(val, tester.evalAndGet("value"));
+  }
+
+  @Test
+  public void valueInjectionOverValueWithDeps() throws Exception {
+    SkyKey key = GraphTester.toSkyKey("value");
+    SkyValue val = new StringValue("val");
+    StringValue prevVal = new StringValue("foo");
+
+    tester.getOrCreate("other").setConstantValue(prevVal);
+    tester.getOrCreate(key).addDependency("other").setComputedValue(COPY);
+    assertEquals(prevVal, tester.evalAndGet("value"));
+    tester.differencer.inject(ImmutableMap.of(key, val));
+    try {
+      tester.evalAndGet("value");
+      Assert.fail("injection over value with deps should have failed");
+    } catch (IllegalStateException e) {
+      assertEquals("existing entry for Type:value has deps: [Type:other]", e.getMessage());
+    }
+  }
+
+  @Test
+  public void valueInjectionOverEqualValueWithDeps() throws Exception {
+    SkyKey key = GraphTester.toSkyKey("value");
+    SkyValue val = new StringValue("val");
+
+    tester.getOrCreate("other").setConstantValue(val);
+    tester.getOrCreate(key).addDependency("other").setComputedValue(COPY);
+    assertEquals(val, tester.evalAndGet("value"));
+    tester.differencer.inject(ImmutableMap.of(key, val));
+    try {
+      tester.evalAndGet("value");
+      Assert.fail("injection over value with deps should have failed");
+    } catch (IllegalStateException e) {
+      assertEquals("existing entry for Type:value has deps: [Type:other]", e.getMessage());
+    }
+  }
+
+  @Test
+  public void valueInjectionOverValueWithErrors() throws Exception {
+    SkyKey key = GraphTester.toSkyKey("value");
+    SkyValue val = new StringValue("val");
+
+    tester.getOrCreate(key).setHasError(true);
+    tester.evalAndGetError(key);
+
+    tester.differencer.inject(ImmutableMap.of(key, val));
+    assertEquals(val, tester.evalAndGet(false, key));
+  }
+
+  @Test
+  public void valueInjectionInvalidatesReverseDeps() throws Exception {
+    SkyKey childKey = GraphTester.toSkyKey("child");
+    SkyKey parentKey = GraphTester.toSkyKey("parent");
+    StringValue oldVal = new StringValue("old_val");
+
+    tester.getOrCreate(childKey).setConstantValue(oldVal);
+    tester.getOrCreate(parentKey).addDependency("child").setComputedValue(COPY);
+
+    EvaluationResult<SkyValue> result = tester.eval(false, parentKey);
+    assertFalse(result.hasError());
+    assertEquals(oldVal, result.get(parentKey));
+
+    SkyValue val = new StringValue("val");
+    tester.differencer.inject(ImmutableMap.of(childKey, val));
+    assertEquals(val, tester.evalAndGet("child"));
+    // Injecting a new child should have invalidated the parent.
+    Assert.assertNull(tester.getExistingValue("parent"));
+
+    tester.eval(false, childKey);
+    assertEquals(val, tester.getExistingValue("child"));
+    Assert.assertNull(tester.getExistingValue("parent"));
+    assertEquals(val, tester.evalAndGet("parent"));
+  }
+
+  @Test
+  public void valueInjectionOverExistingEqualEntryDoesNotInvalidate() throws Exception {
+    SkyKey childKey = GraphTester.toSkyKey("child");
+    SkyKey parentKey = GraphTester.toSkyKey("parent");
+    SkyValue val = new StringValue("same_val");
+
+    tester.getOrCreate(parentKey).addDependency("child").setComputedValue(COPY);
+    tester.getOrCreate(childKey).setConstantValue(new StringValue("same_val"));
+    assertEquals(val, tester.evalAndGet("parent"));
+
+    tester.differencer.inject(ImmutableMap.of(childKey, val));
+    assertEquals(val, tester.getExistingValue("child"));
+    // Since we are injecting an equal value, the parent should not have been invalidated.
+    assertEquals(val, tester.getExistingValue("parent"));
+  }
+
+  @Test
+  public void valueInjectionInterrupt() throws Exception {
+    SkyKey key = GraphTester.toSkyKey("key");
+    SkyValue val = new StringValue("val");
+
+    tester.differencer.inject(ImmutableMap.of(key, val));
+    Thread.currentThread().interrupt();
+    try {
+      tester.evalAndGet("key");
+      fail();
+    } catch (InterruptedException expected) {
+      // Expected.
+    }
+    SkyValue newVal = tester.evalAndGet("key");
+    assertEquals(val, newVal);
+  }
+
+  @Test
+  public void persistentErrorsNotRerun() throws Exception {
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    SkyKey transientErrorKey = GraphTester.toSkyKey("transientError");
+    SkyKey persistentErrorKey1 = GraphTester.toSkyKey("persistentError1");
+    SkyKey persistentErrorKey2 = GraphTester.toSkyKey("persistentError2");
+
+    tester.getOrCreate(topKey)
+          .addErrorDependency(transientErrorKey, new StringValue("doesn't matter"))
+          .addErrorDependency(persistentErrorKey1, new StringValue("doesn't matter"))
+          .setHasError(true);
+    tester.getOrCreate(persistentErrorKey1).setHasError(true);
+    tester.getOrCreate(transientErrorKey)
+          .addErrorDependency(persistentErrorKey2, new StringValue("doesn't matter"))
+          .setHasTransientError(true);
+    tester.getOrCreate(persistentErrorKey2).setHasError(true);
+
+    tester.evalAndGetError(topKey);
+    assertThat(tester.getEnqueuedValues()).containsExactly(
+        topKey, transientErrorKey, persistentErrorKey1, persistentErrorKey2);
+
+    tester.invalidate();
+    tester.invalidateTransientErrors();
+    tester.evalAndGetError(topKey);
+    // TODO(bazel-team): We can do better here once we implement change pruning for errors.
+    assertThat(tester.getEnqueuedValues()).containsExactly(topKey, transientErrorKey);
+  }
+
+  @Test
+  public void cachedChildErrorDepWithSiblingDepOnNoKeepGoingEval() throws Exception {
+    SkyKey parent1Key = GraphTester.toSkyKey("parent1");
+    SkyKey parent2Key = GraphTester.toSkyKey("parent2");
+    final SkyKey errorKey = GraphTester.toSkyKey("error");
+    final SkyKey otherKey = GraphTester.toSkyKey("other");
+    SkyFunction parentBuilder = new SkyFunction() {
+      @Override
+      public SkyValue compute(SkyKey skyKey, Environment env) {
+        env.getValue(errorKey);
+        env.getValue(otherKey);
+        if (env.valuesMissing()) {
+          return null;
+        }
+        return new StringValue("parent");
+      }
+
+      @Override
+      public String extractTag(SkyKey skyKey) {
+        return null;
+      }
+    };
+    tester.getOrCreate(parent1Key).setBuilder(parentBuilder);
+    tester.getOrCreate(parent2Key).setBuilder(parentBuilder);
+    tester.getOrCreate(errorKey).setConstantValue(new StringValue("no error yet"));
+    tester.getOrCreate(otherKey).setConstantValue(new StringValue("other"));
+    tester.eval(/*keepGoing=*/true, parent1Key);
+    tester.eval(/*keepGoing=*/false, parent2Key);
+    tester.getOrCreate(errorKey, /*markAsModified=*/true).setHasError(true);
+    tester.invalidate();
+    tester.eval(/*keepGoing=*/true, parent1Key);
+    tester.eval(/*keepGoing=*/false, parent2Key);
+  }
+
+  private void setGraphForTesting(NotifyingInMemoryGraph notifyingInMemoryGraph) {
+    InMemoryMemoizingEvaluator memoizingEvaluator = (InMemoryMemoizingEvaluator) tester.graph;
+    memoizingEvaluator.setGraphForTesting(notifyingInMemoryGraph);
+  }
+
+  private static final class PassThroughSelected implements ValueComputer {
+    private final SkyKey key;
+
+    public PassThroughSelected(SkyKey key) {
+      this.key = key;
+    }
+
+    @Override
+    public SkyValue compute(Map<SkyKey, SkyValue> deps, SkyFunction.Environment env) {
+      return Preconditions.checkNotNull(deps.get(key));
+    }
+  }
+
+  /**
+   * A graph tester that is specific to the memoizing evaluator, with some convenience methods.
+   */
+  private class MemoizingEvaluatorTester extends GraphTester {
+    private RecordingDifferencer differencer;
+    private MemoizingEvaluator graph;
+    private SequentialBuildDriver driver;
+    private TrackingInvalidationReceiver invalidationReceiver = new TrackingInvalidationReceiver();
+
+    public void initialize() {
+      this.differencer = new RecordingDifferencer();
+      this.graph = new InMemoryMemoizingEvaluator(
+          ImmutableMap.of(NODE_TYPE, createDelegatingFunction()), differencer,
+          invalidationReceiver, emittedEventState, true);
+      this.driver = new SequentialBuildDriver(graph);
+    }
+
+    public void setInvalidationReceiver(TrackingInvalidationReceiver customInvalidationReceiver) {
+      Preconditions.checkState(graph == null, "graph already initialized");
+      invalidationReceiver = customInvalidationReceiver;
+    }
+
+    public void invalidate() {
+      differencer.invalidate(getModifiedValues());
+      getModifiedValues().clear();
+      invalidationReceiver.clear();
+    }
+
+    public void invalidateTransientErrors() {
+      differencer.invalidateTransientErrors();
+    }
+
+    public void delete(String key) {
+      graph.delete(Predicates.equalTo(GraphTester.skyKey(key)));
+    }
+
+    public void resetPlayedEvents() {
+      emittedEventState.clear();
+    }
+
+    public Set<SkyValue> getDirtyValues() {
+      return invalidationReceiver.dirty;
+    }
+
+    public Set<SkyValue> getDeletedValues() {
+      return invalidationReceiver.deleted;
+    }
+
+    public Set<SkyKey> getEnqueuedValues() {
+      return invalidationReceiver.enqueued;
+    }
+
+    public <T extends SkyValue> EvaluationResult<T> eval(
+        boolean keepGoing, int numThreads, SkyKey... keys) throws InterruptedException {
+      assertThat(getModifiedValues()).isEmpty();
+      return driver.evaluate(ImmutableList.copyOf(keys), keepGoing, numThreads, reporter);
+    }
+
+    public <T extends SkyValue> EvaluationResult<T> eval(boolean keepGoing, SkyKey... keys)
+        throws InterruptedException {
+      return eval(keepGoing, 100, keys);
+    }
+
+    public <T extends SkyValue> EvaluationResult<T> eval(boolean keepGoing, String... keys)
+        throws InterruptedException {
+      return eval(keepGoing, toSkyKeys(keys));
+    }
+
+    public SkyValue evalAndGet(boolean keepGoing, String key)
+        throws InterruptedException {
+      return evalAndGet(keepGoing, new SkyKey(NODE_TYPE, key));
+    }
+
+    public SkyValue evalAndGet(String key) throws InterruptedException {
+      return evalAndGet(/*keepGoing=*/false, key);
+    }
+
+    public SkyValue evalAndGet(boolean keepGoing, SkyKey key)
+        throws InterruptedException {
+      EvaluationResult<StringValue> evaluationResult = eval(keepGoing, key);
+      SkyValue result = evaluationResult.get(key);
+      assertNotNull(evaluationResult.toString(), result);
+      return result;
+    }
+
+    public ErrorInfo evalAndGetError(SkyKey key) throws InterruptedException {
+      EvaluationResult<StringValue> evaluationResult = eval(/*keepGoing=*/true, key);
+      ErrorInfo result = evaluationResult.getError(key);
+      assertNotNull(evaluationResult.toString(), result);
+      return result;
+    }
+
+    public ErrorInfo evalAndGetError(String key) throws InterruptedException {
+      return evalAndGetError(new SkyKey(NODE_TYPE, key));
+    }
+
+    @Nullable
+    public SkyValue getExistingValue(String key) {
+      return graph.getExistingValueForTesting(new SkyKey(NODE_TYPE, key));
+    }
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/skyframe/NodeEntryTest.java b/src/test/java/com/google/devtools/build/skyframe/NodeEntryTest.java
new file mode 100644
index 0000000..378b097
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/skyframe/NodeEntryTest.java
@@ -0,0 +1,668 @@
+// Copyright 2014 Google Inc. 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.skyframe;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+import com.google.devtools.build.lib.collect.nestedset.NestedSet;
+import com.google.devtools.build.lib.collect.nestedset.NestedSetBuilder;
+import com.google.devtools.build.lib.collect.nestedset.Order;
+import com.google.devtools.build.lib.util.GroupedList.GroupedListHelper;
+import com.google.devtools.build.skyframe.NodeEntry.DependencyState;
+import com.google.devtools.build.skyframe.SkyFunctionException.ReifiedSkyFunctionException;
+import com.google.devtools.build.skyframe.SkyFunctionException.Transience;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+import javax.annotation.Nullable;
+
+/**
+ * Tests for {@link NodeEntry}.
+ */
+@RunWith(JUnit4.class)
+public class NodeEntryTest {
+
+  private static final SkyFunctionName NODE_TYPE = new SkyFunctionName("Type", false);
+  private static final NestedSet<TaggedEvents> NO_EVENTS =
+      NestedSetBuilder.<TaggedEvents>emptySet(Order.STABLE_ORDER);
+
+  private static SkyKey key(String name) {
+    return new SkyKey(NODE_TYPE, name);
+  }
+
+  @Test
+  public void createEntry() {
+    NodeEntry entry = new NodeEntry();
+    entry.addReverseDepAndCheckIfDone(null); // Start evaluation.
+    assertFalse(entry.isDone());
+    assertTrue(entry.isReady());
+    assertFalse(entry.isDirty());
+    assertFalse(entry.isChanged());
+    assertThat(entry.getTemporaryDirectDeps()).isEmpty();
+  }
+
+  @Test
+  public void signalEntry() {
+    NodeEntry entry = new NodeEntry();
+    entry.addReverseDepAndCheckIfDone(null); // Start evaluation.
+    SkyKey dep1 = key("dep1");
+    addTemporaryDirectDep(entry, dep1);
+    assertFalse(entry.isReady());
+    assertTrue(entry.signalDep());
+    assertTrue(entry.isReady());
+    assertThat(entry.getTemporaryDirectDeps()).containsExactly(dep1);
+    SkyKey dep2 = key("dep2");
+    SkyKey dep3 = key("dep3");
+    addTemporaryDirectDep(entry, dep2);
+    addTemporaryDirectDep(entry, dep3);
+    assertFalse(entry.isReady());
+    assertFalse(entry.signalDep());
+    assertFalse(entry.isReady());
+    assertTrue(entry.signalDep());
+    assertTrue(entry.isReady());
+    assertThat(setValue(entry, new SkyValue() {},
+        /*errorInfo=*/null, /*graphVersion=*/0L)).isEmpty();
+    assertTrue(entry.isDone());
+    assertEquals(new IntVersion(0L), entry.getVersion());
+    assertThat(entry.getDirectDeps()).containsExactly(dep1, dep2, dep3);
+  }
+
+  @Test
+  public void reverseDeps() {
+    NodeEntry entry = new NodeEntry();
+    SkyKey mother = key("mother");
+    SkyKey father = key("father");
+    assertEquals(DependencyState.NEEDS_SCHEDULING, entry.addReverseDepAndCheckIfDone(mother));
+    assertEquals(DependencyState.ADDED_DEP, entry.addReverseDepAndCheckIfDone(null));
+    assertEquals(DependencyState.ADDED_DEP, entry.addReverseDepAndCheckIfDone(father));
+    assertThat(setValue(entry, new SkyValue() {},
+        /*errorInfo=*/null, /*graphVersion=*/0L)).containsExactly(mother, father);
+    assertThat(entry.getReverseDeps()).containsExactly(mother, father);
+    assertTrue(entry.isDone());
+    entry.removeReverseDep(mother);
+    assertFalse(Iterables.contains(entry.getReverseDeps(), mother));
+  }
+
+  @Test
+  public void errorValue() {
+    NodeEntry entry = new NodeEntry();
+    entry.addReverseDepAndCheckIfDone(null); // Start evaluation.
+    ReifiedSkyFunctionException exception = new ReifiedSkyFunctionException(
+        new GenericFunctionException(new SomeErrorException("oops"), Transience.PERSISTENT),
+        key("cause"));
+    ErrorInfo errorInfo = new ErrorInfo(exception);
+    assertThat(setValue(entry, /*value=*/null, errorInfo, /*graphVersion=*/0L)).isEmpty();
+    assertTrue(entry.isDone());
+    assertNull(entry.getValue());
+    assertEquals(errorInfo, entry.getErrorInfo());
+  }
+
+  @Test
+  public void errorAndValue() {
+    NodeEntry entry = new NodeEntry();
+    entry.addReverseDepAndCheckIfDone(null); // Start evaluation.
+    ReifiedSkyFunctionException exception = new ReifiedSkyFunctionException(
+        new GenericFunctionException(new SomeErrorException("oops"), Transience.PERSISTENT),
+        key("cause"));
+    ErrorInfo errorInfo = new ErrorInfo(exception);
+    setValue(entry, new SkyValue() {}, errorInfo, /*graphVersion=*/0L);
+    assertTrue(entry.isDone());
+    assertEquals(errorInfo, entry.getErrorInfo());
+  }
+
+  @Test
+  public void crashOnNullErrorAndValue() {
+    NodeEntry entry = new NodeEntry();
+    entry.addReverseDepAndCheckIfDone(null); // Start evaluation.
+    try {
+      setValue(entry, /*value=*/null, /*errorInfo=*/null, /*graphVersion=*/0L);
+      fail();
+    } catch (IllegalStateException e) {
+      // Expected.
+    }
+  }
+
+  @Test
+  public void crashOnTooManySignals() {
+    NodeEntry entry = new NodeEntry();
+    entry.addReverseDepAndCheckIfDone(null); // Start evaluation.
+    try {
+      entry.signalDep();
+      fail();
+    } catch (IllegalStateException e) {
+      // Expected.
+    }
+  }
+
+  @Test
+  public void crashOnDifferentValue() {
+    NodeEntry entry = new NodeEntry();
+    entry.addReverseDepAndCheckIfDone(null); // Start evaluation.
+    setValue(entry, new SkyValue() {}, /*errorInfo=*/null, /*graphVersion=*/0L);
+    try {
+      // Value() {} and Value() {} are not .equals().
+      setValue(entry, new SkyValue() {}, /*errorInfo=*/null, /*graphVersion=*/1L);
+      fail();
+    } catch (IllegalStateException e) {
+      // Expected.
+    }
+  }
+
+  @Test
+  public void dirtyLifecycle() {
+    NodeEntry entry = new NodeEntry();
+    entry.addReverseDepAndCheckIfDone(null); // Start evaluation.
+    SkyKey dep = key("dep");
+    addTemporaryDirectDep(entry, dep);
+    entry.signalDep();
+    setValue(entry, new SkyValue() {}, /*errorInfo=*/null, /*graphVersion=*/0L);
+    assertFalse(entry.isDirty());
+    assertTrue(entry.isDone());
+    entry.markDirty(/*isChanged=*/false);
+    assertTrue(entry.isDirty());
+    assertFalse(entry.isChanged());
+    assertFalse(entry.isDone());
+    assertTrue(entry.isReady());
+    assertThat(entry.getTemporaryDirectDeps()).isEmpty();
+    SkyKey parent = key("parent");
+    entry.addReverseDepAndCheckIfDone(parent);
+    assertEquals(BuildingState.DirtyState.CHECK_DEPENDENCIES, entry.getDirtyState());
+    assertThat(entry.getNextDirtyDirectDeps()).containsExactly(dep).inOrder();
+    addTemporaryDirectDep(entry, dep);
+    entry.signalDep();
+    assertThat(entry.getTemporaryDirectDeps()).containsExactly(dep);
+    assertTrue(entry.isReady());
+    assertThat(setValue(entry, new SkyValue() {}, /*errorInfo=*/null,
+        /*graphVersion=*/1L)).containsExactly(parent);
+  }
+
+  @Test
+  public void changedLifecycle() {
+    NodeEntry entry = new NodeEntry();
+    entry.addReverseDepAndCheckIfDone(null); // Start evaluation.
+    SkyKey dep = key("dep");
+    addTemporaryDirectDep(entry, dep);
+    entry.signalDep();
+    setValue(entry, new SkyValue() {}, /*errorInfo=*/null, /*graphVersion=*/0L);
+    assertFalse(entry.isDirty());
+    assertTrue(entry.isDone());
+    entry.markDirty(/*isChanged=*/true);
+    assertTrue(entry.isDirty());
+    assertTrue(entry.isChanged());
+    assertFalse(entry.isDone());
+    assertTrue(entry.isReady());
+    SkyKey parent = key("parent");
+    entry.addReverseDepAndCheckIfDone(parent);
+    assertEquals(BuildingState.DirtyState.REBUILDING, entry.getDirtyState());
+    assertTrue(entry.isReady());
+    assertThat(entry.getTemporaryDirectDeps()).isEmpty();
+    assertThat(setValue(entry, new SkyValue() {}, /*errorInfo=*/null,
+        /*graphVersion=*/1L)).containsExactly(parent);
+    assertEquals(new IntVersion(1L), entry.getVersion());
+  }
+
+  @Test
+  public void markDirtyThenChanged() {
+    NodeEntry entry = new NodeEntry();
+    entry.addReverseDepAndCheckIfDone(null); // Start evaluation.
+    addTemporaryDirectDep(entry, key("dep"));
+    entry.signalDep();
+    setValue(entry, new SkyValue() {}, /*errorInfo=*/null, /*graphVersion=*/0L);
+    assertFalse(entry.isDirty());
+    assertTrue(entry.isDone());
+    entry.markDirty(/*isChanged=*/false);
+    assertTrue(entry.isDirty());
+    assertFalse(entry.isChanged());
+    assertFalse(entry.isDone());
+    assertTrue(entry.isReady());
+    entry.markDirty(/*isChanged=*/true);
+    assertTrue(entry.isDirty());
+    assertTrue(entry.isChanged());
+    assertFalse(entry.isDone());
+    assertTrue(entry.isReady());
+  }
+
+
+  @Test
+  public void markChangedThenDirty() {
+    NodeEntry entry = new NodeEntry();
+    entry.addReverseDepAndCheckIfDone(null); // Start evaluation.
+    addTemporaryDirectDep(entry, key("dep"));
+    entry.signalDep();
+    setValue(entry, new SkyValue() {}, /*errorInfo=*/null, /*graphVersion=*/0L);
+    assertFalse(entry.isDirty());
+    assertTrue(entry.isDone());
+    entry.markDirty(/*isChanged=*/true);
+    assertTrue(entry.isDirty());
+    assertTrue(entry.isChanged());
+    assertFalse(entry.isDone());
+    assertTrue(entry.isReady());
+    entry.markDirty(/*isChanged=*/false);
+    assertTrue(entry.isDirty());
+    assertTrue(entry.isChanged());
+    assertFalse(entry.isDone());
+    assertTrue(entry.isReady());
+  }
+
+  @Test
+  public void crashOnTwiceMarkedChanged() {
+    NodeEntry entry = new NodeEntry();
+    entry.addReverseDepAndCheckIfDone(null); // Start evaluation.
+    setValue(entry, new SkyValue() {}, /*errorInfo=*/null, /*graphVersion=*/0L);
+    assertFalse(entry.isDirty());
+    assertTrue(entry.isDone());
+    entry.markDirty(/*isChanged=*/true);
+    try {
+      entry.markDirty(/*isChanged=*/true);
+      fail("Cannot mark entry changed twice");
+    } catch (IllegalStateException e) {
+      // Expected.
+    }
+  }
+
+  @Test
+  public void crashOnTwiceMarkedDirty() {
+    NodeEntry entry = new NodeEntry();
+    entry.addReverseDepAndCheckIfDone(null); // Start evaluation.
+    addTemporaryDirectDep(entry, key("dep"));
+    entry.signalDep();
+    setValue(entry, new SkyValue() {}, /*errorInfo=*/null, /*graphVersion=*/0L);
+    entry.markDirty(/*isChanged=*/false);
+    try {
+      entry.markDirty(/*isChanged=*/false);
+      fail("Cannot mark entry dirty twice");
+    } catch (IllegalStateException e) {
+      // Expected.
+    }
+  }
+
+  @Test
+  public void crashOnAddReverseDepTwice() {
+    NodeEntry entry = new NodeEntry();
+    SkyKey parent = key("parent");
+    assertEquals(DependencyState.NEEDS_SCHEDULING, entry.addReverseDepAndCheckIfDone(parent));
+    try {
+      entry.addReverseDepAndCheckIfDone(parent);
+      entry.getReverseDeps();
+      fail("Cannot add same dep twice");
+    } catch (IllegalStateException e) {
+      // Expected.
+    }
+  }
+
+  @Test
+  public void crashOnAddReverseDepTwiceAfterDone() {
+    NodeEntry entry = new NodeEntry();
+    entry.addReverseDepAndCheckIfDone(null); // Start evaluation.
+    setValue(entry, new SkyValue() {}, /*errorInfo=*/null, /*graphVersion=*/0L);
+    SkyKey parent = key("parent");
+    assertEquals(DependencyState.DONE, entry.addReverseDepAndCheckIfDone(parent));
+    try {
+      entry.addReverseDepAndCheckIfDone(parent);
+      // We only check for duplicates when we request all the reverse deps.
+      entry.getReverseDeps();
+      fail("Cannot add same dep twice");
+    } catch (IllegalStateException e) {
+      // Expected.
+    }
+  }
+
+  @Test
+  public void crashOnAddReverseDepBeforeAfterDone() {
+    NodeEntry entry = new NodeEntry();
+    SkyKey parent = key("parent");
+    assertEquals(DependencyState.NEEDS_SCHEDULING, entry.addReverseDepAndCheckIfDone(parent));
+    setValue(entry, new SkyValue() {}, /*errorInfo=*/null, /*graphVersion=*/0L);
+    try {
+      entry.addReverseDepAndCheckIfDone(parent);
+      // We only check for duplicates when we request all the reverse deps.
+      entry.getReverseDeps();
+      fail("Cannot add same dep twice");
+    } catch (IllegalStateException e) {
+      // Expected.
+    }
+  }
+
+  @Test
+  public void crashOnAddDirtyReverseDep() {
+    NodeEntry entry = new NodeEntry();
+    SkyKey parent = key("parent");
+    assertEquals(DependencyState.NEEDS_SCHEDULING, entry.addReverseDepAndCheckIfDone(parent));
+    try {
+      entry.addReverseDepAndCheckIfDone(parent);
+      // We only check for duplicates when we request all the reverse deps.
+      entry.getReverseDeps();
+      fail("Cannot add same dep twice in one build, even if dirty");
+    } catch (IllegalStateException e) {
+      // Expected.
+    }
+  }
+
+  @Test
+  public void pruneBeforeBuild() {
+    NodeEntry entry = new NodeEntry();
+    SkyKey dep = key("dep");
+    entry.addReverseDepAndCheckIfDone(null); // Start evaluation.
+    addTemporaryDirectDep(entry, dep);
+    entry.signalDep();
+    setValue(entry, new SkyValue() {}, /*errorInfo=*/null, /*graphVersion=*/0L);
+    assertFalse(entry.isDirty());
+    assertTrue(entry.isDone());
+    entry.markDirty(/*isChanged=*/false);
+    assertTrue(entry.isDirty());
+    assertFalse(entry.isChanged());
+    assertFalse(entry.isDone());
+    assertTrue(entry.isReady());
+    SkyKey parent = key("parent");
+    entry.addReverseDepAndCheckIfDone(parent);
+    assertEquals(BuildingState.DirtyState.CHECK_DEPENDENCIES, entry.getDirtyState());
+    assertThat(entry.getNextDirtyDirectDeps()).containsExactly(dep).inOrder();
+    addTemporaryDirectDep(entry, dep);
+    entry.signalDep(new IntVersion(0L));
+    assertEquals(BuildingState.DirtyState.VERIFIED_CLEAN, entry.getDirtyState());
+    assertThat(entry.markClean()).containsExactly(parent);
+    assertTrue(entry.isDone());
+    assertEquals(new IntVersion(0L), entry.getVersion());
+  }
+
+  private static class IntegerValue implements SkyValue {
+    private final int value;
+
+    IntegerValue(int value) {
+      this.value = value;
+    }
+
+    @Override
+    public boolean equals(Object that) {
+      return (that instanceof IntegerValue) && (((IntegerValue) that).value == value);
+    }
+
+    @Override
+    public int hashCode() {
+      return value;
+    }
+  }
+
+  @Test
+  public void pruneAfterBuild() {
+    NodeEntry entry = new NodeEntry();
+    entry.addReverseDepAndCheckIfDone(null); // Start evaluation.
+    SkyKey dep = key("dep");
+    addTemporaryDirectDep(entry, dep);
+    entry.signalDep();
+    setValue(entry, new IntegerValue(5), /*errorInfo=*/null, /*graphVersion=*/0L);
+    entry.markDirty(/*isChanged=*/false);
+    entry.addReverseDepAndCheckIfDone(null); // Start evaluation.
+    assertEquals(BuildingState.DirtyState.CHECK_DEPENDENCIES, entry.getDirtyState());
+    entry.addReverseDepAndCheckIfDone(null); // Start evaluation.
+    assertThat(entry.getNextDirtyDirectDeps()).containsExactly(dep).inOrder();
+    addTemporaryDirectDep(entry, dep);
+    entry.signalDep(new IntVersion(1L));
+    assertEquals(BuildingState.DirtyState.REBUILDING, entry.getDirtyState());
+    assertThat(entry.getTemporaryDirectDeps()).containsExactly(dep);
+    setValue(entry, new IntegerValue(5), /*errorInfo=*/null, /*graphVersion=*/1L);
+    assertTrue(entry.isDone());
+    assertEquals(new IntVersion(0L), entry.getVersion());
+  }
+
+
+  @Test
+  public void noPruneWhenDetailsChange() {
+    NodeEntry entry = new NodeEntry();
+    entry.addReverseDepAndCheckIfDone(null); // Start evaluation.
+    SkyKey dep = key("dep");
+    addTemporaryDirectDep(entry, dep);
+    entry.signalDep();
+    setValue(entry, new IntegerValue(5), /*errorInfo=*/null, /*graphVersion=*/0L);
+    assertFalse(entry.isDirty());
+    assertTrue(entry.isDone());
+    entry.markDirty(/*isChanged=*/false);
+    assertTrue(entry.isDirty());
+    assertFalse(entry.isChanged());
+    assertFalse(entry.isDone());
+    assertTrue(entry.isReady());
+    SkyKey parent = key("parent");
+    entry.addReverseDepAndCheckIfDone(parent);
+    assertEquals(BuildingState.DirtyState.CHECK_DEPENDENCIES, entry.getDirtyState());
+    assertThat(entry.getNextDirtyDirectDeps()).containsExactly(dep).inOrder();
+    addTemporaryDirectDep(entry, dep);
+    entry.signalDep(new IntVersion(1L));
+    assertEquals(BuildingState.DirtyState.REBUILDING, entry.getDirtyState());
+    assertThat(entry.getTemporaryDirectDeps()).containsExactly(dep);
+    ReifiedSkyFunctionException exception = new ReifiedSkyFunctionException(
+        new GenericFunctionException(new SomeErrorException("oops"), Transience.PERSISTENT),
+        key("cause"));
+    setValue(entry, new IntegerValue(5), new ErrorInfo(exception),
+        /*graphVersion=*/1L);
+    assertTrue(entry.isDone());
+    assertEquals("Version increments when setValue changes", new IntVersion(1), entry.getVersion());
+  }
+
+  @Test
+  public void pruneErrorValue() {
+    NodeEntry entry = new NodeEntry();
+    entry.addReverseDepAndCheckIfDone(null); // Start evaluation.
+    SkyKey dep = key("dep");
+    addTemporaryDirectDep(entry, dep);
+    entry.signalDep();
+    ReifiedSkyFunctionException exception = new ReifiedSkyFunctionException(
+        new GenericFunctionException(new SomeErrorException("oops"), Transience.PERSISTENT),
+        key("cause"));
+    ErrorInfo errorInfo = new ErrorInfo(exception);
+    setValue(entry, /*value=*/null, errorInfo, /*graphVersion=*/0L);
+    entry.markDirty(/*isChanged=*/false);
+    entry.addReverseDepAndCheckIfDone(null); // Restart evaluation.
+    assertEquals(BuildingState.DirtyState.CHECK_DEPENDENCIES, entry.getDirtyState());
+    assertThat(entry.getNextDirtyDirectDeps()).containsExactly(dep).inOrder();
+    addTemporaryDirectDep(entry, dep);
+    entry.signalDep(new IntVersion(1L));
+    assertEquals(BuildingState.DirtyState.REBUILDING, entry.getDirtyState());
+    assertThat(entry.getTemporaryDirectDeps()).containsExactly(dep);
+    setValue(entry, /*value=*/null, errorInfo, /*graphVersion=*/1L);
+    assertTrue(entry.isDone());
+    assertEquals(new IntVersion(0L), entry.getVersion());
+  }
+
+  @Test
+  public void getDependencyGroup() {
+    NodeEntry entry = new NodeEntry();
+    entry.addReverseDepAndCheckIfDone(null); // Start evaluation.
+    SkyKey dep = key("dep");
+    SkyKey dep2 = key("dep2");
+    SkyKey dep3 = key("dep3");
+    addTemporaryDirectDeps(entry, dep, dep2);
+    addTemporaryDirectDep(entry, dep3);
+    entry.signalDep();
+    entry.signalDep();
+    entry.signalDep();
+    setValue(entry, /*value=*/new IntegerValue(5), null, 0L);
+    entry.markDirty(/*isChanged=*/false);
+    entry.addReverseDepAndCheckIfDone(null); // Restart evaluation.
+    assertEquals(BuildingState.DirtyState.CHECK_DEPENDENCIES, entry.getDirtyState());
+    assertThat(entry.getNextDirtyDirectDeps()).containsExactly(dep, dep2).inOrder();
+    addTemporaryDirectDeps(entry, dep, dep2);
+    entry.signalDep(new IntVersion(0L));
+    entry.signalDep(new IntVersion(0L));
+    assertEquals(BuildingState.DirtyState.CHECK_DEPENDENCIES, entry.getDirtyState());
+    assertThat(entry.getNextDirtyDirectDeps()).containsExactly(dep3).inOrder();
+  }
+
+  @Test
+  public void maintainDependencyGroupAfterRemoval() {
+    NodeEntry entry = new NodeEntry();
+    entry.addReverseDepAndCheckIfDone(null); // Start evaluation.
+    SkyKey dep = key("dep");
+    SkyKey dep2 = key("dep2");
+    SkyKey dep3 = key("dep3");
+    SkyKey dep4 = key("dep4");
+    SkyKey dep5 = key("dep5");
+    addTemporaryDirectDeps(entry, dep, dep2, dep3);
+    addTemporaryDirectDep(entry, dep4);
+    addTemporaryDirectDep(entry, dep5);
+    entry.signalDep();
+    entry.signalDep();
+    // Oops! Evaluation terminated with an error, but we're going to set this entry's value anyway.
+    entry.removeUnfinishedDeps(ImmutableSet.of(dep2, dep3, dep5));
+    ReifiedSkyFunctionException exception = new ReifiedSkyFunctionException(
+        new GenericFunctionException(new SomeErrorException("oops"), Transience.PERSISTENT),
+        key("key"));
+    setValue(entry, null, new ErrorInfo(exception), 0L);
+    entry.markDirty(/*isChanged=*/false);
+    entry.addReverseDepAndCheckIfDone(null); // Restart evaluation.
+    assertEquals(BuildingState.DirtyState.CHECK_DEPENDENCIES, entry.getDirtyState());
+    assertThat(entry.getNextDirtyDirectDeps()).containsExactly(dep).inOrder();
+    addTemporaryDirectDep(entry, dep);
+    entry.signalDep(new IntVersion(0L));
+    assertEquals(BuildingState.DirtyState.CHECK_DEPENDENCIES, entry.getDirtyState());
+    assertThat(entry.getNextDirtyDirectDeps()).containsExactly(dep4).inOrder();
+  }
+
+  @Test
+  public void noPruneWhenDepsChange() {
+    NodeEntry entry = new NodeEntry();
+    entry.addReverseDepAndCheckIfDone(null); // Start evaluation.
+    SkyKey dep = key("dep");
+    addTemporaryDirectDep(entry, dep);
+    entry.signalDep();
+    setValue(entry, new IntegerValue(5), /*errorInfo=*/null, /*graphVersion=*/0L);
+    entry.markDirty(/*isChanged=*/false);
+    entry.addReverseDepAndCheckIfDone(null); // Start evaluation.
+    assertEquals(BuildingState.DirtyState.CHECK_DEPENDENCIES, entry.getDirtyState());
+    assertThat(entry.getNextDirtyDirectDeps()).containsExactly(dep).inOrder();
+    addTemporaryDirectDep(entry, dep);
+    assertTrue(entry.signalDep(new IntVersion(1L)));
+    assertEquals(BuildingState.DirtyState.REBUILDING, entry.getDirtyState());
+    assertThat(entry.getTemporaryDirectDeps()).containsExactly(dep);
+    addTemporaryDirectDep(entry, key("dep2"));
+    assertTrue(entry.signalDep(new IntVersion(1L)));
+    setValue(entry, new IntegerValue(5), /*errorInfo=*/null, /*graphVersion=*/1L);
+    assertTrue(entry.isDone());
+    assertEquals("Version increments when deps change", new IntVersion(1L), entry.getVersion());
+  }
+
+  @Test
+  public void checkDepsOneByOne() {
+    NodeEntry entry = new NodeEntry();
+    entry.addReverseDepAndCheckIfDone(null); // Start evaluation.
+    List<SkyKey> deps = new ArrayList<>();
+    for (int ii = 0; ii < 10; ii++) {
+      SkyKey dep = key(Integer.toString(ii));
+      deps.add(dep);
+      addTemporaryDirectDep(entry, dep);
+      entry.signalDep();
+    }
+    setValue(entry, new IntegerValue(5), /*errorInfo=*/null, /*graphVersion=*/0L);
+    entry.markDirty(/*isChanged=*/false);
+    entry.addReverseDepAndCheckIfDone(null); // Start new evaluation.
+    assertEquals(BuildingState.DirtyState.CHECK_DEPENDENCIES, entry.getDirtyState());
+    for (int ii = 0; ii < 10; ii++) {
+      assertThat(entry.getNextDirtyDirectDeps()).containsExactly(deps.get(ii)).inOrder();
+      addTemporaryDirectDep(entry, deps.get(ii));
+      assertTrue(entry.signalDep(new IntVersion(0L)));
+      if (ii < 9) {
+        assertEquals(BuildingState.DirtyState.CHECK_DEPENDENCIES, entry.getDirtyState());
+      } else {
+        assertEquals(BuildingState.DirtyState.VERIFIED_CLEAN, entry.getDirtyState());
+      }
+    }
+  }
+
+  @Test
+  public void signalOnlyNewParents() {
+    NodeEntry entry = new NodeEntry();
+    entry.addReverseDepAndCheckIfDone(key("parent"));
+    setValue(entry, new SkyValue() {}, /*errorInfo=*/null, /*graphVersion=*/0L);
+    entry.markDirty(/*isChanged=*/true);
+    SkyKey newParent = key("new parent");
+    entry.addReverseDepAndCheckIfDone(newParent);
+    assertEquals(BuildingState.DirtyState.REBUILDING, entry.getDirtyState());
+    assertThat(setValue(entry, new SkyValue() {}, /*errorInfo=*/null,
+        /*graphVersion=*/1L)).containsExactly(newParent);
+  }
+
+  @Test
+  public void testClone() {
+    NodeEntry entry = new NodeEntry();
+    IntVersion version = new IntVersion(0);
+    IntegerValue originalValue = new IntegerValue(42);
+    SkyKey originalChild = key("child");
+    addTemporaryDirectDep(entry, originalChild);
+    entry.signalDep();
+    entry.setValue(originalValue, version);
+    entry.addReverseDepAndCheckIfDone(key("parent1"));
+    NodeEntry clone1 = entry.cloneNodeEntry();
+    entry.addReverseDepAndCheckIfDone(key("parent2"));
+    NodeEntry clone2 = entry.cloneNodeEntry();
+    entry.removeReverseDep(key("parent1"));
+    entry.removeReverseDep(key("parent2"));
+    IntegerValue updatedValue = new IntegerValue(52);
+    clone2.markDirty(true);
+    clone2.addReverseDepAndCheckIfDone(null);
+    SkyKey newChild = key("newchild");
+    addTemporaryDirectDep(clone2, newChild);
+    clone2.signalDep();
+    clone2.setValue(updatedValue, version.next());
+
+    assertThat(entry.getVersion()).isEqualTo(version);
+    assertThat(clone1.getVersion()).isEqualTo(version);
+    assertThat(clone2.getVersion()).isEqualTo(version.next());
+
+    assertThat(entry.getValue()).isEqualTo(originalValue);
+    assertThat(clone1.getValue()).isEqualTo(originalValue);
+    assertThat(clone2.getValue()).isEqualTo(updatedValue);
+
+    assertThat(entry.getDirectDeps()).containsExactly(originalChild);
+    assertThat(clone1.getDirectDeps()).containsExactly(originalChild);
+    assertThat(clone2.getDirectDeps()).containsExactly(newChild);
+
+    assertThat(entry.getReverseDeps()).hasSize(0);
+    assertThat(clone1.getReverseDeps()).containsExactly(key("parent1"));
+    assertThat(clone2.getReverseDeps()).containsExactly(key("parent1"), key("parent2"));
+  }
+
+  private static Set<SkyKey> setValue(NodeEntry entry, SkyValue value,
+      @Nullable ErrorInfo errorInfo, long graphVersion) {
+    return entry.setValue(ValueWithMetadata.normal(value, errorInfo, NO_EVENTS),
+        new IntVersion(graphVersion));
+  }
+
+  private static void addTemporaryDirectDep(NodeEntry entry, SkyKey key) {
+    GroupedListHelper<SkyKey> helper = new GroupedListHelper<>();
+    helper.add(key);
+    entry.addTemporaryDirectDeps(helper);
+  }
+
+  private static void addTemporaryDirectDeps(NodeEntry entry, SkyKey... keys) {
+    GroupedListHelper<SkyKey> helper = new GroupedListHelper<>();
+    helper.startGroup();
+    for (SkyKey key : keys) {
+      helper.add(key);
+    }
+    helper.endGroup();
+    entry.addTemporaryDirectDeps(helper);
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/skyframe/NotifyingInMemoryGraph.java b/src/test/java/com/google/devtools/build/skyframe/NotifyingInMemoryGraph.java
new file mode 100644
index 0000000..aa88278
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/skyframe/NotifyingInMemoryGraph.java
@@ -0,0 +1,128 @@
+// Copyright 2014 Google Inc. 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.skyframe;
+
+import com.google.devtools.build.lib.concurrent.ThreadSafety.ThreadSafe;
+import com.google.devtools.build.lib.util.Pair;
+
+import java.util.Set;
+
+/**
+ * Class that allows clients to be notified on each access of the graph. Clients can simply track
+ * accesses, or they can block to achieve desired synchronization.
+ */
+public class NotifyingInMemoryGraph extends InMemoryGraph {
+  private final Listener graphListener;
+
+  public NotifyingInMemoryGraph(Listener graphListener) {
+    this.graphListener = graphListener;
+  }
+
+  @Override
+  public NodeEntry createIfAbsent(SkyKey key) {
+    graphListener.accept(key, EventType.CREATE_IF_ABSENT, Order.BEFORE, null);
+    NodeEntry newval = getEntry(key);
+    NodeEntry oldval = getNodeMap().putIfAbsent(key, newval);
+    return oldval == null ? newval : oldval;
+  }
+
+  // Subclasses should override if they wish to subclass NotifyingNodeEntry.
+  protected NotifyingNodeEntry getEntry(SkyKey key) {
+    return new NotifyingNodeEntry(key);
+  }
+
+  /** Receiver to be informed when an event for a given key occurs. */
+  public interface Listener {
+    @ThreadSafe
+    void accept(SkyKey key, EventType type, Order order, Object context);
+
+    public static Listener NULL_LISTENER = new Listener() {
+      @Override
+      public void accept(SkyKey key, EventType type, Order order, Object context) {}
+    };
+  }
+
+  /**
+   * Graph/value entry events that the receiver can be informed of. When writing tests, feel free to
+   * add additional events here if needed.
+   */
+  public enum EventType {
+    CREATE_IF_ABSENT,
+    ADD_REVERSE_DEP,
+    SIGNAL,
+    SET_VALUE,
+    MARK_DIRTY,
+    IS_CHANGED,
+    IS_DIRTY
+  }
+
+  public enum Order {
+    BEFORE,
+    AFTER
+  }
+
+  protected class NotifyingNodeEntry extends NodeEntry {
+    private final SkyKey myKey;
+
+    protected NotifyingNodeEntry(SkyKey key) {
+      myKey = key;
+    }
+
+    // Note that these methods are not synchronized. Necessary synchronization happens when calling
+    // the super() methods.
+    @Override
+    DependencyState addReverseDepAndCheckIfDone(SkyKey reverseDep) {
+      graphListener.accept(myKey, EventType.ADD_REVERSE_DEP, Order.BEFORE, reverseDep);
+      DependencyState result = super.addReverseDepAndCheckIfDone(reverseDep);
+      graphListener.accept(myKey, EventType.ADD_REVERSE_DEP, Order.AFTER, reverseDep);
+      return result;
+    }
+
+    @Override
+    boolean signalDep(Version childVersion) {
+      graphListener.accept(myKey, EventType.SIGNAL, Order.BEFORE, childVersion);
+      boolean result = super.signalDep(childVersion);
+      graphListener.accept(myKey, EventType.SIGNAL, Order.AFTER, childVersion);
+      return result;
+    }
+
+    @Override
+    public Set<SkyKey> setValue(SkyValue value, Version version) {
+      graphListener.accept(myKey, EventType.SET_VALUE, Order.BEFORE, value);
+      Set<SkyKey> result = super.setValue(value, version);
+      graphListener.accept(myKey, EventType.SET_VALUE, Order.AFTER, value);
+      return result;
+    }
+
+    @Override
+    Pair<? extends Iterable<SkyKey>, ? extends SkyValue> markDirty(boolean isChanged) {
+      graphListener.accept(myKey, EventType.MARK_DIRTY, Order.BEFORE, isChanged);
+      Pair<? extends Iterable<SkyKey>, ? extends SkyValue> result = super.markDirty(isChanged);
+      graphListener.accept(myKey, EventType.MARK_DIRTY, Order.AFTER, isChanged);
+      return result;
+    }
+
+    @Override
+    boolean isChanged() {
+      graphListener.accept(myKey, EventType.IS_CHANGED, Order.BEFORE, this);
+      return super.isChanged();
+    }
+
+    @Override
+    public boolean isDirty() {
+      graphListener.accept(myKey, EventType.IS_DIRTY, Order.BEFORE, this);
+      return super.isDirty();
+    }
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/skyframe/ParallelEvaluatorTest.java b/src/test/java/com/google/devtools/build/skyframe/ParallelEvaluatorTest.java
new file mode 100644
index 0000000..5394437
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/skyframe/ParallelEvaluatorTest.java
@@ -0,0 +1,2260 @@
+// Copyright 2014 Google Inc. 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.skyframe;
+
+import static com.google.common.collect.Iterables.getOnlyElement;
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.Truth.assertWithMessage;
+import static com.google.devtools.build.skyframe.GraphTester.CONCATENATE;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
+import com.google.common.util.concurrent.Uninterruptibles;
+import com.google.devtools.build.lib.events.Event;
+import com.google.devtools.build.lib.events.EventCollector;
+import com.google.devtools.build.lib.events.EventHandler;
+import com.google.devtools.build.lib.events.EventKind;
+import com.google.devtools.build.lib.events.OutputFilter.RegexOutputFilter;
+import com.google.devtools.build.lib.events.Reporter;
+import com.google.devtools.build.lib.testutil.JunitTestUtils;
+import com.google.devtools.build.lib.testutil.MoreAsserts;
+import com.google.devtools.build.lib.testutil.TestThread;
+import com.google.devtools.build.lib.testutil.TestUtils;
+import com.google.devtools.build.skyframe.GraphTester.StringValue;
+import com.google.devtools.build.skyframe.NotifyingInMemoryGraph.EventType;
+import com.google.devtools.build.skyframe.NotifyingInMemoryGraph.Listener;
+import com.google.devtools.build.skyframe.NotifyingInMemoryGraph.Order;
+import com.google.devtools.build.skyframe.SkyFunctionException.Transience;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.Semaphore;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+import javax.annotation.Nullable;
+
+/**
+ * Tests for {@link ParallelEvaluator}.
+ */
+@RunWith(JUnit4.class)
+public class ParallelEvaluatorTest {
+  protected ProcessableGraph graph;
+  protected IntVersion graphVersion = new IntVersion(0);
+  protected GraphTester tester = new GraphTester();
+
+  private EventCollector eventCollector;
+  private EventHandler reporter;
+
+  private EvaluationProgressReceiver revalidationReceiver;
+
+  @Before
+  public void initializeReporter() {
+    eventCollector = new EventCollector(EventKind.ALL_EVENTS);
+    reporter = new Reporter(eventCollector);
+  }
+
+  private ParallelEvaluator makeEvaluator(ProcessableGraph graph,
+      ImmutableMap<SkyFunctionName, ? extends SkyFunction> builders, boolean keepGoing) {
+    Version oldGraphVersion = graphVersion;
+    graphVersion = graphVersion.next();
+    return new ParallelEvaluator(graph, oldGraphVersion,
+        builders, reporter,  new MemoizingEvaluator.EmittedEventState(), keepGoing,
+        150, revalidationReceiver, new DirtyKeyTrackerImpl());
+  }
+
+  /** Convenience method for eval-ing a single value. */
+  protected SkyValue eval(boolean keepGoing, SkyKey key) throws InterruptedException {
+    return eval(keepGoing, ImmutableList.of(key)).get(key);
+  }
+
+  protected ErrorInfo evalValueInError(SkyKey key) throws InterruptedException {
+    return eval(true, ImmutableList.of(key)).getError(key);
+  }
+
+  protected <T extends SkyValue> EvaluationResult<T> eval(boolean keepGoing, SkyKey... keys)
+      throws InterruptedException {
+    return eval(keepGoing, ImmutableList.copyOf(keys));
+  }
+
+  protected <T extends SkyValue> EvaluationResult<T> eval(boolean keepGoing, Iterable<SkyKey> keys)
+      throws InterruptedException {
+    ParallelEvaluator evaluator = makeEvaluator(graph,
+        ImmutableMap.of(GraphTester.NODE_TYPE, tester.createDelegatingFunction()),
+        keepGoing);
+    return evaluator.eval(keys);
+  }
+
+  protected GraphTester.TestFunction set(String name, String value) {
+    return tester.set(name, new StringValue(value));
+  }
+
+  @Test
+  public void smoke() throws Exception {
+    graph = new InMemoryGraph();
+    set("a", "a");
+    set("b", "b");
+    tester.getOrCreate("ab").addDependency("a").addDependency("b").setComputedValue(CONCATENATE);
+    StringValue value = (StringValue) eval(false, GraphTester.toSkyKey("ab"));
+    assertEquals("ab", value.getValue());
+    JunitTestUtils.assertNoEvents(eventCollector);
+  }
+
+  /**
+   * Test interruption handling when a long-running SkyFunction gets interrupted.
+   */
+  @Test
+  public void interruptedFunction() throws Exception {
+    runInterruptionTest(new SkyFunctionFactory() {
+      @Override
+      public SkyFunction create(final Semaphore threadStarted, final String[] errorMessage) {
+        return new SkyFunction() {
+          @Override
+          public SkyValue compute(SkyKey key, Environment env) throws InterruptedException {
+            // Signal the waiting test thread that the evaluator thread has really started.
+            threadStarted.release();
+
+            // Simulate a SkyFunction that runs for 10 seconds (this number was chosen arbitrarily).
+            // The main thread should interrupt it shortly after it got started.
+            Thread.sleep(10 * 1000);
+
+            // Set an error message to indicate that the expected interruption didn't happen.
+            // We can't use Assert.fail(String) on an async thread.
+            errorMessage[0] = "SkyFunction should have been interrupted";
+            return null;
+          }
+
+          @Nullable
+          @Override
+          public String extractTag(SkyKey skyKey) {
+            return null;
+          }
+        };
+      }
+    });
+  }
+
+  /**
+   * Test interruption handling when the Evaluator is in-between running SkyFunctions.
+   *
+   * <p>This is the point in time after a SkyFunction requested a dependency which is not yet built
+   * so the builder returned null to the Evaluator, and the latter is about to schedule evaluation
+   * of the missing dependency but gets interrupted before the dependency's SkyFunction could start.
+   */
+  @Test
+  public void interruptedEvaluatorThread() throws Exception {
+    runInterruptionTest(new SkyFunctionFactory() {
+      @Override
+      public SkyFunction create(final Semaphore threadStarted, final String[] errorMessage) {
+        return new SkyFunction() {
+          // No need to synchronize access to this field; we always request just one more
+          // dependency, so it's only one SkyFunction running at any time.
+          private int valueIdCounter = 0;
+
+          @Override
+          public SkyValue compute(SkyKey key, Environment env) {
+            // Signal the waiting test thread that the Evaluator thread has really started.
+            threadStarted.release();
+
+            // Keep the evaluator busy until the test's thread gets scheduled and can
+            // interrupt the Evaluator's thread.
+            env.getValue(GraphTester.toSkyKey("a" + valueIdCounter++));
+
+            // This method never throws InterruptedException, therefore it's the responsibility
+            // of the Evaluator to detect the interrupt and avoid calling subsequent SkyFunctions.
+            return null;
+          }
+
+          @Nullable
+          @Override
+          public String extractTag(SkyKey skyKey) {
+            return null;
+          }
+        };
+      }
+    });
+  }
+
+  private void runPartialResultOnInterruption(boolean buildFastFirst) throws Exception {
+    graph = new InMemoryGraph();
+    // Two runs for fastKey's builder and one for the start of waitKey's builder.
+    final CountDownLatch allValuesReady = new CountDownLatch(3);
+    final SkyKey waitKey = GraphTester.toSkyKey("wait");
+    final SkyKey fastKey = GraphTester.toSkyKey("fast");
+    SkyKey leafKey = GraphTester.toSkyKey("leaf");
+    tester.getOrCreate(waitKey).setBuilder(new SkyFunction() {
+          @Override
+          public SkyValue compute(SkyKey skyKey, Environment env) throws InterruptedException {
+            allValuesReady.countDown();
+            Thread.sleep(10000);
+            throw new AssertionError("Should have been interrupted");
+          }
+
+          @Override
+          public String extractTag(SkyKey skyKey) {
+            return null;
+          }
+        });
+    tester.getOrCreate(fastKey).setBuilder(new ChainedFunction(null, null, allValuesReady, false,
+        new StringValue("fast"), ImmutableList.of(leafKey)));
+    tester.set(leafKey, new StringValue("leaf"));
+    if (buildFastFirst) {
+      eval(/*keepGoing=*/false, fastKey);
+    }
+    final Set<SkyKey> receivedValues = Sets.newConcurrentHashSet();
+    revalidationReceiver = new EvaluationProgressReceiver() {
+      @Override
+      public void invalidated(SkyValue value, InvalidationState state) {}
+
+      @Override
+      public void enqueueing(SkyKey key) {}
+
+      @Override
+      public void evaluated(SkyKey skyKey, SkyValue value, EvaluationState state) {
+        receivedValues.add(skyKey);
+      }
+    };
+    TestThread evalThread = new TestThread() {
+      @Override
+      public void runTest() throws Exception {
+        try {
+          eval(/*keepGoing=*/true, waitKey, fastKey);
+          fail();
+        } catch (InterruptedException e) {
+          // Expected.
+        }
+      }
+    };
+    evalThread.start();
+    assertTrue(allValuesReady.await(TestUtils.WAIT_TIMEOUT_SECONDS, TimeUnit.SECONDS));
+    evalThread.interrupt();
+    evalThread.join(TestUtils.WAIT_TIMEOUT_MILLISECONDS);
+    assertFalse(evalThread.isAlive());
+    if (buildFastFirst) {
+      // If leafKey was already built, it is not reported to the receiver.
+      assertThat(receivedValues).containsExactly(fastKey);
+    } else {
+      // On first time being built, leafKey is registered too.
+      assertThat(receivedValues).containsExactly(fastKey, leafKey);
+    }
+  }
+
+  @Test
+  public void partialResultOnInterruption() throws Exception {
+    runPartialResultOnInterruption(/*buildFastFirst=*/false);
+  }
+
+  @Test
+  public void partialCachedResultOnInterruption() throws Exception {
+    runPartialResultOnInterruption(/*buildFastFirst=*/true);
+  }
+
+  /**
+   * Factory for SkyFunctions for interruption testing (see {@link #runInterruptionTest}).
+   */
+  private interface SkyFunctionFactory {
+    /**
+     * Creates a SkyFunction suitable for a specific test scenario.
+     *
+     * @param threadStarted a latch which the returned SkyFunction must
+     *     {@link Semaphore#release() release} once it started (otherwise the test won't work)
+     * @param errorMessage a single-element array; the SkyFunction can put a error message in it
+     *     to indicate that an assertion failed (calling {@code fail} from async thread doesn't
+     *     work)
+     */
+    SkyFunction create(final Semaphore threadStarted, final String[] errorMessage);
+  }
+
+  /**
+   * Test that we can handle the Evaluator getting interrupted at various points.
+   *
+   * <p>This method creates an Evaluator with the specified SkyFunction for GraphTested.NODE_TYPE,
+   * then starts a thread, requests evaluation and asserts that evaluation started. It then
+   * interrupts the Evaluator thread and asserts that it acknowledged the interruption.
+   *
+   * @param valueBuilderFactory creates a SkyFunction which may or may not handle interruptions
+   *     (depending on the test)
+   */
+  private void runInterruptionTest(SkyFunctionFactory valueBuilderFactory) throws Exception {
+    final Semaphore threadStarted = new Semaphore(0);
+    final Semaphore threadInterrupted = new Semaphore(0);
+    final String[] wasError = new String[] { null };
+    final ParallelEvaluator evaluator = makeEvaluator(new InMemoryGraph(),
+        ImmutableMap.of(GraphTester.NODE_TYPE, valueBuilderFactory.create(threadStarted, wasError)),
+        false);
+
+    Thread t = new Thread(new Runnable() {
+        @Override
+        public void run() {
+          try {
+            evaluator.eval(ImmutableList.of(GraphTester.toSkyKey("a")));
+
+            // There's no real need to set an error here. If the thread is not interrupted then
+            // threadInterrupted is not released and the test thread will fail to acquire it.
+            wasError[0] = "evaluation should have been interrupted";
+          } catch (InterruptedException e) {
+            // This is the interrupt we are waiting for. It should come straight from the
+            // evaluator (more precisely, the AbstractQueueVisitor).
+            // Signal the waiting test thread that the interrupt was acknowledged.
+            threadInterrupted.release();
+          }
+        }
+    });
+
+    // Start the thread and wait for a semaphore. This ensures that the thread was really started.
+    t.start();
+    assertTrue(threadStarted.tryAcquire(TestUtils.WAIT_TIMEOUT_MILLISECONDS,
+        TimeUnit.MILLISECONDS));
+
+    // Interrupt the thread and wait for a semaphore. This ensures that the thread was really
+    // interrupted and this fact was acknowledged.
+    t.interrupt();
+    assertTrue(threadInterrupted.tryAcquire(TestUtils.WAIT_TIMEOUT_MILLISECONDS,
+        TimeUnit.MILLISECONDS));
+
+    // The SkyFunction may have reported an error.
+    if (wasError[0] != null) {
+      fail(wasError[0]);
+    }
+
+    // Wait for the thread to finish.
+    t.join(TestUtils.WAIT_TIMEOUT_MILLISECONDS);
+  }
+
+  @Test
+  public void unrecoverableError() throws Exception {
+    class CustomRuntimeException extends RuntimeException {}
+    final CustomRuntimeException expected = new CustomRuntimeException();
+
+    final SkyFunction builder = new SkyFunction() {
+      @Override
+      @Nullable
+      public SkyValue compute(SkyKey skyKey, Environment env)
+          throws SkyFunctionException, InterruptedException {
+        throw expected;
+      }
+
+      @Override
+      @Nullable
+      public String extractTag(SkyKey skyKey) {
+        return null;
+      }
+    };
+
+    final ParallelEvaluator evaluator = makeEvaluator(new InMemoryGraph(),
+        ImmutableMap.of(GraphTester.NODE_TYPE, builder),
+        false);
+
+    SkyKey valueToEval = GraphTester.toSkyKey("a");
+    try {
+      evaluator.eval(ImmutableList.of(valueToEval));
+    } catch (RuntimeException re) {
+      assertTrue(re.getMessage()
+          .contains("Unrecoverable error while evaluating node '" + valueToEval.toString() + "'"));
+      assertTrue(re.getCause() instanceof CustomRuntimeException);
+    }
+  }
+
+  @Test
+  public void simpleWarning() throws Exception {
+    graph = new InMemoryGraph();
+    set("a", "a").setWarning("warning on 'a'");
+    StringValue value = (StringValue) eval(false, GraphTester.toSkyKey("a"));
+    assertEquals("a", value.getValue());
+    JunitTestUtils.assertContainsEvent(eventCollector, "warning on 'a'");
+    JunitTestUtils.assertEventCount(1, eventCollector);
+  }
+
+  @Test
+  public void warningMatchesRegex() throws Exception {
+    graph = new InMemoryGraph();
+    ((Reporter) reporter).setOutputFilter(RegexOutputFilter.forRegex("a"));
+    set("example", "a value").setWarning("warning message");
+    SkyKey a = GraphTester.toSkyKey("example");
+    tester.getOrCreate(a).setTag("a");
+    StringValue value = (StringValue) eval(false, a);
+    assertEquals("a value", value.getValue());
+    JunitTestUtils.assertContainsEvent(eventCollector, "warning message");
+    JunitTestUtils.assertEventCount(1, eventCollector);
+  }
+
+  @Test
+  public void warningMatchesRegexOnlyTag() throws Exception {
+    graph = new InMemoryGraph();
+    ((Reporter) reporter).setOutputFilter(RegexOutputFilter.forRegex("a"));
+    set("a", "a value").setWarning("warning on 'a'");
+    SkyKey a = GraphTester.toSkyKey("a");
+    tester.getOrCreate(a).setTag("b");
+    StringValue value = (StringValue) eval(false, a);
+    assertEquals("a value", value.getValue());
+    JunitTestUtils.assertEventCount(0, eventCollector);  }
+
+  @Test
+  public void warningDoesNotMatchRegex() throws Exception {
+    graph = new InMemoryGraph();
+    ((Reporter) reporter).setOutputFilter(RegexOutputFilter.forRegex("b"));
+    set("a", "a").setWarning("warning on 'a'");
+    SkyKey a = GraphTester.toSkyKey("a");
+    tester.getOrCreate(a).setTag("a");
+    StringValue value = (StringValue) eval(false, a);
+    assertEquals("a", value.getValue());
+    JunitTestUtils.assertEventCount(0, eventCollector);
+  }
+
+  /** Regression test: events from already-done value not replayed. */
+  @Test
+  public void eventFromDoneChildRecorded() throws Exception {
+    graph = new InMemoryGraph();
+    set("a", "a").setWarning("warning on 'a'");
+    SkyKey a = GraphTester.toSkyKey("a");
+    SkyKey top = GraphTester.toSkyKey("top");
+    tester.getOrCreate(top).addDependency(a).setComputedValue(CONCATENATE);
+    // Build a so that it is already in the graph.
+    eval(false, a);
+    JunitTestUtils.assertEventCount(1, eventCollector);
+    eventCollector.clear();
+    // Build top. The warning from a should be reprinted.
+    eval(false, top);
+    JunitTestUtils.assertEventCount(1, eventCollector);
+    eventCollector.clear();
+    // Build top again. The warning should have been stored in the value.
+    eval(false, top);
+    JunitTestUtils.assertEventCount(1, eventCollector);
+  }
+
+  @Test
+  public void shouldCreateErrorValueWithRootCause() throws Exception {
+    graph = new InMemoryGraph();
+    set("a", "a");
+    SkyKey parentErrorKey = GraphTester.toSkyKey("parent");
+    SkyKey errorKey = GraphTester.toSkyKey("error");
+    tester.getOrCreate(parentErrorKey).addDependency("a").addDependency(errorKey)
+    .setComputedValue(CONCATENATE);
+    tester.getOrCreate(errorKey).setHasError(true);
+    ErrorInfo error = evalValueInError(parentErrorKey);
+    assertThat(error.getRootCauses()).containsExactly(errorKey);
+  }
+
+  @Test
+  public void shouldBuildOneTarget() throws Exception {
+    graph = new InMemoryGraph();
+    set("a", "a");
+    set("b", "b");
+    SkyKey parentErrorKey = GraphTester.toSkyKey("parent");
+    SkyKey errorFreeKey = GraphTester.toSkyKey("ab");
+    SkyKey errorKey = GraphTester.toSkyKey("error");
+    tester.getOrCreate(parentErrorKey).addDependency(errorKey).addDependency("a")
+    .setComputedValue(CONCATENATE);
+    tester.getOrCreate(errorKey).setHasError(true);
+    tester.getOrCreate(errorFreeKey).addDependency("a").addDependency("b")
+    .setComputedValue(CONCATENATE);
+    EvaluationResult<StringValue> result = eval(true, parentErrorKey, errorFreeKey);
+    ErrorInfo error = result.getError(parentErrorKey);
+    assertThat(error.getRootCauses()).containsExactly(errorKey);
+    StringValue abValue = result.get(errorFreeKey);
+    assertEquals("ab", abValue.getValue());
+  }
+
+  @Test
+  public void catastropheHaltsBuild_KeepGoing_KeepEdges() throws Exception {
+    catastrophicBuild(true, true);
+  }
+
+  @Test
+  public void catastropheHaltsBuild_KeepGoing_NoKeepEdges() throws Exception {
+    catastrophicBuild(true, false);
+  }
+
+  @Test
+  public void catastropheInBuild_NoKeepGoing_KeepEdges() throws Exception {
+    catastrophicBuild(false, true);
+  }
+
+  private void catastrophicBuild(boolean keepGoing, boolean keepEdges) throws Exception {
+    graph = new InMemoryGraph(keepEdges);
+
+    SkyKey catastropheKey = GraphTester.toSkyKey("catastrophe");
+    SkyKey otherKey = GraphTester.toSkyKey("someKey");
+
+    tester.getOrCreate(catastropheKey).setBuilder(new SkyFunction() {
+      @Nullable
+      @Override
+      public SkyValue compute(SkyKey skyKey, Environment env) throws SkyFunctionException {
+        throw new SkyFunctionException(new SomeErrorException("bad"),
+            Transience.PERSISTENT) {
+          @Override
+          public boolean isCatastrophic() {
+            return true;
+          }
+        };
+      }
+
+      @Nullable
+      @Override
+      public String extractTag(SkyKey skyKey) {
+        return null;
+      }
+    });
+
+    tester.getOrCreate(otherKey).setBuilder(new SkyFunction() {
+      @Nullable
+      @Override
+      public SkyValue compute(SkyKey skyKey, Environment env) throws InterruptedException {
+        new CountDownLatch(1).await();
+        throw new RuntimeException("can't get here");
+      }
+
+      @Nullable
+      @Override
+      public String extractTag(SkyKey skyKey) {
+        return null;
+      }
+    });
+
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    tester.getOrCreate(topKey).addDependency(catastropheKey).setComputedValue(CONCATENATE);
+    EvaluationResult<StringValue> result = eval(keepGoing, topKey, otherKey);
+    if (!keepGoing) {
+      ErrorInfo error = result.getError(topKey);
+      assertThat(error.getRootCauses()).containsExactly(catastropheKey);
+    } else {
+      assertTrue(result.hasError());
+      assertThat(result.errorMap()).isEmpty();
+    }
+  }
+
+  @Test
+  public void parentFailureDoesntAffectChild() throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey parentKey = GraphTester.toSkyKey("parent");
+    tester.getOrCreate(parentKey).setHasError(true);
+    SkyKey childKey = GraphTester.toSkyKey("child");
+    set("child", "onions");
+    tester.getOrCreate(parentKey).addDependency(childKey).setComputedValue(CONCATENATE);
+    EvaluationResult<StringValue> result = eval(/*keepGoing=*/true, parentKey, childKey);
+    // Child is guaranteed to complete successfully before parent can run (and fail),
+    // since parent depends on it.
+    StringValue childValue = result.get(childKey);
+    Assert.assertNotNull(childValue);
+    assertEquals("onions", childValue.getValue());
+    ErrorInfo error = result.getError(parentKey);
+    Assert.assertNotNull(error);
+    assertThat(error.getRootCauses()).containsExactly(parentKey);
+  }
+
+  @Test
+  public void newParentOfErrorShouldHaveError() throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey errorKey = GraphTester.toSkyKey("error");
+    tester.getOrCreate(errorKey).setHasError(true);
+    ErrorInfo error = evalValueInError(errorKey);
+    assertThat(error.getRootCauses()).containsExactly(errorKey);
+    SkyKey parentKey = GraphTester.toSkyKey("parent");
+    tester.getOrCreate(parentKey).addDependency("error").setComputedValue(CONCATENATE);
+    error = evalValueInError(parentKey);
+    assertThat(error.getRootCauses()).containsExactly(errorKey);
+  }
+
+  @Test
+  public void errorTwoLevelsDeep() throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey parentKey = GraphTester.toSkyKey("parent");
+    SkyKey errorKey = GraphTester.toSkyKey("error");
+    tester.getOrCreate(errorKey).setHasError(true);
+    tester.getOrCreate("mid").addDependency(errorKey).setComputedValue(CONCATENATE);
+    tester.getOrCreate(parentKey).addDependency("mid").setComputedValue(CONCATENATE);
+    ErrorInfo error = evalValueInError(parentKey);
+    assertThat(error.getRootCauses()).containsExactly(errorKey);
+  }
+
+  /**
+   * A recreation of BuildViewTest#testHasErrorRaceCondition.  Also similar to errorTwoLevelsDeep,
+   * except here we request multiple toplevel values.
+   */
+  @Test
+  public void errorPropagationToTopLevelValues() throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    SkyKey midKey = GraphTester.toSkyKey("mid");
+    SkyKey badKey = GraphTester.toSkyKey("bad");
+    tester.getOrCreate(topKey).addDependency(midKey).setComputedValue(CONCATENATE);
+    tester.getOrCreate(midKey).addDependency(badKey).setComputedValue(CONCATENATE);
+    tester.getOrCreate(badKey).setHasError(true);
+    EvaluationResult<SkyValue> result = eval(/*keepGoing=*/false, topKey, midKey);
+    assertThat(result.getError(midKey).getRootCauses()).containsExactly(badKey);
+    // Do it again with keepGoing.  We should also see an error for the top key this time.
+    result = eval(/*keepGoing=*/true, topKey, midKey);
+    assertThat(result.getError(midKey).getRootCauses()).containsExactly(badKey);
+    assertThat(result.getError(topKey).getRootCauses()).containsExactly(badKey);
+  }
+
+  @Test
+  public void valueNotUsedInFailFastErrorRecovery() throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    SkyKey recoveryKey = GraphTester.toSkyKey("midRecovery");
+    SkyKey badKey = GraphTester.toSkyKey("bad");
+
+    tester.getOrCreate(topKey).addDependency(recoveryKey).setComputedValue(CONCATENATE);
+    tester.getOrCreate(recoveryKey).addErrorDependency(badKey, new StringValue("i recovered"))
+        .setComputedValue(CONCATENATE);
+    tester.getOrCreate(badKey).setHasError(true);
+
+    EvaluationResult<SkyValue> result = eval(/*keepGoing=*/true, ImmutableList.of(recoveryKey));
+    assertThat(result.errorMap()).isEmpty();
+    assertTrue(result.hasError());
+    assertEquals(new StringValue("i recovered"), result.get(recoveryKey));
+
+    result = eval(/*keepGoing=*/false, ImmutableList.of(topKey));
+    assertTrue(result.hasError());
+    assertThat(result.keyNames()).isEmpty();
+    assertEquals(1, result.errorMap().size());
+    assertNotNull(result.getError(topKey).getException());
+  }
+
+  /**
+   * Regression test: "clearing incomplete values on --keep_going build is racy".
+   * Tests that if a value is requested on the first (non-keep-going) build and its child throws
+   * an error, when the second (keep-going) build runs, there is not a race that keeps it as a
+   * reverse dep of its children.
+   */
+  @Test
+  public void raceClearingIncompleteValues() throws Exception {
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    final SkyKey midKey = GraphTester.toSkyKey("mid");
+    SkyKey badKey = GraphTester.toSkyKey("bad");
+    final AtomicBoolean waitForSecondCall = new AtomicBoolean(false);
+    final TrackingAwaiter trackingAwaiter = new TrackingAwaiter();
+    final CountDownLatch otherThreadWinning = new CountDownLatch(1);
+    final AtomicReference<Thread> firstThread = new AtomicReference<>();
+    graph = new NotifyingInMemoryGraph(new Listener() {
+      @Override
+      public void accept(SkyKey key, EventType type, Order order, Object context) {
+        if (!waitForSecondCall.get()) {
+          return;
+        }
+        if (key.equals(midKey)) {
+          if (type == EventType.CREATE_IF_ABSENT) {
+            // The first thread to create midKey will not be the first thread to add a reverse dep
+            // to it.
+            firstThread.compareAndSet(null, Thread.currentThread());
+            return;
+          }
+          if (type == EventType.ADD_REVERSE_DEP) {
+            if (order == Order.BEFORE && Thread.currentThread().equals(firstThread.get())) {
+              // If this thread created midKey, block until the other thread adds a dep on it.
+              trackingAwaiter.awaitLatchAndTrackExceptions(otherThreadWinning,
+                  "other thread didn't pass this one");
+            } else if (order == Order.AFTER && !Thread.currentThread().equals(firstThread.get())) {
+              // This thread has added a dep. Allow the other thread to proceed.
+              otherThreadWinning.countDown();
+            }
+          }
+        }
+      }
+    });
+    tester.getOrCreate(topKey).addDependency(midKey).setComputedValue(CONCATENATE);
+    tester.getOrCreate(midKey).addDependency(badKey).setComputedValue(CONCATENATE);
+    tester.getOrCreate(badKey).setHasError(true);
+    EvaluationResult<SkyValue> result = eval(/*keepGoing=*/false, topKey, midKey);
+    assertThat(result.getError(midKey).getRootCauses()).containsExactly(badKey);
+    waitForSecondCall.set(true);
+    result = eval(/*keepGoing=*/true, topKey, midKey);
+    trackingAwaiter.assertNoErrors();
+    assertNotNull(firstThread.get());
+    assertEquals(0, otherThreadWinning.getCount());
+    assertThat(result.getError(midKey).getRootCauses()).containsExactly(badKey);
+    assertThat(result.getError(topKey).getRootCauses()).containsExactly(badKey);
+  }
+
+  @Test
+  public void multipleRootCauses() throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey parentKey = GraphTester.toSkyKey("parent");
+    SkyKey errorKey = GraphTester.toSkyKey("error");
+    SkyKey errorKey2 = GraphTester.toSkyKey("error2");
+    SkyKey errorKey3 = GraphTester.toSkyKey("error3");
+    tester.getOrCreate(errorKey).setHasError(true);
+    tester.getOrCreate(errorKey2).setHasError(true);
+    tester.getOrCreate(errorKey3).setHasError(true);
+    tester.getOrCreate("mid").addDependency(errorKey).addDependency(errorKey2)
+      .setComputedValue(CONCATENATE);
+    tester.getOrCreate(parentKey)
+      .addDependency("mid").addDependency(errorKey2).addDependency(errorKey3)
+      .setComputedValue(CONCATENATE);
+    ErrorInfo error = evalValueInError(parentKey);
+    assertThat(error.getRootCauses()).containsExactly(errorKey, errorKey2, errorKey3);
+  }
+
+  @Test
+  public void rootCauseWithNoKeepGoing() throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey parentKey = GraphTester.toSkyKey("parent");
+    SkyKey errorKey = GraphTester.toSkyKey("error");
+    tester.getOrCreate(errorKey).setHasError(true);
+    tester.getOrCreate("mid").addDependency(errorKey).setComputedValue(CONCATENATE);
+    tester.getOrCreate(parentKey).addDependency("mid").setComputedValue(CONCATENATE);
+    EvaluationResult<StringValue> result = eval(false, ImmutableList.of(parentKey));
+    Map.Entry<SkyKey, ErrorInfo> error = Iterables.getOnlyElement(result.errorMap().entrySet());
+    assertEquals(parentKey, error.getKey());
+    assertThat(error.getValue().getRootCauses()).containsExactly(errorKey);
+  }
+
+  @Test
+  public void errorBubblesToParentsOfTopLevelValue() throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey parentKey = GraphTester.toSkyKey("parent");
+    final SkyKey errorKey = GraphTester.toSkyKey("error");
+    final CountDownLatch latch = new CountDownLatch(1);
+    tester.getOrCreate(errorKey).setBuilder(new ChainedFunction(null, /*waitToFinish=*/latch, null,
+        false, /*value=*/null, ImmutableList.<SkyKey>of()));
+    tester.getOrCreate(parentKey).setBuilder(new ChainedFunction(/*notifyStart=*/latch, null, null,
+        false, new StringValue("unused"), ImmutableList.of(errorKey)));
+    EvaluationResult<StringValue> result = eval( /*keepGoing=*/false,
+        ImmutableList.of(parentKey, errorKey));
+    assertEquals(result.toString(), 2, result.errorMap().size());
+  }
+
+  @Test
+  public void noKeepGoingAfterKeepGoingFails() throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey errorKey = GraphTester.toSkyKey("my_error_value");
+    tester.getOrCreate(errorKey).setHasError(true);
+    SkyKey parentKey = GraphTester.toSkyKey("parent");
+    tester.getOrCreate(parentKey).addDependency(errorKey);
+    ErrorInfo error = evalValueInError(parentKey);
+    assertThat(error.getRootCauses()).containsExactly(errorKey);
+    SkyKey[] list = { parentKey };
+    EvaluationResult<StringValue> result = eval(false, list);
+    ErrorInfo errorInfo = result.getError();
+    assertEquals(errorKey, Iterables.getOnlyElement(errorInfo.getRootCauses()));
+    assertEquals(errorKey.toString(), errorInfo.getException().getMessage());
+  }
+
+  @Test
+  public void twoErrors() throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey firstError = GraphTester.toSkyKey("error1");
+    SkyKey secondError = GraphTester.toSkyKey("error2");
+    CountDownLatch firstStart = new CountDownLatch(1);
+    CountDownLatch secondStart = new CountDownLatch(1);
+    tester.getOrCreate(firstError).setBuilder(new ChainedFunction(firstStart, secondStart,
+        /*notifyFinish=*/null, /*waitForException=*/false, /*value=*/null,
+        ImmutableList.<SkyKey>of()));
+    tester.getOrCreate(secondError).setBuilder(new ChainedFunction(secondStart, firstStart,
+        /*notifyFinish=*/null, /*waitForException=*/false, /*value=*/null,
+        ImmutableList.<SkyKey>of()));
+    EvaluationResult<StringValue> result = eval(/*keepGoing=*/false, firstError, secondError);
+    assertTrue(result.toString(), result.hasError());
+    // With keepGoing=false, the eval call will terminate with exactly one error (the first one
+    // thrown). But the first one thrown here is non-deterministic since we synchronize the
+    // builders so that they run at roughly the same time.
+    assertThat(ImmutableSet.of(firstError, secondError)).contains(
+        Iterables.getOnlyElement(result.errorMap().keySet()));
+  }
+
+  @Test
+  public void simpleCycle() throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey aKey = GraphTester.toSkyKey("a");
+    SkyKey bKey = GraphTester.toSkyKey("b");
+    tester.getOrCreate(aKey).addDependency(bKey);
+    tester.getOrCreate(bKey).addDependency(aKey);
+    ErrorInfo errorInfo = eval(false, ImmutableList.of(aKey)).getError();
+    assertEquals(null, errorInfo.getException());
+    CycleInfo cycleInfo = Iterables.getOnlyElement(errorInfo.getCycleInfo());
+    assertThat(cycleInfo.getCycle()).containsExactly(aKey, bKey).inOrder();
+    assertTrue(cycleInfo.getPathToCycle().isEmpty());
+  }
+
+  @Test
+  public void cycleWithHead() throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey aKey = GraphTester.toSkyKey("a");
+    SkyKey bKey = GraphTester.toSkyKey("b");
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    SkyKey midKey = GraphTester.toSkyKey("mid");
+    tester.getOrCreate(topKey).addDependency(midKey);
+    tester.getOrCreate(midKey).addDependency(aKey);
+    tester.getOrCreate(aKey).addDependency(bKey);
+    tester.getOrCreate(bKey).addDependency(aKey);
+    ErrorInfo errorInfo = eval(false, ImmutableList.of(topKey)).getError();
+    assertEquals(null, errorInfo.getException());
+    CycleInfo cycleInfo = Iterables.getOnlyElement(errorInfo.getCycleInfo());
+    assertThat(cycleInfo.getCycle()).containsExactly(aKey, bKey).inOrder();
+    assertThat(cycleInfo.getPathToCycle()).containsExactly(topKey, midKey).inOrder();
+  }
+
+  @Test
+  public void selfEdgeWithHead() throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey aKey = GraphTester.toSkyKey("a");
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    SkyKey midKey = GraphTester.toSkyKey("mid");
+    tester.getOrCreate(topKey).addDependency(midKey);
+    tester.getOrCreate(midKey).addDependency(aKey);
+    tester.getOrCreate(aKey).addDependency(aKey);
+    ErrorInfo errorInfo = eval(false, ImmutableList.of(topKey)).getError();
+    assertEquals(null, errorInfo.getException());
+    CycleInfo cycleInfo = Iterables.getOnlyElement(errorInfo.getCycleInfo());
+    assertThat(cycleInfo.getCycle()).containsExactly(aKey).inOrder();
+    assertThat(cycleInfo.getPathToCycle()).containsExactly(topKey, midKey).inOrder();
+  }
+
+  @Test
+  public void cycleWithKeepGoing() throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey aKey = GraphTester.toSkyKey("a");
+    SkyKey bKey = GraphTester.toSkyKey("b");
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    SkyKey midKey = GraphTester.toSkyKey("mid");
+    SkyKey goodKey = GraphTester.toSkyKey("good");
+    StringValue goodValue = new StringValue("good");
+    tester.set(goodKey, goodValue);
+    tester.getOrCreate(topKey).addDependency(midKey);
+    tester.getOrCreate(midKey).addDependency(aKey);
+    tester.getOrCreate(aKey).addDependency(bKey);
+    tester.getOrCreate(bKey).addDependency(aKey);
+    EvaluationResult<StringValue> result = eval(true, topKey, goodKey);
+    assertEquals(goodValue, result.get(goodKey));
+    assertEquals(null, result.get(topKey));
+    ErrorInfo errorInfo = result.getError(topKey);
+    CycleInfo cycleInfo = Iterables.getOnlyElement(errorInfo.getCycleInfo());
+    assertThat(cycleInfo.getCycle()).containsExactly(aKey, bKey).inOrder();
+    assertThat(cycleInfo.getPathToCycle()).containsExactly(topKey, midKey).inOrder();
+  }
+
+  @Test
+  public void twoCycles() throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey aKey = GraphTester.toSkyKey("a");
+    SkyKey bKey = GraphTester.toSkyKey("b");
+    SkyKey cKey = GraphTester.toSkyKey("c");
+    SkyKey dKey = GraphTester.toSkyKey("d");
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    tester.getOrCreate(topKey).addDependency(aKey).addDependency(cKey);
+    tester.getOrCreate(aKey).addDependency(bKey);
+    tester.getOrCreate(bKey).addDependency(aKey);
+    tester.getOrCreate(cKey).addDependency(dKey);
+    tester.getOrCreate(dKey).addDependency(cKey);
+    EvaluationResult<StringValue> result = eval(false, ImmutableList.of(topKey));
+    assertEquals(null, result.get(topKey));
+    ErrorInfo errorInfo = result.getError(topKey);
+    Iterable<CycleInfo> cycles = CycleInfo.prepareCycles(topKey,
+        ImmutableList.of(new CycleInfo(ImmutableList.of(aKey, bKey)),
+        new CycleInfo(ImmutableList.of(cKey, dKey))));
+    assertThat(cycles).contains(getOnlyElement(errorInfo.getCycleInfo()));
+  }
+
+
+  @Test
+  public void twoCyclesKeepGoing() throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey aKey = GraphTester.toSkyKey("a");
+    SkyKey bKey = GraphTester.toSkyKey("b");
+    SkyKey cKey = GraphTester.toSkyKey("c");
+    SkyKey dKey = GraphTester.toSkyKey("d");
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    tester.getOrCreate(topKey).addDependency(aKey).addDependency(cKey);
+    tester.getOrCreate(aKey).addDependency(bKey);
+    tester.getOrCreate(bKey).addDependency(aKey);
+    tester.getOrCreate(cKey).addDependency(dKey);
+    tester.getOrCreate(dKey).addDependency(cKey);
+    EvaluationResult<StringValue> result = eval(true, ImmutableList.of(topKey));
+    assertEquals(null, result.get(topKey));
+    ErrorInfo errorInfo = result.getError(topKey);
+    CycleInfo aCycle = new CycleInfo(ImmutableList.of(topKey), ImmutableList.of(aKey, bKey));
+    CycleInfo cCycle = new CycleInfo(ImmutableList.of(topKey), ImmutableList.of(cKey, dKey));
+    assertThat(errorInfo.getCycleInfo()).containsExactly(aCycle, cCycle);
+  }
+
+  @Test
+  public void triangleBelowHeadCycle() throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey aKey = GraphTester.toSkyKey("a");
+    SkyKey bKey = GraphTester.toSkyKey("b");
+    SkyKey cKey = GraphTester.toSkyKey("c");
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    tester.getOrCreate(topKey).addDependency(aKey);
+    tester.getOrCreate(aKey).addDependency(bKey).addDependency(cKey);
+    tester.getOrCreate(bKey).addDependency(cKey);
+    tester.getOrCreate(cKey).addDependency(topKey);
+    EvaluationResult<StringValue> result = eval(true, ImmutableList.of(topKey));
+    assertEquals(null, result.get(topKey));
+    ErrorInfo errorInfo = result.getError(topKey);
+    CycleInfo topCycle = new CycleInfo(ImmutableList.of(topKey, aKey, cKey));
+    assertThat(errorInfo.getCycleInfo()).containsExactly(topCycle);
+  }
+
+  @Test
+  public void longCycle() throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey aKey = GraphTester.toSkyKey("a");
+    SkyKey bKey = GraphTester.toSkyKey("b");
+    SkyKey cKey = GraphTester.toSkyKey("c");
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    tester.getOrCreate(topKey).addDependency(aKey);
+    tester.getOrCreate(aKey).addDependency(bKey);
+    tester.getOrCreate(bKey).addDependency(cKey);
+    tester.getOrCreate(cKey).addDependency(topKey);
+    EvaluationResult<StringValue> result = eval(true, ImmutableList.of(topKey));
+    assertEquals(null, result.get(topKey));
+    ErrorInfo errorInfo = result.getError(topKey);
+    CycleInfo topCycle = new CycleInfo(ImmutableList.of(topKey, aKey, bKey, cKey));
+    assertThat(errorInfo.getCycleInfo()).containsExactly(topCycle);
+  }
+
+  @Test
+  public void cycleWithTail() throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey aKey = GraphTester.toSkyKey("a");
+    SkyKey bKey = GraphTester.toSkyKey("b");
+    SkyKey cKey = GraphTester.toSkyKey("c");
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    tester.getOrCreate(topKey).addDependency(aKey).addDependency(cKey);
+    tester.getOrCreate(aKey).addDependency(bKey);
+    tester.getOrCreate(bKey).addDependency(aKey).addDependency(cKey);
+    tester.getOrCreate(cKey);
+    tester.set(cKey, new StringValue("cValue"));
+    EvaluationResult<StringValue> result = eval(false, ImmutableList.of(topKey));
+    assertEquals(null, result.get(topKey));
+    ErrorInfo errorInfo = result.getError(topKey);
+    CycleInfo cycleInfo = Iterables.getOnlyElement(errorInfo.getCycleInfo());
+    assertThat(cycleInfo.getCycle()).containsExactly(aKey, bKey).inOrder();
+    assertThat(cycleInfo.getPathToCycle()).containsExactly(topKey).inOrder();
+  }
+
+  /** Regression test: "value cannot be ready in a cycle". */
+  @Test
+  public void selfEdgeWithExtraChildrenUnderCycle() throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey aKey = GraphTester.toSkyKey("a");
+    SkyKey bKey = GraphTester.toSkyKey("b");
+    SkyKey cKey = GraphTester.toSkyKey("c");
+    tester.getOrCreate(aKey).addDependency(bKey);
+    tester.getOrCreate(bKey).addDependency(cKey).addDependency(bKey);
+    tester.getOrCreate(cKey).addDependency(aKey);
+    EvaluationResult<StringValue> result = eval(/*keepGoing=*/true, ImmutableList.of(aKey));
+    assertEquals(null, result.get(aKey));
+    ErrorInfo errorInfo = result.getError(aKey);
+    CycleInfo cycleInfo = Iterables.getOnlyElement(errorInfo.getCycleInfo());
+    assertThat(cycleInfo.getCycle()).containsExactly(bKey).inOrder();
+    assertThat(cycleInfo.getPathToCycle()).containsExactly(aKey).inOrder();
+  }
+
+  /** Regression test: "value cannot be ready in a cycle". */
+  @Test
+  public void cycleWithExtraChildrenUnderCycle() throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey aKey = GraphTester.toSkyKey("a");
+    SkyKey bKey = GraphTester.toSkyKey("b");
+    SkyKey cKey = GraphTester.toSkyKey("c");
+    SkyKey dKey = GraphTester.toSkyKey("d");
+    tester.getOrCreate(aKey).addDependency(bKey);
+    tester.getOrCreate(bKey).addDependency(cKey).addDependency(dKey);
+    tester.getOrCreate(cKey).addDependency(aKey);
+    tester.getOrCreate(dKey).addDependency(bKey);
+    EvaluationResult<StringValue> result = eval(/*keepGoing=*/true, ImmutableList.of(aKey));
+    assertEquals(null, result.get(aKey));
+    ErrorInfo errorInfo = result.getError(aKey);
+    CycleInfo cycleInfo = Iterables.getOnlyElement(errorInfo.getCycleInfo());
+    assertThat(cycleInfo.getCycle()).containsExactly(bKey, dKey).inOrder();
+    assertThat(cycleInfo.getPathToCycle()).containsExactly(aKey).inOrder();
+  }
+
+  /** Regression test: "value cannot be ready in a cycle". */
+  @Test
+  public void cycleAboveIndependentCycle() throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey aKey = GraphTester.toSkyKey("a");
+    SkyKey bKey = GraphTester.toSkyKey("b");
+    SkyKey cKey = GraphTester.toSkyKey("c");
+    tester.getOrCreate(aKey).addDependency(bKey);
+    tester.getOrCreate(bKey).addDependency(cKey);
+    tester.getOrCreate(cKey).addDependency(aKey).addDependency(bKey);
+    EvaluationResult<StringValue> result = eval(/*keepGoing=*/true, ImmutableList.of(aKey));
+    assertEquals(null, result.get(aKey));
+    assertThat(result.getError(aKey).getCycleInfo()).containsExactly(
+        new CycleInfo(ImmutableList.of(aKey, bKey, cKey)),
+        new CycleInfo(ImmutableList.of(aKey), ImmutableList.of(bKey, cKey)));
+  }
+
+  public void valueAboveCycleAndExceptionReportsException() throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey aKey = GraphTester.toSkyKey("a");
+    SkyKey errorKey = GraphTester.toSkyKey("error");
+    SkyKey bKey = GraphTester.toSkyKey("b");
+    tester.getOrCreate(aKey).addDependency(bKey).addDependency(errorKey);
+    tester.getOrCreate(bKey).addDependency(bKey);
+    tester.getOrCreate(errorKey).setHasError(true);
+    EvaluationResult<StringValue> result = eval(/*keepGoing=*/true, ImmutableList.of(aKey));
+    assertEquals(null, result.get(aKey));
+    assertNotNull(result.getError(aKey).getException());
+    CycleInfo cycleInfo = Iterables.getOnlyElement(result.getError(aKey).getCycleInfo());
+    assertThat(cycleInfo.getCycle()).containsExactly(bKey).inOrder();
+    assertThat(cycleInfo.getPathToCycle()).containsExactly(aKey).inOrder();
+  }
+
+  @Test
+  public void errorValueStored() throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey errorKey = GraphTester.toSkyKey("my_error_value");
+    tester.getOrCreate(errorKey).setHasError(true);
+    EvaluationResult<StringValue> result = eval(false, ImmutableList.of(errorKey));
+    assertThat(result.keyNames()).isEmpty();
+    assertThat(result.errorMap().keySet()).containsExactly(errorKey);
+    ErrorInfo errorInfo = result.getError();
+    assertThat(errorInfo.getRootCauses()).containsExactly(errorKey);
+    // Update value. But builder won't rebuild it.
+    tester.getOrCreate(errorKey).setHasError(false);
+    tester.set(errorKey, new StringValue("no error?"));
+    result = eval(false, ImmutableList.of(errorKey));
+    assertThat(result.keyNames()).isEmpty();
+    assertThat(result.errorMap().keySet()).containsExactly(errorKey);
+    errorInfo = result.getError();
+    assertThat(errorInfo.getRootCauses()).containsExactly(errorKey);
+  }
+
+  /**
+   * Regression test: "OOM in Skyframe cycle detection".
+   * We only store the first 20 cycles found below any given root value.
+   */
+  @Test
+  public void manyCycles() throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    for (int i = 0; i < 100; i++) {
+      SkyKey dep = GraphTester.toSkyKey(Integer.toString(i));
+      tester.getOrCreate(topKey).addDependency(dep);
+      tester.getOrCreate(dep).addDependency(dep);
+    }
+    EvaluationResult<StringValue> result = eval(/*keepGoing=*/true, ImmutableList.of(topKey));
+    assertEquals(null, result.get(topKey));
+    assertManyCycles(result.getError(topKey), topKey, /*selfEdge=*/false);
+  }
+
+  /**
+   * Regression test: "OOM in Skyframe cycle detection".
+   * We filter out multiple paths to a cycle that go through the same child value.
+   */
+  @Test
+  public void manyPathsToCycle() throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    SkyKey midKey = GraphTester.toSkyKey("mid");
+    SkyKey cycleKey = GraphTester.toSkyKey("cycle");
+    tester.getOrCreate(topKey).addDependency(midKey);
+    tester.getOrCreate(cycleKey).addDependency(cycleKey);
+    for (int i = 0; i < 100; i++) {
+      SkyKey dep = GraphTester.toSkyKey(Integer.toString(i));
+      tester.getOrCreate(midKey).addDependency(dep);
+      tester.getOrCreate(dep).addDependency(cycleKey);
+    }
+    EvaluationResult<StringValue> result = eval(/*keepGoing=*/true, ImmutableList.of(topKey));
+    assertEquals(null, result.get(topKey));
+    CycleInfo cycleInfo = Iterables.getOnlyElement(result.getError(topKey).getCycleInfo());
+    assertEquals(1, cycleInfo.getCycle().size());
+    assertEquals(3, cycleInfo.getPathToCycle().size());
+    assertThat(cycleInfo.getPathToCycle().subList(0, 2)).containsExactly(topKey, midKey).inOrder();
+  }
+
+  /**
+   * Checks that errorInfo has many self-edge cycles, and that one of them is a self-edge of
+   * topKey, if {@code selfEdge} is true.
+   */
+  private static void assertManyCycles(ErrorInfo errorInfo, SkyKey topKey, boolean selfEdge) {
+    MoreAsserts.assertGreaterThan(1, Iterables.size(errorInfo.getCycleInfo()));
+    MoreAsserts.assertLessThan(50, Iterables.size(errorInfo.getCycleInfo()));
+    boolean foundSelfEdge = false;
+    for (CycleInfo cycle : errorInfo.getCycleInfo()) {
+      assertEquals(1, cycle.getCycle().size()); // Self-edge.
+      if (!Iterables.isEmpty(cycle.getPathToCycle())) {
+        assertThat(cycle.getPathToCycle()).containsExactly(topKey).inOrder();
+      } else {
+        assertThat(cycle.getCycle()).containsExactly(topKey).inOrder();
+        foundSelfEdge = true;
+      }
+    }
+    assertEquals(errorInfo + ", " + topKey, selfEdge, foundSelfEdge);
+  }
+
+  @Test
+  public void manyUnprocessedValuesInCycle() throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey lastSelfKey = GraphTester.toSkyKey("lastSelf");
+    SkyKey firstSelfKey = GraphTester.toSkyKey("firstSelf");
+    SkyKey midSelfKey = GraphTester.toSkyKey("midSelf");
+    // We add firstSelf first so that it is processed last in cycle detection (LIFO), meaning that
+    // none of the dep values have to be cleared from firstSelf.
+    tester.getOrCreate(firstSelfKey).addDependency(firstSelfKey);
+    for (int i = 0; i < 100; i++) {
+      SkyKey firstDep = GraphTester.toSkyKey("first" + i);
+      SkyKey midDep = GraphTester.toSkyKey("mid" + i);
+      SkyKey lastDep = GraphTester.toSkyKey("last" + i);
+      tester.getOrCreate(firstSelfKey).addDependency(firstDep);
+      tester.getOrCreate(midSelfKey).addDependency(midDep);
+      tester.getOrCreate(lastSelfKey).addDependency(lastDep);
+      if (i == 90) {
+        // Most of the deps will be cleared from midSelf.
+        tester.getOrCreate(midSelfKey).addDependency(midSelfKey);
+      }
+      tester.getOrCreate(firstDep).addDependency(firstDep);
+      tester.getOrCreate(midDep).addDependency(midDep);
+      tester.getOrCreate(lastDep).addDependency(lastDep);
+    }
+    // All the deps will be cleared from lastSelf.
+    tester.getOrCreate(lastSelfKey).addDependency(lastSelfKey);
+    EvaluationResult<StringValue> result = eval(/*keepGoing=*/true,
+        ImmutableList.of(lastSelfKey, firstSelfKey, midSelfKey));
+    assertWithMessage(result.toString()).that(result.keyNames()).isEmpty();
+    assertThat(result.errorMap().keySet()).containsExactly(lastSelfKey, firstSelfKey, midSelfKey);
+
+    // Check lastSelfKey.
+    ErrorInfo errorInfo = result.getError(lastSelfKey);
+    assertEquals(errorInfo.toString(), 1, Iterables.size(errorInfo.getCycleInfo()));
+    CycleInfo cycleInfo = Iterables.getOnlyElement(errorInfo.getCycleInfo());
+    assertThat(cycleInfo.getCycle()).containsExactly(lastSelfKey);
+    assertThat(cycleInfo.getPathToCycle()).isEmpty();
+
+    // Check firstSelfKey. It should not have discovered its own self-edge, because there were too
+    // many other values before it in the queue.
+    assertManyCycles(result.getError(firstSelfKey), firstSelfKey, /*selfEdge=*/false);
+
+    // Check midSelfKey. It should have discovered its own self-edge.
+    assertManyCycles(result.getError(midSelfKey), midSelfKey, /*selfEdge=*/true);
+  }
+
+  @Test
+  public void errorValueStoredWithKeepGoing() throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey errorKey = GraphTester.toSkyKey("my_error_value");
+    tester.getOrCreate(errorKey).setHasError(true);
+    EvaluationResult<StringValue> result = eval(true, ImmutableList.of(errorKey));
+    assertThat(result.keyNames()).isEmpty();
+    assertThat(result.errorMap().keySet()).containsExactly(errorKey);
+    ErrorInfo errorInfo = result.getError();
+    assertThat(errorInfo.getRootCauses()).containsExactly(errorKey);
+    // Update value. But builder won't rebuild it.
+    tester.getOrCreate(errorKey).setHasError(false);
+    tester.set(errorKey, new StringValue("no error?"));
+    result = eval(true, ImmutableList.of(errorKey));
+    assertThat(result.keyNames()).isEmpty();
+    assertThat(result.errorMap().keySet()).containsExactly(errorKey);
+    errorInfo = result.getError();
+    assertThat(errorInfo.getRootCauses()).containsExactly(errorKey);
+  }
+
+  @Test
+  public void continueWithErrorDep() throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey errorKey = GraphTester.toSkyKey("my_error_value");
+    tester.getOrCreate(errorKey).setHasError(true);
+    tester.set("after", new StringValue("after"));
+    SkyKey parentKey = GraphTester.toSkyKey("parent");
+    tester.getOrCreate(parentKey).addErrorDependency(errorKey, new StringValue("recovered"))
+        .setComputedValue(CONCATENATE).addDependency("after");
+    EvaluationResult<StringValue> result = eval(/*keepGoing=*/true, ImmutableList.of(parentKey));
+    assertThat(result.errorMap()).isEmpty();
+    assertEquals("recoveredafter", result.get(parentKey).getValue());
+    result = eval(/*keepGoing=*/false, ImmutableList.of(parentKey));
+    assertThat(result.keyNames()).isEmpty();
+    Map.Entry<SkyKey, ErrorInfo> error = Iterables.getOnlyElement(result.errorMap().entrySet());
+    assertEquals(parentKey, error.getKey());
+    assertThat(error.getValue().getRootCauses()).containsExactly(errorKey);
+  }
+
+  @Test
+  public void breakWithErrorDep() throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey errorKey = GraphTester.toSkyKey("my_error_value");
+    tester.getOrCreate(errorKey).setHasError(true);
+    tester.set("after", new StringValue("after"));
+    SkyKey parentKey = GraphTester.toSkyKey("parent");
+    tester.getOrCreate(parentKey).addErrorDependency(errorKey, new StringValue("recovered"))
+        .setComputedValue(CONCATENATE).addDependency("after");
+    EvaluationResult<StringValue> result = eval(/*keepGoing=*/false, ImmutableList.of(parentKey));
+    assertThat(result.keyNames()).isEmpty();
+    Map.Entry<SkyKey, ErrorInfo> error = Iterables.getOnlyElement(result.errorMap().entrySet());
+    assertEquals(parentKey, error.getKey());
+    assertThat(error.getValue().getRootCauses()).containsExactly(errorKey);
+    result = eval(/*keepGoing=*/true, ImmutableList.of(parentKey));
+    assertThat(result.errorMap()).isEmpty();
+    assertEquals("recoveredafter", result.get(parentKey).getValue());
+  }
+
+  @Test
+  public void breakWithInterruptibleErrorDep() throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey errorKey = GraphTester.toSkyKey("my_error_value");
+    tester.getOrCreate(errorKey).setHasError(true);
+    SkyKey parentKey = GraphTester.toSkyKey("parent");
+    tester.getOrCreate(parentKey).addErrorDependency(errorKey, new StringValue("recovered"))
+        .setComputedValue(CONCATENATE);
+    // When the error value throws, the propagation will cause an interrupted exception in parent.
+    EvaluationResult<StringValue> result = eval(/*keepGoing=*/false, ImmutableList.of(parentKey));
+    assertThat(result.keyNames()).isEmpty();
+    Map.Entry<SkyKey, ErrorInfo> error = Iterables.getOnlyElement(result.errorMap().entrySet());
+    assertEquals(parentKey, error.getKey());
+    assertThat(error.getValue().getRootCauses()).containsExactly(errorKey);
+    assertFalse(Thread.interrupted());
+    result = eval(/*keepGoing=*/true, ImmutableList.of(parentKey));
+    assertThat(result.errorMap()).isEmpty();
+    assertEquals("recovered", result.get(parentKey).getValue());
+  }
+
+  @Test
+  public void transformErrorDep() throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey errorKey = GraphTester.toSkyKey("my_error_value");
+    tester.getOrCreate(errorKey).setHasError(true);
+    SkyKey parentErrorKey = GraphTester.toSkyKey("parent");
+    tester.getOrCreate(parentErrorKey).addErrorDependency(errorKey, new StringValue("recovered"))
+        .setHasError(true);
+    EvaluationResult<StringValue> result = eval(
+        /*keepGoing=*/false, ImmutableList.of(parentErrorKey));
+    assertThat(result.keyNames()).isEmpty();
+    Map.Entry<SkyKey, ErrorInfo> error = Iterables.getOnlyElement(result.errorMap().entrySet());
+    assertEquals(parentErrorKey, error.getKey());
+    assertThat(error.getValue().getRootCauses()).containsExactly(parentErrorKey);
+  }
+
+  @Test
+  public void transformErrorDepKeepGoing() throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey errorKey = GraphTester.toSkyKey("my_error_value");
+    tester.getOrCreate(errorKey).setHasError(true);
+    SkyKey parentErrorKey = GraphTester.toSkyKey("parent");
+    tester.getOrCreate(parentErrorKey).addErrorDependency(errorKey, new StringValue("recovered"))
+        .setHasError(true);
+    EvaluationResult<StringValue> result = eval(
+        /*keepGoing=*/true, ImmutableList.of(parentErrorKey));
+    assertThat(result.keyNames()).isEmpty();
+    Map.Entry<SkyKey, ErrorInfo> error = Iterables.getOnlyElement(result.errorMap().entrySet());
+    assertEquals(parentErrorKey, error.getKey());
+    assertThat(error.getValue().getRootCauses()).containsExactly(parentErrorKey);
+  }
+
+  @Test
+  public void transformErrorDepOneLevelDownKeepGoing() throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey errorKey = GraphTester.toSkyKey("my_error_value");
+    tester.getOrCreate(errorKey).setHasError(true);
+    tester.set("after", new StringValue("after"));
+    SkyKey parentErrorKey = GraphTester.toSkyKey("parent");
+    tester.getOrCreate(parentErrorKey).addErrorDependency(errorKey, new StringValue("recovered"));
+    tester.set(parentErrorKey, new StringValue("parent value"));
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    tester.getOrCreate(topKey).addDependency(parentErrorKey).addDependency("after")
+        .setComputedValue(CONCATENATE);
+    EvaluationResult<StringValue> result = eval(/*keepGoing=*/true, ImmutableList.of(topKey));
+    assertThat(ImmutableList.<String>copyOf(result.<String>keyNames())).containsExactly("top");
+    assertEquals("parent valueafter", result.get(topKey).getValue());
+    assertThat(result.errorMap()).isEmpty();
+  }
+
+  @Test
+  public void transformErrorDepOneLevelDownNoKeepGoing() throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey errorKey = GraphTester.toSkyKey("my_error_value");
+    tester.getOrCreate(errorKey).setHasError(true);
+    tester.set("after", new StringValue("after"));
+    SkyKey parentErrorKey = GraphTester.toSkyKey("parent");
+    tester.getOrCreate(parentErrorKey).addErrorDependency(errorKey, new StringValue("recovered"));
+    tester.set(parentErrorKey, new StringValue("parent value"));
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    tester.getOrCreate(topKey).addDependency(parentErrorKey).addDependency("after")
+        .setComputedValue(CONCATENATE);
+    EvaluationResult<StringValue> result = eval(/*keepGoing=*/false, ImmutableList.of(topKey));
+    assertThat(result.keyNames()).isEmpty();
+    Map.Entry<SkyKey, ErrorInfo> error = Iterables.getOnlyElement(result.errorMap().entrySet());
+    assertEquals(topKey, error.getKey());
+    assertThat(error.getValue().getRootCauses()).containsExactly(errorKey);
+  }
+
+  /**
+   * Make sure that multiple unfinished children can be cleared from a cycle value.
+   */
+  @Test
+  public void cycleWithMultipleUnfinishedChildren() throws Exception {
+    graph = new InMemoryGraph();
+    tester = new GraphTester();
+    SkyKey cycleKey = GraphTester.toSkyKey("cycle");
+    SkyKey midKey = GraphTester.toSkyKey("mid");
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    SkyKey selfEdge1 = GraphTester.toSkyKey("selfEdge1");
+    SkyKey selfEdge2 = GraphTester.toSkyKey("selfEdge2");
+    tester.getOrCreate(topKey).addDependency(midKey).setComputedValue(CONCATENATE);
+    // selfEdge* come before cycleKey, so cycleKey's path will be checked first (LIFO), and the
+    // cycle with mid will be detected before the selfEdge* cycles are.
+    tester.getOrCreate(midKey).addDependency(selfEdge1).addDependency(selfEdge2)
+        .addDependency(cycleKey)
+    .setComputedValue(CONCATENATE);
+    tester.getOrCreate(cycleKey).addDependency(midKey);
+    tester.getOrCreate(selfEdge1).addDependency(selfEdge1);
+    tester.getOrCreate(selfEdge2).addDependency(selfEdge2);
+    EvaluationResult<StringValue> result = eval(/*keepGoing=*/true, ImmutableSet.of(topKey));
+    assertThat(result.errorMap().keySet()).containsExactly(topKey);
+    Iterable<CycleInfo> cycleInfos = result.getError(topKey).getCycleInfo();
+    CycleInfo cycleInfo = Iterables.getOnlyElement(cycleInfos);
+    assertThat(cycleInfo.getPathToCycle()).containsExactly(topKey);
+    assertThat(cycleInfo.getCycle()).containsExactly(midKey, cycleKey);
+  }
+
+  /**
+   * Regression test: "value in cycle depends on error".
+   * The mid value will have two parents -- top and cycle. Error bubbles up from mid to cycle, and
+   * we should detect cycle.
+   */
+  private void cycleAndErrorInBubbleUp(boolean keepGoing) throws Exception {
+    graph = new DeterministicInMemoryGraph();
+    tester = new GraphTester();
+    SkyKey errorKey = GraphTester.toSkyKey("error");
+    SkyKey cycleKey = GraphTester.toSkyKey("cycle");
+    SkyKey midKey = GraphTester.toSkyKey("mid");
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    tester.getOrCreate(topKey).addDependency(midKey).setComputedValue(CONCATENATE);
+    tester.getOrCreate(midKey).addDependency(errorKey).addDependency(cycleKey)
+        .setComputedValue(CONCATENATE);
+
+    // We need to ensure that cycle value has finished his work, and we have recorded dependencies
+    CountDownLatch cycleFinish = new CountDownLatch(1);
+    tester.getOrCreate(cycleKey).setBuilder(new ChainedFunction(null,
+        null, cycleFinish, false, new StringValue(""), ImmutableSet.<SkyKey>of(midKey)));
+    tester.getOrCreate(errorKey).setBuilder(new ChainedFunction(null, cycleFinish,
+        null, /*waitForException=*/false, null, ImmutableSet.<SkyKey>of()));
+
+    EvaluationResult<StringValue> result = eval(keepGoing, ImmutableSet.of(topKey));
+    assertThat(result.errorMap().keySet()).containsExactly(topKey);
+    Iterable<CycleInfo> cycleInfos = result.getError(topKey).getCycleInfo();
+    if (keepGoing) {
+      // The error thrown will only be recorded in keep_going mode.
+      assertThat(result.getError().getRootCauses()).containsExactly(errorKey);
+    }
+    assertThat(cycleInfos).isNotEmpty();
+    CycleInfo cycleInfo = Iterables.getOnlyElement(cycleInfos);
+    assertThat(cycleInfo.getPathToCycle()).containsExactly(topKey);
+    assertThat(cycleInfo.getCycle()).containsExactly(midKey, cycleKey);
+  }
+
+  @Test
+  public void cycleAndErrorInBubbleUpNoKeepGoing() throws Exception {
+    cycleAndErrorInBubbleUp(false);
+  }
+
+  @Test
+  public void cycleAndErrorInBubbleUpKeepGoing() throws Exception {
+    cycleAndErrorInBubbleUp(true);
+  }
+
+  /**
+   * Regression test: "value in cycle depends on error".
+   * We add another value that won't finish building before the threadpool shuts down, to check that
+   * the cycle detection can handle unfinished values.
+   */
+  @Test
+  public void cycleAndErrorAndOtherInBubbleUp() throws Exception {
+    graph = new DeterministicInMemoryGraph();
+    tester = new GraphTester();
+    SkyKey errorKey = GraphTester.toSkyKey("error");
+    SkyKey cycleKey = GraphTester.toSkyKey("cycle");
+    SkyKey midKey = GraphTester.toSkyKey("mid");
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    tester.getOrCreate(topKey).addDependency(midKey).setComputedValue(CONCATENATE);
+    // We should add cycleKey first and errorKey afterwards. Otherwise there is a chance that
+    // during error propagation cycleKey will not be processed, and we will not detect the cycle.
+    tester.getOrCreate(midKey).addDependency(errorKey).addDependency(cycleKey)
+        .setComputedValue(CONCATENATE);
+    SkyKey otherTop = GraphTester.toSkyKey("otherTop");
+    CountDownLatch topStartAndCycleFinish = new CountDownLatch(2);
+    // In nokeep_going mode, otherTop will wait until the threadpool has received an exception,
+    // then request its own dep. This guarantees that there is a value that is not finished when
+    // cycle detection happens.
+    tester.getOrCreate(otherTop).setBuilder(new ChainedFunction(topStartAndCycleFinish,
+        new CountDownLatch(0), null, /*waitForException=*/true, new StringValue("never returned"),
+        ImmutableSet.<SkyKey>of(GraphTester.toSkyKey("dep that never builds"))));
+
+    tester.getOrCreate(cycleKey).setBuilder(new ChainedFunction(null, null,
+        topStartAndCycleFinish, /*waitForException=*/false, new StringValue(""),
+        ImmutableSet.<SkyKey>of(midKey)));
+    // error waits until otherTop starts and cycle finishes, to make sure otherTop will request
+    // its dep before the threadpool shuts down.
+    tester.getOrCreate(errorKey).setBuilder(new ChainedFunction(null, topStartAndCycleFinish,
+        null, /*waitForException=*/false, null,
+        ImmutableSet.<SkyKey>of()));
+    EvaluationResult<StringValue> result =
+        eval(/*keepGoing=*/false, ImmutableSet.of(topKey, otherTop));
+    assertThat(result.errorMap().keySet()).containsExactly(topKey);
+    Iterable<CycleInfo> cycleInfos = result.getError(topKey).getCycleInfo();
+    assertThat(cycleInfos).isNotEmpty();
+    CycleInfo cycleInfo = Iterables.getOnlyElement(cycleInfos);
+    assertThat(cycleInfo.getPathToCycle()).containsExactly(topKey);
+    assertThat(cycleInfo.getCycle()).containsExactly(midKey, cycleKey);
+  }
+
+  /**
+   * Regression test: "value in cycle depends on error".
+   * Here, we add an additional top-level key in error, just to mix it up.
+   */
+  private void cycleAndErrorAndError(boolean keepGoing) throws Exception {
+    graph = new DeterministicInMemoryGraph();
+    tester = new GraphTester();
+    SkyKey errorKey = GraphTester.toSkyKey("error");
+    SkyKey cycleKey = GraphTester.toSkyKey("cycle");
+    SkyKey midKey = GraphTester.toSkyKey("mid");
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    tester.getOrCreate(topKey).addDependency(midKey).setComputedValue(CONCATENATE);
+    tester.getOrCreate(midKey).addDependency(errorKey).addDependency(cycleKey)
+        .setComputedValue(CONCATENATE);
+    SkyKey otherTop = GraphTester.toSkyKey("otherTop");
+    CountDownLatch topStartAndCycleFinish = new CountDownLatch(2);
+    // In nokeep_going mode, otherTop will wait until the threadpool has received an exception,
+    // then throw its own exception. This guarantees that its exception will not be the one
+    // bubbling up, but that there is a top-level value with an exception by the time the bubbling
+    // up starts.
+    tester.getOrCreate(otherTop).setBuilder(new ChainedFunction(topStartAndCycleFinish,
+        new CountDownLatch(0), null, /*waitForException=*/!keepGoing, null,
+        ImmutableSet.<SkyKey>of()));
+    // error waits until otherTop starts and cycle finishes, to make sure otherTop will request
+    // its dep before the threadpool shuts down.
+    tester.getOrCreate(errorKey).setBuilder(new ChainedFunction(null, topStartAndCycleFinish,
+        null, /*waitForException=*/false, null,
+        ImmutableSet.<SkyKey>of()));
+    tester.getOrCreate(cycleKey).setBuilder(new ChainedFunction(null, null,
+        topStartAndCycleFinish, /*waitForException=*/false, new StringValue(""),
+        ImmutableSet.<SkyKey>of(midKey)));
+    EvaluationResult<StringValue> result =
+        eval(keepGoing, ImmutableSet.of(topKey, otherTop));
+    if (keepGoing) {
+      assertThat(result.errorMap().keySet()).containsExactly(otherTop, topKey);
+      assertThat(result.getError(otherTop).getRootCauses()).containsExactly(otherTop);
+      // The error thrown will only be recorded in keep_going mode.
+      assertThat(result.getError(topKey).getRootCauses()).containsExactly(errorKey);
+    }
+    Iterable<CycleInfo> cycleInfos = result.getError(topKey).getCycleInfo();
+    assertThat(cycleInfos).isNotEmpty();
+    CycleInfo cycleInfo = Iterables.getOnlyElement(cycleInfos);
+    assertThat(cycleInfo.getPathToCycle()).containsExactly(topKey);
+    assertThat(cycleInfo.getCycle()).containsExactly(midKey, cycleKey);
+  }
+
+  @Test
+  public void cycleAndErrorAndErrorNoKeepGoing() throws Exception {
+    cycleAndErrorAndError(false);
+  }
+
+  @Test
+  public void cycleAndErrorAndErrorKeepGoing() throws Exception {
+    cycleAndErrorAndError(true);
+  }
+
+  @Test
+  public void testFunctionCrashTrace() throws Exception {
+    final SkyFunctionName childType = new SkyFunctionName("child", false);
+    final SkyFunctionName parentType = new SkyFunctionName("parent", false);
+
+    class ChildFunction implements SkyFunction {
+      @Override
+      public SkyValue compute(SkyKey skyKey, Environment env) {
+        throw new IllegalStateException("I WANT A PONY!!!");
+      }
+
+      @Override public String extractTag(SkyKey skyKey) { return null; }
+    }
+
+    class ParentFunction implements SkyFunction {
+      @Override
+      public SkyValue compute(SkyKey skyKey, Environment env) {
+        SkyValue dep = env.getValue(new SkyKey(childType, "billy the kid"));
+        if (dep == null) {
+          return null;
+        }
+        throw new IllegalStateException();  // Should never get here.
+      }
+
+      @Override public String extractTag(SkyKey skyKey) { return null; }
+    }
+
+    ImmutableMap<SkyFunctionName, SkyFunction> skyFunctions = ImmutableMap.of(
+        childType, new ChildFunction(),
+        parentType, new ParentFunction());
+    ParallelEvaluator evaluator = makeEvaluator(new InMemoryGraph(),
+        skyFunctions, false);
+
+    try {
+      evaluator.eval(ImmutableList.of(new SkyKey(parentType, "octodad")));
+      fail();
+    } catch (RuntimeException e) {
+      assertEquals("I WANT A PONY!!!", e.getCause().getMessage());
+      assertEquals("Unrecoverable error while evaluating node 'child:billy the kid' "
+          + "(requested by nodes 'parent:octodad')", e.getMessage());
+    }
+  }
+
+  private static class SomeOtherErrorException extends Exception {
+    public SomeOtherErrorException(String msg) {
+      super(msg);
+    }
+  }
+
+  private void unexpectedErrorDep(boolean keepGoing) throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey errorKey = GraphTester.toSkyKey("my_error_value");
+    final SomeOtherErrorException exception = new SomeOtherErrorException("error exception");
+    tester.getOrCreate(errorKey).setBuilder(new SkyFunction() {
+      @Override
+      public SkyValue compute(SkyKey skyKey, Environment env) throws SkyFunctionException {
+        throw new SkyFunctionException(exception, Transience.PERSISTENT) {};
+      }
+
+      @Override
+      public String extractTag(SkyKey skyKey) {
+        throw new UnsupportedOperationException();
+      }
+    });
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    tester.getOrCreate(topKey).addErrorDependency(errorKey, new StringValue("recovered"))
+        .setComputedValue(CONCATENATE);
+    EvaluationResult<StringValue> result = eval(keepGoing, ImmutableList.of(topKey));
+    assertThat(result.keyNames()).isEmpty();
+    assertSame(exception, result.getError(topKey).getException());
+    assertThat(result.getError(topKey).getRootCauses()).containsExactly(errorKey);
+  }
+
+  /**
+   * This and the following three tests are in response a bug: "Skyframe error propagation model is
+   * problematic". They ensure that exceptions a child throws that a value does not specify it can
+   * handle in getValueOrThrow do not cause a crash.
+   */
+  @Test
+  public void unexpectedErrorDepKeepGoing() throws Exception {
+    unexpectedErrorDep(true);
+  }
+
+  @Test
+  public void unexpectedErrorDepNoKeepGoing() throws Exception {
+    unexpectedErrorDep(false);
+  }
+
+  private void unexpectedErrorDepOneLevelDown(final boolean keepGoing) throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey errorKey = GraphTester.toSkyKey("my_error_value");
+    final SomeErrorException exception = new SomeErrorException("error exception");
+    final SomeErrorException topException = new SomeErrorException("top exception");
+    final StringValue topValue = new StringValue("top");
+    tester.getOrCreate(errorKey).setBuilder(new SkyFunction() {
+      @Override
+      public SkyValue compute(SkyKey skyKey, Environment env) throws GenericFunctionException {
+        throw new GenericFunctionException(exception, Transience.PERSISTENT);
+      }
+
+      @Override
+      public String extractTag(SkyKey skyKey) {
+        throw new UnsupportedOperationException();
+      }
+    });
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    final SkyKey parentKey = GraphTester.toSkyKey("parent");
+    tester.getOrCreate(parentKey).addDependency(errorKey).setComputedValue(CONCATENATE);
+    tester.getOrCreate(topKey).setBuilder(new SkyFunction() {
+      @Override
+      public SkyValue compute(SkyKey skyKey, Environment env) throws GenericFunctionException {
+        try {
+          if (env.getValueOrThrow(parentKey, SomeErrorException.class) == null) {
+            return null;
+          }
+        } catch (SomeErrorException e) {
+          assertEquals(e.toString(), exception, e);
+        }
+        if (keepGoing) {
+          return topValue;
+        } else {
+          throw new GenericFunctionException(topException, Transience.PERSISTENT);
+        }
+      }
+      @Override
+      public String extractTag(SkyKey skyKey) {
+        throw new UnsupportedOperationException();
+      }
+    });
+    tester.getOrCreate(topKey).addErrorDependency(errorKey, new StringValue("recovered"))
+        .setComputedValue(CONCATENATE);
+    EvaluationResult<StringValue> result = eval(keepGoing, ImmutableList.of(topKey));
+    if (!keepGoing) {
+      assertThat(result.keyNames()).isEmpty();
+      assertEquals(topException, result.getError(topKey).getException());
+      assertThat(result.getError(topKey).getRootCauses()).containsExactly(topKey);
+      assertTrue(result.hasError());
+    } else {
+      // result.hasError() is set to true even if the top-level value returned has recovered from
+      // an error.
+      assertTrue(result.hasError());
+      assertSame(topValue, result.get(topKey));
+    }
+  }
+
+  @Test
+  public void unexpectedErrorDepOneLevelDownKeepGoing() throws Exception {
+    unexpectedErrorDepOneLevelDown(true);
+  }
+
+  @Test
+  public void unexpectedErrorDepOneLevelDownNoKeepGoing() throws Exception {
+    unexpectedErrorDepOneLevelDown(false);
+  }
+
+  /**
+   * Exercises various situations involving groups of deps that overlap -- request one group, then
+   * request another group that has a dep in common with the first group.
+   *
+   * @param sameFirst whether the dep in common in the two groups should be the first dep.
+   * @param twoCalls whether the two groups should be requested in two different builder calls.
+   * @param valuesOrThrow whether the deps should be requested using getValuesOrThrow.
+   */
+  private void sameDepInTwoGroups(final boolean sameFirst, final boolean twoCalls,
+      final boolean valuesOrThrow) throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey topKey = GraphTester.toSkyKey("top");
+    final List<SkyKey> leaves = new ArrayList<>();
+    for (int i = 1; i <= 3; i++) {
+      SkyKey leaf = GraphTester.toSkyKey("leaf" + i);
+      leaves.add(leaf);
+      tester.set(leaf, new StringValue("leaf" + i));
+    }
+    final SkyKey leaf4 = GraphTester.toSkyKey("leaf4");
+    tester.set(leaf4, new StringValue("leaf" + 4));
+    tester.getOrCreate(topKey).setBuilder(new SkyFunction() {
+      @Override
+      public SkyValue compute(SkyKey skyKey, Environment env) throws SkyFunctionException,
+          InterruptedException {
+        if (valuesOrThrow) {
+          env.getValuesOrThrow(leaves, SomeErrorException.class);
+        } else {
+          env.getValues(leaves);
+        }
+        if (twoCalls && env.valuesMissing()) {
+          return null;
+        }
+        SkyKey first = sameFirst ? leaves.get(0) : leaf4;
+        SkyKey second = sameFirst ? leaf4 : leaves.get(2);
+        List<SkyKey> secondRequest = ImmutableList.of(first, second);
+        if (valuesOrThrow) {
+          env.getValuesOrThrow(secondRequest, SomeErrorException.class);
+        } else {
+          env.getValues(secondRequest);
+        }
+        if (env.valuesMissing()) {
+          return null;
+        }
+        return new StringValue("top");
+      }
+
+      @Override
+      public String extractTag(SkyKey skyKey) {
+        return null;
+      }
+    });
+    eval(/*keepGoing=*/false, topKey);
+    assertEquals(new StringValue("top"), eval(/*keepGoing=*/false, topKey));
+  }
+
+  @Test
+  public void sameDepInTwoGroups_Same_Two_Throw() throws Exception {
+    sameDepInTwoGroups(/*sameFirst=*/true, /*twoCalls=*/true, /*valuesOrThrow=*/true);
+  }
+
+  @Test
+  public void sameDepInTwoGroups_Same_Two_Deps() throws Exception {
+    sameDepInTwoGroups(/*sameFirst=*/true, /*twoCalls=*/true, /*valuesOrThrow=*/false);
+  }
+
+  @Test
+  public void sameDepInTwoGroups_Same_One_Throw() throws Exception {
+    sameDepInTwoGroups(/*sameFirst=*/true, /*twoCalls=*/false, /*valuesOrThrow=*/true);
+  }
+
+  @Test
+  public void sameDepInTwoGroups_Same_One_Deps() throws Exception {
+    sameDepInTwoGroups(/*sameFirst=*/true, /*twoCalls=*/false, /*valuesOrThrow=*/false);
+  }
+
+  @Test
+  public void sameDepInTwoGroups_Different_Two_Throw() throws Exception {
+    sameDepInTwoGroups(/*sameFirst=*/false, /*twoCalls=*/true, /*valuesOrThrow=*/true);
+  }
+
+  @Test
+  public void sameDepInTwoGroups_Different_Two_Deps() throws Exception {
+    sameDepInTwoGroups(/*sameFirst=*/false, /*twoCalls=*/true, /*valuesOrThrow=*/false);
+  }
+
+  @Test
+  public void sameDepInTwoGroups_Different_One_Throw() throws Exception {
+    sameDepInTwoGroups(/*sameFirst=*/false, /*twoCalls=*/false, /*valuesOrThrow=*/true);
+  }
+
+  @Test
+  public void sameDepInTwoGroups_Different_One_Deps() throws Exception {
+    sameDepInTwoGroups(/*sameFirst=*/false, /*twoCalls=*/false, /*valuesOrThrow=*/false);
+  }
+
+  private void getValuesOrThrowWithErrors(boolean keepGoing) throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey parentKey = GraphTester.toSkyKey("parent");
+    final SkyKey errorDep = GraphTester.toSkyKey("errorChild");
+    final SomeErrorException childExn = new SomeErrorException("child error");
+    tester.getOrCreate(errorDep).setBuilder(new SkyFunction() {
+      @Override
+      public SkyValue compute(SkyKey skyKey, Environment env) throws SkyFunctionException {
+        throw new GenericFunctionException(childExn, Transience.PERSISTENT);
+      }
+
+      @Override
+      public String extractTag(SkyKey skyKey) {
+        return null;
+      }
+    });
+    final List<SkyKey> deps = new ArrayList<>();
+    for (int i = 1; i <= 3; i++) {
+      SkyKey dep = GraphTester.toSkyKey("child" + i);
+      deps.add(dep);
+      tester.set(dep, new StringValue("child" + i));
+    }
+    final SomeErrorException parentExn = new SomeErrorException("parent error");
+    tester.getOrCreate(parentKey).setBuilder(new SkyFunction() {
+      @Override
+      public SkyValue compute(SkyKey skyKey, Environment env) throws SkyFunctionException {
+        try {
+          SkyValue value = env.getValueOrThrow(errorDep, SomeErrorException.class);
+          if (value == null) {
+            return null;
+          }
+        } catch (SomeErrorException e) {
+          // Recover from the child error.
+        }
+        env.getValues(deps);
+        if (env.valuesMissing()) {
+          return null;
+        }
+        throw new GenericFunctionException(parentExn, Transience.PERSISTENT);
+      }
+
+      @Override
+      public String extractTag(SkyKey skyKey) {
+        return null;
+      }
+    });
+    EvaluationResult<StringValue> evaluationResult = eval(keepGoing, ImmutableList.of(parentKey));
+    assertTrue(evaluationResult.hasError());
+    assertEquals(keepGoing ? parentExn : childExn, evaluationResult.getError().getException());
+  }
+
+  @Test
+  public void getValuesOrThrowWithErrors_NoKeepGoing() throws Exception {
+    getValuesOrThrowWithErrors(/*keepGoing=*/false);
+  }
+
+  @Test
+  public void getValuesOrThrowWithErrors_KeepGoing() throws Exception {
+    getValuesOrThrowWithErrors(/*keepGoing=*/true);
+  }
+
+  @Test
+  public void duplicateCycles() throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey grandparentKey = GraphTester.toSkyKey("grandparent");
+    SkyKey parentKey1 = GraphTester.toSkyKey("parent1");
+    SkyKey parentKey2 = GraphTester.toSkyKey("parent2");
+    SkyKey loopKey1 = GraphTester.toSkyKey("loop1");
+    SkyKey loopKey2 = GraphTester.toSkyKey("loop2");
+    tester.getOrCreate(loopKey1).addDependency(loopKey2);
+    tester.getOrCreate(loopKey2).addDependency(loopKey1);
+    tester.getOrCreate(parentKey1).addDependency(loopKey1);
+    tester.getOrCreate(parentKey2).addDependency(loopKey2);
+    tester.getOrCreate(grandparentKey).addDependency(parentKey1);
+    tester.getOrCreate(grandparentKey).addDependency(parentKey2);
+
+    ErrorInfo errorInfo = evalValueInError(grandparentKey);
+    List<ImmutableList<SkyKey>> cycles = Lists.newArrayList();
+    for (CycleInfo cycleInfo : errorInfo.getCycleInfo()) {
+      cycles.add(cycleInfo.getCycle());
+    }
+    // Skyframe doesn't automatically dedupe cycles that are the same except for entry point.
+    assertEquals(2, cycles.size());
+    int numUniqueCycles = 0;
+    CycleDeduper<SkyKey> cycleDeduper = new CycleDeduper<SkyKey>();
+    for (ImmutableList<SkyKey> cycle : cycles) {
+      if (cycleDeduper.seen(cycle)) {
+        numUniqueCycles++;
+      }
+    }
+    assertEquals(1, numUniqueCycles);
+  }
+
+  @Test
+  public void signalValueEnqueuedAndEvaluated() throws Exception {
+    final Set<SkyKey> enqueuedValues = Sets.newConcurrentHashSet();
+    final Set<SkyKey> evaluatedValues = Sets.newConcurrentHashSet();
+    EvaluationProgressReceiver progressReceiver = new EvaluationProgressReceiver() {
+      @Override
+      public void invalidated(SkyValue value, InvalidationState state) {
+        throw new IllegalStateException();
+      }
+
+      @Override
+      public void enqueueing(SkyKey skyKey) {
+        enqueuedValues.add(skyKey);
+      }
+
+      @Override
+      public void evaluated(SkyKey skyKey, SkyValue value, EvaluationState state) {
+        evaluatedValues.add(skyKey);
+      }
+    };
+
+    EventHandler reporter = new EventHandler() {
+      @Override
+      public void handle(Event e) {
+        throw new IllegalStateException();
+      }
+    };
+
+    MemoizingEvaluator aug = new InMemoryMemoizingEvaluator(
+        ImmutableMap.of(GraphTester.NODE_TYPE, tester.getFunction()), new RecordingDifferencer(),
+        progressReceiver);
+    SequentialBuildDriver driver = new SequentialBuildDriver(aug);
+
+    tester.getOrCreate("top1").setComputedValue(CONCATENATE)
+        .addDependency("d1").addDependency("d2");
+    tester.getOrCreate("top2").setComputedValue(CONCATENATE).addDependency("d3");
+    tester.getOrCreate("top3");
+    assertThat(enqueuedValues).isEmpty();
+    assertThat(evaluatedValues).isEmpty();
+
+    tester.set("d1", new StringValue("1"));
+    tester.set("d2", new StringValue("2"));
+    tester.set("d3", new StringValue("3"));
+
+    driver.evaluate(ImmutableList.of(GraphTester.toSkyKey("top1")), false, 200, reporter);
+    assertThat(enqueuedValues)
+        .containsExactlyElementsIn(Arrays.asList(GraphTester.toSkyKeys("top1", "d1", "d2")));
+    assertThat(evaluatedValues)
+        .containsExactlyElementsIn(Arrays.asList(GraphTester.toSkyKeys("top1", "d1", "d2")));
+    enqueuedValues.clear();
+    evaluatedValues.clear();
+
+    driver.evaluate(ImmutableList.of(GraphTester.toSkyKey("top2")), false, 200, reporter);
+    assertThat(enqueuedValues)
+        .containsExactlyElementsIn(Arrays.asList(GraphTester.toSkyKeys("top2", "d3")));
+    assertThat(evaluatedValues)
+        .containsExactlyElementsIn(Arrays.asList(GraphTester.toSkyKeys("top2", "d3")));
+    enqueuedValues.clear();
+    evaluatedValues.clear();
+
+    driver.evaluate(ImmutableList.of(GraphTester.toSkyKey("top1")), false, 200, reporter);
+    assertThat(enqueuedValues).isEmpty();
+    assertThat(evaluatedValues)
+        .containsExactlyElementsIn(Arrays.asList(GraphTester.toSkyKeys("top1")));
+  }
+
+  public void runDepOnErrorHaltsNoKeepGoingBuildEagerly(boolean childErrorCached,
+      final boolean handleChildError) throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey parentKey = GraphTester.toSkyKey("parent");
+    final SkyKey childKey = GraphTester.toSkyKey("child");
+    tester.getOrCreate(childKey).setHasError(/*hasError=*/true);
+    // The parent should be built exactly twice: once during normal evaluation and once
+    // during error bubbling.
+    final AtomicInteger numParentInvocations = new AtomicInteger(0);
+    tester.getOrCreate(parentKey).setBuilder(new SkyFunction() {
+      @Override
+      public SkyValue compute(SkyKey skyKey, Environment env) throws SkyFunctionException {
+        int invocations = numParentInvocations.incrementAndGet();
+        if (handleChildError) {
+          try {
+            SkyValue value = env.getValueOrThrow(childKey, SomeErrorException.class);
+            // On the first invocation, either the child error should already be cached and not
+            // propagated, or it should be computed freshly and not propagated. On the second build
+            // (error bubbling), the child error should be propagated.
+            assertTrue("bogus non-null value " + value, value == null);
+            assertEquals("parent incorrectly re-computed during normal evaluation", 1, invocations);
+            assertFalse("child error not propagated during error bubbling",
+                env.inErrorBubblingForTesting());
+            return value;
+          } catch (SomeErrorException e) {
+            assertTrue("child error propagated during normal evaluation",
+                env.inErrorBubblingForTesting());
+            assertEquals(2, invocations);
+            return null;
+          }
+        } else {
+          if (invocations == 1) {
+            assertFalse("parent's first computation should be during normal evaluation",
+                env.inErrorBubblingForTesting());
+            return env.getValue(childKey);
+          } else {
+            assertEquals(2, invocations);
+            assertTrue("parent incorrectly re-computed during normal evaluation",
+                env.inErrorBubblingForTesting());
+            return env.getValue(childKey);
+          }
+        }
+      }
+
+      @Override
+      public String extractTag(SkyKey skyKey) {
+        return null;
+      }
+    });
+    if (childErrorCached) {
+      // Ensure that the child is already in the graph.
+      evalValueInError(childKey);
+    }
+    EvaluationResult<StringValue> result = eval(/*keepGoing=*/false, ImmutableList.of(parentKey));
+    assertEquals(2, numParentInvocations.get());
+    assertTrue(result.hasError());
+    assertEquals(childKey, result.getError().getRootCauseOfException());
+  }
+
+  @Test
+  public void depOnErrorHaltsNoKeepGoingBuildEagerly_ChildErrorCachedAndHandled()
+      throws Exception {
+    runDepOnErrorHaltsNoKeepGoingBuildEagerly(/*childErrorCached=*/true,
+        /*handleChildError=*/true);
+  }
+
+  @Test
+  public void depOnErrorHaltsNoKeepGoingBuildEagerly_ChildErrorCachedAndNotHandled()
+      throws Exception {
+    runDepOnErrorHaltsNoKeepGoingBuildEagerly(/*childErrorCached=*/true,
+        /*handleChildError=*/false);
+  }
+
+  @Test
+  public void depOnErrorHaltsNoKeepGoingBuildEagerly_ChildErrorFreshAndHandled() throws Exception {
+    runDepOnErrorHaltsNoKeepGoingBuildEagerly(/*childErrorCached=*/false,
+        /*handleChildError=*/true);
+  }
+
+  @Test
+  public void depOnErrorHaltsNoKeepGoingBuildEagerly_ChildErrorFreshAndNotHandled()
+      throws Exception {
+    runDepOnErrorHaltsNoKeepGoingBuildEagerly(/*childErrorCached=*/false,
+        /*handleChildError=*/false);
+  }
+
+  @Test
+  public void raceConditionWithNoKeepGoingErrors_InflightError() throws Exception {
+    final CountDownLatch errorCommitted = new CountDownLatch(1);
+    final TrackingAwaiter trackingAwaiterForError = new TrackingAwaiter();
+    final CountDownLatch otherDone = new CountDownLatch(1);
+    final TrackingAwaiter trackingAwaiterForOther = new TrackingAwaiter();
+    final SkyKey errorKey = GraphTester.toSkyKey("errorKey");
+    final SkyKey otherKey = GraphTester.toSkyKey("otherKey");
+    tester.getOrCreate(errorKey).setHasError(true);
+    final AtomicInteger numOtherInvocations = new AtomicInteger(0);
+    tester.getOrCreate(otherKey).setBuilder(new SkyFunction() {
+      @Override
+      public SkyValue compute(SkyKey skyKey, Environment env) throws SkyFunctionException {
+        int invocations = numOtherInvocations.incrementAndGet();
+        if (invocations == 1) {
+          trackingAwaiterForError.awaitLatchAndTrackExceptions(errorCommitted,
+              "error didn't get committed to the graph in time");
+        }
+        try {
+          SkyValue value = env.getValueOrThrow(errorKey, SomeErrorException.class);
+          assertTrue("bogus non-null value " + value, value == null);
+          assertEquals(1, invocations);
+          otherDone.countDown();
+          throw new GenericFunctionException(new SomeErrorException("other"),
+              Transience.PERSISTENT);
+        } catch (SomeErrorException e) {
+          assertEquals(2, invocations);
+          return null;
+        }
+      }
+
+      @Override
+      public String extractTag(SkyKey skyKey) {
+        return null;
+      }
+    });
+    graph = new NotifyingInMemoryGraph(new Listener() {
+      @Override
+      public void accept(SkyKey key, EventType type, Order order, Object context) {
+        if (key.equals(errorKey) && type == EventType.SET_VALUE && order == Order.AFTER) {
+          errorCommitted.countDown();
+          trackingAwaiterForOther.awaitLatchAndTrackExceptions(otherDone,
+              "otherKey's SkyFunction didn't finish in time");
+        }
+      }
+    });
+    EvaluationResult<StringValue> result = eval(/*keepGoing=*/false,
+        ImmutableList.of(errorKey, otherKey));
+    assertEquals(null, graph.get(otherKey));
+    assertTrue(result.hasError());
+    assertEquals(errorKey, result.getError().getRootCauseOfException());
+  }
+
+  @Test
+  public void raceConditionWithNoKeepGoingErrors_FutureError() throws Exception {
+    final CountDownLatch errorCommitted = new CountDownLatch(1);
+    final TrackingAwaiter trackingAwaiterForError = new TrackingAwaiter();
+    final CountDownLatch otherStarted = new CountDownLatch(1);
+    final TrackingAwaiter trackingAwaiterForOther = new TrackingAwaiter();
+    final CountDownLatch otherParentSignaled = new CountDownLatch(1);
+    final TrackingAwaiter trackingAwaiterForOtherParent = new TrackingAwaiter();
+    final SkyKey errorParentKey = GraphTester.toSkyKey("errorParentKey");
+    final SkyKey errorKey = GraphTester.toSkyKey("errorKey");
+    final SkyKey otherParentKey = GraphTester.toSkyKey("otherParentKey");
+    final SkyKey otherKey = GraphTester.toSkyKey("otherKey");
+    final AtomicInteger numOtherParentInvocations = new AtomicInteger(0);
+    final AtomicInteger numErrorParentInvocations = new AtomicInteger(0);
+    tester.getOrCreate(otherParentKey).setBuilder(new SkyFunction() {
+      @Override
+      public SkyValue compute(SkyKey skyKey, Environment env) throws SkyFunctionException {
+        int invocations = numOtherParentInvocations.incrementAndGet();
+        assertEquals("otherParentKey should not be restarted", 1, invocations);
+        return env.getValue(otherKey);
+      }
+
+      @Override
+      public String extractTag(SkyKey skyKey) {
+        return null;
+      }
+    });
+    tester.getOrCreate(otherKey).setBuilder(new SkyFunction() {
+      @Override
+      public SkyValue compute(SkyKey skyKey, Environment env) throws SkyFunctionException {
+        otherStarted.countDown();
+        trackingAwaiterForError.awaitLatchAndTrackExceptions(errorCommitted,
+            "error didn't get committed to the graph in time");
+        return new StringValue("other");
+      }
+
+      @Override
+      public String extractTag(SkyKey skyKey) {
+        return null;
+      }
+    });
+    tester.getOrCreate(errorKey).setBuilder(new SkyFunction() {
+      @Override
+      public SkyValue compute(SkyKey skyKey, Environment env) throws SkyFunctionException {
+        trackingAwaiterForOther.awaitLatchAndTrackExceptions(otherStarted,
+            "other didn't start in time");
+        throw new GenericFunctionException(new SomeErrorException("error"),
+            Transience.PERSISTENT);
+      }
+
+      @Override
+      public String extractTag(SkyKey skyKey) {
+        return null;
+      }
+    });
+    tester.getOrCreate(errorParentKey).setBuilder(new SkyFunction() {
+      @Override
+      public SkyValue compute(SkyKey skyKey, Environment env) throws SkyFunctionException {
+        int invocations = numErrorParentInvocations.incrementAndGet();
+        try {
+          SkyValue value = env.getValueOrThrow(errorKey, SomeErrorException.class);
+          assertTrue("bogus non-null value " + value, value == null);
+          if (invocations == 1) {
+            return null;
+          } else {
+            assertFalse(env.inErrorBubblingForTesting());
+            fail("RACE CONDITION: errorParentKey was restarted!");
+            return null;
+          }
+        } catch (SomeErrorException e) {
+          assertTrue("child error propagated during normal evaluation",
+              env.inErrorBubblingForTesting());
+          assertEquals(2, invocations);
+          return null;
+        }
+      }
+
+      @Override
+      public String extractTag(SkyKey skyKey) {
+        return null;
+      }
+    });
+    graph = new NotifyingInMemoryGraph(new Listener() {
+      @Override
+      public void accept(SkyKey key, EventType type, Order order, Object context) {
+        if (key.equals(errorKey) && type == EventType.SET_VALUE && order == Order.AFTER) {
+          errorCommitted.countDown();
+          trackingAwaiterForOtherParent.awaitLatchAndTrackExceptions(otherParentSignaled,
+              "otherParent didn't get signaled in time");
+          // We try to give some time for ParallelEvaluator to incorrectly re-evaluate
+          // 'otherParentKey'. This test case is testing for a real race condition and the 10ms time
+          // was chosen experimentally to give a true positive rate of 99.8% (without a sleep it
+          // has a 1% true positive rate). There's no good way to do this without sleeping. We
+          // *could* introspect ParallelEvaulator's AbstractQueueVisitor to see if the re-evaluation
+          // has been enqueued, but that's relying on pretty low-level implementation details.
+          Uninterruptibles.sleepUninterruptibly(10, TimeUnit.MILLISECONDS);
+        }
+        if (key.equals(otherParentKey) && type == EventType.SIGNAL && order == Order.AFTER) {
+          otherParentSignaled.countDown();
+        }
+      }
+    });
+    EvaluationResult<StringValue> result = eval(/*keepGoing=*/false,
+        ImmutableList.of(otherParentKey, errorParentKey));
+    assertTrue(result.hasError());
+    assertEquals(errorKey, result.getError().getRootCauseOfException());
+  }
+
+  @Test
+  public void cachedErrorsFromKeepGoingUsedOnNoKeepGoing() throws Exception {
+    graph = new DeterministicInMemoryGraph();
+    tester = new GraphTester();
+    SkyKey errorKey = GraphTester.toSkyKey("error");
+    SkyKey parent1Key = GraphTester.toSkyKey("parent1");
+    SkyKey parent2Key = GraphTester.toSkyKey("parent2");
+    tester.getOrCreate(parent1Key).addDependency(errorKey).setConstantValue(
+        new StringValue("parent1"));
+    tester.getOrCreate(parent2Key).addDependency(errorKey).setConstantValue(
+        new StringValue("parent2"));
+    tester.getOrCreate(errorKey).setHasError(true);
+    EvaluationResult<StringValue> result = eval(/*keepGoing=*/true, ImmutableList.of(parent1Key));
+    assertTrue(result.hasError());
+    assertEquals(errorKey, result.getError().getRootCauseOfException());
+    result = eval(/*keepGoing=*/false, ImmutableList.of(parent2Key));
+    assertTrue(result.hasError());
+    assertEquals(errorKey, result.getError(parent2Key).getRootCauseOfException());
+  }
+
+  @Test
+  public void cachedTopLevelErrorsShouldHaltNoKeepGoingBuildEarly() throws Exception {
+    graph = new DeterministicInMemoryGraph();
+    tester = new GraphTester();
+    SkyKey errorKey = GraphTester.toSkyKey("error");
+    tester.getOrCreate(errorKey).setHasError(true);
+    EvaluationResult<StringValue> result = eval(/*keepGoing=*/true, ImmutableList.of(errorKey));
+    assertTrue(result.hasError());
+    assertEquals(errorKey, result.getError().getRootCauseOfException());
+    SkyKey rogueKey = GraphTester.toSkyKey("rogue");
+    tester.getOrCreate(rogueKey).setBuilder(new SkyFunction() {
+      @Override
+      public SkyValue compute(SkyKey skyKey, Environment env) {
+        // This SkyFunction could do an arbitrarily bad computation, e.g. loop-forever. So we want
+        // to make sure that it is never run when we want to fail-fast anyway.
+        fail("eval call should have already terminated");
+        return null;
+      }
+
+      @Override
+      public String extractTag(SkyKey skyKey) {
+        return null;
+      }
+    });
+    result = eval(/*keepGoing=*/false, ImmutableList.of(errorKey, rogueKey));
+    assertTrue(result.hasError());
+    assertEquals(errorKey, result.getError(errorKey).getRootCauseOfException());
+    assertFalse(result.errorMap().containsKey(rogueKey));
+  }
+
+  private void runUnhandledTransitiveErrors(boolean keepGoing,
+      final boolean explicitlyPropagateError) throws Exception {
+    graph = new DeterministicInMemoryGraph();
+    tester = new GraphTester();
+    SkyKey grandparentKey = GraphTester.toSkyKey("grandparent");
+    final SkyKey parentKey = GraphTester.toSkyKey("parent");
+    final SkyKey childKey = GraphTester.toSkyKey("child");
+    final AtomicBoolean errorPropagated = new AtomicBoolean(false);
+    tester.getOrCreate(grandparentKey).setBuilder(new SkyFunction() {
+      @Override
+      public SkyValue compute(SkyKey skyKey, Environment env) throws SkyFunctionException {
+        try {
+          return env.getValueOrThrow(parentKey, SomeErrorException.class);
+        } catch (SomeErrorException e) {
+          errorPropagated.set(true);
+          throw new GenericFunctionException(e, Transience.PERSISTENT);
+        }
+      }
+
+      @Override
+      public String extractTag(SkyKey skyKey) {
+        return null;
+      }
+    });
+    tester.getOrCreate(parentKey).setBuilder(new SkyFunction() {
+      @Override
+      public SkyValue compute(SkyKey skyKey, Environment env) throws SkyFunctionException {
+        if (explicitlyPropagateError) {
+          try {
+            return env.getValueOrThrow(childKey, SomeErrorException.class);
+          } catch (SomeErrorException e) {
+            throw new GenericFunctionException(e, childKey);
+          }
+        } else {
+          return env.getValue(childKey);
+        }
+      }
+
+      @Override
+      public String extractTag(SkyKey skyKey) {
+        return null;
+      }
+    });
+    tester.getOrCreate(childKey).setHasError(/*hasError=*/true);
+    EvaluationResult<StringValue> result = eval(keepGoing, ImmutableList.of(grandparentKey));
+    assertTrue(result.hasError());
+    assertTrue(errorPropagated.get());
+    assertEquals(grandparentKey, result.getError().getRootCauseOfException());
+  }
+
+  @Test
+  public void unhandledTransitiveErrorsDuringErrorBubbling_ImplicitPropagation() throws Exception {
+    runUnhandledTransitiveErrors(/*keepGoing=*/false, /*explicitlyPropagateError=*/false);
+  }
+
+  @Test
+  public void unhandledTransitiveErrorsDuringErrorBubbling_ExplicitPropagation() throws Exception {
+    runUnhandledTransitiveErrors(/*keepGoing=*/false, /*explicitlyPropagateError=*/true);
+  }
+
+  @Test
+  public void unhandledTransitiveErrorsDuringNormalEvaluation_ImplicitPropagation()
+      throws Exception {
+    runUnhandledTransitiveErrors(/*keepGoing=*/true, /*explicitlyPropagateError=*/false);
+  }
+
+  @Test
+  public void unhandledTransitiveErrorsDuringNormalEvaluation_ExplicitPropagation()
+      throws Exception {
+    runUnhandledTransitiveErrors(/*keepGoing=*/true, /*explicitlyPropagateError=*/true);
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/skyframe/ReverseDepsUtilTest.java b/src/test/java/com/google/devtools/build/skyframe/ReverseDepsUtilTest.java
new file mode 100644
index 0000000..9183775
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/skyframe/ReverseDepsUtilTest.java
@@ -0,0 +1,155 @@
+// Copyright 2014 Google Inc. 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.skyframe;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.collect.ImmutableList;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Test for {@code ReverseDepsUtil}.
+ */
+@RunWith(Parameterized.class)
+public class ReverseDepsUtilTest {
+
+  private static final SkyFunctionName NODE_TYPE = new SkyFunctionName("Type", false);
+  private final int numElements;
+
+  @Parameters
+  public static List<Object[]> paramenters() {
+    List<Object[]> params = new ArrayList<>();
+    for (int i = 0; i < 20; i++) {
+      params.add(new Object[]{i});
+    }
+    return params;
+  }
+
+  public ReverseDepsUtilTest(int numElements) {
+    this.numElements = numElements;
+  }
+
+  private static final ReverseDepsUtil<Example> REVERSE_DEPS_UTIL = new ReverseDepsUtil<Example>() {
+    @Override
+    void setReverseDepsObject(Example container, Object object) {
+      container.reverseDeps = object;
+    }
+
+    @Override
+    void setSingleReverseDep(Example container, boolean singleObject) {
+      container.single = singleObject;
+    }
+
+    @Override
+    void setReverseDepsToRemove(Example container, List<SkyKey> object) {
+      container.reverseDepsToRemove = object;
+    }
+
+    @Override
+    Object getReverseDepsObject(Example container) {
+      return container.reverseDeps;
+    }
+
+    @Override
+    boolean isSingleReverseDep(Example container) {
+      return container.single;
+    }
+
+    @Override
+    List<SkyKey> getReverseDepsToRemove(Example container) {
+      return container.reverseDepsToRemove;
+    }
+  };
+
+  private class Example {
+
+    Object reverseDeps = ImmutableList.of();
+    boolean single;
+    List<SkyKey> reverseDepsToRemove;
+  }
+
+  @Test
+  public void testAddAndRemove() {
+    for (int numRemovals = 0; numRemovals <= numElements; numRemovals++) {
+      Example example = new Example();
+      for (int j = 0; j < numElements; j++) {
+        REVERSE_DEPS_UTIL.addReverseDeps(example, Collections.singleton(new SkyKey(NODE_TYPE, j)));
+      }
+      // Not a big test but at least check that it does not blow up.
+      assertThat(REVERSE_DEPS_UTIL.toString(example)).isNotEmpty();
+      assertThat(REVERSE_DEPS_UTIL.getReverseDeps(example)).hasSize(numElements);
+      for (int i = 0; i < numRemovals; i++) {
+        REVERSE_DEPS_UTIL.removeReverseDep(example, new SkyKey(NODE_TYPE, i));
+      }
+      assertThat(REVERSE_DEPS_UTIL.getReverseDeps(example)).hasSize(numElements - numRemovals);
+      assertThat(example.reverseDepsToRemove).isNull();
+    }
+  }
+
+  // Same as testAdditionAndRemoval but we add all the reverse deps in one call.
+  @Test
+  public void testAddAllAndRemove() {
+    for (int numRemovals = 0; numRemovals <= numElements; numRemovals++) {
+      Example example = new Example();
+      List<SkyKey> toAdd = new ArrayList<>();
+      for (int j = 0; j < numElements; j++) {
+        toAdd.add(new SkyKey(NODE_TYPE, j));
+      }
+      REVERSE_DEPS_UTIL.addReverseDeps(example, toAdd);
+      assertThat(REVERSE_DEPS_UTIL.getReverseDeps(example)).hasSize(numElements);
+      for (int i = 0; i < numRemovals; i++) {
+        REVERSE_DEPS_UTIL.removeReverseDep(example, new SkyKey(NODE_TYPE, i));
+      }
+      assertThat(REVERSE_DEPS_UTIL.getReverseDeps(example)).hasSize(numElements - numRemovals);
+      assertThat(example.reverseDepsToRemove).isNull();
+    }
+  }
+
+  @Test
+  public void testDuplicateCheckOnGetReverseDeps() {
+    Example example = new Example();
+    for (int i = 0; i < numElements; i++) {
+      REVERSE_DEPS_UTIL.addReverseDeps(example, Collections.singleton(new SkyKey(NODE_TYPE, i)));
+    }
+    // Should only fail when we call getReverseDeps().
+    REVERSE_DEPS_UTIL.addReverseDeps(example, Collections.singleton(new SkyKey(NODE_TYPE, 0)));
+    try {
+      REVERSE_DEPS_UTIL.getReverseDeps(example);
+      assertThat(numElements).is(0);
+    } catch (Exception expected) { }
+  }
+
+  @Test
+  public void testMaybeCheck() {
+    Example example = new Example();
+    for (int i = 0; i < numElements; i++) {
+      REVERSE_DEPS_UTIL.addReverseDeps(example, Collections.singleton(new SkyKey(NODE_TYPE, i)));
+      // This should always succeed, since the next element is still not present.
+      REVERSE_DEPS_UTIL.maybeCheckReverseDepNotPresent(example, new SkyKey(NODE_TYPE, i + 1));
+    }
+    try {
+      REVERSE_DEPS_UTIL.maybeCheckReverseDepNotPresent(example, new SkyKey(NODE_TYPE, 0));
+      // Should only fail if empty or above the checking threshold.
+      assertThat(numElements == 0 || numElements >= ReverseDepsUtil.MAYBE_CHECK_THRESHOLD).isTrue();
+    } catch (Exception expected) { }
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/skyframe/SomeErrorException.java b/src/test/java/com/google/devtools/build/skyframe/SomeErrorException.java
new file mode 100644
index 0000000..b25cbd3
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/skyframe/SomeErrorException.java
@@ -0,0 +1,20 @@
+// Copyright 2014 Google Inc. 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.skyframe;
+
+public class SomeErrorException extends Exception {
+  public SomeErrorException(String msg) {
+    super(msg);
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/skyframe/TrackingAwaiter.java b/src/test/java/com/google/devtools/build/skyframe/TrackingAwaiter.java
new file mode 100644
index 0000000..3757583
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/skyframe/TrackingAwaiter.java
@@ -0,0 +1,78 @@
+// Copyright 2014 Google Inc. 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.skyframe;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.base.Throwables;
+import com.google.common.util.concurrent.Uninterruptibles;
+import com.google.devtools.build.lib.testutil.TestUtils;
+import com.google.devtools.build.lib.util.Pair;
+
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+/** Safely await {@link CountDownLatch}es in tests, storing any exceptions that happen. */
+public class TrackingAwaiter {
+  private final ConcurrentLinkedQueue<Pair<String, Throwable>> exceptionsThrown =
+      new ConcurrentLinkedQueue<>();
+
+  /**
+   * This method fixes a race condition with simply calling {@link CountDownLatch#await}. If this
+   * thread is interrupted before {@code latch.await} is called, then {@code latch.await} will throw
+   * an {@link InterruptedException} without checking the value of the latch at all. This leads to a
+   * race condition in which this thread will throw an InterruptedException if it is slow calling
+   * {@code latch.await}, but it will succeed normally otherwise.
+   *
+   * <p>To avoid this, we wait for the latch uninterruptibly. In the end, if the latch has in fact
+   * been released, we do nothing, although the interrupted bit is set, so that the caller can
+   * decide to throw an InterruptedException if it wants to. If the latch was not released, then
+   * this was not a race condition, but an honest-to-goodness interrupt, and we propagate the
+   * exception onward.
+   */
+  public static void waitAndMaybeThrowInterrupt(CountDownLatch latch, String errorMessage)
+      throws InterruptedException {
+    if (Uninterruptibles.awaitUninterruptibly(latch, TestUtils.WAIT_TIMEOUT_SECONDS,
+        TimeUnit.SECONDS)) {
+      // Latch was released. We can ignore the interrupt state.
+      return;
+    }
+    if (!Thread.currentThread().isInterrupted()) {
+      // Nobody interrupted us, but latch wasn't released. Failure.
+      throw new AssertionError(errorMessage);
+    } else {
+      // We were interrupted before the latch was released. Propagate this interruption.
+      throw new InterruptedException();
+    }
+  }
+
+  /** Threadpools can swallow exceptions. Make sure they don't get lost. */
+  public void awaitLatchAndTrackExceptions(CountDownLatch latch, String errorMessage) {
+    try {
+      waitAndMaybeThrowInterrupt(latch, errorMessage);
+    } catch (Throwable e) {
+      // We would expect e to be InterruptedException or AssertionError, but we leave it open so
+      // that any throwable gets recorded.
+      exceptionsThrown.add(Pair.of(errorMessage, e));
+      // Caller will assert exceptionsThrown is empty at end of test and fail, even if this is
+      // swallowed.
+      Throwables.propagate(e);
+    }
+  }
+
+  public void assertNoErrors() {
+    assertThat(exceptionsThrown).isEmpty();
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/skyframe/TrackingInvalidationReceiver.java b/src/test/java/com/google/devtools/build/skyframe/TrackingInvalidationReceiver.java
new file mode 100644
index 0000000..e93098d
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/skyframe/TrackingInvalidationReceiver.java
@@ -0,0 +1,68 @@
+// Copyright 2014 Google Inc. 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.skyframe;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Sets;
+
+import java.util.Set;
+
+/**
+ * A testing utility to keep track of evaluation.
+ */
+public class TrackingInvalidationReceiver implements EvaluationProgressReceiver {
+  public final Set<SkyValue> dirty = Sets.newConcurrentHashSet();
+  public final Set<SkyValue> deleted = Sets.newConcurrentHashSet();
+  public final Set<SkyKey> enqueued = Sets.newConcurrentHashSet();
+  public final Set<SkyKey> evaluated = Sets.newConcurrentHashSet();
+
+  @Override
+  public void invalidated(SkyValue value, InvalidationState state) {
+    switch (state) {
+      case DELETED:
+        dirty.remove(value);
+        deleted.add(value);
+        break;
+      case DIRTY:
+        dirty.add(value);
+        Preconditions.checkState(!deleted.contains(value));
+        break;
+      default:
+        throw new IllegalStateException();
+    }
+  }
+
+  @Override
+  public void enqueueing(SkyKey skyKey) {
+    enqueued.add(skyKey);
+  }
+
+  @Override
+  public void evaluated(SkyKey skyKey, SkyValue value, EvaluationState state) {
+    evaluated.add(skyKey);
+    switch (state) {
+      default:
+        dirty.remove(value);
+        deleted.remove(value);
+        break;
+    }
+  }
+
+  public void clear() {
+    dirty.clear();
+    deleted.clear();
+    enqueued.clear();
+    evaluated.clear();
+  }
+}
diff --git a/src/test/java/com/google/devtools/common/options/AllTests.java b/src/test/java/com/google/devtools/common/options/AllTests.java
new file mode 100644
index 0000000..14d6abb
--- /dev/null
+++ b/src/test/java/com/google/devtools/common/options/AllTests.java
@@ -0,0 +1,25 @@
+// Copyright 2014 Google Inc. 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.common.options;
+
+import com.google.devtools.build.lib.testutil.ClasspathSuite;
+
+import org.junit.runner.RunWith;
+
+/**
+ * Test suite for options parsing framework.
+ */
+@RunWith(ClasspathSuite.class)
+public class AllTests {
+}
diff --git a/src/test/java/com/google/devtools/common/options/AssignmentConverterTest.java b/src/test/java/com/google/devtools/common/options/AssignmentConverterTest.java
new file mode 100644
index 0000000..ecaef4c
--- /dev/null
+++ b/src/test/java/com/google/devtools/common/options/AssignmentConverterTest.java
@@ -0,0 +1,108 @@
+// Copyright 2014 Google Inc. 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.common.options;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.Maps;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.Map;
+
+/**
+ * Test for {@link Converters.AssignmentConverter} and
+ * {@link Converters.OptionalAssignmentConverter}.
+ */
+public abstract class AssignmentConverterTest {
+
+  protected Converter<Map.Entry<String, String>> converter = null;
+
+  protected abstract void setConverter();
+
+  protected Map.Entry<String, String> convert(String input) throws Exception {
+    return converter.convert(input);
+  }
+
+  @Before
+  public void setUp() throws Exception {
+    setConverter();
+  }
+
+  @Test
+  public void assignment() throws Exception {
+    assertEquals(Maps.immutableEntry("A", "1"), convert("A=1"));
+    assertEquals(Maps.immutableEntry("A", "ABC"), convert("A=ABC"));
+    assertEquals(Maps.immutableEntry("A", ""), convert("A="));
+  }
+
+  @Test
+  public void missingName() throws Exception {
+    try {
+      convert("=VALUE");
+      fail();
+    } catch (OptionsParsingException e) {
+      // expected.
+    }
+  }
+
+  @Test
+  public void emptyString() throws Exception {
+    try {
+      convert("");
+      fail();
+    } catch (OptionsParsingException e) {
+      // expected.
+    }
+  }
+
+
+  @RunWith(JUnit4.class)
+  public static class MandatoryAssignmentConverterTest extends AssignmentConverterTest {
+
+    @Override
+    protected void setConverter() {
+      converter = new Converters.AssignmentConverter();
+    }
+
+    @Test
+    public void missingValue() throws Exception {
+      try {
+        convert("NAME");
+        fail();
+      } catch (OptionsParsingException e) {
+        // expected.
+      }
+    }
+  }
+
+  @RunWith(JUnit4.class)
+  public static class OptionalAssignmentConverterTest extends AssignmentConverterTest {
+
+    @Override
+    protected void setConverter() {
+      converter = new Converters.OptionalAssignmentConverter();
+    }
+
+    @Test
+    public void missingValue() throws Exception {
+      assertEquals(Maps.immutableEntry("NAME", null), convert("NAME"));
+    }
+  }
+}
diff --git a/src/test/java/com/google/devtools/common/options/CommaSeparatedOptionListConverterTest.java b/src/test/java/com/google/devtools/common/options/CommaSeparatedOptionListConverterTest.java
new file mode 100644
index 0000000..7308a91
--- /dev/null
+++ b/src/test/java/com/google/devtools/common/options/CommaSeparatedOptionListConverterTest.java
@@ -0,0 +1,83 @@
+// Copyright 2014 Google Inc. 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.common.options;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * A test for {@link Converters.CommaSeparatedOptionListConverter}.
+ */
+@RunWith(JUnit4.class)
+public class CommaSeparatedOptionListConverterTest {
+
+  private Converter<List<String>> converter =
+      new Converters.CommaSeparatedOptionListConverter();
+
+  @Test
+  public void emptyStringYieldsEmptyList() throws Exception {
+    assertEquals(Collections.emptyList(), converter.convert(""));
+  }
+
+  @Test
+  public void commaTwoEmptyStrings() throws Exception {
+    assertEquals(Arrays.asList("", ""), converter.convert(","));
+  }
+
+  @Test
+  public void leadingCommaYieldsLeadingSpace() throws Exception {
+    assertEquals(Arrays.asList("", "leading", "comma"),
+                 converter.convert(",leading,comma"));
+  }
+
+  @Test
+  public void trailingCommaYieldsTrailingSpace() throws Exception {
+    assertEquals(Arrays.asList("trailing", "comma", ""),
+                 converter.convert("trailing,comma,"));
+  }
+
+  @Test
+  public void singleWord() throws Exception {
+    assertEquals(Arrays.asList("lonely"), converter.convert("lonely"));
+  }
+
+  @Test
+  public void multiWords() throws Exception {
+    assertEquals(Arrays.asList("one", "two", "three"),
+                 converter.convert("one,two,three"));
+  }
+
+  @Test
+  public void spaceIsIgnored() throws Exception {
+    assertEquals(Arrays.asList("one two three"),
+                 converter.convert("one two three"));
+  }
+
+  @Test
+  public void valueisUnmodifiable() throws Exception {
+    try {
+      converter.convert("value").add("other");
+      fail("could modify value");
+    } catch (UnsupportedOperationException expected) {}
+  }
+
+}
diff --git a/src/test/java/com/google/devtools/common/options/EnumConverterTest.java b/src/test/java/com/google/devtools/common/options/EnumConverterTest.java
new file mode 100644
index 0000000..5154695
--- /dev/null
+++ b/src/test/java/com/google/devtools/common/options/EnumConverterTest.java
@@ -0,0 +1,117 @@
+// Copyright 2014 Google Inc. 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.common.options;
+
+import static com.google.devtools.common.options.OptionsParser.newOptionsParser;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.fail;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.List;
+
+/**
+ * A test for {@link EnumConverter}.
+ */
+@RunWith(JUnit4.class)
+public class EnumConverterTest {
+
+  private enum CompilationMode {
+    DBG, OPT
+  }
+
+  private static class CompilationModeConverter
+    extends EnumConverter<CompilationMode> {
+
+    public CompilationModeConverter() {
+      super(CompilationMode.class, "compilation mode");
+    }
+  }
+
+  @Test
+  public void converterForEnumWithTwoValues() throws Exception {
+    CompilationModeConverter converter = new CompilationModeConverter();
+    assertEquals(converter.convert("dbg"), CompilationMode.DBG);
+    assertEquals(converter.convert("opt"), CompilationMode.OPT);
+    try {
+      converter.convert("none");
+      fail();
+    } catch(OptionsParsingException e) {
+      assertEquals(e.getMessage(),
+                   "Not a valid compilation mode: 'none' (should be dbg or opt)");
+    }
+    assertEquals("dbg or opt", converter.getTypeDescription());
+  }
+
+  private enum Fruit {
+    Apple, Banana, Cherry
+  }
+
+  private static class FruitConverter extends EnumConverter<Fruit> {
+
+    public FruitConverter() {
+      super(Fruit.class, "fruit");
+    }
+  }
+
+  @Test
+  public void typeDescriptionForEnumWithThreeValues() throws Exception {
+    FruitConverter converter = new FruitConverter();
+    // We always use lowercase in the user-visible messages:
+    assertEquals("apple, banana or cherry",
+                 converter.getTypeDescription());
+  }
+
+  @Test
+  public void converterIsCaseInsensitive() throws Exception {
+    FruitConverter converter = new FruitConverter();
+    assertSame(Fruit.Banana, converter.convert("bAnANa"));
+  }
+
+  // Regression test: lists of enum using a subclass of EnumConverter don't work
+  private static class AlphabetEnumConverter extends EnumConverter<AlphabetEnum> {
+    public AlphabetEnumConverter() {
+      super(AlphabetEnum.class, "alphabet enum");
+    }
+  }
+
+  private static enum AlphabetEnum {
+    ALPHA, BRAVO, CHARLY, DELTA, ECHO
+  }
+
+  public static class EnumListTestOptions extends OptionsBase {
+    @Option(name = "goo",
+            allowMultiple = true,
+            converter = AlphabetEnumConverter.class,
+            defaultValue = "null")
+    public List<AlphabetEnum> goo;
+  }
+
+  @Test
+  public void enumList() throws OptionsParsingException {
+    OptionsParser parser = newOptionsParser(EnumListTestOptions.class);
+    parser.parse("--goo=ALPHA", "--goo=BRAVO");
+    EnumListTestOptions options = parser.getOptions(EnumListTestOptions.class);
+    assertNotNull(options.goo);
+    assertEquals(2, options.goo.size());
+    assertEquals(AlphabetEnum.ALPHA, options.goo.get(0));
+    assertEquals(AlphabetEnum.BRAVO, options.goo.get(1));
+  }
+
+}
diff --git a/src/test/java/com/google/devtools/common/options/GenericTypeHelperTest.java b/src/test/java/com/google/devtools/common/options/GenericTypeHelperTest.java
new file mode 100644
index 0000000..e3a02ac
--- /dev/null
+++ b/src/test/java/com/google/devtools/common/options/GenericTypeHelperTest.java
@@ -0,0 +1,74 @@
+// Copyright 2014 Google Inc. 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.common.options;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests {@link GenericTypeHelper}.
+ */
+@RunWith(JUnit4.class)
+public class GenericTypeHelperTest {
+
+  private static interface DoSomething<T> {
+    T doIt();
+  }
+
+  private static class StringSomething implements DoSomething<String> {
+    @Override
+    public String doIt() {
+      return null;
+    }
+  }
+
+  private static class EnumSomething<T> implements DoSomething<T> {
+    @Override
+    public T doIt() {
+      return null;
+    }
+  }
+
+  private static class AlphabetSomething extends EnumSomething<String> {
+  }
+
+  private static class AlphabetTwoSomething extends AlphabetSomething {
+  }
+
+  private static void assertDoIt(Class<?> expected,
+      Class<? extends DoSomething<?>> implementingClass) throws Exception {
+    assertEquals(expected,
+        GenericTypeHelper.getActualReturnType(implementingClass,
+            implementingClass.getMethod("doIt")));
+  }
+
+  @Test
+  public void getConverterType() throws Exception {
+    assertDoIt(String.class, StringSomething.class);
+  }
+
+  @Test
+  public void getConverterTypeForGenericExtension() throws Exception {
+    assertDoIt(String.class, AlphabetSomething.class);
+  }
+
+  @Test
+  public void getConverterTypeForGenericExtensionSecondGrade() throws Exception {
+    assertDoIt(String.class, AlphabetTwoSomething.class);
+  }
+}
diff --git a/src/test/java/com/google/devtools/common/options/LogLevelConverterTest.java b/src/test/java/com/google/devtools/common/options/LogLevelConverterTest.java
new file mode 100644
index 0000000..4dfa209
--- /dev/null
+++ b/src/test/java/com/google/devtools/common/options/LogLevelConverterTest.java
@@ -0,0 +1,66 @@
+// Copyright 2014 Google Inc. 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.common.options;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+import com.google.devtools.common.options.Converters.LogLevelConverter;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.logging.Level;
+
+/**
+ * A test for {@link LogLevelConverter}.
+ */
+@RunWith(JUnit4.class)
+public class LogLevelConverterTest {
+
+  private LogLevelConverter converter = new LogLevelConverter();
+
+  @Test
+  public void convertsIntsToLevels() throws OptionsParsingException {
+    int levelId = 0;
+    for (Level level : LogLevelConverter.LEVELS) {
+      assertEquals(level, converter.convert(Integer.toString(levelId++)));
+    }
+  }
+
+  @Test
+  public void throwsExceptionWhenInputIsNotANumber() {
+    try {
+      converter.convert("oops - not a number.");
+      fail();
+    } catch (OptionsParsingException e) {
+      assertEquals("Not a log level: oops - not a number.", e.getMessage());
+    }
+  }
+
+  @Test
+  public void throwsExceptionWhenInputIsInvalidInteger() {
+    for (int example : new int[] {-1, 100, 50000}) {
+      try {
+        converter.convert(Integer.toString(example));
+        fail();
+      } catch (OptionsParsingException e) {
+        String expected = "Not a log level: " + Integer.toString(example);
+        assertEquals(expected, e.getMessage());
+      }
+    }
+  }
+
+}
diff --git a/src/test/java/com/google/devtools/common/options/OptionsParserTest.java b/src/test/java/com/google/devtools/common/options/OptionsParserTest.java
new file mode 100644
index 0000000..190d855
--- /dev/null
+++ b/src/test/java/com/google/devtools/common/options/OptionsParserTest.java
@@ -0,0 +1,1026 @@
+// Copyright 2014 Google Inc. 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.common.options;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.devtools.common.options.OptionsParser.newOptionsParser;
+import static java.util.Arrays.asList;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.devtools.common.options.Converters.CommaSeparatedOptionListConverter;
+import com.google.devtools.common.options.OptionsParser.OptionValueDescription;
+import com.google.devtools.common.options.OptionsParser.UnparsedOptionValueDescription;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Tests {@link OptionsParser}.
+ */
+@RunWith(JUnit4.class)
+public class OptionsParserTest {
+
+  public static class ExampleFoo extends OptionsBase {
+
+    @Option(name = "foo",
+            category = "one",
+            defaultValue = "defaultFoo")
+    public String foo;
+
+    @Option(name = "bar",
+            category = "two",
+            defaultValue = "42")
+    public int bar;
+
+    @Option(name = "bing",
+            category = "one",
+            defaultValue = "",
+            allowMultiple = true)
+    public List<String> bing;
+
+    @Option(name = "bang",
+            category = "one",
+            defaultValue = "",
+            converter = StringConverter.class,
+            allowMultiple = true)
+    public List<String> bang;
+
+    @Option(name = "nodoc",
+        category = "undocumented",
+        defaultValue = "",
+        allowMultiple = false)
+    public String nodoc;
+  }
+
+  public static class ExampleBaz extends OptionsBase {
+
+    @Option(name = "baz",
+            category = "one",
+            defaultValue = "defaultBaz")
+    public String baz;
+  }
+
+  public static class StringConverter implements Converter<String> {
+    @Override
+    public String convert(String input) {
+      return input;
+    }
+    @Override
+    public String getTypeDescription() {
+      return "a string";
+    }
+  }
+
+  @Test
+  public void parseWithMultipleOptionsInterfaces()
+      throws OptionsParsingException {
+    OptionsParser parser = newOptionsParser(ExampleFoo.class, ExampleBaz.class);
+    parser.parse("--baz=oops", "--bar", "17");
+    ExampleFoo foo = parser.getOptions(ExampleFoo.class);
+    assertEquals("defaultFoo", foo.foo);
+    assertEquals(17, foo.bar);
+    ExampleBaz baz = parser.getOptions(ExampleBaz.class);
+    assertEquals("oops", baz.baz);
+  }
+
+  @Test
+  public void parserWithUnknownOption() {
+    OptionsParser parser = newOptionsParser(ExampleFoo.class, ExampleBaz.class);
+    try {
+      parser.parse("--unknown", "option");
+      fail();
+    } catch (OptionsParsingException e) {
+      assertEquals("--unknown", e.getInvalidArgument());
+      assertEquals("Unrecognized option: --unknown", e.getMessage());
+    }
+    assertEquals(Collections.<String>emptyList(), parser.getResidue());
+  }
+
+  @Test
+  public void parserWithSingleDashOption() throws OptionsParsingException {
+    OptionsParser parser = newOptionsParser(ExampleFoo.class, ExampleBaz.class);
+    try {
+      parser.parse("-baz=oops", "-bar", "17");
+      fail();
+    } catch (OptionsParsingException expected) {}
+
+    parser = newOptionsParser(ExampleFoo.class, ExampleBaz.class);
+    parser.setAllowSingleDashLongOptions(true);
+    parser.parse("-baz=oops", "-bar", "17");
+    ExampleFoo foo = parser.getOptions(ExampleFoo.class);
+    assertEquals("defaultFoo", foo.foo);
+    assertEquals(17, foo.bar);
+    ExampleBaz baz = parser.getOptions(ExampleBaz.class);
+    assertEquals("oops", baz.baz);
+  }
+
+  @Test
+  public void parsingFailsWithUnknownOptions() {
+    OptionsParser parser = newOptionsParser(ExampleFoo.class, ExampleBaz.class);
+    List<String> unknownOpts = asList("--unknown", "option", "--more_unknowns");
+    try {
+      parser.parse(unknownOpts);
+      fail();
+    } catch (OptionsParsingException e) {
+      assertEquals("--unknown", e.getInvalidArgument());
+      assertEquals("Unrecognized option: --unknown", e.getMessage());
+      assertNotNull(parser.getOptions(ExampleFoo.class));
+      assertNotNull(parser.getOptions(ExampleBaz.class));
+    }
+  }
+
+  @Test
+  public void parseKnownAndUnknownOptions() {
+    OptionsParser parser = newOptionsParser(ExampleFoo.class, ExampleBaz.class);
+    List<String> opts = asList("--bar", "17", "--unknown", "option");
+    try {
+      parser.parse(opts);
+      fail();
+    } catch (OptionsParsingException e) {
+      assertEquals("--unknown", e.getInvalidArgument());
+      assertEquals("Unrecognized option: --unknown", e.getMessage());
+      assertNotNull(parser.getOptions(ExampleFoo.class));
+      assertNotNull(parser.getOptions(ExampleBaz.class));
+    }
+  }
+
+  public static class CategoryTest extends OptionsBase {
+    @Option(name = "swiss_bank_account_number",
+            category = "undocumented", // Not printed in usage messages!
+            defaultValue = "123456789")
+    public int swissBankAccountNumber;
+
+    @Option(name = "student_bank_account_number",
+            category = "one",
+            defaultValue = "987654321")
+    public int studentBankAccountNumber;
+  }
+
+  @Test
+  public void getOptionsAndGetResidueWithNoCallToParse() {
+    // With no call to parse(), all options are at default values, and there's
+    // no reside.
+    assertEquals("defaultFoo",
+                 newOptionsParser(ExampleFoo.class).
+                 getOptions(ExampleFoo.class).foo);
+    assertEquals(Collections.<String>emptyList(),
+                 newOptionsParser(ExampleFoo.class).getResidue());
+  }
+
+  @Test
+  public void parserCanBeCalledRepeatedly() throws OptionsParsingException {
+    OptionsParser parser = newOptionsParser(ExampleFoo.class);
+    parser.parse("--foo", "foo1");
+    assertEquals("foo1", parser.getOptions(ExampleFoo.class).foo);
+    parser.parse();
+    assertEquals("foo1", parser.getOptions(ExampleFoo.class).foo); // no change
+    parser.parse("--foo", "foo2");
+    assertEquals("foo2", parser.getOptions(ExampleFoo.class).foo); // updated
+  }
+
+  @Test
+  public void multipleOccuringOption() throws OptionsParsingException {
+    OptionsParser parser = newOptionsParser(ExampleFoo.class);
+    parser.parse("--bing", "abcdef", "--foo", "foo1", "--bing", "123456" );
+    assertThat(parser.getOptions(ExampleFoo.class).bing).containsExactly("abcdef", "123456");
+  }
+
+  @Test
+  public void multipleOccurringOptionWithConverter() throws OptionsParsingException {
+    // --bang is the same as --bing except that it has a "converter" specified.
+    // This test also tests option values with embedded commas and spaces.
+    OptionsParser parser = newOptionsParser(ExampleFoo.class);
+    parser.parse("--bang", "abc,def ghi", "--foo", "foo1", "--bang", "123456" );
+    assertThat(parser.getOptions(ExampleFoo.class).bang).containsExactly("abc,def ghi", "123456");
+  }
+
+  @Test
+  public void parserIgnoresOptionsAfterMinusMinus()
+      throws OptionsParsingException {
+    OptionsParser parser = newOptionsParser(ExampleFoo.class, ExampleBaz.class);
+    parser.parse("--foo", "well", "--baz", "here", "--", "--bar", "ignore");
+    ExampleFoo foo = parser.getOptions(ExampleFoo.class);
+    ExampleBaz baz = parser.getOptions(ExampleBaz.class);
+    assertEquals("well", foo.foo);
+    assertEquals("here", baz.baz);
+    assertEquals(42, foo.bar); // the default!
+    assertEquals(asList("--bar", "ignore"), parser.getResidue());
+  }
+
+  @Test
+  public void parserThrowsExceptionIfResidueIsNotAllowed() {
+    OptionsParser parser = newOptionsParser(ExampleFoo.class);
+    parser.setAllowResidue(false);
+    try {
+      parser.parse("residue", "is", "not", "OK");
+      fail();
+    } catch (OptionsParsingException e) {
+      assertEquals("Unrecognized arguments: residue is not OK", e.getMessage());
+    }
+  }
+
+  @Test
+  public void multipleCallsToParse() throws Exception {
+    OptionsParser parser = newOptionsParser(ExampleFoo.class);
+    parser.setAllowResidue(true);
+    parser.parse("--foo", "one", "--bar", "43", "unknown1");
+    parser.parse("--foo", "two", "unknown2");
+    ExampleFoo foo = parser.getOptions(ExampleFoo.class);
+    assertEquals("two", foo.foo); // second call takes precedence
+    assertEquals(43, foo.bar);
+    assertEquals(Arrays.asList("unknown1", "unknown2"), parser.getResidue());
+  }
+
+  // Regression test for a subtle bug!  The toString of each options interface
+  // instance was printing out key=value pairs for all flags in the
+  // OptionsParser, not just those belonging to the specific interface type.
+  @Test
+  public void toStringDoesntIncludeFlagsForOtherOptionsInParserInstance()
+      throws Exception {
+    OptionsParser parser = newOptionsParser(ExampleFoo.class, ExampleBaz.class);
+    parser.parse("--foo", "foo", "--bar", "43", "--baz", "baz");
+
+    String fooString = parser.getOptions(ExampleFoo.class).toString();
+    if (!fooString.contains("foo=foo") ||
+        !fooString.contains("bar=43") ||
+        !fooString.contains("ExampleFoo") ||
+        fooString.contains("baz=baz")) {
+      fail("ExampleFoo.toString() is incorrect: " + fooString);
+    }
+
+    String bazString = parser.getOptions(ExampleBaz.class).toString();
+    if (!bazString.contains("baz=baz") ||
+        !bazString.contains("ExampleBaz") ||
+        bazString.contains("foo=foo") ||
+        bazString.contains("bar=43")) {
+      fail("ExampleBaz.toString() is incorrect: " + bazString);
+    }
+  }
+
+  // Regression test for another subtle bug!  The toString was printing all the
+  // explicitly-specified options, even if they were at their default values,
+  // causing toString equivalence to diverge from equals().
+  @Test
+  public void toStringIsIndependentOfExplicitCommandLineOptions() throws Exception {
+    ExampleFoo foo1 = Options.parse(ExampleFoo.class).getOptions();
+    ExampleFoo foo2 = Options.parse(ExampleFoo.class, "--bar", "42").getOptions();
+    assertEquals(foo1, foo2);
+    assertEquals(foo1.toString(), foo2.toString());
+
+    Map<String, Object> expectedMap = new ImmutableMap.Builder<String, Object>().
+        put("bing", Collections.emptyList()).
+        put("bar", 42).
+        put("nodoc", "").
+        put("bang", Collections.emptyList()).
+        put("foo", "defaultFoo").build();
+
+    assertEquals(expectedMap, foo1.asMap());
+    assertEquals(expectedMap, foo2.asMap());
+  }
+
+  // Regression test for yet another subtle bug!  The inherited options weren't
+  // being printed by toString.  One day, a real rain will come and wash all
+  // this scummy code off the streets.
+  public static class DerivedBaz extends ExampleBaz {
+    @Option(name = "derived", defaultValue = "defaultDerived")
+    public String derived;
+  }
+
+  @Test
+  public void toStringPrintsInheritedOptionsToo_Duh() throws Exception {
+    DerivedBaz derivedBaz = Options.parse(DerivedBaz.class).getOptions();
+    String derivedBazString = derivedBaz.toString();
+    if (!derivedBazString.contains("derived=defaultDerived") ||
+        !derivedBazString.contains("baz=defaultBaz")) {
+      fail("DerivedBaz.toString() is incorrect: " + derivedBazString);
+    }
+  }
+
+  // Tests for new default value override mechanism
+  public static class CustomOptions extends OptionsBase {
+    @Option(name = "simple",
+        category = "custom",
+        defaultValue = "simple default")
+    public String simple;
+
+    @Option(name = "multipart_name",
+        category = "custom",
+        defaultValue = "multipart default")
+    public String multipartName;
+  }
+
+  public void assertDefaultStringsForCustomOptions() throws OptionsParsingException {
+    CustomOptions options = Options.parse(CustomOptions.class).getOptions();
+    assertEquals("simple default", options.simple);
+    assertEquals("multipart default", options.multipartName);
+  }
+
+  public static class NullTestOptions extends OptionsBase {
+    @Option(name = "simple",
+            defaultValue = "null")
+    public String simple;
+  }
+
+  @Test
+  public void defaultNullStringGivesNull() throws Exception {
+    NullTestOptions options = Options.parse(NullTestOptions.class).getOptions();
+    assertNull(options.simple);
+  }
+
+  public static class ImplicitDependencyOptions extends OptionsBase {
+    @Option(name = "first",
+            implicitRequirements = "--second=second",
+            defaultValue = "null")
+    public String first;
+
+    @Option(name = "second",
+        implicitRequirements = "--third=third",
+        defaultValue = "null")
+    public String second;
+
+    @Option(name = "third",
+        defaultValue = "null")
+    public String third;
+  }
+
+  @Test
+  public void implicitDependencyHasImplicitDependency() throws Exception {
+    OptionsParser parser = OptionsParser.newOptionsParser(ImplicitDependencyOptions.class);
+    parser.parse(OptionPriority.COMMAND_LINE, null, Arrays.asList("--first=first"));
+    assertEquals("first", parser.getOptions(ImplicitDependencyOptions.class).first);
+    assertEquals("second", parser.getOptions(ImplicitDependencyOptions.class).second);
+    assertEquals("third", parser.getOptions(ImplicitDependencyOptions.class).third);
+  }
+
+  public static class BadImplicitDependencyOptions extends OptionsBase {
+    @Option(name = "first",
+            implicitRequirements = "xxx",
+            defaultValue = "null")
+    public String first;
+  }
+
+  @Test
+  public void badImplicitDependency() throws Exception {
+    OptionsParser parser = OptionsParser.newOptionsParser(BadImplicitDependencyOptions.class);
+    try {
+      parser.parse(OptionPriority.COMMAND_LINE, null, Arrays.asList("--first=first"));
+    } catch (AssertionError e) {
+      /* Expected error. */
+      return;
+    }
+    fail();
+  }
+
+  public static class BadExpansionOptions extends OptionsBase {
+    @Option(name = "first",
+            expansion = { "xxx" },
+            defaultValue = "null")
+    public Void first;
+  }
+
+  @Test
+  public void badExpansionOptions() throws Exception {
+    OptionsParser parser = OptionsParser.newOptionsParser(BadExpansionOptions.class);
+    try {
+      parser.parse(OptionPriority.COMMAND_LINE, null, Arrays.asList("--first"));
+    } catch (AssertionError e) {
+      /* Expected error. */
+      return;
+    }
+    fail();
+  }
+
+  public static class ExpansionOptions extends OptionsBase {
+    @Option(name = "first",
+            expansion = { "--second=first" },
+            defaultValue = "null")
+    public Void first;
+
+    @Option(name = "second",
+            defaultValue = "null")
+    public String second;
+  }
+
+  @Test
+  public void overrideExpansionWithExplicit() throws Exception {
+    OptionsParser parser = OptionsParser.newOptionsParser(ExpansionOptions.class);
+    parser.parse(OptionPriority.COMMAND_LINE, null, Arrays.asList("--first", "--second=second"));
+    ExpansionOptions options = parser.getOptions(ExpansionOptions.class);
+    assertEquals("second", options.second);
+    assertEquals(0, parser.getWarnings().size());
+  }
+
+  @Test
+  public void overrideExplicitWithExpansion() throws Exception {
+    OptionsParser parser = OptionsParser.newOptionsParser(ExpansionOptions.class);
+    parser.parse(OptionPriority.COMMAND_LINE, null, Arrays.asList("--second=second", "--first"));
+    ExpansionOptions options = parser.getOptions(ExpansionOptions.class);
+    assertEquals("first", options.second);
+  }
+
+  @Test
+  public void overrideWithHigherPriority() throws Exception {
+    OptionsParser parser = OptionsParser.newOptionsParser(NullTestOptions.class);
+    parser.parse(OptionPriority.RC_FILE, null, Arrays.asList("--simple=a"));
+    assertEquals("a", parser.getOptions(NullTestOptions.class).simple);
+    parser.parse(OptionPriority.COMMAND_LINE, null, Arrays.asList("--simple=b"));
+    assertEquals("b", parser.getOptions(NullTestOptions.class).simple);
+  }
+
+  @Test
+  public void overrideWithLowerPriority() throws Exception {
+    OptionsParser parser = OptionsParser.newOptionsParser(NullTestOptions.class);
+    parser.parse(OptionPriority.COMMAND_LINE, null, Arrays.asList("--simple=a"));
+    assertEquals("a", parser.getOptions(NullTestOptions.class).simple);
+    parser.parse(OptionPriority.RC_FILE, null, Arrays.asList("--simple=b"));
+    assertEquals("a", parser.getOptions(NullTestOptions.class).simple);
+  }
+
+  @Test
+  public void getOptionValueDescriptionWithNonExistingOption() throws Exception {
+    OptionsParser parser = OptionsParser.newOptionsParser(NullTestOptions.class);
+    try {
+      parser.getOptionValueDescription("notexisting");
+      fail();
+    } catch (IllegalArgumentException e) {
+      /* Expected exception. */
+    }
+  }
+
+  @Test
+  public void getOptionValueDescriptionWithoutValue() throws Exception {
+    OptionsParser parser = OptionsParser.newOptionsParser(NullTestOptions.class);
+    assertNull(parser.getOptionValueDescription("simple"));
+  }
+
+  @Test
+  public void getOptionValueDescriptionWithValue() throws Exception {
+    OptionsParser parser = OptionsParser.newOptionsParser(NullTestOptions.class);
+    parser.parse(OptionPriority.COMMAND_LINE, "my description",
+        Arrays.asList("--simple=abc"));
+    OptionValueDescription result = parser.getOptionValueDescription("simple");
+    assertNotNull(result);
+    assertEquals("simple", result.getName());
+    assertEquals("abc", result.getValue());
+    assertEquals(OptionPriority.COMMAND_LINE, result.getPriority());
+    assertEquals("my description", result.getSource());
+    assertNull(result.getImplicitDependant());
+    assertFalse(result.isImplicitDependency());
+    assertNull(result.getExpansionParent());
+    assertFalse(result.isExpansion());
+  }
+
+  public static class ImplicitDependencyWarningOptions extends OptionsBase {
+    @Option(name = "first",
+            implicitRequirements = "--second=second",
+            defaultValue = "null")
+    public String first;
+
+    @Option(name = "second",
+        defaultValue = "null")
+    public String second;
+
+    @Option(name = "third",
+            implicitRequirements = "--second=third",
+            defaultValue = "null")
+    public String third;
+  }
+
+  @Test
+  public void warningForImplicitOverridingExplicitOption() throws Exception {
+    OptionsParser parser = OptionsParser.newOptionsParser(ImplicitDependencyWarningOptions.class);
+    parser.parse("--second=second", "--first=first");
+    assertThat(parser.getWarnings())
+        .containsExactly("Option 'second' is implicitly defined by "
+                         + "option 'first'; the implicitly set value overrides the previous one");
+  }
+
+  @Test
+  public void warningForExplicitOverridingImplicitOption() throws Exception {
+    OptionsParser parser = OptionsParser.newOptionsParser(ImplicitDependencyWarningOptions.class);
+    parser.parse("--first=first");
+    assertThat(parser.getWarnings()).isEmpty();
+    parser.parse("--second=second");
+    assertThat(parser.getWarnings())
+        .containsExactly("A new value for option 'second' overrides a"
+                         + " previous implicit setting of that option by option 'first'");
+  }
+
+  @Test
+  public void warningForExplicitOverridingImplicitOptionInSameCall() throws Exception {
+    OptionsParser parser = OptionsParser.newOptionsParser(ImplicitDependencyWarningOptions.class);
+    parser.parse("--first=first", "--second=second");
+    assertThat(parser.getWarnings())
+        .containsExactly("Option 'second' is implicitly defined by "
+                         + "option 'first'; the implicitly set value overrides the previous one");
+  }
+
+  @Test
+  public void warningForImplicitOverridingImplicitOption() throws Exception {
+    OptionsParser parser = OptionsParser.newOptionsParser(ImplicitDependencyWarningOptions.class);
+    parser.parse("--first=first");
+    assertThat(parser.getWarnings()).isEmpty();
+    parser.parse("--third=third");
+    assertThat(parser.getWarnings())
+        .containsExactly("Option 'second' is implicitly defined by both "
+                         + "option 'first' and option 'third'");
+  }
+
+  public static class WarningOptions extends OptionsBase {
+    @Deprecated
+    @Option(name = "first",
+            defaultValue = "null")
+    public Void first;
+
+    @Deprecated
+    @Option(name = "second",
+            allowMultiple = true,
+            defaultValue = "null")
+    public List<String> second;
+
+    @Deprecated
+    @Option(name = "third",
+            expansion = "--fourth=true",
+            abbrev = 't',
+            defaultValue = "null")
+    public Void third;
+
+    @Option(name = "fourth",
+            defaultValue = "false")
+    public boolean fourth;
+  }
+
+  @Test
+  public void deprecationWarning() throws Exception {
+    OptionsParser parser = OptionsParser.newOptionsParser(WarningOptions.class);
+    parser.parse(OptionPriority.COMMAND_LINE, null, Arrays.asList("--first"));
+    assertEquals(Arrays.asList("Option 'first' is deprecated"), parser.getWarnings());
+  }
+
+  @Test
+  public void deprecationWarningForListOption() throws Exception {
+    OptionsParser parser = OptionsParser.newOptionsParser(WarningOptions.class);
+    parser.parse(OptionPriority.COMMAND_LINE, null, Arrays.asList("--second=a"));
+    assertEquals(Arrays.asList("Option 'second' is deprecated"), parser.getWarnings());
+  }
+
+  @Test
+  public void deprecationWarningForExpansionOption() throws Exception {
+    OptionsParser parser = OptionsParser.newOptionsParser(WarningOptions.class);
+    parser.parse(OptionPriority.COMMAND_LINE, null, Arrays.asList("--third"));
+    assertEquals(Arrays.asList("Option 'third' is deprecated"), parser.getWarnings());
+    assertTrue(parser.getOptions(WarningOptions.class).fourth);
+  }
+
+  @Test
+  public void deprecationWarningForAbbreviatedExpansionOption() throws Exception {
+    OptionsParser parser = OptionsParser.newOptionsParser(WarningOptions.class);
+    parser.parse(OptionPriority.COMMAND_LINE, null, Arrays.asList("-t"));
+    assertEquals(Arrays.asList("Option 'third' is deprecated"), parser.getWarnings());
+    assertTrue(parser.getOptions(WarningOptions.class).fourth);
+  }
+
+  public static class NewWarningOptions extends OptionsBase {
+    @Option(name = "first",
+            defaultValue = "null",
+            deprecationWarning = "it's gone")
+    public Void first;
+
+    @Option(name = "second",
+            allowMultiple = true,
+            defaultValue = "null",
+            deprecationWarning = "sorry, no replacement")
+    public List<String> second;
+
+    @Option(name = "third",
+            expansion = "--fourth=true",
+            defaultValue = "null",
+            deprecationWarning = "use --forth instead")
+    public Void third;
+
+    @Option(name = "fourth",
+            defaultValue = "false")
+    public boolean fourth;
+  }
+
+  @Test
+  public void newDeprecationWarning() throws Exception {
+    OptionsParser parser = OptionsParser.newOptionsParser(NewWarningOptions.class);
+    parser.parse(OptionPriority.COMMAND_LINE, null, Arrays.asList("--first"));
+    assertEquals(Arrays.asList("Option 'first' is deprecated: it's gone"), parser.getWarnings());
+  }
+
+  @Test
+  public void newDeprecationWarningForListOption() throws Exception {
+    OptionsParser parser = OptionsParser.newOptionsParser(NewWarningOptions.class);
+    parser.parse(OptionPriority.COMMAND_LINE, null, Arrays.asList("--second=a"));
+    assertEquals(Arrays.asList("Option 'second' is deprecated: sorry, no replacement"),
+        parser.getWarnings());
+  }
+
+  @Test
+  public void newDeprecationWarningForExpansionOption() throws Exception {
+    OptionsParser parser = OptionsParser.newOptionsParser(NewWarningOptions.class);
+    parser.parse(OptionPriority.COMMAND_LINE, null, Arrays.asList("--third"));
+    assertEquals(Arrays.asList("Option 'third' is deprecated: use --forth instead"),
+        parser.getWarnings());
+    assertTrue(parser.getOptions(NewWarningOptions.class).fourth);
+  }
+
+  public static class ExpansionWarningOptions extends OptionsBase {
+    @Option(name = "first",
+            expansion = "--second=other",
+            defaultValue = "null")
+    public Void first;
+
+    @Option(name = "second",
+            defaultValue = "null")
+    public String second;
+  }
+
+  @Test
+  public void warningForExpansionOverridingExplicitOption() throws Exception {
+    OptionsParser parser = OptionsParser.newOptionsParser(ExpansionWarningOptions.class);
+    parser.parse("--second=second", "--first");
+    assertThat(parser.getWarnings())
+        .containsExactly("The option 'first' was expanded and now overrides a "
+                         + "previous explicitly specified option 'second'");
+  }
+
+  public static class InvalidOptionConverter extends OptionsBase {
+    @Option(name = "foo",
+            converter = StringConverter.class,
+            defaultValue = "1")
+    public Integer foo;
+  }
+
+  @Test
+  public void errorForInvalidOptionConverter() throws Exception {
+    try {
+      OptionsParser.newOptionsParser(InvalidOptionConverter.class);
+    } catch (AssertionError e) {
+      // Expected exception
+      return;
+    }
+    fail();
+  }
+
+  public static class InvalidListOptionConverter extends OptionsBase {
+    @Option(name = "foo",
+            converter = StringConverter.class,
+            defaultValue = "1",
+            allowMultiple = true)
+    public List<Integer> foo;
+  }
+
+  @Test
+  public void errorForInvalidListOptionConverter() throws Exception {
+    try {
+      OptionsParser.newOptionsParser(InvalidListOptionConverter.class);
+    } catch (AssertionError e) {
+      // Expected exception
+      return;
+    }
+    fail();
+  }
+
+  // This test is here to make sure that nobody accidentally changes the
+  // order of the enum values and breaks the implicit assumptions elsewhere
+  // in the code.
+  @Test
+  public void optionPrioritiesAreCorrectlyOrdered() throws Exception {
+    assertEquals(5, OptionPriority.values().length);
+    assertEquals(-1, OptionPriority.DEFAULT.compareTo(OptionPriority.COMPUTED_DEFAULT));
+    assertEquals(-1, OptionPriority.COMPUTED_DEFAULT.compareTo(OptionPriority.RC_FILE));
+    assertEquals(-1, OptionPriority.RC_FILE.compareTo(OptionPriority.COMMAND_LINE));
+    assertEquals(-1, OptionPriority.COMMAND_LINE.compareTo(OptionPriority.SOFTWARE_REQUIREMENT));
+  }
+
+  public static class IntrospectionExample extends OptionsBase {
+    @Option(name = "alpha",
+            category = "one",
+            defaultValue = "alpha")
+    public String alpha;
+
+    @Option(name = "beta",
+            category = "one",
+            defaultValue = "beta")
+    public String beta;
+
+    @Option(name = "gamma",
+        category = "undocumented",
+        defaultValue = "gamma")
+    public String gamma;
+
+    @Option(name = "delta",
+        category = "undocumented",
+        defaultValue = "delta")
+    public String delta;
+
+    @Option(name = "echo",
+        category = "hidden",
+        defaultValue = "echo")
+    public String echo;
+  }
+
+  @Test
+  public void asListOfUnparsedOptions() throws Exception {
+    OptionsParser parser = OptionsParser.newOptionsParser(IntrospectionExample.class);
+    parser.parse(OptionPriority.COMMAND_LINE, "source",
+        Arrays.asList("--alpha=one", "--gamma=two", "--echo=three"));
+    List<UnparsedOptionValueDescription> result = parser.asListOfUnparsedOptions();
+    assertNotNull(result);
+    assertEquals(3, result.size());
+
+    assertEquals("alpha", result.get(0).getName());
+    assertEquals(true, result.get(0).isDocumented());
+    assertEquals(false, result.get(0).isHidden());
+    assertEquals("one", result.get(0).getUnparsedValue());
+    assertEquals("source", result.get(0).getSource());
+    assertEquals(OptionPriority.COMMAND_LINE, result.get(0).getPriority());
+
+    assertEquals("gamma", result.get(1).getName());
+    assertEquals(false, result.get(1).isDocumented());
+    assertEquals(false, result.get(1).isHidden());
+    assertEquals("two", result.get(1).getUnparsedValue());
+    assertEquals("source", result.get(1).getSource());
+    assertEquals(OptionPriority.COMMAND_LINE, result.get(1).getPriority());
+
+    assertEquals("echo", result.get(2).getName());
+    assertEquals(false, result.get(2).isDocumented());
+    assertEquals(true, result.get(2).isHidden());
+    assertEquals("three", result.get(2).getUnparsedValue());
+    assertEquals("source", result.get(2).getSource());
+    assertEquals(OptionPriority.COMMAND_LINE, result.get(2).getPriority());
+  }
+
+  @Test
+  public void asListOfExplicitOptions() throws Exception {
+    OptionsParser parser = OptionsParser.newOptionsParser(IntrospectionExample.class);
+    parser.parse(OptionPriority.COMMAND_LINE, "source",
+        Arrays.asList("--alpha=one", "--gamma=two"));
+    List<UnparsedOptionValueDescription> result = parser.asListOfExplicitOptions();
+    assertNotNull(result);
+    assertEquals(2, result.size());
+
+    assertEquals("alpha", result.get(0).getName());
+    assertEquals(true, result.get(0).isDocumented());
+    assertEquals("one", result.get(0).getUnparsedValue());
+    assertEquals("source", result.get(0).getSource());
+    assertEquals(OptionPriority.COMMAND_LINE, result.get(0).getPriority());
+
+    assertEquals("gamma", result.get(1).getName());
+    assertEquals(false, result.get(1).isDocumented());
+    assertEquals("two", result.get(1).getUnparsedValue());
+    assertEquals("source", result.get(1).getSource());
+    assertEquals(OptionPriority.COMMAND_LINE, result.get(1).getPriority());
+  }
+
+  private void assertOptionValue(String expectedName, Object expectedValue,
+      OptionPriority expectedPriority, String expectedSource,
+      OptionValueDescription actual) {
+    assertNotNull(actual);
+    assertEquals(expectedName, actual.getName());
+    assertEquals(expectedValue, actual.getValue());
+    assertEquals(expectedPriority, actual.getPriority());
+    assertEquals(expectedSource, actual.getSource());
+  }
+
+  @Test
+  public void asListOfEffectiveOptions() throws Exception {
+    OptionsParser parser = OptionsParser.newOptionsParser(IntrospectionExample.class);
+    parser.parse(OptionPriority.COMMAND_LINE, "source",
+        Arrays.asList("--alpha=one", "--gamma=two"));
+    List<OptionValueDescription> result = parser.asListOfEffectiveOptions();
+    assertNotNull(result);
+    assertEquals(5, result.size());
+    HashMap<String,OptionValueDescription> map = new HashMap<String,OptionValueDescription>();
+    for (OptionValueDescription description : result) {
+      map.put(description.getName(), description);
+    }
+
+    assertOptionValue("alpha", "one", OptionPriority.COMMAND_LINE, "source",
+        map.get("alpha"));
+    assertOptionValue("beta", "beta", OptionPriority.DEFAULT, null,
+        map.get("beta"));
+    assertOptionValue("gamma", "two", OptionPriority.COMMAND_LINE, "source",
+        map.get("gamma"));
+    assertOptionValue("delta", "delta", OptionPriority.DEFAULT, null,
+        map.get("delta"));
+    assertOptionValue("echo", "echo", OptionPriority.DEFAULT, null,
+        map.get("echo"));
+  }
+
+  // Regression tests for bug:
+  // "--option from blazerc unexpectedly overrides --option from command line"
+  public static class ListExample extends OptionsBase {
+    @Option(name = "alpha",
+            converter = StringConverter.class,
+            allowMultiple = true,
+            defaultValue = "null")
+    public List<String> alpha;
+  }
+
+  @Test
+  public void overrideListOptions() throws Exception {
+    OptionsParser parser = OptionsParser.newOptionsParser(ListExample.class);
+    parser.parse(OptionPriority.COMMAND_LINE, "a", Arrays.asList("--alpha=two"));
+    parser.parse(OptionPriority.RC_FILE, "b", Arrays.asList("--alpha=one"));
+    assertEquals(Arrays.asList("one", "two"), parser.getOptions(ListExample.class).alpha);
+  }
+
+  public static class CommaSeparatedOptionsExample extends OptionsBase {
+    @Option(name = "alpha",
+            converter = CommaSeparatedOptionListConverter.class,
+            allowMultiple = true,
+            defaultValue = "null")
+    public List<String> alpha;
+  }
+
+  @Test
+  public void commaSeparatedOptionsWithAllowMultiple() throws Exception {
+    OptionsParser parser = OptionsParser.newOptionsParser(CommaSeparatedOptionsExample.class);
+    parser.parse(OptionPriority.COMMAND_LINE, "a", Arrays.asList("--alpha=one",
+        "--alpha=two,three"));
+    assertEquals(Arrays.asList("one", "two", "three"),
+        parser.getOptions(CommaSeparatedOptionsExample.class).alpha);
+  }
+
+  public static class IllegalListTypeExample extends OptionsBase {
+    @Option(name = "alpha",
+            converter = CommaSeparatedOptionListConverter.class,
+            allowMultiple = true,
+            defaultValue = "null")
+    public List<Integer> alpha;
+  }
+
+  @Test
+  public void illegalListType() throws Exception {
+    try {
+      OptionsParser.newOptionsParser(IllegalListTypeExample.class);
+    } catch (AssertionError e) {
+      // Expected exception
+      return;
+    }
+    fail();
+  }
+
+  public static class Yesterday extends OptionsBase {
+
+    @Option(name = "a",
+            defaultValue = "a")
+    public String a;
+
+    @Option(name = "b",
+            defaultValue = "b")
+    public String b;
+
+    @Option(name = "c",
+            defaultValue = "null",
+            expansion = {"--a=0"})
+    public Void c;
+
+    @Option(name = "d",
+            defaultValue = "null",
+            allowMultiple = true)
+    public List<String> d;
+
+    @Option(name = "e",
+            defaultValue = "null",
+            implicitRequirements = { "--a==1" })
+    public String e;
+
+    @Option(name = "f",
+            defaultValue = "null",
+            implicitRequirements = { "--b==1" })
+    public String f;
+
+    @Option(name = "g",
+            abbrev = 'h',
+            defaultValue = "false")
+    public boolean g;
+  }
+
+  public static List<String> canonicalize(Class<? extends OptionsBase> optionsClass, String... args)
+      throws OptionsParsingException {
+    return OptionsParser.canonicalize(ImmutableList.<Class<? extends OptionsBase>>of(optionsClass),
+        Arrays.asList(args));
+  }
+
+  @Test
+  public void canonicalizeEasy() throws Exception {
+    assertEquals(Arrays.asList("--a=x"), canonicalize(Yesterday.class, "--a=x"));
+  }
+
+  @Test
+  public void canonicalizeSkipDuplicate() throws Exception {
+    assertEquals(Arrays.asList("--a=x"), canonicalize(Yesterday.class, "--a=y", "--a=x"));
+  }
+
+  @Test
+  public void canonicalizeExpands() throws Exception {
+    assertEquals(Arrays.asList("--a=0"), canonicalize(Yesterday.class, "--c"));
+  }
+
+  @Test
+  public void canonicalizeExpansionOverridesExplicit() throws Exception {
+    assertEquals(Arrays.asList("--a=0"), canonicalize(Yesterday.class, "--a=x", "--c"));
+  }
+
+  @Test
+  public void canonicalizeExplicitOverridesExpansion() throws Exception {
+    assertEquals(Arrays.asList("--a=x"), canonicalize(Yesterday.class, "--c", "--a=x"));
+  }
+
+  @Test
+  public void canonicalizeSorts() throws Exception {
+    assertEquals(Arrays.asList("--a=x", "--b=y"), canonicalize(Yesterday.class, "--b=y", "--a=x"));
+  }
+
+  @Test
+  public void canonicalizeImplicitDepsAtEnd() throws Exception {
+    assertEquals(Arrays.asList("--a=x", "--e=y"), canonicalize(Yesterday.class, "--e=y", "--a=x"));
+  }
+
+  @Test
+  public void canonicalizeImplicitDepsSkipsDuplicate() throws Exception {
+    assertEquals(Arrays.asList("--e=y"), canonicalize(Yesterday.class, "--e=x", "--e=y"));
+  }
+
+  @Test
+  public void canonicalizeDoesNotSortImplicitDeps() throws Exception {
+    assertEquals(Arrays.asList("--a=x", "--f=z", "--e=y"),
+        canonicalize(Yesterday.class, "--f=z", "--e=y", "--a=x"));
+  }
+
+  @Test
+  public void canonicalizeDoesNotSkipAllowMultiple() throws Exception {
+    assertEquals(Arrays.asList("--d=a", "--d=b"),
+        canonicalize(Yesterday.class, "--d=a", "--d=b"));
+  }
+
+  @Test
+  public void canonicalizeReplacesAbbrevWithName() throws Exception {
+    assertEquals(Arrays.asList("--g=1"),
+        canonicalize(Yesterday.class, "-h"));
+  }
+
+  public static class LongValueExample extends OptionsBase {
+    @Option(name = "longval",
+            defaultValue = "2147483648")
+    public long longval;
+
+    @Option(name = "intval",
+            defaultValue = "2147483647")
+    public int intval;
+  }
+
+  @Test
+  public void parseLong() throws OptionsParsingException {
+    OptionsParser parser = newOptionsParser(LongValueExample.class);
+    parser.parse("");
+    LongValueExample result = parser.getOptions(LongValueExample.class);
+    assertEquals(2147483648L, result.longval);
+    assertEquals(2147483647, result.intval);
+
+    parser.parse("--longval", Long.toString(Long.MIN_VALUE));
+    result = parser.getOptions(LongValueExample.class);
+    assertEquals(Long.MIN_VALUE, result.longval);
+
+    try {
+      parser.parse("--intval=2147483648");
+      fail();
+    } catch (OptionsParsingException e) {
+    }
+
+    parser.parse("--longval", "100");
+    result = parser.getOptions(LongValueExample.class);
+    assertEquals(100, result.longval);
+  }
+}
diff --git a/src/test/java/com/google/devtools/common/options/OptionsTest.java b/src/test/java/com/google/devtools/common/options/OptionsTest.java
new file mode 100644
index 0000000..700e26b
--- /dev/null
+++ b/src/test/java/com/google/devtools/common/options/OptionsTest.java
@@ -0,0 +1,500 @@
+// Copyright 2014 Google Inc. 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.common.options;
+
+import static com.google.common.truth.Truth.assertThat;
+import static java.util.Arrays.asList;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.net.MalformedURLException;
+import java.net.URL;
+
+/**
+ * Test for {@link Options}.
+ */
+@RunWith(JUnit4.class)
+public class OptionsTest {
+
+  private static final String[] NO_ARGS = {};
+
+  public static class HttpOptions extends OptionsBase {
+
+    @Option(name = "host",
+            defaultValue = "www.google.com",
+            help = "The URL at which the server will be running.")
+    public String host;
+
+    @Option(name = "port",
+            abbrev = 'p',
+            defaultValue = "80",
+            help = "The port at which the server will be running.")
+    public int port;
+
+    @Option(name = "debug",
+            abbrev = 'd',
+            defaultValue = "false",
+            help = "debug")
+    public boolean isDebugging;
+
+    @Option(name = "tristate",
+        abbrev = 't',
+        defaultValue = "auto",
+        help = "tri-state option returning auto by default")
+    public TriState triState;
+
+    @Option(name = "special",
+            defaultValue = "null",
+            expansion = { "--host=special.google.com", "--port=8080"})
+    public Void special;
+  }
+
+  @Test
+  public void paragraphFill() throws Exception {
+    // TODO(bazel-team): don't include trailing space after last word in line.
+    String input = "The quick brown fox jumps over the lazy dog.";
+
+    assertEquals("  The quick \n  brown fox \n  jumps over \n  the lazy \n"
+                 + "  dog.",
+                 OptionsUsage.paragraphFill(input, 2, 13));
+    assertEquals("   The quick brown \n   fox jumps over \n   the lazy dog.",
+                 OptionsUsage.paragraphFill(input, 3, 19));
+
+    String input2 = "The quick brown fox jumps\nAnother paragraph.";
+    assertEquals("  The quick brown fox \n  jumps\n  Another paragraph.",
+                 OptionsUsage.paragraphFill(input2, 2, 23));
+  }
+
+  @Test
+  public void getsDefaults() throws OptionsParsingException {
+    Options<HttpOptions> options = Options.parse(HttpOptions.class, NO_ARGS);
+    String[] remainingArgs = options.getRemainingArgs();
+    HttpOptions webFlags = options.getOptions();
+
+    assertEquals("www.google.com", webFlags.host);
+    assertEquals(80, webFlags.port);
+    assertEquals(false, webFlags.isDebugging);
+    assertEquals(TriState.AUTO, webFlags.triState);
+    assertEquals(0, remainingArgs.length);
+  }
+
+  @Test
+  public void objectMethods() throws OptionsParsingException {
+    String[] args = { "--host", "foo", "--port", "80" };
+    HttpOptions left =
+        Options.parse(HttpOptions.class, args).getOptions();
+    HttpOptions likeLeft =
+        Options.parse(HttpOptions.class, args).getOptions();
+    String [] rightArgs = {"--host", "other", "--port", "90" };
+    HttpOptions right =
+        Options.parse(HttpOptions.class, rightArgs).getOptions();
+
+    String toString = left.toString();
+    // Don't rely on Set.toString iteration order:
+    assertTrue(toString.startsWith(
+                   "com.google.devtools.common.options.OptionsTest"
+                   + "$HttpOptions{"));
+    assertTrue(toString.contains("host=foo"));
+    assertTrue(toString.contains("port=80"));
+    assertTrue(toString.endsWith("}"));
+
+    assertTrue(left.equals(left));
+    assertTrue(left.toString().equals(likeLeft.toString()));
+    assertTrue(left.equals(likeLeft));
+    assertTrue(likeLeft.equals(left));
+    assertFalse(left.equals(right));
+    assertFalse(right.equals(left));
+    assertFalse(left.equals(null));
+    assertFalse(likeLeft.equals(null));
+    assertEquals(likeLeft.hashCode(), likeLeft.hashCode());
+    assertEquals(left.hashCode(), likeLeft.hashCode());
+    // Strictly speaking this is not required for hashCode to be correct,
+    // but a good hashCode should be different at least for some values. So,
+    // we're making sure that at least this particular pair of inputs yields
+    // different values.
+    assertFalse(left.hashCode() == right.hashCode());
+  }
+
+  @Test
+  public void equals() throws OptionsParsingException {
+    String[] args = { "--host", "foo", "--port", "80" };
+    HttpOptions options1 =  Options.parse(HttpOptions.class, args).getOptions();
+
+    String[] args2 = { "-p", "80", "--host", "foo" };
+    HttpOptions options2 =  Options.parse(HttpOptions.class, args2).getOptions();
+    assertEquals("order/abbreviations shouldn't matter", options1, options2);
+
+    assertEquals("explicitly setting a default shouldn't matter",
+        Options.parse(HttpOptions.class, "--port", "80").getOptions(),
+        Options.parse(HttpOptions.class).getOptions());
+
+    assertThat(Options.parse(HttpOptions.class, "--port", "3").getOptions())
+        .isNotEqualTo(Options.parse(HttpOptions.class).getOptions());
+  }
+
+  @Test
+  public void getsFlagsProvidedInArguments()
+      throws OptionsParsingException {
+    String[] args = {"--host", "google.com",
+                     "-p", "8080",  // short form
+                     "--debug"};
+    Options<HttpOptions> options = Options.parse(HttpOptions.class, args);
+    String[] remainingArgs = options.getRemainingArgs();
+    HttpOptions webFlags = options.getOptions();
+
+    assertEquals("google.com", webFlags.host);
+    assertEquals(8080, webFlags.port);
+    assertEquals(true, webFlags.isDebugging);
+    assertEquals(0, remainingArgs.length);
+  }
+
+  @Test
+  public void getsFlagsProvidedWithEquals() throws OptionsParsingException {
+    String[] args = {"--host=google.com",
+                     "--port=8080",
+                     "--debug"};
+    Options<HttpOptions> options = Options.parse(HttpOptions.class, args);
+    String[] remainingArgs = options.getRemainingArgs();
+    HttpOptions webFlags = options.getOptions();
+
+    assertEquals("google.com", webFlags.host);
+    assertEquals(8080, webFlags.port);
+    assertEquals(true, webFlags.isDebugging);
+    assertEquals(0, remainingArgs.length);
+  }
+
+  @Test
+  public void booleanNo() throws OptionsParsingException {
+    Options<HttpOptions> options =
+        Options.parse(HttpOptions.class, new String[]{"--nodebug", "--notristate"});
+    HttpOptions webFlags = options.getOptions();
+    assertEquals(false, webFlags.isDebugging);
+    assertEquals(TriState.NO, webFlags.triState);
+  }
+
+  @Test
+  public void booleanNoUnderscore() throws OptionsParsingException {
+    Options<HttpOptions> options =
+        Options.parse(HttpOptions.class, new String[]{"--no_debug", "--no_tristate"});
+    HttpOptions webFlags = options.getOptions();
+    assertEquals(false, webFlags.isDebugging);
+    assertEquals(TriState.NO, webFlags.triState);
+  }
+
+  @Test
+  public void booleanAbbrevMinus() throws OptionsParsingException {
+    Options<HttpOptions> options =
+        Options.parse(HttpOptions.class, new String[]{"-d-", "-t-"});
+    HttpOptions webFlags = options.getOptions();
+    assertEquals(false, webFlags.isDebugging);
+    assertEquals(TriState.NO, webFlags.triState);
+  }
+
+  @Test
+  public void boolean0() throws OptionsParsingException {
+    Options<HttpOptions> options =
+        Options.parse(HttpOptions.class, new String[]{"--debug=0", "--tristate=0"});
+    HttpOptions webFlags = options.getOptions();
+    assertEquals(false, webFlags.isDebugging);
+    assertEquals(TriState.NO, webFlags.triState);
+  }
+
+  @Test
+  public void boolean1() throws OptionsParsingException {
+    Options<HttpOptions> options =
+        Options.parse(HttpOptions.class, new String[]{"--debug=1", "--tristate=1"});
+    HttpOptions webFlags = options.getOptions();
+    assertEquals(true, webFlags.isDebugging);
+    assertEquals(TriState.YES, webFlags.triState);
+  }
+
+  @Test
+  public void retainsStuffThatsNotOptions() throws OptionsParsingException {
+    String[] args = {"these", "aint", "options"};
+    Options<HttpOptions> options = Options.parse(HttpOptions.class, args);
+    String[] remainingArgs = options.getRemainingArgs();
+    assertEquals(asList(args), asList(remainingArgs));
+  }
+
+  @Test
+  public void retainsStuffThatsNotComplexOptions()
+      throws OptionsParsingException {
+    String[] args = {"--host", "google.com",
+                     "notta",
+                     "--port=8080",
+                     "option",
+                     "--debug=true"};
+    String[] notoptions = {"notta", "option" };
+    Options<HttpOptions> options = Options.parse(HttpOptions.class, args);
+    String[] remainingArgs = options.getRemainingArgs();
+    assertEquals(asList(notoptions), asList(remainingArgs));
+  }
+
+  @Test
+  public void wontParseUnknownOptions() {
+    String [] args = { "--unknown", "--other=23", "--options" };
+    try {
+      Options.parse(HttpOptions.class, args);
+      fail();
+    } catch (OptionsParsingException e) {
+      assertEquals("Unrecognized option: --unknown", e.getMessage());
+    }
+  }
+
+  @Test
+  public void requiresOptionValue() {
+    String[] args = {"--port"};
+    try {
+      Options.parse(HttpOptions.class, args);
+      fail();
+    } catch (OptionsParsingException e) {
+      assertEquals("Expected value after --port", e.getMessage());
+    }
+  }
+
+  @Test
+  public void handlesDuplicateOptions_full() throws Exception {
+    String[] args = {"--port=80", "--port", "81"};
+    Options<HttpOptions> options = Options.parse(HttpOptions.class, args);
+    HttpOptions webFlags = options.getOptions();
+    assertEquals(81, webFlags.port);
+  }
+
+  @Test
+  public void handlesDuplicateOptions_abbrev() throws Exception {
+    String[] args = {"--port=80", "-p", "81"};
+    Options<HttpOptions> options = Options.parse(HttpOptions.class, args);
+    HttpOptions webFlags = options.getOptions();
+    assertEquals(81, webFlags.port);
+  }
+
+  @Test
+  public void duplicateOptionsOkWithSameValues() throws Exception {
+    // These would throw OptionsParsingException if they failed.
+    Options.parse(HttpOptions.class,"--port=80", "--port", "80");
+    Options.parse(HttpOptions.class, "--port=80", "-p", "80");
+  }
+
+  @Test
+  public void isPickyAboutBooleanValues() {
+    try {
+      Options.parse(HttpOptions.class, new String[]{"--debug=not_a_boolean"});
+      fail();
+    } catch (OptionsParsingException e) {
+      assertEquals("While parsing option --debug=not_a_boolean: "
+                   + "\'not_a_boolean\' is not a boolean", e.getMessage());
+    }
+  }
+
+  @Test
+  public void isPickyAboutBooleanNos() {
+    try {
+      Options.parse(HttpOptions.class, new String[]{"--nodebug=1"});
+      fail();
+    } catch (OptionsParsingException e) {
+      assertEquals("Unexpected value after boolean option: --nodebug=1", e.getMessage());
+    }
+  }
+
+  @Test
+  public void usageForBuiltinTypes() {
+    String usage = Options.getUsage(HttpOptions.class);
+    // We can't rely on the option ordering.
+    assertTrue(usage.contains(
+            "  --[no]debug [-d] (a boolean; default: \"false\")\n" +
+            "    debug"));
+    assertTrue(usage.contains(
+            "  --host (a string; default: \"www.google.com\")\n" +
+            "    The URL at which the server will be running."));
+    assertTrue(usage.contains(
+            "  --port [-p] (an integer; default: \"80\")\n" +
+            "    The port at which the server will be running."));
+    assertTrue(usage.contains(
+            "  --special\n" +
+            "    Expands to: --host=special.google.com --port=8080"));
+    assertTrue(usage.contains(
+        "  --[no]tristate [-t] (a tri-state (auto, yes, no); default: \"auto\")\n" +
+        "    tri-state option returning auto by default"));
+  }
+
+  public static class NullTestOptions extends OptionsBase {
+    @Option(name = "host",
+            defaultValue = "null",
+            help = "The URL at which the server will be running.")
+    public String host;
+
+    @Option(name = "none",
+        defaultValue = "null",
+        expansion = {"--host=www.google.com"},
+        help = "An expanded option.")
+    public Void none;
+  }
+
+  @Test
+  public void usageForNullDefault() {
+    String usage = Options.getUsage(NullTestOptions.class);
+    assertTrue(usage.contains(
+            "  --host (a string; default: see description)\n" +
+            "    The URL at which the server will be running."));
+    assertTrue(usage.contains(
+            "  --none\n" +
+            "    An expanded option.\n" +
+            "    Expands to: --host=www.google.com"));
+  }
+
+  public static class MyURLConverter implements Converter<URL> {
+
+    @Override
+    public URL convert(String input) throws OptionsParsingException {
+      try {
+        return new URL(input);
+      } catch (MalformedURLException e) {
+        throw new OptionsParsingException("Could not convert '" + input + "': "
+                                          + e.getMessage());
+      }
+    }
+
+    @Override
+    public String getTypeDescription() {
+      return "a url";
+    }
+
+  }
+
+  public static class UsesCustomConverter extends OptionsBase {
+
+    @Option(name = "url",
+            defaultValue = "http://www.google.com/",
+            converter = MyURLConverter.class)
+    public URL url;
+
+  }
+
+  @Test
+  public void customConverter() throws Exception {
+    Options<UsesCustomConverter> options =
+      Options.parse(UsesCustomConverter.class, new String[0]);
+    URL expected = new URL("http://www.google.com/");
+    assertEquals(expected, options.getOptions().url);
+  }
+
+  @Test
+  public void customConverterThrowsException() throws Exception {
+    String[] args = {"--url=a_malformed:url"};
+    try {
+      Options.parse(UsesCustomConverter.class, args);
+      fail();
+    } catch (OptionsParsingException e) {
+      assertEquals("While parsing option --url=a_malformed:url: "
+                   + "Could not convert 'a_malformed:url': "
+                   + "no protocol: a_malformed:url", e.getMessage());
+    }
+  }
+
+  @Test
+  public void usageWithCustomConverter() {
+    assertEquals(
+        "  --url (a url; default: \"http://www.google.com/\")\n",
+        Options.getUsage(UsesCustomConverter.class));
+  }
+
+  @Test
+  public void unknownBooleanOption() {
+    try {
+      Options.parse(HttpOptions.class, new String[]{"--no-debug"});
+      fail();
+    } catch (OptionsParsingException e) {
+      assertEquals("Unrecognized option: --no-debug", e.getMessage());
+    }
+  }
+
+  public static class J extends OptionsBase {
+    @Option(name = "j", defaultValue = "null")
+    public String string;
+  }
+  @Test
+  public void nullDefaultForReferenceTypeOption() throws Exception {
+    J options = Options.parse(J.class, NO_ARGS).getOptions();
+    assertNull(options.string);
+  }
+
+  public static class K extends OptionsBase {
+    @Option(name = "1", defaultValue = "null")
+    public int int1;
+  }
+  @Test
+  public void nullDefaultForPrimitiveTypeOption() throws Exception {
+    // defaultValue() = "null" is not treated specially for primitive types, so
+    // we get an NumberFormatException from the converter (not a
+    // ClassCastException from casting null to int), just as we would for any
+    // other non-integer-literal string default.
+    try {
+      Options.parse(K.class, NO_ARGS).getOptions();
+      fail();
+    } catch (IllegalStateException e) {
+      assertEquals("OptionsParsingException while retrieving default for "
+                   + "int1: 'null' is not an int",
+                   e.getMessage());
+    }
+  }
+
+  @Test
+  public void nullIsntInterpretedSpeciallyExceptAsADefaultValue()
+      throws Exception {
+    HttpOptions options =
+        Options.parse(HttpOptions.class,
+                      new String[] { "--host", "null" }).getOptions();
+    assertEquals("null", options.host);
+  }
+
+  @Test
+  public void nonDecimalRadicesForIntegerOptions() throws Exception {
+    Options<HttpOptions> options =
+        Options.parse(HttpOptions.class, new String[] { "--port", "0x51"});
+    assertEquals(81, options.getOptions().port);
+  }
+
+  @Test
+  public void expansionOptionSimple() throws Exception {
+    Options<HttpOptions> options =
+      Options.parse(HttpOptions.class, new String[] {"--special"});
+    assertEquals("special.google.com", options.getOptions().host);
+    assertEquals(8080, options.getOptions().port);
+  }
+
+  @Test
+  public void expansionOptionOverride() throws Exception {
+    Options<HttpOptions> options =
+      Options.parse(HttpOptions.class, new String[] {"--port=90", "--special", "--host=foo"});
+    assertEquals("foo", options.getOptions().host);
+    assertEquals(8080, options.getOptions().port);
+  }
+
+  @Test
+  public void expansionOptionEquals() throws Exception {
+    Options<HttpOptions> options1 =
+      Options.parse(HttpOptions.class, new String[] { "--host=special.google.com", "--port=8080"});
+    Options<HttpOptions> options2 =
+      Options.parse(HttpOptions.class, new String[] { "--special" });
+    assertEquals(options1.getOptions(), options2.getOptions());
+  }
+}