Skip to content

Commit 329dfc5

Browse files
mprseadbridge
mprse
authored and
adbridge
committed
Move Timer test, modify ASERT macros, fix comments.
Move Timer test to TESTS/mbed_drivers/ directory which is more suitable. Fix few comments which are incorrect. Use more relevant ASERT macros.
1 parent 1886e8b commit 329dfc5

File tree

2 files changed

+50
-50
lines changed

2 files changed

+50
-50
lines changed

‎TESTS/mbed_drivers/lp_timer/main.cpp‎

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -78,19 +78,19 @@ void test_lptimer_creation()
7878

7979
/* Check results. */
8080
TEST_ASSERT_EQUAL_FLOAT(0, lp_timer.read());
81-
TEST_ASSERT_EQUAL(0, lp_timer.read_ms());
82-
TEST_ASSERT_EQUAL(0, lp_timer.read_us());
83-
TEST_ASSERT_EQUAL(0, lp_timer.read_high_resolution_us());
81+
TEST_ASSERT_EQUAL_INT32(0, lp_timer.read_ms());
82+
TEST_ASSERT_EQUAL_INT32(0, lp_timer.read_us());
83+
TEST_ASSERT_EQUAL_UINT64(0, lp_timer.read_high_resolution_us());
8484

8585
/* Wait 10 ms.
8686
* After that operation timer read routines should still return 0. */
8787
wait_ms(10);
8888

8989
/* Check results. */
9090
TEST_ASSERT_EQUAL_FLOAT(0, lp_timer.read());
91-
TEST_ASSERT_EQUAL(0, lp_timer.read_ms());
92-
TEST_ASSERT_EQUAL(0, lp_timer.read_us());
93-
TEST_ASSERT_EQUAL(0, lp_timer.read_high_resolution_us());
91+
TEST_ASSERT_EQUAL_INT32(0, lp_timer.read_ms());
92+
TEST_ASSERT_EQUAL_INT32(0, lp_timer.read_us());
93+
TEST_ASSERT_EQUAL_UINT64(0, lp_timer.read_high_resolution_us());
9494
}
9595

9696
/* This test verifies if read(), read_us(), read_ms(),
@@ -182,7 +182,7 @@ void test_lptimer_time_accumulation()
182182
/* Stop the timer. */
183183
lp_timer.stop();
184184

185-
/* Check results - totally 5060 ms have elapsed. */
185+
/* Check results - totally 1060 ms have elapsed. */
186186
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(4), 1.060f, lp_timer.read());
187187
TEST_ASSERT_INT32_WITHIN(DELTA_MS(4), 1060, lp_timer.read_ms());
188188
TEST_ASSERT_INT32_WITHIN(DELTA_US(4), 1060000, lp_timer.read_us());

‎TESTS/mbedmicro-rtos-mbed/timer/main.cpp‎ renamed to ‎TESTS/mbed_drivers/timer/main.cpp‎

Lines changed: 43 additions & 43 deletions
Original file line numberDiff line numberDiff line change
@@ -179,19 +179,19 @@ void test_timer_creation_os_ticker()
179179
{
180180
/* Check results. */
181181
TEST_ASSERT_EQUAL_FLOAT(0, p_timer->read());
182-
TEST_ASSERT_EQUAL(0, p_timer->read_ms());
183-
TEST_ASSERT_EQUAL(0, p_timer->read_us());
184-
TEST_ASSERT_EQUAL(0, p_timer->read_high_resolution_us());
182+
TEST_ASSERT_EQUAL_INT32(0, p_timer->read_ms());
183+
TEST_ASSERT_EQUAL_INT32(0, p_timer->read_us());
184+
TEST_ASSERT_EQUAL_UINT64(0, p_timer->read_high_resolution_us());
185185

186186
/* Wait 10 ms.
187187
* After that operation timer read routines should still return 0. */
188188
wait_ms(10);
189189

190190
/* Check results. */
191191
TEST_ASSERT_EQUAL_FLOAT(0, p_timer->read());
192-
TEST_ASSERT_EQUAL(0, p_timer->read_ms());
193-
TEST_ASSERT_EQUAL(0, p_timer->read_us());
194-
TEST_ASSERT_EQUAL(0, p_timer->read_high_resolution_us());
192+
TEST_ASSERT_EQUAL_INT32(0, p_timer->read_ms());
193+
TEST_ASSERT_EQUAL_INT32(0, p_timer->read_us());
194+
TEST_ASSERT_EQUAL_UINT64(0, p_timer->read_high_resolution_us());
195195
}
196196

197197
/* This test verifies if timer is stopped after
@@ -213,19 +213,19 @@ void test_timer_creation_user_ticker()
213213

214214
/* Check results. */
215215
TEST_ASSERT_EQUAL_FLOAT(0, p_timer->read());
216-
TEST_ASSERT_EQUAL(0, p_timer->read_ms());
217-
TEST_ASSERT_EQUAL(0, p_timer->read_us());
218-
TEST_ASSERT_EQUAL(0, p_timer->read_high_resolution_us());
216+
TEST_ASSERT_EQUAL_INT32(0, p_timer->read_ms());
217+
TEST_ASSERT_EQUAL_INT32(0, p_timer->read_us());
218+
TEST_ASSERT_EQUAL_UINT64(0, p_timer->read_high_resolution_us());
219219

220220
/* Simulate that 10 ms has elapsed.
221221
* After that operation timer read routines should still return 0. */
222222
curr_ticker_us_val += 10000;
223223

224224
/* Check results. */
225225
TEST_ASSERT_EQUAL_FLOAT(0, p_timer->read());
226-
TEST_ASSERT_EQUAL(0, p_timer->read_ms());
227-
TEST_ASSERT_EQUAL(0, p_timer->read_us());
228-
TEST_ASSERT_EQUAL(0, p_timer->read_high_resolution_us());
226+
TEST_ASSERT_EQUAL_INT32(0, p_timer->read_ms());
227+
TEST_ASSERT_EQUAL_INT32(0, p_timer->read_us());
228+
TEST_ASSERT_EQUAL_UINT64(0, p_timer->read_high_resolution_us());
229229
}
230230

231231
/* This test verifies verifies if read(), read_us(), read_ms(),
@@ -257,9 +257,9 @@ void test_timer_time_accumulation_user_ticker()
257257

258258
/* Check results - 1 us has elapsed. */
259259
TEST_ASSERT_EQUAL_FLOAT(0.000001f, p_timer->read());
260-
TEST_ASSERT_EQUAL(0, p_timer->read_ms());
261-
TEST_ASSERT_EQUAL(1, p_timer->read_us());
262-
TEST_ASSERT_EQUAL(1, p_timer->read_high_resolution_us());
260+
TEST_ASSERT_EQUAL_INT32(0, p_timer->read_ms());
261+
TEST_ASSERT_EQUAL_INT32(1, p_timer->read_us());
262+
TEST_ASSERT_EQUAL_UINT64(1, p_timer->read_high_resolution_us());
263263

264264
/* Simulate that 100 us has elapsed between stop and start. */
265265
curr_ticker_us_val = 101;
@@ -273,11 +273,11 @@ void test_timer_time_accumulation_user_ticker()
273273
/* Stop the timer. */
274274
p_timer->stop();
275275

276-
/* Check results - 126 us have elapsed. */
276+
/* Check results - 125 us have elapsed. */
277277
TEST_ASSERT_EQUAL_FLOAT(0.000125f, p_timer->read());
278-
TEST_ASSERT_EQUAL(0, p_timer->read_ms());
279-
TEST_ASSERT_EQUAL(125, p_timer->read_us());
280-
TEST_ASSERT_EQUAL(125, p_timer->read_high_resolution_us());
278+
TEST_ASSERT_EQUAL_INT32(0, p_timer->read_ms());
279+
TEST_ASSERT_EQUAL_INT32(125, p_timer->read_us());
280+
TEST_ASSERT_EQUAL_UINT64(125, p_timer->read_high_resolution_us());
281281

282282
/* Simulate that 100 us has elapsed between stop and start. */
283283
curr_ticker_us_val = 325;
@@ -293,9 +293,9 @@ void test_timer_time_accumulation_user_ticker()
293293

294294
/* Check results - 1 ms has elapsed. */
295295
TEST_ASSERT_EQUAL_FLOAT(0.001000f, p_timer->read());
296-
TEST_ASSERT_EQUAL(1, p_timer->read_ms());
297-
TEST_ASSERT_EQUAL(1000, p_timer->read_us());
298-
TEST_ASSERT_EQUAL(1000, p_timer->read_high_resolution_us());
296+
TEST_ASSERT_EQUAL_INT32(1, p_timer->read_ms());
297+
TEST_ASSERT_EQUAL_INT32(1000, p_timer->read_us());
298+
TEST_ASSERT_EQUAL_UINT64(1000, p_timer->read_high_resolution_us());
299299

300300
/* Simulate that 100 us has elapsed between stop and start. */
301301
curr_ticker_us_val = 1300;
@@ -311,9 +311,9 @@ void test_timer_time_accumulation_user_ticker()
311311

312312
/* Check results - 125 ms have elapsed. */
313313
TEST_ASSERT_EQUAL_FLOAT(0.125000f, p_timer->read());
314-
TEST_ASSERT_EQUAL(125, p_timer->read_ms());
315-
TEST_ASSERT_EQUAL(125000, p_timer->read_us());
316-
TEST_ASSERT_EQUAL(125000, p_timer->read_high_resolution_us());
314+
TEST_ASSERT_EQUAL_INT32(125, p_timer->read_ms());
315+
TEST_ASSERT_EQUAL_INT32(125000, p_timer->read_us());
316+
TEST_ASSERT_EQUAL_UINT64(125000, p_timer->read_high_resolution_us());
317317

318318
/* Simulate that 100 us has elapsed between stop and start. */
319319
curr_ticker_us_val = 125400;
@@ -329,9 +329,9 @@ void test_timer_time_accumulation_user_ticker()
329329

330330
/* Check results - 1 s has elapsed. */
331331
TEST_ASSERT_EQUAL_FLOAT(1.000000f, p_timer->read());
332-
TEST_ASSERT_EQUAL(1000, p_timer->read_ms());
333-
TEST_ASSERT_EQUAL(1000000, p_timer->read_us());
334-
TEST_ASSERT_EQUAL(1000000, p_timer->read_high_resolution_us());
332+
TEST_ASSERT_EQUAL_INT32(1000, p_timer->read_ms());
333+
TEST_ASSERT_EQUAL_INT32(1000000, p_timer->read_us());
334+
TEST_ASSERT_EQUAL_UINT64(1000000, p_timer->read_high_resolution_us());
335335

336336
/* Simulate that 100 us has elapsed between stop and start. */
337337
curr_ticker_us_val = 1000500;
@@ -347,9 +347,9 @@ void test_timer_time_accumulation_user_ticker()
347347

348348
/* Check results - 125 s have elapsed. */
349349
TEST_ASSERT_EQUAL_FLOAT(125.000000f, p_timer->read());
350-
TEST_ASSERT_EQUAL(125000, p_timer->read_ms());
351-
TEST_ASSERT_EQUAL(125000000, p_timer->read_us());
352-
TEST_ASSERT_EQUAL(125000000, p_timer->read_high_resolution_us());
350+
TEST_ASSERT_EQUAL_INT32(125000, p_timer->read_ms());
351+
TEST_ASSERT_EQUAL_INT32(125000000, p_timer->read_us());
352+
TEST_ASSERT_EQUAL_UINT64(125000000, p_timer->read_high_resolution_us());
353353

354354
/* Simulate that 100 us has elapsed between stop and start. */
355355
curr_ticker_us_val = 125000600;
@@ -371,9 +371,9 @@ void test_timer_time_accumulation_user_ticker()
371371

372372
/* Check results - 2147483647 (MAX_INT_32) us have elapsed. */
373373
TEST_ASSERT_EQUAL_FLOAT(2147.483647f, p_timer->read());
374-
TEST_ASSERT_EQUAL(2147483, p_timer->read_ms());
375-
TEST_ASSERT_EQUAL(2147483647, p_timer->read_us());
376-
TEST_ASSERT_EQUAL(2147483647, p_timer->read_high_resolution_us());
374+
TEST_ASSERT_EQUAL_INT32(2147483, p_timer->read_ms());
375+
TEST_ASSERT_EQUAL_INT32(2147483647, p_timer->read_us());
376+
TEST_ASSERT_EQUAL_UINT64(2147483647, p_timer->read_high_resolution_us());
377377
}
378378

379379
/* This test verifies if read(), read_us(), read_ms(),
@@ -546,10 +546,10 @@ void test_timer_reset_user_ticker()
546546
p_timer->stop();
547547

548548
/* Check results - totally 10 ms elapsed. */
549-
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(1), 0.010f, p_timer->read());
550-
TEST_ASSERT_INT32_WITHIN(DELTA_MS(1), 10, p_timer->read_ms());
551-
TEST_ASSERT_INT32_WITHIN(DELTA_US(1), 10000, p_timer->read_us());
552-
TEST_ASSERT_UINT64_WITHIN(DELTA_US(1), 10000, p_timer->read_high_resolution_us());
549+
TEST_ASSERT_EQUAL_FLOAT(0.010f, p_timer->read());
550+
TEST_ASSERT_EQUAL_INT32(10, p_timer->read_ms());
551+
TEST_ASSERT_EQUAL_INT32(10000, p_timer->read_us());
552+
TEST_ASSERT_EQUAL_UINT64(10000, p_timer->read_high_resolution_us());
553553

554554
/* Reset the timer - previous measured time should be lost now. */
555555
p_timer->reset();
@@ -564,10 +564,10 @@ void test_timer_reset_user_ticker()
564564
p_timer->stop();
565565

566566
/* Check results - 20 ms elapsed since the reset. */
567-
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(1), 0.020f, p_timer->read());
568-
TEST_ASSERT_INT32_WITHIN(DELTA_MS(1), 20, p_timer->read_ms());
569-
TEST_ASSERT_INT32_WITHIN(DELTA_US(1), 20000, p_timer->read_us());
570-
TEST_ASSERT_UINT64_WITHIN(DELTA_US(1), 20000, p_timer->read_high_resolution_us());
567+
TEST_ASSERT_EQUAL_FLOAT(0.020f, p_timer->read());
568+
TEST_ASSERT_EQUAL_INT32(20, p_timer->read_ms());
569+
TEST_ASSERT_EQUAL_INT32(20000, p_timer->read_us());
570+
TEST_ASSERT_EQUAL_UINT64(20000, p_timer->read_high_resolution_us());
571571
}
572572

573573
/* This test verifies if calling start() for already
@@ -689,7 +689,7 @@ void test_timer_float_operator_user_ticker()
689689
p_timer->stop();
690690

691691
/* Check result - 10 ms elapsed. */
692-
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(1), 0.010f, (float)(*p_timer));
692+
TEST_ASSERT_EQUAL_FLOAT(0.010f, (float)(*p_timer));
693693
}
694694

695695
/* This test verifies if time counted by the timer is

0 commit comments

Comments
 (0)