}
            extensions.add('things', SomeThing)
            things {
                letter = 'a'
                withLetter('b')
            }
            assert things.letter == Letter.B
            things.other('ABC')
            assert things.letter == Letter.A
            things.other(Letter.C)
            assert things.letter == Letter.C
            things.other('A', 'ignore')

        and:
        1 * index.lookup("thing") >> null
        1 * localCandidates.isNone() >> false
        1 * repository.resource(location, true) >> remoteResource
        1 * remoteResource.metaData >> null
        0 * _._
    }

    def "downloads resource and moves it into the cache when it is not cached"() {
        def location = new ExternalResourceName("thing")

- the configuration `mongodbSupportRuntimeOnly`, used to _declare runtime-only dependencies_ for this feature
- the configuration `mongodbSupportCompileOnly`, used to _declare compile-only dependencies_ for this feature
- the configuration `mongodbSupportCompileOnlyApi`, used to _declare compile-only API dependencies_ for this feature

Furthermore, consumable configurations are created in the same manner as for the main feature:

        when:
        def javaSrcFile = sourceDir.file("Thing.java") << 'public class Thing {}'

        then:
        runBuild {
            succeeds()
            waitBeforeModification javaSrcFile
            javaSrcFile.text = 'public class Thing { *******'
            fails()
            waitBeforeModification javaSrcFile
            javaSrcFile.text = 'public class Thing {} '
            succeeds()
        }
    }

                attribute(targetAttribute, objects.named(Thing, 'Bar'))
            }
        }
        context.details.withVariant('foo') {
            attributes {
                attribute(targetAttribute, objects.named(Thing, 'Bar'))
            }
        }
    }
}

interface Thing extends Named { }

def thing = Attribute.of(Thing)

configurations {
    conf {
        attributes {

                testImplementation("junit:junit:4.13")
            }
        """
        file("src/main/groovy/Thing.groovy") << """
            class Thing {}
        """
        file("src/test/groovy/ThingTest.groovy") << """
            import org.junit.*
            class ThingTest {
                @Test void ok() { new Thing() }
            }
        """

        and:
        def expectedTasks = [

    @Test
    fun `Provider#flatMap works with a null return value in script`() {
        withBuildScript("""
            val providerA: Provider<String> = provider { "thing" }.flatMap { provider { null } }
            val providerB: Provider<String> = provider { "thing" }.flatMap { null }
        """)
        build("help")
    }

    @Test
    fun `Provider#flatMap works with a null return value in a kotlin-dsl project`() {

            }
"""
        file("src/main/swift/Lib.swift") << """
            import Lib1
            import Lib2
            class Lib {
                init() {
                    Lib1.thing()
                    Lib2.thing()
                }
            }
        """

        when:
        run("generateSwiftPmManifest")

        then:
        file("Package.swift").text == """// swift-tools-version:4.0

        when:
        file("src/main/groovy/pkg/Thing.groovy") << """
            package pkg

            class Thing {}
        """

        buildFile << """
            groovydoc {
                noVersionStamp = false
            }
        """

        then:
        succeeds "groovydoc"

        and:
        def text = file('build/docs/groovydoc/pkg/Thing.html').text

Additionally, it has a fake client variant, that does the same thing but with fake clients for use in unit tests.

Aside from this, there are a few conveniences and workarounds built-in to the client to make things simpler.

*All Istio Kubernetes usage should use this library and not operate on Kubernetes clients directly.*