target/mips: Simplify decode_opc_mxu() ifdef'ry
[qemu/ar7.git] / tests / test-xbzrle.c
blob795d6f1cbabb0761206aa812f9319155481e2e09
1 /*
2  * Xor Based Zero Run Length Encoding unit tests.
3  *
4  * Copyright 2013 Red Hat, Inc. and/or its affiliates
5  *
6  * Authors:
7  *  Orit Wasserman  <owasserm@redhat.com>
8  *
9  * This work is licensed under the terms of the GNU GPL, version 2 or later.
10  * See the COPYING file in the top-level directory.
11  *
12  */
13 #include "qemu/osdep.h"
14 #include "qemu-common.h"
15 #include "qemu/cutils.h"
16 #include "../migration/xbzrle.h"
18 #define XBZRLE_PAGE_SIZE 4096
20 static void test_uleb(void)
22     uint32_t i, val;
23     uint8_t buf[2];
24     int encode_ret, decode_ret;
26     for (i = 0; i <= 0x3fff; i++) {
27         encode_ret = uleb128_encode_small(&buf[0], i);
28         decode_ret = uleb128_decode_small(&buf[0], &val);
29         g_assert(encode_ret == decode_ret);
30         g_assert(i == val);
31     }
33     /* decode invalid value */
34     buf[0] = 0x80;
35     buf[1] = 0x80;
37     decode_ret = uleb128_decode_small(&buf[0], &val);
38     g_assert(decode_ret == -1);
39     g_assert(val == 0);
42 static void test_encode_decode_zero(void)
44     uint8_t *buffer = g_malloc0(XBZRLE_PAGE_SIZE);
45     uint8_t *compressed = g_malloc0(XBZRLE_PAGE_SIZE);
46     int i = 0;
47     int dlen = 0;
48     int diff_len = g_test_rand_int_range(0, XBZRLE_PAGE_SIZE - 1006);
50     for (i = diff_len; i > 0; i--) {
51         buffer[1000 + i] = i;
52     }
54     buffer[1000 + diff_len + 3] = 103;
55     buffer[1000 + diff_len + 5] = 105;
57     /* encode zero page */
58     dlen = xbzrle_encode_buffer(buffer, buffer, XBZRLE_PAGE_SIZE, compressed,
59                        XBZRLE_PAGE_SIZE);
60     g_assert(dlen == 0);
62     g_free(buffer);
63     g_free(compressed);
66 static void test_encode_decode_unchanged(void)
68     uint8_t *compressed = g_malloc0(XBZRLE_PAGE_SIZE);
69     uint8_t *test = g_malloc0(XBZRLE_PAGE_SIZE);
70     int i = 0;
71     int dlen = 0;
72     int diff_len = g_test_rand_int_range(0, XBZRLE_PAGE_SIZE - 1006);
74     for (i = diff_len; i > 0; i--) {
75         test[1000 + i] = i + 4;
76     }
78     test[1000 + diff_len + 3] = 107;
79     test[1000 + diff_len + 5] = 109;
81     /* test unchanged buffer */
82     dlen = xbzrle_encode_buffer(test, test, XBZRLE_PAGE_SIZE, compressed,
83                                 XBZRLE_PAGE_SIZE);
84     g_assert(dlen == 0);
86     g_free(test);
87     g_free(compressed);
90 static void test_encode_decode_1_byte(void)
92     uint8_t *buffer = g_malloc0(XBZRLE_PAGE_SIZE);
93     uint8_t *test = g_malloc0(XBZRLE_PAGE_SIZE);
94     uint8_t *compressed = g_malloc(XBZRLE_PAGE_SIZE);
95     int dlen = 0, rc = 0;
96     uint8_t buf[2];
98     test[XBZRLE_PAGE_SIZE - 1] = 1;
100     dlen = xbzrle_encode_buffer(buffer, test, XBZRLE_PAGE_SIZE, compressed,
101                        XBZRLE_PAGE_SIZE);
102     g_assert(dlen == (uleb128_encode_small(&buf[0], 4095) + 2));
104     rc = xbzrle_decode_buffer(compressed, dlen, buffer, XBZRLE_PAGE_SIZE);
105     g_assert(rc == XBZRLE_PAGE_SIZE);
106     g_assert(memcmp(test, buffer, XBZRLE_PAGE_SIZE) == 0);
108     g_free(buffer);
109     g_free(compressed);
110     g_free(test);
113 static void test_encode_decode_overflow(void)
115     uint8_t *compressed = g_malloc0(XBZRLE_PAGE_SIZE);
116     uint8_t *test = g_malloc0(XBZRLE_PAGE_SIZE);
117     uint8_t *buffer = g_malloc0(XBZRLE_PAGE_SIZE);
118     int i = 0, rc = 0;
120     for (i = 0; i < XBZRLE_PAGE_SIZE / 2 - 1; i++) {
121         test[i * 2] = 1;
122     }
124     /* encode overflow */
125     rc = xbzrle_encode_buffer(buffer, test, XBZRLE_PAGE_SIZE, compressed,
126                               XBZRLE_PAGE_SIZE);
127     g_assert(rc == -1);
129     g_free(buffer);
130     g_free(compressed);
131     g_free(test);
134 static void encode_decode_range(void)
136     uint8_t *buffer = g_malloc0(XBZRLE_PAGE_SIZE);
137     uint8_t *compressed = g_malloc(XBZRLE_PAGE_SIZE);
138     uint8_t *test = g_malloc0(XBZRLE_PAGE_SIZE);
139     int i = 0, rc = 0;
140     int dlen = 0;
142     int diff_len = g_test_rand_int_range(0, XBZRLE_PAGE_SIZE - 1006);
144     for (i = diff_len; i > 0; i--) {
145         buffer[1000 + i] = i;
146         test[1000 + i] = i + 4;
147     }
149     buffer[1000 + diff_len + 3] = 103;
150     test[1000 + diff_len + 3] = 107;
152     buffer[1000 + diff_len + 5] = 105;
153     test[1000 + diff_len + 5] = 109;
155     /* test encode/decode */
156     dlen = xbzrle_encode_buffer(test, buffer, XBZRLE_PAGE_SIZE, compressed,
157                                 XBZRLE_PAGE_SIZE);
159     rc = xbzrle_decode_buffer(compressed, dlen, test, XBZRLE_PAGE_SIZE);
160     g_assert(rc < XBZRLE_PAGE_SIZE);
161     g_assert(memcmp(test, buffer, XBZRLE_PAGE_SIZE) == 0);
163     g_free(buffer);
164     g_free(compressed);
165     g_free(test);
168 static void test_encode_decode(void)
170     int i;
172     for (i = 0; i < 10000; i++) {
173         encode_decode_range();
174     }
177 int main(int argc, char **argv)
179     g_test_init(&argc, &argv, NULL);
180     g_test_rand_int();
181     g_test_add_func("/xbzrle/uleb", test_uleb);
182     g_test_add_func("/xbzrle/encode_decode_zero", test_encode_decode_zero);
183     g_test_add_func("/xbzrle/encode_decode_unchanged",
184                     test_encode_decode_unchanged);
185     g_test_add_func("/xbzrle/encode_decode_1_byte", test_encode_decode_1_byte);
186     g_test_add_func("/xbzrle/encode_decode_overflow",
187                     test_encode_decode_overflow);
188     g_test_add_func("/xbzrle/encode_decode", test_encode_decode);
190     return g_test_run();