Make `MemoizingEvaluatorTest.java` compliant with the formatter.
This way the diffs of my future CLs won't be cluttered by changes to make the formatter happy.
PiperOrigin-RevId: 414475990
diff --git a/src/test/java/com/google/devtools/build/skyframe/MemoizingEvaluatorTest.java b/src/test/java/com/google/devtools/build/skyframe/MemoizingEvaluatorTest.java
index f072e6a..15690fe 100644
--- a/src/test/java/com/google/devtools/build/skyframe/MemoizingEvaluatorTest.java
+++ b/src/test/java/com/google/devtools/build/skyframe/MemoizingEvaluatorTest.java
@@ -76,7 +76,7 @@
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
-/** Tests for {@link MemoizingEvaluator}.*/
+/** Tests for {@link MemoizingEvaluator}. */
@RunWith(JUnit4.class)
public class MemoizingEvaluatorTest {
@@ -253,29 +253,36 @@
// 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("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"));
@@ -447,8 +454,12 @@
@Test
public void deleteValues() throws Exception {
- tester.getOrCreate("top").setComputedValue(CONCATENATE)
- .addDependency("d1").addDependency("d2").addDependency("d3");
+ 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);
@@ -510,7 +521,7 @@
SkyKey topKey = GraphTester.skyKey("topKey");
tester.getOrCreate(topKey).addDependency(leafKey).setComputedValue(CONCATENATE);
- assertThat(tester.evalAndGet(/*keepGoing=*/false, topKey)).isEqualTo(new StringValue("value"));
+ assertThat(tester.evalAndGet(/*keepGoing=*/ false, topKey)).isEqualTo(new StringValue("value"));
failBuildAndRemoveValue(leafKey);
tester.evaluator.deleteDirty(0);
}
@@ -525,8 +536,11 @@
@Test
public void signalValueEnqueued() throws Exception {
- tester.getOrCreate("top1").setComputedValue(CONCATENATE)
- .addDependency("d1").addDependency("d2");
+ tester
+ .getOrCreate("top1")
+ .setComputedValue(CONCATENATE)
+ .addDependency("d1")
+ .addDependency("d2");
tester.getOrCreate("top2").setComputedValue(CONCATENATE).addDependency("d3");
tester.getOrCreate("top3");
assertThat(tester.getEnqueuedValues()).isEmpty();
@@ -540,8 +554,8 @@
tester.eval(true, "top2");
assertThat(tester.getEnqueuedValues())
- .containsExactlyElementsIn(MemoizingEvaluatorTester.toSkyKeys(
- "top1", "d1", "d2", "top2", "d3"));
+ .containsExactlyElementsIn(
+ MemoizingEvaluatorTester.toSkyKeys("top1", "d1", "d2", "top2", "d3"));
}
// NOTE: Some of these tests exercising errors/warnings run through a size-2 for loop in order
@@ -635,7 +649,7 @@
for (int i = 0; i < 2; i++) {
// Make sure we see the warning exactly once.
initializeReporter();
- tester.eval(/*keepGoing=*/false, "t1", "t2");
+ tester.eval(/*keepGoing=*/ false, "t1", "t2");
if (i == 0 || eventsStored()) {
assertThatEvents(eventCollector).containsExactly("look both ways before crossing");
}
@@ -645,7 +659,8 @@
@Test
public void errorValueDepOnWarningValue() throws Exception {
tester.getOrCreate("error-value").setHasError(true).addDependency("warning-value");
- tester.set("warning-value", new StringValue("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++) {
@@ -668,7 +683,9 @@
// 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")
+ tester
+ .set("x", new StringValue("y"))
+ .setWarning("fizzlepop")
.setProgress("just letting you know");
StringValue value = (StringValue) tester.evalAndGet("x");
@@ -771,15 +788,19 @@
@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
+ .getOrCreate("error-value")
+ .setHasTransientError(true)
+ .setProgress("just letting you know");
tester.evalAndGetError(/*keepGoing=*/ true, "error-value");
assertThatEvents(eventCollector).containsExactly("just letting you know");
// Change the progress message.
- tester.getOrCreate("error-value").setHasTransientError(true).setProgress(
- "letting you know more");
+ 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++) {
@@ -801,16 +822,14 @@
tester.getOrCreate("top").setHasTransientError(true).addDependency(leaf);
tester.set(leaf, new StringValue("leafy"));
tester.evalAndGetError(/*keepGoing=*/ true, "top");
- tester.getOrCreate(leaf, /*markAsModified=*/true);
+ tester.getOrCreate(leaf, /*markAsModified=*/ true);
tester.invalidate();
tester.evalAndGetError(/*keepGoing=*/ true, "top");
}
@Test
public void simpleDependency() throws Exception {
- tester.getOrCreate("ab")
- .addDependency("a")
- .setComputedValue(COPY);
+ tester.getOrCreate("ab").addDependency("a").setComputedValue(COPY);
tester.set("a", new StringValue("me"));
StringValue value = (StringValue) tester.evalAndGet("ab");
assertThat(value.getValue()).isEqualTo("me");
@@ -851,10 +870,7 @@
private SkyKey setupDiamondDependency() {
SkyKey diamondBase = GraphTester.nonHermeticKey("d");
- tester.getOrCreate("a")
- .addDependency("b")
- .addDependency("c")
- .setComputedValue(CONCATENATE);
+ tester.getOrCreate("a").addDependency("b").addDependency("c").setComputedValue(CONCATENATE);
tester.getOrCreate("b").addDependency(diamondBase).setComputedValue(COPY);
tester.getOrCreate("c").addDependency(diamondBase).setComputedValue(COPY);
return diamondBase;
@@ -895,7 +911,7 @@
SkyKey top = GraphTester.skyKey("aatop");
tester.getOrCreate(top).addDependency(mid).setComputedValue(CONCATENATE);
tester.getOrCreate(mid).setHasError(true);
- tester.eval(/*keepGoing=*/false, top, mid);
+ tester.eval(/*keepGoing=*/ false, top, mid);
assertThat(valueSet.getCount()).isEqualTo(0L);
assertThat(tester.progressReceiver.evaluated).containsExactly(mid);
}
@@ -908,12 +924,12 @@
tester.set(leaf, new StringValue("leaf"));
tester.getOrCreate(cycle).addDependency(cycle);
tester.getOrCreate(top).addDependency(leaf).addDependency(cycle);
- tester.eval(/*keepGoing=*/true, top);
+ tester.eval(/*keepGoing=*/ true, top);
assertThat(tester.progressReceiver.evaluated).containsExactly(leaf, top, cycle);
tester.progressReceiver.clear();
- tester.getOrCreate(leaf, /*markAsModified=*/true);
+ tester.getOrCreate(leaf, /*markAsModified=*/ true);
tester.invalidate();
- tester.eval(/*keepGoing=*/true, top);
+ tester.eval(/*keepGoing=*/ true, top);
if (preciseEvaluationStatusStored()) {
assertThat(tester.progressReceiver.evaluated).containsExactly(leaf, top);
}
@@ -975,8 +991,7 @@
expected.append(iString);
}
SkyKey rootKey = toSkyKey("root");
- TestFunction value = tester.getOrCreate(rootKey)
- .setComputedValue(CONCATENATE);
+ TestFunction value = tester.getOrCreate(rootKey).setComputedValue(CONCATENATE);
for (int i = 0; i < values.length; i++) {
value.addDependency(values[i]);
}
@@ -1010,14 +1025,16 @@
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
+ .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"));
@@ -1053,7 +1070,7 @@
tester.getOrCreate(midKey).addDependency(aKey);
tester.getOrCreate(aKey).addDependency(bKey);
tester.getOrCreate(bKey).addDependency(aKey);
- EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/true, topKey, goodKey);
+ EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/ true, topKey, goodKey);
assertThat(result.get(goodKey)).isEqualTo(goodValue);
assertThat(result.get(topKey)).isNull();
ErrorInfo errorInfo = result.getError(topKey);
@@ -1064,7 +1081,7 @@
}
tester.invalidate();
- result = tester.eval(/*keepGoing=*/false, topKey, goodKey);
+ result = tester.eval(/*keepGoing=*/ false, topKey, goodKey);
assertThat(result.get(topKey)).isNull();
errorInfo = result.getError(topKey);
cycleInfo = Iterables.getOnlyElement(errorInfo.getCycleInfo());
@@ -1218,10 +1235,13 @@
makeGraphDeterministic();
SkyKey cycleKey1 = GraphTester.nonHermeticKey("ZcycleKey1");
SkyKey cycleKey2 = GraphTester.toSkyKey("AcycleKey2");
- tester.getOrCreate(cycleKey1).addDependency(cycleKey2).addDependency(cycleKey1)
- .setComputedValue(CONCATENATE);
+ tester
+ .getOrCreate(cycleKey1)
+ .addDependency(cycleKey2)
+ .addDependency(cycleKey1)
+ .setComputedValue(CONCATENATE);
tester.getOrCreate(cycleKey2).addDependency(cycleKey1).setComputedValue(COPY);
- EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/true, cycleKey1);
+ EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/ true, cycleKey1);
assertThat(result.get(cycleKey1)).isNull();
ErrorInfo errorInfo = result.getError(cycleKey1);
CycleInfo cycleInfo = Iterables.getOnlyElement(errorInfo.getCycleInfo());
@@ -1229,9 +1249,9 @@
assertThat(cycleInfo.getCycle()).containsExactly(cycleKey1).inOrder();
assertThat(cycleInfo.getPathToCycle()).isEmpty();
}
- tester.getOrCreate(cycleKey1, /*markAsModified=*/true);
+ tester.getOrCreate(cycleKey1, /*markAsModified=*/ true);
tester.invalidate();
- result = tester.eval(/*keepGoing=*/true, cycleKey1, cycleKey2);
+ result = tester.eval(/*keepGoing=*/ true, cycleKey1, cycleKey2);
assertThat(result.get(cycleKey1)).isNull();
errorInfo = result.getError(cycleKey1);
cycleInfo = Iterables.getOnlyElement(errorInfo.getCycleInfo());
@@ -1295,7 +1315,7 @@
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);
+ EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/ true, cycleKey1);
assertThat(result.get(cycleKey1)).isNull();
ErrorInfo errorInfo = result.getError(cycleKey1);
CycleInfo cycleInfo = Iterables.getOnlyElement(errorInfo.getCycleInfo());
@@ -1303,9 +1323,9 @@
assertThat(cycleInfo.getCycle()).containsExactly(cycleKey1, cycleKey2).inOrder();
assertThat(cycleInfo.getPathToCycle()).isEmpty();
}
- tester.getOrCreate(cycleKey1, /*markAsModified=*/true);
+ tester.getOrCreate(cycleKey1, /*markAsModified=*/ true);
tester.invalidate();
- result = tester.eval(/*keepGoing=*/true, cycleKey1);
+ result = tester.eval(/*keepGoing=*/ true, cycleKey1);
assertThat(result.get(cycleKey1)).isNull();
errorInfo = result.getError(cycleKey1);
cycleInfo = Iterables.getOnlyElement(errorInfo.getCycleInfo());
@@ -1318,12 +1338,12 @@
/**
* {@link ParallelEvaluator} can be configured to not store errors alongside recovered values.
*
- * @param errorsStoredAlongsideValues true if we expect Skyframe to store the error for the
- * cycle in ErrorInfo. If true, supportsTransientExceptions must be true as well.
+ * @param errorsStoredAlongsideValues true if we expect Skyframe to store the error for the cycle
+ * in ErrorInfo. If true, supportsTransientExceptions must be true as well.
* @param supportsTransientExceptions true if we expect Skyframe to mark an ErrorInfo as transient
- * for certain exception types.
+ * for certain exception types.
* @param useTransientError true if the test should set the {@link TestFunction} it creates to
- * throw a transient error.
+ * throw a transient error.
*/
protected void parentOfCycleAndErrorInternal(
boolean errorsStoredAlongsideValues,
@@ -1346,12 +1366,22 @@
} else {
errorFunction.setHasError(true);
}
- tester.getOrCreate(mid).addErrorDependency(errorKey, new StringValue("recovered"))
+ tester
+ .getOrCreate(mid)
+ .addErrorDependency(errorKey, new StringValue("recovered"))
.setComputedValue(COPY);
SkyKey top = GraphTester.toSkyKey("top");
CountDownLatch topEvaluated = new CountDownLatch(2);
- tester.getOrCreate(top).setBuilder(new ChainedFunction(topEvaluated, null, null, false,
- new StringValue("unused"), ImmutableList.of(mid, cycleKey1)));
+ tester
+ .getOrCreate(top)
+ .setBuilder(
+ new ChainedFunction(
+ topEvaluated,
+ null,
+ null,
+ false,
+ new StringValue("unused"),
+ ImmutableList.of(mid, cycleKey1)));
EvaluationResult<StringValue> evalResult = tester.eval(true, top);
assertThatEvaluationResult(evalResult).hasError();
ErrorInfo errorInfo = evalResult.getError(top);
@@ -1475,35 +1505,58 @@
assertThat(tester.evalAndGet(/*keepGoing=*/ false, otherTop))
.isEqualTo(new StringValue("otherTop"));
// Mark dep1 changed, so otherTop will be dirty and request re-evaluation of dep1.
- tester.getOrCreate(dep1, /*markAsModified=*/true);
+ tester.getOrCreate(dep1, /*markAsModified=*/ true);
SkyKey topKey = GraphTester.toSkyKey("top");
// Note that since DeterministicHelper 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)
+ tester
+ .getOrCreate(cycle1Key)
+ .addDependency(errorKey)
+ .addDependency(cycle2Key)
.setComputedValue(CONCATENATE);
- tester.getOrCreate(errorKey).setBuilder(new ChainedFunction(/*notifyStart=*/null,
- /*waitToFinish=*/valuesReady, /*notifyFinish=*/null, /*waitForException=*/false, /*value=*/null,
- ImmutableList.<SkyKey>of()));
+ tester
+ .getOrCreate(errorKey)
+ .setBuilder(
+ new ChainedFunction(
+ /*notifyStart=*/ null,
+ /*waitToFinish=*/ valuesReady,
+ /*notifyFinish=*/ null,
+ /*waitForException=*/ false,
+ /*value=*/ null,
+ ImmutableList.<SkyKey>of()));
// 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)));
+ 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
+ .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);
+ tester.eval(/*keepGoing=*/ false, otherTop, topKey, exceptionMarker);
Iterable<CycleInfo> cycleInfos = result.getError(topKey).getCycleInfo();
assertWithMessage(result.toString()).that(cycleInfos).isNotEmpty();
CycleInfo cycleInfo = Iterables.getOnlyElement(cycleInfos);
@@ -1669,8 +1722,8 @@
}
topLevelBuilder.setConstantValue(new StringValue("xyz"));
- EvaluationResult<StringValue> result = tester.eval(
- /*keepGoing=*/true, /*numThreads=*/5, topLevel);
+ EvaluationResult<StringValue> result =
+ tester.eval(/*keepGoing=*/ true, /*numThreads=*/ 5, topLevel);
assertThat(result.hasError()).isFalse();
assertThat(maxValue[0]).isEqualTo(5);
}
@@ -1734,34 +1787,51 @@
CountDownLatch slowStart = new CountDownLatch(1);
CountDownLatch errorFinish = new CountDownLatch(1);
SkyKey errorKey = GraphTester.nonHermeticKey("error");
- tester.getOrCreate(errorKey).setBuilder(
- new ChainedFunction(/*notifyStart=*/null, /*waitToFinish=*/slowStart,
- /*notifyFinish=*/errorFinish, /*waitForException=*/false, /*value=*/null,
- /*deps=*/ImmutableList.<SkyKey>of()));
+ 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()));
+ 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)
+ 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);
+ EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/ false, topKey);
assertThatEvaluationResult(result).hasSingletonErrorThat(topKey);
// Make sure midKey didn't finish building.
assertThat(tester.getExistingValue(midKey)).isNull();
// Give slowKey a nice ordinary builder.
- tester.getOrCreate(slowKey, /*markAsModified=*/false).setBuilder(null)
+ 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.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);
+ tester.eval(/*keepGoing=*/ false, topKey);
}
/**
@@ -1774,35 +1844,52 @@
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()));
+ 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()));
+ 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)
+ 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);
+ EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/ false, topKey);
assertThatEvaluationResult(result).hasSingletonErrorThat(topKey);
// Make sure midKey didn't finish building.
assertThat(tester.getExistingValue(midKey)).isNull();
// Give slowKey a nice ordinary builder.
- tester.getOrCreate(slowKey, /*markAsModified=*/false).setBuilder(null)
+ 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.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);
+ tester.eval(/*keepGoing=*/ true, topKey);
}
/**
@@ -1811,15 +1898,27 @@
private void passThenFailToBuild(boolean successFirst) 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()));
+ 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()));
+ tester
+ .getOrCreate(slowFailKey)
+ .setBuilder(
+ new ChainedFunction(
+ /*notifyStart=*/ null,
+ /*waitToFinish=*/ blocker,
+ /*notifyFinish=*/ null,
+ /*waitForException=*/ false,
+ /*value=*/ null,
+ /*deps=*/ ImmutableList.<SkyKey>of()));
EvaluationResult<StringValue> result;
if (successFirst) {
@@ -1851,36 +1950,53 @@
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()));
+ 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()));
+ 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)
+ 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);
+ EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/ false, topKey);
assertThatEvaluationResult(result).hasSingletonErrorThat(topKey);
// Make sure midKey didn't finish building.
assertThat(tester.getExistingValue(midKey)).isNull();
// Give slowKey a nice ordinary builder.
- tester.getOrCreate(slowKey, /*markAsModified=*/false).setBuilder(null)
+ 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.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);
+ tester.eval(/*keepGoing=*/ true, topKey);
}
@Test
@@ -1895,12 +2011,12 @@
.addErrorDependency(errorKey, new StringValue("recovered"))
.setComputedValue(CONCATENATE)
.addDependency(afterKey);
- EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/true, parentKey);
+ EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/ true, parentKey);
assertThat(result.errorMap()).isEmpty();
assertThat(result.get(parentKey).getValue()).isEqualTo("recoveredafter");
tester.set(afterKey, new StringValue("before"));
tester.invalidate();
- result = tester.eval(/*keepGoing=*/true, parentKey);
+ result = tester.eval(/*keepGoing=*/ true, parentKey);
assertThat(result.errorMap()).isEmpty();
assertThat(result.get(parentKey).getValue()).isEqualTo("recoveredbefore");
}
@@ -1911,14 +2027,17 @@
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);
+ tester
+ .getOrCreate(parentKey)
+ .addErrorDependency(errorKey, new StringValue("recovered"))
+ .setComputedValue(CONCATENATE)
+ .addDependency("after");
+ EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/ true, parentKey);
assertThat(result.errorMap()).isEmpty();
assertThat(result.get(parentKey).getValue()).isEqualTo("recoveredafter");
tester.set(errorKey, new StringValue("reformed")).setHasError(false);
tester.invalidate();
- result = tester.eval(/*keepGoing=*/true, parentKey);
+ result = tester.eval(/*keepGoing=*/ true, parentKey);
assertThat(result.errorMap()).isEmpty();
assertThat(result.get(parentKey).getValue()).isEqualTo("reformedafter");
}
@@ -1928,7 +2047,9 @@
SkyKey errorKey = GraphTester.nonHermeticKey("my_error_value");
tester.getOrCreate(errorKey).setHasError(true);
SkyKey parentKey = GraphTester.toSkyKey("parent");
- tester.getOrCreate(parentKey).addErrorDependency(errorKey, new StringValue("recovered"))
+ tester
+ .getOrCreate(parentKey)
+ .addErrorDependency(errorKey, new StringValue("recovered"))
.setHasError(true);
// Prime the graph by putting the error value in it beforehand.
assertThat(tester.evalAndGetError(/*keepGoing=*/ true, errorKey)).isNotNull();
@@ -1937,20 +2058,22 @@
assertThatEvaluationResult(result).hasSingletonErrorThat(parentKey);
// Change the error value to no longer throw.
tester.set(errorKey, new StringValue("reformed")).setHasError(false);
- tester.getOrCreate(parentKey, /*markAsModified=*/false).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);
+ result = tester.eval(/*keepGoing=*/ false, parentKey);
assertThat(result.errorMap()).isEmpty();
assertThat(result.get(parentKey).getValue()).isEqualTo("reformed");
// 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.getOrCreate(parentKey, /*markAsModified=*/ false).setHasError(true);
tester.invalidateTransientErrors();
- result = tester.eval(/*keepGoing=*/false, parentKey);
+ result = tester.eval(/*keepGoing=*/ false, parentKey);
assertThat(result.errorMap()).isEmpty();
assertThat(result.get(parentKey).getValue()).isEqualTo("reformed");
}
@@ -1984,15 +2107,15 @@
SkyKey leaf = GraphTester.nonHermeticKey("leaf");
tester.set(leaf, new StringValue("leaf"));
tester.getOrCreate(top).addDependency(leaf).setHasTransientError(true);
- EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/false, top);
+ EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/ false, top);
assertWithMessage(result.toString()).that(result.hasError()).isTrue();
- tester.getOrCreate(leaf, /*markAsModified=*/true);
+ tester.getOrCreate(leaf, /*markAsModified=*/ true);
tester.invalidate();
SkyKey irrelevant = GraphTester.toSkyKey("irrelevant");
tester.set(irrelevant, new StringValue("irrelevant"));
- tester.eval(/*keepGoing=*/true, irrelevant);
+ tester.eval(/*keepGoing=*/ true, irrelevant);
tester.invalidateTransientErrors();
- result = tester.eval(/*keepGoing=*/true, top);
+ result = tester.eval(/*keepGoing=*/ true, top);
assertWithMessage(result.toString()).that(result.hasError()).isTrue();
}
@@ -2002,10 +2125,14 @@
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"))
+ 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"))
+ 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.
@@ -2027,40 +2154,55 @@
CountDownLatch slowStart = new CountDownLatch(1);
CountDownLatch errorFinish = new CountDownLatch(1);
SkyKey errorKey = GraphTester.nonHermeticKey("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()));
+ 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()));
+ 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");
- }
+ 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;
- }
- });
+ @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);
+ EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/ false, topKey);
assertThat(result.hasError()).isTrue();
assertThatEvaluationResult(result).hasErrorEntryForKeyThat(topKey);
@@ -2110,13 +2252,13 @@
EvaluationResult<SkyValue> evaluationResult = tester.eval(/*keepGoing=*/ true, groupDepA, depC);
assertThat(((SkyKeyValue) evaluationResult.get(groupDepA)).key).isEqualTo(depC);
assertThatEvaluationResult(evaluationResult).hasErrorEntryForKeyThat(depC);
- evaluationResult = tester.eval(/*keepGoing=*/false, topKey);
+ evaluationResult = tester.eval(/*keepGoing=*/ false, topKey);
assertThatEvaluationResult(evaluationResult).hasErrorEntryForKeyThat(topKey);
tester.set(groupDepA, new SkyKeyValue(groupDepB));
- tester.getOrCreate(depC, /*markAsModified=*/true);
+ tester.getOrCreate(depC, /*markAsModified=*/ true);
tester.invalidate();
- evaluationResult = tester.eval(/*keepGoing=*/false, topKey);
+ evaluationResult = tester.eval(/*keepGoing=*/ false, topKey);
assertWithMessage(evaluationResult.toString()).that(evaluationResult.hasError()).isFalse();
assertThat(evaluationResult.get(topKey)).isEqualTo(new StringValue("top"));
}
@@ -2237,7 +2379,7 @@
}
});
// First build : just prime the graph.
- EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/false, top);
+ EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/ false, top);
assertThat(result.hasError()).isFalse();
assertThat(result.get(top)).isEqualTo(new StringValue("top"));
assertThat(numTopInvocations.get()).isEqualTo(2);
@@ -2292,12 +2434,12 @@
@Test
public void dirtyChildEnqueuesParentDuringCheckDependencies_ThrowDoesntEnqueue()
throws Exception {
- dirtyChildEnqueuesParentDuringCheckDependencies(/*throwError=*/true);
+ dirtyChildEnqueuesParentDuringCheckDependencies(/*throwError=*/ true);
}
@Test
public void dirtyChildEnqueuesParentDuringCheckDependencies_NoThrow() throws Exception {
- dirtyChildEnqueuesParentDuringCheckDependencies(/*throwError=*/false);
+ dirtyChildEnqueuesParentDuringCheckDependencies(/*throwError=*/ false);
}
@Test
@@ -2372,15 +2514,15 @@
SkyKey leafKey = GraphTester.nonHermeticKey("leaf");
tester.getOrCreate(topKey).addDependency(leafKey).setComputedValue(CONCATENATE);
tester.set(leafKey, new StringValue("leafy"));
- assertThat(tester.evalAndGet(/*keepGoing=*/false, topKey)).isEqualTo(new StringValue("leafy"));
- tester.getOrCreate(topKey, /*markAsModified=*/true);
+ assertThat(tester.evalAndGet(/*keepGoing=*/ false, topKey)).isEqualTo(new StringValue("leafy"));
+ tester.getOrCreate(topKey, /*markAsModified=*/ true);
tester.invalidate();
- assertThat(tester.evalAndGet(/*keepGoing=*/false, leafKey))
+ assertThat(tester.evalAndGet(/*keepGoing=*/ false, leafKey))
.isEqualTo(new StringValue("leafy"));
tester.delete("top");
- tester.getOrCreate(leafKey, /*markAsModified=*/true);
+ tester.getOrCreate(leafKey, /*markAsModified=*/ true);
tester.invalidate();
- assertThat(tester.evalAndGet(/*keepGoing=*/false, leafKey))
+ assertThat(tester.evalAndGet(/*keepGoing=*/ false, leafKey))
.isEqualTo(new StringValue("leafy"));
}
@@ -2667,29 +2809,35 @@
// 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;
- }
+ 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;
- }
+ // 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;
- }
- });
+ return topValue;
+ }
+ });
// First build: assert we can evaluate "top".
assertThat(tester.evalAndGet(/*keepGoing=*/ false, topKey)).isEqualTo(topValue);
@@ -2719,7 +2867,7 @@
tester.invalidate();
// For invalidation.
tester.evalAndGet("dummy");
- tester.getOrCreate(mid, /*markAsModified=*/true);
+ tester.getOrCreate(mid, /*markAsModified=*/ true);
tester.invalidate();
topValue = (StringValue) tester.evalAndGet("top");
assertThat(topValue.getValue()).isEqualTo("crunchy");
@@ -2784,18 +2932,18 @@
tester.set(leaf, new StringValue("leaf"));
tester.getOrCreate(parent).addDependency(leaf).setComputedValue(CONCATENATE);
EvaluationResult<StringValue> result;
- result = tester.eval(/*keepGoing=*/false, parent);
+ result = tester.eval(/*keepGoing=*/ false, parent);
assertThat(result.get(parent).getValue()).isEqualTo("leaf");
// Invalidate leaf, but don't actually change it. It will transitively dirty parent
// concurrently with parent directly dirtying itself.
- tester.getOrCreate(leaf, /*markAsModified=*/true);
+ 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.getOrCreate(parent, /*markAsModified=*/ true).addDependency(other2);
tester.invalidate();
blockingEnabled.set(true);
- result = tester.eval(/*keepGoing=*/false, parent);
+ result = tester.eval(/*keepGoing=*/ false, parent);
assertThat(result.get(parent).getValue()).isEqualTo("leafother2");
assertThat(waitForChanged.getCount()).isEqualTo(0);
assertThat(threadsStarted.getCount()).isEqualTo(0);
@@ -2838,22 +2986,21 @@
expected.append(valueName);
}
SkyKey topKey = toSkyKey("top");
- TestFunction value = tester.getOrCreate(topKey)
- .setComputedValue(CONCATENATE);
+ 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);
+ EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/ false, topKey);
assertThat(result.get(topKey)).isEqualTo(new StringValue(expected.toString()));
for (int j = 0; j < RUNS; j++) {
for (int i = 0; i < values.length; i++) {
- tester.getOrCreate(values[i], /*markAsModified=*/true);
+ 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.getOrCreate(topKey, /*markAsModified=*/ false).setHasError(true);
tester.invalidate();
result = tester.eval(/* keepGoing= */ false, topKey);
@@ -2878,12 +3025,20 @@
SkyKey lastKey = GraphTester.nonHermeticKey("last");
tester.set(lastKey, new StringValue("last"));
SkyKey motherKey = GraphTester.toSkyKey("mother");
- tester.getOrCreate(motherKey).addDependency(errorKey)
- .addDependency(midKey).addDependency(lastKey).setComputedValue(CONCATENATE);
+ 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);
+ tester
+ .getOrCreate(fatherKey)
+ .addDependency(errorKey)
+ .addDependency(midKey)
+ .addDependency(lastKey)
+ .setComputedValue(CONCATENATE);
+ EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/ false, motherKey, fatherKey);
assertThat(result.get(motherKey).getValue()).isEqualTo("biding timeslowlast");
assertThat(result.get(fatherKey).getValue()).isEqualTo("biding timeslowlast");
tester.set(slowKey, null);
@@ -2893,31 +3048,47 @@
// 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
+ .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);
+ result = tester.eval(/*keepGoing=*/ false, motherKey, fatherKey);
assertThat(result.hasError()).isTrue();
// Only one of mother or father should be in the graph.
assertWithMessage(result.getError(motherKey) + ", " + result.getError(fatherKey))
.that((result.getError(motherKey) == null) != (result.getError(fatherKey) == null))
.isTrue();
- SkyKey parentKey = (reevaluateMissingValue == (result.getError(motherKey) == null))
- ? motherKey : fatherKey;
+ SkyKey parentKey =
+ (reevaluateMissingValue == (result.getError(motherKey) == null)) ? motherKey : fatherKey;
// Give slowKey a nice ordinary builder.
- tester.getOrCreate(slowKey, /*markAsModified=*/false).setBuilder(null)
+ tester
+ .getOrCreate(slowKey, /*markAsModified=*/ false)
+ .setBuilder(null)
.setConstantValue(new StringValue("leaf2"));
if (removeError) {
- tester.getOrCreate(errorKey, /*markAsModified=*/true).setBuilder(null)
+ tester
+ .getOrCreate(errorKey, /*markAsModified=*/ true)
+ .setBuilder(null)
.setConstantValue(new StringValue("reformed"));
}
String lastString = "last";
@@ -2928,7 +3099,7 @@
tester.set(lastKey, new StringValue(lastString));
}
tester.invalidate();
- result = tester.eval(/*keepGoing=*/false, parentKey);
+ result = tester.eval(/*keepGoing=*/ false, parentKey);
if (removeError) {
assertThat(result.get(parentKey).getValue()).isEqualTo("reformedleaf2" + lastString);
} else {
@@ -2946,26 +3117,26 @@
*/
@Test
public void dirtyChildrenProperlyRemovedWithInvalidateRemoveError() throws Exception {
- dirtyValueChildrenProperlyRemovedOnEarlyBuildAbort(/*reevaluateMissingValue=*/false,
- /*removeError=*/true);
+ dirtyValueChildrenProperlyRemovedOnEarlyBuildAbort(
+ /*reevaluateMissingValue=*/ false, /*removeError=*/ true);
}
@Test
public void dirtyChildrenProperlyRemovedWithInvalidateKeepError() throws Exception {
- dirtyValueChildrenProperlyRemovedOnEarlyBuildAbort(/*reevaluateMissingValue=*/false,
- /*removeError=*/false);
+ dirtyValueChildrenProperlyRemovedOnEarlyBuildAbort(
+ /*reevaluateMissingValue=*/ false, /*removeError=*/ false);
}
@Test
public void dirtyChildrenProperlyRemovedWithReevaluateRemoveError() throws Exception {
- dirtyValueChildrenProperlyRemovedOnEarlyBuildAbort(/*reevaluateMissingValue=*/true,
- /*removeError=*/true);
+ dirtyValueChildrenProperlyRemovedOnEarlyBuildAbort(
+ /*reevaluateMissingValue=*/ true, /*removeError=*/ true);
}
@Test
public void dirtyChildrenProperlyRemovedWithReevaluateKeepError() throws Exception {
- dirtyValueChildrenProperlyRemovedOnEarlyBuildAbort(/*reevaluateMissingValue=*/true,
- /*removeError=*/false);
+ dirtyValueChildrenProperlyRemovedOnEarlyBuildAbort(
+ /*reevaluateMissingValue=*/ true, /*removeError=*/ false);
}
/**
@@ -2986,30 +3157,36 @@
// 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)
+ tester
+ .getOrCreate(topKey)
+ .addDependency(leafKey)
+ .addDependency(lastKey)
.setComputedValue(CONCATENATE);
tops.add(topKey);
}
- tester.eval(/*keepGoing=*/false, tops.toArray(new SkyKey[0]));
+ 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
+ .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(
@@ -3025,12 +3202,12 @@
shouldSleep.set(false);
} else {
// Non-interrupt case. Just throw an error in the child.
- tester.getOrCreate(leafKey, /*markAsModified=*/true).setHasError(true);
+ 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.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
@@ -3038,7 +3215,7 @@
tester.set(lastKey, new StringValue("new last"));
tester.invalidate();
EvaluationResult<StringValue> result =
- tester.eval(/*keepGoing=*/false, tops.toArray(new SkyKey[0]));
+ tester.eval(/*keepGoing=*/ false, tops.toArray(new SkyKey[0]));
for (SkyKey topKey : tops) {
assertWithMessage(topKey.toString())
.that(result.get(topKey).getValue())
@@ -3052,7 +3229,7 @@
*/
@Test
public void manyDirtyValuesClearChildrenOnError() throws Exception {
- manyDirtyValuesClearChildrenOnFail(/*interrupt=*/false);
+ manyDirtyValuesClearChildrenOnFail(/*interrupt=*/ false);
}
/**
@@ -3061,7 +3238,7 @@
*/
@Test
public void manyDirtyValuesClearChildrenOnInterrupt() throws Exception {
- manyDirtyValuesClearChildrenOnFail(/*interrupt=*/true);
+ manyDirtyValuesClearChildrenOnFail(/*interrupt=*/ true);
}
private SkyKey makeTestKey(SkyKey node0) {
@@ -3122,12 +3299,12 @@
StringValue topValue = (StringValue) tester.evalAndGet("top");
assertThat(topValue.getValue()).isEqualTo("leafy");
// Mark leaf changed, but don't actually change it.
- tester.getOrCreate(leaf, /*markAsModified=*/true);
+ 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.getOrCreate(mid, /*markAsModified=*/ false).setHasError(true);
tester.invalidate();
- EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/false, top);
+ EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/ false, top);
assertThat(result.hasError()).isFalse();
topValue = result.get(top);
assertThat(topValue.getValue()).isEqualTo("leafy");
@@ -3150,16 +3327,16 @@
StringValue value = (StringValue) tester.evalAndGet("top");
assertThat(value.getValue()).isEqualTo("leafysuffixsuffix");
// Mark leaf changed, but don't actually change it.
- tester.getOrCreate(leaf, /*markAsModified=*/true);
+ 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.getOrCreate(mid, /*markAsModified=*/ false).setHasError(true);
tester.invalidate();
value = (StringValue) tester.evalAndGet(/*keepGoing=*/ false, leaf);
assertThat(value.getValue()).isEqualTo("leafy");
assertThat(tester.getDirtyKeys()).containsExactly(mid, top);
assertThat(tester.getDeletedKeys()).isEmpty();
- EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/false, top);
+ EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/ false, top);
assertWithMessage(result.toString()).that(result.hasError()).isFalse();
value = result.get(top);
assertThat(value.getValue()).isEqualTo("leafysuffixsuffix");
@@ -3356,19 +3533,20 @@
}
}
- private static final SkyFunction INTERRUPT_BUILDER = new SkyFunction() {
+ private static final SkyFunction INTERRUPT_BUILDER =
+ new SkyFunction() {
- @Override
- public SkyValue compute(SkyKey skyKey, Environment env) throws SkyFunctionException,
- InterruptedException {
- throw new InterruptedException();
- }
+ @Override
+ public SkyValue compute(SkyKey skyKey, Environment env)
+ throws SkyFunctionException, InterruptedException {
+ throw new InterruptedException();
+ }
- @Override
- public String extractTag(SkyKey skyKey) {
- throw new UnsupportedOperationException();
- }
- };
+ @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
@@ -3377,10 +3555,10 @@
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.getOrCreate(value, /*markAsModified=*/ true).setBuilder(INTERRUPT_BUILDER);
tester.invalidate();
assertThrows(InterruptedException.class, () -> tester.eval(/*keepGoing=*/ false, value));
- tester.getOrCreate(value, /*markAsModified=*/false).setBuilder(null);
+ tester.getOrCreate(value, /*markAsModified=*/ false).setBuilder(null);
}
/**
@@ -3424,10 +3602,10 @@
failBuildAndRemoveValue(leaf);
tester.set(leaf, new StringValue("crunchy"));
tester.invalidate();
- tester.eval(/*keepGoing=*/false, leaf);
+ 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.getOrCreate(top, /*markAsModified=*/ true);
tester.invalidate();
topValue = (StringValue) tester.evalAndGet(/*keepGoing=*/ false, top);
assertThat(topValue.getValue()).isEqualTo("crunchy");
@@ -3438,11 +3616,13 @@
* 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.
*/
@@ -3457,11 +3637,14 @@
// 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)
+ tester
+ .getOrCreate(topKey)
+ .addDependency(leafKey)
+ .addDependency(lastKey)
.setComputedValue(CONCATENATE);
tops.add(topKey);
}
- tester.eval(/*keepGoing=*/false, tops.toArray(new SkyKey[0]));
+ 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
@@ -3469,7 +3652,7 @@
// 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.getOrCreate(leafKey, /*markAsModified=*/ true).setBuilder(INTERRUPT_BUILDER);
tester.invalidate();
assertThrows(
InterruptedException.class,
@@ -3480,7 +3663,9 @@
public void failedDirtyBuild() throws Exception {
SkyKey leaf = GraphTester.nonHermeticKey("leaf");
SkyKey top = GraphTester.toSkyKey("top");
- tester.getOrCreate(top).addErrorDependency(leaf, new StringValue("recover"))
+ tester
+ .getOrCreate(top)
+ .addErrorDependency(leaf, new StringValue("recover"))
.setComputedValue(COPY);
tester.set(leaf, new StringValue("leafy"));
StringValue topValue = (StringValue) tester.evalAndGet("top");
@@ -3488,10 +3673,10 @@
assertThat(tester.getDirtyKeys()).isEmpty();
assertThat(tester.getDeletedKeys()).isEmpty();
// Change leaf.
- tester.getOrCreate(leaf, /*markAsModified=*/true).setHasError(true);
- tester.getOrCreate(top, /*markAsModified=*/false).setHasError(true);
+ tester.getOrCreate(leaf, /*markAsModified=*/ true).setHasError(true);
+ tester.getOrCreate(top, /*markAsModified=*/ false).setHasError(true);
tester.invalidate();
- EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/false, top);
+ EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/ false, top);
assertThatEvaluationResult(result).hasSingletonErrorThat(top);
}
@@ -3500,8 +3685,11 @@
SkyKey leaf = GraphTester.nonHermeticKey("leaf");
SkyKey secondError = GraphTester.nonHermeticKey("secondError");
SkyKey top = GraphTester.toSkyKey("top");
- tester.getOrCreate(top).addDependency(leaf)
- .addErrorDependency(secondError, new StringValue("recover")).setComputedValue(CONCATENATE);
+ 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");
@@ -3509,12 +3697,12 @@
assertThat(tester.getDirtyKeys()).isEmpty();
assertThat(tester.getDeletedKeys()).isEmpty();
// Invalidate leaf.
- tester.getOrCreate(leaf, /*markAsModified=*/true);
+ 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.getOrCreate(secondError, /*markAsModified=*/ true).setHasError(true);
+ tester.getOrCreate(top, /*markAsModified=*/ false).setHasError(true);
tester.invalidate();
- EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/false, top);
+ EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/ false, top);
assertThatEvaluationResult(result).hasSingletonErrorThat(top);
}
@@ -3538,13 +3726,13 @@
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);
+ EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/ false, topKey);
assertThatEvaluationResult(result).hasSingletonErrorThat(topKey);
tester.getOrCreate(error).setHasError(false);
StringValue val = new StringValue("reformed");
tester.set(error, val);
tester.invalidate();
- result = tester.eval(/*keepGoing=*/false, topKey);
+ result = tester.eval(/*keepGoing=*/ false, topKey);
assertThatEvaluationResult(result).hasEntryThat(topKey).isEqualTo(val);
assertThatEvaluationResult(result).hasNoError();
}
@@ -3555,24 +3743,25 @@
SkyKey error = GraphTester.nonHermeticKey("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);
- }
- }
+ 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();
- }
- };
+ @Override
+ public String extractTag(SkyKey skyKey) {
+ throw new UnsupportedOperationException();
+ }
+ };
tester.getOrCreate(topKey).setBuilder(errorFunction);
- EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/false, topKey);
+ EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/ false, topKey);
tester.invalidateTransientErrors();
assertThatEvaluationResult(result).hasSingletonErrorThat(topKey);
tester.getOrCreate(error).setHasTransientError(false);
@@ -3585,7 +3774,7 @@
.setComputedValue(COPY);
tester.invalidate();
tester.invalidateTransientErrors();
- result = tester.eval(/*keepGoing=*/false, topKey);
+ result = tester.eval(/*keepGoing=*/ false, topKey);
assertThatEvaluationResult(result).hasEntryThat(topKey).isEqualTo(reformed);
assertThatEvaluationResult(result).hasNoError();
}
@@ -3620,11 +3809,14 @@
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)
+ 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);
+ EvaluationResult<StringValue> result =
+ tester.eval(/*keepGoing=*/ false, topErrorFirstKey, topBubbleKey);
assertThat(result.get(topErrorFirstKey).getValue()).isEqualTo("biding time");
assertThat(result.get(topBubbleKey).getValue()).isEqualTo("slowbiding time");
// Set up timing of child values: slowKey waits to finish until errorKey has thrown an
@@ -3632,18 +3824,30 @@
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
+ .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);
+ result = tester.eval(/*keepGoing=*/ false, topErrorFirstKey, topBubbleKey);
assertThat(result.hasError()).isTrue();
assertWithMessage(result.toString()).that(result.getError(topErrorFirstKey)).isNotNull();
}
@@ -3653,32 +3857,33 @@
final SkyKey error = GraphTester.nonHermeticKey("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;
- }
+ 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();
- }
- };
+ @Override
+ public String extractTag(SkyKey skyKey) {
+ throw new UnsupportedOperationException();
+ }
+ };
tester.getOrCreate(topKey).setBuilder(recoveryErrorFunction);
- EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/false, topKey);
+ EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/ false, topKey);
assertThatEvaluationResult(result).hasSingletonErrorThat(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);
+ result = tester.eval(/*keepGoing=*/ false, topKey);
assertThatEvaluationResult(result).hasEntryThat(topKey).isEqualTo(reformed);
assertThatEvaluationResult(result).hasNoError();
}
@@ -3726,10 +3931,10 @@
}
/**
- * 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.
+ * 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 {
@@ -3922,11 +4127,11 @@
tester.getOrCreate(absentParentKey).addDependency(errorKey).setComputedValue(CONCATENATE);
assertThat(tester.evalAndGet(/*keepGoing=*/ false, absentParentKey))
.isEqualTo(new StringValue("biding time"));
- tester.getOrCreate(errorKey, /*markAsModified=*/true).setHasError(true);
+ 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);
+ EvaluationResult<StringValue> result = tester.eval(/*keepGoing=*/ false, newParent);
assertThatEvaluationResult(result).hasSingletonErrorThat(newParent);
}
@@ -3959,7 +4164,7 @@
parentEvaluated.incrementAndGet();
return new StringValue(val);
});
- assertStringValue(val, tester.evalAndGet( /*keepGoing=*/false, parent));
+ assertStringValue(val, tester.evalAndGet(/*keepGoing=*/ false, parent));
assertThat(parentEvaluated.get()).isEqualTo(1);
if (hasEvent) {
assertThatEvents(eventCollector).containsExactly("shmoop");
@@ -3969,9 +4174,9 @@
eventCollector.clear();
tester.resetPlayedEvents();
- tester.getOrCreate(child, /*markAsModified=*/true);
+ tester.getOrCreate(child, /*markAsModified=*/ true);
tester.invalidate();
- assertStringValue(val, tester.evalAndGet( /*keepGoing=*/false, parent));
+ assertStringValue(val, tester.evalAndGet(/*keepGoing=*/ false, parent));
assertThat(parentEvaluated.get()).isEqualTo(2);
if (hasEvent) {
assertThatEvents(eventCollector).containsExactly("shmoop");
@@ -3997,14 +4202,14 @@
.setBuilder(
new ChainedFunction(
parentEvaluated, null, null, false, parentVal, ImmutableList.of(child)));
- assertThat(tester.evalAndGet( /*keepGoing=*/false, parent)).isEqualTo(parentVal);
+ assertThat(tester.evalAndGet(/*keepGoing=*/ false, parent)).isEqualTo(parentVal);
assertThat(parentEvaluated.getCount()).isEqualTo(1);
assertThatEvents(eventCollector).containsExactly("bloop");
eventCollector.clear();
tester.resetPlayedEvents();
tester.getOrCreate(child, /*markAsModified=*/ true);
tester.invalidate();
- assertThat(tester.evalAndGet( /*keepGoing=*/false, parent)).isEqualTo(parentVal);
+ assertThat(tester.evalAndGet(/*keepGoing=*/ false, parent)).isEqualTo(parentVal);
assertThatEvents(eventCollector).containsExactly("bloop");
assertThat(parentEvaluated.getCount()).isEqualTo(1);
}
@@ -4166,15 +4371,17 @@
errorInfo = tester.evalAndGetError(/*keepGoing=*/ true, errorKey);
assertThat(errorInfo).isNotNull();
StringValue value = new StringValue("reformed");
- tester.getOrCreate(errorKey, /*markAsModified=*/false).setHasTransientError(false)
+ tester
+ .getOrCreate(errorKey, /*markAsModified=*/ false)
+ .setHasTransientError(false)
.setConstantValue(value);
tester.invalidateTransientErrors();
- StringValue stringValue = (StringValue) tester.evalAndGet(/*keepGoing=*/true, errorKey);
+ StringValue stringValue = (StringValue) tester.evalAndGet(/*keepGoing=*/ true, errorKey);
assertThat(value).isSameInstanceAs(stringValue);
// 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.getOrCreate(errorKey, /*markAsModified=*/ false).setHasTransientError(true);
tester.invalidateTransientErrors();
- stringValue = (StringValue) tester.evalAndGet(/*keepGoing=*/true, errorKey);
+ stringValue = (StringValue) tester.evalAndGet(/*keepGoing=*/ true, errorKey);
assertThat(stringValue).isEqualTo(value);
}
@@ -4213,13 +4420,13 @@
SkyValue value = tester.evalAndGet("top");
SkyKey forceInvalidation = GraphTester.toSkyKey("forceInvalidation");
tester.set(forceInvalidation, new StringValue("forceInvalidation"));
- tester.getOrCreate(toDelete, /*markAsModified=*/true);
+ tester.getOrCreate(toDelete, /*markAsModified=*/ true);
tester.invalidate();
- tester.eval(/*keepGoing=*/false, forceInvalidation);
+ tester.eval(/*keepGoing=*/ false, forceInvalidation);
tester.delete("toDelete");
WeakReference<SkyValue> ref = new WeakReference<>(value);
value = null;
- tester.eval(/*keepGoing=*/false, forceInvalidation);
+ tester.eval(/*keepGoing=*/ false, forceInvalidation);
tester.invalidate(); // So that invalidation receiver doesn't hang on to reference.
GcFinalization.awaitClear(ref);
}
@@ -4237,21 +4444,19 @@
leftValues[i] = GraphTester.nonHermeticKey("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);
+ 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
+ .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"));
@@ -4261,7 +4466,7 @@
for (int i = 0; i < TESTED_NODES; i++) {
try {
- tester.getOrCreate(leftValues[i], /*markAsModified=*/true).setHasError(true);
+ tester.getOrCreate(leftValues[i], /*markAsModified=*/ true).setHasError(true);
tester.invalidate();
EvaluationResult<StringValue> result =
tester.eval(/* keepGoing= */ false, lastLeft, lastRight);
@@ -4270,7 +4475,7 @@
tester.invalidate();
result = tester.eval(/* keepGoing= */ false, lastLeft, lastRight);
assertThat(result.hasError()).isTrue();
- tester.getOrCreate(leftValues[i], /*markAsModified=*/true).setHasError(false);
+ tester.getOrCreate(leftValues[i], /*markAsModified=*/ true).setHasError(false);
tester.invalidate();
result = tester.eval(/* keepGoing= */ false, lastLeft, lastRight);
assertThat(result.get(lastLeft)).isEqualTo(new StringValue("leaf"));
@@ -4308,13 +4513,13 @@
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.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.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.
+ tester.eval(/*keepGoing=*/ false, new SkyKey[0]); // Inject again.
assertThat(tester.evalAndGet(/*keepGoing=*/ false, key)).isEqualTo(val);
}
@@ -4467,22 +4672,25 @@
SkyKey persistentErrorKey1 = GraphTester.toSkyKey("persistentError1");
SkyKey persistentErrorKey2 = GraphTester.toSkyKey("persistentError2");
- TestFunction topFunction = tester.getOrCreate(topKey)
- .addErrorDependency(persistentErrorKey1, new StringValue("doesn't matter"))
- .setHasError(true);
+ TestFunction topFunction =
+ tester
+ .getOrCreate(topKey)
+ .addErrorDependency(persistentErrorKey1, new StringValue("doesn't matter"))
+ .setHasError(true);
tester.getOrCreate(persistentErrorKey1).setHasError(true);
if (includeTransientError) {
topFunction.addErrorDependency(transientErrorKey, new StringValue("doesn't matter"));
- tester.getOrCreate(transientErrorKey)
- .addErrorDependency(persistentErrorKey2, new StringValue("doesn't matter"))
- .setHasTransientError(true);
+ tester
+ .getOrCreate(transientErrorKey)
+ .addErrorDependency(persistentErrorKey2, new StringValue("doesn't matter"))
+ .setHasTransientError(true);
}
tester.getOrCreate(persistentErrorKey2).setHasError(true);
tester.evalAndGetError(/*keepGoing=*/ true, topKey);
if (includeTransientError) {
- assertThat(tester.getEnqueuedValues()).containsExactly(
- topKey, transientErrorKey, persistentErrorKey1, persistentErrorKey2);
+ assertThat(tester.getEnqueuedValues())
+ .containsExactly(topKey, transientErrorKey, persistentErrorKey1, persistentErrorKey2);
} else {
assertThat(tester.getEnqueuedValues()).containsExactly(topKey, persistentErrorKey1);
}
@@ -4528,7 +4736,9 @@
// Names are alphabetized in reverse deps of errorKey.
SkyKey fastToRequestSlowToSetValueKey = GraphTester.toSkyKey("A-slow-set-value-parent");
SkyKey failingKey = GraphTester.toSkyKey("B-fast-fail-parent");
- tester.getOrCreate(fastToRequestSlowToSetValueKey).addDependency(errorKey)
+ tester
+ .getOrCreate(fastToRequestSlowToSetValueKey)
+ .addDependency(errorKey)
.setComputedValue(CONCATENATE);
tester.getOrCreate(failingKey).addDependency(errorKey).setComputedValue(CONCATENATE);
// We only want to force a particular order of operations at some points during evaluation.
@@ -4567,11 +4777,11 @@
},
/*deterministic=*/ true);
// Initialize graph.
- tester.eval(/*keepGoing=*/true, errorKey);
- tester.getOrCreate(invalidatedKey, /*markAsModified=*/true);
+ tester.eval(/*keepGoing=*/ true, errorKey);
+ tester.getOrCreate(invalidatedKey, /*markAsModified=*/ true);
tester.invalidate();
synchronizeThreads.set(true);
- tester.eval(/*keepGoing=*/false, fastToRequestSlowToSetValueKey, failingKey);
+ tester.eval(/*keepGoing=*/ false, fastToRequestSlowToSetValueKey, failingKey);
}
/**
@@ -4599,9 +4809,11 @@
final SkyKey cachedParentKey = GraphTester.toSkyKey("A-cached-parent");
final SkyKey uncachedParentKey = GraphTester.toSkyKey("B-uncached-parent");
tester.getOrCreate(errorKey).addDependency(invalidatedKey).setHasError(true);
- tester.getOrCreate(cachedParentKey).addDependency(errorKey)
- .setComputedValue(CONCATENATE);
- tester.getOrCreate(uncachedParentKey).addDependency(changedKey).addDependency(errorKey)
+ tester.getOrCreate(cachedParentKey).addDependency(errorKey).setComputedValue(CONCATENATE);
+ tester
+ .getOrCreate(uncachedParentKey)
+ .addDependency(changedKey)
+ .addDependency(errorKey)
.setComputedValue(CONCATENATE);
// We only want to force a particular order of operations at some points during evaluation. In
// particular, we don't want to force anything during error bubbling.
@@ -4661,8 +4873,8 @@
},
/*deterministic=*/ true);
// Initialize graph.
- tester.eval(/*keepGoing=*/true, cachedParentKey, uncachedParentKey);
- tester.getOrCreate(invalidatedKey, /*markAsModified=*/true);
+ tester.eval(/*keepGoing=*/ true, cachedParentKey, uncachedParentKey);
+ tester.getOrCreate(invalidatedKey, /*markAsModified=*/ true);
tester.set(changedKey, new StringValue("new value"));
tester.invalidate();
synchronizeThreads.set(true);
@@ -4690,11 +4902,11 @@
}
});
EvaluationResult<StringValue> result =
- tester.eval(/*keepGoing=*/false, cachedParentKey, uncachedParentKey, waitForShutdownKey);
+ tester.eval(/*keepGoing=*/ false, cachedParentKey, uncachedParentKey, waitForShutdownKey);
assertWithMessage(result.toString()).that(result.hasError()).isTrue();
- tester.getOrCreate(invalidatedKey, /*markAsModified=*/true);
+ tester.getOrCreate(invalidatedKey, /*markAsModified=*/ true);
tester.invalidate();
- result = tester.eval(/*keepGoing=*/false, cachedParentKey, uncachedParentKey);
+ result = tester.eval(/*keepGoing=*/ false, cachedParentKey, uncachedParentKey);
assertWithMessage(result.toString()).that(result.hasError()).isTrue();
}
@@ -4705,12 +4917,12 @@
* Through forced synchronization, we make sure that the following sequence of events happens:
*
* <ol>
- * <li>topKey requests errorKey;
- * <li>errorKey is marked clean;
- * <li>topKey finishes its first evaluation and registers its deps;
- * <li>topKey restarts, since it sees that its only dep, errorKey, is done;
- * <li>topKey sees the error thrown by errorKey and throws the error, shutting down the
- * threadpool;
+ * <li>topKey requests errorKey;
+ * <li>errorKey is marked clean;
+ * <li>topKey finishes its first evaluation and registers its deps;
+ * <li>topKey restarts, since it sees that its only dep, errorKey, is done;
+ * <li>topKey sees the error thrown by errorKey and throws the error, shutting down the
+ * threadpool;
* </ol>
*/
@Test
@@ -4818,12 +5030,12 @@
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.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);
+ tester.eval(/*keepGoing=*/ true, parent1Key);
+ tester.eval(/*keepGoing=*/ false, parent2Key);
}
private void injectGraphListenerForTesting(Listener listener, boolean deterministic) {
@@ -5025,11 +5237,13 @@
SkyKey error = GraphTester.nonHermeticKey("error");
tester.getOrCreate(error).setHasError(true);
assertThatErrorInfo(tester.evalAndGetError(/*keepGoing=*/ true, error))
- .hasExceptionThat().isNotNull();
+ .hasExceptionThat()
+ .isNotNull();
tester.getOrCreate(error, /*markAsModified=*/ true);
tester.invalidate();
assertThatErrorInfo(tester.evalAndGetError(/*keepGoing=*/ true, error))
- .hasExceptionThat().isNotNull();
+ .hasExceptionThat()
+ .isNotNull();
}
@Test
@@ -5334,17 +5548,15 @@
return eval(keepGoing, toSkyKeys(keys).toArray(new SkyKey[0]));
}
- public SkyValue evalAndGet(boolean keepGoing, String key)
- throws InterruptedException {
+ public SkyValue evalAndGet(boolean keepGoing, String key) throws InterruptedException {
return evalAndGet(keepGoing, toSkyKey(key));
}
public SkyValue evalAndGet(String key) throws InterruptedException {
- return evalAndGet(/*keepGoing=*/false, key);
+ return evalAndGet(/*keepGoing=*/ false, key);
}
- public SkyValue evalAndGet(boolean keepGoing, SkyKey key)
- throws InterruptedException {
+ public SkyValue evalAndGet(boolean keepGoing, SkyKey key) throws InterruptedException {
EvaluationResult<StringValue> evaluationResult = eval(keepGoing, key);
SkyValue result = evaluationResult.get(key);
assertWithMessage(evaluationResult.toString()).that(result).isNotNull();
