minmax_macro v0.1

[SVN r3105]

minmax_macro/test/rvalue_lvalue.cpp

@@ -0,0 +1,94 @@
+///////////////////////////////////////////////////////////////////////////////
+// rvalue_lvalue.hpp test file
+//
+// Copyright 2006 Eric Niebler.
+// 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)
+//
+// Test code from Howard Hinnant (TODO: get permission!)
+
+#include <boost/test/included/unit_test.hpp>
+#include <boost/algorithm/minmax_macro.hpp>
+
+class A
+{
+private:
+    int i_;
+public:
+    A(int i) : i_(i) {}
+    ~A() {i_ = 0;}
+
+    A(const A& a) : i_(a.i_) {}
+
+    operator int() const {return i_;}
+
+    friend bool operator<(const A& x, const A& y)
+    {return  x.i_ < y.i_;}
+
+    friend bool operator==(const A& x, const A& y)
+    {return  x.i_ == y.i_;}
+};
+
+void test_rvalue_lvalue()
+{
+    // lvalues of the same type:
+    {
+        A a3(3);
+        A a2(2);
+        BOOST_MIN(a2, a3) = A(1);  // a2 == 1, no copy, no move
+        BOOST_CHECK_EQUAL(a2, A(1));
+        BOOST_CHECK_EQUAL(a3, A(3));
+    }
+
+    //{
+    //    // lvalues of the same type with different cv
+    //    const A a3(3);
+    //    A a2(2);
+    //    BOOST_MIN(a2, a3) = A(1);  // illegal operands 'const A' = 'A'
+    //}
+
+    {
+        const A a3(3);
+        A a2(2);
+        const A& a_ref = BOOST_MIN(a2, a3);
+        a2 = A(1);  // a_ref == 1, a_ref refers to a2, no copy, no move
+        BOOST_CHECK_EQUAL(a_ref, A(1));
+    }
+
+    {
+        // lvalue / rvalue mix of the same type
+        A a3(3);
+        const A& a_ref = BOOST_MIN(A(2), a3);
+        BOOST_CHECK_EQUAL(a_ref, A(2));
+        // a_ref refers to temporary returned (by value) from BOOST_MIN, a_ref == 2, A(A&&) executed to move from A(2)
+        // A(const A&) - or some copy constructor - required to be accessible
+    }
+
+    {
+        A a1(1);
+        const A& a_ref = BOOST_MIN(A(2), a1);
+        BOOST_CHECK_EQUAL(a_ref, A(1));
+        // a_ref refers to temporary returned (by value) from BOOST_MIN, a_ref == 1, A(const A&) executed to copy from a1
+    }
+
+    {
+        // rvalue / rvalue
+        const A& a_ref = BOOST_MIN(A(2), A(3));
+        BOOST_CHECK_EQUAL(a_ref, A(2));
+        // a_ref refers to temporary returned (by value) from BOOST_MIN, a_ref == 2, A(A&&) executed to move from A(2)
+        // accessible copy constructor not required
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// init_unit_test_suite
+//
+boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
+{
+    boost::unit_test::test_suite *test = BOOST_TEST_SUITE("rvalue/lvalue min/max test");
+
+    test->add(BOOST_TEST_CASE(&test_rvalue_lvalue));
+
+    return test;
+}