add subtree-ish sources for 12.0.3

[ceph.git] / ceph / src / boost / libs / variant / test / test8.cpp

//-----------------------------------------------------------------------------
// boost-libs variant/test/test8.cpp header file
// See http://www.boost.org for updates, documentation, and revision history.
//-----------------------------------------------------------------------------
//
// Copyright (c) 2003
// Eric Friedman, Itay Maman
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)

#include "boost/test/minimal.hpp"
#include "boost/variant.hpp"

#include <iostream>
#include <vector>
#include <string>

using namespace std;
using namespace boost;

typedef variant<float, std::string, int, std::vector<std::string> > t_var1;

struct int_sum : static_visitor<>
{
   int_sum() : result_(0) { }

   void operator()(int t) 
   {
      result_ += t;
   }

   result_type operator()(float ) { }
   result_type operator()(const std::string& ) { }
   result_type operator()(const std::vector<std::string>& ) { }

   int result_;
}; 

template <typename T, typename Variant>
T& check_pass(Variant& v, T value)
{
    BOOST_CHECK(get<T>(&v));

    try
    {
        T& r = get<T>(v);
        BOOST_CHECK(r == value);
        return r;
    }
    catch(boost::bad_get&)
    {
        throw; // must never reach
    }
}

template <typename T, typename Variant>
void check_fail(Variant& v)
{
    BOOST_CHECK(!relaxed_get<T>(&v));

    try
    {
        T& r = relaxed_get<T>(v);
        (void)r; // suppress warning about r not being used
        BOOST_CHECK(false && relaxed_get<T>(&v)); // should never reach
    }
    catch(const boost::bad_get& e)
    {
        BOOST_CHECK(!!e.what()); // make sure that what() is const qualified and returnes something
    }
}

int test_main(int , char* [])
{
   int_sum acc;
   t_var1 v1 = 800;

   // check get on non-const variant
   {
      int& r1 = check_pass<int>(v1, 800);
      const int& cr1 = check_pass<const int>(v1, 800);

      check_fail<float>(v1);
      check_fail<const float>(v1);
      check_fail<short>(v1);
      check_fail<const short>(v1);

      apply_visitor(acc, v1);
      BOOST_CHECK(acc.result_ == 800);

      r1 = 920; // NOTE: modifies content of v1
      apply_visitor(acc, v1);
      BOOST_CHECK(cr1 == 920);
      BOOST_CHECK(acc.result_ == 800 + 920);
   }

   // check const correctness:
   {
      const t_var1& c = v1;

      check_pass<const int>(c, 920);

      //check_fail<int>(c);
      check_fail<const float>(c);
      //check_fail<float>(c);
      check_fail<const short>(c);
      //check_fail<short>(c);
   }

   return boost::exit_success;
}