github.com/demonoid81/moby@v0.0.0-20200517203328-62dd8e17c460/pkg/pools/pools_test.go (about) 1 package pools // import "github.com/demonoid81/moby/pkg/pools" 2 3 import ( 4 "bufio" 5 "bytes" 6 "io" 7 "strings" 8 "testing" 9 10 "gotest.tools/v3/assert" 11 is "gotest.tools/v3/assert/cmp" 12 ) 13 14 func TestBufioReaderPoolGetWithNoReaderShouldCreateOne(t *testing.T) { 15 reader := BufioReader32KPool.Get(nil) 16 if reader == nil { 17 t.Fatalf("BufioReaderPool should have create a bufio.Reader but did not.") 18 } 19 } 20 21 func TestBufioReaderPoolPutAndGet(t *testing.T) { 22 sr := bufio.NewReader(strings.NewReader("foobar")) 23 reader := BufioReader32KPool.Get(sr) 24 if reader == nil { 25 t.Fatalf("BufioReaderPool should not return a nil reader.") 26 } 27 // verify the first 3 byte 28 buf1 := make([]byte, 3) 29 _, err := reader.Read(buf1) 30 if err != nil { 31 t.Fatal(err) 32 } 33 if actual := string(buf1); actual != "foo" { 34 t.Fatalf("The first letter should have been 'foo' but was %v", actual) 35 } 36 BufioReader32KPool.Put(reader) 37 // Try to read the next 3 bytes 38 _, err = sr.Read(make([]byte, 3)) 39 if err == nil || err != io.EOF { 40 t.Fatalf("The buffer should have been empty, issue an EOF error.") 41 } 42 } 43 44 type simpleReaderCloser struct { 45 io.Reader 46 closed bool 47 } 48 49 func (r *simpleReaderCloser) Close() error { 50 r.closed = true 51 return nil 52 } 53 54 func TestNewReadCloserWrapperWithAReadCloser(t *testing.T) { 55 br := bufio.NewReader(strings.NewReader("")) 56 sr := &simpleReaderCloser{ 57 Reader: strings.NewReader("foobar"), 58 closed: false, 59 } 60 reader := BufioReader32KPool.NewReadCloserWrapper(br, sr) 61 if reader == nil { 62 t.Fatalf("NewReadCloserWrapper should not return a nil reader.") 63 } 64 // Verify the content of reader 65 buf := make([]byte, 3) 66 _, err := reader.Read(buf) 67 if err != nil { 68 t.Fatal(err) 69 } 70 if actual := string(buf); actual != "foo" { 71 t.Fatalf("The first 3 letter should have been 'foo' but were %v", actual) 72 } 73 reader.Close() 74 // Read 3 more bytes "bar" 75 _, err = reader.Read(buf) 76 if err != nil { 77 t.Fatal(err) 78 } 79 if actual := string(buf); actual != "bar" { 80 t.Fatalf("The first 3 letter should have been 'bar' but were %v", actual) 81 } 82 if !sr.closed { 83 t.Fatalf("The ReaderCloser should have been closed, it is not.") 84 } 85 } 86 87 func TestBufioWriterPoolGetWithNoReaderShouldCreateOne(t *testing.T) { 88 writer := BufioWriter32KPool.Get(nil) 89 if writer == nil { 90 t.Fatalf("BufioWriterPool should have create a bufio.Writer but did not.") 91 } 92 } 93 94 func TestBufioWriterPoolPutAndGet(t *testing.T) { 95 buf := new(bytes.Buffer) 96 bw := bufio.NewWriter(buf) 97 writer := BufioWriter32KPool.Get(bw) 98 assert.Assert(t, writer != nil) 99 100 written, err := writer.Write([]byte("foobar")) 101 assert.NilError(t, err) 102 assert.Check(t, is.Equal(6, written)) 103 104 // Make sure we Flush all the way ? 105 writer.Flush() 106 bw.Flush() 107 assert.Check(t, is.Len(buf.Bytes(), 6)) 108 // Reset the buffer 109 buf.Reset() 110 BufioWriter32KPool.Put(writer) 111 // Try to write something 112 if _, err = writer.Write([]byte("barfoo")); err != nil { 113 t.Fatal(err) 114 } 115 // If we now try to flush it, it should panic (the writer is nil) 116 // recover it 117 defer func() { 118 if r := recover(); r == nil { 119 t.Fatal("Trying to flush the writter should have 'paniced', did not.") 120 } 121 }() 122 writer.Flush() 123 } 124 125 type simpleWriterCloser struct { 126 io.Writer 127 closed bool 128 } 129 130 func (r *simpleWriterCloser) Close() error { 131 r.closed = true 132 return nil 133 } 134 135 func TestNewWriteCloserWrapperWithAWriteCloser(t *testing.T) { 136 buf := new(bytes.Buffer) 137 bw := bufio.NewWriter(buf) 138 sw := &simpleWriterCloser{ 139 Writer: new(bytes.Buffer), 140 closed: false, 141 } 142 bw.Flush() 143 writer := BufioWriter32KPool.NewWriteCloserWrapper(bw, sw) 144 if writer == nil { 145 t.Fatalf("BufioReaderPool should not return a nil writer.") 146 } 147 written, err := writer.Write([]byte("foobar")) 148 if err != nil { 149 t.Fatal(err) 150 } 151 if written != 6 { 152 t.Fatalf("Should have written 6 bytes, but wrote %v bytes", written) 153 } 154 writer.Close() 155 if !sw.closed { 156 t.Fatalf("The ReaderCloser should have been closed, it is not.") 157 } 158 } 159 160 func TestBufferPoolPutAndGet(t *testing.T) { 161 buf := buffer32KPool.Get() 162 buffer32KPool.Put(buf) 163 }