bump modules
This commit is contained in:
parent
3124a1bd36
commit
e155660ab0
5
go.mod
5
go.mod
@ -1,6 +1,7 @@
|
|||||||
module novit.nc/direktil/pkg
|
module novit.nc/direktil/pkg
|
||||||
|
|
||||||
require (
|
require (
|
||||||
github.com/ulikunitz/xz v0.5.4
|
github.com/ulikunitz/xz v0.5.5
|
||||||
gopkg.in/yaml.v2 v2.2.1
|
gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
|
||||||
|
gopkg.in/yaml.v2 v2.2.2
|
||||||
)
|
)
|
||||||
|
8
go.sum
Normal file
8
go.sum
Normal file
@ -0,0 +1,8 @@
|
|||||||
|
github.com/ulikunitz/xz v0.5.4/go.mod h1:2bypXElzHzzJZwzH67Y6wb67pO62Rzfn7BSiF4ABRW8=
|
||||||
|
github.com/ulikunitz/xz v0.5.5 h1:pFrO0lVpTBXLpYw+pnLj6TbvHuyjXMfjGeCwSqCVwok=
|
||||||
|
github.com/ulikunitz/xz v0.5.5/go.mod h1:2bypXElzHzzJZwzH67Y6wb67pO62Rzfn7BSiF4ABRW8=
|
||||||
|
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
|
||||||
|
gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
|
||||||
|
gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
|
||||||
|
gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
|
||||||
|
gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
|
16
vendor/github.com/ulikunitz/xz/README.md
generated
vendored
16
vendor/github.com/ulikunitz/xz/README.md
generated
vendored
@ -12,22 +12,23 @@ have been developed over a long time and are highly optimized. However
|
|||||||
there are a number of improvements planned and I'm very optimistic about
|
there are a number of improvements planned and I'm very optimistic about
|
||||||
parallel compression and decompression. Stay tuned!
|
parallel compression and decompression. Stay tuned!
|
||||||
|
|
||||||
# Using the API
|
## Using the API
|
||||||
|
|
||||||
The following example program shows how to use the API.
|
The following example program shows how to use the API.
|
||||||
|
|
||||||
package main
|
```go
|
||||||
|
package main
|
||||||
|
|
||||||
import (
|
import (
|
||||||
"bytes"
|
"bytes"
|
||||||
"io"
|
"io"
|
||||||
"log"
|
"log"
|
||||||
"os"
|
"os"
|
||||||
|
|
||||||
"github.com/ulikunitz/xz"
|
"github.com/ulikunitz/xz"
|
||||||
)
|
)
|
||||||
|
|
||||||
func main() {
|
func main() {
|
||||||
const text = "The quick brown fox jumps over the lazy dog.\n"
|
const text = "The quick brown fox jumps over the lazy dog.\n"
|
||||||
var buf bytes.Buffer
|
var buf bytes.Buffer
|
||||||
// compress text
|
// compress text
|
||||||
@ -49,9 +50,10 @@ The following example program shows how to use the API.
|
|||||||
if _, err = io.Copy(os.Stdout, r); err != nil {
|
if _, err = io.Copy(os.Stdout, r); err != nil {
|
||||||
log.Fatalf("io.Copy error %s", err)
|
log.Fatalf("io.Copy error %s", err)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
```
|
||||||
|
|
||||||
# Using the gxz compression tool
|
## Using the gxz compression tool
|
||||||
|
|
||||||
The package includes a gxz command line utility for compression and
|
The package includes a gxz command line utility for compression and
|
||||||
decompression.
|
decompression.
|
||||||
|
4
vendor/github.com/ulikunitz/xz/TODO.md
generated
vendored
4
vendor/github.com/ulikunitz/xz/TODO.md
generated
vendored
@ -86,6 +86,10 @@
|
|||||||
|
|
||||||
## Log
|
## Log
|
||||||
|
|
||||||
|
### 2018-10-28
|
||||||
|
|
||||||
|
Release v0.5.5 fixes issues #19 observing ErrLimit outputs.
|
||||||
|
|
||||||
### 2017-06-05
|
### 2017-06-05
|
||||||
|
|
||||||
Release v0.5.4 fixes issues #15 of another problem with the padding size
|
Release v0.5.4 fixes issues #15 of another problem with the padding size
|
||||||
|
33
vendor/github.com/ulikunitz/xz/bits_test.go
generated
vendored
33
vendor/github.com/ulikunitz/xz/bits_test.go
generated
vendored
@ -1,33 +0,0 @@
|
|||||||
// Copyright 2014-2017 Ulrich Kunitz. All rights reserved.
|
|
||||||
// Use of this source code is governed by a BSD-style
|
|
||||||
// license that can be found in the LICENSE file.
|
|
||||||
|
|
||||||
package xz
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"testing"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestUvarint(t *testing.T) {
|
|
||||||
tests := []uint64{0, 0x80, 0x100, 0xffffffff, 0x100000000, 1<<64 - 1}
|
|
||||||
p := make([]byte, 10)
|
|
||||||
for _, u := range tests {
|
|
||||||
p = p[:10]
|
|
||||||
n := putUvarint(p, u)
|
|
||||||
if n < 1 {
|
|
||||||
t.Fatalf("putUvarint returned %d", n)
|
|
||||||
}
|
|
||||||
r := bytes.NewReader(p[:n])
|
|
||||||
x, m, err := readUvarint(r)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("readUvarint returned %s", err)
|
|
||||||
}
|
|
||||||
if m != n {
|
|
||||||
t.Fatalf("readUvarint read %d bytes; want %d", m, n)
|
|
||||||
}
|
|
||||||
if x != u {
|
|
||||||
t.Fatalf("readUvarint returned 0x%x; want 0x%x", x, u)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
142
vendor/github.com/ulikunitz/xz/format_test.go
generated
vendored
142
vendor/github.com/ulikunitz/xz/format_test.go
generated
vendored
@ -1,142 +0,0 @@
|
|||||||
// Copyright 2014-2017 Ulrich Kunitz. All rights reserved.
|
|
||||||
// Use of this source code is governed by a BSD-style
|
|
||||||
// license that can be found in the LICENSE file.
|
|
||||||
|
|
||||||
package xz
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"testing"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestHeader(t *testing.T) {
|
|
||||||
h := header{flags: CRC32}
|
|
||||||
data, err := h.MarshalBinary()
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("MarshalBinary error %s", err)
|
|
||||||
}
|
|
||||||
var g header
|
|
||||||
if err = g.UnmarshalBinary(data); err != nil {
|
|
||||||
t.Fatalf("UnmarshalBinary error %s", err)
|
|
||||||
}
|
|
||||||
if g != h {
|
|
||||||
t.Fatalf("unmarshalled %#v; want %#v", g, h)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestFooter(t *testing.T) {
|
|
||||||
f := footer{indexSize: 64, flags: CRC32}
|
|
||||||
data, err := f.MarshalBinary()
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("MarshalBinary error %s", err)
|
|
||||||
}
|
|
||||||
var g footer
|
|
||||||
if err = g.UnmarshalBinary(data); err != nil {
|
|
||||||
t.Fatalf("UnmarshalBinary error %s", err)
|
|
||||||
}
|
|
||||||
if g != f {
|
|
||||||
t.Fatalf("unmarshalled %#v; want %#v", g, f)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestRecord(t *testing.T) {
|
|
||||||
r := record{1234567, 10000}
|
|
||||||
p, err := r.MarshalBinary()
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("MarshalBinary error %s", err)
|
|
||||||
}
|
|
||||||
n := len(p)
|
|
||||||
buf := bytes.NewReader(p)
|
|
||||||
g, m, err := readRecord(buf)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("readFrom error %s", err)
|
|
||||||
}
|
|
||||||
if m != n {
|
|
||||||
t.Fatalf("read %d bytes; wrote %d", m, n)
|
|
||||||
}
|
|
||||||
if g.unpaddedSize != r.unpaddedSize {
|
|
||||||
t.Fatalf("got unpaddedSize %d; want %d", g.unpaddedSize,
|
|
||||||
r.unpaddedSize)
|
|
||||||
}
|
|
||||||
if g.uncompressedSize != r.uncompressedSize {
|
|
||||||
t.Fatalf("got uncompressedSize %d; want %d", g.uncompressedSize,
|
|
||||||
r.uncompressedSize)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestIndex(t *testing.T) {
|
|
||||||
records := []record{{1234, 1}, {2345, 2}}
|
|
||||||
|
|
||||||
var buf bytes.Buffer
|
|
||||||
n, err := writeIndex(&buf, records)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("writeIndex error %s", err)
|
|
||||||
}
|
|
||||||
if n != int64(buf.Len()) {
|
|
||||||
t.Fatalf("writeIndex returned %d; want %d", n, buf.Len())
|
|
||||||
}
|
|
||||||
|
|
||||||
// indicator
|
|
||||||
c, err := buf.ReadByte()
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("buf.ReadByte error %s", err)
|
|
||||||
}
|
|
||||||
if c != 0 {
|
|
||||||
t.Fatalf("indicator %d; want %d", c, 0)
|
|
||||||
}
|
|
||||||
|
|
||||||
g, m, err := readIndexBody(&buf)
|
|
||||||
if err != nil {
|
|
||||||
for i, r := range g {
|
|
||||||
t.Logf("records[%d] %v", i, r)
|
|
||||||
}
|
|
||||||
t.Fatalf("readIndexBody error %s", err)
|
|
||||||
}
|
|
||||||
if m != n-1 {
|
|
||||||
t.Fatalf("readIndexBody returned %d; want %d", m, n-1)
|
|
||||||
}
|
|
||||||
for i, rec := range records {
|
|
||||||
if g[i] != rec {
|
|
||||||
t.Errorf("records[%d] is %v; want %v", i, g[i], rec)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestBlockHeader(t *testing.T) {
|
|
||||||
h := blockHeader{
|
|
||||||
compressedSize: 1234,
|
|
||||||
uncompressedSize: -1,
|
|
||||||
filters: []filter{&lzmaFilter{4096}},
|
|
||||||
}
|
|
||||||
data, err := h.MarshalBinary()
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("MarshalBinary error %s", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
r := bytes.NewReader(data)
|
|
||||||
g, n, err := readBlockHeader(r)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("readBlockHeader error %s", err)
|
|
||||||
}
|
|
||||||
if n != len(data) {
|
|
||||||
t.Fatalf("readBlockHeader returns %d bytes; want %d", n,
|
|
||||||
len(data))
|
|
||||||
}
|
|
||||||
if g.compressedSize != h.compressedSize {
|
|
||||||
t.Errorf("got compressedSize %d; want %d",
|
|
||||||
g.compressedSize, h.compressedSize)
|
|
||||||
}
|
|
||||||
if g.uncompressedSize != h.uncompressedSize {
|
|
||||||
t.Errorf("got uncompressedSize %d; want %d",
|
|
||||||
g.uncompressedSize, h.uncompressedSize)
|
|
||||||
}
|
|
||||||
if len(g.filters) != len(h.filters) {
|
|
||||||
t.Errorf("got len(filters) %d; want %d",
|
|
||||||
len(g.filters), len(h.filters))
|
|
||||||
}
|
|
||||||
glf := g.filters[0].(*lzmaFilter)
|
|
||||||
hlf := h.filters[0].(*lzmaFilter)
|
|
||||||
if glf.dictCap != hlf.dictCap {
|
|
||||||
t.Errorf("got dictCap %d; want %d", glf.dictCap, hlf.dictCap)
|
|
||||||
}
|
|
||||||
}
|
|
30
vendor/github.com/ulikunitz/xz/internal/hash/cyclic_poly_test.go
generated
vendored
30
vendor/github.com/ulikunitz/xz/internal/hash/cyclic_poly_test.go
generated
vendored
@ -1,30 +0,0 @@
|
|||||||
// Copyright 2014-2017 Ulrich Kunitz. All rights reserved.
|
|
||||||
// Use of this source code is governed by a BSD-style
|
|
||||||
// license that can be found in the LICENSE file.
|
|
||||||
|
|
||||||
package hash
|
|
||||||
|
|
||||||
import "testing"
|
|
||||||
|
|
||||||
func TestCyclicPolySimple(t *testing.T) {
|
|
||||||
p := []byte("abcde")
|
|
||||||
r := NewCyclicPoly(4)
|
|
||||||
h2 := Hashes(r, p)
|
|
||||||
for i, h := range h2 {
|
|
||||||
w := Hashes(r, p[i:i+4])[0]
|
|
||||||
t.Logf("%d h=%#016x w=%#016x", i, h, w)
|
|
||||||
if h != w {
|
|
||||||
t.Errorf("rolling hash %d: %#016x; want %#016x",
|
|
||||||
i, h, w)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func BenchmarkCyclicPoly(b *testing.B) {
|
|
||||||
p := makeBenchmarkBytes(4096)
|
|
||||||
r := NewCyclicPoly(4)
|
|
||||||
b.ResetTimer()
|
|
||||||
for i := 0; i < b.N; i++ {
|
|
||||||
Hashes(r, p)
|
|
||||||
}
|
|
||||||
}
|
|
42
vendor/github.com/ulikunitz/xz/internal/hash/rabin_karp_test.go
generated
vendored
42
vendor/github.com/ulikunitz/xz/internal/hash/rabin_karp_test.go
generated
vendored
@ -1,42 +0,0 @@
|
|||||||
// Copyright 2014-2017 Ulrich Kunitz. All rights reserved.
|
|
||||||
// Use of this source code is governed by a BSD-style
|
|
||||||
// license that can be found in the LICENSE file.
|
|
||||||
|
|
||||||
package hash
|
|
||||||
|
|
||||||
import (
|
|
||||||
"math/rand"
|
|
||||||
"testing"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestRabinKarpSimple(t *testing.T) {
|
|
||||||
p := []byte("abcde")
|
|
||||||
r := NewRabinKarp(4)
|
|
||||||
h2 := Hashes(r, p)
|
|
||||||
for i, h := range h2 {
|
|
||||||
w := Hashes(r, p[i:i+4])[0]
|
|
||||||
t.Logf("%d h=%#016x w=%#016x", i, h, w)
|
|
||||||
if h != w {
|
|
||||||
t.Errorf("rolling hash %d: %#016x; want %#016x",
|
|
||||||
i, h, w)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func makeBenchmarkBytes(n int) []byte {
|
|
||||||
rnd := rand.New(rand.NewSource(42))
|
|
||||||
p := make([]byte, n)
|
|
||||||
for i := range p {
|
|
||||||
p[i] = byte(rnd.Uint32())
|
|
||||||
}
|
|
||||||
return p
|
|
||||||
}
|
|
||||||
|
|
||||||
func BenchmarkRabinKarp(b *testing.B) {
|
|
||||||
p := makeBenchmarkBytes(4096)
|
|
||||||
r := NewRabinKarp(4)
|
|
||||||
b.ResetTimer()
|
|
||||||
for i := 0; i < b.N; i++ {
|
|
||||||
Hashes(r, p)
|
|
||||||
}
|
|
||||||
}
|
|
17590
vendor/github.com/ulikunitz/xz/internal/randtxt/englm3.go
generated
vendored
17590
vendor/github.com/ulikunitz/xz/internal/randtxt/englm3.go
generated
vendored
File diff suppressed because it is too large
Load Diff
82
vendor/github.com/ulikunitz/xz/internal/randtxt/groupreader.go
generated
vendored
82
vendor/github.com/ulikunitz/xz/internal/randtxt/groupreader.go
generated
vendored
@ -1,82 +0,0 @@
|
|||||||
// Copyright 2014-2017 Ulrich Kunitz. All rights reserved.
|
|
||||||
// Use of this source code is governed by a BSD-style
|
|
||||||
// license that can be found in the LICENSE file.
|
|
||||||
|
|
||||||
package randtxt
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bufio"
|
|
||||||
"io"
|
|
||||||
"unicode"
|
|
||||||
)
|
|
||||||
|
|
||||||
// GroupReader groups the incoming text in groups of 5, whereby the
|
|
||||||
// number of groups per line can be controlled.
|
|
||||||
type GroupReader struct {
|
|
||||||
R io.ByteReader
|
|
||||||
GroupsPerLine int
|
|
||||||
off int64
|
|
||||||
eof bool
|
|
||||||
}
|
|
||||||
|
|
||||||
// NewGroupReader creates a new group reader.
|
|
||||||
func NewGroupReader(r io.Reader) *GroupReader {
|
|
||||||
return &GroupReader{R: bufio.NewReader(r)}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Read formats the data provided by the internal reader in groups of 5
|
|
||||||
// characters. If GroupsPerLine hasn't been initialized 8 groups per
|
|
||||||
// line will be produced.
|
|
||||||
func (r *GroupReader) Read(p []byte) (n int, err error) {
|
|
||||||
if r.eof {
|
|
||||||
return 0, io.EOF
|
|
||||||
}
|
|
||||||
groupsPerLine := r.GroupsPerLine
|
|
||||||
if groupsPerLine < 1 {
|
|
||||||
groupsPerLine = 8
|
|
||||||
}
|
|
||||||
lineLen := int64(groupsPerLine * 6)
|
|
||||||
var c byte
|
|
||||||
for i := range p {
|
|
||||||
switch {
|
|
||||||
case r.off%lineLen == lineLen-1:
|
|
||||||
if i+1 == len(p) && len(p) > 1 {
|
|
||||||
return i, nil
|
|
||||||
}
|
|
||||||
c = '\n'
|
|
||||||
case r.off%6 == 5:
|
|
||||||
if i+1 == len(p) && len(p) > 1 {
|
|
||||||
return i, nil
|
|
||||||
}
|
|
||||||
c = ' '
|
|
||||||
default:
|
|
||||||
c, err = r.R.ReadByte()
|
|
||||||
if err == io.EOF {
|
|
||||||
r.eof = true
|
|
||||||
if i > 0 {
|
|
||||||
switch p[i-1] {
|
|
||||||
case ' ':
|
|
||||||
p[i-1] = '\n'
|
|
||||||
fallthrough
|
|
||||||
case '\n':
|
|
||||||
return i, io.EOF
|
|
||||||
}
|
|
||||||
}
|
|
||||||
p[i] = '\n'
|
|
||||||
return i + 1, io.EOF
|
|
||||||
}
|
|
||||||
if err != nil {
|
|
||||||
return i, err
|
|
||||||
}
|
|
||||||
switch {
|
|
||||||
case c == ' ':
|
|
||||||
c = '_'
|
|
||||||
case !unicode.IsPrint(rune(c)):
|
|
||||||
c = '-'
|
|
||||||
}
|
|
||||||
}
|
|
||||||
p[i] = c
|
|
||||||
r.off++
|
|
||||||
}
|
|
||||||
return len(p), nil
|
|
||||||
}
|
|
185
vendor/github.com/ulikunitz/xz/internal/randtxt/probs.go
generated
vendored
185
vendor/github.com/ulikunitz/xz/internal/randtxt/probs.go
generated
vendored
@ -1,185 +0,0 @@
|
|||||||
// Copyright 2014-2017 Ulrich Kunitz. All rights reserved.
|
|
||||||
// Use of this source code is governed by a BSD-style
|
|
||||||
// license that can be found in the LICENSE file.
|
|
||||||
|
|
||||||
// Package randtxt supports the generation of random text using a
|
|
||||||
// trigram model for the English language.
|
|
||||||
package randtxt
|
|
||||||
|
|
||||||
import (
|
|
||||||
"math"
|
|
||||||
"math/rand"
|
|
||||||
"sort"
|
|
||||||
)
|
|
||||||
|
|
||||||
// ngram stores an entry from the language model.
|
|
||||||
type ngram struct {
|
|
||||||
s string
|
|
||||||
lgP float64
|
|
||||||
lgQ float64
|
|
||||||
}
|
|
||||||
|
|
||||||
// ngrams represents a slice of ngram values and is used to represent a
|
|
||||||
// language model.
|
|
||||||
type ngrams []ngram
|
|
||||||
|
|
||||||
func (s ngrams) Len() int { return len(s) }
|
|
||||||
func (s ngrams) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
|
|
||||||
func (s ngrams) Less(i, j int) bool { return s[i].s < s[j].s }
|
|
||||||
|
|
||||||
// Sorts the language model in the sequence of their ngrams.
|
|
||||||
func (s ngrams) Sort() { sort.Sort(s) }
|
|
||||||
|
|
||||||
// Search is looking for an ngram or the position where it would be
|
|
||||||
// inserted.
|
|
||||||
func (s ngrams) Search(g string) int {
|
|
||||||
return sort.Search(len(s), func(k int) bool { return s[k].s >= g })
|
|
||||||
}
|
|
||||||
|
|
||||||
// prob represents a string, usually an ngram, and a probability value.
|
|
||||||
type prob struct {
|
|
||||||
s string
|
|
||||||
p float64
|
|
||||||
}
|
|
||||||
|
|
||||||
// probs is a slice of prob values that can be sorted and searched.
|
|
||||||
type probs []prob
|
|
||||||
|
|
||||||
func (s probs) Len() int { return len(s) }
|
|
||||||
func (s probs) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
|
|
||||||
func (s probs) Less(i, j int) bool { return s[i].s < s[j].s }
|
|
||||||
|
|
||||||
// SortByNgram sorts the probs slice by ngram, field s.
|
|
||||||
func (s probs) SortByNgram() { sort.Sort(s) }
|
|
||||||
|
|
||||||
// SortsByProb sorts the probs slice by probability, field p.
|
|
||||||
func (s probs) SortByProb() { sort.Sort(byProb{s}) }
|
|
||||||
|
|
||||||
// SearchNgram searches for an ngram or the position where it would be
|
|
||||||
// inserted.
|
|
||||||
func (s probs) SearchNgram(g string) int {
|
|
||||||
return sort.Search(len(s), func(k int) bool { return s[k].s >= g })
|
|
||||||
}
|
|
||||||
|
|
||||||
// SearchProb searches ngrams for a specific probability or where it
|
|
||||||
// would be inserted.
|
|
||||||
func (s probs) SearchProb(p float64) int {
|
|
||||||
return sort.Search(len(s), func(k int) bool { return s[k].p >= p })
|
|
||||||
}
|
|
||||||
|
|
||||||
// byProb is used to sort probs slice by probability, field p.
|
|
||||||
type byProb struct {
|
|
||||||
probs
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s byProb) Less(i, j int) bool {
|
|
||||||
return s.probs[i].p < s.probs[j].p
|
|
||||||
}
|
|
||||||
|
|
||||||
// cdf can be used to setup a cumulative distribution function
|
|
||||||
// represented by a probs slice. We should have returned an actual
|
|
||||||
// function.
|
|
||||||
func cdf(n int, p func(i int) prob) probs {
|
|
||||||
prs := make(probs, n)
|
|
||||||
sum := 0.0
|
|
||||||
for i := range prs {
|
|
||||||
pr := p(i)
|
|
||||||
sum += pr.p
|
|
||||||
prs[i] = pr
|
|
||||||
}
|
|
||||||
q := 1.0 / sum
|
|
||||||
x := 0.0
|
|
||||||
for i, pr := range prs {
|
|
||||||
x += pr.p * q
|
|
||||||
if x > 1.0 {
|
|
||||||
x = 1.0
|
|
||||||
}
|
|
||||||
prs[i].p = x
|
|
||||||
}
|
|
||||||
if !sort.IsSorted(byProb{prs}) {
|
|
||||||
panic("cdf not sorted")
|
|
||||||
}
|
|
||||||
return prs
|
|
||||||
}
|
|
||||||
|
|
||||||
// pCDFOfLM converts a language model into a cumulative distribution
|
|
||||||
// function represented by probs.
|
|
||||||
func pCDFOfLM(lm ngrams) probs {
|
|
||||||
return cdf(len(lm), func(i int) prob {
|
|
||||||
return prob{lm[i].s, math.Exp2(lm[i].lgP)}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
// cCDF converts a ngrams slice into a cumulative distribution function
|
|
||||||
// using the conditional probability lgQ.
|
|
||||||
func cCDF(s ngrams) probs {
|
|
||||||
return cdf(len(s), func(i int) prob {
|
|
||||||
return prob{s[i].s, math.Exp2(s[i].lgQ)}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
// comap contains a map of conditional distribution function for the
|
|
||||||
// last character.
|
|
||||||
type comap map[string]probs
|
|
||||||
|
|
||||||
// comapOfLM converts a language model in a map of conditional
|
|
||||||
// distribution functions.
|
|
||||||
func comapOfLM(lm ngrams) comap {
|
|
||||||
if !sort.IsSorted(lm) {
|
|
||||||
panic("lm is not sorted")
|
|
||||||
}
|
|
||||||
m := make(comap, 26*26)
|
|
||||||
for i := 0; i < len(lm); {
|
|
||||||
j := i
|
|
||||||
g := lm[i].s
|
|
||||||
g2 := g[:2]
|
|
||||||
z := g2 + "Z"
|
|
||||||
i = lm.Search(z)
|
|
||||||
if i >= len(lm) || lm[i].s != z {
|
|
||||||
panic("unexpected search result")
|
|
||||||
}
|
|
||||||
i++
|
|
||||||
m[g2] = cCDF(lm[j:i])
|
|
||||||
}
|
|
||||||
return m
|
|
||||||
}
|
|
||||||
|
|
||||||
// trigram returns the trigram with prefix g2 using a probability value
|
|
||||||
// in the range [0.0,1.0).
|
|
||||||
func (c comap) trigram(g2 string, p float64) string {
|
|
||||||
prs := c[g2]
|
|
||||||
i := prs.SearchProb(p)
|
|
||||||
return prs[i].s
|
|
||||||
}
|
|
||||||
|
|
||||||
var (
|
|
||||||
// CDF for normal probabilities
|
|
||||||
pcdf = pCDFOfLM(englm3)
|
|
||||||
// map of two letter conditionals
|
|
||||||
cmap = comapOfLM(englm3)
|
|
||||||
)
|
|
||||||
|
|
||||||
// Reader generates a stream of text of uppercase letters with trigrams
|
|
||||||
// distributed according to a language model of the English language.
|
|
||||||
type Reader struct {
|
|
||||||
rnd *rand.Rand
|
|
||||||
g3 string
|
|
||||||
}
|
|
||||||
|
|
||||||
// NewReader creates a new reader. The argument src must create a uniformly
|
|
||||||
// distributed stream of random values.
|
|
||||||
func NewReader(src rand.Source) *Reader {
|
|
||||||
rnd := rand.New(src)
|
|
||||||
i := pcdf.SearchProb(rnd.Float64())
|
|
||||||
return &Reader{rnd, pcdf[i].s}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Read reads random text. The Read function will always return len(p)
|
|
||||||
// bytes and will never return an error.
|
|
||||||
func (r *Reader) Read(p []byte) (n int, err error) {
|
|
||||||
for i := range p {
|
|
||||||
r.g3 = cmap.trigram(r.g3[1:], r.rnd.Float64())
|
|
||||||
p[i] = r.g3[2]
|
|
||||||
}
|
|
||||||
return len(p), nil
|
|
||||||
}
|
|
37
vendor/github.com/ulikunitz/xz/internal/randtxt/probs_test.go
generated
vendored
37
vendor/github.com/ulikunitz/xz/internal/randtxt/probs_test.go
generated
vendored
@ -1,37 +0,0 @@
|
|||||||
// Copyright 2014-2017 Ulrich Kunitz. All rights reserved.
|
|
||||||
// Use of this source code is governed by a BSD-style
|
|
||||||
// license that can be found in the LICENSE file.
|
|
||||||
|
|
||||||
package randtxt
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bufio"
|
|
||||||
"io"
|
|
||||||
"math/rand"
|
|
||||||
"testing"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestReader(t *testing.T) {
|
|
||||||
lr := io.LimitReader(NewReader(rand.NewSource(13)), 195)
|
|
||||||
pretty := NewGroupReader(lr)
|
|
||||||
scanner := bufio.NewScanner(pretty)
|
|
||||||
for scanner.Scan() {
|
|
||||||
t.Log(scanner.Text())
|
|
||||||
}
|
|
||||||
if err := scanner.Err(); err != nil {
|
|
||||||
t.Fatalf("scanner error %s", err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestComap(t *testing.T) {
|
|
||||||
prs := cmap["TH"]
|
|
||||||
for _, p := range prs[3:6] {
|
|
||||||
t.Logf("%v", p)
|
|
||||||
}
|
|
||||||
p := 0.2
|
|
||||||
x := cmap.trigram("TH", p)
|
|
||||||
if x != "THE" {
|
|
||||||
t.Fatalf("cmap.trigram(%q, %.1f) returned %q; want %q",
|
|
||||||
"TH", p, x, "THE")
|
|
||||||
}
|
|
||||||
}
|
|
107
vendor/github.com/ulikunitz/xz/lzma/bintree_test.go
generated
vendored
107
vendor/github.com/ulikunitz/xz/lzma/bintree_test.go
generated
vendored
@ -1,107 +0,0 @@
|
|||||||
// Copyright 2014-2017 Ulrich Kunitz. All rights reserved.
|
|
||||||
// Use of this source code is governed by a BSD-style
|
|
||||||
// license that can be found in the LICENSE file.
|
|
||||||
|
|
||||||
package lzma
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"io"
|
|
||||||
"math/rand"
|
|
||||||
"strings"
|
|
||||||
"testing"
|
|
||||||
|
|
||||||
"github.com/ulikunitz/xz/internal/randtxt"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestBinTree_Find(t *testing.T) {
|
|
||||||
bt, err := newBinTree(30)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
const s = "Klopp feiert mit Liverpool seinen hoechsten SiegSieg"
|
|
||||||
n, err := io.WriteString(bt, s)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("WriteString error %s", err)
|
|
||||||
}
|
|
||||||
if n != len(s) {
|
|
||||||
t.Fatalf("WriteString returned %d; want %d", n, len(s))
|
|
||||||
}
|
|
||||||
|
|
||||||
/* dump info writes the complete tree
|
|
||||||
if err = bt.dump(os.Stdout); err != nil {
|
|
||||||
t.Fatalf("bt.dump error %s", err)
|
|
||||||
}
|
|
||||||
*/
|
|
||||||
|
|
||||||
tests := []string{"Sieg", "Sieb", "Simu"}
|
|
||||||
for _, c := range tests {
|
|
||||||
x := xval([]byte(c))
|
|
||||||
a, b := bt.search(bt.root, x)
|
|
||||||
t.Logf("%q: a, b == %d, %d", c, a, b)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestBinTree_PredSucc(t *testing.T) {
|
|
||||||
bt, err := newBinTree(30)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
const s = "Klopp feiert mit Liverpool seinen hoechsten Sieg."
|
|
||||||
n, err := io.WriteString(bt, s)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("WriteString error %s", err)
|
|
||||||
}
|
|
||||||
if n != len(s) {
|
|
||||||
t.Fatalf("WriteString returned %d; want %d", n, len(s))
|
|
||||||
}
|
|
||||||
for v := bt.min(bt.root); v != null; v = bt.succ(v) {
|
|
||||||
t.Log(dumpX(bt.node[v].x))
|
|
||||||
}
|
|
||||||
t.Log("")
|
|
||||||
for v := bt.max(bt.root); v != null; v = bt.pred(v) {
|
|
||||||
t.Log(dumpX(bt.node[v].x))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestBinTree_Cycle(t *testing.T) {
|
|
||||||
buf := new(bytes.Buffer)
|
|
||||||
w, err := Writer2Config{
|
|
||||||
DictCap: 4096,
|
|
||||||
Matcher: BinaryTree,
|
|
||||||
}.NewWriter2(buf)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("NewWriter error %s", err)
|
|
||||||
}
|
|
||||||
// const txtlen = 1024
|
|
||||||
const txtlen = 10000
|
|
||||||
io.CopyN(buf, randtxt.NewReader(rand.NewSource(42)), txtlen)
|
|
||||||
txt := buf.String()
|
|
||||||
buf.Reset()
|
|
||||||
n, err := io.Copy(w, strings.NewReader(txt))
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Compressing copy error %s", err)
|
|
||||||
}
|
|
||||||
if n != txtlen {
|
|
||||||
t.Fatalf("Compressing data length %d; want %d", n, txtlen)
|
|
||||||
}
|
|
||||||
if err = w.Close(); err != nil {
|
|
||||||
t.Fatalf("w.Close error %s", err)
|
|
||||||
}
|
|
||||||
t.Logf("buf.Len() %d", buf.Len())
|
|
||||||
r, err := Reader2Config{DictCap: 4096}.NewReader2(buf)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("NewReader error %s", err)
|
|
||||||
}
|
|
||||||
out := new(bytes.Buffer)
|
|
||||||
n, err = io.Copy(out, r)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Decompressing copy error %s after %d bytes", err, n)
|
|
||||||
}
|
|
||||||
if n != txtlen {
|
|
||||||
t.Fatalf("Decompression data length %d; want %d", n, txtlen)
|
|
||||||
}
|
|
||||||
if txt != out.String() {
|
|
||||||
t.Fatal("decompressed data differs from original")
|
|
||||||
}
|
|
||||||
}
|
|
230
vendor/github.com/ulikunitz/xz/lzma/buffer_test.go
generated
vendored
230
vendor/github.com/ulikunitz/xz/lzma/buffer_test.go
generated
vendored
@ -1,230 +0,0 @@
|
|||||||
// Copyright 2014-2017 Ulrich Kunitz. All rights reserved.
|
|
||||||
// Use of this source code is governed by a BSD-style
|
|
||||||
// license that can be found in the LICENSE file.
|
|
||||||
|
|
||||||
package lzma
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"io"
|
|
||||||
"testing"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestBuffer_Write(t *testing.T) {
|
|
||||||
buf := newBuffer(10)
|
|
||||||
b := []byte("1234567890")
|
|
||||||
for i := range b {
|
|
||||||
n, err := buf.Write(b[i : i+1])
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("buf.Write(b[%d:%d]) error %s", i, i+1, err)
|
|
||||||
}
|
|
||||||
if n != 1 {
|
|
||||||
t.Fatalf("buf.Write(b[%d:%d]) returned %d; want %d",
|
|
||||||
i, i+1, n, 1)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
const c = 8
|
|
||||||
n, err := buf.Discard(c)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Discard error %s", err)
|
|
||||||
}
|
|
||||||
if n != c {
|
|
||||||
t.Fatalf("Discard returned %d; want %d", n, c)
|
|
||||||
}
|
|
||||||
n, err = buf.Write(b)
|
|
||||||
if err == nil {
|
|
||||||
t.Fatalf("Write length exceed returned no error; n %d", n)
|
|
||||||
}
|
|
||||||
if n != c {
|
|
||||||
t.Fatalf("Write length exceeding returned %d; want %d", n, c)
|
|
||||||
}
|
|
||||||
n, err = buf.Discard(4)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Discard error %s", err)
|
|
||||||
}
|
|
||||||
if n != 4 {
|
|
||||||
t.Fatalf("Discard returned %d; want %d", n, 4)
|
|
||||||
}
|
|
||||||
n, err = buf.Write(b[:3])
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("buf.Write(b[:3]) error %s; n %d", err, n)
|
|
||||||
}
|
|
||||||
if n != 3 {
|
|
||||||
t.Fatalf("buf.Write(b[:3]) returned %d; want %d", n, 3)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestBuffer_Buffered_Available(t *testing.T) {
|
|
||||||
buf := newBuffer(19)
|
|
||||||
b := []byte("0123456789")
|
|
||||||
var err error
|
|
||||||
if _, err = buf.Write(b); err != nil {
|
|
||||||
t.Fatalf("buf.Write(b) error %s", err)
|
|
||||||
}
|
|
||||||
if n := buf.Buffered(); n != 10 {
|
|
||||||
t.Fatalf("buf.Buffered() returns %d; want %d", n, 10)
|
|
||||||
}
|
|
||||||
if _, err = buf.Discard(8); err != nil {
|
|
||||||
t.Fatalf("buf.Discard(8) error %s", err)
|
|
||||||
}
|
|
||||||
if _, err = buf.Write(b[:7]); err != nil {
|
|
||||||
t.Fatalf("buf.Write(b[:7]) error %s", err)
|
|
||||||
}
|
|
||||||
if n := buf.Buffered(); n != 9 {
|
|
||||||
t.Fatalf("buf.Buffered() returns %d; want %d", n, 9)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestBuffer_Read(t *testing.T) {
|
|
||||||
buf := newBuffer(10)
|
|
||||||
b := []byte("0123456789")
|
|
||||||
var err error
|
|
||||||
if _, err = buf.Write(b); err != nil {
|
|
||||||
t.Fatalf("buf.Write(b) error %s", err)
|
|
||||||
}
|
|
||||||
p := make([]byte, 8)
|
|
||||||
n, err := buf.Read(p)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("buf.Read(p) error %s", err)
|
|
||||||
}
|
|
||||||
if n != len(p) {
|
|
||||||
t.Fatalf("buf.Read(p) returned %d; want %d", n, len(p))
|
|
||||||
}
|
|
||||||
if !bytes.Equal(p, b[:8]) {
|
|
||||||
t.Fatalf("buf.Read(p) put %s into p; want %s", p, b[:8])
|
|
||||||
}
|
|
||||||
if _, err = buf.Write(b[:7]); err != nil {
|
|
||||||
t.Fatalf("buf.Write(b[:7]) error %s", err)
|
|
||||||
}
|
|
||||||
q := make([]byte, 7)
|
|
||||||
n, err = buf.Read(q)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("buf.Read(q) error %s", err)
|
|
||||||
}
|
|
||||||
if n != len(q) {
|
|
||||||
t.Fatalf("buf.Read(q) returns %d; want %d", n, len(q))
|
|
||||||
}
|
|
||||||
c := []byte("8901234")
|
|
||||||
if !bytes.Equal(q, c) {
|
|
||||||
t.Fatalf("buf.Read(q) put %s into q; want %s", q, c)
|
|
||||||
}
|
|
||||||
if _, err := buf.Write(b[7:]); err != nil {
|
|
||||||
t.Fatalf("buf.Write(b[7:]) error %s", err)
|
|
||||||
}
|
|
||||||
if _, err := buf.Write(b[:2]); err != nil {
|
|
||||||
t.Fatalf("buf.Write(b[:2]) error %s", err)
|
|
||||||
}
|
|
||||||
t.Logf("buf.rear %d buf.front %d", buf.rear, buf.front)
|
|
||||||
r := make([]byte, 2)
|
|
||||||
n, err = buf.Read(r)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("buf.Read(r) error %s", err)
|
|
||||||
}
|
|
||||||
if n != len(r) {
|
|
||||||
t.Fatalf("buf.Read(r) returns %d; want %d", n, len(r))
|
|
||||||
}
|
|
||||||
d := []byte("56")
|
|
||||||
if !bytes.Equal(r, d) {
|
|
||||||
t.Fatalf("buf.Read(r) put %s into r; want %s", r, d)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestBuffer_Discard(t *testing.T) {
|
|
||||||
buf := newBuffer(10)
|
|
||||||
b := []byte("0123456789")
|
|
||||||
var err error
|
|
||||||
if _, err = buf.Write(b); err != nil {
|
|
||||||
t.Fatalf("buf.Write(b) error %s", err)
|
|
||||||
}
|
|
||||||
n, err := buf.Discard(11)
|
|
||||||
if err == nil {
|
|
||||||
t.Fatalf("buf.Discard(11) didn't return error")
|
|
||||||
}
|
|
||||||
if n != 10 {
|
|
||||||
t.Fatalf("buf.Discard(11) returned %d; want %d", n, 10)
|
|
||||||
}
|
|
||||||
if _, err := buf.Write(b); err != nil {
|
|
||||||
t.Fatalf("buf.Write(b) #2 error %s", err)
|
|
||||||
}
|
|
||||||
n, err = buf.Discard(10)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("buf.Discard(10) error %s", err)
|
|
||||||
}
|
|
||||||
if n != 10 {
|
|
||||||
t.Fatalf("buf.Discard(11) returned %d; want %d", n, 10)
|
|
||||||
}
|
|
||||||
if _, err := buf.Write(b[:4]); err != nil {
|
|
||||||
t.Fatalf("buf.Write(b[:4]) error %s", err)
|
|
||||||
}
|
|
||||||
n, err = buf.Discard(1)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("buf.Discard(1) error %s", err)
|
|
||||||
}
|
|
||||||
if n != 1 {
|
|
||||||
t.Fatalf("buf.Discard(1) returned %d; want %d", n, 1)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestBuffer_Discard_error(t *testing.T) {
|
|
||||||
buf := newBuffer(10)
|
|
||||||
n, err := buf.Discard(-1)
|
|
||||||
if err == nil {
|
|
||||||
t.Fatal("buf.Discard(-1) didn't return an error")
|
|
||||||
}
|
|
||||||
if n != 0 {
|
|
||||||
t.Fatalf("buf.Discard(-1) returned %d; want %d", n, 0)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestPrefixLen(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
a, b []byte
|
|
||||||
k int
|
|
||||||
}{
|
|
||||||
{[]byte("abcde"), []byte("abc"), 3},
|
|
||||||
{[]byte("abc"), []byte("uvw"), 0},
|
|
||||||
{[]byte(""), []byte("uvw"), 0},
|
|
||||||
{[]byte("abcde"), []byte("abcuvw"), 3},
|
|
||||||
}
|
|
||||||
for _, c := range tests {
|
|
||||||
k := prefixLen(c.a, c.b)
|
|
||||||
if k != c.k {
|
|
||||||
t.Errorf("prefixLen(%q,%q) returned %d; want %d",
|
|
||||||
c.a, c.b, k, c.k)
|
|
||||||
}
|
|
||||||
k = prefixLen(c.b, c.a)
|
|
||||||
if k != c.k {
|
|
||||||
t.Errorf("prefixLen(%q,%q) returned %d; want %d",
|
|
||||||
c.b, c.a, k, c.k)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestMatchLen(t *testing.T) {
|
|
||||||
buf := newBuffer(13)
|
|
||||||
const s = "abcaba"
|
|
||||||
_, err := io.WriteString(buf, s)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("WriteString error %s", err)
|
|
||||||
}
|
|
||||||
_, err = io.WriteString(buf, s)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("WriteString error %s", err)
|
|
||||||
}
|
|
||||||
if _, err = buf.Discard(12); err != nil {
|
|
||||||
t.Fatalf("buf.Discard(6) error %s", err)
|
|
||||||
}
|
|
||||||
_, err = io.WriteString(buf, s)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("WriteString error %s", err)
|
|
||||||
}
|
|
||||||
tests := []struct{ d, n int }{{1, 1}, {3, 2}, {6, 6}, {5, 0}, {2, 0}}
|
|
||||||
for _, c := range tests {
|
|
||||||
n := buf.matchLen(c.d, []byte(s))
|
|
||||||
if n != c.n {
|
|
||||||
t.Errorf(
|
|
||||||
"MatchLen(%d,[]byte(%q)) returned %d; want %d",
|
|
||||||
c.d, s, n, c.n)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
59
vendor/github.com/ulikunitz/xz/lzma/decoder_test.go
generated
vendored
59
vendor/github.com/ulikunitz/xz/lzma/decoder_test.go
generated
vendored
@ -1,59 +0,0 @@
|
|||||||
// Copyright 2014-2017 Ulrich Kunitz. All rights reserved.
|
|
||||||
// Use of this source code is governed by a BSD-style
|
|
||||||
// license that can be found in the LICENSE file.
|
|
||||||
|
|
||||||
package lzma
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bufio"
|
|
||||||
"io"
|
|
||||||
"io/ioutil"
|
|
||||||
"os"
|
|
||||||
"testing"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestDecoder(t *testing.T) {
|
|
||||||
filename := "fox.lzma"
|
|
||||||
want := "The quick brown fox jumps over the lazy dog.\n"
|
|
||||||
for i := 0; i < 2; i++ {
|
|
||||||
f, err := os.Open(filename)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("os.Open(%q) error %s", filename, err)
|
|
||||||
}
|
|
||||||
p := make([]byte, 13)
|
|
||||||
_, err = io.ReadFull(f, p)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("io.ReadFull error %s", err)
|
|
||||||
}
|
|
||||||
props, err := PropertiesForCode(p[0])
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("p[0] error %s", err)
|
|
||||||
}
|
|
||||||
state := newState(props)
|
|
||||||
const capacity = 0x800000
|
|
||||||
dict, err := newDecoderDict(capacity)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("newDecoderDict: error %s", err)
|
|
||||||
}
|
|
||||||
size := int64(-1)
|
|
||||||
if i > 0 {
|
|
||||||
size = int64(len(want))
|
|
||||||
}
|
|
||||||
br := bufio.NewReader(f)
|
|
||||||
r, err := newDecoder(br, state, dict, size)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("newDecoder error %s", err)
|
|
||||||
}
|
|
||||||
bytes, err := ioutil.ReadAll(r)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("[%d] ReadAll error %s", i, err)
|
|
||||||
}
|
|
||||||
if err = f.Close(); err != nil {
|
|
||||||
t.Fatalf("Close error %s", err)
|
|
||||||
}
|
|
||||||
got := string(bytes)
|
|
||||||
if got != want {
|
|
||||||
t.Fatalf("read %q; but want %q", got, want)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
33
vendor/github.com/ulikunitz/xz/lzma/decoderdict_test.go
generated
vendored
33
vendor/github.com/ulikunitz/xz/lzma/decoderdict_test.go
generated
vendored
@ -1,33 +0,0 @@
|
|||||||
// Copyright 2014-2017 Ulrich Kunitz. All rights reserved.
|
|
||||||
// Use of this source code is governed by a BSD-style
|
|
||||||
// license that can be found in the LICENSE file.
|
|
||||||
|
|
||||||
package lzma
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"testing"
|
|
||||||
)
|
|
||||||
|
|
||||||
func peek(d *decoderDict) []byte {
|
|
||||||
p := make([]byte, d.buffered())
|
|
||||||
k, err := d.peek(p)
|
|
||||||
if err != nil {
|
|
||||||
panic(fmt.Errorf("peek: "+
|
|
||||||
"Read returned unexpected error %s", err))
|
|
||||||
}
|
|
||||||
if k != len(p) {
|
|
||||||
panic(fmt.Errorf("peek: "+
|
|
||||||
"Read returned %d; wanted %d", k, len(p)))
|
|
||||||
}
|
|
||||||
return p
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestNewDecoderDict(t *testing.T) {
|
|
||||||
if _, err := newDecoderDict(0); err == nil {
|
|
||||||
t.Fatalf("no error for zero dictionary capacity")
|
|
||||||
}
|
|
||||||
if _, err := newDecoderDict(8); err != nil {
|
|
||||||
t.Fatalf("error %s", err)
|
|
||||||
}
|
|
||||||
}
|
|
2
vendor/github.com/ulikunitz/xz/lzma/encoder.go
generated
vendored
2
vendor/github.com/ulikunitz/xz/lzma/encoder.go
generated
vendored
@ -11,7 +11,7 @@ import (
|
|||||||
|
|
||||||
// opLenMargin provides the upper limit of the number of bytes required
|
// opLenMargin provides the upper limit of the number of bytes required
|
||||||
// to encode a single operation.
|
// to encode a single operation.
|
||||||
const opLenMargin = 10
|
const opLenMargin = 16
|
||||||
|
|
||||||
// compressFlags control the compression process.
|
// compressFlags control the compression process.
|
||||||
type compressFlags uint32
|
type compressFlags uint32
|
||||||
|
151
vendor/github.com/ulikunitz/xz/lzma/encoder_test.go
generated
vendored
151
vendor/github.com/ulikunitz/xz/lzma/encoder_test.go
generated
vendored
@ -1,151 +0,0 @@
|
|||||||
// Copyright 2014-2017 Ulrich Kunitz. All rights reserved.
|
|
||||||
// Use of this source code is governed by a BSD-style
|
|
||||||
// license that can be found in the LICENSE file.
|
|
||||||
|
|
||||||
package lzma
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"io"
|
|
||||||
"io/ioutil"
|
|
||||||
"math/rand"
|
|
||||||
"testing"
|
|
||||||
|
|
||||||
"github.com/ulikunitz/xz/internal/randtxt"
|
|
||||||
)
|
|
||||||
|
|
||||||
var testString = `LZMA decoder test example
|
|
||||||
=========================
|
|
||||||
! LZMA ! Decoder ! TEST !
|
|
||||||
=========================
|
|
||||||
! TEST ! LZMA ! Decoder !
|
|
||||||
=========================
|
|
||||||
---- Test Line 1 --------
|
|
||||||
=========================
|
|
||||||
---- Test Line 2 --------
|
|
||||||
=========================
|
|
||||||
=== End of test file ====
|
|
||||||
=========================
|
|
||||||
`
|
|
||||||
|
|
||||||
func cycle(t *testing.T, n int) {
|
|
||||||
t.Logf("cycle(t,%d)", n)
|
|
||||||
if n > len(testString) {
|
|
||||||
t.Fatalf("cycle: n=%d larger than len(testString)=%d", n,
|
|
||||||
len(testString))
|
|
||||||
}
|
|
||||||
const dictCap = MinDictCap
|
|
||||||
m, err := newHashTable(dictCap, 4)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
encoderDict, err := newEncoderDict(dictCap, dictCap+1024, m)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
props := Properties{2, 0, 2}
|
|
||||||
if err := props.verify(); err != nil {
|
|
||||||
t.Fatalf("properties error %s", err)
|
|
||||||
}
|
|
||||||
state := newState(props)
|
|
||||||
var buf bytes.Buffer
|
|
||||||
w, err := newEncoder(&buf, state, encoderDict, eosMarker)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("newEncoder error %s", err)
|
|
||||||
}
|
|
||||||
orig := []byte(testString)[:n]
|
|
||||||
t.Logf("len(orig) %d", len(orig))
|
|
||||||
k, err := w.Write(orig)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("w.Write error %s", err)
|
|
||||||
}
|
|
||||||
if k != len(orig) {
|
|
||||||
t.Fatalf("w.Write returned %d; want %d", k, len(orig))
|
|
||||||
}
|
|
||||||
if err = w.Close(); err != nil {
|
|
||||||
t.Fatalf("w.Close error %s", err)
|
|
||||||
}
|
|
||||||
t.Logf("buf.Len() %d len(orig) %d", buf.Len(), len(orig))
|
|
||||||
decoderDict, err := newDecoderDict(dictCap)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("newDecoderDict error %s", err)
|
|
||||||
}
|
|
||||||
state.Reset()
|
|
||||||
r, err := newDecoder(&buf, state, decoderDict, -1)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("newDecoder error %s", err)
|
|
||||||
}
|
|
||||||
decoded, err := ioutil.ReadAll(r)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("ReadAll(lr) error %s", err)
|
|
||||||
}
|
|
||||||
t.Logf("decoded: %s", decoded)
|
|
||||||
if len(orig) != len(decoded) {
|
|
||||||
t.Fatalf("length decoded is %d; want %d", len(decoded),
|
|
||||||
len(orig))
|
|
||||||
}
|
|
||||||
if !bytes.Equal(orig, decoded) {
|
|
||||||
t.Fatalf("decoded file differs from original")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestEncoderCycle1(t *testing.T) {
|
|
||||||
cycle(t, len(testString))
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestEncoderCycle2(t *testing.T) {
|
|
||||||
buf := new(bytes.Buffer)
|
|
||||||
const txtlen = 50000
|
|
||||||
io.CopyN(buf, randtxt.NewReader(rand.NewSource(42)), txtlen)
|
|
||||||
txt := buf.String()
|
|
||||||
buf.Reset()
|
|
||||||
const dictCap = MinDictCap
|
|
||||||
m, err := newHashTable(dictCap, 4)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
encoderDict, err := newEncoderDict(dictCap, dictCap+1024, m)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
props := Properties{3, 0, 2}
|
|
||||||
if err := props.verify(); err != nil {
|
|
||||||
t.Fatalf("properties error %s", err)
|
|
||||||
}
|
|
||||||
state := newState(props)
|
|
||||||
lbw := &LimitedByteWriter{BW: buf, N: 100}
|
|
||||||
w, err := newEncoder(lbw, state, encoderDict, 0)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("NewEncoder error %s", err)
|
|
||||||
}
|
|
||||||
_, err = io.WriteString(w, txt)
|
|
||||||
if err != nil && err != ErrLimit {
|
|
||||||
t.Fatalf("WriteString error %s", err)
|
|
||||||
}
|
|
||||||
if err = w.Close(); err != nil {
|
|
||||||
t.Fatalf("w.Close error %s", err)
|
|
||||||
}
|
|
||||||
n := w.Compressed()
|
|
||||||
txt = txt[:n]
|
|
||||||
decoderDict, err := newDecoderDict(dictCap)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("NewDecoderDict error %s", err)
|
|
||||||
}
|
|
||||||
state.Reset()
|
|
||||||
r, err := newDecoder(buf, state, decoderDict, n)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("NewDecoder error %s", err)
|
|
||||||
}
|
|
||||||
out := new(bytes.Buffer)
|
|
||||||
if _, err = io.Copy(out, r); err != nil {
|
|
||||||
t.Fatalf("decompress copy error %s", err)
|
|
||||||
}
|
|
||||||
got := out.String()
|
|
||||||
t.Logf("%s", got)
|
|
||||||
if len(got) != int(n) {
|
|
||||||
t.Fatalf("len(got) %d; want %d", len(got), n)
|
|
||||||
}
|
|
||||||
if got != txt {
|
|
||||||
t.Fatalf("got and txt differ")
|
|
||||||
}
|
|
||||||
}
|
|
47
vendor/github.com/ulikunitz/xz/lzma/hashtable_test.go
generated
vendored
47
vendor/github.com/ulikunitz/xz/lzma/hashtable_test.go
generated
vendored
@ -1,47 +0,0 @@
|
|||||||
// Copyright 2014-2017 Ulrich Kunitz. All rights reserved.
|
|
||||||
// Use of this source code is governed by a BSD-style
|
|
||||||
// license that can be found in the LICENSE file.
|
|
||||||
|
|
||||||
package lzma
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"testing"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestHashTable(t *testing.T) {
|
|
||||||
ht, err := newHashTable(32, 2)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("newHashTable: error %s", err)
|
|
||||||
}
|
|
||||||
// 01234567890123456
|
|
||||||
s := "abcabcdefghijklmn"
|
|
||||||
n, err := ht.Write([]byte(s))
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("ht.Write: error %s", err)
|
|
||||||
}
|
|
||||||
if n != len(s) {
|
|
||||||
t.Fatalf("ht.Write returned %d; want %d", n, len(s))
|
|
||||||
}
|
|
||||||
tests := []struct {
|
|
||||||
s string
|
|
||||||
w string
|
|
||||||
}{
|
|
||||||
{"ab", "[3 0]"},
|
|
||||||
{"bc", "[4 1]"},
|
|
||||||
{"ca", "[2]"},
|
|
||||||
{"xx", "[]"},
|
|
||||||
{"gh", "[9]"},
|
|
||||||
{"mn", "[15]"},
|
|
||||||
}
|
|
||||||
distances := make([]int64, 20)
|
|
||||||
for _, c := range tests {
|
|
||||||
distances := distances[:20]
|
|
||||||
k := ht.Matches([]byte(c.s), distances)
|
|
||||||
distances = distances[:k]
|
|
||||||
o := fmt.Sprintf("%v", distances)
|
|
||||||
if o != c.w {
|
|
||||||
t.Errorf("%s: offsets %s; want %s", c.s, o, c.w)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
153
vendor/github.com/ulikunitz/xz/lzma/header2_test.go
generated
vendored
153
vendor/github.com/ulikunitz/xz/lzma/header2_test.go
generated
vendored
@ -1,153 +0,0 @@
|
|||||||
// Copyright 2014-2017 Ulrich Kunitz. All rights reserved.
|
|
||||||
// Use of this source code is governed by a BSD-style
|
|
||||||
// license that can be found in the LICENSE file.
|
|
||||||
|
|
||||||
package lzma
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"fmt"
|
|
||||||
"testing"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestChunkTypeString(t *testing.T) {
|
|
||||||
tests := [...]struct {
|
|
||||||
c chunkType
|
|
||||||
s string
|
|
||||||
}{
|
|
||||||
{cEOS, "EOS"},
|
|
||||||
{cUD, "UD"},
|
|
||||||
{cU, "U"},
|
|
||||||
{cL, "L"},
|
|
||||||
{cLR, "LR"},
|
|
||||||
{cLRN, "LRN"},
|
|
||||||
{cLRND, "LRND"},
|
|
||||||
}
|
|
||||||
for _, c := range tests {
|
|
||||||
s := fmt.Sprintf("%v", c.c)
|
|
||||||
if s != c.s {
|
|
||||||
t.Errorf("got %s; want %s", s, c.s)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestHeaderChunkType(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
h byte
|
|
||||||
c chunkType
|
|
||||||
}{
|
|
||||||
{h: 0, c: cEOS},
|
|
||||||
{h: 1, c: cUD},
|
|
||||||
{h: 2, c: cU},
|
|
||||||
{h: 1<<7 | 0x1f, c: cL},
|
|
||||||
{h: 1<<7 | 1<<5 | 0x1f, c: cLR},
|
|
||||||
{h: 1<<7 | 1<<6 | 0x1f, c: cLRN},
|
|
||||||
{h: 1<<7 | 1<<6 | 1<<5 | 0x1f, c: cLRND},
|
|
||||||
{h: 1<<7 | 1<<6 | 1<<5, c: cLRND},
|
|
||||||
}
|
|
||||||
if _, err := headerChunkType(3); err == nil {
|
|
||||||
t.Fatalf("headerChunkType(%d) got %v; want %v",
|
|
||||||
3, err, errHeaderByte)
|
|
||||||
}
|
|
||||||
for _, tc := range tests {
|
|
||||||
c, err := headerChunkType(tc.h)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("headerChunkType error %s", err)
|
|
||||||
}
|
|
||||||
if c != tc.c {
|
|
||||||
t.Errorf("got %s; want %s", c, tc.c)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestHeaderLen(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
c chunkType
|
|
||||||
n int
|
|
||||||
}{
|
|
||||||
{cEOS, 1}, {cU, 3}, {cUD, 3}, {cL, 5}, {cLR, 5}, {cLRN, 6},
|
|
||||||
{cLRND, 6},
|
|
||||||
}
|
|
||||||
for _, tc := range tests {
|
|
||||||
n := headerLen(tc.c)
|
|
||||||
if n != tc.n {
|
|
||||||
t.Errorf("header length for %s %d; want %d",
|
|
||||||
tc.c, n, tc.n)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func chunkHeaderSamples(t *testing.T) []chunkHeader {
|
|
||||||
props := Properties{LC: 3, LP: 0, PB: 2}
|
|
||||||
headers := make([]chunkHeader, 0, 12)
|
|
||||||
for c := cEOS; c <= cLRND; c++ {
|
|
||||||
var h chunkHeader
|
|
||||||
h.ctype = c
|
|
||||||
if c >= cUD {
|
|
||||||
h.uncompressed = 0x0304
|
|
||||||
}
|
|
||||||
if c >= cL {
|
|
||||||
h.compressed = 0x0201
|
|
||||||
}
|
|
||||||
if c >= cLRN {
|
|
||||||
h.props = props
|
|
||||||
}
|
|
||||||
headers = append(headers, h)
|
|
||||||
}
|
|
||||||
return headers
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestChunkHeaderMarshalling(t *testing.T) {
|
|
||||||
for _, h := range chunkHeaderSamples(t) {
|
|
||||||
data, err := h.MarshalBinary()
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("MarshalBinary for %v error %s", h, err)
|
|
||||||
}
|
|
||||||
var g chunkHeader
|
|
||||||
if err = g.UnmarshalBinary(data); err != nil {
|
|
||||||
t.Fatalf("UnmarshalBinary error %s", err)
|
|
||||||
}
|
|
||||||
if g != h {
|
|
||||||
t.Fatalf("got %v; want %v", g, h)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestReadChunkHeader(t *testing.T) {
|
|
||||||
for _, h := range chunkHeaderSamples(t) {
|
|
||||||
data, err := h.MarshalBinary()
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("MarshalBinary for %v error %s", h, err)
|
|
||||||
}
|
|
||||||
r := bytes.NewReader(data)
|
|
||||||
g, err := readChunkHeader(r)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("readChunkHeader for %v error %s", h, err)
|
|
||||||
}
|
|
||||||
if *g != h {
|
|
||||||
t.Fatalf("got %v; want %v", g, h)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestReadEOS(t *testing.T) {
|
|
||||||
var b [1]byte
|
|
||||||
r := bytes.NewReader(b[:])
|
|
||||||
h, err := readChunkHeader(r)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("readChunkHeader error %s", err)
|
|
||||||
}
|
|
||||||
if h.ctype != cEOS {
|
|
||||||
t.Errorf("ctype got %s; want %s", h.ctype, cEOS)
|
|
||||||
}
|
|
||||||
if h.compressed != 0 {
|
|
||||||
t.Errorf("compressed got %d; want %d", h.compressed, 0)
|
|
||||||
}
|
|
||||||
if h.uncompressed != 0 {
|
|
||||||
t.Errorf("uncompressed got %d; want %d", h.uncompressed, 0)
|
|
||||||
}
|
|
||||||
wantProps := Properties{}
|
|
||||||
if h.props != wantProps {
|
|
||||||
t.Errorf("props got %v; want %v", h.props, wantProps)
|
|
||||||
}
|
|
||||||
}
|
|
52
vendor/github.com/ulikunitz/xz/lzma/header_test.go
generated
vendored
52
vendor/github.com/ulikunitz/xz/lzma/header_test.go
generated
vendored
@ -1,52 +0,0 @@
|
|||||||
// Copyright 2014-2017 Ulrich Kunitz. All rights reserved.
|
|
||||||
// Use of this source code is governed by a BSD-style
|
|
||||||
// license that can be found in the LICENSE file.
|
|
||||||
|
|
||||||
package lzma
|
|
||||||
|
|
||||||
import "testing"
|
|
||||||
|
|
||||||
func TestHeaderMarshalling(t *testing.T) {
|
|
||||||
tests := []header{
|
|
||||||
{properties: Properties{3, 0, 2}, dictCap: 8 * 1024 * 1024,
|
|
||||||
size: -1},
|
|
||||||
{properties: Properties{4, 3, 3}, dictCap: 4096,
|
|
||||||
size: 10},
|
|
||||||
}
|
|
||||||
for _, h := range tests {
|
|
||||||
data, err := h.marshalBinary()
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("marshalBinary error %s", err)
|
|
||||||
}
|
|
||||||
var g header
|
|
||||||
if err = g.unmarshalBinary(data); err != nil {
|
|
||||||
t.Fatalf("unmarshalBinary error %s", err)
|
|
||||||
}
|
|
||||||
if h != g {
|
|
||||||
t.Errorf("got header %#v; want %#v", g, h)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestValidHeader(t *testing.T) {
|
|
||||||
tests := []header{
|
|
||||||
{properties: Properties{3, 0, 2}, dictCap: 8 * 1024 * 1024,
|
|
||||||
size: -1},
|
|
||||||
{properties: Properties{4, 3, 3}, dictCap: 4096,
|
|
||||||
size: 10},
|
|
||||||
}
|
|
||||||
for _, h := range tests {
|
|
||||||
data, err := h.marshalBinary()
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("marshalBinary error %s", err)
|
|
||||||
}
|
|
||||||
if !ValidHeader(data) {
|
|
||||||
t.Errorf("ValidHeader returns false for header %v;"+
|
|
||||||
" want true", h)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
const a = "1234567890123"
|
|
||||||
if ValidHeader([]byte(a)) {
|
|
||||||
t.Errorf("ValidHeader returns true for %s; want false", a)
|
|
||||||
}
|
|
||||||
}
|
|
312
vendor/github.com/ulikunitz/xz/lzma/reader_test.go
generated
vendored
312
vendor/github.com/ulikunitz/xz/lzma/reader_test.go
generated
vendored
@ -1,312 +0,0 @@
|
|||||||
// Copyright 2014-2017 Ulrich Kunitz. All rights reserved.
|
|
||||||
// Use of this source code is governed by a BSD-style
|
|
||||||
// license that can be found in the LICENSE file.
|
|
||||||
|
|
||||||
package lzma
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bufio"
|
|
||||||
"bytes"
|
|
||||||
"io"
|
|
||||||
"io/ioutil"
|
|
||||||
"log"
|
|
||||||
"os"
|
|
||||||
"path/filepath"
|
|
||||||
"testing"
|
|
||||||
"testing/iotest"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestNewReader(t *testing.T) {
|
|
||||||
f, err := os.Open("examples/a.lzma")
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("open examples/a.lzma: %s", err)
|
|
||||||
}
|
|
||||||
defer f.Close()
|
|
||||||
_, err = NewReader(bufio.NewReader(f))
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("NewReader: %s", err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
const (
|
|
||||||
dirname = "examples"
|
|
||||||
origname = "a.txt"
|
|
||||||
)
|
|
||||||
|
|
||||||
func readOrigFile(t *testing.T) []byte {
|
|
||||||
orig, err := ioutil.ReadFile(filepath.Join(dirname, origname))
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("ReadFile: %s", err)
|
|
||||||
}
|
|
||||||
return orig
|
|
||||||
}
|
|
||||||
|
|
||||||
func testDecodeFile(t *testing.T, filename string, orig []byte) {
|
|
||||||
pathname := filepath.Join(dirname, filename)
|
|
||||||
f, err := os.Open(pathname)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Open(%q): %s", pathname, err)
|
|
||||||
}
|
|
||||||
defer func() {
|
|
||||||
if err = f.Close(); err != nil {
|
|
||||||
t.Fatalf("f.Close() error %s", err)
|
|
||||||
}
|
|
||||||
}()
|
|
||||||
t.Logf("file %s opened", filename)
|
|
||||||
l, err := NewReader(bufio.NewReader(f))
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("NewReader: %s", err)
|
|
||||||
}
|
|
||||||
decoded, err := ioutil.ReadAll(l)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("ReadAll: %s", err)
|
|
||||||
}
|
|
||||||
t.Logf("%s", decoded)
|
|
||||||
if len(orig) != len(decoded) {
|
|
||||||
t.Fatalf("length decoded is %d; want %d",
|
|
||||||
len(decoded), len(orig))
|
|
||||||
}
|
|
||||||
if !bytes.Equal(orig, decoded) {
|
|
||||||
t.Fatalf("decoded file differs from original")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestReaderSimple(t *testing.T) {
|
|
||||||
// DebugOn(os.Stderr)
|
|
||||||
// defer DebugOff()
|
|
||||||
|
|
||||||
testDecodeFile(t, "a.lzma", readOrigFile(t))
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestReaderAll(t *testing.T) {
|
|
||||||
dirname := "examples"
|
|
||||||
dir, err := os.Open(dirname)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Open: %s", err)
|
|
||||||
}
|
|
||||||
defer func() {
|
|
||||||
if err := dir.Close(); err != nil {
|
|
||||||
t.Fatalf("dir.Close() error %s", err)
|
|
||||||
}
|
|
||||||
}()
|
|
||||||
all, err := dir.Readdirnames(0)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Readdirnames: %s", err)
|
|
||||||
}
|
|
||||||
// filter now all file with the pattern "a*.lzma"
|
|
||||||
files := make([]string, 0, len(all))
|
|
||||||
for _, fn := range all {
|
|
||||||
match, err := filepath.Match("a*.lzma", fn)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Match: %s", err)
|
|
||||||
}
|
|
||||||
if match {
|
|
||||||
files = append(files, fn)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
t.Log("files:", files)
|
|
||||||
orig := readOrigFile(t)
|
|
||||||
// actually test the files
|
|
||||||
for _, fn := range files {
|
|
||||||
testDecodeFile(t, fn, orig)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
//
|
|
||||||
func Example_reader() {
|
|
||||||
f, err := os.Open("fox.lzma")
|
|
||||||
if err != nil {
|
|
||||||
log.Fatal(err)
|
|
||||||
}
|
|
||||||
// no need for defer; Fatal calls os.Exit(1) that doesn't execute deferred functions
|
|
||||||
r, err := NewReader(bufio.NewReader(f))
|
|
||||||
if err != nil {
|
|
||||||
log.Fatal(err)
|
|
||||||
}
|
|
||||||
_, err = io.Copy(os.Stdout, r)
|
|
||||||
if err != nil {
|
|
||||||
log.Fatal(err)
|
|
||||||
}
|
|
||||||
if err := f.Close(); err != nil {
|
|
||||||
log.Fatal(err)
|
|
||||||
}
|
|
||||||
// Output:
|
|
||||||
// The quick brown fox jumps over the lazy dog.
|
|
||||||
}
|
|
||||||
|
|
||||||
type wrapTest struct {
|
|
||||||
name string
|
|
||||||
wrap func(io.Reader) io.Reader
|
|
||||||
}
|
|
||||||
|
|
||||||
func (w *wrapTest) testFile(t *testing.T, filename string, orig []byte) {
|
|
||||||
pathname := filepath.Join(dirname, filename)
|
|
||||||
f, err := os.Open(pathname)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Open(\"%s\"): %s", pathname, err)
|
|
||||||
}
|
|
||||||
defer func() {
|
|
||||||
if err := f.Close(); err != nil {
|
|
||||||
log.Fatal(err)
|
|
||||||
}
|
|
||||||
}()
|
|
||||||
t.Logf("%s file %s opened", w.name, filename)
|
|
||||||
l, err := NewReader(w.wrap(f))
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("%s NewReader: %s", w.name, err)
|
|
||||||
}
|
|
||||||
decoded, err := ioutil.ReadAll(l)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("%s ReadAll: %s", w.name, err)
|
|
||||||
}
|
|
||||||
t.Logf("%s", decoded)
|
|
||||||
if len(orig) != len(decoded) {
|
|
||||||
t.Fatalf("%s length decoded is %d; want %d",
|
|
||||||
w.name, len(decoded), len(orig))
|
|
||||||
}
|
|
||||||
if !bytes.Equal(orig, decoded) {
|
|
||||||
t.Fatalf("%s decoded file differs from original", w.name)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestReaderWrap(t *testing.T) {
|
|
||||||
tests := [...]wrapTest{
|
|
||||||
{"DataErrReader", iotest.DataErrReader},
|
|
||||||
{"HalfReader", iotest.HalfReader},
|
|
||||||
{"OneByteReader", iotest.OneByteReader},
|
|
||||||
// TimeOutReader would require buffer
|
|
||||||
}
|
|
||||||
orig := readOrigFile(t)
|
|
||||||
for _, tst := range tests {
|
|
||||||
tst.testFile(t, "a.lzma", orig)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestReaderBadFiles(t *testing.T) {
|
|
||||||
dirname := "examples"
|
|
||||||
dir, err := os.Open(dirname)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Open: %s", err)
|
|
||||||
}
|
|
||||||
defer func() {
|
|
||||||
if err := dir.Close(); err != nil {
|
|
||||||
t.Fatalf("dir.Close() error %s", err)
|
|
||||||
}
|
|
||||||
}()
|
|
||||||
all, err := dir.Readdirnames(0)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Readdirnames: %s", err)
|
|
||||||
}
|
|
||||||
// filter now all file with the pattern "bad*.lzma"
|
|
||||||
files := make([]string, 0, len(all))
|
|
||||||
for _, fn := range all {
|
|
||||||
match, err := filepath.Match("bad*.lzma", fn)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Match: %s", err)
|
|
||||||
}
|
|
||||||
if match {
|
|
||||||
files = append(files, fn)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
t.Log("files:", files)
|
|
||||||
for _, filename := range files {
|
|
||||||
pathname := filepath.Join(dirname, filename)
|
|
||||||
f, err := os.Open(pathname)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Open(\"%s\"): %s", pathname, err)
|
|
||||||
}
|
|
||||||
defer func(f *os.File) {
|
|
||||||
if err := f.Close(); err != nil {
|
|
||||||
t.Fatalf("f.Close() error %s", err)
|
|
||||||
}
|
|
||||||
}(f)
|
|
||||||
t.Logf("file %s opened", filename)
|
|
||||||
l, err := NewReader(f)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("NewReader: %s", err)
|
|
||||||
}
|
|
||||||
decoded, err := ioutil.ReadAll(l)
|
|
||||||
if err == nil {
|
|
||||||
t.Errorf("ReadAll for %s: no error", filename)
|
|
||||||
t.Logf("%s", decoded)
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
t.Logf("%s: error %s", filename, err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
type repReader byte
|
|
||||||
|
|
||||||
func (r repReader) Read(p []byte) (n int, err error) {
|
|
||||||
for i := range p {
|
|
||||||
p[i] = byte(r)
|
|
||||||
}
|
|
||||||
return len(p), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func newRepReader(c byte, n int64) *io.LimitedReader {
|
|
||||||
return &io.LimitedReader{R: repReader(c), N: n}
|
|
||||||
}
|
|
||||||
|
|
||||||
func newCodeReader(r io.Reader) *io.PipeReader {
|
|
||||||
pr, pw := io.Pipe()
|
|
||||||
go func() {
|
|
||||||
bw := bufio.NewWriter(pw)
|
|
||||||
lw, err := NewWriter(bw)
|
|
||||||
if err != nil {
|
|
||||||
log.Fatalf("NewWriter error %s", err)
|
|
||||||
}
|
|
||||||
if _, err = io.Copy(lw, r); err != nil {
|
|
||||||
log.Fatalf("io.Copy error %s", err)
|
|
||||||
}
|
|
||||||
if err = lw.Close(); err != nil {
|
|
||||||
log.Fatalf("lw.Close error %s", err)
|
|
||||||
}
|
|
||||||
if err = bw.Flush(); err != nil {
|
|
||||||
log.Fatalf("bw.Flush() error %s", err)
|
|
||||||
}
|
|
||||||
if err = pw.CloseWithError(io.EOF); err != nil {
|
|
||||||
log.Fatalf("pw.CloseWithError(io.EOF) error %s", err)
|
|
||||||
}
|
|
||||||
}()
|
|
||||||
return pr
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestReaderErrAgain(t *testing.T) {
|
|
||||||
lengths := []int64{0, 128, 1024, 4095, 4096, 4097, 8191, 8192, 8193}
|
|
||||||
buf := make([]byte, 128)
|
|
||||||
const c = 'A'
|
|
||||||
for _, n := range lengths {
|
|
||||||
t.Logf("n: %d", n)
|
|
||||||
pr := newCodeReader(newRepReader(c, n))
|
|
||||||
r, err := NewReader(pr)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("NewReader(pr) error %s", err)
|
|
||||||
}
|
|
||||||
k := int64(0)
|
|
||||||
for {
|
|
||||||
m, err := r.Read(buf)
|
|
||||||
k += int64(m)
|
|
||||||
if err == io.EOF {
|
|
||||||
break
|
|
||||||
}
|
|
||||||
if err != nil {
|
|
||||||
t.Errorf("r.Read(buf) error %s", err)
|
|
||||||
break
|
|
||||||
}
|
|
||||||
if m > len(buf) {
|
|
||||||
t.Fatalf("r.Read(buf) %d; want <= %d", m,
|
|
||||||
len(buf))
|
|
||||||
}
|
|
||||||
for i, b := range buf[:m] {
|
|
||||||
if b != c {
|
|
||||||
t.Fatalf("buf[%d]=%c; want %c", i, b,
|
|
||||||
c)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if k != n {
|
|
||||||
t.Errorf("Read %d bytes; want %d", k, n)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
109
vendor/github.com/ulikunitz/xz/lzma/writer2_test.go
generated
vendored
109
vendor/github.com/ulikunitz/xz/lzma/writer2_test.go
generated
vendored
@ -1,109 +0,0 @@
|
|||||||
// Copyright 2014-2017 Ulrich Kunitz. All rights reserved.
|
|
||||||
// Use of this source code is governed by a BSD-style
|
|
||||||
// license that can be found in the LICENSE file.
|
|
||||||
|
|
||||||
package lzma
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"io"
|
|
||||||
"math/rand"
|
|
||||||
"strings"
|
|
||||||
"testing"
|
|
||||||
|
|
||||||
"github.com/ulikunitz/xz/internal/randtxt"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestWriter2(t *testing.T) {
|
|
||||||
var buf bytes.Buffer
|
|
||||||
w, err := Writer2Config{DictCap: 4096}.NewWriter2(&buf)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("NewWriter error %s", err)
|
|
||||||
}
|
|
||||||
n, err := w.Write([]byte{'a'})
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("w.Write([]byte{'a'}) error %s", err)
|
|
||||||
}
|
|
||||||
if n != 1 {
|
|
||||||
t.Fatalf("w.Write([]byte{'a'}) returned %d; want %d", n, 1)
|
|
||||||
}
|
|
||||||
if err = w.Flush(); err != nil {
|
|
||||||
t.Fatalf("w.Flush() error %s", err)
|
|
||||||
}
|
|
||||||
// check that double Flush doesn't write another chunk
|
|
||||||
if err = w.Flush(); err != nil {
|
|
||||||
t.Fatalf("w.Flush() error %s", err)
|
|
||||||
}
|
|
||||||
if err = w.Close(); err != nil {
|
|
||||||
t.Fatalf("w.Close() error %s", err)
|
|
||||||
}
|
|
||||||
p := buf.Bytes()
|
|
||||||
want := []byte{1, 0, 0, 'a', 0}
|
|
||||||
if !bytes.Equal(p, want) {
|
|
||||||
t.Fatalf("bytes written %#v; want %#v", p, want)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestCycle1(t *testing.T) {
|
|
||||||
var buf bytes.Buffer
|
|
||||||
w, err := Writer2Config{DictCap: 4096}.NewWriter2(&buf)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("NewWriter error %s", err)
|
|
||||||
}
|
|
||||||
n, err := w.Write([]byte{'a'})
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("w.Write([]byte{'a'}) error %s", err)
|
|
||||||
}
|
|
||||||
if n != 1 {
|
|
||||||
t.Fatalf("w.Write([]byte{'a'}) returned %d; want %d", n, 1)
|
|
||||||
}
|
|
||||||
if err = w.Close(); err != nil {
|
|
||||||
t.Fatalf("w.Close() error %s", err)
|
|
||||||
}
|
|
||||||
r, err := Reader2Config{DictCap: 4096}.NewReader2(&buf)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("NewReader error %s", err)
|
|
||||||
}
|
|
||||||
p := make([]byte, 3)
|
|
||||||
n, err = r.Read(p)
|
|
||||||
t.Logf("n %d error %v", n, err)
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestCycle2(t *testing.T) {
|
|
||||||
buf := new(bytes.Buffer)
|
|
||||||
w, err := Writer2Config{DictCap: 4096}.NewWriter2(buf)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("NewWriter error %s", err)
|
|
||||||
}
|
|
||||||
// const txtlen = 1024
|
|
||||||
const txtlen = 2100000
|
|
||||||
io.CopyN(buf, randtxt.NewReader(rand.NewSource(42)), txtlen)
|
|
||||||
txt := buf.String()
|
|
||||||
buf.Reset()
|
|
||||||
n, err := io.Copy(w, strings.NewReader(txt))
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Compressing copy error %s", err)
|
|
||||||
}
|
|
||||||
if n != txtlen {
|
|
||||||
t.Fatalf("Compressing data length %d; want %d", n, txtlen)
|
|
||||||
}
|
|
||||||
if err = w.Close(); err != nil {
|
|
||||||
t.Fatalf("w.Close error %s", err)
|
|
||||||
}
|
|
||||||
t.Logf("buf.Len() %d", buf.Len())
|
|
||||||
r, err := Reader2Config{DictCap: 4096}.NewReader2(buf)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("NewReader error %s", err)
|
|
||||||
}
|
|
||||||
out := new(bytes.Buffer)
|
|
||||||
n, err = io.Copy(out, r)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Decompressing copy error %s after %d bytes", err, n)
|
|
||||||
}
|
|
||||||
if n != txtlen {
|
|
||||||
t.Fatalf("Decompression data length %d; want %d", n, txtlen)
|
|
||||||
}
|
|
||||||
if txt != out.String() {
|
|
||||||
t.Fatal("decompressed data differs from original")
|
|
||||||
}
|
|
||||||
}
|
|
249
vendor/github.com/ulikunitz/xz/lzma/writer_test.go
generated
vendored
249
vendor/github.com/ulikunitz/xz/lzma/writer_test.go
generated
vendored
@ -1,249 +0,0 @@
|
|||||||
// Copyright 2014-2017 Ulrich Kunitz. All rights reserved.
|
|
||||||
// Use of this source code is governed by a BSD-style
|
|
||||||
// license that can be found in the LICENSE file.
|
|
||||||
|
|
||||||
package lzma
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bufio"
|
|
||||||
"bytes"
|
|
||||||
"io"
|
|
||||||
"io/ioutil"
|
|
||||||
"log"
|
|
||||||
"math/rand"
|
|
||||||
"os"
|
|
||||||
"testing"
|
|
||||||
|
|
||||||
"github.com/ulikunitz/xz/internal/randtxt"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestWriterCycle(t *testing.T) {
|
|
||||||
orig := readOrigFile(t)
|
|
||||||
buf := new(bytes.Buffer)
|
|
||||||
w, err := NewWriter(buf)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("NewWriter: error %s", err)
|
|
||||||
}
|
|
||||||
n, err := w.Write(orig)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("w.Write error %s", err)
|
|
||||||
}
|
|
||||||
if n != len(orig) {
|
|
||||||
t.Fatalf("w.Write returned %d; want %d", n, len(orig))
|
|
||||||
}
|
|
||||||
if err = w.Close(); err != nil {
|
|
||||||
t.Fatalf("w.Close error %s", err)
|
|
||||||
}
|
|
||||||
t.Logf("buf.Len() %d len(orig) %d", buf.Len(), len(orig))
|
|
||||||
if buf.Len() > len(orig) {
|
|
||||||
t.Errorf("buf.Len()=%d bigger then len(orig)=%d", buf.Len(),
|
|
||||||
len(orig))
|
|
||||||
}
|
|
||||||
lr, err := NewReader(buf)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("NewReader error %s", err)
|
|
||||||
}
|
|
||||||
decoded, err := ioutil.ReadAll(lr)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("ReadAll(lr) error %s", err)
|
|
||||||
}
|
|
||||||
t.Logf("%s", decoded)
|
|
||||||
if len(orig) != len(decoded) {
|
|
||||||
t.Fatalf("length decoded is %d; want %d", len(decoded),
|
|
||||||
len(orig))
|
|
||||||
}
|
|
||||||
if !bytes.Equal(orig, decoded) {
|
|
||||||
t.Fatalf("decoded file differs from original")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestWriterLongData(t *testing.T) {
|
|
||||||
const (
|
|
||||||
seed = 49
|
|
||||||
size = 82237
|
|
||||||
)
|
|
||||||
r := io.LimitReader(randtxt.NewReader(rand.NewSource(seed)), size)
|
|
||||||
txt, err := ioutil.ReadAll(r)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("ReadAll error %s", err)
|
|
||||||
}
|
|
||||||
if len(txt) != size {
|
|
||||||
t.Fatalf("ReadAll read %d bytes; want %d", len(txt), size)
|
|
||||||
}
|
|
||||||
buf := &bytes.Buffer{}
|
|
||||||
w, err := WriterConfig{DictCap: 0x4000}.NewWriter(buf)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("WriterConfig.NewWriter error %s", err)
|
|
||||||
}
|
|
||||||
n, err := w.Write(txt)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("w.Write error %s", err)
|
|
||||||
}
|
|
||||||
if n != len(txt) {
|
|
||||||
t.Fatalf("w.Write wrote %d bytes; want %d", n, size)
|
|
||||||
}
|
|
||||||
if err = w.Close(); err != nil {
|
|
||||||
t.Fatalf("w.Close error %s", err)
|
|
||||||
}
|
|
||||||
t.Logf("compressed length %d", buf.Len())
|
|
||||||
lr, err := NewReader(buf)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("NewReader error %s", err)
|
|
||||||
}
|
|
||||||
txtRead, err := ioutil.ReadAll(lr)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("ReadAll(lr) error %s", err)
|
|
||||||
}
|
|
||||||
if len(txtRead) != size {
|
|
||||||
t.Fatalf("ReadAll(lr) returned %d bytes; want %d",
|
|
||||||
len(txtRead), size)
|
|
||||||
}
|
|
||||||
if !bytes.Equal(txtRead, txt) {
|
|
||||||
t.Fatal("ReadAll(lr) returned txt differs from origin")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestWriter_Size(t *testing.T) {
|
|
||||||
buf := new(bytes.Buffer)
|
|
||||||
w, err := WriterConfig{Size: 10, EOSMarker: true}.NewWriter(buf)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("WriterConfig.NewWriter error %s", err)
|
|
||||||
}
|
|
||||||
q := []byte{'a'}
|
|
||||||
for i := 0; i < 9; i++ {
|
|
||||||
n, err := w.Write(q)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("w.Write error %s", err)
|
|
||||||
}
|
|
||||||
if n != 1 {
|
|
||||||
t.Fatalf("w.Write returned %d; want %d", n, 1)
|
|
||||||
}
|
|
||||||
q[0]++
|
|
||||||
}
|
|
||||||
if err := w.Close(); err != errSize {
|
|
||||||
t.Fatalf("expected errSize, but got %v", err)
|
|
||||||
}
|
|
||||||
n, err := w.Write(q)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("w.Write error %s", err)
|
|
||||||
}
|
|
||||||
if n != 1 {
|
|
||||||
t.Fatalf("w.Write returned %d; want %d", n, 1)
|
|
||||||
}
|
|
||||||
if err = w.Close(); err != nil {
|
|
||||||
t.Fatalf("w.Close error %s", err)
|
|
||||||
}
|
|
||||||
t.Logf("compressed size %d", buf.Len())
|
|
||||||
r, err := NewReader(buf)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("NewReader error %s", err)
|
|
||||||
}
|
|
||||||
b, err := ioutil.ReadAll(r)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("ReadAll error %s", err)
|
|
||||||
}
|
|
||||||
s := string(b)
|
|
||||||
want := "abcdefghij"
|
|
||||||
if s != want {
|
|
||||||
t.Fatalf("read %q, want %q", s, want)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// The example uses the buffered reader and writer from package bufio.
|
|
||||||
func Example_writer() {
|
|
||||||
pr, pw := io.Pipe()
|
|
||||||
go func() {
|
|
||||||
bw := bufio.NewWriter(pw)
|
|
||||||
w, err := NewWriter(bw)
|
|
||||||
if err != nil {
|
|
||||||
log.Fatal(err)
|
|
||||||
}
|
|
||||||
input := []byte("The quick brown fox jumps over the lazy dog.")
|
|
||||||
if _, err = w.Write(input); err != nil {
|
|
||||||
log.Fatal(err)
|
|
||||||
}
|
|
||||||
if err = w.Close(); err != nil {
|
|
||||||
log.Fatal(err)
|
|
||||||
}
|
|
||||||
// reader waits for the data
|
|
||||||
if err = bw.Flush(); err != nil {
|
|
||||||
log.Fatal(err)
|
|
||||||
}
|
|
||||||
}()
|
|
||||||
r, err := NewReader(pr)
|
|
||||||
if err != nil {
|
|
||||||
log.Fatal(err)
|
|
||||||
}
|
|
||||||
_, err = io.Copy(os.Stdout, r)
|
|
||||||
if err != nil {
|
|
||||||
log.Fatal(err)
|
|
||||||
}
|
|
||||||
// Output:
|
|
||||||
// The quick brown fox jumps over the lazy dog.
|
|
||||||
}
|
|
||||||
|
|
||||||
func BenchmarkReader(b *testing.B) {
|
|
||||||
const (
|
|
||||||
seed = 49
|
|
||||||
size = 50000
|
|
||||||
)
|
|
||||||
r := io.LimitReader(randtxt.NewReader(rand.NewSource(seed)), size)
|
|
||||||
txt, err := ioutil.ReadAll(r)
|
|
||||||
if err != nil {
|
|
||||||
b.Fatalf("ReadAll error %s", err)
|
|
||||||
}
|
|
||||||
buf := &bytes.Buffer{}
|
|
||||||
w, err := WriterConfig{DictCap: 0x4000}.NewWriter(buf)
|
|
||||||
if err != nil {
|
|
||||||
b.Fatalf("WriterConfig{}.NewWriter error %s", err)
|
|
||||||
}
|
|
||||||
if _, err = w.Write(txt); err != nil {
|
|
||||||
b.Fatalf("w.Write error %s", err)
|
|
||||||
}
|
|
||||||
if err = w.Close(); err != nil {
|
|
||||||
b.Fatalf("w.Close error %s", err)
|
|
||||||
}
|
|
||||||
data, err := ioutil.ReadAll(buf)
|
|
||||||
if err != nil {
|
|
||||||
b.Fatalf("ReadAll error %s", err)
|
|
||||||
}
|
|
||||||
b.SetBytes(int64(len(txt)))
|
|
||||||
b.ResetTimer()
|
|
||||||
for i := 0; i < b.N; i++ {
|
|
||||||
lr, err := NewReader(bytes.NewReader(data))
|
|
||||||
if err != nil {
|
|
||||||
b.Fatalf("NewReader error %s", err)
|
|
||||||
}
|
|
||||||
if _, err = ioutil.ReadAll(lr); err != nil {
|
|
||||||
b.Fatalf("ReadAll(lr) error %s", err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func BenchmarkWriter(b *testing.B) {
|
|
||||||
const (
|
|
||||||
seed = 49
|
|
||||||
size = 50000
|
|
||||||
)
|
|
||||||
r := io.LimitReader(randtxt.NewReader(rand.NewSource(seed)), size)
|
|
||||||
txt, err := ioutil.ReadAll(r)
|
|
||||||
if err != nil {
|
|
||||||
b.Fatalf("ReadAll error %s", err)
|
|
||||||
}
|
|
||||||
buf := &bytes.Buffer{}
|
|
||||||
b.SetBytes(int64(len(txt)))
|
|
||||||
b.ResetTimer()
|
|
||||||
for i := 0; i < b.N; i++ {
|
|
||||||
buf.Reset()
|
|
||||||
w, err := WriterConfig{DictCap: 0x4000}.NewWriter(buf)
|
|
||||||
if err != nil {
|
|
||||||
b.Fatalf("NewWriter error %s", err)
|
|
||||||
}
|
|
||||||
if _, err = w.Write(txt); err != nil {
|
|
||||||
b.Fatalf("w.Write error %s", err)
|
|
||||||
}
|
|
||||||
if err = w.Close(); err != nil {
|
|
||||||
b.Fatalf("w.Close error %s", err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
81
vendor/github.com/ulikunitz/xz/reader_test.go
generated
vendored
81
vendor/github.com/ulikunitz/xz/reader_test.go
generated
vendored
@ -1,81 +0,0 @@
|
|||||||
// Copyright 2014-2017 Ulrich Kunitz. All rights reserved.
|
|
||||||
// Use of this source code is governed by a BSD-style
|
|
||||||
// license that can be found in the LICENSE file.
|
|
||||||
|
|
||||||
package xz
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"io"
|
|
||||||
"io/ioutil"
|
|
||||||
"os"
|
|
||||||
"testing"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestReaderSimple(t *testing.T) {
|
|
||||||
const file = "fox.xz"
|
|
||||||
xz, err := os.Open(file)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("os.Open(%q) error %s", file, err)
|
|
||||||
}
|
|
||||||
r, err := NewReader(xz)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("NewReader error %s", err)
|
|
||||||
}
|
|
||||||
var buf bytes.Buffer
|
|
||||||
if _, err = io.Copy(&buf, r); err != nil {
|
|
||||||
t.Fatalf("io.Copy error %s", err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestReaderSingleStream(t *testing.T) {
|
|
||||||
data, err := ioutil.ReadFile("fox.xz")
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("ReadFile error %s", err)
|
|
||||||
}
|
|
||||||
xz := bytes.NewReader(data)
|
|
||||||
rc := ReaderConfig{SingleStream: true}
|
|
||||||
r, err := rc.NewReader(xz)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("NewReader error %s", err)
|
|
||||||
}
|
|
||||||
var buf bytes.Buffer
|
|
||||||
if _, err = io.Copy(&buf, r); err != nil {
|
|
||||||
t.Fatalf("io.Copy error %s", err)
|
|
||||||
}
|
|
||||||
buf.Reset()
|
|
||||||
data = append(data, 0)
|
|
||||||
xz = bytes.NewReader(data)
|
|
||||||
r, err = rc.NewReader(xz)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("NewReader error %s", err)
|
|
||||||
}
|
|
||||||
if _, err = io.Copy(&buf, r); err != errUnexpectedData {
|
|
||||||
t.Fatalf("io.Copy returned %v; want %v", err, errUnexpectedData)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestReaaderMultipleStreams(t *testing.T) {
|
|
||||||
data, err := ioutil.ReadFile("fox.xz")
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("ReadFile error %s", err)
|
|
||||||
}
|
|
||||||
m := make([]byte, 0, 4*len(data)+4*4)
|
|
||||||
m = append(m, data...)
|
|
||||||
m = append(m, data...)
|
|
||||||
m = append(m, 0, 0, 0, 0)
|
|
||||||
m = append(m, data...)
|
|
||||||
m = append(m, 0, 0, 0, 0)
|
|
||||||
m = append(m, 0, 0, 0, 0)
|
|
||||||
m = append(m, data...)
|
|
||||||
m = append(m, 0, 0, 0, 0)
|
|
||||||
xz := bytes.NewReader(m)
|
|
||||||
r, err := NewReader(xz)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("NewReader error %s", err)
|
|
||||||
}
|
|
||||||
var buf bytes.Buffer
|
|
||||||
if _, err = io.Copy(&buf, r); err != nil {
|
|
||||||
t.Fatalf("io.Copy error %s", err)
|
|
||||||
}
|
|
||||||
}
|
|
138
vendor/github.com/ulikunitz/xz/writer_test.go
generated
vendored
138
vendor/github.com/ulikunitz/xz/writer_test.go
generated
vendored
@ -1,138 +0,0 @@
|
|||||||
// Copyright 2014-2017 Ulrich Kunitz. All rights reserved.
|
|
||||||
// Use of this source code is governed by a BSD-style
|
|
||||||
// license that can be found in the LICENSE file.
|
|
||||||
|
|
||||||
package xz
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"io"
|
|
||||||
"log"
|
|
||||||
"math/rand"
|
|
||||||
"os"
|
|
||||||
"testing"
|
|
||||||
|
|
||||||
"github.com/ulikunitz/xz/internal/randtxt"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestWriter(t *testing.T) {
|
|
||||||
const text = "The quick brown fox jumps over the lazy dog."
|
|
||||||
var buf bytes.Buffer
|
|
||||||
w, err := NewWriter(&buf)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("NewWriter error %s", err)
|
|
||||||
}
|
|
||||||
n, err := io.WriteString(w, text)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("WriteString error %s", err)
|
|
||||||
}
|
|
||||||
if n != len(text) {
|
|
||||||
t.Fatalf("Writestring wrote %d bytes; want %d", n, len(text))
|
|
||||||
}
|
|
||||||
if err = w.Close(); err != nil {
|
|
||||||
t.Fatalf("w.Close error %s", err)
|
|
||||||
}
|
|
||||||
var out bytes.Buffer
|
|
||||||
r, err := NewReader(&buf)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("NewReader error %s", err)
|
|
||||||
}
|
|
||||||
if _, err = io.Copy(&out, r); err != nil {
|
|
||||||
t.Fatalf("io.Copy error %s", err)
|
|
||||||
}
|
|
||||||
s := out.String()
|
|
||||||
if s != text {
|
|
||||||
t.Fatalf("reader decompressed to %q; want %q", s, text)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestIssue12(t *testing.T) {
|
|
||||||
var buf bytes.Buffer
|
|
||||||
w, err := NewWriter(&buf)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("NewWriter error %s", err)
|
|
||||||
}
|
|
||||||
if err = w.Close(); err != nil {
|
|
||||||
t.Fatalf("w.Close error %s", err)
|
|
||||||
}
|
|
||||||
r, err := NewReader(&buf)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("NewReader error %s", err)
|
|
||||||
}
|
|
||||||
var out bytes.Buffer
|
|
||||||
if _, err = io.Copy(&out, r); err != nil {
|
|
||||||
t.Fatalf("io.Copy error %s", err)
|
|
||||||
}
|
|
||||||
s := out.String()
|
|
||||||
if s != "" {
|
|
||||||
t.Fatalf("reader decompressed to %q; want %q", s, "")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func Example() {
|
|
||||||
const text = "The quick brown fox jumps over the lazy dog."
|
|
||||||
var buf bytes.Buffer
|
|
||||||
|
|
||||||
// compress text
|
|
||||||
w, err := NewWriter(&buf)
|
|
||||||
if err != nil {
|
|
||||||
log.Fatalf("NewWriter error %s", err)
|
|
||||||
}
|
|
||||||
if _, err := io.WriteString(w, text); err != nil {
|
|
||||||
log.Fatalf("WriteString error %s", err)
|
|
||||||
}
|
|
||||||
if err := w.Close(); err != nil {
|
|
||||||
log.Fatalf("w.Close error %s", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// decompress buffer and write result to stdout
|
|
||||||
r, err := NewReader(&buf)
|
|
||||||
if err != nil {
|
|
||||||
log.Fatalf("NewReader error %s", err)
|
|
||||||
}
|
|
||||||
if _, err = io.Copy(os.Stdout, r); err != nil {
|
|
||||||
log.Fatalf("io.Copy error %s", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Output:
|
|
||||||
// The quick brown fox jumps over the lazy dog.
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestWriter2(t *testing.T) {
|
|
||||||
const txtlen = 1023
|
|
||||||
var buf bytes.Buffer
|
|
||||||
io.CopyN(&buf, randtxt.NewReader(rand.NewSource(41)), txtlen)
|
|
||||||
txt := buf.String()
|
|
||||||
|
|
||||||
buf.Reset()
|
|
||||||
w, err := NewWriter(&buf)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("NewWriter error %s", err)
|
|
||||||
}
|
|
||||||
n, err := io.WriteString(w, txt)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("WriteString error %s", err)
|
|
||||||
}
|
|
||||||
if n != len(txt) {
|
|
||||||
t.Fatalf("WriteString wrote %d bytes; want %d", n, len(txt))
|
|
||||||
}
|
|
||||||
if err = w.Close(); err != nil {
|
|
||||||
t.Fatalf("Close error %s", err)
|
|
||||||
}
|
|
||||||
t.Logf("buf.Len() %d", buf.Len())
|
|
||||||
r, err := NewReader(&buf)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("NewReader error %s", err)
|
|
||||||
}
|
|
||||||
var out bytes.Buffer
|
|
||||||
k, err := io.Copy(&out, r)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Decompressing copy error %s after %d bytes", err, n)
|
|
||||||
}
|
|
||||||
if k != txtlen {
|
|
||||||
t.Fatalf("Decompression data length %d; want %d", k, txtlen)
|
|
||||||
}
|
|
||||||
if txt != out.String() {
|
|
||||||
t.Fatal("decompressed data differs from original")
|
|
||||||
}
|
|
||||||
}
|
|
4
vendor/gopkg.in/check.v1/.gitignore
generated
vendored
4
vendor/gopkg.in/check.v1/.gitignore
generated
vendored
@ -1,4 +0,0 @@
|
|||||||
_*
|
|
||||||
*.swp
|
|
||||||
*.[568]
|
|
||||||
[568].out
|
|
3
vendor/gopkg.in/check.v1/.travis.yml
generated
vendored
3
vendor/gopkg.in/check.v1/.travis.yml
generated
vendored
@ -1,3 +0,0 @@
|
|||||||
language: go
|
|
||||||
|
|
||||||
go_import_path: gopkg.in/check.v1
|
|
25
vendor/gopkg.in/check.v1/LICENSE
generated
vendored
25
vendor/gopkg.in/check.v1/LICENSE
generated
vendored
@ -1,25 +0,0 @@
|
|||||||
Gocheck - A rich testing framework for Go
|
|
||||||
|
|
||||||
Copyright (c) 2010-2013 Gustavo Niemeyer <gustavo@niemeyer.net>
|
|
||||||
|
|
||||||
All rights reserved.
|
|
||||||
|
|
||||||
Redistribution and use in source and binary forms, with or without
|
|
||||||
modification, are permitted provided that the following conditions are met:
|
|
||||||
|
|
||||||
1. Redistributions of source code must retain the above copyright notice, this
|
|
||||||
list of conditions and the following disclaimer.
|
|
||||||
2. 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.
|
|
||||||
|
|
||||||
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 OWNER OR CONTRIBUTORS 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.
|
|
20
vendor/gopkg.in/check.v1/README.md
generated
vendored
20
vendor/gopkg.in/check.v1/README.md
generated
vendored
@ -1,20 +0,0 @@
|
|||||||
Instructions
|
|
||||||
============
|
|
||||||
|
|
||||||
Install the package with:
|
|
||||||
|
|
||||||
go get gopkg.in/check.v1
|
|
||||||
|
|
||||||
Import it with:
|
|
||||||
|
|
||||||
import "gopkg.in/check.v1"
|
|
||||||
|
|
||||||
and use _check_ as the package name inside the code.
|
|
||||||
|
|
||||||
For more details, visit the project page:
|
|
||||||
|
|
||||||
* http://labix.org/gocheck
|
|
||||||
|
|
||||||
and the API documentation:
|
|
||||||
|
|
||||||
* https://gopkg.in/check.v1
|
|
2
vendor/gopkg.in/check.v1/TODO
generated
vendored
2
vendor/gopkg.in/check.v1/TODO
generated
vendored
@ -1,2 +0,0 @@
|
|||||||
- Assert(slice, Contains, item)
|
|
||||||
- Parallel test support
|
|
187
vendor/gopkg.in/check.v1/benchmark.go
generated
vendored
187
vendor/gopkg.in/check.v1/benchmark.go
generated
vendored
@ -1,187 +0,0 @@
|
|||||||
// Copyright (c) 2012 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 name of Google Inc. 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
|
|
||||||
// OWNER OR CONTRIBUTORS 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.
|
|
||||||
|
|
||||||
package check
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"runtime"
|
|
||||||
"time"
|
|
||||||
)
|
|
||||||
|
|
||||||
var memStats runtime.MemStats
|
|
||||||
|
|
||||||
// testingB is a type passed to Benchmark functions to manage benchmark
|
|
||||||
// timing and to specify the number of iterations to run.
|
|
||||||
type timer struct {
|
|
||||||
start time.Time // Time test or benchmark started
|
|
||||||
duration time.Duration
|
|
||||||
N int
|
|
||||||
bytes int64
|
|
||||||
timerOn bool
|
|
||||||
benchTime time.Duration
|
|
||||||
// The initial states of memStats.Mallocs and memStats.TotalAlloc.
|
|
||||||
startAllocs uint64
|
|
||||||
startBytes uint64
|
|
||||||
// The net total of this test after being run.
|
|
||||||
netAllocs uint64
|
|
||||||
netBytes uint64
|
|
||||||
}
|
|
||||||
|
|
||||||
// StartTimer starts timing a test. This function is called automatically
|
|
||||||
// before a benchmark starts, but it can also used to resume timing after
|
|
||||||
// a call to StopTimer.
|
|
||||||
func (c *C) StartTimer() {
|
|
||||||
if !c.timerOn {
|
|
||||||
c.start = time.Now()
|
|
||||||
c.timerOn = true
|
|
||||||
|
|
||||||
runtime.ReadMemStats(&memStats)
|
|
||||||
c.startAllocs = memStats.Mallocs
|
|
||||||
c.startBytes = memStats.TotalAlloc
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// StopTimer stops timing a test. This can be used to pause the timer
|
|
||||||
// while performing complex initialization that you don't
|
|
||||||
// want to measure.
|
|
||||||
func (c *C) StopTimer() {
|
|
||||||
if c.timerOn {
|
|
||||||
c.duration += time.Now().Sub(c.start)
|
|
||||||
c.timerOn = false
|
|
||||||
runtime.ReadMemStats(&memStats)
|
|
||||||
c.netAllocs += memStats.Mallocs - c.startAllocs
|
|
||||||
c.netBytes += memStats.TotalAlloc - c.startBytes
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// ResetTimer sets the elapsed benchmark time to zero.
|
|
||||||
// It does not affect whether the timer is running.
|
|
||||||
func (c *C) ResetTimer() {
|
|
||||||
if c.timerOn {
|
|
||||||
c.start = time.Now()
|
|
||||||
runtime.ReadMemStats(&memStats)
|
|
||||||
c.startAllocs = memStats.Mallocs
|
|
||||||
c.startBytes = memStats.TotalAlloc
|
|
||||||
}
|
|
||||||
c.duration = 0
|
|
||||||
c.netAllocs = 0
|
|
||||||
c.netBytes = 0
|
|
||||||
}
|
|
||||||
|
|
||||||
// SetBytes informs the number of bytes that the benchmark processes
|
|
||||||
// on each iteration. If this is called in a benchmark it will also
|
|
||||||
// report MB/s.
|
|
||||||
func (c *C) SetBytes(n int64) {
|
|
||||||
c.bytes = n
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *C) nsPerOp() int64 {
|
|
||||||
if c.N <= 0 {
|
|
||||||
return 0
|
|
||||||
}
|
|
||||||
return c.duration.Nanoseconds() / int64(c.N)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *C) mbPerSec() float64 {
|
|
||||||
if c.bytes <= 0 || c.duration <= 0 || c.N <= 0 {
|
|
||||||
return 0
|
|
||||||
}
|
|
||||||
return (float64(c.bytes) * float64(c.N) / 1e6) / c.duration.Seconds()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *C) timerString() string {
|
|
||||||
if c.N <= 0 {
|
|
||||||
return fmt.Sprintf("%3.3fs", float64(c.duration.Nanoseconds())/1e9)
|
|
||||||
}
|
|
||||||
mbs := c.mbPerSec()
|
|
||||||
mb := ""
|
|
||||||
if mbs != 0 {
|
|
||||||
mb = fmt.Sprintf("\t%7.2f MB/s", mbs)
|
|
||||||
}
|
|
||||||
nsop := c.nsPerOp()
|
|
||||||
ns := fmt.Sprintf("%10d ns/op", nsop)
|
|
||||||
if c.N > 0 && nsop < 100 {
|
|
||||||
// The format specifiers here make sure that
|
|
||||||
// the ones digits line up for all three possible formats.
|
|
||||||
if nsop < 10 {
|
|
||||||
ns = fmt.Sprintf("%13.2f ns/op", float64(c.duration.Nanoseconds())/float64(c.N))
|
|
||||||
} else {
|
|
||||||
ns = fmt.Sprintf("%12.1f ns/op", float64(c.duration.Nanoseconds())/float64(c.N))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
memStats := ""
|
|
||||||
if c.benchMem {
|
|
||||||
allocedBytes := fmt.Sprintf("%8d B/op", int64(c.netBytes)/int64(c.N))
|
|
||||||
allocs := fmt.Sprintf("%8d allocs/op", int64(c.netAllocs)/int64(c.N))
|
|
||||||
memStats = fmt.Sprintf("\t%s\t%s", allocedBytes, allocs)
|
|
||||||
}
|
|
||||||
return fmt.Sprintf("%8d\t%s%s%s", c.N, ns, mb, memStats)
|
|
||||||
}
|
|
||||||
|
|
||||||
func min(x, y int) int {
|
|
||||||
if x > y {
|
|
||||||
return y
|
|
||||||
}
|
|
||||||
return x
|
|
||||||
}
|
|
||||||
|
|
||||||
func max(x, y int) int {
|
|
||||||
if x < y {
|
|
||||||
return y
|
|
||||||
}
|
|
||||||
return x
|
|
||||||
}
|
|
||||||
|
|
||||||
// roundDown10 rounds a number down to the nearest power of 10.
|
|
||||||
func roundDown10(n int) int {
|
|
||||||
var tens = 0
|
|
||||||
// tens = floor(log_10(n))
|
|
||||||
for n > 10 {
|
|
||||||
n = n / 10
|
|
||||||
tens++
|
|
||||||
}
|
|
||||||
// result = 10^tens
|
|
||||||
result := 1
|
|
||||||
for i := 0; i < tens; i++ {
|
|
||||||
result *= 10
|
|
||||||
}
|
|
||||||
return result
|
|
||||||
}
|
|
||||||
|
|
||||||
// roundUp rounds x up to a number of the form [1eX, 2eX, 5eX].
|
|
||||||
func roundUp(n int) int {
|
|
||||||
base := roundDown10(n)
|
|
||||||
if n < (2 * base) {
|
|
||||||
return 2 * base
|
|
||||||
}
|
|
||||||
if n < (5 * base) {
|
|
||||||
return 5 * base
|
|
||||||
}
|
|
||||||
return 10 * base
|
|
||||||
}
|
|
91
vendor/gopkg.in/check.v1/benchmark_test.go
generated
vendored
91
vendor/gopkg.in/check.v1/benchmark_test.go
generated
vendored
@ -1,91 +0,0 @@
|
|||||||
// These tests verify the test running logic.
|
|
||||||
|
|
||||||
package check_test
|
|
||||||
|
|
||||||
import (
|
|
||||||
"time"
|
|
||||||
. "gopkg.in/check.v1"
|
|
||||||
)
|
|
||||||
|
|
||||||
var benchmarkS = Suite(&BenchmarkS{})
|
|
||||||
|
|
||||||
type BenchmarkS struct{}
|
|
||||||
|
|
||||||
func (s *BenchmarkS) TestCountSuite(c *C) {
|
|
||||||
suitesRun += 1
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *BenchmarkS) TestBasicTestTiming(c *C) {
|
|
||||||
helper := FixtureHelper{sleepOn: "Test1", sleep: 1000000 * time.Nanosecond}
|
|
||||||
output := String{}
|
|
||||||
runConf := RunConf{Output: &output, Verbose: true}
|
|
||||||
Run(&helper, &runConf)
|
|
||||||
|
|
||||||
expected := "PASS: check_test\\.go:[0-9]+: FixtureHelper\\.Test1\t0\\.0[0-9]+s\n" +
|
|
||||||
"PASS: check_test\\.go:[0-9]+: FixtureHelper\\.Test2\t0\\.0[0-9]+s\n"
|
|
||||||
c.Assert(output.value, Matches, expected)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *BenchmarkS) TestStreamTestTiming(c *C) {
|
|
||||||
helper := FixtureHelper{sleepOn: "SetUpSuite", sleep: 1000000 * time.Nanosecond}
|
|
||||||
output := String{}
|
|
||||||
runConf := RunConf{Output: &output, Stream: true}
|
|
||||||
Run(&helper, &runConf)
|
|
||||||
|
|
||||||
expected := "(?s).*\nPASS: check_test\\.go:[0-9]+: FixtureHelper\\.SetUpSuite\t[0-9]+\\.[0-9]+s\n.*"
|
|
||||||
c.Assert(output.value, Matches, expected)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *BenchmarkS) TestBenchmark(c *C) {
|
|
||||||
helper := FixtureHelper{sleep: 100000}
|
|
||||||
output := String{}
|
|
||||||
runConf := RunConf{
|
|
||||||
Output: &output,
|
|
||||||
Benchmark: true,
|
|
||||||
BenchmarkTime: 10000000,
|
|
||||||
Filter: "Benchmark1",
|
|
||||||
}
|
|
||||||
Run(&helper, &runConf)
|
|
||||||
c.Check(helper.calls[0], Equals, "SetUpSuite")
|
|
||||||
c.Check(helper.calls[1], Equals, "SetUpTest")
|
|
||||||
c.Check(helper.calls[2], Equals, "Benchmark1")
|
|
||||||
c.Check(helper.calls[3], Equals, "TearDownTest")
|
|
||||||
c.Check(helper.calls[4], Equals, "SetUpTest")
|
|
||||||
c.Check(helper.calls[5], Equals, "Benchmark1")
|
|
||||||
c.Check(helper.calls[6], Equals, "TearDownTest")
|
|
||||||
// ... and more.
|
|
||||||
|
|
||||||
expected := "PASS: check_test\\.go:[0-9]+: FixtureHelper\\.Benchmark1\t\\s+[0-9]+\t\\s+[0-9]+ ns/op\n"
|
|
||||||
c.Assert(output.value, Matches, expected)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *BenchmarkS) TestBenchmarkBytes(c *C) {
|
|
||||||
helper := FixtureHelper{sleep: 100000}
|
|
||||||
output := String{}
|
|
||||||
runConf := RunConf{
|
|
||||||
Output: &output,
|
|
||||||
Benchmark: true,
|
|
||||||
BenchmarkTime: 10000000,
|
|
||||||
Filter: "Benchmark2",
|
|
||||||
}
|
|
||||||
Run(&helper, &runConf)
|
|
||||||
|
|
||||||
expected := "PASS: check_test\\.go:[0-9]+: FixtureHelper\\.Benchmark2\t\\s+[0-9]+\t\\s+[0-9]+ ns/op\t\\s+ *[1-9]\\.[0-9]{2} MB/s\n"
|
|
||||||
c.Assert(output.value, Matches, expected)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *BenchmarkS) TestBenchmarkMem(c *C) {
|
|
||||||
helper := FixtureHelper{sleep: 100000}
|
|
||||||
output := String{}
|
|
||||||
runConf := RunConf{
|
|
||||||
Output: &output,
|
|
||||||
Benchmark: true,
|
|
||||||
BenchmarkMem: true,
|
|
||||||
BenchmarkTime: 10000000,
|
|
||||||
Filter: "Benchmark3",
|
|
||||||
}
|
|
||||||
Run(&helper, &runConf)
|
|
||||||
|
|
||||||
expected := "PASS: check_test\\.go:[0-9]+: FixtureHelper\\.Benchmark3\t\\s+ [0-9]+\t\\s+ *[0-9]+ ns/op\t\\s+ [0-9]+ B/op\t\\s+ [1-9]+ allocs/op\n"
|
|
||||||
c.Assert(output.value, Matches, expected)
|
|
||||||
}
|
|
82
vendor/gopkg.in/check.v1/bootstrap_test.go
generated
vendored
82
vendor/gopkg.in/check.v1/bootstrap_test.go
generated
vendored
@ -1,82 +0,0 @@
|
|||||||
// These initial tests are for bootstrapping. They verify that we can
|
|
||||||
// basically use the testing infrastructure itself to check if the test
|
|
||||||
// system is working.
|
|
||||||
//
|
|
||||||
// These tests use will break down the test runner badly in case of
|
|
||||||
// errors because if they simply fail, we can't be sure the developer
|
|
||||||
// will ever see anything (because failing means the failing system
|
|
||||||
// somehow isn't working! :-)
|
|
||||||
//
|
|
||||||
// Do not assume *any* internal functionality works as expected besides
|
|
||||||
// what's actually tested here.
|
|
||||||
|
|
||||||
package check_test
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"gopkg.in/check.v1"
|
|
||||||
"strings"
|
|
||||||
)
|
|
||||||
|
|
||||||
type BootstrapS struct{}
|
|
||||||
|
|
||||||
var boostrapS = check.Suite(&BootstrapS{})
|
|
||||||
|
|
||||||
func (s *BootstrapS) TestCountSuite(c *check.C) {
|
|
||||||
suitesRun += 1
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *BootstrapS) TestFailedAndFail(c *check.C) {
|
|
||||||
if c.Failed() {
|
|
||||||
critical("c.Failed() must be false first!")
|
|
||||||
}
|
|
||||||
c.Fail()
|
|
||||||
if !c.Failed() {
|
|
||||||
critical("c.Fail() didn't put the test in a failed state!")
|
|
||||||
}
|
|
||||||
c.Succeed()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *BootstrapS) TestFailedAndSucceed(c *check.C) {
|
|
||||||
c.Fail()
|
|
||||||
c.Succeed()
|
|
||||||
if c.Failed() {
|
|
||||||
critical("c.Succeed() didn't put the test back in a non-failed state")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *BootstrapS) TestLogAndGetTestLog(c *check.C) {
|
|
||||||
c.Log("Hello there!")
|
|
||||||
log := c.GetTestLog()
|
|
||||||
if log != "Hello there!\n" {
|
|
||||||
critical(fmt.Sprintf("Log() or GetTestLog() is not working! Got: %#v", log))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *BootstrapS) TestLogfAndGetTestLog(c *check.C) {
|
|
||||||
c.Logf("Hello %v", "there!")
|
|
||||||
log := c.GetTestLog()
|
|
||||||
if log != "Hello there!\n" {
|
|
||||||
critical(fmt.Sprintf("Logf() or GetTestLog() is not working! Got: %#v", log))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *BootstrapS) TestRunShowsErrors(c *check.C) {
|
|
||||||
output := String{}
|
|
||||||
check.Run(&FailHelper{}, &check.RunConf{Output: &output})
|
|
||||||
if strings.Index(output.value, "Expected failure!") == -1 {
|
|
||||||
critical(fmt.Sprintf("RunWithWriter() output did not contain the "+
|
|
||||||
"expected failure! Got: %#v",
|
|
||||||
output.value))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *BootstrapS) TestRunDoesntShowSuccesses(c *check.C) {
|
|
||||||
output := String{}
|
|
||||||
check.Run(&SuccessHelper{}, &check.RunConf{Output: &output})
|
|
||||||
if strings.Index(output.value, "Expected success!") != -1 {
|
|
||||||
critical(fmt.Sprintf("RunWithWriter() output contained a successful "+
|
|
||||||
"test! Got: %#v",
|
|
||||||
output.value))
|
|
||||||
}
|
|
||||||
}
|
|
873
vendor/gopkg.in/check.v1/check.go
generated
vendored
873
vendor/gopkg.in/check.v1/check.go
generated
vendored
@ -1,873 +0,0 @@
|
|||||||
// Package check is a rich testing extension for Go's testing package.
|
|
||||||
//
|
|
||||||
// For details about the project, see:
|
|
||||||
//
|
|
||||||
// http://labix.org/gocheck
|
|
||||||
//
|
|
||||||
package check
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"errors"
|
|
||||||
"fmt"
|
|
||||||
"io"
|
|
||||||
"math/rand"
|
|
||||||
"os"
|
|
||||||
"path"
|
|
||||||
"path/filepath"
|
|
||||||
"reflect"
|
|
||||||
"regexp"
|
|
||||||
"runtime"
|
|
||||||
"strconv"
|
|
||||||
"strings"
|
|
||||||
"sync"
|
|
||||||
"sync/atomic"
|
|
||||||
"time"
|
|
||||||
)
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Internal type which deals with suite method calling.
|
|
||||||
|
|
||||||
const (
|
|
||||||
fixtureKd = iota
|
|
||||||
testKd
|
|
||||||
)
|
|
||||||
|
|
||||||
type funcKind int
|
|
||||||
|
|
||||||
const (
|
|
||||||
succeededSt = iota
|
|
||||||
failedSt
|
|
||||||
skippedSt
|
|
||||||
panickedSt
|
|
||||||
fixturePanickedSt
|
|
||||||
missedSt
|
|
||||||
)
|
|
||||||
|
|
||||||
type funcStatus uint32
|
|
||||||
|
|
||||||
// A method value can't reach its own Method structure.
|
|
||||||
type methodType struct {
|
|
||||||
reflect.Value
|
|
||||||
Info reflect.Method
|
|
||||||
}
|
|
||||||
|
|
||||||
func newMethod(receiver reflect.Value, i int) *methodType {
|
|
||||||
return &methodType{receiver.Method(i), receiver.Type().Method(i)}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (method *methodType) PC() uintptr {
|
|
||||||
return method.Info.Func.Pointer()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (method *methodType) suiteName() string {
|
|
||||||
t := method.Info.Type.In(0)
|
|
||||||
if t.Kind() == reflect.Ptr {
|
|
||||||
t = t.Elem()
|
|
||||||
}
|
|
||||||
return t.Name()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (method *methodType) String() string {
|
|
||||||
return method.suiteName() + "." + method.Info.Name
|
|
||||||
}
|
|
||||||
|
|
||||||
func (method *methodType) matches(re *regexp.Regexp) bool {
|
|
||||||
return (re.MatchString(method.Info.Name) ||
|
|
||||||
re.MatchString(method.suiteName()) ||
|
|
||||||
re.MatchString(method.String()))
|
|
||||||
}
|
|
||||||
|
|
||||||
type C struct {
|
|
||||||
method *methodType
|
|
||||||
kind funcKind
|
|
||||||
testName string
|
|
||||||
_status funcStatus
|
|
||||||
logb *logger
|
|
||||||
logw io.Writer
|
|
||||||
done chan *C
|
|
||||||
reason string
|
|
||||||
mustFail bool
|
|
||||||
tempDir *tempDir
|
|
||||||
benchMem bool
|
|
||||||
startTime time.Time
|
|
||||||
timer
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *C) status() funcStatus {
|
|
||||||
return funcStatus(atomic.LoadUint32((*uint32)(&c._status)))
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *C) setStatus(s funcStatus) {
|
|
||||||
atomic.StoreUint32((*uint32)(&c._status), uint32(s))
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *C) stopNow() {
|
|
||||||
runtime.Goexit()
|
|
||||||
}
|
|
||||||
|
|
||||||
// logger is a concurrency safe byte.Buffer
|
|
||||||
type logger struct {
|
|
||||||
sync.Mutex
|
|
||||||
writer bytes.Buffer
|
|
||||||
}
|
|
||||||
|
|
||||||
func (l *logger) Write(buf []byte) (int, error) {
|
|
||||||
l.Lock()
|
|
||||||
defer l.Unlock()
|
|
||||||
return l.writer.Write(buf)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (l *logger) WriteTo(w io.Writer) (int64, error) {
|
|
||||||
l.Lock()
|
|
||||||
defer l.Unlock()
|
|
||||||
return l.writer.WriteTo(w)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (l *logger) String() string {
|
|
||||||
l.Lock()
|
|
||||||
defer l.Unlock()
|
|
||||||
return l.writer.String()
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Handling of temporary files and directories.
|
|
||||||
|
|
||||||
type tempDir struct {
|
|
||||||
sync.Mutex
|
|
||||||
path string
|
|
||||||
counter int
|
|
||||||
}
|
|
||||||
|
|
||||||
func (td *tempDir) newPath() string {
|
|
||||||
td.Lock()
|
|
||||||
defer td.Unlock()
|
|
||||||
if td.path == "" {
|
|
||||||
var err error
|
|
||||||
for i := 0; i != 100; i++ {
|
|
||||||
path := fmt.Sprintf("%s%ccheck-%d", os.TempDir(), os.PathSeparator, rand.Int())
|
|
||||||
if err = os.Mkdir(path, 0700); err == nil {
|
|
||||||
td.path = path
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if td.path == "" {
|
|
||||||
panic("Couldn't create temporary directory: " + err.Error())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
result := filepath.Join(td.path, strconv.Itoa(td.counter))
|
|
||||||
td.counter++
|
|
||||||
return result
|
|
||||||
}
|
|
||||||
|
|
||||||
func (td *tempDir) removeAll() {
|
|
||||||
td.Lock()
|
|
||||||
defer td.Unlock()
|
|
||||||
if td.path != "" {
|
|
||||||
err := os.RemoveAll(td.path)
|
|
||||||
if err != nil {
|
|
||||||
fmt.Fprintf(os.Stderr, "WARNING: Error cleaning up temporaries: "+err.Error())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Create a new temporary directory which is automatically removed after
|
|
||||||
// the suite finishes running.
|
|
||||||
func (c *C) MkDir() string {
|
|
||||||
path := c.tempDir.newPath()
|
|
||||||
if err := os.Mkdir(path, 0700); err != nil {
|
|
||||||
panic(fmt.Sprintf("Couldn't create temporary directory %s: %s", path, err.Error()))
|
|
||||||
}
|
|
||||||
return path
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Low-level logging functions.
|
|
||||||
|
|
||||||
func (c *C) log(args ...interface{}) {
|
|
||||||
c.writeLog([]byte(fmt.Sprint(args...) + "\n"))
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *C) logf(format string, args ...interface{}) {
|
|
||||||
c.writeLog([]byte(fmt.Sprintf(format+"\n", args...)))
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *C) logNewLine() {
|
|
||||||
c.writeLog([]byte{'\n'})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *C) writeLog(buf []byte) {
|
|
||||||
c.logb.Write(buf)
|
|
||||||
if c.logw != nil {
|
|
||||||
c.logw.Write(buf)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func hasStringOrError(x interface{}) (ok bool) {
|
|
||||||
_, ok = x.(fmt.Stringer)
|
|
||||||
if ok {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
_, ok = x.(error)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *C) logValue(label string, value interface{}) {
|
|
||||||
if label == "" {
|
|
||||||
if hasStringOrError(value) {
|
|
||||||
c.logf("... %#v (%q)", value, value)
|
|
||||||
} else {
|
|
||||||
c.logf("... %#v", value)
|
|
||||||
}
|
|
||||||
} else if value == nil {
|
|
||||||
c.logf("... %s = nil", label)
|
|
||||||
} else {
|
|
||||||
if hasStringOrError(value) {
|
|
||||||
fv := fmt.Sprintf("%#v", value)
|
|
||||||
qv := fmt.Sprintf("%q", value)
|
|
||||||
if fv != qv {
|
|
||||||
c.logf("... %s %s = %s (%s)", label, reflect.TypeOf(value), fv, qv)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if s, ok := value.(string); ok && isMultiLine(s) {
|
|
||||||
c.logf(`... %s %s = "" +`, label, reflect.TypeOf(value))
|
|
||||||
c.logMultiLine(s)
|
|
||||||
} else {
|
|
||||||
c.logf("... %s %s = %#v", label, reflect.TypeOf(value), value)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *C) logMultiLine(s string) {
|
|
||||||
b := make([]byte, 0, len(s)*2)
|
|
||||||
i := 0
|
|
||||||
n := len(s)
|
|
||||||
for i < n {
|
|
||||||
j := i + 1
|
|
||||||
for j < n && s[j-1] != '\n' {
|
|
||||||
j++
|
|
||||||
}
|
|
||||||
b = append(b, "... "...)
|
|
||||||
b = strconv.AppendQuote(b, s[i:j])
|
|
||||||
if j < n {
|
|
||||||
b = append(b, " +"...)
|
|
||||||
}
|
|
||||||
b = append(b, '\n')
|
|
||||||
i = j
|
|
||||||
}
|
|
||||||
c.writeLog(b)
|
|
||||||
}
|
|
||||||
|
|
||||||
func isMultiLine(s string) bool {
|
|
||||||
for i := 0; i+1 < len(s); i++ {
|
|
||||||
if s[i] == '\n' {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *C) logString(issue string) {
|
|
||||||
c.log("... ", issue)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *C) logCaller(skip int) {
|
|
||||||
// This is a bit heavier than it ought to be.
|
|
||||||
skip++ // Our own frame.
|
|
||||||
pc, callerFile, callerLine, ok := runtime.Caller(skip)
|
|
||||||
if !ok {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
var testFile string
|
|
||||||
var testLine int
|
|
||||||
testFunc := runtime.FuncForPC(c.method.PC())
|
|
||||||
if runtime.FuncForPC(pc) != testFunc {
|
|
||||||
for {
|
|
||||||
skip++
|
|
||||||
if pc, file, line, ok := runtime.Caller(skip); ok {
|
|
||||||
// Note that the test line may be different on
|
|
||||||
// distinct calls for the same test. Showing
|
|
||||||
// the "internal" line is helpful when debugging.
|
|
||||||
if runtime.FuncForPC(pc) == testFunc {
|
|
||||||
testFile, testLine = file, line
|
|
||||||
break
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if testFile != "" && (testFile != callerFile || testLine != callerLine) {
|
|
||||||
c.logCode(testFile, testLine)
|
|
||||||
}
|
|
||||||
c.logCode(callerFile, callerLine)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *C) logCode(path string, line int) {
|
|
||||||
c.logf("%s:%d:", nicePath(path), line)
|
|
||||||
code, err := printLine(path, line)
|
|
||||||
if code == "" {
|
|
||||||
code = "..." // XXX Open the file and take the raw line.
|
|
||||||
if err != nil {
|
|
||||||
code += err.Error()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
c.log(indent(code, " "))
|
|
||||||
}
|
|
||||||
|
|
||||||
var valueGo = filepath.Join("reflect", "value.go")
|
|
||||||
var asmGo = filepath.Join("runtime", "asm_")
|
|
||||||
|
|
||||||
func (c *C) logPanic(skip int, value interface{}) {
|
|
||||||
skip++ // Our own frame.
|
|
||||||
initialSkip := skip
|
|
||||||
for ; ; skip++ {
|
|
||||||
if pc, file, line, ok := runtime.Caller(skip); ok {
|
|
||||||
if skip == initialSkip {
|
|
||||||
c.logf("... Panic: %s (PC=0x%X)\n", value, pc)
|
|
||||||
}
|
|
||||||
name := niceFuncName(pc)
|
|
||||||
path := nicePath(file)
|
|
||||||
if strings.Contains(path, "/gopkg.in/check.v") {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
if name == "Value.call" && strings.HasSuffix(path, valueGo) {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
if (name == "call16" || name == "call32") && strings.Contains(path, asmGo) {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
c.logf("%s:%d\n in %s", nicePath(file), line, name)
|
|
||||||
} else {
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *C) logSoftPanic(issue string) {
|
|
||||||
c.log("... Panic: ", issue)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *C) logArgPanic(method *methodType, expectedType string) {
|
|
||||||
c.logf("... Panic: %s argument should be %s",
|
|
||||||
niceFuncName(method.PC()), expectedType)
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Some simple formatting helpers.
|
|
||||||
|
|
||||||
var initWD, initWDErr = os.Getwd()
|
|
||||||
|
|
||||||
func init() {
|
|
||||||
if initWDErr == nil {
|
|
||||||
initWD = strings.Replace(initWD, "\\", "/", -1) + "/"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func nicePath(path string) string {
|
|
||||||
if initWDErr == nil {
|
|
||||||
if strings.HasPrefix(path, initWD) {
|
|
||||||
return path[len(initWD):]
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return path
|
|
||||||
}
|
|
||||||
|
|
||||||
func niceFuncPath(pc uintptr) string {
|
|
||||||
function := runtime.FuncForPC(pc)
|
|
||||||
if function != nil {
|
|
||||||
filename, line := function.FileLine(pc)
|
|
||||||
return fmt.Sprintf("%s:%d", nicePath(filename), line)
|
|
||||||
}
|
|
||||||
return "<unknown path>"
|
|
||||||
}
|
|
||||||
|
|
||||||
func niceFuncName(pc uintptr) string {
|
|
||||||
function := runtime.FuncForPC(pc)
|
|
||||||
if function != nil {
|
|
||||||
name := path.Base(function.Name())
|
|
||||||
if i := strings.Index(name, "."); i > 0 {
|
|
||||||
name = name[i+1:]
|
|
||||||
}
|
|
||||||
if strings.HasPrefix(name, "(*") {
|
|
||||||
if i := strings.Index(name, ")"); i > 0 {
|
|
||||||
name = name[2:i] + name[i+1:]
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if i := strings.LastIndex(name, ".*"); i != -1 {
|
|
||||||
name = name[:i] + "." + name[i+2:]
|
|
||||||
}
|
|
||||||
if i := strings.LastIndex(name, "·"); i != -1 {
|
|
||||||
name = name[:i] + "." + name[i+2:]
|
|
||||||
}
|
|
||||||
return name
|
|
||||||
}
|
|
||||||
return "<unknown function>"
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Result tracker to aggregate call results.
|
|
||||||
|
|
||||||
type Result struct {
|
|
||||||
Succeeded int
|
|
||||||
Failed int
|
|
||||||
Skipped int
|
|
||||||
Panicked int
|
|
||||||
FixturePanicked int
|
|
||||||
ExpectedFailures int
|
|
||||||
Missed int // Not even tried to run, related to a panic in the fixture.
|
|
||||||
RunError error // Houston, we've got a problem.
|
|
||||||
WorkDir string // If KeepWorkDir is true
|
|
||||||
}
|
|
||||||
|
|
||||||
type resultTracker struct {
|
|
||||||
result Result
|
|
||||||
_lastWasProblem bool
|
|
||||||
_waiting int
|
|
||||||
_missed int
|
|
||||||
_expectChan chan *C
|
|
||||||
_doneChan chan *C
|
|
||||||
_stopChan chan bool
|
|
||||||
}
|
|
||||||
|
|
||||||
func newResultTracker() *resultTracker {
|
|
||||||
return &resultTracker{_expectChan: make(chan *C), // Synchronous
|
|
||||||
_doneChan: make(chan *C, 32), // Asynchronous
|
|
||||||
_stopChan: make(chan bool)} // Synchronous
|
|
||||||
}
|
|
||||||
|
|
||||||
func (tracker *resultTracker) start() {
|
|
||||||
go tracker._loopRoutine()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (tracker *resultTracker) waitAndStop() {
|
|
||||||
<-tracker._stopChan
|
|
||||||
}
|
|
||||||
|
|
||||||
func (tracker *resultTracker) expectCall(c *C) {
|
|
||||||
tracker._expectChan <- c
|
|
||||||
}
|
|
||||||
|
|
||||||
func (tracker *resultTracker) callDone(c *C) {
|
|
||||||
tracker._doneChan <- c
|
|
||||||
}
|
|
||||||
|
|
||||||
func (tracker *resultTracker) _loopRoutine() {
|
|
||||||
for {
|
|
||||||
var c *C
|
|
||||||
if tracker._waiting > 0 {
|
|
||||||
// Calls still running. Can't stop.
|
|
||||||
select {
|
|
||||||
// XXX Reindent this (not now to make diff clear)
|
|
||||||
case <-tracker._expectChan:
|
|
||||||
tracker._waiting++
|
|
||||||
case c = <-tracker._doneChan:
|
|
||||||
tracker._waiting--
|
|
||||||
switch c.status() {
|
|
||||||
case succeededSt:
|
|
||||||
if c.kind == testKd {
|
|
||||||
if c.mustFail {
|
|
||||||
tracker.result.ExpectedFailures++
|
|
||||||
} else {
|
|
||||||
tracker.result.Succeeded++
|
|
||||||
}
|
|
||||||
}
|
|
||||||
case failedSt:
|
|
||||||
tracker.result.Failed++
|
|
||||||
case panickedSt:
|
|
||||||
if c.kind == fixtureKd {
|
|
||||||
tracker.result.FixturePanicked++
|
|
||||||
} else {
|
|
||||||
tracker.result.Panicked++
|
|
||||||
}
|
|
||||||
case fixturePanickedSt:
|
|
||||||
// Track it as missed, since the panic
|
|
||||||
// was on the fixture, not on the test.
|
|
||||||
tracker.result.Missed++
|
|
||||||
case missedSt:
|
|
||||||
tracker.result.Missed++
|
|
||||||
case skippedSt:
|
|
||||||
if c.kind == testKd {
|
|
||||||
tracker.result.Skipped++
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
// No calls. Can stop, but no done calls here.
|
|
||||||
select {
|
|
||||||
case tracker._stopChan <- true:
|
|
||||||
return
|
|
||||||
case <-tracker._expectChan:
|
|
||||||
tracker._waiting++
|
|
||||||
case <-tracker._doneChan:
|
|
||||||
panic("Tracker got an unexpected done call.")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// The underlying suite runner.
|
|
||||||
|
|
||||||
type suiteRunner struct {
|
|
||||||
suite interface{}
|
|
||||||
setUpSuite, tearDownSuite *methodType
|
|
||||||
setUpTest, tearDownTest *methodType
|
|
||||||
tests []*methodType
|
|
||||||
tracker *resultTracker
|
|
||||||
tempDir *tempDir
|
|
||||||
keepDir bool
|
|
||||||
output *outputWriter
|
|
||||||
reportedProblemLast bool
|
|
||||||
benchTime time.Duration
|
|
||||||
benchMem bool
|
|
||||||
}
|
|
||||||
|
|
||||||
type RunConf struct {
|
|
||||||
Output io.Writer
|
|
||||||
Stream bool
|
|
||||||
Verbose bool
|
|
||||||
Filter string
|
|
||||||
Benchmark bool
|
|
||||||
BenchmarkTime time.Duration // Defaults to 1 second
|
|
||||||
BenchmarkMem bool
|
|
||||||
KeepWorkDir bool
|
|
||||||
}
|
|
||||||
|
|
||||||
// Create a new suiteRunner able to run all methods in the given suite.
|
|
||||||
func newSuiteRunner(suite interface{}, runConf *RunConf) *suiteRunner {
|
|
||||||
var conf RunConf
|
|
||||||
if runConf != nil {
|
|
||||||
conf = *runConf
|
|
||||||
}
|
|
||||||
if conf.Output == nil {
|
|
||||||
conf.Output = os.Stdout
|
|
||||||
}
|
|
||||||
if conf.Benchmark {
|
|
||||||
conf.Verbose = true
|
|
||||||
}
|
|
||||||
|
|
||||||
suiteType := reflect.TypeOf(suite)
|
|
||||||
suiteNumMethods := suiteType.NumMethod()
|
|
||||||
suiteValue := reflect.ValueOf(suite)
|
|
||||||
|
|
||||||
runner := &suiteRunner{
|
|
||||||
suite: suite,
|
|
||||||
output: newOutputWriter(conf.Output, conf.Stream, conf.Verbose),
|
|
||||||
tracker: newResultTracker(),
|
|
||||||
benchTime: conf.BenchmarkTime,
|
|
||||||
benchMem: conf.BenchmarkMem,
|
|
||||||
tempDir: &tempDir{},
|
|
||||||
keepDir: conf.KeepWorkDir,
|
|
||||||
tests: make([]*methodType, 0, suiteNumMethods),
|
|
||||||
}
|
|
||||||
if runner.benchTime == 0 {
|
|
||||||
runner.benchTime = 1 * time.Second
|
|
||||||
}
|
|
||||||
|
|
||||||
var filterRegexp *regexp.Regexp
|
|
||||||
if conf.Filter != "" {
|
|
||||||
regexp, err := regexp.Compile(conf.Filter)
|
|
||||||
if err != nil {
|
|
||||||
msg := "Bad filter expression: " + err.Error()
|
|
||||||
runner.tracker.result.RunError = errors.New(msg)
|
|
||||||
return runner
|
|
||||||
}
|
|
||||||
filterRegexp = regexp
|
|
||||||
}
|
|
||||||
|
|
||||||
for i := 0; i != suiteNumMethods; i++ {
|
|
||||||
method := newMethod(suiteValue, i)
|
|
||||||
switch method.Info.Name {
|
|
||||||
case "SetUpSuite":
|
|
||||||
runner.setUpSuite = method
|
|
||||||
case "TearDownSuite":
|
|
||||||
runner.tearDownSuite = method
|
|
||||||
case "SetUpTest":
|
|
||||||
runner.setUpTest = method
|
|
||||||
case "TearDownTest":
|
|
||||||
runner.tearDownTest = method
|
|
||||||
default:
|
|
||||||
prefix := "Test"
|
|
||||||
if conf.Benchmark {
|
|
||||||
prefix = "Benchmark"
|
|
||||||
}
|
|
||||||
if !strings.HasPrefix(method.Info.Name, prefix) {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
if filterRegexp == nil || method.matches(filterRegexp) {
|
|
||||||
runner.tests = append(runner.tests, method)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return runner
|
|
||||||
}
|
|
||||||
|
|
||||||
// Run all methods in the given suite.
|
|
||||||
func (runner *suiteRunner) run() *Result {
|
|
||||||
if runner.tracker.result.RunError == nil && len(runner.tests) > 0 {
|
|
||||||
runner.tracker.start()
|
|
||||||
if runner.checkFixtureArgs() {
|
|
||||||
c := runner.runFixture(runner.setUpSuite, "", nil)
|
|
||||||
if c == nil || c.status() == succeededSt {
|
|
||||||
for i := 0; i != len(runner.tests); i++ {
|
|
||||||
c := runner.runTest(runner.tests[i])
|
|
||||||
if c.status() == fixturePanickedSt {
|
|
||||||
runner.skipTests(missedSt, runner.tests[i+1:])
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
} else if c != nil && c.status() == skippedSt {
|
|
||||||
runner.skipTests(skippedSt, runner.tests)
|
|
||||||
} else {
|
|
||||||
runner.skipTests(missedSt, runner.tests)
|
|
||||||
}
|
|
||||||
runner.runFixture(runner.tearDownSuite, "", nil)
|
|
||||||
} else {
|
|
||||||
runner.skipTests(missedSt, runner.tests)
|
|
||||||
}
|
|
||||||
runner.tracker.waitAndStop()
|
|
||||||
if runner.keepDir {
|
|
||||||
runner.tracker.result.WorkDir = runner.tempDir.path
|
|
||||||
} else {
|
|
||||||
runner.tempDir.removeAll()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return &runner.tracker.result
|
|
||||||
}
|
|
||||||
|
|
||||||
// Create a call object with the given suite method, and fork a
|
|
||||||
// goroutine with the provided dispatcher for running it.
|
|
||||||
func (runner *suiteRunner) forkCall(method *methodType, kind funcKind, testName string, logb *logger, dispatcher func(c *C)) *C {
|
|
||||||
var logw io.Writer
|
|
||||||
if runner.output.Stream {
|
|
||||||
logw = runner.output
|
|
||||||
}
|
|
||||||
if logb == nil {
|
|
||||||
logb = new(logger)
|
|
||||||
}
|
|
||||||
c := &C{
|
|
||||||
method: method,
|
|
||||||
kind: kind,
|
|
||||||
testName: testName,
|
|
||||||
logb: logb,
|
|
||||||
logw: logw,
|
|
||||||
tempDir: runner.tempDir,
|
|
||||||
done: make(chan *C, 1),
|
|
||||||
timer: timer{benchTime: runner.benchTime},
|
|
||||||
startTime: time.Now(),
|
|
||||||
benchMem: runner.benchMem,
|
|
||||||
}
|
|
||||||
runner.tracker.expectCall(c)
|
|
||||||
go (func() {
|
|
||||||
runner.reportCallStarted(c)
|
|
||||||
defer runner.callDone(c)
|
|
||||||
dispatcher(c)
|
|
||||||
})()
|
|
||||||
return c
|
|
||||||
}
|
|
||||||
|
|
||||||
// Same as forkCall(), but wait for call to finish before returning.
|
|
||||||
func (runner *suiteRunner) runFunc(method *methodType, kind funcKind, testName string, logb *logger, dispatcher func(c *C)) *C {
|
|
||||||
c := runner.forkCall(method, kind, testName, logb, dispatcher)
|
|
||||||
<-c.done
|
|
||||||
return c
|
|
||||||
}
|
|
||||||
|
|
||||||
// Handle a finished call. If there were any panics, update the call status
|
|
||||||
// accordingly. Then, mark the call as done and report to the tracker.
|
|
||||||
func (runner *suiteRunner) callDone(c *C) {
|
|
||||||
value := recover()
|
|
||||||
if value != nil {
|
|
||||||
switch v := value.(type) {
|
|
||||||
case *fixturePanic:
|
|
||||||
if v.status == skippedSt {
|
|
||||||
c.setStatus(skippedSt)
|
|
||||||
} else {
|
|
||||||
c.logSoftPanic("Fixture has panicked (see related PANIC)")
|
|
||||||
c.setStatus(fixturePanickedSt)
|
|
||||||
}
|
|
||||||
default:
|
|
||||||
c.logPanic(1, value)
|
|
||||||
c.setStatus(panickedSt)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if c.mustFail {
|
|
||||||
switch c.status() {
|
|
||||||
case failedSt:
|
|
||||||
c.setStatus(succeededSt)
|
|
||||||
case succeededSt:
|
|
||||||
c.setStatus(failedSt)
|
|
||||||
c.logString("Error: Test succeeded, but was expected to fail")
|
|
||||||
c.logString("Reason: " + c.reason)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
runner.reportCallDone(c)
|
|
||||||
c.done <- c
|
|
||||||
}
|
|
||||||
|
|
||||||
// Runs a fixture call synchronously. The fixture will still be run in a
|
|
||||||
// goroutine like all suite methods, but this method will not return
|
|
||||||
// while the fixture goroutine is not done, because the fixture must be
|
|
||||||
// run in a desired order.
|
|
||||||
func (runner *suiteRunner) runFixture(method *methodType, testName string, logb *logger) *C {
|
|
||||||
if method != nil {
|
|
||||||
c := runner.runFunc(method, fixtureKd, testName, logb, func(c *C) {
|
|
||||||
c.ResetTimer()
|
|
||||||
c.StartTimer()
|
|
||||||
defer c.StopTimer()
|
|
||||||
c.method.Call([]reflect.Value{reflect.ValueOf(c)})
|
|
||||||
})
|
|
||||||
return c
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Run the fixture method with runFixture(), but panic with a fixturePanic{}
|
|
||||||
// in case the fixture method panics. This makes it easier to track the
|
|
||||||
// fixture panic together with other call panics within forkTest().
|
|
||||||
func (runner *suiteRunner) runFixtureWithPanic(method *methodType, testName string, logb *logger, skipped *bool) *C {
|
|
||||||
if skipped != nil && *skipped {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
c := runner.runFixture(method, testName, logb)
|
|
||||||
if c != nil && c.status() != succeededSt {
|
|
||||||
if skipped != nil {
|
|
||||||
*skipped = c.status() == skippedSt
|
|
||||||
}
|
|
||||||
panic(&fixturePanic{c.status(), method})
|
|
||||||
}
|
|
||||||
return c
|
|
||||||
}
|
|
||||||
|
|
||||||
type fixturePanic struct {
|
|
||||||
status funcStatus
|
|
||||||
method *methodType
|
|
||||||
}
|
|
||||||
|
|
||||||
// Run the suite test method, together with the test-specific fixture,
|
|
||||||
// asynchronously.
|
|
||||||
func (runner *suiteRunner) forkTest(method *methodType) *C {
|
|
||||||
testName := method.String()
|
|
||||||
return runner.forkCall(method, testKd, testName, nil, func(c *C) {
|
|
||||||
var skipped bool
|
|
||||||
defer runner.runFixtureWithPanic(runner.tearDownTest, testName, nil, &skipped)
|
|
||||||
defer c.StopTimer()
|
|
||||||
benchN := 1
|
|
||||||
for {
|
|
||||||
runner.runFixtureWithPanic(runner.setUpTest, testName, c.logb, &skipped)
|
|
||||||
mt := c.method.Type()
|
|
||||||
if mt.NumIn() != 1 || mt.In(0) != reflect.TypeOf(c) {
|
|
||||||
// Rather than a plain panic, provide a more helpful message when
|
|
||||||
// the argument type is incorrect.
|
|
||||||
c.setStatus(panickedSt)
|
|
||||||
c.logArgPanic(c.method, "*check.C")
|
|
||||||
return
|
|
||||||
}
|
|
||||||
if strings.HasPrefix(c.method.Info.Name, "Test") {
|
|
||||||
c.ResetTimer()
|
|
||||||
c.StartTimer()
|
|
||||||
c.method.Call([]reflect.Value{reflect.ValueOf(c)})
|
|
||||||
return
|
|
||||||
}
|
|
||||||
if !strings.HasPrefix(c.method.Info.Name, "Benchmark") {
|
|
||||||
panic("unexpected method prefix: " + c.method.Info.Name)
|
|
||||||
}
|
|
||||||
|
|
||||||
runtime.GC()
|
|
||||||
c.N = benchN
|
|
||||||
c.ResetTimer()
|
|
||||||
c.StartTimer()
|
|
||||||
c.method.Call([]reflect.Value{reflect.ValueOf(c)})
|
|
||||||
c.StopTimer()
|
|
||||||
if c.status() != succeededSt || c.duration >= c.benchTime || benchN >= 1e9 {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
perOpN := int(1e9)
|
|
||||||
if c.nsPerOp() != 0 {
|
|
||||||
perOpN = int(c.benchTime.Nanoseconds() / c.nsPerOp())
|
|
||||||
}
|
|
||||||
|
|
||||||
// Logic taken from the stock testing package:
|
|
||||||
// - Run more iterations than we think we'll need for a second (1.5x).
|
|
||||||
// - Don't grow too fast in case we had timing errors previously.
|
|
||||||
// - Be sure to run at least one more than last time.
|
|
||||||
benchN = max(min(perOpN+perOpN/2, 100*benchN), benchN+1)
|
|
||||||
benchN = roundUp(benchN)
|
|
||||||
|
|
||||||
skipped = true // Don't run the deferred one if this panics.
|
|
||||||
runner.runFixtureWithPanic(runner.tearDownTest, testName, nil, nil)
|
|
||||||
skipped = false
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
// Same as forkTest(), but wait for the test to finish before returning.
|
|
||||||
func (runner *suiteRunner) runTest(method *methodType) *C {
|
|
||||||
c := runner.forkTest(method)
|
|
||||||
<-c.done
|
|
||||||
return c
|
|
||||||
}
|
|
||||||
|
|
||||||
// Helper to mark tests as skipped or missed. A bit heavy for what
|
|
||||||
// it does, but it enables homogeneous handling of tracking, including
|
|
||||||
// nice verbose output.
|
|
||||||
func (runner *suiteRunner) skipTests(status funcStatus, methods []*methodType) {
|
|
||||||
for _, method := range methods {
|
|
||||||
runner.runFunc(method, testKd, "", nil, func(c *C) {
|
|
||||||
c.setStatus(status)
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Verify if the fixture arguments are *check.C. In case of errors,
|
|
||||||
// log the error as a panic in the fixture method call, and return false.
|
|
||||||
func (runner *suiteRunner) checkFixtureArgs() bool {
|
|
||||||
succeeded := true
|
|
||||||
argType := reflect.TypeOf(&C{})
|
|
||||||
for _, method := range []*methodType{runner.setUpSuite, runner.tearDownSuite, runner.setUpTest, runner.tearDownTest} {
|
|
||||||
if method != nil {
|
|
||||||
mt := method.Type()
|
|
||||||
if mt.NumIn() != 1 || mt.In(0) != argType {
|
|
||||||
succeeded = false
|
|
||||||
runner.runFunc(method, fixtureKd, "", nil, func(c *C) {
|
|
||||||
c.logArgPanic(method, "*check.C")
|
|
||||||
c.setStatus(panickedSt)
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return succeeded
|
|
||||||
}
|
|
||||||
|
|
||||||
func (runner *suiteRunner) reportCallStarted(c *C) {
|
|
||||||
runner.output.WriteCallStarted("START", c)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (runner *suiteRunner) reportCallDone(c *C) {
|
|
||||||
runner.tracker.callDone(c)
|
|
||||||
switch c.status() {
|
|
||||||
case succeededSt:
|
|
||||||
if c.mustFail {
|
|
||||||
runner.output.WriteCallSuccess("FAIL EXPECTED", c)
|
|
||||||
} else {
|
|
||||||
runner.output.WriteCallSuccess("PASS", c)
|
|
||||||
}
|
|
||||||
case skippedSt:
|
|
||||||
runner.output.WriteCallSuccess("SKIP", c)
|
|
||||||
case failedSt:
|
|
||||||
runner.output.WriteCallProblem("FAIL", c)
|
|
||||||
case panickedSt:
|
|
||||||
runner.output.WriteCallProblem("PANIC", c)
|
|
||||||
case fixturePanickedSt:
|
|
||||||
// That's a testKd call reporting that its fixture
|
|
||||||
// has panicked. The fixture call which caused the
|
|
||||||
// panic itself was tracked above. We'll report to
|
|
||||||
// aid debugging.
|
|
||||||
runner.output.WriteCallProblem("PANIC", c)
|
|
||||||
case missedSt:
|
|
||||||
runner.output.WriteCallSuccess("MISS", c)
|
|
||||||
}
|
|
||||||
}
|
|
207
vendor/gopkg.in/check.v1/check_test.go
generated
vendored
207
vendor/gopkg.in/check.v1/check_test.go
generated
vendored
@ -1,207 +0,0 @@
|
|||||||
// This file contains just a few generic helpers which are used by the
|
|
||||||
// other test files.
|
|
||||||
|
|
||||||
package check_test
|
|
||||||
|
|
||||||
import (
|
|
||||||
"flag"
|
|
||||||
"fmt"
|
|
||||||
"os"
|
|
||||||
"regexp"
|
|
||||||
"runtime"
|
|
||||||
"testing"
|
|
||||||
"time"
|
|
||||||
|
|
||||||
"gopkg.in/check.v1"
|
|
||||||
)
|
|
||||||
|
|
||||||
// We count the number of suites run at least to get a vague hint that the
|
|
||||||
// test suite is behaving as it should. Otherwise a bug introduced at the
|
|
||||||
// very core of the system could go unperceived.
|
|
||||||
const suitesRunExpected = 8
|
|
||||||
|
|
||||||
var suitesRun int = 0
|
|
||||||
|
|
||||||
func Test(t *testing.T) {
|
|
||||||
check.TestingT(t)
|
|
||||||
if suitesRun != suitesRunExpected && flag.Lookup("check.f").Value.String() == "" {
|
|
||||||
critical(fmt.Sprintf("Expected %d suites to run rather than %d",
|
|
||||||
suitesRunExpected, suitesRun))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Helper functions.
|
|
||||||
|
|
||||||
// Break down badly. This is used in test cases which can't yet assume
|
|
||||||
// that the fundamental bits are working.
|
|
||||||
func critical(error string) {
|
|
||||||
fmt.Fprintln(os.Stderr, "CRITICAL: "+error)
|
|
||||||
os.Exit(1)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Return the file line where it's called.
|
|
||||||
func getMyLine() int {
|
|
||||||
if _, _, line, ok := runtime.Caller(1); ok {
|
|
||||||
return line
|
|
||||||
}
|
|
||||||
return -1
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Helper type implementing a basic io.Writer for testing output.
|
|
||||||
|
|
||||||
// Type implementing the io.Writer interface for analyzing output.
|
|
||||||
type String struct {
|
|
||||||
value string
|
|
||||||
}
|
|
||||||
|
|
||||||
// The only function required by the io.Writer interface. Will append
|
|
||||||
// written data to the String.value string.
|
|
||||||
func (s *String) Write(p []byte) (n int, err error) {
|
|
||||||
s.value += string(p)
|
|
||||||
return len(p), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Trivial wrapper to test errors happening on a different file
|
|
||||||
// than the test itself.
|
|
||||||
func checkEqualWrapper(c *check.C, obtained, expected interface{}) (result bool, line int) {
|
|
||||||
return c.Check(obtained, check.Equals, expected), getMyLine()
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Helper suite for testing basic fail behavior.
|
|
||||||
|
|
||||||
type FailHelper struct {
|
|
||||||
testLine int
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FailHelper) TestLogAndFail(c *check.C) {
|
|
||||||
s.testLine = getMyLine() - 1
|
|
||||||
c.Log("Expected failure!")
|
|
||||||
c.Fail()
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Helper suite for testing basic success behavior.
|
|
||||||
|
|
||||||
type SuccessHelper struct{}
|
|
||||||
|
|
||||||
func (s *SuccessHelper) TestLogAndSucceed(c *check.C) {
|
|
||||||
c.Log("Expected success!")
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Helper suite for testing ordering and behavior of fixture.
|
|
||||||
|
|
||||||
type FixtureHelper struct {
|
|
||||||
calls []string
|
|
||||||
panicOn string
|
|
||||||
skip bool
|
|
||||||
skipOnN int
|
|
||||||
sleepOn string
|
|
||||||
sleep time.Duration
|
|
||||||
bytes int64
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FixtureHelper) trace(name string, c *check.C) {
|
|
||||||
s.calls = append(s.calls, name)
|
|
||||||
if name == s.panicOn {
|
|
||||||
panic(name)
|
|
||||||
}
|
|
||||||
if s.sleep > 0 && s.sleepOn == name {
|
|
||||||
time.Sleep(s.sleep)
|
|
||||||
}
|
|
||||||
if s.skip && s.skipOnN == len(s.calls)-1 {
|
|
||||||
c.Skip("skipOnN == n")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FixtureHelper) SetUpSuite(c *check.C) {
|
|
||||||
s.trace("SetUpSuite", c)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FixtureHelper) TearDownSuite(c *check.C) {
|
|
||||||
s.trace("TearDownSuite", c)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FixtureHelper) SetUpTest(c *check.C) {
|
|
||||||
s.trace("SetUpTest", c)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FixtureHelper) TearDownTest(c *check.C) {
|
|
||||||
s.trace("TearDownTest", c)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FixtureHelper) Test1(c *check.C) {
|
|
||||||
s.trace("Test1", c)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FixtureHelper) Test2(c *check.C) {
|
|
||||||
s.trace("Test2", c)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FixtureHelper) Benchmark1(c *check.C) {
|
|
||||||
s.trace("Benchmark1", c)
|
|
||||||
for i := 0; i < c.N; i++ {
|
|
||||||
time.Sleep(s.sleep)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FixtureHelper) Benchmark2(c *check.C) {
|
|
||||||
s.trace("Benchmark2", c)
|
|
||||||
c.SetBytes(1024)
|
|
||||||
for i := 0; i < c.N; i++ {
|
|
||||||
time.Sleep(s.sleep)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FixtureHelper) Benchmark3(c *check.C) {
|
|
||||||
var x []int64
|
|
||||||
s.trace("Benchmark3", c)
|
|
||||||
for i := 0; i < c.N; i++ {
|
|
||||||
time.Sleep(s.sleep)
|
|
||||||
x = make([]int64, 5)
|
|
||||||
_ = x
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Helper which checks the state of the test and ensures that it matches
|
|
||||||
// the given expectations. Depends on c.Errorf() working, so shouldn't
|
|
||||||
// be used to test this one function.
|
|
||||||
|
|
||||||
type expectedState struct {
|
|
||||||
name string
|
|
||||||
result interface{}
|
|
||||||
failed bool
|
|
||||||
log string
|
|
||||||
}
|
|
||||||
|
|
||||||
// Verify the state of the test. Note that since this also verifies if
|
|
||||||
// the test is supposed to be in a failed state, no other checks should
|
|
||||||
// be done in addition to what is being tested.
|
|
||||||
func checkState(c *check.C, result interface{}, expected *expectedState) {
|
|
||||||
failed := c.Failed()
|
|
||||||
c.Succeed()
|
|
||||||
log := c.GetTestLog()
|
|
||||||
matched, matchError := regexp.MatchString("^"+expected.log+"$", log)
|
|
||||||
if matchError != nil {
|
|
||||||
c.Errorf("Error in matching expression used in testing %s",
|
|
||||||
expected.name)
|
|
||||||
} else if !matched {
|
|
||||||
c.Errorf("%s logged:\n----------\n%s----------\n\nExpected:\n----------\n%s\n----------",
|
|
||||||
expected.name, log, expected.log)
|
|
||||||
}
|
|
||||||
if result != expected.result {
|
|
||||||
c.Errorf("%s returned %#v rather than %#v",
|
|
||||||
expected.name, result, expected.result)
|
|
||||||
}
|
|
||||||
if failed != expected.failed {
|
|
||||||
if failed {
|
|
||||||
c.Errorf("%s has failed when it shouldn't", expected.name)
|
|
||||||
} else {
|
|
||||||
c.Errorf("%s has not failed when it should", expected.name)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
458
vendor/gopkg.in/check.v1/checkers.go
generated
vendored
458
vendor/gopkg.in/check.v1/checkers.go
generated
vendored
@ -1,458 +0,0 @@
|
|||||||
package check
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"reflect"
|
|
||||||
"regexp"
|
|
||||||
)
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// CommentInterface and Commentf helper, to attach extra information to checks.
|
|
||||||
|
|
||||||
type comment struct {
|
|
||||||
format string
|
|
||||||
args []interface{}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Commentf returns an infomational value to use with Assert or Check calls.
|
|
||||||
// If the checker test fails, the provided arguments will be passed to
|
|
||||||
// fmt.Sprintf, and will be presented next to the logged failure.
|
|
||||||
//
|
|
||||||
// For example:
|
|
||||||
//
|
|
||||||
// c.Assert(v, Equals, 42, Commentf("Iteration #%d failed.", i))
|
|
||||||
//
|
|
||||||
// Note that if the comment is constant, a better option is to
|
|
||||||
// simply use a normal comment right above or next to the line, as
|
|
||||||
// it will also get printed with any errors:
|
|
||||||
//
|
|
||||||
// c.Assert(l, Equals, 8192) // Ensure buffer size is correct (bug #123)
|
|
||||||
//
|
|
||||||
func Commentf(format string, args ...interface{}) CommentInterface {
|
|
||||||
return &comment{format, args}
|
|
||||||
}
|
|
||||||
|
|
||||||
// CommentInterface must be implemented by types that attach extra
|
|
||||||
// information to failed checks. See the Commentf function for details.
|
|
||||||
type CommentInterface interface {
|
|
||||||
CheckCommentString() string
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *comment) CheckCommentString() string {
|
|
||||||
return fmt.Sprintf(c.format, c.args...)
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// The Checker interface.
|
|
||||||
|
|
||||||
// The Checker interface must be provided by checkers used with
|
|
||||||
// the Assert and Check verification methods.
|
|
||||||
type Checker interface {
|
|
||||||
Info() *CheckerInfo
|
|
||||||
Check(params []interface{}, names []string) (result bool, error string)
|
|
||||||
}
|
|
||||||
|
|
||||||
// See the Checker interface.
|
|
||||||
type CheckerInfo struct {
|
|
||||||
Name string
|
|
||||||
Params []string
|
|
||||||
}
|
|
||||||
|
|
||||||
func (info *CheckerInfo) Info() *CheckerInfo {
|
|
||||||
return info
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Not checker logic inverter.
|
|
||||||
|
|
||||||
// The Not checker inverts the logic of the provided checker. The
|
|
||||||
// resulting checker will succeed where the original one failed, and
|
|
||||||
// vice-versa.
|
|
||||||
//
|
|
||||||
// For example:
|
|
||||||
//
|
|
||||||
// c.Assert(a, Not(Equals), b)
|
|
||||||
//
|
|
||||||
func Not(checker Checker) Checker {
|
|
||||||
return ¬Checker{checker}
|
|
||||||
}
|
|
||||||
|
|
||||||
type notChecker struct {
|
|
||||||
sub Checker
|
|
||||||
}
|
|
||||||
|
|
||||||
func (checker *notChecker) Info() *CheckerInfo {
|
|
||||||
info := *checker.sub.Info()
|
|
||||||
info.Name = "Not(" + info.Name + ")"
|
|
||||||
return &info
|
|
||||||
}
|
|
||||||
|
|
||||||
func (checker *notChecker) Check(params []interface{}, names []string) (result bool, error string) {
|
|
||||||
result, error = checker.sub.Check(params, names)
|
|
||||||
result = !result
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// IsNil checker.
|
|
||||||
|
|
||||||
type isNilChecker struct {
|
|
||||||
*CheckerInfo
|
|
||||||
}
|
|
||||||
|
|
||||||
// The IsNil checker tests whether the obtained value is nil.
|
|
||||||
//
|
|
||||||
// For example:
|
|
||||||
//
|
|
||||||
// c.Assert(err, IsNil)
|
|
||||||
//
|
|
||||||
var IsNil Checker = &isNilChecker{
|
|
||||||
&CheckerInfo{Name: "IsNil", Params: []string{"value"}},
|
|
||||||
}
|
|
||||||
|
|
||||||
func (checker *isNilChecker) Check(params []interface{}, names []string) (result bool, error string) {
|
|
||||||
return isNil(params[0]), ""
|
|
||||||
}
|
|
||||||
|
|
||||||
func isNil(obtained interface{}) (result bool) {
|
|
||||||
if obtained == nil {
|
|
||||||
result = true
|
|
||||||
} else {
|
|
||||||
switch v := reflect.ValueOf(obtained); v.Kind() {
|
|
||||||
case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
|
|
||||||
return v.IsNil()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// NotNil checker. Alias for Not(IsNil), since it's so common.
|
|
||||||
|
|
||||||
type notNilChecker struct {
|
|
||||||
*CheckerInfo
|
|
||||||
}
|
|
||||||
|
|
||||||
// The NotNil checker verifies that the obtained value is not nil.
|
|
||||||
//
|
|
||||||
// For example:
|
|
||||||
//
|
|
||||||
// c.Assert(iface, NotNil)
|
|
||||||
//
|
|
||||||
// This is an alias for Not(IsNil), made available since it's a
|
|
||||||
// fairly common check.
|
|
||||||
//
|
|
||||||
var NotNil Checker = ¬NilChecker{
|
|
||||||
&CheckerInfo{Name: "NotNil", Params: []string{"value"}},
|
|
||||||
}
|
|
||||||
|
|
||||||
func (checker *notNilChecker) Check(params []interface{}, names []string) (result bool, error string) {
|
|
||||||
return !isNil(params[0]), ""
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Equals checker.
|
|
||||||
|
|
||||||
type equalsChecker struct {
|
|
||||||
*CheckerInfo
|
|
||||||
}
|
|
||||||
|
|
||||||
// The Equals checker verifies that the obtained value is equal to
|
|
||||||
// the expected value, according to usual Go semantics for ==.
|
|
||||||
//
|
|
||||||
// For example:
|
|
||||||
//
|
|
||||||
// c.Assert(value, Equals, 42)
|
|
||||||
//
|
|
||||||
var Equals Checker = &equalsChecker{
|
|
||||||
&CheckerInfo{Name: "Equals", Params: []string{"obtained", "expected"}},
|
|
||||||
}
|
|
||||||
|
|
||||||
func (checker *equalsChecker) Check(params []interface{}, names []string) (result bool, error string) {
|
|
||||||
defer func() {
|
|
||||||
if v := recover(); v != nil {
|
|
||||||
result = false
|
|
||||||
error = fmt.Sprint(v)
|
|
||||||
}
|
|
||||||
}()
|
|
||||||
return params[0] == params[1], ""
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// DeepEquals checker.
|
|
||||||
|
|
||||||
type deepEqualsChecker struct {
|
|
||||||
*CheckerInfo
|
|
||||||
}
|
|
||||||
|
|
||||||
// The DeepEquals checker verifies that the obtained value is deep-equal to
|
|
||||||
// the expected value. The check will work correctly even when facing
|
|
||||||
// slices, interfaces, and values of different types (which always fail
|
|
||||||
// the test).
|
|
||||||
//
|
|
||||||
// For example:
|
|
||||||
//
|
|
||||||
// c.Assert(value, DeepEquals, 42)
|
|
||||||
// c.Assert(array, DeepEquals, []string{"hi", "there"})
|
|
||||||
//
|
|
||||||
var DeepEquals Checker = &deepEqualsChecker{
|
|
||||||
&CheckerInfo{Name: "DeepEquals", Params: []string{"obtained", "expected"}},
|
|
||||||
}
|
|
||||||
|
|
||||||
func (checker *deepEqualsChecker) Check(params []interface{}, names []string) (result bool, error string) {
|
|
||||||
return reflect.DeepEqual(params[0], params[1]), ""
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// HasLen checker.
|
|
||||||
|
|
||||||
type hasLenChecker struct {
|
|
||||||
*CheckerInfo
|
|
||||||
}
|
|
||||||
|
|
||||||
// The HasLen checker verifies that the obtained value has the
|
|
||||||
// provided length. In many cases this is superior to using Equals
|
|
||||||
// in conjunction with the len function because in case the check
|
|
||||||
// fails the value itself will be printed, instead of its length,
|
|
||||||
// providing more details for figuring the problem.
|
|
||||||
//
|
|
||||||
// For example:
|
|
||||||
//
|
|
||||||
// c.Assert(list, HasLen, 5)
|
|
||||||
//
|
|
||||||
var HasLen Checker = &hasLenChecker{
|
|
||||||
&CheckerInfo{Name: "HasLen", Params: []string{"obtained", "n"}},
|
|
||||||
}
|
|
||||||
|
|
||||||
func (checker *hasLenChecker) Check(params []interface{}, names []string) (result bool, error string) {
|
|
||||||
n, ok := params[1].(int)
|
|
||||||
if !ok {
|
|
||||||
return false, "n must be an int"
|
|
||||||
}
|
|
||||||
value := reflect.ValueOf(params[0])
|
|
||||||
switch value.Kind() {
|
|
||||||
case reflect.Map, reflect.Array, reflect.Slice, reflect.Chan, reflect.String:
|
|
||||||
default:
|
|
||||||
return false, "obtained value type has no length"
|
|
||||||
}
|
|
||||||
return value.Len() == n, ""
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// ErrorMatches checker.
|
|
||||||
|
|
||||||
type errorMatchesChecker struct {
|
|
||||||
*CheckerInfo
|
|
||||||
}
|
|
||||||
|
|
||||||
// The ErrorMatches checker verifies that the error value
|
|
||||||
// is non nil and matches the regular expression provided.
|
|
||||||
//
|
|
||||||
// For example:
|
|
||||||
//
|
|
||||||
// c.Assert(err, ErrorMatches, "perm.*denied")
|
|
||||||
//
|
|
||||||
var ErrorMatches Checker = errorMatchesChecker{
|
|
||||||
&CheckerInfo{Name: "ErrorMatches", Params: []string{"value", "regex"}},
|
|
||||||
}
|
|
||||||
|
|
||||||
func (checker errorMatchesChecker) Check(params []interface{}, names []string) (result bool, errStr string) {
|
|
||||||
if params[0] == nil {
|
|
||||||
return false, "Error value is nil"
|
|
||||||
}
|
|
||||||
err, ok := params[0].(error)
|
|
||||||
if !ok {
|
|
||||||
return false, "Value is not an error"
|
|
||||||
}
|
|
||||||
params[0] = err.Error()
|
|
||||||
names[0] = "error"
|
|
||||||
return matches(params[0], params[1])
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Matches checker.
|
|
||||||
|
|
||||||
type matchesChecker struct {
|
|
||||||
*CheckerInfo
|
|
||||||
}
|
|
||||||
|
|
||||||
// The Matches checker verifies that the string provided as the obtained
|
|
||||||
// value (or the string resulting from obtained.String()) matches the
|
|
||||||
// regular expression provided.
|
|
||||||
//
|
|
||||||
// For example:
|
|
||||||
//
|
|
||||||
// c.Assert(err, Matches, "perm.*denied")
|
|
||||||
//
|
|
||||||
var Matches Checker = &matchesChecker{
|
|
||||||
&CheckerInfo{Name: "Matches", Params: []string{"value", "regex"}},
|
|
||||||
}
|
|
||||||
|
|
||||||
func (checker *matchesChecker) Check(params []interface{}, names []string) (result bool, error string) {
|
|
||||||
return matches(params[0], params[1])
|
|
||||||
}
|
|
||||||
|
|
||||||
func matches(value, regex interface{}) (result bool, error string) {
|
|
||||||
reStr, ok := regex.(string)
|
|
||||||
if !ok {
|
|
||||||
return false, "Regex must be a string"
|
|
||||||
}
|
|
||||||
valueStr, valueIsStr := value.(string)
|
|
||||||
if !valueIsStr {
|
|
||||||
if valueWithStr, valueHasStr := value.(fmt.Stringer); valueHasStr {
|
|
||||||
valueStr, valueIsStr = valueWithStr.String(), true
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if valueIsStr {
|
|
||||||
matches, err := regexp.MatchString("^"+reStr+"$", valueStr)
|
|
||||||
if err != nil {
|
|
||||||
return false, "Can't compile regex: " + err.Error()
|
|
||||||
}
|
|
||||||
return matches, ""
|
|
||||||
}
|
|
||||||
return false, "Obtained value is not a string and has no .String()"
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Panics checker.
|
|
||||||
|
|
||||||
type panicsChecker struct {
|
|
||||||
*CheckerInfo
|
|
||||||
}
|
|
||||||
|
|
||||||
// The Panics checker verifies that calling the provided zero-argument
|
|
||||||
// function will cause a panic which is deep-equal to the provided value.
|
|
||||||
//
|
|
||||||
// For example:
|
|
||||||
//
|
|
||||||
// c.Assert(func() { f(1, 2) }, Panics, &SomeErrorType{"BOOM"}).
|
|
||||||
//
|
|
||||||
//
|
|
||||||
var Panics Checker = &panicsChecker{
|
|
||||||
&CheckerInfo{Name: "Panics", Params: []string{"function", "expected"}},
|
|
||||||
}
|
|
||||||
|
|
||||||
func (checker *panicsChecker) Check(params []interface{}, names []string) (result bool, error string) {
|
|
||||||
f := reflect.ValueOf(params[0])
|
|
||||||
if f.Kind() != reflect.Func || f.Type().NumIn() != 0 {
|
|
||||||
return false, "Function must take zero arguments"
|
|
||||||
}
|
|
||||||
defer func() {
|
|
||||||
// If the function has not panicked, then don't do the check.
|
|
||||||
if error != "" {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
params[0] = recover()
|
|
||||||
names[0] = "panic"
|
|
||||||
result = reflect.DeepEqual(params[0], params[1])
|
|
||||||
}()
|
|
||||||
f.Call(nil)
|
|
||||||
return false, "Function has not panicked"
|
|
||||||
}
|
|
||||||
|
|
||||||
type panicMatchesChecker struct {
|
|
||||||
*CheckerInfo
|
|
||||||
}
|
|
||||||
|
|
||||||
// The PanicMatches checker verifies that calling the provided zero-argument
|
|
||||||
// function will cause a panic with an error value matching
|
|
||||||
// the regular expression provided.
|
|
||||||
//
|
|
||||||
// For example:
|
|
||||||
//
|
|
||||||
// c.Assert(func() { f(1, 2) }, PanicMatches, `open.*: no such file or directory`).
|
|
||||||
//
|
|
||||||
//
|
|
||||||
var PanicMatches Checker = &panicMatchesChecker{
|
|
||||||
&CheckerInfo{Name: "PanicMatches", Params: []string{"function", "expected"}},
|
|
||||||
}
|
|
||||||
|
|
||||||
func (checker *panicMatchesChecker) Check(params []interface{}, names []string) (result bool, errmsg string) {
|
|
||||||
f := reflect.ValueOf(params[0])
|
|
||||||
if f.Kind() != reflect.Func || f.Type().NumIn() != 0 {
|
|
||||||
return false, "Function must take zero arguments"
|
|
||||||
}
|
|
||||||
defer func() {
|
|
||||||
// If the function has not panicked, then don't do the check.
|
|
||||||
if errmsg != "" {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
obtained := recover()
|
|
||||||
names[0] = "panic"
|
|
||||||
if e, ok := obtained.(error); ok {
|
|
||||||
params[0] = e.Error()
|
|
||||||
} else if _, ok := obtained.(string); ok {
|
|
||||||
params[0] = obtained
|
|
||||||
} else {
|
|
||||||
errmsg = "Panic value is not a string or an error"
|
|
||||||
return
|
|
||||||
}
|
|
||||||
result, errmsg = matches(params[0], params[1])
|
|
||||||
}()
|
|
||||||
f.Call(nil)
|
|
||||||
return false, "Function has not panicked"
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// FitsTypeOf checker.
|
|
||||||
|
|
||||||
type fitsTypeChecker struct {
|
|
||||||
*CheckerInfo
|
|
||||||
}
|
|
||||||
|
|
||||||
// The FitsTypeOf checker verifies that the obtained value is
|
|
||||||
// assignable to a variable with the same type as the provided
|
|
||||||
// sample value.
|
|
||||||
//
|
|
||||||
// For example:
|
|
||||||
//
|
|
||||||
// c.Assert(value, FitsTypeOf, int64(0))
|
|
||||||
// c.Assert(value, FitsTypeOf, os.Error(nil))
|
|
||||||
//
|
|
||||||
var FitsTypeOf Checker = &fitsTypeChecker{
|
|
||||||
&CheckerInfo{Name: "FitsTypeOf", Params: []string{"obtained", "sample"}},
|
|
||||||
}
|
|
||||||
|
|
||||||
func (checker *fitsTypeChecker) Check(params []interface{}, names []string) (result bool, error string) {
|
|
||||||
obtained := reflect.ValueOf(params[0])
|
|
||||||
sample := reflect.ValueOf(params[1])
|
|
||||||
if !obtained.IsValid() {
|
|
||||||
return false, ""
|
|
||||||
}
|
|
||||||
if !sample.IsValid() {
|
|
||||||
return false, "Invalid sample value"
|
|
||||||
}
|
|
||||||
return obtained.Type().AssignableTo(sample.Type()), ""
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Implements checker.
|
|
||||||
|
|
||||||
type implementsChecker struct {
|
|
||||||
*CheckerInfo
|
|
||||||
}
|
|
||||||
|
|
||||||
// The Implements checker verifies that the obtained value
|
|
||||||
// implements the interface specified via a pointer to an interface
|
|
||||||
// variable.
|
|
||||||
//
|
|
||||||
// For example:
|
|
||||||
//
|
|
||||||
// var e os.Error
|
|
||||||
// c.Assert(err, Implements, &e)
|
|
||||||
//
|
|
||||||
var Implements Checker = &implementsChecker{
|
|
||||||
&CheckerInfo{Name: "Implements", Params: []string{"obtained", "ifaceptr"}},
|
|
||||||
}
|
|
||||||
|
|
||||||
func (checker *implementsChecker) Check(params []interface{}, names []string) (result bool, error string) {
|
|
||||||
obtained := reflect.ValueOf(params[0])
|
|
||||||
ifaceptr := reflect.ValueOf(params[1])
|
|
||||||
if !obtained.IsValid() {
|
|
||||||
return false, ""
|
|
||||||
}
|
|
||||||
if !ifaceptr.IsValid() || ifaceptr.Kind() != reflect.Ptr || ifaceptr.Elem().Kind() != reflect.Interface {
|
|
||||||
return false, "ifaceptr should be a pointer to an interface variable"
|
|
||||||
}
|
|
||||||
return obtained.Type().Implements(ifaceptr.Elem().Type()), ""
|
|
||||||
}
|
|
272
vendor/gopkg.in/check.v1/checkers_test.go
generated
vendored
272
vendor/gopkg.in/check.v1/checkers_test.go
generated
vendored
@ -1,272 +0,0 @@
|
|||||||
package check_test
|
|
||||||
|
|
||||||
import (
|
|
||||||
"errors"
|
|
||||||
"gopkg.in/check.v1"
|
|
||||||
"reflect"
|
|
||||||
"runtime"
|
|
||||||
)
|
|
||||||
|
|
||||||
type CheckersS struct{}
|
|
||||||
|
|
||||||
var _ = check.Suite(&CheckersS{})
|
|
||||||
|
|
||||||
func testInfo(c *check.C, checker check.Checker, name string, paramNames []string) {
|
|
||||||
info := checker.Info()
|
|
||||||
if info.Name != name {
|
|
||||||
c.Fatalf("Got name %s, expected %s", info.Name, name)
|
|
||||||
}
|
|
||||||
if !reflect.DeepEqual(info.Params, paramNames) {
|
|
||||||
c.Fatalf("Got param names %#v, expected %#v", info.Params, paramNames)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func testCheck(c *check.C, checker check.Checker, result bool, error string, params ...interface{}) ([]interface{}, []string) {
|
|
||||||
info := checker.Info()
|
|
||||||
if len(params) != len(info.Params) {
|
|
||||||
c.Fatalf("unexpected param count in test; expected %d got %d", len(info.Params), len(params))
|
|
||||||
}
|
|
||||||
names := append([]string{}, info.Params...)
|
|
||||||
result_, error_ := checker.Check(params, names)
|
|
||||||
if result_ != result || error_ != error {
|
|
||||||
c.Fatalf("%s.Check(%#v) returned (%#v, %#v) rather than (%#v, %#v)",
|
|
||||||
info.Name, params, result_, error_, result, error)
|
|
||||||
}
|
|
||||||
return params, names
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *CheckersS) TestComment(c *check.C) {
|
|
||||||
bug := check.Commentf("a %d bc", 42)
|
|
||||||
comment := bug.CheckCommentString()
|
|
||||||
if comment != "a 42 bc" {
|
|
||||||
c.Fatalf("Commentf returned %#v", comment)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *CheckersS) TestIsNil(c *check.C) {
|
|
||||||
testInfo(c, check.IsNil, "IsNil", []string{"value"})
|
|
||||||
|
|
||||||
testCheck(c, check.IsNil, true, "", nil)
|
|
||||||
testCheck(c, check.IsNil, false, "", "a")
|
|
||||||
|
|
||||||
testCheck(c, check.IsNil, true, "", (chan int)(nil))
|
|
||||||
testCheck(c, check.IsNil, false, "", make(chan int))
|
|
||||||
testCheck(c, check.IsNil, true, "", (error)(nil))
|
|
||||||
testCheck(c, check.IsNil, false, "", errors.New(""))
|
|
||||||
testCheck(c, check.IsNil, true, "", ([]int)(nil))
|
|
||||||
testCheck(c, check.IsNil, false, "", make([]int, 1))
|
|
||||||
testCheck(c, check.IsNil, false, "", int(0))
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *CheckersS) TestNotNil(c *check.C) {
|
|
||||||
testInfo(c, check.NotNil, "NotNil", []string{"value"})
|
|
||||||
|
|
||||||
testCheck(c, check.NotNil, false, "", nil)
|
|
||||||
testCheck(c, check.NotNil, true, "", "a")
|
|
||||||
|
|
||||||
testCheck(c, check.NotNil, false, "", (chan int)(nil))
|
|
||||||
testCheck(c, check.NotNil, true, "", make(chan int))
|
|
||||||
testCheck(c, check.NotNil, false, "", (error)(nil))
|
|
||||||
testCheck(c, check.NotNil, true, "", errors.New(""))
|
|
||||||
testCheck(c, check.NotNil, false, "", ([]int)(nil))
|
|
||||||
testCheck(c, check.NotNil, true, "", make([]int, 1))
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *CheckersS) TestNot(c *check.C) {
|
|
||||||
testInfo(c, check.Not(check.IsNil), "Not(IsNil)", []string{"value"})
|
|
||||||
|
|
||||||
testCheck(c, check.Not(check.IsNil), false, "", nil)
|
|
||||||
testCheck(c, check.Not(check.IsNil), true, "", "a")
|
|
||||||
}
|
|
||||||
|
|
||||||
type simpleStruct struct {
|
|
||||||
i int
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *CheckersS) TestEquals(c *check.C) {
|
|
||||||
testInfo(c, check.Equals, "Equals", []string{"obtained", "expected"})
|
|
||||||
|
|
||||||
// The simplest.
|
|
||||||
testCheck(c, check.Equals, true, "", 42, 42)
|
|
||||||
testCheck(c, check.Equals, false, "", 42, 43)
|
|
||||||
|
|
||||||
// Different native types.
|
|
||||||
testCheck(c, check.Equals, false, "", int32(42), int64(42))
|
|
||||||
|
|
||||||
// With nil.
|
|
||||||
testCheck(c, check.Equals, false, "", 42, nil)
|
|
||||||
|
|
||||||
// Slices
|
|
||||||
testCheck(c, check.Equals, false, "runtime error: comparing uncomparable type []uint8", []byte{1, 2}, []byte{1, 2})
|
|
||||||
|
|
||||||
// Struct values
|
|
||||||
testCheck(c, check.Equals, true, "", simpleStruct{1}, simpleStruct{1})
|
|
||||||
testCheck(c, check.Equals, false, "", simpleStruct{1}, simpleStruct{2})
|
|
||||||
|
|
||||||
// Struct pointers
|
|
||||||
testCheck(c, check.Equals, false, "", &simpleStruct{1}, &simpleStruct{1})
|
|
||||||
testCheck(c, check.Equals, false, "", &simpleStruct{1}, &simpleStruct{2})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *CheckersS) TestDeepEquals(c *check.C) {
|
|
||||||
testInfo(c, check.DeepEquals, "DeepEquals", []string{"obtained", "expected"})
|
|
||||||
|
|
||||||
// The simplest.
|
|
||||||
testCheck(c, check.DeepEquals, true, "", 42, 42)
|
|
||||||
testCheck(c, check.DeepEquals, false, "", 42, 43)
|
|
||||||
|
|
||||||
// Different native types.
|
|
||||||
testCheck(c, check.DeepEquals, false, "", int32(42), int64(42))
|
|
||||||
|
|
||||||
// With nil.
|
|
||||||
testCheck(c, check.DeepEquals, false, "", 42, nil)
|
|
||||||
|
|
||||||
// Slices
|
|
||||||
testCheck(c, check.DeepEquals, true, "", []byte{1, 2}, []byte{1, 2})
|
|
||||||
testCheck(c, check.DeepEquals, false, "", []byte{1, 2}, []byte{1, 3})
|
|
||||||
|
|
||||||
// Struct values
|
|
||||||
testCheck(c, check.DeepEquals, true, "", simpleStruct{1}, simpleStruct{1})
|
|
||||||
testCheck(c, check.DeepEquals, false, "", simpleStruct{1}, simpleStruct{2})
|
|
||||||
|
|
||||||
// Struct pointers
|
|
||||||
testCheck(c, check.DeepEquals, true, "", &simpleStruct{1}, &simpleStruct{1})
|
|
||||||
testCheck(c, check.DeepEquals, false, "", &simpleStruct{1}, &simpleStruct{2})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *CheckersS) TestHasLen(c *check.C) {
|
|
||||||
testInfo(c, check.HasLen, "HasLen", []string{"obtained", "n"})
|
|
||||||
|
|
||||||
testCheck(c, check.HasLen, true, "", "abcd", 4)
|
|
||||||
testCheck(c, check.HasLen, true, "", []int{1, 2}, 2)
|
|
||||||
testCheck(c, check.HasLen, false, "", []int{1, 2}, 3)
|
|
||||||
|
|
||||||
testCheck(c, check.HasLen, false, "n must be an int", []int{1, 2}, "2")
|
|
||||||
testCheck(c, check.HasLen, false, "obtained value type has no length", nil, 2)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *CheckersS) TestErrorMatches(c *check.C) {
|
|
||||||
testInfo(c, check.ErrorMatches, "ErrorMatches", []string{"value", "regex"})
|
|
||||||
|
|
||||||
testCheck(c, check.ErrorMatches, false, "Error value is nil", nil, "some error")
|
|
||||||
testCheck(c, check.ErrorMatches, false, "Value is not an error", 1, "some error")
|
|
||||||
testCheck(c, check.ErrorMatches, true, "", errors.New("some error"), "some error")
|
|
||||||
testCheck(c, check.ErrorMatches, true, "", errors.New("some error"), "so.*or")
|
|
||||||
|
|
||||||
// Verify params mutation
|
|
||||||
params, names := testCheck(c, check.ErrorMatches, false, "", errors.New("some error"), "other error")
|
|
||||||
c.Assert(params[0], check.Equals, "some error")
|
|
||||||
c.Assert(names[0], check.Equals, "error")
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *CheckersS) TestMatches(c *check.C) {
|
|
||||||
testInfo(c, check.Matches, "Matches", []string{"value", "regex"})
|
|
||||||
|
|
||||||
// Simple matching
|
|
||||||
testCheck(c, check.Matches, true, "", "abc", "abc")
|
|
||||||
testCheck(c, check.Matches, true, "", "abc", "a.c")
|
|
||||||
|
|
||||||
// Must match fully
|
|
||||||
testCheck(c, check.Matches, false, "", "abc", "ab")
|
|
||||||
testCheck(c, check.Matches, false, "", "abc", "bc")
|
|
||||||
|
|
||||||
// String()-enabled values accepted
|
|
||||||
testCheck(c, check.Matches, true, "", reflect.ValueOf("abc"), "a.c")
|
|
||||||
testCheck(c, check.Matches, false, "", reflect.ValueOf("abc"), "a.d")
|
|
||||||
|
|
||||||
// Some error conditions.
|
|
||||||
testCheck(c, check.Matches, false, "Obtained value is not a string and has no .String()", 1, "a.c")
|
|
||||||
testCheck(c, check.Matches, false, "Can't compile regex: error parsing regexp: missing closing ]: `[c$`", "abc", "a[c")
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *CheckersS) TestPanics(c *check.C) {
|
|
||||||
testInfo(c, check.Panics, "Panics", []string{"function", "expected"})
|
|
||||||
|
|
||||||
// Some errors.
|
|
||||||
testCheck(c, check.Panics, false, "Function has not panicked", func() bool { return false }, "BOOM")
|
|
||||||
testCheck(c, check.Panics, false, "Function must take zero arguments", 1, "BOOM")
|
|
||||||
|
|
||||||
// Plain strings.
|
|
||||||
testCheck(c, check.Panics, true, "", func() { panic("BOOM") }, "BOOM")
|
|
||||||
testCheck(c, check.Panics, false, "", func() { panic("KABOOM") }, "BOOM")
|
|
||||||
testCheck(c, check.Panics, true, "", func() bool { panic("BOOM") }, "BOOM")
|
|
||||||
|
|
||||||
// Error values.
|
|
||||||
testCheck(c, check.Panics, true, "", func() { panic(errors.New("BOOM")) }, errors.New("BOOM"))
|
|
||||||
testCheck(c, check.Panics, false, "", func() { panic(errors.New("KABOOM")) }, errors.New("BOOM"))
|
|
||||||
|
|
||||||
type deep struct{ i int }
|
|
||||||
// Deep value
|
|
||||||
testCheck(c, check.Panics, true, "", func() { panic(&deep{99}) }, &deep{99})
|
|
||||||
|
|
||||||
// Verify params/names mutation
|
|
||||||
params, names := testCheck(c, check.Panics, false, "", func() { panic(errors.New("KABOOM")) }, errors.New("BOOM"))
|
|
||||||
c.Assert(params[0], check.ErrorMatches, "KABOOM")
|
|
||||||
c.Assert(names[0], check.Equals, "panic")
|
|
||||||
|
|
||||||
// Verify a nil panic
|
|
||||||
testCheck(c, check.Panics, true, "", func() { panic(nil) }, nil)
|
|
||||||
testCheck(c, check.Panics, false, "", func() { panic(nil) }, "NOPE")
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *CheckersS) TestPanicMatches(c *check.C) {
|
|
||||||
testInfo(c, check.PanicMatches, "PanicMatches", []string{"function", "expected"})
|
|
||||||
|
|
||||||
// Error matching.
|
|
||||||
testCheck(c, check.PanicMatches, true, "", func() { panic(errors.New("BOOM")) }, "BO.M")
|
|
||||||
testCheck(c, check.PanicMatches, false, "", func() { panic(errors.New("KABOOM")) }, "BO.M")
|
|
||||||
|
|
||||||
// Some errors.
|
|
||||||
testCheck(c, check.PanicMatches, false, "Function has not panicked", func() bool { return false }, "BOOM")
|
|
||||||
testCheck(c, check.PanicMatches, false, "Function must take zero arguments", 1, "BOOM")
|
|
||||||
|
|
||||||
// Plain strings.
|
|
||||||
testCheck(c, check.PanicMatches, true, "", func() { panic("BOOM") }, "BO.M")
|
|
||||||
testCheck(c, check.PanicMatches, false, "", func() { panic("KABOOM") }, "BOOM")
|
|
||||||
testCheck(c, check.PanicMatches, true, "", func() bool { panic("BOOM") }, "BO.M")
|
|
||||||
|
|
||||||
// Verify params/names mutation
|
|
||||||
params, names := testCheck(c, check.PanicMatches, false, "", func() { panic(errors.New("KABOOM")) }, "BOOM")
|
|
||||||
c.Assert(params[0], check.Equals, "KABOOM")
|
|
||||||
c.Assert(names[0], check.Equals, "panic")
|
|
||||||
|
|
||||||
// Verify a nil panic
|
|
||||||
testCheck(c, check.PanicMatches, false, "Panic value is not a string or an error", func() { panic(nil) }, "")
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *CheckersS) TestFitsTypeOf(c *check.C) {
|
|
||||||
testInfo(c, check.FitsTypeOf, "FitsTypeOf", []string{"obtained", "sample"})
|
|
||||||
|
|
||||||
// Basic types
|
|
||||||
testCheck(c, check.FitsTypeOf, true, "", 1, 0)
|
|
||||||
testCheck(c, check.FitsTypeOf, false, "", 1, int64(0))
|
|
||||||
|
|
||||||
// Aliases
|
|
||||||
testCheck(c, check.FitsTypeOf, false, "", 1, errors.New(""))
|
|
||||||
testCheck(c, check.FitsTypeOf, false, "", "error", errors.New(""))
|
|
||||||
testCheck(c, check.FitsTypeOf, true, "", errors.New("error"), errors.New(""))
|
|
||||||
|
|
||||||
// Structures
|
|
||||||
testCheck(c, check.FitsTypeOf, false, "", 1, simpleStruct{})
|
|
||||||
testCheck(c, check.FitsTypeOf, false, "", simpleStruct{42}, &simpleStruct{})
|
|
||||||
testCheck(c, check.FitsTypeOf, true, "", simpleStruct{42}, simpleStruct{})
|
|
||||||
testCheck(c, check.FitsTypeOf, true, "", &simpleStruct{42}, &simpleStruct{})
|
|
||||||
|
|
||||||
// Some bad values
|
|
||||||
testCheck(c, check.FitsTypeOf, false, "Invalid sample value", 1, interface{}(nil))
|
|
||||||
testCheck(c, check.FitsTypeOf, false, "", interface{}(nil), 0)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *CheckersS) TestImplements(c *check.C) {
|
|
||||||
testInfo(c, check.Implements, "Implements", []string{"obtained", "ifaceptr"})
|
|
||||||
|
|
||||||
var e error
|
|
||||||
var re runtime.Error
|
|
||||||
testCheck(c, check.Implements, true, "", errors.New(""), &e)
|
|
||||||
testCheck(c, check.Implements, false, "", errors.New(""), &re)
|
|
||||||
|
|
||||||
// Some bad values
|
|
||||||
testCheck(c, check.Implements, false, "ifaceptr should be a pointer to an interface variable", 0, errors.New(""))
|
|
||||||
testCheck(c, check.Implements, false, "ifaceptr should be a pointer to an interface variable", 0, interface{}(nil))
|
|
||||||
testCheck(c, check.Implements, false, "", interface{}(nil), &e)
|
|
||||||
}
|
|
19
vendor/gopkg.in/check.v1/export_test.go
generated
vendored
19
vendor/gopkg.in/check.v1/export_test.go
generated
vendored
@ -1,19 +0,0 @@
|
|||||||
package check
|
|
||||||
|
|
||||||
import "io"
|
|
||||||
|
|
||||||
func PrintLine(filename string, line int) (string, error) {
|
|
||||||
return printLine(filename, line)
|
|
||||||
}
|
|
||||||
|
|
||||||
func Indent(s, with string) string {
|
|
||||||
return indent(s, with)
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewOutputWriter(writer io.Writer, stream, verbose bool) *outputWriter {
|
|
||||||
return newOutputWriter(writer, stream, verbose)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *C) FakeSkip(reason string) {
|
|
||||||
c.reason = reason
|
|
||||||
}
|
|
484
vendor/gopkg.in/check.v1/fixture_test.go
generated
vendored
484
vendor/gopkg.in/check.v1/fixture_test.go
generated
vendored
@ -1,484 +0,0 @@
|
|||||||
// Tests for the behavior of the test fixture system.
|
|
||||||
|
|
||||||
package check_test
|
|
||||||
|
|
||||||
import (
|
|
||||||
. "gopkg.in/check.v1"
|
|
||||||
)
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Fixture test suite.
|
|
||||||
|
|
||||||
type FixtureS struct{}
|
|
||||||
|
|
||||||
var fixtureS = Suite(&FixtureS{})
|
|
||||||
|
|
||||||
func (s *FixtureS) TestCountSuite(c *C) {
|
|
||||||
suitesRun += 1
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Basic fixture ordering verification.
|
|
||||||
|
|
||||||
func (s *FixtureS) TestOrder(c *C) {
|
|
||||||
helper := FixtureHelper{}
|
|
||||||
Run(&helper, nil)
|
|
||||||
c.Check(helper.calls[0], Equals, "SetUpSuite")
|
|
||||||
c.Check(helper.calls[1], Equals, "SetUpTest")
|
|
||||||
c.Check(helper.calls[2], Equals, "Test1")
|
|
||||||
c.Check(helper.calls[3], Equals, "TearDownTest")
|
|
||||||
c.Check(helper.calls[4], Equals, "SetUpTest")
|
|
||||||
c.Check(helper.calls[5], Equals, "Test2")
|
|
||||||
c.Check(helper.calls[6], Equals, "TearDownTest")
|
|
||||||
c.Check(helper.calls[7], Equals, "TearDownSuite")
|
|
||||||
c.Check(len(helper.calls), Equals, 8)
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Check the behavior when panics occur within tests and fixtures.
|
|
||||||
|
|
||||||
func (s *FixtureS) TestPanicOnTest(c *C) {
|
|
||||||
helper := FixtureHelper{panicOn: "Test1"}
|
|
||||||
output := String{}
|
|
||||||
Run(&helper, &RunConf{Output: &output})
|
|
||||||
c.Check(helper.calls[0], Equals, "SetUpSuite")
|
|
||||||
c.Check(helper.calls[1], Equals, "SetUpTest")
|
|
||||||
c.Check(helper.calls[2], Equals, "Test1")
|
|
||||||
c.Check(helper.calls[3], Equals, "TearDownTest")
|
|
||||||
c.Check(helper.calls[4], Equals, "SetUpTest")
|
|
||||||
c.Check(helper.calls[5], Equals, "Test2")
|
|
||||||
c.Check(helper.calls[6], Equals, "TearDownTest")
|
|
||||||
c.Check(helper.calls[7], Equals, "TearDownSuite")
|
|
||||||
c.Check(len(helper.calls), Equals, 8)
|
|
||||||
|
|
||||||
expected := "^\n-+\n" +
|
|
||||||
"PANIC: check_test\\.go:[0-9]+: FixtureHelper.Test1\n\n" +
|
|
||||||
"\\.\\.\\. Panic: Test1 \\(PC=[xA-F0-9]+\\)\n\n" +
|
|
||||||
".+:[0-9]+\n" +
|
|
||||||
" in (go)?panic\n" +
|
|
||||||
".*check_test.go:[0-9]+\n" +
|
|
||||||
" in FixtureHelper.trace\n" +
|
|
||||||
".*check_test.go:[0-9]+\n" +
|
|
||||||
" in FixtureHelper.Test1\n" +
|
|
||||||
"(.|\n)*$"
|
|
||||||
|
|
||||||
c.Check(output.value, Matches, expected)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FixtureS) TestPanicOnSetUpTest(c *C) {
|
|
||||||
helper := FixtureHelper{panicOn: "SetUpTest"}
|
|
||||||
output := String{}
|
|
||||||
Run(&helper, &RunConf{Output: &output})
|
|
||||||
c.Check(helper.calls[0], Equals, "SetUpSuite")
|
|
||||||
c.Check(helper.calls[1], Equals, "SetUpTest")
|
|
||||||
c.Check(helper.calls[2], Equals, "TearDownTest")
|
|
||||||
c.Check(helper.calls[3], Equals, "TearDownSuite")
|
|
||||||
c.Check(len(helper.calls), Equals, 4)
|
|
||||||
|
|
||||||
expected := "^\n-+\n" +
|
|
||||||
"PANIC: check_test\\.go:[0-9]+: " +
|
|
||||||
"FixtureHelper\\.SetUpTest\n\n" +
|
|
||||||
"\\.\\.\\. Panic: SetUpTest \\(PC=[xA-F0-9]+\\)\n\n" +
|
|
||||||
".+:[0-9]+\n" +
|
|
||||||
" in (go)?panic\n" +
|
|
||||||
".*check_test.go:[0-9]+\n" +
|
|
||||||
" in FixtureHelper.trace\n" +
|
|
||||||
".*check_test.go:[0-9]+\n" +
|
|
||||||
" in FixtureHelper.SetUpTest\n" +
|
|
||||||
"(.|\n)*" +
|
|
||||||
"\n-+\n" +
|
|
||||||
"PANIC: check_test\\.go:[0-9]+: " +
|
|
||||||
"FixtureHelper\\.Test1\n\n" +
|
|
||||||
"\\.\\.\\. Panic: Fixture has panicked " +
|
|
||||||
"\\(see related PANIC\\)\n$"
|
|
||||||
|
|
||||||
c.Check(output.value, Matches, expected)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FixtureS) TestPanicOnTearDownTest(c *C) {
|
|
||||||
helper := FixtureHelper{panicOn: "TearDownTest"}
|
|
||||||
output := String{}
|
|
||||||
Run(&helper, &RunConf{Output: &output})
|
|
||||||
c.Check(helper.calls[0], Equals, "SetUpSuite")
|
|
||||||
c.Check(helper.calls[1], Equals, "SetUpTest")
|
|
||||||
c.Check(helper.calls[2], Equals, "Test1")
|
|
||||||
c.Check(helper.calls[3], Equals, "TearDownTest")
|
|
||||||
c.Check(helper.calls[4], Equals, "TearDownSuite")
|
|
||||||
c.Check(len(helper.calls), Equals, 5)
|
|
||||||
|
|
||||||
expected := "^\n-+\n" +
|
|
||||||
"PANIC: check_test\\.go:[0-9]+: " +
|
|
||||||
"FixtureHelper.TearDownTest\n\n" +
|
|
||||||
"\\.\\.\\. Panic: TearDownTest \\(PC=[xA-F0-9]+\\)\n\n" +
|
|
||||||
".+:[0-9]+\n" +
|
|
||||||
" in (go)?panic\n" +
|
|
||||||
".*check_test.go:[0-9]+\n" +
|
|
||||||
" in FixtureHelper.trace\n" +
|
|
||||||
".*check_test.go:[0-9]+\n" +
|
|
||||||
" in FixtureHelper.TearDownTest\n" +
|
|
||||||
"(.|\n)*" +
|
|
||||||
"\n-+\n" +
|
|
||||||
"PANIC: check_test\\.go:[0-9]+: " +
|
|
||||||
"FixtureHelper\\.Test1\n\n" +
|
|
||||||
"\\.\\.\\. Panic: Fixture has panicked " +
|
|
||||||
"\\(see related PANIC\\)\n$"
|
|
||||||
|
|
||||||
c.Check(output.value, Matches, expected)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FixtureS) TestPanicOnSetUpSuite(c *C) {
|
|
||||||
helper := FixtureHelper{panicOn: "SetUpSuite"}
|
|
||||||
output := String{}
|
|
||||||
Run(&helper, &RunConf{Output: &output})
|
|
||||||
c.Check(helper.calls[0], Equals, "SetUpSuite")
|
|
||||||
c.Check(helper.calls[1], Equals, "TearDownSuite")
|
|
||||||
c.Check(len(helper.calls), Equals, 2)
|
|
||||||
|
|
||||||
expected := "^\n-+\n" +
|
|
||||||
"PANIC: check_test\\.go:[0-9]+: " +
|
|
||||||
"FixtureHelper.SetUpSuite\n\n" +
|
|
||||||
"\\.\\.\\. Panic: SetUpSuite \\(PC=[xA-F0-9]+\\)\n\n" +
|
|
||||||
".+:[0-9]+\n" +
|
|
||||||
" in (go)?panic\n" +
|
|
||||||
".*check_test.go:[0-9]+\n" +
|
|
||||||
" in FixtureHelper.trace\n" +
|
|
||||||
".*check_test.go:[0-9]+\n" +
|
|
||||||
" in FixtureHelper.SetUpSuite\n" +
|
|
||||||
"(.|\n)*$"
|
|
||||||
|
|
||||||
c.Check(output.value, Matches, expected)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FixtureS) TestPanicOnTearDownSuite(c *C) {
|
|
||||||
helper := FixtureHelper{panicOn: "TearDownSuite"}
|
|
||||||
output := String{}
|
|
||||||
Run(&helper, &RunConf{Output: &output})
|
|
||||||
c.Check(helper.calls[0], Equals, "SetUpSuite")
|
|
||||||
c.Check(helper.calls[1], Equals, "SetUpTest")
|
|
||||||
c.Check(helper.calls[2], Equals, "Test1")
|
|
||||||
c.Check(helper.calls[3], Equals, "TearDownTest")
|
|
||||||
c.Check(helper.calls[4], Equals, "SetUpTest")
|
|
||||||
c.Check(helper.calls[5], Equals, "Test2")
|
|
||||||
c.Check(helper.calls[6], Equals, "TearDownTest")
|
|
||||||
c.Check(helper.calls[7], Equals, "TearDownSuite")
|
|
||||||
c.Check(len(helper.calls), Equals, 8)
|
|
||||||
|
|
||||||
expected := "^\n-+\n" +
|
|
||||||
"PANIC: check_test\\.go:[0-9]+: " +
|
|
||||||
"FixtureHelper.TearDownSuite\n\n" +
|
|
||||||
"\\.\\.\\. Panic: TearDownSuite \\(PC=[xA-F0-9]+\\)\n\n" +
|
|
||||||
".+:[0-9]+\n" +
|
|
||||||
" in (go)?panic\n" +
|
|
||||||
".*check_test.go:[0-9]+\n" +
|
|
||||||
" in FixtureHelper.trace\n" +
|
|
||||||
".*check_test.go:[0-9]+\n" +
|
|
||||||
" in FixtureHelper.TearDownSuite\n" +
|
|
||||||
"(.|\n)*$"
|
|
||||||
|
|
||||||
c.Check(output.value, Matches, expected)
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// A wrong argument on a test or fixture will produce a nice error.
|
|
||||||
|
|
||||||
func (s *FixtureS) TestPanicOnWrongTestArg(c *C) {
|
|
||||||
helper := WrongTestArgHelper{}
|
|
||||||
output := String{}
|
|
||||||
Run(&helper, &RunConf{Output: &output})
|
|
||||||
c.Check(helper.calls[0], Equals, "SetUpSuite")
|
|
||||||
c.Check(helper.calls[1], Equals, "SetUpTest")
|
|
||||||
c.Check(helper.calls[2], Equals, "TearDownTest")
|
|
||||||
c.Check(helper.calls[3], Equals, "SetUpTest")
|
|
||||||
c.Check(helper.calls[4], Equals, "Test2")
|
|
||||||
c.Check(helper.calls[5], Equals, "TearDownTest")
|
|
||||||
c.Check(helper.calls[6], Equals, "TearDownSuite")
|
|
||||||
c.Check(len(helper.calls), Equals, 7)
|
|
||||||
|
|
||||||
expected := "^\n-+\n" +
|
|
||||||
"PANIC: fixture_test\\.go:[0-9]+: " +
|
|
||||||
"WrongTestArgHelper\\.Test1\n\n" +
|
|
||||||
"\\.\\.\\. Panic: WrongTestArgHelper\\.Test1 argument " +
|
|
||||||
"should be \\*check\\.C\n"
|
|
||||||
|
|
||||||
c.Check(output.value, Matches, expected)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FixtureS) TestPanicOnWrongSetUpTestArg(c *C) {
|
|
||||||
helper := WrongSetUpTestArgHelper{}
|
|
||||||
output := String{}
|
|
||||||
Run(&helper, &RunConf{Output: &output})
|
|
||||||
c.Check(len(helper.calls), Equals, 0)
|
|
||||||
|
|
||||||
expected :=
|
|
||||||
"^\n-+\n" +
|
|
||||||
"PANIC: fixture_test\\.go:[0-9]+: " +
|
|
||||||
"WrongSetUpTestArgHelper\\.SetUpTest\n\n" +
|
|
||||||
"\\.\\.\\. Panic: WrongSetUpTestArgHelper\\.SetUpTest argument " +
|
|
||||||
"should be \\*check\\.C\n"
|
|
||||||
|
|
||||||
c.Check(output.value, Matches, expected)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FixtureS) TestPanicOnWrongSetUpSuiteArg(c *C) {
|
|
||||||
helper := WrongSetUpSuiteArgHelper{}
|
|
||||||
output := String{}
|
|
||||||
Run(&helper, &RunConf{Output: &output})
|
|
||||||
c.Check(len(helper.calls), Equals, 0)
|
|
||||||
|
|
||||||
expected :=
|
|
||||||
"^\n-+\n" +
|
|
||||||
"PANIC: fixture_test\\.go:[0-9]+: " +
|
|
||||||
"WrongSetUpSuiteArgHelper\\.SetUpSuite\n\n" +
|
|
||||||
"\\.\\.\\. Panic: WrongSetUpSuiteArgHelper\\.SetUpSuite argument " +
|
|
||||||
"should be \\*check\\.C\n"
|
|
||||||
|
|
||||||
c.Check(output.value, Matches, expected)
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Nice errors also when tests or fixture have wrong arg count.
|
|
||||||
|
|
||||||
func (s *FixtureS) TestPanicOnWrongTestArgCount(c *C) {
|
|
||||||
helper := WrongTestArgCountHelper{}
|
|
||||||
output := String{}
|
|
||||||
Run(&helper, &RunConf{Output: &output})
|
|
||||||
c.Check(helper.calls[0], Equals, "SetUpSuite")
|
|
||||||
c.Check(helper.calls[1], Equals, "SetUpTest")
|
|
||||||
c.Check(helper.calls[2], Equals, "TearDownTest")
|
|
||||||
c.Check(helper.calls[3], Equals, "SetUpTest")
|
|
||||||
c.Check(helper.calls[4], Equals, "Test2")
|
|
||||||
c.Check(helper.calls[5], Equals, "TearDownTest")
|
|
||||||
c.Check(helper.calls[6], Equals, "TearDownSuite")
|
|
||||||
c.Check(len(helper.calls), Equals, 7)
|
|
||||||
|
|
||||||
expected := "^\n-+\n" +
|
|
||||||
"PANIC: fixture_test\\.go:[0-9]+: " +
|
|
||||||
"WrongTestArgCountHelper\\.Test1\n\n" +
|
|
||||||
"\\.\\.\\. Panic: WrongTestArgCountHelper\\.Test1 argument " +
|
|
||||||
"should be \\*check\\.C\n"
|
|
||||||
|
|
||||||
c.Check(output.value, Matches, expected)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FixtureS) TestPanicOnWrongSetUpTestArgCount(c *C) {
|
|
||||||
helper := WrongSetUpTestArgCountHelper{}
|
|
||||||
output := String{}
|
|
||||||
Run(&helper, &RunConf{Output: &output})
|
|
||||||
c.Check(len(helper.calls), Equals, 0)
|
|
||||||
|
|
||||||
expected :=
|
|
||||||
"^\n-+\n" +
|
|
||||||
"PANIC: fixture_test\\.go:[0-9]+: " +
|
|
||||||
"WrongSetUpTestArgCountHelper\\.SetUpTest\n\n" +
|
|
||||||
"\\.\\.\\. Panic: WrongSetUpTestArgCountHelper\\.SetUpTest argument " +
|
|
||||||
"should be \\*check\\.C\n"
|
|
||||||
|
|
||||||
c.Check(output.value, Matches, expected)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FixtureS) TestPanicOnWrongSetUpSuiteArgCount(c *C) {
|
|
||||||
helper := WrongSetUpSuiteArgCountHelper{}
|
|
||||||
output := String{}
|
|
||||||
Run(&helper, &RunConf{Output: &output})
|
|
||||||
c.Check(len(helper.calls), Equals, 0)
|
|
||||||
|
|
||||||
expected :=
|
|
||||||
"^\n-+\n" +
|
|
||||||
"PANIC: fixture_test\\.go:[0-9]+: " +
|
|
||||||
"WrongSetUpSuiteArgCountHelper\\.SetUpSuite\n\n" +
|
|
||||||
"\\.\\.\\. Panic: WrongSetUpSuiteArgCountHelper" +
|
|
||||||
"\\.SetUpSuite argument should be \\*check\\.C\n"
|
|
||||||
|
|
||||||
c.Check(output.value, Matches, expected)
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Helper test suites with wrong function arguments.
|
|
||||||
|
|
||||||
type WrongTestArgHelper struct {
|
|
||||||
FixtureHelper
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *WrongTestArgHelper) Test1(t int) {
|
|
||||||
}
|
|
||||||
|
|
||||||
type WrongSetUpTestArgHelper struct {
|
|
||||||
FixtureHelper
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *WrongSetUpTestArgHelper) SetUpTest(t int) {
|
|
||||||
}
|
|
||||||
|
|
||||||
type WrongSetUpSuiteArgHelper struct {
|
|
||||||
FixtureHelper
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *WrongSetUpSuiteArgHelper) SetUpSuite(t int) {
|
|
||||||
}
|
|
||||||
|
|
||||||
type WrongTestArgCountHelper struct {
|
|
||||||
FixtureHelper
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *WrongTestArgCountHelper) Test1(c *C, i int) {
|
|
||||||
}
|
|
||||||
|
|
||||||
type WrongSetUpTestArgCountHelper struct {
|
|
||||||
FixtureHelper
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *WrongSetUpTestArgCountHelper) SetUpTest(c *C, i int) {
|
|
||||||
}
|
|
||||||
|
|
||||||
type WrongSetUpSuiteArgCountHelper struct {
|
|
||||||
FixtureHelper
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *WrongSetUpSuiteArgCountHelper) SetUpSuite(c *C, i int) {
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Ensure fixture doesn't run without tests.
|
|
||||||
|
|
||||||
type NoTestsHelper struct {
|
|
||||||
hasRun bool
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *NoTestsHelper) SetUpSuite(c *C) {
|
|
||||||
s.hasRun = true
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *NoTestsHelper) TearDownSuite(c *C) {
|
|
||||||
s.hasRun = true
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FixtureS) TestFixtureDoesntRunWithoutTests(c *C) {
|
|
||||||
helper := NoTestsHelper{}
|
|
||||||
output := String{}
|
|
||||||
Run(&helper, &RunConf{Output: &output})
|
|
||||||
c.Check(helper.hasRun, Equals, false)
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Verify that checks and assertions work correctly inside the fixture.
|
|
||||||
|
|
||||||
type FixtureCheckHelper struct {
|
|
||||||
fail string
|
|
||||||
completed bool
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FixtureCheckHelper) SetUpSuite(c *C) {
|
|
||||||
switch s.fail {
|
|
||||||
case "SetUpSuiteAssert":
|
|
||||||
c.Assert(false, Equals, true)
|
|
||||||
case "SetUpSuiteCheck":
|
|
||||||
c.Check(false, Equals, true)
|
|
||||||
}
|
|
||||||
s.completed = true
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FixtureCheckHelper) SetUpTest(c *C) {
|
|
||||||
switch s.fail {
|
|
||||||
case "SetUpTestAssert":
|
|
||||||
c.Assert(false, Equals, true)
|
|
||||||
case "SetUpTestCheck":
|
|
||||||
c.Check(false, Equals, true)
|
|
||||||
}
|
|
||||||
s.completed = true
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FixtureCheckHelper) Test(c *C) {
|
|
||||||
// Do nothing.
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FixtureS) TestSetUpSuiteCheck(c *C) {
|
|
||||||
helper := FixtureCheckHelper{fail: "SetUpSuiteCheck"}
|
|
||||||
output := String{}
|
|
||||||
Run(&helper, &RunConf{Output: &output})
|
|
||||||
c.Assert(output.value, Matches,
|
|
||||||
"\n---+\n"+
|
|
||||||
"FAIL: fixture_test\\.go:[0-9]+: "+
|
|
||||||
"FixtureCheckHelper\\.SetUpSuite\n\n"+
|
|
||||||
"fixture_test\\.go:[0-9]+:\n"+
|
|
||||||
" c\\.Check\\(false, Equals, true\\)\n"+
|
|
||||||
"\\.+ obtained bool = false\n"+
|
|
||||||
"\\.+ expected bool = true\n\n")
|
|
||||||
c.Assert(helper.completed, Equals, true)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FixtureS) TestSetUpSuiteAssert(c *C) {
|
|
||||||
helper := FixtureCheckHelper{fail: "SetUpSuiteAssert"}
|
|
||||||
output := String{}
|
|
||||||
Run(&helper, &RunConf{Output: &output})
|
|
||||||
c.Assert(output.value, Matches,
|
|
||||||
"\n---+\n"+
|
|
||||||
"FAIL: fixture_test\\.go:[0-9]+: "+
|
|
||||||
"FixtureCheckHelper\\.SetUpSuite\n\n"+
|
|
||||||
"fixture_test\\.go:[0-9]+:\n"+
|
|
||||||
" c\\.Assert\\(false, Equals, true\\)\n"+
|
|
||||||
"\\.+ obtained bool = false\n"+
|
|
||||||
"\\.+ expected bool = true\n\n")
|
|
||||||
c.Assert(helper.completed, Equals, false)
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Verify that logging within SetUpTest() persists within the test log itself.
|
|
||||||
|
|
||||||
type FixtureLogHelper struct {
|
|
||||||
c *C
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FixtureLogHelper) SetUpTest(c *C) {
|
|
||||||
s.c = c
|
|
||||||
c.Log("1")
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FixtureLogHelper) Test(c *C) {
|
|
||||||
c.Log("2")
|
|
||||||
s.c.Log("3")
|
|
||||||
c.Log("4")
|
|
||||||
c.Fail()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FixtureLogHelper) TearDownTest(c *C) {
|
|
||||||
s.c.Log("5")
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FixtureS) TestFixtureLogging(c *C) {
|
|
||||||
helper := FixtureLogHelper{}
|
|
||||||
output := String{}
|
|
||||||
Run(&helper, &RunConf{Output: &output})
|
|
||||||
c.Assert(output.value, Matches,
|
|
||||||
"\n---+\n"+
|
|
||||||
"FAIL: fixture_test\\.go:[0-9]+: "+
|
|
||||||
"FixtureLogHelper\\.Test\n\n"+
|
|
||||||
"1\n2\n3\n4\n5\n")
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Skip() within fixture methods.
|
|
||||||
|
|
||||||
func (s *FixtureS) TestSkipSuite(c *C) {
|
|
||||||
helper := FixtureHelper{skip: true, skipOnN: 0}
|
|
||||||
output := String{}
|
|
||||||
result := Run(&helper, &RunConf{Output: &output})
|
|
||||||
c.Assert(output.value, Equals, "")
|
|
||||||
c.Assert(helper.calls[0], Equals, "SetUpSuite")
|
|
||||||
c.Assert(helper.calls[1], Equals, "TearDownSuite")
|
|
||||||
c.Assert(len(helper.calls), Equals, 2)
|
|
||||||
c.Assert(result.Skipped, Equals, 2)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FixtureS) TestSkipTest(c *C) {
|
|
||||||
helper := FixtureHelper{skip: true, skipOnN: 1}
|
|
||||||
output := String{}
|
|
||||||
result := Run(&helper, &RunConf{Output: &output})
|
|
||||||
c.Assert(helper.calls[0], Equals, "SetUpSuite")
|
|
||||||
c.Assert(helper.calls[1], Equals, "SetUpTest")
|
|
||||||
c.Assert(helper.calls[2], Equals, "SetUpTest")
|
|
||||||
c.Assert(helper.calls[3], Equals, "Test2")
|
|
||||||
c.Assert(helper.calls[4], Equals, "TearDownTest")
|
|
||||||
c.Assert(helper.calls[5], Equals, "TearDownSuite")
|
|
||||||
c.Assert(len(helper.calls), Equals, 6)
|
|
||||||
c.Assert(result.Skipped, Equals, 1)
|
|
||||||
}
|
|
335
vendor/gopkg.in/check.v1/foundation_test.go
generated
vendored
335
vendor/gopkg.in/check.v1/foundation_test.go
generated
vendored
@ -1,335 +0,0 @@
|
|||||||
// These tests check that the foundations of gocheck are working properly.
|
|
||||||
// They already assume that fundamental failing is working already, though,
|
|
||||||
// since this was tested in bootstrap_test.go. Even then, some care may
|
|
||||||
// still have to be taken when using external functions, since they should
|
|
||||||
// of course not rely on functionality tested here.
|
|
||||||
|
|
||||||
package check_test
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"gopkg.in/check.v1"
|
|
||||||
"log"
|
|
||||||
"os"
|
|
||||||
"regexp"
|
|
||||||
"strings"
|
|
||||||
)
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Foundation test suite.
|
|
||||||
|
|
||||||
type FoundationS struct{}
|
|
||||||
|
|
||||||
var foundationS = check.Suite(&FoundationS{})
|
|
||||||
|
|
||||||
func (s *FoundationS) TestCountSuite(c *check.C) {
|
|
||||||
suitesRun += 1
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FoundationS) TestErrorf(c *check.C) {
|
|
||||||
// Do not use checkState() here. It depends on Errorf() working.
|
|
||||||
expectedLog := fmt.Sprintf("foundation_test.go:%d:\n"+
|
|
||||||
" c.Errorf(\"Error %%v!\", \"message\")\n"+
|
|
||||||
"... Error: Error message!\n\n",
|
|
||||||
getMyLine()+1)
|
|
||||||
c.Errorf("Error %v!", "message")
|
|
||||||
failed := c.Failed()
|
|
||||||
c.Succeed()
|
|
||||||
if log := c.GetTestLog(); log != expectedLog {
|
|
||||||
c.Logf("Errorf() logged %#v rather than %#v", log, expectedLog)
|
|
||||||
c.Fail()
|
|
||||||
}
|
|
||||||
if !failed {
|
|
||||||
c.Logf("Errorf() didn't put the test in a failed state")
|
|
||||||
c.Fail()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FoundationS) TestError(c *check.C) {
|
|
||||||
expectedLog := fmt.Sprintf("foundation_test.go:%d:\n"+
|
|
||||||
" c\\.Error\\(\"Error \", \"message!\"\\)\n"+
|
|
||||||
"\\.\\.\\. Error: Error message!\n\n",
|
|
||||||
getMyLine()+1)
|
|
||||||
c.Error("Error ", "message!")
|
|
||||||
checkState(c, nil,
|
|
||||||
&expectedState{
|
|
||||||
name: "Error(`Error `, `message!`)",
|
|
||||||
failed: true,
|
|
||||||
log: expectedLog,
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FoundationS) TestFailNow(c *check.C) {
|
|
||||||
defer (func() {
|
|
||||||
if !c.Failed() {
|
|
||||||
c.Error("FailNow() didn't fail the test")
|
|
||||||
} else {
|
|
||||||
c.Succeed()
|
|
||||||
if c.GetTestLog() != "" {
|
|
||||||
c.Error("Something got logged:\n" + c.GetTestLog())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
})()
|
|
||||||
|
|
||||||
c.FailNow()
|
|
||||||
c.Log("FailNow() didn't stop the test")
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FoundationS) TestSucceedNow(c *check.C) {
|
|
||||||
defer (func() {
|
|
||||||
if c.Failed() {
|
|
||||||
c.Error("SucceedNow() didn't succeed the test")
|
|
||||||
}
|
|
||||||
if c.GetTestLog() != "" {
|
|
||||||
c.Error("Something got logged:\n" + c.GetTestLog())
|
|
||||||
}
|
|
||||||
})()
|
|
||||||
|
|
||||||
c.Fail()
|
|
||||||
c.SucceedNow()
|
|
||||||
c.Log("SucceedNow() didn't stop the test")
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FoundationS) TestFailureHeader(c *check.C) {
|
|
||||||
output := String{}
|
|
||||||
failHelper := FailHelper{}
|
|
||||||
check.Run(&failHelper, &check.RunConf{Output: &output})
|
|
||||||
header := fmt.Sprintf(""+
|
|
||||||
"\n-----------------------------------"+
|
|
||||||
"-----------------------------------\n"+
|
|
||||||
"FAIL: check_test.go:%d: FailHelper.TestLogAndFail\n",
|
|
||||||
failHelper.testLine)
|
|
||||||
if strings.Index(output.value, header) == -1 {
|
|
||||||
c.Errorf(""+
|
|
||||||
"Failure didn't print a proper header.\n"+
|
|
||||||
"... Got:\n%s... Expected something with:\n%s",
|
|
||||||
output.value, header)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FoundationS) TestFatal(c *check.C) {
|
|
||||||
var line int
|
|
||||||
defer (func() {
|
|
||||||
if !c.Failed() {
|
|
||||||
c.Error("Fatal() didn't fail the test")
|
|
||||||
} else {
|
|
||||||
c.Succeed()
|
|
||||||
expected := fmt.Sprintf("foundation_test.go:%d:\n"+
|
|
||||||
" c.Fatal(\"Die \", \"now!\")\n"+
|
|
||||||
"... Error: Die now!\n\n",
|
|
||||||
line)
|
|
||||||
if c.GetTestLog() != expected {
|
|
||||||
c.Error("Incorrect log:", c.GetTestLog())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
})()
|
|
||||||
|
|
||||||
line = getMyLine() + 1
|
|
||||||
c.Fatal("Die ", "now!")
|
|
||||||
c.Log("Fatal() didn't stop the test")
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FoundationS) TestFatalf(c *check.C) {
|
|
||||||
var line int
|
|
||||||
defer (func() {
|
|
||||||
if !c.Failed() {
|
|
||||||
c.Error("Fatalf() didn't fail the test")
|
|
||||||
} else {
|
|
||||||
c.Succeed()
|
|
||||||
expected := fmt.Sprintf("foundation_test.go:%d:\n"+
|
|
||||||
" c.Fatalf(\"Die %%s!\", \"now\")\n"+
|
|
||||||
"... Error: Die now!\n\n",
|
|
||||||
line)
|
|
||||||
if c.GetTestLog() != expected {
|
|
||||||
c.Error("Incorrect log:", c.GetTestLog())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
})()
|
|
||||||
|
|
||||||
line = getMyLine() + 1
|
|
||||||
c.Fatalf("Die %s!", "now")
|
|
||||||
c.Log("Fatalf() didn't stop the test")
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FoundationS) TestCallerLoggingInsideTest(c *check.C) {
|
|
||||||
log := fmt.Sprintf(""+
|
|
||||||
"foundation_test.go:%d:\n"+
|
|
||||||
" result := c.Check\\(10, check.Equals, 20\\)\n"+
|
|
||||||
"\\.\\.\\. obtained int = 10\n"+
|
|
||||||
"\\.\\.\\. expected int = 20\n\n",
|
|
||||||
getMyLine()+1)
|
|
||||||
result := c.Check(10, check.Equals, 20)
|
|
||||||
checkState(c, result,
|
|
||||||
&expectedState{
|
|
||||||
name: "Check(10, Equals, 20)",
|
|
||||||
result: false,
|
|
||||||
failed: true,
|
|
||||||
log: log,
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FoundationS) TestCallerLoggingInDifferentFile(c *check.C) {
|
|
||||||
result, line := checkEqualWrapper(c, 10, 20)
|
|
||||||
testLine := getMyLine() - 1
|
|
||||||
log := fmt.Sprintf(""+
|
|
||||||
"foundation_test.go:%d:\n"+
|
|
||||||
" result, line := checkEqualWrapper\\(c, 10, 20\\)\n"+
|
|
||||||
"check_test.go:%d:\n"+
|
|
||||||
" return c.Check\\(obtained, check.Equals, expected\\), getMyLine\\(\\)\n"+
|
|
||||||
"\\.\\.\\. obtained int = 10\n"+
|
|
||||||
"\\.\\.\\. expected int = 20\n\n",
|
|
||||||
testLine, line)
|
|
||||||
checkState(c, result,
|
|
||||||
&expectedState{
|
|
||||||
name: "Check(10, Equals, 20)",
|
|
||||||
result: false,
|
|
||||||
failed: true,
|
|
||||||
log: log,
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// ExpectFailure() inverts the logic of failure.
|
|
||||||
|
|
||||||
type ExpectFailureSucceedHelper struct{}
|
|
||||||
|
|
||||||
func (s *ExpectFailureSucceedHelper) TestSucceed(c *check.C) {
|
|
||||||
c.ExpectFailure("It booms!")
|
|
||||||
c.Error("Boom!")
|
|
||||||
}
|
|
||||||
|
|
||||||
type ExpectFailureFailHelper struct{}
|
|
||||||
|
|
||||||
func (s *ExpectFailureFailHelper) TestFail(c *check.C) {
|
|
||||||
c.ExpectFailure("Bug #XYZ")
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FoundationS) TestExpectFailureFail(c *check.C) {
|
|
||||||
helper := ExpectFailureFailHelper{}
|
|
||||||
output := String{}
|
|
||||||
result := check.Run(&helper, &check.RunConf{Output: &output})
|
|
||||||
|
|
||||||
expected := "" +
|
|
||||||
"^\n-+\n" +
|
|
||||||
"FAIL: foundation_test\\.go:[0-9]+:" +
|
|
||||||
" ExpectFailureFailHelper\\.TestFail\n\n" +
|
|
||||||
"\\.\\.\\. Error: Test succeeded, but was expected to fail\n" +
|
|
||||||
"\\.\\.\\. Reason: Bug #XYZ\n$"
|
|
||||||
|
|
||||||
matched, err := regexp.MatchString(expected, output.value)
|
|
||||||
if err != nil {
|
|
||||||
c.Error("Bad expression: ", expected)
|
|
||||||
} else if !matched {
|
|
||||||
c.Error("ExpectFailure() didn't log properly:\n", output.value)
|
|
||||||
}
|
|
||||||
|
|
||||||
c.Assert(result.ExpectedFailures, check.Equals, 0)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FoundationS) TestExpectFailureSucceed(c *check.C) {
|
|
||||||
helper := ExpectFailureSucceedHelper{}
|
|
||||||
output := String{}
|
|
||||||
result := check.Run(&helper, &check.RunConf{Output: &output})
|
|
||||||
|
|
||||||
c.Assert(output.value, check.Equals, "")
|
|
||||||
c.Assert(result.ExpectedFailures, check.Equals, 1)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FoundationS) TestExpectFailureSucceedVerbose(c *check.C) {
|
|
||||||
helper := ExpectFailureSucceedHelper{}
|
|
||||||
output := String{}
|
|
||||||
result := check.Run(&helper, &check.RunConf{Output: &output, Verbose: true})
|
|
||||||
|
|
||||||
expected := "" +
|
|
||||||
"FAIL EXPECTED: foundation_test\\.go:[0-9]+:" +
|
|
||||||
" ExpectFailureSucceedHelper\\.TestSucceed \\(It booms!\\)\t *[.0-9]+s\n"
|
|
||||||
|
|
||||||
matched, err := regexp.MatchString(expected, output.value)
|
|
||||||
if err != nil {
|
|
||||||
c.Error("Bad expression: ", expected)
|
|
||||||
} else if !matched {
|
|
||||||
c.Error("ExpectFailure() didn't log properly:\n", output.value)
|
|
||||||
}
|
|
||||||
|
|
||||||
c.Assert(result.ExpectedFailures, check.Equals, 1)
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Skip() allows stopping a test without positive/negative results.
|
|
||||||
|
|
||||||
type SkipTestHelper struct{}
|
|
||||||
|
|
||||||
func (s *SkipTestHelper) TestFail(c *check.C) {
|
|
||||||
c.Skip("Wrong platform or whatever")
|
|
||||||
c.Error("Boom!")
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FoundationS) TestSkip(c *check.C) {
|
|
||||||
helper := SkipTestHelper{}
|
|
||||||
output := String{}
|
|
||||||
check.Run(&helper, &check.RunConf{Output: &output})
|
|
||||||
|
|
||||||
if output.value != "" {
|
|
||||||
c.Error("Skip() logged something:\n", output.value)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *FoundationS) TestSkipVerbose(c *check.C) {
|
|
||||||
helper := SkipTestHelper{}
|
|
||||||
output := String{}
|
|
||||||
check.Run(&helper, &check.RunConf{Output: &output, Verbose: true})
|
|
||||||
|
|
||||||
expected := "SKIP: foundation_test\\.go:[0-9]+: SkipTestHelper\\.TestFail" +
|
|
||||||
" \\(Wrong platform or whatever\\)"
|
|
||||||
matched, err := regexp.MatchString(expected, output.value)
|
|
||||||
if err != nil {
|
|
||||||
c.Error("Bad expression: ", expected)
|
|
||||||
} else if !matched {
|
|
||||||
c.Error("Skip() didn't log properly:\n", output.value)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Check minimum *log.Logger interface provided by *check.C.
|
|
||||||
|
|
||||||
type minLogger interface {
|
|
||||||
Output(calldepth int, s string) error
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *BootstrapS) TestMinLogger(c *check.C) {
|
|
||||||
var logger minLogger
|
|
||||||
logger = log.New(os.Stderr, "", 0)
|
|
||||||
logger = c
|
|
||||||
logger.Output(0, "Hello there")
|
|
||||||
expected := `\[LOG\] [0-9]+:[0-9][0-9]\.[0-9][0-9][0-9] +Hello there\n`
|
|
||||||
output := c.GetTestLog()
|
|
||||||
c.Assert(output, check.Matches, expected)
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Ensure that suites with embedded types are working fine, including the
|
|
||||||
// the workaround for issue 906.
|
|
||||||
|
|
||||||
type EmbeddedInternalS struct {
|
|
||||||
called bool
|
|
||||||
}
|
|
||||||
|
|
||||||
type EmbeddedS struct {
|
|
||||||
EmbeddedInternalS
|
|
||||||
}
|
|
||||||
|
|
||||||
var embeddedS = check.Suite(&EmbeddedS{})
|
|
||||||
|
|
||||||
func (s *EmbeddedS) TestCountSuite(c *check.C) {
|
|
||||||
suitesRun += 1
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *EmbeddedInternalS) TestMethod(c *check.C) {
|
|
||||||
c.Error("TestMethod() of the embedded type was called!?")
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *EmbeddedS) TestMethod(c *check.C) {
|
|
||||||
// http://code.google.com/p/go/issues/detail?id=906
|
|
||||||
c.Check(s.called, check.Equals, false) // Go issue 906 is affecting the runner?
|
|
||||||
s.called = true
|
|
||||||
}
|
|
231
vendor/gopkg.in/check.v1/helpers.go
generated
vendored
231
vendor/gopkg.in/check.v1/helpers.go
generated
vendored
@ -1,231 +0,0 @@
|
|||||||
package check
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"strings"
|
|
||||||
"time"
|
|
||||||
)
|
|
||||||
|
|
||||||
// TestName returns the current test name in the form "SuiteName.TestName"
|
|
||||||
func (c *C) TestName() string {
|
|
||||||
return c.testName
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Basic succeeding/failing logic.
|
|
||||||
|
|
||||||
// Failed returns whether the currently running test has already failed.
|
|
||||||
func (c *C) Failed() bool {
|
|
||||||
return c.status() == failedSt
|
|
||||||
}
|
|
||||||
|
|
||||||
// Fail marks the currently running test as failed.
|
|
||||||
//
|
|
||||||
// Something ought to have been previously logged so the developer can tell
|
|
||||||
// what went wrong. The higher level helper functions will fail the test
|
|
||||||
// and do the logging properly.
|
|
||||||
func (c *C) Fail() {
|
|
||||||
c.setStatus(failedSt)
|
|
||||||
}
|
|
||||||
|
|
||||||
// FailNow marks the currently running test as failed and stops running it.
|
|
||||||
// Something ought to have been previously logged so the developer can tell
|
|
||||||
// what went wrong. The higher level helper functions will fail the test
|
|
||||||
// and do the logging properly.
|
|
||||||
func (c *C) FailNow() {
|
|
||||||
c.Fail()
|
|
||||||
c.stopNow()
|
|
||||||
}
|
|
||||||
|
|
||||||
// Succeed marks the currently running test as succeeded, undoing any
|
|
||||||
// previous failures.
|
|
||||||
func (c *C) Succeed() {
|
|
||||||
c.setStatus(succeededSt)
|
|
||||||
}
|
|
||||||
|
|
||||||
// SucceedNow marks the currently running test as succeeded, undoing any
|
|
||||||
// previous failures, and stops running the test.
|
|
||||||
func (c *C) SucceedNow() {
|
|
||||||
c.Succeed()
|
|
||||||
c.stopNow()
|
|
||||||
}
|
|
||||||
|
|
||||||
// ExpectFailure informs that the running test is knowingly broken for
|
|
||||||
// the provided reason. If the test does not fail, an error will be reported
|
|
||||||
// to raise attention to this fact. This method is useful to temporarily
|
|
||||||
// disable tests which cover well known problems until a better time to
|
|
||||||
// fix the problem is found, without forgetting about the fact that a
|
|
||||||
// failure still exists.
|
|
||||||
func (c *C) ExpectFailure(reason string) {
|
|
||||||
if reason == "" {
|
|
||||||
panic("Missing reason why the test is expected to fail")
|
|
||||||
}
|
|
||||||
c.mustFail = true
|
|
||||||
c.reason = reason
|
|
||||||
}
|
|
||||||
|
|
||||||
// Skip skips the running test for the provided reason. If run from within
|
|
||||||
// SetUpTest, the individual test being set up will be skipped, and if run
|
|
||||||
// from within SetUpSuite, the whole suite is skipped.
|
|
||||||
func (c *C) Skip(reason string) {
|
|
||||||
if reason == "" {
|
|
||||||
panic("Missing reason why the test is being skipped")
|
|
||||||
}
|
|
||||||
c.reason = reason
|
|
||||||
c.setStatus(skippedSt)
|
|
||||||
c.stopNow()
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Basic logging.
|
|
||||||
|
|
||||||
// GetTestLog returns the current test error output.
|
|
||||||
func (c *C) GetTestLog() string {
|
|
||||||
return c.logb.String()
|
|
||||||
}
|
|
||||||
|
|
||||||
// Log logs some information into the test error output.
|
|
||||||
// The provided arguments are assembled together into a string with fmt.Sprint.
|
|
||||||
func (c *C) Log(args ...interface{}) {
|
|
||||||
c.log(args...)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Log logs some information into the test error output.
|
|
||||||
// The provided arguments are assembled together into a string with fmt.Sprintf.
|
|
||||||
func (c *C) Logf(format string, args ...interface{}) {
|
|
||||||
c.logf(format, args...)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Output enables *C to be used as a logger in functions that require only
|
|
||||||
// the minimum interface of *log.Logger.
|
|
||||||
func (c *C) Output(calldepth int, s string) error {
|
|
||||||
d := time.Now().Sub(c.startTime)
|
|
||||||
msec := d / time.Millisecond
|
|
||||||
sec := d / time.Second
|
|
||||||
min := d / time.Minute
|
|
||||||
|
|
||||||
c.Logf("[LOG] %d:%02d.%03d %s", min, sec%60, msec%1000, s)
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Error logs an error into the test error output and marks the test as failed.
|
|
||||||
// The provided arguments are assembled together into a string with fmt.Sprint.
|
|
||||||
func (c *C) Error(args ...interface{}) {
|
|
||||||
c.logCaller(1)
|
|
||||||
c.logString(fmt.Sprint("Error: ", fmt.Sprint(args...)))
|
|
||||||
c.logNewLine()
|
|
||||||
c.Fail()
|
|
||||||
}
|
|
||||||
|
|
||||||
// Errorf logs an error into the test error output and marks the test as failed.
|
|
||||||
// The provided arguments are assembled together into a string with fmt.Sprintf.
|
|
||||||
func (c *C) Errorf(format string, args ...interface{}) {
|
|
||||||
c.logCaller(1)
|
|
||||||
c.logString(fmt.Sprintf("Error: "+format, args...))
|
|
||||||
c.logNewLine()
|
|
||||||
c.Fail()
|
|
||||||
}
|
|
||||||
|
|
||||||
// Fatal logs an error into the test error output, marks the test as failed, and
|
|
||||||
// stops the test execution. The provided arguments are assembled together into
|
|
||||||
// a string with fmt.Sprint.
|
|
||||||
func (c *C) Fatal(args ...interface{}) {
|
|
||||||
c.logCaller(1)
|
|
||||||
c.logString(fmt.Sprint("Error: ", fmt.Sprint(args...)))
|
|
||||||
c.logNewLine()
|
|
||||||
c.FailNow()
|
|
||||||
}
|
|
||||||
|
|
||||||
// Fatlaf logs an error into the test error output, marks the test as failed, and
|
|
||||||
// stops the test execution. The provided arguments are assembled together into
|
|
||||||
// a string with fmt.Sprintf.
|
|
||||||
func (c *C) Fatalf(format string, args ...interface{}) {
|
|
||||||
c.logCaller(1)
|
|
||||||
c.logString(fmt.Sprint("Error: ", fmt.Sprintf(format, args...)))
|
|
||||||
c.logNewLine()
|
|
||||||
c.FailNow()
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Generic checks and assertions based on checkers.
|
|
||||||
|
|
||||||
// Check verifies if the first value matches the expected value according
|
|
||||||
// to the provided checker. If they do not match, an error is logged, the
|
|
||||||
// test is marked as failed, and the test execution continues.
|
|
||||||
//
|
|
||||||
// Some checkers may not need the expected argument (e.g. IsNil).
|
|
||||||
//
|
|
||||||
// Extra arguments provided to the function are logged next to the reported
|
|
||||||
// problem when the matching fails.
|
|
||||||
func (c *C) Check(obtained interface{}, checker Checker, args ...interface{}) bool {
|
|
||||||
return c.internalCheck("Check", obtained, checker, args...)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Assert ensures that the first value matches the expected value according
|
|
||||||
// to the provided checker. If they do not match, an error is logged, the
|
|
||||||
// test is marked as failed, and the test execution stops.
|
|
||||||
//
|
|
||||||
// Some checkers may not need the expected argument (e.g. IsNil).
|
|
||||||
//
|
|
||||||
// Extra arguments provided to the function are logged next to the reported
|
|
||||||
// problem when the matching fails.
|
|
||||||
func (c *C) Assert(obtained interface{}, checker Checker, args ...interface{}) {
|
|
||||||
if !c.internalCheck("Assert", obtained, checker, args...) {
|
|
||||||
c.stopNow()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *C) internalCheck(funcName string, obtained interface{}, checker Checker, args ...interface{}) bool {
|
|
||||||
if checker == nil {
|
|
||||||
c.logCaller(2)
|
|
||||||
c.logString(fmt.Sprintf("%s(obtained, nil!?, ...):", funcName))
|
|
||||||
c.logString("Oops.. you've provided a nil checker!")
|
|
||||||
c.logNewLine()
|
|
||||||
c.Fail()
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
||||||
// If the last argument is a bug info, extract it out.
|
|
||||||
var comment CommentInterface
|
|
||||||
if len(args) > 0 {
|
|
||||||
if c, ok := args[len(args)-1].(CommentInterface); ok {
|
|
||||||
comment = c
|
|
||||||
args = args[:len(args)-1]
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
params := append([]interface{}{obtained}, args...)
|
|
||||||
info := checker.Info()
|
|
||||||
|
|
||||||
if len(params) != len(info.Params) {
|
|
||||||
names := append([]string{info.Params[0], info.Name}, info.Params[1:]...)
|
|
||||||
c.logCaller(2)
|
|
||||||
c.logString(fmt.Sprintf("%s(%s):", funcName, strings.Join(names, ", ")))
|
|
||||||
c.logString(fmt.Sprintf("Wrong number of parameters for %s: want %d, got %d", info.Name, len(names), len(params)+1))
|
|
||||||
c.logNewLine()
|
|
||||||
c.Fail()
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
||||||
// Copy since it may be mutated by Check.
|
|
||||||
names := append([]string{}, info.Params...)
|
|
||||||
|
|
||||||
// Do the actual check.
|
|
||||||
result, error := checker.Check(params, names)
|
|
||||||
if !result || error != "" {
|
|
||||||
c.logCaller(2)
|
|
||||||
for i := 0; i != len(params); i++ {
|
|
||||||
c.logValue(names[i], params[i])
|
|
||||||
}
|
|
||||||
if comment != nil {
|
|
||||||
c.logString(comment.CheckCommentString())
|
|
||||||
}
|
|
||||||
if error != "" {
|
|
||||||
c.logString(error)
|
|
||||||
}
|
|
||||||
c.logNewLine()
|
|
||||||
c.Fail()
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
return true
|
|
||||||
}
|
|
519
vendor/gopkg.in/check.v1/helpers_test.go
generated
vendored
519
vendor/gopkg.in/check.v1/helpers_test.go
generated
vendored
@ -1,519 +0,0 @@
|
|||||||
// These tests verify the inner workings of the helper methods associated
|
|
||||||
// with check.T.
|
|
||||||
|
|
||||||
package check_test
|
|
||||||
|
|
||||||
import (
|
|
||||||
"gopkg.in/check.v1"
|
|
||||||
"os"
|
|
||||||
"reflect"
|
|
||||||
"runtime"
|
|
||||||
"sync"
|
|
||||||
)
|
|
||||||
|
|
||||||
var helpersS = check.Suite(&HelpersS{})
|
|
||||||
|
|
||||||
type HelpersS struct{}
|
|
||||||
|
|
||||||
func (s *HelpersS) TestCountSuite(c *check.C) {
|
|
||||||
suitesRun += 1
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Fake checker and bug info to verify the behavior of Assert() and Check().
|
|
||||||
|
|
||||||
type MyChecker struct {
|
|
||||||
info *check.CheckerInfo
|
|
||||||
params []interface{}
|
|
||||||
names []string
|
|
||||||
result bool
|
|
||||||
error string
|
|
||||||
}
|
|
||||||
|
|
||||||
func (checker *MyChecker) Info() *check.CheckerInfo {
|
|
||||||
if checker.info == nil {
|
|
||||||
return &check.CheckerInfo{Name: "MyChecker", Params: []string{"myobtained", "myexpected"}}
|
|
||||||
}
|
|
||||||
return checker.info
|
|
||||||
}
|
|
||||||
|
|
||||||
func (checker *MyChecker) Check(params []interface{}, names []string) (bool, string) {
|
|
||||||
rparams := checker.params
|
|
||||||
rnames := checker.names
|
|
||||||
checker.params = append([]interface{}{}, params...)
|
|
||||||
checker.names = append([]string{}, names...)
|
|
||||||
if rparams != nil {
|
|
||||||
copy(params, rparams)
|
|
||||||
}
|
|
||||||
if rnames != nil {
|
|
||||||
copy(names, rnames)
|
|
||||||
}
|
|
||||||
return checker.result, checker.error
|
|
||||||
}
|
|
||||||
|
|
||||||
type myCommentType string
|
|
||||||
|
|
||||||
func (c myCommentType) CheckCommentString() string {
|
|
||||||
return string(c)
|
|
||||||
}
|
|
||||||
|
|
||||||
func myComment(s string) myCommentType {
|
|
||||||
return myCommentType(s)
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Ensure a real checker actually works fine.
|
|
||||||
|
|
||||||
func (s *HelpersS) TestCheckerInterface(c *check.C) {
|
|
||||||
testHelperSuccess(c, "Check(1, Equals, 1)", true, func() interface{} {
|
|
||||||
return c.Check(1, check.Equals, 1)
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Tests for Check(), mostly the same as for Assert() following these.
|
|
||||||
|
|
||||||
func (s *HelpersS) TestCheckSucceedWithExpected(c *check.C) {
|
|
||||||
checker := &MyChecker{result: true}
|
|
||||||
testHelperSuccess(c, "Check(1, checker, 2)", true, func() interface{} {
|
|
||||||
return c.Check(1, checker, 2)
|
|
||||||
})
|
|
||||||
if !reflect.DeepEqual(checker.params, []interface{}{1, 2}) {
|
|
||||||
c.Fatalf("Bad params for check: %#v", checker.params)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *HelpersS) TestCheckSucceedWithoutExpected(c *check.C) {
|
|
||||||
checker := &MyChecker{result: true, info: &check.CheckerInfo{Params: []string{"myvalue"}}}
|
|
||||||
testHelperSuccess(c, "Check(1, checker)", true, func() interface{} {
|
|
||||||
return c.Check(1, checker)
|
|
||||||
})
|
|
||||||
if !reflect.DeepEqual(checker.params, []interface{}{1}) {
|
|
||||||
c.Fatalf("Bad params for check: %#v", checker.params)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *HelpersS) TestCheckFailWithExpected(c *check.C) {
|
|
||||||
checker := &MyChecker{result: false}
|
|
||||||
log := "(?s)helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" +
|
|
||||||
" return c\\.Check\\(1, checker, 2\\)\n" +
|
|
||||||
"\\.+ myobtained int = 1\n" +
|
|
||||||
"\\.+ myexpected int = 2\n\n"
|
|
||||||
testHelperFailure(c, "Check(1, checker, 2)", false, false, log,
|
|
||||||
func() interface{} {
|
|
||||||
return c.Check(1, checker, 2)
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *HelpersS) TestCheckFailWithExpectedAndComment(c *check.C) {
|
|
||||||
checker := &MyChecker{result: false}
|
|
||||||
log := "(?s)helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" +
|
|
||||||
" return c\\.Check\\(1, checker, 2, myComment\\(\"Hello world!\"\\)\\)\n" +
|
|
||||||
"\\.+ myobtained int = 1\n" +
|
|
||||||
"\\.+ myexpected int = 2\n" +
|
|
||||||
"\\.+ Hello world!\n\n"
|
|
||||||
testHelperFailure(c, "Check(1, checker, 2, msg)", false, false, log,
|
|
||||||
func() interface{} {
|
|
||||||
return c.Check(1, checker, 2, myComment("Hello world!"))
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *HelpersS) TestCheckFailWithExpectedAndStaticComment(c *check.C) {
|
|
||||||
checker := &MyChecker{result: false}
|
|
||||||
log := "(?s)helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" +
|
|
||||||
" // Nice leading comment\\.\n" +
|
|
||||||
" return c\\.Check\\(1, checker, 2\\) // Hello there\n" +
|
|
||||||
"\\.+ myobtained int = 1\n" +
|
|
||||||
"\\.+ myexpected int = 2\n\n"
|
|
||||||
testHelperFailure(c, "Check(1, checker, 2, msg)", false, false, log,
|
|
||||||
func() interface{} {
|
|
||||||
// Nice leading comment.
|
|
||||||
return c.Check(1, checker, 2) // Hello there
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *HelpersS) TestCheckFailWithoutExpected(c *check.C) {
|
|
||||||
checker := &MyChecker{result: false, info: &check.CheckerInfo{Params: []string{"myvalue"}}}
|
|
||||||
log := "(?s)helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" +
|
|
||||||
" return c\\.Check\\(1, checker\\)\n" +
|
|
||||||
"\\.+ myvalue int = 1\n\n"
|
|
||||||
testHelperFailure(c, "Check(1, checker)", false, false, log,
|
|
||||||
func() interface{} {
|
|
||||||
return c.Check(1, checker)
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *HelpersS) TestCheckFailWithoutExpectedAndMessage(c *check.C) {
|
|
||||||
checker := &MyChecker{result: false, info: &check.CheckerInfo{Params: []string{"myvalue"}}}
|
|
||||||
log := "(?s)helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" +
|
|
||||||
" return c\\.Check\\(1, checker, myComment\\(\"Hello world!\"\\)\\)\n" +
|
|
||||||
"\\.+ myvalue int = 1\n" +
|
|
||||||
"\\.+ Hello world!\n\n"
|
|
||||||
testHelperFailure(c, "Check(1, checker, msg)", false, false, log,
|
|
||||||
func() interface{} {
|
|
||||||
return c.Check(1, checker, myComment("Hello world!"))
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *HelpersS) TestCheckWithMissingExpected(c *check.C) {
|
|
||||||
checker := &MyChecker{result: true}
|
|
||||||
log := "(?s)helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" +
|
|
||||||
" return c\\.Check\\(1, checker\\)\n" +
|
|
||||||
"\\.+ Check\\(myobtained, MyChecker, myexpected\\):\n" +
|
|
||||||
"\\.+ Wrong number of parameters for MyChecker: " +
|
|
||||||
"want 3, got 2\n\n"
|
|
||||||
testHelperFailure(c, "Check(1, checker, !?)", false, false, log,
|
|
||||||
func() interface{} {
|
|
||||||
return c.Check(1, checker)
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *HelpersS) TestCheckWithTooManyExpected(c *check.C) {
|
|
||||||
checker := &MyChecker{result: true}
|
|
||||||
log := "(?s)helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" +
|
|
||||||
" return c\\.Check\\(1, checker, 2, 3\\)\n" +
|
|
||||||
"\\.+ Check\\(myobtained, MyChecker, myexpected\\):\n" +
|
|
||||||
"\\.+ Wrong number of parameters for MyChecker: " +
|
|
||||||
"want 3, got 4\n\n"
|
|
||||||
testHelperFailure(c, "Check(1, checker, 2, 3)", false, false, log,
|
|
||||||
func() interface{} {
|
|
||||||
return c.Check(1, checker, 2, 3)
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *HelpersS) TestCheckWithError(c *check.C) {
|
|
||||||
checker := &MyChecker{result: false, error: "Some not so cool data provided!"}
|
|
||||||
log := "(?s)helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" +
|
|
||||||
" return c\\.Check\\(1, checker, 2\\)\n" +
|
|
||||||
"\\.+ myobtained int = 1\n" +
|
|
||||||
"\\.+ myexpected int = 2\n" +
|
|
||||||
"\\.+ Some not so cool data provided!\n\n"
|
|
||||||
testHelperFailure(c, "Check(1, checker, 2)", false, false, log,
|
|
||||||
func() interface{} {
|
|
||||||
return c.Check(1, checker, 2)
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *HelpersS) TestCheckWithNilChecker(c *check.C) {
|
|
||||||
log := "(?s)helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" +
|
|
||||||
" return c\\.Check\\(1, nil\\)\n" +
|
|
||||||
"\\.+ Check\\(obtained, nil!\\?, \\.\\.\\.\\):\n" +
|
|
||||||
"\\.+ Oops\\.\\. you've provided a nil checker!\n\n"
|
|
||||||
testHelperFailure(c, "Check(obtained, nil)", false, false, log,
|
|
||||||
func() interface{} {
|
|
||||||
return c.Check(1, nil)
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *HelpersS) TestCheckWithParamsAndNamesMutation(c *check.C) {
|
|
||||||
checker := &MyChecker{result: false, params: []interface{}{3, 4}, names: []string{"newobtained", "newexpected"}}
|
|
||||||
log := "(?s)helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" +
|
|
||||||
" return c\\.Check\\(1, checker, 2\\)\n" +
|
|
||||||
"\\.+ newobtained int = 3\n" +
|
|
||||||
"\\.+ newexpected int = 4\n\n"
|
|
||||||
testHelperFailure(c, "Check(1, checker, 2) with mutation", false, false, log,
|
|
||||||
func() interface{} {
|
|
||||||
return c.Check(1, checker, 2)
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Tests for Assert(), mostly the same as for Check() above.
|
|
||||||
|
|
||||||
func (s *HelpersS) TestAssertSucceedWithExpected(c *check.C) {
|
|
||||||
checker := &MyChecker{result: true}
|
|
||||||
testHelperSuccess(c, "Assert(1, checker, 2)", nil, func() interface{} {
|
|
||||||
c.Assert(1, checker, 2)
|
|
||||||
return nil
|
|
||||||
})
|
|
||||||
if !reflect.DeepEqual(checker.params, []interface{}{1, 2}) {
|
|
||||||
c.Fatalf("Bad params for check: %#v", checker.params)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *HelpersS) TestAssertSucceedWithoutExpected(c *check.C) {
|
|
||||||
checker := &MyChecker{result: true, info: &check.CheckerInfo{Params: []string{"myvalue"}}}
|
|
||||||
testHelperSuccess(c, "Assert(1, checker)", nil, func() interface{} {
|
|
||||||
c.Assert(1, checker)
|
|
||||||
return nil
|
|
||||||
})
|
|
||||||
if !reflect.DeepEqual(checker.params, []interface{}{1}) {
|
|
||||||
c.Fatalf("Bad params for check: %#v", checker.params)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *HelpersS) TestAssertFailWithExpected(c *check.C) {
|
|
||||||
checker := &MyChecker{result: false}
|
|
||||||
log := "(?s)helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" +
|
|
||||||
" c\\.Assert\\(1, checker, 2\\)\n" +
|
|
||||||
"\\.+ myobtained int = 1\n" +
|
|
||||||
"\\.+ myexpected int = 2\n\n"
|
|
||||||
testHelperFailure(c, "Assert(1, checker, 2)", nil, true, log,
|
|
||||||
func() interface{} {
|
|
||||||
c.Assert(1, checker, 2)
|
|
||||||
return nil
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *HelpersS) TestAssertFailWithExpectedAndMessage(c *check.C) {
|
|
||||||
checker := &MyChecker{result: false}
|
|
||||||
log := "(?s)helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" +
|
|
||||||
" c\\.Assert\\(1, checker, 2, myComment\\(\"Hello world!\"\\)\\)\n" +
|
|
||||||
"\\.+ myobtained int = 1\n" +
|
|
||||||
"\\.+ myexpected int = 2\n" +
|
|
||||||
"\\.+ Hello world!\n\n"
|
|
||||||
testHelperFailure(c, "Assert(1, checker, 2, msg)", nil, true, log,
|
|
||||||
func() interface{} {
|
|
||||||
c.Assert(1, checker, 2, myComment("Hello world!"))
|
|
||||||
return nil
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *HelpersS) TestAssertFailWithoutExpected(c *check.C) {
|
|
||||||
checker := &MyChecker{result: false, info: &check.CheckerInfo{Params: []string{"myvalue"}}}
|
|
||||||
log := "(?s)helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" +
|
|
||||||
" c\\.Assert\\(1, checker\\)\n" +
|
|
||||||
"\\.+ myvalue int = 1\n\n"
|
|
||||||
testHelperFailure(c, "Assert(1, checker)", nil, true, log,
|
|
||||||
func() interface{} {
|
|
||||||
c.Assert(1, checker)
|
|
||||||
return nil
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *HelpersS) TestAssertFailWithoutExpectedAndMessage(c *check.C) {
|
|
||||||
checker := &MyChecker{result: false, info: &check.CheckerInfo{Params: []string{"myvalue"}}}
|
|
||||||
log := "(?s)helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" +
|
|
||||||
" c\\.Assert\\(1, checker, myComment\\(\"Hello world!\"\\)\\)\n" +
|
|
||||||
"\\.+ myvalue int = 1\n" +
|
|
||||||
"\\.+ Hello world!\n\n"
|
|
||||||
testHelperFailure(c, "Assert(1, checker, msg)", nil, true, log,
|
|
||||||
func() interface{} {
|
|
||||||
c.Assert(1, checker, myComment("Hello world!"))
|
|
||||||
return nil
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *HelpersS) TestAssertWithMissingExpected(c *check.C) {
|
|
||||||
checker := &MyChecker{result: true}
|
|
||||||
log := "(?s)helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" +
|
|
||||||
" c\\.Assert\\(1, checker\\)\n" +
|
|
||||||
"\\.+ Assert\\(myobtained, MyChecker, myexpected\\):\n" +
|
|
||||||
"\\.+ Wrong number of parameters for MyChecker: " +
|
|
||||||
"want 3, got 2\n\n"
|
|
||||||
testHelperFailure(c, "Assert(1, checker, !?)", nil, true, log,
|
|
||||||
func() interface{} {
|
|
||||||
c.Assert(1, checker)
|
|
||||||
return nil
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *HelpersS) TestAssertWithError(c *check.C) {
|
|
||||||
checker := &MyChecker{result: false, error: "Some not so cool data provided!"}
|
|
||||||
log := "(?s)helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" +
|
|
||||||
" c\\.Assert\\(1, checker, 2\\)\n" +
|
|
||||||
"\\.+ myobtained int = 1\n" +
|
|
||||||
"\\.+ myexpected int = 2\n" +
|
|
||||||
"\\.+ Some not so cool data provided!\n\n"
|
|
||||||
testHelperFailure(c, "Assert(1, checker, 2)", nil, true, log,
|
|
||||||
func() interface{} {
|
|
||||||
c.Assert(1, checker, 2)
|
|
||||||
return nil
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *HelpersS) TestAssertWithNilChecker(c *check.C) {
|
|
||||||
log := "(?s)helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" +
|
|
||||||
" c\\.Assert\\(1, nil\\)\n" +
|
|
||||||
"\\.+ Assert\\(obtained, nil!\\?, \\.\\.\\.\\):\n" +
|
|
||||||
"\\.+ Oops\\.\\. you've provided a nil checker!\n\n"
|
|
||||||
testHelperFailure(c, "Assert(obtained, nil)", nil, true, log,
|
|
||||||
func() interface{} {
|
|
||||||
c.Assert(1, nil)
|
|
||||||
return nil
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Ensure that values logged work properly in some interesting cases.
|
|
||||||
|
|
||||||
func (s *HelpersS) TestValueLoggingWithArrays(c *check.C) {
|
|
||||||
checker := &MyChecker{result: false}
|
|
||||||
log := "(?s)helpers_test.go:[0-9]+:.*\nhelpers_test.go:[0-9]+:\n" +
|
|
||||||
" return c\\.Check\\(\\[\\]byte{1, 2}, checker, \\[\\]byte{1, 3}\\)\n" +
|
|
||||||
"\\.+ myobtained \\[\\]uint8 = \\[\\]byte{0x1, 0x2}\n" +
|
|
||||||
"\\.+ myexpected \\[\\]uint8 = \\[\\]byte{0x1, 0x3}\n\n"
|
|
||||||
testHelperFailure(c, "Check([]byte{1}, chk, []byte{3})", false, false, log,
|
|
||||||
func() interface{} {
|
|
||||||
return c.Check([]byte{1, 2}, checker, []byte{1, 3})
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *HelpersS) TestValueLoggingWithMultiLine(c *check.C) {
|
|
||||||
checker := &MyChecker{result: false}
|
|
||||||
log := "(?s)helpers_test.go:[0-9]+:.*\nhelpers_test.go:[0-9]+:\n" +
|
|
||||||
" return c\\.Check\\(\"a\\\\nb\\\\n\", checker, \"a\\\\nb\\\\nc\"\\)\n" +
|
|
||||||
"\\.+ myobtained string = \"\" \\+\n" +
|
|
||||||
"\\.+ \"a\\\\n\" \\+\n" +
|
|
||||||
"\\.+ \"b\\\\n\"\n" +
|
|
||||||
"\\.+ myexpected string = \"\" \\+\n" +
|
|
||||||
"\\.+ \"a\\\\n\" \\+\n" +
|
|
||||||
"\\.+ \"b\\\\n\" \\+\n" +
|
|
||||||
"\\.+ \"c\"\n\n"
|
|
||||||
testHelperFailure(c, `Check("a\nb\n", chk, "a\nb\nc")`, false, false, log,
|
|
||||||
func() interface{} {
|
|
||||||
return c.Check("a\nb\n", checker, "a\nb\nc")
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *HelpersS) TestValueLoggingWithMultiLineException(c *check.C) {
|
|
||||||
// If the newline is at the end of the string, don't log as multi-line.
|
|
||||||
checker := &MyChecker{result: false}
|
|
||||||
log := "(?s)helpers_test.go:[0-9]+:.*\nhelpers_test.go:[0-9]+:\n" +
|
|
||||||
" return c\\.Check\\(\"a b\\\\n\", checker, \"a\\\\nb\"\\)\n" +
|
|
||||||
"\\.+ myobtained string = \"a b\\\\n\"\n" +
|
|
||||||
"\\.+ myexpected string = \"\" \\+\n" +
|
|
||||||
"\\.+ \"a\\\\n\" \\+\n" +
|
|
||||||
"\\.+ \"b\"\n\n"
|
|
||||||
testHelperFailure(c, `Check("a b\n", chk, "a\nb")`, false, false, log,
|
|
||||||
func() interface{} {
|
|
||||||
return c.Check("a b\n", checker, "a\nb")
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// MakeDir() tests.
|
|
||||||
|
|
||||||
type MkDirHelper struct {
|
|
||||||
path1 string
|
|
||||||
path2 string
|
|
||||||
isDir1 bool
|
|
||||||
isDir2 bool
|
|
||||||
isDir3 bool
|
|
||||||
isDir4 bool
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *MkDirHelper) SetUpSuite(c *check.C) {
|
|
||||||
s.path1 = c.MkDir()
|
|
||||||
s.isDir1 = isDir(s.path1)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *MkDirHelper) Test(c *check.C) {
|
|
||||||
s.path2 = c.MkDir()
|
|
||||||
s.isDir2 = isDir(s.path2)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *MkDirHelper) TearDownSuite(c *check.C) {
|
|
||||||
s.isDir3 = isDir(s.path1)
|
|
||||||
s.isDir4 = isDir(s.path2)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *HelpersS) TestMkDir(c *check.C) {
|
|
||||||
helper := MkDirHelper{}
|
|
||||||
output := String{}
|
|
||||||
check.Run(&helper, &check.RunConf{Output: &output})
|
|
||||||
c.Assert(output.value, check.Equals, "")
|
|
||||||
c.Check(helper.isDir1, check.Equals, true)
|
|
||||||
c.Check(helper.isDir2, check.Equals, true)
|
|
||||||
c.Check(helper.isDir3, check.Equals, true)
|
|
||||||
c.Check(helper.isDir4, check.Equals, true)
|
|
||||||
c.Check(helper.path1, check.Not(check.Equals),
|
|
||||||
helper.path2)
|
|
||||||
c.Check(isDir(helper.path1), check.Equals, false)
|
|
||||||
c.Check(isDir(helper.path2), check.Equals, false)
|
|
||||||
}
|
|
||||||
|
|
||||||
func isDir(path string) bool {
|
|
||||||
if stat, err := os.Stat(path); err == nil {
|
|
||||||
return stat.IsDir()
|
|
||||||
}
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
||||||
// Concurrent logging should not corrupt the underling buffer.
|
|
||||||
// Use go test -race to detect the race in this test.
|
|
||||||
func (s *HelpersS) TestConcurrentLogging(c *check.C) {
|
|
||||||
defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(runtime.NumCPU()))
|
|
||||||
var start, stop sync.WaitGroup
|
|
||||||
start.Add(1)
|
|
||||||
for i, n := 0, runtime.NumCPU()*2; i < n; i++ {
|
|
||||||
stop.Add(1)
|
|
||||||
go func(i int) {
|
|
||||||
start.Wait()
|
|
||||||
for j := 0; j < 30; j++ {
|
|
||||||
c.Logf("Worker %d: line %d", i, j)
|
|
||||||
}
|
|
||||||
stop.Done()
|
|
||||||
}(i)
|
|
||||||
}
|
|
||||||
start.Done()
|
|
||||||
stop.Wait()
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Test the TestName function
|
|
||||||
|
|
||||||
type TestNameHelper struct {
|
|
||||||
name1 string
|
|
||||||
name2 string
|
|
||||||
name3 string
|
|
||||||
name4 string
|
|
||||||
name5 string
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *TestNameHelper) SetUpSuite(c *check.C) { s.name1 = c.TestName() }
|
|
||||||
func (s *TestNameHelper) SetUpTest(c *check.C) { s.name2 = c.TestName() }
|
|
||||||
func (s *TestNameHelper) Test(c *check.C) { s.name3 = c.TestName() }
|
|
||||||
func (s *TestNameHelper) TearDownTest(c *check.C) { s.name4 = c.TestName() }
|
|
||||||
func (s *TestNameHelper) TearDownSuite(c *check.C) { s.name5 = c.TestName() }
|
|
||||||
|
|
||||||
func (s *HelpersS) TestTestName(c *check.C) {
|
|
||||||
helper := TestNameHelper{}
|
|
||||||
output := String{}
|
|
||||||
check.Run(&helper, &check.RunConf{Output: &output})
|
|
||||||
c.Check(helper.name1, check.Equals, "")
|
|
||||||
c.Check(helper.name2, check.Equals, "TestNameHelper.Test")
|
|
||||||
c.Check(helper.name3, check.Equals, "TestNameHelper.Test")
|
|
||||||
c.Check(helper.name4, check.Equals, "TestNameHelper.Test")
|
|
||||||
c.Check(helper.name5, check.Equals, "")
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// A couple of helper functions to test helper functions. :-)
|
|
||||||
|
|
||||||
func testHelperSuccess(c *check.C, name string, expectedResult interface{}, closure func() interface{}) {
|
|
||||||
var result interface{}
|
|
||||||
defer (func() {
|
|
||||||
if err := recover(); err != nil {
|
|
||||||
panic(err)
|
|
||||||
}
|
|
||||||
checkState(c, result,
|
|
||||||
&expectedState{
|
|
||||||
name: name,
|
|
||||||
result: expectedResult,
|
|
||||||
failed: false,
|
|
||||||
log: "",
|
|
||||||
})
|
|
||||||
})()
|
|
||||||
result = closure()
|
|
||||||
}
|
|
||||||
|
|
||||||
func testHelperFailure(c *check.C, name string, expectedResult interface{}, shouldStop bool, log string, closure func() interface{}) {
|
|
||||||
var result interface{}
|
|
||||||
defer (func() {
|
|
||||||
if err := recover(); err != nil {
|
|
||||||
panic(err)
|
|
||||||
}
|
|
||||||
checkState(c, result,
|
|
||||||
&expectedState{
|
|
||||||
name: name,
|
|
||||||
result: expectedResult,
|
|
||||||
failed: true,
|
|
||||||
log: log,
|
|
||||||
})
|
|
||||||
})()
|
|
||||||
result = closure()
|
|
||||||
if shouldStop {
|
|
||||||
c.Logf("%s didn't stop when it should", name)
|
|
||||||
}
|
|
||||||
}
|
|
168
vendor/gopkg.in/check.v1/printer.go
generated
vendored
168
vendor/gopkg.in/check.v1/printer.go
generated
vendored
@ -1,168 +0,0 @@
|
|||||||
package check
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"go/ast"
|
|
||||||
"go/parser"
|
|
||||||
"go/printer"
|
|
||||||
"go/token"
|
|
||||||
"os"
|
|
||||||
)
|
|
||||||
|
|
||||||
func indent(s, with string) (r string) {
|
|
||||||
eol := true
|
|
||||||
for i := 0; i != len(s); i++ {
|
|
||||||
c := s[i]
|
|
||||||
switch {
|
|
||||||
case eol && c == '\n' || c == '\r':
|
|
||||||
case c == '\n' || c == '\r':
|
|
||||||
eol = true
|
|
||||||
case eol:
|
|
||||||
eol = false
|
|
||||||
s = s[:i] + with + s[i:]
|
|
||||||
i += len(with)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return s
|
|
||||||
}
|
|
||||||
|
|
||||||
func printLine(filename string, line int) (string, error) {
|
|
||||||
fset := token.NewFileSet()
|
|
||||||
file, err := os.Open(filename)
|
|
||||||
if err != nil {
|
|
||||||
return "", err
|
|
||||||
}
|
|
||||||
fnode, err := parser.ParseFile(fset, filename, file, parser.ParseComments)
|
|
||||||
if err != nil {
|
|
||||||
return "", err
|
|
||||||
}
|
|
||||||
config := &printer.Config{Mode: printer.UseSpaces, Tabwidth: 4}
|
|
||||||
lp := &linePrinter{fset: fset, fnode: fnode, line: line, config: config}
|
|
||||||
ast.Walk(lp, fnode)
|
|
||||||
result := lp.output.Bytes()
|
|
||||||
// Comments leave \n at the end.
|
|
||||||
n := len(result)
|
|
||||||
for n > 0 && result[n-1] == '\n' {
|
|
||||||
n--
|
|
||||||
}
|
|
||||||
return string(result[:n]), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
type linePrinter struct {
|
|
||||||
config *printer.Config
|
|
||||||
fset *token.FileSet
|
|
||||||
fnode *ast.File
|
|
||||||
line int
|
|
||||||
output bytes.Buffer
|
|
||||||
stmt ast.Stmt
|
|
||||||
}
|
|
||||||
|
|
||||||
func (lp *linePrinter) emit() bool {
|
|
||||||
if lp.stmt != nil {
|
|
||||||
lp.trim(lp.stmt)
|
|
||||||
lp.printWithComments(lp.stmt)
|
|
||||||
lp.stmt = nil
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
||||||
func (lp *linePrinter) printWithComments(n ast.Node) {
|
|
||||||
nfirst := lp.fset.Position(n.Pos()).Line
|
|
||||||
nlast := lp.fset.Position(n.End()).Line
|
|
||||||
for _, g := range lp.fnode.Comments {
|
|
||||||
cfirst := lp.fset.Position(g.Pos()).Line
|
|
||||||
clast := lp.fset.Position(g.End()).Line
|
|
||||||
if clast == nfirst-1 && lp.fset.Position(n.Pos()).Column == lp.fset.Position(g.Pos()).Column {
|
|
||||||
for _, c := range g.List {
|
|
||||||
lp.output.WriteString(c.Text)
|
|
||||||
lp.output.WriteByte('\n')
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if cfirst >= nfirst && cfirst <= nlast && n.End() <= g.List[0].Slash {
|
|
||||||
// The printer will not include the comment if it starts past
|
|
||||||
// the node itself. Trick it into printing by overlapping the
|
|
||||||
// slash with the end of the statement.
|
|
||||||
g.List[0].Slash = n.End() - 1
|
|
||||||
}
|
|
||||||
}
|
|
||||||
node := &printer.CommentedNode{n, lp.fnode.Comments}
|
|
||||||
lp.config.Fprint(&lp.output, lp.fset, node)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (lp *linePrinter) Visit(n ast.Node) (w ast.Visitor) {
|
|
||||||
if n == nil {
|
|
||||||
if lp.output.Len() == 0 {
|
|
||||||
lp.emit()
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
first := lp.fset.Position(n.Pos()).Line
|
|
||||||
last := lp.fset.Position(n.End()).Line
|
|
||||||
if first <= lp.line && last >= lp.line {
|
|
||||||
// Print the innermost statement containing the line.
|
|
||||||
if stmt, ok := n.(ast.Stmt); ok {
|
|
||||||
if _, ok := n.(*ast.BlockStmt); !ok {
|
|
||||||
lp.stmt = stmt
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if first == lp.line && lp.emit() {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
return lp
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (lp *linePrinter) trim(n ast.Node) bool {
|
|
||||||
stmt, ok := n.(ast.Stmt)
|
|
||||||
if !ok {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
line := lp.fset.Position(n.Pos()).Line
|
|
||||||
if line != lp.line {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
switch stmt := stmt.(type) {
|
|
||||||
case *ast.IfStmt:
|
|
||||||
stmt.Body = lp.trimBlock(stmt.Body)
|
|
||||||
case *ast.SwitchStmt:
|
|
||||||
stmt.Body = lp.trimBlock(stmt.Body)
|
|
||||||
case *ast.TypeSwitchStmt:
|
|
||||||
stmt.Body = lp.trimBlock(stmt.Body)
|
|
||||||
case *ast.CaseClause:
|
|
||||||
stmt.Body = lp.trimList(stmt.Body)
|
|
||||||
case *ast.CommClause:
|
|
||||||
stmt.Body = lp.trimList(stmt.Body)
|
|
||||||
case *ast.BlockStmt:
|
|
||||||
stmt.List = lp.trimList(stmt.List)
|
|
||||||
}
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
func (lp *linePrinter) trimBlock(stmt *ast.BlockStmt) *ast.BlockStmt {
|
|
||||||
if !lp.trim(stmt) {
|
|
||||||
return lp.emptyBlock(stmt)
|
|
||||||
}
|
|
||||||
stmt.Rbrace = stmt.Lbrace
|
|
||||||
return stmt
|
|
||||||
}
|
|
||||||
|
|
||||||
func (lp *linePrinter) trimList(stmts []ast.Stmt) []ast.Stmt {
|
|
||||||
for i := 0; i != len(stmts); i++ {
|
|
||||||
if !lp.trim(stmts[i]) {
|
|
||||||
stmts[i] = lp.emptyStmt(stmts[i])
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return stmts
|
|
||||||
}
|
|
||||||
|
|
||||||
func (lp *linePrinter) emptyStmt(n ast.Node) *ast.ExprStmt {
|
|
||||||
return &ast.ExprStmt{&ast.Ellipsis{n.Pos(), nil}}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (lp *linePrinter) emptyBlock(n ast.Node) *ast.BlockStmt {
|
|
||||||
p := n.Pos()
|
|
||||||
return &ast.BlockStmt{p, []ast.Stmt{lp.emptyStmt(n)}, p}
|
|
||||||
}
|
|
104
vendor/gopkg.in/check.v1/printer_test.go
generated
vendored
104
vendor/gopkg.in/check.v1/printer_test.go
generated
vendored
@ -1,104 +0,0 @@
|
|||||||
package check_test
|
|
||||||
|
|
||||||
import (
|
|
||||||
. "gopkg.in/check.v1"
|
|
||||||
)
|
|
||||||
|
|
||||||
var _ = Suite(&PrinterS{})
|
|
||||||
|
|
||||||
type PrinterS struct{}
|
|
||||||
|
|
||||||
func (s *PrinterS) TestCountSuite(c *C) {
|
|
||||||
suitesRun += 1
|
|
||||||
}
|
|
||||||
|
|
||||||
var printTestFuncLine int
|
|
||||||
|
|
||||||
func init() {
|
|
||||||
printTestFuncLine = getMyLine() + 3
|
|
||||||
}
|
|
||||||
|
|
||||||
func printTestFunc() {
|
|
||||||
println(1) // Comment1
|
|
||||||
if 2 == 2 { // Comment2
|
|
||||||
println(3) // Comment3
|
|
||||||
}
|
|
||||||
switch 5 {
|
|
||||||
case 6: println(6) // Comment6
|
|
||||||
println(7)
|
|
||||||
}
|
|
||||||
switch interface{}(9).(type) {// Comment9
|
|
||||||
case int: println(10)
|
|
||||||
println(11)
|
|
||||||
}
|
|
||||||
select {
|
|
||||||
case <-(chan bool)(nil): println(14)
|
|
||||||
println(15)
|
|
||||||
default: println(16)
|
|
||||||
println(17)
|
|
||||||
}
|
|
||||||
println(19,
|
|
||||||
20)
|
|
||||||
_ = func() { println(21)
|
|
||||||
println(22)
|
|
||||||
}
|
|
||||||
println(24, func() {
|
|
||||||
println(25)
|
|
||||||
})
|
|
||||||
// Leading comment
|
|
||||||
// with multiple lines.
|
|
||||||
println(29) // Comment29
|
|
||||||
}
|
|
||||||
|
|
||||||
var printLineTests = []struct {
|
|
||||||
line int
|
|
||||||
output string
|
|
||||||
}{
|
|
||||||
{1, "println(1) // Comment1"},
|
|
||||||
{2, "if 2 == 2 { // Comment2\n ...\n}"},
|
|
||||||
{3, "println(3) // Comment3"},
|
|
||||||
{5, "switch 5 {\n...\n}"},
|
|
||||||
{6, "case 6:\n println(6) // Comment6\n ..."},
|
|
||||||
{7, "println(7)"},
|
|
||||||
{9, "switch interface{}(9).(type) { // Comment9\n...\n}"},
|
|
||||||
{10, "case int:\n println(10)\n ..."},
|
|
||||||
{14, "case <-(chan bool)(nil):\n println(14)\n ..."},
|
|
||||||
{15, "println(15)"},
|
|
||||||
{16, "default:\n println(16)\n ..."},
|
|
||||||
{17, "println(17)"},
|
|
||||||
{19, "println(19,\n 20)"},
|
|
||||||
{20, "println(19,\n 20)"},
|
|
||||||
{21, "_ = func() {\n println(21)\n println(22)\n}"},
|
|
||||||
{22, "println(22)"},
|
|
||||||
{24, "println(24, func() {\n println(25)\n})"},
|
|
||||||
{25, "println(25)"},
|
|
||||||
{26, "println(24, func() {\n println(25)\n})"},
|
|
||||||
{29, "// Leading comment\n// with multiple lines.\nprintln(29) // Comment29"},
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *PrinterS) TestPrintLine(c *C) {
|
|
||||||
for _, test := range printLineTests {
|
|
||||||
output, err := PrintLine("printer_test.go", printTestFuncLine+test.line)
|
|
||||||
c.Assert(err, IsNil)
|
|
||||||
c.Assert(output, Equals, test.output)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
var indentTests = []struct {
|
|
||||||
in, out string
|
|
||||||
}{
|
|
||||||
{"", ""},
|
|
||||||
{"\n", "\n"},
|
|
||||||
{"a", ">>>a"},
|
|
||||||
{"a\n", ">>>a\n"},
|
|
||||||
{"a\nb", ">>>a\n>>>b"},
|
|
||||||
{" ", ">>> "},
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *PrinterS) TestIndent(c *C) {
|
|
||||||
for _, test := range indentTests {
|
|
||||||
out := Indent(test.in, ">>>")
|
|
||||||
c.Assert(out, Equals, test.out)
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
88
vendor/gopkg.in/check.v1/reporter.go
generated
vendored
88
vendor/gopkg.in/check.v1/reporter.go
generated
vendored
@ -1,88 +0,0 @@
|
|||||||
package check
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"io"
|
|
||||||
"sync"
|
|
||||||
)
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Output writer manages atomic output writing according to settings.
|
|
||||||
|
|
||||||
type outputWriter struct {
|
|
||||||
m sync.Mutex
|
|
||||||
writer io.Writer
|
|
||||||
wroteCallProblemLast bool
|
|
||||||
Stream bool
|
|
||||||
Verbose bool
|
|
||||||
}
|
|
||||||
|
|
||||||
func newOutputWriter(writer io.Writer, stream, verbose bool) *outputWriter {
|
|
||||||
return &outputWriter{writer: writer, Stream: stream, Verbose: verbose}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (ow *outputWriter) Write(content []byte) (n int, err error) {
|
|
||||||
ow.m.Lock()
|
|
||||||
n, err = ow.writer.Write(content)
|
|
||||||
ow.m.Unlock()
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func (ow *outputWriter) WriteCallStarted(label string, c *C) {
|
|
||||||
if ow.Stream {
|
|
||||||
header := renderCallHeader(label, c, "", "\n")
|
|
||||||
ow.m.Lock()
|
|
||||||
ow.writer.Write([]byte(header))
|
|
||||||
ow.m.Unlock()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (ow *outputWriter) WriteCallProblem(label string, c *C) {
|
|
||||||
var prefix string
|
|
||||||
if !ow.Stream {
|
|
||||||
prefix = "\n-----------------------------------" +
|
|
||||||
"-----------------------------------\n"
|
|
||||||
}
|
|
||||||
header := renderCallHeader(label, c, prefix, "\n\n")
|
|
||||||
ow.m.Lock()
|
|
||||||
ow.wroteCallProblemLast = true
|
|
||||||
ow.writer.Write([]byte(header))
|
|
||||||
if !ow.Stream {
|
|
||||||
c.logb.WriteTo(ow.writer)
|
|
||||||
}
|
|
||||||
ow.m.Unlock()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (ow *outputWriter) WriteCallSuccess(label string, c *C) {
|
|
||||||
if ow.Stream || (ow.Verbose && c.kind == testKd) {
|
|
||||||
// TODO Use a buffer here.
|
|
||||||
var suffix string
|
|
||||||
if c.reason != "" {
|
|
||||||
suffix = " (" + c.reason + ")"
|
|
||||||
}
|
|
||||||
if c.status() == succeededSt {
|
|
||||||
suffix += "\t" + c.timerString()
|
|
||||||
}
|
|
||||||
suffix += "\n"
|
|
||||||
if ow.Stream {
|
|
||||||
suffix += "\n"
|
|
||||||
}
|
|
||||||
header := renderCallHeader(label, c, "", suffix)
|
|
||||||
ow.m.Lock()
|
|
||||||
// Resist temptation of using line as prefix above due to race.
|
|
||||||
if !ow.Stream && ow.wroteCallProblemLast {
|
|
||||||
header = "\n-----------------------------------" +
|
|
||||||
"-----------------------------------\n" +
|
|
||||||
header
|
|
||||||
}
|
|
||||||
ow.wroteCallProblemLast = false
|
|
||||||
ow.writer.Write([]byte(header))
|
|
||||||
ow.m.Unlock()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func renderCallHeader(label string, c *C, prefix, suffix string) string {
|
|
||||||
pc := c.method.PC()
|
|
||||||
return fmt.Sprintf("%s%s: %s: %s%s", prefix, label, niceFuncPath(pc),
|
|
||||||
niceFuncName(pc), suffix)
|
|
||||||
}
|
|
159
vendor/gopkg.in/check.v1/reporter_test.go
generated
vendored
159
vendor/gopkg.in/check.v1/reporter_test.go
generated
vendored
@ -1,159 +0,0 @@
|
|||||||
package check_test
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"path/filepath"
|
|
||||||
"runtime"
|
|
||||||
|
|
||||||
. "gopkg.in/check.v1"
|
|
||||||
)
|
|
||||||
|
|
||||||
var _ = Suite(&reporterS{})
|
|
||||||
|
|
||||||
type reporterS struct {
|
|
||||||
testFile string
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *reporterS) SetUpSuite(c *C) {
|
|
||||||
_, fileName, _, ok := runtime.Caller(0)
|
|
||||||
c.Assert(ok, Equals, true)
|
|
||||||
s.testFile = filepath.Base(fileName)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *reporterS) TestWrite(c *C) {
|
|
||||||
testString := "test string"
|
|
||||||
output := String{}
|
|
||||||
|
|
||||||
dummyStream := true
|
|
||||||
dummyVerbose := true
|
|
||||||
o := NewOutputWriter(&output, dummyStream, dummyVerbose)
|
|
||||||
|
|
||||||
o.Write([]byte(testString))
|
|
||||||
c.Assert(output.value, Equals, testString)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *reporterS) TestWriteCallStartedWithStreamFlag(c *C) {
|
|
||||||
testLabel := "test started label"
|
|
||||||
stream := true
|
|
||||||
output := String{}
|
|
||||||
|
|
||||||
dummyVerbose := true
|
|
||||||
o := NewOutputWriter(&output, stream, dummyVerbose)
|
|
||||||
|
|
||||||
o.WriteCallStarted(testLabel, c)
|
|
||||||
expected := fmt.Sprintf("%s: %s:\\d+: %s\n", testLabel, s.testFile, c.TestName())
|
|
||||||
c.Assert(output.value, Matches, expected)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *reporterS) TestWriteCallStartedWithoutStreamFlag(c *C) {
|
|
||||||
stream := false
|
|
||||||
output := String{}
|
|
||||||
|
|
||||||
dummyLabel := "dummy"
|
|
||||||
dummyVerbose := true
|
|
||||||
o := NewOutputWriter(&output, stream, dummyVerbose)
|
|
||||||
|
|
||||||
o.WriteCallStarted(dummyLabel, c)
|
|
||||||
c.Assert(output.value, Equals, "")
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *reporterS) TestWriteCallProblemWithStreamFlag(c *C) {
|
|
||||||
testLabel := "test problem label"
|
|
||||||
stream := true
|
|
||||||
output := String{}
|
|
||||||
|
|
||||||
dummyVerbose := true
|
|
||||||
o := NewOutputWriter(&output, stream, dummyVerbose)
|
|
||||||
|
|
||||||
o.WriteCallProblem(testLabel, c)
|
|
||||||
expected := fmt.Sprintf("%s: %s:\\d+: %s\n\n", testLabel, s.testFile, c.TestName())
|
|
||||||
c.Assert(output.value, Matches, expected)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *reporterS) TestWriteCallProblemWithoutStreamFlag(c *C) {
|
|
||||||
testLabel := "test problem label"
|
|
||||||
stream := false
|
|
||||||
output := String{}
|
|
||||||
|
|
||||||
dummyVerbose := true
|
|
||||||
o := NewOutputWriter(&output, stream, dummyVerbose)
|
|
||||||
|
|
||||||
o.WriteCallProblem(testLabel, c)
|
|
||||||
expected := fmt.Sprintf(""+
|
|
||||||
"\n"+
|
|
||||||
"----------------------------------------------------------------------\n"+
|
|
||||||
"%s: %s:\\d+: %s\n\n", testLabel, s.testFile, c.TestName())
|
|
||||||
c.Assert(output.value, Matches, expected)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *reporterS) TestWriteCallProblemWithoutStreamFlagWithLog(c *C) {
|
|
||||||
testLabel := "test problem label"
|
|
||||||
testLog := "test log"
|
|
||||||
stream := false
|
|
||||||
output := String{}
|
|
||||||
|
|
||||||
dummyVerbose := true
|
|
||||||
o := NewOutputWriter(&output, stream, dummyVerbose)
|
|
||||||
|
|
||||||
c.Log(testLog)
|
|
||||||
o.WriteCallProblem(testLabel, c)
|
|
||||||
expected := fmt.Sprintf(""+
|
|
||||||
"\n"+
|
|
||||||
"----------------------------------------------------------------------\n"+
|
|
||||||
"%s: %s:\\d+: %s\n\n%s\n", testLabel, s.testFile, c.TestName(), testLog)
|
|
||||||
c.Assert(output.value, Matches, expected)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *reporterS) TestWriteCallSuccessWithStreamFlag(c *C) {
|
|
||||||
testLabel := "test success label"
|
|
||||||
stream := true
|
|
||||||
output := String{}
|
|
||||||
|
|
||||||
dummyVerbose := true
|
|
||||||
o := NewOutputWriter(&output, stream, dummyVerbose)
|
|
||||||
|
|
||||||
o.WriteCallSuccess(testLabel, c)
|
|
||||||
expected := fmt.Sprintf("%s: %s:\\d+: %s\t\\d\\.\\d+s\n\n", testLabel, s.testFile, c.TestName())
|
|
||||||
c.Assert(output.value, Matches, expected)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *reporterS) TestWriteCallSuccessWithStreamFlagAndReason(c *C) {
|
|
||||||
testLabel := "test success label"
|
|
||||||
testReason := "test skip reason"
|
|
||||||
stream := true
|
|
||||||
output := String{}
|
|
||||||
|
|
||||||
dummyVerbose := true
|
|
||||||
o := NewOutputWriter(&output, stream, dummyVerbose)
|
|
||||||
c.FakeSkip(testReason)
|
|
||||||
|
|
||||||
o.WriteCallSuccess(testLabel, c)
|
|
||||||
expected := fmt.Sprintf("%s: %s:\\d+: %s \\(%s\\)\t\\d\\.\\d+s\n\n",
|
|
||||||
testLabel, s.testFile, c.TestName(), testReason)
|
|
||||||
c.Assert(output.value, Matches, expected)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *reporterS) TestWriteCallSuccessWithoutStreamFlagWithVerboseFlag(c *C) {
|
|
||||||
testLabel := "test success label"
|
|
||||||
stream := false
|
|
||||||
verbose := true
|
|
||||||
output := String{}
|
|
||||||
|
|
||||||
o := NewOutputWriter(&output, stream, verbose)
|
|
||||||
|
|
||||||
o.WriteCallSuccess(testLabel, c)
|
|
||||||
expected := fmt.Sprintf("%s: %s:\\d+: %s\t\\d\\.\\d+s\n", testLabel, s.testFile, c.TestName())
|
|
||||||
c.Assert(output.value, Matches, expected)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *reporterS) TestWriteCallSuccessWithoutStreamFlagWithoutVerboseFlag(c *C) {
|
|
||||||
testLabel := "test success label"
|
|
||||||
stream := false
|
|
||||||
verbose := false
|
|
||||||
output := String{}
|
|
||||||
|
|
||||||
o := NewOutputWriter(&output, stream, verbose)
|
|
||||||
|
|
||||||
o.WriteCallSuccess(testLabel, c)
|
|
||||||
c.Assert(output.value, Equals, "")
|
|
||||||
}
|
|
175
vendor/gopkg.in/check.v1/run.go
generated
vendored
175
vendor/gopkg.in/check.v1/run.go
generated
vendored
@ -1,175 +0,0 @@
|
|||||||
package check
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bufio"
|
|
||||||
"flag"
|
|
||||||
"fmt"
|
|
||||||
"os"
|
|
||||||
"testing"
|
|
||||||
"time"
|
|
||||||
)
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Test suite registry.
|
|
||||||
|
|
||||||
var allSuites []interface{}
|
|
||||||
|
|
||||||
// Suite registers the given value as a test suite to be run. Any methods
|
|
||||||
// starting with the Test prefix in the given value will be considered as
|
|
||||||
// a test method.
|
|
||||||
func Suite(suite interface{}) interface{} {
|
|
||||||
allSuites = append(allSuites, suite)
|
|
||||||
return suite
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Public running interface.
|
|
||||||
|
|
||||||
var (
|
|
||||||
oldFilterFlag = flag.String("gocheck.f", "", "Regular expression selecting which tests and/or suites to run")
|
|
||||||
oldVerboseFlag = flag.Bool("gocheck.v", false, "Verbose mode")
|
|
||||||
oldStreamFlag = flag.Bool("gocheck.vv", false, "Super verbose mode (disables output caching)")
|
|
||||||
oldBenchFlag = flag.Bool("gocheck.b", false, "Run benchmarks")
|
|
||||||
oldBenchTime = flag.Duration("gocheck.btime", 1*time.Second, "approximate run time for each benchmark")
|
|
||||||
oldListFlag = flag.Bool("gocheck.list", false, "List the names of all tests that will be run")
|
|
||||||
oldWorkFlag = flag.Bool("gocheck.work", false, "Display and do not remove the test working directory")
|
|
||||||
|
|
||||||
newFilterFlag = flag.String("check.f", "", "Regular expression selecting which tests and/or suites to run")
|
|
||||||
newVerboseFlag = flag.Bool("check.v", false, "Verbose mode")
|
|
||||||
newStreamFlag = flag.Bool("check.vv", false, "Super verbose mode (disables output caching)")
|
|
||||||
newBenchFlag = flag.Bool("check.b", false, "Run benchmarks")
|
|
||||||
newBenchTime = flag.Duration("check.btime", 1*time.Second, "approximate run time for each benchmark")
|
|
||||||
newBenchMem = flag.Bool("check.bmem", false, "Report memory benchmarks")
|
|
||||||
newListFlag = flag.Bool("check.list", false, "List the names of all tests that will be run")
|
|
||||||
newWorkFlag = flag.Bool("check.work", false, "Display and do not remove the test working directory")
|
|
||||||
)
|
|
||||||
|
|
||||||
// TestingT runs all test suites registered with the Suite function,
|
|
||||||
// printing results to stdout, and reporting any failures back to
|
|
||||||
// the "testing" package.
|
|
||||||
func TestingT(testingT *testing.T) {
|
|
||||||
benchTime := *newBenchTime
|
|
||||||
if benchTime == 1*time.Second {
|
|
||||||
benchTime = *oldBenchTime
|
|
||||||
}
|
|
||||||
conf := &RunConf{
|
|
||||||
Filter: *oldFilterFlag + *newFilterFlag,
|
|
||||||
Verbose: *oldVerboseFlag || *newVerboseFlag,
|
|
||||||
Stream: *oldStreamFlag || *newStreamFlag,
|
|
||||||
Benchmark: *oldBenchFlag || *newBenchFlag,
|
|
||||||
BenchmarkTime: benchTime,
|
|
||||||
BenchmarkMem: *newBenchMem,
|
|
||||||
KeepWorkDir: *oldWorkFlag || *newWorkFlag,
|
|
||||||
}
|
|
||||||
if *oldListFlag || *newListFlag {
|
|
||||||
w := bufio.NewWriter(os.Stdout)
|
|
||||||
for _, name := range ListAll(conf) {
|
|
||||||
fmt.Fprintln(w, name)
|
|
||||||
}
|
|
||||||
w.Flush()
|
|
||||||
return
|
|
||||||
}
|
|
||||||
result := RunAll(conf)
|
|
||||||
println(result.String())
|
|
||||||
if !result.Passed() {
|
|
||||||
testingT.Fail()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// RunAll runs all test suites registered with the Suite function, using the
|
|
||||||
// provided run configuration.
|
|
||||||
func RunAll(runConf *RunConf) *Result {
|
|
||||||
result := Result{}
|
|
||||||
for _, suite := range allSuites {
|
|
||||||
result.Add(Run(suite, runConf))
|
|
||||||
}
|
|
||||||
return &result
|
|
||||||
}
|
|
||||||
|
|
||||||
// Run runs the provided test suite using the provided run configuration.
|
|
||||||
func Run(suite interface{}, runConf *RunConf) *Result {
|
|
||||||
runner := newSuiteRunner(suite, runConf)
|
|
||||||
return runner.run()
|
|
||||||
}
|
|
||||||
|
|
||||||
// ListAll returns the names of all the test functions registered with the
|
|
||||||
// Suite function that will be run with the provided run configuration.
|
|
||||||
func ListAll(runConf *RunConf) []string {
|
|
||||||
var names []string
|
|
||||||
for _, suite := range allSuites {
|
|
||||||
names = append(names, List(suite, runConf)...)
|
|
||||||
}
|
|
||||||
return names
|
|
||||||
}
|
|
||||||
|
|
||||||
// List returns the names of the test functions in the given
|
|
||||||
// suite that will be run with the provided run configuration.
|
|
||||||
func List(suite interface{}, runConf *RunConf) []string {
|
|
||||||
var names []string
|
|
||||||
runner := newSuiteRunner(suite, runConf)
|
|
||||||
for _, t := range runner.tests {
|
|
||||||
names = append(names, t.String())
|
|
||||||
}
|
|
||||||
return names
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Result methods.
|
|
||||||
|
|
||||||
func (r *Result) Add(other *Result) {
|
|
||||||
r.Succeeded += other.Succeeded
|
|
||||||
r.Skipped += other.Skipped
|
|
||||||
r.Failed += other.Failed
|
|
||||||
r.Panicked += other.Panicked
|
|
||||||
r.FixturePanicked += other.FixturePanicked
|
|
||||||
r.ExpectedFailures += other.ExpectedFailures
|
|
||||||
r.Missed += other.Missed
|
|
||||||
if r.WorkDir != "" && other.WorkDir != "" {
|
|
||||||
r.WorkDir += ":" + other.WorkDir
|
|
||||||
} else if other.WorkDir != "" {
|
|
||||||
r.WorkDir = other.WorkDir
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (r *Result) Passed() bool {
|
|
||||||
return (r.Failed == 0 && r.Panicked == 0 &&
|
|
||||||
r.FixturePanicked == 0 && r.Missed == 0 &&
|
|
||||||
r.RunError == nil)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (r *Result) String() string {
|
|
||||||
if r.RunError != nil {
|
|
||||||
return "ERROR: " + r.RunError.Error()
|
|
||||||
}
|
|
||||||
|
|
||||||
var value string
|
|
||||||
if r.Failed == 0 && r.Panicked == 0 && r.FixturePanicked == 0 &&
|
|
||||||
r.Missed == 0 {
|
|
||||||
value = "OK: "
|
|
||||||
} else {
|
|
||||||
value = "OOPS: "
|
|
||||||
}
|
|
||||||
value += fmt.Sprintf("%d passed", r.Succeeded)
|
|
||||||
if r.Skipped != 0 {
|
|
||||||
value += fmt.Sprintf(", %d skipped", r.Skipped)
|
|
||||||
}
|
|
||||||
if r.ExpectedFailures != 0 {
|
|
||||||
value += fmt.Sprintf(", %d expected failures", r.ExpectedFailures)
|
|
||||||
}
|
|
||||||
if r.Failed != 0 {
|
|
||||||
value += fmt.Sprintf(", %d FAILED", r.Failed)
|
|
||||||
}
|
|
||||||
if r.Panicked != 0 {
|
|
||||||
value += fmt.Sprintf(", %d PANICKED", r.Panicked)
|
|
||||||
}
|
|
||||||
if r.FixturePanicked != 0 {
|
|
||||||
value += fmt.Sprintf(", %d FIXTURE-PANICKED", r.FixturePanicked)
|
|
||||||
}
|
|
||||||
if r.Missed != 0 {
|
|
||||||
value += fmt.Sprintf(", %d MISSED", r.Missed)
|
|
||||||
}
|
|
||||||
if r.WorkDir != "" {
|
|
||||||
value += "\nWORK=" + r.WorkDir
|
|
||||||
}
|
|
||||||
return value
|
|
||||||
}
|
|
419
vendor/gopkg.in/check.v1/run_test.go
generated
vendored
419
vendor/gopkg.in/check.v1/run_test.go
generated
vendored
@ -1,419 +0,0 @@
|
|||||||
// These tests verify the test running logic.
|
|
||||||
|
|
||||||
package check_test
|
|
||||||
|
|
||||||
import (
|
|
||||||
"errors"
|
|
||||||
. "gopkg.in/check.v1"
|
|
||||||
"os"
|
|
||||||
"sync"
|
|
||||||
)
|
|
||||||
|
|
||||||
var runnerS = Suite(&RunS{})
|
|
||||||
|
|
||||||
type RunS struct{}
|
|
||||||
|
|
||||||
func (s *RunS) TestCountSuite(c *C) {
|
|
||||||
suitesRun += 1
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Tests ensuring result counting works properly.
|
|
||||||
|
|
||||||
func (s *RunS) TestSuccess(c *C) {
|
|
||||||
output := String{}
|
|
||||||
result := Run(&SuccessHelper{}, &RunConf{Output: &output})
|
|
||||||
c.Check(result.Succeeded, Equals, 1)
|
|
||||||
c.Check(result.Failed, Equals, 0)
|
|
||||||
c.Check(result.Skipped, Equals, 0)
|
|
||||||
c.Check(result.Panicked, Equals, 0)
|
|
||||||
c.Check(result.FixturePanicked, Equals, 0)
|
|
||||||
c.Check(result.Missed, Equals, 0)
|
|
||||||
c.Check(result.RunError, IsNil)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *RunS) TestFailure(c *C) {
|
|
||||||
output := String{}
|
|
||||||
result := Run(&FailHelper{}, &RunConf{Output: &output})
|
|
||||||
c.Check(result.Succeeded, Equals, 0)
|
|
||||||
c.Check(result.Failed, Equals, 1)
|
|
||||||
c.Check(result.Skipped, Equals, 0)
|
|
||||||
c.Check(result.Panicked, Equals, 0)
|
|
||||||
c.Check(result.FixturePanicked, Equals, 0)
|
|
||||||
c.Check(result.Missed, Equals, 0)
|
|
||||||
c.Check(result.RunError, IsNil)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *RunS) TestFixture(c *C) {
|
|
||||||
output := String{}
|
|
||||||
result := Run(&FixtureHelper{}, &RunConf{Output: &output})
|
|
||||||
c.Check(result.Succeeded, Equals, 2)
|
|
||||||
c.Check(result.Failed, Equals, 0)
|
|
||||||
c.Check(result.Skipped, Equals, 0)
|
|
||||||
c.Check(result.Panicked, Equals, 0)
|
|
||||||
c.Check(result.FixturePanicked, Equals, 0)
|
|
||||||
c.Check(result.Missed, Equals, 0)
|
|
||||||
c.Check(result.RunError, IsNil)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *RunS) TestPanicOnTest(c *C) {
|
|
||||||
output := String{}
|
|
||||||
helper := &FixtureHelper{panicOn: "Test1"}
|
|
||||||
result := Run(helper, &RunConf{Output: &output})
|
|
||||||
c.Check(result.Succeeded, Equals, 1)
|
|
||||||
c.Check(result.Failed, Equals, 0)
|
|
||||||
c.Check(result.Skipped, Equals, 0)
|
|
||||||
c.Check(result.Panicked, Equals, 1)
|
|
||||||
c.Check(result.FixturePanicked, Equals, 0)
|
|
||||||
c.Check(result.Missed, Equals, 0)
|
|
||||||
c.Check(result.RunError, IsNil)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *RunS) TestPanicOnSetUpTest(c *C) {
|
|
||||||
output := String{}
|
|
||||||
helper := &FixtureHelper{panicOn: "SetUpTest"}
|
|
||||||
result := Run(helper, &RunConf{Output: &output})
|
|
||||||
c.Check(result.Succeeded, Equals, 0)
|
|
||||||
c.Check(result.Failed, Equals, 0)
|
|
||||||
c.Check(result.Skipped, Equals, 0)
|
|
||||||
c.Check(result.Panicked, Equals, 0)
|
|
||||||
c.Check(result.FixturePanicked, Equals, 1)
|
|
||||||
c.Check(result.Missed, Equals, 2)
|
|
||||||
c.Check(result.RunError, IsNil)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *RunS) TestPanicOnSetUpSuite(c *C) {
|
|
||||||
output := String{}
|
|
||||||
helper := &FixtureHelper{panicOn: "SetUpSuite"}
|
|
||||||
result := Run(helper, &RunConf{Output: &output})
|
|
||||||
c.Check(result.Succeeded, Equals, 0)
|
|
||||||
c.Check(result.Failed, Equals, 0)
|
|
||||||
c.Check(result.Skipped, Equals, 0)
|
|
||||||
c.Check(result.Panicked, Equals, 0)
|
|
||||||
c.Check(result.FixturePanicked, Equals, 1)
|
|
||||||
c.Check(result.Missed, Equals, 2)
|
|
||||||
c.Check(result.RunError, IsNil)
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Check result aggregation.
|
|
||||||
|
|
||||||
func (s *RunS) TestAdd(c *C) {
|
|
||||||
result := &Result{
|
|
||||||
Succeeded: 1,
|
|
||||||
Skipped: 2,
|
|
||||||
Failed: 3,
|
|
||||||
Panicked: 4,
|
|
||||||
FixturePanicked: 5,
|
|
||||||
Missed: 6,
|
|
||||||
ExpectedFailures: 7,
|
|
||||||
}
|
|
||||||
result.Add(&Result{
|
|
||||||
Succeeded: 10,
|
|
||||||
Skipped: 20,
|
|
||||||
Failed: 30,
|
|
||||||
Panicked: 40,
|
|
||||||
FixturePanicked: 50,
|
|
||||||
Missed: 60,
|
|
||||||
ExpectedFailures: 70,
|
|
||||||
})
|
|
||||||
c.Check(result.Succeeded, Equals, 11)
|
|
||||||
c.Check(result.Skipped, Equals, 22)
|
|
||||||
c.Check(result.Failed, Equals, 33)
|
|
||||||
c.Check(result.Panicked, Equals, 44)
|
|
||||||
c.Check(result.FixturePanicked, Equals, 55)
|
|
||||||
c.Check(result.Missed, Equals, 66)
|
|
||||||
c.Check(result.ExpectedFailures, Equals, 77)
|
|
||||||
c.Check(result.RunError, IsNil)
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Check the Passed() method.
|
|
||||||
|
|
||||||
func (s *RunS) TestPassed(c *C) {
|
|
||||||
c.Assert((&Result{}).Passed(), Equals, true)
|
|
||||||
c.Assert((&Result{Succeeded: 1}).Passed(), Equals, true)
|
|
||||||
c.Assert((&Result{Skipped: 1}).Passed(), Equals, true)
|
|
||||||
c.Assert((&Result{Failed: 1}).Passed(), Equals, false)
|
|
||||||
c.Assert((&Result{Panicked: 1}).Passed(), Equals, false)
|
|
||||||
c.Assert((&Result{FixturePanicked: 1}).Passed(), Equals, false)
|
|
||||||
c.Assert((&Result{Missed: 1}).Passed(), Equals, false)
|
|
||||||
c.Assert((&Result{RunError: errors.New("!")}).Passed(), Equals, false)
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Check that result printing is working correctly.
|
|
||||||
|
|
||||||
func (s *RunS) TestPrintSuccess(c *C) {
|
|
||||||
result := &Result{Succeeded: 5}
|
|
||||||
c.Check(result.String(), Equals, "OK: 5 passed")
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *RunS) TestPrintFailure(c *C) {
|
|
||||||
result := &Result{Failed: 5}
|
|
||||||
c.Check(result.String(), Equals, "OOPS: 0 passed, 5 FAILED")
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *RunS) TestPrintSkipped(c *C) {
|
|
||||||
result := &Result{Skipped: 5}
|
|
||||||
c.Check(result.String(), Equals, "OK: 0 passed, 5 skipped")
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *RunS) TestPrintExpectedFailures(c *C) {
|
|
||||||
result := &Result{ExpectedFailures: 5}
|
|
||||||
c.Check(result.String(), Equals, "OK: 0 passed, 5 expected failures")
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *RunS) TestPrintPanicked(c *C) {
|
|
||||||
result := &Result{Panicked: 5}
|
|
||||||
c.Check(result.String(), Equals, "OOPS: 0 passed, 5 PANICKED")
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *RunS) TestPrintFixturePanicked(c *C) {
|
|
||||||
result := &Result{FixturePanicked: 5}
|
|
||||||
c.Check(result.String(), Equals, "OOPS: 0 passed, 5 FIXTURE-PANICKED")
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *RunS) TestPrintMissed(c *C) {
|
|
||||||
result := &Result{Missed: 5}
|
|
||||||
c.Check(result.String(), Equals, "OOPS: 0 passed, 5 MISSED")
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *RunS) TestPrintAll(c *C) {
|
|
||||||
result := &Result{Succeeded: 1, Skipped: 2, ExpectedFailures: 3,
|
|
||||||
Panicked: 4, FixturePanicked: 5, Missed: 6}
|
|
||||||
c.Check(result.String(), Equals,
|
|
||||||
"OOPS: 1 passed, 2 skipped, 3 expected failures, 4 PANICKED, "+
|
|
||||||
"5 FIXTURE-PANICKED, 6 MISSED")
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *RunS) TestPrintRunError(c *C) {
|
|
||||||
result := &Result{Succeeded: 1, Failed: 1,
|
|
||||||
RunError: errors.New("Kaboom!")}
|
|
||||||
c.Check(result.String(), Equals, "ERROR: Kaboom!")
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Verify that the method pattern flag works correctly.
|
|
||||||
|
|
||||||
func (s *RunS) TestFilterTestName(c *C) {
|
|
||||||
helper := FixtureHelper{}
|
|
||||||
output := String{}
|
|
||||||
runConf := RunConf{Output: &output, Filter: "Test[91]"}
|
|
||||||
Run(&helper, &runConf)
|
|
||||||
c.Check(helper.calls[0], Equals, "SetUpSuite")
|
|
||||||
c.Check(helper.calls[1], Equals, "SetUpTest")
|
|
||||||
c.Check(helper.calls[2], Equals, "Test1")
|
|
||||||
c.Check(helper.calls[3], Equals, "TearDownTest")
|
|
||||||
c.Check(helper.calls[4], Equals, "TearDownSuite")
|
|
||||||
c.Check(len(helper.calls), Equals, 5)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *RunS) TestFilterTestNameWithAll(c *C) {
|
|
||||||
helper := FixtureHelper{}
|
|
||||||
output := String{}
|
|
||||||
runConf := RunConf{Output: &output, Filter: ".*"}
|
|
||||||
Run(&helper, &runConf)
|
|
||||||
c.Check(helper.calls[0], Equals, "SetUpSuite")
|
|
||||||
c.Check(helper.calls[1], Equals, "SetUpTest")
|
|
||||||
c.Check(helper.calls[2], Equals, "Test1")
|
|
||||||
c.Check(helper.calls[3], Equals, "TearDownTest")
|
|
||||||
c.Check(helper.calls[4], Equals, "SetUpTest")
|
|
||||||
c.Check(helper.calls[5], Equals, "Test2")
|
|
||||||
c.Check(helper.calls[6], Equals, "TearDownTest")
|
|
||||||
c.Check(helper.calls[7], Equals, "TearDownSuite")
|
|
||||||
c.Check(len(helper.calls), Equals, 8)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *RunS) TestFilterSuiteName(c *C) {
|
|
||||||
helper := FixtureHelper{}
|
|
||||||
output := String{}
|
|
||||||
runConf := RunConf{Output: &output, Filter: "FixtureHelper"}
|
|
||||||
Run(&helper, &runConf)
|
|
||||||
c.Check(helper.calls[0], Equals, "SetUpSuite")
|
|
||||||
c.Check(helper.calls[1], Equals, "SetUpTest")
|
|
||||||
c.Check(helper.calls[2], Equals, "Test1")
|
|
||||||
c.Check(helper.calls[3], Equals, "TearDownTest")
|
|
||||||
c.Check(helper.calls[4], Equals, "SetUpTest")
|
|
||||||
c.Check(helper.calls[5], Equals, "Test2")
|
|
||||||
c.Check(helper.calls[6], Equals, "TearDownTest")
|
|
||||||
c.Check(helper.calls[7], Equals, "TearDownSuite")
|
|
||||||
c.Check(len(helper.calls), Equals, 8)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *RunS) TestFilterSuiteNameAndTestName(c *C) {
|
|
||||||
helper := FixtureHelper{}
|
|
||||||
output := String{}
|
|
||||||
runConf := RunConf{Output: &output, Filter: "FixtureHelper\\.Test2"}
|
|
||||||
Run(&helper, &runConf)
|
|
||||||
c.Check(helper.calls[0], Equals, "SetUpSuite")
|
|
||||||
c.Check(helper.calls[1], Equals, "SetUpTest")
|
|
||||||
c.Check(helper.calls[2], Equals, "Test2")
|
|
||||||
c.Check(helper.calls[3], Equals, "TearDownTest")
|
|
||||||
c.Check(helper.calls[4], Equals, "TearDownSuite")
|
|
||||||
c.Check(len(helper.calls), Equals, 5)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *RunS) TestFilterAllOut(c *C) {
|
|
||||||
helper := FixtureHelper{}
|
|
||||||
output := String{}
|
|
||||||
runConf := RunConf{Output: &output, Filter: "NotFound"}
|
|
||||||
Run(&helper, &runConf)
|
|
||||||
c.Check(len(helper.calls), Equals, 0)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *RunS) TestRequirePartialMatch(c *C) {
|
|
||||||
helper := FixtureHelper{}
|
|
||||||
output := String{}
|
|
||||||
runConf := RunConf{Output: &output, Filter: "est"}
|
|
||||||
Run(&helper, &runConf)
|
|
||||||
c.Check(len(helper.calls), Equals, 8)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *RunS) TestFilterError(c *C) {
|
|
||||||
helper := FixtureHelper{}
|
|
||||||
output := String{}
|
|
||||||
runConf := RunConf{Output: &output, Filter: "]["}
|
|
||||||
result := Run(&helper, &runConf)
|
|
||||||
c.Check(result.String(), Equals,
|
|
||||||
"ERROR: Bad filter expression: error parsing regexp: missing closing ]: `[`")
|
|
||||||
c.Check(len(helper.calls), Equals, 0)
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Verify that List works correctly.
|
|
||||||
|
|
||||||
func (s *RunS) TestListFiltered(c *C) {
|
|
||||||
names := List(&FixtureHelper{}, &RunConf{Filter: "1"})
|
|
||||||
c.Assert(names, DeepEquals, []string{
|
|
||||||
"FixtureHelper.Test1",
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *RunS) TestList(c *C) {
|
|
||||||
names := List(&FixtureHelper{}, &RunConf{})
|
|
||||||
c.Assert(names, DeepEquals, []string{
|
|
||||||
"FixtureHelper.Test1",
|
|
||||||
"FixtureHelper.Test2",
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Verify that verbose mode prints tests which pass as well.
|
|
||||||
|
|
||||||
func (s *RunS) TestVerboseMode(c *C) {
|
|
||||||
helper := FixtureHelper{}
|
|
||||||
output := String{}
|
|
||||||
runConf := RunConf{Output: &output, Verbose: true}
|
|
||||||
Run(&helper, &runConf)
|
|
||||||
|
|
||||||
expected := "PASS: check_test\\.go:[0-9]+: FixtureHelper\\.Test1\t *[.0-9]+s\n" +
|
|
||||||
"PASS: check_test\\.go:[0-9]+: FixtureHelper\\.Test2\t *[.0-9]+s\n"
|
|
||||||
|
|
||||||
c.Assert(output.value, Matches, expected)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *RunS) TestVerboseModeWithFailBeforePass(c *C) {
|
|
||||||
helper := FixtureHelper{panicOn: "Test1"}
|
|
||||||
output := String{}
|
|
||||||
runConf := RunConf{Output: &output, Verbose: true}
|
|
||||||
Run(&helper, &runConf)
|
|
||||||
|
|
||||||
expected := "(?s).*PANIC.*\n-+\n" + // Should have an extra line.
|
|
||||||
"PASS: check_test\\.go:[0-9]+: FixtureHelper\\.Test2\t *[.0-9]+s\n"
|
|
||||||
|
|
||||||
c.Assert(output.value, Matches, expected)
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Verify the stream output mode. In this mode there's no output caching.
|
|
||||||
|
|
||||||
type StreamHelper struct {
|
|
||||||
l2 sync.Mutex
|
|
||||||
l3 sync.Mutex
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *StreamHelper) SetUpSuite(c *C) {
|
|
||||||
c.Log("0")
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *StreamHelper) Test1(c *C) {
|
|
||||||
c.Log("1")
|
|
||||||
s.l2.Lock()
|
|
||||||
s.l3.Lock()
|
|
||||||
go func() {
|
|
||||||
s.l2.Lock() // Wait for "2".
|
|
||||||
c.Log("3")
|
|
||||||
s.l3.Unlock()
|
|
||||||
}()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *StreamHelper) Test2(c *C) {
|
|
||||||
c.Log("2")
|
|
||||||
s.l2.Unlock()
|
|
||||||
s.l3.Lock() // Wait for "3".
|
|
||||||
c.Fail()
|
|
||||||
c.Log("4")
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *RunS) TestStreamMode(c *C) {
|
|
||||||
helper := &StreamHelper{}
|
|
||||||
output := String{}
|
|
||||||
runConf := RunConf{Output: &output, Stream: true}
|
|
||||||
Run(helper, &runConf)
|
|
||||||
|
|
||||||
expected := "START: run_test\\.go:[0-9]+: StreamHelper\\.SetUpSuite\n0\n" +
|
|
||||||
"PASS: run_test\\.go:[0-9]+: StreamHelper\\.SetUpSuite\t *[.0-9]+s\n\n" +
|
|
||||||
"START: run_test\\.go:[0-9]+: StreamHelper\\.Test1\n1\n" +
|
|
||||||
"PASS: run_test\\.go:[0-9]+: StreamHelper\\.Test1\t *[.0-9]+s\n\n" +
|
|
||||||
"START: run_test\\.go:[0-9]+: StreamHelper\\.Test2\n2\n3\n4\n" +
|
|
||||||
"FAIL: run_test\\.go:[0-9]+: StreamHelper\\.Test2\n\n"
|
|
||||||
|
|
||||||
c.Assert(output.value, Matches, expected)
|
|
||||||
}
|
|
||||||
|
|
||||||
type StreamMissHelper struct{}
|
|
||||||
|
|
||||||
func (s *StreamMissHelper) SetUpSuite(c *C) {
|
|
||||||
c.Log("0")
|
|
||||||
c.Fail()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *StreamMissHelper) Test1(c *C) {
|
|
||||||
c.Log("1")
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *RunS) TestStreamModeWithMiss(c *C) {
|
|
||||||
helper := &StreamMissHelper{}
|
|
||||||
output := String{}
|
|
||||||
runConf := RunConf{Output: &output, Stream: true}
|
|
||||||
Run(helper, &runConf)
|
|
||||||
|
|
||||||
expected := "START: run_test\\.go:[0-9]+: StreamMissHelper\\.SetUpSuite\n0\n" +
|
|
||||||
"FAIL: run_test\\.go:[0-9]+: StreamMissHelper\\.SetUpSuite\n\n" +
|
|
||||||
"START: run_test\\.go:[0-9]+: StreamMissHelper\\.Test1\n" +
|
|
||||||
"MISS: run_test\\.go:[0-9]+: StreamMissHelper\\.Test1\n\n"
|
|
||||||
|
|
||||||
c.Assert(output.value, Matches, expected)
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------
|
|
||||||
// Verify that that the keep work dir request indeed does so.
|
|
||||||
|
|
||||||
type WorkDirSuite struct {}
|
|
||||||
|
|
||||||
func (s *WorkDirSuite) Test(c *C) {
|
|
||||||
c.MkDir()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *RunS) TestKeepWorkDir(c *C) {
|
|
||||||
output := String{}
|
|
||||||
runConf := RunConf{Output: &output, Verbose: true, KeepWorkDir: true}
|
|
||||||
result := Run(&WorkDirSuite{}, &runConf)
|
|
||||||
|
|
||||||
c.Assert(result.String(), Matches, ".*\nWORK=" + result.WorkDir)
|
|
||||||
|
|
||||||
stat, err := os.Stat(result.WorkDir)
|
|
||||||
c.Assert(err, IsNil)
|
|
||||||
c.Assert(stat.IsDir(), Equals, true)
|
|
||||||
}
|
|
1326
vendor/gopkg.in/yaml.v2/decode_test.go
generated
vendored
1326
vendor/gopkg.in/yaml.v2/decode_test.go
generated
vendored
File diff suppressed because it is too large
Load Diff
28
vendor/gopkg.in/yaml.v2/encode.go
generated
vendored
28
vendor/gopkg.in/yaml.v2/encode.go
generated
vendored
@ -13,6 +13,19 @@ import (
|
|||||||
"unicode/utf8"
|
"unicode/utf8"
|
||||||
)
|
)
|
||||||
|
|
||||||
|
// jsonNumber is the interface of the encoding/json.Number datatype.
|
||||||
|
// Repeating the interface here avoids a dependency on encoding/json, and also
|
||||||
|
// supports other libraries like jsoniter, which use a similar datatype with
|
||||||
|
// the same interface. Detecting this interface is useful when dealing with
|
||||||
|
// structures containing json.Number, which is a string under the hood. The
|
||||||
|
// encoder should prefer the use of Int64(), Float64() and string(), in that
|
||||||
|
// order, when encoding this type.
|
||||||
|
type jsonNumber interface {
|
||||||
|
Float64() (float64, error)
|
||||||
|
Int64() (int64, error)
|
||||||
|
String() string
|
||||||
|
}
|
||||||
|
|
||||||
type encoder struct {
|
type encoder struct {
|
||||||
emitter yaml_emitter_t
|
emitter yaml_emitter_t
|
||||||
event yaml_event_t
|
event yaml_event_t
|
||||||
@ -89,6 +102,21 @@ func (e *encoder) marshal(tag string, in reflect.Value) {
|
|||||||
}
|
}
|
||||||
iface := in.Interface()
|
iface := in.Interface()
|
||||||
switch m := iface.(type) {
|
switch m := iface.(type) {
|
||||||
|
case jsonNumber:
|
||||||
|
integer, err := m.Int64()
|
||||||
|
if err == nil {
|
||||||
|
// In this case the json.Number is a valid int64
|
||||||
|
in = reflect.ValueOf(integer)
|
||||||
|
break
|
||||||
|
}
|
||||||
|
float, err := m.Float64()
|
||||||
|
if err == nil {
|
||||||
|
// In this case the json.Number is a valid float64
|
||||||
|
in = reflect.ValueOf(float)
|
||||||
|
break
|
||||||
|
}
|
||||||
|
// fallback case - no number could be obtained
|
||||||
|
in = reflect.ValueOf(m.String())
|
||||||
case time.Time, *time.Time:
|
case time.Time, *time.Time:
|
||||||
// Although time.Time implements TextMarshaler,
|
// Although time.Time implements TextMarshaler,
|
||||||
// we don't want to treat it as a string for YAML
|
// we don't want to treat it as a string for YAML
|
||||||
|
595
vendor/gopkg.in/yaml.v2/encode_test.go
generated
vendored
595
vendor/gopkg.in/yaml.v2/encode_test.go
generated
vendored
@ -1,595 +0,0 @@
|
|||||||
package yaml_test
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"fmt"
|
|
||||||
"math"
|
|
||||||
"strconv"
|
|
||||||
"strings"
|
|
||||||
"time"
|
|
||||||
|
|
||||||
"net"
|
|
||||||
"os"
|
|
||||||
|
|
||||||
. "gopkg.in/check.v1"
|
|
||||||
"gopkg.in/yaml.v2"
|
|
||||||
)
|
|
||||||
|
|
||||||
var marshalIntTest = 123
|
|
||||||
|
|
||||||
var marshalTests = []struct {
|
|
||||||
value interface{}
|
|
||||||
data string
|
|
||||||
}{
|
|
||||||
{
|
|
||||||
nil,
|
|
||||||
"null\n",
|
|
||||||
}, {
|
|
||||||
(*marshalerType)(nil),
|
|
||||||
"null\n",
|
|
||||||
}, {
|
|
||||||
&struct{}{},
|
|
||||||
"{}\n",
|
|
||||||
}, {
|
|
||||||
map[string]string{"v": "hi"},
|
|
||||||
"v: hi\n",
|
|
||||||
}, {
|
|
||||||
map[string]interface{}{"v": "hi"},
|
|
||||||
"v: hi\n",
|
|
||||||
}, {
|
|
||||||
map[string]string{"v": "true"},
|
|
||||||
"v: \"true\"\n",
|
|
||||||
}, {
|
|
||||||
map[string]string{"v": "false"},
|
|
||||||
"v: \"false\"\n",
|
|
||||||
}, {
|
|
||||||
map[string]interface{}{"v": true},
|
|
||||||
"v: true\n",
|
|
||||||
}, {
|
|
||||||
map[string]interface{}{"v": false},
|
|
||||||
"v: false\n",
|
|
||||||
}, {
|
|
||||||
map[string]interface{}{"v": 10},
|
|
||||||
"v: 10\n",
|
|
||||||
}, {
|
|
||||||
map[string]interface{}{"v": -10},
|
|
||||||
"v: -10\n",
|
|
||||||
}, {
|
|
||||||
map[string]uint{"v": 42},
|
|
||||||
"v: 42\n",
|
|
||||||
}, {
|
|
||||||
map[string]interface{}{"v": int64(4294967296)},
|
|
||||||
"v: 4294967296\n",
|
|
||||||
}, {
|
|
||||||
map[string]int64{"v": int64(4294967296)},
|
|
||||||
"v: 4294967296\n",
|
|
||||||
}, {
|
|
||||||
map[string]uint64{"v": 4294967296},
|
|
||||||
"v: 4294967296\n",
|
|
||||||
}, {
|
|
||||||
map[string]interface{}{"v": "10"},
|
|
||||||
"v: \"10\"\n",
|
|
||||||
}, {
|
|
||||||
map[string]interface{}{"v": 0.1},
|
|
||||||
"v: 0.1\n",
|
|
||||||
}, {
|
|
||||||
map[string]interface{}{"v": float64(0.1)},
|
|
||||||
"v: 0.1\n",
|
|
||||||
}, {
|
|
||||||
map[string]interface{}{"v": float32(0.99)},
|
|
||||||
"v: 0.99\n",
|
|
||||||
}, {
|
|
||||||
map[string]interface{}{"v": -0.1},
|
|
||||||
"v: -0.1\n",
|
|
||||||
}, {
|
|
||||||
map[string]interface{}{"v": math.Inf(+1)},
|
|
||||||
"v: .inf\n",
|
|
||||||
}, {
|
|
||||||
map[string]interface{}{"v": math.Inf(-1)},
|
|
||||||
"v: -.inf\n",
|
|
||||||
}, {
|
|
||||||
map[string]interface{}{"v": math.NaN()},
|
|
||||||
"v: .nan\n",
|
|
||||||
}, {
|
|
||||||
map[string]interface{}{"v": nil},
|
|
||||||
"v: null\n",
|
|
||||||
}, {
|
|
||||||
map[string]interface{}{"v": ""},
|
|
||||||
"v: \"\"\n",
|
|
||||||
}, {
|
|
||||||
map[string][]string{"v": []string{"A", "B"}},
|
|
||||||
"v:\n- A\n- B\n",
|
|
||||||
}, {
|
|
||||||
map[string][]string{"v": []string{"A", "B\nC"}},
|
|
||||||
"v:\n- A\n- |-\n B\n C\n",
|
|
||||||
}, {
|
|
||||||
map[string][]interface{}{"v": []interface{}{"A", 1, map[string][]int{"B": []int{2, 3}}}},
|
|
||||||
"v:\n- A\n- 1\n- B:\n - 2\n - 3\n",
|
|
||||||
}, {
|
|
||||||
map[string]interface{}{"a": map[interface{}]interface{}{"b": "c"}},
|
|
||||||
"a:\n b: c\n",
|
|
||||||
}, {
|
|
||||||
map[string]interface{}{"a": "-"},
|
|
||||||
"a: '-'\n",
|
|
||||||
},
|
|
||||||
|
|
||||||
// Simple values.
|
|
||||||
{
|
|
||||||
&marshalIntTest,
|
|
||||||
"123\n",
|
|
||||||
},
|
|
||||||
|
|
||||||
// Structures
|
|
||||||
{
|
|
||||||
&struct{ Hello string }{"world"},
|
|
||||||
"hello: world\n",
|
|
||||||
}, {
|
|
||||||
&struct {
|
|
||||||
A struct {
|
|
||||||
B string
|
|
||||||
}
|
|
||||||
}{struct{ B string }{"c"}},
|
|
||||||
"a:\n b: c\n",
|
|
||||||
}, {
|
|
||||||
&struct {
|
|
||||||
A *struct {
|
|
||||||
B string
|
|
||||||
}
|
|
||||||
}{&struct{ B string }{"c"}},
|
|
||||||
"a:\n b: c\n",
|
|
||||||
}, {
|
|
||||||
&struct {
|
|
||||||
A *struct {
|
|
||||||
B string
|
|
||||||
}
|
|
||||||
}{},
|
|
||||||
"a: null\n",
|
|
||||||
}, {
|
|
||||||
&struct{ A int }{1},
|
|
||||||
"a: 1\n",
|
|
||||||
}, {
|
|
||||||
&struct{ A []int }{[]int{1, 2}},
|
|
||||||
"a:\n- 1\n- 2\n",
|
|
||||||
}, {
|
|
||||||
&struct{ A [2]int }{[2]int{1, 2}},
|
|
||||||
"a:\n- 1\n- 2\n",
|
|
||||||
}, {
|
|
||||||
&struct {
|
|
||||||
B int "a"
|
|
||||||
}{1},
|
|
||||||
"a: 1\n",
|
|
||||||
}, {
|
|
||||||
&struct{ A bool }{true},
|
|
||||||
"a: true\n",
|
|
||||||
},
|
|
||||||
|
|
||||||
// Conditional flag
|
|
||||||
{
|
|
||||||
&struct {
|
|
||||||
A int "a,omitempty"
|
|
||||||
B int "b,omitempty"
|
|
||||||
}{1, 0},
|
|
||||||
"a: 1\n",
|
|
||||||
}, {
|
|
||||||
&struct {
|
|
||||||
A int "a,omitempty"
|
|
||||||
B int "b,omitempty"
|
|
||||||
}{0, 0},
|
|
||||||
"{}\n",
|
|
||||||
}, {
|
|
||||||
&struct {
|
|
||||||
A *struct{ X, y int } "a,omitempty,flow"
|
|
||||||
}{&struct{ X, y int }{1, 2}},
|
|
||||||
"a: {x: 1}\n",
|
|
||||||
}, {
|
|
||||||
&struct {
|
|
||||||
A *struct{ X, y int } "a,omitempty,flow"
|
|
||||||
}{nil},
|
|
||||||
"{}\n",
|
|
||||||
}, {
|
|
||||||
&struct {
|
|
||||||
A *struct{ X, y int } "a,omitempty,flow"
|
|
||||||
}{&struct{ X, y int }{}},
|
|
||||||
"a: {x: 0}\n",
|
|
||||||
}, {
|
|
||||||
&struct {
|
|
||||||
A struct{ X, y int } "a,omitempty,flow"
|
|
||||||
}{struct{ X, y int }{1, 2}},
|
|
||||||
"a: {x: 1}\n",
|
|
||||||
}, {
|
|
||||||
&struct {
|
|
||||||
A struct{ X, y int } "a,omitempty,flow"
|
|
||||||
}{struct{ X, y int }{0, 1}},
|
|
||||||
"{}\n",
|
|
||||||
}, {
|
|
||||||
&struct {
|
|
||||||
A float64 "a,omitempty"
|
|
||||||
B float64 "b,omitempty"
|
|
||||||
}{1, 0},
|
|
||||||
"a: 1\n",
|
|
||||||
},
|
|
||||||
{
|
|
||||||
&struct {
|
|
||||||
T1 time.Time "t1,omitempty"
|
|
||||||
T2 time.Time "t2,omitempty"
|
|
||||||
T3 *time.Time "t3,omitempty"
|
|
||||||
T4 *time.Time "t4,omitempty"
|
|
||||||
}{
|
|
||||||
T2: time.Date(2018, 1, 9, 10, 40, 47, 0, time.UTC),
|
|
||||||
T4: newTime(time.Date(2098, 1, 9, 10, 40, 47, 0, time.UTC)),
|
|
||||||
},
|
|
||||||
"t2: 2018-01-09T10:40:47Z\nt4: 2098-01-09T10:40:47Z\n",
|
|
||||||
},
|
|
||||||
// Nil interface that implements Marshaler.
|
|
||||||
{
|
|
||||||
map[string]yaml.Marshaler{
|
|
||||||
"a": nil,
|
|
||||||
},
|
|
||||||
"a: null\n",
|
|
||||||
},
|
|
||||||
|
|
||||||
// Flow flag
|
|
||||||
{
|
|
||||||
&struct {
|
|
||||||
A []int "a,flow"
|
|
||||||
}{[]int{1, 2}},
|
|
||||||
"a: [1, 2]\n",
|
|
||||||
}, {
|
|
||||||
&struct {
|
|
||||||
A map[string]string "a,flow"
|
|
||||||
}{map[string]string{"b": "c", "d": "e"}},
|
|
||||||
"a: {b: c, d: e}\n",
|
|
||||||
}, {
|
|
||||||
&struct {
|
|
||||||
A struct {
|
|
||||||
B, D string
|
|
||||||
} "a,flow"
|
|
||||||
}{struct{ B, D string }{"c", "e"}},
|
|
||||||
"a: {b: c, d: e}\n",
|
|
||||||
},
|
|
||||||
|
|
||||||
// Unexported field
|
|
||||||
{
|
|
||||||
&struct {
|
|
||||||
u int
|
|
||||||
A int
|
|
||||||
}{0, 1},
|
|
||||||
"a: 1\n",
|
|
||||||
},
|
|
||||||
|
|
||||||
// Ignored field
|
|
||||||
{
|
|
||||||
&struct {
|
|
||||||
A int
|
|
||||||
B int "-"
|
|
||||||
}{1, 2},
|
|
||||||
"a: 1\n",
|
|
||||||
},
|
|
||||||
|
|
||||||
// Struct inlining
|
|
||||||
{
|
|
||||||
&struct {
|
|
||||||
A int
|
|
||||||
C inlineB `yaml:",inline"`
|
|
||||||
}{1, inlineB{2, inlineC{3}}},
|
|
||||||
"a: 1\nb: 2\nc: 3\n",
|
|
||||||
},
|
|
||||||
|
|
||||||
// Map inlining
|
|
||||||
{
|
|
||||||
&struct {
|
|
||||||
A int
|
|
||||||
C map[string]int `yaml:",inline"`
|
|
||||||
}{1, map[string]int{"b": 2, "c": 3}},
|
|
||||||
"a: 1\nb: 2\nc: 3\n",
|
|
||||||
},
|
|
||||||
|
|
||||||
// Duration
|
|
||||||
{
|
|
||||||
map[string]time.Duration{"a": 3 * time.Second},
|
|
||||||
"a: 3s\n",
|
|
||||||
},
|
|
||||||
|
|
||||||
// Issue #24: bug in map merging logic.
|
|
||||||
{
|
|
||||||
map[string]string{"a": "<foo>"},
|
|
||||||
"a: <foo>\n",
|
|
||||||
},
|
|
||||||
|
|
||||||
// Issue #34: marshal unsupported base 60 floats quoted for compatibility
|
|
||||||
// with old YAML 1.1 parsers.
|
|
||||||
{
|
|
||||||
map[string]string{"a": "1:1"},
|
|
||||||
"a: \"1:1\"\n",
|
|
||||||
},
|
|
||||||
|
|
||||||
// Binary data.
|
|
||||||
{
|
|
||||||
map[string]string{"a": "\x00"},
|
|
||||||
"a: \"\\0\"\n",
|
|
||||||
}, {
|
|
||||||
map[string]string{"a": "\x80\x81\x82"},
|
|
||||||
"a: !!binary gIGC\n",
|
|
||||||
}, {
|
|
||||||
map[string]string{"a": strings.Repeat("\x90", 54)},
|
|
||||||
"a: !!binary |\n " + strings.Repeat("kJCQ", 17) + "kJ\n CQ\n",
|
|
||||||
},
|
|
||||||
|
|
||||||
// Ordered maps.
|
|
||||||
{
|
|
||||||
&yaml.MapSlice{{"b", 2}, {"a", 1}, {"d", 4}, {"c", 3}, {"sub", yaml.MapSlice{{"e", 5}}}},
|
|
||||||
"b: 2\na: 1\nd: 4\nc: 3\nsub:\n e: 5\n",
|
|
||||||
},
|
|
||||||
|
|
||||||
// Encode unicode as utf-8 rather than in escaped form.
|
|
||||||
{
|
|
||||||
map[string]string{"a": "你好"},
|
|
||||||
"a: 你好\n",
|
|
||||||
},
|
|
||||||
|
|
||||||
// Support encoding.TextMarshaler.
|
|
||||||
{
|
|
||||||
map[string]net.IP{"a": net.IPv4(1, 2, 3, 4)},
|
|
||||||
"a: 1.2.3.4\n",
|
|
||||||
},
|
|
||||||
// time.Time gets a timestamp tag.
|
|
||||||
{
|
|
||||||
map[string]time.Time{"a": time.Date(2015, 2, 24, 18, 19, 39, 0, time.UTC)},
|
|
||||||
"a: 2015-02-24T18:19:39Z\n",
|
|
||||||
},
|
|
||||||
{
|
|
||||||
map[string]*time.Time{"a": newTime(time.Date(2015, 2, 24, 18, 19, 39, 0, time.UTC))},
|
|
||||||
"a: 2015-02-24T18:19:39Z\n",
|
|
||||||
},
|
|
||||||
{
|
|
||||||
// This is confirmed to be properly decoded in Python (libyaml) without a timestamp tag.
|
|
||||||
map[string]time.Time{"a": time.Date(2015, 2, 24, 18, 19, 39, 123456789, time.FixedZone("FOO", -3*60*60))},
|
|
||||||
"a: 2015-02-24T18:19:39.123456789-03:00\n",
|
|
||||||
},
|
|
||||||
// Ensure timestamp-like strings are quoted.
|
|
||||||
{
|
|
||||||
map[string]string{"a": "2015-02-24T18:19:39Z"},
|
|
||||||
"a: \"2015-02-24T18:19:39Z\"\n",
|
|
||||||
},
|
|
||||||
|
|
||||||
// Ensure strings containing ": " are quoted (reported as PR #43, but not reproducible).
|
|
||||||
{
|
|
||||||
map[string]string{"a": "b: c"},
|
|
||||||
"a: 'b: c'\n",
|
|
||||||
},
|
|
||||||
|
|
||||||
// Containing hash mark ('#') in string should be quoted
|
|
||||||
{
|
|
||||||
map[string]string{"a": "Hello #comment"},
|
|
||||||
"a: 'Hello #comment'\n",
|
|
||||||
},
|
|
||||||
{
|
|
||||||
map[string]string{"a": "你好 #comment"},
|
|
||||||
"a: '你好 #comment'\n",
|
|
||||||
},
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *S) TestMarshal(c *C) {
|
|
||||||
defer os.Setenv("TZ", os.Getenv("TZ"))
|
|
||||||
os.Setenv("TZ", "UTC")
|
|
||||||
for i, item := range marshalTests {
|
|
||||||
c.Logf("test %d: %q", i, item.data)
|
|
||||||
data, err := yaml.Marshal(item.value)
|
|
||||||
c.Assert(err, IsNil)
|
|
||||||
c.Assert(string(data), Equals, item.data)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *S) TestEncoderSingleDocument(c *C) {
|
|
||||||
for i, item := range marshalTests {
|
|
||||||
c.Logf("test %d. %q", i, item.data)
|
|
||||||
var buf bytes.Buffer
|
|
||||||
enc := yaml.NewEncoder(&buf)
|
|
||||||
err := enc.Encode(item.value)
|
|
||||||
c.Assert(err, Equals, nil)
|
|
||||||
err = enc.Close()
|
|
||||||
c.Assert(err, Equals, nil)
|
|
||||||
c.Assert(buf.String(), Equals, item.data)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *S) TestEncoderMultipleDocuments(c *C) {
|
|
||||||
var buf bytes.Buffer
|
|
||||||
enc := yaml.NewEncoder(&buf)
|
|
||||||
err := enc.Encode(map[string]string{"a": "b"})
|
|
||||||
c.Assert(err, Equals, nil)
|
|
||||||
err = enc.Encode(map[string]string{"c": "d"})
|
|
||||||
c.Assert(err, Equals, nil)
|
|
||||||
err = enc.Close()
|
|
||||||
c.Assert(err, Equals, nil)
|
|
||||||
c.Assert(buf.String(), Equals, "a: b\n---\nc: d\n")
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *S) TestEncoderWriteError(c *C) {
|
|
||||||
enc := yaml.NewEncoder(errorWriter{})
|
|
||||||
err := enc.Encode(map[string]string{"a": "b"})
|
|
||||||
c.Assert(err, ErrorMatches, `yaml: write error: some write error`) // Data not flushed yet
|
|
||||||
}
|
|
||||||
|
|
||||||
type errorWriter struct{}
|
|
||||||
|
|
||||||
func (errorWriter) Write([]byte) (int, error) {
|
|
||||||
return 0, fmt.Errorf("some write error")
|
|
||||||
}
|
|
||||||
|
|
||||||
var marshalErrorTests = []struct {
|
|
||||||
value interface{}
|
|
||||||
error string
|
|
||||||
panic string
|
|
||||||
}{{
|
|
||||||
value: &struct {
|
|
||||||
B int
|
|
||||||
inlineB ",inline"
|
|
||||||
}{1, inlineB{2, inlineC{3}}},
|
|
||||||
panic: `Duplicated key 'b' in struct struct \{ B int; .*`,
|
|
||||||
}, {
|
|
||||||
value: &struct {
|
|
||||||
A int
|
|
||||||
B map[string]int ",inline"
|
|
||||||
}{1, map[string]int{"a": 2}},
|
|
||||||
panic: `Can't have key "a" in inlined map; conflicts with struct field`,
|
|
||||||
}}
|
|
||||||
|
|
||||||
func (s *S) TestMarshalErrors(c *C) {
|
|
||||||
for _, item := range marshalErrorTests {
|
|
||||||
if item.panic != "" {
|
|
||||||
c.Assert(func() { yaml.Marshal(item.value) }, PanicMatches, item.panic)
|
|
||||||
} else {
|
|
||||||
_, err := yaml.Marshal(item.value)
|
|
||||||
c.Assert(err, ErrorMatches, item.error)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *S) TestMarshalTypeCache(c *C) {
|
|
||||||
var data []byte
|
|
||||||
var err error
|
|
||||||
func() {
|
|
||||||
type T struct{ A int }
|
|
||||||
data, err = yaml.Marshal(&T{})
|
|
||||||
c.Assert(err, IsNil)
|
|
||||||
}()
|
|
||||||
func() {
|
|
||||||
type T struct{ B int }
|
|
||||||
data, err = yaml.Marshal(&T{})
|
|
||||||
c.Assert(err, IsNil)
|
|
||||||
}()
|
|
||||||
c.Assert(string(data), Equals, "b: 0\n")
|
|
||||||
}
|
|
||||||
|
|
||||||
var marshalerTests = []struct {
|
|
||||||
data string
|
|
||||||
value interface{}
|
|
||||||
}{
|
|
||||||
{"_:\n hi: there\n", map[interface{}]interface{}{"hi": "there"}},
|
|
||||||
{"_:\n- 1\n- A\n", []interface{}{1, "A"}},
|
|
||||||
{"_: 10\n", 10},
|
|
||||||
{"_: null\n", nil},
|
|
||||||
{"_: BAR!\n", "BAR!"},
|
|
||||||
}
|
|
||||||
|
|
||||||
type marshalerType struct {
|
|
||||||
value interface{}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (o marshalerType) MarshalText() ([]byte, error) {
|
|
||||||
panic("MarshalText called on type with MarshalYAML")
|
|
||||||
}
|
|
||||||
|
|
||||||
func (o marshalerType) MarshalYAML() (interface{}, error) {
|
|
||||||
return o.value, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
type marshalerValue struct {
|
|
||||||
Field marshalerType "_"
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *S) TestMarshaler(c *C) {
|
|
||||||
for _, item := range marshalerTests {
|
|
||||||
obj := &marshalerValue{}
|
|
||||||
obj.Field.value = item.value
|
|
||||||
data, err := yaml.Marshal(obj)
|
|
||||||
c.Assert(err, IsNil)
|
|
||||||
c.Assert(string(data), Equals, string(item.data))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *S) TestMarshalerWholeDocument(c *C) {
|
|
||||||
obj := &marshalerType{}
|
|
||||||
obj.value = map[string]string{"hello": "world!"}
|
|
||||||
data, err := yaml.Marshal(obj)
|
|
||||||
c.Assert(err, IsNil)
|
|
||||||
c.Assert(string(data), Equals, "hello: world!\n")
|
|
||||||
}
|
|
||||||
|
|
||||||
type failingMarshaler struct{}
|
|
||||||
|
|
||||||
func (ft *failingMarshaler) MarshalYAML() (interface{}, error) {
|
|
||||||
return nil, failingErr
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *S) TestMarshalerError(c *C) {
|
|
||||||
_, err := yaml.Marshal(&failingMarshaler{})
|
|
||||||
c.Assert(err, Equals, failingErr)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *S) TestSortedOutput(c *C) {
|
|
||||||
order := []interface{}{
|
|
||||||
false,
|
|
||||||
true,
|
|
||||||
1,
|
|
||||||
uint(1),
|
|
||||||
1.0,
|
|
||||||
1.1,
|
|
||||||
1.2,
|
|
||||||
2,
|
|
||||||
uint(2),
|
|
||||||
2.0,
|
|
||||||
2.1,
|
|
||||||
"",
|
|
||||||
".1",
|
|
||||||
".2",
|
|
||||||
".a",
|
|
||||||
"1",
|
|
||||||
"2",
|
|
||||||
"a!10",
|
|
||||||
"a/0001",
|
|
||||||
"a/002",
|
|
||||||
"a/3",
|
|
||||||
"a/10",
|
|
||||||
"a/11",
|
|
||||||
"a/0012",
|
|
||||||
"a/100",
|
|
||||||
"a~10",
|
|
||||||
"ab/1",
|
|
||||||
"b/1",
|
|
||||||
"b/01",
|
|
||||||
"b/2",
|
|
||||||
"b/02",
|
|
||||||
"b/3",
|
|
||||||
"b/03",
|
|
||||||
"b1",
|
|
||||||
"b01",
|
|
||||||
"b3",
|
|
||||||
"c2.10",
|
|
||||||
"c10.2",
|
|
||||||
"d1",
|
|
||||||
"d7",
|
|
||||||
"d7abc",
|
|
||||||
"d12",
|
|
||||||
"d12a",
|
|
||||||
}
|
|
||||||
m := make(map[interface{}]int)
|
|
||||||
for _, k := range order {
|
|
||||||
m[k] = 1
|
|
||||||
}
|
|
||||||
data, err := yaml.Marshal(m)
|
|
||||||
c.Assert(err, IsNil)
|
|
||||||
out := "\n" + string(data)
|
|
||||||
last := 0
|
|
||||||
for i, k := range order {
|
|
||||||
repr := fmt.Sprint(k)
|
|
||||||
if s, ok := k.(string); ok {
|
|
||||||
if _, err = strconv.ParseFloat(repr, 32); s == "" || err == nil {
|
|
||||||
repr = `"` + repr + `"`
|
|
||||||
}
|
|
||||||
}
|
|
||||||
index := strings.Index(out, "\n"+repr+":")
|
|
||||||
if index == -1 {
|
|
||||||
c.Fatalf("%#v is not in the output: %#v", k, out)
|
|
||||||
}
|
|
||||||
if index < last {
|
|
||||||
c.Fatalf("%#v was generated before %#v: %q", k, order[i-1], out)
|
|
||||||
}
|
|
||||||
last = index
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func newTime(t time.Time) *time.Time {
|
|
||||||
return &t
|
|
||||||
}
|
|
41
vendor/gopkg.in/yaml.v2/example_embedded_test.go
generated
vendored
41
vendor/gopkg.in/yaml.v2/example_embedded_test.go
generated
vendored
@ -1,41 +0,0 @@
|
|||||||
package yaml_test
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"log"
|
|
||||||
|
|
||||||
"gopkg.in/yaml.v2"
|
|
||||||
)
|
|
||||||
|
|
||||||
// An example showing how to unmarshal embedded
|
|
||||||
// structs from YAML.
|
|
||||||
|
|
||||||
type StructA struct {
|
|
||||||
A string `yaml:"a"`
|
|
||||||
}
|
|
||||||
|
|
||||||
type StructB struct {
|
|
||||||
// Embedded structs are not treated as embedded in YAML by default. To do that,
|
|
||||||
// add the ",inline" annotation below
|
|
||||||
StructA `yaml:",inline"`
|
|
||||||
B string `yaml:"b"`
|
|
||||||
}
|
|
||||||
|
|
||||||
var data = `
|
|
||||||
a: a string from struct A
|
|
||||||
b: a string from struct B
|
|
||||||
`
|
|
||||||
|
|
||||||
func ExampleUnmarshal_embedded() {
|
|
||||||
var b StructB
|
|
||||||
|
|
||||||
err := yaml.Unmarshal([]byte(data), &b)
|
|
||||||
if err != nil {
|
|
||||||
log.Fatalf("cannot unmarshal data: %v", err)
|
|
||||||
}
|
|
||||||
fmt.Println(b.A)
|
|
||||||
fmt.Println(b.B)
|
|
||||||
// Output:
|
|
||||||
// a string from struct A
|
|
||||||
// a string from struct B
|
|
||||||
}
|
|
12
vendor/gopkg.in/yaml.v2/suite_test.go
generated
vendored
12
vendor/gopkg.in/yaml.v2/suite_test.go
generated
vendored
@ -1,12 +0,0 @@
|
|||||||
package yaml_test
|
|
||||||
|
|
||||||
import (
|
|
||||||
. "gopkg.in/check.v1"
|
|
||||||
"testing"
|
|
||||||
)
|
|
||||||
|
|
||||||
func Test(t *testing.T) { TestingT(t) }
|
|
||||||
|
|
||||||
type S struct{}
|
|
||||||
|
|
||||||
var _ = Suite(&S{})
|
|
7
vendor/modules.txt
vendored
Normal file
7
vendor/modules.txt
vendored
Normal file
@ -0,0 +1,7 @@
|
|||||||
|
# github.com/ulikunitz/xz v0.5.5
|
||||||
|
github.com/ulikunitz/xz
|
||||||
|
github.com/ulikunitz/xz/internal/xlog
|
||||||
|
github.com/ulikunitz/xz/lzma
|
||||||
|
github.com/ulikunitz/xz/internal/hash
|
||||||
|
# gopkg.in/yaml.v2 v2.2.2
|
||||||
|
gopkg.in/yaml.v2
|
10
vendor/vgo.list
vendored
10
vendor/vgo.list
vendored
@ -1,10 +0,0 @@
|
|||||||
# github.com/ulikunitz/xz v0.5.4
|
|
||||||
github.com/ulikunitz/xz
|
|
||||||
github.com/ulikunitz/xz/internal/hash
|
|
||||||
github.com/ulikunitz/xz/internal/randtxt
|
|
||||||
github.com/ulikunitz/xz/internal/xlog
|
|
||||||
github.com/ulikunitz/xz/lzma
|
|
||||||
# gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405
|
|
||||||
gopkg.in/check.v1
|
|
||||||
# gopkg.in/yaml.v2 v2.2.1
|
|
||||||
gopkg.in/yaml.v2
|
|
Loading…
Reference in New Issue
Block a user