then:
        outputContains("files: [test-lib.jar, transformed-a1.jar, transformed-b2.jar, test-1.0.jar]")
        outputContains("components: [test-lib.jar, project :lib, project :ui, org:test:1.0]")
        outputContains("variants: [{artifactType=jar}, {artifactType=jar, buildType=debug, flavor=one, usage=transformed}, {artifactType=jar, usage=transformed}, {artifactType=jar, org.gradle.status=integration}]")
    }

        super.writeRealisedConfigurationsData(encoder, transformed, deduplicationDependencyCache);
        if (transformed instanceof RealisedMavenModuleResolveMetadata) {
            writeDerivedVariants(encoder, (RealisedMavenModuleResolveMetadata) transformed, deduplicationDependencyCache);
        }
    }

  let description = [{
    This pass transforms functional control flow operations in the TensorFlow
    dialect to their region-based counterparts, i.e., `tf.If` is transformed to
    `tf.IfRegion` and `tf.While` is transformed to `tf.WhileRegion`.

    For example, this functional operation

    ```mlir
      %0 = "tf.If"(%arg0, %arg1) {

import org.gradle.api.artifacts.component.ModuleComponentSelector;

/**
 * Represents dependency information as stored in an external descriptor file (POM or IVY.XML).
 * This information is able to be transformed into a `ModuleDependencyMetadata` instance.
 */
public abstract class ExternalDependencyDescriptor {

    public abstract ModuleComponentSelector getSelector();

    public abstract boolean isOptional();

     *
     * @param problem the problem to transform
     * @param id the operation id associated with the problem
     * @return the transformed problem
     */
    Problem transform(Problem problem, OperationIdentifier id);

      %replicated_output = "tf.TPUReplicatedOutput(%identity) : (tensor<i32>) -> tensor<i32>
      return %replicated_output : tensor<i32>
    }
    ```

    will be transformed into:

    ```mlir
    func @tpu_computation(%arg0: tensor<i32>) -> tensor<i32> {
      %cluster = "tf_device.cluster"() ( {
        %identity = "tf.Identity"(%arg0) : (tensor<i32>) -> tensor<i32>

        return dependencies;
    }

    private IvyModuleResolveMetadata withDependencies(Map<IvyDependencyDescriptor, IvyDependencyDescriptor> transformed) {
        ImmutableList<IvyDependencyDescriptor> transformedDescriptors = ImmutableList.copyOf(transformed.values());
        Set<String> configurationNames = getConfigurationNames();

    // objectKeyed = transformEntries(map6, transformer);
    // objectKeyed = transformEntries(map8, transformer);
    // objectKeyed = transformEntries(map9, transformer);
    // numberKeyed = transformEntries(map8, transformer);
    // numberKeyed = transformEntries(map9, transformer);

    // Can't loosen the value type:
    // Map<Number, Number> looseValued1 = transformEntries(map5, transformer);

    /**
     * Copies this state, but with the new component ID and the artifacts transformed by the given transformer.
     */
    LocalComponentGraphResolveState copy(ComponentIdentifier newComponentId, Transformer<LocalComponentArtifactMetadata, LocalComponentArtifactMetadata> transformer);

    /**
     * We currently allow a configuration that has been partially observed for resolution to be modified

When a user runs a Gradle build Gradle it uses transformed plugin jars. 
The whole transformation process normally happens on the first use of a build or when a plugin jar is added to the build script classpath.
We transform the jar and cache transformed jars for future use.

We transform plugins classpath, TestKit classpath and buildscript classes separately.