private static final String AST_NODE_METADATA_KEY = RulesVisitor.class.getName();
    private static final ClassNode ANNOTATION_CLASS_NODE = new ClassNode(RulesBlock.class);

    // TODO - have to do much better here
    public static final String INVALID_STATEMENT = "illegal rule";
    public static final String INVALID_RULE_SIGNATURE = "Rule must follow the pattern '«name»(«type») {}' for a registration, and '«name» {}' for an action";

    private
    val conventionStorage = ConventionStorage()

    private
    val analysisContext = AnalysisStepContext(
        supportedDocumentChecks = emptyList(), // TODO: move the settings blocks check here,
        supportedResolutionResultHandlers = listOf(ConventionDefinitionCollector(conventionStorage), ConventionApplicationHandler(conventionStorage))
    )

    fun evaluate(
        scriptFileName: String,

        when:
        fails failingTaskName

        then:
        // Note: we test less of the exception here because it's different in a build where configuration came from cache
        // In the non cache case, the exception points to the build file. In the from cache case it does not.

//   void MyMethod();
//   FRIEND_TEST(MyClassTest, MyMethod);
// };
//
// class MyClassTest : public testing::Test {
//   // ...
// };
//
// TEST_F(MyClassTest, MyMethod) {
//   // Can call MyClass::MyMethod() here.
// }

#define FRIEND_TEST(test_case_name, test_name)\
friend class test_case_name##_##test_name##_Test

    }

    @Override
    public String getClassName() {
        return null;
    }

    /**
     * Returns the method name for this test, if any.
     * It should be in TestDescriptor, but moved here for backward compatibility
     *  TODO: move it to TestDescriptor interface with 9.0
     *
     * @return The method name. May return null.
     * @since 8.8

import org.gradle.api.tasks.TaskAction
import java.io.File
import java.io.InputStream
import java.nio.charset.Charset

class LicensePlugin: Plugin<Project> {
    // Don't change anything here
}

abstract class LicenseTask : DefaultTask() {
    @Input
    val fileName = project.rootDir.toString() + "/license.txt"

    @TaskAction
    fun action() {
        // Read the license text

    override fun setClasspath(classpath: FileCollection) {
        /*
         * The 'kotlin-daemon-client.jar' repackages 'native-platform' with all its binaries.
         * Here we make sure it is placed at the end of the test classpath so that we do not accidentally
         * pick parts of 'native-platform' from the 'kotlin-daemon-client.jar' when instantiating
         * a Gradle runner.
         */

        when:
        def recordingServer = new TestRecordingSocksServer()
        proxyServer.start(recordingServer)
        proxyServer.configureProxy(executer)
        fails('listJars') // Don't have to succeed here, just record the attempt in the fake proxy and verify it
        then:
        result.assertTaskExecuted(":listJars")
        recordingServer.madeAnyConnection()

        when:
        proxyServer.stop()

    public void clear(ArtifactAtRepositoryKey key) {
        // clear is actually called from org.gradle.internal.resource.cached.AbstractCachedIndex.lookup which
        // is a read operation, in case of missing entry, so we can't fail here, but should be a no-op only
    }

    private static void operationShouldNotHaveBeenCalled() {
        throw new UnsupportedOperationException("A write operation shouldn't have been called in a read-only cache");
    }

class ExternalResourceNameIntegrationTest extends AbstractIntegrationSpec {

    // Network shares on Linux and macOS are just normal file paths, so we don't have anything to test here
    @Requires(UnitTestPreconditions.Windows)
    def "can access repository on network share"() {
        //since we do not have a network share, we test the failure case and assert that the correct path was searched