then:
        single(toolChains).name == 'tc'
        platforms.size() == 1
        single(buildTypes).name == 'bt'
        single(flavors).name == 'flavor1'
    }

    def "creates binaries for executable"() {
        when:
        project.pluginManager.apply(NativeComponentModelPlugin)
        registry
            .mutate(NativeToolChainRegistry) { it.add toolChain("tc") }

    final flavor = new DefaultFlavor("flavor1")
    def flavors = new DefaultFlavorContainer(TestUtil.instantiatorFactory().decorateLenient(), CollectionCallbackActionDecorator.NOOP)
    def exe = Mock(NativeExecutableSpec) {
        getFlavors() >> flavors
    }
    def lib = Mock(NativeLibrarySpec) {
        getFlavors() >> flavors
    }
    def platform = Mock(NativePlatform)

                        def flavor = Attribute.of('flavor', String)
                        p.dependencies.attributesSchema {
                           attribute(buildType)
                           attribute(usage)
                           attribute(flavor)
                        }
                        def buildTypes = ['debug', 'release']
                        def flavors = ['free', 'paid']

	}

	// Choose a random "slice" from a pie
	totalSlices := 0
	for _, flavor := range codes {
		totalSlices += flavor.slices
	}
	// nolint: gosec
	// Test only code
	slice := rand.Intn(totalSlices)

	// What flavor is that slice?
	responseCode := codes[len(codes)-1].httpResponseCode // Assume the last slice
	position := 0
	for n, flavor := range codes {
		if position > slice {

                    c1 { attributes { attribute(flavor, objects.named(Flavor, 'preview')); $debug } }
                    c2 { attributes { attribute(flavor, objects.named(Flavor, 'preview')); $release } }
                    c3 { attributes { attribute(flavor, objects.named(Flavor, 'full')); $debug } }
                    c4 { attributes { attribute(flavor, objects.named(Flavor, 'full')); $release } }
                }

        app.library.writeSources(file("libs/src/hello"))

        file("libs/build.gradle") << """
apply plugin: 'cpp'
model {
    flavors {
        english
        french
    }
    components {
        hello(NativeLibrarySpec) {
            binaries.all {
                if (flavor == flavors.french) {
                    cppCompiler.define "FRENCH"
                }
            }
        }
    }
}
"""
    }

            version = '2.0-SNAPSHOT'

            def flavor = Attribute.of('flavor', $type)
            dependencies {
                attributesSchema {
                    attribute(flavor)
                }
            }

            configurations {
                foo.attributes { attribute(flavor, $freeValue) }
                bar.attributes { attribute(flavor, $paidValue) }
            }

        def attr = Attribute.of(Flavor)

        given:
        schema.attribute(attr).disambiguationRules.add(CustomSelectionRule)

        def value1 = flavor('value1')
        def value2 = flavor('value2')

        def candidates = [value1, value2] as Set

        when:
        def best = schema.matcher().selectionSchema.disambiguate(attr, flavor('requested'), candidates)

        then:

                def distinguishingValues = distinguisher == 'flavor' ? "\n  - Value: 'paid' selects variant: 'bar'\n  - Value: 'free' selects variant: 'foo'" : "\n  - Value: 'bar' selects variant: 'bar'\n  - Value: 'foo' selects variant: 'foo'"

            }

            def flavor = Attribute.of('flavor', String)

            configurations {
                custom {
                    description = "My custom configuration"
                    assert canBeResolved
                    canBeConsumed = false

                    attributes {
                        attribute(flavor, 'vanilla')
                    }
                }