assert context.current().id == id
            assert context.current().source == source
        }

        and:
        context.current() == null
    }

    def "can nest application"() {
        def source = Stub(UserCodeSource)
        def source2 = Stub(UserCodeSource)
        def action = Mock(Action)
        def action2 = Mock(Action)
        def id1

        when:

            route:
              action: ANY
      patch:
        operation: MERGE
        value:
          rate_limits:
            - actions: # any actions in here
                  # Multiple actions nest the descriptors
                  # - generic_key:
                  # descriptor_value: "test"
              - request_headers:
                  header_name: ":path"
                  descriptor_key: "PATH"

            route:
              action: ANY
      patch:
        operation: MERGE
        value:
          rate_limits:
            - actions: # any actions in here
                  # Multiple actions nest the descriptors
                  # - generic_key:
                  # descriptor_value: "test"
              - request_headers:
                  header_name: ":path"
                  descriptor_key: "PATH"

      }
    }

  private var previousLevel: Level? = null

  override fun beforeEach(context: ExtensionContext?) {
    previousLevel = logger.level
    logger.addHandler(handler)
    logger.setLevel(Level.FINEST)
  }

  override fun afterEach(context: ExtensionContext?) {
    logger.setLevel(previousLevel)
    logger.removeHandler(handler)
  }

  override fun apply(
    base: Statement,

    /**
     * Configures debug logging.
     *
     * When enabled, {@link net.rubygrapefruit.platform.internal.jni.NativeLogger} will emit {@link java.util.logging.Level#FINEST} logs.
     */
    void setDebugLoggingEnabled(boolean debugLoggingEnabled);

    /**
     * Close the watcher registry. Stops watching without handling the changes.
     */
    @Override

    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) {

              }
            }
          }
        }
      }

      override fun flush() {
      }

      override fun close() {
      }
    }.apply {
      level = Level.FINEST
    }

  private fun applyLogger(fn: Logger.() -> Unit) {
    Logger.getLogger(OkHttpClient::class.java.`package`.name).fn()
    Logger.getLogger(OkHttpClient::class.java.name).fn()

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