limitations under the License.
*/

package capabilities

import (
	"sync"
)

// Capabilities defines the set of capabilities available within the system.
// For now these are global.  Eventually they may be per-user
type Capabilities struct {
	AllowPrivileged bool

	// Pod sources from which to allow privileged capabilities like host networking, sharing the host

// This file is a spike of what externally published rules for capabilities could look like.
//
// The idea is that such "rules" could be published, then applied by a plugin.
//
// Whenever two libraries provide the same capability, for example, "log4j" and "log4j-over-slfj4",
// it's illegal to have both of them on the classpath. Use this file to declare that they provide
// the same capability, and that we prefer to use slf4j in this case.
[

// with apply.
type CapabilitiesApplyConfiguration struct {
	Add  []v1.Capability `json:"add,omitempty"`
	Drop []v1.Capability `json:"drop,omitempty"`
}

// CapabilitiesApplyConfiguration constructs an declarative configuration of the Capabilities type for use with
// apply.
func Capabilities() *CapabilitiesApplyConfiguration {

        {
            "name": "api",
            "capabilities": [
                { "group": "g1", "name": "m1", "version": "v1" },
                { "group": "g2", "name": "m2", "version": "v2" }
            ],
            "attributes": { "usage": "compile" }
        },
        {
            "attributes": { "usage": "runtime", "packaging": "zip" },
            "capabilities": [

Laura Kassovic <******@****.***> 1701107622 -0800

    }

    public static ImmutableCapabilities of(@Nullable Collection<? extends Capability> capabilities) {
        if (capabilities == null || capabilities.isEmpty()) {
            return EMPTY;
        }
        if (capabilities.size() == 1) {
            Capability single = capabilities.iterator().next();
            return of(single);
        }

// See the License for the specific language governing permissions and
// limitations under the License.

[[declaring-component-capabilities]]
= Declaring Capabilities of a Library

== Capabilities as first-level concept

Components provide a number of features which are often orthogonal to the software architecture used to provide those features.

        this.capabilities &= this.server.scapabilities;
        if ( ( this.server.scapabilities & SmbConstants.CAP_EXTENDED_SECURITY ) == SmbConstants.CAP_EXTENDED_SECURITY )
            this.capabilities |= SmbConstants.CAP_EXTENDED_SECURITY; // & doesn't copy high bit

        if ( ctx.getConfig().isUseUnicode() || ctx.getConfig().isForceUnicode() ) {
            this.capabilities |= SmbConstants.CAP_UNICODE;
        }

limitations under the License.
*/

package capabilities

import (
	"reflect"
	"sync"
	"testing"
)

func TestGet(t *testing.T) {
	defer func() {
		capInstance.lock.Lock()
		defer capInstance.lock.Unlock()
		capInstance.capabilities = nil
		capInstance.once = sync.Once{}
	}()
	defaultCap := Capabilities{
		AllowPrivileged: false,
		PrivilegedSources: PrivilegedSources{

        StringBuilder sb = new StringBuilder("capabilit");
        if (capabilities.size() > 1) {
            sb.append("ies ");
            sb.append(describeCapabilities(targetComponentId, capabilities));
        } else {
            sb.append("y ").append(describeCapabilities(targetComponentId, capabilities));
        }
        return sb.toString();
    }