public org.gradle.api.specs.CompositeSpec createCompositeSpec(Spec... specs) {
        return new OrSpec(specs);
    }

    public org.gradle.api.specs.CompositeSpec<Object> createOtherCompositeSpec(Spec<Object>... specs) {
        return new AndSpec<Object>(specs);
    }

    @Test
    public void isSatisfiedWhenNoSpecs() {
        assertTrue(new OrSpec().isSatisfiedBy(new Object()));
    }

    @Test

	"Subtitle": "Version of Oct 15, 2021",
	"Path": "/ref/spec"
}-->

<h2 id="Introduction">Introduction</h2>

<p>
This is the reference manual for the Go programming language as it was for
language version 1.17, in October 2021, before the introduction of generics.
It is provided for historical interest.
The current reference manual can be found <a href="/doc/go_spec.html">here</a>.

			inSpec:          fakeTracingSpecNoProvider(99.999, false, true),
			opts:            fakeOptsOnlyZipkinTelemetryAPI(),
			want:            fakeTracingConfigNoProvider(99.999, 0, append(defaultTracingTags(), fakeEnvTag)),
			wantReqIDExtCtx: &defaultUUIDExtensionCtx,
		},
		{
			name:   "only telemetry api (no provider) with nil custom tag",

			objType: parser.Type("io.k8s.api.apps.v1.Deployment"),
			managedFields: []metav1.ManagedFieldsEntry{
				applyFieldsEntry("mgr1", `{ "f:spec": { "f:replicas": {}}}`, ""),
				applyFieldsEntry("mgr2", `{ "f:spec": { "f:paused": {}}}`, ""),
			},
			fieldManager: "mgr2",
			expectedOut:  map[string]interface{}{"spec": map[string]interface{}{"paused": true}},

class PluginsCollectingPluginsBlock() : PluginDependenciesSpec {
    val specs: List<MutablePluginDependencySpec>
        get() = _specs

    private
    val _specs = mutableListOf<MutablePluginDependencySpec>()

    @Adding
    override fun id(id: String): MutablePluginDependencySpec = MutablePluginDependencySpec(id).also(_specs::add)

    @Adding
    fun kotlin(id: String) = id("org.jetbrains.kotlin.$id")
}

> argument-like modifiers. In contrast, the generator model `ArgSpec` contains a
> resolved `ArgType` which provides a boolean `is_list()` method directly, and
> the model `OpSpec` provides a list of only the argument-like attributes. In
> addition to convenience, this should aid consistency between generated code in
> each target language._

// or if another error occurred. If the Open API V3 spec for a CRD is not
// found, then the spec for Namespace is checked for query param support instead.
func (v *queryParamVerifierV3) HasSupport(gvk schema.GroupVersionKind) error {
	if (gvk == schema.GroupVersionKind{Version: "v1", Kind: "List"}) {
		return NewParamUnsupportedError(gvk, v.queryParam)
	}
	gvSpec, err := v.root.GVSpec(gvk.GroupVersion())
	if err == nil {

        return classLoaderFactory.createChildClassLoader(spec.name, spec.parent, spec.classPath, spec.implementationHash);
    }

    @VisibleForTesting
    public int size() {
        synchronized (lock) {
            return bySpec.size();
        }
    }

    @Override
    public void stop() {
        synchronized (lock) {

        this.classLoaderFactory = classLoaderFactory;
    }

    @Override
    public ClassLoader getClassLoaderFor(ClassLoaderSpec spec, List<? extends ClassLoader> parents) {
        if (spec instanceof VisitableURLClassLoader.Spec) {
            VisitableURLClassLoader.Spec clSpec = (VisitableURLClassLoader.Spec) spec;
            if (parents.size() != 1) {
                throw new IllegalStateException("Expected exactly one parent ClassLoader");

            roots.add(toSpec(sourceTree))
        }
    }

    private
    fun fromSpec(spec: FileTreeSpec): FileTreeInternal = when (spec) {
        is AdaptedFileTreeSpec -> fileCollectionFactory.treeOf(spec.tree)
        is FilteredFileTreeSpec -> spec.tree.matching(spec.patterns)
        is FilteredMinimalFileTreeSpec -> fromSpec(spec.tree).matching(spec.patterns)