コード例 #1
0
        /// <summary>
        /// Executes each of the requests and waits for all of them to be completed.
        /// </summary>
        /// <param name="buildRequests">Array of BuildRequestData to be built.</param>
        /// <param name="timeout">Number of mili seconds to wait for the pending build requests.</param>
        /// <param name="waitForCompletion">Should wait for the builds to complete.</param>
        /// <param name="asyncBuildRequestsStatus">Array of AsyncBuildRequestStatus which contain information about each request executed asynchronously.</param>
        /// <returns>True if the builds completed successfully.</returns>
        public bool ExecuteAsyncBuildRequests(BuildRequestData[] buildRequests, int timeout, bool waitForCompletion, out AsyncBuildRequestStatus[] asyncBuildRequestsStatus)
        {
            BuildSubmissionTestExtension[] submissionTestExtensions = new BuildSubmissionTestExtension[buildRequests.Length];
            AutoResetEvent[] buildCompletedEvents = new AutoResetEvent[buildRequests.Length];
            asyncBuildRequestsStatus = new AsyncBuildRequestStatus[buildRequests.Length];
            try
            {
                for (int i = 0; i < buildRequests.Length; i++)
                {
                    buildCompletedEvents[i]     = new AutoResetEvent(false);
                    submissionTestExtensions[i] = this.PendBuildRequest(buildRequests[i]);
                    asyncBuildRequestsStatus[i] = new AsyncBuildRequestStatus(buildCompletedEvents[i], submissionTestExtensions[i]);
                    submissionTestExtensions[i].ExecuteAsync(asyncBuildRequestsStatus[i].SubmissionCompletedCallback, null);
                }

                if (waitForCompletion)
                {
                    if (!BuildManagerTestExtension.WaitAll(buildCompletedEvents, timeout))
                    {
                        return(false);
                    }

                    return(true);
                }
                else
                {
                    return(true);
                }
            }
            finally
            {
                if (waitForCompletion)
                {
                    for (int i = 0; i < buildRequests.Length; i++)
                    {
                        buildCompletedEvents[i].Close();
                        buildCompletedEvents[i] = null;
                    }
                }
            }
        }
コード例 #2
0
        /// <summary>
        /// Method to mimic WaitAll in STA. WaitAll for multiple handles on an STA thread is not supported.
        /// </summary>
        /// <param name="waitHandles">Handles to wait for.</param>
        /// <param name="timeout">Number of miliseconds to wait for before timing out.</param>
        /// <returns>True if the wait succeedes.</returns>
        public static bool WaitAll(WaitHandle[] waitHandles, int timeout)
        {
            bool waitStatus = true;

            if (Thread.CurrentThread.GetApartmentState() == ApartmentState.STA)
            {
                foreach (WaitHandle myWaitHandle in waitHandles)
                {
                    if (!BuildManagerTestExtension.Wait(myWaitHandle, timeout))
                    {
                        return(false);
                    }
                }
            }
            else
            {
                waitStatus = WaitHandle.WaitAll(waitHandles);
            }

            return(waitStatus);
        }
コード例 #3
0
        /// <summary>
        /// Responsible for creating the build manager.
        /// For MSBuild backend testing BuildManager is the Entry point for all tests. That is - the environment
        /// for testing starts with the BuildManager. Configuration can specify which components should be mocked
        /// and which test extension should be attached to which component.
        /// </summary>
        /// <returns>TextExtensions created.</returns>
        protected override TestExtensionContainer Generate()
        {
            List <TestExtension> testExtensions = new List <TestExtension>();

            // To workaround the problem where extensions derived out from Testextension does not have a LifeTimeManagmentService.
            LifeTimeManagmentServiceTestExtension lifetimeServiceExtension = new LifeTimeManagmentServiceTestExtension(LifetimeService);

            LifetimeService.Compose(lifetimeServiceExtension);
            testExtensions.Add(lifetimeServiceExtension);

            // Create the build manager and the associated test extension first.
            BuildManagerTestExtension buildManagerTestExtension = new BuildManagerTestExtension(BuildManager.DefaultBuildManager);

            LifetimeService.Compose(buildManagerTestExtension);
            testExtensions.Add(buildManagerTestExtension);

            // When the BuildManager is created it registers a default set of components.
            // Loop through each of the components that we want to mock and then replace the component in the BuildManager.
            foreach (KeyValuePair <ComponentType, string> componentTypePair in this.Configuration.ComponentsToMock)
            {
                buildManagerTestExtension.ReplaceRegisterdFactory(GetBuildComponentTypeFromComponentType(componentTypePair.Key.ToString()), this.CreateMockComponent);
            }

            // Loop through each of the components that we want to wrap with a test extension - create the test extension and aggregate the internal component.
            // This component could be a mock that we create above or the real implementation.
            foreach (KeyValuePair <ComponentType, string> componentTypePair in this.Configuration.TestExtensionForComponents)
            {
                TestExtension extension = CreateTestExtensionForComponent(componentTypePair.Key.ToString(), componentTypePair.Value, buildManagerTestExtension);
                LifetimeService.Compose(extension);
                testExtensions.Add(extension);
            }

            TestExtensionContainer testContainer = new TestExtensionContainer(testExtensions);

            return(testContainer);
        }
コード例 #4
0
        /// <summary>
        /// Create a TestExtension for a given component type.
        /// </summary>
        /// <param name="componentName">Name of the component for which the TestExtension is to be created.</param>
        /// <param name="testExtensionName">Fully qualified TestExtension name.</param>
        /// <param name="buildManagerTestExtension">BuildManager Test extension entry.</param>
        /// <returns>New TestExtension.</returns>
        private static TestExtension CreateTestExtensionForComponent(string componentName, string testExtensionName, BuildManagerTestExtension buildManagerTestExtension)
        {
            BuildComponentType type      = StringToEnum <BuildComponentType>(componentName);
            IBuildComponent    component = buildManagerTestExtension.GetComponent(type);
            Type testExtensionType       = Assembly.GetAssembly(typeof(BuildManagerContainerGenerator)).GetType(testExtensionName, true, true);

            object[] parameters = { component };
            return((TestExtension)testExtensionType.InvokeMember(null, BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.CreateInstance, null, null, parameters, CultureInfo.InvariantCulture));
        }