class ToolingParameterProxyTest extends Specification {

    def "returns parameter valid when well defined"() {
        when:
        ToolingParameterProxy.validateParameter(ValidParameter)

        then:
        noExceptionThrown()
    }

    def "returns parameter invalid when not a getter or setter"() {
        when:
        ToolingParameterProxy.validateParameter(InvalidParameter1)

        then:

  - when:
    - key: "destination.ip"
      values: ["10.10.10.10", "192.168.10.0/24"]
      notValues: ["90.10.10.10", "90.168.10.0/24"]
  - when:
    - key: "destination.port"
      values: ["91", "92"]
      notValues: ["9001", "9002"]
  - when:
    - key: "connection.sni"
      values: ["exact.com", "*.suffix.com", "prefix.*", "*"]
      notValues: ["not-exact.com", "*.not-suffix.com", "not-prefix.*", "*"]
  - when:

        // Check caching
        when:
        server.resetExpectations()
        then:
        succeeds 'retrieve'
    }

    def "will use dependency type to locate artifact, even when custom packaging matches artifact type"() {
        when:
        buildWithDependencies("""
compile('group:projectA:1.0') {
    artifact {

    /**
     * @return When null, assume empty stdin (rather than consume from the current process' stdin).
     */
    @Nullable
    InputStream getStandardInput();

    /**
     * @return When null, use the provider's default Java home.
     */
    @Nullable
    File getJavaHome();

    /**
     * @return When null, use the provider's default JVM arguments. When empty, use no JVM arguments.
     */

    def "can handle null resource when closing"() {
        when:
        uncheckedClose(null)

        then:
        noExceptionThrown()

        when:
        closeQuietly(null)

        then:
        noExceptionThrown()
    }

    def "can close a valid resource"() {
        def resource = Mock(Closeable)

        when:
        uncheckedClose(resource)

        then:

        when:
        outstr.flush()

        then:
        0 * action._
    }

    def closeForwardsBufferedText() {
        TextStream action = Mock()
        def outstr = new LinePerThreadBufferingOutputStream(action)

        when:
        outstr.print("text")

        then:
        0 * action._

        when:
        outstr.close()

        then:

    def "can work when empty"() {
        def parser = new RelativePathParser("tree-some/")

        expect:
        parser.root

        when:
        parser.exitToRoot(exitHandler)
        then:
        0 * _
    }

    def "can exit when moved to different root"() {
        def parser = new RelativePathParser("tree-some/")

        when:

        when:
        lexer.pushText("<P></End>")
        lexer.visit(visitor)

        then:
        1 * visitor.onStartHtmlElement('p')
        1 * visitor.onStartHtmlElementComplete('p')
        1 * visitor.onEndHtmlElement('end')
        1 * visitor.onEnd()
        0 * visitor._
    }

    def parsesHtmlEntities() {
        when:
        lexer.pushText("before &amp; after")

        when:
        run("build")

        then:
        assertTestPassed("my.lib.LibraryTest", "someLibraryMethod returns true")

        where:
        scriptDsl << ScriptDslFixture.SCRIPT_DSLS
    }

    def "creates with gradle.properties when using #scriptDsl build scripts with --incubating"() {
        when:

     *
     * @return The charset. Returns null when this resource is not available as a file.
     */
    @Nullable
    Charset getCharset();

    /**
     * Returns true when the content of this resource is cached in-heap or uses a hard-coded value. Returns false when the content requires IO on each query.
     *
     * <p>When this method returns false, the caller should avoid querying the content more than once.</p>