},
			},
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			original := test.original
			expected := test.expected
			scheme.Default(original)
			if !apiequality.Semantic.DeepEqual(original, expected) {
				t.Errorf("expected vs got:\n%s", cmp.Diff(test.expected, original))
			}
		})
	}

					},
					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)
    }

        transformers.add(new Transformer<T, T>() {
            @Override
            public T transform(T original) {
                transformer.setDelegate(original);
                transformer.setResolveStrategy(Closure.DELEGATE_FIRST);
                Object value = transformer.call(original);
                if (type.isInstance(value)) {
                    return type.cast(value);
                }

    final PropertiesTransformer transformer = new PropertiesTransformer()

    def 'returns original when no action specified'() {
        given:
        Map map = [test:'value']
        Properties original = props(map)
        Properties test = props(map)
        when:
        def result = transformer.transform(original)
        then:
        result == test
    }

    def 'action can access properties'() {

	}

	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()
    }