*
         * @param original the original JAR or classes directory
         * @param transformed the transformed JAR or classes directory
         * @return this builder
         */
        public Builder add(File original, File transformed) {
            originals.add(original);
            if (!original.equals(transformed)) {

            ivySerializationHelper.writeRealisedConfigurationsData(encoder, transformed, deduplicationDependencyCache);
        } else if (transformed instanceof RealisedMavenModuleResolveMetadata) {
            mavenSerializationHelper.writeRealisedVariantsData(encoder, transformed);
            mavenSerializationHelper.writeRealisedConfigurationsData(encoder, transformed, deduplicationDependencyCache);
        } else {

            if (!JarUtil.isMultiReleaseJarManifest(parsedManifest)) {
                // If the original JAR is not multi-release, we don't need the manifest in the transformed JAR at all.
                return;
            }
            isMultiReleaseJar = true;

            // We want the transformed JAR to also be a proper multi-release JAR.
            // To do so it must have the "Multi-Release: true" attribute.

package org.gradle.api.internal.provider;

import org.gradle.api.Transformer;
import org.gradle.api.provider.Provider;

import javax.annotation.Nullable;

public class FlatMapProvider<S, T> extends AbstractMinimalProvider<S> {
    private final ProviderInternal<? extends T> provider;
    private final Transformer<? extends Provider<? extends S>, ? super T> transformer;

        def outputJar = testDir.file("transformed.jar")
        return new JarTestFixture(transform(factory, originalJar, outputJar), 'UTF-8', null, /* checkManifest */ false)
    }

    private TestFile transformDirectory(TransformFactoryType factory, File originalDir) {
        def outputDir = testDir.file("transformed")
        return new TestFile(transform(factory, originalDir, outputDir))
    }

            configHashFor(classpathElementTransformFactory, transform, gradleCoreInstrumentationTypeRegistry),
            classpathFileHasher);
        this.classpathElementTransformFactory = classpathElementTransformFactory;
        this.transform = transform;
    }

			expectedVerb: "LIST",
		},
		{
			desc:        "LIST should be transformed to WATCH if we have the right query param on the request",
			initialVerb: "LIST",
			request: &http.Request{
				Method: "GET",
				URL: &url.URL{
					RawQuery: "watch=true",
				},
			},
			expectedVerb: "WATCH",
		},
		{
			desc:        "LIST isn't transformed to WATCH if we have query params that do not include watch",
			initialVerb: "LIST",

        }
        Object[] transformed = new Object[args.length];
        for (int i = 0; i < args.length; i++) {
            Object arg = args[i];
            Class<?> type = types[i].getTheClass();
            if (type.isEnum() && arg instanceof CharSequence) {
                transformed[i] = toEnumValue(Cast.uncheckedNonnullCast(type), arg);
            } else {
                transformed[i] = args[i];
            }
        }

// expected-error @+1 {{recursive call graph cannot be transformed}}
module {
  func.func private @f() {
    func.call @f() : () -> ()
    func.call @f() : () -> ()
    func.return
  }
}

// -----
// Handle error case of infinite recursion with mutually recursive ops.
// expected-error @+1 {{recursive call graph cannot be transformed}}
module {
  func.func private @f() {
    func.call @g() : () -> ()

    /**
     * Whether the transformer requires dependencies of the transformed artifact to be injected.
     */
    boolean requiresDependencies();

    /**
     * Whether the transformer requires {@link InputChanges} to be injected.
     */
    boolean requiresInputChanges();

    /**
     * Whether the transformer is cacheable.
     */
    boolean isCacheable();