{"abc//./../def", "def"},
		{"abc/../../././../def", "../../def"},
	}
	for _, test := range cleantests {
		want := test.path != test.result
		got := pathNeedsClean([]byte(test.path))
		if !got {
			t.Logf("no clean: %q", test.path)
		}
		if want && !got {
			t.Errorf("input: %q, want %v, got %v", test.path, want, got)
		}
	}

				t.Errorf("parseNumeric(%q): got parsing failure, want success", v.in)
			} else {
				t.Errorf("parseNumeric(%q): got parsing success, want failure", v.in)
			}
		}
		if ok && got != v.want {
			t.Errorf("parseNumeric(%q): got %d, want %d", v.in, got, v.want)
		}
	}
}

func TestFormatNumeric(t *testing.T) {
	vectors := []struct {
		in   int64
		want string
		ok   bool
	}{

		t.Fatalf("bytepool width invalid: got %v want %v", bp.Width(), width)
	}

	// Check with width cap
	if bp.WidthCap() != capWidth {
		t.Fatalf("bytepool capWidth invalid: got %v want %v", bp.WidthCap(), capWidth)
	}

	// Check that retrieved buffer are of the expected width
	b := bp.Get()
	if len(b) != width {
		t.Fatalf("bytepool length invalid: got %v want %v", len(b), width)
	}
	if cap(b) != capWidth {

		filter   Filter
		userTags string
		want     bool
	}{
		{
			filter:   noTags,
			userTags: "",
			want:     true,
		},
		{
			filter:   noTags,
			userTags: "A=3",
			want:     true,
		},
		{
			filter:   oneTag,
			userTags: "A=3",
			want:     false,
		},
		{
			filter:   oneTag,
			userTags: "FOO=1",
			want:     true,
		},
		{
			filter:   oneTag,

			if got := hashDeterministicString(m); got == want {
				t.Errorf("hashDeterministicString() = %v, does not want %v", got, want)
			}
			want = hashDeterministicString(m)
			delete(m, "12312312")
			m["another"] = ""

			if got := hashDeterministicString(m); got == want {
				t.Errorf("hashDeterministicString() = %v, does not want %v", got, want)
			}

			want = hashDeterministicString(m)
			m["another"] = "hashDeterministicString"

		t.Error("lastupdate not set")
	}

	if !want.Info.LastUpdate.Equal(got.Info.LastUpdate) {
		t.Fatalf("deserialize LastUpdate mismatch\nwant: %+v\ngot:  %+v", want, got)
	}
	if len(want.Cache) != len(got.Cache) {
		t.Errorf("deserialize mismatch length\nwant: %+v\ngot:  %+v", len(want.Cache), len(got.Cache))
	}
	for wkey, wval := range want.Cache {
		gotv := got.Cache[wkey]
		if !equalAsJSON(gotv, wval) {

		}
		if got.Method != want.method {
			t.Errorf("%s: got Method %#x; want %#x", want.name, got.Method, want.method)
		}
		if got.Flags != want.flags {
			t.Errorf("%s: got Flags %#x; want %#x", want.name, got.Flags, want.flags)
		}
		if got.CRC32 != want.crc32 {
			t.Errorf("%s: got CRC32 %#x; want %#x", want.name, got.CRC32, want.crc32)
		}
		if got.CompressedSize64 != want.compressedSize {

type SizeTooSmall struct {
	Want int64
	Got  int64
}

func (e SizeTooSmall) Error() string {
	return fmt.Sprintf("Size small: got %d, want %d", e.Got, e.Want)
}

// SizeTooLarge reader size too large
type SizeTooLarge struct {
	Want int64
	Got  int64
}

func (e SizeTooLarge) Error() string {
	return fmt.Sprintf("Size large: got %d, want %d", e.Got, e.Want)
}

// SizeMismatch error size mismatch

		n, err := buf.Write(testBytes[0:1])
		if want := 1; err != nil || n != want {
			t.Errorf("Write: got (%d, %v), want (%d, %v)", n, err, want, nil)
		}
		check(t, "TestBasicOperations (4)", &buf, "a")

		buf.WriteByte(testString[1])
		check(t, "TestBasicOperations (5)", &buf, "ab")

		n, err = buf.Write(testBytes[2:26])
		if want := 24; err != nil || n != want {

	for i, v := range vectors {
		r := strings.NewReader(v.in)
		got, err := parsePAX(r)
		if !maps.Equal(got, v.want) && !(len(got) == 0 && len(v.want) == 0) {
			t.Errorf("test %d, parsePAX():\ngot  %v\nwant %v", i, got, v.want)
		}
		if ok := err == nil; ok != v.ok {
			t.Errorf("test %d, parsePAX(): got %v, want %v", i, ok, v.ok)
		}
	}
}

func TestReadOldGNUSparseMap(t *testing.T) {