]>
Commit | Line | Data |
---|---|---|
41723529 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> |
41723529 UH |
22 | #include <stdlib.h> |
23 | #include <check.h> | |
4960aeb0 | 24 | #include <libsigrok/libsigrok.h> |
41723529 UH |
25 | #include "lib.h" |
26 | ||
41723529 UH |
27 | /* |
28 | * Check whether sr_session_new() works. | |
29 | * If it returns != SR_OK (or segfaults) this test will fail. | |
30 | */ | |
31 | START_TEST(test_session_new) | |
32 | { | |
33 | int ret; | |
34 | struct sr_session *sess; | |
35 | ||
ca1c21ca | 36 | ret = sr_session_new(srtest_ctx, &sess); |
41723529 UH |
37 | fail_unless(ret == SR_OK, "sr_session_new() failed: %d.", ret); |
38 | sr_session_destroy(sess); | |
39 | } | |
40 | END_TEST | |
41 | ||
42 | /* | |
43 | * Check whether sr_session_new() fails for bogus parameters. | |
44 | * If it returns SR_OK (or segfaults) this test will fail. | |
45 | */ | |
46 | START_TEST(test_session_new_bogus) | |
47 | { | |
48 | int ret; | |
49 | ||
ca1c21ca | 50 | ret = sr_session_new(srtest_ctx, NULL); |
41723529 UH |
51 | fail_unless(ret != SR_OK, "sr_session_new(NULL) worked."); |
52 | } | |
53 | END_TEST | |
54 | ||
55 | /* | |
56 | * Check whether multiple sr_session_new() calls work. | |
57 | * If any call returns != SR_OK (or segfaults) this test will fail. | |
58 | */ | |
59 | START_TEST(test_session_new_multiple) | |
60 | { | |
61 | int ret; | |
62 | struct sr_session *sess1, *sess2, *sess3; | |
63 | ||
64 | sess1 = sess2 = sess3 = NULL; | |
65 | ||
66 | /* Multiple sr_session_new() calls must work. */ | |
ca1c21ca | 67 | ret = sr_session_new(srtest_ctx, &sess1); |
41723529 | 68 | fail_unless(ret == SR_OK, "sr_session_new() 1 failed: %d.", ret); |
ca1c21ca | 69 | ret = sr_session_new(srtest_ctx, &sess2); |
41723529 | 70 | fail_unless(ret == SR_OK, "sr_session_new() 2 failed: %d.", ret); |
ca1c21ca | 71 | ret = sr_session_new(srtest_ctx, &sess3); |
41723529 UH |
72 | fail_unless(ret == SR_OK, "sr_session_new() 3 failed: %d.", ret); |
73 | ||
74 | /* The returned session pointers must all be non-NULL. */ | |
75 | fail_unless(sess1 != NULL); | |
76 | fail_unless(sess2 != NULL); | |
77 | fail_unless(sess3 != NULL); | |
78 | ||
79 | /* The returned session pointers must not be the same. */ | |
80 | fail_unless(sess1 != sess2); | |
81 | fail_unless(sess1 != sess3); | |
82 | fail_unless(sess2 != sess3); | |
83 | ||
84 | /* Destroying any of the sessions must work. */ | |
85 | ret = sr_session_destroy(sess1); | |
86 | fail_unless(ret == SR_OK, "sr_session_destroy() 1 failed: %d.", ret); | |
87 | ret = sr_session_destroy(sess2); | |
88 | fail_unless(ret == SR_OK, "sr_session_destroy() 2 failed: %d.", ret); | |
89 | ret = sr_session_destroy(sess3); | |
90 | fail_unless(ret == SR_OK, "sr_session_destroy() 3 failed: %d.", ret); | |
91 | } | |
92 | END_TEST | |
93 | ||
94 | /* | |
95 | * Check whether sr_session_destroy() works. | |
96 | * If it returns != SR_OK (or segfaults) this test will fail. | |
97 | */ | |
98 | START_TEST(test_session_destroy) | |
99 | { | |
100 | int ret; | |
101 | struct sr_session *sess; | |
102 | ||
ca1c21ca | 103 | sr_session_new(srtest_ctx, &sess); |
41723529 UH |
104 | ret = sr_session_destroy(sess); |
105 | fail_unless(ret == SR_OK, "sr_session_destroy() failed: %d.", ret); | |
106 | } | |
107 | END_TEST | |
108 | ||
109 | /* | |
110 | * Check whether sr_session_destroy() fails for bogus sessions. | |
111 | * If it returns SR_OK (or segfaults) this test will fail. | |
112 | */ | |
113 | START_TEST(test_session_destroy_bogus) | |
114 | { | |
115 | int ret; | |
116 | ||
117 | ret = sr_session_destroy(NULL); | |
118 | fail_unless(ret != SR_OK, "sr_session_destroy() worked."); | |
119 | } | |
120 | END_TEST | |
121 | ||
c8965e54 UH |
122 | START_TEST(test_session_trigger_set_get) |
123 | { | |
124 | int ret; | |
125 | struct sr_session *sess; | |
126 | struct sr_trigger *t1, *t2; | |
127 | ||
ca1c21ca | 128 | sr_session_new(srtest_ctx, &sess); |
c8965e54 UH |
129 | t1 = sr_trigger_new("T1"); |
130 | ||
131 | /* Set a trigger and see if getting it works OK. */ | |
132 | ret = sr_session_trigger_set(sess, t1); | |
133 | fail_unless(ret == SR_OK); | |
134 | t2 = sr_session_trigger_get(sess); | |
135 | fail_unless(t2 != NULL); | |
136 | fail_unless(t1 == t2); | |
137 | fail_unless(g_slist_length(t1->stages) == g_slist_length(t2->stages)); | |
138 | fail_unless(!strcmp(t1->name, t2->name)); | |
139 | ||
140 | sr_session_destroy(sess); | |
141 | } | |
142 | END_TEST | |
143 | ||
144 | START_TEST(test_session_trigger_set_get_null) | |
145 | { | |
146 | int ret; | |
147 | struct sr_session *sess; | |
148 | struct sr_trigger *t; | |
149 | ||
ca1c21ca | 150 | sr_session_new(srtest_ctx, &sess); |
c8965e54 UH |
151 | |
152 | /* Adding a NULL trigger is allowed. */ | |
153 | ret = sr_session_trigger_set(sess, NULL); | |
154 | fail_unless(ret == SR_OK); | |
155 | t = sr_session_trigger_get(sess); | |
156 | fail_unless(t == NULL); | |
157 | ||
158 | sr_session_destroy(sess); | |
159 | } | |
160 | END_TEST | |
161 | ||
162 | START_TEST(test_session_trigger_set_null) | |
163 | { | |
164 | int ret; | |
165 | struct sr_trigger *t; | |
166 | ||
167 | t = sr_trigger_new("T1"); | |
168 | ||
169 | /* NULL session, must not segfault. */ | |
170 | ret = sr_session_trigger_set(NULL, t); | |
171 | fail_unless(ret == SR_ERR_ARG); | |
172 | ||
173 | /* NULL session and NULL trigger, must not segfault. */ | |
174 | ret = sr_session_trigger_set(NULL, NULL); | |
175 | fail_unless(ret == SR_ERR_ARG); | |
176 | } | |
177 | END_TEST | |
178 | ||
179 | START_TEST(test_session_trigger_get_null) | |
180 | { | |
181 | struct sr_trigger *t; | |
182 | ||
183 | /* NULL session, must not segfault. */ | |
184 | t = sr_session_trigger_get(NULL); | |
185 | fail_unless(t == NULL); | |
186 | } | |
187 | END_TEST | |
188 | ||
41723529 UH |
189 | Suite *suite_session(void) |
190 | { | |
191 | Suite *s; | |
192 | TCase *tc; | |
193 | ||
194 | s = suite_create("session"); | |
195 | ||
196 | tc = tcase_create("new_destroy"); | |
98de0c78 | 197 | tcase_add_checked_fixture(tc, srtest_setup, srtest_teardown); |
41723529 UH |
198 | tcase_add_test(tc, test_session_new); |
199 | tcase_add_test(tc, test_session_new_bogus); | |
200 | tcase_add_test(tc, test_session_new_multiple); | |
201 | tcase_add_test(tc, test_session_destroy); | |
202 | tcase_add_test(tc, test_session_destroy_bogus); | |
203 | suite_add_tcase(s, tc); | |
204 | ||
c8965e54 UH |
205 | tc = tcase_create("trigger"); |
206 | tcase_add_checked_fixture(tc, srtest_setup, srtest_teardown); | |
207 | tcase_add_test(tc, test_session_trigger_set_get); | |
208 | tcase_add_test(tc, test_session_trigger_set_get_null); | |
209 | tcase_add_test(tc, test_session_trigger_set_null); | |
210 | tcase_add_test(tc, test_session_trigger_get_null); | |
211 | suite_add_tcase(s, tc); | |
212 | ||
41723529 UH |
213 | return s; |
214 | } |