[libsigrok.git] / tests / trigger.c

/*
 * This file is part of the libsigrok project.
 *
 * Copyright (C) 2014 Uwe Hermann <uwe@hermann-uwe.de>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
 */

#include <config.h>
#include <stdio.h>
#include <stdlib.h>
#include <check.h>
#include <libsigrok/libsigrok.h>
#include "lib.h"

/* Test lots of triggers/stages/matches/channels */
#define NUM_TRIGGERS 70
#define NUM_STAGES 30
#define NUM_MATCHES 70
#define NUM_CHANNELS NUM_MATCHES

/* Check whether creating/freeing triggers with valid names works. */
START_TEST(test_trigger_new_free)
{
	int i;
	struct sr_trigger *t[NUM_TRIGGERS];
	char name[10];

	/* Create a few triggers with a valid name. */
	for (i = 0; i < NUM_TRIGGERS; i++) {
		sprintf((char *)&name, "T%d", i);
		t[i] = sr_trigger_new((const char *)&name);
		fail_unless(t[i] != NULL);
		fail_unless(!strcmp(t[i]->name, (const char *)&name));
		fail_unless(t[i]->stages == NULL);
	}

	/* Free the triggers again (must not segfault). */
	for (i = 0; i < NUM_TRIGGERS; i++)
		sr_trigger_free(t[i]);
}
END_TEST

/* Check whether creating/freeing triggers with NULL names works. */
START_TEST(test_trigger_new_free_null)
{
	int i;
	struct sr_trigger *t[NUM_TRIGGERS];

	/* Create a few triggers with a NULL name (which is allowed). */
	for (i = 0; i < NUM_TRIGGERS; i++) {
		t[i] = sr_trigger_new(NULL);
		fail_unless(t[i] != NULL);
		fail_unless(t[i]->name == NULL);
		fail_unless(t[i]->stages == NULL);
	}

	/* Free the triggers again (must not segfault). */
	for (i = 0; i < NUM_TRIGGERS; i++)
		sr_trigger_free(t[i]);
}
END_TEST

/* Check whether sr_trigger_free(NULL) works without segfaulting. */
START_TEST(test_trigger_free_null)
{
	sr_trigger_free(NULL);
}
END_TEST

/* Check whether creating/freeing triggers with stages works. */
START_TEST(test_trigger_stage_add)
{
	int i, j;
	struct sr_trigger *t[NUM_TRIGGERS];
	struct sr_trigger_stage *s[NUM_STAGES];

	/* Create a few triggers with a valid name. */
	for (i = 0; i < NUM_TRIGGERS; i++) {
		t[i] = sr_trigger_new("T");

		/* Add a bunch of trigger stages to this trigger. */
		for (j = 0; j < NUM_STAGES; j++) {
			s[j] = sr_trigger_stage_add(t[i]);
			fail_unless(s[j] != NULL);
			fail_unless(t[i]->stages != NULL);
			fail_unless((int)g_slist_length(t[i]->stages) == (j + 1));
			fail_unless(s[j]->stage == j);
			fail_unless(s[j]->matches == NULL);
		}
	}

	/* Free the triggers again (must not segfault). */
	for (i = 0; i < NUM_TRIGGERS; i++)
		sr_trigger_free(t[i]);
}
END_TEST

/* Check whether creating NULL trigger stages fails (as it should). */
START_TEST(test_trigger_stage_add_null)
{
	/* Should not segfault, but rather return NULL. */
	fail_unless(sr_trigger_stage_add(NULL) == NULL);
}
END_TEST

/* Check whether creating/freeing triggers with matches works. */
START_TEST(test_trigger_match_add)
{
	int i, j, k, tm, ret;
	struct sr_trigger *t[NUM_TRIGGERS];
	struct sr_trigger_stage *s[NUM_STAGES];
	struct sr_channel *chl[NUM_CHANNELS];
	struct sr_channel *cha[NUM_CHANNELS];
	char name[10];

	/* Create a bunch of logic and analog channels. */
	for (i = 0; i < NUM_CHANNELS; i++) {
		sprintf((char *)&name, "L%d", i);
		chl[i] = g_malloc0(sizeof(struct sr_channel));
		chl[i]->index = i;
		chl[i]->type = SR_CHANNEL_LOGIC;
		chl[i]->enabled = TRUE;
		chl[i]->name = g_strdup((const char *)&name);

		sprintf((char *)&name, "A%d", i);
		cha[i] = g_malloc0(sizeof(struct sr_channel));
		cha[i]->index = i;
		cha[i]->type = SR_CHANNEL_ANALOG;
		cha[i]->enabled = TRUE;
		cha[i]->name = g_strdup((const char *)&name);
	}

	/* Create a few triggers with a valid name. */
	for (i = 0; i < NUM_TRIGGERS; i++) {
		t[i] = sr_trigger_new("T");

		/* Add a bunch of trigger stages to this trigger. */
		for (j = 0; j < NUM_STAGES; j++) {
			s[j] = sr_trigger_stage_add(t[i]);

			/* Add a bunch of matches to this stage. */
			for (k = 0; k < NUM_MATCHES; k++) {
				/* Logic channel matches. */
				tm = 1 + (k % 5); /* *_ZERO .. *_EDGE */
				ret = sr_trigger_match_add(s[j], chl[k], tm, 0);
				fail_unless(ret == SR_OK);

				/* Analog channel matches. */
				tm = 3 + (k % 4); /* *_RISING .. *_UNDER */
				ret = sr_trigger_match_add(s[j], cha[k],
					tm, ((rand() % 500) - 500) * 1.739);
				fail_unless(ret == SR_OK);
			}
		}
	}

	/* Free the triggers again (must not segfault). */
	for (i = 0; i < NUM_TRIGGERS; i++)
		sr_trigger_free(t[i]);

	/* Free the channels. */
	for (i = 0; i < NUM_CHANNELS; i++) {
		g_free(chl[i]->name);
		g_free(chl[i]);
		g_free(cha[i]->name);
		g_free(cha[i]);
	}
}
END_TEST

/* Check whether trigger_match_add() copes well with incorrect input. */
START_TEST(test_trigger_match_add_bogus)
{
	int ret;
	struct sr_trigger *t;
	struct sr_trigger_stage *s, *sl;
	struct sr_channel *chl, *cha;

	t = sr_trigger_new("T");
	s = sr_trigger_stage_add(t);
	chl = g_malloc0(sizeof(struct sr_channel));
	chl->index = 0;
	chl->type = SR_CHANNEL_LOGIC;
	chl->enabled = TRUE;
	chl->name = g_strdup("L0");
	cha = g_malloc0(sizeof(struct sr_channel));
	cha->index = 1;
	cha->type = SR_CHANNEL_ANALOG;
	cha->enabled = TRUE;
	cha->name = g_strdup("A0");

	/* Initially we have no matches at all. */
	sl = t->stages->data;
	fail_unless(g_slist_length(sl->matches) == 0);

	/* NULL stage */
	ret = sr_trigger_match_add(NULL, chl, SR_TRIGGER_ZERO, 0);
	fail_unless(ret == SR_ERR_ARG);
	fail_unless(g_slist_length(sl->matches) == 0);

	/* NULL channel */
	ret = sr_trigger_match_add(s, NULL, SR_TRIGGER_ZERO, 0);
	fail_unless(ret == SR_ERR_ARG);
	fail_unless(g_slist_length(sl->matches) == 0);

	/* Invalid trigger matches for logic channels. */
	ret = sr_trigger_match_add(s, chl, SR_TRIGGER_OVER, 0);
	fail_unless(ret == SR_ERR_ARG);
	fail_unless(g_slist_length(sl->matches) == 0);
	ret = sr_trigger_match_add(s, chl, SR_TRIGGER_UNDER, 0);
	fail_unless(ret == SR_ERR_ARG);
	fail_unless(g_slist_length(sl->matches) == 0);

	/* Invalid trigger matches for analog channels. */
	ret = sr_trigger_match_add(s, cha, SR_TRIGGER_ZERO, 9.4);
	fail_unless(ret == SR_ERR_ARG);
	fail_unless(g_slist_length(sl->matches) == 0);
	ret = sr_trigger_match_add(s, cha, SR_TRIGGER_ONE, -9.4);
	fail_unless(ret == SR_ERR_ARG);
	fail_unless(g_slist_length(sl->matches) == 0);

	/* Invalid channel type. */
	chl->type = -1;
	ret = sr_trigger_match_add(s, chl, SR_TRIGGER_ZERO, 0);
	fail_unless(ret == SR_ERR_ARG);
	fail_unless(g_slist_length(sl->matches) == 0);
	chl->type = 270;
	ret = sr_trigger_match_add(s, chl, SR_TRIGGER_ZERO, 0);
	fail_unless(ret == SR_ERR_ARG);
	fail_unless(g_slist_length(sl->matches) == 0);

	sr_trigger_free(t);
	g_free(chl->name);
	g_free(chl);
	g_free(cha->name);
	g_free(cha);
}
END_TEST

Suite *suite_trigger(void)
{
	Suite *s;
	TCase *tc;

	s = suite_create("trigger");

	tc = tcase_create("new_free");
	tcase_add_checked_fixture(tc, srtest_setup, srtest_teardown);
	tcase_add_test(tc, test_trigger_new_free);
	tcase_add_test(tc, test_trigger_new_free_null);
	tcase_add_test(tc, test_trigger_free_null);
	suite_add_tcase(s, tc);

	tc = tcase_create("stage");
	tcase_add_checked_fixture(tc, srtest_setup, srtest_teardown);
	tcase_add_test(tc, test_trigger_stage_add);
	tcase_add_test(tc, test_trigger_stage_add_null);
	suite_add_tcase(s, tc);

	tc = tcase_create("match");
	tcase_set_timeout(tc, 0);
	tcase_add_checked_fixture(tc, srtest_setup, srtest_teardown);
	tcase_add_test(tc, test_trigger_match_add);
	tcase_add_test(tc, test_trigger_match_add_bogus);
	suite_add_tcase(s, tc);

	return s;
}
Commit	Line	Data
c8412d6c UH	1	/*
	2	* This file is part of the libsigrok project.
	3	*
	4	* Copyright (C) 2014 Uwe Hermann <uwe@hermann-uwe.de>
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, write to the Free Software
	18	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	19	*/
	20
6ec6c43b	21	#include <config.h>
c8412d6c UH	22	#include <stdio.h>
	23	#include <stdlib.h>
	24	#include <check.h>
4960aeb0	25	#include <libsigrok/libsigrok.h>
c8412d6c UH	26	#include "lib.h"
	27
	28	/* Test lots of triggers/stages/matches/channels */
	29	#define NUM_TRIGGERS 70
	30	#define NUM_STAGES 30
	31	#define NUM_MATCHES 70
	32	#define NUM_CHANNELS NUM_MATCHES
	33
	34	/* Check whether creating/freeing triggers with valid names works. */
	35	START_TEST(test_trigger_new_free)
	36	{
	37	int i;
	38	struct sr_trigger *t[NUM_TRIGGERS];
	39	char name[10];
	40
	41	/* Create a few triggers with a valid name. */
	42	for (i = 0; i < NUM_TRIGGERS; i++) {
	43	sprintf((char *)&name, "T%d", i);
	44	t[i] = sr_trigger_new((const char *)&name);
	45	fail_unless(t[i] != NULL);
	46	fail_unless(!strcmp(t[i]->name, (const char *)&name));
	47	fail_unless(t[i]->stages == NULL);
	48	}
	49
	50	/* Free the triggers again (must not segfault). */
	51	for (i = 0; i < NUM_TRIGGERS; i++)
	52	sr_trigger_free(t[i]);
	53	}
	54	END_TEST
	55
	56	/* Check whether creating/freeing triggers with NULL names works. */
	57	START_TEST(test_trigger_new_free_null)
	58	{
	59	int i;
	60	struct sr_trigger *t[NUM_TRIGGERS];
	61
	62	/* Create a few triggers with a NULL name (which is allowed). */
	63	for (i = 0; i < NUM_TRIGGERS; i++) {
	64	t[i] = sr_trigger_new(NULL);
	65	fail_unless(t[i] != NULL);
	66	fail_unless(t[i]->name == NULL);
	67	fail_unless(t[i]->stages == NULL);
	68	}
	69
	70	/* Free the triggers again (must not segfault). */
	71	for (i = 0; i < NUM_TRIGGERS; i++)
	72	sr_trigger_free(t[i]);
	73	}
	74	END_TEST
	75
	76	/* Check whether sr_trigger_free(NULL) works without segfaulting. */
	77	START_TEST(test_trigger_free_null)
	78	{
	79	sr_trigger_free(NULL);
	80	}
	81	END_TEST
	82
	83	/* Check whether creating/freeing triggers with stages works. */
	84	START_TEST(test_trigger_stage_add)
	85	{
	86	int i, j;
	87	struct sr_trigger *t[NUM_TRIGGERS];
	88	struct sr_trigger_stage *s[NUM_STAGES];
	89
90	/* Create a few triggers with a valid name. */
91	for (i = 0; i < NUM_TRIGGERS; i++) {
92	t[i] = sr_trigger_new("T");
93
94	/* Add a bunch of trigger stages to this trigger. */
95	for (j = 0; j < NUM_STAGES; j++) {
96	s[j] = sr_trigger_stage_add(t[i]);
97	fail_unless(s[j] != NULL);
98	fail_unless(t[i]->stages != NULL);
99	fail_unless((int)g_slist_length(t[i]->stages) == (j + 1));
100	fail_unless(s[j]->stage == j);
101	fail_unless(s[j]->matches == NULL);
102	}
103	}
104
105	/* Free the triggers again (must not segfault). */
106	for (i = 0; i < NUM_TRIGGERS; i++)
107	sr_trigger_free(t[i]);
108	}
109	END_TEST
110
111	/* Check whether creating NULL trigger stages fails (as it should). */
112	START_TEST(test_trigger_stage_add_null)
113	{
114	/* Should not segfault, but rather return NULL. */
115	fail_unless(sr_trigger_stage_add(NULL) == NULL);
116	}
117	END_TEST
118
119	/* Check whether creating/freeing triggers with matches works. */
120	START_TEST(test_trigger_match_add)
121	{
122	int i, j, k, tm, ret;
123	struct sr_trigger *t[NUM_TRIGGERS];
124	struct sr_trigger_stage *s[NUM_STAGES];
125	struct sr_channel *chl[NUM_CHANNELS];
126	struct sr_channel *cha[NUM_CHANNELS];
127	char name[10];
128
129	/* Create a bunch of logic and analog channels. */
130	for (i = 0; i < NUM_CHANNELS; i++) {
131	sprintf((char *)&name, "L%d", i);
132	chl[i] = g_malloc0(sizeof(struct sr_channel));
133	chl[i]->index = i;
134	chl[i]->type = SR_CHANNEL_LOGIC;
135	chl[i]->enabled = TRUE;
136	chl[i]->name = g_strdup((const char *)&name);
137
138	sprintf((char *)&name, "A%d", i);
139	cha[i] = g_malloc0(sizeof(struct sr_channel));
140	cha[i]->index = i;
141	cha[i]->type = SR_CHANNEL_ANALOG;
142	cha[i]->enabled = TRUE;
143	cha[i]->name = g_strdup((const char *)&name);
144	}
145
146	/* Create a few triggers with a valid name. */
147	for (i = 0; i < NUM_TRIGGERS; i++) {
148	t[i] = sr_trigger_new("T");
149
150	/* Add a bunch of trigger stages to this trigger. */
151	for (j = 0; j < NUM_STAGES; j++) {
152	s[j] = sr_trigger_stage_add(t[i]);
153
154	/* Add a bunch of matches to this stage. */
155	for (k = 0; k < NUM_MATCHES; k++) {
156	/* Logic channel matches. */
157	tm = 1 + (k % 5); /* _ZERO .. _EDGE */
158	ret = sr_trigger_match_add(s[j], chl[k], tm, 0);
159	fail_unless(ret == SR_OK);
160
161	/* Analog channel matches. */
162	tm = 3 + (k % 4); /* _RISING .. _UNDER */
163	ret = sr_trigger_match_add(s[j], cha[k],
164	tm, ((rand() % 500) - 500) * 1.739);
165	fail_unless(ret == SR_OK);
166	}
167	}
168	}
169
170	/* Free the triggers again (must not segfault). */
171	for (i = 0; i < NUM_TRIGGERS; i++)
172	sr_trigger_free(t[i]);
173
174	/* Free the channels. */
175	for (i = 0; i < NUM_CHANNELS; i++) {
176	g_free(chl[i]->name);
177	g_free(chl[i]);
178	g_free(cha[i]->name);
179	g_free(cha[i]);
180	}
181	}
182	END_TEST
183
184	/* Check whether trigger_match_add() copes well with incorrect input. */
185	START_TEST(test_trigger_match_add_bogus)
186	{
187	int ret;
188	struct sr_trigger *t;
189	struct sr_trigger_stage s, sl;
190	struct sr_channel chl, cha;
191
192	t = sr_trigger_new("T");
193	s = sr_trigger_stage_add(t);
194	chl = g_malloc0(sizeof(struct sr_channel));
195	chl->index = 0;
196	chl->type = SR_CHANNEL_LOGIC;
197	chl->enabled = TRUE;
198	chl->name = g_strdup("L0");
199	cha = g_malloc0(sizeof(struct sr_channel));
200	cha->index = 1;
201	cha->type = SR_CHANNEL_ANALOG;
202	cha->enabled = TRUE;
203	cha->name = g_strdup("A0");
204
205	/* Initially we have no matches at all. */
206	sl = t->stages->data;
207	fail_unless(g_slist_length(sl->matches) == 0);
208
209	/* NULL stage */
210	ret = sr_trigger_match_add(NULL, chl, SR_TRIGGER_ZERO, 0);
211	fail_unless(ret == SR_ERR_ARG);
212	fail_unless(g_slist_length(sl->matches) == 0);
213
214	/* NULL channel */
215	ret = sr_trigger_match_add(s, NULL, SR_TRIGGER_ZERO, 0);
216	fail_unless(ret == SR_ERR_ARG);
217	fail_unless(g_slist_length(sl->matches) == 0);
218
219	/* Invalid trigger matches for logic channels. */
220	ret = sr_trigger_match_add(s, chl, SR_TRIGGER_OVER, 0);
221	fail_unless(ret == SR_ERR_ARG);
222	fail_unless(g_slist_length(sl->matches) == 0);
223	ret = sr_trigger_match_add(s, chl, SR_TRIGGER_UNDER, 0);
224	fail_unless(ret == SR_ERR_ARG);
225	fail_unless(g_slist_length(sl->matches) == 0);
226
227	/* Invalid trigger matches for analog channels. */
228	ret = sr_trigger_match_add(s, cha, SR_TRIGGER_ZERO, 9.4);
229	fail_unless(ret == SR_ERR_ARG);
230	fail_unless(g_slist_length(sl->matches) == 0);
231	ret = sr_trigger_match_add(s, cha, SR_TRIGGER_ONE, -9.4);
232	fail_unless(ret == SR_ERR_ARG);
233	fail_unless(g_slist_length(sl->matches) == 0);
234
235	/* Invalid channel type. */
236	chl->type = -1;
237	ret = sr_trigger_match_add(s, chl, SR_TRIGGER_ZERO, 0);
238	fail_unless(ret == SR_ERR_ARG);
239	fail_unless(g_slist_length(sl->matches) == 0);
240	chl->type = 270;
241	ret = sr_trigger_match_add(s, chl, SR_TRIGGER_ZERO, 0);
242	fail_unless(ret == SR_ERR_ARG);
243	fail_unless(g_slist_length(sl->matches) == 0);
244
245	sr_trigger_free(t);
246	g_free(chl->name);
247	g_free(chl);
248	g_free(cha->name);
249	g_free(cha);
250	}
251	END_TEST
252
253	Suite *suite_trigger(void)
254	{
255	Suite *s;
256	TCase *tc;
257
258	s = suite_create("trigger");
259
260	tc = tcase_create("new_free");
261	tcase_add_checked_fixture(tc, srtest_setup, srtest_teardown);
262	tcase_add_test(tc, test_trigger_new_free);
263	tcase_add_test(tc, test_trigger_new_free_null);
264	tcase_add_test(tc, test_trigger_free_null);
265	suite_add_tcase(s, tc);
266
267	tc = tcase_create("stage");
268	tcase_add_checked_fixture(tc, srtest_setup, srtest_teardown);
269	tcase_add_test(tc, test_trigger_stage_add);
270	tcase_add_test(tc, test_trigger_stage_add_null);
271	suite_add_tcase(s, tc);
272
273	tc = tcase_create("match");
372c041b	274	tcase_set_timeout(tc, 0);
c8412d6c UH	275	tcase_add_checked_fixture(tc, srtest_setup, srtest_teardown);
	276	tcase_add_test(tc, test_trigger_match_add);
	277	tcase_add_test(tc, test_trigger_match_add_bogus);
	278	suite_add_tcase(s, tc);
	279
	280	return s;
	281	}