layout_optimization_options);

  // Prepare IR for exporting.
  pm.addPass(CreateBreakUpIslandsPass());

  // In case of failure, the `diag_handler` converts MLIR errors emitted to the
  // MLIRContext into a tensorflow::Status.
  StatusScopedDiagnosticHandler diag_handler(module.getContext());
  LogicalResult result = pm.run(module);
  (void)result;
  return diag_handler.ConsumeStatus();
}

        operations[':compileJava'].failure.contains('Compilation failed')
    }

    def "empty processor path overrides processors in the compile classpath, and no deprecation warning is emitted"() {
        buildFile << """
            dependencies {
                implementation project(":annotation")
                implementation project(":processor")
            }

            compileJava {

// an unexported name). The calls serve two purposes:
// 1) they are opaque to escape analysis, so the argument is considered to
// escape to the heap.
// 2) they keep the argument alive until the call site; the call is emitted after
// the end of the (presumed) use of the argument by C.
// cgoUse should not actually be called (see cgoAlwaysFalse).
func cgoUse(any) { throw("cgoUse should not be called") }

// Returns a NHWC shaped type from an NCHW shaped type op.
// For example- Given a Composite op that wraps a core.aten.avg_pool2d, this
// returns the return type of the tfl.average_pool_2d emitted. Note that the
// aten.avg_pool2d works with the NCHW layout while tfl.average_pool_2d assumes
// NHWC.
ShapedType GetNhwcReturnTypeFromNchw(Operation* old_op);

}  // namespace odml

}  // namespace mlir

            } finally {
                rootId = null;
            }
        } else {
            //when test is completed we should redirect output for the parent
            //so that log events emitted during @AfterSuite, @AfterClass are processed
            Object newOwner = parents.remove(testId);
            outputRedirector.setOutputOwner(newOwner);
        }
        processor.completed(testId, event);
    }

     */
    <U extends AdditionalDataSpec> InternalProblemSpec additionalData(Class<? extends U> specType, Action<? super U> config);

    /**
     * Declares that this problem was emitted by a task with the given path.
     *
     * @param buildTreePath the absolute path of the task within the build tree
     * @return this
     */
    InternalProblemSpec taskPathLocation(String buildTreePath);

import com.google.common.base.Preconditions;

import java.util.List;
import java.util.regex.Pattern;

/**
 * Represents a deprecation warning message that is expected to be emitted by a test.
 * <p>
 * This class exists to support the detection of deprecation warnings that span multiple lines,
 * which may include the keyword "{@code deprecated}" multiple times.
 */

        return new BuildOperationFiringSettingsPreparer(
            new DefaultSettingsPreparer(
                settingsLoaderFactory
            ),
            buildOperationRunner,
            emitter,
            buildDefinition.getFromBuild());
    }

    @Provides

class as a function")}(this,e),this.resolveOptions(t),this.initSelection()}return i(e,[{key:"resolveOptions",value:function(){var t=0<arguments.length&&void 0!==arguments[0]?arguments[0]:{};this.action=t.action,this.container=t.container,this.emitter=t.emitter,this.target=t.target,this.text=t.text,this.trigger=t.trigger,this.selectedText=""}},{key:"initSelection",value:function(){this.text?this.selectFake():this.target&&this.selectTarget()}},{key:"selectFake",value:function(){var t=this,e="rtl"==d...

class TestFailureProgressEventCrossVersionTest extends TestFailureSpecification {

    def setup() {
        enableTestJvmDebugging = false
        enableStdoutProxying = true
    }

    def "Wrapped assertion errors are emitted as test failure events using JUnit 4"() {
        given:
        setupJUnit4()
        file('src/test/java/org/gradle/JUnitTest.java') << '''
            package org.gradle;

            import org.junit.Test;