/**
     * Returns true if the precondition is satisfied.
     * @throws Exception if the precondition cannot be checked
     */
    boolean isSatisfied() throws Exception;

    /**
     * Utility method to check if a precondition class is satisfied.
     *
     * @param preconditionClass the class of the precondition to be checked
     * @return true if the precondition is satisfied

            "java.sourceCompatibility = 1.8"
        } else if (versionNumber < VersionNumber.parse('6.4.0') && TestPrecondition.satisfied(UnitTestPreconditions.Jdk10OrLater)) {
            "java.sourceCompatibility = 9"
        } else if (versionNumber < VersionNumber.parse('6.6.0') && TestPrecondition.satisfied(UnitTestPreconditions.Jdk11OrLater)) {

import static org.gradle.test.precondition.TestPrecondition.satisfied;
import static org.gradle.test.precondition.TestPrecondition.notSatisfied;

@CompileStatic
class UnitTestPreconditions {

    static final class Symlinks implements TestPrecondition {
        @Override
        boolean isSatisfied() {
            return satisfied(MacOs) || satisfied(Linux)
        }
    }

        @Override
        boolean isSatisfied() throws Exception {
            return satisfied(UnitTestPreconditions.UnixDerivative) && locate("bash") != null
        }
    }

    static class DashAvailable implements TestPrecondition {
        @Override
        boolean isSatisfied() throws Exception {
            return satisfied(UnitTestPreconditions.UnixDerivative) && locate("dash") != null
        }
    }

# Gradle / precondition Tester

This project collections information about where test preconditions can be satisfied.
We can use this information (i.e. by looking at the test results in Develocity) to see if we have any preconditions or combinations of preconditions, which are never satisfied – a situation which we otherwise would hardly notice.

 * <p>
 * Each combination can have three outcomes:
 * <ul>
 *     <li><b>Successful:</b> the precondition combination could be satisfied.</li>
 *     <li>
 *         <b>Skipped:</b> the precondition combination could <i>not</i> be satisfied.
 *         This is normal, and simply signifies that the precondition is not satisfied on the current system
 *     </li>
 *     <li>
 *         <b>Failed:</b> there was an error while checking the combination.

            boolean satisfied = javaMethod.getRawReturnType().isAssignableTo(expectedReturnType);
            String message = createMessage(javaMethod, (satisfied ? "has " : "does not have ") + "raw return type assignable to " + expectedReturnType.getName());
            events.add(new SimpleConditionEvent(javaMethod, satisfied, message));
        }

        "cacheIf('cache-if reason') { false }"            | CACHE_IF_SPEC_NOT_SATISFIED    | "'cache-if reason' not satisfied"
        "doNotCacheIf('do-not-cache-if reason') { true }" | DO_NOT_CACHE_IF_SPEC_SATISFIED | "'do-not-cache-if reason' satisfied"
    }

    def "cacheability for a #taskType task can be enabled via #condition"() {

	if err == nil {
		return nil
	}
	return &SyscallError{syscall, err}
}

// IsExist returns a boolean indicating whether the error is known to report
// that a file or directory already exists. It is satisfied by [ErrExist] as
// well as some syscall errors.
//
// This function predates [errors.Is]. It only supports errors returned by
// the os package. New code should use errors.Is(err, fs.ErrExist).

  static class FlagGuard extends Monitor.Guard {

    private boolean satisfied;

    protected FlagGuard(Monitor monitor) {
      super(monitor);
    }

    @Override
    public boolean isSatisfied() {
      return satisfied;
    }

    public void setSatisfied(boolean satisfied) {
      this.satisfied = satisfied;
    }
  }

  private final Method method;