ASSERT_THAT(new_config.specs().specs(), SizeIs(1));

  const QuantizationSpec& spec = new_config.specs().specs(0);
  EXPECT_THAT(spec.matcher().function_name().regex(),
              StrEq("^.*(conv|dot_general).*"));
  EXPECT_TRUE(spec.method().has_weight_only_ptq());

  const WeightOnlyPtq& weight_only_ptq_spec = spec.method().weight_only_ptq();

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.integtests.fixtures

import org.gradle.api.specs.Spec
import org.gradle.api.specs.Specs
import org.gradle.integtests.fixtures.executer.GradleExecuter
import org.gradle.internal.operations.BuildOperationType
import org.gradle.internal.operations.trace.BuildOperationRecord

import org.gradle.api.internal.artifacts.ivyservice.resolveengine.excludes.specs.ExcludeEverything;
import org.gradle.api.internal.artifacts.ivyservice.resolveengine.excludes.specs.ExcludeNothing;
import org.gradle.api.internal.artifacts.ivyservice.resolveengine.excludes.specs.ExcludeSpec;
import org.gradle.api.internal.artifacts.ivyservice.resolveengine.excludes.specs.GroupExclude;

    }

    ExcludeSpec anyOf(ExcludeSpec... specs) {
        switch (specs.length) {
            case 0:
                return factory.nothing()
            case 1:
                return specs[0]
            case 2:
                return factory.anyOf(specs[0], specs[1])
            default:
                return factory.anyOf(RandomizedIteratorHashSet.of(specs as Set<ExcludeSpec>))
        }
    }

    public ExcludeSpec anyOf(Set<ExcludeSpec> specs) {
        return log("anyOf", () -> super.anyOf(specs), specs);
    }

    @Override
    public ExcludeSpec allOf(Set<ExcludeSpec> specs) {
        return log("allOf", () -> super.allOf(specs), specs);
    }

    private ExcludeSpec log(String operationName, Factory<ExcludeSpec> factory, Object... operands) {
        ExcludeSpec spec;
        try {

    }

    @Override
    public ExcludeSpec anyOf(Set<ExcludeSpec> specs) {
        return caches.getAnyOf(new ExcludesKey(specs), key -> delegate.anyOf(key.specs));
    }

    @Override
    public ExcludeSpec allOf(Set<ExcludeSpec> specs) {
        return caches.getAllOf(new ExcludesKey(specs), key -> delegate.allOf(key.specs));
    }

    /**
     * A special key which recognizes the fact union and intersection

    @Override
    void debugTree(
        Spec<? super BuildOperationRecord> predicate = Specs.SATISFIES_ALL,
        Spec<? super BuildOperationRecord> progressPredicate = Specs.SATISFIES_ALL
    ) {
        operations.roots.each { debugOpTree(it, 0, predicate, progressPredicate) }
    }

    private void debugOpTree(
        BuildOperationRecord op,
        int level,
        Spec<? super BuildOperationRecord> predicate,

 * </pre>
 *
 * <p>You may also use a closure or {@link Spec} to specify which files to include or exclude. The closure or {@link Spec}
 * is passed a {@link org.gradle.api.file.FileTreeElement}, and must return a boolean value.</p>
 *
 * <p>If no include patterns or specs are specified, then all files in this container will be included. If any include

        return Optimizations.optimizeAllOf(this, one, two, super::allOf);
    }

    @Override
    public ExcludeSpec anyOf(Set<ExcludeSpec> specs) {
        return Optimizations.optimizeCollection(this, specs, list -> {
            if (list.size() == 2) {
                Iterator<ExcludeSpec> it = list.iterator();
                return delegate.anyOf(it.next(), it.next());
            }

 */
package org.gradle.api.specs;

import org.gradle.util.TestUtil;
import org.junit.Test;

import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;

public class AndSpecTest extends AbstractCompositeSpecTest {
    public org.gradle.api.specs.CompositeSpec<Object> createCompositeSpec(Spec<Object>... specs) {
        return new AndSpec<Object>(specs);
    }