originalText := []byte(testText)

			transformedData, err := envelopeTransformer.TransformToStorage(ctx, originalText, dataCtx)
			if err != nil {
				t.Fatalf("envelopeTransformer: error while transforming data to storage: %s", err)
			}
			untransformedData, _, err := envelopeTransformer.TransformFromStorage(ctx, transformedData, dataCtx)
			if err != nil {

                    def input = inputArtifact.get().asFile
                    File outputFile = outputs.file(input.name + ".xform")
                    def outputDirectory = outputFile.parentFile
                    println("Transforming \$input in output directory \$outputDirectory")
                    java.nio.file.Files.copy(input.toPath(), outputFile.toPath())
                }
            }

            dependencies {

        '''

        expect:
        fails 'merge'
// Expected behavior:
//        when:
//        run 'merge'
//
//        then:
//        outputContains 'Transforming p1.zip'
//        outputContains 'Transforming p2.zip'
//        result.assertTasksExecuted ':p1:produce', ':p1:zip', ':p2:produce', ':p2:zip', ':merge'
//        file('merge.txt').text == 'p1.zip,p2.zip'
    }

called “lowerings”)

MLIR is highly influenced by [LLVM](https://llvm.org/) and unabashedly reuses
many great ideas from it. It has a flexible type system, and allows
representing, analyzing and transforming graphs combining multiple levels of
abstraction in the same compilation unit. These abstractions include TensorFlow
operations, nested polyhedral loop regions, and even LLVM instructions and fixed
hardware operations and types.

    }

    @Override
    protected void processResource(ClasspathBuilder.EntryBuilder builder, ClasspathEntryVisitor.Entry resourceEntry) throws IOException {
        // The entries should only be filtered out if we're transforming the proper multi-release JAR.
        // Otherwise, even if the entry path looks like it is inside the versioned directory, it may still be accessed as a
        // resource.

 * <p>
 * The compilation may extract data from the source under compilation, made available after compilation by {@link #getExtractedData()}.
 * The exposed transformer typically gathers the data while transforming.
 * <p>
 * As these objects are stateful, they can only be used for a single compile operation.
 *
 * @param <T> the type of data extracted by this operation
 */
public interface CompileOperation<T> {

    /**

See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/
// This header file defines common utils used when transforming TF ops to
// Uniform Quantized ops.

#ifndef TENSORFLOW_COMPILER_MLIR_QUANTIZATION_TENSORFLOW_UTILS_TF_TO_UNIFORM_ATTRIBUTE_UTILS_H_

namespace mlir {
namespace TF {

inline constexpr char kStandardPipelineBefore[] = "standard_pipeline_before";
inline constexpr char kStandardPipelineAfter[] = "standard_pipeline_after";

// Runs all passes involved in transforming or optimizing an MLIR graph without
// any target specialization. When enable_logging is true, enables
// tensorflow::BridgeLogger. When enable_inliner is true, enables the inliner
// pass.
ABSL_DEPRECATED(

#include "mlir/IR/BuiltinOps.h"  // from @llvm-project
#include "tensorflow/core/lib/core/status.h"

namespace tensorflow {
namespace tf2xla {
namespace v1 {

// Run all the passes involved in transforming the graph before execution so
// that it is suitable for targeting devices when called via the TF1 Session
// API.
// These transformations take as input a Tensorflow Graph as an MLIR Module

limitations under the License.
==============================================================================*/

// This header file defines common utils used when transforming TF ops to XLA
// ops.
#ifndef TENSORFLOW_COMPILER_MLIR_QUANTIZATION_TENSORFLOW_UTILS_TF_TO_XLA_ATTRIBUTE_UTILS_H_
#define TENSORFLOW_COMPILER_MLIR_QUANTIZATION_TENSORFLOW_UTILS_TF_TO_XLA_ATTRIBUTE_UTILS_H_