matches("somena", "someName")
        matches("somena", "SomeName")
        matches("somena", "SomeName")
        matches("some na", "Some Name")
    }

    def "selects item with matching camel case prefix"() {
        expect:
        matches("sN", "someName")
        matches("soN", "someName")
        matches("SN", "someName")
        matches("SN", "SomeName")
        matches("SN", "SomeNameWithExtraStuff")

        where:
        input << [
                '#someName(SomeClass,Object)',
                '#someName(SomeClass, Object)',
                '#someName(SomeClass,\tObject)',
                '#someName  (  \t SomeClass ,\tObject\t ) '
        ]
    }

    def convertsMethodSignatureWithNoParamsToLink() {
        MethodMetaData method = method('someName', signature: 'someName()')

        val objectFactory = mock<ObjectFactory> {
            on { named(any<Class<Named>>(), eq("foo")) } doReturn SomeNamed("foo")
        }

        val named = objectFactory.named<SomeNamed>("foo")
        assertThat(named.name, equalTo("foo"))

        inOrder(objectFactory) {
            verify(objectFactory).named(SomeNamed::class.java, "foo")
            verifyNoMoreInteractions()
        }
    }

    @Test

// tag::use-plugin[]
plugins {
    distribution
}
// end::use-plugin[]

// tag::configure-distribution[]
distributions {
    main {
        distributionBaseName = "someName"
        distributionClassifier = "classifier"
        contents {
            from("src/readme")
        }
    }
}
// end::configure-distribution[]

// tag::custom-distribution[]
distributions {
    create("custom") {

            </arguments>
        </buildCommand>
    </buildSpec>
    <natures>
        <nature>org.eclipse.jdt.core.scalanature</nature>
    </natures>
    <linkedResources>
        <link>
            <name>somename</name>
            <type>sometype</type>
            <location>somelocation</location>
        </link>
    </linkedResources>
    <filteredResources>
        <filter>
            <id>1</id>

// tag::publish-distribution[]
plugins {
// end::publish-distribution[]
    id 'distribution'
}
// end::use-plugin[]

// tag::configure-distribution[]
distributions {
    main {
        distributionBaseName = 'someName'
        distributionClassifier = 'classifier'
        contents {
            from 'src/readme'
        }
    }
}
// end::configure-distribution[]

// tag::custom-distribution[]
distributions {

    }

    private void reportInvalidVariant(ResolvedVariantResult variant) {
        Optional<ResolvedVariantResult> sameName = selectedVariants.stream()
            .filter(v -> v.getDisplayName().equals(variant.getDisplayName()))
            .findFirst();
        String moreInfo = sameName.isPresent()
            ? "A variant with the same name exists but is not the same instance."

        Project.PATH_SEPARATOR + "child" + Project.PATH_SEPARATOR + "childchild" + Project.PATH_SEPARATOR + TEST_TASK_NAME ==  task.getPath()
    }

    def testDependsOn() {
        Task dependsOnTask = createTask(project, "somename")
        Task task = createTask(project, TEST_TASK_NAME)
        project.getTasks().create("path1")
        project.getTasks().create("path2")

        when:

// the coverage processing has changed the line numbers, so we can't use runtime.Caller.

package main

import _ "unsafe" // for go:linkname

//go:linkname some_name some_name
var some_name int

const anything = 1e9 // Just some unlikely value that means "we got here, don't care how often"

func testAll() {
	testSimple()
	testBlockRun()
	testIf()
	testFor()
	testRange()

    }

    private ProjectDescriptor projectDescriptor(ScriptFileResolver scriptFileResolver = null) {
        def parentDescriptor = new DefaultProjectDescriptor(null, "somename", new File("somefile"), descriptorRegistry, fileResolver, scriptFileResolver)
        def descriptor = new DefaultProjectDescriptor(parentDescriptor, testName.methodName, testDirectory, descriptorRegistry, fileResolver, scriptFileResolver)