The C based gRPC (C++, Python, Ruby, Objective-C, PHP, C#) https://grpc.io/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

300 lines
9.0 KiB

/*
*
* Copyright 2015 gRPC authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
#include "src/core/lib/avl/avl.h"
#include <stdio.h>
#include <string.h>
#include <grpc/support/alloc.h>
#include <grpc/support/log.h>
#include "src/core/lib/gpr/useful.h"
#include "test/core/util/test_config.h"
static int* box(int x) {
int* b = static_cast<int*>(gpr_malloc(sizeof(*b)));
*b = x;
return b;
}
static long int_compare(void* int1, void* int2, void* /*unused*/) {
return (*static_cast<int*>(int1)) - (*static_cast<int*>(int2));
}
static void* int_copy(void* p, void* /*unused*/) {
return box(*static_cast<int*>(p));
}
static void destroy(void* p, void* /*unused*/) { gpr_free(p); }
static const grpc_avl_vtable int_int_vtable = {destroy, int_copy, int_compare,
destroy, int_copy};
static void check_get(grpc_avl avl, int key, int value) {
int* k = box(key);
GPR_ASSERT(*(int*)grpc_avl_get(avl, k, nullptr) == value);
gpr_free(k);
}
static void check_negget(grpc_avl avl, int key) {
int* k = box(key);
GPR_ASSERT(grpc_avl_get(avl, k, nullptr) == nullptr);
gpr_free(k);
}
static grpc_avl remove_int(grpc_avl avl, int key) {
int* k = box(key);
avl = grpc_avl_remove(avl, k, nullptr);
gpr_free(k);
return avl;
}
static void test_get(void) {
grpc_avl avl;
gpr_log(GPR_DEBUG, "test_get");
avl = grpc_avl_create(&int_int_vtable);
avl = grpc_avl_add(avl, box(1), box(11), nullptr);
avl = grpc_avl_add(avl, box(2), box(22), nullptr);
avl = grpc_avl_add(avl, box(3), box(33), nullptr);
check_get(avl, 1, 11);
check_get(avl, 2, 22);
check_get(avl, 3, 33);
check_negget(avl, 4);
grpc_avl_unref(avl, nullptr);
}
static void test_ll(void) {
grpc_avl avl;
gpr_log(GPR_DEBUG, "test_ll");
avl = grpc_avl_create(&int_int_vtable);
avl = grpc_avl_add(avl, box(5), box(1), nullptr);
avl = grpc_avl_add(avl, box(4), box(2), nullptr);
avl = grpc_avl_add(avl, box(3), box(3), nullptr);
GPR_ASSERT(*(int*)avl.root->key == 4);
GPR_ASSERT(*(int*)avl.root->left->key == 3);
GPR_ASSERT(*(int*)avl.root->right->key == 5);
grpc_avl_unref(avl, nullptr);
}
static void test_lr(void) {
grpc_avl avl;
gpr_log(GPR_DEBUG, "test_lr");
avl = grpc_avl_create(&int_int_vtable);
avl = grpc_avl_add(avl, box(5), box(1), nullptr);
avl = grpc_avl_add(avl, box(3), box(2), nullptr);
avl = grpc_avl_add(avl, box(4), box(3), nullptr);
GPR_ASSERT(*(int*)avl.root->key == 4);
GPR_ASSERT(*(int*)avl.root->left->key == 3);
GPR_ASSERT(*(int*)avl.root->right->key == 5);
grpc_avl_unref(avl, nullptr);
}
static void test_rr(void) {
grpc_avl avl;
gpr_log(GPR_DEBUG, "test_rr");
avl = grpc_avl_create(&int_int_vtable);
avl = grpc_avl_add(avl, box(3), box(1), nullptr);
avl = grpc_avl_add(avl, box(4), box(2), nullptr);
avl = grpc_avl_add(avl, box(5), box(3), nullptr);
GPR_ASSERT(*(int*)avl.root->key == 4);
GPR_ASSERT(*(int*)avl.root->left->key == 3);
GPR_ASSERT(*(int*)avl.root->right->key == 5);
grpc_avl_unref(avl, nullptr);
}
static void test_rl(void) {
grpc_avl avl;
gpr_log(GPR_DEBUG, "test_rl");
avl = grpc_avl_create(&int_int_vtable);
avl = grpc_avl_add(avl, box(3), box(1), nullptr);
avl = grpc_avl_add(avl, box(5), box(2), nullptr);
avl = grpc_avl_add(avl, box(4), box(3), nullptr);
GPR_ASSERT(*(int*)avl.root->key == 4);
GPR_ASSERT(*(int*)avl.root->left->key == 3);
GPR_ASSERT(*(int*)avl.root->right->key == 5);
grpc_avl_unref(avl, nullptr);
}
static void test_unbalanced(void) {
grpc_avl avl;
gpr_log(GPR_DEBUG, "test_unbalanced");
avl = grpc_avl_create(&int_int_vtable);
avl = grpc_avl_add(avl, box(5), box(1), nullptr);
avl = grpc_avl_add(avl, box(4), box(2), nullptr);
avl = grpc_avl_add(avl, box(3), box(3), nullptr);
avl = grpc_avl_add(avl, box(2), box(4), nullptr);
avl = grpc_avl_add(avl, box(1), box(5), nullptr);
GPR_ASSERT(*(int*)avl.root->key == 4);
GPR_ASSERT(*(int*)avl.root->left->key == 2);
GPR_ASSERT(*(int*)avl.root->left->left->key == 1);
GPR_ASSERT(*(int*)avl.root->left->right->key == 3);
GPR_ASSERT(*(int*)avl.root->right->key == 5);
grpc_avl_unref(avl, nullptr);
}
static void test_replace(void) {
grpc_avl avl;
gpr_log(GPR_DEBUG, "test_replace");
avl = grpc_avl_create(&int_int_vtable);
avl = grpc_avl_add(avl, box(1), box(1), nullptr);
avl = grpc_avl_add(avl, box(1), box(2), nullptr);
check_get(avl, 1, 2);
check_negget(avl, 2);
grpc_avl_unref(avl, nullptr);
}
static void test_remove(void) {
grpc_avl avl;
grpc_avl avl3, avl4, avl5, avln;
gpr_log(GPR_DEBUG, "test_remove");
avl = grpc_avl_create(&int_int_vtable);
avl = grpc_avl_add(avl, box(3), box(1), nullptr);
avl = grpc_avl_add(avl, box(4), box(2), nullptr);
avl = grpc_avl_add(avl, box(5), box(3), nullptr);
avl3 = remove_int(grpc_avl_ref(avl, nullptr), 3);
avl4 = remove_int(grpc_avl_ref(avl, nullptr), 4);
avl5 = remove_int(grpc_avl_ref(avl, nullptr), 5);
avln = remove_int(grpc_avl_ref(avl, nullptr), 1);
grpc_avl_unref(avl, nullptr);
check_negget(avl3, 3);
check_get(avl3, 4, 2);
check_get(avl3, 5, 3);
grpc_avl_unref(avl3, nullptr);
check_get(avl4, 3, 1);
check_negget(avl4, 4);
check_get(avl4, 5, 3);
grpc_avl_unref(avl4, nullptr);
check_get(avl5, 3, 1);
check_get(avl5, 4, 2);
check_negget(avl5, 5);
grpc_avl_unref(avl5, nullptr);
check_get(avln, 3, 1);
check_get(avln, 4, 2);
check_get(avln, 5, 3);
grpc_avl_unref(avln, nullptr);
}
static void test_badcase1(void) {
grpc_avl avl;
gpr_log(GPR_DEBUG, "test_badcase1");
avl = grpc_avl_create(&int_int_vtable);
avl = grpc_avl_add(avl, box(88), box(1), nullptr);
avl = remove_int(avl, 643);
avl = remove_int(avl, 983);
avl = grpc_avl_add(avl, box(985), box(4), nullptr);
avl = grpc_avl_add(avl, box(640), box(5), nullptr);
avl = grpc_avl_add(avl, box(41), box(6), nullptr);
avl = grpc_avl_add(avl, box(112), box(7), nullptr);
avl = grpc_avl_add(avl, box(342), box(8), nullptr);
avl = remove_int(avl, 1013);
avl = grpc_avl_add(avl, box(434), box(10), nullptr);
avl = grpc_avl_add(avl, box(520), box(11), nullptr);
avl = grpc_avl_add(avl, box(231), box(12), nullptr);
avl = grpc_avl_add(avl, box(852), box(13), nullptr);
avl = remove_int(avl, 461);
avl = grpc_avl_add(avl, box(108), box(15), nullptr);
avl = grpc_avl_add(avl, box(806), box(16), nullptr);
avl = grpc_avl_add(avl, box(827), box(17), nullptr);
avl = remove_int(avl, 796);
avl = grpc_avl_add(avl, box(340), box(19), nullptr);
avl = grpc_avl_add(avl, box(498), box(20), nullptr);
avl = grpc_avl_add(avl, box(203), box(21), nullptr);
avl = grpc_avl_add(avl, box(751), box(22), nullptr);
avl = grpc_avl_add(avl, box(150), box(23), nullptr);
avl = remove_int(avl, 237);
avl = grpc_avl_add(avl, box(830), box(25), nullptr);
avl = remove_int(avl, 1007);
avl = remove_int(avl, 394);
avl = grpc_avl_add(avl, box(65), box(28), nullptr);
avl = remove_int(avl, 904);
avl = remove_int(avl, 123);
avl = grpc_avl_add(avl, box(238), box(31), nullptr);
avl = grpc_avl_add(avl, box(184), box(32), nullptr);
avl = remove_int(avl, 331);
avl = grpc_avl_add(avl, box(827), box(34), nullptr);
check_get(avl, 830, 25);
grpc_avl_unref(avl, nullptr);
}
static void test_stress(int amount_of_stress) {
int added[1024];
int i, j;
int deletions = 0;
grpc_avl avl;
unsigned seed = static_cast<unsigned>(time(nullptr));
gpr_log(GPR_DEBUG, "test_stress amount=%d seed=%u", amount_of_stress, seed);
srand(static_cast<unsigned>(time(nullptr)));
avl = grpc_avl_create(&int_int_vtable);
memset(added, 0, sizeof(added));
for (i = 1; deletions < amount_of_stress; i++) {
int idx = rand() % static_cast<int> GPR_ARRAY_SIZE(added);
GPR_ASSERT(i);
if (rand() < RAND_MAX / 2) {
added[idx] = i;
printf("avl = grpc_avl_add(avl, box(%d), box(%d), NULL); /* d=%d */\n",
idx, i, deletions);
avl = grpc_avl_add(avl, box(idx), box(i), nullptr);
} else {
deletions += (added[idx] != 0);
added[idx] = 0;
printf("avl = remove_int(avl, %d); /* d=%d */\n", idx, deletions);
avl = remove_int(avl, idx);
}
for (j = 0; j < static_cast<int> GPR_ARRAY_SIZE(added); j++) {
if (added[j] != 0) {
check_get(avl, j, added[j]);
} else {
check_negget(avl, j);
}
}
}
grpc_avl_unref(avl, nullptr);
}
int main(int argc, char* argv[]) {
grpc::testing::TestEnvironment env(argc, argv);
test_get();
test_ll();
test_lr();
test_rr();
test_rl();
test_unbalanced();
test_replace();
test_remove();
test_badcase1();
test_stress(10);
return 0;
}