package ioutils import ( "bytes" "fmt" "io" "io/ioutil" "strings" "testing" "time" ) // Implement io.Reader type errorReader struct{} func (r *errorReader) Read(p []byte) (int, error) { return 0, fmt.Errorf("Error reader always fail.") } func TestReadCloserWrapperClose(t *testing.T) { reader := strings.NewReader("A string reader") wrapper := NewReadCloserWrapper(reader, func() error { return fmt.Errorf("This will be called when closing") }) err := wrapper.Close() if err == nil || !strings.Contains(err.Error(), "This will be called when closing") { t.Fatalf("readCloserWrapper should have call the anonymous func and thus, fail.") } } func TestReaderErrWrapperReadOnError(t *testing.T) { called := false reader := &errorReader{} wrapper := NewReaderErrWrapper(reader, func() { called = true }) _, err := wrapper.Read([]byte{}) if err == nil || !strings.Contains(err.Error(), "Error reader always fail.") { t.Fatalf("readErrWrapper should returned an error") } if !called { t.Fatalf("readErrWrapper should have call the anonymous function on failure") } } func TestReaderErrWrapperRead(t *testing.T) { reader := strings.NewReader("a string reader.") wrapper := NewReaderErrWrapper(reader, func() { t.Fatalf("readErrWrapper should not have called the anonymous function") }) // Read 20 byte (should be ok with the string above) num, err := wrapper.Read(make([]byte, 20)) if err != nil { t.Fatal(err) } if num != 16 { t.Fatalf("readerErrWrapper should have read 16 byte, but read %d", num) } } func TestNewBufReaderWithDrainbufAndBuffer(t *testing.T) { reader, writer := io.Pipe() drainBuffer := make([]byte, 1024) buffer := NewBytesPipe(nil) bufreader := NewBufReaderWithDrainbufAndBuffer(reader, drainBuffer, buffer) // Write everything down to a Pipe // Usually, a pipe should block but because of the buffered reader, // the writes will go through done := make(chan bool) go func() { writer.Write([]byte("hello world")) writer.Close() done <- true }() // Drain the reader *after* everything has been written, just to verify // it is indeed buffering select { case <-done: case <-time.After(1 * time.Second): t.Fatal("timeout") } output, err := ioutil.ReadAll(bufreader) if err != nil { t.Fatal(err) } if !bytes.Equal(output, []byte("hello world")) { t.Error(string(output)) } } func TestBufReader(t *testing.T) { reader, writer := io.Pipe() bufreader := NewBufReader(reader) // Write everything down to a Pipe // Usually, a pipe should block but because of the buffered reader, // the writes will go through done := make(chan bool) go func() { writer.Write([]byte("hello world")) writer.Close() done <- true }() // Drain the reader *after* everything has been written, just to verify // it is indeed buffering <-done output, err := ioutil.ReadAll(bufreader) if err != nil { t.Fatal(err) } if !bytes.Equal(output, []byte("hello world")) { t.Error(string(output)) } } func TestBufReaderCloseWithNonReaderCloser(t *testing.T) { reader := strings.NewReader("buffer") bufreader := NewBufReader(reader) if err := bufreader.Close(); err != nil { t.Fatal(err) } } // implements io.ReadCloser type simpleReaderCloser struct { err error } func (r *simpleReaderCloser) Read(p []byte) (n int, err error) { return 0, r.err } func (r *simpleReaderCloser) Close() error { r.err = io.EOF return nil } func TestBufReaderCloseWithReaderCloser(t *testing.T) { reader := &simpleReaderCloser{} bufreader := NewBufReader(reader) err := bufreader.Close() if err != nil { t.Fatal(err) } } func TestHashData(t *testing.T) { reader := strings.NewReader("hash-me") actual, err := HashData(reader) if err != nil { t.Fatal(err) } expected := "sha256:4d11186aed035cc624d553e10db358492c84a7cd6b9670d92123c144930450aa" if actual != expected { t.Fatalf("Expecting %s, got %s", expected, actual) } } type repeatedReader struct { readCount int maxReads int data []byte } func newRepeatedReader(max int, data []byte) *repeatedReader { return &repeatedReader{0, max, data} } func (r *repeatedReader) Read(p []byte) (int, error) { if r.readCount >= r.maxReads { return 0, io.EOF } r.readCount++ n := copy(p, r.data) return n, nil } func testWithData(data []byte, reads int) { reader := newRepeatedReader(reads, data) bufReader := NewBufReader(reader) io.Copy(ioutil.Discard, bufReader) } func Benchmark1M10BytesReads(b *testing.B) { reads := 1000000 readSize := int64(10) data := make([]byte, readSize) b.SetBytes(readSize * int64(reads)) b.ResetTimer() for i := 0; i < b.N; i++ { testWithData(data, reads) } } func Benchmark1M1024BytesReads(b *testing.B) { reads := 1000000 readSize := int64(1024) data := make([]byte, readSize) b.SetBytes(readSize * int64(reads)) b.ResetTimer() for i := 0; i < b.N; i++ { testWithData(data, reads) } } func Benchmark10k32KBytesReads(b *testing.B) { reads := 10000 readSize := int64(32 * 1024) data := make([]byte, readSize) b.SetBytes(readSize * int64(reads)) b.ResetTimer() for i := 0; i < b.N; i++ { testWithData(data, reads) } }