def "can build javadoc from modularized java with exclusions"() {
        testBuildFile << """
            tasks.withType(Javadoc) {
                exclude("test/internal")
                // This shouldn't be necessarily, but is a workaround for now
                options.addPathOption('-source-path').value.add(file('src/main/java'))
            }
        """

        when:
        succeeds("javadoc")
        then:

!!! warning
    Extra keys passed to `Field` will also be present in the resulting OpenAPI schema for your application.
    As these keys may not necessarily be part of the OpenAPI specification, some OpenAPI tools, for example [the OpenAPI validator](https://validator.swagger.io/), may not work with your generated schema.

## Recap

     */
    public val defaultExpressionInfo: DefaultExpressionInfo?,

    /**
     * A list of expressions that return a value.
     *
     * Returned expressions are not necessarily [KtReturnExpression]s.
     * For instance, implicit return from a lambda can be an arbitrary expression.
     */
    public val valuedReturnExpressions: List<KtExpression>,

    /**

    override fun create(target: BuildState): Any {
        // Make sure the project tree has been loaded and can be queried (but not necessarily configured)
        target.ensureProjectsLoaded()

        val schemaBuilder = GradleProcessInterpretationSchemaBuilder(softwareTypeRegistry)

        val settings = target.mutableModel.settings

assert contacts() == null
assert contacts("a") == "a"
"""

        expect:
        succeeds()
    }

    // Documents actual behaviour for backwards compatibility, not necessarily desired behaviour
    @Requires(
        value = IntegTestPreconditions.NotIsolatedProjects,
        reason = "Exercises IP incompatible behavior: Groovy method inheritance"
    )

       */
      return;
    }

    /*
     * Only under Windows (or hypothetically when running with some other non-POSIX, ACL-based
     * filesystem) does our prod code look up the username. Thus, this test doesn't necessarily test
     * anything interesting under most environments. Still, we can run it (except for Android, at
     * least old versions), so we mostly do. This is useful because we don't actually run our CI on

        fails ':a:pingServer'

        then:
        failure.assertHasCause('b failed')
        failure.assertHasCause('c failed')
    }

    def "tasks are executed when they are ready and not necessarily alphabetically"() {
        buildFile << """
            tasks.getByPath(':b:pingA').dependsOn(':a:pingA')
            tasks.getByPath(':b:pingC').dependsOn([':b:pingA', ':b:pingB'])
        """

        expect:

function in the Istio control plane without necessarily being tied to any one component that runs in a Deployment.
Component settings are those that necessarily refer to a particular Deployment or Service. For example, the number
of Pilot replicas is a component setting, because it refers to a component which is a Deployment in the
cluster. Most K8s platform settings are necessarily component settings.

            }
        }
    }

    private static boolean isPresent(@Nullable Object value) {
        if (value instanceof Provider) {
            // carefully check for presence without necessarily resolving
            return ((Provider<?>) value).isPresent();
        }
        return value != null;
    }

    private static boolean hasConfigurableValue(@Nullable Object value) {

            return model;
        }
        model = new DefaultGradleBuild();
        all.put(targetBuild, model);

        // Make sure the project tree has been loaded and can be queried (but not necessarily configured)
        targetBuild.ensureProjectsLoaded();

        GradleInternal gradle = targetBuild.getMutableModel();
        addProjects(targetBuild, model);
        addIncludedBuilds(gradle, model, all);