public static void SubmitResult(Uri testVaultServer, string session, string project, string buildname, string testgroup, string testname, TestOutcome outcome, bool personal)
        {
            try
            {
                using ( var client = new WebClient() ){

                    client.BaseAddress = testVaultServer.ToString();
                    client.CachePolicy = new System.Net.Cache.RequestCachePolicy( System.Net.Cache.RequestCacheLevel.NoCacheNoStore );
                    client.Headers.Add("Content-Type", "text/xml");

                    var result = new TestResult()
                    {
                        Group = new TestGroup() { Name = testgroup, Project = new TestProject() { Project = project } },
                        Name = testname,
                        Outcome = outcome,
                        TestSession = session,
                        IsPersonal = personal,
                        BuildID = buildname,
                    };

                    var xc = new XmlSerializer(result.GetType());
                    var io = new System.IO.MemoryStream();
                    xc.Serialize( io, result );

                    client.UploadData( testVaultServer.ToString(), io.ToArray() );

                }
            } catch ( Exception e )
            {
                Console.Error.WriteLine( e );
            }
        }

 /// <summary>
 /// Creates a result record.
 /// </summary>
 /// <param name="method">Test method metadata object.</param>
 /// <param name="testClass">Test class metadata object.</param>
 /// <param name="result">Test result object.</param>
 /// <param name="exception">Exception instance, if any.</param>
 public ScenarioResult(ITestMethod method, ITestClass testClass, TestOutcome result, Exception exception)
 {
     TestClass = testClass;
     TestMethod = method;
     Exception = exception;
     Result = result;
 }

 private TestStepRun CreateFakeRun(string id, TestOutcome outcome, params TestStepRun[] children)
 {
     var run = new TestStepRun(new TestStepData(id, id, id, id));
     run.Result = new TestResult(outcome);
     run.Children.AddRange(children);
     return run;
 }

 public TestResult ToTestResult(string qualifiedTestCaseName, TestOutcome outcome, int duration, string executable = DummyExecutable)
 {
     return new TestResult(ToTestCase(qualifiedTestCaseName, executable))
     {
         Outcome = outcome,
         Duration = TimeSpan.FromMilliseconds(duration)
     };
 }

 public int TestOutcomeTotalsAreCorrect(TestOutcome outcome)
 {
     return testLog.Events
         .FindAll(e => e.EventType == FakeFrameworkHandle.EventType.RecordResult)
         .ConvertAll(e => e.TestResult)
         .FindAll(r => r.Outcome == outcome)
         .Count;
 }

 public static TestInfo FromRelativePaths(string className, string methodName, string projectFilePath, string sourceCodeFilePath, int sourceCodeLineNumber, TestOutcome outcome, string classFilePath = null) {
     return FromAbsolutePaths(className,
         methodName,
         TestData.GetPath(projectFilePath),
         TestData.GetPath(sourceCodeFilePath),
         sourceCodeLineNumber,
         outcome,
         classFilePath != null ? TestData.GetPath(classFilePath) : null);
 }

 void ITestExecutionRecorder.RecordEnd(TestCase testCase, TestOutcome outcome)
 {
     Events.Add(new Event()
     {
         EventType = EventType.RecordEnd,
         TestCase = testCase,
         TestOutcome = outcome
     });
 }

 public static TestInfo FromAbsolutePaths(string className, string methodName, string projectFilePath, string sourceCodeFilePath, int sourceCodeLineNumber, TestOutcome outcome, string classFilePath = null) {
     TestInfo ti = new TestInfo();
     ti.ClassName = className;
     ti.MethodName = methodName;
     ti.ProjectFilePath = projectFilePath;
     ti.SourceCodeFilePath = sourceCodeFilePath;
     ti.SourceCodeLineNumber = sourceCodeLineNumber;
     ti.Outcome = outcome;
     ti.ClassFilePath = classFilePath ?? sourceCodeFilePath;
     ti.RelativeClassFilePath = CommonUtils.GetRelativeFilePath(Path.GetDirectoryName(ti.ProjectFilePath), ti.ClassFilePath);
     return ti;
 }

    public GallioRunListener(ISpecificationRunListener listener, IProgressMonitor progressMonitor,
      ITestContext context, IEnumerable<ITestCommand> specificationCommands)
    {
      _listener = listener;
      _progressMonitor = progressMonitor;
      _testContext = context;

      _outcome = TestOutcome.Passed;

      _contextsBySpec = new Dictionary<string, ITestContext>();
      _commandsBySpec = (from command in specificationCommands
                         let specificationTest = command.Test as MachineSpecificationTest
                         where specificationTest != null
                         select new { Name = specificationTest.Specification.Name, Command = command })
                         .ToDictionary(x => x.Name, x => x.Command);
    }

        public static async Task FinishTestAsync(string testName, TestOutcome outcome, string message = null, string filename = null, string stdOut = null, bool printFailuresOnly = false)
        {
            var endTime = DateTimeOffset.Now.Ticks;

            TimeSpan duration;
            long startTime;
            if (TestStartTimes.TryGetValue(testName, out startTime))
            {
                duration = new TimeSpan(endTime - startTime);
                TestStartTimes.Remove(testName);
            }
            else
            {
                duration = TimeSpan.Zero;
            }

            if (null == filename)
            {
                TestStartFilename.TryGetValue(testName, out filename);
                TestStartFilename.Remove(testName);
            }

            if (!printFailuresOnly || outcome != TestOutcome.Passed)
            {
                FancyConsole.Write("Test {0} complete.", testName);
                switch (outcome)
                {
                    case TestOutcome.Failed:
                        FancyConsole.Write(ConsoleColor.Red, " Failed: {0}", message);
                        break;
                    case TestOutcome.Passed:
                        FancyConsole.Write(ConsoleColor.Green, " Passed: {0}", message);
                        break;
                    default:
                        FancyConsole.Write(" {0}: {1}", outcome, message);
                        break;
                }
                FancyConsole.WriteLine(" duration: {0}", duration);
            }

            await BuildWorkerApi.RecordTestAsync(testName, TestFrameworkName, outcome: outcome, durationInMilliseconds: (long)duration.TotalMilliseconds, errorMessage: message, filename: filename, stdOut: stdOut);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="MSTestAllureAdapter.MSTestResult"/> class.
        /// </summary>
        /// <param name="name">Name.</param>
        /// <param name="outcome">Outcome.</param>
        /// <param name="start">Start time.</param>
        /// <param name="end">End time.</param>
        /// <param name="suits">List of test suits this test belongs to.</param>
        /// <param name="innerResults">List of inner test results this test might have.</param>
        public MSTestResult(string name, TestOutcome outcome, DateTime start, DateTime end, IEnumerable<string> suits, IEnumerable<MSTestResult> innerResults) 
		{ 
            Name = name;

            mSuits = suits ?? Enumerable.Empty<string>();

            Outcome = outcome;
            Start = start;
            End = end;

            List<MSTestResult> results = new List<MSTestResult>();
            if (innerResults != null)
            {
                foreach (MSTestResult result in innerResults)
                {
                    results.Add(result.Clone());
                }
            }

            InnerTests = results;
		}

 /// <summary>
 /// Terminates the test and reports a specific test outcome.
 /// </summary>
 /// <remarks>
 /// <para>
 /// The test is terminated with by throwing a <see cref="TestTerminatedException" />
 /// with the specified outcome.  If other code in the test case catches
 /// this exception and does not rethrow it then the test might not terminate correctly.
 /// </para>
 /// </remarks>
 /// <param name="outcome">The desired test outcome.</param>
 /// <param name="messageFormat">The custom message format string, or null if none.</param>
 /// <param name="messageArgs">The custom message arguments, or null if none.</param>
 /// <exception cref="TestTerminatedException">Thrown always.</exception>
 public static void Terminate(TestOutcome outcome, string messageFormat, params object[] messageArgs)
 {
     throw new TestTerminatedException(outcome, messageFormat != null && messageArgs != null
         ? String.Format(messageFormat, messageArgs)
         : messageFormat ?? "The test was terminated.");
 }

 /// <summary>
 /// Record a test outcome.
 /// </summary>
 /// <param name="message">The accompanying message.</param>
 /// <param name="outcome">The outcome value.</param>
 public void TestResult(string message, TestOutcome outcome)
 {
   LogMessage m = Create(LogMessageType.TestResult, message);
   DecorateTestOutcome(m, outcome);
 }

 /// <summary>
 /// Decorate the log message object with a test outcome object.
 /// </summary>
 /// <param name="message">The log message object.</param>
 /// <param name="outcome">Test outcome object.</param>
 protected static void DecorateTestOutcome(LogMessage message, TestOutcome outcome)
 {
   Decorate(message, LogDecorator.TestOutcome, outcome);
 }

 public void RecordEnd(TestCase testCase, TestOutcome outcome) {
 }

 /// <summary>
 /// Finishes the step represented by the context.
 /// </summary>
 /// <param name="outcome">The outcome.</param>
 /// <returns>The final test result.</returns>
 internal TestResult FinishStep(TestOutcome outcome)
 {
     return inner.FinishStep(outcome, null);
 }

 /// <summary>
 /// Creates an exception.
 /// </summary>
 /// <param name="outcome">The test outcome.</param>
 /// <param name="message">The message, or null if none.</param>
 /// <param name="innerException">The inner exception, or null if none.</param>
 public TestTerminatedException(TestOutcome outcome, string message, Exception innerException)
     : base(message, innerException)
 {
     this.outcome = outcome;
 }

 public static MSVST4U_UnitTestResult New_MSVST4U_UnitTestResult_DataDriven(Guid runId, ITestElement test, TestOutcome outcome, TestResultCounter counters, MSVSTTC_TestResult[] innerResults)
 {
     return MSVST4U_Tunnels.CreateAggregateDataTestResult(runId, test, outcome, counters, innerResults);
 }

 /// <summary>
 /// Terminates the test silently and reports a specific test outcome.
 /// </summary>
 /// <remarks>
 /// <para>
 /// Unlike <see cref="Terminate(TestOutcome)" /> this method does not report the
 /// stack trace.  It also does not include a termination reason unless one is explicitly
 /// specified by the caller.
 /// </para>
 /// <para>
 /// The test is terminated with by throwing a <see cref="SilentTestException" />
 /// with the specified outcome.  If other code in the test case catches
 /// this exception and does not rethrow it then the test might not terminate correctly.
 /// </para>
 /// </remarks>
 /// <param name="outcome">The desired test outcome.</param>
 /// <exception cref="SilentTestException">Thrown always.</exception>
 public static void TerminateSilently(TestOutcome outcome)
 {
     TerminateSilently(outcome, null, null);
 }

            /// <summary>
            /// Adds the result of a test method into the log.
            /// </summary>
            /// <param name="test">The test metadata.</param>
            /// <param name="storage">The storage value.</param>
            /// <param name="codeBase">The code base value.</param>
            /// <param name="adapterTypeName">The adapter type name.</param>
            /// <param name="className">The class name.</param>
            /// <param name="testListName">The test list name.</param>
            /// <param name="computerName">The computer name.</param>
            /// <param name="startTime">The start time.</param>
            /// <param name="endTime">The end time.</param>
            /// <param name="outcome">The outcome.</param>
            public void AddTestMethodResult(
                ITestMethod test,
                string storage,
                string codeBase,
                string adapterTypeName,
                string className,
                string testListName,
                string computerName,
                DateTime startTime,
                DateTime endTime,
                TestOutcome outcome)
            {
                if (test == null)
                {
                    throw new ArgumentNullException("test");
                }

                // Friendly name of the test
                string name = test.Name;

                // Generate GUIDs.
                string testId = Guid.NewGuid().ToString();
                string executionId = Guid.NewGuid().ToString();
                string testListId = GetTestListGuid(testListName);

                // UnitTest element.
                SimpleXElement unitTest = CreateElement("UnitTest");
                unitTest.SetAttributeValue("name", name);
                unitTest.SetAttributeValue("storage", storage);
                unitTest.SetAttributeValue("id", testId);

                SimpleXElement owners = CreateElement("Owners");
                SimpleXElement owner = CreateElement("Owner");
                string ownerString = test.Owner ?? string.Empty;
                owner.SetAttributeValue("name", ownerString);
                owners.Add(owner);
                unitTest.Add(owners);

                if (!string.IsNullOrEmpty(test.Description))
                {
                    SimpleXElement description = CreateElement("Description");
                    description.SetValue(test.Description);
                    unitTest.Add(description);
                }

                SimpleXElement execution = CreateElement("Execution");
                execution.SetAttributeValue("id", executionId);
                unitTest.Add(execution);

                // TestMethod element.
                SimpleXElement testMethod = CreateElement("TestMethod");
                testMethod.SetAttributeValue("codeBase", codeBase);
                testMethod.SetAttributeValue("adapterTypeName", adapterTypeName);
                testMethod.SetAttributeValue("className", className);
                testMethod.SetAttributeValue("name", name);
                unitTest.Add(testMethod);

                TestDefinitions.Add(unitTest);

                // TestEntry element.
                SimpleXElement testEntry = CreateElement("TestEntry");
                testEntry.SetAttributeValue("testId", testId);
                testEntry.SetAttributeValue("executionId", executionId);
                testEntry.SetAttributeValue("testListId", testListId);
                TestEntries.Add(testEntry);

                // UnitTestResult element.
                SimpleXElement unitTestResult = CreateElement("UnitTestResult");
                unitTestResult.SetAttributeValue("executionId", executionId);
                unitTestResult.SetAttributeValue("testId", testId);
                unitTestResult.SetAttributeValue("testName", name);
                unitTestResult.SetAttributeValue("computerName", computerName);

                TimeSpan duration = endTime.Subtract(startTime);
                unitTestResult.SetAttributeValue("duration", duration.ToString());

                unitTestResult.SetAttributeValue("startTime", ToDateString(startTime));
                unitTestResult.SetAttributeValue("endTime", ToDateString(endTime));
                unitTestResult.SetAttributeValue("testType", UnitTestTestTypeId);
                unitTestResult.SetAttributeValue("outcome", outcome.ToString());
                unitTestResult.SetAttributeValue("testListId", testListId.ToString());

                // Add any pending items
                foreach (SimpleXElement pending in _pendingElements)
                {
                    unitTestResult.Add(pending);
                }
//.........这里部分代码省略.........