[[groovy:project_object]]
== The `Project` object

As Groovy is an object-oriented language based on Java, its properties and methods apply to objects. In some cases, the object is implicit — particularly at the top level of a build script, i.e. not nested inside a `{}` block.

Consider this fragment of build script, which contains an unqualified property and block:

[source,groovy]
----

   */
  open fun connectionReleased(
    call: Call,
    connection: Connection,
  ) {
  }

  /**
   * Invoked just prior to sending request headers.
   *
   * The connection is implicit, and will generally relate to the last [connectionAcquired] event.
   *
   * This can be invoked more than 1 time for a single [Call]. For example, if the response to the
   * [Call.request] is a redirect to a different address.

        validationContext.visitPropertyProblem(problem ->
            problem.id(TextUtil.screamingSnakeToKebabCase(IMPLICIT_DEPENDENCY), "Property has implicit dependency", GradleCoreProblemGroup.validation().property()) // TODO (donat) missing test coverage
                .contextualLabel("Gradle detected a problem with the following location: '" + consumerProducerPath + "'")

            fun test() {

                // Implicit SAM conversion in regular source
                println(createK(String::class) { it.toUpperCase() })
                println(create("FOO") { it.toLowerCase() })

                // Implicit SAM with receiver conversion in regular source
                applyActionTo("BAR") {
                    println(toLowerCase())

        """

        when:
        run()

        then:
        result.assertTaskExecuted(":included:jar")
        result.assertTaskExecuted(":buildSrc:jar")
    }

    // buildSrc acts like an implicit pluginManagement { } included build
    def "library contributed by buildSrc is not visible to the root build"() {
        writeLibraryTo(file("buildSrc"))

        file("build.gradle") << """

				w.string("interface{comparable}")
				break
			}
		}
		if t.implicit {
			if len(t.methods) == 0 && len(t.embeddeds) == 1 {
				w.typ(t.embeddeds[0])
				break
			}
			// Something's wrong with the implicit interface.
			// Print it as such and continue.
			w.string("/* implicit */ ")
		}
		w.string("interface{")
		first := true
		if w.ctxt != nil {

        }

        DefaultMutableCapabilitiesMetadata mutableCapabilities;
        if (capabilities.asSet().isEmpty()) {
            // we must add the implicit capability here because it is assumed that if there's a rule
            // "addCapability" would effectively _add_ a capability, so the implicit one must not be forgotten
            mutableCapabilities = new DefaultMutableCapabilitiesMetadata(ImmutableCapabilities.of(

        1 * store.put({ it == keyHash }, { it.timestamp == timeProvider.currentTime })
        0 * _
        result.length == 6
    }

    void "can expire entries based on implicit inputs"() {
        withServiceInjectedRule()
        def id = new Id('Alicia')

        def implicitInput = Mock(ImplicitInputRecord)
        def service = Mock(SomeService)

   Cannot select module with conflict on capability 'cglib:cglib:3.2.5' also provided by [cglib:cglib-nodep:3.2.5($variant)]""")
    }

    def "implicit capability conflict is detected if implicit capability is discovered late"() {
        given:
        repository {
            'cglib:cglib:3.2.5'()
            'cglib:cglib-nodep:3.2.5'()
            'org:lib:1.0' {

        if (getDistribution().isSupportsSpacesInGradleAndJavaOpts()) {
            // Mix the implicit launcher JVM args in with the requested JVM args
            super.transformInvocation(invocation);
        } else {
            // Need to move those implicit JVM args that contain a space to the Gradle command-line (if possible)