| package xxhash |
| |
| import ( |
| "bytes" |
| "encoding/binary" |
| "fmt" |
| "strings" |
| "testing" |
| ) |
| |
| func TestAll(t *testing.T) { |
| for _, tt := range []struct { |
| name string |
| input string |
| want uint64 |
| }{ |
| {"empty", "", 0xef46db3751d8e999}, |
| {"a", "a", 0xd24ec4f1a98c6e5b}, |
| {"as", "as", 0x1c330fb2d66be179}, |
| {"asd", "asd", 0x631c37ce72a97393}, |
| {"asdf", "asdf", 0x415872f599cea71e}, |
| { |
| "len=63", |
| // Exactly 63 characters, which exercises all code paths. |
| "Call me Ishmael. Some years ago--never mind how long precisely-", |
| 0x02a2e85470d6fd96, |
| }, |
| } { |
| lastChunkSize := len(tt.input) |
| if lastChunkSize == 0 { |
| lastChunkSize = 1 |
| } |
| for chunkSize := 1; chunkSize <= lastChunkSize; chunkSize++ { |
| name := fmt.Sprintf("%s,chunkSize=%d", tt.name, chunkSize) |
| t.Run(name, func(t *testing.T) { |
| testDigest(t, tt.input, chunkSize, tt.want) |
| }) |
| } |
| t.Run(tt.name, func(t *testing.T) { testSum(t, tt.input, tt.want) }) |
| } |
| } |
| |
| func testDigest(t *testing.T, input string, chunkSize int, want uint64) { |
| d := New() |
| ds := New() // uses WriteString |
| for i := 0; i < len(input); i += chunkSize { |
| chunk := input[i:] |
| if len(chunk) > chunkSize { |
| chunk = chunk[:chunkSize] |
| } |
| n, err := d.Write([]byte(chunk)) |
| if err != nil || n != len(chunk) { |
| t.Fatalf("Digest.Write: got (%d, %v); want (%d, nil)", n, err, len(chunk)) |
| } |
| n, err = ds.WriteString(chunk) |
| if err != nil || n != len(chunk) { |
| t.Fatalf("Digest.WriteString: got (%d, %v); want (%d, nil)", n, err, len(chunk)) |
| } |
| } |
| if got := d.Sum64(); got != want { |
| t.Fatalf("Digest.Sum64: got 0x%x; want 0x%x", got, want) |
| } |
| if got := ds.Sum64(); got != want { |
| t.Fatalf("Digest.Sum64 (WriteString): got 0x%x; want 0x%x", got, want) |
| } |
| var b [8]byte |
| binary.BigEndian.PutUint64(b[:], want) |
| if got := d.Sum(nil); !bytes.Equal(got, b[:]) { |
| t.Fatalf("Sum: got %v; want %v", got, b[:]) |
| } |
| } |
| |
| func testSum(t *testing.T, input string, want uint64) { |
| if got := Sum64([]byte(input)); got != want { |
| t.Fatalf("Sum64: got 0x%x; want 0x%x", got, want) |
| } |
| if got := Sum64String(input); got != want { |
| t.Fatalf("Sum64String: got 0x%x; want 0x%x", got, want) |
| } |
| } |
| |
| func TestReset(t *testing.T) { |
| parts := []string{"The quic", "k br", "o", "wn fox jumps", " ov", "er the lazy ", "dog."} |
| d := New() |
| for _, part := range parts { |
| d.Write([]byte(part)) |
| } |
| h0 := d.Sum64() |
| |
| d.Reset() |
| d.Write([]byte(strings.Join(parts, ""))) |
| h1 := d.Sum64() |
| |
| if h0 != h1 { |
| t.Errorf("0x%x != 0x%x", h0, h1) |
| } |
| } |
| |
| func TestBinaryMarshaling(t *testing.T) { |
| d := New() |
| d.WriteString("abc") |
| b, err := d.MarshalBinary() |
| if err != nil { |
| t.Fatal(err) |
| } |
| d = New() |
| d.WriteString("junk") |
| if err := d.UnmarshalBinary(b); err != nil { |
| t.Fatal(err) |
| } |
| d.WriteString("def") |
| if got, want := d.Sum64(), Sum64String("abcdef"); got != want { |
| t.Fatalf("after MarshalBinary+UnmarshalBinary, got 0x%x; want 0x%x", got, want) |
| } |
| |
| d0 := New() |
| d1 := New() |
| for i := 0; i < 64; i++ { |
| b, err := d0.MarshalBinary() |
| if err != nil { |
| t.Fatal(err) |
| } |
| d0 = new(Digest) |
| if err := d0.UnmarshalBinary(b); err != nil { |
| t.Fatal(err) |
| } |
| if got, want := d0.Sum64(), d1.Sum64(); got != want { |
| t.Fatalf("after %d Writes, unmarshaled Digest gave sum 0x%x; want 0x%x", i, got, want) |
| } |
| |
| d0.Write([]byte{'a'}) |
| d1.Write([]byte{'a'}) |
| } |
| } |
| |
| var sink uint64 |
| |
| func TestAllocs(t *testing.T) { |
| const shortStr = "abcdefghijklmnop" |
| // Sum64([]byte(shortString)) shouldn't allocate because the |
| // intermediate []byte ought not to escape. |
| // (See https://github.com/cespare/xxhash/pull/2.) |
| t.Run("Sum64", func(t *testing.T) { |
| testAllocs(t, func() { |
| sink = Sum64([]byte(shortStr)) |
| }) |
| }) |
| // Creating and using a Digest shouldn't allocate because its methods |
| // shouldn't make it escape. (A previous version of New returned a |
| // hash.Hash64 which forces an allocation.) |
| t.Run("Digest", func(t *testing.T) { |
| b := []byte("asdf") |
| testAllocs(t, func() { |
| d := New() |
| d.Write(b) |
| sink = d.Sum64() |
| }) |
| }) |
| } |
| |
| func testAllocs(t *testing.T, fn func()) { |
| t.Helper() |
| if allocs := int(testing.AllocsPerRun(10, fn)); allocs > 0 { |
| t.Fatalf("got %d allocation(s) (want zero)", allocs) |
| } |
| } |