writer_test.go

Documentation: compress/flate

     1  // Copyright 2012 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package flate
     6  
     7  import (
     8  	"bytes"
     9  	"fmt"
    10  	"io"
    11  	"math/rand"
    12  	"runtime"
    13  	"testing"
    14  )
    15  
    16  func BenchmarkEncode(b *testing.B) {
    17  	doBench(b, func(b *testing.B, buf0 []byte, level, n int) {
    18  		b.StopTimer()
    19  		b.SetBytes(int64(n))
    20  
    21  		buf1 := make([]byte, n)
    22  		for i := 0; i < n; i += len(buf0) {
    23  			if len(buf0) > n-i {
    24  				buf0 = buf0[:n-i]
    25  			}
    26  			copy(buf1[i:], buf0)
    27  		}
    28  		buf0 = nil
    29  		w, err := NewWriter(io.Discard, level)
    30  		if err != nil {
    31  			b.Fatal(err)
    32  		}
    33  		runtime.GC()
    34  		b.StartTimer()
    35  		for i := 0; i < b.N; i++ {
    36  			w.Reset(io.Discard)
    37  			w.Write(buf1)
    38  			w.Close()
    39  		}
    40  	})
    41  }
    42  
    43  // errorWriter is a writer that fails after N writes.
    44  type errorWriter struct {
    45  	N int
    46  }
    47  
    48  func (e *errorWriter) Write(b []byte) (int, error) {
    49  	if e.N <= 0 {
    50  		return 0, io.ErrClosedPipe
    51  	}
    52  	e.N--
    53  	return len(b), nil
    54  }
    55  
    56  // Test if errors from the underlying writer is passed upwards.
    57  func TestWriteError(t *testing.T) {
    58  	t.Parallel()
    59  	buf := new(bytes.Buffer)
    60  	n := 65536
    61  	if !testing.Short() {
    62  		n *= 4
    63  	}
    64  	for i := 0; i < n; i++ {
    65  		fmt.Fprintf(buf, "asdasfasf%d%dfghfgujyut%dyutyu\n", i, i, i)
    66  	}
    67  	in := buf.Bytes()
    68  	// We create our own buffer to control number of writes.
    69  	copyBuffer := make([]byte, 128)
    70  	for l := 0; l < 10; l++ {
    71  		for fail := 1; fail <= 256; fail *= 2 {
    72  			// Fail after 'fail' writes
    73  			ew := &errorWriter{N: fail}
    74  			w, err := NewWriter(ew, l)
    75  			if err != nil {
    76  				t.Fatalf("NewWriter: level %d: %v", l, err)
    77  			}
    78  			n, err := io.CopyBuffer(w, struct{ io.Reader }{bytes.NewBuffer(in)}, copyBuffer)
    79  			if err == nil {
    80  				t.Fatalf("Level %d: Expected an error, writer was %#v", l, ew)
    81  			}
    82  			n2, err := w.Write([]byte{1, 2, 2, 3, 4, 5})
    83  			if n2 != 0 {
    84  				t.Fatal("Level", l, "Expected 0 length write, got", n)
    85  			}
    86  			if err == nil {
    87  				t.Fatal("Level", l, "Expected an error")
    88  			}
    89  			err = w.Flush()
    90  			if err == nil {
    91  				t.Fatal("Level", l, "Expected an error on flush")
    92  			}
    93  			err = w.Close()
    94  			if err == nil {
    95  				t.Fatal("Level", l, "Expected an error on close")
    96  			}
    97  
    98  			w.Reset(io.Discard)
    99  			n2, err = w.Write([]byte{1, 2, 3, 4, 5, 6})
   100  			if err != nil {
   101  				t.Fatal("Level", l, "Got unexpected error after reset:", err)
   102  			}
   103  			if n2 == 0 {
   104  				t.Fatal("Level", l, "Got 0 length write, expected > 0")
   105  			}
   106  			if testing.Short() {
   107  				return
   108  			}
   109  		}
   110  	}
   111  }
   112  
   113  // Test if two runs produce identical results
   114  // even when writing different sizes to the Writer.
   115  func TestDeterministic(t *testing.T) {
   116  	t.Parallel()
   117  	for i := 0; i <= 9; i++ {
   118  		t.Run(fmt.Sprint("L", i), func(t *testing.T) { testDeterministic(i, t) })
   119  	}
   120  	t.Run("LM2", func(t *testing.T) { testDeterministic(-2, t) })
   121  }
   122  
   123  func testDeterministic(i int, t *testing.T) {
   124  	t.Parallel()
   125  	// Test so much we cross a good number of block boundaries.
   126  	var length = maxStoreBlockSize*30 + 500
   127  	if testing.Short() {
   128  		length /= 10
   129  	}
   130  
   131  	// Create a random, but compressible stream.
   132  	rng := rand.New(rand.NewSource(1))
   133  	t1 := make([]byte, length)
   134  	for i := range t1 {
   135  		t1[i] = byte(rng.Int63() & 7)
   136  	}
   137  
   138  	// Do our first encode.
   139  	var b1 bytes.Buffer
   140  	br := bytes.NewBuffer(t1)
   141  	w, err := NewWriter(&b1, i)
   142  	if err != nil {
   143  		t.Fatal(err)
   144  	}
   145  	// Use a very small prime sized buffer.
   146  	cbuf := make([]byte, 787)
   147  	_, err = io.CopyBuffer(w, struct{ io.Reader }{br}, cbuf)
   148  	if err != nil {
   149  		t.Fatal(err)
   150  	}
   151  	w.Close()
   152  
   153  	// We choose a different buffer size,
   154  	// bigger than a maximum block, and also a prime.
   155  	var b2 bytes.Buffer
   156  	cbuf = make([]byte, 81761)
   157  	br2 := bytes.NewBuffer(t1)
   158  	w2, err := NewWriter(&b2, i)
   159  	if err != nil {
   160  		t.Fatal(err)
   161  	}
   162  	_, err = io.CopyBuffer(w2, struct{ io.Reader }{br2}, cbuf)
   163  	if err != nil {
   164  		t.Fatal(err)
   165  	}
   166  	w2.Close()
   167  
   168  	b1b := b1.Bytes()
   169  	b2b := b2.Bytes()
   170  
   171  	if !bytes.Equal(b1b, b2b) {
   172  		t.Errorf("level %d did not produce deterministic result, result mismatch, len(a) = %d, len(b) = %d", i, len(b1b), len(b2b))
   173  	}
   174  }
   175  
   176  // TestDeflateFast_Reset will test that encoding is consistent
   177  // across a warparound of the table offset.
   178  // See https://github.com/golang/go/issues/34121
   179  func TestDeflateFast_Reset(t *testing.T) {
   180  	buf := new(bytes.Buffer)
   181  	n := 65536
   182  
   183  	for i := 0; i < n; i++ {
   184  		fmt.Fprintf(buf, "asdfasdfasdfasdf%d%dfghfgujyut%dyutyu\n", i, i, i)
   185  	}
   186  	// This is specific to level 1.
   187  	const level = 1
   188  	in := buf.Bytes()
   189  	offset := 1
   190  	if testing.Short() {
   191  		offset = 256
   192  	}
   193  
   194  	// We do an encode with a clean buffer to compare.
   195  	var want bytes.Buffer
   196  	w, err := NewWriter(&want, level)
   197  	if err != nil {
   198  		t.Fatalf("NewWriter: level %d: %v", level, err)
   199  	}
   200  
   201  	// Output written 3 times.
   202  	w.Write(in)
   203  	w.Write(in)
   204  	w.Write(in)
   205  	w.Close()
   206  
   207  	for ; offset <= 256; offset *= 2 {
   208  		w, err := NewWriter(io.Discard, level)
   209  		if err != nil {
   210  			t.Fatalf("NewWriter: level %d: %v", level, err)
   211  		}
   212  
   213  		// Reset until we are right before the wraparound.
   214  		// Each reset adds maxMatchOffset to the offset.
   215  		for i := 0; i < (bufferReset-len(in)-offset-maxMatchOffset)/maxMatchOffset; i++ {
   216  			// skip ahead to where we are close to wrap around...
   217  			w.d.reset(nil)
   218  		}
   219  		var got bytes.Buffer
   220  		w.Reset(&got)
   221  
   222  		// Write 3 times, close.
   223  		for i := 0; i < 3; i++ {
   224  			_, err = w.Write(in)
   225  			if err != nil {
   226  				t.Fatal(err)
   227  			}
   228  		}
   229  		err = w.Close()
   230  		if err != nil {
   231  			t.Fatal(err)
   232  		}
   233  		if !bytes.Equal(got.Bytes(), want.Bytes()) {
   234  			t.Fatalf("output did not match at wraparound, len(want)  = %d, len(got) = %d", want.Len(), got.Len())
   235  		}
   236  	}
   237  }
   238
View as plain text