},
					},
					PolicyTypes: []networkingv1.PolicyType{networkingv1.PolicyTypeEgress},
				},
			},
		},
	}

	for i, test := range tests {
		original := test.original
		expected := test.expected
		obj2 := roundTrip(t, runtime.Object(original))
		got, ok := obj2.(*networkingv1.NetworkPolicy)
		if !ok {
			t.Errorf("(%d) unexpected object: %v", i, got)
			t.FailNow()
		}

					},
					RevisionHistoryLimit: utilpointer.Int32(10),
				},
			},
		},
	}

	for i, test := range tests {
		original := test.original
		expected := test.expected
		obj2 := roundTrip(t, runtime.Object(original))
		got, ok := obj2.(*extensionsv1beta1.DaemonSet)
		if !ok {
			t.Errorf("(%d) unexpected object: %v", i, got)
			t.FailNow()
		}

        assert current.build_time == original.build_time
        assert current.version == original.version
        assert current.options == original.options
        assert current.inputs == original.inputs
    }

    void assertFileHasResetTimestamp(SwiftDepsHandler.SwiftDeps current, File... inputs) {
        assert !original.inputs.isEmpty()
        def changedInputs = inputs*.absolutePath

        runBuildViaTAPI()
        def original = getDaemonUID()
        when:
        runBuildViaTAPI()
        then:
        assertSameDaemon(original)
    }

    def "tooling API client reuses existing daemon started by CLI"() {
        runBuildViaCLI()
        def original = getDaemonUID()
        when:
        runBuildViaTAPI()
        then:
        assertSameDaemon(original)
    }

	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			original := test.original
			expected := test.expected

			scheme.Default(original)
			if !reflect.DeepEqual(expected, original) {
				t.Errorf("Expected defaulting to work - diff: %s", cmp.Diff(expected, original))
			}
		})
	}

    private ClassLoader original
    private final ContextClassLoaderDispatch dispatch = new ContextClassLoaderDispatch(target, appClassLoader)

    def setup() {
        original = Thread.currentThread().contextClassLoader
    }

    public void cleanup() {
        Thread.currentThread().contextClassLoader = original
    }

    def 'sets ContextClassLoader during dispatch'() {

 */
class MethodHandleInvocation implements Invocation {
    private final MethodHandle original;
    private final Object[] originalArgs;
    private final Object[] unspreadArgs;
    private final int unspreadArgsOffset;

    public MethodHandleInvocation(MethodHandle original, Object[] originalArgs, boolean isSpread) {
        this.original = original;
        this.originalArgs = originalArgs;
        if (isSpread) {

    }

    def "original jars are returned in the list of original jars"() {
        given:
        TransformedClassPath cp = transformedClassPath("original.jar": "transformed.jar")

        expect:
        cp.asFiles == [file("original.jar")]
        cp.asURIs == [file("original.jar").toURI()]
        cp.asURLs == [file("original.jar").toURI().toURL()]
        cp.asURLArray == [file("original.jar").toURI().toURL()].toArray()
    }

            );
        }
        return Optional.of(left(original));
    }

    private File transformFile(File original, FileSystemLocationSnapshot snapshot, ClasspathFileTransformer transformer, InstrumentationTypeRegistry typeRegistry) {
        final File result = transformer.transform(original, snapshot, cache.getBaseDir(), typeRegistry);
        markAccessed(result, original);
        return result;
    }

	t.Logf("seed = %v", seed)
	f.RandSource(rand.New(rand.NewSource(seed)))

	for i := 0; i < 1000; i++ {
		original := &authenticationv1.TokenReview{}
		f.Fuzz(&original.Spec)
		f.Fuzz(&original.Status)
		converted := &authenticationv1beta1.TokenReview{
			Spec:   v1SpecToV1beta1Spec(&original.Spec),
			Status: v1StatusToV1beta1Status(original.Status),
		}
		roundtripped := &authenticationv1.TokenReview{