import hudson.tasks.junit.CaseResult; //导入依赖的package包/类
/**
 * Collects Surefire test results
 * @param suites
 * @param packageNames
 * @return
 */
private Map<String, Boolean> prepareTestResults(Collection<SuiteResult> suites,	Set<String> packageNames) {
	Map<String,Boolean> zephyrTestCaseMap = new HashMap<String, Boolean>();
	for (Iterator<SuiteResult> iterator = suites.iterator(); iterator
			.hasNext();) {
		SuiteResult suiteResult = iterator.next();
		List<CaseResult> cases = suiteResult.getCases();
		for (CaseResult caseResult : cases) {
			boolean isPassed = caseResult.isPassed();
			String name = caseResult.getFullName();
			if (!zephyrTestCaseMap.containsKey(name)) {
				zephyrTestCaseMap.put(name, isPassed);
				packageNames.add(caseResult.getPackageName());
			}
		}
	}
	return zephyrTestCaseMap;
}
 

import hudson.tasks.junit.CaseResult; //导入依赖的package包/类
/**
 * Convert JUnit's TestResult representation into a generic UnitResults
 * @param jUnitResults The result of the JUnit run
 * @return The converted results
 */
public UnitResults convertJUnit(TestResult jUnitResults) {
    UnitResults results = new UnitResults();
    if (jUnitResults == null) {
        return results;
    }
    for (SuiteResult sr : jUnitResults.getSuites()) {
        for (CaseResult cr : sr.getCases()) {
            UnitResult result = new UnitResult(
                    cr.getClassName(),
                    cr.getDisplayName(),
                    cr.getErrorStackTrace(),
                    cr.getDuration(),
                    cr.getFailCount(),
                    cr.getSkipCount(),
                    cr.getPassCount()
            );
            results.add(result);
        }
    }
    return results;
}
 

import hudson.tasks.junit.CaseResult; //导入依赖的package包/类
static List<CaseResult> setupCaseResultList() {
  CaseResult caseOne = mock(CaseResult.class);
  CaseResult caseTwo = mock(CaseResult.class);
  CaseResult caseThree = mock(CaseResult.class);

  when(caseOne.getClassName()).thenReturn(TEST_CLASS_ONE);
  when(caseOne.getName()).thenReturn(TEST_METHOD_ONE);

  when(caseTwo.getClassName()).thenReturn(TEST_CLASS_ONE);
  when(caseTwo.getName()).thenReturn(TEST_METHOD_TWO);

  when(caseThree.getClassName()).thenReturn(TEST_CLASS_TWO);
  when(caseThree.getName()).thenReturn(TEST_METHOD_ONE);

  List<CaseResult> caseResultList = new ArrayList<CaseResult>();
  caseResultList.add(caseOne);
  caseResultList.add(caseTwo);
  caseResultList.add(caseThree);
  return caseResultList;
}
 

import hudson.tasks.junit.CaseResult; //导入依赖的package包/类
@Override
public List<TestAction> getTestAction(TestObject testObject) {

   if (build.getParent().getPublishersList().get(QuarantinableJUnitResultArchiver.class) == null) {
      // only display if QuarantinableJUnitResultArchiver chosen, to avoid
      // confusion
      System.out.println("not right publisher");
      return Collections.emptyList();
   }

   String id = testObject.getId();
   QuarantineTestAction result = quarantines.get(id);

   if (result != null) {
      return Collections.<TestAction> singletonList(result);
   }

   if (testObject instanceof CaseResult) {
      return Collections.<TestAction> singletonList(new QuarantineTestAction(this, id));
   }
   return Collections.emptyList();
}
 

import hudson.tasks.junit.CaseResult; //导入依赖的package包/类
public List<CaseResult> getQuarantinedTests() {
   ArrayList<CaseResult> list = new ArrayList<CaseResult>();
   for (TopLevelItem item : getOwner().getItems()) {
      if (item instanceof Job) {
         Job job = (Job) item;
         Run lb = job.getLastBuild();
         while (lb != null && (lb.hasntStartedYet() || lb.isBuilding()))
            lb = lb.getPreviousBuild();

         if (lb != null && lb.getAction(TestResultAction.class) != null) {
            for (SuiteResult suite : lb.getAction(TestResultAction.class).getResult().getSuites()) {
               for (CaseResult test : suite.getCases()) {
                  QuarantineTestAction action = test.getTestAction(QuarantineTestAction.class);
                  if (action != null && action.isQuarantined()) {
                     list.add(test);
                  }
               }
            }
         }
      }
   }
   return list;
}
 

import hudson.tasks.junit.CaseResult; //导入依赖的package包/类
public void testNoTestsHaveQuarantineActionForStandardPublisher() throws Exception {
   project.getPublishersList().remove(QuarantinableJUnitResultArchiver.class);

   DescribableList<TestDataPublisher, Descriptor<TestDataPublisher>> publishers = new DescribableList<TestDataPublisher, Descriptor<TestDataPublisher>>(
         project);
   publishers.add(new QuarantineTestDataPublisher());
   project.getPublishersList().add(new JUnitResultArchiver("*.xml", false, publishers));

   TestResult tr = getResultsFromJUnitResult("junit-1-failure.xml");

   for (SuiteResult suite : tr.getSuites()) {
      for (CaseResult result : suite.getCases()) {
         assertNull(result.getTestAction(QuarantineTestAction.class));
      }
   }
}
 

import hudson.tasks.junit.CaseResult; //导入依赖的package包/类
private int getTestAge(CaseResult result) {
    if (result.isPassed())
        return 0;
    else if (result.getRun() != null) {
        return result.getRun().getNumber() - result.getFailedSince() + 1;
    } else {
        return 0;
    }
}
 

import hudson.tasks.junit.CaseResult; //导入依赖的package包/类
private int outputTest(StringBuilder buffer, CaseResult failedTest,
                           boolean showStack, boolean showMessage, int lengthLeft) {
        StringBuilder local = new StringBuilder();

        local.append(failedTest.isPassed() ? "PASSED" : "FAILED").append(": ");

//        if(failedTest instanceof CaseResult) {
//            local.append(failedTest.getClassName());
//        } else {
//            local.append(failedTest.getFullName());
//        }
//        local.append('.').append(failedTest.getDisplayName()).append('\n');

        if (showMessage) {
            local.append("\nError Message:\n").append(failedTest.getErrorDetails()).append("\n");
        }

        if (showStack) {
            local.append("\nStack Trace:\n").append(failedTest.getErrorStackTrace()).append('\n');
        }

        if (showMessage || showStack) {
            local.append('\n');
        }

        if (local.length() > lengthLeft) {
            local.setLength(lengthLeft);
        }

        buffer.append(local.toString());
        return local.length();
    }
 

import hudson.tasks.junit.CaseResult; //导入依赖的package包/类
public int getFailedTestCount(SuiteResult suiteResult) {//work!

        int failedTestCount = 0;
        List<CaseResult> cases = suiteResult.getCases();
        for (CaseResult caseResult : cases) {
            if (!caseResult.isPassed() && !caseResult.isSkipped()) { // Any error, invalidates the suite result
                failedTestCount++;
            }
        }
        return failedTestCount;
    }
 

import hudson.tasks.junit.CaseResult; //导入依赖的package包/类
@Override
public TestResultAction.Data contributeTestData(Run<?, ?> run, @Nonnull FilePath workspace,
                                                Launcher launcher, TaskListener listener,
                                                TestResult testResult) throws IOException, InterruptedException {
    log(listener.getLogger(), "Publishing test results");
    Map<String, String> testSessionMap = workspace.act(new BrowserStackReportFileCallable(REPORT_FILE_PATTERN, run.getTimeInMillis()));
    AutomateActionData automateActionData = new AutomateActionData();
    Map<String, Long> testCaseIndices = new HashMap<String, Long>();

    int testCount = 0;
    int sessionCount = 0;

    for (SuiteResult suiteResult : testResult.getSuites()) {
        List<CaseResult> cases = suiteResult.getCases();
        testCount += cases.size();
        logDebug(listener.getLogger(), suiteResult.getName() + ": " + cases.size() + " test cases found.");

        for (CaseResult caseResult : cases) {
            String testCaseName = getTestCaseName(caseResult);

            Long testIndex = testCaseIndices.containsKey(testCaseName) ? testCaseIndices.get(testCaseName) : -1L;
            testCaseIndices.put(testCaseName, ++testIndex);
            logDebug(listener.getLogger(), testCaseName + " / " + testCaseName + " <=> " + testIndex);

            String testId = String.format("%s{%d}", testCaseName, testIndex);
            if (testSessionMap.containsKey(testId)) {
                AutomateTestAction automateTestAction = new AutomateTestAction(run, caseResult, testSessionMap.get(testId));
                automateActionData.registerTestAction(caseResult.getId(), automateTestAction);
                logDebug(listener.getLogger(), "registerTestAction: " + testId + " => " + automateTestAction);
                sessionCount++;
            }
        }
    }

    testCaseIndices.clear();
    log(listener.getLogger(), testCount + " tests recorded");
    log(listener.getLogger(), sessionCount + " sessions captured");
    log(listener.getLogger(), "Publishing test results: SUCCESS");
    return automateActionData;
}
 

import hudson.tasks.junit.CaseResult; //导入依赖的package包/类
@Override
public List<? extends TestAction> getTestAction(TestObject testObject) {
    if (testObject instanceof CaseResult) {
        String caseResultId = testObject.getId();
        if (testActionMap.containsKey(caseResultId)) {
            return Collections.singletonList(testActionMap.get(caseResultId));
        }
    }

    return Collections.emptyList();
}
 

import hudson.tasks.junit.CaseResult; //导入依赖的package包/类
@Test
public void testThatReportsArePresent() throws Exception {
    /* =================== Prepare ================= */
    new MockAutomateClient();

    addBuildStep();
    project.getBuildersList().add(new TouchBuilder());
    project.getBuildersList().add(new CopyResourceFileToWorkspaceTarget("browserstack-reports", "REPORT-com.browserstack.automate.application.tests.TestCaseWithFourUniqueSessions.xml"));
    project.getBuildersList().add(new CopyResourceFileToWorkspaceTarget("surefire-reports", "TEST-com.browserstack.automate.application.tests.TestCaseWithFourUniqueSessions.xml"));

    JUnitResultArchiver jUnitResultArchiver = new JUnitResultArchiver("**/surefire-reports/*.xml");
    jUnitResultArchiver.setTestDataPublishers(Collections.singletonList(new AutomateTestDataPublisher()));
    project.getPublishersList().add(jUnitResultArchiver);

    /* =================== Execute ================= */
    FreeStyleBuild build = project.scheduleBuild2(0).get();
    TestResultAction action = build.getAction(TestResultAction.class);

    /* =================== Verify ================= */
    List<TestResultAction.Data> testData = Deencapsulation.getField(action, "testData");
    // Assumption here is that there is only one suite result based on the XML files
    // copied into the workspace above.
    SuiteResult suiteResult = action.getResult().getSuites().iterator().next();

    jenkinsRule.assertBuildStatus(Result.SUCCESS, build);
    Assert.assertNotNull("Additional data on the test MUST be set.", testData);
    Assert.assertTrue("Additional Test data MUST have values.", testData.size() >= 1);
    TestResultAction.Data data = testData.get(0);
    Assert.assertTrue("Additional Test data MUST be an instance of AutomateActionData.", data instanceof AutomateActionData);

    for (CaseResult caseResult : suiteResult.getCases()) {
        AutomateTestAction automateTestAction = (AutomateTestAction) data.getTestAction(caseResult).get(0);
        Session automateSession = automateTestAction.getSession();
        Assert.assertNotNull("Automate Session should not be null.", automateSession);
        Assert.assertTrue("Session Id should not be null or empty.", StringUtils.isNotEmpty(automateSession.getId()));
    }
}
 

import hudson.tasks.junit.CaseResult; //导入依赖的package包/类
@Override
public String getTextResult(Run<?, ?> run) {
    List<TestResultAction> actions = run.getActions(TestResultAction.class);
    StringBuilder builder = new StringBuilder();
    for (TestResultAction action : actions) {
        List<CaseResult> failedTests = action.getFailedTests();
        for (CaseResult result : failedTests) {
            builder.append(result.getTitle() + "\n");
            builder.append(result.getErrorDetails() + "\n");
        }
    }
    return builder.toString();
}
 

import hudson.tasks.junit.CaseResult; //导入依赖的package包/类
/**
 * Organize failing test cases by their class names
 *
 * @param caseResultList all the failing test cases list
 * @return the map with class name and the set of test methods in each class
 */
static Map<String, Set<String>> getFailingTestClassMethodMap(List<CaseResult> caseResultList) {
  Map<String, Set<String>> classMethodMap = new HashMap<String, Set<String>>();
  if (caseResultList != null) {
    for (CaseResult caseResult : caseResultList) {
      if (!classMethodMap.containsKey(caseResult.getClassName())) {
        classMethodMap.put(caseResult.getClassName(), new HashSet<String>());
      }
      classMethodMap.get(caseResult.getClassName()).add(caseResult.getName());
    }
  }
  return classMethodMap;
}
 

import hudson.tasks.junit.CaseResult; //导入依赖的package包/类
@Test
public void testGetFailingTestClassMethodMap() throws Exception {
  List<CaseResult> caseResultList = setupCaseResultList();
  Map<String, Set<String>> classMethodMap = DeflakeListener.getFailingTestClassMethodMap(
      caseResultList);
  assertEquals("Map size should be equal to number of classes", 2, classMethodMap.size());
  Set<String> expectedClassOneMethods = Sets.newHashSet(TEST_METHOD_ONE, TEST_METHOD_TWO);
  Set<String> expectedClassTwoMethods = Sets.newHashSet(TEST_METHOD_ONE);

  assertEquals("Incorrect test methods", expectedClassOneMethods,
      classMethodMap.get(TEST_CLASS_ONE));
  assertEquals("Incorrect test methods", expectedClassTwoMethods,
      classMethodMap.get(TEST_CLASS_TWO));
}
 

import hudson.tasks.junit.CaseResult; //导入依赖的package包/类
@Test
public void testGetFailingTestClassMethodMapWithNoTest() {
  assertTrue("Should return empty map for empty input list",
      DeflakeListener.getFailingTestClassMethodMap(new ArrayList<CaseResult>()).isEmpty());
  assertTrue("Should return empty map for null input list",
      DeflakeListener.getFailingTestClassMethodMap(null).isEmpty());
}
 

import hudson.tasks.junit.CaseResult; //导入依赖的package包/类
@Override
public List<? extends TestAction> getTestAction(TestObject testObject) {
    if (!(testObject instanceof CaseResult)) {
        // Add information only to test case result.
        // Not add to package result or class result.
        return Collections.emptyList();
    }

    CaseResult caseResult = (CaseResult) testObject;
    String qualifiedClassName = caseResult.getClassName();
    String testName = caseResult.getName();
    return Collections.singletonList(new SahaginTestAction(build, qualifiedClassName, testName));
}
 

import hudson.tasks.junit.CaseResult; //导入依赖的package包/类
@Override
public List<TestAction> getTestAction(TestObject testObject)
{
  if (testObject instanceof CaseResult)
  {
    String id = testObject.getId();
    JunitResultAction action = actions.get(id);
    if (action != null)
    {
      return Collections.<TestAction>singletonList(action);
    }
  }

  return Collections.emptyList();
}
 

import hudson.tasks.junit.CaseResult; //导入依赖的package包/类
public void addResult(CaseResult result, QuarantineTestAction action) {
   String username = action.quarantinedByName();

   if (!emailsToSend.containsKey(username)) {
      emailsToSend.put(username, new ArrayList<ResultActionPair>());
   }
   emailsToSend.get(username).add(new ResultActionPair(result, action));

}
 

import hudson.tasks.junit.CaseResult; //导入依赖的package包/类
public int getNumberOfSuccessivePasses(CaseResult test) {
   int count = 0;

   for (TestResult result : test.getHistory().getList()) {
      if (result.isPassed()) {
         count++;
      } else {
         return count;
      }
   }
   return count;
}