}

    requirements {
        // These tests are usually heavy and the build time is twice on EC2 agents
        requiresNotEc2Agent()
    }

    applyTestDefaults(
        model = model,
        buildType = this,
        gradleTasks = ":smoke-ide-test:smokeIdeTest",
        extraParameters = buildScanTag("SmokeIdeTests"),
    )
}) {
    companion object {

        <title>Properties</title>
        <table>
            <thead>
                <tr>
                    <td>Name</td>
                </tr>
            </thead>
            <tr>
                <td>buildType</td>
            </tr>
            <tr>
                <td>flavor</td>
            </tr>
            <tr>
                <td>targetPlatform</td>
            </tr>
            <tr>

     * Specifies the names of one or more {@link Flavor}s that this component should be built for.
     */
    void targetFlavors(String... flavorSelectors);

    /**
     * Specifies the names of one or more {@link BuildType}s that this component should be built for.
     */
    void targetBuildTypes(String... buildTypeSelectors);

     *
     * <p>Contributes the following services:</p>
     * <ul>
     *     <li>{@link org.gradle.api.internal.BuildType}</li>
     *     <li>{@link BuildModelParameters}</li>
     *     <li>{@link BuildActionModelRequirements}</li>
     * </ul>
     */
    Supplier servicesForBuildTree(BuildActionModelRequirements actionModelRequirements);

            @Override
            public Collection<String> getClassNames() {
                return classContentByName.keySet();
            }

            @Override
            public void buildType(String className, TypeSpec.Builder builder) {
                classContentByName.get(className).accept(builder);
            }

            @Override
            public List<CallInterceptionRequest> getCoveredRequests() {

        given:
        buildFile << """
            def buildType = Attribute.of("buildType", String)
            def flavor = Attribute.of("flavor", String)
            allprojects {
                dependencies.attributesSchema.attribute(buildType)
                dependencies.attributesSchema.attribute(flavor)
            }

            project(':lib') {

        this.dimensions = dimensions.withDefault { VariantDimension.missing(it) }
    }

    VariantDimension getBuildType() {
        return dimensions.get("buildType")
    }

    VariantDimension getOs() {
        return dimensions.get("os")
    }

    String getAsPath() {
        if (dimensions.isEmpty()) {
            return ''
        }

                CanGenerateClasses generateType = (CanGenerateClasses) result;
                getOriginatingElements(generateType.getCoveredRequests()).forEach(builder::addOriginatingElement);
                generateType.buildType(canonicalClassName, builder);
                TypeSpec generatedType = builder.build();
                JavaFile javaFile = JavaFile.builder(className.packageName(), generatedType).indent("    ").build();
                try {

                        "org.gradle.docs.samples.Bucket3SnippetsTest=docsTest"
                    )
                )
            )
        }

        docsTests.forEach(this::buildType)
    }
}

class DocsTestTrigger(model: CIBuildModel, docsTestProject: DocsTestProject) : BaseGradleBuildType(init = {
    id("${asDocsTestId(model, docsTestProject.os)}_Trigger")

        failure.assertHasCause("No shared library binary available for library 'hello' with [flavor: 'german', platform: '${NativePlatformsTestFixture.defaultPlatformName}', buildType: 'debug']")
    }

    def "fails with reasonable error message when trying to target an unknown flavor"() {
        when:
        buildFile << """
model {
    components {