mirror of
https://github.com/qemu/qemu.git
synced 2024-12-11 12:43:55 +08:00
21e3cd295b
Signed-off-by: Orit Wasserman <owasserm@redhat.com> Reviewed-by: Paolo Bonzini <pbonzini@redhat.com> Signed-off-by: Juan Quintela <quintela@redhat.com> Reviewed-by: Eric Blake <eblake@redhat.com>
197 lines
4.9 KiB
C
197 lines
4.9 KiB
C
/*
|
|
* Xor Based Zero Run Length Encoding unit tests.
|
|
*
|
|
* Copyright 2013 Red Hat, Inc. and/or its affiliates
|
|
*
|
|
* Authors:
|
|
* Orit Wasserman <owasserm@redhat.com>
|
|
*
|
|
* This work is licensed under the terms of the GNU GPL, version 2 or later.
|
|
* See the COPYING file in the top-level directory.
|
|
*
|
|
*/
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <strings.h>
|
|
#include <string.h>
|
|
#include <sys/time.h>
|
|
#include <assert.h>
|
|
#include "qemu-common.h"
|
|
#include "include/migration/migration.h"
|
|
|
|
#define PAGE_SIZE 4096
|
|
|
|
static void test_uleb(void)
|
|
{
|
|
uint32_t i, val;
|
|
uint8_t buf[2];
|
|
int encode_ret, decode_ret;
|
|
|
|
for (i = 0; i <= 0x3fff; i++) {
|
|
encode_ret = uleb128_encode_small(&buf[0], i);
|
|
decode_ret = uleb128_decode_small(&buf[0], &val);
|
|
g_assert(encode_ret == decode_ret);
|
|
g_assert(i == val);
|
|
}
|
|
|
|
/* decode invalid value */
|
|
buf[0] = 0x80;
|
|
buf[1] = 0x80;
|
|
|
|
decode_ret = uleb128_decode_small(&buf[0], &val);
|
|
g_assert(decode_ret == -1);
|
|
g_assert(val == 0);
|
|
}
|
|
|
|
static void test_encode_decode_zero(void)
|
|
{
|
|
uint8_t *buffer = g_malloc0(PAGE_SIZE);
|
|
uint8_t *compressed = g_malloc0(PAGE_SIZE);
|
|
int i = 0;
|
|
int dlen = 0;
|
|
int diff_len = g_test_rand_int_range(0, PAGE_SIZE - 1006);
|
|
|
|
for (i = diff_len; i > 0; i--) {
|
|
buffer[1000 + i] = i;
|
|
}
|
|
|
|
buffer[1000 + diff_len + 3] = 103;
|
|
buffer[1000 + diff_len + 5] = 105;
|
|
|
|
/* encode zero page */
|
|
dlen = xbzrle_encode_buffer(buffer, buffer, PAGE_SIZE, compressed,
|
|
PAGE_SIZE);
|
|
g_assert(dlen == 0);
|
|
|
|
g_free(buffer);
|
|
g_free(compressed);
|
|
}
|
|
|
|
static void test_encode_decode_unchanged(void)
|
|
{
|
|
uint8_t *compressed = g_malloc0(PAGE_SIZE);
|
|
uint8_t *test = g_malloc0(PAGE_SIZE);
|
|
int i = 0;
|
|
int dlen = 0;
|
|
int diff_len = g_test_rand_int_range(0, PAGE_SIZE - 1006);
|
|
|
|
for (i = diff_len; i > 0; i--) {
|
|
test[1000 + i] = i + 4;
|
|
}
|
|
|
|
test[1000 + diff_len + 3] = 107;
|
|
test[1000 + diff_len + 5] = 109;
|
|
|
|
/* test unchanged buffer */
|
|
dlen = xbzrle_encode_buffer(test, test, PAGE_SIZE, compressed,
|
|
PAGE_SIZE);
|
|
g_assert(dlen == 0);
|
|
|
|
g_free(test);
|
|
g_free(compressed);
|
|
}
|
|
|
|
static void test_encode_decode_1_byte(void)
|
|
{
|
|
uint8_t *buffer = g_malloc0(PAGE_SIZE);
|
|
uint8_t *test = g_malloc0(PAGE_SIZE);
|
|
uint8_t *compressed = g_malloc(PAGE_SIZE);
|
|
int dlen = 0, rc = 0;
|
|
uint8_t buf[2];
|
|
|
|
test[PAGE_SIZE - 1] = 1;
|
|
|
|
dlen = xbzrle_encode_buffer(buffer, test, PAGE_SIZE, compressed,
|
|
PAGE_SIZE);
|
|
g_assert(dlen == (uleb128_encode_small(&buf[0], 4095) + 2));
|
|
|
|
rc = xbzrle_decode_buffer(compressed, dlen, buffer, PAGE_SIZE);
|
|
g_assert(rc == PAGE_SIZE);
|
|
g_assert(memcmp(test, buffer, PAGE_SIZE) == 0);
|
|
|
|
g_free(buffer);
|
|
g_free(compressed);
|
|
g_free(test);
|
|
}
|
|
|
|
static void test_encode_decode_overflow(void)
|
|
{
|
|
uint8_t *compressed = g_malloc0(PAGE_SIZE);
|
|
uint8_t *test = g_malloc0(PAGE_SIZE);
|
|
uint8_t *buffer = g_malloc0(PAGE_SIZE);
|
|
int i = 0, rc = 0;
|
|
|
|
for (i = 0; i < PAGE_SIZE / 2 - 1; i++) {
|
|
test[i * 2] = 1;
|
|
}
|
|
|
|
/* encode overflow */
|
|
rc = xbzrle_encode_buffer(buffer, test, PAGE_SIZE, compressed,
|
|
PAGE_SIZE);
|
|
g_assert(rc == -1);
|
|
|
|
g_free(buffer);
|
|
g_free(compressed);
|
|
g_free(test);
|
|
}
|
|
|
|
static void encode_decode_range(void)
|
|
{
|
|
uint8_t *buffer = g_malloc0(PAGE_SIZE);
|
|
uint8_t *compressed = g_malloc(PAGE_SIZE);
|
|
uint8_t *test = g_malloc0(PAGE_SIZE);
|
|
int i = 0, rc = 0;
|
|
int dlen = 0;
|
|
|
|
int diff_len = g_test_rand_int_range(0, PAGE_SIZE - 1006);
|
|
|
|
for (i = diff_len; i > 0; i--) {
|
|
buffer[1000 + i] = i;
|
|
test[1000 + i] = i + 4;
|
|
}
|
|
|
|
buffer[1000 + diff_len + 3] = 103;
|
|
test[1000 + diff_len + 3] = 107;
|
|
|
|
buffer[1000 + diff_len + 5] = 105;
|
|
test[1000 + diff_len + 5] = 109;
|
|
|
|
/* test encode/decode */
|
|
dlen = xbzrle_encode_buffer(test, buffer, PAGE_SIZE, compressed,
|
|
PAGE_SIZE);
|
|
|
|
rc = xbzrle_decode_buffer(compressed, dlen, test, PAGE_SIZE);
|
|
g_assert(rc < PAGE_SIZE);
|
|
g_assert(memcmp(test, buffer, PAGE_SIZE) == 0);
|
|
|
|
g_free(buffer);
|
|
g_free(compressed);
|
|
g_free(test);
|
|
}
|
|
|
|
static void test_encode_decode(void)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < 10000; i++) {
|
|
encode_decode_range();
|
|
}
|
|
}
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
g_test_init(&argc, &argv, NULL);
|
|
g_test_rand_int();
|
|
g_test_add_func("/xbzrle/uleb", test_uleb);
|
|
g_test_add_func("/xbzrle/encode_decode_zero", test_encode_decode_zero);
|
|
g_test_add_func("/xbzrle/encode_decode_unchanged",
|
|
test_encode_decode_unchanged);
|
|
g_test_add_func("/xbzrle/encode_decode_1_byte", test_encode_decode_1_byte);
|
|
g_test_add_func("/xbzrle/encode_decode_overflow",
|
|
test_encode_decode_overflow);
|
|
g_test_add_func("/xbzrle/encode_decode", test_encode_decode);
|
|
|
|
return g_test_run();
|
|
}
|