tests/test_core.c

   1 #include <uds/uds.h>
   2 #include <check.h>
   3 #include <stdint.h>
   4 #include <stdio.h>
   5 #include <stdbool.h>
   6
   7 extern void setup();
   8 extern bool last_response_was_received;
   9 extern DiagnosticResponse last_response_received;
  10 extern DiagnosticShims SHIMS;
  11 extern uint16_t last_can_frame_sent_arb_id;
  12 extern uint8_t last_can_payload_sent[8];
  13 extern uint8_t last_can_payload_size;
  14
  15 void response_received_handler(const DiagnosticResponse* response) {
  16     last_response_was_received = true;
  17     last_response_received = *response;
  18 }
  19
  20 START_TEST (test_receive_wrong_arb_id)
  21 {
  22     DiagnosticRequest request = {
  23         arbitration_id: 0x100,
  24         mode: OBD2_MODE_POWERTRAIN_DIAGNOSTIC_REQUEST
  25     };
  26     DiagnosticRequestHandle handle = diagnostic_request(&SHIMS, &request,
  27             response_received_handler);
  28
  29     fail_if(last_response_was_received);
  30     const uint8_t can_data[] = {0x2, request.mode + 0x40, 0x23};
  31     diagnostic_receive_can_frame(&SHIMS, &handle, request.arbitration_id,
  32             can_data, sizeof(can_data));
  33     fail_if(last_response_was_received);
  34 }
  35 END_TEST
  36
  37 START_TEST (test_send_diag_request_with_payload)
  38 {
  39     DiagnosticRequest request = {
  40         arbitration_id: 0x100,
  41         mode: OBD2_MODE_POWERTRAIN_DIAGNOSTIC_REQUEST,
  42         payload: {0x12, 0x34},
  43         payload_length: 2,
  44         no_frame_padding: true
  45     };
  46     DiagnosticRequestHandle handle = diagnostic_request(&SHIMS, &request,
  47             response_received_handler);
  48
  49     fail_if(handle.completed);
  50     // TODO it'd be better to check the ISO-TP message instead of the CAN frame,
  51     // but we don't have a good way to do that
  52     ck_assert_int_eq(last_can_frame_sent_arb_id, request.arbitration_id);
  53     ck_assert_int_eq(last_can_payload_sent[1], request.mode);
  54     ck_assert_int_eq(last_can_payload_size, 4);
  55     ck_assert_int_eq(last_can_payload_sent[2], request.payload[0]);
  56     ck_assert_int_eq(last_can_payload_sent[3], request.payload[1]);
  57 }
  58 END_TEST
  59
  60 START_TEST (test_send_functional_request)
  61 {
  62     DiagnosticRequest request = {
  63         arbitration_id: OBD2_FUNCTIONAL_BROADCAST_ID,
  64         mode: OBD2_MODE_EMISSIONS_DTC_REQUEST,
  65         no_frame_padding: true
  66     };
  67     DiagnosticRequestHandle handle = diagnostic_request(&SHIMS, &request,
  68             response_received_handler);
  69
  70     fail_if(handle.completed);
  71     ck_assert_int_eq(last_can_frame_sent_arb_id, request.arbitration_id);
  72     ck_assert_int_eq(last_can_payload_sent[1], request.mode);
  73     ck_assert_int_eq(last_can_payload_size, 2);
  74
  75     fail_if(last_response_was_received);
  76     const uint8_t can_data[] = {0x2, request.mode + 0x40, 0x23};
  77     for(uint16_t filter = OBD2_FUNCTIONAL_RESPONSE_START; filter <
  78             OBD2_FUNCTIONAL_RESPONSE_START + OBD2_FUNCTIONAL_RESPONSE_COUNT;
  79             filter++) {
  80         DiagnosticResponse response = diagnostic_receive_can_frame(&SHIMS, &handle,
  81                 filter, can_data, sizeof(can_data));
  82         fail_unless(response.success);
  83         fail_unless(response.completed);
  84         fail_unless(handle.completed);
  85         ck_assert(last_response_received.success);
  86         ck_assert_int_eq(last_response_received.arbitration_id,
  87                 filter);
  88         ck_assert_int_eq(last_response_received.mode, request.mode);
  89         fail_if(last_response_received.has_pid);
  90         ck_assert_int_eq(last_response_received.payload_length, 1);
  91         ck_assert_int_eq(last_response_received.payload[0], can_data[2]);
  92     }
  93 }
  94 END_TEST
  95
  96 START_TEST (test_sent_message_no_padding)
  97 {
  98     DiagnosticRequest request = {
  99         arbitration_id: 0x100,
 100         mode: OBD2_MODE_EMISSIONS_DTC_REQUEST,
 101         no_frame_padding: true
 102     };
 103     DiagnosticRequestHandle handle = diagnostic_request(&SHIMS, &request,
 104             response_received_handler);
 105
 106     fail_if(handle.completed);
 107     ck_assert_int_eq(last_can_frame_sent_arb_id, request.arbitration_id);
 108     ck_assert_int_eq(last_can_payload_size, 2);
 109 }
 110 END_TEST
 111
 112 START_TEST (test_sent_message_is_padded_by_default)
 113 {
 114     DiagnosticRequest request = {
 115         arbitration_id: 0x100,
 116         mode: OBD2_MODE_EMISSIONS_DTC_REQUEST
 117     };
 118     DiagnosticRequestHandle handle = diagnostic_request(&SHIMS, &request,
 119             response_received_handler);
 120
 121     fail_if(handle.completed);
 122     ck_assert_int_eq(last_can_frame_sent_arb_id, request.arbitration_id);
 123     ck_assert_int_eq(last_can_payload_size, 8);
 124 }
 125 END_TEST
 126
 127 START_TEST (test_sent_message_is_padded)
 128 {
 129     DiagnosticRequest request = {
 130         arbitration_id: 0x100,
 131         mode: OBD2_MODE_EMISSIONS_DTC_REQUEST,
 132         no_frame_padding: false
 133     };
 134     DiagnosticRequestHandle handle = diagnostic_request(&SHIMS, &request,
 135             response_received_handler);
 136
 137     fail_if(handle.completed);
 138     ck_assert_int_eq(last_can_frame_sent_arb_id, request.arbitration_id);
 139     ck_assert_int_eq(last_can_payload_size, 8);
 140 }
 141 END_TEST
 142
 143 START_TEST (test_send_diag_request)
 144 {
 145     DiagnosticRequest request = {
 146         arbitration_id: 0x100,
 147         mode: OBD2_MODE_EMISSIONS_DTC_REQUEST,
 148         no_frame_padding: true
 149     };
 150     DiagnosticRequestHandle handle = diagnostic_request(&SHIMS, &request,
 151             response_received_handler);
 152
 153     fail_if(handle.completed);
 154     ck_assert_int_eq(last_can_frame_sent_arb_id, request.arbitration_id);
 155     ck_assert_int_eq(last_can_payload_sent[1], request.mode);
 156     ck_assert_int_eq(last_can_payload_size, 2);
 157
 158     fail_if(last_response_was_received);
 159     const uint8_t can_data[] = {0x2, request.mode + 0x40, 0x23};
 160     DiagnosticResponse response = diagnostic_receive_can_frame(&SHIMS, &handle,
 161             request.arbitration_id + 0x8, can_data, sizeof(can_data));
 162     fail_unless(response.success);
 163     fail_unless(response.completed);
 164     fail_unless(handle.completed);
 165     ck_assert(last_response_received.success);
 166     ck_assert_int_eq(last_response_received.arbitration_id,
 167             request.arbitration_id + 0x8);
 168     ck_assert_int_eq(last_response_received.mode, request.mode);
 169         fail_if(last_response_received.has_pid);
 170     ck_assert_int_eq(last_response_received.payload_length, 1);
 171     ck_assert_int_eq(last_response_received.payload[0], can_data[2]);
 172 }
 173 END_TEST
 174
 175 START_TEST (test_autoset_pid_length)
 176 {
 177     uint16_t arb_id = OBD2_MODE_POWERTRAIN_DIAGNOSTIC_REQUEST;
 178     diagnostic_request_pid(&SHIMS, DIAGNOSTIC_STANDARD_PID, arb_id, 0x2,
 179             response_received_handler);
 180
 181     ck_assert_int_eq(last_can_frame_sent_arb_id, arb_id);
 182     ck_assert_int_eq(last_can_payload_sent[1], 0x1);
 183     ck_assert_int_eq(last_can_payload_sent[2], 0x2);
 184     // padding is on for the diagnostic_request_pid helper function - if you
 185     // need to turn it off, use the more manual diagnostic_request(...)
 186     ck_assert_int_eq(last_can_payload_size, 8);
 187
 188     DiagnosticRequest request = {
 189         arbitration_id: 0x100,
 190         mode: 0x22,
 191         has_pid: true,
 192         pid: 2,
 193         no_frame_padding: true
 194     };
 195     diagnostic_request(&SHIMS, &request, response_received_handler);
 196
 197     ck_assert_int_eq(last_can_frame_sent_arb_id, request.arbitration_id);
 198     ck_assert_int_eq(last_can_payload_sent[1], request.mode);
 199     ck_assert_int_eq(last_can_payload_size, 4);
 200 }
 201 END_TEST
 202
 203 START_TEST (test_request_pid_standard)
 204 {
 205     uint16_t arb_id = OBD2_MODE_POWERTRAIN_DIAGNOSTIC_REQUEST;
 206     DiagnosticRequestHandle handle = diagnostic_request_pid(&SHIMS,
 207             DIAGNOSTIC_STANDARD_PID, arb_id, 0x2, response_received_handler);
 208
 209     fail_if(last_response_was_received);
 210     const uint8_t can_data[] = {0x3, 0x1 + 0x40, 0x2, 0x45};
 211     diagnostic_receive_can_frame(&SHIMS, &handle, arb_id + 0x8,
 212             can_data, sizeof(can_data));
 213     fail_unless(last_response_was_received);
 214     ck_assert(last_response_received.success);
 215     ck_assert_int_eq(last_response_received.arbitration_id,
 216             arb_id + 0x8);
 217     ck_assert_int_eq(last_response_received.mode, 0x1);
 218     fail_unless(last_response_received.has_pid);
 219     ck_assert_int_eq(last_response_received.pid, 0x2);
 220     ck_assert_int_eq(last_response_received.payload_length, 1);
 221     ck_assert_int_eq(last_response_received.payload[0], can_data[3]);
 222 }
 223 END_TEST
 224
 225 START_TEST (test_request_pid_enhanced)
 226 {
 227     uint16_t arb_id = 0x100;
 228     DiagnosticRequestHandle handle = diagnostic_request_pid(&SHIMS,
 229             DIAGNOSTIC_ENHANCED_PID, arb_id, 0x2, response_received_handler);
 230
 231     fail_if(last_response_was_received);
 232     const uint8_t can_data[] = {0x4, 0x22 + 0x40, 0x0, 0x2, 0x45};
 233     diagnostic_receive_can_frame(&SHIMS, &handle, arb_id + 0x8, can_data,
 234             sizeof(can_data));
 235     fail_unless(last_response_was_received);
 236     ck_assert(last_response_received.success);
 237     ck_assert_int_eq(last_response_received.arbitration_id,
 238             arb_id + 0x8);
 239     ck_assert_int_eq(last_response_received.mode, 0x22);
 240     fail_unless(last_response_received.has_pid);
 241     ck_assert_int_eq(last_response_received.pid, 0x2);
 242     ck_assert_int_eq(last_response_received.payload_length, 1);
 243     ck_assert_int_eq(last_response_received.payload[0], can_data[4]);
 244 }
 245 END_TEST
 246
 247 START_TEST (test_wrong_mode_response)
 248 {
 249     uint16_t arb_id = 0x100;
 250     DiagnosticRequestHandle handle = diagnostic_request_pid(&SHIMS,
 251             DIAGNOSTIC_ENHANCED_PID, arb_id, 0x2, response_received_handler);
 252
 253     fail_if(last_response_was_received);
 254     const uint8_t can_data[] = {0x4, 0x1 + 0x40, 0x0, 0x2, 0x45};
 255     diagnostic_receive_can_frame(&SHIMS, &handle, arb_id + 0x8, can_data,
 256             sizeof(can_data));
 257     fail_if(last_response_was_received);
 258     fail_if(handle.completed);
 259 }
 260 END_TEST
 261
 262 START_TEST (test_missing_pid)
 263 {
 264     uint16_t arb_id = 0x100;
 265     DiagnosticRequestHandle handle = diagnostic_request_pid(&SHIMS,
 266             DIAGNOSTIC_ENHANCED_PID, arb_id, 0x2, response_received_handler);
 267
 268     fail_if(last_response_was_received);
 269     const uint8_t can_data[] = {0x1, 0x22 + 0x40};
 270     diagnostic_receive_can_frame(&SHIMS, &handle, arb_id + 0x8, can_data,
 271             sizeof(can_data));
 272     fail_if(last_response_was_received);
 273     fail_if(handle.completed);
 274 }
 275 END_TEST
 276
 277 START_TEST (test_wrong_pid_response)
 278 {
 279     uint16_t arb_id = 0x100;
 280     DiagnosticRequestHandle handle = diagnostic_request_pid(&SHIMS,
 281             DIAGNOSTIC_ENHANCED_PID, arb_id, 0x2, response_received_handler);
 282
 283     fail_if(last_response_was_received);
 284     const uint8_t can_data[] = {0x4, 0x22 + 0x40, 0x0, 0x3, 0x45};
 285     diagnostic_receive_can_frame(&SHIMS, &handle, arb_id + 0x8, can_data,
 286             sizeof(can_data));
 287     fail_if(last_response_was_received);
 288     fail_if(handle.completed);
 289 }
 290 END_TEST
 291
 292 START_TEST (test_wrong_pid_then_right_completes)
 293 {
 294     uint16_t arb_id = 0x100;
 295     DiagnosticRequestHandle handle = diagnostic_request_pid(&SHIMS,
 296             DIAGNOSTIC_ENHANCED_PID, arb_id, 0x2, response_received_handler);
 297
 298     fail_if(last_response_was_received);
 299     uint8_t can_data[] = {0x4, 0x22 + 0x40, 0x0, 0x3, 0x45};
 300     diagnostic_receive_can_frame(&SHIMS, &handle, arb_id + 0x8, can_data,
 301             sizeof(can_data));
 302     fail_if(last_response_was_received);
 303     fail_if(handle.completed);
 304
 305     can_data[3] = 0x2;
 306     diagnostic_receive_can_frame(&SHIMS, &handle, arb_id + 0x8, can_data,
 307             sizeof(can_data));
 308     fail_unless(last_response_was_received);
 309     fail_unless(handle.completed);
 310     fail_unless(handle.success);
 311     fail_unless(last_response_received.success);
 312     ck_assert_int_eq(last_response_received.pid, 0x2);
 313 }
 314 END_TEST
 315
 316 START_TEST (test_negative_response)
 317 {
 318     DiagnosticRequest request = {
 319         arbitration_id: 0x100,
 320         mode: OBD2_MODE_POWERTRAIN_DIAGNOSTIC_REQUEST
 321     };
 322     DiagnosticRequestHandle handle = diagnostic_request(&SHIMS, &request,
 323             response_received_handler);
 324     const uint8_t can_data[] = {0x3, 0x7f, request.mode, NRC_SERVICE_NOT_SUPPORTED};
 325     DiagnosticResponse response = diagnostic_receive_can_frame(&SHIMS, &handle,
 326             request.arbitration_id + 0x8, can_data, sizeof(can_data));
 327     fail_unless(response.completed);
 328     fail_if(response.success);
 329     fail_unless(handle.completed);
 330
 331     fail_if(last_response_received.success);
 332     ck_assert_int_eq(last_response_received.arbitration_id,
 333             request.arbitration_id + 0x8);
 334     ck_assert_int_eq(last_response_received.mode, request.mode);
 335     ck_assert_int_eq(last_response_received.pid, 0);
 336     ck_assert_int_eq(last_response_received.negative_response_code, NRC_SERVICE_NOT_SUPPORTED);
 337     ck_assert_int_eq(last_response_received.payload_length, 0);
 338 }
 339 END_TEST
 340
 341 START_TEST (test_payload_to_float)
 342 {
 343     uint16_t arb_id = OBD2_MODE_POWERTRAIN_DIAGNOSTIC_REQUEST;
 344     DiagnosticRequestHandle handle = diagnostic_request_pid(&SHIMS,
 345             DIAGNOSTIC_STANDARD_PID, arb_id, 0x2, response_received_handler);
 346
 347     fail_if(last_response_was_received);
 348     const uint8_t can_data[] = {0x4, 0x1 + 0x40, 0x2, 0x45, 0x12};
 349     DiagnosticResponse response = diagnostic_receive_can_frame(&SHIMS, &handle, arb_id + 0x8,
 350             can_data, sizeof(can_data));
 351     ck_assert_int_eq(diagnostic_payload_to_float(&response), 0x4512);
 352 }
 353 END_TEST
 354
 355 Suite* testSuite(void) {
 356     Suite* s = suite_create("uds");
 357     TCase *tc_core = tcase_create("core");
 358     tcase_add_checked_fixture(tc_core, setup, NULL);
 359     tcase_add_test(tc_core, test_sent_message_no_padding);
 360     tcase_add_test(tc_core, test_sent_message_is_padded);
 361     tcase_add_test(tc_core, test_sent_message_is_padded_by_default);
 362     tcase_add_test(tc_core, test_send_diag_request);
 363     tcase_add_test(tc_core, test_send_functional_request);
 364     tcase_add_test(tc_core, test_send_diag_request_with_payload);
 365     tcase_add_test(tc_core, test_receive_wrong_arb_id);
 366     tcase_add_test(tc_core, test_autoset_pid_length);
 367     tcase_add_test(tc_core, test_request_pid_standard);
 368     tcase_add_test(tc_core, test_request_pid_enhanced);
 369     tcase_add_test(tc_core, test_wrong_mode_response);
 370     tcase_add_test(tc_core, test_wrong_pid_response);
 371     tcase_add_test(tc_core, test_missing_pid);
 372     tcase_add_test(tc_core, test_wrong_pid_then_right_completes);
 373     tcase_add_test(tc_core, test_negative_response);
 374     tcase_add_test(tc_core, test_payload_to_float);
 375
 376     // TODO these are future work:
 377     // TODO test request MIL
 378     // TODO test request VIN
 379     // TODO test request DTC
 380     // TODO test clear DTC
 381     // TODO test enumerate PIDs
 382     suite_add_tcase(s, tc_core);
 383
 384     return s;
 385 }
 386
 387 int main(void) {
 388     int numberFailed;
 389     Suite* s = testSuite();
 390     SRunner *sr = srunner_create(s);
 391     // Don't fork so we can actually use gdb
 392     srunner_set_fork_status(sr, CK_NOFORK);
 393     srunner_run_all(sr, CK_NORMAL);
 394     numberFailed = srunner_ntests_failed(sr);
 395     srunner_free(sr);
 396     return (numberFailed == 0) ? 0 : 1;
 397 }