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

      %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();

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. 

     * Constructs a complete cacheable variant chain given a root transformed variant and the chain of variants
     * to apply to that root variant.
     *
     * @param stateChain The transform chain from the search state to apply to the root transformed variant.
     * @param root The root variant to apply the chain to.
     *
     * @return A variant chain representing the final transformed variant.
     */

         * If the value needs to be transformed, instead of unpacking consider using {@link #transform(Transformer)}
         * which automatically keeps track of side effects.
         */
        T orElse(T defaultValue);

        /**
         * Behaves like {@link #get()}, but does not execute a side effect if present.
         * <p>

     return %arg0
    }
    func @while_cond(%arg0: tensor<*x!tf_type.resource<tensor<f32>>>) {
      %read = "tf.ReadVariableOp"(%arg0)
      return %read
    }
    ```

    will be transformed to:

    ```mlir
    func @cluster_with_loop() {
      %0 = "tf.VarHandleOp"() ...
      %1 = "tf.ReadVariableOp"(%0)
      %2 = "tf_device.cluster"() ( {

        Action<XmlProvider> elementAction = Mock()
        Action<XmlProvider> stringAction2 = Mock()
        transformer.addAction(stringAction)
        transformer.addAction(elementAction)
        transformer.addAction(nodeAction)
        transformer.addAction(stringAction2)

        when:
        def result = transformer.transform('<root/>')

        then:
        stringAction.execute(_) >> { XmlProvider provider ->

        return getGradleVersionedCacheDir().file(CacheLayout.TRANSFORMS.getName())
    }

    /**
     * Finds all cached transformed JARs named {@code jarName}.
     * @param jarName the name of the JAR to look
     * @return the list of transformed JARs in the cache
     */
    List<File> getArtifactTransformJarsByName(String jarName) {