throw selfReferencingException
        """

        when:
        fails("help", "-s")

        then:
        failureCauseContains("BOOM self")
        result.assertHasErrorOutput("Caused by: java.lang.Throwable: [CIRCULAR REFERENCE: java.lang.Exception: BOOM self]")
    }

              String s1(Integer iDontExist) {
                "foo"
              }
            }

            pluginManager.apply Rules
        """

        then:
        fails "help"
        failureCauseContains("""
  Rules#s1(Integer)
    inputs:
      - <no path> Integer (parameter 1) [*]

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

    }

    def "can not filter specific iterations of unrolled tests"() {
        when:
        fails("test", "--tests", "SubClass.$testMethod")

        then:
        failureCauseContains("No tests found for given includes: [SubClass.$testMethod](--tests filter)")

        where:

                    mavenCentral()
                }
            }
            println("foo project plugin applied")
        """

        then:
        fails("help")
        failureCauseContains("Only Settings scripts can contain a pluginManagement {} block.")
    }

    def "precompiled project plugin can not use buildscript block"() {
        when:
        enablePrecompiledPluginsInBuildSrc()

                        implementationClass = 'com.foo.Bar'
                    }
                }
            }
        """
        expect:
        fails "jar"
        failureCauseContains(String.format(JavaGradlePluginPlugin.DECLARATION_MISSING_ID_MESSAGE, 'helloPlugin'))
    }

    def "Fails if plugin declaration has no implementation class"() {
        given:
        buildFile()

                access {
                    name = "something"
                }
            }
        """

        when:
        fails(":help")

        then:
        failureCauseContains("Boom")
    }

    private String defineSettingsPluginRegisteringSoftwareTypeProvidingPlugin() {
        return """
        package com.example.restricted;

        import org.gradle.api.DefaultTask;

                }
            }

            apply type: Rules
        '''

        then:
        fails "taskWithUnboundRuleSourceApplied"

        and:
        failureCauseContains '''
  UnboundRuleSource#unboundRule(String, Integer, String)
    subject:
      - <no path> String (parameter 1) [*]
          scope: tasks.taskWithUnboundRuleSourceApplied
    inputs:

                }
            }

            configureGradleLifecycle()
        """

        when:
        fails "help"

        then:
        failureCauseContains("cannot serialize object of type '$concreteTypeName'")

        where:
        concreteType                      | baseType         | reference
        // Live JVM state

                foobah {
                }
                fooar {
                }
            }
        '''

        when:
        fails "tasks"

        then:
        failureCauseContains('''
  fooar { ... } @ build.gradle line 20, column 17
    subject:
      - fooar Object [*]
          suggestions: foobar

  foobah { ... } @ build.gradle line 18, column 17
    subject:

        settingsFile << """
            caches {
                ${modifyCacheConfiguration(property, value)}
            }
        """

        expect:
        fails("help")
        failureCauseContains(String.format(DefaultCacheConfigurations.UNSAFE_MODIFICATION_ERROR, errorProperty))

        where:
        property                                           | errorProperty                  | value