LCOV - code coverage report
Current view: top level - UTests - testArrayView.cpp (source / functions) Hit Total Coverage
Test: Coverage example Lines: 100 100 100.0 %
Date: 2021-12-02 17:21:05 Functions: 4 4 100.0 %

          Line data    Source code
       1             : #include "Utils/small_vector.hpp"
       2             : #include "Utils/SpArrayView.hpp"
       3             : 
       4             : #include "UTester.hpp"
       5             : 
       6             : class TestArrayView : public UTester< TestArrayView > {
       7             :     using Parent = UTester< TestArrayView >;
       8             : 
       9          23 :     void CompareWithArray(const SpArrayView& view,
      10             :                           small_vector_base<long int> &shouldBe,
      11             :                           const int lineOffset){
      12         125 :         for(long int idx : view){
      13         102 :             UASSERTETRUE_OFFSET(idx < static_cast<long int>(shouldBe.size()), lineOffset);
      14         102 :             UASSERTEEQUAL_OFFSET(shouldBe[idx], 1L, lineOffset);
      15         102 :             shouldBe[idx] -= 1;
      16             :         }
      17             : 
      18         301 :         for(const long int& res : shouldBe){
      19         278 :             UASSERTEEQUAL_OFFSET(res, 0L, lineOffset);
      20             :         }
      21          23 :     }
      22             : 
      23           1 :     void TestBasic(){
      24             :         {
      25           2 :             SpArrayView view(10);
      26             : 
      27             :             {
      28             :                 small_vector<long int> shouldBe{1, 1, 1, 1, 1,
      29           2 :                                                1, 1, 1, 1, 1};
      30           1 :                 CompareWithArray(view, shouldBe, __LINE__);
      31             :             }
      32             : 
      33           1 :             view.removeItem(5);
      34             :             {
      35             :                 small_vector<long int> shouldBe{1, 1, 1, 1, 1,
      36           2 :                                                0, 1, 1, 1, 1};
      37           1 :                 CompareWithArray(view, shouldBe, __LINE__);
      38             :             }
      39             : 
      40           1 :             view.removeItem(7);
      41             :             {
      42             :                 small_vector<long int> shouldBe{1, 1, 1, 1, 1,
      43           2 :                                                0, 1, 0, 1, 1};
      44           1 :                 CompareWithArray(view, shouldBe, __LINE__);
      45             :             }
      46             : 
      47           1 :             view.removeItem(5);
      48           1 :             view.removeItem(7);
      49           1 :             view.removeItem(10);
      50             :             {
      51             :                 small_vector<long int> shouldBe{1, 1, 1, 1, 1,
      52           2 :                                                0, 1, 0, 1, 1};
      53           1 :                 CompareWithArray(view, shouldBe, __LINE__);
      54             :             }
      55             :         }
      56             : 
      57             :         {
      58           5 :             for(int idxRemove = 0 ; idxRemove < 4 ; ++idxRemove){
      59           8 :                 SpArrayView view(4);
      60           4 :                 view.removeItem(idxRemove);
      61           8 :                 small_vector<long int> shouldBe{1, 1, 1, 1};
      62           4 :                 shouldBe[idxRemove] = 0;
      63           4 :                 CompareWithArray(view, shouldBe, __LINE__);
      64             :             }
      65             :         }
      66             : 
      67             :         {
      68           2 :             SpArrayView view(0,10,3);
      69             : 
      70             :             {
      71             :                 small_vector<long int> shouldBe{1, 0, 0,
      72             :                                                1, 0, 0,
      73             :                                                1, 0, 0,
      74           2 :                                                1};
      75           1 :                 CompareWithArray(view, shouldBe, __LINE__);
      76             :             }
      77             : 
      78           1 :             view.removeItem(5);
      79             :             {
      80             :                 small_vector<long int> shouldBe{1, 0, 0,
      81             :                                                1, 0, 0,
      82             :                                                1, 0, 0,
      83           2 :                                                1};
      84           1 :                 CompareWithArray(view, shouldBe, __LINE__);
      85             :             }
      86             : 
      87           1 :             view.removeItem(3);
      88             :             {
      89             :                 small_vector<long int> shouldBe{1, 0, 0,
      90             :                                                0, 0, 0,
      91             :                                                1, 0, 0,
      92           2 :                                                1};
      93           1 :                 CompareWithArray(view, shouldBe, __LINE__);
      94             :             }
      95             : 
      96           1 :             view.removeItem(5);
      97           1 :             view.removeItem(7);
      98           1 :             view.removeItem(10);
      99             :             {
     100             :                 small_vector<long int> shouldBe{1, 0, 0,
     101             :                                                0, 0, 0,
     102             :                                                1, 0, 0,
     103           2 :                                                1};
     104           1 :                 CompareWithArray(view, shouldBe, __LINE__);
     105             :             }
     106             : 
     107           1 :             view.removeItems(6,9);
     108             :             {
     109           2 :                 small_vector<long int> shouldBe{1};
     110           1 :                 CompareWithArray(view, shouldBe, __LINE__);
     111             :             }
     112             :         }
     113             : 
     114             :         {
     115           2 :             SpArrayView view(0,10,3);
     116             : 
     117             :             {
     118             :                 small_vector<long int> shouldBe{1, 0, 0,
     119             :                                   1, 0, 0,
     120             :                                   1, 0, 0,
     121           2 :                                   1};
     122           1 :                 CompareWithArray(view, shouldBe, __LINE__);
     123             :             }
     124             : 
     125           1 :             view.addItem(12);
     126           1 :             UASSERTETRUE(view.getNbIntervals() == 1);
     127             :             {
     128             :                 small_vector<long int> shouldBe{1, 0, 0,
     129             :                                   1, 0, 0,
     130             :                                   1, 0, 0,
     131             :                                   1, 0, 0,
     132           2 :                                   1};
     133           1 :                 CompareWithArray(view, shouldBe, __LINE__);
     134             :             }
     135             : 
     136             : 
     137           1 :             view.addItem(16);
     138           1 :             UASSERTETRUE(view.getNbIntervals() == 2);
     139             :             {
     140             :                 small_vector<long int> shouldBe{1, 0, 0,
     141             :                                   1, 0, 0,
     142             :                                   1, 0, 0,
     143             :                                   1, 0, 0,
     144             :                                   1, 0, 0,
     145           2 :                                   0, 1};
     146           1 :                 CompareWithArray(view, shouldBe, __LINE__);
     147             :             }
     148             : 
     149           1 :             view.addItem(17);
     150           1 :             UASSERTETRUE(view.getNbIntervals() == 2);
     151             :             {
     152             :                 small_vector<long int> shouldBe{1, 0, 0,
     153             :                                   1, 0, 0,
     154             :                                   1, 0, 0,
     155             :                                   1, 0, 0,
     156             :                                   1, 0, 0,
     157           2 :                                   0, 1, 1};
     158           1 :                 CompareWithArray(view, shouldBe, __LINE__);
     159             :             }
     160             : 
     161           1 :             view.addItem(2);
     162           1 :             UASSERTETRUE(view.getNbIntervals() == 3);
     163             :             {
     164             :                 small_vector<long int> shouldBe{1, 0, 1,
     165             :                                   1, 0, 0,
     166             :                                   1, 0, 0,
     167             :                                   1, 0, 0,
     168             :                                   1, 0, 0,
     169           2 :                                   0, 1, 1};
     170           1 :                 CompareWithArray(view, shouldBe, __LINE__);
     171             :             }
     172             :         }
     173             :         
     174             :         {
     175           2 :             SpArrayView view(5, 21, 5);
     176             :             
     177           1 :             UASSERTETRUE(view.getNbIntervals() == 1);
     178             :             {
     179           2 :                 small_vector<long int> shouldBe(21, 0);
     180           1 :                 shouldBe[20] = 1;
     181           1 :                 shouldBe[15] = 1;
     182           1 :                 shouldBe[10] = 1;
     183           1 :                 shouldBe[5] = 1;
     184           1 :                 CompareWithArray(view, shouldBe, __LINE__);
     185             :             }
     186             :             
     187           1 :             view.removeItem(20);
     188             :             
     189           1 :             UASSERTETRUE(view.getNbIntervals() == 1);
     190             :             {
     191           2 :                 small_vector<long int> shouldBe(21, 0);
     192           1 :                 shouldBe[15] = 1;
     193           1 :                 shouldBe[10] = 1;
     194           1 :                 shouldBe[5] = 1;
     195           1 :                 CompareWithArray(view, shouldBe, __LINE__);
     196             :             }
     197             :             
     198           1 :             view.removeItem(15);
     199             :             
     200           1 :             UASSERTETRUE(view.getNbIntervals() == 1);
     201             :             {
     202           2 :                 small_vector<long int> shouldBe(21, 0);
     203           1 :                 shouldBe[10] = 1;
     204           1 :                 shouldBe[5] = 1;
     205           1 :                 CompareWithArray(view, shouldBe, __LINE__);
     206             :             }
     207             :             
     208           1 :             view.removeItem(10);
     209             :             
     210           1 :             UASSERTETRUE(view.getNbIntervals() == 1);
     211             :             {
     212           2 :                 small_vector<long int> shouldBe(21, 0);
     213           1 :                 shouldBe[5] = 1;
     214           1 :                 CompareWithArray(view, shouldBe, __LINE__);
     215             :             }
     216             :             
     217           1 :             view.removeItem(5);
     218             :             
     219           1 :             UASSERTETRUE(view.getNbIntervals() == 0);
     220             :             {
     221           2 :                 small_vector<long int> shouldBe(21, 0);
     222           1 :                 CompareWithArray(view, shouldBe, __LINE__);
     223             :             }
     224             :         }
     225           1 :     }
     226             : 
     227           1 :     void SetTests() {
     228           1 :         Parent::AddTest(&TestArrayView::TestBasic, "Basic test for array view");
     229           1 :     }
     230             : };
     231             : 
     232             : // You must do this
     233           1 : TestClass(TestArrayView)
     234             : 

Generated by: LCOV version 1.14