private final ImmutableAttributes targetVariantAttributes;
        private final ImmutableCapabilities capabilities;

        public CalculateArtifacts(ComponentIdentifier ownerId, ResolvedArtifactSet delegate, ImmutableAttributes targetVariantAttributes, ImmutableCapabilities capabilities, ImmutableList<BoundTransformStep> steps) {
            this.ownerId = ownerId;
            this.delegate = delegate;

        final List<Capability> capabilities;

        RemoteVariant(
            String name,
            List<Attribute> attributes,
            AvailableAt availableAt,
            List<Capability> capabilities
        ) {
            this.name = name;
            this.attributes = attributes;
            this.availableAt = availableAt;
            this.capabilities = capabilities;
        }
    }

        private final AttributeContainer attributes;
        private final Set<? extends Capability> capabilities;

        private VariantIdentity(AttributeContainer attributes, Set<? extends Capability> capabilities) {
            this.attributes = attributes;
            this.capabilities = capabilities;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) {

                    outgoing {
                        // Force identical capabilities as the default
                        capability('org.gradle:sample:1.0')
                    }
                }
            }""".stripIndent()

        succeeds("outgoingVariants")
        expect:

// empty container defaults.  Used for testing.
func ValidSecurityContextWithContainerDefaults() *v1.SecurityContext {
	priv := false
	defProcMount := v1.DefaultProcMount
	return &v1.SecurityContext{
		Capabilities: &v1.Capabilities{},
		Privileged:   &priv,
		ProcMount:    &defProcMount,
	}
}

// ValidInternalSecurityContextWithContainerDefaults creates a valid security context provider based on

                doLast {
                    def capabilities = result.get().dependencies.first().resolvedVariant.capabilities
                    assert capabilities.size() == 1
                    assert capabilities.first().group == "com"
                    assert capabilities.first().name == "final"
                }
            }
        """

        expect:

    }

    @Override
    public void capability(Object notation) {
        if (canCreate) {
            if (capabilities == null) {
                capabilities = domainObjectCollectionFactory.newDomainObjectSet(Capability.class);
            }
            if (notation instanceof Provider) {
                capabilities.addLater(((Provider<?>) notation).map(capabilityNotationParser::parseNotation));
            } else {

        super(context.getConfig(), SMB2_SESSION_SETUP);
        this.securityMode = securityMode;
        this.capabilities = capabilities;
        this.previousSessionId = previousSessionid;
        this.token = token;
    }


    @Override
    protected Smb2SessionSetupResponse createResponse ( CIFSContext tc, ServerMessageBlock2Request<Smb2SessionSetupResponse> req ) {

            return ImmutableCapabilities.EMPTY;
        }
        ImmutableSet.Builder<ImmutableCapability> capabilities = ImmutableSet.builderWithExpectedSize(size);
        for (int i = 0; i < size; i++) {
            capabilities.add(capabilitySerializer.read(decoder));
        }
        return new ImmutableCapabilities(capabilities.build());
    }

    @Override

    private final AttributeContainer attributes;
    private final ImmutableCapabilities capabilities;

    public ComponentVariantIdentifier(ComponentIdentifier componentId, AttributeContainer attributes, ImmutableCapabilities capabilities) {
        this.componentId = componentId;
        this.attributes = attributes;
        this.capabilities = capabilities;
    }

    public ComponentIdentifier getComponentId() {
        return componentId;