Merged for Boost 1.48

[SVN r74161]

doc/Jamfile.v2

@@ -0,0 +1,82 @@
+#  Boost.Container library documentation Jamfile  ---------------------------------
+#
+#  Copyright Ion Gaztanaga 2009-2011. Use, modification and
+#  distribution is subject to 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 for updates, documentation, and revision history.
+
+import doxygen ;
+import quickbook ;
+
+using auto-index ;
+
+path-constant images_location : html ;
+
+doxygen autodoc
+   :
+      [ glob ../../../boost/container/*.hpp ]
+   :
+        <doxygen:param>EXTRACT_ALL=NO
+        <doxygen:param>HIDE_UNDOC_MEMBERS=YES
+        <doxygen:param>EXTRACT_PRIVATE=NO
+        <doxygen:param>ENABLE_PREPROCESSING=YES
+        <doxygen:param>EXPAND_ONLY_PREDEF=YES
+        <doxygen:param>MACRO_EXPANSION=YES
+        <doxygen:param>"PREDEFINED=\"insert_const_ref_type= const T&\" \\
+                                   \"BOOST_CONTAINER_DOXYGEN_INVOKED\" \\
+                                   \"BOOST_RV_REF(T)=T &&\" \\
+                                   \"BOOST_COPY_ASSIGN_REF(T)=const T &\" \\
+                                   \"BOOST_RV_REF_2_TEMPL_ARGS(T,a,b)=T<a, b> &&\" \\
+                                   \"BOOST_RV_REF_3_TEMPL_ARGS(T,a,b,c)=T<a,b,c>T<a,b,c> &&\" \\
+                                   \"BOOST_FWD_REF(a)=a &&\""
+        <xsl:param>"boost.doxygen.reftitle=Boost.Container Header Reference"
+   ;
+
+xml container : container.qbk 
+              : 
+                 <include>../../../tools/auto_index/include
+              ;
+
+boostbook standalone
+   :
+      container
+   :
+        <xsl:param>boost.root=../../../..
+        <xsl:param>boost.libraries=../../../../libs/libraries.htm
+        <xsl:param>generate.section.toc.level=3
+        <xsl:param>chunk.first.sections=1
+        <format>pdf:<xsl:param>img.src.path=$(images_location)/
+        <dependency>autodoc
+        <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html
+
+        # Build requirements go here:
+        
+        # <auto-index>on (or off) one turns on (or off) indexing:
+        <auto-index>on
+        
+        # Turns on (or off) auto-index-verbose for diagnostic info.
+        # This is highly recommended until you have got all the many details correct!
+        <auto-index-verbose>on 
+        
+        # Choose the indexing method (separately for html and PDF) - see manual.
+        # Choose indexing method for PDFs:
+        <format>pdf:<auto-index-internal>off
+        
+        # Choose indexing method for html:
+        <format>html:<auto-index-internal>on
+        
+        # Set the name of the script file to use (index.idx is popular):
+        <auto-index-script>index.idx
+        # Commands in the script file should all use RELATIVE PATHS
+        # otherwise the script will not be portable to other machines.
+        # Relative paths are normally taken as relative to the location 
+        # of the script file, but we can add a prefix to all
+        # those relative paths using the <auto-index-prefix> feature.
+        # The path specified by <auto-index-prefix> may be either relative or
+        # absolute, for example the following will get us up to the boost root
+        # directory for most Boost libraries:
+        <auto-index-prefix>"../../.."
+
+   ;

doc/container.qbk

@@ -0,0 +1,590 @@
+[/
+ / Copyright (c) 2009-2011 Ion Gazta\u00F1aga
+ /
+ / 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)
+ /]
+
+[library Boost.Container
+    [quickbook 1.5]
+    [authors [Gaztanaga, Ion]]
+    [copyright 2009-2011 Ion Gaztanaga]
+    [id container]
+    [dirname container]
+    [purpose Containers library]
+    [license
+        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])
+    ]
+]
+
+[template super[x]'''<superscript>'''[x]'''</superscript>''']
+[template sub[x]'''<subscript>'''[x]'''</subscript>''']
+
+[section:intro Introduction]
+
+[*Boost.Container] library implements several well-known containers, including
+STL containers. The aim of the library is to offers advanced features not present
+in standard containers or to offer the latest standard draft features for compilers
+that comply with C++03.
+
+In short, what does [*Boost.Container] offer?
+
+* Move semantics are implemented, including move emulation for pre-C++11 compilers.
+* New advanced features (e.g. placement insertion, recursive containers) are present.
+* Containers support stateful allocators and are compatible with [*Boost.Interprocess]
+  (they can be safely placed in shared memory).
+* The library offers new useful containers:
+  * [classref boost::container::flat_map flat_map],
+    [classref boost::container::flat_map flat_set],
+    [classref boost::container::flat_map flat_multiset] and
+    [classref boost::container::flat_map flat_multiset]: drop-in
+    replacements for standard associative containers but more memory friendly and with faster
+    searches.
+  * [classref boost::container::stable_vector stable_vector]: a std::list and std::vector hybrid
+    container: vector-like random-access iterators and list-like iterator stability in insertions and erasures.
+  * [classref boost::container::slist slist]: the classic pre-standard singly linked list implementation
+    offering constant-time `size()`. Note that C++11 `forward_list` has no `size()`.
+
+[section:introduction_building_container Building Boost.Container]
+
+There is no need to compile [*Boost.Container], since it's
+a header only library. Just include your Boost header directory in your
+compiler include path.
+
+[endsect]
+
+[section:tested_compilers Tested compilers]
+
+[*Boost.Container] requires a decent C++98 compatibility. Some compilers known to work are:
+
+*  Visual C++ >= 7.1.
+*  GCC >= 3.4.
+*  Intel C++ >= 9.0
+
+[endsect]
+
+[endsect]
+
+[section:move_emplace Efficient insertion]
+
+Move semantics and placement insertion are two features brought by C++11 containers
+that can have a very positive impact in your C++ applications. Boost.Container implements
+both techniques both for C++11 and C++03 compilers.
+
+[section:move_containers Move-aware containers]
+
+All containers offered by [*Boost.Container] can store movable-only types
+and actual requirements for `value_type` depend on each container operations.
+Following C++11 requirements even for C++03 compilers, many operations now require
+movable or default constructible types instead of just copy constructible types.
+
+Containers themselves are also movable, with no-throw guarantee if allocator
+or predicate (if present) copy operations are no-throw. This allows
+high performance operations when transferring data between vectors.
+Let's see an example:
+
+[import ../example/doc_move_containers.cpp]
+[doc_move_containers]
+
+[endsect]
+
+[section:emplace Emplace: Placement insertion]
+
+All containers offered by [*Boost.Container] implement placement insertion,
+which means that  objects can be built directly into the container from user arguments
+without creating any temporary object. For compilers without variadic templates support
+placement insertion is emulated up to a finite (10) number of arguments.
+
+Expensive to move types are perfect candidates emplace functions and in case of node containers
+([classref boost::container::list list], [classref boost::container::set set], ...)
+emplace allows storing non-movable and non-copyable types in containers! Let's
+see an example:
+
+[import ../example/doc_emplace.cpp]
+[doc_emplace]
+
+[endsect]
+
+[endsect]
+
+
+[section:containers_of_incomplete_types Containers of Incomplete Types]
+
+Incomplete types allow
+[@http://en.wikipedia.org/wiki/Type_erasure [*type erasure ]] and
+[@http://en.wikipedia.org/wiki/Recursive_data_type [*recursive data types]], and
+C and C++ programmers have been using it for years to build complex data structures, like
+tree structures where a node may have an arbitrary number of children.
+
+What about standard containers? Containers of incomplete types have been under discussion for a long time,
+as explained in Matt Austern's great article ([@http://drdobbs.com/184403814 [*The Standard Librarian: Containers of Incomplete Types]]):
+
+["['Unlike most of my columns, this one is about something you can't do with the C++ Standard library:
+put incomplete types in one of the standard containers. This column explains why you might want to
+do this, why the standardization committee banned it even though they knew it was useful, and what
+you might be able to do to get around the restriction.]]
+
+["['In 1997, shortly before the C++ Standard was completed, the standardization committee received a
+query: Is it possible to create standard containers with incomplete types? It took a while for the
+committee to understand the question. What would such a thing even mean, and why on earth would you
+ever want to do it? The committee eventually worked it out and came up with an answer to the question.
+(Just so you don't have to skip ahead to the end, the answer is "no.") But the question is much more
+interesting than the answer: it points to a useful, and insufficiently discussed, programming technique.
+The standard library doesn't directly support that technique, but the two can be made to coexist.]]
+
+["['In a future revision of C++, it might make sense to relax the restriction on instantiating
+standard library templates with incomplete types. Clearly, the general prohibition should stay
+in place - instantiating templates with incomplete types is a delicate business, and there are
+too many classes in the standard library where it would make no sense. But perhaps it should be
+relaxed on a case-by-case basis, and `vector` looks like a good candidate for such special-case
+treatment: it's the one standard container class where there are good reasons to instantiate
+it with an incomplete type and where Standard Library implementors want to make it work. As of
+today, in fact, implementors would have to go out of their way to prohibit it!]]
+
+C++11 standard is also cautious about incomplete types and STL: ["['17.6.4.8 Other functions (...) 2.
+the effects are undefined in the following cases: (...) In particular - if an incomplete type (3.9)
+is used as a template argument when instantiating a template component,
+unless specifically allowed for that component]]. Fortunately [*Boost.Container] containers are designed
+to support type erasure and recursive types, so let's see some examples:
+
+[section:recursive_containers Recursive containers]
+
+All containers offered by [*Boost.Container] can be used to define recursive containers:
+
+[import ../example/doc_recursive_containers.cpp]
+[doc_recursive_containers]
+
+[endsect]
+
+[section:type_erasure Type Erasure]
+
+Containers of incomplete types are useful to break header file dependencies and improve
+compilation types. With Boost.Container, you can write a header file defining a class
+with containers of incomplete types as data members, if you carefully put all the
+implementation details that require knowing the size of the `value_type` in your
+implementation file:
+
+[import ../example/doc_type_erasure.cpp]
+
+In this header file we define a class (`MyClassHolder)` that holds a `vector` of an
+incomplete type (`MyClass`) that it's only forward declared.
+
+[doc_type_erasure_MyClassHolder_h]
+
+Then we can define `MyClass` in its own header file.
+
+[doc_type_erasure_MyClass_h]
+
+And include it only in the implementation file of `MyClassHolder`
+
+[doc_type_erasure_MyClassHolder_cpp]
+
+Finally, we can just compile, link, and run!
+
+[doc_type_erasure_main_cpp]
+
+[endsect]
+
+[endsect]
+
+[section:non_standard_containers Non-standard containers]
+
+[section:stable_vector ['stable_vector]]
+
+This useful, fully STL-compliant stable container [@http://bannalia.blogspot.com/2008/09/introducing-stablevector.html designed by by Joaqu\u00EDn M. L\u00F3pez Mu\u00F1oz]
+is an hybrid between `vector` and `list`, providing most of
+the features of `vector` except [@http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#69 element contiguity].
+
+Extremely convenient as they are, `vector`s have a limitation that many novice C++ programmers frequently stumble upon:
+iterators and references to an element of an `vector` are invalidated when a preceding element is erased or when the
+vector expands and needs to migrate its internal storage to a wider memory region (i.e. when the required size exceeds
+the vector's capacity). We say then that `vector`s are unstable: by contrast, stable containers are those for which
+references and iterators to a given element remain valid as long as the element is not erased: examples of stable containers
+within the C++ standard library are `list` and the standard associative containers (`set`, `map`, etc.).
+
+Sometimes stability is too precious a feature to live without, but one particular property of `vector`s, element contiguity,
+makes it impossible to add stability to this container. So, provided we sacrifice element contiguity, how much
+can a stable design approach the behavior of `vector` (random access iterators, amortized constant time end
+insertion/deletion, minimal memory overhead, etc.)?
+The following image describes the layout of a possible data structure upon which to base the design of a stable vector:
+
+[$images/stable_vector.png [width 50%] [align center] ]
+
+Each element is stored in its own separate node. All the nodes are referenced from a contiguous array of pointers, but
+also every node contains an "up" pointer referring back to the associated array cell. This up pointer is the key element
+to implementing stability and random accessibility:
+
+Iterators point to the nodes rather than to the pointer array. This ensures stability, as it is only the pointer array
+that needs to be shifted or relocated upon insertion or deletion. Random access operations can be implemented by using
+the pointer array as a convenient intermediate zone. For instance, if the iterator it holds a node pointer `it.p` and we
+want to advance it by n positions, we simply do:
+
+[c++]
+
+   it.p = *(it.p->up+n);
+
+That is, we go "up" to the pointer array, add n there and then go "down" to the resulting node. 
+
+[*General properties]. `stable_vector` satisfies all the requirements of a container, a reversible container and a sequence
+and provides all the optional operations present in vector. Like vector, iterators are random access. `stable_vector`
+does not provide element contiguity; in exchange for this absence, the container is stable, i.e. references and iterators
+to an element of a `stable_vector` remain valid as long as the element is not erased, and an iterator that has been
+assigned the return value of end() always remain valid until the destruction of the associated `stable_vector`.
+
+[*Operation complexity]. The big-O complexities of `stable_vector` operations match exactly those of vector. In general,
+insertion/deletion is constant time at the end of the sequence and linear elsewhere. Unlike vector, `stable_vector`
+does not internally perform any value_type destruction, copy/move construction/assignment operations other than those exactly
+corresponding to the insertion of new elements or deletion of stored elements, which can sometimes compensate in terms of
+performance for the extra burden of doing more pointer manipulation and an additional allocation per element.
+
+[*Exception safety]. (according to [@http://www.boost.org/community/exception_safety.html Abrahams' terminology])
+As `stable_vector` does not internally copy/move elements around, some
+operations provide stronger exception safety guarantees than in vector:
+
+[table:stable_vector_req Exception safety
+    [[operation] [exception safety for `vector<T>`] [exception safety for `stable_vector<T>`]]
+    [[insert]    [strong unless copy/move construction/assignment of `T` throw (basic)]     [strong]]
+    [[erase]     [no-throw unless copy/move construction/assignment  of `T` throw (basic)]     [no-throw]]
+]
+
+[*Memory overhead]. The C++ standard does not specifiy requirements on memory consumption, but virtually any implementation
+of `vector` has the same behavior wih respect to memory usage: the memory allocated by a `vector` v with n elements of type T
+is
+
+m[sub v] = c\u2219e,
+
+where c is `v.capacity()` and e is `sizeof(T)`. c can be as low as n if the user has explicitly reserved the exact capacity
+required; otherwise, the average value c for a growing `vector` oscillates between 1.25\u2219n and 1.5\u2219n for typical resizing
+policies. For `stable_vector`, the memory usage is
+
+m[sub sv] = (c + 1)p + (n + 1)(e + p),
+
+where p is the size of a pointer. We have c + 1 and n + 1 rather than c and n because a dummy node is needed at the end of
+the sequence. If we call f the capacity to size ratio c/n and assume that n is large enough, we have that
+
+m[sub sv]/m[sub v] \u2243 (fp + e + p)/fe.
+
+So, `stable_vector` uses less memory than `vector` only when e > p and the capacity to size ratio exceeds a given threshold:
+
+m[sub sv] < m[sub v] <-> f > (e + p)/(e - p). (provided e > p)
+
+This threshold approaches typical values of f below 1.5 when e > 5p; in a 32-bit architecture, when e > 20 bytes.
+
+[*Summary]. `stable_vector` is a drop-in replacement for `vector` providing stability of references and iterators, in exchange
+for missing element contiguity and also some performance and memory overhead. When the element objects are expensive to
+move around, the performance overhead can turn into a net performance gain for `stable_vector` if many middle insertions
+or deletions are performed or if resizing is very frequent. Similarly, if the elements are large there are situations when
+the memory used by `stable_vector` can actually be less than required by vector.
+
+['Note: Text and explanations taken from [@http://bannalia.blogspot.com/2008/09/introducing-stablevector.html Joaqu\u00EDn's blog]]
+
+[endsect]
+
+[section:flat_xxx ['flat_(multi)map/set] associative containers]
+
+Using sorted vectors instead of tree-based associative containers is a well-known technique in
+C++ world. Matt Austern's  classic article
+[@http://lafstern.org/matt/col1.pdf Why You Shouldn't Use set, and What You Should Use Instead]
+(C++ Report 12:4, April 2000) was enlightening:
+
+["['Red-black trees aren't the only way to organize data that permits lookup in logarithmic time.  One of the basic
+algorithms of computer science is binary search, which works by successively dividing a range in half. Binary
+search is log N and it doesn't require any fancy data structures, just a sorted collection of elements. 
+(...) You can use whatever data structure is convenient, so long as it provides STL iterator; 
+usually it's easiest to use a C array, or a vector.]]
+
+["['Both std::lower_bound and set::find take time proportional to log N, but the constants of proportionality
+are very different.  Using g++ (...) it takes X seconds to perform a million lookups in a
+sorted vector<double> of a million elements, and almost twice as long (...) using a set. Moreover,
+the set uses almost three times as much memory (48 million bytes) as the vector (16.8 million).]]
+
+["['Using a sorted vector instead of a set gives you faster lookup and much faster iteration,
+but at the cost of slower insertion.  Insertion into a set, using set::insert, is proportional
+to log N, but insertion into a sorted vector, (...)
+, is proportional to N. Whenever you insert something into a vector,
+vector::insert has to make room by shifting all of the elements that follow it.  On average, if you're equally
+likely to insert a new element anywhere, you'll be shifting N/2 elements.]]
+
+["['It may sometimes be convenient to bundle all of this together into a small container adaptor.
+This class does not satisfy the requirements of a Standard Associative Container, since the complexity of insert is
+O(N) rather than O(log N), but otherwise it is almost a drop-in replacement for set.]]
+
+Following Matt Austern's indications, Andrei Alexandrescu's
+[@http://www.bestwebbuys.com/Modern-C-Design-Generic-Programming-and-Design-Patterns-Applied-ISBN-9780201704310?isrc=-rd Modern C++ Design]
+showed `AssocVector`, a `std::map` drop-in
+replacement designed in his [@http://loki-lib.sourceforge.net/ Loki] library:
+
+["['It seems as if we're better off with a sorted vector. The disadvantages of a sorted
+vector are linear-time insertions and linear-time deletions (...). In exchange, a vector 
+offers about twice the lookup speed and a much smaller working set (...). 
+Loki saves the trouble of maintaining a sorted vector by hand by defining an AssocVector class 
+template. AssocVector is a drop-in replacement for std::map (it supports the same set of member 
+functions), implemented on top of std::vector. AssocVector differs from a map in the behavior of 
+its erase functions (AssocVector::erase invalidates all iterators into the object) and in the 
+complexity guarantees of insert and erase (linear as opposed to constant). ]]
+
+[*Boost.Container] `flat_[multi]map/set` containers are ordered-vector based associative containers
+based on Austern's and Alexandrescu's guidelines. These ordered vector containers have also
+benefited recently with the addition of `move semantics` to C++, speeding up insertion
+and erasure times considerably. Flat associative containers have the following
+attributes:
+
+* Faster lookup than standard associative containers
+* Much faster iteration than standard associative containers
+* Less memory consumption for small objects (and for big objects if `shrink_to_fit` is used)
+* Improved cache performance (data is stored in contiguous memory)
+* Non-stable iterators (iterators are invalidated when inserting and erasing elements)
+* Non-copyable and non-movable values types can't be stored
+* Weaker exception safety than standard associative containers
+(copy/move constructors can throw when shifting values in erasures and insertions)
+* Slower insertion and erasure than standard associative containers (specially for non-movable types)
+
+[endsect]
+
+[section:slist ['slist]]
+
+When the standard template library was designed, it contained a singly linked list called `slist`.
+Unfortunately, this container was not standardized and remained as an extension for many standard
+library implementations until C++11 introduced `forward_list`, which is a bit different from the
+the original SGI `slist`. According to [@http://www.sgi.com/tech/stl/Slist.html SGI STL documentation]:
+
+["['An `slist` is a singly linked list: a list where each element is linked to the next element, but
+not to the previous element. That is, it is a Sequence that supports forward but not backward traversal,
+and (amortized) constant time insertion and removal of elements. Slists, like lists, have the important
+property that insertion and splicing do not invalidate iterators to list elements, and that even removal
+invalidates only the iterators that point to the elements that are removed. The ordering of iterators
+may be changed (that is, slist<T>::iterator might have a different predecessor or successor after a list
+operation than it did before), but the iterators themselves will not be invalidated or made to point to
+different elements unless that invalidation or mutation is explicit.]]
+
+["['The main difference between `slist` and list is that list's iterators are bidirectional iterators,
+while slist's iterators are forward iterators. This means that `slist` is less versatile than list;
+frequently, however, bidirectional iterators are unnecessary. You should usually use `slist` unless
+you actually need the extra functionality of list, because singly linked lists are smaller and faster
+than double linked lists.]]
+
+["['Important performance note: like every other Sequence, `slist` defines the member functions insert and erase.
+Using these member functions carelessly, however, can result in disastrously slow programs. The problem is that
+insert's first argument is an iterator pos, and that it inserts the new element(s) before pos. This means that
+insert must find the iterator just before pos; this is a constant-time operation for list, since list has
+bidirectional iterators, but for `slist` it must find that iterator by traversing the list from the beginning
+up to pos. In other words: insert and erase are slow operations anywhere but near the beginning of the slist.]]
+
+["['Slist provides the member functions insert_after and erase_after, which are constant time operations: you should
+always use insert_after and erase_after whenever possible. If you find that insert_after and erase_after aren't
+adequate for your needs, and that you often need to use insert and erase in the middle of the list, then you
+should probably use list instead of slist.]]
+
+[*Boost.Container] updates the classic `slist` container with C++11 features like move semantics and placement
+insertion and implements it a bit differently for the standard C++11 `forward_list`. `forward_list` has no `size()`
+method, so it's been designed to allow (or in practice, encourage) implementations without tracking list size
+with every insertion/erasure, allowing constant-time 
+`splice_after(iterator, forward_list &, iterator, iterator)`-based list merging. On the other hand `slist` offers
+constant-time `size()` for those that don't care about linear-time `splice_after(iterator, slist &, iterator, iterator)`
+`size()` and offers an additional `splice_after(iterator, slist &, iterator, iterator, size_type)` method that
+can speed up `slist` merging when the programmer already knows the size. `slist` and `forward_list` are therefore
+complementary.
+
+[endsect]
+
+[endsect]
+
+[section:Cpp11_conformance C++11 Conformance]
+
+[*Boost.Container] aims for full C++11 conformance except reasoned deviations,
+backporting as much as possible for C++03. Obviously, this conformance is a work
+in progress so this section explains what C++11 features are implemented and which of them
+have been backported to C++03 compilers.
+
+[section:move_emplace Move and Emplace]
+
+For compilers with rvalue references and for those C++03 types that use
+[@http://www.boost.org/libs/move Boost.Move] rvalue reference emulation
+[*Boost.Container] supports all C++11 features related to move semantics: containers
+are movable, requirements for `value_type` are those specified for C++11 containers.
+
+For compilers with variadic templates, [*Boost.Container] supports placement insertion
+(`emplace`, ...) functions from C++11. For those compilers without variadic templates
+support [*Boost.Container] uses the preprocessor to create a set of overloads up to
+a finite (10) number of parameters.
+
+[endsect]
+
+[section:alloc_traits_move_traits Stateful allocators and Scoped allocators]
+
+C++03 was not stateful-allocator friendly. For compactness of container objects and for
+simplicity, it did not require containers to support allocators with state: Allocator objects
+need not be stored in container objects. It was not possible to store an allocator with state,
+say an allocator that holds a pointer to an arena from which to allocate. C++03 allowed implementors
+to suppose two allocators of the same type always compare equal (that means that memory allocated
+by one allocator object could be deallocated by another instance of the same type) and
+allocators were not swapped when the container was swapped.
+
+Many C++ container implementors felt C++03 guarantees were too weak and started to offer extensions.
+[*Boost.Container], following [@http://www.boost.org/libs/interprocess/ Boost.Interprocess] 
+containers experience supporting stateful allocators, offers the following guarantees:
+
+* Allocators are copy-constructed in copy/move constructors
+* If possible, a single allocator is hold to construct `value_type` and this allocator is copy constructed
+  from the user-supplied allocator object during container's constructor. If the container needs an auxiliary 
+  allocator (e.g. a array allocator used by `deque` or `stable_vector`), that allocator is also 
+  copy-constructed from the user-supplied allocator when the container is constructed (i.e. it's 
+  not constructed on the fly when auxiliary memory is needed).
+* Allocators are compared for equality when swapping containers. If allocators don't compare
+  equal allocators are swapped using an unqualified `swap` call.
+
+C++11 further improves stateful allocator support through the
+[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2554.pdf
+Scoped Allocators model], using classes like `std::scoped_allocator_adaptor` and `std::allocator_traits`.
+[*Boost.Container does not support it yet, but there are plans to do so and backport scoped allocator
+support to C++03 compilers.
+
+[endsect]
+
+[section:initializer_lists Initializer lists]
+
+[*Boost.Container] does not support initializer lists when constructing or assigning containers
+but it will support it for compilers with initialized-list support. This feature won't be backported
+to C++03 compilers.
+
+[endsect]
+
+[section:Vector_bool vector<bool>]
+
+`vector<bool>` specialization has been quite problematic, and there have been several
+unsuccessful tries to deprecate or remove it from the standard. [*Boost.Container] does not implement it
+as there is a superior [@http://www.boost.org/libs/dynamic_bitset/ Boost.DynamicBitset]
+solution. For issues with `vector<bool>` see papers
+[@http://www.gotw.ca/publications/N1211.pdf vector<bool>: N1211: More Problems, Better Solutions], 
+[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2160.html N2160: Library Issue 96: Fixing vector<bool>],
+[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2204.html N2204 A Specification to deprecate vector<bool>].
+
+* ["['In 1998, admitting that the committee made a mistake was controversial.
+  Since then Java has had to deprecate such significant portions of their libraries
+  that the idea C++ would be ridiculed for deprecating a single minor template specialization seems quaint.]]
+
+* ["['`vector<bool>` is not a container and `vector<bool>::iterator` is not a random-access iterator
+(or even a forward or bidirectional iterator either, for that matter). This has already broken user code
+in the field in mysterious ways.]]
+
+* ["['`vector<bool>` forces a specific (and potentially bad) optimization choice on all users by enshrining
+it in the standard. The optimization is premature; different users have different requirements. This too
+has already hurt users who have been forced to implement workarounds to disable the 'optimization'
+(e.g., by using a vector<char> and manually casting to/from bool).]]
+
+So `boost::container::vector<bool>::iterator` returns real `bool` references and works as a fully compliant container.
+If you need a memory optimized version of `boost::container::vector<bool>` functionalities, please use
+[@http://www.boost.org/libs/dynamic_bitset/ Boost.DynamicBitset].
+
+[endsect]
+
+[endsect]
+
+[section:other_features Other features]
+
+* Default constructors don't allocate memory which improves performance and
+  usually implies a no-throw guarantee (if predicate's or allocator's default constructor doesn't throw).
+
+* Small string optimization for [classref boost::container::basic_string basic_string],
+  with an internal buffer of 11/23 bytes (32/64 bit systems)
+  [*without] increasing the usual `sizeof` of the string (3 words).
+
+* `[multi]set/map` containers are size optimized embedding the color bit of the red-black tree nodes
+   in the parent pointer.
+
+* `[multi]set/map` containers use no recursive functions so stack problems are avoided.
+
+[endsect]
+
+[section:history_and_reasons History and reasons to use Boost.Container]
+
+[section:boost_container_history Boost.Container history]
+
+[*Boost.Container] is a product of a long development effort that started
+[@http://lists.boost.org/Archives/boost/2004/11/76263.php in 2004 with the experimental Shmem library],
+which pioneered the use of standard containers in shared memory. Shmem included modified SGI STL container
+code tweaked to support non-raw `allocator::pointer` types and stateful allocators. Once reviewed,
+Shmem was accepted as [@http://www.boost.org/libs/interprocess/ Boost.Interprocess] and this library
+continued to refine and improve those containers.
+
+In 2007, container code from node containers (`map`, `list`, `slist`) was rewritten, refactored 
+and expanded to build the intrusive container library [@http://www.boost.org/libs/intrusive/ Boost.Intrusive].
+[*Boost.Interprocess] containers were refactored to take advantage of [*Boost.Intrusive] containers and
+code duplication was minimized. Both libraries continued to gain support and bug fixes for years.
+They introduced move semantics, emplacement insertion and more features of then unreleased C++0x
+standard.
+
+[*Boost.Interprocess] containers were always standard compliant, and those containers and new
+containers like `stable_vector` and `flat_[multi]set/map` were used outside [*Boost.Interprocess]
+with success. As containers were mature enough to get their own library, it was a natural step to
+collect them containers and build [*Boost.Container], a library targeted to a wider audience.
+
+[endsect]
+
+
+[section:Why_boost_container Why Boost.Container?]
+
+With so many high quality standard library implementations out there, why would you want to
+use [*Boost.Container]? There are several reasons for that:
+
+* If you have a C++03 compiler, you can have access to C++11 features and have an easy
+  code migration when you change your compiler.
+* It's compatible with [*Boost.Interprocess] shared memory allocators.
+* You have extremely useful new containers like `stable_vector` and `flat_[multi]set/map`.
+* If you work on multiple platforms, you'll have a portable behaviour without depending
+  on the std-lib implementation conformance of each platform. Some examples:
+   * Default constructors don't allocate memory at all, which improves performance and
+   usually implies a no-throw guarantee (if predicate's or allocator's default constructor doesn't throw).
+   * Small string optimization for [classref boost::container::basic_string basic_string].
+* New extensions beyond the standard based on user feedback to improve code performance.
+
+[endsect]
+
+[endsect]
+
+[include auto_index_helpers.qbk]
+
+[section:index Indexes]
+
+[named_index class_name Class Index]
+[named_index typedef_name Typedef Index]
+[named_index function_name Function Index]
+[/named_index macro_name Macro Index]
+[/index]
+
+[endsect]
+
+[xinclude autodoc.xml]
+
+[section:acknowledgements_notes Acknowledgements, notes and links]
+
+*  Original standard container code comes from [@http://www.sgi.com/tech/stl/ SGI STL library],
+   which enhanced the original HP STL code. Most of this code was rewritten for
+   [*Boost.Interprocess] and moved to [*Boost.Intrusive]. `deque` and `string` containers still
+   have fragments of the original SGI code. Many thanks to Alexander Stepanov, Meng Lee, David Musser,
+   Matt Austern... and all HP and SGI STL developers.
+
+*  `flat_[multi]_map/set` containers were originally based on [@http://en.wikipedia.org/wiki/Loki_%28C%2B%2B%29 Loki's]
+   AssocVector class. Code was rewritten and expanded for [*Boost.Interprocess], so thanks to Andrei Alexandrescu.
+
+*  `stable_vector` was invented and coded by
+   [@http://bannalia.blogspot.com/2008/09/introducing-stablevector.html Joaqu\u00EDn M. L\u00F3pez Mu\u00F1oz],
+   then adapted for [*Boost.Interprocess]. Thanks for such a great container.
+
+*  Howard Hinnant's help and advices were essential when implementing move semantics, 
+   improving allocator support or implementing small string optimization. Thanks Howard
+   for your wonderful standard library implementations.
+
+*  And finally thanks to all Boosters who helped all these years, improving, fixing and
+   reviewing all my libraries.
+
+[endsect]
+
+[section:release_notes Release Notes]
+
+*  First release with Boost 1.48. Container code from [*Boost.Interprocess] was deleted
+   and redirected to [*Boost.Container ] via using directives.
+
+[endsect]

doc/html/boostbook.css

@@ -0,0 +1,537 @@
+/*=============================================================================
+    Copyright (c) 2004 Joel de Guzman
+
+    Use, modification and distribution is subject to 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)
+=============================================================================*/
+
+/*=============================================================================
+    Body defaults
+=============================================================================*/
+
+    body 
+    {
+        margin: 1em;
+        font-family: sans-serif;
+    }
+
+/*=============================================================================
+    Paragraphs
+=============================================================================*/
+
+    p 
+    {
+        text-align: left;
+        font-size: 10pt; 
+        line-height: 1.15;
+    }
+
+/*=============================================================================
+    Program listings
+=============================================================================*/
+
+    /* Code on paragraphs */
+    p tt.computeroutput
+    {
+        font-size: 10pt;
+    }
+
+    pre.synopsis
+    {
+        font-size: 10pt;
+        margin: 1pc 4% 0pc 4%;
+        padding: 0.5pc 0.5pc 0.5pc 0.5pc;
+    }
+
+    .programlisting, 
+    .screen
+    {
+        font-size: 10pt;
+        display: block;
+        margin: 1pc 4% 0pc 4%;
+        padding: 0.5pc 0.5pc 0.5pc 0.5pc;
+    }
+
+/*=============================================================================
+    Headings
+=============================================================================*/
+
+    h1, h2, h3, h4, h5, h6 
+    { 
+        text-align: left;
+        margin: 1em 0em 0.5em 0em;
+        font-weight: bold;
+    }
+
+    h1 { font: 140% }
+    h2 { font: bold 140% }
+    h3 { font: bold 130% }
+    h4 { font: bold 120% }
+    h5 { font: italic 110% }
+    h6 { font: italic 100% }
+
+    /* Top page titles */
+    title, 
+    h1.title, 
+    h2.title
+    h3.title, 
+    h4.title, 
+    h5.title, 
+    h6.title, 
+    .refentrytitle
+    {
+        font-weight: bold;
+        margin-bottom: 1pc;
+    }
+
+    h1.title { font-size: 140% }
+    h2.title { font-size: 140% }
+    h3.title { font-size: 130% }
+    h4.title { font-size: 120% }
+    h5.title { font-size: 110% }
+    h6.title { font-size: 100% }
+
+    .section h1 
+    {
+        margin: 0em 0em 0.5em 0em;
+        font-size: 140%;
+    }
+
+    .section h2 { font-size: 140% }
+    .section h3 { font-size: 130% }
+    .section h4 { font-size: 120% }
+    .section h5 { font-size: 110% }
+    .section h6 { font-size: 100% }
+
+    /* Code on titles */
+    h1 tt.computeroutput { font-size: 140% }
+    h2 tt.computeroutput { font-size: 140% }
+    h3 tt.computeroutput { font-size: 130% }
+    h4 tt.computeroutput { font-size: 120% }
+    h5 tt.computeroutput { font-size: 110% }
+    h6 tt.computeroutput { font-size: 100% }
+
+/*=============================================================================
+    Author
+=============================================================================*/
+
+    h3.author 
+    { 
+        font-size: 100% 
+    }
+
+/*=============================================================================
+    Lists
+=============================================================================*/
+
+    li
+    {
+        font-size: 10pt;
+        line-height: 1.3;
+    }
+
+    /* Unordered lists */
+    ul 
+    {
+        text-align: left;
+    }
+
+    /* Ordered lists */
+    ol 
+    {
+        text-align: left;
+    }
+
+/*=============================================================================
+    Links
+=============================================================================*/
+
+    a
+    {
+        text-decoration: none; /* no underline */
+    }
+
+    a:hover
+    {
+        text-decoration: underline;
+    }
+
+/*=============================================================================
+    Spirit style navigation
+=============================================================================*/
+
+    .spirit-nav
+    {
+        text-align: right;
+    }
+
+    .spirit-nav a
+    {
+        color: white;
+        padding-left: 0.5em;
+    }
+
+    .spirit-nav img
+    {
+        border-width: 0px;
+    }
+
+/*=============================================================================
+    Table of contents
+=============================================================================*/
+
+    .toc
+    {
+       margin: 1pc 4% 0pc 4%;
+       padding: 0.1pc 1pc 0.1pc 1pc;
+       font-size: 10pt;
+       line-height: 1.15;
+    }
+
+    .toc-main
+    {
+     width: 600;
+    text-align: center;
+       margin: 1pc 1pc 1pc 10%;
+       padding: 2pc 1pc 3pc 1pc;
+    line-height: 0.1;
+    }
+
+    .boost-toc
+    {
+       float: right;
+       padding: 0.5pc;
+    }
+
+/*=============================================================================
+    Tables
+=============================================================================*/
+
+    .table-title, 
+    div.table p.title
+    {
+        margin-left: 4%;
+        padding-right: 0.5em; 
+        padding-left: 0.5em;
+    }
+
+    .informaltable table, 
+    .table table
+    {
+        width: 92%;
+        margin-left: 4%;
+        margin-right: 4%;
+    }
+
+    div.informaltable table, 
+    div.table table
+    {
+        padding: 4px;
+    }
+
+    /* Table Cells */
+    div.informaltable table tr td, 
+    div.table table tr td
+    {
+        padding: 0.5em;
+        text-align: left;
+    }
+
+    div.informaltable table tr th, 
+    div.table table tr th
+    {
+        padding: 0.5em 0.5em 0.5em 0.5em;
+        border: 1pt solid white;
+        font-size: 120%;
+    }
+
+/*=============================================================================
+    Blurbs
+=============================================================================*/
+
+    div.note,
+    div.tip,
+    div.important,
+    div.caution,
+    div.warning,
+    p.blurb
+    {
+        font-size: 10pt;
+        line-height: 1.2;
+        display: block;
+        margin: 1pc 4% 0pc 4%;
+        padding: 0.5pc 0.5pc 0.5pc 0.5pc;
+    }
+
+    p.blurb img
+    {
+        padding: 1pt;
+    }
+
+/*=============================================================================
+    Variable Lists
+=============================================================================*/
+
+    span.term
+    {
+        font-weight: bold;
+        font-size: 10pt;
+    }
+
+    div.variablelist table tbody tr td
+    {
+        text-align: left;
+        vertical-align: top;
+        padding: 0em 2em 0em 0em;
+        font-size: 10pt;
+    }
+
+    div.variablelist table tbody tr td p
+    {
+        margin: 0em 0em 0.5em 0em;
+    }
+
+    /* Make the terms in definition lists bold */
+    div.variablelist dl dt
+    {
+        font-weight: bold;
+        font-size: 10pt;
+    }
+
+    div.variablelist dl dd
+    {
+        margin: 1em 0em 1em 2em;
+        font-size: 10pt;
+    }
+
+/*=============================================================================
+    Misc
+=============================================================================*/
+
+    /* Title of books and articles in bibliographies */
+    span.title
+    {
+        font-style: italic;
+    }
+
+    span.underline
+    {
+        text-decoration: underline;
+    }
+
+    span.strikethrough
+    {
+        text-decoration: line-through;
+    }
+
+    /* Copyright, Legal Notice */
+    div div.legalnotice p
+    {
+        font-size: 8pt;
+        text-align: left
+    }
+
+/*=============================================================================
+    Colors
+=============================================================================*/
+
+    @media screen
+    {
+        /* Links */
+        a
+        {
+            color: #0C7445;
+        }
+
+        a:visited
+        {
+            color: #663974;
+        }
+
+        h1 a, h2 a, h3 a, h4 a, h5 a, h6 a,
+        h1 a:hover, h2 a:hover, h3 a:hover, h4 a:hover, h5 a:hover, h6 a:hover,
+        h1 a:visited, h2 a:visited, h3 a:visited, h4 a:visited, h5 a:visited, h6 a:visited
+        {
+            text-decoration: none; /* no underline */
+            color: #000000;
+        }
+
+        /* Syntax Highlighting */
+        .keyword        { color: #0000AA; }
+        .identifier     { color: #000000; }
+        .special        { color: #707070; }
+        .preprocessor   { color: #402080; }
+        .char           { color: teal; }
+        .comment        { color: #800000; }
+        .string         { color: teal; }
+        .number         { color: teal; }
+        .white_bkd      { background-color: #E8FBE9; }
+        .dk_grey_bkd    { background-color: #A0DAAC; }
+
+        /* Copyright, Legal Notice */
+        .copyright
+        { 
+            color: #666666; 
+            font-size: small; 
+        }
+
+        div div.legalnotice p
+        {
+            color: #666666;
+        }
+
+        /* Program listing */
+        pre.synopsis
+        {
+            border: 1px solid #DCDCDC;
+            border-bottom: 3px solid #9D9D9D;
+            border-right: 3px solid #9D9D9D;
+            background-color: #FAFFFB;
+        }
+
+        .programlisting, 
+        .screen
+        {
+            border: 1px solid #DCDCDC;
+            border-bottom: 3px solid #9D9D9D;
+            border-right: 3px solid #9D9D9D;
+            background-color: #FAFFFB;
+        }
+
+        /* Blurbs */
+        div.note,
+        div.tip,
+        div.important,
+        div.caution,
+        div.warning,
+        p.blurb
+        {
+            border: 1px solid #DCDCDC;
+            border-bottom: 3px solid #9D9D9D;
+            border-right: 3px solid #9D9D9D;
+            background-color: #FAFFFB;
+        }
+
+        /* Table of contents */
+        .toc
+        {
+            border: 1px solid #DCDCDC;
+            border-bottom: 3px solid #9D9D9D;
+            border-right: 3px solid #9D9D9D;
+            background-color: #FAFFFB;
+        }
+
+        /* Table of contents */
+        .toc-main
+        {
+            border: 1px solid #DCDCDC;
+            border-bottom: 3px solid #9D9D9D;
+            border-right: 3px solid #9D9D9D;
+            background-color: #FAFFFB;
+        }
+
+
+        /* Tables */
+        div.informaltable table tr td, 
+        div.table table tr td
+        {
+            border: 1px solid #DCDCDC;
+            background-color: #FAFFFB;
+        }
+
+        div.informaltable table tr th, 
+        div.table table tr th
+        {
+            background-color: #E3F9E4;
+            border: 1px solid #DCDCDC;
+        }
+
+        /* Misc */
+        span.highlight
+        {
+            color: #00A000;
+        }
+    }
+
+    @media print
+    {
+        /* Links */
+        a
+        {
+            color: black;
+        }
+
+        a:visited
+        {
+            color: black;
+        }
+
+        .spirit-nav
+        {
+            display: none;
+        }
+
+        /* Program listing */
+        pre.synopsis
+        {
+            border: 1px solid gray;
+            background-color: #FAFFFB;
+        }
+
+        .programlisting, 
+        .screen
+        {
+            border: 1px solid gray;
+            background-color: #FAFFFB;
+        }
+
+        /* Table of contents */
+        .toc
+        {
+            border: 1px solid #DCDCDC;
+            border-bottom: 3px solid #9D9D9D;
+            border-right: 3px solid #9D9D9D;
+            background-color: #FAFFFB;
+        }
+
+        /* Table of contents */
+        .toc-main
+        {
+            border: 1px solid #DCDCDC;
+            border-bottom: 3px solid #9D9D9D;
+            border-right: 3px solid #9D9D9D;
+            background-color: #FAFFFB;
+        }
+
+        .informaltable table, 
+        .table table
+        {
+            border: 1px solid #DCDCDC;
+            border-bottom: 3px solid #9D9D9D;
+            border-right: 3px solid #9D9D9D;
+            border-collapse: collapse;
+            background-color: #FAFFFB;
+        }
+
+        /* Tables */
+        div.informaltable table tr td, 
+        div.table table tr td
+        {
+            border: 1px solid #DCDCDC;
+            background-color: #FAFFFB;
+        }
+
+        div.informaltable table tr th, 
+        div.table table tr th
+        {
+            border: 1px solid #DCDCDC;
+            background-color: #FAFFFB;
+        }
+
+        /* Misc */
+        span.highlight
+        {
+            font-weight: bold;
+        }
+    }

doc/html/reference.css

@@ -0,0 +1,12 @@
+/*=============================================================================
+    Copyright (c) 2004 Joel de Guzman
+
+    Use, modification and distribution is subject to 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)
+=============================================================================*/
+PRE.synopsis { 
+  background-color: #e0ffff;
+  border: thin solid blue;
+  padding: 1em
+}

doc/index.idx

@@ -0,0 +1 @@
+!scan-path "boost/container" ".*.hpp" false 

example/Jamfile.v2

@@ -0,0 +1,34 @@
+# Boost Container Library Example Jamfile
+
+#  (C) Copyright Ion Gaztanaga 2009
+# Use, modification and distribution are subject to 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)
+
+# Adapted from John Maddock's TR1 Jamfile.v2
+# Copyright John Maddock 2005.
+# Use, modification and distribution are subject to 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)
+
+# this rule enumerates through all the sources and invokes
+# the run rule for each source, the result is a list of all
+# the run rules, which we can pass on to the test_suite rule:
+
+rule test_all
+{
+   local all_rules = ;
+
+   for local fileb in [ glob doc_*.cpp ]
+   {
+      all_rules += [ run $(fileb)
+      :  # additional args
+      :  # test-files
+      :  # requirements
+      ] ;
+   }
+
+   return $(all_rules) ;
+}
+
+test-suite container_example : [ test_all r ] : <threading>multi ; 

example/doc_emplace.cpp

@@ -0,0 +1,44 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2009-2011. 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/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/workaround.hpp>
+//[doc_emplace
+#include <boost/container/list.hpp>
+#include <cassert>
+
+//Non-copyable and non-movable class
+class non_copy_movable
+{
+   non_copy_movable(const non_copy_movable &);
+   non_copy_movable& operator=(const non_copy_movable &);
+
+   public:
+   non_copy_movable(int = 0) {}
+};
+
+int main ()
+{
+   using namespace boost::container;
+
+   //Store non-copyable and non-movable objects in a list
+   list<non_copy_movable> l;
+   non_copy_movable ncm;
+
+   //A new element will be built calling non_copy_movable(int) contructor
+   l.emplace(l.begin(), 0);
+   assert(l.size() == 1);
+
+   //A new element will be built calling the default constructor
+   l.emplace(l.begin());
+   assert(l.size() == 2);
+   return 0;
+}
+//]
+#include <boost/container/detail/config_end.hpp>

example/doc_move_containers.cpp

@@ -0,0 +1,54 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2009-2011. 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/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/workaround.hpp>
+//[doc_move_containers
+#include <boost/container/vector.hpp>
+#include <boost/move/move.hpp>
+#include <cassert>
+
+//Non-copyable class
+class non_copyable
+{
+   BOOST_MOVABLE_BUT_NOT_COPYABLE(non_copyable)
+
+   public:
+   non_copyable(){}
+   non_copyable(BOOST_RV_REF(non_copyable)) {}
+   non_copyable& operator=(BOOST_RV_REF(non_copyable)) { return *this; }
+};
+
+int main ()
+{
+   using namespace boost::container;
+
+   //Store non-copyable objects in a vector
+   vector<non_copyable> v;
+   non_copyable nc;
+   v.push_back(boost::move(nc));
+   assert(v.size() == 1);
+
+   //Reserve no longer needs copy-constructible
+   v.reserve(100);
+   assert(v.capacity() >= 100);
+
+   //This resize overload only needs movable and default constructible
+   v.resize(200);
+   assert(v.size() == 200);
+
+   //Containers are also movable
+   vector<non_copyable> v_other(boost::move(v));
+   assert(v_other.size() == 200);
+   assert(v.empty());
+
+   return 0;
+}
+//]
+#include <boost/container/detail/config_end.hpp>

example/doc_recursive_containers.cpp

@@ -0,0 +1,61 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2009-2011. 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/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/workaround.hpp>
+//[doc_recursive_containers
+#include <boost/container/vector.hpp>
+#include <boost/container/list.hpp>
+#include <boost/container/map.hpp>
+#include <boost/container/stable_vector.hpp>
+#include <boost/container/string.hpp>
+
+using namespace boost::container;
+
+struct data
+{
+   int               i_;
+   //A vector holding still undefined class 'data'
+   vector<data>      v_;
+   //A list holding still undefined 'data'
+   list<data>        l_;
+   //A map holding still undefined 'data'
+   map<data, data>   m_;
+
+   friend bool operator <(const data &l, const data &r)
+   { return l.i_ < r.i_; }
+};
+
+struct tree_node
+{
+   string name;
+   string value;
+
+   //children nodes of this node
+   list<tree_node>        children_;
+};
+
+
+
+int main()
+{
+   //a container holding a recursive data type
+   stable_vector<data> sv;
+   sv.resize(100);
+
+   //Let's build a tree based in 
+   //a recursive data type
+   tree_node root;
+   root.name  = "root";
+   root.value = "root_value";
+   root.children_.resize(7);
+   return 0;
+}
+//]
+#include <boost/container/detail/config_end.hpp>

example/doc_type_erasure.cpp

@@ -0,0 +1,91 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2009-2011. 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/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/workaround.hpp>
+//[doc_type_erasure_MyClassHolder_h
+#include <boost/container/vector.hpp>
+
+//MyClassHolder.h
+
+//We don't need to include "MyClass.h"
+//to store vector<MyClass> 
+class MyClass;
+
+class MyClassHolder
+{
+   public:
+
+   void AddNewObject(const MyClass &o);
+   const MyClass & GetLastObject() const;
+
+   private:
+   ::boost::container::vector<MyClass> vector_;
+};
+
+//]
+
+//[doc_type_erasure_MyClass_h
+
+//MyClass.h
+
+class MyClass
+{
+   private:
+   int value_;
+
+   public:
+   MyClass(int val = 0) : value_(val){}
+
+   friend bool operator==(const MyClass &l, const MyClass &r)
+   {  return l.value_ == r.value_;  } 
+   //...
+};
+
+//]
+
+
+
+//[doc_type_erasure_main_cpp
+
+//Main.cpp
+
+//=#include "MyClassHolder.h"
+//=#include "MyClass.h"
+
+#include <cassert>
+
+int main()
+{
+   MyClass mc(7);
+   MyClassHolder myclassholder;
+   myclassholder.AddNewObject(mc);
+   return myclassholder.GetLastObject() == mc ? 0 : 1;
+}
+//]
+
+//[doc_type_erasure_MyClassHolder_cpp
+
+//MyClassHolder.cpp
+
+//=#include "MyClassHolder.h"
+
+//In the implementation MyClass must be a complete
+//type so we include the appropriate header
+//=#include "MyClass.h"
+
+void MyClassHolder::AddNewObject(const MyClass &o)
+{  vector_.push_back(o);  }
+
+const MyClass & MyClassHolder::GetLastObject() const
+{  return vector_.back();  }
+
+//]
+
+#include <boost/container/detail/config_end.hpp>

index.html

@@ -0,0 +1,14 @@
+<!--
+Copyright 2005-2011 Ion Gaztanaga
+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="refresh" content="0; URL=../../doc/html/container.html">
+</head>
+<body>
+Automatic redirection failed, please go to 
+<a href="../../doc/html/container.html">../../doc/html/container.html</a>
+</body>
+</html>

proj/to-do.txt

@@ -0,0 +1,2 @@
+->Change "insert" and "push_back"/"push_front" to catch non-const rvalues
+->Add an example with stateful allocators

proj/vc7ide/container.sln

@@ -0,0 +1,87 @@
+Microsoft Visual Studio Solution File, Format Version 8.00
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "deque_test", "deque_test.vcproj", "{58CCE183-6092-48FE-A4F7-BA0D3A792655}"
+	ProjectSection(ProjectDependencies) = postProject
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "flat_tree_test", "flat_tree_test.vcproj", "{58CCE183-6092-48FE-A4F7-BA0D3A792637}"
+	ProjectSection(ProjectDependencies) = postProject
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "list_test", "list_ex.vcproj", "{58CCE183-6092-48FE-A4F7-BA0D3A792632}"
+	ProjectSection(ProjectDependencies) = postProject
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "stable_vector_test", "stable_vector_test.vcproj", "{5E11C8D3-FA52-760A-84FE-943A6BA05A21}"
+	ProjectSection(ProjectDependencies) = postProject
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "string_test", "string_test.vcproj", "{58CCE183-6092-48FE-A4F7-BA0D4A792607}"
+	ProjectSection(ProjectDependencies) = postProject
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "tree_test", "tree_test.vcproj", "{58CCE183-6092-48FE-A4F7-BA0D3A792606}"
+	ProjectSection(ProjectDependencies) = postProject
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "slist_test", "slist_test.vcproj", "{58CCE183-6092-48FE-A4F7-BA0D3A792608}"
+	ProjectSection(ProjectDependencies) = postProject
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vector_test", "vector_test.vcproj", "{5CE11C83-096A-84FE-4FA2-D3A6BA792002}"
+	ProjectSection(ProjectDependencies) = postProject
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "_containerlib", "container.vcproj", "{FF56BAF1-32EC-4B22-B6BD-95A3A67C3135}"
+	ProjectSection(ProjectDependencies) = postProject
+	EndProjectSection
+EndProject
+Global
+	GlobalSection(SolutionConfiguration) = preSolution
+		Debug = Debug
+		Release = Release
+	EndGlobalSection
+	GlobalSection(ProjectDependencies) = postSolution
+	EndGlobalSection
+	GlobalSection(ProjectConfiguration) = postSolution
+		{58CCE183-6092-48FE-A4F7-BA0D3A792655}.Debug.ActiveCfg = Debug|Win32
+		{58CCE183-6092-48FE-A4F7-BA0D3A792655}.Debug.Build.0 = Debug|Win32
+		{58CCE183-6092-48FE-A4F7-BA0D3A792655}.Release.ActiveCfg = Release|Win32
+		{58CCE183-6092-48FE-A4F7-BA0D3A792655}.Release.Build.0 = Release|Win32
+		{58CCE183-6092-48FE-A4F7-BA0D3A792637}.Debug.ActiveCfg = Debug|Win32
+		{58CCE183-6092-48FE-A4F7-BA0D3A792637}.Debug.Build.0 = Debug|Win32
+		{58CCE183-6092-48FE-A4F7-BA0D3A792637}.Release.ActiveCfg = Release|Win32
+		{58CCE183-6092-48FE-A4F7-BA0D3A792637}.Release.Build.0 = Release|Win32
+		{58CCE183-6092-48FE-A4F7-BA0D3A792632}.Debug.ActiveCfg = Debug|Win32
+		{58CCE183-6092-48FE-A4F7-BA0D3A792632}.Debug.Build.0 = Debug|Win32
+		{58CCE183-6092-48FE-A4F7-BA0D3A792632}.Release.ActiveCfg = Release|Win32
+		{58CCE183-6092-48FE-A4F7-BA0D3A792632}.Release.Build.0 = Release|Win32
+		{5E11C8D3-FA52-760A-84FE-943A6BA05A21}.Debug.ActiveCfg = Debug|Win32
+		{5E11C8D3-FA52-760A-84FE-943A6BA05A21}.Debug.Build.0 = Debug|Win32
+		{5E11C8D3-FA52-760A-84FE-943A6BA05A21}.Release.ActiveCfg = Release|Win32
+		{5E11C8D3-FA52-760A-84FE-943A6BA05A21}.Release.Build.0 = Release|Win32
+		{58CCE183-6092-48FE-A4F7-BA0D4A792607}.Debug.ActiveCfg = Debug|Win32
+		{58CCE183-6092-48FE-A4F7-BA0D4A792607}.Debug.Build.0 = Debug|Win32
+		{58CCE183-6092-48FE-A4F7-BA0D4A792607}.Release.ActiveCfg = Release|Win32
+		{58CCE183-6092-48FE-A4F7-BA0D4A792607}.Release.Build.0 = Release|Win32
+		{58CCE183-6092-48FE-A4F7-BA0D3A792606}.Debug.ActiveCfg = Debug|Win32
+		{58CCE183-6092-48FE-A4F7-BA0D3A792606}.Debug.Build.0 = Debug|Win32
+		{58CCE183-6092-48FE-A4F7-BA0D3A792606}.Release.ActiveCfg = Release|Win32
+		{58CCE183-6092-48FE-A4F7-BA0D3A792606}.Release.Build.0 = Release|Win32
+		{58CCE183-6092-48FE-A4F7-BA0D3A792608}.Debug.ActiveCfg = Debug|Win32
+		{58CCE183-6092-48FE-A4F7-BA0D3A792608}.Debug.Build.0 = Debug|Win32
+		{58CCE183-6092-48FE-A4F7-BA0D3A792608}.Release.ActiveCfg = Release|Win32
+		{58CCE183-6092-48FE-A4F7-BA0D3A792608}.Release.Build.0 = Release|Win32
+		{5CE11C83-096A-84FE-4FA2-D3A6BA792002}.Debug.ActiveCfg = Debug|Win32
+		{5CE11C83-096A-84FE-4FA2-D3A6BA792002}.Debug.Build.0 = Debug|Win32
+		{5CE11C83-096A-84FE-4FA2-D3A6BA792002}.Release.ActiveCfg = Release|Win32
+		{5CE11C83-096A-84FE-4FA2-D3A6BA792002}.Release.Build.0 = Release|Win32
+		{FF56BAF1-32EC-4B22-B6BD-95A3A67C3135}.Debug.ActiveCfg = Debug|Win32
+		{FF56BAF1-32EC-4B22-B6BD-95A3A67C3135}.Debug.Build.0 = Debug|Win32
+		{FF56BAF1-32EC-4B22-B6BD-95A3A67C3135}.Release.ActiveCfg = Release|Win32
+		{FF56BAF1-32EC-4B22-B6BD-95A3A67C3135}.Release.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+	EndGlobalSection
+	GlobalSection(ExtensibilityAddIns) = postSolution
+	EndGlobalSection
+EndGlobal

proj/vc7ide/container.vcproj

@@ -0,0 +1,321 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.10"
+	Name="_containerlib"
+	ProjectGUID="{FF56BAF1-32EC-4B22-B6BD-95A3A67C3135}"
+	Keyword="Win32Proj">
+	<Platforms>
+		<Platform
+			Name="Win32"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="../../Bin/Win32"
+			IntermediateDirectory="Debug"
+			ConfigurationType="4"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="../../../.."
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;BOOST_DATE_TIME_NO_LIB"
+				MinimalRebuild="TRUE"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="TRUE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="$(OutDir)/d.lib"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="../../Bin/Win32"
+			IntermediateDirectory="Release"
+			ConfigurationType="4"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="../../../.."
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;BOOST_DATE_TIME_NO_LIB"
+				RuntimeLibrary="2"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="TRUE"
+				DebugInformationFormat="0"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="$(OutDir)/container.lib"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="detail"
+			Filter="">
+			<File
+				RelativePath="..\..\..\..\boost\container\detail\adaptive_node_pool_impl.hpp">
+			</File>
+			<File
+				RelativePath="..\..\..\..\boost\container\detail\advanced_insert_int.hpp">
+			</File>
+			<File
+				RelativePath="..\..\..\..\boost\container\detail\algorithms.hpp">
+			</File>
+			<File
+				RelativePath="..\..\..\..\boost\container\detail\allocation_type.hpp">
+			</File>
+			<File
+				RelativePath="..\..\..\..\boost\container\detail\config_begin.hpp">
+			</File>
+			<File
+				RelativePath="..\..\..\..\boost\container\detail\config_end.hpp">
+			</File>
+			<File
+				RelativePath="..\..\..\..\boost\container\detail\destroyers.hpp">
+			</File>
+			<File
+				RelativePath="..\..\..\..\boost\container\detail\flat_tree.hpp">
+			</File>
+			<File
+				RelativePath="..\..\..\..\boost\container\detail\iterators.hpp">
+			</File>
+			<File
+				RelativePath="..\..\..\..\boost\container\detail\math_functions.hpp">
+			</File>
+			<File
+				RelativePath="..\..\..\..\boost\container\detail\mpl.hpp">
+			</File>
+			<File
+				RelativePath="..\..\..\..\boost\container\detail\multiallocation_chain.hpp">
+			</File>
+			<File
+				RelativePath="..\..\..\..\boost\container\detail\node_alloc_holder.hpp">
+			</File>
+			<File
+				RelativePath="..\..\..\..\boost\container\detail\node_pool_impl.hpp">
+			</File>
+			<File
+				RelativePath="..\..\..\..\boost\container\detail\pair.hpp">
+			</File>
+			<File
+				RelativePath="..\..\..\..\boost\container\detail\pool_common.hpp">
+			</File>
+			<File
+				RelativePath="..\..\..\..\boost\container\detail\preprocessor.hpp">
+			</File>
+			<File
+				RelativePath="..\..\..\..\boost\container\detail\transform_iterator.hpp">
+			</File>
+			<File
+				RelativePath="..\..\..\..\boost\container\detail\tree.hpp">
+			</File>
+			<File
+				RelativePath="..\..\..\..\boost\container\detail\type_traits.hpp">
+			</File>
+			<File
+				RelativePath="..\..\..\..\boost\container\detail\utilities.hpp">
+			</File>
+			<File
+				RelativePath="..\..\..\..\boost\container\detail\value_init.hpp">
+			</File>
+			<File
+				RelativePath="..\..\..\..\boost\container\detail\variadic_templates_tools.hpp">
+			</File>
+			<File
+				RelativePath="..\..\..\..\boost\container\detail\version_type.hpp">
+			</File>
+			<File
+				RelativePath="..\..\..\..\boost\container\detail\workaround.hpp">
+			</File>
+		</Filter>
+		<Filter
+			Name="Documentation"
+			Filter="">
+			<File
+				RelativePath="..\..\doc\container.qbk">
+			</File>
+			<File
+				RelativePath="..\..\doc\index.idx">
+			</File>
+			<File
+				RelativePath="..\..\doc\Jamfile.v2">
+			</File>
+		</Filter>
+		<Filter
+			Name="example"
+			Filter="">
+			<File
+				RelativePath="..\..\example\doc_emplace.cpp">
+			</File>
+			<File
+				RelativePath="..\..\example\doc_move_containers.cpp">
+			</File>
+			<File
+				RelativePath="..\..\example\doc_recursive_containers.cpp">
+			</File>
+			<File
+				RelativePath="..\..\example\doc_type_erasure.cpp">
+			</File>
+			<File
+				RelativePath="..\..\example\Jamfile.v2">
+			</File>
+		</Filter>
+		<Filter
+			Name="test"
+			Filter="">
+			<File
+				RelativePath="..\..\test\boost_interprocess_check.hpp">
+			</File>
+			<File
+				RelativePath="..\..\test\check_equal_containers.hpp">
+			</File>
+			<File
+				RelativePath="..\..\test\deque_test.cpp">
+			</File>
+			<File
+				RelativePath="..\..\test\dummy_test_allocator.hpp">
+			</File>
+			<File
+				RelativePath="..\..\test\emplace_test.hpp">
+			</File>
+			<File
+				RelativePath="..\..\test\expand_bwd_test_allocator.hpp">
+			</File>
+			<File
+				RelativePath="..\..\test\expand_bwd_test_template.hpp">
+			</File>
+			<File
+				RelativePath="..\..\test\flat_tree_test.cpp">
+			</File>
+			<File
+				RelativePath="..\..\test\heap_allocator_v1.hpp">
+			</File>
+			<File
+				RelativePath="..\..\test\Jamfile.v2">
+			</File>
+			<File
+				RelativePath="..\..\test\list_test.cpp">
+			</File>
+			<File
+				RelativePath="..\..\test\list_test.hpp">
+			</File>
+			<File
+				RelativePath="..\..\test\map_test.hpp">
+			</File>
+			<File
+				RelativePath="..\..\test\movable_int.hpp">
+			</File>
+			<File
+				RelativePath="..\..\test\print_container.hpp">
+			</File>
+			<File
+				RelativePath="..\..\test\set_test.hpp">
+			</File>
+			<File
+				RelativePath="..\..\test\slist_test.cpp">
+			</File>
+			<File
+				RelativePath="..\..\test\stable_vector_test.cpp">
+			</File>
+			<File
+				RelativePath="..\..\test\string_test.cpp">
+			</File>
+			<File
+				RelativePath="..\..\test\tree_test.cpp">
+			</File>
+			<File
+				RelativePath="..\..\test\util.hpp">
+			</File>
+			<File
+				RelativePath="..\..\test\vector_test.cpp">
+			</File>
+			<File
+				RelativePath="..\..\test\vector_test.hpp">
+			</File>
+		</Filter>
+		<File
+			RelativePath="..\..\..\..\boost\container\container_fwd.hpp">
+		</File>
+		<File
+			RelativePath="..\..\..\..\boost\container\deque.hpp">
+		</File>
+		<File
+			RelativePath="..\..\..\..\boost\container\flat_map.hpp">
+		</File>
+		<File
+			RelativePath="..\..\..\..\boost\container\flat_set.hpp">
+		</File>
+		<File
+			RelativePath="..\..\..\..\boost\container\list.hpp">
+		</File>
+		<File
+			RelativePath="..\..\..\..\boost\container\map.hpp">
+		</File>
+		<File
+			RelativePath="..\..\..\..\boost\container\set.hpp">
+		</File>
+		<File
+			RelativePath="..\..\..\..\boost\container\slist.hpp">
+		</File>
+		<File
+			RelativePath="..\..\..\..\boost\container\stable_vector.hpp">
+		</File>
+		<File
+			RelativePath="..\..\..\..\boost\container\string.hpp">
+		</File>
+		<File
+			RelativePath="..\to-do.txt">
+		</File>
+		<File
+			RelativePath="..\..\..\..\boost\container\vector.hpp">
+		</File>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

proj/vc7ide/deque_test.vcproj

@@ -0,0 +1,138 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.10"
+	Name="deque_test"
+	ProjectGUID="{58CCE183-6092-48FE-A4F7-BA0D3A792655}"
+	Keyword="Win32Proj">
+	<Platforms>
+		<Platform
+			Name="Win32"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="../../Bin/Win32/Debug"
+			IntermediateDirectory="Debug/deque_test"
+			ConfigurationType="1"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="../../../.."
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;BOOST_DATE_TIME_NO_LIB"
+				MinimalRebuild="TRUE"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				TreatWChar_tAsBuiltInType="TRUE"
+				ForceConformanceInForLoopScope="FALSE"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				Detect64BitPortabilityProblems="TRUE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="winmm.lib"
+				OutputFile="$(OutDir)/deque_test_d.exe"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories="../../../../stage/lib"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile="$(OutDir)/deque_test.pdb"
+				SubSystem="1"
+				TargetMachine="1"
+				FixedBaseAddress="1"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="../../Bin/Win32/Release"
+			IntermediateDirectory="Release/deque_test"
+			ConfigurationType="1"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="../../../.."
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;BOOST_DATE_TIME_NO_LIB"
+				RuntimeLibrary="2"
+				TreatWChar_tAsBuiltInType="TRUE"
+				ForceConformanceInForLoopScope="FALSE"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				Detect64BitPortabilityProblems="TRUE"
+				DebugInformationFormat="0"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="winmm.lib"
+				OutputFile="$(OutDir)/deque_test.exe"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories="../../../../stage/lib"
+				GenerateDebugInformation="TRUE"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
+			<File
+				RelativePath="..\..\test\deque_test.cpp">
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

proj/vc7ide/flat_tree_test.vcproj

@@ -0,0 +1,140 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.10"
+	Name="flat_tree_test"
+	ProjectGUID="{58CCE183-6092-48FE-A4F7-BA0D3A792637}"
+	Keyword="Win32Proj">
+	<Platforms>
+		<Platform
+			Name="Win32"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="../../Bin/Win32/Debug"
+			IntermediateDirectory="Debug/flat_tree_test"
+			ConfigurationType="1"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="../../../.."
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;BOOST_DATE_TIME_NO_LIB"
+				GeneratePreprocessedFile="0"
+				KeepComments="FALSE"
+				MinimalRebuild="TRUE"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				TreatWChar_tAsBuiltInType="TRUE"
+				ForceConformanceInForLoopScope="FALSE"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				Detect64BitPortabilityProblems="TRUE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="winmm.lib"
+				OutputFile="$(OutDir)/flat_tree_test_d.exe"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories="../../../../stage/lib"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile="$(OutDir)/flat_tree_test.pdb"
+				SubSystem="1"
+				TargetMachine="1"
+				FixedBaseAddress="1"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="../../Bin/Win32/Release"
+			IntermediateDirectory="Release/flat_tree_test"
+			ConfigurationType="1"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="../../../.."
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;BOOST_DATE_TIME_NO_LIB"
+				RuntimeLibrary="2"
+				TreatWChar_tAsBuiltInType="TRUE"
+				ForceConformanceInForLoopScope="FALSE"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				Detect64BitPortabilityProblems="TRUE"
+				DebugInformationFormat="0"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="winmm.lib"
+				OutputFile="$(OutDir)/flat_tree_test.exe"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories="../../../../stage/lib"
+				GenerateDebugInformation="TRUE"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
+			<File
+				RelativePath="..\..\test\flat_tree_test.cpp">
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

proj/vc7ide/list_ex.vcproj

@@ -0,0 +1,140 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.10"
+	Name="list_test"
+	ProjectGUID="{58CCE183-6092-48FE-A4F7-BA0D3A792632}"
+	Keyword="Win32Proj">
+	<Platforms>
+		<Platform
+			Name="Win32"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="../../Bin/Win32/Debug"
+			IntermediateDirectory="Debug/list_ex"
+			ConfigurationType="1"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="../../../.."
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;BOOST_DATE_TIME_NO_LIB"
+				GeneratePreprocessedFile="0"
+				KeepComments="FALSE"
+				MinimalRebuild="TRUE"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				TreatWChar_tAsBuiltInType="TRUE"
+				ForceConformanceInForLoopScope="FALSE"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				Detect64BitPortabilityProblems="TRUE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="winmm.lib"
+				OutputFile="$(OutDir)/list_ex_d.exe"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories="../../../../stage/lib"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile="$(OutDir)/list_ex.pdb"
+				SubSystem="1"
+				TargetMachine="1"
+				FixedBaseAddress="1"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="../../Bin/Win32/Release"
+			IntermediateDirectory="Release/list_ex"
+			ConfigurationType="1"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="../../../.."
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;BOOST_DATE_TIME_NO_LIB"
+				RuntimeLibrary="2"
+				TreatWChar_tAsBuiltInType="TRUE"
+				ForceConformanceInForLoopScope="FALSE"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				Detect64BitPortabilityProblems="TRUE"
+				DebugInformationFormat="0"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="winmm.lib"
+				OutputFile="$(OutDir)/list_ex.exe"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories="../../../../stage/lib"
+				GenerateDebugInformation="TRUE"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
+			<File
+				RelativePath="..\..\test\list_test.cpp">
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

proj/vc7ide/slist_test.vcproj

@@ -0,0 +1,138 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.10"
+	Name="slist_test"
+	ProjectGUID="{58CCE183-6092-48FE-A4F7-BA0D3A792608}"
+	Keyword="Win32Proj">
+	<Platforms>
+		<Platform
+			Name="Win32"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="../../Bin/Win32/Debug"
+			IntermediateDirectory="Debug/slist_test"
+			ConfigurationType="1"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="../../../.."
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;BOOST_DATE_TIME_NO_LIB"
+				MinimalRebuild="TRUE"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				TreatWChar_tAsBuiltInType="TRUE"
+				ForceConformanceInForLoopScope="FALSE"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				Detect64BitPortabilityProblems="TRUE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="winmm.lib"
+				OutputFile="$(OutDir)/slist_test_d.exe"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories="../../../../stage/lib"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile="$(OutDir)/slist_test.pdb"
+				SubSystem="1"
+				TargetMachine="1"
+				FixedBaseAddress="1"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="../../Bin/Win32/Release"
+			IntermediateDirectory="Release/slist_test"
+			ConfigurationType="1"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="../../../.."
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;BOOST_DATE_TIME_NO_LIB"
+				RuntimeLibrary="2"
+				TreatWChar_tAsBuiltInType="TRUE"
+				ForceConformanceInForLoopScope="FALSE"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				Detect64BitPortabilityProblems="TRUE"
+				DebugInformationFormat="0"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="winmm.lib"
+				OutputFile="$(OutDir)/slist_test.exe"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories="../../../../stage/lib"
+				GenerateDebugInformation="TRUE"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
+			<File
+				RelativePath="..\..\test\slist_test.cpp">
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

proj/vc7ide/stable_vector_test.vcproj

@@ -0,0 +1,133 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.10"
+	Name="stable_vector_test"
+	ProjectGUID="{5E11C8D3-FA52-760A-84FE-943A6BA05A21}"
+	Keyword="Win32Proj">
+	<Platforms>
+		<Platform
+			Name="Win32"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="../../Bin/Win32/Debug"
+			IntermediateDirectory="Debug/stable_vector_test"
+			ConfigurationType="1"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="../../../.."
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;BOOST_DATE_TIME_NO_LIB"
+				MinimalRebuild="TRUE"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				TreatWChar_tAsBuiltInType="TRUE"
+				ForceConformanceInForLoopScope="FALSE"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				Detect64BitPortabilityProblems="TRUE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="winmm.lib"
+				OutputFile="$(OutDir)/stable_vector_test_d.exe"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories="../../../../stage/lib"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile="$(OutDir)/stable_vector_test.pdb"
+				SubSystem="1"
+				TargetMachine="1"
+				FixedBaseAddress="1"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="../../Bin/Win32/Release"
+			IntermediateDirectory="Release/stable_vector_test"
+			ConfigurationType="1"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="../../../.."
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;BOOST_DATE_TIME_NO_LIB"
+				RuntimeLibrary="2"
+				TreatWChar_tAsBuiltInType="TRUE"
+				ForceConformanceInForLoopScope="FALSE"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				Detect64BitPortabilityProblems="TRUE"
+				DebugInformationFormat="0"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="winmm.lib"
+				OutputFile="$(OutDir)/stable_vector_test.exe"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories="../../../../stage/lib"
+				GenerateDebugInformation="TRUE"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{37BC807F-2451-A306-7AC5-7A35A32A22DF}">
+			<File
+				RelativePath="..\..\test\stable_vector_test.cpp">
+			</File>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

proj/vc7ide/string_test.vcproj

@@ -0,0 +1,139 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.10"
+	Name="string_test"
+	ProjectGUID="{58CCE183-6092-48FE-A4F7-BA0D4A792607}"
+	Keyword="Win32Proj">
+	<Platforms>
+		<Platform
+			Name="Win32"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="../../Bin/Win32/Debug"
+			IntermediateDirectory="Debug/string_test"
+			ConfigurationType="1"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="../../../.."
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;BOOST_DATE_TIME_NO_LIB"
+				GeneratePreprocessedFile="0"
+				MinimalRebuild="TRUE"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				TreatWChar_tAsBuiltInType="TRUE"
+				ForceConformanceInForLoopScope="FALSE"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				Detect64BitPortabilityProblems="TRUE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="winmm.lib"
+				OutputFile="$(OutDir)/string_test_d.exe"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories="../../../../stage/lib"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile="$(OutDir)/string_test.pdb"
+				SubSystem="1"
+				TargetMachine="1"
+				FixedBaseAddress="1"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="../../Bin/Win32/Release"
+			IntermediateDirectory="Release/string_test"
+			ConfigurationType="1"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="../../../.."
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;BOOST_DATE_TIME_NO_LIB"
+				RuntimeLibrary="2"
+				TreatWChar_tAsBuiltInType="TRUE"
+				ForceConformanceInForLoopScope="FALSE"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				Detect64BitPortabilityProblems="TRUE"
+				DebugInformationFormat="0"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="winmm.lib"
+				OutputFile="$(OutDir)/string_test.exe"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories="../../../../stage/lib"
+				GenerateDebugInformation="TRUE"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
+			<File
+				RelativePath="..\..\test\string_test.cpp">
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

proj/vc7ide/tree_test.vcproj

@@ -0,0 +1,138 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.10"
+	Name="tree_test"
+	ProjectGUID="{58CCE183-6092-48FE-A4F7-BA0D3A792606}"
+	Keyword="Win32Proj">
+	<Platforms>
+		<Platform
+			Name="Win32"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="../../Bin/Win32/Debug"
+			IntermediateDirectory="Debug/tree_test"
+			ConfigurationType="1"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="../../../.."
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;BOOST_DATE_TIME_NO_LIB"
+				MinimalRebuild="TRUE"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				TreatWChar_tAsBuiltInType="TRUE"
+				ForceConformanceInForLoopScope="FALSE"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				Detect64BitPortabilityProblems="TRUE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="winmm.lib"
+				OutputFile="$(OutDir)/tree_test_d.exe"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories="../../../../stage/lib"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile="$(OutDir)/tree_test.pdb"
+				SubSystem="1"
+				TargetMachine="1"
+				FixedBaseAddress="1"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="../../Bin/Win32/Release"
+			IntermediateDirectory="Release/tree_test"
+			ConfigurationType="1"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="../../../.."
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;BOOST_DATE_TIME_NO_LIB"
+				RuntimeLibrary="2"
+				TreatWChar_tAsBuiltInType="TRUE"
+				ForceConformanceInForLoopScope="FALSE"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				Detect64BitPortabilityProblems="TRUE"
+				DebugInformationFormat="0"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="winmm.lib"
+				OutputFile="$(OutDir)/tree_test.exe"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories="../../../../stage/lib"
+				GenerateDebugInformation="TRUE"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
+			<File
+				RelativePath="..\..\test\tree_test.cpp">
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

proj/vc7ide/vector_test.vcproj

@@ -0,0 +1,138 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.10"
+	Name="vector_test"
+	ProjectGUID="{5CE11C83-096A-84FE-4FA2-D3A6BA792002}"
+	Keyword="Win32Proj">
+	<Platforms>
+		<Platform
+			Name="Win32"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="../../Bin/Win32/Debug"
+			IntermediateDirectory="Debug/vector_test"
+			ConfigurationType="1"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="../../../.."
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;BOOST_DATE_TIME_NO_LIB"
+				MinimalRebuild="TRUE"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				TreatWChar_tAsBuiltInType="TRUE"
+				ForceConformanceInForLoopScope="FALSE"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				Detect64BitPortabilityProblems="TRUE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="winmm.lib"
+				OutputFile="$(OutDir)/vector_test_d.exe"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories="../../../../stage/lib"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile="$(OutDir)/vector_test.pdb"
+				SubSystem="1"
+				TargetMachine="1"
+				FixedBaseAddress="1"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="../../Bin/Win32/Release"
+			IntermediateDirectory="Release/vector_test"
+			ConfigurationType="1"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="../../../.."
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;BOOST_DATE_TIME_NO_LIB"
+				RuntimeLibrary="2"
+				TreatWChar_tAsBuiltInType="TRUE"
+				ForceConformanceInForLoopScope="FALSE"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				Detect64BitPortabilityProblems="TRUE"
+				DebugInformationFormat="0"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="winmm.lib"
+				OutputFile="$(OutDir)/vector_test.exe"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories="../../../../stage/lib"
+				GenerateDebugInformation="TRUE"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{41737BCF-4312-7AC5-A066-32D75A32A2AF}">
+			<File
+				RelativePath="..\..\test\vector_test.cpp">
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93815995-89BD-b043-5E8B-65FBE52E2AFB}">
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

test/Jamfile.v2

@@ -0,0 +1,34 @@
+# Boost Container Library Test Jamfile
+
+#  (C) Copyright Ion Gaztanaga 2009.
+# Use, modification and distribution are subject to 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)
+
+# Adapted from John Maddock's TR1 Jamfile.v2
+# Copyright John Maddock 2005.
+# Use, modification and distribution are subject to 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)
+
+# this rule enumerates through all the sources and invokes
+# the run rule for each source, the result is a list of all
+# the run rules, which we can pass on to the test_suite rule:
+
+rule test_all
+{
+   local all_rules = ;
+
+   for local fileb in [ glob *.cpp ]
+   {
+      all_rules += [ run $(fileb)
+      :  # additional args
+      :  # test-files
+      :  # requirements
+      ] ;
+   }
+
+   return $(all_rules) ;
+}
+
+test-suite container_test : [ test_all r ] ; 

test/check_equal_containers.hpp

@@ -0,0 +1,76 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2006. 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/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_TEST_CHECK_EQUAL_CONTAINERS_HPP
+#define BOOST_CONTAINER_TEST_CHECK_EQUAL_CONTAINERS_HPP
+
+#include <boost/container/detail/config_begin.hpp>
+#include <functional>
+#include <iostream>
+#include <algorithm>
+
+namespace boost{
+namespace container {
+namespace test{
+
+//Function to check if both containers are equal
+template<class MyBoostCont
+        ,class MyStdCont>
+bool CheckEqualContainers(MyBoostCont *boostcont, MyStdCont *stdcont)
+{
+   if(boostcont->size() != stdcont->size())
+      return false;
+
+   typedef typename MyBoostCont::value_type value_type;
+
+   typename MyBoostCont::iterator itboost(boostcont->begin()), itboostend(boostcont->end());
+   typename MyStdCont::iterator itstd(stdcont->begin());
+   typename MyStdCont::size_type dist = (typename MyStdCont::size_type)std::distance(itboost, itboostend);
+   if(dist != boostcont->size()){ 
+      return false;
+   }
+   std::size_t i = 0;
+   for(; itboost != itboostend; ++itboost, ++itstd, ++i){
+      value_type val(*itstd);
+      const value_type &v = *itboost;
+      if(v != val)
+         return false;
+   }
+   return true;
+}
+
+template<class MyBoostCont
+        ,class MyStdCont>
+bool CheckEqualPairContainers(MyBoostCont *boostcont, MyStdCont *stdcont)
+{
+   if(boostcont->size() != stdcont->size())
+      return false;
+
+   typedef typename MyBoostCont::key_type      key_type;
+   typedef typename MyBoostCont::mapped_type   mapped_type;
+
+   typename MyBoostCont::iterator itboost(boostcont->begin()), itboostend(boostcont->end());
+   typename MyStdCont::iterator itstd(stdcont->begin());
+   for(; itboost != itboostend; ++itboost, ++itstd){
+      if(itboost->first != key_type(itstd->first))
+         return false;
+
+      if(itboost->second != mapped_type(itstd->second))
+         return false;
+   }
+   return true;
+}
+}  //namespace test{
+}  //namespace container {
+}  //namespace boost{
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif //#ifndef BOOST_CONTAINER_TEST_CHECK_EQUAL_CONTAINERS_HPP

test/deque_test.cpp

@@ -0,0 +1,295 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2011. 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/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/detail/config_begin.hpp>
+#include <algorithm>
+#include <memory>
+#include <deque>
+#include <iostream>
+#include <functional>
+#include <list>
+
+#include <boost/container/deque.hpp>
+#include "print_container.hpp"
+#include "check_equal_containers.hpp"
+#include "dummy_test_allocator.hpp"
+#include "movable_int.hpp"
+#include <boost/move/move.hpp>
+#include <boost/container/detail/mpl.hpp>
+#include <boost/container/detail/type_traits.hpp>
+#include <string>
+#include "emplace_test.hpp"
+#include "vector_test.hpp"
+
+
+using namespace boost::container;
+
+//Explicit instantiation to detect compilation errors
+template class boost::container::deque
+ < test::movable_and_copyable_int
+ , test::dummy_test_allocator<test::movable_and_copyable_int> >;
+
+//Function to check if both sets are equal
+template<class V1, class V2>
+bool deque_copyable_only(V1 *, V2 *, containers_detail::false_type)
+{
+   return true;
+}
+
+//Function to check if both sets are equal
+template<class V1, class V2>
+bool deque_copyable_only(V1 *cntdeque, V2 *stddeque, containers_detail::true_type)
+{
+   typedef typename V1::value_type IntType;
+   std::size_t size = cntdeque->size();
+   stddeque->insert(stddeque->end(), 50, 1);
+   cntdeque->insert(cntdeque->end(), 50, 1);
+   if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+   {
+      IntType move_me(1);
+      stddeque->insert(stddeque->begin()+size/2, 50, 1);
+      cntdeque->insert(cntdeque->begin()+size/2, 50, boost::move(move_me));
+      if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+   }
+   {
+      IntType move_me(2);
+      cntdeque->assign(cntdeque->size()/2, boost::move(move_me));
+      stddeque->assign(stddeque->size()/2, 2);
+      if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+   }
+   {
+      IntType move_me(1);
+      stddeque->clear();
+      cntdeque->clear();
+      stddeque->insert(stddeque->begin(), 50, 1);
+      cntdeque->insert(cntdeque->begin(), 50, boost::move(move_me));
+      if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+      stddeque->insert(stddeque->begin()+20, 50, 1);
+      cntdeque->insert(cntdeque->begin()+20, 50, boost::move(move_me));
+      if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+      stddeque->insert(stddeque->begin()+20, 20, 1);
+      cntdeque->insert(cntdeque->begin()+20, 20, boost::move(move_me));
+      if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+   }
+   {
+      IntType move_me(1);
+      stddeque->clear();
+      cntdeque->clear();
+      stddeque->insert(stddeque->end(), 50, 1);
+      cntdeque->insert(cntdeque->end(), 50, boost::move(move_me));
+      if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+      stddeque->insert(stddeque->end()-20, 50, 1);
+      cntdeque->insert(cntdeque->end()-20, 50, boost::move(move_me));
+      if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+      stddeque->insert(stddeque->end()-20, 20, 1);
+      cntdeque->insert(cntdeque->end()-20, 20, boost::move(move_me));
+      if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+   }
+
+   return true;
+}
+
+//Test recursive structures
+class recursive_deque
+{
+public:
+   int id_;
+   deque<recursive_deque> deque_;
+};
+
+template<class IntType>
+bool do_test()
+{
+   //Test for recursive types
+   {
+      deque<recursive_deque> recursive_deque_deque;
+   }
+
+   {
+      //Now test move semantics
+      deque<recursive_deque> original;
+      deque<recursive_deque> move_ctor(boost::move(original));
+      deque<recursive_deque> move_assign;
+      move_assign = boost::move(move_ctor);
+      move_assign.swap(original);
+   }
+
+   //Alias deque types
+   typedef deque<IntType>  MyCntDeque;
+   typedef std::deque<int> MyStdDeque;
+   const int max = 100;
+   try{
+      //Shared memory allocator must be always be initialized
+      //since it has no default constructor
+      MyCntDeque *cntdeque = new MyCntDeque;
+      MyStdDeque *stddeque = new MyStdDeque;
+      //Compare several shared memory deque operations with std::deque
+      int i;
+      for(i = 0; i < max*100; ++i){
+         IntType move_me(i);
+         cntdeque->insert(cntdeque->end(), boost::move(move_me));
+         stddeque->insert(stddeque->end(), i);
+      }
+      if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+
+      cntdeque->clear();
+      stddeque->clear();
+
+      for(i = 0; i < max*100; ++i){
+         IntType move_me(i);
+         cntdeque->push_back(boost::move(move_me));
+         stddeque->push_back(i);
+      }
+      if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+
+      cntdeque->clear();
+      stddeque->clear();
+
+      for(i = 0; i < max*100; ++i){
+         IntType move_me(i);
+         cntdeque->push_front(boost::move(move_me));
+         stddeque->push_front(i);
+      }
+      if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+
+      typename MyCntDeque::iterator it;
+      typename MyCntDeque::const_iterator cit = it;
+
+      cntdeque->erase(cntdeque->begin()++);
+      stddeque->erase(stddeque->begin()++);
+      if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+
+      cntdeque->erase(cntdeque->begin());
+      stddeque->erase(stddeque->begin());
+      if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+
+      {
+         //Initialize values
+         IntType aux_vect[50];
+         for(int i = 0; i < 50; ++i){
+            IntType move_me (-1);
+            aux_vect[i] = boost::move(move_me);
+         }
+         int aux_vect2[50];
+         for(int i = 0; i < 50; ++i){
+            aux_vect2[i] = -1;
+         }
+
+         cntdeque->insert(cntdeque->end()
+                           ,boost::make_move_iterator(&aux_vect[0])
+                           ,boost::make_move_iterator(aux_vect + 50));
+         stddeque->insert(stddeque->end(), aux_vect2, aux_vect2 + 50);
+         if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+
+         for(int i = 0, j = static_cast<int>(cntdeque->size()); i < j; ++i){
+            cntdeque->erase(cntdeque->begin());
+            stddeque->erase(stddeque->begin());
+         }
+         if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+      }
+      {
+         IntType aux_vect[50];
+         for(int i = 0; i < 50; ++i){
+            IntType move_me(-1);
+            aux_vect[i] = boost::move(move_me);
+         }
+         int aux_vect2[50];
+         for(int i = 0; i < 50; ++i){
+            aux_vect2[i] = -1;
+         }
+         cntdeque->insert(cntdeque->begin()
+                           ,boost::make_move_iterator(&aux_vect[0])
+                           ,boost::make_move_iterator(aux_vect + 50));
+         stddeque->insert(stddeque->begin(), aux_vect2, aux_vect2 + 50);
+         if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+      }
+
+      if(!deque_copyable_only(cntdeque, stddeque
+                     ,containers_detail::bool_<boost::container::test::is_copyable<IntType>::value>())){
+         return false;
+      }
+
+      cntdeque->erase(cntdeque->begin());
+      stddeque->erase(stddeque->begin());
+
+      if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+
+      for(i = 0; i < max; ++i){
+         IntType move_me(i);
+         cntdeque->insert(cntdeque->begin(), boost::move(move_me));
+         stddeque->insert(stddeque->begin(), i);
+      }
+      if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+
+      //Test insertion from list
+      {
+         std::list<int> l(50, int(1));
+         cntdeque->insert(cntdeque->begin(), l.begin(), l.end());
+         stddeque->insert(stddeque->begin(), l.begin(), l.end());
+         if(!test::CheckEqualContainers(cntdeque, stddeque)) return 1;
+         cntdeque->assign(l.begin(), l.end());
+         stddeque->assign(l.begin(), l.end());
+         if(!test::CheckEqualContainers(cntdeque, stddeque)) return 1;
+      }
+
+      cntdeque->resize(100);
+      stddeque->resize(100);
+      if(!test::CheckEqualContainers(cntdeque, stddeque)) return 1;         
+
+      cntdeque->resize(200);
+      stddeque->resize(200);
+      if(!test::CheckEqualContainers(cntdeque, stddeque)) return 1;         
+
+      delete cntdeque;
+      delete stddeque;
+   }
+   catch(std::exception &ex){
+      std::cout << ex.what() << std::endl;
+      return false;
+   }
+   
+   std::cout << std::endl << "Test OK!" << std::endl;
+   return true;
+}
+
+
+int main ()
+{
+   if(!do_test<int>())
+      return 1;
+
+   if(!do_test<test::movable_int>())
+      return 1;
+
+   {
+      typedef deque<int> MyDeque;
+      typedef deque<test::movable_int> MyMoveDeque;
+      typedef deque<test::movable_and_copyable_int> MyCopyMoveDeque;
+      typedef deque<test::copyable_int> MyCopyDeque;
+      if(test::vector_test<MyDeque>())
+         return 1;
+      if(test::vector_test<MyMoveDeque>())
+         return 1;
+      if(test::vector_test<MyCopyMoveDeque>())
+         return 1;
+      if(test::vector_test<MyCopyDeque>())
+         return 1;
+   }
+
+   const test::EmplaceOptions Options = (test::EmplaceOptions)(test::EMPLACE_BACK | test::EMPLACE_FRONT | test::EMPLACE_BEFORE);
+
+   if(!boost::container::test::test_emplace
+      < deque<test::EmplaceInt>, Options>())
+      return 1;
+
+   return 0;
+}
+
+#include <boost/container/detail/config_end.hpp>

test/dummy_test_allocator.hpp

@@ -0,0 +1,157 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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/container for documentation.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_DUMMY_TEST_ALLOCATOR_HPP
+#define BOOST_CONTAINER_DUMMY_TEST_ALLOCATOR_HPP
+
+#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#  pragma once
+#endif
+
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/workaround.hpp>
+
+#include <boost/container/container_fwd.hpp>
+#include <boost/container/detail/allocation_type.hpp>
+#include <boost/assert.hpp>
+#include <boost/container/detail/utilities.hpp>
+#include <boost/container/detail/type_traits.hpp>
+#include <boost/container/detail/version_type.hpp>
+#include <memory>
+#include <algorithm>
+#include <cstddef>
+#include <stdexcept>
+#include <cassert>
+
+//!\file
+//!Describes an allocator to test expand capabilities
+
+namespace boost {
+namespace container {
+namespace test {
+
+//This allocator just allows two allocations. The first one will return 
+//mp_buffer + m_offset configured in the constructor. The second one
+//will return mp_buffer.
+template<class T>
+class dummy_test_allocator 
+{
+ private:
+   typedef dummy_test_allocator<T> self_t;
+   typedef void *                   aux_pointer_t;
+   typedef const void *             cvoid_ptr;
+
+   template<class T2>
+   dummy_test_allocator& operator=(const dummy_test_allocator<T2>&);
+
+   dummy_test_allocator& operator=(const dummy_test_allocator&);
+
+   public:
+   typedef T                                    value_type;
+   typedef T *                                  pointer;
+   typedef const T *                            const_pointer;
+   typedef typename containers_detail::add_reference
+                     <value_type>::type         reference;
+   typedef typename containers_detail::add_reference
+                     <const value_type>::type   const_reference;
+   typedef std::size_t                          size_type;
+   typedef std::ptrdiff_t                       difference_type;
+
+//   typedef boost::container::version_type<dummy_test_allocator, 2>   version;
+
+   template<class T2>
+   struct rebind
+   {  typedef dummy_test_allocator<T2>   other;   };
+
+   //!Default constructor. Never throws
+   dummy_test_allocator()
+   {} 
+
+   //!Constructor from other dummy_test_allocator. Never throws
+   dummy_test_allocator(const dummy_test_allocator &)
+   {}
+
+   //!Constructor from related dummy_test_allocator. Never throws
+   template<class T2>
+   dummy_test_allocator(const dummy_test_allocator<T2> &)
+   {}
+
+   pointer address(reference value) 
+   {  return pointer(addressof(value));  }
+
+   const_pointer address(const_reference value) const
+   {  return const_pointer(addressof(value));  }
+
+   pointer allocate(size_type, cvoid_ptr = 0)
+   {  return 0; }
+
+   void deallocate(const pointer &, size_type)
+   { }
+
+   template<class Convertible>
+   void construct(pointer, const Convertible &)
+   {}
+
+   void destroy(pointer)
+   {}
+
+   size_type max_size() const
+   {  return 0;   }
+
+   friend void swap(self_t &, self_t &)
+   {}
+
+   //Experimental version 2 dummy_test_allocator functions
+
+   std::pair<pointer, bool>
+      allocation_command(boost::container::allocation_type,
+                         size_type, 
+                         size_type,
+                         size_type &, const pointer & = 0)
+   {  return std::pair<pointer, bool>(pointer(0), true); }
+
+   //!Returns maximum the number of objects the previously allocated memory
+   //!pointed by p can hold.
+   size_type size(const pointer &) const
+   {  return 0; }
+
+   //!Allocates just one object. Memory allocated with this function
+   //!must be deallocated only with deallocate_one().
+   //!Throws boost::container::bad_alloc if there is no enough memory
+   pointer allocate_one()
+   {  return pointer(0);  }
+
+   //!Deallocates memory previously allocated with allocate_one().
+   //!You should never use deallocate_one to deallocate memory allocated
+   //!with other functions different from allocate_one(). Never throws
+   void deallocate_one(const pointer &)
+   {}
+};
+
+//!Equality test for same type of dummy_test_allocator
+template<class T> inline
+bool operator==(const dummy_test_allocator<T>  &, 
+                const dummy_test_allocator<T>  &)
+{  return false; }
+
+//!Inequality test for same type of dummy_test_allocator
+template<class T> inline
+bool operator!=(const dummy_test_allocator<T>  &, 
+                const dummy_test_allocator<T>  &)
+{  return true; }
+
+}  //namespace test {
+}  //namespace container {
+}  //namespace boost {
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif   //BOOST_CONTAINER_DUMMY_TEST_ALLOCATOR_HPP
+

test/emplace_test.hpp

@@ -0,0 +1,625 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2008. 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/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_CONTAINER_TEST_EMPLACE_TEST_HPP
+#define BOOST_CONTAINER_TEST_EMPLACE_TEST_HPP
+
+#include <iostream>
+#include <typeinfo>
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/workaround.hpp>
+#include <boost/container/detail/mpl.hpp>
+#include <boost/move/move.hpp>
+#include <boost/container/detail/utilities.hpp>
+#include <boost/aligned_storage.hpp>
+
+namespace boost{
+namespace container {
+namespace test{
+
+class EmplaceInt
+{
+   BOOST_MOVABLE_BUT_NOT_COPYABLE(EmplaceInt)
+
+   public:
+   EmplaceInt(int a = 0, int b = 0, int c = 0, int d = 0, int e = 0)
+      : a_(a), b_(b), c_(c), d_(d), e_(e)
+   {}
+
+   EmplaceInt(BOOST_RV_REF(EmplaceInt) o)
+      : a_(o.a_), b_(o.b_), c_(o.c_), d_(o.d_), e_(o.e_)
+   {}
+
+   EmplaceInt& operator=(BOOST_RV_REF(EmplaceInt) o)
+   {
+      this->a_ = o.a_;
+      this->b_ = o.b_;
+      this->c_ = o.c_;
+      this->d_ = o.d_;
+      this->e_ = o.e_;
+      return *this;
+   }
+
+   friend bool operator==(const EmplaceInt &l, const EmplaceInt &r)
+   {
+      return l.a_ == r.a_ &&
+             l.b_ == r.b_ &&
+             l.c_ == r.c_ &&
+             l.d_ == r.d_ &&
+             l.e_ == r.e_;
+   }
+
+   friend bool operator<(const EmplaceInt &l, const EmplaceInt &r)
+   {  return l.sum() < r.sum(); }
+
+   friend bool operator>(const EmplaceInt &l, const EmplaceInt &r)
+   {  return l.sum() > r.sum(); }
+
+   friend bool operator!=(const EmplaceInt &l, const EmplaceInt &r)
+   {  return !(l == r); }
+
+   friend std::ostream &operator <<(std::ostream &os, const EmplaceInt &v)
+   {
+      os << "EmplaceInt: " << v.a_ << ' ' << v.b_ << ' ' << v.c_ << ' ' << v.d_ << ' ' << v.e_;
+      return os;
+   }
+
+   ~EmplaceInt()
+   {  a_ = b_ = c_ = d_ = e_ = 0; }
+
+   //private:
+   int sum() const
+   {  return this->a_ + this->b_ + this->c_ + this->d_ + this->e_; }
+
+   int a_, b_, c_, d_, e_;
+   int padding[6];
+};
+
+
+}  //namespace test {
+
+namespace test {
+
+enum EmplaceOptions{
+   EMPLACE_BACK         = 1 << 0,
+   EMPLACE_FRONT        = 1 << 1,
+   EMPLACE_BEFORE       = 1 << 2,
+   EMPLACE_AFTER        = 1 << 3,
+   EMPLACE_ASSOC        = 1 << 4,
+   EMPLACE_HINT         = 1 << 5,
+   EMPLACE_ASSOC_PAIR   = 1 << 6,
+   EMPLACE_HINT_PAIR    = 1 << 7
+};
+
+template<class Container>
+bool test_expected_container(const Container &ec, const EmplaceInt *Expected, unsigned int only_first_n)
+{
+   typedef typename Container::const_iterator const_iterator;
+   const_iterator itb(ec.begin()), ite(ec.end());
+   unsigned int cur = 0;
+   if(only_first_n > ec.size()){
+      return false;
+   }
+   for(; itb != ite && only_first_n--; ++itb, ++cur){
+      const EmplaceInt & cr = *itb;
+      if(cr != Expected[cur]){
+         return false;
+      }
+   }
+   return true;
+}
+
+template<class Container>
+bool test_expected_container(const Container &ec, const std::pair<EmplaceInt, EmplaceInt> *Expected, unsigned int only_first_n)
+{
+   typedef typename Container::const_iterator const_iterator;
+   const_iterator itb(ec.begin()), ite(ec.end());
+   unsigned int cur = 0;
+   if(only_first_n > ec.size()){
+      return false;
+   }
+   for(; itb != ite && only_first_n--; ++itb, ++cur){
+      if(itb->first != Expected[cur].first){
+         std::cout << "Error in first: " << itb->first << ' ' << Expected[cur].first << std::endl;
+         return false;
+
+      }
+      else if(itb->second != Expected[cur].second){
+         std::cout << "Error in second: " << itb->second << ' ' << Expected[cur].second << std::endl;
+         return false;
+      }
+   }
+   return true;
+}
+
+static EmplaceInt expected [10];
+
+typedef std::pair<EmplaceInt, EmplaceInt> EmplaceIntPair;
+static boost::aligned_storage<sizeof(EmplaceIntPair)*10>::type pair_storage;
+
+static EmplaceIntPair* initialize_emplace_int_pair()
+{
+   EmplaceIntPair* ret = reinterpret_cast<EmplaceIntPair*>(&pair_storage);
+   for(unsigned int i = 0; i != 10; ++i){
+      new(&ret->first)EmplaceInt();
+      new(&ret->second)EmplaceInt();
+   }
+   return ret;
+}
+
+static EmplaceIntPair * expected_pair = initialize_emplace_int_pair();
+
+
+template<class Container>
+bool test_emplace_back(containers_detail::true_)
+{
+   std::cout << "Starting test_emplace_back." << std::endl << "  Class: "
+      << typeid(Container).name() << std::endl;
+
+   {
+   new(&expected [0]) EmplaceInt();
+   new(&expected [1]) EmplaceInt(1);
+   new(&expected [2]) EmplaceInt(1, 2);
+   new(&expected [3]) EmplaceInt(1, 2, 3);
+   new(&expected [4]) EmplaceInt(1, 2, 3, 4);
+   new(&expected [5]) EmplaceInt(1, 2, 3, 4, 5);
+   Container c;
+   c.emplace_back();
+   if(!test_expected_container(c, &expected[0], 1))
+      return false;
+   c.emplace_back(1);
+   if(!test_expected_container(c, &expected[0], 2))
+      return false;
+   c.emplace_back(1, 2);
+   if(!test_expected_container(c, &expected[0], 3))
+      return false;
+   c.emplace_back(1, 2, 3);
+   if(!test_expected_container(c, &expected[0], 4))
+      return false;
+   c.emplace_back(1, 2, 3, 4);
+   if(!test_expected_container(c, &expected[0], 5))
+      return false;
+   c.emplace_back(1, 2, 3, 4, 5);
+   if(!test_expected_container(c, &expected[0], 6))
+      return false;
+   }
+
+   return true;
+}
+
+template<class Container>
+bool test_emplace_back(containers_detail::false_)
+{  return true;   }
+
+template<class Container>
+bool test_emplace_front(containers_detail::true_)
+{
+   std::cout << "Starting test_emplace_front." << std::endl << "  Class: "
+      << typeid(Container).name() << std::endl;
+
+   {
+      new(&expected [0]) EmplaceInt(1, 2, 3, 4, 5);
+      new(&expected [1]) EmplaceInt(1, 2, 3, 4);
+      new(&expected [2]) EmplaceInt(1, 2, 3);
+      new(&expected [3]) EmplaceInt(1, 2);
+      new(&expected [4]) EmplaceInt(1);
+      new(&expected [5]) EmplaceInt();
+      Container c;
+      c.emplace_front();
+      if(!test_expected_container(c, &expected[0] + 5, 1))
+         return false;
+      c.emplace_front(1);/*
+      if(!test_expected_container(c, &expected[0] + 4, 2))
+         return false;
+      c.emplace_front(1, 2);
+      if(!test_expected_container(c, &expected[0] + 3, 3))
+         return false;
+      c.emplace_front(1, 2, 3);
+      if(!test_expected_container(c, &expected[0] + 2, 4))
+         return false;
+      c.emplace_front(1, 2, 3, 4);
+      if(!test_expected_container(c, &expected[0] + 1, 5))
+         return false;
+      c.emplace_front(1, 2, 3, 4, 5);
+      if(!test_expected_container(c, &expected[0] + 0, 6))
+         return false;*/
+   }
+   return true;
+}
+
+template<class Container>
+bool test_emplace_front(containers_detail::false_)
+{  return true;   }
+
+template<class Container>
+bool test_emplace_before(containers_detail::true_)
+{
+   std::cout << "Starting test_emplace_before." << std::endl << "  Class: "
+      << typeid(Container).name() << std::endl;
+
+   {
+      new(&expected [0]) EmplaceInt();
+      new(&expected [1]) EmplaceInt(1);
+      new(&expected [2]) EmplaceInt();
+      Container c;
+      c.emplace(c.cend(), 1);
+      c.emplace(c.cbegin());
+      if(!test_expected_container(c, &expected[0], 2))
+         return false;
+      c.emplace(c.cend());
+      if(!test_expected_container(c, &expected[0], 3))
+         return false;
+   }
+   {
+      new(&expected [0]) EmplaceInt();
+      new(&expected [1]) EmplaceInt(1);
+      new(&expected [2]) EmplaceInt(1, 2);
+      new(&expected [3]) EmplaceInt(1, 2, 3);
+      new(&expected [4]) EmplaceInt(1, 2, 3, 4);
+      new(&expected [5]) EmplaceInt(1, 2, 3, 4, 5);
+      //emplace_front-like
+      Container c;
+      c.emplace(c.cbegin(), 1, 2, 3, 4, 5);
+      c.emplace(c.cbegin(), 1, 2, 3, 4);
+      c.emplace(c.cbegin(), 1, 2, 3);
+      c.emplace(c.cbegin(), 1, 2);
+      c.emplace(c.cbegin(), 1);
+      c.emplace(c.cbegin());
+      if(!test_expected_container(c, &expected[0], 6))
+         return false;
+      c.clear();
+      //emplace_back-like
+      typename Container::const_iterator i = c.emplace(c.cend());
+      if(!test_expected_container(c, &expected[0], 1))
+         return false;
+      i = c.emplace(++i, 1);
+      if(!test_expected_container(c, &expected[0], 2))
+         return false;
+      i = c.emplace(++i, 1, 2);
+      if(!test_expected_container(c, &expected[0], 3))
+         return false;
+      i = c.emplace(++i, 1, 2, 3);
+      if(!test_expected_container(c, &expected[0], 4))
+         return false;
+      i = c.emplace(++i, 1, 2, 3, 4);
+      if(!test_expected_container(c, &expected[0], 5))
+         return false;
+      i = c.emplace(++i, 1, 2, 3, 4, 5);
+      if(!test_expected_container(c, &expected[0], 6))
+         return false;
+      c.clear();
+      //emplace in the middle
+      c.emplace(c.cbegin());
+      i = c.emplace(c.cend(), 1, 2, 3, 4, 5);
+      i = c.emplace(i, 1, 2, 3, 4);
+      i = c.emplace(i, 1, 2, 3);
+      i = c.emplace(i, 1, 2);
+      i = c.emplace(i, 1);
+
+      if(!test_expected_container(c, &expected[0], 6))
+         return false;
+   }
+   return true;
+}
+
+template<class Container>
+bool test_emplace_before(containers_detail::false_)
+{  return true;   }
+
+template<class Container>
+bool test_emplace_after(containers_detail::true_)
+{
+   std::cout << "Starting test_emplace_after." << std::endl << "  Class: "
+      << typeid(Container).name() << std::endl;
+   {
+      new(&expected [0]) EmplaceInt();
+      new(&expected [1]) EmplaceInt(1);
+      new(&expected [2]) EmplaceInt();
+      Container c;
+      typename Container::const_iterator i = c.emplace_after(c.cbefore_begin(), 1);
+      c.emplace_after(c.cbefore_begin());
+      if(!test_expected_container(c, &expected[0], 2))
+         return false;
+      c.emplace_after(i);
+      if(!test_expected_container(c, &expected[0], 3))
+         return false;
+   }
+   {
+      new(&expected [0]) EmplaceInt();
+      new(&expected [1]) EmplaceInt(1);
+      new(&expected [2]) EmplaceInt(1, 2);
+      new(&expected [3]) EmplaceInt(1, 2, 3);
+      new(&expected [4]) EmplaceInt(1, 2, 3, 4);
+      new(&expected [5]) EmplaceInt(1, 2, 3, 4, 5);
+      //emplace_front-like
+      Container c;
+      c.emplace_after(c.cbefore_begin(), 1, 2, 3, 4, 5);
+      c.emplace_after(c.cbefore_begin(), 1, 2, 3, 4);
+      c.emplace_after(c.cbefore_begin(), 1, 2, 3);
+      c.emplace_after(c.cbefore_begin(), 1, 2);
+      c.emplace_after(c.cbefore_begin(), 1);
+      c.emplace_after(c.cbefore_begin());
+      if(!test_expected_container(c, &expected[0], 6))
+         return false;
+      c.clear();
+      //emplace_back-like
+      typename Container::const_iterator i = c.emplace_after(c.cbefore_begin());
+      if(!test_expected_container(c, &expected[0], 1))
+         return false;
+      i = c.emplace_after(i, 1);
+      if(!test_expected_container(c, &expected[0], 2))
+         return false;
+      i = c.emplace_after(i, 1, 2);
+      if(!test_expected_container(c, &expected[0], 3))
+         return false;
+      i = c.emplace_after(i, 1, 2, 3);
+      if(!test_expected_container(c, &expected[0], 4))
+         return false;
+      i = c.emplace_after(i, 1, 2, 3, 4);
+      if(!test_expected_container(c, &expected[0], 5))
+         return false;
+      i = c.emplace_after(i, 1, 2, 3, 4, 5);
+      if(!test_expected_container(c, &expected[0], 6))
+         return false;
+      c.clear();
+      //emplace_after in the middle
+      i = c.emplace_after(c.cbefore_begin());
+      c.emplace_after(i, 1, 2, 3, 4, 5);
+      c.emplace_after(i, 1, 2, 3, 4);
+      c.emplace_after(i, 1, 2, 3);
+      c.emplace_after(i, 1, 2);
+      c.emplace_after(i, 1);
+
+      if(!test_expected_container(c, &expected[0], 6))
+         return false;
+   }
+   return true;
+}
+
+template<class Container>
+bool test_emplace_after(containers_detail::false_)
+{  return true;   }
+
+template<class Container>
+bool test_emplace_assoc(containers_detail::true_)
+{
+   std::cout << "Starting test_emplace_assoc." << std::endl << "  Class: "
+      << typeid(Container).name() << std::endl;
+
+   new(&expected [0]) EmplaceInt();
+   new(&expected [1]) EmplaceInt(1);
+   new(&expected [2]) EmplaceInt(1, 2);
+   new(&expected [3]) EmplaceInt(1, 2, 3);
+   new(&expected [4]) EmplaceInt(1, 2, 3, 4);
+   new(&expected [5]) EmplaceInt(1, 2, 3, 4, 5);
+   {
+      Container c;
+      c.emplace();
+      if(!test_expected_container(c, &expected[0], 1))
+         return false;
+      c.emplace(1);
+      if(!test_expected_container(c, &expected[0], 2))
+         return false;
+      c.emplace(1, 2);
+      if(!test_expected_container(c, &expected[0], 3))
+         return false;
+      c.emplace(1, 2, 3);
+      if(!test_expected_container(c, &expected[0], 4))
+         return false;
+      c.emplace(1, 2, 3, 4);
+      if(!test_expected_container(c, &expected[0], 5))
+         return false;
+      c.emplace(1, 2, 3, 4, 5);
+      if(!test_expected_container(c, &expected[0], 6))
+         return false;
+   }
+   return true;
+}
+
+template<class Container>
+bool test_emplace_assoc(containers_detail::false_)
+{  return true;   }
+
+template<class Container>
+bool test_emplace_hint(containers_detail::true_)
+{
+   std::cout << "Starting test_emplace_hint." << std::endl << "  Class: "
+      << typeid(Container).name() << std::endl;
+
+   new(&expected [0]) EmplaceInt();
+   new(&expected [1]) EmplaceInt(1);
+   new(&expected [2]) EmplaceInt(1, 2);
+   new(&expected [3]) EmplaceInt(1, 2, 3);
+   new(&expected [4]) EmplaceInt(1, 2, 3, 4);
+   new(&expected [5]) EmplaceInt(1, 2, 3, 4, 5);
+
+   {
+      Container c;
+      typename Container::const_iterator it;
+      it = c.emplace_hint(c.begin());
+      if(!test_expected_container(c, &expected[0], 1))
+         return false;
+      it = c.emplace_hint(it, 1);
+      if(!test_expected_container(c, &expected[0], 2))
+         return false;
+      it = c.emplace_hint(it, 1, 2);
+      if(!test_expected_container(c, &expected[0], 3))
+         return false;
+      it = c.emplace_hint(it, 1, 2, 3);
+      if(!test_expected_container(c, &expected[0], 4))
+         return false;
+      it = c.emplace_hint(it, 1, 2, 3, 4);
+      if(!test_expected_container(c, &expected[0], 5))
+         return false;
+      it = c.emplace_hint(it, 1, 2, 3, 4, 5);
+      if(!test_expected_container(c, &expected[0], 6))
+         return false;
+   }
+
+   return true;
+}
+
+template<class Container>
+bool test_emplace_hint(containers_detail::false_)
+{  return true;   }
+
+template<class Container>
+bool test_emplace_assoc_pair(containers_detail::true_)
+{
+   std::cout << "Starting test_emplace_assoc_pair." << std::endl << "  Class: "
+      << typeid(Container).name() << std::endl;
+
+   new(&expected_pair[0].first) EmplaceInt();
+   new(&expected_pair[0].second) EmplaceInt();
+   new(&expected_pair[1].first) EmplaceInt(1);
+   new(&expected_pair[1].second) EmplaceInt();
+   new(&expected_pair[2].first) EmplaceInt(2);
+   new(&expected_pair[2].second) EmplaceInt(2);
+   new(&expected_pair[3].first) EmplaceInt(3);
+   new(&expected_pair[3].second) EmplaceInt(2, 3);
+   new(&expected_pair[4].first) EmplaceInt(4);
+   new(&expected_pair[4].second) EmplaceInt(2, 3, 4);
+   new(&expected_pair[5].first) EmplaceInt(5);
+   new(&expected_pair[5].second) EmplaceInt(2, 3, 4, 5);
+   {
+      Container c;
+      c.emplace();
+      if(!test_expected_container(c, &expected_pair[0], 1)){
+         std::cout << "Error after c.emplace();\n";
+         return false;
+      }
+      c.emplace(1);
+      if(!test_expected_container(c, &expected_pair[0], 2)){
+         std::cout << "Error after c.emplace(1);\n";
+         return false;
+      }
+      c.emplace(2, 2);
+      if(!test_expected_container(c, &expected_pair[0], 3)){
+         std::cout << "Error after c.emplace(2, 2);\n";
+         return false;
+      }
+      c.emplace(3, 2, 3);
+      if(!test_expected_container(c, &expected_pair[0], 4)){
+         std::cout << "Error after c.emplace(3, 2, 3);\n";
+         return false;
+      }
+      c.emplace(4, 2, 3, 4);
+      if(!test_expected_container(c, &expected_pair[0], 5)){
+         std::cout << "Error after c.emplace(4, 2, 3, 4);\n";
+         return false;
+      }
+      c.emplace(5, 2, 3, 4, 5);
+      if(!test_expected_container(c, &expected_pair[0], 6)){
+         std::cout << "Error after c.emplace(5, 2, 3, 4, 5);\n";
+         return false;
+      }
+   }
+   return true;
+}
+
+template<class Container>
+bool test_emplace_assoc_pair(containers_detail::false_)
+{  return true;   }
+
+template<class Container>
+bool test_emplace_hint_pair(containers_detail::true_)
+{
+   std::cout << "Starting test_emplace_hint_pair." << std::endl << "  Class: "
+      << typeid(Container).name() << std::endl;
+
+   new(&expected_pair[0].first) EmplaceInt();
+   new(&expected_pair[0].second) EmplaceInt();
+   new(&expected_pair[1].first) EmplaceInt(1);
+   new(&expected_pair[1].second) EmplaceInt();
+   new(&expected_pair[2].first) EmplaceInt(2);
+   new(&expected_pair[2].second) EmplaceInt(2);
+   new(&expected_pair[3].first) EmplaceInt(3);
+   new(&expected_pair[3].second) EmplaceInt(2, 3);
+   new(&expected_pair[4].first) EmplaceInt(4);
+   new(&expected_pair[4].second) EmplaceInt(2, 3, 4);
+   new(&expected_pair[5].first) EmplaceInt(5);
+   new(&expected_pair[5].second) EmplaceInt(2, 3, 4, 5);
+   {
+      Container c;
+      typename Container::const_iterator it;
+      it = c.emplace_hint(c.begin());
+      if(!test_expected_container(c, &expected_pair[0], 1)){
+         std::cout << "Error after c.emplace(1);\n";
+         return false;
+      }
+      it = c.emplace_hint(it, 1);
+      if(!test_expected_container(c, &expected_pair[0], 2)){
+         std::cout << "Error after c.emplace(it, 1);\n";
+         return false;
+      }
+      it = c.emplace_hint(it, 2, 2);
+      if(!test_expected_container(c, &expected_pair[0], 3)){
+         std::cout << "Error after c.emplace(it, 2, 2);\n";
+         return false;
+      }
+      it = c.emplace_hint(it, 3, 2, 3);
+      if(!test_expected_container(c, &expected_pair[0], 4)){
+         std::cout << "Error after c.emplace(it, 3, 2, 3);\n";
+         return false;
+      }
+      it = c.emplace_hint(it, 4, 2, 3, 4);
+      if(!test_expected_container(c, &expected_pair[0], 5)){
+         std::cout << "Error after c.emplace(it, 4, 2, 3, 4);\n";
+         return false;
+      }
+      it = c.emplace_hint(it, 5, 2, 3, 4, 5);
+      if(!test_expected_container(c, &expected_pair[0], 6)){
+         std::cout << "Error after c.emplace(it, 5, 2, 3, 4, 5);\n";
+         return false;
+      }
+   }
+   return true;
+}
+
+template<class Container>
+bool test_emplace_hint_pair(containers_detail::false_)
+{  return true;   }
+
+template <EmplaceOptions O, EmplaceOptions Mask>
+struct emplace_active
+{
+   static const bool value = (0 != (O & Mask));
+   typedef containers_detail::bool_<value> type;
+   operator type() const{  return type(); }
+};
+
+template<class Container, EmplaceOptions O>
+bool test_emplace()
+{
+//   if(!test_emplace_back<Container>(emplace_active<O, EMPLACE_BACK>()))
+//      return false;
+   if(!test_emplace_front<Container>(emplace_active<O, EMPLACE_FRONT>()))
+      return false;/*
+   if(!test_emplace_before<Container>(emplace_active<O, EMPLACE_BEFORE>()))
+      return false;
+   if(!test_emplace_after<Container>(emplace_active<O, EMPLACE_AFTER>()))
+      return false;
+   if(!test_emplace_assoc<Container>(emplace_active<O, EMPLACE_ASSOC>()))
+      return false;
+   if(!test_emplace_hint<Container>(emplace_active<O, EMPLACE_HINT>()))
+      return false;
+   if(!test_emplace_assoc_pair<Container>(emplace_active<O, EMPLACE_ASSOC_PAIR>()))
+      return false;
+   if(!test_emplace_hint_pair<Container>(emplace_active<O, EMPLACE_HINT_PAIR>()))
+      return false;*/
+   return true;
+}
+
+}  //namespace test{
+}  //namespace container {
+}  //namespace boost{
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_CONTAINER_TEST_EMPLACE_TEST_HPP

test/expand_bwd_test_allocator.hpp

@@ -0,0 +1,193 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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/container for documentation.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_EXPAND_BWD_TEST_ALLOCATOR_HPP
+#define BOOST_CONTAINER_EXPAND_BWD_TEST_ALLOCATOR_HPP
+
+#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#  pragma once
+#endif
+
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/workaround.hpp>
+
+#include <boost/container/container_fwd.hpp>
+#include <boost/container/detail/allocation_type.hpp>
+#include <boost/assert.hpp>
+#include <boost/container/detail/utilities.hpp>
+#include <boost/container/detail/version_type.hpp>
+#include <memory>
+#include <algorithm>
+#include <cstddef>
+#include <stdexcept>
+#include <cassert>
+
+//!\file
+//!Describes an allocator to test expand capabilities
+
+namespace boost {
+namespace container {
+namespace test {
+
+//This allocator just allows two allocations. The first one will return 
+//mp_buffer + m_offset configured in the constructor. The second one
+//will return mp_buffer.
+template<class T>
+class expand_bwd_test_allocator 
+{
+ private:
+   typedef expand_bwd_test_allocator<T> self_t;
+   typedef void *                   aux_pointer_t;
+   typedef const void *             cvoid_ptr;
+
+   template<class T2>
+   expand_bwd_test_allocator& operator=(const expand_bwd_test_allocator<T2>&);
+
+   expand_bwd_test_allocator& operator=(const expand_bwd_test_allocator&);
+
+   public:
+   typedef T                                    value_type;
+   typedef T *                                  pointer;
+   typedef const T *                            const_pointer;
+   typedef typename containers_detail::add_reference
+                     <value_type>::type         reference;
+   typedef typename containers_detail::add_reference
+                     <const value_type>::type   const_reference;
+   typedef std::size_t                          size_type;
+   typedef std::ptrdiff_t                       difference_type;
+
+   typedef boost::container::containers_detail::version_type<expand_bwd_test_allocator, 2>   version;
+
+   template<class T2>
+   struct rebind
+   {  typedef expand_bwd_test_allocator<T2>   other;   };
+
+   //!Constructor from the segment manager. Never throws
+   expand_bwd_test_allocator(T *buffer, size_type size, difference_type offset) 
+      : mp_buffer(buffer), m_size(size)
+      , m_offset(offset),  m_allocations(0){ }
+
+   //!Constructor from other expand_bwd_test_allocator. Never throws
+   expand_bwd_test_allocator(const expand_bwd_test_allocator &other) 
+      : mp_buffer(other.mp_buffer), m_size(other.m_size)
+      , m_offset(other.m_offset),  m_allocations(0){ }
+
+   //!Constructor from related expand_bwd_test_allocator. Never throws
+   template<class T2>
+   expand_bwd_test_allocator(const expand_bwd_test_allocator<T2> &other)
+      : mp_buffer(other.mp_buffer), m_size(other.m_size)
+      , m_offset(other.m_offset),  m_allocations(0){ }
+
+   pointer address(reference value)
+   {  return pointer(addressof(value));  }
+
+   const_pointer address(const_reference value) const
+   {  return const_pointer(addressof(value));  }
+
+   pointer allocate(size_type , cvoid_ptr hint = 0)
+   {  (void)hint; return 0; }
+
+   void deallocate(const pointer &, size_type)
+   {}
+
+   template<class Convertible>
+   void construct(pointer ptr, const Convertible &value)
+   {  new((void*)ptr) value_type(value);  }
+
+   void destroy(pointer ptr)
+   {  (*ptr).~value_type();  }
+
+   size_type max_size() const
+   {  return m_size;   }
+
+   friend void swap(self_t &alloc1, self_t &alloc2)
+   {  
+      containers_detail::do_swap(alloc1.mp_buffer, alloc2.mp_buffer);
+      containers_detail::do_swap(alloc1.m_size,    alloc2.m_size);
+      containers_detail::do_swap(alloc1.m_offset,  alloc2.m_offset);
+   }
+
+   //Experimental version 2 expand_bwd_test_allocator functions
+
+   std::pair<pointer, bool>
+      allocation_command(boost::container::allocation_type command,
+                         size_type limit_size, 
+                         size_type preferred_size,
+                         size_type &received_size, const pointer &reuse = 0)
+   {
+      (void)preferred_size;   (void)reuse;   (void)command;
+      //This allocator only expands backwards!
+      assert(m_allocations == 0 || (command & boost::container::expand_bwd));
+      
+      received_size = limit_size;
+
+      if(m_allocations == 0){
+         if((m_offset + limit_size) > m_size){
+            assert(0);
+         }
+         ++m_allocations;
+         return std::pair<pointer, bool>(mp_buffer + m_offset, false);
+      }
+      else if(m_allocations == 1){
+         if(limit_size > m_size){
+            assert(0);
+         }
+         ++m_allocations;
+         return std::pair<pointer, bool>(mp_buffer, true);
+      }
+      else{
+         assert(0);
+         throw std::bad_alloc();
+      }
+   }
+
+   //!Returns maximum the number of objects the previously allocated memory
+   //!pointed by p can hold.
+   size_type size(const pointer &p) const
+   {  (void)p; return m_size; }
+
+   //!Allocates just one object. Memory allocated with this function
+   //!must be deallocated only with deallocate_one().
+   //!Throws boost::container::bad_alloc if there is no enough memory
+   pointer allocate_one()
+   {  return this->allocate(1);  }
+
+   //!Deallocates memory previously allocated with allocate_one().
+   //!You should never use deallocate_one to deallocate memory allocated
+   //!with other functions different from allocate_one(). Never throws
+   void deallocate_one(const pointer &p)
+   {  return this->deallocate(p, 1);  }
+
+   pointer           mp_buffer;
+   size_type         m_size;
+   difference_type   m_offset;
+   char              m_allocations;
+};
+
+//!Equality test for same type of expand_bwd_test_allocator
+template<class T> inline
+bool operator==(const expand_bwd_test_allocator<T>  &alloc1, 
+                const expand_bwd_test_allocator<T>  &alloc2)
+{  return false; }
+
+//!Inequality test for same type of expand_bwd_test_allocator
+template<class T> inline
+bool operator!=(const expand_bwd_test_allocator<T>  &alloc1, 
+                const expand_bwd_test_allocator<T>  &alloc2)
+{  return true; }
+
+}  //namespace test {
+}  //namespace container {
+}  //namespace boost {
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif   //BOOST_CONTAINER_EXPAND_BWD_TEST_ALLOCATOR_HPP
+

test/expand_bwd_test_template.hpp

@@ -0,0 +1,269 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2006. 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/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_TEST_ALLOCATION_TEST_TEMPLATE_HEADER
+#define BOOST_CONTAINER_TEST_ALLOCATION_TEST_TEMPLATE_HEADER
+
+#include <boost/container/detail/config_begin.hpp>
+#include <vector>
+#include <typeinfo>
+#include "expand_bwd_test_allocator.hpp"
+#include <algorithm>
+#include <boost/type_traits/remove_volatile.hpp>
+
+namespace boost { namespace container { namespace test {
+
+template<class T>
+struct value_holder
+{
+   value_holder(T val)  :  m_value(val){}
+   value_holder(): m_value(0){}
+   ~value_holder(){ m_value = 0; }
+   bool operator == (const value_holder &other) const
+   {  return m_value == other.m_value; }
+   bool operator != (const value_holder &other) const
+   {  return m_value != other.m_value; }
+
+   T m_value;
+};
+
+template<class T>
+struct triple_value_holder
+{
+   triple_value_holder(T val)
+      :  m_value1(val)
+      ,  m_value2(val)
+      ,  m_value3(val)
+   {}
+
+   triple_value_holder()
+      :  m_value1(0)
+      ,  m_value2(0)
+      ,  m_value3(0)
+   {}
+
+   ~triple_value_holder()
+   {  m_value1 = m_value2 = m_value3 = 0; }
+
+   bool operator == (const triple_value_holder &other) const
+   {
+      return   m_value1 == other.m_value1
+         &&    m_value2 == other.m_value2
+         &&    m_value3 == other.m_value3;
+   }
+
+   bool operator != (const triple_value_holder &other) const
+   {
+      return   m_value1 != other.m_value1
+         ||    m_value2 != other.m_value2
+         ||    m_value3 != other.m_value3;
+   }
+
+   T m_value1;
+   T m_value2;
+   T m_value3;
+};
+
+typedef value_holder<int> int_holder;
+typedef triple_value_holder<int> triple_int_holder;
+
+
+
+//Function to check if both sets are equal
+template <class Vector1, class Vector2>
+bool CheckEqualVector(const Vector1 &vector1, const Vector2 &vector2)
+{
+   if(vector1.size() != vector2.size())
+      return false;
+   return std::equal(vector1.begin(), vector1.end(), vector2.begin());
+}
+
+template<class Vector>
+bool CheckUninitializedIsZero(const Vector & v)
+{
+   typedef  typename Vector::value_type value_type;
+   typename Vector::size_type sz    = v.size();
+   typename Vector::size_type extra = v.capacity() - v.size();
+   value_type comp(0);
+
+   const value_type *holder = &v[0] + sz;
+
+   while(extra--){
+      if(*holder++ != comp)
+         return false;
+   }
+   return true;
+}
+
+
+//This function tests all the possible combinations when
+//inserting data in a vector and expanding backwards
+template<class VectorWithExpandBwdAllocator>
+bool test_insert_with_expand_bwd()
+{
+   typedef typename VectorWithExpandBwdAllocator::value_type value_type;
+   typedef typename boost::remove_volatile<value_type>::type non_volatile_value_type;
+   typedef std::vector<non_volatile_value_type> Vect;
+   const int MemorySize = 1000;
+
+   //Distance old and new buffer
+   const int Offset[]      = 
+      {  350,  250,  150,  150,
+         150,  50,   50,   50    };
+   //Insert position
+   const int Position[]    = 
+      {  100,  100,  100,  100,
+         100,  100,  100,  100   };
+   //Initial vector size
+   const int InitialSize[] = 
+      {  200,  200,  200,  200,
+         200,  200,  200,  200   };
+   //Size of the data to insert
+   const int InsertSize[]  = 
+      {  100,  100,  100,  200,
+         300,  25,   100,  200   };
+   //Number of tests
+   const int Iterations    = sizeof(InsertSize)/sizeof(int);
+
+   for(int iteration = 0; iteration < Iterations; ++iteration)
+   {
+      value_type *memory = new value_type[MemorySize];
+      try {
+         std::vector<non_volatile_value_type> initial_data;
+         initial_data.resize(InitialSize[iteration]);
+         for(int i = 0; i < InitialSize[iteration]; ++i){
+            initial_data[i] = i;
+         }
+
+         Vect data_to_insert;
+         data_to_insert.resize(InsertSize[iteration]);
+         for(int i = 0; i < InsertSize[iteration]; ++i){
+            data_to_insert[i] = -i;
+         }
+
+         expand_bwd_test_allocator<value_type> alloc
+            (&memory[0], MemorySize, Offset[iteration]);
+         VectorWithExpandBwdAllocator vector(alloc);
+         vector.insert( vector.begin()
+                     , initial_data.begin(), initial_data.end());
+         vector.insert( vector.begin() + Position[iteration]
+                     , data_to_insert.begin(), data_to_insert.end());
+         initial_data.insert(initial_data.begin() + Position[iteration]
+                           , data_to_insert.begin(), data_to_insert.end());
+         //Now check that values are equal
+         if(!CheckEqualVector(vector, initial_data)){
+            std::cout << "test_assign_with_expand_bwd::CheckEqualVector failed." << std::endl 
+                     << "   Class: " << typeid(VectorWithExpandBwdAllocator).name() << std::endl
+                     << "   Iteration: " << iteration << std::endl;
+            return false;
+         }
+      }
+      catch(...){
+         delete [](const_cast<non_volatile_value_type*>(memory));
+         throw;
+      }
+      delete [](const_cast<non_volatile_value_type*>(memory));
+   }
+
+   return true;
+}
+
+//This function tests all the possible combinations when
+//inserting data in a vector and expanding backwards
+template<class VectorWithExpandBwdAllocator>
+bool test_assign_with_expand_bwd()
+{
+   typedef typename VectorWithExpandBwdAllocator::value_type value_type;
+   typedef typename boost::remove_volatile<value_type>::type non_volatile_value_type;
+   typedef std::vector<non_volatile_value_type> Vect;
+   const int MemorySize = 200;
+
+   const int Offset[]      = { 50, 50, 50};
+   const int InitialSize[] = { 25, 25, 25};
+   const int AssignSize[]  = { 40, 60, 80};
+   const int Iterations    = sizeof(AssignSize)/sizeof(int);
+
+   for(int iteration = 0; iteration <Iterations; ++iteration)
+   {
+      value_type *memory = new value_type[MemorySize];
+      try {
+         //Create initial data
+         std::vector<non_volatile_value_type> initial_data;
+         initial_data.resize(InitialSize[iteration]);
+         for(int i = 0; i < InitialSize[iteration]; ++i){
+            initial_data[i] = i;
+         }
+
+         //Create data to assign
+         std::vector<non_volatile_value_type> data_to_assign;
+         data_to_assign.resize(AssignSize[iteration]);
+         for(int i = 0; i < AssignSize[iteration]; ++i){
+            data_to_assign[i] = -i;
+         }
+
+         //Insert initial data to the vector to test
+         expand_bwd_test_allocator<value_type> alloc
+            (&memory[0], MemorySize, Offset[iteration]);
+         VectorWithExpandBwdAllocator vector(alloc);
+         vector.insert( vector.begin()
+                     , initial_data.begin(), initial_data.end());
+
+         //Assign data 
+         vector.assign(data_to_assign.begin(), data_to_assign.end());
+         initial_data.assign(data_to_assign.begin(), data_to_assign.end());
+
+         //Now check that values are equal
+         if(!CheckEqualVector(vector, initial_data)){
+            std::cout << "test_assign_with_expand_bwd::CheckEqualVector failed." << std::endl 
+                     << "   Class: " << typeid(VectorWithExpandBwdAllocator).name() << std::endl
+                     << "   Iteration: " << iteration << std::endl;
+            return false;
+         }
+      }
+      catch(...){
+         delete [](const_cast<typename boost::remove_volatile<value_type>::type*>(memory));
+         throw;
+      }
+      delete [](const_cast<typename boost::remove_volatile<value_type>::type*>(memory));
+   }
+
+   return true;
+}
+
+//This function calls all tests
+template<class VectorWithExpandBwdAllocator>
+bool test_all_expand_bwd()
+{
+   std::cout << "Starting test_insert_with_expand_bwd." << std::endl << "  Class: "
+             << typeid(VectorWithExpandBwdAllocator).name() << std::endl;
+
+   if(!test_insert_with_expand_bwd<VectorWithExpandBwdAllocator>()){
+      std::cout << "test_allocation_direct_deallocation failed. Class: "
+                << typeid(VectorWithExpandBwdAllocator).name() << std::endl;
+      return false;
+   }
+
+   std::cout << "Starting test_assign_with_expand_bwd." << std::endl << "  Class: "
+             << typeid(VectorWithExpandBwdAllocator).name() << std::endl;
+
+   if(!test_assign_with_expand_bwd<VectorWithExpandBwdAllocator>()){
+      std::cout << "test_allocation_direct_deallocation failed. Class: "
+                << typeid(VectorWithExpandBwdAllocator).name() << std::endl;
+      return false;
+   }
+
+   return true;
+}
+
+}}}   //namespace boost { namespace container { namespace test {
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif   //BOOST_CONTAINER_TEST_ALLOCATION_TEST_TEMPLATE_HEADER

test/flat_tree_test.cpp

@@ -0,0 +1,333 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2011. 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/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/detail/config_begin.hpp>
+#include <set>
+#include <boost/container/flat_set.hpp>
+#include <boost/container/flat_map.hpp>
+#include "print_container.hpp"
+#include "dummy_test_allocator.hpp"
+#include "movable_int.hpp"
+#include "set_test.hpp"
+#include "map_test.hpp"
+#include "emplace_test.hpp"
+
+using namespace boost::container;
+
+//Alias allocator type
+typedef std::allocator<int> allocator_t;
+typedef std::allocator<test::movable_int> 
+   movable_allocator_t;
+typedef std::allocator<std::pair<int, int> > 
+   pair_allocator_t;
+typedef std::allocator<std::pair<test::movable_int, test::movable_int> > 
+   movable_pair_allocator_t;
+typedef std::allocator<test::movable_and_copyable_int > 
+   move_copy_allocator_t;
+typedef std::allocator<std::pair<test::movable_and_copyable_int, test::movable_and_copyable_int> > 
+   move_copy_pair_allocator_t;
+typedef std::allocator<test::copyable_int > 
+   copy_allocator_t;
+typedef std::allocator<std::pair<test::copyable_int, test::copyable_int> > 
+   copy_pair_allocator_t;
+
+
+//Alias set types
+typedef std::set<int>                                                   MyStdSet;
+typedef std::multiset<int>                                              MyStdMultiSet;
+typedef std::map<int, int>                                              MyStdMap;
+typedef std::multimap<int, int>                                         MyStdMultiMap;
+
+typedef flat_set<int, std::less<int>, allocator_t>                MyBoostSet;
+typedef flat_multiset<int, std::less<int>, allocator_t>           MyBoostMultiSet;
+typedef flat_map<int, int, std::less<int>, pair_allocator_t>      MyBoostMap;
+typedef flat_multimap<int, int, std::less<int>, pair_allocator_t> MyBoostMultiMap;
+
+typedef flat_set<test::movable_int, std::less<test::movable_int>
+                ,movable_allocator_t>                             MyMovableBoostSet;
+typedef flat_multiset<test::movable_int,std::less<test::movable_int>
+                     ,movable_allocator_t>                        MyMovableBoostMultiSet;
+typedef flat_map<test::movable_int, test::movable_int
+                ,std::less<test::movable_int>
+                ,movable_pair_allocator_t>                        MyMovableBoostMap;
+typedef flat_multimap<test::movable_int, test::movable_int
+                ,std::less<test::movable_int>
+                ,movable_pair_allocator_t>                        MyMovableBoostMultiMap;
+
+typedef flat_set<test::movable_and_copyable_int, std::less<test::movable_and_copyable_int>
+                ,move_copy_allocator_t>                             MyMoveCopyBoostSet;
+typedef flat_multiset<test::movable_and_copyable_int,std::less<test::movable_and_copyable_int>
+                     ,move_copy_allocator_t>                        MyMoveCopyBoostMultiSet;
+typedef flat_map<test::movable_and_copyable_int, test::movable_and_copyable_int
+                ,std::less<test::movable_and_copyable_int>
+                ,move_copy_pair_allocator_t>                        MyMoveCopyBoostMap;
+typedef flat_multimap<test::movable_and_copyable_int, test::movable_and_copyable_int
+                ,std::less<test::movable_and_copyable_int>
+                ,move_copy_pair_allocator_t>                        MyMoveCopyBoostMultiMap;
+
+typedef flat_set<test::copyable_int, std::less<test::copyable_int>
+                ,copy_allocator_t>                             MyCopyBoostSet;
+typedef flat_multiset<test::copyable_int,std::less<test::copyable_int>
+                     ,copy_allocator_t>                        MyCopyBoostMultiSet;
+typedef flat_map<test::copyable_int, test::copyable_int
+                ,std::less<test::copyable_int>
+                ,copy_pair_allocator_t>                        MyCopyBoostMap;
+typedef flat_multimap<test::copyable_int, test::copyable_int
+                ,std::less<test::copyable_int>
+                ,copy_pair_allocator_t>                        MyCopyBoostMultiMap;
+
+
+
+//Test recursive structures
+class recursive_flat_set
+{
+   public:
+   recursive_flat_set(const recursive_flat_set &c)
+      : id_(c.id_), flat_set_(c.flat_set_)
+   {}
+
+   recursive_flat_set & operator =(const recursive_flat_set &c)
+   {
+      id_ = c.id_;
+      flat_set_= c.flat_set_;
+      return *this;
+   }
+   int id_;
+   flat_set<recursive_flat_set> flat_set_;
+   friend bool operator< (const recursive_flat_set &a, const recursive_flat_set &b)
+   {  return a.id_ < b.id_;   }
+};
+
+
+
+class recursive_flat_map
+{
+   public:
+   recursive_flat_map(const recursive_flat_map &c)
+      : id_(c.id_), map_(c.map_)
+   {}
+
+   recursive_flat_map & operator =(const recursive_flat_map &c)
+   {
+      id_ = c.id_;
+      map_= c.map_;
+      return *this;
+   }
+
+   int id_;
+   flat_map<recursive_flat_map, recursive_flat_map> map_;
+
+   friend bool operator< (const recursive_flat_map &a, const recursive_flat_map &b)
+   {  return a.id_ < b.id_;   }
+};
+
+//Test recursive structures
+class recursive_flat_multiset
+{
+   public:
+   recursive_flat_multiset(const recursive_flat_multiset &c)
+      : id_(c.id_), flat_set_(c.flat_set_)
+   {}
+
+   recursive_flat_multiset & operator =(const recursive_flat_multiset &c)
+   {
+      id_ = c.id_;
+      flat_set_= c.flat_set_;
+      return *this;
+   }
+   int id_;
+   flat_multiset<recursive_flat_multiset> flat_set_;
+   friend bool operator< (const recursive_flat_multiset &a, const recursive_flat_multiset &b)
+   {  return a.id_ < b.id_;   }
+};
+
+class recursive_flat_multimap
+{
+public:
+   recursive_flat_multimap(const recursive_flat_multimap &c)
+      : id_(c.id_), map_(c.map_)
+   {}
+
+   recursive_flat_multimap & operator =(const recursive_flat_multimap &c)
+   {
+      id_ = c.id_;
+      map_= c.map_;
+      return *this;
+   }
+   int id_;
+   flat_map<recursive_flat_multimap, recursive_flat_multimap> map_;
+   friend bool operator< (const recursive_flat_multimap &a, const recursive_flat_multimap &b)
+   {  return a.id_ < b.id_;   }
+};
+
+template<class C>
+void test_move()
+{
+   //Now test move semantics
+   C original;
+   C move_ctor(boost::move(original));
+   C move_assign;
+   move_assign = boost::move(move_ctor);
+   move_assign.swap(original);
+}
+
+int main()
+{
+   using namespace boost::container::test;
+
+   //Now test move semantics
+   {
+      test_move<flat_set<recursive_flat_set> >();
+      test_move<flat_multiset<recursive_flat_multiset> >();
+      test_move<flat_map<recursive_flat_map, recursive_flat_map> >();
+      test_move<flat_multimap<recursive_flat_multimap, recursive_flat_multimap> >();
+   }
+
+
+   if (0 != set_test<
+                  MyBoostSet
+                  ,MyStdSet
+                  ,MyBoostMultiSet
+                  ,MyStdMultiSet>()){
+      std::cout << "Error in set_test<MyBoostSet>" << std::endl;
+      return 1;
+   }
+
+   if (0 != set_test_copyable<
+                  MyBoostSet
+                  ,MyStdSet
+                  ,MyBoostMultiSet
+                  ,MyStdMultiSet>()){
+      std::cout << "Error in set_test<MyBoostSet>" << std::endl;
+      return 1;
+   }
+
+   if (0 != set_test<
+                  MyMovableBoostSet
+                  ,MyStdSet
+                  ,MyMovableBoostMultiSet
+                  ,MyStdMultiSet>()){
+      std::cout << "Error in set_test<MyMovableBoostSet>" << std::endl;
+      return 1;
+   }
+
+   if (0 != set_test<
+                  MyMoveCopyBoostSet
+                  ,MyStdSet
+                  ,MyMoveCopyBoostMultiSet
+                  ,MyStdMultiSet>()){
+      std::cout << "Error in set_test<MyMoveCopyBoostSet>" << std::endl;
+      return 1;
+   }
+
+   if (0 != set_test_copyable<
+                  MyMoveCopyBoostSet
+                  ,MyStdSet
+                  ,MyMoveCopyBoostMultiSet
+                  ,MyStdMultiSet>()){
+      std::cout << "Error in set_test<MyBoostSet>" << std::endl;
+      return 1;
+   }
+
+   if (0 != set_test<
+                  MyCopyBoostSet
+                  ,MyStdSet
+                  ,MyCopyBoostMultiSet
+                  ,MyStdMultiSet>()){
+      std::cout << "Error in set_test<MyCopyBoostSet>" << std::endl;
+      return 1;
+   }
+
+   if (0 != set_test_copyable<
+                  MyCopyBoostSet
+                  ,MyStdSet
+                  ,MyCopyBoostMultiSet
+                  ,MyStdMultiSet>()){
+      std::cout << "Error in set_test<MyBoostSet>" << std::endl;
+      return 1;
+   }
+
+   if (0 != map_test<
+                  MyBoostMap
+                  ,MyStdMap
+                  ,MyBoostMultiMap
+                  ,MyStdMultiMap>()){
+      std::cout << "Error in set_test<MyBoostMap>" << std::endl;
+      return 1;
+   }
+
+   if (0 != map_test_copyable<
+                  MyBoostMap
+                  ,MyStdMap
+                  ,MyBoostMultiMap
+                  ,MyStdMultiMap>()){
+      std::cout << "Error in set_test<MyBoostMap>" << std::endl;
+      return 1;
+   }
+
+//   if (0 != map_test<
+//                  MyMovableBoostMap
+//                  ,MyStdMap
+//                  ,MyMovableBoostMultiMap
+//                  ,MyStdMultiMap>()){
+//      return 1;
+//   }
+
+   if (0 != map_test<
+                  MyMoveCopyBoostMap
+                  ,MyStdMap
+                  ,MyMoveCopyBoostMultiMap
+                  ,MyStdMultiMap>()){
+      std::cout << "Error in set_test<MyMoveCopyBoostMap>" << std::endl;
+      return 1;
+   }
+
+   if (0 != map_test_copyable<
+                  MyMoveCopyBoostMap
+                  ,MyStdMap
+                  ,MyMoveCopyBoostMultiMap
+                  ,MyStdMultiMap>()){
+      std::cout << "Error in set_test<MyBoostMap>" << std::endl;
+      return 1;
+   }
+
+   if (0 != map_test<
+                  MyCopyBoostMap
+                  ,MyStdMap
+                  ,MyCopyBoostMultiMap
+                  ,MyStdMultiMap>()){
+      std::cout << "Error in set_test<MyCopyBoostMap>" << std::endl;
+      return 1;
+   }
+
+   if (0 != map_test_copyable<
+                  MyCopyBoostMap
+                  ,MyStdMap
+                  ,MyCopyBoostMultiMap
+                  ,MyStdMultiMap>()){
+      std::cout << "Error in set_test<MyBoostMap>" << std::endl;
+      return 1;
+   }
+
+   const test::EmplaceOptions SetOptions = (test::EmplaceOptions)(test::EMPLACE_HINT | test::EMPLACE_ASSOC);
+   const test::EmplaceOptions MapOptions = (test::EmplaceOptions)(test::EMPLACE_HINT_PAIR | test::EMPLACE_ASSOC_PAIR);
+
+//   if(!boost::container::test::test_emplace<flat_map<test::EmplaceInt, test::EmplaceInt>, MapOptions>())
+//      return 1;
+   if(!boost::container::test::test_emplace<flat_multimap<test::EmplaceInt, test::EmplaceInt>, MapOptions>())
+      return 1;
+   if(!boost::container::test::test_emplace<flat_set<test::EmplaceInt>, SetOptions>())
+      return 1;
+   if(!boost::container::test::test_emplace<flat_multiset<test::EmplaceInt>, SetOptions>())
+      return 1;
+   return 0;
+}
+
+#include <boost/container/detail/config_end.hpp>

test/heap_allocator_v1.hpp

@@ -0,0 +1,159 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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/container for documentation.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_HEAP_ALLOCATOR_V1_HPP
+#define BOOST_CONTAINER_HEAP_ALLOCATOR_V1_HPP
+
+#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#  pragma once
+#endif
+
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/workaround.hpp>
+
+#include <boost/pointer_to_other.hpp>
+
+#include <boost/container/container_fwd.hpp>
+#include <boost/container/detail/allocation_type.hpp>
+#include <boost/container/detail/utilities.hpp>
+#include <boost/container/detail/version_type.hpp>
+#include <boost/container/exceptions.hpp>
+#include <memory>
+#include <algorithm>
+#include <cstddef>
+#include <stdexcept>
+
+//!\file
+//!Describes an heap_allocator_v1 that allocates portions of fixed size
+//!memory buffer (shared memory, mapped file...)
+
+namespace boost {
+namespace container {
+namespace test {
+
+//!An STL compatible heap_allocator_v1 that uses a segment manager as 
+//!memory source. The internal pointer type will of the same type (raw, smart) as
+//!"typename SegmentManager::void_pointer" type. This allows
+//!placing the heap_allocator_v1 in shared memory, memory mapped-files, etc...*/
+template<class T, class SegmentManager>
+class heap_allocator_v1 
+{
+ private:
+   typedef heap_allocator_v1<T, SegmentManager>         self_t;
+   typedef SegmentManager                          segment_manager;
+   typedef typename segment_manager::void_pointer  aux_pointer_t;
+
+   typedef typename 
+      boost::pointer_to_other
+         <aux_pointer_t, const void>::type   cvoid_ptr;
+
+   typedef typename boost::pointer_to_other
+      <cvoid_ptr, segment_manager>::type     alloc_ptr_t;
+
+   template<class T2, class SegmentManager2>
+   heap_allocator_v1& operator=(const heap_allocator_v1<T2, SegmentManager2>&);
+
+   heap_allocator_v1& operator=(const heap_allocator_v1&);
+
+   alloc_ptr_t mp_mngr;
+
+ public:
+   typedef T                                    value_type;
+   typedef typename boost::pointer_to_other
+      <cvoid_ptr, T>::type                      pointer;
+   typedef typename boost::
+      pointer_to_other<pointer, const T>::type  const_pointer;
+   typedef typename detail::add_reference
+                     <value_type>::type         reference;
+   typedef typename detail::add_reference
+                     <const value_type>::type   const_reference;
+   typedef std::size_t                          size_type;
+   typedef std::ptrdiff_t                       difference_type;
+
+   //!Obtains an heap_allocator_v1 of other type
+   template<class T2>
+   struct rebind
+   {   
+      typedef heap_allocator_v1<T2, SegmentManager>     other;
+   };
+
+   //!Returns the segment manager. Never throws
+   segment_manager* get_segment_manager()const
+   {  return detail::get_pointer(mp_mngr);   }
+/*
+   //!Returns address of mutable object. Never throws
+   pointer address(reference value) const
+   {  return pointer(addressof(value));  }
+
+   //!Returns address of non mutable object. Never throws
+   const_pointer address(const_reference value) const
+   {  return const_pointer(addressof(value));  }
+*/
+   //!Constructor from the segment manager. Never throws
+   heap_allocator_v1(segment_manager *segment_mngr) 
+      : mp_mngr(segment_mngr) { }
+
+   //!Constructor from other heap_allocator_v1. Never throws
+   heap_allocator_v1(const heap_allocator_v1 &other) 
+      : mp_mngr(other.get_segment_manager()){ }
+
+   //!Constructor from related heap_allocator_v1. Never throws
+   template<class T2>
+   heap_allocator_v1(const heap_allocator_v1<T2, SegmentManager> &other) 
+      : mp_mngr(other.get_segment_manager()){}
+
+   //!Allocates memory for an array of count elements. 
+   //!Throws boost::container::bad_alloc if there is no enough memory
+   pointer allocate(size_type count, cvoid_ptr hint = 0)
+   {  (void)hint; return ::new value_type[count];  }
+
+   //!Deallocates memory previously allocated. Never throws
+   void deallocate(const pointer &ptr, size_type)
+   {  return ::delete[] detail::get_pointer(ptr) ;  }
+
+   //!Construct object, calling constructor. 
+   //!Throws if T(const T&) throws
+   void construct(const pointer &ptr, const_reference value)
+   {  new((void*)detail::get_pointer(ptr)) value_type(value);  }
+
+   //!Destroys object. Throws if object's destructor throws
+   void destroy(const pointer &ptr)
+   {  BOOST_ASSERT(ptr != 0); (*ptr).~value_type();  }
+
+   //!Returns the number of elements that could be allocated. Never throws
+   size_type max_size() const
+   {  return mp_mngr->get_size();   }
+
+   //!Swap segment manager. Does not throw. If each heap_allocator_v1 is placed in
+   //!different memory segments, the result is undefined.
+   friend void swap(self_t &alloc1, self_t &alloc2)
+   {  detail::do_swap(alloc1.mp_mngr, alloc2.mp_mngr);   }
+};
+
+//!Equality test for same type of heap_allocator_v1
+template<class T, class SegmentManager> inline
+bool operator==(const heap_allocator_v1<T , SegmentManager>  &alloc1, 
+                const heap_allocator_v1<T, SegmentManager>  &alloc2)
+   {  return alloc1.get_segment_manager() == alloc2.get_segment_manager(); }
+
+//!Inequality test for same type of heap_allocator_v1
+template<class T, class SegmentManager> inline
+bool operator!=(const heap_allocator_v1<T, SegmentManager>  &alloc1, 
+                const heap_allocator_v1<T, SegmentManager>  &alloc2)
+   {  return alloc1.get_segment_manager() != alloc2.get_segment_manager(); }
+
+}  //namespace test {
+}  //namespace container {
+}  //namespace boost {
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif   //BOOST_CONTAINER_HEAP_ALLOCATOR_V1_HPP
+

test/list_test.cpp

@@ -0,0 +1,78 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2011. 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/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/list.hpp>
+#include "dummy_test_allocator.hpp"
+#include "movable_int.hpp"
+#include "list_test.hpp"
+#include "emplace_test.hpp"
+
+using namespace boost::container;
+
+//Explicit instantiation to detect compilation errors
+template class boost::container::list<test::movable_and_copyable_int, 
+   test::dummy_test_allocator<test::movable_and_copyable_int> >;
+typedef list<int> MyList;
+
+typedef list<test::movable_int> MyMoveList;
+typedef list<test::movable_and_copyable_int> MyCopyMoveList;
+typedef list<test::copyable_int> MyCopyList;
+
+class recursive_list
+{
+public:
+   int id_;
+   list<recursive_list> list_;
+   recursive_list &operator=(const recursive_list &o)
+   { list_ = o.list_;  return *this; }
+};
+
+void recursive_list_test()//Test for recursive types
+{
+   list<recursive_list> recursive, copy;
+   //Test to test both move emulations
+   if(!copy.size()){
+      copy = recursive;
+   }
+}
+
+int main ()
+{
+   recursive_list_test();
+   {
+      //Now test move semantics
+      list<recursive_list> original;
+      list<recursive_list> move_ctor(boost::move(original));
+      list<recursive_list> move_assign;
+      move_assign = boost::move(move_ctor);
+      move_assign.swap(original);
+   }
+   if(test::list_test<MyList, true>())
+      return 1;
+
+   if(test::list_test<MyMoveList, true>())
+      return 1;
+
+   if(test::list_test<MyCopyMoveList, true>())
+      return 1;
+
+   if(test::list_test<MyCopyList, true>())
+      return 1;
+
+   const test::EmplaceOptions Options = (test::EmplaceOptions)(test::EMPLACE_BACK | test::EMPLACE_FRONT | test::EMPLACE_BEFORE);
+
+   if(!boost::container::test::test_emplace<list<test::EmplaceInt>, Options>())
+      return 1;
+
+   return 0;
+}
+
+#include <boost/container/detail/config_end.hpp>

test/list_test.hpp

@@ -0,0 +1,312 @@
+////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2006. 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/container for documentation.
+//
+////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_TEST_LIST_TEST_HEADER
+#define BOOST_CONTAINER_TEST_LIST_TEST_HEADER
+
+#include <boost/container/detail/config_begin.hpp>
+#include "check_equal_containers.hpp"
+#include <memory>
+#include <list>
+#include <vector>
+#include <functional>
+#include "print_container.hpp"
+#include <boost/move/move.hpp>
+#include <string>
+
+namespace boost{
+namespace container {
+namespace test{
+
+template<class V1, class V2>
+bool list_copyable_only(V1 *, V2 *, boost::container::containers_detail::false_type)
+{
+   return true;
+}
+
+//Function to check if both sets are equal
+template<class V1, class V2>
+bool list_copyable_only(V1 *boostlist, V2 *stdlist, boost::container::containers_detail::true_type)
+{
+   typedef typename V1::value_type IntType;
+   boostlist->insert(boostlist->end(), 50, IntType(1));
+   stdlist->insert(stdlist->end(), 50, 1);
+   if(!test::CheckEqualContainers(boostlist, stdlist)) return false;
+
+   {
+      IntType move_me(1);
+      boostlist->insert(boostlist->begin(), 50, boost::move(move_me));
+      stdlist->insert(stdlist->begin(), 50, 1);
+      if(!test::CheckEqualContainers(boostlist, stdlist)) return false;
+   }
+   {
+      IntType move_me(2);
+      boostlist->assign(boostlist->size()/2, boost::move(move_me));
+      stdlist->assign(stdlist->size()/2, 2);
+      if(!test::CheckEqualContainers(boostlist, stdlist)) return false;
+   }
+   {
+      IntType move_me(3);
+      boostlist->assign(boostlist->size()*3-1, boost::move(move_me));
+      stdlist->assign(stdlist->size()*3-1, 3);
+      if(!test::CheckEqualContainers(boostlist, stdlist)) return false;
+   }
+
+   {
+      IntType copy_me(3);
+      const IntType ccopy_me(3);
+      boostlist->push_front(copy_me);
+      stdlist->push_front(int(3));
+      boostlist->push_front(ccopy_me);
+      stdlist->push_front(int(3));
+      if(!test::CheckEqualContainers(boostlist, stdlist)) return false;
+   }
+
+   return true;
+}
+
+template<bool DoublyLinked>
+struct list_push_data_function
+{
+   template<class MyBoostList, class MyStdList>
+   static int execute(int max, MyBoostList *boostlist, MyStdList *stdlist)
+   {
+      typedef typename MyBoostList::value_type IntType;
+      for(int i = 0; i < max; ++i){
+         IntType move_me(i);
+         boostlist->push_back(boost::move(move_me));
+         stdlist->push_back(i);
+         boostlist->push_front(IntType(i));
+         stdlist->push_front(int(i));
+      }
+      if(!CheckEqualContainers(boostlist, stdlist))
+         return 1;
+      return 0;
+   }
+};
+
+template<>
+struct list_push_data_function<false>
+{
+   template<class MyBoostList, class MyStdList>
+   static int execute(int max, MyBoostList *boostlist, MyStdList *stdlist)
+   {
+      typedef typename MyBoostList::value_type IntType;
+      for(int i = 0; i < max; ++i){
+         IntType move_me(i);
+         boostlist->push_front(boost::move(move_me));
+         stdlist->push_front(i);
+         boostlist->push_front(IntType(i));
+         stdlist->push_front(int(i));
+      }
+      if(!CheckEqualContainers(boostlist, stdlist))
+         return 1;
+      return 0;
+   }
+};
+
+template<bool DoublyLinked>
+struct list_pop_back_function
+{
+   template<class MyStdList, class MyBoostList>
+   static int execute(MyBoostList *boostlist, MyStdList *stdlist)
+   {
+      boostlist->pop_back();
+      stdlist->pop_back();
+      if(!CheckEqualContainers(boostlist, stdlist))
+         return 1;
+      return 0;
+   }
+};
+
+template<>
+struct list_pop_back_function<false>
+{
+   template<class MyStdList, class MyBoostList>
+   static int execute(MyBoostList *boostlist, MyStdList *stdlist)
+   {
+      (void)boostlist; (void)stdlist;
+      return 0;
+   }
+};
+
+template<class MyBoostList
+        ,bool  DoublyLinked>
+int list_test (bool copied_allocators_equal = true)
+{
+   typedef std::list<int> MyStdList;
+   typedef typename MyBoostList::value_type IntType;
+   const int max = 100;
+   typedef list_push_data_function<DoublyLinked> push_data_t;
+
+   try{
+      MyBoostList *boostlist = new MyBoostList;
+      MyStdList *stdlist = new MyStdList;
+
+      if(push_data_t::execute(max, boostlist, stdlist)){
+         return 1;
+      }
+
+      boostlist->erase(boostlist->begin()++);
+      stdlist->erase(stdlist->begin()++);
+      if(!CheckEqualContainers(boostlist, stdlist)) return 1;
+
+      if(list_pop_back_function<DoublyLinked>::execute(boostlist, stdlist)){
+         return 1;
+      }
+
+      boostlist->pop_front();
+      stdlist->pop_front();
+      if(!CheckEqualContainers(boostlist, stdlist)) return 1;
+
+      {
+         IntType aux_vect[50];
+         for(int i = 0; i < 50; ++i){
+            IntType move_me(-1);
+            aux_vect[i] = boost::move(move_me);
+         }
+         int aux_vect2[50];
+         for(int i = 0; i < 50; ++i){
+            aux_vect2[i] = -1;
+         }
+         boostlist->assign(boost::make_move_iterator(&aux_vect[0])
+                        ,boost::make_move_iterator(&aux_vect[50]));
+         stdlist->assign(&aux_vect2[0], &aux_vect2[50]);
+         if(!CheckEqualContainers(boostlist, stdlist)) return 1;
+      }
+
+      if(copied_allocators_equal){
+         boostlist->sort();
+         stdlist->sort();
+         if(!CheckEqualContainers(boostlist, stdlist)) return 1;
+      }
+
+      boostlist->reverse();
+      stdlist->reverse();
+      if(!CheckEqualContainers(boostlist, stdlist)) return 1;
+
+      boostlist->reverse();
+      stdlist->reverse();
+      if(!CheckEqualContainers(boostlist, stdlist)) return 1;
+
+      {
+         IntType aux_vect[50];
+         for(int i = 0; i < 50; ++i){
+            IntType move_me(-1);
+            aux_vect[i] = boost::move(move_me);
+         }
+         int aux_vect2[50];
+         for(int i = 0; i < 50; ++i){
+            aux_vect2[i] = -1;
+         }
+         boostlist->insert(boostlist->begin()
+                        ,boost::make_move_iterator(&aux_vect[0])
+                        ,boost::make_move_iterator(&aux_vect[50]));
+         stdlist->insert(stdlist->begin(), &aux_vect2[0], &aux_vect2[50]);
+      }
+
+      boostlist->unique();
+      stdlist->unique();
+      if(!CheckEqualContainers(boostlist, stdlist))
+         return 1;
+
+      if(copied_allocators_equal){
+         boostlist->sort(std::greater<IntType>());
+         stdlist->sort(std::greater<int>());
+         if(!CheckEqualContainers(boostlist, stdlist))
+            return 1;
+      }
+
+      for(int i = 0; i < max; ++i){
+         IntType new_int(i);
+         boostlist->insert(boostlist->end(), boost::move(new_int));
+         stdlist->insert(stdlist->end(), i);
+         if(!test::CheckEqualContainers(boostlist, stdlist)) return 1;
+      }
+      if(!test::CheckEqualContainers(boostlist, stdlist)) return 1;
+
+      boostlist->resize(25);
+      stdlist->resize(25);
+      boostlist->resize(50);
+      stdlist->resize(50);
+      boostlist->resize(0);
+      stdlist->resize(0);
+      if(!CheckEqualContainers(boostlist, stdlist))
+         return 1;
+
+      if(push_data_t::execute(max, boostlist, stdlist)){
+         return 1;
+      }
+      {
+         MyBoostList otherboostlist(boostlist->get_allocator());
+         MyStdList otherstdlist;
+
+         int listsize = (int)boostlist->size();
+
+         if(push_data_t::execute(listsize, boostlist, stdlist)){
+            return 1;
+         }
+
+         if(copied_allocators_equal){
+            boostlist->splice(boostlist->begin(), otherboostlist);
+            stdlist->splice(stdlist->begin(), otherstdlist);
+            if(!CheckEqualContainers(boostlist, stdlist))
+               return 1;   
+         }
+
+         listsize = (int)boostlist->size();
+
+         if(push_data_t::execute(listsize, boostlist, stdlist)){
+            return 1;
+         }
+
+         if(push_data_t::execute(listsize, &otherboostlist, &otherstdlist)){
+            return 1;
+         }
+
+         if(copied_allocators_equal){
+            boostlist->sort(std::greater<IntType>());
+            stdlist->sort(std::greater<int>());
+            if(!CheckEqualContainers(boostlist, stdlist))
+               return 1;
+
+            otherboostlist.sort(std::greater<IntType>());
+            otherstdlist.sort(std::greater<int>());
+            if(!CheckEqualContainers(&otherboostlist, &otherstdlist))
+               return 1;
+
+            boostlist->merge(otherboostlist, std::greater<IntType>());
+            stdlist->merge(otherstdlist, std::greater<int>());
+            if(!CheckEqualContainers(boostlist, stdlist))
+               return 1;
+         }
+
+         if(!list_copyable_only(boostlist, stdlist
+                        ,containers_detail::bool_<boost::container::test::is_copyable<IntType>::value>())){
+            return 1;
+         }
+      }
+
+      delete boostlist;
+      delete stdlist;
+   }
+   catch(...){
+      throw;
+   }
+   return 0;
+}
+
+}  //namespace test{
+}  //namespace container {
+}  //namespace boost{
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif

test/map_test.hpp

@@ -0,0 +1,521 @@
+////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2006. 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/container for documentation.
+//
+////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_TEST_MAP_TEST_HEADER
+#define BOOST_CONTAINER_TEST_MAP_TEST_HEADER
+
+#include <boost/container/detail/config_begin.hpp>
+#include "check_equal_containers.hpp"
+#include <map>
+#include <functional>
+#include <utility>
+#include "print_container.hpp"
+#include <boost/container/detail/utilities.hpp>
+#include <boost/container/detail/pair.hpp>
+#include <string>
+
+template<class T1, class T2, class T3, class T4>
+bool operator ==(std::pair<T1, T2> &p1, std::pair<T1, T2> &p2)
+{
+   return p1.first == p2.first && p1.second == p2.second;
+}
+
+namespace boost{
+namespace container {
+namespace test{
+
+template<class MyBoostMap
+        ,class MyStdMap
+        ,class MyBoostMultiMap
+        ,class MyStdMultiMap>
+int map_test ()
+{
+   typedef typename MyBoostMap::key_type    IntType;
+   typedef containers_detail::pair<IntType, IntType>         IntPairType;
+   typedef typename MyStdMap::value_type  StdPairType;
+   const int max = 100;
+
+   try{
+      MyBoostMap *boostmap = new MyBoostMap;
+      MyStdMap *stdmap = new MyStdMap;
+      MyBoostMultiMap *boostmultimap = new MyBoostMultiMap;
+      MyStdMultiMap *stdmultimap = new MyStdMultiMap;
+
+      //Test construction from a range   
+      {
+         //This is really nasty, but we have no other simple choice
+         IntPairType aux_vect[50];
+         for(int i = 0; i < 50; ++i){
+            IntType i1(i/2);
+            IntType i2(i/2);
+            new(&aux_vect[i])IntPairType(boost::move(i1), boost::move(i2));
+         }
+
+         typedef typename MyStdMap::value_type StdValueType;
+         typedef typename MyStdMap::key_type StdKeyType;
+         typedef typename MyStdMap::mapped_type StdMappedType;
+         StdValueType aux_vect2[50];
+         for(int i = 0; i < 50; ++i){
+            new(&aux_vect2[i])StdValueType(StdKeyType(i/2), StdMappedType(i/2));
+         }
+
+         IntPairType aux_vect3[50];
+         for(int i = 0; i < 50; ++i){
+            IntType i1(i/2);
+            IntType i2(i/2);
+            new(&aux_vect3[i])IntPairType(boost::move(i1), boost::move(i2));
+         }
+
+         MyBoostMap *boostmap2 = new MyBoostMap
+               ( boost::make_move_iterator(&aux_vect[0])
+               , boost::make_move_iterator(aux_vect + 50));
+         MyStdMap *stdmap2 = new MyStdMap(aux_vect2, aux_vect2 + 50);
+         MyBoostMultiMap *boostmultimap2 = new MyBoostMultiMap
+               ( boost::make_move_iterator(&aux_vect3[0])
+               , boost::make_move_iterator(aux_vect3 + 50));
+         MyStdMultiMap *stdmultimap2 = new MyStdMultiMap(aux_vect2, aux_vect2 + 50);
+         if(!CheckEqualContainers(boostmap2, stdmap2)) return 1;
+         if(!CheckEqualContainers(boostmultimap2, stdmultimap2)) return 1;
+
+         //ordered range insertion
+         //This is really nasty, but we have no other simple choice
+         for(int i = 0; i < 50; ++i){
+            IntType i1(i);
+            IntType i2(i);
+            new(&aux_vect[i])IntPairType(boost::move(i1), boost::move(i2));
+         }
+
+         for(int i = 0; i < 50; ++i){
+            new(&aux_vect2[i])StdValueType(StdKeyType(i), StdMappedType(i));
+         }
+
+         for(int i = 0; i < 50; ++i){
+            IntType i1(i);
+            IntType i2(i);
+            new(&aux_vect3[i])IntPairType(boost::move(i1), boost::move(i2));
+         }
+/*
+         MyBoostMap *boostmap3 = new MyBoostMap 
+               ( ordered_unique_range
+               , boost::make_move_iterator(&aux_vect[0])
+               , boost::make_move_iterator(aux_vect + 50));
+         MyStdMap *stdmap3 = new MyStdMap(aux_vect2, aux_vect2 + 50);
+         MyBoostMultiMap *boostmultimap3 = new MyBoostMultiMap
+               ( ordered_range
+               , boost::make_move_iterator(&aux_vect3[0])
+               , boost::make_move_iterator(aux_vect3 + 50));
+         MyStdMultiMap *stdmultimap3 = new MyStdMultiMap(aux_vect2, aux_vect2 + 50);
+
+         if(!CheckEqualContainers(boostmap3, stdmap3)){
+            std::cout << "Error in construct<MyBoostMap>(MyBoostMap3)" << std::endl;
+            return 1;
+         }
+         if(!CheckEqualContainers(boostmultimap3, stdmultimap3)){
+            std::cout << "Error in construct<MyBoostMultiMap>(MyBoostMultiMap3)" << std::endl;
+            return 1;
+         }
+*/
+         delete boostmap2;
+         delete boostmultimap2;
+         delete stdmap2;
+         delete stdmultimap2;
+         //delete boostmap3;
+         //delete boostmultimap3;
+         //delete stdmap3;
+         //delete stdmultimap3;
+      }
+      {
+         //This is really nasty, but we have no other simple choice
+         IntPairType aux_vect[max];
+         for(int i = 0; i < max; ++i){
+            IntType i1(i);
+            IntType i2(i);
+            new(&aux_vect[i])IntPairType(boost::move(i1), boost::move(i2));
+         }
+         IntPairType aux_vect3[max];
+         for(int i = 0; i < max; ++i){
+            IntType i1(i);
+            IntType i2(i);
+            new(&aux_vect3[i])IntPairType(boost::move(i1), boost::move(i2));
+         }
+
+         for(int i = 0; i < max; ++i){
+            boostmap->insert(boost::move(aux_vect[i]));
+            stdmap->insert(StdPairType(i, i));
+            boostmultimap->insert(boost::move(aux_vect3[i]));
+            stdmultimap->insert(StdPairType(i, i));
+         }
+
+         if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
+         if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
+
+         typename MyBoostMap::iterator it;
+         typename MyBoostMap::const_iterator cit = it;
+
+         boostmap->erase(boostmap->begin()++);
+         stdmap->erase(stdmap->begin()++);
+         boostmultimap->erase(boostmultimap->begin()++);
+         stdmultimap->erase(stdmultimap->begin()++);
+         if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
+         if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
+
+         boostmap->erase(boostmap->begin());
+         stdmap->erase(stdmap->begin());
+         boostmultimap->erase(boostmultimap->begin());
+         stdmultimap->erase(stdmultimap->begin());
+         if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
+         if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
+
+         //Swapping test
+         MyBoostMap tmpboostemap2;
+         MyStdMap tmpstdmap2;
+         MyBoostMultiMap tmpboostemultimap2;
+         MyStdMultiMap tmpstdmultimap2;
+         boostmap->swap(tmpboostemap2);
+         stdmap->swap(tmpstdmap2);
+         boostmultimap->swap(tmpboostemultimap2);
+         stdmultimap->swap(tmpstdmultimap2);
+         boostmap->swap(tmpboostemap2);
+         stdmap->swap(tmpstdmap2);
+         boostmultimap->swap(tmpboostemultimap2);
+         stdmultimap->swap(tmpstdmultimap2);
+         if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
+         if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
+      }
+      //Insertion from other container
+      //Initialize values
+      {
+         //This is really nasty, but we have no other simple choice
+         IntPairType aux_vect[50];
+         for(int i = 0; i < 50; ++i){
+            IntType i1(-1);
+            IntType i2(-1);
+            new(&aux_vect[i])IntPairType(boost::move(i1), boost::move(i2));
+         }
+         IntPairType aux_vect3[50];
+         for(int i = 0; i < 50; ++i){
+            IntType i1(-1);
+            IntType i2(-1);
+            new(&aux_vect3[i])IntPairType(boost::move(i1), boost::move(i2));
+         }
+
+         boostmap->insert(boost::make_move_iterator(&aux_vect[0]), boost::make_move_iterator(aux_vect + 50));
+         boostmultimap->insert(boost::make_move_iterator(&aux_vect3[0]), boost::make_move_iterator(aux_vect3 + 50));
+         for(std::size_t i = 0; i != 50; ++i){
+            StdPairType stdpairtype(-1, -1);
+            stdmap->insert(stdpairtype);
+            stdmultimap->insert(stdpairtype);
+         }
+         if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
+         if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
+
+         for(int i = 0, j = static_cast<int>(boostmap->size()); i < j; ++i){
+            boostmap->erase(IntType(i));
+            stdmap->erase(i);
+            boostmultimap->erase(IntType(i));
+            stdmultimap->erase(i);
+         }
+         if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
+         if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
+      }
+      {
+         IntPairType aux_vect[50];
+         for(int i = 0; i < 50; ++i){
+            IntType i1(-1);
+            IntType i2(-1);
+            new(&aux_vect[i])IntPairType(boost::move(i1), boost::move(i2));
+         }
+
+         IntPairType aux_vect3[50];
+         for(int i = 0; i < 50; ++i){
+            IntType i1(-1);
+            IntType i2(-1);
+            new(&aux_vect3[i])IntPairType(boost::move(i1), boost::move(i2));
+         }
+
+         IntPairType aux_vect4[50];
+         for(int i = 0; i < 50; ++i){
+            IntType i1(-1);
+            IntType i2(-1);
+            new(&aux_vect4[i])IntPairType(boost::move(i1), boost::move(i2));
+         }
+
+         IntPairType aux_vect5[50];
+         for(int i = 0; i < 50; ++i){
+            IntType i1(-1);
+            IntType i2(-1);
+            new(&aux_vect5[i])IntPairType(boost::move(i1), boost::move(i2));
+         }
+
+         boostmap->insert(boost::make_move_iterator(&aux_vect[0]), boost::make_move_iterator(aux_vect + 50));
+         boostmap->insert(boost::make_move_iterator(&aux_vect3[0]), boost::make_move_iterator(aux_vect3 + 50));
+         boostmultimap->insert(boost::make_move_iterator(&aux_vect4[0]), boost::make_move_iterator(aux_vect4 + 50));
+         boostmultimap->insert(boost::make_move_iterator(&aux_vect5[0]), boost::make_move_iterator(aux_vect5 + 50));
+
+         for(std::size_t i = 0; i != 50; ++i){
+            StdPairType stdpairtype(-1, -1);
+            stdmap->insert(stdpairtype);
+            stdmultimap->insert(stdpairtype);
+            stdmap->insert(stdpairtype);
+            stdmultimap->insert(stdpairtype);
+         }
+         if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
+         if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
+
+         boostmap->erase(boostmap->begin()->first);
+         stdmap->erase(stdmap->begin()->first);
+         boostmultimap->erase(boostmultimap->begin()->first);
+         stdmultimap->erase(stdmultimap->begin()->first);
+         if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
+         if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
+      }
+
+      {
+         //This is really nasty, but we have no other simple choice
+         IntPairType aux_vect[max];
+         for(int i = 0; i < max; ++i){
+            IntType i1(i);
+            IntType i2(i);
+            new(&aux_vect[i])IntPairType(boost::move(i1), boost::move(i2));
+         }
+         IntPairType aux_vect3[max];
+         for(int i = 0; i < max; ++i){
+            IntType i1(i);
+            IntType i2(i);
+            new(&aux_vect3[i])IntPairType(boost::move(i1), boost::move(i2));
+         }
+
+         for(int i = 0; i < max; ++i){
+            boostmap->insert(boost::move(aux_vect[i]));
+            stdmap->insert(StdPairType(i, i));
+            boostmultimap->insert(boost::move(aux_vect3[i]));
+            stdmultimap->insert(StdPairType(i, i));
+         }
+
+         if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
+         if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
+
+         for(int i = 0; i < max; ++i){
+            IntPairType intpair;
+            {
+               IntType i1(i);
+               IntType i2(i);
+               new(&intpair)IntPairType(boost::move(i1), boost::move(i2));
+            }
+            boostmap->insert(boostmap->begin(), boost::move(intpair));
+            stdmap->insert(stdmap->begin(), StdPairType(i, i));
+            //PrintContainers(boostmap, stdmap);
+            {
+               IntType i1(i);
+               IntType i2(i);
+               new(&intpair)IntPairType(boost::move(i1), boost::move(i2));
+            }
+            boostmultimap->insert(boostmultimap->begin(), boost::move(intpair));
+            stdmultimap->insert(stdmultimap->begin(), StdPairType(i, i));
+            //PrintContainers(boostmultimap, stdmultimap);
+            if(!CheckEqualPairContainers(boostmap, stdmap))
+               return 1;
+            if(!CheckEqualPairContainers(boostmultimap, stdmultimap))
+               return 1;
+            {
+               IntType i1(i);
+               IntType i2(i);
+               new(&intpair)IntPairType(boost::move(i1), boost::move(i2));
+            }
+            boostmap->insert(boostmap->end(), boost::move(intpair));
+            stdmap->insert(stdmap->end(), StdPairType(i, i));
+            {
+               IntType i1(i);
+               IntType i2(i);
+               new(&intpair)IntPairType(boost::move(i1), boost::move(i2));
+            }
+            boostmultimap->insert(boostmultimap->end(), boost::move(intpair));
+            stdmultimap->insert(stdmultimap->end(), StdPairType(i, i));
+            if(!CheckEqualPairContainers(boostmap, stdmap))
+               return 1;
+            if(!CheckEqualPairContainers(boostmultimap, stdmultimap))
+               return 1;
+            {
+               IntType i1(i);
+               IntType i2(i);
+               new(&intpair)IntPairType(boost::move(i1), boost::move(i2));
+            }
+            boostmap->insert(boostmap->lower_bound(IntType(i)), boost::move(intpair));
+            stdmap->insert(stdmap->lower_bound(i), StdPairType(i, i));
+            //PrintContainers(boostmap, stdmap);
+            {
+               IntType i1(i);
+               IntType i2(i);
+               new(&intpair)IntPairType(boost::move(i1), boost::move(i2));
+            }
+            {
+               IntType i1(i);
+               boostmultimap->insert(boostmultimap->lower_bound(boost::move(i1)), boost::move(intpair));
+               stdmultimap->insert(stdmultimap->lower_bound(i), StdPairType(i, i));
+            }
+
+            //PrintContainers(boostmultimap, stdmultimap);
+            if(!CheckEqualPairContainers(boostmap, stdmap))
+               return 1;
+            if(!CheckEqualPairContainers(boostmultimap, stdmultimap))
+               return 1;
+            {
+               IntType i1(i);
+               IntType i2(i);
+               new(&intpair)IntPairType(boost::move(i1), boost::move(i2));
+            }
+            {
+               IntType i1(i);
+               boostmap->insert(boostmap->upper_bound(boost::move(i1)), boost::move(intpair));
+               stdmap->insert(stdmap->upper_bound(i), StdPairType(i, i));
+            }
+            //PrintContainers(boostmap, stdmap);
+            {
+               IntType i1(i);
+               IntType i2(i);
+               new(&intpair)IntPairType(boost::move(i1), boost::move(i2));
+            }
+            {
+               IntType i1(i);
+               boostmultimap->insert(boostmultimap->upper_bound(boost::move(i1)), boost::move(intpair));
+               stdmultimap->insert(stdmultimap->upper_bound(i), StdPairType(i, i));
+            }
+            //PrintContainers(boostmultimap, stdmultimap);
+            if(!CheckEqualPairContainers(boostmap, stdmap))
+               return 1;
+            if(!CheckEqualPairContainers(boostmultimap, stdmultimap))
+               return 1;
+         }
+
+         //Compare count with std containers
+         for(int i = 0; i < max; ++i){
+            if(boostmap->count(IntType(i)) != stdmap->count(i)){
+               return -1;
+            }
+
+            if(boostmultimap->count(IntType(i)) != stdmultimap->count(i)){
+               return -1;
+            }
+         }
+
+         //Now do count exercise
+         boostmap->erase(boostmap->begin(), boostmap->end());
+         boostmultimap->erase(boostmultimap->begin(), boostmultimap->end());
+         boostmap->clear();
+         boostmultimap->clear();
+
+         for(int j = 0; j < 3; ++j)
+         for(int i = 0; i < 100; ++i){
+            IntPairType intpair;
+            {
+            IntType i1(i), i2(i);
+            new(&intpair)IntPairType(boost::move(i1), boost::move(i2));
+            }
+            boostmap->insert(boost::move(intpair));
+            {
+               IntType i1(i), i2(i);
+               new(&intpair)IntPairType(boost::move(i1), boost::move(i2));
+            }
+            boostmultimap->insert(boost::move(intpair));
+            if(boostmap->count(IntType(i)) != typename MyBoostMultiMap::size_type(1))
+               return 1;
+            if(boostmultimap->count(IntType(i)) != typename MyBoostMultiMap::size_type(j+1))
+               return 1;
+         }
+      }
+
+      delete boostmap;
+      delete stdmap;
+      delete boostmultimap;
+      delete stdmultimap;
+   }
+   catch(...){
+      throw;
+   }
+   return 0;
+}
+
+template<class MyBoostMap
+        ,class MyStdMap
+        ,class MyBoostMultiMap
+        ,class MyStdMultiMap>
+int map_test_copyable ()
+{
+   typedef typename MyBoostMap::key_type    IntType;
+   typedef containers_detail::pair<IntType, IntType>         IntPairType;
+   typedef typename MyStdMap::value_type  StdPairType;
+
+   const int max = 100;
+
+   try{
+   MyBoostMap *boostmap = new MyBoostMap;
+   MyStdMap *stdmap = new MyStdMap;
+   MyBoostMultiMap *boostmultimap = new MyBoostMultiMap;
+   MyStdMultiMap *stdmultimap = new MyStdMultiMap;
+
+   int i;
+   for(i = 0; i < max; ++i){
+      {
+      IntType i1(i), i2(i);
+      IntPairType intpair1(boost::move(i1), boost::move(i2));
+      boostmap->insert(boost::move(intpair1));
+      stdmap->insert(StdPairType(i, i));
+      }
+      {
+      IntType i1(i), i2(i);
+      IntPairType intpair2(boost::move(i1), boost::move(i2));
+      boostmultimap->insert(boost::move(intpair2));
+      stdmultimap->insert(StdPairType(i, i));
+      }
+   }
+   if(!CheckEqualContainers(boostmap, stdmap)) return 1;
+   if(!CheckEqualContainers(boostmultimap, stdmultimap)) return 1;
+
+      {
+         //Now, test copy constructor
+         MyBoostMap boostmapcopy(*boostmap);
+         MyStdMap stdmapcopy(*stdmap);
+         MyBoostMultiMap boostmmapcopy(*boostmultimap);
+         MyStdMultiMap stdmmapcopy(*stdmultimap);
+
+         if(!CheckEqualContainers(&boostmapcopy, &stdmapcopy))
+            return 1;
+         if(!CheckEqualContainers(&boostmmapcopy, &stdmmapcopy))
+            return 1;
+
+         //And now assignment
+         boostmapcopy  = *boostmap;
+         stdmapcopy  = *stdmap;
+         boostmmapcopy = *boostmultimap;
+         stdmmapcopy = *stdmultimap;
+         
+         if(!CheckEqualContainers(&boostmapcopy, &stdmapcopy))
+            return 1;
+         if(!CheckEqualContainers(&boostmmapcopy, &stdmmapcopy))
+            return 1;
+         delete boostmap;
+         delete boostmultimap;
+         delete stdmap;
+         delete stdmultimap;
+      }
+   }
+   catch(...){
+      throw;
+   }
+   return 0;
+}
+
+}  //namespace test{
+}  //namespace container {
+}  //namespace boost{
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_CONTAINER_TEST_MAP_TEST_HEADER

test/movable_int.hpp

@@ -0,0 +1,230 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2006. 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/container for documentation.
+//
+///////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_TEST_MOVABLE_INT_HEADER
+#define BOOST_CONTAINER_TEST_MOVABLE_INT_HEADER
+
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/workaround.hpp>
+#include <boost/move/move.hpp>
+
+namespace boost {
+namespace container {
+namespace test {
+
+template<class T>
+struct is_copyable;
+
+template<>
+struct is_copyable<int>
+{
+   static const bool value = true;
+};
+
+
+class movable_int
+{
+   BOOST_MOVABLE_BUT_NOT_COPYABLE(movable_int)
+
+   public:
+   movable_int()
+      :  m_int(0)
+   {}
+
+   explicit movable_int(int a)
+      :  m_int(a)
+   {}
+
+   movable_int(BOOST_RV_REF(movable_int) mmi)
+      :  m_int(mmi.m_int)
+   {  mmi.m_int = 0; }
+
+   movable_int & operator= (BOOST_RV_REF(movable_int) mmi)
+   {  this->m_int = mmi.m_int;   mmi.m_int = 0;  return *this;  }
+
+   movable_int & operator= (int i)
+   {  this->m_int = i;  return *this;  }
+
+   bool operator ==(const movable_int &mi) const
+   {  return this->m_int == mi.m_int;   }
+
+   bool operator !=(const movable_int &mi) const
+   {  return this->m_int != mi.m_int;   }
+
+   bool operator <(const movable_int &mi) const
+   {  return this->m_int < mi.m_int;   }
+
+   bool operator <=(const movable_int &mi) const
+   {  return this->m_int <= mi.m_int;   }
+
+   bool operator >=(const movable_int &mi) const
+   {  return this->m_int >= mi.m_int;   }
+
+   bool operator >(const movable_int &mi) const
+   {  return this->m_int > mi.m_int;   }
+
+   int get_int() const
+   {  return m_int;  }
+
+   private:
+   int m_int;
+};
+
+template<class E, class T> 
+std::basic_ostream<E, T> & operator<< 
+   (std::basic_ostream<E, T> & os, movable_int const & p)
+
+{
+    os << p.get_int();
+    return os;
+}
+
+
+template<>
+struct is_copyable<movable_int>
+{
+   static const bool value = false;
+};
+
+class movable_and_copyable_int
+{
+   BOOST_COPYABLE_AND_MOVABLE(movable_and_copyable_int)
+
+   public:
+   movable_and_copyable_int()
+      :  m_int(0)
+   {}
+
+   explicit movable_and_copyable_int(int a)
+      :  m_int(a)
+   {}
+
+   movable_and_copyable_int(const movable_and_copyable_int& mmi)
+      :  m_int(mmi.m_int)
+   {}
+   
+   movable_and_copyable_int(BOOST_RV_REF(movable_and_copyable_int) mmi)
+      :  m_int(mmi.m_int)
+   {  mmi.m_int = 0; }
+
+   movable_and_copyable_int &operator= (BOOST_COPY_ASSIGN_REF(movable_and_copyable_int) mi)
+   {  this->m_int = mi.m_int;    return *this;  }
+
+   movable_and_copyable_int & operator= (BOOST_RV_REF(movable_and_copyable_int) mmi)
+   {  this->m_int = mmi.m_int;   mmi.m_int = 0;    return *this;  }
+
+   movable_and_copyable_int & operator= (int i)
+   {  this->m_int = i;  return *this;  }
+
+   bool operator ==(const movable_and_copyable_int &mi) const
+   {  return this->m_int == mi.m_int;   }
+
+   bool operator !=(const movable_and_copyable_int &mi) const
+   {  return this->m_int != mi.m_int;   }
+
+   bool operator <(const movable_and_copyable_int &mi) const
+   {  return this->m_int < mi.m_int;   }
+
+   bool operator <=(const movable_and_copyable_int &mi) const
+   {  return this->m_int <= mi.m_int;   }
+
+   bool operator >=(const movable_and_copyable_int &mi) const
+   {  return this->m_int >= mi.m_int;   }
+
+   bool operator >(const movable_and_copyable_int &mi) const
+   {  return this->m_int > mi.m_int;   }
+
+   int get_int() const
+   {  return m_int;  }
+
+   private:
+   int m_int;
+};
+
+template<class E, class T> 
+std::basic_ostream<E, T> & operator<< 
+   (std::basic_ostream<E, T> & os, movable_and_copyable_int const & p)
+
+{
+    os << p.get_int();
+    return os;
+}
+
+template<>
+struct is_copyable<movable_and_copyable_int>
+{
+   static const bool value = true;
+};
+
+class copyable_int
+{
+   public:
+   copyable_int()
+      :  m_int(0)
+   {}
+
+   explicit copyable_int(int a)
+      :  m_int(a)
+   {}
+
+   copyable_int(const copyable_int& mmi)
+      :  m_int(mmi.m_int)
+   {}
+   
+   copyable_int & operator= (int i)
+   {  this->m_int = i;  return *this;  }
+
+   bool operator ==(const copyable_int &mi) const
+   {  return this->m_int == mi.m_int;   }
+
+   bool operator !=(const copyable_int &mi) const
+   {  return this->m_int != mi.m_int;   }
+
+   bool operator <(const copyable_int &mi) const
+   {  return this->m_int < mi.m_int;   }
+
+   bool operator <=(const copyable_int &mi) const
+   {  return this->m_int <= mi.m_int;   }
+
+   bool operator >=(const copyable_int &mi) const
+   {  return this->m_int >= mi.m_int;   }
+
+   bool operator >(const copyable_int &mi) const
+   {  return this->m_int > mi.m_int;   }
+
+   int get_int() const
+   {  return m_int;  }
+
+   private:
+   int m_int;
+};
+
+template<class E, class T> 
+std::basic_ostream<E, T> & operator<< 
+   (std::basic_ostream<E, T> & os, copyable_int const & p)
+
+{
+    os << p.get_int();
+    return os;
+}
+
+template<>
+struct is_copyable<copyable_int>
+{
+   static const bool value = true;
+};
+
+}  //namespace test {
+}  //namespace container {
+}  //namespace boost {
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_CONTAINER_TEST_MOVABLE_INT_HEADER

test/print_container.hpp

@@ -0,0 +1,64 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2011. 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/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_PRINTCONTAINER_HPP
+#define BOOST_PRINTCONTAINER_HPP
+
+#include <boost/container/detail/config_begin.hpp>
+#include <functional>
+#include <iostream>
+#include <algorithm>
+
+namespace boost{
+namespace container {
+namespace test{
+
+struct PrintValues : public std::unary_function<int, void>
+{
+   void operator() (int value) const
+   {
+      std::cout << value << " ";
+   }
+};
+
+template<class Container>
+void PrintContents(const Container &cont, const char *contName)
+{
+   std::cout<< "Printing contents of " << contName << std::endl;
+   std::for_each(cont.begin(), cont.end(), PrintValues());
+   std::cout<< std::endl << std::endl;
+}
+
+//Function to dump data
+template<class MyBoostCont
+        ,class MyStdCont>
+void PrintContainers(MyBoostCont *boostcont, MyStdCont *stdcont)
+{
+   typename MyBoostCont::iterator itboost = boostcont->begin(), itboostend = boostcont->end();
+   typename MyStdCont::iterator itstd = stdcont->begin(), itstdend = stdcont->end();
+
+   std::cout << "MyBoostCont" << std::endl;
+   for(; itboost != itboostend; ++itboost){
+      std::cout << *itboost << std::endl;
+   }
+   std::cout << "MyStdCont" << std::endl; 
+  
+   for(; itstd != itstdend; ++itstd){
+      std::cout << *itstd << std::endl;
+   }
+}
+
+}  //namespace test{
+}  //namespace container {
+}  //namespace boost{
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif //#ifndef BOOST_PRINTCONTAINER_HPP

test/set_test.hpp

@@ -0,0 +1,504 @@
+////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2011. 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/container for documentation.
+//
+////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_TEST_SET_TEST_HEADER
+#define BOOST_CONTAINER_TEST_SET_TEST_HEADER
+
+#include <boost/container/detail/config_begin.hpp>
+#include "check_equal_containers.hpp"
+#include <memory>
+#include <set>
+#include <functional>
+#include "print_container.hpp"
+#include <boost/move/move.hpp>
+#include <string>
+
+namespace boost{
+namespace container {
+namespace test{
+
+template<class MyBoostSet
+        ,class MyStdSet
+        ,class MyBoostMultiSet
+        ,class MyStdMultiSet>
+int set_test ()
+{
+   typedef typename MyBoostSet::value_type IntType;
+   const int max = 100;
+
+   //Shared memory allocator must be always be initialized
+   //since it has no default constructor
+   MyBoostSet *boostset = new MyBoostSet;
+   MyStdSet *stdset = new MyStdSet;
+   MyBoostMultiSet *boostmultiset = new MyBoostMultiSet;
+   MyStdMultiSet *stdmultiset = new MyStdMultiSet;
+
+   //Test construction from a range   
+   {
+      IntType aux_vect[50];
+      for(int i = 0; i < 50; ++i){
+         IntType move_me(i/2);
+         aux_vect[i] = boost::move(move_me);
+      }
+      int aux_vect2[50];
+      for(int i = 0; i < 50; ++i){
+         aux_vect2[i] = i/2;
+      }
+      IntType aux_vect3[50];
+      for(int i = 0; i < 50; ++i){
+         IntType move_me(i/2);
+         aux_vect3[i] = boost::move(move_me);
+      }
+
+      MyBoostSet *boostset2 = new MyBoostSet
+            ( boost::make_move_iterator(&aux_vect[0])
+            , boost::make_move_iterator(aux_vect + 50));
+      MyStdSet *stdset2 = new MyStdSet(aux_vect2, aux_vect2 + 50);
+      MyBoostMultiSet *boostmultiset2 = new MyBoostMultiSet
+            ( boost::make_move_iterator(&aux_vect3[0])
+            , boost::make_move_iterator(aux_vect3 + 50));
+      MyStdMultiSet *stdmultiset2 = new MyStdMultiSet(aux_vect2, aux_vect2 + 50);
+      if(!CheckEqualContainers(boostset2, stdset2)){
+         std::cout << "Error in construct<MyBoostSet>(MyBoostSet2)" << std::endl;
+         return 1;
+      }
+      if(!CheckEqualContainers(boostmultiset2, stdmultiset2)){
+         std::cout << "Error in construct<MyBoostMultiSet>(MyBoostMultiSet2)" << std::endl;
+         return 1;
+      }
+
+      //ordered range insertion
+      for(int i = 0; i < 50; ++i){
+         IntType move_me(i);
+         aux_vect[i] = boost::move(move_me);
+      }
+
+      for(int i = 0; i < 50; ++i){
+         aux_vect2[i] = i;
+      }
+
+      for(int i = 0; i < 50; ++i){
+         IntType move_me(i);
+         aux_vect3[i] = boost::move(move_me);
+      }
+/*
+      MyBoostSet *boostset3 = MyBoostSet
+            ( ordered_unique_range
+            , boost::make_move_iterator(&aux_vect[0])
+            , boost::make_move_iterator(aux_vect + 50));
+      MyStdSet *stdset3 = new MyStdSet(aux_vect2, aux_vect2 + 50);
+      MyBoostMultiSet *boostmultiset3 = MyBoostMultiSet
+            ( ordered_range
+            , boost::make_move_iterator(&aux_vect3[0])
+            , boost::make_move_iterator(aux_vect3 + 50));
+      MyStdMultiSet *stdmultiset3 = new MyStdMultiSet(aux_vect2, aux_vect2 + 50);
+
+      if(!CheckEqualContainers(boostset3, stdset3)){
+         std::cout << "Error in construct<MyBoostSet>(MyBoostSet3)" << std::endl;
+         return 1;
+      }
+      if(!CheckEqualContainers(boostmultiset3, stdmultiset3)){
+         std::cout << "Error in construct<MyBoostMultiSet>(MyBoostMultiSet3)" << std::endl;
+         return 1;
+      }
+*/
+      delete boostset2;
+      delete boostmultiset2;
+      delete stdset2;
+      delete stdmultiset2;
+      //delete boostset3;
+      //delete boostmultiset3;
+      //delete stdset3;
+      //delete stdmultiset3;
+   }
+
+   int i, j;
+   for(i = 0; i < max; ++i){
+      IntType move_me(i);
+      boostset->insert(boost::move(move_me));
+      stdset->insert(i);
+      boostset->insert(IntType(i));
+      stdset->insert(i);
+      IntType move_me2(i);
+      boostmultiset->insert(boost::move(move_me2));
+      stdmultiset->insert(i);
+      boostmultiset->insert(IntType(i));
+      stdmultiset->insert(i);
+   }
+
+   if(!CheckEqualContainers(boostset, stdset)){
+      std::cout << "Error in boostset->insert(boost::move(move_me)" << std::endl;
+      return 1;
+   }
+
+   if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+      std::cout << "Error in boostmultiset->insert(boost::move(move_me)" << std::endl;
+      return 1;
+   }
+
+   typename MyBoostSet::iterator it;
+   typename MyBoostSet::const_iterator cit = it;
+
+   boostset->erase(boostset->begin()++);
+   stdset->erase(stdset->begin()++);
+   boostmultiset->erase(boostmultiset->begin()++);
+   stdmultiset->erase(stdmultiset->begin()++);
+   if(!CheckEqualContainers(boostset, stdset)){
+      std::cout << "Error in boostset->erase(boostset->begin()++)" << std::endl;
+      return 1;
+   }
+   if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+      std::cout << "Error in boostmultiset->erase(boostmultiset->begin()++)" << std::endl;
+      return 1;
+   }
+
+   boostset->erase(boostset->begin());
+   stdset->erase(stdset->begin());
+   boostmultiset->erase(boostmultiset->begin());
+   stdmultiset->erase(stdmultiset->begin());
+   if(!CheckEqualContainers(boostset, stdset)){
+      std::cout << "Error in boostset->erase(boostset->begin())" << std::endl;
+      return 1;
+   }
+   if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+      std::cout << "Error in boostmultiset->erase(boostmultiset->begin())" << std::endl;
+      return 1;
+   }
+
+   //Swapping test
+   MyBoostSet tmpboosteset2;
+   MyStdSet tmpstdset2;
+   MyBoostMultiSet tmpboostemultiset2;
+   MyStdMultiSet tmpstdmultiset2;
+   boostset->swap(tmpboosteset2);
+   stdset->swap(tmpstdset2);
+   boostmultiset->swap(tmpboostemultiset2);
+   stdmultiset->swap(tmpstdmultiset2);
+   boostset->swap(tmpboosteset2);
+   stdset->swap(tmpstdset2);
+   boostmultiset->swap(tmpboostemultiset2);
+   stdmultiset->swap(tmpstdmultiset2);
+   if(!CheckEqualContainers(boostset, stdset)){
+      std::cout << "Error in boostset->swap(tmpboosteset2)" << std::endl;
+      return 1;
+   }
+   if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+      std::cout << "Error in boostmultiset->swap(tmpboostemultiset2)" << std::endl;
+      return 1;
+   }
+
+   //Insertion from other container
+   //Initialize values
+   {
+      IntType aux_vect[50];
+      for(int i = 0; i < 50; ++i){
+         IntType move_me(-1);
+         aux_vect[i] = boost::move(move_me);
+      }
+      int aux_vect2[50];
+      for(int i = 0; i < 50; ++i){
+         aux_vect2[i] = -1;
+      }
+      IntType aux_vect3[50];
+      for(int i = 0; i < 50; ++i){
+         IntType move_me(-1);
+         aux_vect3[i] = boost::move(move_me);
+      }
+
+      boostset->insert(boost::make_move_iterator(&aux_vect[0]), boost::make_move_iterator(aux_vect + 50));
+      stdset->insert(aux_vect2, aux_vect2 + 50);
+      boostmultiset->insert(boost::make_move_iterator(&aux_vect3[0]), boost::make_move_iterator(aux_vect3 + 50));
+      stdmultiset->insert(aux_vect2, aux_vect2 + 50);
+      if(!CheckEqualContainers(boostset, stdset)){
+         std::cout << "Error in boostset->insert(boost::make_move_iterator(&aux_vect[0])..." << std::endl;
+         return 1;
+      }
+      if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+         std::cout << "Error in boostmultiset->insert(boost::make_move_iterator(&aux_vect3[0]), ..." << std::endl;
+         return 1;
+      }
+
+      for(int i = 0, j = static_cast<int>(boostset->size()); i < j; ++i){
+         IntType erase_me(i);
+         boostset->erase(erase_me);
+         stdset->erase(i);
+         boostmultiset->erase(erase_me);
+         stdmultiset->erase(i);
+         if(!CheckEqualContainers(boostset, stdset)){
+            std::cout << "Error in boostset->erase(erase_me)" << boostset->size() << " " << stdset->size() << std::endl;
+            return 1;
+         }
+         if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+            std::cout << "Error in boostmultiset->erase(erase_me)" << std::endl;
+            return 1;
+         }
+      }
+   }
+   {
+      IntType aux_vect[50];
+      for(int i = 0; i < 50; ++i){
+         IntType move_me(-1);
+         aux_vect[i] = boost::move(move_me);
+      }
+      int aux_vect2[50];
+      for(int i = 0; i < 50; ++i){
+         aux_vect2[i] = -1;
+      }
+      IntType aux_vect3[50];
+      for(int i = 0; i < 50; ++i){
+         IntType move_me(-1);
+         aux_vect3[i] = boost::move(move_me);
+      }
+
+      IntType aux_vect4[50];
+      for(int i = 0; i < 50; ++i){
+         IntType move_me(-1);
+         aux_vect4[i] = boost::move(move_me);
+      }
+
+      IntType aux_vect5[50];
+      for(int i = 0; i < 50; ++i){
+         IntType move_me(-1);
+         aux_vect5[i] = boost::move(move_me);
+      }
+
+      boostset->insert(boost::make_move_iterator(&aux_vect[0]), boost::make_move_iterator(aux_vect + 50));
+      boostset->insert(boost::make_move_iterator(&aux_vect3[0]), boost::make_move_iterator(aux_vect3 + 50));
+      stdset->insert(aux_vect2, aux_vect2 + 50);
+      stdset->insert(aux_vect2, aux_vect2 + 50);
+      boostmultiset->insert(boost::make_move_iterator(&aux_vect4[0]), boost::make_move_iterator(aux_vect4 + 50));
+      boostmultiset->insert(boost::make_move_iterator(&aux_vect5[0]), boost::make_move_iterator(aux_vect5 + 50));
+      stdmultiset->insert(aux_vect2, aux_vect2 + 50);
+      stdmultiset->insert(aux_vect2, aux_vect2 + 50);
+      if(!CheckEqualContainers(boostset, stdset)){
+         std::cout << "Error in boostset->insert(boost::make_move_iterator(&aux_vect3[0])..." << std::endl;
+         return 1;
+      }
+      if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+         std::cout << "Error in boostmultiset->insert(boost::make_move_iterator(&aux_vect5[0])..." << std::endl;
+         return 1;
+      }
+
+      boostset->erase(*boostset->begin());
+      stdset->erase(*stdset->begin());
+      boostmultiset->erase(*boostmultiset->begin());
+      stdmultiset->erase(*stdmultiset->begin());
+      if(!CheckEqualContainers(boostset, stdset)){
+         std::cout << "Error in boostset->erase(*boostset->begin())" << std::endl;
+         return 1;
+      }
+      if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+         std::cout << "Error in boostmultiset->erase(*boostmultiset->begin())" << std::endl;
+         return 1;
+      }
+   }
+
+   for(i = 0; i < max; ++i){
+      IntType move_me(i);
+      boostset->insert(boost::move(move_me));
+      stdset->insert(i);
+      IntType move_me2(i);
+      boostmultiset->insert(boost::move(move_me2));
+      stdmultiset->insert(i);
+   }
+
+   if(!CheckEqualContainers(boostset, stdset)){
+      std::cout << "Error in boostset->insert(boost::move(move_me)) try 2" << std::endl;
+      return 1;
+   }
+   if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+      std::cout << "Error in boostmultiset->insert(boost::move(move_me2)) try 2" << std::endl;
+      return 1;
+   }
+
+   for(i = 0; i < max; ++i){
+      IntType move_me(i);
+      boostset->insert(boostset->begin(), boost::move(move_me));
+      stdset->insert(stdset->begin(), i);
+      //PrintContainers(boostset, stdset);
+      IntType move_me2(i);
+      boostmultiset->insert(boostmultiset->begin(), boost::move(move_me2));
+      stdmultiset->insert(stdmultiset->begin(), i);
+      //PrintContainers(boostmultiset, stdmultiset);
+      if(!CheckEqualContainers(boostset, stdset)){
+         std::cout << "Error in boostset->insert(boostset->begin(), boost::move(move_me))" << std::endl;
+         return 1;
+      }
+      if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+         std::cout << "Error in boostmultiset->insert(boostmultiset->begin(), boost::move(move_me2))" << std::endl;
+         return 1;
+      }
+
+      IntType move_me3(i);
+      boostset->insert(boostset->end(), boost::move(move_me3));
+      stdset->insert(stdset->end(), i);
+      IntType move_me4(i);
+      boostmultiset->insert(boostmultiset->end(), boost::move(move_me4));
+      stdmultiset->insert(stdmultiset->end(), i);
+      if(!CheckEqualContainers(boostset, stdset)){
+         std::cout << "Error in boostset->insert(boostset->end(), boost::move(move_me3))" << std::endl;
+         return 1;
+      }
+      if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+         std::cout << "Error in boostmultiset->insert(boostmultiset->end(), boost::move(move_me4))" << std::endl;
+         return 1;
+      }
+      {
+      IntType move_me(i);
+      boostset->insert(boostset->upper_bound(move_me), boost::move(move_me));
+      stdset->insert(stdset->upper_bound(i), i);
+      //PrintContainers(boostset, stdset);
+      IntType move_me2(i);
+      boostmultiset->insert(boostmultiset->upper_bound(move_me2), boost::move(move_me2));
+      stdmultiset->insert(stdmultiset->upper_bound(i), i);
+      //PrintContainers(boostmultiset, stdmultiset);
+      if(!CheckEqualContainers(boostset, stdset)){
+         std::cout << "Error in boostset->insert(boostset->upper_bound(move_me), boost::move(move_me))" << std::endl;
+         return 1;
+      }
+      if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+         std::cout << "Error in boostmultiset->insert(boostmultiset->upper_bound(move_me2), boost::move(move_me2))" << std::endl;
+         return 1;
+      }
+
+      }
+      {
+      IntType move_me(i);
+      boostset->insert(boostset->lower_bound(move_me), boost::move(move_me2));
+      stdset->insert(stdset->lower_bound(i), i);
+      //PrintContainers(boostset, stdset);
+      IntType move_me2(i);
+      boostmultiset->insert(boostmultiset->lower_bound(move_me2), boost::move(move_me2));
+      stdmultiset->insert(stdmultiset->lower_bound(i), i);
+      //PrintContainers(boostmultiset, stdmultiset);
+      if(!CheckEqualContainers(boostset, stdset)){
+         std::cout << "Error in boostset->insert(boostset->lower_bound(move_me), boost::move(move_me2))" << std::endl;
+         return 1;
+      }
+      if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+         std::cout << "Error in boostmultiset->insert(boostmultiset->lower_bound(move_me2), boost::move(move_me2))" << std::endl;
+         return 1;
+      }
+      }
+   }
+
+   //Compare count with std containers
+   for(i = 0; i < max; ++i){
+      IntType count_me(i);
+      if(boostset->count(count_me) != stdset->count(i)){
+         return -1;
+      }
+      if(boostmultiset->count(count_me) != stdmultiset->count(i)){
+         return -1;
+      }
+   }
+
+   //Now do count exercise
+   boostset->erase(boostset->begin(), boostset->end());
+   boostmultiset->erase(boostmultiset->begin(), boostmultiset->end());
+   boostset->clear();
+   boostmultiset->clear();
+
+   for(j = 0; j < 3; ++j)
+   for(i = 0; i < 100; ++i){
+      IntType move_me(i);
+      boostset->insert(boost::move(move_me));
+      IntType move_me2(i);
+      boostmultiset->insert(boost::move(move_me2));
+      IntType count_me(i);
+      if(boostset->count(count_me) != typename MyBoostMultiSet::size_type(1)){
+         std::cout << "Error in boostset->count(count_me)" << std::endl;
+         return 1;
+      }
+      if(boostmultiset->count(count_me) != typename MyBoostMultiSet::size_type(j+1)){
+         std::cout << "Error in boostmultiset->count(count_me)" << std::endl;
+         return 1;
+      }
+   }
+
+   delete boostset;
+   delete stdset;
+   delete boostmultiset;
+   delete stdmultiset;
+   return 0;
+}
+
+template<class MyBoostSet
+        ,class MyStdSet
+        ,class MyBoostMultiSet
+        ,class MyStdMultiSet>
+int set_test_copyable ()
+{
+   typedef typename MyBoostSet::value_type IntType;
+   const int max = 100;
+
+   try{
+      //Shared memory allocator must be always be initialized
+      //since it has no default constructor
+      MyBoostSet *boostset = new MyBoostSet;
+      MyStdSet *stdset = new MyStdSet;
+      MyBoostMultiSet *boostmultiset = new MyBoostMultiSet;
+      MyStdMultiSet *stdmultiset = new MyStdMultiSet;
+
+      int i;
+      for(i = 0; i < max; ++i){
+         IntType move_me(i);
+         boostset->insert(boost::move(move_me));
+         stdset->insert(i);
+         IntType move_me2(i);
+         boostmultiset->insert(boost::move(move_me2));
+         stdmultiset->insert(i);
+      }
+      if(!CheckEqualContainers(boostset, stdset)) return 1;
+      if(!CheckEqualContainers(boostmultiset, stdmultiset)) return 1;
+
+      {
+         //Now, test copy constructor
+         MyBoostSet boostsetcopy(*boostset);
+         MyStdSet stdsetcopy(*stdset);
+
+         if(!CheckEqualContainers(&boostsetcopy, &stdsetcopy))
+            return 1;
+
+         MyBoostMultiSet boostmsetcopy(*boostmultiset);
+         MyStdMultiSet stdmsetcopy(*stdmultiset);
+
+         if(!CheckEqualContainers(&boostmsetcopy, &stdmsetcopy))
+            return 1;
+
+         //And now assignment
+         boostsetcopy  = *boostset;
+         stdsetcopy  = *stdset;
+
+         if(!CheckEqualContainers(&boostsetcopy, &stdsetcopy))
+            return 1;
+
+         boostmsetcopy = *boostmultiset;
+         stdmsetcopy = *stdmultiset;
+         
+         if(!CheckEqualContainers(&boostmsetcopy, &stdmsetcopy))
+            return 1;
+      }
+      delete boostset;
+      delete boostmultiset;
+   }
+   catch(...){
+      throw;
+   }
+   return 0;
+}
+
+}  //namespace test{
+}  //namespace container {
+}  //namespace boost{
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif

test/slist_test.cpp

@@ -0,0 +1,82 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2011. 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/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/slist.hpp>
+#include "dummy_test_allocator.hpp"
+#include "movable_int.hpp"
+#include "list_test.hpp"
+#include "emplace_test.hpp"
+
+using namespace boost::container;
+
+//Explicit instantiation to detect compilation errors
+template class boost::container::slist<test::movable_and_copyable_int, 
+   test::dummy_test_allocator<test::movable_and_copyable_int> >;
+
+typedef slist<int> MyList;
+typedef slist<test::movable_int> MyMoveList;
+typedef slist<test::movable_and_copyable_int> MyCopyMoveList;
+typedef slist<test::copyable_int> MyCopyList;
+
+class recursive_slist
+{
+public:
+   int id_;
+   slist<recursive_slist> slist_;
+   recursive_slist &operator=(const recursive_slist &o)
+   { slist_ = o.slist_;  return *this; }
+};
+
+void recursive_slist_test()//Test for recursive types
+{
+   slist<recursive_slist> recursive_list_list;
+}
+
+int main ()
+{
+   recursive_slist_test();
+   {
+      //Now test move semantics
+      slist<recursive_slist> original;
+      slist<recursive_slist> move_ctor(boost::move(original));
+      slist<recursive_slist> move_assign;
+      move_assign = boost::move(move_ctor);
+      move_assign.swap(original);
+      {
+         slist<recursive_slist> recursive, copy;
+         //Test to test both move emulations
+         if(!copy.size()){
+            copy = recursive;
+         }
+      }
+   }
+
+   if(test::list_test<MyList, false>())
+      return 1;
+
+   if(test::list_test<MyMoveList, false>())
+      return 1;
+
+   if(test::list_test<MyCopyMoveList, false>())
+      return 1;
+
+   if(test::list_test<MyCopyList, false>())
+      return 1;
+
+   const test::EmplaceOptions Options = (test::EmplaceOptions)
+      (test::EMPLACE_FRONT | test::EMPLACE_AFTER | test::EMPLACE_BEFORE  | test::EMPLACE_AFTER);
+
+   if(!boost::container::test::test_emplace
+      < slist<test::EmplaceInt>, Options>())
+      return 1;
+}
+
+#include <boost/container/detail/config_end.hpp>
+

test/stable_vector_test.cpp

@@ -0,0 +1,86 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2011. 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/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/detail/config_begin.hpp>
+#include <algorithm>
+#include <memory>
+#include <vector>
+#include <iostream>
+#include <functional>
+
+#include <boost/container/stable_vector.hpp>
+#include "check_equal_containers.hpp"
+#include "movable_int.hpp"
+#include "expand_bwd_test_allocator.hpp"
+#include "expand_bwd_test_template.hpp"
+#include "dummy_test_allocator.hpp"
+#include "vector_test.hpp"
+
+using namespace boost::container;
+
+//Explicit instantiation to detect compilation errors
+//template class stable_vector<test::movable_and_copyable_int, 
+   //test::dummy_test_allocator<test::movable_and_copyable_int> >;
+
+class recursive_vector
+{
+   public:
+   int id_;
+   stable_vector<recursive_vector> vector_;
+   recursive_vector &operator=(const recursive_vector &o)
+   { vector_ = o.vector_;  return *this; }
+};
+
+void recursive_vector_test()//Test for recursive types
+{
+   stable_vector<recursive_vector> recursive, copy;
+   //Test to test both move emulations
+   if(!copy.size()){
+      copy = recursive;
+   }
+}
+
+int main()
+{
+   recursive_vector_test();
+   {
+      //Now test move semantics
+      stable_vector<recursive_vector> original;
+      stable_vector<recursive_vector> move_ctor(boost::move(original));
+      stable_vector<recursive_vector> move_assign;
+      move_assign = boost::move(move_ctor);
+      move_assign.swap(original);
+   }
+   typedef stable_vector<int> MyVector;
+   typedef stable_vector<test::movable_int> MyMoveVector;
+   typedef stable_vector<test::movable_and_copyable_int> MyCopyMoveVector;
+   typedef stable_vector<test::copyable_int> MyCopyVector;
+
+   if(test::vector_test<MyVector>())
+      return 1;
+
+   if(test::vector_test<MyMoveVector>())
+      return 1;
+
+   if(test::vector_test<MyCopyMoveVector>())
+      return 1;
+
+   if(test::vector_test<MyCopyVector>())
+      return 1;
+
+   const test::EmplaceOptions Options = (test::EmplaceOptions)(test::EMPLACE_BACK | test::EMPLACE_BEFORE);
+   if(!boost::container::test::test_emplace
+      < stable_vector<test::EmplaceInt>, Options>())
+      return 1;
+
+   return 0;
+}
+
+#include <boost/container/detail/config_end.hpp>

test/string_test.cpp

@@ -0,0 +1,293 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2011. 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/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/vector.hpp>
+#include <boost/container/string.hpp>
+#include <string>
+#include <vector>
+#include <algorithm>
+#include <cstring>
+#include <cstdio>
+#include <cstddef>
+#include <new>
+#include "dummy_test_allocator.hpp"
+#include "check_equal_containers.hpp"
+#include "expand_bwd_test_allocator.hpp"
+#include "expand_bwd_test_template.hpp"
+
+using namespace boost::container;
+
+typedef test::dummy_test_allocator<char>           DummyCharAllocator; 
+typedef basic_string<char, std::char_traits<char>, DummyCharAllocator> DummyString;
+typedef test::dummy_test_allocator<DummyString>    DummyStringAllocator;
+typedef test::dummy_test_allocator<wchar_t>              DummyWCharAllocator; 
+typedef basic_string<wchar_t, std::char_traits<wchar_t>, DummyWCharAllocator> DummyWString;
+typedef test::dummy_test_allocator<DummyWString>         DummyWStringAllocator;
+
+//Explicit instantiations of container::basic_string
+template class basic_string<char, std::char_traits<char>, DummyCharAllocator>;
+template class basic_string<wchar_t, std::char_traits<wchar_t>, DummyWCharAllocator>;
+//Explicit instantiation of container::vectors of container::strings
+template class vector<DummyString, DummyStringAllocator>;
+template class vector<DummyWString, DummyWStringAllocator>;
+
+struct StringEqual
+{
+   template<class Str1, class Str2>
+   bool operator ()(const Str1 &string1, const Str2 &string2) const
+   {
+      if(string1.size() != string2.size())
+         return false;
+      return std::char_traits<typename Str1::value_type>::compare
+         (string1.c_str(), string2.c_str(), string1.size()) == 0;
+   }
+};
+
+//Function to check if both lists are equal
+template<class StrVector1, class StrVector2>
+bool CheckEqualStringVector(StrVector1 *strvect1, StrVector2 *strvect2)
+{
+   StringEqual comp;
+   return std::equal(strvect1->begin(), strvect1->end(), 
+                     strvect2->begin(), comp);
+}
+
+template<class CharType>
+int string_test()
+{
+   typedef std::string        StdString;
+   typedef vector<StdString>  StdStringVector;
+   typedef basic_string<CharType> BoostString;
+   typedef vector<BoostString> BoostStringVector;
+
+   const int MaxSize = 100;
+
+   //Create shared memory
+   {
+      BoostStringVector *boostStringVect = new BoostStringVector;
+      StdStringVector *stdStringVect = new StdStringVector;
+      BoostString auxBoostString;
+      StdString auxStdString(StdString(auxBoostString.begin(), auxBoostString.end() ));
+
+      CharType buffer [20];
+
+      //First, push back
+      for(int i = 0; i < MaxSize; ++i){
+         auxBoostString = "String";
+         auxStdString = "String";
+         std::sprintf(buffer, "%i", i);
+         auxBoostString += buffer;
+         auxStdString += buffer;
+         boostStringVect->push_back(auxBoostString);
+         stdStringVect->push_back(auxStdString);
+      }
+
+      if(!CheckEqualStringVector(boostStringVect, stdStringVect)){
+         return 1;
+      }
+
+      //Now push back moving 
+      for(int i = 0; i < MaxSize; ++i){
+         auxBoostString = "String";
+         auxStdString = "String";
+         std::sprintf(buffer, "%i", i);
+         auxBoostString += buffer;
+         auxStdString += buffer;
+         boostStringVect->push_back(boost::move(auxBoostString));
+         stdStringVect->push_back(auxStdString);
+      }
+
+      if(!CheckEqualStringVector(boostStringVect, stdStringVect)){
+         return 1;
+      }
+
+      //push front
+      for(int i = 0; i < MaxSize; ++i){
+         auxBoostString = "String";
+         auxStdString = "String";
+         std::sprintf(buffer, "%i", i);
+         auxBoostString += buffer;
+         auxStdString += buffer;
+         boostStringVect->insert(boostStringVect->begin(), auxBoostString);
+         stdStringVect->insert(stdStringVect->begin(), auxStdString);
+      }
+
+      if(!CheckEqualStringVector(boostStringVect, stdStringVect)){
+         return 1;
+      }
+
+      //Now push front moving 
+      for(int i = 0; i < MaxSize; ++i){
+         auxBoostString = "String";
+         auxStdString = "String";
+         std::sprintf(buffer, "%i", i);
+         auxBoostString += buffer;
+         auxStdString += buffer;
+         boostStringVect->insert(boostStringVect->begin(), boost::move(auxBoostString));
+         stdStringVect->insert(stdStringVect->begin(), auxStdString);
+      }
+
+      if(!CheckEqualStringVector(boostStringVect, stdStringVect)){
+         return 1;
+      }
+
+      //Now test long and short representation swapping
+
+      //Short first
+      auxBoostString = "String";
+      auxStdString = "String";
+      BoostString boost_swapper;
+      StdString std_swapper;
+      boost_swapper.swap(auxBoostString);
+      std_swapper.swap(auxStdString);
+      if(!StringEqual()(auxBoostString, auxStdString))
+         return 1;   
+      if(!StringEqual()(boost_swapper, std_swapper))
+         return 1;   
+      boost_swapper.swap(auxBoostString);
+      std_swapper.swap(auxStdString);
+      if(!StringEqual()(auxBoostString, auxStdString))
+         return 1;   
+      if(!StringEqual()(boost_swapper, std_swapper))
+         return 1;   
+
+      //Shrink_to_fit
+      auxBoostString.shrink_to_fit();
+      StdString(auxStdString).swap(auxStdString);
+      if(!StringEqual()(auxBoostString, auxStdString))
+         return 1;
+
+      //Reserve + shrink_to_fit
+      auxBoostString.reserve(boost_swapper.size()*2+1);
+      auxStdString.reserve(std_swapper.size()*2+1);
+      if(!StringEqual()(auxBoostString, auxStdString))
+         return 1;
+
+      auxBoostString.shrink_to_fit();
+      StdString(auxStdString).swap(auxStdString);
+      if(!StringEqual()(auxBoostString, auxStdString))
+         return 1;
+
+      //Long string
+      auxBoostString = "LongLongLongLongLongLongLongLongLongLongLongLongLongString";
+      auxStdString   = "LongLongLongLongLongLongLongLongLongLongLongLongLongString";
+      boost_swapper = BoostString();
+      std_swapper = StdString();
+      boost_swapper.swap(auxBoostString);
+      std_swapper.swap(auxStdString);
+      if(!StringEqual()(auxBoostString, auxStdString))
+         return 1;   
+      if(!StringEqual()(boost_swapper, std_swapper))
+         return 1;
+      boost_swapper.swap(auxBoostString);
+      std_swapper.swap(auxStdString);
+
+      //Shrink_to_fit
+      auxBoostString.shrink_to_fit();
+      StdString(auxStdString).swap(auxStdString);
+      if(!StringEqual()(auxBoostString, auxStdString))
+         return 1;
+
+      auxBoostString.clear();
+      auxStdString.clear();
+      auxBoostString.shrink_to_fit();
+      StdString(auxStdString).swap(auxStdString);
+      if(!StringEqual()(auxBoostString, auxStdString))
+         return 1;
+
+      //No sort
+      std::sort(boostStringVect->begin(), boostStringVect->end());
+      std::sort(stdStringVect->begin(), stdStringVect->end());
+      if(!CheckEqualStringVector(boostStringVect, stdStringVect)) return 1;
+
+      const CharType prefix []    = "Prefix";
+      const int  prefix_size  = sizeof(prefix)/sizeof(prefix[0])-1;
+      const CharType sufix []     = "Suffix";
+
+      for(int i = 0; i < MaxSize; ++i){
+         (*boostStringVect)[i].append(sufix);
+         (*stdStringVect)[i].append(sufix);
+         (*boostStringVect)[i].insert((*boostStringVect)[i].begin(), 
+                                    prefix, prefix + prefix_size);
+         (*stdStringVect)[i].insert((*stdStringVect)[i].begin(), 
+                                    prefix, prefix + prefix_size);
+      }
+
+      if(!CheckEqualStringVector(boostStringVect, stdStringVect)) return 1;
+
+      for(int i = 0; i < MaxSize; ++i){
+         std::reverse((*boostStringVect)[i].begin(), (*boostStringVect)[i].end());
+         std::reverse((*stdStringVect)[i].begin(), (*stdStringVect)[i].end());
+      }
+
+      if(!CheckEqualStringVector(boostStringVect, stdStringVect)) return 1;
+
+      for(int i = 0; i < MaxSize; ++i){
+         std::reverse((*boostStringVect)[i].begin(), (*boostStringVect)[i].end());
+         std::reverse((*stdStringVect)[i].begin(), (*stdStringVect)[i].end());
+      }
+
+      if(!CheckEqualStringVector(boostStringVect, stdStringVect)) return 1;
+
+      for(int i = 0; i < MaxSize; ++i){
+         std::sort(boostStringVect->begin(), boostStringVect->end());
+         std::sort(stdStringVect->begin(), stdStringVect->end());
+      }
+
+      if(!CheckEqualStringVector(boostStringVect, stdStringVect)) return 1;
+
+      for(int i = 0; i < MaxSize; ++i){
+         (*boostStringVect)[i].replace((*boostStringVect)[i].begin(), 
+                                    (*boostStringVect)[i].end(),
+                                    "String");
+         (*stdStringVect)[i].replace((*stdStringVect)[i].begin(), 
+                                    (*stdStringVect)[i].end(),
+                                    "String");
+      }
+
+      if(!CheckEqualStringVector(boostStringVect, stdStringVect)) return 1;
+
+      boostStringVect->erase(std::unique(boostStringVect->begin(), boostStringVect->end()),
+                           boostStringVect->end());
+      stdStringVect->erase(std::unique(stdStringVect->begin(), stdStringVect->end()),
+                           stdStringVect->end());
+      if(!CheckEqualStringVector(boostStringVect, stdStringVect)) return 1;
+
+      //When done, delete vector
+      delete boostStringVect;
+      delete stdStringVect;
+   }
+   return 0;
+}
+
+bool test_expand_bwd()
+{
+   //Now test all back insertion possibilities
+   typedef test::expand_bwd_test_allocator<char>
+      allocator_type;
+   typedef basic_string<char, std::char_traits<char>, allocator_type>
+      string_type;
+   return  test::test_all_expand_bwd<string_type>();
+}
+
+int main()
+{
+   if(string_test<char>()){
+      return 1;
+   }
+
+   if(!test_expand_bwd())
+      return 1;
+
+   return 0;
+}
+
+#include <boost/container/detail/config_end.hpp>

test/tree_test.cpp

@@ -0,0 +1,233 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2011. 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/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/container/detail/config_begin.hpp>
+#include <set>
+#include <boost/container/set.hpp>
+#include <boost/container/map.hpp>
+#include "print_container.hpp"
+#include "movable_int.hpp"
+#include "dummy_test_allocator.hpp"
+#include "set_test.hpp"
+#include "map_test.hpp"
+#include "emplace_test.hpp"
+
+using namespace boost::container;
+
+//Alias standard types
+typedef std::set<int>                                          MyStdSet;
+typedef std::multiset<int>                                     MyStdMultiSet;
+typedef std::map<int, int>                                     MyStdMap;
+typedef std::multimap<int, int>                                MyStdMultiMap;
+
+//Alias non-movable types
+typedef set<int>           MyBoostSet;
+typedef multiset<int>      MyBoostMultiSet;
+typedef map<int, int>      MyBoostMap;
+typedef multimap<int, int> MyBoostMultiMap;
+
+//Alias movable types
+typedef set<test::movable_int>                           MyMovableBoostSet;
+typedef multiset<test::movable_int>                      MyMovableBoostMultiSet;
+typedef map<test::movable_int, test::movable_int>        MyMovableBoostMap;
+typedef multimap<test::movable_int, test::movable_int>   MyMovableBoostMultiMap;
+typedef set<test::movable_and_copyable_int>              MyMoveCopyBoostSet;
+typedef set<test::copyable_int>                          MyCopyBoostSet;
+typedef multiset<test::movable_and_copyable_int>         MyMoveCopyBoostMultiSet;
+typedef multiset<test::copyable_int>                     MyCopyBoostMultiSet;
+typedef map<test::movable_and_copyable_int
+           ,test::movable_and_copyable_int>              MyMoveCopyBoostMap;
+typedef multimap<test::movable_and_copyable_int
+                ,test::movable_and_copyable_int>         MyMoveCopyBoostMultiMap;
+typedef map<test::copyable_int
+           ,test::copyable_int>                          MyCopyBoostMap;
+typedef multimap<test::copyable_int
+                ,test::copyable_int>                     MyCopyBoostMultiMap;
+//Test recursive structures
+class recursive_set
+{
+public:
+   int id_;
+   set<recursive_set> set_;
+   friend bool operator< (const recursive_set &a, const recursive_set &b)
+   {  return a.id_ < b.id_;   }
+};
+
+class recursive_map
+{
+   public:
+   int id_;
+   map<recursive_map, recursive_map> map_;
+   friend bool operator< (const recursive_map &a, const recursive_map &b)
+   {  return a.id_ < b.id_;   }
+};
+
+//Test recursive structures
+class recursive_multiset
+{
+public:
+   int id_;
+   multiset<recursive_multiset> multiset_;
+   friend bool operator< (const recursive_multiset &a, const recursive_multiset &b)
+   {  return a.id_ < b.id_;   }
+};
+
+class recursive_multimap
+{
+public:
+   int id_;
+   multimap<recursive_multimap, recursive_multimap> multimap_;
+   friend bool operator< (const recursive_multimap &a, const recursive_multimap &b)
+   {  return a.id_ < b.id_;   }
+};
+
+template<class C>
+void test_move()
+{
+   //Now test move semantics
+   C original;
+   C move_ctor(boost::move(original));
+   C move_assign;
+   move_assign = boost::move(move_ctor);
+   move_assign.swap(original);
+}
+
+int main ()
+{
+   //Recursive container instantiation
+   {
+      set<recursive_set> set_;
+      multiset<recursive_multiset> multiset_;
+      map<recursive_map, recursive_map> map_;
+      multimap<recursive_multimap, recursive_multimap> multimap_;
+   }
+   //Now test move semantics
+   {
+      test_move<set<recursive_set> >();
+      test_move<multiset<recursive_multiset> >();
+      test_move<map<recursive_map, recursive_map> >();
+      test_move<multimap<recursive_multimap, recursive_multimap> >();
+   }
+
+   //using namespace boost::container::detail;
+
+   if(0 != test::set_test<MyBoostSet
+                        ,MyStdSet
+                        ,MyBoostMultiSet
+                        ,MyStdMultiSet>()){
+      return 1;
+   }
+
+   if(0 != test::set_test_copyable<MyBoostSet
+                        ,MyStdSet
+                        ,MyBoostMultiSet
+                        ,MyStdMultiSet>()){
+      return 1;
+   }
+
+   if(0 != test::set_test<MyMovableBoostSet
+                        ,MyStdSet
+                        ,MyMovableBoostMultiSet
+                        ,MyStdMultiSet>()){
+      return 1;
+   }
+
+   if(0 != test::set_test<MyMoveCopyBoostSet
+                        ,MyStdSet
+                        ,MyMoveCopyBoostMultiSet
+                        ,MyStdMultiSet>()){
+      return 1;
+   }
+
+   if(0 != test::set_test_copyable<MyMoveCopyBoostSet
+                        ,MyStdSet
+                        ,MyMoveCopyBoostMultiSet
+                        ,MyStdMultiSet>()){
+      return 1;
+   }
+
+   if(0 != test::set_test<MyCopyBoostSet
+                        ,MyStdSet
+                        ,MyCopyBoostMultiSet
+                        ,MyStdMultiSet>()){
+      return 1;
+   }
+
+   if(0 != test::set_test_copyable<MyCopyBoostSet
+                        ,MyStdSet
+                        ,MyCopyBoostMultiSet
+                        ,MyStdMultiSet>()){
+      return 1;
+   }
+
+   if (0 != test::map_test<MyBoostMap
+                  ,MyStdMap
+                  ,MyBoostMultiMap
+                  ,MyStdMultiMap>()){
+      return 1;
+   }
+
+   if(0 != test::map_test_copyable<MyBoostMap
+                        ,MyStdMap
+                        ,MyBoostMultiMap
+                        ,MyStdMultiMap>()){
+      return 1;
+   }
+
+//   if (0 != test::map_test<my_managed_shared_memory
+//                  ,MyMovableBoostMap
+//                  ,MyStdMap
+//                  ,MyMovableBoostMultiMap
+//                  ,MyStdMultiMap>()){
+//      return 1;
+//   }
+
+   if (0 != test::map_test<MyMoveCopyBoostMap
+                  ,MyStdMap
+                  ,MyMoveCopyBoostMultiMap
+                  ,MyStdMultiMap>()){
+      return 1;
+   }
+
+   if (0 != test::map_test_copyable<MyMoveCopyBoostMap
+                  ,MyStdMap
+                  ,MyMoveCopyBoostMultiMap
+                  ,MyStdMultiMap>()){
+      return 1;
+   }
+
+   if (0 != test::map_test<MyCopyBoostMap
+                  ,MyStdMap
+                  ,MyCopyBoostMultiMap
+                  ,MyStdMultiMap>()){
+      return 1;
+   }
+
+   if (0 != test::map_test_copyable<MyCopyBoostMap
+                  ,MyStdMap
+                  ,MyCopyBoostMultiMap
+                  ,MyStdMultiMap>()){
+      return 1;
+   }
+
+   const test::EmplaceOptions SetOptions = (test::EmplaceOptions)(test::EMPLACE_HINT | test::EMPLACE_ASSOC);
+   if(!boost::container::test::test_emplace<set<test::EmplaceInt>, SetOptions>())
+      return 1;
+   if(!boost::container::test::test_emplace<multiset<test::EmplaceInt>, SetOptions>())
+      return 1;
+   const test::EmplaceOptions MapOptions = (test::EmplaceOptions)(test::EMPLACE_HINT_PAIR | test::EMPLACE_ASSOC_PAIR);
+   if(!boost::container::test::test_emplace<map<test::EmplaceInt, test::EmplaceInt>, MapOptions>())
+      return 1;
+   if(!boost::container::test::test_emplace<multimap<test::EmplaceInt, test::EmplaceInt>, MapOptions>())
+      return 1;
+
+   return 0;
+}
+
+#include <boost/container/detail/config_end.hpp>

test/util.hpp

@@ -0,0 +1,113 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2011. 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/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2001-2003
+// William E. Kempf
+//
+// Permission to use, copy, modify, distribute and sell this software
+// and its documentation for any purpose is hereby granted without fee,
+// provided that the above copyright notice appear in all copies and
+// that both that copyright notice and this permission notice appear
+// in supporting documentation.  William E. Kempf makes no representations
+// about the suitability of this software for any purpose.
+// It is provided "as is" without express or implied warranty.
+
+#ifndef BOOST_CONTAINER_TEST_UTIL_HEADER
+#define BOOST_CONTAINER_TEST_UTIL_HEADER
+
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/sync/container_mutex.hpp>
+#include <boost/container/sync/container_condition.hpp>
+#include <boost/container/sync/scoped_lock.hpp>
+#include <boost/thread/thread.hpp>
+#include <boost/thread/xtime.hpp>
+
+#include <boost/date_time/posix_time/posix_time_types.hpp>
+#include <algorithm>
+#include <iostream>
+
+#ifndef DEFAULT_EXECUTION_MONITOR_TYPE
+#   define DEFAULT_EXECUTION_MONITOR_TYPE execution_monitor::use_condition
+#endif
+
+namespace boost {
+namespace container {
+namespace test {
+
+inline void sleep(const boost::posix_time::ptime &xt)
+{
+   boost::container::container_mutex mx;
+   boost::container::scoped_lock<boost::container::container_mutex>
+      lock(mx);
+   boost::container::container_condition cond;
+   cond.timed_wait(lock, xt);
+}
+
+inline boost::posix_time::ptime delay(int secs, int msecs=0, int nsecs = 0)
+{
+   (void)msecs;
+   using namespace boost::posix_time;
+   int count = static_cast<int>(double(nsecs)*
+               (double(time_duration::ticks_per_second())/double(1000000000.0)));
+   count += static_cast<int>(double(msecs)*
+               (double(time_duration::ticks_per_second())/double(1000.0)));
+   boost::posix_time::ptime cur = microsec_clock::universal_time();
+   return cur +=  boost::posix_time::time_duration(0, 0, secs, count);
+}
+
+inline bool in_range(const boost::posix_time::ptime& xt, int secs=1)
+{
+    boost::posix_time::ptime min = delay(-secs);
+    boost::posix_time::ptime max = delay(0);
+    return (xt > min) && (max > xt);
+}
+
+boost::xtime xsecs(int secs)
+{
+   boost::xtime ret;
+   boost::xtime_get(&ret, boost::TIME_UTC);
+   ret.sec += secs;
+   return ret;
+}
+
+template <typename P>
+class thread_adapter
+{
+   public:
+   thread_adapter(void (*func)(void*, P &), void* param1, P &param2)
+      : _func(func), _param1(param1) ,_param2(param2){ }
+   void operator()() const { _func(_param1, _param2); }
+
+   private:
+   void (*_func)(void*, P &);
+   void* _param1;
+   P& _param2;
+};
+
+template <typename P>
+struct data
+{
+   data(int id, int secs=0)
+      : m_id(id), m_value(-1), m_secs(secs)
+   {}
+   int m_id;
+   int m_value;
+   int m_secs;
+};
+
+static int shared_val = 0;
+static const int BaseSeconds = 1;
+
+}  //namespace test {
+}  //namespace container {
+}  //namespace boost {
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_CONTAINER_TEST_UTIL_HEADER

test/vector_test.cpp

@@ -0,0 +1,127 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2011. 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/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/detail/config_begin.hpp>
+#include <algorithm>
+#include <memory>
+#include <vector>
+#include <iostream>
+#include <functional>
+
+#include <boost/container/vector.hpp>
+#include "check_equal_containers.hpp"
+#include "movable_int.hpp"
+#include "expand_bwd_test_allocator.hpp"
+#include "expand_bwd_test_template.hpp"
+#include "dummy_test_allocator.hpp"
+#include "vector_test.hpp"
+
+using namespace boost::container;
+
+//Explicit instantiation to detect compilation errors
+template class boost::container::vector<test::movable_and_copyable_int, 
+   test::dummy_test_allocator<test::movable_and_copyable_int> >;
+
+int test_expand_bwd()
+{
+   //Now test all back insertion possibilities
+
+   //First raw ints
+   typedef test::expand_bwd_test_allocator<int>
+      int_allocator_type;
+   typedef vector<int, int_allocator_type>
+      int_vector;
+
+   if(!test::test_all_expand_bwd<int_vector>())
+      return 1;
+
+   //Now user defined wrapped int
+   typedef test::expand_bwd_test_allocator<test::int_holder>
+      int_holder_allocator_type;
+   typedef vector<test::int_holder, int_holder_allocator_type>
+      int_holder_vector;
+
+   if(!test::test_all_expand_bwd<int_holder_vector>())
+      return 1;
+
+   //Now user defined bigger wrapped int
+   typedef test::expand_bwd_test_allocator<test::triple_int_holder>
+      triple_int_holder_allocator_type;
+
+   typedef vector<test::triple_int_holder, triple_int_holder_allocator_type>
+      triple_int_holder_vector;
+
+   if(!test::test_all_expand_bwd<triple_int_holder_vector>())
+      return 1;
+
+   return 0;
+}
+
+class recursive_vector
+{
+   public:
+   int id_;
+   vector<recursive_vector> vector_;
+};
+
+void recursive_vector_test()//Test for recursive types
+{
+   vector<recursive_vector> recursive_vector_vector;
+}
+
+enum Test
+{
+   zero, one, two, three, four, five, six
+};
+
+
+int main()
+{
+   recursive_vector_test();
+   {
+      //Now test move semantics
+      vector<recursive_vector> original;
+      vector<recursive_vector> move_ctor(boost::move(original));
+      vector<recursive_vector> move_assign;
+      move_assign = boost::move(move_ctor);
+      move_assign.swap(original);
+   }
+   typedef vector<int> MyVector;
+   typedef vector<test::movable_int> MyMoveVector;
+   typedef vector<test::movable_and_copyable_int> MyCopyMoveVector;
+   typedef vector<test::copyable_int> MyCopyVector;
+   typedef vector<Test> MyEnumVector;
+
+
+   if(test::vector_test<MyVector>())
+      return 1;
+   if(test::vector_test<MyMoveVector>())
+      return 1;
+   if(test::vector_test<MyCopyMoveVector>())
+      return 1;
+   if(test::vector_test<MyCopyVector>())
+      return 1;
+   if(test_expand_bwd())
+      return 1;
+
+   MyEnumVector v;
+   Test t;
+   v.push_back(t);
+   v.push_back(::boost::move(t));
+   v.push_back(Test());
+
+   const test::EmplaceOptions Options = (test::EmplaceOptions)(test::EMPLACE_BACK | test::EMPLACE_BEFORE);
+   if(!boost::container::test::test_emplace
+      < vector<test::EmplaceInt>, Options>())
+      return 1;
+
+   return 0;
+}
+#include <boost/container/detail/config_end.hpp>

test/vector_test.hpp

@@ -0,0 +1,253 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2011. 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/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/detail/config_begin.hpp>
+#include <algorithm>
+#include <memory>
+#include <vector>
+#include <iostream>
+#include <functional>
+#include <list>
+
+#include <boost/move/move.hpp>
+#include <boost/container/detail/mpl.hpp>
+#include "print_container.hpp"
+#include "check_equal_containers.hpp"
+#include "movable_int.hpp"
+#include <string>
+#include <vector>
+#include "emplace_test.hpp"
+
+namespace boost{
+namespace container {
+namespace test{
+
+template<class V1, class V2>
+bool vector_copyable_only(V1 *, V2 *, boost::container::containers_detail::false_type)
+{
+   return true;
+}
+
+//Function to check if both sets are equal
+template<class V1, class V2>
+bool vector_copyable_only(V1 *boostvector, V2 *stdvector, boost::container::containers_detail::true_type)
+{
+   typedef typename V1::value_type IntType;
+   std::size_t size = boostvector->size();
+   boostvector->insert(boostvector->end(), 50, IntType(1));
+   stdvector->insert(stdvector->end(), 50, 1);
+   if(!test::CheckEqualContainers(boostvector, stdvector)) return false;
+
+   {
+      IntType move_me(1);
+      boostvector->insert(boostvector->begin()+size/2, 50, boost::move(move_me));
+      stdvector->insert(stdvector->begin()+size/2, 50, 1);
+      if(!test::CheckEqualContainers(boostvector, stdvector)) return false;
+   }
+   {
+      IntType move_me(2);
+      boostvector->assign(boostvector->size()/2, boost::move(move_me));
+      stdvector->assign(stdvector->size()/2, 2);
+      if(!test::CheckEqualContainers(boostvector, stdvector)) return false;
+   }
+   {
+      IntType move_me(3);
+      boostvector->assign(boostvector->size()*3-1, boost::move(move_me));
+      stdvector->assign(stdvector->size()*3-1, 3);
+      if(!test::CheckEqualContainers(boostvector, stdvector)) return false;
+   }
+
+   {
+      IntType copy_me(3);
+      const IntType ccopy_me(3);
+      boostvector->push_back(copy_me);
+      stdvector->push_back(int(3));
+      boostvector->push_back(ccopy_me);
+      stdvector->push_back(int(3));
+      if(!test::CheckEqualContainers(boostvector, stdvector)) return false;
+   }
+
+   return true;
+}
+
+template<class MyBoostVector>
+int vector_test()
+{
+   typedef std::vector<int>                     MyStdVector;
+   typedef typename MyBoostVector::value_type     IntType;
+   const int max = 100;
+
+   {
+      try{
+         MyBoostVector *boostvector = new MyBoostVector;
+         MyStdVector *stdvector = new MyStdVector;
+         boostvector->resize(100);
+         stdvector->resize(100);
+         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;         
+
+         boostvector->resize(200);
+         stdvector->resize(200);
+         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;         
+
+         boostvector->resize(0);
+         stdvector->resize(0);
+         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;         
+
+         for(int i = 0; i < max; ++i){
+            IntType new_int(i);
+            boostvector->insert(boostvector->end(), boost::move(new_int));
+            stdvector->insert(stdvector->end(), i);
+            if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+         }
+         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+         typename MyBoostVector::iterator boostit(boostvector->begin());
+         typename MyStdVector::iterator stdit(stdvector->begin());
+         typename MyBoostVector::const_iterator cboostit = boostit;
+         ++boostit; ++stdit;
+         boostvector->erase(boostit);
+         stdvector->erase(stdit);
+         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+         boostvector->erase(boostvector->begin());
+         stdvector->erase(stdvector->begin());
+         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+         {
+            //Initialize values
+            IntType aux_vect[50];
+            for(int i = 0; i < 50; ++i){
+               IntType new_int(-1);
+               BOOST_STATIC_ASSERT((boost::container::test::is_copyable<boost::container::test::movable_int>::value == false));
+               aux_vect[i] = boost::move(new_int);
+            }
+            int aux_vect2[50];
+            for(int i = 0; i < 50; ++i){
+               aux_vect2[i] = -1;
+            }
+
+            boostvector->insert(boostvector->end()
+                              ,boost::make_move_iterator(&aux_vect[0])
+                              ,boost::make_move_iterator(aux_vect + 50));
+            stdvector->insert(stdvector->end(), aux_vect2, aux_vect2 + 50);
+            if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+            for(int i = 0, j = static_cast<int>(boostvector->size()); i < j; ++i){
+               boostvector->erase(boostvector->begin());
+               stdvector->erase(stdvector->begin());
+            }
+            if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+         }
+         {
+            IntType aux_vect[50];
+            for(int i = 0; i < 50; ++i){
+               IntType new_int(-1);
+               aux_vect[i] = boost::move(new_int);
+            }
+            int aux_vect2[50];
+            for(int i = 0; i < 50; ++i){
+               aux_vect2[i] = -1;
+            }
+            boostvector->insert(boostvector->begin()
+                              ,boost::make_move_iterator(&aux_vect[0])
+                              ,boost::make_move_iterator(aux_vect + 50));
+            stdvector->insert(stdvector->begin(), aux_vect2, aux_vect2 + 50);
+            if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+         }
+/*
+         boostvector->reserve(boostvector->size()*2);
+         stdvector->reserve(stdvector->size()*2);
+         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+*/
+         boostvector->shrink_to_fit();
+         MyStdVector(*stdvector).swap(*stdvector);
+         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+         boostvector->shrink_to_fit();
+         MyStdVector(*stdvector).swap(*stdvector);
+         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+         IntType push_back_this(1);
+         boostvector->push_back(boost::move(push_back_this));
+         stdvector->push_back(int(1));
+         boostvector->push_back(IntType(1));
+         stdvector->push_back(int(1));
+
+         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+         if(!vector_copyable_only(boostvector, stdvector
+                        ,containers_detail::bool_<boost::container::test::is_copyable<IntType>::value>())){
+            return 1;
+         }
+
+         boostvector->erase(boostvector->begin());
+         stdvector->erase(stdvector->begin());
+         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+         for(int i = 0; i < max; ++i){
+            IntType insert_this(i);
+            boostvector->insert(boostvector->begin(), boost::move(insert_this));
+            stdvector->insert(stdvector->begin(), i);
+            boostvector->insert(boostvector->begin(), IntType(i));
+            stdvector->insert(stdvector->begin(), int(i));
+         }
+         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+         //Test insertion from list
+         {
+            std::list<int> l(50, int(1));
+            boostvector->insert(boostvector->begin(), l.begin(), l.end());
+            stdvector->insert(stdvector->begin(), l.begin(), l.end());
+            if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+            boostvector->assign(l.begin(), l.end());
+            stdvector->assign(l.begin(), l.end());
+            if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+         }
+/*
+         std::size_t cap = boostvector->capacity();
+         boostvector->reserve(cap*2);
+         stdvector->reserve(cap*2);
+         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+         boostvector->resize(0);
+         stdvector->resize(0);
+         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+         boostvector->resize(cap*2);
+         stdvector->resize(cap*2);
+         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+         boostvector->clear();
+         stdvector->clear();
+         boostvector->shrink_to_fit();
+         MyStdVector(*stdvector).swap(*stdvector);
+         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+         boostvector->resize(cap*2);
+         stdvector->resize(cap*2);
+         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+*/
+
+         delete stdvector;
+         delete boostvector;
+      }
+      catch(std::exception &ex){
+         std::cout << ex.what() << std::endl;
+         return 1;
+      }
+   }
+   std::cout << std::endl << "Test OK!" << std::endl;
+   return 0;
+}
+
+}  //namespace test{
+}  //namespace container {
+}  //namespace boost{
+
+#include <boost/container/detail/config_end.hpp>