Merge remote-tracking branch 'remotes/ehabkost/tags/machine-next-pull-request' into...
[qemu.git] / tests / test-xbzrle.c
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"
17
18 #define PAGE_SIZE 4096
19
20 static void test_uleb(void)
21 {
22 uint32_t i, val;
23 uint8_t buf[2];
24 int encode_ret, decode_ret;
25
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 }
32
33 /* decode invalid value */
34 buf[0] = 0x80;
35 buf[1] = 0x80;
36
37 decode_ret = uleb128_decode_small(&buf[0], &val);
38 g_assert(decode_ret == -1);
39 g_assert(val == 0);
40 }
41
42 static void test_encode_decode_zero(void)
43 {
44 uint8_t *buffer = g_malloc0(PAGE_SIZE);
45 uint8_t *compressed = g_malloc0(PAGE_SIZE);
46 int i = 0;
47 int dlen = 0;
48 int diff_len = g_test_rand_int_range(0, PAGE_SIZE - 1006);
49
50 for (i = diff_len; i > 0; i--) {
51 buffer[1000 + i] = i;
52 }
53
54 buffer[1000 + diff_len + 3] = 103;
55 buffer[1000 + diff_len + 5] = 105;
56
57 /* encode zero page */
58 dlen = xbzrle_encode_buffer(buffer, buffer, PAGE_SIZE, compressed,
59 PAGE_SIZE);
60 g_assert(dlen == 0);
61
62 g_free(buffer);
63 g_free(compressed);
64 }
65
66 static void test_encode_decode_unchanged(void)
67 {
68 uint8_t *compressed = g_malloc0(PAGE_SIZE);
69 uint8_t *test = g_malloc0(PAGE_SIZE);
70 int i = 0;
71 int dlen = 0;
72 int diff_len = g_test_rand_int_range(0, PAGE_SIZE - 1006);
73
74 for (i = diff_len; i > 0; i--) {
75 test[1000 + i] = i + 4;
76 }
77
78 test[1000 + diff_len + 3] = 107;
79 test[1000 + diff_len + 5] = 109;
80
81 /* test unchanged buffer */
82 dlen = xbzrle_encode_buffer(test, test, PAGE_SIZE, compressed,
83 PAGE_SIZE);
84 g_assert(dlen == 0);
85
86 g_free(test);
87 g_free(compressed);
88 }
89
90 static void test_encode_decode_1_byte(void)
91 {
92 uint8_t *buffer = g_malloc0(PAGE_SIZE);
93 uint8_t *test = g_malloc0(PAGE_SIZE);
94 uint8_t *compressed = g_malloc(PAGE_SIZE);
95 int dlen = 0, rc = 0;
96 uint8_t buf[2];
97
98 test[PAGE_SIZE - 1] = 1;
99
100 dlen = xbzrle_encode_buffer(buffer, test, PAGE_SIZE, compressed,
101 PAGE_SIZE);
102 g_assert(dlen == (uleb128_encode_small(&buf[0], 4095) + 2));
103
104 rc = xbzrle_decode_buffer(compressed, dlen, buffer, PAGE_SIZE);
105 g_assert(rc == PAGE_SIZE);
106 g_assert(memcmp(test, buffer, PAGE_SIZE) == 0);
107
108 g_free(buffer);
109 g_free(compressed);
110 g_free(test);
111 }
112
113 static void test_encode_decode_overflow(void)
114 {
115 uint8_t *compressed = g_malloc0(PAGE_SIZE);
116 uint8_t *test = g_malloc0(PAGE_SIZE);
117 uint8_t *buffer = g_malloc0(PAGE_SIZE);
118 int i = 0, rc = 0;
119
120 for (i = 0; i < PAGE_SIZE / 2 - 1; i++) {
121 test[i * 2] = 1;
122 }
123
124 /* encode overflow */
125 rc = xbzrle_encode_buffer(buffer, test, PAGE_SIZE, compressed,
126 PAGE_SIZE);
127 g_assert(rc == -1);
128
129 g_free(buffer);
130 g_free(compressed);
131 g_free(test);
132 }
133
134 static void encode_decode_range(void)
135 {
136 uint8_t *buffer = g_malloc0(PAGE_SIZE);
137 uint8_t *compressed = g_malloc(PAGE_SIZE);
138 uint8_t *test = g_malloc0(PAGE_SIZE);
139 int i = 0, rc = 0;
140 int dlen = 0;
141
142 int diff_len = g_test_rand_int_range(0, PAGE_SIZE - 1006);
143
144 for (i = diff_len; i > 0; i--) {
145 buffer[1000 + i] = i;
146 test[1000 + i] = i + 4;
147 }
148
149 buffer[1000 + diff_len + 3] = 103;
150 test[1000 + diff_len + 3] = 107;
151
152 buffer[1000 + diff_len + 5] = 105;
153 test[1000 + diff_len + 5] = 109;
154
155 /* test encode/decode */
156 dlen = xbzrle_encode_buffer(test, buffer, PAGE_SIZE, compressed,
157 PAGE_SIZE);
158
159 rc = xbzrle_decode_buffer(compressed, dlen, test, PAGE_SIZE);
160 g_assert(rc < PAGE_SIZE);
161 g_assert(memcmp(test, buffer, PAGE_SIZE) == 0);
162
163 g_free(buffer);
164 g_free(compressed);
165 g_free(test);
166 }
167
168 static void test_encode_decode(void)
169 {
170 int i;
171
172 for (i = 0; i < 10000; i++) {
173 encode_decode_range();
174 }
175 }
176
177 int main(int argc, char **argv)
178 {
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);
189
190 return g_test_run();
191 }