Skip to content

Commit f9cf2ed

Browse files
henrikbrixandersenhenrikbrixandersen
committed
tests: drivers: can: api: replace zassert_equal() with zassert_ok()
Replace zassert_equal(err, 0, ...) with zassert_ok(err, ...) to simplify code. Signed-off-by: Henrik Brix Andersen <henrik@brixandersen.dk>
1 parent 87e1920 commit f9cf2ed

File tree

3 files changed

+113
-113
lines changed

3 files changed

+113
-113
lines changed

‎tests/drivers/can/api/src/canfd.c‎

Lines changed: 38 additions & 38 deletions
Original file line numberDiff line numberDiff line change
@@ -98,7 +98,7 @@ static void send_test_frame(const struct device *dev, const struct can_frame *fr
9898

9999
err = can_send(dev, frame, TEST_SEND_TIMEOUT, NULL, NULL);
100100
zassert_not_equal(err, -EBUSY, "arbitration lost in loopback mode");
101-
zassert_equal(err, 0, "failed to send frame (err %d)", err);
101+
zassert_ok(err, "failed to send frame (err %d)", err);
102102
}
103103

104104
/**
@@ -118,7 +118,7 @@ static void send_test_frame_nowait(const struct device *dev, const struct can_fr
118118

119119
err = can_send(dev, frame, TEST_SEND_TIMEOUT, callback, (void *)frame);
120120
zassert_not_equal(err, -EBUSY, "arbitration lost in loopback mode");
121-
zassert_equal(err, 0, "failed to send frame (err %d)", err);
121+
zassert_ok(err, "failed to send frame (err %d)", err);
122122
}
123123

124124
/**
@@ -186,7 +186,7 @@ static void send_receive(const struct can_filter *filter1,
186186
send_test_frame(can_dev, frame1);
187187

188188
err = k_msgq_get(&can_msgq, &frame_buffer, TEST_RECEIVE_TIMEOUT);
189-
zassert_equal(err, 0, "receive timeout");
189+
zassert_ok(err, "receive timeout");
190190

191191
assert_frame_equal(&frame_buffer, frame1, 0);
192192
can_remove_rx_filter(can_dev, filter_id_1);
@@ -209,16 +209,16 @@ static void send_receive(const struct can_filter *filter1,
209209
send_test_frame_nowait(can_dev, frame2, tx_std_callback_2);
210210

211211
err = k_sem_take(&rx_callback_sem, TEST_RECEIVE_TIMEOUT);
212-
zassert_equal(err, 0, "receive timeout");
212+
zassert_ok(err, "receive timeout");
213213

214214
err = k_sem_take(&rx_callback_sem, TEST_RECEIVE_TIMEOUT);
215-
zassert_equal(err, 0, "receive timeout");
215+
zassert_ok(err, "receive timeout");
216216

217217
err = k_sem_take(&tx_callback_sem, TEST_SEND_TIMEOUT);
218-
zassert_equal(err, 0, "missing TX callback");
218+
zassert_ok(err, "missing TX callback");
219219

220220
err = k_sem_take(&tx_callback_sem, TEST_SEND_TIMEOUT);
221-
zassert_equal(err, 0, "missing TX callback");
221+
zassert_ok(err, "missing TX callback");
222222

223223
can_remove_rx_filter(can_dev, filter_id_1);
224224
can_remove_rx_filter(can_dev, filter_id_2);
@@ -233,7 +233,7 @@ ZTEST(canfd, test_canfd_get_capabilities)
233233
int err;
234234

235235
err = can_get_capabilities(can_dev, &cap);
236-
zassert_equal(err, 0, "failed to get CAN capabilities (err %d)", err);
236+
zassert_ok(err, "failed to get CAN capabilities (err %d)", err);
237237
zassert_not_equal(cap & (CAN_MODE_LOOPBACK | CAN_MODE_FD), 0,
238238
"CAN FD loopback mode not supported");
239239
}
@@ -315,18 +315,18 @@ static void check_filters_preserved_between_modes(can_mode_t first, can_mode_t s
315315

316316
/* Stop controller and set first mode */
317317
err = can_stop(can_dev);
318-
zassert_equal(err, 0, "failed to stop CAN controller (err %d)", err);
318+
zassert_ok(err, "failed to stop CAN controller (err %d)", err);
319319

320320
err = can_get_state(can_dev, &state, NULL);
321-
zassert_equal(err, 0, "failed to get CAN state (err %d)", err);
321+
zassert_ok(err, "failed to get CAN state (err %d)", err);
322322
zassert_equal(state, CAN_STATE_STOPPED, "CAN controller not stopped");
323323

324324
err = can_set_mode(can_dev, first | CAN_MODE_LOOPBACK);
325-
zassert_equal(err, 0, "failed to set first loopback mode (err %d)", err);
325+
zassert_ok(err, "failed to set first loopback mode (err %d)", err);
326326
zassert_equal(first | CAN_MODE_LOOPBACK, can_get_mode(can_dev));
327327

328328
err = can_start(can_dev);
329-
zassert_equal(err, 0, "failed to start CAN controller (err %d)", err);
329+
zassert_ok(err, "failed to start CAN controller (err %d)", err);
330330

331331
/* Add classic CAN and CAN FD filter */
332332
filter_id_1 = add_rx_msgq(can_dev, &test_std_filter_1);
@@ -335,60 +335,60 @@ static void check_filters_preserved_between_modes(can_mode_t first, can_mode_t s
335335
/* Verify classic filter in first mode */
336336
send_test_frame(can_dev, &test_std_frame_1);
337337
err = k_msgq_get(&can_msgq, &frame, TEST_RECEIVE_TIMEOUT);
338-
zassert_equal(err, 0, "receive timeout");
338+
zassert_ok(err, "receive timeout");
339339
assert_frame_equal(&frame, &test_std_frame_1, 0);
340340

341341
if ((first & CAN_MODE_FD) != 0) {
342342
/* Verify CAN FD filter in first mode */
343343
send_test_frame(can_dev, &test_std_fdf_frame_2);
344344
err = k_msgq_get(&can_msgq, &frame, TEST_RECEIVE_TIMEOUT);
345-
zassert_equal(err, 0, "receive timeout");
345+
zassert_ok(err, "receive timeout");
346346
assert_frame_equal(&frame, &test_std_fdf_frame_2, 0);
347347
}
348348

349349
/* Stop controller and set second mode */
350350
err = can_stop(can_dev);
351-
zassert_equal(err, 0, "failed to stop CAN controller (err %d)", err);
351+
zassert_ok(err, "failed to stop CAN controller (err %d)", err);
352352

353353
err = can_get_state(can_dev, &state, NULL);
354-
zassert_equal(err, 0, "failed to get CAN state (err %d)", err);
354+
zassert_ok(err, "failed to get CAN state (err %d)", err);
355355
zassert_equal(state, CAN_STATE_STOPPED, "CAN controller not stopped");
356356

357357
err = can_set_mode(can_dev, second | CAN_MODE_LOOPBACK);
358-
zassert_equal(err, 0, "failed to set second loopback mode (err %d)", err);
358+
zassert_ok(err, "failed to set second loopback mode (err %d)", err);
359359
zassert_equal(second | CAN_MODE_LOOPBACK, can_get_mode(can_dev));
360360

361361
err = can_start(can_dev);
362-
zassert_equal(err, 0, "failed to start CAN controller (err %d)", err);
362+
zassert_ok(err, "failed to start CAN controller (err %d)", err);
363363

364364
/* Verify classic filter in second mode */
365365
send_test_frame(can_dev, &test_std_frame_1);
366366
err = k_msgq_get(&can_msgq, &frame, TEST_RECEIVE_TIMEOUT);
367-
zassert_equal(err, 0, "receive timeout");
367+
zassert_ok(err, "receive timeout");
368368
assert_frame_equal(&frame, &test_std_frame_1, 0);
369369

370370
if ((second & CAN_MODE_FD) != 0) {
371371
/* Verify CAN FD filter in second mode */
372372
send_test_frame(can_dev, &test_std_fdf_frame_2);
373373
err = k_msgq_get(&can_msgq, &frame, TEST_RECEIVE_TIMEOUT);
374-
zassert_equal(err, 0, "receive timeout");
374+
zassert_ok(err, "receive timeout");
375375
assert_frame_equal(&frame, &test_std_fdf_frame_2, 0);
376376
}
377377

378378
/* Stop controller and restore CAN FD loopback mode */
379379
err = can_stop(can_dev);
380-
zassert_equal(err, 0, "failed to stop CAN controller (err %d)", err);
380+
zassert_ok(err, "failed to stop CAN controller (err %d)", err);
381381

382382
err = can_get_state(can_dev, &state, NULL);
383-
zassert_equal(err, 0, "failed to get CAN state (err %d)", err);
383+
zassert_ok(err, "failed to get CAN state (err %d)", err);
384384
zassert_equal(state, CAN_STATE_STOPPED, "CAN controller not stopped");
385385

386386
err = can_set_mode(can_dev, CAN_MODE_FD | CAN_MODE_LOOPBACK);
387-
zassert_equal(err, 0, "failed to set loopback-mode (err %d)", err);
387+
zassert_ok(err, "failed to set loopback-mode (err %d)", err);
388388
zassert_equal(CAN_MODE_FD | CAN_MODE_LOOPBACK, can_get_mode(can_dev));
389389

390390
err = can_start(can_dev);
391-
zassert_equal(err, 0, "failed to start CAN controller (err %d)", err);
391+
zassert_ok(err, "failed to start CAN controller (err %d)", err);
392392

393393
can_remove_rx_filter(can_dev, filter_id_1);
394394
can_remove_rx_filter(can_dev, filter_id_2);
@@ -420,16 +420,16 @@ ZTEST_USER(canfd, test_set_timing_data_min)
420420
int err;
421421

422422
err = can_stop(can_dev);
423-
zassert_equal(err, 0, "failed to stop CAN controller (err %d)", err);
423+
zassert_ok(err, "failed to stop CAN controller (err %d)", err);
424424

425425
err = can_set_timing_data(can_dev, can_get_timing_data_min(can_dev));
426-
zassert_equal(err, 0, "failed to set minimum timing data parameters (err %d)", err);
426+
zassert_ok(err, "failed to set minimum timing data parameters (err %d)", err);
427427

428428
err = can_set_bitrate_data(can_dev, CONFIG_CAN_DEFAULT_BITRATE_DATA);
429-
zassert_equal(err, 0, "failed to restore default data bitrate");
429+
zassert_ok(err, "failed to restore default data bitrate");
430430

431431
err = can_start(can_dev);
432-
zassert_equal(err, 0, "failed to start CAN controller (err %d)", err);
432+
zassert_ok(err, "failed to start CAN controller (err %d)", err);
433433
}
434434

435435
/**
@@ -445,16 +445,16 @@ ZTEST_USER(canfd, test_set_bitrate_data_too_low)
445445
}
446446

447447
err = can_stop(can_dev);
448-
zassert_equal(err, 0, "failed to stop CAN controller (err %d)", err);
448+
zassert_ok(err, "failed to stop CAN controller (err %d)", err);
449449

450450
err = can_set_bitrate_data(can_dev, min - 1);
451451
zassert_equal(err, -ENOTSUP, "too low data phase bitrate accepted");
452452

453453
err = can_set_bitrate_data(can_dev, CONFIG_CAN_DEFAULT_BITRATE_DATA);
454-
zassert_equal(err, 0, "failed to restore default data bitrate");
454+
zassert_ok(err, "failed to restore default data bitrate");
455455

456456
err = can_start(can_dev);
457-
zassert_equal(err, 0, "failed to start CAN controller (err %d)", err);
457+
zassert_ok(err, "failed to start CAN controller (err %d)", err);
458458
}
459459

460460
/**
@@ -466,13 +466,13 @@ ZTEST_USER(canfd, test_set_bitrate_too_high)
466466
int err;
467467

468468
err = can_stop(can_dev);
469-
zassert_equal(err, 0, "failed to stop CAN controller (err %d)", err);
469+
zassert_ok(err, "failed to stop CAN controller (err %d)", err);
470470

471471
err = can_set_bitrate_data(can_dev, max + 1);
472472
zassert_equal(err, -ENOTSUP, "too high data phase bitrate accepted");
473473

474474
err = can_start(can_dev);
475-
zassert_equal(err, 0, "failed to start CAN controller (err %d)", err);
475+
zassert_ok(err, "failed to start CAN controller (err %d)", err);
476476
}
477477

478478
/**
@@ -495,16 +495,16 @@ ZTEST_USER(canfd, test_set_timing_data_max)
495495
int err;
496496

497497
err = can_stop(can_dev);
498-
zassert_equal(err, 0, "failed to stop CAN controller (err %d)", err);
498+
zassert_ok(err, "failed to stop CAN controller (err %d)", err);
499499

500500
err = can_set_timing_data(can_dev, can_get_timing_data_max(can_dev));
501-
zassert_equal(err, 0, "failed to set maximum timing data parameters (err %d)", err);
501+
zassert_ok(err, "failed to set maximum timing data parameters (err %d)", err);
502502

503503
err = can_set_bitrate_data(can_dev, CONFIG_CAN_DEFAULT_BITRATE_DATA);
504-
zassert_equal(err, 0, "failed to restore default data bitrate");
504+
zassert_ok(err, "failed to restore default data bitrate");
505505

506506
err = can_start(can_dev);
507-
zassert_equal(err, 0, "failed to start CAN controller (err %d)", err);
507+
zassert_ok(err, "failed to start CAN controller (err %d)", err);
508508
}
509509

510510
/**
@@ -549,7 +549,7 @@ static bool canfd_predicate(const void *state)
549549
}
550550

551551
err = can_get_capabilities(can_dev, &cap);
552-
zassert_equal(err, 0, "failed to get CAN controller capabilities (err %d)", err);
552+
zassert_ok(err, "failed to get CAN controller capabilities (err %d)", err);
553553

554554
if ((cap & CAN_MODE_FD) == 0) {
555555
return false;

0 commit comments

Comments
 (0)