| // Copyright 2011 The Snappy-Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| package snappy |
| |
| import ( |
| "bytes" |
| "flag" |
| "fmt" |
| "io" |
| "io/ioutil" |
| "math/rand" |
| "net/http" |
| "os" |
| "path/filepath" |
| "strings" |
| "testing" |
| ) |
| |
| var ( |
| download = flag.Bool("download", false, "If true, download any missing files before running benchmarks") |
| testdata = flag.String("testdata", "testdata", "Directory containing the test data") |
| ) |
| |
| func TestMaxEncodedLenOfMaxUncompressedChunkLen(t *testing.T) { |
| got := maxEncodedLenOfMaxUncompressedChunkLen |
| want := MaxEncodedLen(maxUncompressedChunkLen) |
| if got != want { |
| t.Fatalf("got %d, want %d", got, want) |
| } |
| } |
| |
| func roundtrip(b, ebuf, dbuf []byte) error { |
| d, err := Decode(dbuf, Encode(ebuf, b)) |
| if err != nil { |
| return fmt.Errorf("decoding error: %v", err) |
| } |
| if !bytes.Equal(b, d) { |
| return fmt.Errorf("roundtrip mismatch:\n\twant %v\n\tgot %v", b, d) |
| } |
| return nil |
| } |
| |
| func TestEmpty(t *testing.T) { |
| if err := roundtrip(nil, nil, nil); err != nil { |
| t.Fatal(err) |
| } |
| } |
| |
| func TestSmallCopy(t *testing.T) { |
| for _, ebuf := range [][]byte{nil, make([]byte, 20), make([]byte, 64)} { |
| for _, dbuf := range [][]byte{nil, make([]byte, 20), make([]byte, 64)} { |
| for i := 0; i < 32; i++ { |
| s := "aaaa" + strings.Repeat("b", i) + "aaaabbbb" |
| if err := roundtrip([]byte(s), ebuf, dbuf); err != nil { |
| t.Errorf("len(ebuf)=%d, len(dbuf)=%d, i=%d: %v", len(ebuf), len(dbuf), i, err) |
| } |
| } |
| } |
| } |
| } |
| |
| func TestSmallRand(t *testing.T) { |
| rng := rand.New(rand.NewSource(1)) |
| for n := 1; n < 20000; n += 23 { |
| b := make([]byte, n) |
| for i := range b { |
| b[i] = uint8(rng.Uint32()) |
| } |
| if err := roundtrip(b, nil, nil); err != nil { |
| t.Fatal(err) |
| } |
| } |
| } |
| |
| func TestSmallRegular(t *testing.T) { |
| for n := 1; n < 20000; n += 23 { |
| b := make([]byte, n) |
| for i := range b { |
| b[i] = uint8(i%10 + 'a') |
| } |
| if err := roundtrip(b, nil, nil); err != nil { |
| t.Fatal(err) |
| } |
| } |
| } |
| |
| func TestInvalidVarint(t *testing.T) { |
| data := []byte("\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00") |
| if _, err := DecodedLen(data); err != ErrCorrupt { |
| t.Errorf("DecodedLen: got %v, want ErrCorrupt", err) |
| } |
| if _, err := Decode(nil, data); err != ErrCorrupt { |
| t.Errorf("Decode: got %v, want ErrCorrupt", err) |
| } |
| |
| // The encoded varint overflows 32 bits |
| data = []byte("\xff\xff\xff\xff\xff\x00") |
| |
| if _, err := DecodedLen(data); err != ErrCorrupt { |
| t.Errorf("DecodedLen: got %v, want ErrCorrupt", err) |
| } |
| if _, err := Decode(nil, data); err != ErrCorrupt { |
| t.Errorf("Decode: got %v, want ErrCorrupt", err) |
| } |
| } |
| |
| func TestDecode(t *testing.T) { |
| testCases := []struct { |
| desc string |
| input string |
| want string |
| wantErr error |
| }{{ |
| `decodedLen=0x100000000 is too long`, |
| "\x80\x80\x80\x80\x10" + "\x00\x41", |
| "", |
| ErrCorrupt, |
| }, { |
| `decodedLen=3; tagLiteral, 0-byte length; length=3; valid input`, |
| "\x03" + "\x08\xff\xff\xff", |
| "\xff\xff\xff", |
| nil, |
| }, { |
| `decodedLen=1; tagLiteral, 1-byte length; not enough length bytes`, |
| "\x01" + "\xf0", |
| "", |
| ErrCorrupt, |
| }, { |
| `decodedLen=3; tagLiteral, 1-byte length; length=3; valid input`, |
| "\x03" + "\xf0\x02\xff\xff\xff", |
| "\xff\xff\xff", |
| nil, |
| }, { |
| `decodedLen=1; tagLiteral, 2-byte length; not enough length bytes`, |
| "\x01" + "\xf4\x00", |
| "", |
| ErrCorrupt, |
| }, { |
| `decodedLen=3; tagLiteral, 2-byte length; length=3; valid input`, |
| "\x03" + "\xf4\x02\x00\xff\xff\xff", |
| "\xff\xff\xff", |
| nil, |
| }, { |
| `decodedLen=1; tagLiteral, 3-byte length; not enough length bytes`, |
| "\x01" + "\xf8\x00\x00", |
| "", |
| ErrCorrupt, |
| }, { |
| `decodedLen=3; tagLiteral, 3-byte length; length=3; valid input`, |
| "\x03" + "\xf8\x02\x00\x00\xff\xff\xff", |
| "\xff\xff\xff", |
| nil, |
| }, { |
| `decodedLen=1; tagLiteral, 4-byte length; not enough length bytes`, |
| "\x01" + "\xfc\x00\x00\x00", |
| "", |
| ErrCorrupt, |
| }, { |
| `decodedLen=1; tagLiteral, 4-byte length; length=3; not enough dst bytes`, |
| "\x01" + "\xfc\x02\x00\x00\x00\xff\xff\xff", |
| "", |
| ErrCorrupt, |
| }, { |
| `decodedLen=4; tagLiteral, 4-byte length; length=3; not enough src bytes`, |
| "\x04" + "\xfc\x02\x00\x00\x00\xff", |
| "", |
| ErrCorrupt, |
| }, { |
| `decodedLen=3; tagLiteral, 4-byte length; length=3; valid input`, |
| "\x03" + "\xfc\x02\x00\x00\x00\xff\xff\xff", |
| "\xff\xff\xff", |
| nil, |
| }, { |
| `decodedLen=4; tagCopy1, 1 extra length|offset byte; not enough extra bytes`, |
| "\x04" + "\x01", |
| "", |
| ErrCorrupt, |
| }, { |
| `decodedLen=4; tagCopy2, 2 extra length|offset bytes; not enough extra bytes`, |
| "\x04" + "\x02\x00", |
| "", |
| ErrCorrupt, |
| }, { |
| `decodedLen=4; tagCopy4; unsupported COPY_4 tag`, |
| "\x04" + "\x03\x00\x00\x00\x00", |
| "", |
| errUnsupportedCopy4Tag, |
| }, { |
| `decodedLen=4; tagLiteral (4 bytes "abcd"); valid input`, |
| "\x04" + "\x0cabcd", |
| "abcd", |
| nil, |
| }, { |
| `decodedLen=8; tagLiteral (4 bytes "abcd"); tagCopy1; length=4 offset=4; valid input`, |
| "\x08" + "\x0cabcd" + "\x01\x04", |
| "abcdabcd", |
| nil, |
| }, { |
| `decodedLen=8; tagLiteral (4 bytes "abcd"); tagCopy1; length=4 offset=2; valid input`, |
| "\x08" + "\x0cabcd" + "\x01\x02", |
| "abcdcdcd", |
| nil, |
| }, { |
| `decodedLen=8; tagLiteral (4 bytes "abcd"); tagCopy1; length=4 offset=1; valid input`, |
| "\x08" + "\x0cabcd" + "\x01\x01", |
| "abcddddd", |
| nil, |
| }, { |
| `decodedLen=8; tagLiteral (4 bytes "abcd"); tagCopy1; length=4 offset=0; zero offset`, |
| "\x08" + "\x0cabcd" + "\x01\x00", |
| "", |
| ErrCorrupt, |
| }, { |
| `decodedLen=9; tagLiteral (4 bytes "abcd"); tagCopy1; length=4 offset=4; inconsistent dLen`, |
| "\x09" + "\x0cabcd" + "\x01\x04", |
| "", |
| ErrCorrupt, |
| }, { |
| `decodedLen=8; tagLiteral (4 bytes "abcd"); tagCopy1; length=4 offset=5; offset too large`, |
| "\x08" + "\x0cabcd" + "\x01\x05", |
| "", |
| ErrCorrupt, |
| }, { |
| `decodedLen=7; tagLiteral (4 bytes "abcd"); tagCopy1; length=4 offset=4; length too large`, |
| "\x07" + "\x0cabcd" + "\x01\x04", |
| "", |
| ErrCorrupt, |
| }} |
| |
| for _, tc := range testCases { |
| g, gotErr := Decode(nil, []byte(tc.input)) |
| if got := string(g); got != tc.want || gotErr != tc.wantErr { |
| t.Errorf("%s:\ngot %q, %v\nwant %q, %v", tc.desc, got, gotErr, tc.want, tc.wantErr) |
| } |
| } |
| } |
| |
| func cmp(a, b []byte) error { |
| if len(a) != len(b) { |
| return fmt.Errorf("got %d bytes, want %d", len(a), len(b)) |
| } |
| for i := range a { |
| if a[i] != b[i] { |
| return fmt.Errorf("byte #%d: got 0x%02x, want 0x%02x", i, a[i], b[i]) |
| } |
| } |
| return nil |
| } |
| |
| func TestFramingFormat(t *testing.T) { |
| // src is comprised of alternating 1e5-sized sequences of random |
| // (incompressible) bytes and repeated (compressible) bytes. 1e5 was chosen |
| // because it is larger than maxUncompressedChunkLen (64k). |
| src := make([]byte, 1e6) |
| rng := rand.New(rand.NewSource(1)) |
| for i := 0; i < 10; i++ { |
| if i%2 == 0 { |
| for j := 0; j < 1e5; j++ { |
| src[1e5*i+j] = uint8(rng.Intn(256)) |
| } |
| } else { |
| for j := 0; j < 1e5; j++ { |
| src[1e5*i+j] = uint8(i) |
| } |
| } |
| } |
| |
| buf := new(bytes.Buffer) |
| if _, err := NewWriter(buf).Write(src); err != nil { |
| t.Fatalf("Write: encoding: %v", err) |
| } |
| dst, err := ioutil.ReadAll(NewReader(buf)) |
| if err != nil { |
| t.Fatalf("ReadAll: decoding: %v", err) |
| } |
| if err := cmp(dst, src); err != nil { |
| t.Fatal(err) |
| } |
| } |
| |
| func TestWriterGoldenOutput(t *testing.T) { |
| buf := new(bytes.Buffer) |
| w := NewBufferedWriter(buf) |
| defer w.Close() |
| w.Write([]byte("abcd")) // Not compressible. |
| w.Flush() |
| w.Write(bytes.Repeat([]byte{'A'}, 100)) // Compressible. |
| w.Flush() |
| got := buf.String() |
| want := strings.Join([]string{ |
| magicChunk, |
| "\x01\x08\x00\x00", // Uncompressed chunk, 8 bytes long (including 4 byte checksum). |
| "\x68\x10\xe6\xb6", // Checksum. |
| "\x61\x62\x63\x64", // Uncompressed payload: "abcd". |
| "\x00\x0d\x00\x00", // Compressed chunk, 13 bytes long (including 4 byte checksum). |
| "\x37\xcb\xbc\x9d", // Checksum. |
| "\x64", // Compressed payload: Uncompressed length (varint encoded): 100. |
| "\x00\x41", // Compressed payload: tagLiteral, length=1, "A". |
| "\xfe\x01\x00", // Compressed payload: tagCopy2, length=64, offset=1. |
| "\x8a\x01\x00", // Compressed payload: tagCopy2, length=35, offset=1. |
| }, "") |
| if got != want { |
| t.Fatalf("\ngot: % x\nwant: % x", got, want) |
| } |
| } |
| |
| func TestNewBufferedWriter(t *testing.T) { |
| // Test all 32 possible sub-sequences of these 5 input slices. |
| // |
| // Their lengths sum to 400,000, which is over 6 times the Writer ibuf |
| // capacity: 6 * maxUncompressedChunkLen is 393,216. |
| inputs := [][]byte{ |
| bytes.Repeat([]byte{'a'}, 40000), |
| bytes.Repeat([]byte{'b'}, 150000), |
| bytes.Repeat([]byte{'c'}, 60000), |
| bytes.Repeat([]byte{'d'}, 120000), |
| bytes.Repeat([]byte{'e'}, 30000), |
| } |
| loop: |
| for i := 0; i < 1<<uint(len(inputs)); i++ { |
| var want []byte |
| buf := new(bytes.Buffer) |
| w := NewBufferedWriter(buf) |
| for j, input := range inputs { |
| if i&(1<<uint(j)) == 0 { |
| continue |
| } |
| if _, err := w.Write(input); err != nil { |
| t.Errorf("i=%#02x: j=%d: Write: %v", i, j, err) |
| continue loop |
| } |
| want = append(want, input...) |
| } |
| if err := w.Close(); err != nil { |
| t.Errorf("i=%#02x: Close: %v", i, err) |
| continue |
| } |
| got, err := ioutil.ReadAll(NewReader(buf)) |
| if err != nil { |
| t.Errorf("i=%#02x: ReadAll: %v", i, err) |
| continue |
| } |
| if err := cmp(got, want); err != nil { |
| t.Errorf("i=%#02x: %v", i, err) |
| continue |
| } |
| } |
| } |
| |
| func TestFlush(t *testing.T) { |
| buf := new(bytes.Buffer) |
| w := NewBufferedWriter(buf) |
| defer w.Close() |
| if _, err := w.Write(bytes.Repeat([]byte{'x'}, 20)); err != nil { |
| t.Fatalf("Write: %v", err) |
| } |
| if n := buf.Len(); n != 0 { |
| t.Fatalf("before Flush: %d bytes were written to the underlying io.Writer, want 0", n) |
| } |
| if err := w.Flush(); err != nil { |
| t.Fatalf("Flush: %v", err) |
| } |
| if n := buf.Len(); n == 0 { |
| t.Fatalf("after Flush: %d bytes were written to the underlying io.Writer, want non-0", n) |
| } |
| } |
| |
| func TestReaderReset(t *testing.T) { |
| gold := bytes.Repeat([]byte("All that is gold does not glitter,\n"), 10000) |
| buf := new(bytes.Buffer) |
| if _, err := NewWriter(buf).Write(gold); err != nil { |
| t.Fatalf("Write: %v", err) |
| } |
| encoded, invalid, partial := buf.String(), "invalid", "partial" |
| r := NewReader(nil) |
| for i, s := range []string{encoded, invalid, partial, encoded, partial, invalid, encoded, encoded} { |
| if s == partial { |
| r.Reset(strings.NewReader(encoded)) |
| if _, err := r.Read(make([]byte, 101)); err != nil { |
| t.Errorf("#%d: %v", i, err) |
| continue |
| } |
| continue |
| } |
| r.Reset(strings.NewReader(s)) |
| got, err := ioutil.ReadAll(r) |
| switch s { |
| case encoded: |
| if err != nil { |
| t.Errorf("#%d: %v", i, err) |
| continue |
| } |
| if err := cmp(got, gold); err != nil { |
| t.Errorf("#%d: %v", i, err) |
| continue |
| } |
| case invalid: |
| if err == nil { |
| t.Errorf("#%d: got nil error, want non-nil", i) |
| continue |
| } |
| } |
| } |
| } |
| |
| func TestWriterReset(t *testing.T) { |
| gold := bytes.Repeat([]byte("Not all those who wander are lost;\n"), 10000) |
| const n = 20 |
| for _, buffered := range []bool{false, true} { |
| var w *Writer |
| if buffered { |
| w = NewBufferedWriter(nil) |
| defer w.Close() |
| } else { |
| w = NewWriter(nil) |
| } |
| |
| var gots, wants [][]byte |
| failed := false |
| for i := 0; i <= n; i++ { |
| buf := new(bytes.Buffer) |
| w.Reset(buf) |
| want := gold[:len(gold)*i/n] |
| if _, err := w.Write(want); err != nil { |
| t.Errorf("#%d: Write: %v", i, err) |
| failed = true |
| continue |
| } |
| if buffered { |
| if err := w.Flush(); err != nil { |
| t.Errorf("#%d: Flush: %v", i, err) |
| failed = true |
| continue |
| } |
| } |
| got, err := ioutil.ReadAll(NewReader(buf)) |
| if err != nil { |
| t.Errorf("#%d: ReadAll: %v", i, err) |
| failed = true |
| continue |
| } |
| gots = append(gots, got) |
| wants = append(wants, want) |
| } |
| if failed { |
| continue |
| } |
| for i := range gots { |
| if err := cmp(gots[i], wants[i]); err != nil { |
| t.Errorf("#%d: %v", i, err) |
| } |
| } |
| } |
| } |
| |
| func TestWriterResetWithoutFlush(t *testing.T) { |
| buf0 := new(bytes.Buffer) |
| buf1 := new(bytes.Buffer) |
| w := NewBufferedWriter(buf0) |
| if _, err := w.Write([]byte("xxx")); err != nil { |
| t.Fatalf("Write #0: %v", err) |
| } |
| // Note that we don't Flush the Writer before calling Reset. |
| w.Reset(buf1) |
| if _, err := w.Write([]byte("yyy")); err != nil { |
| t.Fatalf("Write #1: %v", err) |
| } |
| if err := w.Flush(); err != nil { |
| t.Fatalf("Flush: %v", err) |
| } |
| got, err := ioutil.ReadAll(NewReader(buf1)) |
| if err != nil { |
| t.Fatalf("ReadAll: %v", err) |
| } |
| if err := cmp(got, []byte("yyy")); err != nil { |
| t.Fatal(err) |
| } |
| } |
| |
| type writeCounter int |
| |
| func (c *writeCounter) Write(p []byte) (int, error) { |
| *c++ |
| return len(p), nil |
| } |
| |
| // TestNumUnderlyingWrites tests that each Writer flush only makes one or two |
| // Write calls on its underlying io.Writer, depending on whether or not the |
| // flushed buffer was compressible. |
| func TestNumUnderlyingWrites(t *testing.T) { |
| testCases := []struct { |
| input []byte |
| want int |
| }{ |
| {bytes.Repeat([]byte{'x'}, 100), 1}, |
| {bytes.Repeat([]byte{'y'}, 100), 1}, |
| {[]byte("ABCDEFGHIJKLMNOPQRST"), 2}, |
| } |
| |
| var c writeCounter |
| w := NewBufferedWriter(&c) |
| defer w.Close() |
| for i, tc := range testCases { |
| c = 0 |
| if _, err := w.Write(tc.input); err != nil { |
| t.Errorf("#%d: Write: %v", i, err) |
| continue |
| } |
| if err := w.Flush(); err != nil { |
| t.Errorf("#%d: Flush: %v", i, err) |
| continue |
| } |
| if int(c) != tc.want { |
| t.Errorf("#%d: got %d underlying writes, want %d", i, c, tc.want) |
| continue |
| } |
| } |
| } |
| |
| func benchDecode(b *testing.B, src []byte) { |
| encoded := Encode(nil, src) |
| // Bandwidth is in amount of uncompressed data. |
| b.SetBytes(int64(len(src))) |
| b.ResetTimer() |
| for i := 0; i < b.N; i++ { |
| Decode(src, encoded) |
| } |
| } |
| |
| func benchEncode(b *testing.B, src []byte) { |
| // Bandwidth is in amount of uncompressed data. |
| b.SetBytes(int64(len(src))) |
| dst := make([]byte, MaxEncodedLen(len(src))) |
| b.ResetTimer() |
| for i := 0; i < b.N; i++ { |
| Encode(dst, src) |
| } |
| } |
| |
| func readFile(b testing.TB, filename string) []byte { |
| src, err := ioutil.ReadFile(filename) |
| if err != nil { |
| b.Skipf("skipping benchmark: %v", err) |
| } |
| if len(src) == 0 { |
| b.Fatalf("%s has zero length", filename) |
| } |
| return src |
| } |
| |
| // expand returns a slice of length n containing repeated copies of src. |
| func expand(src []byte, n int) []byte { |
| dst := make([]byte, n) |
| for x := dst; len(x) > 0; { |
| i := copy(x, src) |
| x = x[i:] |
| } |
| return dst |
| } |
| |
| func benchWords(b *testing.B, n int, decode bool) { |
| // Note: the file is OS-language dependent so the resulting values are not |
| // directly comparable for non-US-English OS installations. |
| data := expand(readFile(b, "/usr/share/dict/words"), n) |
| if decode { |
| benchDecode(b, data) |
| } else { |
| benchEncode(b, data) |
| } |
| } |
| |
| func BenchmarkWordsDecode1e1(b *testing.B) { benchWords(b, 1e1, true) } |
| func BenchmarkWordsDecode1e2(b *testing.B) { benchWords(b, 1e2, true) } |
| func BenchmarkWordsDecode1e3(b *testing.B) { benchWords(b, 1e3, true) } |
| func BenchmarkWordsDecode1e4(b *testing.B) { benchWords(b, 1e4, true) } |
| func BenchmarkWordsDecode1e5(b *testing.B) { benchWords(b, 1e5, true) } |
| func BenchmarkWordsDecode1e6(b *testing.B) { benchWords(b, 1e6, true) } |
| func BenchmarkWordsEncode1e1(b *testing.B) { benchWords(b, 1e1, false) } |
| func BenchmarkWordsEncode1e2(b *testing.B) { benchWords(b, 1e2, false) } |
| func BenchmarkWordsEncode1e3(b *testing.B) { benchWords(b, 1e3, false) } |
| func BenchmarkWordsEncode1e4(b *testing.B) { benchWords(b, 1e4, false) } |
| func BenchmarkWordsEncode1e5(b *testing.B) { benchWords(b, 1e5, false) } |
| func BenchmarkWordsEncode1e6(b *testing.B) { benchWords(b, 1e6, false) } |
| |
| func BenchmarkRandomEncode(b *testing.B) { |
| rng := rand.New(rand.NewSource(1)) |
| data := make([]byte, 1<<20) |
| for i := range data { |
| data[i] = uint8(rng.Intn(256)) |
| } |
| benchEncode(b, data) |
| } |
| |
| // testFiles' values are copied directly from |
| // https://raw.githubusercontent.com/google/snappy/master/snappy_unittest.cc |
| // The label field is unused in snappy-go. |
| // |
| // If this list changes (due to the upstream C++ list changing), remember to |
| // update the .gitignore file in this repository. |
| var testFiles = []struct { |
| label string |
| filename string |
| sizeLimit int |
| }{ |
| {"html", "html", 0}, |
| {"urls", "urls.10K", 0}, |
| {"jpg", "fireworks.jpeg", 0}, |
| {"jpg_200", "fireworks.jpeg", 200}, |
| {"pdf", "paper-100k.pdf", 0}, |
| {"html4", "html_x_4", 0}, |
| {"txt1", "alice29.txt", 0}, |
| {"txt2", "asyoulik.txt", 0}, |
| {"txt3", "lcet10.txt", 0}, |
| {"txt4", "plrabn12.txt", 0}, |
| {"pb", "geo.protodata", 0}, |
| {"gaviota", "kppkn.gtb", 0}, |
| } |
| |
| // The test data files are present at this canonical URL. |
| const baseURL = "https://raw.githubusercontent.com/google/snappy/master/testdata/" |
| |
| func downloadTestdata(b *testing.B, basename string) (errRet error) { |
| filename := filepath.Join(*testdata, basename) |
| if stat, err := os.Stat(filename); err == nil && stat.Size() != 0 { |
| return nil |
| } |
| |
| if !*download { |
| b.Skipf("test data not found; skipping benchmark without the -download flag") |
| } |
| // Download the official snappy C++ implementation reference test data |
| // files for benchmarking. |
| if err := os.Mkdir(*testdata, 0777); err != nil && !os.IsExist(err) { |
| return fmt.Errorf("failed to create testdata: %s", err) |
| } |
| |
| f, err := os.Create(filename) |
| if err != nil { |
| return fmt.Errorf("failed to create %s: %s", filename, err) |
| } |
| defer f.Close() |
| defer func() { |
| if errRet != nil { |
| os.Remove(filename) |
| } |
| }() |
| url := baseURL + basename |
| resp, err := http.Get(url) |
| if err != nil { |
| return fmt.Errorf("failed to download %s: %s", url, err) |
| } |
| defer resp.Body.Close() |
| if s := resp.StatusCode; s != http.StatusOK { |
| return fmt.Errorf("downloading %s: HTTP status code %d (%s)", url, s, http.StatusText(s)) |
| } |
| _, err = io.Copy(f, resp.Body) |
| if err != nil { |
| return fmt.Errorf("failed to download %s to %s: %s", url, filename, err) |
| } |
| return nil |
| } |
| |
| func benchFile(b *testing.B, n int, decode bool) { |
| if err := downloadTestdata(b, testFiles[n].filename); err != nil { |
| b.Fatalf("failed to download testdata: %s", err) |
| } |
| data := readFile(b, filepath.Join(*testdata, testFiles[n].filename)) |
| if n := testFiles[n].sizeLimit; 0 < n && n < len(data) { |
| data = data[:n] |
| } |
| if decode { |
| benchDecode(b, data) |
| } else { |
| benchEncode(b, data) |
| } |
| } |
| |
| // Naming convention is kept similar to what snappy's C++ implementation uses. |
| func Benchmark_UFlat0(b *testing.B) { benchFile(b, 0, true) } |
| func Benchmark_UFlat1(b *testing.B) { benchFile(b, 1, true) } |
| func Benchmark_UFlat2(b *testing.B) { benchFile(b, 2, true) } |
| func Benchmark_UFlat3(b *testing.B) { benchFile(b, 3, true) } |
| func Benchmark_UFlat4(b *testing.B) { benchFile(b, 4, true) } |
| func Benchmark_UFlat5(b *testing.B) { benchFile(b, 5, true) } |
| func Benchmark_UFlat6(b *testing.B) { benchFile(b, 6, true) } |
| func Benchmark_UFlat7(b *testing.B) { benchFile(b, 7, true) } |
| func Benchmark_UFlat8(b *testing.B) { benchFile(b, 8, true) } |
| func Benchmark_UFlat9(b *testing.B) { benchFile(b, 9, true) } |
| func Benchmark_UFlat10(b *testing.B) { benchFile(b, 10, true) } |
| func Benchmark_UFlat11(b *testing.B) { benchFile(b, 11, true) } |
| func Benchmark_ZFlat0(b *testing.B) { benchFile(b, 0, false) } |
| func Benchmark_ZFlat1(b *testing.B) { benchFile(b, 1, false) } |
| func Benchmark_ZFlat2(b *testing.B) { benchFile(b, 2, false) } |
| func Benchmark_ZFlat3(b *testing.B) { benchFile(b, 3, false) } |
| func Benchmark_ZFlat4(b *testing.B) { benchFile(b, 4, false) } |
| func Benchmark_ZFlat5(b *testing.B) { benchFile(b, 5, false) } |
| func Benchmark_ZFlat6(b *testing.B) { benchFile(b, 6, false) } |
| func Benchmark_ZFlat7(b *testing.B) { benchFile(b, 7, false) } |
| func Benchmark_ZFlat8(b *testing.B) { benchFile(b, 8, false) } |
| func Benchmark_ZFlat9(b *testing.B) { benchFile(b, 9, false) } |
| func Benchmark_ZFlat10(b *testing.B) { benchFile(b, 10, false) } |
| func Benchmark_ZFlat11(b *testing.B) { benchFile(b, 11, false) } |