#include <sched.h>
#endif
-int debug = FALSE;
-int statistics = FALSE;
-char *coverage_report;
+static int debug = FALSE;
+static int statistics = FALSE;
+static char *coverage_report;
+static struct sr_context *ctx;
struct channel {
char *name;
};
struct pd {
- char *name;
+ const char *name;
GSList *channels;
GSList *options;
};
struct output {
- char *pd;
+ const char *pd;
+ const char *pd_id;
int type;
- char *class;
+ const char *class;
int class_idx;
- char *outfile;
+ const char *outfile;
int outfd;
};
GSList *missed_lines;
};
-struct cvg *get_mod_cov(PyObject *py_cov, char *module_name);
-void cvg_add(struct cvg *dst, struct cvg *src);
-struct cvg *cvg_new(void);
-gboolean find_missed_line(struct cvg *cvg, char *linespec);
+static struct cvg *get_mod_cov(PyObject *py_cov, const char *module_name);
+static void cvg_add(struct cvg *dst, const struct cvg *src);
+static struct cvg *cvg_new(void);
+static gboolean find_missed_line(struct cvg *cvg, const char *linespec);
-static void logmsg(char *prefix, FILE *out, const char *format, va_list args)
+static void logmsg(const char *prefix, FILE *out, const char *format, va_list args)
{
if (prefix)
fprintf(out, "%s", prefix);
return SRD_OK;
}
-static void usage(char *msg)
+static void usage(const char *msg)
{
if (msg)
fprintf(stderr, "%s\n", msg);
- printf("Usage: runtc [-dPpoiOf]\n");
- printf(" -d Debug\n");
- printf(" -P
<protocol decoder>\n");
- printf(" -p <channelname=channelnum> (optional)\n");
- printf(" -o <channeloption=value> (optional)\n");
+ printf("Usage: runtc [-dPpoiOfcS]\n");
+ printf(" -d (enables debug output)\n");
+ printf(" -P <protocol decoder>\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");
printf(" -c <coverage report> (optional)\n");
+ printf(" -S (enables statistics)\n");
exit(msg ? 1 : 0);
}
-/* This is a neutered version of libsigrokdecode's py_str_as_str(). It
+/*
+ * This is a neutered version of libsigrokdecode's py_str_as_str(). It
* does no error checking, but then the only strings it processes are
- * generated by Python's repr(), so are known good. */
+ * generated by Python's repr(), so are known good.
+ */
static char *py_str_as_str(const PyObject *py_str)
{
PyObject *py_encstr;
return outstr;
}
+/*
+ * The following routines are callbacks for libsigrokdecode. They receive
+ * output from protocol decoders, optionally dropping data to only forward
+ * a selected decoder's or class' information. Output is written to either
+ * a specified file or stdout, an external process will compare captured
+ * output against expectations.
+ *
+ * Note that runtc(1) output emits the decoder "class" name instead of the
+ * instance name. So that generated output remains compatible with existing
+ * .output files which hold expected output of test cases. Without this
+ * approach, developers had to "anticipate" instance names from test.conf
+ * setups (and knowledge about internal implementation details of the srd
+ * library), and adjust .output files to reflect those names. Or specify
+ * instance names in each and every test.conf description (-o inst_id=ID).
+ *
+ * It's assumed that runtc(1) is used to check stacked decoders, but not
+ * multiple stacks in parallel and no stacks with multiple instances of
+ * decoders of the same type. When such configurations become desirable,
+ * runtc(1) needs to emit the instance name, and test configurations and
+ * output expectations need adjustment.
+ */
+
static void srd_cb_py(struct srd_proto_data *pdata, void *cb_data)
{
struct output *op;
pydata = pdata->data;
DBG("ptr %p", pydata);
- if (strcmp(pdata->pdo->di->inst_id, op->pd))
+ if (strcmp(pdata->pdo->di->inst_id, op->pd_id))
/* This is not the PD selected for output. */
return;
s = py_str_as_str(pyrepr);
Py_DecRef(pyrepr);
- /* Output format for testing is '<ss>-<es> <inst-id>: <repr>\n'. */
+ /* Output format for testing is '<ss>-<es> <decoder-id>: <repr>\n'. */
out = g_string_sized_new(128);
g_string_printf(out, "%" PRIu64 "-%" PRIu64 " %s: %s\n",
pdata->start_sample, pdata->end_sample,
- pdata->pdo->di->inst_id, s);
+ pdata->pdo->di->decoder->id, s);
g_free(s);
if (write(op->outfd, out->str, out->len) == -1)
ERR("SRD_OUTPUT_PYTHON callback write failure!");
op = cb_data;
pdb = pdata->data;
- if (strcmp(pdata->pdo->di->inst_id, op->pd))
+ if (strcmp(pdata->pdo->di->inst_id, op->pd_id))
/* This is not the PD selected for output. */
return;
out = g_string_sized_new(128);
g_string_printf(out, "%" PRIu64 "-%" PRIu64 " %s:",
pdata->start_sample, pdata->end_sample,
- pdata->pdo->di->inst_id);
+ pdata->pdo->di->decoder->id);
for (i = 0; i < pdb->size; i++) {
g_string_append_printf(out, " %.2x", pdb->data[i]);
}
static void srd_cb_ann(struct srd_proto_data *pdata, void *cb_data)
{
+ struct srd_decoder_inst *di;
struct srd_decoder *dec;
struct srd_proto_data_annotation *pda;
struct output *op;
int i;
char **dec_ann;
- DBG("Annotation output from %s", pdata->pdo->di->inst_id);
+ /*
+ * Only inspect received annotations when they originate from
+ * the selected protocol decoder, and an optionally specified
+ * annotation class matches the received data.
+ */
op = cb_data;
pda = pdata->data;
- dec = pdata->pdo->di->decoder;
- if (strcmp(pdata->pdo->di->inst_id, op->pd))
+ di = pdata->pdo->di;
+ dec = di->decoder;
+ DBG("Annotation output from %s", di->inst_id);
+ if (strcmp(di->inst_id, op->pd_id))
/* This is not the PD selected for output. */
return;
- if (op->class_idx != -1 && op->class_idx != pda->ann_format)
+ if (op->class_idx != -1 && op->class_idx != pda->ann_class)
/*
* This output takes a specific annotation class,
* but not the one that just came in.
*/
return;
- dec_ann = g_slist_nth_data(dec->annotations, pda->ann_format);
+ /*
+ * Print the annotation information in textual representation
+ * to the specified output file. Prefix the annotation strings
+ * with the start and end sample number, the decoder name, and
+ * the annotation name.
+ */
+ dec_ann = g_slist_nth_data(dec->annotations, pda->ann_class);
line = g_string_sized_new(256);
g_string_printf(line, "%" PRIu64 "-%" PRIu64 " %s: %s:",
pdata->start_sample, pdata->end_sample,
- pdata->pdo->di->inst_id, dec_ann[0]);
+ dec->id, dec_ann[0]);
for (i = 0; pda->ann_text[i]; i++)
g_string_append_printf(line, " \"%s\"", pda->ann_text[i]);
g_string_append(line, "\n");
static void sr_cb(const struct sr_dev_inst *sdi,
const struct sr_datafeed_packet *packet, void *cb_data)
{
+ static int samplecnt = 0;
const struct sr_datafeed_logic *logic;
struct srd_session *sess;
GVariant *gvar;
uint64_t samplerate;
int num_samples;
- static int samplecnt = 0;
+ struct sr_dev_driver *driver;
sess = cb_data;
+ driver = sr_dev_inst_driver_get(sdi);
+
switch (packet->type) {
case SR_DF_HEADER:
DBG("Received SR_DF_HEADER");
- if (sr_config_get(sdi->driver, sdi, NULL, SR_CONF_SAMPLERATE,
+ if (sr_config_get(driver, sdi, NULL, SR_CONF_SAMPLERATE,
&gvar) != SR_OK) {
ERR("Getting samplerate failed");
break;
case SR_DF_LOGIC:
logic = packet->payload;
num_samples = logic->length / logic->unitsize;
- DBG("Received SR_DF_LOGIC: %d samples", num_samples);
+ DBG("Received SR_DF_LOGIC (%"PRIu64" bytes, unitsize = %d).",
+ logic->length, logic->unitsize);
srd_session_send(sess, samplecnt, samplecnt + num_samples,
- logic->data, logic->length);
- samplecnt += logic->length / logic->unitsize;
+ logic->data, logic->length, logic->unitsize);
+ samplecnt += num_samples;
break;
case SR_DF_END:
DBG("Received SR_DF_END");
}
-static int run_testcase(char *infile, GSList *pdlist, struct output *op)
+static int run_testcase(const char *infile, GSList *pdlist, struct output *op)
{
struct srd_session *sess;
struct srd_decoder *dec;
struct option *option;
GVariant *gvar;
GHashTable *channels, *opts;
- GSList *pdl, *l;
- int idx;
+ GSList *pdl, *l, *devices;
+ int idx, i;
int max_channel;
char **decoder_class;
struct sr_session *sr_sess;
+ gboolean is_number;
+ const char *s;
if (op->outfile) {
if ((op->outfd = open(op->outfile, O_CREAT|O_WRONLY, 0600)) == -1) {
ERR("Unable to open %s for writing: %s", op->outfile,
- strerror(errno));
+ g_strerror(errno));
return FALSE;
}
}
- if (sr_session_load(infile, &sr_sess) != SR_OK)
+ if (sr_session_load(ctx, infile, &sr_sess) != SR_OK)
return FALSE;
+ sr_session_dev_list(sr_sess, &devices);
+
if (srd_session_new(&sess) != SRD_OK)
return FALSE;
sr_session_datafeed_callback_add(sr_sess, sr_cb, sess);
(GDestroyNotify)g_variant_unref);
for (l = pd->options; l; l = l->next) {
option = l->data;
- g_hash_table_insert(opts, option->key, option->value);
+
+ is_number = TRUE;
+ s = g_variant_get_string(option->value, NULL);
+ for (i = 0; i < (int)strlen(s); i++) {
+ if (!isdigit(s[i]))
+ is_number = FALSE;
+ }
+
+ if (is_number) {
+ /* Integer option value */
+ g_hash_table_insert(opts, option->key,
+ g_variant_new_int64(strtoull(s, NULL, 10)));
+ } else {
+ /* String option value */
+ g_hash_table_insert(opts, option->key, option->value);
+ }
}
if (!(di = srd_inst_new(sess, pd->name, opts)))
return FALSE;
g_hash_table_destroy(opts);
+ /*
+ * Get (a reference to) the decoder instance's ID if we
+ * are about to receive PD output from it. We need to
+ * filter output that carries the decoder instance's name.
+ */
+ if (strcmp(pd->name, op->pd) == 0) {
+ op->pd_id = di->inst_id;
+ DBG("Decoder of type \"%s\" has instance ID \"%s\".",
+ op->pd, op->pd_id);
+ }
+
/* Map channels. */
if (pd->channels) {
channels = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
g_variant_ref_sink(gvar);
g_hash_table_insert(channels, channel->name, gvar);
}
- if (srd_inst_channel_set_all(di, channels,
- (max_channel + 8) / 8) != SRD_OK)
+
+ if (srd_inst_channel_set_all(di, channels) != SRD_OK)
return FALSE;
g_hash_table_destroy(channels);
}
- /* If this is not the first decoder in the list, stack it
- * on top of the previous one. */
+ /*
+ * If this is not the first decoder in the list, stack it
+ * on top of the previous one.
+ */
if (prev_di) {
if (srd_inst_stack(sess, prev_di, di) != SRD_OK) {
ERR("Failed to stack decoder instances.");
}
prev_di = di;
}
+ /*
+ * Bail out if we haven't created an instance of the selected
+ * decoder type of which we shall grab output data from.
+ */
+ if (!op->pd_id)
+ return FALSE;
- /* Resolve top decoder's class index, so we can match. */
+ /* Resolve selected decoder's class index, so we can match. */
dec = srd_decoder_get_by_id(pd->name);
if (op->class) {
if (op->type == SRD_OUTPUT_ANN)
if (!strcmp(decoder_class[0], op->class)) {
op->class_idx = idx;
break;
- } else
- idx++;
+ }
+ idx++;
l = l->next;
}
if (op->class_idx == -1) {
ERR("Output class '%s' not found in decoder %s.",
op->class, pd->name);
return FALSE;
- } else
- DBG("Class %s index is %d", op->class, op->class_idx);
+ }
+ DBG("Class %s index is %d", op->class, op->class_idx);
}
sr_session_start(sr_sess);
return py_cov;
}
-struct cvg *get_mod_cov(PyObject *py_cov, char *module_name)
+static struct cvg *get_mod_cov(PyObject *py_cov, const char *module_name)
{
PyObject *py_mod, *py_pathlist, *py_path, *py_func, *py_pd;
PyObject *py_result, *py_missed, *py_item;
py_pathlist = PyObject_GetAttrString(py_mod, "__path__");
for (i = 0; i < PyList_Size(py_pathlist); i++) {
py_path = PyList_GetItem(py_pathlist, i);
- PyUnicode_FSConverter(PyList_GetItem(py_pathlist, i), &py_path);
+ PyUnicode_FSConverter(PyList_GetItem(py_pathlist, i), &py_path);
path = PyBytes_AS_STRING(py_path);
if (!(d = opendir(path))) {
ERR("Invalid module path '%s'", path);
return cvg_mod;
}
-struct cvg *cvg_new(void)
+static struct cvg *cvg_new(void)
{
struct cvg *cvg;
return cvg;
}
-gboolean find_missed_line(struct cvg *cvg, char *linespec)
+static gboolean find_missed_line(struct cvg *cvg, const char *linespec)
{
GSList *l;
return FALSE;
}
-void cvg_add(struct cvg *dst, struct cvg *src)
+static void cvg_add(struct cvg *dst, const struct cvg *src)
{
GSList *l;
char *linespec;
int main(int argc, char **argv)
{
- struct sr_context *ctx;
PyObject *coverage;
GSList *pdlist;
struct pd *pd;
op = malloc(sizeof(struct output));
op->pd = NULL;
+ op->pd_id = NULL;
op->type = -1;
op->class = NULL;
op->class_idx = -1;
if (c == 'p') {
channel = malloc(sizeof(struct channel));
channel->name = g_strdup(kv[0]);
- channel->channel = strtoul(kv[1], 0, 10);
+ channel->channel = strtoul(kv[1], NULL, 10);
/* Apply to last PD. */
pd->channels = g_slist_append(pd->channels, channel);
} else {
option = malloc(sizeof(struct option));
option->key = g_strdup(kv[0]);
option->value = g_variant_new_string(kv[1]);
- g_variant_ref_sink(option->value);
+ g_variant_ref_sink(option->value);
/* Apply to last PD. */
pd->options = g_slist_append(pd->options, option);
}
projects / sigrok-test.git / blobdiff