ceph/src/seastar/tests/unit/abortable_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) 2022 ScyllaDB
  21  */
  22
  23 #include <seastar/core/thread.hh>
  24 #include <seastar/testing/test_case.hh>
  25 #include <seastar/testing/thread_test_case.hh>
  26 #include <seastar/core/abortable_fifo.hh>
  27 #include <seastar/util/later.hh>
  28 #include <boost/range/irange.hpp>
  29
  30 using namespace seastar;
  31
  32 SEASTAR_TEST_CASE(test_no_abortable_operations) {
  33     internal::abortable_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_THREAD_TEST_CASE(test_abortable_operations) {
  78     std::vector<int> expired;
  79     struct my_expiry {
  80         std::vector<int>& e;
  81         void operator()(int& v) noexcept { e.push_back(v); }
  82     };
  83
  84     internal::abortable_fifo<int, my_expiry> fifo(my_expiry{expired});
  85     abort_source as;
  86
  87     fifo.push_back(1, as);
  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     as.request_abort();
  95     yield().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     as = abort_source();
 105
 106     fifo.push_back(1);
 107     fifo.push_back(2, as);
 108     fifo.push_back(3);
 109
 110     as.request_abort();
 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     abort_source as1, as2;
 128
 129     fifo.push_back(1, as1);
 130     fifo.push_back(2, as1);
 131     fifo.push_back(3);
 132     fifo.push_back(4, as2);
 133
 134     as1.request_abort();
 135     yield().get();
 136
 137     BOOST_REQUIRE(!fifo.empty());
 138     BOOST_REQUIRE_EQUAL(fifo.size(), 2u);
 139     BOOST_REQUIRE(bool(fifo));
 140     BOOST_REQUIRE_EQUAL(expired.size(), 2u);
 141     std::sort(expired.begin(), expired.end());
 142     BOOST_REQUIRE_EQUAL(expired[0], 1);
 143     BOOST_REQUIRE_EQUAL(expired[1], 2);
 144     BOOST_REQUIRE_EQUAL(fifo.front(), 3);
 145     fifo.pop_front();
 146     BOOST_REQUIRE_EQUAL(fifo.size(), 1u);
 147     BOOST_REQUIRE_EQUAL(fifo.front(), 4);
 148     fifo.pop_front();
 149     BOOST_REQUIRE_EQUAL(fifo.size(), 0u);
 150
 151     expired.clear();
 152
 153     as = abort_source();
 154
 155     fifo.push_back(1);
 156     fifo.push_back(2, as);
 157     fifo.push_back(3, as);
 158     fifo.push_back(4, as);
 159
 160     as.request_abort();
 161     yield().get();
 162
 163     BOOST_REQUIRE(!fifo.empty());
 164     BOOST_REQUIRE_EQUAL(fifo.size(), 1u);
 165     BOOST_REQUIRE(bool(fifo));
 166     BOOST_REQUIRE_EQUAL(expired.size(), 3u);
 167     std::sort(expired.begin(), expired.end());
 168     BOOST_REQUIRE_EQUAL(expired[0], 2);
 169     BOOST_REQUIRE_EQUAL(expired[1], 3);
 170     BOOST_REQUIRE_EQUAL(expired[2], 4);
 171     BOOST_REQUIRE_EQUAL(fifo.front(), 1);
 172     fifo.pop_front();
 173     BOOST_REQUIRE_EQUAL(fifo.size(), 0u);
 174
 175     expired.clear();
 176     as = abort_source();
 177
 178     fifo.push_back(1);
 179     fifo.push_back(2, as);
 180     fifo.push_back(3, as);
 181     fifo.push_back(4, as);
 182     fifo.push_back(5);
 183
 184     as.request_abort();
 185     yield().get();
 186
 187     BOOST_REQUIRE_EQUAL(fifo.size(), 2u);
 188     BOOST_REQUIRE_EQUAL(fifo.front(), 1);
 189     fifo.pop_front();
 190     BOOST_REQUIRE_EQUAL(fifo.size(), 1u);
 191     BOOST_REQUIRE_EQUAL(fifo.front(), 5);
 192     fifo.pop_front();
 193     BOOST_REQUIRE_EQUAL(fifo.size(), 0u);
 194 }