public void TestMissingResults() { ResultsCache cache = new ResultsCache(); BuildRequest request = new BuildRequest(1 /* submissionId */, 0, 1, new string[1] { "testTarget" }, null, BuildEventContext.Invalid, null); BuildResult retrievedResult = cache.GetResultForRequest(request); Assert.Null(retrievedResult); }
/// <summary> /// Setup the object /// </summary> public Integration_Tests() { this.commonTests = new Common_Tests(this.GetComponent, true); this.resultsCache = null; this.tempPath = System.IO.Path.GetTempPath(); this.assemblyPath = Path.GetDirectoryName( new Uri(System.Reflection.Assembly.GetExecutingAssembly().EscapedCodeBase).LocalPath); this.assemblyPath = Path.Combine(this.assemblyPath, "Microsoft.Build.Unittest.dll"); }
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 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 Setup() { _resultsCache = new ResultsCache(); _commonTests.Setup(); }
/// <summary> /// Setup the object /// </summary> public TargetBuilder_Tests() { _commonTests = new Common_Tests(this.GetComponent, true); _tempPath = System.IO.Path.GetTempPath(); _resultsCache = null; }
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 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 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 TearDown() { this.commonTests.TearDown(); this.resultsCache = null; }
public void Setup() { this.resultsCache = new ResultsCache(); this.commonTests.Setup(); }
/// <summary> /// Setup the object /// </summary> public TaskBuilder_Tests() { this.commonTests = new Common_Tests(this.GetComponent, true); this.resultsCache = null; }
public void TearDown() { _commonTests.TearDown(); _resultsCache = null; }
public void TestConstructor() { ResultsCache cache = new ResultsCache(); }
/// <summary> /// Builds the specified targets. /// </summary> /// <param name="loggingContext">The logging context for the project.</param> /// <param name="entry">The BuildRequestEntry for which we are building targets.</param> /// <param name="callback">The callback to be used to handle new project build requests.</param> /// <param name="targetNames">The names of the targets to build.</param> /// <param name="baseLookup">The Lookup containing all current items and properties for this target.</param> /// <param name="cancellationToken">The <see cref="CancellationToken"/> to use when building the targets.</param> /// <returns>The target's outputs and result codes</returns> public async Task <BuildResult> BuildTargets(ProjectLoggingContext loggingContext, BuildRequestEntry entry, IRequestBuilderCallback callback, string[] targetNames, Lookup baseLookup, CancellationToken cancellationToken) { ErrorUtilities.VerifyThrowArgumentNull(loggingContext, "projectLoggingContext"); ErrorUtilities.VerifyThrowArgumentNull(entry, "entry"); ErrorUtilities.VerifyThrowArgumentNull(callback, "requestBuilderCallback"); ErrorUtilities.VerifyThrowArgumentNull(targetNames, "targetNames"); ErrorUtilities.VerifyThrowArgumentNull(baseLookup, "baseLookup"); ErrorUtilities.VerifyThrow(targetNames.Length > 0, "List of targets must be non-empty"); ErrorUtilities.VerifyThrow(_componentHost != null, "InitializeComponent must be called before building targets."); _requestEntry = entry; _requestBuilderCallback = callback; _projectLoggingContext = loggingContext; _cancellationToken = cancellationToken; // Clone the base lookup so that if we are re-entered by another request while this one in blocked, we don't have visibility to // their state, and they have no visibility into ours. _baseLookup = baseLookup.Clone(); _targetsToBuild = new ConcurrentStack <TargetEntry>(); // Get the actual target objects from the names BuildRequestConfiguration configuration = _requestEntry.RequestConfiguration; bool previousCacheableStatus = configuration.IsCacheable; configuration.IsCacheable = false; configuration.RetrieveFromCache(); _projectInstance = configuration.Project; // Now get the current results cache entry. ResultsCache resultsCache = (ResultsCache)_componentHost.GetComponent(BuildComponentType.ResultsCache); BuildResult existingBuildResult = null; resultsCache.ResultsDictionary.TryGetValue(_requestEntry.Request.ConfigurationId, out existingBuildResult); _buildResult = new BuildResult(entry.Request, existingBuildResult, null); if (existingBuildResult == null) { // Add this result so that if our project gets re-entered we won't rebuild any targets we have already built. resultsCache.AddResult(_buildResult); } List <TargetSpecification> targets = new List <TargetSpecification>(targetNames.Length); foreach (string targetName in targetNames) { var targetExists = _projectInstance.Targets.ContainsKey(targetName); if (!targetExists && entry.Request.BuildRequestDataFlags.HasFlag(BuildRequestDataFlags.SkipNonexistentTargets)) { _projectLoggingContext.LogComment(Framework.MessageImportance.Low, "TargetSkippedWhenSkipNonexistentTargets", targetName); continue; } targets.Add(new TargetSpecification(targetName, targetExists ? _projectInstance.Targets[targetName].Location : _projectInstance.ProjectFileLocation)); } // Push targets onto the stack. This method will reverse their push order so that they // get built in the same order specified in the array. await PushTargets(targets, null, baseLookup, false, false, TargetBuiltReason.None); // Now process the targets ITaskBuilder taskBuilder = _componentHost.GetComponent(BuildComponentType.TaskBuilder) as ITaskBuilder; try { await ProcessTargetStack(taskBuilder); } finally { // If there are still targets left on the stack, they need to be removed from the 'active targets' list foreach (TargetEntry target in _targetsToBuild) { configuration.ActivelyBuildingTargets.Remove(target.Name); } ((IBuildComponent)taskBuilder).ShutdownComponent(); } if (_cancellationToken.IsCancellationRequested) { throw new BuildAbortedException(); } // Gather up outputs for the requested targets and return those. All of our information should be in the base lookup now. BuildResult resultsToReport = new BuildResult(_buildResult, targetNames); // Return after-build project state if requested. if (_requestEntry.Request.BuildRequestDataFlags.HasFlag(BuildRequestDataFlags.ProvideProjectStateAfterBuild)) { resultsToReport.ProjectStateAfterBuild = _projectInstance; } configuration.IsCacheable = previousCacheableStatus; return(resultsToReport); }
/// <summary> /// Setup the object /// </summary> public RequestBuilder_Tests() { this.commonTests = new Common_Tests(this.GetComponent, true); this.resultsCache = null; this.tempPath = System.IO.Path.GetTempPath(); }