Adding upstream version 16.2.11+ds.upstream/16.2.11+dsupstream

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

107 files changed, 10041 insertions, 0 deletions

diff --git a/src/boost/libs/multi_index/README.md b/src/boost/libs/multi_index/README.md
new file mode 100644
index 000000000..93a9f2faa
--- /dev/null
+++ b/src/boost/libs/multi_index/README.md
@@ -0,0 +1,10 @@
+# Boost Multi-index Containers Library
+
+Branch   | Travis | AppVeyor | Regression tests
+---------|--------|----------|-----------------
+develop  | [![Build Status](https://travis-ci.com/boostorg/multi_index.svg?branch=develop)](https://travis-ci.com/boostorg/multi_index) | [![Build Status](https://ci.appveyor.com/api/projects/status/github/boostorg/multi_index?branch=develop&svg=true)](https://ci.appveyor.com/project/joaquintides/multi-index) | [![Test Results](./test_results.svg)](https://www.boost.org/development/tests/develop/developer/multi_index.html)
+master   | [![Build Status](https://travis-ci.com/boostorg/multi_index.svg?branch=master)](https://travis-ci.com/boostorg/multi_index) | [![Build Status](https://ci.appveyor.com/api/projects/status/github/boostorg/multi_index?branch=master&svg=true)](https://ci.appveyor.com/project/joaquintides/multi-index) | [![Test Results](./test_results.svg)](https://www.boost.org/development/tests/master/developer/multi_index.html)
+
+[Boost.MultiIndex](http://boost.org/libs/multi_index) provides a class template
+named `multi_index_container` which enables the construction of containers
+maintaining one or more indices with different sorting and access semantics.
diff --git a/src/boost/libs/multi_index/example/Jamfile.v2 b/src/boost/libs/multi_index/example/Jamfile.v2
new file mode 100644
index 000000000..a4dc9c318
--- /dev/null
+++ b/src/boost/libs/multi_index/example/Jamfile.v2
@@ -0,0 +1,69 @@
+# Boost.MultiIndex examples Jamfile
+#
+# Copyright 2003-2007 Joaquín M López Muñoz.
+# 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)
+#
+# See http://www.boost.org/libs/multi_index for library home page.
+
+exe basic
+    : basic.cpp
+    : <include>$(BOOST_ROOT)
+    ;
+
+exe bimap
+    : bimap.cpp
+    : <include>$(BOOST_ROOT)
+    ;
+
+exe complex_structs
+    : complex_structs.cpp
+    : <include>$(BOOST_ROOT)
+    ;
+
+exe composite_keys
+    : composite_keys.cpp
+    : <include>$(BOOST_ROOT)
+    ;
+
+exe fun_key
+    : fun_key.cpp
+    : <include>$(BOOST_ROOT)
+    ;
+
+exe hashed
+    : hashed.cpp
+    : <include>$(BOOST_ROOT)
+    ;
+
+exe ip_allocator
+    : ip_allocator.cpp
+    : <include>$(BOOST_ROOT) <threading>multi
+    ;
+
+exe non_default_ctor
+    : non_default_ctor.cpp
+    : <include>$(BOOST_ROOT)
+    ;
+
+exe random_access
+    : random_access.cpp
+    : <include>$(BOOST_ROOT)
+    ;
+
+exe rearrange
+    : rearrange.cpp
+    : <include>$(BOOST_ROOT)
+    ;
+
+exe sequenced
+    : sequenced.cpp
+    : <include>$(BOOST_ROOT)
+    ;
+
+exe serialization
+    : serialization.cpp
+      /boost/serialization//boost_serialization
+    : <include>$(BOOST_ROOT)
+    ;
diff --git a/src/boost/libs/multi_index/example/basic.cpp b/src/boost/libs/multi_index/example/basic.cpp
new file mode 100644
index 000000000..f7c46ced0
--- /dev/null
+++ b/src/boost/libs/multi_index/example/basic.cpp
@@ -0,0 +1,119 @@
+/* Boost.MultiIndex basic example.
+ *
+ * Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#if !defined(NDEBUG)
+#define BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING
+#define BOOST_MULTI_INDEX_ENABLE_SAFE_MODE
+#endif
+
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/member.hpp>
+#include <boost/multi_index/ordered_index.hpp>
+#include <algorithm>
+#include <iostream>
+#include <iterator>
+#include <string>
+
+using boost::multi_index_container;
+using namespace boost::multi_index;
+
+/* an employee record holds its ID, name and age */
+
+struct employee
+{
+  int         id;
+  std::string name;
+  int         age;
+
+  employee(int id_,std::string name_,int age_):id(id_),name(name_),age(age_){}
+
+  friend std::ostream& operator<<(std::ostream& os,const employee& e)
+  {
+    os<<e.id<<" "<<e.name<<" "<<e.age<<std::endl;
+    return os;
+  }
+};
+
+/* tags for accessing the corresponding indices of employee_set */
+
+struct id{};
+struct name{};
+struct age{};
+
+/* see Compiler specifics: Use of member_offset for info on
+ * BOOST_MULTI_INDEX_MEMBER
+ */
+
+/* Define a multi_index_container of employees with following indices:
+ *   - a unique index sorted by employee::int,
+ *   - a non-unique index sorted by employee::name,
+ *   - a non-unique index sorted by employee::age.
+ */
+
+typedef multi_index_container<
+  employee,
+  indexed_by<
+    ordered_unique<
+      tag<id>,  BOOST_MULTI_INDEX_MEMBER(employee,int,id)>,
+    ordered_non_unique<
+      tag<name>,BOOST_MULTI_INDEX_MEMBER(employee,std::string,name)>,
+    ordered_non_unique<
+      tag<age>, BOOST_MULTI_INDEX_MEMBER(employee,int,age)> >
+> employee_set;
+
+template<typename Tag,typename MultiIndexContainer>
+void print_out_by(const MultiIndexContainer& s)
+{
+  /* obtain a reference to the index tagged by Tag */
+
+  const typename boost::multi_index::index<MultiIndexContainer,Tag>::type& i=
+    get<Tag>(s);
+
+  typedef typename MultiIndexContainer::value_type value_type;
+
+  /* dump the elements of the index to cout */
+
+  std::copy(i.begin(),i.end(),std::ostream_iterator<value_type>(std::cout));
+}
+
+
+int main()
+{
+  employee_set es;
+
+  es.insert(employee(0,"Joe",31));
+  es.insert(employee(1,"Robert",27));
+  es.insert(employee(2,"John",40));
+
+  /* next insertion will fail, as there is an employee with
+   * the same ID
+   */
+
+  es.insert(employee(2,"Aristotle",2387));
+
+  es.insert(employee(3,"Albert",20));
+  es.insert(employee(4,"John",57));
+
+  /* list the employees sorted by ID, name and age */
+
+  std::cout<<"by ID"<<std::endl;
+  print_out_by<id>(es);
+  std::cout<<std::endl;
+
+  std::cout<<"by name"<<std::endl;
+  print_out_by<name>(es);
+  std::cout<<std::endl;
+
+  std::cout<<"by age"<<std::endl;
+  print_out_by<age>(es);
+  std::cout<<std::endl;
+
+  return 0;
+}
diff --git a/src/boost/libs/multi_index/example/bimap.cpp b/src/boost/libs/multi_index/example/bimap.cpp
new file mode 100644
index 000000000..aac99d06c
--- /dev/null
+++ b/src/boost/libs/multi_index/example/bimap.cpp
@@ -0,0 +1,149 @@
+/* Boost.MultiIndex example of a bidirectional map.
+ *
+ * Copyright 2003-2009 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#if !defined(NDEBUG)
+#define BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING
+#define BOOST_MULTI_INDEX_ENABLE_SAFE_MODE
+#endif
+
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/member.hpp>
+#include <boost/multi_index/ordered_index.hpp>
+#include <iostream>
+#include <string>
+
+using boost::multi_index_container;
+using namespace boost::multi_index;
+
+/* tags for accessing both sides of a bidirectional map */
+
+struct from{};
+struct to{};
+
+/* The class template bidirectional_map wraps the specification
+ * of a bidirectional map based on multi_index_container.
+ */
+
+template<typename FromType,typename ToType>
+struct bidirectional_map
+{
+  struct value_type
+  {
+    value_type(const FromType& first_,const ToType& second_):
+      first(first_),second(second_)
+    {}
+
+    FromType first;
+    ToType   second;
+  };
+
+#if defined(BOOST_NO_POINTER_TO_MEMBER_TEMPLATE_PARAMETERS) ||\
+    defined(BOOST_MSVC)&&(BOOST_MSVC<1300) ||\
+    defined(BOOST_INTEL_CXX_VERSION)&&defined(_MSC_VER)&&\
+           (BOOST_INTEL_CXX_VERSION<=700)
+
+/* see Compiler specifics: Use of member_offset for info on member<> and
+ * member_offset<>
+ */
+
+  BOOST_STATIC_CONSTANT(unsigned,from_offset=offsetof(value_type,first));
+  BOOST_STATIC_CONSTANT(unsigned,to_offset  =offsetof(value_type,second));
+
+  typedef multi_index_container<
+    value_type,
+    indexed_by<
+      ordered_unique<
+        tag<from>,member_offset<value_type,FromType,from_offset> >,
+      ordered_unique<
+        tag<to>,  member_offset<value_type,ToType,to_offset> >
+    >
+  > type;
+
+#else
+
+  /* A bidirectional map can be simulated as a multi_index_container
+   * of pairs of (FromType,ToType) with two unique indices, one
+   * for each member of the pair.
+   */
+
+  typedef multi_index_container<
+    value_type,
+    indexed_by<
+      ordered_unique<
+        tag<from>,member<value_type,FromType,&value_type::first> >,
+      ordered_unique<
+        tag<to>,  member<value_type,ToType,&value_type::second> >
+    >
+  > type;
+
+#endif
+};
+
+/* a dictionary is a bidirectional map from strings to strings */
+
+typedef bidirectional_map<std::string,std::string>::type dictionary;
+
+int main()
+{
+  dictionary d;
+
+  /* Fill up our microdictionary. first members Spanish, second members
+   * English.
+   */
+
+  d.insert(dictionary::value_type("hola","hello"));
+  d.insert(dictionary::value_type("adios","goodbye"));
+  d.insert(dictionary::value_type("rosa","rose"));
+  d.insert(dictionary::value_type("mesa","table"));
+
+
+  std::cout<<"enter a word"<<std::endl;
+  std::string word;
+  std::getline(std::cin,word);
+
+#if defined(BOOST_NO_MEMBER_TEMPLATES) /* use global get<> and family instead */
+
+  dictionary::iterator it=get<from>(d).find(word);
+  if(it!=d.end()){
+    std::cout<<word<<" is said "<<it->second<<" in English"<<std::endl;
+  }
+  else{
+    nth_index<dictionary,1>::type::iterator it2=get<1>(d).find(word);
+    if(it2!=get<1>(d).end()){
+      std::cout<<word<<" is said "<<it2->first<<" in Spanish"<<std::endl;
+    }
+    else std::cout<<"No such word in the dictionary"<<std::endl;
+  }
+
+#else
+
+  /* search the queried word on the from index (Spanish) */
+
+  dictionary::iterator it=d.get<from>().find(word);
+  if(it!=d.end()){ /* found */
+
+    /* the second part of the element is the equivalent in English */
+
+    std::cout<<word<<" is said "<<it->second<<" in English"<<std::endl;
+  }
+  else{
+    /* word not found in Spanish, try our luck in English */
+
+    dictionary::index<to>::type::iterator it2=d.get<to>().find(word);
+    if(it2!=d.get<to>().end()){
+      std::cout<<word<<" is said "<<it2->first<<" in Spanish"<<std::endl;
+    }
+    else std::cout<<"No such word in the dictionary"<<std::endl;
+  }
+
+#endif
+
+  return 0;
+}
diff --git a/src/boost/libs/multi_index/example/complex_structs.cpp b/src/boost/libs/multi_index/example/complex_structs.cpp
new file mode 100644
index 000000000..70eb78bcd
--- /dev/null
+++ b/src/boost/libs/multi_index/example/complex_structs.cpp
@@ -0,0 +1,315 @@
+/* Boost.MultiIndex example: complex searches and foreign keys.
+ *
+ * Copyright 2003-2008 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#if !defined(NDEBUG)
+#define BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING
+#define BOOST_MULTI_INDEX_ENABLE_SAFE_MODE
+#endif
+
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/member.hpp>
+#include <boost/multi_index/ordered_index.hpp>
+#include <boost/tuple/tuple.hpp>
+#include <iostream>
+#include <string>
+
+using boost::multi_index_container;
+using namespace boost::multi_index;
+
+/* This small utility that cascades two key extractors will be
+ * used througout the example.
+ */
+
+template<class KeyExtractor1,class KeyExtractor2>
+struct key_from_key
+{
+public:
+  typedef typename KeyExtractor1::result_type result_type;
+
+  key_from_key(
+    const KeyExtractor1& key1_=KeyExtractor1(),
+    const KeyExtractor2& key2_=KeyExtractor2()):
+    key1(key1_),key2(key2_)
+  {}
+
+  template<typename Arg>
+  result_type operator()(Arg& arg)const
+  {
+    return key1(key2(arg));
+  }
+
+private:
+  KeyExtractor1 key1;
+  KeyExtractor2 key2;
+};
+
+/* tags for accessing several indices defined below */
+
+struct model{};
+struct manufacturer{};
+struct price{};
+
+/* a manufacturer struct just holds the name of the manufacturer */
+
+struct car_manufacturer
+{
+  std::string name;
+
+  car_manufacturer(const std::string& name_):name(name_){}
+};
+
+/* car_model holds the model of car, its price and a pointer to the
+ * manufacturer. The pointer thing eliminates duplication of the same
+ * data among cars of the same manufacturer.
+ */
+
+struct car_model
+{
+  std::string             model;
+  const car_manufacturer* manufacturer;
+  int                     price;
+
+  car_model(
+    const std::string& model_,const car_manufacturer* manufacturer_,int price_):
+    model(model_),manufacturer(manufacturer_),price(price_)
+  {}
+
+  friend std::ostream& operator<<(std::ostream& os,const car_model& c)
+  {
+    os<<c.manufacturer->name<<" "<<c.model<<" $"<<c.price<<std::endl;
+    return os;
+  }
+};
+
+/* see Compiler specifics: Use of member_offset for info on
+ * BOOST_MULTI_INDEX_MEMBER
+ */
+
+/* Car manufacturers are stored in a multi_index_container with one single
+ * index on  the name member. This is functionally equivalent to an std::set,
+ * though in this latter case we woud have to define a non-default comparison
+ * predicate (with multi_index_container, member<> does the work for us.)
+ */
+
+typedef multi_index_container<
+  car_manufacturer,
+  indexed_by<
+    ordered_unique<
+      BOOST_MULTI_INDEX_MEMBER(car_manufacturer,std::string,name)
+    >
+  >
+> car_manufacturer_table;
+
+/* Define a multi_index_container of car_models with following indices:
+ *   - a unique index sorted by car_model::model,
+ *   - a non-unique index sorted by car_model::manufacturer; note the
+ *     non-standard manufacturer_extractor used.
+ *   - a non-unique index sorted by car_model::price.
+ */
+
+typedef multi_index_container<
+  car_model,
+  indexed_by<
+    ordered_unique<
+      tag<model>,BOOST_MULTI_INDEX_MEMBER(car_model,std::string,model)
+    >,
+    ordered_non_unique<
+      tag<manufacturer>,
+      key_from_key<
+        BOOST_MULTI_INDEX_MEMBER(car_manufacturer,const std::string,name),
+        BOOST_MULTI_INDEX_MEMBER(
+          car_model,const car_manufacturer *,manufacturer)
+      >
+    >,
+    ordered_non_unique<
+      tag<price>,BOOST_MULTI_INDEX_MEMBER(car_model,int,price)
+    >
+  >
+> car_table;
+
+/* We call a *view* to a multi_index_container storing pointers instead of
+ * actual objects. These views are used in the complex search performed
+ * in the program. Resorting to multi_index of pointers eliminates
+ * unnecessary copying of objects, and provides us with an opportunity
+ * to show how BOOST_MULTI_INDEX_MEMBER can be used with pointer
+ * type elements.
+ * car_table_price_view indexes (pointers to) car_models by price.
+ */
+
+typedef multi_index_container<
+  const car_model*,
+  indexed_by<
+    ordered_non_unique<BOOST_MULTI_INDEX_MEMBER(car_model,const int,price)>
+  >
+> car_table_price_view;
+
+/* car_table_manufacturer_view indexes (pointers to) car_models by
+ * manufacturer
+ */
+
+typedef multi_index_container<
+  const car_model*,
+  indexed_by<
+    ordered_non_unique<
+      key_from_key<
+        BOOST_MULTI_INDEX_MEMBER(car_manufacturer,const std::string,name),
+        BOOST_MULTI_INDEX_MEMBER(
+          car_model,const car_manufacturer * const,manufacturer)
+      >
+    >
+  >
+> car_table_manufacturer_view;
+
+int main()
+{
+  car_manufacturer_table cmt;
+
+  /* Fill the car_manufacturer table and keep pointers to the
+   * elements inserted.
+   */
+
+  const car_manufacturer * cadillac=
+    &*(cmt.insert(car_manufacturer("Cadillac")).first);
+  const car_manufacturer * ford    =
+    &*(cmt.insert(car_manufacturer("Ford")).first);
+  const car_manufacturer * bmw     =
+    &*(cmt.insert(car_manufacturer("BMW")).first);
+  const car_manufacturer * audi    =
+    &*(cmt.insert(car_manufacturer("Audi")).first);
+
+  car_table ct;
+
+  /* Fill the car_model_table. We use the previously initialized
+   * pointers to the elements of cmt.
+   */
+
+  ct.insert(car_model("XLR",cadillac,76200));
+  ct.insert(car_model("SRX",cadillac,38690));
+  ct.insert(car_model("CTS",cadillac,30695));
+  ct.insert(car_model("Escalade",cadillac,54770));
+  ct.insert(car_model("ESV",cadillac,57195));
+  ct.insert(car_model("EXT",cadillac,52045));
+  ct.insert(car_model("Deville",cadillac,45195));
+  ct.insert(car_model("Seville",cadillac,46330));
+
+  ct.insert(car_model("ZX2",ford,15355));
+  ct.insert(car_model("Thunderbird",ford,43995));
+  ct.insert(car_model("Windstar",ford,35510));
+  ct.insert(car_model("Focus",ford,19630));
+  ct.insert(car_model("Taurus",ford,24290));
+  ct.insert(car_model("Mustang",ford,39900));
+  ct.insert(car_model("Crown Victoria",ford,30370));
+
+  ct.insert(car_model("325i",bmw,27800));
+  ct.insert(car_model("545i",bmw,54300));
+  ct.insert(car_model("745i",bmw,68500));
+  ct.insert(car_model("M3 coupe",bmw,46500));
+  ct.insert(car_model("Z4 roadster 3.0i",bmw,40250));
+  ct.insert(car_model("X5 4.4i",bmw,49950));
+
+  ct.insert(car_model("A4 1.8T",audi,25940));
+  ct.insert(car_model("TT Coupe",audi,33940));
+  ct.insert(car_model("A6 3.0",audi,36640));
+  ct.insert(car_model("Allroad quattro 2.7T",audi,40640));
+  ct.insert(car_model("A8 L",audi,69190));
+
+  std::cout<<"enter a car manufacturer"<<std::endl;
+  std::string cm;
+  std::getline(std::cin,cm);
+  
+  /* check for manufacturer */
+  
+  car_manufacturer_table::iterator icm=cmt.find(cm);
+  
+  if(icm==cmt.end()){
+    std::cout<<"no such manufacturer in the table"<<std::endl;
+    return 0;
+  }
+
+  std::cout<<"enter a minimum price"<<std::endl;
+  int min_price;
+  std::cin>>min_price;
+  std::cout<<"enter a maximum price"<<std::endl;
+  int max_price;
+  std::cin>>max_price;
+
+  {
+    /* method 1 */
+
+    /* find all the cars for the manufacturer given */
+
+    boost::multi_index::index<car_table,manufacturer>::type::iterator ic0,ic1;
+    boost::tuples::tie(ic0,ic1)=get<manufacturer>(ct).equal_range(cm);
+
+    /* construct a view (indexed by price) with these */
+
+    car_table_price_view ctpv;
+    while(ic0!=ic1){
+      ctpv.insert(&*ic0);
+      ++ic0;
+    }
+
+    /* select the cars in the range given */
+
+    car_table_price_view::iterator ictpv0=ctpv.lower_bound(min_price);
+    car_table_price_view::iterator ictpv1=ctpv.upper_bound(max_price);
+    if(ictpv0==ictpv1){
+      std::cout<<"no cars in the range given"<<std::endl;
+      return 0;
+    }
+
+    /* list them */
+
+    std::cout<<"listing by method 1"<<std::endl;
+    while(ictpv0!=ictpv1){
+      std::cout<<**ictpv0;
+      ++ictpv0;
+    }
+    std::cout<<std::endl;
+  }
+
+  {
+    /* method 2 will give the same results */
+
+    /* find the cars in the range given */
+
+    boost::multi_index::index<car_table,price>::type::iterator ic0,ic1;
+    ic0=get<price>(ct).lower_bound(min_price);
+    ic1=get<price>(ct).upper_bound(max_price);
+
+    /* construct a view with these */
+
+    car_table_manufacturer_view ctmv;
+    while(ic0!=ic1){
+      ctmv.insert(&*ic0);
+      ++ic0;
+    }
+
+    /* select the cars with given manufacturer */
+
+    car_table_manufacturer_view::iterator ictmv0,ictmv1;
+    boost::tuples::tie(ictmv0,ictmv1)=ctmv.equal_range(cm);
+    if(ictmv0==ictmv1){
+      std::cout<<"no cars in the range given"<<std::endl;
+      return 0;
+    }
+
+    /* list them */
+
+    std::cout<<"listing by method 2"<<std::endl;
+    while(ictmv0!=ictmv1){
+      std::cout<<**ictmv0;
+      ++ictmv0;
+    }
+    std::cout<<std::endl;
+  }
+
+  return 0;
+}
diff --git a/src/boost/libs/multi_index/example/composite_keys.cpp b/src/boost/libs/multi_index/example/composite_keys.cpp
new file mode 100644
index 000000000..e9da2affa
--- /dev/null
+++ b/src/boost/libs/multi_index/example/composite_keys.cpp
@@ -0,0 +1,285 @@
+/* Boost.MultiIndex example of composite keys.
+ *
+ * Copyright 2003-2008 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#if !defined(NDEBUG)
+#define BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING
+#define BOOST_MULTI_INDEX_ENABLE_SAFE_MODE
+#endif
+
+#include <boost/call_traits.hpp>
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/composite_key.hpp>
+#include <boost/multi_index/member.hpp>
+#include <boost/multi_index/ordered_index.hpp>
+#include <boost/next_prior.hpp>
+#include <boost/tokenizer.hpp>
+#include <functional>
+#include <iostream>
+#include <iterator>
+#include <map>
+#include <string>
+
+using namespace boost::multi_index;
+
+/* A file record maintains some info on name and size as well
+ * as a pointer to the directory it belongs (null meaning the root
+ * directory.)
+ */
+
+struct file_entry
+{
+  file_entry(
+    std::string name_,unsigned size_,bool is_dir_,const file_entry* dir_):
+    name(name_),size(size_),is_dir(is_dir_),dir(dir_)
+  {}
+
+  std::string       name;
+  unsigned          size;
+  bool              is_dir;
+  const file_entry* dir;
+
+  friend std::ostream& operator<<(std::ostream& os,const file_entry& f)
+  {
+    os<<f.name<<"\t"<<f.size;
+    if(f.is_dir)os<<"\t <dir>";
+    return os;
+  }
+};
+
+/* A file system is just a multi_index_container of entries with indices on
+ * file and size. These indices are firstly ordered by directory, as commands
+ * work on a current directory basis. Composite keys are just fine to model
+ * this.
+ * NB: The use of derivation here instead of simple typedef is explained in
+ * Compiler specifics: type hiding.
+ */
+
+struct name_key:composite_key<
+  file_entry,
+  BOOST_MULTI_INDEX_MEMBER(file_entry,const file_entry*,dir),
+  BOOST_MULTI_INDEX_MEMBER(file_entry,std::string,name)
+>{};
+
+struct size_key:composite_key<
+  file_entry,
+  BOOST_MULTI_INDEX_MEMBER(file_entry,const file_entry* const,dir),
+  BOOST_MULTI_INDEX_MEMBER(file_entry,unsigned,size)
+>{};
+
+/* see Compiler specifics: composite_key in compilers without partial
+ * template specialization, for info on composite_key_result_less
+ */
+
+typedef multi_index_container<
+  file_entry,
+  indexed_by<
+    /* primary index sorted by name (inside the same directory) */
+    ordered_unique<name_key>,
+    /* secondary index sorted by size (inside the same directory) */
+    ordered_non_unique<size_key>
+  >
+> file_system;
+
+/* typedef's of the two indices of file_system */
+
+typedef nth_index<file_system,0>::type file_system_by_name;
+typedef nth_index<file_system,1>::type file_system_by_size;
+
+/* We build a rudimentary file system simulation out of some global
+ * info and a map of commands provided to the user.
+ */
+
+static file_system fs;                 /* the one and only file system */
+static file_system_by_name& fs_by_name=fs;         /* name index to fs */
+static file_system_by_size& fs_by_size=get<1>(fs); /* size index to fs */
+static const file_entry* current_dir=0;            /* root directory   */
+
+/* command framework */
+
+/* A command provides an execute memfun fed with the corresponding params
+ * (first param is stripped off as it serves to identify the command
+ * currently being used.)
+ */
+
+typedef boost::tokenizer<boost::char_separator<char> > command_tokenizer;
+
+class command
+{
+public:
+  virtual ~command(){}
+  virtual void execute(
+    command_tokenizer::iterator tok1,command_tokenizer::iterator tok2)=0;
+};
+
+/* available commands */
+
+/* cd: syntax cd [.|..|<directory>] */
+
+class command_cd:public command
+{
+public:
+  virtual void execute(
+    command_tokenizer::iterator tok1,command_tokenizer::iterator tok2)
+  {
+    if(tok1==tok2)return;
+    std::string dir=*tok1++;
+
+    if(dir==".")return;
+    if(dir==".."){
+      if(current_dir)current_dir=current_dir->dir;
+      return;
+    }
+
+    file_system_by_name::iterator it=fs.find(
+      boost::make_tuple(current_dir,dir));
+    if(it==fs.end()){
+      std::cout<<"non-existent directory"<<std::endl;
+      return;
+    }
+    if(!it->is_dir){
+      std::cout<<dir<<" is not a directory"<<std::endl;
+      return;
+    }
+    current_dir=&*it;
+  }
+};
+static command_cd cd;
+
+/* ls: syntax ls [-s] */
+
+class command_ls:public command
+{
+public:
+  virtual void execute(
+    command_tokenizer::iterator tok1,command_tokenizer::iterator tok2)
+  {
+    std::string option;
+    if(tok1!=tok2)option=*tok1++;
+
+    if(!option.empty()){
+      if(option!="-s"){
+        std::cout<<"incorrect parameter"<<std::endl;
+        return;
+      }
+
+      /* list by size */
+
+      file_system_by_size::iterator it0,it1;
+      boost::tie(it0,it1)=fs_by_size.equal_range(
+        boost::make_tuple(current_dir));
+      std::copy(it0,it1,std::ostream_iterator<file_entry>(std::cout,"\n"));
+
+      return;
+    }
+
+    /* list by name */
+
+    file_system_by_name::iterator it0,it1;
+    boost::tie(it0,it1)=fs.equal_range(boost::make_tuple(current_dir));
+    std::copy(it0,it1,std::ostream_iterator<file_entry>(std::cout,"\n"));
+  }
+};
+static command_ls ls;
+
+/* mkdir: syntax mkdir <directory> */
+
+class command_mkdir:public command
+{
+public:
+  virtual void execute(
+    command_tokenizer::iterator tok1,command_tokenizer::iterator tok2)
+  {
+    std::string dir;
+    if(tok1!=tok2)dir=*tok1++;
+
+    if(dir.empty()){
+      std::cout<<"missing parameter"<<std::endl;
+      return;
+    }
+
+    if(dir=="."||dir==".."){
+      std::cout<<"incorrect parameter"<<std::endl;
+      return;
+    }
+
+    if(!fs.insert(file_entry(dir,0,true,current_dir)).second){
+      std::cout<<"directory already exists"<<std::endl;
+      return;
+    }
+  }
+};
+static command_mkdir mkdir;
+
+/* table of commands, a map from command names to class command pointers */
+
+typedef std::map<std::string,command*> command_table;
+static command_table cmt;
+
+int main()
+{
+  /* fill the file system with some data */
+
+  file_system::iterator it0,it1;
+  
+  fs.insert(file_entry("usr.cfg",240,false,0));
+  fs.insert(file_entry("memo.txt",2430,false,0));
+  it0=fs.insert(file_entry("dev",0,true,0)).first;
+    fs.insert(file_entry("tty0",128,false,&*it0));
+    fs.insert(file_entry("tty1",128,false,&*it0));
+  it0=fs.insert(file_entry("usr",0,true,0)).first;
+    it1=fs.insert(file_entry("bin",0,true,&*it0)).first;
+      fs.insert(file_entry("bjam",172032,false,&*it1));
+  it0=fs.insert(file_entry("home",0,true,0)).first;
+    it1=fs.insert(file_entry("andy",0,true,&*it0)).first;
+      fs.insert(file_entry("logo.jpg",5345,false,&*it1)).first;
+      fs.insert(file_entry("foo.cpp",890,false,&*it1)).first;
+      fs.insert(file_entry("foo.hpp",93,false,&*it1)).first;
+      fs.insert(file_entry("foo.html",750,false,&*it1)).first;
+      fs.insert(file_entry("a.obj",12302,false,&*it1)).first;
+      fs.insert(file_entry(".bash_history",8780,false,&*it1)).first;
+    it1=fs.insert(file_entry("rachel",0,true,&*it0)).first;
+      fs.insert(file_entry("test.py",650,false,&*it1)).first;
+      fs.insert(file_entry("todo.txt",241,false,&*it1)).first;
+      fs.insert(file_entry(".bash_history",9510,false,&*it1)).first;
+
+  /* fill the command table */
+
+  cmt["cd"]   =&cd;
+  cmt["ls"]   =&ls;
+  cmt["mkdir"]=&mkdir;
+
+  /* main looop */
+
+  for(;;){
+    /* print out the current directory and the prompt symbol */
+
+    if(current_dir)std::cout<<current_dir->name;
+    std::cout<<">";
+
+    /* get an input line from the user: if empty, exit the program */
+
+    std::string com;
+    std::getline(std::cin,com);
+    command_tokenizer tok(com,boost::char_separator<char>(" \t\n"));
+    if(tok.begin()==tok.end())break; /* null command, exit */
+
+    /* select the corresponding command and execute it */
+
+    command_table::iterator it=cmt.find(*tok.begin());
+    if(it==cmt.end()){
+      std::cout<<"invalid command"<<std::endl;
+      continue;
+    }
+
+    it->second->execute(boost::next(tok.begin()),tok.end());
+  }
+  
+  return 0;
+}
diff --git a/src/boost/libs/multi_index/example/fun_key.cpp b/src/boost/libs/multi_index/example/fun_key.cpp
new file mode 100644
index 000000000..769d7bf6c
--- /dev/null
+++ b/src/boost/libs/multi_index/example/fun_key.cpp
@@ -0,0 +1,100 @@
+/* Boost.MultiIndex example of functions used as key extractors.
+ *
+ * Copyright 2003-2008 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#if !defined(NDEBUG)
+#define BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING
+#define BOOST_MULTI_INDEX_ENABLE_SAFE_MODE
+#endif
+
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/global_fun.hpp>
+#include <boost/multi_index/mem_fun.hpp>
+#include <boost/multi_index/ordered_index.hpp>
+#include <iostream>
+#include <string>
+
+using namespace boost::multi_index;
+
+/* A name record consists of the given name (e.g. "Charlie")
+ * and the family name (e.g. "Brown"). The full name, calculated
+ * by name_record::name() is laid out in the "phonebook order"
+ * family name + given_name.
+ */
+
+struct name_record
+{
+  name_record(std::string given_name_,std::string family_name_):
+    given_name(given_name_),family_name(family_name_)
+  {}
+
+  std::string name()const
+  {
+    std::string str=family_name;
+    str+=" ";
+    str+=given_name;
+    return str;
+  }
+
+private:
+  std::string given_name;
+  std::string family_name;
+};
+
+std::string::size_type name_record_length(const name_record& r)
+{
+  return r.name().size();
+}
+
+/* multi_index_container with indices based on name_record::name()
+ * and name_record_length().
+ * See Compiler specifics: Use of const_mem_fun_explicit and
+ * mem_fun_explicit for info on BOOST_MULTI_INDEX_CONST_MEM_FUN.
+ */
+
+typedef multi_index_container<
+  name_record,
+  indexed_by<
+    ordered_unique<
+      BOOST_MULTI_INDEX_CONST_MEM_FUN(name_record,std::string,name)
+    >,
+    ordered_non_unique<
+      global_fun<const name_record&,std::string::size_type,name_record_length>
+    >
+  >
+> name_record_set;
+
+int main()
+{
+  name_record_set ns;
+
+  ns.insert(name_record("Joe","Smith"));
+  ns.insert(name_record("Robert","Nightingale"));
+  ns.insert(name_record("Robert","Brown"));
+  ns.insert(name_record("Marc","Tuxedo"));
+
+  /* list the names in ns in phonebook order */
+
+  std::cout<<"Phonenook order\n"
+           <<"---------------"<<std::endl;
+  for(name_record_set::iterator it=ns.begin();it!=ns.end();++it){
+    std::cout<<it->name()<<std::endl;
+  }
+
+  /* list the names in ns according to their length*/
+
+  std::cout<<"\nLength order\n"
+           <<  "------------"<<std::endl;
+  for(nth_index<name_record_set,1>::type::iterator it1=get<1>(ns).begin();
+      it1!=get<1>(ns).end();++it1){
+    std::cout<<it1->name()<<std::endl;
+  }
+
+  return 0;
+}
diff --git a/src/boost/libs/multi_index/example/hashed.cpp b/src/boost/libs/multi_index/example/hashed.cpp
new file mode 100644
index 000000000..98228ea25
--- /dev/null
+++ b/src/boost/libs/multi_index/example/hashed.cpp
@@ -0,0 +1,124 @@
+/* Boost.MultiIndex example of use of hashed indices.
+ *
+ * Copyright 2003-2008 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#if !defined(NDEBUG)
+#define BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING
+#define BOOST_MULTI_INDEX_ENABLE_SAFE_MODE
+#endif
+
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/hashed_index.hpp>
+#include <boost/multi_index/member.hpp>
+#include <boost/multi_index/ordered_index.hpp>
+#include <boost/tokenizer.hpp>
+#include <iomanip>
+#include <iostream>
+#include <string>
+
+using boost::multi_index_container;
+using namespace boost::multi_index;
+
+/* word_counter keeps the ocurrences of words inserted. A hashed
+ * index allows for fast checking of preexisting entries.
+ */
+
+struct word_counter_entry
+{
+  std::string  word;
+  unsigned int occurrences;
+
+  word_counter_entry(std::string word_):word(word_),occurrences(0){}
+};
+
+/* see Compiler specifics: Use of member_offset for info on
+ * BOOST_MULTI_INDEX_MEMBER
+ */
+
+typedef multi_index_container<
+  word_counter_entry,
+  indexed_by<
+    ordered_non_unique<
+      BOOST_MULTI_INDEX_MEMBER(word_counter_entry,unsigned int,occurrences),
+      std::greater<unsigned int> /* sorted beginning with most frequent */
+    >,
+    hashed_unique<
+      BOOST_MULTI_INDEX_MEMBER(word_counter_entry,std::string,word)
+    >
+  >
+> word_counter;
+
+/* utilities */
+
+template<typename T>
+struct increment
+{
+  void operator()(T& x)const{++x;}
+};
+
+typedef boost::tokenizer<boost::char_separator<char> > text_tokenizer;
+
+int main()
+{
+  /* boostinspect:noascii */
+
+  std::string text=
+    "En un lugar de la Mancha, de cuyo nombre no quiero acordarme, no ha "
+    "mucho tiempo que vivía un hidalgo de los de lanza en astillero, adarga "
+    "antigua, rocín flaco y galgo corredor. Una olla de algo más vaca que "
+    "carnero, salpicón las más noches, duelos y quebrantos los sábados, "
+    "lantejas los viernes, algún palomino de añadidura los domingos, "
+    "consumían las tres partes de su hacienda. El resto della concluían sayo "
+    "de velarte, calzas de velludo para las fiestas, con sus pantuflos de lo "
+    "mesmo, y los días de entresemana se honraba con su vellorí de lo más "
+    "fino. Tenía en su casa una ama que pasaba de los cuarenta, y una "
+    "sobrina que no llegaba a los veinte, y un mozo de campo y plaza, que "
+    "así ensillaba el rocín como tomaba la podadera. Frisaba la edad de "
+    "nuestro hidalgo con los cincuenta años; era de complexión recia, seco "
+    "de carnes, enjuto de rostro, gran madrugador y amigo de la caza. "
+    "Quieren decir que tenía el sobrenombre de Quijada, o Quesada, que en "
+    "esto hay alguna diferencia en los autores que deste caso escriben; "
+    "aunque, por conjeturas verosímiles, se deja entender que se llamaba "
+    "Quejana. Pero esto importa poco a nuestro cuento; basta que en la "
+    "narración dél no se salga un punto de la verdad.";
+
+  /* feed the text into the container */
+
+  word_counter   wc;
+  text_tokenizer tok(text,boost::char_separator<char>(" \t\n.,;:!?'\"-"));
+  unsigned int   total_occurrences=0;
+  for(text_tokenizer::iterator it=tok.begin(),it_end=tok.end();
+      it!=it_end;++it){
+    /* Insert the word into the container. If duplicate, wit will point to
+     * the preexistent entry.
+     */
+
+    ++total_occurrences;
+    word_counter::iterator wit=wc.insert(*it).first;
+
+    /* Increment occurrences.
+     * In a lambda-capable compiler, this can be written as:
+     *   wc.modify_key(wit,++_1);
+     */
+
+    wc.modify_key(wit,increment<unsigned int>());
+  }
+
+  /* list words by frequency of appearance */
+
+  std::cout<<std::fixed<<std::setprecision(2);
+  for(word_counter::iterator wit=wc.begin(),wit_end=wc.end();
+      wit!=wit_end;++wit){
+    std::cout<<std::setw(11)<<wit->word<<": "
+             <<std::setw(5) <<100.0*wit->occurrences/total_occurrences<<"%"
+             <<std::endl;
+  }
+
+  return 0;
+}
diff --git a/src/boost/libs/multi_index/example/ip_allocator.cpp b/src/boost/libs/multi_index/example/ip_allocator.cpp
new file mode 100644
index 000000000..f2c6d677d
--- /dev/null
+++ b/src/boost/libs/multi_index/example/ip_allocator.cpp
@@ -0,0 +1,293 @@
+/* Boost.MultiIndex example of use of Boost.Interprocess allocators.
+ *
+ * Copyright 2003-2008 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#if !defined(NDEBUG)
+#define BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING
+#define BOOST_MULTI_INDEX_ENABLE_SAFE_MODE
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <algorithm>
+#include <boost/interprocess/allocators/allocator.hpp>
+#include <boost/interprocess/containers/string.hpp>
+#include <boost/interprocess/managed_mapped_file.hpp>
+#include <boost/interprocess/sync/named_mutex.hpp>
+#include <boost/interprocess/sync/scoped_lock.hpp>
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/ordered_index.hpp>
+#include <boost/multi_index/member.hpp>
+#include <iostream>
+#include <iterator>
+#include <sstream>
+#include <string>
+
+using boost::multi_index_container;
+using namespace boost::multi_index;
+namespace bip=boost::interprocess;
+
+/* shared_string is a string type placeable in shared memory,
+ * courtesy of Boost.Interprocess.
+ */
+
+typedef bip::basic_string<
+  char,std::char_traits<char>,
+  bip::allocator<char,bip::managed_mapped_file::segment_manager>
+> shared_string;
+
+/* Book record. All its members can be placed in shared memory,
+ * hence the structure itself can too.
+ */
+
+struct book
+{
+  shared_string name;
+  shared_string author;
+  unsigned      pages;
+  unsigned      prize;
+
+  book(const shared_string::allocator_type& al):
+    name(al),author(al),pages(0),prize(0)
+  {}
+
+  friend std::ostream& operator<<(std::ostream& os,const book& b)
+  {
+    os<<b.author<<": \""<<b.name<<"\", $"<<b.prize<<", "<<b.pages<<" pages\n";
+    return os;
+  }
+};
+
+/* partial_str_less allows for partial searches taking into account
+ * only the first n chars of the strings compared against. See
+ * Tutorial: Basics: Special lookup operations for more info on this
+ * type of comparison functors.
+ */
+
+/* partial_string is a mere string holder used to differentiate from
+ * a plain string.
+ */
+
+struct partial_string 
+{
+  partial_string(const shared_string& str):str(str){}
+  shared_string str;
+};
+
+struct partial_str_less
+{
+  bool operator()(const shared_string& x,const shared_string& y)const
+  {
+    return x<y;
+  }
+
+  bool operator()(const shared_string& x,const partial_string& y)const
+  {
+    return x.substr(0,y.str.size())<y.str;
+  }
+
+  bool operator()(const partial_string& x,const shared_string& y)const
+  {
+    return x.str<y.substr(0,x.str.size());
+  }
+};
+
+/* Define a multi_index_container of book records with indices on
+ * author, name and prize. The index on names allows for partial
+ * searches. This container can be placed in shared memory because:
+ *   * book can be placed in shared memory.
+ *   * We are using a Boost.Interprocess specific allocator.
+ */
+
+/* see Compiler specifics: Use of member_offset for info on
+ * BOOST_MULTI_INDEX_MEMBER
+ */
+
+typedef multi_index_container<
+  book,
+  indexed_by<
+    ordered_non_unique<
+      BOOST_MULTI_INDEX_MEMBER(book,shared_string,author)
+    >,
+    ordered_non_unique<
+      BOOST_MULTI_INDEX_MEMBER(book,shared_string,name),
+      partial_str_less
+    >,
+    ordered_non_unique<
+      BOOST_MULTI_INDEX_MEMBER(book,unsigned,prize)
+    >
+  >,
+  bip::allocator<book,bip::managed_mapped_file::segment_manager>
+> book_container;
+
+/* A small utility to get data entered via std::cin */
+
+template<typename T>
+void enter(const char* msg,T& t)
+{
+  std::cout<<msg;
+  std::string str;
+  std::getline(std::cin,str);
+  std::istringstream iss(str);
+  iss>>t;
+}
+
+void enter(const char* msg,std::string& str)
+{
+  std::cout<<msg;
+  std::getline(std::cin,str);
+}
+
+void enter(const char* msg,shared_string& str)
+{
+  std::cout<<msg;
+  std::string stdstr;
+  std::getline(std::cin,stdstr);
+  str=stdstr.c_str();
+}
+
+int main()
+{
+  /* Create (or open) the memory mapped file where the book container
+   * is stored, along with a mutex for synchronized access.
+   */
+
+  bip::managed_mapped_file seg(
+    bip::open_or_create,"./book_container.db",
+    65536);
+  bip::named_mutex mutex(
+    bip::open_or_create,"7FD6D7E8-320B-11DC-82CF-F0B655D89593");
+
+  /* create or open the book container in shared memory */
+
+  book_container* pbc=seg.find_or_construct<book_container>("book container")(
+    book_container::ctor_args_list(),
+    book_container::allocator_type(seg.get_segment_manager()));
+
+  std::string command_info=
+    "1. list books by author\n"
+    "2. list all books by prize\n"
+    "3. insert a book\n"
+    "4. delete a book\n"
+    "0. exit\n";
+
+  std::cout<<command_info;
+
+  /* main loop */
+
+  for(bool exit=false;!exit;){
+    int command=-1;
+    enter("command: ",command);
+
+    switch(command){
+      case 0:{ /* exit */
+        exit=true; 
+        break;
+      }
+      case 1:{ /* list books by author */
+        std::string author;
+        enter("author (empty=all authors): ",author);
+
+        /* operations with the container must be mutex protected */
+
+        bip::scoped_lock<bip::named_mutex> lock(mutex);
+
+        std::pair<book_container::iterator,book_container::iterator> rng;
+        if(author.empty()){
+          rng=std::make_pair(pbc->begin(),pbc->end());
+        }
+        else{
+          rng=pbc->equal_range(
+            shared_string(
+              author.c_str(),
+              shared_string::allocator_type(seg.get_segment_manager())));
+        }
+
+        if(rng.first==rng.second){
+          std::cout<<"no entries\n";
+        }
+        else{
+          std::copy(
+            rng.first,rng.second,std::ostream_iterator<book>(std::cout));
+        }
+        break;
+      }
+      case 2:{ /* list all books by prize */
+        bip::scoped_lock<bip::named_mutex> lock(mutex);
+
+        std::copy(
+          get<2>(*pbc).begin(),get<2>(*pbc).end(),
+          std::ostream_iterator<book>(std::cout));
+        break;
+      }
+      case 3:{ /* insert a book */
+        book b(shared_string::allocator_type(seg.get_segment_manager()));
+
+        enter("author: ",b.author);
+        enter("name: "  ,b.name);
+        enter("prize: " ,b.prize);
+        enter("pages: " ,b.pages);
+
+        std::cout<<"insert the following?\n"<<b<<"(y/n): ";
+        char yn='n';
+        enter("",yn);
+        if(yn=='y'||yn=='Y'){
+          bip::scoped_lock<bip::named_mutex> lock(mutex);
+          pbc->insert(b);
+        }
+
+        break;
+      }
+      case 4:{ /* delete a book */
+        shared_string name(
+          shared_string::allocator_type(seg.get_segment_manager()));
+        enter(
+          "name of the book (you can enter\nonly the first few characters): ",
+          name);
+
+        typedef nth_index<book_container,1>::type index_by_name;
+        index_by_name&          idx=get<1>(*pbc);
+        index_by_name::iterator it;
+        book b(shared_string::allocator_type(seg.get_segment_manager()));
+
+        {
+          /* Look for a book whose title begins with name. Note that we
+           * are unlocking after doing the search so as to not leave the
+           * container blocked during user prompting. That is also why a
+           * local copy of the book is done.
+           */
+
+          bip::scoped_lock<bip::named_mutex> lock(mutex);
+
+          it=idx.find(partial_string(name));
+          if(it==idx.end()){
+            std::cout<<"no such book found\n";
+            break;
+          }
+          b=*it;
+        }
+
+        std::cout<<"delete the following?\n"<<b<<"(y/n): ";
+        char yn='n';
+        enter("",yn);
+        if(yn=='y'||yn=='Y'){
+          bip::scoped_lock<bip::named_mutex> lock(mutex);
+          idx.erase(it);
+        }
+
+        break;
+      }
+      default:{
+        std::cout<<"select one option:\n"<<command_info;
+        break;
+      }
+    }
+  }
+
+  return 0;
+}
diff --git a/src/boost/libs/multi_index/example/non_default_ctor.cpp b/src/boost/libs/multi_index/example/non_default_ctor.cpp
new file mode 100644
index 000000000..afdbd5133
--- /dev/null
+++ b/src/boost/libs/multi_index/example/non_default_ctor.cpp
@@ -0,0 +1,96 @@
+/* Boost.MultiIndex example of use of multi_index_container::ctor_args_list.
+ *
+ * Copyright 2003-2008 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#if !defined(NDEBUG)
+#define BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING
+#define BOOST_MULTI_INDEX_ENABLE_SAFE_MODE
+#endif
+
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/identity.hpp>
+#include <boost/multi_index/ordered_index.hpp>
+#include <algorithm>
+#include <iostream>
+#include <iterator>
+
+using boost::multi_index_container;
+using namespace boost::multi_index;
+
+/* modulo_less order numbers according to their division residual.
+ * For instance, if modulo==10 then 22 is less than 15 as 22%10==2 and
+ * 15%10==5.
+ */
+
+template<typename IntegralType>
+struct modulo_less
+{
+  modulo_less(IntegralType m):modulo(m){}
+
+  bool operator()(IntegralType x,IntegralType y)const
+  {
+    return (x%modulo)<(y%modulo);
+  }
+
+private:
+  IntegralType modulo;
+};
+
+/* multi_index_container of unsigned ints holding a "natural" index plus
+ * an ordering based on modulo_less.
+ */
+
+typedef multi_index_container<
+  unsigned int,
+  indexed_by<
+    ordered_unique<identity<unsigned int> >,
+    ordered_non_unique<identity<unsigned int>, modulo_less<unsigned int> >
+  >
+> modulo_indexed_set;
+
+int main()
+{
+  /* define a modulo_indexed_set with modulo==10 */
+
+  modulo_indexed_set::ctor_args_list args_list=
+    boost::make_tuple(
+      /* ctor_args for index #0 is default constructible */
+      nth_index<modulo_indexed_set,0>::type::ctor_args(),
+
+      /* first parm is key_from_value, second is our sought for key_compare */
+      boost::make_tuple(identity<unsigned int>(),modulo_less<unsigned int>(10))
+    );
+
+  modulo_indexed_set m(args_list);
+  /* this could have be written online without the args_list variable,
+   * left as it is for explanatory purposes. */
+
+  /* insert some numbers */
+
+  unsigned int       numbers[]={0,1,20,40,33,68,11,101,60,34,88,230,21,4,7,17};
+  const std::size_t  numbers_length(sizeof(numbers)/sizeof(numbers[0]));
+
+  m.insert(&numbers[0],&numbers[numbers_length]);
+
+  /* lists all numbers in order, along with their "equivalence class", that is,
+   * the equivalent numbers under modulo_less
+   */
+
+  for(modulo_indexed_set::iterator it=m.begin();it!=m.end();++it){
+    std::cout<<*it<<" -> ( ";
+
+    nth_index<modulo_indexed_set,1>::type::iterator it0,it1;
+    boost::tie(it0,it1)=get<1>(m).equal_range(*it);
+    std::copy(it0,it1,std::ostream_iterator<unsigned int>(std::cout," "));
+
+    std::cout<<")"<<std::endl;
+  }
+
+  return 0;
+}
diff --git a/src/boost/libs/multi_index/example/random_access.cpp b/src/boost/libs/multi_index/example/random_access.cpp
new file mode 100644
index 000000000..7532c6d9d
--- /dev/null
+++ b/src/boost/libs/multi_index/example/random_access.cpp
@@ -0,0 +1,102 @@
+/* Boost.MultiIndex example of use of random access indices.
+ *
+ * Copyright 2003-2008 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#if !defined(NDEBUG)
+#define BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING
+#define BOOST_MULTI_INDEX_ENABLE_SAFE_MODE
+#endif
+
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/identity.hpp>
+#include <boost/multi_index/ordered_index.hpp>
+#include <boost/multi_index/random_access_index.hpp>
+#include <boost/tokenizer.hpp>
+#include <algorithm>
+#include <iostream>
+#include <iterator>
+#include <string>
+
+using boost::multi_index_container;
+using namespace boost::multi_index;
+
+/* text_container holds words as inserted and also keep them indexed
+ * by dictionary order.
+ */
+
+typedef multi_index_container<
+  std::string,
+  indexed_by<
+    random_access<>,
+    ordered_non_unique<identity<std::string> >
+  >
+> text_container;
+
+/* ordered index */
+
+typedef nth_index<text_container,1>::type ordered_text;
+
+/* Helper function for obtaining the position of an element in the
+ * container.
+ */
+
+template<typename IndexIterator>
+text_container::size_type text_position(
+  const text_container& tc,IndexIterator it)
+{
+  /* project to the base index and calculate offset from begin() */
+
+  return project<0>(tc,it)-tc.begin();
+}
+
+typedef boost::tokenizer<boost::char_separator<char> > text_tokenizer;
+
+int main()
+{
+  std::string text=
+    "'Oh, you wicked little thing!' cried Alice, catching up the kitten, "
+    "and giving it a little kiss to make it understand that it was in "
+    "disgrace. 'Really, Dinah ought to have taught you better manners! You "
+    "ought, Dinah, you know you ought!' she added, looking reproachfully at "
+    "the old cat, and speaking in as cross a voice as she could manage "
+    "-- and then she scrambled back into the armchair, taking the kitten and "
+    "the worsted with her, and began winding up the ball again. But she "
+    "didn't get on very fast, as she was talking all the time, sometimes to "
+    "the kitten, and sometimes to herself. Kitty sat very demurely on her "
+    "knee, pretending to watch the progress of the winding, and now and then "
+    "putting out one paw and gently touching the ball, as if it would be glad "
+    "to help, if it might.";
+
+  /* feed the text into the container */
+
+  text_container tc;
+  tc.reserve(text.size()); /* makes insertion faster */
+  text_tokenizer tok(text,boost::char_separator<char>(" \t\n.,;:!?'\"-"));
+  std::copy(tok.begin(),tok.end(),std::back_inserter(tc));
+
+  std::cout<<"enter a position (0-"<<tc.size()-1<<"):";
+  text_container::size_type pos=tc.size();
+  std::cin>>pos;
+  if(pos>=tc.size()){
+    std::cout<<"out of bounds"<<std::endl;
+  }
+  else{
+    std::cout<<"the word \""<<tc[pos]<<"\" appears at position(s): ";
+
+    std::pair<ordered_text::iterator,ordered_text::iterator> p=
+      get<1>(tc).equal_range(tc[pos]);
+    while(p.first!=p.second){
+      std::cout<<text_position(tc,p.first++)<<" ";
+    }
+
+    std::cout<<std::endl;
+  }
+
+  return 0;
+}
diff --git a/src/boost/libs/multi_index/example/rearrange.cpp b/src/boost/libs/multi_index/example/rearrange.cpp
new file mode 100644
index 000000000..31388513d
--- /dev/null
+++ b/src/boost/libs/multi_index/example/rearrange.cpp
@@ -0,0 +1,265 @@
+/* Boost.MultiIndex example of use of rearrange facilities.
+ *
+ * Copyright 2003-2015 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#if !defined(NDEBUG)
+#define BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING
+#define BOOST_MULTI_INDEX_ENABLE_SAFE_MODE
+#endif
+
+#include <boost/config.hpp>
+#include <boost/detail/iterator.hpp>
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/random_access_index.hpp>
+#include <boost/random/binomial_distribution.hpp>
+#include <boost/random/uniform_real.hpp>
+#include <boost/random/mersenne_twister.hpp>
+#include <algorithm>
+#include <iostream>
+#include <iterator>
+#include <vector>
+
+#if !defined(BOOST_NO_CXX11_HDR_RANDOM)
+#include <random>
+#endif
+
+using boost::multi_index_container;
+using namespace boost::multi_index;
+
+/* We model a card deck with a random access array containing
+ * card numbers (from 0 to 51), supplemented with an additional
+ * index which retains the start ordering.
+ */
+
+class deck
+{
+  BOOST_STATIC_CONSTANT(std::size_t,num_cards=52);
+
+  typedef multi_index_container<
+    int,
+    indexed_by<
+      random_access<>, /* base index    */
+      random_access<>  /* "start" index */
+    >
+  >                              container_type;
+  container_type cont;
+
+public:
+  deck()
+  {
+    cont.reserve(num_cards);
+    get<1>(cont).reserve(num_cards);
+    for(std::size_t i=0;i<num_cards;++i)cont.push_back(i);
+  }
+
+  typedef container_type::iterator  iterator;
+  typedef container_type::size_type size_type;
+
+  iterator  begin()const{return cont.begin();}
+  iterator  end()const{return cont.end();}
+  size_type size()const{return cont.size();}
+
+  template<typename InputIterator>
+  void rearrange(InputIterator it)
+  {
+    cont.rearrange(it);
+  }
+
+  void reset()
+  {
+    /* simply rearrange the base index like the start index */
+
+    cont.rearrange(get<1>(cont).begin());
+  }
+
+  std::size_t position(int i)const
+  {
+    /* The position of a card in the deck is calculated by locating
+     * the card through the start index (which is ordered), projecting
+     * to the base index and diffing with the begin position.
+     * Resulting complexity: constant.
+     */
+
+    return project<0>(cont,get<1>(cont).begin()+i)-cont.begin();
+  }
+
+  std::size_t rising_sequences()const
+  {
+    /* Iterate through all cards and increment the sequence count
+     * when the current position is left to the previous.
+     * Resulting complexity: O(n), n=num_cards.
+     */
+
+    std::size_t s=1;
+    std::size_t last_pos=0;
+
+    for(std::size_t i=0;i<num_cards;++i){
+      std::size_t pos=position(i);
+      if(pos<last_pos)++s;
+      last_pos=pos;
+    }
+
+    return s;
+  }
+};
+
+/* A vector of reference_wrappers to deck elements can be used
+ * as a view to the deck container.
+ * We use a special implicit_reference_wrapper having implicit
+ * ctor from its base type, as this simplifies the use of generic
+ * techniques on the resulting data structures.
+ */
+
+template<typename T>
+class implicit_reference_wrapper:public boost::reference_wrapper<T>
+{
+private:
+  typedef boost::reference_wrapper<T> super;
+public:
+  implicit_reference_wrapper(T& t):super(t){}
+};
+
+typedef std::vector<implicit_reference_wrapper<const int> > deck_view;
+
+/* Riffle shuffle is modeled like this: A cut is selected in the deck
+ * following a binomial distribution. Then, cards are randomly selected
+ * from one packet or the other with probability proportional to
+ * packet size.
+ */
+
+template<typename RandomAccessIterator,typename OutputIterator>
+void riffle_shuffle(
+  RandomAccessIterator first,RandomAccessIterator last,
+  OutputIterator out)
+{
+  static boost::mt19937 rnd_gen;
+
+  typedef typename boost::detail::iterator_traits<
+    RandomAccessIterator>::difference_type         difference_type;
+  typedef boost::binomial_distribution<
+    difference_type>                               rnd_cut_select_type;
+  typedef boost::uniform_real<>                    rnd_deck_select_type;
+
+  rnd_cut_select_type  cut_select(last-first);
+  RandomAccessIterator middle=first+cut_select(rnd_gen);
+  difference_type      s0=middle-first;
+  difference_type      s1=last-middle;
+  rnd_deck_select_type deck_select;
+
+  while(s0!=0&&s1!=0){
+    if(deck_select(rnd_gen)<(double)s0/(s0+s1)){
+      *out++=*first++;
+      --s0;
+    }
+    else{
+      *out++=*middle++;
+      --s1;
+    }
+  }
+  std::copy(first,first+s0,out);
+  std::copy(middle,middle+s1,out);
+}
+
+struct riffle_shuffler
+{
+  void operator()(deck& d)const
+  {
+    dv.clear();
+    dv.reserve(d.size());
+    riffle_shuffle(
+      d.begin(),d.end(),std::back_inserter(dv)); /* do the shuffling  */
+    d.rearrange(dv.begin());                     /* apply to the deck */
+  }
+
+private:
+  mutable deck_view dv;
+};
+
+/* A truly random shuffle (up to stdlib implementation quality) using
+ * std::shuffle.
+ */
+
+struct random_shuffler
+{
+  void operator()(deck& d)
+  {
+    dv.clear();
+    dv.reserve(d.size());
+    std::copy(d.begin(),d.end(),std::back_inserter(dv));
+    shuffle_view();
+    d.rearrange(dv.begin());                  /* apply to the deck */
+  }
+
+private:
+  deck_view    dv;
+
+#if !defined(BOOST_NO_CXX11_HDR_RANDOM)
+  std::mt19937 e;
+
+  void shuffle_view()
+  {
+    std::shuffle(dv.begin(),dv.end(),e);
+  }
+#else
+  /* for pre-C++11 compilers we use std::random_shuffle */
+
+  void shuffle_view()
+  {
+    std::random_shuffle(dv.begin(),dv.end());
+  }
+#endif
+};
+
+/* Repeat a given shuffling algorithm repeats_num times
+ * and obtain the resulting rising sequences number. Average
+ * for tests_num trials.
+ */
+
+template<typename Shuffler>
+double shuffle_test(
+ unsigned int repeats_num,unsigned int tests_num
+ BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Shuffler))
+{
+  deck          d;
+  Shuffler      sh;
+  unsigned long total=0;
+
+  for(unsigned int n=0;n<tests_num;++n){
+    for(unsigned m=0;m<repeats_num;++m)sh(d);
+    total+=d.rising_sequences();
+    d.reset();
+  }
+
+  return (double)total/tests_num;
+}
+
+int main()
+{
+  unsigned rifs_num=0;
+  unsigned tests_num=0;
+
+  std::cout<<"number of riffle shuffles (vg 5):";
+  std::cin>>rifs_num;
+  std::cout<<"number of tests (vg 1000):";
+  std::cin>>tests_num;
+
+  std::cout<<"shuffling..."<<std::endl;
+
+  std::cout<<"riffle shuffling\n"
+             "  avg number of rising sequences: "
+           <<shuffle_test<riffle_shuffler>(rifs_num,tests_num)
+           <<std::endl;
+
+  std::cout<<"random shuffling\n"
+             "  avg number of rising sequences: "
+           <<shuffle_test<random_shuffler>(1,tests_num)
+           <<std::endl;
+
+  return 0;
+}
diff --git a/src/boost/libs/multi_index/example/sequenced.cpp b/src/boost/libs/multi_index/example/sequenced.cpp
new file mode 100644
index 000000000..14651da4f
--- /dev/null
+++ b/src/boost/libs/multi_index/example/sequenced.cpp
@@ -0,0 +1,100 @@
+/* Boost.MultiIndex example of use of sequenced indices.
+ *
+ * Copyright 2003-2008 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#if !defined(NDEBUG)
+#define BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING
+#define BOOST_MULTI_INDEX_ENABLE_SAFE_MODE
+#endif
+
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/identity.hpp>
+#include <boost/multi_index/ordered_index.hpp>
+#include <boost/multi_index/sequenced_index.hpp>
+#include <boost/tokenizer.hpp>
+#include <algorithm>
+#include <iomanip>
+#include <iostream>
+#include <iterator>
+#include <string>
+
+using boost::multi_index_container;
+using namespace boost::multi_index;
+
+/* text_container holds words as inserted and also keep them indexed
+ * by dictionary order.
+ */
+
+typedef multi_index_container<
+  std::string,
+  indexed_by<
+    sequenced<>,
+    ordered_non_unique<identity<std::string> >
+  >
+> text_container;
+
+/* ordered index */
+
+typedef nth_index<text_container,1>::type ordered_text;
+
+typedef boost::tokenizer<boost::char_separator<char> > text_tokenizer;
+
+int main()
+{
+  std::string text=
+    "Alice was beginning to get very tired of sitting by her sister on the "
+    "bank, and of having nothing to do: once or twice she had peeped into the "
+    "book her sister was reading, but it had no pictures or conversations in "
+    "it, 'and what is the use of a book,' thought Alice 'without pictures or "
+    "conversation?'";
+
+  /* feed the text into the container */
+
+  text_container tc;
+  text_tokenizer tok(text,boost::char_separator<char>(" \t\n.,;:!?'\"-"));
+  std::copy(tok.begin(),tok.end(),std::back_inserter(tc));
+
+  /* list all words in alphabetical order along with their number
+   * of occurrences
+   */
+
+  ordered_text& ot=get<1>(tc);
+  for(ordered_text::iterator it=ot.begin();it!=ot.end();){
+    std::cout<<std::left<<std::setw(14)<<*it<<":";  /* print the word */
+    ordered_text::iterator it2=ot.upper_bound(*it); /* jump to next   */
+    std::cout<<std::right<<std::setw(3)   /* and compute the distance */
+             <<std::distance(it,it2)<<" times"<<std::endl;
+    it=it2;
+  }
+
+  /* reverse the text and print it out */
+
+  tc.reverse();
+  std::cout<<std::endl;
+  std::copy(
+    tc.begin(),tc.end(),std::ostream_iterator<std::string>(std::cout," "));
+  std::cout<<std::endl;
+  tc.reverse(); /* undo */
+
+  /* delete most common English words and print the result */
+
+  std::string common_words[]=
+    {"the","of","and","a","to","in","is","you","that","it",
+     "he","for","was","on","are","as","with","his","they","at"};
+
+  for(std::size_t n=0;n<sizeof(common_words)/sizeof(common_words[0]);++n){
+    ot.erase(common_words[n]);
+  }
+  std::cout<<std::endl;
+  std::copy(
+    tc.begin(),tc.end(),std::ostream_iterator<std::string>(std::cout," "));
+  std::cout<<std::endl;
+
+  return 0;
+}
diff --git a/src/boost/libs/multi_index/example/serialization.cpp b/src/boost/libs/multi_index/example/serialization.cpp
new file mode 100644
index 000000000..46ccf508e
--- /dev/null
+++ b/src/boost/libs/multi_index/example/serialization.cpp
@@ -0,0 +1,144 @@
+/* Boost.MultiIndex example of serialization of a MRU list.
+ *
+ * Copyright 2003-2008 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#if !defined(NDEBUG)
+#define BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING
+#define BOOST_MULTI_INDEX_ENABLE_SAFE_MODE
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <algorithm>
+#include <boost/archive/text_oarchive.hpp>
+#include <boost/archive/text_iarchive.hpp>
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/hashed_index.hpp>
+#include <boost/multi_index/identity.hpp>
+#include <boost/multi_index/sequenced_index.hpp>
+#include <fstream>
+#include <iostream>
+#include <iterator>
+#include <sstream>
+#include <string>
+
+using namespace boost::multi_index;
+
+/* An MRU (most recently used) list keeps record of the last n
+ * inserted items, listing first the newer ones. Care has to be
+ * taken when a duplicate item is inserted: instead of letting it
+ * appear twice, the MRU list relocates it to the first position.
+ */
+
+template <typename Item>
+class mru_list
+{
+  typedef multi_index_container<
+    Item,
+    indexed_by<
+      sequenced<>,
+      hashed_unique<identity<Item> >
+    >
+  > item_list;
+
+public:
+  typedef Item                         item_type;
+  typedef typename item_list::iterator iterator;
+
+  mru_list(std::size_t max_num_items_):max_num_items(max_num_items_){}
+
+  void insert(const item_type& item)
+  {
+    std::pair<iterator,bool> p=il.push_front(item);
+
+    if(!p.second){                     /* duplicate item */
+      il.relocate(il.begin(),p.first); /* put in front */
+    }
+    else if(il.size()>max_num_items){  /* keep the length <= max_num_items */
+      il.pop_back();
+    }
+  }
+
+  iterator begin(){return il.begin();}
+  iterator end(){return il.end();}
+
+  /* Utilities to save and load the MRU list, internally
+   * based on Boost.Serialization.
+   */
+
+  void save_to_file(const char* file_name)const
+  {
+    std::ofstream ofs(file_name);
+    boost::archive::text_oarchive oa(ofs);
+    oa<<boost::serialization::make_nvp("mru",*this);
+  }
+
+  void load_from_file(const char* file_name)
+  {
+    std::ifstream ifs(file_name);
+    if(ifs){
+      boost::archive::text_iarchive ia(ifs);
+      ia>>boost::serialization::make_nvp("mru",*this);
+    }
+  }
+
+private:
+  item_list   il;
+  std::size_t max_num_items;
+
+  /* serialization support */
+
+  friend class boost::serialization::access;
+    
+  template<class Archive>
+  void serialize(Archive& ar,const unsigned int)
+  {
+    ar&BOOST_SERIALIZATION_NVP(il);
+    ar&BOOST_SERIALIZATION_NVP(max_num_items);
+  }
+};
+
+int main()
+{
+  const char* mru_store="mru_store";
+
+  /* Construct a MRU limited to 10 items and retrieve its
+   * previous contents.
+   */
+
+  mru_list<std::string> mru(10);
+  mru.load_from_file(mru_store);
+
+  /* main loop */
+
+  for(;;){
+    std::cout<<"enter a term: ";
+
+    std::string line;
+    std::getline(std::cin,line);
+    if(line.empty())break;
+
+    std::string term;
+    std::istringstream iss(line);
+    iss>>term;
+    if(term.empty())break;
+
+    mru.insert(term);
+
+    std::cout<<"most recently entered terms:"<<std::endl;
+    std::copy(
+      mru.begin(),mru.end(),
+      std::ostream_iterator<std::string>(std::cout,"\n"));
+  }
+
+  /* persist the MRU list */
+
+  mru.save_to_file(mru_store);
+
+  return 0;
+}
diff --git a/src/boost/libs/multi_index/index.html b/src/boost/libs/multi_index/index.html
new file mode 100644
index 000000000..c190fc1e6
--- /dev/null
+++ b/src/boost/libs/multi_index/index.html
@@ -0,0 +1,20 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0.1 Transitional//EN">
+<!--
+ Copyright 2003-2004 Joaquín M López Muñoz.
+ 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)
+-->
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<meta http-equiv="refresh" content="0; URL=doc/index.html">
+<title>Boost.MultiIndex Documentation</title>
+<link rel="stylesheet" href="doc/style.css" type="text/css">
+</head>
+
+<body>
+Automatic redirection failed, please go to
+<a href="doc/index.html">doc/index.html</a>
+</body>
+</html>
diff --git a/src/boost/libs/multi_index/meta/libraries.json b/src/boost/libs/multi_index/meta/libraries.json
new file mode 100644
index 000000000..8f0df7493
--- /dev/null
+++ b/src/boost/libs/multi_index/meta/libraries.json
@@ -0,0 +1,15 @@
+{
+    "key": "multi_index",
+    "name": "Multi-Index",
+    "authors": [
+        "Joaqu\u00edn M L\u00f3pez Mu\u00f1oz"
+    ],
+    "description": "The Boost Multi-index Containers Library provides a class template named multi_index_container which enables the construction of containers maintaining one or more indices with different sorting and access semantics.",
+    "category": [
+        "Containers",
+        "Data"
+    ],
+    "maintainers": [
+        "Joaquin M Lopez Munoz <joaquin.lopezmunoz -at- gmail.com>"
+    ]
+}
diff --git a/src/boost/libs/multi_index/perf/Jamfile.v2 b/src/boost/libs/multi_index/perf/Jamfile.v2
new file mode 100644
index 000000000..c9aea9c7c
--- /dev/null
+++ b/src/boost/libs/multi_index/perf/Jamfile.v2
@@ -0,0 +1,14 @@
+# Boost.MultiIndex performance tests Jamfile
+#
+# Copyright 2003-2006 Joaquín M López Muñoz.
+# 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)
+#
+# See http://www.boost.org/libs/multi_index for library home page.
+
+exe test_perf
+    : test_perf.cpp
+    : <include>$(BOOST_ROOT)
+    : release
+    ;
diff --git a/src/boost/libs/multi_index/perf/test_perf.cpp b/src/boost/libs/multi_index/perf/test_perf.cpp
new file mode 100644
index 000000000..7b2441787
--- /dev/null
+++ b/src/boost/libs/multi_index/perf/test_perf.cpp
@@ -0,0 +1,545 @@
+/* Boost.MultiIndex performance test.
+ *
+ * Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+
+#include <algorithm>
+#include <assert.h>
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/identity.hpp>
+#include <boost/multi_index/ordered_index.hpp>
+#include <boost/multi_index/sequenced_index.hpp>
+#include <boost/next_prior.hpp>
+#include <climits>
+#include <ctime>
+#include <iomanip>
+#include <iostream>
+#include <list>
+#include <set>
+#include <string>
+#include <vector>
+
+using namespace std;
+using namespace boost::multi_index;
+
+/* Measurement harness by Andrew Koenig, extracted from companion code to
+ *   Stroustrup, B.: "Wrapping C++ Member Function Calls", The C++ Report,
+ *     June 2000, Vol 12/No 6.
+ * Original code retrievable at: http://www.research.att.com/~bs/wrap_code.cpp
+ */
+
+// How many clock units does it take to interrogate the clock?
+static double clock_overhead()
+{
+    clock_t k = clock(), start, limit;
+
+    // Wait for the clock to tick
+    do start = clock();
+    while (start == k);
+
+    // interrogate the clock until it has advanced at least a second
+    // (for reasonable accuracy)
+    limit = start + CLOCKS_PER_SEC;
+
+    unsigned long r = 0;
+    while ((k = clock()) < limit)
+        ++r;
+
+    return double(k - start) / r;
+}
+
+// We'd like the odds to be factor:1 that the result is
+// within percent% of the median
+const int factor = 10;
+const int percent = 20;
+
+// Measure a function (object) factor*2 times,
+// appending the measurements to the second argument
+template<class F>
+void measure_aux(F f, vector<double>& mv)
+{
+    static double ovhd = clock_overhead();
+
+    // Ensure we don't reallocate in mid-measurement
+    mv.reserve(mv.size() + factor*2);
+
+    // Wait for the clock to tick
+    clock_t k = clock();
+    clock_t start;
+
+    do start = clock();
+    while (start == k);
+
+    // Do 2*factor measurements
+    for (int i = 2*factor; i; --i) {
+        unsigned long count = 0, limit = 1, tcount = 0;
+
+        // Original code used CLOCKS_PER_SEC/100
+        const clock_t clocklimit = start + CLOCKS_PER_SEC/10;
+        clock_t t;
+
+        do {
+            while (count < limit) {
+                f();
+                ++count;
+            }
+            limit *= 2;
+            ++tcount;
+        } while ((t = clock()) < clocklimit);
+
+        // Wait for the clock to tick again;
+        clock_t t2;
+        do ++tcount;
+        while ((t2 = clock()) == t);
+
+        // Append the measurement to the vector
+        mv.push_back(((t2 - start) - (tcount * ovhd)) / count);
+
+        // Establish a new starting point
+        start = t2;
+    }
+}
+
+// Returns the number of clock units per iteration
+// With odds of factor:1, the measurement is within percent% of
+// the value returned, which is also the median of all measurements.
+template<class F>
+double measure(F f)
+{
+    vector<double> mv;
+
+    int n = 0;                        // iteration counter
+    do {
+        ++n;
+
+        // Try 2*factor measurements
+        measure_aux(f, mv);
+        assert(mv.size() == 2*n*factor);
+
+        // Compute the median.  We know the size is even, so we cheat.
+        sort(mv.begin(), mv.end());
+        double median = (mv[n*factor] + mv[n*factor-1])/2;
+
+        // If the extrema are within threshold of the median, we're done
+        if (mv[n] > (median * (100-percent))/100 &&
+            mv[mv.size() - n - 1] < (median * (100+percent))/100)
+            return median;
+
+    } while (mv.size() < factor * 200);
+
+    // Give up!
+    clog << "Help!\n\n";
+    exit(1);
+}
+
+/* dereferencing compare predicate */
+
+template <typename Iterator,typename Compare>
+struct it_compare
+{
+  bool operator()(const Iterator& x,const Iterator& y)const{return comp(*x,*y);}
+
+private:
+  Compare comp;
+};
+
+/* list_wrapper and multiset_wrapper adapt std::lists and std::multisets
+ * to make them conform to a set-like insert interface which test
+ * routines do assume.
+ */
+
+template <typename List>
+struct list_wrapper:List
+{
+  typedef typename List::value_type value_type;
+  typedef typename List::iterator   iterator;
+
+  pair<iterator,bool> insert(const value_type& v)
+  {
+    List::push_back(v);
+    return pair<iterator,bool>(boost::prior(List::end()),true);
+  }
+};
+
+template <typename Multiset>
+struct multiset_wrapper:Multiset
+{
+  typedef typename Multiset::value_type value_type;
+  typedef typename Multiset::iterator   iterator;
+
+  pair<iterator,bool> insert(const value_type& v)
+  {
+    return pair<iterator,bool>(Multiset::insert(v),true);
+  }
+};
+
+/* space comsumption of manual simulations is determined by checking
+ * the node sizes of the containers involved. This cannot be done in a
+ * portable manner, so node_size has to be written on a per stdlibrary
+ * basis. Add your own versions if necessary.
+ */
+
+#if defined(BOOST_DINKUMWARE_STDLIB)
+
+template<typename Container>
+size_t node_size(const Container&)
+{
+  return sizeof(*Container().begin()._Mynode());
+}
+
+#elif defined(__GLIBCPP__) || defined(__GLIBCXX__)
+
+template<typename Container>
+size_t node_size(const Container&)
+{
+  typedef typename Container::iterator::_Link_type node_ptr;
+  node_ptr p=0;
+  return sizeof(*p);
+}
+
+template<typename Value,typename Allocator>
+size_t node_size(const list<Value,Allocator>&)
+{
+  return sizeof(typename list<Value,Allocator>::iterator::_Node);
+}
+
+template<typename List>
+size_t node_size(const list_wrapper<List>&)
+{
+  return sizeof(typename List::iterator::_Node);
+}
+
+#else
+
+/* default version returns 0 by convention */
+
+template<typename Container>
+size_t node_size(const Container&)
+{
+  return 0;
+}
+
+#endif
+
+/* mono_container runs the tested routine on multi_index and manual
+ * simulations comprised of one standard container.
+ * bi_container and tri_container run the equivalent routine for manual
+ * compositions of two and three standard containers, respectively.
+ */
+
+template <typename Container>
+struct mono_container
+{
+  mono_container(int n_):n(n_){}
+
+  void operator()()
+  {
+    typedef typename Container::iterator iterator;
+
+    Container c;
+
+    for(int i=0;i<n;++i)c.insert(i);
+    for(iterator it=c.begin();it!=c.end();)c.erase(it++);
+  }
+
+  static size_t multi_index_node_size()
+  {
+    return sizeof(*Container().begin().get_node());
+  }
+
+  static size_t node_size()
+  {
+    return ::node_size(Container());
+  }
+
+private:
+  int n;
+};
+
+template <typename Container1,typename Container2>
+struct bi_container
+{
+  bi_container(int n_):n(n_){}
+
+  void operator()()
+  {
+    typedef typename Container1::iterator iterator1;
+    typedef typename Container2::iterator iterator2;
+
+    Container1 c1;
+    Container2 c2;
+
+    for(int i=0;i<n;++i){
+      iterator1 it1=c1.insert(i).first;
+      c2.insert(it1);
+    }
+    for(iterator2 it2=c2.begin();it2!=c2.end();)
+    {
+      c1.erase(*it2);
+      c2.erase(it2++);
+    }
+  }
+
+  static size_t node_size()
+  {
+    return ::node_size(Container1())+::node_size(Container2());
+  }
+
+private:
+  int n;
+};
+
+template <typename Container1,typename Container2,typename Container3>
+struct tri_container
+{
+  tri_container(int n_):n(n_){}
+
+  void operator()()
+  {
+    typedef typename Container1::iterator iterator1;
+    typedef typename Container2::iterator iterator2;
+    typedef typename Container3::iterator iterator3;
+
+    Container1 c1;
+    Container2 c2;
+    Container3 c3;
+
+    for(int i=0;i<n;++i){
+      iterator1 it1=c1.insert(i).first;
+      iterator2 it2=c2.insert(it1).first;
+      c3.insert(it2);
+    }
+    for(iterator3 it3=c3.begin();it3!=c3.end();)
+    {
+      c1.erase(**it3);
+      c2.erase(*it3);
+      c3.erase(it3++);
+    }
+  }
+
+  static size_t node_size()
+  {
+    return ::node_size(Container1())+
+           ::node_size(Container2())+::node_size(Container3());
+  }
+
+private:
+  int n;
+};
+
+/* measure and compare two routines for several numbers of elements
+ * and also estimates relative memory consumption.
+ */
+
+template <typename IndexedTest,typename ManualTest>
+void run_tests(const char* title)
+{
+  cout<<fixed<<setprecision(2);
+  cout<<title<<endl;
+  int n=1000;
+  for(int i=0;i<3;++i){
+    double indexed_t=measure(IndexedTest(n));
+    double manual_t=measure(ManualTest(n));
+    cout<<"  10^"<<i+3<<" elmts: "
+        <<setw(6)<<100.0*indexed_t/manual_t<<"% "
+        <<"("
+          <<setw(6)<<1000.0*indexed_t/CLOCKS_PER_SEC<<" ms / "
+          <<setw(6)<<1000.0*manual_t/CLOCKS_PER_SEC<<" ms)"
+        <<endl;
+    n*=10;
+  }
+
+  size_t indexed_t_node_size=IndexedTest::multi_index_node_size();
+  size_t manual_t_node_size=ManualTest::node_size();
+
+  if(manual_t_node_size){
+    cout<<"  space gain: "
+        <<setw(6)<<100.0*indexed_t_node_size/manual_t_node_size<<"%"<<endl;
+  }
+}
+
+/* compare_structures accept a multi_index_container instantiation and
+ * several standard containers, builds a manual simulation out of the
+ * latter and run the tests.
+ */
+
+template <typename IndexedType,typename ManualType>
+void compare_structures(const char* title)
+{
+  run_tests<
+    mono_container<IndexedType>,
+    mono_container<ManualType>
+  >(title);
+}
+
+template <typename IndexedType,typename ManualType1,typename ManualType2>
+void compare_structures2(const char* title)
+{
+  run_tests<
+    mono_container<IndexedType>,
+    bi_container<ManualType1,ManualType2>
+  >(title);
+}
+
+template <
+  typename IndexedType,
+  typename ManualType1,typename ManualType2,typename ManualType3
+>
+void compare_structures3(const char* title)
+{
+  run_tests<
+    mono_container<IndexedType>,
+    tri_container<ManualType1,ManualType2,ManualType3>
+  >(title);
+}
+
+int main()
+{
+  /* some stdlibs provide the discussed but finally rejected std::identity */
+  using boost::multi_index::identity; 
+
+  {
+    /* 1 ordered index */
+
+    typedef multi_index_container<int> indexed_t;
+    typedef set<int>                   manual_t;
+
+    compare_structures<indexed_t,manual_t>(
+      "1 ordered index");
+  }
+  {
+    /* 1 sequenced index */
+
+    typedef list_wrapper<
+      multi_index_container<
+        int,
+        indexed_by<sequenced<> > 
+      >
+    >                                  indexed_t;
+    typedef list_wrapper<list<int> >   manual_t;
+
+    compare_structures<indexed_t,manual_t>(
+      "1 sequenced index");
+  }
+  {
+    /* 2 ordered indices */
+
+    typedef multi_index_container<
+      int,
+      indexed_by<
+        ordered_unique<identity<int> >,
+        ordered_non_unique<identity<int> >
+      >
+    >                                  indexed_t;
+    typedef set<int>                   manual_t1;
+    typedef multiset<
+      manual_t1::iterator,
+      it_compare<
+        manual_t1::iterator,
+        manual_t1::key_compare
+      >
+    >                                  manual_t2;
+
+    compare_structures2<indexed_t,manual_t1,manual_t2>(
+      "2 ordered indices");
+  }
+  {
+    /* 1 ordered index + 1 sequenced index */
+
+    typedef multi_index_container<
+      int,
+      indexed_by<
+        boost::multi_index::ordered_unique<identity<int> >,
+        sequenced<>
+      >
+    >                                  indexed_t;
+    typedef list_wrapper<
+      list<int>
+    >                                  manual_t1;
+    typedef multiset<
+      manual_t1::iterator,
+      it_compare<
+        manual_t1::iterator,
+        std::less<int>
+      >
+    >                                  manual_t2;
+
+    compare_structures2<indexed_t,manual_t1,manual_t2>(
+      "1 ordered index + 1 sequenced index");
+  }
+  {
+    /* 3 ordered indices */
+
+    typedef multi_index_container<
+      int,
+      indexed_by<
+        ordered_unique<identity<int> >,
+        ordered_non_unique<identity<int> >,
+        ordered_non_unique<identity<int> >
+      >
+    >                                  indexed_t;
+    typedef set<int>                   manual_t1;
+    typedef multiset_wrapper<
+      multiset<
+        manual_t1::iterator,
+        it_compare<
+          manual_t1::iterator,
+          manual_t1::key_compare
+        >
+      >
+    >                                  manual_t2;
+    typedef multiset<
+      manual_t2::iterator,
+      it_compare<
+        manual_t2::iterator,
+        manual_t2::key_compare
+      >
+    >                                  manual_t3;
+
+    compare_structures3<indexed_t,manual_t1,manual_t2,manual_t3>(
+      "3 ordered indices");
+  }
+  {
+    /* 2 ordered indices + 1 sequenced index */
+
+    typedef multi_index_container<
+      int,
+      indexed_by<
+        ordered_unique<identity<int> >,
+        ordered_non_unique<identity<int> >,
+        sequenced<>
+      >
+    >                                  indexed_t;
+    typedef list_wrapper<
+      list<int>
+    >                                  manual_t1;
+    typedef multiset_wrapper<
+      multiset<
+        manual_t1::iterator,
+        it_compare<
+          manual_t1::iterator,
+          std::less<int>
+        >
+      >
+    >                                  manual_t2;
+    typedef multiset<
+      manual_t2::iterator,
+      it_compare<
+        manual_t2::iterator,
+        manual_t2::key_compare
+      >
+    >                                  manual_t3;
+
+    compare_structures3<indexed_t,manual_t1,manual_t2,manual_t3>(
+      "2 ordered indices + 1 sequenced index");
+  }
+
+  return 0;
+}
diff --git a/src/boost/libs/multi_index/test/Jamfile.v2 b/src/boost/libs/multi_index/test/Jamfile.v2
new file mode 100644
index 000000000..405dc7656
--- /dev/null
+++ b/src/boost/libs/multi_index/test/Jamfile.v2
@@ -0,0 +1,75 @@
+# Boost.MultiIndex tests Jamfile
+#
+# Copyright 2003-2020 Joaquín M López Muñoz.
+# 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)
+#
+# See http://www.boost.org/libs/multi_index for library home page.
+
+import os ;
+import type ;
+
+# Windows Vista UAC has an heuristic by which executable files whose name
+# contains any of the words "install", "setup", "update", etc. are assumed
+# to be installation packages needing administrative rights, which causes
+# the system to bring up a window asking for execution confirmation by the
+# user, thus interferring in the unattended bjam process.
+# Problem bypassed by changing the EXE names containing a taboo word.
+# Thanks to Rene Rivera for guidance on the use of the <tag> feature.
+
+rule change-test_update-exe-name ( name : type ? : property-set ) 
+{ 
+    if [ os.on-windows ] && [ type.is-subtype $(type) EXE ]
+    {
+        return test_updat.exe ;
+    }
+}
+
+project
+    : requirements
+      <toolset>msvc:<define>_SCL_SECURE_NO_WARNINGS
+      <toolset>msvc:<define>_CRT_SECURE_NO_WARNINGS
+      <toolset>msvc:<define>_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS
+      <toolset>msvc:<cxxflags>/wd4494
+    ;
+
+obj boost_multi_index_key_supported : check_bmi_key_supported.cpp  ;
+explicit boost_multi_index_key_supported ;
+
+test-suite "multi_index" :
+    [ run test_alloc_awareness.cpp  test_alloc_awareness_main.cpp  ]
+    [ run test_basic.cpp            test_basic_main.cpp            ]
+    [ run test_capacity.cpp         test_capacity_main.cpp         ]
+    [ run test_comparison.cpp       test_comparison_main.cpp       ]
+    [ run test_composite_key.cpp    test_composite_key_main.cpp    ]
+    [ run test_conv_iterators.cpp   test_conv_iterators_main.cpp   ]
+    [ run test_copy_assignment.cpp  test_copy_assignment_main.cpp  ]
+    [ run test_hash_ops.cpp         test_hash_ops_main.cpp         ]
+    [ run test_iterators.cpp        test_iterators_main.cpp        ]
+    [ run test_key.cpp              test_key_main.cpp
+        : : :
+        [ check-target-builds boost_multi_index_key_supported
+            "BOOST_MULTI_INDEX_KEY_SUPPORTED defined"
+            : : <build>no                                        ] ]
+    [ run test_key_extractors.cpp   test_key_extractors_main.cpp   ]
+    [ run test_list_ops.cpp         test_list_ops_main.cpp         ]
+    [ run test_modifiers.cpp        test_modifiers_main.cpp        ]
+    [ run test_mpl_ops.cpp          test_mpl_ops_main.cpp          ]
+    [ run test_observers.cpp        test_observers_main.cpp        ]    
+    [ run test_projection.cpp       test_projection_main.cpp       ]
+    [ run test_range.cpp            test_range_main.cpp            ]
+    [ run test_rank_ops.cpp         test_rank_ops_main.cpp         ]
+    [ run test_rearrange.cpp        test_rearrange_main.cpp        ]
+    [ run test_safe_mode.cpp        test_safe_mode_main.cpp        ]
+    [ run test_serialization.cpp    test_serialization1.cpp
+          test_serialization2.cpp   test_serialization3.cpp
+          test_serialization_main.cpp
+          /boost/serialization//boost_serialization                ]
+    [ run test_set_ops.cpp          test_set_ops_main.cpp          ]
+    [ run test_special_set_ops.cpp  test_special_set_ops_main.cpp  ]
+    [ run test_update.cpp           test_update_main.cpp 
+        : : : 
+        -<tag>@$(BOOST_JAMROOT_MODULE)%$(BOOST_JAMROOT_MODULE).tag
+        <tag>@change-test_update-exe-name                          ]
+    ;
diff --git a/src/boost/libs/multi_index/test/check_bmi_key_supported.cpp b/src/boost/libs/multi_index/test/check_bmi_key_supported.cpp
new file mode 100644
index 000000000..99ce8694b
--- /dev/null
+++ b/src/boost/libs/multi_index/test/check_bmi_key_supported.cpp
@@ -0,0 +1,13 @@
+/* Copyright 2003-2018 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include <boost/multi_index/key.hpp>
+
+#if !defined(BOOST_MULTI_INDEX_KEY_SUPPORTED)
+#error BOOST_MULTI_INDEX_KEY_SUPPORTED macro not defined
+#endif
diff --git a/src/boost/libs/multi_index/test/employee.hpp b/src/boost/libs/multi_index/test/employee.hpp
new file mode 100644
index 000000000..3a63c02e8
--- /dev/null
+++ b/src/boost/libs/multi_index/test/employee.hpp
@@ -0,0 +1,152 @@
+/* Used in Boost.MultiIndex tests.
+ *
+ * Copyright 2003-2018 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_TEST_EMPLOYEE_HPP
+#define BOOST_MULTI_INDEX_TEST_EMPLOYEE_HPP
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/move/core.hpp>
+#include <boost/move/utility_core.hpp>
+#include <boost/mpl/vector.hpp>
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/hashed_index.hpp>
+#include <boost/multi_index/identity.hpp>
+#include <boost/multi_index/member.hpp>
+#include <boost/multi_index/ordered_index.hpp>
+#include <boost/multi_index/random_access_index.hpp>
+#include <boost/multi_index/ranked_index.hpp>
+#include <boost/multi_index/sequenced_index.hpp>
+#include <ostream>
+#include <string>
+#include "non_std_allocator.hpp"
+
+struct employee
+{
+  int         id;
+  std::string name;
+  int         age;
+  int         ssn;
+
+  employee(int id_,std::string name_,int age_,int ssn_):
+    id(id_),name(name_),age(age_),ssn(ssn_)
+  {}
+
+  employee(const employee& x):
+    id(x.id),name(x.name),age(x.age),ssn(x.ssn)
+  {}
+
+  employee(BOOST_RV_REF(employee) x):
+    id(x.id),name(boost::move(x.name)),age(x.age),ssn(x.ssn)
+  {}
+
+  employee& operator=(BOOST_COPY_ASSIGN_REF(employee) x)
+  {
+    id=x.id;
+    name=x.name;
+    age=x.age;
+    ssn=x.ssn;
+    return *this;
+  };
+
+  employee& operator=(BOOST_RV_REF(employee) x)
+  {
+    id=x.id;
+    name=boost::move(x.name);
+    age=x.age;
+    ssn=x.ssn;
+    return *this;
+  }
+
+  bool operator==(const employee& x)const
+  {
+    return id==x.id&&name==x.name&&age==x.age;
+  }
+
+  bool operator<(const employee& x)const
+  {
+    return id<x.id;
+  }
+
+  bool operator!=(const employee& x)const{return !(*this==x);}
+  bool operator> (const employee& x)const{return x<*this;}
+  bool operator>=(const employee& x)const{return !(*this<x);}
+  bool operator<=(const employee& x)const{return !(x<*this);}
+
+  struct comp_id
+  {
+    bool operator()(int x,const employee& e2)const{return x<e2.id;}
+    bool operator()(const employee& e1,int x)const{return e1.id<x;}
+  };
+
+  friend std::ostream& operator<<(std::ostream& os,const employee& e)
+  {
+    os<<e.id<<" "<<e.name<<" "<<e.age<<std::endl;
+    return os;
+  }
+
+private:
+  BOOST_COPYABLE_AND_MOVABLE(employee)
+};
+
+struct name{};
+struct by_name{};
+struct age{};
+struct as_inserted{};
+struct ssn{};
+struct randomly{};
+
+struct employee_set_indices:
+  boost::mpl::vector<
+    boost::multi_index::ordered_unique<
+      boost::multi_index::identity<employee> >,
+    boost::multi_index::hashed_non_unique<
+      boost::multi_index::tag<name,by_name>,
+      BOOST_MULTI_INDEX_MEMBER(employee,std::string,name)>,
+    boost::multi_index::ranked_non_unique<
+      boost::multi_index::tag<age>,
+      BOOST_MULTI_INDEX_MEMBER(employee,int,age)>,
+    boost::multi_index::sequenced<
+      boost::multi_index::tag<as_inserted> >,
+    boost::multi_index::hashed_unique<
+      boost::multi_index::tag<ssn>,
+      BOOST_MULTI_INDEX_MEMBER(employee,int,ssn)>,
+    boost::multi_index::random_access<
+      boost::multi_index::tag<randomly> > >
+{};
+
+typedef
+  boost::multi_index::multi_index_container<
+    employee,
+    employee_set_indices,
+    non_std_allocator<employee> >        employee_set;
+
+#if defined(BOOST_NO_MEMBER_TEMPLATES)
+typedef boost::multi_index::nth_index<
+  employee_set,1>::type                  employee_set_by_name;
+#else
+typedef employee_set::nth_index<1>::type employee_set_by_name;
+#endif
+
+typedef boost::multi_index::index<
+         employee_set,age>::type         employee_set_by_age;
+typedef boost::multi_index::index<
+         employee_set,as_inserted>::type employee_set_as_inserted;
+typedef boost::multi_index::index<
+         employee_set,ssn>::type         employee_set_by_ssn;
+
+#if defined(BOOST_NO_MEMBER_TEMPLATES)
+typedef boost::multi_index::index<
+         employee_set,randomly>::type    employee_set_randomly;
+#else
+typedef employee_set::index<
+          randomly>::type                employee_set_randomly;
+#endif
+
+#endif
diff --git a/src/boost/libs/multi_index/test/non_std_allocator.hpp b/src/boost/libs/multi_index/test/non_std_allocator.hpp
new file mode 100644
index 000000000..80f366ca0
--- /dev/null
+++ b/src/boost/libs/multi_index/test/non_std_allocator.hpp
@@ -0,0 +1,141 @@
+/* Used in Boost.MultiIndex tests.
+ *
+ * Copyright 2003-2020 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_TEST_NON_STD_ALLOCATOR_HPP
+#define BOOST_MULTI_INDEX_TEST_NON_STD_ALLOCATOR_HPP
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/throw_exception.hpp>
+#include <iterator>
+#include <cstddef>
+#include <stdexcept>
+
+template<typename T>
+class non_raw_pointer
+{
+public:
+  typedef std::ptrdiff_t                  difference_type;
+  typedef T                               value_type;
+  typedef T*                              pointer;
+  typedef T&                              reference;
+  typedef std::random_access_iterator_tag iterator_category;
+
+  non_raw_pointer(){}
+  explicit non_raw_pointer(T* p_):p(p_){}
+
+  T& operator*()const
+  {
+#if !defined(BOOST_NO_EXCEPTIONS)
+    if(!p)boost::throw_exception(std::runtime_error("null indirection"));
+#endif
+
+    return *p;
+  }
+
+  T* operator->()const{return p;}
+  non_raw_pointer& operator++(){++p;return *this;}
+  non_raw_pointer operator++(int){non_raw_pointer t(*this);++p;return t;}
+  non_raw_pointer& operator--(){--p;return *this;}
+  non_raw_pointer operator--(int){non_raw_pointer t(*this);--p;return t;}
+  non_raw_pointer& operator+=(std::ptrdiff_t n){p+=n;return *this;}
+  non_raw_pointer& operator-=(std::ptrdiff_t n){p-=n;return *this;}
+  T& operator[](std::ptrdiff_t n)const{return p[n];}
+
+  T* raw_ptr()const{return p;}
+
+private:
+  T* p;
+};
+
+template<typename T>
+non_raw_pointer<T> operator+(const non_raw_pointer<T>& x,std::ptrdiff_t n)
+{return non_raw_pointer<T>(x.raw_ptr()+n);}
+
+template<typename T>
+non_raw_pointer<T> operator+(std::ptrdiff_t n,const non_raw_pointer<T>& x)
+{return non_raw_pointer<T>(n+x.raw_ptr());}
+
+template<typename T>
+non_raw_pointer<T> operator-(const non_raw_pointer<T>& x,std::ptrdiff_t n)
+{return non_raw_pointer<T>(x.raw_ptr()-n);}
+
+template<typename T>
+std::ptrdiff_t operator-(
+  const non_raw_pointer<T>& x,const non_raw_pointer<T>& y)
+{return x.raw_ptr()-y.raw_ptr();}
+
+template<typename T>
+bool operator==(const non_raw_pointer<T>& x,const non_raw_pointer<T>& y)
+{return x.raw_ptr()==y.raw_ptr();}
+
+template<typename T>
+bool operator!=(const non_raw_pointer<T>& x,const non_raw_pointer<T>& y)
+{return x.raw_ptr()!=y.raw_ptr();}
+
+template<typename T>
+bool operator<(const non_raw_pointer<T>& x,const non_raw_pointer<T>& y)
+{return x.raw_ptr()<y.raw_ptr();}
+
+template<typename T>
+bool operator>(const non_raw_pointer<T>& x,const non_raw_pointer<T>& y)
+{return x.raw_ptr()>y.raw_ptr();}
+
+template<typename T>
+bool operator>=(const non_raw_pointer<T>& x,const non_raw_pointer<T>& y)
+{return x.raw_ptr()>=y.raw_ptr();}
+
+template<typename T>
+bool operator<=(const non_raw_pointer<T>& x,const non_raw_pointer<T>& y)
+{return x.raw_ptr()<=y.raw_ptr();}
+
+template<typename T>
+class non_std_allocator
+{
+public:
+  typedef std::size_t              size_type;
+  typedef std::ptrdiff_t           difference_type;
+  typedef non_raw_pointer<T>       pointer;
+  typedef non_raw_pointer<const T> const_pointer;
+  typedef void*                    void_pointer;
+  typedef const void*              const_void_pointer;
+  typedef T&                       reference;
+  typedef const T&                 const_reference;
+  typedef T                        value_type;
+  template<class U>struct rebind{typedef non_std_allocator<U> other;};
+
+  non_std_allocator(){}
+  non_std_allocator(const non_std_allocator<T>&){}
+  template<class U>non_std_allocator(const non_std_allocator<U>&,int=0){}
+  non_std_allocator& operator=(const non_std_allocator<T>&){return *this;}
+
+  pointer allocate(size_type n)
+  {
+    return pointer((T*)(new char[n*sizeof(T)]));
+  }
+
+  void deallocate(pointer p,size_type)
+  {
+    delete[](char *)&*p;
+  }
+
+  size_type max_size() const{return (size_type )(-1);}
+
+  friend bool operator==(const non_std_allocator&,const non_std_allocator&)
+  {
+    return true;
+  }
+
+  friend bool operator!=(const non_std_allocator&,const non_std_allocator&)
+  {
+    return false;
+  }
+};
+
+#endif
diff --git a/src/boost/libs/multi_index/test/pair_of_ints.hpp b/src/boost/libs/multi_index/test/pair_of_ints.hpp
new file mode 100644
index 000000000..6089ffc34
--- /dev/null
+++ b/src/boost/libs/multi_index/test/pair_of_ints.hpp
@@ -0,0 +1,78 @@
+/* Used in Boost.MultiIndex tests.
+ *
+ * Copyright 2003-2010 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_TEST_PAIR_OF_INTS_HPP
+#define BOOST_MULTI_INDEX_TEST_PAIR_OF_INTS_HPP
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/serialization/nvp.hpp>
+
+struct pair_of_ints
+{
+  pair_of_ints(int first_=0,int second_=0):first(first_),second(second_){}
+
+  bool operator==(const pair_of_ints& x)const
+  {
+    return first==x.first&&second==x.second;
+  }
+
+  bool operator!=(const pair_of_ints& x)const{return !(*this==x);}
+
+  int first,second;
+};
+
+inline void increment_first(pair_of_ints& p)
+{
+  ++p.first;
+}
+
+inline void increment_second(pair_of_ints& p)
+{
+  ++p.second;
+}
+
+inline void increment_int(int& x)
+{
+  ++x;
+}
+
+inline int decrement_first(pair_of_ints& p)
+{
+  return --p.first;
+}
+
+inline int decrement_second(pair_of_ints& p)
+{
+  return --p.second;
+}
+
+inline int decrement_int(int& x)
+{
+  return --x;
+}
+
+#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
+namespace boost{
+namespace serialization{
+#endif
+
+template<class Archive>
+void serialize(Archive& ar,pair_of_ints& p,const unsigned int)
+{
+  ar&boost::serialization::make_nvp("first",p.first);
+  ar&boost::serialization::make_nvp("second",p.second);
+}
+
+#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
+} /* namespace serialization */
+} /* namespace boost*/
+#endif
+
+#endif
diff --git a/src/boost/libs/multi_index/test/pre_multi_index.hpp b/src/boost/libs/multi_index/test/pre_multi_index.hpp
new file mode 100644
index 000000000..7fc5b9e92
--- /dev/null
+++ b/src/boost/libs/multi_index/test/pre_multi_index.hpp
@@ -0,0 +1,49 @@
+/* Used in Boost.MultiIndex tests.
+ *
+ * Copyright 2003-2008 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_TEST_PRE_MULTI_INDEX_HPP
+#define BOOST_MULTI_INDEX_TEST_PRE_MULTI_INDEX_HPP
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/detail/workaround.hpp>
+#include <boost/multi_index/safe_mode_errors.hpp>
+
+#if defined(__GNUC__)&&defined(__APPLE__)&&\
+    (__GNUC__==4)&&(__GNUC_MINOR__==0)&&(__APPLE_CC__<=4061)
+  /* Darwin 8.1 includes a prerelease version of GCC 4.0 that, alas,
+   * has a regression as described in
+   *   http://gcc.gnu.org/bugzilla/show_bug.cgi?id=17435
+   * This compiler bug (fixed in the official 4.0 release) ruins the
+   * mechanisms upon which invariant-checking scope guards are built,
+   * so we can't set the invariant checking mode.
+   */
+#else
+#define BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING
+#endif
+
+#define BOOST_MULTI_INDEX_ENABLE_SAFE_MODE
+
+#if BOOST_WORKAROUND(__IBMCPP__,<=600)
+#pragma info(nolan) /* suppress warnings about offsetof with non-POD types */
+#endif
+
+struct safe_mode_exception
+{
+  safe_mode_exception(boost::multi_index::safe_mode::error_code error_code_):
+    error_code(error_code_)
+  {}
+
+  boost::multi_index::safe_mode::error_code error_code;
+};
+
+#define BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(expr,error_code) \
+if(!(expr)){throw safe_mode_exception(error_code);}
+
+#endif
diff --git a/src/boost/libs/multi_index/test/rooted_allocator.hpp b/src/boost/libs/multi_index/test/rooted_allocator.hpp
new file mode 100644
index 000000000..dc55c1999
--- /dev/null
+++ b/src/boost/libs/multi_index/test/rooted_allocator.hpp
@@ -0,0 +1,64 @@
+/* Used in Boost.MultiIndex tests.
+ *
+ * Copyright 2003-2020 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_TEST_ROOTED_ALLOCATOR_HPP
+#define BOOST_MULTI_INDEX_TEST_ROOTED_ALLOCATOR_HPP
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/type_traits/integral_constant.hpp>
+#include <memory>
+
+#if defined(BOOST_MSVC)
+#pragma warning(push)
+#pragma warning(disable:4355) /* this used in base member initializer list */
+#endif
+
+template<typename T,bool Propagate,bool AlwaysEqual>
+class rooted_allocator:public std::allocator<T>
+{
+  typedef boost::integral_constant<bool,Propagate>   propagate_type;
+  typedef boost::integral_constant<bool,AlwaysEqual> always_equal_type;
+
+public:
+  typedef propagate_type    propagate_on_container_copy_assignment;
+  typedef propagate_type    propagate_on_container_move_assignment;
+  typedef propagate_type    propagate_on_container_swap;
+  typedef always_equal_type is_always_equal;
+  template<typename U>
+  struct rebind{typedef rooted_allocator<U,Propagate,AlwaysEqual> other;};
+
+  rooted_allocator():root(0){}
+  explicit rooted_allocator(int):root(this){}
+  template<typename U>
+  rooted_allocator(const rooted_allocator<U,Propagate,AlwaysEqual>& x):
+    root(x.root){}
+
+  template<typename U>
+  bool operator==(const rooted_allocator<U,Propagate,AlwaysEqual>& x)const
+    {return AlwaysEqual?true:root==x.root;}
+  template<typename U>
+  bool operator!=(const rooted_allocator<U,Propagate,AlwaysEqual>& x)const
+    {return !(*this==x);}
+
+  template<typename U>
+  bool comes_from(const rooted_allocator<U,Propagate,AlwaysEqual>& x)const
+    {return root==&x;}
+
+private:
+  template<typename,bool,bool> friend class rooted_allocator;
+
+  const void* root;
+};
+
+#if defined(BOOST_MSVC)
+#pragma warning(pop) /* C4355 */
+#endif
+
+#endif
diff --git a/src/boost/libs/multi_index/test/small_allocator.hpp b/src/boost/libs/multi_index/test/small_allocator.hpp
new file mode 100644
index 000000000..7d1227b0f
--- /dev/null
+++ b/src/boost/libs/multi_index/test/small_allocator.hpp
@@ -0,0 +1,58 @@
+/* Used in Boost.MultiIndex tests.
+ *
+ * Copyright 2003-2018 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_TEST_SMALL_ALLOCATOR_HPP
+#define BOOST_MULTI_INDEX_TEST_SMALL_ALLOCATOR_HPP
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+
+template<typename T>
+class small_allocator
+{
+public:
+  typedef unsigned char size_type;
+  typedef signed char   difference_type;
+  typedef T*            pointer;
+  typedef const T*      const_pointer;
+  typedef void*         void_pointer;
+  typedef const void*   const_void_pointer;
+  typedef T&            reference;
+  typedef const T&      const_reference;
+  typedef T             value_type;
+  template<class U>struct rebind{typedef small_allocator<U> other;};
+
+  small_allocator(){}
+  small_allocator(const small_allocator<T>&){}
+  template<class U>small_allocator(const small_allocator<U>&,int=0){}
+
+  pointer allocate(size_type n)
+  {
+    return pointer((T*)(new char[n*sizeof(T)]));
+  }
+
+  void deallocate(pointer p,size_type)
+  {
+    delete[](char *)&*p;
+  }
+
+  size_type max_size()const{return (size_type)(-1);}
+
+  friend bool operator==(const small_allocator&,const small_allocator&)
+  {
+    return true;
+  }
+
+  friend bool operator!=(const small_allocator&,const small_allocator&)
+  {
+    return false;
+  }
+};
+
+#endif
diff --git a/src/boost/libs/multi_index/test/test_all_main.cpp b/src/boost/libs/multi_index/test/test_all_main.cpp
new file mode 100644
index 000000000..d4536183f
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_all_main.cpp
@@ -0,0 +1,65 @@
+/* Boost.MultiIndex test suite.
+ *
+ * Copyright 2003-2020 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include <boost/detail/lightweight_test.hpp>
+#include "test_alloc_awareness.hpp"
+#include "test_basic.hpp"
+#include "test_capacity.hpp"
+#include "test_comparison.hpp"
+#include "test_composite_key.hpp"
+#include "test_conv_iterators.hpp"
+#include "test_copy_assignment.hpp"
+#include "test_hash_ops.hpp"
+#include "test_iterators.hpp"
+#include "test_key.hpp"
+#include "test_key_extractors.hpp"
+#include "test_list_ops.hpp"
+#include "test_modifiers.hpp"
+#include "test_mpl_ops.hpp"
+#include "test_observers.hpp"
+#include "test_projection.hpp"
+#include "test_range.hpp"
+#include "test_rank_ops.hpp"
+#include "test_rearrange.hpp"
+#include "test_safe_mode.hpp"
+#include "test_serialization.hpp"
+#include "test_set_ops.hpp"
+#include "test_special_set_ops.hpp"
+#include "test_update.hpp"
+
+int main()
+{
+  test_allocator_awareness();
+  test_basic();
+  test_capacity();
+  test_comparison();
+  test_composite_key();
+  test_conv_iterators();
+  test_copy_assignment();
+  test_hash_ops();
+  test_iterators();
+  test_key();
+  test_key_extractors();
+  test_list_ops();
+  test_modifiers();
+  test_mpl_ops();
+  test_observers();
+  test_projection();
+  test_range();
+  test_rank_ops();
+  test_rearrange();
+  test_safe_mode();
+  test_serialization();
+  test_set_ops();
+  test_special_set_ops();
+  test_update();
+
+  return boost::report_errors();
+}
diff --git a/src/boost/libs/multi_index/test/test_alloc_awareness.cpp b/src/boost/libs/multi_index/test/test_alloc_awareness.cpp
new file mode 100644
index 000000000..af6075104
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_alloc_awareness.cpp
@@ -0,0 +1,159 @@
+/* Boost.MultiIndex test for allocator awareness.
+ *
+ * Copyright 2003-2020 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include "test_alloc_awareness.hpp"
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/move/core.hpp>
+#include "pre_multi_index.hpp"
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/hashed_index.hpp>
+#include <boost/multi_index/member.hpp>
+#include <boost/multi_index/ordered_index.hpp>
+#include <boost/multi_index/random_access_index.hpp>
+#include <boost/multi_index/ranked_index.hpp>
+#include <boost/multi_index/sequenced_index.hpp>
+#include "rooted_allocator.hpp"
+
+struct move_tracker
+{
+  move_tracker(int n):n(n),move_cted(false){}
+  move_tracker(const move_tracker& x):n(x.n),move_cted(false){}
+  move_tracker(BOOST_RV_REF(move_tracker) x):n(x.n),move_cted(true){}
+  move_tracker& operator=(BOOST_COPY_ASSIGN_REF(move_tracker) x)
+    {n=x.n;return *this;}
+  move_tracker& operator=(BOOST_RV_REF(move_tracker) x){n=x.n;return *this;}
+
+  int  n;
+  bool move_cted;
+
+private:
+  BOOST_COPYABLE_AND_MOVABLE(move_tracker)
+};
+
+inline bool operator==(const move_tracker& x,const move_tracker& y)
+{
+  return x.n==y.n;
+}
+
+inline bool operator<(const move_tracker& x,const move_tracker& y)
+{
+  return x.n<y.n;
+}
+
+#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
+namespace boost{
+#endif
+
+inline std::size_t hash_value(const move_tracker& x)
+{
+  boost::hash<int> h;
+  return h(x.n);
+}
+
+#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
+} /* namespace boost */
+#endif
+
+#if defined(BOOST_NO_CXX17_IF_CONSTEXPR)&&defined(BOOST_MSVC)
+#pragma warning(push)
+#pragma warning(disable:4127) /* conditional expression is constant */
+#endif
+
+template<bool Propagate,bool AlwaysEqual>
+void test_allocator_awareness_for()
+{
+  using namespace boost::multi_index;
+
+  typedef rooted_allocator<move_tracker,Propagate,AlwaysEqual> allocator;
+  typedef multi_index_container<
+    move_tracker,
+    indexed_by<
+      hashed_unique<identity<move_tracker> >,
+      ordered_unique<identity<move_tracker> >,
+      random_access<>,
+      ranked_unique<identity<move_tracker> >,
+      sequenced<>
+    >,
+    allocator
+  >                                                            container;
+
+  allocator root1(0),root2(0);
+  container c(root1);
+  for(int i=0;i<10;++i)c.emplace(i);
+
+  BOOST_TEST(c.get_allocator().comes_from(root1));
+
+  {
+    container c2(c,root2);
+    BOOST_TEST(c2.get_allocator().comes_from(root2));
+    BOOST_TEST(c2==c);
+  }
+  {
+    container           c2(c);
+    const move_tracker* pfirst=&*c2.begin();
+    container           c3(boost::move(c2),root2);
+    BOOST_TEST(c3.get_allocator().comes_from(root2));
+    BOOST_TEST(c3==c);
+    BOOST_TEST(c2.empty());
+    BOOST_TEST(AlwaysEqual==(&*c3.begin()==pfirst));
+    BOOST_TEST(!AlwaysEqual==(c3.begin()->move_cted));
+  }
+  {
+    container c2(root2);
+    c2=c;
+    BOOST_TEST(c2.get_allocator().comes_from(Propagate?root1:root2));
+    BOOST_TEST(c2==c);
+  }
+  {
+    const bool          element_transfer=Propagate||AlwaysEqual;
+
+    container           c2(c);
+    const move_tracker* pfirst=&*c2.begin();
+    container           c3(root2);
+    c3=boost::move(c2);
+    BOOST_TEST(c3.get_allocator().comes_from(Propagate?root1:root2));
+    BOOST_TEST(c3==c);
+    BOOST_TEST(c2.empty());
+    BOOST_TEST(element_transfer==(&*c3.begin()==pfirst));
+    BOOST_TEST(!element_transfer==(c3.begin()->move_cted));
+  }
+  if(Propagate||AlwaysEqual){
+    container           c2(c);
+    const move_tracker* pfirst=&*c2.begin();
+    container           c3(root2);
+    c3.swap(c2);
+    BOOST_TEST(c2.get_allocator().comes_from(Propagate?root2:root1));
+    BOOST_TEST(c3.get_allocator().comes_from(Propagate?root1:root2));
+    BOOST_TEST(c3==c);
+    BOOST_TEST(c2.empty());
+    BOOST_TEST(&*c3.begin()==pfirst);
+    BOOST_TEST(!c3.begin()->move_cted);
+  }
+}
+
+#if defined(BOOST_NO_CXX17_IF_CONSTEXPR)&&defined(BOOST_MSVC)
+#pragma warning(pop) /* C4127 */
+#endif
+
+void test_allocator_awareness()
+{
+  test_allocator_awareness_for<false,false>();
+  test_allocator_awareness_for<false,true>();
+
+#if !defined(BOOST_NO_CXX11_ALLOCATOR)
+  /* only in C+11 onwards are allocators potentially expected to propagate */
+
+  test_allocator_awareness_for<true,false>();
+  test_allocator_awareness_for<true,true>();
+
+#endif
+}
diff --git a/src/boost/libs/multi_index/test/test_alloc_awareness.hpp b/src/boost/libs/multi_index/test/test_alloc_awareness.hpp
new file mode 100644
index 000000000..d659ef55f
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_alloc_awareness.hpp
@@ -0,0 +1,11 @@
+/* Boost.MultiIndex test for allocator awareness.
+ *
+ * Copyright 2003-2020 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+void test_allocator_awareness();
diff --git a/src/boost/libs/multi_index/test/test_alloc_awareness_main.cpp b/src/boost/libs/multi_index/test/test_alloc_awareness_main.cpp
new file mode 100644
index 000000000..8fed7f9c9
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_alloc_awareness_main.cpp
@@ -0,0 +1,18 @@
+/* Boost.MultiIndex test for allocator awareness.
+ *
+ * Copyright 2003-2020 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include <boost/detail/lightweight_test.hpp>
+#include "test_alloc_awareness.hpp"
+
+int main()
+{
+  test_allocator_awareness();
+  return boost::report_errors();
+}
diff --git a/src/boost/libs/multi_index/test/test_basic.cpp b/src/boost/libs/multi_index/test/test_basic.cpp
new file mode 100644
index 000000000..dbfa9dada
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_basic.cpp
@@ -0,0 +1,158 @@
+/* Boost.MultiIndex basic test.
+ *
+ * Copyright 2003-2017 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include "test_basic.hpp"
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <algorithm>
+#include <vector>
+#include "pre_multi_index.hpp"
+#include "employee.hpp"
+#include <boost/detail/lightweight_test.hpp>
+
+using namespace boost::multi_index;
+
+struct less_by_employee_age
+{
+  bool operator()(const employee& e1,const employee& e2)const
+  {
+    return e1.age<e2.age;
+  }
+};
+
+struct no_addressof_type
+{
+  no_addressof_type(int n):n(n){}
+
+  void operator&()const{}
+
+  int n;
+};
+
+bool operator==(const no_addressof_type& x,const no_addressof_type& y)
+{
+  return x.n==y.n;
+}
+
+bool operator<(const no_addressof_type& x,const no_addressof_type& y)
+{
+  return x.n<y.n;
+}
+
+#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
+namespace boost{
+#endif
+
+inline std::size_t hash_value(const no_addressof_type& x)
+{
+  boost::hash<int> h;
+  return h(x.n);
+}
+
+#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
+} /* namespace boost */
+#endif
+
+void test_basic()
+{
+  employee_set          es;
+  std::vector<employee> v;
+
+#if defined(BOOST_NO_MEMBER_TEMPLATES)
+  employee_set_by_name& i1=get<by_name>(es);
+#else
+  employee_set_by_name& i1=es.get<by_name>();
+#endif
+
+  const employee_set_by_age& i2=get<2>(es);
+  employee_set_as_inserted&  i3=get<3>(es);
+  employee_set_by_ssn&       i4=get<ssn>(es);
+  employee_set_randomly&     i5=get<randomly>(es);
+
+  es.insert(employee(0,"Joe",31,1123));
+  es.insert(employee(5,"Anna",41,1123));      /* clash*/
+  i1.insert(employee(1,"Robert",27,5601));
+  es.insert(employee(2,"John",40,7889));
+  i3.push_back(employee(3,"Albert",20,9012));
+  i4.insert(employee(4,"John",57,1002));
+  i5.push_back(employee(0,"Andrew",60,2302)); /* clash */
+
+  v.push_back(employee(0,"Joe",31,1123));
+  v.push_back(employee(1,"Robert",27,5601));
+  v.push_back(employee(2,"John",40,7889));
+  v.push_back(employee(3,"Albert",20,9012));
+  v.push_back(employee(4,"John",57,1002));
+
+  {
+    /* by insertion order */
+
+    BOOST_TEST(std::equal(i3.begin(),i3.end(),v.begin()));
+    BOOST_TEST(std::equal(i5.begin(),i5.end(),v.begin()));
+  }
+
+  {
+    /* by id */
+
+    std::sort(v.begin(),v.end());
+    BOOST_TEST(std::equal(es.begin(),es.end(),v.begin()));
+  }
+
+  {
+    /* by age */
+
+    std::sort(v.begin(),v.end(),less_by_employee_age());
+    BOOST_TEST(std::equal(i2.begin(),i2.end(),v.begin()));
+  }
+
+  {
+    /* testcase for https://svn.boost.org/trac10/ticket/13307 */
+
+    typedef multi_index_container<
+      no_addressof_type,
+      indexed_by<
+        random_access<>,
+        ordered_non_unique<identity<no_addressof_type> >,
+        sequenced<>,
+        hashed_non_unique<identity<no_addressof_type> >
+      >
+    > multi_index_t;
+
+    multi_index_t        c;
+    const multi_index_t& cc=c;
+    no_addressof_type    x(0);
+    int                  a[]={1,2};
+    int                  b[]={6,7};
+    c.push_back(x);
+    c.insert(c.end(),a,a+2);
+    c.push_back(no_addressof_type(3));
+    c.emplace_back(4);
+    c.get<1>().emplace_hint(c.get<1>().begin(),5);
+    c.get<1>().insert(b,b+2);
+    (void)c.begin()->n;
+    (void)c.get<1>().begin()->n;
+    (void)c.get<2>().begin()->n;
+    (void)c.get<3>().begin()->n;
+    (void)c.get<3>().begin(0)->n;
+    (void)c.iterator_to(c.front());
+    (void)cc.iterator_to(c.front());
+    (void)c.get<1>().iterator_to(c.front());
+    (void)cc.get<1>().iterator_to(c.front());
+    (void)c.get<2>().iterator_to(c.front());
+    (void)cc.get<2>().iterator_to(c.front());
+    (void)c.get<3>().iterator_to(c.front());
+    (void)cc.get<3>().iterator_to(c.front());
+    (void)c.get<3>().local_iterator_to(c.front());
+    (void)cc.get<3>().local_iterator_to(c.front());
+    multi_index_t c2=c;(void)c2;
+    c.erase(c.begin());
+    c.erase(c.begin(),c.end());
+  }
+
+}
diff --git a/src/boost/libs/multi_index/test/test_basic.hpp b/src/boost/libs/multi_index/test/test_basic.hpp
new file mode 100644
index 000000000..652c0e090
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_basic.hpp
@@ -0,0 +1,11 @@
+/* Boost.MultiIndex basic test.
+ *
+ * Copyright 2003-2008 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+void test_basic();
diff --git a/src/boost/libs/multi_index/test/test_basic_main.cpp b/src/boost/libs/multi_index/test/test_basic_main.cpp
new file mode 100644
index 000000000..a98132ac3
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_basic_main.cpp
@@ -0,0 +1,18 @@
+/* Boost.MultiIndex basic test.
+ *
+ * Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include <boost/detail/lightweight_test.hpp>
+#include "test_basic.hpp"
+
+int main()
+{
+  test_basic();
+  return boost::report_errors();
+}
diff --git a/src/boost/libs/multi_index/test/test_capacity.cpp b/src/boost/libs/multi_index/test/test_capacity.cpp
new file mode 100644
index 000000000..57774da8d
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_capacity.cpp
@@ -0,0 +1,97 @@
+/* Boost.MultiIndex test for capacity memfuns.
+ *
+ * Copyright 2003-2015 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include "test_capacity.hpp"
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include "pre_multi_index.hpp"
+#include "employee.hpp"
+#include <boost/detail/lightweight_test.hpp>
+
+using namespace boost::multi_index;
+
+void test_capacity()
+{
+  employee_set es;
+
+  es.insert(employee(0,"Joe",31,1123));
+  es.insert(employee(1,"Robert",27,5601));
+  es.insert(employee(2,"John",40,7889));
+  es.insert(employee(3,"Albert",20,9012));
+  es.insert(employee(4,"John",57,1002));
+
+  BOOST_TEST(!es.empty());
+  BOOST_TEST(es.size()==5);
+  BOOST_TEST(es.size()<=es.max_size());
+
+  es.erase(es.begin());
+  BOOST_TEST(!get<name>(es).empty());
+  BOOST_TEST(get<name>(es).size()==4);
+  BOOST_TEST(get<name>(es).size()<=get<name>(es).max_size());
+
+  es.erase(es.begin());
+  BOOST_TEST(!get<as_inserted>(es).empty());
+  BOOST_TEST(get<as_inserted>(es).size()==3);
+  BOOST_TEST(get<as_inserted>(es).size()<=get<as_inserted>(es).max_size());
+
+  multi_index_container<int,indexed_by<sequenced<> > > ss;
+
+  ss.resize(10);
+  BOOST_TEST(ss.size()==10);
+  BOOST_TEST(ss.size()<=ss.max_size());
+
+  ss.resize(20,666);
+  BOOST_TEST(ss.size()==20);
+  BOOST_TEST(ss.back()==666);
+
+  ss.resize(5,10);
+  BOOST_TEST(ss.size()==5);
+
+  ss.resize(4);
+  BOOST_TEST(ss.size()==4);
+
+  multi_index_container<int,indexed_by<random_access<> > > rs;
+
+  rs.resize(10);
+  BOOST_TEST(rs.size()==10);
+  BOOST_TEST(rs.size()<=rs.max_size());
+  BOOST_TEST(rs.size()<=rs.capacity());
+
+  rs.resize(20,666);
+  BOOST_TEST(rs.size()==20);
+  BOOST_TEST(rs.back()==666);
+  BOOST_TEST(rs.size()<=rs.capacity());
+
+  employee_set::size_type c=rs.capacity();
+  rs.resize(10,20);
+  BOOST_TEST(rs.size()==10);
+  BOOST_TEST(rs.capacity()==c);
+
+  rs.resize(5);
+  BOOST_TEST(rs.size()==5);
+  BOOST_TEST(rs.capacity()==c);
+
+  rs.reserve(100);
+  BOOST_TEST(rs.size()==5);
+  BOOST_TEST(rs.capacity()>=100);
+
+  c=rs.capacity();
+  rs.reserve(99);
+  BOOST_TEST(rs.size()==5);
+  BOOST_TEST(rs.capacity()==c);
+
+  rs.shrink_to_fit();
+  BOOST_TEST(rs.size()==5);
+  BOOST_TEST(rs.capacity()==rs.size());
+
+  rs.clear();
+  rs.shrink_to_fit();
+  BOOST_TEST(rs.capacity()==0);
+}
diff --git a/src/boost/libs/multi_index/test/test_capacity.hpp b/src/boost/libs/multi_index/test/test_capacity.hpp
new file mode 100644
index 000000000..73bcf5e93
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_capacity.hpp
@@ -0,0 +1,11 @@
+/* Boost.MultiIndex test for capacity memfuns.
+ *
+ * Copyright 2003-2008 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+void test_capacity();
diff --git a/src/boost/libs/multi_index/test/test_capacity_main.cpp b/src/boost/libs/multi_index/test/test_capacity_main.cpp
new file mode 100644
index 000000000..ff8024280
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_capacity_main.cpp
@@ -0,0 +1,19 @@
+/* Boost.MultiIndex test for capacity memfuns.
+ *
+ * Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include <boost/detail/lightweight_test.hpp>
+#include "test_capacity.hpp"
+
+int main()
+{
+  test_capacity();
+  return boost::report_errors();
+}
+
diff --git a/src/boost/libs/multi_index/test/test_comparison.cpp b/src/boost/libs/multi_index/test/test_comparison.cpp
new file mode 100644
index 000000000..15226196b
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_comparison.cpp
@@ -0,0 +1,151 @@
+/* Boost.MultiIndex test for comparison functions.
+ *
+ * Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include "test_comparison.hpp"
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include "pre_multi_index.hpp"
+#include "employee.hpp"
+#include "pair_of_ints.hpp"
+#include <boost/detail/lightweight_test.hpp>
+
+using namespace boost::multi_index;
+
+template<typename Value>
+struct lookup_list{
+  typedef multi_index_container<
+    Value,
+    indexed_by<
+      sequenced<>,
+      ordered_non_unique<identity<Value> >
+    >
+  > type;
+};
+
+template<typename Value>
+struct lookup_vector{
+  typedef multi_index_container<
+    Value,
+    indexed_by<
+      random_access<>,
+      ordered_non_unique<identity<Value> >
+    >
+  > type;
+};
+
+void test_comparison()
+{
+  employee_set              es;
+  employee_set_by_name&     i1=get<1>(es);
+  employee_set_by_age&      i2=get<2>(es);
+  employee_set_as_inserted& i3=get<3>(es);
+  employee_set_by_ssn&      i4=get<4>(es);
+  employee_set_randomly&    i5=get<5>(es);
+  es.insert(employee(0,"Joe",31,1123));
+  es.insert(employee(1,"Robert",27,5601));
+  es.insert(employee(2,"John",40,7889));
+  es.insert(employee(3,"Albert",20,9012));
+  es.insert(employee(4,"John",57,1002));
+
+  employee_set              es2;
+  employee_set_by_name&     i12=get<by_name>(es2);
+  employee_set_by_age&      i22=get<age>(es2);
+  employee_set_as_inserted& i32=get<3>(es2);
+  employee_set_by_ssn&      i42=get<4>(es2);
+  employee_set_randomly&    i52=get<5>(es2);
+  es2.insert(employee(0,"Joe",31,1123));
+  es2.insert(employee(1,"Robert",27,5601));
+  es2.insert(employee(2,"John",40,7889));
+  es2.insert(employee(3,"Albert",20,9012));
+
+  BOOST_TEST(es==es&&es<=es&&es>=es&&
+             i12==i12&&  
+             i22==i22&&i22<=i22&&i22>=i22&&
+             i32==i32&&i32<=i32&&i32>=i32&&
+             i42==i42&&
+             i52==i52&&i52<=i52&&i52>=i52);
+  BOOST_TEST(es!=es2&&es2<es&&es>es2&&!(es<=es2)&&!(es2>=es));
+  BOOST_TEST(i1!=i12);
+  BOOST_TEST(i2!=i22&&i22<i2&&i2>i22&&!(i2<=i22)&&!(i22>=i2));
+  BOOST_TEST(i3!=i32&&i32<i3&&i3>i32&&!(i3<=i32)&&!(i32>=i3));
+  BOOST_TEST(i4!=i42);
+  BOOST_TEST(i5!=i52&&i52<i5&&i5>i52&&!(i5<=i52)&&!(i52>=i5));
+
+  multi_index_container<
+    pair_of_ints,
+    indexed_by<
+      hashed_non_unique<BOOST_MULTI_INDEX_MEMBER(pair_of_ints,int,first)>
+    >
+  > hc1,hc2;
+  hc1.insert(pair_of_ints(0,0));
+  hc1.insert(pair_of_ints(0,1));
+  hc1.insert(pair_of_ints(0,2));
+  hc1.insert(pair_of_ints(0,3));
+  hc1.insert(pair_of_ints(1,0));
+  hc1.insert(pair_of_ints(1,1));
+
+  hc2.insert(pair_of_ints(0,2));
+  hc2.insert(pair_of_ints(0,1));
+  hc2.insert(pair_of_ints(1,1));
+  hc2.insert(pair_of_ints(1,0));
+  hc2.insert(pair_of_ints(0,3));
+  hc2.insert(pair_of_ints(0,0));
+  BOOST_TEST(hc1==hc2);
+
+  hc1.insert(pair_of_ints(0,4));
+  hc2.insert(pair_of_ints(0,5));
+  BOOST_TEST(hc1!=hc2);
+
+  lookup_list<int>::type    l1;
+  lookup_list<char>::type   l2;
+  lookup_vector<char>::type l3;
+  lookup_list<long>::type   l4;
+  lookup_vector<long>::type l5;
+
+  l1.push_back(3);
+  l1.push_back(4);
+  l1.push_back(5);
+  l1.push_back(1);
+  l1.push_back(2);
+
+  l2.push_back(char(3));
+  l2.push_back(char(4));
+  l2.push_back(char(5));
+  l2.push_back(char(1));
+  l2.push_back(char(2));
+
+  l3.push_back(char(3));
+  l3.push_back(char(4));
+  l3.push_back(char(5));
+  l3.push_back(char(1));
+  l3.push_back(char(2));
+
+  l4.push_back(long(3));
+  l4.push_back(long(4));
+  l4.push_back(long(5));
+  l4.push_back(long(1));
+
+  l5.push_back(long(3));
+  l5.push_back(long(4));
+  l5.push_back(long(5));
+  l5.push_back(long(1));
+
+  BOOST_TEST(l1==l2&&l1<=l2&&l1>=l2);
+  BOOST_TEST(
+    get<1>(l1)==get<1>(l2)&&get<1>(l1)<=get<1>(l2)&&get<1>(l1)>=get<1>(l2));
+  BOOST_TEST(
+    get<1>(l1)==get<1>(l3)&&get<1>(l1)<=get<1>(l3)&&get<1>(l1)>=get<1>(l3));
+  BOOST_TEST(l1!=l4&&l4<l1&&l1>l4);
+  BOOST_TEST(
+    get<1>(l1)!=get<1>(l4)&&get<1>(l1)<get<1>(l4)&&get<1>(l4)>get<1>(l1));
+  BOOST_TEST(l3!=l5&&l5<l3&&l3>l5);
+  BOOST_TEST(
+    get<1>(l3)!=get<1>(l5)&&get<1>(l3)<get<1>(l5)&&get<1>(l5)>get<1>(l3));
+}
diff --git a/src/boost/libs/multi_index/test/test_comparison.hpp b/src/boost/libs/multi_index/test/test_comparison.hpp
new file mode 100644
index 000000000..4f0106922
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_comparison.hpp
@@ -0,0 +1,11 @@
+/* Boost.MultiIndex test for comparison functions.
+ *
+ * Copyright 2003-2008 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+void test_comparison();
diff --git a/src/boost/libs/multi_index/test/test_comparison_main.cpp b/src/boost/libs/multi_index/test/test_comparison_main.cpp
new file mode 100644
index 000000000..aace1229e
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_comparison_main.cpp
@@ -0,0 +1,19 @@
+/* Boost.MultiIndex test for comparison functions.
+ *
+ * Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include <boost/detail/lightweight_test.hpp>
+#include "test_comparison.hpp"
+
+int main()
+{
+  test_comparison();
+  return boost::report_errors();
+}
+
diff --git a/src/boost/libs/multi_index/test/test_composite_key.cpp b/src/boost/libs/multi_index/test/test_composite_key.cpp
new file mode 100644
index 000000000..24049692a
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_composite_key.cpp
@@ -0,0 +1,670 @@
+/* Boost.MultiIndex test for composite_key.
+ *
+ * Copyright 2003-2018 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include "test_composite_key.hpp"
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/detail/lightweight_test.hpp>
+#include "pre_multi_index.hpp"
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/composite_key.hpp>
+#include <boost/multi_index/hashed_index.hpp>
+#include <boost/multi_index/member.hpp>
+#include <boost/multi_index/ordered_index.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/repeat_from_to.hpp>
+
+using namespace boost::multi_index;
+using namespace boost::tuples;
+
+struct is_composite_key_result_helper
+{
+  typedef char yes;
+  struct no{char m[2];};
+
+  static no test(void*);
+
+  template<typename CompositeKey>
+  static yes test(composite_key_result<CompositeKey>*);
+};
+
+template<typename T>
+struct is_composite_key_result
+{
+  typedef is_composite_key_result_helper helper;
+
+  BOOST_STATIC_CONSTANT(bool,
+    value=(
+      sizeof(helper::test((T*)0))==
+      sizeof(typename helper::yes)));
+};
+
+template<typename CompositeKeyResult>
+struct composite_key_result_length
+{
+  BOOST_STATIC_CONSTANT(int,
+    value=boost::tuples::length<
+      BOOST_DEDUCED_TYPENAME 
+      CompositeKeyResult::composite_key_type::key_extractor_tuple
+    >::value);
+};
+
+#if !defined(BOOST_NO_CXX11_HDR_TUPLE)&&\
+    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+struct is_boost_tuple_helper
+{
+  typedef char yes;
+  struct no{char m[2];};
+
+  static no test(void*);
+
+  template<BOOST_PP_ENUM_PARAMS(10,typename T)>
+  static yes test(boost::tuple<BOOST_PP_ENUM_PARAMS(10,T)>*);
+};
+
+template<typename T>
+struct is_boost_tuple
+{
+  typedef is_boost_tuple_helper helper;
+
+  BOOST_STATIC_CONSTANT(bool,
+    value=(
+      sizeof(helper::test((T*)0))==
+      sizeof(typename helper::yes)));
+};
+
+template<typename T>
+struct composite_object_length
+{
+  typedef typename boost::mpl::if_c<
+    is_composite_key_result<T>::value,
+    composite_key_result_length<T>,
+    typename boost::mpl::if_c<
+      is_boost_tuple<T>::value,
+      boost::tuples::length<T>,
+      std::tuple_size<T>
+    >::type
+  >::type type;
+
+  BOOST_STATIC_CONSTANT(int,value=type::value);
+};
+#else
+template<typename T>
+struct composite_object_length
+{
+  typedef typename boost::mpl::if_c<
+    is_composite_key_result<T>::value,
+    composite_key_result_length<T>,
+    boost::tuples::length<T>
+  >::type type;
+
+  BOOST_STATIC_CONSTANT(int,value=type::value);
+};
+#endif
+
+template<typename CompositeKeyResult,typename T2>
+struct comparison_equal_length
+{
+  static bool is_less(const CompositeKeyResult& x,const T2& y)
+  {
+    composite_key_result_equal_to<CompositeKeyResult> eq;
+    composite_key_result_less<CompositeKeyResult>     lt;
+    composite_key_result_greater<CompositeKeyResult>  gt;
+    std::equal_to<CompositeKeyResult>                 std_eq;
+    std::less<CompositeKeyResult>                     std_lt;
+    std::greater<CompositeKeyResult>                  std_gt;
+
+    return  (x< y) && !(y< x)&&
+           !(x==y) && !(y==x)&&
+            (x!=y) &&  (y!=x)&&
+           !(x> y) &&  (y> x)&&
+           !(x>=y) &&  (y>=x)&&
+            (x<=y) && !(y<=x)&&
+          !eq(x,y) && !eq(y,x)&&
+           lt(x,y) && !lt(y,x)&&
+          !gt(x,y) &&  gt(y,x)&&
+      !std_eq(x,y) && !std_eq(y,x)&&
+       std_lt(x,y) && !std_lt(y,x)&&
+      !std_gt(x,y) &&  std_gt(y,x);
+  }
+
+  static bool is_greater(const CompositeKeyResult& x,const T2& y)
+  {
+    composite_key_result_equal_to<CompositeKeyResult> eq;
+    composite_key_result_less<CompositeKeyResult>     lt;
+    composite_key_result_greater<CompositeKeyResult>  gt;
+    std::equal_to<CompositeKeyResult>                 std_eq;
+    std::less<CompositeKeyResult>                     std_lt;
+    std::greater<CompositeKeyResult>                  std_gt;
+
+    return !(x< y) &&  (y< x)&&
+           !(x==y) && !(y==x)&&
+            (x!=y) &&  (y!=x)&&
+            (x> y) && !(y> x)&&
+            (x>=y) && !(y>=x)&&
+           !(x<=y) &&  (y<=x)&&
+          !eq(x,y) && !eq(y,x)&&
+          !lt(x,y) &&  lt(y,x)&&
+           gt(x,y) && !gt(y,x)&&
+      !std_eq(x,y) && !std_eq(y,x)&&
+      !std_lt(x,y) &&  std_lt(y,x)&&
+       std_gt(x,y) && !std_gt(y,x);
+  }
+
+  static bool is_equiv(const CompositeKeyResult& x,const T2& y)
+  {
+    composite_key_result_equal_to<CompositeKeyResult> eq;
+    composite_key_result_less<CompositeKeyResult>     lt;
+    composite_key_result_greater<CompositeKeyResult>  gt;
+    std::equal_to<CompositeKeyResult>                 std_eq;
+    std::less<CompositeKeyResult>                     std_lt;
+    std::greater<CompositeKeyResult>                  std_gt;
+
+    return !(x< y) && !(y< x)&&
+            (x==y) &&  (y==x)&&
+           !(x!=y) && !(y!=x)&&
+           !(x> y) && !(y> x)&&
+            (x>=y) &&  (y>=x)&&
+            (x<=y) &&  (y<=x)&&
+           eq(x,y) &&  eq(y,x)&&
+          !lt(x,y) && !lt(y,x)&&
+          !gt(x,y) && !gt(y,x)&&
+       std_eq(x,y) &&  std_eq(y,x)&&
+      !std_lt(x,y) && !std_lt(y,x)&&
+      !std_gt(x,y) && !std_gt(y,x);
+  }
+};
+
+template<typename CompositeKeyResult,typename T2>
+struct comparison_different_length
+{
+  static bool is_less(const CompositeKeyResult& x,const T2& y)
+  {
+    composite_key_result_less<CompositeKeyResult>    lt;
+    composite_key_result_greater<CompositeKeyResult> gt;
+    std::less<CompositeKeyResult>                    std_lt;
+    std::greater<CompositeKeyResult>                 std_gt;
+
+    return  (x< y) && !(y< x)&&
+           !(x> y) &&  (y> x)&&
+           !(x>=y) &&  (y>=x)&&
+            (x<=y) && !(y<=x)&&
+           lt(x,y) && !lt(y,x)&&
+          !gt(x,y) &&  gt(y,x)&&
+       std_lt(x,y) && !std_lt(y,x)&&
+      !std_gt(x,y) &&  std_gt(y,x);
+  }
+
+  static bool is_greater(const CompositeKeyResult& x,const T2& y)
+  {
+    composite_key_result_less<CompositeKeyResult>    lt;
+    composite_key_result_greater<CompositeKeyResult> gt;
+    std::less<CompositeKeyResult>                    std_lt;
+    std::greater<CompositeKeyResult>                 std_gt;
+
+    return !(x< y) &&  (y< x)&&
+            (x> y) && !(y> x)&&
+            (x>=y) && !(y>=x)&&
+           !(x<=y) &&  (y<=x)&&
+          !lt(x,y) &&  lt(y,x)&&
+           gt(x,y) && !gt(y,x)&&
+      !std_lt(x,y) && std_lt(y,x)&&
+       std_gt(x,y) && !std_gt(y,x);
+  }
+
+  static bool is_equiv(const CompositeKeyResult& x,const T2& y)
+  {
+    composite_key_result_less<CompositeKeyResult>    lt;
+    composite_key_result_greater<CompositeKeyResult> gt;
+    std::less<CompositeKeyResult>                    std_lt;
+    std::greater<CompositeKeyResult>                 std_gt;
+
+    return !(x< y) && !(y< x)&&
+           !(x> y) && !(y> x)&&
+            (x>=y) &&  (y>=x)&&
+            (x<=y) &&  (y<=x)&&
+          !lt(x,y) && !lt(y,x)&&
+          !gt(x,y) && !gt(y,x)&&
+      !std_lt(x,y) && !std_lt(y,x)&&
+      !std_gt(x,y) && !std_gt(y,x);
+  }
+};
+
+template<typename CompositeKeyResult,typename T2>
+struct comparison_helper:
+  boost::mpl::if_c<
+    composite_key_result_length<CompositeKeyResult>::value==
+      composite_object_length<T2>::value,
+    comparison_equal_length<CompositeKeyResult,T2>,
+    comparison_different_length<CompositeKeyResult,T2>
+  >::type
+{
+};
+
+template<typename CompositeKeyResult,typename T2>
+static bool is_less(const CompositeKeyResult& x,const T2& y)
+{
+  return comparison_helper<CompositeKeyResult,T2>::is_less(x,y);
+}
+
+template<typename CompositeKeyResult,typename T2>
+static bool is_greater(const CompositeKeyResult& x,const T2& y)
+{
+  return comparison_helper<CompositeKeyResult,T2>::is_greater(x,y);
+}
+
+template<typename CompositeKeyResult,typename T2>
+static bool is_equiv(const CompositeKeyResult& x,const T2& y)
+{
+  return comparison_helper<CompositeKeyResult,T2>::is_equiv(x,y);
+}
+
+template<typename T1,typename T2,typename Compare>
+static bool is_less(const T1& x,const T2& y,const Compare& c)
+{
+  return c(x,y)&&!c(y,x);
+}
+
+template<typename T1,typename T2,typename Compare>
+static bool is_greater(const T1& x,const T2& y,const Compare& c)
+{
+  return c(y,x)&&!c(x,y);
+}
+
+template<typename T1,typename T2,typename Compare>
+static bool is_equiv(const T1& x,const T2& y,const Compare& c)
+{
+  return !c(x,y)&&!c(y,x);
+}
+
+template<typename T1,typename T2,typename Compare,typename Equiv>
+static bool is_less(
+  const T1& x,const T2& y,const Compare& c,const Equiv& eq)
+{
+  return c(x,y)&&!c(y,x)&&!eq(x,y)&&!eq(y,x);
+}
+
+template<typename T1,typename T2,typename Compare,typename Equiv>
+static bool is_greater(
+  const T1& x,const T2& y,const Compare& c,const Equiv& eq)
+{
+  return c(y,x)&&!c(x,y)&&!eq(x,y)&&!eq(y,x);
+}
+
+template<typename T1,typename T2,typename Compare,typename Equiv>
+static bool is_equiv(
+  const T1& x,const T2& y,const Compare& c,const Equiv& eq)
+{
+  return !c(x,y)&&!c(y,x)&&eq(x,y)&&eq(y,x);
+}
+
+struct xyz
+{
+  xyz(int x_=0,int y_=0,int z_=0):x(x_),y(y_),z(z_){}
+
+  int  x;
+  int  y;
+  int  z;
+};
+
+struct modulo_equal
+{
+  modulo_equal(int i):i_(i){}
+  bool operator ()(int x,int y)const{return (x%i_)==(y%i_);}
+
+private:
+  int i_;
+};
+
+struct xystr
+{
+  xystr(int x_=0,int y_=0,std::string str_=0):x(x_),y(y_),str(str_){}
+
+  int         x;
+  int         y;
+  std::string str;
+};
+
+#define TUPLE_MAKER_CREATE(z,n,tuple)                   \
+template<BOOST_PP_ENUM_PARAMS(n,typename T)>            \
+static tuple<BOOST_PP_ENUM_PARAMS(n,T)>                 \
+create(BOOST_PP_ENUM_BINARY_PARAMS(n,const T,& t)){     \
+  return tuple<BOOST_PP_ENUM_PARAMS(n,T)>(              \
+   BOOST_PP_ENUM_PARAMS(n,t));                          \
+}
+
+#define DEFINE_TUPLE_MAKER(name,tuple)                  \
+struct name                                             \
+{                                                       \
+  static tuple<> create(){return tuple<>();}            \
+  BOOST_PP_REPEAT_FROM_TO(1,5,TUPLE_MAKER_CREATE,tuple) \
+};
+
+DEFINE_TUPLE_MAKER(boost_tuple_maker,boost::tuple)
+
+#if !defined(BOOST_NO_CXX11_HDR_TUPLE)&&\
+    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+DEFINE_TUPLE_MAKER(std_tuple_maker,std::tuple)
+#endif
+
+#undef DEFINE_TUPLE_MAKER
+#undef TUPLE_MAKER_CREATE
+
+template<typename TupleMaker>
+void test_composite_key_template()
+{
+  typedef composite_key<
+    xyz,
+    BOOST_MULTI_INDEX_MEMBER(xyz,int,x),
+    BOOST_MULTI_INDEX_MEMBER(xyz,int,y),
+    BOOST_MULTI_INDEX_MEMBER(xyz,int,z)
+  > ckey_t1;
+
+  typedef multi_index_container<
+    xyz,
+    indexed_by<
+      ordered_unique<ckey_t1>
+    >
+  > indexed_t1;
+
+  indexed_t1 mc1;
+  mc1.insert(xyz(0,0,0));
+  mc1.insert(xyz(0,0,1));
+  mc1.insert(xyz(0,1,0));
+  mc1.insert(xyz(0,1,1));
+  mc1.insert(xyz(1,0,0));
+  mc1.insert(xyz(1,0,1));
+  mc1.insert(xyz(1,1,0));
+  mc1.insert(xyz(1,1,1));
+
+  BOOST_TEST(mc1.size()==8);
+  BOOST_TEST(
+    std::distance(
+      mc1.find(mc1.key_extractor()(xyz(0,0,0))),
+      mc1.find(mc1.key_extractor()(xyz(1,0,0))))==4);
+  BOOST_TEST(
+    std::distance(
+      mc1.find(TupleMaker::create(0,0,0)),
+      mc1.find(TupleMaker::create(1,0,0)))==4);
+  BOOST_TEST(
+    std::distance(
+      mc1.lower_bound(TupleMaker::create(0,0)),
+      mc1.upper_bound(TupleMaker::create(1,0)))==6);
+
+#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+  BOOST_TEST(
+    std::distance(
+      mc1.lower_bound(1),
+      mc1.upper_bound(1))==4);
+#endif
+
+  ckey_t1 ck1;
+  ckey_t1 ck2(ck1);
+  ckey_t1 ck3(
+    boost::make_tuple(
+      BOOST_MULTI_INDEX_MEMBER(xyz,int,x)(),
+      BOOST_MULTI_INDEX_MEMBER(xyz,int,y)(),
+      BOOST_MULTI_INDEX_MEMBER(xyz,int,z)()));
+  ckey_t1 ck4(get<0>(ck1.key_extractors()));
+
+  (void)ck3; /* prevent unused var */
+
+  get<2>(ck4.key_extractors())=
+    get<2>(ck2.key_extractors());
+
+  BOOST_TEST(is_equiv  (ck1(xyz(0,0,0)),ck2(xyz(0,0,0))));
+  BOOST_TEST(is_less   (ck1(xyz(0,0,1)),ck2(xyz(0,1,0))));
+  BOOST_TEST(is_greater(ck1(xyz(0,0,1)),ck2(xyz(0,0,0))));
+
+  BOOST_TEST(is_equiv  (ck1(xyz(0,0,0)),TupleMaker::create(0)));
+  BOOST_TEST(is_less   (ck1(xyz(0,0,0)),TupleMaker::create(1)));
+  BOOST_TEST(is_greater(ck1(xyz(0,0,0)),TupleMaker::create(-1)));
+  BOOST_TEST(is_equiv  (ck1(xyz(0,0,0)),TupleMaker::create(0,0)));
+  BOOST_TEST(is_less   (ck1(xyz(0,0,0)),TupleMaker::create(0,1)));
+  BOOST_TEST(is_greater(ck1(xyz(0,0,0)),TupleMaker::create(0,-1)));
+  BOOST_TEST(is_equiv  (ck1(xyz(0,0,0)),TupleMaker::create(0,0,0)));
+  BOOST_TEST(is_less   (ck1(xyz(0,0,0)),TupleMaker::create(0,0,1)));
+  BOOST_TEST(is_greater(ck1(xyz(0,0,0)),TupleMaker::create(0,0,-1)));
+  BOOST_TEST(is_equiv  (ck1(xyz(0,0,0)),TupleMaker::create(0,0,0,1)));
+
+  typedef composite_key_result_less<ckey_t1::result_type>     ckey_comp_t1;
+  typedef composite_key_result_equal_to<ckey_t1::result_type> ckey_eq_t1;
+
+  ckey_comp_t1 cp1;
+  ckey_eq_t1   eq1;
+
+  BOOST_TEST(is_equiv  (ck1(xyz(0,0,0)),ck2(xyz(0,0,0)),cp1,eq1));
+  BOOST_TEST(is_less   (ck1(xyz(0,0,1)),ck2(xyz(0,1,0)),cp1,eq1));
+  BOOST_TEST(is_greater(ck1(xyz(0,0,1)),ck2(xyz(0,0,0)),cp1,eq1));
+
+  BOOST_TEST(is_equiv  (ck1(xyz(0,0,0)),TupleMaker::create(0),cp1));
+  BOOST_TEST(is_less   (ck1(xyz(0,0,0)),TupleMaker::create(1),cp1));
+  BOOST_TEST(is_greater(ck1(xyz(0,0,0)),TupleMaker::create(-1),cp1));
+
+#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+  BOOST_TEST(is_equiv  (ck1(xyz(0,0,0)),0,cp1));
+  BOOST_TEST(is_less   (ck1(xyz(0,0,0)),1,cp1));
+  BOOST_TEST(is_greater(ck1(xyz(0,0,0)),-1,cp1));
+#endif
+
+  BOOST_TEST(is_equiv  (ck1(xyz(0,0,0)),TupleMaker::create(0,0),cp1));
+  BOOST_TEST(is_less   (ck1(xyz(0,0,0)),TupleMaker::create(0,1),cp1));
+  BOOST_TEST(is_greater(ck1(xyz(0,0,0)),TupleMaker::create(0,-1),cp1));
+  BOOST_TEST(is_equiv  (ck1(xyz(0,0,0)),TupleMaker::create(0,0,0),cp1,eq1));
+  BOOST_TEST(is_less   (ck1(xyz(0,0,0)),TupleMaker::create(0,0,1),cp1,eq1));
+  BOOST_TEST(is_greater(ck1(xyz(0,0,0)),TupleMaker::create(0,0,-1),cp1,eq1));
+
+  typedef composite_key_result_greater<ckey_t1::result_type> ckey_comp_t2;
+
+  ckey_comp_t2 cp2;
+
+  BOOST_TEST(is_equiv  (ck1(xyz(0,0,0)),ck2(xyz(0,0,0)),cp2));
+  BOOST_TEST(is_greater(ck1(xyz(0,0,1)),ck2(xyz(0,1,0)),cp2));
+  BOOST_TEST(is_less   (ck1(xyz(0,0,1)),ck2(xyz(0,0,0)),cp2));
+
+  BOOST_TEST(is_equiv  (ck1(xyz(0,0,0)),TupleMaker::create(0),cp2));
+  BOOST_TEST(is_greater(ck1(xyz(0,0,0)),TupleMaker::create(1),cp2));
+  BOOST_TEST(is_less   (ck1(xyz(0,0,0)),TupleMaker::create(-1),cp2));
+  BOOST_TEST(is_equiv  (ck1(xyz(0,0,0)),TupleMaker::create(0,0),cp2));
+  BOOST_TEST(is_greater(ck1(xyz(0,0,0)),TupleMaker::create(0,1),cp2));
+  BOOST_TEST(is_less   (ck1(xyz(0,0,0)),TupleMaker::create(0,-1),cp2));
+  BOOST_TEST(is_equiv  (ck1(xyz(0,0,0)),TupleMaker::create(0,0,0),cp2));
+  BOOST_TEST(is_greater(ck1(xyz(0,0,0)),TupleMaker::create(0,0,1),cp2));
+  BOOST_TEST(is_less   (ck1(xyz(0,0,0)),TupleMaker::create(0,0,-1),cp2));
+
+  typedef composite_key_equal_to<
+    modulo_equal,
+    modulo_equal,
+    std::equal_to<int>,
+    std::equal_to<int>
+  > ckey_eq_t2;
+
+  ckey_eq_t2 eq2(
+    boost::make_tuple(
+      modulo_equal(2),
+      modulo_equal(3),
+      std::equal_to<int>(),
+      std::equal_to<int>()));
+  ckey_eq_t2 eq3(eq2);
+  ckey_eq_t2 eq4(
+    get<0>(eq3.key_eqs()),
+    get<1>(eq3.key_eqs()));
+
+  eq3=eq4; /* prevent unused var */
+  eq4=eq3; /* prevent unused var */
+
+  BOOST_TEST( eq2(ck1(xyz(0,0,0)),ck1(xyz(0,0,0))));
+  BOOST_TEST(!eq2(ck1(xyz(0,1,0)),ck1(xyz(0,0,0))));
+  BOOST_TEST(!eq2(ck1(xyz(0,2,0)),ck1(xyz(0,0,0))));
+  BOOST_TEST( eq2(ck1(xyz(0,3,0)),ck1(xyz(0,0,0))));
+  BOOST_TEST(!eq2(ck1(xyz(1,0,0)),ck1(xyz(0,0,0))));
+  BOOST_TEST(!eq2(ck1(xyz(1,1,0)),ck1(xyz(0,0,0))));
+  BOOST_TEST(!eq2(ck1(xyz(1,2,0)),ck1(xyz(0,0,0))));
+  BOOST_TEST(!eq2(ck1(xyz(1,3,0)),ck1(xyz(0,0,0))));
+  BOOST_TEST( eq2(ck1(xyz(2,0,0)),ck1(xyz(0,0,0))));
+  BOOST_TEST(!eq2(ck1(xyz(2,1,0)),ck1(xyz(0,0,0))));
+  BOOST_TEST(!eq2(ck1(xyz(2,2,0)),ck1(xyz(0,0,0))));
+  BOOST_TEST( eq2(ck1(xyz(2,3,0)),ck1(xyz(0,0,0))));
+
+  BOOST_TEST( eq2(TupleMaker::create(0,0,0),ck1(xyz(0,0,0))));
+  BOOST_TEST(!eq2(ck1(xyz(0,1,0))          ,TupleMaker::create(0,0,0)));
+  BOOST_TEST(!eq2(TupleMaker::create(0,2,0),ck1(xyz(0,0,0))));
+  BOOST_TEST( eq2(ck1(xyz(0,3,0))          ,TupleMaker::create(0,0,0)));
+  BOOST_TEST(!eq2(TupleMaker::create(1,0,0),ck1(xyz(0,0,0))));
+  BOOST_TEST(!eq2(ck1(xyz(1,1,0))          ,TupleMaker::create(0,0,0)));
+  BOOST_TEST(!eq2(TupleMaker::create(1,2,0),ck1(xyz(0,0,0))));
+  BOOST_TEST(!eq2(ck1(xyz(1,3,0))          ,TupleMaker::create(0,0,0)));
+  BOOST_TEST( eq2(TupleMaker::create(2,0,0),ck1(xyz(0,0,0))));
+  BOOST_TEST(!eq2(ck1(xyz(2,1,0))          ,TupleMaker::create(0,0,0)));
+  BOOST_TEST(!eq2(TupleMaker::create(2,2,0),ck1(xyz(0,0,0))));
+  BOOST_TEST( eq2(ck1(xyz(2,3,0))          ,TupleMaker::create(0,0,0)));
+
+  typedef composite_key_compare<
+    std::less<int>,
+    std::greater<int>, /* order reversed */
+    std::less<int>
+  > ckey_comp_t3;
+
+  ckey_comp_t3 cp3;
+  ckey_comp_t3 cp4(cp3);
+  ckey_comp_t3 cp5(
+    boost::make_tuple(
+      std::less<int>(),
+      std::greater<int>(),
+      std::less<int>()));
+  ckey_comp_t3 cp6(get<0>(cp3.key_comps()));
+
+  cp4=cp5; /* prevent unused var */
+  cp5=cp6; /* prevent unused var */
+  cp6=cp4; /* prevent unused var */
+
+  BOOST_TEST(is_equiv  (ck1(xyz(0,0,0)),ck2(xyz(0,0,0)),cp3));
+  BOOST_TEST(is_greater(ck1(xyz(0,0,1)),ck2(xyz(0,1,0)),cp3));
+  BOOST_TEST(is_greater(ck1(xyz(0,0,1)),ck2(xyz(0,0,0)),cp3));
+
+  BOOST_TEST(is_equiv  (ck1(xyz(0,0,0)),TupleMaker::create(0),cp3));
+  BOOST_TEST(is_less   (ck1(xyz(0,0,0)),TupleMaker::create(1),cp3));
+  BOOST_TEST(is_greater(ck1(xyz(0,0,0)),TupleMaker::create(-1),cp3));
+  BOOST_TEST(is_equiv  (ck1(xyz(0,0,0)),TupleMaker::create(0,0),cp3));
+  BOOST_TEST(is_less   (ck1(xyz(0,0,0)),TupleMaker::create(0,-1),cp3));
+  BOOST_TEST(is_greater(ck1(xyz(0,0,0)),TupleMaker::create(0,1),cp3));
+  BOOST_TEST(is_equiv  (ck1(xyz(0,0,0)),TupleMaker::create(0,0,0),cp3));
+  BOOST_TEST(is_less   (ck1(xyz(0,0,0)),TupleMaker::create(0,0,1),cp3));
+  BOOST_TEST(is_greater(ck1(xyz(0,0,0)),TupleMaker::create(0,0,-1),cp3));
+
+  typedef composite_key<
+    xyz,
+    BOOST_MULTI_INDEX_MEMBER(xyz,int,y), /* members reversed */
+    BOOST_MULTI_INDEX_MEMBER(xyz,int,x)
+  > ckey_t2;
+
+  ckey_t2 ck5;
+
+  BOOST_TEST(is_equiv  (ck1(xyz(0,0,1)),ck5(xyz(0,0,0))));
+  BOOST_TEST(is_less   (ck1(xyz(0,0,0)),ck5(xyz(-1,1,0))));
+  BOOST_TEST(is_greater(ck1(xyz(0,0,0)),ck5(xyz(1,-1,0))));
+
+  BOOST_TEST(is_equiv  (ck1(xyz(0,0,1)),ck5(xyz(0,0,0)),cp1));
+  BOOST_TEST(is_less   (ck1(xyz(0,0,0)),ck5(xyz(-1,1,0)),cp1));
+  BOOST_TEST(is_greater(ck1(xyz(0,0,0)),ck5(xyz(1,-1,0)),cp1));
+
+  BOOST_TEST(is_equiv  (ck1(xyz(0,0,1)),ck5(xyz(0,0,0)),cp2));
+  BOOST_TEST(is_greater(ck1(xyz(0,0,0)),ck5(xyz(-1,1,0)),cp2));
+  BOOST_TEST(is_less   (ck1(xyz(0,0,0)),ck5(xyz(1,-1,0)),cp2));
+
+  BOOST_TEST(is_equiv  (ck1(xyz(0,0,1)),ck5(xyz(0,0,0)),cp3));
+  BOOST_TEST(is_less   (ck1(xyz(0,0,0)),ck5(xyz(-1,1,0)),cp3));
+  BOOST_TEST(is_greater(ck1(xyz(0,0,0)),ck5(xyz(1,-1,0)),cp3));
+
+  typedef multi_index_container<
+    xyz,
+    indexed_by<
+      hashed_unique<ckey_t1>
+    >
+  > indexed_t2;
+
+  indexed_t2 mc2;
+  mc2.insert(xyz(0,0,0));
+  mc2.insert(xyz(0,0,1));
+  mc2.insert(xyz(0,1,0));
+  mc2.insert(xyz(0,1,1));
+  mc2.insert(xyz(1,0,0));
+  mc2.insert(xyz(1,0,1));
+  mc2.insert(xyz(1,1,0));
+  mc2.insert(xyz(1,1,1));
+  mc2.insert(xyz(0,0,0));
+  mc2.insert(xyz(0,0,1));
+  mc2.insert(xyz(0,1,0));
+  mc2.insert(xyz(0,1,1));
+  mc2.insert(xyz(1,0,0));
+  mc2.insert(xyz(1,0,1));
+  mc2.insert(xyz(1,1,0));
+  mc2.insert(xyz(1,1,1));
+
+  BOOST_TEST(mc2.size()==8);
+  BOOST_TEST(mc2.find(TupleMaker::create(0,0,1))->z==1);
+  BOOST_TEST(ck1(*(mc2.find(TupleMaker::create(1,0,1))))==
+             TupleMaker::create(1,0,1));
+
+  typedef composite_key<
+    xystr,
+    BOOST_MULTI_INDEX_MEMBER(xystr,std::string,str),
+    BOOST_MULTI_INDEX_MEMBER(xystr,int,x),
+    BOOST_MULTI_INDEX_MEMBER(xystr,int,y)
+  > ckey_t3;
+
+  ckey_t3 ck6;
+
+  typedef composite_key_hash<
+    boost::hash<std::string>,
+    boost::hash<int>,
+    boost::hash<int>
+  > ckey_hash_t;
+
+  ckey_hash_t ch1;
+  ckey_hash_t ch2(ch1);
+  ckey_hash_t ch3(
+    boost::make_tuple(
+      boost::hash<std::string>(),
+      boost::hash<int>(),
+      boost::hash<int>()));
+  ckey_hash_t ch4(get<0>(ch1.key_hash_functions()));
+
+  ch2=ch3; /* prevent unused var */
+  ch3=ch4; /* prevent unused var */
+  ch4=ch2; /* prevent unused var */
+
+  BOOST_TEST(
+    ch1(ck6(xystr(0,0,"hello")))==
+    ch1(TupleMaker::create(std::string("hello"),0,0)));
+  BOOST_TEST(
+    ch1(ck6(xystr(4,5,"world")))==
+    ch1(TupleMaker::create(std::string("world"),4,5)));
+
+  typedef boost::hash<composite_key_result<ckey_t3> > ckeyres_hash_t;
+
+  ckeyres_hash_t crh;
+
+  BOOST_TEST(
+    ch1(ck6(xystr(0,0,"hello")))==crh(ck6(xystr(0,0,"hello"))));
+  BOOST_TEST(
+    ch1(ck6(xystr(4,5,"world")))==crh(ck6(xystr(4,5,"world"))));
+}
+
+void test_composite_key()
+{
+  test_composite_key_template<boost_tuple_maker>();
+
+#if !defined(BOOST_NO_CXX11_HDR_TUPLE)&&\
+    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+  test_composite_key_template<std_tuple_maker>();
+#endif
+}
diff --git a/src/boost/libs/multi_index/test/test_composite_key.hpp b/src/boost/libs/multi_index/test/test_composite_key.hpp
new file mode 100644
index 000000000..8a7ae5344
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_composite_key.hpp
@@ -0,0 +1,11 @@
+/* Boost.MultiIndex test for composite_key.
+ *
+ * Copyright 2003-2008 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+void test_composite_key();
diff --git a/src/boost/libs/multi_index/test/test_composite_key_main.cpp b/src/boost/libs/multi_index/test/test_composite_key_main.cpp
new file mode 100644
index 000000000..79f7c2d4e
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_composite_key_main.cpp
@@ -0,0 +1,18 @@
+/* Boost.MultiIndex test for composite_key.
+ *
+ * Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include <boost/detail/lightweight_test.hpp>
+#include "test_composite_key.hpp"
+
+int main()
+{
+  test_composite_key();
+  return boost::report_errors();
+}
diff --git a/src/boost/libs/multi_index/test/test_conv_iterators.cpp b/src/boost/libs/multi_index/test/test_conv_iterators.cpp
new file mode 100644
index 000000000..24751e011
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_conv_iterators.cpp
@@ -0,0 +1,75 @@
+/* Boost.MultiIndex test for interconvertibilty between const and
+ * non-const iterators.
+ *
+ * Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include "test_conv_iterators.hpp"
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include "pre_multi_index.hpp"
+#include "employee.hpp"
+#include <boost/detail/lightweight_test.hpp>
+
+using namespace boost::multi_index;
+
+void test_conv_iterators()
+{
+  employee_set es;
+  es.insert(employee(2,"John",40,7889));
+
+  {
+    const employee_set& ces=es;
+    employee_set::iterator        it=es.find(employee(2,"John",40,7889));
+    employee_set::const_iterator it1=es.find(employee(2,"John",40,7889));
+    employee_set::const_iterator it2=ces.find(employee(2,"John",40,7889));
+
+    BOOST_TEST(it==it1&&it1==it2&&it2==it);
+    BOOST_TEST(*it==*it1&&*it1==*it2&&*it2==*it);
+  }
+  {
+    employee_set_by_name&        i1=get<1>(es);
+    const employee_set_by_name& ci1=get<1>(es);
+    employee_set_by_name::iterator        it=i1.find("John");
+    employee_set_by_name::const_iterator it1=i1.find("John");
+    employee_set_by_name::const_iterator it2=ci1.find("John");
+
+    BOOST_TEST(it==it1&&it1==it2&&it2==it);
+    BOOST_TEST(*it==*it1&&*it1==*it2&&*it2==*it);
+  }
+  {
+    employee_set_by_name&        i1=get<1>(es);
+    const employee_set_by_name& ci1=get<1>(es);
+    employee_set_by_name::local_iterator        it=i1.begin(i1.bucket("John"));
+    employee_set_by_name::const_local_iterator it1=i1.begin(i1.bucket("John"));
+    employee_set_by_name::const_local_iterator it2=ci1.begin(ci1.bucket("John"));
+
+    BOOST_TEST(it==it1&&it1==it2&&it2==it);
+    BOOST_TEST(*it==*it1&&*it1==*it2&&*it2==*it);
+  }
+  {
+    employee_set_as_inserted&        i3=get<3>(es);
+    const employee_set_as_inserted& ci3=get<3>(es);
+    employee_set_as_inserted::iterator        it=i3.begin();
+    employee_set_as_inserted::const_iterator it1=i3.begin();
+    employee_set_as_inserted::const_iterator it2=ci3.begin();
+
+    BOOST_TEST(it==it1&&it1==it2&&it2==it);
+    BOOST_TEST(*it==*it1&&*it1==*it2&&*it2==*it);
+  }
+  {
+    employee_set_randomly&        i5=get<5>(es);
+    const employee_set_randomly& ci5=get<5>(es);
+    employee_set_randomly::iterator        it=i5.begin();
+    employee_set_randomly::const_iterator it1=i5.begin();
+    employee_set_randomly::const_iterator it2=ci5.begin();
+
+    BOOST_TEST(it==it1&&it1==it2&&it2==it);
+    BOOST_TEST(*it==*it1&&*it1==*it2&&*it2==*it);
+  }
+}
diff --git a/src/boost/libs/multi_index/test/test_conv_iterators.hpp b/src/boost/libs/multi_index/test/test_conv_iterators.hpp
new file mode 100644
index 000000000..1e493b52a
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_conv_iterators.hpp
@@ -0,0 +1,12 @@
+/* Boost.MultiIndex test for interconvertibilty between const and
+ * non-const iterators.
+ *
+ * Copyright 2003-2008 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+void test_conv_iterators();
diff --git a/src/boost/libs/multi_index/test/test_conv_iterators_main.cpp b/src/boost/libs/multi_index/test/test_conv_iterators_main.cpp
new file mode 100644
index 000000000..5d07f7fc1
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_conv_iterators_main.cpp
@@ -0,0 +1,21 @@
+/* Boost.MultiIndex test for interconvertibilty between const and
+ * non-const iterators.
+ *
+ * Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include <boost/detail/lightweight_test.hpp>
+#include "test_conv_iterators.hpp"
+
+int main()
+{
+  test_conv_iterators();
+  return boost::report_errors();
+}
+
+
diff --git a/src/boost/libs/multi_index/test/test_copy_assignment.cpp b/src/boost/libs/multi_index/test/test_copy_assignment.cpp
new file mode 100644
index 000000000..fca40b267
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_copy_assignment.cpp
@@ -0,0 +1,365 @@
+/* Boost.MultiIndex test for copying and assignment.
+ *
+ * Copyright 2003-2018 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include "test_copy_assignment.hpp"
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <algorithm>
+#include <boost/move/utility_core.hpp>
+#include <list>
+#include <numeric>
+#include <vector>
+#include "pre_multi_index.hpp"
+#include "employee.hpp"
+#include "small_allocator.hpp"
+#include <boost/detail/lightweight_test.hpp>
+
+using namespace boost::multi_index;
+
+#if BOOST_WORKAROUND(__MWERKS__,<=0x3003)
+/* The "ISO C++ Template Parser" option makes CW8.3 incorrectly fail at
+ * expressions of the form sizeof(x) where x is an array local to a
+ * template function.
+ */
+
+#pragma parse_func_templ off
+#endif
+
+typedef multi_index_container<int> copyable_and_movable;
+
+struct holder
+{
+  copyable_and_movable c;
+};
+
+template<typename Sequence>
+static void test_assign()
+{
+  Sequence s;
+
+  int a[]={0,1,2,3,4,5};
+  std::size_t sa=sizeof(a)/sizeof(a[0]);
+
+  s.assign(&a[0],&a[sa]);
+  BOOST_TEST(s.size()==sa&&std::equal(s.begin(),s.end(),&a[0]));
+
+  s.assign((const int*)(&a[0]),(const int*)(&a[sa]));
+  BOOST_TEST(s.size()==sa&&std::equal(s.begin(),s.end(),&a[0]));
+
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+  s.assign({0,1,2,3,4,5});
+#else
+  s.assign(&a[0],&a[sa]);
+#endif
+
+  BOOST_TEST(s.size()==sa&&std::equal(s.begin(),s.end(),&a[0]));
+
+  s.assign((std::size_t)18,37);
+  BOOST_TEST(s.size()==18&&std::accumulate(s.begin(),s.end(),0)==666);
+
+  s.assign((std::size_t)12,167);
+  BOOST_TEST(s.size()==12&&std::accumulate(s.begin(),s.end(),0)==2004);
+}
+
+#if BOOST_WORKAROUND(__MWERKS__,<=0x3003)
+#pragma parse_func_templ reset
+#endif
+
+template<typename Sequence>
+static void test_integral_assign()
+{
+  /* Special cases described in 23.1.1/9: integral types must not
+   * be taken as iterators in assign(f,l) and insert(p,f,l).
+   */
+
+  Sequence s;
+
+  s.assign(5,10);
+  BOOST_TEST(s.size()==5&&std::accumulate(s.begin(),s.end(),0)==50);
+  s.assign(2u,5u);
+  BOOST_TEST(s.size()==2&&std::accumulate(s.begin(),s.end(),0)==10);
+
+  s.clear();
+  s.insert(s.begin(),5,10);
+  BOOST_TEST(s.size()==5&&std::accumulate(s.begin(),s.end(),0)==50);
+  s.insert(s.begin(),2u,5u);
+  BOOST_TEST(s.size()==7&&std::accumulate(s.begin(),s.end(),0)==60);
+}
+
+employee_set produce_employee_set()
+{
+  employee_set es;
+  es.insert(employee(0,"Petr",60,2837));
+  es.insert(employee(1,"Jiri",25,2143));
+  es.insert(employee(2,"Radka",40,4875));
+  es.insert(employee(3,"Milan",38,3474));
+  return es;
+}
+
+void test_copy_assignment()
+{
+  employee_set es;
+  employee_set es2(es);
+
+  employee_set::allocator_type al=es.get_allocator();
+  al=get<1>(es).get_allocator();
+  al=get<2>(es).get_allocator();
+  al=get<3>(es).get_allocator();
+  al=get<4>(es).get_allocator();
+  al=get<5>(es).get_allocator();
+
+  BOOST_TEST(es2.empty());
+
+  es2.insert(employee(0,"Joe",31,1123));
+  es2.insert(employee(1,"Robert",27,5601));
+  es2.insert(employee(2,"John",40,7889));
+  es2.insert(employee(2,"Aristotle",2388,3357)); /* clash */
+  es2.insert(employee(3,"Albert",20,9012));
+  es2.insert(employee(4,"John",57,1002));
+  es2.insert(employee(0,"Andrew",60,2302));      /* clash */
+
+  employee_set es3(es2);
+
+  BOOST_TEST(es2==es3);
+  BOOST_TEST(get<2>(es2)==get<2>(es3));
+  BOOST_TEST(get<3>(es2)==get<3>(es3));
+  BOOST_TEST(get<5>(es2)==get<5>(es3));
+
+  employee_set es4=employee_set(non_std_allocator<employee>());
+  employee_set_by_name& i1=get<name>(es4);
+  i1=get<1>(es2);
+
+  BOOST_TEST(es4==es2);
+
+  employee_set es5=employee_set(employee_set::ctor_args_list());
+  employee_set_by_age& i2=get<age>(es5);
+  i2=get<2>(es2);
+
+  BOOST_TEST(i2==get<2>(es2));
+
+  employee_set es6;
+  employee_set_as_inserted& i3=get<as_inserted>(es6);
+  i3=get<3>(es2);
+
+  BOOST_TEST(i3==get<3>(es2));
+
+  employee_set es7;
+  employee_set_randomly& i5=get<randomly>(es7);
+  i5=get<5>(es2);
+
+  BOOST_TEST(i5==get<5>(es2));
+
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)&&\
+    !BOOST_WORKAROUND(BOOST_MSVC,==1800) /* MSVC 12.0 chokes on what follows */
+  employee_set es8({{0,"Rose",40,4512},{1,"Mary",38,3345},{2,"Jo",25,7102}});
+  employee_set es9;
+  es9={{0,"Rose",40,4512},{1,"Mary",38,3345},{2,"Jo",25,7102},
+       {0,"Rose",40,4512}};
+
+  BOOST_TEST(es8.size()==3);
+  BOOST_TEST(es9==es8);
+
+  es9.clear();
+  get<0>(es9)={{0,"Rose",40,4512},{1,"Mary",38,3345},{2,"Jo",25,7102},
+               {0,"Rose",40,4512}};
+  BOOST_TEST(es9==es8);
+
+  es9.clear();
+  get<0>(es9)={{0,"Rose",40,4512},{2,"Jo",25,7102},{1,"Mary",38,3345}};
+  BOOST_TEST(es9==es8);
+
+  es9.clear();
+  get<1>(es9)={{1,"Mary",38,3345},{0,"Rose",40,4512},{2,"Jo",25,7102},
+               {0,"Rose",40,4512}};
+  BOOST_TEST(es9==es8);
+
+  es9.clear();
+  get<2>(es9)={{2,"Jo",25,7102},{0,"Rose",40,4512},{1,"Mary",38,3345}};
+  BOOST_TEST(es9==es8);
+
+  es9.clear();
+  get<3>(es9)={{0,"Rose",40,4512},{1,"Mary",38,3345},{1,"Mary",38,3345},
+               {2,"Jo",25,7102}};
+  BOOST_TEST(es9==es8);
+
+  es9.clear();
+  get<4>(es9)={{1,"Mary",38,3345},{2,"Jo",25,7102},{0,"Rose",40,4512}};
+  BOOST_TEST(es9==es8);
+
+  es9.clear();
+  get<5>(es9)={{1,"Mary",38,3345},{2,"Jo",25,7102},{0,"Rose",40,4512},
+               {2,"Jo",25,7102}};
+  BOOST_TEST(es9==es8);
+#endif
+
+  employee_set es10(produce_employee_set()),es11(produce_employee_set());
+  BOOST_TEST(es10==es11);
+
+  employee_set es12(boost::move(es10));
+  BOOST_TEST(es10.empty());
+  BOOST_TEST(es11==es12);
+
+  es10=boost::move(es12);
+  BOOST_TEST(es12.empty());
+  BOOST_TEST(es11==es10);
+
+  std::list<employee> l;
+  l.push_back(employee(3,"Anna",31,5388));
+  l.push_back(employee(1,"Rachel",27,9012));
+  l.push_back(employee(2,"Agatha",40,1520));
+
+  employee_set es13(l.begin(),l.end());
+
+  l.sort();
+
+  BOOST_TEST(es13.size()==l.size()&&
+              std::equal(es13.begin(),es13.end(),l.begin()));
+
+  test_assign<multi_index_container<int,indexed_by<sequenced<> > > >();
+  test_integral_assign<
+    multi_index_container<int,indexed_by<sequenced<> > > >();
+
+  test_assign<multi_index_container<int,indexed_by<random_access<> > > >();
+  test_integral_assign<
+    multi_index_container<int,indexed_by<random_access<> > > >();
+
+  /* Testcase for problem described at  http://www.boost.org/doc/html/move/
+   * emulation_limitations.html#move.emulation_limitations.assignment_operator
+   */
+
+  holder h((holder()));
+  h=holder();
+
+#if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
+{
+  /* testcase for https://svn.boost.org/trac10/ticket/13518 */
+
+  multi_index_container<int> x={};
+}
+#endif
+
+  typedef small_allocator<int> small_alloc;
+  typedef multi_index_container<
+    int,
+    indexed_by<
+      ordered_unique<identity<int> >,
+      ranked_unique<identity<int> >,
+      hashed_unique<identity<int> >,
+      sequenced<>,
+      random_access<>
+    >,
+    small_alloc
+  > small_container;
+  typedef small_container::nth_index<0>::type small_container_0;
+  typedef small_container::nth_index<1>::type small_container_1;
+  typedef small_container::nth_index<2>::type small_container_2;
+  typedef small_container::nth_index<3>::type small_container_3;
+  typedef small_container::nth_index<4>::type small_container_4;
+
+  BOOST_STATIC_ASSERT((
+    boost::is_same<small_container::size_type,small_alloc::size_type>::value));
+  BOOST_STATIC_ASSERT((
+    boost::is_same<
+      small_container::difference_type,small_alloc::difference_type>::value));
+  BOOST_STATIC_ASSERT((
+    boost::is_same<small_container_0::size_type,small_alloc::size_type>::value));
+  BOOST_STATIC_ASSERT((
+    boost::is_same<
+      small_container_0::difference_type,small_alloc::difference_type>::value));
+  BOOST_STATIC_ASSERT((
+    boost::is_same<small_container_1::size_type,small_alloc::size_type>::value));
+  BOOST_STATIC_ASSERT((
+    boost::is_same<
+      small_container_1::difference_type,small_alloc::difference_type>::value));
+  BOOST_STATIC_ASSERT((
+    boost::is_same<small_container_2::size_type,small_alloc::size_type>::value));
+  BOOST_STATIC_ASSERT((
+    boost::is_same<
+      small_container_2::difference_type,small_alloc::difference_type>::value));
+  BOOST_STATIC_ASSERT((
+    boost::is_same<small_container_3::size_type,small_alloc::size_type>::value));
+  BOOST_STATIC_ASSERT((
+    boost::is_same<
+      small_container_3::difference_type,small_alloc::difference_type>::value));
+  BOOST_STATIC_ASSERT((
+    boost::is_same<small_container_4::size_type,small_alloc::size_type>::value));
+  BOOST_STATIC_ASSERT((
+    boost::is_same<
+      small_container_4::difference_type,small_alloc::difference_type>::value));
+
+  small_container        sc;
+  small_container_0&     sc0=sc.get<0>();
+  small_container_1&     sc1=sc.get<1>();
+  small_container_2&     sc2=sc.get<2>();
+  small_container_3&     sc3=sc.get<3>();
+  small_container_4&     sc4=sc.get<4>();
+  small_alloc::size_type s,
+                         ms=(small_alloc::size_type)(-1);
+
+  sc.insert(0);
+
+  s=sc0.size();
+  BOOST_TEST(sc0.max_size()<=ms);
+  s=sc0.erase(1);
+  s=sc0.count(0);
+  s=sc0.count(0,std::less<int>());
+
+  s=sc1.size();
+  BOOST_TEST(sc1.max_size()<=ms);
+  s=sc1.erase(1);
+  s=sc1.count(0);
+  s=sc1.count(0,std::less<int>());
+  (void)sc1.nth(s);
+  s=sc1.rank(sc1.begin());
+  s=sc1.find_rank(0);
+  s=sc1.find_rank(0,std::less<int>());
+  s=sc1.lower_bound_rank(0);
+  s=sc1.lower_bound_rank(0,std::less<int>());
+  s=sc1.upper_bound_rank(0);
+  s=sc1.upper_bound_rank(0,std::less<int>());
+  s=sc1.equal_range_rank(0).first;
+  s=sc1.equal_range_rank(0).second;
+  s=sc1.range_rank(unbounded,unbounded).first;
+  s=sc1.range_rank(unbounded,unbounded).second;
+
+  s=sc2.size();
+  BOOST_TEST(sc2.max_size()<=ms);
+  s=sc2.erase(1);
+  s=sc2.count(0);
+  s=sc2.count(0,boost::hash<int>(),std::equal_to<int>());
+  s=sc2.bucket_count();
+  BOOST_TEST(sc2.max_bucket_count()<=ms);
+  BOOST_TEST(sc2.bucket_size((small_alloc::size_type)(0))<=ms);
+  BOOST_TEST(sc2.bucket_size(0)<=ms);
+  (void)sc2.begin(0);
+  (void)sc2.end(0);
+  (void)sc2.cbegin(0);
+  (void)sc2.cend(0);
+  sc2.rehash(2);
+  sc2.reserve(2);
+
+  s=sc3.size();
+  BOOST_TEST(sc3.max_size()<=ms);
+  sc3.resize(0);
+  sc3.resize(0,0);
+  sc3.assign((small_alloc::size_type)(1),0);
+  sc3.insert(sc3.begin(),(small_alloc::size_type)(0),0);
+
+  s=sc4.size();
+  BOOST_TEST(sc4.max_size()<=ms);
+  BOOST_TEST(sc4.capacity()<=ms);
+  sc4.reserve(0);
+  sc4.resize(0);
+  sc4.resize(0,0);
+  sc4.assign((small_alloc::size_type)(1),0);
+  (void)sc4[0];
+  (void)sc4.at(0);
+  sc4.insert(sc4.begin(),(small_alloc::size_type)(0),0);
+}
diff --git a/src/boost/libs/multi_index/test/test_copy_assignment.hpp b/src/boost/libs/multi_index/test/test_copy_assignment.hpp
new file mode 100644
index 000000000..59a1ed5b5
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_copy_assignment.hpp
@@ -0,0 +1,11 @@
+/* Boost.MultiIndex test for copying and assignment.
+ *
+ * Copyright 2003-2008 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+void test_copy_assignment();
diff --git a/src/boost/libs/multi_index/test/test_copy_assignment_main.cpp b/src/boost/libs/multi_index/test/test_copy_assignment_main.cpp
new file mode 100644
index 000000000..e14bd973d
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_copy_assignment_main.cpp
@@ -0,0 +1,18 @@
+/* Boost.MultiIndex test for copying and assignment.
+ *
+ * Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include <boost/detail/lightweight_test.hpp>
+#include "test_copy_assignment.hpp"
+
+int main()
+{
+  test_copy_assignment();
+  return boost::report_errors();
+}
diff --git a/src/boost/libs/multi_index/test/test_hash_ops.cpp b/src/boost/libs/multi_index/test/test_hash_ops.cpp
new file mode 100644
index 000000000..e85d905aa
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_hash_ops.cpp
@@ -0,0 +1,118 @@
+/* Boost.MultiIndex test for standard hash operations.
+ *
+ * Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include "test_hash_ops.hpp"
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <iterator>
+#include <boost/detail/lightweight_test.hpp>
+#include "pre_multi_index.hpp"
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/hashed_index.hpp>
+#include <boost/multi_index/identity.hpp>
+#include <vector>
+
+#include <iostream>
+
+using namespace boost::multi_index;
+
+template<typename HashedContainer>
+void check_load_factor(const HashedContainer& hc)
+{
+  float lf=(float)hc.size()/hc.bucket_count();
+  BOOST_TEST(lf<=hc.load_factor()+1.E-6);
+  BOOST_TEST(lf>=hc.load_factor()-1.E-6);
+  BOOST_TEST(lf<=hc.max_load_factor()+1.E-6);
+}
+
+typedef multi_index_container<
+  int,
+  indexed_by<
+    hashed_unique<identity<int> >
+  >
+> hash_container;
+
+void test_hash_ops()
+{
+  hash_container hc;
+
+  BOOST_TEST(hc.max_load_factor()==1.0f);
+  BOOST_TEST(hc.bucket_count()<=hc.max_bucket_count());
+
+  hc.insert(1000);
+  hash_container::size_type buc=hc.bucket(1000);
+  hash_container::local_iterator it0=hc.begin(buc);
+  hash_container::local_iterator it1=hc.end(buc);
+  BOOST_TEST(
+    (hash_container::size_type)std::distance(it0,it1)==hc.bucket_size(buc)&&
+    hc.bucket_size(buc)==1&&*it0==1000);
+
+  hc.clear();
+
+  for(hash_container::size_type s=2*hc.bucket_count();s--;){
+    hc.insert((int)s);
+  }
+  check_load_factor(hc);
+
+  hc.max_load_factor(0.5f);
+  BOOST_TEST(hc.max_load_factor()==0.5f);
+  hc.insert(-1);
+  check_load_factor(hc);
+
+  hc.rehash(1);
+  BOOST_TEST(hc.bucket_count()>=1);
+  check_load_factor(hc);
+
+  hc.max_load_factor(0.25f);
+  hc.rehash(1);
+  BOOST_TEST(hc.bucket_count()>=1);
+  check_load_factor(hc);
+
+  hash_container::size_type bc=4*hc.bucket_count();
+  hc.max_load_factor(0.125f);
+  hc.rehash(bc);
+  BOOST_TEST(hc.bucket_count()>=bc);
+  check_load_factor(hc);
+
+  bc=2*hc.bucket_count();
+  hc.rehash(bc);
+  BOOST_TEST(hc.bucket_count()>=bc);
+  check_load_factor(hc);
+
+  hc.clear();
+  hc.insert(0);
+  hc.rehash(1);
+  BOOST_TEST(hc.bucket_count()>=1);
+  check_load_factor(hc);
+
+  hash_container hc2;
+  hc2.insert(0);
+  hc2.max_load_factor(0.5f/hc2.bucket_count());
+  BOOST_TEST(hc2.load_factor()>hc2.max_load_factor());
+  hc2.reserve(1);
+  BOOST_TEST(hc2.load_factor()<hc2.max_load_factor());
+
+  hash_container hc3;
+  hc3.clear();
+  hc3.max_load_factor(1.0f);
+  hc3.reserve(1000);
+  hash_container::size_type bc3=hc3.bucket_count();
+  BOOST_TEST(bc3>=1000);
+  std::vector<int> v;
+  for(unsigned int n=0;n<bc3;++n)v.push_back(n);
+  hc3.insert(v.begin(),v.end());
+  BOOST_TEST(hc3.bucket_count()==bc3); /* LWG issue 2156 */
+  hc3.max_load_factor(0.25f);
+  hc3.reserve(100);
+  BOOST_TEST(hc3.bucket_count()>bc3);
+  bc3=hc3.bucket_count();
+  hc3.reserve((hash_container::size_type)(3.0f*hc3.max_load_factor()*bc3));
+  BOOST_TEST(hc3.bucket_count()>bc3);
+}
diff --git a/src/boost/libs/multi_index/test/test_hash_ops.hpp b/src/boost/libs/multi_index/test/test_hash_ops.hpp
new file mode 100644
index 000000000..37ebc4ada
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_hash_ops.hpp
@@ -0,0 +1,11 @@
+/* Boost.MultiIndex test for standard hash operations.
+ *
+ * Copyright 2003-2008 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+void test_hash_ops();
diff --git a/src/boost/libs/multi_index/test/test_hash_ops_main.cpp b/src/boost/libs/multi_index/test/test_hash_ops_main.cpp
new file mode 100644
index 000000000..be237b37e
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_hash_ops_main.cpp
@@ -0,0 +1,18 @@
+/* Boost.MultiIndex test for standard hash operations.
+ *
+ * Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include <boost/detail/lightweight_test.hpp>
+#include "test_hash_ops.hpp"
+
+int main()
+{
+  test_hash_ops();
+  return boost::report_errors();
+}
diff --git a/src/boost/libs/multi_index/test/test_iterators.cpp b/src/boost/libs/multi_index/test/test_iterators.cpp
new file mode 100644
index 000000000..d9c7f7f20
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_iterators.cpp
@@ -0,0 +1,250 @@
+/* Boost.MultiIndex test for iterators.
+ *
+ * Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include "test_iterators.hpp"
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include "pre_multi_index.hpp"
+#include "employee.hpp"
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/next_prior.hpp>
+
+using namespace boost::multi_index;
+
+template<typename Index>
+void test_non_const_iterators(Index& i,int target)
+{
+  typedef typename Index::iterator         iterator;
+  typedef typename Index::reverse_iterator reverse_iterator;
+
+  int n=0;
+  for(iterator it=i.begin();it!=i.end();++it){
+    BOOST_TEST(i.iterator_to(*it)==it);
+    n+=it->id;
+  }
+  int m=0;
+  for(reverse_iterator rit=i.rbegin();rit!=i.rend();++rit){
+    m+=rit->id;
+  }
+  int p=0;
+  for(iterator it2=i.end();it2!=i.begin();){
+    --it2;
+    p+=it2->id;
+  }
+  int q=0;
+  for(reverse_iterator rit2=i.rend();rit2!=i.rbegin();){
+    --rit2;
+    q+=rit2->id;
+  }
+
+  BOOST_TEST(n==target&&n==m&&n==p&&n==q);
+}
+
+template<typename Index>
+void test_const_iterators(const Index& i,int target)
+{
+  typedef typename Index::const_iterator         const_iterator;
+  typedef typename Index::const_reverse_iterator const_reverse_iterator;
+
+  BOOST_TEST(i.cbegin()==i.begin());
+  BOOST_TEST(i.cend()==i.end());
+  BOOST_TEST(i.crbegin()==i.rbegin());
+  BOOST_TEST(i.crend()==i.rend());
+
+  int n=0;
+  for(const_iterator it=i.begin();it!=i.end();++it){
+    BOOST_TEST(i.iterator_to(*it)==it);
+    n+=it->id;
+  }
+  int m=0;
+  for(const_reverse_iterator rit=i.rbegin();rit!=i.rend();++rit){
+    m+=rit->id;
+  }
+  int p=0;
+  for(const_iterator it2=i.end();it2!=i.begin();){
+    --it2;
+    p+=it2->id;
+  }
+  int q=0;
+  for(const_reverse_iterator rit2=i.rend();rit2!=i.rbegin();){
+    --rit2;
+    q+=rit2->id;
+  }
+
+  BOOST_TEST(n==target&&n==m&&n==p&&n==q);
+}
+
+template<typename Index>
+void test_non_const_hashed_iterators(Index& i,int target)
+{
+  typedef typename Index::iterator       iterator;
+  typedef typename Index::local_iterator local_iterator;
+  typedef typename Index::size_type      size_type;
+
+  int n=0;
+  for(iterator it=i.begin();it!=i.end();++it){
+    BOOST_TEST(i.iterator_to(*it)==it);
+    n+=it->id;
+  }
+  int m=0;
+  for(size_type buc=0;buc<i.bucket_count();++buc){
+    for(local_iterator it=i.begin(buc);it!=i.end(buc);++it){
+      BOOST_TEST(i.local_iterator_to(*it)==it);
+      m+=it->id;
+    }
+  }
+
+  BOOST_TEST(n==target&&n==m);
+}
+
+template<typename Index>
+void test_const_hashed_iterators(const Index& i,int target)
+{
+  typedef typename Index::const_iterator       const_iterator;
+  typedef typename Index::const_local_iterator const_local_iterator;
+  typedef typename Index::size_type            size_type;
+
+  BOOST_TEST(i.cbegin()==i.begin());
+  BOOST_TEST(i.cend()==i.end());
+
+  int n=0;
+  for(const_iterator it=i.begin();it!=i.end();++it){
+    BOOST_TEST(i.iterator_to(*it)==it);
+    n+=it->id;
+  }
+  int m=0;
+  for(size_type buc=0;buc<i.bucket_count();++buc){
+    BOOST_TEST(i.cbegin(buc)==i.begin(buc));
+    BOOST_TEST(i.cend(buc)==i.end(buc));
+    for(const_local_iterator it=i.begin(buc);it!=i.end(buc);++it){
+      BOOST_TEST(i.local_iterator_to(*it)==it);
+      m+=it->id;
+    }
+  }
+
+  BOOST_TEST(n==target&&n==m);
+}
+
+template<typename Index>
+void test_non_const_rnd_iterators(Index& i,int target)
+{
+  typedef typename Index::iterator         iterator;
+  typedef typename Index::reverse_iterator reverse_iterator;
+  typedef typename Index::difference_type  difference_type;
+
+  iterator         middle=i.begin()+(i.end()-i.begin())/2;
+  difference_type  off=middle-i.begin();
+  reverse_iterator rmiddle=i.rbegin()+off;
+  bool             odd=((i.end()-i.begin())%2)!=0;
+
+  int n=0;
+  for(iterator it=i.begin();it!=middle;++it){
+    BOOST_TEST(i.iterator_to(*it)==it);
+    n+=it->id;
+    n+=it[off].id;
+  }
+  if(odd)n+=(boost::prior(i.end()))->id;
+  int m=0;
+  for(reverse_iterator rit=i.rbegin();rit!=rmiddle;++rit){
+    m+=rit->id;
+    m+=(rit+off)->id;
+  }
+  if(odd)m+=(boost::prior(i.rend()))->id;
+  int p=0;
+  for(iterator it2=i.end();it2!=middle;){
+    --it2;
+    p+=it2->id;
+    p+=(it2-off)->id;
+  }
+  if(odd)p-=middle->id;
+  int q=0;
+  for(reverse_iterator rit2=i.rend();rit2!=rmiddle;){
+    --rit2;
+    q+=rit2->id;
+    q+=(rit2-off)->id;
+  }
+  if(odd)q-=rmiddle->id;
+
+  BOOST_TEST(n==target&&n==m&&n==p&&n==q);
+}
+
+template<typename Index>
+void test_const_rnd_iterators(const Index& i,int target)
+{
+  typedef typename Index::const_iterator         const_iterator;
+  typedef typename Index::const_reverse_iterator const_reverse_iterator;
+  typedef typename Index::difference_type        difference_type;
+
+  BOOST_TEST(i.cbegin()==i.begin());
+  BOOST_TEST(i.cend()==i.end());
+  BOOST_TEST(i.crbegin()==i.rbegin());
+  BOOST_TEST(i.crend()==i.rend());
+
+  const_iterator         middle=i.begin()+(i.end()-i.begin())/2;
+  difference_type        off=middle-i.begin();
+  const_reverse_iterator rmiddle=i.rbegin()+off;
+  bool                   odd=((i.end()-i.begin())%2)!=0;
+
+  int n=0;
+  for(const_iterator it=i.begin();it!=middle;++it){
+    BOOST_TEST(i.iterator_to(*it)==it);
+    n+=it->id;
+    n+=it[off].id;
+  }
+  if(odd)n+=(boost::prior(i.end()))->id;
+  int m=0;
+  for(const_reverse_iterator rit=i.rbegin();rit!=rmiddle;++rit){
+    m+=rit->id;
+    m+=(rit+off)->id;
+  }
+  if(odd)m+=(boost::prior(i.rend()))->id;
+  int p=0;
+  for(const_iterator it2=i.end();it2!=middle;){
+    --it2;
+    p+=it2->id;
+    p+=(it2-off)->id;
+  }
+  if(odd)p-=middle->id;
+  int q=0;
+  for(const_reverse_iterator rit2=i.rend();rit2!=rmiddle;){
+    --rit2;
+    q+=rit2->id;
+    q+=(rit2-off)->id;
+  }
+  if(odd)q-=rmiddle->id;
+
+  BOOST_TEST(n==target&&n==m&&n==p&&n==q);
+}
+
+void test_iterators()
+{
+  employee_set es;
+
+  es.insert(employee(0,"Joe",31,1123));
+  es.insert(employee(1,"Robert",27,5601));
+  es.insert(employee(2,"John",40,7889));
+  es.insert(employee(3,"Albert",20,9012));
+  es.insert(employee(4,"John",57,1002));
+
+  int target=0+1+2+3+4;
+
+  test_non_const_iterators       (es,target);
+  test_const_iterators           (es,target);
+  test_non_const_hashed_iterators(get<1>(es),target);
+  test_const_hashed_iterators    (get<1>(es),target);
+  test_non_const_iterators       (get<2>(es),target);
+  test_const_iterators           (get<2>(es),target);
+  test_non_const_iterators       (get<3>(es),target);
+  test_const_iterators           (get<3>(es),target);
+  test_non_const_hashed_iterators(get<4>(es),target);
+  test_const_hashed_iterators    (get<4>(es),target);
+  test_non_const_rnd_iterators   (get<5>(es),target);
+  test_const_rnd_iterators       (get<5>(es),target);
+}
diff --git a/src/boost/libs/multi_index/test/test_iterators.hpp b/src/boost/libs/multi_index/test/test_iterators.hpp
new file mode 100644
index 000000000..01ffab21e
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_iterators.hpp
@@ -0,0 +1,11 @@
+/* Boost.MultiIndex test for iterators.
+ *
+ * Copyright 2003-2008 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+void test_iterators();
diff --git a/src/boost/libs/multi_index/test/test_iterators_main.cpp b/src/boost/libs/multi_index/test/test_iterators_main.cpp
new file mode 100644
index 000000000..13bd39ae2
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_iterators_main.cpp
@@ -0,0 +1,19 @@
+/* Boost.MultiIndex test for iterators.
+ *
+ * Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include <boost/detail/lightweight_test.hpp>
+#include "test_iterators.hpp"
+
+int main()
+{
+  test_iterators();
+  return boost::report_errors();
+}
+
diff --git a/src/boost/libs/multi_index/test/test_key.cpp b/src/boost/libs/multi_index/test/test_key.cpp
new file mode 100644
index 000000000..10ebb37e7
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_key.cpp
@@ -0,0 +1,170 @@
+/* Boost.MultiIndex test for terse key specification syntax.
+ *
+ * Copyright 2003-2019 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include "test_key.hpp"
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/detail/lightweight_test.hpp>
+#include "pre_multi_index.hpp"
+#include <boost/multi_index/key.hpp>
+
+#if !defined(BOOST_MULTI_INDEX_KEY_SUPPORTED)
+
+#include <boost/config/pragma_message.hpp>
+
+BOOST_PRAGMA_MESSAGE("boost::multi_index::key not supported, skipping test")
+
+void test_key()
+{
+}
+#else
+
+#include <functional>
+#include <type_traits>
+
+using namespace boost::multi_index;
+
+namespace {
+
+struct base
+{
+  int       x;
+  const int cx;
+  int       f(){return x;};
+  int       cf()const{return x;};
+  int       vf()volatile{return x;};
+  int       cvf()const volatile{return x;};
+  int       rf()&{return x;};
+  int       crf()const&{return x;};
+  int       vrf()volatile&{return x;};
+  int       cvrf()const volatile&{return x;};
+  int       nef()noexcept{return x;};
+  int       cnef()const noexcept{return x;};
+  int       vnef()volatile noexcept{return x;};
+  int       cvnef()const volatile noexcept{return x;};
+  int       rnef()& noexcept{return x;};
+  int       crnef()const& noexcept{return x;};
+  int       vrnef()volatile& noexcept{return x;};
+  int       cvrnef()const volatile& noexcept{return x;};
+};
+
+int gf(const base& b){return b.x;}
+int negf(const base& b)noexcept{return b.x;}
+
+struct derived:base
+{
+  int y;
+};
+
+int gh(derived& d){return d.y;}
+int grh(std::reference_wrapper<derived>& d){return d.get().y;}
+
+} /* namespace */
+
+void test_key()
+{
+  BOOST_TEST((std::is_same<
+    key<&base::x>,member<base,int,&base::x> 
+  >::value));
+  BOOST_TEST((std::is_same<
+    key<&base::cx>,member<base,const int,&base::cx> 
+  >::value));
+  BOOST_TEST((std::is_same<
+    key<&base::f>,mem_fun<base,int,&base::f> 
+  >::value));
+  BOOST_TEST((std::is_same<
+    key<&base::cf>,const_mem_fun<base,int,&base::cf>
+  >::value));
+  BOOST_TEST((std::is_same<
+    key<&base::vf>,volatile_mem_fun<base,int,&base::vf> 
+  >::value));
+  BOOST_TEST((std::is_same<
+    key<&base::cvf>,cv_mem_fun<base,int,&base::cvf>
+  >::value));
+  BOOST_TEST((std::is_same<
+    key<&base::rf>,ref_mem_fun<base,int,&base::rf> 
+  >::value));
+  BOOST_TEST((std::is_same<
+    key<&base::crf>,cref_mem_fun<base,int,&base::crf>
+  >::value));
+  BOOST_TEST((std::is_same<
+    key<&base::vrf>,vref_mem_fun<base,int,&base::vrf> 
+  >::value));
+  BOOST_TEST((std::is_same<
+    key<&base::cvrf>,cvref_mem_fun<base,int,&base::cvrf>
+  >::value));
+  BOOST_TEST((std::is_same<
+    key<&base::nef>,mem_fun<base,int,&base::nef> 
+  >::value));
+  BOOST_TEST((std::is_same<
+    key<&base::cnef>,const_mem_fun<base,int,&base::cnef>
+  >::value));
+  BOOST_TEST((std::is_same<
+    key<&base::vnef>,volatile_mem_fun<base,int,&base::vnef> 
+  >::value));
+  BOOST_TEST((std::is_same<
+    key<&base::cvnef>,cv_mem_fun<base,int,&base::cvnef>
+  >::value));
+  BOOST_TEST((std::is_same<
+    key<&base::rnef>,ref_mem_fun<base,int,&base::rnef> 
+  >::value));
+  BOOST_TEST((std::is_same<
+    key<&base::crnef>,cref_mem_fun<base,int,&base::crnef>
+  >::value));
+  BOOST_TEST((std::is_same<
+    key<&base::vrnef>,vref_mem_fun<base,int,&base::vrnef> 
+  >::value));
+  BOOST_TEST((std::is_same<
+    key<&base::cvrnef>,cvref_mem_fun<base,int,&base::cvrnef>
+  >::value));
+  BOOST_TEST((std::is_same<
+    key<gf>,global_fun<const base&,int,gf> 
+  >::value));
+  BOOST_TEST((std::is_same<
+    key<negf>,global_fun<const base&,int,negf> 
+  >::value));
+  BOOST_TEST((std::is_same<
+    key<&base::x,&base::cx,&base::f,&base::cf,gf>,
+    composite_key<
+      base,
+      member<base,int,&base::x>,
+      member<base,const int,&base::cx>,
+      mem_fun<base,int,&base::f>,
+      const_mem_fun<base,int,&base::cf>,
+      global_fun<const base&,int,gf>
+    >
+  >::value));
+  BOOST_TEST((std::is_same<
+    key<&base::x,&derived::y>,
+    composite_key<
+      derived,
+      member<base,int,&base::x>,
+      member<derived,int,&derived::y>
+    >
+  >::value));
+  BOOST_TEST((std::is_same<
+    key<gf,gh>,
+    composite_key<
+      derived,
+      global_fun<const base&,int,gf>,
+      global_fun<derived&,int,gh>
+    >
+  >::value));
+  BOOST_TEST((std::is_same<
+    key<gf,gh,grh>,
+    composite_key<
+      std::reference_wrapper<derived>,
+      global_fun<const base&,int,gf>,
+      global_fun<derived&,int,gh>,
+      global_fun<std::reference_wrapper<derived>&,int,grh>
+    >
+  >::value));
+}
+#endif
diff --git a/src/boost/libs/multi_index/test/test_key.hpp b/src/boost/libs/multi_index/test/test_key.hpp
new file mode 100644
index 000000000..9ebe4fe66
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_key.hpp
@@ -0,0 +1,11 @@
+/* Boost.MultiIndex test for terse key specification syntax.
+ *
+ * Copyright 2003-2018 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+void test_key();
diff --git a/src/boost/libs/multi_index/test/test_key_extractors.cpp b/src/boost/libs/multi_index/test/test_key_extractors.cpp
new file mode 100644
index 000000000..31eec101f
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_key_extractors.cpp
@@ -0,0 +1,604 @@
+/* Boost.MultiIndex test for key extractors.
+ *
+ * Copyright 2003-2020 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include "test_key_extractors.hpp"
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/detail/lightweight_test.hpp>
+#include "pre_multi_index.hpp"
+#include <boost/multi_index/key_extractors.hpp>
+#include <boost/ref.hpp>
+#include <boost/scoped_ptr.hpp>
+#include <list>
+
+using namespace boost::multi_index;
+using namespace boost::tuples;
+
+struct test_class
+{
+  int       int_member;
+  const int int_cmember;
+
+  bool bool_mem_fun_const()const{return true;}
+  bool bool_mem_fun(){return false;}
+  bool bool_mem_fun_volatile()volatile{return false;}
+  bool bool_mem_fun_cv()const volatile{return true;}
+
+#if !defined(BOOST_NO_CXX11_REF_QUALIFIERS)
+
+  bool bool_mem_fun_cref()const&{return true;}
+  bool bool_mem_fun_ref()&{return false;}
+  bool bool_mem_fun_vref()volatile&{return false;}
+  bool bool_mem_fun_cvref()const volatile&{return true;}
+
+#endif
+
+  static bool bool_global_fun(test_class){return true;}
+  static bool bool_global_fun_const_ref(const test_class&){return false;}
+  static bool bool_global_fun_ref(test_class&){return true;}
+
+  test_class(int i=0):int_member(i),int_cmember(i){}
+  test_class(int i,int j):int_member(i),int_cmember(j){}
+  test_class(const test_class& x):
+    int_member(x.int_member),int_cmember(x.int_cmember){}
+
+  test_class& operator=(const test_class& x)
+  {
+    int_member=x.int_member;
+    return *this;
+  }
+
+  bool operator<(const test_class& x)const
+  {
+    if(int_member<x.int_member)return true;
+    if(x.int_member<int_member)return false;
+    return int_cmember<x.int_cmember;
+  }
+
+  bool operator==(const test_class& x)const
+  {
+    return int_member==x.int_member&&int_cmember==x.int_cmember;
+  }
+};
+
+struct test_derived_class:test_class
+{
+  test_derived_class(int i=0):test_class(i){}
+  test_derived_class(int i,int j):test_class(i,j){}
+};
+
+typedef identity<test_class>                                       idn;
+typedef identity<const test_class>                                 cidn;
+typedef BOOST_MULTI_INDEX_MEMBER(test_class,int,int_member)        key_m;
+typedef BOOST_MULTI_INDEX_MEMBER(test_class,const int,int_member)  ckey_m;
+typedef BOOST_MULTI_INDEX_MEMBER(test_class,const int,int_cmember) key_cm;
+typedef BOOST_MULTI_INDEX_MEM_FUN(test_class,bool,bool_mem_fun)    key_mf;
+typedef BOOST_MULTI_INDEX_CONST_MEM_FUN(
+          test_class,bool,bool_mem_fun_const)                      key_cmf;
+typedef volatile_mem_fun<
+          test_class,bool,&test_class::bool_mem_fun_volatile>      key_vmf;
+typedef cv_mem_fun<test_class,bool,&test_class::bool_mem_fun_cv>   key_cvmf;
+
+#if !defined(BOOST_NO_CXX11_REF_QUALIFIERS)
+
+typedef cref_mem_fun<
+          test_class,bool,&test_class::bool_mem_fun_cref>          key_crmf;
+typedef ref_mem_fun<test_class,bool,&test_class::bool_mem_fun_ref> key_rmf;
+typedef vref_mem_fun<
+          test_class,bool,&test_class::bool_mem_fun_vref>          key_vrmf;
+typedef cvref_mem_fun<
+          test_class,bool,&test_class::bool_mem_fun_cvref>         key_cvrmf;
+
+#endif
+
+typedef global_fun<test_class,bool,&test_class::bool_global_fun>   key_gf;
+typedef global_fun<
+          const test_class&,bool,
+          &test_class::bool_global_fun_const_ref
+        >                                                          key_gcrf;
+typedef global_fun<
+          test_class&,bool,
+          &test_class::bool_global_fun_ref
+        >                                                          key_grf;
+typedef composite_key<
+          test_class,
+          idn,
+          key_m,
+          key_cm,
+          key_cmf
+        >                                                          compkey;
+typedef composite_key<
+          test_class,
+          cidn,
+          ckey_m
+        >                                                          ccompkey;
+typedef composite_key<
+          boost::reference_wrapper<test_class>,
+          key_mf
+        >                                                          ccompw_key;
+
+#if !defined(BOOST_NO_SFINAE)
+/* testcases for problems with non-copyable classes reported at
+ * http://lists.boost.org/Archives/boost/2006/04/103065.php
+ */
+
+struct test_nc_class
+{
+  int       int_member;
+  const int int_cmember;
+
+  bool bool_mem_fun_const()const{return true;}
+  bool bool_mem_fun(){return false;}
+
+  static bool bool_global_fun_const_ref(const test_nc_class&){return false;}
+  static bool bool_global_fun_ref(test_nc_class&){return true;}
+
+  test_nc_class(int i=0):int_member(i),int_cmember(i){}
+  test_nc_class(int i,int j):int_member(i),int_cmember(j){}
+
+  bool operator==(const test_nc_class& x)const
+  {
+    return int_member==x.int_member&&int_cmember==x.int_cmember;
+  }
+
+private:
+  test_nc_class(const test_nc_class&);
+  test_nc_class& operator=(const test_nc_class&);
+};
+
+struct test_nc_derived_class:test_nc_class
+{
+  test_nc_derived_class(int i=0):test_nc_class(i){}
+  test_nc_derived_class(int i,int j):test_nc_class(i,j){}
+};
+
+typedef identity<test_nc_class>                                nc_idn;
+typedef identity<const test_nc_class>                          nc_cidn;
+typedef BOOST_MULTI_INDEX_MEMBER(test_nc_class,int,int_member) nc_key_m;
+typedef BOOST_MULTI_INDEX_MEMBER(
+          test_nc_class,const int,int_member)                  nc_ckey_m;
+typedef BOOST_MULTI_INDEX_CONST_MEM_FUN(
+          test_nc_class,bool,bool_mem_fun_const)               nc_key_cmf;
+typedef BOOST_MULTI_INDEX_MEM_FUN(
+          test_nc_class,bool,bool_mem_fun)                     nc_key_mf;
+typedef global_fun<
+          const test_nc_class&,bool,
+          &test_nc_class::bool_global_fun_const_ref
+        >                                                      nc_key_gcrf;
+typedef global_fun<
+          test_nc_class&,bool,
+          &test_nc_class::bool_global_fun_ref
+        >                                                      nc_key_grf;
+typedef composite_key<
+          test_nc_class,
+          nc_idn,
+          nc_key_m,
+          nc_ckey_m,
+          nc_key_cmf
+        >                                                      nc_compkey;
+#endif
+
+void test_key_extractors()
+{
+  idn        id;
+  cidn       cid;
+  key_m      k_m;
+  ckey_m     ck_m;
+  key_cm     k_cm;
+  key_cmf    k_cmf;
+  key_mf     k_mf;
+  key_vmf    k_vmf;
+  key_cvmf   k_cvmf;
+#if !defined(BOOST_NO_CXX11_REF_QUALIFIERS)
+  key_crmf   k_crmf;
+  key_rmf    k_rmf;
+  key_vrmf   k_vrmf;
+  key_cvrmf  k_cvrmf;
+#endif
+  key_gf     k_gf;
+  key_gcrf   k_gcrf;
+  key_grf    k_grf;
+  compkey    cmpk;
+  ccompkey   ccmpk;
+  ccompw_key ccmpk_w;
+
+  test_derived_class                         td(-1,0);
+  const test_derived_class&                  ctdr=td;
+
+  test_class&                                tr=td;
+  const test_class&                          ctr=tr;
+
+  test_derived_class*                        tdp=&td;
+  const test_derived_class*                  ctdp=&ctdr;
+
+  test_class*                                tp=&tr;
+  const test_class*                          ctp=&tr;
+
+  test_class**                               tpp=&tp;
+  const test_class**                         ctpp=&ctp;
+
+  boost::scoped_ptr<test_class*>             tap(new test_class*(tp));
+  boost::scoped_ptr<const test_class*>       ctap(new const test_class*(ctp));
+
+  boost::reference_wrapper<test_class>       tw(tr);
+  boost::reference_wrapper<const test_class> ctw(tr);
+
+  id(tr).int_member=0;
+  BOOST_TEST(id(tr).int_member==0);
+  BOOST_TEST(cid(tr).int_member==0);
+  BOOST_TEST(k_m(tr)==0);
+  BOOST_TEST(ck_m(tr)==0);
+  BOOST_TEST(cmpk(tr)==make_tuple(test_class(0,0),0,0,true));
+  BOOST_TEST(ccmpk(tr)==make_tuple(test_class(0,0),0));
+  BOOST_TEST(id(ctr).int_member==0);
+  BOOST_TEST(cid(ctr).int_member==0);
+  BOOST_TEST(k_m(ctr)==0);
+  BOOST_TEST(ck_m(ctr)==0);
+  BOOST_TEST(cmpk(ctr)==make_tuple(test_class(0,0),0,0,true));
+  BOOST_TEST(ccmpk(ctr)==make_tuple(test_class(0,0),0));
+
+#if !defined(BOOST_NO_SFINAE)
+  BOOST_TEST(id(td).int_member==0);
+  BOOST_TEST(cid(td).int_member==0);
+  BOOST_TEST(k_m(td)==0);
+  BOOST_TEST(ck_m(td)==0);
+  BOOST_TEST(cmpk(td)==make_tuple(test_class(0,0),0,0,true));
+  BOOST_TEST(ccmpk(td)==make_tuple(test_class(0,0),0));
+  BOOST_TEST(id(ctdr).int_member==0);
+  BOOST_TEST(cid(ctdr).int_member==0);
+  BOOST_TEST(k_m(ctdr)==0);
+  BOOST_TEST(ck_m(ctdr)==0);
+  BOOST_TEST(cmpk(ctdr)==make_tuple(test_class(0,0),0,0,true));
+  BOOST_TEST(ccmpk(ctdr)==make_tuple(test_class(0,0),0));
+#endif
+
+  k_m(tr)=1;
+  BOOST_TEST(id(tp).int_member==1);
+  BOOST_TEST(cid(tp).int_member==1);
+  BOOST_TEST(k_m(tp)==1);
+  BOOST_TEST(ck_m(tp)==1);
+  BOOST_TEST(cmpk(tp)==make_tuple(test_class(1,0),1,0,true));
+  BOOST_TEST(ccmpk(tp)==make_tuple(test_class(1,0),1));
+  BOOST_TEST(cid(ctp).int_member==1);
+  BOOST_TEST(ck_m(ctp)==1);
+  BOOST_TEST(cmpk(ctp)==make_tuple(test_class(1,0),1,0,true));
+  BOOST_TEST(ccmpk(ctp)==make_tuple(test_class(1,0),1));
+
+#if !defined(BOOST_NO_SFINAE)
+  BOOST_TEST(id(tdp).int_member==1);
+  BOOST_TEST(cid(tdp).int_member==1);
+  BOOST_TEST(k_m(tdp)==1);
+  BOOST_TEST(ck_m(tdp)==1);
+  BOOST_TEST(cmpk(tdp)==make_tuple(test_class(1,0),1,0,true));
+  BOOST_TEST(ccmpk(tdp)==make_tuple(test_class(1,0),1));
+  BOOST_TEST(cid(ctdp).int_member==1);
+  BOOST_TEST(ck_m(ctdp)==1);
+  BOOST_TEST(cmpk(ctdp)==make_tuple(test_class(1,0),1,0,true));
+  BOOST_TEST(ccmpk(ctdp)==make_tuple(test_class(1,0),1));
+#endif
+
+  k_m(tp)=2;
+  BOOST_TEST(id(tpp).int_member==2);
+  BOOST_TEST(cid(tpp).int_member==2);
+  BOOST_TEST(k_m(tpp)==2);
+  BOOST_TEST(ck_m(tpp)==2);
+  BOOST_TEST(cmpk(tpp)==make_tuple(test_class(2,0),2,0,true));
+  BOOST_TEST(ccmpk(tpp)==make_tuple(test_class(2,0),2));
+  BOOST_TEST(cid(ctpp).int_member==2);
+  BOOST_TEST(ck_m(ctpp)==2);
+  BOOST_TEST(cmpk(ctpp)==make_tuple(test_class(2,0),2,0,true));
+  BOOST_TEST(ccmpk(ctpp)==make_tuple(test_class(2,0),2));
+
+  k_m(tpp)=3;
+  BOOST_TEST(id(tap).int_member==3);
+  BOOST_TEST(cid(tap).int_member==3);
+  BOOST_TEST(k_m(tap)==3);
+  BOOST_TEST(ck_m(tap)==3);
+  BOOST_TEST(cmpk(tap)==make_tuple(test_class(3,0),3,0,true));
+  BOOST_TEST(ccmpk(tap)==make_tuple(test_class(3,0),3));
+  BOOST_TEST(cid(ctap).int_member==3);
+  BOOST_TEST(ck_m(ctap)==3);
+  BOOST_TEST(cmpk(ctap)==make_tuple(test_class(3,0),3,0,true));
+  BOOST_TEST(ccmpk(ctap)==make_tuple(test_class(3,0),3));
+
+  k_m(tap)=4;
+  BOOST_TEST(id(tw).int_member==4);
+  BOOST_TEST(cid(tw).int_member==4);
+  BOOST_TEST(k_m(tw)==4);
+  BOOST_TEST(ck_m(tw)==4);
+  BOOST_TEST(cmpk(tw)==make_tuple(test_class(4,0),4,0,true));
+  BOOST_TEST(ccmpk(tw)==make_tuple(test_class(4,0),4));
+
+  k_m(tw)=5;
+  BOOST_TEST(id(ctw).int_member==5);
+  BOOST_TEST(cid(ctw).int_member==5);
+  BOOST_TEST(k_m(ctw)==5);
+  BOOST_TEST(ck_m(ctw)==5);
+  BOOST_TEST(cmpk(ctw)==make_tuple(test_class(5,0),5,0,true));
+  BOOST_TEST(ccmpk(ctw)==make_tuple(test_class(5,0),5));
+
+  BOOST_TEST(k_cm(tr)==0);
+  BOOST_TEST(k_cm(ctr)==0);
+
+#if !defined(BOOST_NO_SFINAE)
+  BOOST_TEST(k_cm(td)==0);
+  BOOST_TEST(k_cm(ctdr)==0);
+#endif
+
+  BOOST_TEST(k_cm(tp)==0);
+  BOOST_TEST(k_cm(ctp)==0);
+
+#if !defined(BOOST_NO_SFINAE)
+  BOOST_TEST(k_cm(tdp)==0);
+  BOOST_TEST(k_cm(ctdp)==0);
+#endif
+  
+  BOOST_TEST(k_cm(tpp)==0);
+  BOOST_TEST(k_cm(ctpp)==0);
+  BOOST_TEST(k_cm(tap)==0);
+  BOOST_TEST(k_cm(ctap)==0);
+
+  BOOST_TEST(k_cm(tw)==0);
+  BOOST_TEST(k_cm(ctw)==0);
+
+  BOOST_TEST(k_cmf(tr));
+  BOOST_TEST(k_cmf(ctr));
+  BOOST_TEST(k_cvmf(tr));
+  BOOST_TEST(k_cvmf(ctr));
+
+#if !defined(BOOST_NO_CXX11_REF_QUALIFIERS)
+  BOOST_TEST(k_crmf(tr));
+  BOOST_TEST(k_crmf(ctr));
+  BOOST_TEST(k_cvrmf(tr));
+  BOOST_TEST(k_cvrmf(ctr));
+#endif
+
+#if !defined(BOOST_NO_SFINAE)
+  BOOST_TEST(k_cmf(td));
+  BOOST_TEST(k_cmf(ctdr));
+  BOOST_TEST(k_cvmf(td));
+  BOOST_TEST(k_cvmf(ctdr));
+
+#if !defined(BOOST_NO_CXX11_REF_QUALIFIERS)
+  BOOST_TEST(k_crmf(td));
+  BOOST_TEST(k_crmf(ctdr));
+  BOOST_TEST(k_cvrmf(td));
+  BOOST_TEST(k_cvrmf(ctdr));
+#endif
+#endif
+
+  BOOST_TEST(k_cmf(tp));
+  BOOST_TEST(k_cmf(ctp));
+  BOOST_TEST(k_cvmf(tp));
+  BOOST_TEST(k_cvmf(ctp));
+
+#if !defined(BOOST_NO_CXX11_REF_QUALIFIERS)
+  BOOST_TEST(k_crmf(tp));
+  BOOST_TEST(k_crmf(ctp));
+  BOOST_TEST(k_cvrmf(tp));
+  BOOST_TEST(k_cvrmf(ctp));
+#endif
+
+#if !defined(BOOST_NO_SFINAE)
+  BOOST_TEST(k_cmf(tdp));
+  BOOST_TEST(k_cmf(ctdp));
+  BOOST_TEST(k_cvmf(tdp));
+  BOOST_TEST(k_cvmf(ctdp));
+
+#if !defined(BOOST_NO_CXX11_REF_QUALIFIERS)
+  BOOST_TEST(k_crmf(tdp));
+  BOOST_TEST(k_crmf(ctdp));
+  BOOST_TEST(k_cvrmf(tdp));
+  BOOST_TEST(k_cvrmf(ctdp));
+#endif
+#endif
+
+  BOOST_TEST(k_cmf(tpp));
+  BOOST_TEST(k_cmf(ctpp));
+  BOOST_TEST(k_cmf(tap));
+  BOOST_TEST(k_cmf(ctap));
+  BOOST_TEST(k_cvmf(tpp));
+  BOOST_TEST(k_cvmf(ctpp));
+  BOOST_TEST(k_cvmf(tap));
+  BOOST_TEST(k_cvmf(ctap));
+
+#if !defined(BOOST_NO_CXX11_REF_QUALIFIERS)
+  BOOST_TEST(k_crmf(tpp));
+  BOOST_TEST(k_crmf(ctpp));
+  BOOST_TEST(k_crmf(tap));
+  BOOST_TEST(k_crmf(ctap));
+  BOOST_TEST(k_cvrmf(tpp));
+  BOOST_TEST(k_cvrmf(ctpp));
+  BOOST_TEST(k_cvrmf(tap));
+  BOOST_TEST(k_cvrmf(ctap));
+#endif
+
+  BOOST_TEST(k_cmf(tw));
+  BOOST_TEST(k_cmf(ctw));
+  BOOST_TEST(k_cvmf(tw));
+  BOOST_TEST(k_cvmf(ctw));
+
+#if !defined(BOOST_NO_CXX11_REF_QUALIFIERS)
+  BOOST_TEST(k_crmf(tw));
+  BOOST_TEST(k_crmf(ctw));
+  BOOST_TEST(k_cvrmf(tw));
+  BOOST_TEST(k_cvrmf(ctw));
+#endif
+
+  BOOST_TEST(!k_mf(tr));
+  BOOST_TEST(!k_vmf(tr));
+
+#if !defined(BOOST_NO_CXX11_REF_QUALIFIERS)
+  BOOST_TEST(!k_rmf(tr));
+  BOOST_TEST(!k_vrmf(tr));
+#endif
+
+#if !defined(BOOST_NO_SFINAE)
+  BOOST_TEST(!k_mf(td));
+  BOOST_TEST(!k_vmf(td));
+
+#if !defined(BOOST_NO_CXX11_REF_QUALIFIERS)
+  BOOST_TEST(!k_rmf(td));
+  BOOST_TEST(!k_vrmf(td));
+#endif
+#endif
+
+  BOOST_TEST(!k_mf(tp));
+  BOOST_TEST(!k_vmf(tp));
+
+#if !defined(BOOST_NO_CXX11_REF_QUALIFIERS)
+  BOOST_TEST(!k_rmf(tp));
+  BOOST_TEST(!k_vrmf(tp));
+#endif
+
+#if !defined(BOOST_NO_SFINAE)
+  BOOST_TEST(!k_mf(tdp));
+  BOOST_TEST(!k_vmf(tdp));
+
+#if !defined(BOOST_NO_CXX11_REF_QUALIFIERS)
+  BOOST_TEST(!k_rmf(tdp));
+  BOOST_TEST(!k_vrmf(tdp));
+#endif
+#endif
+
+  BOOST_TEST(!k_mf(tpp));
+  BOOST_TEST(!k_mf(tap));
+  BOOST_TEST(!k_mf(tw));
+  BOOST_TEST(!k_vmf(tpp));
+  BOOST_TEST(!k_vmf(tap));
+  BOOST_TEST(!k_vmf(tw));
+
+#if !defined(BOOST_NO_CXX11_REF_QUALIFIERS)
+  BOOST_TEST(!k_rmf(tpp));
+  BOOST_TEST(!k_rmf(tap));
+  BOOST_TEST(!k_rmf(tw));
+  BOOST_TEST(!k_vrmf(tpp));
+  BOOST_TEST(!k_vrmf(tap));
+  BOOST_TEST(!k_vrmf(tw));
+#endif
+
+  BOOST_TEST(k_gf(tr));
+  BOOST_TEST(k_gf(ctr));
+
+#if !defined(BOOST_NO_SFINAE)
+  BOOST_TEST(k_gf(td));
+  BOOST_TEST(k_gf(ctdr));
+#endif
+
+  BOOST_TEST(k_gf(tp));
+  BOOST_TEST(k_gf(ctp));
+
+#if !defined(BOOST_NO_SFINAE)
+  BOOST_TEST(k_gf(tdp));
+  BOOST_TEST(k_gf(ctdp));
+#endif
+
+  BOOST_TEST(k_gf(tpp));
+  BOOST_TEST(k_gf(ctpp));
+  BOOST_TEST(k_gf(tap));
+  BOOST_TEST(k_gf(ctap));
+
+  BOOST_TEST(k_gf(tw));
+  BOOST_TEST(k_gf(ctw));
+  
+  BOOST_TEST(!k_gcrf(tr));
+  BOOST_TEST(!k_gcrf(ctr));
+
+#if !defined(BOOST_NO_SFINAE)
+  BOOST_TEST(!k_gcrf(td));
+  BOOST_TEST(!k_gcrf(ctdr));
+#endif
+
+  BOOST_TEST(!k_gcrf(tp));
+  BOOST_TEST(!k_gcrf(ctp));
+
+#if !defined(BOOST_NO_SFINAE)
+  BOOST_TEST(!k_gcrf(tdp));
+  BOOST_TEST(!k_gcrf(ctdp));
+#endif
+
+  BOOST_TEST(!k_gcrf(tpp));
+  BOOST_TEST(!k_gcrf(ctpp));
+  BOOST_TEST(!k_gcrf(tap));
+  BOOST_TEST(!k_gcrf(ctap));
+
+  BOOST_TEST(!k_gcrf(tw));
+  BOOST_TEST(!k_gcrf(ctw));
+
+  BOOST_TEST(k_grf(tr));
+
+#if !defined(BOOST_NO_SFINAE)
+  BOOST_TEST(k_grf(td));
+#endif
+
+  BOOST_TEST(k_grf(tp));
+
+#if !defined(BOOST_NO_SFINAE)
+  BOOST_TEST(k_grf(tdp));
+#endif
+
+  BOOST_TEST(k_grf(tpp));
+  BOOST_TEST(k_grf(tap));
+  BOOST_TEST(k_grf(tw));
+
+  BOOST_TEST(ccmpk_w(tw)==make_tuple(false));
+
+#if !defined(BOOST_NO_SFINAE)
+/* testcases for problems with non-copyable classes reported at
+ * http://lists.boost.org/Archives/boost/2006/04/103065.php
+ */
+
+  nc_idn        nc_id;
+  nc_cidn       nc_cid;
+  nc_key_m      nc_k_m;
+  nc_ckey_m     nc_ck_m;
+  nc_key_cmf    nc_k_cmf;
+  nc_key_mf     nc_k_mf;
+  nc_key_gcrf   nc_k_gcrf;
+  nc_key_grf    nc_k_grf;
+  nc_compkey    nc_cmpk;
+
+  test_nc_derived_class nc_td(-1,0);
+
+  nc_id(nc_td).int_member=0;
+  BOOST_TEST(nc_id(nc_td).int_member==0);
+  BOOST_TEST(nc_cid(nc_td).int_member==0);
+
+  nc_k_m(&nc_td)=1;
+  BOOST_TEST(nc_k_m(&nc_td)==1);
+  BOOST_TEST(nc_ck_m(&nc_td)==1);
+
+  BOOST_TEST(nc_k_cmf(nc_td));
+  BOOST_TEST(!nc_k_mf(nc_td));
+
+  BOOST_TEST(!nc_k_gcrf(nc_td));
+  BOOST_TEST(nc_k_grf(nc_td));
+
+  test_nc_class nc_t(1,0);
+  BOOST_TEST(nc_cmpk(nc_td)==make_tuple(boost::cref(nc_t),1,1,true));
+#endif
+  
+  std::list<test_class> tl;
+  for(int i=0;i<20;++i)tl.push_back(test_class(i));
+
+  int j=0;
+  for(std::list<test_class>::iterator it=tl.begin();it!=tl.end();++it){
+    BOOST_TEST(k_m(it)==j);
+    BOOST_TEST(k_cm(it)==j);
+    BOOST_TEST(k_cmf(it));
+    BOOST_TEST(!k_mf(it));
+    BOOST_TEST(k_gf(it));
+    BOOST_TEST(!k_gcrf(it));
+    BOOST_TEST(k_grf(it));
+    BOOST_TEST(cmpk(it)==make_tuple(test_class(j),j,j,true));
+    BOOST_TEST(ccmpk(it)==make_tuple(test_class(j),j));
+    ++j;
+  }
+}
diff --git a/src/boost/libs/multi_index/test/test_key_extractors.hpp b/src/boost/libs/multi_index/test/test_key_extractors.hpp
new file mode 100644
index 000000000..cee8ac099
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_key_extractors.hpp
@@ -0,0 +1,11 @@
+/* Boost.MultiIndex test for key extractors.
+ *
+ * Copyright 2003-2008 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+void test_key_extractors();
diff --git a/src/boost/libs/multi_index/test/test_key_extractors_main.cpp b/src/boost/libs/multi_index/test/test_key_extractors_main.cpp
new file mode 100644
index 000000000..3887daff9
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_key_extractors_main.cpp
@@ -0,0 +1,18 @@
+/* Boost.MultiIndex test for key extractors.
+ *
+ * Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include <boost/detail/lightweight_test.hpp>
+#include "test_key_extractors.hpp"
+
+int main()
+{
+  test_key_extractors();
+  return boost::report_errors();
+}
diff --git a/src/boost/libs/multi_index/test/test_key_main.cpp b/src/boost/libs/multi_index/test/test_key_main.cpp
new file mode 100644
index 000000000..a4d012a85
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_key_main.cpp
@@ -0,0 +1,18 @@
+/* Boost.MultiIndex test for terse key specification syntax.
+ *
+ * Copyright 2003-2018 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include <boost/detail/lightweight_test.hpp>
+#include "test_key.hpp"
+
+int main()
+{
+  test_key();
+  return boost::report_errors();
+}
diff --git a/src/boost/libs/multi_index/test/test_list_ops.cpp b/src/boost/libs/multi_index/test/test_list_ops.cpp
new file mode 100644
index 000000000..e67fda7f8
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_list_ops.cpp
@@ -0,0 +1,275 @@
+/* Boost.MultiIndex test for standard list operations.
+ *
+ * Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include "test_list_ops.hpp"
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <algorithm>
+#include <vector>
+#include <boost/detail/lightweight_test.hpp>
+#include "pre_multi_index.hpp"
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/identity.hpp>
+#include <boost/multi_index/ordered_index.hpp>
+#include <boost/multi_index/sequenced_index.hpp>
+#include <boost/multi_index/random_access_index.hpp>
+#include <boost/preprocessor/seq/enum.hpp>
+
+using namespace boost::multi_index;
+
+#undef CHECK_EQUAL
+#define CHECK_EQUAL(p,check_seq) \
+{\
+  int v[]={BOOST_PP_SEQ_ENUM(check_seq)};\
+  std::size_t size_v=sizeof(v)/sizeof(int);\
+  BOOST_TEST(std::size_t(std::distance((p).begin(),(p).end()))==size_v);\
+  BOOST_TEST(std::equal((p).begin(),(p).end(),&v[0]));\
+}
+
+#undef CHECK_VOID_RANGE
+#define CHECK_VOID_RANGE(p) BOOST_TEST((p).first==(p).second)
+
+struct is_even
+{
+  bool operator()(int x)const{return x%2==0;}
+};
+
+template <int m>
+struct same_integral_div
+{
+  bool operator()(int x,int y)const{return (x/m)==(y/m);}
+};
+
+template <typename Container,typename Compare>
+bool is_sorted(
+  const Container& c,const Compare& comp=Compare())
+{
+  if(c.empty())return true;
+
+  typedef typename Container::const_iterator const_iterator;
+  for(const_iterator it(c.begin());;){
+    const_iterator it2=it;
+    ++it2;
+    if(it2==c.end())return true;
+    if(comp(*it2,*it))return false;
+    it=it2;
+  }
+}
+
+#if BOOST_WORKAROUND(__MWERKS__,<=0x3003)
+/* The "ISO C++ Template Parser" option makes CW8.3 incorrectly fail at
+ * expressions of the form sizeof(x) where x is an array local to a
+ * template function.
+ */
+
+#pragma parse_func_templ off
+#endif
+
+template<typename Sequence>
+static void test_list_ops_unique_seq()
+{
+  typedef typename nth_index<Sequence,1>::type sequenced_index;
+
+  Sequence         ss,ss2;
+  sequenced_index &si=get<1>(ss),&si2=get<1>(ss2);
+
+  si.push_front(0);                       /* 0        */
+  si.push_front(4);                       /* 40       */
+  ss.insert(2);                           /* 402      */
+  ss.insert(5);                           /* 4025     */
+  si.push_front(3);                       /* 34025    */
+  si.push_back(6);                        /* 340256   */
+  si.push_back(1);                        /* 3402561  */
+  si.insert(project<1>(ss,ss.find(2)),8); /* 34082561 */
+  si2=si;
+
+  CHECK_EQUAL(si,(3)(4)(0)(8)(2)(5)(6)(1));
+
+  si.remove(8);
+  CHECK_EQUAL(si,(3)(4)(0)(2)(5)(6)(1));
+
+  si.remove_if(is_even());
+
+  CHECK_EQUAL(si,(3)(5)(1));
+
+  si.splice(si.end(),si2);
+  CHECK_EQUAL(si,(3)(5)(1)(4)(0)(8)(2)(6));
+  CHECK_EQUAL(si2,(3)(5)(1));
+
+  si.splice(project<1>(ss,ss.find(4)),si,project<1>(ss,ss.find(8)));
+  CHECK_EQUAL(si,(3)(5)(1)(8)(4)(0)(2)(6));
+  si2.clear();
+  si2.splice(si2.begin(),si,si.begin());
+
+  si.splice(si.end(),si2,si2.begin());
+  CHECK_EQUAL(si,(5)(1)(8)(4)(0)(2)(6)(3));
+  BOOST_TEST(si2.empty());
+
+  si2.splice(si2.end(),si,project<1>(ss,ss.find(0)),project<1>(ss,ss.find(6)));
+  CHECK_EQUAL(si,(5)(1)(8)(4)(6)(3));
+  CHECK_EQUAL(si2,(0)(2));
+
+  si.splice(si.begin(),si,si.begin(),si.begin());
+  CHECK_EQUAL(si,(5)(1)(8)(4)(6)(3));
+
+  si.splice(project<1>(ss,ss.find(8)),si,project<1>(ss,ss.find(4)),si.end());
+  CHECK_EQUAL(si,(5)(1)(4)(6)(3)(8));
+
+  si.sort();
+  si2.sort();
+  BOOST_TEST(is_sorted(si,std::less<int>()));
+  BOOST_TEST(is_sorted(si2,std::less<int>()));
+
+  si.merge(si2);
+  BOOST_TEST(is_sorted(si,std::less<int>()));
+  BOOST_TEST(si2.empty());
+
+  {
+    Sequence         ss3(ss);
+    sequenced_index &si3=get<1>(ss3);
+
+    si3.sort(std::greater<int>());
+    si.reverse();
+    BOOST_TEST(si==si3);
+  }
+
+  si2.splice(si2.end(),si,project<1>(ss,ss.find(6)),project<1>(ss,ss.find(3)));
+  CHECK_EQUAL(si2,(6)(5)(4));
+
+  si.merge(si2,std::greater<int>());
+  BOOST_TEST(is_sorted(si,std::greater<int>()));
+  BOOST_TEST(si2.empty());
+
+  /* testcase for bug reported at
+   * https://svn.boost.org/trac/boost/ticket/3076
+   */
+  {
+    Sequence         ss3;
+    sequenced_index &si3=get<1>(ss3);
+    si3.sort();
+  }
+}
+
+template<typename Sequence>
+static void test_list_ops_non_unique_seq()
+{
+  typedef typename Sequence::iterator iterator;
+
+  Sequence ss;
+  for(int i=0;i<10;++i){
+    ss.push_back(i);
+    ss.push_back(i);
+    ss.push_front(i);
+    ss.push_front(i);
+  } /* 9988776655443322110000112233445566778899 */
+
+  ss.unique();
+  CHECK_EQUAL(
+    ss,
+    (9)(8)(7)(6)(5)(4)(3)(2)(1)(0)
+    (1)(2)(3)(4)(5)(6)(7)(8)(9));
+
+  iterator it=ss.begin();
+  for(int j=0;j<9;++j,++it){} /* it points to o */
+
+  Sequence ss2;
+  ss2.splice(ss2.end(),ss,ss.begin(),it);
+  ss2.reverse();
+  ss.merge(ss2);
+  CHECK_EQUAL(
+    ss,
+    (0)(1)(1)(2)(2)(3)(3)(4)(4)(5)(5)
+    (6)(6)(7)(7)(8)(8)(9)(9));
+
+  ss.unique(same_integral_div<3>());
+  CHECK_EQUAL(ss,(0)(3)(6)(9));
+
+  ss.unique(same_integral_div<1>());
+  CHECK_EQUAL(ss,(0)(3)(6)(9));
+
+  /* testcases for bugs reported at
+   * http://lists.boost.org/boost-users/2006/09/22604.php
+   */
+  {
+    Sequence ss_,ss2_;
+    ss_.push_back(0);
+    ss2_.push_back(0);
+    ss_.splice(ss_.end(),ss2_,ss2_.begin());
+    CHECK_EQUAL(ss_,(0)(0));
+    BOOST_TEST(ss2_.empty());
+
+    ss_.clear();
+    ss2_.clear();
+    ss_.push_back(0);
+    ss2_.push_back(0);
+    ss_.splice(ss_.end(),ss2_,ss2_.begin(),ss2_.end());
+    CHECK_EQUAL(ss_,(0)(0));
+    BOOST_TEST(ss2_.empty());
+
+    ss_.clear();
+    ss2_.clear();
+    ss_.push_back(0);
+    ss2_.push_back(0);
+    ss_.merge(ss2_);
+    CHECK_EQUAL(ss_,(0)(0));
+    BOOST_TEST(ss2_.empty());
+
+    typedef typename Sequence::value_type value_type;
+    ss_.clear();
+    ss2_.clear();
+    ss_.push_back(0);
+    ss2_.push_back(0);
+    ss_.merge(ss2_,std::less<value_type>());
+    CHECK_EQUAL(ss_,(0)(0));
+    BOOST_TEST(ss2_.empty());
+  }
+}
+
+#if BOOST_WORKAROUND(__MWERKS__,<=0x3003)
+#pragma parse_func_templ reset
+#endif
+
+void test_list_ops()
+{
+  typedef multi_index_container<
+    int,
+    indexed_by<
+      ordered_unique<identity<int> >,
+      sequenced<>
+    >
+  > sequenced_set;
+  
+  test_list_ops_unique_seq<sequenced_set>();
+
+
+  typedef multi_index_container<
+    int,
+    indexed_by<
+      ordered_unique<identity<int> >,
+      random_access<>
+    >
+  > random_access_set;
+  
+  test_list_ops_unique_seq<random_access_set>();
+
+  typedef multi_index_container<
+    int,
+    indexed_by<sequenced<> >
+  > int_list;
+
+  test_list_ops_non_unique_seq<int_list>();
+
+  typedef multi_index_container<
+    int,
+    indexed_by<random_access<> >
+  > int_vector;
+
+  test_list_ops_non_unique_seq<int_vector>();
+}
diff --git a/src/boost/libs/multi_index/test/test_list_ops.hpp b/src/boost/libs/multi_index/test/test_list_ops.hpp
new file mode 100644
index 000000000..4547c88a6
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_list_ops.hpp
@@ -0,0 +1,11 @@
+/* Boost.MultiIndex test for standard list operations.
+ *
+ * Copyright 2003-2008 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+void test_list_ops();
diff --git a/src/boost/libs/multi_index/test/test_list_ops_main.cpp b/src/boost/libs/multi_index/test/test_list_ops_main.cpp
new file mode 100644
index 000000000..ce79320a0
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_list_ops_main.cpp
@@ -0,0 +1,18 @@
+/* Boost.MultiIndex test for standard list operations.
+ *
+ * Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include <boost/detail/lightweight_test.hpp>
+#include "test_list_ops.hpp"
+
+int main()
+{
+  test_list_ops();
+  return boost::report_errors();
+}
diff --git a/src/boost/libs/multi_index/test/test_modifiers.cpp b/src/boost/libs/multi_index/test/test_modifiers.cpp
new file mode 100644
index 000000000..ea677ae15
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_modifiers.cpp
@@ -0,0 +1,581 @@
+/* Boost.MultiIndex test for modifier memfuns.
+ *
+ * Copyright 2003-2018 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include "test_modifiers.hpp"
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/enable_shared_from_this.hpp>
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/move/core.hpp>
+#include <boost/move/utility_core.hpp>
+#include <boost/next_prior.hpp>
+#include <boost/shared_ptr.hpp>
+#include <iterator>
+#include <vector>
+#include "pre_multi_index.hpp"
+#include "employee.hpp"
+
+using namespace boost::multi_index;
+
+struct non_copyable_int
+{
+  explicit non_copyable_int(int n_):n(n_){}
+  non_copyable_int(BOOST_RV_REF(non_copyable_int) x):n(x.n){x.n=0;} 
+  non_copyable_int& operator=(BOOST_RV_REF(non_copyable_int) x)
+  {
+    n=x.n;
+    x.n=0;
+    return *this;
+  } 
+
+  int n;
+private:
+  BOOST_MOVABLE_BUT_NOT_COPYABLE(non_copyable_int)
+};
+
+class always_one
+{
+public:
+  always_one():n(1){}
+  ~always_one(){n=0;}
+
+  int get()const{return n;}
+
+private:
+  int n;
+};
+
+inline bool operator==(const always_one& x,const always_one& y)
+{
+  return x.get()==y.get();
+}
+
+#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
+namespace boost{
+#endif
+
+inline std::size_t hash_value(const always_one& x)
+{
+  return static_cast<std::size_t>(x.get());
+}
+
+#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
+} /* namespace boost */
+#endif
+
+class linked_object
+{
+  struct impl:boost::enable_shared_from_this<impl>
+  {
+    typedef boost::shared_ptr<const impl> ptr;
+
+    impl(int n_,ptr next_=ptr()):n(n_),next(next_){}
+
+    int n;
+    ptr next;
+  };
+
+  typedef multi_index_container<
+    impl,
+    indexed_by<
+
+#if BOOST_WORKAROUND(__IBMCPP__,BOOST_TESTED_AT(1010))
+      ordered_unique<member<impl,int,&linked_object::impl::n> >,
+      hashed_non_unique<member<impl,int,&linked_object::impl::n> >,
+#else
+      ordered_unique<member<impl,int,&impl::n> >,
+      hashed_non_unique<member<impl,int,&impl::n> >,
+#endif
+
+      sequenced<>,
+      random_access<>
+    >
+  > impl_repository_t;
+
+  static impl_repository_t impl_repository;
+
+public:
+  linked_object(int n):pimpl(init(impl(n))){}
+  linked_object(int n,const linked_object& x):pimpl(init(impl(n,x.pimpl))){}
+
+private:
+  impl::ptr init(const impl& x)
+  {
+    std::pair<impl_repository_t::iterator,bool> p=impl_repository.insert(x);
+    if(p.second)return impl::ptr(&*p.first,&erase_impl);
+    else        return p.first->shared_from_this();
+  }
+
+  static void erase_impl(const impl* p)
+  {
+    impl_repository.erase(p->n);
+  }
+
+  impl::ptr pimpl;
+};
+
+linked_object::impl_repository_t linked_object::impl_repository;
+
+struct tempvalue_iterator:
+  boost::iterator_facade<
+    tempvalue_iterator,int,boost::forward_traversal_tag,int>
+{
+  tempvalue_iterator(int n_):n(n_){}
+  
+  void increment(){++n;}
+  bool equal(const tempvalue_iterator& x)const{return n==x.n;}
+  int dereference()const{return n;}
+  
+  int n;
+};
+
+struct change_int
+{
+  change_int(int n):n(n){}
+
+  void operator()(int& x)const{x=n;}
+
+  int n;
+};
+
+#if !(defined BOOST_NO_EXCEPTIONS)
+struct change_int_and_throw
+{
+  change_int_and_throw(int n):n(n){}
+
+  void operator()(int& x)const{x=n;throw 0;}
+
+  int n;
+};
+#endif
+
+void test_modifiers()
+{
+  employee_set              es;
+  employee_set_by_name&     i1=get<name>(es);
+  employee_set_by_age&      i2=get<age>(es);
+  employee_set_as_inserted& i3=get<as_inserted>(es);
+  employee_set_by_ssn&      i4=get<ssn>(es);
+  employee_set_randomly&    i5=get<randomly>(es);
+
+  es.insert(employee(0,"Joe",31,1123));
+  BOOST_TEST(es.emplace(0,"Joe",31,1123).second==false);
+  BOOST_TEST(i1.insert(employee(0,"Joe Jr.",5,2563)).second==false);
+  BOOST_TEST(i2.emplace_hint(i2.end(),1,"Victor",5,1123)->name!="Victor");
+  BOOST_TEST(i3.insert(i3.begin(),employee(1,"Victor",5,1123)).second
+                ==false);
+  BOOST_TEST(i3.push_front(employee(0,"Joe Jr.",5,2563)).second==false);
+  BOOST_TEST(i3.push_back(employee(0,"Joe Jr.",5,2563)).second==false);
+  BOOST_TEST(i5.emplace_front(1,"Victor",5,1123).second==false);
+  BOOST_TEST(i5.emplace_back(1,"Victor",5,1123).second==false);
+
+  employee_set_by_name::iterator it1=i1.find("Joe");
+  i1.insert(it1,employee(1,"Joe Jr.",5,2563));
+  BOOST_TEST(es.size()==2);
+
+  employee_set_by_age::iterator it2=i2.find(31);
+  i2.insert(it2,employee(2,"Grandda Joe",64,7881));
+  BOOST_TEST(es.size()==3);
+
+  employee_set_as_inserted::iterator it3=i3.begin();
+  i3.insert(it3,100,employee(3,"Judy",39,6201));
+  BOOST_TEST((--it3)->ssn==6201);
+  BOOST_TEST(es.size()==4);
+
+  employee_set_randomly::iterator it5=i5.begin();
+  i5.insert(it5,100,employee(4,"Jill",52,3379));
+  BOOST_TEST(i5.begin()->age==52);
+  BOOST_TEST(es.size()==5);
+
+  es.erase(employee(1,"Joe Jr.",5,2563));
+  BOOST_TEST(i3.size()==4&&i5.size()==4);
+
+  BOOST_TEST(i1.erase("Judy")==1);
+  BOOST_TEST(es.size()==3&&i2.size()==3);
+
+  BOOST_TEST(i2.erase(it2)->age==52);
+  BOOST_TEST(i3.size()==2&&i4.size()==2);
+
+  i3.pop_front();
+  BOOST_TEST(i1.size()==1&&i2.size()==1);
+
+  i5.erase(i5.begin(),i5.end());
+  BOOST_TEST(es.size()==0&&i3.size()==0);
+
+  i5.emplace(i5.end(),0,"Joe",31,1123);
+  BOOST_TEST(i1.erase(i1.begin())==i1.end());
+  BOOST_TEST(i1.size()==0);
+
+  i1.emplace(0,"Joe",31,1123);
+  i3.emplace(i3.begin(),1,"Jack",31,5032);
+  i4.emplace_hint(i4.end(),2,"James",31,3847);
+  BOOST_TEST(i2.erase(31)==3);
+  BOOST_TEST(i2.size()==0);
+
+  i3.emplace_front(1,"Jack",31,5032);
+  i3.emplace_back(0,"Joe",31,1123);
+  BOOST_TEST(i3.front()==employee(1,"Jack",31,5032));
+  BOOST_TEST(i3.back()==employee(0,"Joe",31,1123));
+
+  i3.pop_back();
+  BOOST_TEST(i3.back()==employee(1,"Jack",31,5032));
+  BOOST_TEST(es.size()==1);
+
+  i3.pop_front();
+  BOOST_TEST(es.size()==0);
+
+  i5.push_back(employee(1,"Jack",31,5032));
+  i5.push_front(employee(0,"Joe",31,1123));
+  i5.insert(i5.end()-1,employee(2,"Grandda Joe",64,7881));
+  BOOST_TEST(i5.back()==employee(1,"Jack",31,5032));
+  BOOST_TEST(i5.front()==employee(0,"Joe",31,1123));
+  BOOST_TEST(i5[0]==i5.front()&&i5.at(0)==i5.front());
+  BOOST_TEST(i5[i5.size()-1]==i5.back()&&i5.at(i5.size()-1)==i5.back());
+
+  i5.pop_front();
+  BOOST_TEST(i5.back()==employee(1,"Jack",31,5032));
+  BOOST_TEST(i5.front()==employee(2,"Grandda Joe",64,7881));
+  BOOST_TEST(es.size()==2);
+
+  i5.pop_back();
+  BOOST_TEST(i5.back()==employee(2,"Grandda Joe",64,7881));
+  BOOST_TEST(i5.front()==i5.front());
+  BOOST_TEST(es.size()==1);
+
+  i5.erase(i5.begin());
+  BOOST_TEST(es.size()==0);
+  
+  std::vector<employee> ve;
+  ve.push_back(employee(3,"Anna",31,5388));
+  ve.push_back(employee(1,"Rachel",27,9012));
+  ve.push_back(employee(2,"Agatha",40,1520));
+
+  i1.insert(ve.begin(),ve.end());
+  BOOST_TEST(i2.size()==3);
+
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+  i1.insert({{4,"Vanessa",20,9236},{5,"Penelope",55,2358}});
+  BOOST_TEST(i2.size()==5);
+#endif
+
+  BOOST_TEST(i2.erase(i2.begin(),i2.end())==i2.end());
+  BOOST_TEST(es.size()==0);
+
+  i2.insert(ve.begin(),ve.end());
+  BOOST_TEST(i3.size()==3);
+
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+  i2.insert({{4,"Vanessa",20,9236},{5,"Penelope",55,2358}});
+  BOOST_TEST(i3.size()==5);
+#endif
+
+  BOOST_TEST(*(i3.erase(i3.begin()))==employee(1,"Rachel",27,9012));
+  BOOST_TEST(i3.erase(i3.begin(),i3.end())==i3.end());
+  BOOST_TEST(es.size()==0);
+
+  i3.insert(i3.end(),ve.begin(),ve.end());
+  BOOST_TEST(es.size()==3);
+
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+  i3.insert(i3.begin(),{{4,"Vanessa",20,9236},{5,"Penelope",55,2358}});
+  BOOST_TEST(i3.front().name=="Vanessa");
+  BOOST_TEST(i4.size()==5);
+#endif
+
+  BOOST_TEST(i4.erase(9012)==1);
+  i4.erase(i4.begin());
+  BOOST_TEST(i4.erase(i4.begin(),i4.end())==i4.end());
+
+  i4.insert(ve.begin(),ve.end());
+  BOOST_TEST(i5.size()==3);
+
+  BOOST_TEST(i5.erase(i5.begin(),i5.end())==i5.end());
+  BOOST_TEST(es.size()==0);
+
+  i5.insert(i5.begin(),ve.begin(),ve.end());
+  BOOST_TEST(i1.size()==3);
+
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+  i5.insert(i5.end(),{{4,"Vanessa",20,9236},{5,"Penelope",55,2358}});
+  BOOST_TEST(i5.back().name=="Penelope");
+  BOOST_TEST(i1.size()==5);
+#endif
+
+  BOOST_TEST(es.erase(es.begin(),es.end())==es.end());
+  BOOST_TEST(i2.size()==0);
+
+  es.insert(employee(0,"Joe",31,1123));
+  es.insert(employee(1,"Robert",27,5601));
+  es.insert(employee(2,"John",40,7889));
+  es.insert(employee(3,"Albert",20,9012));
+  es.insert(employee(4,"John",57,1002));
+
+  employee_set es_backup(es);
+
+  employee_set es2;
+  es2.insert(employee(3,"Anna",31,5388));
+  es2.insert(employee(1,"Rachel",27,9012));
+  es2.insert(employee(2,"Agatha",40,1520));
+
+  employee_set es2_backup(es2);
+
+  i1.swap(get<1>(es2));
+  BOOST_TEST(es==es2_backup&&es2==es_backup);
+
+  i2.swap(get<2>(es2));
+  BOOST_TEST(es==es_backup&&es2==es2_backup);
+
+  i3.swap(get<3>(es2));
+  BOOST_TEST(es==es2_backup&&es2==es_backup);
+
+  i4.swap(get<4>(es2));
+  BOOST_TEST(es==es_backup&&es2==es2_backup);
+
+  i5.swap(get<5>(es2));
+  BOOST_TEST(es==es2_backup&&es2==es_backup);
+
+#if defined(BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL)
+  ::boost::multi_index::detail::swap(i1,get<1>(es2));
+#else
+  using std::swap;
+  swap(i1,get<1>(es2));
+#endif
+
+  BOOST_TEST(es==es_backup&&es2==es2_backup);
+
+#if defined(BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL)
+  ::boost::multi_index::detail::swap(i2,get<2>(es2));
+#else
+  using std::swap;
+  swap(i2,get<2>(es2));
+#endif
+
+  BOOST_TEST(es==es2_backup&&es2==es_backup);
+
+#if defined(BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL)
+  ::boost::multi_index::detail::swap(i3,get<3>(es2));
+#else
+  using std::swap;
+  swap(i3,get<3>(es2));
+#endif
+
+  BOOST_TEST(es==es_backup&&es2==es2_backup);
+
+#if defined(BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL)
+  ::boost::multi_index::detail::swap(i4,get<4>(es2));
+#else
+  using std::swap;
+  swap(i4,get<4>(es2));
+#endif
+
+  BOOST_TEST(es==es2_backup&&es2==es_backup);
+
+#if defined(BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL)
+  ::boost::multi_index::detail::swap(i5,get<5>(es2));
+#else
+  using std::swap;
+  swap(i5,get<5>(es2));
+#endif
+
+  BOOST_TEST(es==es_backup&&es2==es2_backup);
+
+  i3.clear();
+  BOOST_TEST(i3.size()==0);
+
+  es=es2;
+  i4.clear();
+  BOOST_TEST(i4.size()==0);
+
+  es=es2;
+  i5.clear();
+  BOOST_TEST(i5.size()==0);
+
+  es2.clear();
+  BOOST_TEST(es2.size()==0);
+
+  /* non-copyable elements */
+
+  multi_index_container<
+    non_copyable_int,
+    indexed_by<
+      ordered_non_unique<member<non_copyable_int,int,&non_copyable_int::n> >,
+      hashed_non_unique<member<non_copyable_int,int,&non_copyable_int::n> >,
+      sequenced<>,
+      random_access<>
+    >
+  > ncic,ncic2;
+
+  ncic.emplace(1);
+  get<1>(ncic).emplace(1);
+  get<2>(ncic).emplace_back(1);
+  get<3>(ncic).emplace_back(1);
+
+  non_copyable_int nci(1);
+  ncic.insert(boost::move(nci));
+  BOOST_TEST(nci.n==0);
+
+  nci.n=1;
+  get<1>(ncic).insert(boost::move(nci));
+  BOOST_TEST(nci.n==0);
+
+  nci.n=1;
+  get<2>(ncic).push_back(boost::move(nci));
+  BOOST_TEST(nci.n==0);
+
+  nci.n=1;
+  get<3>(ncic).push_back(boost::move(nci));
+  BOOST_TEST(nci.n==0);
+
+  std::vector<int> vi(4,1);
+  const std::vector<int>& cvi=vi;
+  ncic.insert(vi.begin(),vi.end());
+  ncic.insert(cvi.begin(),cvi.end());
+  get<2>(ncic).insert(get<2>(ncic).begin(),vi.begin(),vi.end());
+  get<2>(ncic).insert(get<2>(ncic).begin(),cvi.begin(),cvi.end());
+
+  BOOST_TEST(ncic.count(1)==24);
+
+  ncic.swap(ncic2);
+  BOOST_TEST(ncic.empty());
+  BOOST_TEST(ncic2.count(1)==24);
+
+  /* testcase for problem reported at
+   * http://lists.boost.org/boost-users/2006/12/24215.php
+   */
+
+  multi_index_container<
+    always_one,
+    indexed_by<
+      hashed_non_unique<identity<always_one> >
+    >
+  > aoc;
+
+  aoc.insert(always_one());
+  aoc.insert(always_one());
+  aoc.erase(*(aoc.begin()));
+  BOOST_TEST(aoc.empty());
+
+  /* Testcases for compliance with "as close to hint as possible"
+   * proposed behavior for associative containers:
+   *   http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#233
+   *   http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1780.html
+   */
+
+  typedef multi_index_container<
+    int,
+    indexed_by<
+      ordered_non_unique<identity<int> >
+    >
+  > int_non_unique_container;
+
+  int_non_unique_container c;
+  c.insert(0);c.insert(0);
+  c.insert(1);c.insert(1);
+  c.insert(2);c.insert(2);
+
+  BOOST_TEST(std::distance(c.begin(),c.insert(c.begin(),1))==2);
+  BOOST_TEST(std::distance(c.begin(),c.insert(boost::next(c.begin()),1))==2);
+  BOOST_TEST(std::distance(c.begin(),c.insert(c.lower_bound(1),1))==2);
+  BOOST_TEST(
+    std::distance(c.begin(),c.insert(boost::next(c.lower_bound(1)),1))==3);
+  BOOST_TEST(std::distance(c.begin(),c.insert(c.upper_bound(1),1))==8);
+  BOOST_TEST(std::distance(c.begin(),c.insert(boost::prior(c.end()),1))==9);
+  BOOST_TEST(std::distance(c.begin(),c.insert(c.end(),1))==10);
+
+  /* testcase for erase() reentrancy */
+  {
+    linked_object o1(1);
+    linked_object o2(2,o1);
+    o1=o2;
+  }
+
+  /* testcases for bug reported at
+   * https://svn.boost.org/trac/boost/ticket/9665
+   */
+
+  {
+    multi_index_container<
+      int,
+      indexed_by<hashed_unique<identity<int> > >
+    > hc;
+    hc.insert(tempvalue_iterator(0),tempvalue_iterator(10));
+    BOOST_TEST(hc.size()==10);
+
+    multi_index_container<
+      int,
+      indexed_by<ordered_unique<identity<int> > >
+    > oc;
+    oc.insert(tempvalue_iterator(0),tempvalue_iterator(10));
+    BOOST_TEST(oc.size()==10);
+  }
+
+  /* testcases for https://svn.boost.org/trac10/ticket/12542 */
+
+  {
+    multi_index_container<
+      int,
+      indexed_by<
+        ordered_unique<identity<int> >,
+        hashed_unique<identity<int> >
+     >
+    > ohc;
+
+#if !(defined BOOST_NO_EXCEPTIONS)
+    ohc.insert(0);
+    ohc.insert(1);
+
+    try{
+      ohc.modify_key(ohc.begin(),change_int_and_throw(1));
+    }
+    catch(int){}
+    BOOST_TEST(ohc.size()==1);
+    ohc.clear();
+
+    ohc.insert(0);
+    ohc.insert(1);
+
+    try{
+      ohc.modify_key(ohc.begin(),change_int_and_throw(1),change_int(0));
+    }
+    catch(int){}
+    BOOST_TEST(ohc.size()==1);
+    ohc.clear();
+
+    ohc.insert(0);
+    ohc.insert(1);
+
+    try{
+      ohc.modify_key(
+        ohc.begin(),change_int_and_throw(1),change_int_and_throw(0));
+    }
+    catch(int){}
+    BOOST_TEST(ohc.size()==1);
+    ohc.clear();
+
+    ohc.insert(0);
+    ohc.insert(1);
+
+    try{
+      ohc.modify_key(ohc.begin(),change_int(1),change_int_and_throw(0));
+    }
+    catch(int){}
+    BOOST_TEST(ohc.size()==1);
+    ohc.clear();
+#endif
+
+    ohc.insert(0);
+    ohc.insert(1);
+
+    ohc.modify_key(ohc.begin(),change_int(1),change_int(1));
+    BOOST_TEST(ohc.size()==1);
+    ohc.clear();
+  }
+}
diff --git a/src/boost/libs/multi_index/test/test_modifiers.hpp b/src/boost/libs/multi_index/test/test_modifiers.hpp
new file mode 100644
index 000000000..c5d28f818
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_modifiers.hpp
@@ -0,0 +1,11 @@
+/* Boost.MultiIndex test for modifier memfuns.
+ *
+ * Copyright 2003-2008 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+void test_modifiers();
diff --git a/src/boost/libs/multi_index/test/test_modifiers_main.cpp b/src/boost/libs/multi_index/test/test_modifiers_main.cpp
new file mode 100644
index 000000000..795289f87
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_modifiers_main.cpp
@@ -0,0 +1,20 @@
+/* Boost.MultiIndex test for modifier memfuns.
+ *
+ * Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include <boost/detail/lightweight_test.hpp>
+#include "test_modifiers.hpp"
+
+int main()
+{
+  test_modifiers();
+  return boost::report_errors();
+}
+
+
diff --git a/src/boost/libs/multi_index/test/test_mpl_ops.cpp b/src/boost/libs/multi_index/test/test_mpl_ops.cpp
new file mode 100644
index 000000000..21b86072f
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_mpl_ops.cpp
@@ -0,0 +1,75 @@
+/* Boost.MultiIndex test for MPL operations.
+ *
+ * Copyright 2003-2008 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include "test_mpl_ops.hpp"
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include "pre_multi_index.hpp"
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/identity.hpp>
+#include <boost/multi_index/ordered_index.hpp>
+#include <boost/multi_index/sequenced_index.hpp>
+#include <boost/mpl/at.hpp>
+#include <boost/mpl/list.hpp>
+
+using namespace boost::multi_index;
+
+void test_mpl_ops()
+{
+  typedef multi_index_container<
+    int,
+    indexed_by<
+      ordered_unique<identity<int> >,
+      ordered_non_unique<identity<int> >
+     >
+  >                           indexed_t1;
+
+  BOOST_STATIC_ASSERT((boost::is_same<
+    boost::mpl::at_c<indexed_t1::index_specifier_type_list,0>::type,
+    ordered_unique<identity<int> > >::value));
+  BOOST_STATIC_ASSERT((boost::is_same<
+    boost::mpl::at_c<indexed_t1::index_specifier_type_list,1>::type,
+    ordered_non_unique<identity<int> > >::value));
+
+  typedef boost::mpl::push_front<
+    indexed_t1::index_specifier_type_list,
+    sequenced<>
+  >::type                     index_list_t;
+
+  typedef multi_index_container<
+    int,
+    index_list_t
+  >                           indexed_t2;
+
+  BOOST_STATIC_ASSERT((boost::is_same<
+    boost::mpl::at_c<indexed_t2::index_specifier_type_list,0>::type,
+    sequenced<> >::value));
+  BOOST_STATIC_ASSERT((boost::is_same<
+    boost::mpl::at_c<indexed_t2::index_specifier_type_list,1>::type,
+    boost::mpl::at_c<indexed_t1::index_specifier_type_list,0>::type>::value));
+  BOOST_STATIC_ASSERT((boost::is_same<
+    boost::mpl::at_c<indexed_t2::index_specifier_type_list,2>::type,
+    boost::mpl::at_c<indexed_t1::index_specifier_type_list,1>::type>::value));
+
+  typedef multi_index_container<
+    int,
+    boost::mpl::list<
+      ordered_unique<identity<int> >,
+      ordered_non_unique<identity<int> >
+    >
+  >                           indexed_t3;
+
+  BOOST_STATIC_ASSERT((boost::is_same<
+    boost::mpl::at_c<indexed_t3::index_specifier_type_list,0>::type,
+    boost::mpl::at_c<indexed_t1::index_specifier_type_list,0>::type>::value));
+  BOOST_STATIC_ASSERT((boost::is_same<
+    boost::mpl::at_c<indexed_t3::index_specifier_type_list,1>::type,
+    boost::mpl::at_c<indexed_t1::index_specifier_type_list,1>::type>::value));
+}
diff --git a/src/boost/libs/multi_index/test/test_mpl_ops.hpp b/src/boost/libs/multi_index/test/test_mpl_ops.hpp
new file mode 100644
index 000000000..320600bac
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_mpl_ops.hpp
@@ -0,0 +1,11 @@
+/* Boost.MultiIndex test for for MPL operations.
+ *
+ * Copyright 2003-2008 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+void test_mpl_ops();
diff --git a/src/boost/libs/multi_index/test/test_mpl_ops_main.cpp b/src/boost/libs/multi_index/test/test_mpl_ops_main.cpp
new file mode 100644
index 000000000..fe1879b25
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_mpl_ops_main.cpp
@@ -0,0 +1,18 @@
+/* Boost.MultiIndex test for for MPL operations.
+ *
+ * Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include <boost/detail/lightweight_test.hpp>
+#include "test_mpl_ops.hpp"
+
+int main()
+{
+  test_mpl_ops();
+  return boost::report_errors();
+}
diff --git a/src/boost/libs/multi_index/test/test_observers.cpp b/src/boost/libs/multi_index/test/test_observers.cpp
new file mode 100644
index 000000000..8013408a4
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_observers.cpp
@@ -0,0 +1,56 @@
+/* Boost.MultiIndex test for observer memfuns.
+ *
+ * Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include "test_observers.hpp"
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <algorithm>
+#include <vector>
+#include "pre_multi_index.hpp"
+#include "employee.hpp"
+#include <boost/detail/lightweight_test.hpp>
+
+using namespace boost::multi_index;
+
+void test_observers()
+{
+  employee_set                es;
+  const employee_set_by_name& i1=get<by_name>(es);
+  const employee_set_by_age&  i2=get<age>(es);
+
+  es.insert(employee(0,"Joe",31,1123));
+  es.insert(employee(1,"Robert",27,5601));
+  es.insert(employee(2,"John",40,7889));
+  es.insert(employee(3,"Albert",20,9012));
+  es.insert(employee(4,"John",57,1002));
+
+  {
+    employee_set_by_name::key_from_value k=i1.key_extractor();
+    employee_set_by_name::hasher         h=i1.hash_function();
+    employee_set_by_name::key_equal      eq=i1.key_eq();
+
+    employee_set_by_name::const_iterator it0=i1.equal_range("John").first;
+    employee_set_by_name::const_iterator it1=it0;++it1;
+    BOOST_TEST(k(*it0)=="John"&&k(*it1)=="John");
+    BOOST_TEST(h(k(*it0))==h(k(*it1)));
+    BOOST_TEST(eq(k(*it0),k(*it1))==true);
+  }
+  {
+    employee_set_by_age::key_from_value k=i2.key_extractor();
+    employee_set_by_age::key_compare    c=i2.key_comp();
+    employee_set_by_age::value_compare  vc=i2.value_comp();
+
+    employee_set_by_age::const_iterator it0=i2.find(31);
+    employee_set_by_age::const_iterator it1=i2.find(40);
+    BOOST_TEST(k(*it0)==31&&k(*it1)==40);
+    BOOST_TEST(c(k(*it0),k(*it1))==true);
+    BOOST_TEST(vc(*it0,*it1)==true);
+  }
+}
diff --git a/src/boost/libs/multi_index/test/test_observers.hpp b/src/boost/libs/multi_index/test/test_observers.hpp
new file mode 100644
index 000000000..f9a0a1129
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_observers.hpp
@@ -0,0 +1,11 @@
+/* Boost.MultiIndex test for observer memfuns.
+ *
+ * Copyright 2003-2008 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+void test_observers();
diff --git a/src/boost/libs/multi_index/test/test_observers_main.cpp b/src/boost/libs/multi_index/test/test_observers_main.cpp
new file mode 100644
index 000000000..2d92fe626
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_observers_main.cpp
@@ -0,0 +1,18 @@
+/* Boost.MultiIndex test for observer memfuns.
+ *
+ * Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include <boost/detail/lightweight_test.hpp>
+#include "test_observers.hpp"
+
+int main()
+{
+  test_observers();
+  return boost::report_errors();
+}
diff --git a/src/boost/libs/multi_index/test/test_projection.cpp b/src/boost/libs/multi_index/test/test_projection.cpp
new file mode 100644
index 000000000..324a04583
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_projection.cpp
@@ -0,0 +1,135 @@
+/* Boost.MultiIndex test for projection capabilities.
+ *
+ * Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include "test_projection.hpp"
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include "pre_multi_index.hpp"
+#include "employee.hpp"
+#include <boost/detail/lightweight_test.hpp>
+
+using namespace boost::multi_index;
+
+void test_projection()
+{
+  employee_set          es;
+  es.insert(employee(0,"Joe",31,1123));
+  es.insert(employee(1,"Robert",27,5601));
+  es.insert(employee(2,"John",40,7889));
+  es.insert(employee(3,"Albert",20,9012));
+  es.insert(employee(4,"John",57,1002));
+
+  employee_set::iterator             it,itbis;
+  employee_set_by_name::iterator     it1;
+  employee_set_by_age::iterator      it2;
+  employee_set_as_inserted::iterator it3;
+  employee_set_by_ssn::iterator      it4;
+  employee_set_randomly::iterator    it5;
+
+  BOOST_STATIC_ASSERT((boost::is_same<
+    employee_set::iterator,
+    nth_index_iterator<employee_set,0>::type >::value));
+  BOOST_STATIC_ASSERT((boost::is_same<
+    employee_set_by_name::iterator,
+    nth_index_iterator<employee_set,1>::type >::value));
+#if defined(BOOST_NO_MEMBER_TEMPLATES)
+  BOOST_STATIC_ASSERT((boost::is_same<
+    employee_set_by_age::iterator,
+    index_iterator<employee_set,age>::type >::value));
+#else
+  BOOST_STATIC_ASSERT((boost::is_same<
+    employee_set_by_age::iterator,
+    employee_set::index_iterator<age>::type >::value));
+#endif
+  BOOST_STATIC_ASSERT((boost::is_same<
+    employee_set_as_inserted::iterator,
+    nth_index_iterator<employee_set,3>::type >::value));
+  BOOST_STATIC_ASSERT((boost::is_same<
+    employee_set_by_ssn::iterator,
+    nth_index_iterator<employee_set,4>::type >::value));
+  BOOST_STATIC_ASSERT((boost::is_same<
+    employee_set_randomly::iterator,
+    nth_index_iterator<employee_set,5>::type >::value));
+
+  it=   es.find(employee(1,"Robert",27,5601));
+  it1=  project<name>(es,it);
+  it2=  project<age>(es,it1);
+  it3=  project<as_inserted>(es,it2);
+  it4=  project<ssn>(es,it3);
+  it5=  project<randomly>(es,it4);
+#if defined(BOOST_NO_MEMBER_TEMPLATES)
+  itbis=project<0>(es,it5);
+#else
+  itbis=es.project<0>(it5);
+#endif
+
+  BOOST_TEST(
+    *it==*it1&&*it1==*it2&&*it2==*it3&&*it3==*it4&&*it4==*it5&&itbis==it);
+
+  BOOST_TEST(project<name>(es,es.end())==get<name>(es).end());
+  BOOST_TEST(project<age>(es,es.end())==get<age>(es).end());
+  BOOST_TEST(project<as_inserted>(es,es.end())==get<as_inserted>(es).end());
+  BOOST_TEST(project<ssn>(es,es.end())==get<ssn>(es).end());
+  BOOST_TEST(project<randomly>(es,es.end())==get<randomly>(es).end());
+
+  const employee_set& ces=es;
+
+  employee_set::const_iterator             cit,citbis;
+  employee_set_by_name::const_iterator     cit1;
+  employee_set_by_age::const_iterator      cit2;
+  employee_set_as_inserted::const_iterator cit3;
+  employee_set_by_ssn::const_iterator      cit4;
+  employee_set_randomly::const_iterator    cit5;
+
+  BOOST_STATIC_ASSERT((boost::is_same<
+    employee_set::const_iterator,
+    nth_index_const_iterator<employee_set,0>::type >::value));
+  BOOST_STATIC_ASSERT((boost::is_same<
+    employee_set_by_name::const_iterator,
+    nth_index_const_iterator<employee_set,1>::type >::value));
+#if defined(BOOST_NO_MEMBER_TEMPLATES)
+  BOOST_STATIC_ASSERT((boost::is_same<
+    employee_set_by_age::const_iterator,
+    index_const_iterator<employee_set,age>::type >::value));
+#else
+  BOOST_STATIC_ASSERT((boost::is_same<
+    employee_set_by_age::const_iterator,
+    employee_set::index_const_iterator<age>::type >::value));
+#endif
+  BOOST_STATIC_ASSERT((boost::is_same<
+    employee_set_as_inserted::const_iterator,
+    nth_index_const_iterator<employee_set,3>::type >::value));
+  BOOST_STATIC_ASSERT((boost::is_same<
+    employee_set_by_ssn::const_iterator,
+    nth_index_const_iterator<employee_set,4>::type >::value));
+  BOOST_STATIC_ASSERT((boost::is_same<
+    employee_set_randomly::const_iterator,
+    nth_index_const_iterator<employee_set,5>::type >::value));
+
+  cit=   ces.find(employee(4,"John",57,1002));
+#if defined(BOOST_NO_MEMBER_TEMPLATES)
+  cit1=  project<by_name>(ces,cit);
+#else
+  cit1=  ces.project<by_name>(cit);
+#endif
+  cit2=  project<age>(ces,cit1);
+#if defined(BOOST_NO_MEMBER_TEMPLATES)
+  cit3=  project<as_inserted>(ces,cit2);
+#else
+  cit3=  ces.project<as_inserted>(cit2);
+#endif
+  cit4=  project<ssn>(ces,cit3);
+  cit5=  project<randomly>(ces,cit4);
+  citbis=project<0>(ces,cit5);
+
+  BOOST_TEST(
+    *cit==*cit1&&*cit1==*cit2&&*cit2==*cit3&&*cit3==*cit4&&*cit4==*cit5&&
+    citbis==cit);
+}
diff --git a/src/boost/libs/multi_index/test/test_projection.hpp b/src/boost/libs/multi_index/test/test_projection.hpp
new file mode 100644
index 000000000..660ecb232
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_projection.hpp
@@ -0,0 +1,11 @@
+/* Boost.MultiIndex test for projection capabilities.
+ *
+ * Copyright 2003-2008 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+void test_projection();
diff --git a/src/boost/libs/multi_index/test/test_projection_main.cpp b/src/boost/libs/multi_index/test/test_projection_main.cpp
new file mode 100644
index 000000000..560316a65
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_projection_main.cpp
@@ -0,0 +1,20 @@
+/* Boost.MultiIndex test for projection capabilities.
+ *
+ * Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include <boost/detail/lightweight_test.hpp>
+#include "test_projection.hpp"
+
+int main()
+{
+  test_projection();
+  return boost::report_errors();
+}
+
+
diff --git a/src/boost/libs/multi_index/test/test_range.cpp b/src/boost/libs/multi_index/test/test_range.cpp
new file mode 100644
index 000000000..0d6ab13a3
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_range.cpp
@@ -0,0 +1,125 @@
+/* Boost.MultiIndex test for range().
+ *
+ * Copyright 2003-2020 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include "test_range.hpp"
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <algorithm>
+#include <boost/bind/bind.hpp>
+#include <boost/detail/lightweight_test.hpp>
+#include "pre_multi_index.hpp"
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/identity.hpp>
+#include <boost/multi_index/ordered_index.hpp>
+#include <boost/preprocessor/seq/enum.hpp>
+#include <functional>
+
+using namespace boost::multi_index;
+
+typedef multi_index_container<int>  int_set;
+typedef int_set::iterator int_set_iterator;
+
+#undef CHECK_RANGE
+#define CHECK_RANGE(p,check_seq) \
+{\
+  int v[]={BOOST_PP_SEQ_ENUM(check_seq)};\
+  std::size_t size_v=sizeof(v)/sizeof(int);\
+  BOOST_TEST(std::size_t(std::distance((p).first,(p).second))==size_v);\
+  BOOST_TEST(std::equal((p).first,(p).second,&v[0]));\
+}
+
+#undef CHECK_VOID_RANGE
+#define CHECK_VOID_RANGE(p) BOOST_TEST((p).first==(p).second)
+
+#undef BIND1ST
+#define BIND1ST(f,x) ::boost::bind(f,x,::boost::arg<1>())
+
+#undef BIND2ND
+#define BIND2ND(f,x) ::boost::bind(f,::boost::arg<1>(),x)
+
+void test_range()
+{
+  int_set is;
+
+  for(int i=1;i<=10;++i)is.insert(i);
+
+  std::pair<int_set::iterator,int_set::iterator> p;
+
+  p=is.range(unbounded,unbounded);
+  CHECK_RANGE(p,(1)(2)(3)(4)(5)(6)(7)(8)(9)(10));
+
+  p=is.range(
+    BIND1ST(std::less<int>(),5), /* 5 < x */
+    unbounded);
+  CHECK_RANGE(p,(6)(7)(8)(9)(10));
+
+  p=is.range(
+    BIND1ST(std::less_equal<int>(),8), /* 8 <= x */
+    unbounded);
+  CHECK_RANGE(p,(8)(9)(10));
+
+  p=is.range(
+    BIND1ST(std::less_equal<int>(),11), /* 11 <= x */
+    unbounded);
+  CHECK_VOID_RANGE(p);
+
+  p=is.range(
+    unbounded,
+    BIND2ND(std::less<int>(),8)); /* x < 8 */
+  CHECK_RANGE(p,(1)(2)(3)(4)(5)(6)(7));
+
+  p=is.range(
+    unbounded,
+    BIND2ND(std::less_equal<int>(),4)); /* x <= 4 */
+  CHECK_RANGE(p,(1)(2)(3)(4));
+
+  p=is.range(
+    unbounded,
+    BIND2ND(std::less_equal<int>(),0)); /* x <= 0 */
+  CHECK_VOID_RANGE(p);
+
+  p=is.range(
+    BIND1ST(std::less<int>(),6),        /* 6 <  x */
+    BIND2ND(std::less_equal<int>(),9)); /* x <= 9 */
+  CHECK_RANGE(p,(7)(8)(9));
+
+  p=is.range(
+    BIND1ST(std::less_equal<int>(),4), /* 4 <= x */
+    BIND2ND(std::less<int>(),5));      /* x <  5 */
+  CHECK_RANGE(p,(4));
+
+  p=is.range(
+    BIND1ST(std::less_equal<int>(),10),  /* 10 <=  x */
+    BIND2ND(std::less_equal<int>(),10)); /*  x <= 10 */
+  CHECK_RANGE(p,(10));
+
+  p=is.range(
+    BIND1ST(std::less<int>(),0),   /* 0 <  x */
+    BIND2ND(std::less<int>(),11)); /* x < 11 */
+  CHECK_RANGE(p,(1)(2)(3)(4)(5)(6)(7)(8)(9)(10));
+
+  p=is.range(
+    BIND1ST(std::less<int>(),7),        /* 7 <  x */
+    BIND2ND(std::less_equal<int>(),7)); /* x <= 7 */
+  CHECK_VOID_RANGE(p);
+  BOOST_TEST(p.first==is.upper_bound(7));
+
+  p=is.range(
+    BIND1ST(std::less_equal<int>(),8), /* 8 <= x */
+    BIND2ND(std::less<int>(),2));      /* x <  2 */
+  CHECK_VOID_RANGE(p);
+  BOOST_TEST(p.first==is.lower_bound(8));
+
+  p=is.range(
+    BIND1ST(std::less<int>(),4),  /* 4 < x */
+    BIND2ND(std::less<int>(),5)); /* x < 5 */
+  CHECK_VOID_RANGE(p);
+  BOOST_TEST(p.first!=is.end());
+}
diff --git a/src/boost/libs/multi_index/test/test_range.hpp b/src/boost/libs/multi_index/test/test_range.hpp
new file mode 100644
index 000000000..2706e8dbd
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_range.hpp
@@ -0,0 +1,11 @@
+/* Boost.MultiIndex test for range().
+ *
+ * Copyright 2003-2008 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+void test_range();
diff --git a/src/boost/libs/multi_index/test/test_range_main.cpp b/src/boost/libs/multi_index/test/test_range_main.cpp
new file mode 100644
index 000000000..8c916687c
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_range_main.cpp
@@ -0,0 +1,18 @@
+/* Boost.MultiIndex test for range().
+ *
+ * Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include <boost/detail/lightweight_test.hpp>
+#include "test_range.hpp"
+
+int main()
+{
+  test_range();
+  return boost::report_errors();
+}
diff --git a/src/boost/libs/multi_index/test/test_rank_ops.cpp b/src/boost/libs/multi_index/test/test_rank_ops.cpp
new file mode 100644
index 000000000..670540143
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_rank_ops.cpp
@@ -0,0 +1,154 @@
+/* Boost.MultiIndex test for rank operations.
+ *
+ * Copyright 2003-2017 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include "test_rank_ops.hpp"
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <algorithm>
+#include <iterator>
+#include <set>
+#include <boost/detail/lightweight_test.hpp>
+#include "pre_multi_index.hpp"
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/identity.hpp>
+#include <boost/multi_index/ranked_index.hpp>
+
+using namespace boost::multi_index;
+
+template<
+  typename Sequence1,typename Iterator2,typename Sequence2
+>
+bool same_position(
+  std::size_t n1,const Sequence1& s1,Iterator2 it2,const Sequence2& s2)
+{
+  typedef typename Sequence1::const_iterator const_iterator1;
+  typedef typename Sequence2::const_iterator const_iterator2;
+
+  const_iterator1 cit1=s1.begin();
+  std::advance(cit1,n1);
+  const_iterator2 cit2=it2;
+  return std::distance(s1.begin(),cit1)==std::distance(s2.begin(),cit2);
+}
+
+struct less_equal_than
+{
+  less_equal_than(int n_):n(n_){}
+  bool operator()(int x)const{return x<=n;}
+  int n;
+};
+
+struct greater_equal_than
+{
+  greater_equal_than(int n_):n(n_){}
+  bool operator()(int x)const{return x>=n;}
+  int n;
+};
+
+template<typename Sequence>
+static void local_test_rank_ops()
+{
+  int                data[]={2,2,1,5,6,7,9,10,9,6,9,6,9};
+  Sequence           s(data,data+sizeof(data)/sizeof(data[0]));
+  std::multiset<int> ss(s.begin(),s.end());
+
+  typedef typename Sequence::iterator iterator;
+
+  iterator it=s.begin();
+  for(std::size_t n=0;n<=s.size()+1;++n){
+    BOOST_TEST(s.nth(n)==it);
+    BOOST_TEST(s.rank(it)==(std::min)(s.size(),n));
+    if(it!=s.end())++it;
+  }
+
+  std::pair<std::size_t,std::size_t> p1;
+  std::pair<iterator,iterator>       p2;
+
+  p1=s.range_rank(unbounded,unbounded);
+  p2=s.range(unbounded,unbounded);
+  BOOST_TEST(same_position(p1.first,s,p2.first,s));
+  BOOST_TEST(same_position(p1.second,s,p2.second,s));
+
+  for(int i=0;i<12;++i){
+    std::size_t pos=s.find_rank(i);
+    BOOST_TEST((pos==s.size()&&ss.find(i)==ss.end())||(*s.nth(pos)==i));
+    BOOST_TEST(same_position(s.lower_bound_rank(i),s,ss.lower_bound(i),ss));
+    BOOST_TEST(same_position(s.upper_bound_rank(i),s,ss.upper_bound(i),ss));
+    std::pair<std::size_t,std::size_t> posp=s.equal_range_rank(i);
+    BOOST_TEST(same_position(posp.first,s,ss.lower_bound(i),ss));
+    BOOST_TEST(same_position(posp.second,s,ss.upper_bound(i),ss));
+
+    p1=s.range_rank(greater_equal_than(i),unbounded);
+    p2=s.range(greater_equal_than(i),unbounded);
+    BOOST_TEST(same_position(p1.first,s,p2.first,s));
+    BOOST_TEST(same_position(p1.second,s,p2.second,s));
+    p1=s.range_rank(unbounded,less_equal_than(i));
+    p2=s.range(unbounded,less_equal_than(i));
+    BOOST_TEST(same_position(p1.first,s,p2.first,s));
+    BOOST_TEST(same_position(p1.second,s,p2.second,s));
+
+    for(int j=0;j<12;++j){
+      p1=s.range_rank(greater_equal_than(i),less_equal_than(j));
+      p2=s.range(greater_equal_than(i),less_equal_than(j));
+      BOOST_TEST(same_position(p1.first,s,p2.first,s));
+      BOOST_TEST(same_position(p1.second,s,p2.second,s));
+    }
+  }
+
+  Sequence se; /* empty */
+  BOOST_TEST(se.nth(0)==se.end());
+  BOOST_TEST(se.nth(1)==se.end());
+  BOOST_TEST(se.rank(se.end())==0);
+  BOOST_TEST(se.find_rank(0)==0);
+  BOOST_TEST(se.lower_bound_rank(0)==0);
+  BOOST_TEST(se.upper_bound_rank(0)==0);
+  p1=se.equal_range_rank(0);
+  BOOST_TEST(p1.first==0&&p1.second==0);
+  p1=se.range_rank(unbounded,unbounded);
+  BOOST_TEST(p1.first==0&&p1.second==0);
+  p1=se.range_rank(greater_equal_than(0),unbounded);
+  BOOST_TEST(p1.first==0&&p1.second==0);
+  p1=se.range_rank(unbounded,less_equal_than(0));
+  BOOST_TEST(p1.first==0&&p1.second==0);
+  p1=se.range_rank(greater_equal_than(0),less_equal_than(0));
+  BOOST_TEST(p1.first==0&&p1.second==0);
+}
+
+void test_rank_ops()
+{
+  typedef multi_index_container<
+    int,
+    indexed_by<
+      ranked_unique<identity<int> >
+    >
+  > ranked_set;
+  
+  local_test_rank_ops<ranked_set>();
+
+  typedef multi_index_container<
+    int,
+    indexed_by<
+      ranked_non_unique<identity<int> >
+    >
+  > ranked_multiset;
+  
+  local_test_rank_ops<ranked_multiset>();
+
+  /* testcase for https://svn.boost.org/trac/boost/ticket/12955 */
+
+  typedef multi_index_container<
+    int,
+    indexed_by<
+      ranked_unique<identity<int> >,
+      ranked_non_unique<identity<int> >
+    >
+  > biranked_set;
+  
+  local_test_rank_ops<biranked_set>();
+}
diff --git a/src/boost/libs/multi_index/test/test_rank_ops.hpp b/src/boost/libs/multi_index/test/test_rank_ops.hpp
new file mode 100644
index 000000000..d410bd6e3
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_rank_ops.hpp
@@ -0,0 +1,11 @@
+/* Boost.MultiIndex test for rank operations.
+ *
+ * Copyright 2003-20015 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+void test_rank_ops();
diff --git a/src/boost/libs/multi_index/test/test_rank_ops_main.cpp b/src/boost/libs/multi_index/test/test_rank_ops_main.cpp
new file mode 100644
index 000000000..b51de6be0
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_rank_ops_main.cpp
@@ -0,0 +1,18 @@
+/* Boost.MultiIndex test for rank operations.
+ *
+ * Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include <boost/detail/lightweight_test.hpp>
+#include "test_rank_ops.hpp"
+
+int main()
+{
+  test_rank_ops();
+  return boost::report_errors();
+}
diff --git a/src/boost/libs/multi_index/test/test_rearrange.cpp b/src/boost/libs/multi_index/test/test_rearrange.cpp
new file mode 100644
index 000000000..9a5ddaec4
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_rearrange.cpp
@@ -0,0 +1,132 @@
+/* Boost.MultiIndex test for rearrange operations.
+ *
+ * Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include "test_rearrange.hpp"
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <algorithm>
+#include <iterator>
+#include <boost/detail/lightweight_test.hpp>
+#include "pre_multi_index.hpp"
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/sequenced_index.hpp>
+#include <boost/multi_index/random_access_index.hpp>
+#include <boost/next_prior.hpp>
+#include <boost/preprocessor/seq/enum.hpp>
+#include <boost/ref.hpp>
+#include <vector>
+
+using namespace boost::multi_index;
+
+#undef CHECK_EQUAL
+#define CHECK_EQUAL(p,check_seq) \
+{\
+  int v[]={BOOST_PP_SEQ_ENUM(check_seq)};\
+  std::size_t size_v=sizeof(v)/sizeof(int);\
+  BOOST_TEST(std::size_t(std::distance((p).begin(),(p).end()))==size_v);\
+  BOOST_TEST(std::equal((p).begin(),(p).end(),&v[0]));\
+}
+
+#undef CHECK_VOID_RANGE
+#define CHECK_VOID_RANGE(p) BOOST_TEST((p).first==(p).second)
+
+#if BOOST_WORKAROUND(__MWERKS__,<=0x3003)
+/* The "ISO C++ Template Parser" option makes CW8.3 incorrectly fail at
+ * expressions of the form sizeof(x) where x is an array local to a
+ * template function.
+ */
+
+#pragma parse_func_templ off
+#endif
+
+template<typename Sequence>
+static void local_test_rearrange()
+{
+  typedef typename Sequence::iterator   iterator;
+  typedef typename Sequence::value_type value_type;
+
+  Sequence sc;
+  sc.push_back(0);
+  sc.push_back(1);
+  sc.push_back(2);
+  sc.push_back(3);
+  sc.push_back(4);
+  sc.push_back(5);
+
+  iterator it;
+
+  it=sc.begin();
+  std::advance(it,3);
+  sc.relocate(sc.begin(),it);
+  CHECK_EQUAL(sc,(3)(0)(1)(2)(4)(5));
+  BOOST_TEST(it==sc.begin());
+
+  sc.relocate(it,it);
+  CHECK_EQUAL(sc,(3)(0)(1)(2)(4)(5));
+
+  std::advance(it,3);
+  sc.relocate(sc.end(),it,sc.end());
+  CHECK_EQUAL(sc,(3)(0)(1)(2)(4)(5));
+
+  sc.relocate(sc.begin(),it,it);
+  CHECK_EQUAL(sc,(3)(0)(1)(2)(4)(5));
+
+  iterator it2;
+
+  it2=sc.begin();
+  ++it2;
+  sc.relocate(it2,it,sc.end());
+  CHECK_EQUAL(sc,(3)(2)(4)(5)(0)(1));
+  BOOST_TEST(std::distance(it,it2)==3);
+
+  sc.relocate(boost::prior(sc.end()),it,it2);
+  CHECK_EQUAL(sc,(3)(0)(2)(4)(5)(1));
+
+  std::vector<boost::reference_wrapper<const value_type> > v;
+  for(iterator it3=sc.begin();it3!=sc.end();++it3){
+    v.push_back(boost::cref(*it3));
+  }
+
+  sc.rearrange(v.begin());
+  BOOST_TEST(std::equal(sc.begin(),sc.end(),v.begin()));
+
+  std::reverse(v.begin(),v.end());
+  sc.rearrange(v.begin());
+  BOOST_TEST(std::equal(sc.begin(),sc.end(),v.begin()));
+
+  std::sort(v.begin(),v.end());
+  sc.rearrange(v.begin());
+  BOOST_TEST(std::equal(sc.begin(),sc.end(),v.begin()));
+
+  std::reverse(v.begin(),v.begin()+v.size()/2);
+  sc.rearrange(v.begin());
+  BOOST_TEST(std::equal(sc.begin(),sc.end(),v.begin()));
+}
+
+#if BOOST_WORKAROUND(__MWERKS__,<=0x3003)
+#pragma parse_func_templ reset
+#endif
+
+void test_rearrange()
+{
+  typedef multi_index_container<
+    int,
+    indexed_by<sequenced<> >
+  > int_list;
+
+  local_test_rearrange<int_list>();
+
+  typedef multi_index_container<
+    int,
+    indexed_by<random_access<> >
+  > int_vector;
+
+  local_test_rearrange<int_vector>();
+}
diff --git a/src/boost/libs/multi_index/test/test_rearrange.hpp b/src/boost/libs/multi_index/test/test_rearrange.hpp
new file mode 100644
index 000000000..f3ec8457c
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_rearrange.hpp
@@ -0,0 +1,11 @@
+/* Boost.MultiIndex test for rearrange operations.
+ *
+ * Copyright 2003-2008 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+void test_rearrange();
diff --git a/src/boost/libs/multi_index/test/test_rearrange_main.cpp b/src/boost/libs/multi_index/test/test_rearrange_main.cpp
new file mode 100644
index 000000000..9fe5a65be
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_rearrange_main.cpp
@@ -0,0 +1,18 @@
+/* Boost.MultiIndex test for rearrange operations.
+ *
+ * Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include <boost/detail/lightweight_test.hpp>
+#include "test_rearrange.hpp"
+
+int main()
+{
+  test_rearrange();
+  return boost::report_errors();
+}
diff --git a/src/boost/libs/multi_index/test/test_safe_mode.cpp b/src/boost/libs/multi_index/test/test_safe_mode.cpp
new file mode 100644
index 000000000..b5a7e796d
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_safe_mode.cpp
@@ -0,0 +1,472 @@
+/* Boost.MultiIndex test for safe_mode.
+ *
+ * Copyright 2003-2018 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include "test_safe_mode.hpp"
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include "pre_multi_index.hpp"
+#include "employee.hpp"
+#include "pair_of_ints.hpp"
+#include <stdexcept>
+#include <boost/detail/lightweight_test.hpp>
+
+using namespace boost::multi_index;
+
+#define TRY_SAFE_MODE \
+try{
+
+#define CATCH_SAFE_MODE(err) \
+  throw std::runtime_error("safe mode violation not detected");\
+}catch(const safe_mode_exception& e){\
+  if(e.error_code!=(err))throw std::runtime_error(\
+    "safe mode violation not expected");\
+}
+
+template<typename T> void prevent_unused_var_warning(const T&){}
+
+template<typename Policy>
+static void local_test_safe_mode(
+  std::forward_iterator_tag
+  BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Policy))
+{
+  typedef typename Policy::container      container;
+  typedef typename Policy::index_type     index_type;
+  typedef typename index_type::value_type value_type;
+  typedef typename index_type::iterator   iterator;
+
+  container   c,c2;
+  index_type& i=Policy::index_from_container(c);
+  index_type& i2=Policy::index_from_container(c2);
+  Policy::insert(i,Policy::some_value());
+
+  TRY_SAFE_MODE
+    iterator it;
+    iterator it2=i.begin();
+    it2=it;
+  CATCH_SAFE_MODE(safe_mode::invalid_iterator)
+
+  TRY_SAFE_MODE
+    iterator it;
+    value_type e=*it;
+  CATCH_SAFE_MODE(safe_mode::invalid_iterator)
+  
+  TRY_SAFE_MODE
+    iterator it=i.end();
+    value_type e=*it;
+  CATCH_SAFE_MODE(safe_mode::not_dereferenceable_iterator)
+
+  TRY_SAFE_MODE
+    iterator it=i.end();
+    ++it;
+  CATCH_SAFE_MODE(safe_mode::not_incrementable_iterator)
+
+  TRY_SAFE_MODE
+    iterator it;
+    iterator it2;
+    bool b=(it==it2);
+    prevent_unused_var_warning(b);
+  CATCH_SAFE_MODE(safe_mode::invalid_iterator)
+
+  TRY_SAFE_MODE
+    iterator it=i.begin();
+    iterator it2;
+    bool b=(it==it2);
+    prevent_unused_var_warning(b);
+  CATCH_SAFE_MODE(safe_mode::invalid_iterator)
+
+  TRY_SAFE_MODE
+    iterator it=i.begin();
+    iterator it2=i2.begin();
+    bool b=(it==it2);
+    prevent_unused_var_warning(b);
+  CATCH_SAFE_MODE(safe_mode::not_same_owner)
+
+  TRY_SAFE_MODE
+    i.erase(i.end(),i.begin());
+  CATCH_SAFE_MODE(safe_mode::invalid_range)
+
+  TRY_SAFE_MODE
+    iterator it;
+    Policy::insert(i,it,Policy::some_value());
+  CATCH_SAFE_MODE(safe_mode::invalid_iterator)
+
+  TRY_SAFE_MODE
+    i.erase(i.end());
+  CATCH_SAFE_MODE(safe_mode::not_dereferenceable_iterator)
+
+  TRY_SAFE_MODE
+    iterator it=i.begin();
+    Policy::insert(i2,it,Policy::some_value());
+  CATCH_SAFE_MODE(safe_mode::not_owner)
+
+  TRY_SAFE_MODE
+    iterator it=i.begin();
+    iterator it2=i2.end();
+    i2.erase(it,it2);
+  CATCH_SAFE_MODE(safe_mode::not_owner)
+
+  TRY_SAFE_MODE
+    iterator it=Policy::insert(i,Policy::another_value());
+    i.erase(it);
+    i.erase(it);
+  CATCH_SAFE_MODE(safe_mode::invalid_iterator)
+
+  TRY_SAFE_MODE
+    container   c3(c);
+    index_type& i3=Policy::index_from_container(c3);
+    iterator it=Policy::insert(i3,Policy::another_value());
+    i3.clear();
+    i3.erase(it);
+  CATCH_SAFE_MODE(safe_mode::invalid_iterator)
+
+  TRY_SAFE_MODE
+    iterator it;
+    {
+      container   c3;
+      index_type& i3=Policy::index_from_container(c3);
+      it=i3.end();
+    }
+    iterator it2;
+    it2=it;
+  CATCH_SAFE_MODE(safe_mode::invalid_iterator)
+
+  TRY_SAFE_MODE
+    iterator it;
+    {
+      container   c3;
+      index_type& i3=Policy::index_from_container(c3);
+      it=Policy::insert(i3,Policy::some_value());
+    }
+    value_type e=*it;
+  CATCH_SAFE_MODE(safe_mode::invalid_iterator)
+
+  TRY_SAFE_MODE
+    iterator it;
+    {
+      container   c3;
+      index_type& i3=Policy::index_from_container(c3);
+      it=Policy::insert(i3,Policy::some_value());
+    }
+    iterator it2;
+    it2=it;
+  CATCH_SAFE_MODE(safe_mode::invalid_iterator)
+
+  TRY_SAFE_MODE
+    container   c3(c);
+    container   c4;
+    index_type& i3=Policy::index_from_container(c3);
+    index_type& i4=Policy::index_from_container(c4);
+    iterator  it=i3.begin();
+    i3.swap(i4);
+    i3.erase(it);
+  CATCH_SAFE_MODE(safe_mode::not_owner)
+
+  /* this, unlike the previous case, is indeed correct, test safe mode
+   * gets it right
+   */
+  { 
+    container   c3(c);
+    container   c4;
+    index_type& i3=Policy::index_from_container(c3);
+    index_type& i4=Policy::index_from_container(c4);
+    iterator  it=i3.begin();
+    i3.swap(i4);
+    i4.erase(it);
+  }
+
+  TRY_SAFE_MODE
+    iterator it=i.end();
+    typename container::iterator it2=project<0>(c2,it);
+  CATCH_SAFE_MODE(safe_mode::not_owner)
+
+  TRY_SAFE_MODE
+    iterator it=Policy::insert(i,Policy::another_value());
+    typename container::iterator it2=project<0>(c,it);
+    i.erase(it);
+    value_type e=*it2;
+  CATCH_SAFE_MODE(safe_mode::invalid_iterator)
+
+  /* testcase for bug reported at
+   * http://lists.boost.org/boost-users/2006/02/17230.php
+   */
+  {
+    container c3(c);
+    index_type& i3=Policy::index_from_container(c3);
+    iterator it=i3.end();
+    i3.clear();
+    it=i3.end();
+  }
+
+  /* testcase for doppelganger bug of that discovered for STLport at
+   * http://lists.boost.org/Archives/boost/2006/04/102740.php
+   */
+  {
+    container c3;
+    index_type& i3=Policy::index_from_container(c3);
+    iterator it=i3.end();
+    i3.clear();
+    iterator it2=it;
+    BOOST_TEST(it2==i3.end());
+  }
+}
+
+template<typename Policy>
+static void local_test_safe_mode(
+  std::bidirectional_iterator_tag
+  BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Policy))
+{
+  ::local_test_safe_mode<Policy>(std::forward_iterator_tag());
+
+  typedef typename Policy::container    container;
+  typedef typename Policy::index_type   index_type;
+  typedef typename index_type::iterator iterator;
+
+  container   c;
+  index_type& i=Policy::index_from_container(c);
+  Policy::insert(i,Policy::some_value());
+
+  TRY_SAFE_MODE
+    iterator it=i.begin();
+    --it;
+  CATCH_SAFE_MODE(safe_mode::not_decrementable_iterator)
+}
+
+template<typename Policy>
+static void local_test_safe_mode(
+  std::random_access_iterator_tag
+  BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Policy))
+{
+  ::local_test_safe_mode<Policy>(std::bidirectional_iterator_tag());
+
+  typedef typename Policy::container    container;
+  typedef typename Policy::index_type   index_type;
+  typedef typename index_type::iterator iterator;
+
+  container   c;
+  index_type& i=Policy::index_from_container(c);
+  Policy::insert(i,Policy::some_value());
+
+  TRY_SAFE_MODE
+    iterator it=i.begin();
+    it+=2;
+  CATCH_SAFE_MODE(safe_mode::out_of_bounds)
+
+  TRY_SAFE_MODE
+    iterator it=i.begin();
+    it-=1;
+  CATCH_SAFE_MODE(safe_mode::out_of_bounds)
+}
+
+template<typename Policy>
+static void local_test_safe_mode()
+{
+  typedef typename Policy::index_type::iterator::iterator_category category;
+  ::local_test_safe_mode<Policy>(category());
+}
+
+template<typename Policy>
+static void local_test_safe_mode_with_rearrange()
+{
+  ::local_test_safe_mode<Policy>();
+
+  typedef typename Policy::container    container;
+  typedef typename Policy::index_type   index_type;
+  typedef typename index_type::iterator iterator;
+
+  container   c;
+  index_type& i=Policy::index_from_container(c);
+  Policy::insert(i,Policy::some_value());
+
+  TRY_SAFE_MODE
+    iterator it;
+    i.splice(it,i,i.begin(),i.end());
+  CATCH_SAFE_MODE(safe_mode::invalid_iterator)
+
+  TRY_SAFE_MODE
+    container   c2(c);
+    index_type& i2=Policy::index_from_container(c2);
+    iterator    it2=i2.begin();
+    iterator    it=i.begin();
+    i.splice(it2,i2,it);
+  CATCH_SAFE_MODE(safe_mode::not_owner)
+
+  TRY_SAFE_MODE
+    i.splice(i.begin(),i,i.begin(),i.end());
+  CATCH_SAFE_MODE(safe_mode::inside_range)
+
+  TRY_SAFE_MODE
+    i.splice(i.begin(),i,i.end(),i.begin());
+  CATCH_SAFE_MODE(safe_mode::invalid_range)
+
+  TRY_SAFE_MODE
+    i.splice(i.begin(),i);
+  CATCH_SAFE_MODE(safe_mode::same_container)
+
+  TRY_SAFE_MODE
+    iterator it;
+    i.relocate(it,i.begin(),i.end());
+  CATCH_SAFE_MODE(safe_mode::invalid_iterator)
+
+  TRY_SAFE_MODE
+    i.relocate(i.begin(),i.begin(),i.end());
+  CATCH_SAFE_MODE(safe_mode::inside_range)
+
+  TRY_SAFE_MODE
+    i.relocate(i.begin(),i.end(),i.begin());
+  CATCH_SAFE_MODE(safe_mode::invalid_range)
+}
+
+template<typename MultiIndexContainer,int N>
+struct index_policy_base
+{
+  typedef MultiIndexContainer                   container;
+  typedef typename nth_index<container,N>::type index_type;
+
+  static index_type& index_from_container(container& c){return get<N>(c);}
+};
+
+template<typename MultiIndexContainer,int N>
+struct key_based_index_policy_base:
+  index_policy_base<MultiIndexContainer,N>
+{
+  typedef index_policy_base<MultiIndexContainer,N> super;
+
+  typedef typename super::container       container;
+  typedef typename super::index_type      index_type;
+  typedef typename index_type::value_type value_type;
+  typedef typename index_type::iterator   iterator;
+
+  static iterator insert(index_type& i,const value_type& v)
+  {
+    return i.insert(v).first;
+  }
+
+  static iterator insert(index_type& i,iterator it,const value_type& v)
+  {
+    return i.insert(it,v);
+  }
+};
+
+template<typename MultiIndexContainer,int N>
+struct non_key_based_index_policy_base:
+  index_policy_base<MultiIndexContainer,N>
+{
+  typedef index_policy_base<MultiIndexContainer,N> super;
+
+  typedef typename super::container       container;
+  typedef typename super::index_type      index_type;
+  typedef typename index_type::value_type value_type;
+  typedef typename index_type::iterator   iterator;
+
+  static iterator insert(index_type& i,const value_type& v)
+  {
+    return i.push_back(v).first;
+  }
+
+  static iterator insert(index_type& i,iterator it,const value_type& v)
+  {
+    return i.insert(it,v).first;
+  }
+};
+
+struct employee_set_policy_base
+{
+  static employee    some_value(){return employee(0,"Joe",31,1123);}
+  static employee    another_value(){return employee(1,"Robert",27,5601);}
+};
+
+struct employee_set_policy:
+  employee_set_policy_base,
+  key_based_index_policy_base<employee_set,0>
+{};
+
+struct employee_set_by_name_policy:
+  employee_set_policy_base,
+  key_based_index_policy_base<employee_set,1>
+{};
+
+struct employee_set_as_inserted_policy:
+  employee_set_policy_base,
+  non_key_based_index_policy_base<employee_set,3>
+{};
+
+struct employee_set_randomly_policy:
+  employee_set_policy_base,
+  non_key_based_index_policy_base<employee_set,5>
+{};
+
+template<typename IntegralBimap>
+static void test_integral_bimap()
+{
+  typedef typename IntegralBimap::value_type value_type;
+  typedef typename IntegralBimap::iterator   iterator;
+
+  TRY_SAFE_MODE
+    IntegralBimap bm;
+    iterator it=bm.insert(value_type(0,0)).first;
+    bm.insert(value_type(1,1));
+    bm.modify(it,increment_first);
+    value_type v=*it;
+    prevent_unused_var_warning(v);
+  CATCH_SAFE_MODE(safe_mode::invalid_iterator)
+
+  TRY_SAFE_MODE
+    IntegralBimap bm;
+    iterator it=bm.insert(value_type(0,0)).first;
+    bm.insert(value_type(1,1));
+    bm.modify(it,increment_second);
+    pair_of_ints v=*it;
+    prevent_unused_var_warning(v);
+  CATCH_SAFE_MODE(safe_mode::invalid_iterator)
+}
+
+void test_safe_mode()
+{
+  local_test_safe_mode<employee_set_policy>();
+  local_test_safe_mode<employee_set_by_name_policy>();
+  local_test_safe_mode_with_rearrange<employee_set_as_inserted_policy>();
+  local_test_safe_mode_with_rearrange<employee_set_randomly_policy>();
+
+  typedef multi_index_container<
+    pair_of_ints,
+    indexed_by<
+      ordered_unique<BOOST_MULTI_INDEX_MEMBER(pair_of_ints,int,first)>,
+      ordered_unique<BOOST_MULTI_INDEX_MEMBER(pair_of_ints,int,second)> >
+  > bimap0_type;
+
+  test_integral_bimap<bimap0_type>();
+
+  typedef multi_index_container<
+    pair_of_ints,
+    indexed_by<
+      ordered_unique<BOOST_MULTI_INDEX_MEMBER(pair_of_ints,int,first)>,
+      hashed_unique<BOOST_MULTI_INDEX_MEMBER(pair_of_ints,int,second)> >
+  > bimap1_type;
+
+  test_integral_bimap<bimap1_type>();
+
+  typedef multi_index_container<
+    pair_of_ints,
+    indexed_by<
+      hashed_unique<BOOST_MULTI_INDEX_MEMBER(pair_of_ints,int,first)>,
+      ordered_unique<BOOST_MULTI_INDEX_MEMBER(pair_of_ints,int,second)> >
+  > bimap2_type;
+
+  test_integral_bimap<bimap2_type>();
+
+  typedef multi_index_container<
+    pair_of_ints,
+    indexed_by<
+      hashed_unique<BOOST_MULTI_INDEX_MEMBER(pair_of_ints,int,first)>,
+      hashed_unique<BOOST_MULTI_INDEX_MEMBER(pair_of_ints,int,second)> >
+  > bimap3_type;
+
+  test_integral_bimap<bimap3_type>();
+}
diff --git a/src/boost/libs/multi_index/test/test_safe_mode.hpp b/src/boost/libs/multi_index/test/test_safe_mode.hpp
new file mode 100644
index 000000000..156d7b275
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_safe_mode.hpp
@@ -0,0 +1,11 @@
+/* Boost.MultiIndex test for safe mode.
+ *
+ * Copyright 2003-2008 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+void test_safe_mode();
diff --git a/src/boost/libs/multi_index/test/test_safe_mode_main.cpp b/src/boost/libs/multi_index/test/test_safe_mode_main.cpp
new file mode 100644
index 000000000..4bb892c6c
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_safe_mode_main.cpp
@@ -0,0 +1,19 @@
+/* Boost.MultiIndex test for safe mode.
+ *
+ * Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include <boost/detail/lightweight_test.hpp>
+#include "test_safe_mode.hpp"
+
+int main()
+{
+  test_safe_mode();
+  return boost::report_errors();
+}
+
diff --git a/src/boost/libs/multi_index/test/test_serialization.cpp b/src/boost/libs/multi_index/test/test_serialization.cpp
new file mode 100644
index 000000000..6c5b8f6e7
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_serialization.cpp
@@ -0,0 +1,21 @@
+/* Boost.MultiIndex test for serialization.
+ *
+ * Copyright 2003-2008 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include "test_serialization.hpp"
+#include "test_serialization1.hpp"
+#include "test_serialization2.hpp"
+#include "test_serialization3.hpp"
+
+void test_serialization()
+{
+  test_serialization1();
+  test_serialization2();
+  test_serialization3();
+}
diff --git a/src/boost/libs/multi_index/test/test_serialization.hpp b/src/boost/libs/multi_index/test/test_serialization.hpp
new file mode 100644
index 000000000..8e66535fe
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_serialization.hpp
@@ -0,0 +1,11 @@
+/* Boost.MultiIndex test for serialization.
+ *
+ * Copyright 2003-2008 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+void test_serialization();
diff --git a/src/boost/libs/multi_index/test/test_serialization1.cpp b/src/boost/libs/multi_index/test/test_serialization1.cpp
new file mode 100644
index 000000000..f41c9ca5a
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_serialization1.cpp
@@ -0,0 +1,66 @@
+/* Boost.MultiIndex test for serialization, part 1.
+ *
+ * Copyright 2003-2008 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include "test_serialization1.hpp"
+#include "test_serialization_template.hpp"
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/multi_index/ordered_index.hpp>
+#include <boost/multi_index/sequenced_index.hpp>
+#include <boost/multi_index/random_access_index.hpp>
+#include <boost/multi_index/key_extractors.hpp>
+#include "non_std_allocator.hpp"
+
+using namespace boost::multi_index;
+
+void test_serialization1()
+{
+  {
+    typedef multi_index_container<
+      int,
+      indexed_by<
+        sequenced<>,
+        sequenced<>,
+        random_access<>
+      >
+    > multi_index_t;
+
+    multi_index_t m;
+    for(int i=0;i<100;++i)m.push_back(i);
+    m.reverse();
+    test_serialization(m);
+
+    m.clear();
+    for(int j=50;j<100;++j)m.push_back(j);
+    for(int k=0;k<50;++k)m.push_back(k);
+    m.sort();
+    test_serialization(m);
+  }
+  {
+    typedef multi_index_container<
+      int,
+      indexed_by<
+        random_access<>,
+        sequenced<>,
+        ordered_non_unique<identity<int> >
+      >,
+      non_std_allocator<int>
+    > multi_index_t;
+
+    multi_index_t m;
+    for(int i=0;i<100;++i){
+      m.push_back(i);
+      m.push_back(i);
+      m.push_back(i);
+    }
+    m.reverse();
+    test_serialization(m);
+  }
+}
diff --git a/src/boost/libs/multi_index/test/test_serialization1.hpp b/src/boost/libs/multi_index/test/test_serialization1.hpp
new file mode 100644
index 000000000..2db6ec8d3
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_serialization1.hpp
@@ -0,0 +1,11 @@
+/* Boost.MultiIndex test for serialization, part 1.
+ *
+ * Copyright 2003-2008 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+void test_serialization1();
diff --git a/src/boost/libs/multi_index/test/test_serialization2.cpp b/src/boost/libs/multi_index/test/test_serialization2.cpp
new file mode 100644
index 000000000..1c93c5fa6
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_serialization2.cpp
@@ -0,0 +1,81 @@
+/* Boost.MultiIndex test for serialization, part 2.
+ *
+ * Copyright 2003-2008 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include "test_serialization2.hpp"
+#include "test_serialization_template.hpp"
+
+#include <boost/multi_index/ordered_index.hpp>
+#include <boost/multi_index/sequenced_index.hpp>
+#include <boost/multi_index/random_access_index.hpp>
+#include <boost/multi_index/key_extractors.hpp>
+#include "non_std_allocator.hpp"
+#include "pair_of_ints.hpp"
+
+using namespace boost::multi_index;
+
+void test_serialization2()
+{
+  {
+    typedef multi_index_container<
+      pair_of_ints,
+      indexed_by<
+        ordered_unique<
+          BOOST_MULTI_INDEX_MEMBER(pair_of_ints,int,first)
+        >,
+        ordered_non_unique<
+          BOOST_MULTI_INDEX_MEMBER(pair_of_ints,int,second)
+        >,
+        random_access<>,
+        sequenced<>
+      >,
+      non_std_allocator<pair_of_ints>
+    > multi_index_t;
+
+    multi_index_t m;
+    test_serialization(m);
+
+    m.insert(pair_of_ints(4,0));
+    test_serialization(m);
+
+    m.insert(pair_of_ints(3,1));
+    m.insert(pair_of_ints(2,1));
+    test_serialization(m);
+
+    m.insert(pair_of_ints(1,1));
+    test_serialization(m);
+
+    m.insert(pair_of_ints(0,0));
+    test_serialization(m);
+
+    m.insert(pair_of_ints(5,1));
+    m.insert(pair_of_ints(7,1));
+    m.insert(pair_of_ints(6,1));
+    test_serialization(m);
+    
+    m.insert(pair_of_ints(8,1));
+    m.insert(pair_of_ints(9,1));
+    m.insert(pair_of_ints(12,1));
+    m.insert(pair_of_ints(11,1));
+    m.insert(pair_of_ints(10,1));
+    test_serialization(m);
+
+    /* testcase for bug reported at
+     * http://lists.boost.org/boost-users/2006/05/19362.php
+     */
+
+    m.clear();
+    m.insert(pair_of_ints(0,0));
+    m.insert(pair_of_ints(1,0));
+    m.insert(pair_of_ints(2,1));
+    m.insert(pair_of_ints(4,2));
+    m.insert(pair_of_ints(3,2));
+    test_serialization(m);
+  }
+}
diff --git a/src/boost/libs/multi_index/test/test_serialization2.hpp b/src/boost/libs/multi_index/test/test_serialization2.hpp
new file mode 100644
index 000000000..6382882f6
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_serialization2.hpp
@@ -0,0 +1,11 @@
+/* Boost.MultiIndex test for serialization, part 2.
+ *
+ * Copyright 2003-2008 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+void test_serialization2();
diff --git a/src/boost/libs/multi_index/test/test_serialization3.cpp b/src/boost/libs/multi_index/test/test_serialization3.cpp
new file mode 100644
index 000000000..5a759c1d5
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_serialization3.cpp
@@ -0,0 +1,216 @@
+/* Boost.MultiIndex test for serialization, part 3.
+ *
+ * Copyright 2003-2018 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include "test_serialization3.hpp"
+#include "test_serialization_template.hpp"
+
+#include <boost/move/core.hpp>
+#include <boost/multi_index/hashed_index.hpp>
+#include <boost/multi_index/sequenced_index.hpp>
+#include <boost/multi_index/ordered_index.hpp>
+#include <boost/multi_index/key_extractors.hpp>
+#include "non_std_allocator.hpp"
+
+struct non_default_ctble
+{
+  non_default_ctble(int n_):n(n_){}
+
+  bool operator==(const non_default_ctble& x)const{return n==x.n;}
+
+  int n;
+};
+
+#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
+namespace boost{
+namespace serialization{
+#endif
+
+template<class Archive>
+void save_construct_data(
+  Archive& ar,const non_default_ctble* p,const unsigned int version)
+{
+  if(version<3)return;
+
+  ar<<boost::serialization::make_nvp("n",p->n);
+}
+
+template<class Archive>
+void load_construct_data(
+  Archive& ar,non_default_ctble* p,const unsigned int version)
+{
+  if(version<3)return;
+
+  int n=0;
+  ar>>boost::serialization::make_nvp("n",n);
+  ::new(p)non_default_ctble(n);
+}
+
+template<class Archive>
+void serialize(Archive&,non_default_ctble&,const unsigned int)
+{
+}
+
+#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
+} /* namespace serialization */
+} /* namespace boost*/
+#endif
+
+namespace boost{
+namespace serialization{
+template<> struct version<non_default_ctble>
+{
+  BOOST_STATIC_CONSTANT(int,value=3);
+};
+} /* namespace serialization */
+} /* namespace boost*/
+
+struct non_copyable
+{
+  non_copyable(int n_=0):n(n_){}
+  non_copyable(BOOST_RV_REF(non_copyable) x):n(x.n){}
+
+  bool operator==(const non_copyable& x)const{return n==x.n;}
+  bool operator<(const non_copyable& x)const{return n<x.n;}
+
+  int n;
+
+private:
+  BOOST_MOVABLE_BUT_NOT_COPYABLE(non_copyable)
+};
+
+#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
+namespace boost{
+namespace serialization{
+#endif
+
+template<class Archive>
+void serialize(Archive& ar,non_copyable& x,const unsigned int)
+{
+  ar&boost::serialization::make_nvp("n",x.n);
+}
+
+#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
+} /* namespace serialization */
+} /* namespace boost*/
+#endif
+
+using namespace boost::multi_index;
+
+void test_serialization3()
+{
+  const int N=100;
+  const int SHUFFLE=10232;
+
+  typedef multi_index_container<
+    int,
+    indexed_by<
+      hashed_unique<identity<int> >,
+      sequenced<>
+    >,
+    non_std_allocator<int>
+  > hashed_set;
+
+  typedef hashed_set::iterator       iterator;
+  typedef hashed_set::local_iterator local_iterator;
+
+  hashed_set hs;
+
+  for(int i=0;i<N;++i){
+    hs.insert(i*SHUFFLE);
+  }
+
+  std::ostringstream oss;
+  {
+    boost::archive::text_oarchive oa(oss);
+    oa<<const_cast<const hashed_set&>(hs);
+
+    std::vector<iterator> its(N);
+    for(int i=0;i<N;++i){
+      iterator it=hs.find(i*SHUFFLE);
+      its.push_back(it);
+      oa<<const_cast<const iterator&>(its.back());
+    }
+    iterator it=hs.end();
+    oa<<const_cast<const iterator&>(it);
+
+    std::vector<local_iterator> lits(2*N);
+    for(std::size_t buc=0;buc<hs.bucket_count();++buc){
+      for(local_iterator lit=hs.begin(buc),lit_end=hs.end(buc);
+          lit!=lit_end;++lit){
+        oa<<*lit;
+        lits.push_back(lit);
+        oa<<const_cast<const local_iterator&>(lits.back());
+      }
+      local_iterator lit2=hs.end(buc);
+      lits.push_back(lit2);
+      oa<<const_cast<const local_iterator&>(lits.back());
+    }
+  }
+
+  hashed_set hs2;
+  std::istringstream iss(oss.str());
+  boost::archive::text_iarchive ia(iss);
+  ia>>hs2;
+  BOOST_TEST(boost::multi_index::get<1>(hs)==boost::multi_index::get<1>(hs2));
+
+  for(int j=0;j<N;++j){
+    iterator it;
+    ia>>it;
+    BOOST_TEST(*it==j*SHUFFLE);
+  }
+  iterator it;
+  ia>>it;
+  BOOST_TEST(it==hs2.end());
+
+  for(std::size_t buc=0;buc<hs2.bucket_count();++buc){
+    for(std::size_t k=0;k<hs2.bucket_size(buc);++k){
+      int n;
+      local_iterator it_;
+      ia>>n;
+      ia>>it_;
+      BOOST_TEST(*it_==n);
+    }
+    local_iterator it2;
+    ia>>it2;
+    BOOST_TEST(it2==hs2.end(buc));
+  }
+
+  {
+    typedef multi_index_container<
+      non_default_ctble,
+      indexed_by<
+        ordered_unique<
+          BOOST_MULTI_INDEX_MEMBER(non_default_ctble,int,n)
+        >
+      >
+    > multi_index_t;
+
+    multi_index_t m;
+    for(int i=0;i<100;++i)m.insert(non_default_ctble(i));
+    test_serialization(m);
+  }
+
+  {
+    /* testcase for https://svn.boost.org/trac10/ticket/13478 */
+
+    typedef multi_index_container<
+      non_copyable,
+      indexed_by<
+        ordered_unique<
+          BOOST_MULTI_INDEX_MEMBER(non_copyable,int,n)
+        >
+      >
+    > multi_index_t;
+
+    multi_index_t m;
+    for(int i=0;i<100;++i)m.emplace(i);
+    test_serialization(m);
+  }
+}
diff --git a/src/boost/libs/multi_index/test/test_serialization3.hpp b/src/boost/libs/multi_index/test/test_serialization3.hpp
new file mode 100644
index 000000000..bb620c0b6
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_serialization3.hpp
@@ -0,0 +1,11 @@
+/* Boost.MultiIndex test for serialization, part 3.
+ *
+ * Copyright 2003-2008 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+void test_serialization3();
diff --git a/src/boost/libs/multi_index/test/test_serialization_main.cpp b/src/boost/libs/multi_index/test/test_serialization_main.cpp
new file mode 100644
index 000000000..43a698a77
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_serialization_main.cpp
@@ -0,0 +1,18 @@
+/* Boost.MultiIndex test for serialization.
+ *
+ * Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include <boost/detail/lightweight_test.hpp>
+#include "test_serialization.hpp"
+
+int main()
+{
+  test_serialization();
+  return boost::report_errors();
+}
diff --git a/src/boost/libs/multi_index/test/test_serialization_template.hpp b/src/boost/libs/multi_index/test/test_serialization_template.hpp
new file mode 100644
index 000000000..b7a9a9c92
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_serialization_template.hpp
@@ -0,0 +1,105 @@
+/* Boost.MultiIndex serialization tests template.
+ *
+ * Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/archive/text_oarchive.hpp>
+#include <boost/archive/text_iarchive.hpp>
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/mpl/size.hpp>
+#include "pre_multi_index.hpp"
+#include <boost/multi_index_container.hpp>
+#include <string>
+#include <sstream>
+#include <vector>
+
+template<int N>
+struct all_indices_equal_helper
+{
+  template<class MultiIndexContainer>
+  static bool compare(
+    const MultiIndexContainer& m1,const MultiIndexContainer& m2)
+  {
+    if(!(boost::multi_index::get<N>(m1)==boost::multi_index::get<N>(m2))){
+      return false;
+    }
+    return all_indices_equal_helper<N-1>::compare(m1,m2);
+  }
+};
+
+template<>
+struct all_indices_equal_helper<0>
+{
+  template<class MultiIndexContainer>
+  static bool compare(
+    const MultiIndexContainer&,const MultiIndexContainer&)
+  {
+    return true;
+  }
+};
+
+template<class MultiIndexContainer>
+bool all_indices_equal(
+  const MultiIndexContainer& m1,const MultiIndexContainer& m2)
+{
+  BOOST_STATIC_CONSTANT(int,
+    N=boost::mpl::size<
+    BOOST_DEDUCED_TYPENAME MultiIndexContainer::index_type_list>::type::value);
+
+  return all_indices_equal_helper<N-1>::compare(m1,m2);
+}
+
+template<class MultiIndexContainer>
+void test_serialization(const MultiIndexContainer& m)
+{
+  typedef typename MultiIndexContainer::iterator       iterator;
+  typedef typename MultiIndexContainer::const_iterator const_iterator;
+
+  std::ostringstream oss;
+  {
+    boost::archive::text_oarchive oa(oss);
+    oa<<m;
+
+    std::vector<const_iterator> its(m.size());
+    const_iterator              it_end=m.end();
+    for(const_iterator it=m.begin();it!=it_end;++it){
+      its.push_back(it);
+      oa<<const_cast<const const_iterator&>(its.back());
+    }
+    oa<<const_cast<const const_iterator&>(it_end);
+  }
+
+  MultiIndexContainer m2;
+  std::istringstream iss(oss.str());
+  boost::archive::text_iarchive ia(iss);
+  ia>>m2;
+  BOOST_TEST(all_indices_equal(m,m2));
+
+  iterator it_end=m2.end();
+  for(iterator it=m2.begin();it!=it_end;++it){
+    iterator it2;
+    ia>>it2;
+    BOOST_TEST(it==it2);
+
+    /* exercise safe mode with this (unchecked) iterator */
+    BOOST_TEST(*it==*it2);
+    m2.erase(it,it2);
+    m2.erase(it2,it2);
+    m2.erase(it2,it);
+    iterator it3(++it2);
+    iterator it4;
+    it4=--it2;
+    BOOST_TEST(it==it4);
+    BOOST_TEST(it==boost::multi_index::project<0>(m2,it4));
+  }
+  iterator it2;
+  ia>>it2;
+  BOOST_TEST(it_end==it2);
+  BOOST_TEST(it_end==boost::multi_index::project<0>(m2,it2));
+}
diff --git a/src/boost/libs/multi_index/test/test_set_ops.cpp b/src/boost/libs/multi_index/test/test_set_ops.cpp
new file mode 100644
index 000000000..0e9a70da8
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_set_ops.cpp
@@ -0,0 +1,127 @@
+/* Boost.MultiIndex test for standard set operations.
+ *
+ * Copyright 2003-2014 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include "test_set_ops.hpp"
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <algorithm>
+#include <vector>
+#include "pre_multi_index.hpp"
+#include "employee.hpp"
+#include <boost/detail/lightweight_test.hpp>
+
+using namespace boost::multi_index;
+
+struct type1{};
+
+struct type2
+{
+private:
+  operator type1()const{return type1();}
+};
+
+struct type3
+{
+  operator type1()const{return type1();}
+};
+
+struct less_type12
+{
+  bool operator()(type1,type1)const{return false;}
+  bool operator()(type1,type2)const{return false;}
+  bool operator()(type2,type1)const{return false;}
+};
+
+bool less_type1_f(type1,type1){return false;}
+
+struct hash_type12
+{
+  std::size_t operator()(type1)const{return 0;}
+  std::size_t operator()(type2)const{return 0;}
+};
+
+struct eq_type12
+{
+  bool operator()(type1,type1)const{return true;}
+  bool operator()(type1,type2)const{return true;}
+  bool operator()(type2,type1)const{return true;}
+};
+
+void test_set_ops()
+{
+  employee_set               es;
+  employee_set_by_name&      i1=get<by_name>(es);
+  const employee_set_by_age& i2=get<age>(es);
+  employee_set_by_ssn&       i4=get<ssn>(es);
+
+  es.insert(employee(0,"Joe",31,1123));
+  es.insert(employee(1,"Robert",27,5601));
+  es.insert(employee(2,"John",40,7889));
+  es.insert(employee(3,"Albert",20,9012));
+  es.insert(employee(4,"John",57,1002));
+
+  BOOST_TEST(i1.find("John")->name=="John");
+  BOOST_TEST(i2.find(41)==i2.end());
+  BOOST_TEST(i4.find(5601)->name=="Robert");
+
+  BOOST_TEST(i1.count("John")==2);
+  BOOST_TEST(es.count(employee(10,"",-1,0))==0);
+  BOOST_TEST(i4.count(7881)==0);
+
+  BOOST_TEST(
+    std::distance(
+      i2.lower_bound(31),
+      i2.upper_bound(60))==3);
+
+  std::pair<employee_set_by_name::iterator,employee_set_by_name::iterator> p=
+    i1.equal_range("John");
+  BOOST_TEST(std::distance(p.first,p.second)==2);
+
+  p=i1.equal_range("Serena");
+  BOOST_TEST(p.first==i1.end()&&p.second==i1.end());
+
+  std::pair<employee_set_by_age::iterator,employee_set_by_age::iterator> p2=
+    i2.equal_range(30);
+  BOOST_TEST(p2.first==p2.second&&p2.first->age==31);
+
+  /* check promotion detection plays nice with private conversion */
+
+  multi_index_container<
+    type1,
+    indexed_by<
+      ordered_unique<identity<type1>,less_type12>,
+      hashed_unique<identity<type1>,hash_type12,eq_type12>
+    >
+  > c;
+  c.insert(type1());
+
+  BOOST_TEST(c.find(type2())==c.begin());
+  BOOST_TEST(c.count(type2())==1);
+  BOOST_TEST(c.lower_bound(type2())==c.begin());
+  BOOST_TEST(c.upper_bound(type2())==c.end());
+  BOOST_TEST(c.equal_range(type2())==std::make_pair(c.begin(),c.end()));
+
+  BOOST_TEST(c.get<1>().find(type2())==c.get<1>().begin());
+  BOOST_TEST(c.get<1>().count(type2())==1);
+  BOOST_TEST(c.get<1>().equal_range(type2())==
+             std::make_pair(c.get<1>().begin(),c.get<1>().end()));
+
+  /* check promotion detection does not break with functions */
+
+  multi_index_container<
+    type1,
+    indexed_by<
+      ordered_unique<identity<type1>,bool(*)(type1,type1)>
+    >
+  > c2(boost::make_tuple(boost::make_tuple(identity<type1>(),&less_type1_f)));
+  c2.insert(type1());
+
+  BOOST_TEST(c2.find(type3())==c2.begin());
+}
diff --git a/src/boost/libs/multi_index/test/test_set_ops.hpp b/src/boost/libs/multi_index/test/test_set_ops.hpp
new file mode 100644
index 000000000..dc333c887
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_set_ops.hpp
@@ -0,0 +1,11 @@
+/* Boost.MultiIndex test for standard set operations.
+ *
+ * Copyright 2003-2008 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+void test_set_ops();
diff --git a/src/boost/libs/multi_index/test/test_set_ops_main.cpp b/src/boost/libs/multi_index/test/test_set_ops_main.cpp
new file mode 100644
index 000000000..9a45a73e2
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_set_ops_main.cpp
@@ -0,0 +1,18 @@
+/* Boost.MultiIndex test for standard set operations.
+ *
+ * Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include <boost/detail/lightweight_test.hpp>
+#include "test_set_ops.hpp"
+
+int main()
+{
+  test_set_ops();
+  return boost::report_errors();
+}
diff --git a/src/boost/libs/multi_index/test/test_special_set_ops.cpp b/src/boost/libs/multi_index/test/test_special_set_ops.cpp
new file mode 100644
index 000000000..516a2cc6a
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_special_set_ops.cpp
@@ -0,0 +1,95 @@
+/* Boost.MultiIndex test for special set operations.
+ *
+ * Copyright 2003-2015 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include "test_special_set_ops.hpp"
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <algorithm>
+#include <sstream>
+#include "pre_multi_index.hpp"
+#include "employee.hpp"
+#include <boost/detail/lightweight_test.hpp>
+
+using namespace boost::multi_index;
+
+static int string_to_int(const std::string& str)
+{
+  std::istringstream iss(str);
+  int                res;
+  iss>>res;
+  return res;
+}
+
+struct comp_int_string
+{
+  bool operator()(int x,const std::string& y)const
+  {
+    return x<string_to_int(y);
+  }
+
+  bool operator()(const std::string& x,int y)const
+  {
+    return string_to_int(x)<y;
+  }
+};
+
+struct hash_string_as_int
+{
+  int operator()(const std::string& x)const
+  {
+    return static_cast<int>(boost::hash<int>()(string_to_int(x)));
+  }
+};
+
+struct eq_string_int
+{
+  bool operator()(int x,const std::string& y)const
+  {
+    return x==string_to_int(y);
+  }
+
+  bool operator()(const std::string& x,int y)const
+  {
+    return operator()(y,x);
+  }
+};
+
+void test_special_set_ops()
+{
+  employee_set es;
+
+  es.insert(employee(0,"Joe",31,1123));
+  es.insert(employee(1,"Robert",27,5601));
+  es.insert(employee(2,"John",40,7889));
+  es.insert(employee(3,"Albert",20,9012));
+  es.insert(employee(4,"John",57,1002));
+
+  std::pair<employee_set_by_ssn::iterator,employee_set_by_ssn::iterator> p=
+    get<ssn>(es).equal_range(
+      "7889",hash_string_as_int(),eq_string_int());
+
+  BOOST_TEST(std::distance(p.first,p.second)==1&&(p.first)->id==2);
+
+  BOOST_TEST(
+    get<ssn>(es).count(
+      "5601",hash_string_as_int(),eq_string_int())==1);
+
+  BOOST_TEST(
+    get<ssn>(es).find(
+      "1123",hash_string_as_int(),eq_string_int())->name=="Joe");
+
+  BOOST_TEST(
+    std::distance(
+      get<age>(es).lower_bound("27",comp_int_string()),
+      get<age>(es).upper_bound("40",comp_int_string()))==3);
+
+  BOOST_TEST(es.count(2,employee::comp_id())==1);
+  BOOST_TEST(es.count(5,employee::comp_id())==0);
+}
diff --git a/src/boost/libs/multi_index/test/test_special_set_ops.hpp b/src/boost/libs/multi_index/test/test_special_set_ops.hpp
new file mode 100644
index 000000000..a9434de58
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_special_set_ops.hpp
@@ -0,0 +1,11 @@
+/* Boost.MultiIndex test for special set operations.
+ *
+ * Copyright 2003-2008 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+void test_special_set_ops();
diff --git a/src/boost/libs/multi_index/test/test_special_set_ops_main.cpp b/src/boost/libs/multi_index/test/test_special_set_ops_main.cpp
new file mode 100644
index 000000000..843f86d0c
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_special_set_ops_main.cpp
@@ -0,0 +1,18 @@
+/* Boost.MultiIndex test for special set operations.
+ *
+ * Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include <boost/detail/lightweight_test.hpp>
+#include "test_special_set_ops.hpp"
+
+int main()
+{
+  test_special_set_ops();
+  return boost::report_errors();
+}
diff --git a/src/boost/libs/multi_index/test/test_update.cpp b/src/boost/libs/multi_index/test/test_update.cpp
new file mode 100644
index 000000000..56e9c827f
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_update.cpp
@@ -0,0 +1,281 @@
+/* Boost.MultiIndex test for replace(), modify() and modify_key().
+ *
+ * Copyright 2003-2018 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include "test_update.hpp"
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <algorithm>
+#include <cstddef>
+#include "pre_multi_index.hpp"
+#include "employee.hpp"
+#include "pair_of_ints.hpp"
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/next_prior.hpp>
+
+struct do_nothing
+{
+  template<typename T>
+  void operator()(const T&)const{}
+};
+
+struct null_hash
+{
+  template<typename T>
+  std::size_t operator()(const T&)const{return 0;}
+};
+
+struct assign_value
+{
+  assign_value(int n):n_(n){}
+
+  void operator()(int& x)const{x=n_;}
+
+  int n_;
+};
+
+template<class MultiIndexContainer>
+void test_stable_update()
+{
+  typedef typename MultiIndexContainer::iterator        iterator;
+  typedef typename MultiIndexContainer::size_type       size_type;
+  typedef typename MultiIndexContainer::difference_type difference_type;
+
+  MultiIndexContainer c;
+  c.insert(0);
+  c.insert(1);c.insert(1);
+  c.insert(2);c.insert(2);c.insert(2);c.insert(2);
+  c.insert(3);
+  c.insert(4);c.insert(4);c.insert(4);
+  c.insert(5);c.insert(5);
+  c.insert(6);
+  c.insert(7);
+  size_type num_elems=
+    c.count(0)+c.count(1)+c.count(2)+c.count(3)+
+    c.count(4)+c.count(5)+c.count(6)+c.count(7);
+
+  for(size_type n=c.size();n--;){
+    iterator it=boost::next(c.begin(),(difference_type)n);
+
+    c.replace(it,*it);
+    BOOST_TEST((size_type)std::distance(c.begin(),it)==n);
+
+    c.modify(it,do_nothing());
+    BOOST_TEST((size_type)std::distance(c.begin(),it)==n);
+
+    c.modify(it,do_nothing(),do_nothing());
+    BOOST_TEST((size_type)std::distance(c.begin(),it)==n);
+
+    for(int i=0;i<=8;++i){
+      MultiIndexContainer cpy(c);
+      bool b=c.modify(it,assign_value(i),assign_value(*it));
+      BOOST_TEST(b||(size_type)std::distance(c.begin(),it)==n);
+      BOOST_TEST(c.count(0)+c.count(1)+c.count(2)+c.count(3)+c.count(4)+
+                  c.count(5)+c.count(6)+c.count(7)+c.count(8)==num_elems);
+      if(b){
+        c=cpy;
+        it=boost::next(c.begin(),(difference_type)n);
+      }
+    }
+  }
+}
+
+using namespace boost::multi_index;
+
+void test_update()
+{
+  employee_set              es;
+  employee_set_as_inserted& i=get<as_inserted>(es);
+  employee_set_randomly&    r=get<randomly>(es);
+
+  es.insert(employee(0,"Joe",31,1123));
+  es.insert(employee(1,"Robert",27,5601));
+  es.insert(employee(2,"John",40,7889));
+  es.insert(employee(3,"Olbert",20,9012));
+  es.insert(employee(4,"John",57,1002));
+
+  employee_set::iterator             it=es.find(employee(0,"Joe",31,1123));
+  employee_set_as_inserted::iterator it1=
+    project<as_inserted>(es,get<name>(es).find("Olbert"));
+  employee_set_randomly::iterator    it2=
+    project<randomly>(es,get<age>(es).find(57));
+
+  BOOST_TEST(es.replace(it,*it));
+  BOOST_TEST(i.replace(it1,*it1));
+  BOOST_TEST(r.replace(it2,*it2));
+  BOOST_TEST(!es.replace(it,employee(3,"Joe",31,1123))&&it->id==0);
+  BOOST_TEST(es.replace(it,employee(0,"Joe",32,1123))&&it->age==32);
+  BOOST_TEST(i.replace(it1,employee(3,"Albert",20,9012))&&it1->name==
+                "Albert");
+  BOOST_TEST(!r.replace(it2,employee(4,"John",57,5601)));
+
+  {
+    typedef multi_index_container<
+      pair_of_ints,
+      indexed_by<
+        ordered_unique<BOOST_MULTI_INDEX_MEMBER(pair_of_ints,int,first)>,
+        hashed_unique<BOOST_MULTI_INDEX_MEMBER(pair_of_ints,int,second)>,
+        sequenced<> > >
+    int_int_set;
+
+    int_int_set iis;
+    nth_index<int_int_set,1>::type& ii1=get<1>(iis);
+    nth_index<int_int_set,2>::type& ii2=get<2>(iis);
+    iis.insert(pair_of_ints(0,0));
+    iis.insert(pair_of_ints(5,5));
+    iis.insert(pair_of_ints(10,10));
+
+    BOOST_TEST(!iis.replace(iis.begin(),pair_of_ints(5,0)));
+    BOOST_TEST(!ii2.replace(ii2.begin(),pair_of_ints(0,5)));
+    BOOST_TEST(!ii1.replace(project<1>(iis,iis.begin()),pair_of_ints(5,11)));
+    BOOST_TEST(!iis.replace(iis.begin(),pair_of_ints(11,5)));
+    BOOST_TEST(!iis.replace(boost::next(iis.begin()),pair_of_ints(10,5)));
+    BOOST_TEST(!ii1.replace(
+      project<1>(iis,boost::next(iis.begin())),pair_of_ints(5,10)));
+    BOOST_TEST(!iis.replace(boost::prior(iis.end()),pair_of_ints(5,10)));
+    BOOST_TEST(!ii2.replace(boost::prior(ii2.end()),pair_of_ints(10,5)));
+
+    BOOST_TEST(iis.modify(iis.begin(),increment_first));
+    BOOST_TEST(ii2.modify(ii2.begin(),increment_first));
+    BOOST_TEST(ii1.modify(project<1>(iis,iis.begin()),increment_first));
+    BOOST_TEST(ii2.modify(ii2.begin(),increment_first,decrement_first));
+
+    BOOST_TEST(!iis.modify(iis.begin(),increment_first,decrement_first));
+    BOOST_TEST(iis.size()==3);
+
+    BOOST_TEST(!iis.modify(iis.begin(),increment_first));
+    BOOST_TEST(iis.size()==2);
+
+    iis.insert(pair_of_ints(0,0));
+    BOOST_TEST(ii2.modify(boost::prior(ii2.end()),increment_second));
+    BOOST_TEST(iis.modify(iis.begin(),increment_second));
+    BOOST_TEST(ii2.modify(boost::prior(ii2.end()),increment_second));
+    BOOST_TEST(iis.modify(iis.begin(),increment_second,decrement_second));
+
+    BOOST_TEST(!ii2.modify(
+      boost::prior(ii2.end()),increment_second,decrement_second));
+    BOOST_TEST(ii2.size()==3);
+
+    BOOST_TEST(!ii2.modify(boost::prior(ii2.end()),increment_second));
+    BOOST_TEST(ii2.size()==2);
+
+    iis.insert(pair_of_ints(0,0));
+    BOOST_TEST(iis.modify_key(iis.begin(),increment_int));
+    BOOST_TEST(iis.modify_key(iis.begin(),increment_int,decrement_int));
+    BOOST_TEST(iis.modify_key(iis.begin(),increment_int));
+    BOOST_TEST(iis.modify_key(iis.begin(),increment_int));
+
+    BOOST_TEST(!iis.modify_key(iis.begin(),increment_int,decrement_int));
+    BOOST_TEST(iis.size()==3);
+
+    BOOST_TEST(!iis.modify_key(iis.begin(),increment_int));
+    BOOST_TEST(iis.size()==2);
+
+    nth_index_iterator<int_int_set,1>::type it_=ii1.find(5);
+    BOOST_TEST(ii1.modify_key(it_,increment_int));
+    BOOST_TEST(ii1.modify_key(it_,increment_int));
+    BOOST_TEST(ii1.modify_key(it_,increment_int,decrement_int));
+    BOOST_TEST(ii1.modify_key(it_,increment_int));
+
+    BOOST_TEST(!ii1.modify_key(it_,increment_int,decrement_int));
+    BOOST_TEST(ii1.size()==2);
+
+    BOOST_TEST(!ii1.modify_key(it_,increment_int));
+    BOOST_TEST(ii1.size()==1);
+  }
+  {
+    typedef multi_index_container<
+      pair_of_ints,
+      indexed_by<
+        hashed_unique<BOOST_MULTI_INDEX_MEMBER(pair_of_ints,int,first)>,
+        random_access<>,
+        ordered_unique<BOOST_MULTI_INDEX_MEMBER(pair_of_ints,int,second)> > >
+    int_int_set;
+
+    int_int_set iis;
+    nth_index<int_int_set,1>::type& ii1=get<1>(iis);
+    int_int_set::iterator p1=iis.insert(pair_of_ints(0,0)).first;
+    int_int_set::iterator p2=iis.insert(pair_of_ints(5,5)).first;
+    int_int_set::iterator p3=iis.insert(pair_of_ints(10,10)).first;
+
+    BOOST_TEST(!iis.replace(p1,pair_of_ints(5,0)));
+    BOOST_TEST(!ii1.replace(ii1.begin(),pair_of_ints(0,5)));
+    BOOST_TEST(!iis.replace(p1,pair_of_ints(5,11)));
+    BOOST_TEST(!iis.replace(p1,pair_of_ints(11,5)));
+    BOOST_TEST(!iis.replace(p2,pair_of_ints(10,5)));
+    BOOST_TEST(!iis.replace(p2,pair_of_ints(5,10)));
+    BOOST_TEST(!iis.replace(p3,pair_of_ints(5,10)));
+    BOOST_TEST(!ii1.replace(boost::prior(ii1.end()),pair_of_ints(10,5)));
+
+    BOOST_TEST(iis.modify(p1,increment_first));
+    BOOST_TEST(ii1.modify(ii1.begin(),increment_first));
+    BOOST_TEST(iis.modify(p1,increment_first));
+    BOOST_TEST(ii1.modify(ii1.begin(),increment_first,decrement_first));
+
+    BOOST_TEST(!iis.modify(p1,increment_first,decrement_first));
+    BOOST_TEST(iis.size()==3);
+
+    BOOST_TEST(!iis.modify(p1,increment_first));
+    BOOST_TEST(iis.size()==2);
+
+    p1=iis.insert(pair_of_ints(0,0)).first;
+    BOOST_TEST(ii1.modify(boost::prior(ii1.end()),increment_second));
+    BOOST_TEST(iis.modify(p1,increment_second,decrement_second));
+    BOOST_TEST(ii1.modify(boost::prior(ii1.end()),increment_second));
+    BOOST_TEST(iis.modify(p1,increment_second));
+
+    BOOST_TEST(!ii1.modify(
+      boost::prior(ii1.end()),increment_second,decrement_second));
+    BOOST_TEST(ii1.size()==3);
+
+    BOOST_TEST(!ii1.modify(boost::prior(ii1.end()),increment_second));
+    BOOST_TEST(ii1.size()==2);
+  }
+  {
+    typedef multi_index_container<
+      int,
+      indexed_by<
+        ordered_non_unique<identity<int> >
+      >
+    > int_multiset;
+    test_stable_update<int_multiset>();
+
+    typedef multi_index_container<
+      int,
+      indexed_by<
+        hashed_unique<identity<int> >
+      >
+    > int_hashed_set;
+    test_stable_update<int_hashed_set>();
+
+    typedef multi_index_container<
+      int,
+      indexed_by<
+        hashed_unique<identity<int> >
+      >
+    > int_hashed_multiset;
+    test_stable_update<int_hashed_multiset>();
+
+    typedef multi_index_container<
+      int,
+      indexed_by<
+        hashed_unique<identity<int>,null_hash>
+      >
+    > degenerate_int_hashed_set;
+    test_stable_update<degenerate_int_hashed_set>();
+
+    typedef multi_index_container<
+      int,
+      indexed_by<
+        hashed_non_unique<identity<int>,null_hash>
+      >
+    > degenerate_int_hashed_multiset;
+    test_stable_update<degenerate_int_hashed_multiset>();
+  }
+}
diff --git a/src/boost/libs/multi_index/test/test_update.hpp b/src/boost/libs/multi_index/test/test_update.hpp
new file mode 100644
index 000000000..ec7424b64
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_update.hpp
@@ -0,0 +1,11 @@
+/* Boost.MultiIndex test for replace(), modify() and modify_key().
+ *
+ * Copyright 2003-2008 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+void test_update();
diff --git a/src/boost/libs/multi_index/test/test_update_main.cpp b/src/boost/libs/multi_index/test/test_update_main.cpp
new file mode 100644
index 000000000..4fa2dba1b
--- /dev/null
+++ b/src/boost/libs/multi_index/test/test_update_main.cpp
@@ -0,0 +1,18 @@
+/* Boost.MultiIndex test for replace(), modify() and modify_key().
+ *
+ * Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#include <boost/detail/lightweight_test.hpp>
+#include "test_update.hpp"
+
+int main()
+{
+  test_update();
+  return boost::report_errors();
+}
diff --git a/src/boost/libs/multi_index/test_results.svg b/src/boost/libs/multi_index/test_results.svg
new file mode 100644
index 000000000..d3d613ffd
--- /dev/null
+++ b/src/boost/libs/multi_index/test_results.svg
@@ -0,0 +1,26 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="95" height="20">
+  <linearGradient id="b" x2="0" y2="100%">
+    <stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
+    <stop offset="1" stop-opacity=".1"/>
+  </linearGradient>
+  <clipPath id="a">
+    <rect width="95" height="20" rx="3" fill="#fff"/>
+  </clipPath>
+  <g clip-path="url(#a)">
+    <path fill="#555" d="M0 0h48v20H0z"/>
+    <path fill="#4c1" d="M48 0h47v20H48z"/>
+    <path fill="url(#b)" d="M0 0h95v20H0z"/>
+  </g>
+  <g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,Verdana,Geneva,sans-serif" font-size="110">
+    <path fill="#fff" d="M 10.8566 9.70598 l -3.60307 0 l -0.0903426 0.15447 l -1.63598 2.79514 l -0.0919027 0.156812 l 0.0912783 0.157278 l 1.63599 2.82198 l 0.0901858 0.155564 l 3.60291 0 l 0.090498 -0.153378 l 1.64956 -2.79498 l 0.093151 -0.157907 l -0.0923709 -0.158212 l -1.64956 -2.82213 l -0.0903415 -0.154627 z m -5.06008 3.1072 l 1.63598 -2.79514 l 3.24498 0 l 1.64956 2.82213 l -1.64956 2.79498 l -3.24498 0 l -1.63598 -2.82198 z"/>
+    <path fill="#fff" d="M 16.6973 6.54947 l -3.6026 0 l -0.090185 0.155562 l -1.54689 2.67 l -0.0906544 0.156655 l 0.0908101 0.1565 l 1.72508 2.97067 l 0.0908101 0.156188 l 0.180528 -0.000780746 l 3.06679 -0.0137328 l 0.178187 -0.000780746 l 0.0898736 -0.153845 l 1.65658 -2.83383 l 0.0926823 -0.158528 l -0.093773 -0.15806 l -1.65658 -2.79311 l -0.0906529 -0.15291 z m -4.96959 2.98206 l 1.54689 -2.67 l 3.24498 0 l 1.65658 2.79311 l -1.65658 2.83383 l -3.06679 0.0137328 l -1.72508 -2.97067 z"/>
+    <path fill="#fff" d="M 12.4576 4.03269 l -3.56874 0 l -0.0898744 0.156967 l -1.61336 2.81683 l -0.0875335 0.152755 l 0.0855053 0.153848 l 0.991265 1.78437 l 0.0887818 0.160088 l 0.183024 0.000468606 l 2.38603 0.00686454 l 0.178812 0.000468606 l 0.0909666 -0.154003 l 1.72804 -2.92995 l 0.850837 0 l -0.265721 -0.466534 l -0.868311 -1.52458 l -0.0897187 -0.15759 z m -5.00126 3.12889 l 1.61336 -2.81683 l 3.20644 0 l 0.868313 1.52458 l -0.492278 0 l -1.81854 3.08348 l -2.38603 -0.00686454 l -0.991265 -1.78437 z"/>
+    <path fill="#cccccc" d="M 10.8566 9.70598 m -5.06008 3.1072 l 1.63598 -2.79514 l 3.24498 0 l 1.64956 2.82213 l -1.64956 2.79498 l -3.24498 0 l -1.63598 -2.82198 z"/>
+    <path fill="#cccccc" d="M 16.6973 6.54947 m -4.96959 2.98206 l 1.54689 -2.67 l 3.24498 0 l 1.65658 2.79311 l -1.65658 2.83383 l -3.06679 0.0137328 l -1.72508 -2.97067 z"/>
+    <path fill="#cccccc" d="M 12.4576 4.03269 m -5.00126 3.12889 l 1.61336 -2.81683 l 3.20644 0 l 0.868313 1.52458 l -0.492278 0 l -1.81854 3.08348 l -2.38603 -0.00686454 l -0.991265 -1.78437 z"/>
+    <text x="335" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="210">test</text>
+    <text x="335" y="140" transform="scale(.1)" textLength="210">test</text>
+    <text x="705" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="370">results</text>
+    <text x="705" y="140" transform="scale(.1)" textLength="370">results</text>
+  </g>
+</svg>
\ No newline at end of file