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

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

func fn(setText []rune, negate bool) int {
	ranges := []singleRange{}

	if len(setText) > 0 {
		fillFirst := false
		l := len(setText)
		if negate {
			if setText[0] == 0 {
				setText = setText[1:]
			} else {
				l++
				fillFirst = true
			}
		}

		if l%2 == 0 {

    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>) =

			return false
		}
	}
	return true
}

// nssCriterion is the parsed structure of one of the criteria in brackets
// after an NSS source name.
type nssCriterion struct {
	negate bool   // if "!" was present
	status string // e.g. "success", "unavail" (lowercase)
	action string // e.g. "return", "continue" (lowercase)
}

// standardStatusAction reports whether c is equivalent to not

			want: &nssConf{
				sources: map[string][]nssSource{
					"foo": {
						{source: "a"},
						{
							source: "b",
							criteria: []nssCriterion{
								{
									negate: true,
									status: "a",
									action: "b",
								},
								{
									status: "x",
									action: "y",
								},
							},
						},
						{source: "c"},
					},
				},

    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 {