when:
        run(":printTestSoftwareTypeExtensionConfiguration")

        then:
        assertThatDeclaredValuesAreSetProperly()
    }

    def 'sensible error when model types do not match in software type declaration'() {
        given:
        withSoftwareTypePluginWithMismatchedModelTypes().prepareToExecute()

            executer.withTasks("b", "a").withArguments("-x", ":a").run().assertTasksExecuted(":b", ":sub:a")
        }
    }

    def "sensible error message for circular task dependency"() {
        buildFile << """
            task a(dependsOn: 'b')
            task b(dependsOn: 'a')
        """
        expect:
        2.times {

// SignPSS calculates the signature of digest using PSS.
//
// digest must be the result of hashing the input message using the given hash
// function. The opts argument may be nil, in which case sensible defaults are
// used. If opts.Hash is set, it overrides hash.
//
// The signature is randomized depending on the message, key, and salt size,
// using bytes from rand. Most applications should use [crypto/rand.Reader] as

        when:
        run "projects"
        then:
        outputDoesNotContain("Included builds")
    }

    def "rendering long project descriptions is sensible"() {
        settingsFile << "rootProject.name = 'my-root-project'"
        buildFile << """
            description = '''
this is a long description

this shouldn't be visible
            '''
        """

// Make is a convenience wrapper for Parse that omits the error.
// In case of an error, a sensible default is returned.
func Make(s string) Tag {
	return Default.Make(s)
}

// Make is a convenience wrapper for c.Parse that omits the error.
// In case of an error, a sensible default is returned.
func (c CanonType) Make(s string) Tag {
	t, _ := c.Parse(s)
	return t
}

        "everything has convention and is set"             | setAll("convention", "convention") | setAll("test", "baz") | """id = test\nbar = baz"""
    }

    def "sensible error when conventions are set more than once (#testCase)"() {
        given:
        withSoftwareTypePlugins().prepareToExecute()

     *
     * Note that "default value" is not related to the convention value, though they are easy to confuse.
     * A default value is a fallback value that is sensible to the caller, in the absence of the explicit value.
     * The default value is not related in any way to the convention value.
     *
     * @param value the current explicit value
     * @param defaultValue the default value

Nie wieder falsche Schlüsselnamen tippen, Hin und Herhüpfen zwischen der Dokumentation, Hoch- und Runterscrollen, um herauszufinden, ob es `username` oder `user_name` war.

### Kompakt

Es gibt für alles sensible **Defaultwerte**, mit optionaler Konfiguration überall. Alle Parameter können feinjustiert werden, damit sie tun, was Sie benötigen, und die API definieren, die Sie brauchen.

Aber standardmäßig **„funktioniert einfach alles“**.

        modelNode.father.father.size() == 1
        modelNode.father.father[0].type == "Person"
        modelNode.father.father[0].nodeValue == "reference to element 'father'"
    }

    def "renders sensible value for node whose toString() method returns null"() {
        given:
        buildFile << """
            @Managed abstract class SomeType {
                String toString() { null }
            }

        run 'copy'

        then:
        assertDestinationFilePermissions("rw-r--r--")
    }

    @Requires(UnitTestPreconditions.FilePermissions)
    def "permissions block sets sensible defaults"() {
        given:
        withSourceFiles("r--------")
        buildScript '''
            task (copy, type:Copy) {
               from 'files'
               into 'dest'
               eachFile {