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 {

        buildFile << """
    apply plugin: 'cpp'
    apply plugin: 'visual-studio'

    model {
        platforms {
            win32 {
                architecture "i386"
            }
        }
        buildTypes {
            debug
            release
        }
        components {
            main(NativeExecutableSpec)
        }
    }
"""
    }

    @Requires(IntegTestPreconditions.IsEmbeddedExecutor)

                        architecture "i386"
                    }
                    x64 {
                        architecture "amd64"
                    }
                }
                buildTypes {
                    debug
                    release
                }
                components {
                    all {
                        targetPlatform "win32"

        def conf = conf()
        def flavor = Attribute.of('flavor', Flavor) // give it a name and a type
        def buildType = Attribute.of(BuildType) // infer the name from the type

        when:
        conf.getAttributes().attribute(flavor, new FlavorImpl(name: 'free'))
        conf.getAttributes().attribute(buildType, new BuildTypeImpl(name: 'release'))

        then:
        !conf.attributes.isEmpty()

            allprojects {
                apply plugin: 'visual-studio'
            }
            subprojects {
                apply plugin: 'cpp'

                model {
                    buildTypes {
                        debug
                        release
                    }
                }
            }
        """
    }

    @ToBeFixedForConfigurationCache

                }
                compileOptions {
                    sourceCompatibility JavaVersion.VERSION_1_8
                    targetCompatibility JavaVersion.VERSION_1_8
                }
                buildTypes {
                    release {
                        minifyEnabled false
                    }
                }
            }
        """.stripIndent()
    }

    @Override