Ethan Buchman
7 years ago
committed by
GitHub
GitHub
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
13 changed files with 740 additions and 273 deletions
Split View
Diff Options
-
+13 -0CHANGELOG.md
-
+7 -20cli/setup.go
-
+5 -11cli/setup_test.go
-
+152 -94clist/clist.go
-
+3 -4common/bit_array.go
-
+100 -21common/random.go
-
+120 -0common/random_test.go
-
+184 -42common/repeat_timer.go
-
+68 -54common/repeat_timer_test.go
-
+56 -13pubsub/pubsub.go
-
+25 -7pubsub/pubsub_test.go
-
+6 -6test.sh
-
+1 -1version/version.go
+ 13
- 0
CHANGELOG.md
View File
+ 7
- 20
cli/setup.go
View File
+ 5
- 11
cli/setup_test.go
View File
+ 152
- 94
clist/clist.go
View File
+ 3
- 4
common/bit_array.go
View File
+ 100
- 21
common/random.go
View File
+ 120
- 0
common/random_test.go
View File
| @ -0,0 +1,120 @@ | |||
| package common | |||
| import ( | |||
| "bytes" | |||
| "encoding/json" | |||
| "fmt" | |||
| "io" | |||
| mrand "math/rand" | |||
| "sync" | |||
| "testing" | |||
| "time" | |||
| "github.com/stretchr/testify/assert" | |||
| ) | |||
| func TestRandStr(t *testing.T) { | |||
| l := 243 | |||
| s := RandStr(l) | |||
| assert.Equal(t, l, len(s)) | |||
| } | |||
| func TestRandBytes(t *testing.T) { | |||
| l := 243 | |||
| b := RandBytes(l) | |||
| assert.Equal(t, l, len(b)) | |||
| } | |||
| func TestRandIntn(t *testing.T) { | |||
| n := 243 | |||
| for i := 0; i < 100; i++ { | |||
| x := RandIntn(n) | |||
| assert.True(t, x < n) | |||
| } | |||
| } | |||
| // It is essential that these tests run and never repeat their outputs | |||
| // lest we've been pwned and the behavior of our randomness is controlled. | |||
| // See Issues: | |||
| // * https://github.com/tendermint/tmlibs/issues/99 | |||
| // * https://github.com/tendermint/tendermint/issues/973 | |||
| func TestUniqueRng(t *testing.T) { | |||
| buf := new(bytes.Buffer) | |||
| outputs := make(map[string][]int) | |||
| for i := 0; i < 100; i++ { | |||
| testThemAll(buf) | |||
| output := buf.String() | |||
| buf.Reset() | |||
| runs, seen := outputs[output] | |||
| if seen { | |||
| t.Errorf("Run #%d's output was already seen in previous runs: %v", i, runs) | |||
| } | |||
| outputs[output] = append(outputs[output], i) | |||
| } | |||
| } | |||
| func testThemAll(out io.Writer) { | |||
| // Reset the internal PRNG | |||
| reset() | |||
| // Set math/rand's Seed so that any direct invocations | |||
| // of math/rand will reveal themselves. | |||
| mrand.Seed(1) | |||
| perm := RandPerm(10) | |||
| blob, _ := json.Marshal(perm) | |||
| fmt.Fprintf(out, "perm: %s\n", blob) | |||
| fmt.Fprintf(out, "randInt: %d\n", RandInt()) | |||
| fmt.Fprintf(out, "randUint: %d\n", RandUint()) | |||
| fmt.Fprintf(out, "randIntn: %d\n", RandIntn(97)) | |||
| fmt.Fprintf(out, "randInt31: %d\n", RandInt31()) | |||
| fmt.Fprintf(out, "randInt32: %d\n", RandInt32()) | |||
| fmt.Fprintf(out, "randInt63: %d\n", RandInt63()) | |||
| fmt.Fprintf(out, "randInt64: %d\n", RandInt64()) | |||
| fmt.Fprintf(out, "randUint32: %d\n", RandUint32()) | |||
| fmt.Fprintf(out, "randUint64: %d\n", RandUint64()) | |||
| fmt.Fprintf(out, "randUint16Exp: %d\n", RandUint16Exp()) | |||
| fmt.Fprintf(out, "randUint32Exp: %d\n", RandUint32Exp()) | |||
| fmt.Fprintf(out, "randUint64Exp: %d\n", RandUint64Exp()) | |||
| } | |||
| func TestRngConcurrencySafety(t *testing.T) { | |||
| var wg sync.WaitGroup | |||
| for i := 0; i < 100; i++ { | |||
| wg.Add(1) | |||
| go func() { | |||
| defer wg.Done() | |||
| _ = RandUint64() | |||
| <-time.After(time.Millisecond * time.Duration(RandIntn(100))) | |||
| _ = RandPerm(3) | |||
| }() | |||
| } | |||
| wg.Wait() | |||
| } | |||
| func BenchmarkRandBytes10B(b *testing.B) { | |||
| benchmarkRandBytes(b, 10) | |||
| } | |||
| func BenchmarkRandBytes100B(b *testing.B) { | |||
| benchmarkRandBytes(b, 100) | |||
| } | |||
| func BenchmarkRandBytes1KiB(b *testing.B) { | |||
| benchmarkRandBytes(b, 1024) | |||
| } | |||
| func BenchmarkRandBytes10KiB(b *testing.B) { | |||
| benchmarkRandBytes(b, 10*1024) | |||
| } | |||
| func BenchmarkRandBytes100KiB(b *testing.B) { | |||
| benchmarkRandBytes(b, 100*1024) | |||
| } | |||
| func BenchmarkRandBytes1MiB(b *testing.B) { | |||
| benchmarkRandBytes(b, 1024*1024) | |||
| } | |||
| func benchmarkRandBytes(b *testing.B, n int) { | |||
| for i := 0; i < b.N; i++ { | |||
| _ = RandBytes(n) | |||
| } | |||
| b.ReportAllocs() | |||
| } | |||
+ 184
- 42
common/repeat_timer.go
View File
+ 68
- 54
common/repeat_timer_test.go
View File
| @ -1,78 +1,92 @@ | |||
| package common | |||
| import ( | |||
| "sync" | |||
| "testing" | |||
| "time" | |||
| // make govet noshadow happy... | |||
| asrt "github.com/stretchr/testify/assert" | |||
| "github.com/stretchr/testify/assert" | |||
| ) | |||
| type rCounter struct { | |||
| input chan time.Time | |||
| mtx sync.Mutex | |||
| count int | |||
| func TestDefaultTicker(t *testing.T) { | |||
| ticker := defaultTickerMaker(time.Millisecond * 10) | |||
| <-ticker.Chan() | |||
| ticker.Stop() | |||
| } | |||
| func (c *rCounter) Increment() { | |||
| c.mtx.Lock() | |||
| c.count++ | |||
| c.mtx.Unlock() | |||
| } | |||
| func TestRepeat(t *testing.T) { | |||
| func (c *rCounter) Count() int { | |||
| c.mtx.Lock() | |||
| val := c.count | |||
| c.mtx.Unlock() | |||
| return val | |||
| } | |||
| ch := make(chan time.Time, 100) | |||
| lt := time.Time{} // zero time is year 1 | |||
| // Read should run in a go-routine and | |||
| // updates count by one every time a packet comes in | |||
| func (c *rCounter) Read() { | |||
| for range c.input { | |||
| c.Increment() | |||
| // tick fires `cnt` times for each second. | |||
| tick := func(cnt int) { | |||
| for i := 0; i < cnt; i++ { | |||
| lt = lt.Add(time.Second) | |||
| ch <- lt | |||
| } | |||
| } | |||
| } | |||
| func TestRepeat(test *testing.T) { | |||
| assert := asrt.New(test) | |||
| dur := time.Duration(50) * time.Millisecond | |||
| short := time.Duration(20) * time.Millisecond | |||
| // delay waits for cnt durations, an a little extra | |||
| delay := func(cnt int) time.Duration { | |||
| return time.Duration(cnt)*dur + time.Millisecond | |||
| // tock consumes Ticker.Chan() events `cnt` times. | |||
| tock := func(t *testing.T, rt *RepeatTimer, cnt int) { | |||
| for i := 0; i < cnt; i++ { | |||
| timeout := time.After(time.Second * 10) | |||
| select { | |||
| case <-rt.Chan(): | |||
| case <-timeout: | |||
| panic("expected RepeatTimer to fire") | |||
| } | |||
| } | |||
| done := true | |||
| select { | |||
| case <-rt.Chan(): | |||
| done = false | |||
| default: | |||
| } | |||
| assert.True(t, done) | |||
| } | |||
| t := NewRepeatTimer("bar", dur) | |||
| // start at 0 | |||
| c := &rCounter{input: t.Ch} | |||
| go c.Read() | |||
| assert.Equal(0, c.Count()) | |||
| tm := NewLogicalTickerMaker(ch) | |||
| dur := time.Duration(10 * time.Millisecond) // less than a second | |||
| rt := NewRepeatTimerWithTickerMaker("bar", dur, tm) | |||
| // Start at 0. | |||
| tock(t, rt, 0) | |||
| tick(1) // init time | |||
| // wait for 4 periods | |||
| time.Sleep(delay(4)) | |||
| assert.Equal(4, c.Count()) | |||
| tock(t, rt, 0) | |||
| tick(1) // wait 1 periods | |||
| tock(t, rt, 1) | |||
| tick(2) // wait 2 periods | |||
| tock(t, rt, 2) | |||
| tick(3) // wait 3 periods | |||
| tock(t, rt, 3) | |||
| tick(4) // wait 4 periods | |||
| tock(t, rt, 4) | |||
| // keep reseting leads to no firing | |||
| // Multiple resets leads to no firing. | |||
| for i := 0; i < 20; i++ { | |||
| time.Sleep(short) | |||
| t.Reset() | |||
| time.Sleep(time.Millisecond) | |||
| rt.Reset() | |||
| } | |||
| assert.Equal(4, c.Count()) | |||
| // after this, it still works normal | |||
| time.Sleep(delay(2)) | |||
| assert.Equal(6, c.Count()) | |||
| // After this, it works as new. | |||
| tock(t, rt, 0) | |||
| tick(1) // init time | |||
| tock(t, rt, 0) | |||
| tick(1) // wait 1 periods | |||
| tock(t, rt, 1) | |||
| tick(2) // wait 2 periods | |||
| tock(t, rt, 2) | |||
| tick(3) // wait 3 periods | |||
| tock(t, rt, 3) | |||
| tick(4) // wait 4 periods | |||
| tock(t, rt, 4) | |||
| // after a stop, nothing more is sent | |||
| stopped := t.Stop() | |||
| assert.True(stopped) | |||
| time.Sleep(delay(7)) | |||
| assert.Equal(6, c.Count()) | |||
| // After a stop, nothing more is sent. | |||
| rt.Stop() | |||
| tock(t, rt, 0) | |||
| // close channel to stop counter | |||
| close(t.Ch) | |||
| // Another stop panics. | |||
| assert.Panics(t, func() { rt.Stop() }) | |||
| } | |||
+ 56
- 13
pubsub/pubsub.go
View File
+ 25
- 7
pubsub/pubsub_test.go
View File
+ 6
- 6
test.sh
View File
+ 1
- 1
version/version.go
View File
| @ -1,3 +1,3 @@ | |||
| package version | |||
| const Version = "0.5.0" | |||
| const Version = "0.6.0" | |||