ceph/src/boost/libs/yap/test/reference_returns.cpp

   1 // Copyright (C) 2016-2018 T. Zachary Laine
   2 //
   3 // Distributed under the Boost Software License, Version 1.0. (See
   4 // accompanying file LICENSE_1_0.txt or copy at
   5 // http://www.boost.org/LICENSE_1_0.txt)
   6 #include <boost/yap/expression.hpp>
   7
   8 #include <boost/mpl/assert.hpp>
   9
  10 #include <boost/test/minimal.hpp>
  11
  12
  13 template<typename T>
  14 using term = boost::yap::terminal<boost::yap::expression, T>;
  15
  16 namespace yap = boost::yap;
  17
  18 namespace reference_returning {
  19
  20     struct number
  21     {
  22         double value;
  23     };
  24
  25     number a_result{3.0};
  26     number const the_result{13.0};
  27
  28     number const & operator+(number a, number b) { return the_result; }
  29
  30     number & operator-(number a, number b) { return a_result; }
  31 }
  32
  33 int test_main(int, char * [])
  34 {
  35     {
  36         term<reference_returning::number> unity = {{1.0}};
  37         auto plus_expr = unity + reference_returning::number{1.0};
  38
  39         {
  40             reference_returning::number const & n = evaluate(plus_expr);
  41             BOOST_CHECK(&n == &reference_returning::the_result);
  42         }
  43
  44         using plus_eval_type = decltype(evaluate(plus_expr));
  45         BOOST_MPL_ASSERT((std::is_same<
  46                           plus_eval_type,
  47                           reference_returning::number const &>));
  48
  49         auto minus_expr = unity - reference_returning::number{1.0};
  50
  51         {
  52             reference_returning::number & n = evaluate(minus_expr);
  53             BOOST_CHECK(&n == &reference_returning::a_result);
  54         }
  55
  56         using minus_eval_type = decltype(evaluate(minus_expr));
  57         BOOST_MPL_ASSERT((std::is_same<
  58                           minus_eval_type,
  59                           reference_returning::number &>));
  60
  61         using namespace yap::literals;
  62
  63         {
  64             reference_returning::number & n =
  65                 evaluate(1_p, reference_returning::a_result);
  66             BOOST_CHECK(&n == &reference_returning::a_result);
  67         }
  68
  69         using a_eval_type = decltype(evaluate(1_p, reference_returning::a_result));
  70         BOOST_MPL_ASSERT(
  71             (std::is_same<
  72                 a_eval_type,
  73                 reference_returning::number &>));
  74
  75         {
  76             reference_returning::number const & n =
  77                 evaluate(1_p, reference_returning::the_result);
  78             BOOST_CHECK(&n == &reference_returning::the_result);
  79         }
  80
  81         using the_eval_type = decltype(evaluate(1_p, reference_returning::the_result));
  82         BOOST_MPL_ASSERT(
  83             (std::is_same<
  84                 the_eval_type,
  85                 reference_returning::number const &>));
  86     }
  87
  88     return 0;
  89 }