Add the ability to pack an RDMPDU

Author: peternewman

libs/acn/RDMPDU.cpp

@@ -29,6 +29,21 @@ namespace acn {
 using ola::io::OutputStream;
 using ola::network::HostToNetwork;
 
+unsigned int RDMPDU::DataSize() const {
+  return static_cast<unsigned int>(m_command.size());
+}
+
+bool RDMPDU::PackData(uint8_t *data, unsigned int *length) const {
+  *length = static_cast<unsigned int>(m_command.size());
+  memcpy(data, reinterpret_cast<const uint8_t*>(m_command.data()), *length);
+  return true;
+}
+
+void RDMPDU::PackData(ola::io::OutputStream *stream) const {
+  stream->Write(reinterpret_cast<const uint8_t*>(m_command.data()),
+                static_cast<unsigned int>(m_command.size()));
+}
+
 void RDMPDU::PrependPDU(ola::io::IOStack *stack) {
   uint8_t vector = HostToNetwork(ola::rdm::START_CODE);
   stack->Write(reinterpret_cast<uint8_t*>(&vector), sizeof(vector));

libs/acn/RDMPDU.h

@@ -21,16 +21,38 @@
 #ifndef LIBS_ACN_RDMPDU_H_
 #define LIBS_ACN_RDMPDU_H_
 
+#include <string>
+#include <ola/io/ByteString.h>
 #include <ola/io/IOStack.h>
+#include <ola/rdm/RDMPacket.h>
 
 #include "libs/acn/PDU.h"
 
 namespace ola {
 namespace acn {
 
-class RDMPDU : private PDU {
+class RDMPDU : public PDU {
  public:
+  explicit RDMPDU(const ola::io::ByteString &command):
+    PDU(ola::rdm::START_CODE, ONE_BYTE, true),
+    m_command(command) {}
+
+  unsigned int HeaderSize() const { return 0; }
+  bool PackHeader(OLA_UNUSED uint8_t *data,
+                  unsigned int *length) const {
+    *length = 0;
+    return true;
+  }
+  void PackHeader(OLA_UNUSED ola::io::OutputStream *stream) const {}
+
+  unsigned int DataSize() const;
+  bool PackData(uint8_t *data, unsigned int *length) const;
+  void PackData(ola::io::OutputStream *stream) const;
+
   static void PrependPDU(ola::io::IOStack *stack);
+
+ private:
+  const ola::io::ByteString m_command;
 };
 }  // namespace acn
 }  // namespace ola

libs/acn/RDMPDUTest.cpp

@@ -23,6 +23,8 @@
 #include <string>
 
 #include "ola/Logging.h"
+#include "ola/io/ByteString.h"
+#include "ola/io/IOQueue.h"
 #include "ola/io/IOStack.h"
 #include "ola/network/NetworkUtils.h"
 #include "ola/testing/TestUtils.h"
@@ -32,24 +34,125 @@
 namespace ola {
 namespace acn {
 
+using ola::io::ByteString;
+using ola::io::IOQueue;
 using ola::io::IOStack;
+using ola::io::OutputStream;
+using ola::network::HostToNetwork;
 
 class RDMPDUTest: public CppUnit::TestFixture {
   CPPUNIT_TEST_SUITE(RDMPDUTest);
+  CPPUNIT_TEST(testSimpleRDMPDU);
+  CPPUNIT_TEST(testSimpleRDMPDUToOutputStream);
   CPPUNIT_TEST(testPrepend);
   CPPUNIT_TEST_SUITE_END();
 
  public:
+  void testSimpleRDMPDU();
+  void testSimpleRDMPDUToOutputStream();
   void testPrepend();
 
  private:
   static const unsigned int TEST_VECTOR;
+  static const uint8_t EXPECTED_GET_RESPONSE_BUFFER[];
 };
 
 CPPUNIT_TEST_SUITE_REGISTRATION(RDMPDUTest);
 
 const unsigned int RDMPDUTest::TEST_VECTOR = 0xcc;
 
+const uint8_t RDMPDUTest::EXPECTED_GET_RESPONSE_BUFFER[] = {
+  1, 28,  // sub code & length
+  0, 3, 0, 0, 0, 4,   // dst uid
+  0, 1, 0, 0, 0, 2,   // src uid
+  0, 0, 0, 0, 10,  // transaction, port id, msg count & sub device
+  0x21, 1, 40, 4,  // command, param id, param data length
+  0x5a, 0x5a, 0x5a, 0x5a,  // param data
+  0x02, 0xb3  // checksum
+};
+
+/*
+ * Test that packing an RDMPDU works.
+ */
+void RDMPDUTest::testSimpleRDMPDU() {
+  ByteString empty;
+  RDMPDU empty_pdu(empty);
+
+  OLA_ASSERT_EQ(0u, empty_pdu.HeaderSize());
+  OLA_ASSERT_EQ(0u, empty_pdu.DataSize());
+  OLA_ASSERT_EQ(4u, empty_pdu.Size());
+
+  ByteString response(EXPECTED_GET_RESPONSE_BUFFER,
+                      sizeof(EXPECTED_GET_RESPONSE_BUFFER));
+  RDMPDU pdu(response);
+
+  OLA_ASSERT_EQ(0u, pdu.HeaderSize());
+  OLA_ASSERT_EQ(29u, pdu.DataSize());
+  OLA_ASSERT_EQ(33u, pdu.Size());
+
+  unsigned int size = pdu.Size();
+  uint8_t *data = new uint8_t[size];
+  unsigned int bytes_used = size;
+  OLA_ASSERT(pdu.Pack(data, &bytes_used));
+  OLA_ASSERT_EQ(size, bytes_used);
+
+  // spot check the data
+  OLA_ASSERT_EQ((uint8_t) 0xf0, data[0]);
+  // bytes_used is technically data[1] and data[2] if > 255
+  OLA_ASSERT_EQ((uint8_t) bytes_used, data[2]);
+  OLA_ASSERT_EQ(HostToNetwork((uint8_t) TEST_VECTOR), data[3]);
+
+  // test undersized buffer
+  bytes_used = size - 1;
+  OLA_ASSERT_FALSE(pdu.Pack(data, &bytes_used));
+  OLA_ASSERT_EQ(0u, bytes_used);
+
+  // test oversized buffer
+  bytes_used = size + 1;
+  OLA_ASSERT(pdu.Pack(data, &bytes_used));
+  OLA_ASSERT_EQ(size, bytes_used);
+  delete[] data;
+}
+
+
+/*
+ * Test that writing to an output stream works.
+ */
+void RDMPDUTest::testSimpleRDMPDUToOutputStream() {
+  ByteString response(EXPECTED_GET_RESPONSE_BUFFER,
+                      sizeof(EXPECTED_GET_RESPONSE_BUFFER));
+  RDMPDU pdu(response);
+
+  OLA_ASSERT_EQ(0u, pdu.HeaderSize());
+  OLA_ASSERT_EQ(29u, pdu.DataSize());
+  OLA_ASSERT_EQ(33u, pdu.Size());
+
+  IOQueue output;
+  OutputStream stream(&output);
+  pdu.Write(&stream);
+  OLA_ASSERT_EQ(33u, output.Size());
+
+  uint8_t *pdu_data = new uint8_t[output.Size()];
+  unsigned int pdu_size = output.Peek(pdu_data, output.Size());
+  OLA_ASSERT_EQ(output.Size(), pdu_size);
+
+  uint8_t EXPECTED[] = {
+    0xf0, 0x00, 0x21,
+    0xcc,
+    1, 28,  // sub code & length
+    0, 3, 0, 0, 0, 4,   // dst uid
+    0, 1, 0, 0, 0, 2,   // src uid
+    0, 0, 0, 0, 10,  // transaction, port id, msg count & sub device
+    0x21, 1, 40, 4,  // command, param id, param data length
+    0x5a, 0x5a, 0x5a, 0x5a,  // param data
+    0x02, 0xb3  // checksum
+  };
+  OLA_ASSERT_DATA_EQUALS(EXPECTED, sizeof(EXPECTED), pdu_data, pdu_size);
+  output.Pop(output.Size());
+  delete[] pdu_data;
+}
+
+
 void RDMPDUTest::testPrepend() {
   IOStack stack;
   RDMPDU::PrependPDU(&stack);