Add ast_event subscription unit test and fix some ast_event API bugs.
authorRussell Bryant <russell@russellbryant.com>
Thu, 22 Apr 2010 21:06:53 +0000 (21:06 +0000)
committerRussell Bryant <russell@russellbryant.com>
Thu, 22 Apr 2010 21:06:53 +0000 (21:06 +0000)
This patch introduces another test in test_event.c that exercises most of the
subscription related ast_event API calls.  I made some minor additions to the
existing event allocation test to increase API coverage by the test code.
Finally, I made a list in a comment of API calls not yet touched by the test
module as a to-do list for future test development.

During the development of this test code, I discovered a number of bugs in
the event API.

1) subscriptions to AST_EVENT_ALL were not handled appropriately in a couple
   of different places.  The API allows a subscription to all event types,
   but with IE parameters, just as if it was a subscription to a specific
   event type.  However, the parameters were being ignored.  This affected
   ast_event_check_subscriber() and event distribution to subscribers.

2) Some of the logic in ast_event_check_subscriber() for checking subscriptions
   against query parameters was wrong.

Review: https://reviewboard.asterisk.org/r/617/

git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@258632 65c4cc65-6c06-0410-ace0-fbb531ad65f3

main/event.c
tests/test_event.c

index 366834e..51a3a45 100644 (file)
@@ -350,14 +350,69 @@ static void ast_event_ie_val_destroy(struct ast_event_ie_val *ie_val)
        ast_free(ie_val);
 }
 
+/*!
+ * \internal
+ * \brief Check if an ie_val matches a subscription
+ *
+ * \param sub subscription to check against
+ * \param ie_val IE value to check
+ *
+ * \retval 0 not matched
+ * \retval non-zero matched
+ */
+static int match_ie_val_to_sub(const struct ast_event_sub *sub, const struct ast_event_ie_val *ie_val)
+{
+       const struct ast_event_ie_val *sub_ie_val;
+       int res = 1;
+
+       AST_LIST_TRAVERSE(&sub->ie_vals, sub_ie_val, entry) {
+               if (sub_ie_val->ie_type == ie_val->ie_type) {
+                       break;
+               }
+       }
+
+       if (!sub_ie_val) {
+               /* This subscriber doesn't care about this IE, so consider
+                * it matched. */
+               return 1;
+       }
+
+       switch (ie_val->ie_pltype) {
+       case AST_EVENT_IE_PLTYPE_UINT:
+               res = (ie_val->payload.uint != sub_ie_val->payload.uint);
+               break;
+       case AST_EVENT_IE_PLTYPE_BITFLAGS:
+               /*
+                * If the subscriber has requested *any* of the bitflags we are providing,
+                * then it's a match.
+                */
+               res = !(ie_val->payload.uint & sub_ie_val->payload.uint);
+               break;
+       case AST_EVENT_IE_PLTYPE_STR:
+               res = strcmp(ie_val->payload.str, sub_ie_val->payload.str);
+               break;
+       case AST_EVENT_IE_PLTYPE_RAW:
+               res = memcmp(ie_val->payload.raw,
+                               sub_ie_val->payload.raw, ie_val->raw_datalen);
+               break;
+       case AST_EVENT_IE_PLTYPE_EXISTS:
+       case AST_EVENT_IE_PLTYPE_UNKNOWN:
+               break;
+       }
+
+       return res;
+}
+
 enum ast_event_subscriber_res ast_event_check_subscriber(enum ast_event_type type, ...)
 {
        va_list ap;
        enum ast_event_ie_type ie_type;
        enum ast_event_subscriber_res res = AST_EVENT_SUB_NONE;
-       struct ast_event_ie_val *ie_val, *sub_ie_val;
+       struct ast_event_ie_val *ie_val;
        struct ast_event_sub *sub;
        AST_LIST_HEAD_NOLOCK_STATIC(ie_vals, ast_event_ie_val);
+       const enum ast_event_type event_types[] = { type, AST_EVENT_ALL };
+       int i;
 
        if (type >= AST_EVENT_TOTAL) {
                ast_log(LOG_ERROR, "%u is an invalid type!\n", type);
@@ -405,74 +460,42 @@ enum ast_event_subscriber_res ast_event_check_subscriber(enum ast_event_type typ
        }
        va_end(ap);
 
-       AST_RWDLLIST_RDLOCK(&ast_event_subs[type]);
-       AST_RWDLLIST_TRAVERSE(&ast_event_subs[type], sub, entry) {
-               AST_LIST_TRAVERSE(&ie_vals, ie_val, entry) {
-                       int break_out = 0;
-
-                       AST_LIST_TRAVERSE(&sub->ie_vals, sub_ie_val, entry) {
-                               if (sub_ie_val->ie_type == ie_val->ie_type) {
+       for (i = 0; i < ARRAY_LEN(event_types); i++) {
+               AST_RWDLLIST_RDLOCK(&ast_event_subs[event_types[i]]);
+               AST_RWDLLIST_TRAVERSE(&ast_event_subs[event_types[i]], sub, entry) {
+                       AST_LIST_TRAVERSE(&ie_vals, ie_val, entry) {
+                               if (match_ie_val_to_sub(sub, ie_val)) {
                                        break;
                                }
                        }
 
-                       if (!sub_ie_val) {
-                               /* This subscriber doesn't care about this IE, so consider
-                                * it matched. */
-                               continue;
-                       }
-
-                       switch (ie_val->ie_pltype) {
-                       case AST_EVENT_IE_PLTYPE_UINT:
-                               break_out = (ie_val->payload.uint != sub_ie_val->payload.uint);
-                               break;
-                       case AST_EVENT_IE_PLTYPE_BITFLAGS:
-                               /* if the subscriber has requested *any* of the bitflags we are providing,
-                                * then it's a match
-                                */
-                               break_out = (ie_val->payload.uint & sub_ie_val->payload.uint);
-                               break;
-                       case AST_EVENT_IE_PLTYPE_STR:
-                               break_out = strcmp(ie_val->payload.str, sub_ie_val->payload.str);
-                               break;
-                       case AST_EVENT_IE_PLTYPE_RAW:
-                               break_out = memcmp(ie_val->payload.raw,
-                                               sub_ie_val->payload.raw, ie_val->raw_datalen);
-                               break;
-                       case AST_EVENT_IE_PLTYPE_EXISTS:
-                               /* The subscriber doesn't actually care what the value is */
-                               break_out = 1;
-                               break;
-                       case AST_EVENT_IE_PLTYPE_UNKNOWN:
-                               break;
-                       }
-
-                       if (break_out) {
+                       if (!ie_val) {
+                               /* Everything matched. */
                                break;
                        }
                }
-
-               if (!ie_val) {
-                       /* Everything matched */
+               AST_RWDLLIST_UNLOCK(&ast_event_subs[event_types[i]]);
+               if (sub) {
                        break;
                }
        }
-       AST_RWDLLIST_UNLOCK(&ast_event_subs[type]);
-
-       if (sub) {
-               /* All parameters were matched */
-               return AST_EVENT_SUB_EXISTS;
-       }
 
-       AST_RWDLLIST_RDLOCK(&ast_event_subs[AST_EVENT_ALL]);
-       if (!AST_DLLIST_EMPTY(&ast_event_subs[AST_EVENT_ALL])) {
-               res = AST_EVENT_SUB_EXISTS;
-       }
-       AST_RWDLLIST_UNLOCK(&ast_event_subs[AST_EVENT_ALL]);
-
-       return res;
+       return sub ? AST_EVENT_SUB_EXISTS : AST_EVENT_SUB_NONE;
 }
 
+/*!
+ * \internal
+ * \brief Check if an ie_val matches an event
+ *
+ * \param event event to check against
+ * \param ie_val IE value to check
+ * \param event2 optional event, if specified, the value to compare against will be pulled
+ *        from this event instead of from the ie_val structure.  In this case, only the IE
+ *        type and payload type will be pulled from ie_val.
+ *
+ * \retval 0 not matched
+ * \retval non-zero matched
+ */
 static int match_ie_val(const struct ast_event *event,
                const struct ast_event_ie_val *ie_val, const struct ast_event *event2)
 {
@@ -488,8 +511,9 @@ static int match_ie_val(const struct ast_event *event,
        {
                uint32_t flags = event2 ? ast_event_get_ie_uint(event2, ie_val->ie_type) : ie_val->payload.uint;
 
-               /* if the subscriber has requested *any* of the bitflags that this event provides,
-                * then it's a match
+               /*
+                * If the subscriber has requested *any* of the bitflags that this event provides,
+                * then it's a match.
                 */
                return (flags & ast_event_get_ie_bitflags(event, ie_val->ie_type)) ? 1 : 0;
        }
@@ -1332,32 +1356,28 @@ static int handle_event(void *data)
 {
        struct ast_event_ref *event_ref = data;
        struct ast_event_sub *sub;
-       uint16_t host_event_type;
-
-       host_event_type = ntohs(event_ref->event->type);
+       const enum ast_event_type event_types[] = {
+               ntohs(event_ref->event->type),
+               AST_EVENT_ALL
+       };
+       int i;
 
-       /* Subscribers to this specific event first */
-       AST_RWDLLIST_RDLOCK(&ast_event_subs[host_event_type]);
-       AST_RWDLLIST_TRAVERSE(&ast_event_subs[host_event_type], sub, entry) {
-               struct ast_event_ie_val *ie_val;
-               AST_LIST_TRAVERSE(&sub->ie_vals, ie_val, entry) {
-                       if (!match_ie_val(event_ref->event, ie_val, NULL)) {
-                               break;
+       for (i = 0; i < ARRAY_LEN(event_types); i++) {
+               AST_RWDLLIST_RDLOCK(&ast_event_subs[event_types[i]]);
+               AST_RWDLLIST_TRAVERSE(&ast_event_subs[event_types[i]], sub, entry) {
+                       struct ast_event_ie_val *ie_val;
+                       AST_LIST_TRAVERSE(&sub->ie_vals, ie_val, entry) {
+                               if (!match_ie_val(event_ref->event, ie_val, NULL)) {
+                                       break;
+                               }
                        }
+                       if (ie_val) {
+                               continue;
+                       }
+                       sub->cb(event_ref->event, sub->userdata);
                }
-               if (ie_val) {
-                       continue;
-               }
-               sub->cb(event_ref->event, sub->userdata);
-       }
-       AST_RWDLLIST_UNLOCK(&ast_event_subs[host_event_type]);
-
-       /* Now to subscribers to all event types */
-       AST_RWDLLIST_RDLOCK(&ast_event_subs[AST_EVENT_ALL]);
-       AST_RWDLLIST_TRAVERSE(&ast_event_subs[AST_EVENT_ALL], sub, entry) {
-               sub->cb(event_ref->event, sub->userdata);
+               AST_RWDLLIST_UNLOCK(&ast_event_subs[event_types[i]]);
        }
-       AST_RWDLLIST_UNLOCK(&ast_event_subs[AST_EVENT_ALL]);
 
        ao2_ref(event_ref, -1);
 
index 47895b5..6a557b5 100644 (file)
  * \author Russell Bryant <russell@digium.com>
  *
  * \ingroup tests
+ *
+ * \todo API Calls not yet touched by a test: XXX TODO
+ *   - ast_event_queue_and_cache()
+ *   - ast_event_get_cached()
+ *   - ast_event_report_subs()
+ *   - ast_event_dump_cache()
+ *   - ast_event_get_ie_type_name()
+ *   - ast_event_get_ie_pltype()
+ *   - ast_event_str_to_event_type()
+ *   - ast_event_str_to_ie_type()
+ *   - ast_event_iterator_init()
+ *   - ast_event_iterator_next()
+ *   - ast_event_iterator_get_ie_type()
+ *   - ast_event_iterator_get_ie_uint()
+ *   - ast_event_iterator_get_ie_bitflags()
+ *   - ast_event_iterator_get_ie_str()
+ *   - ast_event_iterator_get_ie_raw()
  */
 
 /*** MODULEINFO
@@ -39,8 +56,8 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
 #include "asterisk/event.h"
 
 static int check_event(struct ast_event *event, struct ast_test *test,
-               enum ast_event_type expected_type, const char *str,
-               uint32_t uint)
+               enum ast_event_type expected_type, const char *type_name,
+               const char *str, uint32_t uint, uint32_t bitflags)
 {
        enum ast_event_type type;
        const void *foo;
@@ -53,32 +70,45 @@ static int check_event(struct ast_event *event, struct ast_test *test,
                return -1;
        }
 
-       /* Check #2: Check for automatically included EID */
+       /* Check #2: Check string representation of event type */
+       if (strcmp(type_name, ast_event_get_type_name(event))) {
+               ast_test_status_update(test, "Didn't get expected type name: '%s' != '%s'\n",
+                               type_name, ast_event_get_type_name(event));
+               return -1;
+       }
+
+       /* Check #3: Check for automatically included EID */
        if (memcmp(&ast_eid_default, ast_event_get_ie_raw(event, AST_EVENT_IE_EID), sizeof(ast_eid_default))) {
                ast_test_status_update(test, "Failed to get EID\n");
                return -1;
        }
 
-       /* Check #3: Check for the string IE */
+       /* Check #4: Check for the string IE */
        if (strcmp(str, ast_event_get_ie_str(event, AST_EVENT_IE_MAILBOX))) {
                ast_test_status_update(test, "Failed to get string IE.\n");
                return -1;
        }
 
-       /* Check #4: Check for the uint IE */
+       /* Check #5: Check for the uint IE */
        if (uint != ast_event_get_ie_uint(event, AST_EVENT_IE_NEWMSGS)) {
                ast_test_status_update(test, "Failed to get uint IE.\n");
                return -1;
        }
 
-       /* Check #5: Check if a check for a str IE that isn't there works */
+       /* Check #6: Check for the bitflags IE */
+       if (bitflags != ast_event_get_ie_bitflags(event, AST_EVENT_IE_OLDMSGS)) {
+               ast_test_status_update(test, "Failed to get bitflags IE.\n");
+               return -1;
+       }
+
+       /* Check #7: Check if a check for a str IE that isn't there works */
        if ((foo = ast_event_get_ie_str(event, AST_EVENT_IE_DEVICE))) {
                ast_test_status_update(test, "DEVICE IE check returned non-NULL %p\n", foo);
                return -1;
        }
 
-       /* Check #6: Check if a check for a uint IE that isn't there returns 0 */
-       if (ast_event_get_ie_uint(event, AST_EVENT_IE_OLDMSGS)) {
+       /* Check #8: Check if a check for a uint IE that isn't there returns 0 */
+       if (ast_event_get_ie_uint(event, AST_EVENT_IE_STATE)) {
                ast_test_status_update(test, "OLDMSGS IE should be 0\n");
                return -1;
        }
@@ -88,14 +118,18 @@ static int check_event(struct ast_event *event, struct ast_test *test,
        return 0;
 }
 
+/*!
+ * \internal
+ */
 AST_TEST_DEFINE(event_new_test)
 {
        enum ast_test_result_state res = AST_TEST_PASS;
-       struct ast_event *event = NULL;
+       struct ast_event *event = NULL, *event2 = NULL;
 
        static const enum ast_event_type type = AST_EVENT_CUSTOM;
        static const char str[] = "SIP/alligatormittens";
        static const uint32_t uint = 0xb00bface;
+       static const uint32_t bitflags = 0x12488421;
 
        switch (cmd) {
        case TEST_INIT:
@@ -137,56 +171,369 @@ AST_TEST_DEFINE(event_new_test)
                goto return_cleanup;
        }
 
+       if (ast_event_append_ie_bitflags(&event, AST_EVENT_IE_OLDMSGS, bitflags)) {
+               ast_test_status_update(test, "Failed to append bitflags IE\n");
+               res = AST_TEST_FAIL;
+               goto return_cleanup;
+       }
+
        if (ast_event_append_eid(&event)) {
                ast_test_status_update(test, "Failed to append EID\n");
                res = AST_TEST_FAIL;
                goto return_cleanup;
        }
 
-       if (check_event(event, test, type, str, uint)) {
+       if (check_event(event, test, type, "Custom", str, uint, bitflags)) {
                ast_test_status_update(test, "Dynamically generated event broken\n");
                res = AST_TEST_FAIL;
                goto return_cleanup;
        }
 
-       ast_event_destroy(event);
-       event = NULL;
-
-       event = ast_event_new(type,
+       event2 = ast_event_new(type,
                        AST_EVENT_IE_MAILBOX, AST_EVENT_IE_PLTYPE_STR, str,
                        AST_EVENT_IE_NEWMSGS, AST_EVENT_IE_PLTYPE_UINT, uint,
+                       AST_EVENT_IE_OLDMSGS, AST_EVENT_IE_PLTYPE_BITFLAGS, bitflags,
                        AST_EVENT_IE_END);
 
-       if (!event) {
+       if (!event2) {
                ast_test_status_update(test, "Failed to allocate ast_event object.\n");
                res = AST_TEST_FAIL;
                goto return_cleanup;
        }
 
-       if (check_event(event, test, type, str, uint)) {
+       if (check_event(event2, test, type, "Custom", str, uint, bitflags)) {
                ast_test_status_update(test, "Statically generated event broken\n");
                res = AST_TEST_FAIL;
                goto return_cleanup;
        }
 
+       if (ast_event_get_size(event) != ast_event_get_size(event2)) {
+               ast_test_status_update(test, "Events expected to be identical have different size: %d != %d\n",
+                               (int) ast_event_get_size(event),
+                               (int) ast_event_get_size(event2));
+               res = AST_TEST_FAIL;
+               goto return_cleanup;
+       }
+
 return_cleanup:
        if (event) {
                ast_event_destroy(event);
                event = NULL;
        }
 
+       if (event2) {
+               ast_event_destroy(event2);
+               event2 = NULL;
+       }
+
+       return res;
+}
+
+struct event_sub_data {
+       unsigned int count;
+};
+
+static void event_sub_cb(const struct ast_event *event, void *d)
+{
+       struct event_sub_data *data = d;
+
+       data->count++;
+}
+
+/*!
+ * \internal
+ * \brief Test event subscriptions
+ *
+ * - Query for existing Subscriptions:
+ *   - ast_event_check_subscriber()
+ */
+AST_TEST_DEFINE(event_sub_test)
+{
+       enum ast_test_result_state res = AST_TEST_PASS;
+       struct ast_event *event;
+       int i;
+       enum ast_event_subscriber_res sub_res;
+       static struct {
+               struct ast_event_sub *sub;
+               struct event_sub_data data;
+               const unsigned int expected_count;
+       } test_subs[] = {
+               [0] = {
+                       .expected_count = 3,
+               },
+               [1] = {
+                       .expected_count = 1,
+               },
+               [2] = {
+                       .expected_count = 2,
+               },
+       };
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "ast_event_subscribe_test";
+               info->category = "main/event/";
+               info->summary = "Test event subscriptions";
+               info->description =
+                       "This test exercises the API calls that allow subscriptions "
+                       "to events.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /*
+        * Subscription #1:
+        *  - allocate normally
+        *  - subscribe to all CUSTOM events
+        *
+        * Subscription #2:
+        *  - allocate dynamically
+        *  - subscribe to all CUSTOM events
+        *  - add payload checks
+        *
+        * Subscription #3:
+        *  - allocate normally
+        *  - subscribe to all events with an IE check
+        */
+
+       test_subs[0].sub = ast_event_subscribe(AST_EVENT_CUSTOM, event_sub_cb, "test_sub", &test_subs[0].data,
+                       AST_EVENT_IE_END);
+       if (!test_subs[0].sub) {
+               ast_test_status_update(test, "Failed to create test_subs[0].sub\n");
+               res = AST_TEST_FAIL;
+               goto return_cleanup;
+       }
+
+       if (strcmp(ast_event_subscriber_get_description(test_subs[0].sub), "test_sub")) {
+               ast_test_status_update(test,
+                               "Unexpected subscription description on test_subs[0].sub\n");
+               res = AST_TEST_FAIL;
+               goto return_cleanup;
+       }
+
+       test_subs[1].sub = ast_event_subscribe_new(AST_EVENT_CUSTOM, event_sub_cb, &test_subs[1].data);
+       if (!test_subs[1].sub) {
+               ast_test_status_update(test, "Failed to create test_subs[1].sub\n");
+               res = AST_TEST_FAIL;
+               goto return_cleanup;
+       }
+
+       /* For the sake of exercising destruction before activation */
+       ast_event_sub_destroy(test_subs[1].sub);
+
+       test_subs[1].sub = ast_event_subscribe_new(AST_EVENT_CUSTOM, event_sub_cb, &test_subs[1].data);
+       if (!test_subs[1].sub) {
+               ast_test_status_update(test, "Failed to create test_subs[1].sub\n");
+               res = AST_TEST_FAIL;
+               goto return_cleanup;
+       }
+
+       if (strcmp(ast_event_subscriber_get_description(test_subs[1].sub), "")) {
+               ast_event_sub_destroy(test_subs[1].sub);
+               test_subs[1].sub = NULL;
+               ast_test_status_update(test,
+                               "Unexpected subscription description on test_subs[1].sub\n");
+               res = AST_TEST_FAIL;
+               goto return_cleanup;
+       }
+
+       if (ast_event_sub_append_ie_uint(test_subs[1].sub, AST_EVENT_IE_NEWMSGS, 3)) {
+               ast_event_sub_destroy(test_subs[1].sub);
+               test_subs[1].sub = NULL;
+               ast_test_status_update(test, "Failed to append uint IE to test_subs[1].sub\n");
+               res = AST_TEST_FAIL;
+               goto return_cleanup;
+       }
+
+       if (ast_event_sub_append_ie_bitflags(test_subs[1].sub, AST_EVENT_IE_NEWMSGS, 1)) {
+               ast_event_sub_destroy(test_subs[1].sub);
+               test_subs[1].sub = NULL;
+               ast_test_status_update(test, "Failed to append bitflags IE to test_subs[1].sub\n");
+               res = AST_TEST_FAIL;
+               goto return_cleanup;
+       }
+
+       if (ast_event_sub_append_ie_str(test_subs[1].sub, AST_EVENT_IE_DEVICE, "FOO/bar")) {
+               ast_event_sub_destroy(test_subs[1].sub);
+               test_subs[1].sub = NULL;
+               ast_test_status_update(test, "Failed to append str IE to test_subs[1].sub\n");
+               res = AST_TEST_FAIL;
+               goto return_cleanup;
+       }
+
+       if (ast_event_sub_append_ie_raw(test_subs[1].sub, AST_EVENT_IE_MAILBOX, "800 km",
+                       strlen("800 km"))) {
+               ast_event_sub_destroy(test_subs[1].sub);
+               test_subs[1].sub = NULL;
+               ast_test_status_update(test, "Failed to append raw IE to test_subs[1].sub\n");
+               res = AST_TEST_FAIL;
+               goto return_cleanup;
+       }
+
+       if (ast_event_sub_append_ie_exists(test_subs[1].sub, AST_EVENT_IE_DEVICE)) {
+               ast_event_sub_destroy(test_subs[1].sub);
+               test_subs[1].sub = NULL;
+               ast_test_status_update(test, "Failed to append exists IE to test_subs[1].sub\n");
+               res = AST_TEST_FAIL;
+               goto return_cleanup;
+       }
+
+       if (ast_event_sub_activate(test_subs[1].sub)) {
+               ast_event_sub_destroy(test_subs[1].sub);
+               test_subs[1].sub = NULL;
+               ast_test_status_update(test, "Failed to activate test_subs[1].sub\n");
+               res = AST_TEST_FAIL;
+               goto return_cleanup;
+       }
+
+       test_subs[2].sub = ast_event_subscribe(AST_EVENT_ALL, event_sub_cb, "test_sub", &test_subs[2].data,
+                       AST_EVENT_IE_DEVICE, AST_EVENT_IE_PLTYPE_STR, "FOO/bar",
+                       AST_EVENT_IE_END);
+       if (!test_subs[2].sub) {
+               ast_test_status_update(test, "Failed to create test_subs[2].sub\n");
+               res = AST_TEST_FAIL;
+               goto return_cleanup;
+       }
+
+       /*
+        * Exercise the API call to check for existing subscriptions.
+        */
+
+       sub_res = ast_event_check_subscriber(AST_EVENT_CUSTOM,
+                       AST_EVENT_IE_DEVICE, AST_EVENT_IE_PLTYPE_STR, "FOO/bar",
+                       AST_EVENT_IE_END);
+       if (sub_res != AST_EVENT_SUB_EXISTS) {
+               ast_test_status_update(test, "subscription did not exist\n");
+               res = AST_TEST_FAIL;
+               goto return_cleanup;
+       }
+
+       sub_res = ast_event_check_subscriber(AST_EVENT_CUSTOM,
+                       AST_EVENT_IE_DEVICE, AST_EVENT_IE_PLTYPE_STR, "BOOBS",
+                       AST_EVENT_IE_END);
+       if (sub_res != AST_EVENT_SUB_NONE) {
+               ast_test_status_update(test, "Someone subscribed to updates on boobs, lol? (%d)\n", sub_res);
+               res = AST_TEST_FAIL;
+               goto return_cleanup;
+       }
+
+       /*
+        * Fire off some events and track what was received in the callback
+        *
+        * event #1:
+        *  - simple custom event (will match sub 1 and 3)
+        *
+        * event #2:
+        *  - custom event with payloads that satisfy every payload check
+        *    for sub #2 (will match sub 1, 2, and 3)
+        *
+        * event #3:
+        *  - custom event that should only match sub #1
+        */
+
+       event = ast_event_new(AST_EVENT_CUSTOM,
+                       AST_EVENT_IE_DEVICE, AST_EVENT_IE_PLTYPE_STR, "FOO/bar",
+                       AST_EVENT_IE_END);
+       if (!event) {
+               ast_test_status_update(test, "Failed to create event\n");
+               res = AST_TEST_FAIL;
+               goto return_cleanup;
+       }
+       if (ast_event_queue(event)) {
+               ast_event_destroy(event);
+               event = NULL;
+               ast_test_status_update(test, "Failed to queue event\n");
+               res = AST_TEST_FAIL;
+               goto return_cleanup;
+       }
+
+       event = ast_event_new(AST_EVENT_CUSTOM,
+                       AST_EVENT_IE_DEVICE, AST_EVENT_IE_PLTYPE_STR, "FOO/bar",
+                       AST_EVENT_IE_MAILBOX, AST_EVENT_IE_PLTYPE_RAW, "800 km", strlen("800 km"),
+                       AST_EVENT_IE_NEWMSGS, AST_EVENT_IE_PLTYPE_UINT, 3,
+                       AST_EVENT_IE_END);
+       if (!event) {
+               ast_test_status_update(test, "Failed to create event\n");
+               res = AST_TEST_FAIL;
+               goto return_cleanup;
+       }
+       if (ast_event_queue(event)) {
+               ast_event_destroy(event);
+               event = NULL;
+               ast_test_status_update(test, "Failed to queue event\n");
+               res = AST_TEST_FAIL;
+               goto return_cleanup;
+       }
+
+       event = ast_event_new(AST_EVENT_CUSTOM,
+                       AST_EVENT_IE_DEVICE, AST_EVENT_IE_PLTYPE_STR, "blah",
+                       AST_EVENT_IE_MAILBOX, AST_EVENT_IE_PLTYPE_RAW, "801 km", strlen("801 km"),
+                       AST_EVENT_IE_NEWMSGS, AST_EVENT_IE_PLTYPE_UINT, 0,
+                       AST_EVENT_IE_END);
+       if (!event) {
+               ast_test_status_update(test, "Failed to create event\n");
+               res = AST_TEST_FAIL;
+               goto return_cleanup;
+       }
+       if (ast_event_queue(event)) {
+               ast_event_destroy(event);
+               event = NULL;
+               ast_test_status_update(test, "Failed to queue event\n");
+               res = AST_TEST_FAIL;
+               goto return_cleanup;
+       }
+       event = NULL;
+
+       /*
+        * Check the results of the test.
+        *
+        * First of all, event distribution is asynchronous from the event producer,
+        * so knowing when to continue from here and check results is an instance of
+        * the halting problem.  A few seconds really should be more than enough time.
+        * If something was actually blocking event distribution that long, I would call
+        * it a bug.
+        *
+        * Expected results:
+        *  - sub 1, 2 events
+        *  - sub 2, 1 event
+        *  - sub 3, 2 events
+        */
+
+       ast_test_status_update(test, "Sleeping a few seconds to allow event propagation...\n");
+       sleep(3);
+
+       for (i = 0; i < ARRAY_LEN(test_subs); i++) {
+               if (test_subs[i].data.count != test_subs[i].expected_count) {
+                       ast_test_status_update(test, "Unexpected callback count, %u != %u for #%d\n",
+                                       test_subs[i].data.count, test_subs[i].expected_count, i);
+                       res = AST_TEST_FAIL;
+               }
+       }
+
+return_cleanup:
+       for (i = 0; i < ARRAY_LEN(test_subs); i++) {
+               if (test_subs[i].sub) {
+                       test_subs[i].sub = ast_event_unsubscribe(test_subs[i].sub);
+               }
+       }
+
        return res;
 }
 
 static int unload_module(void)
 {
        AST_TEST_UNREGISTER(event_new_test);
+       AST_TEST_UNREGISTER(event_sub_test);
+
        return 0;
 }
 
 static int load_module(void)
 {
        AST_TEST_REGISTER(event_new_test);
+       AST_TEST_REGISTER(event_sub_test);
+
        return AST_MODULE_LOAD_SUCCESS;
 }