/**
 * 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() {
        return sourceSpec;
    }

    @Override

        }
        if (spec == SATISFIES_NONE) {
            return satisfyAll();
        }
        if (spec instanceof NotSpec) {
            NotSpec<? super T> notSpec = Cast.uncheckedNonnullCast(spec);
            return Cast.uncheckedNonnullCast(notSpec.getSourceSpec());
        }
        return new NotSpec<>(spec);
    }

import static org.hamcrest.MatcherAssert.assertThat;

public class NotSpecTest {
    @Test
    public void testIsSatisfiedBy() {
        assertThat(new org.gradle.api.specs.NotSpec(createFilterSpec()).isSatisfiedBy(true), equalTo(false));
        assertThat(new org.gradle.api.specs.NotSpec(createFilterSpec()).isSatisfiedBy(false), equalTo(true));
    }

    private Spec<Boolean> createFilterSpec() {
        return new Spec<Boolean>() {

 * limitations under the License.
 */

package org.gradle.api.tasks.util.internal

import org.gradle.api.file.FileTreeElement
import org.gradle.api.specs.AndSpec
import org.gradle.api.specs.NotSpec
import org.gradle.api.specs.Spec
import org.gradle.api.tasks.util.PatternSet
import spock.lang.Specification

class CachingPatternSpecFactoryTest extends Specification {

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

package org.gradle.internal.classpath;

import org.gradle.api.specs.NotSpec;
import org.gradle.api.specs.Spec;
import org.gradle.internal.Cast;
import org.gradle.internal.UncheckedException;
import org.gradle.util.internal.CollectionUtils;

import java.io.File;
import java.io.Serializable;

    }

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

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

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

        expect:
        Specs.negate(Specs.negate(spec)) == spec
    }

			}
			gotSpec, err := tr.TranslateFromValueToSpec([]byte(tt.valueYAML), false)
			if gotErr, wantErr := errToString(err), tt.wantErr; gotErr != wantErr {
				t.Errorf("ValuesToProto(%s)(%v): gotErr:%s, wantErr:%s", tt.desc, tt.valueYAML, gotErr, wantErr)
			}
			if tt.wantErr == "" {
				byteArray, err := protomarshal.Marshal(gotSpec)
				if err != nil {

			iop:  "testdata/quantity.yaml",
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			m := loadResource(t, tt.iop)
			gotSpec := m.Spec.DeepCopy()
			if diff := cmp.Diff(m.Spec, gotSpec, protocmp.Transform()); diff != "" {
				t.Error(diff)
			}
		})
	}
}

func loadResource(t *testing.T, filepath string) *install.IstioOperator {
	t.Helper()

		},
	}

	for _, test := range tests {
		t.Run(test.desc, func(t *testing.T) {
			gotSpec := roundTrip(t, runtime.Object(&storagev1.CSIDriver{})).(*storagev1.CSIDriver).Spec
			got := reflect.Indirect(reflect.ValueOf(gotSpec)).FieldByName(test.field).Interface()
			want := reflect.Indirect(reflect.ValueOf(test.wantSpec)).FieldByName(test.field).Interface()

		},
	}

	for _, test := range tests {
		t.Run(test.desc, func(t *testing.T) {
			gotSpec := roundTrip(t, runtime.Object(&storagev1beta1.CSIDriver{})).(*storagev1beta1.CSIDriver).Spec
			got := reflect.Indirect(reflect.ValueOf(gotSpec)).FieldByName(test.field).Interface()
			want := reflect.Indirect(reflect.ValueOf(test.wantSpec)).FieldByName(test.field).Interface()