Service Discovery messages add EVSide Se/Deserialization (#91)

cienporcien · web-flow · commit 78a54ca86631 · 2025-03-06T11:00:59.000+01:00
* Service Discovery messages add EVSide Se/Deserialization
* Fixed a couple of things suggested by the pull request review.
* Add unit tests with service_discovery_req/res vas_list
* Changed all auto const to const auto

Signed-off-by: Roger Bedell &lt;rogerbedell@hotmail.com&gt;
diff --git a/src/iso15118/message/service_discovery.cpp b/src/iso15118/message/service_discovery.cpp
@@ -20,14 +20,60 @@ template <> void convert(const struct iso20_ServiceDiscoveryReqType& in, Service
     }
 }
 
+template <> void convert(const struct iso20_ServiceDiscoveryResType& in, ServiceDiscoveryResponse& out) {
+
+    cb_convert_enum(in.ResponseCode, out.response_code);
+
+    out.service_renegotiation_supported = in.ServiceRenegotiationSupported;
+
+    // remove the default AC service
+    out.energy_transfer_service_list.clear();
+    out.energy_transfer_service_list.reserve(in.EnergyTransferServiceList.Service.arrayLen);
+
+    for (auto i = 0; i < in.EnergyTransferServiceList.Service.arrayLen; i++) {
+        const auto& service = in.EnergyTransferServiceList.Service.array[i];
+        auto& out_service = out.energy_transfer_service_list.emplace_back();
+        cb_convert_enum(service.ServiceID, out_service.service_id);
+        out_service.free_service = service.FreeService;
+    }
+
+    if (in.VASList_isUsed) {
+
+        out.vas_list.emplace();
+        out.vas_list->reserve(in.VASList.Service.arrayLen);
+
+        for (auto i = 0; i < in.VASList.Service.arrayLen; i++) {
+            const auto& service = in.VASList.Service.array[i];
+            auto& out_service = out.vas_list->emplace_back();
+            cb_convert_enum(service.ServiceID, out_service.service_id);
+            out_service.free_service = service.FreeService;
+        }
+    }
+
+    convert(in.Header, out.header);
+}
+
+template <> void convert(const ServiceDiscoveryRequest& in, iso20_ServiceDiscoveryReqType& out) {
+    init_iso20_ServiceDiscoveryReqType(&out);
+
+    if (in.supported_service_ids) {
+        auto& out_service_ids = out.SupportedServiceIDs.ServiceID.array;
+        const auto& supported_service_ids = in.supported_service_ids.value();
+        std::copy(supported_service_ids.begin(), supported_service_ids.end(), out_service_ids);
+        out.SupportedServiceIDs.ServiceID.arrayLen = supported_service_ids.size();
+        CB_SET_USED(out.SupportedServiceIDs);
+    }
+    convert(in.header, out.Header);
+}
+
 template <> void convert(const ServiceDiscoveryResponse& in, iso20_ServiceDiscoveryResType& out) {
     init_iso20_ServiceDiscoveryResType(&out);
 
     cb_convert_enum(in.response_code, out.ResponseCode);
     out.ServiceRenegotiationSupported = in.service_renegotiation_supported;
 
     uint8_t index = 0;
-    for (auto const& service : in.energy_transfer_service_list) {
+    for (const auto& service : in.energy_transfer_service_list) {
         auto& out_service = out.EnergyTransferServiceList.Service.array[index++];
         cb_convert_enum(service.service_id, out_service.ServiceID);
         out_service.FreeService = service.free_service;
@@ -36,7 +82,7 @@ template <> void convert(const ServiceDiscoveryResponse& in, iso20_ServiceDiscov
 
     if (in.vas_list) {
         index = 0;
-        for (auto const& service : *in.vas_list) {
+        for (const auto& service : *in.vas_list) {
             auto& out_service = out.VASList.Service.array[index++];
             cb_convert_enum(service.service_id, out_service.ServiceID);
             out_service.FreeService = service.free_service;
@@ -52,6 +98,10 @@ template <> void insert_type(VariantAccess& va, const struct iso20_ServiceDiscov
     va.insert_type<ServiceDiscoveryRequest>(in);
 };
 
+template <> void insert_type(VariantAccess& va, const struct iso20_ServiceDiscoveryResType& in) {
+    va.insert_type<ServiceDiscoveryResponse>(in);
+};
+
 template <> int serialize_to_exi(const ServiceDiscoveryResponse& in, exi_bitstream_t& out) {
     iso20_exiDocument doc;
     init_iso20_exiDocument(&doc);
@@ -63,8 +113,23 @@ template <> int serialize_to_exi(const ServiceDiscoveryResponse& in, exi_bitstre
     return encode_iso20_exiDocument(&out, &doc);
 }
 
+template <> int serialize_to_exi(const ServiceDiscoveryRequest& in, exi_bitstream_t& out) {
+    iso20_exiDocument doc;
+    init_iso20_exiDocument(&doc);
+
+    CB_SET_USED(doc.ServiceDiscoveryReq);
+
+    convert(in, doc.ServiceDiscoveryReq);
+
+    return encode_iso20_exiDocument(&out, &doc);
+}
+
 template <> size_t serialize(const ServiceDiscoveryResponse& in, const io::StreamOutputView& out) {
     return serialize_helper(in, out);
 }
 
+template <> size_t serialize(const ServiceDiscoveryRequest& in, const io::StreamOutputView& out) {
+    return serialize_helper(in, out);
+}
+
 } // namespace iso15118::message_20
diff --git a/src/iso15118/message/variant.cpp b/src/iso15118/message/variant.cpp
@@ -58,6 +58,8 @@ static void handle_main(VariantAccess& va) {
         insert_type(va, doc.AuthorizationRes);
     } else if (doc.ServiceDiscoveryReq_isUsed) {
         insert_type(va, doc.ServiceDiscoveryReq);
+    } else if (doc.ServiceDiscoveryRes_isUsed) {
+        insert_type(va, doc.ServiceDiscoveryRes);
     } else if (doc.ServiceDetailReq_isUsed) {
         insert_type(va, doc.ServiceDetailReq);
     } else if (doc.ServiceSelectionReq_isUsed) {
diff --git a/test/exi/cb/iso20/service_discovery.cpp b/test/exi/cb/iso20/service_discovery.cpp
@@ -18,7 +18,7 @@ SCENARIO("Se/Deserialize service_discovery messages") {
 
         message_20::Variant variant(io::v2gtp::PayloadType::Part20Main, stream_view);
 
-        THEN("It should be decoded succussfully") {
+        THEN("It should be decoded successfully") {
 
             REQUIRE(variant.get_type() == message_20::Type::ServiceDiscoveryReq);
 
@@ -30,7 +30,58 @@ SCENARIO("Se/Deserialize service_discovery messages") {
         }
     }
 
-    // TODO(sl): Adding test with service_discovery_req supported_service_ids
+    GIVEN("Deserialize service_discovery_req_with_supported_service_ids") {
+
+        uint8_t doc_raw[] = {0x80, 0x7c, 0x04, 0x02, 0x75, 0xff, 0x96, 0x4a, 0x2c, 0xed,
+                             0xa1, 0x0e, 0x38, 0x7e, 0x8a, 0x60, 0x62, 0x00, 0x44};
+
+        const io::StreamInputView stream_view{doc_raw, sizeof(doc_raw)};
+
+        message_20::Variant variant(io::v2gtp::PayloadType::Part20Main, stream_view);
+
+        THEN("It should be decoded successfully") {
+
+            REQUIRE(variant.get_type() == message_20::Type::ServiceDiscoveryReq);
+
+            const auto& msg = variant.get<message_20::ServiceDiscoveryRequest>();
+            const auto& header = msg.header;
+
+            REQUIRE(header.session_id == std::array<uint8_t, 8>{0x04, 0xEB, 0xFF, 0x2C, 0x94, 0x59, 0xDB, 0x42});
+            REQUIRE(header.timestamp == 1692009443);
+            REQUIRE(msg.supported_service_ids.has_value() == true);
+            REQUIRE(msg.supported_service_ids.value().size() == 1);
+            REQUIRE(msg.supported_service_ids.value()[0] == 2);
+        }
+    }
+
+    GIVEN("Serialize service_discovery_req") {
+
+        message_20::ServiceDiscoveryRequest req;
+
+        req.header = message_20::Header{{0x04, 0xEB, 0xFF, 0x2C, 0x94, 0x59, 0xDB, 0x42}, 1692009443};
+
+        std::vector<uint8_t> expected = {0x80, 0x7c, 0x04, 0x02, 0x75, 0xff, 0x96, 0x4a, 0x2c,
+                                         0xed, 0xa1, 0x0e, 0x38, 0x7e, 0x8a, 0x60, 0x62, 0x80};
+
+        THEN("It should be serialized successfully") {
+            REQUIRE(serialize_helper(req) == expected);
+        }
+    }
+
+    GIVEN("Serialize service_discovery_req_with_supported_service_ids") {
+
+        message_20::ServiceDiscoveryRequest req;
+
+        req.header = message_20::Header{{0x04, 0xEB, 0xFF, 0x2C, 0x94, 0x59, 0xDB, 0x42}, 1692009443};
+        req.supported_service_ids = {2};
+
+        std::vector<uint8_t> expected = {0x80, 0x7c, 0x04, 0x02, 0x75, 0xff, 0x96, 0x4a, 0x2c, 0xed,
+                                         0xa1, 0x0e, 0x38, 0x7e, 0x8a, 0x60, 0x62, 0x00, 0x44};
+
+        THEN("It should be serialized successfully") {
+            REQUIRE(serialize_helper(req) == expected);
+        }
+    }
 
     GIVEN("Serialize service_discovery_res") {
 
@@ -45,8 +96,86 @@ SCENARIO("Se/Deserialize service_discovery messages") {
         std::vector<uint8_t> expected = {0x80, 0x80, 0x04, 0x1e, 0xa6, 0x5f, 0xc9, 0x9b, 0xa7, 0x6c, 0x4d, 0x8c,
                                          0x2b, 0xfe, 0x1b, 0x60, 0x62, 0x00, 0x00, 0x02, 0x00, 0x01, 0x80, 0x50};
 
-        THEN("It should be serialized succussfully") {
+        THEN("It should be serialized successfully") {
+            REQUIRE(serialize_helper(res) == expected);
+        }
+    }
+
+    GIVEN("Serialize service_discovery_res_with_vas_list") {
+
+        message_20::ServiceDiscoveryResponse res;
+
+        res.header = message_20::Header{{0x3D, 0x4C, 0xBF, 0x93, 0x37, 0x4E, 0xD8, 0x9B}, 1725456322};
+        res.response_code = message_20::datatypes::ResponseCode::OK;
+        res.service_renegotiation_supported = false;
+        res.energy_transfer_service_list = {{message_20::datatypes::ServiceCategory::DC, false},
+                                            {message_20::datatypes::ServiceCategory::DC_BPT, false}};
+        res.vas_list = {{message_20::datatypes::ServiceCategory::Internet, true}};
+
+        std::vector<uint8_t> expected = {0x80, 0x80, 0x04, 0x1e, 0xa6, 0x5f, 0xc9, 0x9b, 0xa7, 0x6c, 0x4d, 0x8c, 0x2b,
+                                         0xfe, 0x1b, 0x60, 0x62, 0x00, 0x00, 0x02, 0x00, 0x01, 0x80, 0x40, 0x82, 0x22};
+
+        THEN("It should be serialized successfully") {
             REQUIRE(serialize_helper(res) == expected);
         }
     }
+
+    GIVEN("Deserialize service_discovery_res") {
+
+        uint8_t doc_raw[] = {0x80, 0x80, 0x04, 0x1e, 0xa6, 0x5f, 0xc9, 0x9b, 0xa7, 0x6c, 0x4d, 0x8c,
+                             0x2b, 0xfe, 0x1b, 0x60, 0x62, 0x00, 0x00, 0x02, 0x00, 0x01, 0x80, 0x50};
+
+        const io::StreamInputView stream_view{doc_raw, sizeof(doc_raw)};
+
+        message_20::Variant variant(io::v2gtp::PayloadType::Part20Main, stream_view);
+
+        THEN("It should be decoded successfully") {
+
+            REQUIRE(variant.get_type() == message_20::Type::ServiceDiscoveryRes);
+
+            const auto& msg = variant.get<message_20::ServiceDiscoveryResponse>();
+            const auto& header = msg.header;
+
+            REQUIRE(header.session_id == std::array<uint8_t, 8>{0x3D, 0x4C, 0xBF, 0x93, 0x37, 0x4E, 0xD8, 0x9B});
+            REQUIRE(header.timestamp == 1725456322);
+            REQUIRE(msg.response_code == message_20::datatypes::ResponseCode::OK);
+            REQUIRE(msg.service_renegotiation_supported == false);
+            REQUIRE(msg.energy_transfer_service_list.size() == 2);
+            REQUIRE(msg.energy_transfer_service_list[0].service_id == message_20::datatypes::ServiceCategory::DC);
+            REQUIRE(msg.energy_transfer_service_list[0].free_service == false);
+            REQUIRE(msg.energy_transfer_service_list[1].service_id == message_20::datatypes::ServiceCategory::DC_BPT);
+            REQUIRE(msg.energy_transfer_service_list[1].free_service == false);
+        }
+    }
+
+    GIVEN("Deserialize service_discovery_res_with_vas_list") {
+
+        uint8_t doc_raw[] = {0x80, 0x80, 0x04, 0x1e, 0xa6, 0x5f, 0xc9, 0x9b, 0xa7, 0x6c, 0x4d, 0x8c, 0x2b,
+                             0xfe, 0x1b, 0x60, 0x62, 0x00, 0x00, 0x02, 0x00, 0x01, 0x80, 0x40, 0x82, 0x22};
+
+        const io::StreamInputView stream_view{doc_raw, sizeof(doc_raw)};
+
+        message_20::Variant variant(io::v2gtp::PayloadType::Part20Main, stream_view);
+
+        THEN("It should be decoded successfully") {
+
+            REQUIRE(variant.get_type() == message_20::Type::ServiceDiscoveryRes);
+
+            const auto& msg = variant.get<message_20::ServiceDiscoveryResponse>();
+            const auto& header = msg.header;
+
+            REQUIRE(header.session_id == std::array<uint8_t, 8>{0x3D, 0x4C, 0xBF, 0x93, 0x37, 0x4E, 0xD8, 0x9B});
+            REQUIRE(header.timestamp == 1725456322);
+            REQUIRE(msg.response_code == message_20::datatypes::ResponseCode::OK);
+            REQUIRE(msg.service_renegotiation_supported == false);
+            REQUIRE(msg.energy_transfer_service_list.size() == 2);
+            REQUIRE(msg.energy_transfer_service_list[0].service_id == message_20::datatypes::ServiceCategory::DC);
+            REQUIRE(msg.energy_transfer_service_list[0].free_service == false);
+            REQUIRE(msg.energy_transfer_service_list[1].service_id == message_20::datatypes::ServiceCategory::DC_BPT);
+            REQUIRE(msg.energy_transfer_service_list[1].free_service == false);
+            REQUIRE(msg.vas_list.value().size() == 1);
+            REQUIRE(msg.vas_list.value()[0].service_id == message_20::datatypes::ServiceCategory::Internet);
+            REQUIRE(msg.vas_list.value()[0].free_service == true);
+        }
+    }
 }
