Exemple #1
0
  protected void generateFailureSuite(XmlSuite xmlSuite, ISuite suite, String outputDir) {
    XmlSuite failedSuite = (XmlSuite) xmlSuite.clone();
    failedSuite.setName("Failed suite [" + xmlSuite.getName() + "]");
    m_xmlSuite = failedSuite;

    Map<String, XmlTest> xmlTests = Maps.newHashMap();
    for (XmlTest xmlT : xmlSuite.getTests()) {
      xmlTests.put(xmlT.getName(), xmlT);
    }

    Map<String, ISuiteResult> results = suite.getResults();

    for (Map.Entry<String, ISuiteResult> entry : results.entrySet()) {
      ISuiteResult suiteResult = entry.getValue();
      ITestContext testContext = suiteResult.getTestContext();

      generateXmlTest(
          suite,
          xmlTests.get(testContext.getName()),
          testContext,
          testContext.getFailedTests().getAllResults(),
          testContext.getSkippedTests().getAllResults());
    }

    if (null != failedSuite.getTests() && failedSuite.getTests().size() > 0) {
      Utils.writeUtf8File(outputDir, TESTNG_FAILED_XML, failedSuite.toXml());
      Utils.writeUtf8File(suite.getOutputDirectory(), TESTNG_FAILED_XML, failedSuite.toXml());
    }
  }
  private static void doTest(XmlSuite suite, String expected) {
    final StringBuffer buf = new StringBuffer();
    final IDEATestNGRemoteListener listener = createListener(buf);

    for (XmlTest test : suite.getTests()) {
      for (XmlClass aClass : test.getClasses()) {
        final String classFQName = aClass.getName();
        for (XmlInclude include : aClass.getIncludedMethods()) {
          final String methodName = include.getName();
          List<Integer> numbers = include.getInvocationNumbers();
          if (numbers.isEmpty()) {
            numbers = Collections.singletonList(0);
          }
          for (Integer integer : numbers) {
            final MockTestNGResult result =
                new MockTestNGResult(classFQName, methodName, null, new Object[] {integer});
            listener.onTestStart(result);
            listener.onTestFinished(result);
          }
        }
      }
    }

    Assert.assertEquals(
        "output: " + buf, expected, StringUtil.convertLineSeparators(buf.toString()));
  }
  @Test
  public void testOneTestMethodWithMultipleInvocationCount() throws Exception {
    final XmlSuite suite = new XmlSuite();
    final XmlTest test = new XmlTest();
    final XmlClass xmlClass = new XmlClass("a.ATest", false);
    xmlClass.getIncludedMethods().add(new XmlInclude("test1", Arrays.asList(0, 1, 2), 0));
    test.getClasses().add(xmlClass);
    suite.getTests().add(test);

    doTest(
        suite,
        "##teamcity[testCount count='1']\n"
            + "\n"
            + "##teamcity[testSuiteStarted name ='ATest' locationHint = 'java:suite://a.ATest']\n"
            + "\n"
            + "##teamcity[testStarted name='ATest.test1|[0|]' locationHint='java:test://a.ATest.test1|[0|]']\n"
            + "\n"
            + "##teamcity[testFinished name='ATest.test1|[0|]']\n"
            + "##teamcity[testCount count='1']\n"
            + "\n"
            + "##teamcity[testStarted name='ATest.test1|[1|] (1)' locationHint='java:test://a.ATest.test1|[1|]']\n"
            + "\n"
            + "##teamcity[testFinished name='ATest.test1|[1|] (1)']\n"
            + "##teamcity[testCount count='1']\n"
            + "\n"
            + "##teamcity[testStarted name='ATest.test1|[2|] (2)' locationHint='java:test://a.ATest.test1|[2|]']\n"
            + "\n"
            + "##teamcity[testFinished name='ATest.test1|[2|] (2)']\n");
  }
Exemple #4
0
 public TCKRunner() {
   setName("JSR363-TCK 0.1");
   XmlTest test = new XmlTest(this);
   test.setName("TCK/Test Setup");
   List<XmlClass> classes = new ArrayList<>();
   classes.add(new XmlClass(TCKSetup.class));
   test.setXmlClasses(classes);
 }
  private XmlSuite createXmlSuite() {
    XmlSuite result = new XmlSuite();
    result.setName(getDefaultSuiteName());
    XmlTest test = new XmlTest(result);
    test.setName(getDefaultTestName());

    updateXmlSuite(result);

    return result;
  }
Exemple #6
0
  protected XmlTest createXmlTest(XmlSuite suite, String name, String... classes) {
    XmlTest result = new XmlTest(suite);
    int index = 0;
    result.setName(name);
    for (String c : classes) {
      XmlClass xc = new XmlClass(c, index++, true /* load classes */);
      result.getXmlClasses().add(xc);
    }

    return result;
  }
 private void updateXmlSuite(XmlSuite suite) {
   p("Updating XML suite");
   XmlTest test = suite.getTests().get(0);
   test.getXmlClasses().clear();
   test.getXmlPackages().clear();
   if (m_selectionCombo.getSelectionIndex() == 0) {
     test.getXmlClasses().addAll(m_classes);
   } else {
     test.getXmlPackages().addAll(m_packages);
   }
   p("Done updating XML suite");
 }
  // Send the name of the suite and the name of the test as parameters so that the methods can
  // associate their
  // execution event logs with them. Specified the delay in seconds to apply for the method
  // execution. This delay
  // helps in determining the parallelism or lack thereof for method executions.
  public static void addParams(XmlSuite suite, String suiteName, String testName, String sleepFor) {
    Map<String, String> parameters = new HashMap<>();
    parameters.put("suiteName", suiteName);
    parameters.put("testName", testName);
    parameters.put("sleepFor", sleepFor);

    for (XmlTest test : suite.getTests()) {
      if (test.getName().equals(testName)) {
        test.setParameters(parameters);
      }
    }
  }
Exemple #9
0
  private XmlSuite createSuite(String name, Class[] classes) {
    XmlSuite result = new XmlSuite();
    result.setName(name);

    for (Class c : classes) {
      XmlTest test1 = new XmlTest(result);
      test1.setName(c.getName());
      XmlClass class1 = new XmlClass(c);
      test1.getXmlClasses().add(class1);
    }

    return result;
  }
  /**
   * Call testng to run test cases.
   *
   * @param testngFile testng running configuration file, such as "testng.xml",
   *     "config1.xml,config2.xml"
   * @throws Exception
   */
  private static void handleTestNGRun(String testngFile) throws Exception {

    TestNG testng = new TestNG();
    List<XmlSuite> allXmlSuites = new ArrayList<XmlSuite>();
    for (String suiteFile : testngFile.split(",")) {
      Collection<XmlSuite> allSuites =
          new Parser(suiteFile).parse(); // suiteFile itself has "/testng.xml"
      for (XmlSuite s : allSuites) {
        allXmlSuites.add(s);
        for (XmlTest test : s.getTests()) { // <test> tag
          if (test.getParameter("testngFile")
              != null) // if there is a "testngFile" parameter under <test> tag, parse it to a
          allXmlSuites.addAll(
                new Parser(test.getParameter("testngFile"))
                    .parse()); // testng configuration file and run it.
        }
      }
    }

    int globalRunCount = 1; // default value
    if (globalMap.get("globalRunCount") != null
        && globalMap.get("globalRunCount").trim().length() != 0)
      globalRunCount = Integer.valueOf(globalMap.get("globalRunCount"));
    if (globalRunCount == 0) allXmlSuites.clear();
    else if (globalRunCount == 1) ;
    else {
      List<XmlSuite> allXmlSuitesOriginal = new ArrayList<XmlSuite>(allXmlSuites);
      for (int i = 2;
          i <= globalRunCount;
          i++) { // notice: if use testng default html report only can recognize one suite if more
                 // suites have the same names
        allXmlSuites.addAll(
            allXmlSuitesOriginal); // though changed the suite name. html report still not ok. but
                                   // testng-results.xml has the correct values.
      }
    }

    testng.setXmlSuites(allXmlSuites);
    testng.setOutputDirectory(reportRootdir);

    testng.setUseDefaultListeners(true);

    // add customized TestNG listeners
    testMethodStatusListener =
        new TestMethodStatusListener(); // enable obtained by forward operation
    testng.addListener(testMethodStatusListener);
    testReportListener = new TestReportListener(testMethodStatusListener);
    testng.addListener(testReportListener);

    testng.run();
  }
 /**
  * Returns this test as a TestNG XmlTest
  *
  * @param suite
  * @param loadClasses whether to load classes when creating the XmlTest
  * @return this test as TestNG XmlTest
  */
 public XmlTest getTestAsXmlTest(XmlSuite suite, boolean loadClasses) {
   XmlTest xmltest = new XmlTest(suite);
   xmltest.setName(this.id + "." + this.name); // set name like
   // "<id>.<name>"
   // add parameters to this test case
   Properties params = this.getParametersAsProperties();
   for (Enumeration<?> e = params.keys(); e.hasMoreElements(); ) {
     String key = (String) e.nextElement();
     xmltest.addParameter(key, params.getProperty(key));
   }
   // add test classes
   xmltest.setXmlClasses(this.getXmlClasses(loadClasses));
   return xmltest;
 }
Exemple #12
0
 /** @return The parameters defined in this test tag and the tags above it. */
 public Map<String, String> getAllParameters() {
   Map<String, String> result = Maps.newHashMap();
   Map<String, String> parameters = m_xmlTest.getLocalParameters();
   result.putAll(parameters);
   result.putAll(m_parameters);
   return result;
 }
Exemple #13
0
  @Override
  public Object[] getInstances(boolean create) {
    Object[] result = {};

    if (m_xmlTest.isJUnit()) {
      if (create) {
        result =
            new Object[] {
              ClassHelper.createInstance(
                  m_class, m_classes, m_xmlTest, m_annotationFinder, m_objectFactory)
            };
      }
    } else {
      result = new Object[] {getDefaultInstance()};
    }
    if (m_instances.size() > 0) {
      result = m_instances.toArray(new Object[m_instances.size()]);
    }

    m_instanceCount = m_instances.size();
    m_instanceHashCodes = new long[m_instanceCount];
    for (int i = 0; i < m_instanceCount; i++) {
      m_instanceHashCodes[i] = m_instances.get(i).hashCode();
    }
    return result;
  }
Exemple #14
0
 /** Constructor. */
 public TCKRunner() {
   setName("JSR354-TCK, version 1.1");
   XmlTest test = new XmlTest(this);
   test.setName("TCK/Test Setup");
   List<XmlClass> classes = new ArrayList<>();
   classes.add(new XmlClass(TCKTestSetup.class));
   classes.add(new XmlClass(ModellingCurrenciesTest.class));
   classes.add(new XmlClass(ModellingMonetaryAmountsTest.class));
   classes.add(new XmlClass(CreatingMonetaryAmountsTest.class));
   classes.add(new XmlClass(ExternalizingNumericValueTest.class));
   classes.add(new XmlClass(FunctionalExtensionPointsTest.class));
   classes.add(new XmlClass(AccessingCurrenciesAmountsRoundingsTest.class));
   classes.add(new XmlClass(MonetaryConversionsTest.class));
   classes.add(new XmlClass(ExchangeRatesAndRateProvidersTest.class));
   classes.add(new XmlClass(ConvertingAmountsTest.class));
   classes.add(new XmlClass(ProviderChainsTest.class));
   classes.add(new XmlClass(FormattingMonetaryAmountsTest.class));
   test.setXmlClasses(classes);
 }
Exemple #15
0
  /**
   * Clone the <TT>source</TT> <CODE>XmlTest</CODE> by including: - test attributes - groups
   * definitions - parameters
   *
   * <p>The &lt;classes&gt; sub element is ignored for the moment.
   *
   * @return a clone of the current XmlTest
   */
  @Override
  public Object clone() {
    XmlTest result = new XmlTest(getSuite());

    result.setName(getName());
    result.setIncludedGroups(getIncludedGroups());
    result.setExcludedGroups(getExcludedGroups());
    result.setJUnit(isJUnit());
    result.setParallel(getParallel());
    result.setVerbose(getVerbose());
    result.setParameters(getParameters());
    result.setXmlPackages(getXmlPackages());

    Map<String, List<String>> metagroups = getMetaGroups();
    for (Map.Entry<String, List<String>> group : metagroups.entrySet()) {
      result.addMetaGroup(group.getKey(), group.getValue());
    }

    return result;
  }
  @Test
  public void verifyTestContextInjection(ITestContext tc, XmlTest xmlTest) {
    TestNG tng = create();
    tng.setTestClasses(new Class[] {Sample.class});
    TestListenerAdapter tla = new TestListenerAdapter();
    tng.addListener(tla);
    tng.run();

    Assert.assertEquals(xmlTest.getName(), "Injection");
    Assert.assertEquals(tla.getPassedTests().size(), 1);
    Assert.assertEquals(tla.getPassedTests().get(0).getMethod().getMethodName(), "f");
  }
Exemple #17
0
  public static XmlSuite parse(String filePath, InputStream is) throws FileNotFoundException {
    Constructor constructor = new TestNGConstructor(XmlSuite.class);
    {
      TypeDescription suiteDescription = new TypeDescription(XmlSuite.class);
      suiteDescription.putListPropertyType("packages", XmlPackage.class);
      suiteDescription.putListPropertyType("listeners", String.class);
      suiteDescription.putListPropertyType("tests", XmlTest.class);
      suiteDescription.putListPropertyType("method-selectors", XmlMethodSelector.class);
      constructor.addTypeDescription(suiteDescription);
    }

    {
      TypeDescription testDescription = new TypeDescription(XmlTest.class);
      testDescription.putListPropertyType("classes", XmlClass.class);
      testDescription.putMapPropertyType("metaGroups", String.class, List.class);
      testDescription.putListPropertyType("method-selectors", XmlMethodSelector.class);
      constructor.addTypeDescription(testDescription);
    }

    org.yaml.snakeyaml.Yaml y = new org.yaml.snakeyaml.Yaml(constructor);
    if (is == null) is = new FileInputStream(new File(filePath));
    XmlSuite result = (XmlSuite) y.load(is);

    result.setFileName(filePath);
    // DEBUG
    //    System.out.println("[Yaml] " + result.toXml());

    // Adjust XmlTest parents and indices
    for (XmlTest t : result.getTests()) {
      t.setSuite(result);
      int index = 0;
      for (XmlClass c : t.getClasses()) {
        c.setIndex(index++);
      }
    }

    return result;
  }
Exemple #18
0
  /**
   * @param methods The methods we want to represent
   * @param srcXmlTest
   * @return A list of XmlClass objects (each representing a <class> tag) based on the parameter
   *     methods
   */
  private List<XmlClass> createXmlClasses(List<ITestNGMethod> methods, XmlTest srcXmlTest) {
    List<XmlClass> result = Lists.newArrayList();
    Map<Class, Set<ITestNGMethod>> methodsMap = Maps.newHashMap();

    for (ITestNGMethod m : methods) {
      Object[] instances = m.getInstances();
      Class clazz =
          instances == null || instances.length == 0 || instances[0] == null
              ? m.getRealClass()
              : instances[0].getClass();
      Set<ITestNGMethod> methodList = methodsMap.get(clazz);
      if (null == methodList) {
        methodList = new HashSet<ITestNGMethod>();
        methodsMap.put(clazz, methodList);
      }
      methodList.add(m);
    }

    // Ideally, we should preserve each parameter in each class but putting them
    // all in the same bag for now
    Map<String, String> parameters = Maps.newHashMap();
    for (XmlClass c : srcXmlTest.getClasses()) {
      parameters.putAll(c.getLocalParameters());
    }

    int index = 0;
    for (Map.Entry<Class, Set<ITestNGMethod>> entry : methodsMap.entrySet()) {
      Class clazz = entry.getKey();
      Set<ITestNGMethod> methodList = entry.getValue();
      // @author Borojevic
      // Need to check all the methods, not just @Test ones.
      XmlClass xmlClass = new XmlClass(clazz.getName(), index++, false /* don't load classes */);
      List<XmlInclude> methodNames = Lists.newArrayList(methodList.size());
      int ind = 0;
      for (ITestNGMethod m : methodList) {
        methodNames.add(
            new XmlInclude(m.getMethod().getName(), m.getFailedInvocationNumbers(), ind++));
      }
      xmlClass.setIncludedMethods(methodNames);
      xmlClass.setParameters(parameters);
      result.add(xmlClass);
    }

    return result;
  }
Exemple #19
0
 /** Generate testng-failed.xml */
 private void createXmlTest(
     ITestContext context, List<ITestNGMethod> methods, XmlTest srcXmlTest) {
   XmlTest xmlTest = new XmlTest(m_xmlSuite);
   xmlTest.setName(context.getName() + "(failed)");
   xmlTest.setBeanShellExpression(srcXmlTest.getExpression());
   xmlTest.setIncludedGroups(srcXmlTest.getIncludedGroups());
   xmlTest.setExcludedGroups(srcXmlTest.getExcludedGroups());
   xmlTest.setParallel(srcXmlTest.getParallel());
   xmlTest.setParameters(srcXmlTest.getLocalParameters());
   xmlTest.setJUnit(srcXmlTest.isJUnit());
   List<XmlClass> xmlClasses = createXmlClasses(methods, srcXmlTest);
   xmlTest.setXmlClasses(xmlClasses);
 }
Exemple #20
0
  private static void toYaml(StringBuilder result, String sp, XmlTest t) {
    String sp2 = sp + "  ";
    result.append(sp).append("- name: ").append(t.getName()).append("\n");

    maybeAdd(result, sp2, "junit", t.isJUnit(), XmlSuite.DEFAULT_JUNIT);
    maybeAdd(result, sp2, "verbose", t.getVerbose(), XmlSuite.DEFAULT_VERBOSE);
    maybeAdd(result, sp2, "timeOut", t.getTimeOut(), null);
    maybeAdd(result, sp2, "parallel", t.getParallel(), XmlSuite.DEFAULT_PARALLEL);
    maybeAdd(
        result,
        sp2,
        "skipFailedInvocationCounts",
        t.skipFailedInvocationCounts(),
        XmlSuite.DEFAULT_SKIP_FAILED_INVOCATION_COUNTS);

    maybeAdd(result, "preserveOrder", sp2, t.getPreserveOrder(), XmlSuite.DEFAULT_PRESERVE_ORDER);

    toYaml(result, "parameters", sp2, t.getTestParameters());

    if (t.getIncludedGroups().size() > 0) {
      result
          .append(sp2)
          .append("includedGroups: [ ")
          .append(Utils.join(t.getIncludedGroups(), ","))
          .append(" ]\n");
    }

    if (t.getExcludedGroups().size() > 0) {
      result
          .append(sp2)
          .append("excludedGroups: [ ")
          .append(Utils.join(t.getExcludedGroups(), ","))
          .append(" ]\n");
    }

    Map<String, List<String>> mg = t.getMetaGroups();
    if (mg.size() > 0) {
      result.append(sp2).append("metaGroups: { ");
      boolean first = true;
      for (String group : mg.keySet()) {
        if (!first) result.append(", ");
        result.append(group).append(": [ ").append(Utils.join(mg.get(group), ",")).append(" ] ");
        first = false;
      }
      result.append(" }\n");
    }

    if (t.getXmlPackages().size() > 0) {
      result.append(sp2).append("xmlPackages:\n");
      for (XmlPackage xp : t.getXmlPackages()) {
        toYaml(result, sp2 + "  - ", xp);
      }
    }

    if (t.getXmlClasses().size() > 0) {
      result.append(sp2).append("classes:\n");
      for (XmlClass xc : t.getXmlClasses()) {
        toYaml(result, sp2 + "  ", xc);
      }
    }

    result.append("\n");
  }