From 483eb2f56657e8e7f419ab1a4fab8dce9ade8609 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sat, 27 Apr 2024 20:24:20 +0200 Subject: Adding upstream version 14.2.21. Signed-off-by: Daniel Baumann --- src/boost/libs/fusion/test/sequence/adapt_adt.cpp | 311 ++++++++++++++++++++ .../libs/fusion/test/sequence/adapt_adt_empty.cpp | 87 ++++++ .../libs/fusion/test/sequence/adapt_adt_named.cpp | 161 +++++++++++ .../fusion/test/sequence/adapt_adt_named_empty.cpp | 88 ++++++ .../libs/fusion/test/sequence/adapt_assoc_adt.cpp | 164 +++++++++++ .../fusion/test/sequence/adapt_assoc_adt_empty.cpp | 89 ++++++ .../fusion/test/sequence/adapt_assoc_adt_named.cpp | 159 ++++++++++ .../test/sequence/adapt_assoc_adt_named_empty.cpp | 90 ++++++ .../fusion/test/sequence/adapt_assoc_struct.cpp | 168 +++++++++++ .../test/sequence/adapt_assoc_struct_empty.cpp | 89 ++++++ .../test/sequence/adapt_assoc_struct_named.cpp | 139 +++++++++ .../sequence/adapt_assoc_struct_named_empty.cpp | 90 ++++++ .../fusion/test/sequence/adapt_assoc_tpl_adt.cpp | 177 +++++++++++ .../test/sequence/adapt_assoc_tpl_adt_empty.cpp | 89 ++++++ .../test/sequence/adapt_assoc_tpl_struct.cpp | 168 +++++++++++ .../test/sequence/adapt_assoc_tpl_struct_empty.cpp | 89 ++++++ .../libs/fusion/test/sequence/adapt_struct.cpp | 271 +++++++++++++++++ .../fusion/test/sequence/adapt_struct_empty.cpp | 87 ++++++ .../fusion/test/sequence/adapt_struct_named.cpp | 164 +++++++++++ .../test/sequence/adapt_struct_named_empty.cpp | 88 ++++++ .../libs/fusion/test/sequence/adapt_tpl_adt.cpp | 182 ++++++++++++ .../fusion/test/sequence/adapt_tpl_adt_empty.cpp | 87 ++++++ .../libs/fusion/test/sequence/adapt_tpl_struct.cpp | 159 ++++++++++ .../test/sequence/adapt_tpl_struct_empty.cpp | 87 ++++++ .../fusion/test/sequence/adt_attribute_proxy.cpp | 189 ++++++++++++ src/boost/libs/fusion/test/sequence/array.cpp | 41 +++ src/boost/libs/fusion/test/sequence/as_deque.cpp | 70 +++++ src/boost/libs/fusion/test/sequence/as_list.cpp | 53 ++++ src/boost/libs/fusion/test/sequence/as_map.cpp | 61 ++++ .../libs/fusion/test/sequence/as_map_assoc.cpp | 85 ++++++ src/boost/libs/fusion/test/sequence/as_set.cpp | 64 ++++ src/boost/libs/fusion/test/sequence/as_vector.cpp | 54 ++++ .../fusion/test/sequence/back_extended_deque.cpp | 114 ++++++++ .../libs/fusion/test/sequence/boost_array.cpp | 44 +++ .../libs/fusion/test/sequence/boost_tuple.cpp | 118 ++++++++ .../fusion/test/sequence/boost_tuple_iterator.cpp | 21 ++ src/boost/libs/fusion/test/sequence/comparison.hpp | 57 ++++ src/boost/libs/fusion/test/sequence/cons.cpp | 95 ++++++ .../libs/fusion/test/sequence/construction.hpp | 122 ++++++++ src/boost/libs/fusion/test/sequence/conversion.hpp | 322 +++++++++++++++++++++ src/boost/libs/fusion/test/sequence/convert.hpp | 51 ++++ .../fusion/test/sequence/convert_boost_tuple.cpp | 14 + .../libs/fusion/test/sequence/convert_deque.cpp | 13 + .../libs/fusion/test/sequence/convert_list.cpp | 13 + .../libs/fusion/test/sequence/convert_std_pair.cpp | 14 + .../fusion/test/sequence/convert_std_tuple.cpp | 20 ++ .../libs/fusion/test/sequence/convert_vector.cpp | 13 + src/boost/libs/fusion/test/sequence/copy.hpp | 154 ++++++++++ .../libs/fusion/test/sequence/deduce_sequence.cpp | 91 ++++++ .../fusion/test/sequence/define_assoc_struct.cpp | 117 ++++++++ .../test/sequence/define_assoc_struct_empty.cpp | 78 +++++ .../test/sequence/define_assoc_struct_move.cpp | 67 +++++ .../test/sequence/define_assoc_tpl_struct.cpp | 121 ++++++++ .../sequence/define_assoc_tpl_struct_empty.cpp | 78 +++++ .../test/sequence/define_assoc_tpl_struct_move.cpp | 78 +++++ .../libs/fusion/test/sequence/define_struct.cpp | 130 +++++++++ .../fusion/test/sequence/define_struct_empty.cpp | 76 +++++ .../fusion/test/sequence/define_struct_inline.cpp | 153 ++++++++++ .../test/sequence/define_struct_inline_empty.cpp | 76 +++++ .../test/sequence/define_struct_inline_move.cpp | 73 +++++ .../fusion/test/sequence/define_struct_move.cpp | 66 +++++ .../fusion/test/sequence/define_tpl_struct.cpp | 112 +++++++ .../test/sequence/define_tpl_struct_empty.cpp | 75 +++++ .../test/sequence/define_tpl_struct_inline.cpp | 138 +++++++++ .../sequence/define_tpl_struct_inline_empty.cpp | 75 +++++ .../sequence/define_tpl_struct_inline_move.cpp | 73 +++++ .../test/sequence/define_tpl_struct_move.cpp | 66 +++++ .../libs/fusion/test/sequence/deque_comparison.cpp | 20 ++ .../fusion/test/sequence/deque_construction.cpp | 19 ++ src/boost/libs/fusion/test/sequence/deque_copy.cpp | 42 +++ src/boost/libs/fusion/test/sequence/deque_hash.cpp | 16 + .../test/sequence/deque_is_constructible.cpp | 21 ++ .../libs/fusion/test/sequence/deque_iterator.cpp | 19 ++ src/boost/libs/fusion/test/sequence/deque_make.cpp | 20 ++ src/boost/libs/fusion/test/sequence/deque_misc.cpp | 24 ++ src/boost/libs/fusion/test/sequence/deque_move.cpp | 22 ++ .../libs/fusion/test/sequence/deque_mutate.cpp | 20 ++ src/boost/libs/fusion/test/sequence/deque_nest.cpp | 43 +++ src/boost/libs/fusion/test/sequence/deque_tie.cpp | 23 ++ .../libs/fusion/test/sequence/deque_value_at.cpp | 20 ++ .../libs/fusion/test/sequence/filter_view.cpp | 129 +++++++++ src/boost/libs/fusion/test/sequence/fixture.hpp | 216 ++++++++++++++ .../libs/fusion/test/sequence/flatten_view.cpp | 56 ++++ .../fusion/test/sequence/front_extended_deque.cpp | 114 ++++++++ src/boost/libs/fusion/test/sequence/github-159.cpp | 16 + src/boost/libs/fusion/test/sequence/github-176.cpp | 90 ++++++ src/boost/libs/fusion/test/sequence/hash.cpp | 59 ++++ src/boost/libs/fusion/test/sequence/hash.hpp | 35 +++ src/boost/libs/fusion/test/sequence/io.cpp | 131 +++++++++ src/boost/libs/fusion/test/sequence/iterator.hpp | 200 +++++++++++++ .../libs/fusion/test/sequence/iterator_range.cpp | 115 ++++++++ src/boost/libs/fusion/test/sequence/joint_view.cpp | 188 ++++++++++++ .../libs/fusion/test/sequence/list_comparison.cpp | 19 ++ .../fusion/test/sequence/list_construction.cpp | 18 ++ src/boost/libs/fusion/test/sequence/list_copy.cpp | 21 ++ src/boost/libs/fusion/test/sequence/list_hash.cpp | 16 + .../libs/fusion/test/sequence/list_iterator.cpp | 22 ++ src/boost/libs/fusion/test/sequence/list_make.cpp | 20 ++ src/boost/libs/fusion/test/sequence/list_misc.cpp | 21 ++ .../libs/fusion/test/sequence/list_mutate.cpp | 19 ++ src/boost/libs/fusion/test/sequence/list_nest.cpp | 36 +++ src/boost/libs/fusion/test/sequence/list_tie.cpp | 22 ++ .../libs/fusion/test/sequence/list_value_at.cpp | 19 ++ src/boost/libs/fusion/test/sequence/make.hpp | 88 ++++++ src/boost/libs/fusion/test/sequence/make_list.cpp | 20 ++ .../libs/fusion/test/sequence/make_vector.cpp | 20 ++ src/boost/libs/fusion/test/sequence/map.cpp | 181 ++++++++++++ .../libs/fusion/test/sequence/map_comparison.cpp | 68 +++++ .../libs/fusion/test/sequence/map_construction.cpp | 134 +++++++++ src/boost/libs/fusion/test/sequence/map_copy.cpp | 90 ++++++ src/boost/libs/fusion/test/sequence/map_misc.cpp | 179 ++++++++++++ src/boost/libs/fusion/test/sequence/map_move.cpp | 28 ++ src/boost/libs/fusion/test/sequence/map_mutate.cpp | 69 +++++ src/boost/libs/fusion/test/sequence/map_tie.cpp | 35 +++ src/boost/libs/fusion/test/sequence/misc.hpp | 204 +++++++++++++ src/boost/libs/fusion/test/sequence/move.hpp | 120 ++++++++ src/boost/libs/fusion/test/sequence/mutate.hpp | 52 ++++ src/boost/libs/fusion/test/sequence/nest.hpp | 321 ++++++++++++++++++++ src/boost/libs/fusion/test/sequence/nil.cpp | 25 ++ src/boost/libs/fusion/test/sequence/nview.cpp | 139 +++++++++ src/boost/libs/fusion/test/sequence/ref_vector.cpp | 64 ++++ .../libs/fusion/test/sequence/repetitive_view.cpp | 53 ++++ .../libs/fusion/test/sequence/reverse_view.cpp | 109 +++++++ .../test/sequence/segmented_iterator_range.cpp | 146 ++++++++++ src/boost/libs/fusion/test/sequence/set.cpp | 110 +++++++ .../libs/fusion/test/sequence/single_view.cpp | 93 ++++++ src/boost/libs/fusion/test/sequence/size.cpp | 103 +++++++ src/boost/libs/fusion/test/sequence/std_array.cpp | 51 ++++ src/boost/libs/fusion/test/sequence/std_pair.cpp | 100 +++++++ src/boost/libs/fusion/test/sequence/std_tuple.cpp | 37 +++ .../fusion/test/sequence/std_tuple_iterator.cpp | 26 ++ src/boost/libs/fusion/test/sequence/swap.cpp | 35 +++ .../fusion/test/sequence/test_deduce_sequence.cpp | 22 ++ src/boost/libs/fusion/test/sequence/tie.hpp | 85 ++++++ src/boost/libs/fusion/test/sequence/traits.hpp | 253 ++++++++++++++++ .../libs/fusion/test/sequence/transform_view.cpp | 115 ++++++++ src/boost/libs/fusion/test/sequence/tree.hpp | 100 +++++++ .../libs/fusion/test/sequence/tuple_comparison.cpp | 20 ++ .../fusion/test/sequence/tuple_construction.cpp | 49 ++++ .../libs/fusion/test/sequence/tuple_conversion.cpp | 51 ++++ src/boost/libs/fusion/test/sequence/tuple_copy.cpp | 22 ++ .../libs/fusion/test/sequence/tuple_element.cpp | 21 ++ src/boost/libs/fusion/test/sequence/tuple_hash.cpp | 16 + src/boost/libs/fusion/test/sequence/tuple_make.cpp | 21 ++ src/boost/libs/fusion/test/sequence/tuple_misc.cpp | 23 ++ .../libs/fusion/test/sequence/tuple_mutate.cpp | 20 ++ src/boost/libs/fusion/test/sequence/tuple_nest.cpp | 35 +++ src/boost/libs/fusion/test/sequence/tuple_tie.cpp | 22 ++ .../libs/fusion/test/sequence/tuple_traits.cpp | 89 ++++++ src/boost/libs/fusion/test/sequence/value_at.hpp | 100 +++++++ .../fusion/test/sequence/vector_comparison.cpp | 19 ++ .../fusion/test/sequence/vector_construction.cpp | 18 ++ .../fusion/test/sequence/vector_conversion.cpp | 19 ++ .../libs/fusion/test/sequence/vector_copy.cpp | 21 ++ .../libs/fusion/test/sequence/vector_hash.cpp | 16 + .../libs/fusion/test/sequence/vector_iterator.cpp | 22 ++ .../libs/fusion/test/sequence/vector_make.cpp | 20 ++ .../libs/fusion/test/sequence/vector_misc.cpp | 21 ++ .../libs/fusion/test/sequence/vector_move.cpp | 22 ++ .../libs/fusion/test/sequence/vector_mutate.cpp | 19 ++ src/boost/libs/fusion/test/sequence/vector_n.cpp | 231 +++++++++++++++ .../libs/fusion/test/sequence/vector_nest.cpp | 19 ++ src/boost/libs/fusion/test/sequence/vector_tie.cpp | 22 ++ .../libs/fusion/test/sequence/vector_traits.cpp | 32 ++ .../libs/fusion/test/sequence/vector_value_at.cpp | 19 ++ src/boost/libs/fusion/test/sequence/zip_view.cpp | 87 ++++++ src/boost/libs/fusion/test/sequence/zip_view2.cpp | 64 ++++ .../libs/fusion/test/sequence/zip_view_ignore.cpp | 58 ++++ 168 files changed, 13212 insertions(+) create mode 100644 src/boost/libs/fusion/test/sequence/adapt_adt.cpp create mode 100644 src/boost/libs/fusion/test/sequence/adapt_adt_empty.cpp create mode 100644 src/boost/libs/fusion/test/sequence/adapt_adt_named.cpp create mode 100644 src/boost/libs/fusion/test/sequence/adapt_adt_named_empty.cpp create mode 100644 src/boost/libs/fusion/test/sequence/adapt_assoc_adt.cpp create mode 100644 src/boost/libs/fusion/test/sequence/adapt_assoc_adt_empty.cpp create mode 100644 src/boost/libs/fusion/test/sequence/adapt_assoc_adt_named.cpp create mode 100644 src/boost/libs/fusion/test/sequence/adapt_assoc_adt_named_empty.cpp create mode 100644 src/boost/libs/fusion/test/sequence/adapt_assoc_struct.cpp create mode 100644 src/boost/libs/fusion/test/sequence/adapt_assoc_struct_empty.cpp create mode 100644 src/boost/libs/fusion/test/sequence/adapt_assoc_struct_named.cpp create mode 100644 src/boost/libs/fusion/test/sequence/adapt_assoc_struct_named_empty.cpp create mode 100644 src/boost/libs/fusion/test/sequence/adapt_assoc_tpl_adt.cpp create mode 100644 src/boost/libs/fusion/test/sequence/adapt_assoc_tpl_adt_empty.cpp create mode 100644 src/boost/libs/fusion/test/sequence/adapt_assoc_tpl_struct.cpp create mode 100644 src/boost/libs/fusion/test/sequence/adapt_assoc_tpl_struct_empty.cpp create mode 100644 src/boost/libs/fusion/test/sequence/adapt_struct.cpp create mode 100644 src/boost/libs/fusion/test/sequence/adapt_struct_empty.cpp create mode 100644 src/boost/libs/fusion/test/sequence/adapt_struct_named.cpp create mode 100644 src/boost/libs/fusion/test/sequence/adapt_struct_named_empty.cpp create mode 100644 src/boost/libs/fusion/test/sequence/adapt_tpl_adt.cpp create mode 100644 src/boost/libs/fusion/test/sequence/adapt_tpl_adt_empty.cpp create mode 100644 src/boost/libs/fusion/test/sequence/adapt_tpl_struct.cpp create mode 100644 src/boost/libs/fusion/test/sequence/adapt_tpl_struct_empty.cpp create mode 100644 src/boost/libs/fusion/test/sequence/adt_attribute_proxy.cpp create mode 100644 src/boost/libs/fusion/test/sequence/array.cpp create mode 100644 src/boost/libs/fusion/test/sequence/as_deque.cpp create mode 100644 src/boost/libs/fusion/test/sequence/as_list.cpp create mode 100644 src/boost/libs/fusion/test/sequence/as_map.cpp create mode 100644 src/boost/libs/fusion/test/sequence/as_map_assoc.cpp create mode 100644 src/boost/libs/fusion/test/sequence/as_set.cpp create mode 100644 src/boost/libs/fusion/test/sequence/as_vector.cpp create mode 100644 src/boost/libs/fusion/test/sequence/back_extended_deque.cpp create mode 100644 src/boost/libs/fusion/test/sequence/boost_array.cpp create mode 100644 src/boost/libs/fusion/test/sequence/boost_tuple.cpp create mode 100644 src/boost/libs/fusion/test/sequence/boost_tuple_iterator.cpp create mode 100644 src/boost/libs/fusion/test/sequence/comparison.hpp create mode 100644 src/boost/libs/fusion/test/sequence/cons.cpp create mode 100644 src/boost/libs/fusion/test/sequence/construction.hpp create mode 100644 src/boost/libs/fusion/test/sequence/conversion.hpp create mode 100644 src/boost/libs/fusion/test/sequence/convert.hpp create mode 100644 src/boost/libs/fusion/test/sequence/convert_boost_tuple.cpp create mode 100644 src/boost/libs/fusion/test/sequence/convert_deque.cpp create mode 100644 src/boost/libs/fusion/test/sequence/convert_list.cpp create mode 100644 src/boost/libs/fusion/test/sequence/convert_std_pair.cpp create mode 100644 src/boost/libs/fusion/test/sequence/convert_std_tuple.cpp create mode 100644 src/boost/libs/fusion/test/sequence/convert_vector.cpp create mode 100644 src/boost/libs/fusion/test/sequence/copy.hpp create mode 100644 src/boost/libs/fusion/test/sequence/deduce_sequence.cpp create mode 100644 src/boost/libs/fusion/test/sequence/define_assoc_struct.cpp create mode 100644 src/boost/libs/fusion/test/sequence/define_assoc_struct_empty.cpp create mode 100644 src/boost/libs/fusion/test/sequence/define_assoc_struct_move.cpp create mode 100644 src/boost/libs/fusion/test/sequence/define_assoc_tpl_struct.cpp create mode 100644 src/boost/libs/fusion/test/sequence/define_assoc_tpl_struct_empty.cpp create mode 100644 src/boost/libs/fusion/test/sequence/define_assoc_tpl_struct_move.cpp create mode 100644 src/boost/libs/fusion/test/sequence/define_struct.cpp create mode 100644 src/boost/libs/fusion/test/sequence/define_struct_empty.cpp create mode 100644 src/boost/libs/fusion/test/sequence/define_struct_inline.cpp create mode 100644 src/boost/libs/fusion/test/sequence/define_struct_inline_empty.cpp create mode 100644 src/boost/libs/fusion/test/sequence/define_struct_inline_move.cpp create mode 100644 src/boost/libs/fusion/test/sequence/define_struct_move.cpp create mode 100644 src/boost/libs/fusion/test/sequence/define_tpl_struct.cpp create mode 100644 src/boost/libs/fusion/test/sequence/define_tpl_struct_empty.cpp create mode 100644 src/boost/libs/fusion/test/sequence/define_tpl_struct_inline.cpp create mode 100644 src/boost/libs/fusion/test/sequence/define_tpl_struct_inline_empty.cpp create mode 100644 src/boost/libs/fusion/test/sequence/define_tpl_struct_inline_move.cpp create mode 100644 src/boost/libs/fusion/test/sequence/define_tpl_struct_move.cpp create mode 100644 src/boost/libs/fusion/test/sequence/deque_comparison.cpp create mode 100644 src/boost/libs/fusion/test/sequence/deque_construction.cpp create mode 100644 src/boost/libs/fusion/test/sequence/deque_copy.cpp create mode 100644 src/boost/libs/fusion/test/sequence/deque_hash.cpp create mode 100644 src/boost/libs/fusion/test/sequence/deque_is_constructible.cpp create mode 100644 src/boost/libs/fusion/test/sequence/deque_iterator.cpp create mode 100644 src/boost/libs/fusion/test/sequence/deque_make.cpp create mode 100644 src/boost/libs/fusion/test/sequence/deque_misc.cpp create mode 100644 src/boost/libs/fusion/test/sequence/deque_move.cpp create mode 100644 src/boost/libs/fusion/test/sequence/deque_mutate.cpp create mode 100644 src/boost/libs/fusion/test/sequence/deque_nest.cpp create mode 100644 src/boost/libs/fusion/test/sequence/deque_tie.cpp create mode 100644 src/boost/libs/fusion/test/sequence/deque_value_at.cpp create mode 100644 src/boost/libs/fusion/test/sequence/filter_view.cpp create mode 100644 src/boost/libs/fusion/test/sequence/fixture.hpp create mode 100644 src/boost/libs/fusion/test/sequence/flatten_view.cpp create mode 100644 src/boost/libs/fusion/test/sequence/front_extended_deque.cpp create mode 100644 src/boost/libs/fusion/test/sequence/github-159.cpp create mode 100644 src/boost/libs/fusion/test/sequence/github-176.cpp create mode 100644 src/boost/libs/fusion/test/sequence/hash.cpp create mode 100644 src/boost/libs/fusion/test/sequence/hash.hpp create mode 100644 src/boost/libs/fusion/test/sequence/io.cpp create mode 100644 src/boost/libs/fusion/test/sequence/iterator.hpp create mode 100644 src/boost/libs/fusion/test/sequence/iterator_range.cpp create mode 100644 src/boost/libs/fusion/test/sequence/joint_view.cpp create mode 100644 src/boost/libs/fusion/test/sequence/list_comparison.cpp create mode 100644 src/boost/libs/fusion/test/sequence/list_construction.cpp create mode 100644 src/boost/libs/fusion/test/sequence/list_copy.cpp create mode 100644 src/boost/libs/fusion/test/sequence/list_hash.cpp create mode 100644 src/boost/libs/fusion/test/sequence/list_iterator.cpp create mode 100644 src/boost/libs/fusion/test/sequence/list_make.cpp create mode 100644 src/boost/libs/fusion/test/sequence/list_misc.cpp create mode 100644 src/boost/libs/fusion/test/sequence/list_mutate.cpp create mode 100644 src/boost/libs/fusion/test/sequence/list_nest.cpp create mode 100644 src/boost/libs/fusion/test/sequence/list_tie.cpp create mode 100644 src/boost/libs/fusion/test/sequence/list_value_at.cpp create mode 100644 src/boost/libs/fusion/test/sequence/make.hpp create mode 100644 src/boost/libs/fusion/test/sequence/make_list.cpp create mode 100644 src/boost/libs/fusion/test/sequence/make_vector.cpp create mode 100644 src/boost/libs/fusion/test/sequence/map.cpp create mode 100644 src/boost/libs/fusion/test/sequence/map_comparison.cpp create mode 100644 src/boost/libs/fusion/test/sequence/map_construction.cpp create mode 100644 src/boost/libs/fusion/test/sequence/map_copy.cpp create mode 100644 src/boost/libs/fusion/test/sequence/map_misc.cpp create mode 100644 src/boost/libs/fusion/test/sequence/map_move.cpp create mode 100644 src/boost/libs/fusion/test/sequence/map_mutate.cpp create mode 100644 src/boost/libs/fusion/test/sequence/map_tie.cpp create mode 100644 src/boost/libs/fusion/test/sequence/misc.hpp create mode 100644 src/boost/libs/fusion/test/sequence/move.hpp create mode 100644 src/boost/libs/fusion/test/sequence/mutate.hpp create mode 100644 src/boost/libs/fusion/test/sequence/nest.hpp create mode 100644 src/boost/libs/fusion/test/sequence/nil.cpp create mode 100644 src/boost/libs/fusion/test/sequence/nview.cpp create mode 100644 src/boost/libs/fusion/test/sequence/ref_vector.cpp create mode 100644 src/boost/libs/fusion/test/sequence/repetitive_view.cpp create mode 100644 src/boost/libs/fusion/test/sequence/reverse_view.cpp create mode 100644 src/boost/libs/fusion/test/sequence/segmented_iterator_range.cpp create mode 100644 src/boost/libs/fusion/test/sequence/set.cpp create mode 100644 src/boost/libs/fusion/test/sequence/single_view.cpp create mode 100644 src/boost/libs/fusion/test/sequence/size.cpp create mode 100644 src/boost/libs/fusion/test/sequence/std_array.cpp create mode 100644 src/boost/libs/fusion/test/sequence/std_pair.cpp create mode 100644 src/boost/libs/fusion/test/sequence/std_tuple.cpp create mode 100644 src/boost/libs/fusion/test/sequence/std_tuple_iterator.cpp create mode 100644 src/boost/libs/fusion/test/sequence/swap.cpp create mode 100644 src/boost/libs/fusion/test/sequence/test_deduce_sequence.cpp create mode 100644 src/boost/libs/fusion/test/sequence/tie.hpp create mode 100644 src/boost/libs/fusion/test/sequence/traits.hpp create mode 100644 src/boost/libs/fusion/test/sequence/transform_view.cpp create mode 100644 src/boost/libs/fusion/test/sequence/tree.hpp create mode 100644 src/boost/libs/fusion/test/sequence/tuple_comparison.cpp create mode 100644 src/boost/libs/fusion/test/sequence/tuple_construction.cpp create mode 100644 src/boost/libs/fusion/test/sequence/tuple_conversion.cpp create mode 100644 src/boost/libs/fusion/test/sequence/tuple_copy.cpp create mode 100644 src/boost/libs/fusion/test/sequence/tuple_element.cpp create mode 100644 src/boost/libs/fusion/test/sequence/tuple_hash.cpp create mode 100644 src/boost/libs/fusion/test/sequence/tuple_make.cpp create mode 100644 src/boost/libs/fusion/test/sequence/tuple_misc.cpp create mode 100644 src/boost/libs/fusion/test/sequence/tuple_mutate.cpp create mode 100644 src/boost/libs/fusion/test/sequence/tuple_nest.cpp create mode 100644 src/boost/libs/fusion/test/sequence/tuple_tie.cpp create mode 100644 src/boost/libs/fusion/test/sequence/tuple_traits.cpp create mode 100644 src/boost/libs/fusion/test/sequence/value_at.hpp create mode 100644 src/boost/libs/fusion/test/sequence/vector_comparison.cpp create mode 100644 src/boost/libs/fusion/test/sequence/vector_construction.cpp create mode 100644 src/boost/libs/fusion/test/sequence/vector_conversion.cpp create mode 100644 src/boost/libs/fusion/test/sequence/vector_copy.cpp create mode 100644 src/boost/libs/fusion/test/sequence/vector_hash.cpp create mode 100644 src/boost/libs/fusion/test/sequence/vector_iterator.cpp create mode 100644 src/boost/libs/fusion/test/sequence/vector_make.cpp create mode 100644 src/boost/libs/fusion/test/sequence/vector_misc.cpp create mode 100644 src/boost/libs/fusion/test/sequence/vector_move.cpp create mode 100644 src/boost/libs/fusion/test/sequence/vector_mutate.cpp create mode 100644 src/boost/libs/fusion/test/sequence/vector_n.cpp create mode 100644 src/boost/libs/fusion/test/sequence/vector_nest.cpp create mode 100644 src/boost/libs/fusion/test/sequence/vector_tie.cpp create mode 100644 src/boost/libs/fusion/test/sequence/vector_traits.cpp create mode 100644 src/boost/libs/fusion/test/sequence/vector_value_at.cpp create mode 100644 src/boost/libs/fusion/test/sequence/zip_view.cpp create mode 100644 src/boost/libs/fusion/test/sequence/zip_view2.cpp create mode 100644 src/boost/libs/fusion/test/sequence/zip_view_ignore.cpp (limited to 'src/boost/libs/fusion/test/sequence') diff --git a/src/boost/libs/fusion/test/sequence/adapt_adt.cpp b/src/boost/libs/fusion/test/sequence/adapt_adt.cpp new file mode 100644 index 00000000..00a149b7 --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/adapt_adt.cpp @@ -0,0 +1,311 @@ +/*============================================================================= + Copyright (c) 2001-2009 Joel de Guzman + + 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace ns +{ + class point + { + public: + + point() : x(0), y(0), z(0) {} + point(int in_x, int in_y, int in_z) : x(in_x), y(in_y), z(in_z) {} + + int get_x() const { return x; } + int get_y() const { return y; } + int get_z() const { return z; } + void set_x(int x_) { x = x_; } + void set_y(int y_) { y = y_; } + void set_z(int z_) { z = z_; } + + private: + + int x; + int y; + int z; + }; + +#if !BOOST_WORKAROUND(__GNUC__,<4) + class point_with_private_members + { + friend struct boost::fusion::extension::access; + + public: + point_with_private_members() : x(0), y(0), z(0) {} + point_with_private_members(int in_x, int in_y, int in_z) + : x(in_x), y(in_y), z(in_z) {} + + int get_x() const { return x; } + int get_y() const { return y; } + int get_z() const { return z; } + void set_x(int x_) { x = x_; } + void set_y(int y_) { y = y_; } + void set_z(int z_) { z = z_; } + + private: + + int x; + int y; + int z; + }; +#endif + + // A sequence that has data members defined in an unrelated namespace + // (std, in this case). This allows testing ADL issues. + class name + { + public: + name() {} + name(const std::string& last, const std::string& first) + : last(last), first(first) {} + + const std::string& get_last() const { return last; } + const std::string& get_first() const { return first; } + void set_last(const std::string& last_) { last = last_; } + void set_first(const std::string& first_) { first = first_; } + private: + std::string last; + std::string first; + }; +} + +#if BOOST_PP_VARIADICS + BOOST_FUSION_ADAPT_ADT( + ns::point, + (int, int, obj.get_x(), obj.set_x(val)) + // Mixing auto & BOOST_FUSION_ADAPT_AUTO to test backward compatibility + (auto, BOOST_FUSION_ADAPT_AUTO, obj.get_y(), obj.set_y(val)) + (obj.get_z(), obj.set_z(val)) + ) + +# if !BOOST_WORKAROUND(__GNUC__,<4) + BOOST_FUSION_ADAPT_ADT( + ns::point_with_private_members, + (obj.get_x(), obj.set_x(val)) + (obj.get_y(), obj.set_y(val)) + (obj.get_z(), obj.set_z(val)) + ) +# endif + + + BOOST_FUSION_ADAPT_ADT( + ns::name, + (obj.get_last(), obj.set_last(val)) + (obj.get_first(), obj.set_first(val)) + ) + + +#else // BOOST_PP_VARIADICS + BOOST_FUSION_ADAPT_ADT( + ns::point, + (int, int, obj.get_x(), obj.set_x(val)) + (auto, auto, obj.get_y(), obj.set_y(val)) + (auto, auto, obj.get_z(), obj.set_z(val)) + ) + +# if !BOOST_WORKAROUND(__GNUC__,<4) + BOOST_FUSION_ADAPT_ADT( + ns::point_with_private_members, + (auto, auto, obj.get_x(), obj.set_x(val)) + (auto, auto, obj.get_y(), obj.set_y(val)) + (auto, auto, obj.get_z(), obj.set_z(val)) + ) +# endif + + BOOST_FUSION_ADAPT_ADT( + ns::name, + (const std::string&, const std::string&, obj.get_last(), obj.set_last(val)) + (BOOST_FUSION_ADAPT_AUTO, auto, obj.get_first(), obj.set_first(val)) + ) + +#endif + +class empty_adt{}; +BOOST_FUSION_ADAPT_ADT(empty_adt,) + +int +main() +{ + using namespace boost::fusion; + using namespace boost; + + std::cout << tuple_open('['); + std::cout << tuple_close(']'); + std::cout << tuple_delimiter(", "); + + { + BOOST_MPL_ASSERT_NOT((traits::is_view)); + BOOST_STATIC_ASSERT(!traits::is_view::value); + ns::point p(123, 456, 789); + + std::cout << at_c<0>(p) << std::endl; + std::cout << at_c<1>(p) << std::endl; + std::cout << at_c<2>(p) << std::endl; + std::cout << p << std::endl; + BOOST_TEST(p == make_vector(123, 456, 789)); + + at_c<0>(p) = 6; + at_c<1>(p) = 9; + at_c<2>(p) = 12; + BOOST_TEST(p == make_vector(6, 9, 12)); + + BOOST_STATIC_ASSERT(boost::fusion::result_of::size::value == 3); + BOOST_STATIC_ASSERT(!boost::fusion::result_of::empty::value); + + BOOST_TEST(front(p) == 6); + BOOST_TEST(back(p) == 12); + } + + { + fusion::vector v1(4, 2.f, 2); + ns::point v2(5, 3, 3); + fusion::vector v3(5, 4., 4); + BOOST_TEST(v1 < v2); + BOOST_TEST(v1 <= v2); + BOOST_TEST(v2 > v1); + BOOST_TEST(v2 >= v1); + BOOST_TEST(v2 < v3); + BOOST_TEST(v2 <= v3); + BOOST_TEST(v3 > v2); + BOOST_TEST(v3 >= v2); + } + + { + fusion::vector v1("Lincoln", "Abraham"); + ns::name v2("Roosevelt", "Franklin"); + ns::name v3("Roosevelt", "Theodore"); + BOOST_TEST(v1 < v2); + BOOST_TEST(v1 <= v2); + BOOST_TEST(v2 > v1); + BOOST_TEST(v2 >= v1); + BOOST_TEST(v2 < v3); + BOOST_TEST(v2 <= v3); + BOOST_TEST(v3 > v2); + BOOST_TEST(v3 >= v2); + } + + { + // conversion from ns::point to vector + ns::point p(5, 3, 3); + fusion::vector v(p); + v = p; + } + + { + // conversion from ns::point to list + ns::point p(5, 3, 3); + fusion::list l(p); + l = p; + } + + { + BOOST_MPL_ASSERT((mpl::is_sequence)); + BOOST_MPL_ASSERT((boost::is_same< + boost::fusion::result_of::value_at_c::type + , mpl::front::type>)); + } + +#if !BOOST_WORKAROUND(__GNUC__,<4) + { + BOOST_MPL_ASSERT_NOT((traits::is_view)); + BOOST_STATIC_ASSERT(!traits::is_view::value); + ns::point_with_private_members p(123, 456, 789); + + std::cout << at_c<0>(p) << std::endl; + std::cout << at_c<1>(p) << std::endl; + std::cout << at_c<2>(p) << std::endl; + std::cout << p << std::endl; + BOOST_TEST(p == make_vector(123, 456, 789)); + + at_c<0>(p) = 6; + at_c<1>(p) = 9; + at_c<2>(p) = 12; + BOOST_TEST(p == make_vector(6, 9, 12)); + + BOOST_STATIC_ASSERT(boost::fusion::result_of::size::value == 3); + BOOST_STATIC_ASSERT(!boost::fusion::result_of::empty::value); + + BOOST_TEST(front(p) == 6); + BOOST_TEST(back(p) == 12); + } +#endif + + { + // Check types provided in case it's provided + BOOST_MPL_ASSERT(( + boost::is_same< + boost::fusion::result_of::front::type, + boost::fusion::extension::adt_attribute_proxy + >)); + BOOST_MPL_ASSERT(( + boost::is_same< + boost::fusion::result_of::front::type::type, + int + >)); + BOOST_MPL_ASSERT(( + boost::is_same< + boost::fusion::result_of::front::type, + boost::fusion::extension::adt_attribute_proxy + >)); + BOOST_MPL_ASSERT(( + boost::is_same< + boost::fusion::result_of::front::type::type, + int + >)); + + // Check types provided in case it's deduced + BOOST_MPL_ASSERT(( + boost::is_same< + boost::fusion::result_of::back::type, + boost::fusion::extension::adt_attribute_proxy + >)); + BOOST_MPL_ASSERT(( + boost::is_same< + boost::fusion::result_of::back::type::type, + int + >)); + BOOST_MPL_ASSERT(( + boost::is_same< + boost::fusion::result_of::back::type, + boost::fusion::extension::adt_attribute_proxy + >)); + BOOST_MPL_ASSERT(( + boost::is_same< + boost::fusion::result_of::back::type::type, + int + >)); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/sequence/adapt_adt_empty.cpp b/src/boost/libs/fusion/test/sequence/adapt_adt_empty.cpp new file mode 100644 index 00000000..03e786b7 --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/adapt_adt_empty.cpp @@ -0,0 +1,87 @@ +/*============================================================================= + Copyright (c) 2016 Kohei Takahashi + + 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +class empty_adt{}; +BOOST_FUSION_ADAPT_ADT(empty_adt,) + +int +main() +{ + using namespace boost::fusion; + using namespace boost; + + std::cout << tuple_open('['); + std::cout << tuple_close(']'); + std::cout << tuple_delimiter(", "); + + { + BOOST_MPL_ASSERT_NOT((traits::is_view)); + BOOST_STATIC_ASSERT(!traits::is_view::value); + empty_adt e; + + std::cout << e << std::endl; + BOOST_TEST(e == make_vector()); + + BOOST_STATIC_ASSERT(fusion::result_of::size::value == 0); + BOOST_MPL_ASSERT((fusion::result_of::empty)); + + BOOST_MPL_ASSERT((fusion::result_of::equal_to< + fusion::result_of::begin::type, + fusion::result_of::end::type>)); + } + + { + fusion::vector<> v; + empty_adt e; + BOOST_TEST(v == e); + BOOST_TEST_NOT(v != e); + BOOST_TEST_NOT(v < e); + BOOST_TEST(v <= e); + BOOST_TEST_NOT(e > v); + BOOST_TEST(e >= v); + } + + { + empty_adt e; + + // conversion from empty_adt to vector + fusion::vector<> v(e); + v = e; + + // FIXME + // conversion from empty_adt to list + //fusion::list<> l(e); + //l = e; + } + + BOOST_MPL_ASSERT((mpl::is_sequence)); + + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/sequence/adapt_adt_named.cpp b/src/boost/libs/fusion/test/sequence/adapt_adt_named.cpp new file mode 100644 index 00000000..19d2d8b1 --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/adapt_adt_named.cpp @@ -0,0 +1,161 @@ +/*============================================================================= + Copyright (c) 2001-2009 Joel de Guzman + + 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace ns +{ + class point + { + public: + + point() : x(0), y(0), z(0) {} + point(int in_x, int in_y, int in_z) : x(in_x), y(in_y), z(in_z) {} + + int get_x() const { return x; } + int get_y() const { return y; } + int get_z() const { return z; } + void set_x(int x_) { x = x_; } + void set_y(int y_) { y = y_; } + void set_z(int z_) { z = z_; } + + private: + + int x; + int y; + int z; + }; +} + +#if BOOST_PP_VARIADICS + +// this creates a fusion view: boost::fusion::adapted::point +BOOST_FUSION_ADAPT_ADT_NAMED( + ns::point, point, + (int, int, obj.get_x(), obj.set_x(val)) + (int, int, obj.get_y(), obj.set_y(val)) + (obj.get_z(), obj.set_z(val)) +) + +#else // BOOST_PP_VARIADICS + +// this creates a fusion view: boost::fusion::adapted::point +BOOST_FUSION_ADAPT_ADT_NAMED( + ns::point, point, + (int, int, obj.get_x(), obj.set_x(val)) + (int, int, obj.get_y(), obj.set_y(val)) + (auto, auto, obj.get_z(), obj.set_z(val)) +) + +#endif // BOOST_PP_VARIADICS + + +class empty_adt{}; +BOOST_FUSION_ADAPT_ADT_NAMED(empty_adt,renamed_empty_adt,) + +int +main() +{ + using namespace boost::fusion; + using namespace boost; + + std::cout << tuple_open('['); + std::cout << tuple_close(']'); + std::cout << tuple_delimiter(", "); + + { + BOOST_MPL_ASSERT((traits::is_view)); + BOOST_STATIC_ASSERT(traits::is_view::value); + ns::point basep(123, 456, 789); + adapted::point p(basep); + + std::cout << at_c<0>(p) << std::endl; + std::cout << at_c<1>(p) << std::endl; + std::cout << at_c<2>(p) << std::endl; + std::cout << p << std::endl; + BOOST_TEST(p == make_vector(123, 456, 789)); + + at_c<0>(p) = 6; + at_c<1>(p) = 9; + at_c<2>(p) = 12; + BOOST_TEST(p == make_vector(6, 9, 12)); + + BOOST_STATIC_ASSERT(boost::fusion::result_of::size::value == 3); + BOOST_STATIC_ASSERT(!boost::fusion::result_of::empty::value); + + BOOST_TEST(front(p) == 6); + BOOST_TEST(back(p) == 12); + } + + { + fusion::vector v1(4, 2.f, 2); + ns::point basep(5, 3, 3); + adapted::point v2(basep); + + fusion::vector v3(5, 4., 4); + BOOST_TEST(v1 < v2); + BOOST_TEST(v1 <= v2); + BOOST_TEST(v2 > v1); + BOOST_TEST(v2 >= v1); + BOOST_TEST(v2 < v3); + BOOST_TEST(v2 <= v3); + BOOST_TEST(v3 > v2); + BOOST_TEST(v3 >= v2); + } + + { + // conversion from ns::point to vector + ns::point basep(5, 3, 3); + adapted::point p(basep); + + fusion::vector v(p); + v = p; + } + + { + // conversion from ns::point to list + ns::point basep(5, 3, 3); + adapted::point p(basep); + + fusion::list l(p); + l = p; + } + + { + BOOST_MPL_ASSERT((mpl::is_sequence)); + BOOST_MPL_ASSERT((boost::is_same< + boost::fusion::result_of::value_at_c::type + , mpl::front::type>)); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/sequence/adapt_adt_named_empty.cpp b/src/boost/libs/fusion/test/sequence/adapt_adt_named_empty.cpp new file mode 100644 index 00000000..c7fa2033 --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/adapt_adt_named_empty.cpp @@ -0,0 +1,88 @@ +/*============================================================================= + Copyright (c) 2016 Kohei Takahashi + + 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +class empty_adt{}; +BOOST_FUSION_ADAPT_ADT_NAMED(::empty_adt,empty_adt,) + +int +main() +{ + using namespace boost::fusion; + using namespace boost; + + std::cout << tuple_open('['); + std::cout << tuple_close(']'); + std::cout << tuple_delimiter(", "); + + empty_adt empty; + { + BOOST_MPL_ASSERT((traits::is_view)); + BOOST_STATIC_ASSERT(traits::is_view::value); + adapted::empty_adt e(empty); + + std::cout << e << std::endl; + BOOST_TEST(e == make_vector()); + + BOOST_STATIC_ASSERT(fusion::result_of::size::value == 0); + BOOST_MPL_ASSERT((fusion::result_of::empty)); + + BOOST_MPL_ASSERT((fusion::result_of::equal_to< + fusion::result_of::begin::type, + fusion::result_of::end::type>)); + } + + { + fusion::vector<> v; + adapted::empty_adt e(empty); + BOOST_TEST(v == e); + BOOST_TEST_NOT(v != e); + BOOST_TEST_NOT(v < e); + BOOST_TEST(v <= e); + BOOST_TEST_NOT(e > v); + BOOST_TEST(e >= v); + } + + { + adapted::empty_adt e(empty); + + // conversion from empty_adt to vector + fusion::vector<> v(e); + v = e; + + // FIXME + // conversion from empty_adt to list + //fusion::list<> l(e); + //l = e; + } + + BOOST_MPL_ASSERT((mpl::is_sequence)); + + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/sequence/adapt_assoc_adt.cpp b/src/boost/libs/fusion/test/sequence/adapt_assoc_adt.cpp new file mode 100644 index 00000000..a0dc2232 --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/adapt_assoc_adt.cpp @@ -0,0 +1,164 @@ +/*============================================================================= + Copyright (c) 2010 Christopher Schmidt + + 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace ns +{ + struct x_member; + struct y_member; + struct z_member; + + struct non_member; + + class point + { + public: + + point() : x(0), y(0), z(0) {} + point(int in_x, int in_y, int in_z) : x(in_x), y(in_y), z(in_z) {} + + int get_x() const { return x; } + int get_y() const { return y; } + int get_z() const { return z; } + void set_x(int x_) { x = x_; } + void set_y(int y_) { y = y_; } + void set_z(int z_) { z = z_; } + + private: + + int x; + int y; + int z; + }; +} + +#if BOOST_PP_VARIADICS + +BOOST_FUSION_ADAPT_ASSOC_ADT( + ns::point, + (int, int, obj.get_x(), obj.set_x(val), ns::x_member) + (int, int, obj.get_y(), obj.set_y(val), ns::y_member) + (obj.get_z(), obj.set_z(val), ns::z_member) +) + +#else // BOOST_PP_VARIADICS + +BOOST_FUSION_ADAPT_ASSOC_ADT( + ns::point, + (int, int, obj.get_x(), obj.set_x(val), ns::x_member) + (int, int, obj.get_y(), obj.set_y(val), ns::y_member) + (auto, auto, obj.get_z(), obj.set_z(val), ns::z_member) +) + +#endif + +class empty_adt{}; +BOOST_FUSION_ADAPT_ASSOC_ADT(empty_adt,) + +int +main() +{ + using namespace boost::fusion; + + std::cout << tuple_open('['); + std::cout << tuple_close(']'); + std::cout << tuple_delimiter(", "); + + { + BOOST_MPL_ASSERT_NOT((traits::is_view)); + BOOST_STATIC_ASSERT(!traits::is_view::value); + ns::point p(123, 456, 789); + + std::cout << at_c<0>(p) << std::endl; + std::cout << at_c<1>(p) << std::endl; + std::cout << at_c<2>(p) << std::endl; + std::cout << p << std::endl; + BOOST_TEST(p == make_vector(123, 456, 789)); + + at_c<0>(p) = 6; + at_c<1>(p) = 9; + at_c<2>(p) = 12; + BOOST_TEST(p == make_vector(6, 9, 12)); + + BOOST_STATIC_ASSERT(boost::fusion::result_of::size::value == 3); + BOOST_STATIC_ASSERT(!boost::fusion::result_of::empty::value); + + BOOST_TEST(front(p) == 6); + BOOST_TEST(back(p) == 12); + } + + { + boost::fusion::vector v1(4, 2.f, 2); + ns::point v2(5, 3, 3); + boost::fusion::vector v3(5, 4., 4); + BOOST_TEST(v1 < v2); + BOOST_TEST(v1 <= v2); + BOOST_TEST(v2 > v1); + BOOST_TEST(v2 >= v1); + BOOST_TEST(v2 < v3); + BOOST_TEST(v2 <= v3); + BOOST_TEST(v3 > v2); + BOOST_TEST(v3 >= v2); + } + + { + // conversion from ns::point to vector + ns::point p(5, 3, 3); + boost::fusion::vector v(p); + v = p; + } + + { + // conversion from ns::point to list + ns::point p(5, 3, 3); + boost::fusion::list l(p); + l = p; + } + + { + BOOST_MPL_ASSERT((boost::mpl::is_sequence)); + BOOST_MPL_ASSERT((boost::is_same< + boost::fusion::result_of::value_at_c::type + , boost::mpl::front::type>)); + } + + { + // assoc stuff + BOOST_MPL_ASSERT((boost::fusion::result_of::has_key)); + BOOST_MPL_ASSERT((boost::fusion::result_of::has_key)); + BOOST_MPL_ASSERT((boost::fusion::result_of::has_key)); + BOOST_MPL_ASSERT((boost::mpl::not_ >)); + + + BOOST_MPL_ASSERT((boost::is_same::type, int>)); + BOOST_MPL_ASSERT((boost::is_same::type, int>)); + BOOST_MPL_ASSERT((boost::is_same::type, int>)); + + ns::point p(5, 3, 1); + + BOOST_TEST(at_key(p) == 5); + BOOST_TEST(at_key(p) == 3); + BOOST_TEST(at_key(p) == 1); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/sequence/adapt_assoc_adt_empty.cpp b/src/boost/libs/fusion/test/sequence/adapt_assoc_adt_empty.cpp new file mode 100644 index 00000000..26cd9857 --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/adapt_assoc_adt_empty.cpp @@ -0,0 +1,89 @@ +/*============================================================================= + Copyright (c) 2016 Kohei Takahashi + + 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +class empty_adt{}; +BOOST_FUSION_ADAPT_ASSOC_ADT(empty_adt,) + +int +main() +{ + using namespace boost::fusion; + using namespace boost; + + std::cout << tuple_open('['); + std::cout << tuple_close(']'); + std::cout << tuple_delimiter(", "); + + { + BOOST_MPL_ASSERT_NOT((traits::is_view)); + BOOST_STATIC_ASSERT(!traits::is_view::value); + empty_adt e; + + std::cout << e << std::endl; + BOOST_TEST(e == make_vector()); + + BOOST_STATIC_ASSERT(fusion::result_of::size::value == 0); + BOOST_MPL_ASSERT((fusion::result_of::empty)); + + BOOST_MPL_ASSERT((fusion::result_of::equal_to< + fusion::result_of::begin::type, + fusion::result_of::end::type>)); + } + + { + fusion::vector<> v; + empty_adt e; + BOOST_TEST(v == e); + BOOST_TEST_NOT(e != v); + BOOST_TEST_NOT(v < e); + BOOST_TEST(v <= e); + BOOST_TEST_NOT(e > v); + BOOST_TEST(e >= v); + } + + { + empty_adt e; + + // conversion from empty_adt to vector + fusion::vector<> v(e); + v = e; + + // FIXME + // conversion from empty_adt to list + //fusion::list<> l(e); + //l = e; + } + + BOOST_MPL_ASSERT((mpl::is_sequence)); + BOOST_MPL_ASSERT_NOT((fusion::result_of::has_key)); + BOOST_MPL_ASSERT_NOT((fusion::result_of::has_key)); + + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/sequence/adapt_assoc_adt_named.cpp b/src/boost/libs/fusion/test/sequence/adapt_assoc_adt_named.cpp new file mode 100644 index 00000000..ecdd9028 --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/adapt_assoc_adt_named.cpp @@ -0,0 +1,159 @@ +/*============================================================================= + Copyright (c) 2010 Christopher Schmidt + + 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace ns +{ + struct x_member; + struct y_member; + struct z_member; + + class point + { + public: + + point() : x(0), y(0) {} + point(int in_x, int in_y) : x(in_x), y(in_y) {} + + int get_x() const { return x; } + int get_y() const { return y; } + void set_x(int x_) { x = x_; } + void set_y(int y_) { y = y_; } + + private: + + int x; + int y; + }; +} + +#if BOOST_PP_VARIADICS + + BOOST_FUSION_ADAPT_ASSOC_ADT_NAMED( + ns::point, + point, + (obj.get_x(), obj.set_x(val), ns::x_member) + (int, int, obj.get_y(), obj.set_y(val), ns::y_member) + ) + +#else // BOOST_PP_VARIADICS + + BOOST_FUSION_ADAPT_ASSOC_ADT_NAMED( + ns::point, + point, + (auto, auto, obj.get_x(), obj.set_x(val), ns::x_member) + (int, int, obj.get_y(), obj.set_y(val), ns::y_member) + ) + +#endif + + +class empty_adt{}; +BOOST_FUSION_ADAPT_ASSOC_ADT_NAMED(empty_adt, renamed_empty_adt,) + +int +main() +{ + using namespace boost::fusion; + + std::cout << tuple_open('['); + std::cout << tuple_close(']'); + std::cout << tuple_delimiter(", "); + + { + BOOST_MPL_ASSERT((traits::is_view)); + BOOST_STATIC_ASSERT(traits::is_view::value); + ns::point basep(123, 456); + adapted::point p(basep); + + std::cout << at_c<0>(p) << std::endl; + std::cout << at_c<1>(p) << std::endl; + std::cout << p << std::endl; + BOOST_TEST(p == make_vector(123, 456)); + + at_c<0>(p) = 6; + at_c<1>(p) = 9; + BOOST_TEST(p == make_vector(6, 9)); + + BOOST_STATIC_ASSERT(boost::fusion::result_of::size::value == 2); + BOOST_STATIC_ASSERT(!boost::fusion::result_of::empty::value); + + BOOST_TEST(front(p) == 6); + BOOST_TEST(back(p) == 9); + } + + { + boost::fusion::vector v1(4, 2.f); + ns::point basev2(5, 3); + adapted::point v2(basev2); + boost::fusion::vector v3(5, 4.); + BOOST_TEST(v1 < v2); + BOOST_TEST(v1 <= v2); + BOOST_TEST(v2 > v1); + BOOST_TEST(v2 >= v1); + BOOST_TEST(v2 < v3); + BOOST_TEST(v2 <= v3); + BOOST_TEST(v3 > v2); + BOOST_TEST(v3 >= v2); + } + + { + // conversion from adapted::point to vector + ns::point basep(5, 3); + adapted::point p(basep); + boost::fusion::vector v(p); + v = p; + } + + { + // conversion from adated::point to list + ns::point basep(5, 3); + adapted::point p(basep); + boost::fusion::list l(p); + l = p; + } + + { + BOOST_MPL_ASSERT((boost::mpl::is_sequence)); + BOOST_MPL_ASSERT((boost::is_same< + boost::fusion::result_of::value_at_c::type + , boost::mpl::front::type>)); + } + + { + // assoc stuff + BOOST_MPL_ASSERT((boost::fusion::result_of::has_key)); + BOOST_MPL_ASSERT((boost::fusion::result_of::has_key)); + BOOST_MPL_ASSERT((boost::mpl::not_ >)); + + BOOST_MPL_ASSERT((boost::is_same::type, int>)); + BOOST_MPL_ASSERT((boost::is_same::type, int>)); + + ns::point basep(5, 3); + adapted::point p(basep); + + BOOST_TEST(at_key(p) == 5); + BOOST_TEST(at_key(p) == 3); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/sequence/adapt_assoc_adt_named_empty.cpp b/src/boost/libs/fusion/test/sequence/adapt_assoc_adt_named_empty.cpp new file mode 100644 index 00000000..e2e26800 --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/adapt_assoc_adt_named_empty.cpp @@ -0,0 +1,90 @@ +/*============================================================================= + Copyright (c) 2016 Kohei Takahashi + + 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +class empty_adt{}; +BOOST_FUSION_ADAPT_ASSOC_ADT_NAMED(::empty_adt,empty_adt,) + +int +main() +{ + using namespace boost::fusion; + using namespace boost; + + std::cout << tuple_open('['); + std::cout << tuple_close(']'); + std::cout << tuple_delimiter(", "); + + empty_adt empty; + { + BOOST_MPL_ASSERT((traits::is_view)); + BOOST_STATIC_ASSERT(traits::is_view::value); + adapted::empty_adt e(empty); + + std::cout << e << std::endl; + BOOST_TEST(e == make_vector()); + + BOOST_STATIC_ASSERT(fusion::result_of::size::value == 0); + BOOST_MPL_ASSERT((fusion::result_of::empty)); + + BOOST_MPL_ASSERT((fusion::result_of::equal_to< + fusion::result_of::begin::type, + fusion::result_of::end::type>)); + } + + { + fusion::vector<> v; + adapted::empty_adt e(empty); + BOOST_TEST(v == e); + BOOST_TEST_NOT(e != v); + BOOST_TEST_NOT(v < e); + BOOST_TEST(v <= e); + BOOST_TEST_NOT(e > v); + BOOST_TEST(e >= v); + } + + { + adapted::empty_adt e(empty); + + // conversion from empty_adt to vector + fusion::vector<> v(e); + v = e; + + // FIXME + // conversion from empty_adt to list + //fusion::list<> l(e); + //l = e; + } + + BOOST_MPL_ASSERT((mpl::is_sequence)); + BOOST_MPL_ASSERT_NOT((fusion::result_of::has_key)); + BOOST_MPL_ASSERT_NOT((fusion::result_of::has_key)); + + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/sequence/adapt_assoc_struct.cpp b/src/boost/libs/fusion/test/sequence/adapt_assoc_struct.cpp new file mode 100644 index 00000000..6266e95f --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/adapt_assoc_struct.cpp @@ -0,0 +1,168 @@ +/*============================================================================= + Copyright (c) 2001-2007 Joel de Guzman + Copyright (c) 2005-2007 Dan Marsden + + 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace ns +{ + struct x_member; + struct y_member; + struct z_member; + struct non_member; + + struct point + { + int x; + int y; + int z; + }; +} + +#if BOOST_PP_VARIADICS + BOOST_FUSION_ADAPT_ASSOC_STRUCT( + ns::point, + (x, ns::x_member) + (auto, y, ns::y_member) + (int, z, ns::z_member) + ) + +#else // BOOST_PP_VARIADICS + BOOST_FUSION_ADAPT_ASSOC_STRUCT( + ns::point, + (auto, x, ns::x_member) + (auto, y, ns::y_member) + (int, z, ns::z_member) + ) + +#endif + +struct empty_struct {}; +BOOST_FUSION_ADAPT_ASSOC_STRUCT(empty_struct,) + +int +main() +{ + using namespace boost::fusion; + using namespace boost; + + std::cout << tuple_open('['); + std::cout << tuple_close(']'); + std::cout << tuple_delimiter(", "); + + { + BOOST_MPL_ASSERT_NOT((traits::is_view)); + BOOST_STATIC_ASSERT(!traits::is_view::value); + ns::point p = {123, 456, 789}; + + std::cout << at_c<0>(p) << std::endl; + std::cout << at_c<1>(p) << std::endl; + std::cout << at_c<2>(p) << std::endl; + std::cout << p << std::endl; + BOOST_TEST(p == make_vector(123, 456, 789)); + + at_c<0>(p) = 6; + at_c<1>(p) = 9; + at_c<2>(p) = 12; + BOOST_TEST(p == make_vector(6, 9, 12)); + + BOOST_STATIC_ASSERT(boost::fusion::result_of::size::value == 3); + BOOST_STATIC_ASSERT(!boost::fusion::result_of::empty::value); + + BOOST_TEST(front(p) == 6); + BOOST_TEST(back(p) == 12); + } + + { + fusion::vector v1(4, 2.f, 2); + ns::point v2 = {5, 3, 3}; + fusion::vector v3(5, 4., 4); + BOOST_TEST(v1 < v2); + BOOST_TEST(v1 <= v2); + BOOST_TEST(v2 > v1); + BOOST_TEST(v2 >= v1); + BOOST_TEST(v2 < v3); + BOOST_TEST(v2 <= v3); + BOOST_TEST(v3 > v2); + BOOST_TEST(v3 >= v2); + } + + { + // conversion from ns::point to vector + ns::point p = {5, 3, 3}; + fusion::vector v(p); + v = p; + } + + { + // conversion from ns::point to list + ns::point p = {5, 3, 3}; + fusion::list l(p); + l = p; + } + + { + // assoc stuff + BOOST_MPL_ASSERT((boost::fusion::result_of::has_key)); + BOOST_MPL_ASSERT((boost::fusion::result_of::has_key)); + BOOST_MPL_ASSERT((boost::fusion::result_of::has_key)); + BOOST_MPL_ASSERT((mpl::not_ >)); + + BOOST_MPL_ASSERT((boost::is_same::type, int>)); + BOOST_MPL_ASSERT((boost::is_same::type, int>)); + BOOST_MPL_ASSERT((boost::is_same::type, int>)); + + ns::point p = {5, 3, 9}; + + BOOST_TEST(at_key(p) == 5); + BOOST_TEST(at_key(p) == 3); + BOOST_TEST(at_key(p) == 9); + } + + { + BOOST_MPL_ASSERT((mpl::is_sequence)); + BOOST_MPL_ASSERT((boost::is_same< + boost::fusion::result_of::value_at_c::type + , mpl::front::type>)); + BOOST_MPL_ASSERT((boost::is_same< + boost::fusion::result_of::value_at_c::type + , mpl::back::type>)); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/sequence/adapt_assoc_struct_empty.cpp b/src/boost/libs/fusion/test/sequence/adapt_assoc_struct_empty.cpp new file mode 100644 index 00000000..c7cadf94 --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/adapt_assoc_struct_empty.cpp @@ -0,0 +1,89 @@ +/*============================================================================= + Copyright (c) 2016 Kohei Takahashi + + 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +class empty_struct{}; +BOOST_FUSION_ADAPT_ASSOC_STRUCT(empty_struct,) + +int +main() +{ + using namespace boost::fusion; + using namespace boost; + + std::cout << tuple_open('['); + std::cout << tuple_close(']'); + std::cout << tuple_delimiter(", "); + + { + BOOST_MPL_ASSERT_NOT((traits::is_view)); + BOOST_STATIC_ASSERT(!traits::is_view::value); + empty_struct e; + + std::cout << e << std::endl; + BOOST_TEST(e == make_vector()); + + BOOST_STATIC_ASSERT(fusion::result_of::size::value == 0); + BOOST_MPL_ASSERT((fusion::result_of::empty)); + + BOOST_MPL_ASSERT((fusion::result_of::equal_to< + fusion::result_of::begin::type, + fusion::result_of::end::type>)); + } + + { + fusion::vector<> v; + empty_struct e; + BOOST_TEST(v <= e); + BOOST_TEST_NOT(e > v); + BOOST_TEST_NOT(v < e); + BOOST_TEST(v <= e); + BOOST_TEST_NOT(e > v); + BOOST_TEST(e >= v); + } + + { + empty_struct e; + + // conversion from empty_struct to vector + fusion::vector<> v(e); + v = e; + + // FIXME + // conversion from empty_struct to list + //fusion::list<> l(e); + //l = e; + } + + BOOST_MPL_ASSERT((mpl::is_sequence)); + BOOST_MPL_ASSERT_NOT((fusion::result_of::has_key)); + BOOST_MPL_ASSERT_NOT((fusion::result_of::has_key)); + + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/sequence/adapt_assoc_struct_named.cpp b/src/boost/libs/fusion/test/sequence/adapt_assoc_struct_named.cpp new file mode 100644 index 00000000..96606787 --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/adapt_assoc_struct_named.cpp @@ -0,0 +1,139 @@ +/*============================================================================= + Copyright (c) 2010 Christopher Schmidt + + 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace ns +{ + struct x_member; + struct y_member; + struct z_member; + + struct point + { + int x; + int y; + }; +} + + +#if BOOST_PP_VARIADICS + + BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED( + ns::point, + point, + (x, ns::x_member) + (auto, y, ns::y_member) + ) + +#else // BOOST_PP_VARIADICS + + BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED( + ns::point, + point, + (int, x, ns::x_member) + (auto, y, ns::y_member) + ) + +#endif + +struct empty_struct {}; +BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED(empty_struct, renamed_empty_struct,) + +int +main() +{ + using namespace boost::fusion; + + std::cout << tuple_open('['); + std::cout << tuple_close(']'); + std::cout << tuple_delimiter(", "); + + { + BOOST_MPL_ASSERT((traits::is_view)); + BOOST_STATIC_ASSERT(traits::is_view::value); + ns::point basep = {123, 456}; + adapted::point p(basep); + + std::cout << at_c<0>(p) << std::endl; + std::cout << at_c<1>(p) << std::endl; + std::cout << p << std::endl; + BOOST_TEST(p == make_vector(123, 456)); + + at_c<0>(p) = 6; + at_c<1>(p) = 9; + BOOST_TEST(p == make_vector(6, 9)); + + BOOST_STATIC_ASSERT(boost::fusion::result_of::size::value == 2); + BOOST_STATIC_ASSERT(!boost::fusion::result_of::empty::value); + + BOOST_TEST(front(p) == 6); + BOOST_TEST(back(p) == 9); + } + + { + vector v1(4, 2.f); + ns::point basev2 = {5, 3}; + adapted::point v2(basev2); + + vector v3(5, 4.); + BOOST_TEST(v1 < v2); + BOOST_TEST(v1 <= v2); + BOOST_TEST(v2 > v1); + BOOST_TEST(v2 >= v1); + BOOST_TEST(v2 < v3); + BOOST_TEST(v2 <= v3); + BOOST_TEST(v3 > v2); + BOOST_TEST(v3 >= v2); + } + + { + // conversion from adapted::point to vector + ns::point basep = {5, 3}; + adapted::point p(basep); + vector v(p); + v = p; + } + + { + // conversion from adapted::point to list + ns::point basep = {5, 3}; + adapted::point p(basep); + list l(p); + l = p; + } + + { + // assoc stuff + BOOST_MPL_ASSERT((boost::fusion::result_of::has_key)); + BOOST_MPL_ASSERT((boost::fusion::result_of::has_key)); + BOOST_MPL_ASSERT((boost::mpl::not_ >)); + + BOOST_MPL_ASSERT((boost::is_same::type, int>)); + BOOST_MPL_ASSERT((boost::is_same::type, int>)); + + ns::point basep = {5, 3}; + adapted::point p(basep); + + BOOST_TEST(at_key(p) == 5); + BOOST_TEST(at_key(p) == 3); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/sequence/adapt_assoc_struct_named_empty.cpp b/src/boost/libs/fusion/test/sequence/adapt_assoc_struct_named_empty.cpp new file mode 100644 index 00000000..a1783fd3 --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/adapt_assoc_struct_named_empty.cpp @@ -0,0 +1,90 @@ +/*============================================================================= + Copyright (c) 2016 Kohei Takahashi + + 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +class empty_struct{}; +BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED(::empty_struct,empty_struct,) + +int +main() +{ + using namespace boost::fusion; + using namespace boost; + + std::cout << tuple_open('['); + std::cout << tuple_close(']'); + std::cout << tuple_delimiter(", "); + + empty_struct empty; + { + BOOST_MPL_ASSERT((traits::is_view)); + BOOST_STATIC_ASSERT(traits::is_view::value); + adapted::empty_struct e(empty); + + std::cout << e << std::endl; + BOOST_TEST(e == make_vector()); + + BOOST_STATIC_ASSERT(fusion::result_of::size::value == 0); + BOOST_MPL_ASSERT((fusion::result_of::empty)); + + BOOST_MPL_ASSERT((fusion::result_of::equal_to< + fusion::result_of::begin::type, + fusion::result_of::end::type>)); + } + + { + fusion::vector<> v; + adapted::empty_struct e(empty); + BOOST_TEST(v <= e); + BOOST_TEST_NOT(e > v); + BOOST_TEST_NOT(v < e); + BOOST_TEST(v <= e); + BOOST_TEST_NOT(e > v); + BOOST_TEST(e >= v); + } + + { + adapted::empty_struct e(empty); + + // conversion from empty_struct to vector + fusion::vector<> v(e); + v = e; + + // FIXME + // conversion from empty_struct to list + //fusion::list<> l(e); + //l = e; + } + + BOOST_MPL_ASSERT((mpl::is_sequence)); + BOOST_MPL_ASSERT_NOT((fusion::result_of::has_key)); + BOOST_MPL_ASSERT_NOT((fusion::result_of::has_key)); + + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/sequence/adapt_assoc_tpl_adt.cpp b/src/boost/libs/fusion/test/sequence/adapt_assoc_tpl_adt.cpp new file mode 100644 index 00000000..f416f46a --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/adapt_assoc_tpl_adt.cpp @@ -0,0 +1,177 @@ +/*============================================================================= + Copyright (c) 2010 Christopher Schmidt + + 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace ns +{ + struct x_member; + struct y_member; + struct z_member; + + struct non_member; + + template + class point + { + public: + + point() : x(0), y(0), z(0) {} + point(X in_x, Y in_y, Z in_z) : x(in_x), y(in_y), z(in_z) {} + + X get_x() const { return x; } + Y get_y() const { return y; } + Z get_z() const { return z; } + void set_x(X x_) { x = x_; } + void set_y(Y y_) { y = y_; } + void set_z(Z z_) { z = z_; } + + private: + + X x; + Y y; + Z z; + }; +} + +#if BOOST_PP_VARIADICS +BOOST_FUSION_ADAPT_ASSOC_TPL_ADT( + (X)(Y)(Z), + (ns::point)(X)(Y)(Z), + (X, X, obj.get_x(), obj.set_x(val), ns::x_member) + (Y, Y, obj.get_y(), obj.set_y(val), ns::y_member) + (obj.get_z(), obj.set_z(val), ns::z_member) +) + +#else // BOOST_PP_VARIADICS +BOOST_FUSION_ADAPT_ASSOC_TPL_ADT( + (X)(Y)(Z), + (ns::point)(X)(Y)(Z), + (X, X, obj.get_x(), obj.set_x(val), ns::x_member) + (Y, Y, obj.get_y(), obj.set_y(val), ns::y_member) + (auto, auto, obj.get_z(), obj.set_z(val), ns::z_member) +) + +#endif + +template +class empty_adt_templated_factory { + + TypeToConstruct operator()() { + return TypeToConstruct(); + } + +}; + +BOOST_FUSION_ADAPT_ASSOC_TPL_ADT( + (TypeToConstruct), + (empty_adt_templated_factory)(TypeToConstruct), +) + +int +main() +{ + using namespace boost::fusion; + + typedef ns::point point; + + std::cout << tuple_open('['); + std::cout << tuple_close(']'); + std::cout << tuple_delimiter(", "); + + { + BOOST_MPL_ASSERT_NOT((traits::is_view)); + BOOST_STATIC_ASSERT(!traits::is_view::value); + point p(123, 456, 789); + + std::cout << at_c<0>(p) << std::endl; + std::cout << at_c<1>(p) << std::endl; + std::cout << at_c<2>(p) << std::endl; + std::cout << p << std::endl; + BOOST_TEST(p == make_vector(123, 456, 789)); + + at_c<0>(p) = 6; + at_c<1>(p) = 9; + at_c<2>(p) = 12; + BOOST_TEST(p == make_vector(6, 9, 12)); + + BOOST_STATIC_ASSERT(boost::fusion::result_of::size::value == 3); + BOOST_STATIC_ASSERT(!boost::fusion::result_of::empty::value); + + BOOST_TEST(front(p) == 6); + BOOST_TEST(back(p) == 12); + } + + { + boost::fusion::vector v1(4, 2.f, 2); + point v2(5, 3, 3); + boost::fusion::vector v3(5, 4., 4); + BOOST_TEST(v1 < v2); + BOOST_TEST(v1 <= v2); + BOOST_TEST(v2 > v1); + BOOST_TEST(v2 >= v1); + BOOST_TEST(v2 < v3); + BOOST_TEST(v2 <= v3); + BOOST_TEST(v3 > v2); + BOOST_TEST(v3 >= v2); + } + + { + // conversion from point to vector + point p(5, 3, 3); + boost::fusion::vector v(p); + v = p; + } + + { + // conversion from point to list + point p(5, 3, 3); + boost::fusion::list l(p); + l = p; + } + + { + BOOST_MPL_ASSERT((boost::mpl::is_sequence)); + BOOST_MPL_ASSERT((boost::is_same< + boost::fusion::result_of::value_at_c::type + , boost::mpl::front::type>)); + } + + { + // assoc stuff + BOOST_MPL_ASSERT((boost::fusion::result_of::has_key)); + BOOST_MPL_ASSERT((boost::fusion::result_of::has_key)); + BOOST_MPL_ASSERT((boost::fusion::result_of::has_key)); + BOOST_MPL_ASSERT((boost::mpl::not_ >)); + + BOOST_MPL_ASSERT((boost::is_same::type, int>)); + BOOST_MPL_ASSERT((boost::is_same::type, int>)); + BOOST_MPL_ASSERT((boost::is_same::type, long>)); + + point p(5, 3, 1); + + BOOST_TEST(at_key(p) == 5); + BOOST_TEST(at_key(p) == 3); + BOOST_TEST(at_key(p) == 1); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/sequence/adapt_assoc_tpl_adt_empty.cpp b/src/boost/libs/fusion/test/sequence/adapt_assoc_tpl_adt_empty.cpp new file mode 100644 index 00000000..f38ba7ac --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/adapt_assoc_tpl_adt_empty.cpp @@ -0,0 +1,89 @@ +/*============================================================================= + Copyright (c) 2016 Kohei Takahashi + + 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +template +class empty_adt{}; +BOOST_FUSION_ADAPT_ASSOC_TPL_ADT((T), (empty_adt)(T),) + +int +main() +{ + using namespace boost::fusion; + using namespace boost; + + std::cout << tuple_open('['); + std::cout << tuple_close(']'); + std::cout << tuple_delimiter(", "); + + { + BOOST_MPL_ASSERT_NOT((traits::is_view >)); + empty_adt e; + + std::cout << e << std::endl; + BOOST_TEST(e == make_vector()); + + BOOST_STATIC_ASSERT(fusion::result_of::size >::value == 0); + BOOST_MPL_ASSERT((fusion::result_of::empty >)); + + BOOST_MPL_ASSERT((fusion::result_of::equal_to< + fusion::result_of::begin >::type, + fusion::result_of::end >::type>)); + } + + { + fusion::vector<> v; + empty_adt e; + BOOST_TEST(v <= e); + BOOST_TEST_NOT(e > v); + BOOST_TEST_NOT(v < e); + BOOST_TEST(v <= e); + BOOST_TEST_NOT(e > v); + BOOST_TEST(e >= v); + } + + { + empty_adt e; + + // conversion from empty_adt to vector + fusion::vector<> v(e); + v = e; + + // FIXME + // conversion from empty_adt to list + //fusion::list<> l(e); + //l = e; + } + + BOOST_MPL_ASSERT((mpl::is_sequence >)); + BOOST_MPL_ASSERT_NOT((fusion::result_of::has_key, void>)); + BOOST_MPL_ASSERT_NOT((fusion::result_of::has_key, int>)); + + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/sequence/adapt_assoc_tpl_struct.cpp b/src/boost/libs/fusion/test/sequence/adapt_assoc_tpl_struct.cpp new file mode 100644 index 00000000..49f42c5d --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/adapt_assoc_tpl_struct.cpp @@ -0,0 +1,168 @@ +/*============================================================================= + Copyright (c) 2010 Christopher Schmidt + + 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace ns +{ + struct x_member; + struct y_member; + struct z_member; + + struct non_member; + + template + struct point + { + X x; + Y y; + Z z; + }; +} + +#if BOOST_PP_VARIADICS + BOOST_FUSION_ADAPT_ASSOC_TPL_STRUCT( + (X)(Y)(Z), + (ns::point)(X)(Y)(Z), + (int, x, ns::x_member) + (auto, y, ns::y_member) + (z, ns::z_member) + ) + +#else // BOOST_PP_VARIADICS + BOOST_FUSION_ADAPT_ASSOC_TPL_STRUCT( + (X)(Y)(Z), + (ns::point)(X)(Y)(Z), + (int, x, ns::x_member) + (Y, y, ns::y_member) + (auto, z, ns::z_member) + ) +#endif + +template +struct empty_struct_templated_factory { + + TypeToConstruct operator()() { + return TypeToConstruct(); + } + +}; + +BOOST_FUSION_ADAPT_ASSOC_TPL_STRUCT( + (TypeToConstruct), + (empty_struct_templated_factory)(TypeToConstruct), +) + +int +main() +{ + using namespace boost::fusion; + + typedef ns::point point; + + std::cout << tuple_open('['); + std::cout << tuple_close(']'); + std::cout << tuple_delimiter(", "); + + { + BOOST_MPL_ASSERT_NOT((traits::is_view)); + BOOST_STATIC_ASSERT(!traits::is_view::value); + point p = {123, 456, 789.43f}; + + std::cout << at_c<0>(p) << std::endl; + std::cout << at_c<1>(p) << std::endl; + std::cout << at_c<2>(p) << std::endl; + std::cout << p << std::endl; + BOOST_TEST(p == make_vector(123, 456, 789.43f)); + + at_c<0>(p) = 6; + at_c<1>(p) = 9; + at_c<2>(p) = 12; + BOOST_TEST(p == make_vector(6, 9, 12)); + + BOOST_STATIC_ASSERT(boost::fusion::result_of::size::value == 3); + BOOST_STATIC_ASSERT(!boost::fusion::result_of::empty::value); + + BOOST_TEST(front(p) == 6); + BOOST_TEST(back(p) == 12); + } + + { + vector v1(4, 2.f, 2); + point v2 = {5, 3, 3.f}; + vector v3(5, 4., 4.13f); + BOOST_TEST(v1 < v2); + BOOST_TEST(v1 <= v2); + BOOST_TEST(v2 > v1); + BOOST_TEST(v2 >= v1); + BOOST_TEST(v2 < v3); + BOOST_TEST(v2 <= v3); + BOOST_TEST(v3 > v2); + BOOST_TEST(v3 >= v2); + } + + { + // conversion from point to vector + point p = {5, 3, 3.f}; + vector v(p); + v = p; + } + + { + // conversion from point to list + point p = {5, 3, 3.f}; + list l(p); + l = p; + } + + { + // assoc stuff + BOOST_MPL_ASSERT((boost::fusion::result_of::has_key)); + BOOST_MPL_ASSERT((boost::fusion::result_of::has_key)); + BOOST_MPL_ASSERT((boost::fusion::result_of::has_key)); + BOOST_MPL_ASSERT((boost::mpl::not_ >)); + + BOOST_MPL_ASSERT((boost::is_same::type, int>)); + BOOST_MPL_ASSERT((boost::is_same::type, int>)); + BOOST_MPL_ASSERT((boost::is_same::type, float>)); + + point p = {5, 3, 9.f}; + + BOOST_TEST(at_key(p) == 5); + BOOST_TEST(at_key(p) == 3); + BOOST_TEST(at_key(p) == 9); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/sequence/adapt_assoc_tpl_struct_empty.cpp b/src/boost/libs/fusion/test/sequence/adapt_assoc_tpl_struct_empty.cpp new file mode 100644 index 00000000..42795c41 --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/adapt_assoc_tpl_struct_empty.cpp @@ -0,0 +1,89 @@ +/*============================================================================= + Copyright (c) 2016 Kohei Takahashi + + 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +template +class empty_struct{}; +BOOST_FUSION_ADAPT_ASSOC_TPL_STRUCT((T), (empty_struct)(T),) + +int +main() +{ + using namespace boost::fusion; + using namespace boost; + + std::cout << tuple_open('['); + std::cout << tuple_close(']'); + std::cout << tuple_delimiter(", "); + + { + BOOST_MPL_ASSERT_NOT((traits::is_view >)); + empty_struct e; + + std::cout << e << std::endl; + BOOST_TEST(e == make_vector()); + + BOOST_STATIC_ASSERT(fusion::result_of::size >::value == 0); + BOOST_MPL_ASSERT((fusion::result_of::empty >)); + + BOOST_MPL_ASSERT((fusion::result_of::equal_to< + fusion::result_of::begin >::type, + fusion::result_of::end >::type>)); + } + + { + fusion::vector<> v; + empty_struct e; + BOOST_TEST(v <= e); + BOOST_TEST_NOT(e > v); + BOOST_TEST_NOT(v < e); + BOOST_TEST(v <= e); + BOOST_TEST_NOT(e > v); + BOOST_TEST(e >= v); + } + + { + empty_struct e; + + // conversion from empty_struct to vector + fusion::vector<> v(e); + v = e; + + // FIXME + // conversion from empty_struct to list + //fusion::list<> l(e); + //l = e; + } + + BOOST_MPL_ASSERT((mpl::is_sequence >)); + BOOST_MPL_ASSERT_NOT((fusion::result_of::has_key, void>)); + BOOST_MPL_ASSERT_NOT((fusion::result_of::has_key, int>)); + + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/sequence/adapt_struct.cpp b/src/boost/libs/fusion/test/sequence/adapt_struct.cpp new file mode 100644 index 00000000..3518ff41 --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/adapt_struct.cpp @@ -0,0 +1,271 @@ +/*============================================================================= + Copyright (c) 2001-2007 Joel de Guzman + + 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace namespaced_type { + typedef int integer; +} + +namespace ns +{ + struct point + { + int x; + int y; + namespaced_type::integer z; + }; + +#if !BOOST_WORKAROUND(__GNUC__,<4) + struct point_with_private_attributes + { + friend struct boost::fusion::extension::access; + + private: + int x; + int y; + int z; + + public: + point_with_private_attributes(int x, int y, int z):x(x),y(y),z(z) + {} + }; +#endif + + struct foo + { + int x; + }; + + struct bar + { + foo foo_; + int y; + }; + + + // Testing non-constexpr compatible types + struct employee { + std::string name; + std::string nickname; + + employee(std::string name, std::string nickname) + : name(name), nickname(nickname) + {} + }; +} + +#if BOOST_PP_VARIADICS + + BOOST_FUSION_ADAPT_STRUCT( + ns::point, + x, + y, + z + ) + +# if !BOOST_WORKAROUND(__GNUC__,<4) + BOOST_FUSION_ADAPT_STRUCT( + ns::point_with_private_attributes, + x, + y, + z + ) +# endif + + struct s { int m; }; + BOOST_FUSION_ADAPT_STRUCT(s, m) + + BOOST_FUSION_ADAPT_STRUCT( + ns::bar, + foo_.x, // test that adapted members can actually be expressions + (auto , y) + ) + + BOOST_FUSION_ADAPT_STRUCT( + ns::employee, + name, + nickname + ) + + +#else // BOOST_PP_VARIADICS + + BOOST_FUSION_ADAPT_STRUCT( + ns::point, + (int, x) + (auto, y) + (namespaced_type::integer, z) + ) + +# if !BOOST_WORKAROUND(__GNUC__,<4) + BOOST_FUSION_ADAPT_STRUCT( + ns::point_with_private_attributes, + (int, x) + (int, y) + (auto, z) + ) +# endif + + struct s { int m; }; + BOOST_FUSION_ADAPT_STRUCT(s, (auto, m)) + + BOOST_FUSION_ADAPT_STRUCT( + ns::bar, + (auto, foo_.x) // test that adapted members can actually be expressions + (BOOST_FUSION_ADAPT_AUTO, y) // Mixing auto & BOOST_FUSION_ADAPT_AUTO + // to test backward compatibility + ) + + BOOST_FUSION_ADAPT_STRUCT( + ns::employee, + (std::string, name) + (BOOST_FUSION_ADAPT_AUTO, nickname) + ) + +#endif + +struct empty_struct {}; +BOOST_FUSION_ADAPT_STRUCT(empty_struct,) + +int +main() +{ + using namespace boost::fusion; + using namespace boost; + using ns::point; + + std::cout << tuple_open('['); + std::cout << tuple_close(']'); + std::cout << tuple_delimiter(", "); + + { + BOOST_MPL_ASSERT_NOT((traits::is_view)); + BOOST_STATIC_ASSERT(!traits::is_view::value); + point p = {123, 456, 789}; + + std::cout << at_c<0>(p) << std::endl; + std::cout << at_c<1>(p) << std::endl; + std::cout << at_c<2>(p) << std::endl; + std::cout << p << std::endl; + BOOST_TEST(p == make_vector(123, 456, 789)); + + at_c<0>(p) = 6; + at_c<1>(p) = 9; + at_c<2>(p) = 12; + BOOST_TEST(p == make_vector(6, 9, 12)); + + BOOST_STATIC_ASSERT(boost::fusion::result_of::size::value == 3); + BOOST_STATIC_ASSERT(!boost::fusion::result_of::empty::value); + + BOOST_TEST(front(p) == 6); + BOOST_TEST(back(p) == 12); + } + + { + vector v1(4, 2.f, 2); + point v2 = {5, 3, 3}; + vector v3(5, 4., 4); + BOOST_TEST(v1 < v2); + BOOST_TEST(v1 <= v2); + BOOST_TEST(v2 > v1); + BOOST_TEST(v2 >= v1); + BOOST_TEST(v2 < v3); + BOOST_TEST(v2 <= v3); + BOOST_TEST(v3 > v2); + BOOST_TEST(v3 >= v2); + } + + { + // conversion from point to vector + point p = {5, 3, 3}; + vector v(p); + v = p; + } + + { + // conversion from point to list + point p = {5, 3, 3}; + list l(p); + l = p; + } + + { // begin/end + using namespace boost::fusion; + using boost::is_same; + + typedef boost::fusion::result_of::begin::type b; + typedef boost::fusion::result_of::end::type e; + // this fails + BOOST_MPL_ASSERT((is_same::type, e>)); + } + + { + BOOST_MPL_ASSERT((mpl::is_sequence)); + BOOST_MPL_ASSERT((boost::is_same< + boost::fusion::result_of::value_at_c::type + , mpl::front::type>)); + } + +#if !BOOST_WORKAROUND(__GNUC__,<4) + { + ns::point_with_private_attributes p(123, 456, 789); + + std::cout << at_c<0>(p) << std::endl; + std::cout << at_c<1>(p) << std::endl; + std::cout << at_c<2>(p) << std::endl; + std::cout << p << std::endl; + BOOST_TEST(p == make_vector(123, 456, 789)); + } +#endif + + { + fusion::vector v1(4, 2.f); + ns::bar v2 = {{5}, 3}; + BOOST_TEST(v1 < v2); + BOOST_TEST(v1 <= v2); + BOOST_TEST(v2 > v1); + BOOST_TEST(v2 >= v1); + } + + { + ns::employee emp("John Doe", "jdoe"); + std::cout << at_c<0>(emp) << std::endl; + std::cout << at_c<1>(emp) << std::endl; + + fusion::vector v1("John Doe", "jdoe"); + BOOST_TEST(emp == v1); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/sequence/adapt_struct_empty.cpp b/src/boost/libs/fusion/test/sequence/adapt_struct_empty.cpp new file mode 100644 index 00000000..202131d4 --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/adapt_struct_empty.cpp @@ -0,0 +1,87 @@ +/*============================================================================= + Copyright (c) 2016 Kohei Takahashi + + 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +class empty_struct{}; +BOOST_FUSION_ADAPT_STRUCT(empty_struct,) + +int +main() +{ + using namespace boost::fusion; + using namespace boost; + + std::cout << tuple_open('['); + std::cout << tuple_close(']'); + std::cout << tuple_delimiter(", "); + + { + BOOST_MPL_ASSERT_NOT((traits::is_view)); + BOOST_STATIC_ASSERT(!traits::is_view::value); + empty_struct e; + + std::cout << e << std::endl; + BOOST_TEST(e == make_vector()); + + BOOST_STATIC_ASSERT(fusion::result_of::size::value == 0); + BOOST_MPL_ASSERT((fusion::result_of::empty)); + + BOOST_MPL_ASSERT((fusion::result_of::equal_to< + fusion::result_of::begin::type, + fusion::result_of::end::type>)); + } + + { + fusion::vector<> v; + empty_struct e; + BOOST_TEST(v == e); + BOOST_TEST_NOT(e != v); + BOOST_TEST_NOT(v < e); + BOOST_TEST(v <= e); + BOOST_TEST_NOT(e > v); + BOOST_TEST(e >= v); + } + + { + empty_struct e; + + // conversion from empty_struct to vector + fusion::vector<> v(e); + v = e; + + // FIXME + // conversion from empty_struct to list + //fusion::list<> l(e); + //l = e; + } + + BOOST_MPL_ASSERT((mpl::is_sequence)); + + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/sequence/adapt_struct_named.cpp b/src/boost/libs/fusion/test/sequence/adapt_struct_named.cpp new file mode 100644 index 00000000..ec5cf7ba --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/adapt_struct_named.cpp @@ -0,0 +1,164 @@ +/*============================================================================= + Copyright (c) 2001-2007 Joel de Guzman + + 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace ns +{ + struct point + { + int x; + int y; + int z; + }; +} + +#if BOOST_PP_VARIADICS + + // this creates a fusion view: boost::fusion::adapted::point + BOOST_FUSION_ADAPT_STRUCT_NAMED( + ns::point, point, + x, + y, + z + ) + + // this creates a fusion view: ns1::s1 + struct s { int m; }; + BOOST_FUSION_ADAPT_STRUCT_NAMED_NS(s, (ns1), s1, m) + +#else // BOOST_PP_VARIADICS + + // this creates a fusion view: boost::fusion::adapted::point + BOOST_FUSION_ADAPT_STRUCT_NAMED( + ns::point, point, + (int, x) + (BOOST_FUSION_ADAPT_AUTO, y) + (auto, z) + ) + + // this creates a fusion view: ns1::s1 + struct s { int m; }; + BOOST_FUSION_ADAPT_STRUCT_NAMED_NS(s, (ns1), s1, (auto, m)) + +#endif + +struct empty_struct {}; +BOOST_FUSION_ADAPT_STRUCT_NAMED(empty_struct, renamed_empty_struct, ) +BOOST_FUSION_ADAPT_STRUCT_NAMED_NS(empty_struct, (ns1), renamed_empty_struct1, ) + +int +main() +{ + using namespace boost::fusion; + using namespace boost; + + std::cout << tuple_open('['); + std::cout << tuple_close(']'); + std::cout << tuple_delimiter(", "); + + { + BOOST_MPL_ASSERT((traits::is_view)); + BOOST_STATIC_ASSERT(traits::is_view::value); + ns::point basep = {123, 456, 789}; + adapted::point p(basep); + + std::cout << at_c<0>(p) << std::endl; + std::cout << at_c<1>(p) << std::endl; + std::cout << at_c<2>(p) << std::endl; + std::cout << p << std::endl; + BOOST_TEST(p == make_vector(123, 456, 789)); + + at_c<0>(p) = 6; + at_c<1>(p) = 9; + at_c<2>(p) = 12; + BOOST_TEST(p == make_vector(6, 9, 12)); + + BOOST_STATIC_ASSERT(boost::fusion::result_of::size::value == 3); + BOOST_STATIC_ASSERT(!boost::fusion::result_of::empty::value); + + BOOST_TEST(front(p) == 6); + BOOST_TEST(back(p) == 12); + } + + { + fusion::vector v1(4, 2.f, 2); + ns::point p = {5, 3, 3}; + adapted::point v2(p); + + fusion::vector v3(5, 4., 4); + BOOST_TEST(v1 < v2); + BOOST_TEST(v1 <= v2); + BOOST_TEST(v2 > v1); + BOOST_TEST(v2 >= v1); + BOOST_TEST(v2 < v3); + BOOST_TEST(v2 <= v3); + BOOST_TEST(v3 > v2); + BOOST_TEST(v3 >= v2); + } + + { + // conversion from adapted::point to vector + ns::point basep = {5, 3, 3}; + adapted::point p(basep); + fusion::vector v(p); + v = p; + } + + { + // conversion from adapted::point to list + ns::point basep = {5, 3, 3}; + adapted::point p(basep); + fusion::list l(p); + l = p; + } + + { // begin/end + using namespace boost::fusion; + using boost::is_same; + + typedef boost::fusion::result_of::begin::type b; + typedef boost::fusion::result_of::end::type e; + // this fails + BOOST_MPL_ASSERT((is_same::type, e>)); + } + + + { + BOOST_MPL_ASSERT((mpl::is_sequence)); + BOOST_MPL_ASSERT((boost::is_same< + boost::fusion::result_of::value_at_c::type + , mpl::front::type>)); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/sequence/adapt_struct_named_empty.cpp b/src/boost/libs/fusion/test/sequence/adapt_struct_named_empty.cpp new file mode 100644 index 00000000..7272f6f6 --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/adapt_struct_named_empty.cpp @@ -0,0 +1,88 @@ +/*============================================================================= + Copyright (c) 2016 Kohei Takahashi + + 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +class empty_struct{}; +BOOST_FUSION_ADAPT_STRUCT_NAMED(::empty_struct,empty_struct,) + +int +main() +{ + using namespace boost::fusion; + using namespace boost; + + std::cout << tuple_open('['); + std::cout << tuple_close(']'); + std::cout << tuple_delimiter(", "); + + empty_struct empty; + { + BOOST_MPL_ASSERT((traits::is_view)); + BOOST_STATIC_ASSERT(traits::is_view::value); + adapted::empty_struct e(empty); + + std::cout << e << std::endl; + BOOST_TEST(e == make_vector()); + + BOOST_STATIC_ASSERT(fusion::result_of::size::value == 0); + BOOST_MPL_ASSERT((fusion::result_of::empty)); + + BOOST_MPL_ASSERT((fusion::result_of::equal_to< + fusion::result_of::begin::type, + fusion::result_of::end::type>)); + } + + { + fusion::vector<> v; + adapted::empty_struct e(empty); + BOOST_TEST(v == e); + BOOST_TEST_NOT(e != v); + BOOST_TEST_NOT(v < e); + BOOST_TEST(v <= e); + BOOST_TEST_NOT(e > v); + BOOST_TEST(e >= v); + } + + { + adapted::empty_struct e(empty); + + // conversion from empty_struct to vector + fusion::vector<> v(e); + v = e; + + // FIXME + // conversion from empty_struct to list + //fusion::list<> l(e); + //l = e; + } + + BOOST_MPL_ASSERT((mpl::is_sequence)); + + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/sequence/adapt_tpl_adt.cpp b/src/boost/libs/fusion/test/sequence/adapt_tpl_adt.cpp new file mode 100644 index 00000000..d917134a --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/adapt_tpl_adt.cpp @@ -0,0 +1,182 @@ +/*============================================================================= + Copyright (c) 2010 Christopher Schmidt + + 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace ns +{ + template + class point + { + public: + + point() : x(0), y(0), z(0) {} + point(X x_, Y y_, int z_) : x(x_), y(y_), z(z_) {} + + X get_x() const { return x; } + Y get_y() const { return y; } + int get_z() const { return z; } + void set_x(X x_) { x = x_; } + void set_y(Y y_) { y = y_; } + void set_z(int z_) { z = z_; } + + private: + + X x; + Y y; + int z; + }; +} + + +#if BOOST_PP_VARIADICS + + BOOST_FUSION_ADAPT_TPL_ADT( + (X)(Y), + (ns::point)(X)(Y), + (X, X, obj.get_x(), obj.set_x(val)) + (Y, Y, obj.get_y(), obj.set_y(val)) + (obj.get_z(), obj.set_z(val)) + ) + +#else // BOOST_PP_VARIADICS + + BOOST_FUSION_ADAPT_TPL_ADT( + (X)(Y), + (ns::point)(X)(Y), + (X, X, obj.get_x(), obj.set_x(val)) + (Y, Y, obj.get_y(), obj.set_y(val)) + (auto, auto, obj.get_z(), obj.set_z(val)) + ) +#endif + +template +class empty_adt_templated_factory { + + TypeToConstruct operator()() { + return TypeToConstruct(); + } + +}; + +BOOST_FUSION_ADAPT_TPL_ADT( + (TypeToConstruct), + (empty_adt_templated_factory)(TypeToConstruct), +) + +int +main() +{ + using namespace boost::fusion; + + typedef ns::point point; + typedef ns::point name; + + std::cout << tuple_open('['); + std::cout << tuple_close(']'); + std::cout << tuple_delimiter(", "); + + { + BOOST_MPL_ASSERT_NOT((traits::is_view)); + BOOST_STATIC_ASSERT(!traits::is_view::value); + point p(123, 456, 789); + + std::cout << at_c<0>(p) << std::endl; + std::cout << at_c<1>(p) << std::endl; + std::cout << at_c<2>(p) << std::endl; + std::cout << p << std::endl; + BOOST_TEST(p == make_vector(123, 456, 789)); + + at_c<0>(p) = 6; + at_c<1>(p) = 9; + at_c<2>(p) = 12; + BOOST_TEST(p == make_vector(6, 9, 12)); + + BOOST_STATIC_ASSERT(boost::fusion::result_of::size::value == 3); + BOOST_STATIC_ASSERT(!boost::fusion::result_of::empty::value); + + BOOST_TEST(front(p) == 6); + BOOST_TEST(back(p) == 12); + } + + { + boost::fusion::vector v1(4, 2.f, 2); + point v2(5, 3, 3); + boost::fusion::vector v3(5, 4., 4); + BOOST_TEST(v1 < v2); + BOOST_TEST(v1 <= v2); + BOOST_TEST(v2 > v1); + BOOST_TEST(v2 >= v1); + BOOST_TEST(v2 < v3); + BOOST_TEST(v2 <= v3); + BOOST_TEST(v3 > v2); + BOOST_TEST(v3 >= v2); + } + + { + boost::fusion::vector v1("Lincoln", "Abraham", 3); + name v2("Roosevelt", "Franklin", 3); + name v3("Roosevelt", "Theodore", 3); + BOOST_TEST(v1 < v2); + BOOST_TEST(v1 <= v2); + BOOST_TEST(v2 > v1); + BOOST_TEST(v2 >= v1); + BOOST_TEST(v2 < v3); + BOOST_TEST(v2 <= v3); + BOOST_TEST(v3 > v2); + BOOST_TEST(v3 >= v2); + } + + { + // conversion from point to vector + point p(5, 3, 3); + boost::fusion::vector v(p); + v = p; + } + + { + // conversion from point to list + point p(5, 3, 3); + boost::fusion::list l(p); + l = p; + } + + { + BOOST_MPL_ASSERT((boost::mpl::is_sequence)); + BOOST_MPL_ASSERT((boost::is_same< + boost::fusion::result_of::value_at_c::type + , boost::mpl::front::type>)); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/sequence/adapt_tpl_adt_empty.cpp b/src/boost/libs/fusion/test/sequence/adapt_tpl_adt_empty.cpp new file mode 100644 index 00000000..82bf2121 --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/adapt_tpl_adt_empty.cpp @@ -0,0 +1,87 @@ +/*============================================================================= + Copyright (c) 2016 Kohei Takahashi + + 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +template +class empty_adt{}; +BOOST_FUSION_ADAPT_TPL_ADT((T), (empty_adt)(T),) + +int +main() +{ + using namespace boost::fusion; + using namespace boost; + + std::cout << tuple_open('['); + std::cout << tuple_close(']'); + std::cout << tuple_delimiter(", "); + + { + BOOST_MPL_ASSERT_NOT((traits::is_view >)); + empty_adt e; + + std::cout << e << std::endl; + BOOST_TEST(e == make_vector()); + + BOOST_STATIC_ASSERT(fusion::result_of::size >::value == 0); + BOOST_MPL_ASSERT((fusion::result_of::empty >)); + + BOOST_MPL_ASSERT((fusion::result_of::equal_to< + fusion::result_of::begin >::type, + fusion::result_of::end >::type>)); + } + + { + fusion::vector<> v; + empty_adt e; + BOOST_TEST(v == e); + BOOST_TEST_NOT(v != e); + BOOST_TEST_NOT(v < e); + BOOST_TEST(v <= e); + BOOST_TEST_NOT(e > v); + BOOST_TEST(e >= v); + } + + { + empty_adt e; + + // conversion from empty_adt to vector + fusion::vector<> v(e); + v = e; + + // FIXME + // conversion from empty_adt to list + //fusion::list<> l(e); + //l = e; + } + + BOOST_MPL_ASSERT((mpl::is_sequence >)); + + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/sequence/adapt_tpl_struct.cpp b/src/boost/libs/fusion/test/sequence/adapt_tpl_struct.cpp new file mode 100644 index 00000000..1776cd62 --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/adapt_tpl_struct.cpp @@ -0,0 +1,159 @@ +/*============================================================================= + Copyright (c) 2010 Christopher Schmidt + + 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace ns +{ + template + struct point + { + X x; + Y y; + int z; + }; +} + +#if BOOST_PP_VARIADICS + + BOOST_FUSION_ADAPT_TPL_STRUCT( + (X)(Y), + (ns::point)(X)(Y), + x, + (auto, y) + (int, z) + ) + + template + struct s { M m; }; + BOOST_FUSION_ADAPT_TPL_STRUCT((M), (s)(M), m) + +#else // BOOST_PP_VARIADICS + + BOOST_FUSION_ADAPT_TPL_STRUCT( + (X)(Y), + (ns::point)(X)(Y), + (X, x) + (Y, y) + (auto, z) + ) + + template + struct s { M m; }; + BOOST_FUSION_ADAPT_TPL_STRUCT((M), (s)(M), (auto, m)) + +#endif + +template +struct empty_struct_templated_factory { + + TypeToConstruct operator()() { + return TypeToConstruct(); + } + +}; + +BOOST_FUSION_ADAPT_TPL_STRUCT( + (TypeToConstruct), + (empty_struct_templated_factory)(TypeToConstruct), +) + +int +main() +{ + using namespace boost::fusion; + + typedef ns::point point; + + std::cout << tuple_open('['); + std::cout << tuple_close(']'); + std::cout << tuple_delimiter(", "); + + { + BOOST_MPL_ASSERT_NOT((traits::is_view)); + BOOST_STATIC_ASSERT(!traits::is_view::value); + point p = {123, 456, 789}; + + std::cout << at_c<0>(p) << std::endl; + std::cout << at_c<1>(p) << std::endl; + std::cout << at_c<2>(p) << std::endl; + std::cout << p << std::endl; + BOOST_TEST(p == make_vector(123, 456, 789)); + + at_c<0>(p) = 6; + at_c<1>(p) = 9; + at_c<2>(p) = 12; + BOOST_TEST(p == make_vector(6, 9, 12)); + + BOOST_STATIC_ASSERT(boost::fusion::result_of::size::value == 3); + BOOST_STATIC_ASSERT(!boost::fusion::result_of::empty::value); + + BOOST_TEST(front(p) == 6); + BOOST_TEST(back(p) == 12); + } + + { + vector v1(4, 2.f, 2); + point v2 = {5, 3, 3}; + vector v3(5, 4., 4); + BOOST_TEST(v1 < v2); + BOOST_TEST(v1 <= v2); + BOOST_TEST(v2 > v1); + BOOST_TEST(v2 >= v1); + BOOST_TEST(v2 < v3); + BOOST_TEST(v2 <= v3); + BOOST_TEST(v3 > v2); + BOOST_TEST(v3 >= v2); + } + + { + // conversion from point to vector + point p = {5, 3, 3}; + vector v(p); + v = p; + } + + { + // conversion from point to list + point p = {5, 3, 3}; + list l(p); + l = p; + } + + { // begin/end + using namespace boost::fusion; + + typedef boost::fusion::result_of::begin >::type b; + typedef boost::fusion::result_of::end >::type e; + // this fails + BOOST_MPL_ASSERT((boost::is_same::type, e>)); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/sequence/adapt_tpl_struct_empty.cpp b/src/boost/libs/fusion/test/sequence/adapt_tpl_struct_empty.cpp new file mode 100644 index 00000000..5cb1d442 --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/adapt_tpl_struct_empty.cpp @@ -0,0 +1,87 @@ +/*============================================================================= + Copyright (c) 2016 Kohei Takahashi + + 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +template +class empty_struct{}; +BOOST_FUSION_ADAPT_TPL_STRUCT((T), (empty_struct)(T),) + +int +main() +{ + using namespace boost::fusion; + using namespace boost; + + std::cout << tuple_open('['); + std::cout << tuple_close(']'); + std::cout << tuple_delimiter(", "); + + { + BOOST_MPL_ASSERT_NOT((traits::is_view >)); + empty_struct e; + + std::cout << e << std::endl; + BOOST_TEST(e == make_vector()); + + BOOST_STATIC_ASSERT(fusion::result_of::size >::value == 0); + BOOST_MPL_ASSERT((fusion::result_of::empty >)); + + BOOST_MPL_ASSERT((fusion::result_of::equal_to< + fusion::result_of::begin >::type, + fusion::result_of::end >::type>)); + } + + { + fusion::vector<> v; + empty_struct e; + BOOST_TEST(v == e); + BOOST_TEST_NOT(v != e); + BOOST_TEST_NOT(v < e); + BOOST_TEST(v <= e); + BOOST_TEST_NOT(v > e); + BOOST_TEST(v >= e); + } + + { + empty_struct e; + + // conversion from empty_struct to vector + fusion::vector<> v(e); + v = e; + + // FIXME + // conversion from empty_struct to list + //fusion::list<> l(e); + //l = e; + } + + BOOST_MPL_ASSERT((mpl::is_sequence >)); + + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/sequence/adt_attribute_proxy.cpp b/src/boost/libs/fusion/test/sequence/adt_attribute_proxy.cpp new file mode 100644 index 00000000..eae4eb9a --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/adt_attribute_proxy.cpp @@ -0,0 +1,189 @@ +/*============================================================================= + Copyright (c) 2010 Christopher Schmidt + + 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 +#include +#include +#include +#include +#include +#include + +namespace fusion=boost::fusion; + +template +struct employee +{ +private: + Name name; + Age age; + +public: + template + void + set_name(OtherName const& n) + { + name=n; + } + + template + void + set_age(OtherAge const& a) + { + age=a; + } + + Name& get_name() + { + return name; + } + + Name const& get_name()const + { + return name; + } + + Age& get_age() + { + return age; + } + + Age const& get_age()const + { + return age; + } +}; + +namespace keys +{ + struct name; + struct age; +} + +BOOST_FUSION_ADAPT_ASSOC_TPL_ADT( + (Name)(Age), + (employee) (Name)(Age), + (Name&, Name const&, obj.get_name(), obj.template set_name(val), keys::name) + (Age&, Age const&, obj.get_age(), obj.template set_age(val), keys::age)) + +int main() +{ + typedef employee et; + typedef et const etc; + et e; + etc& ec=e; + + fusion::at_key(e)="marshall mathers"; + fusion::at_key(e)=37; + + BOOST_MPL_ASSERT(( + boost::is_same< + boost::fusion::result_of::value_at_key::type, + std::string + >)); + BOOST_MPL_ASSERT(( + boost::is_same< + boost::fusion::result_of::value_at_key::type, + boost::fusion::result_of::value_at_c::type + >)); + BOOST_MPL_ASSERT(( + boost::is_same< + boost::fusion::result_of::value_at_key::type, + int + >)); + BOOST_MPL_ASSERT(( + boost::is_same< + boost::fusion::result_of::value_at_key::type, + boost::fusion::result_of::value_at_c::type + >)); + + BOOST_MPL_ASSERT(( + boost::is_same< + boost::fusion::result_of::at_key::type, + fusion::extension::adt_attribute_proxy + >)); + BOOST_MPL_ASSERT(( + boost::is_same< + boost::fusion::result_of::at_key::type, + fusion::extension::adt_attribute_proxy + >)); + BOOST_MPL_ASSERT(( + boost::is_same< + boost::fusion::result_of::at_key::type, + boost::fusion::result_of::front::type + >)); + BOOST_MPL_ASSERT(( + boost::is_same< + boost::fusion::result_of::at_key::type, + boost::fusion::result_of::back::type + >)); + + BOOST_MPL_ASSERT(( + boost::is_same< + boost::fusion::result_of::at_key::type, + fusion::extension::adt_attribute_proxy + >)); + BOOST_MPL_ASSERT(( + boost::is_same< + boost::fusion::result_of::at_key::type, + fusion::extension::adt_attribute_proxy + >)); + BOOST_MPL_ASSERT(( + boost::is_same< + boost::fusion::result_of::at_key::type, + boost::fusion::result_of::front::type + >)); + BOOST_MPL_ASSERT(( + boost::is_same< + boost::fusion::result_of::at_key::type, + boost::fusion::result_of::back::type + >)); + + BOOST_MPL_ASSERT(( + boost::is_same< + fusion::extension::adt_attribute_proxy::type, + std::string& + >)); + BOOST_MPL_ASSERT(( + boost::is_same< + fusion::extension::adt_attribute_proxy::type, + std::string const& + >)); + BOOST_MPL_ASSERT(( + boost::is_same< + fusion::extension::adt_attribute_proxy::type, + int& + >)); + BOOST_MPL_ASSERT(( + boost::is_same< + fusion::extension::adt_attribute_proxy::type, + int const& + >)); + + { + std::string& name=fusion::at_key(e); + int& age=fusion::at_key(e); + BOOST_TEST(name=="marshall mathers"); + BOOST_TEST(age==37); + BOOST_TEST(fusion::at_key(e).get()=="marshall mathers"); + BOOST_TEST(fusion::at_key(e).get()==37); + BOOST_TEST(fusion::front(e).get()=="marshall mathers"); + BOOST_TEST(fusion::back(e).get()==37); + } + + { + std::string const& name=fusion::at_key(ec); + int const& age=fusion::at_key(ec); + BOOST_TEST(name=="marshall mathers"); + BOOST_TEST(age==37); + BOOST_TEST(fusion::at_key(ec).get()=="marshall mathers"); + BOOST_TEST(fusion::at_key(ec).get()==37); + BOOST_TEST(fusion::front(ec).get()=="marshall mathers"); + BOOST_TEST(fusion::back(ec).get()==37); + } + return boost::report_errors(); +} diff --git a/src/boost/libs/fusion/test/sequence/array.cpp b/src/boost/libs/fusion/test/sequence/array.cpp new file mode 100644 index 00000000..ca4a40ac --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/array.cpp @@ -0,0 +1,41 @@ +/*============================================================================= + Copyright (c) 2010 Christopher Schmidt + + 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 + +#include +#include +#include +#include +#include + +#include + +int main() +{ + using namespace boost::fusion; + typedef int array_type[3]; + + BOOST_MPL_ASSERT((traits::is_sequence)); + BOOST_MPL_ASSERT_NOT((traits::is_view)); + BOOST_STATIC_ASSERT(traits::is_sequence::value); + BOOST_STATIC_ASSERT(!traits::is_view::value); + + array_type arr = {1,2,3}; + + BOOST_TEST(*begin(arr) == 1); + BOOST_TEST(*next(begin(arr)) == 2); + BOOST_TEST(*advance_c<2>(begin(arr)) == 3); + BOOST_TEST(prior(next(begin(arr))) == begin(arr)); + BOOST_TEST(*prior(end(arr)) == 3); + BOOST_TEST(at_c<2>(arr) == 3); + BOOST_TEST(size(arr) == 3); + BOOST_TEST(distance(begin(arr), end(arr)) == 3); + + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/sequence/as_deque.cpp b/src/boost/libs/fusion/test/sequence/as_deque.cpp new file mode 100644 index 00000000..c56c598d --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/as_deque.cpp @@ -0,0 +1,70 @@ +/*============================================================================= + Copyright (c) 2014 Louis Dionne + + 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 +#include +#include +#include +#include +#include +#include +#include +#include + +#include + + +int main() { + using namespace boost::fusion; + using namespace boost; + + BOOST_TEST(as_deque(make_vector()) == make_deque()); + BOOST_TEST(as_deque(make_vector(1)) == make_deque(1)); + BOOST_TEST(as_deque(make_vector(1, '2')) == make_deque(1, '2')); + BOOST_TEST(as_deque(make_vector(1, '2', 3.3f)) == make_deque(1, '2', 3.3f)); + + BOOST_TEST(as_deque(make_list()) == make_deque()); + BOOST_TEST(as_deque(make_list(1)) == make_deque(1)); + BOOST_TEST(as_deque(make_list(1, '2')) == make_deque(1, '2')); + BOOST_TEST(as_deque(make_list(1, '2', 3.3f)) == make_deque(1, '2', 3.3f)); + + { + deque<> xs; + BOOST_TEST(as_deque(push_back(xs, 1)) == make_deque(1)); + } + + { + deque xs(1); + BOOST_TEST(as_deque(push_back(xs, '2')) == make_deque(1, '2')); + } + + { + deque xs(1, '2'); + BOOST_TEST(as_deque(push_back(xs, 3.3f)) == make_deque(1, '2', 3.3f)); + } + + { + deque<> xs; + BOOST_TEST( + as_deque(push_front(xs, make_deque(1, '2', 3.3f))) == + make_deque(make_deque(1, '2', 3.3f)) + ); + + BOOST_TEST(as_deque(make_deque(make_deque(1))) == make_deque(make_deque(1))); + } + +/* Disabling test for now, see https://github.com/boostorg/fusion/pull/38 ($$$ FIXME $$$) + + { + deque<> xs; + BOOST_TEST( + as_deque(push_front(xs, make_vector(1, '2', 3.3f))) == + make_deque(make_vector(1, '2', 3.3f)) + ); + } +*/ + return boost::report_errors(); +} diff --git a/src/boost/libs/fusion/test/sequence/as_list.cpp b/src/boost/libs/fusion/test/sequence/as_list.cpp new file mode 100644 index 00000000..8ee8bf12 --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/as_list.cpp @@ -0,0 +1,53 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + + 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include + +int +main() +{ + using namespace boost::fusion; + using namespace boost; + + std::cout << tuple_open('['); + std::cout << tuple_close(']'); + std::cout << tuple_delimiter(", "); + + { + vector0<> empty; + std::cout << as_list(make_vector(1, 1.23, "harru")) << std::endl; + std::cout << as_list(push_back(empty, 999)) << std::endl; + + BOOST_TEST(as_list(make_vector(1, 1.23, "harru")) == make_vector(1, 1.23, std::string("harru"))); + BOOST_TEST(as_list(push_back(empty, 999)) == push_back(empty, 999)); + } + + { + std::cout << as_list(mpl::vector_c()) << std::endl; + BOOST_TEST((as_list(mpl::vector_c()) + == mpl::vector_c())); + } + + { + // test conversion + list l(make_vector(123, "harru")); + BOOST_TEST(l == make_vector(123, "harru")); + l = (make_vector(235, "hola")); // test assign + BOOST_TEST(l == make_vector(235, "hola")); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/sequence/as_map.cpp b/src/boost/libs/fusion/test/sequence/as_map.cpp new file mode 100644 index 00000000..d2a89cc6 --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/as_map.cpp @@ -0,0 +1,61 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + + 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +int +main() +{ + using namespace boost::fusion; + using namespace boost; + + std::cout << tuple_open('['); + std::cout << tuple_close(']'); + std::cout << tuple_delimiter(", "); + + { + vector0<> empty; + std::cout << as_map(make_list(make_pair('X'), make_pair("Men"))) << std::endl; + std::cout << as_map(push_back(empty, make_pair(999))) << std::endl; + } + + { + typedef pair p1; + typedef pair p2; + boost::fusion::result_of::as_map >::type map(make_pair('X'), make_pair("Men")); + std::cout << at_key(map) << std::endl; + std::cout << at_key(map) << std::endl; + BOOST_TEST(at_key(map) == 'X'); + BOOST_TEST(at_key(map) == "Men"); + } + + { + // test conversion + typedef map< + pair + , pair > + map_type; + + map_type m(make_vector(make_pair('X'), make_pair("Men"))); + BOOST_TEST(as_vector(m) == make_vector(make_pair('X'), make_pair("Men"))); + m = (make_vector(make_pair('X'), make_pair("Men"))); // test assign + BOOST_TEST(as_vector(m) == make_vector(make_pair('X'), make_pair("Men"))); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/sequence/as_map_assoc.cpp b/src/boost/libs/fusion/test/sequence/as_map_assoc.cpp new file mode 100644 index 00000000..bc9a6951 --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/as_map_assoc.cpp @@ -0,0 +1,85 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + + 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace ns +{ + struct x_member; + struct y_member; + struct z_member; + + struct point + { + int x; + int y; + }; +} + +BOOST_FUSION_ADAPT_ASSOC_STRUCT( + ns::point, + (int, x, ns::x_member) + (int, y, ns::y_member) +) + +int +main() +{ + using namespace boost::fusion; + using namespace boost; + + std::cout << tuple_open('['); + std::cout << tuple_close(']'); + std::cout << tuple_delimiter(", "); + + { + ns::point p = {123, 456}; + std::cout << as_map(p) << std::endl; + } + + { + ns::point p = {123, 456}; + boost::fusion::result_of::as_map::type map(p); + std::cout << at_key(map) << std::endl; + std::cout << at_key(map) << std::endl; + BOOST_TEST(at_key(map) == 123); + BOOST_TEST(at_key(map) == 456); + } + + { + boost::fusion::result_of::as_map >::type map(make_set(1, '2')); + BOOST_TEST(at_key(map) == 1); + BOOST_TEST(at_key(map) == '2'); + } + + { + // test conversion + typedef map< + pair + , pair > + map_type; + + ns::point p = {123, 456}; + map_type m(p); + BOOST_TEST(as_vector(m) == make_vector(make_pair(123), make_pair(456))); + m = (make_vector(make_pair(123), make_pair(456))); // test assign + BOOST_TEST(as_vector(m) == make_vector(make_pair(123), make_pair(456))); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/sequence/as_set.cpp b/src/boost/libs/fusion/test/sequence/as_set.cpp new file mode 100644 index 00000000..97dd89e8 --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/as_set.cpp @@ -0,0 +1,64 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + + 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +int +main() +{ + using namespace boost::fusion; + using namespace boost; + + std::cout << tuple_open('['); + std::cout << tuple_close(']'); + std::cout << tuple_delimiter(", "); + + { + vector0<> empty; + std::cout << as_set(make_list(1, 1.23, "harru")) << std::endl; + std::cout << as_set(push_back(empty, 999)) << std::endl; + + BOOST_TEST(as_list(as_set(make_list(1, 1.23, "harru"))) + == make_list(1, 1.23, std::string("harru"))); + BOOST_TEST(as_list(as_set(push_back(empty, 999))) + == push_back(empty, 999)); + } + + { + boost::fusion::result_of::as_set >::type set(1, 1.23, "harru"); + std::cout << at_key(set) << std::endl; + BOOST_TEST(at_key(set) == 1); + } + + { + std::cout << as_set(mpl::vector_c()) << std::endl; + BOOST_TEST((as_list(as_set(mpl::vector_c())) + == mpl::vector_c())); + } + + { + // test conversion + set s(make_vector(123, "harru")); + BOOST_TEST(as_vector(s) == make_vector(123, "harru")); + s = (make_vector(235, "hola")); // test assign + BOOST_TEST(as_vector(s) == make_vector(235, "hola")); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/sequence/as_vector.cpp b/src/boost/libs/fusion/test/sequence/as_vector.cpp new file mode 100644 index 00000000..af1aaffb --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/as_vector.cpp @@ -0,0 +1,54 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + + 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +int +main() +{ + using namespace boost::fusion; + using namespace boost; + + std::cout << tuple_open('['); + std::cout << tuple_close(']'); + std::cout << tuple_delimiter(", "); + + { + vector0<> empty; + std::cout << as_vector(make_list(1, 1.23, "harru")) << std::endl; + std::cout << as_vector(push_back(empty, 999)) << std::endl; + + BOOST_TEST(as_vector(make_list(1, 1.23, "harru")) == make_list(1, 1.23, std::string("harru"))); + BOOST_TEST(as_vector(push_back(empty, 999)) == push_back(empty, 999)); + } + + { + std::cout << as_vector(mpl::vector_c()) << std::endl; + BOOST_TEST((as_vector(mpl::vector_c()) + == mpl::vector_c())); + } + + { + // test conversion + vector v(make_list(123, "harru")); + BOOST_TEST(v == make_list(123, "harru")); + v = (make_list(235, "hola")); // test assign + BOOST_TEST(v == make_list(235, "hola")); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/sequence/back_extended_deque.cpp b/src/boost/libs/fusion/test/sequence/back_extended_deque.cpp new file mode 100644 index 00000000..368ec0c2 --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/back_extended_deque.cpp @@ -0,0 +1,114 @@ +/*============================================================================= + Copyright (c) 1999-2003 Jaakko Jarvi + Copyright (c) 2001-2011 Joel de Guzman + Copyright (c) 2006 Dan Marsden + + 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 + +#include +#include +#include +#include +#include + +#include +#include + +#include +#include + +int main() +{ + using namespace boost::fusion; + { + typedef deque<> initial_deque_type; + initial_deque_type initial_deque; + typedef back_extended_deque extended_type; + extended_type extended(initial_deque, 101L); + + BOOST_TEST(size(extended) == 1); + BOOST_TEST(extended == make_vector(101L)); + BOOST_TEST(*begin(extended) == 101L); + BOOST_TEST(*prior(end(extended)) == 101L); + BOOST_TEST(distance(begin(extended), end(extended)) == 1); + } + { + namespace mpl = boost::mpl; + typedef deque<> initial_deque_type; + typedef back_extended_deque extended_type; + + BOOST_MPL_ASSERT((boost::is_same::type, long>)); + BOOST_MPL_ASSERT((boost::is_same::type>::type, long>)); + BOOST_MPL_ASSERT((mpl::equal_to::type, mpl::int_<1> >)); + } + { + long l(101L); + typedef deque<> initial_deque_type; + initial_deque_type initial_deque; + typedef back_extended_deque extended_type; + extended_type extended(initial_deque, l); + BOOST_TEST(extended == make_vector(101L)); + + long l2(202L); + extended_type extended2(initial_deque_type(), l2); + + extended = extended2; + + BOOST_TEST(extended == make_vector(202L)); + + BOOST_TEST(l == l2); + } + + { + typedef deque initial_deque_type; + initial_deque_type initial_deque(1, 'a'); + typedef back_extended_deque extended_type; + extended_type extended(initial_deque, 101L); + + BOOST_TEST(size(extended) == 3); + BOOST_TEST(extended == make_vector(1, 'a', 101L)); + BOOST_TEST(*begin(extended) == 1); + BOOST_TEST(*next(begin(extended)) == 'a'); + BOOST_TEST(*prior(end(extended)) == 101L); + BOOST_TEST(distance(begin(extended), end(extended)) == 3); + BOOST_TEST(*advance_c<2>(begin(extended)) == 101L); + } + { + namespace mpl = boost::mpl; + typedef deque initial_deque_type; + typedef back_extended_deque extended_type; + + BOOST_MPL_ASSERT((boost::is_same::type, int>)); + BOOST_MPL_ASSERT((boost::is_same::type, char>)); + BOOST_MPL_ASSERT((boost::is_same::type, long>)); + BOOST_MPL_ASSERT((boost::is_same::type>::type, int>)); + BOOST_MPL_ASSERT((mpl::equal_to::type, mpl::int_<3> >)); + } + { + char ch('a'); + long l(101L); + int i(1); + typedef deque initial_deque_type; + initial_deque_type initial_deque(i, ch); + typedef back_extended_deque extended_type; + extended_type extended(initial_deque, l); + BOOST_TEST(extended == make_vector(1, 'a', 101L)); + + char ch2('b'); + long l2(202L); + int i2(2); + extended_type extended2(initial_deque_type(i2, ch2), l2); + + extended = extended2; + + BOOST_TEST(extended == make_vector(2, 'b', 202L)); + + BOOST_TEST(i == i2); + BOOST_TEST(ch == ch2); + BOOST_TEST(l == l2); + } + return boost::report_errors(); +} diff --git a/src/boost/libs/fusion/test/sequence/boost_array.cpp b/src/boost/libs/fusion/test/sequence/boost_array.cpp new file mode 100644 index 00000000..f3f71470 --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/boost_array.cpp @@ -0,0 +1,44 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + Copyright (c) 2005-2006 Dan Marsden + Copyright (c) 2010 Christopher Schmidt + + 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 + +#include +#include + +#include +#include +#include +#include + +#include + +int main() +{ + using namespace boost::fusion; + typedef boost::array array_type; + + BOOST_MPL_ASSERT((traits::is_sequence)); + BOOST_MPL_ASSERT_NOT((traits::is_view)); + BOOST_STATIC_ASSERT(traits::is_sequence::value); + BOOST_STATIC_ASSERT(!traits::is_view::value); + + array_type arr = {{1,2,3}}; + + BOOST_TEST(*begin(arr) == 1); + BOOST_TEST(*next(begin(arr)) == 2); + BOOST_TEST(*advance_c<2>(begin(arr)) == 3); + BOOST_TEST(prior(next(begin(arr))) == begin(arr)); + BOOST_TEST(*prior(end(arr)) == 3); + BOOST_TEST(at_c<2>(arr) == 3); + BOOST_TEST(size(arr) == 3); + BOOST_TEST(distance(begin(arr), end(arr)) == 3); + + return boost::report_errors(); +} diff --git a/src/boost/libs/fusion/test/sequence/boost_tuple.cpp b/src/boost/libs/fusion/test/sequence/boost_tuple.cpp new file mode 100644 index 00000000..abe7d3c8 --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/boost_tuple.cpp @@ -0,0 +1,118 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + + 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +int +main() +{ + using namespace boost::fusion; + using namespace boost; + + std::cout << tuple_open('['); + std::cout << tuple_close(']'); + std::cout << tuple_delimiter(", "); + + { + typedef boost::tuple tuple_type; + BOOST_MPL_ASSERT_NOT((traits::is_view)); + BOOST_STATIC_ASSERT(!traits::is_view::value); + tuple_type t(123, "Hola!!!"); + + std::cout << at_c<0>(t) << std::endl; + std::cout << at_c<1>(t) << std::endl; + std::cout << t << std::endl; + BOOST_TEST(t == make_vector(123, "Hola!!!")); + + at_c<0>(t) = 6; + at_c<1>(t) = "mama mia"; + BOOST_TEST(t == make_vector(6, "mama mia")); + + BOOST_STATIC_ASSERT(boost::fusion::result_of::size::value == 2); + BOOST_STATIC_ASSERT(!boost::fusion::result_of::empty::value); + + BOOST_TEST(front(t) == 6); + } + + { + fusion::vector v1(4, 3.3f); + boost::tuple v2(5, 3.3f); + fusion::vector v3(5, 4.4); + BOOST_TEST(v1 < v2); + BOOST_TEST(v1 <= v2); + BOOST_TEST(v2 > v1); + BOOST_TEST(v2 >= v1); + BOOST_TEST(v2 < v3); + BOOST_TEST(v2 <= v3); + BOOST_TEST(v3 > v2); + BOOST_TEST(v3 >= v2); + } + + { + // conversion from boost tuple to vector + fusion::vector v(tuples::make_tuple(123, "Hola!!!")); + v = tuples::make_tuple(123, "Hola!!!"); + } + + { + // conversion from boost tuple to list + fusion::list l(tuples::make_tuple(123, "Hola!!!")); + l = tuples::make_tuple(123, "Hola!!!"); + } + + { + // conversion vector to boost tuple + boost::tuple t = convert(make_vector(123, "Hola!!!")); + BOOST_TEST(get<0>(t) == 123); + BOOST_TEST(get<1>(t) == "Hola!!!"); + } + + { + // test from Ticket #1601, submitted by Shunsuke Sogame + // expanded by Stjepan Rajko + boost::tuple t(3, 'a'); + + BOOST_TEST(0u == fusion::distance(fusion::begin(t), fusion::begin(t))); + BOOST_TEST(1u == fusion::distance(fusion::begin(t), fusion::next(fusion::begin(t)))); + BOOST_TEST(2u == fusion::distance(fusion::begin(t), fusion::end(t))); + } + + { + typedef boost::tuple tuple_type; + BOOST_MPL_ASSERT((mpl::is_sequence)); + BOOST_MPL_ASSERT((boost::is_same::type>)); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/sequence/boost_tuple_iterator.cpp b/src/boost/libs/fusion/test/sequence/boost_tuple_iterator.cpp new file mode 100644 index 00000000..3ab096b9 --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/boost_tuple_iterator.cpp @@ -0,0 +1,21 @@ +/*============================================================================= + Copyright (c) 2014 Kohei Takahashi + + 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 + +#define FUSION_SEQUENCE boost::tuple +#define FUSION_TRAVERSAL_TAG forward_traversal_tag +#define FUSION_NO_PRIOR +#include "./iterator.hpp" + +int +main() +{ + test(); + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/sequence/comparison.hpp b/src/boost/libs/fusion/test/sequence/comparison.hpp new file mode 100644 index 00000000..2dfe6550 --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/comparison.hpp @@ -0,0 +1,57 @@ +/*============================================================================= + Copyright (c) 1999-2003 Jaakko Jarvi + Copyright (c) 2001-2011 Joel de Guzman + + 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 +#include + +void +equality_test() +{ + using namespace boost::fusion; + + FUSION_SEQUENCE v1(5, 'a'); + FUSION_SEQUENCE v2(5, 'a'); + BOOST_TEST(v1 == v2); + + FUSION_SEQUENCE v3(5, 'b'); + FUSION_SEQUENCE t4(2, 'a'); + BOOST_TEST(v1 != v3); + BOOST_TEST(v1 != t4); + BOOST_TEST(!(v1 != v2)); + + FUSION_SEQUENCE v5(5, 'a', true); + BOOST_TEST(v1 != v5); + BOOST_TEST(!(v1 == v5)); + BOOST_TEST(v5 != v1); + BOOST_TEST(!(v5 == v1)); +} + +void +ordering_test() +{ + using namespace boost::fusion; + + FUSION_SEQUENCE v1(4, 3.3f); + FUSION_SEQUENCE v2(5, 3.3f); + FUSION_SEQUENCE v3(5, 4.4); + BOOST_TEST(v1 < v2); + BOOST_TEST(v1 <= v2); + BOOST_TEST(v2 > v1); + BOOST_TEST(v2 >= v1); + BOOST_TEST(v2 < v3); + BOOST_TEST(v2 <= v3); + BOOST_TEST(v3 > v2); + BOOST_TEST(v3 >= v2); + +#if defined(FUSION_TEST_FAIL) + FUSION_SEQUENCE v5(5, 'a', true); + v1 >= v5; +#endif +} + + + diff --git a/src/boost/libs/fusion/test/sequence/cons.cpp b/src/boost/libs/fusion/test/sequence/cons.cpp new file mode 100644 index 00000000..88a04101 --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/cons.cpp @@ -0,0 +1,95 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + Copyright (c) 2005 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) +==============================================================================*/ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +int +main() +{ + using namespace boost::fusion; + using boost::is_same; + namespace fusion = boost::fusion; + + std::cout << tuple_open('['); + std::cout << tuple_close(']'); + std::cout << tuple_delimiter(", "); + +/// Testing cons + + { + std::string hello("hello"); + cons > ns = + make_cons(1, make_cons(hello)); + + BOOST_TEST((*begin(ns) == 1)); + BOOST_TEST((*fusion::next(begin(ns)) == hello)); + + *begin(ns) += 1; + *fusion::next(begin(ns)) += ' '; + + BOOST_TEST((*begin(ns) == 2)); + BOOST_TEST((*fusion::next(begin(ns)) == hello + ' ')); + + for_each(ns, boost::lambda::_1 += ' '); + + BOOST_TEST((*begin(ns) == 2 + ' ')); + BOOST_TEST((*fusion::next(begin(ns)) == hello + ' ' + ' ')); + } + + { + BOOST_TEST( + make_cons("hello") == make_vector(std::string("hello")) + ); + + BOOST_TEST( + make_cons(123, make_cons("hello")) == + make_vector(123, std::string("hello")) + ); + } + + { + vector t(1, 1.1f); + cons > nf = + make_cons(1, make_cons(1.1f)); + + BOOST_TEST((t == nf)); + BOOST_TEST((vector(1) == filter_if >(nf))); + + std::cout << nf << std::endl; + std::cout << filter_if >(nf) << std::endl; + } + + { + int i = 3; + cons tie(cons_tie(i)); + BOOST_TEST((*begin(tie) == 3)); + } + + { + // This used to trigger a hard compilation error: + cons > xs; + begin(push_front(xs, 3)); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/sequence/construction.hpp b/src/boost/libs/fusion/test/sequence/construction.hpp new file mode 100644 index 00000000..94c7d182 --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/construction.hpp @@ -0,0 +1,122 @@ +/*============================================================================= + Copyright (c) 1999-2003 Jaakko Jarvi + Copyright (c) 2001-2011 Joel de Guzman + + 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 +#include +#include + +#if !defined(FUSION_AT) +#define FUSION_AT at_c +#endif + +namespace test_detail +{ + // something to prevent warnings for unused variables + template void dummy(const T&) {} + + // no public default constructor + class foo + { + public: + + explicit foo(int v) : val(v) {} + + bool operator==(const foo& other) const + { + return val == other.val; + } + + private: + + foo() {} + int val; + }; + + // another class without a public default constructor + class no_def_constructor + { + no_def_constructor() {} + + public: + + no_def_constructor(std::string) {} + }; +} + +inline void +test() +{ + using namespace boost::fusion; + using namespace test_detail; + + nil empty; + (void)empty; + + FUSION_SEQUENCE<> empty0; + (void)empty0; + +#ifndef NO_CONSTRUCT_FROM_NIL + FUSION_SEQUENCE<> empty1(empty); + (void)empty1; +#endif + + FUSION_SEQUENCE t1; + BOOST_TEST(FUSION_AT<0>(t1) == int()); + + FUSION_SEQUENCE t2(5.5f); + BOOST_TEST(FUSION_AT<0>(t2) > 5.4f && FUSION_AT<0>(t2) < 5.6f); + + FUSION_SEQUENCE t3(foo(12)); + BOOST_TEST(FUSION_AT<0>(t3) == foo(12)); + + FUSION_SEQUENCE t4(t2); + BOOST_TEST(FUSION_AT<0>(t4) > 5.4 && FUSION_AT<0>(t4) < 5.6); + + FUSION_SEQUENCE t5; + BOOST_TEST(FUSION_AT<0>(t5) == int()); + BOOST_TEST(FUSION_AT<1>(t5) == float()); + + FUSION_SEQUENCE t6(12, 5.5f); + BOOST_TEST(FUSION_AT<0>(t6) == 12); + BOOST_TEST(FUSION_AT<1>(t6) > 5.4f && FUSION_AT<1>(t6) < 5.6f); + + FUSION_SEQUENCE t7(t6); + BOOST_TEST(FUSION_AT<0>(t7) == 12); + BOOST_TEST(FUSION_AT<1>(t7) > 5.4f && FUSION_AT<1>(t7) < 5.6f); + + FUSION_SEQUENCE t8(t6); + BOOST_TEST(FUSION_AT<0>(t8) == 12); + BOOST_TEST(FUSION_AT<1>(t8) > 5.4f && FUSION_AT<1>(t8) < 5.6f); + + dummy + ( + FUSION_SEQUENCE( + std::string("Jaba"), // ok, since the default + std::string("Daba"), // constructor is not used + std::string("Doo") + ) + ); + + dummy(FUSION_SEQUENCE()); + dummy(FUSION_SEQUENCE(1,3.14)); + +#if defined(FUSION_TEST_FAIL) + dummy(FUSION_SEQUENCE()); // should fail, no defaults for references + dummy(FUSION_SEQUENCE()); // likewise +#endif + + { + double dd = 5; + dummy(FUSION_SEQUENCE(dd)); // ok + dummy(FUSION_SEQUENCE(dd+3.14)); // ok, but dangerous + } + +#if defined(FUSION_TEST_FAIL) + dummy(FUSION_SEQUENCE(dd+3.14)); // should fail, + // temporary to non-const reference +#endif +} diff --git a/src/boost/libs/fusion/test/sequence/conversion.hpp b/src/boost/libs/fusion/test/sequence/conversion.hpp new file mode 100644 index 00000000..f5720776 --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/conversion.hpp @@ -0,0 +1,322 @@ +/*============================================================================= + Copyright (c) 2016 Lee Clagett + + Use modification and distribution are subject to the Boost Software + License, Version 1.0. (See accompanyintg file LICENSE_1_0.txt or copy at + http://www.boost.org/LICENSE_1_0.txt). +==============================================================================*/ + +#include +#include +#include +#include +#if !defined(BOOST_NO_CXX11_HDR_TUPLE) \ + && !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) +# include +#endif +#include +#include +#include +#include + +#include "fixture.hpp" + +template