// If a solution is found, solve prints the board after each move in a backward
// fashion (i.e., the last board position is printed first, all the way back to
// the starting board position).
func solve() bool {
	var last, n int
	for pos, field := range board {
		// try each board position
		if field == '●' {
			// found a peg
			for _, dir := range [...]int{-1, -N, +1, +N} {
				// try each direction
				if move(pos, dir) {

    def "does not remove vcs checkout that is older than 7 days but recently used"() {
        // checkout all versions
        versions.each { version ->
            succeeds("assertVersion", "-PrepoVersion=${version}")
        }
        // mark all versions as unused
        versions.each { version ->
            markUnused(version)
        }

        when:
        cleanupNow()

    }

    @UnsupportedWithConfigurationCache(because = "taskGraph.afterTask")
    def "new build should be triggered when input files to tasks are changed after each task has been executed, but before the build has completed (changed: #changingInput)"() {
        given:
        ['a', 'b', 'c', 'd'].each { file(it).createDir() }

        when:
        buildFile << """
            task a {
              inputs.dir "a"

dependencies {
    rejectConfig "org.sample:api:1.+"
}
// end::reject-version-1-1[]

tasks.register('printRejectConfig') {
    FileCollection rejectConfig = configurations.rejectConfig
    doLast {
        rejectConfig.each { println "Resolved: ${it.name}" }
    }
}

// tag::component-selection-with-metadata[]
configurations {
    metadataRulesConfig {
        resolutionStrategy {
            componentSelection {

2. <<nameddomainobjectset,`NamedDomainObjectSet<T>`>>: A specialization of `DomainObjectSet` where each object has a unique name associated with it. This is often used for collections where each element needs to be uniquely identified by a name.

     * @param name The name.
     * @param ruleSource A rule source class.
     */
    void named(String name, Class<? extends RuleSource> ruleSource);

    /**
     * Applies the given action to each item in this collection, as each item is required.
     *
     * <p>The given action is invoked to configure the item when the item is required. It is called before any actions provided to {@link #create(String, org.gradle.api.Action)}.
     *

        [":", ":foo", ":foo:bar"].each { projectPath ->
            getGenerationTaskNames(projectPath).each { taskName ->
                result.assertTaskOrder(getCleanTaskName(taskName), taskName)
            }
        }
    }

    def assertGenerationTasksRunBeforeCleanTasks() {
        [":", ":foo", ":foo:bar"].each { projectPath ->
            getGenerationTaskNames(projectPath).each { taskName ->

// CHECK:            input_arg
// CHECK:              type: DT_RESOURCE
// CHECK:            output_arg
// CHECK:              type: DT_RESOURCE
// CHECK:          ret

// Check _resource_arg_unique_id for each argument. Since they alias each other,
// both values are 0.
// CHECK:          arg_attr
// CHECK-NEXT:       key: 0
// CHECK-NEXT:       value
// CHECK:             key: "_resource_arg_unique_id"
// CHECK-NEXT:        value

                    }
                }
            """
        }

        ('a'..'z').each {
            createDirs(it)
            settingsFile << "include '$it'\n"
            file("${it}/build.gradle") << """
                apply plugin: 'java-library'
            """
            ['project1', 'project2'].each { downstream ->
                file("$downstream/build.gradle") << """
                    dependencies {

            server.expectConcurrent(it)
        }
        configurationCacheRun ":finalized:task", "--parallel"
        configurationCache.assertStateStored()

        and: "unrequested finalizer dependencies not to run in parallel when loading the graph"
        [":finalized:dep", ":finalized:task", ":finalizer:dep", ":finalizer:task"].each {
            server.expectConcurrent(it)