2 * QTest testcase for the ptimer
4 * Copyright (c) 2016 Dmitry Osipenko <digetx@gmail.com>
6 * This work is licensed under the terms of the GNU GPL, version 2 or later.
7 * See the COPYING file in the top-level directory.
11 #include "qemu/osdep.h"
12 #include <glib/gprintf.h>
14 #include "qemu/main-loop.h"
15 #include "hw/ptimer.h"
18 #include "ptimer-test.h"
20 static bool triggered
;
22 static void ptimer_trigger(void *opaque
)
27 static void ptimer_test_expire_qemu_timers(int64_t expire_time
,
30 QEMUTimerList
*timer_list
= main_loop_tlg
.tl
[type
];
31 QEMUTimer
*t
= timer_list
->active_timers
.next
;
34 if (t
->expire_time
== expire_time
) {
46 static void ptimer_test_set_qemu_time_ns(int64_t ns
)
48 ptimer_test_time_ns
= ns
;
51 static void qemu_clock_step(uint64_t ns
)
53 int64_t deadline
= qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL
,
55 int64_t advanced_time
= qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
) + ns
;
57 while (deadline
!= -1 && deadline
<= advanced_time
) {
58 ptimer_test_set_qemu_time_ns(deadline
);
59 ptimer_test_expire_qemu_timers(deadline
, QEMU_CLOCK_VIRTUAL
);
60 deadline
= qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL
,
64 ptimer_test_set_qemu_time_ns(advanced_time
);
67 static void check_set_count(gconstpointer arg
)
69 const uint8_t *policy
= arg
;
70 ptimer_state
*ptimer
= ptimer_init(ptimer_trigger
, NULL
, *policy
);
74 ptimer_transaction_begin(ptimer
);
75 ptimer_set_count(ptimer
, 1000);
76 ptimer_transaction_commit(ptimer
);
77 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, 1000);
78 g_assert_false(triggered
);
82 static void check_set_limit(gconstpointer arg
)
84 const uint8_t *policy
= arg
;
85 ptimer_state
*ptimer
= ptimer_init(ptimer_trigger
, NULL
, *policy
);
89 ptimer_transaction_begin(ptimer
);
90 ptimer_set_limit(ptimer
, 1000, 0);
91 ptimer_transaction_commit(ptimer
);
92 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, 0);
93 g_assert_cmpuint(ptimer_get_limit(ptimer
), ==, 1000);
94 g_assert_false(triggered
);
96 ptimer_transaction_begin(ptimer
);
97 ptimer_set_limit(ptimer
, 2000, 1);
98 ptimer_transaction_commit(ptimer
);
99 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, 2000);
100 g_assert_cmpuint(ptimer_get_limit(ptimer
), ==, 2000);
101 g_assert_false(triggered
);
105 static void check_oneshot(gconstpointer arg
)
107 const uint8_t *policy
= arg
;
108 ptimer_state
*ptimer
= ptimer_init(ptimer_trigger
, NULL
, *policy
);
109 bool no_round_down
= (*policy
& PTIMER_POLICY_NO_COUNTER_ROUND_DOWN
);
113 ptimer_transaction_begin(ptimer
);
114 ptimer_set_period(ptimer
, 2000000);
115 ptimer_set_count(ptimer
, 10);
116 ptimer_run(ptimer
, 1);
117 ptimer_transaction_commit(ptimer
);
119 qemu_clock_step(2000000 * 2 + 1);
121 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, no_round_down
? 8 : 7);
122 g_assert_false(triggered
);
124 ptimer_transaction_begin(ptimer
);
126 ptimer_transaction_commit(ptimer
);
128 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, no_round_down
? 8 : 7);
129 g_assert_false(triggered
);
131 qemu_clock_step(2000000 * 11);
133 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, no_round_down
? 8 : 7);
134 g_assert_false(triggered
);
136 ptimer_transaction_begin(ptimer
);
137 ptimer_run(ptimer
, 1);
138 ptimer_transaction_commit(ptimer
);
140 qemu_clock_step(2000000 * 7 + 1);
142 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, no_round_down
? 1 : 0);
145 g_assert_false(triggered
);
147 g_assert_true(triggered
);
152 qemu_clock_step(2000000);
154 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, 0);
157 g_assert_true(triggered
);
161 g_assert_false(triggered
);
164 qemu_clock_step(4000000);
166 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, 0);
167 g_assert_false(triggered
);
169 ptimer_transaction_begin(ptimer
);
170 ptimer_set_count(ptimer
, 10);
171 ptimer_transaction_commit(ptimer
);
173 qemu_clock_step(20000000 + 1);
175 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, 10);
176 g_assert_false(triggered
);
178 ptimer_transaction_begin(ptimer
);
179 ptimer_set_limit(ptimer
, 9, 1);
180 ptimer_transaction_commit(ptimer
);
182 qemu_clock_step(20000000 + 1);
184 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, 9);
185 g_assert_false(triggered
);
187 ptimer_transaction_begin(ptimer
);
188 ptimer_run(ptimer
, 1);
189 ptimer_transaction_commit(ptimer
);
191 qemu_clock_step(2000000 + 1);
193 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, no_round_down
? 8 : 7);
194 g_assert_false(triggered
);
196 ptimer_transaction_begin(ptimer
);
197 ptimer_set_count(ptimer
, 20);
198 ptimer_transaction_commit(ptimer
);
200 qemu_clock_step(2000000 * 19 + 1);
202 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, no_round_down
? 1 : 0);
203 g_assert_false(triggered
);
205 qemu_clock_step(2000000);
207 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, 0);
208 g_assert_true(triggered
);
210 ptimer_transaction_begin(ptimer
);
212 ptimer_transaction_commit(ptimer
);
216 qemu_clock_step(2000000 * 12 + 1);
218 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, 0);
219 g_assert_false(triggered
);
223 static void check_periodic(gconstpointer arg
)
225 const uint8_t *policy
= arg
;
226 ptimer_state
*ptimer
= ptimer_init(ptimer_trigger
, NULL
, *policy
);
227 bool wrap_policy
= (*policy
& PTIMER_POLICY_WRAP_AFTER_ONE_PERIOD
);
228 bool no_immediate_trigger
= (*policy
& PTIMER_POLICY_NO_IMMEDIATE_TRIGGER
);
229 bool no_immediate_reload
= (*policy
& PTIMER_POLICY_NO_IMMEDIATE_RELOAD
);
230 bool no_round_down
= (*policy
& PTIMER_POLICY_NO_COUNTER_ROUND_DOWN
);
231 bool trig_only_on_dec
= (*policy
& PTIMER_POLICY_TRIGGER_ONLY_ON_DECREMENT
);
235 ptimer_transaction_begin(ptimer
);
236 ptimer_set_period(ptimer
, 2000000);
237 ptimer_set_limit(ptimer
, 10, 1);
238 ptimer_run(ptimer
, 0);
239 ptimer_transaction_commit(ptimer
);
241 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, 10);
242 g_assert_false(triggered
);
246 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, no_round_down
? 10 : 9);
247 g_assert_false(triggered
);
249 qemu_clock_step(2000000 * 10 - 1);
251 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, wrap_policy
? 0 : 10);
252 g_assert_true(triggered
);
256 g_assert_cmpuint(ptimer_get_count(ptimer
), ==,
257 wrap_policy
? 0 : (no_round_down
? 10 : 9));
258 g_assert_true(triggered
);
262 qemu_clock_step(2000000);
264 g_assert_cmpuint(ptimer_get_count(ptimer
), ==,
265 (no_round_down
? 9 : 8) + (wrap_policy
? 1 : 0));
266 g_assert_false(triggered
);
268 ptimer_transaction_begin(ptimer
);
269 ptimer_set_count(ptimer
, 20);
270 ptimer_transaction_commit(ptimer
);
272 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, 20);
273 g_assert_false(triggered
);
277 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, no_round_down
? 20 : 19);
278 g_assert_false(triggered
);
280 qemu_clock_step(2000000 * 11 + 1);
282 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, no_round_down
? 9 : 8);
283 g_assert_false(triggered
);
285 qemu_clock_step(2000000 * 10);
287 g_assert_cmpuint(ptimer_get_count(ptimer
), ==,
288 (no_round_down
? 9 : 8) + (wrap_policy
? 1 : 0));
289 g_assert_true(triggered
);
293 ptimer_transaction_begin(ptimer
);
294 ptimer_set_count(ptimer
, 3);
295 ptimer_transaction_commit(ptimer
);
297 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, 3);
298 g_assert_false(triggered
);
302 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, no_round_down
? 3 : 2);
303 g_assert_false(triggered
);
305 qemu_clock_step(2000000 * 4);
307 g_assert_cmpuint(ptimer_get_count(ptimer
), ==,
308 (no_round_down
? 9 : 8) + (wrap_policy
? 1 : 0));
309 g_assert_true(triggered
);
311 ptimer_transaction_begin(ptimer
);
313 ptimer_transaction_commit(ptimer
);
316 qemu_clock_step(2000000);
318 g_assert_cmpuint(ptimer_get_count(ptimer
), ==,
319 (no_round_down
? 9 : 8) + (wrap_policy
? 1 : 0));
320 g_assert_false(triggered
);
322 ptimer_transaction_begin(ptimer
);
323 ptimer_set_count(ptimer
, 3);
324 ptimer_run(ptimer
, 0);
325 ptimer_transaction_commit(ptimer
);
327 qemu_clock_step(2000000 * 3 + 1);
329 g_assert_cmpuint(ptimer_get_count(ptimer
), ==,
330 wrap_policy
? 0 : (no_round_down
? 10 : 9));
331 g_assert_true(triggered
);
335 qemu_clock_step(2000000);
337 g_assert_cmpuint(ptimer_get_count(ptimer
), ==,
338 (no_round_down
? 9 : 8) + (wrap_policy
? 1 : 0));
339 g_assert_false(triggered
);
341 ptimer_transaction_begin(ptimer
);
342 ptimer_set_count(ptimer
, 0);
343 ptimer_transaction_commit(ptimer
);
344 g_assert_cmpuint(ptimer_get_count(ptimer
), ==,
345 no_immediate_reload
? 0 : 10);
347 if (no_immediate_trigger
|| trig_only_on_dec
) {
348 g_assert_false(triggered
);
350 g_assert_true(triggered
);
357 if (no_immediate_reload
) {
358 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, 0);
359 g_assert_false(triggered
);
361 qemu_clock_step(2000000);
363 if (no_immediate_trigger
) {
364 g_assert_true(triggered
);
366 g_assert_false(triggered
);
372 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, no_round_down
? 10 : 9);
373 g_assert_false(triggered
);
375 qemu_clock_step(2000000 * 12);
377 g_assert_cmpuint(ptimer_get_count(ptimer
), ==,
378 (no_round_down
? 8 : 7) + (wrap_policy
? 1 : 0));
379 g_assert_true(triggered
);
381 ptimer_transaction_begin(ptimer
);
383 ptimer_transaction_commit(ptimer
);
387 qemu_clock_step(2000000 * 10);
389 g_assert_cmpuint(ptimer_get_count(ptimer
), ==,
390 (no_round_down
? 8 : 7) + (wrap_policy
? 1 : 0));
391 g_assert_false(triggered
);
393 ptimer_transaction_begin(ptimer
);
394 ptimer_run(ptimer
, 0);
395 ptimer_transaction_commit(ptimer
);
397 ptimer_transaction_begin(ptimer
);
398 ptimer_set_period(ptimer
, 0);
399 ptimer_transaction_commit(ptimer
);
401 qemu_clock_step(2000000 + 1);
403 g_assert_cmpuint(ptimer_get_count(ptimer
), ==,
404 (no_round_down
? 8 : 7) + (wrap_policy
? 1 : 0));
405 g_assert_false(triggered
);
409 static void check_on_the_fly_mode_change(gconstpointer arg
)
411 const uint8_t *policy
= arg
;
412 ptimer_state
*ptimer
= ptimer_init(ptimer_trigger
, NULL
, *policy
);
413 bool wrap_policy
= (*policy
& PTIMER_POLICY_WRAP_AFTER_ONE_PERIOD
);
414 bool no_round_down
= (*policy
& PTIMER_POLICY_NO_COUNTER_ROUND_DOWN
);
418 ptimer_transaction_begin(ptimer
);
419 ptimer_set_period(ptimer
, 2000000);
420 ptimer_set_limit(ptimer
, 10, 1);
421 ptimer_run(ptimer
, 1);
422 ptimer_transaction_commit(ptimer
);
424 qemu_clock_step(2000000 * 9 + 1);
426 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, no_round_down
? 1 : 0);
427 g_assert_false(triggered
);
429 ptimer_transaction_begin(ptimer
);
430 ptimer_run(ptimer
, 0);
431 ptimer_transaction_commit(ptimer
);
433 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, no_round_down
? 1 : 0);
434 g_assert_false(triggered
);
436 qemu_clock_step(2000000);
438 g_assert_cmpuint(ptimer_get_count(ptimer
), ==,
439 wrap_policy
? 0 : (no_round_down
? 10 : 9));
440 g_assert_true(triggered
);
444 qemu_clock_step(2000000 * 9);
446 ptimer_transaction_begin(ptimer
);
447 ptimer_run(ptimer
, 1);
448 ptimer_transaction_commit(ptimer
);
450 g_assert_cmpuint(ptimer_get_count(ptimer
), ==,
451 (no_round_down
? 1 : 0) + (wrap_policy
? 1 : 0));
452 g_assert_false(triggered
);
454 qemu_clock_step(2000000 * 3);
456 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, 0);
457 g_assert_true(triggered
);
461 static void check_on_the_fly_period_change(gconstpointer arg
)
463 const uint8_t *policy
= arg
;
464 ptimer_state
*ptimer
= ptimer_init(ptimer_trigger
, NULL
, *policy
);
465 bool no_round_down
= (*policy
& PTIMER_POLICY_NO_COUNTER_ROUND_DOWN
);
469 ptimer_transaction_begin(ptimer
);
470 ptimer_set_period(ptimer
, 2000000);
471 ptimer_set_limit(ptimer
, 8, 1);
472 ptimer_run(ptimer
, 1);
473 ptimer_transaction_commit(ptimer
);
475 qemu_clock_step(2000000 * 4 + 1);
477 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, no_round_down
? 4 : 3);
478 g_assert_false(triggered
);
480 ptimer_transaction_begin(ptimer
);
481 ptimer_set_period(ptimer
, 4000000);
482 ptimer_transaction_commit(ptimer
);
483 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, no_round_down
? 4 : 3);
485 qemu_clock_step(4000000 * 2 + 1);
487 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, no_round_down
? 2 : 0);
488 g_assert_false(triggered
);
490 qemu_clock_step(4000000 * 2);
492 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, 0);
493 g_assert_true(triggered
);
497 static void check_on_the_fly_freq_change(gconstpointer arg
)
499 const uint8_t *policy
= arg
;
500 ptimer_state
*ptimer
= ptimer_init(ptimer_trigger
, NULL
, *policy
);
501 bool no_round_down
= (*policy
& PTIMER_POLICY_NO_COUNTER_ROUND_DOWN
);
505 ptimer_transaction_begin(ptimer
);
506 ptimer_set_freq(ptimer
, 500);
507 ptimer_set_limit(ptimer
, 8, 1);
508 ptimer_run(ptimer
, 1);
509 ptimer_transaction_commit(ptimer
);
511 qemu_clock_step(2000000 * 4 + 1);
513 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, no_round_down
? 4 : 3);
514 g_assert_false(triggered
);
516 ptimer_transaction_begin(ptimer
);
517 ptimer_set_freq(ptimer
, 250);
518 ptimer_transaction_commit(ptimer
);
519 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, no_round_down
? 4 : 3);
521 qemu_clock_step(2000000 * 4 + 1);
523 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, no_round_down
? 2 : 0);
524 g_assert_false(triggered
);
526 qemu_clock_step(2000000 * 4);
528 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, 0);
529 g_assert_true(triggered
);
533 static void check_run_with_period_0(gconstpointer arg
)
535 const uint8_t *policy
= arg
;
536 ptimer_state
*ptimer
= ptimer_init(ptimer_trigger
, NULL
, *policy
);
540 ptimer_transaction_begin(ptimer
);
541 ptimer_set_count(ptimer
, 99);
542 ptimer_run(ptimer
, 1);
543 ptimer_transaction_commit(ptimer
);
545 qemu_clock_step(10 * NANOSECONDS_PER_SECOND
);
547 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, 99);
548 g_assert_false(triggered
);
552 static void check_run_with_delta_0(gconstpointer arg
)
554 const uint8_t *policy
= arg
;
555 ptimer_state
*ptimer
= ptimer_init(ptimer_trigger
, NULL
, *policy
);
556 bool wrap_policy
= (*policy
& PTIMER_POLICY_WRAP_AFTER_ONE_PERIOD
);
557 bool no_immediate_trigger
= (*policy
& PTIMER_POLICY_NO_IMMEDIATE_TRIGGER
);
558 bool no_immediate_reload
= (*policy
& PTIMER_POLICY_NO_IMMEDIATE_RELOAD
);
559 bool no_round_down
= (*policy
& PTIMER_POLICY_NO_COUNTER_ROUND_DOWN
);
560 bool trig_only_on_dec
= (*policy
& PTIMER_POLICY_TRIGGER_ONLY_ON_DECREMENT
);
564 ptimer_transaction_begin(ptimer
);
565 ptimer_set_period(ptimer
, 2000000);
566 ptimer_set_limit(ptimer
, 99, 0);
567 ptimer_run(ptimer
, 1);
568 ptimer_transaction_commit(ptimer
);
569 g_assert_cmpuint(ptimer_get_count(ptimer
), ==,
570 no_immediate_reload
? 0 : 99);
572 if (no_immediate_trigger
|| trig_only_on_dec
) {
573 g_assert_false(triggered
);
575 g_assert_true(triggered
);
580 if (no_immediate_trigger
|| no_immediate_reload
) {
581 qemu_clock_step(2000000 + 1);
583 g_assert_cmpuint(ptimer_get_count(ptimer
), ==,
584 no_immediate_reload
? 0 : (no_round_down
? 98 : 97));
586 if (no_immediate_trigger
&& no_immediate_reload
) {
587 g_assert_true(triggered
);
591 g_assert_false(triggered
);
594 ptimer_transaction_begin(ptimer
);
595 ptimer_set_count(ptimer
, 99);
596 ptimer_run(ptimer
, 1);
597 ptimer_transaction_commit(ptimer
);
600 qemu_clock_step(2000000 + 1);
602 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, no_round_down
? 98 : 97);
603 g_assert_false(triggered
);
605 qemu_clock_step(2000000 * 97);
607 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, no_round_down
? 1 : 0);
608 g_assert_false(triggered
);
610 qemu_clock_step(2000000 * 2);
612 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, 0);
613 g_assert_true(triggered
);
617 ptimer_transaction_begin(ptimer
);
618 ptimer_set_count(ptimer
, 0);
619 ptimer_run(ptimer
, 0);
620 ptimer_transaction_commit(ptimer
);
621 g_assert_cmpuint(ptimer_get_count(ptimer
), ==,
622 no_immediate_reload
? 0 : 99);
624 if (no_immediate_trigger
|| trig_only_on_dec
) {
625 g_assert_false(triggered
);
627 g_assert_true(triggered
);
634 if (no_immediate_reload
) {
635 qemu_clock_step(2000000);
638 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, no_round_down
? 99 : 98);
640 if (no_immediate_reload
&& no_immediate_trigger
) {
641 g_assert_true(triggered
);
643 g_assert_false(triggered
);
648 qemu_clock_step(2000000);
650 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, no_round_down
? 98 : 97);
651 g_assert_false(triggered
);
653 qemu_clock_step(2000000 * 98);
655 g_assert_cmpuint(ptimer_get_count(ptimer
), ==,
656 wrap_policy
? 0 : (no_round_down
? 99 : 98));
657 g_assert_true(triggered
);
659 ptimer_transaction_begin(ptimer
);
661 ptimer_transaction_commit(ptimer
);
665 static void check_periodic_with_load_0(gconstpointer arg
)
667 const uint8_t *policy
= arg
;
668 ptimer_state
*ptimer
= ptimer_init(ptimer_trigger
, NULL
, *policy
);
669 bool continuous_trigger
= (*policy
& PTIMER_POLICY_CONTINUOUS_TRIGGER
);
670 bool no_immediate_trigger
= (*policy
& PTIMER_POLICY_NO_IMMEDIATE_TRIGGER
);
671 bool trig_only_on_dec
= (*policy
& PTIMER_POLICY_TRIGGER_ONLY_ON_DECREMENT
);
675 ptimer_transaction_begin(ptimer
);
676 ptimer_set_period(ptimer
, 2000000);
677 ptimer_run(ptimer
, 0);
678 ptimer_transaction_commit(ptimer
);
680 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, 0);
682 if (no_immediate_trigger
|| trig_only_on_dec
) {
683 g_assert_false(triggered
);
685 g_assert_true(triggered
);
690 qemu_clock_step(2000000 + 1);
692 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, 0);
694 if (continuous_trigger
|| no_immediate_trigger
) {
695 g_assert_true(triggered
);
697 g_assert_false(triggered
);
702 ptimer_transaction_begin(ptimer
);
703 ptimer_set_count(ptimer
, 10);
704 ptimer_run(ptimer
, 0);
705 ptimer_transaction_commit(ptimer
);
707 qemu_clock_step(2000000 * 10 + 1);
709 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, 0);
710 g_assert_true(triggered
);
714 qemu_clock_step(2000000 + 1);
716 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, 0);
718 if (continuous_trigger
) {
719 g_assert_true(triggered
);
721 g_assert_false(triggered
);
724 ptimer_transaction_begin(ptimer
);
726 ptimer_transaction_commit(ptimer
);
730 static void check_oneshot_with_load_0(gconstpointer arg
)
732 const uint8_t *policy
= arg
;
733 ptimer_state
*ptimer
= ptimer_init(ptimer_trigger
, NULL
, *policy
);
734 bool no_immediate_trigger
= (*policy
& PTIMER_POLICY_NO_IMMEDIATE_TRIGGER
);
735 bool trig_only_on_dec
= (*policy
& PTIMER_POLICY_TRIGGER_ONLY_ON_DECREMENT
);
739 ptimer_transaction_begin(ptimer
);
740 ptimer_set_period(ptimer
, 2000000);
741 ptimer_run(ptimer
, 1);
742 ptimer_transaction_commit(ptimer
);
744 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, 0);
746 if (no_immediate_trigger
|| trig_only_on_dec
) {
747 g_assert_false(triggered
);
749 g_assert_true(triggered
);
754 qemu_clock_step(2000000 + 1);
756 g_assert_cmpuint(ptimer_get_count(ptimer
), ==, 0);
758 if (no_immediate_trigger
) {
759 g_assert_true(triggered
);
761 g_assert_false(triggered
);
767 static void add_ptimer_tests(uint8_t policy
)
769 char policy_name
[256] = "";
772 if (policy
== PTIMER_POLICY_DEFAULT
) {
773 g_sprintf(policy_name
, "default");
776 if (policy
& PTIMER_POLICY_WRAP_AFTER_ONE_PERIOD
) {
777 g_strlcat(policy_name
, "wrap_after_one_period,", 256);
780 if (policy
& PTIMER_POLICY_CONTINUOUS_TRIGGER
) {
781 g_strlcat(policy_name
, "continuous_trigger,", 256);
784 if (policy
& PTIMER_POLICY_NO_IMMEDIATE_TRIGGER
) {
785 g_strlcat(policy_name
, "no_immediate_trigger,", 256);
788 if (policy
& PTIMER_POLICY_NO_IMMEDIATE_RELOAD
) {
789 g_strlcat(policy_name
, "no_immediate_reload,", 256);
792 if (policy
& PTIMER_POLICY_NO_COUNTER_ROUND_DOWN
) {
793 g_strlcat(policy_name
, "no_counter_rounddown,", 256);
796 if (policy
& PTIMER_POLICY_TRIGGER_ONLY_ON_DECREMENT
) {
797 g_strlcat(policy_name
, "trigger_only_on_decrement,", 256);
800 g_test_add_data_func_full(
801 tmp
= g_strdup_printf("/ptimer/set_count policy=%s", policy_name
),
802 g_memdup(&policy
, 1), check_set_count
, g_free
);
805 g_test_add_data_func_full(
806 tmp
= g_strdup_printf("/ptimer/set_limit policy=%s", policy_name
),
807 g_memdup(&policy
, 1), check_set_limit
, g_free
);
810 g_test_add_data_func_full(
811 tmp
= g_strdup_printf("/ptimer/oneshot policy=%s", policy_name
),
812 g_memdup(&policy
, 1), check_oneshot
, g_free
);
815 g_test_add_data_func_full(
816 tmp
= g_strdup_printf("/ptimer/periodic policy=%s", policy_name
),
817 g_memdup(&policy
, 1), check_periodic
, g_free
);
820 g_test_add_data_func_full(
821 tmp
= g_strdup_printf("/ptimer/on_the_fly_mode_change policy=%s",
823 g_memdup(&policy
, 1), check_on_the_fly_mode_change
, g_free
);
826 g_test_add_data_func_full(
827 tmp
= g_strdup_printf("/ptimer/on_the_fly_period_change policy=%s",
829 g_memdup(&policy
, 1), check_on_the_fly_period_change
, g_free
);
832 g_test_add_data_func_full(
833 tmp
= g_strdup_printf("/ptimer/on_the_fly_freq_change policy=%s",
835 g_memdup(&policy
, 1), check_on_the_fly_freq_change
, g_free
);
838 g_test_add_data_func_full(
839 tmp
= g_strdup_printf("/ptimer/run_with_period_0 policy=%s",
841 g_memdup(&policy
, 1), check_run_with_period_0
, g_free
);
844 g_test_add_data_func_full(
845 tmp
= g_strdup_printf("/ptimer/run_with_delta_0 policy=%s",
847 g_memdup(&policy
, 1), check_run_with_delta_0
, g_free
);
850 g_test_add_data_func_full(
851 tmp
= g_strdup_printf("/ptimer/periodic_with_load_0 policy=%s",
853 g_memdup(&policy
, 1), check_periodic_with_load_0
, g_free
);
856 g_test_add_data_func_full(
857 tmp
= g_strdup_printf("/ptimer/oneshot_with_load_0 policy=%s",
859 g_memdup(&policy
, 1), check_oneshot_with_load_0
, g_free
);
863 static void add_all_ptimer_policies_comb_tests(void)
865 int last_policy
= PTIMER_POLICY_TRIGGER_ONLY_ON_DECREMENT
;
866 int policy
= PTIMER_POLICY_DEFAULT
;
868 for (; policy
< (last_policy
<< 1); policy
++) {
869 if ((policy
& PTIMER_POLICY_TRIGGER_ONLY_ON_DECREMENT
) &&
870 (policy
& PTIMER_POLICY_NO_IMMEDIATE_TRIGGER
)) {
871 /* Incompatible policy flag settings -- don't try to test them */
874 add_ptimer_tests(policy
);
878 int main(int argc
, char **argv
)
882 g_test_init(&argc
, &argv
, NULL
);
884 for (i
= 0; i
< QEMU_CLOCK_MAX
; i
++) {
885 main_loop_tlg
.tl
[i
] = g_new0(QEMUTimerList
, 1);
888 add_all_ptimer_policies_comb_tests();
890 qtest_allowed
= true;