Skip to content

Commit d49899a

Browse files
mprsemprse
committed
Provide fix for Timer and LowPowerTimer tests (time accumulation).
LowPoterTimer test gives sometimes failed result while testing measured time accumulation. The check which verifies if total number of elapsed milliseconds is valid fails. Test assumes that delta value equal to 1 ms is sufficient for all test cases, which is not true since in case where time measurement is performed few times in sequence the measurement error also accumulates and 1 ms might be not enough. To solve this problem delta value for milliseconds tests must be updated.
1 parent 97e2d4a commit d49899a

File tree

2 files changed

+91
-85
lines changed

2 files changed

+91
-85
lines changed

‎TESTS/mbed_drivers/lp_timer/main.cpp

Lines changed: 39 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -53,14 +53,17 @@ extern uint32_t SystemCoreClock;
5353
* For NRF51_DK DELTA = (40000 / 16000000) * 1000000 = 2500[us]
5454
*/
5555
#define US_PER_SEC 1000000
56+
#define US_PER_MSEC 1000
5657
#define TOLERANCE_FACTOR 40000.0f
5758
#define US_FACTOR 1000000.0f
5859

5960
static const int delta_sys_clk_us = ((int) (TOLERANCE_FACTOR / (float) SystemCoreClock * US_FACTOR));
6061

61-
#define DELTA_US delta_sys_clk_us
62-
#define DELTA_S ((float)delta_sys_clk_us/US_PER_SEC)
63-
#define DELTA_MS 1
62+
/* When test performs time measurement using Timer in sequence, then measurement error accumulates
63+
* in the successive attempts. */
64+
#define DELTA_US(i) (delta_sys_clk_us * i)
65+
#define DELTA_S(i) ((float)delta_sys_clk_us * i / US_PER_SEC)
66+
#define DELTA_MS(i) (1 + ( (i * delta_sys_clk_us) / US_PER_MSEC))
6467

6568
/* This test verifies if low power timer is stopped after
6669
* creation.
@@ -115,10 +118,10 @@ void test_lptimer_time_accumulation()
115118
lp_timer.stop();
116119

117120
/* Check results - totally 10 ms have elapsed. */
118-
TEST_ASSERT_FLOAT_WITHIN(DELTA_S, 0.010f, lp_timer.read());
119-
TEST_ASSERT_INT32_WITHIN(DELTA_MS, 10, lp_timer.read_ms());
120-
TEST_ASSERT_INT32_WITHIN(DELTA_US, 10000, lp_timer.read_us());
121-
TEST_ASSERT_UINT64_WITHIN(DELTA_US, 10000, lp_timer.read_high_resolution_us());
121+
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(1), 0.010f, lp_timer.read());
122+
TEST_ASSERT_INT32_WITHIN(DELTA_MS(1), 10, lp_timer.read_ms());
123+
TEST_ASSERT_INT32_WITHIN(DELTA_US(1), 10000, lp_timer.read_us());
124+
TEST_ASSERT_UINT64_WITHIN(DELTA_US(1), 10000, lp_timer.read_high_resolution_us());
122125

123126
/* Wait 50 ms - this is done to show that time elapsed when
124127
* the timer is stopped does not have influence on the
@@ -137,10 +140,10 @@ void test_lptimer_time_accumulation()
137140
lp_timer.stop();
138141

139142
/* Check results - totally 30 ms have elapsed. */
140-
TEST_ASSERT_FLOAT_WITHIN(2 * DELTA_S, 0.030f, lp_timer.read());
141-
TEST_ASSERT_INT32_WITHIN(DELTA_MS, 30, lp_timer.read_ms());
142-
TEST_ASSERT_INT32_WITHIN(2 * DELTA_US, 30000, lp_timer.read_us());
143-
TEST_ASSERT_UINT64_WITHIN(2 * DELTA_US, 30000, lp_timer.read_high_resolution_us());
143+
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(2), 0.030f, lp_timer.read());
144+
TEST_ASSERT_INT32_WITHIN(DELTA_MS(2), 30, lp_timer.read_ms());
145+
TEST_ASSERT_INT32_WITHIN(DELTA_US(2), 30000, lp_timer.read_us());
146+
TEST_ASSERT_UINT64_WITHIN(DELTA_US(2), 30000, lp_timer.read_high_resolution_us());
144147

145148
/* Wait 50 ms - this is done to show that time elapsed when
146149
* the timer is stopped does not have influence on the
@@ -158,10 +161,10 @@ void test_lptimer_time_accumulation()
158161
lp_timer.stop();
159162

160163
/* Check results - totally 60 ms have elapsed. */
161-
TEST_ASSERT_FLOAT_WITHIN(3 * DELTA_S, 0.060f, lp_timer.read());
162-
TEST_ASSERT_INT32_WITHIN(DELTA_MS, 60, lp_timer.read_ms());
163-
TEST_ASSERT_INT32_WITHIN(3 * DELTA_US, 60000, lp_timer.read_us());
164-
TEST_ASSERT_UINT64_WITHIN(3 * DELTA_US, 60000, lp_timer.read_high_resolution_us());
164+
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(3), 0.060f, lp_timer.read());
165+
TEST_ASSERT_INT32_WITHIN(DELTA_MS(3), 60, lp_timer.read_ms());
166+
TEST_ASSERT_INT32_WITHIN(DELTA_US(3), 60000, lp_timer.read_us());
167+
TEST_ASSERT_UINT64_WITHIN(DELTA_US(3), 60000, lp_timer.read_high_resolution_us());
165168

166169
/* Wait 50 ms - this is done to show that time elapsed when
167170
* the timer is stopped does not have influence on the
@@ -180,10 +183,10 @@ void test_lptimer_time_accumulation()
180183
lp_timer.stop();
181184

182185
/* Check results - totally 5060 ms have elapsed. */
183-
TEST_ASSERT_FLOAT_WITHIN(4 * DELTA_S, 1.060f, lp_timer.read());
184-
TEST_ASSERT_INT32_WITHIN(DELTA_MS, 1060, lp_timer.read_ms());
185-
TEST_ASSERT_INT32_WITHIN(4 * DELTA_US, 1060000, lp_timer.read_us());
186-
TEST_ASSERT_UINT64_WITHIN(4 * DELTA_US, 1060000, lp_timer.read_high_resolution_us());
186+
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(4), 1.060f, lp_timer.read());
187+
TEST_ASSERT_INT32_WITHIN(DELTA_MS(4), 1060, lp_timer.read_ms());
188+
TEST_ASSERT_INT32_WITHIN(DELTA_US(4), 1060000, lp_timer.read_us());
189+
TEST_ASSERT_UINT64_WITHIN(DELTA_US(4), 1060000, lp_timer.read_high_resolution_us());
187190
}
188191

189192
/* This test verifies if reset() function resets the
@@ -209,10 +212,10 @@ void test_lptimer_reset()
209212
lp_timer.stop();
210213

211214
/* Check results - totally 10 ms elapsed. */
212-
TEST_ASSERT_FLOAT_WITHIN(DELTA_S, 0.010f, lp_timer.read());
213-
TEST_ASSERT_INT32_WITHIN(DELTA_MS, 10, lp_timer.read_ms());
214-
TEST_ASSERT_INT32_WITHIN(DELTA_US, 10000, lp_timer.read_us());
215-
TEST_ASSERT_UINT64_WITHIN(DELTA_US, 10000, lp_timer.read_high_resolution_us());
215+
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(1), 0.010f, lp_timer.read());
216+
TEST_ASSERT_INT32_WITHIN(DELTA_MS(1), 10, lp_timer.read_ms());
217+
TEST_ASSERT_INT32_WITHIN(DELTA_US(1), 10000, lp_timer.read_us());
218+
TEST_ASSERT_UINT64_WITHIN(DELTA_US(1), 10000, lp_timer.read_high_resolution_us());
216219

217220
/* Reset the timer - previous measured time should be lost now. */
218221
lp_timer.reset();
@@ -227,10 +230,10 @@ void test_lptimer_reset()
227230
lp_timer.stop();
228231

229232
/* Check results - 20 ms elapsed since the reset. */
230-
TEST_ASSERT_FLOAT_WITHIN(DELTA_S, 0.020f, lp_timer.read());
231-
TEST_ASSERT_INT32_WITHIN(DELTA_MS, 20, lp_timer.read_ms());
232-
TEST_ASSERT_INT32_WITHIN(DELTA_US, 20000, lp_timer.read_us());
233-
TEST_ASSERT_UINT64_WITHIN(DELTA_US, 20000, lp_timer.read_high_resolution_us());
233+
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(1), 0.020f, lp_timer.read());
234+
TEST_ASSERT_INT32_WITHIN(DELTA_MS(1), 20, lp_timer.read_ms());
235+
TEST_ASSERT_INT32_WITHIN(DELTA_US(1), 20000, lp_timer.read_us());
236+
TEST_ASSERT_UINT64_WITHIN(DELTA_US(1), 20000, lp_timer.read_high_resolution_us());
234237
}
235238

236239
/* This test verifies if calling start() for already
@@ -260,10 +263,10 @@ void test_lptimer_start_started_timer()
260263
lp_timer.stop();
261264

262265
/* Check results - 30 ms have elapsed since the first start. */
263-
TEST_ASSERT_FLOAT_WITHIN(2 * DELTA_S, 0.030f, lp_timer.read());
264-
TEST_ASSERT_INT32_WITHIN(DELTA_MS, 30, lp_timer.read_ms());
265-
TEST_ASSERT_INT32_WITHIN(2 * DELTA_US, 30000, lp_timer.read_us());
266-
TEST_ASSERT_UINT64_WITHIN(2 * DELTA_US, 30000, lp_timer.read_high_resolution_us());
266+
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(2), 0.030f, lp_timer.read());
267+
TEST_ASSERT_INT32_WITHIN(DELTA_MS(2), 30, lp_timer.read_ms());
268+
TEST_ASSERT_INT32_WITHIN(DELTA_US(2), 30000, lp_timer.read_us());
269+
TEST_ASSERT_UINT64_WITHIN(DELTA_US(2), 30000, lp_timer.read_high_resolution_us());
267270
}
268271

269272
/* This test verifies low power timer float operator.
@@ -287,7 +290,7 @@ void test_lptimer_float_operator()
287290
lp_timer.stop();
288291

289292
/* Check result - 10 ms elapsed. */
290-
TEST_ASSERT_FLOAT_WITHIN(DELTA_S, 0.010f, (float )(lp_timer));
293+
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(1), 0.010f, (float )(lp_timer));
291294
}
292295

293296
/* This test verifies if time counted by the low power timer is
@@ -313,10 +316,10 @@ void test_lptimer_time_measurement()
313316
lp_timer.stop();
314317

315318
/* Check results - wait_val_us us have elapsed. */
316-
TEST_ASSERT_FLOAT_WITHIN(DELTA_S, (float )wait_val_us / 1000000, lp_timer.read());
317-
TEST_ASSERT_INT32_WITHIN(DELTA_MS, wait_val_us / 1000, lp_timer.read_ms());
318-
TEST_ASSERT_INT32_WITHIN(DELTA_US, wait_val_us, lp_timer.read_us());
319-
TEST_ASSERT_UINT64_WITHIN(DELTA_US, wait_val_us, lp_timer.read_high_resolution_us());
319+
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(1), (float )wait_val_us / 1000000, lp_timer.read());
320+
TEST_ASSERT_INT32_WITHIN(DELTA_MS(1), wait_val_us / 1000, lp_timer.read_ms());
321+
TEST_ASSERT_INT32_WITHIN(DELTA_US(1), wait_val_us, lp_timer.read_us());
322+
TEST_ASSERT_UINT64_WITHIN(DELTA_US(1), wait_val_us, lp_timer.read_high_resolution_us());
320323
}
321324

322325
utest::v1::status_t test_setup(const size_t number_of_cases)

‎TESTS/mbedmicro-rtos-mbed/timer/main.cpp

Lines changed: 52 additions & 49 deletions
Original file line numberDiff line numberDiff line change
@@ -44,14 +44,17 @@ extern uint32_t SystemCoreClock;
4444
* For NRF51_DK DELTA = (15000 / 16000000) * 1000000 = 937[us]
4545
*/
4646
#define US_PER_SEC 1000000
47+
#define US_PER_MSEC 1000
4748
#define TOLERANCE_FACTOR 15000.0f
4849
#define US_FACTOR 1000000.0f
4950

5051
static const int delta_sys_clk_us = ((int) (TOLERANCE_FACTOR / (float)SystemCoreClock * US_FACTOR));
5152

52-
#define DELTA_US delta_sys_clk_us
53-
#define DELTA_S ((float)delta_sys_clk_us/US_PER_SEC)
54-
#define DELTA_MS 1
53+
/* When test performs time measurement using Timer in sequence, then measurement error accumulates
54+
* in the successive attempts. */
55+
#define DELTA_US(i) (delta_sys_clk_us * i)
56+
#define DELTA_S(i) ((float)delta_sys_clk_us * i / US_PER_SEC)
57+
#define DELTA_MS(i) (1 + ( (i * delta_sys_clk_us) / US_PER_MSEC))
5558

5659
#define TICKER_FREQ_1MHZ 1000000
5760
#define TICKER_BITS 32
@@ -410,10 +413,10 @@ void test_timer_time_accumulation_os_ticker()
410413
p_timer->stop();
411414

412415
/* Check results - totally 10 ms have elapsed. */
413-
TEST_ASSERT_FLOAT_WITHIN(DELTA_S, 0.010f, p_timer->read());
414-
TEST_ASSERT_INT32_WITHIN(DELTA_MS, 10, p_timer->read_ms());
415-
TEST_ASSERT_INT32_WITHIN(DELTA_US, 10000, p_timer->read_us());
416-
TEST_ASSERT_UINT64_WITHIN(DELTA_US, 10000, p_timer->read_high_resolution_us());
416+
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(1), 0.010f, p_timer->read());
417+
TEST_ASSERT_INT32_WITHIN(DELTA_MS(1), 10, p_timer->read_ms());
418+
TEST_ASSERT_INT32_WITHIN(DELTA_US(1), 10000, p_timer->read_us());
419+
TEST_ASSERT_UINT64_WITHIN(DELTA_US(1), 10000, p_timer->read_high_resolution_us());
417420

418421
/* Wait 50 ms - this is done to show that time elapsed when
419422
* the timer is stopped does not have influence on the
@@ -432,10 +435,10 @@ void test_timer_time_accumulation_os_ticker()
432435
p_timer->stop();
433436

434437
/* Check results - totally 30 ms have elapsed. */
435-
TEST_ASSERT_FLOAT_WITHIN(2 * DELTA_S, 0.030f, p_timer->read());
436-
TEST_ASSERT_INT32_WITHIN(2 * DELTA_MS, 30, p_timer->read_ms());
437-
TEST_ASSERT_INT32_WITHIN(2 * DELTA_US, 30000, p_timer->read_us());
438-
TEST_ASSERT_UINT64_WITHIN(2 * DELTA_US, 30000, p_timer->read_high_resolution_us());
438+
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(2), 0.030f, p_timer->read());
439+
TEST_ASSERT_INT32_WITHIN(DELTA_MS(2), 30, p_timer->read_ms());
440+
TEST_ASSERT_INT32_WITHIN(DELTA_US(2), 30000, p_timer->read_us());
441+
TEST_ASSERT_UINT64_WITHIN(DELTA_US(2), 30000, p_timer->read_high_resolution_us());
439442

440443
/* Wait 50 ms - this is done to show that time elapsed when
441444
* the timer is stopped does not have influence on the
@@ -453,10 +456,10 @@ void test_timer_time_accumulation_os_ticker()
453456
p_timer->stop();
454457

455458
/* Check results - totally 60 ms have elapsed. */
456-
TEST_ASSERT_FLOAT_WITHIN(3 * DELTA_S, 0.060f, p_timer->read());
457-
TEST_ASSERT_INT32_WITHIN(3 * DELTA_MS, 60, p_timer->read_ms());
458-
TEST_ASSERT_INT32_WITHIN(3 * DELTA_US, 60000, p_timer->read_us());
459-
TEST_ASSERT_UINT64_WITHIN(3 * DELTA_US, 60000, p_timer->read_high_resolution_us());
459+
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(3), 0.060f, p_timer->read());
460+
TEST_ASSERT_INT32_WITHIN(DELTA_MS(3), 60, p_timer->read_ms());
461+
TEST_ASSERT_INT32_WITHIN(DELTA_US(3), 60000, p_timer->read_us());
462+
TEST_ASSERT_UINT64_WITHIN(DELTA_US(3), 60000, p_timer->read_high_resolution_us());
460463

461464
/* Wait 50 ms - this is done to show that time elapsed when
462465
* the timer is stopped does not have influence on the
@@ -475,10 +478,10 @@ void test_timer_time_accumulation_os_ticker()
475478
p_timer->stop();
476479

477480
/* Check results - totally 1060 ms have elapsed. */
478-
TEST_ASSERT_FLOAT_WITHIN(4 * DELTA_S, 1.060f, p_timer->read());
479-
TEST_ASSERT_INT32_WITHIN(4 * DELTA_MS, 1060, p_timer->read_ms());
480-
TEST_ASSERT_INT32_WITHIN(4 * DELTA_US, 1060000, p_timer->read_us());
481-
TEST_ASSERT_UINT64_WITHIN(4 * DELTA_US, 1060000, p_timer->read_high_resolution_us());
481+
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(4), 1.060f, p_timer->read());
482+
TEST_ASSERT_INT32_WITHIN(DELTA_MS(4), 1060, p_timer->read_ms());
483+
TEST_ASSERT_INT32_WITHIN(DELTA_US(4), 1060000, p_timer->read_us());
484+
TEST_ASSERT_UINT64_WITHIN(DELTA_US(4), 1060000, p_timer->read_high_resolution_us());
482485
}
483486

484487
/* This test verifies if reset() function resets the timer
@@ -504,10 +507,10 @@ void test_timer_reset_os_ticker()
504507
p_timer->stop();
505508

506509
/* Check results - totally 10 ms elapsed. */
507-
TEST_ASSERT_FLOAT_WITHIN(DELTA_S, 0.010f, p_timer->read());
508-
TEST_ASSERT_INT32_WITHIN(DELTA_MS, 10, p_timer->read_ms());
509-
TEST_ASSERT_INT32_WITHIN(DELTA_US, 10000, p_timer->read_us());
510-
TEST_ASSERT_UINT64_WITHIN(DELTA_US, 10000, p_timer->read_high_resolution_us());
510+
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(1), 0.010f, p_timer->read());
511+
TEST_ASSERT_INT32_WITHIN(DELTA_MS(1), 10, p_timer->read_ms());
512+
TEST_ASSERT_INT32_WITHIN(DELTA_US(1), 10000, p_timer->read_us());
513+
TEST_ASSERT_UINT64_WITHIN(DELTA_US(1), 10000, p_timer->read_high_resolution_us());
511514

512515
/* Reset the timer - previous measured time should be lost now. */
513516
p_timer->reset();
@@ -522,10 +525,10 @@ void test_timer_reset_os_ticker()
522525
p_timer->stop();
523526

524527
/* Check results - 20 ms elapsed since the reset. */
525-
TEST_ASSERT_FLOAT_WITHIN(DELTA_S, 0.020f, p_timer->read());
526-
TEST_ASSERT_INT32_WITHIN(DELTA_MS, 20, p_timer->read_ms());
527-
TEST_ASSERT_INT32_WITHIN(DELTA_US, 20000, p_timer->read_us());
528-
TEST_ASSERT_UINT64_WITHIN(DELTA_US, 20000, p_timer->read_high_resolution_us());
528+
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(1), 0.020f, p_timer->read());
529+
TEST_ASSERT_INT32_WITHIN(DELTA_MS(1), 20, p_timer->read_ms());
530+
TEST_ASSERT_INT32_WITHIN(DELTA_US(1), 20000, p_timer->read_us());
531+
TEST_ASSERT_UINT64_WITHIN(DELTA_US(1), 20000, p_timer->read_high_resolution_us());
529532
}
530533

531534
/* This test verifies if reset() function resets the timer
@@ -555,10 +558,10 @@ void test_timer_reset_user_ticker()
555558
p_timer->stop();
556559

557560
/* Check results - totally 10 ms elapsed. */
558-
TEST_ASSERT_FLOAT_WITHIN(DELTA_S, 0.010f, p_timer->read());
559-
TEST_ASSERT_INT32_WITHIN(DELTA_MS, 10, p_timer->read_ms());
560-
TEST_ASSERT_INT32_WITHIN(DELTA_US, 10000, p_timer->read_us());
561-
TEST_ASSERT_UINT64_WITHIN(DELTA_US, 10000, p_timer->read_high_resolution_us());
561+
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(1), 0.010f, p_timer->read());
562+
TEST_ASSERT_INT32_WITHIN(DELTA_MS(1), 10, p_timer->read_ms());
563+
TEST_ASSERT_INT32_WITHIN(DELTA_US(1), 10000, p_timer->read_us());
564+
TEST_ASSERT_UINT64_WITHIN(DELTA_US(1), 10000, p_timer->read_high_resolution_us());
562565

563566
/* Reset the timer - previous measured time should be lost now. */
564567
p_timer->reset();
@@ -573,10 +576,10 @@ void test_timer_reset_user_ticker()
573576
p_timer->stop();
574577

575578
/* Check results - 20 ms elapsed since the reset. */
576-
TEST_ASSERT_FLOAT_WITHIN(DELTA_S, 0.020f, p_timer->read());
577-
TEST_ASSERT_INT32_WITHIN(DELTA_MS, 20, p_timer->read_ms());
578-
TEST_ASSERT_INT32_WITHIN(DELTA_US, 20000, p_timer->read_us());
579-
TEST_ASSERT_UINT64_WITHIN(DELTA_US, 20000, p_timer->read_high_resolution_us());
579+
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(1), 0.020f, p_timer->read());
580+
TEST_ASSERT_INT32_WITHIN(DELTA_MS(1), 20, p_timer->read_ms());
581+
TEST_ASSERT_INT32_WITHIN(DELTA_US(1), 20000, p_timer->read_us());
582+
TEST_ASSERT_UINT64_WITHIN(DELTA_US(1), 20000, p_timer->read_high_resolution_us());
580583
}
581584

582585
/* This test verifies if calling start() for already
@@ -606,10 +609,10 @@ void test_timer_start_started_timer_os_ticker()
606609
p_timer->stop();
607610

608611
/* Check results - 30 ms have elapsed since the first start. */
609-
TEST_ASSERT_FLOAT_WITHIN(2 * DELTA_S, 0.030f, p_timer->read());
610-
TEST_ASSERT_INT32_WITHIN(2 * DELTA_MS, 30, p_timer->read_ms());
611-
TEST_ASSERT_INT32_WITHIN(2 * DELTA_US, 30000, p_timer->read_us());
612-
TEST_ASSERT_UINT64_WITHIN(2 * DELTA_US, 30000, p_timer->read_high_resolution_us());
612+
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(2), 0.030f, p_timer->read());
613+
TEST_ASSERT_INT32_WITHIN(DELTA_MS(2), 30, p_timer->read_ms());
614+
TEST_ASSERT_INT32_WITHIN(DELTA_US(2), 30000, p_timer->read_us());
615+
TEST_ASSERT_UINT64_WITHIN(DELTA_US(2), 30000, p_timer->read_high_resolution_us());
613616
}
614617

615618
/* This test verifies if calling start() for already
@@ -643,10 +646,10 @@ void test_timer_start_started_timer_user_ticker()
643646
p_timer->stop();
644647

645648
/* Check results - 30 ms have elapsed since the first start. */
646-
TEST_ASSERT_FLOAT_WITHIN(2 * DELTA_S, 0.030f, p_timer->read());
647-
TEST_ASSERT_INT32_WITHIN(2 * DELTA_MS, 30, p_timer->read_ms());
648-
TEST_ASSERT_INT32_WITHIN(2 * DELTA_US, 30000, p_timer->read_us());
649-
TEST_ASSERT_UINT64_WITHIN(2 * DELTA_US, 30000, p_timer->read_high_resolution_us());
649+
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(2), 0.030f, p_timer->read());
650+
TEST_ASSERT_INT32_WITHIN(DELTA_MS(2), 30, p_timer->read_ms());
651+
TEST_ASSERT_INT32_WITHIN(DELTA_US(2), 30000, p_timer->read_us());
652+
TEST_ASSERT_UINT64_WITHIN(DELTA_US(2), 30000, p_timer->read_high_resolution_us());
650653
}
651654

652655
/* This test verifies Timer float operator.
@@ -670,7 +673,7 @@ void test_timer_float_operator_os_ticker()
670673
p_timer->stop();
671674

672675
/* Check result - 10 ms elapsed. */
673-
TEST_ASSERT_FLOAT_WITHIN(DELTA_S, 0.010f, (float)(*p_timer));
676+
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(1), 0.010f, (float)(*p_timer));
674677
}
675678

676679
/* This test verifies Timer float operator.
@@ -698,7 +701,7 @@ void test_timer_float_operator_user_ticker()
698701
p_timer->stop();
699702

700703
/* Check result - 10 ms elapsed. */
701-
TEST_ASSERT_FLOAT_WITHIN(DELTA_S, 0.010f, (float)(*p_timer));
704+
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(1), 0.010f, (float)(*p_timer));
702705
}
703706

704707
/* This test verifies if time counted by the timer is
@@ -725,10 +728,10 @@ void test_timer_time_measurement()
725728
p_timer->stop();
726729

727730
/* Check results. */
728-
TEST_ASSERT_FLOAT_WITHIN(DELTA_S, (float)wait_val_us / 1000000, p_timer->read());
729-
TEST_ASSERT_INT32_WITHIN(DELTA_MS, wait_val_us / 1000, p_timer->read_ms());
730-
TEST_ASSERT_INT32_WITHIN(DELTA_US, wait_val_us, p_timer->read_us());
731-
TEST_ASSERT_UINT64_WITHIN(DELTA_US, wait_val_us, p_timer->read_high_resolution_us());
731+
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(1), (float)wait_val_us / 1000000, p_timer->read());
732+
TEST_ASSERT_INT32_WITHIN(DELTA_MS(1), wait_val_us / 1000, p_timer->read_ms());
733+
TEST_ASSERT_INT32_WITHIN(DELTA_US(1), wait_val_us, p_timer->read_us());
734+
TEST_ASSERT_UINT64_WITHIN(DELTA_US(1), wait_val_us, p_timer->read_high_resolution_us());
732735
}
733736

734737
utest::v1::status_t test_setup(const size_t number_of_cases) {

0 commit comments

Comments
 (0)