Add some E1.37-5 PIDs and accompanying RDM tests

common/rdm/DummyResponder.cpp

@@ -160,6 +160,18 @@ const ResponderOps<DummyResponder>::ParamHandler
   { PID_DNS_NAME_SERVER,
     &DummyResponder::GetDNSNameServer,
     NULL},
+  { PID_MANUFACTURER_URL,
+    &DummyResponder::GetManufacturerURL,
+    NULL},
+  { PID_PRODUCT_URL,
+    &DummyResponder::GetProductURL,
+    NULL},
+  { PID_FIRMWARE_URL,
+    &DummyResponder::GetFirmwareURL,
+    NULL},
+  { PID_TEST_DATA,
+    &DummyResponder::GetTestData,
+    &DummyResponder::SetTestData},
   { OLA_MANUFACTURER_PID_CODE_VERSION,
     &DummyResponder::GetOlaCodeVersion,
     NULL},
@@ -225,7 +237,7 @@ RDMResponse *DummyResponder::GetParamDescription(
 RDMResponse *DummyResponder::GetDeviceInfo(const RDMRequest *request) {
   return ResponderHelper::GetDeviceInfo(
       request, OLA_DUMMY_DEVICE_MODEL,
-      PRODUCT_CATEGORY_OTHER, 3,
+      PRODUCT_CATEGORY_OTHER, 4,
       &m_personality_manager,
       m_start_address,
       0, m_sensors.size());
@@ -435,6 +447,39 @@ RDMResponse *DummyResponder::GetDNSNameServer(
                                            m_network_manager.get());
 }
 
+RDMResponse *DummyResponder::GetManufacturerURL(
+    const RDMRequest *request) {
+  return ResponderHelper::GetString(
+      // TODO(Peter): This field's length isn't limited in the spec
+      request, OLA_MANUFACTURER_URL, 0, UINT8_MAX);
+}
+
+RDMResponse *DummyResponder::GetProductURL(
+    const RDMRequest *request) {
+  return ResponderHelper::GetString(
+      request,
+      "https://openlighting.org/rdm-tools/dummy-responders/",
+      0,
+      UINT8_MAX); // TODO(Peter): This field's length isn't limited in the spec
+}
+
+RDMResponse *DummyResponder::GetFirmwareURL(
+    const RDMRequest *request) {
+  return ResponderHelper::GetString(
+      request,
+      "https://github.com/OpenLightingProject/ola",
+      0,
+      UINT8_MAX); // TODO(Peter): This field's length isn't limited in the spec
+}
+
+RDMResponse *DummyResponder::GetTestData(const RDMRequest *request) {
+  return ResponderHelper::GetTestData(request);
+}
+
+RDMResponse *DummyResponder::SetTestData(const RDMRequest *request) {
+  return ResponderHelper::SetTestData(request);
+}
+
 RDMResponse *DummyResponder::GetOlaCodeVersion(
     const RDMRequest *request) {
   return ResponderHelper::GetString(request, VERSION);

common/rdm/Makefile.mk

@@ -86,6 +86,8 @@ test_programs += \
     common/rdm/RDMHelperTester \
     common/rdm/RDMMessageTester \
     common/rdm/RDMReplyTester \
+    common/rdm/ResponderHelperTester \
+    common/rdm/ResponderTagSetTester \
     common/rdm/UIDAllocatorTester \
     common/rdm/UIDTester
 
@@ -142,6 +144,15 @@ common_rdm_RDMCommandSerializerTester_SOURCES = \
 common_rdm_RDMCommandSerializerTester_CXXFLAGS = $(COMMON_TESTING_FLAGS)
 common_rdm_RDMCommandSerializerTester_LDADD = $(COMMON_TESTING_LIBS)
 
+common_rdm_ResponderHelperTester_SOURCES = common/rdm/ResponderHelperTest.cpp
+common_rdm_ResponderHelperTester_CXXFLAGS = $(COMMON_TESTING_FLAGS)
+common_rdm_ResponderHelperTester_LDADD = $(COMMON_TESTING_LIBS)
+
+common_rdm_ResponderTagSetTester_SOURCES = \
+    common/rdm/ResponderTagSetTest.cpp
+common_rdm_ResponderTagSetTester_CXXFLAGS = $(COMMON_TESTING_FLAGS)
+common_rdm_ResponderTagSetTester_LDADD = $(COMMON_TESTING_LIBS)
+
 common_rdm_QueueingRDMControllerTester_SOURCES = \
     common/rdm/QueueingRDMControllerTest.cpp \
     common/rdm/TestHelper.h

common/rdm/OpenLightingEnums.cpp

@@ -23,5 +23,6 @@ namespace ola {
 namespace rdm {
 
 const char OLA_MANUFACTURER_LABEL[] = "Open Lighting Project";
+const char OLA_MANUFACTURER_URL[] = "https://openlighting.org/";
 }  // namespace rdm
 }  // namespace ola

common/rdm/PidStoreLoader.cpp

@@ -514,7 +514,7 @@ const FieldDescriptor *PidStoreLoader::IntegerFieldToFieldDescriptor(
     intervals.push_back(interval);
   }
 
-  // if not intervals were specified, we automatically add all the labels
+  // if no intervals were specified, we automatically add all the labels
   bool intervals_empty = intervals.empty();
 
   for (int i = 0; i < field.label_size(); ++i) {
@@ -550,7 +550,8 @@ const FieldDescriptor *PidStoreLoader::StringFieldToFieldDescriptor(
     min = field.min_size();
 
   if (!field.has_max_size()) {
-    OLA_WARN << "String field failed to specify max size";
+    OLA_WARN << "String field " << field.name()
+             << " failed to specify max size";
     return NULL;
   }
   return new ola::messaging::StringFieldDescriptor(

common/rdm/RDMHelper.cpp

@@ -1146,5 +1146,45 @@ string UnitToString(uint8_t unit) {
       return str.str();
   }
 }
+
+
+/**
+ * Convert a uint8_t representing a shipping lock state to a human-readable string.
+ * @param shipping_lock_state the shipping lock state value
+ */
+string ShippingLockStateToString(uint8_t shipping_lock_state) {
+  switch (shipping_lock_state) {
+    case SHIPPING_LOCK_STATE_UNLOCKED:
+      return "Unlocked";
+    case SHIPPING_LOCK_STATE_LOCKED:
+      return "Locked";
+    case SHIPPING_LOCK_STATE_PARTIALLY_LOCKED:
+      return "Partially locked";
+    default:
+      ostringstream str;
+      str << "Unknown, was " << static_cast<int>(shipping_lock_state);
+      return str.str();
+  }
+}
+
+
+/**
+ * Safely convert a uint8_t to a rdm_shipping_lock_state
+ */
+bool UIntToShippingLockState(uint8_t state, rdm_shipping_lock_state *shipping_lock_state) {
+  switch (state) {
+    case SHIPPING_LOCK_STATE_UNLOCKED:
+      *shipping_lock_state = SHIPPING_LOCK_STATE_UNLOCKED;
+      return true;
+    case SHIPPING_LOCK_STATE_LOCKED:
+      *shipping_lock_state = SHIPPING_LOCK_STATE_LOCKED;
+      return true;
+    case SHIPPING_LOCK_STATE_PARTIALLY_LOCKED:
+      *shipping_lock_state = SHIPPING_LOCK_STATE_PARTIALLY_LOCKED;
+      return true;
+    default:
+      return false;
+  }
+}
 }  // namespace rdm
 }  // namespace  ola

common/rdm/ResponderHelper.cpp

@@ -47,6 +47,7 @@ using ola::network::InterfacePicker;
 using ola::network::IPV4Address;
 using ola::network::MACAddress;
 using ola::network::NetworkToHost;
+using ola::strings::StrNLength;
 using std::min;
 using std::string;
 using std::vector;
@@ -79,6 +80,24 @@ bool ResponderHelper::ExtractUInt32(const RDMRequest *request,
   return GenericExtractValue(request, output);
 }
 
+bool ResponderHelper::ExtractString(const RDMRequest *request,
+                                    std::string *output,
+                                    uint8_t max_length) {
+  if (request->ParamDataSize() > max_length) {
+    return false;
+  }
+
+  size_t len = (size_t) request->ParamDataSize();
+  if (request->ParamData() != NULL) {
+    // StrNLength ensures we stop on the first null we hit
+    len = StrNLength(reinterpret_cast<const char*>(request->ParamData()),
+                     min(len, (size_t) max_length));
+  }
+  const string value(reinterpret_cast<const char*>(request->ParamData()), len);
+  *output = value;
+  return true;
+}
+
 
 RDMResponse *ResponderHelper::GetDeviceInfo(
     const RDMRequest *request,
@@ -1053,6 +1072,121 @@ RDMResponse *ResponderHelper::GetIPV4Address(
                         queued_message_count);
 }
 
+RDMResponse *ResponderHelper::GetTestData(
+    const RDMRequest *request,
+    uint8_t queued_message_count) {
+  uint16_t pattern_length;
+  if (!ExtractUInt16(request, &pattern_length)) {
+    return NackWithReason(request, NR_FORMAT_ERROR, queued_message_count);
+  }
+
+  if (pattern_length > MAX_RDM_TEST_DATA_PATTERN_LENGTH) {
+    return NackWithReason(request, NR_DATA_OUT_OF_RANGE, queued_message_count);
+  }
+
+  uint8_t pattern_data[pattern_length];
+
+  for (unsigned int i = 0; i < pattern_length; i++) {
+    // Need to return values 0-255, 0... etc
+    pattern_data[i] = i % (UINT8_MAX + 1);
+  }
+
+  return GetResponseFromData(
+      request,
+      reinterpret_cast<uint8_t*>(&pattern_data),
+      sizeof(pattern_data),
+      RDM_ACK,
+      queued_message_count);
+}
+
+RDMResponse *ResponderHelper::SetTestData(
+    const RDMRequest *request,
+    uint8_t queued_message_count) {
+  return GetResponseFromData(
+      request,
+      request->ParamData(),
+      request->ParamDataSize(),
+      RDM_ACK,
+      queued_message_count);
+}
+
+RDMResponse *ResponderHelper::GetListTags(
+    const RDMRequest *request,
+    const TagSet *tag_set,
+    uint8_t queued_message_count) {
+  if (request->ParamDataSize()) {
+    return NackWithReason(request, NR_FORMAT_ERROR, queued_message_count);
+  }
+
+  uint8_t tags[(MAX_RDM_STRING_LENGTH + 1) * tag_set->Size()];
+  unsigned int pdl = sizeof(tags);
+
+  tag_set->Pack(tags, &pdl);
+
+  return GetResponseFromData(request, tags, pdl,
+                             RDM_ACK, queued_message_count);
+}
+
+RDMResponse *ResponderHelper::SetAddTag(
+    const RDMRequest *request,
+    TagSet *tag_set,
+    uint8_t queued_message_count) {
+  string tag;
+  if (!ResponderHelper::ExtractString(request, &tag)) {
+    return NackWithReason(request, NR_FORMAT_ERROR, queued_message_count);
+  }
+
+  tag_set->AddTag(tag);
+
+  return ResponderHelper::EmptySetResponse(request, queued_message_count);
+}
+
+RDMResponse *ResponderHelper::SetRemoveTag(
+    const RDMRequest *request,
+    TagSet *tag_set,
+    uint8_t queued_message_count) {
+  string tag;
+  if (!ResponderHelper::ExtractString(request, &tag)) {
+    return NackWithReason(request, NR_FORMAT_ERROR, queued_message_count);
+  }
+
+  if (tag_set->Contains(tag)) {
+    tag_set->RemoveTag(tag);
+
+    return ResponderHelper::EmptySetResponse(request, queued_message_count);
+  } else {
+    return NackWithReason(request, NR_DATA_OUT_OF_RANGE, queued_message_count);
+  }
+}
+
+RDMResponse *ResponderHelper::GetCheckTag(
+    const RDMRequest *request,
+    const TagSet *tag_set,
+    uint8_t queued_message_count) {
+  string tag;
+  if (!ResponderHelper::ExtractString(request, &tag)) {
+    return NackWithReason(request, NR_FORMAT_ERROR, queued_message_count);
+  }
+
+  uint8_t param = tag_set->Contains(tag) ? 1 : 0;
+
+  return GetResponseFromData(request, &param, sizeof(param),
+                             RDM_ACK, queued_message_count);
+}
+
+RDMResponse *ResponderHelper::SetClearTags(
+    const RDMRequest *request,
+    TagSet *tag_set,
+    uint8_t queued_message_count) {
+  if (request->ParamDataSize()) {
+    return NackWithReason(request, NR_FORMAT_ERROR, queued_message_count);
+  }
+
+  tag_set->Clear();
+
+  return ResponderHelper::EmptySetResponse(request, queued_message_count);
+}
+
 /**
  * @brief Handle a request that returns a string
  * @note this truncates the string to max_length