diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 983952f7..bc1c2e80 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -18,150 +18,150 @@ jobs: matrix: include: - toolset: gcc-4.8 - cxxstd: "03,11" + cxxstd: "11" container: ubuntu:18.04 os: ubuntu-latest install: g++-4.8 - toolset: gcc-5 - cxxstd: "03,11,14,1z" + cxxstd: "11,14,1z" container: ubuntu:18.04 os: ubuntu-latest install: g++-5 - toolset: gcc-6 - cxxstd: "03,11,14,1z" + cxxstd: "11,14,1z" container: ubuntu:18.04 os: ubuntu-latest install: g++-6 - toolset: gcc-7 - cxxstd: "03,11,14,17" + cxxstd: "11,14,17" os: ubuntu-20.04 install: g++-7 - toolset: gcc-8 - cxxstd: "03,11,14,17,2a" + cxxstd: "11,14,17,2a" os: ubuntu-20.04 install: g++-8 - toolset: gcc-9 - cxxstd: "03,11,14,17,2a" + cxxstd: "11,14,17,2a" os: ubuntu-20.04 - toolset: gcc-10 - cxxstd: "03,11,14,17,2a" + cxxstd: "11,14,17,2a" os: ubuntu-20.04 install: g++-10 - toolset: gcc-11 - cxxstd: "03,11,14,17,2a" + cxxstd: "11,14,17,2a" os: ubuntu-22.04 install: g++-11 - toolset: gcc-12 - cxxstd: "03,11,14,17,20,2b" + cxxstd: "11,14,17,20,2b" os: ubuntu-22.04 install: g++-12 - toolset: gcc-13 - cxxstd: "03,11,14,17,20,2b" + cxxstd: "11,14,17,20,2b" container: ubuntu:24.04 os: ubuntu-latest install: g++-13 - toolset: gcc-14 - cxxstd: "03,11,14,17,20,2b" + cxxstd: "11,14,17,20,2b" container: ubuntu:24.04 os: ubuntu-latest install: g++-14 - toolset: clang compiler: clang++-3.9 - cxxstd: "03,11,14" + cxxstd: "11,14" container: ubuntu:18.04 os: ubuntu-latest install: clang-3.9 - toolset: clang compiler: clang++-4.0 - cxxstd: "03,11,14" + cxxstd: "11,14" container: ubuntu:18.04 os: ubuntu-latest install: clang-4.0 - toolset: clang compiler: clang++-5.0 - cxxstd: "03,11,14,1z" + cxxstd: "11,14,1z" container: ubuntu:18.04 os: ubuntu-latest install: clang-5.0 - toolset: clang compiler: clang++-6.0 - cxxstd: "03,11,14,17" + cxxstd: "11,14,17" os: ubuntu-20.04 install: clang-6.0 - toolset: clang compiler: clang++-7 - cxxstd: "03,11,14,17" + cxxstd: "11,14,17" os: ubuntu-20.04 install: clang-7 - toolset: clang compiler: clang++-8 - cxxstd: "03,11,14,17,2a" + cxxstd: "11,14,17,2a" os: ubuntu-20.04 install: clang-8 - toolset: clang compiler: clang++-9 - cxxstd: "03,11,14,17,2a" + cxxstd: "11,14,17,2a" os: ubuntu-20.04 install: clang-9 - toolset: clang compiler: clang++-10 - cxxstd: "03,11,14,17,2a" + cxxstd: "11,14,17,2a" os: ubuntu-20.04 install: clang-10 - toolset: clang compiler: clang++-11 - cxxstd: "03,11,14,17,2a" + cxxstd: "11,14,17,2a" os: ubuntu-20.04 install: clang-11 - toolset: clang compiler: clang++-12 - cxxstd: "03,11,14,17,2a" + cxxstd: "11,14,17,2a" os: ubuntu-20.04 install: clang-12 - toolset: clang compiler: clang++-13 - cxxstd: "03,11,14,17,20,2b" + cxxstd: "11,14,17,20,2b" container: ubuntu:22.04 os: ubuntu-latest install: clang-13 - toolset: clang compiler: clang++-14 - cxxstd: "03,11,14,17,20,2b" + cxxstd: "11,14,17,20,2b" container: ubuntu:22.04 os: ubuntu-latest install: clang-14 - toolset: clang compiler: clang++-15 - cxxstd: "03,11,14,17,20,2b" + cxxstd: "11,14,17,20,2b" container: ubuntu:22.04 os: ubuntu-latest install: clang-15 - toolset: clang compiler: clang++-16 - cxxstd: "03,11,14,17,20,2b" + cxxstd: "11,14,17,20,2b" container: ubuntu:24.04 os: ubuntu-latest install: clang-16 - toolset: clang compiler: clang++-17 - cxxstd: "03,11,14,17,20,2b" + cxxstd: "11,14,17,20,2b" container: ubuntu:24.04 os: ubuntu-latest install: clang-17 - toolset: clang compiler: clang++-18 - cxxstd: "03,11,14,17,20,2b" + cxxstd: "11,14,17,20,2b" container: ubuntu:24.04 os: ubuntu-latest install: clang-18 - toolset: clang - cxxstd: "03,11,14,17,20,2b" + cxxstd: "11,14,17,20,2b" os: macos-13 - toolset: clang - cxxstd: "03,11,14,17,20,2b" + cxxstd: "11,14,17,20,2b" os: macos-14 - toolset: clang - cxxstd: "03,11,14,17,20,2b" + cxxstd: "11,14,17,20,2b" os: macos-15 runs-on: ${{matrix.os}} @@ -252,7 +252,7 @@ jobs: addrmd: 32,64 os: windows-2022 - toolset: gcc - cxxstd: "03,11,14,17,2a" + cxxstd: "11,14,17,2a" addrmd: 64 os: windows-2019 diff --git a/test/arithmetic.cxx b/test/arithmetic.cxx index caf509b1..c77bef84 100644 --- a/test/arithmetic.cxx +++ b/test/arithmetic.cxx @@ -15,310 +15,310 @@ /* addition */ -BEGIN BOOST_PP_ADD(2, 3) == 5 END +static_assert(BOOST_PP_ADD(2, 3) == 5, ""); -BEGIN BOOST_PP_ADD(BOOST_PP_ADD(2, 2), 2) == 6 END -BEGIN BOOST_PP_ADD(2, BOOST_PP_ADD(1, 4)) == 7 END -BEGIN BOOST_PP_ADD(BOOST_PP_ADD(2, 2), BOOST_PP_ADD(2, 2)) == 8 END +static_assert(BOOST_PP_ADD(BOOST_PP_ADD(2, 2), 2) == 6, ""); +static_assert(BOOST_PP_ADD(2, BOOST_PP_ADD(1, 4)) == 7, ""); +static_assert(BOOST_PP_ADD(BOOST_PP_ADD(2, 2), BOOST_PP_ADD(2, 2)) == 8, ""); #if BOOST_PP_LIMIT_MAG == 256 && BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT() -BEGIN BOOST_PP_ADD(1, 256) == 256 END -BEGIN BOOST_PP_ADD(256, 1) == 256 END -BEGIN BOOST_PP_ADD(2, 255) == 256 END -BEGIN BOOST_PP_ADD(255, 2) == 256 END -BEGIN BOOST_PP_ADD(1, 255) == 256 END -BEGIN BOOST_PP_ADD(255, 1) == 256 END +static_assert(BOOST_PP_ADD(1, 256) == 256, ""); +static_assert(BOOST_PP_ADD(256, 1) == 256, ""); +static_assert(BOOST_PP_ADD(2, 255) == 256, ""); +static_assert(BOOST_PP_ADD(255, 2) == 256, ""); +static_assert(BOOST_PP_ADD(1, 255) == 256, ""); +static_assert(BOOST_PP_ADD(255, 1) == 256, ""); #endif #if BOOST_PP_LIMIT_MAG == 512 -BEGIN BOOST_PP_ADD(374, 129) == 503 END +static_assert(BOOST_PP_ADD(374, 129) == 503, ""); -BEGIN BOOST_PP_ADD(1, 512) == 512 END -BEGIN BOOST_PP_ADD(512, 1) == 512 END -BEGIN BOOST_PP_ADD(2, 511) == 512 END -BEGIN BOOST_PP_ADD(511, 2) == 512 END +static_assert(BOOST_PP_ADD(1, 512) == 512, ""); +static_assert(BOOST_PP_ADD(512, 1) == 512, ""); +static_assert(BOOST_PP_ADD(2, 511) == 512, ""); +static_assert(BOOST_PP_ADD(511, 2) == 512, ""); -BEGIN BOOST_PP_ADD(BOOST_PP_ADD(134, 187), 95) == 416 END -BEGIN BOOST_PP_ADD(BOOST_PP_ADD(83, 120), BOOST_PP_ADD(204, 51)) == 458 END -BEGIN BOOST_PP_ADD(149, BOOST_PP_ADD(102, 137)) == 388 END -BEGIN BOOST_PP_ADD(357, BOOST_PP_ADD(102, 137)) == 512 END +static_assert(BOOST_PP_ADD(BOOST_PP_ADD(134, 187), 95) == 416, ""); +static_assert(BOOST_PP_ADD(BOOST_PP_ADD(83, 120), BOOST_PP_ADD(204, 51)) == 458, ""); +static_assert(BOOST_PP_ADD(149, BOOST_PP_ADD(102, 137)) == 388, ""); +static_assert(BOOST_PP_ADD(357, BOOST_PP_ADD(102, 137)) == 512, ""); #endif #if BOOST_PP_LIMIT_MAG == 1024 -BEGIN BOOST_PP_ADD(732, 188) == 920 END +static_assert(BOOST_PP_ADD(732, 188) == 920, ""); -BEGIN BOOST_PP_ADD(1, 1024) == 1024 END -BEGIN BOOST_PP_ADD(1024, 1) == 1024 END -BEGIN BOOST_PP_ADD(2, 1023) == 1024 END -BEGIN BOOST_PP_ADD(1023, 2) == 1024 END +static_assert(BOOST_PP_ADD(1, 1024) == 1024, ""); +static_assert(BOOST_PP_ADD(1024, 1) == 1024, ""); +static_assert(BOOST_PP_ADD(2, 1023) == 1024, ""); +static_assert(BOOST_PP_ADD(1023, 2) == 1024, ""); -BEGIN BOOST_PP_ADD(BOOST_PP_ADD(254, 525), 149) == 928 END -BEGIN BOOST_PP_ADD(BOOST_PP_ADD(241, 96), BOOST_PP_ADD(373, 175)) == 885 END -BEGIN BOOST_PP_ADD(792, BOOST_PP_ADD(356, 410)) == 1024 END +static_assert(BOOST_PP_ADD(BOOST_PP_ADD(254, 525), 149) == 928, ""); +static_assert(BOOST_PP_ADD(BOOST_PP_ADD(241, 96), BOOST_PP_ADD(373, 175)) == 885, ""); +static_assert(BOOST_PP_ADD(792, BOOST_PP_ADD(356, 410)) == 1024, ""); #endif /* subtraction */ -BEGIN BOOST_PP_SUB(11, 0) == 11 END -BEGIN BOOST_PP_SUB(12, 1) == 11 END -BEGIN BOOST_PP_SUB(3, 4) == 0 END +static_assert(BOOST_PP_SUB(11, 0) == 11, ""); +static_assert(BOOST_PP_SUB(12, 1) == 11, ""); +static_assert(BOOST_PP_SUB(3, 4) == 0, ""); -BEGIN BOOST_PP_SUB(5, BOOST_PP_SUB(3, 2)) == 4 END -BEGIN BOOST_PP_SUB(BOOST_PP_SUB(10, 5), 2) == 3 END -BEGIN BOOST_PP_SUB(BOOST_PP_SUB(7, 3), BOOST_PP_SUB(10, 8)) == 2 END +static_assert(BOOST_PP_SUB(5, BOOST_PP_SUB(3, 2)) == 4, ""); +static_assert(BOOST_PP_SUB(BOOST_PP_SUB(10, 5), 2) == 3, ""); +static_assert(BOOST_PP_SUB(BOOST_PP_SUB(7, 3), BOOST_PP_SUB(10, 8)) == 2, ""); #if BOOST_PP_LIMIT_MAG == 256 && BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT() -BEGIN BOOST_PP_SUB(1, 256) == 0 END -BEGIN BOOST_PP_SUB(256, 255) == 1 END +static_assert(BOOST_PP_SUB(1, 256) == 0, ""); +static_assert(BOOST_PP_SUB(256, 255) == 1, ""); #endif #if BOOST_PP_LIMIT_MAG == 512 -BEGIN BOOST_PP_SUB(315, 412) == 0 END -BEGIN BOOST_PP_SUB(511, 510) == 1 END -BEGIN BOOST_PP_SUB(463, 317) == 146 END -BEGIN BOOST_PP_SUB(272, 195) == 77 END +static_assert(BOOST_PP_SUB(315, 412) == 0, ""); +static_assert(BOOST_PP_SUB(511, 510) == 1, ""); +static_assert(BOOST_PP_SUB(463, 317) == 146, ""); +static_assert(BOOST_PP_SUB(272, 195) == 77, ""); -BEGIN BOOST_PP_SUB(1, 512) == 0 END -BEGIN BOOST_PP_SUB(512, 511) == 1 END +static_assert(BOOST_PP_SUB(1, 512) == 0, ""); +static_assert(BOOST_PP_SUB(512, 511) == 1, ""); -BEGIN BOOST_PP_SUB(371, BOOST_PP_SUB(3, 2)) == 370 END -BEGIN BOOST_PP_SUB(BOOST_PP_SUB(478, 211), 58) == 209 END -BEGIN BOOST_PP_SUB(BOOST_PP_SUB(395, 277), BOOST_PP_SUB(10, 7)) == 115 END -BEGIN BOOST_PP_SUB(BOOST_PP_SUB(412, 383), BOOST_PP_SUB(512, 506)) == 23 END +static_assert(BOOST_PP_SUB(371, BOOST_PP_SUB(3, 2)) == 370, ""); +static_assert(BOOST_PP_SUB(BOOST_PP_SUB(478, 211), 58) == 209, ""); +static_assert(BOOST_PP_SUB(BOOST_PP_SUB(395, 277), BOOST_PP_SUB(10, 7)) == 115, ""); +static_assert(BOOST_PP_SUB(BOOST_PP_SUB(412, 383), BOOST_PP_SUB(512, 506)) == 23, ""); #endif #if BOOST_PP_LIMIT_MAG == 1024 -BEGIN BOOST_PP_SUB(782, 849) == 0 END -BEGIN BOOST_PP_SUB(1023, 1022) == 1 END -BEGIN BOOST_PP_SUB(654, 538) == 116 END +static_assert(BOOST_PP_SUB(782, 849) == 0, ""); +static_assert(BOOST_PP_SUB(1023, 1022) == 1, ""); +static_assert(BOOST_PP_SUB(654, 538) == 116, ""); -BEGIN BOOST_PP_SUB(1, 1024) == 0 END -BEGIN BOOST_PP_SUB(1024, 1023) == 1 END +static_assert(BOOST_PP_SUB(1, 1024) == 0, ""); +static_assert(BOOST_PP_SUB(1024, 1023) == 1, ""); -BEGIN BOOST_PP_SUB(829, BOOST_PP_SUB(3, 2)) == 828 END -BEGIN BOOST_PP_SUB(BOOST_PP_SUB(616, 439), 92) == 85 END -BEGIN BOOST_PP_SUB(BOOST_PP_SUB(822, 547), BOOST_PP_SUB(1024, 1011)) == 262 END +static_assert(BOOST_PP_SUB(829, BOOST_PP_SUB(3, 2)) == 828, ""); +static_assert(BOOST_PP_SUB(BOOST_PP_SUB(616, 439), 92) == 85, ""); +static_assert(BOOST_PP_SUB(BOOST_PP_SUB(822, 547), BOOST_PP_SUB(1024, 1011)) == 262, ""); #endif /* multiplication */ -BEGIN BOOST_PP_MUL(0, 1) == 0 END -BEGIN BOOST_PP_MUL(1, 0) == 0 END -BEGIN BOOST_PP_MUL(1, 1) == 1 END -BEGIN BOOST_PP_MUL(4, 3) == 12 END +static_assert(BOOST_PP_MUL(0, 1) == 0, ""); +static_assert(BOOST_PP_MUL(1, 0) == 0, ""); +static_assert(BOOST_PP_MUL(1, 1) == 1, ""); +static_assert(BOOST_PP_MUL(4, 3) == 12, ""); -BEGIN BOOST_PP_MUL(BOOST_PP_MUL(2, 2), 2) == 8 END -BEGIN BOOST_PP_MUL(2, BOOST_PP_MUL(2, 2)) == 8 END -BEGIN BOOST_PP_MUL(BOOST_PP_MUL(2, 2), BOOST_PP_MUL(2, 2)) == 16 END +static_assert(BOOST_PP_MUL(BOOST_PP_MUL(2, 2), 2) == 8, ""); +static_assert(BOOST_PP_MUL(2, BOOST_PP_MUL(2, 2)) == 8, ""); +static_assert(BOOST_PP_MUL(BOOST_PP_MUL(2, 2), BOOST_PP_MUL(2, 2)) == 16, ""); #if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT() -BEGIN BOOST_PP_MUL(0, BOOST_PP_LIMIT_MAG) == 0 END -BEGIN BOOST_PP_MUL(1, BOOST_PP_LIMIT_MAG) == BOOST_PP_LIMIT_MAG END -BEGIN BOOST_PP_MUL(2, BOOST_PP_LIMIT_MAG) == BOOST_PP_LIMIT_MAG END -BEGIN BOOST_PP_MUL(BOOST_PP_LIMIT_MAG, 0) == 0 END -BEGIN BOOST_PP_MUL(BOOST_PP_LIMIT_MAG, 1) == BOOST_PP_LIMIT_MAG END -BEGIN BOOST_PP_MUL(BOOST_PP_LIMIT_MAG, 2) == BOOST_PP_LIMIT_MAG END +static_assert(BOOST_PP_MUL(0, BOOST_PP_LIMIT_MAG) == 0, ""); +static_assert(BOOST_PP_MUL(1, BOOST_PP_LIMIT_MAG) == BOOST_PP_LIMIT_MAG, ""); +static_assert(BOOST_PP_MUL(2, BOOST_PP_LIMIT_MAG) == BOOST_PP_LIMIT_MAG, ""); +static_assert(BOOST_PP_MUL(BOOST_PP_LIMIT_MAG, 0) == 0, ""); +static_assert(BOOST_PP_MUL(BOOST_PP_LIMIT_MAG, 1) == BOOST_PP_LIMIT_MAG, ""); +static_assert(BOOST_PP_MUL(BOOST_PP_LIMIT_MAG, 2) == BOOST_PP_LIMIT_MAG, ""); #endif #if BOOST_PP_LIMIT_MAG == 256 && BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT() -BEGIN BOOST_PP_MUL(17, 17) == 256 END -BEGIN BOOST_PP_MUL(0, 255) == 0 END -BEGIN BOOST_PP_MUL(1, 255) == 255 END -BEGIN BOOST_PP_MUL(2, 255) == 256 END -BEGIN BOOST_PP_MUL(255, 0) == 0 END -BEGIN BOOST_PP_MUL(255, 1) == 255 END -BEGIN BOOST_PP_MUL(255, 2) == 256 END +static_assert(BOOST_PP_MUL(17, 17) == 256, ""); +static_assert(BOOST_PP_MUL(0, 255) == 0, ""); +static_assert(BOOST_PP_MUL(1, 255) == 255, ""); +static_assert(BOOST_PP_MUL(2, 255) == 256, ""); +static_assert(BOOST_PP_MUL(255, 0) == 0, ""); +static_assert(BOOST_PP_MUL(255, 1) == 255, ""); +static_assert(BOOST_PP_MUL(255, 2) == 256, ""); #endif #if BOOST_PP_LIMIT_MAG == 512 -BEGIN BOOST_PP_MUL(0, 351) == 0 END -BEGIN BOOST_PP_MUL(489, 0) == 0 END -BEGIN BOOST_PP_MUL(1, 272) == 272 END -BEGIN BOOST_PP_MUL(34, 11) == 374 END +static_assert(BOOST_PP_MUL(0, 351) == 0, ""); +static_assert(BOOST_PP_MUL(489, 0) == 0, ""); +static_assert(BOOST_PP_MUL(1, 272) == 272, ""); +static_assert(BOOST_PP_MUL(34, 11) == 374, ""); -BEGIN BOOST_PP_MUL(BOOST_PP_MUL(7, 7), 7) == 343 END -BEGIN BOOST_PP_MUL(7, BOOST_PP_MUL(7, 7)) == 343 END -BEGIN BOOST_PP_MUL(BOOST_PP_MUL(5, 5), BOOST_PP_MUL(4, 4)) == 400 END +static_assert(BOOST_PP_MUL(BOOST_PP_MUL(7, 7), 7) == 343, ""); +static_assert(BOOST_PP_MUL(7, BOOST_PP_MUL(7, 7)) == 343, ""); +static_assert(BOOST_PP_MUL(BOOST_PP_MUL(5, 5), BOOST_PP_MUL(4, 4)) == 400, ""); -BEGIN BOOST_PP_MUL(24, 24) == 512 END -BEGIN BOOST_PP_MUL(0, 511) == 0 END -BEGIN BOOST_PP_MUL(1, 511) == 511 END -BEGIN BOOST_PP_MUL(2, 511) == 512 END -BEGIN BOOST_PP_MUL(511, 0) == 0 END -BEGIN BOOST_PP_MUL(511, 1) == 511 END -BEGIN BOOST_PP_MUL(511, 2) == 512 END +static_assert(BOOST_PP_MUL(24, 24) == 512, ""); +static_assert(BOOST_PP_MUL(0, 511) == 0, ""); +static_assert(BOOST_PP_MUL(1, 511) == 511, ""); +static_assert(BOOST_PP_MUL(2, 511) == 512, ""); +static_assert(BOOST_PP_MUL(511, 0) == 0, ""); +static_assert(BOOST_PP_MUL(511, 1) == 511, ""); +static_assert(BOOST_PP_MUL(511, 2) == 512, ""); #endif #if BOOST_PP_LIMIT_MAG == 1024 -BEGIN BOOST_PP_MUL(0, 653) == 0 END -BEGIN BOOST_PP_MUL(926, 0) == 0 END -BEGIN BOOST_PP_MUL(1, 849) == 849 END -BEGIN BOOST_PP_MUL(42, 17) == 714 END +static_assert(BOOST_PP_MUL(0, 653) == 0, ""); +static_assert(BOOST_PP_MUL(926, 0) == 0, ""); +static_assert(BOOST_PP_MUL(1, 849) == 849, ""); +static_assert(BOOST_PP_MUL(42, 17) == 714, ""); -BEGIN BOOST_PP_MUL(BOOST_PP_MUL(9, 9), 9) == 729 END -BEGIN BOOST_PP_MUL(9, BOOST_PP_MUL(9, 9)) == 729 END -BEGIN BOOST_PP_MUL(BOOST_PP_MUL(6, 6), BOOST_PP_MUL(5, 5)) == 900 END +static_assert(BOOST_PP_MUL(BOOST_PP_MUL(9, 9), 9) == 729, ""); +static_assert(BOOST_PP_MUL(9, BOOST_PP_MUL(9, 9)) == 729, ""); +static_assert(BOOST_PP_MUL(BOOST_PP_MUL(6, 6), BOOST_PP_MUL(5, 5)) == 900, ""); -BEGIN BOOST_PP_MUL(35, 35) == 1024 END -BEGIN BOOST_PP_MUL(0, 1024) == 0 END -BEGIN BOOST_PP_MUL(1, 1024) == 1024 END -BEGIN BOOST_PP_MUL(2, 1024) == 1024 END -BEGIN BOOST_PP_MUL(1023, 0) == 0 END -BEGIN BOOST_PP_MUL(1023, 1) == 1023 END -BEGIN BOOST_PP_MUL(1023, 2) == 1024 END +static_assert(BOOST_PP_MUL(35, 35) == 1024, ""); +static_assert(BOOST_PP_MUL(0, 1024) == 0, ""); +static_assert(BOOST_PP_MUL(1, 1024) == 1024, ""); +static_assert(BOOST_PP_MUL(2, 1024) == 1024, ""); +static_assert(BOOST_PP_MUL(1023, 0) == 0, ""); +static_assert(BOOST_PP_MUL(1023, 1) == 1023, ""); +static_assert(BOOST_PP_MUL(1023, 2) == 1024, ""); #endif /* division */ -BEGIN BOOST_PP_DIV(2, 1) == 2 END -BEGIN BOOST_PP_DIV(0, 5) == 0 END -BEGIN BOOST_PP_DIV(7, 3) == 2 END +static_assert(BOOST_PP_DIV(2, 1) == 2, ""); +static_assert(BOOST_PP_DIV(0, 5) == 0, ""); +static_assert(BOOST_PP_DIV(7, 3) == 2, ""); -BEGIN BOOST_PP_DIV(BOOST_PP_DIV(4, 2), 2) == 1 END -BEGIN BOOST_PP_DIV(10, BOOST_PP_DIV(10, 2)) == 2 END -BEGIN BOOST_PP_DIV(BOOST_PP_DIV(10, 2), BOOST_PP_DIV(4, 2)) == 2 END +static_assert(BOOST_PP_DIV(BOOST_PP_DIV(4, 2), 2) == 1, ""); +static_assert(BOOST_PP_DIV(10, BOOST_PP_DIV(10, 2)) == 2, ""); +static_assert(BOOST_PP_DIV(BOOST_PP_DIV(10, 2), BOOST_PP_DIV(4, 2)) == 2, ""); #if BOOST_PP_LIMIT_MAG == 512 -BEGIN BOOST_PP_DIV(468, 3) == 156 END -BEGIN BOOST_PP_DIV(0, 272) == 0 END -BEGIN BOOST_PP_DIV(335, 6) == 55 END +static_assert(BOOST_PP_DIV(468, 3) == 156, ""); +static_assert(BOOST_PP_DIV(0, 272) == 0, ""); +static_assert(BOOST_PP_DIV(335, 6) == 55, ""); -BEGIN BOOST_PP_DIV(BOOST_PP_DIV(498, 2), 2) == 124 END -BEGIN BOOST_PP_DIV(375, BOOST_PP_DIV(279, 3)) == 4 END -BEGIN BOOST_PP_DIV(BOOST_PP_DIV(486, 2), BOOST_PP_DIV(17, 4)) == 60 END +static_assert(BOOST_PP_DIV(BOOST_PP_DIV(498, 2), 2) == 124, ""); +static_assert(BOOST_PP_DIV(375, BOOST_PP_DIV(279, 3)) == 4, ""); +static_assert(BOOST_PP_DIV(BOOST_PP_DIV(486, 2), BOOST_PP_DIV(17, 4)) == 60, ""); #endif #if BOOST_PP_LIMIT_MAG == 1024 -BEGIN BOOST_PP_DIV(849, 36) == 23 END -BEGIN BOOST_PP_DIV(0, 638) == 0 END -BEGIN BOOST_PP_DIV(467, 17) == 27 END +static_assert(BOOST_PP_DIV(849, 36) == 23, ""); +static_assert(BOOST_PP_DIV(0, 638) == 0, ""); +static_assert(BOOST_PP_DIV(467, 17) == 27, ""); -BEGIN BOOST_PP_DIV(BOOST_PP_DIV(1004, 10), 5) == 20 END -BEGIN BOOST_PP_DIV(593, BOOST_PP_DIV(925, 25)) == 16 END -BEGIN BOOST_PP_DIV(BOOST_PP_DIV(746, 12), BOOST_PP_DIV(848, 424)) == 31 END +static_assert(BOOST_PP_DIV(BOOST_PP_DIV(1004, 10), 5) == 20, ""); +static_assert(BOOST_PP_DIV(593, BOOST_PP_DIV(925, 25)) == 16, ""); +static_assert(BOOST_PP_DIV(BOOST_PP_DIV(746, 12), BOOST_PP_DIV(848, 424)) == 31, ""); #endif /* modulus */ -BEGIN BOOST_PP_MOD(5, 5) == 0 END -BEGIN BOOST_PP_MOD(9, 5) == 4 END -BEGIN BOOST_PP_MOD(7, 4) == 3 END +static_assert(BOOST_PP_MOD(5, 5) == 0, ""); +static_assert(BOOST_PP_MOD(9, 5) == 4, ""); +static_assert(BOOST_PP_MOD(7, 4) == 3, ""); -BEGIN BOOST_PP_MOD(BOOST_PP_MOD(5, 3), 3) == 2 END -BEGIN BOOST_PP_MOD(5, BOOST_PP_MOD(4, 3)) == 0 END +static_assert(BOOST_PP_MOD(BOOST_PP_MOD(5, 3), 3) == 2, ""); +static_assert(BOOST_PP_MOD(5, BOOST_PP_MOD(4, 3)) == 0, ""); #if BOOST_PP_LIMIT_MAG == 512 -BEGIN BOOST_PP_MOD(473, 473) == 0 END -BEGIN BOOST_PP_MOD(381, 126) == 3 END -BEGIN BOOST_PP_MOD(262, 27) == 19 END +static_assert(BOOST_PP_MOD(473, 473) == 0, ""); +static_assert(BOOST_PP_MOD(381, 126) == 3, ""); +static_assert(BOOST_PP_MOD(262, 27) == 19, ""); -BEGIN BOOST_PP_MOD(BOOST_PP_MOD(368, 65), 7) == 1 END -BEGIN BOOST_PP_MOD(194, BOOST_PP_MOD(411, 205)) == 0 END +static_assert(BOOST_PP_MOD(BOOST_PP_MOD(368, 65), 7) == 1, ""); +static_assert(BOOST_PP_MOD(194, BOOST_PP_MOD(411, 205)) == 0, ""); #endif #if BOOST_PP_LIMIT_MAG == 1024 -BEGIN BOOST_PP_MOD(831, 831) == 0 END -BEGIN BOOST_PP_MOD(935, 73) == 59 END -BEGIN BOOST_PP_MOD(610, 84) == 22 END +static_assert(BOOST_PP_MOD(831, 831) == 0, ""); +static_assert(BOOST_PP_MOD(935, 73) == 59, ""); +static_assert(BOOST_PP_MOD(610, 84) == 22, ""); -BEGIN BOOST_PP_MOD(BOOST_PP_MOD(732, 27), 2) == 1 END -BEGIN BOOST_PP_MOD(1023, BOOST_PP_MOD(544, 29)) == 11 END +static_assert(BOOST_PP_MOD(BOOST_PP_MOD(732, 27), 2) == 1, ""); +static_assert(BOOST_PP_MOD(1023, BOOST_PP_MOD(544, 29)) == 11, ""); #endif /* increment */ -BEGIN BOOST_PP_INC(0) == 1 END -BEGIN BOOST_PP_INC(22) == 23 END -BEGIN BOOST_PP_INC(BOOST_PP_INC(0)) == 2 END -BEGIN BOOST_PP_INC(BOOST_PP_INC(17)) == 19 END +static_assert(BOOST_PP_INC(0) == 1, ""); +static_assert(BOOST_PP_INC(22) == 23, ""); +static_assert(BOOST_PP_INC(BOOST_PP_INC(0)) == 2, ""); +static_assert(BOOST_PP_INC(BOOST_PP_INC(17)) == 19, ""); #if BOOST_PP_LIMIT_MAG == 256 -BEGIN BOOST_PP_INC(256) == 256 END -BEGIN BOOST_PP_INC(BOOST_PP_INC(255)) == 256 END +static_assert(BOOST_PP_INC(256) == 256, ""); +static_assert(BOOST_PP_INC(BOOST_PP_INC(255)) == 256, ""); #endif #if BOOST_PP_LIMIT_MAG == 512 -BEGIN BOOST_PP_INC(349) == 350 END -BEGIN BOOST_PP_INC(426) == 427 END -BEGIN BOOST_PP_INC(256) == 257 END -BEGIN BOOST_PP_INC(BOOST_PP_INC(505)) == 507 END -BEGIN BOOST_PP_INC(BOOST_PP_INC(272)) == 274 END -BEGIN BOOST_PP_INC(BOOST_PP_INC(255)) == 257 END +static_assert(BOOST_PP_INC(349) == 350, ""); +static_assert(BOOST_PP_INC(426) == 427, ""); +static_assert(BOOST_PP_INC(256) == 257, ""); +static_assert(BOOST_PP_INC(BOOST_PP_INC(505)) == 507, ""); +static_assert(BOOST_PP_INC(BOOST_PP_INC(272)) == 274, ""); +static_assert(BOOST_PP_INC(BOOST_PP_INC(255)) == 257, ""); #endif #if BOOST_PP_LIMIT_MAG == 1024 -BEGIN BOOST_PP_INC(593) == 594 END -BEGIN BOOST_PP_INC(821) == 822 END -BEGIN BOOST_PP_INC(512) == 513 END -BEGIN BOOST_PP_INC(BOOST_PP_INC(924)) == 926 END -BEGIN BOOST_PP_INC(BOOST_PP_INC(732)) == 734 END -BEGIN BOOST_PP_INC(BOOST_PP_INC(511)) == 513 END +static_assert(BOOST_PP_INC(593) == 594, ""); +static_assert(BOOST_PP_INC(821) == 822, ""); +static_assert(BOOST_PP_INC(512) == 513, ""); +static_assert(BOOST_PP_INC(BOOST_PP_INC(924)) == 926, ""); +static_assert(BOOST_PP_INC(BOOST_PP_INC(732)) == 734, ""); +static_assert(BOOST_PP_INC(BOOST_PP_INC(511)) == 513, ""); #endif /* decrement */ -BEGIN BOOST_PP_DEC(256) == 255 END -BEGIN BOOST_PP_DEC(47) == 46 END -BEGIN BOOST_PP_DEC(0) == 0 END +static_assert(BOOST_PP_DEC(256) == 255, ""); +static_assert(BOOST_PP_DEC(47) == 46, ""); +static_assert(BOOST_PP_DEC(0) == 0, ""); -BEGIN BOOST_PP_DEC(BOOST_PP_DEC(256)) == 254 END -BEGIN BOOST_PP_DEC(BOOST_PP_DEC(85)) == 83 END -BEGIN BOOST_PP_DEC(BOOST_PP_DEC(1)) == 0 END +static_assert(BOOST_PP_DEC(BOOST_PP_DEC(256)) == 254, ""); +static_assert(BOOST_PP_DEC(BOOST_PP_DEC(85)) == 83, ""); +static_assert(BOOST_PP_DEC(BOOST_PP_DEC(1)) == 0, ""); #if BOOST_PP_LIMIT_MAG == 512 -BEGIN BOOST_PP_DEC(257) == 256 END -BEGIN BOOST_PP_DEC(473) == 472 END -BEGIN BOOST_PP_DEC(512) == 511 END +static_assert(BOOST_PP_DEC(257) == 256, ""); +static_assert(BOOST_PP_DEC(473) == 472, ""); +static_assert(BOOST_PP_DEC(512) == 511, ""); -BEGIN BOOST_PP_DEC(BOOST_PP_DEC(257)) == 255 END -BEGIN BOOST_PP_DEC(BOOST_PP_DEC(329)) == 327 END -BEGIN BOOST_PP_DEC(BOOST_PP_DEC(512)) == 510 END +static_assert(BOOST_PP_DEC(BOOST_PP_DEC(257)) == 255, ""); +static_assert(BOOST_PP_DEC(BOOST_PP_DEC(329)) == 327, ""); +static_assert(BOOST_PP_DEC(BOOST_PP_DEC(512)) == 510, ""); #endif #if BOOST_PP_LIMIT_MAG == 1024 -BEGIN BOOST_PP_DEC(1025) == 1024 END -BEGIN BOOST_PP_DEC(770) == 769 END -BEGIN BOOST_PP_DEC(1024) == 1023 END +static_assert(BOOST_PP_DEC(1025) == 1024, ""); +static_assert(BOOST_PP_DEC(770) == 769, ""); +static_assert(BOOST_PP_DEC(1024) == 1023, ""); -BEGIN BOOST_PP_DEC(BOOST_PP_DEC(1025)) == 1023 END -BEGIN BOOST_PP_DEC(BOOST_PP_DEC(959)) == 957 END -BEGIN BOOST_PP_DEC(BOOST_PP_DEC(1024)) == 1022 END +static_assert(BOOST_PP_DEC(BOOST_PP_DEC(1025)) == 1023, ""); +static_assert(BOOST_PP_DEC(BOOST_PP_DEC(959)) == 957, ""); +static_assert(BOOST_PP_DEC(BOOST_PP_DEC(1024)) == 1022, ""); #endif diff --git a/test/array.cxx b/test/array.cxx index c7e3be94..cb53e905 100644 --- a/test/array.cxx +++ b/test/array.cxx @@ -76,382 +76,382 @@ // element access -BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_ARRAY_ELEM(0, ARRAY_ONE)) == 1 END -BEGIN BOOST_PP_ARRAY_ELEM(1, ARRAY) == 1 END -BEGIN BOOST_PP_ARRAY_ELEM(2, (5, (0, 1, 2, 3, 4))) == 2 END -BEGIN BOOST_PP_ARRAY_ELEM(28, ARRAY_LARGE) == 28 END -BEGIN BOOST_PP_ARRAY_ELEM(17, (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))) == 17 END -BEGIN BOOST_PP_ARRAY_ELEM(42, ARRAY_VERY_LARGE) == 42 END -BEGIN BOOST_PP_ARRAY_ELEM(62, (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))) == 62 END +static_assert(BOOST_PP_IS_EMPTY(BOOST_PP_ARRAY_ELEM(0, ARRAY_ONE)) == 1, ""); +static_assert(BOOST_PP_ARRAY_ELEM(1, ARRAY) == 1, ""); +static_assert(BOOST_PP_ARRAY_ELEM(2, (5, (0, 1, 2, 3, 4))) == 2, ""); +static_assert(BOOST_PP_ARRAY_ELEM(28, ARRAY_LARGE) == 28, ""); +static_assert(BOOST_PP_ARRAY_ELEM(17, (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))) == 17, ""); +static_assert(BOOST_PP_ARRAY_ELEM(42, ARRAY_VERY_LARGE) == 42, ""); +static_assert(BOOST_PP_ARRAY_ELEM(62, (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))) == 62, ""); // size -BEGIN BOOST_PP_ARRAY_SIZE(ARRAY) == 3 END -BEGIN BOOST_PP_ARRAY_SIZE((5, (0, 1, 2, 3, 4))) == 5 END -BEGIN BOOST_PP_ARRAY_SIZE(ARRAY_LARGE) == 33 END -BEGIN BOOST_PP_ARRAY_SIZE((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 -BEGIN BOOST_PP_ARRAY_SIZE(ARRAY_VERY_LARGE) == 64 END -BEGIN BOOST_PP_ARRAY_SIZE((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 -BEGIN BOOST_PP_ARRAY_SIZE(ARRAY_EMPTY) == 0 END -BEGIN BOOST_PP_ARRAY_SIZE(ARRAY_ONE) == 1 END +static_assert(BOOST_PP_ARRAY_SIZE(ARRAY) == 3, ""); +static_assert(BOOST_PP_ARRAY_SIZE((5, (0, 1, 2, 3, 4))) == 5, ""); +static_assert(BOOST_PP_ARRAY_SIZE(ARRAY_LARGE) == 33, ""); +static_assert(BOOST_PP_ARRAY_SIZE((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, ""); +static_assert(BOOST_PP_ARRAY_SIZE(ARRAY_VERY_LARGE) == 64, ""); +static_assert(BOOST_PP_ARRAY_SIZE((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, ""); +static_assert(BOOST_PP_ARRAY_SIZE(ARRAY_EMPTY) == 0, ""); +static_assert(BOOST_PP_ARRAY_SIZE(ARRAY_ONE) == 1, ""); #if BOOST_PP_LIMIT_TUPLE > 64 -BEGIN BOOST_PP_ARRAY_ELEM(73, ARRAY_LARGE_128) == 73 END -BEGIN BOOST_PP_ARRAY_ELEM(89, ARRAY_LARGE_128) == 89 END -BEGIN BOOST_PP_ARRAY_ELEM(101, ARRAY_LARGE_128) == 101 END -BEGIN BOOST_PP_ARRAY_ELEM(95, ARRAY_VERY_LARGE_128) == 95 END -BEGIN BOOST_PP_ARRAY_ELEM(110, ARRAY_VERY_LARGE_128) == 110 END -BEGIN BOOST_PP_ARRAY_ELEM(126, ARRAY_VERY_LARGE_128) == 126 END +static_assert(BOOST_PP_ARRAY_ELEM(73, ARRAY_LARGE_128) == 73, ""); +static_assert(BOOST_PP_ARRAY_ELEM(89, ARRAY_LARGE_128) == 89, ""); +static_assert(BOOST_PP_ARRAY_ELEM(101, ARRAY_LARGE_128) == 101, ""); +static_assert(BOOST_PP_ARRAY_ELEM(95, ARRAY_VERY_LARGE_128) == 95, ""); +static_assert(BOOST_PP_ARRAY_ELEM(110, ARRAY_VERY_LARGE_128) == 110, ""); +static_assert(BOOST_PP_ARRAY_ELEM(126, ARRAY_VERY_LARGE_128) == 126, ""); #endif #if BOOST_PP_LIMIT_TUPLE > 128 -BEGIN BOOST_PP_ARRAY_ELEM(83, ARRAY_LARGE_256) == 83 END -BEGIN BOOST_PP_ARRAY_ELEM(131, ARRAY_LARGE_256) == 131 END -BEGIN BOOST_PP_ARRAY_ELEM(140, ARRAY_LARGE_256) == 140 END -BEGIN BOOST_PP_ARRAY_ELEM(174, ARRAY_VERY_LARGE_256) == 174 END -BEGIN BOOST_PP_ARRAY_ELEM(226, ARRAY_VERY_LARGE_256) == 226 END -BEGIN BOOST_PP_ARRAY_ELEM(253, ARRAY_VERY_LARGE_256) == 253 END +static_assert(BOOST_PP_ARRAY_ELEM(83, ARRAY_LARGE_256) == 83, ""); +static_assert(BOOST_PP_ARRAY_ELEM(131, ARRAY_LARGE_256) == 131, ""); +static_assert(BOOST_PP_ARRAY_ELEM(140, ARRAY_LARGE_256) == 140, ""); +static_assert(BOOST_PP_ARRAY_ELEM(174, ARRAY_VERY_LARGE_256) == 174, ""); +static_assert(BOOST_PP_ARRAY_ELEM(226, ARRAY_VERY_LARGE_256) == 226, ""); +static_assert(BOOST_PP_ARRAY_ELEM(253, ARRAY_VERY_LARGE_256) == 253, ""); #endif // enum -BEGIN BOOST_PP_VARIADIC_ELEM(2,BOOST_PP_ARRAY_ENUM(ARRAY)) == 2 END -BEGIN BOOST_PP_VARIADIC_ELEM(3,BOOST_PP_ARRAY_ENUM((5, (0, 1, 2, 3, 4)))) == 3 END -BEGIN BOOST_PP_VARIADIC_ELEM(31,BOOST_PP_ARRAY_ENUM(ARRAY_LARGE)) == 31 END -BEGIN BOOST_PP_VARIADIC_ELEM(13,BOOST_PP_ARRAY_ENUM((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)))) == 13 END -BEGIN BOOST_PP_VARIADIC_ELEM(39,BOOST_PP_ARRAY_ENUM(ARRAY_VERY_LARGE)) == 39 END -BEGIN BOOST_PP_VARIADIC_ELEM(24,BOOST_PP_ARRAY_ENUM((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)))) == 24 END -BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_ARRAY_ENUM((5, (0, 1, 2, 3, 4)))) == 5 END -BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_ARRAY_ENUM(ARRAY_LARGE)) == 33 END -BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_ARRAY_ENUM(ARRAY_VERY_LARGE)) == 64 END -BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_ARRAY_ENUM((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 +static_assert(BOOST_PP_VARIADIC_ELEM(2,BOOST_PP_ARRAY_ENUM(ARRAY)) == 2, ""); +static_assert(BOOST_PP_VARIADIC_ELEM(3,BOOST_PP_ARRAY_ENUM((5, (0, 1, 2, 3, 4)))) == 3, ""); +static_assert(BOOST_PP_VARIADIC_ELEM(31,BOOST_PP_ARRAY_ENUM(ARRAY_LARGE)) == 31, ""); +static_assert(BOOST_PP_VARIADIC_ELEM(13,BOOST_PP_ARRAY_ENUM((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)))) == 13, ""); +static_assert(BOOST_PP_VARIADIC_ELEM(39,BOOST_PP_ARRAY_ENUM(ARRAY_VERY_LARGE)) == 39, ""); +static_assert(BOOST_PP_VARIADIC_ELEM(24,BOOST_PP_ARRAY_ENUM((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)))) == 24, ""); +static_assert(BOOST_PP_VARIADIC_SIZE(BOOST_PP_ARRAY_ENUM((5, (0, 1, 2, 3, 4)))) == 5, ""); +static_assert(BOOST_PP_VARIADIC_SIZE(BOOST_PP_ARRAY_ENUM(ARRAY_LARGE)) == 33, ""); +static_assert(BOOST_PP_VARIADIC_SIZE(BOOST_PP_ARRAY_ENUM(ARRAY_VERY_LARGE)) == 64, ""); +static_assert(BOOST_PP_VARIADIC_SIZE(BOOST_PP_ARRAY_ENUM((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, ""); # if BOOST_PP_VARIADIC_HAS_OPT() -BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_ARRAY_ENUM(ARRAY_ONE)) == 0 END +static_assert(BOOST_PP_VARIADIC_SIZE(BOOST_PP_ARRAY_ENUM(ARRAY_ONE)) == 0, ""); # else -BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_ARRAY_ENUM(ARRAY_ONE)) == 1 END +static_assert(BOOST_PP_VARIADIC_SIZE(BOOST_PP_ARRAY_ENUM(ARRAY_ONE)) == 1, ""); #endif #if BOOST_PP_LIMIT_TUPLE > 64 -BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_ARRAY_ENUM(ARRAY_LARGE_128)) == 104 END -BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_ARRAY_ENUM(ARRAY_VERY_LARGE_128)) == 128 END +static_assert(BOOST_PP_VARIADIC_SIZE(BOOST_PP_ARRAY_ENUM(ARRAY_LARGE_128)) == 104, ""); +static_assert(BOOST_PP_VARIADIC_SIZE(BOOST_PP_ARRAY_ENUM(ARRAY_VERY_LARGE_128)) == 128, ""); #endif #if BOOST_PP_LIMIT_TUPLE > 128 -BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_ARRAY_ENUM(ARRAY_LARGE_256)) == 142 END -BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_ARRAY_ENUM(ARRAY_VERY_LARGE_256)) == 256 END +static_assert(BOOST_PP_VARIADIC_SIZE(BOOST_PP_ARRAY_ENUM(ARRAY_LARGE_256)) == 142, ""); +static_assert(BOOST_PP_VARIADIC_SIZE(BOOST_PP_ARRAY_ENUM(ARRAY_VERY_LARGE_256)) == 256, ""); #endif // to_list -BEGIN BOOST_PP_LIST_AT(BOOST_PP_ARRAY_TO_LIST(ARRAY), 1) == 1 END -BEGIN BOOST_PP_LIST_AT(BOOST_PP_ARRAY_TO_LIST((5, (0, 1, 2, 3, 4))), 4) == 4 END -BEGIN BOOST_PP_LIST_AT(BOOST_PP_ARRAY_TO_LIST((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))), 26) == 26 END -BEGIN BOOST_PP_LIST_AT(BOOST_PP_ARRAY_TO_LIST(ARRAY_VERY_LARGE), 60) == 60 END -BEGIN BOOST_PP_LIST_SIZE(BOOST_PP_ARRAY_TO_LIST(ARRAY_EMPTY)) == 0 END -BEGIN BOOST_PP_LIST_SIZE(BOOST_PP_ARRAY_TO_LIST(ARRAY_ONE)) == 1 END +static_assert(BOOST_PP_LIST_AT(BOOST_PP_ARRAY_TO_LIST(ARRAY), 1) == 1, ""); +static_assert(BOOST_PP_LIST_AT(BOOST_PP_ARRAY_TO_LIST((5, (0, 1, 2, 3, 4))), 4) == 4, ""); +static_assert(BOOST_PP_LIST_AT(BOOST_PP_ARRAY_TO_LIST((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))), 26) == 26, ""); +static_assert(BOOST_PP_LIST_AT(BOOST_PP_ARRAY_TO_LIST(ARRAY_VERY_LARGE), 60) == 60, ""); +static_assert(BOOST_PP_LIST_SIZE(BOOST_PP_ARRAY_TO_LIST(ARRAY_EMPTY)) == 0, ""); +static_assert(BOOST_PP_LIST_SIZE(BOOST_PP_ARRAY_TO_LIST(ARRAY_ONE)) == 1, ""); #if BOOST_PP_LIMIT_TUPLE > 64 -BEGIN BOOST_PP_LIST_AT(BOOST_PP_ARRAY_TO_LIST(ARRAY_LARGE_128), 88) == 88 END -BEGIN BOOST_PP_LIST_AT(BOOST_PP_ARRAY_TO_LIST(ARRAY_VERY_LARGE_128), 113) == 113 END +static_assert(BOOST_PP_LIST_AT(BOOST_PP_ARRAY_TO_LIST(ARRAY_LARGE_128), 88) == 88, ""); +static_assert(BOOST_PP_LIST_AT(BOOST_PP_ARRAY_TO_LIST(ARRAY_VERY_LARGE_128), 113) == 113, ""); #endif #if BOOST_PP_LIMIT_TUPLE > 128 -BEGIN BOOST_PP_LIST_AT(BOOST_PP_ARRAY_TO_LIST(ARRAY_LARGE_256), 137) == 137 END -BEGIN BOOST_PP_LIST_AT(BOOST_PP_ARRAY_TO_LIST(ARRAY_VERY_LARGE_256), 235) == 235 END +static_assert(BOOST_PP_LIST_AT(BOOST_PP_ARRAY_TO_LIST(ARRAY_LARGE_256), 137) == 137, ""); +static_assert(BOOST_PP_LIST_AT(BOOST_PP_ARRAY_TO_LIST(ARRAY_VERY_LARGE_256), 235) == 235, ""); #endif // to_seq -BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_SEQ_ELEM(0, BOOST_PP_ARRAY_TO_SEQ(ARRAY_ONE))) == 1 END -BEGIN BOOST_PP_SEQ_ELEM(0, BOOST_PP_ARRAY_TO_SEQ(ARRAY)) == 0 END -BEGIN BOOST_PP_SEQ_ELEM(3, BOOST_PP_ARRAY_TO_SEQ((5, (0, 1, 2, 3, 4)))) == 3 END -BEGIN BOOST_PP_SEQ_ELEM(17, BOOST_PP_ARRAY_TO_SEQ(ARRAY_LARGE)) == 17 END -BEGIN BOOST_PP_SEQ_ELEM(42, BOOST_PP_ARRAY_TO_SEQ((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)))) == 42 END +static_assert(BOOST_PP_IS_EMPTY(BOOST_PP_SEQ_ELEM(0, BOOST_PP_ARRAY_TO_SEQ(ARRAY_ONE))) == 1, ""); +static_assert(BOOST_PP_SEQ_ELEM(0, BOOST_PP_ARRAY_TO_SEQ(ARRAY)) == 0, ""); +static_assert(BOOST_PP_SEQ_ELEM(3, BOOST_PP_ARRAY_TO_SEQ((5, (0, 1, 2, 3, 4)))) == 3, ""); +static_assert(BOOST_PP_SEQ_ELEM(17, BOOST_PP_ARRAY_TO_SEQ(ARRAY_LARGE)) == 17, ""); +static_assert(BOOST_PP_SEQ_ELEM(42, BOOST_PP_ARRAY_TO_SEQ((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)))) == 42, ""); #if BOOST_PP_LIMIT_TUPLE > 64 -BEGIN BOOST_PP_SEQ_ELEM(97,BOOST_PP_ARRAY_TO_SEQ(ARRAY_LARGE_128)) == 97 END -BEGIN BOOST_PP_SEQ_ELEM(123,BOOST_PP_ARRAY_TO_SEQ(ARRAY_VERY_LARGE_128)) == 123 END +static_assert(BOOST_PP_SEQ_ELEM(97,BOOST_PP_ARRAY_TO_SEQ(ARRAY_LARGE_128)) == 97, ""); +static_assert(BOOST_PP_SEQ_ELEM(123,BOOST_PP_ARRAY_TO_SEQ(ARRAY_VERY_LARGE_128)) == 123, ""); #endif #if BOOST_PP_LIMIT_TUPLE > 128 -BEGIN BOOST_PP_SEQ_ELEM(53,BOOST_PP_ARRAY_TO_SEQ(ARRAY_LARGE_256)) == 53 END -BEGIN BOOST_PP_SEQ_ELEM(181,BOOST_PP_ARRAY_TO_SEQ(ARRAY_VERY_LARGE_256)) == 181 END +static_assert(BOOST_PP_SEQ_ELEM(53,BOOST_PP_ARRAY_TO_SEQ(ARRAY_LARGE_256)) == 53, ""); +static_assert(BOOST_PP_SEQ_ELEM(181,BOOST_PP_ARRAY_TO_SEQ(ARRAY_VERY_LARGE_256)) == 181, ""); #endif // to_tuple -BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_TUPLE_ELEM(0, BOOST_PP_ARRAY_TO_TUPLE(ARRAY_ONE))) == 1 END -BEGIN BOOST_PP_TUPLE_ELEM(2, BOOST_PP_ARRAY_TO_TUPLE(ARRAY)) == 2 END -BEGIN BOOST_PP_TUPLE_ELEM(1, BOOST_PP_ARRAY_TO_TUPLE((5, (0, 1, 2, 3, 4)))) == 1 END -BEGIN BOOST_PP_TUPLE_ELEM(26, BOOST_PP_ARRAY_TO_TUPLE(ARRAY_LARGE)) == 26 END -BEGIN BOOST_PP_TUPLE_ELEM(37, BOOST_PP_ARRAY_TO_TUPLE((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)))) == 37 END +static_assert(BOOST_PP_IS_EMPTY(BOOST_PP_TUPLE_ELEM(0, BOOST_PP_ARRAY_TO_TUPLE(ARRAY_ONE))) == 1, ""); +static_assert(BOOST_PP_TUPLE_ELEM(2, BOOST_PP_ARRAY_TO_TUPLE(ARRAY)) == 2, ""); +static_assert(BOOST_PP_TUPLE_ELEM(1, BOOST_PP_ARRAY_TO_TUPLE((5, (0, 1, 2, 3, 4)))) == 1, ""); +static_assert(BOOST_PP_TUPLE_ELEM(26, BOOST_PP_ARRAY_TO_TUPLE(ARRAY_LARGE)) == 26, ""); +static_assert(BOOST_PP_TUPLE_ELEM(37, BOOST_PP_ARRAY_TO_TUPLE((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)))) == 37, ""); #if BOOST_PP_LIMIT_TUPLE > 64 -BEGIN BOOST_PP_TUPLE_ELEM(97,BOOST_PP_ARRAY_TO_TUPLE(ARRAY_LARGE_128)) == 97 END -BEGIN BOOST_PP_TUPLE_ELEM(123,BOOST_PP_ARRAY_TO_TUPLE(ARRAY_VERY_LARGE_128)) == 123 END +static_assert(BOOST_PP_TUPLE_ELEM(97,BOOST_PP_ARRAY_TO_TUPLE(ARRAY_LARGE_128)) == 97, ""); +static_assert(BOOST_PP_TUPLE_ELEM(123,BOOST_PP_ARRAY_TO_TUPLE(ARRAY_VERY_LARGE_128)) == 123, ""); #endif #if BOOST_PP_LIMIT_TUPLE > 128 -BEGIN BOOST_PP_TUPLE_ELEM(53,BOOST_PP_ARRAY_TO_TUPLE(ARRAY_LARGE_256)) == 53 END -BEGIN BOOST_PP_TUPLE_ELEM(181,BOOST_PP_ARRAY_TO_TUPLE(ARRAY_VERY_LARGE_256)) == 181 END +static_assert(BOOST_PP_TUPLE_ELEM(53,BOOST_PP_ARRAY_TO_TUPLE(ARRAY_LARGE_256)) == 53, ""); +static_assert(BOOST_PP_TUPLE_ELEM(181,BOOST_PP_ARRAY_TO_TUPLE(ARRAY_VERY_LARGE_256)) == 181, ""); #endif // insert -BEGIN BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_INSERT(ARRAY_ONE,0,63)) == 63 END -BEGIN BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_INSERT(ARRAY,2,40)) == 0 END -BEGIN BOOST_PP_ARRAY_ELEM(1, BOOST_PP_ARRAY_INSERT(ARRAY,1,40)) == 40 END -BEGIN BOOST_PP_ARRAY_ELEM(2, BOOST_PP_ARRAY_INSERT(ARRAY,1,40)) == 1 END -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_INSERT(ARRAY,1,40)) == 4 END +static_assert(BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_INSERT(ARRAY_ONE,0,63)) == 63, ""); +static_assert(BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_INSERT(ARRAY,2,40)) == 0, ""); +static_assert(BOOST_PP_ARRAY_ELEM(1, BOOST_PP_ARRAY_INSERT(ARRAY,1,40)) == 40, ""); +static_assert(BOOST_PP_ARRAY_ELEM(2, BOOST_PP_ARRAY_INSERT(ARRAY,1,40)) == 1, ""); +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_INSERT(ARRAY,1,40)) == 4, ""); -BEGIN BOOST_PP_ARRAY_ELEM(8, BOOST_PP_ARRAY_INSERT(ARRAY_LARGE,22,1000)) == 8 END -BEGIN BOOST_PP_ARRAY_ELEM(22, BOOST_PP_ARRAY_INSERT(ARRAY_LARGE,22,1000)) == 1000 END -BEGIN BOOST_PP_ARRAY_ELEM(26, BOOST_PP_ARRAY_INSERT(ARRAY_LARGE,22,1000)) == 25 END -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_INSERT(ARRAY_LARGE,22,1000)) == 34 END +static_assert(BOOST_PP_ARRAY_ELEM(8, BOOST_PP_ARRAY_INSERT(ARRAY_LARGE,22,1000)) == 8, ""); +static_assert(BOOST_PP_ARRAY_ELEM(22, BOOST_PP_ARRAY_INSERT(ARRAY_LARGE,22,1000)) == 1000, ""); +static_assert(BOOST_PP_ARRAY_ELEM(26, BOOST_PP_ARRAY_INSERT(ARRAY_LARGE,22,1000)) == 25, ""); +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_INSERT(ARRAY_LARGE,22,1000)) == 34, ""); -BEGIN BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_INSERT(ARRAY_EMPTY,0,25)) == 25 END -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_INSERT(ARRAY_EMPTY,0,1000)) == 1 END +static_assert(BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_INSERT(ARRAY_EMPTY,0,25)) == 25, ""); +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_INSERT(ARRAY_EMPTY,0,1000)) == 1, ""); #if BOOST_PP_LIMIT_TUPLE > 64 -BEGIN BOOST_PP_ARRAY_ELEM(69, BOOST_PP_ARRAY_INSERT(ARRAY_LARGE_128,76,1000)) == 69 END -BEGIN BOOST_PP_ARRAY_ELEM(101, BOOST_PP_ARRAY_INSERT(ARRAY_LARGE_128,101,1000)) == 1000 END -BEGIN BOOST_PP_ARRAY_ELEM(98, BOOST_PP_ARRAY_INSERT(ARRAY_LARGE_128,96,1000)) == 97 END -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_INSERT(ARRAY_LARGE_128,84,1000)) == 105 END +static_assert(BOOST_PP_ARRAY_ELEM(69, BOOST_PP_ARRAY_INSERT(ARRAY_LARGE_128,76,1000)) == 69, ""); +static_assert(BOOST_PP_ARRAY_ELEM(101, BOOST_PP_ARRAY_INSERT(ARRAY_LARGE_128,101,1000)) == 1000, ""); +static_assert(BOOST_PP_ARRAY_ELEM(98, BOOST_PP_ARRAY_INSERT(ARRAY_LARGE_128,96,1000)) == 97, ""); +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_INSERT(ARRAY_LARGE_128,84,1000)) == 105, ""); #endif #if BOOST_PP_LIMIT_TUPLE > 128 -BEGIN BOOST_PP_ARRAY_ELEM(73, BOOST_PP_ARRAY_INSERT(ARRAY_LARGE_256,134,1000)) == 73 END -BEGIN BOOST_PP_ARRAY_ELEM(141, BOOST_PP_ARRAY_INSERT(ARRAY_LARGE_256,141,1000)) == 1000 END -BEGIN BOOST_PP_ARRAY_ELEM(133, BOOST_PP_ARRAY_INSERT(ARRAY_LARGE_256,39,1000)) == 132 END -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_INSERT(ARRAY_LARGE_256,121,1000)) == 143 END -BEGIN BOOST_PP_ARRAY_ELEM(227,BOOST_PP_ARRAY_INSERT(ARRAY_VERY_LARGE_255,212,1000)) == 226 END -BEGIN BOOST_PP_ARRAY_ELEM(212,BOOST_PP_ARRAY_INSERT(ARRAY_VERY_LARGE_255,212,1000)) == 1000 END +static_assert(BOOST_PP_ARRAY_ELEM(73, BOOST_PP_ARRAY_INSERT(ARRAY_LARGE_256,134,1000)) == 73, ""); +static_assert(BOOST_PP_ARRAY_ELEM(141, BOOST_PP_ARRAY_INSERT(ARRAY_LARGE_256,141,1000)) == 1000, ""); +static_assert(BOOST_PP_ARRAY_ELEM(133, BOOST_PP_ARRAY_INSERT(ARRAY_LARGE_256,39,1000)) == 132, ""); +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_INSERT(ARRAY_LARGE_256,121,1000)) == 143, ""); +static_assert(BOOST_PP_ARRAY_ELEM(227,BOOST_PP_ARRAY_INSERT(ARRAY_VERY_LARGE_255,212,1000)) == 226, ""); +static_assert(BOOST_PP_ARRAY_ELEM(212,BOOST_PP_ARRAY_INSERT(ARRAY_VERY_LARGE_255,212,1000)) == 1000, ""); #endif // pop_back -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_BACK(ARRAY)) == 2 END -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_BACK(ARRAY_LARGE)) == 32 END -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_BACK(ARRAY_VERY_LARGE)) == 63 END +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_BACK(ARRAY)) == 2, ""); +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_BACK(ARRAY_LARGE)) == 32, ""); +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_BACK(ARRAY_VERY_LARGE)) == 63, ""); #if BOOST_PP_LIMIT_TUPLE > 64 -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_BACK(ARRAY_LARGE_128)) == 103 END -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_BACK(ARRAY_VERY_LARGE_128)) == 127 END +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_BACK(ARRAY_LARGE_128)) == 103, ""); +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_BACK(ARRAY_VERY_LARGE_128)) == 127, ""); #endif #if BOOST_PP_LIMIT_TUPLE > 128 -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_BACK(ARRAY_LARGE_256)) == 141 END -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_BACK(ARRAY_VERY_LARGE_256)) == 255 END +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_BACK(ARRAY_LARGE_256)) == 141, ""); +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_BACK(ARRAY_VERY_LARGE_256)) == 255, ""); #endif // pop_front -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_FRONT(ARRAY)) == 2 END -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_FRONT(ARRAY_LARGE)) == 32 END -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_FRONT(ARRAY_VERY_LARGE)) == 63 END +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_FRONT(ARRAY)) == 2, ""); +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_FRONT(ARRAY_LARGE)) == 32, ""); +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_FRONT(ARRAY_VERY_LARGE)) == 63, ""); -BEGIN BOOST_PP_ARRAY_ELEM(1, BOOST_PP_ARRAY_POP_FRONT(ARRAY)) == 2 END -BEGIN BOOST_PP_ARRAY_ELEM(31, BOOST_PP_ARRAY_POP_FRONT(ARRAY_LARGE)) == 32 END -BEGIN BOOST_PP_ARRAY_ELEM(55, BOOST_PP_ARRAY_POP_FRONT(ARRAY_VERY_LARGE)) == 56 END +static_assert(BOOST_PP_ARRAY_ELEM(1, BOOST_PP_ARRAY_POP_FRONT(ARRAY)) == 2, ""); +static_assert(BOOST_PP_ARRAY_ELEM(31, BOOST_PP_ARRAY_POP_FRONT(ARRAY_LARGE)) == 32, ""); +static_assert(BOOST_PP_ARRAY_ELEM(55, BOOST_PP_ARRAY_POP_FRONT(ARRAY_VERY_LARGE)) == 56, ""); #if BOOST_PP_LIMIT_TUPLE > 64 -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_FRONT(ARRAY_LARGE_128)) == 103 END -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_FRONT(ARRAY_VERY_LARGE_128)) == 127 END -BEGIN BOOST_PP_ARRAY_ELEM(84, BOOST_PP_ARRAY_POP_FRONT(ARRAY_LARGE_128)) == 85 END -BEGIN BOOST_PP_ARRAY_ELEM(117, BOOST_PP_ARRAY_POP_FRONT(ARRAY_VERY_LARGE_128)) == 118 END +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_FRONT(ARRAY_LARGE_128)) == 103, ""); +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_FRONT(ARRAY_VERY_LARGE_128)) == 127, ""); +static_assert(BOOST_PP_ARRAY_ELEM(84, BOOST_PP_ARRAY_POP_FRONT(ARRAY_LARGE_128)) == 85, ""); +static_assert(BOOST_PP_ARRAY_ELEM(117, BOOST_PP_ARRAY_POP_FRONT(ARRAY_VERY_LARGE_128)) == 118, ""); #endif #if BOOST_PP_LIMIT_TUPLE > 128 -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_FRONT(ARRAY_LARGE_256)) == 141 END -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_FRONT(ARRAY_VERY_LARGE_256)) == 255 END -BEGIN BOOST_PP_ARRAY_ELEM(129, BOOST_PP_ARRAY_POP_FRONT(ARRAY_LARGE_256)) == 130 END -BEGIN BOOST_PP_ARRAY_ELEM(248, BOOST_PP_ARRAY_POP_FRONT(ARRAY_VERY_LARGE_256)) == 249 END +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_FRONT(ARRAY_LARGE_256)) == 141, ""); +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_FRONT(ARRAY_VERY_LARGE_256)) == 255, ""); +static_assert(BOOST_PP_ARRAY_ELEM(129, BOOST_PP_ARRAY_POP_FRONT(ARRAY_LARGE_256)) == 130, ""); +static_assert(BOOST_PP_ARRAY_ELEM(248, BOOST_PP_ARRAY_POP_FRONT(ARRAY_VERY_LARGE_256)) == 249, ""); #endif // push_back -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_BACK(ARRAY, 3)) == 4 END -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_BACK(ARRAY_LARGE, 33)) == 34 END -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_BACK(ARRAY_EMPTY, 10)) == 1 END -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_BACK(ARRAY_ONE, 44)) == 2 END -BEGIN BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_PUSH_BACK(ARRAY, 3)) == 0 END -BEGIN BOOST_PP_ARRAY_ELEM(33, BOOST_PP_ARRAY_PUSH_BACK(ARRAY_LARGE, 33)) == 33 END -BEGIN BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_PUSH_BACK(ARRAY_EMPTY, 136)) == 136 END -BEGIN BOOST_PP_ARRAY_ELEM(1, BOOST_PP_ARRAY_PUSH_BACK(ARRAY_ONE, 245)) == 245 END +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_BACK(ARRAY, 3)) == 4, ""); +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_BACK(ARRAY_LARGE, 33)) == 34, ""); +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_BACK(ARRAY_EMPTY, 10)) == 1, ""); +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_BACK(ARRAY_ONE, 44)) == 2, ""); +static_assert(BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_PUSH_BACK(ARRAY, 3)) == 0, ""); +static_assert(BOOST_PP_ARRAY_ELEM(33, BOOST_PP_ARRAY_PUSH_BACK(ARRAY_LARGE, 33)) == 33, ""); +static_assert(BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_PUSH_BACK(ARRAY_EMPTY, 136)) == 136, ""); +static_assert(BOOST_PP_ARRAY_ELEM(1, BOOST_PP_ARRAY_PUSH_BACK(ARRAY_ONE, 245)) == 245, ""); #if BOOST_PP_LIMIT_TUPLE > 64 -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_BACK(ARRAY_LARGE_128, 66)) == 105 END -BEGIN BOOST_PP_ARRAY_ELEM(104, BOOST_PP_ARRAY_PUSH_BACK(ARRAY_LARGE_128, 101)) == 101 END +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_BACK(ARRAY_LARGE_128, 66)) == 105, ""); +static_assert(BOOST_PP_ARRAY_ELEM(104, BOOST_PP_ARRAY_PUSH_BACK(ARRAY_LARGE_128, 101)) == 101, ""); #endif #if BOOST_PP_LIMIT_TUPLE > 128 -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_BACK(ARRAY_LARGE_256, 192)) == 143 END -BEGIN BOOST_PP_ARRAY_ELEM(142, BOOST_PP_ARRAY_PUSH_BACK(ARRAY_LARGE_256, 77)) == 77 END -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_BACK(ARRAY_VERY_LARGE_255, 255)) == 256 END +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_BACK(ARRAY_LARGE_256, 192)) == 143, ""); +static_assert(BOOST_PP_ARRAY_ELEM(142, BOOST_PP_ARRAY_PUSH_BACK(ARRAY_LARGE_256, 77)) == 77, ""); +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_BACK(ARRAY_VERY_LARGE_255, 255)) == 256, ""); #endif // push_front -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_FRONT(ARRAY, 555)) == 4 END -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_FRONT(ARRAY_LARGE, 666)) == 34 END -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_FRONT(ARRAY_EMPTY, 10)) == 1 END -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_FRONT(ARRAY_ONE, 131)) == 2 END -BEGIN BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_PUSH_FRONT(ARRAY, 555)) == 555 END -BEGIN BOOST_PP_ARRAY_ELEM(33, BOOST_PP_ARRAY_PUSH_FRONT(ARRAY_LARGE, 33)) == 32 END -BEGIN BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_PUSH_FRONT(ARRAY_EMPTY, 136)) == 136 END -BEGIN BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_PUSH_FRONT(ARRAY_ONE, 56)) == 56 END +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_FRONT(ARRAY, 555)) == 4, ""); +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_FRONT(ARRAY_LARGE, 666)) == 34, ""); +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_FRONT(ARRAY_EMPTY, 10)) == 1, ""); +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_FRONT(ARRAY_ONE, 131)) == 2, ""); +static_assert(BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_PUSH_FRONT(ARRAY, 555)) == 555, ""); +static_assert(BOOST_PP_ARRAY_ELEM(33, BOOST_PP_ARRAY_PUSH_FRONT(ARRAY_LARGE, 33)) == 32, ""); +static_assert(BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_PUSH_FRONT(ARRAY_EMPTY, 136)) == 136, ""); +static_assert(BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_PUSH_FRONT(ARRAY_ONE, 56)) == 56, ""); #if BOOST_PP_LIMIT_TUPLE > 64 -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_FRONT(ARRAY_LARGE_128, 666)) == 105 END -BEGIN BOOST_PP_ARRAY_ELEM(103, BOOST_PP_ARRAY_PUSH_FRONT(ARRAY_LARGE_128, 29)) == 102 END +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_FRONT(ARRAY_LARGE_128, 666)) == 105, ""); +static_assert(BOOST_PP_ARRAY_ELEM(103, BOOST_PP_ARRAY_PUSH_FRONT(ARRAY_LARGE_128, 29)) == 102, ""); #endif #if BOOST_PP_LIMIT_TUPLE > 128 -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_FRONT(ARRAY_LARGE_256, 333)) == 143 END -BEGIN BOOST_PP_ARRAY_ELEM(136, BOOST_PP_ARRAY_PUSH_FRONT(ARRAY_LARGE_256, 47)) == 135 END -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_FRONT(ARRAY_VERY_LARGE_255, 4)) == 256 END +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_FRONT(ARRAY_LARGE_256, 333)) == 143, ""); +static_assert(BOOST_PP_ARRAY_ELEM(136, BOOST_PP_ARRAY_PUSH_FRONT(ARRAY_LARGE_256, 47)) == 135, ""); +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_FRONT(ARRAY_VERY_LARGE_255, 4)) == 256, ""); #endif // remove -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REMOVE(ARRAY_ONE, 0)) == 0 END -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REMOVE(ARRAY, 1)) == 2 END -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REMOVE(ARRAY_LARGE, 17)) == 32 END -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REMOVE(ARRAY_VERY_LARGE, 27)) == 63 END -BEGIN BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_REMOVE(ARRAY, 2)) == 0 END -BEGIN BOOST_PP_ARRAY_ELEM(29, BOOST_PP_ARRAY_REMOVE(ARRAY_LARGE, 25)) == 30 END -BEGIN BOOST_PP_ARRAY_ELEM(62, BOOST_PP_ARRAY_REMOVE(ARRAY_VERY_LARGE, 48)) == 63 END +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REMOVE(ARRAY_ONE, 0)) == 0, ""); +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REMOVE(ARRAY, 1)) == 2, ""); +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REMOVE(ARRAY_LARGE, 17)) == 32, ""); +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REMOVE(ARRAY_VERY_LARGE, 27)) == 63, ""); +static_assert(BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_REMOVE(ARRAY, 2)) == 0, ""); +static_assert(BOOST_PP_ARRAY_ELEM(29, BOOST_PP_ARRAY_REMOVE(ARRAY_LARGE, 25)) == 30, ""); +static_assert(BOOST_PP_ARRAY_ELEM(62, BOOST_PP_ARRAY_REMOVE(ARRAY_VERY_LARGE, 48)) == 63, ""); #if BOOST_PP_LIMIT_TUPLE > 64 -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REMOVE(ARRAY_LARGE_128, 100)) == 103 END -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REMOVE(ARRAY_VERY_LARGE_128, 123)) == 127 END -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REMOVE(ARRAY_VERY_LARGE_128, 0)) == 127 END -BEGIN BOOST_PP_ARRAY_ELEM(102, BOOST_PP_ARRAY_REMOVE(ARRAY_LARGE_128, 97)) == 103 END -BEGIN BOOST_PP_ARRAY_ELEM(76, BOOST_PP_ARRAY_REMOVE(ARRAY_LARGE_128, 0)) == 77 END -BEGIN BOOST_PP_ARRAY_ELEM(119, BOOST_PP_ARRAY_REMOVE(ARRAY_VERY_LARGE_128, 115)) == 120 END +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REMOVE(ARRAY_LARGE_128, 100)) == 103, ""); +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REMOVE(ARRAY_VERY_LARGE_128, 123)) == 127, ""); +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REMOVE(ARRAY_VERY_LARGE_128, 0)) == 127, ""); +static_assert(BOOST_PP_ARRAY_ELEM(102, BOOST_PP_ARRAY_REMOVE(ARRAY_LARGE_128, 97)) == 103, ""); +static_assert(BOOST_PP_ARRAY_ELEM(76, BOOST_PP_ARRAY_REMOVE(ARRAY_LARGE_128, 0)) == 77, ""); +static_assert(BOOST_PP_ARRAY_ELEM(119, BOOST_PP_ARRAY_REMOVE(ARRAY_VERY_LARGE_128, 115)) == 120, ""); #endif #if BOOST_PP_LIMIT_TUPLE > 128 -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REMOVE(ARRAY_LARGE_256, 133)) == 141 END -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REMOVE(ARRAY_LARGE_256, 0)) == 141 END -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REMOVE(ARRAY_VERY_LARGE_256, 241)) == 255 END -BEGIN BOOST_PP_ARRAY_ELEM(140, BOOST_PP_ARRAY_REMOVE(ARRAY_LARGE_256, 138)) == 141 END -BEGIN BOOST_PP_ARRAY_ELEM(181, BOOST_PP_ARRAY_REMOVE(ARRAY_VERY_LARGE_256, 166)) == 182 END -BEGIN BOOST_PP_ARRAY_ELEM(236, BOOST_PP_ARRAY_REMOVE(ARRAY_VERY_LARGE_256, 0)) == 237 END +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REMOVE(ARRAY_LARGE_256, 133)) == 141, ""); +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REMOVE(ARRAY_LARGE_256, 0)) == 141, ""); +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REMOVE(ARRAY_VERY_LARGE_256, 241)) == 255, ""); +static_assert(BOOST_PP_ARRAY_ELEM(140, BOOST_PP_ARRAY_REMOVE(ARRAY_LARGE_256, 138)) == 141, ""); +static_assert(BOOST_PP_ARRAY_ELEM(181, BOOST_PP_ARRAY_REMOVE(ARRAY_VERY_LARGE_256, 166)) == 182, ""); +static_assert(BOOST_PP_ARRAY_ELEM(236, BOOST_PP_ARRAY_REMOVE(ARRAY_VERY_LARGE_256, 0)) == 237, ""); #endif // replace -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REPLACE(ARRAY_ONE, 0, 3)) == 1 END -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REPLACE(ARRAY_VERY_LARGE, 27, 1000)) == 64 END -BEGIN BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_REPLACE(ARRAY_ONE, 0, 68)) == 68 END -BEGIN BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_REPLACE(ARRAY, 1, 44)) == 0 END -BEGIN BOOST_PP_ARRAY_ELEM(29, BOOST_PP_ARRAY_REPLACE(ARRAY_LARGE, 29, 999)) == 999 END -BEGIN BOOST_PP_ARRAY_ELEM(38, BOOST_PP_ARRAY_REPLACE(ARRAY_VERY_LARGE, 37, 1)) == 38 END -BEGIN BOOST_PP_ARRAY_ELEM(28, BOOST_PP_ARRAY_REPLACE(ARRAY_VERY_LARGE, 28, 1)) == 1 END +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REPLACE(ARRAY_ONE, 0, 3)) == 1, ""); +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REPLACE(ARRAY_VERY_LARGE, 27, 1000)) == 64, ""); +static_assert(BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_REPLACE(ARRAY_ONE, 0, 68)) == 68, ""); +static_assert(BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_REPLACE(ARRAY, 1, 44)) == 0, ""); +static_assert(BOOST_PP_ARRAY_ELEM(29, BOOST_PP_ARRAY_REPLACE(ARRAY_LARGE, 29, 999)) == 999, ""); +static_assert(BOOST_PP_ARRAY_ELEM(38, BOOST_PP_ARRAY_REPLACE(ARRAY_VERY_LARGE, 37, 1)) == 38, ""); +static_assert(BOOST_PP_ARRAY_ELEM(28, BOOST_PP_ARRAY_REPLACE(ARRAY_VERY_LARGE, 28, 1)) == 1, ""); #if BOOST_PP_LIMIT_TUPLE > 64 -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REPLACE(ARRAY_VERY_LARGE_128, 93, 1000)) == 128 END -BEGIN BOOST_PP_ARRAY_ELEM(89, BOOST_PP_ARRAY_REPLACE(ARRAY_LARGE_128, 89, 111)) == 111 END -BEGIN BOOST_PP_ARRAY_ELEM(73, BOOST_PP_ARRAY_REPLACE(ARRAY_VERY_LARGE_128, 66, 1)) == 73 END -BEGIN BOOST_PP_ARRAY_ELEM(122, BOOST_PP_ARRAY_REPLACE(ARRAY_VERY_LARGE_128, 122, 1)) == 1 END -BEGIN BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_REPLACE(ARRAY_VERY_LARGE_128, 0, 128)) == 128 END -BEGIN BOOST_PP_ARRAY_ELEM(95, BOOST_PP_ARRAY_REPLACE(ARRAY_VERY_LARGE_128, 0, 128)) == 95 END +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REPLACE(ARRAY_VERY_LARGE_128, 93, 1000)) == 128, ""); +static_assert(BOOST_PP_ARRAY_ELEM(89, BOOST_PP_ARRAY_REPLACE(ARRAY_LARGE_128, 89, 111)) == 111, ""); +static_assert(BOOST_PP_ARRAY_ELEM(73, BOOST_PP_ARRAY_REPLACE(ARRAY_VERY_LARGE_128, 66, 1)) == 73, ""); +static_assert(BOOST_PP_ARRAY_ELEM(122, BOOST_PP_ARRAY_REPLACE(ARRAY_VERY_LARGE_128, 122, 1)) == 1, ""); +static_assert(BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_REPLACE(ARRAY_VERY_LARGE_128, 0, 128)) == 128, ""); +static_assert(BOOST_PP_ARRAY_ELEM(95, BOOST_PP_ARRAY_REPLACE(ARRAY_VERY_LARGE_128, 0, 128)) == 95, ""); #endif #if BOOST_PP_LIMIT_TUPLE > 128 -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REPLACE(ARRAY_VERY_LARGE_256, 217, 1000)) == 256 END -BEGIN BOOST_PP_ARRAY_ELEM(136, BOOST_PP_ARRAY_REPLACE(ARRAY_LARGE_256, 136, 999)) == 999 END -BEGIN BOOST_PP_ARRAY_ELEM(192, BOOST_PP_ARRAY_REPLACE(ARRAY_VERY_LARGE_256, 185, 1)) == 192 END -BEGIN BOOST_PP_ARRAY_ELEM(237, BOOST_PP_ARRAY_REPLACE(ARRAY_VERY_LARGE_256, 237, 1)) == 1 END -BEGIN BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_REPLACE(ARRAY_VERY_LARGE_256, 0, 256)) == 256 END -BEGIN BOOST_PP_ARRAY_ELEM(167, BOOST_PP_ARRAY_REPLACE(ARRAY_VERY_LARGE_256, 0, 256)) == 167 END +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REPLACE(ARRAY_VERY_LARGE_256, 217, 1000)) == 256, ""); +static_assert(BOOST_PP_ARRAY_ELEM(136, BOOST_PP_ARRAY_REPLACE(ARRAY_LARGE_256, 136, 999)) == 999, ""); +static_assert(BOOST_PP_ARRAY_ELEM(192, BOOST_PP_ARRAY_REPLACE(ARRAY_VERY_LARGE_256, 185, 1)) == 192, ""); +static_assert(BOOST_PP_ARRAY_ELEM(237, BOOST_PP_ARRAY_REPLACE(ARRAY_VERY_LARGE_256, 237, 1)) == 1, ""); +static_assert(BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_REPLACE(ARRAY_VERY_LARGE_256, 0, 256)) == 256, ""); +static_assert(BOOST_PP_ARRAY_ELEM(167, BOOST_PP_ARRAY_REPLACE(ARRAY_VERY_LARGE_256, 0, 256)) == 167, ""); #endif // reverse -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REVERSE(ARRAY_VERY_LARGE)) == 64 END +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REVERSE(ARRAY_VERY_LARGE)) == 64, ""); #if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT() -BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_REVERSE(ARRAY_ONE))) == 1 END +static_assert(BOOST_PP_IS_EMPTY(BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_REVERSE(ARRAY_ONE))) == 1, ""); #else -// BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_REVERSE(ARRAY_ONE))) == 1 END -BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_ARRAY_ELEM(0, ARRAY_ONE)) == 1 END +// static_assert(BOOST_PP_IS_EMPTY(BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_REVERSE(ARRAY_ONE))) == 1, ""); +static_assert(BOOST_PP_IS_EMPTY(BOOST_PP_ARRAY_ELEM(0, ARRAY_ONE)) == 1, ""); #endif -BEGIN BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_REVERSE(ARRAY)) == 2 END -BEGIN BOOST_PP_ARRAY_ELEM(29, BOOST_PP_ARRAY_REVERSE(ARRAY_LARGE)) == 3 END -BEGIN BOOST_PP_ARRAY_ELEM(38, BOOST_PP_ARRAY_REVERSE(ARRAY_VERY_LARGE)) == 25 END -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REVERSE(ARRAY_EMPTY)) == 0 END -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REVERSE(ARRAY_ONE)) == 1 END +static_assert(BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_REVERSE(ARRAY)) == 2, ""); +static_assert(BOOST_PP_ARRAY_ELEM(29, BOOST_PP_ARRAY_REVERSE(ARRAY_LARGE)) == 3, ""); +static_assert(BOOST_PP_ARRAY_ELEM(38, BOOST_PP_ARRAY_REVERSE(ARRAY_VERY_LARGE)) == 25, ""); +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REVERSE(ARRAY_EMPTY)) == 0, ""); +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REVERSE(ARRAY_ONE)) == 1, ""); #if BOOST_PP_LIMIT_TUPLE > 64 -BEGIN BOOST_PP_ARRAY_ELEM(83, BOOST_PP_ARRAY_REVERSE(ARRAY_LARGE_128)) == 20 END -BEGIN BOOST_PP_ARRAY_ELEM(119, BOOST_PP_ARRAY_REVERSE(ARRAY_VERY_LARGE_128)) == 8 END +static_assert(BOOST_PP_ARRAY_ELEM(83, BOOST_PP_ARRAY_REVERSE(ARRAY_LARGE_128)) == 20, ""); +static_assert(BOOST_PP_ARRAY_ELEM(119, BOOST_PP_ARRAY_REVERSE(ARRAY_VERY_LARGE_128)) == 8, ""); #endif #if BOOST_PP_LIMIT_TUPLE > 128 -BEGIN BOOST_PP_ARRAY_ELEM(56, BOOST_PP_ARRAY_REVERSE(ARRAY_LARGE_256)) == 85 END -BEGIN BOOST_PP_ARRAY_ELEM(212, BOOST_PP_ARRAY_REVERSE(ARRAY_VERY_LARGE_256)) == 43 END +static_assert(BOOST_PP_ARRAY_ELEM(56, BOOST_PP_ARRAY_REVERSE(ARRAY_LARGE_256)) == 85, ""); +static_assert(BOOST_PP_ARRAY_ELEM(212, BOOST_PP_ARRAY_REVERSE(ARRAY_VERY_LARGE_256)) == 43, ""); #endif diff --git a/test/checkempty.cxx b/test/checkempty.cxx index c6421118..79aa0afc 100644 --- a/test/checkempty.cxx +++ b/test/checkempty.cxx @@ -35,27 +35,27 @@ #define ATUPLE (atuple) #define ATUPLE_PLUS (atuple) data -BEGIN BOOST_PP_CHECK_EMPTY(FUNC_GEN) == 0 END -BEGIN BOOST_PP_CHECK_EMPTY(FUNC_GEN2) == 0 END -BEGIN BOOST_PP_CHECK_EMPTY(FUNC_GEN3) == 0 END -BEGIN BOOST_PP_CHECK_EMPTY(FUNC_GEN4) == 0 END -BEGIN BOOST_PP_CHECK_EMPTY(FUNC_GEN5) == 0 END -BEGIN BOOST_PP_CHECK_EMPTY(FUNC_GEN8) == 0 END -BEGIN BOOST_PP_CHECK_EMPTY(FUNC_GEN9) == 0 END -BEGIN BOOST_PP_CHECK_EMPTY(FUNC_GEN10) == 0 END -BEGIN BOOST_PP_CHECK_EMPTY(BOOST_PP_EMPTY()) == 1 END -BEGIN BOOST_PP_CHECK_EMPTY(DATA BOOST_PP_EMPTY()) == 1 END -BEGIN BOOST_PP_CHECK_EMPTY(x BOOST_PP_EMPTY()) == 0 END -BEGIN BOOST_PP_CHECK_EMPTY(OBJECT BOOST_PP_EMPTY()) == 1 END -BEGIN BOOST_PP_CHECK_EMPTY(FUNC(z) BOOST_PP_EMPTY()) == 1 END -BEGIN BOOST_PP_CHECK_EMPTY(FUNC_GEN6) == 0 END -BEGIN BOOST_PP_CHECK_EMPTY(FUNC_GEN7) == 0 END -BEGIN BOOST_PP_CHECK_EMPTY(NAME) == 0 END -BEGIN BOOST_PP_CHECK_EMPTY(ATUPLE) == 0 END -BEGIN BOOST_PP_CHECK_EMPTY(ATUPLE_PLUS) == 0 END +static_assert(BOOST_PP_CHECK_EMPTY(FUNC_GEN) == 0, ""); +static_assert(BOOST_PP_CHECK_EMPTY(FUNC_GEN2) == 0, ""); +static_assert(BOOST_PP_CHECK_EMPTY(FUNC_GEN3) == 0, ""); +static_assert(BOOST_PP_CHECK_EMPTY(FUNC_GEN4) == 0, ""); +static_assert(BOOST_PP_CHECK_EMPTY(FUNC_GEN5) == 0, ""); +static_assert(BOOST_PP_CHECK_EMPTY(FUNC_GEN8) == 0, ""); +static_assert(BOOST_PP_CHECK_EMPTY(FUNC_GEN9) == 0, ""); +static_assert(BOOST_PP_CHECK_EMPTY(FUNC_GEN10) == 0, ""); +static_assert(BOOST_PP_CHECK_EMPTY(BOOST_PP_EMPTY()) == 1, ""); +static_assert(BOOST_PP_CHECK_EMPTY(DATA BOOST_PP_EMPTY()) == 1, ""); +static_assert(BOOST_PP_CHECK_EMPTY(x BOOST_PP_EMPTY()) == 0, ""); +static_assert(BOOST_PP_CHECK_EMPTY(OBJECT BOOST_PP_EMPTY()) == 1, ""); +static_assert(BOOST_PP_CHECK_EMPTY(FUNC(z) BOOST_PP_EMPTY()) == 1, ""); +static_assert(BOOST_PP_CHECK_EMPTY(FUNC_GEN6) == 0, ""); +static_assert(BOOST_PP_CHECK_EMPTY(FUNC_GEN7) == 0, ""); +static_assert(BOOST_PP_CHECK_EMPTY(NAME) == 0, ""); +static_assert(BOOST_PP_CHECK_EMPTY(ATUPLE) == 0, ""); +static_assert(BOOST_PP_CHECK_EMPTY(ATUPLE_PLUS) == 0, ""); # else -BEGIN 1 == 1 END +static_assert(1 == 1, ""); # endif diff --git a/test/clang_cuda.cu b/test/clang_cuda.cu index c360a387..816c1902 100644 --- a/test/clang_cuda.cu +++ b/test/clang_cuda.cu @@ -9,15 +9,14 @@ # # /* See http://www.boost.org for most recent version. */ # -# include "test_macro.h" #if defined(__clang__) && defined(__CUDACC__) && defined(__CUDA__) -BEGIN BOOST_PP_VARIADICS == 1 END +static_assert(BOOST_PP_VARIADICS == 1, ""); #else -BEGIN 0 == 1 END +static_assert(0 == 1, ""); #endif diff --git a/test/comparison.cxx b/test/comparison.cxx index 65ae94d3..975f04ee 100644 --- a/test/comparison.cxx +++ b/test/comparison.cxx @@ -15,122 +15,122 @@ /* equality */ -BEGIN BOOST_PP_EQUAL(2, 0) == 0 END -BEGIN BOOST_PP_EQUAL(2, 2) == 1 END +static_assert(BOOST_PP_EQUAL(2, 0) == 0, ""); +static_assert(BOOST_PP_EQUAL(2, 2) == 1, ""); #if BOOST_PP_LIMIT_MAG == 512 -BEGIN BOOST_PP_EQUAL(135, 487) == 0 END -BEGIN BOOST_PP_EQUAL(367, 367) == 1 END +static_assert(BOOST_PP_EQUAL(135, 487) == 0, ""); +static_assert(BOOST_PP_EQUAL(367, 367) == 1, ""); #endif #if BOOST_PP_LIMIT_MAG == 1024 -BEGIN BOOST_PP_EQUAL(749, 832) == 0 END -BEGIN BOOST_PP_EQUAL(955, 955) == 1 END +static_assert(BOOST_PP_EQUAL(749, 832) == 0, ""); +static_assert(BOOST_PP_EQUAL(955, 955) == 1, ""); #endif /* inequality */ -BEGIN BOOST_PP_NOT_EQUAL(2, 0) == 1 END -BEGIN BOOST_PP_NOT_EQUAL(2, 2) == 0 END +static_assert(BOOST_PP_NOT_EQUAL(2, 0) == 1, ""); +static_assert(BOOST_PP_NOT_EQUAL(2, 2) == 0, ""); #if BOOST_PP_LIMIT_MAG == 512 -BEGIN BOOST_PP_NOT_EQUAL(375, 126) == 1 END -BEGIN BOOST_PP_NOT_EQUAL(439, 439) == 0 END +static_assert(BOOST_PP_NOT_EQUAL(375, 126) == 1, ""); +static_assert(BOOST_PP_NOT_EQUAL(439, 439) == 0, ""); #endif #if BOOST_PP_LIMIT_MAG == 1024 -BEGIN BOOST_PP_NOT_EQUAL(684, 674) == 1 END -BEGIN BOOST_PP_NOT_EQUAL(1011, 1011) == 0 END +static_assert(BOOST_PP_NOT_EQUAL(684, 674) == 1, ""); +static_assert(BOOST_PP_NOT_EQUAL(1011, 1011) == 0, ""); #endif /* less */ -BEGIN BOOST_PP_LESS(2, 1) == 0 END -BEGIN BOOST_PP_LESS(1, 2) == 1 END +static_assert(BOOST_PP_LESS(2, 1) == 0, ""); +static_assert(BOOST_PP_LESS(1, 2) == 1, ""); #if BOOST_PP_LIMIT_MAG == 512 -BEGIN BOOST_PP_LESS(265, 241) == 0 END -BEGIN BOOST_PP_LESS(510, 511) == 1 END +static_assert(BOOST_PP_LESS(265, 241) == 0, ""); +static_assert(BOOST_PP_LESS(510, 511) == 1, ""); #endif #if BOOST_PP_LIMIT_MAG == 1024 -BEGIN BOOST_PP_LESS(753, 629) == 0 END -BEGIN BOOST_PP_LESS(1022, 1024) == 1 END +static_assert(BOOST_PP_LESS(753, 629) == 0, ""); +static_assert(BOOST_PP_LESS(1022, 1024) == 1, ""); #endif /* less_equal */ -BEGIN BOOST_PP_LESS_EQUAL(2, 1) == 0 END -BEGIN BOOST_PP_LESS_EQUAL(1, 2) == 1 END -BEGIN BOOST_PP_LESS_EQUAL(2, 2) == 1 END +static_assert(BOOST_PP_LESS_EQUAL(2, 1) == 0, ""); +static_assert(BOOST_PP_LESS_EQUAL(1, 2) == 1, ""); +static_assert(BOOST_PP_LESS_EQUAL(2, 2) == 1, ""); #if BOOST_PP_LIMIT_MAG == 512 -BEGIN BOOST_PP_LESS_EQUAL(327, 211) == 0 END -BEGIN BOOST_PP_LESS_EQUAL(489, 502) == 1 END -BEGIN BOOST_PP_LESS_EQUAL(327, 327) == 1 END +static_assert(BOOST_PP_LESS_EQUAL(327, 211) == 0, ""); +static_assert(BOOST_PP_LESS_EQUAL(489, 502) == 1, ""); +static_assert(BOOST_PP_LESS_EQUAL(327, 327) == 1, ""); #endif #if BOOST_PP_LIMIT_MAG == 1024 -BEGIN BOOST_PP_LESS_EQUAL(951, 632) == 0 END -BEGIN BOOST_PP_LESS_EQUAL(875, 1002) == 1 END -BEGIN BOOST_PP_LESS_EQUAL(727, 727) == 1 END +static_assert(BOOST_PP_LESS_EQUAL(951, 632) == 0, ""); +static_assert(BOOST_PP_LESS_EQUAL(875, 1002) == 1, ""); +static_assert(BOOST_PP_LESS_EQUAL(727, 727) == 1, ""); #endif /* greater */ -BEGIN BOOST_PP_GREATER(2, 1) == 1 END -BEGIN BOOST_PP_GREATER(1, 2) == 0 END +static_assert(BOOST_PP_GREATER(2, 1) == 1, ""); +static_assert(BOOST_PP_GREATER(1, 2) == 0, ""); #if BOOST_PP_LIMIT_MAG == 512 -BEGIN BOOST_PP_GREATER(348, 259) == 1 END -BEGIN BOOST_PP_GREATER(411, 411) == 0 END -BEGIN BOOST_PP_GREATER(327, 373) == 0 END +static_assert(BOOST_PP_GREATER(348, 259) == 1, ""); +static_assert(BOOST_PP_GREATER(411, 411) == 0, ""); +static_assert(BOOST_PP_GREATER(327, 373) == 0, ""); #endif #if BOOST_PP_LIMIT_MAG == 1024 -BEGIN BOOST_PP_GREATER(846, 523) == 1 END -BEGIN BOOST_PP_GREATER(574, 574) == 0 END -BEGIN BOOST_PP_GREATER(749, 811) == 0 END +static_assert(BOOST_PP_GREATER(846, 523) == 1, ""); +static_assert(BOOST_PP_GREATER(574, 574) == 0, ""); +static_assert(BOOST_PP_GREATER(749, 811) == 0, ""); #endif /* greater_equal */ -BEGIN BOOST_PP_GREATER_EQUAL(2, 1) == 1 END -BEGIN BOOST_PP_GREATER_EQUAL(1, 2) == 0 END -BEGIN BOOST_PP_GREATER_EQUAL(2, 2) == 1 END +static_assert(BOOST_PP_GREATER_EQUAL(2, 1) == 1, ""); +static_assert(BOOST_PP_GREATER_EQUAL(1, 2) == 0, ""); +static_assert(BOOST_PP_GREATER_EQUAL(2, 2) == 1, ""); #if BOOST_PP_LIMIT_MAG == 512 -BEGIN BOOST_PP_GREATER_EQUAL(341, 27) == 1 END -BEGIN BOOST_PP_GREATER_EQUAL(289, 470) == 0 END -BEGIN BOOST_PP_GREATER_EQUAL(296, 296) == 1 END +static_assert(BOOST_PP_GREATER_EQUAL(341, 27) == 1, ""); +static_assert(BOOST_PP_GREATER_EQUAL(289, 470) == 0, ""); +static_assert(BOOST_PP_GREATER_EQUAL(296, 296) == 1, ""); #endif #if BOOST_PP_LIMIT_MAG == 1024 -BEGIN BOOST_PP_GREATER_EQUAL(946, 852) == 1 END -BEGIN BOOST_PP_GREATER_EQUAL(685, 717) == 0 END -BEGIN BOOST_PP_GREATER_EQUAL(1001, 1001) == 1 END +static_assert(BOOST_PP_GREATER_EQUAL(946, 852) == 1, ""); +static_assert(BOOST_PP_GREATER_EQUAL(685, 717) == 0, ""); +static_assert(BOOST_PP_GREATER_EQUAL(1001, 1001) == 1, ""); #endif diff --git a/test/control.cxx b/test/control.cxx index 8a2b7c8d..6ed95b2c 100644 --- a/test/control.cxx +++ b/test/control.cxx @@ -17,31 +17,31 @@ # define TR(x) 1 -BEGIN BOOST_PP_EXPR_IIF(0, TR)(0) == 0 END -BEGIN BOOST_PP_EXPR_IIF(1, TR)(0) == 1 END +static_assert(BOOST_PP_EXPR_IIF(0, TR)(0) == 0, ""); +static_assert(BOOST_PP_EXPR_IIF(1, TR)(0) == 1, ""); -BEGIN BOOST_PP_EXPR_IF(3, TR)(0) == 1 END -BEGIN BOOST_PP_EXPR_IF(0, TR)(0) == 0 END +static_assert(BOOST_PP_EXPR_IF(3, TR)(0) == 1, ""); +static_assert(BOOST_PP_EXPR_IF(0, TR)(0) == 0, ""); -BEGIN BOOST_PP_IIF(0, 1, 0) == 0 END -BEGIN BOOST_PP_IIF(1, 1, 0) == 1 END +static_assert(BOOST_PP_IIF(0, 1, 0) == 0, ""); +static_assert(BOOST_PP_IIF(1, 1, 0) == 1, ""); -BEGIN BOOST_PP_IF(0, 1, 0) == 0 END -BEGIN BOOST_PP_IF(9, 1, 0) == 1 END +static_assert(BOOST_PP_IF(0, 1, 0) == 0, ""); +static_assert(BOOST_PP_IF(9, 1, 0) == 1, ""); # define PRED(d, state) state # define OP_1(d, state) BOOST_PP_DEC(state) -BEGIN BOOST_PP_WHILE(PRED, OP_1, 50) == 0 END +static_assert(BOOST_PP_WHILE(PRED, OP_1, 50) == 0, ""); # define OP_2(d, state) BOOST_PP_DEC(BOOST_PP_ADD(BOOST_PP_WHILE(PRED, OP_1, state), state)) # define OP_3(d, state) BOOST_PP_DEC(BOOST_PP_ADD_D(d, BOOST_PP_WHILE_ ## d(PRED, OP_1, state), state)) -BEGIN BOOST_PP_WHILE(PRED, OP_2, 10) == 0 END -BEGIN BOOST_PP_WHILE(PRED, OP_3, 10) == 0 END +static_assert(BOOST_PP_WHILE(PRED, OP_2, 10) == 0, ""); +static_assert(BOOST_PP_WHILE(PRED, OP_3, 10) == 0, ""); #if BOOST_PP_LIMIT_MAG != 256 -BEGIN BOOST_PP_WHILE(PRED, OP_1, BOOST_PP_LIMIT_MAG) == 0 END +static_assert(BOOST_PP_WHILE(PRED, OP_1, BOOST_PP_LIMIT_MAG) == 0, ""); #endif diff --git a/test/debug.cxx b/test/debug.cxx index 6495fc8f..fa42506f 100644 --- a/test/debug.cxx +++ b/test/debug.cxx @@ -12,10 +12,10 @@ # include # include "test.h" -BEGIN sizeof(BOOST_PP_ASSERT_MSG(0, "text") "") / sizeof(char) != 1 END -BEGIN sizeof(BOOST_PP_ASSERT_MSG(1, "text") "") / sizeof(char) == 1 END +static_assert(sizeof(BOOST_PP_ASSERT_MSG(0, "text") "") / sizeof(char) != 1, ""); +static_assert(sizeof(BOOST_PP_ASSERT_MSG(1, "text") "") / sizeof(char) == 1, ""); BOOST_PP_ASSERT(10) # line BOOST_PP_LINE(100, __FILE__) -BEGIN __LINE__ == 100 END +static_assert(__LINE__ == 100, ""); diff --git a/test/facilities.cxx b/test/facilities.cxx index 0c402fd0..a0df7c14 100644 --- a/test/facilities.cxx +++ b/test/facilities.cxx @@ -15,20 +15,20 @@ # include # include "test.h" -BEGIN BOOST_PP_APPLY(BOOST_PP_NIL) 0 == 0 END -BEGIN BOOST_PP_APPLY((0)) == 0 END +static_assert(BOOST_PP_APPLY(BOOST_PP_NIL) 0 == 0, ""); +static_assert(BOOST_PP_APPLY((0)) == 0, ""); -BEGIN BOOST_PP_APPLY((BOOST_PP_EMPTY))() 0 == 0 END +static_assert(BOOST_PP_APPLY((BOOST_PP_EMPTY))() 0 == 0, ""); # define MACRO(x, y, z) 1 # define ARGS (1, 2, 3) -BEGIN BOOST_PP_EXPAND(MACRO ARGS) == 1 END +static_assert(BOOST_PP_EXPAND(MACRO ARGS) == 1, ""); -BEGIN BOOST_PP_IDENTITY(1)() == 1 END -BEGIN BOOST_PP_IDENTITY_N(36,10)(0,1,2,3,4,5,6,7,8,9) == 36 END +static_assert(BOOST_PP_IDENTITY(1)() == 1, ""); +static_assert(BOOST_PP_IDENTITY_N(36,10)(0,1,2,3,4,5,6,7,8,9) == 36, ""); -BEGIN BOOST_PP_CAT(BOOST_PP_INTERCEPT, 2) 1 == 1 END +static_assert(BOOST_PP_CAT(BOOST_PP_INTERCEPT, 2) 1 == 1, ""); #define OVMAC_1(x) BOOST_PP_ADD(x,5) #define OVMAC_2(x,y) BOOST_PP_ADD(x,y) @@ -45,7 +45,7 @@ BEGIN BOOST_PP_CAT(BOOST_PP_INTERCEPT, 2) 1 == 1 END #endif -BEGIN OVTEST(3,4,5) == 17 END -BEGIN OVTEST(9,3,2,7) == 41 END -BEGIN OVTEST(8) == 13 END -BEGIN OVTEST(24,61) == 85 END +static_assert(OVTEST(3,4,5) == 17, ""); +static_assert(OVTEST(9,3,2,7) == 41, ""); +static_assert(OVTEST(8) == 13, ""); +static_assert(OVTEST(24,61) == 85, ""); diff --git a/test/isempty.cxx b/test/isempty.cxx index f6e3aa78..3b4b4f22 100644 --- a/test/isempty.cxx +++ b/test/isempty.cxx @@ -40,46 +40,46 @@ #if defined(__cplusplus) && __cplusplus > 201703L && BOOST_PP_VARIADIC_HAS_OPT() -BEGIN BOOST_PP_IS_EMPTY(FUNC_GEN) == 0 END -BEGIN BOOST_PP_IS_EMPTY(FUNC_GEN2) == 0 END -BEGIN BOOST_PP_IS_EMPTY(FUNC_GEN3) == 0 END -BEGIN BOOST_PP_IS_EMPTY(FUNC_GEN4) == 0 END -BEGIN BOOST_PP_IS_EMPTY(FUNC_GEN5) == 0 END -BEGIN BOOST_PP_IS_EMPTY(FUNC_GEN8) == 0 END -BEGIN BOOST_PP_IS_EMPTY(FUNC_GEN9) == 0 END -BEGIN BOOST_PP_IS_EMPTY(FUNC_GEN10) == 0 END +static_assert(BOOST_PP_IS_EMPTY(FUNC_GEN) == 0, ""); +static_assert(BOOST_PP_IS_EMPTY(FUNC_GEN2) == 0, ""); +static_assert(BOOST_PP_IS_EMPTY(FUNC_GEN3) == 0, ""); +static_assert(BOOST_PP_IS_EMPTY(FUNC_GEN4) == 0, ""); +static_assert(BOOST_PP_IS_EMPTY(FUNC_GEN5) == 0, ""); +static_assert(BOOST_PP_IS_EMPTY(FUNC_GEN8) == 0, ""); +static_assert(BOOST_PP_IS_EMPTY(FUNC_GEN9) == 0, ""); +static_assert(BOOST_PP_IS_EMPTY(FUNC_GEN10) == 0, ""); #elif BOOST_PP_VARIADICS_MSVC /* Testing the VC++ variadic version */ /* INCORRECT */ -BEGIN BOOST_PP_IS_EMPTY(FUNC_GEN) == 1 END -BEGIN BOOST_PP_IS_EMPTY(FUNC_GEN2) == 1 END -BEGIN BOOST_PP_IS_EMPTY(FUNC_GEN3) == 1 END -BEGIN BOOST_PP_IS_EMPTY(FUNC_GEN4) == 1 END -BEGIN BOOST_PP_IS_EMPTY(FUNC_GEN5) == 1 END -BEGIN BOOST_PP_IS_EMPTY(FUNC_GEN8) == 1 END -BEGIN BOOST_PP_IS_EMPTY(FUNC_GEN10) == 1 END +static_assert(BOOST_PP_IS_EMPTY(FUNC_GEN) == 1, ""); +static_assert(BOOST_PP_IS_EMPTY(FUNC_GEN2) == 1, ""); +static_assert(BOOST_PP_IS_EMPTY(FUNC_GEN3) == 1, ""); +static_assert(BOOST_PP_IS_EMPTY(FUNC_GEN4) == 1, ""); +static_assert(BOOST_PP_IS_EMPTY(FUNC_GEN5) == 1, ""); +static_assert(BOOST_PP_IS_EMPTY(FUNC_GEN8) == 1, ""); +static_assert(BOOST_PP_IS_EMPTY(FUNC_GEN10) == 1, ""); /* CORRECT */ -BEGIN BOOST_PP_IS_EMPTY(FUNC_GEN9) == 0 END +static_assert(BOOST_PP_IS_EMPTY(FUNC_GEN9) == 0, ""); #else /* Testing the non-VC++ variadic version */ /* CORRECT */ -BEGIN BOOST_PP_IS_EMPTY(FUNC_GEN) == 0 END -BEGIN BOOST_PP_IS_EMPTY(FUNC_GEN2) == 0 END -BEGIN BOOST_PP_IS_EMPTY(FUNC_GEN3) == 0 END -BEGIN BOOST_PP_IS_EMPTY(FUNC_GEN4) == 0 END -BEGIN BOOST_PP_IS_EMPTY(FUNC_GEN5) == 0 END -BEGIN BOOST_PP_IS_EMPTY(FUNC_GEN10) == 0 END +static_assert(BOOST_PP_IS_EMPTY(FUNC_GEN) == 0, ""); +static_assert(BOOST_PP_IS_EMPTY(FUNC_GEN2) == 0, ""); +static_assert(BOOST_PP_IS_EMPTY(FUNC_GEN3) == 0, ""); +static_assert(BOOST_PP_IS_EMPTY(FUNC_GEN4) == 0, ""); +static_assert(BOOST_PP_IS_EMPTY(FUNC_GEN5) == 0, ""); +static_assert(BOOST_PP_IS_EMPTY(FUNC_GEN10) == 0, ""); /* COMPILER ERROR */ -// BEGIN BOOST_PP_IS_EMPTY(FUNC_GEN8) == 0 END -// BEGIN BOOST_PP_IS_EMPTY(FUNC_GEN9) == 0 END +// static_assert(BOOST_PP_IS_EMPTY(FUNC_GEN8) == 0, ""); +// static_assert(BOOST_PP_IS_EMPTY(FUNC_GEN9) == 0, ""); #endif @@ -87,15 +87,15 @@ BEGIN BOOST_PP_IS_EMPTY(FUNC_GEN10) == 0 END /* CORRECT */ -BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_EMPTY()) == 1 END -BEGIN BOOST_PP_IS_EMPTY(DATA BOOST_PP_EMPTY()) == 1 END -BEGIN BOOST_PP_IS_EMPTY(x BOOST_PP_EMPTY()) == 0 END -BEGIN BOOST_PP_IS_EMPTY(OBJECT BOOST_PP_EMPTY()) == 1 END -BEGIN BOOST_PP_IS_EMPTY(FUNC(z) BOOST_PP_EMPTY()) == 1 END -BEGIN BOOST_PP_IS_EMPTY(FUNC_GEN6) == 0 END -BEGIN BOOST_PP_IS_EMPTY(FUNC_GEN7) == 0 END -BEGIN BOOST_PP_IS_EMPTY(NAME) == 0 END -BEGIN BOOST_PP_IS_EMPTY(ATUPLE) == 0 END -BEGIN BOOST_PP_IS_EMPTY(ATUPLE_PLUS) == 0 END +static_assert(BOOST_PP_IS_EMPTY(BOOST_PP_EMPTY()) == 1, ""); +static_assert(BOOST_PP_IS_EMPTY(DATA BOOST_PP_EMPTY()) == 1, ""); +static_assert(BOOST_PP_IS_EMPTY(x BOOST_PP_EMPTY()) == 0, ""); +static_assert(BOOST_PP_IS_EMPTY(OBJECT BOOST_PP_EMPTY()) == 1, ""); +static_assert(BOOST_PP_IS_EMPTY(FUNC(z) BOOST_PP_EMPTY()) == 1, ""); +static_assert(BOOST_PP_IS_EMPTY(FUNC_GEN6) == 0, ""); +static_assert(BOOST_PP_IS_EMPTY(FUNC_GEN7) == 0, ""); +static_assert(BOOST_PP_IS_EMPTY(NAME) == 0, ""); +static_assert(BOOST_PP_IS_EMPTY(ATUPLE) == 0, ""); +static_assert(BOOST_PP_IS_EMPTY(ATUPLE_PLUS) == 0, ""); #endif diff --git a/test/isempty_variadic_standard_failure.cxx b/test/isempty_variadic_standard_failure.cxx index 1bfe0eec..d33c0fc2 100644 --- a/test/isempty_variadic_standard_failure.cxx +++ b/test/isempty_variadic_standard_failure.cxx @@ -20,16 +20,16 @@ # include -BEGIN BOOST_PP_IS_EMPTY(FUNC_GEN8) == BOOST_PP_VARIADIC_HAS_OPT() END +static_assert(BOOST_PP_IS_EMPTY(FUNC_GEN8) == BOOST_PP_VARIADIC_HAS_OPT(), ""); #else -BEGIN BOOST_PP_IS_EMPTY(FUNC_GEN8) == 0 END +static_assert(BOOST_PP_IS_EMPTY(FUNC_GEN8) == 0, ""); #endif #else -BEGIN 1 == 0 END +static_assert(1 == 0, ""); #endif diff --git a/test/isempty_variadic_standard_failure2.cxx b/test/isempty_variadic_standard_failure2.cxx index ae067f57..33f25174 100644 --- a/test/isempty_variadic_standard_failure2.cxx +++ b/test/isempty_variadic_standard_failure2.cxx @@ -20,16 +20,16 @@ # include -BEGIN BOOST_PP_IS_EMPTY(FUNC_GEN9) == BOOST_PP_VARIADIC_HAS_OPT() END +static_assert(BOOST_PP_IS_EMPTY(FUNC_GEN9) == BOOST_PP_VARIADIC_HAS_OPT(), ""); #else -BEGIN BOOST_PP_IS_EMPTY(FUNC_GEN9) == 0 END +static_assert(BOOST_PP_IS_EMPTY(FUNC_GEN9) == 0, ""); #endif #else -BEGIN 1 == 0 END +static_assert(1 == 0, ""); #endif diff --git a/test/iteration.cpp b/test/iteration.cpp index 2b551ebd..29b34c88 100644 --- a/test/iteration.cpp +++ b/test/iteration.cpp @@ -15,7 +15,7 @@ # # include "iteration.h" # -# define TEST(n) BEGIN n == n END +# define TEST(n) static_assert(n == n); # # define BOOST_PP_LOCAL_MACRO(n) TEST(n) # define BOOST_PP_LOCAL_LIMITS (1, 5) @@ -42,6 +42,6 @@ # # else -BEGIN BOOST_PP_IS_SELFISH == 1 END +static_assert(BOOST_PP_IS_SELFISH == 1, ""); # endif diff --git a/test/iteration.h b/test/iteration.h index 37bda60c..67e1354d 100644 --- a/test/iteration.h +++ b/test/iteration.h @@ -183,10 +183,10 @@ # if defined NO_FLAGS struct BOOST_PP_CAT(X, BOOST_PP_ITERATION()) { - BEGIN + static_assert( BOOST_PP_ITERATION() >= BOOST_PP_ITERATION_START() && BOOST_PP_ITERATION() <= BOOST_PP_ITERATION_FINISH() - END + ); }; # elif BOOST_PP_ITERATION_DEPTH() == 1 \ diff --git a/test/list.cxx b/test/list.cxx index ce621091..2e343a30 100644 --- a/test/list.cxx +++ b/test/list.cxx @@ -297,95 +297,95 @@ #endif -BEGIN BOOST_PP_LIST_FIRST(LIST) == 4 END -BEGIN BOOST_PP_LIST_IS_CONS(LIST) == 1 END -BEGIN BOOST_PP_LIST_IS_CONS(LISTNIL) == 0 END -BEGIN BOOST_PP_LIST_IS_NIL(LIST) == 0 END -BEGIN BOOST_PP_LIST_IS_NIL(LISTNIL) == 1 END +static_assert(BOOST_PP_LIST_FIRST(LIST) == 4, ""); +static_assert(BOOST_PP_LIST_IS_CONS(LIST) == 1, ""); +static_assert(BOOST_PP_LIST_IS_CONS(LISTNIL) == 0, ""); +static_assert(BOOST_PP_LIST_IS_NIL(LIST) == 0, ""); +static_assert(BOOST_PP_LIST_IS_NIL(LISTNIL) == 1, ""); # if BOOST_PP_LIMIT_MAG == 512 -BEGIN BOOST_PP_LIST_FIRST(LIST_512) == 1 END -BEGIN BOOST_PP_LIST_IS_CONS(LIST_512) == 1 END -BEGIN BOOST_PP_LIST_IS_NIL(LIST_512) == 0 END +static_assert(BOOST_PP_LIST_FIRST(LIST_512) == 1, ""); +static_assert(BOOST_PP_LIST_IS_CONS(LIST_512) == 1, ""); +static_assert(BOOST_PP_LIST_IS_NIL(LIST_512) == 0, ""); #endif # if BOOST_PP_LIMIT_MAG == 1024 -BEGIN BOOST_PP_LIST_FIRST(LIST_1024) == 1 END -BEGIN BOOST_PP_LIST_IS_CONS(LIST_1024) == 1 END -BEGIN BOOST_PP_LIST_IS_NIL(LIST_1024) == 0 END +static_assert(BOOST_PP_LIST_FIRST(LIST_1024) == 1, ""); +static_assert(BOOST_PP_LIST_IS_CONS(LIST_1024) == 1, ""); +static_assert(BOOST_PP_LIST_IS_NIL(LIST_1024) == 0, ""); #endif -BEGIN BOOST_PP_VARIADIC_ELEM(2,BOOST_PP_LIST_ENUM(LIST)) == 5 END -BEGIN BOOST_PP_LIST_FOLD_LEFT(BOOST_PP_SUB_D, 22, LIST) == 10 END -BEGIN BOOST_PP_LIST_FOLD_LEFT(BOOST_PP_SUB_D, 22, LISTNIL) == 22 END -BEGIN BOOST_PP_LIST_FOLD_RIGHT(BOOST_PP_ADD_D, 0, LIST) == 12 END -BEGIN BOOST_PP_LIST_FOLD_RIGHT(BOOST_PP_ADD_D, 0, LISTNIL) == 0 END -BEGIN BOOST_PP_LIST_FOLD_RIGHT(REVERSAL, 0, LIST) == 4 END +static_assert(BOOST_PP_VARIADIC_ELEM(2,BOOST_PP_LIST_ENUM(LIST)) == 5, ""); +static_assert(BOOST_PP_LIST_FOLD_LEFT(BOOST_PP_SUB_D, 22, LIST) == 10, ""); +static_assert(BOOST_PP_LIST_FOLD_LEFT(BOOST_PP_SUB_D, 22, LISTNIL) == 22, ""); +static_assert(BOOST_PP_LIST_FOLD_RIGHT(BOOST_PP_ADD_D, 0, LIST) == 12, ""); +static_assert(BOOST_PP_LIST_FOLD_RIGHT(BOOST_PP_ADD_D, 0, LISTNIL) == 0, ""); +static_assert(BOOST_PP_LIST_FOLD_RIGHT(REVERSAL, 0, LIST) == 4, ""); -BEGIN BOOST_PP_LIST_CAT(BOOST_PP_LIST_REVERSE(LIST)) == 2514 END -BEGIN BOOST_PP_LIST_IS_NIL(BOOST_PP_LIST_REVERSE(LISTNIL)) == 1 END +static_assert(BOOST_PP_LIST_CAT(BOOST_PP_LIST_REVERSE(LIST)) == 2514, ""); +static_assert(BOOST_PP_LIST_IS_NIL(BOOST_PP_LIST_REVERSE(LISTNIL)) == 1, ""); # if BOOST_PP_LIMIT_MAG == 512 -BEGIN BOOST_PP_LIST_AT(BOOST_PP_LIST_REVERSE(LIST_512),493) == 19 END +static_assert(BOOST_PP_LIST_AT(BOOST_PP_LIST_REVERSE(LIST_512),493) == 19, ""); #endif # if BOOST_PP_LIMIT_MAG == 1024 -BEGIN BOOST_PP_LIST_AT(BOOST_PP_LIST_REVERSE(LIST_1024),931) == 93 END +static_assert(BOOST_PP_LIST_AT(BOOST_PP_LIST_REVERSE(LIST_1024),931) == 93, ""); #endif -BEGIN BOOST_PP_LIST_CAT(BOOST_PP_LIST_REST_N(2, LIST)) == 52 END -BEGIN BOOST_PP_LIST_IS_NIL(BOOST_PP_LIST_REST_N(0, LISTNIL)) == 1 END -BEGIN BOOST_PP_LIST_CAT(BOOST_PP_LIST_FIRST_N(2, LIST)) == 41 END +static_assert(BOOST_PP_LIST_CAT(BOOST_PP_LIST_REST_N(2, LIST)) == 52, ""); +static_assert(BOOST_PP_LIST_IS_NIL(BOOST_PP_LIST_REST_N(0, LISTNIL)) == 1, ""); +static_assert(BOOST_PP_LIST_CAT(BOOST_PP_LIST_FIRST_N(2, LIST)) == 41, ""); # if BOOST_PP_LIMIT_MAG == 512 -BEGIN BOOST_PP_LIST_AT(BOOST_PP_LIST_FIRST_N(357, LIST_512),291) == 292 END -BEGIN BOOST_PP_LIST_SIZE(BOOST_PP_LIST_REST_N(411, LIST_512)) == 101 END +static_assert(BOOST_PP_LIST_AT(BOOST_PP_LIST_FIRST_N(357, LIST_512),291) == 292, ""); +static_assert(BOOST_PP_LIST_SIZE(BOOST_PP_LIST_REST_N(411, LIST_512)) == 101, ""); #endif # if BOOST_PP_LIMIT_MAG == 1024 -BEGIN BOOST_PP_LIST_AT(BOOST_PP_LIST_FIRST_N(738, LIST_1024),629) == 630 END -BEGIN BOOST_PP_LIST_SIZE(BOOST_PP_LIST_REST_N(813, LIST_1024)) == 211 END +static_assert(BOOST_PP_LIST_AT(BOOST_PP_LIST_FIRST_N(738, LIST_1024),629) == 630, ""); +static_assert(BOOST_PP_LIST_SIZE(BOOST_PP_LIST_REST_N(813, LIST_1024)) == 211, ""); #endif -BEGIN BOOST_PP_LIST_AT(LIST, 2) == 5 END -BEGIN BOOST_PP_LIST_SIZE(LIST) == 4 END -BEGIN BOOST_PP_LIST_SIZE(LISTNIL) == 0 END +static_assert(BOOST_PP_LIST_AT(LIST, 2) == 5, ""); +static_assert(BOOST_PP_LIST_SIZE(LIST) == 4, ""); +static_assert(BOOST_PP_LIST_SIZE(LISTNIL) == 0, ""); # if BOOST_PP_LIMIT_MAG == 512 -BEGIN BOOST_PP_LIST_AT(LIST_512, 279) == 280 END -BEGIN BOOST_PP_LIST_SIZE(LIST_512) == 512 END +static_assert(BOOST_PP_LIST_AT(LIST_512, 279) == 280, ""); +static_assert(BOOST_PP_LIST_SIZE(LIST_512) == 512, ""); #endif # if BOOST_PP_LIMIT_MAG == 1024 -BEGIN BOOST_PP_LIST_AT(LIST_1024, 925) == 926 END -BEGIN BOOST_PP_LIST_SIZE(LIST_1024) == 1024 END +static_assert(BOOST_PP_LIST_AT(LIST_1024, 925) == 926, ""); +static_assert(BOOST_PP_LIST_SIZE(LIST_1024) == 1024, ""); #endif -BEGIN BOOST_PP_LIST_CAT(BOOST_PP_LIST_TRANSFORM(BOOST_PP_ADD_D, 2, LIST)) == 6374 END -BEGIN BOOST_PP_LIST_IS_NIL(BOOST_PP_LIST_TRANSFORM(BOOST_PP_ADD_D, 2, LISTNIL)) == 1 END +static_assert(BOOST_PP_LIST_CAT(BOOST_PP_LIST_TRANSFORM(BOOST_PP_ADD_D, 2, LIST)) == 6374, ""); +static_assert(BOOST_PP_LIST_IS_NIL(BOOST_PP_LIST_TRANSFORM(BOOST_PP_ADD_D, 2, LISTNIL)) == 1, ""); # if BOOST_PP_LIMIT_MAG == 512 #define BOOST_PP_LIST_TEST_TRANSFORM_OP(d, data, elem) BOOST_PP_EQUAL(elem,data) -BEGIN BOOST_PP_LIST_AT(BOOST_PP_LIST_TRANSFORM(BOOST_PP_LIST_TEST_TRANSFORM_OP, 472, LIST_512),471) == 1 END -BEGIN BOOST_PP_LIST_AT(BOOST_PP_LIST_TRANSFORM(BOOST_PP_LIST_TEST_TRANSFORM_OP, 267, LIST_512),333) == 0 END +static_assert(BOOST_PP_LIST_AT(BOOST_PP_LIST_TRANSFORM(BOOST_PP_LIST_TEST_TRANSFORM_OP, 472, LIST_512),471) == 1, ""); +static_assert(BOOST_PP_LIST_AT(BOOST_PP_LIST_TRANSFORM(BOOST_PP_LIST_TEST_TRANSFORM_OP, 267, LIST_512),333) == 0, ""); #endif @@ -393,66 +393,66 @@ BEGIN BOOST_PP_LIST_AT(BOOST_PP_LIST_TRANSFORM(BOOST_PP_LIST_TEST_TRANSFORM_OP, #define BOOST_PP_LIST_TEST_TRANSFORM_OP(d, data, elem) BOOST_PP_EQUAL(elem,data) -BEGIN BOOST_PP_LIST_AT(BOOST_PP_LIST_TRANSFORM(BOOST_PP_LIST_TEST_TRANSFORM_OP, 876, LIST_1024),875) == 1 END -BEGIN BOOST_PP_LIST_AT(BOOST_PP_LIST_TRANSFORM(BOOST_PP_LIST_TEST_TRANSFORM_OP, 637, LIST_1024),741) == 0 END +static_assert(BOOST_PP_LIST_AT(BOOST_PP_LIST_TRANSFORM(BOOST_PP_LIST_TEST_TRANSFORM_OP, 876, LIST_1024),875) == 1, ""); +static_assert(BOOST_PP_LIST_AT(BOOST_PP_LIST_TRANSFORM(BOOST_PP_LIST_TEST_TRANSFORM_OP, 637, LIST_1024),741) == 0, ""); #endif -BEGIN BOOST_PP_LIST_CAT(BOOST_PP_LIST_APPEND(BOOST_PP_LIST_REST(LIST), LIST)) == 1524152 END -BEGIN BOOST_PP_LIST_CAT(BOOST_PP_LIST_APPEND(LIST,LISTNIL)) == 4152 END -BEGIN BOOST_PP_LIST_CAT(BOOST_PP_LIST_APPEND(LISTNIL,LIST)) == 4152 END -BEGIN BOOST_PP_LIST_IS_NIL(BOOST_PP_LIST_APPEND(LISTNIL,LISTNIL)) == 1 END +static_assert(BOOST_PP_LIST_CAT(BOOST_PP_LIST_APPEND(BOOST_PP_LIST_REST(LIST), LIST)) == 1524152, ""); +static_assert(BOOST_PP_LIST_CAT(BOOST_PP_LIST_APPEND(LIST,LISTNIL)) == 4152, ""); +static_assert(BOOST_PP_LIST_CAT(BOOST_PP_LIST_APPEND(LISTNIL,LIST)) == 4152, ""); +static_assert(BOOST_PP_LIST_IS_NIL(BOOST_PP_LIST_APPEND(LISTNIL,LISTNIL)) == 1, ""); # if BOOST_PP_LIMIT_MAG == 512 -BEGIN BOOST_PP_LIST_AT(BOOST_PP_LIST_APPEND(LIST_256,LIST),258) == 5 END -BEGIN BOOST_PP_LIST_AT(BOOST_PP_LIST_APPEND(LIST,LIST_256),258) == 255 END +static_assert(BOOST_PP_LIST_AT(BOOST_PP_LIST_APPEND(LIST_256,LIST),258) == 5, ""); +static_assert(BOOST_PP_LIST_AT(BOOST_PP_LIST_APPEND(LIST,LIST_256),258) == 255, ""); #endif # if BOOST_PP_LIMIT_MAG == 1024 -BEGIN BOOST_PP_LIST_AT(BOOST_PP_LIST_APPEND(LIST_512,LIST),515) == 2 END -BEGIN BOOST_PP_LIST_AT(BOOST_PP_LIST_APPEND(LIST,LIST_512),513) == 510 END +static_assert(BOOST_PP_LIST_AT(BOOST_PP_LIST_APPEND(LIST_512,LIST),515) == 2, ""); +static_assert(BOOST_PP_LIST_AT(BOOST_PP_LIST_APPEND(LIST,LIST_512),513) == 510, ""); #endif -BEGIN BOOST_PP_LIST_FOR_EACH(F1, 1, LIST) == 16 END -BEGIN BOOST_PP_LIST_FOR_EACH_I(FI2, 1, LIST) == 17 END +static_assert(BOOST_PP_LIST_FOR_EACH(F1, 1, LIST) == 16, ""); +static_assert(BOOST_PP_LIST_FOR_EACH_I(FI2, 1, LIST) == 17, ""); -BEGIN BOOST_PP_TUPLE_ELEM(4, 3, BOOST_PP_LIST_TO_TUPLE(LIST)) == 2 END +static_assert(BOOST_PP_TUPLE_ELEM(4, 3, BOOST_PP_LIST_TO_TUPLE(LIST)) == 2, ""); -BEGIN BOOST_PP_LIST_CAT(BOOST_PP_LIST_FILTER(BOOST_PP_LESS_D, 3, LIST)) == 45 END -BEGIN BOOST_PP_LIST_IS_NIL(BOOST_PP_LIST_FILTER(BOOST_PP_LESS_D, 3, LISTNIL)) == 1 END +static_assert(BOOST_PP_LIST_CAT(BOOST_PP_LIST_FILTER(BOOST_PP_LESS_D, 3, LIST)) == 45, ""); +static_assert(BOOST_PP_LIST_IS_NIL(BOOST_PP_LIST_FILTER(BOOST_PP_LESS_D, 3, LISTNIL)) == 1, ""); # if BOOST_PP_LIMIT_MAG == 512 -BEGIN BOOST_PP_LIST_SIZE(BOOST_PP_LIST_FILTER(BOOST_PP_EQUAL_D, 372, LIST_512)) == 1 END +static_assert(BOOST_PP_LIST_SIZE(BOOST_PP_LIST_FILTER(BOOST_PP_EQUAL_D, 372, LIST_512)) == 1, ""); #endif # if BOOST_PP_LIMIT_MAG == 1024 && (!defined(__clang__) || defined(_MSC_VER) || defined(__CODEGEARC__)) -BEGIN BOOST_PP_LIST_SIZE(BOOST_PP_LIST_FILTER(BOOST_PP_EQUAL_D, 923, LIST_1024)) == 1 END +static_assert(BOOST_PP_LIST_SIZE(BOOST_PP_LIST_FILTER(BOOST_PP_EQUAL_D, 923, LIST_1024)) == 1, ""); #endif -BEGIN BOOST_PP_LIST_FOR_EACH_PRODUCT(F2, 2, ( (1, (0, BOOST_PP_NIL)), (2, (3, BOOST_PP_NIL)) )) == 0 END -BEGIN BOOST_PP_LIST_FOR_EACH_PRODUCT(F2, ( (1, (0, BOOST_PP_NIL)), (2, (3, BOOST_PP_NIL)) )) == 0 END -BEGIN BOOST_PP_LIST_CAT(BOOST_PP_LIST_FOLD_LEFT(BOOST_PP_LIST_APPEND_D, BOOST_PP_NIL, LL)) == 0x0a1b2c3d END +static_assert(BOOST_PP_LIST_FOR_EACH_PRODUCT(F2, 2, ( (1, (0, BOOST_PP_NIL)), (2, (3, BOOST_PP_NIL)) )) == 0, ""); +static_assert(BOOST_PP_LIST_FOR_EACH_PRODUCT(F2, ( (1, (0, BOOST_PP_NIL)), (2, (3, BOOST_PP_NIL)) )) == 0, ""); +static_assert(BOOST_PP_LIST_CAT(BOOST_PP_LIST_FOLD_LEFT(BOOST_PP_LIST_APPEND_D, BOOST_PP_NIL, LL)) == 0x0a1b2c3d, ""); -BEGIN BOOST_PP_ARRAY_ELEM(2, BOOST_PP_LIST_TO_ARRAY(LIST)) == 5 END -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_LIST_TO_ARRAY(LISTNIL)) == 0 END -BEGIN BOOST_PP_SEQ_ELEM(3, BOOST_PP_LIST_TO_SEQ(LIST)) == 2 END +static_assert(BOOST_PP_ARRAY_ELEM(2, BOOST_PP_LIST_TO_ARRAY(LIST)) == 5, ""); +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_LIST_TO_ARRAY(LISTNIL)) == 0, ""); +static_assert(BOOST_PP_SEQ_ELEM(3, BOOST_PP_LIST_TO_SEQ(LIST)) == 2, ""); # if BOOST_PP_LIMIT_MAG == 512 && BOOST_PP_LIMIT_FOR == 512 -BEGIN BOOST_PP_SEQ_ELEM(437, BOOST_PP_LIST_TO_SEQ(LIST_512)) == 438 END +static_assert(BOOST_PP_SEQ_ELEM(437, BOOST_PP_LIST_TO_SEQ(LIST_512)) == 438, ""); #endif # if BOOST_PP_LIMIT_MAG == 1024 && BOOST_PP_LIMIT_FOR == 1024 -BEGIN BOOST_PP_SEQ_ELEM(736, BOOST_PP_LIST_TO_SEQ(LIST_1024)) == 737 END +static_assert(BOOST_PP_SEQ_ELEM(736, BOOST_PP_LIST_TO_SEQ(LIST_1024)) == 737, ""); #endif diff --git a/test/logical.cxx b/test/logical.cxx index 08c02164..4013d39a 100644 --- a/test/logical.cxx +++ b/test/logical.cxx @@ -13,99 +13,99 @@ # include # include "test.h" -BEGIN BOOST_PP_NOT(0) == 1 END -BEGIN BOOST_PP_NOT(2) == 0 END +static_assert(BOOST_PP_NOT(0) == 1, ""); +static_assert(BOOST_PP_NOT(2) == 0, ""); -BEGIN BOOST_PP_AND(0, 0) == 0 END -BEGIN BOOST_PP_AND(0, 3) == 0 END -BEGIN BOOST_PP_AND(4, 0) == 0 END -BEGIN BOOST_PP_AND(5, 6) == 1 END +static_assert(BOOST_PP_AND(0, 0) == 0, ""); +static_assert(BOOST_PP_AND(0, 3) == 0, ""); +static_assert(BOOST_PP_AND(4, 0) == 0, ""); +static_assert(BOOST_PP_AND(5, 6) == 1, ""); -BEGIN BOOST_PP_OR(0, 0) == 0 END -BEGIN BOOST_PP_OR(0, 7) == 1 END -BEGIN BOOST_PP_OR(8, 0) == 1 END -BEGIN BOOST_PP_OR(9, 1) == 1 END +static_assert(BOOST_PP_OR(0, 0) == 0, ""); +static_assert(BOOST_PP_OR(0, 7) == 1, ""); +static_assert(BOOST_PP_OR(8, 0) == 1, ""); +static_assert(BOOST_PP_OR(9, 1) == 1, ""); -BEGIN BOOST_PP_XOR(0, 0) == 0 END -BEGIN BOOST_PP_XOR(0, 2) == 1 END -BEGIN BOOST_PP_XOR(3, 0) == 1 END -BEGIN BOOST_PP_XOR(4, 5) == 0 END +static_assert(BOOST_PP_XOR(0, 0) == 0, ""); +static_assert(BOOST_PP_XOR(0, 2) == 1, ""); +static_assert(BOOST_PP_XOR(3, 0) == 1, ""); +static_assert(BOOST_PP_XOR(4, 5) == 0, ""); -BEGIN BOOST_PP_NOR(0, 0) == 1 END -BEGIN BOOST_PP_NOR(0, 6) == 0 END -BEGIN BOOST_PP_NOR(7, 0) == 0 END -BEGIN BOOST_PP_NOR(8, 9) == 0 END +static_assert(BOOST_PP_NOR(0, 0) == 1, ""); +static_assert(BOOST_PP_NOR(0, 6) == 0, ""); +static_assert(BOOST_PP_NOR(7, 0) == 0, ""); +static_assert(BOOST_PP_NOR(8, 9) == 0, ""); -BEGIN BOOST_PP_BOOL(22) == 1 END -BEGIN BOOST_PP_BOOL(0) == 0 END +static_assert(BOOST_PP_BOOL(22) == 1, ""); +static_assert(BOOST_PP_BOOL(0) == 0, ""); #if BOOST_PP_LIMIT_MAG == 512 -BEGIN BOOST_PP_NOT(283) == 0 END +static_assert(BOOST_PP_NOT(283) == 0, ""); -BEGIN BOOST_PP_AND(0, 505) == 0 END -BEGIN BOOST_PP_AND(376, 0) == 0 END -BEGIN BOOST_PP_AND(482, 139) == 1 END +static_assert(BOOST_PP_AND(0, 505) == 0, ""); +static_assert(BOOST_PP_AND(376, 0) == 0, ""); +static_assert(BOOST_PP_AND(482, 139) == 1, ""); -BEGIN BOOST_PP_OR(0, 274) == 1 END -BEGIN BOOST_PP_OR(512, 0) == 1 END -BEGIN BOOST_PP_OR(23, 386) == 1 END +static_assert(BOOST_PP_OR(0, 274) == 1, ""); +static_assert(BOOST_PP_OR(512, 0) == 1, ""); +static_assert(BOOST_PP_OR(23, 386) == 1, ""); -BEGIN BOOST_PP_XOR(0, 494) == 1 END -BEGIN BOOST_PP_XOR(391, 0) == 1 END -BEGIN BOOST_PP_XOR(260, 438) == 0 END +static_assert(BOOST_PP_XOR(0, 494) == 1, ""); +static_assert(BOOST_PP_XOR(391, 0) == 1, ""); +static_assert(BOOST_PP_XOR(260, 438) == 0, ""); -BEGIN BOOST_PP_NOR(0, 455) == 0 END -BEGIN BOOST_PP_NOR(338, 0) == 0 END -BEGIN BOOST_PP_NOR(267, 504) == 0 END +static_assert(BOOST_PP_NOR(0, 455) == 0, ""); +static_assert(BOOST_PP_NOR(338, 0) == 0, ""); +static_assert(BOOST_PP_NOR(267, 504) == 0, ""); -BEGIN BOOST_PP_BOOL(378) == 1 END +static_assert(BOOST_PP_BOOL(378) == 1, ""); #endif #if BOOST_PP_LIMIT_MAG == 1024 -BEGIN BOOST_PP_NOT(946) == 0 END +static_assert(BOOST_PP_NOT(946) == 0, ""); -BEGIN BOOST_PP_AND(0, 1002) == 0 END -BEGIN BOOST_PP_AND(628, 0) == 0 END -BEGIN BOOST_PP_AND(741, 110) == 1 END +static_assert(BOOST_PP_AND(0, 1002) == 0, ""); +static_assert(BOOST_PP_AND(628, 0) == 0, ""); +static_assert(BOOST_PP_AND(741, 110) == 1, ""); -BEGIN BOOST_PP_OR(0, 893) == 1 END -BEGIN BOOST_PP_OR(1024, 0) == 1 END -BEGIN BOOST_PP_OR(23, 730) == 1 END +static_assert(BOOST_PP_OR(0, 893) == 1, ""); +static_assert(BOOST_PP_OR(1024, 0) == 1, ""); +static_assert(BOOST_PP_OR(23, 730) == 1, ""); -BEGIN BOOST_PP_XOR(0, 942) == 1 END -BEGIN BOOST_PP_XOR(641, 0) == 1 END -BEGIN BOOST_PP_XOR(783, 869) == 0 END +static_assert(BOOST_PP_XOR(0, 942) == 1, ""); +static_assert(BOOST_PP_XOR(641, 0) == 1, ""); +static_assert(BOOST_PP_XOR(783, 869) == 0, ""); -BEGIN BOOST_PP_NOR(0, 515) == 0 END -BEGIN BOOST_PP_NOR(739, 0) == 0 END -BEGIN BOOST_PP_NOR(1024, 983) == 0 END +static_assert(BOOST_PP_NOR(0, 515) == 0, ""); +static_assert(BOOST_PP_NOR(739, 0) == 0, ""); +static_assert(BOOST_PP_NOR(1024, 983) == 0, ""); -BEGIN BOOST_PP_BOOL(577) == 1 END +static_assert(BOOST_PP_BOOL(577) == 1, ""); #endif -BEGIN BOOST_PP_BITAND(0, 0) == 0 END -BEGIN BOOST_PP_BITAND(0, 1) == 0 END -BEGIN BOOST_PP_BITAND(1, 0) == 0 END -BEGIN BOOST_PP_BITAND(1, 1) == 1 END +static_assert(BOOST_PP_BITAND(0, 0) == 0, ""); +static_assert(BOOST_PP_BITAND(0, 1) == 0, ""); +static_assert(BOOST_PP_BITAND(1, 0) == 0, ""); +static_assert(BOOST_PP_BITAND(1, 1) == 1, ""); -BEGIN BOOST_PP_BITNOR(0, 0) == 1 END -BEGIN BOOST_PP_BITNOR(0, 1) == 0 END -BEGIN BOOST_PP_BITNOR(1, 0) == 0 END -BEGIN BOOST_PP_BITNOR(1, 1) == 0 END +static_assert(BOOST_PP_BITNOR(0, 0) == 1, ""); +static_assert(BOOST_PP_BITNOR(0, 1) == 0, ""); +static_assert(BOOST_PP_BITNOR(1, 0) == 0, ""); +static_assert(BOOST_PP_BITNOR(1, 1) == 0, ""); -BEGIN BOOST_PP_BITOR(0, 0) == 0 END -BEGIN BOOST_PP_BITOR(0, 1) == 1 END -BEGIN BOOST_PP_BITOR(1, 0) == 1 END -BEGIN BOOST_PP_BITOR(1, 1) == 1 END +static_assert(BOOST_PP_BITOR(0, 0) == 0, ""); +static_assert(BOOST_PP_BITOR(0, 1) == 1, ""); +static_assert(BOOST_PP_BITOR(1, 0) == 1, ""); +static_assert(BOOST_PP_BITOR(1, 1) == 1, ""); -BEGIN BOOST_PP_BITXOR(0, 0) == 0 END -BEGIN BOOST_PP_BITXOR(0, 1) == 1 END -BEGIN BOOST_PP_BITXOR(1, 0) == 1 END -BEGIN BOOST_PP_BITXOR(1, 1) == 0 END +static_assert(BOOST_PP_BITXOR(0, 0) == 0, ""); +static_assert(BOOST_PP_BITXOR(0, 1) == 1, ""); +static_assert(BOOST_PP_BITXOR(1, 0) == 1, ""); +static_assert(BOOST_PP_BITXOR(1, 1) == 0, ""); -BEGIN BOOST_PP_COMPL(0) == 1 END -BEGIN BOOST_PP_COMPL(1) == 0 END +static_assert(BOOST_PP_COMPL(0) == 1, ""); +static_assert(BOOST_PP_COMPL(1) == 0, ""); diff --git a/test/punctuation.cxx b/test/punctuation.cxx index ea198f5c..27de3b6b 100644 --- a/test/punctuation.cxx +++ b/test/punctuation.cxx @@ -29,22 +29,22 @@ // is_begin_parens -BEGIN BOOST_PP_IS_BEGIN_PARENS() == 0 END -BEGIN BOOST_PP_IS_BEGIN_PARENS(A_TUPLE) == 1 END -BEGIN BOOST_PP_IS_BEGIN_PARENS(A_TUPLE2) == 1 END -BEGIN BOOST_PP_IS_BEGIN_PARENS(A_TUPLE_PLUS) == 1 END -BEGIN BOOST_PP_IS_BEGIN_PARENS(PLUS_ATUPLE) == 0 END -BEGIN BOOST_PP_IS_BEGIN_PARENS(JDATA) == 0 END -BEGIN BOOST_PP_IS_BEGIN_PARENS(NOT_TUPLE) == 0 END -BEGIN BOOST_PP_IS_BEGIN_PARENS(NOT_TUPLE2) == 0 END -BEGIN BOOST_PP_IS_BEGIN_PARENS(A_SEQ) == 1 END -BEGIN BOOST_PP_IS_BEGIN_PARENS(AN_ARRAY) == 1 END -BEGIN BOOST_PP_IS_BEGIN_PARENS(A_LIST) == 1 END -BEGIN BOOST_PP_IS_BEGIN_PARENS((y)2(x)) == 1 END +static_assert(BOOST_PP_IS_BEGIN_PARENS() == 0, ""); +static_assert(BOOST_PP_IS_BEGIN_PARENS(A_TUPLE) == 1, ""); +static_assert(BOOST_PP_IS_BEGIN_PARENS(A_TUPLE2) == 1, ""); +static_assert(BOOST_PP_IS_BEGIN_PARENS(A_TUPLE_PLUS) == 1, ""); +static_assert(BOOST_PP_IS_BEGIN_PARENS(PLUS_ATUPLE) == 0, ""); +static_assert(BOOST_PP_IS_BEGIN_PARENS(JDATA) == 0, ""); +static_assert(BOOST_PP_IS_BEGIN_PARENS(NOT_TUPLE) == 0, ""); +static_assert(BOOST_PP_IS_BEGIN_PARENS(NOT_TUPLE2) == 0, ""); +static_assert(BOOST_PP_IS_BEGIN_PARENS(A_SEQ) == 1, ""); +static_assert(BOOST_PP_IS_BEGIN_PARENS(AN_ARRAY) == 1, ""); +static_assert(BOOST_PP_IS_BEGIN_PARENS(A_LIST) == 1, ""); +static_assert(BOOST_PP_IS_BEGIN_PARENS((y)2(x)) == 1, ""); // remove_parens -BEGIN BOOST_PP_REMOVE_PARENS(DATA) == 17 END -BEGIN BOOST_PP_REMOVE_PARENS(DATA2)== 32 END -BEGIN BOOST_PP_REMOVE_PARENS(DATA3)== 96 END -BEGIN BOOST_PP_REMOVE_PARENS(DATA4)== 41 END +static_assert(BOOST_PP_REMOVE_PARENS(DATA) == 17, ""); +static_assert(BOOST_PP_REMOVE_PARENS(DATA2)== 32, ""); +static_assert(BOOST_PP_REMOVE_PARENS(DATA3)== 96, ""); +static_assert(BOOST_PP_REMOVE_PARENS(DATA4)== 41, ""); diff --git a/test/quick.cpp b/test/quick.cpp index 56e7c28a..d6c1f7d2 100644 --- a/test/quick.cpp +++ b/test/quick.cpp @@ -4,39 +4,38 @@ // https://www.boost.org/LICENSE_1_0.txt #include -# include "test_macro.h" /* equality */ -BEGIN BOOST_PP_EQUAL(2, 0) == 0 END -BEGIN BOOST_PP_EQUAL(2, 2) == 1 END +static_assert(BOOST_PP_EQUAL(2, 0) == 0, ""); +static_assert(BOOST_PP_EQUAL(2, 2) == 1, ""); /* inequality */ -BEGIN BOOST_PP_NOT_EQUAL(2, 0) == 1 END -BEGIN BOOST_PP_NOT_EQUAL(2, 2) == 0 END +static_assert(BOOST_PP_NOT_EQUAL(2, 0) == 1, ""); +static_assert(BOOST_PP_NOT_EQUAL(2, 2) == 0, ""); /* less */ -BEGIN BOOST_PP_LESS(2, 1) == 0 END -BEGIN BOOST_PP_LESS(1, 2) == 1 END +static_assert(BOOST_PP_LESS(2, 1) == 0, ""); +static_assert(BOOST_PP_LESS(1, 2) == 1, ""); /* less_equal */ -BEGIN BOOST_PP_LESS_EQUAL(2, 1) == 0 END -BEGIN BOOST_PP_LESS_EQUAL(1, 2) == 1 END -BEGIN BOOST_PP_LESS_EQUAL(2, 2) == 1 END +static_assert(BOOST_PP_LESS_EQUAL(2, 1) == 0, ""); +static_assert(BOOST_PP_LESS_EQUAL(1, 2) == 1, ""); +static_assert(BOOST_PP_LESS_EQUAL(2, 2) == 1, ""); /* greater */ -BEGIN BOOST_PP_GREATER(2, 1) == 1 END -BEGIN BOOST_PP_GREATER(1, 2) == 0 END +static_assert(BOOST_PP_GREATER(2, 1) == 1, ""); +static_assert(BOOST_PP_GREATER(1, 2) == 0, ""); /* greater_equal */ -BEGIN BOOST_PP_GREATER_EQUAL(2, 1) == 1 END -BEGIN BOOST_PP_GREATER_EQUAL(1, 2) == 0 END -BEGIN BOOST_PP_GREATER_EQUAL(2, 2) == 1 END +static_assert(BOOST_PP_GREATER_EQUAL(2, 1) == 1, ""); +static_assert(BOOST_PP_GREATER_EQUAL(1, 2) == 0, ""); +static_assert(BOOST_PP_GREATER_EQUAL(2, 2) == 1, ""); int main() { diff --git a/test/repetition.cpp b/test/repetition.cpp index 4147878e..4dfdd945 100644 --- a/test/repetition.cpp +++ b/test/repetition.cpp @@ -44,7 +44,7 @@ TEST(MAX) template struct no_rescan; # define F1(z, n, p) p n -BEGIN 1 + (4+5+6) BOOST_PP_REPEAT_FROM_TO(4, 7, F1, -) END +static_assert(1 + (4+5+6) BOOST_PP_REPEAT_FROM_TO(4, 7, F1, -), ""); # if BOOST_PP_LIMIT_REPEAT == 512 diff --git a/test/selection.cxx b/test/selection.cxx index 720a7768..f51ebbc2 100644 --- a/test/selection.cxx +++ b/test/selection.cxx @@ -13,34 +13,34 @@ # include # include "test.h" -BEGIN BOOST_PP_MAX(2, 2) == 2 END -BEGIN BOOST_PP_MAX(2, 1) == 2 END -BEGIN BOOST_PP_MAX(1, 2) == 2 END +static_assert(BOOST_PP_MAX(2, 2) == 2, ""); +static_assert(BOOST_PP_MAX(2, 1) == 2, ""); +static_assert(BOOST_PP_MAX(1, 2) == 2, ""); -BEGIN BOOST_PP_MIN(2, 2) == 2 END -BEGIN BOOST_PP_MIN(2, 1) == 1 END -BEGIN BOOST_PP_MIN(1, 2) == 1 END +static_assert(BOOST_PP_MIN(2, 2) == 2, ""); +static_assert(BOOST_PP_MIN(2, 1) == 1, ""); +static_assert(BOOST_PP_MIN(1, 2) == 1, ""); # if BOOST_PP_LIMIT_MAG == 512 -BEGIN BOOST_PP_MAX(438, 438) == 438 END -BEGIN BOOST_PP_MAX(371, 289) == 371 END -BEGIN BOOST_PP_MAX(390, 468) == 468 END +static_assert(BOOST_PP_MAX(438, 438) == 438, ""); +static_assert(BOOST_PP_MAX(371, 289) == 371, ""); +static_assert(BOOST_PP_MAX(390, 468) == 468, ""); -BEGIN BOOST_PP_MIN(391, 391) == 391 END -BEGIN BOOST_PP_MIN(425, 274) == 274 END -BEGIN BOOST_PP_MIN(410, 503) == 410 END +static_assert(BOOST_PP_MIN(391, 391) == 391, ""); +static_assert(BOOST_PP_MIN(425, 274) == 274, ""); +static_assert(BOOST_PP_MIN(410, 503) == 410, ""); # endif # if BOOST_PP_LIMIT_MAG == 1024 -BEGIN BOOST_PP_MAX(892, 892) == 892 END -BEGIN BOOST_PP_MAX(967, 640) == 967 END -BEGIN BOOST_PP_MAX(583, 745) == 745 END +static_assert(BOOST_PP_MAX(892, 892) == 892, ""); +static_assert(BOOST_PP_MAX(967, 640) == 967, ""); +static_assert(BOOST_PP_MAX(583, 745) == 745, ""); -BEGIN BOOST_PP_MIN(837, 837) == 837 END -BEGIN BOOST_PP_MIN(646, 583) == 583 END -BEGIN BOOST_PP_MIN(782, 826) == 782 END +static_assert(BOOST_PP_MIN(837, 837) == 837, ""); +static_assert(BOOST_PP_MIN(646, 583) == 583, ""); +static_assert(BOOST_PP_MIN(782, 826) == 782, ""); # endif diff --git a/test/seq.cxx b/test/seq.cxx index 26291a71..a9e47834 100644 --- a/test/seq.cxx +++ b/test/seq.cxx @@ -263,111 +263,111 @@ # define ADD_S(s, x, y) BOOST_PP_ADD(x, y) # define CAT_S(s, x, y) BOOST_PP_CAT(x, BOOST_PP_IS_EMPTY(y)) -BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_SEQ_HEAD(SEQ_NONE)) == 1 END -BEGIN BOOST_PP_SEQ_HEAD(SEQ) == 4 END -BEGIN BOOST_PP_SEQ_HEAD(SEQ_255) == 1 END -BEGIN BOOST_PP_SEQ_HEAD(SEQ_256) == 1 END +static_assert(BOOST_PP_IS_EMPTY(BOOST_PP_SEQ_HEAD(SEQ_NONE)) == 1, ""); +static_assert(BOOST_PP_SEQ_HEAD(SEQ) == 4, ""); +static_assert(BOOST_PP_SEQ_HEAD(SEQ_255) == 1, ""); +static_assert(BOOST_PP_SEQ_HEAD(SEQ_256) == 1, ""); # if BOOST_PP_LIMIT_SEQ == 512 -BEGIN BOOST_PP_SEQ_HEAD(SEQ_511) == 1 END -BEGIN BOOST_PP_SEQ_HEAD(SEQ_512) == 1 END +static_assert(BOOST_PP_SEQ_HEAD(SEQ_511) == 1, ""); +static_assert(BOOST_PP_SEQ_HEAD(SEQ_512) == 1, ""); # endif # if BOOST_PP_LIMIT_SEQ == 1024 -BEGIN BOOST_PP_SEQ_HEAD(SEQ_1023) == 1 END -BEGIN BOOST_PP_SEQ_HEAD(SEQ_1024) == 1 END +static_assert(BOOST_PP_SEQ_HEAD(SEQ_1023) == 1, ""); +static_assert(BOOST_PP_SEQ_HEAD(SEQ_1024) == 1, ""); # endif -BEGIN BOOST_PP_SEQ_FOLD_LEFT(CAT_S, 1, SEQ_NONE) == 11 END -BEGIN BOOST_PP_SEQ_FOLD_LEFT(SUB_S, 22, SEQ) == 10 END -BEGIN BOOST_PP_SEQ_FOLD_RIGHT(CAT_S, 2, SEQ_NONE) == 21 END -BEGIN BOOST_PP_SEQ_FOLD_RIGHT(ADD_S, 0, SEQ) == 12 END -BEGIN BOOST_PP_SEQ_FOLD_RIGHT(REVERSAL, 0, SEQ) == 4 END +static_assert(BOOST_PP_SEQ_FOLD_LEFT(CAT_S, 1, SEQ_NONE) == 11, ""); +static_assert(BOOST_PP_SEQ_FOLD_LEFT(SUB_S, 22, SEQ) == 10, ""); +static_assert(BOOST_PP_SEQ_FOLD_RIGHT(CAT_S, 2, SEQ_NONE) == 21, ""); +static_assert(BOOST_PP_SEQ_FOLD_RIGHT(ADD_S, 0, SEQ) == 12, ""); +static_assert(BOOST_PP_SEQ_FOLD_RIGHT(REVERSAL, 0, SEQ) == 4, ""); -BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_REVERSE(SEQ_NONE))) == 1 END -BEGIN BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_REVERSE(SEQ)) == 2514 END +static_assert(BOOST_PP_IS_EMPTY(BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_REVERSE(SEQ_NONE))) == 1, ""); +static_assert(BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_REVERSE(SEQ)) == 2514, ""); # if BOOST_PP_LIMIT_SEQ == 512 -BEGIN BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(SEQ_512)) == 512 END +static_assert(BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(SEQ_512)) == 512, ""); #endif # if BOOST_PP_LIMIT_SEQ == 1024 -BEGIN BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(SEQ_1024)) == 1024 END +static_assert(BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(SEQ_1024)) == 1024, ""); #endif -BEGIN BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_REST_N(2, SEQ)) == 52 END -BEGIN BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_REST_N(99, SEQ_100)) == 100 END -BEGIN BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_REST_N(255, SEQ_256)) == 256 END +static_assert(BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_REST_N(2, SEQ)) == 52, ""); +static_assert(BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_REST_N(99, SEQ_100)) == 100, ""); +static_assert(BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_REST_N(255, SEQ_256)) == 256, ""); # if BOOST_PP_LIMIT_SEQ == 512 -BEGIN BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REST_N(509, SEQ_511)) == 510 END +static_assert(BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REST_N(509, SEQ_511)) == 510, ""); #endif # if BOOST_PP_LIMIT_SEQ == 1024 -BEGIN BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REST_N(1020, SEQ_1023)) == 1021 END +static_assert(BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REST_N(1020, SEQ_1023)) == 1021, ""); #endif -BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_FIRST_N(1, SEQ_NONE))) == 1 END -BEGIN BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_FIRST_N(2, SEQ)) == 41 END -BEGIN BOOST_PP_SEQ_ELEM(50,BOOST_PP_SEQ_FIRST_N(100, SEQ_100)) == 51 END -BEGIN BOOST_PP_SEQ_ELEM(100,BOOST_PP_SEQ_FIRST_N(255, SEQ_255)) == 101 END -BEGIN BOOST_PP_SEQ_ELEM(200,BOOST_PP_SEQ_FIRST_N(256, SEQ_256)) == 201 END +static_assert(BOOST_PP_IS_EMPTY(BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_FIRST_N(1, SEQ_NONE))) == 1, ""); +static_assert(BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_FIRST_N(2, SEQ)) == 41, ""); +static_assert(BOOST_PP_SEQ_ELEM(50,BOOST_PP_SEQ_FIRST_N(100, SEQ_100)) == 51, ""); +static_assert(BOOST_PP_SEQ_ELEM(100,BOOST_PP_SEQ_FIRST_N(255, SEQ_255)) == 101, ""); +static_assert(BOOST_PP_SEQ_ELEM(200,BOOST_PP_SEQ_FIRST_N(256, SEQ_256)) == 201, ""); # if BOOST_PP_LIMIT_SEQ == 512 -BEGIN BOOST_PP_SEQ_ELEM(7,BOOST_PP_SEQ_FIRST_N(15, SEQ_512)) == 8 END +static_assert(BOOST_PP_SEQ_ELEM(7,BOOST_PP_SEQ_FIRST_N(15, SEQ_512)) == 8, ""); #endif # if BOOST_PP_LIMIT_SEQ == 1024 -BEGIN BOOST_PP_SEQ_ELEM(14,BOOST_PP_SEQ_FIRST_N(25, SEQ_1024)) == 15 END +static_assert(BOOST_PP_SEQ_ELEM(14,BOOST_PP_SEQ_FIRST_N(25, SEQ_1024)) == 15, ""); #endif -BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_SEQ_ELEM(0, SEQ_NONE)) == 1 END -BEGIN BOOST_PP_SEQ_SIZE(SEQ_NONE) == 1 END -BEGIN BOOST_PP_SEQ_ELEM(2, SEQ) == 5 END -BEGIN BOOST_PP_SEQ_ELEM(20, SEQ_255) == 21 END -BEGIN BOOST_PP_SEQ_ELEM(254, SEQ_255) == 255 END -BEGIN BOOST_PP_SEQ_ELEM(220, SEQ_256) == 221 END -BEGIN BOOST_PP_SEQ_ELEM(255, SEQ_256) == 256 END -BEGIN BOOST_PP_SEQ_SIZE(SEQ) == 4 END +static_assert(BOOST_PP_IS_EMPTY(BOOST_PP_SEQ_ELEM(0, SEQ_NONE)) == 1, ""); +static_assert(BOOST_PP_SEQ_SIZE(SEQ_NONE) == 1, ""); +static_assert(BOOST_PP_SEQ_ELEM(2, SEQ) == 5, ""); +static_assert(BOOST_PP_SEQ_ELEM(20, SEQ_255) == 21, ""); +static_assert(BOOST_PP_SEQ_ELEM(254, SEQ_255) == 255, ""); +static_assert(BOOST_PP_SEQ_ELEM(220, SEQ_256) == 221, ""); +static_assert(BOOST_PP_SEQ_ELEM(255, SEQ_256) == 256, ""); +static_assert(BOOST_PP_SEQ_SIZE(SEQ) == 4, ""); # if BOOST_PP_LIMIT_SEQ == 512 -BEGIN BOOST_PP_SEQ_SIZE(SEQ_511) == 511 END -BEGIN BOOST_PP_SEQ_ELEM(476, SEQ_512) == 477 END +static_assert(BOOST_PP_SEQ_SIZE(SEQ_511) == 511, ""); +static_assert(BOOST_PP_SEQ_ELEM(476, SEQ_512) == 477, ""); #endif # if BOOST_PP_LIMIT_SEQ == 1024 -BEGIN BOOST_PP_SEQ_SIZE(SEQ_1023) == 1023 END -BEGIN BOOST_PP_SEQ_ELEM(934, SEQ_1024) == 935 END +static_assert(BOOST_PP_SEQ_SIZE(SEQ_1023) == 1023, ""); +static_assert(BOOST_PP_SEQ_ELEM(934, SEQ_1024) == 935, ""); #endif -BEGIN BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_TRANSFORM(CAT_S, 13, SEQ_NONE)) == 131 END -BEGIN BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_TRANSFORM(ADD_S, 2, SEQ)) == 6374 END +static_assert(BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_TRANSFORM(CAT_S, 13, SEQ_NONE)) == 131, ""); +static_assert(BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_TRANSFORM(ADD_S, 2, SEQ)) == 6374, ""); # if BOOST_PP_LIMIT_SEQ == 512 #define STRANS_512(s,data,elem) BOOST_PP_ADD(elem,data) -BEGIN BOOST_PP_SEQ_ELEM(383, BOOST_PP_SEQ_TRANSFORM(STRANS_512,2,SEQ_512)) == 386 END +static_assert(BOOST_PP_SEQ_ELEM(383, BOOST_PP_SEQ_TRANSFORM(STRANS_512,2,SEQ_512)) == 386, ""); #endif @@ -375,34 +375,34 @@ BEGIN BOOST_PP_SEQ_ELEM(383, BOOST_PP_SEQ_TRANSFORM(STRANS_512,2,SEQ_512)) == 38 #define STRANS_1024(s,data,elem) BOOST_PP_ADD(elem,data) -BEGIN BOOST_PP_SEQ_ELEM(728, BOOST_PP_SEQ_TRANSFORM(STRANS_1024,1,SEQ_1024)) == 730 END +static_assert(BOOST_PP_SEQ_ELEM(728, BOOST_PP_SEQ_TRANSFORM(STRANS_1024,1,SEQ_1024)) == 730, ""); #endif -BEGIN BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_TAIL(SEQ) SEQ) == 1524152 END +static_assert(BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_TAIL(SEQ) SEQ) == 1524152, ""); # if BOOST_PP_LIMIT_SEQ == 512 -BEGIN BOOST_PP_SEQ_ELEM(459, BOOST_PP_SEQ_TAIL(SEQ_511)) == 461 END +static_assert(BOOST_PP_SEQ_ELEM(459, BOOST_PP_SEQ_TAIL(SEQ_511)) == 461, ""); #endif # if BOOST_PP_LIMIT_SEQ == 1024 -BEGIN BOOST_PP_SEQ_ELEM(624, BOOST_PP_SEQ_TAIL(SEQ_1023)) == 626 END +static_assert(BOOST_PP_SEQ_ELEM(624, BOOST_PP_SEQ_TAIL(SEQ_1023)) == 626, ""); #endif # define F1(r, state, x) + x + state # define FI2(r, state, i, x) BOOST_PP_IIF(BOOST_PP_EQUAL(i,2),+ x + x + state,+ x + state) -BEGIN BOOST_PP_SEQ_FOR_EACH(F1, 1, SEQ) == 16 END -BEGIN BOOST_PP_SEQ_FOR_EACH_I(FI2, 1, SEQ) == 21 END +static_assert(BOOST_PP_SEQ_FOR_EACH(F1, 1, SEQ) == 16, ""); +static_assert(BOOST_PP_SEQ_FOR_EACH_I(FI2, 1, SEQ) == 21, ""); # if BOOST_PP_LIMIT_SEQ == 512 && BOOST_PP_LIMIT_FOR == 512 # define FE5I2(r, state, i, x) BOOST_PP_EXPR_IIF(BOOST_PP_LESS(i,5),+ x - state) -BEGIN BOOST_PP_SEQ_FOR_EACH_I(FE5I2, 1, SEQ_512) == 10 END +static_assert(BOOST_PP_SEQ_FOR_EACH_I(FE5I2, 1, SEQ_512) == 10, ""); #endif @@ -410,23 +410,23 @@ BEGIN BOOST_PP_SEQ_FOR_EACH_I(FE5I2, 1, SEQ_512) == 10 END # define FE1024(r, state, i, x) BOOST_PP_EXPR_IIF(BOOST_PP_LESS(i,6),+ x - state) -BEGIN BOOST_PP_SEQ_FOR_EACH_I(FE1024, 2, SEQ_1024) == 9 END +static_assert(BOOST_PP_SEQ_FOR_EACH_I(FE1024, 2, SEQ_1024) == 9, ""); #endif -BEGIN BOOST_PP_TUPLE_ELEM(4, 3, BOOST_PP_SEQ_TO_TUPLE(SEQ)) == 2 END -BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_TUPLE_ELEM(1, 0, BOOST_PP_SEQ_TO_TUPLE(SEQ_NONE))) == 1 END -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_SEQ_TO_TUPLE(SEQ_NONE)) == 1 END -BEGIN BOOST_PP_ARRAY_ELEM(3, BOOST_PP_SEQ_TO_ARRAY(SEQ)) == 2 END +static_assert(BOOST_PP_TUPLE_ELEM(4, 3, BOOST_PP_SEQ_TO_TUPLE(SEQ)) == 2, ""); +static_assert(BOOST_PP_IS_EMPTY(BOOST_PP_TUPLE_ELEM(1, 0, BOOST_PP_SEQ_TO_TUPLE(SEQ_NONE))) == 1, ""); +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_SEQ_TO_TUPLE(SEQ_NONE)) == 1, ""); +static_assert(BOOST_PP_ARRAY_ELEM(3, BOOST_PP_SEQ_TO_ARRAY(SEQ)) == 2, ""); -BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_ARRAY_ELEM(0, BOOST_PP_SEQ_TO_ARRAY(SEQ_NONE))) == 1 END -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_SEQ_TO_ARRAY(SEQ_NONE)) == 1 END +static_assert(BOOST_PP_IS_EMPTY(BOOST_PP_ARRAY_ELEM(0, BOOST_PP_SEQ_TO_ARRAY(SEQ_NONE))) == 1, ""); +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_SEQ_TO_ARRAY(SEQ_NONE)) == 1, ""); # define LESS_S(s, x, y) BOOST_PP_LESS(x, y) # define FILTER_MOD_S(s, data, elem) BOOST_PP_NOT(BOOST_PP_MOD(elem,data)) -BEGIN BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_FILTER(LESS_S, 3, SEQ)) == 45 END -BEGIN BOOST_PP_SEQ_ELEM(4,BOOST_PP_SEQ_FILTER(FILTER_MOD_S, 20, SEQ_100)) == 100 END -BEGIN BOOST_PP_SEQ_ELEM(2,BOOST_PP_SEQ_FILTER(FILTER_MOD_S, 30, SEQ_100)) == 90 END +static_assert(BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_FILTER(LESS_S, 3, SEQ)) == 45, ""); +static_assert(BOOST_PP_SEQ_ELEM(4,BOOST_PP_SEQ_FILTER(FILTER_MOD_S, 20, SEQ_100)) == 100, ""); +static_assert(BOOST_PP_SEQ_ELEM(2,BOOST_PP_SEQ_FILTER(FILTER_MOD_S, 30, SEQ_100)) == 90, ""); # if BOOST_PP_LIMIT_SEQ == 512 @@ -438,7 +438,7 @@ BEGIN BOOST_PP_SEQ_ELEM(2,BOOST_PP_SEQ_FILTER(FILTER_MOD_S, 30, SEQ_100)) == 90 ) \ /* */ -BEGIN BOOST_PP_SEQ_ELEM(1,BOOST_PP_SEQ_FILTER(FILTER_EQ_512_S, 20, SEQ_512)) == 21 END +static_assert(BOOST_PP_SEQ_ELEM(1,BOOST_PP_SEQ_FILTER(FILTER_EQ_512_S, 20, SEQ_512)) == 21, ""); #endif @@ -452,173 +452,173 @@ BEGIN BOOST_PP_SEQ_ELEM(1,BOOST_PP_SEQ_FILTER(FILTER_EQ_512_S, 20, SEQ_512)) == ) \ /* */ -BEGIN BOOST_PP_SEQ_ELEM(0,BOOST_PP_SEQ_FILTER(FILTER_EQ_1024_S, 100, SEQ_1024)) == 99 END +static_assert(BOOST_PP_SEQ_ELEM(0,BOOST_PP_SEQ_FILTER(FILTER_EQ_1024_S, 100, SEQ_1024)) == 99, ""); #endif -BEGIN BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_INSERT(SEQ_NONE, 0, 7)) == 7 END -BEGIN BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_INSERT(SEQ, 0, 3)) == 34152 END -BEGIN BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_INSERT(SEQ, 2, 3)) == 41352 END -BEGIN BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_INSERT(SEQ, 4, 3)) == 41523 END -BEGIN BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_INSERT(SEQ_255, 0, 100)) == 256 END -BEGIN BOOST_PP_SEQ_ELEM(255,BOOST_PP_SEQ_INSERT(SEQ_255, 0, 100)) == 255 END -BEGIN BOOST_PP_SEQ_ELEM(0,BOOST_PP_SEQ_INSERT(SEQ_255, 0, 113)) == 113 END +static_assert(BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_INSERT(SEQ_NONE, 0, 7)) == 7, ""); +static_assert(BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_INSERT(SEQ, 0, 3)) == 34152, ""); +static_assert(BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_INSERT(SEQ, 2, 3)) == 41352, ""); +static_assert(BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_INSERT(SEQ, 4, 3)) == 41523, ""); +static_assert(BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_INSERT(SEQ_255, 0, 100)) == 256, ""); +static_assert(BOOST_PP_SEQ_ELEM(255,BOOST_PP_SEQ_INSERT(SEQ_255, 0, 100)) == 255, ""); +static_assert(BOOST_PP_SEQ_ELEM(0,BOOST_PP_SEQ_INSERT(SEQ_255, 0, 113)) == 113, ""); # if BOOST_PP_LIMIT_SEQ == 512 -BEGIN BOOST_PP_SEQ_ELEM(511,BOOST_PP_SEQ_INSERT(SEQ_511, 0, 0)) == 511 END -BEGIN BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_INSERT(SEQ_511, 510, 431)) == 512 END +static_assert(BOOST_PP_SEQ_ELEM(511,BOOST_PP_SEQ_INSERT(SEQ_511, 0, 0)) == 511, ""); +static_assert(BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_INSERT(SEQ_511, 510, 431)) == 512, ""); #endif # if BOOST_PP_LIMIT_SEQ == 1024 -BEGIN BOOST_PP_SEQ_ELEM(1023,BOOST_PP_SEQ_INSERT(SEQ_1023, 0, 0)) == 1023 END -BEGIN BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_INSERT(SEQ_1023, 742, 29)) == 1024 END +static_assert(BOOST_PP_SEQ_ELEM(1023,BOOST_PP_SEQ_INSERT(SEQ_1023, 0, 0)) == 1023, ""); +static_assert(BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_INSERT(SEQ_1023, 742, 29)) == 1024, ""); #endif -BEGIN BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_POP_BACK(SEQ)) == 415 END -BEGIN BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_POP_BACK(SEQ_256)) == 255 END -BEGIN BOOST_PP_SEQ_ELEM(254,BOOST_PP_SEQ_POP_BACK(SEQ_256)) == 255 END -BEGIN BOOST_PP_SEQ_ELEM(100,BOOST_PP_SEQ_POP_BACK(SEQ_256)) == 101 END +static_assert(BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_POP_BACK(SEQ)) == 415, ""); +static_assert(BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_POP_BACK(SEQ_256)) == 255, ""); +static_assert(BOOST_PP_SEQ_ELEM(254,BOOST_PP_SEQ_POP_BACK(SEQ_256)) == 255, ""); +static_assert(BOOST_PP_SEQ_ELEM(100,BOOST_PP_SEQ_POP_BACK(SEQ_256)) == 101, ""); # if BOOST_PP_LIMIT_SEQ == 512 -BEGIN BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_POP_BACK(SEQ_512)) == 511 END -BEGIN BOOST_PP_SEQ_ELEM(437,BOOST_PP_SEQ_POP_BACK(SEQ_511)) == 438 END +static_assert(BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_POP_BACK(SEQ_512)) == 511, ""); +static_assert(BOOST_PP_SEQ_ELEM(437,BOOST_PP_SEQ_POP_BACK(SEQ_511)) == 438, ""); #endif # if BOOST_PP_LIMIT_SEQ == 1024 -BEGIN BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_POP_BACK(SEQ_1024)) == 1023 END -BEGIN BOOST_PP_SEQ_ELEM(632,BOOST_PP_SEQ_POP_BACK(SEQ_1023)) == 633 END +static_assert(BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_POP_BACK(SEQ_1024)) == 1023, ""); +static_assert(BOOST_PP_SEQ_ELEM(632,BOOST_PP_SEQ_POP_BACK(SEQ_1023)) == 633, ""); #endif -BEGIN BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_POP_FRONT(SEQ)) == 152 END -BEGIN BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_POP_FRONT(SEQ_256)) == 255 END -BEGIN BOOST_PP_SEQ_ELEM(0,BOOST_PP_SEQ_POP_FRONT(SEQ_256)) == 2 END -BEGIN BOOST_PP_SEQ_ELEM(254,BOOST_PP_SEQ_POP_FRONT(SEQ_256)) == 256 END +static_assert(BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_POP_FRONT(SEQ)) == 152, ""); +static_assert(BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_POP_FRONT(SEQ_256)) == 255, ""); +static_assert(BOOST_PP_SEQ_ELEM(0,BOOST_PP_SEQ_POP_FRONT(SEQ_256)) == 2, ""); +static_assert(BOOST_PP_SEQ_ELEM(254,BOOST_PP_SEQ_POP_FRONT(SEQ_256)) == 256, ""); # if BOOST_PP_LIMIT_SEQ == 512 -BEGIN BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_POP_FRONT(SEQ_512)) == 511 END -BEGIN BOOST_PP_SEQ_ELEM(347,BOOST_PP_SEQ_POP_FRONT(SEQ_512)) == 349 END +static_assert(BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_POP_FRONT(SEQ_512)) == 511, ""); +static_assert(BOOST_PP_SEQ_ELEM(347,BOOST_PP_SEQ_POP_FRONT(SEQ_512)) == 349, ""); #endif # if BOOST_PP_LIMIT_SEQ == 1024 -BEGIN BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_POP_FRONT(SEQ_1024)) == 1023 END -BEGIN BOOST_PP_SEQ_ELEM(875,BOOST_PP_SEQ_POP_FRONT(SEQ_1024)) == 877 END +static_assert(BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_POP_FRONT(SEQ_1024)) == 1023, ""); +static_assert(BOOST_PP_SEQ_ELEM(875,BOOST_PP_SEQ_POP_FRONT(SEQ_1024)) == 877, ""); #endif -BEGIN BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_PUSH_FRONT(SEQ_NONE, 145)) == 145 END -BEGIN BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_PUSH_FRONT(SEQ, 3)) == 34152 END -BEGIN BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_PUSH_FRONT(SEQ_255, 57)) == 256 END -BEGIN BOOST_PP_SEQ_ELEM(0,BOOST_PP_SEQ_PUSH_FRONT(SEQ_255, 222)) == 222 END -BEGIN BOOST_PP_SEQ_ELEM(255,BOOST_PP_SEQ_PUSH_FRONT(SEQ_255, 111)) == 255 END +static_assert(BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_PUSH_FRONT(SEQ_NONE, 145)) == 145, ""); +static_assert(BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_PUSH_FRONT(SEQ, 3)) == 34152, ""); +static_assert(BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_PUSH_FRONT(SEQ_255, 57)) == 256, ""); +static_assert(BOOST_PP_SEQ_ELEM(0,BOOST_PP_SEQ_PUSH_FRONT(SEQ_255, 222)) == 222, ""); +static_assert(BOOST_PP_SEQ_ELEM(255,BOOST_PP_SEQ_PUSH_FRONT(SEQ_255, 111)) == 255, ""); # if BOOST_PP_LIMIT_SEQ == 512 -BEGIN BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_PUSH_FRONT(SEQ_511, 0)) == 512 END -BEGIN BOOST_PP_SEQ_ELEM(391,BOOST_PP_SEQ_PUSH_FRONT(SEQ_511, 435)) == 391 END +static_assert(BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_PUSH_FRONT(SEQ_511, 0)) == 512, ""); +static_assert(BOOST_PP_SEQ_ELEM(391,BOOST_PP_SEQ_PUSH_FRONT(SEQ_511, 435)) == 391, ""); #endif # if BOOST_PP_LIMIT_SEQ == 1024 -BEGIN BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_PUSH_FRONT(SEQ_1023, 0)) == 1024 END -BEGIN BOOST_PP_SEQ_ELEM(961,BOOST_PP_SEQ_PUSH_FRONT(SEQ_1023, 435)) == 961 END +static_assert(BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_PUSH_FRONT(SEQ_1023, 0)) == 1024, ""); +static_assert(BOOST_PP_SEQ_ELEM(961,BOOST_PP_SEQ_PUSH_FRONT(SEQ_1023, 435)) == 961, ""); #endif -BEGIN BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_PUSH_BACK(SEQ_NONE, 79)) == 79 END -BEGIN BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_PUSH_BACK(SEQ, 3)) == 41523 END -BEGIN BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_PUSH_BACK(SEQ_255, 199)) == 256 END -BEGIN BOOST_PP_SEQ_ELEM(254,BOOST_PP_SEQ_PUSH_BACK(SEQ_255, 99)) == 255 END -BEGIN BOOST_PP_SEQ_ELEM(255,BOOST_PP_SEQ_PUSH_BACK(SEQ_255, 99)) == 99 END +static_assert(BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_PUSH_BACK(SEQ_NONE, 79)) == 79, ""); +static_assert(BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_PUSH_BACK(SEQ, 3)) == 41523, ""); +static_assert(BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_PUSH_BACK(SEQ_255, 199)) == 256, ""); +static_assert(BOOST_PP_SEQ_ELEM(254,BOOST_PP_SEQ_PUSH_BACK(SEQ_255, 99)) == 255, ""); +static_assert(BOOST_PP_SEQ_ELEM(255,BOOST_PP_SEQ_PUSH_BACK(SEQ_255, 99)) == 99, ""); # if BOOST_PP_LIMIT_SEQ == 512 -BEGIN BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_PUSH_BACK(SEQ_511, 275)) == 512 END -BEGIN BOOST_PP_SEQ_ELEM(473,BOOST_PP_SEQ_PUSH_BACK(SEQ_511, 78)) == 474 END -BEGIN BOOST_PP_SEQ_ELEM(511,BOOST_PP_SEQ_PUSH_BACK(SEQ_511, 78)) == 78 END +static_assert(BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_PUSH_BACK(SEQ_511, 275)) == 512, ""); +static_assert(BOOST_PP_SEQ_ELEM(473,BOOST_PP_SEQ_PUSH_BACK(SEQ_511, 78)) == 474, ""); +static_assert(BOOST_PP_SEQ_ELEM(511,BOOST_PP_SEQ_PUSH_BACK(SEQ_511, 78)) == 78, ""); #endif # if BOOST_PP_LIMIT_SEQ == 1024 -BEGIN BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_PUSH_BACK(SEQ_1023, 275)) == 1024 END -BEGIN BOOST_PP_SEQ_ELEM(846,BOOST_PP_SEQ_PUSH_BACK(SEQ_1023, 720)) == 847 END -BEGIN BOOST_PP_SEQ_ELEM(1023,BOOST_PP_SEQ_PUSH_BACK(SEQ_1023, 311)) == 311 END +static_assert(BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_PUSH_BACK(SEQ_1023, 275)) == 1024, ""); +static_assert(BOOST_PP_SEQ_ELEM(846,BOOST_PP_SEQ_PUSH_BACK(SEQ_1023, 720)) == 847, ""); +static_assert(BOOST_PP_SEQ_ELEM(1023,BOOST_PP_SEQ_PUSH_BACK(SEQ_1023, 311)) == 311, ""); #endif -BEGIN BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_REMOVE(SEQ, 0)) == 152 END -BEGIN BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_REMOVE(SEQ, 2)) == 412 END -BEGIN BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_REMOVE(SEQ, 3)) == 415 END +static_assert(BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_REMOVE(SEQ, 0)) == 152, ""); +static_assert(BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_REMOVE(SEQ, 2)) == 412, ""); +static_assert(BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_REMOVE(SEQ, 3)) == 415, ""); -BEGIN BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_REMOVE(SEQ_255, 254)) == 254 END -BEGIN BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_REMOVE(SEQ_256, 255)) == 255 END +static_assert(BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_REMOVE(SEQ_255, 254)) == 254, ""); +static_assert(BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_REMOVE(SEQ_256, 255)) == 255, ""); # if BOOST_PP_LIMIT_SEQ == 512 -BEGIN BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_REMOVE(SEQ_511, 429)) == 510 END -BEGIN BOOST_PP_SEQ_ELEM(462,BOOST_PP_SEQ_REMOVE(SEQ_512, 374)) == 464 END +static_assert(BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_REMOVE(SEQ_511, 429)) == 510, ""); +static_assert(BOOST_PP_SEQ_ELEM(462,BOOST_PP_SEQ_REMOVE(SEQ_512, 374)) == 464, ""); #endif # if BOOST_PP_LIMIT_SEQ == 1024 -BEGIN BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_REMOVE(SEQ_1023, 989)) == 1022 END -BEGIN BOOST_PP_SEQ_ELEM(731,BOOST_PP_SEQ_REMOVE(SEQ_1024, 555)) == 733 END +static_assert(BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_REMOVE(SEQ_1023, 989)) == 1022, ""); +static_assert(BOOST_PP_SEQ_ELEM(731,BOOST_PP_SEQ_REMOVE(SEQ_1024, 555)) == 733, ""); #endif -BEGIN BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_REPLACE(SEQ_NONE, 0, 22)) == 22 END -BEGIN BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_REPLACE(SEQ, 0, 3)) == 3152 END -BEGIN BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_REPLACE(SEQ, 1, 3)) == 4352 END -BEGIN BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_REPLACE(SEQ, 3, 3)) == 4153 END -BEGIN BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_REPLACE(SEQ_256, 255, 22)) == 256 END -BEGIN BOOST_PP_SEQ_ELEM(233,BOOST_PP_SEQ_REPLACE(SEQ_256, 255, 22)) == 234 END -BEGIN BOOST_PP_SEQ_ELEM(255,BOOST_PP_SEQ_REPLACE(SEQ_256, 255, 22)) == 22 END +static_assert(BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_REPLACE(SEQ_NONE, 0, 22)) == 22, ""); +static_assert(BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_REPLACE(SEQ, 0, 3)) == 3152, ""); +static_assert(BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_REPLACE(SEQ, 1, 3)) == 4352, ""); +static_assert(BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_REPLACE(SEQ, 3, 3)) == 4153, ""); +static_assert(BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_REPLACE(SEQ_256, 255, 22)) == 256, ""); +static_assert(BOOST_PP_SEQ_ELEM(233,BOOST_PP_SEQ_REPLACE(SEQ_256, 255, 22)) == 234, ""); +static_assert(BOOST_PP_SEQ_ELEM(255,BOOST_PP_SEQ_REPLACE(SEQ_256, 255, 22)) == 22, ""); # if BOOST_PP_LIMIT_SEQ == 512 -BEGIN BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_REPLACE(SEQ_511, 509, 350)) == 511 END -BEGIN BOOST_PP_SEQ_ELEM(482,BOOST_PP_SEQ_REPLACE(SEQ_512, 436, 33)) == 483 END -BEGIN BOOST_PP_SEQ_ELEM(436,BOOST_PP_SEQ_REPLACE(SEQ_512, 436, 33)) == 33 END +static_assert(BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_REPLACE(SEQ_511, 509, 350)) == 511, ""); +static_assert(BOOST_PP_SEQ_ELEM(482,BOOST_PP_SEQ_REPLACE(SEQ_512, 436, 33)) == 483, ""); +static_assert(BOOST_PP_SEQ_ELEM(436,BOOST_PP_SEQ_REPLACE(SEQ_512, 436, 33)) == 33, ""); #endif # if BOOST_PP_LIMIT_SEQ == 1024 -BEGIN BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_REPLACE(SEQ_1023, 846, 25)) == 1023 END -BEGIN BOOST_PP_SEQ_ELEM(984,BOOST_PP_SEQ_REPLACE(SEQ_1024, 841, 670)) == 985 END -BEGIN BOOST_PP_SEQ_ELEM(841,BOOST_PP_SEQ_REPLACE(SEQ_1024, 841, 670)) == 670 END +static_assert(BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_REPLACE(SEQ_1023, 846, 25)) == 1023, ""); +static_assert(BOOST_PP_SEQ_ELEM(984,BOOST_PP_SEQ_REPLACE(SEQ_1024, 841, 670)) == 985, ""); +static_assert(BOOST_PP_SEQ_ELEM(841,BOOST_PP_SEQ_REPLACE(SEQ_1024, 841, 670)) == 670, ""); #endif -BEGIN BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_SUBSEQ(SEQ, 0, 4)) == 4152 END -BEGIN BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_SUBSEQ(SEQ, 0, 2)) == 41 END -BEGIN BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_SUBSEQ(SEQ, 1, 2)) == 15 END -BEGIN BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_SUBSEQ(SEQ, 2, 2)) == 52 END +static_assert(BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_SUBSEQ(SEQ, 0, 4)) == 4152, ""); +static_assert(BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_SUBSEQ(SEQ, 0, 2)) == 41, ""); +static_assert(BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_SUBSEQ(SEQ, 1, 2)) == 15, ""); +static_assert(BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_SUBSEQ(SEQ, 2, 2)) == 52, ""); # if BOOST_PP_LIMIT_SEQ == 512 -BEGIN BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_SUBSEQ(SEQ_511, 372, 5)) == 5 END -BEGIN BOOST_PP_SEQ_ELEM(14,BOOST_PP_SEQ_SUBSEQ(SEQ_512, 293, 17)) == 308 END +static_assert(BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_SUBSEQ(SEQ_511, 372, 5)) == 5, ""); +static_assert(BOOST_PP_SEQ_ELEM(14,BOOST_PP_SEQ_SUBSEQ(SEQ_512, 293, 17)) == 308, ""); #endif # if BOOST_PP_LIMIT_SEQ == 1024 -BEGIN BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_SUBSEQ(SEQ_1023, 846, 5)) == 5 END -BEGIN BOOST_PP_SEQ_ELEM(16,BOOST_PP_SEQ_SUBSEQ(SEQ_1024, 843, 19)) == 860 END +static_assert(BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_SUBSEQ(SEQ_1023, 846, 5)) == 5, ""); +static_assert(BOOST_PP_SEQ_ELEM(16,BOOST_PP_SEQ_SUBSEQ(SEQ_1024, 843, 19)) == 860, ""); #endif @@ -626,7 +626,7 @@ BEGIN BOOST_PP_SEQ_ELEM(16,BOOST_PP_SEQ_SUBSEQ(SEQ_1024, 843, 19)) == 860 END #define ADD_NIL(x) x(nil) -BEGIN BOOST_PP_SEQ_FOR_EACH_PRODUCT(F2, ((1)(0)) ((2)(3))) == 0 END +static_assert(BOOST_PP_SEQ_FOR_EACH_PRODUCT(F2, ((1)(0)) ((2)(3))) == 0, ""); # define L1 (0)(x) # define L2 (a)(1)(b)(2) @@ -635,22 +635,22 @@ BEGIN BOOST_PP_SEQ_FOR_EACH_PRODUCT(F2, ((1)(0)) ((2)(3))) == 0 END # define LL (L1)(L2)(L3) #define SEQ_APPEND(s, state, elem) state elem -BEGIN BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_TAIL(BOOST_PP_SEQ_FOLD_LEFT(SEQ_APPEND, (~), LL))) == 0x0a1b2c3d END -BEGIN BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_TAIL(BOOST_PP_SEQ_FOLD_LEFT(SEQ_APPEND, (~), LL))) == 9 END +static_assert(BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_TAIL(BOOST_PP_SEQ_FOLD_LEFT(SEQ_APPEND, (~), LL))) == 0x0a1b2c3d, ""); +static_assert(BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_TAIL(BOOST_PP_SEQ_FOLD_LEFT(SEQ_APPEND, (~), LL))) == 9, ""); -BEGIN BOOST_PP_LIST_AT(BOOST_PP_SEQ_TO_LIST(SEQ), 2) == 5 END -BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_LIST_AT(BOOST_PP_SEQ_TO_LIST(SEQ_NONE),0)) == 1 END -BEGIN BOOST_PP_LIST_SIZE(BOOST_PP_SEQ_TO_LIST(SEQ_NONE)) == 1 END +static_assert(BOOST_PP_LIST_AT(BOOST_PP_SEQ_TO_LIST(SEQ), 2) == 5, ""); +static_assert(BOOST_PP_IS_EMPTY(BOOST_PP_LIST_AT(BOOST_PP_SEQ_TO_LIST(SEQ_NONE),0)) == 1, ""); +static_assert(BOOST_PP_LIST_SIZE(BOOST_PP_SEQ_TO_LIST(SEQ_NONE)) == 1, ""); # if BOOST_PP_VARIADIC_HAS_OPT() -BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_SEQ_ENUM(SEQ_NONE)) == 0 END +static_assert(BOOST_PP_VARIADIC_SIZE(BOOST_PP_SEQ_ENUM(SEQ_NONE)) == 0, ""); # else -BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_SEQ_ENUM(SEQ_NONE)) == 1 END +static_assert(BOOST_PP_VARIADIC_SIZE(BOOST_PP_SEQ_ENUM(SEQ_NONE)) == 1, ""); # endif -BEGIN BOOST_PP_VARIADIC_ELEM(0,BOOST_PP_SEQ_ENUM(SEQ)) == 4 END -BEGIN BOOST_PP_TUPLE_ELEM(2,BOOST_PP_SEQ_ELEM(0,BOOST_PP_VARIADIC_SEQ_TO_SEQ(SEQVAR))) == 8 END +static_assert(BOOST_PP_VARIADIC_ELEM(0,BOOST_PP_SEQ_ENUM(SEQ)) == 4, ""); +static_assert(BOOST_PP_TUPLE_ELEM(2,BOOST_PP_SEQ_ELEM(0,BOOST_PP_VARIADIC_SEQ_TO_SEQ(SEQVAR))) == 8, ""); diff --git a/test/slot.cxx b/test/slot.cxx index c26cfe15..0e7b956e 100644 --- a/test/slot.cxx +++ b/test/slot.cxx @@ -20,29 +20,29 @@ # undef X -BEGIN BOOST_PP_SLOT(1) == 10 END +static_assert(BOOST_PP_SLOT(1) == 10, ""); # define BOOST_PP_VALUE BOOST_PP_SLOT(1) * BOOST_PP_SLOT(1) # include BOOST_PP_ASSIGN_SLOT(1) -BEGIN BOOST_PP_SLOT(1) == 100 END +static_assert(BOOST_PP_SLOT(1) == 100, ""); -BEGIN BOOST_PP_COUNTER == 0 END +static_assert(BOOST_PP_COUNTER == 0, ""); #include BOOST_PP_UPDATE_COUNTER() -BEGIN BOOST_PP_COUNTER == 1 END +static_assert(BOOST_PP_COUNTER == 1, ""); #include BOOST_PP_UPDATE_COUNTER() #include BOOST_PP_UPDATE_COUNTER() -BEGIN BOOST_PP_COUNTER == 3 END +static_assert(BOOST_PP_COUNTER == 3, ""); #include BOOST_PP_UPDATE_COUNTER() #include BOOST_PP_UPDATE_COUNTER() #include BOOST_PP_UPDATE_COUNTER() -BEGIN BOOST_PP_COUNTER == 6 END +static_assert(BOOST_PP_COUNTER == 6, ""); #include BOOST_PP_UPDATE_COUNTER() #include BOOST_PP_UPDATE_COUNTER() @@ -50,4 +50,4 @@ BEGIN BOOST_PP_COUNTER == 6 END #include BOOST_PP_UPDATE_COUNTER() #include BOOST_PP_UPDATE_COUNTER() -BEGIN BOOST_PP_COUNTER == 11 END +static_assert(BOOST_PP_COUNTER == 11, ""); diff --git a/test/stringize.cxx b/test/stringize.cxx index 8c8b7630..eb8fa72a 100644 --- a/test/stringize.cxx +++ b/test/stringize.cxx @@ -23,14 +23,14 @@ #define FDATA(x) BOOST_PP_INC(x) # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() -BEGIN sizeof(BOOST_PP_STRINGIZE(NDATA)) / sizeof(char) == 1 END -BEGIN sizeof(BOOST_PP_WSTRINGIZE(NDATA)) / sizeof(wchar_t) == 1 END +static_assert(sizeof(BOOST_PP_STRINGIZE(NDATA)) / sizeof(char) == 1, ""); +static_assert(sizeof(BOOST_PP_WSTRINGIZE(NDATA)) / sizeof(wchar_t) == 1, ""); #endif -BEGIN sizeof(BOOST_PP_STRINGIZE(DATA)) / sizeof(char) == 5 END -BEGIN sizeof(BOOST_PP_STRINGIZE(FDATA(1))) / sizeof(char) == 2 END -BEGIN sizeof(BOOST_PP_STRINGIZE(FDATA(9))) / sizeof(char) == 3 END -BEGIN sizeof(BOOST_PP_WSTRINGIZE(DATA)) / sizeof(wchar_t) == 5 END -BEGIN sizeof(BOOST_PP_WSTRINGIZE(FDATA(1))) / sizeof(wchar_t) == 2 END -BEGIN sizeof(BOOST_PP_WSTRINGIZE(FDATA(9))) / sizeof(wchar_t) == 3 END -BEGIN sizeof(BOOST_PP_STRINGIZE(VDATA)) / sizeof(char) == 8 END -BEGIN sizeof(BOOST_PP_WSTRINGIZE(VDATA)) / sizeof(wchar_t) == 8 END +static_assert(sizeof(BOOST_PP_STRINGIZE(DATA)) / sizeof(char) == 5, ""); +static_assert(sizeof(BOOST_PP_STRINGIZE(FDATA(1))) / sizeof(char) == 2, ""); +static_assert(sizeof(BOOST_PP_STRINGIZE(FDATA(9))) / sizeof(char) == 3, ""); +static_assert(sizeof(BOOST_PP_WSTRINGIZE(DATA)) / sizeof(wchar_t) == 5, ""); +static_assert(sizeof(BOOST_PP_WSTRINGIZE(FDATA(1))) / sizeof(wchar_t) == 2, ""); +static_assert(sizeof(BOOST_PP_WSTRINGIZE(FDATA(9))) / sizeof(wchar_t) == 3, ""); +static_assert(sizeof(BOOST_PP_STRINGIZE(VDATA)) / sizeof(char) == 8, ""); +static_assert(sizeof(BOOST_PP_WSTRINGIZE(VDATA)) / sizeof(wchar_t) == 8, ""); diff --git a/test/test.h b/test/test.h index 1fc33af6..94579cf4 100644 --- a/test/test.h +++ b/test/test.h @@ -14,7 +14,9 @@ # ifndef BOOST_LIBS_PREPROCESSOR_REGRESSION_TEST_H # define BOOST_LIBS_PREPROCESSOR_REGRESSION_TEST_H # -# include "test_macro.h" +# ifndef __cplusplus +# include // C static_assert +# endif #include "test_main.h" # # endif diff --git a/test/test_macro.h b/test/test_macro.h deleted file mode 100644 index f9fe1f42..00000000 --- a/test/test_macro.h +++ /dev/null @@ -1,22 +0,0 @@ -# /* Copyright (C) 2001 -# * Housemarque Oy -# * http://www.housemarque.com -# * -# * 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) -# */ -# -# /* Revised by Paul Mensonides (2002) */ -# -# /* See http://www.boost.org for most recent version. */ -# -# ifndef BOOST_LIBS_PREPROCESSOR_REGRESSION_TEST_MACRO_H -# define BOOST_LIBS_PREPROCESSOR_REGRESSION_TEST_MACRO_H -# -# include -# -# define BEGIN typedef int BOOST_PP_CAT(test_, __LINE__)[(( -# define END )==1) ? 1 : -1]; -# -# endif diff --git a/test/test_main.h b/test/test_main.h index 23797c26..98e6ba3a 100644 --- a/test/test_main.h +++ b/test/test_main.h @@ -25,7 +25,7 @@ using namespace std; #endif int main(void) { - printf("pass " __TIME__); + printf("pass %s\n", __TIME__); return 0; } diff --git a/test/tuple.cxx b/test/tuple.cxx index 08c12a4f..31b36214 100644 --- a/test/tuple.cxx +++ b/test/tuple.cxx @@ -110,204 +110,204 @@ // elem -BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_TUPLE_ELEM(1, 0, TUPLE_NONE)) == 1 END -BEGIN BOOST_PP_TUPLE_ELEM(6, 3, TUPLE) == 3 END -BEGIN BOOST_PP_TUPLE_ELEM(6, 5, TUPLE) == 5 END -BEGIN BOOST_PP_TUPLE_ELEM(33, 15, TUPLE_LARGE) == 15 END -BEGIN BOOST_PP_TUPLE_ELEM(33, 27, TUPLE_LARGE) == 27 END -BEGIN BOOST_PP_TUPLE_ELEM(33, 32, TUPLE_LARGE) == 32 END -BEGIN BOOST_PP_TUPLE_ELEM(64, 22, TUPLE_VERY_LARGE) == 22 END -BEGIN BOOST_PP_TUPLE_ELEM(64, 47, TUPLE_VERY_LARGE) == 47 END -BEGIN BOOST_PP_TUPLE_ELEM(64, 63, TUPLE_VERY_LARGE) == 63 END +static_assert(BOOST_PP_IS_EMPTY(BOOST_PP_TUPLE_ELEM(1, 0, TUPLE_NONE)) == 1, ""); +static_assert(BOOST_PP_TUPLE_ELEM(6, 3, TUPLE) == 3, ""); +static_assert(BOOST_PP_TUPLE_ELEM(6, 5, TUPLE) == 5, ""); +static_assert(BOOST_PP_TUPLE_ELEM(33, 15, TUPLE_LARGE) == 15, ""); +static_assert(BOOST_PP_TUPLE_ELEM(33, 27, TUPLE_LARGE) == 27, ""); +static_assert(BOOST_PP_TUPLE_ELEM(33, 32, TUPLE_LARGE) == 32, ""); +static_assert(BOOST_PP_TUPLE_ELEM(64, 22, TUPLE_VERY_LARGE) == 22, ""); +static_assert(BOOST_PP_TUPLE_ELEM(64, 47, TUPLE_VERY_LARGE) == 47, ""); +static_assert(BOOST_PP_TUPLE_ELEM(64, 63, TUPLE_VERY_LARGE) == 63, ""); #if BOOST_PP_LIMIT_TUPLE > 64 -BEGIN BOOST_PP_TUPLE_ELEM(104, 73, TUPLE_LARGE_128) == 73 END -BEGIN BOOST_PP_TUPLE_ELEM(104, 89, TUPLE_LARGE_128) == 89 END -BEGIN BOOST_PP_TUPLE_ELEM(104, 101, TUPLE_LARGE_128) == 101 END -BEGIN BOOST_PP_TUPLE_ELEM(128, 95, TUPLE_VERY_LARGE_128) == 95 END -BEGIN BOOST_PP_TUPLE_ELEM(128, 110, TUPLE_VERY_LARGE_128) == 110 END -BEGIN BOOST_PP_TUPLE_ELEM(128, 126, TUPLE_VERY_LARGE_128) == 126 END +static_assert(BOOST_PP_TUPLE_ELEM(104, 73, TUPLE_LARGE_128) == 73, ""); +static_assert(BOOST_PP_TUPLE_ELEM(104, 89, TUPLE_LARGE_128) == 89, ""); +static_assert(BOOST_PP_TUPLE_ELEM(104, 101, TUPLE_LARGE_128) == 101, ""); +static_assert(BOOST_PP_TUPLE_ELEM(128, 95, TUPLE_VERY_LARGE_128) == 95, ""); +static_assert(BOOST_PP_TUPLE_ELEM(128, 110, TUPLE_VERY_LARGE_128) == 110, ""); +static_assert(BOOST_PP_TUPLE_ELEM(128, 126, TUPLE_VERY_LARGE_128) == 126, ""); #endif #if BOOST_PP_LIMIT_TUPLE > 128 -BEGIN BOOST_PP_TUPLE_ELEM(142, 83, TUPLE_LARGE_256) == 83 END -BEGIN BOOST_PP_TUPLE_ELEM(142, 131, TUPLE_LARGE_256) == 131 END -BEGIN BOOST_PP_TUPLE_ELEM(142, 140, TUPLE_LARGE_256) == 140 END -BEGIN BOOST_PP_TUPLE_ELEM(256, 174, TUPLE_VERY_LARGE_256) == 174 END -BEGIN BOOST_PP_TUPLE_ELEM(256, 226, TUPLE_VERY_LARGE_256) == 226 END -BEGIN BOOST_PP_TUPLE_ELEM(256, 253, TUPLE_VERY_LARGE_256) == 253 END +static_assert(BOOST_PP_TUPLE_ELEM(142, 83, TUPLE_LARGE_256) == 83, ""); +static_assert(BOOST_PP_TUPLE_ELEM(142, 131, TUPLE_LARGE_256) == 131, ""); +static_assert(BOOST_PP_TUPLE_ELEM(142, 140, TUPLE_LARGE_256) == 140, ""); +static_assert(BOOST_PP_TUPLE_ELEM(256, 174, TUPLE_VERY_LARGE_256) == 174, ""); +static_assert(BOOST_PP_TUPLE_ELEM(256, 226, TUPLE_VERY_LARGE_256) == 226, ""); +static_assert(BOOST_PP_TUPLE_ELEM(256, 253, TUPLE_VERY_LARGE_256) == 253, ""); #endif // reverse -BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_TUPLE_ELEM(1, 0, BOOST_PP_TUPLE_REVERSE(1,TUPLE_NONE))) == 1 END -BEGIN BOOST_PP_TUPLE_ELEM(6, 2, BOOST_PP_TUPLE_REVERSE(6,TUPLE)) == 3 END -BEGIN BOOST_PP_TUPLE_ELEM(33, 27, BOOST_PP_TUPLE_REVERSE(33,TUPLE_LARGE)) == 5 END -BEGIN BOOST_PP_TUPLE_ELEM(64, 43, BOOST_PP_TUPLE_REVERSE(64,TUPLE_VERY_LARGE)) == 20 END -BEGIN CALC(T2) == 7 END -BEGIN CALC(BOOST_PP_TUPLE_REVERSE(3, T2)) == 6 END +static_assert(BOOST_PP_IS_EMPTY(BOOST_PP_TUPLE_ELEM(1, 0, BOOST_PP_TUPLE_REVERSE(1,TUPLE_NONE))) == 1, ""); +static_assert(BOOST_PP_TUPLE_ELEM(6, 2, BOOST_PP_TUPLE_REVERSE(6,TUPLE)) == 3, ""); +static_assert(BOOST_PP_TUPLE_ELEM(33, 27, BOOST_PP_TUPLE_REVERSE(33,TUPLE_LARGE)) == 5, ""); +static_assert(BOOST_PP_TUPLE_ELEM(64, 43, BOOST_PP_TUPLE_REVERSE(64,TUPLE_VERY_LARGE)) == 20, ""); +static_assert(CALC(T2) == 7, ""); +static_assert(CALC(BOOST_PP_TUPLE_REVERSE(3, T2)) == 6, ""); #if BOOST_PP_LIMIT_TUPLE > 64 -BEGIN BOOST_PP_TUPLE_ELEM(104, 83, BOOST_PP_TUPLE_REVERSE(104,TUPLE_LARGE_128)) == 20 END -BEGIN BOOST_PP_TUPLE_ELEM(128, 119, BOOST_PP_TUPLE_REVERSE(128,TUPLE_VERY_LARGE_128)) == 8 END +static_assert(BOOST_PP_TUPLE_ELEM(104, 83, BOOST_PP_TUPLE_REVERSE(104,TUPLE_LARGE_128)) == 20, ""); +static_assert(BOOST_PP_TUPLE_ELEM(128, 119, BOOST_PP_TUPLE_REVERSE(128,TUPLE_VERY_LARGE_128)) == 8, ""); #endif #if BOOST_PP_LIMIT_TUPLE > 128 -BEGIN BOOST_PP_TUPLE_ELEM(142, 56, BOOST_PP_TUPLE_REVERSE(142,TUPLE_LARGE_256)) == 85 END -BEGIN BOOST_PP_TUPLE_ELEM(256, 212, BOOST_PP_TUPLE_REVERSE(256,TUPLE_VERY_LARGE_256)) == 43 END +static_assert(BOOST_PP_TUPLE_ELEM(142, 56, BOOST_PP_TUPLE_REVERSE(142,TUPLE_LARGE_256)) == 85, ""); +static_assert(BOOST_PP_TUPLE_ELEM(256, 212, BOOST_PP_TUPLE_REVERSE(256,TUPLE_VERY_LARGE_256)) == 43, ""); #endif // eat -BEGIN TEST_EAT == 4 END -BEGIN TEST_EAT_NONE == 17 END -BEGIN TEST_EAT_LARGE == 6 END -BEGIN TEST_EAT_VERY_LARGE == 8 END +static_assert(TEST_EAT == 4, ""); +static_assert(TEST_EAT_NONE == 17, ""); +static_assert(TEST_EAT_LARGE == 6, ""); +static_assert(TEST_EAT_VERY_LARGE == 8, ""); #if BOOST_PP_LIMIT_TUPLE > 64 -BEGIN TEST_EAT_LARGE_128 == 113 END -BEGIN TEST_EAT_VERY_LARGE_128 == 123 END +static_assert(TEST_EAT_LARGE_128 == 113, ""); +static_assert(TEST_EAT_VERY_LARGE_128 == 123, ""); #endif #if BOOST_PP_LIMIT_TUPLE > 128 -BEGIN TEST_EAT_LARGE_256 == 75 END -BEGIN TEST_EAT_VERY_LARGE_256 == 224 END +static_assert(TEST_EAT_LARGE_256 == 75, ""); +static_assert(TEST_EAT_VERY_LARGE_256 == 224, ""); #endif // to_array -BEGIN BOOST_PP_ARRAY_ELEM(3,BOOST_PP_TUPLE_TO_ARRAY(6,TUPLE)) == 3 END -BEGIN BOOST_PP_ARRAY_ELEM(29,BOOST_PP_TUPLE_TO_ARRAY(33,TUPLE_LARGE)) == 29 END -BEGIN BOOST_PP_ARRAY_ELEM(61,BOOST_PP_TUPLE_TO_ARRAY(64,TUPLE_VERY_LARGE)) == 61 END -BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_ARRAY_ELEM(0,BOOST_PP_TUPLE_TO_ARRAY(1,TUPLE_NONE))) == 1 END -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_TUPLE_TO_ARRAY(1,TUPLE_NONE)) == 1 END +static_assert(BOOST_PP_ARRAY_ELEM(3,BOOST_PP_TUPLE_TO_ARRAY(6,TUPLE)) == 3, ""); +static_assert(BOOST_PP_ARRAY_ELEM(29,BOOST_PP_TUPLE_TO_ARRAY(33,TUPLE_LARGE)) == 29, ""); +static_assert(BOOST_PP_ARRAY_ELEM(61,BOOST_PP_TUPLE_TO_ARRAY(64,TUPLE_VERY_LARGE)) == 61, ""); +static_assert(BOOST_PP_IS_EMPTY(BOOST_PP_ARRAY_ELEM(0,BOOST_PP_TUPLE_TO_ARRAY(1,TUPLE_NONE))) == 1, ""); +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_TUPLE_TO_ARRAY(1,TUPLE_NONE)) == 1, ""); #if BOOST_PP_LIMIT_TUPLE > 64 -BEGIN BOOST_PP_ARRAY_ELEM(65,BOOST_PP_TUPLE_TO_ARRAY(104,TUPLE_LARGE_128)) == 65 END -BEGIN BOOST_PP_ARRAY_ELEM(117,BOOST_PP_TUPLE_TO_ARRAY(128,TUPLE_VERY_LARGE_128)) == 117 END +static_assert(BOOST_PP_ARRAY_ELEM(65,BOOST_PP_TUPLE_TO_ARRAY(104,TUPLE_LARGE_128)) == 65, ""); +static_assert(BOOST_PP_ARRAY_ELEM(117,BOOST_PP_TUPLE_TO_ARRAY(128,TUPLE_VERY_LARGE_128)) == 117, ""); #endif #if BOOST_PP_LIMIT_TUPLE > 128 -BEGIN BOOST_PP_ARRAY_ELEM(131,BOOST_PP_TUPLE_TO_ARRAY(142,TUPLE_LARGE_256)) == 131 END -BEGIN BOOST_PP_ARRAY_ELEM(197,BOOST_PP_TUPLE_TO_ARRAY(256,TUPLE_VERY_LARGE_256)) == 197 END +static_assert(BOOST_PP_ARRAY_ELEM(131,BOOST_PP_TUPLE_TO_ARRAY(142,TUPLE_LARGE_256)) == 131, ""); +static_assert(BOOST_PP_ARRAY_ELEM(197,BOOST_PP_TUPLE_TO_ARRAY(256,TUPLE_VERY_LARGE_256)) == 197, ""); #endif // to_list -BEGIN BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(6,TUPLE), 2) == 2 END -BEGIN BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(33,TUPLE_LARGE), 19) == 19 END -BEGIN BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(64,TUPLE_VERY_LARGE), 62) == 62 END -BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(1,TUPLE_NONE), 0)) == 1 END -BEGIN BOOST_PP_LIST_SIZE(BOOST_PP_TUPLE_TO_LIST(1,TUPLE_NONE)) == 1 END +static_assert(BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(6,TUPLE), 2) == 2, ""); +static_assert(BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(33,TUPLE_LARGE), 19) == 19, ""); +static_assert(BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(64,TUPLE_VERY_LARGE), 62) == 62, ""); +static_assert(BOOST_PP_IS_EMPTY(BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(1,TUPLE_NONE), 0)) == 1, ""); +static_assert(BOOST_PP_LIST_SIZE(BOOST_PP_TUPLE_TO_LIST(1,TUPLE_NONE)) == 1, ""); #if BOOST_PP_LIMIT_TUPLE > 64 -BEGIN BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(104,TUPLE_LARGE_128), 88) == 88 END -BEGIN BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(128,TUPLE_VERY_LARGE_128), 113) == 113 END +static_assert(BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(104,TUPLE_LARGE_128), 88) == 88, ""); +static_assert(BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(128,TUPLE_VERY_LARGE_128), 113) == 113, ""); #endif #if BOOST_PP_LIMIT_TUPLE > 128 -BEGIN BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(142,TUPLE_LARGE_256), 137) == 137 END -BEGIN BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(256,TUPLE_VERY_LARGE_256), 235) == 235 END +static_assert(BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(142,TUPLE_LARGE_256), 137) == 137, ""); +static_assert(BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(256,TUPLE_VERY_LARGE_256), 235) == 235, ""); #endif // to_seq -BEGIN BOOST_PP_SEQ_ELEM(4,BOOST_PP_TUPLE_TO_SEQ(6,TUPLE)) == 4 END -BEGIN BOOST_PP_SEQ_ELEM(31,BOOST_PP_TUPLE_TO_SEQ(33,TUPLE_LARGE)) == 31 END -BEGIN BOOST_PP_SEQ_ELEM(55,BOOST_PP_TUPLE_TO_SEQ(64,TUPLE_VERY_LARGE)) == 55 END -BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_SEQ_ELEM(0,BOOST_PP_TUPLE_TO_SEQ(1,TUPLE_NONE))) == 1 END -BEGIN BOOST_PP_SEQ_SIZE(BOOST_PP_TUPLE_TO_SEQ(1,TUPLE_NONE)) == 1 END +static_assert(BOOST_PP_SEQ_ELEM(4,BOOST_PP_TUPLE_TO_SEQ(6,TUPLE)) == 4, ""); +static_assert(BOOST_PP_SEQ_ELEM(31,BOOST_PP_TUPLE_TO_SEQ(33,TUPLE_LARGE)) == 31, ""); +static_assert(BOOST_PP_SEQ_ELEM(55,BOOST_PP_TUPLE_TO_SEQ(64,TUPLE_VERY_LARGE)) == 55, ""); +static_assert(BOOST_PP_IS_EMPTY(BOOST_PP_SEQ_ELEM(0,BOOST_PP_TUPLE_TO_SEQ(1,TUPLE_NONE))) == 1, ""); +static_assert(BOOST_PP_SEQ_SIZE(BOOST_PP_TUPLE_TO_SEQ(1,TUPLE_NONE)) == 1, ""); #if BOOST_PP_LIMIT_TUPLE > 64 -BEGIN BOOST_PP_SEQ_ELEM(97,BOOST_PP_TUPLE_TO_SEQ(104,TUPLE_LARGE_128)) == 97 END -BEGIN BOOST_PP_SEQ_ELEM(123,BOOST_PP_TUPLE_TO_SEQ(128,TUPLE_VERY_LARGE_128)) == 123 END +static_assert(BOOST_PP_SEQ_ELEM(97,BOOST_PP_TUPLE_TO_SEQ(104,TUPLE_LARGE_128)) == 97, ""); +static_assert(BOOST_PP_SEQ_ELEM(123,BOOST_PP_TUPLE_TO_SEQ(128,TUPLE_VERY_LARGE_128)) == 123, ""); #endif #if BOOST_PP_LIMIT_TUPLE > 128 -BEGIN BOOST_PP_SEQ_ELEM(53,BOOST_PP_TUPLE_TO_SEQ(142,TUPLE_LARGE_256)) == 53 END -BEGIN BOOST_PP_SEQ_ELEM(181,BOOST_PP_TUPLE_TO_SEQ(256,TUPLE_VERY_LARGE_256)) == 181 END +static_assert(BOOST_PP_SEQ_ELEM(53,BOOST_PP_TUPLE_TO_SEQ(142,TUPLE_LARGE_256)) == 53, ""); +static_assert(BOOST_PP_SEQ_ELEM(181,BOOST_PP_TUPLE_TO_SEQ(256,TUPLE_VERY_LARGE_256)) == 181, ""); #endif // elem -BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_TUPLE_ELEM(0, TUPLE_NONE)) == 1 END -BEGIN BOOST_PP_TUPLE_ELEM(3, TUPLE) == 3 END -BEGIN BOOST_PP_TUPLE_ELEM(5, TUPLE) == 5 END -BEGIN BOOST_PP_TUPLE_ELEM(15, TUPLE_LARGE) == 15 END -BEGIN BOOST_PP_TUPLE_ELEM(27, TUPLE_LARGE) == 27 END -BEGIN BOOST_PP_TUPLE_ELEM(32, TUPLE_LARGE) == 32 END -BEGIN BOOST_PP_TUPLE_ELEM(22, TUPLE_VERY_LARGE) == 22 END -BEGIN BOOST_PP_TUPLE_ELEM(47, TUPLE_VERY_LARGE) == 47 END -BEGIN BOOST_PP_TUPLE_ELEM(63, TUPLE_VERY_LARGE) == 63 END +static_assert(BOOST_PP_IS_EMPTY(BOOST_PP_TUPLE_ELEM(0, TUPLE_NONE)) == 1, ""); +static_assert(BOOST_PP_TUPLE_ELEM(3, TUPLE) == 3, ""); +static_assert(BOOST_PP_TUPLE_ELEM(5, TUPLE) == 5, ""); +static_assert(BOOST_PP_TUPLE_ELEM(15, TUPLE_LARGE) == 15, ""); +static_assert(BOOST_PP_TUPLE_ELEM(27, TUPLE_LARGE) == 27, ""); +static_assert(BOOST_PP_TUPLE_ELEM(32, TUPLE_LARGE) == 32, ""); +static_assert(BOOST_PP_TUPLE_ELEM(22, TUPLE_VERY_LARGE) == 22, ""); +static_assert(BOOST_PP_TUPLE_ELEM(47, TUPLE_VERY_LARGE) == 47, ""); +static_assert(BOOST_PP_TUPLE_ELEM(63, TUPLE_VERY_LARGE) == 63, ""); #if BOOST_PP_LIMIT_TUPLE > 64 -BEGIN BOOST_PP_TUPLE_ELEM(73, TUPLE_LARGE_128) == 73 END -BEGIN BOOST_PP_TUPLE_ELEM(89, TUPLE_LARGE_128) == 89 END -BEGIN BOOST_PP_TUPLE_ELEM(101, TUPLE_LARGE_128) == 101 END -BEGIN BOOST_PP_TUPLE_ELEM(95, TUPLE_VERY_LARGE_128) == 95 END -BEGIN BOOST_PP_TUPLE_ELEM(110, TUPLE_VERY_LARGE_128) == 110 END -BEGIN BOOST_PP_TUPLE_ELEM(126, TUPLE_VERY_LARGE_128) == 126 END +static_assert(BOOST_PP_TUPLE_ELEM(73, TUPLE_LARGE_128) == 73, ""); +static_assert(BOOST_PP_TUPLE_ELEM(89, TUPLE_LARGE_128) == 89, ""); +static_assert(BOOST_PP_TUPLE_ELEM(101, TUPLE_LARGE_128) == 101, ""); +static_assert(BOOST_PP_TUPLE_ELEM(95, TUPLE_VERY_LARGE_128) == 95, ""); +static_assert(BOOST_PP_TUPLE_ELEM(110, TUPLE_VERY_LARGE_128) == 110, ""); +static_assert(BOOST_PP_TUPLE_ELEM(126, TUPLE_VERY_LARGE_128) == 126, ""); #endif #if BOOST_PP_LIMIT_TUPLE > 128 -BEGIN BOOST_PP_TUPLE_ELEM(83, TUPLE_LARGE_256) == 83 END -BEGIN BOOST_PP_TUPLE_ELEM(131, TUPLE_LARGE_256) == 131 END -BEGIN BOOST_PP_TUPLE_ELEM(140, TUPLE_LARGE_256) == 140 END -BEGIN BOOST_PP_TUPLE_ELEM(174, TUPLE_VERY_LARGE_256) == 174 END -BEGIN BOOST_PP_TUPLE_ELEM(226, TUPLE_VERY_LARGE_256) == 226 END -BEGIN BOOST_PP_TUPLE_ELEM(253, TUPLE_VERY_LARGE_256) == 253 END +static_assert(BOOST_PP_TUPLE_ELEM(83, TUPLE_LARGE_256) == 83, ""); +static_assert(BOOST_PP_TUPLE_ELEM(131, TUPLE_LARGE_256) == 131, ""); +static_assert(BOOST_PP_TUPLE_ELEM(140, TUPLE_LARGE_256) == 140, ""); +static_assert(BOOST_PP_TUPLE_ELEM(174, TUPLE_VERY_LARGE_256) == 174, ""); +static_assert(BOOST_PP_TUPLE_ELEM(226, TUPLE_VERY_LARGE_256) == 226, ""); +static_assert(BOOST_PP_TUPLE_ELEM(253, TUPLE_VERY_LARGE_256) == 253, ""); #endif // reverse -BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_TUPLE_ELEM(0, BOOST_PP_TUPLE_REVERSE(TUPLE_NONE))) == 1 END -BEGIN BOOST_PP_TUPLE_ELEM(2, BOOST_PP_TUPLE_REVERSE(TUPLE)) == 3 END -BEGIN BOOST_PP_TUPLE_ELEM(27, BOOST_PP_TUPLE_REVERSE(TUPLE_LARGE)) == 5 END -BEGIN BOOST_PP_TUPLE_ELEM(43, BOOST_PP_TUPLE_REVERSE(TUPLE_VERY_LARGE)) == 20 END -BEGIN CALC(BOOST_PP_TUPLE_REVERSE(T2)) == 6 END -BEGIN BOOST_PP_VARIADIC_ELEM(2,BOOST_PP_TUPLE_ENUM(BOOST_PP_TUPLE_REVERSE(TUPLE))) == 3 END -BEGIN BOOST_PP_VARIADIC_ELEM(27,BOOST_PP_TUPLE_ENUM(BOOST_PP_TUPLE_REVERSE(TUPLE_LARGE))) == 5 END -BEGIN BOOST_PP_VARIADIC_ELEM(45,BOOST_PP_TUPLE_ENUM(BOOST_PP_TUPLE_REVERSE(TUPLE_VERY_LARGE))) == 18 END +static_assert(BOOST_PP_IS_EMPTY(BOOST_PP_TUPLE_ELEM(0, BOOST_PP_TUPLE_REVERSE(TUPLE_NONE))) == 1, ""); +static_assert(BOOST_PP_TUPLE_ELEM(2, BOOST_PP_TUPLE_REVERSE(TUPLE)) == 3, ""); +static_assert(BOOST_PP_TUPLE_ELEM(27, BOOST_PP_TUPLE_REVERSE(TUPLE_LARGE)) == 5, ""); +static_assert(BOOST_PP_TUPLE_ELEM(43, BOOST_PP_TUPLE_REVERSE(TUPLE_VERY_LARGE)) == 20, ""); +static_assert(CALC(BOOST_PP_TUPLE_REVERSE(T2)) == 6, ""); +static_assert(BOOST_PP_VARIADIC_ELEM(2,BOOST_PP_TUPLE_ENUM(BOOST_PP_TUPLE_REVERSE(TUPLE))) == 3, ""); +static_assert(BOOST_PP_VARIADIC_ELEM(27,BOOST_PP_TUPLE_ENUM(BOOST_PP_TUPLE_REVERSE(TUPLE_LARGE))) == 5, ""); +static_assert(BOOST_PP_VARIADIC_ELEM(45,BOOST_PP_TUPLE_ENUM(BOOST_PP_TUPLE_REVERSE(TUPLE_VERY_LARGE))) == 18, ""); #if BOOST_PP_LIMIT_TUPLE > 64 -BEGIN BOOST_PP_TUPLE_ELEM(83, BOOST_PP_TUPLE_REVERSE(TUPLE_LARGE_128)) == 20 END -BEGIN BOOST_PP_TUPLE_ELEM(119, BOOST_PP_TUPLE_REVERSE(TUPLE_VERY_LARGE_128)) == 8 END +static_assert(BOOST_PP_TUPLE_ELEM(83, BOOST_PP_TUPLE_REVERSE(TUPLE_LARGE_128)) == 20, ""); +static_assert(BOOST_PP_TUPLE_ELEM(119, BOOST_PP_TUPLE_REVERSE(TUPLE_VERY_LARGE_128)) == 8, ""); #endif #if BOOST_PP_LIMIT_TUPLE > 128 -BEGIN BOOST_PP_TUPLE_ELEM(56, BOOST_PP_TUPLE_REVERSE(TUPLE_LARGE_256)) == 85 END -BEGIN BOOST_PP_TUPLE_ELEM(212, BOOST_PP_TUPLE_REVERSE(TUPLE_VERY_LARGE_256)) == 43 END +static_assert(BOOST_PP_TUPLE_ELEM(56, BOOST_PP_TUPLE_REVERSE(TUPLE_LARGE_256)) == 85, ""); +static_assert(BOOST_PP_TUPLE_ELEM(212, BOOST_PP_TUPLE_REVERSE(TUPLE_VERY_LARGE_256)) == 43, ""); #endif @@ -315,160 +315,160 @@ BEGIN BOOST_PP_TUPLE_ELEM(212, BOOST_PP_TUPLE_REVERSE(TUPLE_VERY_LARGE_256)) == # if BOOST_PP_VARIADIC_HAS_OPT() -BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_ENUM(TUPLE_NONE)) == 0 END +static_assert(BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_ENUM(TUPLE_NONE)) == 0, ""); # else -BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_ENUM(TUPLE_NONE)) == 1 END +static_assert(BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_ENUM(TUPLE_NONE)) == 1, ""); # endif -BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_ENUM(TUPLE)) == 6 END -BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_ENUM(TUPLE_LARGE)) == 33 END -BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_ENUM(TUPLE_VERY_LARGE)) == 64 END +static_assert(BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_ENUM(TUPLE)) == 6, ""); +static_assert(BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_ENUM(TUPLE_LARGE)) == 33, ""); +static_assert(BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_ENUM(TUPLE_VERY_LARGE)) == 64, ""); #if BOOST_PP_LIMIT_TUPLE > 64 -BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_ENUM(TUPLE_LARGE_128)) == 104 END -BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_ENUM(TUPLE_VERY_LARGE_128)) == 128 END +static_assert(BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_ENUM(TUPLE_LARGE_128)) == 104, ""); +static_assert(BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_ENUM(TUPLE_VERY_LARGE_128)) == 128, ""); #endif #if BOOST_PP_LIMIT_TUPLE > 128 -BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_ENUM(TUPLE_LARGE_256)) == 142 END -BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_ENUM(TUPLE_VERY_LARGE_256)) == 256 END +static_assert(BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_ENUM(TUPLE_LARGE_256)) == 142, ""); +static_assert(BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_ENUM(TUPLE_VERY_LARGE_256)) == 256, ""); #endif // insert -BEGIN BOOST_PP_TUPLE_ELEM(0, BOOST_PP_TUPLE_INSERT(TUPLE_NONE,0,40)) == 40 END -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_INSERT(TUPLE_NONE,0,40)) == 2 END +static_assert(BOOST_PP_TUPLE_ELEM(0, BOOST_PP_TUPLE_INSERT(TUPLE_NONE,0,40)) == 40, ""); +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_INSERT(TUPLE_NONE,0,40)) == 2, ""); -BEGIN BOOST_PP_TUPLE_ELEM(0, BOOST_PP_TUPLE_INSERT(TUPLE,2,40)) == 0 END -BEGIN BOOST_PP_TUPLE_ELEM(1, BOOST_PP_TUPLE_INSERT(TUPLE,1,40)) == 40 END -BEGIN BOOST_PP_TUPLE_ELEM(2, BOOST_PP_TUPLE_INSERT(TUPLE,1,40)) == 1 END -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_INSERT(TUPLE,1,40)) == 7 END +static_assert(BOOST_PP_TUPLE_ELEM(0, BOOST_PP_TUPLE_INSERT(TUPLE,2,40)) == 0, ""); +static_assert(BOOST_PP_TUPLE_ELEM(1, BOOST_PP_TUPLE_INSERT(TUPLE,1,40)) == 40, ""); +static_assert(BOOST_PP_TUPLE_ELEM(2, BOOST_PP_TUPLE_INSERT(TUPLE,1,40)) == 1, ""); +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_INSERT(TUPLE,1,40)) == 7, ""); -BEGIN BOOST_PP_TUPLE_ELEM(8, BOOST_PP_TUPLE_INSERT(TUPLE_LARGE,22,1000)) == 8 END -BEGIN BOOST_PP_TUPLE_ELEM(22, BOOST_PP_TUPLE_INSERT(TUPLE_LARGE,22,1000)) == 1000 END -BEGIN BOOST_PP_TUPLE_ELEM(26, BOOST_PP_TUPLE_INSERT(TUPLE_LARGE,22,1000)) == 25 END -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_INSERT(TUPLE_LARGE,22,1000)) == 34 END +static_assert(BOOST_PP_TUPLE_ELEM(8, BOOST_PP_TUPLE_INSERT(TUPLE_LARGE,22,1000)) == 8, ""); +static_assert(BOOST_PP_TUPLE_ELEM(22, BOOST_PP_TUPLE_INSERT(TUPLE_LARGE,22,1000)) == 1000, ""); +static_assert(BOOST_PP_TUPLE_ELEM(26, BOOST_PP_TUPLE_INSERT(TUPLE_LARGE,22,1000)) == 25, ""); +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_INSERT(TUPLE_LARGE,22,1000)) == 34, ""); #if BOOST_PP_LIMIT_TUPLE > 64 -BEGIN BOOST_PP_TUPLE_ELEM(69, BOOST_PP_TUPLE_INSERT(TUPLE_LARGE_128,76,1000)) == 69 END -BEGIN BOOST_PP_TUPLE_ELEM(101, BOOST_PP_TUPLE_INSERT(TUPLE_LARGE_128,101,1000)) == 1000 END -BEGIN BOOST_PP_TUPLE_ELEM(98, BOOST_PP_TUPLE_INSERT(TUPLE_LARGE_128,96,1000)) == 97 END -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_INSERT(TUPLE_LARGE_128,84,1000)) == 105 END +static_assert(BOOST_PP_TUPLE_ELEM(69, BOOST_PP_TUPLE_INSERT(TUPLE_LARGE_128,76,1000)) == 69, ""); +static_assert(BOOST_PP_TUPLE_ELEM(101, BOOST_PP_TUPLE_INSERT(TUPLE_LARGE_128,101,1000)) == 1000, ""); +static_assert(BOOST_PP_TUPLE_ELEM(98, BOOST_PP_TUPLE_INSERT(TUPLE_LARGE_128,96,1000)) == 97, ""); +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_INSERT(TUPLE_LARGE_128,84,1000)) == 105, ""); #endif #if BOOST_PP_LIMIT_TUPLE > 128 -BEGIN BOOST_PP_TUPLE_ELEM(73, BOOST_PP_TUPLE_INSERT(TUPLE_LARGE_256,134,1000)) == 73 END -BEGIN BOOST_PP_TUPLE_ELEM(141, BOOST_PP_TUPLE_INSERT(TUPLE_LARGE_256,141,1000)) == 1000 END -BEGIN BOOST_PP_TUPLE_ELEM(133, BOOST_PP_TUPLE_INSERT(TUPLE_LARGE_256,39,1000)) == 132 END -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_INSERT(TUPLE_LARGE_256,121,1000)) == 143 END -BEGIN BOOST_PP_TUPLE_ELEM(227,BOOST_PP_TUPLE_INSERT(TUPLE_VERY_LARGE_255,212,1000)) == 226 END -BEGIN BOOST_PP_TUPLE_ELEM(212,BOOST_PP_TUPLE_INSERT(TUPLE_VERY_LARGE_255,212,1000)) == 1000 END +static_assert(BOOST_PP_TUPLE_ELEM(73, BOOST_PP_TUPLE_INSERT(TUPLE_LARGE_256,134,1000)) == 73, ""); +static_assert(BOOST_PP_TUPLE_ELEM(141, BOOST_PP_TUPLE_INSERT(TUPLE_LARGE_256,141,1000)) == 1000, ""); +static_assert(BOOST_PP_TUPLE_ELEM(133, BOOST_PP_TUPLE_INSERT(TUPLE_LARGE_256,39,1000)) == 132, ""); +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_INSERT(TUPLE_LARGE_256,121,1000)) == 143, ""); +static_assert(BOOST_PP_TUPLE_ELEM(227,BOOST_PP_TUPLE_INSERT(TUPLE_VERY_LARGE_255,212,1000)) == 226, ""); +static_assert(BOOST_PP_TUPLE_ELEM(212,BOOST_PP_TUPLE_INSERT(TUPLE_VERY_LARGE_255,212,1000)) == 1000, ""); #endif // pop_back -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_BACK(TUPLE)) == 5 END -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_BACK(TUPLE_LARGE)) == 32 END -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_BACK(TUPLE_VERY_LARGE)) == 63 END +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_BACK(TUPLE)) == 5, ""); +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_BACK(TUPLE_LARGE)) == 32, ""); +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_BACK(TUPLE_VERY_LARGE)) == 63, ""); #if BOOST_PP_LIMIT_TUPLE > 64 -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_BACK(TUPLE_LARGE_128)) == 103 END -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_BACK(TUPLE_VERY_LARGE_128)) == 127 END +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_BACK(TUPLE_LARGE_128)) == 103, ""); +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_BACK(TUPLE_VERY_LARGE_128)) == 127, ""); #endif #if BOOST_PP_LIMIT_TUPLE > 128 -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_BACK(TUPLE_LARGE_256)) == 141 END -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_BACK(TUPLE_VERY_LARGE_256)) == 255 END +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_BACK(TUPLE_LARGE_256)) == 141, ""); +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_BACK(TUPLE_VERY_LARGE_256)) == 255, ""); #endif // pop_front -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_FRONT(TUPLE)) == 5 END -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_FRONT(TUPLE_LARGE)) == 32 END -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_FRONT(TUPLE_VERY_LARGE)) == 63 END +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_FRONT(TUPLE)) == 5, ""); +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_FRONT(TUPLE_LARGE)) == 32, ""); +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_FRONT(TUPLE_VERY_LARGE)) == 63, ""); -BEGIN BOOST_PP_TUPLE_ELEM(1, BOOST_PP_TUPLE_POP_FRONT(TUPLE)) == 2 END -BEGIN BOOST_PP_TUPLE_ELEM(31, BOOST_PP_TUPLE_POP_FRONT(TUPLE_LARGE)) == 32 END -BEGIN BOOST_PP_TUPLE_ELEM(55, BOOST_PP_TUPLE_POP_FRONT(TUPLE_VERY_LARGE)) == 56 END +static_assert(BOOST_PP_TUPLE_ELEM(1, BOOST_PP_TUPLE_POP_FRONT(TUPLE)) == 2, ""); +static_assert(BOOST_PP_TUPLE_ELEM(31, BOOST_PP_TUPLE_POP_FRONT(TUPLE_LARGE)) == 32, ""); +static_assert(BOOST_PP_TUPLE_ELEM(55, BOOST_PP_TUPLE_POP_FRONT(TUPLE_VERY_LARGE)) == 56, ""); #if BOOST_PP_LIMIT_TUPLE > 64 -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_FRONT(TUPLE_LARGE_128)) == 103 END -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_FRONT(TUPLE_VERY_LARGE_128)) == 127 END -BEGIN BOOST_PP_TUPLE_ELEM(84, BOOST_PP_TUPLE_POP_FRONT(TUPLE_LARGE_128)) == 85 END -BEGIN BOOST_PP_TUPLE_ELEM(117, BOOST_PP_TUPLE_POP_FRONT(TUPLE_VERY_LARGE_128)) == 118 END +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_FRONT(TUPLE_LARGE_128)) == 103, ""); +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_FRONT(TUPLE_VERY_LARGE_128)) == 127, ""); +static_assert(BOOST_PP_TUPLE_ELEM(84, BOOST_PP_TUPLE_POP_FRONT(TUPLE_LARGE_128)) == 85, ""); +static_assert(BOOST_PP_TUPLE_ELEM(117, BOOST_PP_TUPLE_POP_FRONT(TUPLE_VERY_LARGE_128)) == 118, ""); #endif #if BOOST_PP_LIMIT_TUPLE > 128 -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_FRONT(TUPLE_LARGE_256)) == 141 END -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_FRONT(TUPLE_VERY_LARGE_256)) == 255 END -BEGIN BOOST_PP_TUPLE_ELEM(129, BOOST_PP_TUPLE_POP_FRONT(TUPLE_LARGE_256)) == 130 END -BEGIN BOOST_PP_TUPLE_ELEM(248, BOOST_PP_TUPLE_POP_FRONT(TUPLE_VERY_LARGE_256)) == 249 END +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_FRONT(TUPLE_LARGE_256)) == 141, ""); +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_POP_FRONT(TUPLE_VERY_LARGE_256)) == 255, ""); +static_assert(BOOST_PP_TUPLE_ELEM(129, BOOST_PP_TUPLE_POP_FRONT(TUPLE_LARGE_256)) == 130, ""); +static_assert(BOOST_PP_TUPLE_ELEM(248, BOOST_PP_TUPLE_POP_FRONT(TUPLE_VERY_LARGE_256)) == 249, ""); #endif // push_back -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_PUSH_BACK(TUPLE_NONE, 1)) == 2 END -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_PUSH_BACK(TUPLE, 6)) == 7 END -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_PUSH_BACK(TUPLE_LARGE, 33)) == 34 END -BEGIN BOOST_PP_TUPLE_ELEM(1, BOOST_PP_TUPLE_PUSH_BACK(TUPLE_NONE, 1)) == 1 END -BEGIN BOOST_PP_TUPLE_ELEM(0, BOOST_PP_TUPLE_PUSH_BACK(TUPLE, 6)) == 0 END -BEGIN BOOST_PP_TUPLE_ELEM(33, BOOST_PP_TUPLE_PUSH_BACK(TUPLE_LARGE, 33)) == 33 END +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_PUSH_BACK(TUPLE_NONE, 1)) == 2, ""); +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_PUSH_BACK(TUPLE, 6)) == 7, ""); +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_PUSH_BACK(TUPLE_LARGE, 33)) == 34, ""); +static_assert(BOOST_PP_TUPLE_ELEM(1, BOOST_PP_TUPLE_PUSH_BACK(TUPLE_NONE, 1)) == 1, ""); +static_assert(BOOST_PP_TUPLE_ELEM(0, BOOST_PP_TUPLE_PUSH_BACK(TUPLE, 6)) == 0, ""); +static_assert(BOOST_PP_TUPLE_ELEM(33, BOOST_PP_TUPLE_PUSH_BACK(TUPLE_LARGE, 33)) == 33, ""); #if BOOST_PP_LIMIT_TUPLE > 64 -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_PUSH_BACK(TUPLE_LARGE_128, 66)) == 105 END -BEGIN BOOST_PP_TUPLE_ELEM(104, BOOST_PP_TUPLE_PUSH_BACK(TUPLE_LARGE_128, 101)) == 101 END +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_PUSH_BACK(TUPLE_LARGE_128, 66)) == 105, ""); +static_assert(BOOST_PP_TUPLE_ELEM(104, BOOST_PP_TUPLE_PUSH_BACK(TUPLE_LARGE_128, 101)) == 101, ""); #endif #if BOOST_PP_LIMIT_TUPLE > 128 -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_PUSH_BACK(TUPLE_LARGE_256, 192)) == 143 END -BEGIN BOOST_PP_TUPLE_ELEM(142, BOOST_PP_TUPLE_PUSH_BACK(TUPLE_LARGE_256, 77)) == 77 END -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_PUSH_BACK(TUPLE_VERY_LARGE_255, 255)) == 256 END +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_PUSH_BACK(TUPLE_LARGE_256, 192)) == 143, ""); +static_assert(BOOST_PP_TUPLE_ELEM(142, BOOST_PP_TUPLE_PUSH_BACK(TUPLE_LARGE_256, 77)) == 77, ""); +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_PUSH_BACK(TUPLE_VERY_LARGE_255, 255)) == 256, ""); #endif // push_front -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_PUSH_FRONT(TUPLE_NONE, 55)) == 2 END -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_PUSH_FRONT(TUPLE, 555)) == 7 END -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_PUSH_FRONT(TUPLE_LARGE, 666)) == 34 END -BEGIN BOOST_PP_TUPLE_ELEM(0, BOOST_PP_TUPLE_PUSH_FRONT(TUPLE_NONE, 55)) == 55 END -BEGIN BOOST_PP_TUPLE_ELEM(0, BOOST_PP_TUPLE_PUSH_FRONT(TUPLE, 555)) == 555 END -BEGIN BOOST_PP_TUPLE_ELEM(33, BOOST_PP_TUPLE_PUSH_FRONT(TUPLE_LARGE, 33)) == 32 END +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_PUSH_FRONT(TUPLE_NONE, 55)) == 2, ""); +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_PUSH_FRONT(TUPLE, 555)) == 7, ""); +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_PUSH_FRONT(TUPLE_LARGE, 666)) == 34, ""); +static_assert(BOOST_PP_TUPLE_ELEM(0, BOOST_PP_TUPLE_PUSH_FRONT(TUPLE_NONE, 55)) == 55, ""); +static_assert(BOOST_PP_TUPLE_ELEM(0, BOOST_PP_TUPLE_PUSH_FRONT(TUPLE, 555)) == 555, ""); +static_assert(BOOST_PP_TUPLE_ELEM(33, BOOST_PP_TUPLE_PUSH_FRONT(TUPLE_LARGE, 33)) == 32, ""); #if BOOST_PP_LIMIT_TUPLE > 64 -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_PUSH_FRONT(TUPLE_LARGE_128, 666)) == 105 END -BEGIN BOOST_PP_TUPLE_ELEM(103, BOOST_PP_TUPLE_PUSH_FRONT(TUPLE_LARGE_128, 29)) == 102 END +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_PUSH_FRONT(TUPLE_LARGE_128, 666)) == 105, ""); +static_assert(BOOST_PP_TUPLE_ELEM(103, BOOST_PP_TUPLE_PUSH_FRONT(TUPLE_LARGE_128, 29)) == 102, ""); #endif #if BOOST_PP_LIMIT_TUPLE > 128 -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_PUSH_FRONT(TUPLE_LARGE_256, 333)) == 143 END -BEGIN BOOST_PP_TUPLE_ELEM(136, BOOST_PP_TUPLE_PUSH_FRONT(TUPLE_LARGE_256, 47)) == 135 END -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_PUSH_FRONT(TUPLE_VERY_LARGE_255, 4)) == 256 END +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_PUSH_FRONT(TUPLE_LARGE_256, 333)) == 143, ""); +static_assert(BOOST_PP_TUPLE_ELEM(136, BOOST_PP_TUPLE_PUSH_FRONT(TUPLE_LARGE_256, 47)) == 135, ""); +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_PUSH_FRONT(TUPLE_VERY_LARGE_255, 4)) == 256, ""); #endif @@ -478,28 +478,28 @@ BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_PUSH_FRONT(TUPLE_VERY_LARGE_255, 4)) == # if BOOST_PP_VARIADIC_HAS_OPT() -BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM(1)()) == 0 END +static_assert(BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM(1)()) == 0, ""); # else -BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM(1)()) == 1 END +static_assert(BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM(1)()) == 1, ""); # endif -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 -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 +static_assert(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, ""); +static_assert(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, ""); #else #if BOOST_PP_VARIADICS_MSVC -BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_TUPLE_REM_CAT() TUPLE_NONE) == 1 END +static_assert(BOOST_PP_IS_EMPTY(BOOST_PP_TUPLE_REM_CAT() TUPLE_NONE) == 1, ""); #else -BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_TUPLE_REM() TUPLE_NONE) == 1 END +static_assert(BOOST_PP_IS_EMPTY(BOOST_PP_TUPLE_REM() TUPLE_NONE) == 1, ""); #endif -BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM()(0, 1, 2, 3, 4, 5)) == 6 END -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 -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 +static_assert(BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM()(0, 1, 2, 3, 4, 5)) == 6, ""); +static_assert(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, ""); +static_assert(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, ""); #endif @@ -507,191 +507,191 @@ BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM()(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, # if BOOST_PP_VARIADIC_HAS_OPT() -BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM_CTOR(TUPLE_NONE)) == 0 END +static_assert(BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM_CTOR(TUPLE_NONE)) == 0, ""); # else -BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM_CTOR(TUPLE_NONE)) == 1 END +static_assert(BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM_CTOR(TUPLE_NONE)) == 1, ""); # endif -BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM_CTOR(TUPLE)) == 6 END -BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM_CTOR(TUPLE_LARGE)) == 33 END -BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM_CTOR(TUPLE_VERY_LARGE)) == 64 END +static_assert(BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM_CTOR(TUPLE)) == 6, ""); +static_assert(BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM_CTOR(TUPLE_LARGE)) == 33, ""); +static_assert(BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM_CTOR(TUPLE_VERY_LARGE)) == 64, ""); #if BOOST_PP_LIMIT_TUPLE > 64 -BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM_CTOR(TUPLE_LARGE_128)) == 104 END -BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM_CTOR(TUPLE_VERY_LARGE_128)) == 128 END +static_assert(BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM_CTOR(TUPLE_LARGE_128)) == 104, ""); +static_assert(BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM_CTOR(TUPLE_VERY_LARGE_128)) == 128, ""); #endif #if BOOST_PP_LIMIT_TUPLE > 128 -BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM_CTOR(TUPLE_LARGE_256)) == 142 END -BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM_CTOR(TUPLE_VERY_LARGE_256)) == 256 END +static_assert(BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM_CTOR(TUPLE_LARGE_256)) == 142, ""); +static_assert(BOOST_PP_VARIADIC_SIZE(BOOST_PP_TUPLE_REM_CTOR(TUPLE_VERY_LARGE_256)) == 256, ""); #endif // remove -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_REMOVE(TUPLE, 1)) == 5 END -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_REMOVE(TUPLE_LARGE, 17)) == 32 END -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_REMOVE(TUPLE_VERY_LARGE, 27)) == 63 END -BEGIN BOOST_PP_TUPLE_ELEM(0, BOOST_PP_TUPLE_REMOVE(TUPLE, 2)) == 0 END -BEGIN BOOST_PP_TUPLE_ELEM(29, BOOST_PP_TUPLE_REMOVE(TUPLE_LARGE, 25)) == 30 END -BEGIN BOOST_PP_TUPLE_ELEM(62, BOOST_PP_TUPLE_REMOVE(TUPLE_VERY_LARGE, 48)) == 63 END +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_REMOVE(TUPLE, 1)) == 5, ""); +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_REMOVE(TUPLE_LARGE, 17)) == 32, ""); +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_REMOVE(TUPLE_VERY_LARGE, 27)) == 63, ""); +static_assert(BOOST_PP_TUPLE_ELEM(0, BOOST_PP_TUPLE_REMOVE(TUPLE, 2)) == 0, ""); +static_assert(BOOST_PP_TUPLE_ELEM(29, BOOST_PP_TUPLE_REMOVE(TUPLE_LARGE, 25)) == 30, ""); +static_assert(BOOST_PP_TUPLE_ELEM(62, BOOST_PP_TUPLE_REMOVE(TUPLE_VERY_LARGE, 48)) == 63, ""); #if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT() -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_REMOVE(TUPLE_LARGE, 0)) == 32 END -BEGIN BOOST_PP_TUPLE_ELEM(25, BOOST_PP_TUPLE_REMOVE(TUPLE_VERY_LARGE, 0)) == 26 END +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_REMOVE(TUPLE_LARGE, 0)) == 32, ""); +static_assert(BOOST_PP_TUPLE_ELEM(25, BOOST_PP_TUPLE_REMOVE(TUPLE_VERY_LARGE, 0)) == 26, ""); #endif #if BOOST_PP_LIMIT_TUPLE > 64 -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_REMOVE(TUPLE_LARGE_128, 100)) == 103 END -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_REMOVE(TUPLE_VERY_LARGE_128, 123)) == 127 END -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_REMOVE(TUPLE_VERY_LARGE_128, 0)) == 127 END -BEGIN BOOST_PP_TUPLE_ELEM(102, BOOST_PP_TUPLE_REMOVE(TUPLE_LARGE_128, 97)) == 103 END -BEGIN BOOST_PP_TUPLE_ELEM(76, BOOST_PP_TUPLE_REMOVE(TUPLE_LARGE_128, 0)) == 77 END -BEGIN BOOST_PP_TUPLE_ELEM(119, BOOST_PP_TUPLE_REMOVE(TUPLE_VERY_LARGE_128, 115)) == 120 END +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_REMOVE(TUPLE_LARGE_128, 100)) == 103, ""); +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_REMOVE(TUPLE_VERY_LARGE_128, 123)) == 127, ""); +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_REMOVE(TUPLE_VERY_LARGE_128, 0)) == 127, ""); +static_assert(BOOST_PP_TUPLE_ELEM(102, BOOST_PP_TUPLE_REMOVE(TUPLE_LARGE_128, 97)) == 103, ""); +static_assert(BOOST_PP_TUPLE_ELEM(76, BOOST_PP_TUPLE_REMOVE(TUPLE_LARGE_128, 0)) == 77, ""); +static_assert(BOOST_PP_TUPLE_ELEM(119, BOOST_PP_TUPLE_REMOVE(TUPLE_VERY_LARGE_128, 115)) == 120, ""); #endif #if BOOST_PP_LIMIT_TUPLE > 128 -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_REMOVE(TUPLE_LARGE_256, 133)) == 141 END -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_REMOVE(TUPLE_LARGE_256, 0)) == 141 END -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_REMOVE(TUPLE_VERY_LARGE_256, 241)) == 255 END -BEGIN BOOST_PP_TUPLE_ELEM(140, BOOST_PP_TUPLE_REMOVE(TUPLE_LARGE_256, 138)) == 141 END -BEGIN BOOST_PP_TUPLE_ELEM(181, BOOST_PP_TUPLE_REMOVE(TUPLE_VERY_LARGE_256, 166)) == 182 END -BEGIN BOOST_PP_TUPLE_ELEM(236, BOOST_PP_TUPLE_REMOVE(TUPLE_VERY_LARGE_256, 0)) == 237 END +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_REMOVE(TUPLE_LARGE_256, 133)) == 141, ""); +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_REMOVE(TUPLE_LARGE_256, 0)) == 141, ""); +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_REMOVE(TUPLE_VERY_LARGE_256, 241)) == 255, ""); +static_assert(BOOST_PP_TUPLE_ELEM(140, BOOST_PP_TUPLE_REMOVE(TUPLE_LARGE_256, 138)) == 141, ""); +static_assert(BOOST_PP_TUPLE_ELEM(181, BOOST_PP_TUPLE_REMOVE(TUPLE_VERY_LARGE_256, 166)) == 182, ""); +static_assert(BOOST_PP_TUPLE_ELEM(236, BOOST_PP_TUPLE_REMOVE(TUPLE_VERY_LARGE_256, 0)) == 237, ""); #endif // replace -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE, 27, 1000)) == 64 END -BEGIN BOOST_PP_TUPLE_ELEM(0, BOOST_PP_TUPLE_REPLACE(TUPLE_NONE, 0, 71)) == 71 END -BEGIN BOOST_PP_TUPLE_ELEM(0, BOOST_PP_TUPLE_REPLACE(TUPLE, 1, 44)) == 0 END -BEGIN BOOST_PP_TUPLE_ELEM(29, BOOST_PP_TUPLE_REPLACE(TUPLE_LARGE, 29, 999)) == 999 END -BEGIN BOOST_PP_TUPLE_ELEM(38, BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE, 37, 1)) == 38 END -BEGIN BOOST_PP_TUPLE_ELEM(28, BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE, 28, 1)) == 1 END +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE, 27, 1000)) == 64, ""); +static_assert(BOOST_PP_TUPLE_ELEM(0, BOOST_PP_TUPLE_REPLACE(TUPLE_NONE, 0, 71)) == 71, ""); +static_assert(BOOST_PP_TUPLE_ELEM(0, BOOST_PP_TUPLE_REPLACE(TUPLE, 1, 44)) == 0, ""); +static_assert(BOOST_PP_TUPLE_ELEM(29, BOOST_PP_TUPLE_REPLACE(TUPLE_LARGE, 29, 999)) == 999, ""); +static_assert(BOOST_PP_TUPLE_ELEM(38, BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE, 37, 1)) == 38, ""); +static_assert(BOOST_PP_TUPLE_ELEM(28, BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE, 28, 1)) == 1, ""); #if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT() -BEGIN BOOST_PP_TUPLE_ELEM(0, BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE, 0, 64)) == 64 END -BEGIN BOOST_PP_TUPLE_ELEM(17, BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE, 0, 256)) == 17 END +static_assert(BOOST_PP_TUPLE_ELEM(0, BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE, 0, 64)) == 64, ""); +static_assert(BOOST_PP_TUPLE_ELEM(17, BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE, 0, 256)) == 17, ""); #endif #if BOOST_PP_LIMIT_TUPLE > 64 -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE_128, 93, 1000)) == 128 END -BEGIN BOOST_PP_TUPLE_ELEM(89, BOOST_PP_TUPLE_REPLACE(TUPLE_LARGE_128, 89, 111)) == 111 END -BEGIN BOOST_PP_TUPLE_ELEM(73, BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE_128, 66, 1)) == 73 END -BEGIN BOOST_PP_TUPLE_ELEM(122, BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE_128, 122, 1)) == 1 END -BEGIN BOOST_PP_TUPLE_ELEM(0, BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE_128, 0, 128)) == 128 END -BEGIN BOOST_PP_TUPLE_ELEM(95, BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE_128, 0, 128)) == 95 END +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE_128, 93, 1000)) == 128, ""); +static_assert(BOOST_PP_TUPLE_ELEM(89, BOOST_PP_TUPLE_REPLACE(TUPLE_LARGE_128, 89, 111)) == 111, ""); +static_assert(BOOST_PP_TUPLE_ELEM(73, BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE_128, 66, 1)) == 73, ""); +static_assert(BOOST_PP_TUPLE_ELEM(122, BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE_128, 122, 1)) == 1, ""); +static_assert(BOOST_PP_TUPLE_ELEM(0, BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE_128, 0, 128)) == 128, ""); +static_assert(BOOST_PP_TUPLE_ELEM(95, BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE_128, 0, 128)) == 95, ""); #endif #if BOOST_PP_LIMIT_TUPLE > 128 -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE_256, 217, 1000)) == 256 END -BEGIN BOOST_PP_TUPLE_ELEM(136, BOOST_PP_TUPLE_REPLACE(TUPLE_LARGE_256, 136, 999)) == 999 END -BEGIN BOOST_PP_TUPLE_ELEM(192, BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE_256, 185, 1)) == 192 END -BEGIN BOOST_PP_TUPLE_ELEM(237, BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE_256, 237, 1)) == 1 END -BEGIN BOOST_PP_TUPLE_ELEM(0, BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE_256, 0, 256)) == 256 END -BEGIN BOOST_PP_TUPLE_ELEM(167, BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE_256, 0, 256)) == 167 END +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE_256, 217, 1000)) == 256, ""); +static_assert(BOOST_PP_TUPLE_ELEM(136, BOOST_PP_TUPLE_REPLACE(TUPLE_LARGE_256, 136, 999)) == 999, ""); +static_assert(BOOST_PP_TUPLE_ELEM(192, BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE_256, 185, 1)) == 192, ""); +static_assert(BOOST_PP_TUPLE_ELEM(237, BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE_256, 237, 1)) == 1, ""); +static_assert(BOOST_PP_TUPLE_ELEM(0, BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE_256, 0, 256)) == 256, ""); +static_assert(BOOST_PP_TUPLE_ELEM(167, BOOST_PP_TUPLE_REPLACE(TUPLE_VERY_LARGE_256, 0, 256)) == 167, ""); #endif // size -BEGIN BOOST_PP_TUPLE_SIZE(TUPLE_NONE) == 1 END -BEGIN BOOST_PP_TUPLE_SIZE(TUPLE) == 6 END -BEGIN BOOST_PP_TUPLE_SIZE(TUPLE_LARGE) == 33 END -BEGIN BOOST_PP_TUPLE_SIZE(TUPLE_VERY_LARGE) == 64 END +static_assert(BOOST_PP_TUPLE_SIZE(TUPLE_NONE) == 1, ""); +static_assert(BOOST_PP_TUPLE_SIZE(TUPLE) == 6, ""); +static_assert(BOOST_PP_TUPLE_SIZE(TUPLE_LARGE) == 33, ""); +static_assert(BOOST_PP_TUPLE_SIZE(TUPLE_VERY_LARGE) == 64, ""); #if BOOST_PP_LIMIT_TUPLE > 64 -BEGIN BOOST_PP_TUPLE_SIZE(TUPLE_LARGE_128) == 104 END -BEGIN BOOST_PP_TUPLE_SIZE(TUPLE_VERY_LARGE_128) == 128 END +static_assert(BOOST_PP_TUPLE_SIZE(TUPLE_LARGE_128) == 104, ""); +static_assert(BOOST_PP_TUPLE_SIZE(TUPLE_VERY_LARGE_128) == 128, ""); #endif #if BOOST_PP_LIMIT_TUPLE > 128 -BEGIN BOOST_PP_TUPLE_SIZE(TUPLE_LARGE_256) == 142 END -BEGIN BOOST_PP_TUPLE_SIZE(TUPLE_VERY_LARGE_256) == 256 END +static_assert(BOOST_PP_TUPLE_SIZE(TUPLE_LARGE_256) == 142, ""); +static_assert(BOOST_PP_TUPLE_SIZE(TUPLE_VERY_LARGE_256) == 256, ""); #endif // to_array -BEGIN BOOST_PP_ARRAY_ELEM(3,BOOST_PP_TUPLE_TO_ARRAY(TUPLE)) == 3 END -BEGIN BOOST_PP_ARRAY_ELEM(29,BOOST_PP_TUPLE_TO_ARRAY(TUPLE_LARGE)) == 29 END -BEGIN BOOST_PP_ARRAY_ELEM(61,BOOST_PP_TUPLE_TO_ARRAY(TUPLE_VERY_LARGE)) == 61 END -BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_ARRAY_ELEM(0,BOOST_PP_TUPLE_TO_ARRAY(TUPLE_NONE))) == 1 END -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_TUPLE_TO_ARRAY(TUPLE_NONE)) == 1 END +static_assert(BOOST_PP_ARRAY_ELEM(3,BOOST_PP_TUPLE_TO_ARRAY(TUPLE)) == 3, ""); +static_assert(BOOST_PP_ARRAY_ELEM(29,BOOST_PP_TUPLE_TO_ARRAY(TUPLE_LARGE)) == 29, ""); +static_assert(BOOST_PP_ARRAY_ELEM(61,BOOST_PP_TUPLE_TO_ARRAY(TUPLE_VERY_LARGE)) == 61, ""); +static_assert(BOOST_PP_IS_EMPTY(BOOST_PP_ARRAY_ELEM(0,BOOST_PP_TUPLE_TO_ARRAY(TUPLE_NONE))) == 1, ""); +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_TUPLE_TO_ARRAY(TUPLE_NONE)) == 1, ""); #if BOOST_PP_LIMIT_TUPLE > 64 -BEGIN BOOST_PP_ARRAY_ELEM(65,BOOST_PP_TUPLE_TO_ARRAY(TUPLE_LARGE_128)) == 65 END -BEGIN BOOST_PP_ARRAY_ELEM(117,BOOST_PP_TUPLE_TO_ARRAY(TUPLE_VERY_LARGE_128)) == 117 END +static_assert(BOOST_PP_ARRAY_ELEM(65,BOOST_PP_TUPLE_TO_ARRAY(TUPLE_LARGE_128)) == 65, ""); +static_assert(BOOST_PP_ARRAY_ELEM(117,BOOST_PP_TUPLE_TO_ARRAY(TUPLE_VERY_LARGE_128)) == 117, ""); #endif #if BOOST_PP_LIMIT_TUPLE > 128 -BEGIN BOOST_PP_ARRAY_ELEM(131,BOOST_PP_TUPLE_TO_ARRAY(TUPLE_LARGE_256)) == 131 END -BEGIN BOOST_PP_ARRAY_ELEM(197,BOOST_PP_TUPLE_TO_ARRAY(TUPLE_VERY_LARGE_256)) == 197 END +static_assert(BOOST_PP_ARRAY_ELEM(131,BOOST_PP_TUPLE_TO_ARRAY(TUPLE_LARGE_256)) == 131, ""); +static_assert(BOOST_PP_ARRAY_ELEM(197,BOOST_PP_TUPLE_TO_ARRAY(TUPLE_VERY_LARGE_256)) == 197, ""); #endif // to_list -BEGIN BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(TUPLE), 2) == 2 END -BEGIN BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(TUPLE_LARGE), 19) == 19 END -BEGIN BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(TUPLE_VERY_LARGE), 62) == 62 END -BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(TUPLE_NONE), 0)) == 1 END -BEGIN BOOST_PP_LIST_SIZE(BOOST_PP_TUPLE_TO_LIST(TUPLE_NONE)) == 1 END +static_assert(BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(TUPLE), 2) == 2, ""); +static_assert(BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(TUPLE_LARGE), 19) == 19, ""); +static_assert(BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(TUPLE_VERY_LARGE), 62) == 62, ""); +static_assert(BOOST_PP_IS_EMPTY(BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(TUPLE_NONE), 0)) == 1, ""); +static_assert(BOOST_PP_LIST_SIZE(BOOST_PP_TUPLE_TO_LIST(TUPLE_NONE)) == 1, ""); #if BOOST_PP_LIMIT_TUPLE > 64 -BEGIN BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(TUPLE_LARGE_128), 88) == 88 END -BEGIN BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(TUPLE_VERY_LARGE_128), 113) == 113 END +static_assert(BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(TUPLE_LARGE_128), 88) == 88, ""); +static_assert(BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(TUPLE_VERY_LARGE_128), 113) == 113, ""); #endif #if BOOST_PP_LIMIT_TUPLE > 128 -BEGIN BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(TUPLE_LARGE_256), 137) == 137 END -BEGIN BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(TUPLE_VERY_LARGE_256), 235) == 235 END +static_assert(BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(TUPLE_LARGE_256), 137) == 137, ""); +static_assert(BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(TUPLE_VERY_LARGE_256), 235) == 235, ""); #endif // to_seq -BEGIN BOOST_PP_SEQ_ELEM(4,BOOST_PP_TUPLE_TO_SEQ(TUPLE)) == 4 END -BEGIN BOOST_PP_SEQ_ELEM(31,BOOST_PP_TUPLE_TO_SEQ(TUPLE_LARGE)) == 31 END -BEGIN BOOST_PP_SEQ_ELEM(55,BOOST_PP_TUPLE_TO_SEQ(TUPLE_VERY_LARGE)) == 55 END -BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_SEQ_ELEM(0,BOOST_PP_TUPLE_TO_SEQ(TUPLE_NONE))) == 1 END -BEGIN BOOST_PP_SEQ_SIZE(BOOST_PP_TUPLE_TO_SEQ(TUPLE_NONE)) == 1 END +static_assert(BOOST_PP_SEQ_ELEM(4,BOOST_PP_TUPLE_TO_SEQ(TUPLE)) == 4, ""); +static_assert(BOOST_PP_SEQ_ELEM(31,BOOST_PP_TUPLE_TO_SEQ(TUPLE_LARGE)) == 31, ""); +static_assert(BOOST_PP_SEQ_ELEM(55,BOOST_PP_TUPLE_TO_SEQ(TUPLE_VERY_LARGE)) == 55, ""); +static_assert(BOOST_PP_IS_EMPTY(BOOST_PP_SEQ_ELEM(0,BOOST_PP_TUPLE_TO_SEQ(TUPLE_NONE))) == 1, ""); +static_assert(BOOST_PP_SEQ_SIZE(BOOST_PP_TUPLE_TO_SEQ(TUPLE_NONE)) == 1, ""); #if BOOST_PP_LIMIT_TUPLE > 64 -BEGIN BOOST_PP_SEQ_ELEM(97,BOOST_PP_TUPLE_TO_SEQ(TUPLE_LARGE_128)) == 97 END -BEGIN BOOST_PP_SEQ_ELEM(123,BOOST_PP_TUPLE_TO_SEQ(TUPLE_VERY_LARGE_128)) == 123 END +static_assert(BOOST_PP_SEQ_ELEM(97,BOOST_PP_TUPLE_TO_SEQ(TUPLE_LARGE_128)) == 97, ""); +static_assert(BOOST_PP_SEQ_ELEM(123,BOOST_PP_TUPLE_TO_SEQ(TUPLE_VERY_LARGE_128)) == 123, ""); #endif #if BOOST_PP_LIMIT_TUPLE > 128 -BEGIN BOOST_PP_SEQ_ELEM(53,BOOST_PP_TUPLE_TO_SEQ(TUPLE_LARGE_256)) == 53 END -BEGIN BOOST_PP_SEQ_ELEM(181,BOOST_PP_TUPLE_TO_SEQ(TUPLE_VERY_LARGE_256)) == 181 END +static_assert(BOOST_PP_SEQ_ELEM(53,BOOST_PP_TUPLE_TO_SEQ(TUPLE_LARGE_256)) == 53, ""); +static_assert(BOOST_PP_SEQ_ELEM(181,BOOST_PP_TUPLE_TO_SEQ(TUPLE_VERY_LARGE_256)) == 181, ""); #endif diff --git a/test/tuple_elem_bug_test.cxx b/test/tuple_elem_bug_test.cxx index 217a6dcf..9f895021 100644 --- a/test/tuple_elem_bug_test.cxx +++ b/test/tuple_elem_bug_test.cxx @@ -34,5 +34,5 @@ ) \ /**/ -BEGIN TN_TEST_ONE(A,(1)) == 1 END -BEGIN TN_TEST_ONE(A,()) == 0 END +static_assert(TN_TEST_ONE(A,(1)) == 1, ""); +static_assert(TN_TEST_ONE(A,()) == 0, ""); diff --git a/test/vaopt.cxx b/test/vaopt.cxx index a0f9659d..def88cea 100644 --- a/test/vaopt.cxx +++ b/test/vaopt.cxx @@ -40,49 +40,49 @@ #define TRY_PASS_EMPTY_STD(...) BOOST_PP_VARIADIC_ELEM(0, __VA_OPT__ (0,) 1) #define TRY_PASS_EMPTY_BOOST(...) BOOST_PP_VARIADIC_ELEM(0,BOOST_PP_VA_OPT((0),(1),__VA_ARGS__)) -BEGIN TRY_PASS_EMPTY_STD(FUNC_GEN) == 0 END -BEGIN TRY_PASS_EMPTY_BOOST(FUNC_GEN) == 0 END -BEGIN TRY_PASS_EMPTY_STD(FUNC_GEN2) == 0 END -BEGIN TRY_PASS_EMPTY_BOOST(FUNC_GEN2) == 0 END -BEGIN TRY_PASS_EMPTY_STD(FUNC_GEN3) == 0 END -BEGIN TRY_PASS_EMPTY_BOOST(FUNC_GEN3) == 0 END -BEGIN TRY_PASS_EMPTY_STD(FUNC_GEN4) == 0 END -BEGIN TRY_PASS_EMPTY_BOOST(FUNC_GEN4) == 0 END -BEGIN TRY_PASS_EMPTY_STD(FUNC_GEN5) == 0 END -BEGIN TRY_PASS_EMPTY_BOOST(FUNC_GEN5) == 0 END -BEGIN TRY_PASS_EMPTY_STD(FUNC_GEN8) == 0 END -BEGIN TRY_PASS_EMPTY_BOOST(FUNC_GEN8) == 0 END -BEGIN TRY_PASS_EMPTY_STD(FUNC_GEN9) == 0 END -BEGIN TRY_PASS_EMPTY_BOOST(FUNC_GEN9) == 0 END -BEGIN TRY_PASS_EMPTY_STD(FUNC_GEN10) == 0 END -BEGIN TRY_PASS_EMPTY_BOOST(FUNC_GEN10) == 0 END -BEGIN TRY_PASS_EMPTY_STD(BOOST_PP_EMPTY()) == 1 END -BEGIN TRY_PASS_EMPTY_BOOST(BOOST_PP_EMPTY()) == 1 END -BEGIN TRY_PASS_EMPTY_STD(DATA BOOST_PP_EMPTY()) == 1 END -BEGIN TRY_PASS_EMPTY_BOOST(DATA BOOST_PP_EMPTY()) == 1 END -BEGIN TRY_PASS_EMPTY_STD() == 1 END -BEGIN TRY_PASS_EMPTY_BOOST() == 1 END -BEGIN TRY_PASS_EMPTY_STD(DATA) == 1 END -BEGIN TRY_PASS_EMPTY_BOOST(DATA) == 1 END -BEGIN TRY_PASS_EMPTY_STD(x BOOST_PP_EMPTY()) == 0 END -BEGIN TRY_PASS_EMPTY_BOOST(x BOOST_PP_EMPTY()) == 0 END -BEGIN TRY_PASS_EMPTY_STD(OBJECT BOOST_PP_EMPTY()) == 1 END -BEGIN TRY_PASS_EMPTY_BOOST(OBJECT BOOST_PP_EMPTY()) == 1 END -BEGIN TRY_PASS_EMPTY_STD(FUNC(z) BOOST_PP_EMPTY()) == 1 END -BEGIN TRY_PASS_EMPTY_BOOST(FUNC(z) BOOST_PP_EMPTY()) == 1 END -BEGIN TRY_PASS_EMPTY_STD(FUNC_GEN6) == 0 END -BEGIN TRY_PASS_EMPTY_BOOST(FUNC_GEN6) == 0 END -BEGIN TRY_PASS_EMPTY_STD(FUNC_GEN7) == 0 END -BEGIN TRY_PASS_EMPTY_BOOST(FUNC_GEN7) == 0 END -BEGIN TRY_PASS_EMPTY_STD(NAME) == 0 END -BEGIN TRY_PASS_EMPTY_BOOST(NAME) == 0 END -BEGIN TRY_PASS_EMPTY_STD(ATUPLE) == 0 END -BEGIN TRY_PASS_EMPTY_BOOST(ATUPLE) == 0 END -BEGIN TRY_PASS_EMPTY_STD(ATUPLE_PLUS) == 0 END -BEGIN TRY_PASS_EMPTY_BOOST(ATUPLE_PLUS) == 0 END +static_assert(TRY_PASS_EMPTY_STD(FUNC_GEN) == 0, ""); +static_assert(TRY_PASS_EMPTY_BOOST(FUNC_GEN) == 0, ""); +static_assert(TRY_PASS_EMPTY_STD(FUNC_GEN2) == 0, ""); +static_assert(TRY_PASS_EMPTY_BOOST(FUNC_GEN2) == 0, ""); +static_assert(TRY_PASS_EMPTY_STD(FUNC_GEN3) == 0, ""); +static_assert(TRY_PASS_EMPTY_BOOST(FUNC_GEN3) == 0, ""); +static_assert(TRY_PASS_EMPTY_STD(FUNC_GEN4) == 0, ""); +static_assert(TRY_PASS_EMPTY_BOOST(FUNC_GEN4) == 0, ""); +static_assert(TRY_PASS_EMPTY_STD(FUNC_GEN5) == 0, ""); +static_assert(TRY_PASS_EMPTY_BOOST(FUNC_GEN5) == 0, ""); +static_assert(TRY_PASS_EMPTY_STD(FUNC_GEN8) == 0, ""); +static_assert(TRY_PASS_EMPTY_BOOST(FUNC_GEN8) == 0, ""); +static_assert(TRY_PASS_EMPTY_STD(FUNC_GEN9) == 0, ""); +static_assert(TRY_PASS_EMPTY_BOOST(FUNC_GEN9) == 0, ""); +static_assert(TRY_PASS_EMPTY_STD(FUNC_GEN10) == 0, ""); +static_assert(TRY_PASS_EMPTY_BOOST(FUNC_GEN10) == 0, ""); +static_assert(TRY_PASS_EMPTY_STD(BOOST_PP_EMPTY()) == 1, ""); +static_assert(TRY_PASS_EMPTY_BOOST(BOOST_PP_EMPTY()) == 1, ""); +static_assert(TRY_PASS_EMPTY_STD(DATA BOOST_PP_EMPTY()) == 1, ""); +static_assert(TRY_PASS_EMPTY_BOOST(DATA BOOST_PP_EMPTY()) == 1, ""); +static_assert(TRY_PASS_EMPTY_STD() == 1, ""); +static_assert(TRY_PASS_EMPTY_BOOST() == 1, ""); +static_assert(TRY_PASS_EMPTY_STD(DATA) == 1, ""); +static_assert(TRY_PASS_EMPTY_BOOST(DATA) == 1, ""); +static_assert(TRY_PASS_EMPTY_STD(x BOOST_PP_EMPTY()) == 0, ""); +static_assert(TRY_PASS_EMPTY_BOOST(x BOOST_PP_EMPTY()) == 0, ""); +static_assert(TRY_PASS_EMPTY_STD(OBJECT BOOST_PP_EMPTY()) == 1, ""); +static_assert(TRY_PASS_EMPTY_BOOST(OBJECT BOOST_PP_EMPTY()) == 1, ""); +static_assert(TRY_PASS_EMPTY_STD(FUNC(z) BOOST_PP_EMPTY()) == 1, ""); +static_assert(TRY_PASS_EMPTY_BOOST(FUNC(z) BOOST_PP_EMPTY()) == 1, ""); +static_assert(TRY_PASS_EMPTY_STD(FUNC_GEN6) == 0, ""); +static_assert(TRY_PASS_EMPTY_BOOST(FUNC_GEN6) == 0, ""); +static_assert(TRY_PASS_EMPTY_STD(FUNC_GEN7) == 0, ""); +static_assert(TRY_PASS_EMPTY_BOOST(FUNC_GEN7) == 0, ""); +static_assert(TRY_PASS_EMPTY_STD(NAME) == 0, ""); +static_assert(TRY_PASS_EMPTY_BOOST(NAME) == 0, ""); +static_assert(TRY_PASS_EMPTY_STD(ATUPLE) == 0, ""); +static_assert(TRY_PASS_EMPTY_BOOST(ATUPLE) == 0, ""); +static_assert(TRY_PASS_EMPTY_STD(ATUPLE_PLUS) == 0, ""); +static_assert(TRY_PASS_EMPTY_BOOST(ATUPLE_PLUS) == 0, ""); # else -BEGIN 1 == 1 END +static_assert(1 == 1, ""); # endif diff --git a/test/variadic.cxx b/test/variadic.cxx index 732ea78a..a4e4b1ac 100644 --- a/test/variadic.cxx +++ b/test/variadic.cxx @@ -58,69 +58,69 @@ #endif -BEGIN BOOST_PP_VARIADIC_ELEM(4,VDATA) == 4 END -BEGIN BOOST_PP_VARIADIC_ELEM(6,7,11,3,8,14,85,56,92,165) == 56 END -BEGIN BOOST_PP_VARIADIC_ELEM(29,VDATA_LARGE) == 29 END -BEGIN BOOST_PP_VARIADIC_ELEM(57,VDATA_VERY_LARGE) == 57 END -BEGIN BOOST_PP_VARIADIC_ELEM(35, 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 END -BEGIN BOOST_PP_VARIADIC_SIZE(VDATA) == 7 END -BEGIN BOOST_PP_VARIADIC_SIZE(7,11,3,8,14,85,56,92,165) == 9 END -BEGIN BOOST_PP_VARIADIC_SIZE(VDATA_LARGE) == 33 END -BEGIN BOOST_PP_VARIADIC_SIZE(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 -BEGIN BOOST_PP_VARIADIC_SIZE(VDATA_VERY_LARGE) == 64 END +static_assert(BOOST_PP_VARIADIC_ELEM(4,VDATA) == 4, ""); +static_assert(BOOST_PP_VARIADIC_ELEM(6,7,11,3,8,14,85,56,92,165) == 56, ""); +static_assert(BOOST_PP_VARIADIC_ELEM(29,VDATA_LARGE) == 29, ""); +static_assert(BOOST_PP_VARIADIC_ELEM(57,VDATA_VERY_LARGE) == 57, ""); +static_assert(BOOST_PP_VARIADIC_ELEM(35, 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, ""); +static_assert(BOOST_PP_VARIADIC_SIZE(VDATA) == 7, ""); +static_assert(BOOST_PP_VARIADIC_SIZE(7,11,3,8,14,85,56,92,165) == 9, ""); +static_assert(BOOST_PP_VARIADIC_SIZE(VDATA_LARGE) == 33, ""); +static_assert(BOOST_PP_VARIADIC_SIZE(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, ""); +static_assert(BOOST_PP_VARIADIC_SIZE(VDATA_VERY_LARGE) == 64, ""); #if BOOST_PP_VARIADIC_HAS_OPT() -BEGIN BOOST_PP_VARIADIC_SIZE(VDATA_EMPTY) == 0 END -BEGIN BOOST_PP_VARIADIC_SIZE() == 0 END +static_assert(BOOST_PP_VARIADIC_SIZE(VDATA_EMPTY) == 0, ""); +static_assert(BOOST_PP_VARIADIC_SIZE() == 0, ""); #endif -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_VARIADIC_TO_ARRAY(VDATA)) == 7 END -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_VARIADIC_TO_ARRAY(VDATA_VERY_LARGE)) == 64 END -BEGIN BOOST_PP_ARRAY_ELEM(4,BOOST_PP_VARIADIC_TO_ARRAY(7,11,3,8,14,85,56,92,165)) == 14 END -BEGIN BOOST_PP_ARRAY_ELEM(30,BOOST_PP_VARIADIC_TO_ARRAY(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)) == 30 END -BEGIN BOOST_PP_LIST_AT(BOOST_PP_VARIADIC_TO_LIST(VDATA),3) == 3 END -BEGIN BOOST_PP_LIST_AT(BOOST_PP_VARIADIC_TO_LIST(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),49) == 49 END -BEGIN BOOST_PP_LIST_SIZE(BOOST_PP_VARIADIC_TO_LIST(7,11,3,8,14,85,56,92,165)) == 9 END -BEGIN BOOST_PP_LIST_SIZE(BOOST_PP_VARIADIC_TO_LIST(VDATA_LARGE)) == 33 END -BEGIN BOOST_PP_SEQ_ELEM(5,BOOST_PP_VARIADIC_TO_SEQ(VDATA)) == 5 END -BEGIN BOOST_PP_SEQ_ELEM(16,BOOST_PP_VARIADIC_TO_SEQ(VDATA_LARGE)) == 16 END -BEGIN BOOST_PP_SEQ_SIZE(BOOST_PP_VARIADIC_TO_SEQ(3,78,22,11,3)) == 5 END -BEGIN BOOST_PP_SEQ_SIZE(BOOST_PP_VARIADIC_TO_SEQ(VDATA_VERY_LARGE)) == 64 END -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_VARIADIC_TO_TUPLE(VDATA)) == 7 END -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_VARIADIC_TO_TUPLE(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 -BEGIN BOOST_PP_TUPLE_ELEM(8,BOOST_PP_VARIADIC_TO_TUPLE(7,11,3,8,14,85,56,92,165)) == 165 END -BEGIN BOOST_PP_TUPLE_ELEM(27,BOOST_PP_VARIADIC_TO_TUPLE(VDATA_LARGE)) == 27 END +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_VARIADIC_TO_ARRAY(VDATA)) == 7, ""); +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_VARIADIC_TO_ARRAY(VDATA_VERY_LARGE)) == 64, ""); +static_assert(BOOST_PP_ARRAY_ELEM(4,BOOST_PP_VARIADIC_TO_ARRAY(7,11,3,8,14,85,56,92,165)) == 14, ""); +static_assert(BOOST_PP_ARRAY_ELEM(30,BOOST_PP_VARIADIC_TO_ARRAY(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)) == 30, ""); +static_assert(BOOST_PP_LIST_AT(BOOST_PP_VARIADIC_TO_LIST(VDATA),3) == 3, ""); +static_assert(BOOST_PP_LIST_AT(BOOST_PP_VARIADIC_TO_LIST(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),49) == 49, ""); +static_assert(BOOST_PP_LIST_SIZE(BOOST_PP_VARIADIC_TO_LIST(7,11,3,8,14,85,56,92,165)) == 9, ""); +static_assert(BOOST_PP_LIST_SIZE(BOOST_PP_VARIADIC_TO_LIST(VDATA_LARGE)) == 33, ""); +static_assert(BOOST_PP_SEQ_ELEM(5,BOOST_PP_VARIADIC_TO_SEQ(VDATA)) == 5, ""); +static_assert(BOOST_PP_SEQ_ELEM(16,BOOST_PP_VARIADIC_TO_SEQ(VDATA_LARGE)) == 16, ""); +static_assert(BOOST_PP_SEQ_SIZE(BOOST_PP_VARIADIC_TO_SEQ(3,78,22,11,3)) == 5, ""); +static_assert(BOOST_PP_SEQ_SIZE(BOOST_PP_VARIADIC_TO_SEQ(VDATA_VERY_LARGE)) == 64, ""); +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_VARIADIC_TO_TUPLE(VDATA)) == 7, ""); +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_VARIADIC_TO_TUPLE(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, ""); +static_assert(BOOST_PP_TUPLE_ELEM(8,BOOST_PP_VARIADIC_TO_TUPLE(7,11,3,8,14,85,56,92,165)) == 165, ""); +static_assert(BOOST_PP_TUPLE_ELEM(27,BOOST_PP_VARIADIC_TO_TUPLE(VDATA_LARGE)) == 27, ""); #if BOOST_PP_LIMIT_VARIADIC > 64 -BEGIN BOOST_PP_VARIADIC_ELEM(47,VDATA_LARGE_128) == 47 END -BEGIN BOOST_PP_VARIADIC_ELEM(81,VDATA_LARGE_128) == 81 END -BEGIN BOOST_PP_VARIADIC_ELEM(29,VDATA_VERY_LARGE_128) == 29 END -BEGIN BOOST_PP_VARIADIC_ELEM(112,VDATA_VERY_LARGE_128) == 112 END -BEGIN BOOST_PP_VARIADIC_SIZE(VDATA_LARGE_128) == 96 END -BEGIN BOOST_PP_VARIADIC_SIZE(VDATA_VERY_LARGE_128) == 128 END +static_assert(BOOST_PP_VARIADIC_ELEM(47,VDATA_LARGE_128) == 47, ""); +static_assert(BOOST_PP_VARIADIC_ELEM(81,VDATA_LARGE_128) == 81, ""); +static_assert(BOOST_PP_VARIADIC_ELEM(29,VDATA_VERY_LARGE_128) == 29, ""); +static_assert(BOOST_PP_VARIADIC_ELEM(112,VDATA_VERY_LARGE_128) == 112, ""); +static_assert(BOOST_PP_VARIADIC_SIZE(VDATA_LARGE_128) == 96, ""); +static_assert(BOOST_PP_VARIADIC_SIZE(VDATA_VERY_LARGE_128) == 128, ""); #if BOOST_PP_LIMIT_TUPLE > 64 -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_VARIADIC_TO_ARRAY(VDATA_LARGE_128)) == 96 END -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_VARIADIC_TO_ARRAY(VDATA_VERY_LARGE_128)) == 128 END -BEGIN BOOST_PP_ARRAY_ELEM(83,BOOST_PP_VARIADIC_TO_ARRAY(VDATA_LARGE_128)) == 83 END -BEGIN BOOST_PP_ARRAY_ELEM(117,BOOST_PP_VARIADIC_TO_ARRAY(VDATA_VERY_LARGE_128)) == 117 END +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_VARIADIC_TO_ARRAY(VDATA_LARGE_128)) == 96, ""); +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_VARIADIC_TO_ARRAY(VDATA_VERY_LARGE_128)) == 128, ""); +static_assert(BOOST_PP_ARRAY_ELEM(83,BOOST_PP_VARIADIC_TO_ARRAY(VDATA_LARGE_128)) == 83, ""); +static_assert(BOOST_PP_ARRAY_ELEM(117,BOOST_PP_VARIADIC_TO_ARRAY(VDATA_VERY_LARGE_128)) == 117, ""); #endif -BEGIN BOOST_PP_LIST_AT(BOOST_PP_VARIADIC_TO_LIST(VDATA_LARGE_128),79) == 79 END -BEGIN BOOST_PP_LIST_SIZE(BOOST_PP_VARIADIC_TO_LIST(VDATA_VERY_LARGE_128)) == 128 END -BEGIN BOOST_PP_SEQ_ELEM(113,BOOST_PP_VARIADIC_TO_SEQ(VDATA_VERY_LARGE_128)) == 113 END -BEGIN BOOST_PP_SEQ_ELEM(82,BOOST_PP_VARIADIC_TO_SEQ(VDATA_LARGE_128)) == 82 END -BEGIN BOOST_PP_SEQ_SIZE(BOOST_PP_VARIADIC_TO_SEQ(VDATA_LARGE_128)) == 96 END +static_assert(BOOST_PP_LIST_AT(BOOST_PP_VARIADIC_TO_LIST(VDATA_LARGE_128),79) == 79, ""); +static_assert(BOOST_PP_LIST_SIZE(BOOST_PP_VARIADIC_TO_LIST(VDATA_VERY_LARGE_128)) == 128, ""); +static_assert(BOOST_PP_SEQ_ELEM(113,BOOST_PP_VARIADIC_TO_SEQ(VDATA_VERY_LARGE_128)) == 113, ""); +static_assert(BOOST_PP_SEQ_ELEM(82,BOOST_PP_VARIADIC_TO_SEQ(VDATA_LARGE_128)) == 82, ""); +static_assert(BOOST_PP_SEQ_SIZE(BOOST_PP_VARIADIC_TO_SEQ(VDATA_LARGE_128)) == 96, ""); #if BOOST_PP_LIMIT_TUPLE > 64 -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_VARIADIC_TO_TUPLE(VDATA_VERY_LARGE_128)) == 128 END -BEGIN BOOST_PP_TUPLE_ELEM(77,BOOST_PP_VARIADIC_TO_TUPLE(VDATA_LARGE_128)) == 77 END +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_VARIADIC_TO_TUPLE(VDATA_VERY_LARGE_128)) == 128, ""); +static_assert(BOOST_PP_TUPLE_ELEM(77,BOOST_PP_VARIADIC_TO_TUPLE(VDATA_LARGE_128)) == 77, ""); #endif @@ -128,35 +128,35 @@ BEGIN BOOST_PP_TUPLE_ELEM(77,BOOST_PP_VARIADIC_TO_TUPLE(VDATA_LARGE_128)) == 77 #if BOOST_PP_LIMIT_VARIADIC > 128 -BEGIN BOOST_PP_VARIADIC_ELEM(47,VDATA_LARGE_256) == 47 END -BEGIN BOOST_PP_VARIADIC_ELEM(110,VDATA_LARGE_256) == 110 END -BEGIN BOOST_PP_VARIADIC_ELEM(135,VDATA_LARGE_256) == 135 END -BEGIN BOOST_PP_VARIADIC_ELEM(36,VDATA_VERY_LARGE_256) == 36 END -BEGIN BOOST_PP_VARIADIC_ELEM(95,VDATA_VERY_LARGE_256) == 95 END -BEGIN BOOST_PP_VARIADIC_ELEM(161,VDATA_VERY_LARGE_256) == 161 END -BEGIN BOOST_PP_VARIADIC_ELEM(217,VDATA_VERY_LARGE_256) == 217 END -BEGIN BOOST_PP_VARIADIC_SIZE(VDATA_LARGE_256) == 139 END -BEGIN BOOST_PP_VARIADIC_SIZE(VDATA_VERY_LARGE_256) == 256 END +static_assert(BOOST_PP_VARIADIC_ELEM(47,VDATA_LARGE_256) == 47, ""); +static_assert(BOOST_PP_VARIADIC_ELEM(110,VDATA_LARGE_256) == 110, ""); +static_assert(BOOST_PP_VARIADIC_ELEM(135,VDATA_LARGE_256) == 135, ""); +static_assert(BOOST_PP_VARIADIC_ELEM(36,VDATA_VERY_LARGE_256) == 36, ""); +static_assert(BOOST_PP_VARIADIC_ELEM(95,VDATA_VERY_LARGE_256) == 95, ""); +static_assert(BOOST_PP_VARIADIC_ELEM(161,VDATA_VERY_LARGE_256) == 161, ""); +static_assert(BOOST_PP_VARIADIC_ELEM(217,VDATA_VERY_LARGE_256) == 217, ""); +static_assert(BOOST_PP_VARIADIC_SIZE(VDATA_LARGE_256) == 139, ""); +static_assert(BOOST_PP_VARIADIC_SIZE(VDATA_VERY_LARGE_256) == 256, ""); #if BOOST_PP_LIMIT_TUPLE > 128 -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_VARIADIC_TO_ARRAY(VDATA_LARGE_256)) == 139 END -BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_VARIADIC_TO_ARRAY(VDATA_VERY_LARGE_256)) == 256 END -BEGIN BOOST_PP_ARRAY_ELEM(133,BOOST_PP_VARIADIC_TO_ARRAY(VDATA_LARGE_256)) == 133 END -BEGIN BOOST_PP_ARRAY_ELEM(203,BOOST_PP_VARIADIC_TO_ARRAY(VDATA_VERY_LARGE_256)) == 203 END +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_VARIADIC_TO_ARRAY(VDATA_LARGE_256)) == 139, ""); +static_assert(BOOST_PP_ARRAY_SIZE(BOOST_PP_VARIADIC_TO_ARRAY(VDATA_VERY_LARGE_256)) == 256, ""); +static_assert(BOOST_PP_ARRAY_ELEM(133,BOOST_PP_VARIADIC_TO_ARRAY(VDATA_LARGE_256)) == 133, ""); +static_assert(BOOST_PP_ARRAY_ELEM(203,BOOST_PP_VARIADIC_TO_ARRAY(VDATA_VERY_LARGE_256)) == 203, ""); #endif -BEGIN BOOST_PP_LIST_AT(BOOST_PP_VARIADIC_TO_LIST(VDATA_LARGE_256),137) == 137 END -BEGIN BOOST_PP_LIST_SIZE(BOOST_PP_VARIADIC_TO_LIST(VDATA_VERY_LARGE_256)) == 256 END -BEGIN BOOST_PP_SEQ_ELEM(212,BOOST_PP_VARIADIC_TO_SEQ(VDATA_VERY_LARGE_256)) == 212 END -BEGIN BOOST_PP_SEQ_ELEM(129,BOOST_PP_VARIADIC_TO_SEQ(VDATA_LARGE_256)) == 129 END -BEGIN BOOST_PP_SEQ_SIZE(BOOST_PP_VARIADIC_TO_SEQ(VDATA_LARGE_256)) == 139 END +static_assert(BOOST_PP_LIST_AT(BOOST_PP_VARIADIC_TO_LIST(VDATA_LARGE_256),137) == 137, ""); +static_assert(BOOST_PP_LIST_SIZE(BOOST_PP_VARIADIC_TO_LIST(VDATA_VERY_LARGE_256)) == 256, ""); +static_assert(BOOST_PP_SEQ_ELEM(212,BOOST_PP_VARIADIC_TO_SEQ(VDATA_VERY_LARGE_256)) == 212, ""); +static_assert(BOOST_PP_SEQ_ELEM(129,BOOST_PP_VARIADIC_TO_SEQ(VDATA_LARGE_256)) == 129, ""); +static_assert(BOOST_PP_SEQ_SIZE(BOOST_PP_VARIADIC_TO_SEQ(VDATA_LARGE_256)) == 139, ""); #if BOOST_PP_LIMIT_TUPLE > 128 -BEGIN BOOST_PP_TUPLE_SIZE(BOOST_PP_VARIADIC_TO_TUPLE(VDATA_VERY_LARGE_256)) == 256 END -BEGIN BOOST_PP_TUPLE_ELEM(133,BOOST_PP_VARIADIC_TO_TUPLE(VDATA_LARGE_256)) == 133 END +static_assert(BOOST_PP_TUPLE_SIZE(BOOST_PP_VARIADIC_TO_TUPLE(VDATA_VERY_LARGE_256)) == 256, ""); +static_assert(BOOST_PP_TUPLE_ELEM(133,BOOST_PP_VARIADIC_TO_TUPLE(VDATA_LARGE_256)) == 133, ""); #endif