tests/lib/test_simple_sink.c

   1 /*
   2  * Copyright (c) 2019 Philippe Proulx <pproulx@efficios.com>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; under version 2 of the License.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along
  14  * with this program; if not, write to the Free Software Foundation, Inc.,
  15  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  16  */
  17
  18 #include <babeltrace2/babeltrace.h>
  19 #include "common/assert.h"
  20 #include <string.h>
  21 #include "tap/tap.h"
  22
  23 #define NR_TESTS 68
  24
  25 struct test_data {
  26         bt_graph_simple_sink_component_initialize_func_status init_status;
  27         bt_graph_simple_sink_component_consume_func_status consume_status;
  28 };
  29
  30 static
  31 bt_graph_simple_sink_component_initialize_func_status simple_INITIALIZE_func(
  32                 bt_self_component_port_input_message_iterator *iterator,
  33                 void *data)
  34 {
  35         struct test_data *test_data = data;
  36
  37         ok(iterator, "Message iterator is not NULL in initialization function");
  38         ok(data, "Data is not NULL in initialization function");
  39         return test_data->init_status;
  40 }
  41
  42 static
  43 bt_graph_simple_sink_component_consume_func_status simple_consume_func(
  44                 bt_self_component_port_input_message_iterator *iterator,
  45                 void *data)
  46 {
  47         struct test_data *test_data = data;
  48
  49         ok(iterator, "Message iterator is not NULL in consume function");
  50         ok(data, "Data is not NULL in consume function");
  51         return test_data->consume_status;
  52 }
  53
  54 static
  55 void simple_fini_func(void *data)
  56 {
  57         ok(data, "Data is not NULL in finalization function");
  58 }
  59
  60 static
  61 bt_component_class_initialize_method_status src_init(
  62                 bt_self_component_source *self_comp,
  63                 bt_self_component_source_configuration *config,
  64                 const bt_value *params, void *init_method_data)
  65 {
  66         bt_self_component_add_port_status status;
  67
  68         status = bt_self_component_source_add_output_port(self_comp,
  69                 "out", NULL, NULL);
  70         BT_ASSERT(status == BT_SELF_COMPONENT_ADD_PORT_STATUS_OK);
  71         return BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK;
  72 }
  73
  74 static
  75 bt_message_iterator_class_next_method_status src_iter_next(
  76                 bt_self_message_iterator *message_iterator,
  77                 bt_message_array_const msgs, uint64_t capacity,
  78                 uint64_t *count)
  79 {
  80         return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_END;
  81 }
  82
  83 static
  84 bt_graph *create_graph_with_source(const bt_port_output **out_port)
  85 {
  86         bt_message_iterator_class *msg_iter_cls;
  87         bt_component_class_source *src_comp_cls;
  88         bt_graph *graph;
  89         const bt_component_source *src_comp = NULL;
  90         bt_graph_add_component_status add_comp_status;
  91         bt_component_class_set_method_status set_method_status;
  92
  93         BT_ASSERT(out_port);
  94
  95         msg_iter_cls = bt_message_iterator_class_create(src_iter_next);
  96         BT_ASSERT(msg_iter_cls);
  97
  98         src_comp_cls = bt_component_class_source_create("src", msg_iter_cls);
  99         BT_ASSERT(src_comp_cls);
 100         set_method_status = bt_component_class_source_set_initialize_method(
 101                 src_comp_cls, src_init);
 102         BT_ASSERT(set_method_status == BT_COMPONENT_CLASS_SET_METHOD_STATUS_OK);
 103         graph = bt_graph_create(0);
 104         BT_ASSERT(graph);
 105         add_comp_status = bt_graph_add_source_component(graph, src_comp_cls,
 106                 "src", NULL, BT_LOGGING_LEVEL_NONE, &src_comp);
 107         BT_ASSERT(add_comp_status == BT_GRAPH_ADD_COMPONENT_STATUS_OK);
 108         BT_ASSERT(src_comp);
 109         *out_port = bt_component_source_borrow_output_port_by_index_const(
 110                 src_comp, 0);
 111         BT_ASSERT(*out_port);
 112         bt_component_source_put_ref(src_comp);
 113         bt_component_class_source_put_ref(src_comp_cls);
 114         bt_message_iterator_class_put_ref(msg_iter_cls);
 115         return graph;
 116 }
 117
 118 static
 119 void test_simple_expect_run_once_status(
 120                 bt_graph_simple_sink_component_initialize_func_status init_status,
 121                 bt_graph_simple_sink_component_consume_func_status consume_status,
 122                 bt_graph_run_once_status exp_run_once_status)
 123 {
 124         const bt_port_output *src_out_port = NULL;
 125         bt_graph *graph;
 126         const bt_component_sink *sink_comp = NULL;
 127         const bt_port_input *sink_in_port;
 128         bt_graph_add_component_status add_comp_status;
 129         bt_graph_run_once_status run_once_status;
 130         bt_graph_connect_ports_status connect_status;
 131         struct test_data test_data = {
 132                 .init_status = init_status,
 133                 .consume_status = consume_status,
 134         };
 135         const struct bt_error *err;
 136
 137         graph = create_graph_with_source(&src_out_port);
 138         BT_ASSERT(graph);
 139         BT_ASSERT(src_out_port);
 140
 141         add_comp_status = bt_graph_add_simple_sink_component(graph, "sink",
 142                 simple_INITIALIZE_func, simple_consume_func, simple_fini_func,
 143                 &test_data, &sink_comp);
 144         BT_ASSERT(add_comp_status == BT_GRAPH_ADD_COMPONENT_STATUS_OK);
 145         BT_ASSERT(sink_comp);
 146
 147         sink_in_port = bt_component_sink_borrow_input_port_by_name_const(
 148                 sink_comp, "in");
 149         ok(sink_in_port,
 150                 "Simple sink component has an input port named \"in\"");
 151
 152         connect_status = bt_graph_connect_ports(graph, src_out_port,
 153                 sink_in_port, NULL);
 154         ok(connect_status == BT_GRAPH_CONNECT_PORTS_STATUS_OK,
 155                 "Simple sink component's \"in\" port is connectable");
 156
 157         run_once_status = bt_graph_run_once(graph);
 158         ok(run_once_status == exp_run_once_status,
 159                 "Graph \"run once\" status is the expected one (status code: %d)",
 160                 run_once_status);
 161
 162         err = bt_current_thread_take_error();
 163         ok((run_once_status < 0) == (err != NULL),
 164                 "Current thread error is set if bt_graph_run_once returned an error");
 165
 166         bt_component_sink_put_ref(sink_comp);
 167         bt_graph_put_ref(graph);
 168         if (err) {
 169                 bt_error_release(err);
 170         }
 171 }
 172
 173 int main(void)
 174 {
 175         plan_tests(NR_TESTS);
 176
 177         /* Test initialization function status */
 178         test_simple_expect_run_once_status(
 179                 BT_GRAPH_SIMPLE_SINK_COMPONENT_INITIALIZE_FUNC_STATUS_OK,
 180                 BT_GRAPH_SIMPLE_SINK_COMPONENT_CONSUME_FUNC_STATUS_OK,
 181                 BT_GRAPH_RUN_ONCE_STATUS_OK);
 182         test_simple_expect_run_once_status(
 183                 BT_GRAPH_SIMPLE_SINK_COMPONENT_INITIALIZE_FUNC_STATUS_ERROR,
 184                 BT_GRAPH_SIMPLE_SINK_COMPONENT_CONSUME_FUNC_STATUS_OK,
 185                 BT_GRAPH_RUN_ONCE_STATUS_ERROR);
 186         test_simple_expect_run_once_status(
 187                 BT_GRAPH_SIMPLE_SINK_COMPONENT_INITIALIZE_FUNC_STATUS_MEMORY_ERROR,
 188                 BT_GRAPH_SIMPLE_SINK_COMPONENT_CONSUME_FUNC_STATUS_OK,
 189                 BT_GRAPH_RUN_ONCE_STATUS_MEMORY_ERROR);
 190
 191         /* Test "consume" function status */
 192         test_simple_expect_run_once_status(
 193                 BT_GRAPH_SIMPLE_SINK_COMPONENT_INITIALIZE_FUNC_STATUS_OK,
 194                 BT_GRAPH_SIMPLE_SINK_COMPONENT_CONSUME_FUNC_STATUS_OK,
 195                 BT_GRAPH_RUN_ONCE_STATUS_OK);
 196         test_simple_expect_run_once_status(
 197                 BT_GRAPH_SIMPLE_SINK_COMPONENT_INITIALIZE_FUNC_STATUS_OK,
 198                 BT_GRAPH_SIMPLE_SINK_COMPONENT_CONSUME_FUNC_STATUS_ERROR,
 199                 BT_GRAPH_RUN_ONCE_STATUS_ERROR);
 200         test_simple_expect_run_once_status(
 201                 BT_GRAPH_SIMPLE_SINK_COMPONENT_INITIALIZE_FUNC_STATUS_OK,
 202                 BT_GRAPH_SIMPLE_SINK_COMPONENT_CONSUME_FUNC_STATUS_MEMORY_ERROR,
 203                 BT_GRAPH_RUN_ONCE_STATUS_MEMORY_ERROR);
 204         test_simple_expect_run_once_status(
 205                 BT_GRAPH_SIMPLE_SINK_COMPONENT_INITIALIZE_FUNC_STATUS_OK,
 206                 BT_GRAPH_SIMPLE_SINK_COMPONENT_CONSUME_FUNC_STATUS_AGAIN,
 207                 BT_GRAPH_RUN_ONCE_STATUS_AGAIN);
 208         test_simple_expect_run_once_status(
 209                 BT_GRAPH_SIMPLE_SINK_COMPONENT_INITIALIZE_FUNC_STATUS_OK,
 210                 BT_GRAPH_SIMPLE_SINK_COMPONENT_CONSUME_FUNC_STATUS_END,
 211                 BT_GRAPH_RUN_ONCE_STATUS_END);
 212
 213         return exit_status();
 214 }