tests/test_core.c

   1 #include <obd2/obd2.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
  12 void response_received_handler(const DiagnosticResponse* response) {
  13     last_response_was_received = true;
  14     // TODO not sure if we can copy the struct like this
  15     last_response_received = *response;
  16 }
  17
  18 START_TEST (test_receive_wrong_arb_id)
  19 {
  20     DiagnosticRequest request = {
  21         arbitration_id: 0x7df,
  22         mode: OBD2_MODE_POWERTRAIN_DIAGNOSTIC_REQUEST
  23     };
  24     DiagnosticRequestHandle handle = diagnostic_request(&SHIMS, &request,
  25             response_received_handler);
  26
  27     fail_if(last_response_was_received);
  28     const uint8_t can_data[] = {0x2, request.mode + 0x40, 0x23};
  29     diagnostic_receive_can_frame(&SHIMS, &handle, request.arbitration_id,
  30             can_data, sizeof(can_data));
  31     fail_if(last_response_was_received);
  32 }
  33 END_TEST
  34
  35 START_TEST (test_send_diag_request)
  36 {
  37     DiagnosticRequest request = {
  38         arbitration_id: 0x7df,
  39         mode: OBD2_MODE_POWERTRAIN_DIAGNOSTIC_REQUEST
  40     };
  41     DiagnosticRequestHandle handle = diagnostic_request(&SHIMS, &request,
  42             response_received_handler);
  43
  44     fail_if(handle.completed);
  45
  46     fail_if(last_response_was_received);
  47     const uint8_t can_data[] = {0x2, request.mode + 0x40, 0x23};
  48     DiagnosticResponse response = diagnostic_receive_can_frame(&SHIMS, &handle,
  49             request.arbitration_id + 0x8, can_data, sizeof(can_data));
  50     fail_unless(response.success);
  51     fail_unless(response.completed);
  52     fail_unless(handle.completed);
  53     ck_assert(last_response_received.success);
  54     ck_assert_int_eq(last_response_received.arbitration_id,
  55             request.arbitration_id + 0x8);
  56     ck_assert_int_eq(last_response_received.mode, request.mode);
  57     ck_assert_int_eq(last_response_received.pid, 0);
  58     ck_assert_int_eq(last_response_received.payload_length, 1);
  59     ck_assert_int_eq(last_response_received.payload[0], can_data[2]);
  60 }
  61 END_TEST
  62
  63 START_TEST (test_request_pid_standard)
  64 {
  65     // TODO need a constant for the 7df broadcast functional request
  66     uint16_t arb_id = 0x7df;
  67     DiagnosticRequestHandle handle = diagnostic_request_pid(&SHIMS,
  68             DIAGNOSTIC_STANDARD_PID, arb_id, 0x2, response_received_handler);
  69
  70     fail_if(last_response_was_received);
  71     const uint8_t can_data[] = {0x3, 0x1 + 0x40, 0x2, 0x45};
  72     diagnostic_receive_can_frame(&SHIMS, &handle, arb_id + 0x8,
  73             can_data, sizeof(can_data));
  74     fail_unless(last_response_was_received);
  75     ck_assert(last_response_received.success);
  76     ck_assert_int_eq(last_response_received.arbitration_id,
  77             arb_id + 0x8);
  78     ck_assert_int_eq(last_response_received.mode, 0x1);
  79     ck_assert_int_eq(last_response_received.pid, 0x2);
  80     ck_assert_int_eq(last_response_received.payload_length, 1);
  81     ck_assert_int_eq(last_response_received.payload[0], can_data[3]);
  82 }
  83 END_TEST
  84
  85 START_TEST (test_request_pid_enhanced)
  86 {
  87     uint16_t arb_id = 0x7df;
  88     DiagnosticRequestHandle handle = diagnostic_request_pid(&SHIMS,
  89             DIAGNOSTIC_ENHANCED_PID, arb_id, 0x2, response_received_handler);
  90
  91     fail_if(last_response_was_received);
  92     const uint8_t can_data[] = {0x4, 0x22 + 0x40, 0x0, 0x2, 0x45};
  93     diagnostic_receive_can_frame(&SHIMS, &handle, arb_id + 0x8, can_data,
  94             sizeof(can_data));
  95     fail_unless(last_response_was_received);
  96     ck_assert(last_response_received.success);
  97     ck_assert_int_eq(last_response_received.arbitration_id,
  98             arb_id + 0x8);
  99     ck_assert_int_eq(last_response_received.mode, 0x22);
 100     ck_assert_int_eq(last_response_received.pid, 0x2);
 101     ck_assert_int_eq(last_response_received.payload_length, 1);
 102     ck_assert_int_eq(last_response_received.payload[0], can_data[4]);
 103 }
 104 END_TEST
 105
 106 START_TEST (test_wrong_mode_response)
 107 {
 108     uint16_t arb_id = 0x7df;
 109     DiagnosticRequestHandle handle = diagnostic_request_pid(&SHIMS,
 110             DIAGNOSTIC_ENHANCED_PID, arb_id, 0x2, response_received_handler);
 111
 112     fail_if(last_response_was_received);
 113     const uint8_t can_data[] = {0x4, 0x1 + 0x40, 0x0, 0x2, 0x45};
 114     diagnostic_receive_can_frame(&SHIMS, &handle, arb_id + 0x8, can_data,
 115             sizeof(can_data));
 116     fail_unless(last_response_was_received);
 117     fail_if(last_response_received.success);
 118 }
 119 END_TEST
 120
 121 Suite* testSuite(void) {
 122     Suite* s = suite_create("obd2");
 123     TCase *tc_core = tcase_create("core");
 124     tcase_add_checked_fixture(tc_core, setup, NULL);
 125     tcase_add_test(tc_core, test_send_diag_request);
 126     tcase_add_test(tc_core, test_receive_wrong_arb_id);
 127     tcase_add_test(tc_core, test_request_pid_standard);
 128     tcase_add_test(tc_core, test_request_pid_enhanced);
 129     tcase_add_test(tc_core, test_wrong_mode_response);
 130
 131     // TODO these are future work:
 132     // TODO test request MIL
 133     // TODO test request VIN
 134     // TODO test request DTC
 135     // TODO test clear DTC
 136     // TODO test enumerate PIDs
 137     suite_add_tcase(s, tc_core);
 138
 139     return s;
 140 }
 141
 142 int main(void) {
 143     int numberFailed;
 144     Suite* s = testSuite();
 145     SRunner *sr = srunner_create(s);
 146     // Don't fork so we can actually use gdb
 147     srunner_set_fork_status(sr, CK_NOFORK);
 148     srunner_run_all(sr, CK_NORMAL);
 149     numberFailed = srunner_ntests_failed(sr);
 150     srunner_free(sr);
 151     return (numberFailed == 0) ? 0 : 1;
 152 }