},
		})
	}
	if f.expansionSet {
		resp.Capabilities = append(resp.Capabilities, &csipb.NodeServiceCapability{
			Type: &csipb.NodeServiceCapability_Rpc{
				Rpc: &csipb.NodeServiceCapability_RPC{
					Type: csipb.NodeServiceCapability_RPC_EXPAND_VOLUME,
				},
			},
		})
	}

	if f.volumeStatsSet {
		resp.Capabilities = append(resp.Capabilities, &csipb.NodeServiceCapability{

            artifacts = ImmutableList.of();
            return this;
        }

        Builder withCapabilities(ImmutableCapabilities capabilities) {
            this.capabilities = capabilities;
            return this;
        }

        public DefaultConfigurationMetadata build() {
            return new DefaultConfigurationMetadata(
                    getComponentId(),

    /**
     * @return the shareFlags
     */
    public int getShareFlags () {
        return this.shareFlags;
    }


    /**
     * @return the capabilities
     */
    public int getCapabilities () {
        return this.capabilities;
    }


    /**
     * @return the maximalAccess
     */
    public int getMaximalAccess () {
        return this.maximalAccess;
    }

            write(value.attributes)
            writeCollection(value.capabilities.asSet())
        }
    }

    override suspend fun ReadContext.decode(): ComponentVariantIdentifier {
        return decodePreservingSharedIdentity {
            val componentId = readNonNull<ComponentIdentifier>()
            val attributes = readNonNull<ImmutableAttributes>()
            val capabilities: List<Capability> = readList().uncheckedCast()

		runner:              runner,
		unsupportedCommands: []string{},
	}

	// Initialize the plugin and probe the capabilities
	call := flexPlugin.NewDriverCall(initCmd)
	ds, err := call.Run()
	if err != nil {
		return nil, err
	}
	flexPlugin.capabilities = *ds.Capabilities

	if flexPlugin.capabilities.Attach {
		// Plugin supports attach/detach, so return flexVolumeAttachablePlugin

        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 9080
        securityContext:
          allowPrivilegeEscalation: false
          capabilities:
            drop:
              - all
          runAsNonRoot: true
---
##################################################################################################
# Ratings service

                capabilities = ImmutableCapabilities.EMPTY;
                dependencies = ImmutableList.of();
                dependencyConstraints = ImmutableList.of();
                files = ImmutableList.of();
                isExternalVariant = false;
            } else {
                attributes = baseVariant.getAttributes();
                capabilities = baseVariant.getCapabilities();

 *
 */
public class ValidateNegotiateInfoResponse implements Decodable {

    private int capabilities;
    private byte[] serverGuid = new byte[16];
    private int securityMode;
    private int dialect;


    /**
     * @return the capabilities
     */
    public int getCapabilities () {
        return this.capabilities;
    }


    /**
     * @return the serverGuid
     */

func TestHandleResponseDefaults(t *testing.T) {
	ds, err := handleCmdResponse("test", []byte(`{"status": "Success"}`))
	if err != nil {
		t.Error("error: ", err)
	}

	if *ds.Capabilities != *defaultCapabilities() {
		t.Error("wrong default capabilities: ", *ds.Capabilities)
	}

            DisplayName displayName = variant.asDescribable();
            ImmutableCapabilities capabilities = withImplicitCapability(variant.getCapabilities(), component);
            return new ArtifactBackedResolvedVariant(identifier, displayName, attributes, capabilities, artifacts, new DefaultComponentArtifactResolver(component, artifactResolver));
        } else {