Skip to content

Commit d962f67

Browse files
mprsemprse
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 d49899a commit d962f67

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
@@ -191,19 +191,19 @@ void test_timer_creation_os_ticker()
191191
{
192192
/* Check results. */
193193
TEST_ASSERT_EQUAL_FLOAT(0, p_timer->read());
194-
TEST_ASSERT_EQUAL(0, p_timer->read_ms());
195-
TEST_ASSERT_EQUAL(0, p_timer->read_us());
196-
TEST_ASSERT_EQUAL(0, p_timer->read_high_resolution_us());
194+
TEST_ASSERT_EQUAL_INT32(0, p_timer->read_ms());
195+
TEST_ASSERT_EQUAL_INT32(0, p_timer->read_us());
196+
TEST_ASSERT_EQUAL_UINT64(0, p_timer->read_high_resolution_us());
197197

198198
/* Wait 10 ms.
199199
* After that operation timer read routines should still return 0. */
200200
wait_ms(10);
201201

202202
/* Check results. */
203203
TEST_ASSERT_EQUAL_FLOAT(0, p_timer->read());
204-
TEST_ASSERT_EQUAL(0, p_timer->read_ms());
205-
TEST_ASSERT_EQUAL(0, p_timer->read_us());
206-
TEST_ASSERT_EQUAL(0, p_timer->read_high_resolution_us());
204+
TEST_ASSERT_EQUAL_INT32(0, p_timer->read_ms());
205+
TEST_ASSERT_EQUAL_INT32(0, p_timer->read_us());
206+
TEST_ASSERT_EQUAL_UINT64(0, p_timer->read_high_resolution_us());
207207
}
208208

209209
/* This test verifies if timer is stopped after
@@ -225,19 +225,19 @@ void test_timer_creation_user_ticker()
225225

226226
/* Check results. */
227227
TEST_ASSERT_EQUAL_FLOAT(0, p_timer->read());
228-
TEST_ASSERT_EQUAL(0, p_timer->read_ms());
229-
TEST_ASSERT_EQUAL(0, p_timer->read_us());
230-
TEST_ASSERT_EQUAL(0, p_timer->read_high_resolution_us());
228+
TEST_ASSERT_EQUAL_INT32(0, p_timer->read_ms());
229+
TEST_ASSERT_EQUAL_INT32(0, p_timer->read_us());
230+
TEST_ASSERT_EQUAL_UINT64(0, p_timer->read_high_resolution_us());
231231

232232
/* Simulate that 10 ms has elapsed.
233233
* After that operation timer read routines should still return 0. */
234234
curr_ticker_ticks_val += 10000;
235235

236236
/* Check results. */
237237
TEST_ASSERT_EQUAL_FLOAT(0, p_timer->read());
238-
TEST_ASSERT_EQUAL(0, p_timer->read_ms());
239-
TEST_ASSERT_EQUAL(0, p_timer->read_us());
240-
TEST_ASSERT_EQUAL(0, p_timer->read_high_resolution_us());
238+
TEST_ASSERT_EQUAL_INT32(0, p_timer->read_ms());
239+
TEST_ASSERT_EQUAL_INT32(0, p_timer->read_us());
240+
TEST_ASSERT_EQUAL_UINT64(0, p_timer->read_high_resolution_us());
241241
}
242242

243243
/* This test verifies verifies if read(), read_us(), read_ms(),
@@ -269,9 +269,9 @@ void test_timer_time_accumulation_user_ticker()
269269

270270
/* Check results - 1 us has elapsed. */
271271
TEST_ASSERT_EQUAL_FLOAT(0.000001f, p_timer->read());
272-
TEST_ASSERT_EQUAL(0, p_timer->read_ms());
273-
TEST_ASSERT_EQUAL(1, p_timer->read_us());
274-
TEST_ASSERT_EQUAL(1, p_timer->read_high_resolution_us());
272+
TEST_ASSERT_EQUAL_INT32(0, p_timer->read_ms());
273+
TEST_ASSERT_EQUAL_INT32(1, p_timer->read_us());
274+
TEST_ASSERT_EQUAL_UINT64(1, p_timer->read_high_resolution_us());
275275

276276
/* Simulate that 100 us has elapsed between stop and start. */
277277
curr_ticker_ticks_val = 101;
@@ -285,11 +285,11 @@ void test_timer_time_accumulation_user_ticker()
285285
/* Stop the timer. */
286286
p_timer->stop();
287287

288-
/* Check results - 126 us have elapsed. */
288+
/* Check results - 125 us have elapsed. */
289289
TEST_ASSERT_EQUAL_FLOAT(0.000125f, p_timer->read());
290-
TEST_ASSERT_EQUAL(0, p_timer->read_ms());
291-
TEST_ASSERT_EQUAL(125, p_timer->read_us());
292-
TEST_ASSERT_EQUAL(125, p_timer->read_high_resolution_us());
290+
TEST_ASSERT_EQUAL_INT32(0, p_timer->read_ms());
291+
TEST_ASSERT_EQUAL_INT32(125, p_timer->read_us());
292+
TEST_ASSERT_EQUAL_UINT64(125, p_timer->read_high_resolution_us());
293293

294294
/* Simulate that 100 us has elapsed between stop and start. */
295295
curr_ticker_ticks_val = 325;
@@ -305,9 +305,9 @@ void test_timer_time_accumulation_user_ticker()
305305

306306
/* Check results - 1 ms has elapsed. */
307307
TEST_ASSERT_EQUAL_FLOAT(0.001000f, p_timer->read());
308-
TEST_ASSERT_EQUAL(1, p_timer->read_ms());
309-
TEST_ASSERT_EQUAL(1000, p_timer->read_us());
310-
TEST_ASSERT_EQUAL(1000, p_timer->read_high_resolution_us());
308+
TEST_ASSERT_EQUAL_INT32(1, p_timer->read_ms());
309+
TEST_ASSERT_EQUAL_INT32(1000, p_timer->read_us());
310+
TEST_ASSERT_EQUAL_UINT64(1000, p_timer->read_high_resolution_us());
311311

312312
/* Simulate that 100 us has elapsed between stop and start. */
313313
curr_ticker_ticks_val = 1300;
@@ -323,9 +323,9 @@ void test_timer_time_accumulation_user_ticker()
323323

324324
/* Check results - 125 ms have elapsed. */
325325
TEST_ASSERT_EQUAL_FLOAT(0.125000f, p_timer->read());
326-
TEST_ASSERT_EQUAL(125, p_timer->read_ms());
327-
TEST_ASSERT_EQUAL(125000, p_timer->read_us());
328-
TEST_ASSERT_EQUAL(125000, p_timer->read_high_resolution_us());
326+
TEST_ASSERT_EQUAL_INT32(125, p_timer->read_ms());
327+
TEST_ASSERT_EQUAL_INT32(125000, p_timer->read_us());
328+
TEST_ASSERT_EQUAL_UINT64(125000, p_timer->read_high_resolution_us());
329329

330330
/* Simulate that 100 us has elapsed between stop and start. */
331331
curr_ticker_ticks_val = 125400;
@@ -341,9 +341,9 @@ void test_timer_time_accumulation_user_ticker()
341341

342342
/* Check results - 1 s has elapsed. */
343343
TEST_ASSERT_EQUAL_FLOAT(1.000000f, p_timer->read());
344-
TEST_ASSERT_EQUAL(1000, p_timer->read_ms());
345-
TEST_ASSERT_EQUAL(1000000, p_timer->read_us());
346-
TEST_ASSERT_EQUAL(1000000, p_timer->read_high_resolution_us());
344+
TEST_ASSERT_EQUAL_INT32(1000, p_timer->read_ms());
345+
TEST_ASSERT_EQUAL_INT32(1000000, p_timer->read_us());
346+
TEST_ASSERT_EQUAL_UINT64(1000000, p_timer->read_high_resolution_us());
347347

348348
/* Simulate that 100 us has elapsed between stop and start. */
349349
curr_ticker_ticks_val = 1000500;
@@ -359,9 +359,9 @@ void test_timer_time_accumulation_user_ticker()
359359

360360
/* Check results - 125 s have elapsed. */
361361
TEST_ASSERT_EQUAL_FLOAT(125.000000f, p_timer->read());
362-
TEST_ASSERT_EQUAL(125000, p_timer->read_ms());
363-
TEST_ASSERT_EQUAL(125000000, p_timer->read_us());
364-
TEST_ASSERT_EQUAL(125000000, p_timer->read_high_resolution_us());
362+
TEST_ASSERT_EQUAL_INT32(125000, p_timer->read_ms());
363+
TEST_ASSERT_EQUAL_INT32(125000000, p_timer->read_us());
364+
TEST_ASSERT_EQUAL_UINT64(125000000, p_timer->read_high_resolution_us());
365365

366366
/* Simulate that 100 us has elapsed between stop and start. */
367367
curr_ticker_ticks_val = 125000600;
@@ -383,9 +383,9 @@ void test_timer_time_accumulation_user_ticker()
383383

384384
/* Check results - 2147483647 (MAX_INT_32) us have elapsed. */
385385
TEST_ASSERT_EQUAL_FLOAT(2147.483647f, p_timer->read());
386-
TEST_ASSERT_EQUAL(2147483, p_timer->read_ms());
387-
TEST_ASSERT_EQUAL(2147483647, p_timer->read_us());
388-
TEST_ASSERT_EQUAL(2147483647, p_timer->read_high_resolution_us());
386+
TEST_ASSERT_EQUAL_INT32(2147483, p_timer->read_ms());
387+
TEST_ASSERT_EQUAL_INT32(2147483647, p_timer->read_us());
388+
TEST_ASSERT_EQUAL_UINT64(2147483647, p_timer->read_high_resolution_us());
389389
}
390390

391391
/* This test verifies if read(), read_us(), read_ms(),
@@ -558,10 +558,10 @@ void test_timer_reset_user_ticker()
558558
p_timer->stop();
559559

560560
/* Check results - totally 10 ms elapsed. */
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());
561+
TEST_ASSERT_EQUAL_FLOAT(0.010f, p_timer->read());
562+
TEST_ASSERT_EQUAL_INT32(10, p_timer->read_ms());
563+
TEST_ASSERT_EQUAL_INT32(10000, p_timer->read_us());
564+
TEST_ASSERT_EQUAL_UINT64(10000, p_timer->read_high_resolution_us());
565565

566566
/* Reset the timer - previous measured time should be lost now. */
567567
p_timer->reset();
@@ -576,10 +576,10 @@ void test_timer_reset_user_ticker()
576576
p_timer->stop();
577577

578578
/* Check results - 20 ms elapsed since the reset. */
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());
579+
TEST_ASSERT_EQUAL_FLOAT(0.020f, p_timer->read());
580+
TEST_ASSERT_EQUAL_INT32(20, p_timer->read_ms());
581+
TEST_ASSERT_EQUAL_INT32(20000, p_timer->read_us());
582+
TEST_ASSERT_EQUAL_UINT64(20000, p_timer->read_high_resolution_us());
583583
}
584584

585585
/* This test verifies if calling start() for already
@@ -701,7 +701,7 @@ void test_timer_float_operator_user_ticker()
701701
p_timer->stop();
702702

703703
/* Check result - 10 ms elapsed. */
704-
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(1), 0.010f, (float)(*p_timer));
704+
TEST_ASSERT_EQUAL_FLOAT(0.010f, (float)(*p_timer));
705705
}
706706

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

0 commit comments

Comments
 (0)