static void test_class(const pn_class_t *clazz, size_t size)
{
void *a = pn_class_new(clazz, size);
void *b = pn_class_new(clazz, size);
assert(!pn_class_equals(clazz, a, b));
assert(pn_class_equals(clazz, a, a));
assert(pn_class_equals(clazz, b, b));
assert(!pn_class_equals(clazz, a, NULL));
assert(!pn_class_equals(clazz, NULL, a));
int rca = pn_class_refcount(clazz, a);
int rcb = pn_class_refcount(clazz, b);
assert(rca == -1 || rca == 1);
assert(rcb == -1 || rcb == 1);
pn_class_incref(clazz, a);
rca = pn_class_refcount(clazz, a);
assert(rca == -1 || rca == 2);
pn_class_decref(clazz, a);
rca = pn_class_refcount(clazz, a);
assert(rca == -1 || rca == 1);
pn_class_free(clazz, a);
pn_class_free(clazz, b);
}
static void test_compare(void)
{
static pn_class_t clazz = PN_CLASS(compare);
void *a = pn_class_new(&clazz, 0);
assert(a);
void *b = pn_class_new(&clazz, 0);
assert(b);
assert(pn_compare(a, b));
assert(!pn_equals(a, b));
assert(!pn_compare(a, a));
assert(pn_equals(a, a));
assert(!pn_compare(b, b));
assert(pn_equals(b, b));
assert(pn_compare(a, b) == (intptr_t) ((uintptr_t) b - (uintptr_t) a));
assert(pn_compare(NULL, b));
assert(!pn_equals(NULL, b));
assert(pn_compare(a, NULL));
assert(!pn_equals(a, NULL));
assert(!pn_compare(NULL, NULL));
assert(pn_equals(NULL, NULL));
pn_free(a);
pn_free(b);
}
void test_list_compare(void)
{
pn_list_t *a = pn_list(PN_OBJECT, 0);
pn_list_t *b = pn_list(PN_OBJECT, 0);
assert(pn_equals(a, b));
void *one = pn_class_new(PN_OBJECT, 0);
void *two = pn_class_new(PN_OBJECT, 0);
void *three = pn_class_new(PN_OBJECT, 0);
pn_list_add(a, one);
assert(!pn_equals(a, b));
pn_list_add(b, one);
assert(pn_equals(a, b));
pn_list_add(b, two);
assert(!pn_equals(a, b));
pn_list_add(a, two);
assert(pn_equals(a, b));
pn_list_add(a, three);
assert(!pn_equals(a, b));
pn_list_add(b, three);
assert(pn_equals(a, b));
pn_free(a); pn_free(b);
pn_free(one); pn_free(two); pn_free(three);
}
static void test_list_refcount(size_t capacity)
{
void *one = pn_class_new(PN_OBJECT, 0);
void *two = pn_class_new(PN_OBJECT, 0);
void *three = pn_class_new(PN_OBJECT, 0);
void *four = pn_class_new(PN_OBJECT, 0);
pn_list_t *list = pn_list(PN_OBJECT, 0);
assert(!pn_list_add(list, one));
assert(!pn_list_add(list, two));
assert(!pn_list_add(list, three));
assert(!pn_list_add(list, four));
assert(pn_list_get(list, 0) == one);
assert(pn_list_get(list, 1) == two);
assert(pn_list_get(list, 2) == three);
assert(pn_list_get(list, 3) == four);
assert(pn_list_size(list) == 4);
assert(pn_refcount(one) == 2);
assert(pn_refcount(two) == 2);
assert(pn_refcount(three) == 2);
assert(pn_refcount(four) == 2);
pn_list_del(list, 1, 2);
assert(pn_list_size(list) == 2);
assert(pn_refcount(one) == 2);
assert(pn_refcount(two) == 1);
assert(pn_refcount(three) == 1);
assert(pn_refcount(four) == 2);
assert(pn_list_get(list, 0) == one);
assert(pn_list_get(list, 1) == four);
assert(!pn_list_add(list, one));
assert(pn_list_size(list) == 3);
assert(pn_refcount(one) == 3);
pn_decref(list);
assert(pn_refcount(one) == 1);
assert(pn_refcount(two) == 1);
assert(pn_refcount(three) == 1);
assert(pn_refcount(four) == 1);
pn_decref(one);
pn_decref(two);
pn_decref(three);
pn_decref(four);
}
static void test_map_links(void)
{
const pn_class_t collider_clazz = PN_CLASS(collider);
void *keys[3];
for (int i = 0; i < 3; i++)
keys[i] = pn_class_new(&collider_clazz, 0);
// test deleting a head, middle link, tail
for (int delete_idx=0; delete_idx < 3; delete_idx++) {
pn_map_t *map = pn_map(PN_WEAKREF, PN_WEAKREF, 0, 0.75);
// create a chain of entries that have same head (from identical key hashcode)
for (int i = 0; i < 3; i++) {
pn_map_put(map, keys[i], keys[i]);
}
pn_map_del(map, keys[delete_idx]);
for (int i = 0; i < 3; i++) {
void *value = (i == delete_idx) ? NULL : keys[i];
assert (pn_map_get(map, keys[i]) == value);
}
pn_free(map);
}
for (int i = 0; i < 3; i++)
pn_free(keys[i]);
}
iocp_t *pni_iocp()
{
static const pn_cid_t CID_pni_iocp = CID_pn_void;
static const pn_class_t clazz = PN_CLASS(pni_iocp);
iocp_t *iocp = (iocp_t *) pn_class_new(&clazz, sizeof(iocp_t));
return iocp;
}
PN_EXTERN pn_url_t *pn_url() {
static const pn_class_t clazz = PN_CLASS(pn_url);
pn_url_t *url = (pn_url_t*) pn_class_new(&clazz, sizeof(pn_url_t));
if (!url) return NULL;
memset(url, 0, sizeof(*url));
url->str = pn_string(NULL);
return url;
}
write_pipeline_t *pni_write_pipeline(iocpdesc_t *iocpd)
{
static const pn_cid_t CID_write_pipeline = CID_pn_void;
static const pn_class_t clazz = PN_CLASS(write_pipeline);
write_pipeline_t *pipeline = (write_pipeline_t *) pn_class_new(&clazz, sizeof(write_pipeline_t));
pipeline->iocpd = iocpd;
pipeline->primary->base.iocpd = iocpd;
return pipeline;
}
// Reference counted in the iocpdesc map, zombie_list, selector.
static iocpdesc_t *pni_iocpdesc(pn_socket_t s)
{
static const pn_cid_t CID_pni_iocpdesc = CID_pn_void;
static pn_class_t clazz = PN_CLASS(pni_iocpdesc);
iocpdesc_t *iocpd = (iocpdesc_t *) pn_class_new(&clazz, sizeof(iocpdesc_t));
assert(iocpd);
iocpd->socket = s;
return iocpd;
}
static void test_hashcode(void)
{
static pn_class_t clazz = PN_CLASS(hashcode);
void *obj = pn_class_new(&clazz, 0);
assert(obj);
assert(pn_hashcode(obj) == (uintptr_t) obj);
assert(pn_hashcode(NULL) == 0);
pn_free(obj);
}
static void test_hash(void)
{
void *one = pn_class_new(PN_OBJECT, 0);
void *two = pn_class_new(PN_OBJECT, 0);
void *three = pn_class_new(PN_OBJECT, 0);
pn_hash_t *hash = pn_hash(PN_OBJECT, 4, 0.75);
pn_hash_put(hash, 0, NULL);
pn_hash_put(hash, 1, one);
pn_hash_put(hash, 2, two);
pn_hash_put(hash, 3, three);
pn_hash_put(hash, 4, one);
pn_hash_put(hash, 5, two);
pn_hash_put(hash, 6, three);
pn_hash_put(hash, 7, one);
pn_hash_put(hash, 8, two);
pn_hash_put(hash, 9, three);
pn_hash_put(hash, 10, one);
pn_hash_put(hash, 11, two);
pn_hash_put(hash, 12, three);
pn_hash_put(hash, 18, one);
assert(pn_hash_get(hash, 2) == two);
assert(pn_hash_get(hash, 5) == two);
assert(pn_hash_get(hash, 18) == one);
assert(pn_hash_get(hash, 0) == NULL);
assert(pn_hash_size(hash) == 14);
pn_hash_del(hash, 5);
assert(pn_hash_get(hash, 5) == NULL);
assert(pn_hash_size(hash) == 13);
pn_hash_del(hash, 18);
assert(pn_hash_get(hash, 18) == NULL);
assert(pn_hash_size(hash) == 12);
pn_decref(hash);
pn_decref(one);
pn_decref(two);
pn_decref(three);
}
pn_list_t *pn_list(const pn_class_t *clazz, size_t capacity)
{
static const pn_class_t list_clazz = PN_CLASS(pn_list);
pn_list_t *list = (pn_list_t *) pn_class_new(&list_clazz, sizeof(pn_list_t));
list->clazz = clazz;
list->capacity = capacity ? capacity : 16;
list->elements = (void **) malloc(list->capacity * sizeof(void *));
list->size = 0;
return list;
}
static connect_result_t *connect_result(iocpdesc_t *iocpd, struct addrinfo *addr) {
static const pn_cid_t CID_connect_result = CID_pn_void;
static const pn_class_t clazz = PN_CLASS(connect_result);
connect_result_t *result = (connect_result_t *) pn_class_new(&clazz, sizeof(connect_result_t));
if (result) {
memset(result, 0, sizeof(connect_result_t));
result->base.type = IOCP_CONNECT;
result->base.iocpd = iocpd;
result->addrinfo = addr;
}
return result;
}
static pni_acceptor_t *pni_acceptor(iocpdesc_t *iocpd)
{
static const pn_cid_t CID_pni_acceptor = CID_pn_void;
static const pn_class_t clazz = PN_CLASS(pni_acceptor);
pni_acceptor_t *acceptor = (pni_acceptor_t *) pn_class_new(&clazz, sizeof(pni_acceptor_t));
acceptor->listen_sock = iocpd;
acceptor->accept_queue_size = 0;
acceptor->signalled = false;
pn_socket_t sock = acceptor->listen_sock->socket;
acceptor->fn_accept_ex = lookup_accept_ex(sock);
acceptor->fn_get_accept_ex_sockaddrs = lookup_get_accept_ex_sockaddrs(sock);
return acceptor;
}
static void test_new(size_t size, const pn_class_t *clazz)
{
void *obj = pn_class_new(clazz, size);
assert(obj);
assert(pn_class_refcount(PN_OBJECT, obj) == 1);
assert(pn_class(obj) == clazz);
char *bytes = (char *) obj;
for (size_t i = 0; i < size; i++) {
// touch everything for valgrind
bytes[i] = i;
}
pn_free(obj);
}
static void test_finalize(void)
{
static pn_class_t clazz = PN_CLASS(finalizer);
int **obj = (int **) pn_class_new(&clazz, sizeof(int **));
assert(obj);
int called = 0;
*obj = &called;
pn_free(obj);
assert(called == 1);
}
static void test_map_iteration(int n)
{
pn_list_t *pairs = pn_list(PN_OBJECT, 2*n);
for (int i = 0; i < n; i++) {
void *key = pn_class_new(PN_OBJECT, 0);
void *value = pn_class_new(PN_OBJECT, 0);
pn_list_add(pairs, key);
pn_list_add(pairs, value);
pn_decref(key);
pn_decref(value);
}
pn_map_t *map = pn_map(PN_OBJECT, PN_OBJECT, 0, 0.75);
assert(pn_map_head(map) == 0);
for (int i = 0; i < n; i++) {
pn_map_put(map, pn_list_get(pairs, 2*i), pn_list_get(pairs, 2*i + 1));
}
for (pn_handle_t entry = pn_map_head(map); entry; entry = pn_map_next(map, entry))
{
void *key = pn_map_key(map, entry);
void *value = pn_map_value(map, entry);
ssize_t idx = pn_list_index(pairs, key);
assert(idx >= 0);
assert(pn_list_get(pairs, idx) == key);
assert(pn_list_get(pairs, idx + 1) == value);
pn_list_del(pairs, idx, 2);
}
assert(pn_list_size(pairs) == 0);
pn_decref(map);
pn_decref(pairs);
}
pn_subscription_t *pn_subscription(pn_messenger_t *messenger,
const char *scheme,
const char *host,
const char *port)
{
static const pn_class_t clazz = PN_CLASS(pn_subscription);
pn_subscription_t *sub = (pn_subscription_t *) pn_class_new(&clazz, sizeof(pn_subscription_t));
sub->messenger = messenger;
pn_string_set(sub->scheme, scheme);
pn_string_set(sub->host, host);
pn_string_set(sub->port, port);
pni_messenger_add_subscription(messenger, sub);
pn_class_decref(PN_OBJECT, sub);
return sub;
}
pn_selectable_t *pni_selectable(ssize_t (*capacity)(pn_selectable_t *),
ssize_t (*pending)(pn_selectable_t *),
pn_timestamp_t (*deadline)(pn_selectable_t *),
void (*readable)(pn_selectable_t *),
void (*writable)(pn_selectable_t *),
void (*expired)(pn_selectable_t *),
void (*finalize)(pn_selectable_t *))
{
static const pn_class_t clazz = PN_CLASS(pn_selectable);
pn_selectable_t *selectable = (pn_selectable_t *) pn_class_new(&clazz, sizeof(pn_selectable_t));
selectable->capacity = capacity;
selectable->pending = pending;
selectable->readable = readable;
selectable->deadline = deadline;
selectable->writable = writable;
selectable->expired = expired;
selectable->finalize = finalize;
return selectable;
}
static void test_refcounting(int refs)
{
void *obj = pn_class_new(PN_OBJECT, 0);
assert(pn_refcount(obj) == 1);
for (int i = 0; i < refs; i++) {
pn_incref(obj);
assert(pn_refcount(obj) == i + 2);
}
assert(pn_refcount(obj) == refs + 1);
for (int i = 0; i < refs; i++) {
pn_decref(obj);
assert(pn_refcount(obj) == refs - i);
}
assert(pn_refcount(obj) == 1);
pn_free(obj);
}
pn_io_t *pn_io(void)
{
static const pn_class_t clazz = PN_CLASS(pn_io);
pn_io_t *io = (pn_io_t *) pn_class_new(&clazz, sizeof(pn_io_t));
return io;
}
pn_selector_t *pni_selector()
{
static const pn_class_t clazz = PN_CLASS(pn_selector);
pn_selector_t *selector = (pn_selector_t *) pn_class_new(&clazz, sizeof(pn_selector_t));
return selector;
}
pn_iterator_t *pn_iterator()
{
static const pn_class_t clazz = PN_CLASS(pn_iterator);
pn_iterator_t *it = (pn_iterator_t *) pn_class_new(&clazz, sizeof(pn_iterator_t));
return it;
}
pn_encoder_t *pn_encoder()
{
static const pn_class_t clazz = PN_CLASS(pn_encoder);
return (pn_encoder_t *) pn_class_new(&clazz, sizeof(pn_encoder_t));
}
static void test_map(void)
{
void *one = pn_class_new(PN_OBJECT, 0);
void *two = pn_class_new(PN_OBJECT, 0);
void *three = pn_class_new(PN_OBJECT, 0);
pn_map_t *map = pn_map(PN_OBJECT, PN_OBJECT, 4, 0.75);
assert(pn_map_size(map) == 0);
pn_string_t *key = pn_string("key");
pn_string_t *dup = pn_string("key");
pn_string_t *key1 = pn_string("key1");
pn_string_t *key2 = pn_string("key2");
assert(!pn_map_put(map, key, one));
assert(pn_map_size(map) == 1);
assert(!pn_map_put(map, key1, two));
assert(pn_map_size(map) == 2);
assert(!pn_map_put(map, key2, three));
assert(pn_map_size(map) == 3);
assert(pn_map_get(map, dup) == one);
assert(!pn_map_put(map, dup, one));
assert(pn_map_size(map) == 3);
assert(!pn_map_put(map, dup, two));
assert(pn_map_size(map) == 3);
assert(pn_map_get(map, dup) == two);
assert(pn_refcount(key) == 2);
assert(pn_refcount(dup) == 1);
assert(pn_refcount(key1) == 2);
assert(pn_refcount(key2) == 2);
assert(pn_refcount(one) == 1);
assert(pn_refcount(two) == 3);
assert(pn_refcount(three) == 2);
pn_map_del(map, key1);
assert(pn_map_size(map) == 2);
assert(pn_refcount(key) == 2);
assert(pn_refcount(dup) == 1);
assert(pn_refcount(key1) == 1);
assert(pn_refcount(key2) == 2);
assert(pn_refcount(one) == 1);
assert(pn_refcount(two) == 2);
assert(pn_refcount(three) == 2);
pn_decref(one);
pn_decref(two);
pn_decref(three);
pn_decref(key);
pn_decref(dup);
pn_decref(key1);
pn_decref(key2);
pn_decref(map);
}
