'handlers = java.util.logging.ConsoleHandler' + EOL +
                '.level = FINEST' + EOL +
                'java.util.logging.ConsoleHandler.formatter = ' + DummyFormatter.class.name + EOL +
                'java.util.logging.ConsoleHandler.level = FINEST' + EOL +
                'hello.level = INFO' + EOL +
                'hello.world.level = FINER' + EOL))
        }
    }

                    assert logger.isLoggable(Level.CONFIG)
                    assert logger.isLoggable(Level.FINE)
                    assert !logger.isLoggable(Level.FINER)
                    assert !logger.isLoggable(Level.FINEST)
                }
            }
        """

        when:
        executer.withArgument("--debug")

        then:
        succeeds('isLoggable')
    }

            activeLogger.addHandler(handler)
          }

          if (sslDebug) {
            val activeLogger = getLogger("javax.net.ssl")

            activeLogger.level = Level.FINEST
            handler.level = Level.FINEST
            handler.formatter = MessageFormatter
            activeLogger.addHandler(handler)
          }
        }
      }
    }

    fun getLogger(name: String): Logger {

    handler: Handler = logHandler(),
  ): Closeable {
    val logger = Logger.getLogger(loggerClass)
    if (configuredLoggers.add(logger)) {
      logger.addHandler(handler)
      logger.level = Level.FINEST
    }
    return Closeable {
      logger.removeHandler(handler)
    }
  }

  fun enable(loggerClass: KClass<*>) = enable(loggerClass.java.name)

            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:

      }
    }

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

	"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",

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