*/}}
{{- define "minio.networkPolicy.apiVersion" -}}
  {{- if semverCompare ">=1.4-0, <1.7-0" .Capabilities.KubeVersion.Version -}}
    {{- print "extensions/v1beta1" -}}
  {{- else if semverCompare ">=1.7-0, <1.16-0" .Capabilities.KubeVersion.Version -}}
    {{- print "networking.k8s.io/v1beta1" -}}
  {{- else if semverCompare "^1.16-0" .Capabilities.KubeVersion.Version -}}
    {{- print "networking.k8s.io/v1" -}}
  {{- end -}}
{{- end -}}

            }

            dependencies {
                twoImplementation(project(':shared')) {
                    capabilities {
                        requireCapability('g:one:v')
                    }
                }
                twoPrefImplementation(project(':shared')) {
                    capabilities {
                        requireCapability('g:one-preferred:v')
                    }
                }
            }

            ImmutableAttributes componentLevelAttributes,
            ImmutableCapabilities capabilities,
            boolean addedByRule,
            boolean externalVariant
    ) {
        this(componentId, name, transitive, visible, hierarchy, artifacts, excludes, componentLevelAttributes, capabilities, null, addedByRule, externalVariant);
    }

    public RealisedConfigurationMetadata(

				continue
			}
		}

		// Capabilities
		{
			modifiedSC := nonNilSC(tc.newSC())
			m := NewContainerSecurityContextMutator(tc.newSC())
			modifiedSC.Capabilities = &api.Capabilities{Drop: []api.Capability{"test2"}}
			m.SetCapabilities(&api.Capabilities{Drop: []api.Capability{"test2"}})
			if !reflect.DeepEqual(m.ContainerSecurityContext(), modifiedSC) {

        this.name = name
        this.attributes = attributes
        this.dependencies = dependencies
        this.dependencyConstraints = dependencyConstraints
        this.artifacts = artifacts
        this.capabilities = capabilities
        this.availableAt = availableAt
    }

import com.google.common.collect.ImmutableSet;
import org.gradle.api.InvalidUserDataException;
import org.gradle.api.capabilities.CapabilitiesMetadata;
import org.gradle.api.capabilities.Capability;
import org.gradle.api.capabilities.MutableCapabilitiesMetadata;
import org.gradle.api.internal.capabilities.ImmutableCapability;

import java.util.LinkedHashSet;
import java.util.Set;

/**

                    }
                    capabilities {
                        requireCapability('org.test:cap1')
                    }
                }
                conf('org:test:1.0') {
                    attributes {
                        attribute(CUSTOM2_ATTRIBUTE, 'c2')
                    }
                    capabilities {
                        requireCapability('org.test:cap2')

		Role:  opts.Role,
		Type:  opts.Type,
		Level: opts.Level,
	}
}

// convertToRuntimeCapabilities converts v1.Capabilities to runtimeapi.Capability.
func convertToRuntimeCapabilities(opts *v1.Capabilities) *runtimeapi.Capability {
	if opts == nil {
		return nil
	}

	capabilities := &runtimeapi.Capability{
		AddCapabilities:  make([]string, len(opts.Add)),
		DropCapabilities: make([]string, len(opts.Drop)),
	}

        if (sourceSet == null) {
            throw new InvalidUserCodeException("You must specify which source set to use for feature '" + name + "'");
        }

        if (capabilities.isEmpty()) {
            capabilities.add(new ProjectDerivedCapability(project, name));
        }

        if (SourceSet.isMain(sourceSet)) {

        }
    }

    private void writeCapabilities(String key, List<ModuleMetadataSpec.Capability> capabilities) throws IOException {
        if (capabilities.isEmpty()) {
            return;
        }
        writeArray(key, () -> {
            for (ModuleMetadataSpec.Capability capability : capabilities) {
                writeObject(() -> {
                    write("group", capability.group);