* again and get a more complete representation of the same object; but properties cannot be
     * removed, so this only allows limited reuse of the helper instance. The helper allows
     * duplication of properties (multiple name/value pairs with the same name can be added).
     */
    @Override
    public String toString() {

class TaskInputFilePropertiesIntegrationTest extends AbstractIntegrationSpec implements ValidationMessageChecker {
    def setup() {
        expectReindentedValidationMessage()
        enableProblemsApiCheck()
    }

    def "allows optional @#annotation.simpleName to have null value"() {
        buildFile << """
            import ${GetInputFilesVisitor.name}
            import ${TaskPropertyUtils.name}
            import ${PropertyWalker.name}

    }

    def "allows reconfiguring project cache dir with relative directory"() {
        given:
        buildFile "task foo { outputs.file file('out'); doLast { } }"

        when:
        executer.withTasks("foo").withArguments("--project-cache-dir", ".foo").run()

        then:
        assert file(".foo").exists()
    }

Component selection rules may influence which component instance should be selected when multiple versions are available that match a version selector.
Rules are applied against every available version and allow the version to be explicitly rejected by rule.
This allows Gradle to ignore any component instance that does not satisfy conditions set by the rule.
Examples include:

    def "allows setting forced modules"() {
        expect:
        strategy.forcedModules.empty

        when:
        strategy.force 'org.foo:bar:1.0', 'org.foo:baz:2.0'

        then:

func NewMockVersion(ctrl *gomock.Controller) *MockVersion {
	mock := &MockVersion{ctrl: ctrl}
	mock.recorder = &MockVersionMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockVersion) EXPECT() *MockVersionMockRecorder {
	return m.recorder
}

// Compare mocks base method.
func (m *MockVersion) Compare(other string) (int, error) {

     * again and get a more complete representation of the same object; but properties cannot be
     * removed, so this only allows limited reuse of the helper instance. The helper allows
     * duplication of properties (multiple name/value pairs with the same name can be added).
     */
    @Override
    public String toString() {

     *
     * @param closure The closure to call.
     */
    public void afterTest(Closure closure) {
        addDispatchAsTestListener("afterTest", closure);
    }

    /**
     * Allows to set options related to which test events are logged to the console, and on which detail level. For example, to show more information about exceptions use:
     *
     * <pre class='autoTested'>
     * apply plugin: 'java'

A `plugins{}` block inside `pluginManagement{}` allows all plugin versions for the build to be defined in a single location.
Plugins can then be applied by id to any build script via the `plugins{}` block.

One benefit of setting plugin versions this way is that the `pluginManagement.plugins{}` does not have the same <<#sec:constrained_syntax,constrained syntax>> as the build script `plugins{}` block.

[[migmvn:profiles_and_properties]]
== Migrating Maven profiles and properties

Maven allows you parameterize builds using properties of various sorts.
Some are read-only properties of the project model, others are user-defined in the POM.
It even allows you to treat system properties as project properties.