github.com/endophage/docker@v1.4.2-0.20161027011718-242853499895/pkg/ioutils/bytespipe_test.go (about)

     1  package ioutils
     2  
     3  import (
     4  	"crypto/sha1"
     5  	"encoding/hex"
     6  	"math/rand"
     7  	"testing"
     8  	"time"
     9  )
    10  
    11  func TestBytesPipeRead(t *testing.T) {
    12  	buf := NewBytesPipe()
    13  	buf.Write([]byte("12"))
    14  	buf.Write([]byte("34"))
    15  	buf.Write([]byte("56"))
    16  	buf.Write([]byte("78"))
    17  	buf.Write([]byte("90"))
    18  	rd := make([]byte, 4)
    19  	n, err := buf.Read(rd)
    20  	if err != nil {
    21  		t.Fatal(err)
    22  	}
    23  	if n != 4 {
    24  		t.Fatalf("Wrong number of bytes read: %d, should be %d", n, 4)
    25  	}
    26  	if string(rd) != "1234" {
    27  		t.Fatalf("Read %s, but must be %s", rd, "1234")
    28  	}
    29  	n, err = buf.Read(rd)
    30  	if err != nil {
    31  		t.Fatal(err)
    32  	}
    33  	if n != 4 {
    34  		t.Fatalf("Wrong number of bytes read: %d, should be %d", n, 4)
    35  	}
    36  	if string(rd) != "5678" {
    37  		t.Fatalf("Read %s, but must be %s", rd, "5679")
    38  	}
    39  	n, err = buf.Read(rd)
    40  	if err != nil {
    41  		t.Fatal(err)
    42  	}
    43  	if n != 2 {
    44  		t.Fatalf("Wrong number of bytes read: %d, should be %d", n, 2)
    45  	}
    46  	if string(rd[:n]) != "90" {
    47  		t.Fatalf("Read %s, but must be %s", rd, "90")
    48  	}
    49  }
    50  
    51  func TestBytesPipeWrite(t *testing.T) {
    52  	buf := NewBytesPipe()
    53  	buf.Write([]byte("12"))
    54  	buf.Write([]byte("34"))
    55  	buf.Write([]byte("56"))
    56  	buf.Write([]byte("78"))
    57  	buf.Write([]byte("90"))
    58  	if buf.buf[0].String() != "1234567890" {
    59  		t.Fatalf("Buffer %q, must be %q", buf.buf[0].String(), "1234567890")
    60  	}
    61  }
    62  
    63  // Write and read in different speeds/chunk sizes and check valid data is read.
    64  func TestBytesPipeWriteRandomChunks(t *testing.T) {
    65  	cases := []struct{ iterations, writesPerLoop, readsPerLoop int }{
    66  		{100, 10, 1},
    67  		{1000, 10, 5},
    68  		{1000, 100, 0},
    69  		{1000, 5, 6},
    70  		{10000, 50, 25},
    71  	}
    72  
    73  	testMessage := []byte("this is a random string for testing")
    74  	// random slice sizes to read and write
    75  	writeChunks := []int{25, 35, 15, 20}
    76  	readChunks := []int{5, 45, 20, 25}
    77  
    78  	for _, c := range cases {
    79  		// first pass: write directly to hash
    80  		hash := sha1.New()
    81  		for i := 0; i < c.iterations*c.writesPerLoop; i++ {
    82  			if _, err := hash.Write(testMessage[:writeChunks[i%len(writeChunks)]]); err != nil {
    83  				t.Fatal(err)
    84  			}
    85  		}
    86  		expected := hex.EncodeToString(hash.Sum(nil))
    87  
    88  		// write/read through buffer
    89  		buf := NewBytesPipe()
    90  		hash.Reset()
    91  
    92  		done := make(chan struct{})
    93  
    94  		go func() {
    95  			// random delay before read starts
    96  			<-time.After(time.Duration(rand.Intn(10)) * time.Millisecond)
    97  			for i := 0; ; i++ {
    98  				p := make([]byte, readChunks[(c.iterations*c.readsPerLoop+i)%len(readChunks)])
    99  				n, _ := buf.Read(p)
   100  				if n == 0 {
   101  					break
   102  				}
   103  				hash.Write(p[:n])
   104  			}
   105  
   106  			close(done)
   107  		}()
   108  
   109  		for i := 0; i < c.iterations; i++ {
   110  			for w := 0; w < c.writesPerLoop; w++ {
   111  				buf.Write(testMessage[:writeChunks[(i*c.writesPerLoop+w)%len(writeChunks)]])
   112  			}
   113  		}
   114  		buf.Close()
   115  		<-done
   116  
   117  		actual := hex.EncodeToString(hash.Sum(nil))
   118  
   119  		if expected != actual {
   120  			t.Fatalf("BytesPipe returned invalid data. Expected checksum %v, got %v", expected, actual)
   121  		}
   122  
   123  	}
   124  }
   125  
   126  func BenchmarkBytesPipeWrite(b *testing.B) {
   127  	testData := []byte("pretty short line, because why not?")
   128  	for i := 0; i < b.N; i++ {
   129  		readBuf := make([]byte, 1024)
   130  		buf := NewBytesPipe()
   131  		go func() {
   132  			var err error
   133  			for err == nil {
   134  				_, err = buf.Read(readBuf)
   135  			}
   136  		}()
   137  		for j := 0; j < 1000; j++ {
   138  			buf.Write(testData)
   139  		}
   140  		buf.Close()
   141  	}
   142  }
   143  
   144  func BenchmarkBytesPipeRead(b *testing.B) {
   145  	rd := make([]byte, 512)
   146  	for i := 0; i < b.N; i++ {
   147  		b.StopTimer()
   148  		buf := NewBytesPipe()
   149  		for j := 0; j < 500; j++ {
   150  			buf.Write(make([]byte, 1024))
   151  		}
   152  		b.StartTimer()
   153  		for j := 0; j < 1000; j++ {
   154  			if n, _ := buf.Read(rd); n != 512 {
   155  				b.Fatalf("Wrong number of bytes: %d", n)
   156  			}
   157  		}
   158  	}
   159  }