diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/go13_bench_test.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/go13_bench_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..e76657e5ec3ec065e80fc4335cb5dffb92a98277
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/go13_bench_test.go
@@ -0,0 +1,58 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// +build go1.3
+
+package leveldb
+
+import (
+ "sync/atomic"
+ "testing"
+)
+
+func BenchmarkDBReadConcurrent(b *testing.B) {
+ p := openDBBench(b, false)
+ p.populate(b.N)
+ p.fill()
+ p.gc()
+ defer p.close()
+
+ b.ResetTimer()
+ b.SetBytes(116)
+
+ b.RunParallel(func(pb *testing.PB) {
+ iter := p.newIter()
+ defer iter.Release()
+ for pb.Next() && iter.Next() {
+ }
+ })
+}
+
+func BenchmarkDBReadConcurrent2(b *testing.B) {
+ p := openDBBench(b, false)
+ p.populate(b.N)
+ p.fill()
+ p.gc()
+ defer p.close()
+
+ b.ResetTimer()
+ b.SetBytes(116)
+
+ var dir uint32
+ b.RunParallel(func(pb *testing.PB) {
+ iter := p.newIter()
+ defer iter.Release()
+ if atomic.AddUint32(&dir, 1)%2 == 0 {
+ for pb.Next() && iter.Next() {
+ }
+ } else {
+ if pb.Next() && iter.Last() {
+ for pb.Next() && iter.Prev() {
+ }
+ }
+ }
+ })
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/gosnappy/snappy/decode.go b/Godeps/_workspace/src/github.com/syndtr/gosnappy/snappy/decode.go
new file mode 100644
index 0000000000000000000000000000000000000000..d93c1b9dbfd7cea5fe7b86520548181d3729fa94
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/gosnappy/snappy/decode.go
@@ -0,0 +1,124 @@
+// Copyright 2011 The Snappy-Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package snappy
+
+import (
+ "encoding/binary"
+ "errors"
+)
+
+// ErrCorrupt reports that the input is invalid.
+var ErrCorrupt = errors.New("snappy: corrupt input")
+
+// DecodedLen returns the length of the decoded block.
+func DecodedLen(src []byte) (int, error) {
+ v, _, err := decodedLen(src)
+ return v, err
+}
+
+// decodedLen returns the length of the decoded block and the number of bytes
+// that the length header occupied.
+func decodedLen(src []byte) (blockLen, headerLen int, err error) {
+ v, n := binary.Uvarint(src)
+ if n == 0 {
+ return 0, 0, ErrCorrupt
+ }
+ if uint64(int(v)) != v {
+ return 0, 0, errors.New("snappy: decoded block is too large")
+ }
+ return int(v), n, nil
+}
+
+// Decode returns the decoded form of src. The returned slice may be a sub-
+// slice of dst if dst was large enough to hold the entire decoded block.
+// Otherwise, a newly allocated slice will be returned.
+// It is valid to pass a nil dst.
+func Decode(dst, src []byte) ([]byte, error) {
+ dLen, s, err := decodedLen(src)
+ if err != nil {
+ return nil, err
+ }
+ if len(dst) < dLen {
+ dst = make([]byte, dLen)
+ }
+
+ var d, offset, length int
+ for s < len(src) {
+ switch src[s] & 0x03 {
+ case tagLiteral:
+ x := uint(src[s] >> 2)
+ switch {
+ case x < 60:
+ s += 1
+ case x == 60:
+ s += 2
+ if s > len(src) {
+ return nil, ErrCorrupt
+ }
+ x = uint(src[s-1])
+ case x == 61:
+ s += 3
+ if s > len(src) {
+ return nil, ErrCorrupt
+ }
+ x = uint(src[s-2]) | uint(src[s-1])<<8
+ case x == 62:
+ s += 4
+ if s > len(src) {
+ return nil, ErrCorrupt
+ }
+ x = uint(src[s-3]) | uint(src[s-2])<<8 | uint(src[s-1])<<16
+ case x == 63:
+ s += 5
+ if s > len(src) {
+ return nil, ErrCorrupt
+ }
+ x = uint(src[s-4]) | uint(src[s-3])<<8 | uint(src[s-2])<<16 | uint(src[s-1])<<24
+ }
+ length = int(x + 1)
+ if length <= 0 {
+ return nil, errors.New("snappy: unsupported literal length")
+ }
+ if length > len(dst)-d || length > len(src)-s {
+ return nil, ErrCorrupt
+ }
+ copy(dst[d:], src[s:s+length])
+ d += length
+ s += length
+ continue
+
+ case tagCopy1:
+ s += 2
+ if s > len(src) {
+ return nil, ErrCorrupt
+ }
+ length = 4 + int(src[s-2])>>2&0x7
+ offset = int(src[s-2])&0xe0<<3 | int(src[s-1])
+
+ case tagCopy2:
+ s += 3
+ if s > len(src) {
+ return nil, ErrCorrupt
+ }
+ length = 1 + int(src[s-3])>>2
+ offset = int(src[s-2]) | int(src[s-1])<<8
+
+ case tagCopy4:
+ return nil, errors.New("snappy: unsupported COPY_4 tag")
+ }
+
+ end := d + length
+ if offset > d || end > len(dst) {
+ return nil, ErrCorrupt
+ }
+ for ; d < end; d++ {
+ dst[d] = dst[d-offset]
+ }
+ }
+ if d != dLen {
+ return nil, ErrCorrupt
+ }
+ return dst[:d], nil
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/gosnappy/snappy/encode.go b/Godeps/_workspace/src/github.com/syndtr/gosnappy/snappy/encode.go
new file mode 100644
index 0000000000000000000000000000000000000000..b2371db11c8f0c15a4be374eed72f96bd42b864c
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/gosnappy/snappy/encode.go
@@ -0,0 +1,174 @@
+// Copyright 2011 The Snappy-Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package snappy
+
+import (
+ "encoding/binary"
+)
+
+// We limit how far copy back-references can go, the same as the C++ code.
+const maxOffset = 1 << 15
+
+// emitLiteral writes a literal chunk and returns the number of bytes written.
+func emitLiteral(dst, lit []byte) int {
+ i, n := 0, uint(len(lit)-1)
+ switch {
+ case n < 60:
+ dst[0] = uint8(n)<<2 | tagLiteral
+ i = 1
+ case n < 1<<8:
+ dst[0] = 60<<2 | tagLiteral
+ dst[1] = uint8(n)
+ i = 2
+ case n < 1<<16:
+ dst[0] = 61<<2 | tagLiteral
+ dst[1] = uint8(n)
+ dst[2] = uint8(n >> 8)
+ i = 3
+ case n < 1<<24:
+ dst[0] = 62<<2 | tagLiteral
+ dst[1] = uint8(n)
+ dst[2] = uint8(n >> 8)
+ dst[3] = uint8(n >> 16)
+ i = 4
+ case int64(n) < 1<<32:
+ dst[0] = 63<<2 | tagLiteral
+ dst[1] = uint8(n)
+ dst[2] = uint8(n >> 8)
+ dst[3] = uint8(n >> 16)
+ dst[4] = uint8(n >> 24)
+ i = 5
+ default:
+ panic("snappy: source buffer is too long")
+ }
+ if copy(dst[i:], lit) != len(lit) {
+ panic("snappy: destination buffer is too short")
+ }
+ return i + len(lit)
+}
+
+// emitCopy writes a copy chunk and returns the number of bytes written.
+func emitCopy(dst []byte, offset, length int) int {
+ i := 0
+ for length > 0 {
+ x := length - 4
+ if 0 <= x && x < 1<<3 && offset < 1<<11 {
+ dst[i+0] = uint8(offset>>8)&0x07<<5 | uint8(x)<<2 | tagCopy1
+ dst[i+1] = uint8(offset)
+ i += 2
+ break
+ }
+
+ x = length
+ if x > 1<<6 {
+ x = 1 << 6
+ }
+ dst[i+0] = uint8(x-1)<<2 | tagCopy2
+ dst[i+1] = uint8(offset)
+ dst[i+2] = uint8(offset >> 8)
+ i += 3
+ length -= x
+ }
+ return i
+}
+
+// Encode returns the encoded form of src. The returned slice may be a sub-
+// slice of dst if dst was large enough to hold the entire encoded block.
+// Otherwise, a newly allocated slice will be returned.
+// It is valid to pass a nil dst.
+func Encode(dst, src []byte) ([]byte, error) {
+ if n := MaxEncodedLen(len(src)); len(dst) < n {
+ dst = make([]byte, n)
+ }
+
+ // The block starts with the varint-encoded length of the decompressed bytes.
+ d := binary.PutUvarint(dst, uint64(len(src)))
+
+ // Return early if src is short.
+ if len(src) <= 4 {
+ if len(src) != 0 {
+ d += emitLiteral(dst[d:], src)
+ }
+ return dst[:d], nil
+ }
+
+ // Initialize the hash table. Its size ranges from 1<<8 to 1<<14 inclusive.
+ const maxTableSize = 1 << 14
+ shift, tableSize := uint(32-8), 1<<8
+ for tableSize < maxTableSize && tableSize < len(src) {
+ shift--
+ tableSize *= 2
+ }
+ var table [maxTableSize]int
+
+ // Iterate over the source bytes.
+ var (
+ s int // The iterator position.
+ t int // The last position with the same hash as s.
+ lit int // The start position of any pending literal bytes.
+ )
+ for s+3 < len(src) {
+ // Update the hash table.
+ b0, b1, b2, b3 := src[s], src[s+1], src[s+2], src[s+3]
+ h := uint32(b0) | uint32(b1)<<8 | uint32(b2)<<16 | uint32(b3)<<24
+ p := &table[(h*0x1e35a7bd)>>shift]
+ // We need to to store values in [-1, inf) in table. To save
+ // some initialization time, (re)use the table's zero value
+ // and shift the values against this zero: add 1 on writes,
+ // subtract 1 on reads.
+ t, *p = *p-1, s+1
+ // If t is invalid or src[s:s+4] differs from src[t:t+4], accumulate a literal byte.
+ if t < 0 || s-t >= maxOffset || b0 != src[t] || b1 != src[t+1] || b2 != src[t+2] || b3 != src[t+3] {
+ s++
+ continue
+ }
+ // Otherwise, we have a match. First, emit any pending literal bytes.
+ if lit != s {
+ d += emitLiteral(dst[d:], src[lit:s])
+ }
+ // Extend the match to be as long as possible.
+ s0 := s
+ s, t = s+4, t+4
+ for s < len(src) && src[s] == src[t] {
+ s++
+ t++
+ }
+ // Emit the copied bytes.
+ d += emitCopy(dst[d:], s-t, s-s0)
+ lit = s
+ }
+
+ // Emit any final pending literal bytes and return.
+ if lit != len(src) {
+ d += emitLiteral(dst[d:], src[lit:])
+ }
+ return dst[:d], nil
+}
+
+// MaxEncodedLen returns the maximum length of a snappy block, given its
+// uncompressed length.
+func MaxEncodedLen(srcLen int) int {
+ // Compressed data can be defined as:
+ // compressed := item* literal*
+ // item := literal* copy
+ //
+ // The trailing literal sequence has a space blowup of at most 62/60
+ // since a literal of length 60 needs one tag byte + one extra byte
+ // for length information.
+ //
+ // Item blowup is trickier to measure. Suppose the "copy" op copies
+ // 4 bytes of data. Because of a special check in the encoding code,
+ // we produce a 4-byte copy only if the offset is < 65536. Therefore
+ // the copy op takes 3 bytes to encode, and this type of item leads
+ // to at most the 62/60 blowup for representing literals.
+ //
+ // Suppose the "copy" op copies 5 bytes of data. If the offset is big
+ // enough, it will take 5 bytes to encode the copy op. Therefore the
+ // worst case here is a one-byte literal followed by a five-byte copy.
+ // That is, 6 bytes of input turn into 7 bytes of "compressed" data.
+ //
+ // This last factor dominates the blowup, so the final estimate is:
+ return 32 + srcLen + srcLen/6
+}
diff --git a/Godeps/_workspace/src/github.com/syndtr/gosnappy/snappy/snappy.go b/Godeps/_workspace/src/github.com/syndtr/gosnappy/snappy/snappy.go
new file mode 100644
index 0000000000000000000000000000000000000000..2f1b790d0b7170df134cdf3f95786120a1f54dae
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/gosnappy/snappy/snappy.go
@@ -0,0 +1,38 @@
+// Copyright 2011 The Snappy-Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package snappy implements the snappy block-based compression format.
+// It aims for very high speeds and reasonable compression.
+//
+// The C++ snappy implementation is at http://code.google.com/p/snappy/
+package snappy
+
+/*
+Each encoded block begins with the varint-encoded length of the decoded data,
+followed by a sequence of chunks. Chunks begin and end on byte boundaries. The
+first byte of each chunk is broken into its 2 least and 6 most significant bits
+called l and m: l ranges in [0, 4) and m ranges in [0, 64). l is the chunk tag.
+Zero means a literal tag. All other values mean a copy tag.
+
+For literal tags:
+ - If m < 60, the next 1 + m bytes are literal bytes.
+ - Otherwise, let n be the little-endian unsigned integer denoted by the next
+ m - 59 bytes. The next 1 + n bytes after that are literal bytes.
+
+For copy tags, length bytes are copied from offset bytes ago, in the style of
+Lempel-Ziv compression algorithms. In particular:
+ - For l == 1, the offset ranges in [0, 1<<11) and the length in [4, 12).
+ The length is 4 + the low 3 bits of m. The high 3 bits of m form bits 8-10
+ of the offset. The next byte is bits 0-7 of the offset.
+ - For l == 2, the offset ranges in [0, 1<<16) and the length in [1, 65).
+ The length is 1 + m. The offset is the little-endian unsigned integer
+ denoted by the next 2 bytes.
+ - For l == 3, this tag is a legacy format that is no longer supported.
+*/
+const (
+ tagLiteral = 0x00
+ tagCopy1 = 0x01
+ tagCopy2 = 0x02
+ tagCopy4 = 0x03
+)
diff --git a/Godeps/_workspace/src/github.com/syndtr/gosnappy/snappy/snappy_test.go b/Godeps/_workspace/src/github.com/syndtr/gosnappy/snappy/snappy_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..7ba839244e9bb8b75ec49b2083eb428549190784
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/syndtr/gosnappy/snappy/snappy_test.go
@@ -0,0 +1,261 @@
+// Copyright 2011 The Snappy-Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package snappy
+
+import (
+ "bytes"
+ "flag"
+ "fmt"
+ "io"
+ "io/ioutil"
+ "math/rand"
+ "net/http"
+ "os"
+ "path/filepath"
+ "strings"
+ "testing"
+)
+
+var download = flag.Bool("download", false, "If true, download any missing files before running benchmarks")
+
+func roundtrip(b, ebuf, dbuf []byte) error {
+ e, err := Encode(ebuf, b)
+ if err != nil {
+ return fmt.Errorf("encoding error: %v", err)
+ }
+ d, err := Decode(dbuf, e)
+ if err != nil {
+ return fmt.Errorf("decoding error: %v", err)
+ }
+ if !bytes.Equal(b, d) {
+ return fmt.Errorf("roundtrip mismatch:\n\twant %v\n\tgot %v", b, d)
+ }
+ return nil
+}
+
+func TestEmpty(t *testing.T) {
+ if err := roundtrip(nil, nil, nil); err != nil {
+ t.Fatal(err)
+ }
+}
+
+func TestSmallCopy(t *testing.T) {
+ for _, ebuf := range [][]byte{nil, make([]byte, 20), make([]byte, 64)} {
+ for _, dbuf := range [][]byte{nil, make([]byte, 20), make([]byte, 64)} {
+ for i := 0; i < 32; i++ {
+ s := "aaaa" + strings.Repeat("b", i) + "aaaabbbb"
+ if err := roundtrip([]byte(s), ebuf, dbuf); err != nil {
+ t.Errorf("len(ebuf)=%d, len(dbuf)=%d, i=%d: %v", len(ebuf), len(dbuf), i, err)
+ }
+ }
+ }
+ }
+}
+
+func TestSmallRand(t *testing.T) {
+ rand.Seed(27354294)
+ for n := 1; n < 20000; n += 23 {
+ b := make([]byte, n)
+ for i, _ := range b {
+ b[i] = uint8(rand.Uint32())
+ }
+ if err := roundtrip(b, nil, nil); err != nil {
+ t.Fatal(err)
+ }
+ }
+}
+
+func TestSmallRegular(t *testing.T) {
+ for n := 1; n < 20000; n += 23 {
+ b := make([]byte, n)
+ for i, _ := range b {
+ b[i] = uint8(i%10 + 'a')
+ }
+ if err := roundtrip(b, nil, nil); err != nil {
+ t.Fatal(err)
+ }
+ }
+}
+
+func benchDecode(b *testing.B, src []byte) {
+ encoded, err := Encode(nil, src)
+ if err != nil {
+ b.Fatal(err)
+ }
+ // Bandwidth is in amount of uncompressed data.
+ b.SetBytes(int64(len(src)))
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ Decode(src, encoded)
+ }
+}
+
+func benchEncode(b *testing.B, src []byte) {
+ // Bandwidth is in amount of uncompressed data.
+ b.SetBytes(int64(len(src)))
+ dst := make([]byte, MaxEncodedLen(len(src)))
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ Encode(dst, src)
+ }
+}
+
+func readFile(b *testing.B, filename string) []byte {
+ src, err := ioutil.ReadFile(filename)
+ if err != nil {
+ b.Fatalf("failed reading %s: %s", filename, err)
+ }
+ if len(src) == 0 {
+ b.Fatalf("%s has zero length", filename)
+ }
+ return src
+}
+
+// expand returns a slice of length n containing repeated copies of src.
+func expand(src []byte, n int) []byte {
+ dst := make([]byte, n)
+ for x := dst; len(x) > 0; {
+ i := copy(x, src)
+ x = x[i:]
+ }
+ return dst
+}
+
+func benchWords(b *testing.B, n int, decode bool) {
+ // Note: the file is OS-language dependent so the resulting values are not
+ // directly comparable for non-US-English OS installations.
+ data := expand(readFile(b, "/usr/share/dict/words"), n)
+ if decode {
+ benchDecode(b, data)
+ } else {
+ benchEncode(b, data)
+ }
+}
+
+func BenchmarkWordsDecode1e3(b *testing.B) { benchWords(b, 1e3, true) }
+func BenchmarkWordsDecode1e4(b *testing.B) { benchWords(b, 1e4, true) }
+func BenchmarkWordsDecode1e5(b *testing.B) { benchWords(b, 1e5, true) }
+func BenchmarkWordsDecode1e6(b *testing.B) { benchWords(b, 1e6, true) }
+func BenchmarkWordsEncode1e3(b *testing.B) { benchWords(b, 1e3, false) }
+func BenchmarkWordsEncode1e4(b *testing.B) { benchWords(b, 1e4, false) }
+func BenchmarkWordsEncode1e5(b *testing.B) { benchWords(b, 1e5, false) }
+func BenchmarkWordsEncode1e6(b *testing.B) { benchWords(b, 1e6, false) }
+
+// testFiles' values are copied directly from
+// https://code.google.com/p/snappy/source/browse/trunk/snappy_unittest.cc.
+// The label field is unused in snappy-go.
+var testFiles = []struct {
+ label string
+ filename string
+}{
+ {"html", "html"},
+ {"urls", "urls.10K"},
+ {"jpg", "house.jpg"},
+ {"pdf", "mapreduce-osdi-1.pdf"},
+ {"html4", "html_x_4"},
+ {"cp", "cp.html"},
+ {"c", "fields.c"},
+ {"lsp", "grammar.lsp"},
+ {"xls", "kennedy.xls"},
+ {"txt1", "alice29.txt"},
+ {"txt2", "asyoulik.txt"},
+ {"txt3", "lcet10.txt"},
+ {"txt4", "plrabn12.txt"},
+ {"bin", "ptt5"},
+ {"sum", "sum"},
+ {"man", "xargs.1"},
+ {"pb", "geo.protodata"},
+ {"gaviota", "kppkn.gtb"},
+}
+
+// The test data files are present at this canonical URL.
+const baseURL = "https://snappy.googlecode.com/svn/trunk/testdata/"
+
+func downloadTestdata(basename string) (errRet error) {
+ filename := filepath.Join("testdata", basename)
+ f, err := os.Create(filename)
+ if err != nil {
+ return fmt.Errorf("failed to create %s: %s", filename, err)
+ }
+ defer f.Close()
+ defer func() {
+ if errRet != nil {
+ os.Remove(filename)
+ }
+ }()
+ resp, err := http.Get(baseURL + basename)
+ if err != nil {
+ return fmt.Errorf("failed to download %s: %s", baseURL+basename, err)
+ }
+ defer resp.Body.Close()
+ _, err = io.Copy(f, resp.Body)
+ if err != nil {
+ return fmt.Errorf("failed to write %s: %s", filename, err)
+ }
+ return nil
+}
+
+func benchFile(b *testing.B, n int, decode bool) {
+ filename := filepath.Join("testdata", testFiles[n].filename)
+ if stat, err := os.Stat(filename); err != nil || stat.Size() == 0 {
+ if !*download {
+ b.Fatal("test data not found; skipping benchmark without the -download flag")
+ }
+ // Download the official snappy C++ implementation reference test data
+ // files for benchmarking.
+ if err := os.Mkdir("testdata", 0777); err != nil && !os.IsExist(err) {
+ b.Fatalf("failed to create testdata: %s", err)
+ }
+ for _, tf := range testFiles {
+ if err := downloadTestdata(tf.filename); err != nil {
+ b.Fatalf("failed to download testdata: %s", err)
+ }
+ }
+ }
+ data := readFile(b, filename)
+ if decode {
+ benchDecode(b, data)
+ } else {
+ benchEncode(b, data)
+ }
+}
+
+// Naming convention is kept similar to what snappy's C++ implementation uses.
+func Benchmark_UFlat0(b *testing.B) { benchFile(b, 0, true) }
+func Benchmark_UFlat1(b *testing.B) { benchFile(b, 1, true) }
+func Benchmark_UFlat2(b *testing.B) { benchFile(b, 2, true) }
+func Benchmark_UFlat3(b *testing.B) { benchFile(b, 3, true) }
+func Benchmark_UFlat4(b *testing.B) { benchFile(b, 4, true) }
+func Benchmark_UFlat5(b *testing.B) { benchFile(b, 5, true) }
+func Benchmark_UFlat6(b *testing.B) { benchFile(b, 6, true) }
+func Benchmark_UFlat7(b *testing.B) { benchFile(b, 7, true) }
+func Benchmark_UFlat8(b *testing.B) { benchFile(b, 8, true) }
+func Benchmark_UFlat9(b *testing.B) { benchFile(b, 9, true) }
+func Benchmark_UFlat10(b *testing.B) { benchFile(b, 10, true) }
+func Benchmark_UFlat11(b *testing.B) { benchFile(b, 11, true) }
+func Benchmark_UFlat12(b *testing.B) { benchFile(b, 12, true) }
+func Benchmark_UFlat13(b *testing.B) { benchFile(b, 13, true) }
+func Benchmark_UFlat14(b *testing.B) { benchFile(b, 14, true) }
+func Benchmark_UFlat15(b *testing.B) { benchFile(b, 15, true) }
+func Benchmark_UFlat16(b *testing.B) { benchFile(b, 16, true) }
+func Benchmark_UFlat17(b *testing.B) { benchFile(b, 17, true) }
+func Benchmark_ZFlat0(b *testing.B) { benchFile(b, 0, false) }
+func Benchmark_ZFlat1(b *testing.B) { benchFile(b, 1, false) }
+func Benchmark_ZFlat2(b *testing.B) { benchFile(b, 2, false) }
+func Benchmark_ZFlat3(b *testing.B) { benchFile(b, 3, false) }
+func Benchmark_ZFlat4(b *testing.B) { benchFile(b, 4, false) }
+func Benchmark_ZFlat5(b *testing.B) { benchFile(b, 5, false) }
+func Benchmark_ZFlat6(b *testing.B) { benchFile(b, 6, false) }
+func Benchmark_ZFlat7(b *testing.B) { benchFile(b, 7, false) }
+func Benchmark_ZFlat8(b *testing.B) { benchFile(b, 8, false) }
+func Benchmark_ZFlat9(b *testing.B) { benchFile(b, 9, false) }
+func Benchmark_ZFlat10(b *testing.B) { benchFile(b, 10, false) }
+func Benchmark_ZFlat11(b *testing.B) { benchFile(b, 11, false) }
+func Benchmark_ZFlat12(b *testing.B) { benchFile(b, 12, false) }
+func Benchmark_ZFlat13(b *testing.B) { benchFile(b, 13, false) }
+func Benchmark_ZFlat14(b *testing.B) { benchFile(b, 14, false) }
+func Benchmark_ZFlat15(b *testing.B) { benchFile(b, 15, false) }
+func Benchmark_ZFlat16(b *testing.B) { benchFile(b, 16, false) }
+func Benchmark_ZFlat17(b *testing.B) { benchFile(b, 17, false) }
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/config/tendermint/genesis.json b/Godeps/_workspace/src/github.com/tendermint/tendermint/config/tendermint/genesis.json
new file mode 100644
index 0000000000000000000000000000000000000000..eca00696edb4414df42fe6770cc23cde5a758529
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/config/tendermint/genesis.json
@@ -0,0 +1,75 @@
+{
+ "chain_id": "tendermint_testnet_11.c",
+ "accounts": [
+ {
+ "address": "9FCBA7F840A0BFEBBE755E853C9947270A912D04",
+ "amount": 1991999998000000
+ },
+ {
+ "address": "964B1493BBE3312278B7DEB94C39149F7899A345",
+ "amount": 100000000000000
+ },
+ {
+ "address": "B9FA4AB462B9C6BF6A62DB4AE77C9E7087209A04",
+ "amount": 1000000000000
+ },
+ {
+ "address": "F171824590D69386F709E7B6704B369C5A370D60",
+ "amount": 1000000000000
+ },
+ {
+ "address": "56EFE746A13D9A6054AC89C3E2A361C2DB8B9EAE",
+ "amount": 1000000000000
+ },
+ {
+ "address": "7C2E032D8407EDF66A04D88CF0E1D9B15D98AE2D",
+ "amount": 1000000000000
+ },
+ {
+ "address": "636EF5823E082AD66EBC203FD4DFB1031F0C61CA",
+ "amount": 1000000000000
+ },
+ {
+ "address": "9008419E6351360A59B124E707E4CA2A5BFB9BE6",
+ "amount": 1000000000000
+ },
+ {
+ "address": "C78F48919B8A4030AD3E5ED643F8D2302E41953D",
+ "amount": 1000000000000
+ },
+ {
+ "address": "5290AC90CE2422DDC3F91F6A246F7E3C542EA51A",
+ "amount": 1000000000000
+ },
+ {
+ "address": "A88A61069B6660F30F65E8786AFDD4F1D8F625E9",
+ "amount": 1000000
+ },
+ {
+ "address": "EE2EE9247973B4AFC3867CFE5F415410AC251B61",
+ "amount": 1000000
+ }
+ ],
+ "validators": [
+ {
+ "pub_key": [1, "178EC6008A4364508979C70CBF100BD4BCBAA12DDE6251F5F486B4FD09014F06"],
+ "amount": 100000000000
+ },
+ {
+ "pub_key": [1, "2A77777CC51467DE42350D4A8F34720D527734189BE64C7A930DD169E1FED3C6"],
+ "amount": 100000000000
+ },
+ {
+ "pub_key": [1, "3718E69D09B11B3AD3FA31AEF07EC416D2AEED241CACE7B0F30AE9803FFB0F08"],
+ "amount": 100000000000
+ },
+ {
+ "pub_key": [1, "C6B0440DEACD1E4CF1C736CEB8E38E788B700BA2B2045A55CB657A455CF5F889"],
+ "amount": 100000000000
+ },
+ {
+ "pub_key": [1, "3BA1190D54F91EFBF8B0125F7EC116AD4BA2894B6EE38564A5D5FD3230D91F7B"],
+ "amount": 100000000000
+ }
+ ]
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/state_test.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/state_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..a3d8b3ae85065f2a3afd35c5cc69a3ddd87fcabc
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/state_test.go
@@ -0,0 +1,1177 @@
+package consensus
+
+import (
+ "bytes"
+ "fmt"
+ "testing"
+ "time"
+
+ _ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/config/tendermint_test"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/events"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+)
+
+/*
+
+ProposeSuite
+x * TestEnterProposeNoValidator - timeout into prevote round
+x * TestEnterPropose - finish propose without timing out (we have the proposal)
+x * TestBadProposal - 2 vals, bad proposal (bad block state hash), should prevote and precommit nil
+FullRoundSuite
+x * TestFullRound1 - 1 val, full successful round
+x * TestFullRoundNil - 1 val, full round of nil
+x * TestFullRound2 - 2 vals, both required for fuill round
+LockSuite
+x * TestLockNoPOL - 2 vals, 4 rounds. one val locked, precommits nil every round except first.
+x * TestLockPOLRelock - 4 vals, one precommits, other 3 polka at next round, so we unlock and precomit the polka
+x * TestLockPOLUnlock - 4 vals, one precommits, other 3 polka nil at next round, so we unlock and precomit nil
+x * TestLockPOLSafety1 - 4 vals. We shouldn't change lock based on polka at earlier round
+x * TestLockPOLSafety2 - 4 vals. After unlocking, we shouldn't relock based on polka at earlier round
+ * TestNetworkLock - once +1/3 precommits, network should be locked
+ * TestNetworkLockPOL - once +1/3 precommits, the block with more recent polka is committed
+SlashingSuite
+x * TestSlashingPrevotes - a validator prevoting twice in a round gets slashed
+x * TestSlashingPrecommits - a validator precomitting twice in a round gets slashed
+CatchupSuite
+ * TestCatchup - if we might be behind and we've seen any 2/3 prevotes, round skip to new round, precommit, or prevote
+HaltSuite
+x * TestHalt1 - if we see +2/3 precommits after timing out into new round, we should still commit
+
+*/
+
+//----------------------------------------------------------------------------------------------------
+// ProposeSuite
+
+func init() {
+ fmt.Println("")
+ timeoutPropose = 1000 * time.Millisecond
+}
+
+// a non-validator should timeout into the prevote round
+func TestEnterProposeNoPrivValidator(t *testing.T) {
+ css, _ := simpleConsensusState(1)
+ cs := css[0]
+ cs.SetPrivValidator(nil)
+
+ timeoutChan := make(chan struct{})
+ evsw := events.NewEventSwitch()
+ evsw.OnStart()
+ evsw.AddListenerForEvent("tester", types.EventStringTimeoutPropose(), func(data types.EventData) {
+ timeoutChan <- struct{}{}
+ })
+ cs.SetFireable(evsw)
+
+ // starts a go routine for EnterPropose
+ cs.EnterNewRound(cs.Height, 0, false)
+
+ // go to prevote
+ <-cs.NewStepCh()
+
+ // if we're not a validator, EnterPropose should timeout
+ select {
+ case rs := <-cs.NewStepCh():
+ log.Info(rs.String())
+ t.Fatal("Expected EnterPropose to timeout")
+ case <-timeoutChan:
+ rs := cs.GetRoundState()
+ if rs.Proposal != nil {
+ t.Error("Expected to make no proposal, since no privValidator")
+ }
+ break
+ }
+}
+
+// a validator should not timeout of the prevote round (TODO: unless the block is really big!)
+func TestEnterPropose(t *testing.T) {
+ css, _ := simpleConsensusState(1)
+ cs := css[0]
+
+ timeoutChan := make(chan struct{})
+ evsw := events.NewEventSwitch()
+ evsw.OnStart()
+ evsw.AddListenerForEvent("tester", types.EventStringTimeoutPropose(), func(data types.EventData) {
+ timeoutChan <- struct{}{}
+ })
+ cs.SetFireable(evsw)
+
+ // starts a go routine for EnterPropose
+ cs.EnterNewRound(cs.Height, 0, false)
+
+ // go to prevote
+ <-cs.NewStepCh()
+
+ // if we are a validator, we expect it not to timeout
+ select {
+ case <-cs.NewStepCh():
+ rs := cs.GetRoundState()
+
+ // Check that Proposal, ProposalBlock, ProposalBlockParts are set.
+ if rs.Proposal == nil {
+ t.Error("rs.Proposal should be set")
+ }
+ if rs.ProposalBlock == nil {
+ t.Error("rs.ProposalBlock should be set")
+ }
+ if rs.ProposalBlockParts.Total() == 0 {
+ t.Error("rs.ProposalBlockParts should be set")
+ }
+ break
+ case <-timeoutChan:
+ t.Fatal("Expected EnterPropose not to timeout")
+ }
+}
+
+func TestBadProposal(t *testing.T) {
+ css, privVals := simpleConsensusState(2)
+ cs1, cs2 := css[0], css[1]
+ cs1.newStepCh = make(chan *RoundState) // so it blocks
+
+ timeoutChan := make(chan struct{})
+ evsw := events.NewEventSwitch()
+ evsw.OnStart()
+ evsw.AddListenerForEvent("tester", types.EventStringTimeoutPropose(), func(data types.EventData) {
+ timeoutChan <- struct{}{}
+ })
+ evsw.AddListenerForEvent("tester", types.EventStringTimeoutWait(), func(data types.EventData) {
+ timeoutChan <- struct{}{}
+ })
+ cs1.SetFireable(evsw)
+
+ // make the second validator the proposer
+ propBlock := changeProposer(t, cs1, cs2)
+
+ // make the block bad by tampering with statehash
+ stateHash := propBlock.StateHash
+ stateHash[0] = byte((stateHash[0] + 1) % 255)
+ propBlock.StateHash = stateHash
+ propBlockParts := propBlock.MakePartSet()
+ proposal := types.NewProposal(cs2.Height, cs2.Round, propBlockParts.Header(), cs2.Votes.POLRound())
+ if err := cs2.privValidator.SignProposal(cs2.state.ChainID, proposal); err != nil {
+ t.Fatal("failed to sign bad proposal", err)
+ }
+
+ // start round
+ cs1.EnterNewRound(cs1.Height, 0, false)
+
+ // now we're on a new round and not the proposer
+ <-cs1.NewStepCh()
+ // so set the proposal block (and fix voting power)
+ cs1.mtx.Lock()
+ cs1.Proposal, cs1.ProposalBlock, cs1.ProposalBlockParts = proposal, propBlock, propBlockParts
+ fixVotingPower(t, cs1, privVals[1].Address)
+ cs1.mtx.Unlock()
+ // and wait for timeout
+ <-timeoutChan
+
+ // go to prevote, prevote for nil (proposal is bad)
+ <-cs1.NewStepCh()
+ validatePrevote(t, cs1, 0, privVals[0], nil)
+
+ // add bad prevote from cs2. we should precommit nil
+ signAddVoteToFrom(types.VoteTypePrevote, cs1, cs2, propBlock.Hash(), propBlock.MakePartSet().Header())
+ _, _, _ = <-cs1.NewStepCh(), <-timeoutChan, <-cs1.NewStepCh()
+ validatePrecommit(t, cs1, 0, 0, privVals[0], nil, nil)
+ signAddVoteToFrom(types.VoteTypePrecommit, cs1, cs2, propBlock.Hash(), propBlock.MakePartSet().Header())
+}
+
+//----------------------------------------------------------------------------------------------------
+// FulLRoundSuite
+
+// propose, prevote, and precommit a block
+func TestFullRound1(t *testing.T) {
+ css, privVals := simpleConsensusState(1)
+ cs := css[0]
+
+ // starts a go routine for EnterPropose
+ cs.EnterNewRound(cs.Height, 0, false)
+ // wait to finish propose and prevote
+ _, _ = <-cs.NewStepCh(), <-cs.NewStepCh()
+
+ // we should now be in precommit
+ // verify our prevote is there
+ cs.mtx.Lock()
+ propBlockHash := cs.ProposalBlock.Hash()
+ cs.mtx.Unlock()
+
+ // the proposed block should be prevoted, precommitted, and locked
+ validatePrevoteAndPrecommit(t, cs, 0, 0, privVals[0], propBlockHash, propBlockHash, nil)
+}
+
+// nil is proposed, so prevote and precommit nil
+func TestFullRoundNil(t *testing.T) {
+ css, privVals := simpleConsensusState(1)
+ cs := css[0]
+ cs.newStepCh = make(chan *RoundState) // so it blocks
+ cs.SetPrivValidator(nil)
+
+ timeoutChan := make(chan struct{})
+ evsw := events.NewEventSwitch()
+ evsw.OnStart()
+ evsw.AddListenerForEvent("tester", types.EventStringTimeoutPropose(), func(data types.EventData) {
+ timeoutChan <- struct{}{}
+ })
+ cs.SetFireable(evsw)
+
+ // starts a go routine for EnterPropose
+ cs.EnterNewRound(cs.Height, 0, false)
+
+ // wait to finish propose (we should time out)
+ <-cs.NewStepCh()
+ cs.SetPrivValidator(privVals[0]) // this might be a race condition (uses the mutex that EnterPropose has just released and EnterPrevote is about to grab)
+ <-timeoutChan
+
+ // wait to finish prevote
+ <-cs.NewStepCh()
+
+ // should prevote and precommit nil
+ validatePrevoteAndPrecommit(t, cs, 0, 0, privVals[0], nil, nil, nil)
+}
+
+// run through propose, prevote, precommit commit with two validators
+// where the first validator has to wait for votes from the second
+func TestFullRound2(t *testing.T) {
+ css, privVals := simpleConsensusState(2)
+ cs1, cs2 := css[0], css[1]
+ cs1.newStepCh = make(chan *RoundState) // so it blocks
+ cs2.newStepCh = make(chan *RoundState) // so it blocks
+
+ // start round and wait for propose and prevote
+ cs1.EnterNewRound(cs1.Height, 0, false)
+ _, _ = <-cs1.NewStepCh(), <-cs1.NewStepCh()
+
+ // we should now be stuck in limbo forever, waiting for more prevotes
+ ensureNoNewStep(t, cs1)
+
+ propBlockHash, propPartsHeader := cs1.ProposalBlock.Hash(), cs1.ProposalBlockParts.Header()
+
+ // prevote arrives from cs2:
+ signAddVoteToFrom(types.VoteTypePrevote, cs1, cs2, propBlockHash, propPartsHeader)
+
+ // wait to finish precommit
+ <-cs1.NewStepCh()
+
+ // the proposed block should now be locked and our precommit added
+ validatePrecommit(t, cs1, 0, 0, privVals[0], propBlockHash, propBlockHash)
+
+ // we should now be stuck in limbo forever, waiting for more precommits
+ ensureNoNewStep(t, cs1)
+
+ // precommit arrives from cs2:
+ signAddVoteToFrom(types.VoteTypePrecommit, cs1, cs2, propBlockHash, propPartsHeader)
+
+ // wait to finish commit, propose in next height
+ _, rs := <-cs1.NewStepCh(), <-cs1.NewStepCh()
+ if rs.Height != 2 {
+ t.Fatal("Expected height to increment")
+ }
+}
+
+//------------------------------------------------------------------------------------------
+// LockSuite
+
+// two validators, 4 rounds.
+// val1 proposes the first 2 rounds, and is locked in the first.
+// val2 proposes the next two. val1 should precommit nil on all (except first where he locks)
+func TestLockNoPOL(t *testing.T) {
+ css, privVals := simpleConsensusState(2)
+ cs1, cs2 := css[0], css[1]
+ cs1.newStepCh = make(chan *RoundState) // so it blocks
+
+ timeoutChan := make(chan struct{})
+ evsw := events.NewEventSwitch()
+ evsw.OnStart()
+ evsw.AddListenerForEvent("tester", types.EventStringTimeoutPropose(), func(data types.EventData) {
+ timeoutChan <- struct{}{}
+ })
+ evsw.AddListenerForEvent("tester", types.EventStringTimeoutWait(), func(data types.EventData) {
+ timeoutChan <- struct{}{}
+ })
+ cs1.SetFireable(evsw)
+
+ /*
+ Round1 (cs1, B) // B B // B B2
+ */
+
+ // start round and wait for propose and prevote
+ cs1.EnterNewRound(cs1.Height, 0, false)
+ _, _ = <-cs1.NewStepCh(), <-cs1.NewStepCh()
+
+ // we should now be stuck in limbo forever, waiting for more prevotes
+ // prevote arrives from cs2:
+ signAddVoteToFrom(types.VoteTypePrevote, cs1, cs2, cs1.ProposalBlock.Hash(), cs1.ProposalBlockParts.Header())
+
+ cs1.mtx.Lock() // XXX: sigh
+ theBlockHash := cs1.ProposalBlock.Hash()
+ cs1.mtx.Unlock()
+
+ // wait to finish precommit
+ <-cs1.NewStepCh()
+
+ // the proposed block should now be locked and our precommit added
+ validatePrecommit(t, cs1, 0, 0, privVals[0], theBlockHash, theBlockHash)
+
+ // we should now be stuck in limbo forever, waiting for more precommits
+ // lets add one for a different block
+ // NOTE: in practice we should never get to a point where there are precommits for different blocks at the same round
+ hash := cs1.ProposalBlock.Hash()
+ hash[0] = byte((hash[0] + 1) % 255)
+ signAddVoteToFrom(types.VoteTypePrecommit, cs1, cs2, hash, cs1.ProposalBlockParts.Header())
+
+ // (note we're entering precommit for a second time this round)
+ // but with invalid args. then we EnterPrecommitWait, and the timeout to new round
+ _, _ = <-cs1.NewStepCh(), <-timeoutChan
+
+ log.Info("#### ONTO ROUND 2")
+ /*
+ Round2 (cs1, B) // B B2
+ */
+
+ incrementRound(cs2)
+
+ // go to prevote
+ <-cs1.NewStepCh()
+
+ // now we're on a new round and the proposer
+ if cs1.ProposalBlock != cs1.LockedBlock {
+ t.Fatalf("Expected proposal block to be locked block. Got %v, Expected %v", cs1.ProposalBlock, cs1.LockedBlock)
+ }
+
+ // wait to finish prevote
+ <-cs1.NewStepCh()
+
+ // we should have prevoted our locked block
+ validatePrevote(t, cs1, 1, privVals[0], cs1.LockedBlock.Hash())
+
+ // add a conflicting prevote from the other validator
+ signAddVoteToFrom(types.VoteTypePrevote, cs1, cs2, hash, cs1.ProposalBlockParts.Header())
+
+ // now we're going to enter prevote again, but with invalid args
+ // and then prevote wait, which should timeout. then wait for precommit
+ _, _, _ = <-cs1.NewStepCh(), <-timeoutChan, <-cs1.NewStepCh()
+
+ // the proposed block should still be locked and our precommit added
+ // we should precommit nil and be locked on the proposal
+ validatePrecommit(t, cs1, 1, 0, privVals[0], nil, theBlockHash)
+
+ // add conflicting precommit from cs2
+ // NOTE: in practice we should never get to a point where there are precommits for different blocks at the same round
+ signAddVoteToFrom(types.VoteTypePrecommit, cs1, cs2, hash, cs1.ProposalBlockParts.Header())
+
+ // (note we're entering precommit for a second time this round, but with invalid args
+ // then we EnterPrecommitWait and timeout into NewRound
+ _, _ = <-cs1.NewStepCh(), <-timeoutChan
+
+ log.Info("#### ONTO ROUND 3")
+ /*
+ Round3 (cs2, _) // B, B2
+ */
+
+ incrementRound(cs2)
+
+ // now we're on a new round and not the proposer, so wait for timeout
+ _, _ = <-cs1.NewStepCh(), <-timeoutChan
+ if cs1.ProposalBlock != nil {
+ t.Fatal("Expected proposal block to be nil")
+ }
+
+ // go to prevote, prevote for locked block
+ <-cs1.NewStepCh()
+ validatePrevote(t, cs1, 0, privVals[0], cs1.LockedBlock.Hash())
+
+ // TODO: quick fastforward to new round, set proposer
+ signAddVoteToFrom(types.VoteTypePrevote, cs1, cs2, hash, cs1.ProposalBlockParts.Header())
+ _, _, _ = <-cs1.NewStepCh(), <-timeoutChan, <-cs1.NewStepCh()
+ validatePrecommit(t, cs1, 2, 0, privVals[0], nil, theBlockHash) // precommit nil but be locked on proposal
+ signAddVoteToFrom(types.VoteTypePrecommit, cs1, cs2, hash, cs1.ProposalBlockParts.Header()) // NOTE: conflicting precommits at same height
+
+ <-cs1.NewStepCh()
+
+ // before we time out into new round, set next proposer
+ // and next proposal block
+ _, v1 := cs1.Validators.GetByAddress(privVals[0].Address)
+ v1.VotingPower = 1
+ if updated := cs1.Validators.Update(v1); !updated {
+ t.Fatal("failed to update validator")
+ }
+
+ cs2.decideProposal(cs2.Height, cs2.Round+1)
+ prop, propBlock := cs2.Proposal, cs2.ProposalBlock
+ if prop == nil || propBlock == nil {
+ t.Fatal("Failed to create proposal block with cs2")
+ }
+
+ incrementRound(cs2)
+
+ <-timeoutChan
+
+ log.Info("#### ONTO ROUND 4")
+ /*
+ Round4 (cs2, C) // B C // B C
+ */
+
+ // now we're on a new round and not the proposer
+ <-cs1.NewStepCh()
+ // so set the proposal block
+ cs1.mtx.Lock()
+ cs1.Proposal, cs1.ProposalBlock = prop, propBlock
+ cs1.mtx.Unlock()
+ // and wait for timeout
+ <-timeoutChan
+ // go to prevote, prevote for locked block (not proposal)
+ <-cs1.NewStepCh()
+ validatePrevote(t, cs1, 0, privVals[0], cs1.LockedBlock.Hash())
+
+ signAddVoteToFrom(types.VoteTypePrevote, cs1, cs2, propBlock.Hash(), propBlock.MakePartSet().Header())
+ _, _, _ = <-cs1.NewStepCh(), <-timeoutChan, <-cs1.NewStepCh()
+ validatePrecommit(t, cs1, 2, 0, privVals[0], nil, theBlockHash) // precommit nil but locked on proposal
+ signAddVoteToFrom(types.VoteTypePrecommit, cs1, cs2, propBlock.Hash(), propBlock.MakePartSet().Header()) // NOTE: conflicting precommits at same height
+}
+
+// 4 vals, one precommits, other 3 polka at next round, so we unlock and precomit the polka
+func TestLockPOLRelock(t *testing.T) {
+ css, privVals := simpleConsensusState(4)
+ cs1, cs2, cs3, cs4 := css[0], css[1], css[2], css[3]
+ cs1.newStepCh = make(chan *RoundState) // so it blocks
+
+ timeoutChan := make(chan *types.EventDataRoundState)
+ voteChan := make(chan *types.EventDataVote)
+ evsw := events.NewEventSwitch()
+ evsw.OnStart()
+ evsw.AddListenerForEvent("tester", types.EventStringTimeoutPropose(), func(data types.EventData) {
+ timeoutChan <- data.(*types.EventDataRoundState)
+ })
+ evsw.AddListenerForEvent("tester", types.EventStringTimeoutWait(), func(data types.EventData) {
+ timeoutChan <- data.(*types.EventDataRoundState)
+ })
+ evsw.AddListenerForEvent("tester", types.EventStringVote(), func(data types.EventData) {
+ vote := data.(*types.EventDataVote)
+ // we only fire for our own votes
+ if bytes.Equal(cs1.privValidator.Address, vote.Address) {
+ voteChan <- vote
+ }
+ })
+ cs1.SetFireable(evsw)
+
+ // everything done from perspective of cs1
+
+ /*
+ Round1 (cs1, B) // B B B B// B nil B nil
+
+ eg. cs2 and cs4 didn't see the 2/3 prevotes
+ */
+
+ // start round and wait for propose and prevote
+ cs1.EnterNewRound(cs1.Height, 0, false)
+ _, _, _ = <-cs1.NewStepCh(), <-voteChan, <-cs1.NewStepCh()
+
+ theBlockHash := cs1.ProposalBlock.Hash()
+
+ // wait to finish precommit after prevotes done
+ // we do this in a go routine with another channel since otherwise
+ // we may get deadlock with EnterPrecommit waiting to send on newStepCh and the final
+ // signAddVoteToFrom waiting for the cs.mtx.Lock
+ donePrecommit := make(chan struct{})
+ go func() {
+ <-voteChan
+ <-cs1.NewStepCh()
+ donePrecommit <- struct{}{}
+ }()
+ signAddVoteToFromMany(types.VoteTypePrevote, cs1, cs1.ProposalBlock.Hash(), cs1.ProposalBlockParts.Header(), cs2, cs3, cs4)
+ <-donePrecommit
+
+ // the proposed block should now be locked and our precommit added
+ validatePrecommit(t, cs1, 0, 0, privVals[0], theBlockHash, theBlockHash)
+
+ donePrecommitWait := make(chan struct{})
+ go func() {
+ // (note we're entering precommit for a second time this round)
+ // but with invalid args. then we EnterPrecommitWait, twice (?)
+ <-cs1.NewStepCh()
+ donePrecommitWait <- struct{}{}
+ }()
+ // add precommits from the rest
+ signAddVoteToFromMany(types.VoteTypePrecommit, cs1, nil, types.PartSetHeader{}, cs2, cs4)
+ signAddVoteToFrom(types.VoteTypePrecommit, cs1, cs3, cs1.ProposalBlock.Hash(), cs1.ProposalBlockParts.Header())
+ <-donePrecommitWait
+
+ // before we time out into new round, set next proposer
+ // and next proposal block
+ _, v1 := cs1.Validators.GetByAddress(privVals[0].Address)
+ v1.VotingPower = 1
+ if updated := cs1.Validators.Update(v1); !updated {
+ t.Fatal("failed to update validator")
+ }
+
+ cs2.decideProposal(cs2.Height, cs2.Round+1)
+ prop, propBlock := cs2.Proposal, cs2.ProposalBlock
+ if prop == nil || propBlock == nil {
+ t.Fatal("Failed to create proposal block with cs2")
+ }
+
+ incrementRound(cs2, cs3, cs4)
+
+ // timeout to new round
+ te := <-timeoutChan
+ if te.Step != RoundStepPrecommitWait.String() {
+ t.Fatalf("expected to timeout of precommit into new round. got %v", te.Step)
+ }
+
+ log.Info("### ONTO ROUND 2")
+
+ /*
+ Round2 (cs2, C) // B C C C // C C C _)
+
+ cs1 changes lock!
+ */
+
+ // now we're on a new round and not the proposer
+ <-cs1.NewStepCh()
+ cs1.mtx.Lock()
+ // so set the proposal block
+ propBlockHash, propBlockParts := propBlock.Hash(), propBlock.MakePartSet()
+ cs1.Proposal, cs1.ProposalBlock, cs1.ProposalBlockParts = prop, propBlock, propBlockParts
+ cs1.mtx.Unlock()
+ // and wait for timeout
+ te = <-timeoutChan
+ if te.Step != RoundStepPropose.String() {
+ t.Fatalf("expected to timeout of propose. got %v", te.Step)
+ }
+ // go to prevote, prevote for locked block (not proposal), move on
+ _, _ = <-voteChan, <-cs1.NewStepCh()
+ validatePrevote(t, cs1, 0, privVals[0], theBlockHash)
+
+ donePrecommit = make(chan struct{})
+ go func() {
+ // we need this go routine because if we go into PrevoteWait it has to pull on newStepCh
+ // before the final vote will get added (because it holds the mutex).
+ select {
+ case <-cs1.NewStepCh(): // we're in PrevoteWait, go to Precommit
+ <-voteChan
+ case <-voteChan: // we went straight to Precommit
+ }
+ donePrecommit <- struct{}{}
+ }()
+ // now lets add prevotes from everyone else for the new block
+ signAddVoteToFromMany(types.VoteTypePrevote, cs1, propBlockHash, propBlockParts.Header(), cs2, cs3, cs4)
+ <-donePrecommit
+
+ // we should have unlocked and locked on the new block
+ validatePrecommit(t, cs1, 1, 1, privVals[0], propBlockHash, propBlockHash)
+
+ donePrecommitWait = make(chan struct{})
+ go func() {
+ // (note we're entering precommit for a second time this round)
+ // but with invalid args. then we EnterPrecommitWait,
+ <-cs1.NewStepCh()
+ donePrecommitWait <- struct{}{}
+ }()
+ signAddVoteToFromMany(types.VoteTypePrecommit, cs1, propBlockHash, propBlockParts.Header(), cs2, cs3)
+ <-donePrecommitWait
+
+ <-cs1.NewStepCh()
+ rs := <-cs1.NewStepCh()
+ if rs.Height != 2 {
+ t.Fatal("Expected height to increment")
+ }
+
+ if hash, _, ok := rs.LastCommit.TwoThirdsMajority(); !ok || !bytes.Equal(hash, propBlockHash) {
+ t.Fatal("Expected block to get committed")
+ }
+}
+
+// 4 vals, one precommits, other 3 polka at next round, so we unlock and precomit the polka
+func TestLockPOLUnlock(t *testing.T) {
+ css, privVals := simpleConsensusState(4)
+ cs1, cs2, cs3, cs4 := css[0], css[1], css[2], css[3]
+ cs1.newStepCh = make(chan *RoundState) // so it blocks
+
+ timeoutChan := make(chan *types.EventDataRoundState)
+ voteChan := make(chan *types.EventDataVote)
+ evsw := events.NewEventSwitch()
+ evsw.OnStart()
+ evsw.AddListenerForEvent("tester", types.EventStringTimeoutPropose(), func(data types.EventData) {
+ timeoutChan <- data.(*types.EventDataRoundState)
+ })
+ evsw.AddListenerForEvent("tester", types.EventStringTimeoutWait(), func(data types.EventData) {
+ timeoutChan <- data.(*types.EventDataRoundState)
+ })
+ evsw.AddListenerForEvent("tester", types.EventStringVote(), func(data types.EventData) {
+ vote := data.(*types.EventDataVote)
+ // we only fire for our own votes
+ if bytes.Equal(cs1.privValidator.Address, vote.Address) {
+ voteChan <- vote
+ }
+ })
+ cs1.SetFireable(evsw)
+
+ // everything done from perspective of cs1
+
+ /*
+ Round1 (cs1, B) // B B B B // B nil B nil
+
+ eg. didn't see the 2/3 prevotes
+ */
+
+ // start round and wait for propose and prevote
+ cs1.EnterNewRound(cs1.Height, 0, false)
+ _, _, _ = <-cs1.NewStepCh(), <-voteChan, <-cs1.NewStepCh()
+
+ theBlockHash := cs1.ProposalBlock.Hash()
+
+ donePrecommit := make(chan struct{})
+ go func() {
+ <-voteChan
+ <-cs1.NewStepCh()
+ donePrecommit <- struct{}{}
+ }()
+ signAddVoteToFromMany(types.VoteTypePrevote, cs1, cs1.ProposalBlock.Hash(), cs1.ProposalBlockParts.Header(), cs2, cs3, cs4)
+ <-donePrecommit
+
+ // the proposed block should now be locked and our precommit added
+ validatePrecommit(t, cs1, 0, 0, privVals[0], theBlockHash, theBlockHash)
+
+ donePrecommitWait := make(chan struct{})
+ go func() {
+ <-cs1.NewStepCh()
+ donePrecommitWait <- struct{}{}
+ }()
+ // add precommits from the rest
+ signAddVoteToFromMany(types.VoteTypePrecommit, cs1, nil, types.PartSetHeader{}, cs2, cs4)
+ signAddVoteToFrom(types.VoteTypePrecommit, cs1, cs3, cs1.ProposalBlock.Hash(), cs1.ProposalBlockParts.Header())
+ <-donePrecommitWait
+
+ // before we time out into new round, set next proposer
+ // and next proposal block
+ _, v1 := cs1.Validators.GetByAddress(privVals[0].Address)
+ v1.VotingPower = 1
+ if updated := cs1.Validators.Update(v1); !updated {
+ t.Fatal("failed to update validator")
+ }
+
+ cs2.decideProposal(cs2.Height, cs2.Round+1)
+ prop, propBlock := cs2.Proposal, cs2.ProposalBlock
+ if prop == nil || propBlock == nil {
+ t.Fatal("Failed to create proposal block with cs2")
+ }
+
+ incrementRound(cs2, cs3, cs4)
+
+ // timeout to new round
+ <-timeoutChan
+
+ log.Info("#### ONTO ROUND 2")
+ /*
+ Round2 (cs2, C) // B nil nil nil // nil nil nil _
+
+ cs1 unlocks!
+ */
+
+ // now we're on a new round and not the proposer,
+ <-cs1.NewStepCh()
+ cs1.mtx.Lock()
+ // so set the proposal block
+ cs1.Proposal, cs1.ProposalBlock, cs1.ProposalBlockParts = prop, propBlock, propBlock.MakePartSet()
+ lockedBlockHash := cs1.LockedBlock.Hash()
+ cs1.mtx.Unlock()
+ // and wait for timeout
+ <-timeoutChan
+
+ // go to prevote, prevote for locked block (not proposal)
+ _, _ = <-voteChan, <-cs1.NewStepCh()
+ validatePrevote(t, cs1, 0, privVals[0], lockedBlockHash)
+
+ donePrecommit = make(chan struct{})
+ go func() {
+ select {
+ case <-cs1.NewStepCh(): // we're in PrevoteWait, go to Precommit
+ <-voteChan
+ case <-voteChan: // we went straight to Precommit
+ }
+ donePrecommit <- struct{}{}
+ }()
+ // now lets add prevotes from everyone else for the new block
+ signAddVoteToFromMany(types.VoteTypePrevote, cs1, nil, types.PartSetHeader{}, cs2, cs3, cs4)
+ <-donePrecommit
+
+ // we should have unlocked
+ // NOTE: we don't lock on nil, so LockedRound is still 0
+ validatePrecommit(t, cs1, 1, 0, privVals[0], nil, nil)
+
+ donePrecommitWait = make(chan struct{})
+ go func() {
+ // the votes will bring us to new round right away
+ // we should timeout of it
+ _, _, _ = <-cs1.NewStepCh(), <-cs1.NewStepCh(), <-timeoutChan
+ donePrecommitWait <- struct{}{}
+ }()
+ signAddVoteToFromMany(types.VoteTypePrecommit, cs1, nil, types.PartSetHeader{}, cs2, cs3)
+ <-donePrecommitWait
+}
+
+// 4 vals
+// a polka at round 1 but we miss it
+// then a polka at round 2 that we lock on
+// then we see the polka from round 1 but shouldn't unlock
+func TestLockPOLSafety1(t *testing.T) {
+ css, privVals := simpleConsensusState(4)
+ cs1, cs2, cs3, cs4 := css[0], css[1], css[2], css[3]
+ cs1.newStepCh = make(chan *RoundState) // so it blocks
+
+ timeoutChan := make(chan *types.EventDataRoundState)
+ voteChan := make(chan *types.EventDataVote)
+ evsw := events.NewEventSwitch()
+ evsw.OnStart()
+ evsw.AddListenerForEvent("tester", types.EventStringTimeoutPropose(), func(data types.EventData) {
+ timeoutChan <- data.(*types.EventDataRoundState)
+ })
+ evsw.AddListenerForEvent("tester", types.EventStringTimeoutWait(), func(data types.EventData) {
+ timeoutChan <- data.(*types.EventDataRoundState)
+ })
+ evsw.AddListenerForEvent("tester", types.EventStringVote(), func(data types.EventData) {
+ vote := data.(*types.EventDataVote)
+ // we only fire for our own votes
+ if bytes.Equal(cs1.privValidator.Address, vote.Address) {
+ voteChan <- vote
+ }
+ })
+ cs1.SetFireable(evsw)
+
+ // start round and wait for propose and prevote
+ cs1.EnterNewRound(cs1.Height, 0, false)
+ _, _, _ = <-cs1.NewStepCh(), <-voteChan, <-cs1.NewStepCh()
+
+ propBlock := cs1.ProposalBlock
+
+ validatePrevote(t, cs1, 0, privVals[0], cs1.ProposalBlock.Hash())
+
+ // the others sign a polka but we don't see it
+ prevotes := signVoteMany(types.VoteTypePrevote, propBlock.Hash(), propBlock.MakePartSet().Header(), cs2, cs3, cs4)
+
+ // before we time out into new round, set next proposer
+ // and next proposal block
+ _, v1 := cs1.Validators.GetByAddress(privVals[0].Address)
+ v1.VotingPower = 1
+ if updated := cs1.Validators.Update(v1); !updated {
+ t.Fatal("failed to update validator")
+ }
+
+ log.Warn("old prop", "hash", fmt.Sprintf("%X", propBlock.Hash()))
+
+ // we do see them precommit nil
+ signAddVoteToFromMany(types.VoteTypePrecommit, cs1, nil, types.PartSetHeader{}, cs2, cs3, cs4)
+
+ cs2.decideProposal(cs2.Height, cs2.Round+1)
+ prop, propBlock := cs2.Proposal, cs2.ProposalBlock
+ if prop == nil || propBlock == nil {
+ t.Fatal("Failed to create proposal block with cs2")
+ }
+
+ incrementRound(cs2, cs3, cs4)
+
+ log.Info("### ONTO ROUND 2")
+ /*Round2
+ // we timeout and prevote our lock
+ // a polka happened but we didn't see it!
+ */
+
+ // now we're on a new round and not the proposer,
+ <-cs1.NewStepCh()
+ // so set proposal
+ cs1.mtx.Lock()
+ propBlockHash, propBlockParts := propBlock.Hash(), propBlock.MakePartSet()
+ cs1.Proposal, cs1.ProposalBlock, cs1.ProposalBlockParts = prop, propBlock, propBlockParts
+ cs1.mtx.Unlock()
+ // and wait for timeout
+ <-timeoutChan
+ if cs1.LockedBlock != nil {
+ t.Fatal("we should not be locked!")
+ }
+ log.Warn("new prop", "hash", fmt.Sprintf("%X", propBlockHash))
+ // go to prevote, prevote for proposal block
+ _, _ = <-voteChan, <-cs1.NewStepCh()
+ validatePrevote(t, cs1, 1, privVals[0], propBlockHash)
+
+ // now we see the others prevote for it, so we should lock on it
+ donePrecommit := make(chan struct{})
+ go func() {
+ select {
+ case <-cs1.NewStepCh(): // we're in PrevoteWait, go to Precommit
+ <-voteChan
+ case <-voteChan: // we went straight to Precommit
+ }
+ <-cs1.NewStepCh()
+ donePrecommit <- struct{}{}
+ }()
+ // now lets add prevotes from everyone else for nil
+ signAddVoteToFromMany(types.VoteTypePrevote, cs1, propBlockHash, propBlockParts.Header(), cs2, cs3, cs4)
+ <-donePrecommit
+
+ // we should have precommitted
+ validatePrecommit(t, cs1, 1, 1, privVals[0], propBlockHash, propBlockHash)
+
+ // now we see precommits for nil
+ donePrecommitWait := make(chan struct{})
+ go func() {
+ // the votes will bring us to new round
+ // we should timeut of it and go to prevote
+ <-cs1.NewStepCh()
+ <-timeoutChan
+ donePrecommitWait <- struct{}{}
+ }()
+ signAddVoteToFromMany(types.VoteTypePrecommit, cs1, nil, types.PartSetHeader{}, cs2, cs3)
+ <-donePrecommitWait
+
+ incrementRound(cs2, cs3, cs4)
+
+ log.Info("### ONTO ROUND 3")
+ /*Round3
+ we see the polka from round 1 but we shouldn't unlock!
+ */
+
+ // timeout of propose
+ _, _ = <-cs1.NewStepCh(), <-timeoutChan
+
+ // finish prevote
+ _, _ = <-voteChan, <-cs1.NewStepCh()
+
+ // we should prevote what we're locked on
+ validatePrevote(t, cs1, 2, privVals[0], propBlockHash)
+
+ // add prevotes from the earlier round
+ addVoteToFromMany(cs1, prevotes, cs2, cs3, cs4)
+
+ log.Warn("Done adding prevotes!")
+
+ ensureNoNewStep(t, cs1)
+}
+
+// 4 vals.
+// polka P1 at R1, P2 at R2, and P3 at R3,
+// we lock on P1 at R1, don't see P2, and unlock using P3 at R3
+// then we should make sure we don't lock using P2
+func TestLockPOLSafety2(t *testing.T) {
+ css, privVals := simpleConsensusState(4)
+ cs1, cs2, cs3, cs4 := css[0], css[1], css[2], css[3]
+ cs1.newStepCh = make(chan *RoundState) // so it blocks
+
+ timeoutChan := make(chan *types.EventDataRoundState)
+ voteChan := make(chan *types.EventDataVote)
+ evsw := events.NewEventSwitch()
+ evsw.OnStart()
+ evsw.AddListenerForEvent("tester", types.EventStringTimeoutPropose(), func(data types.EventData) {
+ timeoutChan <- data.(*types.EventDataRoundState)
+ })
+ evsw.AddListenerForEvent("tester", types.EventStringTimeoutWait(), func(data types.EventData) {
+ timeoutChan <- data.(*types.EventDataRoundState)
+ })
+ evsw.AddListenerForEvent("tester", types.EventStringVote(), func(data types.EventData) {
+ vote := data.(*types.EventDataVote)
+ // we only fire for our own votes
+ if bytes.Equal(cs1.privValidator.Address, vote.Address) {
+ voteChan <- vote
+ }
+ })
+ cs1.SetFireable(evsw)
+
+ // start round and wait for propose and prevote
+ cs1.EnterNewRound(cs1.Height, 0, false)
+ _, _, _ = <-cs1.NewStepCh(), <-voteChan, <-cs1.NewStepCh()
+
+ theBlockHash := cs1.ProposalBlock.Hash()
+
+ donePrecommit := make(chan struct{})
+ go func() {
+ <-voteChan
+ <-cs1.NewStepCh()
+ donePrecommit <- struct{}{}
+ }()
+ signAddVoteToFromMany(types.VoteTypePrevote, cs1, cs1.ProposalBlock.Hash(), cs1.ProposalBlockParts.Header(), cs2, cs3, cs4)
+ <-donePrecommit
+
+ // the proposed block should now be locked and our precommit added
+ validatePrecommit(t, cs1, 0, 0, privVals[0], theBlockHash, theBlockHash)
+
+ donePrecommitWait := make(chan struct{})
+ go func() {
+ <-cs1.NewStepCh()
+ donePrecommitWait <- struct{}{}
+ }()
+ // add precommits from the rest
+ signAddVoteToFromMany(types.VoteTypePrecommit, cs1, nil, types.PartSetHeader{}, cs2, cs4)
+ signAddVoteToFrom(types.VoteTypePrecommit, cs1, cs3, cs1.ProposalBlock.Hash(), cs1.ProposalBlockParts.Header())
+ <-donePrecommitWait
+
+ // before we time out into new round, set next proposer
+ // and next proposal block
+ _, v1 := cs1.Validators.GetByAddress(privVals[0].Address)
+ v1.VotingPower = 1
+ if updated := cs1.Validators.Update(v1); !updated {
+ t.Fatal("failed to update validator")
+ }
+
+ cs2.decideProposal(cs2.Height, cs2.Round+1)
+ prop, propBlock := cs2.Proposal, cs2.ProposalBlock
+ if prop == nil || propBlock == nil {
+ t.Fatal("Failed to create proposal block with cs2")
+ }
+
+ incrementRound(cs2, cs3, cs4)
+
+ // timeout to new round
+ <-timeoutChan
+
+ log.Info("### ONTO Round 2")
+ /*Round2
+ // we timeout and prevote our lock
+ // a polka happened but we didn't see it!
+ */
+
+ // now we're on a new round and not the proposer, so wait for timeout
+ _, _ = <-cs1.NewStepCh(), <-timeoutChan
+ // go to prevote, prevote for locked block
+ _, _ = <-voteChan, <-cs1.NewStepCh()
+ validatePrevote(t, cs1, 0, privVals[0], cs1.LockedBlock.Hash())
+
+ // the others sign a polka but we don't see it
+ prevotes := signVoteMany(types.VoteTypePrevote, propBlock.Hash(), propBlock.MakePartSet().Header(), cs2, cs3, cs4)
+
+ // once we see prevotes for the next round we'll skip ahead
+
+ incrementRound(cs2, cs3, cs4)
+
+ log.Info("### ONTO Round 3")
+ /*Round3
+ a polka for nil causes us to unlock
+ */
+
+ // these prevotes will send us straight to precommit at the higher round
+ donePrecommit = make(chan struct{})
+ go func() {
+ select {
+ case <-cs1.NewStepCh(): // we're in PrevoteWait, go to Precommit
+ <-voteChan
+ case <-voteChan: // we went straight to Precommit
+ }
+ <-cs1.NewStepCh()
+ donePrecommit <- struct{}{}
+ }()
+ // now lets add prevotes from everyone else for nil
+ signAddVoteToFromMany(types.VoteTypePrevote, cs1, nil, types.PartSetHeader{}, cs2, cs3, cs4)
+ <-donePrecommit
+
+ // we should have unlocked
+ // NOTE: we don't lock on nil, so LockedRound is still 0
+ validatePrecommit(t, cs1, 2, 0, privVals[0], nil, nil)
+
+ donePrecommitWait = make(chan struct{})
+ go func() {
+ // the votes will bring us to new round right away
+ // we should timeut of it and go to prevote
+ <-cs1.NewStepCh()
+ // set the proposal block to be that which got a polka in R2
+ cs1.mtx.Lock()
+ cs1.Proposal, cs1.ProposalBlock, cs1.ProposalBlockParts = prop, propBlock, propBlock.MakePartSet()
+ cs1.mtx.Unlock()
+ // timeout into prevote, finish prevote
+ _, _, _ = <-timeoutChan, <-voteChan, <-cs1.NewStepCh()
+ donePrecommitWait <- struct{}{}
+ }()
+ signAddVoteToFromMany(types.VoteTypePrecommit, cs1, nil, types.PartSetHeader{}, cs2, cs3)
+ <-donePrecommitWait
+
+ log.Info("### ONTO ROUND 4")
+ /*Round4
+ we see the polka from R2
+ make sure we don't lock because of it!
+ */
+ // new round and not proposer
+ // (we already timed out and stepped into prevote)
+
+ log.Warn("adding prevotes from round 2")
+
+ addVoteToFromMany(cs1, prevotes, cs2, cs3, cs4)
+
+ log.Warn("Done adding prevotes!")
+
+ // we should prevote it now
+ validatePrevote(t, cs1, 3, privVals[0], cs1.ProposalBlock.Hash())
+
+ // but we shouldn't precommit it
+ precommits := cs1.Votes.Precommits(3)
+ vote := precommits.GetByIndex(0)
+ if vote != nil {
+ t.Fatal("validator precommitted at round 4 based on an old polka")
+ }
+}
+
+//------------------------------------------------------------------------------------------
+// SlashingSuite
+
+func TestSlashingPrevotes(t *testing.T) {
+ css, _ := simpleConsensusState(2)
+ cs1, cs2 := css[0], css[1]
+ cs1.newStepCh = make(chan *RoundState) // so it blocks
+
+ // start round and wait for propose and prevote
+ cs1.EnterNewRound(cs1.Height, 0, false)
+ _, _ = <-cs1.NewStepCh(), <-cs1.NewStepCh()
+
+ // we should now be stuck in limbo forever, waiting for more prevotes
+ // add one for a different block should cause us to go into prevote wait
+ hash := cs1.ProposalBlock.Hash()
+ hash[0] = byte(hash[0]+1) % 255
+ signAddVoteToFrom(types.VoteTypePrevote, cs1, cs2, hash, cs1.ProposalBlockParts.Header())
+
+ // pass prevote wait
+ <-cs1.NewStepCh()
+
+ // NOTE: we have to send the vote for different block first so we don't just go into precommit round right
+ // away and ignore more prevotes (and thus fail to slash!)
+
+ // add the conflicting vote
+ signAddVoteToFrom(types.VoteTypePrevote, cs1, cs2, cs1.ProposalBlock.Hash(), cs1.ProposalBlockParts.Header())
+
+ // conflicting vote should cause us to broadcast dupeout tx on mempool
+ txs := cs1.mempoolReactor.Mempool.GetProposalTxs()
+ if len(txs) != 1 {
+ t.Fatal("expected to find a transaction in the mempool after double signing")
+ }
+ dupeoutTx, ok := txs[0].(*types.DupeoutTx)
+ if !ok {
+ t.Fatal("expected to find DupeoutTx in mempool after double signing")
+ }
+
+ if !bytes.Equal(dupeoutTx.Address, cs2.privValidator.Address) {
+ t.Fatalf("expected DupeoutTx for %X, got %X", cs2.privValidator.Address, dupeoutTx.Address)
+ }
+
+ // TODO: validate the sig
+}
+
+func TestSlashingPrecommits(t *testing.T) {
+ css, _ := simpleConsensusState(2)
+ cs1, cs2 := css[0], css[1]
+ cs1.newStepCh = make(chan *RoundState) // so it blocks
+
+ // start round and wait for propose and prevote
+ cs1.EnterNewRound(cs1.Height, 0, false)
+ _, _ = <-cs1.NewStepCh(), <-cs1.NewStepCh()
+
+ // add prevote from cs2
+ signAddVoteToFrom(types.VoteTypePrevote, cs1, cs2, cs1.ProposalBlock.Hash(), cs1.ProposalBlockParts.Header())
+
+ // wait to finish precommit
+ <-cs1.NewStepCh()
+
+ // we should now be stuck in limbo forever, waiting for more prevotes
+ // add one for a different block should cause us to go into prevote wait
+ hash := cs1.ProposalBlock.Hash()
+ hash[0] = byte(hash[0]+1) % 255
+ signAddVoteToFrom(types.VoteTypePrecommit, cs1, cs2, hash, cs1.ProposalBlockParts.Header())
+
+ // pass prevote wait
+ <-cs1.NewStepCh()
+
+ // NOTE: we have to send the vote for different block first so we don't just go into precommit round right
+ // away and ignore more prevotes (and thus fail to slash!)
+
+ // add precommit from cs2
+ signAddVoteToFrom(types.VoteTypePrecommit, cs1, cs2, cs1.ProposalBlock.Hash(), cs1.ProposalBlockParts.Header())
+
+ // conflicting vote should cause us to broadcast dupeout tx on mempool
+ txs := cs1.mempoolReactor.Mempool.GetProposalTxs()
+ if len(txs) != 1 {
+ t.Fatal("expected to find a transaction in the mempool after double signing")
+ }
+ dupeoutTx, ok := txs[0].(*types.DupeoutTx)
+ if !ok {
+ t.Fatal("expected to find DupeoutTx in mempool after double signing")
+ }
+
+ if !bytes.Equal(dupeoutTx.Address, cs2.privValidator.Address) {
+ t.Fatalf("expected DupeoutTx for %X, got %X", cs2.privValidator.Address, dupeoutTx.Address)
+ }
+
+ // TODO: validate the sig
+
+}
+
+//------------------------------------------------------------------------------------------
+// CatchupSuite
+
+//------------------------------------------------------------------------------------------
+// HaltSuite
+
+// 4 vals.
+// we receive a final precommit after going into next round, but others might have gone to commit already!
+func TestHalt1(t *testing.T) {
+ css, privVals := simpleConsensusState(4)
+ cs1, cs2, cs3, cs4 := css[0], css[1], css[2], css[3]
+ cs1.newStepCh = make(chan *RoundState) // so it blocks
+
+ timeoutChan := make(chan struct{})
+ evsw := events.NewEventSwitch()
+ evsw.OnStart()
+ evsw.AddListenerForEvent("tester", types.EventStringTimeoutWait(), func(data types.EventData) {
+ timeoutChan <- struct{}{}
+ })
+ cs1.SetFireable(evsw)
+
+ // start round and wait for propose and prevote
+ cs1.EnterNewRound(cs1.Height, 0, false)
+ _, _ = <-cs1.NewStepCh(), <-cs1.NewStepCh()
+
+ theBlockHash := cs1.ProposalBlock.Hash()
+
+ donePrecommit := make(chan struct{})
+ go func() {
+ <-cs1.NewStepCh()
+ donePrecommit <- struct{}{}
+ }()
+ signAddVoteToFromMany(types.VoteTypePrevote, cs1, cs1.ProposalBlock.Hash(), cs1.ProposalBlockParts.Header(), cs3, cs4)
+ <-donePrecommit
+
+ // the proposed block should now be locked and our precommit added
+ validatePrecommit(t, cs1, 0, 0, privVals[0], theBlockHash, theBlockHash)
+
+ donePrecommitWait := make(chan struct{})
+ go func() {
+ <-cs1.NewStepCh()
+ donePrecommitWait <- struct{}{}
+ }()
+ // add precommits from the rest
+ signAddVoteToFrom(types.VoteTypePrecommit, cs1, cs2, nil, types.PartSetHeader{}) // didnt receive proposal
+ signAddVoteToFrom(types.VoteTypePrecommit, cs1, cs3, cs1.ProposalBlock.Hash(), cs1.ProposalBlockParts.Header())
+ // we receive this later, but cs3 might receive it earlier and with ours will go to commit!
+ precommit4 := signVote(cs4, types.VoteTypePrecommit, cs1.ProposalBlock.Hash(), cs1.ProposalBlockParts.Header())
+ <-donePrecommitWait
+
+ incrementRound(cs2, cs3, cs4)
+
+ // timeout to new round
+ <-timeoutChan
+
+ log.Info("### ONTO ROUND 2")
+ /*Round2
+ // we timeout and prevote our lock
+ // a polka happened but we didn't see it!
+ */
+
+ // go to prevote, prevote for locked block
+ _, _ = <-cs1.NewStepCh(), <-cs1.NewStepCh()
+ validatePrevote(t, cs1, 0, privVals[0], cs1.LockedBlock.Hash())
+
+ // now we receive the precommit from the previous round
+ addVoteToFrom(cs1, cs4, precommit4)
+
+ // receiving that precommit should take us straight to commit
+ ensureNewStep(t, cs1)
+ log.Warn("done enter commit!")
+
+ // update to state
+ ensureNewStep(t, cs1)
+
+ if cs1.Height != 2 {
+ t.Fatal("expected height to increment")
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/mempool/config.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/mempool/config.go
new file mode 100644
index 0000000000000000000000000000000000000000..233bb88c2de02d6e4b61e803a9950893c5769d18
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/mempool/config.go
@@ -0,0 +1,13 @@
+package mempool
+
+import (
+ cfg "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/config"
+)
+
+var config cfg.Config = nil
+
+func init() {
+ cfg.OnConfig(func(newConfig cfg.Config) {
+ config = newConfig
+ })
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/mempool/mempool_test.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/mempool/mempool_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..ab6e4e993dc27275b67a201fa6295c1a908986a2
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/mempool/mempool_test.go
@@ -0,0 +1,273 @@
+package mempool
+
+import (
+ "fmt"
+ "sync"
+ "testing"
+ "time"
+
+ acm "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
+ _ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/config/tendermint_test"
+ sm "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/state"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+)
+
+var someAddr = []byte("ABCDEFGHIJABCDEFGHIJ")
+
+// number of txs
+var nTxs = 100
+
+// what the ResetInfo should look like after ResetForBlockAndState
+var TestResetInfoData = ResetInfo{
+ Included: []Range{
+ Range{0, 5},
+ Range{10, 10},
+ Range{30, 5},
+ },
+ Invalid: []Range{
+ Range{5, 5},
+ Range{20, 8}, // let 28 and 29 be valid
+ Range{35, 64}, // let 99 be valid
+ },
+}
+
+// inverse of the ResetInfo
+var notInvalidNotIncluded = map[int]struct{}{
+ 28: struct{}{},
+ 29: struct{}{},
+ 99: struct{}{},
+}
+
+func newSendTx(t *testing.T, mempool *Mempool, from *acm.PrivAccount, to []byte, amt int64) types.Tx {
+ tx := types.NewSendTx()
+ tx.AddInput(mempool.GetCache(), from.PubKey, amt)
+ tx.AddOutput(to, amt)
+ tx.SignInput(config.GetString("chain_id"), 0, from)
+ if err := mempool.AddTx(tx); err != nil {
+ t.Fatal(err)
+ }
+ return tx
+}
+
+func addTxs(t *testing.T, mempool *Mempool, lastAcc *acm.PrivAccount, privAccs []*acm.PrivAccount) []types.Tx {
+ txs := make([]types.Tx, nTxs)
+ for i := 0; i < nTxs; i++ {
+ if _, ok := notInvalidNotIncluded[i]; ok {
+ txs[i] = newSendTx(t, mempool, lastAcc, someAddr, 10)
+ } else {
+ txs[i] = newSendTx(t, mempool, privAccs[i%len(privAccs)], privAccs[(i+1)%len(privAccs)].Address, 5)
+ }
+ }
+ return txs
+}
+
+func makeBlock(mempool *Mempool) *types.Block {
+ txs := mempool.GetProposalTxs()
+ var includedTxs []types.Tx
+ for _, rid := range TestResetInfoData.Included {
+ includedTxs = append(includedTxs, txs[rid.Start:rid.Start+rid.Length]...)
+ }
+
+ mempool.mtx.Lock()
+ state := mempool.state
+ state.LastBlockHeight += 1
+ mempool.mtx.Unlock()
+ return &types.Block{
+ Header: &types.Header{
+ ChainID: state.ChainID,
+ Height: state.LastBlockHeight,
+ NumTxs: len(includedTxs),
+ },
+ Data: &types.Data{
+ Txs: includedTxs,
+ },
+ }
+}
+
+// Add txs. Grab chunks to put in block. All the others become invalid because of nonce errors except those in notInvalidNotIncluded
+func TestResetInfo(t *testing.T) {
+ amtPerAccount := int64(100000)
+ state, privAccs, _ := sm.RandGenesisState(6, false, amtPerAccount, 1, true, 100)
+
+ mempool := NewMempool(state)
+
+ lastAcc := privAccs[5] // we save him (his tx wont become invalid)
+ privAccs = privAccs[:5]
+
+ txs := addTxs(t, mempool, lastAcc, privAccs)
+
+ // its actually an invalid block since we're skipping nonces
+ // but all we care about is how the mempool responds after
+ block := makeBlock(mempool)
+
+ ri := mempool.ResetForBlockAndState(block, state)
+
+ if len(ri.Included) != len(TestResetInfoData.Included) {
+ t.Fatalf("invalid number of included ranges. Got %d, expected %d\n", len(ri.Included), len(TestResetInfoData.Included))
+ }
+
+ if len(ri.Invalid) != len(TestResetInfoData.Invalid) {
+ t.Fatalf("invalid number of invalid ranges. Got %d, expected %d\n", len(ri.Invalid), len(TestResetInfoData.Invalid))
+ }
+
+ for i, rid := range ri.Included {
+ inc := TestResetInfoData.Included[i]
+ if rid.Start != inc.Start {
+ t.Fatalf("Invalid start of range. Got %d, expected %d\n", inc.Start, rid.Start)
+ }
+ if rid.Length != inc.Length {
+ t.Fatalf("Invalid length of range. Got %d, expected %d\n", inc.Length, rid.Length)
+ }
+ }
+
+ txs = mempool.GetProposalTxs()
+ if len(txs) != len(notInvalidNotIncluded) {
+ t.Fatalf("Expected %d txs left in mempool. Got %d", len(notInvalidNotIncluded), len(txs))
+ }
+}
+
+//------------------------------------------------------------------------------------------
+
+type TestPeer struct {
+ sync.Mutex
+ running bool
+ height int
+
+ t *testing.T
+
+ received int
+ txs map[string]int
+
+ timeoutFail int
+
+ done chan int
+}
+
+func newPeer(t *testing.T, state *sm.State) *TestPeer {
+ return &TestPeer{
+ running: true,
+ height: state.LastBlockHeight,
+ t: t,
+ txs: make(map[string]int),
+ done: make(chan int),
+ }
+}
+
+func (tp *TestPeer) IsRunning() bool {
+ tp.Lock()
+ defer tp.Unlock()
+ return tp.running
+}
+
+func (tp *TestPeer) SetRunning(running bool) {
+ tp.Lock()
+ defer tp.Unlock()
+ tp.running = running
+}
+
+func (tp *TestPeer) Send(chID byte, msg interface{}) bool {
+ if tp.timeoutFail > 0 {
+ time.Sleep(time.Second * time.Duration(tp.timeoutFail))
+ return false
+ }
+ tx := msg.(*TxMessage).Tx
+ id := types.TxID(config.GetString("chain_id"), tx)
+ if _, ok := tp.txs[string(id)]; ok {
+ tp.t.Fatal("received the same tx twice!")
+ }
+ tp.txs[string(id)] = tp.received
+ tp.received += 1
+ tp.done <- tp.received
+ return true
+}
+
+func (tp *TestPeer) Get(key string) interface{} {
+ return tp
+}
+
+func (tp *TestPeer) GetHeight() int {
+ return tp.height
+}
+
+func TestBroadcast(t *testing.T) {
+ state, privAccs, _ := sm.RandGenesisState(6, false, 10000, 1, true, 100)
+ mempool := NewMempool(state)
+ reactor := NewMempoolReactor(mempool)
+ reactor.Start()
+
+ lastAcc := privAccs[5] // we save him (his tx wont become invalid)
+ privAccs = privAccs[:5]
+
+ peer := newPeer(t, state)
+ newBlockChan := make(chan ResetInfo)
+ tickerChan := make(chan time.Time)
+ go reactor.broadcastTxRoutine(tickerChan, newBlockChan, peer)
+
+ // we don't broadcast any before updating
+ fmt.Println("dont broadcast any")
+ addTxs(t, mempool, lastAcc, privAccs)
+ block := makeBlock(mempool)
+ ri := mempool.ResetForBlockAndState(block, state)
+ newBlockChan <- ri
+ peer.height = ri.Height
+ tickerChan <- time.Now()
+ pullTxs(t, peer, len(mempool.txs)) // should have sent whatever txs are left (3)
+
+ toBroadcast := []int{1, 3, 7, 9, 11, 12, 18, 20, 21, 28, 29, 30, 31, 34, 35, 36, 50, 90, 99, 100}
+ for _, N := range toBroadcast {
+ peer = resetPeer(t, reactor, mempool, state, tickerChan, newBlockChan, peer)
+
+ // we broadcast N txs before updating
+ fmt.Println("broadcast", N)
+ addTxs(t, mempool, lastAcc, privAccs)
+ txsToSendPerCheck = N
+ tickerChan <- time.Now()
+ pullTxs(t, peer, txsToSendPerCheck) // should have sent N txs
+ block = makeBlock(mempool)
+ ri := mempool.ResetForBlockAndState(block, state)
+ newBlockChan <- ri
+ peer.height = ri.Height
+ txsToSendPerCheck = 100
+ tickerChan <- time.Now()
+ left := len(mempool.txs)
+ if N > 99 {
+ left -= 3
+ } else if N > 29 {
+ left -= 2
+ } else if N > 28 {
+ left -= 1
+ }
+ pullTxs(t, peer, left) // should have sent whatever txs are left that havent been sent
+ }
+}
+
+func pullTxs(t *testing.T, peer *TestPeer, N int) {
+ timer := time.NewTicker(time.Second * 2)
+ for i := 0; i < N; i++ {
+ select {
+ case <-peer.done:
+ case <-timer.C:
+ panic(fmt.Sprintf("invalid number of received messages. Got %d, expected %d\n", i, N))
+ }
+ }
+
+ if N == 0 {
+ select {
+ case <-peer.done:
+ t.Fatalf("should not have sent any more txs")
+ case <-timer.C:
+ }
+ }
+}
+
+func resetPeer(t *testing.T, reactor *MempoolReactor, mempool *Mempool, state *sm.State, tickerChan chan time.Time, newBlockChan chan ResetInfo, peer *TestPeer) *TestPeer {
+ // reset peer
+ mempool.txs = []types.Tx{}
+ mempool.state = state
+ mempool.cache = sm.NewBlockCache(state)
+ peer.SetRunning(false)
+ tickerChan <- time.Now()
+ peer = newPeer(t, state)
+ go reactor.broadcastTxRoutine(tickerChan, newBlockChan, peer)
+ return peer
+}
diff --git a/Godeps/_workspace/src/github.com/tendermint/tendermint/types/keys.go b/Godeps/_workspace/src/github.com/tendermint/tendermint/types/keys.go
new file mode 100644
index 0000000000000000000000000000000000000000..90591b95936e5dc6af8d616a099169f95c9ceca0
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/tendermint/tendermint/types/keys.go
@@ -0,0 +1,6 @@
+package types
+
+var (
+ PeerStateKey = "ConsensusReactor.peerState"
+ PeerMempoolChKey = "MempoolReactor.peerMempoolCh"
+)
diff --git a/Godeps/_workspace/src/golang.org/x/net/context/ctxhttp/cancelreq.go b/Godeps/_workspace/src/golang.org/x/net/context/ctxhttp/cancelreq.go
new file mode 100644
index 0000000000000000000000000000000000000000..48610e3627701c05e1cbf8e12db219af43cbd108
--- /dev/null
+++ b/Godeps/_workspace/src/golang.org/x/net/context/ctxhttp/cancelreq.go
@@ -0,0 +1,18 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build go1.5
+
+package ctxhttp
+
+import "net/http"
+
+func canceler(client *http.Client, req *http.Request) func() {
+ ch := make(chan struct{})
+ req.Cancel = ch
+
+ return func() {
+ close(ch)
+ }
+}
diff --git a/Godeps/_workspace/src/golang.org/x/net/context/ctxhttp/cancelreq_go14.go b/Godeps/_workspace/src/golang.org/x/net/context/ctxhttp/cancelreq_go14.go
new file mode 100644
index 0000000000000000000000000000000000000000..56bcbadb85fcc2a69db540797f41511cf16e5a6d
--- /dev/null
+++ b/Godeps/_workspace/src/golang.org/x/net/context/ctxhttp/cancelreq_go14.go
@@ -0,0 +1,23 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build !go1.5
+
+package ctxhttp
+
+import "net/http"
+
+type requestCanceler interface {
+ CancelRequest(*http.Request)
+}
+
+func canceler(client *http.Client, req *http.Request) func() {
+ rc, ok := client.Transport.(requestCanceler)
+ if !ok {
+ return func() {}
+ }
+ return func() {
+ rc.CancelRequest(req)
+ }
+}
diff --git a/Godeps/_workspace/src/golang.org/x/net/context/ctxhttp/ctxhttp.go b/Godeps/_workspace/src/golang.org/x/net/context/ctxhttp/ctxhttp.go
new file mode 100644
index 0000000000000000000000000000000000000000..0e3c1ebfe17f2fa98d633ee0f7f08cca862a1b19
--- /dev/null
+++ b/Godeps/_workspace/src/golang.org/x/net/context/ctxhttp/ctxhttp.go
@@ -0,0 +1,79 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package ctxhttp provides helper functions for performing context-aware HTTP requests.
+package ctxhttp
+
+import (
+ "io"
+ "net/http"
+ "net/url"
+ "strings"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/golang.org/x/net/context"
+)
+
+// Do sends an HTTP request with the provided http.Client and returns an HTTP response.
+// If the client is nil, http.DefaultClient is used.
+// If the context is canceled or times out, ctx.Err() will be returned.
+func Do(ctx context.Context, client *http.Client, req *http.Request) (*http.Response, error) {
+ if client == nil {
+ client = http.DefaultClient
+ }
+
+ // Request cancelation changed in Go 1.5, see cancelreq.go and cancelreq_go14.go.
+ cancel := canceler(client, req)
+
+ type responseAndError struct {
+ resp *http.Response
+ err error
+ }
+ result := make(chan responseAndError, 1)
+
+ go func() {
+ resp, err := client.Do(req)
+ result <- responseAndError{resp, err}
+ }()
+
+ select {
+ case <-ctx.Done():
+ cancel()
+ return nil, ctx.Err()
+ case r := <-result:
+ return r.resp, r.err
+ }
+}
+
+// Get issues a GET request via the Do function.
+func Get(ctx context.Context, client *http.Client, url string) (*http.Response, error) {
+ req, err := http.NewRequest("GET", url, nil)
+ if err != nil {
+ return nil, err
+ }
+ return Do(ctx, client, req)
+}
+
+// Head issues a HEAD request via the Do function.
+func Head(ctx context.Context, client *http.Client, url string) (*http.Response, error) {
+ req, err := http.NewRequest("HEAD", url, nil)
+ if err != nil {
+ return nil, err
+ }
+ return Do(ctx, client, req)
+}
+
+// Post issues a POST request via the Do function.
+func Post(ctx context.Context, client *http.Client, url string, bodyType string, body io.Reader) (*http.Response, error) {
+ req, err := http.NewRequest("POST", url, body)
+ if err != nil {
+ return nil, err
+ }
+ req.Header.Set("Content-Type", bodyType)
+ return Do(ctx, client, req)
+}
+
+// PostForm issues a POST request via the Do function.
+func PostForm(ctx context.Context, client *http.Client, url string, data url.Values) (*http.Response, error) {
+ return Post(ctx, client, url, "application/x-www-form-urlencoded", strings.NewReader(data.Encode()))
+}
diff --git a/Godeps/_workspace/src/golang.org/x/net/context/ctxhttp/ctxhttp_test.go b/Godeps/_workspace/src/golang.org/x/net/context/ctxhttp/ctxhttp_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..a02a2a97b6248c99260c7aed855d46c19e7d331f
--- /dev/null
+++ b/Godeps/_workspace/src/golang.org/x/net/context/ctxhttp/ctxhttp_test.go
@@ -0,0 +1,72 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ctxhttp
+
+import (
+ "io/ioutil"
+ "net/http"
+ "net/http/httptest"
+ "testing"
+ "time"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/golang.org/x/net/context"
+)
+
+const (
+ requestDuration = 100 * time.Millisecond
+ requestBody = "ok"
+)
+
+func TestNoTimeout(t *testing.T) {
+ ctx := context.Background()
+ resp, err := doRequest(ctx)
+
+ if resp == nil || err != nil {
+ t.Fatalf("error received from client: %v %v", err, resp)
+ }
+}
+func TestCancel(t *testing.T) {
+ ctx, cancel := context.WithCancel(context.Background())
+ go func() {
+ time.Sleep(requestDuration / 2)
+ cancel()
+ }()
+
+ resp, err := doRequest(ctx)
+
+ if resp != nil || err == nil {
+ t.Fatalf("expected error, didn't get one. resp: %v", resp)
+ }
+ if err != ctx.Err() {
+ t.Fatalf("expected error from context but got: %v", err)
+ }
+}
+
+func TestCancelAfterRequest(t *testing.T) {
+ ctx, cancel := context.WithCancel(context.Background())
+
+ resp, err := doRequest(ctx)
+
+ // Cancel before reading the body.
+ // Request.Body should still be readable after the context is canceled.
+ cancel()
+
+ b, err := ioutil.ReadAll(resp.Body)
+ if err != nil || string(b) != requestBody {
+ t.Fatalf("could not read body: %q %v", b, err)
+ }
+}
+
+func doRequest(ctx context.Context) (*http.Response, error) {
+ var okHandler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ time.Sleep(requestDuration)
+ w.Write([]byte(requestBody))
+ })
+
+ serv := httptest.NewServer(okHandler)
+ defer serv.Close()
+
+ return Get(ctx, nil, serv.URL)
+}
diff --git a/Godeps/_workspace/src/gopkg.in/bluesuncorp/validator.v5/examples/simple.go b/Godeps/_workspace/src/gopkg.in/bluesuncorp/validator.v5/examples/simple.go
new file mode 100644
index 0000000000000000000000000000000000000000..c36bd6868f5b65304f232a1902f2105ea86f7344
--- /dev/null
+++ b/Godeps/_workspace/src/gopkg.in/bluesuncorp/validator.v5/examples/simple.go
@@ -0,0 +1,85 @@
+package main
+
+import (
+ "fmt"
+
+ "gopkg.in/go-playground/validator.v5"
+)
+
+// User contains user information
+type User struct {
+ FirstName string `validate:"required"`
+ LastName string `validate:"required"`
+ Age uint8 `validate:"gte=0,lte=130"`
+ Email string `validate:"required,email"`
+ FavouriteColor string `validate:"hexcolor|rgb|rgba"`
+ Addresses []*Address `validate:"required,dive,required"` // a person can have a home and cottage...
+}
+
+// Address houses a users address information
+type Address struct {
+ Street string `validate:"required"`
+ City string `validate:"required"`
+ Planet string `validate:"required"`
+ Phone string `validate:"required"`
+}
+
+var validate *validator.Validate
+
+func main() {
+
+ validate = validator.New("validate", validator.BakedInValidators)
+
+ address := &Address{
+ Street: "Eavesdown Docks",
+ Planet: "Persphone",
+ Phone: "none",
+ }
+
+ user := &User{
+ FirstName: "Badger",
+ LastName: "Smith",
+ Age: 135,
+ Email: "Badger.Smith@gmail.com",
+ FavouriteColor: "#000",
+ Addresses: []*Address{address},
+ }
+
+ // returns nil or *StructErrors
+ errs := validate.Struct(user)
+
+ if errs != nil {
+
+ // err will be of type *FieldError
+ err := errs.Errors["Age"]
+ fmt.Println(err.Error()) // output: Field validation for "Age" failed on the "lte" tag
+ fmt.Println(err.Field) // output: Age
+ fmt.Println(err.Tag) // output: lte
+ fmt.Println(err.Kind) // output: uint8
+ fmt.Println(err.Type) // output: uint8
+ fmt.Println(err.Param) // output: 130
+ fmt.Println(err.Value) // output: 135
+
+ // or if you prefer you can use the Flatten function
+ // NOTE: I find this usefull when using a more hard static approach of checking field errors.
+ // The above, is best for passing to some generic code to say parse the errors. i.e. I pass errs
+ // to a routine which loops through the errors, creates and translates the error message into the
+ // users locale and returns a map of map[string]string // field and error which I then use
+ // within the HTML rendering.
+
+ flat := errs.Flatten()
+ fmt.Println(flat) // output: map[Age:Field validation for "Age" failed on the "lte" tag Addresses[0].Address.City:Field validation for "City" failed on the "required" tag]
+ err = flat["Addresses[0].Address.City"]
+ fmt.Println(err.Field) // output: City
+ fmt.Println(err.Tag) // output: required
+ fmt.Println(err.Kind) // output: string
+ fmt.Println(err.Type) // output: string
+ fmt.Println(err.Param) // output:
+ fmt.Println(err.Value) // output:
+
+ // from here you can create your own error messages in whatever language you wish
+ return
+ }
+
+ // save user to database
+}