/**
     * Does this handler do something useful with the properties that match it? Or can these properties be ignored?
     *
     * Should consider splitting up this type, perhaps into something that inspects the properties and produces the actual handlers and validation problems.
     */
    boolean isPropertyRelevant();

    /**
     * Visit the value of a property with this annotation attached.
     */

/**
 * Thrown when there is a problem with the usage of a model rule.
 * <p>
 * This exception is different to {@link InvalidModelRuleDeclarationException} in that it signifies a problem
 * with using a model rule in a particular context, whereas {@code InvalidModelRuleDeclarationException} signifies

 * limitations under the License.
 */

package org.gradle.kotlin.dsl.execution

import org.junit.Test


class ProgramParserAnnotationErasureTest {

    @Test
    fun `empty Stage 1 with non-empty Stage 2 parse to Stage 2 with Stage 1 fragments erased`() {
        val scriptOnlySource =
            programSourceWith("""
                @Suppress("unused_variable")
                println("Stage 2")""".trimIndent())

/*
 * Copyright 2014 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,

        Preconditions.checkNotNull(
            key,
            "Cannot get the value of a property of type %s with key type %s as the source contains a null key.",
            Map.class.getName(), keyType.getName());
        Preconditions.checkNotNull(
            value,
            "Cannot get the value of a property of type %s with value type %s as the source contains a null value for key \"%s\".",

            equalTo(42)
        )
    }

    @Test
    fun `can serialize Kotlin action with Property`() {
        val loaded = valueCarriedBy(roundtripOf(isolatedActionCarrying(propertyOf("42"))))
        assertThat(
            loaded.get(),
            equalTo("42")
        )
    }

    @Test
    fun `can serialize Java lambda with Property`() {
        assertProviderRoundtrip(
            propertyOf("42"),
            "42"

    /**
     * Invokes with Groovy semantics and [arguments].
     */
    operator fun String.invoke(vararg arguments: Any?): Any?

    /**
     * Invokes with Groovy semantics and no arguments.
     */
    operator fun String.invoke(): Any? =
        invoke(*emptyArray<Any>())

    /**
     * Invokes with Groovy semantics, [arguments] and provides a nested [GroovyBuilderScope].

        def result = runner.buildAndFail()
        def output = result.output

        then:
        output.contains("- Gradle runtime: support for using a Java agent with TestKit builds is not yet implemented with the configuration cache.")

        when:
        runner = GradleRunner.create()
        runner.withJvmArguments("-javaagent:${agentJar}")
        if (!GradleContextualExecuter.embedded) {

/**
 * Allows the registration of {@link WorkInputListener work input listeners}.
 */
@ServiceScope(Global.class)
public interface WorkInputListeners {
    /**
     * Registers the listener with the build, the listener can be unregistered with {@link #removeListener(WorkInputListener)}.
     */
    void addListener(WorkInputListener listener);

    void removeListener(WorkInputListener listener);

        problems.onProblem(
            PropertyProblem(
                PropertyTrace.Gradle,
                StructuredMessage.build { text("support for using a Java agent with TestKit builds is not yet implemented with the configuration cache.") },
                documentationSection = DocumentationSection.NotYetImplementedTestKitJavaAgent
            )
        )