when:
        executeWithException(original)
        then:
        def ex = thrown type
        ex === original

        where:
        original << [
            new RuntimeException("lajos"),
            new Error("lajos"),
            new UncheckedIOException(new IOException("lajos"))
        ]
        type = original.class
    }

        return new CastingTransformer<O, I>(outputType);
    }

    //just returns the original object
    public static <T> Transformer<T, T> noOpTransformer() {
        return new Transformer<T, T>() {
            @Override
            public T transform(T original) {
                return original;
            }
        };
    }

    @Override
    public Version transform(String original) {
        return cache.computeIfAbsent(original, this::parse);
    }

    private Version parse(String original) {
        List<String> parts = new ArrayList<>();
        boolean digit = false;
        int startPart = 0;
        int pos = 0;
        int endBase = 0;
        int endBaseStr = 0;
        for (; pos < original.length(); pos++) {

    final T original

    ThreadLocalInterceptorSet(T original) {
        this.original = original
    }

    boolean isEmpty() {
        substitutions.get() == 0
    }

    void substituteForCurrentThread(T substitution) {
        if (threadLocalDecorators.get() != original) {

        return new CastingTransformer<O, I>(outputType);
    }

    //just returns the original object
    public static <T> InternalTransformer<T, T> noOpTransformer() {
        return new InternalTransformer<T, T>() {
            @Override
            public T transform(T original) {
                return original;
            }
        };
    }

    /**
     * Overrides original type that will be used for generated code.
     * By default, the original type is determined from the lazy property type, e.g.:
     * Property[T] -> original type becomes T (also Property[Integer] -> Integer and not int)
     * RegularFileProperty -> original type becomes File
     * DirectoryProperty -> original type becomes File
     * MapProperty[K, V] -> original type becomes Map[K, V]

        createFile(new File(cachesDir, "transforms-1/second/transformed/original/file"))
        createFile(new File(cachesDir, "transforms-2/first/transformed/instrumented/file"))
        createFile(new File(cachesDir, "transforms-2/first/transformed/original/file"))
        createFile(new File(cachesDir, "transforms-2/second/metadata.bin"))

public class DerivedIvyArtifact extends AbstractIvyArtifact {
    private final IvyArtifact original;
    private final PublicationInternal.DerivedArtifact derived;

    public DerivedIvyArtifact(IvyArtifact original, PublicationInternal.DerivedArtifact derived, TaskDependencyFactory taskDependencyFactory) {
        super(taskDependencyFactory);
        this.original = original;
        this.derived = derived;
    }

    @Override

						},
					},
					RevisionHistoryLimit: ptr.To[int32](10),
				},
			},
		},
	}

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

			wrap: func() (http.ResponseWriter, http.ResponseWriter) {
				original := &FakeResponseWriter{}
				return original, original
			},
		},
		{
			name: "wrapped once",
			wrap: func() (http.ResponseWriter, http.ResponseWriter) {
				original := &FakeResponseWriter{}
				return original, &fakeResponseWriterDecorator{
					ResponseWriter: original,
				}
			},
		},
		{
			name: "wrapped multiple times",