1 # /* ************************************************************************** 2 # * * 3 # * (C) Copyright Paul Mensonides 2002. 4 # * Distributed under the Boost Software License, Version 1.0. (See 5 # * accompanying file LICENSE_1_0.txt or copy at 6 # * http://www.boost.org/LICENSE_1_0.txt) 7 # * * 8 # ************************************************************************** */ 9 # 10 # /* Revised by Edward Diener (2011,2014,2020) */ 11 # 12 # /* See http://www.boost.org for most recent version. */ 13 # 14 # include <boost/preprocessor/config/limits.hpp> 15 # include <boost/preprocessor/cat.hpp> 16 # include <boost/preprocessor/control/if.hpp> 17 # include <boost/preprocessor/tuple.hpp> 18 # include <boost/preprocessor/array/elem.hpp> 19 # include <boost/preprocessor/array/size.hpp> 20 # include <boost/preprocessor/list/at.hpp> 21 # include <boost/preprocessor/list/size.hpp> 22 # include <boost/preprocessor/seq/elem.hpp> 23 # include <boost/preprocessor/seq/size.hpp> 24 # include <boost/preprocessor/facilities/is_empty.hpp> 25 # include <boost/preprocessor/variadic/size.hpp> 26 # include <boost/preprocessor/variadic/elem.hpp> 27 # include <boost/preprocessor/variadic/has_opt.hpp> 28 # include <libs/preprocessor/test/test.h> 29 # include <libs/preprocessor/test/tuple_elem_bug_test.cxx> 30 31 # define TUPLE (0, 1, 2, 3, 4, 5) 32 # define TUPLE_NONE () 33 # define TUPLE_LARGE (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32) 34 # define TUPLE_VERY_LARGE (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63) 35 # define T2 (+3, /2, +6) 36 37 #if BOOST_PP_LIMIT_TUPLE > 64 38 39 # define TUPLE_LARGE_128 \ 40 ( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, \ 41 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103 ) 42 43 # define TUPLE_VERY_LARGE_128 \ 44 ( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, \ 45 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127 ) 46 47 #endif 48 49 #if BOOST_PP_LIMIT_TUPLE > 128 50 51 # define TUPLE_LARGE_256 \ 52 ( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, \ 53 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, \ 54 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141 ) 55 56 # define TUPLE_VERY_LARGE_256 \ 57 ( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, \ 58 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, \ 59 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, \ 60 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255 ) 61 62 # define TUPLE_VERY_LARGE_255 \ 63 ( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, \ 64 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, \ 65 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, \ 66 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254 ) 67 68 #endif 69 70 # define CALC(x) BOOST_PP_TUPLE_ELEM(0, x) BOOST_PP_TUPLE_ELEM(1, x) BOOST_PP_TUPLE_ELEM(2, x) 71 # define TEST_EAT BOOST_PP_TUPLE_EAT()(1, 2) 4 72 # define TEST_EAT_NONE BOOST_PP_TUPLE_EAT()() 17 73 # define TEST_EAT_LARGE BOOST_PP_TUPLE_EAT()(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32) 6 74 # define TEST_EAT_VERY_LARGE BOOST_PP_TUPLE_EAT()(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63) 8 75 76 #if BOOST_PP_LIMIT_TUPLE > 64 77 78 # define TEST_EAT_LARGE_128 \ 79 BOOST_PP_TUPLE_EAT() \ 80 ( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, \ 81 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99 ) \ 82 113 83 84 # define TEST_EAT_VERY_LARGE_128 \ 85 BOOST_PP_TUPLE_EAT() \ 86 ( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, \ 87 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127 ) \ 88 123 89 90 #endif 91 92 #if BOOST_PP_LIMIT_TUPLE > 128 93 94 # define TEST_EAT_LARGE_256 \ 95 BOOST_PP_TUPLE_EAT() \ 96 ( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, \ 97 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, \ 98 128, 129, 130, 131, 132, 133, 134 ) \ 99 75 100 101 # define TEST_EAT_VERY_LARGE_256 \ 102 BOOST_PP_TUPLE_EAT() \ 103 ( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, \ 104 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, \ 105 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, \ 106 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255 ) \ 107 224 108 109 #endif 110 111 // elem 112 113 BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_TUPLE_ELEM(1, 0, TUPLE_NONE)) == 1 END 114 BEGIN BOOST_PP_TUPLE_ELEM(6, 3, TUPLE) == 3 END 115 BEGIN BOOST_PP_TUPLE_ELEM(6, 5, TUPLE) == 5 END 116 BEGIN BOOST_PP_TUPLE_ELEM(33, 15, TUPLE_LARGE) == 15 END 117 BEGIN BOOST_PP_TUPLE_ELEM(33, 27, TUPLE_LARGE) == 27 END 118 BEGIN BOOST_PP_TUPLE_ELEM(33, 32, TUPLE_LARGE) == 32 END 119 BEGIN BOOST_PP_TUPLE_ELEM(64, 22, TUPLE_VERY_LARGE) == 22 END 120 BEGIN BOOST_PP_TUPLE_ELEM(64, 47, TUPLE_VERY_LARGE) == 47 END 121 BEGIN BOOST_PP_TUPLE_ELEM(64, 63, TUPLE_VERY_LARGE) == 63 END 122 123 #if BOOST_PP_LIMIT_TUPLE > 64 124 125 BEGIN BOOST_PP_TUPLE_ELEM(104, 73, TUPLE_LARGE_128) == 73 END 126 BEGIN BOOST_PP_TUPLE_ELEM(104, 89, TUPLE_LARGE_128) == 89 END 127 BEGIN BOOST_PP_TUPLE_ELEM(104, 101, TUPLE_LARGE_128) == 101 END 128 BEGIN BOOST_PP_TUPLE_ELEM(128, 95, TUPLE_VERY_LARGE_128) == 95 END 129 BEGIN BOOST_PP_TUPLE_ELEM(128, 110, TUPLE_VERY_LARGE_128) == 110 END 130 BEGIN BOOST_PP_TUPLE_ELEM(128, 126, TUPLE_VERY_LARGE_128) == 126 END 131 132 #endif 133 134 #if BOOST_PP_LIMIT_TUPLE > 128 135 136 BEGIN BOOST_PP_TUPLE_ELEM(142, 83, TUPLE_LARGE_256) == 83 END 137 BEGIN BOOST_PP_TUPLE_ELEM(142, 131, TUPLE_LARGE_256) == 131 END 138 BEGIN BOOST_PP_TUPLE_ELEM(142, 140, TUPLE_LARGE_256) == 140 END 139 BEGIN BOOST_PP_TUPLE_ELEM(256, 174, TUPLE_VERY_LARGE_256) == 174 END 140 BEGIN BOOST_PP_TUPLE_ELEM(256, 226, TUPLE_VERY_LARGE_256) == 226 END 141 BEGIN BOOST_PP_TUPLE_ELEM(256, 253, TUPLE_VERY_LARGE_256) == 253 END 142 143 #endif 144 145 // reverse 146 147 BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_TUPLE_ELEM(1, 0, BOOST_PP_TUPLE_REVERSE(1,TUPLE_NONE))) == 1 END 148 BEGIN BOOST_PP_TUPLE_ELEM(6, 2, BOOST_PP_TUPLE_REVERSE(6,TUPLE)) == 3 END 149 BEGIN BOOST_PP_TUPLE_ELEM(33, 27, BOOST_PP_TUPLE_REVERSE(33,TUPLE_LARGE)) == 5 END 150 BEGIN BOOST_PP_TUPLE_ELEM(64, 43, BOOST_PP_TUPLE_REVERSE(64,TUPLE_VERY_LARGE)) == 20 END 151 BEGIN CALC(T2) == 7 END 152 BEGIN CALC(BOOST_PP_TUPLE_REVERSE(3, T2)) == 6 END 153 154 #if BOOST_PP_LIMIT_TUPLE > 64 155 156 BEGIN BOOST_PP_TUPLE_ELEM(104, 83, BOOST_PP_TUPLE_REVERSE(104,TUPLE_LARGE_128)) == 20 END 157 BEGIN BOOST_PP_TUPLE_ELEM(128, 119, BOOST_PP_TUPLE_REVERSE(128,TUPLE_VERY_LARGE_128)) == 8 END 158 159 #endif 160 161 #if BOOST_PP_LIMIT_TUPLE > 128 162 163 BEGIN BOOST_PP_TUPLE_ELEM(142, 56, BOOST_PP_TUPLE_REVERSE(142,TUPLE_LARGE_256)) == 85 END 164 BEGIN BOOST_PP_TUPLE_ELEM(256, 212, BOOST_PP_TUPLE_REVERSE(256,TUPLE_VERY_LARGE_256)) == 43 END 165 166 #endif 167 168 // eat 169 170 BEGIN TEST_EAT == 4 END 171 BEGIN TEST_EAT_NONE == 17 END 172 BEGIN TEST_EAT_LARGE == 6 END 173 BEGIN TEST_EAT_VERY_LARGE == 8 END 174 175 #if BOOST_PP_LIMIT_TUPLE > 64 176 177 BEGIN TEST_EAT_LARGE_128 == 113 END 178 BEGIN TEST_EAT_VERY_LARGE_128 == 123 END 179 180 #endif 181 182 #if BOOST_PP_LIMIT_TUPLE > 128 183 184 BEGIN TEST_EAT_LARGE_256 == 75 END 185 BEGIN TEST_EAT_VERY_LARGE_256 == 224 END 186 187 #endif 188 189 // to_array 190 191 BEGIN BOOST_PP_ARRAY_ELEM(3,BOOST_PP_TUPLE_TO_ARRAY(6,TUPLE)) == 3 END 192 BEGIN BOOST_PP_ARRAY_ELEM(29,BOOST_PP_TUPLE_TO_ARRAY(33,TUPLE_LARGE)) == 29 END 193 BEGIN BOOST_PP_ARRAY_ELEM(61,BOOST_PP_TUPLE_TO_ARRAY(64,TUPLE_VERY_LARGE)) == 61 END 194 BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_ARRAY_ELEM(0,BOOST_PP_TUPLE_TO_ARRAY(1,TUPLE_NONE))) == 1 END 195 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_TUPLE_TO_ARRAY(1,TUPLE_NONE)) == 1 END 196 197 #if BOOST_PP_LIMIT_TUPLE > 64 198 199 BEGIN BOOST_PP_ARRAY_ELEM(65,BOOST_PP_TUPLE_TO_ARRAY(104,TUPLE_LARGE_128)) == 65 END 200 BEGIN BOOST_PP_ARRAY_ELEM(117,BOOST_PP_TUPLE_TO_ARRAY(128,TUPLE_VERY_LARGE_128)) == 117 END 201 202 #endif 203 204 #if BOOST_PP_LIMIT_TUPLE > 128 205 206 BEGIN BOOST_PP_ARRAY_ELEM(131,BOOST_PP_TUPLE_TO_ARRAY(142,TUPLE_LARGE_256)) == 131 END 207 BEGIN BOOST_PP_ARRAY_ELEM(197,BOOST_PP_TUPLE_TO_ARRAY(256,TUPLE_VERY_LARGE_256)) == 197 END 208 209 #endif 210 211 // to_list 212 213 BEGIN BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(6,TUPLE), 2) == 2 END 214 BEGIN BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(33,TUPLE_LARGE), 19) == 19 END 215 BEGIN BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(64,TUPLE_VERY_LARGE), 62) == 62 END 216 BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(1,TUPLE_NONE), 0)) == 1 END 217 BEGIN BOOST_PP_LIST_SIZE(BOOST_PP_TUPLE_TO_LIST(1,TUPLE_NONE)) == 1 END 218 219 #if BOOST_PP_LIMIT_TUPLE > 64 220 221 BEGIN BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(104,TUPLE_LARGE_128), 88) == 88 END 222 BEGIN BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(128,TUPLE_VERY_LARGE_128), 113) == 113 END 223 224 #endif 225 226 #if BOOST_PP_LIMIT_TUPLE > 128 227 228 BEGIN BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(142,TUPLE_LARGE_256), 137) == 137 END 229 BEGIN BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(256,TUPLE_VERY_LARGE_256), 235) == 235 END 230 231 #endif 232 233 // to_seq 234 235 BEGIN BOOST_PP_SEQ_ELEM(4,BOOST_PP_TUPLE_TO_SEQ(6,TUPLE)) == 4 END 236 BEGIN BOOST_PP_SEQ_ELEM(31,BOOST_PP_TUPLE_TO_SEQ(33,TUPLE_LARGE)) == 31 END 237 BEGIN BOOST_PP_SEQ_ELEM(55,BOOST_PP_TUPLE_TO_SEQ(64,TUPLE_VERY_LARGE)) == 55 END 238 BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_SEQ_ELEM(0,BOOST_PP_TUPLE_TO_SEQ(1,TUPLE_NONE))) == 1 END 239 BEGIN BOOST_PP_SEQ_SIZE(BOOST_PP_TUPLE_TO_SEQ(1,TUPLE_NONE)) == 1 END 240 241 #if BOOST_PP_LIMIT_TUPLE > 64 242 243 BEGIN BOOST_PP_SEQ_ELEM(97,BOOST_PP_TUPLE_TO_SEQ(104,TUPLE_LARGE_128)) == 97 END 244 BEGIN BOOST_PP_SEQ_ELEM(123,BOOST_PP_TUPLE_TO_SEQ(128,TUPLE_VERY_LARGE_128)) == 123 END 245 246 #endif 247 248 #if BOOST_PP_LIMIT_TUPLE > 128 249 250 BEGIN BOOST_PP_SEQ_ELEM(53,BOOST_PP_TUPLE_TO_SEQ(142,TUPLE_LARGE_256)) == 53 END 251 BEGIN BOOST_PP_SEQ_ELEM(181,BOOST_PP_TUPLE_TO_SEQ(256,TUPLE_VERY_LARGE_256)) == 181 END 252 253 #endif 254 255 // elem 256 257 BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_TUPLE_ELEM(0, TUPLE_NONE)) == 1 END 258 BEGIN BOOST_PP_TUPLE_ELEM(3, TUPLE) == 3 END 259 BEGIN BOOST_PP_TUPLE_ELEM(5, TUPLE) == 5 END 260 BEGIN BOOST_PP_TUPLE_ELEM(15, TUPLE_LARGE) == 15 END 261 BEGIN BOOST_PP_TUPLE_ELEM(27, TUPLE_LARGE) == 27 END 262 BEGIN BOOST_PP_TUPLE_ELEM(32, TUPLE_LARGE) == 32 END 263 BEGIN BOOST_PP_TUPLE_ELEM(22, TUPLE_VERY_LARGE) == 22 END 264 BEGIN BOOST_PP_TUPLE_ELEM(47, TUPLE_VERY_LARGE) == 47 END 265 BEGIN BOOST_PP_TUPLE_ELEM(63, TUPLE_VERY_LARGE) == 63 END 266 267 #if BOOST_PP_LIMIT_TUPLE > 64 268 269 BEGIN BOOST_PP_TUPLE_ELEM(73, TUPLE_LARGE_128) == 73 END 270 BEGIN BOOST_PP_TUPLE_ELEM(89, TUPLE_LARGE_128) == 89 END 271 BEGIN BOOST_PP_TUPLE_ELEM(101, TUPLE_LARGE_128) == 101 END 272 BEGIN BOOST_PP_TUPLE_ELEM(95, TUPLE_VERY_LARGE_128) == 95 END 273 BEGIN BOOST_PP_TUPLE_ELEM(110, TUPLE_VERY_LARGE_128) == 110 END 274 BEGIN BOOST_PP_TUPLE_ELEM(126, TUPLE_VERY_LARGE_128) == 126 END 275 276 #endif 277 278 #if BOOST_PP_LIMIT_TUPLE > 128 279 280 BEGIN BOOST_PP_TUPLE_ELEM(83, TUPLE_LARGE_256) == 83 END 281 BEGIN BOOST_PP_TUPLE_ELEM(131, TUPLE_LARGE_256) == 131 END 282 BEGIN BOOST_PP_TUPLE_ELEM(140, TUPLE_LARGE_256) == 140 END 283 BEGIN BOOST_PP_TUPLE_ELEM(174, TUPLE_VERY_LARGE_256) == 174 END 284 BEGIN BOOST_PP_TUPLE_ELEM(226, TUPLE_VERY_LARGE_256) == 226 END 285 BEGIN BOOST_PP_TUPLE_ELEM(253, TUPLE_VERY_LARGE_256) == 253 END 286 287 #endif 288 289 // reverse 290 291 BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_TUPLE_ELEM(0, BOOST_PP_TUPLE_REVERSE(TUPLE_NONE))) == 1 END 292 BEGIN BOOST_PP_TUPLE_ELEM(2, BOOST_PP_TUPLE_REVERSE(TUPLE)) == 3 END 293 BEGIN BOOST_PP_TUPLE_ELEM(27, BOOST_PP_TUPLE_REVERSE(TUPLE_LARGE)) == 5 END 294 BEGIN BOOST_PP_TUPLE_ELEM(43, BOOST_PP_TUPLE_REVERSE(TUPLE_VERY_LARGE)) == 20 END 295 BEGIN CALC(BOOST_PP_TUPLE_REVERSE(T2)) == 6 END 296 BEGIN BOOST_PP_VARIADIC_ELEM(2,BOOST_PP_TUPLE_ENUM(BOOST_PP_TUPLE_REVERSE(TUPLE))) == 3 END 297 BEGIN BOOST_PP_VARIADIC_ELEM(27,BOOST_PP_TUPLE_ENUM(BOOST_PP_TUPLE_REVERSE(TUPLE_LARGE))) == 5 END 298 BEGIN BOOST_PP_VARIADIC_ELEM(45,BOOST_PP_TUPLE_ENUM(BOOST_PP_TUPLE_REVERSE(TUPLE_VERY_LARGE))) == 18 END 299 300 #if BOOST_PP_LIMIT_TUPLE > 64 301 302 BEGIN BOOST_PP_TUPLE_ELEM(83, BOOST_PP_TUPLE_REVERSE(TUPLE_LARGE_128)) == 20 END 303 BEGIN BOOST_PP_TUPLE_ELEM(119, BOOST_PP_TUPLE_REVERSE(TUPLE_VERY_LARGE_128)) == 8 END 304 305 #endif 306 307 #if BOOST_PP_LIMIT_TUPLE > 128 308 309 BEGIN BOOST_PP_TUPLE_ELEM(56, BOOST_PP_TUPLE_REVERSE(TUPLE_LARGE_256)) == 85 END 310 BEGIN BOOST_PP_TUPLE_ELEM(212, BOOST_PP_TUPLE_REVERSE(TUPLE_VERY_LARGE_256)) == 43 END 311 312 #endif 313 314 // enum 315 316 # if BOOST_PP_VARIADIC_HAS_OPT() 317 318 BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_ENUM(TUPLE_NONE)) == 0 END 319 320 # else 321 322 BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_ENUM(TUPLE_NONE)) == 1 END 323 324 # endif 325 326 BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_ENUM(TUPLE)) == 6 END 327 BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_ENUM(TUPLE_LARGE)) == 33 END 328 BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_ENUM(TUPLE_VERY_LARGE)) == 64 END 329 330 #if BOOST_PP_LIMIT_TUPLE > 64 331 332 BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_ENUM(TUPLE_LARGE_128)) == 104 END 333 BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_ENUM(TUPLE_VERY_LARGE_128)) == 128 END 334 335 #endif 336 337 #if BOOST_PP_LIMIT_TUPLE > 128 338 339 BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_ENUM(TUPLE_LARGE_256)) == 142 END 340 BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_ENUM(TUPLE_VERY_LARGE_256)) == 256 END 341 342 #endif 343 344 // insert 345 346 BEGIN BOOST_PP_TUPLE_ELEM(0, BOOST_PP_TUPLE_INSERT(TUPLE_NONE,0,40)) == 40 END 347 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_INSERT(TUPLE_NONE,0,40)) == 2 END 348 349 BEGIN BOOST_PP_TUPLE_ELEM(0, BOOST_PP_TUPLE_INSERT(TUPLE,2,40)) == 0 END 350 BEGIN BOOST_PP_TUPLE_ELEM(1, BOOST_PP_TUPLE_INSERT(TUPLE,1,40)) == 40 END 351 BEGIN BOOST_PP_TUPLE_ELEM(2, BOOST_PP_TUPLE_INSERT(TUPLE,1,40)) == 1 END 352 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_INSERT(TUPLE,1,40)) == 7 END 353 354 BEGIN BOOST_PP_TUPLE_ELEM(8, BOOST_PP_TUPLE_INSERT(TUPLE_LARGE,22,1000)) == 8 END 355 BEGIN BOOST_PP_TUPLE_ELEM(22, BOOST_PP_TUPLE_INSERT(TUPLE_LARGE,22,1000)) == 1000 END 356 BEGIN BOOST_PP_TUPLE_ELEM(26, BOOST_PP_TUPLE_INSERT(TUPLE_LARGE,22,1000)) == 25 END 357 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_INSERT(TUPLE_LARGE,22,1000)) == 34 END 358 359 #if BOOST_PP_LIMIT_TUPLE > 64 360 361 BEGIN BOOST_PP_TUPLE_ELEM(69, BOOST_PP_TUPLE_INSERT(TUPLE_LARGE_128,76,1000)) == 69 END 362 BEGIN BOOST_PP_TUPLE_ELEM(101, BOOST_PP_TUPLE_INSERT(TUPLE_LARGE_128,101,1000)) == 1000 END 363 BEGIN BOOST_PP_TUPLE_ELEM(98, BOOST_PP_TUPLE_INSERT(TUPLE_LARGE_128,96,1000)) == 97 END 364 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_INSERT(TUPLE_LARGE_128,84,1000)) == 105 END 365 366 #endif 367 368 #if BOOST_PP_LIMIT_TUPLE > 128 369 370 BEGIN BOOST_PP_TUPLE_ELEM(73, BOOST_PP_TUPLE_INSERT(TUPLE_LARGE_256,134,1000)) == 73 END 371 BEGIN BOOST_PP_TUPLE_ELEM(141, BOOST_PP_TUPLE_INSERT(TUPLE_LARGE_256,141,1000)) == 1000 END 372 BEGIN BOOST_PP_TUPLE_ELEM(133, BOOST_PP_TUPLE_INSERT(TUPLE_LARGE_256,39,1000)) == 132 END 373 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_INSERT(TUPLE_LARGE_256,121,1000)) == 143 END 374 BEGIN BOOST_PP_TUPLE_ELEM(227,BOOST_PP_TUPLE_INSERT(TUPLE_VERY_LARGE_255,212,1000)) == 226 END 375 BEGIN BOOST_PP_TUPLE_ELEM(212,BOOST_PP_TUPLE_INSERT(TUPLE_VERY_LARGE_255,212,1000)) == 1000 END 376 377 #endif 378 379 // pop_back 380 381 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_BACK(TUPLE)) == 5 END 382 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_BACK(TUPLE_LARGE)) == 32 END 383 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_BACK(TUPLE_VERY_LARGE)) == 63 END 384 385 #if BOOST_PP_LIMIT_TUPLE > 64 386 387 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_BACK(TUPLE_LARGE_128)) == 103 END 388 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_BACK(TUPLE_VERY_LARGE_128)) == 127 END 389 390 #endif 391 392 #if BOOST_PP_LIMIT_TUPLE > 128 393 394 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_BACK(TUPLE_LARGE_256)) == 141 END 395 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_BACK(TUPLE_VERY_LARGE_256)) == 255 END 396 397 #endif 398 399 // pop_front 400 401 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_FRONT(TUPLE)) == 5 END 402 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_FRONT(TUPLE_LARGE)) == 32 END 403 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_FRONT(TUPLE_VERY_LARGE)) == 63 END 404 405 BEGIN BOOST_PP_TUPLE_ELEM(1, BOOST_PP_TUPLE_POP_FRONT(TUPLE)) == 2 END 406 BEGIN BOOST_PP_TUPLE_ELEM(31, BOOST_PP_TUPLE_POP_FRONT(TUPLE_LARGE)) == 32 END 407 BEGIN BOOST_PP_TUPLE_ELEM(55, BOOST_PP_TUPLE_POP_FRONT(TUPLE_VERY_LARGE)) == 56 END 408 409 #if BOOST_PP_LIMIT_TUPLE > 64 410 411 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_FRONT(TUPLE_LARGE_128)) == 103 END 412 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_FRONT(TUPLE_VERY_LARGE_128)) == 127 END 413 BEGIN BOOST_PP_TUPLE_ELEM(84, BOOST_PP_TUPLE_POP_FRONT(TUPLE_LARGE_128)) == 85 END 414 BEGIN BOOST_PP_TUPLE_ELEM(117, BOOST_PP_TUPLE_POP_FRONT(TUPLE_VERY_LARGE_128)) == 118 END 415 416 #endif 417 418 #if BOOST_PP_LIMIT_TUPLE > 128 419 420 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_FRONT(TUPLE_LARGE_256)) == 141 END 421 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_FRONT(TUPLE_VERY_LARGE_256)) == 255 END 422 BEGIN BOOST_PP_TUPLE_ELEM(129, BOOST_PP_TUPLE_POP_FRONT(TUPLE_LARGE_256)) == 130 END 423 BEGIN BOOST_PP_TUPLE_ELEM(248, BOOST_PP_TUPLE_POP_FRONT(TUPLE_VERY_LARGE_256)) == 249 END 424 425 #endif 426 427 // push_back 428 429 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_PUSH_BACK(TUPLE_NONE, 1)) == 2 END 430 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_PUSH_BACK(TUPLE, 6)) == 7 END 431 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_PUSH_BACK(TUPLE_LARGE, 33)) == 34 END 432 BEGIN BOOST_PP_TUPLE_ELEM(1, BOOST_PP_TUPLE_PUSH_BACK(TUPLE_NONE, 1)) == 1 END 433 BEGIN BOOST_PP_TUPLE_ELEM(0, BOOST_PP_TUPLE_PUSH_BACK(TUPLE, 6)) == 0 END 434 BEGIN BOOST_PP_TUPLE_ELEM(33, BOOST_PP_TUPLE_PUSH_BACK(TUPLE_LARGE, 33)) == 33 END 435 436 #if BOOST_PP_LIMIT_TUPLE > 64 437 438 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_PUSH_BACK(TUPLE_LARGE_128, 66)) == 105 END 439 BEGIN BOOST_PP_TUPLE_ELEM(104, BOOST_PP_TUPLE_PUSH_BACK(TUPLE_LARGE_128, 101)) == 101 END 440 441 #endif 442 443 #if BOOST_PP_LIMIT_TUPLE > 128 444 445 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_PUSH_BACK(TUPLE_LARGE_256, 192)) == 143 END 446 BEGIN BOOST_PP_TUPLE_ELEM(142, BOOST_PP_TUPLE_PUSH_BACK(TUPLE_LARGE_256, 77)) == 77 END 447 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_PUSH_BACK(TUPLE_VERY_LARGE_255, 255)) == 256 END 448 449 #endif 450 451 // push_front 452 453 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_PUSH_FRONT(TUPLE_NONE, 55)) == 2 END 454 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_PUSH_FRONT(TUPLE, 555)) == 7 END 455 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_PUSH_FRONT(TUPLE_LARGE, 666)) == 34 END 456 BEGIN BOOST_PP_TUPLE_ELEM(0, BOOST_PP_TUPLE_PUSH_FRONT(TUPLE_NONE, 55)) == 55 END 457 BEGIN BOOST_PP_TUPLE_ELEM(0, BOOST_PP_TUPLE_PUSH_FRONT(TUPLE, 555)) == 555 END 458 BEGIN BOOST_PP_TUPLE_ELEM(33, BOOST_PP_TUPLE_PUSH_FRONT(TUPLE_LARGE, 33)) == 32 END 459 460 #if BOOST_PP_LIMIT_TUPLE > 64 461 462 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_PUSH_FRONT(TUPLE_LARGE_128, 666)) == 105 END 463 BEGIN BOOST_PP_TUPLE_ELEM(103, BOOST_PP_TUPLE_PUSH_FRONT(TUPLE_LARGE_128, 29)) == 102 END 464 465 #endif 466 467 #if BOOST_PP_LIMIT_TUPLE > 128 468 469 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_PUSH_FRONT(TUPLE_LARGE_256, 333)) == 143 END 470 BEGIN BOOST_PP_TUPLE_ELEM(136, BOOST_PP_TUPLE_PUSH_FRONT(TUPLE_LARGE_256, 47)) == 135 END 471 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_PUSH_FRONT(TUPLE_VERY_LARGE_255, 4)) == 256 END 472 473 #endif 474 475 // rem 476 477 #if BOOST_PP_VARIADICS_MSVC && _MSC_VER <= 1400 478 479 # if BOOST_PP_VARIADIC_HAS_OPT() 480 481 BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM(1)()) == 0 END 482 483 # else 484 485 BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM(1)()) == 1 END 486 487 # endif 488 489 BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM(33)(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32)) == 33 END 490 BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM(64)(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63)) == 64 END 491 492 #else 493 494 #if BOOST_PP_VARIADICS_MSVC 495 BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_TUPLE_REM_CAT() TUPLE_NONE) == 1 END 496 #else 497 BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_TUPLE_REM() TUPLE_NONE) == 1 END 498 #endif 499 500 BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM()(0, 1, 2, 3, 4, 5)) == 6 END 501 BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM()(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32)) == 33 END 502 BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM()(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63)) == 64 END 503 504 #endif 505 506 // rem_ctor 507 508 # if BOOST_PP_VARIADIC_HAS_OPT() 509 510 BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM_CTOR(TUPLE_NONE)) == 0 END 511 512 # else 513 514 BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM_CTOR(TUPLE_NONE)) == 1 END 515 516 # endif 517 518 BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM_CTOR(TUPLE)) == 6 END 519 BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM_CTOR(TUPLE_LARGE)) == 33 END 520 BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM_CTOR(TUPLE_VERY_LARGE)) == 64 END 521 522 #if BOOST_PP_LIMIT_TUPLE > 64 523 524 BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM_CTOR(TUPLE_LARGE_128)) == 104 END 525 BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM_CTOR(TUPLE_VERY_LARGE_128)) == 128 END 526 527 #endif 528 529 #if BOOST_PP_LIMIT_TUPLE > 128 530 531 BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM_CTOR(TUPLE_LARGE_256)) == 142 END 532 BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM_CTOR(TUPLE_VERY_LARGE_256)) == 256 END 533 534 #endif 535 536 // remove 537 538 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_REMOVE(TUPLE, 1)) == 5 END 539 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_REMOVE(TUPLE_LARGE, 17)) == 32 END 540 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_REMOVE(TUPLE_VERY_LARGE, 27)) == 63 END 541 BEGIN BOOST_PP_TUPLE_ELEM(0, BOOST_PP_TUPLE_REMOVE(TUPLE, 2)) == 0 END 542 BEGIN BOOST_PP_TUPLE_ELEM(29, BOOST_PP_TUPLE_REMOVE(TUPLE_LARGE, 25)) == 30 END 543 BEGIN BOOST_PP_TUPLE_ELEM(62, BOOST_PP_TUPLE_REMOVE(TUPLE_VERY_LARGE, 48)) == 63 END 544 545 #if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT() 546 547 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_REMOVE(TUPLE_LARGE, 0)) == 32 END 548 BEGIN BOOST_PP_TUPLE_ELEM(25, BOOST_PP_TUPLE_REMOVE(TUPLE_VERY_LARGE, 0)) == 26 END 549 550 #endif 551 552 #if BOOST_PP_LIMIT_TUPLE > 64 553 554 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_REMOVE(TUPLE_LARGE_128, 100)) == 103 END 555 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_REMOVE(TUPLE_VERY_LARGE_128, 123)) == 127 END 556 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_REMOVE(TUPLE_VERY_LARGE_128, 0)) == 127 END 557 BEGIN BOOST_PP_TUPLE_ELEM(102, BOOST_PP_TUPLE_REMOVE(TUPLE_LARGE_128, 97)) == 103 END 558 BEGIN BOOST_PP_TUPLE_ELEM(76, BOOST_PP_TUPLE_REMOVE(TUPLE_LARGE_128, 0)) == 77 END 559 BEGIN BOOST_PP_TUPLE_ELEM(119, BOOST_PP_TUPLE_REMOVE(TUPLE_VERY_LARGE_128, 115)) == 120 END 560 561 #endif 562 563 #if BOOST_PP_LIMIT_TUPLE > 128 564 565 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_REMOVE(TUPLE_LARGE_256, 133)) == 141 END 566 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_REMOVE(TUPLE_LARGE_256, 0)) == 141 END 567 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_REMOVE(TUPLE_VERY_LARGE_256, 241)) == 255 END 568 BEGIN BOOST_PP_TUPLE_ELEM(140, BOOST_PP_TUPLE_REMOVE(TUPLE_LARGE_256, 138)) == 141 END 569 BEGIN BOOST_PP_TUPLE_ELEM(181, BOOST_PP_TUPLE_REMOVE(TUPLE_VERY_LARGE_256, 166)) == 182 END 570 BEGIN BOOST_PP_TUPLE_ELEM(236, BOOST_PP_TUPLE_REMOVE(TUPLE_VERY_LARGE_256, 0)) == 237 END 571 572 #endif 573 574 // replace 575 576 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE, 27, 1000)) == 64 END 577 BEGIN BOOST_PP_TUPLE_ELEM(0, BOOST_PP_TUPLE_REPLACE(TUPLE_NONE, 0, 71)) == 71 END 578 BEGIN BOOST_PP_TUPLE_ELEM(0, BOOST_PP_TUPLE_REPLACE(TUPLE, 1, 44)) == 0 END 579 BEGIN BOOST_PP_TUPLE_ELEM(29, BOOST_PP_TUPLE_REPLACE(TUPLE_LARGE, 29, 999)) == 999 END 580 BEGIN BOOST_PP_TUPLE_ELEM(38, BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE, 37, 1)) == 38 END 581 BEGIN BOOST_PP_TUPLE_ELEM(28, BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE, 28, 1)) == 1 END 582 583 #if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT() 584 585 BEGIN BOOST_PP_TUPLE_ELEM(0, BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE, 0, 64)) == 64 END 586 BEGIN BOOST_PP_TUPLE_ELEM(17, BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE, 0, 256)) == 17 END 587 588 #endif 589 590 #if BOOST_PP_LIMIT_TUPLE > 64 591 592 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE_128, 93, 1000)) == 128 END 593 BEGIN BOOST_PP_TUPLE_ELEM(89, BOOST_PP_TUPLE_REPLACE(TUPLE_LARGE_128, 89, 111)) == 111 END 594 BEGIN BOOST_PP_TUPLE_ELEM(73, BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE_128, 66, 1)) == 73 END 595 BEGIN BOOST_PP_TUPLE_ELEM(122, BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE_128, 122, 1)) == 1 END 596 BEGIN BOOST_PP_TUPLE_ELEM(0, BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE_128, 0, 128)) == 128 END 597 BEGIN BOOST_PP_TUPLE_ELEM(95, BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE_128, 0, 128)) == 95 END 598 599 #endif 600 601 #if BOOST_PP_LIMIT_TUPLE > 128 602 603 BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE_256, 217, 1000)) == 256 END 604 BEGIN BOOST_PP_TUPLE_ELEM(136, BOOST_PP_TUPLE_REPLACE(TUPLE_LARGE_256, 136, 999)) == 999 END 605 BEGIN BOOST_PP_TUPLE_ELEM(192, BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE_256, 185, 1)) == 192 END 606 BEGIN BOOST_PP_TUPLE_ELEM(237, BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE_256, 237, 1)) == 1 END 607 BEGIN BOOST_PP_TUPLE_ELEM(0, BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE_256, 0, 256)) == 256 END 608 BEGIN BOOST_PP_TUPLE_ELEM(167, BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE_256, 0, 256)) == 167 END 609 610 #endif 611 612 // size 613 614 BEGIN BOOST_PP_TUPLE_SIZE(TUPLE_NONE) == 1 END 615 BEGIN BOOST_PP_TUPLE_SIZE(TUPLE) == 6 END 616 BEGIN BOOST_PP_TUPLE_SIZE(TUPLE_LARGE) == 33 END 617 BEGIN BOOST_PP_TUPLE_SIZE(TUPLE_VERY_LARGE) == 64 END 618 619 #if BOOST_PP_LIMIT_TUPLE > 64 620 621 BEGIN BOOST_PP_TUPLE_SIZE(TUPLE_LARGE_128) == 104 END 622 BEGIN BOOST_PP_TUPLE_SIZE(TUPLE_VERY_LARGE_128) == 128 END 623 624 #endif 625 626 #if BOOST_PP_LIMIT_TUPLE > 128 627 628 BEGIN BOOST_PP_TUPLE_SIZE(TUPLE_LARGE_256) == 142 END 629 BEGIN BOOST_PP_TUPLE_SIZE(TUPLE_VERY_LARGE_256) == 256 END 630 631 #endif 632 633 // to_array 634 635 BEGIN BOOST_PP_ARRAY_ELEM(3,BOOST_PP_TUPLE_TO_ARRAY(TUPLE)) == 3 END 636 BEGIN BOOST_PP_ARRAY_ELEM(29,BOOST_PP_TUPLE_TO_ARRAY(TUPLE_LARGE)) == 29 END 637 BEGIN BOOST_PP_ARRAY_ELEM(61,BOOST_PP_TUPLE_TO_ARRAY(TUPLE_VERY_LARGE)) == 61 END 638 BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_ARRAY_ELEM(0,BOOST_PP_TUPLE_TO_ARRAY(TUPLE_NONE))) == 1 END 639 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_TUPLE_TO_ARRAY(TUPLE_NONE)) == 1 END 640 641 #if BOOST_PP_LIMIT_TUPLE > 64 642 643 BEGIN BOOST_PP_ARRAY_ELEM(65,BOOST_PP_TUPLE_TO_ARRAY(TUPLE_LARGE_128)) == 65 END 644 BEGIN BOOST_PP_ARRAY_ELEM(117,BOOST_PP_TUPLE_TO_ARRAY(TUPLE_VERY_LARGE_128)) == 117 END 645 646 #endif 647 648 #if BOOST_PP_LIMIT_TUPLE > 128 649 650 BEGIN BOOST_PP_ARRAY_ELEM(131,BOOST_PP_TUPLE_TO_ARRAY(TUPLE_LARGE_256)) == 131 END 651 BEGIN BOOST_PP_ARRAY_ELEM(197,BOOST_PP_TUPLE_TO_ARRAY(TUPLE_VERY_LARGE_256)) == 197 END 652 653 #endif 654 655 // to_list 656 657 BEGIN BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(TUPLE), 2) == 2 END 658 BEGIN BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(TUPLE_LARGE), 19) == 19 END 659 BEGIN BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(TUPLE_VERY_LARGE), 62) == 62 END 660 BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(TUPLE_NONE), 0)) == 1 END 661 BEGIN BOOST_PP_LIST_SIZE(BOOST_PP_TUPLE_TO_LIST(TUPLE_NONE)) == 1 END 662 663 #if BOOST_PP_LIMIT_TUPLE > 64 664 665 BEGIN BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(TUPLE_LARGE_128), 88) == 88 END 666 BEGIN BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(TUPLE_VERY_LARGE_128), 113) == 113 END 667 668 #endif 669 670 #if BOOST_PP_LIMIT_TUPLE > 128 671 672 BEGIN BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(TUPLE_LARGE_256), 137) == 137 END 673 BEGIN BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(TUPLE_VERY_LARGE_256), 235) == 235 END 674 675 #endif 676 677 // to_seq 678 679 BEGIN BOOST_PP_SEQ_ELEM(4,BOOST_PP_TUPLE_TO_SEQ(TUPLE)) == 4 END 680 BEGIN BOOST_PP_SEQ_ELEM(31,BOOST_PP_TUPLE_TO_SEQ(TUPLE_LARGE)) == 31 END 681 BEGIN BOOST_PP_SEQ_ELEM(55,BOOST_PP_TUPLE_TO_SEQ(TUPLE_VERY_LARGE)) == 55 END 682 BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_SEQ_ELEM(0,BOOST_PP_TUPLE_TO_SEQ(TUPLE_NONE))) == 1 END 683 BEGIN BOOST_PP_SEQ_SIZE(BOOST_PP_TUPLE_TO_SEQ(TUPLE_NONE)) == 1 END 684 685 #if BOOST_PP_LIMIT_TUPLE > 64 686 687 BEGIN BOOST_PP_SEQ_ELEM(97,BOOST_PP_TUPLE_TO_SEQ(TUPLE_LARGE_128)) == 97 END 688 BEGIN BOOST_PP_SEQ_ELEM(123,BOOST_PP_TUPLE_TO_SEQ(TUPLE_VERY_LARGE_128)) == 123 END 689 690 #endif 691 692 #if BOOST_PP_LIMIT_TUPLE > 128 693 694 BEGIN BOOST_PP_SEQ_ELEM(53,BOOST_PP_TUPLE_TO_SEQ(TUPLE_LARGE_256)) == 53 END 695 BEGIN BOOST_PP_SEQ_ELEM(181,BOOST_PP_TUPLE_TO_SEQ(TUPLE_VERY_LARGE_256)) == 181 END 696 697 #endif 698