},
	}

	for _, tc := range tt {
		cn, err := DualUseCommonName(tc.host)
		if tc.expectErr {
			if err == nil {
				t.Errorf("[%s] passed - expected error", tc.name)
			}
			continue
		}

		if err != nil {
			t.Errorf("[%s] unexpected error: %v", tc.name, err)
		}

		if tc.expectedCN != cn {
			t.Errorf("[%s] unexpected CN: wanted %q got %q", tc.name, tc.expectedCN, cn)
		}
	}

	}

func TestPathToPrefix(t *testing.T) {
	for _, tc := range escapeTests {
		if got := PathToPrefix(tc.Path); got != tc.Escaped {
			t.Errorf("expected PathToPrefix(%s) = %s, got %s", tc.Path, tc.Escaped, got)
		}
	}
}

func TestPrefixToPath(t *testing.T) {
	for _, tc := range escapeTests {
		got, err := PrefixToPath(tc.Escaped)
		if err != nil {

	}

	checker := &illegalPackageSourceChecker{disallowedPrefixes}

	for _, tc := range testCases {
		if checker.IsForbidden(tc.pkgPath) {
			if tc.shouldBeAllowed {
				t.Fatalf("expected package path %q to have been allowed", tc.pkgPath)
			}
			continue
		}

		if !tc.shouldBeAllowed {
			t.Fatalf("expected package path %q to have been rejected", tc.pkgPath)
		}
	}

			exitError:  transientError,
		},
	}

	for _, tc := range tests {
		metricsGetter := &metricsCsi{volumeID: tc.volumeID, targetPath: tc.targetPath}
		metricsGetter.driverName = "unknown-driver"
		_, err := metricsGetter.GetMetrics()
		if err == nil {
			t.Errorf("test should fail, but no error occurred")
		} else if reflect.TypeOf(tc.exitError) != reflect.TypeOf(err) {

    /**
     * Get transport connection
     * 
     * @param tc
     *            context to use
     * @param address
     * @param port
     * @param exclusive
     *            whether to acquire an unshared connection
     * @return a transport connection to the target
     */
    SmbTransport getSmbTransport ( CIFSContext tc, Address address, int port, boolean exclusive );


    /**

				Conditions:      commonVersionFalseCondition(),
			},
		},
	}

	for _, tc := range tests {
		sv := &v1alpha1.StorageVersion{Status: tc.old}
		updated := localUpdateStorageVersion(sv, tc.newSSV.APIServerID, tc.newSSV.EncodingVersion, tc.newSSV.DecodableVersions, tc.newSSV.ServedVersions)
		if tc.expectLastTransitionTimeUpdate == updated.Status.Conditions[0].LastTransitionTime.IsZero() {

			Expect: 443,
		},
	}

	for _, tc := range testCases {
		actual, err := convertToPort(tc.V)
		if tc.Err != "" {
			if err == nil {
				t.Errorf("%s: expecting error %s but found no error", tc.Name, tc.Err)
			} else if !strings.HasPrefix(err.Error(), tc.Err) {
				t.Errorf("%s: expecting error %s, but got: %s", tc.Name, tc.Err, err.Error())
			}
		} else if tc.Expect != actual {

			t.Errorf("%q: Did not observe an expected error", tc.desc)
			continue
		}
		if !tc.expectErr && err != nil {
			t.Errorf("%q: Observed an unexpected error: %v", tc.desc, err)
			continue
		}
		if tc.expectVal != ipport {
			t.Errorf("%q: Unexpected ipport: expected %q, saw %q", tc.desc, tc.expectVal, ipport)
		}
	}
}

func TestReservedMemoryVar(t *testing.T) {

		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			out, err := parseASN1String(tc.tag, tc.value)
			if err != nil && err.Error() != tc.expectedErr {
				t.Fatalf("parseASN1String returned unexpected error: got %q, want %q", err, tc.expectedErr)
			} else if err == nil && tc.expectedErr != "" {
				t.Fatalf("parseASN1String didn't fail, expected: %s", tc.expectedErr)
			}
			if out != tc.expected {

		expectedError:   fmt.Errorf("no imagefs label for configured runtime"),
	}}

	for _, tc := range testcases {
		t.Run(tc.description, func(t *testing.T) {
			infoProvider := NewImageFsInfoProvider(tc.runtimeEndpoint)
			label, err := infoProvider.ImageFsInfoLabel()
			assert.Equal(t, tc.expectedLabel, label)
			assert.Equal(t, tc.expectedError, err)
		})
	}
}

func TestContainerFsInfoLabel(t *testing.T) {