tests/lib/test_trace_listener.c

   1 /*
   2  * test_trace_lister.c
   3  *
   4  * CTF IR trace listener interface test
   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"
  23 #include <babeltrace/ctf-ir/event-class.h>
  24 #include <babeltrace/ctf-ir/field-types.h>
  25 #include <babeltrace/ctf-ir/stream-class.h>
  26 #include <babeltrace/ctf-ir/trace.h>
  27 #include <babeltrace/ctf-ir/trace-internal.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30
  31 #define NR_TESTS 21
  32
  33 struct visitor_state {
  34         int i;
  35 };
  36
  37 struct expected_result {
  38         const char *object_name;
  39         enum bt_ctf_object_type object_type;
  40 };
  41
  42 struct expected_result expected_results[] = {
  43         { NULL, BT_CTF_OBJECT_TYPE_TRACE },
  44         { "sc1", BT_CTF_OBJECT_TYPE_STREAM_CLASS },
  45         { "ec1", BT_CTF_OBJECT_TYPE_EVENT_CLASS },
  46         { "sc2", BT_CTF_OBJECT_TYPE_STREAM_CLASS },
  47         { "ec2", BT_CTF_OBJECT_TYPE_EVENT_CLASS },
  48         { "ec3", BT_CTF_OBJECT_TYPE_EVENT_CLASS },
  49         /* Elements added after the initial add_listener call. */
  50         { "sc3", BT_CTF_OBJECT_TYPE_STREAM_CLASS },
  51         { "ec4", BT_CTF_OBJECT_TYPE_EVENT_CLASS },
  52         { "ec5", BT_CTF_OBJECT_TYPE_EVENT_CLASS },
  53 };
  54
  55 const char *object_type_str(enum bt_ctf_object_type type)
  56 {
  57         switch (type) {
  58         case BT_CTF_OBJECT_TYPE_TRACE:
  59                 return "trace";
  60         case BT_CTF_OBJECT_TYPE_STREAM_CLASS:
  61                 return "stream class";
  62         case BT_CTF_OBJECT_TYPE_STREAM:
  63                 return "stream";
  64         case BT_CTF_OBJECT_TYPE_EVENT_CLASS:
  65                 return "event class";
  66         case BT_CTF_OBJECT_TYPE_EVENT:
  67                 return "event";
  68         default:
  69                 return "unknown";
  70         }
  71 }
  72
  73 struct bt_ctf_event_class *init_event_class(const char *name)
  74 {
  75         int ret;
  76         struct bt_ctf_event_class *ec = bt_ctf_event_class_create(name);
  77         struct bt_ctf_field_type *int_field =
  78                         bt_ctf_field_type_integer_create(8);
  79
  80         if (!ec || !int_field) {
  81                 goto error;
  82         }
  83
  84         ret = bt_ctf_event_class_add_field(ec, int_field, "an_int_field");
  85         if (ret) {
  86                 goto error;
  87         }
  88
  89         BT_PUT(int_field);
  90         return ec;
  91 error:
  92         BT_PUT(ec);
  93         BT_PUT(int_field);
  94         return NULL;
  95 }
  96
  97 struct bt_ctf_trace *init_trace(void)
  98 {
  99         int ret;
 100         struct bt_ctf_trace *trace = bt_ctf_trace_create();
 101         struct bt_ctf_stream_class *sc1 = bt_ctf_stream_class_create("sc1");
 102         struct bt_ctf_stream_class *sc2 = bt_ctf_stream_class_create("sc2");
 103         struct bt_ctf_event_class *ec1 = init_event_class("ec1");
 104         struct bt_ctf_event_class *ec2 = init_event_class("ec2");
 105         struct bt_ctf_event_class *ec3 = init_event_class("ec3");
 106
 107         if (!trace || !sc1 || !sc2 || !ec1 || !ec2 || !ec3) {
 108                 goto end;
 109         }
 110
 111         ret = bt_ctf_trace_set_native_byte_order(trace,
 112                 BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
 113         if (ret) {
 114                 goto error;
 115         }
 116
 117         ret = bt_ctf_stream_class_add_event_class(sc1, ec1);
 118         if (ret) {
 119                 goto error;
 120         }
 121
 122         ret = bt_ctf_stream_class_add_event_class(sc2, ec2);
 123         if (ret) {
 124                 goto error;
 125         }
 126
 127         ret = bt_ctf_stream_class_add_event_class(sc2, ec3);
 128         if (ret) {
 129                 goto error;
 130         }
 131
 132         ret = bt_ctf_trace_add_stream_class(trace, sc1);
 133         if (ret) {
 134                 goto error;
 135         }
 136
 137         ret = bt_ctf_trace_add_stream_class(trace, sc2);
 138         if (ret) {
 139                 goto error;
 140         }
 141 end:
 142         BT_PUT(sc1);
 143         BT_PUT(sc2);
 144         BT_PUT(ec1);
 145         BT_PUT(ec2);
 146         BT_PUT(ec3);
 147         return trace;
 148 error:
 149         BT_PUT(trace);
 150         goto end;
 151 }
 152
 153 void visitor(struct bt_ctf_object *object, void *data)
 154 {
 155         bool names_match;
 156         const char *object_name;
 157         struct visitor_state *state = data;
 158         struct expected_result *expected = &expected_results[state->i++];
 159
 160         switch (bt_ctf_object_get_type(object)) {
 161         case BT_CTF_OBJECT_TYPE_TRACE:
 162                 object_name = NULL;
 163                 names_match = expected->object_name == NULL;
 164                 break;
 165         case BT_CTF_OBJECT_TYPE_STREAM_CLASS:
 166                 object_name = bt_ctf_stream_class_get_name(
 167                                 bt_ctf_object_get_object(object));
 168                 if (!object_name) {
 169                         return;
 170                 }
 171
 172                 names_match = !strcmp(object_name, expected->object_name);
 173                 break;
 174         case BT_CTF_OBJECT_TYPE_EVENT_CLASS:
 175                 object_name = bt_ctf_event_class_get_name(
 176                                 bt_ctf_object_get_object(object));
 177                 if (!object_name) {
 178                         return;
 179                 }
 180
 181                 names_match = !strcmp(object_name, expected->object_name);
 182                 break;
 183         default:
 184                 diag("Encountered an unexpected type while visiting trace");
 185                 return;
 186         }
 187
 188         ok(expected->object_type == bt_ctf_object_get_type(object),
 189                         "Encoutered object type %s, expected %s",
 190                         object_type_str(expected->object_type),
 191                         object_type_str(bt_ctf_object_get_type(object)));
 192         ok(names_match, "Element name is %s, expected %s",
 193                         object_name ? : "NULL",
 194                         expected->object_name ? : "NULL");
 195 }
 196
 197 int main(int argc, char **argv)
 198 {
 199         int ret, index;
 200         struct bt_ctf_trace *trace;
 201         struct visitor_state state = { 0 };
 202         struct bt_ctf_stream_class *sc3;
 203         struct bt_ctf_event_class *ec4, *ec5;
 204
 205         plan_tests(NR_TESTS);
 206
 207         trace = init_trace();
 208         if (!trace) {
 209                 diag("Failed to initialize reference trace, aborting.");
 210                 exit(-1);
 211         }
 212
 213         ret = bt_ctf_trace_add_listener(trace, visitor, &state);
 214         ok(!ret, "bt_ctf_trace_add_listener returned success");
 215
 216         /*
 217          * Validate that listeners are notified when new objects are added to a
 218          * trace.
 219          */
 220         sc3 = bt_ctf_stream_class_create("sc3");
 221         if (!sc3) {
 222                 diag("Failed to create stream class, aborting.");
 223                 exit(-1);
 224         }
 225
 226         ec4 = init_event_class("ec4");
 227         ec5 = init_event_class("ec5");
 228         if (!ec4 || !ec5) {
 229                 diag("Failed to create event classes, aborting.");
 230                 exit(-1);
 231         }
 232
 233         ret = bt_ctf_stream_class_add_event_class(sc3, ec4);
 234         if (ret) {
 235                 diag("Failed to add event class to stream class, aborting.");
 236         }
 237
 238         index = state.i;
 239         ret = bt_ctf_trace_add_stream_class(trace, sc3);
 240         if (ret) {
 241                 diag("Failed to add stream class sc3 to trace, aborting.");
 242                 exit(-1);
 243         }
 244
 245         /* Listener should have been invoked two times (sc3 + ec4). */
 246         ok(index + 2 == state.i, "trace modification listener has been invoked twice after addition of a stream class");
 247
 248         index = state.i;
 249         ret = bt_ctf_stream_class_add_event_class(sc3, ec5);
 250         if (ret) {
 251                 diag("Failed to add event class to stream class, aborting.");
 252                 exit(-1);
 253         }
 254
 255         ok(index + 1 == state.i, "trace modification has been invoked once after addition of an event class");
 256
 257         BT_PUT(sc3);
 258         BT_PUT(ec5);
 259         BT_PUT(ec4);
 260         BT_PUT(trace);
 261         return exit_status();
 262 }
 263