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_component_class_message_iterator_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_COMPONENT_CLASS_MESSAGE_ITERATOR_NEXT_METHOD_STATUS_END;
  81 }
  82
  83 static
  84 bt_graph *create_graph_with_source(const bt_port_output **out_port)
  85 {
  86         bt_component_class_source *src_comp_cls;
  87         bt_graph *graph;
  88         const bt_component_source *src_comp = NULL;
  89         bt_graph_add_component_status add_comp_status;
  90         bt_component_class_set_method_status set_method_status;
  91
  92         BT_ASSERT(out_port);
  93         src_comp_cls = bt_component_class_source_create("src", src_iter_next);
  94         BT_ASSERT(src_comp_cls);
  95         set_method_status = bt_component_class_source_set_initialize_method(
  96                 src_comp_cls, src_init);
  97         BT_ASSERT(set_method_status == BT_COMPONENT_CLASS_SET_METHOD_STATUS_OK);
  98         graph = bt_graph_create(0);
  99         BT_ASSERT(graph);
 100         add_comp_status = bt_graph_add_source_component(graph, src_comp_cls,
 101                 "src", NULL, BT_LOGGING_LEVEL_NONE, &src_comp);
 102         BT_ASSERT(add_comp_status == BT_GRAPH_ADD_COMPONENT_STATUS_OK);
 103         BT_ASSERT(src_comp);
 104         *out_port = bt_component_source_borrow_output_port_by_index_const(
 105                 src_comp, 0);
 106         BT_ASSERT(*out_port);
 107         bt_component_source_put_ref(src_comp);
 108         bt_component_class_source_put_ref(src_comp_cls);
 109         return graph;
 110 }
 111
 112 static
 113 void test_simple_expect_run_once_status(
 114                 bt_graph_simple_sink_component_initialize_func_status init_status,
 115                 bt_graph_simple_sink_component_consume_func_status consume_status,
 116                 bt_graph_run_once_status exp_run_once_status)
 117 {
 118         const bt_port_output *src_out_port = NULL;
 119         bt_graph *graph;
 120         const bt_component_sink *sink_comp = NULL;
 121         const bt_port_input *sink_in_port;
 122         bt_graph_add_component_status add_comp_status;
 123         bt_graph_run_once_status run_once_status;
 124         bt_graph_connect_ports_status connect_status;
 125         struct test_data test_data = {
 126                 .init_status = init_status,
 127                 .consume_status = consume_status,
 128         };
 129         const struct bt_error *err;
 130
 131         graph = create_graph_with_source(&src_out_port);
 132         BT_ASSERT(graph);
 133         BT_ASSERT(src_out_port);
 134
 135         add_comp_status = bt_graph_add_simple_sink_component(graph, "sink",
 136                 simple_INITIALIZE_func, simple_consume_func, simple_fini_func,
 137                 &test_data, &sink_comp);
 138         BT_ASSERT(add_comp_status == BT_GRAPH_ADD_COMPONENT_STATUS_OK);
 139         BT_ASSERT(sink_comp);
 140
 141         sink_in_port = bt_component_sink_borrow_input_port_by_name_const(
 142                 sink_comp, "in");
 143         ok(sink_in_port,
 144                 "Simple sink component has an input port named \"in\"");
 145
 146         connect_status = bt_graph_connect_ports(graph, src_out_port,
 147                 sink_in_port, NULL);
 148         ok(connect_status == BT_GRAPH_CONNECT_PORTS_STATUS_OK,
 149                 "Simple sink component's \"in\" port is connectable");
 150
 151         run_once_status = bt_graph_run_once(graph);
 152         ok(run_once_status == exp_run_once_status,
 153                 "Graph \"run once\" status is the expected one (status code: %d)",
 154                 run_once_status);
 155
 156         err = bt_current_thread_take_error();
 157         ok((run_once_status < 0) == (err != NULL),
 158                 "Current thread error is set if bt_graph_run_once returned an error");
 159
 160         bt_component_sink_put_ref(sink_comp);
 161         bt_graph_put_ref(graph);
 162         if (err) {
 163                 bt_error_release(err);
 164         }
 165 }
 166
 167 int main(void)
 168 {
 169         plan_tests(NR_TESTS);
 170
 171         /* Test initialization function status */
 172         test_simple_expect_run_once_status(
 173                 BT_GRAPH_SIMPLE_SINK_COMPONENT_INITIALIZE_FUNC_STATUS_OK,
 174                 BT_GRAPH_SIMPLE_SINK_COMPONENT_CONSUME_FUNC_STATUS_OK,
 175                 BT_GRAPH_RUN_ONCE_STATUS_OK);
 176         test_simple_expect_run_once_status(
 177                 BT_GRAPH_SIMPLE_SINK_COMPONENT_INITIALIZE_FUNC_STATUS_ERROR,
 178                 BT_GRAPH_SIMPLE_SINK_COMPONENT_CONSUME_FUNC_STATUS_OK,
 179                 BT_GRAPH_RUN_ONCE_STATUS_ERROR);
 180         test_simple_expect_run_once_status(
 181                 BT_GRAPH_SIMPLE_SINK_COMPONENT_INITIALIZE_FUNC_STATUS_MEMORY_ERROR,
 182                 BT_GRAPH_SIMPLE_SINK_COMPONENT_CONSUME_FUNC_STATUS_OK,
 183                 BT_GRAPH_RUN_ONCE_STATUS_MEMORY_ERROR);
 184
 185         /* Test "consume" function status */
 186         test_simple_expect_run_once_status(
 187                 BT_GRAPH_SIMPLE_SINK_COMPONENT_INITIALIZE_FUNC_STATUS_OK,
 188                 BT_GRAPH_SIMPLE_SINK_COMPONENT_CONSUME_FUNC_STATUS_OK,
 189                 BT_GRAPH_RUN_ONCE_STATUS_OK);
 190         test_simple_expect_run_once_status(
 191                 BT_GRAPH_SIMPLE_SINK_COMPONENT_INITIALIZE_FUNC_STATUS_OK,
 192                 BT_GRAPH_SIMPLE_SINK_COMPONENT_CONSUME_FUNC_STATUS_ERROR,
 193                 BT_GRAPH_RUN_ONCE_STATUS_ERROR);
 194         test_simple_expect_run_once_status(
 195                 BT_GRAPH_SIMPLE_SINK_COMPONENT_INITIALIZE_FUNC_STATUS_OK,
 196                 BT_GRAPH_SIMPLE_SINK_COMPONENT_CONSUME_FUNC_STATUS_MEMORY_ERROR,
 197                 BT_GRAPH_RUN_ONCE_STATUS_MEMORY_ERROR);
 198         test_simple_expect_run_once_status(
 199                 BT_GRAPH_SIMPLE_SINK_COMPONENT_INITIALIZE_FUNC_STATUS_OK,
 200                 BT_GRAPH_SIMPLE_SINK_COMPONENT_CONSUME_FUNC_STATUS_AGAIN,
 201                 BT_GRAPH_RUN_ONCE_STATUS_AGAIN);
 202         test_simple_expect_run_once_status(
 203                 BT_GRAPH_SIMPLE_SINK_COMPONENT_INITIALIZE_FUNC_STATUS_OK,
 204                 BT_GRAPH_SIMPLE_SINK_COMPONENT_CONSUME_FUNC_STATUS_END,
 205                 BT_GRAPH_RUN_ONCE_STATUS_END);
 206
 207         return exit_status();
 208 }