tests/lib/test_ir_visit.c

   1 /*
   2  * test_ir_visit.c
   3  *
   4  * CTF IR visitor 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/visitor.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <assert.h>
  31
  32 #define NR_TESTS 13
  33
  34 struct visitor_state {
  35         int i;
  36 };
  37
  38 struct expected_result {
  39         const char *object_name;
  40         enum bt_ctf_object_type object_type;
  41 };
  42
  43 struct expected_result expected_results[] = {
  44         { NULL, BT_CTF_OBJECT_TYPE_TRACE },
  45         { "sc1", BT_CTF_OBJECT_TYPE_STREAM_CLASS },
  46         { "ec1", BT_CTF_OBJECT_TYPE_EVENT_CLASS },
  47         { "sc2", BT_CTF_OBJECT_TYPE_STREAM_CLASS },
  48         { "ec2", BT_CTF_OBJECT_TYPE_EVENT_CLASS },
  49         { "ec3", BT_CTF_OBJECT_TYPE_EVENT_CLASS },
  50 };
  51
  52 const char *object_type_str(enum bt_ctf_object_type type)
  53 {
  54         switch (type) {
  55         case BT_CTF_OBJECT_TYPE_TRACE:
  56                 return "trace";
  57         case BT_CTF_OBJECT_TYPE_STREAM_CLASS:
  58                 return "stream class";
  59         case BT_CTF_OBJECT_TYPE_STREAM:
  60                 return "stream";
  61         case BT_CTF_OBJECT_TYPE_EVENT_CLASS:
  62                 return "event class";
  63         case BT_CTF_OBJECT_TYPE_EVENT:
  64                 return "event";
  65         default:
  66                 return "unknown";
  67         }
  68 }
  69
  70 struct bt_ctf_event_class *init_event_class(const char *name)
  71 {
  72         int ret;
  73         struct bt_ctf_event_class *ec = bt_ctf_event_class_create(name);
  74         struct bt_ctf_field_type *int_field =
  75                         bt_ctf_field_type_integer_create(8);
  76
  77         if (!ec || !int_field) {
  78                 goto error;
  79         }
  80
  81         ret = bt_ctf_event_class_add_field(ec, int_field, "an_int_field");
  82         if (ret) {
  83                 goto error;
  84         }
  85
  86         BT_PUT(int_field);
  87         return ec;
  88 error:
  89         BT_PUT(ec);
  90         BT_PUT(int_field);
  91         return NULL;
  92 }
  93
  94 struct bt_ctf_trace *init_trace(void)
  95 {
  96         int ret;
  97         struct bt_ctf_trace *trace = bt_ctf_trace_create();
  98         struct bt_ctf_stream_class *sc1 = bt_ctf_stream_class_create("sc1");
  99         struct bt_ctf_stream_class *sc2 = bt_ctf_stream_class_create("sc2");
 100         struct bt_ctf_event_class *ec1 = init_event_class("ec1");
 101         struct bt_ctf_event_class *ec2 = init_event_class("ec2");
 102         struct bt_ctf_event_class *ec3 = init_event_class("ec3");
 103
 104         if (!trace || !sc1 || !sc2 || !ec1 || !ec2 || !ec3) {
 105                 goto end;
 106         }
 107
 108         ret = bt_ctf_trace_set_native_byte_order(trace,
 109                 BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
 110         assert(ret == 0);
 111         ret = bt_ctf_stream_class_add_event_class(sc1, ec1);
 112         if (ret) {
 113                 goto error;
 114         }
 115
 116         ret = bt_ctf_stream_class_add_event_class(sc2, ec2);
 117         if (ret) {
 118                 goto error;
 119         }
 120
 121         ret = bt_ctf_stream_class_add_event_class(sc2, ec3);
 122         if (ret) {
 123                 goto error;
 124         }
 125
 126         ret = bt_ctf_trace_add_stream_class(trace, sc1);
 127         if (ret) {
 128                 goto error;
 129         }
 130
 131         ret = bt_ctf_trace_add_stream_class(trace, sc2);
 132         if (ret) {
 133                 goto error;
 134         }
 135 end:
 136         BT_PUT(sc1);
 137         BT_PUT(sc2);
 138         BT_PUT(ec1);
 139         BT_PUT(ec2);
 140         BT_PUT(ec3);
 141         return trace;
 142 error:
 143         BT_PUT(trace);
 144         goto end;
 145 }
 146
 147 int visitor(struct bt_ctf_object *object, void *data)
 148 {
 149         int ret = 0;
 150         bool names_match;
 151         const char *object_name;
 152         struct visitor_state *state = data;
 153         struct expected_result *expected = &expected_results[state->i++];
 154
 155         switch (bt_ctf_object_get_type(object)) {
 156         case BT_CTF_OBJECT_TYPE_TRACE:
 157                 object_name = NULL;
 158                 names_match = expected->object_name == NULL;
 159                 break;
 160         case BT_CTF_OBJECT_TYPE_STREAM_CLASS:
 161                 object_name = bt_ctf_stream_class_get_name(
 162                                 bt_ctf_object_get_object(object));
 163                 if (!object_name) {
 164                         ret = -1;
 165                         goto end;
 166                 }
 167
 168                 names_match = !strcmp(object_name, expected->object_name);
 169                 break;
 170         case BT_CTF_OBJECT_TYPE_EVENT_CLASS:
 171                 object_name = bt_ctf_event_class_get_name(
 172                                 bt_ctf_object_get_object(object));
 173                 if (!object_name) {
 174                         ret = -1;
 175                         goto end;
 176                 }
 177
 178                 names_match = !strcmp(object_name, expected->object_name);
 179                 break;
 180         default:
 181                 diag("Encountered an unexpected type while visiting trace");
 182                 ret = -1;
 183                 goto end;
 184         }
 185
 186         ok(expected->object_type == bt_ctf_object_get_type(object),
 187                         "Encoutered object type %s, expected %s",
 188                         object_type_str(expected->object_type),
 189                         object_type_str(bt_ctf_object_get_type(object)));
 190         ok(names_match, "Element name is %s, expected %s",
 191                         object_name ? : "NULL",
 192                         expected->object_name ? : "NULL");
 193 end:
 194         return ret;
 195 }
 196
 197 int main(int argc, char **argv)
 198 {
 199         int ret;
 200         struct bt_ctf_trace *trace;
 201         struct visitor_state state = { 0 };
 202
 203         plan_tests(NR_TESTS);
 204
 205         /*
 206          * Initialize a reference trace which we'll walk using the
 207          * bt_ctf_*_visit() interface.
 208          */
 209         trace = init_trace();
 210         if (!trace) {
 211                 diag("Failed to initialize reference trace, aborting.");
 212                 exit(-1);
 213         }
 214
 215         ret = bt_ctf_trace_visit(trace, visitor, &state);
 216         ok(!ret, "bt_ctf_trace_visit returned success");
 217
 218         BT_PUT(trace);
 219         return exit_status();
 220 }
 221