expect:
        Specs.negate(Specs.satisfyAll()) == Specs.satisfyNone()
    }

    def "negation of none is all"() {
        expect:
        Specs.negate(Specs.satisfyNone()) == Specs.satisfyAll()
    }

    def "negation of spec is !spec"() {
        def spec = Stub(Spec)

        expect:
        def negation = Specs.negate(spec)
        negation instanceof NotSpec

    public final method getSecondValue(): int
    public final inner class Operation$Add
}

public final class Operation$Negate {
    // source: 'classKinds.kt'
    private final field value: int
    public method <init>(p0: int): void
    public final method getValue(): int
    public final inner class Operation$Negate
}

public final class Operation$Subtract {
    // source: 'classKinds.kt'
    private final field minuend: int

    when {
        includes.isEmpty() && excludes.isEmpty() -> PatternMatcher.MATCH_ALL
        includes.isEmpty() -> patternSpecFor(excludes).negate()
        excludes.isEmpty() -> patternSpecFor(includes)
        else -> patternSpecFor(includes).and(patternSpecFor(excludes).negate())
    }


private
fun patternSpecFor(patterns: List<String>) =

    NORTH, SOUTH, WEST, EAST
}

sealed class Operation {
    class Add(val firstValue: Int, val secondValue: Int) : Operation()
    class Subtract(val minuend: Int, val subtrahend: Int) : Operation()
    class Negate(val value: Int) : Operation()

		twoArgsF func(v, x, y *Element) *Element
	}
	for _, tt := range []target{
		{name: "Absolute", oneArgF: (*Element).Absolute},
		{name: "Invert", oneArgF: (*Element).Invert},
		{name: "Negate", oneArgF: (*Element).Negate},
		{name: "Set", oneArgF: (*Element).Set},
		{name: "Square", oneArgF: (*Element).Square},
		{name: "Pow22523", oneArgF: (*Element).Pow22523},
		{
			name: "Mult32",

// CHECK:           [[LHSIM:%.*]] = mhlo.imag [[LHS]]
// CHECK:           [[LHSIMNEG:%.*]] = mhlo.negate [[LHSIM]]
// CHECK:           [[LHSCONJ:%.*]] = mhlo.complex [[LHSRE]], [[LHSIMNEG]]
// CHECK:           [[RHSRE:%.*]] = mhlo.real [[RHS]]
// CHECK:           [[RHSIM:%.*]] = mhlo.imag [[RHS]]
// CHECK:           [[RHSIMNEG:%.*]] = mhlo.negate [[RHSIM]]
// CHECK:           [[RHSCONJ:%.*]] = mhlo.complex [[RHSRE]], [[RHSIMNEG]]

			return false
		}

		// Ensure the arguments were not modified.
		return x == x1 && y == y1
	}

	for name, f := range map[string]interface{}{
		"Negate": func(v, x Scalar) bool {
			return checkAliasingOneArg((*Scalar).Negate, v, x)
		},
		"Multiply": func(v, x, y Scalar) bool {
			return checkAliasingTwoArgs((*Scalar).Multiply, v, x, y)
		},
		"Add": func(v, x, y Scalar) bool {

        return new And(PatternMatcher.this, other);
    }

    public PatternMatcher or(final PatternMatcher other) {
        return new Or(PatternMatcher.this, other);
    }

    public PatternMatcher negate() {
        return new PatternMatcher() {
            @Override
            public boolean test(String[] segments, boolean isFile) {
                return !PatternMatcher.this.test(segments, isFile);
            }

    private final Spec<SpecRuleAction<? super ComponentSelection>> withNoInputs = element -> element.getAction().getInputTypes().isEmpty();
    private final Spec<SpecRuleAction<? super ComponentSelection>> withInputs = Specs.negate(withNoInputs);

    void apply(ComponentSelectionInternal selection, Collection<SpecRuleAction<? super ComponentSelection>> specRuleActions, MetadataProvider metadataProvider) {

        }

        return new OrSpec<>(filtered);
    }

    /**
     * Returns a spec that selects everything that is not selected by the given spec.
     */
    public static <T> Spec<T> negate(Spec<? super T> spec) {
        if (spec == SATISFIES_ALL) {
            return satisfyNone();
        }
        if (spec == SATISFIES_NONE) {
            return satisfyAll();
        }