From aba785ed62c0ee62437eb5c597bce7639882e407 Mon Sep 17 00:00:00 2001 From: gmoryes Date: Mon, 17 Feb 2020 19:29:59 +0300 Subject: [PATCH] [routing] ser des tests --- 3party/opening_hours/opening_hours.cpp | 65 +++++++ 3party/opening_hours/opening_hours.hpp | 22 +++ routing/road_access.cpp | 24 ++- routing/road_access.hpp | 11 +- routing/road_access_serialization.hpp | 31 ++-- routing/routing_tests/road_access_test.cpp | 196 ++++++++++++++++++--- 6 files changed, 310 insertions(+), 39 deletions(-) diff --git a/3party/opening_hours/opening_hours.cpp b/3party/opening_hours/opening_hours.cpp index 71502c23a6..ef859969d0 100644 --- a/3party/opening_hours/opening_hours.cpp +++ b/3party/opening_hours/opening_hours.cpp @@ -398,6 +398,11 @@ std::ostream & operator<<(std::ostream & ost, NthWeekdayOfTheMonthEntry const en return ost; } +bool NthWeekdayOfTheMonthEntry::operator==(NthWeekdayOfTheMonthEntry const & rhs) const +{ + return m_start == rhs.m_start && m_end == rhs.m_end; +} + // WeekdayRange ------------------------------------------------------------------------------------ bool WeekdayRange::HasWday(Weekday const wday) const { @@ -412,6 +417,12 @@ bool WeekdayRange::HasWday(Weekday const wday) const : wday <= GetEnd() || GetStart() <= wday; } +bool WeekdayRange::operator==(WeekdayRange const & rhs) const +{ + return m_start == rhs.m_start && m_end == rhs.m_end && m_offset == rhs.m_offset && + m_nths == rhs.m_nths; +} + std::ostream & operator<<(std::ostream & ost, Weekday const wday) { switch (wday) @@ -490,6 +501,11 @@ std::ostream & operator<<(std::ostream & ost, THolidays const & holidays) return ost; } +bool Holiday::operator==(Holiday const & rhs) const +{ + return m_plural == rhs.m_plural && m_offset == rhs.m_offset; +} + // Weekdays ---------------------------------------------------------------------------------------- std::ostream & operator<<(std::ostream & ost, Weekdays const & weekday) @@ -501,6 +517,11 @@ std::ostream & operator<<(std::ostream & ost, Weekdays const & weekday) return ost; } +bool Weekdays::operator==(Weekdays const & rhs) const +{ + return m_weekdayRanges == rhs.m_weekdayRanges && m_holidays == rhs.m_holidays; +} + // DateOffset -------------------------------------------------------------------------------------- std::ostream & operator<<(std::ostream & ost, DateOffset const & offset) { @@ -513,6 +534,12 @@ std::ostream & operator<<(std::ostream & ost, DateOffset const & offset) return ost; } +bool DateOffset::operator==(DateOffset const & rhs) const +{ + return m_wdayOffest == rhs.m_wdayOffest && m_positive == rhs.m_positive && + m_offset == rhs.m_offset; +} + // MonthDay ---------------------------------------------------------------------------------------- std::ostream & operator<<(std::ostream & ost, MonthDay::Month const month) { @@ -615,6 +642,12 @@ std::ostream & operator<<(std::ostream & ost, MonthDay const md) return ost; } +bool MonthDay::operator==(MonthDay const & rhs) const +{ + return m_year == rhs.m_year && m_month == rhs.m_month && m_daynum == rhs.m_daynum && + m_variable_date == rhs.m_variable_date && m_offset == rhs.m_offset; +} + // MonthdayRange ----------------------------------------------------------------------------------- std::ostream & operator<<(std::ostream & ost, MonthdayRange const & range) { @@ -637,6 +670,12 @@ std::ostream & operator<<(std::ostream & ost, TMonthdayRanges const & ranges) return ost; } +bool MonthdayRange::operator==(MonthdayRange const & rhs) const +{ + return m_start == rhs.m_start && m_end == rhs.m_end && m_period == rhs.m_period && + m_plus == rhs.m_plus; +} + // YearRange --------------------------------------------------------------------------------------- std::ostream & operator<<(std::ostream & ost, YearRange const range) { @@ -664,6 +703,12 @@ std::ostream & operator<<(std::ostream & ost, TYearRanges const ranges) return ost; } +bool YearRange::operator==(YearRange const & rhs) const +{ + return m_start == rhs.m_start && m_end == rhs.m_end && m_plus == rhs.m_plus && + m_period == rhs.m_period; +} + // WeekRange --------------------------------------------------------------------------------------- std::ostream & operator<<(std::ostream & ost, WeekRange const range) { @@ -688,6 +733,11 @@ std::ostream & operator<<(std::ostream & ost, TWeekRanges const ranges) return ost; } +bool WeekRange::operator==(WeekRange const & rhs) const +{ + return m_start == rhs.m_start && m_end == rhs.m_end && m_period == rhs.m_period; +} + // RuleSequence ------------------------------------------------------------------------------------ bool RuleSequence::HasMonthDay() const { @@ -703,6 +753,16 @@ bool RuleSequence::HasMonthDay() const return false; } +bool RuleSequence::operator==(RuleSequence const & rhs) const +{ + return m_twentyFourHours == rhs.m_twentyFourHours && m_years == rhs.m_years && + m_months == rhs.m_months && m_weeks == rhs.m_weeks && m_weekdays == rhs.m_weekdays && + m_times == rhs.m_times && m_comment == rhs.m_comment && + m_anySeparator == rhs.m_anySeparator && + m_separatorForReadability == rhs.m_separatorForReadability && + m_modifier == rhs.m_modifier && m_modifierComment == rhs.m_modifierComment; +} + std::ostream & operator<<(std::ostream & ost, RuleSequence::Modifier const modifier) { switch (modifier) @@ -860,4 +920,9 @@ void swap(OpeningHours & lhs, OpeningHours & rhs) std::swap(lhs.m_rule, rhs.m_rule); std::swap(lhs.m_valid, rhs.m_valid); } + +bool OpeningHours::operator==(OpeningHours const & rhs) const +{ + return m_valid == rhs.m_valid && m_rule == rhs.m_rule; +} } // namespace osmoh diff --git a/3party/opening_hours/opening_hours.hpp b/3party/opening_hours/opening_hours.hpp index 78798b768f..60f17fab73 100644 --- a/3party/opening_hours/opening_hours.hpp +++ b/3party/opening_hours/opening_hours.hpp @@ -275,6 +275,8 @@ public: void SetStart(NthDayOfTheMonth const s) { m_start = s; } void SetEnd(NthDayOfTheMonth const e) { m_end = e; } + bool operator==(NthWeekdayOfTheMonthEntry const & rhs) const; + private: NthDayOfTheMonth m_start = NthDayOfTheMonth::None; NthDayOfTheMonth m_end = NthDayOfTheMonth::None; @@ -345,6 +347,8 @@ public: void AddNth(NthWeekdayOfTheMonthEntry const & entry) { m_nths.push_back(entry); } + bool operator==(WeekdayRange const & rhs) const; + private: Weekday m_start = Weekday::None; Weekday m_end = Weekday::None; @@ -366,6 +370,8 @@ public: int32_t GetOffset() const { return m_offset; } void SetOffset(int32_t const offset) { m_offset = offset; } + bool operator==(Holiday const & rhs) const; + private: bool m_plural = false; int32_t m_offset = 0; @@ -393,6 +399,8 @@ public: void AddWeekdayRange(WeekdayRange const range) { m_weekdayRanges.push_back(range); } void AddHoliday(Holiday const & holiday) { m_holidays.push_back(holiday); } + bool operator==(Weekdays const & rhs) const; + private: TWeekdayRanges m_weekdayRanges; THolidays m_holidays; @@ -416,6 +424,8 @@ public: void SetOffset(int32_t const offset) { m_offset = offset; } void SetWDayOffsetPositive(bool const on) { m_positive = on; } + bool operator==(DateOffset const & rhs) const; + private: Weekday m_wdayOffest = Weekday::None; bool m_positive = true; @@ -473,6 +483,8 @@ public: void SetOffset(DateOffset const & offset) { m_offset = offset; } void SetVariableDate(VariableDate const date) { m_variable_date = date; } + bool operator==(MonthDay const & rhs) const; + private: TYear m_year = 0; Month m_month = Month::None; @@ -517,6 +529,8 @@ public: void SetPeriod(uint32_t const period) { m_period = period; } void SetPlus(bool const plus) { m_plus = plus; } + bool operator==(MonthdayRange const & rhs) const; + private: MonthDay m_start; MonthDay m_end; @@ -550,6 +564,8 @@ public: void SetPlus(bool const plus) { m_plus = plus; } void SetPeriod(uint32_t const period) { m_period = period; } + bool operator==(YearRange const & rhs) const; + private: TYear m_start = 0; TYear m_end = 0; @@ -581,6 +597,8 @@ public: void SetEnd(TWeek const end) { m_end = end; } void SetPeriod(uint32_t const period) { m_period = period; } + bool operator==(WeekRange const & rhs) const; + private: TWeek m_start = 0; TWeek m_end = 0; @@ -645,6 +663,8 @@ public: void SetModifier(Modifier const modifier) { m_modifier = modifier; } + bool operator==(RuleSequence const & rhs) const; + private: bool m_twentyFourHours{false}; @@ -691,6 +711,8 @@ public: friend void swap(OpeningHours & lhs, OpeningHours & rhs); + bool operator==(OpeningHours const & rhs) const; + private: TRuleSequences m_rule; bool m_valid; diff --git a/routing/road_access.cpp b/routing/road_access.cpp index 6918ccdde3..b7d69c515a 100644 --- a/routing/road_access.cpp +++ b/routing/road_access.cpp @@ -54,7 +54,9 @@ RoadAccess::Type RoadAccess::GetAccess(RoadPoint const & point) const bool RoadAccess::operator==(RoadAccess const & rhs) const { - return m_wayToAccess == rhs.m_wayToAccess && m_pointToAccess == rhs.m_pointToAccess; + return m_wayToAccess == rhs.m_wayToAccess && m_pointToAccess == rhs.m_pointToAccess && + m_wayToAccessConditional == rhs.m_wayToAccessConditional && + m_pointToAccessConditional == rhs.m_pointToAccessConditional; } // Functions --------------------------------------------------------------------------------------- @@ -80,16 +82,32 @@ void FromString(string const & s, RoadAccess::Type & result) ASSERT(false, ("Could not read RoadAccess from the string", s)); } +string DebugPrint(RoadAccess::Conditional const & conditional) +{ + stringstream ss; + ss << " { "; + for (auto const & access : conditional.GetAccesses()) + { + ss << DebugPrint(access.m_type) << " @ (" << access.m_openingHours.GetRule() << "), "; + } + ss << " } "; + return ss.str(); +} + string DebugPrint(RoadAccess::Type type) { return ToString(type); } string DebugPrint(RoadAccess const & r) { size_t const kMaxIdsToShow = 10; ostringstream oss; - oss << "RoadAccess { FeatureTypes ["; + oss << "WayToAccess { FeatureTypes ["; PrintKV(oss, r.GetWayToAccess(), kMaxIdsToShow); - oss << "], PointTypes ["; + oss << "], PointToAccess ["; PrintKV(oss, r.GetPointToAccess(), kMaxIdsToShow); + oss << "], WayToAccessConditional ["; + PrintKV(oss, r.GetWayToAccessConditional(), kMaxIdsToShow); + oss << "], PointToAccessConditional ["; + PrintKV(oss, r.GetPointToAccessConditional(), kMaxIdsToShow); oss << "] }"; return oss.str(); } diff --git a/routing/road_access.hpp b/routing/road_access.hpp index 5c493a216b..8fa7403e59 100644 --- a/routing/road_access.hpp +++ b/routing/road_access.hpp @@ -54,6 +54,11 @@ public: { } + bool operator==(Access const & rhs) const + { + return m_type == rhs.m_type && m_openingHours == rhs.m_openingHours; + } + RoadAccess::Type m_type = RoadAccess::Type::Count; osmoh::OpeningHours m_openingHours; }; @@ -65,9 +70,12 @@ public: m_accesses.emplace_back(type, std::move(openingHours)); } + size_t Size() const { return m_accesses.size(); } bool IsEmpty() const { return m_accesses.empty(); } std::vector const & GetAccesses() const { return m_accesses; } - size_t Size() const { return m_accesses.size(); } + + bool operator==(Conditional const & rhs) const { return m_accesses == rhs.m_accesses; } + bool operator!=(Conditional const & rhs) const { return !(*this == rhs); } private: std::vector m_accesses; @@ -130,6 +138,7 @@ private: std::string ToString(RoadAccess::Type type); void FromString(std::string const & s, RoadAccess::Type & result); +std::string DebugPrint(RoadAccess::Conditional const & conditional); std::string DebugPrint(RoadAccess::Type type); std::string DebugPrint(RoadAccess const & r); } // namespace routing diff --git a/routing/road_access_serialization.hpp b/routing/road_access_serialization.hpp index 8de2918456..265f4ea737 100644 --- a/routing/road_access_serialization.hpp +++ b/routing/road_access_serialization.hpp @@ -458,26 +458,30 @@ private: size_t successWritten = 0; WriteToSink(sink, successWritten); - BitWriter bitWriter(sink); - uint32_t prevFeatureId = 0; - for (auto const & [position, accessConditional] : positionsAccessConditional) { - if (!openingHoursSerializer.Serialize(bitWriter, accessConditional.m_openingHours)) - continue; + BitWriter bitWriter(sink); + uint32_t prevFeatureId = 0; + for (auto const & [position, accessConditional] : positionsAccessConditional) + { + if (!openingHoursSerializer.Serialize(bitWriter, accessConditional.m_openingHours)) + continue; - uint32_t const currentFeatureId = - position.GetFeatureId(); - CHECK_GREATER_OR_EQUAL(currentFeatureId, prevFeatureId, ()); - uint32_t const featureIdDiff = currentFeatureId - prevFeatureId; - prevFeatureId = currentFeatureId; + uint32_t const currentFeatureId = position.GetFeatureId(); + CHECK_GREATER_OR_EQUAL(currentFeatureId, prevFeatureId, ()); + uint32_t const featureIdDiff = currentFeatureId - prevFeatureId; + prevFeatureId = currentFeatureId; - WriteGamma(bitWriter, featureIdDiff + 1); - WriteGamma(bitWriter, position.GetPointId() + 1); - ++successWritten; + WriteGamma(bitWriter, featureIdDiff + 1); + auto const pointId = position.IsWay() ? 0 : position.GetPointId() + 1; + WriteGamma(bitWriter, pointId + 1); + ++successWritten; + } } + auto const endPos = sink.Pos(); sink.Seek(sizePos); WriteToSink(sink, successWritten); + sink.Seek(endPos); } template @@ -497,6 +501,7 @@ private: auto oh = openingHoursDeserializer.Deserialize(bitReader); auto const featureIdDiff = ReadGamma(bitReader) - 1; auto const featureId = prevFeatureId + featureIdDiff; + prevFeatureId = featureId; auto const pointId = ReadGamma(bitReader) - 1; AccessPosition const position(featureId, pointId); diff --git a/routing/routing_tests/road_access_test.cpp b/routing/routing_tests/road_access_test.cpp index df7950c642..df854650c0 100644 --- a/routing/routing_tests/road_access_test.cpp +++ b/routing/routing_tests/road_access_test.cpp @@ -12,6 +12,8 @@ #include #include +#include "3party/opening_hours/opening_hours.hpp" + using namespace routing; using namespace routing_test; using namespace std; @@ -20,53 +22,203 @@ using TestEdge = TestIndexGraphTopology::Edge; namespace { -UNIT_TEST(RoadAccess_Serialization) +void FillRoadAccessBySample_1(RoadAccess & roadAccess) { - RoadAccess::WayToAccess const m0 = { + RoadAccess::WayToAccess wayToAccess = { {1 /* featureId */, RoadAccess::Type::No}, {2 /* featureId */, RoadAccess::Type::Private}, }; - RoadAccess::WayToAccess const m1 = { + RoadAccess::PointToAccess pointToAccess = { + {RoadPoint(3 /* featureId */, 0 /* pointId */), RoadAccess::Type::No}, + {RoadPoint(4 /* featureId */, 7 /* pointId */), RoadAccess::Type::Private}, + }; + + roadAccess.SetAccess(move(wayToAccess), move(pointToAccess)); +} + +void FillRoadAccessBySample_2(RoadAccess & roadAccess) +{ + RoadAccess::WayToAccess wayToAccess = { {1 /* featureId */, RoadAccess::Type::Private}, {2 /* featureId */, RoadAccess::Type::Destination}, }; + RoadAccess::PointToAccess pointToAccess = { + {RoadPoint(3 /* featureId */, 10 /* pointId */), RoadAccess::Type::Destination}, + {RoadPoint(4 /* featureId */, 0 /* pointId */), RoadAccess::Type::No}, + }; + + roadAccess.SetAccess(move(wayToAccess), move(pointToAccess)); +} + +void FillRoadAccessBySampleConditional_1(RoadAccess & roadAccess) +{ + std::vector const openingHoursStrings = { + "Mo-Su", "10:00-18:00", "Mo-Fr 10:00-14:00", "09:00-13:00", "Apr - May", "2010 - 2100"}; + + std::vector openingHours; + for (auto const & oh : openingHoursStrings) + { + openingHours.emplace_back(oh); + TEST(openingHours.back().IsValid(), ()); + } + + RoadAccess::Conditional conditional_1; + conditional_1.Insert(RoadAccess::Type::No, move(openingHours[0])); + conditional_1.Insert(RoadAccess::Type::Private, move(openingHours[1])); + + RoadAccess::Conditional conditional_2; + conditional_2.Insert(RoadAccess::Type::Destination, move(openingHours[2])); + + RoadAccess::Conditional conditional_3; + conditional_3.Insert(RoadAccess::Type::No, move(openingHours[4])); + conditional_3.Insert(RoadAccess::Type::Destination, move(openingHours[3])); + + RoadAccess::Conditional conditional_4; + conditional_4.Insert(RoadAccess::Type::Destination, move(openingHours[5])); + + RoadAccess::WayToAccessConditional wayToAccessConditional = {{1 /* featureId */, conditional_1}, + {2 /* featureId */, conditional_2}}; + + RoadAccess::PointToAccessConditional pointToAccessConditional = { + {RoadPoint(3 /* featureId */, 0 /* pointId */), conditional_3}, + {RoadPoint(4 /* featureId */, 7 /* pointId */), conditional_4}}; + + roadAccess.SetAccessConditional(move(wayToAccessConditional), move(pointToAccessConditional)); +} + +void FillRoadAccessBySampleConditional_2(RoadAccess & roadAccess) +{ + std::vector const openingHoursStrings = { + "Mo", "Apr-May 03:00-04:25", "Mo-Sa 12:00-13:00", "2010-2098", "Nov-Apr", "19:00-21:00"}; + + std::vector openingHours; + for (auto const & oh : openingHoursStrings) + { + openingHours.emplace_back(oh); + TEST(openingHours.back().IsValid(), (oh)); + } + + RoadAccess::Conditional conditional_1; + conditional_1.Insert(RoadAccess::Type::Private, move(openingHours[0])); + + RoadAccess::Conditional conditional_2; + conditional_2.Insert(RoadAccess::Type::No, move(openingHours[1])); + conditional_2.Insert(RoadAccess::Type::Private, move(openingHours[2])); + + RoadAccess::Conditional conditional_3; + conditional_3.Insert(RoadAccess::Type::Destination, move(openingHours[3])); + + RoadAccess::Conditional conditional_4; + conditional_4.Insert(RoadAccess::Type::No, move(openingHours[4])); + conditional_4.Insert(RoadAccess::Type::No, move(openingHours[5])); + + RoadAccess::WayToAccessConditional wayToAccessConditional = {{1 /* featureId */, conditional_1}, + {2 /* featureId */, conditional_2}}; + + RoadAccess::PointToAccessConditional pointToAccessConditional = { + {RoadPoint(3 /* featureId */, 10 /* pointId */), conditional_3}, + {RoadPoint(4 /* featureId */, 2 /* pointId */), conditional_4}}; + + roadAccess.SetAccessConditional(move(wayToAccessConditional), move(pointToAccessConditional)); +} + + +class RoadAccessSerDesTest +{ +public: + void Serialize(RoadAccessSerializer::RoadAccessByVehicleType const & roadAccessAllTypes) + { + MemWriter writer(m_buffer); + RoadAccessSerializer::Serialize(writer, roadAccessAllTypes); + } + + void TestDeserialize(VehicleType vehicleType, RoadAccess const & answer) + { + RoadAccess deserializedRoadAccess; + + MemReader memReader(m_buffer.data(), m_buffer.size()); + ReaderSource src(memReader); + RoadAccessSerializer::Deserialize(src, vehicleType, deserializedRoadAccess); + TEST_EQUAL(src.Size(), 0, ()); + TEST_EQUAL(answer, deserializedRoadAccess, ()); + } + + void ClearBuffer() { m_buffer.clear(); } + +private: + vector m_buffer; +}; + +UNIT_CLASS_TEST(RoadAccessSerDesTest, RoadAccess_Serdes) +{ RoadAccess roadAccessCar; - roadAccessCar.SetWayToAccessForTests(m0); + FillRoadAccessBySample_1(roadAccessCar); RoadAccess roadAccessPedestrian; - roadAccessPedestrian.SetWayToAccessForTests(m1); + FillRoadAccessBySample_2(roadAccessPedestrian); RoadAccessSerializer::RoadAccessByVehicleType roadAccessAllTypes; roadAccessAllTypes[static_cast(VehicleType::Car)] = roadAccessCar; roadAccessAllTypes[static_cast(VehicleType::Pedestrian)] = roadAccessPedestrian; - vector buf; + Serialize(roadAccessAllTypes); + TestDeserialize(VehicleType::Car, roadAccessCar); + TestDeserialize(VehicleType::Pedestrian, roadAccessPedestrian); +} + +UNIT_CLASS_TEST(RoadAccessSerDesTest, RoadAccess_Serdes_Conditional_One_Vehicle) +{ + auto constexpr kVehicleTypeCount = static_cast(VehicleType::Count); + for (size_t vehicleTypeId = 0; vehicleTypeId < kVehicleTypeCount; ++vehicleTypeId) { - MemWriter writer(buf); - RoadAccessSerializer::Serialize(writer, roadAccessAllTypes); + RoadAccess roadAccess; + FillRoadAccessBySampleConditional_1(roadAccess); + + RoadAccessSerializer::RoadAccessByVehicleType roadAccessAllTypes; + roadAccessAllTypes[vehicleTypeId] = roadAccess; + + Serialize(roadAccessAllTypes); + TestDeserialize(static_cast(vehicleTypeId), roadAccess); + ClearBuffer(); } +} - { - RoadAccess deserializedRoadAccess; +UNIT_CLASS_TEST(RoadAccessSerDesTest, RoadAccess_Serdes_Conditional_Several_Vehicles) +{ + RoadAccess roadAccessCar; + FillRoadAccessBySampleConditional_1(roadAccessCar); - MemReader memReader(buf.data(), buf.size()); - ReaderSource src(memReader); - RoadAccessSerializer::Deserialize(src, VehicleType::Car, deserializedRoadAccess); + RoadAccess roadAccessPedestrian; + FillRoadAccessBySampleConditional_2(roadAccessPedestrian); - TEST_EQUAL(roadAccessCar, deserializedRoadAccess, ()); - } + RoadAccessSerializer::RoadAccessByVehicleType roadAccessAllTypes; + roadAccessAllTypes[static_cast(VehicleType::Car)] = roadAccessCar; + roadAccessAllTypes[static_cast(VehicleType::Pedestrian)] = roadAccessPedestrian; - { - RoadAccess deserializedRoadAccess; + Serialize(roadAccessAllTypes); + TestDeserialize(VehicleType::Car, roadAccessCar); + TestDeserialize(VehicleType::Pedestrian, roadAccessPedestrian); +} - MemReader memReader(buf.data(), buf.size()); - ReaderSource src(memReader); - RoadAccessSerializer::Deserialize(src, VehicleType::Pedestrian, deserializedRoadAccess); +UNIT_CLASS_TEST(RoadAccessSerDesTest, RoadAccess_Serdes_Conditional_Mixed_Several_Vehicles) +{ + RoadAccess roadAccessCar; + FillRoadAccessBySampleConditional_1(roadAccessCar); + FillRoadAccessBySample_1(roadAccessCar); - TEST_EQUAL(roadAccessPedestrian, deserializedRoadAccess, ()); - } + RoadAccess roadAccessPedestrian; + FillRoadAccessBySampleConditional_2(roadAccessPedestrian); + FillRoadAccessBySample_2(roadAccessPedestrian); + + RoadAccessSerializer::RoadAccessByVehicleType roadAccessAllTypes; + roadAccessAllTypes[static_cast(VehicleType::Car)] = roadAccessCar; + roadAccessAllTypes[static_cast(VehicleType::Pedestrian)] = roadAccessPedestrian; + + Serialize(roadAccessAllTypes); + TestDeserialize(VehicleType::Car, roadAccessCar); + TestDeserialize(VehicleType::Pedestrian, roadAccessPedestrian); } UNIT_TEST(RoadAccess_WayBlocked)