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/core/manual_clock.hh>
  25 #include <seastar/testing/test_case.hh>
  26 #include <seastar/core/expiring_fifo.hh>
  27 #include <seastar/util/later.hh>
  28 #include <boost/range/irange.hpp>
  29
  30 using namespace seastar;
  31 using namespace std::chrono_literals;
  32
  33 SEASTAR_TEST_CASE(test_no_expiry_operations) {
  34     expiring_fifo<int> fifo;
  35
  36     BOOST_REQUIRE(fifo.empty());
  37     BOOST_REQUIRE_EQUAL(fifo.size(), 0u);
  38     BOOST_REQUIRE(!bool(fifo));
  39
  40     fifo.push_back(1);
  41
  42     BOOST_REQUIRE(!fifo.empty());
  43     BOOST_REQUIRE_EQUAL(fifo.size(), 1u);
  44     BOOST_REQUIRE(bool(fifo));
  45     BOOST_REQUIRE_EQUAL(fifo.front(), 1);
  46
  47     fifo.push_back(2);
  48     fifo.push_back(3);
  49
  50     BOOST_REQUIRE(!fifo.empty());
  51     BOOST_REQUIRE_EQUAL(fifo.size(), 3u);
  52     BOOST_REQUIRE(bool(fifo));
  53     BOOST_REQUIRE_EQUAL(fifo.front(), 1);
  54
  55     fifo.pop_front();
  56
  57     BOOST_REQUIRE(!fifo.empty());
  58     BOOST_REQUIRE_EQUAL(fifo.size(), 2u);
  59     BOOST_REQUIRE(bool(fifo));
  60     BOOST_REQUIRE_EQUAL(fifo.front(), 2);
  61
  62     fifo.pop_front();
  63
  64     BOOST_REQUIRE(!fifo.empty());
  65     BOOST_REQUIRE_EQUAL(fifo.size(), 1u);
  66     BOOST_REQUIRE(bool(fifo));
  67     BOOST_REQUIRE_EQUAL(fifo.front(), 3);
  68
  69     fifo.pop_front();
  70
  71     BOOST_REQUIRE(fifo.empty());
  72     BOOST_REQUIRE_EQUAL(fifo.size(), 0u);
  73     BOOST_REQUIRE(!bool(fifo));
  74
  75     return make_ready_future<>();
  76 }
  77
  78 SEASTAR_TEST_CASE(test_expiry_operations) {
  79     return seastar::async([] {
  80         std::vector<int> expired;
  81         struct my_expiry {
  82             std::vector<int>& e;
  83             void operator()(int& v) { e.push_back(v); }
  84         };
  85
  86         expiring_fifo<int, my_expiry, manual_clock> fifo(my_expiry{expired});
  87
  88         fifo.push_back(1, manual_clock::now() + 1s);
  89
  90         BOOST_REQUIRE(!fifo.empty());
  91         BOOST_REQUIRE_EQUAL(fifo.size(), 1u);
  92         BOOST_REQUIRE(bool(fifo));
  93         BOOST_REQUIRE_EQUAL(fifo.front(), 1);
  94
  95         manual_clock::advance(1s);
  96         yield().get();
  97
  98         BOOST_REQUIRE(fifo.empty());
  99         BOOST_REQUIRE_EQUAL(fifo.size(), 0u);
 100         BOOST_REQUIRE(!bool(fifo));
 101         BOOST_REQUIRE_EQUAL(expired.size(), 1u);
 102         BOOST_REQUIRE_EQUAL(expired[0], 1);
 103
 104         expired.clear();
 105
 106         fifo.push_back(1);
 107         fifo.push_back(2, manual_clock::now() + 1s);
 108         fifo.push_back(3);
 109
 110         manual_clock::advance(1s);
 111         yield().get();
 112
 113         BOOST_REQUIRE(!fifo.empty());
 114         BOOST_REQUIRE_EQUAL(fifo.size(), 2u);
 115         BOOST_REQUIRE(bool(fifo));
 116         BOOST_REQUIRE_EQUAL(expired.size(), 1u);
 117         BOOST_REQUIRE_EQUAL(expired[0], 2);
 118         BOOST_REQUIRE_EQUAL(fifo.front(), 1);
 119         fifo.pop_front();
 120         BOOST_REQUIRE_EQUAL(fifo.size(), 1u);
 121         BOOST_REQUIRE_EQUAL(fifo.front(), 3);
 122         fifo.pop_front();
 123         BOOST_REQUIRE_EQUAL(fifo.size(), 0u);
 124
 125         expired.clear();
 126
 127         fifo.push_back(1, manual_clock::now() + 1s);
 128         fifo.push_back(2, manual_clock::now() + 1s);
 129         fifo.push_back(3);
 130         fifo.push_back(4, manual_clock::now() + 2s);
 131
 132         manual_clock::advance(1s);
 133         yield().get();
 134
 135         BOOST_REQUIRE(!fifo.empty());
 136         BOOST_REQUIRE_EQUAL(fifo.size(), 2u);
 137         BOOST_REQUIRE(bool(fifo));
 138         BOOST_REQUIRE_EQUAL(expired.size(), 2u);
 139         std::sort(expired.begin(), expired.end());
 140         BOOST_REQUIRE_EQUAL(expired[0], 1);
 141         BOOST_REQUIRE_EQUAL(expired[1], 2);
 142         BOOST_REQUIRE_EQUAL(fifo.front(), 3);
 143         fifo.pop_front();
 144         BOOST_REQUIRE_EQUAL(fifo.size(), 1u);
 145         BOOST_REQUIRE_EQUAL(fifo.front(), 4);
 146         fifo.pop_front();
 147         BOOST_REQUIRE_EQUAL(fifo.size(), 0u);
 148
 149         expired.clear();
 150
 151         fifo.push_back(1);
 152         fifo.push_back(2, manual_clock::now() + 1s);
 153         fifo.push_back(3, manual_clock::now() + 1s);
 154         fifo.push_back(4, manual_clock::now() + 1s);
 155
 156         manual_clock::advance(1s);
 157         yield().get();
 158
 159         BOOST_REQUIRE(!fifo.empty());
 160         BOOST_REQUIRE_EQUAL(fifo.size(), 1u);
 161         BOOST_REQUIRE(bool(fifo));
 162         BOOST_REQUIRE_EQUAL(expired.size(), 3u);
 163         std::sort(expired.begin(), expired.end());
 164         BOOST_REQUIRE_EQUAL(expired[0], 2);
 165         BOOST_REQUIRE_EQUAL(expired[1], 3);
 166         BOOST_REQUIRE_EQUAL(expired[2], 4);
 167         BOOST_REQUIRE_EQUAL(fifo.front(), 1);
 168         fifo.pop_front();
 169         BOOST_REQUIRE_EQUAL(fifo.size(), 0u);
 170
 171         expired.clear();
 172
 173         fifo.push_back(1);
 174         fifo.push_back(2, manual_clock::now() + 1s);
 175         fifo.push_back(3, manual_clock::now() + 1s);
 176         fifo.push_back(4, manual_clock::now() + 1s);
 177         fifo.push_back(5);
 178
 179         manual_clock::advance(1s);
 180         yield().get();
 181
 182         BOOST_REQUIRE_EQUAL(fifo.size(), 2u);
 183         BOOST_REQUIRE_EQUAL(fifo.front(), 1);
 184         fifo.pop_front();
 185         BOOST_REQUIRE_EQUAL(fifo.size(), 1u);
 186         BOOST_REQUIRE_EQUAL(fifo.front(), 5);
 187         fifo.pop_front();
 188         BOOST_REQUIRE_EQUAL(fifo.size(), 0u);
 189     });
 190 }