Adding upstream version 14.2.21.upstream/14.2.21upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

11 files changed, 3825 insertions, 0 deletions

diff --git a/src/boost/libs/dynamic_bitset/test/Jamfile.v2 b/src/boost/libs/dynamic_bitset/test/Jamfile.v2
new file mode 100644
index 00000000..91f91def
--- /dev/null
+++ b/src/boost/libs/dynamic_bitset/test/Jamfile.v2
@@ -0,0 +1,42 @@
+#
+#              Copyright Vladimir Prus 2004
+#
+# 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)
+#
+
+import os ;
+
+# import rules for testing conditional on config file variables
+import ../../config/checks/config : requires ;
+
+test-suite dynamic_bitset :
+
+    [ run dyn_bitset_unit_tests1.cpp : : : <library>/boost/system//boost_system ]
+    [ run dyn_bitset_unit_tests2.cpp : : : <library>/boost/system//boost_system ]
+    [ run dyn_bitset_unit_tests3.cpp : : : <library>/boost/system//boost_system ]
+    [ run dyn_bitset_unit_tests4.cpp : : : <library>/boost/filesystem//boost_filesystem
+                                           <library>/boost/system//boost_system ]
+    [ run test_ambiguous_set.cpp ]
+    [ run test_lowest_bit.cpp ]
+
+    [ run test_boost_hash.cpp ]
+    [ run test_std_hash.cpp          : : : [ requires cxx11_hdr_unordered_set ] ] 
+
+    [ compile-fail test_std_hash.cpp : [ requires cxx11_hdr_unordered_set ]
+                                       <define>BOOST_DYNAMIC_BITSET_NO_STD_HASH
+                                     : test_std_hash_disabled ]
+    ;
+
+# due to https://github.com/boostorg/serialization/issues/108
+if ! [ os.environ UBSAN_OPTIONS ]
+{
+  test-suite dynamic_bitset_serialization :
+
+    [ run dyn_bitset_unit_tests5.cpp
+       : : : <define>_SCL_SECURE_NO_WARNINGS=1
+             <library>/boost/serialization//boost_serialization
+             <library>/boost/system//boost_system ]
+    ;
+}
diff --git a/src/boost/libs/dynamic_bitset/test/bitset_test.hpp b/src/boost/libs/dynamic_bitset/test/bitset_test.hpp
new file mode 100644
index 00000000..669aca5b
--- /dev/null
+++ b/src/boost/libs/dynamic_bitset/test/bitset_test.hpp
@@ -0,0 +1,1454 @@
+// -----------------------------------------------------------
+//              Copyright (c) 2001 Jeremy Siek
+//        Copyright (c) 2003-2006, 2008 Gennaro Prota
+//             Copyright (c) 2014 Ahmed Charles
+//            Copyright (c) 2014 Riccardo Marcangelo
+//             Copyright (c) 2018 Evgeny Shulgin
+//
+// 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)
+//
+// -----------------------------------------------------------
+
+#ifndef BOOST_BITSET_TEST_HPP_GP_20040319
+#define BOOST_BITSET_TEST_HPP_GP_20040319
+
+#include <boost/config.hpp>
+#if !defined (BOOST_NO_STD_LOCALE)
+# include <locale>
+#endif
+
+#include <vector>
+#include <fstream> // used for operator<<
+#include <string>    // for (basic_string and) getline()
+#include <algorithm> // for std::min
+#include <assert.h>  // <cassert> is sometimes macro-guarded :-(
+
+#include <boost/limits.hpp>
+#include <boost/dynamic_bitset/dynamic_bitset.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/filesystem.hpp>
+
+template <typename Block>
+inline bool nth_bit(Block num, std::size_t n)
+{
+#ifndef NDEBUG
+#ifdef __BORLANDC__
+  // Borland deduces Block as a const qualified type,
+  // and thus finds numeric_limits<Block> to be zero :(
+  //  (though not directly relevant here, see also
+  //   lib issue 559)
+  int block_width = sizeof(Block) * CHAR_BIT;
+#else
+  int block_width = std::numeric_limits<Block>::digits;
+#endif
+  assert(n < (std::size_t) block_width);
+#endif
+
+  return (num >> n) & 1;
+}
+
+// A long, 'irregular', string useful for various tests
+std::string get_long_string()
+{
+  const char * const p =
+  //    6         5         4         3         2         1
+  // 3210987654321098765432109876543210987654321098765432109876543210
+    "1110011100011110000011110000011111110000000000000110101110000000"
+    "1010101000011100011101010111110000101011111000001111100011100011"
+    "0000000110000001000000111100000111100010101111111000000011100011"
+    "1111111111111111111111111111111111111111111111111111111111111100"
+    "1000001100000001111111111111110000000011111000111100001010100000"
+    "101000111100011010101110011011000000010";
+
+  return std::string(p);
+}
+
+class scoped_temp_file
+{
+public:
+  scoped_temp_file()
+    : m_path(boost::filesystem::unique_path())
+  {
+  }
+
+  ~scoped_temp_file()
+  {
+    boost::filesystem::remove(m_path);
+  }
+
+  const boost::filesystem::path& path() const
+  {
+    return m_path;
+  }
+
+private:
+  boost::filesystem::path m_path;
+};
+
+#if defined BOOST_OLD_IOSTREAMS || defined BOOST_NO_STD_LOCALE
+template <typename Stream>
+bool is_one_or_zero(const Stream & /*s*/, char c)
+{
+  return c == '1' || c == '0';
+}
+template <typename Stream>
+bool is_white_space(const Stream & /*s*/, char c)
+{
+  return std::isspace(c);
+}
+#else
+template <typename Stream, typename Ch>
+bool is_one_or_zero(const Stream& s, Ch c)
+{
+  typedef typename Stream::traits_type Tr;
+  const Ch zero = s.widen('0');
+  const Ch one  = s.widen('1');
+
+  return Tr::eq(c, one) || Tr::eq(c, zero);
+}
+template <typename Stream, typename Ch>
+bool is_white_space(const Stream & s, Ch c)
+{
+  // NOTE: the using directive is to satisfy Borland 5.6.4
+  //       with its own library (STLport), which doesn't
+  //       like std::isspace(c, loc)
+  using namespace std;
+  return isspace(c, s.getloc());
+}
+#endif // defined BOOST_OLD_IOSTREAMS
+
+
+template <typename Stream>
+bool has_flags(const Stream& s, std::ios::iostate flags)
+{
+  return (s.rdstate() & flags) != std::ios::goodbit;
+}
+
+
+// constructors
+//   default (can't do this generically)
+
+template <typename Bitset>
+struct bitset_test {
+
+  typedef typename Bitset::block_type Block;
+  BOOST_STATIC_CONSTANT(int, bits_per_block = Bitset::bits_per_block);
+
+  // from unsigned long
+  //
+  // Note: this is templatized so that we check that the do-the-right-thing
+  // constructor dispatch is working correctly.
+  //
+  template <typename NumBits, typename Value>
+  static void from_unsigned_long(NumBits num_bits, Value num)
+  {
+    // An object of size sz = num_bits is constructed:
+    // - the first m bit positions are initialized to the corresponding
+    //   bit values in num (m being the smaller of sz and ulong_width)
+    //
+    // - any remaining bit positions are initialized to zero
+    //
+
+    Bitset b(static_cast<typename Bitset::size_type>(num_bits), static_cast<unsigned long>(num));
+
+    // OK, we can now cast to size_type
+    typedef typename Bitset::size_type size_type;
+    const size_type sz = static_cast<size_type>(num_bits);
+
+    BOOST_TEST(b.size() == sz);
+
+    const std::size_t ulong_width = std::numeric_limits<unsigned long>::digits;
+    size_type m = sz;
+    if (ulong_width < sz)
+        m = ulong_width;
+
+    size_type i = 0;
+    for ( ; i < m; ++i)
+      BOOST_TEST(b.test(i) == nth_bit(static_cast<unsigned long>(num), i));
+    for ( ; i < sz; ++i)
+      BOOST_TEST(b.test(i) == 0);
+  }
+
+  // from string
+  //
+  // Note: The corresponding function in dynamic_bitset (constructor
+  // from a string) has several default arguments. Actually we don't
+  // test the correct working of those defaults here (except for the
+  // default of num_bits). I'm not sure what to do in this regard.
+  //
+  // Note2: the default argument expression for num_bits doesn't use
+  //        static_cast, to avoid a gcc 2.95.3 'sorry, not implemented'
+  //
+  template <typename Ch, typename Tr, typename Al>
+  static void from_string(const std::basic_string<Ch, Tr, Al>& str,
+                          std::size_t pos,
+                          std::size_t max_char,
+                          std::size_t num_bits = (std::size_t)(-1))
+  {
+
+      std::size_t rlen = (std::min)(max_char, str.size() - pos);
+
+      // The resulting size N of the bitset is num_bits, if
+      // that is different from the default arg, rlen otherwise.
+      // Put M = the smaller of N and rlen, then character
+      // position pos + M - 1 corresponds to bit position zero.
+      // Subsequent decreasing character positions correspond to
+      // increasing bit positions.
+
+      const bool size_upon_string = num_bits == (std::size_t)(-1);
+      Bitset b = size_upon_string ?
+                    Bitset(str, pos, max_char)
+                  : Bitset(str, pos, max_char, num_bits);
+
+      const std::size_t actual_size = size_upon_string? rlen : num_bits;
+      BOOST_TEST(b.size() == actual_size);
+      std::size_t m = (std::min)(num_bits, rlen);
+      std::size_t j;
+      for (j = 0; j < m; ++j)
+          BOOST_TEST(b[j] == (str[pos + m - 1 - j] == '1'));
+      // If M < N, remaining bit positions are zero
+      for (; j < actual_size; ++j)
+          BOOST_TEST(b[j] == 0);
+
+
+  }
+
+  static void to_block_range(const Bitset & b /*, BlockOutputIterator result*/)
+  {
+    typedef typename Bitset::size_type size_type;
+
+    Block sentinel = 0xF0;
+    int s = 8; // number of sentinels (must be *even*)
+    int offset = s/2;
+    std::vector<Block> v(b.num_blocks() + s, sentinel);
+
+    boost::to_block_range(b, v.begin() + offset);
+
+    assert(v.size() >= (size_type)s && (s >= 2) && (s % 2 == 0));
+    // check sentinels at both ends
+    for(int i = 0; i < s/2; ++i) {
+        BOOST_TEST(v[i] == sentinel);
+        BOOST_TEST(v[v.size()-1-i] == sentinel);
+    }
+
+    typename std::vector<Block>::const_iterator p = v.begin() + offset;
+    for(size_type n = 0; n < b.num_blocks(); ++n, ++p) {
+      typename Bitset::block_width_type i = 0;
+      for(; i < bits_per_block; ++i) {
+        size_type bit = n * bits_per_block + i;
+        BOOST_TEST(nth_bit(*p, i) == (bit < b.size()? b[bit] : 0));
+      }
+    }
+  }
+
+  // TODO from_block_range (below) should be splitted
+
+  // PRE: std::equal(first1, last1, first2) == true
+  static void from_block_range(const std::vector<Block>& blocks)
+  {
+    { // test constructor from block range
+      Bitset bset(blocks.begin(), blocks.end());
+      std::size_t n = blocks.size();
+      for (std::size_t b = 0; b < n; ++b) {
+        typename Bitset::block_width_type i = 0;
+        for (; i < bits_per_block; ++i) {
+          std::size_t bit = b * bits_per_block + i;
+          BOOST_TEST(bset[bit] == nth_bit(blocks[b], i));
+        }
+      }
+      BOOST_TEST(bset.size() == n * bits_per_block);
+    }
+    { // test boost::from_block_range
+      const typename Bitset::size_type n = blocks.size();
+      Bitset bset(n * bits_per_block);
+      boost::from_block_range(blocks.begin(), blocks.end(), bset);
+      for (std::size_t b = 0; b < n; ++b) {
+        typename Bitset::block_width_type i = 0;
+        for (; i < bits_per_block; ++i) {
+          std::size_t bit = b * bits_per_block + i;
+          BOOST_TEST(bset[bit] == nth_bit(blocks[b], i));
+        }
+      }
+      BOOST_TEST(n <= bset.num_blocks());
+    }
+  }
+
+  // copy constructor (absent from std::bitset)
+  static void copy_constructor(const Bitset& b)
+  {
+    Bitset copy(b);
+    BOOST_TEST(b == copy);
+
+    // Changes to the copy do not affect the original
+    if (b.size() > 0) {
+      std::size_t pos = copy.size() / 2;
+      copy.flip(pos);
+      BOOST_TEST(copy[pos] != b[pos]);
+    }
+  }
+
+  // copy assignment operator (absent from std::bitset)
+  static void copy_assignment_operator(const Bitset& lhs, const Bitset& rhs)
+  {
+    Bitset b(lhs);
+    b = rhs;
+    b = b; // self assignment check
+    BOOST_TEST(b == rhs);
+
+    // Changes to the copy do not affect the original
+    if (b.size() > 0) {
+      std::size_t pos = b.size() / 2;
+      b.flip(pos);
+      BOOST_TEST(b[pos] != rhs[pos]);
+    }
+  }
+
+  static void max_size(const Bitset& b)
+  {
+    BOOST_TEST(b.max_size() > 0);
+  }
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+  // move constructor (absent from std::bitset)
+  static void move_constructor(const Bitset& b)
+  {
+    Bitset copy(boost::move(b));
+    BOOST_TEST(b == copy);
+  }
+
+  // move assignment operator (absent from std::bitset)
+  static void move_assignment_operator(const Bitset& lhs, const Bitset& rhs)
+  {
+    Bitset b(lhs);
+    Bitset c(rhs);
+    b = boost::move(c);
+    b = boost::move(b); // self assignment check
+    BOOST_TEST(b == rhs);
+  }
+
+#endif // BOOST_NO_CXX11_RVALUE_REFERENCES
+
+  static void swap(const Bitset& lhs, const Bitset& rhs)
+  {
+    // bitsets must be swapped
+    Bitset copy1(lhs);
+    Bitset copy2(rhs);
+    copy1.swap(copy2);
+
+    BOOST_TEST(copy1 == rhs);
+    BOOST_TEST(copy2 == lhs);
+
+    // references must be stable under a swap
+    for(typename Bitset::size_type i = 0; i < lhs.size(); ++i) {
+      Bitset b1(lhs);
+      Bitset b2(rhs);
+      typename Bitset::reference ref = b1[i];
+      bool x = ref;
+      if (i < b2.size())
+        b2[i] = !x; // make sure b2[i] is different
+      b1.swap(b2);
+      BOOST_TEST(b2[i] == x); // now it must be equal..
+      b2.flip(i);
+      BOOST_TEST(ref == b2[i]); // .. and ref must be into b2
+      BOOST_TEST(ref == !x);
+    }
+
+  }
+
+  static void resize(const Bitset& lhs)
+  {
+    Bitset b(lhs);
+
+    // Test no change in size
+    b.resize(lhs.size());
+    BOOST_TEST(b == lhs);
+
+    // Test increase in size
+    b.resize(lhs.size() * 2, true);
+
+    std::size_t i;
+    for (i = 0; i < lhs.size(); ++i)
+      BOOST_TEST(b[i] == lhs[i]);
+    for (; i < b.size(); ++i)
+      BOOST_TEST(b[i] == true);
+
+    // Test decrease in size
+    b.resize(lhs.size());
+    for (i = 0; i < lhs.size(); ++i)
+      BOOST_TEST(b[i] == lhs[i]);
+  }
+
+  static void clear(const Bitset& lhs)
+  {
+    Bitset b(lhs);
+    b.clear();
+    BOOST_TEST(b.size() == 0);
+  }
+
+  static void pop_back(const Bitset& lhs)
+  {
+    Bitset b(lhs);
+    b.pop_back();
+    BOOST_TEST(b.size() == lhs.size() - 1);
+    for (std::size_t i = 0; i < b.size(); ++i)
+      BOOST_TEST(b[i] == lhs[i]);
+
+    b.pop_back();
+    BOOST_TEST(b.size() == lhs.size() - 2);
+    for (std::size_t j = 0; j < b.size(); ++j)
+      BOOST_TEST(b[j] == lhs[j]);
+  }
+
+  static void append_bit(const Bitset& lhs)
+  {
+    Bitset b(lhs);
+    b.push_back(true);
+    BOOST_TEST(b.size() == lhs.size() + 1);
+    BOOST_TEST(b[b.size() - 1] == true);
+    for (std::size_t i = 0; i < lhs.size(); ++i)
+      BOOST_TEST(b[i] == lhs[i]);
+
+    b.push_back(false);
+    BOOST_TEST(b.size() == lhs.size() + 2);
+    BOOST_TEST(b[b.size() - 1] == false);
+    BOOST_TEST(b[b.size() - 2] == true);
+    for (std::size_t j = 0; j < lhs.size(); ++j)
+      BOOST_TEST(b[j] == lhs[j]);
+  }
+
+  static void append_block(const Bitset& lhs)
+  {
+    Bitset b(lhs);
+    Block value(128);
+    b.append(value);
+    BOOST_TEST(b.size() == lhs.size() + bits_per_block);
+    for (typename Bitset::block_width_type i = 0; i < bits_per_block; ++i)
+      BOOST_TEST(b[lhs.size() + i] == bool((value >> i) & 1));
+  }
+
+  static void append_block_range(const Bitset& lhs, const std::vector<Block>& blocks)
+  {
+    Bitset b(lhs), c(lhs);
+    b.append(blocks.begin(), blocks.end());
+    for (typename std::vector<Block>::const_iterator i = blocks.begin();
+         i != blocks.end(); ++i)
+      c.append(*i);
+    BOOST_TEST(b == c);
+  }
+
+  // operator[] and reference members
+  // PRE: b[i] == bit_vec[i]
+  static void operator_bracket(const Bitset& lhs, const std::vector<bool>& bit_vec)
+  {
+    Bitset b(lhs);
+    std::size_t i, j, k;
+
+    // x = b[i]
+    // x = ~b[i]
+    for (i = 0; i < b.size(); ++i) {
+      bool x = b[i];
+      BOOST_TEST(x == bit_vec[i]);
+      x = ~b[i];
+      BOOST_TEST(x == !bit_vec[i]);
+    }
+    Bitset prev(b);
+
+    // b[i] = x
+    for (j = 0; j < b.size(); ++j) {
+      bool x = !prev[j];
+      b[j] = x;
+      for (k = 0; k < b.size(); ++k)
+        if (j == k)
+          BOOST_TEST(b[k] == x);
+        else
+          BOOST_TEST(b[k] == prev[k]);
+      b[j] = prev[j];
+    }
+    b.flip();
+
+    // b[i] = b[j]
+    for (i = 0; i < b.size(); ++i) {
+      b[i] = prev[i];
+      for (j = 0; j < b.size(); ++j) {
+        if (i == j)
+          BOOST_TEST(b[j] == prev[j]);
+        else
+          BOOST_TEST(b[j] == !prev[j]);
+      }
+      b[i] = !prev[i];
+    }
+
+    // b[i].flip()
+    for (i = 0; i < b.size(); ++i) {
+      b[i].flip();
+      for (j = 0; j < b.size(); ++j) {
+        if (i == j)
+          BOOST_TEST(b[j] == prev[j]);
+        else
+          BOOST_TEST(b[j] == !prev[j]);
+      }
+      b[i].flip();
+    }
+  }
+
+  //===========================================================================
+  // bitwise operators
+
+  // bitwise and assignment
+
+  // PRE: b.size() == rhs.size()
+  static void and_assignment(const Bitset& b, const Bitset& rhs)
+  {
+    Bitset lhs(b);
+    Bitset prev(lhs);
+    lhs &= rhs;
+    // Clears each bit in lhs for which the corresponding bit in rhs is
+    // clear, and leaves all other bits unchanged.
+    for (std::size_t I = 0; I < lhs.size(); ++I)
+      if (rhs[I] == 0)
+        BOOST_TEST(lhs[I] == 0);
+      else
+        BOOST_TEST(lhs[I] == prev[I]);
+  }
+
+  // PRE: b.size() == rhs.size()
+  static void or_assignment(const Bitset& b, const Bitset& rhs)
+  {
+    Bitset lhs(b);
+    Bitset prev(lhs);
+    lhs |= rhs;
+    // Sets each bit in lhs for which the corresponding bit in rhs is set, and
+    // leaves all other bits unchanged.
+    for (std::size_t I = 0; I < lhs.size(); ++I)
+      if (rhs[I] == 1)
+        BOOST_TEST(lhs[I] == 1);
+      else
+        BOOST_TEST(lhs[I] == prev[I]);
+  }
+
+  // PRE: b.size() == rhs.size()
+  static void xor_assignment(const Bitset& b, const Bitset& rhs)
+  {
+    Bitset lhs(b);
+    Bitset prev(lhs);
+    lhs ^= rhs;
+    // Flips each bit in lhs for which the corresponding bit in rhs is set,
+    // and leaves all other bits unchanged.
+    for (std::size_t I = 0; I < lhs.size(); ++I)
+      if (rhs[I] == 1)
+        BOOST_TEST(lhs[I] == !prev[I]);
+      else
+        BOOST_TEST(lhs[I] == prev[I]);
+  }
+
+  // PRE: b.size() == rhs.size()
+  static void sub_assignment(const Bitset& b, const Bitset& rhs)
+  {
+    Bitset lhs(b);
+    Bitset prev(lhs);
+    lhs -= rhs;
+    // Resets each bit in lhs for which the corresponding bit in rhs is set,
+    // and leaves all other bits unchanged.
+    for (std::size_t I = 0; I < lhs.size(); ++I)
+      if (rhs[I] == 1)
+        BOOST_TEST(lhs[I] == 0);
+      else
+        BOOST_TEST(lhs[I] == prev[I]);
+  }
+
+  static void shift_left_assignment(const Bitset& b, std::size_t pos)
+  {
+    Bitset lhs(b);
+    Bitset prev(lhs);
+    lhs <<= pos;
+    // Replaces each bit at position I in lhs with the following value:
+    // - If I < pos, the new value is zero
+    // - If I >= pos, the new value is the previous value of the bit at
+    //   position I - pos
+    for (std::size_t I = 0; I < lhs.size(); ++I)
+      if (I < pos)
+        BOOST_TEST(lhs[I] == 0);
+      else
+        BOOST_TEST(lhs[I] == prev[I - pos]);
+  }
+
+  static void shift_right_assignment(const Bitset& b, std::size_t pos)
+  {
+    Bitset lhs(b);
+    Bitset prev(lhs);
+    lhs >>= pos;
+    // Replaces each bit at position I in lhs with the following value:
+    // - If pos >= N - I, the new value is zero
+    // - If pos < N - I, the new value is the previous value of the bit at
+    //    position I + pos
+    std::size_t N = lhs.size();
+    for (std::size_t I = 0; I < N; ++I)
+      if (pos >= N - I)
+        BOOST_TEST(lhs[I] == 0);
+      else
+        BOOST_TEST(lhs[I] == prev[I + pos]);
+  }
+
+
+  static void set_all(const Bitset& b)
+  {
+    Bitset lhs(b);
+    lhs.set();
+    for (std::size_t I = 0; I < lhs.size(); ++I)
+      BOOST_TEST(lhs[I] == 1);
+  }
+
+  static void set_one(const Bitset& b, std::size_t pos, bool value)
+  {
+    Bitset lhs(b);
+    std::size_t N = lhs.size();
+    if (pos < N) {
+      Bitset prev(lhs);
+      // Stores a new value in the bit at position pos in lhs.
+      lhs.set(pos, value);
+      BOOST_TEST(lhs[pos] == value);
+
+      // All other values of lhs remain unchanged
+      for (std::size_t I = 0; I < N; ++I)
+        if (I != pos)
+          BOOST_TEST(lhs[I] == prev[I]);
+    } else {
+      // Not in range, doesn't satisfy precondition.
+    }
+  }
+
+  static void set_segment(const Bitset& b, std::size_t pos,
+    std::size_t len, bool value)
+  {
+    Bitset lhs(b);
+    std::size_t N = lhs.size();
+    Bitset prev(lhs);
+    lhs.set(pos, len, value);
+    for (std::size_t I = 0; I < N; ++I)
+    {
+      if (I < pos || I >= pos + len)
+        BOOST_TEST(lhs[I] == prev[I]);
+      else
+        BOOST_TEST(lhs[I] == value);
+    }
+  }
+
+  static void reset_all(const Bitset& b)
+  {
+    Bitset lhs(b);
+    // Resets all bits in lhs
+    lhs.reset();
+    for (std::size_t I = 0; I < lhs.size(); ++I)
+      BOOST_TEST(lhs[I] == 0);
+  }
+
+  static void reset_one(const Bitset& b, std::size_t pos)
+  {
+    Bitset lhs(b);
+    std::size_t N = lhs.size();
+    if (pos < N) {
+      Bitset prev(lhs);
+      lhs.reset(pos);
+      // Resets the bit at position pos in lhs
+      BOOST_TEST(lhs[pos] == 0);
+
+      // All other values of lhs remain unchanged
+      for (std::size_t I = 0; I < N; ++I)
+        if (I != pos)
+          BOOST_TEST(lhs[I] == prev[I]);
+    } else {
+      // Not in range, doesn't satisfy precondition.
+    }
+  }
+
+  static void reset_segment(const Bitset& b, std::size_t pos,
+    std::size_t len)
+  {
+    Bitset lhs(b);
+    std::size_t N = lhs.size();
+    Bitset prev(lhs);
+    lhs.reset(pos, len);
+    for (std::size_t I = 0; I < N; ++I)
+    {
+      if (I < pos || I >= pos + len)
+        BOOST_TEST(lhs[I] == prev[I]);
+      else
+        BOOST_TEST(!lhs[I]);
+    }
+  }
+
+  static void operator_flip(const Bitset& b)
+  {
+    Bitset lhs(b);
+    Bitset x(lhs);
+    BOOST_TEST(~lhs == x.flip());
+  }
+
+  static void flip_all(const Bitset& b)
+  {
+    Bitset lhs(b);
+    std::size_t N = lhs.size();
+    Bitset prev(lhs);
+    lhs.flip();
+    // Toggles all the bits in lhs
+    for (std::size_t I = 0; I < N; ++I)
+      BOOST_TEST(lhs[I] == !prev[I]);
+  }
+
+  static void flip_one(const Bitset& b, std::size_t pos)
+  {
+    Bitset lhs(b);
+    std::size_t N = lhs.size();
+    if (pos < N) {
+      Bitset prev(lhs);
+      lhs.flip(pos);
+      // Toggles the bit at position pos in lhs
+      BOOST_TEST(lhs[pos] == !prev[pos]);
+
+      // All other values of lhs remain unchanged
+      for (std::size_t I = 0; I < N; ++I)
+        if (I != pos)
+          BOOST_TEST(lhs[I] == prev[I]);
+    } else {
+      // Not in range, doesn't satisfy precondition.
+    }
+  }
+
+  static void flip_segment(const Bitset& b, std::size_t pos,
+    std::size_t len)
+  {
+    Bitset lhs(b);
+    std::size_t N = lhs.size();
+    Bitset prev(lhs);
+    lhs.flip(pos, len);
+    for (std::size_t I = 0; I < N; ++I)
+    {
+      if (I < pos || I >= pos + len)
+        BOOST_TEST(lhs[I] == prev[I]);
+      else
+        BOOST_TEST(lhs[I] != prev[I]);
+    }
+  }
+
+  // empty
+  static void empty(const Bitset& b)
+  {
+    BOOST_TEST(b.empty() == (b.size() == 0));
+  }
+
+  // to_ulong()
+  static void to_ulong(const Bitset& lhs)
+  {
+    typedef unsigned long result_type;
+    std::size_t n = std::numeric_limits<result_type>::digits;
+    std::size_t sz = lhs.size();
+
+    bool will_overflow = false;
+    for (std::size_t i = n; i < sz; ++i) {
+      if (lhs.test(i) != 0) {
+        will_overflow = true;
+        break;
+      }
+    }
+    if (will_overflow) {
+      try {
+        (void)lhs.to_ulong();
+        BOOST_TEST(false); // It should have thrown an exception
+      } catch (std::overflow_error & ex) {
+        // Good!
+        BOOST_TEST(!!ex.what());
+      } catch (...) {
+        BOOST_TEST(false); // threw the wrong exception
+      }
+    } else {
+      result_type num = lhs.to_ulong();
+      // Be sure the number is right
+      if (sz == 0)
+        BOOST_TEST(num == 0);
+      else {
+        for (std::size_t i = 0; i < sz; ++i)
+          BOOST_TEST(lhs[i] == (i < n ? nth_bit(num, i) : 0));
+      }
+    }
+  }
+
+  // to_string()
+  static void to_string(const Bitset& b)
+  {
+    std::string str;
+    boost::to_string(b, str);
+    BOOST_TEST(str.size() == b.size());
+    for (std::size_t i = 0; i < b.size(); ++i)
+      BOOST_TEST(str[b.size() - 1 - i] ==(b.test(i)? '1':'0'));
+  }
+
+  static void count(const Bitset& b)
+  {
+    std::size_t c = b.count();
+    std::size_t actual = 0;
+    for (std::size_t i = 0; i < b.size(); ++i)
+      if (b[i])
+        ++actual;
+    BOOST_TEST(c == actual);
+  }
+
+  static void size(const Bitset& b)
+  {
+    BOOST_TEST(Bitset(b).set().count() == b.size());
+  }
+
+  static void capacity_test_one(const Bitset& lhs)
+  {
+    //empty bitset
+    Bitset b(lhs);
+    BOOST_TEST(b.capacity() == 0);
+  }
+
+  static void capacity_test_two(const Bitset& lhs)
+  {
+    //bitset constructed with size "100"
+    Bitset b(lhs);
+    BOOST_TEST(b.capacity() >= 100);
+    b.resize(200);
+    BOOST_TEST(b.capacity() >= 200);
+  }
+
+  static void reserve_test_one(const Bitset& lhs)
+  {
+    //empty bitset
+    Bitset b(lhs);
+    b.reserve(16);
+    BOOST_TEST(b.capacity() >= 16);
+  }
+
+  static void reserve_test_two(const Bitset& lhs)
+  {
+    //bitset constructed with size "100"
+    Bitset b(lhs);
+    BOOST_TEST(b.capacity() >= 100);
+    b.reserve(60);
+    BOOST_TEST(b.size() == 100);
+    BOOST_TEST(b.capacity() >= 100);
+    b.reserve(160);
+    BOOST_TEST(b.size() == 100);
+    BOOST_TEST(b.capacity() >= 160);
+  }
+
+  static void shrink_to_fit_test_one(const Bitset& lhs)
+  {
+    //empty bitset
+    Bitset b(lhs);
+    b.shrink_to_fit();
+    BOOST_TEST(b.size() == 0);
+    BOOST_TEST(b.capacity() == 0);
+  }
+
+  static void shrink_to_fit_test_two(const Bitset& lhs)
+  {
+    //bitset constructed with size "100"
+    Bitset b(lhs);
+    b.shrink_to_fit();
+    BOOST_TEST(b.capacity() >= 100);
+    BOOST_TEST(b.size() == 100);
+    b.reserve(200);
+    BOOST_TEST(b.capacity() >= 200);
+    BOOST_TEST(b.size() == 100);
+    b.shrink_to_fit();
+    BOOST_TEST(b.capacity() < 200);
+    BOOST_TEST(b.size() == 100);
+  }
+
+  static void all(const Bitset& b)
+  {
+    BOOST_TEST(b.all() == (b.count() == b.size()));
+    bool result = true;
+    for(std::size_t i = 0; i < b.size(); ++i)
+      if(!b[i]) {
+        result = false;
+        break;
+      }
+    BOOST_TEST(b.all() == result);
+  }
+
+  static void any(const Bitset& b)
+  {
+    BOOST_TEST(b.any() == (b.count() != 0));
+    bool result = false;
+    for(std::size_t i = 0; i < b.size(); ++i)
+      if(b[i]) {
+        result = true;
+        break;
+      }
+    BOOST_TEST(b.any() == result);
+  }
+
+  static void none(const Bitset& b)
+  {
+    bool result = true;
+    for(std::size_t i = 0; i < b.size(); ++i) {
+      if(b[i]) {
+        result = false;
+        break;
+      }
+    }
+    BOOST_TEST(b.none() == result);
+
+    // sanity
+    BOOST_TEST(b.none() == !b.any());
+    BOOST_TEST(b.none() == (b.count() == 0));
+  }
+
+  static void subset(const Bitset& a, const Bitset& b)
+  {
+    BOOST_TEST(a.size() == b.size()); // PRE
+
+    bool is_subset = true;
+    if (b.size()) { // could use b.any() but let's be safe
+      for(std::size_t i = 0; i < a.size(); ++i) {
+        if(a.test(i) && !b.test(i)) {
+          is_subset = false;
+          break;
+        }
+      }
+    }
+    else {
+      // sanity
+      BOOST_TEST(a.count() == 0);
+      BOOST_TEST(a.any() == false);
+
+      //is_subset = (a.any() == false);
+    }
+
+    BOOST_TEST(a.is_subset_of(b) == is_subset);
+  }
+
+  static void proper_subset(const Bitset& a, const Bitset& b)
+  {
+    // PRE: a.size() == b.size()
+    BOOST_TEST(a.size() == b.size());
+
+    bool is_proper = false;
+
+    if (b.size() != 0) {
+
+      // check it's a subset
+      subset(a, b);
+
+      // is it proper?
+      for (std::size_t i = 0; i < a.size(); ++i) {
+        if (!a.test(i) && b.test(i)) {
+          is_proper = true;
+          // sanity
+          BOOST_TEST(a.count() < b.count());
+          BOOST_TEST(b.any());
+        }
+      }
+    }
+
+    BOOST_TEST(a.is_proper_subset_of(b) == is_proper);
+    if (is_proper)
+      BOOST_TEST(b.is_proper_subset_of(a) != is_proper);// antisymmetry
+  }
+
+  static void intersects(const Bitset& a, const Bitset& b)
+  {
+    bool have_intersection = false;
+
+    typename Bitset::size_type m = a.size() < b.size() ? a.size() : b.size();
+    for(typename Bitset::size_type i = 0; i < m && !have_intersection; ++i)
+      if(a[i] == true && b[i] == true)
+        have_intersection = true;
+
+    BOOST_TEST(a.intersects(b) == have_intersection);
+    // also check commutativity
+    BOOST_TEST(b.intersects(a) == have_intersection);
+  }
+
+  static void find_first(const Bitset& b)
+  {
+      // find first non-null bit, if any
+      typename Bitset::size_type i = 0;
+      while (i < b.size() && b[i] == 0)
+          ++i;
+
+      if (i == b.size())
+        BOOST_TEST(b.find_first() == Bitset::npos); // not found;
+      else {
+        BOOST_TEST(b.find_first() == i);
+        BOOST_TEST(b.test(i) == true);
+      }
+
+  }
+
+  static void find_next(const Bitset& b, typename Bitset::size_type prev)
+  {
+    BOOST_TEST(next_bit_on(b, prev) == b.find_next(prev));
+  }
+
+  static void operator_equal(const Bitset& a, const Bitset& b)
+  {
+    if (a == b) {
+      for (std::size_t I = 0; I < a.size(); ++I)
+        BOOST_TEST(a[I] == b[I]);
+    } else {
+      if (a.size() == b.size()) {
+        bool diff = false;
+        for (std::size_t I = 0; I < a.size(); ++I)
+          if (a[I] != b[I]) {
+            diff = true;
+            break;
+          }
+        BOOST_TEST(diff);
+      }
+    }
+  }
+
+  static void operator_not_equal(const Bitset& a, const Bitset& b)
+  {
+    if (a != b) {
+      if (a.size() == b.size()) {
+        bool diff = false;
+        for (std::size_t I = 0; I < a.size(); ++I)
+          if (a[I] != b[I]) {
+            diff = true;
+            break;
+          }
+        BOOST_TEST(diff);
+      }
+    } else {
+      for (std::size_t I = 0; I < a.size(); ++I)
+        BOOST_TEST(a[I] == b[I]);
+    }
+  }
+
+  static bool less_than(const Bitset& a, const Bitset& b)
+  {
+  
+    typedef BOOST_DEDUCED_TYPENAME Bitset::size_type size_type;
+    
+    size_type asize(a.size());
+    size_type bsize(b.size());
+    
+    if (!bsize)
+        {
+        return false;
+        }
+    else if (!asize)
+        {
+        return true;
+        }
+    else
+        {
+              
+        // Compare from most significant to least.
+    
+        size_type leqsize(std::min BOOST_PREVENT_MACRO_SUBSTITUTION(asize,bsize));
+        size_type I;
+        for (I = 0; I < leqsize; ++I,--asize,--bsize)
+          {
+          
+          size_type i = asize-1;
+          size_type j = bsize-1;
+            
+          if (a[i] < b[j])
+            return true;
+          else if (a[i] > b[j])
+            return false;
+          // if (a[i] = b[j]) skip to next
+          }
+          return (a.size() < b.size());
+        }
+  }
+
+  static typename Bitset::size_type next_bit_on(const Bitset& b, typename Bitset::size_type prev)
+  {
+      // helper function for find_next()
+      //
+
+      if (b.none() == true || prev == Bitset::npos)
+          return Bitset::npos;
+
+      ++prev;
+
+      if (prev >= b.size())
+          return Bitset::npos;
+
+      typename Bitset::size_type i = prev;
+      while (i < b.size() && b[i] == 0)
+          ++i;
+
+      return i==b.size() ? Bitset::npos : i;
+
+  }
+
+  static void operator_less_than(const Bitset& a, const Bitset& b)
+  {
+    if (less_than(a, b))
+      BOOST_TEST(a < b);
+    else
+      BOOST_TEST(!(a < b));
+  }
+
+  static void operator_greater_than(const Bitset& a, const Bitset& b)
+  {
+    if (less_than(a, b) || a == b)
+      BOOST_TEST(!(a > b));
+    else
+      BOOST_TEST(a > b);
+  }
+
+  static void operator_less_than_eq(const Bitset& a, const Bitset& b)
+  {
+    if (less_than(a, b) || a == b)
+      BOOST_TEST(a <= b);
+    else
+      BOOST_TEST(!(a <= b));
+  }
+
+  static void operator_greater_than_eq(const Bitset& a, const Bitset& b)
+  {
+    if (less_than(a, b))
+      BOOST_TEST(!(a >= b));
+    else
+      BOOST_TEST(a >= b);
+  }
+
+  static void test_bit(const Bitset& b, std::size_t pos)
+  {
+    Bitset lhs(b);
+    std::size_t N = lhs.size();
+    if (pos < N) {
+      BOOST_TEST(lhs.test(pos) == lhs[pos]);
+    } else {
+      // Not in range, doesn't satisfy precondition.
+    }
+  }
+
+  static void test_set_bit(const Bitset& b, std::size_t pos, bool value)
+  {
+    Bitset lhs(b);
+    std::size_t N = lhs.size();
+    if (pos < N) {
+      Bitset prev(lhs);
+      // Stores a new value in the bit at position pos in lhs.
+      BOOST_TEST(lhs.test_set(pos, value) == prev[pos]);
+      BOOST_TEST(lhs[pos] == value);
+
+      // All other values of lhs remain unchanged
+      for (std::size_t I = 0; I < N; ++I)
+        if (I != pos)
+          BOOST_TEST(lhs[I] == prev[I]);
+    } else {
+      // Not in range, doesn't satisfy precondition.
+    }
+  }
+
+  static void operator_shift_left(const Bitset& lhs, std::size_t pos)
+  {
+    Bitset x(lhs);
+    BOOST_TEST((lhs << pos) == (x <<= pos));
+  }
+
+  static void operator_shift_right(const Bitset& lhs, std::size_t pos)
+  {
+    Bitset x(lhs);
+    BOOST_TEST((lhs >> pos) == (x >>= pos));
+  }
+
+  // operator|
+  static
+  void operator_or(const Bitset& lhs, const Bitset& rhs)
+  {
+    Bitset x(lhs);
+    BOOST_TEST((lhs | rhs) == (x |= rhs));
+  }
+
+  // operator&
+  static
+  void operator_and(const Bitset& lhs, const Bitset& rhs)
+  {
+    Bitset x(lhs);
+    BOOST_TEST((lhs & rhs) == (x &= rhs));
+  }
+
+  // operator^
+  static
+  void operator_xor(const Bitset& lhs, const Bitset& rhs)
+  {
+    Bitset x(lhs);
+    BOOST_TEST((lhs ^ rhs) == (x ^= rhs));
+  }
+
+  // operator-
+  static
+  void operator_sub(const Bitset& lhs, const Bitset& rhs)
+  {
+    Bitset x(lhs);
+    BOOST_TEST((lhs - rhs) == (x -= rhs));
+  }
+
+//------------------------------------------------------------------------------
+//                               I/O TESTS
+   // The following tests assume the results of extraction (i.e.: contents,
+   // state and width of is, contents of b) only depend on input (the string
+   // str). In other words, they don't consider "unexpected" errors such as
+   // stream corruption or out of memory. The reason is simple: if e.g. the
+   // stream buffer throws, the stream layer may eat the exception and
+   // transform it into a badbit. But we can't trust the stream state here,
+   // because one of the things that we want to test is exactly whether it
+   // is set correctly. Similarly for insertion.
+   //
+   // To provide for these cases would require that the test functions know
+   // in advance whether the stream buffer and/or allocations will fail, and
+   // when; that is, we should write both a special allocator and a special
+   // stream buffer capable of throwing "on demand" and pass them here.
+
+   // Seems overkill for these kinds of unit tests.
+  //-------------------------------------------------------------------------
+
+  // operator<<( [basic_]ostream,
+  template <typename Stream>
+  static void stream_inserter(const Bitset & b,
+                              Stream & s,
+                              const char * file_name
+                              )
+  {
+#if defined BOOST_OLD_IOSTREAMS
+    typedef char char_type;
+    typedef std::string string_type;
+    typedef ifstream corresponding_input_stream_type;
+#else
+    typedef typename Stream::char_type char_type;
+    typedef std::basic_string<char_type> string_type;
+    typedef std::basic_ifstream<char_type> corresponding_input_stream_type;
+
+    std::ios::iostate except = s.exceptions();
+#endif
+
+    typedef typename Bitset::size_type size_type;
+    std::streamsize w = s.width();
+    char_type fill_char = s.fill();
+    std::ios::iostate oldstate = s.rdstate();
+    bool stream_was_good = s.good();
+
+    bool did_throw = false;
+    try {
+      s << b;
+    }
+#if defined BOOST_OLD_IOSTREAMS
+    catch(...) {
+      BOOST_TEST(false);
+    }
+#else
+    catch (const std::ios_base::failure &) {
+        BOOST_TEST((except & s.rdstate()) != 0);
+        did_throw = true;
+    } catch (...) {
+        did_throw = true;
+    }
+#endif
+
+    BOOST_TEST(did_throw || !stream_was_good || (s.width() == 0));
+
+    if (!stream_was_good) {
+      BOOST_TEST(s.good() == false);
+
+      // this should actually be oldstate == s.rdstate()
+      // but some implementations add badbit in the
+      // sentry constructor
+      //
+      BOOST_TEST((oldstate & s.rdstate()) == oldstate);
+      BOOST_TEST(s.width() == w);
+    }
+    else {
+      if(!did_throw)
+        BOOST_TEST(s.width() == 0);
+      // This test require that os be an output _and_ input stream.
+      // Of course dynamic_bitset's operator << doesn't require that.
+
+      size_type total_len = w <= 0 || static_cast<size_type>(w) < b.size()? b.size() : static_cast<size_type>(w);
+      const string_type padding (total_len - b.size(), fill_char);
+      string_type expected;
+      boost::to_string(b, expected);
+      if ((s.flags() & std::ios::adjustfield) != std::ios::left)
+        expected = padding + expected;
+      else
+        expected = expected + padding;
+
+      assert(expected.length() == total_len);
+
+      // close, and reopen the file stream to verify contents
+      s.close();
+      corresponding_input_stream_type is(file_name);
+      string_type contents;
+      std::getline(is, contents, char_type());
+      BOOST_TEST(contents == expected);
+    }
+  }
+
+  // operator>>( [basic_]istream
+  template <typename Stream, typename String>
+  static void stream_extractor(Bitset& b,
+                               Stream& is,
+                               String& str
+                              )
+  {
+    // save necessary info then do extraction
+    //
+    const std::streamsize w = is.width();
+    Bitset a_copy(b);
+    bool stream_was_good = is.good();
+
+    bool did_throw = false;
+
+#if defined BOOST_OLD_IOSTREAMS
+    bool has_stream_exceptions = false;
+    is >> b;
+#else
+    const std::ios::iostate except = is.exceptions();
+    bool has_stream_exceptions = true;
+    try {
+      is >> b;
+    }
+    catch(const std::ios::failure &) {
+      did_throw = true;
+    }
+
+    // postconditions
+    BOOST_TEST(except == is.exceptions()); // paranoid
+#endif
+    //------------------------------------------------------------------
+
+    // postconditions
+    BOOST_TEST(b.size() <= b.max_size());
+    if(w > 0)
+      BOOST_TEST(b.size() <= static_cast<typename Bitset::size_type>(w));
+
+    // throw if and only if required
+    if(has_stream_exceptions) {
+        const bool exceptional_state = has_flags(is, is.exceptions());
+        BOOST_TEST(exceptional_state == did_throw);
+    }
+
+    typedef typename String::size_type size_type;
+    typedef typename String::value_type Ch;
+    size_type after_digits = 0;
+
+    if(!stream_was_good) {
+        BOOST_TEST(has_flags(is, std::ios::failbit));
+        BOOST_TEST(b == a_copy);
+        BOOST_TEST(is.width() == (did_throw ? w : 0));
+    }
+    else {
+      // stream was good(), parse the string;
+      // it may contain three parts, all of which are optional
+      // {spaces}   {digits}   {non-digits}
+      //        opt        opt            opt
+      //
+      // The values of b.max_size() and is.width() may lead to
+      // ignore part of the digits, if any.
+
+      size_type pos = 0;
+      size_type len = str.length();
+      // {spaces}
+      for( ; pos < len && is_white_space(is, str[pos]); ++pos)
+        {}
+      size_type after_spaces = pos;
+      // {digits} or part of them
+      const typename Bitset::size_type max_digits =
+            w > 0 && static_cast<typename Bitset::size_type>(w) < b.max_size()
+                               ? static_cast<typename Bitset::size_type>(w) : b.max_size();
+
+      for( ; pos < len && (pos - after_spaces) < max_digits; ++pos) {
+          if(!is_one_or_zero(is, str[pos]))
+              break;
+      }
+      after_digits = pos;
+      size_type num_digits = after_digits - after_spaces;
+
+      // eofbit
+      if((after_digits == len && max_digits > num_digits ))
+          BOOST_TEST(has_flags(is, std::ios::eofbit));
+      else
+          BOOST_TEST(!has_flags(is, std::ios::eofbit));
+
+      // failbit <=> there are no digits, except for the library
+      // issue explained below.
+      //
+      if(num_digits == 0) {
+        if(after_digits == len && has_stream_exceptions &&
+            (is.exceptions() & std::ios::eofbit) != std::ios::goodbit) {
+                // This is a special case related to library issue 195:
+                // reaching eof when skipping whitespaces in the sentry ctor.
+                // The resolution says the sentry constructor should set *both*
+                // eofbit and failbit; but many implementations deliberately
+                // set eofbit only. See for instance:
+                //  http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00086.html
+                //
+                BOOST_TEST(did_throw);
+
+            }
+        else {
+            BOOST_TEST(has_flags(is, std::ios::failbit));
+        }
+      }
+      else
+        BOOST_TEST(!has_flags(is, std::ios::failbit));
+
+
+      if(num_digits == 0 && after_digits == len) {
+        // The VC6 library has a bug/non-conformity in the sentry
+        // constructor. It uses code like
+        //  // skip whitespaces...
+        //  int_type _C = rdbuf()->sgetc();
+        //  while (!_Tr::eq_int_type(_Tr::eof(), _C) ...
+        //
+        // For an empty file the while statement is never "entered"
+        // and the stream remains in good() state; thus the sentry
+        // object gives "true" when converted to bool. This is worse
+        // than the case above, because not only failbit is not set,
+        // but no bit is set at all, end we end up clearing the
+        // bitset though there's nothing in the file to be extracted.
+        // Note that the dynamic_bitset docs say a sentry object is
+        // constructed and then converted to bool, thus we rely on
+        // what the underlying library does.
+        //
+#if !defined(BOOST_DINKUMWARE_STDLIB) || (BOOST_DINKUMWARE_STDLIB >= 306)
+        BOOST_TEST(b == a_copy);
+#else
+        BOOST_TEST(b.empty() == true);
+#endif
+      }
+      else {
+        String sub = str.substr(after_spaces, num_digits);
+        BOOST_TEST(b == Bitset(sub));
+      }
+
+      // check width
+      BOOST_TEST(is.width() == 0
+                  || (after_digits == len && num_digits == 0 && did_throw));
+    }
+
+
+    // clear the stream to allow further reading then
+    // retrieve any remaining chars with a single getline()
+    is.exceptions(std::ios::goodbit);
+    is.clear();
+    String remainder;
+    std::getline(is, remainder, Ch());
+    if(stream_was_good)
+      BOOST_TEST(remainder == str.substr(after_digits));
+    else
+      BOOST_TEST(remainder == str);
+
+  }
+
+
+};
+
+
+
+#endif // include guard
diff --git a/src/boost/libs/dynamic_bitset/test/dyn_bitset_unit_tests1.cpp b/src/boost/libs/dynamic_bitset/test/dyn_bitset_unit_tests1.cpp
new file mode 100644
index 00000000..c7227019
--- /dev/null
+++ b/src/boost/libs/dynamic_bitset/test/dyn_bitset_unit_tests1.cpp
@@ -0,0 +1,539 @@
+// -----------------------------------------------------------
+//              Copyright (c) 2001 Jeremy Siek
+//           Copyright (c) 2003-2006 Gennaro Prota
+//             Copyright (c) 2014 Ahmed Charles
+//            Copyright (c) 2014 Riccardo Marcangelo 
+//
+// Copyright (c) 2014 Glen Joseph Fernandes
+// (glenjofe@gmail.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)
+//
+// -----------------------------------------------------------
+
+#include "bitset_test.hpp"
+#include <boost/dynamic_bitset/dynamic_bitset.hpp>
+#include <boost/limits.hpp>
+#include <boost/config.hpp>
+
+#include <boost/config/workaround.hpp>
+
+#if !defined(BOOST_NO_CXX11_ALLOCATOR)
+#include <cstdlib>
+
+template<class T>
+class minimal_allocator {
+public:
+    typedef T value_type;
+
+    minimal_allocator() {}
+
+    template <typename U>
+    minimal_allocator(const minimal_allocator<U>&) {}
+
+    T* allocate(std::size_t n) {
+        void* p = std::malloc(sizeof(T) * n);
+        if (!p) {
+            throw std::bad_alloc();
+        }
+        return static_cast<T*>(p);
+    }
+
+    void deallocate(T* p, std::size_t) {
+        std::free(p);
+    }
+};
+#endif
+
+#define BOOST_BITSET_TEST_COUNT(x) (sizeof(x)/sizeof(x[0]))
+
+
+// Codewarrior 8.3 for Win fails without this.
+// Thanks Howard Hinnant ;)
+#if defined __MWERKS__ && BOOST_WORKAROUND(__MWERKS__, <= 0x3003) // 8.x
+# pragma parse_func_templ off
+#endif
+
+
+template <typename Tests, typename String>
+void run_string_tests(const String& s
+                      BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tests)
+                     )
+{
+
+  const std::size_t len = s.length();
+  const std::size_t step = len/4 ? len/4 : 1;
+
+  // bitset length determined by the string-related arguments
+  std::size_t i;
+  for (i = 0; i <= len/2 ; i += step) {
+    Tests::from_string(s, i, len/2);     // len/2 - i bits
+    Tests::from_string(s, i, len);       // len - i   bits
+    Tests::from_string(s, i, 1 + len*2); // len - i   bits
+  }
+
+  // bitset length explicitly specified
+  for (i = 0; i <= len/2; i += step) {
+    for (std::size_t sz = 0; sz <= len*4; sz+= step*2) {
+      Tests::from_string(s, i, len/2, sz);
+      Tests::from_string(s, i, len,   sz);
+      Tests::from_string(s, i, 1 + len*2, sz);
+
+      }
+  }
+
+}
+
+// tests the do-the-right-thing constructor dispatch
+template <typename Tests, typename T>
+void run_numeric_ctor_tests( BOOST_EXPLICIT_TEMPLATE_TYPE(Tests)
+                             BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(T) )
+{
+
+    const int bits_per_block = Tests::bits_per_block;
+    const int width = std::numeric_limits<T>::digits;
+    const T ma = (std::numeric_limits<T>::max)();
+    const T mi = (std::numeric_limits<T>::min)();
+
+    int sizes[] = {
+        0, 7*width/10,          width,          13*width/10,          3*width,
+           7*bits_per_block/10, bits_per_block, 13*bits_per_block/10, 3*bits_per_block
+    };
+
+    const T numbers[] = {
+              T(-1), T(-3), T(-8), T(-15), T(mi/2), T(mi),
+        T(0), T(1),  T(3),  T(8),  T(15),  T(ma/2), T(ma)
+    };
+
+    for (std::size_t s = 0; s < BOOST_BITSET_TEST_COUNT(sizes); ++s) {
+      for (std::size_t n = 0; n < BOOST_BITSET_TEST_COUNT(numbers); ++n ) {
+
+          // can match ctor from ulong or templated one
+          Tests::from_unsigned_long(sizes[s], numbers[n]);
+
+          typedef std::size_t compare_type;
+          const compare_type sz = sizes[s];
+          // this condition is to be sure that size is representable in T, so
+          // that for signed T's we avoid implementation-defined behavior [if ma
+          // is larger than what std::size_t can hold then this is ok for our
+          // purposes: our sizes are anyhow < max(size_t)], which in turn could
+          // make the first argument of from_unsigned_long() a small negative,
+          // later converted to a very large unsigned. Example: signed 8-bit
+          // char (CHAR_MAX=127), bits_per_block=64, sz = 192 > 127.
+          const bool fits =
+              sz <= static_cast<compare_type>(ma);
+
+          if (fits) {
+            // can match templated ctor only (so we test dispatching)
+            Tests::from_unsigned_long(static_cast<T>(sizes[s]), numbers[n]);
+          }
+
+      }
+    }
+
+}
+
+
+template <typename Block>
+void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
+{
+  typedef boost::dynamic_bitset<Block> bitset_type;
+  typedef bitset_test<bitset_type> Tests;
+  const int bits_per_block = bitset_type::bits_per_block;
+
+  const std::string long_string = get_long_string();
+  const Block all_1s = static_cast<Block>(-1);
+
+  //=====================================================================
+  // Test construction from unsigned long
+  {
+    // NOTE:
+    //
+    // 1. keep this in sync with the numeric types supported
+    //    for constructor dispatch (of course)
+    // 2. bool is tested separately; ugly and inelegant, but
+    //    we don't have much time to think of a better solution
+    //    which is likely to work on broken compilers
+    //
+    const int sizes[] = {
+        0,                     1,                                  3,
+           7*bits_per_block/10, bits_per_block, 13*bits_per_block/10, 3*bits_per_block 
+    };
+    
+    const bool values[] = { false, true };
+
+    for (std::size_t s = 0; s < BOOST_BITSET_TEST_COUNT(sizes); ++s) {
+      for (std::size_t v = 0; v < BOOST_BITSET_TEST_COUNT(values); ++v) {
+          Tests::from_unsigned_long(sizes[s], values[v]);
+          Tests::from_unsigned_long(sizes[s] != 0, values[v]);
+      }
+    }
+
+    run_numeric_ctor_tests<Tests, char>();
+
+#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+    run_numeric_ctor_tests<Tests, wchar_t>();
+#endif
+
+    run_numeric_ctor_tests<Tests, signed char>();
+    run_numeric_ctor_tests<Tests, short int>();
+    run_numeric_ctor_tests<Tests, int>();
+    run_numeric_ctor_tests<Tests, long int>();
+
+    run_numeric_ctor_tests<Tests, unsigned char>();
+    run_numeric_ctor_tests<Tests, unsigned short>();
+    run_numeric_ctor_tests<Tests, unsigned int>();
+    run_numeric_ctor_tests<Tests, unsigned long>();
+
+#if defined(BOOST_HAS_LONG_LONG)
+    run_numeric_ctor_tests<Tests, ::boost::long_long_type>();
+    run_numeric_ctor_tests<Tests, ::boost::ulong_long_type>();
+#endif
+
+  }
+  //=====================================================================
+  // Test construction from a string
+  {
+
+    run_string_tests<Tests>(std::string("")); // empty string
+    run_string_tests<Tests>(std::string("1"));
+
+    run_string_tests<Tests>(long_string);
+
+# if !defined BOOST_NO_STD_WSTRING
+    // I need to decide what to do for non "C" locales here. On
+    // one hand I should have better tests. On the other one
+    // I don't want tests for dynamic_bitset to cope with locales,
+    // ctype::widen, etc. (but that's what you deserve when you
+    // don't separate concerns at the library level)
+    //
+    run_string_tests<Tests>(
+        std::wstring(L"11111000000111111111010101010101010101010111111"));
+# endif
+
+    // Note that these are _valid_ arguments
+    Tests::from_string(std::string("x11y"), 1, 2);
+    Tests::from_string(std::string("x11"), 1, 10);
+    Tests::from_string(std::string("x11"), 1, 10, 10);
+
+  }
+  //=====================================================================
+  // test from_block_range
+  {
+    std::vector<Block> blocks;
+    Tests::from_block_range(blocks);
+  }
+  {
+    std::vector<Block> blocks(3);
+    blocks[0] = static_cast<Block>(0);
+    blocks[1] = static_cast<Block>(1);
+    blocks[2] = all_1s;
+    Tests::from_block_range(blocks);
+  }
+  {
+    const unsigned int n = (std::numeric_limits<unsigned char>::max)();
+    std::vector<Block> blocks(n);
+    for (typename std::vector<Block>::size_type i = 0; i < n; ++i)
+      blocks[i] = static_cast<Block>(i);
+    Tests::from_block_range(blocks);
+  }
+  //=====================================================================
+  // test to_block_range
+  {
+    bitset_type b;
+    Tests::to_block_range(b);
+  }
+  {
+    bitset_type b(1, 1ul);
+    Tests::to_block_range(b);
+  }
+  {
+    bitset_type b(long_string);
+    Tests::to_block_range(b);
+  }
+
+  //=====================================================================
+  // Test copy constructor
+  {
+    boost::dynamic_bitset<Block> b;
+    Tests::copy_constructor(b);
+  }
+  {
+    boost::dynamic_bitset<Block> b(std::string("0"));
+    Tests::copy_constructor(b);
+  }
+  {
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::copy_constructor(b);
+  }
+  //=====================================================================
+  // Test copy assignment operator
+  {
+    bitset_type a, b;
+    Tests::copy_assignment_operator(a, b);
+  }
+  {
+    bitset_type a(std::string("1")), b(std::string("0"));
+    Tests::copy_assignment_operator(a, b);
+  }
+  {
+    bitset_type a(long_string), b(long_string);
+    Tests::copy_assignment_operator(a, b);
+  }
+  {
+    bitset_type a;
+    bitset_type b(long_string); // b greater than a, a empty
+    Tests::copy_assignment_operator(a, b);
+  }
+  {
+    bitset_type a(std::string("0"));
+    bitset_type b(long_string); // b greater than a
+    Tests::copy_assignment_operator(a, b);
+  }
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+  //=====================================================================
+  // Test move constructor
+  {
+    boost::dynamic_bitset<Block> b;
+    Tests::move_constructor(b);
+  }
+  {
+    boost::dynamic_bitset<Block> b(std::string("0"));
+    Tests::move_constructor(b);
+  }
+  {
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::move_constructor(b);
+  }
+  //=====================================================================
+  // Test move assignment operator
+  {
+    bitset_type a, b;
+    Tests::move_assignment_operator(a, b);
+  }
+  {
+    bitset_type a(std::string("1")), b(std::string("0"));
+    Tests::move_assignment_operator(a, b);
+  }
+  {
+    bitset_type a(long_string), b(long_string);
+    Tests::move_assignment_operator(a, b);
+  }
+  {
+    bitset_type a;
+    bitset_type b(long_string); // b greater than a, a empty
+    Tests::move_assignment_operator(a, b);
+  }
+  {
+    bitset_type a(std::string("0"));
+    bitset_type b(long_string); // b greater than a
+    Tests::move_assignment_operator(a, b);
+  }
+#endif // BOOST_NO_CXX11_RVALUE_REFERENCES
+  //=====================================================================
+  // Test swap
+  {
+    bitset_type a;
+    bitset_type b(std::string("1"));
+    Tests::swap(a, b);
+    Tests::swap(b, a);
+    Tests::swap(a, a);
+  }
+  {
+    bitset_type a;
+    bitset_type b(long_string);
+    Tests::swap(a, b);
+    Tests::swap(b, a);
+  }
+  {
+    bitset_type a(std::string("0"));
+    bitset_type b(long_string);
+    Tests::swap(a, b);
+    Tests::swap(b, a);
+    Tests::swap(a, a);
+    Tests::swap(b, b);
+  }
+  //=====================================================================
+  // Test resize
+  {
+    boost::dynamic_bitset<Block> a;
+    Tests::resize(a);
+  }
+  {
+    boost::dynamic_bitset<Block> a(std::string("0"));
+    Tests::resize(a);
+  }
+  {
+    boost::dynamic_bitset<Block> a(std::string("1"));
+    Tests::resize(a);
+  }
+  {
+    boost::dynamic_bitset<Block> a(long_string);
+    Tests::resize(a);
+  }
+  //=====================================================================
+  // Test clear
+  {
+    boost::dynamic_bitset<Block> a;
+    Tests::clear(a);
+  }
+  {
+    boost::dynamic_bitset<Block> a(long_string);
+    Tests::clear(a);
+  }
+  //=====================================================================
+  // Test pop back 
+  {
+    boost::dynamic_bitset<Block> a(std::string("01"));
+    Tests::pop_back(a);
+  }
+  {
+    boost::dynamic_bitset<Block> a(std::string("10"));
+    Tests::pop_back(a);
+  }
+  {
+    const int size_to_fill_all_blocks = 4 * bits_per_block;
+    boost::dynamic_bitset<Block> a(size_to_fill_all_blocks, 255ul);
+    Tests::pop_back(a);
+  }
+  {
+    boost::dynamic_bitset<Block> a(long_string);
+    Tests::pop_back(a);
+  }
+  //=====================================================================
+  // Test append bit
+  {
+    boost::dynamic_bitset<Block> a;
+    Tests::append_bit(a);
+  }
+  {
+    boost::dynamic_bitset<Block> a(std::string("0"));
+    Tests::append_bit(a);
+  }
+  {
+    boost::dynamic_bitset<Block> a(std::string("1"));
+    Tests::append_bit(a);
+  }
+  {
+    const int size_to_fill_all_blocks = 4 * bits_per_block;
+    boost::dynamic_bitset<Block> a(size_to_fill_all_blocks, 255ul);
+    Tests::append_bit(a);
+  }
+  {
+    boost::dynamic_bitset<Block> a(long_string);
+    Tests::append_bit(a);
+  }
+  //=====================================================================
+  // Test append block
+  {
+    boost::dynamic_bitset<Block> a;
+    Tests::append_block(a);
+  }
+  {
+    boost::dynamic_bitset<Block> a(std::string("0"));
+    Tests::append_block(a);
+  }
+  {
+    boost::dynamic_bitset<Block> a(std::string("1"));
+    Tests::append_block(a);
+  }
+  {
+    const int size_to_fill_all_blocks = 4 * bits_per_block;
+    boost::dynamic_bitset<Block> a(size_to_fill_all_blocks, 15ul);
+    Tests::append_block(a);
+  }
+  {
+    boost::dynamic_bitset<Block> a(long_string);
+    Tests::append_block(a);
+  }
+  //=====================================================================
+  // Test append block range
+  {
+    boost::dynamic_bitset<Block> a;
+    std::vector<Block> blocks;
+    Tests::append_block_range(a, blocks);
+  }
+  {
+    boost::dynamic_bitset<Block> a(std::string("0"));
+    std::vector<Block> blocks(3);
+    blocks[0] = static_cast<Block>(0);
+    blocks[1] = static_cast<Block>(1);
+    blocks[2] = all_1s;
+    Tests::append_block_range(a, blocks);
+  }
+  {
+    boost::dynamic_bitset<Block> a(std::string("1"));
+    const unsigned int n = (std::numeric_limits<unsigned char>::max)();
+    std::vector<Block> blocks(n);
+    for (typename std::vector<Block>::size_type i = 0; i < n; ++i)
+      blocks[i] = static_cast<Block>(i);
+    Tests::append_block_range(a, blocks);
+  }
+  {
+    boost::dynamic_bitset<Block> a;
+    a.append(Block(1));
+    a.append(Block(2));
+    Block x[] = {3, 4, 5};
+    std::size_t sz = sizeof(x) / sizeof(x[0]);
+    std::vector<Block> blocks(x, x + sz);
+    Tests::append_block_range(a, blocks);
+  }
+  {
+    boost::dynamic_bitset<Block> a(long_string);
+    std::vector<Block> blocks(3);
+    blocks[0] = static_cast<Block>(0);
+    blocks[1] = static_cast<Block>(1);
+    blocks[2] = all_1s;
+    Tests::append_block_range(a, blocks);
+  }
+  //=====================================================================
+  // Test bracket operator
+  {
+    boost::dynamic_bitset<Block> b1;
+    std::vector<bool> bitvec1;
+    Tests::operator_bracket(b1, bitvec1);
+  }
+  {
+    boost::dynamic_bitset<Block> b(std::string("1"));
+    std::vector<bool> bit_vec(1, true);
+    Tests::operator_bracket(b, bit_vec);
+  }
+  {
+    boost::dynamic_bitset<Block> b(long_string);
+    std::size_t n = long_string.size();
+    std::vector<bool> bit_vec(n);
+    for (std::size_t i = 0; i < n; ++i)
+      bit_vec[i] = long_string[n - 1 - i] == '0' ? 0 : 1;
+    Tests::operator_bracket(b, bit_vec);
+  }
+#if !defined(BOOST_NO_CXX11_ALLOCATOR)
+  {
+     typedef boost::dynamic_bitset<Block,
+       minimal_allocator<Block> > Bitset;
+     Bitset b;
+     bitset_test<Bitset>::max_size(b);
+  }
+#endif
+  // Test copy-initialize with default constructor
+  {
+    boost::dynamic_bitset<Block> b[1] = {};
+    (void)b;
+  }
+}
+
+int
+main()
+{
+  run_test_cases<unsigned char>();
+  run_test_cases<unsigned short>();
+  run_test_cases<unsigned int>();
+  run_test_cases<unsigned long>();
+# ifdef BOOST_HAS_LONG_LONG
+  run_test_cases< ::boost::ulong_long_type>();
+# endif
+
+  return boost::report_errors();
+}
diff --git a/src/boost/libs/dynamic_bitset/test/dyn_bitset_unit_tests2.cpp b/src/boost/libs/dynamic_bitset/test/dyn_bitset_unit_tests2.cpp
new file mode 100644
index 00000000..69a2edb3
--- /dev/null
+++ b/src/boost/libs/dynamic_bitset/test/dyn_bitset_unit_tests2.cpp
@@ -0,0 +1,383 @@
+// -----------------------------------------------------------
+//              Copyright (c) 2001 Jeremy Siek
+//           Copyright (c) 2003-2006 Gennaro Prota
+//             Copyright (c) 2014 Ahmed Charles
+//             Copyright (c) 2018 Evgeny Shulgin
+//
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+//
+// -----------------------------------------------------------
+
+#include "bitset_test.hpp"
+#include <boost/dynamic_bitset/dynamic_bitset.hpp>
+#include <boost/config.hpp>
+
+
+template <typename Block>
+void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
+{
+  typedef boost::dynamic_bitset<Block> bitset_type;
+  typedef bitset_test< bitset_type > Tests;
+  const int bits_per_block = bitset_type::bits_per_block;
+
+  std::string long_string = get_long_string();
+
+  //=====================================================================
+  // Test operator&=
+  {
+    boost::dynamic_bitset<Block> lhs, rhs;
+    Tests::and_assignment(lhs, rhs);
+  }
+  {
+    boost::dynamic_bitset<Block> lhs(std::string("1")), rhs(std::string("0"));
+    Tests::and_assignment(lhs, rhs);
+  }
+  {
+    boost::dynamic_bitset<Block> lhs(long_string.size(), 0), rhs(long_string);
+    Tests::and_assignment(lhs, rhs);
+  }
+  {
+    boost::dynamic_bitset<Block> lhs(long_string.size(), 1), rhs(long_string);
+    Tests::and_assignment(lhs, rhs);
+  }
+  //=====================================================================
+  // Test operator |=
+  {
+    boost::dynamic_bitset<Block> lhs, rhs;
+    Tests::or_assignment(lhs, rhs);
+  }
+  {
+    boost::dynamic_bitset<Block> lhs(std::string("1")), rhs(std::string("0"));
+    Tests::or_assignment(lhs, rhs);
+  }
+  {
+    boost::dynamic_bitset<Block> lhs(long_string.size(), 0), rhs(long_string);
+    Tests::or_assignment(lhs, rhs);
+  }
+  {
+    boost::dynamic_bitset<Block> lhs(long_string.size(), 1), rhs(long_string);
+    Tests::or_assignment(lhs, rhs);
+  }
+  //=====================================================================
+  // Test operator^=
+  {
+    boost::dynamic_bitset<Block> lhs, rhs;
+    Tests::xor_assignment(lhs, rhs);
+  }
+  {
+    boost::dynamic_bitset<Block> lhs(std::string("1")), rhs(std::string("0"));
+    Tests::xor_assignment(lhs, rhs);
+  }
+  {
+    boost::dynamic_bitset<Block> lhs(std::string("0")), rhs(std::string("1"));
+    Tests::xor_assignment(lhs, rhs);
+  }
+  {
+    boost::dynamic_bitset<Block> lhs(long_string), rhs(long_string);
+    Tests::xor_assignment(lhs, rhs);
+  }
+  //=====================================================================
+  // Test operator-=
+  {
+    boost::dynamic_bitset<Block> lhs, rhs;
+    Tests::sub_assignment(lhs, rhs);
+  }
+  {
+    boost::dynamic_bitset<Block> lhs(std::string("1")), rhs(std::string("0"));
+    Tests::sub_assignment(lhs, rhs);
+  }
+  {
+    boost::dynamic_bitset<Block> lhs(std::string("0")), rhs(std::string("1"));
+    Tests::sub_assignment(lhs, rhs);
+  }
+  {
+    boost::dynamic_bitset<Block> lhs(long_string), rhs(long_string);
+    Tests::sub_assignment(lhs, rhs);
+  }
+  //=====================================================================
+  // Test operator<<=
+  { // case pos == 0
+    std::size_t pos = 0;
+    {
+      boost::dynamic_bitset<Block> b;
+      Tests::shift_left_assignment(b, pos);
+    }
+    {
+      boost::dynamic_bitset<Block> b(std::string("1010"));
+      Tests::shift_left_assignment(b, pos);
+    }
+    {
+      boost::dynamic_bitset<Block> b(long_string);
+      Tests::shift_left_assignment(b, pos);
+    }
+  }
+  {
+    // test with both multiple and
+    // non multiple of bits_per_block
+    const int how_many = 10;
+    for (int i = 1; i <= how_many; ++i) {
+        std::size_t     multiple = i * bits_per_block;
+        std::size_t non_multiple = multiple - 1;
+        boost::dynamic_bitset<Block> b(long_string);
+
+        Tests::shift_left_assignment(b, multiple);
+        Tests::shift_left_assignment(b, non_multiple);
+    }
+  }
+  { // case pos == size()/2
+    std::size_t pos = long_string.size() / 2;
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::shift_left_assignment(b, pos);
+  }
+  { // case pos >= n
+    std::size_t pos = long_string.size();
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::shift_left_assignment(b, pos);
+  }
+  //=====================================================================
+  // Test operator>>=
+  { // case pos == 0
+    std::size_t pos = 0;
+    {
+      boost::dynamic_bitset<Block> b;
+      Tests::shift_right_assignment(b, pos);
+    }
+    {
+      boost::dynamic_bitset<Block> b(std::string("1010"));
+      Tests::shift_right_assignment(b, pos);
+    }
+    {
+      boost::dynamic_bitset<Block> b(long_string);
+      Tests::shift_right_assignment(b, pos);
+    }
+  }
+  {
+    // test with both multiple and
+    // non multiple of bits_per_block
+    const int how_many = 10;
+    for (int i = 1; i <= how_many; ++i) {
+        std::size_t     multiple = i * bits_per_block;
+        std::size_t non_multiple = multiple - 1;
+        boost::dynamic_bitset<Block> b(long_string);
+
+        Tests::shift_right_assignment(b, multiple);
+        Tests::shift_right_assignment(b, non_multiple);
+    }
+
+  }
+  { // case pos == size()/2
+    std::size_t pos = long_string.size() / 2;
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::shift_right_assignment(b, pos);
+  }
+  { // case pos >= n
+    std::size_t pos = long_string.size();
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::shift_right_assignment(b, pos);
+  }
+  //=====================================================================
+  // test b.set()
+  {
+    boost::dynamic_bitset<Block> b;
+    Tests::set_all(b);
+  }
+  {
+    boost::dynamic_bitset<Block> b(std::string("0"));
+    Tests::set_all(b);
+  }
+  {
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::set_all(b);
+  }
+  //=====================================================================
+  // Test b.set(pos)
+  { // case pos >= b.size()
+    boost::dynamic_bitset<Block> b;
+    Tests::set_one(b, 0, true);
+    Tests::set_one(b, 0, false);
+  }
+  { // case pos < b.size()
+    boost::dynamic_bitset<Block> b(std::string("0"));
+    Tests::set_one(b, 0, true);
+    Tests::set_one(b, 0, false);
+  }
+  { // case pos == b.size() / 2
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::set_one(b, long_string.size()/2, true);
+    Tests::set_one(b, long_string.size()/2, false);
+  }
+  //=====================================================================
+  // Test b.set(pos, len)
+  { // case size is 1
+    boost::dynamic_bitset<Block> b(std::string("0"));
+    Tests::set_segment(b, 0, 1, true);
+    Tests::set_segment(b, 0, 1, false);
+  }
+  { // case fill the whole set
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::set_segment(b, 0, b.size(), true);
+    Tests::set_segment(b, 0, b.size(), false);
+  }
+  { // case pos = size / 4, len = size / 2
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::set_segment(b, b.size() / 4, b.size() / 2, true);
+    Tests::set_segment(b, b.size() / 4, b.size() / 2, false);
+  }
+  { // case pos = block_size / 2, len = size - block_size
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::set_segment(b, boost::dynamic_bitset<Block>::bits_per_block / 2,
+            b.size() - boost::dynamic_bitset<Block>::bits_per_block, true);
+    Tests::set_segment(b, boost::dynamic_bitset<Block>::bits_per_block / 2,
+            b.size() - boost::dynamic_bitset<Block>::bits_per_block, false);
+  }
+  { // case pos = 1, len = size - 2
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::set_segment(b, 1, b.size() - 2, true);
+    Tests::set_segment(b, 1, b.size() - 2, false);
+  }
+  { // case pos = 3, len = 7
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::set_segment(b, 3, 7, true);
+    Tests::set_segment(b, 3, 7, false);
+  }
+  //=====================================================================
+  // Test b.reset()
+  {
+    boost::dynamic_bitset<Block> b;
+    Tests::reset_all(b);
+  }
+  {
+    boost::dynamic_bitset<Block> b(std::string("0"));
+    Tests::reset_all(b);
+  }
+  {
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::reset_all(b);
+  }
+  //=====================================================================
+  // Test b.reset(pos)
+  { // case pos >= b.size()
+    boost::dynamic_bitset<Block> b;
+    Tests::reset_one(b, 0);
+  }
+  { // case pos < b.size()
+    boost::dynamic_bitset<Block> b(std::string("0"));
+    Tests::reset_one(b, 0);
+  }
+  { // case pos == b.size() / 2
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::reset_one(b, long_string.size()/2);
+  }
+  //=====================================================================
+  // Test b.reset(pos, len)
+  { // case size is 1
+    boost::dynamic_bitset<Block> b(std::string("0"));
+    Tests::reset_segment(b, 0, 1);
+  }
+  { // case fill the whole set
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::reset_segment(b, 0, b.size());
+  }
+  { // case pos = size / 4, len = size / 2
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::reset_segment(b, b.size() / 4, b.size() / 2);
+  }
+  { // case pos = block_size / 2, len = size - block_size
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::reset_segment(b, boost::dynamic_bitset<Block>::bits_per_block / 2,
+            b.size() - boost::dynamic_bitset<Block>::bits_per_block);
+  }
+  { // case pos = 1, len = size - 2
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::reset_segment(b, 1, b.size() - 2);
+  }
+  { // case pos = 3, len = 7
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::reset_segment(b, 3, 7);
+  }
+  //=====================================================================
+  // Test ~b
+  {
+    boost::dynamic_bitset<Block> b;
+    Tests::operator_flip(b);
+  }
+  {
+    boost::dynamic_bitset<Block> b(std::string("1"));
+    Tests::operator_flip(b);
+  }
+  {
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::operator_flip(b);
+  }
+  //=====================================================================
+  // Test b.flip()
+  {
+    boost::dynamic_bitset<Block> b;
+    Tests::flip_all(b);
+  }
+  {
+    boost::dynamic_bitset<Block> b(std::string("1"));
+    Tests::flip_all(b);
+  }
+  {
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::flip_all(b);
+  }
+  //=====================================================================
+  // Test b.flip(pos)
+  { // case pos >= b.size()
+    boost::dynamic_bitset<Block> b;
+    Tests::flip_one(b, 0);
+  }
+  { // case pos < b.size()
+    boost::dynamic_bitset<Block> b(std::string("0"));
+    Tests::flip_one(b, 0);
+  }
+  { // case pos == b.size() / 2
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::flip_one(b, long_string.size()/2);
+  }
+  //=====================================================================
+  // Test b.flip(pos, len)
+  { // case size is 1
+    boost::dynamic_bitset<Block> b(std::string("0"));
+    Tests::flip_segment(b, 0, 1);
+  }
+  { // case fill the whole set
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::flip_segment(b, 0, b.size());
+  }
+  { // case pos = size / 4, len = size / 2
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::flip_segment(b, b.size() / 4, b.size() / 2);
+  }
+  { // case pos = block_size / 2, len = size - block_size
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::flip_segment(b, boost::dynamic_bitset<Block>::bits_per_block / 2,
+            b.size() - boost::dynamic_bitset<Block>::bits_per_block);
+  }
+  { // case pos = 1, len = size - 2
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::flip_segment(b, 1, b.size() - 2);
+  }
+  { // case pos = 3, len = 7
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::flip_segment(b, 3, 7);
+  }
+}
+
+int
+main()
+{
+  run_test_cases<unsigned char>();
+  run_test_cases<unsigned short>();
+  run_test_cases<unsigned int>();
+  run_test_cases<unsigned long>();
+# ifdef BOOST_HAS_LONG_LONG
+  run_test_cases< ::boost::ulong_long_type>();
+# endif
+
+  return boost::report_errors();
+}
diff --git a/src/boost/libs/dynamic_bitset/test/dyn_bitset_unit_tests3.cpp b/src/boost/libs/dynamic_bitset/test/dyn_bitset_unit_tests3.cpp
new file mode 100644
index 00000000..5692c260
--- /dev/null
+++ b/src/boost/libs/dynamic_bitset/test/dyn_bitset_unit_tests3.cpp
@@ -0,0 +1,814 @@
+// -----------------------------------------------------------
+//              Copyright (c) 2001 Jeremy Siek
+//           Copyright (c) 2003-2006 Gennaro Prota
+//             Copyright (c) 2014 Ahmed Charles
+//          Copyright (c) 2014 Riccardo Marcangelo
+//
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+//
+// -----------------------------------------------------------
+
+#include <assert.h>
+#include "bitset_test.hpp"
+#include <boost/dynamic_bitset/dynamic_bitset.hpp>
+#include <boost/limits.hpp>
+#include <boost/config.hpp>
+
+template <typename Block>
+void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
+{
+  // a bunch of typedefs which will be handy later on
+  typedef boost::dynamic_bitset<Block> bitset_type;
+  typedef bitset_test<bitset_type> Tests;
+  // typedef typename bitset_type::size_type size_type; // unusable with Borland 5.5.1
+
+  std::string long_string = get_long_string();
+  std::size_t ul_width = std::numeric_limits<unsigned long>::digits;
+
+  //=====================================================================
+  // Test b.empty()
+  {
+    bitset_type b;
+    Tests::empty(b);
+  }
+  {
+    bitset_type b(1, 1ul);
+    Tests::empty(b);
+  }
+  {
+    bitset_type b(bitset_type::bits_per_block
+                  + bitset_type::bits_per_block/2, 15ul);
+    Tests::empty(b);
+  }
+  //=====================================================================
+  // Test b.to_long()
+  {
+    boost::dynamic_bitset<Block> b;
+    Tests::to_ulong(b);
+  }
+  {
+    boost::dynamic_bitset<Block> b(std::string("1"));
+    Tests::to_ulong(b);
+  }
+  {
+    boost::dynamic_bitset<Block> b(bitset_type::bits_per_block,
+                                   static_cast<unsigned long>(-1));
+    Tests::to_ulong(b);
+  }
+  {
+    std::string str(ul_width - 1, '1');
+    boost::dynamic_bitset<Block> b(str);
+    Tests::to_ulong(b);
+  }
+  {
+    std::string ul_str(ul_width, '1');
+    boost::dynamic_bitset<Block> b(ul_str);
+    Tests::to_ulong(b);
+  }
+  { // case overflow
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::to_ulong(b);
+  }
+  //=====================================================================
+  // Test to_string(b, str)
+  {
+    boost::dynamic_bitset<Block> b;
+    Tests::to_string(b);
+  }
+  {
+    boost::dynamic_bitset<Block> b(std::string("0"));
+    Tests::to_string(b);
+  }
+  {
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::to_string(b);
+  }
+  //=====================================================================
+  // Test b.count()
+  {
+    boost::dynamic_bitset<Block> b;
+    Tests::count(b);
+  }
+  {
+    boost::dynamic_bitset<Block> b(std::string("0"));
+    Tests::count(b);
+  }
+  {
+    boost::dynamic_bitset<Block> b(std::string("1"));
+    Tests::count(b);
+  }
+  {
+    boost::dynamic_bitset<Block> b(8, 255ul);
+    Tests::count(b);
+  }
+  {
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::count(b);
+  }
+  //=====================================================================
+  // Test b.size()
+  {
+    boost::dynamic_bitset<Block> b;
+    Tests::size(b);
+  }
+  {
+    boost::dynamic_bitset<Block> b(std::string("0"));
+    Tests::size(b);
+  }
+  {
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::size(b);
+  }
+  //=====================================================================
+  // Test b.capacity()
+  {
+    boost::dynamic_bitset<Block> b;
+    Tests::capacity_test_one(b);
+  }
+  {
+    boost::dynamic_bitset<Block> b(100);
+    Tests::capacity_test_two(b);
+  }
+  //=====================================================================
+  // Test b.reserve()
+  {
+    boost::dynamic_bitset<Block> b;
+    Tests::reserve_test_one(b);
+  }
+  {
+    boost::dynamic_bitset<Block> b(100);
+    Tests::reserve_test_two(b);
+  }
+  //=====================================================================
+  // Test b.shrink_to_fit()
+  {
+    boost::dynamic_bitset<Block> b;
+    Tests::shrink_to_fit_test_one(b);
+  }
+  {
+    boost::dynamic_bitset<Block> b(100);
+    Tests::shrink_to_fit_test_two(b);
+  }
+  //=====================================================================
+  // Test b.all()
+  {
+    boost::dynamic_bitset<Block> b;
+    Tests::all(b);
+    Tests::all(~b);
+    Tests::all(b.set());
+    Tests::all(b.reset());
+  }
+  {
+    boost::dynamic_bitset<Block> b(std::string("0"));
+    Tests::all(b);
+    Tests::all(~b);
+    Tests::all(b.set());
+    Tests::all(b.reset());
+  }
+  {
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::all(b);
+    Tests::all(~b);
+    Tests::all(b.set());
+    Tests::all(b.reset());
+  }
+  //=====================================================================
+  // Test b.any()
+  {
+    boost::dynamic_bitset<Block> b;
+    Tests::any(b);
+    Tests::any(~b);
+    Tests::any(b.set());
+    Tests::any(b.reset());
+  }
+  {
+    boost::dynamic_bitset<Block> b(std::string("0"));
+    Tests::any(b);
+    Tests::any(~b);
+    Tests::any(b.set());
+    Tests::any(b.reset());
+  }
+  {
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::any(b);
+    Tests::any(~b);
+    Tests::any(b.set());
+    Tests::any(b.reset());
+  }
+  //=====================================================================
+  // Test b.none()
+  {
+    boost::dynamic_bitset<Block> b;
+    Tests::none(b);
+    Tests::none(~b);
+    Tests::none(b.set());
+    Tests::none(b.reset());
+  }
+  {
+    boost::dynamic_bitset<Block> b(std::string("0"));
+    Tests::none(b);
+    Tests::none(~b);
+    Tests::none(b.set());
+    Tests::none(b.reset());
+  }
+  {
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::none(b);
+    Tests::none(~b);
+    Tests::none(b.set());
+    Tests::none(b.reset());
+  }
+  //=====================================================================
+  // Test a.is_subset_of(b)
+  {
+    boost::dynamic_bitset<Block> a, b;
+    Tests::subset(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(std::string("0")), b(std::string("0"));
+    Tests::subset(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(std::string("1")), b(std::string("1"));
+    Tests::subset(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(long_string), b(long_string);
+    Tests::subset(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(long_string), b(long_string);
+    a[long_string.size()/2].flip();
+    Tests::subset(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(long_string), b(long_string);
+    b[long_string.size()/2].flip();
+    Tests::subset(a, b);
+  }
+  //=====================================================================
+  // Test a.is_proper_subset_of(b)
+  {
+    boost::dynamic_bitset<Block> a, b;
+    Tests::proper_subset(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(std::string("0")), b(std::string("0"));
+    Tests::proper_subset(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(std::string("1")), b(std::string("1"));
+    Tests::proper_subset(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(long_string), b(long_string);
+    Tests::proper_subset(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(long_string), b(long_string);
+    a[long_string.size()/2].flip();
+    Tests::proper_subset(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(long_string), b(long_string);
+    b[long_string.size()/2].flip();
+    Tests::proper_subset(a, b);
+  }
+  //=====================================================================
+  // Test intersects
+  {
+    bitset_type a; // empty
+    bitset_type b;
+    Tests::intersects(a, b);
+  }
+  {
+    bitset_type a;
+    bitset_type b(5, 8ul);
+    Tests::intersects(a, b);
+  }
+  {
+    bitset_type a(8, 0ul);
+    bitset_type b(15, 0ul);
+    b[9] = 1;
+    Tests::intersects(a, b);
+  }
+  {
+    bitset_type a(15, 0ul);
+    bitset_type b(22, 0ul);
+    a[14] = b[14] = 1;
+    Tests::intersects(a, b);
+  }
+  //=====================================================================
+  // Test find_first
+  {
+      // empty bitset
+      bitset_type b;
+      Tests::find_first(b);
+  }
+  {
+      // bitset of size 1
+      bitset_type b(1, 1ul);
+      Tests::find_first(b);
+  }
+  {
+      // all-0s bitset
+      bitset_type b(4 * bitset_type::bits_per_block, 0ul);
+      Tests::find_first(b);
+  }
+  {
+      // first bit on
+      bitset_type b(1, 1ul);
+      Tests::find_first(b);
+  }
+  {
+      // last bit on
+      bitset_type b(4 * bitset_type::bits_per_block - 1, 0ul);
+      b.set(b.size() - 1);
+      Tests::find_first(b);
+  }
+  //=====================================================================
+  // Test find_next
+  {
+      // empty bitset
+      bitset_type b;
+
+      // check
+      Tests::find_next(b, 0);
+      Tests::find_next(b, 1);
+      Tests::find_next(b, 200);
+      Tests::find_next(b, b.npos);
+  }
+  {
+      // bitset of size 1 (find_next can never find)
+      bitset_type b(1, 1ul);
+
+      // check
+      Tests::find_next(b, 0);
+      Tests::find_next(b, 1);
+      Tests::find_next(b, 200);
+      Tests::find_next(b, b.npos);
+  }
+  {
+      // all-1s bitset
+      bitset_type b(16 * bitset_type::bits_per_block);
+      b.set();
+
+      // check
+      const typename bitset_type::size_type larger_than_size = 5 + b.size();
+      for(typename bitset_type::size_type i = 0; i <= larger_than_size; ++i) {
+          Tests::find_next(b, i);
+      }
+      Tests::find_next(b, b.npos);
+  }
+  {
+      // a bitset with 1s at block boundary only
+      const int num_blocks = 32;
+      const int block_width = bitset_type::bits_per_block;
+
+      bitset_type b(num_blocks * block_width);
+      typename bitset_type::size_type i = block_width - 1;
+      for ( ; i < b.size(); i += block_width) {
+
+        b.set(i);
+        typename bitset_type::size_type first_in_block = i - (block_width - 1);
+        b.set(first_in_block);
+      }
+
+      // check
+      const typename bitset_type::size_type larger_than_size = 5 + b.size();
+      for (i = 0; i <= larger_than_size; ++i) {
+          Tests::find_next(b, i);
+      }
+      Tests::find_next(b, b.npos);
+
+  }
+  {
+      // bitset with alternate 1s and 0s
+      const typename bitset_type::size_type sz = 1000;
+      bitset_type b(sz);
+
+      typename bitset_type::size_type i = 0;
+      for ( ; i < sz; ++i) {
+        b[i] = (i%2 == 0);
+      }
+
+      // check
+      const typename bitset_type::size_type larger_than_size = 5 + b.size();
+      for (i = 0; i <= larger_than_size; ++i) {
+          Tests::find_next(b, i);
+      }
+      Tests::find_next(b, b.npos);
+
+  }
+  //=====================================================================
+  // Test operator==
+  {
+    boost::dynamic_bitset<Block> a, b;
+    Tests::operator_equal(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(std::string("0")), b(std::string("0"));
+    Tests::operator_equal(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(std::string("1")), b(std::string("1"));
+    Tests::operator_equal(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(long_string), b(long_string);
+    Tests::operator_equal(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(long_string), b(long_string);
+    a[long_string.size()/2].flip();
+    Tests::operator_equal(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(long_string), b(long_string);
+    b[long_string.size()/2].flip();
+    Tests::operator_equal(a, b);
+  }
+  //=====================================================================
+  // Test operator!=
+  {
+    boost::dynamic_bitset<Block> a, b;
+    Tests::operator_not_equal(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(std::string("0")), b(std::string("0"));
+    Tests::operator_not_equal(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(std::string("1")), b(std::string("1"));
+    Tests::operator_not_equal(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(long_string), b(long_string);
+    Tests::operator_not_equal(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(long_string), b(long_string);
+    a[long_string.size()/2].flip();
+    Tests::operator_not_equal(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(long_string), b(long_string);
+    b[long_string.size()/2].flip();
+    Tests::operator_not_equal(a, b);
+  }
+  //=====================================================================
+  // Test operator<
+  {
+    boost::dynamic_bitset<Block> a, b;
+    Tests::operator_less_than(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(std::string("0")), b(std::string("0"));
+    Tests::operator_less_than(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(std::string("1")), b(std::string("1"));
+    Tests::operator_less_than(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(std::string("10")), b(std::string("11"));
+    Tests::operator_less_than(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(std::string("101")), b(std::string("11"));
+    Tests::operator_less_than(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(std::string("10")), b(std::string("111"));
+    Tests::operator_less_than(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(long_string), b(long_string);
+    Tests::operator_less_than(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(long_string), b(long_string);
+    a[long_string.size()/2].flip();
+    Tests::operator_less_than(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(long_string), b(long_string);
+    b[long_string.size()/2].flip();
+    Tests::operator_less_than(a, b);
+  }
+  // check for consistency with ulong behaviour when the sizes are equal
+  {
+    boost::dynamic_bitset<Block> a(3, 4ul), b(3, 5ul);
+    assert(a < b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(3, 4ul), b(3, 4ul);
+    assert(!(a < b));
+  }
+  {
+    boost::dynamic_bitset<Block> a(3, 5ul), b(3, 4ul);
+    assert(!(a < b));
+  }
+  // when the sizes are not equal lexicographic compare does not necessarily correspond to ulong behavior
+  {
+    boost::dynamic_bitset<Block> a(4, 4ul), b(3, 5ul);
+    assert(a < b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(3, 4ul), b(4, 5ul);
+    assert(!(a < b));
+  }
+  {
+    boost::dynamic_bitset<Block> a(4, 4ul), b(3, 4ul);
+    assert(a < b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(3, 4ul), b(4, 4ul);
+    assert(!(a < b));
+  }
+  {
+    boost::dynamic_bitset<Block> a(4, 5ul), b(3, 4ul);
+    assert(a < b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(3, 5ul), b(4, 4ul);
+    assert(!(a < b));
+  }
+  //=====================================================================
+  // Test operator<=
+  {
+    boost::dynamic_bitset<Block> a, b;
+    Tests::operator_less_than_eq(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(std::string("0")), b(std::string("0"));
+    Tests::operator_less_than_eq(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(std::string("1")), b(std::string("1"));
+    Tests::operator_less_than_eq(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(long_string), b(long_string);
+    Tests::operator_less_than_eq(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(long_string), b(long_string);
+    a[long_string.size()/2].flip();
+    Tests::operator_less_than_eq(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(long_string), b(long_string);
+    b[long_string.size()/2].flip();
+    Tests::operator_less_than_eq(a, b);
+  }
+  // check for consistency with ulong behaviour
+  {
+    boost::dynamic_bitset<Block> a(3, 4ul), b(3, 5ul);
+    assert(a <= b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(3, 4ul), b(3, 4ul);
+    assert(a <= b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(3, 5ul), b(3, 4ul);
+    assert(!(a <= b));
+  }
+  //=====================================================================
+  // Test operator>
+  {
+    boost::dynamic_bitset<Block> a, b;
+    Tests::operator_greater_than(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(std::string("0")), b(std::string("0"));
+    Tests::operator_greater_than(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(std::string("1")), b(std::string("1"));
+    Tests::operator_greater_than(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(long_string), b(long_string);
+    Tests::operator_greater_than(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(long_string), b(long_string);
+    a[long_string.size()/2].flip();
+    Tests::operator_greater_than(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(long_string), b(long_string);
+    b[long_string.size()/2].flip();
+    Tests::operator_greater_than(a, b);
+  }
+  // check for consistency with ulong behaviour
+  {
+    boost::dynamic_bitset<Block> a(3, 4ul), b(3, 5ul);
+    assert(!(a > b));
+  }
+  {
+    boost::dynamic_bitset<Block> a(3, 4ul), b(3, 4ul);
+    assert(!(a > b));
+  }
+  {
+    boost::dynamic_bitset<Block> a(3, 5ul), b(3, 4ul);
+    assert(a > b);
+  }
+  //=====================================================================
+  // Test operator<=
+  {
+    boost::dynamic_bitset<Block> a, b;
+    Tests::operator_greater_than_eq(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(std::string("0")), b(std::string("0"));
+    Tests::operator_greater_than_eq(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(std::string("1")), b(std::string("1"));
+    Tests::operator_greater_than_eq(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(long_string), b(long_string);
+    Tests::operator_greater_than_eq(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(long_string), b(long_string);
+    a[long_string.size()/2].flip();
+    Tests::operator_greater_than_eq(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(long_string), b(long_string);
+    b[long_string.size()/2].flip();
+    Tests::operator_greater_than_eq(a, b);
+  }
+  // check for consistency with ulong behaviour
+  {
+    boost::dynamic_bitset<Block> a(3, 4ul), b(3, 5ul);
+    assert(!(a >= b));
+  }
+  {
+    boost::dynamic_bitset<Block> a(3, 4ul), b(3, 4ul);
+    assert(a >= b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(3, 5ul), b(3, 4ul);
+    assert(a >= b);
+  }
+  //=====================================================================
+  // Test b.test(pos)
+  { // case pos >= b.size()
+    boost::dynamic_bitset<Block> b;
+    Tests::test_bit(b, 0);
+  }
+  { // case pos < b.size()
+    boost::dynamic_bitset<Block> b(std::string("0"));
+    Tests::test_bit(b, 0);
+  }
+  { // case pos == b.size() / 2
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::test_bit(b, long_string.size()/2);
+  }
+  //=====================================================================
+  // Test b.test_set(pos)
+  { // case pos >= b.size()
+    boost::dynamic_bitset<Block> b;
+    Tests::test_set_bit(b, 0, true);
+    Tests::test_set_bit(b, 0, false);
+  }
+  { // case pos < b.size()
+    boost::dynamic_bitset<Block> b(std::string("0"));
+    Tests::test_set_bit(b, 0, true);
+    Tests::test_set_bit(b, 0, false);
+  }
+  { // case pos == b.size() / 2
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::test_set_bit(b, long_string.size() / 2, true);
+    Tests::test_set_bit(b, long_string.size() / 2, false);
+  }
+  //=====================================================================
+  // Test b << pos
+  { // case pos == 0
+    std::size_t pos = 0;
+    boost::dynamic_bitset<Block> b(std::string("1010"));
+    Tests::operator_shift_left(b, pos);
+  }
+  { // case pos == size()/2
+    std::size_t pos = long_string.size() / 2;
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::operator_shift_left(b, pos);
+  }
+  { // case pos >= n
+    std::size_t pos = long_string.size();
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::operator_shift_left(b, pos);
+  }
+  //=====================================================================
+  // Test b >> pos
+  { // case pos == 0
+    std::size_t pos = 0;
+    boost::dynamic_bitset<Block> b(std::string("1010"));
+    Tests::operator_shift_right(b, pos);
+  }
+  { // case pos == size()/2
+    std::size_t pos = long_string.size() / 2;
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::operator_shift_right(b, pos);
+  }
+  { // case pos >= n
+    std::size_t pos = long_string.size();
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::operator_shift_right(b, pos);
+  }
+  //=====================================================================
+  // Test a & b
+  {
+    boost::dynamic_bitset<Block> lhs, rhs;
+    Tests::operator_and(lhs, rhs);
+  }
+  {
+    boost::dynamic_bitset<Block> lhs(std::string("1")), rhs(std::string("0"));
+    Tests::operator_and(lhs, rhs);
+  }
+  {
+    boost::dynamic_bitset<Block> lhs(long_string.size(), 0), rhs(long_string);
+    Tests::operator_and(lhs, rhs);
+  }
+  {
+    boost::dynamic_bitset<Block> lhs(long_string.size(), 1), rhs(long_string);
+    Tests::operator_and(lhs, rhs);
+  }
+  //=====================================================================
+  // Test a | b
+  {
+    boost::dynamic_bitset<Block> lhs, rhs;
+    Tests::operator_or(lhs, rhs);
+  }
+  {
+    boost::dynamic_bitset<Block> lhs(std::string("1")), rhs(std::string("0"));
+    Tests::operator_or(lhs, rhs);
+  }
+  {
+    boost::dynamic_bitset<Block> lhs(long_string.size(), 0), rhs(long_string);
+    Tests::operator_or(lhs, rhs);
+  }
+  {
+    boost::dynamic_bitset<Block> lhs(long_string.size(), 1), rhs(long_string);
+    Tests::operator_or(lhs, rhs);
+  }
+  //=====================================================================
+  // Test a^b
+  {
+    boost::dynamic_bitset<Block> lhs, rhs;
+    Tests::operator_xor(lhs, rhs);
+  }
+  {
+    boost::dynamic_bitset<Block> lhs(std::string("1")), rhs(std::string("0"));
+    Tests::operator_xor(lhs, rhs);
+  }
+  {
+    boost::dynamic_bitset<Block> lhs(long_string.size(), 0), rhs(long_string);
+    Tests::operator_xor(lhs, rhs);
+  }
+  {
+    boost::dynamic_bitset<Block> lhs(long_string.size(), 1), rhs(long_string);
+    Tests::operator_xor(lhs, rhs);
+  }
+  //=====================================================================
+  // Test a-b
+  {
+    boost::dynamic_bitset<Block> lhs, rhs;
+    Tests::operator_sub(lhs, rhs);
+  }
+  {
+    boost::dynamic_bitset<Block> lhs(std::string("1")), rhs(std::string("0"));
+    Tests::operator_sub(lhs, rhs);
+  }
+  {
+    boost::dynamic_bitset<Block> lhs(long_string.size(), 0), rhs(long_string);
+    Tests::operator_sub(lhs, rhs);
+  }
+  {
+    boost::dynamic_bitset<Block> lhs(long_string.size(), 1), rhs(long_string);
+    Tests::operator_sub(lhs, rhs);
+  }
+}
+
+
+int
+main()
+{
+  run_test_cases<unsigned char>();
+  run_test_cases<unsigned short>();
+  run_test_cases<unsigned int>();
+  run_test_cases<unsigned long>();
+# ifdef BOOST_HAS_LONG_LONG
+  run_test_cases< ::boost::ulong_long_type>();
+# endif
+
+  return boost::report_errors();
+}
diff --git a/src/boost/libs/dynamic_bitset/test/dyn_bitset_unit_tests4.cpp b/src/boost/libs/dynamic_bitset/test/dyn_bitset_unit_tests4.cpp
new file mode 100644
index 00000000..413fddd0
--- /dev/null
+++ b/src/boost/libs/dynamic_bitset/test/dyn_bitset_unit_tests4.cpp
@@ -0,0 +1,338 @@
+// -----------------------------------------------------------
+//              Copyright (c) 2001 Jeremy Siek
+//           Copyright (c) 2003-2006 Gennaro Prota
+//
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+//
+// -----------------------------------------------------------
+
+#include <fstream>
+#include <string>
+#include <cstddef>   // for std::size_t
+#include <stdexcept> // for std::logic_error
+#include <assert.h>
+
+#include <boost/config.hpp>
+#if !defined (BOOST_NO_STRINGSTREAM)
+# include <sstream>
+#endif
+
+#include "bitset_test.hpp"
+#include <boost/dynamic_bitset/dynamic_bitset.hpp>
+#include <boost/config/workaround.hpp>
+
+
+// Codewarrior 8.3 for Win fails without this.
+// Thanks Howard Hinnant ;)
+#if defined __MWERKS__ && BOOST_WORKAROUND(__MWERKS__, <= 0x3003) // 8.x
+# pragma parse_func_templ off
+#endif
+
+
+#if defined BOOST_NO_STD_WSTRING || defined BOOST_NO_STD_LOCALE
+# define BOOST_DYNAMIC_BITSET_NO_WCHAR_T_TESTS
+#endif
+
+#if !defined BOOST_DYNAMIC_BITSET_NO_WCHAR_T_TESTS
+std::wstring widen_string( const std::string & str,
+                           const std::locale & loc = std::locale() )
+{
+  std::wstring result;
+  const std::string::size_type len = str.length();
+  if(len != 0) {
+
+    typedef std::ctype<wchar_t> ct_type;
+    typedef std::wstring::traits_type tr_type;
+    const ct_type & ct = BOOST_USE_FACET(ct_type, loc);
+
+    result.resize(len);
+    for (std::size_t i = 0; i < len; ++i)
+        tr_type::assign(result[i], ct.widen(str[i]));
+
+  }
+  return result;
+}
+#endif
+
+template <typename Block>
+void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
+{
+
+  typedef boost::dynamic_bitset<Block> bitset_type;
+  typedef bitset_test<bitset_type> Tests;
+
+  //=====================================================================
+  // Test stream operator<<
+  {
+
+    // The test "variables" are: the stream type and its state, the
+    // exception mask, the width, the fill char and the padding side (left/right)
+
+    std::ios::iostate masks[] = {
+                                  std::ios::goodbit,
+                                  std::ios::eofbit,
+                                  std::ios::failbit,
+                                  std::ios::eofbit | std::ios::failbit
+                                };
+
+    static std::string strings[] = {
+                                  std::string(""),
+                                  std::string("0"),
+                                  std::string("1"),
+                                  std::string("11100"),
+                                  get_long_string()
+                                };
+
+    char fill_chars[] =         { '*', 'x', ' ' };
+
+    std::size_t num_masks   = sizeof(masks) / sizeof(masks[0]);
+    std::size_t num_strings = sizeof(strings) / sizeof(strings[0]);
+    std::size_t num_chars   = sizeof(fill_chars) / sizeof(fill_chars[0]);
+
+    std::fstream not_good_stream("dynamic_bitset_tests - this file shouldn't exist",
+                                 std::ios::in);
+
+
+    for (std::size_t mi = 0; mi < num_masks; ++mi) {
+      for (std::size_t si = 0; si < num_strings; ++si) {
+
+        std::streamsize slen = (std::streamsize)(strings[si].length());
+
+        assert( (std::numeric_limits<std::streamsize>::max)()
+                 >=(std::streamsize)(1+slen*2) );
+
+        for (std::size_t ci = 0; ci < num_chars; ++ci) {
+
+          // note how "negative widths" are tested too
+          const std::streamsize widths[] = { -1 - slen/2, 0, slen/2, 1 + slen*2 };
+          std::size_t num_widths = sizeof(widths) / sizeof(widths[0]);
+
+          for (std::size_t wi = 0; wi < num_widths; ++wi) {
+            std::streamsize w = widths[wi];
+            {
+              // test 0 - stream !good()
+              if(not_good_stream.good())
+                  throw std::logic_error("Error in operator << tests"
+                                         " - please, double check");
+              bitset_type b(strings[si]);
+              not_good_stream.width(w);
+              not_good_stream.fill(fill_chars[ci]);
+              try { not_good_stream.exceptions(masks[mi]); } catch(...) {}
+
+              Tests::stream_inserter(b, not_good_stream, "<unused_string>");
+            }
+            {
+              // test 1a - file stream
+              scoped_temp_file stf;
+              bitset_type b(strings[si]);
+              std::ofstream file(stf.path().string().c_str(), std::ios::trunc);
+              file.width(w);
+              file.fill(fill_chars[ci]);
+              file.exceptions(masks[mi]);
+              Tests::stream_inserter(b, file, stf.path().string().c_str());
+            }
+            {
+              //NOTE: there are NO string stream tests
+            }
+#if !defined (BOOST_DYNAMIC_BITSET_NO_WCHAR_T_TESTS)
+            {
+              // test 1b - wide file stream
+              scoped_temp_file stf;
+              bitset_type b(strings[si]);
+              std::wofstream file(stf.path().string().c_str());
+              file.width(w);
+              file.fill(fill_chars[ci]);
+              file.exceptions(masks[mi]);
+              Tests::stream_inserter(b, file, stf.path().string().c_str()); 
+            }
+#endif
+          }
+        }
+      }
+    } // for (; mi..)
+
+  }
+
+  //=====================================================================
+  // Test stream operator>>
+  {
+
+  // The test "variables" are: the stream type, the exception mask,
+  // the actual contents (and/or state) of the stream, and width.
+  //
+  // With few exceptions, each test case consists of writing a different
+  // assortment of digits and "whitespaces" to a text stream and then checking
+  // that what was written gets read back unchanged. That's NOT guaranteed by
+  // the standard, unless the assortment always ends with a '\n' and satisfies
+  // other conditions (see C99, 7.19.2/2), however it works in practice and is
+  // a good "real life" test. Some characters, such as '\v' and '\f', are not
+  // used exactly because they are the ones which will most likely give problems
+  // on some systems (for instance '\f' could actually be written as a sequence
+  // of new-lines, and we could never be able to read it back)
+  //
+  // Note how the bitset object is not initially empty. That helps checking
+  // that it isn't erroneously clear()ed by operator>>.
+
+
+  std::ios::iostate masks[] = {
+                                std::ios::goodbit,
+                                std::ios::eofbit,
+                                std::ios::failbit,
+                                std::ios::eofbit | std::ios::failbit
+                              };
+
+  const std::string spaces = "\t\n "; //"\t\n\v\f ";
+
+  const std::string long_string = get_long_string();
+  /*const*/ static std::string strings[] = {
+                  // NOTE: "const" gives the usual problems with Borland
+                  //       (in Tests::stream_extractor instantiation)
+
+
+#if !(defined __BORLANDC__     \
+      && BOOST_WORKAROUND(BOOST_RWSTD_VER, BOOST_TESTED_AT(0x20101)))
+                                        // Borland 5.5.1 with RW library crashes
+            // empty string
+            std::string(""),
+            // no bitset
+            spaces,
+#endif
+            // no bitset
+            std::string("x"),
+            std::string("\t  xyz"),
+
+            // bitset of size 1
+            std::string("0"),
+            std::string("1"),
+
+            std::string("  0  "),
+            std::string("  1  "),
+            spaces + "1",
+            "1" + spaces,
+            spaces + "1" + spaces,
+            std::string("  x1x  "),
+            std::string("  1x  "),
+
+            // long bitset
+            long_string,
+            "  " + long_string + " xyz",
+            spaces + long_string,
+            spaces + long_string + spaces
+    };
+
+
+  //-----------------------------------------------------
+
+  std::stringstream not_good_stream;
+  not_good_stream << "test";
+  std::string sink;
+  not_good_stream >> sink; // now the stream should be in eof state
+
+  const std::size_t num_masks = sizeof(masks) / sizeof(masks[0]);
+  const std::size_t num_strings = sizeof(strings) / sizeof(strings[0]);
+
+  for (std::size_t mi = 0; mi < num_masks; ++mi) {
+    for (std::size_t si = 0; si < num_strings; ++si) {
+
+      const std::streamsize slen = (std::streamsize)(strings[si].length());
+      assert((std::numeric_limits<std::streamsize>::max)() >= (std::streamsize)(1+slen*2));
+
+      std::streamsize widths[] = { -1, 0, slen/2, slen, 1 + slen*2 };
+      std::size_t num_widths = sizeof(widths) / sizeof(widths[0]);
+
+      for(std::size_t wi = 0; wi < num_widths; ++wi) {
+        const std::streamsize w = widths[wi];
+
+        // test 0 - !good() stream
+        {
+          if(not_good_stream.good())
+            throw std::logic_error("Error in operator >> tests"
+                                   " - please, double check");
+          bitset_type b(1, 15ul); // note: b is not empty
+          not_good_stream.width(w);
+          try { not_good_stream.exceptions(masks[mi]); } catch(...) {}
+          std::string irrelevant;
+          Tests::stream_extractor(b, not_good_stream, irrelevant);
+        }
+        // test 1a - (narrow) file stream
+        {
+          scoped_temp_file stf;
+          bitset_type b(1, 255ul);
+          {
+            std::ofstream f(stf.path().string().c_str());
+            f << strings[si];
+          }
+
+          std::ifstream f(stf.path().string().c_str());
+          f.width(w);
+          f.exceptions(masks[mi]);
+          Tests::stream_extractor(b, f, strings[si]);
+        }
+#if !defined(BOOST_NO_STRINGSTREAM)
+        // test 2a - stringstream
+        {
+          bitset_type b(1, 255ul);
+          std::istringstream stream(strings[si]);
+          stream.width(w);
+          stream.exceptions(masks[mi]);
+          Tests::stream_extractor(b, stream, strings[si]);
+        }
+#endif
+
+#if !defined(BOOST_DYNAMIC_BITSET_NO_WCHAR_T_TESTS)
+        // test 1b - wchar_t file stream
+        {
+          scoped_temp_file stf;
+          std::wstring wstr = widen_string(strings[si]);
+          bitset_type b(1, 255ul);
+          {
+            std::basic_ofstream<wchar_t> of(stf.path().string().c_str());
+            of << wstr;
+          }
+
+          std::basic_ifstream<wchar_t> f(stf.path().string().c_str());
+          f.width(w);
+          f.exceptions(masks[mi]);
+          Tests::stream_extractor(b, f, wstr);
+        }
+        // test 2b - wstringstream
+        {
+          bitset_type b(1, 255ul);
+          std::wstring wstr = widen_string(strings[si]);
+
+          std::wistringstream wstream(wstr);
+          wstream.width(w);
+          wstream.exceptions(masks[mi]);
+          Tests::stream_extractor(b, wstream, wstr);
+        }
+#endif // BOOST_DYNAMIC_BITSET_NO_WCHAR_T_TESTS
+
+      }
+    }
+
+  } // for ( mi = 0; ...)
+
+
+  }
+  //=====================================================================
+  // << Any other tests go here >>
+  //         .....
+
+}
+
+
+int
+main()
+{
+  run_test_cases<unsigned char>();
+  run_test_cases<unsigned short>();
+  run_test_cases<unsigned int>();
+  run_test_cases<unsigned long>();
+# ifdef BOOST_HAS_LONG_LONG
+  run_test_cases< ::boost::ulong_long_type>();
+# endif
+
+  return boost::report_errors();
+}
diff --git a/src/boost/libs/dynamic_bitset/test/dyn_bitset_unit_tests5.cpp b/src/boost/libs/dynamic_bitset/test/dyn_bitset_unit_tests5.cpp
new file mode 100644
index 00000000..79a60521
--- /dev/null
+++ b/src/boost/libs/dynamic_bitset/test/dyn_bitset_unit_tests5.cpp
@@ -0,0 +1,111 @@
+// -----------------------------------------------------------
+//              Copyright (c) 2001 Jeremy Siek
+//           Copyright (c) 2003-2006 Gennaro Prota
+//
+// Copyright (c) 2015 Seth Heeren
+//
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+//
+// -----------------------------------------------------------
+
+#include "boost/config.hpp"
+#if !defined (BOOST_NO_STRINGSTREAM)
+# include <sstream>
+#endif
+
+#include "bitset_test.hpp"
+#include <boost/dynamic_bitset/serialization.hpp>
+#include <boost/config/workaround.hpp>
+
+
+// Codewarrior 8.3 for Win fails without this.
+// Thanks Howard Hinnant ;)
+#if defined __MWERKS__ && BOOST_WORKAROUND(__MWERKS__, <= 0x3003) // 8.x
+# pragma parse_func_templ off
+#endif
+
+
+#if defined BOOST_NO_STD_WSTRING || defined BOOST_NO_STD_LOCALE
+# define BOOST_DYNAMIC_BITSET_NO_WCHAR_T_TESTS
+#endif
+
+#include <boost/archive/binary_oarchive.hpp>
+#include <boost/archive/binary_iarchive.hpp>
+#include <boost/archive/xml_oarchive.hpp>
+#include <boost/archive/xml_iarchive.hpp>
+#include <sstream>
+
+namespace {
+    template <typename Block>
+        struct SerializableType {
+            boost::dynamic_bitset<Block> x;
+
+          private:
+            friend class boost::serialization::access;
+            template <class Archive> void serialize(Archive &ar, const unsigned int) {
+                ar & BOOST_SERIALIZATION_NVP(x);
+            }
+        };
+
+    template <typename Block, typename IArchive, typename OArchive>
+        void test_serialization( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
+        {
+            SerializableType<Block> a;
+
+            for (int i=0; i<128; ++i)
+                a.x.resize(11*i, i%2);
+
+#if !defined (BOOST_NO_STRINGSTREAM)
+            std::stringstream ss;
+
+            // test serialization
+            {
+                OArchive oa(ss);
+                oa << BOOST_SERIALIZATION_NVP(a);
+            }
+
+            // test de-serialization
+            {
+                IArchive ia(ss);
+                SerializableType<Block> b;
+                ia >> BOOST_SERIALIZATION_NVP(b);
+
+                assert(a.x == b.x);
+            }
+#else
+#           error "TODO implement file-based test path?"
+#endif
+        }
+
+    template <typename Block>
+        void test_binary_archive( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) ) {
+            test_serialization<Block, boost::archive::binary_iarchive, boost::archive::binary_oarchive>();
+        }
+
+    template <typename Block>
+        void test_xml_archive( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) ) {
+            test_serialization<Block, boost::archive::xml_iarchive, boost::archive::xml_oarchive>();
+        }
+}
+
+template <typename Block>
+void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
+{
+    test_binary_archive<Block>();
+    test_xml_archive<Block>();
+}
+
+int main()
+{
+    run_test_cases<unsigned char>();
+    run_test_cases<unsigned short>();
+    run_test_cases<unsigned int>();
+    run_test_cases<unsigned long>();
+# ifdef BOOST_HAS_LONG_LONG
+    run_test_cases< ::boost::ulong_long_type>();
+# endif
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/dynamic_bitset/test/test_ambiguous_set.cpp b/src/boost/libs/dynamic_bitset/test/test_ambiguous_set.cpp
new file mode 100644
index 00000000..b51808a8
--- /dev/null
+++ b/src/boost/libs/dynamic_bitset/test/test_ambiguous_set.cpp
@@ -0,0 +1,30 @@
+//
+// Copyright (C) 2018 James E. King III
+// 
+// Permission to copy, use, modify, sell and distribute this software
+// is granted provided this copyright notice appears in all copies.
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <boost/dynamic_bitset.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+int main(int, char*[])
+{
+    boost::dynamic_bitset<> x(5); // all 0's by default
+    x.set(1, 2);
+    x.set(3, 1, true);
+    x.set(2, 1, false);
+    BOOST_TEST(!x.test(0));
+    BOOST_TEST( x.test(1));
+    BOOST_TEST(!x.test(2));
+    BOOST_TEST( x.test(3));
+    BOOST_TEST(!x.test(4));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/dynamic_bitset/test/test_boost_hash.cpp b/src/boost/libs/dynamic_bitset/test/test_boost_hash.cpp
new file mode 100644
index 00000000..85900642
--- /dev/null
+++ b/src/boost/libs/dynamic_bitset/test/test_boost_hash.cpp
@@ -0,0 +1,47 @@
+//
+// Copyright (C) 2019 James E. King III
+//
+// Permission to copy, use, modify, sell and distribute this software
+// is granted provided this copyright notice appears in all copies.
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <boost/config.hpp>
+#include <boost/dynamic_bitset.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <set>
+
+int main(int, char*[])
+{
+    typedef boost::dynamic_bitset<unsigned long> bitset_type;
+    const std::string long_string =
+        "01001110101110110101011010000000000011110101101111111111";
+    const std::string long_string_prime_begin =
+        "11001110101110110101011010000000000011110101101111111111";
+    const std::string long_string_prime_end =
+        "01001110101110110101011010000000000011110101101111111110";
+
+    bitset_type zeroes(long_string.size(), 0);
+    bitset_type stuff (long_string);
+    bitset_type stupb (long_string_prime_begin);
+    bitset_type stupe (long_string_prime_end);
+    bitset_type ones  (long_string.size(), 1);
+
+    boost::hash<bitset_type> bitset_hasher;
+    std::set<std::size_t> results;
+    results.insert(bitset_hasher(zeroes));
+    results.insert(bitset_hasher(stuff));
+    results.insert(bitset_hasher(stupb));
+    results.insert(bitset_hasher(stupe));
+    results.insert(bitset_hasher(ones));
+
+    // if any hash is identical to another there will be less than 5
+    BOOST_TEST_EQ(results.size(), 5);
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/dynamic_bitset/test/test_lowest_bit.cpp b/src/boost/libs/dynamic_bitset/test/test_lowest_bit.cpp
new file mode 100644
index 00000000..a31f19d6
--- /dev/null
+++ b/src/boost/libs/dynamic_bitset/test/test_lowest_bit.cpp
@@ -0,0 +1,28 @@
+//
+// Copyright (C) 2018 James E. King III
+// 
+// Permission to copy, use, modify, sell and distribute this software
+// is granted provided this copyright notice appears in all copies.
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <boost/cstdint.hpp>
+#include <boost/dynamic_bitset/detail/lowest_bit.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+int main(int, char*[])
+{
+    for (boost::int32_t i = 1; i < 32; ++i) {
+	BOOST_TEST_EQ(i, boost::detail::lowest_bit(1u << i));
+    }
+
+    BOOST_TEST_EQ(2, boost::detail::lowest_bit(123456788));
+    BOOST_TEST_EQ(30, boost::detail::lowest_bit(static_cast<boost::int64_t>(1507208177123328)));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/dynamic_bitset/test/test_std_hash.cpp b/src/boost/libs/dynamic_bitset/test/test_std_hash.cpp
new file mode 100644
index 00000000..2910b23f
--- /dev/null
+++ b/src/boost/libs/dynamic_bitset/test/test_std_hash.cpp
@@ -0,0 +1,39 @@
+//
+// Copyright (C) 2019 James E. King III
+//
+// Permission to copy, use, modify, sell and distribute this software
+// is granted provided this copyright notice appears in all copies.
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <boost/config.hpp>
+#include <boost/dynamic_bitset.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+#include <functional>
+#include <unordered_set>
+
+int main(int, char*[])
+{
+    typedef boost::dynamic_bitset<unsigned long> bitset_type;
+    const std::string long_string =
+        "01001110101110110101011010000000000011110101101111111111";
+
+    bitset_type zeroes(long_string.size(), 0);
+    bitset_type stuff (long_string);
+    bitset_type ones  (long_string.size(), 1);
+
+    std::unordered_set<bitset_type> bitsets;
+    bitsets.insert(zeroes);
+    bitsets.insert(stuff);
+    bitsets.insert(ones);
+
+    BOOST_TEST_EQ(bitsets.size(), 3);
+
+    return boost::report_errors();
+}