Fix C++ wrapper reliability issues, add 19 unit tests

Bug fixes:
- Light::write(IPacket): return actual byte count instead of bool (was
  converting result > 0, destroying error info and always returning 0 or 1)
- IFd::run_tx(write_func): break on write returning 0 to prevent infinite
  loop when device is busy (was spinning forever on len -= 0)
- IFd::run_rx/run_tx: increase internal buffer from 4 to 64 bytes for
  better throughput on high-speed serial connections
- IHdlcLinkLayer::getData(): protect m_flushFlag read with m_sendMutex
  to fix race condition with flushTx() from another thread
- ISerialLinkLayer::runTx(): break on write returning 0 (same infinite
  loop fix as IFd::run_tx)
- FdD destructor: store original uintptr_t* pointer to fix undefined
  behavior from delete[] on mismatched type (was allocating uintptr_t[]
  but deleting as uint8_t[])
- Proto::end(): add null check for m_link before calling m_link->end()
- Proto::getLostRxFrames(): protect counter access with mutex

New tests (19 added, 101 total):
- CPP_LIGHT (3): WriteReturnsByteCount, WritePacketReturnsByteCount,
  SendAndReceive
- CPP_HDLC (3): WriteAndGenerateTxData, SendAndReceiveFrame,
  WritePacketInterface
- CPP_FD (10): BeginAndEnd, StaticBufferVariant, DynamicAllocationCleanup,
  WriteReturnsProperValues, RunRxWithDirectData, RunTxGeneratesData,
  RunTxCallbackBreaksOnZeroWrite, ReceiveCallback, ConnectEventCallback,
  CrcModes
- CPP_PACKET (3): PutAndRead, CopyConstructor, Clear

Co-authored-by: Copilot <[email protected]>

Author: lexus2k

Makefile.cpputest

@@ -22,6 +22,7 @@ OBJ_UNIT_TEST = \
         unittest/tiny_fd_nrm_tests.o \
         unittest/fd_tests.o \
         unittest/fd_multidrop_tests.o \
+        unittest/cpp_wrapper_tests.o \
 
 
 unittest: $(OBJ_UNIT_TEST) library

src/TinyLightProtocol.cpp

@@ -64,7 +64,7 @@ int Light::read(char *buf, int size)
 
 int Light::write(const IPacket &pkt)
 {
-    return tiny_light_send(&m_data, pkt.m_buf, pkt.m_len) > 0;
+    return tiny_light_send(&m_data, pkt.m_buf, pkt.m_len);
 }
 
 int Light::read(IPacket &pkt)

src/TinyProtocol.cpp

@@ -194,7 +194,10 @@ void Proto::end()
         m_readThread = nullptr;
     }
 #endif
-    m_link->end();
+    if ( m_link )
+    {
+        m_link->end();
+    }
     return;
 }
 
@@ -314,8 +317,10 @@ void Proto::setTxDelay( uint32_t delay )
 
 int Proto::getLostRxFrames()
 {
+    tiny_mutex_lock( &m_mutex );
     int val = m_lostRxFrames;
     m_lostRxFrames = 0;
+    tiny_mutex_unlock( &m_mutex );
     return val;
 }
 #endif

src/TinyProtocolFd.cpp

@@ -99,7 +99,7 @@ int IFd::run_rx(const void *data, int len)
 
 int IFd::run_rx(read_block_cb_t read_func)
 {
-    uint8_t buf[4];
+    uint8_t buf[64];
     int len = read_func(m_userData, buf, sizeof(buf));
     if ( len <= 0 )
     {
@@ -115,7 +115,7 @@ int IFd::run_tx(void *data, int max_size)
 
 int IFd::run_tx(write_block_cb_t write_func)
 {
-    uint8_t buf[4];
+    uint8_t buf[64];
     int len = tiny_fd_get_tx_data(m_handle, buf, sizeof(buf), 0);
     if ( len <= 0 )
     {
@@ -125,9 +125,9 @@ int IFd::run_tx(write_block_cb_t write_func)
     while ( len )
     {
         int result = write_func(m_userData, ptr, len);
-        if ( result < 0 )
+        if ( result <= 0 )
         {
-            return result;
+            return result < 0 ? result : TINY_ERR_FAILED;
         }
         len -= result;
         ptr += result;

src/TinyProtocolFd.h

@@ -371,15 +371,18 @@ class FdD: public IFd
      */
     explicit FdD(int size)
         : IFd(reinterpret_cast<uint8_t *>(new uintptr_t[(size + TINY_ALIGN_STRUCT_VALUE - 1) / TINY_ALIGN_STRUCT_VALUE]), size)
+        , m_allocated(reinterpret_cast<uintptr_t *>(m_buffer))
     {
     }
 
     ~FdD()
     {
-        delete[] m_buffer;
+        end();
+        delete[] m_allocated;
     }
 
 private:
+    uintptr_t *m_allocated = nullptr;
 };
 
 /**

src/link/TinyHdlcLinkLayer.cpp

@@ -124,15 +124,19 @@ int IHdlcLinkLayer::getData(uint8_t *data, int size)
 {
     if ( tiny_events_wait( &m_events, TX_MESSAGE_SENDING, EVENT_BITS_LEAVE, getTimeout() ) )
     {
-        if ( m_flushFlag )
+        tiny_mutex_lock( &m_sendMutex );
+        bool flush = m_flushFlag;
+        if ( flush )
         {
-//            tiny_mutex_lock( &m_sendMutex );
             m_flushFlag = false;
             hdlc_ll_reset( m_handle, HDLC_LL_RESET_TX_ONLY );
             tiny_events_clear( &m_events, TX_MESSAGE_SENDING );
             tiny_events_set( &m_events, TX_QUEUE_FREE );
-//            tiny_events_clear( &m_events, TX_MESSAGE_SENDING );
-//            tiny_mutex_unlock( &m_sendMutex );
+        }
+        tiny_mutex_unlock( &m_sendMutex );
+        if ( flush )
+        {
+            return 0;
         }
         return hdlc_ll_run_tx(m_handle, data, size);
     }

src/link/TinySerialLinkLayer.h

@@ -88,7 +88,7 @@ template <class BASE, int BSIZE> class ISerialLinkLayer: public BASE
         while ( len > 0 )
         {
             int sent = m_serial.write(ptr, len);
-            if ( sent < 0 )
+            if ( sent <= 0 )
             {
                 break;
             }