Commit | Line | Data |
---|---|---|
aa968dde YB |
1 | /* |
2 | * test-seeks.c | |
3 | * | |
4 | * Lib BabelTrace - Seeks test program | |
5 | * | |
6 | * Copyright 2012 - Yannick Brosseau <yannick.brosseau@gmail.com> | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or modify | |
9 | * it under the terms of the GNU General Public License as published by | |
10 | * the Free Software Foundation; under version 2 of the License. | |
11 | * | |
12 | * This program is distributed in the hope that it will be useful, | |
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | * GNU General Public License for more details. | |
16 | * | |
17 | * You should have received a copy of the GNU General Public License along | |
18 | * with this program; if not, write to the Free Software Foundation, Inc., | |
19 | * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. | |
20 | */ | |
38424656 | 21 | |
aa968dde YB |
22 | #include <babeltrace/context.h> |
23 | #include <babeltrace/iterator.h> | |
24 | #include <babeltrace/ctf/iterator.h> | |
9a19a512 | 25 | #include <babeltrace/ctf/events-internal.h> |
c0903f87 | 26 | #include <babeltrace/babeltrace-internal.h> /* For symbol side-effects */ |
aa968dde YB |
27 | |
28 | #include <stdio.h> | |
29 | #include <stdlib.h> | |
30 | #include <errno.h> | |
8099326b | 31 | #include <babeltrace/compat/limits.h> |
aa968dde | 32 | |
1833a3d1 | 33 | #include <tap/tap.h> |
aa968dde | 34 | #include "common.h" |
aa968dde | 35 | |
61cf588b | 36 | #define NR_TESTS 36 |
aa968dde YB |
37 | |
38 | void run_seek_begin(char *path, uint64_t expected_begin) | |
39 | { | |
40 | struct bt_context *ctx; | |
41 | struct bt_ctf_iter *iter; | |
42 | struct bt_ctf_event *event; | |
43 | struct bt_iter_pos newpos; | |
44 | int ret; | |
61cf588b MD |
45 | int64_t timestamp_begin; |
46 | int64_t timestamp_seek_begin; | |
aa968dde YB |
47 | |
48 | /* Open the trace */ | |
49 | ctx = create_context_with_path(path); | |
50 | if (!ctx) { | |
8bbe269d | 51 | diag("Cannot create valid context"); |
513413e1 | 52 | return; |
aa968dde YB |
53 | } |
54 | ||
55 | /* Create iterator with null begin and end */ | |
56 | iter = bt_ctf_iter_create(ctx, NULL, NULL); | |
57 | if (!iter) { | |
8bbe269d | 58 | diag("Cannot create valid iterator"); |
513413e1 | 59 | return; |
aa968dde YB |
60 | } |
61 | ||
62 | event = bt_ctf_iter_read_event(iter); | |
63 | ||
64 | ok(event, "Event valid"); | |
65 | ||
66 | /* Validate that the first timestamp is right */ | |
61cf588b | 67 | ok1(bt_ctf_get_timestamp(event, ×tamp_begin) == 0); |
aa968dde YB |
68 | |
69 | ok1(timestamp_begin == expected_begin); | |
70 | ||
71 | /* Validate that we get the same value after a seek begin */ | |
72 | newpos.type = BT_SEEK_BEGIN; | |
73 | ret = bt_iter_set_pos(bt_ctf_get_iter(iter), &newpos); | |
74 | ||
75 | ok(ret == 0, "Seek begin retval %d", ret); | |
76 | ||
77 | event = bt_ctf_iter_read_event(iter); | |
78 | ||
79 | ok(event, "Event valid"); | |
80 | ||
61cf588b | 81 | ok1(bt_ctf_get_timestamp(event, ×tamp_seek_begin) == 0); |
aa968dde YB |
82 | |
83 | ok1(timestamp_begin == timestamp_seek_begin); | |
84 | ||
85 | bt_context_put(ctx); | |
86 | } | |
87 | ||
88 | ||
89 | void run_seek_last(char *path, uint64_t expected_last) | |
90 | { | |
91 | struct bt_context *ctx; | |
92 | struct bt_ctf_iter *iter; | |
93 | struct bt_ctf_event *event; | |
94 | struct bt_iter_pos newpos; | |
95 | int ret; | |
61cf588b | 96 | int64_t timestamp_last; |
aa968dde YB |
97 | |
98 | /* Open the trace */ | |
99 | ctx = create_context_with_path(path); | |
100 | if (!ctx) { | |
8bbe269d | 101 | diag("Cannot create valid context"); |
513413e1 | 102 | return; |
aa968dde YB |
103 | } |
104 | ||
105 | /* Create iterator with null last and end */ | |
106 | iter = bt_ctf_iter_create(ctx, NULL, NULL); | |
107 | if (!iter) { | |
8bbe269d | 108 | diag("Cannot create valid iterator"); |
513413e1 | 109 | return; |
aa968dde YB |
110 | } |
111 | ||
112 | event = bt_ctf_iter_read_event(iter); | |
113 | ||
114 | ok(event, "Event valid at beginning"); | |
115 | ||
116 | /* Seek to last */ | |
117 | newpos.type = BT_SEEK_LAST; | |
118 | ret = bt_iter_set_pos(bt_ctf_get_iter(iter), &newpos); | |
119 | ||
120 | ok(ret == 0, "Seek last retval %d", ret); | |
121 | ||
122 | event = bt_ctf_iter_read_event(iter); | |
123 | ||
124 | ok(event, "Event valid at last position"); | |
125 | ||
61cf588b | 126 | ok1(bt_ctf_get_timestamp(event, ×tamp_last) == 0); |
aa968dde YB |
127 | |
128 | ok1(timestamp_last == expected_last); | |
129 | ||
130 | /* Try to read next event */ | |
131 | ret = bt_iter_next(bt_ctf_get_iter(iter)); | |
132 | ||
133 | ok(ret == 0, "iter next should return an error"); | |
134 | ||
135 | event = bt_ctf_iter_read_event(iter); | |
136 | ||
137 | ok(event == 0, "Event after last should be invalid"); | |
138 | ||
139 | bt_context_put(ctx); | |
140 | } | |
141 | ||
58cfc173 YB |
142 | void run_seek_time_at_last(char *path, uint64_t expected_last) |
143 | { | |
144 | struct bt_context *ctx; | |
145 | struct bt_ctf_iter *iter; | |
146 | struct bt_ctf_event *event; | |
147 | struct bt_iter_pos newpos; | |
148 | int ret; | |
61cf588b | 149 | int64_t timestamp_last; |
58cfc173 YB |
150 | |
151 | /* Open the trace */ | |
152 | ctx = create_context_with_path(path); | |
153 | if (!ctx) { | |
8bbe269d | 154 | diag("Cannot create valid context"); |
513413e1 | 155 | return; |
58cfc173 YB |
156 | } |
157 | ||
158 | /* Create iterator with null last and end */ | |
159 | iter = bt_ctf_iter_create(ctx, NULL, NULL); | |
160 | if (!iter) { | |
8bbe269d | 161 | diag("Cannot create valid iterator"); |
513413e1 | 162 | return; |
58cfc173 YB |
163 | } |
164 | ||
165 | event = bt_ctf_iter_read_event(iter); | |
166 | ||
167 | ok(event, "Event valid at beginning"); | |
168 | ||
169 | /* Seek to last */ | |
170 | newpos.type = BT_SEEK_TIME; | |
171 | newpos.u.seek_time = expected_last; | |
172 | ret = bt_iter_set_pos(bt_ctf_get_iter(iter), &newpos); | |
173 | ||
174 | ok(ret == 0, "Seek time at last retval %d", ret); | |
175 | ||
176 | event = bt_ctf_iter_read_event(iter); | |
177 | ||
178 | ok(event, "Event valid at last position"); | |
179 | ||
61cf588b | 180 | ok1(bt_ctf_get_timestamp(event, ×tamp_last) == 0); |
58cfc173 YB |
181 | |
182 | ok1(timestamp_last == expected_last); | |
183 | ||
184 | /* Try to read next event */ | |
185 | ret = bt_iter_next(bt_ctf_get_iter(iter)); | |
186 | ||
187 | ok(ret == 0, "iter next should return an error"); | |
188 | ||
189 | event = bt_ctf_iter_read_event(iter); | |
190 | ||
191 | ok(event == 0, "Event after last should be invalid"); | |
192 | ||
193 | bt_context_put(ctx); | |
194 | } | |
195 | ||
52105e87 YB |
196 | void run_seek_cycles(char *path, |
197 | uint64_t expected_begin, | |
198 | uint64_t expected_last) | |
199 | { | |
200 | struct bt_context *ctx; | |
201 | struct bt_ctf_iter *iter; | |
202 | struct bt_ctf_event *event; | |
203 | struct bt_iter_pos newpos; | |
204 | int ret; | |
61cf588b | 205 | int64_t timestamp; |
52105e87 YB |
206 | |
207 | /* Open the trace */ | |
208 | ctx = create_context_with_path(path); | |
209 | if (!ctx) { | |
8bbe269d | 210 | diag("Cannot create valid context"); |
513413e1 | 211 | return; |
52105e87 YB |
212 | } |
213 | ||
214 | /* Create iterator with null last and end */ | |
215 | iter = bt_ctf_iter_create(ctx, NULL, NULL); | |
216 | if (!iter) { | |
8bbe269d | 217 | diag("Cannot create valid iterator"); |
513413e1 | 218 | return; |
52105e87 YB |
219 | } |
220 | ||
221 | event = bt_ctf_iter_read_event(iter); | |
222 | ||
223 | ok(event, "Event valid at beginning"); | |
224 | ||
225 | /* Seek to last */ | |
226 | newpos.type = BT_SEEK_LAST; | |
227 | ret = bt_iter_set_pos(bt_ctf_get_iter(iter), &newpos); | |
228 | ||
229 | ok(ret == 0, "Seek last retval %d", ret); | |
230 | ||
231 | event = bt_ctf_iter_read_event(iter); | |
232 | ||
233 | ok(event, "Event valid at last position"); | |
234 | ||
61cf588b | 235 | ok1(bt_ctf_get_timestamp(event, ×tamp) == 0); |
52105e87 YB |
236 | |
237 | ok1(timestamp == expected_last); | |
238 | ||
239 | /* Try to read next event */ | |
240 | ret = bt_iter_next(bt_ctf_get_iter(iter)); | |
241 | ||
242 | ok(ret == 0, "iter next should return an error"); | |
243 | ||
244 | event = bt_ctf_iter_read_event(iter); | |
245 | ||
246 | ok(event == 0, "Event after last should be invalid"); | |
247 | ||
248 | /* Seek to BEGIN */ | |
249 | newpos.type = BT_SEEK_BEGIN; | |
250 | ret = bt_iter_set_pos(bt_ctf_get_iter(iter), &newpos); | |
251 | ||
252 | ok(ret == 0, "Seek begin retval %d", ret); | |
253 | ||
254 | event = bt_ctf_iter_read_event(iter); | |
255 | ||
256 | ok(event, "Event valid at first position"); | |
257 | ||
61cf588b | 258 | ok1(bt_ctf_get_timestamp(event, ×tamp) == 0); |
52105e87 YB |
259 | |
260 | ok1(timestamp == expected_begin); | |
261 | ||
262 | /* Seek last again */ | |
263 | newpos.type = BT_SEEK_LAST; | |
264 | ret = bt_iter_set_pos(bt_ctf_get_iter(iter), &newpos); | |
265 | ||
266 | ok(ret == 0, "Seek last retval %d", ret); | |
267 | ||
268 | event = bt_ctf_iter_read_event(iter); | |
269 | ||
270 | ok(event, "Event valid at last position"); | |
271 | ||
61cf588b | 272 | ok1(bt_ctf_get_timestamp(event, ×tamp) == 0); |
52105e87 YB |
273 | |
274 | ok1(timestamp == expected_last); | |
275 | ||
276 | bt_context_put(ctx); | |
277 | } | |
278 | ||
aa968dde YB |
279 | int main(int argc, char **argv) |
280 | { | |
281 | char *path; | |
282 | uint64_t expected_begin; | |
283 | uint64_t expected_last; | |
284 | ||
c0903f87 MD |
285 | /* |
286 | * Side-effects ensuring libs are not optimized away by static | |
287 | * linking. | |
288 | */ | |
289 | babeltrace_debug = 0; /* libbabeltrace.la */ | |
290 | opt_clock_offset = 0; /* libbabeltrace-ctf.la */ | |
291 | ||
8bbe269d | 292 | plan_tests(NR_TESTS); |
aa968dde | 293 | |
8bbe269d MJ |
294 | if (argc < 4) { |
295 | diag("Invalid arguments: need a trace path and the start and last timestamp"); | |
296 | exit(1); | |
aa968dde YB |
297 | } |
298 | ||
299 | /* Parse arguments (Trace, begin timestamp) */ | |
300 | path = argv[1]; | |
301 | ||
302 | expected_begin = strtoull(argv[2], NULL, 0); | |
303 | if (ULLONG_MAX == expected_begin && errno == ERANGE) { | |
8bbe269d MJ |
304 | diag("Invalid value for begin timestamp"); |
305 | exit(1); | |
aa968dde YB |
306 | } |
307 | ||
308 | expected_last = strtoull(argv[3], NULL, 0); | |
309 | if (ULLONG_MAX == expected_last && errno == ERANGE) { | |
8bbe269d MJ |
310 | diag("Invalid value for last timestamp"); |
311 | exit(1); | |
aa968dde YB |
312 | } |
313 | ||
314 | run_seek_begin(path, expected_begin); | |
58cfc173 | 315 | run_seek_time_at_last(path, expected_last); |
aa968dde | 316 | run_seek_last(path, expected_last); |
52105e87 | 317 | run_seek_cycles(path, expected_begin, expected_last); |
aa968dde YB |
318 | |
319 | return exit_status(); | |
320 | } |