public void beforeInvocation(IInvokedMethod arg0, ITestResult arg1) {
   TestNG tn = new TestNG();
   tn.setDefaultTestName(returnMethodName(arg0.getTestMethod()));
   String textMsg = "About to begin executing " + returnMethodName(arg0.getTestMethod());
   method = returnMethodName(arg0.getTestMethod());
   Reporter.log(textMsg, true);
 }
 /**
  * Get All tests id by class + method + parameters hash code.
  *
  * @param context
  * @param suite
  * @author kevinkong
  */
 private void getAllTestIds(ITestContext context, ISuite suite) {
   IResultMap passTests = context.getPassedTests();
   IResultMap failTests = context.getFailedTests();
   List<IInvokedMethod> invokedMethods = suite.getAllInvokedMethods();
   for (IInvokedMethod im : invokedMethods) {
     if (passTests.getAllMethods().contains(im.getTestMethod())
         || failTests.getAllMethods().contains(im.getTestMethod())) {
       int testId = getId(im.getTestResult());
       // m_out.println("ALLtestid=" + testId);
       allRunTestIds.add(testId);
     }
   }
 }
Esempio n. 3
0
  public void beforeInvocation(IInvokedMethod invokedMethod, ITestResult testResult) {
    if (!methodConfigured) {
      if (isAfterConfiguration(invokedMethod.getTestMethod())) {
        return;
      }

      if (invokedMethod.getTestMethod().isBeforeSuiteConfiguration()) {
        return;
      }

      configureMethod(testResult);

      methodConfigured = true;
    }
  }
  @Override
  public void beforeInvocation(
      IInvokedMethod method, ITestResult testResult, ITestContext context) {
    int failed = findFailed(context);
    if (failed > 0) {
      LOG.error("Masking will not proceed. {} Configurations have failed", failed);
      return;
    }

    Method rmethod = method.getTestMethod().getConstructorOrMethod().getMethod();
    if (rmethod.getAnnotation(Test.class) != null
        || rmethod.getAnnotation(BeforeClass.class) != null
        || rmethod.getAnnotation(BeforeTest.class) != null) {
      if (rmethod.getAnnotation(RunsWithController.class) != null
          || rmethod.getDeclaringClass().getAnnotation(RunsWithController.class) != null) {
        LOG.warn("Method or Class of {} asks Controller to be masked", rmethod.getName());
        AnnotationsHelper p = SteviaContext.getSpringContext().getBean(AnnotationsHelper.class);
        try {
          p.maskExistingController(rmethod);
          masked = true;
        } catch (Throwable e) {
          throw new IllegalStateException("failed to replace controller", e);
        }
      }
    }
  }
  /**
   * Before invocation.
   *
   * @param methodtest the methodtest
   * @param result the result
   * @see org.testng.IInvokedMethodListener#beforeInvocation(org.testng.IInvokedMethod,
   *     org.testng.ITestResult)
   */
  @Override
  public final void beforeInvocation(final IInvokedMethod methodtest, final ITestResult result) {

    if (methodtest.isTestMethod()) {

      String dataProvider = "";

      Method method = methodtest.getTestMethod().getConstructorOrMethod().getMethod();
      Annotation[] testAnnot = method.getAnnotations();
      for (Annotation annot : testAnnot) {

        if (annot instanceof Test) {

          Test tAnnot = (Test) annot;
          dataProvider = tAnnot.dataProvider();
          if ("".equalsIgnoreCase(prevDataProvider)
              || !(prevDataProvider.equalsIgnoreCase(dataProvider))) {
            dataIteration = 0;
            prevDataProvider = dataProvider;
          }
        }
      }

      dataIteration++;
    }
  }
  public void afterInvocation(IInvokedMethod method, ITestResult result) {
    resultT = result;
    String textMsg = "Completed executing " + returnMethodName(method.getTestMethod());
    Reporter.log(textMsg, true);

    Reporter.setCurrentTestResult(result);

    if (method.isTestMethod()) {

      List<Throwable> verificationFailures = TestBase.getVerificationFailures();

      // if there are verification failures...
      if (verificationFailures.size() > 0) {

        // set the test to failed
        result.setStatus(ITestResult.FAILURE);

        // if there is an assertion failure add it to verificationFailures
        if (result.getThrowable() != null) {
          verificationFailures.add(result.getThrowable());
        }

        int size = verificationFailures.size();
        // if there's only one failure just set that
        if (size == 1) {
          result.setThrowable(verificationFailures.get(0));
        } else {
          // create a failure message with all failures and stack traces (except last failure)
          StringBuffer failureMessage =
              new StringBuffer("Multiple failures (").append(size).append("):\n\n");
          for (int i = 0; i < size - 1; i++) {
            failureMessage
                .append("Failure ")
                .append(i + 1)
                .append(" of ")
                .append(size)
                .append(":\n");
            Throwable t = verificationFailures.get(i);
            String fullStackTrace = Utils.stackTrace(t, false)[1];
            failureMessage.append(fullStackTrace).append("\n\n");
          }

          // final failure
          Throwable last = verificationFailures.get(size - 1);
          failureMessage.append("Failure ").append(size).append(" of ").append(size).append(":\n");
          failureMessage.append(last.toString());

          // set merged throwable
          Throwable merged = new Throwable(failureMessage.toString());
          merged.setStackTrace(last.getStackTrace());

          result.setThrowable(merged);
        }
      }
    }
  }
  /**
   * Since the methods will be sorted chronologically, we want to return the ITestNGMethod from the
   * invoked methods.
   */
  private Collection<ITestNGMethod> getMethodSet(IResultMap tests, ISuite suite) {
    List<IInvokedMethod> r = Lists.newArrayList();
    List<IInvokedMethod> invokedMethods = suite.getAllInvokedMethods();

    // Eliminate the repeat retry methods
    for (IInvokedMethod im : invokedMethods) {
      if (tests.getAllMethods().contains(im.getTestMethod())) {
        int testId = getId(im.getTestResult());
        if (!testIds.contains(testId)) {
          testIds.add(testId);
          r.add(im);
        }
      }
    }
    Arrays.sort(r.toArray(new IInvokedMethod[r.size()]), new TestSorter());
    List<ITestNGMethod> result = Lists.newArrayList();

    // Add all the invoked methods
    for (IInvokedMethod m : r) {
      result.add(m.getTestMethod());
    }

    // Add all the methods that weren't invoked (e.g. skipped) that we
    // haven't added yet
    // for (ITestNGMethod m : tests.getAllMethods()) {
    // if (!result.contains(m)) {
    // result.add(m);
    // }
    // }

    for (ITestResult allResult : tests.getAllResults()) {
      int testId = getId(allResult);
      if (!testIds.contains(testId)) {
        result.add(allResult.getMethod());
      }
    }

    return result;
  }