private final String variantName;

    public ComponentVariantNodeIdentifier(ComponentIdentifier componentId, String variantName) {
        this.componentId = componentId;
        this.variantName = variantName;
    }

    @Override
    public String toString() {
        return componentId.getDisplayName() + ":" + variantName;
    }

    @Override
    public boolean equals(Object o) {

        def expectedVariants = [] as TreeSet
        features.each { feature ->
            expectedVariants.addAll([variantName(feature, 'apiElements'), variantName(feature, 'runtimeElements')])
            if (withDocumentation) {
                expectedVariants.addAll([variantName(feature, 'javadocElements'), variantName(feature, 'sourcesElements')])
            }
        }

    private Set<ResolvedArtifact> allModuleArtifactsCache;

    public DefaultResolvedDependency(String variantName, ModuleVersionIdentifier moduleVersionId, BuildOperationExecutor buildOperationProcessor) {
        this.moduleVersionId = moduleVersionId;
        this.variantName = variantName;
        this.buildOperationProcessor = buildOperationProcessor;
        this.moduleArtifacts = new LinkedHashSet<>();
    }

        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

        resolutionStrategy.capabilitiesResolution {
          withCapability("com.google.guava:guava") {
            candidates
              .find {
                val variantName = it.javaClass.getDeclaredMethod("getVariantName")
                (variantName.invoke(it) as String).contains("android")
              }
              ?.apply { select(this) }
          }
        }
      }
    }

) : Codec<TransformingAsyncArtifactListener.TransformedArtifact> {
    override suspend fun WriteContext.encode(value: TransformingAsyncArtifactListener.TransformedArtifact) {
        write(value.variantName)
        write(value.target)
        writeCollection(value.capabilities.asSet())
        write(value.artifact.id.componentIdentifier)
        write(value.artifact.file)

    }

    public void resolvedDependency(final Long id, ModuleVersionIdentifier moduleVersionId, String variantName) {
        binaryStore.write(encoder -> {
            encoder.writeByte(NODE);
            encoder.writeSmallLong(id);
            moduleVersionIdSerializer.write(encoder, moduleVersionId);
            encoder.writeString(variantName);
        });
    }

    public void done(final Long id) {

        val variantName = readString()
        val identifier = readNonNull<VariantResolveMetadata.Identifier>()
        val attributes = readNonNull<ImmutableAttributes>()
        val artifacts = readList {
            readNonNull<PublishArtifactLocalArtifactMetadata>()
        }
        val displayName = Describables.of(variantName)

        elements.add(failure)
    }

    override fun visitArtifact(variantName: DisplayName, variantAttributes: AttributeContainer, capabilities: ImmutableCapabilities, artifact: ResolvableArtifact) {
        if (artifacts.add(artifact)) {
            elements.add(FixedFileArtifactSpec(artifact.id, variantAttributes, capabilities, variantName, artifact.file))
        }
    }