public void TestSimpleBuildRequest()
{
BuildRequestConfiguration configuration = CreateTestProject(1);
try
{
TestTargetBuilder targetBuilder = (TestTargetBuilder)_host.GetComponent(BuildComponentType.TargetBuilder);
IConfigCache configCache = (IConfigCache)_host.GetComponent(BuildComponentType.ConfigCache);
configCache.AddConfiguration(configuration);
BuildRequest request = CreateNewBuildRequest(1, new string[1] { "target1" });
BuildRequestEntry entry = new BuildRequestEntry(request, configuration);
BuildResult result = new BuildResult(request);
result.AddResultsForTarget("target1", GetEmptySuccessfulTargetResult());
targetBuilder.SetResultsToReturn(result);
_requestBuilder.BuildRequest(GetNodeLoggingContext(), entry);
WaitForEvent(_buildRequestCompletedEvent, "Build Request Completed");
Assert.Equal(BuildRequestEntryState.Complete, entry.State);
Assert.Equal(entry, _buildRequestCompleted_Entry);
Assert.Equal(BuildResultCode.Success, _buildRequestCompleted_Entry.Result.OverallResult);
}
finally
{
DeleteTestProject(configuration);
}
}
/// <summary>
/// Set up and initialize before each test is run
/// </summary>
///
public TaskHost_Tests()
{
LoggingServiceFactory loggingFactory = new LoggingServiceFactory(LoggerMode.Synchronous, 1);
_loggingService = loggingFactory.CreateInstance(BuildComponentType.LoggingService) as LoggingService;
_customLogger = new MyCustomLogger();
_mockHost = new MockHost();
_mockHost.LoggingService = _loggingService;
_loggingService.RegisterLogger(_customLogger);
_elementLocation = ElementLocation.Create("MockFile", 5, 5);
BuildRequest buildRequest = new BuildRequest(1 /* submissionId */, 1, 1, new List<string>(), null, BuildEventContext.Invalid, null);
BuildRequestConfiguration configuration = new BuildRequestConfiguration(1, new BuildRequestData("Nothing", new Dictionary<string, string>(), "4.0", new string[0], null), "2.0");
configuration.Project = new ProjectInstance(ProjectRootElement.Create());
BuildRequestEntry entry = new BuildRequestEntry(buildRequest, configuration);
BuildResult buildResult = new BuildResult(buildRequest, false);
buildResult.AddResultsForTarget("Build", new TargetResult(new TaskItem[] { new TaskItem("IamSuper", configuration.ProjectFullPath) }, TestUtilities.GetSkippedResult()));
_mockRequestCallback = new MockIRequestBuilderCallback(new BuildResult[] { buildResult });
entry.Builder = (IRequestBuilder)_mockRequestCallback;
_taskHost = new TaskHost(_mockHost, entry, _elementLocation, null /*Dont care about the callback either unless doing a build*/);
_taskHost.LoggingContext = new TaskLoggingContext(_loggingService, BuildEventContext.Invalid);
}
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", TestUtilities.GetEmptyFailingTargetResult());
cache.AddResult(result);
BuildResult retrievedResult = cache.GetResultForRequest(request);
Assert.True(AreResultsIdentical(result, retrievedResult));
}
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", new string[0], null), "2.0");
BuildRequestEntry entry = new BuildRequestEntry(request, config);
Assert.AreEqual(entry.State, BuildRequestEntryState.Ready);
Assert.AreEqual(entry.Request, request);
Assert.IsNull(entry.Result);
// Move to active. Should not be any results yet.
IDictionary<int, BuildResult> results = entry.Continue();
Assert.AreEqual(entry.State, BuildRequestEntryState.Active);
Assert.IsNull(entry.Result);
Assert.IsNull(results);
// Wait for results, move to waiting.
BuildRequest waitingRequest = CreateNewBuildRequest(2, new string[1] { "bar" });
entry.WaitForResult(waitingRequest);
Assert.AreEqual(entry.State, BuildRequestEntryState.Waiting);
Assert.AreEqual(entry.Request, request);
Assert.IsNull(entry.Result);
// Provide the results, move to ready.
BuildResult requiredResult = new BuildResult(waitingRequest);
requiredResult.AddResultsForTarget("bar", TestUtilities.GetEmptySucceedingTargetResult());
entry.ReportResult(requiredResult);
Assert.AreEqual(entry.State, BuildRequestEntryState.Ready);
Assert.AreEqual(entry.Request, request);
Assert.IsNull(entry.Result);
// Continue the build, move to active.
results = entry.Continue();
Assert.AreEqual(entry.State, BuildRequestEntryState.Active);
Assert.IsNull(entry.Result);
Assert.AreEqual(results.Count, 1);
Assert.IsTrue(results.ContainsKey(requiredResult.NodeRequestId));
Assert.AreEqual(results[requiredResult.NodeRequestId], requiredResult);
// Complete the build, move to completed.
BuildResult result = new BuildResult(request);
result.AddResultsForTarget("foo", TestUtilities.GetEmptySucceedingTargetResult());
entry.Complete(result);
Assert.AreEqual(entry.State, BuildRequestEntryState.Complete);
Assert.IsNotNull(entry.Result);
Assert.AreEqual(entry.Result, result);
}
public void TestAddAndRetrieveResultsByConfiguration()
{
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", TestUtilities.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("otherTarget", TestUtilities.GetEmptySucceedingTargetResult());
cache.AddResult(result);
BuildResult retrievedResult = cache.GetResultsForConfiguration(1);
Assert.True(retrievedResult.HasResultsForTarget("testTarget"));
Assert.True(retrievedResult.HasResultsForTarget("otherTarget"));
}
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", new string[0], null), "2.0");
BuildRequestEntry entry = new BuildRequestEntry(request, config);
Assert.Equal(entry.State, BuildRequestEntryState.Ready);
entry.Continue();
Assert.Equal(entry.State, BuildRequestEntryState.Active);
BuildResult requiredResult = new BuildResult(request);
requiredResult.AddResultsForTarget("foo", TestUtilities.GetEmptySucceedingTargetResult());
entry.Complete(requiredResult);
Assert.Equal(entry.State, BuildRequestEntryState.Complete);
BuildRequest waitingRequest1 = CreateNewBuildRequest(2, new string[1] { "bar" });
entry.WaitForResult(waitingRequest1);
}
);
}
public void TestBuildWithNewConfiguration()
{
BuildRequestData data = new BuildRequestData(Path.GetFullPath("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);
BuildRequestData data2 = new BuildRequestData(Path.GetFullPath("OtherFile"), new Dictionary<string, string>(), "TestToolsVersion", new string[0], null);
BuildRequestConfiguration unresolvedConfig = new BuildRequestConfiguration(data2, "2.0");
builder.NewRequests.Add(new FullyQualifiedBuildRequest[1] { new FullyQualifiedBuildRequest(unresolvedConfig, 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 request to generate the child request with the unresolved configuration
WaitForEvent(_newConfigurationEvent, "NewConfigurationEvent");
Assert.Equal(Path.GetFullPath("OtherFile"), _newConfiguration_Config.ProjectFullPath);
Assert.Equal("TestToolsVersion", _newConfiguration_Config.ToolsVersion);
Assert.True(_newConfiguration_Config.WasGeneratedByNode);
Thread.Sleep(250);
VerifyEngineStatus(BuildRequestEngineStatus.Waiting);
// Resolve the configuration
BuildRequestConfigurationResponse response = new BuildRequestConfigurationResponse(_newConfiguration_Config.ConfigurationId, 2, 0);
_engine.ReportConfigurationResponse(response);
// Now wait for the actual requests to be issued.
WaitForEvent(_newRequestEvent, "NewRequestEvent");
Assert.Equal(2, _newRequest_Request.BuildRequests[0].ConfigurationId);
Assert.Equal(2, _newRequest_Request.BuildRequests[0].ConfigurationId);
Assert.Equal(1, _newRequest_Request.BuildRequests[0].Targets.Count);
Assert.Equal("requiredTarget1", _newRequest_Request.BuildRequests[0].Targets[0]);
// Report a result to satisfy the build request
BuildResult result = new BuildResult(_newRequest_Request.BuildRequests[0]);
result.AddResultsForTarget("requiredTarget1", TestUtilities.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);
Thread.Sleep(250);
VerifyEngineStatus(BuildRequestEngineStatus.Idle);
}
public void TestMixedWaitingRequests()
{
BuildRequest request = CreateNewBuildRequest(1, new string[1] { "foo" });
BuildRequestConfiguration config = new BuildRequestConfiguration(1, new BuildRequestData("foo", new Dictionary<string, string>(), "foo", new string[0], null), "2.0");
BuildRequestEntry entry = new BuildRequestEntry(request, config);
Assert.AreEqual(entry.State, BuildRequestEntryState.Ready);
entry.Continue();
Assert.AreEqual(entry.State, BuildRequestEntryState.Active);
BuildRequest waitingRequest1 = CreateNewBuildRequest(2, new string[1] { "bar" });
entry.WaitForResult(waitingRequest1);
Assert.AreEqual(entry.State, BuildRequestEntryState.Waiting);
BuildRequest waitingRequest2 = CreateNewBuildRequest(-1, new string[1] { "xor" });
entry.WaitForResult(waitingRequest2);
Assert.AreEqual(entry.State, BuildRequestEntryState.Waiting);
Assert.IsNull(entry.GetRequestsToIssueIfReady(), "Entry should not be ready to issue because there are unresolved configurations");
entry.ResolveConfigurationRequest(-1, 3);
Assert.AreEqual(entry.State, BuildRequestEntryState.Waiting);
BuildResult requiredResult1 = new BuildResult(waitingRequest1);
requiredResult1.AddResultsForTarget("bar", TestUtilities.GetEmptySucceedingTargetResult());
entry.ReportResult(requiredResult1);
Assert.AreEqual(entry.State, BuildRequestEntryState.Waiting);
BuildResult requiredResult2 = new BuildResult(waitingRequest2);
requiredResult2.AddResultsForTarget("xor", TestUtilities.GetEmptySucceedingTargetResult());
entry.ReportResult(requiredResult2);
Assert.AreEqual(entry.State, BuildRequestEntryState.Ready);
}
public void TestResultsWithNoMatch1()
{
BuildRequest request = CreateNewBuildRequest(1, new string[1] { "foo" });
BuildRequestConfiguration config = new BuildRequestConfiguration(1, new BuildRequestData("foo", new Dictionary<string, string>(), "foo", new string[0], null), "2.0");
BuildRequestEntry entry = new BuildRequestEntry(request, config);
Assert.AreEqual(entry.State, BuildRequestEntryState.Ready);
entry.Continue();
Assert.AreEqual(entry.State, BuildRequestEntryState.Active);
BuildRequest waitingRequest1 = CreateNewBuildRequest(2, new string[1] { "bar" });
entry.WaitForResult(waitingRequest1);
Assert.AreEqual(entry.State, BuildRequestEntryState.Waiting);
BuildRequest randomRequest = CreateNewBuildRequest(3, new string[0]);
BuildResult requiredResult = new BuildResult(randomRequest);
requiredResult.AddResultsForTarget("bar", TestUtilities.GetEmptySucceedingTargetResult());
entry.ReportResult(requiredResult);
Assert.AreEqual(entry.State, BuildRequestEntryState.Waiting);
}
public void TestRequestWithReferenceCancelled()
{
BuildRequestConfiguration configuration = CreateTestProject(1);
try
{
TestTargetBuilder targetBuilder = (TestTargetBuilder)_host.GetComponent(BuildComponentType.TargetBuilder);
IConfigCache configCache = (IConfigCache)_host.GetComponent(BuildComponentType.ConfigCache);
FullyQualifiedBuildRequest[] newRequest = new FullyQualifiedBuildRequest[1] { new FullyQualifiedBuildRequest(configuration, new string[1] { "testTarget2" }, true) };
targetBuilder.SetNewBuildRequests(newRequest);
configCache.AddConfiguration(configuration);
BuildRequest request = CreateNewBuildRequest(1, new string[1] { "target1" });
BuildRequestEntry entry = new BuildRequestEntry(request, configuration);
BuildResult result = new BuildResult(request);
result.AddResultsForTarget("target1", GetEmptySuccessfulTargetResult());
targetBuilder.SetResultsToReturn(result);
_requestBuilder.BuildRequest(GetNodeLoggingContext(), entry);
WaitForEvent(_newBuildRequestsEvent, "New Build Requests");
Assert.Equal(_newBuildRequests_Entry, entry);
ObjectModelHelpers.AssertArrayContentsMatch(_newBuildRequests_FQRequests, newRequest);
BuildResult newResult = new BuildResult(_newBuildRequests_BuildRequests[0]);
newResult.AddResultsForTarget("testTarget2", GetEmptySuccessfulTargetResult());
entry.ReportResult(newResult);
_requestBuilder.ContinueRequest();
Thread.Sleep(500);
_requestBuilder.CancelRequest();
WaitForEvent(_buildRequestCompletedEvent, "Build Request Completed");
Assert.Equal(BuildRequestEntryState.Complete, entry.State);
Assert.Equal(entry, _buildRequestCompleted_Entry);
Assert.Equal(BuildResultCode.Failure, _buildRequestCompleted_Entry.Result.OverallResult);
}
finally
{
DeleteTestProject(configuration);
}
}
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.Equal(1, _newRequest_Request.BuildRequests[0].Targets.Count);
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", TestUtilities.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 TestMergeResultsBad3()
{
BuildRequest request = CreateNewBuildRequest(1, new string[0]);
BuildResult result = new BuildResult(request);
result.AddResultsForTarget("foo", TestUtilities.GetEmptySucceedingTargetResult());
BuildRequest request2 = CreateNewBuildRequest(2, new string[0]);
BuildResult result2 = new BuildResult(request2);
result2.AddResultsForTarget("bar", TestUtilities.GetEmptySucceedingTargetResult());
result.MergeResults(result2);
}
public void TestHasResultsForTarget()
{
BuildRequest request = CreateNewBuildRequest(1, new string[0]);
BuildResult result = new BuildResult(request);
result.AddResultsForTarget("foo", TestUtilities.GetEmptySucceedingTargetResult());
Assert.IsTrue(result.HasResultsForTarget("foo"));
Assert.IsFalse(result.HasResultsForTarget("bar"));
}
public void TestAddResultsInvalid3()
{
BuildRequest request = CreateNewBuildRequest(1, new string[0]);
BuildResult result = new BuildResult(request);
result.AddResultsForTarget(null, TestUtilities.GetEmptySucceedingTargetResult());
}
public void TestMergeResults()
{
BuildRequest request = CreateNewBuildRequest(1, new string[0]);
BuildResult result = new BuildResult(request);
result.AddResultsForTarget("foo", TestUtilities.GetEmptySucceedingTargetResult());
BuildResult result2 = new BuildResult(request);
result.AddResultsForTarget("bar", TestUtilities.GetEmptyFailingTargetResult());
result.MergeResults(result2);
Assert.AreEqual(TargetResultCode.Success, result["foo"].ResultCode);
Assert.AreEqual(TargetResultCode.Failure, result["bar"].ResultCode);
BuildResult result3 = new BuildResult(request);
result.MergeResults(result3);
BuildResult result4 = new BuildResult(request);
result4.AddResultsForTarget("xor", TestUtilities.GetEmptySucceedingTargetResult());
result.MergeResults(result4);
Assert.AreEqual(TargetResultCode.Success, result["foo"].ResultCode);
Assert.AreEqual(TargetResultCode.Failure, result["bar"].ResultCode);
Assert.AreEqual(TargetResultCode.Success, result["xor"].ResultCode);
}
public void TestAddResultsInvalid2()
{
BuildRequest request = CreateNewBuildRequest(1, new string[0]);
BuildResult result = new BuildResult(request);
result.AddResultsForTarget("foo", null);
}
public void TestIndexerBad2()
{
BuildRequest request = CreateNewBuildRequest(1, new string[0]);
BuildResult result = new BuildResult(request);
result.AddResultsForTarget("foo", TestUtilities.GetEmptySucceedingTargetResult());
ITargetResult targetResult = result["bar"];
}
public void TestOverallResult()
{
BuildRequest request = CreateNewBuildRequest(1, new string[0]);
BuildResult result = new BuildResult(request);
Assert.AreEqual(BuildResultCode.Success, result.OverallResult);
result.AddResultsForTarget("foo", TestUtilities.GetEmptySucceedingTargetResult());
Assert.AreEqual(BuildResultCode.Success, result.OverallResult);
result.AddResultsForTarget("bar", new TargetResult(new TaskItem[0] { }, new WorkUnitResult(WorkUnitResultCode.Success, WorkUnitActionCode.Continue, new Exception())));
Assert.AreEqual(BuildResultCode.Success, result.OverallResult);
result.AddResultsForTarget("baz", new TargetResult(new TaskItem[0] { }, TestUtilities.GetStopWithErrorResult(new Exception())));
Assert.AreEqual(BuildResultCode.Failure, result.OverallResult);
BuildRequest request2 = CreateNewBuildRequest(2, new string[0]);
BuildResult result2 = new BuildResult(request2);
result2.AddResultsForTarget("foo", TestUtilities.GetEmptySucceedingTargetResult());
result2.AddResultsForTarget("bar", TestUtilities.GetEmptyFailingTargetResult());
Assert.AreEqual(BuildResultCode.Failure, result2.OverallResult);
}
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", TestUtilities.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 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.AreEqual(countFound, 0);
result.AddResultsForTarget("foo", TestUtilities.GetEmptySucceedingTargetResult());
bool foundFoo = false;
countFound = 0;
foreach (KeyValuePair<string, TargetResult> resultPair in result.ResultsByTarget)
{
if (resultPair.Key == "foo")
{
foundFoo = true;
}
countFound++;
}
Assert.AreEqual(countFound, 1);
Assert.IsTrue(foundFoo);
result.AddResultsForTarget("bar", TestUtilities.GetEmptySucceedingTargetResult());
foundFoo = false;
bool foundBar = false;
countFound = 0;
foreach (KeyValuePair<string, TargetResult> resultPair in result.ResultsByTarget)
{
if (resultPair.Key == "foo")
{
Assert.IsFalse(foundFoo);
foundFoo = true;
}
if (resultPair.Key == "bar")
{
Assert.IsFalse(foundBar);
foundBar = true;
}
countFound++;
}
Assert.AreEqual(countFound, 2);
Assert.IsTrue(foundFoo);
Assert.IsTrue(foundBar);
}
/// <summary>
/// Thread to process the build request
/// </summary>
private void BuilderThreadProc()
{
bool completeSuccess = true;
WaitHandle[] handles = new WaitHandle[2] { _cancelEvent, _continueEvent };
_threadStarted.Set();
// Add a request for each of the referenced projects. All we need to do is to make sure that the new project definition for the referenced
// project has been added to the host collection
FullyQualifiedBuildRequest[] fq = new FullyQualifiedBuildRequest[_currentProjectDefinition.ChildDefinitions.Count];
int fqCount = 0;
foreach (RequestDefinition childDefinition in _currentProjectDefinition.ChildDefinitions)
{
BuildRequestConfiguration unresolvedConfig = childDefinition.UnresolvedConfiguration;
fq[fqCount++] = new FullyQualifiedBuildRequest(unresolvedConfig, childDefinition.TargetsToBuild, true);
}
try
{
// Check to see if there was a cancel before we do anything
if (_cancelEvent.WaitOne(1, false))
{
HandleCancel();
return;
}
// Submit the build request for the references if we have any
if (fqCount > 0)
{
OnNewBuildRequests(_requestedEntry, fq);
// Wait for all of them to complete till our entry is marked ready
int evt = WaitHandle.WaitAny(handles);
// If a cancel occurs then we are done. Set the result to an exception
if (evt == 0)
{
HandleCancel();
return;
}
// If we get a continue then one of the reference has complete. Set the result in the cache only in case of success.
// Even though there may have been error - we cannot abandone the loop as there are already
// requests in progress which may call back to this thread
else if (evt == 1)
{
IDictionary<int, BuildResult> results = _requestedEntry.Continue();
foreach (BuildResult configResult in results.Values)
{
if (configResult.OverallResult == BuildResultCode.Failure)
{
completeSuccess = false;
}
else
{
_resultsCache.AddResult(configResult);
}
}
}
}
// Check to see if there was a cancel we process the final result
if (_cancelEvent.WaitOne(1, false))
{
HandleCancel();
return;
}
// Simulate execution time for the actual entry if one was specified and if the entry built successfully
if (_currentProjectDefinition.ExecutionTime > 0 && completeSuccess == true)
{
Thread.Sleep(_currentProjectDefinition.ExecutionTime);
}
// Create and send the result
BuildResult result = new BuildResult(_requestedEntry.Request);
// No specific target was asked to build. Return the default result
if (_requestedEntry.Request.Targets.Count == 0)
{
result.AddResultsForTarget(RequestDefinition.defaultTargetName, new TargetResult(new TaskItem[1], completeSuccess ? TestUtilities.GetSuccessResult() : TestUtilities.GetStopWithErrorResult()));
}
else
{
foreach (string target in _requestedEntry.Request.Targets)
{
result.AddResultsForTarget(target, new TargetResult(new TaskItem[1], completeSuccess ? TestUtilities.GetSuccessResult() : TestUtilities.GetStopWithErrorResult()));
}
}
_resultsCache.AddResult(result);
_requestedEntry.Complete(result);
RaiseRequestComplete(_requestedEntry);
return;
}
catch (Exception e)
{
if (_requestedEntry != null)
{
string message = String.Format("Test: Unhandeled exception occured: \nMessage: {0} \nStack:\n{1}", e.Message, e.StackTrace);
BuildResult errorResult = new BuildResult(_requestedEntry.Request, new InvalidOperationException(message));
_requestedEntry.Complete(errorResult);
RaiseRequestComplete(_requestedEntry);
}
}
}
public void TestTranslation()
{
BuildRequest request = new BuildRequest(1, 1, 2, new string[] { "alpha", "omega" }, null, new BuildEventContext(1, 1, 2, 3, 4, 5), null);
BuildResult result = new BuildResult(request, new BuildAbortedException());
TaskItem fooTaskItem = new TaskItem("foo", "asdf.proj");
fooTaskItem.SetMetadata("meta1", "metavalue1");
fooTaskItem.SetMetadata("meta2", "metavalue2");
result.InitialTargets = new List<string> { "a", "b" };
result.DefaultTargets = new List<string> { "c", "d" };
result.AddResultsForTarget("alpha", new TargetResult(new TaskItem[] { fooTaskItem }, TestUtilities.GetSuccessResult()));
result.AddResultsForTarget("omega", new TargetResult(new TaskItem[] { }, TestUtilities.GetStopWithErrorResult(new ArgumentException("The argument was invalid"))));
Assert.AreEqual(NodePacketType.BuildResult, (result as INodePacket).Type);
((INodePacketTranslatable)result).Translate(TranslationHelpers.GetWriteTranslator());
INodePacket packet = BuildResult.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
BuildResult deserializedResult = packet as BuildResult;
Assert.AreEqual(result.ConfigurationId, deserializedResult.ConfigurationId);
Assert.IsTrue(TranslationHelpers.CompareCollections(result.DefaultTargets, deserializedResult.DefaultTargets, StringComparer.Ordinal));
Assert.IsTrue(TranslationHelpers.CompareExceptions(result.Exception, deserializedResult.Exception));
Assert.AreEqual(result.Exception.Message, deserializedResult.Exception.Message);
Assert.AreEqual(result.GlobalRequestId, deserializedResult.GlobalRequestId);
Assert.IsTrue(TranslationHelpers.CompareCollections(result.InitialTargets, deserializedResult.InitialTargets, StringComparer.Ordinal));
Assert.AreEqual(result.NodeRequestId, deserializedResult.NodeRequestId);
Assert.AreEqual(result["alpha"].ResultCode, deserializedResult["alpha"].ResultCode);
Assert.IsTrue(TranslationHelpers.CompareExceptions(result["alpha"].Exception, deserializedResult["alpha"].Exception));
Assert.IsTrue(TranslationHelpers.CompareCollections(result["alpha"].Items, deserializedResult["alpha"].Items, TaskItemComparer.Instance));
Assert.AreEqual(result["omega"].ResultCode, deserializedResult["omega"].ResultCode);
Assert.IsTrue(TranslationHelpers.CompareExceptions(result["omega"].Exception, deserializedResult["omega"].Exception));
Assert.IsTrue(TranslationHelpers.CompareCollections(result["omega"].Items, deserializedResult["omega"].Items, TaskItemComparer.Instance));
}
public Task<BuildResult> BuildTargets(ProjectLoggingContext loggingContext, BuildRequestEntry entry, IRequestBuilderCallback callback, string[] targets, Lookup baseLookup, CancellationToken cancellationToken)
{
_requestBuilderCallback = callback;
if (cancellationToken.WaitHandle.WaitOne(1500, false))
{
BuildResult result = new BuildResult(entry.Request);
foreach (string target in targets)
{
result.AddResultsForTarget(target, TestUtilities.GetEmptyFailingTargetResult());
}
return Task<BuildResult>.FromResult(result);
}
if (null != _newRequests)
{
string[] projectFiles = new string[_newRequests.Length];
PropertyDictionary<ProjectPropertyInstance>[] properties = new PropertyDictionary<ProjectPropertyInstance>[_newRequests.Length];
string[] toolsVersions = new string[_newRequests.Length];
for (int i = 0; i < projectFiles.Length; ++i)
{
projectFiles[i] = _newRequests[i].Config.ProjectFullPath;
properties[i] = new PropertyDictionary<ProjectPropertyInstance>(_newRequests[i].Config.Properties);
toolsVersions[i] = _newRequests[i].Config.ToolsVersion;
}
_requestBuilderCallback.BuildProjects(projectFiles, properties, toolsVersions, _newRequests[0].Targets, _newRequests[0].ResultsNeeded);
if (cancellationToken.WaitHandle.WaitOne(1500, false))
{
BuildResult result = new BuildResult(entry.Request);
foreach (string target in targets)
{
result.AddResultsForTarget(target, TestUtilities.GetEmptyFailingTargetResult());
}
return Task<BuildResult>.FromResult(result);
}
}
return Task<BuildResult>.FromResult(_cache.GetResultForRequest(entry.Request));
}
private void BuilderThreadProc()
{
_entry.RequestConfiguration.Project = CreateStandinProject();
if (ThrowExceptionOnRequest)
{
BuildResult errorResult = new BuildResult(_entry.Request, new InvalidOperationException("ContinueRequest not received in time."));
_entry.Complete(errorResult);
RaiseRequestComplete(_entry);
return;
}
bool completeSuccess = CompleteRequestSuccessfully;
if (_cancelEvent.WaitOne(1000, false))
{
BuildResult res = new BuildResult(_entry.Request, new BuildAbortedException());
_entry.Complete(res);
RaiseRequestComplete(_entry);
return;
}
for (int i = 0; i < NewRequests.Count; ++i)
{
OnNewBuildRequests(_entry, NewRequests[i]);
WaitHandle[] handles = new WaitHandle[2] { _cancelEvent, _continueEvent };
int evt = WaitHandle.WaitAny(handles, 5000, false);
if (evt == 0)
{
BuildResult res = new BuildResult(_entry.Request, new BuildAbortedException());
_entry.Complete(res);
RaiseRequestComplete(_entry);
return;
}
else if (evt == 1)
{
IDictionary<int, BuildResult> results = _entry.Continue();
foreach (BuildResult configResult in results.Values)
{
if (configResult.OverallResult == BuildResultCode.Failure)
{
completeSuccess = false;
break;
}
}
}
else
{
BuildResult errorResult = new BuildResult(_entry.Request, new InvalidOperationException("ContinueRequest not received in time."));
_entry.Complete(errorResult);
RaiseRequestComplete(_entry);
return;
}
if (!completeSuccess)
{
break;
}
Delay();
}
BuildResult result = new BuildResult(_entry.Request);
foreach (string target in _entry.Request.Targets)
{
result.AddResultsForTarget(target, new TargetResult(new TaskItem[1] { new TaskItem("include", _entry.RequestConfiguration.ProjectFullPath) }, completeSuccess ? TestUtilities.GetSuccessResult() : TestUtilities.GetStopWithErrorResult()));
}
_entry.Complete(result);
}
/// <summary>
/// Creates a build result for a request
/// </summary>
private BuildResult CreateBuildResult(BuildRequest request, string target, WorkUnitResult workUnitResult)
{
BuildResult result = new BuildResult(request);
result.AddResultsForTarget(target, new TargetResult(new TaskItem[] { }, workUnitResult));
return result;
}
public void TestRetrieveSubsetTargetsFromResult()
{
ResultsCache cache = new ResultsCache();
BuildRequest request = new BuildRequest(1 /* submissionId */, 0, 1, new string[1] { "testTarget2" }, null, BuildEventContext.Invalid, null);
BuildResult result = new BuildResult(request);
result.AddResultsForTarget("testTarget", TestUtilities.GetEmptyFailingTargetResult());
result.AddResultsForTarget("testTarget2", TestUtilities.GetEmptySucceedingTargetResult());
cache.AddResult(result);
ResultsCacheResponse response = cache.SatisfyRequest(request, new List<string>(), new List<string>(new string[] { "testTarget2" }), new List<string>(new string[] { "testTarget" }), skippedResultsAreOK: false);
Assert.Equal(ResultsCacheResponseType.Satisfied, response.Type);
Assert.True(AreResultsIdenticalForTarget(result, response.Results, "testTarget2"));
Assert.False(response.Results.HasResultsForTarget("testTarget"));
Assert.Equal(BuildResultCode.Failure, response.Results.OverallResult);
}
public void TestNoReadyToComplete()
{
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.AreEqual(entry.State, BuildRequestEntryState.Ready);
BuildResult requiredResult = new BuildResult(request);
requiredResult.AddResultsForTarget("foo", TestUtilities.GetEmptySucceedingTargetResult());
entry.Complete(requiredResult);
}
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", TestUtilities.GetEmptyFailingTargetResult());
cache.AddResult(result);
cache.ClearResults();
Assert.Null(cache.GetResultForRequest(request));
}
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", TestUtilities.GetEmptyFailingTargetResult());
cache.AddResult(result);
BuildResult retrievedResult = cache.GetResultForRequest(request);
}
);
}
public void TestMultipleWaitingRequests()
{
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(entry.State, BuildRequestEntryState.Active);
BuildRequest waitingRequest1 = CreateNewBuildRequest(2, new string[1] { "bar" });
entry.WaitForResult(waitingRequest1);
Assert.Equal(entry.State, BuildRequestEntryState.Waiting);
BuildRequest waitingRequest2 = CreateNewBuildRequest(2, new string[1] { "xor" });
entry.WaitForResult(waitingRequest2);
Assert.Equal(entry.State, BuildRequestEntryState.Waiting);
BuildResult requiredResult1 = new BuildResult(waitingRequest1);
requiredResult1.AddResultsForTarget("bar", TestUtilities.GetEmptySucceedingTargetResult());
entry.ReportResult(requiredResult1);
Assert.Equal(entry.State, BuildRequestEntryState.Waiting);
BuildResult requiredResult2 = new BuildResult(waitingRequest2);
requiredResult2.AddResultsForTarget("xor", TestUtilities.GetEmptySucceedingTargetResult());
entry.ReportResult(requiredResult2);
Assert.Equal(entry.State, BuildRequestEntryState.Ready);
}