Line data    Source code

       1             : // Copyright (c) 2012-2019 The Bitcoin Core developers
       2             : // Distributed under the MIT software license, see the accompanying
       3             : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
       4             : 
       5             : #include <limitedmap.h>
       6             : 
       7             : #include <test/util/setup_common.h>
       8             : 
       9             : #include <boost/test/unit_test.hpp>
      10             : 
      11          89 : BOOST_FIXTURE_TEST_SUITE(limitedmap_tests, BasicTestingSetup)
      12             : 
      13          95 : BOOST_AUTO_TEST_CASE(limitedmap_test)
      14             : {
      15             :     // create a limitedmap capped at 10 items
      16           1 :     limitedmap<int, int> map(10);
      17             : 
      18             :     // check that the max size is 10
      19           1 :     BOOST_CHECK(map.max_size() == 10);
      20             : 
      21             :     // check that it's empty
      22           1 :     BOOST_CHECK(map.size() == 0);
      23             : 
      24             :     // insert (-1, -1)
      25           1 :     map.insert(std::pair<int, int>(-1, -1));
      26             : 
      27             :     // make sure that the size is updated
      28           1 :     BOOST_CHECK(map.size() == 1);
      29             : 
      30             :     // make sure that the new item is in the map
      31           1 :     BOOST_CHECK(map.count(-1) == 1);
      32             : 
      33             :     // insert 10 new items
      34          11 :     for (int i = 0; i < 10; i++) {
      35          10 :         map.insert(std::pair<int, int>(i, i + 1));
      36             :     }
      37             : 
      38             :     // make sure that the map now contains 10 items...
      39           1 :     BOOST_CHECK(map.size() == 10);
      40             : 
      41             :     // ...and that the first item has been discarded
      42           1 :     BOOST_CHECK(map.count(-1) == 0);
      43             : 
      44             :     // iterate over the map, both with an index and an iterator
      45           1 :     limitedmap<int, int>::const_iterator it = map.begin();
      46          11 :     for (int i = 0; i < 10; i++) {
      47             :         // make sure the item is present
      48          10 :         BOOST_CHECK(map.count(i) == 1);
      49             : 
      50             :         // use the iterator to check for the expected key and value
      51          10 :         BOOST_CHECK(it->first == i);
      52          10 :         BOOST_CHECK(it->second == i + 1);
      53             : 
      54             :         // use find to check for the value
      55          10 :         BOOST_CHECK(map.find(i)->second == i + 1);
      56             : 
      57             :         // update and recheck
      58          10 :         map.update(it, i + 2);
      59          10 :         BOOST_CHECK(map.find(i)->second == i + 2);
      60             : 
      61          10 :         it++;
      62             :     }
      63             : 
      64             :     // check that we've exhausted the iterator
      65           1 :     BOOST_CHECK(it == map.end());
      66             : 
      67             :     // resize the map to 5 items
      68           1 :     map.max_size(5);
      69             : 
      70             :     // check that the max size and size are now 5
      71           1 :     BOOST_CHECK(map.max_size() == 5);
      72           1 :     BOOST_CHECK(map.size() == 5);
      73             : 
      74             :     // check that items less than 5 have been discarded
      75             :     // and items greater than 5 are retained
      76          11 :     for (int i = 0; i < 10; i++) {
      77          10 :         if (i < 5) {
      78           5 :             BOOST_CHECK(map.count(i) == 0);
      79             :         } else {
      80           5 :             BOOST_CHECK(map.count(i) == 1);
      81             :         }
      82             :     }
      83             : 
      84             :     // erase some items not in the map
      85          10 :     for (int i = 100; i < 1000; i += 100) {
      86           9 :         map.erase(i);
      87             :     }
      88             : 
      89             :     // check that the size is unaffected
      90           1 :     BOOST_CHECK(map.size() == 5);
      91             : 
      92             :     // erase the remaining elements
      93           6 :     for (int i = 5; i < 10; i++) {
      94           5 :         map.erase(i);
      95             :     }
      96             : 
      97             :     // check that the map is now empty
      98           1 :     BOOST_CHECK(map.empty());
      99           1 : }
     100             : 
     101          89 : BOOST_AUTO_TEST_SUITE_END()