Branch data     Line data    Source code

       1                 :            : // ----------------- BEGIN LICENSE BLOCK ---------------------------------
       2                 :            : //
       3                 :            : // Copyright (C) 2018-2021 Intel Corporation
       4                 :            : //
       5                 :            : // SPDX-License-Identifier: LGPL-2.1-only
       6                 :            : //
       7                 :            : // ----------------- END LICENSE BLOCK -----------------------------------
       8                 :            : 
       9                 :            : #include "RssCheckTestBaseT.hpp"
      10                 :            : 
      11                 :            : namespace ad {
      12                 :            : namespace rss {
      13                 :            : namespace core {
      14                 :            : 
      15                 :            : template <class TESTBASE> class RssCheckIntersectionTestBase : public TESTBASE
      16                 :            : {
      17                 :            : protected:
      18                 :            :   using TESTBASE::worldModel;
      19                 :        154 :   world::Object &getEgoObject() override
      20                 :            :   {
      21                 :        154 :     return TESTBASE::objectOnSegment0;
      22                 :            :   }
      23                 :            : 
      24                 :        154 :   world::Object &getSceneObject(uint32_t) override
      25                 :            :   {
      26                 :        154 :     return TESTBASE::objectOnSegment8;
      27                 :            :   }
      28                 :            : 
      29                 :            :   virtual bool isBrakeExpected(uint32_t i) = 0;
      30                 :            : 
      31                 :          4 :   void performIntersectionTest()
      32                 :            :   {
      33                 :          4 :     state::ProperResponse properResponse;
      34         [ +  - ]:          4 :     core::RssCheck rssCheck;
      35         [ +  + ]:         12 :     for (auto egoVehicleSegmentId : {world::LaneSegmentId(0), world::LaneSegmentId(3)})
      36                 :            :     {
      37         [ +  + ]:         16 :       for (auto &scene : worldModel.scenes)
      38                 :            :       {
      39                 :          8 :         scene.egoVehicle.occupiedRegions[0].segmentId = egoVehicleSegmentId;
      40                 :            :       }
      41         [ +  + ]:        736 :       for (uint32_t i = 0; i <= 90; i++)
      42                 :            :       {
      43         [ +  + ]:       1456 :         for (auto &scene : worldModel.scenes)
      44                 :            :         {
      45                 :        728 :           scene.egoVehicle.occupiedRegions[0].lonRange.minimum = ParametricValue(0.01 * i);
      46                 :        728 :           scene.egoVehicle.occupiedRegions[0].lonRange.maximum = ParametricValue(0.01 * i + 0.1);
      47                 :            :         }
      48                 :        728 :         worldModel.timeIndex++;
      49                 :            : 
      50   [ +  -  -  +  :        728 :         ASSERT_TRUE(rssCheck.calculateProperResponse(worldModel, properResponse));
          -  -  -  -  -  
                -  -  - ]
      51                 :            : 
      52                 :            : #if RSS_CHECK_TEST_DEBUG_OUT
      53                 :            :         std::cout << "Testing: segment[" << egoVehicleSegmentId << "] range min=" << i
      54                 :            :                   << " brake?=" << isBrakeExpected(i) << std::endl;
      55                 :            : #endif
      56   [ +  -  +  + ]:        728 :         if (isBrakeExpected(i))
      57                 :            :         {
      58         [ +  - ]:        180 :           TESTBASE::testRestrictions(properResponse.accelerationRestrictions, state::LongitudinalResponse::BrakeMin);
      59                 :            :         }
      60                 :            :         else
      61                 :            :         {
      62         [ +  - ]:        548 :           TESTBASE::testRestrictions(properResponse.accelerationRestrictions);
      63                 :            :         }
      64                 :            :       }
      65                 :            :     }
      66                 :            :   }
      67                 :            : };
      68                 :            : 
      69                 :            : template <class TESTBASE>
      70                 :            : class RssCheckIntersectionEgoHasPriorityTestBase : public RssCheckIntersectionTestBase<TESTBASE>
      71                 :            : {
      72                 :            : protected:
      73                 :        104 :   situation::SituationType getSituationType() override
      74                 :            :   {
      75                 :        104 :     return situation::SituationType::IntersectionEgoHasPriority;
      76                 :            :   }
      77                 :            : 
      78                 :        364 :   bool isBrakeExpected(uint32_t i) override
      79                 :            :   {
      80                 :        364 :     bool const egoVehicleFaraway
      81   [ +  +  +  + ]:        364 :       = (i < 11) || (TESTBASE::worldModel.scenes[0].egoVehicle.occupiedRegions[0].segmentId == world::LaneSegmentId(0));
      82                 :        364 :     bool const egoVehicleInFront
      83   [ +  +  +  + ]:        364 :       = (i > 64) && (TESTBASE::worldModel.scenes[0].egoVehicle.occupiedRegions[0].segmentId == world::LaneSegmentId(3));
      84                 :            : 
      85   [ +  +  +  + ]:        364 :     return !egoVehicleFaraway && !egoVehicleInFront;
      86                 :            :   }
      87                 :            : };
      88                 :            : 
      89                 :            : using RssCheckIntersectionEgoHasPriorityTest = RssCheckIntersectionEgoHasPriorityTestBase<RssCheckTestBase>;
      90                 :            : 
      91                 :            : using RssCheckIntersectionEgoHasPriorityOutOfMemoryTest
      92                 :            :   = RssCheckIntersectionEgoHasPriorityTestBase<RssCheckOutOfMemoryTestBase>;
      93   [ +  -  +  -  :        101 : TEST_P(RssCheckIntersectionEgoHasPriorityOutOfMemoryTest, outOfMemoryAnyTime)
          +  -  +  -  +  
                      - ]
      94                 :            : {
      95         [ +  - ]:         50 :   performOutOfMemoryTest();
      96                 :         50 : }
      97   [ -  +  -  -  :         51 : INSTANTIATE_TEST_CASE_P(Range,
                   -  - ]
      98                 :            :                         RssCheckIntersectionEgoHasPriorityOutOfMemoryTest,
      99                 :            :                         ::testing::Range(uint64_t(0u), uint64_t(50u), 1u));
     100                 :            : 
     101                 :          2 : TEST_F(RssCheckIntersectionEgoHasPriorityTest, IntersectionTest)
     102                 :            : {
     103                 :          1 :   performIntersectionTest();
     104                 :          1 : }
     105                 :            : 
     106                 :          2 : TEST_F(RssCheckIntersectionEgoHasPriorityTest, IntersectionDescriptionIsExtended)
     107                 :            : {
     108                 :          1 :   worldModel.scenes[0].egoVehicleRoad.push_back(worldModel.scenes[0].egoVehicleRoad.front());
     109                 :          1 :   performIntersectionTest();
     110                 :          1 : }
     111                 :            : 
     112                 :            : template <class TESTBASE>
     113                 :            : class RssCheckIntersectionObjectHasPriorityTestBase : public RssCheckIntersectionTestBase<TESTBASE>
     114                 :            : {
     115                 :            : protected:
     116                 :        153 :   situation::SituationType getSituationType() override
     117                 :            :   {
     118                 :        153 :     return situation::SituationType::IntersectionObjectHasPriority;
     119                 :            :   }
     120                 :            : 
     121                 :        182 :   bool isBrakeExpected(uint32_t i) override
     122                 :            :   {
     123                 :        182 :     bool const egoVehicleNearEnough
     124   [ +  +  +  + ]:        182 :       = (TESTBASE::worldModel.scenes[0].egoVehicle.occupiedRegions[0].segmentId == world::LaneSegmentId(3)) && (i > 54);
     125                 :            : 
     126                 :        182 :     return egoVehicleNearEnough;
     127                 :            :   }
     128                 :            : };
     129                 :            : 
     130                 :            : using RssCheckIntersectionObjectHasPriorityTest = RssCheckIntersectionObjectHasPriorityTestBase<RssCheckTestBase>;
     131                 :            : 
     132                 :            : using RssCheckIntersectionObjectHasPriorityOutOfMemoryTest
     133                 :            :   = RssCheckIntersectionObjectHasPriorityTestBase<RssCheckOutOfMemoryTestBase>;
     134   [ +  -  +  -  :        101 : TEST_P(RssCheckIntersectionObjectHasPriorityOutOfMemoryTest, outOfMemoryAnyTime)
          +  -  +  -  +  
                      - ]
     135                 :            : {
     136         [ +  - ]:         50 :   performOutOfMemoryTest();
     137                 :         50 : }
     138   [ -  +  -  -  :         51 : INSTANTIATE_TEST_CASE_P(Range,
                   -  - ]
     139                 :            :                         RssCheckIntersectionObjectHasPriorityOutOfMemoryTest,
     140                 :            :                         ::testing::Range(uint64_t(0u), uint64_t(50u), 1u));
     141                 :            : 
     142                 :          2 : TEST_F(RssCheckIntersectionObjectHasPriorityTest, IntersectionTest)
     143                 :            : {
     144                 :          1 :   performIntersectionTest();
     145                 :          1 : }
     146                 :            : 
     147                 :            : template <class TESTBASE> class RssCheckIntersectionSamePriorityTestBase : public RssCheckIntersectionTestBase<TESTBASE>
     148                 :            : {
     149                 :            : protected:
     150                 :        204 :   situation::SituationType getSituationType() override
     151                 :            :   {
     152                 :        204 :     return situation::SituationType::IntersectionSamePriority;
     153                 :            :   }
     154                 :            : 
     155                 :        182 :   bool isBrakeExpected(uint32_t i) override
     156                 :            :   {
     157                 :        182 :     return (TESTBASE::worldModel.scenes[0].egoVehicle.occupiedRegions[0].segmentId == world::LaneSegmentId(3))
     158   [ +  +  +  + ]:        182 :       && (i > 54);
     159                 :            :   }
     160                 :            : };
     161                 :            : 
     162                 :            : using RssCheckIntersectionSamePriorityTest = RssCheckIntersectionSamePriorityTestBase<RssCheckTestBase>;
     163                 :            : 
     164                 :            : using RssCheckIntersectionSamePriorityOutOfMemoryTest
     165                 :            :   = RssCheckIntersectionSamePriorityTestBase<RssCheckOutOfMemoryTestBase>;
     166   [ +  -  +  -  :        101 : TEST_P(RssCheckIntersectionSamePriorityOutOfMemoryTest, outOfMemoryAnyTime)
          +  -  +  -  +  
                      - ]
     167                 :            : {
     168         [ +  - ]:         50 :   performOutOfMemoryTest();
     169                 :         50 : }
     170   [ -  +  -  -  :         51 : INSTANTIATE_TEST_CASE_P(Range,
                   -  - ]
     171                 :            :                         RssCheckIntersectionSamePriorityOutOfMemoryTest,
     172                 :            :                         ::testing::Range(uint64_t(0u), uint64_t(50u), 1u));
     173                 :            : 
     174                 :          2 : TEST_F(RssCheckIntersectionSamePriorityTest, IntersectionTest)
     175                 :            : {
     176                 :          1 :   performIntersectionTest();
     177                 :          1 : }
     178                 :            : 
     179                 :            : } // namespace core
     180                 :            : } // namespace rss
     181                 :            : } // namespace ad