ceph/src/boost/libs/leaf/test/error_id_test.cpp

   1 // Copyright (c) 2018-2020 Emil Dotchevski and Reverge Studios, Inc.
   2
   3 // Distributed under the Boost Software License, Version 1.0. (See accompanying
   4 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   5
   6 #include <boost/leaf/error.hpp>
   7 #include "lightweight_test.hpp"
   8 #include <future>
   9 #include <vector>
  10 #include <algorithm>
  11 #include <iterator>
  12
  13 namespace leaf = boost::leaf;
  14
  15 constexpr int ids_per_thread = 10000;
  16
  17 std::vector<int> generate_ids()
  18 {
  19     std::vector<int> ids;
  20     ids.reserve(ids_per_thread);
  21     for(int i=0; i!=ids_per_thread-1; ++i)
  22     {
  23         int id = leaf::leaf_detail::new_id();
  24         BOOST_TEST_NE(id&1, 0);
  25         int last = leaf::leaf_detail::current_id();
  26         BOOST_TEST_EQ(last, leaf::leaf_detail::current_id());
  27         BOOST_TEST_NE(last&1, 0);
  28         BOOST_TEST_EQ(last, id);
  29         ids.push_back(id);
  30     }
  31     return ids;
  32 }
  33
  34 int main()
  35 {
  36     {
  37         leaf::error_id e1;
  38         leaf::error_id e2;
  39         BOOST_TEST(!e1);
  40         BOOST_TEST_EQ(e1.value(), 0);
  41         BOOST_TEST(!e2);
  42         BOOST_TEST_EQ(e2.value(), 0);
  43         BOOST_TEST(e1==e2);
  44         BOOST_TEST(!(e1!=e2));
  45         BOOST_TEST(!(e1<e2));
  46         BOOST_TEST(!(e2<e1));
  47     }
  48     {
  49         leaf::error_id e1;
  50         leaf::error_id e2 = leaf::new_error();
  51         BOOST_TEST(!e1);
  52         BOOST_TEST_EQ(e1.value(), 0);
  53         BOOST_TEST(e2);
  54         BOOST_TEST_EQ(e2.value(), 1);
  55         BOOST_TEST(!(e1==e2));
  56         BOOST_TEST(e1!=e2);
  57         BOOST_TEST(e1<e2);
  58         BOOST_TEST(!(e2<e1));
  59     }
  60     {
  61         leaf::error_id e1 = leaf::new_error();
  62         leaf::error_id e2 = leaf::new_error();
  63         BOOST_TEST(e1);
  64         BOOST_TEST_EQ(e1.value(), 5);
  65         BOOST_TEST(e2);
  66         BOOST_TEST_EQ(e2.value(), 9);
  67         BOOST_TEST(!(e1==e2));
  68         BOOST_TEST(e1!=e2);
  69         BOOST_TEST(e1<e2);
  70         BOOST_TEST(!(e2<e1));
  71     }
  72     {
  73         leaf::error_id e1 = leaf::new_error();
  74         leaf::error_id e2 = e1;
  75         BOOST_TEST(e1);
  76         BOOST_TEST_EQ(e1.value(), 13);
  77         BOOST_TEST(e2);
  78         BOOST_TEST_EQ(e2.value(), 13);
  79         BOOST_TEST(e1==e2);
  80         BOOST_TEST(!(e1!=e2));
  81         BOOST_TEST(!(e1<e2));
  82         BOOST_TEST(!(e2<e1));
  83     }
  84     {
  85         leaf::error_id e1 = leaf::new_error();
  86         leaf::error_id e2; e2 = e1;
  87         BOOST_TEST(e1);
  88         BOOST_TEST_EQ(e1.value(), 17);
  89         BOOST_TEST(e2);
  90         BOOST_TEST_EQ(e2.value(), 17);
  91         BOOST_TEST(e1==e2);
  92         BOOST_TEST(!(e1!=e2));
  93         BOOST_TEST(!(e1<e2));
  94         BOOST_TEST(!(e2<e1));
  95     }
  96 #ifdef BOOST_LEAF_NO_THREADS
  97     std::vector<int> all_ids = generate_ids();
  98 #else
  99     constexpr int thread_count = 100;
 100     using thread_ids = std::future<std::vector<int>>;
 101     std::vector<thread_ids> fut;
 102     fut.reserve(thread_count);
 103     std::generate_n(
 104         std::back_inserter(fut),
 105         thread_count,
 106         [=]
 107         {
 108             return std::async(std::launch::async, &generate_ids);
 109         });
 110     std::vector<int> all_ids;
 111     for(auto & f : fut)
 112     {
 113         auto fv = f.get();
 114         all_ids.insert(all_ids.end(), fv.begin(), fv.end());
 115     }
 116 #endif
 117     std::sort(all_ids.begin(), all_ids.end());
 118     auto u = std::unique(all_ids.begin(), all_ids.end());
 119     BOOST_TEST(u==all_ids.end());
 120
 121     return boost::report_errors();
 122 }