1 /*
2 * Copyright (c) 2015, Intel Corporation
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are met:
6 *
7 * * Redistributions of source code must retain the above copyright notice,
8 * this list of conditions and the following disclaimer.
9 * * Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 * * Neither the name of Intel Corporation nor the names of its contributors
13 * may be used to endorse or promote products derived from this software
14 * without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
20 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26 * POSSIBILITY OF SUCH DAMAGE.
27 */
28
29 #include "config.h"
30
31 #include "gtest/gtest.h"
32 #include "util/state_compress.h"
33
34 #include <vector>
35 #include <tuple>
36
37 using namespace std;
38
TEST(state_compress,u32)39 TEST(state_compress, u32) {
40 char buf[sizeof(u32)] = { 0 };
41 vector<tuple<u32, u32, int> > tests = {
42 make_tuple(0U, 0x1U, 1),
43 make_tuple(1U, 0x1U, 1),
44 make_tuple(0x80008000, 0x80808080, 1),
45 make_tuple(0x9f008000, 0x80808080, 1),
46 make_tuple(0x9fab8dfe, 0xff0fff71, 3),
47 make_tuple(0x9fab8dfe, 0xffefff71, 4),
48 make_tuple(0xf0f0f0f0, 0x0f0f0f0f, 4),
49 };
50
51 for (const auto &e : tests) {
52 u32 val;
53 u32 mask;
54 int len;
55 tie(val, mask, len) = e;
56
57 storecompressed32(&buf, &val, &mask, len);
58
59 u32 val_out;
60 loadcompressed32(&val_out, &buf, &mask, len);
61
62 EXPECT_EQ(val & mask, val_out);
63 }
64 }
65
TEST(state_compress,u64a)66 TEST(state_compress, u64a) {
67 char buf[sizeof(u64a)] = { 0 };
68 vector<tuple<u64a, u64a, int> > tests = {
69 make_tuple(0ULL, 0x1ULL, 1),
70 make_tuple(1ULL, 0x1ULL, 1),
71 make_tuple(0x80008000ULL, 0x80808080ULL, 1),
72 make_tuple(0x9f008000ULL, 0x80808080ULL, 1),
73 make_tuple(0x9fab8dfeULL, 0xff0fff71ULL, 3),
74 make_tuple(0x9fab8dfeULL, 0xffefff71ULL, 4),
75 make_tuple(0xf0f0f0f0ULL, 0x0f0f0f0fULL, 4),
76 make_tuple(0x0123456789abcdefULL, 0x0123456789abcdefULL, 5),
77 make_tuple(0x0123456789abcdefULL, 0xfedcba9876543210ULL, 6),
78 make_tuple(0x0123456789abcdefULL, 0x0123456789abcdefULL, 7),
79 make_tuple(0x0123456789abcdefULL, 0xffffffffffffffffULL, 8),
80 };
81
82 for (const auto &e : tests) {
83 u64a val;
84 u64a mask;
85 int len;
86 tie(val, mask, len) = e;
87
88 storecompressed64(&buf, &val, &mask, len);
89
90 u64a val_out;
91 loadcompressed64(&val_out, &buf, &mask, len);
92
93 EXPECT_EQ(val & mask, val_out);
94 }
95 }
96
TEST(state_compress,m128_1)97 TEST(state_compress, m128_1) {
98 char buf[sizeof(m128)] = { 0 };
99
100 for (u32 i = 0; i < 16; i++) {
101 char mask_raw[16] = { 0 };
102 char val_raw[16] = { 0 };
103
104 memset(val_raw, (i << 4) + 3, 16);
105
106 mask_raw[i] = 0xff;
107 val_raw[i] = i;
108
109 mask_raw[15 - i] = 0xff;
110 val_raw[15 - i] = i;
111
112 m128 val;
113 m128 mask;
114
115 memcpy(&val, val_raw, sizeof(val));
116 memcpy(&mask, mask_raw, sizeof(mask));
117
118 storecompressed128(&buf, &val, &mask, 0);
119
120 m128 val_out;
121 loadcompressed128(&val_out, &buf, &mask, 0);
122
123 EXPECT_TRUE(!diff128(and128(val, mask), val_out));
124
125 mask_raw[i] = 0x0f;
126 mask_raw[15 - i] = 0x0f;
127 memcpy(&mask, mask_raw, sizeof(mask));
128 val_raw[i] = 9;
129
130 storecompressed128(&buf, &val, &mask, 0);
131 loadcompressed128(&val_out, &buf, &mask, 0);
132
133 EXPECT_TRUE(!diff128(and128(val, mask), val_out));
134 }
135 }
136
TEST(state_compress,m128_2)137 TEST(state_compress, m128_2) {
138 char buf[sizeof(m128)] = { 0 };
139
140 char val_raw[16] = { '0', '1', '2', '3', '4', '5', '6', '7',
141 '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
142 m128 val;
143 memcpy(&val, val_raw, sizeof(val));
144
145 for (u32 i = 0; i < 16; i++) {
146 char mask_raw[16];
147 memset(mask_raw, 0x7f, sizeof(mask_raw));
148 mask_raw[i] = 0;
149
150 m128 mask;
151 memcpy(&mask, mask_raw, sizeof(mask));
152
153 storecompressed128(&buf, &val, &mask, 0);
154
155 m128 val_out;
156 loadcompressed128(&val_out, &buf, &mask, 0);
157
158 EXPECT_TRUE(!diff128(and128(val, mask), val_out));
159
160 for (u32 j = i + 1; j < 16; j++) {
161 mask_raw[j] = 0;
162 memcpy(&mask, mask_raw, sizeof(mask));
163
164 storecompressed128(&buf, &val, &mask, 0);
165 loadcompressed128(&val_out, &buf, &mask, 0);
166 EXPECT_TRUE(!diff128(and128(val, mask), val_out));
167
168 mask_raw[j] = 0x7f;
169 }
170 }
171 }
172
TEST(state_compress,m256_1)173 TEST(state_compress, m256_1) {
174 char buf[sizeof(m256)] = { 0 };
175
176 for (u32 i = 0; i < 32; i++) {
177 char mask_raw[32] = { 0 };
178 char val_raw[32] = { 0 };
179
180 memset(val_raw, (i << 3) + 3, 32);
181
182 mask_raw[i] = 0xff;
183 val_raw[i] = i;
184
185 mask_raw[31 - i] = 0xff;
186 val_raw[31 - i] = i;
187
188 m256 val;
189 m256 mask;
190
191 memcpy(&val, val_raw, sizeof(val));
192 memcpy(&mask, mask_raw, sizeof(mask));
193
194 storecompressed256(&buf, &val, &mask, 0);
195
196 m256 val_out;
197 loadcompressed256(&val_out, &buf, &mask, 0);
198
199 EXPECT_TRUE(!diff256(and256(val, mask), val_out));
200
201 mask_raw[i] = 0x7;
202 mask_raw[31 - i] = 0x1f;
203 memcpy(&mask, mask_raw, sizeof(mask));
204 val_raw[i] = 5;
205
206 storecompressed256(&buf, &val, &mask, 0);
207 loadcompressed256(&val_out, &buf, &mask, 0);
208
209 EXPECT_TRUE(!diff256(and256(val, mask), val_out));
210 }
211 }
212
TEST(state_compress,m256_2)213 TEST(state_compress, m256_2) {
214 char buf[sizeof(m256)] = { 0 };
215
216 char val_raw[32] = { '0', '1', '2', '3', '4', '5', '6', '7',
217 '8', '9', 'a', 'b', 'c', 'd', 'e', 'f',
218 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
219 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P' };
220 m256 val;
221 memcpy(&val, val_raw, sizeof(val));
222
223 for (u32 i = 0; i < 32; i++) {
224 char mask_raw[32];
225 memset(mask_raw, 0x7f, sizeof(mask_raw));
226 mask_raw[i] = 0;
227
228 m256 mask;
229 memcpy(&mask, mask_raw, sizeof(mask));
230
231 storecompressed256(&buf, &val, &mask, 0);
232
233 m256 val_out;
234 loadcompressed256(&val_out, &buf, &mask, 0);
235
236 EXPECT_TRUE(!diff256(and256(val, mask), val_out));
237
238 for (u32 j = i + 1; j < 32; j++) {
239 mask_raw[j] = 0;
240 memcpy(&mask, mask_raw, sizeof(mask));
241
242 storecompressed256(&buf, &val, &mask, 0);
243 loadcompressed256(&val_out, &buf, &mask, 0);
244 EXPECT_TRUE(!diff256(and256(val, mask), val_out));
245
246 mask_raw[j] = 0x7f;
247 }
248 }
249 }
250
TEST(state_compress,m384_1)251 TEST(state_compress, m384_1) {
252 char buf[sizeof(m384)] = { 0 };
253
254 for (u32 i = 0; i < 48; i++) {
255 char mask_raw[48] = { 0 };
256 char val_raw[48] = { 0 };
257
258 memset(val_raw, (i << 2) + 3, 48);
259
260 mask_raw[i] = 0xff;
261 val_raw[i] = i;
262
263 mask_raw[47 - i] = 0xff;
264 val_raw[47 - i] = i;
265
266 m384 val;
267 m384 mask;
268
269 memcpy(&val, val_raw, sizeof(val));
270 memcpy(&mask, mask_raw, sizeof(mask));
271
272 storecompressed384(&buf, &val, &mask, 0);
273
274 m384 val_out;
275 loadcompressed384(&val_out, &buf, &mask, 0);
276
277 EXPECT_TRUE(!diff384(and384(val, mask), val_out));
278
279 mask_raw[i] = 0x3;
280 mask_raw[47 - i] = 0x2f;
281 memcpy(&mask, mask_raw, sizeof(mask));
282 val_raw[i] = 3;
283
284 storecompressed384(&buf, &val, &mask, 0);
285 loadcompressed384(&val_out, &buf, &mask, 0);
286
287 EXPECT_TRUE(!diff384(and384(val, mask), val_out));
288 }
289 }
290
TEST(state_compress,m384_2)291 TEST(state_compress, m384_2) {
292 char buf[sizeof(m384)] = { 0 };
293
294 char val_raw[48] = { '0', '1', '2', '3', '4', '5', '6', '7',
295 '8', '9', 'a', 'b', 'c', 'd', 'e', 'f',
296 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
297 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
298 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
299 'Q', 'R', ' ', '-', ',', '"', ';', ':' };
300 m384 val;
301 memcpy(&val, val_raw, sizeof(val));
302
303 for (u32 i = 0; i < 48; i++) {
304 char mask_raw[48];
305 memset(mask_raw, 0x7f, sizeof(mask_raw));
306 mask_raw[i] = 0;
307
308 m384 mask;
309 memcpy(&mask, mask_raw, sizeof(mask));
310
311 storecompressed384(&buf, &val, &mask, 0);
312
313 m384 val_out;
314 loadcompressed384(&val_out, &buf, &mask, 0);
315
316 EXPECT_TRUE(!diff384(and384(val, mask), val_out));
317
318 for (u32 j = i + 1; j < 48; j++) {
319 mask_raw[j] = 0;
320 memcpy(&mask, mask_raw, sizeof(mask));
321
322 storecompressed384(&buf, &val, &mask, 0);
323 loadcompressed384(&val_out, &buf, &mask, 0);
324 EXPECT_TRUE(!diff384(and384(val, mask), val_out));
325
326 mask_raw[j] = 0x7f;
327 }
328 }
329 }
330
TEST(state_compress,m512_1)331 TEST(state_compress, m512_1) {
332 char buf[sizeof(m512)] = { 0 };
333
334 for (u32 i = 0; i < 64; i++) {
335 char mask_raw[64] = { 0 };
336 char val_raw[64] = { 0 };
337
338 memset(val_raw, (i << 2) + 3, 64);
339
340 mask_raw[i] = 0xff;
341 val_raw[i] = i;
342
343 mask_raw[63 - i] = 0xff;
344 val_raw[63 - i] = i;
345
346 m512 val;
347 m512 mask;
348
349 memcpy(&val, val_raw, sizeof(val));
350 memcpy(&mask, mask_raw, sizeof(mask));
351
352 storecompressed512(&buf, &val, &mask, 0);
353
354 m512 val_out;
355 loadcompressed512(&val_out, &buf, &mask, 0);
356
357 EXPECT_TRUE(!diff512(and512(val, mask), val_out));
358
359 mask_raw[i] = 0x3;
360 mask_raw[63 - i] = 0x2f;
361 memcpy(&mask, mask_raw, sizeof(mask));
362 val_raw[i] = 3;
363
364 storecompressed512(&buf, &val, &mask, 0);
365 loadcompressed512(&val_out, &buf, &mask, 0);
366
367 EXPECT_TRUE(!diff512(and512(val, mask), val_out));
368 }
369 }
370
TEST(state_compress,m512_2)371 TEST(state_compress, m512_2) {
372 char buf[sizeof(m512)] = { 0 };
373
374 char val_raw[64] = { '0', '1', '2', '3', '4', '5', '6', '7',
375 '8', '9', 'a', 'b', 'c', 'd', 'e', 'f',
376 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
377 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
378 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
379 'Q', 'R', ' ', '-', ',', '"', ';', ':',
380 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n' };
381 m512 val;
382 memcpy(&val, val_raw, sizeof(val));
383
384 for (u32 i = 0; i < 64; i++) {
385 char mask_raw[64];
386 memset(mask_raw, 0x7f, sizeof(mask_raw));
387 mask_raw[i] = 0;
388
389 m512 mask;
390 memcpy(&mask, mask_raw, sizeof(mask));
391
392 storecompressed512(&buf, &val, &mask, 0);
393
394 m512 val_out;
395 loadcompressed512(&val_out, &buf, &mask, 0);
396
397 EXPECT_TRUE(!diff512(and512(val, mask), val_out));
398
399 for (u32 j = i + 1; j < 64; j++) {
400 mask_raw[j] = 0;
401 memcpy(&mask, mask_raw, sizeof(mask));
402
403 storecompressed512(&buf, &val, &mask, 0);
404 loadcompressed512(&val_out, &buf, &mask, 0);
405 EXPECT_TRUE(!diff512(and512(val, mask), val_out));
406
407 mask_raw[j] = 0x7f;
408 }
409 }
410 }
411