kenmirrors
/
freeswitch
mirror of https://github.com/signalwire/freeswitch.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
freeswitch/libs/sofia-sip/libsofia-sip-ua/su/torture_heap.c

544 lines
11 KiB
C
Raw Blame History

/*
* This file is part of the Sofia-SIP package
*
* Copyright (C) 2007 Nokia Corporation.
*
* Contact: Pekka Pessi <pekka.pessi@nokia.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA
*
*/
/**@internal
* @file torture_heap.c
* @brief Test heap
*
* @author Pekka Pessi <Pekka.Pessi@nokia.com>
*/
#include "config.h"
#include <sofia-sip/heap.h>
#include <unistd.h>
#include <stddef.h>
#include <string.h>
#include <assert.h>
#include <errno.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
typedef struct {
unsigned key, value;
size_t index;
} type1, *type2;
static type1 const null = { 0, 0, 0 };
static inline
int less1(type1 a, type1 b)
{
return a.key < b.key;
}
static inline
void set1(type1 *heap, size_t index, type1 e)
{
e.index = index;
heap[index] = e;
}
#define alloc(a, o, size) realloc((o), (size))
static inline
int less2(type2 a, type2 b)
{
return a->key < b->key;
}
static inline
void set2(type2 *heap, size_t index, type2 e)
{
e->index = index;
heap[index] = e;
}
#define scope static
/* Define heap having structs as its elements */
typedef HEAP_TYPE Heap1;
HEAP_DECLARE(static, Heap1, heap1_, type1);
HEAP_BODIES(static, Heap1, heap1_, type1, less1, set1, alloc, null);
/* Define heap having pointers as its elements */
typedef HEAP_TYPE Heap2;
HEAP_DECLARE(static, Heap2, heap2_, type1 *);
HEAP_BODIES(static, Heap2, heap2_, type1 *, less2, set2, alloc, NULL);
/* ====================================================================== */
int tstflags;
#define TSTFLAGS tstflags
#include <sofia-sip/tstdef.h>
char name[] = "torture_heap";
size_t _set, _cmp;
static int int_less(void *_array, size_t a, size_t b)
{
int *array = _array;
_cmp++;
return array[a] < array[b];
}
static void int_swap(void *_array, size_t a, size_t b)
{
int *array = _array;
int swap = array[a];
array[a] = array[b];
array[b] = swap;
_set++;
}
void test_sort(int *array, size_t r, size_t N)
{
su_smoothsort(array, r, N, int_less, int_swap);
}
int test_smooth_sort()
{
BEGIN();
size_t i, n, N = 300000;
int array[N];
size_t v1 = 3, v2 = 1;
for (n = v1; n <= N; n = v1 + v2 + 1, v2 = v1, v1 = n) {
for (i = 0; i < n; i++) {
array[i] = (int)(n - i - 1);
}
_set = 0;
/* write(1, ".", 1); */
test_sort(array, 0, n);
TEST_1(_set > 0); _set = 0;
test_sort(array, 0, n);
TEST(_set, 0);
for (i = 0; i < n; i++) {
TEST(array[i], i);
}
}
for (n = 4; n <= N; n *= 2) {
for (i = 0; i < n; i++) {
array[i] = (int)(n - i - 1);
}
/* write(1, "/", 1); */
test_sort(array, 0, n / 2);
test_sort(array, n / 2, n / 2);
for (i = 0; i < n / 2; i++) {
TEST(array[i], i + n / 2);
}
for (; i < n; i++) {
TEST(array[i], i - n / 2);
}
}
END();
}
int test_value()
{
BEGIN();
Heap1 heap = { NULL };
unsigned i, previous, n, N;
unsigned char *tests;
N = 3000;
TEST_1(tests = calloc(sizeof (unsigned char), N + 1));
TEST(heap1_resize(NULL, &heap, 0), 0);
/* Add N entries in reverse order */
for (i = N; i > 0; i--) {
type1 e = { i / 10, i, 0 };
if (heap1_is_full(heap))
TEST(heap1_resize(NULL, &heap, 0), 0);
TEST(heap1_is_full(heap), 0);
TEST(heap1_add(heap, e), 0);
tests[i] |= 1;
}
TEST(heap1_used(heap), N);
for (i = 1; i <= N; i++) {
type1 const e = heap1_get(heap, i);
TEST(e.index, i);
TEST(tests[e.value] & 2, 0);
tests[e.value] |= 2;
if (2 * i <= N) {
type1 const left = heap1_get(heap, 2 * i);
TEST_1(e.key <= left.key);
}
if (2 * i + 1 <= N) {
type1 const right = heap1_get(heap, 2 * i + 1);
TEST_1(e.key <= right.key);
}
}
/* Remove N entries */
previous = 0;
for (n = 0; heap1_used(heap) > 0; n++) {
type1 const e = heap1_get(heap, 1);
TEST_1(previous <= e.key);
TEST(tests[e.value] & 4, 0);
tests[e.value] |= 4;
previous = e.key;
TEST(heap1_get(heap, 1).index, 1);
TEST(heap1_remove(heap, 1).index, 0);
}
TEST(n, N);
/* Add N entries in reverse order */
for (i = N; i > 0; i--) {
type1 e = { i / 10, i, 0 };
if (heap1_is_full(heap))
TEST(heap1_resize(NULL, &heap, 0), 0);
TEST(heap1_is_full(heap), 0);
TEST(heap1_add(heap, e), 0);
}
TEST(heap1_used(heap), N);
heap1_sort(heap);
for (i = 1; i <= N; i++) {
type1 e = heap1_get(heap, i);
TEST(e.index, i);
}
/* Remove 1000 entries from random places */
previous = 0;
for (i = 0; i < 1000 && heap1_used(heap) > 0; i++) {
type1 e;
n = i * 397651 % heap1_used(heap) + 1;
e = heap1_get(heap, n);
TEST(e.index, n);
TEST(tests[e.value] & 8, 0); tests[e.value] |= 8;
TEST(heap1_get(heap, n).index, n);
TEST(heap1_remove(heap, n).index, 0);
}
for (i = 1; i <= heap1_used(heap); i++) {
type1 e = heap1_get(heap, i);
type1 left = heap1_get(heap, 2 * i);
type1 right = heap1_get(heap, 2 * i + 1);
TEST_1(left.index == 0 || e.key <= left.key);
TEST_1(right.index == 0 || e.key <= right.key);
}
/* Remove rest */
for (n = 0, previous = 0; heap1_used(heap) > 0; n++) {
type1 e = heap1_get(heap, 1);
TEST(e.index, 1);
TEST(tests[e.value] & 8, 0);
tests[e.value] |= 8;
TEST_1(previous <= e.key);
previous = e.key;
TEST(heap1_get(heap, 1).index, 1);
TEST(heap1_remove(heap, 1).index, 0);
}
for (i = 1; i <= N; i++) {
TEST(tests[i], 8 | 4 | 2 | 1);
}
TEST(heap1_resize(NULL, &heap, 63), 0);
TEST(heap1_size(heap), 63);
TEST(heap1_free(NULL, &heap), 0);
free(tests);
END();
}
int test_ref()
{
BEGIN();
Heap2 heap = { NULL };
unsigned i, previous, n, N;
unsigned char *tests;
type1 *items;
N = 300000;
TEST_1(tests = calloc(sizeof (unsigned char), N + 1));
TEST_1(items = calloc((sizeof *items), N + 1));
TEST(heap2_resize(NULL, &heap, 0), 0);
/* Add N entries in reverse order */
for (i = N; i > 0; i--) {
type2 e = items + i;
e->key = i / 10, e->value = i;
if (heap2_is_full(heap))
TEST(heap2_resize(NULL, &heap, 0), 0);
TEST(heap2_is_full(heap), 0);
TEST(heap2_add(heap, e), 0);
tests[i] |= 1;
}
TEST(heap2_used(heap), N);
for (i = 1; i <= N; i++) {
type2 const e = heap2_get(heap, i);
TEST_1(e);
TEST(e->index, i);
TEST(tests[e->value] & 2, 0);
tests[e->value] |= 2;
if (2 * i <= N) {
type2 const left = heap2_get(heap, 2 * i);
TEST_1(e->key <= left->key);
}
if (2 * i + 1 <= N) {
type2 const right = heap2_get(heap, 2 * i + 1);
TEST_1(e->key <= right->key);
}
}
/* Remove N entries */
previous = 0;
for (n = 0; heap2_used(heap) > 0; n++) {
type2 const e = heap2_get(heap, 1);
TEST_1(e);
TEST_1(previous <= e->key);
TEST(tests[e->value] & 4, 0);
tests[e->value] |= 4;
previous = e->key;
TEST(heap2_remove(heap, 1), e);
}
TEST(n, N);
/* Add N entries in reverse order */
for (i = N; i > 0; i--) {
type2 e = items + i;
if (heap2_is_full(heap))
TEST(heap2_resize(NULL, &heap, 0), 0);
TEST(heap2_is_full(heap), 0);
TEST(heap2_add(heap, e), 0);
}
TEST(heap2_used(heap), N);
heap2_sort(heap);
for (i = 1; i <= N; i++) {
type2 const e = heap2_get(heap, i);
TEST_1(e); TEST(e->index, i);
}
heap2_sort(heap);
for (i = 1; i <= N; i++) {
type2 const e = heap2_get(heap, i);
TEST_1(e); TEST(e->index, i);
}
/* Remove all odd entries */
for (i = heap2_used(heap), n = 0; i > 0; i--) {
type2 e = heap2_get(heap, i);
TEST_1(e); TEST(e->index, i);
n++;
tests[e->value] |= 16;
if (e->value & 1) {
TEST(tests[e->value] & 8, 0); tests[e->value] |= 8;
heap2_remove(heap, i);
}
}
for (i = 1; i <= N; i++) {
if (i & 1)
TEST(tests[i] & 8, 8);
else
TEST(tests[i] & 8, 0);
}
/* Remove 1000 entries from random places */
for (i = 0; i < 1000 && heap2_used(heap) > 0; i++) {
type2 e;
n = i * 397651 % heap2_used(heap) + 1;
e = heap2_get(heap, n);
TEST_1(e); TEST(e->index, n);
TEST(tests[e->value] & 8, 0); tests[e->value] |= 8;
TEST(heap2_remove(heap, n), e);
}
for (i = 1; i <= heap2_used(heap); i++) {
type2 e = heap2_get(heap, i);
TEST_1(e); TEST(e->index, i);
if (2 * i <= heap2_used(heap)) {
type2 const left = heap2_get(heap, 2 * i);
TEST_1(left);
TEST_1(e->key <= left->key);
}
if (2 * i + 1 <= heap2_used(heap)) {
type2 const right = heap2_get(heap, 2 * i + 1);
TEST_1(right);
TEST_1(e->key <= right->key);
}
}
/* Remove rest */
for (n = 0, previous = 0; heap2_used(heap) > 0; n++) {
type2 e = heap2_remove(heap, 1);
TEST_1(e); TEST(e->index, 0);
TEST(tests[e->value] & 8, 0);
tests[e->value] |= 8;
TEST_1(previous <= e->key);
previous = e->key;
}
for (i = 1; i <= N; i++) {
TEST(tests[i], 16 | 8 | 4 | 2 | 1);
}
TEST(heap2_resize(NULL, &heap, 63), 0);
TEST(heap2_size(heap), 63);
TEST(heap2_free(NULL, &heap), 0);
free(tests);
free(items);
END();
}
int test_triplet()
{
BEGIN();
Heap2 heap = { NULL };
unsigned i, N;
type1 *items;
N = 3;
TEST_1(items = calloc((sizeof *items), N + 1));
TEST(heap2_resize(NULL, &heap, 0), 0);
for (i = 1; i <= N; i++) {
type2 e = items + i;
e->key = i, e->value = i;
if (heap2_is_full(heap))
TEST(heap2_resize(NULL, &heap, 0), 0);
TEST(heap2_is_full(heap), 0);
TEST(heap2_add(heap, e), 0);
}
for (i = 1; i <= N; i++) {
type2 e = heap2_get(heap, i);
TEST(e->key, i);
TEST(e->value, i);
}
for (i = 1; i <= N; i++) {
type2 e = heap2_remove(heap, 1);
TEST(e->key, i);
TEST(e->value, i);
}
TEST(heap2_free(NULL, &heap), 0);
free(items);
END();
}
void usage(int exitcode)
{
fprintf(stderr,
"usage: %s [-v] [-a]\n",
name);
exit(exitcode);
}
int main(int argc, char *argv[])
{
int retval = 0;
int i;
for (i = 1; argv[i]; i++) {
if (strcmp(argv[i], "-v") == 0)
tstflags |= tst_verbatim;
else if (strcmp(argv[i], "-a") == 0)
tstflags |= tst_abort;
else
usage(1);
}
retval |= test_triplet(); fflush(stdout);
retval |= test_smooth_sort(); fflush(stdout);
retval |= test_value(); fflush(stdout);
retval |= test_ref(); fflush(stdout);
return retval;
}
Reference in New Issue View Git Blame Copy Permalink