module.ivyFile.text = "<ivy-module>"

        when:
        module.ivy.expectGet()

        then:
        fails "checkDeps"
        failedResolve.assertFailurePresent(failure)
        failure
            .assertResolutionFailure(":compile")
            .assertHasCause("Could not parse Ivy file ${module.ivy.uri}")
            .assertHasCause("invalid version null")
    }

        module.pomFile.text = "<project/>"

        when:
        module.pom.expectGet()

        then:
        fails "checkDeps"
        failedResolve.assertFailurePresent(failure)
        failure.assertResolutionFailure(":compile")
            .assertHasCause("Could not parse POM ${module.pom.uri}")
            .assertHasCause("Missing required attribute: groupId")
    }

        server.allowGetOrHead('/repo/group/projectA/1.2/ivy-1.2.xml', 'username', 'password', module.ivyFile)

        then:
        fails 'checkDeps'

        and:
        failedResolve.assertFailurePresent(failure)
        failure
            .assertResolutionFailure(':compile')
            .assertThatCause(CoreMatchers.containsString('Received status code 401 from server: Unauthorized'))

        where:

            dependencies {
                components {
                    all(WrongRule)
                }
            }
        """

        expect:
        fails 'checkDeps'
        resolve.assertFailurePresent(failure)
        failure.assertHasFileName("Build file '$buildFile.path'")
        failure.assertHasLineNumber(lines + 3)

            dependencies { compile 'org.group.name:projectA:1.2' }
        """
        failedResolve.prepare()

        when:

        fails 'checkDeps'
        then:
        failedResolve.assertFailurePresent(failure)
        failure.assertHasCause("Could not resolve all files for configuration ':compile'.")
        failure.assertHasCause("Could not resolve org.group.name:projectA:1.2.")

        failedResolve.prepare()

        when:
        module.allowAll()

        then:
        executer.withStackTraceChecksDisabled()
        fails('checkDeps')

        and:
        failedResolve.assertFailurePresent(failure)
        failure.assertHasCause("Could not GET '$server.uri")
        failure.assertThatCause(
            allOf(
                anyOf(

                        doLast {
                            configurations.${config}.resolve()
                        }
                    }
                }
            }
        """
    }

    void assertFailurePresent(ExecutionFailure failure) {
        if (GradleContextualExecuter.configCache) {
            failure.assertHasDescription("Configuration cache state could not be cached")
        } else {

        m1.allowAll()
        m2.allowAll()
        m3.pom.expectGetBroken()
        m4.allowAll()

        when:
        fails "checkDeps"

        then:
        failedResolve.assertFailurePresent(failure)
        def op = operations.first(ResolveConfigurationDependenciesBuildOperationType)
        op.details.configurationName == "compileClasspath"
        op.details.projectPath == ":"

    }
}
"""
        resolve.prepare()

        when:
        executer.withArguments("--offline")

        then:
        fails 'checkDeps'

        and:
        resolve.assertFailurePresent(failure)
        failure.assertResolutionFailure(":compile")
            .assertHasCause('No cached version of org.name:projectA:1.2 available for offline mode')
    }

                conf("${build.group}:${build.buildName}")
            }
        """
        fixture.prepare("conf")

        then:
        fails("checkDeps")
        fixture.assertFailurePresent(failure)
        failureCauseContains("Cannot resolve external dependency com.example:included-build")
    }