@Override
    public void writeVariantResult(ResolvedGraphVariant variant, Encoder encoder) throws Exception {
        encoder.writeSmallLong(variant.getNodeId());
        VariantGraphResolveState state = variant.getResolveState();
        if (state.isAdHoc()) {
            writeVariantData(encoder, state);
        } else {
            writeVariantReference(encoder, variant, state);
        }
    }

        when:
        variant.artifacts

        then:
        1 * rule.execute(_)

        when:
        variant.artifacts
        variant.artifacts
        variant.artifacts

        then:
        0 * rule.execute(_)

        where:
        metadataType | metadata
        "maven"      | mavenComponentMetadata()
        "ivy"        | ivyComponentMetadata()

        when:
        run "publish"

        then:
        javaLibrary.parsedModuleMetadata.variant("apiElements") {
            noMoreDependencies()
        }
        javaLibrary.parsedModuleMetadata.variant("runtimeElements") {
            noMoreDependencies()
        }
        javaLibrary.parsedModuleMetadata.variant("optionalFeatureRuntimeElements") {
            dependency('org', 'optionaldep', '1.0')

            getTo() >> to
            getTransformStep() >> Stub(TransformStep)
        }
    }

    private ResolvedVariant variant(Map<String, Object> attributes) {
        return variant(AttributeTestUtil.attributes(attributes))
    }

    private ResolvedVariant variant(AttributeContainerInternal attributes) {
        return Mock(ResolvedVariant) {
            getAttributes() >> attributes
        }
    }

        then:
        javaLibrary.parsedModuleMetadata.variant("apiElements") {
            noMoreDependencies()
        }
        javaLibrary.parsedModuleMetadata.variant("runtimeElements") {
            noMoreDependencies()
        }
        javaLibrary.parsedModuleMetadata.variant("featureApiElements") {
            noMoreDependencies()
        }
        javaLibrary.parsedModuleMetadata.variant("featureRuntimeElements") {

    }

    @Override
    String getIdeBuildTaskName(String variant) {
        return "install${variant.capitalize()}"
    }

    @Override
    List<String> getTasksToBuildFromIde(String variant) {
        return [":compile${variant.capitalize()}Cpp", ":link${variant.capitalize()}", ":install${variant.capitalize()}"]
    }

    @Override
    String getVisualStudioProjectName() {

                }
            }
        }

        where:
        notation << [
            'platform(module("org:lib:1.0"))',
            'variant(platform(module("org:lib:1.0"))) { }',
            'variant(module("org:lib:1.0")) { platform() }',
            'variant(module("org:lib:1.0")) { attributes { attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category, Category.REGULAR_PLATFORM)) } }',
        ]

    }

     * can match this classified dependency to a proper variant.
     */
    def "reasonable behavior when a Maven library uses a classifier to select a Gradle variant"() {
        def gradleLibrary = mavenHttpRepo.module("org", "lib", "1.0")
                .adhocVariants()
                .variant("apiElements", ['org.gradle.usage': Usage.JAVA_API, 'groovy.runtime': 'classic'])

        def differentFrom = factory.createResolvedDependency(selector('requested'), newModule('xxx'), selectedModule, variant, false)
        def differentSelected = factory.createResolvedDependency(selector('requested'), fromModule, newModule('xxx'), variant, false)
        def differentConstraint = factory.createResolvedDependency(selector('requested'), fromModule, selectedModule, variant, true)

        then:
        dep.is(same)

    /**
     * Constructs a complete cacheable variant chain given a root transformed variant and the chain of variants
     * to apply to that root variant.
     *
     * @param stateChain The transform chain from the search state to apply to the root transformed variant.
     * @param root The root variant to apply the chain to.
     *
     * @return A variant chain representing the final transformed variant.
     */