Add a test that ensures that taskprocessor listener callbacks

are properly called.

The new test is a bit raw in that it uses magic numbers, but that
can be improved upon easily.



git-svn-id: https://origsvn.digium.com/svn/asterisk/team/mmichelson/threadpool@376124 65c4cc65-6c06-0410-ace0-fbb531ad65f3

tests/test_taskprocessor.c

@@ -34,6 +34,7 @@
 #include "asterisk/test.h"
 #include "asterisk/taskprocessor.h"
 #include "asterisk/module.h"
+#include "asterisk/astobj2.h"
 
 struct task_data {
 	ast_cond_t cond;
@@ -98,15 +99,119 @@ test_end:
 	return res;
 }
 
+struct test_listener_pvt {
+	int num_pushed;
+	int num_emptied;
+};
+
+static void *test_alloc(struct ast_taskprocessor_listener *listener)
+{
+	struct test_listener_pvt *pvt;
+
+	pvt = ast_calloc(1, sizeof(*pvt));
+	return pvt;
+}
+
+static void test_task_pushed(struct ast_taskprocessor_listener *listener, int was_empty)
+{
+	struct test_listener_pvt *pvt = listener->private_data;
+	++pvt->num_pushed;
+}
+
+static void test_emptied(struct ast_taskprocessor_listener *listener)
+{
+	struct test_listener_pvt *pvt = listener->private_data;
+	++pvt->num_emptied;
+}
+
+static void test_destroy(void *private_data)
+{
+	struct test_listener_pvt *pvt = private_data;
+	ast_free(pvt);
+}
+
+static const struct ast_taskprocessor_listener_callbacks test_callbacks = {
+	.alloc = test_alloc,
+	.task_pushed = test_task_pushed,
+	.emptied = test_emptied,
+	.destroy = test_destroy,
+};
+
+static int listener_test_task(void *ignore)
+{
+	return 0;
+}
+
+AST_TEST_DEFINE(taskprocessor_listener)
+{
+	struct ast_taskprocessor *tps;
+	struct ast_taskprocessor_listener *listener;
+	struct test_listener_pvt *pvt;
+	enum ast_test_result_state res = AST_TEST_PASS;
+
+	switch (cmd) {
+	case TEST_INIT:
+		info->name = "taskprocessor_listener";
+		info->category = "/main/taskprocessor/";
+		info->summary = "Test of taskproccesor listeners";
+		info->description =
+			"Ensures that listener callbacks are called when expected.";
+		return AST_TEST_NOT_RUN;
+	case TEST_EXECUTE:
+		break;
+	}
+
+	listener = ast_taskprocessor_listener_alloc(&test_callbacks);
+	if (!listener) {
+		ast_test_status_update(test, "Unable to allocate test taskprocessor listener\n");
+		return AST_TEST_FAIL;
+	}
+
+	tps = ast_taskprocessor_create_with_listener("test_listener", listener);
+	if (!tps) {
+		ast_test_status_update(test, "Unable to allocate test taskprocessor\n");
+		res = AST_TEST_FAIL;
+		goto test_exit;
+	}
+
+	ast_taskprocessor_push(tps, listener_test_task, NULL);
+	ast_taskprocessor_push(tps, listener_test_task, NULL);
+
+	ast_taskprocessor_execute(tps);
+	ast_taskprocessor_execute(tps);
+
+	pvt = listener->private_data;
+	if (pvt->num_pushed != 2) {
+		ast_test_status_update(test, "Unexpected number of tasks pushed. Expected %d but got %d\n",
+				2, pvt->num_pushed);
+		res = AST_TEST_FAIL;
+		goto test_exit;
+	}
+
+	if (pvt->num_emptied != 1) {
+		ast_test_status_update(test, "Unexpected number of empties. Expected %d but got %d\n",
+				1, pvt->num_emptied);
+		res = AST_TEST_FAIL;
+		goto test_exit;
+	}
+
+test_exit:
+	ao2_ref(listener, -1);
+	ast_taskprocessor_unreference(tps);
+	return res;
+}
+
 static int unload_module(void)
 {
 	ast_test_unregister(default_taskprocessor);
+	ast_test_unregister(taskprocessor_listener);
 	return 0;
 }
 
 static int load_module(void)
 {
 	ast_test_register(default_taskprocessor);
+	ast_test_register(taskprocessor_listener);
 	return AST_MODULE_LOAD_SUCCESS;
 }