Java ConditionEvaluationResult.enabled方法代码示例

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包/类
@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包/类
@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包/类
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包/类
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包/类
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包/类
private ConditionEvaluationResult evaluateIfAnnotated(Optional<AnnotatedElement> element) {
	// @formatter:off
	Optional<ConditionEvaluationResult> disabledResult = element
			.flatMap(el -> findAnnotation(el, DisabledOnOs.class))
			.map(DisabledOnOs::value)
			.map(this::disabledIfOn);
	// @formatter:on
	if (disabledResult.isPresent()) {
		return disabledResult.get();
	}

	// @formatter:off
	Optional<ConditionEvaluationResult> enabledResult = element
			.flatMap(el -> findAnnotation(el, EnabledOnOs.class))
			.map(EnabledOnOs::value)
			// invert the selection to disable the test
			// if it NOT one of those given to the annotation
			.map(OS::except)
			.map(this::disabledIfOn);
	// @formatter:on
	if (enabledResult.isPresent()) {
		return enabledResult.get();
	}

	// if both annotations are missing, the container/test is enabled
	return ConditionEvaluationResult.enabled(NO_CONDITION_PRESENT);
}
 

import org.junit.jupiter.api.extension.ConditionEvaluationResult; //导入方法依赖的package包/类
private ConditionEvaluationResult disabledIfOn(OS[] disabledOnOs) {
	OS os = osDetector.get();
	if (Arrays.asList(disabledOnOs).contains(os)) {
		return ConditionEvaluationResult.disabled(format(TEST_DISABLED, os));
	}
	else {
		return ConditionEvaluationResult.enabled(format(TEST_ENABLED, os));
	}
}
 

import org.junit.jupiter.api.extension.ConditionEvaluationResult; //导入方法依赖的package包/类
@Override
public ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext context) {
    boolean monday = Calendar.getInstance().get(Calendar.DAY_OF_WEEK) == Calendar.MONDAY;

    return monday ?
            ConditionEvaluationResult.disabled("I spare you on Mondays.") :
            ConditionEvaluationResult.enabled("Don't spare you on other days though >:(");
}