Issue 1 accessory address translation fix

accessory_address_translation_test.c

@@ -0,0 +1,177 @@
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+
+typedef enum {FALSE = 0, TRUE = !0} BOOL;
+typedef uint8_t BYTE;
+typedef uint16_t WORD;
+typedef uint32_t DWORD;
+typedef enum {INVALID = 0, VALID = 1} packet_status_t;
+
+struct
+{
+  BYTE RB0;
+  BYTE RB1;
+} PORTBbits;
+
+#define CANCMD 1
+#define near
+#define rom
+
+#include "packet_gen.c"
+
+DccFlags dcc_flags;
+OpFlags  op_flags;
+
+BYTE dcc_buff_s[7];
+BYTE dcc_buff_m[7];
+BYTE dcc_bytes_m;
+BYTE Tx1[14];
+WORD Node_id;
+
+ecan_rx_buffer *rx_ptr;
+
+ModNVPtr cmdNVptr;
+ModeWord mode_word;
+
+const NodevarTable nodevartable;
+
+unsigned int  cv;
+unsigned char cv_data;
+
+ActiveShuttleEntry activeShuttleTable[MAX_HANDLES];
+
+DelayListEntry delayedEvents[MAX_DELAYED_EVENTS];
+
+void
+clear_shuttle_entry(BYTE)
+{}
+
+void
+sendCbusMsg()
+{}
+
+void
+set_shuttle_loco( BYTE, BYTE)
+{}
+
+BOOL
+populate_shuttle(BYTE session, BYTE shuttle_id, BOOL ifempty)
+{
+  return TRUE;
+}
+
+void
+sendCbusDebugEvent(WORD, BYTE*)
+{}
+
+BOOL
+addDelayedEvent(BYTE, BYTE, enum eventActions, BYTE)
+{}
+
+void
+stopAll()
+{}
+
+int
+main(int, char**)
+{
+  struct test_values
+  {
+    WORD event_number;
+    BOOL is_acc_on;
+    packet_status_t expected_status;
+    BYTE expected_d0;
+    BYTE expected_d1;
+  };
+
+  const BOOL ASON = TRUE;
+  const BOOL ASOF = FALSE;
+
+  const struct test_values test_data[] = {{   0, ASOF,   VALID, 0x81, 0xF8},
+                                          {   0, ASON,   VALID, 0x81, 0xF9},
+                                          {   1, ASOF,   VALID, 0x81, 0xFA},
+                                          {   1, ASON,   VALID, 0x81, 0xFB},
+                                          {   3, ASOF,   VALID, 0x81, 0xFE},
+                                          {   3, ASON,   VALID, 0x81, 0xFF},
+                                          {   4, ASOF,   VALID, 0x82, 0xF8},
+                                          {   4, ASON,   VALID, 0x82, 0xF9},
+                                          {   5, ASOF,   VALID, 0x82, 0xFA},
+                                          {   5, ASON,   VALID, 0x82, 0xFB},
+                                          { 250, ASOF,   VALID, 0xBF, 0xFC},
+                                          { 250, ASON,   VALID, 0xBF, 0xFD},
+                                          { 251, ASOF,   VALID, 0xBF, 0xFE},
+                                          { 251, ASON,   VALID, 0xBF, 0xFF},
+                                          { 252, ASOF,   VALID, 0x80, 0xE8},
+                                          { 252, ASON,   VALID, 0x80, 0xE9},
+                                          { 253, ASOF,   VALID, 0x80, 0xEA},
+                                          { 253, ASON,   VALID, 0x80, 0xEB},
+                                          { 254, ASOF,   VALID, 0x80, 0xEC},
+                                          { 254, ASON,   VALID, 0x80, 0xED},
+                                          { 255, ASOF,   VALID, 0x80, 0xEE},
+                                          { 255, ASON,   VALID, 0x80, 0xEF},
+                                          { 504, ASOF,   VALID, 0xBF, 0xE8},
+                                          { 504, ASON,   VALID, 0xBF, 0xE9},
+                                          {2039, ASOF,   VALID, 0xBE, 0x8E},
+                                          {2039, ASON,   VALID, 0xBE, 0x8F},
+                                          {2040, ASOF,   VALID, 0xBF, 0x88},
+                                          {2040, ASON,   VALID, 0xBF, 0x89},
+                                          {2041, ASOF,   VALID, 0xBF, 0x8A},
+                                          {2041, ASON,   VALID, 0xBF, 0x8B},
+                                          {2043, ASOF,   VALID, 0xBF, 0x8E},
+                                          {2043, ASON,   VALID, 0xBF, 0x8F},
+                                          {2044, ASOF,   VALID, 0x80, 0xF8},
+                                          {2044, ASON,   VALID, 0x80, 0xF9},
+                                          {2045, ASOF,   VALID, 0x80, 0xFA},
+                                          {2045, ASON,   VALID, 0x80, 0xFB},
+                                          {2046, ASOF,   VALID, 0x80, 0xFC},
+                                          {2046, ASON,   VALID, 0x80, 0xFD},
+                                          {2047, ASOF,   VALID, 0x80, 0xFE},
+                                          {2047, ASON,   VALID, 0x80, 0xFF},
+                                          {2048, ASOF,   VALID, 0x81, 0xF8},
+                                          {2048, ASON,   VALID, 0x81, 0xF9}};
+  const size_t number_of_tests = sizeof(test_data)/sizeof(test_data[0]);
+
+  dcc_queue_t *s_ptr = NULL;
+
+  s_head = 0;
+
+  for (size_t test_index = 0; number_of_tests > test_index; ++test_index)
+  {
+    const struct test_values *test = &test_data[test_index];
+
+    s_ptr = &s_queue[s_head];
+
+    s_ptr->status.valid = INVALID;
+
+    dccAccessoryWrite(test->event_number, test->is_acc_on);
+
+    printf("Test %lu: Event %s(%u); ",
+           test_index, test->is_acc_on ? "ASON" : "ASOF",
+           test->event_number);
+    if (INVALID == test->expected_status)
+    {
+      printf("Expected invalid packet; Got %s packet; %s\n",
+             (INVALID == s_ptr->status.valid) ? "valid" : "invalid",
+             (INVALID == s_ptr->status.valid) ? "PASS" : "FAIL");
+    }
+    else
+    {
+      printf("Expected: 0x%X, 0x%X; Got", test->expected_d0, test->expected_d1);
+      if (INVALID == test->expected_status)
+      {
+        printf(" invalid packet; FAIL\n");
+      }
+      else
+      {
+        printf(": 0x%X, 0x%X; %s\n",
+               s_ptr->d[0], s_ptr->d[1],
+               (test->expected_d0 == s_ptr->d[0] &&
+                test->expected_d1 == s_ptr->d[1]) ? "PASS" : "FAIL");
+      }
+    }
+  }
+
+  return 0;
+}

accessory_address_translation_test.log

@@ -0,0 +1,42 @@
+Test 0: Event ASOF(0); Expected: 0x81, 0xF8; Got: 0x81, 0xF8; PASS
+Test 1: Event ASON(0); Expected: 0x81, 0xF9; Got: 0x81, 0xF9; PASS
+Test 2: Event ASOF(1); Expected: 0x81, 0xFA; Got: 0x81, 0xFA; PASS
+Test 3: Event ASON(1); Expected: 0x81, 0xFB; Got: 0x81, 0xFB; PASS
+Test 4: Event ASOF(3); Expected: 0x81, 0xFE; Got: 0x81, 0xFE; PASS
+Test 5: Event ASON(3); Expected: 0x81, 0xFF; Got: 0x81, 0xFF; PASS
+Test 6: Event ASOF(4); Expected: 0x82, 0xF8; Got: 0x82, 0xF8; PASS
+Test 7: Event ASON(4); Expected: 0x82, 0xF9; Got: 0x82, 0xF9; PASS
+Test 8: Event ASOF(5); Expected: 0x82, 0xFA; Got: 0x82, 0xFA; PASS
+Test 9: Event ASON(5); Expected: 0x82, 0xFB; Got: 0x82, 0xFB; PASS
+Test 10: Event ASOF(250); Expected: 0xBF, 0xFC; Got: 0xBF, 0xFC; PASS
+Test 11: Event ASON(250); Expected: 0xBF, 0xFD; Got: 0xBF, 0xFD; PASS
+Test 12: Event ASOF(251); Expected: 0xBF, 0xFE; Got: 0xBF, 0xFE; PASS
+Test 13: Event ASON(251); Expected: 0xBF, 0xFF; Got: 0xBF, 0xFF; PASS
+Test 14: Event ASOF(252); Expected: 0x80, 0xE8; Got: 0x80, 0xE8; PASS
+Test 15: Event ASON(252); Expected: 0x80, 0xE9; Got: 0x80, 0xE9; PASS
+Test 16: Event ASOF(253); Expected: 0x80, 0xEA; Got: 0x80, 0xEA; PASS
+Test 17: Event ASON(253); Expected: 0x80, 0xEB; Got: 0x80, 0xEB; PASS
+Test 18: Event ASOF(254); Expected: 0x80, 0xEC; Got: 0x80, 0xEC; PASS
+Test 19: Event ASON(254); Expected: 0x80, 0xED; Got: 0x80, 0xED; PASS
+Test 20: Event ASOF(255); Expected: 0x80, 0xEE; Got: 0x80, 0xEE; PASS
+Test 21: Event ASON(255); Expected: 0x80, 0xEF; Got: 0x80, 0xEF; PASS
+Test 22: Event ASOF(504); Expected: 0xBF, 0xE8; Got: 0xBF, 0xE8; PASS
+Test 23: Event ASON(504); Expected: 0xBF, 0xE9; Got: 0xBF, 0xE9; PASS
+Test 24: Event ASOF(2039); Expected: 0xBE, 0x8E; Got: 0xBE, 0x8E; PASS
+Test 25: Event ASON(2039); Expected: 0xBE, 0x8F; Got: 0xBE, 0x8F; PASS
+Test 26: Event ASOF(2040); Expected: 0xBF, 0x88; Got: 0xBF, 0x88; PASS
+Test 27: Event ASON(2040); Expected: 0xBF, 0x89; Got: 0xBF, 0x89; PASS
+Test 28: Event ASOF(2041); Expected: 0xBF, 0x8A; Got: 0xBF, 0x8A; PASS
+Test 29: Event ASON(2041); Expected: 0xBF, 0x8B; Got: 0xBF, 0x8B; PASS
+Test 30: Event ASOF(2043); Expected: 0xBF, 0x8E; Got: 0xBF, 0x8E; PASS
+Test 31: Event ASON(2043); Expected: 0xBF, 0x8F; Got: 0xBF, 0x8F; PASS
+Test 32: Event ASOF(2044); Expected: 0x80, 0xF8; Got: 0x80, 0xF8; PASS
+Test 33: Event ASON(2044); Expected: 0x80, 0xF9; Got: 0x80, 0xF9; PASS
+Test 34: Event ASOF(2045); Expected: 0x80, 0xFA; Got: 0x80, 0xFA; PASS
+Test 35: Event ASON(2045); Expected: 0x80, 0xFB; Got: 0x80, 0xFB; PASS
+Test 36: Event ASOF(2046); Expected: 0x80, 0xFC; Got: 0x80, 0xFC; PASS
+Test 37: Event ASON(2046); Expected: 0x80, 0xFD; Got: 0x80, 0xFD; PASS
+Test 38: Event ASOF(2047); Expected: 0x80, 0xFE; Got: 0x80, 0xFE; PASS
+Test 39: Event ASON(2047); Expected: 0x80, 0xFF; Got: 0x80, 0xFF; PASS
+Test 40: Event ASOF(2048); Expected: 0x81, 0xF8; Got: 0x81, 0xF8; PASS
+Test 41: Event ASON(2048); Expected: 0x81, 0xF9; Got: 0x81, 0xF9; PASS

accessory_address_translation_test.sh

@@ -0,0 +1,50 @@
+#!/bin/bash
+mock_headers()
+{
+  for header_to_mock in $*
+  do
+    if [[ ! -e ${header_to_mock} ]]
+    then
+      touch ${header_to_mock} $(basename ${header_to_mock} .h).mocked
+    fi
+  done
+}
+
+link_headers()
+{
+  for header_link in $*
+  do
+    IFS=","
+    set -- ${header_link}
+    source=${1}
+    target=${2}
+    if [[ ${2} == "." ]]
+    then
+      target=$(basename ${source})
+    fi
+    if [[ ! -e ${target} ]]
+    then
+      ln -s ${source} ${target}
+    fi
+  done
+}
+
+cleanup_headers()
+{
+  for header_to_clean in $*
+  do
+    if [[ -f $(basename ${header_to_clean} .h).mocked ]]
+    then
+      rm ${header_to_clean} $(basename ${header_to_clean} .h).mocked
+    elif [[ -L ${header_to_clean} ]]
+    then
+      rm ${header_to_clean}
+    fi
+  done
+}
+
+mock_headers devincs.h GenericTypeDefs.h
+link_headers FliM.h,FLiM.h ../cbusdefs/cbusdefs.h,.
+gcc -ggdb -O0 -I. accessory_address_translation_test.c && ./a.out | tee accessory_address_translation_test.log
+#gcc -ggdb -O0 -I. accessory_address_translation_test.c && ddd ./a.out
+cleanup_headers devincs.h GenericTypeDefs.h FLiM.h cbusdefs.h