* See the License for the specific language governing permissions and
 * limitations under the License.
 */
package gradlebuild.docs.model;

public interface Attachable<T> {
    void attach(ClassMetaDataRepository<T> repository);

	AzureVolumeLimitKey = "attachable-volumes-azure-disk"
	// GCEVolumeLimitKey stores resource name that will store volume limits for GCE node
	GCEVolumeLimitKey = "attachable-volumes-gce-pd"

	// CinderVolumeLimitKey contains Volume limit key for Cinder
	CinderVolumeLimitKey = "attachable-volumes-cinder"
	// DefaultMaxCinderVolumes defines the maximum number of PD Volumes for Cinder

)

func TestGetCSIAttachLimitKey(t *testing.T) {
	// When driverName is less than 39 characters
	csiLimitKey := GetCSIAttachLimitKey("com.amazon.ebs")
	if csiLimitKey != "attachable-volumes-csi-com.amazon.ebs" {
		t.Errorf("Expected com.amazon.ebs got %s", csiLimitKey)
	}

	// When driver is longer than 39 chars
	longDriverName := "com.amazon.kubernetes.eks.ec2.ebs/csi-driver"

		return
	}

	for _, volumeID := range rc.volumesNeedUpdateFromNodeStatus {
		attachable := false
		for _, attachedVolume := range node.Status.VolumesAttached {
			if volumeID != attachedVolume.Name {
				continue
			}
			rc.actualStateOfWorld.UpdateReconstructedDevicePath(volumeID, attachedVolume.DevicePath)
			attachable = true

		Name: name,
		VolumeSource: api.VolumeSource{
			CSI: &api.CSIVolumeSource{
				Driver:   driverName,
				ReadOnly: &ro,
			},
		},
	}
}

func getTestCSIDriver(name string, podInfoMount *bool, attachable *bool, volumeLifecycleModes []storagev1.VolumeLifecycleMode) *storagev1.CSIDriver {
	defaultFSGroupPolicy := storagev1.ReadWriteOnceWithFSTypeFSGroupPolicy
	seLinuxMountSupport := true
	noSElinuxMountSupport := false

import gradlebuild.docs.model.Attachable;
import gradlebuild.docs.model.ClassMetaDataRepository;
import org.gradle.util.CollectionUtils;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class ClassLinkMetaData implements Serializable, Attachable<ClassLinkMetaData> {
    private final String className;

		volumeAttachable := volutil.IsAttachableVolume(volumeToAttach.VolumeSpec, dswp.volumePluginMgr)
		if !volumeAttachable {
			logger.Info("Volume changes from attachable to non-attachable", "volumeName", volumeToAttach.VolumeName)
			for _, scheduledPod := range volumeToAttach.ScheduledPods {
				podUID := volutil.GetUniquePodName(scheduledPod)

        def newRepo = new SimpleClassMetaDataRepository<TestDomainObject>()
        newRepo.load(file)

        then:
        newRepo.find('class') == value
    }
}

class TestDomainObject implements Attachable<TestDomainObject>, Serializable {
    def value

    TestDomainObject(String value) {
        this.value = value
    }

    @Override
    boolean equals(Object o) {
        return o.value == value

import java.util.List;
import java.util.Map;
import java.util.TreeMap;

import static org.apache.commons.lang.StringUtils.getLevenshteinDistance;

public class SimpleClassMetaDataRepository<T extends Attachable<T>> implements ClassMetaDataRepository<T> {
    private final Map<String, T> classes = new TreeMap<>();

    @SuppressWarnings("unchecked")
    public void load(File repoFile) {
        try {

			volumeExists)
	}

	// Change the CSI volume plugin attachability
	fakeVolumePlugin.NonAttachable = true

	dswp.findAndRemoveDeletedPods(logger)

	// The volume should not exist after it becomes non-attachable
	volumeExists = dswp.desiredStateOfWorld.VolumeExists(expectedVolumeName, k8stypes.NodeName(pod.Spec.NodeName))
	if volumeExists {
		t.Fatalf(
			"VolumeExists(%q) failed. Expected: <false> Actual: <%v>",