[babeltrace.git] / tests / lib / test_bt_notification_heap.c

/*
 * test_bt_notification_heap.c
 *
 * bt_notification_heap tests
 *
 * Copyright 2016 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; under version 2 of the License.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#include "tap/tap.h"
#include <stdlib.h>
#include <babeltrace/compiler-internal.h>
#include <babeltrace/ref.h>
#include <babeltrace/graph/notification-heap.h>
#include <babeltrace/graph/notification.h>
#include <babeltrace/graph/notification-internal.h>

#define NR_TESTS 7

struct dummy_notification {
	struct bt_notification parent;
	uint64_t value;
};

static
void dummy_notification_destroy(struct bt_object *obj)
{
	g_free(obj);
}

/* Reproduced from internal notification.c code. */
void bt_notification_init(struct bt_notification *notification,
		enum bt_notification_type type,
		bt_object_release_func release)
{
	assert(type > BT_NOTIFICATION_TYPE_ALL &&
			type < BT_NOTIFICATION_TYPE_NR);
	notification->type = type;
	bt_object_init(&notification->base, release);
}

static
struct bt_notification *dummy_notification_create(uint64_t value)
{
	struct dummy_notification *notification;

	notification = g_new0(struct dummy_notification, 1);
	if (!notification) {
		goto error;
	}
	bt_notification_init(&notification->parent,
			BT_NOTIFICATION_TYPE_NR - 1 /* dummy value */,
		        dummy_notification_destroy);
	notification->value = value;
	return &notification->parent;
error:
	return NULL;
}

static
bt_bool compare_notifications(struct bt_notification *a, struct bt_notification *b,
		void *unused)
{
	uint64_t val_a = ((struct dummy_notification *) a)->value;
	uint64_t val_b = ((struct dummy_notification *) b)->value;

	if (val_a == val_b) {
		return a < b;
	} else {
		return val_a < val_b;
	}
}

int main(int argc, char **argv)
{
	int i;
	uint64_t last_read_value = 0;
	struct bt_notification_heap *heap = NULL;

	/* Initialize tap harness before any tests */
	plan_tests(NR_TESTS);
	heap = bt_notification_heap_create(compare_notifications, NULL);
	ok(heap, "Created a notification heap");

	/* Insert 10 000 notifications with random values. */
	for (i = 0; i < 10000; i++) {
		int ret;
		struct bt_notification *notification =
				dummy_notification_create(rand());

		if (!notification) {
			diag("Dummy notification creation failed");
			goto end;
		}

		ret = bt_notification_heap_insert(heap, notification);
		if (ret) {
			diag("Failed to insert notification %i in heap", i);
			goto end;
		}
		bt_put(notification);
	}
	pass("Inserted 10 000 random notifications in notification heap");

	/* Pop 5000 notifications, making sure the values read are ascending */
	for (i = 0; i < 5000; i++) {
		struct bt_notification *pop_notification;
		struct bt_notification *peek_notification;
		struct dummy_notification *dummy;

		peek_notification = bt_notification_heap_peek(heap);
		if (!peek_notification) {
			fail("Failed to peek a notification");
			goto end;
		}

		pop_notification = bt_notification_heap_pop(heap);
		if (!pop_notification) {
			fail("Failed to pop a notification");
			goto end;
		}

		if (peek_notification != pop_notification) {
			fail("bt_notification_heap_peek and bt_notification_heap_pop do not return the same notification");
			bt_put(peek_notification);
			bt_put(pop_notification);
			goto end;
		}

		dummy = container_of(pop_notification,
				struct dummy_notification, parent);
		if (dummy->value < last_read_value) {
			fail("Notification heap did not provide notifications in ascending order");
		}
		last_read_value = dummy->value;
		bt_put(peek_notification);
		bt_put(pop_notification);
	}

	pass("bt_notification_heap_peek and bt_notification_heap_pop return the same notification");
	pass("Notification heap provided 5 000 notifications in ascending order");

	/* Insert 10 000 notifications with random values. */
	for (i = 0; i < 10000; i++) {
		int ret;
		struct bt_notification *notification =
				dummy_notification_create(rand());

		if (!notification) {
			diag("Dummy notification creation failed");
			goto end;
		}

		ret = bt_notification_heap_insert(heap, notification);
		if (ret) {
			diag("Failed to insert notification %i in heap", i);
			goto end;
		}
		bt_put(notification);
	}
	pass("Inserted 10 000 random notifications in notification heap after popping");

	last_read_value = 0;
	/* Pop remaining 15 000 notifications, making sure the values read are ascending */
	for (i = 0; i < 15000; i++) {
		struct bt_notification *pop_notification;
		struct dummy_notification *dummy;

		pop_notification = bt_notification_heap_pop(heap);
		if (!pop_notification) {
			fail("Failed to pop a notification");
			goto end;
		}
		dummy = container_of(pop_notification,
				struct dummy_notification, parent);
		if (dummy->value < last_read_value) {
			fail("Notification heap did not provide notifications in ascending order");
		}
		last_read_value = dummy->value;
		bt_put(pop_notification);
	}
	pass("Popped remaining 15 000 notifications from heap in ascending order");

	ok(!bt_notification_heap_peek(heap), "No notifications left in heap");
end:
	bt_put(heap);
	return exit_status();
}
Commit	Line	Data
e7ba301a JG	1	/*
	2	* test_bt_notification_heap.c
	3	*
	4	* bt_notification_heap tests
	5	*
	6	* Copyright 2016 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation; under version 2 of the License.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License along
	18	* with this program; if not, write to the Free Software Foundation, Inc.,
	19	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*/
	21
	22	#include "tap/tap.h"
e7ba301a	23	#include <stdlib.h>
3d9990ac	24	#include <babeltrace/compiler-internal.h>
e7ba301a	25	#include <babeltrace/ref.h>
b2e0c907 PP	26	#include <babeltrace/graph/notification-heap.h>
	27	#include <babeltrace/graph/notification.h>
	28	#include <babeltrace/graph/notification-internal.h>
e7ba301a JG	29
	30	#define NR_TESTS 7
	31
	32	struct dummy_notification {
	33	struct bt_notification parent;
	34	uint64_t value;
	35	};
	36
	37	static
	38	void dummy_notification_destroy(struct bt_object *obj)
	39	{
	40	g_free(obj);
	41	}
	42
	43	/* Reproduced from internal notification.c code. */
	44	void bt_notification_init(struct bt_notification *notification,
	45	enum bt_notification_type type,
	46	bt_object_release_func release)
	47	{
	48	assert(type > BT_NOTIFICATION_TYPE_ALL &&
	49	type < BT_NOTIFICATION_TYPE_NR);
	50	notification->type = type;
	51	bt_object_init(&notification->base, release);
	52	}
	53
	54	static
	55	struct bt_notification *dummy_notification_create(uint64_t value)
	56	{
	57	struct dummy_notification *notification;
	58
	59	notification = g_new0(struct dummy_notification, 1);
	60	if (!notification) {
	61	goto error;
	62	}
	63	bt_notification_init(&notification->parent,
	64	BT_NOTIFICATION_TYPE_NR - 1 /* dummy value */,
	65	dummy_notification_destroy);
	66	notification->value = value;
	67	return &notification->parent;
	68	error:
	69	return NULL;
	70	}
	71
	72	static
c55a9f58	73	bt_bool compare_notifications(struct bt_notification a, struct bt_notification b,
352fe16f	74	void *unused)
e7ba301a JG	75	{
	76	uint64_t val_a = ((struct dummy_notification *) a)->value;
	77	uint64_t val_b = ((struct dummy_notification *) b)->value;
	78
	79	if (val_a == val_b) {
	80	return a < b;
	81	} else {
	82	return val_a < val_b;
	83	}
	84	}
	85
	86	int main(int argc, char **argv)
	87	{
	88	int i;
	89	uint64_t last_read_value = 0;
	90	struct bt_notification_heap *heap = NULL;
	91
	92	/* Initialize tap harness before any tests */
	93	plan_tests(NR_TESTS);
352fe16f	94	heap = bt_notification_heap_create(compare_notifications, NULL);
e7ba301a JG	95	ok(heap, "Created a notification heap");
	96
	97	/* Insert 10 000 notifications with random values. */
	98	for (i = 0; i < 10000; i++) {
	99	int ret;
	100	struct bt_notification *notification =
	101	dummy_notification_create(rand());
	102
	103	if (!notification) {
	104	diag("Dummy notification creation failed");
	105	goto end;
	106	}
	107
	108	ret = bt_notification_heap_insert(heap, notification);
	109	if (ret) {
	110	diag("Failed to insert notification %i in heap", i);
	111	goto end;
	112	}
	113	bt_put(notification);
	114	}
	115	pass("Inserted 10 000 random notifications in notification heap");
	116
	117	/* Pop 5000 notifications, making sure the values read are ascending */
	118	for (i = 0; i < 5000; i++) {
	119	struct bt_notification *pop_notification;
	120	struct bt_notification *peek_notification;
	121	struct dummy_notification *dummy;
	122
	123	peek_notification = bt_notification_heap_peek(heap);
	124	if (!peek_notification) {
	125	fail("Failed to peek a notification");
	126	goto end;
	127	}
	128
	129	pop_notification = bt_notification_heap_pop(heap);
	130	if (!pop_notification) {
	131	fail("Failed to pop a notification");
	132	goto end;
	133	}
	134
	135	if (peek_notification != pop_notification) {
	136	fail("bt_notification_heap_peek and bt_notification_heap_pop do not return the same notification");
	137	bt_put(peek_notification);
	138	bt_put(pop_notification);
	139	goto end;
	140	}
	141
	142	dummy = container_of(pop_notification,
	143	struct dummy_notification, parent);
	144	if (dummy->value < last_read_value) {
	145	fail("Notification heap did not provide notifications in ascending order");
	146	}
	147	last_read_value = dummy->value;
	148	bt_put(peek_notification);
	149	bt_put(pop_notification);
	150	}
	151
	152	pass("bt_notification_heap_peek and bt_notification_heap_pop return the same notification");
	153	pass("Notification heap provided 5 000 notifications in ascending order");
	154
	155	/* Insert 10 000 notifications with random values. */
	156	for (i = 0; i < 10000; i++) {
	157	int ret;
	158	struct bt_notification *notification =
159	dummy_notification_create(rand());
160
161	if (!notification) {
162	diag("Dummy notification creation failed");
163	goto end;
164	}
165
166	ret = bt_notification_heap_insert(heap, notification);
167	if (ret) {
168	diag("Failed to insert notification %i in heap", i);
169	goto end;
170	}
171	bt_put(notification);
172	}
173	pass("Inserted 10 000 random notifications in notification heap after popping");
174
175	last_read_value = 0;
176	/* Pop remaining 15 000 notifications, making sure the values read are ascending */
177	for (i = 0; i < 15000; i++) {
178	struct bt_notification *pop_notification;
179	struct dummy_notification *dummy;
180
181	pop_notification = bt_notification_heap_pop(heap);
182	if (!pop_notification) {
183	fail("Failed to pop a notification");
184	goto end;
185	}
186	dummy = container_of(pop_notification,
187	struct dummy_notification, parent);
188	if (dummy->value < last_read_value) {
189	fail("Notification heap did not provide notifications in ascending order");
190	}
191	last_read_value = dummy->value;
192	bt_put(pop_notification);
193	}
194	pass("Popped remaining 15 000 notifications from heap in ascending order");
195
196	ok(!bt_notification_heap_peek(heap), "No notifications left in heap");
197	end:
198	bt_put(heap);
199	return exit_status();
200	}