ceph/src/boost/libs/beast/subtree/unit_test/include/boost/beast/unit_test/results.hpp

   1 //
   2 // Copyright (c) 2016-2017 Vinnie Falco (vinnie dot falco at gmail dot com)
   3 //
   4 // Distributed under the Boost Software License, Version 1.0. (See accompanying
   5 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   6 //
   7 // Official repository: https://github.com/boostorg/beast
   8 //
   9
  10 #ifndef BOOST_BEAST_UNIT_TEST_RESULTS_HPP
  11 #define BOOST_BEAST_UNIT_TEST_RESULTS_HPP
  12
  13 #include <boost/beast/unit_test/detail/const_container.hpp>
  14
  15 #include <string>
  16 #include <vector>
  17
  18 namespace boost {
  19 namespace beast {
  20 namespace unit_test {
  21
  22 /** Holds a set of test condition outcomes in a testcase. */
  23 class case_results
  24 {
  25 public:
  26     /** Holds the result of evaluating one test condition. */
  27     struct test
  28     {
  29         explicit test(bool pass_)
  30             : pass(pass_)
  31         {
  32         }
  33
  34         test(bool pass_, std::string const& reason_)
  35             : pass(pass_)
  36             , reason(reason_)
  37         {
  38         }
  39
  40         bool pass;
  41         std::string reason;
  42     };
  43
  44 private:
  45     class tests_t
  46         : public detail::const_container <std::vector <test>>
  47     {
  48     private:
  49         std::size_t failed_;
  50
  51     public:
  52         tests_t()
  53             : failed_(0)
  54         {
  55         }
  56
  57         /** Returns the total number of test conditions. */
  58         std::size_t
  59         total() const
  60         {
  61             return cont().size();
  62         }
  63
  64         /** Returns the number of failed test conditions. */
  65         std::size_t
  66         failed() const
  67         {
  68             return failed_;
  69         }
  70
  71         /** Register a successful test condition. */
  72         void
  73         pass()
  74         {
  75             cont().emplace_back(true);
  76         }
  77
  78         /** Register a failed test condition. */
  79         void
  80         fail(std::string const& reason = "")
  81         {
  82             ++failed_;
  83             cont().emplace_back(false, reason);
  84         }
  85     };
  86
  87     class log_t
  88         : public detail::const_container <std::vector <std::string>>
  89     {
  90     public:
  91         /** Insert a string into the log. */
  92         void
  93         insert(std::string const& s)
  94         {
  95             cont().push_back(s);
  96         }
  97     };
  98
  99     std::string name_;
 100
 101 public:
 102     explicit case_results(std::string const& name = "")
 103         : name_(name)
 104     {
 105     }
 106
 107     /** Returns the name of this testcase. */
 108     std::string const&
 109     name() const
 110     {
 111         return name_;
 112     }
 113
 114     /** Memberspace for a container of test condition outcomes. */
 115     tests_t tests;
 116
 117     /** Memberspace for a container of testcase log messages. */
 118     log_t log;
 119 };
 120
 121 //--------------------------------------------------------------------------
 122
 123 /** Holds the set of testcase results in a suite. */
 124 class suite_results
 125     : public detail::const_container <std::vector <case_results>>
 126 {
 127 private:
 128     std::string name_;
 129     std::size_t total_ = 0;
 130     std::size_t failed_ = 0;
 131
 132 public:
 133     explicit suite_results(std::string const& name = "")
 134         : name_(name)
 135     {
 136     }
 137
 138     /** Returns the name of this suite. */
 139     std::string const&
 140     name() const
 141     {
 142         return name_;
 143     }
 144
 145     /** Returns the total number of test conditions. */
 146     std::size_t
 147     total() const
 148     {
 149         return total_;
 150     }
 151
 152     /** Returns the number of failures. */
 153     std::size_t
 154     failed() const
 155     {
 156         return failed_;
 157     }
 158
 159     /** Insert a set of testcase results. */
 160     /** @{ */
 161     void
 162     insert(case_results&& r)
 163     {
 164         cont().emplace_back(std::move(r));
 165         total_ += r.tests.total();
 166         failed_ += r.tests.failed();
 167     }
 168
 169     void
 170     insert(case_results const& r)
 171     {
 172         cont().push_back(r);
 173         total_ += r.tests.total();
 174         failed_ += r.tests.failed();
 175     }
 176     /** @} */
 177 };
 178
 179 //------------------------------------------------------------------------------
 180
 181 // VFALCO TODO Make this a template class using scoped allocators
 182 /** Holds the results of running a set of testsuites. */
 183 class results
 184     : public detail::const_container <std::vector <suite_results>>
 185 {
 186 private:
 187     std::size_t m_cases;
 188     std::size_t total_;
 189     std::size_t failed_;
 190
 191 public:
 192     results()
 193         : m_cases(0)
 194         , total_(0)
 195         , failed_(0)
 196     {
 197     }
 198
 199     /** Returns the total number of test cases. */
 200     std::size_t
 201     cases() const
 202     {
 203         return m_cases;
 204     }
 205
 206     /** Returns the total number of test conditions. */
 207     std::size_t
 208     total() const
 209     {
 210         return total_;
 211     }
 212
 213     /** Returns the number of failures. */
 214     std::size_t
 215     failed() const
 216     {
 217         return failed_;
 218     }
 219
 220     /** Insert a set of suite results. */
 221     /** @{ */
 222     void
 223     insert(suite_results&& r)
 224     {
 225         m_cases += r.size();
 226         total_ += r.total();
 227         failed_ += r.failed();
 228         cont().emplace_back(std::move(r));
 229     }
 230
 231     void
 232     insert(suite_results const& r)
 233     {
 234         m_cases += r.size();
 235         total_ += r.total();
 236         failed_ += r.failed();
 237         cont().push_back(r);
 238     }
 239     /** @} */
 240 };
 241
 242 } // unit_test
 243 } // beast
 244 } // boost
 245
 246 #endif