/
arrayPool_test.go
123 lines (109 loc) · 3.24 KB
/
arrayPool_test.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
package gopool_test
import (
"errors"
"testing"
"github.com/karrick/gopool"
)
func TestArrayPoolErrorWithoutFactory(t *testing.T) {
pool, err := gopool.NewArrayPool()
if pool != nil {
t.Errorf("Actual: %#v; Expected: %#v", pool, nil)
}
if err == nil {
t.Errorf("Actual: %#v; Expected: %#v", err, "not nil")
}
}
func TestArrayPoolErrorWithNonPositiveSize(t *testing.T) {
pool, err := gopool.NewArrayPool(gopool.Size(0))
if pool != nil {
t.Errorf("Actual: %#v; Expected: %#v", pool, nil)
}
if err == nil {
t.Errorf("Actual: %#v; Expected: %#v", err, "not nil")
}
pool, err = gopool.NewArrayPool(gopool.Size(-1))
if pool != nil {
t.Errorf("Actual: %#v; Expected: %#v", pool, nil)
}
if err == nil {
t.Errorf("Actual: %#v; Expected: %#v", err, "not nil")
}
}
func TestArrayPoolCreatesSizeItems(t *testing.T) {
var size = 42
var factoryInvoked int
_, err := gopool.NewArrayPool(gopool.Size(size),
gopool.Factory(func() (interface{}, error) {
factoryInvoked++
return nil, nil
}))
if err != nil {
t.Fatal(err)
}
if actual, expected := factoryInvoked, size; actual != expected {
t.Errorf("Actual: %#v; Expected: %#v", actual, expected)
}
}
func TestArrayPoolInvokesReset(t *testing.T) {
var resetInvoked int
pool, err := gopool.NewArrayPool(
gopool.Factory(func() (interface{}, error) {
return nil, nil
}),
gopool.Reset(func(item interface{}) {
resetInvoked++
}))
if err != nil {
t.Fatal(err)
}
pool.Put(pool.Get())
if actual, expected := resetInvoked, 1; actual != expected {
t.Errorf("Actual: %#v; Expected: %#v", actual, expected)
}
}
func TestArrayPoolInvokesClose(t *testing.T) {
var closeInvoked int
pool, err := gopool.NewArrayPool(gopool.Size(1),
gopool.Factory(func() (interface{}, error) {
return nil, nil
}),
gopool.Close(func(_ interface{}) error {
closeInvoked++
return errors.New("foo")
}))
if err != nil {
t.Fatal(err)
}
if err := pool.Close(); err == nil || err.Error() != "foo" {
t.Errorf("Actual: %#v; Expected: %#v", err, "foo")
}
if actual, expected := closeInvoked, 1; actual != expected {
t.Errorf("Actual: %#v; Expected: %#v", actual, expected)
}
}
func TestArrayPool(t *testing.T) {
pool, err := gopool.NewArrayPool(gopool.Factory(makeBuffer), gopool.Reset(resetBuffer), gopool.Close(closeBuffer))
if err != nil {
t.Fatalf("Actual: %#v; Expected: %#v", err, nil)
}
test(t, pool)
}
func TestArrayPoolSize(t *testing.T) {
pool, err := gopool.NewArrayPool(gopool.Factory(makeBuffer), gopool.Reset(resetBuffer), gopool.Close(closeBuffer), gopool.Size(lowCap))
if err != nil {
t.Fatal(err)
}
test(t, pool)
}
func BenchmarkArrayLowConcurrency(b *testing.B) {
pool, _ := gopool.NewArrayPool(gopool.Factory(makeBuffer), gopool.Reset(resetBuffer), gopool.Close(closeBuffer), gopool.Size(lowCap))
bench(b, pool, lowConcurrency)
}
func BenchmarkArrayMediumConcurrency(b *testing.B) {
pool, _ := gopool.NewArrayPool(gopool.Factory(makeBuffer), gopool.Reset(resetBuffer), gopool.Close(closeBuffer), gopool.Size(medCap))
bench(b, pool, medConcurrency)
}
func BenchmarkArrayHighConcurrency(b *testing.B) {
pool, _ := gopool.NewArrayPool(gopool.Factory(makeBuffer), gopool.Reset(resetBuffer), gopool.Close(closeBuffer), gopool.Size(largeCap))
bench(b, pool, highConcurrency)
}