limitations under the License.
*/

package store

import (
	"testing"

	"github.com/stretchr/testify/assert"
)

func TestIsValidKey(t *testing.T) {
	testcases := []struct {
		key   string
		valid bool
	}{
		{
			"    ",
			false,
		},
		{
			"/foo/bar",
			false,
		},
		{
			".foo",
			false,
		},
		{

	testCases := []struct {
		pod      *v1.Pod
		expected bool
	}{{pods[0], true}, {pods[1], false}, {pods[2], false}, {pods[3], false}, {pods[4], false}}

	for i, testCase := range testCases {
		if actual := handler.ShouldSync(testCase.pod); actual != testCase.expected {
			t.Errorf("[%d] ShouldSync expected %#v, got %#v", i, testCase.expected, actual)
		}

		ObjectMeta: metav1.ObjectMeta{
			Name: "my-vac7",
			Annotations: map[string]string{
				AlphaIsDefaultVolumeAttributesClassAnnotation: "true",
			},
		},
		DriverName: dirverName2,
	}

	testCases := []struct {
		name       string
		driverName string
		classes    []*storagev1alpha1.VolumeAttributesClass
		expect     *storagev1alpha1.VolumeAttributesClass
	}{
		{

limitations under the License.
*/

package path

import (
	"strings"
	"testing"
)

func TestValidatePathSegmentName(t *testing.T) {
	testcases := map[string]struct {
		Name        string
		Prefix      bool
		ExpectedMsg string
	}{
		"empty": {
			Name:        "",
			Prefix:      false,
			ExpectedMsg: "",
		},
		"empty,prefix": {

			expectedErr: errFileNameTooLong,
		},
	}

	for i, testCase := range testCases {
		if err := xlStorage.RenameFile(context.Background(), testCase.srcVol, testCase.srcPath, testCase.destVol, testCase.destPath); err != testCase.expectedErr {
			t.Fatalf("TestXLStorage %d:  Expected the error to be : \"%v\", got: \"%v\".", i+1, testCase.expectedErr, err)
		}
	}
}

			expectedErrCode:  ErrNone,
		},
	}
	for i, testCase := range testCases {
		actualSignStr, actualErrCode := parseSignature(testCase.inputSignElement)
		if testCase.expectedErrCode != actualErrCode {
			t.Fatalf("Test %d: Expected the APIErrCode to be %d, got %d", i+1, testCase.expectedErrCode, actualErrCode)
		}
		if actualErrCode == ErrNone {
			if testCase.expectedSignStr != actualSignStr {

		t.Cleanup(func() { os.Setenv(env, prev) })

		if err := os.Unsetenv(env); err != nil {
			t.Errorf("couldn't unset env %s: %v", env, err)
		}
	}
}

func TestFallbackToEnv(t *testing.T) {
	testCases := []struct {
		desc          string
		env           string
		value         string
		valueSet      bool
		expectedValue string
		expectedError bool
	}{
		{
			desc:          "value unset",

	exe, err := buildTestProg(t, "testprog", "-gcflags=all=-d=checkptr=2")
	if err != nil {
		t.Fatal(err)
	}

	testCases := []struct {
		cmd  string
		want string
	}{
		{"CheckPtrAlignmentNested", "fatal error: checkptr: converted pointer straddles multiple allocations\n"},
	}

	for _, tc := range testCases {
		tc := tc
		t.Run(tc.cmd, func(t *testing.T) {
			t.Parallel()

		},
	}

	root := NewPath("root")
	p := root
	for i, tc := range testCases {
		p = tc.op(p)
		if p.String() != tc.expected {
			t.Errorf("[%d] Expected %q, got %q", i, tc.expected, p.String())
		}
		if p.Root() != root {
			t.Errorf("[%d] Wrong root: %#v", i, p.Root())
		}
	}
}

func TestPathMultiArg(t *testing.T) {
	testCases := []struct {
		op       func(*Path) *Path
		expected string
	}{
		{

var (
	localhost    = "localhost:4317"
	ipAddress    = "127.0.0.1:4317"
	samplingRate = int32(12345)
)

func strptr(s string) *string {
	return &s
}

func TestValidateTracingOptions(t *testing.T) {
	testcases := []struct {
		name        string
		expectError bool
		contents    *TracingOptions
	}{
		{
			name:        "nil-valid",
			expectError: false,
		},
		{
			name:        "empty-valid",