ceph/src/boost/libs/histogram/test/detail_accumulator_traits_test.cpp

   1 // Copyright 2019 Hans Dembinski
   2 //
   3 // Distributed under the Boost Software License, Version 1.0.
   4 // (See accompanying file LICENSE_1_0.txt
   5 // or copy at http://www.boost.org/LICENSE_1_0.txt)
   6
   7 #include <boost/core/lightweight_test.hpp>
   8 #include <boost/core/lightweight_test_trait.hpp>
   9 #include <boost/histogram/detail/accumulator_traits.hpp>
  10 #include <boost/histogram/weight.hpp>
  11 #include <tuple>
  12
  13 namespace dtl = boost::histogram::detail;
  14
  15 int main() {
  16   using boost::histogram::weight_type;
  17
  18   BOOST_TEST(dtl::accumulator_traits<int>::weight_support);
  19   BOOST_TEST_TRAIT_SAME(dtl::accumulator_traits<int>::args, std::tuple<>);
  20
  21   BOOST_TEST(dtl::accumulator_traits<float>::weight_support);
  22   BOOST_TEST_TRAIT_SAME(dtl::accumulator_traits<float>::args, std::tuple<>);
  23
  24   struct A1 {
  25     void operator()();
  26   };
  27
  28   BOOST_TEST_NOT(dtl::accumulator_traits<A1>::weight_support);
  29   BOOST_TEST_TRAIT_SAME(typename dtl::accumulator_traits<A1>::args, std::tuple<>);
  30
  31   struct A2 {
  32     void operator()(int, double);
  33   };
  34
  35   BOOST_TEST_NOT(dtl::accumulator_traits<A2>::weight_support);
  36   BOOST_TEST_TRAIT_SAME(typename dtl::accumulator_traits<A2>::args,
  37                         std::tuple<int, double>);
  38
  39   struct A3 {
  40     void operator()();
  41     void operator()(weight_type<int>);
  42   };
  43
  44   BOOST_TEST(dtl::accumulator_traits<A3>::weight_support);
  45   BOOST_TEST_TRAIT_SAME(typename dtl::accumulator_traits<A3>::args, std::tuple<>);
  46
  47   struct A4 {
  48     void operator()(int, double, char);
  49     void operator()(weight_type<int>, int, double, char);
  50   };
  51
  52   BOOST_TEST(dtl::accumulator_traits<A4>::weight_support);
  53   BOOST_TEST_TRAIT_SAME(typename dtl::accumulator_traits<A4>::args,
  54                         std::tuple<int, double, char>);
  55
  56   struct A5 {
  57     void operator()(const weight_type<int>, int);
  58   };
  59
  60   BOOST_TEST(dtl::accumulator_traits<A5>::weight_support);
  61   BOOST_TEST_TRAIT_SAME(typename dtl::accumulator_traits<A5>::args, std::tuple<int>);
  62
  63   struct A6 {
  64     void operator()(const weight_type<int>&, const int);
  65   };
  66
  67   BOOST_TEST(dtl::accumulator_traits<A6>::weight_support);
  68   BOOST_TEST_TRAIT_SAME(typename dtl::accumulator_traits<A6>::args, std::tuple<int>);
  69
  70   struct A7 {
  71     void operator()(weight_type<int>&&, int&&);
  72   };
  73
  74   BOOST_TEST(dtl::accumulator_traits<A7>::weight_support);
  75   BOOST_TEST_TRAIT_SAME(typename dtl::accumulator_traits<A7>::args, std::tuple<int&&>);
  76
  77   struct B1 {
  78     int operator+=(int);
  79   };
  80
  81   BOOST_TEST(dtl::accumulator_traits<B1>::weight_support);
  82   BOOST_TEST_TRAIT_SAME(typename dtl::accumulator_traits<B1>::args, std::tuple<>);
  83
  84   struct B2 {
  85     int operator+=(weight_type<int>);
  86   };
  87
  88   BOOST_TEST(dtl::accumulator_traits<B2>::weight_support);
  89   BOOST_TEST_TRAIT_SAME(typename dtl::accumulator_traits<B2>::args, std::tuple<>);
  90
  91   struct B3 {
  92     int operator+=(const weight_type<double>&);
  93   };
  94
  95   BOOST_TEST(dtl::accumulator_traits<B3>::weight_support);
  96   BOOST_TEST_TRAIT_SAME(typename dtl::accumulator_traits<B3>::args, std::tuple<>);
  97
  98   // potentially ambiguous case that mimicks accumulators::weighted_sum
  99   struct B4 {
 100     B4(int) {}
 101     int operator+=(const weight_type<double>&);
 102     int operator+=(const B4&); // *this += 0 succeeds as *this += B4(0)
 103   };
 104
 105   BOOST_TEST(dtl::accumulator_traits<B4>::weight_support);
 106   BOOST_TEST_TRAIT_SAME(typename dtl::accumulator_traits<B4>::args, std::tuple<>);
 107
 108   return boost::report_errors();
 109 }