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