[ceph.git] / ceph / src / boost / libs / function / test / contains_test.cpp

// Boost.Function library

//  Copyright Douglas Gregor 2004. Use, modification and
//  distribution is subject to 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/function.hpp>
#include <boost/ref.hpp>

static int forty_two() { return 42; }

struct Seventeen
{
  int operator()() const { return 17; }
};

struct ReturnInt
{
  explicit ReturnInt(int value) : value(value) {}

  int operator()() const { return value; }

  int value;
};

bool operator==(const ReturnInt& x, const ReturnInt& y)
{ return x.value == y.value; }

bool operator!=(const ReturnInt& x, const ReturnInt& y)
{ return x.value != y.value; }

namespace contain_test {

struct ReturnIntFE
{
  explicit ReturnIntFE(int value) : value(value) {}

  int operator()() const { return value; }

  int value;
};

}

#ifndef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP

namespace contain_test {
# ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
bool function_equal(const ReturnIntFE& x, const ReturnIntFE& y)
{ return x.value == y.value; }
# else
bool function_equal_impl(const ReturnIntFE& x, const ReturnIntFE& y, int)
{ return x.value == y.value; }
# endif // #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
}
#else // BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
namespace boost {
# ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
bool 
function_equal(const contain_test::ReturnIntFE& x, 
               const contain_test::ReturnIntFE& y)
{ return x.value == y.value; }
# else
bool 
function_equal_impl(const contain_test::ReturnIntFE& x, 
                    const contain_test::ReturnIntFE& y, int)
{ return x.value == y.value; }
# endif
}
#endif

static void target_test()
{
  boost::function0<int> f;

  f = &forty_two;
  BOOST_CHECK(*f.target<int (*)()>() == &forty_two);
  BOOST_CHECK(!f.target<Seventeen>());

  f = Seventeen();
  BOOST_CHECK(!f.target<int (*)()>());
  BOOST_CHECK(f.target<Seventeen>());

  Seventeen this_seventeen;
  f = boost::ref(this_seventeen);
  BOOST_CHECK(!f.target<int (*)()>());
  BOOST_CHECK(f.target<Seventeen>());
  BOOST_CHECK(f.target<Seventeen>() == &this_seventeen);

  const Seventeen const_seventeen = this_seventeen;
  f = boost::ref(const_seventeen);
  BOOST_CHECK(!f.target<int (*)()>());
  BOOST_CHECK(f.target<const Seventeen>());
  BOOST_CHECK(f.target<const Seventeen>() == &const_seventeen);
  BOOST_CHECK(f.target<const volatile Seventeen>());
  BOOST_CHECK(!f.target<Seventeen>());
  BOOST_CHECK(!f.target<volatile Seventeen>());
}

static void equal_test()
{
  boost::function0<int> f;

  f = &forty_two;
  BOOST_CHECK(f == &forty_two);
  BOOST_CHECK(f != ReturnInt(17));
#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
  BOOST_CHECK(&forty_two == f);
  BOOST_CHECK(ReturnInt(17) != f);
#endif

  BOOST_CHECK(f.contains(&forty_two));

  f = ReturnInt(17);
  BOOST_CHECK(f != &forty_two);
  BOOST_CHECK(f == ReturnInt(17));
  BOOST_CHECK(f != ReturnInt(16));
#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
  BOOST_CHECK(&forty_two != f);
  BOOST_CHECK(ReturnInt(17) == f);
  BOOST_CHECK(ReturnInt(16) != f);
#endif

  BOOST_CHECK(f.contains(ReturnInt(17)));

  f = contain_test::ReturnIntFE(17);
  BOOST_CHECK(f != &forty_two);
  BOOST_CHECK(f == contain_test::ReturnIntFE(17));
  BOOST_CHECK(f != contain_test::ReturnIntFE(16));
#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
  BOOST_CHECK(&forty_two != f);
  BOOST_CHECK(contain_test::ReturnIntFE(17) == f);
  BOOST_CHECK(contain_test::ReturnIntFE(16) != f);
#endif

  BOOST_CHECK(f.contains(contain_test::ReturnIntFE(17)));

#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
  boost::function<int(void)> g;

  g = &forty_two;
  BOOST_CHECK(g == &forty_two);
  BOOST_CHECK(g != ReturnInt(17));
#  if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
  BOOST_CHECK(&forty_two == g);
  BOOST_CHECK(ReturnInt(17) != g);
#  endif

  g = ReturnInt(17);
  BOOST_CHECK(g != &forty_two);
  BOOST_CHECK(g == ReturnInt(17));
  BOOST_CHECK(g != ReturnInt(16));
#  if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
  BOOST_CHECK(&forty_two != g);
  BOOST_CHECK(ReturnInt(17) == g);
  BOOST_CHECK(ReturnInt(16) != g);
#  endif
#endif
}

static void ref_equal_test()
{
  {
    ReturnInt ri(17);
    boost::function0<int> f = boost::ref(ri);

    // References and values are equal
    BOOST_CHECK(f == boost::ref(ri));
    BOOST_CHECK(f == ri);
    BOOST_CHECK(boost::ref(ri) == f);
    BOOST_CHECK(!(f != boost::ref(ri)));
    BOOST_CHECK(!(f != ri));
    BOOST_CHECK(!(boost::ref(ri) != f));
#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
    BOOST_CHECK(ri == f);
    BOOST_CHECK(!(ri != f));
#endif

    // Values equal, references inequal
    ReturnInt ri2(17);
    BOOST_CHECK(f == ri2);
    BOOST_CHECK(f != boost::ref(ri2));
    BOOST_CHECK(boost::ref(ri2) != f);
    BOOST_CHECK(!(f != ri2));
    BOOST_CHECK(!(f == boost::ref(ri2)));
    BOOST_CHECK(!(boost::ref(ri2) == f));
#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
    BOOST_CHECK(ri2 == f);
    BOOST_CHECK(!(ri2 != f));
#endif 
  }

#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
  {
    ReturnInt ri(17);
    boost::function<int(void)> f = boost::ref(ri);

    // References and values are equal
    BOOST_CHECK(f == boost::ref(ri));
    BOOST_CHECK(f == ri);
    BOOST_CHECK(boost::ref(ri) == f);
    BOOST_CHECK(!(f != boost::ref(ri)));
    BOOST_CHECK(!(f != ri));
    BOOST_CHECK(!(boost::ref(ri) != f));
#  if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
    BOOST_CHECK(ri == f);
    BOOST_CHECK(!(ri != f));
#  endif

    // Values equal, references inequal
    ReturnInt ri2(17);
    BOOST_CHECK(f == ri2);
    BOOST_CHECK(f != boost::ref(ri2));
    BOOST_CHECK(boost::ref(ri2) != f);
    BOOST_CHECK(!(f != ri2));
    BOOST_CHECK(!(f == boost::ref(ri2)));
    BOOST_CHECK(!(boost::ref(ri2) == f));
#  if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
    BOOST_CHECK(ri2 == f);
    BOOST_CHECK(!(ri2 != f));
#  endif
  }
#endif
}

int test_main(int, char*[])
{
  target_test();
  equal_test();
  ref_equal_test();

  return 0;
}
Commit	Line	Data
7c673cae FG	1	// Boost.Function library
	2
	3	// Copyright Douglas Gregor 2004. Use, modification and
	4	// distribution is subject to the Boost Software License, Version
	5	// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
	6	// http://www.boost.org/LICENSE_1_0.txt)
	7
	8	#include <boost/test/minimal.hpp>
	9	#include <boost/function.hpp>
	10	#include <boost/ref.hpp>
	11
	12	static int forty_two() { return 42; }
	13
	14	struct Seventeen
	15	{
	16	int operator()() const { return 17; }
	17	};
	18
	19	struct ReturnInt
	20	{
	21	explicit ReturnInt(int value) : value(value) {}
	22
	23	int operator()() const { return value; }
	24
	25	int value;
	26	};
	27
	28	bool operator==(const ReturnInt& x, const ReturnInt& y)
	29	{ return x.value == y.value; }
	30
	31	bool operator!=(const ReturnInt& x, const ReturnInt& y)
	32	{ return x.value != y.value; }
	33
	34	namespace contain_test {
	35
	36	struct ReturnIntFE
	37	{
	38	explicit ReturnIntFE(int value) : value(value) {}
	39
	40	int operator()() const { return value; }
	41
	42	int value;
	43	};
	44
	45	}
	46
	47	#ifndef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
	48
	49	namespace contain_test {
	50	# ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
	51	bool function_equal(const ReturnIntFE& x, const ReturnIntFE& y)
	52	{ return x.value == y.value; }
	53	# else
	54	bool function_equal_impl(const ReturnIntFE& x, const ReturnIntFE& y, int)
	55	{ return x.value == y.value; }
	56	# endif // #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
	57	}
	58	#else // BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
	59	namespace boost {
	60	# ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
	61	bool
	62	function_equal(const contain_test::ReturnIntFE& x,
	63	const contain_test::ReturnIntFE& y)
	64	{ return x.value == y.value; }
65	# else
66	bool
67	function_equal_impl(const contain_test::ReturnIntFE& x,
68	const contain_test::ReturnIntFE& y, int)
69	{ return x.value == y.value; }
70	# endif
71	}
72	#endif
73
74	static void target_test()
75	{
76	boost::function0<int> f;
77
78	f = &forty_two;
79	BOOST_CHECK(f.target<int ()()>() == &forty_two);
80	BOOST_CHECK(!f.target<Seventeen>());
81
82	f = Seventeen();
83	BOOST_CHECK(!f.target<int (*)()>());
84	BOOST_CHECK(f.target<Seventeen>());
85
86	Seventeen this_seventeen;
87	f = boost::ref(this_seventeen);
88	BOOST_CHECK(!f.target<int (*)()>());
89	BOOST_CHECK(f.target<Seventeen>());
90	BOOST_CHECK(f.target<Seventeen>() == &this_seventeen);
91
92	const Seventeen const_seventeen = this_seventeen;
93	f = boost::ref(const_seventeen);
94	BOOST_CHECK(!f.target<int (*)()>());
95	BOOST_CHECK(f.target<const Seventeen>());
96	BOOST_CHECK(f.target<const Seventeen>() == &const_seventeen);
97	BOOST_CHECK(f.target<const volatile Seventeen>());
98	BOOST_CHECK(!f.target<Seventeen>());
99	BOOST_CHECK(!f.target<volatile Seventeen>());
100	}
101
102	static void equal_test()
103	{
104	boost::function0<int> f;
105
106	f = &forty_two;
107	BOOST_CHECK(f == &forty_two);
108	BOOST_CHECK(f != ReturnInt(17));
109	#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
110	BOOST_CHECK(&forty_two == f);
111	BOOST_CHECK(ReturnInt(17) != f);
112	#endif
113
114	BOOST_CHECK(f.contains(&forty_two));
115
116	f = ReturnInt(17);
117	BOOST_CHECK(f != &forty_two);
118	BOOST_CHECK(f == ReturnInt(17));
119	BOOST_CHECK(f != ReturnInt(16));
120	#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
121	BOOST_CHECK(&forty_two != f);
122	BOOST_CHECK(ReturnInt(17) == f);
123	BOOST_CHECK(ReturnInt(16) != f);
124	#endif
125
126	BOOST_CHECK(f.contains(ReturnInt(17)));
127
128	f = contain_test::ReturnIntFE(17);
129	BOOST_CHECK(f != &forty_two);
130	BOOST_CHECK(f == contain_test::ReturnIntFE(17));
131	BOOST_CHECK(f != contain_test::ReturnIntFE(16));
132	#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
133	BOOST_CHECK(&forty_two != f);
134	BOOST_CHECK(contain_test::ReturnIntFE(17) == f);
135	BOOST_CHECK(contain_test::ReturnIntFE(16) != f);
136	#endif
137
138	BOOST_CHECK(f.contains(contain_test::ReturnIntFE(17)));
139
140	#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
141	boost::function<int(void)> g;
142
143	g = &forty_two;
144	BOOST_CHECK(g == &forty_two);
145	BOOST_CHECK(g != ReturnInt(17));
146	# if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
147	BOOST_CHECK(&forty_two == g);
148	BOOST_CHECK(ReturnInt(17) != g);
149	# endif
150
151	g = ReturnInt(17);
152	BOOST_CHECK(g != &forty_two);
153	BOOST_CHECK(g == ReturnInt(17));
154	BOOST_CHECK(g != ReturnInt(16));
155	# if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
156	BOOST_CHECK(&forty_two != g);
157	BOOST_CHECK(ReturnInt(17) == g);
158	BOOST_CHECK(ReturnInt(16) != g);
159	# endif
160	#endif
161	}
162
163	static void ref_equal_test()
164	{
165	{
166	ReturnInt ri(17);
167	boost::function0<int> f = boost::ref(ri);
168
169	// References and values are equal
170	BOOST_CHECK(f == boost::ref(ri));
171	BOOST_CHECK(f == ri);
172	BOOST_CHECK(boost::ref(ri) == f);
173	BOOST_CHECK(!(f != boost::ref(ri)));
174	BOOST_CHECK(!(f != ri));
175	BOOST_CHECK(!(boost::ref(ri) != f));
176	#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
177	BOOST_CHECK(ri == f);
178	BOOST_CHECK(!(ri != f));
179	#endif
180
181	// Values equal, references inequal
182	ReturnInt ri2(17);
183	BOOST_CHECK(f == ri2);
184	BOOST_CHECK(f != boost::ref(ri2));
185	BOOST_CHECK(boost::ref(ri2) != f);
186	BOOST_CHECK(!(f != ri2));
187	BOOST_CHECK(!(f == boost::ref(ri2)));
188	BOOST_CHECK(!(boost::ref(ri2) == f));
189	#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
190	BOOST_CHECK(ri2 == f);
191	BOOST_CHECK(!(ri2 != f));
192	#endif
193	}
194
195	#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
196	{
197	ReturnInt ri(17);
198	boost::function<int(void)> f = boost::ref(ri);
199
200	// References and values are equal
201	BOOST_CHECK(f == boost::ref(ri));
202	BOOST_CHECK(f == ri);
203	BOOST_CHECK(boost::ref(ri) == f);
204	BOOST_CHECK(!(f != boost::ref(ri)));
205	BOOST_CHECK(!(f != ri));
206	BOOST_CHECK(!(boost::ref(ri) != f));
207	# if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
208	BOOST_CHECK(ri == f);
209	BOOST_CHECK(!(ri != f));
210	# endif
211
212	// Values equal, references inequal
213	ReturnInt ri2(17);
214	BOOST_CHECK(f == ri2);
215	BOOST_CHECK(f != boost::ref(ri2));
216	BOOST_CHECK(boost::ref(ri2) != f);
217	BOOST_CHECK(!(f != ri2));
218	BOOST_CHECK(!(f == boost::ref(ri2)));
219	BOOST_CHECK(!(boost::ref(ri2) == f));
220	# if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
221	BOOST_CHECK(ri2 == f);
222	BOOST_CHECK(!(ri2 != f));
223	# endif
224	}
225	#endif
226	}
227
228	int test_main(int, char*[])
229	{
230	target_test();
231	equal_test();
232	ref_equal_test();
233
234	return 0;
235	}