file("src/ignore-2.txt").createFile()

        run("generate")

        then:
        result.assertTaskSkipped(":generate")
        output.count("checking") == 8
        outputContains("checking a/a.txt")
        outputContains("checking ignore-2.txt")
        file("out.txt").text == "a.txt,c.txt"

        when:
        file("src/d/d.txt").createFile()
        file("src/ignore-3.txt").createFile()

                println("checking \${it.name}")
                !it.name.contains('ignore')
            }
            task copy(type: Copy) {
                from files
                into 'dest'
            }
        """

        when:
        run 'copy'

        then:
        outputContains("checking one.txt")
        outputContains("checking ignore.txt")

        return propertyWithNoValue().value(value)
    }

    def "finalization checking works empty providers"() {
        given:
        def property = propertyWithNoValue()

        expect:
        !property.isPresent()
        !property.isFinalized()
    }

    def "finalization checking works with simple values"() {
        given:
        def property = propertyWithValue(someValue())

// rundir

// Copyright 2012 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// The reflect package was not correctly checking field names
// when checking for struct assignability.

// guard against this behavior changing during the type checking pass.
// Therefore we implement the following rule: any number of goroutines can type
// check concurrently with the same EnableAlias value, but if any goroutine
// tries to type check concurrently with a different EnableAlias value, we
// panic.
//
// To achieve this, _aliasAny is a state machine:
//
//	0:        no type checking is occurring

 */
@Incubating
public interface CheckableComponentSpec extends ComponentSpec {

    /**
     * Returns the task responsible for checking this component.
     */
    @Nullable
    Task getCheckTask();

    /**
     * Specifies the task responsible for checking this component.
     */
    void setCheckTask(@Nullable Task checkTask);

    /**

import javax.annotation.Nullable;

/**
 * Interface for services which support recording the "implicit inputs" they generate.
 * Whenever a rule calls a service, it may have side effects that needs to be taken
 * into account when checking if the rule is up-to-date. For example, if a rule performs
 * an HTTP query, we know that there is an implicit input to the rule which is the result
 * of the HTTP query (the external resource).
 *

 * limitations under the License.
 */

package org.gradle.test.precondition

import org.junit.jupiter.api.Assumptions
import spock.lang.Specification

/**
 * This class executes a special test suite, checking all the allowed precondition combinations.
 *
 * <p>
 * Each combination can have three outcomes:
 * <ul>
 *     <li><b>Successful:</b> the precondition combination could be satisfied.</li>
 *     <li>

// Blank methods need to be type-checked.
// Verify by checking that errors are reported.
func (T /* ERROR "undefined" */ ) _() {}
func (T1) _(undefined /* ERROR "undefined" */ ) {}
func (T1) _() int { return "foo" /* ERRORx "cannot use .* in return statement" */ }

// Methods with undefined receiver type can still be checked.
// Verify by checking that errors are reported.
func (Foo /* ERROR "undefined" */ ) m() {}

// during the type checking pass. Therefore we implement the following rule:
// any number of goroutines can type check concurrently with the same
// EnableAlias value, but if any goroutine tries to type check concurrently
// with a different EnableAlias value, we panic.
//
// To achieve this, _aliasAny is a state machine:
//
//	0:        no type checking is occurring