private final ImmutableCapabilities capabilities;

    public DefaultCapabilitiesMetadata(ImmutableCapabilities capabilities) {
        this.capabilities = capabilities;
    }

    @Override
    public List<? extends Capability> getCapabilities() {
        return capabilities.asSet().asList();
    }

    private int capabilities;
    private byte[] clientGuid;
    private int securityMode;
    private int dialects[];


    /**
     * @param capabilities
     * @param clientGuid
     * @param securityMode
     * @param dialects
     * 
     */
    public ValidateNegotiateInfoRequest ( int capabilities, byte[] clientGuid, int securityMode, int[] dialects ) {

			return err
		}
	}
	pod.Spec.Containers[0].SecurityContext = &v1.SecurityContext{
		Capabilities: &v1.Capabilities{
			// We drop all capabilities that are added by default.
			Drop: []v1.Capability{"ALL"},
			// kube-apiserver binary has the file capability cap_net_bind_service applied to it.

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.api.capabilities;

/**
 * Describes the capabilities of a component in a mutable way.
 * This interface can be used to adjust the capabilities of a published component via
 * metadata rules (see {@link org.gradle.api.artifacts.dsl.ComponentMetadataHandler}.
 *
 * @since 4.7
 */

     */
    private static class VariantIdentity {
        private final ImmutableAttributes attributes;
        private final ImmutableCapabilities capabilities;

        private VariantIdentity(ImmutableAttributes attributes, ImmutableCapabilities capabilities) {
            this.attributes = attributes;
            this.capabilities = capabilities;
        }

        ]

    }

    def "can substitute a dependency without capabilities with a dependency with capabilities"() {
        mavenRepo.module("org", "lib", "1.0").publish()

        buildFile << """

            repositories {
               maven { url "${mavenRepo.uri}" }
            }

                                        ImmutableCapabilities capabilities,
                                        @Nullable ResolvedVariantResult externalVariant) {
        this.owner = owner;
        this.displayName = displayName;
        this.attributes = attributes;
        this.capabilities = capabilities;
        this.externalVariant = externalVariant;
        this.hashCode = computeHashCode();
    }

        }
        return builder.build();
    }

    private void writeCapabilities(Encoder encoder, Collection<Capability> capabilities) throws IOException {
        encoder.writeSmallInt(capabilities.size());
        for (Capability capability : capabilities) {
            encoder.writeString(capability.getGroup());
            encoder.writeString(capability.getName());

                        def capabilities = it.variant.capabilities
                        if (capabilities.isEmpty()) {
                            throw new IllegalStateException("Expected default capability to be explicit")
                        } else {
                            println "  - capabilities: " + capabilities.collect {

        AttributeContainerInternal attributes,
        ImmutableCapabilities capabilities,
        List<? extends ComponentArtifactMetadata> artifacts,
        ComponentArtifactResolver componentArtifactResolver
    ) {
        this.identifier = identifier;
        this.displayName = displayName;
        this.attributes = attributes;
        this.capabilities = capabilities;
        this.artifacts = artifacts;