import org.junit.jupiter.api.extension.ConditionEvaluationResult; //导入依赖的package包/类
@Override
public ConditionEvaluationResult evaluateExecutionCondition(
        ExtensionContext context) {

    Optional<AnnotatedElement> element = context.getElement();
    ConditionEvaluationResult out = ConditionEvaluationResult
            .enabled("@DisabledOnOs is not present");

    Optional<DisabledOnOs> disabledOnOs = AnnotationUtils
            .findAnnotation(element, DisabledOnOs.class);

    if (disabledOnOs.isPresent()) {
        Os myOs = Os.determine();
        if (Arrays.asList(disabledOnOs.get().value()).contains(myOs)) {
            out = ConditionEvaluationResult
                    .disabled("Test is disabled on " + myOs);
        } else {
            out = ConditionEvaluationResult
                    .enabled("Test is not disabled on " + myOs);
        }
    }

    System.out.println("--> " + out.getReason().get());
    return out;
}
 

import org.junit.jupiter.api.extension.ConditionEvaluationResult; //导入依赖的package包/类
private ConditionEvaluationResult evaluate(
    LinkedList<String> displayName,
    ExtensionContext context) {
  Optional<ConditionEvaluationResult> result =
      context
          .getElement()
          .flatMap(element -> evaluateElement(displayName, element));

  if (result.isPresent()) {
    return result.get();
  }

  displayName.addFirst(context.getDisplayName());
  return context.getParent()
      .map(parent -> evaluate(displayName, parent))
      .orElse(ConditionEvaluationResult.enabled(null));
}
 

import org.junit.jupiter.api.extension.ConditionEvaluationResult; //导入依赖的package包/类
@Override
public ConditionEvaluationResult evaluateExecutionCondition(final ExtensionContext context) {
  return context.getElement()
                .flatMap(annotatedElement -> findAnnotation(annotatedElement, EnabledOnOperatingSystem.class))
                .map(EnabledOnOperatingSystem::value)
                .map(enabledOses -> Objects.requireNonNull(enabledOses, "OperatingSystem value must not be null"))
                .map(enabledOses -> Arrays.stream(enabledOses)
                                          .filter(OperatingSystem::isRunning)
                                          .collect(Collectors.collectingAndThen(Collectors.toList(), runningOses -> {
                      if (!runningOses.isEmpty()) {
                        return enabled("Enabled for OperatingSystem" + runningOses);
                      } else {
                        return disabled("Current supported OperatingSystem types=" + OperatingSystem.current() + " does not contain "
                                            + Arrays.toString(enabledOses));
                      }
                    }))
                ).orElse(DEFAULT);
}
 

import org.junit.jupiter.api.extension.ConditionEvaluationResult; //导入依赖的package包/类
@Override
public ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext context) {

    // Search for the @DisabledWeekdays annotation from the TestExtensionContext
    Optional<AnnotatedElement> contextElement = context.getElement();
    AnnotatedElement annotatedElement = contextElement.orElse(null);

    if (annotatedElement == null) return null;

    DisabledWeekdays weekdayAnnotation = annotatedElement.getAnnotation(DisabledWeekdays.class);

    // Determine whether the test should be disabled
    boolean weekdayToday = IntStream.of(weekdayAnnotation.value())
            .anyMatch(day -> day == Calendar.getInstance().get(Calendar.DAY_OF_WEEK));

    // Return a ConditionEvaluationResult based on the outcome of the boolean weekdayToday
    return weekdayToday ?
            ConditionEvaluationResult.disabled("I spare you today.") :
            ConditionEvaluationResult.enabled("Don't spare you on other days though >:(");
}
 

import org.junit.jupiter.api.extension.ConditionEvaluationResult; //导入依赖的package包/类
/**
 * Containers and tests are disabled if they are annotated with {@link DisabledOnCIServer} and they tests are run on
 * the CI server.
 */
@Override
public ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext context) {
    if (!isCIServer()) {
        return ENABLED;
    }

    Optional<AnnotatedElement> element = context.getElement();
    Optional<DisabledOnCIServer> disabled = AnnotationUtils.findAnnotation(element, DisabledOnCIServer.class);
    if (disabled.isPresent()) {
        String reason = disabled.map(DisabledOnCIServer::value)
                .filter(StringUtil::isNotBlank)
                .orElseGet(() -> element.get() + " is disabled on CI server");
        return ConditionEvaluationResult.disabled(reason);
    }

    return ENABLED;
}
 

import org.junit.jupiter.api.extension.ConditionEvaluationResult; //导入依赖的package包/类
ConditionEvaluationResult isTypeEnabled(GenerateVideo gv) {
    Type type = gv.value();
    if (type == ALL) return ENABLED_TYPE;
    if (!EncoderY4M.LOSSLESS && type == MAIN) return ENABLED_TYPE;
    if (EncoderY4M.LOSSLESS && type == LOSSLESS) return ENABLED_TYPE;
    return DISABLED_TYPE;
}
 

import org.junit.jupiter.api.extension.ConditionEvaluationResult; //导入依赖的package包/类
@Override
public ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext extensionContext) {
  AnnotatedElement element = extensionContext.getElement().orElseThrow(AssertionError::new);
  Disabled disabled = findAnnotation(element, Disabled.class).orElseThrow(AssertionError::new);
  String name = disabled.value();
  String reason = name + "=" + System.getProperty(name);
  boolean result = Boolean.getBoolean(name);
  if (disabled.not()) {
    result = !result;
  }
  if (result) {
    return ConditionEvaluationResult.disabled(reason);
  }
  return ConditionEvaluationResult.enabled(reason);
}
 

import org.junit.jupiter.api.extension.ConditionEvaluationResult; //导入依赖的package包/类
Optional<ConditionEvaluationResult> evaluateElement(
    List<String> currentDisplayName,
    AnnotatedElement element) {
  List<Disable> disabledTests = findRepeatableAnnotations(element, Disable.class);

  return disabledTests
      .stream()
      .filter(
          disabledTest -> Arrays.asList(disabledTest.value()).equals(currentDisplayName))
      .map(disabledTest -> ConditionEvaluationResult.disabled(disabledTest.reason()))
      .findFirst();
}
 

import org.junit.jupiter.api.extension.ConditionEvaluationResult; //导入依赖的package包/类
@Override
public ConditionEvaluationResult evaluateExecutionCondition(final ExtensionContext context) {
  return context.getElement()
                .flatMap(annotatedElement -> findAnnotation(annotatedElement, RunOnDay.class))
                .map(RunOnDay::value)
                .map(RunOnDayCondition::evaluateIfRunningOnDay)
                .orElse(DEFAULT);
}
 

import org.junit.jupiter.api.extension.ConditionEvaluationResult; //导入依赖的package包/类
private static ConditionEvaluationResult evaluateIfRunningOnDay(final DayOfWeek[] days) {
  // TODO: figure out how to inject a configurable clock instance
  final DayOfWeek currentDay = LocalDate.now().getDayOfWeek();
  final boolean runningInday = Stream.of(days).anyMatch(currentDay::equals);

  if (runningInday) {
    return enabled("Current day is " + currentDay + ", in the specified days of " + Arrays.toString(days));
  } else {
    return disabled("Current day is " + currentDay + ", not in the specified days of " + Arrays.toString(days));
  }
}
 

import org.junit.jupiter.api.extension.ConditionEvaluationResult; //导入依赖的package包/类
@Override
public ConditionEvaluationResult evaluateExecutionCondition(final ExtensionContext context) {
  return context.getElement()
         .flatMap(annotatedElement -> AnnotationSupport.findAnnotation(annotatedElement, DisabledOnJava8.class))
         .map(annotation -> evaluatedIfJava8())
         .orElse(DEFAULT);
}
 

import org.junit.jupiter.api.extension.ConditionEvaluationResult; //导入依赖的package包/类
private static ConditionEvaluationResult evaluatedIfJava8() {
  final String specificationVersion = System.getProperty("java.specification.version");
  if ("1.8".equals(specificationVersion)) {
    return DISABLED;
  } else {
    return ConditionEvaluationResult.enabled("Enabled on java.specification.version=" + specificationVersion);
  }
}
 

import org.junit.jupiter.api.extension.ConditionEvaluationResult; //导入依赖的package包/类
@Override
public ConditionEvaluationResult evaluateExecutionCondition(final ExtensionContext context) {
  return context.getElement()
                .flatMap(annotatedElement -> AnnotationSupport.findAnnotation(annotatedElement, DisabledOnJava9.class))
                .map(annotation -> evaluatedIfJava8())
                .orElse(DEFAULT);
}
 

import org.junit.jupiter.api.extension.ConditionEvaluationResult; //导入依赖的package包/类
private static ConditionEvaluationResult evaluatedIfJava8() {
  final String specificationVersion = System.getProperty("java.specification.version");
  if ("9".equals(specificationVersion)) {
    return DISABLED;
  } else {
    return ConditionEvaluationResult.enabled("Enabled on java.specification.version=" + specificationVersion);
  }
}
 

import org.junit.jupiter.api.extension.ConditionEvaluationResult; //导入依赖的package包/类
@Override
public ConditionEvaluationResult evaluateExecutionCondition(final ExtensionContext context) {
  return context.getElement()
                .flatMap(annotatedElement -> findAnnotation(annotatedElement, DisabledWhen.class))
                .map(DisabledWhen::value)
                .map(supplierClass -> ReflectionSupport.newInstance(supplierClass))
                .map(Supplier::get)
                .map(result -> Objects.requireNonNull(result, "Supplier result must not be null"))
                .map(shouldDisable -> shouldDisable
                    ? disabled(DisabledWhen.class + " evaluated to true")
                    : enabled(DisabledWhen.class + " evaluated to false"))
                .orElse(DEFAULT);
}
 

import org.junit.jupiter.api.extension.ConditionEvaluationResult; //导入依赖的package包/类
@Override
public ConditionEvaluationResult evaluateExecutionCondition(final ExtensionContext context) {
  return context.getElement()
                .flatMap(annotatedElement -> findAnnotation(annotatedElement, EnabledWhen.class))
                .map(EnabledWhen::value)
                .map(supplierClass -> ReflectionSupport.newInstance(supplierClass))
                .map(Supplier::get)
                .map(result -> Objects.requireNonNull(result, "Result must not be null"))
                .map(shouldEnable -> shouldEnable
                    ? enabled(EnabledWhen.class + " evaluated to false")
                    : disabled(EnabledWhen.class + " evaluated to true"))
                .orElse(DEFAULT);
}
 

import org.junit.jupiter.api.extension.ConditionEvaluationResult; //导入依赖的package包/类
private ConditionEvaluationResult evaluateIfAnnotated(Optional<AnnotatedElement> element) {
	Optional<DisabledOnOs> disabled = element.flatMap(el -> findAnnotation(el, DisabledOnOs.class));
	if (disabled.isPresent())
		return disabledIfOn(disabled.get().value());

	Optional<TestExceptOnOs> testExcept = element.flatMap(el -> findAnnotation(el, TestExceptOnOs.class));
	if (testExcept.isPresent())
		return disabledIfOn(testExcept.get().value());

	return ConditionEvaluationResult.enabled("");
}
 

import org.junit.jupiter.api.extension.ConditionEvaluationResult; //导入依赖的package包/类
private ConditionEvaluationResult disabledIfOn(OS[] disabledOnOs) {
	OS os = OS.determine();
	if (Arrays.asList(disabledOnOs).contains(os))
		return ConditionEvaluationResult.disabled("Test is disabled on " + os + ".");
	else
		return ConditionEvaluationResult.enabled("Test is not disabled in " + os + ".");
}
 

import org.junit.jupiter.api.extension.ConditionEvaluationResult; //导入依赖的package包/类
@Override
public ConditionEvaluationResult evaluate(TestExtensionContext context) {
	Class<? extends Exception>[] exceptionTypes = context.getTestClass()
			.flatMap(testClass -> findAnnotation(testClass, DisabledIfTestFailedWith.class))
			.orElseThrow(() -> new IllegalStateException("The extension should not be executed "
					+ "unless the test class is annotated with @DisabledIfTestFailedWith."))
			.value();

	return disableIfExceptionWasThrown(context, exceptionTypes);
}
 

import org.junit.jupiter.api.extension.ConditionEvaluationResult; //导入依赖的package包/类
private ConditionEvaluationResult disableIfExceptionWasThrown(
		ExtensionContext context,
		Class<? extends Exception>[] exceptions) {
	return Arrays.stream(exceptions)
			.filter(ex -> wasThrown(context, ex))
			.findAny()
			.map(thrown -> ConditionEvaluationResult.disabled(thrown.getSimpleName() + " was thrown."))
			.orElseGet(() -> ConditionEvaluationResult.enabled(""));
}