decode_test.go

Documentation: github.com/klauspost/compress/s2

     1  // Copyright (c) 2019 Klaus Post. 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 s2
     6  
     7  import (
     8  	"bytes"
     9  	"fmt"
    10  	"io"
    11  	"os"
    12  	"runtime"
    13  	"strings"
    14  	"testing"
    15  
    16  	"github.com/klauspost/compress/zip"
    17  )
    18  
    19  func TestDecodeRegression(t *testing.T) {
    20  	data, err := os.ReadFile("testdata/dec-block-regressions.zip")
    21  	if err != nil {
    22  		t.Fatal(err)
    23  	}
    24  	zr, err := zip.NewReader(bytes.NewReader(data), int64(len(data)))
    25  	if err != nil {
    26  		t.Fatal(err)
    27  	}
    28  	for _, tt := range zr.File {
    29  		if !strings.HasSuffix(t.Name(), "") {
    30  			continue
    31  		}
    32  		t.Run(tt.Name, func(t *testing.T) {
    33  			r, err := tt.Open()
    34  			if err != nil {
    35  				t.Error(err)
    36  				return
    37  			}
    38  			in, err := io.ReadAll(r)
    39  			if err != nil {
    40  				t.Error(err)
    41  			}
    42  			got, err := Decode(nil, in)
    43  			t.Log("Received:", len(got), err)
    44  		})
    45  	}
    46  }
    47  
    48  func TestDecoderMaxBlockSize(t *testing.T) {
    49  	data, err := os.ReadFile("testdata/enc_regressions.zip")
    50  	if err != nil {
    51  		t.Fatal(err)
    52  	}
    53  	zr, err := zip.NewReader(bytes.NewReader(data), int64(len(data)))
    54  	if err != nil {
    55  		t.Fatal(err)
    56  	}
    57  	sizes := []int{4 << 10, 10 << 10, 1 << 20, 4 << 20}
    58  	test := func(t *testing.T, data []byte) {
    59  		for _, size := range sizes {
    60  			t.Run(fmt.Sprintf("%d", size), func(t *testing.T) {
    61  				var buf bytes.Buffer
    62  				dec := NewReader(nil, ReaderMaxBlockSize(size), ReaderAllocBlock(size/2))
    63  				enc := NewWriter(&buf, WriterBlockSize(size), WriterPadding(16<<10), WriterPaddingSrc(zeroReader{}))
    64  
    65  				// Test writer.
    66  				n, err := enc.Write(data)
    67  				if err != nil {
    68  					t.Error(err)
    69  					return
    70  				}
    71  				if n != len(data) {
    72  					t.Error(fmt.Errorf("Write: Short write, want %d, got %d", len(data), n))
    73  					return
    74  				}
    75  				err = enc.Close()
    76  				if err != nil {
    77  					t.Error(err)
    78  					return
    79  				}
    80  				// Calling close twice should not affect anything.
    81  				err = enc.Close()
    82  				if err != nil {
    83  					t.Error(err)
    84  					return
    85  				}
    86  
    87  				dec.Reset(&buf)
    88  				got, err := io.ReadAll(dec)
    89  				if err != nil {
    90  					t.Error(err)
    91  					return
    92  				}
    93  				if !bytes.Equal(data, got) {
    94  					t.Error("block (reset) decoder mismatch")
    95  					return
    96  				}
    97  
    98  				// Test Reset on both and use ReadFrom instead.
    99  				buf.Reset()
   100  				enc.Reset(&buf)
   101  				n2, err := enc.ReadFrom(bytes.NewBuffer(data))
   102  				if err != nil {
   103  					t.Error(err)
   104  					return
   105  				}
   106  				if n2 != int64(len(data)) {
   107  					t.Error(fmt.Errorf("ReadFrom: Short read, want %d, got %d", len(data), n2))
   108  					return
   109  				}
   110  				// Encode twice...
   111  				n2, err = enc.ReadFrom(bytes.NewBuffer(data))
   112  				if err != nil {
   113  					t.Error(err)
   114  					return
   115  				}
   116  				if n2 != int64(len(data)) {
   117  					t.Error(fmt.Errorf("ReadFrom: Short read, want %d, got %d", len(data), n2))
   118  					return
   119  				}
   120  
   121  				err = enc.Close()
   122  				if err != nil {
   123  					t.Error(err)
   124  					return
   125  				}
   126  				if enc.pad > 0 && buf.Len()%enc.pad != 0 {
   127  					t.Error(fmt.Errorf("wanted size to be mutiple of %d, got size %d with remainder %d", enc.pad, buf.Len(), buf.Len()%enc.pad))
   128  					return
   129  				}
   130  				encoded := buf.Bytes()
   131  				dec.Reset(&buf)
   132  				// Skip first...
   133  				dec.Skip(int64(len(data)))
   134  				got, err = io.ReadAll(dec)
   135  				if err != nil {
   136  					t.Error(err)
   137  					return
   138  				}
   139  				if !bytes.Equal(data, got) {
   140  					t.Error("frame (reset) decoder mismatch")
   141  					return
   142  				}
   143  				// Re-add data, Read concurrent.
   144  				buf.Write(encoded)
   145  				dec.Reset(&buf)
   146  				var doubleB bytes.Buffer
   147  				nb, err := dec.DecodeConcurrent(&doubleB, runtime.GOMAXPROCS(0))
   148  				if err != nil {
   149  					t.Error(err)
   150  					return
   151  				}
   152  				if nb != int64(len(data)*2) {
   153  					t.Errorf("want %d, got %d, err: %v", len(data)*2, nb, err)
   154  					return
   155  				}
   156  				got = doubleB.Bytes()[:len(data)]
   157  				if !bytes.Equal(data, got) {
   158  					t.Error("frame (DecodeConcurrent) decoder mismatch")
   159  					return
   160  				}
   161  				got = doubleB.Bytes()[len(data):]
   162  				if !bytes.Equal(data, got) {
   163  					t.Error("frame (DecodeConcurrent) decoder mismatch")
   164  					return
   165  				}
   166  			})
   167  		}
   168  	}
   169  	for _, tt := range zr.File {
   170  		if !strings.HasSuffix(t.Name(), "") {
   171  			continue
   172  		}
   173  		t.Run(tt.Name, func(t *testing.T) {
   174  			r, err := tt.Open()
   175  			if err != nil {
   176  				t.Error(err)
   177  				return
   178  			}
   179  			b, err := io.ReadAll(r)
   180  			if err != nil {
   181  				t.Error(err)
   182  				return
   183  			}
   184  			test(t, b[:len(b):len(b)])
   185  		})
   186  	}
   187  }
   188
View as plain text