@Override
  protected Statement methodBlock(FrameworkMethod frameworkMethod) {
    Thread currentThread = Thread.currentThread();

    ClassLoader contextClassLoader = currentThread.getContextClassLoader();

    PortalClassLoaderUtil.setClassLoader(contextClassLoader);

    TestClass testClass = getTestClass();

    List<FrameworkMethod> beforeFrameworkMethods = testClass.getAnnotatedMethods(Before.class);

    List<FrameworkMethod> afterFrameworkMethods = testClass.getAnnotatedMethods(After.class);

    List<String> arguments = createArguments(frameworkMethod);

    Class<?> clazz = testClass.getJavaClass();

    return new RunInNewJVMStatment(
        _classPath,
        arguments,
        clazz,
        beforeFrameworkMethods,
        frameworkMethod,
        afterFrameworkMethods);
  }
예제 #2
0
 /** @see Parameterized */
 private FrameworkMethod getParametersMethod(TestClass testClass) throws Exception {
   List<FrameworkMethod> methods = testClass.getAnnotatedMethods(Parameterized.Parameters.class);
   for (FrameworkMethod each : methods) {
     int modifiers = each.getMethod().getModifiers();
     if (Modifier.isStatic(modifiers) && Modifier.isPublic(modifiers)) return each;
   }
   throw new Exception("No public static parameters method on class " + testClass.getName());
 }
예제 #3
0
 @Test
 public void annotatedMethodValues() {
   TestClass tc = new TestClass(MethodsAnnotated.class);
   List<String> values =
       tc.getAnnotatedMethodValues(new MethodsAnnotated(), Ignore.class, String.class);
   assertThat(values, hasItem("jupiter"));
   assertThat(values.size(), is(1));
 }
예제 #4
0
 @Test
 public void annotatedFieldValues() {
   TestClass tc = new TestClass(FieldAnnotated.class);
   List<String> values =
       tc.getAnnotatedFieldValues(new FieldAnnotated(), Rule.class, String.class);
   assertThat(values, hasItem("andromeda"));
   assertThat(values.size(), is(1));
 }
  private boolean shouldInitMockitoMocks() {
    TestClass testClass = this.getTestClass();
    InitMocks initMocks = testClass.getAnnotation(InitMocks.class);

    if (initMocks != null) {
      return initMocks.value();
    }

    return true;
  }
예제 #6
0
 @Test
 public void providesAnnotatedFieldsSortedByName() {
   TestClass tc = new TestClass(FieldAnnotated.class);
   List<FrameworkField> annotatedFields = tc.getAnnotatedFields();
   assertThat("Wrong number of annotated fields.", annotatedFields.size(), is(3));
   assertThat(
       "First annotated field is wrong.",
       annotatedFields.iterator().next().getName(),
       is("fieldA"));
 }
예제 #7
0
 /**
  * 判断是否需要执行MilouDbUnitTestExecutionListener
  *
  * @param testClass
  */
 private void switchMilouDBUnitTestExecutionListener(TestClass testClass) {
   List<FrameworkMethod> DBSituations = testClass.getAnnotatedMethods(DBSituations.class);
   List<FrameworkMethod> DBSetupSituation = testClass.getAnnotatedMethods(DBSetupSituation.class);
   List<FrameworkMethod> DBTeardownSituation =
       testClass.getAnnotatedMethods(DBTeardownSituation.class);
   if (!CollectionUtils.isEmpty(DBSituations)
       || !CollectionUtils.isEmpty(DBSetupSituation)
       || !CollectionUtils.isEmpty(DBTeardownSituation)) {
     MilouDBThreadLocal.setMilouDBListener(Boolean.valueOf(true));
   }
 }
  public InternalRemoteRunner(
      Class<?> testClass, String endpoint, Class<? extends Runner> remoteRunnerClass)
      throws InitializationError {
    super(testClass);
    this.testClass = testClass;
    this.remoteRunnerClass = remoteRunnerClass;
    TestClass tc = new TestClass(testClass);

    description = Description.createTestDescription(testClass, tc.getName(), tc.getAnnotations());

    for (FrameworkMethod method : tc.getAnnotatedMethods(Test.class)) {
      String methodName = method.getName();
      Description child =
          Description.createTestDescription(testClass, methodName, method.getAnnotations());

      methodNames.put(child, methodName);
      description.addChild(child);
    }

    if (executorService == null) {
      String ep = System.getProperty("junit.remote.endpoint");
      if (ep == null) {
        ep = endpoint;
      }

      for (String e : ep.split(",")) {
        if (e.trim().equals("")) {
          continue;
        }
        endpoints.add(e.trim());
      }
      executorService = Executors.newFixedThreadPool(endpoints.size());
    }

    setScheduler(
        new RunnerScheduler() {
          @Override
          public void schedule(final Runnable childStatement) {
            SEMAPHORE.reducePermits(1);
            executorService.submit(new SemaphoreDelegate(childStatement));
          }

          @Override
          public void finished() {
            try {
              SEMAPHORE.acquire();
              SEMAPHORE.release();
            } catch (InterruptedException ignore) {
              Thread.currentThread().interrupt();
            }
          }
        });
  }
예제 #9
0
 public int getMaxTestNameLen() {
   if (0 == maxMethodNameLen) {
     int ml = 0;
     final TestClass tc = new TestClass(getClass());
     final List<FrameworkMethod> testMethods = tc.getAnnotatedMethods(org.junit.Test.class);
     for (Iterator<FrameworkMethod> iter = testMethods.iterator(); iter.hasNext(); ) {
       final int l = iter.next().getName().length();
       if (ml < l) {
         ml = l;
       }
     }
     maxMethodNameLen = ml;
   }
   return maxMethodNameLen;
 }
  protected static List<MethodKey> getMethodKeys(
      Class<?> targetClass, Class<? extends Annotation> annotationClass) {

    TestClass testClass = new TestClass(targetClass);

    List<FrameworkMethod> frameworkMethods = testClass.getAnnotatedMethods(annotationClass);

    List<MethodKey> methodKeys = new ArrayList<MethodKey>(frameworkMethods.size());

    for (FrameworkMethod annotatedFrameworkMethod : frameworkMethods) {
      methodKeys.add(new MethodKey(annotatedFrameworkMethod.getMethod()));
    }

    return methodKeys;
  }
 @SuppressWarnings("deprecation")
 private void addSinglePointMethods(ParameterSignature sig, List<PotentialAssignment> list) {
   for (FrameworkMethod dataPointMethod : fClass.getAnnotatedMethods(DataPoint.class)) {
     Class<?> type = sig.getType();
     if ((dataPointMethod.producesType(type))) list.add(new MethodParameterValue(dataPointMethod));
   }
 }
  @Test
  public void
      testFindDataProviderLocationShouldReturnTestClassContainingSetLocationInUseDataProviderAnnotation() {
    // Given:
    final Class<?> dataProviderLocation = DataProviderRunnerTest.class;

    doReturn(new Class<?>[] {dataProviderLocation}).when(useDataProvider).location();

    // When:
    TestClass result = underTest.findDataProviderLocation(useDataProvider);

    // Then:
    assertThat(result).isNotNull();
    // assertThat(result.getJavaClass()).isEqualTo(dataProviderLocation);
    assertThat(result.getName()).isEqualTo(dataProviderLocation.getName());
  }
예제 #13
0
 @Override
 public Description getDescription() {
   Description description =
       Description.createSuiteDescription(getName(), fTestClass.getAnnotations());
   for (T child : getFilteredChildren()) description.addChild(describeChild(child));
   return description;
 }
예제 #14
0
 private List<Class<?>> gatherClasses() {
   ArrayList<Class<?>> result = new ArrayList<Class<?>>();
   List<Classes> classeses =
       fTestClass.getAnnotatedFieldValues(fInstance, SuiteClasses2.class, Classes.class);
   for (Classes each : classeses) result.addAll(each.get());
   return result;
 }
예제 #15
0
 private static Object createTestObject(TestClass testClass) throws InitializationError {
   try {
     return testClass.getOnlyConstructor().newInstance();
   } catch (Exception ex) {
     throw new InitializationError(ex);
   }
 }
예제 #16
0
 public Suite2(Class<?> testClass) throws InitializationError {
   fTestClass = new TestClass(testClass);
   try {
     fInstance = fTestClass.getOnlyConstructor().newInstance();
   } catch (Exception e) {
     throw new InitializationError(e);
   }
 }
 private void addMultiPointMethods(List<PotentialAssignment> list) {
   for (FrameworkMethod dataPointsMethod : fClass.getAnnotatedMethods(DataPoints.class))
     try {
       addArrayValues(dataPointsMethod.getName(), list, dataPointsMethod.invokeExplosively(null));
     } catch (Throwable e) {
       // ignore and move on
     }
 }
예제 #18
0
 private void setAllSituationIntoMap(TestClass testClass) {
   List<FrameworkMethod> frameworkMethods = testClass.getAnnotatedMethods(Test.class);
   for (FrameworkMethod method : frameworkMethods) {
     List<SituationInfo> list = getSituationInfos(method);
     if (!CollectionUtils.isEmpty(list)) {
       situationInfos.put(method, list);
     }
   }
 }
예제 #19
0
 private List<S2TestRule> setS2ClassRule(S2TestRule... rules) {
   List<S2TestRule> ruleList = new ArrayList<S2TestRule>();
   for (S2TestRule rule : rules) {
     ruleList.add(rule);
   }
   when(testClass.getAnnotatedFieldValues(null, ClassRule.class, S2TestRule.class))
       .thenReturn(ruleList);
   return ruleList;
 }
  private void handleInitializationError(
      final boolean developmentMode,
      final List<TestClassResult> result,
      final String klassName,
      final Class<?> klass,
      final InitializationError e) {
    TestClass testClass = new TestClass(klass);

    boolean allMethods =
        (!developmentMode) || (klass.getAnnotation(TestDuringDevelopment.class) != null);

    List<Throwable> causes = e.getCauses();
    long now = System.currentTimeMillis();
    List<TestCaseResult> testCaseResults = new ArrayList<TestCaseResult>();
    List<FrameworkMethod> annotatedMethods = testClass.getAnnotatedMethods(Test.class);

    Exception wrapperException = new Exception("Error during initialization. See log for details");
    wrapperException.setStackTrace(new StackTraceElement[0]);

    for (FrameworkMethod frameworkMethod : annotatedMethods) {
      if (allMethods || (frameworkMethod.getAnnotation(TestDuringDevelopment.class) != null)) {
        TestCaseResult testCaseResult =
            new TestCaseResult(frameworkMethod.getName(), now, now, wrapperException);

        testCaseResults.add(testCaseResult);
      }
    }

    TestClassResult classResult =
        new TestClassResult(klassName, 0, testCaseResults.size(), 0, 0, now, now, testCaseResults);

    result.add(classResult);

    StringWriter sw = new StringWriter();
    PrintWriter pw = new PrintWriter(sw);
    pw.write("Error during initialization of test class '" + klassName + "':\n");
    for (Throwable throwable : causes) {
      throwable.printStackTrace(pw);
    }
    LOGGER.log(Level.SEVERE, sw.toString());
  }
예제 #21
0
 /** 完成Stub的元数据扫描,构建stub元数据仓库 */
 private void stubInfoRepoInit(TestClass testClass) {
   // 加载本地stub仓库
   List<FrameworkMethod> stubMethods = testClass.getAnnotatedMethods(Stub.class);
   if (!CollectionUtils.isEmpty(stubMethods)) {
     for (FrameworkMethod fm : stubMethods) {
       StubInfo info = new StubInfo();
       String stubId = fm.getAnnotation(Stub.class).value();
       info.setStubId(stubId);
       info.setStubClass(testClass.getJavaClass());
       info.setStubMethod(fm.getMethod());
       logger.info("[milou] scan stub,stubId={}", stubId);
       StubInfoRepo.setIntoStubInfoRepo(stubId, info);
     }
   }
   StubLocation locationAnno = testClass.getJavaClass().getAnnotation(StubLocation.class);
   if (locationAnno != null && !locationAnno.value().equals(StubLocation.LOCAL)) {
     // 根据注解加载指定路径下的stub仓库
     List<Class<?>> scanList = PackageScanner.getStubClass(locationAnno.value());
     StubInfoScanner.scanAllStubClass(scanList, StubInfoRepo.getStubInfoRepo());
   }
 }
 private List<TestCaseResult> createErrorTestCaseResults(
     final Class<?> klass, final boolean developmentMode, final long now) {
   TestClass testClass = new TestClass(klass);
   boolean allMethods =
       (!developmentMode) || (klass.getAnnotation(TestDuringDevelopment.class) != null);
   List<FrameworkMethod> annotatedMethods = testClass.getAnnotatedMethods(Test.class);
   List<TestCaseResult> result = new ArrayList<TestCaseResult>();
   for (FrameworkMethod frameworkMethod : annotatedMethods) {
     if (allMethods || (frameworkMethod.getAnnotation(TestDuringDevelopment.class) != null)) {
       Exception exception =
           new Exception(
               "Service object behind the reference was null. We experienced this when the activate"
                   + " method of a DS component threw an exception but there can be other causes. Please"
                   + " check the log! Please note, that in Equinox sometimes such exceptions are"
                   + " written only into different files in the configuration folder.");
       exception.setStackTrace(new StackTraceElement[0]);
       result.add(new TestCaseResult(frameworkMethod.getName(), now, now, exception));
     }
   }
   return result;
 }
 private void addFields(ParameterSignature sig, List<PotentialAssignment> list) {
   for (final Field field : fClass.getJavaClass().getFields()) {
     if (Modifier.isStatic(field.getModifiers())) {
       Class<?> type = field.getType();
       if (sig.canAcceptArrayType(type) && field.getAnnotation(DataPoints.class) != null) {
         addArrayValues(field.getName(), list, getStaticFieldValue(field));
       } else if (sig.canAcceptType(type) && field.getAnnotation(DataPoint.class) != null) {
         list.add(PotentialAssignment.forValue(field.getName(), getStaticFieldValue(field)));
       }
     }
   }
 }
예제 #24
0
 /** {@inheritDoc} */
 @Override
 public Object invokeExplosively(final Object target, final Object... params) throws Throwable {
   if (!parameters_.isEmpty()) {
     final List<FrameworkField> annotatedFieldsByParameter =
         testClass_.getAnnotatedFields(Parameter.class);
     if (annotatedFieldsByParameter.size() != parameters_.size()) {
       throw new Exception(
           "Wrong number of parameters and @Parameter fields."
               + " @Parameter fields counted: "
               + annotatedFieldsByParameter.size()
               + ", available parameters: "
               + parameters_.size()
               + ".");
     }
     for (final FrameworkField each : annotatedFieldsByParameter) {
       final Field field = each.getField();
       final Parameter annotation = field.getAnnotation(Parameter.class);
       final int index = annotation.value();
       try {
         field.set(target, parameters_.get(index));
       } catch (final IllegalArgumentException iare) {
         throw new Exception(
             testClass_.getName()
                 + ": Trying to set "
                 + field.getName()
                 + " with the value "
                 + parameters_.get(index)
                 + " that is not the right type ("
                 + parameters_.get(index).getClass().getSimpleName()
                 + " instead of "
                 + field.getType().getSimpleName()
                 + ").",
             iare);
       }
     }
   }
   return super.invokeExplosively(target, params);
 }
  private static Set<Field> getTestFactoryFields(
      TestClass testClass, TestSessionFactory.Scope scope) {
    Set<Field> testFactoryFields = new HashSet<Field>();

    for (FrameworkField frameworkField : testClass.getAnnotatedFields(TestSessionFactory.class)) {
      Field field = frameworkField.getField();
      if (scope == field.getAnnotation(TestSessionFactory.class).scope()) {
        field.setAccessible(true);
        testFactoryFields.add(field);
      }
    }

    return testFactoryFields;
  }
예제 #26
0
 @Override
 protected Statement classBlock(final RunNotifier notifier) {
   TestClass testClass = getTestClass();
   Method checkMethod = getMethod(testClass.getJavaClass(), CheckBefore.class);
   Exception exception = execute(newInstance(testClass.getJavaClass()), checkMethod);
   Statement statement;
   if (exception == null) {
     statement = super.classBlock(notifier);
   } else {
     LOG.warn(
         "skip test "
             + testClass.getJavaClass().getSimpleName()
             + " cause check faild: "
             + exception.getMessage());
     return new Statement() {
       @Override
       public void evaluate() throws Throwable {
         Description description = Description.createSuiteDescription(getClass());
         notifier.fireTestIgnored(description);
       }
     };
   }
   return statement;
 }
예제 #27
0
  public TestClassAttributes(
      TestClass testClass, ClassResolver classResolver, DependencyCollector dependencyCollector) {
    beforeMethods = testClass.getAnnotatedMethods(Before.class);
    afterMethods = testClass.getAnnotatedMethods(After.class);
    stjsClass = classResolver.resolve(testClass.getName());

    htmlFixture = testClass.getJavaClass().getAnnotation(HTMLFixture.class);

    scripts =
        getScriptsPathes(
            testClass.getJavaClass(),
            Scripts.class,
            new Function1<Annotation, Collection<String>>() {
              @Override
              public Collection<String> $invoke(Annotation annotation) {
                return Arrays.asList(Scripts.class.cast(annotation).value());
              }
            });

    scriptsBefore =
        getScriptsPathes(
            testClass.getJavaClass(),
            ScriptsBefore.class,
            new Function1<Annotation, Collection<String>>() {
              @Override
              public Collection<String> $invoke(Annotation annotation) {
                return Arrays.asList(ScriptsBefore.class.cast(annotation).value());
              }
            });

    scriptsAfter =
        getScriptsPathes(
            testClass.getJavaClass(),
            ScriptsAfter.class,
            new Function1<Annotation, Collection<String>>() {
              @Override
              public Collection<String> $invoke(Annotation annotation) {
                return Arrays.asList(ScriptsAfter.class.cast(annotation).value());
              }
            });

    dependencies = dependencyCollector.orderAllDependencies(stjsClass);
  }
예제 #28
0
 /** Returns a name used to describe this Runner */
 protected String getName() {
   return fTestClass.getName();
 }
예제 #29
0
 /** @return list of {@link FrameworkField}s annotated with {@link Rule} */
 protected List<FrameworkField> classRuleFields() {
   return fTestClass.getAnnotatedFields(ClassRule.class);
 }
예제 #30
0
 /**
  * Returns a {@link Statement}: run all non-overridden {@code @AfterClass} methods on this class
  * and superclasses before executing {@code statement}; all AfterClass methods are always
  * executed: exceptions thrown by previous steps are combined, if necessary, with exceptions from
  * AfterClass methods into a {@link MultipleFailureException}.
  */
 protected Statement withAfterClasses(Statement statement) {
   List<FrameworkMethod> afters = fTestClass.getAnnotatedMethods(AfterClass.class);
   return afters.isEmpty() ? statement : new RunAfters(statement, afters, null);
 }