project.mainComponent.binaries.size() == 2

        def debugBinary = project.mainComponent.binaries[0]
        debugBinary instanceof CppExecutable
        debugBinary.name == 'mainDebug'
        debugBinary.variantName == 'debug'
        debugBinary.baseName == 'app'
        debugBinary.compilationDetails.sources.sourceFile as Set == [src1, src2] as Set
        debugBinary.compilationDetails.sources.objectFile.each { assert it != null }

        def debugX86Binary = project.mainComponent.binaries[0]
        debugX86Binary instanceof CppExecutable
        debugX86Binary.name == 'mainDebugX86'
        debugX86Binary.variantName == 'debugX86'
        debugX86Binary.baseName == 'app'
        debugX86Binary.compilationDetails.sources.sourceFile as Set == [src1, src2] as Set

    @Shared
        defaultVariant

    protected static <T> VariantMetadataRules.VariantAction<T> variantAction(String variantName, Action<? super T> action) {
        new VariantMetadataRules.VariantAction<T>(variantName, action)
    }

    private DefaultAttributesSchema createSchema() {

        return variantMetadataRules;
    }

    @Override
    public MutableComponentVariant addVariant(String variantName, ImmutableAttributes attributes) {
        return addVariant(new MutableVariantImpl(variantName, attributes));
    }

    @Override
    public MutableComponentVariant addVariant(MutableComponentVariant variant) {
        if (newVariants == null) {

        );
    }

    @Nullable
    @Override
    public <T> T resolveVariant(Class<T> coordsType, Path identityPath, String variantName) {
        return withCoordinateResolver(coordsType, identityPath, resolver ->
            resolver.getVariantCoordinates(variantName)
        );
    }

    /**
     * Execute the action with a resolver for the given project.
     */

                default:
                    consumeAny(reader);
                    break;
            }
        }
        assertDefined(reader, "name", variantName);
        reader.endObject();

        MutableComponentVariant variant = metadata.addVariant(variantName, attributes);
        variant.setAvailableExternally(availableExternally);
        if (availableExternally) {
            if (!dependencyConstraints.isEmpty()) {

            this.version = attrs.version
            this.moduleVersionId = moduleVersionId
            this.id = id
            this.type = type
            if (attrs.variantName) {
                variant(attrs.variantName, attrs.variantAttributes)
            }
            reasons.add('requested')
        }

        Set<ExpectedArtifact> getArtifacts() {

        // Can we change this name without breaking compatibility? Is the variant name part
        // of the component's API?
        String variantName = getSourceSet().getName() + SOURCE_ELEMENTS_VARIANT_NAME_SUFFIX;

        ConsumableConfiguration variant = project.getConfigurations().consumable(variantName).get();
        variant.setDescription("List of source directories contained in the Main SourceSet.");
        variant.setVisible(false);

        final Set<File> files = new LinkedHashSet<>();
        List<Throwable> failures;

        @Override
        public void visitArtifact(DisplayName variantName, AttributeContainer variantAttributes, ImmutableCapabilities capabilities, ResolvableArtifact artifact) {
            try {
                ResolvedArtifact resolvedArtifact = artifact.toPublicView();

            }

            configurations.classpath {
                resolutionStrategy.capabilitiesResolution.all { details ->
                    def selection =
                        details.candidates.find { it.variantName.endsWith('preferred') }
                    println("Selecting \$selection from \${details.candidates}")
                    details.select(selection)
                }
            }

            dependencies {