#  Boost.SmartPtr Library test Jamfile
#
#  Copyright (c) 2003-2007 Peter Dimov
#  Copyright (c) 2003 Dave Abrahams
#
#  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)

# bring in rules for testing
import testing ;

{
    test-suite "smart_ptr"
        : [ run smart_ptr_test.cpp ]
          [ run shared_ptr_basic_test.cpp : : : <toolset>gcc:<cxxflags>-Wno-non-virtual-dtor ]
          [ run shared_ptr_test.cpp : : : <toolset>gcc:<cxxflags>-Wno-non-virtual-dtor ]
          [ run weak_ptr_test.cpp ]
          [ run weak_ptr_move_test.cpp ]
          [ run shared_from_this_test.cpp : : : <toolset>gcc:<cxxflags>-Wno-non-virtual-dtor ]
          [ run get_deleter_test.cpp ]
          [ run intrusive_ptr_test.cpp ]
          [ run intrusive_ptr_move_test.cpp ]
          [ run atomic_count_test.cpp ]
          [ run lw_mutex_test.cpp ]
          [ compile-fail shared_ptr_assign_fail.cpp ]
          [ compile-fail shared_ptr_delete_fail.cpp ]
          [ compile-fail shared_ptr_compare_fail.cpp ]
          [ run shared_ptr_alloc2_test.cpp ]
          [ run pointer_cast_test.cpp ]
          [ compile pointer_to_other_test.cpp ]
          [ run auto_ptr_rv_test.cpp ]
          [ run shared_ptr_alias_test.cpp ]
          [ run shared_ptr_rv_test.cpp ]
          [ run shared_ptr_move_test.cpp ]
          [ compile-fail shared_ptr_pv_fail.cpp ]
          [ run sp_unary_addr_test.cpp ]
          [ compile-fail scoped_ptr_eq_fail.cpp ]
          [ compile-fail scoped_array_eq_fail.cpp ]
          [ run esft_regtest.cpp ]
          [ run yield_k_test.cpp ]
          [ run yield_k_test.cpp : : : <threading>multi : yield_k_test.mt ]
          [ run spinlock_test.cpp ]
          [ run spinlock_try_test.cpp ]
          [ run spinlock_try_test.cpp : : : <threading>multi : spinlock_try_test.mt ]
          [ run spinlock_pool_test.cpp ]
          [ run make_shared_test.cpp ]
          [ run make_shared_perfect_forwarding_test.cpp ]
          [ run sp_convertible_test.cpp ]
          [ run wp_convertible_test.cpp ]
          [ run ip_convertible_test.cpp ]
          [ run allocate_shared_test.cpp ]
          [ run sp_atomic_test.cpp ]
          [ run esft_void_test.cpp ]
          [ run esft_second_ptr_test.cpp ]
          [ run make_shared_esft_test.cpp ]
          [ run allocate_shared_esft_test.cpp ]
          [ run sp_recursive_assign_test.cpp ]
          [ run sp_recursive_assign2_test.cpp ]
          [ run sp_recursive_assign_rv_test.cpp ]
          [ run sp_recursive_assign2_rv_test.cpp ]
          [ run esft_constructor_test.cpp ]
          [ compile-fail auto_ptr_lv_fail.cpp ]
          [ run atomic_count_test2.cpp ]
          [ run sp_typeinfo_test.cpp ]
          [ compile make_shared_fp_test.cpp ]
        ;
}
