TestExecutor(TestLogger logger) {
        this.logger = logger
    }

    void start() {
        lock.lock()
        try {
            if (owner != null) {
                throw new IllegalStateException("Cannot nest async { } blocks.")
            }
            owner = Thread.currentThread()
        } finally {
            lock.unlock()
        }
    }

    void execute(Runnable runnable) {

	"BSETI",
	"WORD",
	"BEQZ",
	"BGEZ",
	"BGT",
	"BGTU",
	"BGTZ",
	"BLE",
	"BLEU",
	"BLEZ",
	"BLTZ",
	"BNEZ",
	"FABSD",
	"FABSS",
	"FNEGD",
	"FNEGS",
	"FNED",
	"FNES",
	"MOV",
	"MOVB",
	"MOVBU",
	"MOVF",
	"MOVD",
	"MOVH",
	"MOVHU",
	"MOVW",
	"MOVWU",
	"NEG",
	"NEGW",
	"NOT",
	"SEQZ",
	"SNEZ",
	"LAST",

            this.parentName = parentName
            this.name = name
        }
    }

    def "can nest auto creation configure closures"() {
        given:
        def parent = instantiator.newInstance(Container, "top", "parent", { name1 ->
            instantiator.newInstance(Container, "parent", name1, { name2 ->

  // Assign optimal data layout to layout sensitive operations and delete
  // redundant transposes from the IR.
  LayoutOptimizationPipelineOptions layout_optimization_options;
  CreateLayoutOptimizationPipeline(pm.nest<func::FuncOp>(),
                                   layout_optimization_options);

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

	SRLI	$1, X5, F1			// ERROR "expected integer register in rd position but got non-integer register F1"
	SRLI	$1, F1, X5			// ERROR "expected integer register in rs1 position but got non-integer register F1"
	FNES	F1, (X5)			// ERROR "needs an integer register output"

 */

package org.gradle.integtests.composite

import org.gradle.api.Plugin
import org.gradle.api.Project

class CompositeBuildNestingIntegrationTest extends AbstractCompositeBuildIntegrationTest {
    def "can nest included builds"() {
        given:
        dependency(buildA, "org.test:buildB:1.2")

        def buildC = singleProjectBuild("buildC") {
            buildFile << """
                apply plugin: 'java'

      tf.TensorSpec([], tf.float32),
      tf.TensorSpec([], tf.float32),
  ]])
  def f0001_list_2_elements(self, l):
    return

  # Check index paths for dicts.
  # Keys are linearized in sorted order, matching `tf.nest.flatten`.
  #
  # CHECK:      func {{@[a-zA-Z_0-9]+}}(
  # CHECK-SAME:   %arg0: tensor<1xf32> {tf._user_specified_name = "d", tf_saved_model.index_path = [0, "x"]},

  def f0004_list_2_elements(self):
    return [[tf.constant(1.0, shape=[1]), tf.constant(1.0, shape=[2])]]

  # Check index paths for dicts.
  # Keys are linearized in sorted order, matching `tf.nest.flatten`.
  # More thorough testing of this is in structured_input.py. The underlying code
  # path for linearization is shared, so no need to replicate that testing here.
  #
  # CHECK:      func {{@[a-zA-Z_0-9]+}}() -> (

        task2.target.name == 'target2'

        and:
        def task3 = project.tasks.target3
        task3 instanceof AntTarget
        task3.target.name == 'target3'
    }

    def "can nest elements"() {
        when:
        ant.otherProp = 'true'
        ant.condition(property: 'prop', value: 'someValue') {
            or {
                and {
                    isSet(property: 'otherProp')

	return matchPatternInternal(pattern, false)
}

func matchPatternInternal(pattern string, vendorExclude bool) func(name string) bool {
	// Convert pattern to regular expression.
	// The strategy for the trailing /... is to nest it in an explicit ? expression.
	// The strategy for the vendor exclusion is to change the unmatchable
	// vendor strings to a disallowed code point (vendorChar) and to use