test encoding of str

Author: bertmelis

src/Datapoint/Converter.cpp

@@ -81,6 +81,15 @@ int Div2Convert::toString(char* buf, std::size_t maxLen, VariantValue value) con
   return snprintf(buf, maxLen, "%.1f", static_cast<float>(value));
 }
 
+void Div2Convert::fromString(const char* buf, VariantValue* result) const {
+  char* end = nullptr;
+  float ret = std::strtof(buf, &end);
+  if (buf == end || ret == HUGE_VALF) {
+    vw_log_e("Could not convert string to float");
+  }
+  *result = VariantValue(ret);
+}
+
 VariantValue Div3600Convert::decode(const uint8_t* data, uint8_t len) const {
   assert(len == 4);
   (void) len;
@@ -104,6 +113,15 @@ int Div3600Convert::toString(char* buf, std::size_t maxLen, VariantValue value)
   return snprintf(buf, maxLen, "%.4f", static_cast<float>(value));
 }
 
+void Div3600Convert::fromString(const char* buf, VariantValue* result) const {
+  char* end = nullptr;
+  float ret = std::strtof(buf, &end);
+  if (buf == end || ret == HUGE_VALF) {
+    vw_log_e("Could not convert string to float");
+  }
+  *result = VariantValue(ret);
+}
+
 VariantValue NoconvConvert::decode(const uint8_t* data, uint8_t len) const {
   // assert(len == 1 || len == 2 || len == 4);
   if (len == 1) {

src/Datapoint/Converter.h

@@ -58,7 +58,7 @@ class Converter {
   virtual VariantValue decode(const uint8_t* data, uint8_t len) const = 0;
   virtual void encode(uint8_t* buf, uint8_t len, const VariantValue& val) const = 0;
   virtual int toString(char* buf, std::size_t maxLen, VariantValue value) const;
-  virtual void fromString(const char* buf, VariantValue* result) const;
+  virtual void fromString(const char* buf, VariantValue* result) const;  // buf = c-string, 0-terminated
   bool operator==(const Converter& rhs) const {
     return (this == &rhs);
   }
@@ -69,21 +69,23 @@ class Div10Convert : public Converter {
   VariantValue decode(const uint8_t* data, uint8_t len) const override;
   void encode(uint8_t* buf, uint8_t len, const VariantValue& val) const override;
   int toString(char* buf, std::size_t maxLen, VariantValue value) const override;
-  void fromString(const char* buf, VariantValue* result) const override;  // C-string = 0-terminated
+  void fromString(const char* buf, VariantValue* result) const override;
 };
 
 class Div2Convert : public Converter {
  public:
   VariantValue decode(const uint8_t* data, uint8_t len) const override;
   void encode(uint8_t* buf, uint8_t len, const VariantValue& val) const override;
   int toString(char* buf, std::size_t maxLen, VariantValue value) const override;
+  void fromString(const char* buf, VariantValue* result) const override;
 };
 
 class Div3600Convert : public Converter {
  public:
   VariantValue decode(const uint8_t* data, uint8_t len) const override;
   void encode(uint8_t* buf, uint8_t len, const VariantValue& val) const override;
   int toString(char* buf, std::size_t maxLen, VariantValue value) const override;
+  void fromString(const char* buf, VariantValue* result) const override;
 };
 
 class NoconvConvert : public Converter {

test/test_Datapoint/test_Datapoint.cpp

@@ -171,6 +171,18 @@ void test_HourEncode() {
   TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, buffer, len);
 }
 
+void test_HourEncodeStr() {
+  Datapoint dp("hour", 0x0000, 4, VitoWiFi::div3600);
+  const uint8_t expected[] = {0x80, 0x8F, 0x21, 0x61};
+  const char* value = "452663.72";
+  const uint8_t len = 4;
+  uint8_t buffer[len] = {0};
+
+  dp.encode(buffer, len, value);
+
+  TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, buffer, len);
+}
+
 
 void test_CountDecode() {
   Datapoint dp("count", 0x0000, 4, VitoWiFi::noconv);
@@ -247,7 +259,7 @@ void test_COPDecodeStr() {
 }
 
 void test_COPEncode() {
-  Datapoint dp("count", 0x0000, 2, VitoWiFi::div10);
+  Datapoint dp("count", 0x0000, 1, VitoWiFi::div10);
   const uint8_t expected[] = {0x1A};
   const float value = 2.6;
   const uint8_t len = 1;
@@ -258,6 +270,18 @@ void test_COPEncode() {
   TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, buffer, len);
 }
 
+void test_COPEncodeStr() {
+  Datapoint dp("count", 0x0000, 1, VitoWiFi::div10);
+  const uint8_t expected[] = {0x1A};
+  const char* value = "2.6";
+  const uint8_t len = 1;
+  uint8_t buffer[len] = {0};
+
+  dp.encode(buffer, len, value);
+
+  TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, buffer, len);
+}
+
 void test_ScheduleEncode() {
   const char* schedule = "7:30 08:30 16:20 23:10";
   const uint8_t expected[] = {0x3B, 0x43, 0x82, 0xB9, 0x00, 0x00, 0x00, 0x00};
@@ -298,13 +322,15 @@ int main() {
   RUN_TEST(test_HourDecode);
   RUN_TEST(test_HourDecodeStr);
   RUN_TEST(test_HourEncode);
+  RUN_TEST(test_HourEncodeStr);
   RUN_TEST(test_CountDecode);
   RUN_TEST(test_CountEncode);
   RUN_TEST(test_CountShortDecode);
   RUN_TEST(test_CountShortEncode);
   RUN_TEST(test_COPDecode);
   RUN_TEST(test_COPDecodeStr);
   RUN_TEST(test_COPEncode);
+  RUN_TEST(test_COPEncodeStr);
   RUN_TEST(test_ScheduleEncode);
   RUN_TEST(test_ScheduleDecode);
   return UNITY_END();