when:
        fails "help"

        then:
        failureDescriptionStartsWith("Error resolving plugin [id: 'my-plugin', version: '1.0.1']")
        failureHasCause("The request for this plugin could not be satisfied because the plugin is already on the classpath with a different version (1.0).")

        and:
        operations.hasOperation("Apply plugin my-plugin to root project 'root'")

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

import spock.lang.Specification

class SpecsTest extends Specification {

    static class A {}
    static class B extends A {}
    static class C extends B {}

    def "isInstance spec is satisfied for all instances extending from the specified type"() {
        when:
        Spec<Object> spec = Specs.isInstance(B)

        then:
        !spec.isSatisfiedBy(new Object())
        !spec.isSatisfiedBy(new A())

				condt, reflect.TypeOf(condt).String())
		}
	}
	return parsedPolicy, nil
}

// checkPolicyCond returns a boolean to indicate if a condition is satisfied according
// to the passed operator
func checkPolicyCond(op string, input1, input2 string) bool {
	switch op {
	case policyCondEqual:
		return input1 == input2
	case policyCondStartsWith:

            "  Not made cacheable, yet"
        output.contains "Caching disabled for task ':compileHelloSharedLibraryHelloCpp' because:\n" +
            "  'Pre-compiled headers are used' satisfied"
    }

                    "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()
    }

			// We can't rely on a prefix match since /apis matches everything (see the big comment on Director above)
			if path == "/apis" || path == "/apis/" {
				klog.V(5).Infof("%v: %v %q satisfied by gorestful with webservice %v", d.name, req.Method, path, ws.RootPath())
				// don't use servemux here because gorestful servemuxes get messed up when removing webservices

            this.preconditions = preconditions
        }

        @Override
        void evaluate() {
            Assume.assumeTrue("Not all Requirements ${preconditions*.simpleName} are satisfied", false)
        }
    }

     *
     * @param action The action to delegate filtered items to
     * @param filter The spec to use to filter items by
     * @param <T> The type of item the action expects
     * @return A new action that only forwards arguments on to the given filter is they are satisfied by the given spec.
     */