>     - parent.p3 Integer
>   inputs:
>     - parent.p4 Number [*]
>         suggestions: parent.p31, parent.p32
>     - <no path> Number [*]
>     - parent.p6 Number

[*] - indicates that a model item could not be found for the path or type.
""")
    }

        e.cause instanceof IllegalArgumentException
        e.cause.message == "Could not find any public constructor for ${SomeType} which accepts parameters [java.lang.Object]."

        when:
        instantiator.newInstance(SomeType, "a", "b")

        then:
        e = thrown()
        e.cause.message == "Could not find any public constructor for ${SomeType} which accepts parameters [java.lang.String, java.lang.String]."

        when:
        executer.withStackTraceChecksDisabled()
        withBuildCache().run "customTask"

        then:
        output =~ /Could not store entry .* in remote build cache: ${errorPattern}/
    }

    def "build does not fail if connection repeatedly drops during store"() {
        // For every write, read some of the data and then close the connection

        then:
        failure.assertHasFailure("Configuration cache state could not be cached: field `files` of `Bean` bean found in field `__bean__` of task `:test` of type `Test`: error writing value of type 'org.gradle.api.internal.artifacts.configurations.DefaultUnlockedConfiguration'") {
            it.assertHasFirstCause("Could not resolve all files for configuration ':implementation'.")
        }
    }

        and:
        factory.graphPopulated(null)

        then:
        def e = thrown(ProjectConfigurationException)
        e.message == 'Credentials required for this build could not be resolved.'
        e.causes.size() == 2
    }

    def "evaluates name and value of header credentials provider"() {
        given:

        context.getDependencies(task, dependency)

        then:
        1 * dependency.visitDependencies(_) >> { throw failure }
        def e = thrown(TaskDependencyResolveException)
        e.message == "Could not determine the dependencies of $task."
        e.cause == failure
    }

    def failsWhenThereIsACyclicDependency() {
        throw new UnsupportedOperationException()
    }

            }.get()

        '''

        expect:
        fails()

        and:
        // TODO(mlopatkin) The error message can be improved.
        failureHasCause(~/Could not isolate value ResultSource(.*) of type ResultSource.Params/)
    }

    def "task cannot depend on buildWorkResult, fails with clear message and problem is reported"() {
        given:
        buildFile '''

    def "class should not have any instance fields"() {
        when:
        factory.named(NamedWithFields, "a")

        then:
        def e = thrown(ObjectInstantiationException)
        e.message == "Could not create an instance of type ${NamedWithFields.name}."
        e.cause.message == """Type ${NamedWithFields.name} is not a valid Named implementation class:

    }

    def "fails when base parameters type is used"() {
        when:
        scheme.parameterTypeFor(BaseParams)

        then:
        def e = thrown(IllegalArgumentException)
        e.message == "Could not create the parameters for BaseParams: must use a sub-type of SomeParams as the parameters type. Use Nothing as the parameters type for implementations that do not take parameters."
    }

        1 * obj1.tryGetProperty("p") >> DynamicInvokeResult.notFound()
        1 * obj2.tryGetProperty("p") >> DynamicInvokeResult.notFound()
        1 * obj3.tryGetProperty("p") >> DynamicInvokeResult.notFound()
        e.message == "Could not get unknown property 'p' for <obj>."
    }

    def "set property returns on first delegate that has the property"() {
        def obj1 = Mock(DynamicObject)
        def obj2 = Mock(DynamicObject)