ceph/src/seastar/tests/unit/expiring_fifo_test.cc

   1 /*
   2  * This file is open source software, licensed to you under the terms
   3  * of the Apache License, Version 2.0 (the "License").  See the NOTICE file
   4  * distributed with this work for additional information regarding copyright
   5  * ownership.  You may not use this file except in compliance with the License.
   6  *
   7  * You may obtain a copy of the License at
   8  *
   9  *   http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing,
  12  * software distributed under the License is distributed on an
  13  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  14  * KIND, either express or implied.  See the License for the
  15  * specific language governing permissions and limitations
  16  * under the License.
  17  */
  18
  19 /*
  20  * Copyright (C) 2016 ScyllaDB
  21  */
  22
  23 #include <seastar/core/thread.hh>
  24 #include <seastar/testing/test_case.hh>
  25 #include <seastar/core/future-util.hh>
  26 #include <seastar/core/expiring_fifo.hh>
  27 #include <boost/range/irange.hpp>
  28
  29 using namespace seastar;
  30 using namespace std::chrono_literals;
  31
  32 SEASTAR_TEST_CASE(test_no_expiry_operations) {
  33     expiring_fifo<int> fifo;
  34
  35     BOOST_REQUIRE(fifo.empty());
  36     BOOST_REQUIRE_EQUAL(fifo.size(), 0u);
  37     BOOST_REQUIRE(!bool(fifo));
  38
  39     fifo.push_back(1);
  40
  41     BOOST_REQUIRE(!fifo.empty());
  42     BOOST_REQUIRE_EQUAL(fifo.size(), 1u);
  43     BOOST_REQUIRE(bool(fifo));
  44     BOOST_REQUIRE_EQUAL(fifo.front(), 1);
  45
  46     fifo.push_back(2);
  47     fifo.push_back(3);
  48
  49     BOOST_REQUIRE(!fifo.empty());
  50     BOOST_REQUIRE_EQUAL(fifo.size(), 3u);
  51     BOOST_REQUIRE(bool(fifo));
  52     BOOST_REQUIRE_EQUAL(fifo.front(), 1);
  53
  54     fifo.pop_front();
  55
  56     BOOST_REQUIRE(!fifo.empty());
  57     BOOST_REQUIRE_EQUAL(fifo.size(), 2u);
  58     BOOST_REQUIRE(bool(fifo));
  59     BOOST_REQUIRE_EQUAL(fifo.front(), 2);
  60
  61     fifo.pop_front();
  62
  63     BOOST_REQUIRE(!fifo.empty());
  64     BOOST_REQUIRE_EQUAL(fifo.size(), 1u);
  65     BOOST_REQUIRE(bool(fifo));
  66     BOOST_REQUIRE_EQUAL(fifo.front(), 3);
  67
  68     fifo.pop_front();
  69
  70     BOOST_REQUIRE(fifo.empty());
  71     BOOST_REQUIRE_EQUAL(fifo.size(), 0u);
  72     BOOST_REQUIRE(!bool(fifo));
  73
  74     return make_ready_future<>();
  75 }
  76
  77 SEASTAR_TEST_CASE(test_expiry_operations) {
  78     return seastar::async([] {
  79         std::vector<int> expired;
  80         struct my_expiry {
  81             std::vector<int>& e;
  82             void operator()(int& v) { e.push_back(v); }
  83         };
  84
  85         expiring_fifo<int, my_expiry, manual_clock> fifo(my_expiry{expired});
  86
  87         fifo.push_back(1, manual_clock::now() + 1s);
  88
  89         BOOST_REQUIRE(!fifo.empty());
  90         BOOST_REQUIRE_EQUAL(fifo.size(), 1u);
  91         BOOST_REQUIRE(bool(fifo));
  92         BOOST_REQUIRE_EQUAL(fifo.front(), 1);
  93
  94         manual_clock::advance(1s);
  95         later().get();
  96
  97         BOOST_REQUIRE(fifo.empty());
  98         BOOST_REQUIRE_EQUAL(fifo.size(), 0u);
  99         BOOST_REQUIRE(!bool(fifo));
 100         BOOST_REQUIRE_EQUAL(expired.size(), 1u);
 101         BOOST_REQUIRE_EQUAL(expired[0], 1);
 102
 103         expired.clear();
 104
 105         fifo.push_back(1);
 106         fifo.push_back(2, manual_clock::now() + 1s);
 107         fifo.push_back(3);
 108
 109         manual_clock::advance(1s);
 110         later().get();
 111
 112         BOOST_REQUIRE(!fifo.empty());
 113         BOOST_REQUIRE_EQUAL(fifo.size(), 2u);
 114         BOOST_REQUIRE(bool(fifo));
 115         BOOST_REQUIRE_EQUAL(expired.size(), 1u);
 116         BOOST_REQUIRE_EQUAL(expired[0], 2);
 117         BOOST_REQUIRE_EQUAL(fifo.front(), 1);
 118         fifo.pop_front();
 119         BOOST_REQUIRE_EQUAL(fifo.size(), 1u);
 120         BOOST_REQUIRE_EQUAL(fifo.front(), 3);
 121         fifo.pop_front();
 122         BOOST_REQUIRE_EQUAL(fifo.size(), 0u);
 123
 124         expired.clear();
 125
 126         fifo.push_back(1, manual_clock::now() + 1s);
 127         fifo.push_back(2, manual_clock::now() + 1s);
 128         fifo.push_back(3);
 129         fifo.push_back(4, manual_clock::now() + 2s);
 130
 131         manual_clock::advance(1s);
 132         later().get();
 133
 134         BOOST_REQUIRE(!fifo.empty());
 135         BOOST_REQUIRE_EQUAL(fifo.size(), 2u);
 136         BOOST_REQUIRE(bool(fifo));
 137         BOOST_REQUIRE_EQUAL(expired.size(), 2u);
 138         std::sort(expired.begin(), expired.end());
 139         BOOST_REQUIRE_EQUAL(expired[0], 1);
 140         BOOST_REQUIRE_EQUAL(expired[1], 2);
 141         BOOST_REQUIRE_EQUAL(fifo.front(), 3);
 142         fifo.pop_front();
 143         BOOST_REQUIRE_EQUAL(fifo.size(), 1u);
 144         BOOST_REQUIRE_EQUAL(fifo.front(), 4);
 145         fifo.pop_front();
 146         BOOST_REQUIRE_EQUAL(fifo.size(), 0u);
 147
 148         expired.clear();
 149
 150         fifo.push_back(1);
 151         fifo.push_back(2, manual_clock::now() + 1s);
 152         fifo.push_back(3, manual_clock::now() + 1s);
 153         fifo.push_back(4, manual_clock::now() + 1s);
 154
 155         manual_clock::advance(1s);
 156         later().get();
 157
 158         BOOST_REQUIRE(!fifo.empty());
 159         BOOST_REQUIRE_EQUAL(fifo.size(), 1u);
 160         BOOST_REQUIRE(bool(fifo));
 161         BOOST_REQUIRE_EQUAL(expired.size(), 3u);
 162         std::sort(expired.begin(), expired.end());
 163         BOOST_REQUIRE_EQUAL(expired[0], 2);
 164         BOOST_REQUIRE_EQUAL(expired[1], 3);
 165         BOOST_REQUIRE_EQUAL(expired[2], 4);
 166         BOOST_REQUIRE_EQUAL(fifo.front(), 1);
 167         fifo.pop_front();
 168         BOOST_REQUIRE_EQUAL(fifo.size(), 0u);
 169
 170         expired.clear();
 171
 172         fifo.push_back(1);
 173         fifo.push_back(2, manual_clock::now() + 1s);
 174         fifo.push_back(3, manual_clock::now() + 1s);
 175         fifo.push_back(4, manual_clock::now() + 1s);
 176         fifo.push_back(5);
 177
 178         manual_clock::advance(1s);
 179         later().get();
 180
 181         BOOST_REQUIRE_EQUAL(fifo.size(), 2u);
 182         BOOST_REQUIRE_EQUAL(fifo.front(), 1);
 183         fifo.pop_front();
 184         BOOST_REQUIRE_EQUAL(fifo.size(), 1u);
 185         BOOST_REQUIRE_EQUAL(fifo.front(), 5);
 186         fifo.pop_front();
 187         BOOST_REQUIRE_EQUAL(fifo.size(), 0u);
 188     });
 189 }