UncopiableAndUnmovableClass_test.cc File Reference

#include "larcorealg/CoreUtils/UncopiableAndUnmovableClass.h"
#include <boost/test/unit_test.hpp>
#include <type_traits>

Go to the source code of this file.

Macros
#define	BOOST_TEST_MODULE   ( UncopiableAndUnmovableClass_test )

Functions
	BOOST_AUTO_TEST_CASE (UncopiableAndUnmovableClassTest)

Macro Definition Documentation

#define BOOST_TEST_MODULE   ( UncopiableAndUnmovableClass_test )

Definition at line 19 of file UncopiableAndUnmovableClass_test.cc.

Function Documentation

BOOST_AUTO_TEST_CASE

(

UncopiableAndUnmovableClassTest

)

Definition at line 55 of file UncopiableAndUnmovableClass_test.cc.

                                                      {

   // check lar::UncopiableAndUnmovableClass class itself
   BOOST_TEST
     (!std::is_copy_constructible<lar::UncopiableAndUnmovableClass>::value);
   BOOST_TEST
     (!std::is_copy_assignable<lar::UncopiableAndUnmovableClass>::value);
   BOOST_TEST
     (!std::is_move_constructible<lar::UncopiableAndUnmovableClass>::value);
   BOOST_TEST
     (!std::is_move_assignable<lar::UncopiableAndUnmovableClass>::value);


   // check a class derived from lar::UncopiableAndUnmovableClass class
   struct Derived: protected lar::UncopiableAndUnmovableClass {};

   BOOST_TEST(!std::is_copy_constructible<Derived>::value);
   BOOST_TEST(!std::is_copy_assignable   <Derived>::value);
   BOOST_TEST(!std::is_move_constructible<Derived>::value);
   BOOST_TEST(!std::is_move_assignable   <Derived>::value);


   // check a class derived from lar::UncopiableAndUnmovableClass class
   // and made movable
   struct MovableDerived: protected lar::UncopiableAndUnmovableClass {
      MovableDerived(MovableDerived&&):
        lar::UncopiableAndUnmovableClass() {}
   };

   BOOST_TEST(!std::is_copy_constructible<MovableDerived>::value);
   BOOST_TEST(!std::is_copy_assignable   <MovableDerived>::value);
   BOOST_TEST( std::is_move_constructible<MovableDerived>::value);
   BOOST_TEST(!std::is_move_assignable   <MovableDerived>::value);


   // check a class derived from lar::UncopiableAndUnmovableClass class
   // and made both copy- and move-assignable
   struct AssignableDerived: protected lar::UncopiableAndUnmovableClass {
      AssignableDerived& operator=(AssignableDerived const&) { return *this; }
      AssignableDerived& operator=(AssignableDerived&&) { return *this; }
   };

   BOOST_TEST(!std::is_copy_constructible<AssignableDerived>::value);
   BOOST_TEST( std::is_copy_assignable   <AssignableDerived>::value);
   BOOST_TEST(!std::is_move_constructible<AssignableDerived>::value);
   BOOST_TEST( std::is_move_assignable   <AssignableDerived>::value);

} // BOOST_AUTO_TEST_CASE(UncopiableAndUnmovableClassTest)