import org.gradle.api.internal.artifacts.ivyservice.NamespaceId
import org.gradle.api.internal.artifacts.ivyservice.modulecache.ModuleSourcesSerializer
import org.gradle.api.specs.Specs
import org.gradle.cache.internal.DefaultInMemoryCacheDecoratorFactory
import org.gradle.cache.scopes.GlobalScopedCacheBuilderFactory
import org.gradle.internal.action.ConfigurableRule

        final Bean bean3 = new Bean("b3");

        when:
        Spec<Bean> spec = { it != bean } as Spec<Bean>
        Spec<Bean> spec2 = {it != bean2 } as Spec<Bean>

        container.add(bean);
        container.add(bean2);
        container.add(bean3);

        then:
        container.matching(spec).matching(spec2) as List == [bean3]
    }

    def canGetDomainObjectByName() {
        when:

 */
package org.gradle.api.specs;

/**
 * A {@link org.gradle.api.specs.Spec} implementation which negates another {@code Spec}.
 * 
 * @param <T> The target type for this Spec
 */
public class NotSpec<T> implements Spec<T> {
    private Spec<? super T> sourceSpec;

    public NotSpec(Spec<? super T> sourceSpec) {
        this.sourceSpec = sourceSpec;
    }

    Spec<? super T> getSourceSpec() {

import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import org.gradle.api.NonNullApi;
import org.gradle.api.Task;
import org.gradle.api.specs.Spec;
import org.gradle.api.specs.Specs;
import org.gradle.internal.resources.ResourceLockCoordinationService;

import java.util.AbstractCollection;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;

        return delegate;
    }

    @Override
    public DomainObjectSet<T> matching(Closure spec) {
        return matching(Specs.convertClosureToSpec(spec));
    }

    @Override
    public DomainObjectSet<T> matching(Spec<? super T> spec) {
        return delegate.matching(spec);
    }

    @Override
    public <S extends T> DomainObjectSet<S> withType(Class<S> type) {

import org.gradle.api.internal.artifacts.ivyservice.resolveengine.artifact.ArtifactVisitor
import org.gradle.api.internal.tasks.TaskDependencyResolveContext
import org.gradle.api.specs.Specs
import org.gradle.internal.component.external.model.DefaultModuleComponentIdentifier
import spock.lang.Specification

class ShortCircuitEmptyConfigurationResolverSpec extends Specification {

 * limitations under the License.
 */

package org.gradle.api.internal.specs;

import org.gradle.api.specs.Spec;

/**
 * A predicate against objects of type T that can explain the unsatisfied reason.
 *
 * @param <T> The target type for this Spec
 */
public interface ExplainingSpec<T> extends Spec<T> {

    /**
     * Explains why the spec is not satisfied.
     *
     * @param element candidate

	switch {
	case b&128 != 0:
		// Indexed representation.
		// High bit set?
		// https://httpwg.org/specs/rfc7541.html#rfc.section.6.1
		return d.parseFieldIndexed()
	case b&192 == 64:
		// 6.2.1 Literal Header Field with Incremental Indexing
		// 0b10xxxxxx: top two bits are 10
		// https://httpwg.org/specs/rfc7541.html#rfc.section.6.2.1
		return d.parseFieldLiteral(6, indexedTrue)
	case b&240 == 0:

    }
  } finally {
    client.dispatcher.executorService.shutdownNow()
    client.connectionPool.evictAll()
  }
}

private fun buildClient(vararg specs: ConnectionSpec): OkHttpClient {
  return OkHttpClient.Builder()
    .connectionSpecs(listOf(*specs))
    .build()
}

private fun sendRequest(
  client: OkHttpClient,
  url: String,
) {
  System.out.printf("%-40s ", url)
  System.out.flush()

//   appended. This expresses the fact that user-provided specs take precedence.
// * Preset unspecified
//   - No-op.
QuantizationConfig ExpandPresets(const QuantizationConfig& config);

// Returns whether a given QuantizationSpecs has the given quantization method.
bool HasQuantizationMethod(const QuantizationSpecs& specs,
                           Method::MethodCase method_case);