continue
		}
		if string(data) != "abc" {
			t.Errorf(`abc file is expected to have "abc" in it, but has %v`, data)
			continue
		}

		fi1, err := os.Stat(link)
		if err != nil {
			t.Errorf("failed to stat link %v: %v", link, err)
			continue
		}
		if tp := fi1.Mode().Type(); tp != fs.ModeDir {
			t.Errorf("Stat(%q) is type %v; want %v", link, tp, fs.ModeDir)
			continue
		}

			"aaaaaaaaaa",
			"aaaaaaaaaaa", // 11 a's
			".",
			".*",
			"a+",
			"aa+",
			"aaaa[b]?",
			"aaa*",
		},
	},

	{
		"abc",
		"abc",
		[]string{
			"a",
			"b",
			"c",
			"ab",
			"bc",
			"abc",
			"a.c",
			"a(b|c)",
			"abc?",
		},
	},

	{
		"barbara*3",
		"barbarabarbarabarbara",
		[]string{
			"a",
			"bar",
			"rab",
			"arab",
			"barbar",

			expectedPruned: []string{"array[1].b", "array[2].b", "specified.b", "unspecified"}},
		{name: "nested x-kubernetes-preserve-unknown-fields", json: `
{
  "unspecified":"bar",
  "alpha": "abc",
  "beta": 42.0,
  "unspecifiedObject": {"unspecified": "bar"},
  "pruning": {
     "unspecified": "bar",
     "unspecifiedObject": {"unspecified": "bar"},
     "pruning": {"unspecified": "bar"},

			in:            hex("a143414243187b"), // {"ABC": 123}
			want:          map[string]interface{}{"ABC": int64(123)},
			assertOnError: assertNilError,
		},
		{
			name:          "map with mixed string key types",
			in:            hex("a243abcdef187b43414243187c"), // {h'abcdef': 123, "ABC": 124}
			want:          map[string]interface{}{"\xab\xcd\xef": int64(123), "ABC": int64(124)},
			assertOnError: assertNilError,
		},

			t.Errorf("%q: got %t, want %t", host, got, want)
		}
	}
}

var defaultPathTests = map[string]string{
	"/":           "/",
	"/abc":        "/",
	"/abc/":       "/abc",
	"/abc/xyz":    "/abc",
	"/abc/xyz/":   "/abc/xyz",
	"/a/b/c.html": "/a/b",
	"":            "/",
	"strange":     "/",
	"//":          "/",
	"/a//b":       "/a/",
	"/a/./b":      "/a/.",

			class: func() *resource.ResourceClass {
				class := testClass(goodName, goodName)
				class.Annotations = map[string]string{

		return "/" // Path is empty or malformed.
	}

	i := strings.LastIndex(path, "/") // Path starts with "/", so i != -1.
	if i == 0 {
		return "/" // Path has the form "/abc".
	}
	return path[:i] // Path is either of form "/abc/xyz" or "/abc/xyz/".
}

// newEntry creates an entry from an http.Cookie c. now is the current time and
// is compared to c.Expires to determine deletion of c. defPath and host are the

	if err != nil {
		t.Fatalf("can't make a temp dir: %v", err)
	}
	defer os.RemoveAll(tmpDir)
	podManager := kubepod.NewBasicPodManager()

	pod := &v1.Pod{
		ObjectMeta: metav1.ObjectMeta{
			Name:      "abc",
			Namespace: "nsA",
			UID:       "1234",
		},
		Spec: v1.PodSpec{
			Containers: []v1.Container{
				{
					Name: "container1",
					VolumeMounts: []v1.VolumeMount{
						{

				if got := err.Error(); got != want {
					t.Fatalf("want error message %q, got %q", want, got)
				}
			},
		},
		{
			in:   FromString(""),
			want: []byte{0x40},
		},
		{
			in:   FromString("abc"),
			want: []byte{0x43, 'a', 'b', 'c'},
		},
		{
			in:   FromInt32(0), // min positive integer representable in one byte
			want: []byte{0x00},
		},
		{

			template: func() *resource.ResourceClaimTemplate {
				template := testClaimTemplate(goodName, goodNS, goodClaimSpec)