/**
     * 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)) {

        @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));
        }

	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).

// Returns true if the provided padding in the composite op can *not* be 
// satisfied by SAME or VALID tensorflow padding.
def HasCustomPadding:
  Constraint<CPred<"GetAvgPoolOpPadAttr($_builder, (*$0.begin()).getDefiningOp<mhlo::CompositeOp>()) == $_builder.getStringAttr(\"CUSTOM\")">>;

// Returns true if the provided padding in the composite op can be satisfied 
// by SAME or VALID tensorflow padding.

                    "the plugin is already on the classpath with an unknown version, so compatibility cannot be checked."
            );
        } else if (!existingVersion.equals(version)) {
            throw new InvalidPluginRequestException(
                pluginRequest,
                "The request for this plugin could not be satisfied because " +

    def "registers javaToolchains extension"() {
        expect:
        project.extensions.getByType(JavaToolchainService) == project.extensions.getByName("javaToolchains")
    }

    def "toolchain service dependencies are satisfied"() {
        expect:
        project.extensions.getByType(JavaToolchainService).launcherFor(Actions.doNothing()).get().executablePath.asFile.isFile()
    }