Upgrade server dependencies, manage them with govendor

This commit is contained in:
Ken-Håvard Lieng 2017-04-18 03:02:51 +02:00
parent ebee2746d6
commit 971278e7e5
1748 changed files with 196165 additions and 194500 deletions

24
vendor/github.com/dsnet/compress/LICENSE.md generated vendored Normal file
View file

@ -0,0 +1,24 @@
Copyright © 2015, Joe Tsai and The Go Authors. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution.
* Neither the copyright holder nor the names of its contributors may be used to
endorse or promote products derived from this software without specific prior
written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

View file

@ -1,5 +0,0 @@
// Copyright 2015, Joe Tsai. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE.md file.
package brotli

View file

@ -1,225 +0,0 @@
// Copyright 2015, Joe Tsai. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE.md file.
package brotli
import "hash/crc32"
import "bytes"
import "encoding/hex"
import "testing"
func TestTableCRC(t *testing.T) {
// Convert transformLUT to byte array according to Appendix B of the RFC.
var transformBuf bytes.Buffer
for _, t := range transformLUT {
transformBuf.WriteString(t.prefix + "\x00")
transformBuf.WriteByte(byte(t.transform))
transformBuf.WriteString(t.suffix + "\x00")
}
var vectors = []struct {
crc uint32
buf []byte
}{
{crc: 0x5136cb04, buf: dictLUT[:]},
{crc: 0x8e91efb7, buf: contextLUT0[:]},
{crc: 0xd01a32f4, buf: contextLUT1[:]},
{crc: 0x0dd7a0d6, buf: contextLUT2[:]},
{crc: 0x3d965f81, buf: transformBuf.Bytes()},
}
for i, v := range vectors {
crc := crc32.ChecksumIEEE(v.buf)
if crc != v.crc {
t.Errorf("test %d, CRC-32 mismatch: got %08x, want %08x", i, crc, v.crc)
}
}
}
func TestMoveToFront(t *testing.T) {
var vectors = []struct {
input, output string
}{{
input: "",
output: "",
}, {
input: "ff00ff00ff00ff00",
output: "ff01010101010101",
}, {
input: "0000000000000000000000000000000000000000000000000000000000000000" +
"0000000000000000000000000000000000000000000000000000010000000001",
output: "0000000000000000000000000000000000000000000000000000000000000000" +
"0000000000000000000000000000000000000000000000000000010100000001",
}, {
input: "0000000000000000000000010101010101010101010101010101010101010101" +
"0101010101010101010101010101010101010101000000000000000203030004",
output: "0000000000000000000000010000000000000000000000000000000000000000" +
"0000000000000000000000000000000000000000010000000000000203000204",
}, {
input: "00000001",
output: "00000001",
}, {
input: "0000000000000000000000000000000000000000000000000000000000000000" +
"0000000000000000000000000000000000000000000000000000000100000000",
output: "0000000000000000000000000000000000000000000000000000000000000000" +
"0000000000000000000000000000000000000000000000000000000101000000",
}, {
input: "0000000000000000010101010101010101010101010101010101010101010101" +
"0101010101010101010101010101010101010101010101010101010101010101" +
"0101010101010101010200000000000000020203030303030304040505050505" +
"0505050505050505050505050505050505050505050505050505050505050505",
output: "0000000000000000010000000000000000000000000000000000000000000000" +
"0000000000000000000000000000000000000000000000000000000000000000" +
"0000000000000000000202000000000000010003000000000004000500000000" +
"0000000000000000000000000000000000000000000000000000000000000000",
}, {
input: "000000010101000202020003030300040404000505050006",
output: "000000010000010200000103000001040000010500000106",
}, {
input: "0000000000000000000000000000000000000000000000000000000000000000" +
"0000000000000000000000000000000000000000000000000000000000000000" +
"0000000000000000000000000000000000000001010102020202030202020202" +
"0202020202020202020202020202020202020202020202020202020202020202",
output: "0000000000000000000000000000000000000000000000000000000000000000" +
"0000000000000000000000000000000000000000000000000000000000000000" +
"0000000000000000000000000000000000000001000002000000030100000000" +
"0000000000000000000000000000000000000000000000000000000000000000",
}, {
input: "0000000000000000000102020202020202020000000000000000000000000000" +
"0000000000000000000000000000000000000000000000000000000000000000" +
"0000000000000000000302020202020202010103030303030304040505050505" +
"0505050505050505050505050505050505050505050505050505050505050505",
output: "0000000000000000000102000000000000000200000000000000000000000000" +
"0000000000000000000000000000000000000000000000000000000000000000" +
"0000000000000000000302000000000000030002000000000004000500000000" +
"0000000000000000000000000000000000000000000000000000000000000000",
}, {
input: "0000010000000102020201030303010404020105",
output: "0000010100000102000001030000010400030205",
}, {
input: "0000000000000000010202010101010101010202020202020202020202020202" +
"0202020202020202020202020202020202020202020202020202020202020202" +
"0202020202020202020201010101010101020202020202020203040000000000" +
"0000000000000000000000000000000000000000000000000000000000000000" +
"0000000000000000000201010101010101020205050505050503030606060606" +
"0606060606060606060606060606060606060606060606060606060606060606" +
"0606060606060606060202020202020202000702020202020202040404040404" +
"0404040404040404040404040404040404040404040404040404040404040404",
output: "0000000000000000010200010000000000000100000000000000000000000000" +
"0000000000000000000000000000000000000000000000000000000000000000" +
"0000000000000000000001000000000000010000000000000003040400000000" +
"0000000000000000000000000000000000000000000000000000000000000000" +
"0000000000000000000304000000000000010005000000000005000600000000" +
"0000000000000000000000000000000000000000000000000000000000000000" +
"0000000000000000000300000000000000050702000000000000070000000000" +
"0000000000000000000000000000000000000000000000000000000000000000",
}, {
input: "0000000000000001010100020202000303030004040400050505000606060007" +
"070700080808000909090a0a",
output: "0000000000000001000001020000010300000104000001050000010600000107" +
"000001080000010900000a00",
}, {
input: "0000010203030303040000050600070507050201070206060804000400020002" +
"06000200000006000905020000080805050a0202000808080808080105080808" +
"0400050205020505050505050b0205040b0505050505050b0605050505050505" +
"0505050505050505050505050505050502050505050505050505050202050505" +
"040502020b0b0b0b020b0b0b0b0b0b02020b0b0b0b0b0b02020b0b0b0b0b0b0b" +
"0b0b0b0b0b0b0b02020b0b0b0b0b0b0b0b0b0b0b0b0b0b0204020b0b0b050b0a" +
"0c0c02010d0d0d0d0d00060b0d0d0d0d020201020d0d0d0d0c0b02020d0d0d07" +
"04040404070606020b050402060602000e020202060205040404060606040202" +
"040404040404040404040404000000000f0f00090f0f0f0f0f0f0f0b09030d0d" +
"0909060909090101010100000909090909090909010101010101010101010101" +
"0101010101010101010101010d0d0d0d0d0d0d10090c0909090909100f0f0f0f" +
"0f0f07070f0f0f0f0f0f0e0e0f0f0f0f0f0f0f0f0c0c0c0c0c0c0c0c0c0c0c0c" +
"0c0c00080d0d0d0d0d0d020b0d0d0d0d030200010d0d0d0d0d0b02040d0d0d07" +
"0202020207060b020202020206060b0e0e040006060208080808080806060606" +
"00000000000000000000000009090909111111110d0d0d0d1212120900000000" +
"000107060a0a0505050500001212121212121212090909090909090909090909" +
"050511040d0d0d0d0d02040b0d070d0d0a0200010d0d0d0d050b02020d0d0d0d" +
"07020202060b0b0b0402050b02050b07010b00050202020202020c0002020202" +
"02020202020202020202020202020202020202020d0d0d0d0d0d0d0d09090909" +
"09090f0912121212121212121210101010101010090909090909090909090909" +
"0909090909090909090909090909090909090909090909090909090909090909" +
"090909090e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e" +
"0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e" +
"0e0e020211111111111111111111080808080808111111111111111111111111" +
"1111111111111111111111111111111111111111111111111111111111111111" +
"111111110e0e0e0e0e0e0e0e0e030303030303030e0e0e0e0e0e0e0e0e0e0e0e" +
"0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e" +
"0e0e0e0e03030303030303030303030303030303030303030303030303030303",
output: "0000010203000000040400050602070301010607030205000807070101040101" +
"04020201000002010908040300060003000a0400040400000000000905020000" +
"0804030501010100000000000b02020403020000000000010902000000000000" +
"0000000000000000000000000000000004010000000000000000000100010000" +
"0401020004000000010100000000000100010000000000010001000000000000" +
"0000000000000001000100000000000000000000000000010301020000030108" +
"0c0004090d00000000090907030000000500050102000000060403000300000c" +
"0a00000001070004050a0503040001090e020000030105050000030000010300" +
"010000000000000000000000050000000f00010e0200000000000008020f0b00" +
"0200080100000d00000007000200000000000000020000000000000000000000" +
"0000000000000000000000000400000000000010030e01000000000209000000" +
"00000e000100000000000e000100000000000000050000000000000000000000" +
"000008100800000000000e0d020000000d03050c040000000005040e0300000b" +
"03000000010e0503000000000200020c0006080400050a000000000002000000" +
"0300000000000000000000000e000000110000000a0000001200000304000000" +
"000c0c0712001200000005000700000000000000070000000000000000000000" +
"0300090c0a000000000c020e030b01000a050a0c040000000907050003000000" +
"070200000c040000090306030202020507020804050000000000100302000000" +
"000000000000000000000000000000000000000009000000000000000c000000" +
"000011010e000000000000000012000000000000020000000000000000000000" +
"0000000000000000000000000000000000000000000000000000000000000000" +
"0000000011000000000000000000000000000000000000000000000000000000" +
"0000000000000000000000000000000000000000000000000000000000000000" +
"0000060010000000000000000000110000000000010000000000000000000000" +
"0000000000000000000000000000000000000000000000000000000000000000" +
"0000000003000000000000000012000000000000010000000000000000000000" +
"0000000000000000000000000000000000000000000000000000000000000000" +
"0000000001000000000000000000000000000000000000000000000000000000",
}, {
input: "0000000000010101010102020202030303030404040405050505050606060707" +
"07070808",
output: "0000000000010000000002000000030000000400000005000000000600000700" +
"00000800",
}, {
input: "0000000000000000010001010101010101000000000000000002020303030303" +
"0303030303030303030303030303030303030303030303030303030303030303" +
"0303030303030303030401010101010101040005050505050502020303030303" +
"0303030303030303030303030303030303030303030303030303030303030303",
output: "0000000000000000010101000000000000010000000000000002000300000000" +
"0000000000000000000000000000000000000000000000000000000000000000" +
"0000000000000000000404000000000000010405000000000005000500000000" +
"0000000000000000000000000000000000000000000000000000000000000000",
}, {
input: "0000010000000102020101030303010404040105050501060606010707010108" +
"08010109",
output: "0000010100000102000100030000010400000105000001060000010700010008" +
"00010009",
}}
var mtf moveToFront
for i, v := range vectors {
input, _ := hex.DecodeString(v.input)
mtf.Encode(input)
output := append([]uint8(nil), input...)
mtf.Decode(input)
if input := hex.EncodeToString(input); input != v.input {
t.Errorf("test %d, input differs:\ngot %v\nwant %v", i, input, v.input)
}
if output := hex.EncodeToString(output); output != v.output {
t.Errorf("test %d, output differs:\ngot %v\nwant %v", i, output, v.output)
}
}
}
// This package relies on dynamic generation of LUTs to reduce the static
// binary size. This benchmark attempts to measure the startup cost of init.
// This benchmark is not thread-safe; so do not run it in parallel with other
// tests or benchmarks!
func BenchmarkInit(b *testing.B) {
b.ReportAllocs()
for i := 0; i < b.N; i++ {
initLUTs()
}
}

View file

@ -1,161 +0,0 @@
// Copyright 2015, Joe Tsai. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE.md file.
package brotli
import "bytes"
import "strings"
import "testing"
func TestDictDecoder(t *testing.T) {
const abc = "ABC\n"
const fox = "The quick brown fox jumped over the lazy dog!\n"
const poem = "The Road Not Taken\nRobert Frost\n" +
"\n" +
"Two roads diverged in a yellow wood,\n" +
"And sorry I could not travel both\n" +
"And be one traveler, long I stood\n" +
"And looked down one as far as I could\n" +
"To where it bent in the undergrowth;\n" +
"\n" +
"Then took the other, as just as fair,\n" +
"And having perhaps the better claim,\n" +
"Because it was grassy and wanted wear;\n" +
"Though as for that the passing there\n" +
"Had worn them really about the same,\n" +
"\n" +
"And both that morning equally lay\n" +
"In leaves no step had trodden black.\n" +
"Oh, I kept the first for another day!\n" +
"Yet knowing how way leads on to way,\n" +
"I doubted if I should ever come back.\n" +
"\n" +
"I shall be telling this with a sigh\n" +
"Somewhere ages and ages hence:\n" +
"Two roads diverged in a wood, and I-\n" +
"I took the one less traveled by,\n" +
"And that has made all the difference.\n"
var refs = []struct {
dist int // Backward distance (0 if this is an insertion)
length int // Length of copy or insertion
}{
{0, 38}, {33, 3}, {0, 48}, {79, 3}, {0, 11}, {34, 5}, {0, 6}, {23, 7},
{0, 8}, {50, 3}, {0, 2}, {69, 3}, {34, 5}, {0, 4}, {97, 3}, {0, 4},
{43, 5}, {0, 6}, {7, 4}, {88, 7}, {0, 12}, {80, 3}, {0, 2}, {141, 4},
{0, 1}, {196, 3}, {0, 3}, {157, 3}, {0, 6}, {181, 3}, {0, 2}, {23, 3},
{77, 3}, {28, 5}, {128, 3}, {110, 4}, {70, 3}, {0, 4}, {85, 6}, {0, 2},
{182, 6}, {0, 4}, {133, 3}, {0, 7}, {47, 5}, {0, 20}, {112, 5}, {0, 1},
{58, 3}, {0, 8}, {59, 3}, {0, 4}, {173, 3}, {0, 5}, {114, 3}, {0, 4},
{92, 5}, {0, 2}, {71, 3}, {0, 2}, {76, 5}, {0, 1}, {46, 3}, {96, 4},
{130, 4}, {0, 3}, {360, 3}, {0, 3}, {178, 5}, {0, 7}, {75, 3}, {0, 3},
{45, 6}, {0, 6}, {299, 6}, {180, 3}, {70, 6}, {0, 1}, {48, 3}, {66, 4},
{0, 3}, {47, 5}, {0, 9}, {325, 3}, {0, 1}, {359, 3}, {318, 3}, {0, 2},
{199, 3}, {0, 1}, {344, 3}, {0, 3}, {248, 3}, {0, 10}, {310, 3}, {0, 3},
{93, 6}, {0, 3}, {252, 3}, {157, 4}, {0, 2}, {273, 5}, {0, 14}, {99, 4},
{0, 1}, {464, 4}, {0, 2}, {92, 4}, {495, 3}, {0, 1}, {322, 4}, {16, 4},
{0, 3}, {402, 3}, {0, 2}, {237, 4}, {0, 2}, {432, 4}, {0, 1}, {483, 5},
{0, 2}, {294, 4}, {0, 2}, {306, 3}, {113, 5}, {0, 1}, {26, 4}, {164, 3},
{488, 4}, {0, 1}, {542, 3}, {248, 6}, {0, 5}, {205, 3}, {0, 8}, {48, 3},
{449, 6}, {0, 2}, {192, 3}, {328, 4}, {9, 5}, {433, 3}, {0, 3}, {622, 25},
{615, 5}, {46, 5}, {0, 2}, {104, 3}, {475, 10}, {549, 3}, {0, 4}, {597, 8},
{314, 3}, {0, 1}, {473, 6}, {317, 5}, {0, 1}, {400, 3}, {0, 3}, {109, 3},
{151, 3}, {48, 4}, {0, 4}, {125, 3}, {108, 3}, {0, 2},
}
var want string
var buf bytes.Buffer
var dd dictDecoder
dd.Init(1 << 11)
var checkLastBytes = func(str string) {
if len(str) < 2 {
str = "\x00\x00" + str
}
str = str[len(str)-2:]
p1, p2 := dd.LastBytes()
got := string([]byte{p2, p1})
if got != str {
t.Errorf("last bytes mismatch: got %q, want %q", got, str)
}
}
var writeCopy = func(dist, length int) {
if dist < length {
cnt := (dist + length - 1) / dist
want += strings.Repeat(want[len(want)-dist:], cnt)[:length]
} else {
want += want[len(want)-dist:][:length]
}
for length > 0 {
length -= dd.WriteCopy(dist, length)
if dd.AvailSize() == 0 {
buf.Write(dd.ReadFlush())
}
}
checkLastBytes(want)
}
var writeString = func(str string) {
want += str
for len(str) > 0 {
cnt := copy(dd.WriteSlice(), str)
str = str[cnt:]
dd.WriteMark(cnt)
if dd.AvailSize() == 0 {
buf.Write(dd.ReadFlush())
}
}
checkLastBytes(want)
}
writeString("")
writeString(".")
str := poem
for _, ref := range refs {
if ref.dist == 0 {
writeString(str[:ref.length])
} else {
writeCopy(ref.dist, ref.length)
}
str = str[ref.length:]
}
writeCopy(dd.HistSize(), 33)
writeString(abc)
writeCopy(len(abc), 59*len(abc))
writeString(fox)
writeCopy(len(fox), 9*len(fox))
writeString(".")
writeCopy(1, 9)
writeString(strings.ToUpper(poem))
writeCopy(len(poem), 7*len(poem))
writeCopy(dd.HistSize(), 10)
buf.Write(dd.ReadFlush())
if buf.String() != want {
t.Errorf("final string mismatch:\ngot %q\nwant %q", buf.String(), want)
}
}
func BenchmarkDictDecoderCopy(b *testing.B) {
nb := 1 << 24
b.SetBytes(int64(nb))
for i := 0; i < b.N; i++ {
var dd dictDecoder
dd.Init(1 << 16)
copy(dd.WriteSlice(), "abc")
dd.WriteMark(3)
dist, length := 3, nb
for length > 0 {
length -= dd.WriteCopy(dist, length)
if dd.AvailSize() == 0 {
dd.ReadFlush()
}
}
}
}

View file

@ -1,5 +0,0 @@
// Copyright 2015, Joe Tsai. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE.md file.
package brotli

View file

@ -1,5 +0,0 @@
// Copyright 2015, Joe Tsai. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE.md file.
package brotli

View file

@ -1,455 +0,0 @@
// Copyright 2015, Joe Tsai. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE.md file.
package brotli
import "io"
import "io/ioutil"
import "bufio"
import "bytes"
import "strings"
import "encoding/hex"
import "runtime"
import "testing"
func TestReader(t *testing.T) {
var vectors = []struct {
desc string // Description of the test
input string // Test input string in hex
output string // Expected output string in hex
inIdx int64 // Expected input offset after reading
outIdx int64 // Expected output offset after reading
err error // Expected error
}{{
desc: "empty string (truncated)",
err: io.ErrUnexpectedEOF,
}, {
desc: "empty last block (WBITS: 16)",
input: "06",
inIdx: 1,
}, {
desc: "empty last block (WBITS: 12)",
input: "c101",
inIdx: 2,
}, {
desc: "empty last block (WBITS: 17)",
input: "8101",
inIdx: 2,
}, {
desc: "empty last block (WBITS: 21)",
input: "39",
inIdx: 1,
}, {
desc: "empty last block (WBITS: invalid)",
input: "9101",
inIdx: 1,
err: ErrCorrupt,
}, {
desc: "empty last block (trash at the end)",
input: "06ff",
inIdx: 1,
}, {
desc: "empty last block (padding is non-zero)",
input: "16",
inIdx: 1,
err: ErrCorrupt,
}, {
desc: "empty meta data block (MLEN: 0)",
input: "0c03",
inIdx: 2,
}, {
desc: "meta data block",
input: "2c0648656c6c6f2c20776f726c642103",
inIdx: 16,
}, {
desc: "meta data block (truncated)",
input: "2c06",
inIdx: 2,
err: io.ErrUnexpectedEOF,
}, {
desc: "meta data block (use reserved bit)",
input: "3c0648656c6c6f2c20776f726c642103",
inIdx: 1,
err: ErrCorrupt,
}, {
desc: "meta data block (meta padding is non-zero)",
input: "2c8648656c6c6f2c20776f726c642103",
inIdx: 2,
err: ErrCorrupt,
}, {
desc: "meta data block (non-minimal MLEN)",
input: "4c060048656c6c6f2c20776f726c642103",
inIdx: 3,
err: ErrCorrupt,
}, {
desc: "meta data block (MLEN: 1<<0)",
input: "2c00ff03",
inIdx: 4,
}, {
desc: "meta data block (MLEN: 1<<24)",
input: "ecffff7f" + strings.Repeat("f0", 1<<24) + "03",
inIdx: 5 + 1<<24,
}, {
desc: "raw data block",
input: "c0001048656c6c6f2c20776f726c642103",
output: "48656c6c6f2c20776f726c6421",
inIdx: 17,
outIdx: 13,
}, {
desc: "raw data block (truncated)",
input: "c00010",
inIdx: 3,
err: io.ErrUnexpectedEOF,
}, {
desc: "raw data block (raw padding is non-zero)",
input: "c000f048656c6c6f2c20776f726c642103",
inIdx: 3,
err: ErrCorrupt,
}, {
desc: "raw data block (non-minimal MLEN)",
input: "c400000148656c6c6f2c20776f726c642103",
inIdx: 3,
err: ErrCorrupt,
}, {
desc: "raw data block (MLEN: 1<<0)",
input: "0000106103",
output: "61",
inIdx: 4 + 1<<0,
outIdx: 1 << 0,
}, {
desc: "raw data block (MLEN: 1<<24)",
input: "f8ffff1f" + strings.Repeat("f0", 1<<24) + "03",
output: strings.Repeat("f0", 1<<24),
inIdx: 5 + 1<<24,
outIdx: 1 << 24,
}, {
desc: "simple prefix (|L|:1 |I|:1 |D|:1 MLEN:1)",
input: "00000000c4682010c0",
output: "a3",
inIdx: 9,
outIdx: 1,
}, {
desc: "simple prefix, out-of-order (|L|:2 |I|:1 |D|:1 MLEN:1)",
input: "00000000d4a8682010c001",
output: "a3",
inIdx: 11,
outIdx: 1,
}, {
desc: "simple prefix, non-unique (|L|:2 |I|:1 |D|:1 MLEN:1)",
input: "00000000d4e8682010c001",
output: "",
inIdx: 7,
outIdx: 0,
err: ErrCorrupt,
}, {
desc: "simple prefix, out-of-order (|L|:3 |I|:1 |D|:1 MLEN:1)",
input: "0000000024e8e96820104003",
output: "a3",
inIdx: 12,
outIdx: 1,
}, {
desc: "simple prefix, out-of-order, no-tree-select (|L|:4 |I|:1 |D|:1 MLEN:1)",
input: "0000000034e8e968a840208006",
output: "a3",
inIdx: 13,
outIdx: 1,
}, {
desc: "simple prefix, out-of-order, yes-tree-select (|L|:4 |I|:1 |D|:1 MLEN:1)",
input: "0000000034e8e968e94020800d",
output: "a3",
inIdx: 13,
outIdx: 1,
}, {
desc: "simple prefix, max-sym-ok (|L|:1 |I|:2 |D|:1 MLEN:1)",
input: "00000000c46821f06b0006",
output: "a3",
inIdx: 11,
outIdx: 1,
}, {
desc: "simple prefix, max-sym-bad (|L|:1 |I|:2 |D|:1 MLEN:1)",
input: "00000000c46821006c0006",
output: "",
inIdx: 9,
outIdx: 0,
err: ErrCorrupt,
}, {
desc: "complex prefix, skip-zero, terminate-clens-codes (|L|:1 |I|:2 |D|:1 MLEN:1)",
input: "0000000070472010c001",
output: "01",
inIdx: 10,
outIdx: 1,
}, {
desc: "complex prefix, skip-zero, terminate-clens-codes (|L|:1 |I|:2 |D|:1 MLEN:1)",
input: "0000000070c01d080470",
output: "01",
inIdx: 10,
outIdx: 1,
}, {
desc: "complex prefix, skip-zero, terminate-clens-codes (|L|:1 |I|:2 |D|:1 MLEN:2)",
input: "1000000070c01d1004d0",
output: "0100",
inIdx: 10,
outIdx: 2,
}, {
desc: "complex prefix, skip-zero, terminate-codes (|L|:1 |I|:4 |D|:1 MLEN:3)",
input: "20000000b0c100000056151804700e",
output: "030201",
inIdx: 15,
outIdx: 3,
}, {
desc: "complex prefix, skip-zero, under-subscribed (|L|:1 |I|:4 |D|:1 MLEN:3)",
input: "20000000b0c1000000ae2a3008e01c",
output: "",
inIdx: 10,
outIdx: 0,
err: ErrCorrupt,
}, {
desc: "complex prefix, skip-zero, over-subscribed (|L|:1 |I|:4 |D|:1 MLEN:3)",
input: "20000000b0c1000000ac0a0c023807",
output: "",
inIdx: 10,
outIdx: 0,
err: ErrCorrupt,
}, {
desc: "complex prefix, skip-zero, single clens (|L|:1 |I|:256 |D|:1 MLEN:4)",
input: "30000000000000020001420000a5ff5503",
output: "00a5ffaa",
inIdx: 17,
outIdx: 4,
}, {
desc: "complex prefix, skip-zero, single clens (|L|:1 |I|:32 |D|:1 MLEN:4)",
input: "3000000000c001000004080100faf7",
output: "00051f1b",
inIdx: 15,
outIdx: 4,
}, {
desc: "complex prefix, skip-zero, single clens, zero clen (|L|:1 |I|:? |D|:1 MLEN:4)",
input: "30000000007000000004080100faf7",
output: "",
inIdx: 10,
outIdx: 0,
err: ErrCorrupt,
}, {
desc: "complex prefix, skip-zero, empty clens (|L|:1 |I|:? |D|:1 MLEN:4)",
input: "30000000000000000001420080fe3d",
output: "",
inIdx: 9,
outIdx: 0,
err: ErrCorrupt,
}, {
desc: "complex prefix, skip-zero, single clens, rep-last clen (|L|:1 |I|:256 |D|:1 MLEN:4)",
input: "3000000000002000006a014200aa33cc5503",
output: "55cc33aa",
inIdx: 18,
outIdx: 4,
}, {
desc: "complex prefix, skip-zero, single clens, rep-last clen, over-subscribed (|L|:1 |I|:257 |D|:1 MLEN:4)",
input: "300000000000200000aa014200aa33cc5503",
output: "",
inIdx: 10,
outIdx: 0,
err: ErrCorrupt,
}, {
desc: "complex prefix, skip-zero, single clens, rep-last clen, integer overflow (|L|:1 |I|:1018 |D|:1 MLEN:4)",
input: "3000000000002000002a070801a8ce30570d",
output: "",
inIdx: 11,
outIdx: 0,
err: ErrCorrupt,
}, {
desc: "complex prefix, skip-two, single clens, rep-last clen (|L|:1 |I|:256 |D|:1 MLEN:4)",
input: "3000000008000f00805a801080ea0c73d5",
output: "55cc33aa",
inIdx: 17,
outIdx: 4,
}, {
desc: "complex prefix, skip-three, single clens, rep-last clen (|L|:1 |I|:256 |D|:1 MLEN:4)",
input: "300000000cc00300a0162004a03ac35c35",
output: "55cc33aa",
inIdx: 17,
outIdx: 4,
}, {
desc: "complex prefix, skip-zero, linear clens (|L|:1 |I|:16 |D|:1 MLEN:16)",
input: "f000000050555555ffff8bd5169058d43cb2fadcf77f201480dabdeff7f7efbf" +
"fffddffffbfffe7fffff01",
output: "6162636465666768696a6b6c6d6e6f70",
inIdx: 43,
outIdx: 16,
}, {
desc: "complex prefix, skip-zero, mixed clens (|L|:1 |I|:192 |D|:1 MLEN:16)",
input: "f000000050555555ffffe37a310f369a4d4b80756cc779b0619a02a1002c29ab" +
"ec066084eee99dfd67d8ac18",
output: "000240525356575e717a8abcbdbed7d9",
inIdx: 44,
outIdx: 16,
}, {
desc: "compressed string: \"Hello, world! Hello, world!\"",
input: "1b1a00008c946ed6540dc2825426d942de6a9668ea996c961e00",
output: "48656c6c6f2c20776f726c64212048656c6c6f2c20776f726c6421",
inIdx: 26,
outIdx: 27,
}, {
desc: "compressed string (padding is non-zero): \"Hello, world! Hello, world!\"",
input: "1b1a00008c946ed6540dc2825426d942de6a9668ea996c961e80",
output: "48656c6c6f2c20776f726c64212048656c6c6f2c20776f726c6421",
inIdx: 26,
outIdx: 27,
err: ErrCorrupt,
}}
for i, v := range vectors {
input, _ := hex.DecodeString(v.input)
rd, err := NewReader(bytes.NewReader(input), nil)
if err != nil {
t.Errorf("test %d, unexpected NewReader error: %v", i, err)
}
data, err := ioutil.ReadAll(rd)
output := hex.EncodeToString(data)
if err != v.err {
t.Errorf("test %d, %s\nerror mismatch: got %v, want %v", i, v.desc, err, v.err)
}
if output != v.output {
t.Errorf("test %d, %s\noutput mismatch:\ngot %v\nwant %v", i, v.desc, output, v.output)
}
if rd.InputOffset != v.inIdx {
t.Errorf("test %d, %s\ninput offset mismatch: got %d, want %d", i, v.desc, rd.InputOffset, v.inIdx)
}
if rd.OutputOffset != v.outIdx {
t.Errorf("test %d, %s\noutput offset mismatch: got %d, want %d", i, v.desc, rd.OutputOffset, v.outIdx)
}
}
}
func TestReaderGolden(t *testing.T) {
var vectors = []struct {
input string // Input filename
output string // Output filename
}{
{"empty.br", "empty"},
{"empty.00.br", "empty"},
{"empty.01.br", "empty"},
{"empty.02.br", "empty"},
{"empty.03.br", "empty"},
{"empty.04.br", "empty"},
{"empty.05.br", "empty"},
{"empty.06.br", "empty"},
{"empty.07.br", "empty"},
{"empty.08.br", "empty"},
{"empty.09.br", "empty"},
{"empty.10.br", "empty"},
{"empty.11.br", "empty"},
{"empty.12.br", "empty"},
{"empty.13.br", "empty"},
{"empty.14.br", "empty"},
{"empty.15.br", "empty"},
{"empty.16.br", "empty"},
{"empty.17.br", "empty"},
{"empty.18.br", "empty"},
{"zeros.br", "zeros"},
{"x.br", "x"},
{"x.00.br", "x"},
{"x.01.br", "x"},
{"x.02.br", "x"},
{"x.03.br", "x"},
{"xyzzy.br", "xyzzy"},
{"10x10y.br", "10x10y"},
{"64x.br", "64x"},
{"backward65536.br", "backward65536"},
{"quickfox.br", "quickfox"},
{"quickfox_repeated.br", "quickfox_repeated"},
{"ukkonooa.br", "ukkonooa"},
{"monkey.br", "monkey"},
{"random_org_10k.bin.br", "random_org_10k.bin"},
{"asyoulik.txt.br", "asyoulik.txt"},
{"compressed_file.br", "compressed_file"},
{"compressed_repeated.br", "compressed_repeated"},
{"alice29.txt.br", "alice29.txt"},
{"lcet10.txt.br", "lcet10.txt"},
{"mapsdatazrh.br", "mapsdatazrh"},
{"plrabn12.txt.br", "plrabn12.txt"},
}
for i, v := range vectors {
input, err := ioutil.ReadFile("testdata/" + v.input)
if err != nil {
t.Errorf("test %d: %s\n%v", i, v.input, err)
continue
}
output, err := ioutil.ReadFile("testdata/" + v.output)
if err != nil {
t.Errorf("test %d: %s\n%v", i, v.output, err)
continue
}
rd, err := NewReader(bytes.NewReader(input), nil)
if err != nil {
t.Errorf("test %d, unexpected NewReader error: %v", i, err)
}
data, err := ioutil.ReadAll(rd)
if err != nil {
t.Errorf("test %d, %s\nerror mismatch: got %v, want nil", i, v.input, err)
}
if string(data) != string(output) {
t.Errorf("test %d, %s\noutput mismatch:\ngot %q\nwant %q", i, v.input, string(data), string(output))
}
}
}
func benchmarkDecode(b *testing.B, testfile string) {
b.StopTimer()
b.ReportAllocs()
input, err := ioutil.ReadFile("testdata/" + testfile)
if err != nil {
b.Fatal(err)
}
r, err := NewReader(bytes.NewReader(input), nil)
if err != nil {
b.Fatal(err)
}
output, err := ioutil.ReadAll(r)
if err != nil {
b.Fatal(err)
}
nb := int64(len(output))
output = nil
runtime.GC()
b.SetBytes(nb)
b.StartTimer()
for i := 0; i < b.N; i++ {
r, err := NewReader(bufio.NewReader(bytes.NewReader(input)), nil)
if err != nil {
b.Fatal(err)
}
cnt, err := io.Copy(ioutil.Discard, r)
if err != nil {
b.Fatalf("unexpected error: %v", err)
}
if cnt != nb {
b.Fatalf("unexpected count: got %d, want %d", cnt, nb)
}
}
}
func BenchmarkDecodeDigitsSpeed1e4(b *testing.B) { benchmarkDecode(b, "digits-speed-1e4.br") }
func BenchmarkDecodeDigitsSpeed1e5(b *testing.B) { benchmarkDecode(b, "digits-speed-1e5.br") }
func BenchmarkDecodeDigitsSpeed1e6(b *testing.B) { benchmarkDecode(b, "digits-speed-1e6.br") }
func BenchmarkDecodeDigitsDefault1e4(b *testing.B) { benchmarkDecode(b, "digits-default-1e4.br") }
func BenchmarkDecodeDigitsDefault1e5(b *testing.B) { benchmarkDecode(b, "digits-default-1e5.br") }
func BenchmarkDecodeDigitsDefault1e6(b *testing.B) { benchmarkDecode(b, "digits-default-1e6.br") }
func BenchmarkDecodeDigitsCompress1e4(b *testing.B) { benchmarkDecode(b, "digits-best-1e4.br") }
func BenchmarkDecodeDigitsCompress1e5(b *testing.B) { benchmarkDecode(b, "digits-best-1e5.br") }
func BenchmarkDecodeDigitsCompress1e6(b *testing.B) { benchmarkDecode(b, "digits-best-1e6.br") }
func BenchmarkDecodeTwainSpeed1e4(b *testing.B) { benchmarkDecode(b, "twain-speed-1e4.br") }
func BenchmarkDecodeTwainSpeed1e5(b *testing.B) { benchmarkDecode(b, "twain-speed-1e5.br") }
func BenchmarkDecodeTwainSpeed1e6(b *testing.B) { benchmarkDecode(b, "twain-speed-1e6.br") }
func BenchmarkDecodeTwainDefault1e4(b *testing.B) { benchmarkDecode(b, "twain-default-1e4.br") }
func BenchmarkDecodeTwainDefault1e5(b *testing.B) { benchmarkDecode(b, "twain-default-1e5.br") }
func BenchmarkDecodeTwainDefault1e6(b *testing.B) { benchmarkDecode(b, "twain-default-1e6.br") }
func BenchmarkDecodeTwainCompress1e4(b *testing.B) { benchmarkDecode(b, "twain-best-1e4.br") }
func BenchmarkDecodeTwainCompress1e5(b *testing.B) { benchmarkDecode(b, "twain-best-1e5.br") }
func BenchmarkDecodeTwainCompress1e6(b *testing.B) { benchmarkDecode(b, "twain-best-1e6.br") }

View file

@ -1,61 +0,0 @@
// Copyright 2015, Joe Tsai. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE.md file.
package brotli
import "testing"
func TestTransform(t *testing.T) {
var vectors = []struct {
id int
input string
output string
}{
{id: 0, input: "Hello, world!", output: "Hello, world!"},
{id: 23, input: "groups of", output: "groups"},
{id: 42, input: "s for the ", output: "s for "},
{id: 48, input: "presentation", output: "prese"},
{id: 56, input: "maintenance", output: "maint"},
{id: 23, input: "Alexandria", output: "Alexand"},
{id: 23, input: "archives", output: "archi"},
{id: 49, input: "fighty", output: "fighting "},
{id: 49, input: "12", output: "1ing "},
{id: 49, input: "1", output: "ing "},
{id: 49, input: "", output: "ing "},
{id: 64, input: "123456789a", output: "1"},
{id: 64, input: "123456789", output: ""},
{id: 64, input: "1", output: ""},
{id: 64, input: "", output: ""},
{id: 3, input: "afloat", output: "float"},
{id: 3, input: "12", output: "2"},
{id: 3, input: "1", output: ""},
{id: 3, input: "", output: ""},
{id: 54, input: "123456789a", output: "a"},
{id: 54, input: "123456789", output: ""},
{id: 54, input: "1", output: ""},
{id: 54, input: "", output: ""},
{id: 73, input: "", output: " the of the "},
{id: 73, input: "dichlorodifluoromethanes", output: " the dichlorodifluoromethanes of the "},
{id: 15, input: "", output: " "},
{id: 15, input: "meow", output: " Meow "},
{id: 15, input: "-scale", output: " -scale "},
{id: 15, input: "почти", output: " Почти "},
{id: 15, input: "互联网", output: " 亗联网 "},
{id: 119, input: "", output: " ='"},
{id: 119, input: "meow", output: " MEOW='"},
{id: 119, input: "-scale", output: " -SCALE='"},
{id: 119, input: "почти", output: " ПОѧѢИ='"},
{id: 119, input: "互联网", output: " 亗聑罔='"},
}
var buf [maxWordSize]byte
for i, v := range vectors {
cnt := transformWord(buf[:], []byte(v.input), v.id)
output := string(buf[:cnt])
if output != v.output {
t.Errorf("test %d, output mismatch: got %q, want %q", i, output, v.output)
}
}
}

View file

@ -1,5 +0,0 @@
// Copyright 2015, Joe Tsai. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE.md file.
package brotli