tests/check_session.c: Fix compiler warning.

[libsigrokdecode.git] / tests / runtc.c

diff --git a/tests/runtc.c b/tests/runtc.c
index af1e3fba961129a3641a4aaa220ad89130ecc779..11ae560dbea4766c63872d09018dbf9b333a6e66 100644 (file)
--- a/tests/runtc.c
+++ b/tests/runtc.c
@@ -17,6 +17,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <Python.h>
 #include "../libsigrokdecode.h"
 #include <libsigrok/libsigrok.h>
 #include <stdlib.h>
@@ -35,25 +36,25 @@
 #ifdef __LINUX__
 #include <sched.h>
 #endif
-#include "../config.h"
+#include "config.h"
 
 int debug = FALSE;
 int statistics = FALSE;
 char *coverage_report;
 
-struct probe {
+struct channel {
        char *name;
-       int probe;
+       int channel;
 };
 
 struct option {
        char *key;
-       char *value;
+       GVariant *value;
 };
 
 struct pd {
        char *name;
-       GSList *probes;
+       GSList *channels;
        GSList *options;
 };
 
@@ -140,8 +141,8 @@ static void usage(char *msg)
        printf("Usage: runtc [-dPpoiOf]\n");
        printf("  -d  Debug\n");
        printf("  -P  <protocol decoder>\n");
-       printf("  -p  <probename=probenum> (optional)\n");
-       printf("  -o  <probeoption=value> (optional)\n");
+       printf("  -p  <channelname=channelnum> (optional)\n");
+       printf("  -o  <channeloption=value> (optional)\n");
        printf("  -i <input file>\n");
        printf("  -O <output-pd:output-type[:output-class]>\n");
        printf("  -f <output file> (optional)\n");
@@ -327,16 +328,17 @@ static int run_testcase(char *infile, GSList *pdlist, struct output *op)
        struct srd_session *sess;
        struct srd_decoder *dec;
        struct srd_decoder_inst *di, *prev_di;
-       srd_pd_output_callback_t cb;
+       srd_pd_output_callback cb;
        struct pd *pd;
-       struct probe *probe;
+       struct channel *channel;
        struct option *option;
        GVariant *gvar;
-       GHashTable *probes, *opts;
+       GHashTable *channels, *opts;
        GSList *pdl, *l;
        int idx;
-       int max_probe;
+       int max_channel;
        char **decoder_class;
+       struct sr_session *sr_sess;
 
        if (op->outfile) {
                if ((op->outfd = open(op->outfile, O_CREAT|O_WRONLY, 0600)) == -1) {
@@ -346,12 +348,12 @@ static int run_testcase(char *infile, GSList *pdlist, struct output *op)
                }
        }
 
-       if (sr_session_load(infile) != SR_OK)
+       if (sr_session_load(infile, &sr_sess) != SR_OK)
                return FALSE;
 
        if (srd_session_new(&sess) != SRD_OK)
                return FALSE;
-       sr_session_datafeed_callback_add(sr_cb, sess);
+       sr_session_datafeed_callback_add(sr_sess, sr_cb, sess);
        switch (op->type) {
        case SRD_OUTPUT_ANN:
                cb = srd_cb_ann;
@@ -385,23 +387,23 @@ static int run_testcase(char *infile, GSList *pdlist, struct output *op)
                        return FALSE;
                g_hash_table_destroy(opts);
 
-               /* Map probes. */
-               if (pd->probes) {
-                       probes = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
+               /* Map channels. */
+               if (pd->channels) {
+                       channels = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
                                        (GDestroyNotify)g_variant_unref);
-                       max_probe = 0;
-                       for (l = pd->probes; l; l = l->next) {
-                               probe = l->data;
-                               if (probe->probe > max_probe)
-                                       max_probe = probe->probe;
-                               gvar = g_variant_new_int32(probe->probe);
+                       max_channel = 0;
+                       for (l = pd->channels; l; l = l->next) {
+                               channel = l->data;
+                               if (channel->channel > max_channel)
+                                       max_channel = channel->channel;
+                               gvar = g_variant_new_int32(channel->channel);
                                g_variant_ref_sink(gvar);
-                               g_hash_table_insert(probes, probe->name, gvar);
+                               g_hash_table_insert(channels, channel->name, gvar);
                        }
-                       if (srd_inst_probe_set_all(di, probes,
-                                       (max_probe + 8) / 8) != SRD_OK)
+                       if (srd_inst_channel_set_all(di, channels,
+                                       (max_channel + 8) / 8) != SRD_OK)
                                return FALSE;
-                       g_hash_table_destroy(probes);
+                       g_hash_table_destroy(channels);
                }
 
                /* If this is not the first decoder in the list, stack it
@@ -443,9 +445,9 @@ static int run_testcase(char *infile, GSList *pdlist, struct output *op)
                        DBG("Class %s index is %d", op->class, op->class_idx);
        }
 
-       sr_session_start();
-       sr_session_run();
-       sr_session_stop();
+       sr_session_start(sr_sess);
+       sr_session_run(sr_sess);
+       sr_session_stop(sr_sess);
 
        srd_session_destroy(sess);
 
@@ -685,11 +687,11 @@ int main(int argc, char **argv)
        PyObject *coverage;
        GSList *pdlist;
        struct pd *pd;
-       struct probe *probe;
+       struct channel *channel;
        struct option *option;
        struct output *op;
-       int ret;
-       char c, *opt_infile, **kv, **opstr;
+       int ret, c;
+       char *opt_infile, **kv, **opstr;
 
        op = malloc(sizeof(struct output));
        op->pd = NULL;
@@ -710,7 +712,7 @@ int main(int argc, char **argv)
                case 'P':
                        pd = g_malloc(sizeof(struct pd));
                        pd->name = g_strdup(optarg);
-                       pd->probes = pd->options = NULL;
+                       pd->channels = pd->options = NULL;
                        pdlist = g_slist_append(pdlist, pd);
                        break;
                case 'p':
@@ -728,15 +730,16 @@ int main(int argc, char **argv)
                                usage(NULL);
                        }
                        if (c == 'p') {
-                               probe = malloc(sizeof(struct probe));
-                               probe->name = g_strdup(kv[0]);
-                               probe->probe = strtoul(kv[1], 0, 10);
+                               channel = malloc(sizeof(struct channel));
+                               channel->name = g_strdup(kv[0]);
+                               channel->channel = strtoul(kv[1], 0, 10);
                                /* Apply to last PD. */
-                               pd->probes = g_slist_append(pd->probes, probe);
+                               pd->channels = g_slist_append(pd->channels, channel);
                        } else {
                                option = malloc(sizeof(struct option));
                                option->key = g_strdup(kv[0]);
-                               option->value = g_strdup(kv[1]);
+                               option->value = g_variant_new_string(kv[1]);
+                g_variant_ref_sink(option->value);
                                /* Apply to last PD. */
                                pd->options = g_slist_append(pd->options, option);
                        }
@@ -759,6 +762,9 @@ int main(int argc, char **argv)
                                op->type = SRD_OUTPUT_BINARY;
                        else if (!strcmp(opstr[1], "python"))
                                op->type = SRD_OUTPUT_PYTHON;
+                       else if (!strcmp(opstr[1], "exception"))
+                /* Doesn't matter, we just need it to bomb out. */
+                               op->type = SRD_OUTPUT_PYTHON;
                        else {
                                ERR("Unknown output type '%s'", opstr[1]);
                                g_strfreev(opstr);