then:
        result1.output.count("Transforming") + result2.output.count("Transforming") == 2
        result1.output.count("Transforming thing.jar to Red") + result2.output.count("Transforming thing.jar to Red") == 1
        result1.output.count("Transforming thing.jar to Blue") + result2.output.count("Transforming thing.jar to Blue") == 1
    }

            .assertOutputContains("Creating multiplier")
            .assertOutputContains("Transforming lib1.jar to lib1.jar.green")

        result.groupedOutput.transform("GreenMultiplier", "lib2.jar (project :lib)")
            .assertOutputContains("Creating multiplier")
            .assertOutputContains("Transforming lib2.jar to lib2.jar.green")

        where:
        type << TESTED_CONSOLE_TYPES
    }

        run("resolve")

        then:
        result.assertTaskExecuted(":producer")
        output.count("transforming [dir1]") == 1
        outputContains("result = [dir1.size]")

        when:
        run("resolve")

        then:
        result.assertTaskExecuted(":producer")
        output.count("transforming") == 0
        outputContains("result = [dir1.size]")
    }

        def build1 = executer.withTasks("redThings").withArgument("-Dcrash=true").start()
        build1.waitForFailure()

        run("redThings")

        then:
        output.count("Transforming") == 1
        output.count("Transforming thing.jar to Red") == 1
    }

        """
        succeeds ":a:resolve"
        outputContains("Transforming")
    }

    void executesIncrementally(String fileChanges) {
        setupBuildFile()
        buildFile << """
            ext.incremental = true
            $fileChanges
        """
        succeeds ":a:resolve"
        outputContains("Transforming")
    }

    void previousExecution() {

                    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 {

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_