if err != nil {
			t.Fatalf("Run failed with error. Failed to create a new pv: <%v>", err)
		}
		pvInformer.GetIndexer().Add(newPv)
	}
	if tc.vaName != "" {
		newVa := controllervolumetesting.NewVolumeAttachment(tc.vaName, tc.pvName, tc.vaNodeName, tc.vaAttachStatus)
		_, err = adc.kubeClient.StorageV1().VolumeAttachments().Create(tCtx, newVa, metav1.CreateOptions{})
		if err != nil {

			},
			NodeName: nodeName,
		},
	}
}

// Returns a volumeAttachment object
func NewVolumeAttachment(vaName, pvName, nodeName string, status bool) *storagev1.VolumeAttachment {
	return &storagev1.VolumeAttachment{

		ObjectMeta: metav1.ObjectMeta{
			UID:  types.UID(vaName),
			Name: vaName,
		},
		Spec: storagev1.VolumeAttachmentSpec{
			Attacher: "test.storage.gke.io",
			NodeName: nodeName,

		if pvName == nil {
			// Currently VA objects are created for CSI volumes only. nil pvName is unexpected, generate a warning
			logger.Info("Skipping the va as its pvName is nil", "node", klog.KRef("", string(nodeName)), "vaName", va.Name)
			continue
		}
		pv, err := adc.pvLister.Get(*pvName)
		if err != nil {
			logger.Error(err, "Unable to lookup pv object", "PV", klog.KRef("", *pvName))
			continue
		}

	va := int(sect.virtualAddress)
	pefile.dataDirectory[pe.IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress = uint32(va)
	pefile.dataDirectory[pe.IMAGE_DIRECTORY_ENTRY_EXPORT].Size = sect.virtualSize

	vaName := va + binary.Size(&e) + nexport*4
	vaAddr := va + binary.Size(&e)
	vaNa := va + binary.Size(&e) + nexport*8

	e.Characteristics = 0
	e.MajorVersion = 0
	e.MinorVersion = 0

func NewIPSet(name string, v6 bool, deps NetlinkIpsetDeps) (IPSet, error) {
	var err error
	set := IPSet{
		V4Name: fmt.Sprintf(V4Name, name),
		Deps:   deps,
		Prefix: name,
	}
	err = deps.ipsetIPHashCreate(set.V4Name, false)
	if v6 {
		set.V6Name = fmt.Sprintf(V6Name, name)
		v6err := deps.ipsetIPHashCreate(set.V6Name, true)
		err = errors.Join(err, v6err)
	}
	return set, err
}

func (m *IPSet) DestroySet() error {

}

func TestAddPodToHostNSIPSetsV6(t *testing.T) {
	pod := buildConvincingPod(true)

	var podUID string = string(pod.ObjectMeta.UID)
	fakeIPSetDeps := ipset.FakeNLDeps()
	set := ipset.IPSet{V4Name: "foo-v4", V6Name: "foo-v6", Prefix: "foo", Deps: fakeIPSetDeps}
	ipProto := uint8(unix.IPPROTO_TCP)

	fakeIPSetDeps.On("addIP",
		"foo-v6",
		netip.MustParseAddr("e9ac:1e77:90ca:399f:4d6d:ece3:2f9b:3162"),
		ipProto,

			newSpec:       specWithVACName(vacName),
			expectNewSpec: specWithVACName(vacName),
			oldSpec:       specWithVACName(vacName),
			expectOldSpec: specWithVACName(vacName),
		},
		"disabled vac old pv had volume attributes class name": {
			vacEnabled:    false,
			newSpec:       specWithVACName(vacName),
			expectNewSpec: specWithVACName(vacName),
			oldSpec:       specWithVACName(vacName),
			expectOldSpec: specWithVACName(vacName),

			private:   &privateClaims{Kubernetes: kubernetes{Svcacct: ref{Name: "saname", UID: "sauid"}, Namespace: "ns"}},
			expectErr: "",
		},
		{
			name:      "expired",
			getter:    fakeGetter{serviceAccount, nil, nil, nil},
			private:   &privateClaims{Kubernetes: kubernetes{Svcacct: ref{Name: "saname", UID: "sauid"}, Namespace: "ns"}},
			expiry:    *jwt.NewNumericDate(now().Add(-1_000 * time.Hour)),

			for _, cert := range test.certs {
				if cert.CAName != "" && certMap[cert.CAName] == nil {
					t.Errorf("Certificate %q references nonexistent CA %q", cert.Name, cert.CAName)
				}
			}
		})
	}
}

func TestMakeCertTree(t *testing.T) {
	rootCert := &KubeadmCert{
		Name: "root",
	}
	leaf0 := &KubeadmCert{
		Name:   "leaf0",
		CAName: "root",
	}
	leaf1 := &KubeadmCert{
		Name:   "leaf1",

			oldSpec: core.PersistentVolumeClaimSpec{},
		},
		"vac disabled with vac when vac exists in oldSpec": {
			spec:       core.PersistentVolumeClaimSpec{VolumeAttributesClassName: vacName},
			oldSpec:    core.PersistentVolumeClaimSpec{VolumeAttributesClassName: vacName},
			vacEnabled: false,
			wantVAC:    vacName,
		},