@Test
    fun `preserves identity of java util logging Level`() {
        configurationCacheRoundtripOf(java.util.logging.Level.INFO to java.util.logging.Level.WARNING).run {
            assertThat(
                first,
                sameInstance(java.util.logging.Level.INFO)
            )
            assertThat(
                second,
                sameInstance(java.util.logging.Level.WARNING)
            )
        }
    }

import org.hamcrest.CoreMatchers.equalTo
import org.hamcrest.MatcherAssert.assertThat
import org.junit.Assert.fail
import org.junit.Test


class PartialEvaluatorTest {

    @Test
    fun `Project target - top-level - empty`() {

        assertThat(
            "reduces to static program that applies default plugin requests and base plugins",
            partialEvaluationOf(
                Program.Empty,

@Deprecated(deprecationMessage, replaceWith = ReplaceWith("get().buildDependencies"), level = DeprecationLevel.HIDDEN)
val <T : Configuration> NamedDomainObjectProvider<T>.buildDependencies: TaskDependency
    get() = get().buildDependencies


/**
 * See [Configuration.getSingleFile].
 */
@Deprecated(deprecationMessage, replaceWith = ReplaceWith("get().singleFile"), level = DeprecationLevel.HIDDEN)

    companion object {
        var level = 0

        fun <T> debug(name: String, parser: Parser<T>): Parser<T> = {
            val levelString = "\t".repeat(level)
            println("${levelString}Parsing with $name @ ${this.currentPosition.offset} ...")
            level++
            val result = parser()
            level--

            assertIs<ObjectOrigin.NewObjectFromMemberFunction>(this)
            assertEquals("my2", function.simpleName)
        }
    }

    @Test
    fun `a local value cannot be used until assigned at top level`() {
        val resolution = schema.resolve(
            """
            my {
                my = m
            }

            val m = my1()

            my {
                my = m
            }

import org.hamcrest.CoreMatchers.equalTo
import org.hamcrest.MatcherAssert.assertThat

import org.junit.Test


class LexerTest {

    @Test
    fun `extracts comments, annotations and top-level blocks`() {

        assertThat(
            lex(
                "/* ... @TaskAction ... */" +
                    "\n// ... @Suppress(\"unused_variable\")" +
                    "\nbuildscript { /*" +

    @Test
    fun `given top-level buildscript reference it returns null`() {
        assertNoBuildscript(
            """
            val a = buildscript
            a.dependencies {}"""
        )
    }

    @Test
    fun `given top-level buildscript reference followed by top-level buildscript it returns correct range`() {
        assertThat(
            extractBuildscriptBlockFrom("val a = buildscript\nbuildscript {}"),

    (parent as? ObjectOrigin.AccessAndConfigureReceiver)?.function?.simpleName == ConventionsTopLevelReceiver::conventions.name


/**
 * Checks if a given ObjectOrigin receiver is the top-level receiver.
 */
private
fun isTopLevelReceiver(objectOrigin: ObjectOrigin) =

import org.gradle.api.logging.Logger


class LoggingTracer(
    private val profile: String,
    private val writePosition: () -> Long,
    private val logger: Logger,
    private val level: LogLevel
) : Tracer {

    // Include a sequence number in the events so the order of events can be preserved in face of log output reordering
    private
    var nextSequenceNumber = 0L

            ) to codecs
        }

    private
    fun loggingTracerFor(profile: () -> String, encoder: KryoBackedEncoder) =
        loggingTracerLogLevel()?.let { level ->
            LoggingTracer(profile(), encoder::getWritePosition, logger, level)
        }

    private
    fun loggingTracerLogLevel(): LogLevel? = when {
        startParameter.isDebug -> LogLevel.LIFECYCLE