1
2
3
4 package zstd
5
6 import (
7 "bytes"
8 "encoding/csv"
9 "fmt"
10 "io"
11 "os"
12 "reflect"
13 "strconv"
14 "testing"
15
16 "github.com/klauspost/compress/internal/cpuinfo"
17 "github.com/klauspost/compress/zip"
18 )
19
20 func Benchmark_seqdec_decodeNoBMI(b *testing.B) {
21 if !cpuinfo.HasBMI2() {
22 b.Skip("Already tested, platform does not have bmi2")
23 return
24 }
25 defer cpuinfo.DisableBMI2()()
26
27 benchmark_seqdec_decode(b)
28 }
29
30 func Test_sequenceDecs_decodeNoBMI(t *testing.T) {
31 if !cpuinfo.HasBMI2() {
32 t.Skip("Already tested, platform does not have bmi2")
33 return
34 }
35 defer cpuinfo.DisableBMI2()()
36
37 const writeWant = false
38 var buf bytes.Buffer
39 zw := zip.NewWriter(&buf)
40
41 want := map[string][]seqVals{}
42 var wantOffsets = map[string][3]int{}
43 if !writeWant {
44 fn := "testdata/seqs-want.zip"
45 data, err := os.ReadFile(fn)
46 tb := t
47 if err != nil {
48 tb.Fatal(err)
49 }
50 zr, err := zip.NewReader(bytes.NewReader(data), int64(len(data)))
51 if err != nil {
52 tb.Fatal(err)
53 }
54 for _, tt := range zr.File {
55 var ref testSequence
56 if !ref.parse(tt.Name) {
57 tb.Skip("unable to parse:", tt.Name)
58 }
59 o, err := tt.Open()
60 if err != nil {
61 t.Fatal(err)
62 }
63 r := csv.NewReader(o)
64 recs, err := r.ReadAll()
65 if err != nil {
66 t.Fatal(err)
67 }
68 for i, rec := range recs {
69 if i == 0 {
70 var o [3]int
71 o[0], _ = strconv.Atoi(rec[0])
72 o[1], _ = strconv.Atoi(rec[1])
73 o[2], _ = strconv.Atoi(rec[2])
74 wantOffsets[tt.Name] = o
75 continue
76 }
77 s := seqVals{}
78 s.mo, _ = strconv.Atoi(rec[0])
79 s.ml, _ = strconv.Atoi(rec[1])
80 s.ll, _ = strconv.Atoi(rec[2])
81 want[tt.Name] = append(want[tt.Name], s)
82 }
83 o.Close()
84 }
85 }
86 fn := "testdata/seqs.zip"
87 data, err := os.ReadFile(fn)
88 tb := t
89 if err != nil {
90 tb.Fatal(err)
91 }
92 zr, err := zip.NewReader(bytes.NewReader(data), int64(len(data)))
93 if err != nil {
94 tb.Fatal(err)
95 }
96 for _, tt := range zr.File {
97 var ref testSequence
98 if !ref.parse(tt.Name) {
99 tb.Skip("unable to parse:", tt.Name)
100 }
101 r, err := tt.Open()
102 if err != nil {
103 tb.Error(err)
104 return
105 }
106
107 seqData, err := io.ReadAll(r)
108 if err != nil {
109 tb.Error(err)
110 return
111 }
112 var buf = bytes.NewBuffer(seqData)
113 s := readDecoders(tb, buf, ref)
114 seqs := make([]seqVals, ref.n)
115
116 t.Run(tt.Name, func(t *testing.T) {
117 fatalIf := func(err error) {
118 if err != nil {
119 t.Fatal(err)
120 }
121 }
122 fatalIf(s.br.init(buf.Bytes()))
123 fatalIf(s.litLengths.init(s.br))
124 fatalIf(s.offsets.init(s.br))
125 fatalIf(s.matchLengths.init(s.br))
126
127 err := s.decode(seqs)
128 if err != nil {
129 t.Error(err)
130 }
131 if writeWant {
132 w, err := zw.Create(tt.Name)
133 fatalIf(err)
134 c := csv.NewWriter(w)
135 w.Write([]byte(fmt.Sprintf("%d,%d,%d\n", s.prevOffset[0], s.prevOffset[1], s.prevOffset[2])))
136 for _, seq := range seqs {
137 c.Write([]string{strconv.Itoa(seq.mo), strconv.Itoa(seq.ml), strconv.Itoa(seq.ll)})
138 }
139 c.Flush()
140 } else {
141 if s.prevOffset != wantOffsets[tt.Name] {
142 t.Errorf("want offsets %v, got %v", wantOffsets[tt.Name], s.prevOffset)
143 }
144
145 if !reflect.DeepEqual(want[tt.Name], seqs) {
146 t.Errorf("got %v\nwant %v", seqs, want[tt.Name])
147 }
148 }
149 })
150 }
151 if writeWant {
152 zw.Close()
153 os.WriteFile("testdata/seqs-want.zip", buf.Bytes(), os.ModePerm)
154 }
155 }
156
View as plain text