originalSELinuxLabel:           seLinuxFileLabel,
		}
		// record desired size of the volume
		if volumeSpec.PersistentVolume != nil {
			pvCap := volumeSpec.PersistentVolume.Spec.Capacity.Storage()
			if pvCap != nil {
				pvCapCopy := pvCap.DeepCopy()
				vmt.persistentVolumeSize = &pvCapCopy
			}
		}
		dsw.volumesToMount[volumeName] = vmt
	}

// source code is governed by a BSD-style license that can be found in
// the LICENSE file.

package main

import "fmt"

func main() {
	const N = 1024
	var a [N]int
	x := cap(append(a[:N-1:N], 9, 9))
	y := cap(append(a[:N:N], 9))
	if x != y {
		panic(fmt.Sprintf("different capacity on append: %d vs %d", x, y))
	}

package p

var a = []int{1,2,3}

func _(len int) {
	_ =  len(a) // ERROR "cannot call non-function|expected function"
}

var cap = false

                variant('runtime') {
                    capability('org', 'testA', '1.0')
                    capability('cap')
                }
            }
            'org:testB:1.0' {
                variant('runtime') {
                    capability('org', 'testB', '1.0')
                    capability('cap')
                }
            }
        }

        buildFile << """
            dependencies {

func testCapChan(t *testing.T) {

	v := make(chan int, 25)

	if want, got := 25, capChan_ssa(v); got != want {
		t.Errorf("expected cap(chan) = %d, got %d", want, got)
	}
}

func testCapNilChan(t *testing.T) {

	var v chan int
	if want, got := 0, capChan_ssa(v); got != want {
		t.Errorf("expected cap(nil) = %d, got %d", want, got)
	}
}

func TestChan(t *testing.T) {
	testLenChan(t)
	testLenNilChan(t)

import (
	"math/rand"
	"time"
)

func backoffWait(min, unit, cap time.Duration) func(*rand.Rand, uint) time.Duration {
	if unit > time.Hour {
		// Protect against integer overflow
		panic("unit cannot exceed one hour")
	}
	return func(r *rand.Rand, attempt uint) time.Duration {
		sleep := min
		sleep += unit * time.Duration(attempt)
		if sleep > cap {
			sleep = cap
		}
		sleep -= time.Duration(r.Float64() * float64(sleep))

		if len(a) != 1 || len(c) != 3 {
			bug()
			println("append call not ordered:", len(a), b, len(c))
		}
	}

	// cap
	{
		x := make([]int, 1)
		f := func() int { x = make([]int, 3); return 2 }
		a, b, c := cap(x), f(), cap(x)
		if a != 1 || c != 3 {
			bug()
			println("cap call not ordered:", a, b, c)
		}
	}

	// complex
	{
		x := 1.0
		f := func() int { x = 3; return 2 }

		}

		pmap := params
		if baseName, _, ok := strings.Cut(key, "*"); ok {
			if continuation == nil {
				continuation = make(map[string]map[string]string)
			}
			var ok bool
			if pmap, ok = continuation[baseName]; !ok {
				continuation[baseName] = make(map[string]string)
				pmap = continuation[baseName]
			}
		}
		if v, exists := pmap[key]; exists && v != value {

			len(a2)
	if x != 20 {
		println("wrong arraylen")
		panic("fail")
	}

	x =
		len(b0) +
			len(b3)
	if x != 3 {
		println("wrong slicelen")
		panic("fail")
	}

	x =
		cap(b0) +
			cap(b3)
	if x != 3 {
		println("wrong slicecap")
		panic("fail")
	}
}

			make([]int, 0),
			6,
		},
		{
			"size: 6 cap: 6 slice",
			make([]int, 6),
			6,
		},
		{
			"size: 6 cap: 12 slice",
			make([]int, 6, 12),
			6,
		},
		{
			"size: 4 cap: 4 slice",
			make([]int, 4),
			6,
		},
		{
			"size: 4 cap: 12 slice",
			make([]int, 4, 12),
			6,
		},
		{
			"size: 10 cap: 10 slice",
			make([]int, 10),
			6,
		},
		{