Branch data Line data Source code
1 : : /*
2 : : * ----------------- BEGIN LICENSE BLOCK ---------------------------------
3 : : *
4 : : * Copyright (C) 2018-2021 Intel Corporation
5 : : *
6 : : * SPDX-License-Identifier: MIT
7 : : *
8 : : * ----------------- END LICENSE BLOCK -----------------------------------
9 : : */
10 : :
11 : : /*
12 : : * Generated file
13 : : */
14 : :
15 : : #if defined(__clang__) && (__clang_major__ >= 7)
16 : : #pragma GCC diagnostic push
17 : : #pragma GCC diagnostic ignored "-Wself-assign-overloaded"
18 : : #endif
19 : :
20 : : #include <gtest/gtest.h>
21 : : #include <limits>
22 : : #include "ad/map/lane/Lane.hpp"
23 : :
24 : : class LaneTests : public testing::Test
25 : : {
26 : : protected:
27 : 21 : virtual void SetUp() override
28 : : {
29 : : // valid initialization
30 : 42 : ::ad::map::lane::Lane value;
31 : 21 : ::ad::map::lane::LaneId valueId(1);
32 : 21 : value.id = valueId;
33 : 21 : ::ad::map::lane::LaneType valueType(::ad::map::lane::LaneType::INVALID);
34 : 21 : value.type = valueType;
35 : 21 : ::ad::map::lane::LaneDirection valueDirection(::ad::map::lane::LaneDirection::INVALID);
36 : 21 : value.direction = valueDirection;
37 : 42 : ::ad::map::restriction::Restrictions valueRestrictions;
38 : 42 : ::ad::map::restriction::RestrictionList valueRestrictionsConjunctions;
39 : 42 : ::ad::map::restriction::Restriction valueRestrictionsConjunctionsElement;
40 : 21 : bool valueRestrictionsConjunctionsElementNegated{true};
41 : 21 : valueRestrictionsConjunctionsElement.negated = valueRestrictionsConjunctionsElementNegated;
42 : 42 : ::ad::map::restriction::RoadUserTypeList valueRestrictionsConjunctionsElementRoadUserTypes;
43 : 21 : ::ad::map::restriction::RoadUserType valueRestrictionsConjunctionsElementRoadUserTypesElement(
44 : : ::ad::map::restriction::RoadUserType::INVALID);
45 [ + - ]: 21 : valueRestrictionsConjunctionsElementRoadUserTypes.resize(1,
46 : : valueRestrictionsConjunctionsElementRoadUserTypesElement);
47 [ + - ]: 21 : valueRestrictionsConjunctionsElement.roadUserTypes = valueRestrictionsConjunctionsElementRoadUserTypes;
48 : 21 : ::ad::map::restriction::PassengerCount valueRestrictionsConjunctionsElementPassengersMin(
49 : : std::numeric_limits<::ad::map::restriction::PassengerCount>::lowest());
50 : 21 : valueRestrictionsConjunctionsElement.passengersMin = valueRestrictionsConjunctionsElementPassengersMin;
51 [ + - ]: 21 : valueRestrictionsConjunctions.resize(1, valueRestrictionsConjunctionsElement);
52 [ + - ]: 21 : valueRestrictions.conjunctions = valueRestrictionsConjunctions;
53 : 42 : ::ad::map::restriction::RestrictionList valueRestrictionsDisjunctions;
54 : 42 : ::ad::map::restriction::Restriction valueRestrictionsDisjunctionsElement;
55 : 21 : bool valueRestrictionsDisjunctionsElementNegated{true};
56 : 21 : valueRestrictionsDisjunctionsElement.negated = valueRestrictionsDisjunctionsElementNegated;
57 : 42 : ::ad::map::restriction::RoadUserTypeList valueRestrictionsDisjunctionsElementRoadUserTypes;
58 : 21 : ::ad::map::restriction::RoadUserType valueRestrictionsDisjunctionsElementRoadUserTypesElement(
59 : : ::ad::map::restriction::RoadUserType::INVALID);
60 [ + - ]: 21 : valueRestrictionsDisjunctionsElementRoadUserTypes.resize(1,
61 : : valueRestrictionsDisjunctionsElementRoadUserTypesElement);
62 [ + - ]: 21 : valueRestrictionsDisjunctionsElement.roadUserTypes = valueRestrictionsDisjunctionsElementRoadUserTypes;
63 : 21 : ::ad::map::restriction::PassengerCount valueRestrictionsDisjunctionsElementPassengersMin(
64 : : std::numeric_limits<::ad::map::restriction::PassengerCount>::lowest());
65 : 21 : valueRestrictionsDisjunctionsElement.passengersMin = valueRestrictionsDisjunctionsElementPassengersMin;
66 [ + - ]: 21 : valueRestrictionsDisjunctions.resize(1, valueRestrictionsDisjunctionsElement);
67 [ + - ]: 21 : valueRestrictions.disjunctions = valueRestrictionsDisjunctions;
68 [ + - ]: 21 : value.restrictions = valueRestrictions;
69 : 21 : ::ad::physics::Distance valueLength(-1e9);
70 : 21 : value.length = valueLength;
71 : 21 : ::ad::physics::MetricRange valueLengthRange;
72 : 21 : ::ad::physics::Distance valueLengthRangeMinimum(-1e9);
73 : 21 : valueLengthRangeMinimum = ::ad::physics::Distance(0.); // set to valid value within struct
74 : 21 : valueLengthRange.minimum = valueLengthRangeMinimum;
75 : 21 : ::ad::physics::Distance valueLengthRangeMaximum(-1e9);
76 : 21 : valueLengthRange.maximum = valueLengthRangeMaximum;
77 : 21 : valueLengthRange.maximum = valueLengthRange.minimum;
78 : 21 : valueLengthRange.minimum = valueLengthRange.maximum;
79 : 21 : value.lengthRange = valueLengthRange;
80 : 21 : ::ad::physics::Distance valueWidth(-1e9);
81 : 21 : value.width = valueWidth;
82 : 21 : ::ad::physics::MetricRange valueWidthRange;
83 : 21 : ::ad::physics::Distance valueWidthRangeMinimum(-1e9);
84 : 21 : valueWidthRangeMinimum = ::ad::physics::Distance(0.); // set to valid value within struct
85 : 21 : valueWidthRange.minimum = valueWidthRangeMinimum;
86 : 21 : ::ad::physics::Distance valueWidthRangeMaximum(-1e9);
87 : 21 : valueWidthRange.maximum = valueWidthRangeMaximum;
88 : 21 : valueWidthRange.maximum = valueWidthRange.minimum;
89 : 21 : valueWidthRange.minimum = valueWidthRange.maximum;
90 : 21 : value.widthRange = valueWidthRange;
91 : 42 : ::ad::map::restriction::SpeedLimitList valueSpeedLimits;
92 : 21 : ::ad::map::restriction::SpeedLimit valueSpeedLimitsElement;
93 : 21 : ::ad::physics::Speed valueSpeedLimitsElementSpeedLimit(-100.);
94 : 21 : valueSpeedLimitsElement.speedLimit = valueSpeedLimitsElementSpeedLimit;
95 : 21 : ::ad::physics::ParametricRange valueSpeedLimitsElementLanePiece;
96 : 21 : ::ad::physics::ParametricValue valueSpeedLimitsElementLanePieceMinimum(0.);
97 : 21 : valueSpeedLimitsElementLanePiece.minimum = valueSpeedLimitsElementLanePieceMinimum;
98 : 21 : ::ad::physics::ParametricValue valueSpeedLimitsElementLanePieceMaximum(0.);
99 : 21 : valueSpeedLimitsElementLanePiece.maximum = valueSpeedLimitsElementLanePieceMaximum;
100 : 21 : valueSpeedLimitsElementLanePiece.maximum = valueSpeedLimitsElementLanePiece.minimum;
101 : 21 : valueSpeedLimitsElementLanePiece.minimum = valueSpeedLimitsElementLanePiece.maximum;
102 : 21 : valueSpeedLimitsElement.lanePiece = valueSpeedLimitsElementLanePiece;
103 [ + - ]: 21 : valueSpeedLimits.resize(1, valueSpeedLimitsElement);
104 [ + - ]: 21 : value.speedLimits = valueSpeedLimits;
105 : 42 : ::ad::map::point::Geometry valueEdgeLeft;
106 : 21 : bool valueEdgeLeftIsValid{true};
107 : 21 : valueEdgeLeft.isValid = valueEdgeLeftIsValid;
108 : 21 : bool valueEdgeLeftIsClosed{true};
109 : 21 : valueEdgeLeft.isClosed = valueEdgeLeftIsClosed;
110 : 42 : ::ad::map::point::ECEFEdge valueEdgeLeftEcefEdge;
111 : 21 : ::ad::map::point::ECEFPoint valueEdgeLeftEcefEdgeElement;
112 : 21 : ::ad::map::point::ECEFCoordinate valueEdgeLeftEcefEdgeElementX(-6400000);
113 : 21 : valueEdgeLeftEcefEdgeElement.x = valueEdgeLeftEcefEdgeElementX;
114 : 21 : ::ad::map::point::ECEFCoordinate valueEdgeLeftEcefEdgeElementY(-6400000);
115 : 21 : valueEdgeLeftEcefEdgeElement.y = valueEdgeLeftEcefEdgeElementY;
116 : 21 : ::ad::map::point::ECEFCoordinate valueEdgeLeftEcefEdgeElementZ(-6400000);
117 : 21 : valueEdgeLeftEcefEdgeElement.z = valueEdgeLeftEcefEdgeElementZ;
118 [ + - ]: 21 : valueEdgeLeftEcefEdge.resize(1, valueEdgeLeftEcefEdgeElement);
119 [ + - ]: 21 : valueEdgeLeft.ecefEdge = valueEdgeLeftEcefEdge;
120 : 21 : ::ad::physics::Distance valueEdgeLeftLength(-1e9);
121 : 21 : valueEdgeLeft.length = valueEdgeLeftLength;
122 : 42 : ::ad::map::point::ENUEdgeCache valueEdgeLeftPrivate_enuEdgeCache;
123 : 42 : ::ad::map::point::ENUEdge valueEdgeLeftPrivate_enuEdgeCacheEnuEdge;
124 : 21 : ::ad::map::point::ENUPoint valueEdgeLeftPrivate_enuEdgeCacheEnuEdgeElement;
125 : 21 : ::ad::map::point::ENUCoordinate valueEdgeLeftPrivate_enuEdgeCacheEnuEdgeElementX(-16384);
126 : 21 : valueEdgeLeftPrivate_enuEdgeCacheEnuEdgeElement.x = valueEdgeLeftPrivate_enuEdgeCacheEnuEdgeElementX;
127 : 21 : ::ad::map::point::ENUCoordinate valueEdgeLeftPrivate_enuEdgeCacheEnuEdgeElementY(-16384);
128 : 21 : valueEdgeLeftPrivate_enuEdgeCacheEnuEdgeElement.y = valueEdgeLeftPrivate_enuEdgeCacheEnuEdgeElementY;
129 : 21 : ::ad::map::point::ENUCoordinate valueEdgeLeftPrivate_enuEdgeCacheEnuEdgeElementZ(-16384);
130 : 21 : valueEdgeLeftPrivate_enuEdgeCacheEnuEdgeElement.z = valueEdgeLeftPrivate_enuEdgeCacheEnuEdgeElementZ;
131 [ + - ]: 21 : valueEdgeLeftPrivate_enuEdgeCacheEnuEdge.resize(1, valueEdgeLeftPrivate_enuEdgeCacheEnuEdgeElement);
132 [ + - ]: 21 : valueEdgeLeftPrivate_enuEdgeCache.enuEdge = valueEdgeLeftPrivate_enuEdgeCacheEnuEdge;
133 : 21 : uint64_t valueEdgeLeftPrivate_enuEdgeCacheEnuVersion{std::numeric_limits<uint64_t>::min()};
134 : 21 : valueEdgeLeftPrivate_enuEdgeCache.enuVersion = valueEdgeLeftPrivate_enuEdgeCacheEnuVersion;
135 [ + - ]: 21 : valueEdgeLeft.private_enuEdgeCache = valueEdgeLeftPrivate_enuEdgeCache;
136 [ + - ]: 21 : value.edgeLeft = valueEdgeLeft;
137 : 42 : ::ad::map::point::Geometry valueEdgeRight;
138 : 21 : bool valueEdgeRightIsValid{true};
139 : 21 : valueEdgeRight.isValid = valueEdgeRightIsValid;
140 : 21 : bool valueEdgeRightIsClosed{true};
141 : 21 : valueEdgeRight.isClosed = valueEdgeRightIsClosed;
142 : 42 : ::ad::map::point::ECEFEdge valueEdgeRightEcefEdge;
143 : 21 : ::ad::map::point::ECEFPoint valueEdgeRightEcefEdgeElement;
144 : 21 : ::ad::map::point::ECEFCoordinate valueEdgeRightEcefEdgeElementX(-6400000);
145 : 21 : valueEdgeRightEcefEdgeElement.x = valueEdgeRightEcefEdgeElementX;
146 : 21 : ::ad::map::point::ECEFCoordinate valueEdgeRightEcefEdgeElementY(-6400000);
147 : 21 : valueEdgeRightEcefEdgeElement.y = valueEdgeRightEcefEdgeElementY;
148 : 21 : ::ad::map::point::ECEFCoordinate valueEdgeRightEcefEdgeElementZ(-6400000);
149 : 21 : valueEdgeRightEcefEdgeElement.z = valueEdgeRightEcefEdgeElementZ;
150 [ + - ]: 21 : valueEdgeRightEcefEdge.resize(1, valueEdgeRightEcefEdgeElement);
151 [ + - ]: 21 : valueEdgeRight.ecefEdge = valueEdgeRightEcefEdge;
152 : 21 : ::ad::physics::Distance valueEdgeRightLength(-1e9);
153 : 21 : valueEdgeRight.length = valueEdgeRightLength;
154 : 42 : ::ad::map::point::ENUEdgeCache valueEdgeRightPrivate_enuEdgeCache;
155 : 42 : ::ad::map::point::ENUEdge valueEdgeRightPrivate_enuEdgeCacheEnuEdge;
156 : 21 : ::ad::map::point::ENUPoint valueEdgeRightPrivate_enuEdgeCacheEnuEdgeElement;
157 : 21 : ::ad::map::point::ENUCoordinate valueEdgeRightPrivate_enuEdgeCacheEnuEdgeElementX(-16384);
158 : 21 : valueEdgeRightPrivate_enuEdgeCacheEnuEdgeElement.x = valueEdgeRightPrivate_enuEdgeCacheEnuEdgeElementX;
159 : 21 : ::ad::map::point::ENUCoordinate valueEdgeRightPrivate_enuEdgeCacheEnuEdgeElementY(-16384);
160 : 21 : valueEdgeRightPrivate_enuEdgeCacheEnuEdgeElement.y = valueEdgeRightPrivate_enuEdgeCacheEnuEdgeElementY;
161 : 21 : ::ad::map::point::ENUCoordinate valueEdgeRightPrivate_enuEdgeCacheEnuEdgeElementZ(-16384);
162 : 21 : valueEdgeRightPrivate_enuEdgeCacheEnuEdgeElement.z = valueEdgeRightPrivate_enuEdgeCacheEnuEdgeElementZ;
163 [ + - ]: 21 : valueEdgeRightPrivate_enuEdgeCacheEnuEdge.resize(1, valueEdgeRightPrivate_enuEdgeCacheEnuEdgeElement);
164 [ + - ]: 21 : valueEdgeRightPrivate_enuEdgeCache.enuEdge = valueEdgeRightPrivate_enuEdgeCacheEnuEdge;
165 : 21 : uint64_t valueEdgeRightPrivate_enuEdgeCacheEnuVersion{std::numeric_limits<uint64_t>::min()};
166 : 21 : valueEdgeRightPrivate_enuEdgeCache.enuVersion = valueEdgeRightPrivate_enuEdgeCacheEnuVersion;
167 [ + - ]: 21 : valueEdgeRight.private_enuEdgeCache = valueEdgeRightPrivate_enuEdgeCache;
168 [ + - ]: 21 : value.edgeRight = valueEdgeRight;
169 : 42 : ::ad::map::lane::ContactLaneList valueContactLanes;
170 : 42 : ::ad::map::lane::ContactLane valueContactLanesElement;
171 : 21 : ::ad::map::lane::LaneId valueContactLanesElementToLane(1);
172 : 21 : valueContactLanesElement.toLane = valueContactLanesElementToLane;
173 : 21 : ::ad::map::lane::ContactLocation valueContactLanesElementLocation(::ad::map::lane::ContactLocation::INVALID);
174 : 21 : valueContactLanesElement.location = valueContactLanesElementLocation;
175 : 42 : ::ad::map::lane::ContactTypeList valueContactLanesElementTypes;
176 : 21 : ::ad::map::lane::ContactType valueContactLanesElementTypesElement(::ad::map::lane::ContactType::INVALID);
177 [ + - ]: 21 : valueContactLanesElementTypes.resize(1, valueContactLanesElementTypesElement);
178 [ + - ]: 21 : valueContactLanesElement.types = valueContactLanesElementTypes;
179 : 42 : ::ad::map::restriction::Restrictions valueContactLanesElementRestrictions;
180 : 42 : ::ad::map::restriction::RestrictionList valueContactLanesElementRestrictionsConjunctions;
181 : 42 : ::ad::map::restriction::Restriction valueContactLanesElementRestrictionsConjunctionsElement;
182 : 21 : bool valueContactLanesElementRestrictionsConjunctionsElementNegated{true};
183 : : valueContactLanesElementRestrictionsConjunctionsElement.negated
184 : 21 : = valueContactLanesElementRestrictionsConjunctionsElementNegated;
185 : 42 : ::ad::map::restriction::RoadUserTypeList valueContactLanesElementRestrictionsConjunctionsElementRoadUserTypes;
186 : 21 : ::ad::map::restriction::RoadUserType valueContactLanesElementRestrictionsConjunctionsElementRoadUserTypesElement(
187 : : ::ad::map::restriction::RoadUserType::INVALID);
188 [ + - ]: 21 : valueContactLanesElementRestrictionsConjunctionsElementRoadUserTypes.resize(
189 : : 1, valueContactLanesElementRestrictionsConjunctionsElementRoadUserTypesElement);
190 : : valueContactLanesElementRestrictionsConjunctionsElement.roadUserTypes
191 [ + - ]: 21 : = valueContactLanesElementRestrictionsConjunctionsElementRoadUserTypes;
192 : 21 : ::ad::map::restriction::PassengerCount valueContactLanesElementRestrictionsConjunctionsElementPassengersMin(
193 : : std::numeric_limits<::ad::map::restriction::PassengerCount>::lowest());
194 : : valueContactLanesElementRestrictionsConjunctionsElement.passengersMin
195 : 21 : = valueContactLanesElementRestrictionsConjunctionsElementPassengersMin;
196 [ + - ]: 21 : valueContactLanesElementRestrictionsConjunctions.resize(1, valueContactLanesElementRestrictionsConjunctionsElement);
197 [ + - ]: 21 : valueContactLanesElementRestrictions.conjunctions = valueContactLanesElementRestrictionsConjunctions;
198 : 42 : ::ad::map::restriction::RestrictionList valueContactLanesElementRestrictionsDisjunctions;
199 : 42 : ::ad::map::restriction::Restriction valueContactLanesElementRestrictionsDisjunctionsElement;
200 : 21 : bool valueContactLanesElementRestrictionsDisjunctionsElementNegated{true};
201 : : valueContactLanesElementRestrictionsDisjunctionsElement.negated
202 : 21 : = valueContactLanesElementRestrictionsDisjunctionsElementNegated;
203 : 42 : ::ad::map::restriction::RoadUserTypeList valueContactLanesElementRestrictionsDisjunctionsElementRoadUserTypes;
204 : 21 : ::ad::map::restriction::RoadUserType valueContactLanesElementRestrictionsDisjunctionsElementRoadUserTypesElement(
205 : : ::ad::map::restriction::RoadUserType::INVALID);
206 [ + - ]: 21 : valueContactLanesElementRestrictionsDisjunctionsElementRoadUserTypes.resize(
207 : : 1, valueContactLanesElementRestrictionsDisjunctionsElementRoadUserTypesElement);
208 : : valueContactLanesElementRestrictionsDisjunctionsElement.roadUserTypes
209 [ + - ]: 21 : = valueContactLanesElementRestrictionsDisjunctionsElementRoadUserTypes;
210 : 21 : ::ad::map::restriction::PassengerCount valueContactLanesElementRestrictionsDisjunctionsElementPassengersMin(
211 : : std::numeric_limits<::ad::map::restriction::PassengerCount>::lowest());
212 : : valueContactLanesElementRestrictionsDisjunctionsElement.passengersMin
213 : 21 : = valueContactLanesElementRestrictionsDisjunctionsElementPassengersMin;
214 [ + - ]: 21 : valueContactLanesElementRestrictionsDisjunctions.resize(1, valueContactLanesElementRestrictionsDisjunctionsElement);
215 [ + - ]: 21 : valueContactLanesElementRestrictions.disjunctions = valueContactLanesElementRestrictionsDisjunctions;
216 [ + - ]: 21 : valueContactLanesElement.restrictions = valueContactLanesElementRestrictions;
217 : : ::ad::map::landmark::LandmarkId valueContactLanesElementTrafficLightId(
218 : 21 : std::numeric_limits<::ad::map::landmark::LandmarkId>::lowest());
219 : 21 : valueContactLanesElement.trafficLightId = valueContactLanesElementTrafficLightId;
220 [ + - ]: 21 : valueContactLanes.resize(1, valueContactLanesElement);
221 [ + - ]: 21 : value.contactLanes = valueContactLanes;
222 : 21 : ::ad::map::lane::ComplianceVersion valueComplianceVersion(
223 : : std::numeric_limits<::ad::map::lane::ComplianceVersion>::lowest());
224 : 21 : value.complianceVersion = valueComplianceVersion;
225 : 21 : ::ad::map::point::BoundingSphere valueBoundingSphere;
226 : 21 : ::ad::map::point::ECEFPoint valueBoundingSphereCenter;
227 : 21 : ::ad::map::point::ECEFCoordinate valueBoundingSphereCenterX(-6400000);
228 : 21 : valueBoundingSphereCenter.x = valueBoundingSphereCenterX;
229 : 21 : ::ad::map::point::ECEFCoordinate valueBoundingSphereCenterY(-6400000);
230 : 21 : valueBoundingSphereCenter.y = valueBoundingSphereCenterY;
231 : 21 : ::ad::map::point::ECEFCoordinate valueBoundingSphereCenterZ(-6400000);
232 : 21 : valueBoundingSphereCenter.z = valueBoundingSphereCenterZ;
233 : 21 : valueBoundingSphere.center = valueBoundingSphereCenter;
234 : 21 : ::ad::physics::Distance valueBoundingSphereRadius(-1e9);
235 : 21 : valueBoundingSphere.radius = valueBoundingSphereRadius;
236 : 21 : value.boundingSphere = valueBoundingSphere;
237 : 42 : ::ad::map::landmark::LandmarkIdList valueVisibleLandmarks;
238 : : ::ad::map::landmark::LandmarkId valueVisibleLandmarksElement(
239 : 21 : std::numeric_limits<::ad::map::landmark::LandmarkId>::lowest());
240 [ + - ]: 21 : valueVisibleLandmarks.resize(1, valueVisibleLandmarksElement);
241 [ + - ]: 21 : value.visibleLandmarks = valueVisibleLandmarks;
242 [ + - ]: 21 : mValue = value;
243 : 21 : }
244 : :
245 : : ::ad::map::lane::Lane mValue;
246 : : };
247 : :
248 : 2 : TEST_F(LaneTests, copyConstruction)
249 : : {
250 [ + - ]: 2 : ::ad::map::lane::Lane value(mValue);
251 [ + - - + : 1 : EXPECT_EQ(mValue, value);
- - - - -
- ]
252 : 1 : }
253 : :
254 : 2 : TEST_F(LaneTests, moveConstruction)
255 : : {
256 [ + - ]: 2 : ::ad::map::lane::Lane tmpValue(mValue);
257 : 2 : ::ad::map::lane::Lane value(std::move(tmpValue));
258 [ + - - + : 1 : EXPECT_EQ(mValue, value);
- - - - -
- ]
259 : 1 : }
260 : :
261 : 2 : TEST_F(LaneTests, copyAssignment)
262 : : {
263 : 2 : ::ad::map::lane::Lane value;
264 [ + - ]: 1 : value = mValue;
265 [ + - - + : 1 : EXPECT_EQ(mValue, value);
- - - - -
- ]
266 : 1 : }
267 : :
268 : 2 : TEST_F(LaneTests, moveAssignment)
269 : : {
270 [ + - ]: 2 : ::ad::map::lane::Lane tmpValue(mValue);
271 : 2 : ::ad::map::lane::Lane value;
272 : 1 : value = std::move(tmpValue);
273 [ + - - + : 1 : EXPECT_EQ(mValue, value);
- - - - -
- ]
274 : 1 : }
275 : :
276 : 2 : TEST_F(LaneTests, comparisonOperatorEqual)
277 : : {
278 [ + - ]: 2 : ::ad::map::lane::Lane valueA = mValue;
279 [ + - ]: 2 : ::ad::map::lane::Lane valueB = mValue;
280 : :
281 [ + - - + : 1 : EXPECT_TRUE(valueA == valueB);
- - - - -
- - - ]
282 [ + - - + : 1 : EXPECT_FALSE(valueA != valueB);
- - - - -
- - - ]
283 : 1 : }
284 : :
285 : 2 : TEST_F(LaneTests, stringConversionTest)
286 : : {
287 [ + - ]: 1 : std::stringstream stream;
288 [ + - ]: 1 : stream << mValue;
289 [ + - ]: 1 : std::string ostreamStr = stream.str();
290 [ + - ]: 1 : std::string toStr = std::to_string(mValue);
291 [ + - - + : 1 : ASSERT_EQ(ostreamStr, toStr);
- - - - -
- ]
292 : : }
293 : :
294 : 2 : TEST_F(LaneTests, comparisonOperatorIdDiffers)
295 : : {
296 [ + - ]: 2 : ::ad::map::lane::Lane valueA = mValue;
297 : 1 : ::ad::map::lane::LaneId id(std::numeric_limits<::ad::map::lane::LaneId>::max());
298 : 1 : valueA.id = id;
299 [ + - ]: 2 : ::ad::map::lane::Lane valueB = mValue;
300 : :
301 [ + - - + : 1 : EXPECT_FALSE(valueA == valueB);
- - - - -
- - - ]
302 [ + - - + : 1 : EXPECT_TRUE(valueA != valueB);
- - - - -
- - - ]
303 : 1 : }
304 : :
305 : 2 : TEST_F(LaneTests, comparisonOperatorTypeDiffers)
306 : : {
307 [ + - ]: 2 : ::ad::map::lane::Lane valueA = mValue;
308 : 1 : ::ad::map::lane::LaneType type(::ad::map::lane::LaneType::BIKE);
309 : 1 : valueA.type = type;
310 [ + - ]: 2 : ::ad::map::lane::Lane valueB = mValue;
311 : :
312 [ + - - + : 1 : EXPECT_FALSE(valueA == valueB);
- - - - -
- - - ]
313 [ + - - + : 1 : EXPECT_TRUE(valueA != valueB);
- - - - -
- - - ]
314 : 1 : }
315 : :
316 : 2 : TEST_F(LaneTests, comparisonOperatorDirectionDiffers)
317 : : {
318 [ + - ]: 2 : ::ad::map::lane::Lane valueA = mValue;
319 : 1 : ::ad::map::lane::LaneDirection direction(::ad::map::lane::LaneDirection::NONE);
320 : 1 : valueA.direction = direction;
321 [ + - ]: 2 : ::ad::map::lane::Lane valueB = mValue;
322 : :
323 [ + - - + : 1 : EXPECT_FALSE(valueA == valueB);
- - - - -
- - - ]
324 [ + - - + : 1 : EXPECT_TRUE(valueA != valueB);
- - - - -
- - - ]
325 : 1 : }
326 : :
327 : 2 : TEST_F(LaneTests, comparisonOperatorRestrictionsDiffers)
328 : : {
329 [ + - ]: 2 : ::ad::map::lane::Lane valueA = mValue;
330 : 2 : ::ad::map::restriction::Restrictions restrictions;
331 : 2 : ::ad::map::restriction::RestrictionList restrictionsConjunctions;
332 : 2 : ::ad::map::restriction::Restriction restrictionsConjunctionsElement;
333 : 1 : bool restrictionsConjunctionsElementNegated{false};
334 : 1 : restrictionsConjunctionsElement.negated = restrictionsConjunctionsElementNegated;
335 : 2 : ::ad::map::restriction::RoadUserTypeList restrictionsConjunctionsElementRoadUserTypes;
336 : 1 : ::ad::map::restriction::RoadUserType restrictionsConjunctionsElementRoadUserTypesElement(
337 : : ::ad::map::restriction::RoadUserType::CAR_DIESEL);
338 [ + - ]: 1 : restrictionsConjunctionsElementRoadUserTypes.resize(2, restrictionsConjunctionsElementRoadUserTypesElement);
339 [ + - ]: 1 : restrictionsConjunctionsElement.roadUserTypes = restrictionsConjunctionsElementRoadUserTypes;
340 : 1 : ::ad::map::restriction::PassengerCount restrictionsConjunctionsElementPassengersMin(
341 : : std::numeric_limits<::ad::map::restriction::PassengerCount>::max());
342 : 1 : restrictionsConjunctionsElement.passengersMin = restrictionsConjunctionsElementPassengersMin;
343 [ + - ]: 1 : restrictionsConjunctions.resize(2, restrictionsConjunctionsElement);
344 [ + - ]: 1 : restrictions.conjunctions = restrictionsConjunctions;
345 : 2 : ::ad::map::restriction::RestrictionList restrictionsDisjunctions;
346 : 2 : ::ad::map::restriction::Restriction restrictionsDisjunctionsElement;
347 : 1 : bool restrictionsDisjunctionsElementNegated{false};
348 : 1 : restrictionsDisjunctionsElement.negated = restrictionsDisjunctionsElementNegated;
349 : 2 : ::ad::map::restriction::RoadUserTypeList restrictionsDisjunctionsElementRoadUserTypes;
350 : 1 : ::ad::map::restriction::RoadUserType restrictionsDisjunctionsElementRoadUserTypesElement(
351 : : ::ad::map::restriction::RoadUserType::CAR_DIESEL);
352 [ + - ]: 1 : restrictionsDisjunctionsElementRoadUserTypes.resize(2, restrictionsDisjunctionsElementRoadUserTypesElement);
353 [ + - ]: 1 : restrictionsDisjunctionsElement.roadUserTypes = restrictionsDisjunctionsElementRoadUserTypes;
354 : 1 : ::ad::map::restriction::PassengerCount restrictionsDisjunctionsElementPassengersMin(
355 : : std::numeric_limits<::ad::map::restriction::PassengerCount>::max());
356 : 1 : restrictionsDisjunctionsElement.passengersMin = restrictionsDisjunctionsElementPassengersMin;
357 [ + - ]: 1 : restrictionsDisjunctions.resize(2, restrictionsDisjunctionsElement);
358 [ + - ]: 1 : restrictions.disjunctions = restrictionsDisjunctions;
359 [ + - ]: 1 : valueA.restrictions = restrictions;
360 [ + - ]: 2 : ::ad::map::lane::Lane valueB = mValue;
361 : :
362 [ + - - + : 1 : EXPECT_FALSE(valueA == valueB);
- - - - -
- - - ]
363 [ + - - + : 1 : EXPECT_TRUE(valueA != valueB);
- - - - -
- - - ]
364 : 1 : }
365 : :
366 : 2 : TEST_F(LaneTests, comparisonOperatorLengthDiffers)
367 : : {
368 [ + - ]: 2 : ::ad::map::lane::Lane valueA = mValue;
369 : 1 : ::ad::physics::Distance length(1e9);
370 : 1 : valueA.length = length;
371 [ + - ]: 2 : ::ad::map::lane::Lane valueB = mValue;
372 : :
373 [ + - - + : 1 : EXPECT_FALSE(valueA == valueB);
- - - - -
- - - ]
374 [ + - - + : 1 : EXPECT_TRUE(valueA != valueB);
- - - - -
- - - ]
375 : 1 : }
376 : :
377 : 2 : TEST_F(LaneTests, comparisonOperatorLengthRangeDiffers)
378 : : {
379 [ + - ]: 2 : ::ad::map::lane::Lane valueA = mValue;
380 : 1 : ::ad::physics::MetricRange lengthRange;
381 : 1 : ::ad::physics::Distance lengthRangeMinimum(1e9);
382 : 1 : lengthRange.minimum = lengthRangeMinimum;
383 : 1 : ::ad::physics::Distance lengthRangeMaximum(1e9);
384 : 1 : lengthRangeMaximum = ::ad::physics::Distance(1e6); // set to valid value within struct
385 : 1 : lengthRange.maximum = lengthRangeMaximum;
386 : 1 : lengthRange.maximum = lengthRange.minimum;
387 : 1 : lengthRange.minimum = lengthRange.maximum;
388 : 1 : valueA.lengthRange = lengthRange;
389 [ + - ]: 2 : ::ad::map::lane::Lane valueB = mValue;
390 : :
391 [ + - - + : 1 : EXPECT_FALSE(valueA == valueB);
- - - - -
- - - ]
392 [ + - - + : 1 : EXPECT_TRUE(valueA != valueB);
- - - - -
- - - ]
393 : 1 : }
394 : :
395 : 2 : TEST_F(LaneTests, comparisonOperatorWidthDiffers)
396 : : {
397 [ + - ]: 2 : ::ad::map::lane::Lane valueA = mValue;
398 : 1 : ::ad::physics::Distance width(1e9);
399 : 1 : valueA.width = width;
400 [ + - ]: 2 : ::ad::map::lane::Lane valueB = mValue;
401 : :
402 [ + - - + : 1 : EXPECT_FALSE(valueA == valueB);
- - - - -
- - - ]
403 [ + - - + : 1 : EXPECT_TRUE(valueA != valueB);
- - - - -
- - - ]
404 : 1 : }
405 : :
406 : 2 : TEST_F(LaneTests, comparisonOperatorWidthRangeDiffers)
407 : : {
408 [ + - ]: 2 : ::ad::map::lane::Lane valueA = mValue;
409 : 1 : ::ad::physics::MetricRange widthRange;
410 : 1 : ::ad::physics::Distance widthRangeMinimum(1e9);
411 : 1 : widthRange.minimum = widthRangeMinimum;
412 : 1 : ::ad::physics::Distance widthRangeMaximum(1e9);
413 : 1 : widthRangeMaximum = ::ad::physics::Distance(1e6); // set to valid value within struct
414 : 1 : widthRange.maximum = widthRangeMaximum;
415 : 1 : widthRange.maximum = widthRange.minimum;
416 : 1 : widthRange.minimum = widthRange.maximum;
417 : 1 : valueA.widthRange = widthRange;
418 [ + - ]: 2 : ::ad::map::lane::Lane valueB = mValue;
419 : :
420 [ + - - + : 1 : EXPECT_FALSE(valueA == valueB);
- - - - -
- - - ]
421 [ + - - + : 1 : EXPECT_TRUE(valueA != valueB);
- - - - -
- - - ]
422 : 1 : }
423 : :
424 : 2 : TEST_F(LaneTests, comparisonOperatorSpeedLimitsDiffers)
425 : : {
426 [ + - ]: 2 : ::ad::map::lane::Lane valueA = mValue;
427 : 2 : ::ad::map::restriction::SpeedLimitList speedLimits;
428 : 1 : ::ad::map::restriction::SpeedLimit speedLimitsElement;
429 : 1 : ::ad::physics::Speed speedLimitsElementSpeedLimit(100.);
430 : 1 : speedLimitsElement.speedLimit = speedLimitsElementSpeedLimit;
431 : 1 : ::ad::physics::ParametricRange speedLimitsElementLanePiece;
432 : 1 : ::ad::physics::ParametricValue speedLimitsElementLanePieceMinimum(1.);
433 : 1 : speedLimitsElementLanePiece.minimum = speedLimitsElementLanePieceMinimum;
434 : 1 : ::ad::physics::ParametricValue speedLimitsElementLanePieceMaximum(1.);
435 : 1 : speedLimitsElementLanePiece.maximum = speedLimitsElementLanePieceMaximum;
436 : 1 : speedLimitsElementLanePiece.maximum = speedLimitsElementLanePiece.minimum;
437 : 1 : speedLimitsElementLanePiece.minimum = speedLimitsElementLanePiece.maximum;
438 : 1 : speedLimitsElement.lanePiece = speedLimitsElementLanePiece;
439 [ + - ]: 1 : speedLimits.resize(2, speedLimitsElement);
440 [ + - ]: 1 : valueA.speedLimits = speedLimits;
441 [ + - ]: 2 : ::ad::map::lane::Lane valueB = mValue;
442 : :
443 [ + - - + : 1 : EXPECT_FALSE(valueA == valueB);
- - - - -
- - - ]
444 [ + - - + : 1 : EXPECT_TRUE(valueA != valueB);
- - - - -
- - - ]
445 : 1 : }
446 : :
447 : 2 : TEST_F(LaneTests, comparisonOperatorEdgeLeftDiffers)
448 : : {
449 [ + - ]: 2 : ::ad::map::lane::Lane valueA = mValue;
450 : 2 : ::ad::map::point::Geometry edgeLeft;
451 : 1 : bool edgeLeftIsValid{false};
452 : 1 : edgeLeft.isValid = edgeLeftIsValid;
453 : 1 : bool edgeLeftIsClosed{false};
454 : 1 : edgeLeft.isClosed = edgeLeftIsClosed;
455 : 2 : ::ad::map::point::ECEFEdge edgeLeftEcefEdge;
456 : 1 : ::ad::map::point::ECEFPoint edgeLeftEcefEdgeElement;
457 : 1 : ::ad::map::point::ECEFCoordinate edgeLeftEcefEdgeElementX(6400000);
458 : 1 : edgeLeftEcefEdgeElement.x = edgeLeftEcefEdgeElementX;
459 : 1 : ::ad::map::point::ECEFCoordinate edgeLeftEcefEdgeElementY(6400000);
460 : 1 : edgeLeftEcefEdgeElement.y = edgeLeftEcefEdgeElementY;
461 : 1 : ::ad::map::point::ECEFCoordinate edgeLeftEcefEdgeElementZ(6400000);
462 : 1 : edgeLeftEcefEdgeElement.z = edgeLeftEcefEdgeElementZ;
463 [ + - ]: 1 : edgeLeftEcefEdge.resize(2, edgeLeftEcefEdgeElement);
464 [ + - ]: 1 : edgeLeft.ecefEdge = edgeLeftEcefEdge;
465 : 1 : ::ad::physics::Distance edgeLeftLength(1e9);
466 : 1 : edgeLeft.length = edgeLeftLength;
467 : 2 : ::ad::map::point::ENUEdgeCache edgeLeftPrivate_enuEdgeCache;
468 : 2 : ::ad::map::point::ENUEdge edgeLeftPrivate_enuEdgeCacheEnuEdge;
469 : 1 : ::ad::map::point::ENUPoint edgeLeftPrivate_enuEdgeCacheEnuEdgeElement;
470 : 1 : ::ad::map::point::ENUCoordinate edgeLeftPrivate_enuEdgeCacheEnuEdgeElementX(16384);
471 : 1 : edgeLeftPrivate_enuEdgeCacheEnuEdgeElement.x = edgeLeftPrivate_enuEdgeCacheEnuEdgeElementX;
472 : 1 : ::ad::map::point::ENUCoordinate edgeLeftPrivate_enuEdgeCacheEnuEdgeElementY(16384);
473 : 1 : edgeLeftPrivate_enuEdgeCacheEnuEdgeElement.y = edgeLeftPrivate_enuEdgeCacheEnuEdgeElementY;
474 : 1 : ::ad::map::point::ENUCoordinate edgeLeftPrivate_enuEdgeCacheEnuEdgeElementZ(16384);
475 : 1 : edgeLeftPrivate_enuEdgeCacheEnuEdgeElement.z = edgeLeftPrivate_enuEdgeCacheEnuEdgeElementZ;
476 [ + - ]: 1 : edgeLeftPrivate_enuEdgeCacheEnuEdge.resize(2, edgeLeftPrivate_enuEdgeCacheEnuEdgeElement);
477 [ + - ]: 1 : edgeLeftPrivate_enuEdgeCache.enuEdge = edgeLeftPrivate_enuEdgeCacheEnuEdge;
478 : 1 : uint64_t edgeLeftPrivate_enuEdgeCacheEnuVersion{std::numeric_limits<uint64_t>::max()};
479 : 1 : edgeLeftPrivate_enuEdgeCache.enuVersion = edgeLeftPrivate_enuEdgeCacheEnuVersion;
480 [ + - ]: 1 : edgeLeft.private_enuEdgeCache = edgeLeftPrivate_enuEdgeCache;
481 [ + - ]: 1 : valueA.edgeLeft = edgeLeft;
482 [ + - ]: 2 : ::ad::map::lane::Lane valueB = mValue;
483 : :
484 [ + - - + : 1 : EXPECT_FALSE(valueA == valueB);
- - - - -
- - - ]
485 [ + - - + : 1 : EXPECT_TRUE(valueA != valueB);
- - - - -
- - - ]
486 : 1 : }
487 : :
488 : 2 : TEST_F(LaneTests, comparisonOperatorEdgeRightDiffers)
489 : : {
490 [ + - ]: 2 : ::ad::map::lane::Lane valueA = mValue;
491 : 2 : ::ad::map::point::Geometry edgeRight;
492 : 1 : bool edgeRightIsValid{false};
493 : 1 : edgeRight.isValid = edgeRightIsValid;
494 : 1 : bool edgeRightIsClosed{false};
495 : 1 : edgeRight.isClosed = edgeRightIsClosed;
496 : 2 : ::ad::map::point::ECEFEdge edgeRightEcefEdge;
497 : 1 : ::ad::map::point::ECEFPoint edgeRightEcefEdgeElement;
498 : 1 : ::ad::map::point::ECEFCoordinate edgeRightEcefEdgeElementX(6400000);
499 : 1 : edgeRightEcefEdgeElement.x = edgeRightEcefEdgeElementX;
500 : 1 : ::ad::map::point::ECEFCoordinate edgeRightEcefEdgeElementY(6400000);
501 : 1 : edgeRightEcefEdgeElement.y = edgeRightEcefEdgeElementY;
502 : 1 : ::ad::map::point::ECEFCoordinate edgeRightEcefEdgeElementZ(6400000);
503 : 1 : edgeRightEcefEdgeElement.z = edgeRightEcefEdgeElementZ;
504 [ + - ]: 1 : edgeRightEcefEdge.resize(2, edgeRightEcefEdgeElement);
505 [ + - ]: 1 : edgeRight.ecefEdge = edgeRightEcefEdge;
506 : 1 : ::ad::physics::Distance edgeRightLength(1e9);
507 : 1 : edgeRight.length = edgeRightLength;
508 : 2 : ::ad::map::point::ENUEdgeCache edgeRightPrivate_enuEdgeCache;
509 : 2 : ::ad::map::point::ENUEdge edgeRightPrivate_enuEdgeCacheEnuEdge;
510 : 1 : ::ad::map::point::ENUPoint edgeRightPrivate_enuEdgeCacheEnuEdgeElement;
511 : 1 : ::ad::map::point::ENUCoordinate edgeRightPrivate_enuEdgeCacheEnuEdgeElementX(16384);
512 : 1 : edgeRightPrivate_enuEdgeCacheEnuEdgeElement.x = edgeRightPrivate_enuEdgeCacheEnuEdgeElementX;
513 : 1 : ::ad::map::point::ENUCoordinate edgeRightPrivate_enuEdgeCacheEnuEdgeElementY(16384);
514 : 1 : edgeRightPrivate_enuEdgeCacheEnuEdgeElement.y = edgeRightPrivate_enuEdgeCacheEnuEdgeElementY;
515 : 1 : ::ad::map::point::ENUCoordinate edgeRightPrivate_enuEdgeCacheEnuEdgeElementZ(16384);
516 : 1 : edgeRightPrivate_enuEdgeCacheEnuEdgeElement.z = edgeRightPrivate_enuEdgeCacheEnuEdgeElementZ;
517 [ + - ]: 1 : edgeRightPrivate_enuEdgeCacheEnuEdge.resize(2, edgeRightPrivate_enuEdgeCacheEnuEdgeElement);
518 [ + - ]: 1 : edgeRightPrivate_enuEdgeCache.enuEdge = edgeRightPrivate_enuEdgeCacheEnuEdge;
519 : 1 : uint64_t edgeRightPrivate_enuEdgeCacheEnuVersion{std::numeric_limits<uint64_t>::max()};
520 : 1 : edgeRightPrivate_enuEdgeCache.enuVersion = edgeRightPrivate_enuEdgeCacheEnuVersion;
521 [ + - ]: 1 : edgeRight.private_enuEdgeCache = edgeRightPrivate_enuEdgeCache;
522 [ + - ]: 1 : valueA.edgeRight = edgeRight;
523 [ + - ]: 2 : ::ad::map::lane::Lane valueB = mValue;
524 : :
525 [ + - - + : 1 : EXPECT_FALSE(valueA == valueB);
- - - - -
- - - ]
526 [ + - - + : 1 : EXPECT_TRUE(valueA != valueB);
- - - - -
- - - ]
527 : 1 : }
528 : :
529 : 2 : TEST_F(LaneTests, comparisonOperatorContactLanesDiffers)
530 : : {
531 [ + - ]: 2 : ::ad::map::lane::Lane valueA = mValue;
532 : 2 : ::ad::map::lane::ContactLaneList contactLanes;
533 : 2 : ::ad::map::lane::ContactLane contactLanesElement;
534 : 1 : ::ad::map::lane::LaneId contactLanesElementToLane(std::numeric_limits<::ad::map::lane::LaneId>::max());
535 : 1 : contactLanesElement.toLane = contactLanesElementToLane;
536 : 1 : ::ad::map::lane::ContactLocation contactLanesElementLocation(::ad::map::lane::ContactLocation::OVERLAP);
537 : 1 : contactLanesElement.location = contactLanesElementLocation;
538 : 2 : ::ad::map::lane::ContactTypeList contactLanesElementTypes;
539 : 1 : ::ad::map::lane::ContactType contactLanesElementTypesElement(
540 : : ::ad::map::lane::ContactType::PRIO_TO_RIGHT_AND_STRAIGHT);
541 [ + - ]: 1 : contactLanesElementTypes.resize(2, contactLanesElementTypesElement);
542 [ + - ]: 1 : contactLanesElement.types = contactLanesElementTypes;
543 : 2 : ::ad::map::restriction::Restrictions contactLanesElementRestrictions;
544 : 2 : ::ad::map::restriction::RestrictionList contactLanesElementRestrictionsConjunctions;
545 : 2 : ::ad::map::restriction::Restriction contactLanesElementRestrictionsConjunctionsElement;
546 : 1 : bool contactLanesElementRestrictionsConjunctionsElementNegated{false};
547 : : contactLanesElementRestrictionsConjunctionsElement.negated
548 : 1 : = contactLanesElementRestrictionsConjunctionsElementNegated;
549 : 2 : ::ad::map::restriction::RoadUserTypeList contactLanesElementRestrictionsConjunctionsElementRoadUserTypes;
550 : 1 : ::ad::map::restriction::RoadUserType contactLanesElementRestrictionsConjunctionsElementRoadUserTypesElement(
551 : : ::ad::map::restriction::RoadUserType::CAR_DIESEL);
552 [ + - ]: 1 : contactLanesElementRestrictionsConjunctionsElementRoadUserTypes.resize(
553 : : 2, contactLanesElementRestrictionsConjunctionsElementRoadUserTypesElement);
554 : : contactLanesElementRestrictionsConjunctionsElement.roadUserTypes
555 [ + - ]: 1 : = contactLanesElementRestrictionsConjunctionsElementRoadUserTypes;
556 : 1 : ::ad::map::restriction::PassengerCount contactLanesElementRestrictionsConjunctionsElementPassengersMin(
557 : : std::numeric_limits<::ad::map::restriction::PassengerCount>::max());
558 : : contactLanesElementRestrictionsConjunctionsElement.passengersMin
559 : 1 : = contactLanesElementRestrictionsConjunctionsElementPassengersMin;
560 [ + - ]: 1 : contactLanesElementRestrictionsConjunctions.resize(2, contactLanesElementRestrictionsConjunctionsElement);
561 [ + - ]: 1 : contactLanesElementRestrictions.conjunctions = contactLanesElementRestrictionsConjunctions;
562 : 2 : ::ad::map::restriction::RestrictionList contactLanesElementRestrictionsDisjunctions;
563 : 2 : ::ad::map::restriction::Restriction contactLanesElementRestrictionsDisjunctionsElement;
564 : 1 : bool contactLanesElementRestrictionsDisjunctionsElementNegated{false};
565 : : contactLanesElementRestrictionsDisjunctionsElement.negated
566 : 1 : = contactLanesElementRestrictionsDisjunctionsElementNegated;
567 : 2 : ::ad::map::restriction::RoadUserTypeList contactLanesElementRestrictionsDisjunctionsElementRoadUserTypes;
568 : 1 : ::ad::map::restriction::RoadUserType contactLanesElementRestrictionsDisjunctionsElementRoadUserTypesElement(
569 : : ::ad::map::restriction::RoadUserType::CAR_DIESEL);
570 [ + - ]: 1 : contactLanesElementRestrictionsDisjunctionsElementRoadUserTypes.resize(
571 : : 2, contactLanesElementRestrictionsDisjunctionsElementRoadUserTypesElement);
572 : : contactLanesElementRestrictionsDisjunctionsElement.roadUserTypes
573 [ + - ]: 1 : = contactLanesElementRestrictionsDisjunctionsElementRoadUserTypes;
574 : 1 : ::ad::map::restriction::PassengerCount contactLanesElementRestrictionsDisjunctionsElementPassengersMin(
575 : : std::numeric_limits<::ad::map::restriction::PassengerCount>::max());
576 : : contactLanesElementRestrictionsDisjunctionsElement.passengersMin
577 : 1 : = contactLanesElementRestrictionsDisjunctionsElementPassengersMin;
578 [ + - ]: 1 : contactLanesElementRestrictionsDisjunctions.resize(2, contactLanesElementRestrictionsDisjunctionsElement);
579 [ + - ]: 1 : contactLanesElementRestrictions.disjunctions = contactLanesElementRestrictionsDisjunctions;
580 [ + - ]: 1 : contactLanesElement.restrictions = contactLanesElementRestrictions;
581 : : ::ad::map::landmark::LandmarkId contactLanesElementTrafficLightId(
582 : 1 : std::numeric_limits<::ad::map::landmark::LandmarkId>::max());
583 : 1 : contactLanesElement.trafficLightId = contactLanesElementTrafficLightId;
584 [ + - ]: 1 : contactLanes.resize(2, contactLanesElement);
585 [ + - ]: 1 : valueA.contactLanes = contactLanes;
586 [ + - ]: 2 : ::ad::map::lane::Lane valueB = mValue;
587 : :
588 [ + - - + : 1 : EXPECT_FALSE(valueA == valueB);
- - - - -
- - - ]
589 [ + - - + : 1 : EXPECT_TRUE(valueA != valueB);
- - - - -
- - - ]
590 : 1 : }
591 : :
592 : 2 : TEST_F(LaneTests, comparisonOperatorComplianceVersionDiffers)
593 : : {
594 [ + - ]: 2 : ::ad::map::lane::Lane valueA = mValue;
595 : 1 : ::ad::map::lane::ComplianceVersion complianceVersion(std::numeric_limits<::ad::map::lane::ComplianceVersion>::max());
596 : 1 : valueA.complianceVersion = complianceVersion;
597 [ + - ]: 2 : ::ad::map::lane::Lane valueB = mValue;
598 : :
599 [ + - - + : 1 : EXPECT_FALSE(valueA == valueB);
- - - - -
- - - ]
600 [ + - - + : 1 : EXPECT_TRUE(valueA != valueB);
- - - - -
- - - ]
601 : 1 : }
602 : :
603 : 2 : TEST_F(LaneTests, comparisonOperatorBoundingSphereDiffers)
604 : : {
605 [ + - ]: 2 : ::ad::map::lane::Lane valueA = mValue;
606 : 1 : ::ad::map::point::BoundingSphere boundingSphere;
607 : 1 : ::ad::map::point::ECEFPoint boundingSphereCenter;
608 : 1 : ::ad::map::point::ECEFCoordinate boundingSphereCenterX(6400000);
609 : 1 : boundingSphereCenter.x = boundingSphereCenterX;
610 : 1 : ::ad::map::point::ECEFCoordinate boundingSphereCenterY(6400000);
611 : 1 : boundingSphereCenter.y = boundingSphereCenterY;
612 : 1 : ::ad::map::point::ECEFCoordinate boundingSphereCenterZ(6400000);
613 : 1 : boundingSphereCenter.z = boundingSphereCenterZ;
614 : 1 : boundingSphere.center = boundingSphereCenter;
615 : 1 : ::ad::physics::Distance boundingSphereRadius(1e9);
616 : 1 : boundingSphere.radius = boundingSphereRadius;
617 : 1 : valueA.boundingSphere = boundingSphere;
618 [ + - ]: 2 : ::ad::map::lane::Lane valueB = mValue;
619 : :
620 [ + - - + : 1 : EXPECT_FALSE(valueA == valueB);
- - - - -
- - - ]
621 [ + - - + : 1 : EXPECT_TRUE(valueA != valueB);
- - - - -
- - - ]
622 : 1 : }
623 : :
624 : 2 : TEST_F(LaneTests, comparisonOperatorVisibleLandmarksDiffers)
625 : : {
626 [ + - ]: 2 : ::ad::map::lane::Lane valueA = mValue;
627 : 2 : ::ad::map::landmark::LandmarkIdList visibleLandmarks;
628 : 1 : ::ad::map::landmark::LandmarkId visibleLandmarksElement(std::numeric_limits<::ad::map::landmark::LandmarkId>::max());
629 [ + - ]: 1 : visibleLandmarks.resize(2, visibleLandmarksElement);
630 [ + - ]: 1 : valueA.visibleLandmarks = visibleLandmarks;
631 [ + - ]: 2 : ::ad::map::lane::Lane valueB = mValue;
632 : :
633 [ + - - + : 1 : EXPECT_FALSE(valueA == valueB);
- - - - -
- - - ]
634 [ + - - + : 1 : EXPECT_TRUE(valueA != valueB);
- - - - -
- - - ]
635 : 1 : }
636 : :
637 : : #if defined(__clang__) && (__clang_major__ >= 7)
638 : : #pragma GCC diagnostic pop
639 : : #endif
|
