public void TestMultipleRequestsWithAllResults()
{
CreateConfiguration(1, "foo.proj");
BuildRequest request1 = CreateBuildRequest(1, 1, new string[] { "foo" });
BuildResult result1 = CacheBuildResult(request1, "foo", BuildResultUtilities.GetSuccessResult());
CreateConfiguration(2, "bar.proj");
BuildRequest request2 = CreateBuildRequest(2, 2, new string[] { "bar" });
BuildResult result2 = CacheBuildResult(request2, "bar", BuildResultUtilities.GetSuccessResult());
BuildRequestBlocker blocker = new BuildRequestBlocker(request1.ParentGlobalRequestId, new string[] { }, new BuildRequest[] { request1, request2 });
List <ScheduleResponse> response = new List <ScheduleResponse>(_scheduler.ReportRequestBlocked(1, blocker));
Assert.Equal(3, response.Count);
// First two are the results which were cached.
Assert.Equal(ScheduleActionType.ReportResults, response[0].Action);
Assert.True(ResultsCache_Tests.AreResultsIdentical(result1, response[0].Unblocker.Result));
Assert.Equal(ScheduleActionType.ReportResults, response[1].Action);
Assert.True(ResultsCache_Tests.AreResultsIdentical(result2, response[1].Unblocker.Result));
// Last response is to continue the parent.
Assert.Equal(ScheduleActionType.ResumeExecution, response[2].Action);
Assert.Equal(request1.ParentGlobalRequestId, response[2].Unblocker.BlockedRequestId);
Assert.Null(response[2].Unblocker.Result);
}
public void TestResultsWithNoMatch1()
{
BuildRequest request = CreateNewBuildRequest(1, new string[1] {
"foo"
});
BuildRequestConfiguration config = new BuildRequestConfiguration(1, new BuildRequestData("foo", new Dictionary <string, string>(), "foo", Array.Empty <string>(), null), "2.0");
BuildRequestEntry entry = new BuildRequestEntry(request, config);
Assert.Equal(BuildRequestEntryState.Ready, entry.State);
entry.Continue();
Assert.Equal(BuildRequestEntryState.Active, entry.State);
BuildRequest waitingRequest1 = CreateNewBuildRequest(2, new string[1] {
"bar"
});
entry.WaitForResult(waitingRequest1);
Assert.Equal(BuildRequestEntryState.Waiting, entry.State);
BuildRequest randomRequest = CreateNewBuildRequest(3, Array.Empty <string>());
BuildResult requiredResult = new BuildResult(randomRequest);
requiredResult.AddResultsForTarget("bar", BuildResultUtilities.GetEmptySucceedingTargetResult());
entry.ReportResult(requiredResult);
Assert.Equal(BuildRequestEntryState.Waiting, entry.State);
}
public void CacheCanBeEnumerated()
{
ResultsCache cache = new ResultsCache();
BuildRequest request = new BuildRequest(submissionId: 1, nodeRequestId: 0, configurationId: 1, new string[1] {
"testTarget"
}, null, BuildEventContext.Invalid, null);
BuildResult result = new BuildResult(request);
result.AddResultsForTarget("result1target1", BuildResultUtilities.GetEmptyFailingTargetResult());
cache.AddResult(result);
request = new BuildRequest(1 /* submissionId */, 0, 1, new string[1] {
"otherTarget"
}, null, BuildEventContext.Invalid, null);
result = new BuildResult(request);
result.AddResultsForTarget("result1target2", BuildResultUtilities.GetEmptySucceedingTargetResult());
cache.AddResult(result);
BuildResult result2 = new BuildResult(new BuildRequest(submissionId: 1, nodeRequestId: 0, configurationId: 2, new string[1] {
"testTarget"
}, null, BuildEventContext.Invalid, null));
result2.AddResultsForTarget("result2target1", BuildResultUtilities.GetEmptyFailingTargetResult());
cache.AddResult(result2);
var results = cache.GetEnumerator().ToArray();
results.Length.ShouldBe(2);
Assert.True(results[0].HasResultsForTarget("result1target1"));
Assert.True(results[0].HasResultsForTarget("result1target2"));
Assert.True(results[1].HasResultsForTarget("result2target1"));
}
public void TestOverallResult()
{
BuildRequest request = CreateNewBuildRequest(1, new string[0]);
BuildResult result = new BuildResult(request);
Assert.Equal(BuildResultCode.Success, result.OverallResult);
result.AddResultsForTarget("foo", BuildResultUtilities.GetEmptySucceedingTargetResult());
Assert.Equal(BuildResultCode.Success, result.OverallResult);
result.AddResultsForTarget("bar", new TargetResult(new TaskItem[0] {
}, new WorkUnitResult(WorkUnitResultCode.Success, WorkUnitActionCode.Continue, new Exception())));
Assert.Equal(BuildResultCode.Success, result.OverallResult);
result.AddResultsForTarget("baz", new TargetResult(new TaskItem[0] {
}, BuildResultUtilities.GetStopWithErrorResult(new Exception())));
Assert.Equal(BuildResultCode.Failure, result.OverallResult);
BuildRequest request2 = CreateNewBuildRequest(2, new string[0]);
BuildResult result2 = new BuildResult(request2);
result2.AddResultsForTarget("foo", BuildResultUtilities.GetEmptySucceedingTargetResult());
result2.AddResultsForTarget("bar", BuildResultUtilities.GetEmptyFailingTargetResult());
Assert.Equal(BuildResultCode.Failure, result2.OverallResult);
}
public void TestMergeResults()
{
BuildRequest request = CreateNewBuildRequest(1, new string[0]);
BuildResult result = new BuildResult(request);
result.AddResultsForTarget("foo", BuildResultUtilities.GetEmptySucceedingTargetResult());
BuildResult result2 = new BuildResult(request);
result.AddResultsForTarget("bar", BuildResultUtilities.GetEmptyFailingTargetResult());
result.MergeResults(result2);
Assert.Equal(TargetResultCode.Success, result["foo"].ResultCode);
Assert.Equal(TargetResultCode.Failure, result["bar"].ResultCode);
BuildResult result3 = new BuildResult(request);
result.MergeResults(result3);
BuildResult result4 = new BuildResult(request);
result4.AddResultsForTarget("xor", BuildResultUtilities.GetEmptySucceedingTargetResult());
result.MergeResults(result4);
Assert.Equal(TargetResultCode.Success, result["foo"].ResultCode);
Assert.Equal(TargetResultCode.Failure, result["bar"].ResultCode);
Assert.Equal(TargetResultCode.Success, result["xor"].ResultCode);
}
public void TestResolveConfiguration()
{
BuildRequest request = CreateNewBuildRequest(1, new string[1] {
"foo"
});
BuildRequestData data1 = new BuildRequestData("foo", new Dictionary <string, string>(), "foo", new string[0], null);
BuildRequestConfiguration config = new BuildRequestConfiguration(1, data1, "2.0");
BuildRequestEntry entry = new BuildRequestEntry(request, config);
entry.Continue();
Assert.Equal(BuildRequestEntryState.Active, entry.State);
BuildRequest waitingRequest = CreateNewBuildRequest(-1, new string[1] {
"bar"
});
entry.WaitForResult(waitingRequest);
entry.ResolveConfigurationRequest(-1, 2);
BuildResult requiredResult = new BuildResult(waitingRequest);
requiredResult.AddResultsForTarget("bar", BuildResultUtilities.GetEmptySucceedingTargetResult());
entry.ReportResult(requiredResult);
Assert.Equal(BuildRequestEntryState.Ready, entry.State);
}
public void TestChildRequest()
{
CreateConfiguration(1, "foo.proj");
BuildRequest request = CreateBuildRequest(1, 1, new string[] { "foo" });
BuildRequestBlocker blocker = new BuildRequestBlocker(-1, new string[] { }, new BuildRequest[] { request });
List <ScheduleResponse> response = new List <ScheduleResponse>(_scheduler.ReportRequestBlocked(1, blocker));
CreateConfiguration(2, "bar.proj");
BuildRequest childRequest = CreateBuildRequest(2, 2, new string[] { "foo" }, request);
BuildResult childResult = CacheBuildResult(childRequest, "foo", BuildResultUtilities.GetSuccessResult());
blocker = new BuildRequestBlocker(0, new string[] { "foo" }, new BuildRequest[] { childRequest });
response = new List <ScheduleResponse>(_scheduler.ReportRequestBlocked(1, blocker));
Assert.Equal(2, response.Count);
// The first response will be to report the results back to the node.
Assert.Equal(ScheduleActionType.ReportResults, response[0].Action);
Assert.True(ResultsCache_Tests.AreResultsIdentical(childResult, response[0].Unblocker.Result));
// The second response will be to continue building the original request.
Assert.Equal(ScheduleActionType.ResumeExecution, response[1].Action);
Assert.Null(response[1].Unblocker.Result);
}
public void TestNoCompleteToWaiting()
{
Assert.Throws <InternalErrorException>(() =>
{
BuildRequest request = CreateNewBuildRequest(1, new string[1] {
"foo"
});
BuildRequestConfiguration config = new BuildRequestConfiguration(1, new BuildRequestData("foo", new Dictionary <string, string>(), "foo", Array.Empty <string>(), null), "2.0");
BuildRequestEntry entry = new BuildRequestEntry(request, config);
Assert.Equal(BuildRequestEntryState.Ready, entry.State);
entry.Continue();
Assert.Equal(BuildRequestEntryState.Active, entry.State);
BuildResult requiredResult = new BuildResult(request);
requiredResult.AddResultsForTarget("foo", BuildResultUtilities.GetEmptySucceedingTargetResult());
entry.Complete(requiredResult);
Assert.Equal(BuildRequestEntryState.Complete, entry.State);
BuildRequest waitingRequest1 = CreateNewBuildRequest(2, new string[1] {
"bar"
});
entry.WaitForResult(waitingRequest1);
}
);
}
public void TestConstructorNoItems()
{
TargetResult result = new TargetResult(new TaskItem[] { }, BuildResultUtilities.GetStopWithErrorResult());
Assert.Empty(result.Items);
Assert.Null(result.Exception);
Assert.Equal(TargetResultCode.Failure, result.ResultCode);
}
public void TestConstructorNullItems()
{
Assert.Throws <ArgumentNullException>(() =>
{
TargetResult result = new TargetResult(null, BuildResultUtilities.GetStopWithErrorResult());
}
);
}
public void TestConstructorWithExceptionNull()
{
TaskItem item = new TaskItem("foo", "bar.proj");
TargetResult result = new TargetResult(new TaskItem[] { item }, BuildResultUtilities.GetStopWithErrorResult());
Assert.Single(result.Items);
Assert.Null(result.Exception);
Assert.Equal(TargetResultCode.Failure, result.ResultCode);
}
public void TestSimpleStateProgression()
{
// Start in Ready
BuildRequest request = CreateNewBuildRequest(1, new string[1] {
"foo"
});
BuildRequestConfiguration config = new BuildRequestConfiguration(1, new BuildRequestData("foo", new Dictionary <string, string>(), "foo", Array.Empty <string>(), null), "2.0");
BuildRequestEntry entry = new BuildRequestEntry(request, config);
Assert.Equal(BuildRequestEntryState.Ready, entry.State);
Assert.Equal(entry.Request, request);
Assert.Null(entry.Result);
// Move to active. Should not be any results yet.
IDictionary <int, BuildResult> results = entry.Continue();
Assert.Equal(BuildRequestEntryState.Active, entry.State);
Assert.Null(entry.Result);
Assert.Null(results);
// Wait for results, move to waiting.
BuildRequest waitingRequest = CreateNewBuildRequest(2, new string[1] {
"bar"
});
entry.WaitForResult(waitingRequest);
Assert.Equal(BuildRequestEntryState.Waiting, entry.State);
Assert.Equal(entry.Request, request);
Assert.Null(entry.Result);
// Provide the results, move to ready.
BuildResult requiredResult = new BuildResult(waitingRequest);
requiredResult.AddResultsForTarget("bar", BuildResultUtilities.GetEmptySucceedingTargetResult());
entry.ReportResult(requiredResult);
Assert.Equal(BuildRequestEntryState.Ready, entry.State);
Assert.Equal(entry.Request, request);
Assert.Null(entry.Result);
// Continue the build, move to active.
results = entry.Continue();
Assert.Equal(BuildRequestEntryState.Active, entry.State);
Assert.Null(entry.Result);
Assert.Single(results);
Assert.True(results.ContainsKey(requiredResult.NodeRequestId));
Assert.Equal(results[requiredResult.NodeRequestId], requiredResult);
// Complete the build, move to completed.
BuildResult result = new BuildResult(request);
result.AddResultsForTarget("foo", BuildResultUtilities.GetEmptySucceedingTargetResult());
entry.Complete(result);
Assert.Equal(BuildRequestEntryState.Complete, entry.State);
Assert.NotNull(entry.Result);
Assert.Equal(entry.Result, result);
}
public void TestBuildWithChildren()
{
BuildRequestData data = new BuildRequestData("TestFile", new Dictionary <string, string>(), "TestToolsVersion", new string[0], null);
BuildRequestConfiguration config = new BuildRequestConfiguration(1, data, "2.0");
_cache.AddConfiguration(config);
// Configure the builder to spawn build requests
MockRequestBuilder builder = (MockRequestBuilder)_host.GetComponent(BuildComponentType.RequestBuilder);
builder.NewRequests.Add(new FullyQualifiedBuildRequest[1] {
new FullyQualifiedBuildRequest(config, new string[1] {
"requiredTarget1"
}, true)
});
// Create the initial build request
string[] targets = new string[3] {
"target1", "target2", "target3"
};
BuildRequest request = CreateNewBuildRequest(1, targets);
// Kick it off
VerifyEngineStatus(BuildRequestEngineStatus.Uninitialized);
_engine.InitializeForBuild(new NodeLoggingContext(_host.LoggingService, 0, false));
_engine.SubmitBuildRequest(request);
Thread.Sleep(250);
VerifyEngineStatus(BuildRequestEngineStatus.Active);
// Wait for the new requests to be spawned by the builder
WaitForEvent(_newRequestEvent, "NewRequestEvent");
Assert.Equal(1, _newRequest_Request.BuildRequests[0].ConfigurationId);
Assert.Single(_newRequest_Request.BuildRequests[0].Targets);
Assert.Equal("requiredTarget1", _newRequest_Request.BuildRequests[0].Targets[0]);
// Wait for a moment, because the build request engine thread may not have gotten around
// to going to the waiting state.
Thread.Sleep(250);
VerifyEngineStatus(BuildRequestEngineStatus.Waiting);
// Report a result to satisfy the build request
BuildResult result = new BuildResult(_newRequest_Request.BuildRequests[0]);
result.AddResultsForTarget("requiredTarget1", BuildResultUtilities.GetEmptySucceedingTargetResult());
_engine.UnblockBuildRequest(new BuildRequestUnblocker(result));
// Continue the request.
_engine.UnblockBuildRequest(new BuildRequestUnblocker(request.GlobalRequestId));
// Wait for the original request to complete
WaitForEvent(_requestCompleteEvent, "RequestComplete");
Assert.Equal(request, _requestComplete_Request);
Assert.Equal(BuildResultCode.Success, _requestComplete_Result.OverallResult);
VerifyEngineStatus(BuildRequestEngineStatus.Idle);
}
public void TestHasResultsForTarget()
{
BuildRequest request = CreateNewBuildRequest(1, new string[0]);
BuildResult result = new BuildResult(request);
result.AddResultsForTarget("foo", BuildResultUtilities.GetEmptySucceedingTargetResult());
Assert.True(result.HasResultsForTarget("foo"));
Assert.False(result.HasResultsForTarget("bar"));
}
public void TestAddResultsInvalid3()
{
Assert.Throws <ArgumentNullException>(() =>
{
BuildRequest request = CreateNewBuildRequest(1, new string[0]);
BuildResult result = new BuildResult(request);
result.AddResultsForTarget(null, BuildResultUtilities.GetEmptySucceedingTargetResult());
}
);
}
public void TestIndexerBad2()
{
Assert.Throws <KeyNotFoundException>(() =>
{
BuildRequest request = CreateNewBuildRequest(1, new string[0]);
BuildResult result = new BuildResult(request);
result.AddResultsForTarget("foo", BuildResultUtilities.GetEmptySucceedingTargetResult());
ITargetResult targetResult = result["bar"];
}
);
}
public void TestAddAndRetrieve()
{
BuildRequest request = CreateNewBuildRequest(1, Array.Empty <string>());
BuildResult result = new BuildResult(request);
result.AddResultsForTarget("foo", BuildResultUtilities.GetEmptySucceedingTargetResult());
result.AddResultsForTarget("bar", BuildResultUtilities.GetEmptyFailingTargetResult());
Assert.Equal(TargetResultCode.Success, result["foo"].ResultCode);
Assert.Equal(TargetResultCode.Failure, result["bar"].ResultCode);
}
public void TestMergeResultsBad1()
{
Assert.Throws <ArgumentNullException>(() =>
{
BuildRequest request = CreateNewBuildRequest(1, Array.Empty <string>());
BuildResult result = new BuildResult(request);
result.AddResultsForTarget("foo", BuildResultUtilities.GetEmptySucceedingTargetResult());
result.MergeResults(null);
}
);
}
public void TestEnumerator()
{
BuildRequest request = CreateNewBuildRequest(1, new string[0]);
BuildResult result = new BuildResult(request);
int countFound = 0;
foreach (KeyValuePair <string, TargetResult> resultPair in result.ResultsByTarget)
{
countFound++;
}
Assert.Equal(0, countFound);
result.AddResultsForTarget("foo", BuildResultUtilities.GetEmptySucceedingTargetResult());
bool foundFoo = false;
countFound = 0;
foreach (KeyValuePair <string, TargetResult> resultPair in result.ResultsByTarget)
{
if (resultPair.Key == "foo")
{
foundFoo = true;
}
countFound++;
}
Assert.Equal(1, countFound);
Assert.True(foundFoo);
result.AddResultsForTarget("bar", BuildResultUtilities.GetEmptySucceedingTargetResult());
foundFoo = false;
bool foundBar = false;
countFound = 0;
foreach (KeyValuePair <string, TargetResult> resultPair in result.ResultsByTarget)
{
if (resultPair.Key == "foo")
{
Assert.False(foundFoo);
foundFoo = true;
}
if (resultPair.Key == "bar")
{
Assert.False(foundBar);
foundBar = true;
}
countFound++;
}
Assert.Equal(2, countFound);
Assert.True(foundFoo);
Assert.True(foundBar);
}
public void TestAddAndRetrieveResults()
{
ResultsCache cache = new ResultsCache();
BuildRequest request = new BuildRequest(1 /* submissionId */, 0, 1, new string[1] {
"testTarget"
}, null, BuildEventContext.Invalid, null); BuildResult result = new BuildResult(request);
result.AddResultsForTarget("testTarget", BuildResultUtilities.GetEmptyFailingTargetResult());
cache.AddResult(result);
BuildResult retrievedResult = cache.GetResultForRequest(request);
Assert.True(AreResultsIdentical(result, retrievedResult));
}
public void TestTwoRequestsWithSecondFailure()
{
CreateConfiguration(1, "foo.proj");
BuildRequest request1 = CreateBuildRequest(1, 1, new string[] { "foo" });
BuildRequest request2 = CreateBuildRequest(2, 1, new string[] { "bar" });
BuildResult result2 = CacheBuildResult(request2, "bar", BuildResultUtilities.GetStopWithErrorResult());
BuildRequestBlocker blocker = new BuildRequestBlocker(request1.ParentGlobalRequestId, new string[] { }, new BuildRequest[] { request1, request2 });
List <ScheduleResponse> response = new List <ScheduleResponse>(_scheduler.ReportRequestBlocked(1, blocker));
Assert.Equal(2, response.Count);
Assert.True(ResultsCache_Tests.AreResultsIdentical(result2, response[0].Unblocker.Result));
Assert.Equal(ScheduleActionType.ScheduleWithConfiguration, response[1].Action);
}
public void TestTranslationWithException()
{
TaskItem item = new TaskItem("foo", "bar.proj");
item.SetMetadata("a", "b");
TargetResult result = new TargetResult(new TaskItem[] { item }, BuildResultUtilities.GetStopWithErrorResult(new BuildAbortedException()));
((ITranslatable)result).Translate(TranslationHelpers.GetWriteTranslator());
TargetResult deserializedResult = TargetResult.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
Assert.Equal(result.ResultCode, deserializedResult.ResultCode);
Assert.True(TranslationHelpers.CompareCollections(result.Items, deserializedResult.Items, TaskItemComparer.Instance));
Assert.True(TranslationHelpers.CompareExceptions(result.Exception, deserializedResult.Exception));
}
public void TestRetrieveIncompleteResults()
{
Assert.Throws <InternalErrorException>(() =>
{
ResultsCache cache = new ResultsCache();
BuildRequest request = new BuildRequest(1 /* submissionId */, 0, 1, new string[2] {
"testTarget", "testTarget2"
}, null, BuildEventContext.Invalid, null);
BuildResult result = new BuildResult(request);
result.AddResultsForTarget("testTarget", BuildResultUtilities.GetEmptyFailingTargetResult());
cache.AddResult(result);
cache.GetResultForRequest(request);
}
);
}
public void TestMergeResultsBad3()
{
Assert.Throws <InternalErrorException>(() =>
{
BuildRequest request = CreateNewBuildRequest(1, new string[0]);
BuildResult result = new BuildResult(request);
result.AddResultsForTarget("foo", BuildResultUtilities.GetEmptySucceedingTargetResult());
BuildRequest request2 = CreateNewBuildRequest(2, new string[0]);
BuildResult result2 = new BuildResult(request2);
result2.AddResultsForTarget("bar", BuildResultUtilities.GetEmptySucceedingTargetResult());
result.MergeResults(result2);
}
);
}
public void TestMergeResultsWithException()
{
ResultsCache cache = new ResultsCache();
BuildRequest request = new BuildRequest(1 /* submissionId */, 0, 1, new string[] { "testTarget" }, null, BuildEventContext.Invalid, null);
BuildResult result = new BuildResult(request);
result.AddResultsForTarget("testTarget", BuildResultUtilities.GetEmptyFailingTargetResult());
cache.AddResult(result);
BuildResult result2 = new BuildResult(request, new Exception("Test exception"));
cache.AddResult(result2);
BuildResult retrievedResult = cache.GetResultForRequest(request);
Assert.NotNull(retrievedResult.Exception);
}
public void TestMultipleRequestsWithSomeResults()
{
CreateConfiguration(1, "foo.proj");
BuildRequest request1 = CreateBuildRequest(1, 1, new string[] { "foo" });
CreateConfiguration(2, "bar.proj");
BuildRequest request2 = CreateBuildRequest(2, 2, new string[] { "bar" });
BuildResult result2 = CacheBuildResult(request2, "bar", BuildResultUtilities.GetSuccessResult());
BuildRequestBlocker blocker = new BuildRequestBlocker(request1.ParentGlobalRequestId, Array.Empty <string>(), new BuildRequest[] { request1, request2 });
List <ScheduleResponse> response = new List <ScheduleResponse>(_scheduler.ReportRequestBlocked(1, blocker));
Assert.Equal(2, response.Count);
Assert.Equal(ScheduleActionType.ReportResults, response[0].Action);
Assert.True(ResultsCache_Tests.AreResultsIdentical(result2, response[0].Unblocker.Result));
Assert.Equal(ScheduleActionType.ScheduleWithConfiguration, response[1].Action);
Assert.Equal(request1, response[1].BuildRequest);
}
public void TestClearResultsCache()
{
ResultsCache cache = new ResultsCache();
cache.ClearResults();
BuildRequest request = new BuildRequest(1 /* submissionId */, 0, 1, new string[1] {
"testTarget2"
}, null, BuildEventContext.Invalid, null);
BuildResult result = new BuildResult(request);
result.AddResultsForTarget("testTarget", BuildResultUtilities.GetEmptyFailingTargetResult());
cache.AddResult(result);
cache.ClearResults();
Assert.Null(cache.GetResultForRequest(request));
}
public void TestNoReadyToComplete()
{
Assert.Throws <InternalErrorException>(() =>
{
BuildRequest request = CreateNewBuildRequest(1, new string[1] {
"foo"
});
BuildRequestData data1 = new BuildRequestData("foo", new Dictionary <string, string>(), "foo", new string[0], null);
BuildRequestConfiguration config = new BuildRequestConfiguration(1, data1, "2.0");
BuildRequestEntry entry = new BuildRequestEntry(request, config);
Assert.Equal(BuildRequestEntryState.Ready, entry.State);
BuildResult requiredResult = new BuildResult(request);
requiredResult.AddResultsForTarget("foo", BuildResultUtilities.GetEmptySucceedingTargetResult());
entry.Complete(requiredResult);
}
);
}
public void TestMixedWaitingRequests()
{
BuildRequest request = CreateNewBuildRequest(1, new string[1] {
"foo"
});
BuildRequestConfiguration config = new BuildRequestConfiguration(1, new BuildRequestData("foo", new Dictionary <string, string>(), "foo", Array.Empty <string>(), null), "2.0");
BuildRequestEntry entry = new BuildRequestEntry(request, config);
Assert.Equal(BuildRequestEntryState.Ready, entry.State);
entry.Continue();
Assert.Equal(BuildRequestEntryState.Active, entry.State);
BuildRequest waitingRequest1 = CreateNewBuildRequest(2, new string[1] {
"bar"
});
entry.WaitForResult(waitingRequest1);
Assert.Equal(BuildRequestEntryState.Waiting, entry.State);
BuildRequest waitingRequest2 = CreateNewBuildRequest(-1, new string[1] {
"xor"
});
entry.WaitForResult(waitingRequest2);
Assert.Equal(BuildRequestEntryState.Waiting, entry.State);
Assert.Null(entry.GetRequestsToIssueIfReady()); // "Entry should not be ready to issue because there are unresolved configurations"
entry.ResolveConfigurationRequest(-1, 3);
Assert.Equal(BuildRequestEntryState.Waiting, entry.State);
BuildResult requiredResult1 = new BuildResult(waitingRequest1);
requiredResult1.AddResultsForTarget("bar", BuildResultUtilities.GetEmptySucceedingTargetResult());
entry.ReportResult(requiredResult1);
Assert.Equal(BuildRequestEntryState.Waiting, entry.State);
BuildResult requiredResult2 = new BuildResult(waitingRequest2);
requiredResult2.AddResultsForTarget("xor", BuildResultUtilities.GetEmptySucceedingTargetResult());
entry.ReportResult(requiredResult2);
Assert.Equal(BuildRequestEntryState.Ready, entry.State);
}
public void TestSimpleRequestWithCachedResultsFail()
{
CreateConfiguration(1, "foo.proj");
BuildRequest request = CreateBuildRequest(1, 1, new string[] { "foo" });
BuildResult result = CacheBuildResult(request, "foo", BuildResultUtilities.GetStopWithErrorResult());
BuildRequestBlocker blocker = new BuildRequestBlocker(request.ParentGlobalRequestId, new string[] { }, new BuildRequest[] { request });
List <ScheduleResponse> response = new List <ScheduleResponse>(_scheduler.ReportRequestBlocked(1, blocker));
Assert.Equal(2, response.Count);
// First response tells the parent of the results.
Assert.Equal(ScheduleActionType.ReportResults, response[0].Action);
Assert.True(ResultsCache_Tests.AreResultsIdentical(result, response[0].Unblocker.Result));
// Second response tells the parent to continue.
Assert.Equal(ScheduleActionType.ResumeExecution, response[1].Action);
Assert.Null(response[1].Unblocker.Result);
}
