Implement full support for non-pointer pointers in custom allocators for list.

llvm-svn: 184859

64 files changed, 1857 insertions, 4 deletions

diff --git a/libcxx/test/containers/sequences/list/db_back.pass.cpp b/libcxx/test/containers/sequences/list/db_back.pass.cpp
index ef8e6924ec7..1cf9e4b395f 100644
--- a/libcxx/test/containers/sequences/list/db_back.pass.cpp
+++ b/libcxx/test/containers/sequences/list/db_back.pass.cpp
@@ -21,8 +21,11 @@
 #include <exception>
 #include <cstdlib>
 
+#include "../../min_allocator.h"
+
 int main()
 {
+    {
     typedef int T;
     typedef std::list<T> C;
     C c(1);
@@ -30,6 +33,18 @@ int main()
     c.clear();
     assert(c.back() == 0);
     assert(false);
+    }
+#if __cplusplus >= 201103L
+    {
+    typedef int T;
+    typedef std::list<T, min_allocator<T>> C;
+    C c(1);
+    assert(c.back() == 0);
+    c.clear();
+    assert(c.back() == 0);
+    assert(false);
+    }
+#endif
 }
 
 #else
diff --git a/libcxx/test/containers/sequences/list/db_cback.pass.cpp b/libcxx/test/containers/sequences/list/db_cback.pass.cpp
index dc40b470b7b..55338f80475 100644
--- a/libcxx/test/containers/sequences/list/db_cback.pass.cpp
+++ b/libcxx/test/containers/sequences/list/db_cback.pass.cpp
@@ -21,13 +21,26 @@
 #include <exception>
 #include <cstdlib>
 
+#include "../../min_allocator.h"
+
 int main()
 {
+    {
     typedef int T;
     typedef std::list<T> C;
     const C c;
     assert(c.back() == 0);
     assert(false);
+    }
+#if __cplusplus >= 201103L
+    {
+    typedef int T;
+    typedef std::list<T, min_allocator<T>> C;
+    const C c;
+    assert(c.back() == 0);
+    assert(false);
+    }
+#endif
 }
 
 #else
diff --git a/libcxx/test/containers/sequences/list/db_cfront.pass.cpp b/libcxx/test/containers/sequences/list/db_cfront.pass.cpp
index aa5ab98cf58..9a36a5355ea 100644
--- a/libcxx/test/containers/sequences/list/db_cfront.pass.cpp
+++ b/libcxx/test/containers/sequences/list/db_cfront.pass.cpp
@@ -21,13 +21,26 @@
 #include <exception>
 #include <cstdlib>
 
+#include "../../min_allocator.h"
+
 int main()
 {
+    {
     typedef int T;
     typedef std::list<T> C;
     const C c;
     assert(c.front() == 0);
     assert(false);
+    }
+#if __cplusplus >= 201103L
+    {
+    typedef int T;
+    typedef std::list<T, min_allocator<T>> C;
+    const C c;
+    assert(c.front() == 0);
+    assert(false);
+    }
+#endif
 }
 
 #else
diff --git a/libcxx/test/containers/sequences/list/db_front.pass.cpp b/libcxx/test/containers/sequences/list/db_front.pass.cpp
index fc37c5adc97..39fcf244860 100644
--- a/libcxx/test/containers/sequences/list/db_front.pass.cpp
+++ b/libcxx/test/containers/sequences/list/db_front.pass.cpp
@@ -21,8 +21,11 @@
 #include <exception>
 #include <cstdlib>
 
+#include "../../min_allocator.h"
+
 int main()
 {
+    {
     typedef int T;
     typedef std::list<T> C;
     C c(1);
@@ -30,6 +33,18 @@ int main()
     c.clear();
     assert(c.front() == 0);
     assert(false);
+    }
+#if __cplusplus >= 201103L
+    {
+    typedef int T;
+    typedef std::list<T, min_allocator<T>> C;
+    C c(1);
+    assert(c.front() == 0);
+    c.clear();
+    assert(c.front() == 0);
+    assert(false);
+    }
+#endif
 }
 
 #else
diff --git a/libcxx/test/containers/sequences/list/db_iterators_1.pass.cpp b/libcxx/test/containers/sequences/list/db_iterators_1.pass.cpp
index 7038ed47302..ae278f78756 100644
--- a/libcxx/test/containers/sequences/list/db_iterators_1.pass.cpp
+++ b/libcxx/test/containers/sequences/list/db_iterators_1.pass.cpp
@@ -21,14 +21,28 @@
 #include <exception>
 #include <cstdlib>
 
+#include "../../min_allocator.h"
+
 int main()
 {
+    {
     typedef int T;
     typedef std::list<T> C;
     C c1;
     C c2;
     bool b = c1.begin() != c2.begin();
     assert(false);
+    }
+#if __cplusplus >= 201103L
+    {
+    typedef int T;
+    typedef std::list<T, min_allocator<T>> C;
+    C c1;
+    C c2;
+    bool b = c1.begin() != c2.begin();
+    assert(false);
+    }
+#endif
 }
 
 #else
diff --git a/libcxx/test/containers/sequences/list/db_iterators_6.pass.cpp b/libcxx/test/containers/sequences/list/db_iterators_6.pass.cpp
index c64b4384c35..c27c8d7a43a 100644
--- a/libcxx/test/containers/sequences/list/db_iterators_6.pass.cpp
+++ b/libcxx/test/containers/sequences/list/db_iterators_6.pass.cpp
@@ -21,8 +21,11 @@
 #include <exception>
 #include <cstdlib>
 
+#include "../../min_allocator.h"
+
 int main()
 {
+    {
     typedef int T;
     typedef std::list<T> C;
     C c(1);
@@ -31,6 +34,19 @@ int main()
     assert(i == c.begin());
     --i;
     assert(false);
+    }
+#if __cplusplus >= 201103L
+    {
+    typedef int T;
+    typedef std::list<T, min_allocator<T>> C;
+    C c(1);
+    C::iterator i = c.end();
+    --i;
+    assert(i == c.begin());
+    --i;
+    assert(false);
+    }
+#endif
 }
 
 #else
diff --git a/libcxx/test/containers/sequences/list/db_iterators_7.pass.cpp b/libcxx/test/containers/sequences/list/db_iterators_7.pass.cpp
index 0d61b238ff8..57bb317a9a9 100644
--- a/libcxx/test/containers/sequences/list/db_iterators_7.pass.cpp
+++ b/libcxx/test/containers/sequences/list/db_iterators_7.pass.cpp
@@ -21,8 +21,11 @@
 #include <exception>
 #include <cstdlib>
 
+#include "../../min_allocator.h"
+
 int main()
 {
+    {
     typedef int T;
     typedef std::list<T> C;
     C c(1);
@@ -31,6 +34,19 @@ int main()
     assert(i == c.end());
     ++i;
     assert(false);
+    }
+#if __cplusplus >= 201103L
+    {
+    typedef int T;
+    typedef std::list<T, min_allocator<T>> C;
+    C c(1);
+    C::iterator i = c.begin();
+    ++i;
+    assert(i == c.end());
+    ++i;
+    assert(false);
+    }
+#endif
 }
 
 #else
diff --git a/libcxx/test/containers/sequences/list/db_iterators_8.pass.cpp b/libcxx/test/containers/sequences/list/db_iterators_8.pass.cpp
index b05c3abcf90..9b09b77647a 100644
--- a/libcxx/test/containers/sequences/list/db_iterators_8.pass.cpp
+++ b/libcxx/test/containers/sequences/list/db_iterators_8.pass.cpp
@@ -21,14 +21,28 @@
 #include <exception>
 #include <cstdlib>
 
+#include "../../min_allocator.h"
+
 int main()
 {
+    {
     typedef int T;
     typedef std::list<T> C;
     C c(1);
     C::iterator i = c.end();
     T j = *i;
     assert(false);
+    }
+#if __cplusplus >= 201103L
+    {
+    typedef int T;
+    typedef std::list<T, min_allocator<T>> C;
+    C c(1);
+    C::iterator i = c.end();
+    T j = *i;
+    assert(false);
+    }
+#endif
 }
 
 #else
diff --git a/libcxx/test/containers/sequences/list/iterators.pass.cpp b/libcxx/test/containers/sequences/list/iterators.pass.cpp
index a53e977df9c..94e4200094a 100644
--- a/libcxx/test/containers/sequences/list/iterators.pass.cpp
+++ b/libcxx/test/containers/sequences/list/iterators.pass.cpp
@@ -20,6 +20,14 @@
 #include <cassert>
 #include <iterator>
 
+#include "../../min_allocator.h"
+
+struct A
+{
+    int first;
+    int second;
+};
+
 int main()
 {
     {
@@ -69,4 +77,62 @@ int main()
         C::iterator i;
         C::const_iterator j;
     }
+#if __cplusplus >= 201103L
+    {
+        typedef int T;
+        typedef std::list<T, min_allocator<T>> C;
+        C c;
+        C::iterator i = c.begin();
+        C::iterator j = c.end();
+        assert(std::distance(i, j) == 0);
+        assert(i == j);
+    }
+    {
+        typedef int T;
+        typedef std::list<T, min_allocator<T>> C;
+        const C c;
+        C::const_iterator i = c.begin();
+        C::const_iterator j = c.end();
+        assert(std::distance(i, j) == 0);
+        assert(i == j);
+    }
+    {
+        typedef int T;
+        typedef std::list<T, min_allocator<T>> C;
+        C c;
+        C::const_iterator i = c.cbegin();
+        C::const_iterator j = c.cend();
+        assert(std::distance(i, j) == 0);
+        assert(i == j);
+        assert(i == c.end());
+    }
+    {
+        typedef int T;
+        typedef std::list<T, min_allocator<T>> C;
+        const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+        C c(std::begin(t), std::end(t));
+        C::iterator i = c.begin();
+        assert(*i == 0);
+        ++i;
+        assert(*i == 1);
+        *i = 10;
+        assert(*i == 10);
+        assert(std::distance(c.begin(), c.end()) == 10);
+    }
+    {
+        typedef int T;
+        typedef std::list<T, min_allocator<T>> C;
+        C::iterator i;
+        C::const_iterator j;
+    }
+    {
+        typedef A T;
+        typedef std::list<T, min_allocator<T>> C;
+        C c = {A{1, 2}};
+        C::iterator i = c.begin();
+        i->first = 3;
+        C::const_iterator j = i;
+        assert(j->first == 3);
+    }
+#endif
 }
diff --git a/libcxx/test/containers/sequences/list/list.capacity/resize_size.pass.cpp b/libcxx/test/containers/sequences/list/list.capacity/resize_size.pass.cpp
index 93fc26c4532..d5135eef8c7 100644
--- a/libcxx/test/containers/sequences/list/list.capacity/resize_size.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.capacity/resize_size.pass.cpp
@@ -14,6 +14,7 @@
 #include <list>
 #include <cassert>
 #include "../../../DefaultOnly.h"
+#include "../../../min_allocator.h"
 
 int main()
 {
@@ -46,4 +47,35 @@ int main()
         assert(std::distance(l.begin(), l.end()) == 20);
     }
 #endif  // __LIBCPP_MOVE
+#if __cplusplus >= 201103L
+    {
+        std::list<int, min_allocator<int>> l(5, 2);
+        l.resize(2);
+        assert(l.size() == 2);
+        assert(std::distance(l.begin(), l.end()) == 2);
+        assert((l == std::list<int, min_allocator<int>>(2, 2)));
+    }
+    {
+        std::list<int, min_allocator<int>> l(5, 2);
+        l.resize(10);
+        assert(l.size() == 10);
+        assert(std::distance(l.begin(), l.end()) == 10);
+        assert(l.front() == 2);
+        assert(l.back() == 0);
+    }
+#ifdef __LIBCPP_MOVE
+    {
+        std::list<DefaultOnly, min_allocator<DefaultOnly>> l(10);
+        l.resize(5);
+        assert(l.size() == 5);
+        assert(std::distance(l.begin(), l.end()) == 5);
+    }
+    {
+        std::list<DefaultOnly, min_allocator<DefaultOnly>> l(10);
+        l.resize(20);
+        assert(l.size() == 20);
+        assert(std::distance(l.begin(), l.end()) == 20);
+    }
+#endif  // __LIBCPP_MOVE
+#endif
 }
diff --git a/libcxx/test/containers/sequences/list/list.capacity/resize_size_value.pass.cpp b/libcxx/test/containers/sequences/list/list.capacity/resize_size_value.pass.cpp
index 1779d466aa2..dbe2c3f66e1 100644
--- a/libcxx/test/containers/sequences/list/list.capacity/resize_size_value.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.capacity/resize_size_value.pass.cpp
@@ -14,6 +14,7 @@
 #include <list>
 #include <cassert>
 #include "../../../DefaultOnly.h"
+#include "../../../min_allocator.h"
 
 int main()
 {
@@ -32,4 +33,21 @@ int main()
         assert(l.front() == 2);
         assert(l.back() == 3.5);
     }
+#if __cplusplus >= 201103L
+    {
+        std::list<double, min_allocator<double>> l(5, 2);
+        l.resize(2, 3.5);
+        assert(l.size() == 2);
+        assert(std::distance(l.begin(), l.end()) == 2);
+        assert((l == std::list<double, min_allocator<double>>(2, 2)));
+    }
+    {
+        std::list<double, min_allocator<double>> l(5, 2);
+        l.resize(10, 3.5);
+        assert(l.size() == 10);
+        assert(std::distance(l.begin(), l.end()) == 10);
+        assert(l.front() == 2);
+        assert(l.back() == 3.5);
+    }
+#endif
 }
diff --git a/libcxx/test/containers/sequences/list/list.cons/assign_copy.pass.cpp b/libcxx/test/containers/sequences/list/list.cons/assign_copy.pass.cpp
index 3233e3ec5ff..422436ad05c 100644
--- a/libcxx/test/containers/sequences/list/list.cons/assign_copy.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.cons/assign_copy.pass.cpp
@@ -14,6 +14,7 @@
 #include <list>
 #include <cassert>
 #include "../../../test_allocator.h"
+#include "../../../min_allocator.h"
 
 int main()
 {
@@ -31,4 +32,13 @@ int main()
         assert(l2 == l);
         assert(l2.get_allocator() == other_allocator<int>(5));
     }
+#if __cplusplus >= 201103L
+    {
+        std::list<int, min_allocator<int> > l(3, 2, min_allocator<int>());
+        std::list<int, min_allocator<int> > l2(l, min_allocator<int>());
+        l2 = l;
+        assert(l2 == l);
+        assert(l2.get_allocator() == min_allocator<int>());
+    }
+#endif
 }
diff --git a/libcxx/test/containers/sequences/list/list.cons/assign_initializer_list.pass.cpp b/libcxx/test/containers/sequences/list/list.cons/assign_initializer_list.pass.cpp
index 9721ad2b188..e438f4062de 100644
--- a/libcxx/test/containers/sequences/list/list.cons/assign_initializer_list.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.cons/assign_initializer_list.pass.cpp
@@ -14,9 +14,12 @@
 #include <list>
 #include <cassert>
 
+#include "../../../min_allocator.h"
+
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+    {
     std::list<int> d;
     d.assign({3, 4, 5, 6});
     assert(d.size() == 4);
@@ -25,5 +28,18 @@ int main()
     assert(*i++ == 4);
     assert(*i++ == 5);
     assert(*i++ == 6);
+    }
+#if __cplusplus >= 201103L
+    {
+    std::list<int, min_allocator<int>> d;
+    d.assign({3, 4, 5, 6});
+    assert(d.size() == 4);
+    std::list<int, min_allocator<int>>::iterator i = d.begin();
+    assert(*i++ == 3);
+    assert(*i++ == 4);
+    assert(*i++ == 5);
+    assert(*i++ == 6);
+    }
+#endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }
diff --git a/libcxx/test/containers/sequences/list/list.cons/assign_move.pass.cpp b/libcxx/test/containers/sequences/list/list.cons/assign_move.pass.cpp
index beeacb534bd..da788dd7ee5 100644
--- a/libcxx/test/containers/sequences/list/list.cons/assign_move.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.cons/assign_move.pass.cpp
@@ -15,6 +15,7 @@
 #include <cassert>
 #include "../../../MoveOnly.h"
 #include "../../../test_allocator.h"
+#include "../../../min_allocator.h"
 
 int main()
 {
@@ -61,5 +62,21 @@ int main()
         assert(l.empty());
         assert(l2.get_allocator() == lo.get_allocator());
     }
+#if __cplusplus >= 201103L
+    {
+        std::list<MoveOnly, min_allocator<MoveOnly> > l(min_allocator<MoveOnly>{});
+        std::list<MoveOnly, min_allocator<MoveOnly> > lo(min_allocator<MoveOnly>{});
+        for (int i = 1; i <= 3; ++i)
+        {
+            l.push_back(i);
+            lo.push_back(i);
+        }
+        std::list<MoveOnly, min_allocator<MoveOnly> > l2(min_allocator<MoveOnly>{});
+        l2 = std::move(l);
+        assert(l2 == lo);
+        assert(l.empty());
+        assert(l2.get_allocator() == lo.get_allocator());
+    }
+#endif
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/libcxx/test/containers/sequences/list/list.cons/copy.pass.cpp b/libcxx/test/containers/sequences/list/list.cons/copy.pass.cpp
index 5fea3f52dcc..b490ebaf8bf 100644
--- a/libcxx/test/containers/sequences/list/list.cons/copy.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.cons/copy.pass.cpp
@@ -15,6 +15,7 @@
 #include <cassert>
 #include "../../../DefaultOnly.h"
 #include "../../../test_allocator.h"
+#include "../../../min_allocator.h"
 
 int main()
 {
@@ -37,4 +38,17 @@ int main()
         assert(l2.get_allocator() == other_allocator<int>(-2));
     }
 #endif  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
+#if __cplusplus >= 201103L
+    {
+        std::list<int, min_allocator<int>> l(3, 2);
+        std::list<int, min_allocator<int>> l2 = l;
+        assert(l2 == l);
+    }
+    {
+        std::list<int, min_allocator<int> > l(3, 2, min_allocator<int>());
+        std::list<int, min_allocator<int> > l2 = l;
+        assert(l2 == l);
+        assert(l2.get_allocator() == l.get_allocator());
+    }
+#endif
 }
diff --git a/libcxx/test/containers/sequences/list/list.cons/copy_alloc.pass.cpp b/libcxx/test/containers/sequences/list/list.cons/copy_alloc.pass.cpp
index 453c4b580b3..30eb9ff38f2 100644
--- a/libcxx/test/containers/sequences/list/list.cons/copy_alloc.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.cons/copy_alloc.pass.cpp
@@ -15,6 +15,7 @@
 #include <cassert>
 #include "../../../DefaultOnly.h"
 #include "../../../test_allocator.h"
+#include "../../../min_allocator.h"
 
 int main()
 {
@@ -30,4 +31,12 @@ int main()
         assert(l2 == l);
         assert(l2.get_allocator() == other_allocator<int>(3));
     }
+#if __cplusplus >= 201103L
+    {
+        std::list<int, min_allocator<int> > l(3, 2, min_allocator<int>());
+        std::list<int, min_allocator<int> > l2(l, min_allocator<int>());
+        assert(l2 == l);
+        assert(l2.get_allocator() == min_allocator<int>());
+    }
+#endif
 }
diff --git a/libcxx/test/containers/sequences/list/list.cons/default.pass.cpp b/libcxx/test/containers/sequences/list/list.cons/default.pass.cpp
index 97eedf44d0d..a6e193c2ea8 100644
--- a/libcxx/test/containers/sequences/list/list.cons/default.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.cons/default.pass.cpp
@@ -14,6 +14,7 @@
 #include <list>
 #include <cassert>
 #include "../../../DefaultOnly.h"
+#include "../../../min_allocator.h"
 
 int main()
 {
@@ -32,4 +33,21 @@ int main()
         assert(l.size() == 0);
         assert(std::distance(l.begin(), l.end()) == 0);
     }
+#if __cplusplus >= 201103L
+    {
+        std::list<int, min_allocator<int>> l;
+        assert(l.size() == 0);
+        assert(std::distance(l.begin(), l.end()) == 0);
+    }
+    {
+        std::list<DefaultOnly, min_allocator<DefaultOnly>> l;
+        assert(l.size() == 0);
+        assert(std::distance(l.begin(), l.end()) == 0);
+    }
+    {
+        std::list<int, min_allocator<int>> l((min_allocator<int>()));
+        assert(l.size() == 0);
+        assert(std::distance(l.begin(), l.end()) == 0);
+    }
+#endif
 }
diff --git a/libcxx/test/containers/sequences/list/list.cons/default_stack_alloc.pass.cpp b/libcxx/test/containers/sequences/list/list.cons/default_stack_alloc.pass.cpp
index 29b893601db..ef42e522fb3 100644
--- a/libcxx/test/containers/sequences/list/list.cons/default_stack_alloc.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.cons/default_stack_alloc.pass.cpp
@@ -14,8 +14,7 @@
 #include <list>
 #include <cassert>
 #include "../../../stack_allocator.h"
-
-#include <iostream>
+#include "../../../min_allocator.h"
 
 int main()
 {
@@ -34,4 +33,16 @@ int main()
         assert(l.size() == 0);
         assert(std::distance(l.begin(), l.end()) == 0);
     }
+#if __cplusplus >= 201103L
+    {
+        std::list<int, min_allocator<int>> l;
+        assert(l.size() == 0);
+        assert(std::distance(l.begin(), l.end()) == 0);
+    }
+    {
+        std::list<int, min_allocator<int>> l((min_allocator<int>()));
+        assert(l.size() == 0);
+        assert(std::distance(l.begin(), l.end()) == 0);
+    }
+#endif
 }
diff --git a/libcxx/test/containers/sequences/list/list.cons/initializer_list.pass.cpp b/libcxx/test/containers/sequences/list/list.cons/initializer_list.pass.cpp
index d111a25ef3c..f862eedf392 100644
--- a/libcxx/test/containers/sequences/list/list.cons/initializer_list.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.cons/initializer_list.pass.cpp
@@ -14,9 +14,12 @@
 #include <list>
 #include <cassert>
 
+#include "../../../min_allocator.h"
+
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+    {
     std::list<int> d = {3, 4, 5, 6};
     assert(d.size() == 4);
     std::list<int>::iterator i = d.begin();
@@ -24,5 +27,17 @@ int main()
     assert(*i++ == 4);
     assert(*i++ == 5);
     assert(*i++ == 6);
+    }
+#if __cplusplus >= 201103L
+    {
+    std::list<int, min_allocator<int>> d = {3, 4, 5, 6};
+    assert(d.size() == 4);
+    std::list<int, min_allocator<int>>::iterator i = d.begin();
+    assert(*i++ == 3);
+    assert(*i++ == 4);
+    assert(*i++ == 5);
+    assert(*i++ == 6);
+    }
+#endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }
diff --git a/libcxx/test/containers/sequences/list/list.cons/initializer_list_alloc.pass.cpp b/libcxx/test/containers/sequences/list/list.cons/initializer_list_alloc.pass.cpp
index 7f302edbc82..649610abc0a 100644
--- a/libcxx/test/containers/sequences/list/list.cons/initializer_list_alloc.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.cons/initializer_list_alloc.pass.cpp
@@ -15,10 +15,12 @@
 #include <cassert>
 
 #include "../../../test_allocator.h"
+#include "../../../min_allocator.h"
 
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+    {
     std::list<int, test_allocator<int>> d({3, 4, 5, 6}, test_allocator<int>(3));
     assert(d.get_allocator() == test_allocator<int>(3));
     assert(d.size() == 4);
@@ -27,5 +29,18 @@ int main()
     assert(*i++ == 4);
     assert(*i++ == 5);
     assert(*i++ == 6);
+    }
+#if __cplusplus >= 201103L
+    {
+    std::list<int, min_allocator<int>> d({3, 4, 5, 6}, min_allocator<int>());
+    assert(d.get_allocator() == min_allocator<int>());
+    assert(d.size() == 4);
+    std::list<int, min_allocator<int>>::iterator i = d.begin();
+    assert(*i++ == 3);
+    assert(*i++ == 4);
+    assert(*i++ == 5);
+    assert(*i++ == 6);
+    }
+#endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }
diff --git a/libcxx/test/containers/sequences/list/list.cons/input_iterator.pass.cpp b/libcxx/test/containers/sequences/list/list.cons/input_iterator.pass.cpp
index 859f6bca6b4..b5d8dcba72a 100644
--- a/libcxx/test/containers/sequences/list/list.cons/input_iterator.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.cons/input_iterator.pass.cpp
@@ -16,6 +16,7 @@
 #include <cassert>
 #include "test_iterators.h"
 #include "../../../stack_allocator.h"
+#include "../../../min_allocator.h"
 
 int main()
 {
@@ -50,4 +51,27 @@ int main()
         for (std::list<int>::const_iterator i = l.begin(), e = l.end(); i != e; ++i, ++j)
             assert(*i == j);
     }
+#if __cplusplus >= 201103L
+    {
+        int a[] = {0, 1, 2, 3};
+        std::list<int, min_allocator<int>> l(input_iterator<const int*>(a),
+                         input_iterator<const int*>(a + sizeof(a)/sizeof(a[0])));
+        assert(l.size() == sizeof(a)/sizeof(a[0]));
+        assert(std::distance(l.begin(), l.end()) == sizeof(a)/sizeof(a[0]));
+        int j = 0;
+        for (std::list<int, min_allocator<int>>::const_iterator i = l.begin(), e = l.end(); i != e; ++i, ++j)
+            assert(*i == j);
+    }
+    {
+        int a[] = {0, 1, 2, 3};
+        std::list<int, min_allocator<int>> l(input_iterator<const int*>(a),
+                         input_iterator<const int*>(a + sizeof(a)/sizeof(a[0])),
+                         min_allocator<int>());
+        assert(l.size() == sizeof(a)/sizeof(a[0]));
+        assert(std::distance(l.begin(), l.end()) == sizeof(a)/sizeof(a[0]));
+        int j = 0;
+        for (std::list<int, min_allocator<int>>::const_iterator i = l.begin(), e = l.end(); i != e; ++i, ++j)
+            assert(*i == j);
+    }
+#endif
 }
diff --git a/libcxx/test/containers/sequences/list/list.cons/move.pass.cpp b/libcxx/test/containers/sequences/list/list.cons/move.pass.cpp
index 5e76cafe70d..3754202589a 100644
--- a/libcxx/test/containers/sequences/list/list.cons/move.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.cons/move.pass.cpp
@@ -15,6 +15,7 @@
 #include <cassert>
 #include "../../../MoveOnly.h"
 #include "../../../test_allocator.h"
+#include "../../../min_allocator.h"
 
 int main()
 {
@@ -45,5 +46,20 @@ int main()
         assert(l.empty());
         assert(l2.get_allocator() == lo.get_allocator());
     }
+#if __cplusplus >= 201103L
+    {
+        std::list<MoveOnly, min_allocator<MoveOnly> > l(min_allocator<MoveOnly>{});
+        std::list<MoveOnly, min_allocator<MoveOnly> > lo(min_allocator<MoveOnly>{});
+        for (int i = 1; i <= 3; ++i)
+        {
+            l.push_back(i);
+            lo.push_back(i);
+        }
+        std::list<MoveOnly, min_allocator<MoveOnly> > l2 = std::move(l);
+        assert(l2 == lo);
+        assert(l.empty());
+        assert(l2.get_allocator() == lo.get_allocator());
+    }
+#endif
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/libcxx/test/containers/sequences/list/list.cons/move_alloc.pass.cpp b/libcxx/test/containers/sequences/list/list.cons/move_alloc.pass.cpp
index 3206ea500a9..94711d4b1db 100644
--- a/libcxx/test/containers/sequences/list/list.cons/move_alloc.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.cons/move_alloc.pass.cpp
@@ -15,6 +15,7 @@
 #include <cassert>
 #include "../../../MoveOnly.h"
 #include "../../../test_allocator.h"
+#include "../../../min_allocator.h"
 
 int main()
 {
@@ -58,5 +59,20 @@ int main()
         assert(!l.empty());
         assert(l2.get_allocator() == other_allocator<MoveOnly>(4));
     }
+#if __cplusplus >= 201103L
+    {
+        std::list<MoveOnly, min_allocator<MoveOnly> > l(min_allocator<MoveOnly>{});
+        std::list<MoveOnly, min_allocator<MoveOnly> > lo(min_allocator<MoveOnly>{});
+        for (int i = 1; i <= 3; ++i)
+        {
+            l.push_back(i);
+            lo.push_back(i);
+        }
+        std::list<MoveOnly, min_allocator<MoveOnly> > l2(std::move(l), min_allocator<MoveOnly>());
+        assert(l2 == lo);
+        assert(l.empty());
+        assert(l2.get_allocator() == min_allocator<MoveOnly>());
+    }
+#endif
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/libcxx/test/containers/sequences/list/list.cons/op_equal_initializer_list.pass.cpp b/libcxx/test/containers/sequences/list/list.cons/op_equal_initializer_list.pass.cpp
index a744f0fe445..f090043844b 100644
--- a/libcxx/test/containers/sequences/list/list.cons/op_equal_initializer_list.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.cons/op_equal_initializer_list.pass.cpp
@@ -13,10 +13,12 @@
 
 #include <list>
 #include <cassert>
+#include "../../../min_allocator.h"
 
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+    {
     std::list<int> d;
     d = {3, 4, 5, 6};
     assert(d.size() == 4);
@@ -25,5 +27,18 @@ int main()
     assert(*i++ == 4);
     assert(*i++ == 5);
     assert(*i++ == 6);
+    }
+#if __cplusplus >= 201103L
+    {
+    std::list<int, min_allocator<int>> d;
+    d = {3, 4, 5, 6};
+    assert(d.size() == 4);
+    std::list<int, min_allocator<int>>::iterator i = d.begin();
+    assert(*i++ == 3);
+    assert(*i++ == 4);
+    assert(*i++ == 5);
+    assert(*i++ == 6);
+    }
+#endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }
diff --git a/libcxx/test/containers/sequences/list/list.cons/size_type.pass.cpp b/libcxx/test/containers/sequences/list/list.cons/size_type.pass.cpp
index f636a43d1f6..be17f06635f 100644
--- a/libcxx/test/containers/sequences/list/list.cons/size_type.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.cons/size_type.pass.cpp
@@ -15,6 +15,7 @@
 #include <cassert>
 #include "../../../DefaultOnly.h"
 #include "../../../stack_allocator.h"
+#include "../../../min_allocator.h"
 
 int main()
 {
@@ -47,4 +48,24 @@ int main()
         assert(std::distance(l.begin(), l.end()) == 3);
     }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#if __cplusplus >= 201103L
+    {
+        std::list<int, min_allocator<int>> l(3);
+        assert(l.size() == 3);
+        assert(std::distance(l.begin(), l.end()) == 3);
+        std::list<int, min_allocator<int>>::const_iterator i = l.begin();
+        assert(*i == 0);
+        ++i;
+        assert(*i == 0);
+        ++i;
+        assert(*i == 0);
+    }
+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    {
+        std::list<DefaultOnly, min_allocator<DefaultOnly>> l(3);
+        assert(l.size() == 3);
+        assert(std::distance(l.begin(), l.end()) == 3);
+    }
+#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 }
diff --git a/libcxx/test/containers/sequences/list/list.cons/size_value_alloc.pass.cpp b/libcxx/test/containers/sequences/list/list.cons/size_value_alloc.pass.cpp
index 212777cad45..89cdf0e1602 100644
--- a/libcxx/test/containers/sequences/list/list.cons/size_value_alloc.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.cons/size_value_alloc.pass.cpp
@@ -15,6 +15,7 @@
 #include <cassert>
 #include "../../../DefaultOnly.h"
 #include "../../../stack_allocator.h"
+#include "../../../min_allocator.h"
 
 int main()
 {
@@ -51,4 +52,28 @@ int main()
         ++i;
         assert(*i == 2);
     }
+#if __cplusplus >= 201103L
+    {
+        std::list<int, min_allocator<int>> l(3, 2);
+        assert(l.size() == 3);
+        assert(std::distance(l.begin(), l.end()) == 3);
+        std::list<int, min_allocator<int>>::const_iterator i = l.begin();
+        assert(*i == 2);
+        ++i;
+        assert(*i == 2);
+        ++i;
+        assert(*i == 2);
+    }
+    {
+        std::list<int, min_allocator<int>> l(3, 2, min_allocator<int>());
+        assert(l.size() == 3);
+        assert(std::distance(l.begin(), l.end()) == 3);
+        std::list<int, min_allocator<int>>::const_iterator i = l.begin();
+        assert(*i == 2);
+        ++i;
+        assert(*i == 2);
+        ++i;
+        assert(*i == 2);
+    }
+#endif
 }
diff --git a/libcxx/test/containers/sequences/list/list.modifiers/clear.pass.cpp b/libcxx/test/containers/sequences/list/list.modifiers/clear.pass.cpp
index e3b63a24081..5bfab6fe20c 100644
--- a/libcxx/test/containers/sequences/list/list.modifiers/clear.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.modifiers/clear.pass.cpp
@@ -14,10 +14,22 @@
 #include <list>
 #include <cassert>
 
+#include "../../../min_allocator.h"
+
 int main()
 {
+    {
     int a[] = {1, 2, 3};
     std::list<int> c(a, a+3);
     c.clear();
     assert(c.empty());
+    }
+#if __cplusplus >= 201103L
+    {
+    int a[] = {1, 2, 3};
+    std::list<int, min_allocator<int>> c(a, a+3);
+    c.clear();
+    assert(c.empty());
+    }
+#endif
 }
diff --git a/libcxx/test/containers/sequences/list/list.modifiers/emplace.pass.cpp b/libcxx/test/containers/sequences/list/list.modifiers/emplace.pass.cpp
index 218c42b8117..2347052ae3e 100644
--- a/libcxx/test/containers/sequences/list/list.modifiers/emplace.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.modifiers/emplace.pass.cpp
@@ -18,6 +18,8 @@
 #include <list>
 #include <cassert>
 
+#include "../../../min_allocator.h"
+
 class A
 {
     int i_;
@@ -36,6 +38,7 @@ public:
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    {
     std::list<A> c;
     c.emplace(c.cbegin(), 2, 3.5);
     assert(c.size() == 1);
@@ -47,7 +50,7 @@ int main()
     assert(c.front().getd() == 3.5);
     assert(c.back().geti() == 3);
     assert(c.back().getd() == 4.5);
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    }
 #if _LIBCPP_DEBUG2 >= 1
     {
         std::list<A> c1;
@@ -56,4 +59,30 @@ int main()
         assert(false);
     }
 #endif
+#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#if __cplusplus >= 201103L
+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    {
+    std::list<A, min_allocator<A>> c;
+    c.emplace(c.cbegin(), 2, 3.5);
+    assert(c.size() == 1);
+    assert(c.front().geti() == 2);
+    assert(c.front().getd() == 3.5);
+    c.emplace(c.cend(), 3, 4.5);
+    assert(c.size() == 2);
+    assert(c.front().geti() == 2);
+    assert(c.front().getd() == 3.5);
+    assert(c.back().geti() == 3);
+    assert(c.back().getd() == 4.5);
+    }
+#if _LIBCPP_DEBUG2 >= 1
+    {
+        std::list<A, min_allocator<A>> c1;
+        std::list<A, min_allocator<A>> c2;
+        std::list<A, min_allocator<A>>::iterator i = c1.emplace(c2.cbegin(), 2, 3.5);
+        assert(false);
+    }
+#endif
+#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 }
diff --git a/libcxx/test/containers/sequences/list/list.modifiers/emplace_back.pass.cpp b/libcxx/test/containers/sequences/list/list.modifiers/emplace_back.pass.cpp
index 2802fe54476..71bc671e23e 100644
--- a/libcxx/test/containers/sequences/list/list.modifiers/emplace_back.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.modifiers/emplace_back.pass.cpp
@@ -14,6 +14,8 @@
 #include <list>
 #include <cassert>
 
+#include "../../../min_allocator.h"
+
 class A
 {
     int i_;
@@ -32,6 +34,7 @@ public:
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    {
     std::list<A> c;
     c.emplace_back(2, 3.5);
     assert(c.size() == 1);
@@ -43,5 +46,21 @@ int main()
     assert(c.front().getd() == 3.5);
     assert(c.back().geti() == 3);
     assert(c.back().getd() == 4.5);
+    }
+#if __cplusplus >= 201103L
+    {
+    std::list<A, min_allocator<A>> c;
+    c.emplace_back(2, 3.5);
+    assert(c.size() == 1);
+    assert(c.front().geti() == 2);
+    assert(c.front().getd() == 3.5);
+    c.emplace_back(3, 4.5);
+    assert(c.size() == 2);
+    assert(c.front().geti() == 2);
+    assert(c.front().getd() == 3.5);
+    assert(c.back().geti() == 3);
+    assert(c.back().getd() == 4.5);
+    }
+#endif
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/libcxx/test/containers/sequences/list/list.modifiers/emplace_front.pass.cpp b/libcxx/test/containers/sequences/list/list.modifiers/emplace_front.pass.cpp
index 09fe68ce32c..2eee9da2deb 100644
--- a/libcxx/test/containers/sequences/list/list.modifiers/emplace_front.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.modifiers/emplace_front.pass.cpp
@@ -14,6 +14,8 @@
 #include <list>
 #include <cassert>
 
+#include "../../../min_allocator.h"
+
 class A
 {
     int i_;
@@ -32,6 +34,7 @@ public:
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    {
     std::list<A> c;
     c.emplace_front(2, 3.5);
     assert(c.size() == 1);
@@ -43,5 +46,21 @@ int main()
     assert(c.front().getd() == 4.5);
     assert(c.back().geti() == 2);
     assert(c.back().getd() == 3.5);
+    }
+#if __cplusplus >= 201103L
+    {
+    std::list<A, min_allocator<A>> c;
+    c.emplace_front(2, 3.5);
+    assert(c.size() == 1);
+    assert(c.front().geti() == 2);
+    assert(c.front().getd() == 3.5);
+    c.emplace_front(3, 4.5);
+    assert(c.size() == 2);
+    assert(c.front().geti() == 3);
+    assert(c.front().getd() == 4.5);
+    assert(c.back().geti() == 2);
+    assert(c.back().getd() == 3.5);
+    }
+#endif
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/libcxx/test/containers/sequences/list/list.modifiers/erase_iter.pass.cpp b/libcxx/test/containers/sequences/list/list.modifiers/erase_iter.pass.cpp
index deac04ba843..0c2e5a1ccee 100644
--- a/libcxx/test/containers/sequences/list/list.modifiers/erase_iter.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.modifiers/erase_iter.pass.cpp
@@ -14,8 +14,11 @@
 #include <list>
 #include <cassert>
 
+#include "../../../min_allocator.h"
+
 int main()
 {
+    {
     int a1[] = {1, 2, 3};
     std::list<int> l1(a1, a1+3);
     std::list<int>::const_iterator i = l1.begin();
@@ -35,4 +38,28 @@ int main()
     assert(j == l1.end());
     assert(l1.size() == 0);
     assert(distance(l1.begin(), l1.end()) == 0);
+    }
+#if __cplusplus >= 201103L
+    {
+    int a1[] = {1, 2, 3};
+    std::list<int, min_allocator<int>> l1(a1, a1+3);
+    std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+    ++i;
+    std::list<int, min_allocator<int>>::iterator j = l1.erase(i);
+    assert(l1.size() == 2);
+    assert(distance(l1.begin(), l1.end()) == 2);
+    assert(*j == 3);
+    assert(*l1.begin() == 1);
+    assert(*next(l1.begin()) == 3);
+    j = l1.erase(j);
+    assert(j == l1.end());
+    assert(l1.size() == 1);
+    assert(distance(l1.begin(), l1.end()) == 1);
+    assert(*l1.begin() == 1);
+    j = l1.erase(l1.begin());
+    assert(j == l1.end());
+    assert(l1.size() == 0);
+    assert(distance(l1.begin(), l1.end()) == 0);
+    }
+#endif
 }
diff --git a/libcxx/test/containers/sequences/list/list.modifiers/erase_iter_db1.pass.cpp b/libcxx/test/containers/sequences/list/list.modifiers/erase_iter_db1.pass.cpp
index 68ba20db676..1f4efbaa370 100644
--- a/libcxx/test/containers/sequences/list/list.modifiers/erase_iter_db1.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.modifiers/erase_iter_db1.pass.cpp
@@ -20,13 +20,26 @@
 #include <cstdlib>
 #include <exception>
 
+#include "../../../min_allocator.h"
+
 int main()
 {
+    {
     int a1[] = {1, 2, 3};
     std::list<int> l1(a1, a1+3);
     std::list<int>::const_iterator i = l1.end();
     l1.erase(i);
     assert(false);
+    }
+#if __cplusplus >= 201103L
+    {
+    int a1[] = {1, 2, 3};
+    std::list<int, min_allocator<int>> l1(a1, a1+3);
+    std::list<int, min_allocator<int>>::const_iterator i = l1.end();
+    l1.erase(i);
+    assert(false);
+    }
+#endif
 }
 
 #else
diff --git a/libcxx/test/containers/sequences/list/list.modifiers/erase_iter_db2.pass.cpp b/libcxx/test/containers/sequences/list/list.modifiers/erase_iter_db2.pass.cpp
index 8026878ccae..8f1397c03b7 100644
--- a/libcxx/test/containers/sequences/list/list.modifiers/erase_iter_db2.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.modifiers/erase_iter_db2.pass.cpp
@@ -20,14 +20,28 @@
 #include <cstdlib>
 #include <exception>
 
+#include "../../../min_allocator.h"
+
 int main()
 {
+    {
     int a1[] = {1, 2, 3};
     std::list<int> l1(a1, a1+3);
     std::list<int> l2(a1, a1+3);
     std::list<int>::const_iterator i = l2.begin();
     l1.erase(i);
     assert(false);
+    }
+#if __cplusplus >= 201103L
+    {
+    int a1[] = {1, 2, 3};
+    std::list<int, min_allocator<int>> l1(a1, a1+3);
+    std::list<int, min_allocator<int>> l2(a1, a1+3);
+    std::list<int, min_allocator<int>>::const_iterator i = l2.begin();
+    l1.erase(i);
+    assert(false);
+    }
+#endif
 }
 
 #else
diff --git a/libcxx/test/containers/sequences/list/list.modifiers/erase_iter_iter.pass.cpp b/libcxx/test/containers/sequences/list/list.modifiers/erase_iter_iter.pass.cpp
index a7c9a0d2f35..e1a6e5aef5d 100644
--- a/libcxx/test/containers/sequences/list/list.modifiers/erase_iter_iter.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.modifiers/erase_iter_iter.pass.cpp
@@ -14,6 +14,8 @@
 #include <list>
 #include <cassert>
 
+#include "../../../min_allocator.h"
+
 int main()
 {
     int a1[] = {1, 2, 3};
@@ -47,4 +49,36 @@ int main()
         assert(distance(l1.cbegin(), l1.cend()) == 0);
         assert(i == l1.begin());
     }
+#if __cplusplus >= 201103L
+    {
+        std::list<int, min_allocator<int>> l1(a1, a1+3);
+        std::list<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin(), l1.cbegin());
+        assert(l1.size() == 3);
+        assert(distance(l1.cbegin(), l1.cend()) == 3);
+        assert(i == l1.begin());
+    }
+    {
+        std::list<int, min_allocator<int>> l1(a1, a1+3);
+        std::list<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin(), next(l1.cbegin()));
+        assert(l1.size() == 2);
+        assert(distance(l1.cbegin(), l1.cend()) == 2);
+        assert(i == l1.begin());
+        assert((l1 == std::list<int, min_allocator<int>>(a1+1, a1+3)));
+    }
+    {
+        std::list<int, min_allocator<int>> l1(a1, a1+3);
+        std::list<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin(), next(l1.cbegin(), 2));
+        assert(l1.size() == 1);
+        assert(distance(l1.cbegin(), l1.cend()) == 1);
+        assert(i == l1.begin());
+        assert((l1 == std::list<int, min_allocator<int>>(a1+2, a1+3)));
+    }
+    {
+        std::list<int, min_allocator<int>> l1(a1, a1+3);
+        std::list<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin(), next(l1.cbegin(), 3));
+        assert(l1.size() == 0);
+        assert(distance(l1.cbegin(), l1.cend()) == 0);
+        assert(i == l1.begin());
+    }
+#endif
 }
diff --git a/libcxx/test/containers/sequences/list/list.modifiers/erase_iter_iter_db1.pass.cpp b/libcxx/test/containers/sequences/list/list.modifiers/erase_iter_iter_db1.pass.cpp
index d9d901dde0c..e4d5ca3c383 100644
--- a/libcxx/test/containers/sequences/list/list.modifiers/erase_iter_iter_db1.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.modifiers/erase_iter_iter_db1.pass.cpp
@@ -20,13 +20,26 @@
 #include <exception>
 #include <cstdlib>
 
+#include "../../../min_allocator.h"
+
 int main()
 {
+    {
     int a1[] = {1, 2, 3};
     std::list<int> l1(a1, a1+3);
     std::list<int> l2(a1, a1+3);
     std::list<int>::iterator i = l1.erase(l2.cbegin(), next(l1.cbegin()));
     assert(false);
+    }
+#if __cplusplus >= 201103L
+    {
+    int a1[] = {1, 2, 3};
+    std::list<int, min_allocator<int>> l1(a1, a1+3);
+    std::list<int, min_allocator<int>> l2(a1, a1+3);
+    std::list<int, min_allocator<int>>::iterator i = l1.erase(l2.cbegin(), next(l1.cbegin()));
+    assert(false);
+    }
+#endif
 }
 
 #else
diff --git a/libcxx/test/containers/sequences/list/list.modifiers/erase_iter_iter_db2.pass.cpp b/libcxx/test/containers/sequences/list/list.modifiers/erase_iter_iter_db2.pass.cpp
index dc9a0fead4e..09ce820627c 100644
--- a/libcxx/test/containers/sequences/list/list.modifiers/erase_iter_iter_db2.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.modifiers/erase_iter_iter_db2.pass.cpp
@@ -20,13 +20,26 @@
 #include <exception>
 #include <cstdlib>
 
+#include "../../../min_allocator.h"
+
 int main()
 {
+    {
     int a1[] = {1, 2, 3};
     std::list<int> l1(a1, a1+3);
     std::list<int> l2(a1, a1+3);
     std::list<int>::iterator i = l1.erase(l1.cbegin(), next(l2.cbegin()));
     assert(false);
+    }
+#if __cplusplus >= 201103L
+    {
+    int a1[] = {1, 2, 3};
+    std::list<int, min_allocator<int>> l1(a1, a1+3);
+    std::list<int, min_allocator<int>> l2(a1, a1+3);
+    std::list<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin(), next(l2.cbegin()));
+    assert(false);
+    }
+#endif
 }
 
 #else
diff --git a/libcxx/test/containers/sequences/list/list.modifiers/erase_iter_iter_db3.pass.cpp b/libcxx/test/containers/sequences/list/list.modifiers/erase_iter_iter_db3.pass.cpp
index acfc90ec798..b2d36f8acca 100644
--- a/libcxx/test/containers/sequences/list/list.modifiers/erase_iter_iter_db3.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.modifiers/erase_iter_iter_db3.pass.cpp
@@ -20,13 +20,26 @@
 #include <exception>
 #include <cstdlib>
 
+#include "../../../min_allocator.h"
+
 int main()
 {
+    {
     int a1[] = {1, 2, 3};
     std::list<int> l1(a1, a1+3);
     std::list<int> l2(a1, a1+3);
     std::list<int>::iterator i = l1.erase(l2.cbegin(), next(l2.cbegin()));
     assert(false);
+    }
+#if __cplusplus >= 201103L
+    {
+    int a1[] = {1, 2, 3};
+    std::list<int, min_allocator<int>> l1(a1, a1+3);
+    std::list<int, min_allocator<int>> l2(a1, a1+3);
+    std::list<int, min_allocator<int>>::iterator i = l1.erase(l2.cbegin(), next(l2.cbegin()));
+    assert(false);
+    }
+#endif
 }
 
 #else
diff --git a/libcxx/test/containers/sequences/list/list.modifiers/erase_iter_iter_db4.pass.cpp b/libcxx/test/containers/sequences/list/list.modifiers/erase_iter_iter_db4.pass.cpp
index bf69657b15c..f2ea2ae5f7e 100644
--- a/libcxx/test/containers/sequences/list/list.modifiers/erase_iter_iter_db4.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.modifiers/erase_iter_iter_db4.pass.cpp
@@ -20,12 +20,24 @@
 #include <exception>
 #include <cstdlib>
 
+#include "../../../min_allocator.h"
+
 int main()
 {
+    {
     int a1[] = {1, 2, 3};
     std::list<int> l1(a1, a1+3);
     std::list<int>::iterator i = l1.erase(next(l1.cbegin()), l1.cbegin());
     assert(false);
+    }
+#if __cplusplus >= 201103L
+    {
+    int a1[] = {1, 2, 3};
+    std::list<int, min_allocator<int>> l1(a1, a1+3);
+    std::list<int, min_allocator<int>>::iterator i = l1.erase(next(l1.cbegin()), l1.cbegin());
+    assert(false);
+    }
+#endif
 }
 
 #else
diff --git a/libcxx/test/containers/sequences/list/list.modifiers/insert_iter_initializer_list.pass.cpp b/libcxx/test/containers/sequences/list/list.modifiers/insert_iter_initializer_list.pass.cpp
index d82dbccf614..9afb506fea5 100644
--- a/libcxx/test/containers/sequences/list/list.modifiers/insert_iter_initializer_list.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.modifiers/insert_iter_initializer_list.pass.cpp
@@ -14,9 +14,12 @@
 #include <list>
 #include <cassert>
 
+#include "../../../min_allocator.h"
+
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+    {
     std::list<int> d(10, 1);
     std::list<int>::iterator i = d.insert(next(d.cbegin(), 2), {3, 4, 5, 6});
     assert(d.size() == 14);
@@ -36,5 +39,29 @@ int main()
     assert(*i++ == 1);
     assert(*i++ == 1);
     assert(*i++ == 1);
+    }
+#if __cplusplus >= 201103L
+    {
+    std::list<int, min_allocator<int>> d(10, 1);
+    std::list<int, min_allocator<int>>::iterator i = d.insert(next(d.cbegin(), 2), {3, 4, 5, 6});
+    assert(d.size() == 14);
+    assert(i == next(d.begin(), 2));
+    i = d.begin();
+    assert(*i++ == 1);
+    assert(*i++ == 1);
+    assert(*i++ == 3);
+    assert(*i++ == 4);
+    assert(*i++ == 5);
+    assert(*i++ == 6);
+    assert(*i++ == 1);
+    assert(*i++ == 1);
+    assert(*i++ == 1);
+    assert(*i++ == 1);
+    assert(*i++ == 1);
+    assert(*i++ == 1);
+    assert(*i++ == 1);
+    assert(*i++ == 1);
+    }
+#endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }
diff --git a/libcxx/test/containers/sequences/list/list.modifiers/insert_iter_iter_iter.pass.cpp b/libcxx/test/containers/sequences/list/list.modifiers/insert_iter_iter_iter.pass.cpp
index e8ea2a87997..1c5d2556966 100644
--- a/libcxx/test/containers/sequences/list/list.modifiers/insert_iter_iter_iter.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.modifiers/insert_iter_iter_iter.pass.cpp
@@ -20,6 +20,7 @@
 #include <cstdlib>
 #include <cassert>
 #include "test_iterators.h"
+#include "../../../min_allocator.h"
 
 int throw_next = 0xFFFF;
 int count = 0;
@@ -97,9 +98,9 @@ int main()
     ++i;
     assert(*i == 3);
     }
+    throw_next = 0xFFFF;
 #if _LIBCPP_DEBUG2 >= 1
     {
-        throw_next = 0xFFFF;
         std::list<int> v(100);
         std::list<int> v2(100);
         int a[] = {1, 2, 3, 4, 5};
@@ -109,4 +110,74 @@ int main()
         assert(false);
     }
 #endif
+#if __cplusplus >= 201103L
+    {
+    int a1[] = {1, 2, 3};
+    std::list<int, min_allocator<int>> l1;
+    std::list<int, min_allocator<int>>::iterator i = l1.insert(l1.begin(), a1, a1+3);
+    assert(i == l1.begin());
+    assert(l1.size() == 3);
+    assert(distance(l1.begin(), l1.end()) == 3);
+    i = l1.begin();
+    assert(*i == 1);
+    ++i;
+    assert(*i == 2);
+    ++i;
+    assert(*i == 3);
+    int a2[] = {4, 5, 6};
+    i = l1.insert(i, a2, a2+3);
+    assert(*i == 4);
+    assert(l1.size() == 6);
+    assert(distance(l1.begin(), l1.end()) == 6);
+    i = l1.begin();
+    assert(*i == 1);
+    ++i;
+    assert(*i == 2);
+    ++i;
+    assert(*i == 4);
+    ++i;
+    assert(*i == 5);
+    ++i;
+    assert(*i == 6);
+    ++i;
+    assert(*i == 3);
+    throw_next = 2;
+    int save_count = count;
+    try
+    {
+        i = l1.insert(i, a2, a2+3);
+        assert(false);
+    }
+    catch (...)
+    {
+    }
+    assert(save_count == count);
+    assert(l1.size() == 6);
+    assert(distance(l1.begin(), l1.end()) == 6);
+    i = l1.begin();
+    assert(*i == 1);
+    ++i;
+    assert(*i == 2);
+    ++i;
+    assert(*i == 4);
+    ++i;
+    assert(*i == 5);
+    ++i;
+    assert(*i == 6);
+    ++i;
+    assert(*i == 3);
+    }
+#if _LIBCPP_DEBUG2 >= 1
+    {
+        throw_next = 0xFFFF;
+        std::list<int, min_allocator<int>> v(100);
+        std::list<int, min_allocator<int>> v2(100);
+        int a[] = {1, 2, 3, 4, 5};
+        const int N = sizeof(a)/sizeof(a[0]);
+        std::list<int, min_allocator<int>>::iterator i = v.insert(next(v2.cbegin(), 10), input_iterator<const int*>(a),
+                                       input_iterator<const int*>(a+N));
+        assert(false);
+    }
+#endif
+#endif
 }
diff --git a/libcxx/test/containers/sequences/list/list.modifiers/insert_iter_rvalue.pass.cpp b/libcxx/test/containers/sequences/list/list.modifiers/insert_iter_rvalue.pass.cpp
index 3c352249c67..40554a48a12 100644
--- a/libcxx/test/containers/sequences/list/list.modifiers/insert_iter_rvalue.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.modifiers/insert_iter_rvalue.pass.cpp
@@ -19,10 +19,12 @@
 #include <cassert>
 
 #include "../../../MoveOnly.h"
+#include "../../../min_allocator.h"
 
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    {
     std::list<MoveOnly> l1;
     l1.insert(l1.cend(), MoveOnly(1));
     assert(l1.size() == 1);
@@ -31,6 +33,7 @@ int main()
     assert(l1.size() == 2);
     assert(l1.front() == MoveOnly(2));
     assert(l1.back() == MoveOnly(1));
+    }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 #if _LIBCPP_DEBUG2 >= 1
     {
@@ -40,4 +43,26 @@ int main()
         assert(false);
     }
 #endif
+#if __cplusplus >= 201103L
+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    {
+    std::list<MoveOnly, min_allocator<MoveOnly>> l1;
+    l1.insert(l1.cend(), MoveOnly(1));
+    assert(l1.size() == 1);
+    assert(l1.front() == MoveOnly(1));
+    l1.insert(l1.cbegin(), MoveOnly(2));
+    assert(l1.size() == 2);
+    assert(l1.front() == MoveOnly(2));
+    assert(l1.back() == MoveOnly(1));
+    }
+#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#if _LIBCPP_DEBUG2 >= 1
+    {
+        std::list<int, min_allocator<int>> v1(3);
+        std::list<int, min_allocator<int>> v2(3);
+        v1.insert(v2.begin(), 4);
+        assert(false);
+    }
+#endif
+#endif
 }
diff --git a/libcxx/test/containers/sequences/list/list.modifiers/insert_iter_size_value.pass.cpp b/libcxx/test/containers/sequences/list/list.modifiers/insert_iter_size_value.pass.cpp
index 9221a7fef44..3566d1922d3 100644
--- a/libcxx/test/containers/sequences/list/list.modifiers/insert_iter_size_value.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.modifiers/insert_iter_size_value.pass.cpp
@@ -19,6 +19,8 @@
 #include <cstdlib>
 #include <cassert>
 
+#include "../../../min_allocator.h"
+
 int throw_next = 0xFFFF;
 int count = 0;
 
@@ -39,6 +41,7 @@ void  operator delete(void* p) throw()
 
 int main()
 {
+    {
     int a1[] = {1, 2, 3};
     int a2[] = {1, 4, 4, 4, 4, 4, 2, 3};
     std::list<int> l1(a1, a1+3);
@@ -58,6 +61,7 @@ int main()
     throw_next = 0xFFFF;
     assert(save_count == count);
     assert(l1 == std::list<int>(a2, a2+8));
+    }
 #if _LIBCPP_DEBUG2 >= 1
     {
         std::list<int> c1(100);
@@ -66,4 +70,35 @@ int main()
         assert(false);
     }
 #endif
+#if __cplusplus >= 201103L
+    {
+    int a1[] = {1, 2, 3};
+    int a2[] = {1, 4, 4, 4, 4, 4, 2, 3};
+    std::list<int, min_allocator<int>> l1(a1, a1+3);
+    std::list<int, min_allocator<int>>::iterator i = l1.insert(next(l1.cbegin()), 5, 4);
+    assert(i == next(l1.begin()));
+    assert((l1 == std::list<int, min_allocator<int>>(a2, a2+8)));
+    throw_next = 4;
+    int save_count = count;
+    try
+    {
+        i = l1.insert(i, 5, 5);
+        assert(false);
+    }
+    catch (...)
+    {
+    }
+    throw_next = 0xFFFF;
+    assert(save_count == count);
+    assert((l1 == std::list<int, min_allocator<int>>(a2, a2+8)));
+    }
+#if _LIBCPP_DEBUG2 >= 1
+    {
+        std::list<int, min_allocator<int>> c1(100);
+        std::list<int, min_allocator<int>> c2;
+        std::list<int, min_allocator<int>>::iterator i = c1.insert(next(c2.cbegin(), 10), 5, 1);
+        assert(false);
+    }
+#endif
+#endif
 }
diff --git a/libcxx/test/containers/sequences/list/list.modifiers/insert_iter_value.pass.cpp b/libcxx/test/containers/sequences/list/list.modifiers/insert_iter_value.pass.cpp
index 6ea2a176aa4..50aac8b5af9 100644
--- a/libcxx/test/containers/sequences/list/list.modifiers/insert_iter_value.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.modifiers/insert_iter_value.pass.cpp
@@ -19,6 +19,8 @@
 #include <cstdlib>
 #include <cassert>
 
+#include "../../../min_allocator.h"
+
 int throw_next = 0xFFFF;
 int count = 0;
 
@@ -39,6 +41,7 @@ void  operator delete(void* p) throw()
 
 int main()
 {
+    {
     int a1[] = {1, 2, 3};
     int a2[] = {1, 4, 2, 3};
     std::list<int> l1(a1, a1+3);
@@ -60,6 +63,7 @@ int main()
     throw_next = 0xFFFF;
     assert(save_count == count);
     assert(l1 == std::list<int>(a2, a2+4));
+    }
 #if _LIBCPP_DEBUG2 >= 1
     {
         std::list<int> v1(3);
@@ -69,4 +73,38 @@ int main()
         assert(false);
     }
 #endif
+#if __cplusplus >= 201103L
+    {
+    int a1[] = {1, 2, 3};
+    int a2[] = {1, 4, 2, 3};
+    std::list<int, min_allocator<int>> l1(a1, a1+3);
+    std::list<int, min_allocator<int>>::iterator i = l1.insert(next(l1.cbegin()), 4);
+    assert(i == next(l1.begin()));
+    assert(l1.size() == 4);
+    assert(distance(l1.begin(), l1.end()) == 4);
+    assert((l1 == std::list<int, min_allocator<int>>(a2, a2+4)));
+    throw_next = 0;
+    int save_count = count;
+    try
+    {
+        i = l1.insert(i, 5);
+        assert(false);
+    }
+    catch (...)
+    {
+    }
+    throw_next = 0xFFFF;
+    assert(save_count == count);
+    assert((l1 == std::list<int, min_allocator<int>>(a2, a2+4)));
+    }
+#if _LIBCPP_DEBUG2 >= 1
+    {
+        std::list<int, min_allocator<int>> v1(3);
+        std::list<int, min_allocator<int>> v2(3);
+        int i = 4;
+        v1.insert(v2.begin(), i);
+        assert(false);
+    }
+#endif
+#endif
 }
diff --git a/libcxx/test/containers/sequences/list/list.modifiers/pop_back.pass.cpp b/libcxx/test/containers/sequences/list/list.modifiers/pop_back.pass.cpp
index 97105fd80db..d7e8b61d602 100644
--- a/libcxx/test/containers/sequences/list/list.modifiers/pop_back.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.modifiers/pop_back.pass.cpp
@@ -18,8 +18,11 @@
 #include <list>
 #include <cassert>
 
+#include "../../../min_allocator.h"
+
 int main()
 {
+    {
     int a[] = {1, 2, 3};
     std::list<int> c(a, a+3);
     c.pop_back();
@@ -32,4 +35,21 @@ int main()
         c.pop_back();
         assert(false);
 #endif        
+    }
+#if __cplusplus >= 201103L
+    {
+    int a[] = {1, 2, 3};
+    std::list<int, min_allocator<int>> c(a, a+3);
+    c.pop_back();
+    assert((c == std::list<int, min_allocator<int>>(a, a+2)));
+    c.pop_back();
+    assert((c == std::list<int, min_allocator<int>>(a, a+1)));
+    c.pop_back();
+    assert(c.empty());
+#if _LIBCPP_DEBUG2 >= 1
+        c.pop_back();
+        assert(false);
+#endif        
+    }
+#endif
 }
diff --git a/libcxx/test/containers/sequences/list/list.modifiers/pop_front.pass.cpp b/libcxx/test/containers/sequences/list/list.modifiers/pop_front.pass.cpp
index 77cb14581c0..cc1462cb422 100644
--- a/libcxx/test/containers/sequences/list/list.modifiers/pop_front.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.modifiers/pop_front.pass.cpp
@@ -14,8 +14,11 @@
 #include <list>
 #include <cassert>
 
+#include "../../../min_allocator.h"
+
 int main()
 {
+    {
     int a[] = {1, 2, 3};
     std::list<int> c(a, a+3);
     c.pop_front();
@@ -24,4 +27,17 @@ int main()
     assert(c == std::list<int>(a+2, a+3));
     c.pop_front();
     assert(c.empty());
+    }
+#if __cplusplus >= 201103L
+    {
+    int a[] = {1, 2, 3};
+    std::list<int, min_allocator<int>> c(a, a+3);
+    c.pop_front();
+    assert((c == std::list<int, min_allocator<int>>(a+1, a+3)));
+    c.pop_front();
+    assert((c == std::list<int, min_allocator<int>>(a+2, a+3)));
+    c.pop_front();
+    assert(c.empty());
+    }
+#endif
 }
diff --git a/libcxx/test/containers/sequences/list/list.modifiers/push_back.pass.cpp b/libcxx/test/containers/sequences/list/list.modifiers/push_back.pass.cpp
index 6e5f1af3bea..2022bb05a54 100644
--- a/libcxx/test/containers/sequences/list/list.modifiers/push_back.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.modifiers/push_back.pass.cpp
@@ -14,11 +14,24 @@
 #include <list>
 #include <cassert>
 
+#include "../../../min_allocator.h"
+
 int main()
 {
+    {
     std::list<int> c;
     for (int i = 0; i < 5; ++i)
         c.push_back(i);
     int a[] = {0, 1, 2, 3, 4};
     assert(c == std::list<int>(a, a+5));
+    }
+#if __cplusplus >= 201103L
+    {
+    std::list<int, min_allocator<int>> c;
+    for (int i = 0; i < 5; ++i)
+        c.push_back(i);
+    int a[] = {0, 1, 2, 3, 4};
+    assert((c == std::list<int, min_allocator<int>>(a, a+5)));
+    }
+#endif
 }
diff --git a/libcxx/test/containers/sequences/list/list.modifiers/push_back_rvalue.pass.cpp b/libcxx/test/containers/sequences/list/list.modifiers/push_back_rvalue.pass.cpp
index 846b56d0fde..3f0dddd4924 100644
--- a/libcxx/test/containers/sequences/list/list.modifiers/push_back_rvalue.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.modifiers/push_back_rvalue.pass.cpp
@@ -15,10 +15,12 @@
 #include <cassert>
 
 #include "../../../MoveOnly.h"
+#include "../../../min_allocator.h"
 
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    {
     std::list<MoveOnly> l1;
     l1.push_back(MoveOnly(1));
     assert(l1.size() == 1);
@@ -27,5 +29,18 @@ int main()
     assert(l1.size() == 2);
     assert(l1.front() == MoveOnly(1));
     assert(l1.back() == MoveOnly(2));
+    }
+#if __cplusplus >= 201103L
+    {
+    std::list<MoveOnly, min_allocator<MoveOnly>> l1;
+    l1.push_back(MoveOnly(1));
+    assert(l1.size() == 1);
+    assert(l1.front() == MoveOnly(1));
+    l1.push_back(MoveOnly(2));
+    assert(l1.size() == 2);
+    assert(l1.front() == MoveOnly(1));
+    assert(l1.back() == MoveOnly(2));
+    }
+#endif
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/libcxx/test/containers/sequences/list/list.modifiers/push_front.pass.cpp b/libcxx/test/containers/sequences/list/list.modifiers/push_front.pass.cpp
index 7061cb8f562..7042829eac6 100644
--- a/libcxx/test/containers/sequences/list/list.modifiers/push_front.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.modifiers/push_front.pass.cpp
@@ -14,11 +14,24 @@
 #include <list>
 #include <cassert>
 
+#include "../../../min_allocator.h"
+
 int main()
 {
+    {
     std::list<int> c;
     for (int i = 0; i < 5; ++i)
         c.push_front(i);
     int a[] = {4, 3, 2, 1, 0};
     assert(c == std::list<int>(a, a+5));
+    }
+#if __cplusplus >= 201103L
+    {
+    std::list<int, min_allocator<int>> c;
+    for (int i = 0; i < 5; ++i)
+        c.push_front(i);
+    int a[] = {4, 3, 2, 1, 0};
+    assert((c == std::list<int, min_allocator<int>>(a, a+5)));
+    }
+#endif
 }
diff --git a/libcxx/test/containers/sequences/list/list.modifiers/push_front_rvalue.pass.cpp b/libcxx/test/containers/sequences/list/list.modifiers/push_front_rvalue.pass.cpp
index 931501e61b5..e7976fa4cd5 100644
--- a/libcxx/test/containers/sequences/list/list.modifiers/push_front_rvalue.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.modifiers/push_front_rvalue.pass.cpp
@@ -15,10 +15,12 @@
 #include <cassert>
 
 #include "../../../MoveOnly.h"
+#include "../../../min_allocator.h"
 
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    {
     std::list<MoveOnly> l1;
     l1.push_front(MoveOnly(1));
     assert(l1.size() == 1);
@@ -27,5 +29,18 @@ int main()
     assert(l1.size() == 2);
     assert(l1.front() == MoveOnly(2));
     assert(l1.back() == MoveOnly(1));
+    }
+#if __cplusplus >= 201103L
+    {
+    std::list<MoveOnly, min_allocator<MoveOnly>> l1;
+    l1.push_front(MoveOnly(1));
+    assert(l1.size() == 1);
+    assert(l1.front() == MoveOnly(1));
+    l1.push_front(MoveOnly(2));
+    assert(l1.size() == 2);
+    assert(l1.front() == MoveOnly(2));
+    assert(l1.back() == MoveOnly(1));
+    }
+#endif
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/libcxx/test/containers/sequences/list/list.ops/merge.pass.cpp b/libcxx/test/containers/sequences/list/list.ops/merge.pass.cpp
index a20e1b5c136..9b8d2ad2389 100644
--- a/libcxx/test/containers/sequences/list/list.ops/merge.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.ops/merge.pass.cpp
@@ -14,8 +14,11 @@
 #include <list>
 #include <cassert>
 
+#include "../../../min_allocator.h"
+
 int main()
 {
+    {
     int a1[] = {1, 3, 7, 9, 10};
     int a2[] = {0, 2, 4, 5, 6, 8, 11};
     int a3[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
@@ -23,4 +26,16 @@ int main()
     std::list<int> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
     c1.merge(c2);
     assert(c1 == std::list<int>(a3, a3+sizeof(a3)/sizeof(a3[0])));
+    }
+#if __cplusplus >= 201103L
+    {
+    int a1[] = {1, 3, 7, 9, 10};
+    int a2[] = {0, 2, 4, 5, 6, 8, 11};
+    int a3[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
+    std::list<int, min_allocator<int>> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
+    std::list<int, min_allocator<int>> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
+    c1.merge(c2);
+    assert((c1 == std::list<int, min_allocator<int>>(a3, a3+sizeof(a3)/sizeof(a3[0]))));
+    }
+#endif
 }
diff --git a/libcxx/test/containers/sequences/list/list.ops/merge_comp.pass.cpp b/libcxx/test/containers/sequences/list/list.ops/merge_comp.pass.cpp
index 141988bd6a1..b09e2dcdbc5 100644
--- a/libcxx/test/containers/sequences/list/list.ops/merge_comp.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.ops/merge_comp.pass.cpp
@@ -15,8 +15,11 @@
 #include <functional>
 #include <cassert>
 
+#include "../../../min_allocator.h"
+
 int main()
 {
+    {
     int a1[] = {10, 9, 7, 3, 1};
     int a2[] = {11, 8, 6, 5, 4, 2, 0};
     int a3[] = {11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
@@ -24,4 +27,16 @@ int main()
     std::list<int> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
     c1.merge(c2, std::greater<int>());
     assert(c1 == std::list<int>(a3, a3+sizeof(a3)/sizeof(a3[0])));
+    }
+#if __cplusplus >= 201103L
+    {
+    int a1[] = {10, 9, 7, 3, 1};
+    int a2[] = {11, 8, 6, 5, 4, 2, 0};
+    int a3[] = {11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
+    std::list<int, min_allocator<int>> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
+    std::list<int, min_allocator<int>> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
+    c1.merge(c2, std::greater<int>());
+    assert((c1 == std::list<int, min_allocator<int>>(a3, a3+sizeof(a3)/sizeof(a3[0]))));
+    }
+#endif
 }
diff --git a/libcxx/test/containers/sequences/list/list.ops/remove.pass.cpp b/libcxx/test/containers/sequences/list/list.ops/remove.pass.cpp
index 0af405c1f44..f17dfc8ded6 100644
--- a/libcxx/test/containers/sequences/list/list.ops/remove.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.ops/remove.pass.cpp
@@ -14,11 +14,24 @@
 #include <list>
 #include <cassert>
 
+#include "../../../min_allocator.h"
+
 int main()
 {
+    {
     int a1[] = {1, 2, 3, 4};
     int a2[] = {1, 2, 4};
     std::list<int> c(a1, a1+4);
     c.remove(3);
     assert(c == std::list<int>(a2, a2+3));
+    }
+#if __cplusplus >= 201103L
+    {
+    int a1[] = {1, 2, 3, 4};
+    int a2[] = {1, 2, 4};
+    std::list<int, min_allocator<int>> c(a1, a1+4);
+    c.remove(3);
+    assert((c == std::list<int, min_allocator<int>>(a2, a2+3)));
+    }
+#endif
 }
diff --git a/libcxx/test/containers/sequences/list/list.ops/remove_if.pass.cpp b/libcxx/test/containers/sequences/list/list.ops/remove_if.pass.cpp
index 1b56ea757dd..e6366072ae6 100644
--- a/libcxx/test/containers/sequences/list/list.ops/remove_if.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.ops/remove_if.pass.cpp
@@ -15,6 +15,8 @@
 #include <cassert>
 #include <functional>
 
+#include "../../../min_allocator.h"
+
 bool g(int i)
 {
     return i < 3;
@@ -22,9 +24,20 @@ bool g(int i)
 
 int main()
 {
+    {
     int a1[] = {1, 2, 3, 4};
     int a2[] = {3, 4};
     std::list<int> c(a1, a1+4);
     c.remove_if(g);
     assert(c == std::list<int>(a2, a2+2));
+    }
+#if __cplusplus >= 201103L
+    {
+    int a1[] = {1, 2, 3, 4};
+    int a2[] = {3, 4};
+    std::list<int, min_allocator<int>> c(a1, a1+4);
+    c.remove_if(g);
+    assert((c == std::list<int, min_allocator<int>>(a2, a2+2)));
+    }
+#endif
 }
diff --git a/libcxx/test/containers/sequences/list/list.ops/reverse.pass.cpp b/libcxx/test/containers/sequences/list/list.ops/reverse.pass.cpp
index b8d1684c04d..3eafeee6e2b 100644
--- a/libcxx/test/containers/sequences/list/list.ops/reverse.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.ops/reverse.pass.cpp
@@ -14,11 +14,24 @@
 #include <list>
 #include <cassert>
 
+#include "../../../min_allocator.h"
+
 int main()
 {
+    {
     int a1[] = {11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
     int a2[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
     std::list<int> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
     c1.reverse();
     assert(c1 == std::list<int>(a2, a2+sizeof(a2)/sizeof(a2[0])));
+    }
+#if __cplusplus >= 201103L
+    {
+    int a1[] = {11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
+    int a2[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
+    std::list<int, min_allocator<int>> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
+    c1.reverse();
+    assert((c1 == std::list<int, min_allocator<int>>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
+    }
+#endif
 }
diff --git a/libcxx/test/containers/sequences/list/list.ops/sort.pass.cpp b/libcxx/test/containers/sequences/list/list.ops/sort.pass.cpp
index 887cb543ea6..a79f0a69ba2 100644
--- a/libcxx/test/containers/sequences/list/list.ops/sort.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.ops/sort.pass.cpp
@@ -14,11 +14,24 @@
 #include <list>
 #include <cassert>
 
+#include "../../../min_allocator.h"
+
 int main()
 {
+    {
     int a1[] = {4, 8, 1, 0, 5, 7, 2, 3, 6, 11, 10, 9};
     int a2[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
     std::list<int> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
     c1.sort();
     assert(c1 == std::list<int>(a2, a2+sizeof(a2)/sizeof(a2[0])));
+    }
+#if __cplusplus >= 201103L
+    {
+    int a1[] = {4, 8, 1, 0, 5, 7, 2, 3, 6, 11, 10, 9};
+    int a2[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
+    std::list<int, min_allocator<int>> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
+    c1.sort();
+    assert((c1 == std::list<int, min_allocator<int>>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
+    }
+#endif
 }
diff --git a/libcxx/test/containers/sequences/list/list.ops/sort_comp.pass.cpp b/libcxx/test/containers/sequences/list/list.ops/sort_comp.pass.cpp
index d080522d499..c107e1fb9b4 100644
--- a/libcxx/test/containers/sequences/list/list.ops/sort_comp.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.ops/sort_comp.pass.cpp
@@ -15,11 +15,24 @@
 #include <functional>
 #include <cassert>
 
+#include "../../../min_allocator.h"
+
 int main()
 {
+    {
     int a1[] = {4, 8, 1, 0, 5, 7, 2, 3, 6, 11, 10, 9};
     int a2[] = {11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
     std::list<int> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
     c1.sort(std::greater<int>());
     assert(c1 == std::list<int>(a2, a2+sizeof(a2)/sizeof(a2[0])));
+    }
+#if __cplusplus >= 201103L
+    {
+    int a1[] = {4, 8, 1, 0, 5, 7, 2, 3, 6, 11, 10, 9};
+    int a2[] = {11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
+    std::list<int, min_allocator<int>> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
+    c1.sort(std::greater<int>());
+    assert((c1 == std::list<int, min_allocator<int>>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
+    }
+#endif
 }
diff --git a/libcxx/test/containers/sequences/list/list.ops/splice_pos_list.pass.cpp b/libcxx/test/containers/sequences/list/list.ops/splice_pos_list.pass.cpp
index 26d191216c7..dee246dee58 100644
--- a/libcxx/test/containers/sequences/list/list.ops/splice_pos_list.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.ops/splice_pos_list.pass.cpp
@@ -18,6 +18,8 @@
 #include <list>
 #include <cassert>
 
+#include "../../../min_allocator.h"
+
 int main()
 {
     int a1[] = {1, 2, 3};
@@ -409,4 +411,393 @@ int main()
         assert(false);
     }
 #endif
+#if __cplusplus >= 201103L
+    {
+        std::list<int, min_allocator<int>> l1;
+        std::list<int, min_allocator<int>> l2;
+        l1.splice(l1.end(), l2);
+        assert(l1.size() == 0);
+        assert(distance(l1.begin(), l1.end()) == 0);
+        assert(l2.size() == 0);
+        assert(distance(l2.begin(), l2.end()) == 0);
+    }
+    {
+        std::list<int, min_allocator<int>> l1;
+        std::list<int, min_allocator<int>> l2(a2, a2+1);
+        l1.splice(l1.end(), l2);
+        assert(l1.size() == 1);
+        assert(distance(l1.begin(), l1.end()) == 1);
+        assert(l2.size() == 0);
+        assert(distance(l2.begin(), l2.end()) == 0);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 4);
+    }
+    {
+        std::list<int, min_allocator<int>> l1;
+        std::list<int, min_allocator<int>> l2(a2, a2+2);
+        l1.splice(l1.end(), l2);
+        assert(l1.size() == 2);
+        assert(distance(l1.begin(), l1.end()) == 2);
+        assert(l2.size() == 0);
+        assert(distance(l2.begin(), l2.end()) == 0);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 4);
+        ++i;
+        assert(*i == 5);
+    }
+    {
+        std::list<int, min_allocator<int>> l1;
+        std::list<int, min_allocator<int>> l2(a2, a2+3);
+        l1.splice(l1.end(), l2);
+        assert(l1.size() == 3);
+        assert(distance(l1.begin(), l1.end()) == 3);
+        assert(l2.size() == 0);
+        assert(distance(l2.begin(), l2.end()) == 0);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 4);
+        ++i;
+        assert(*i == 5);
+        ++i;
+        assert(*i == 6);
+    }
+    {
+        std::list<int, min_allocator<int>> l1(a1, a1+1);
+        std::list<int, min_allocator<int>> l2;
+        l1.splice(l1.begin(), l2);
+        assert(l1.size() == 1);
+        assert(distance(l1.begin(), l1.end()) == 1);
+        assert(l2.size() == 0);
+        assert(distance(l2.begin(), l2.end()) == 0);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 1);
+    }
+    {
+        std::list<int, min_allocator<int>> l1(a1, a1+1);
+        std::list<int, min_allocator<int>> l2;
+        l1.splice(l1.end(), l2);
+        assert(l1.size() == 1);
+        assert(distance(l1.begin(), l1.end()) == 1);
+        assert(l2.size() == 0);
+        assert(distance(l2.begin(), l2.end()) == 0);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 1);
+    }
+    {
+        std::list<int, min_allocator<int>> l1(a1, a1+1);
+        std::list<int, min_allocator<int>> l2(a2, a2+1);
+        l1.splice(l1.begin(), l2);
+        assert(l1.size() == 2);
+        assert(distance(l1.begin(), l1.end()) == 2);
+        assert(l2.size() == 0);
+        assert(distance(l2.begin(), l2.end()) == 0);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 4);
+        ++i;
+        assert(*i == 1);
+    }
+    {
+        std::list<int, min_allocator<int>> l1(a1, a1+1);
+        std::list<int, min_allocator<int>> l2(a2, a2+1);
+        l1.splice(l1.end(), l2);
+        assert(l1.size() == 2);
+        assert(distance(l1.begin(), l1.end()) == 2);
+        assert(l2.size() == 0);
+        assert(distance(l2.begin(), l2.end()) == 0);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 1);
+        ++i;
+        assert(*i == 4);
+    }
+    {
+        std::list<int, min_allocator<int>> l1(a1, a1+1);
+        std::list<int, min_allocator<int>> l2(a2, a2+2);
+        l1.splice(l1.begin(), l2);
+        assert(l1.size() == 3);
+        assert(distance(l1.begin(), l1.end()) == 3);
+        assert(l2.size() == 0);
+        assert(distance(l2.begin(), l2.end()) == 0);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 4);
+        ++i;
+        assert(*i == 5);
+        ++i;
+        assert(*i == 1);
+    }
+    {
+        std::list<int, min_allocator<int>> l1(a1, a1+1);
+        std::list<int, min_allocator<int>> l2(a2, a2+2);
+        l1.splice(l1.end(), l2);
+        assert(l1.size() == 3);
+        assert(distance(l1.begin(), l1.end()) == 3);
+        assert(l2.size() == 0);
+        assert(distance(l2.begin(), l2.end()) == 0);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 1);
+        ++i;
+        assert(*i == 4);
+        ++i;
+        assert(*i == 5);
+    }
+    {
+        std::list<int, min_allocator<int>> l1(a1, a1+1);
+        std::list<int, min_allocator<int>> l2(a2, a2+3);
+        l1.splice(l1.begin(), l2);
+        assert(l1.size() == 4);
+        assert(distance(l1.begin(), l1.end()) == 4);
+        assert(l2.size() == 0);
+        assert(distance(l2.begin(), l2.end()) == 0);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 4);
+        ++i;
+        assert(*i == 5);
+        ++i;
+        assert(*i == 6);
+        ++i;
+        assert(*i == 1);
+    }
+    {
+        std::list<int, min_allocator<int>> l1(a1, a1+1);
+        std::list<int, min_allocator<int>> l2(a2, a2+3);
+        l1.splice(l1.end(), l2);
+        assert(l1.size() == 4);
+        assert(distance(l1.begin(), l1.end()) == 4);
+        assert(l2.size() == 0);
+        assert(distance(l2.begin(), l2.end()) == 0);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 1);
+        ++i;
+        assert(*i == 4);
+        ++i;
+        assert(*i == 5);
+        ++i;
+        assert(*i == 6);
+    }
+    {
+        std::list<int, min_allocator<int>> l1(a1, a1+2);
+        std::list<int, min_allocator<int>> l2;
+        l1.splice(l1.begin(), l2);
+        assert(l1.size() == 2);
+        assert(distance(l1.begin(), l1.end()) == 2);
+        assert(l2.size() == 0);
+        assert(distance(l2.begin(), l2.end()) == 0);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 1);
+        ++i;
+        assert(*i == 2);
+    }
+    {
+        std::list<int, min_allocator<int>> l1(a1, a1+2);
+        std::list<int, min_allocator<int>> l2;
+        l1.splice(next(l1.begin()), l2);
+        assert(l1.size() == 2);
+        assert(distance(l1.begin(), l1.end()) == 2);
+        assert(l2.size() == 0);
+        assert(distance(l2.begin(), l2.end()) == 0);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 1);
+        ++i;
+        assert(*i == 2);
+    }
+    {
+        std::list<int, min_allocator<int>> l1(a1, a1+2);
+        std::list<int, min_allocator<int>> l2;
+        l1.splice(next(l1.begin(), 2), l2);
+        assert(l1.size() == 2);
+        assert(distance(l1.begin(), l1.end()) == 2);
+        assert(l2.size() == 0);
+        assert(distance(l2.begin(), l2.end()) == 0);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 1);
+        ++i;
+        assert(*i == 2);
+    }
+    {
+        std::list<int, min_allocator<int>> l1(a1, a1+2);
+        std::list<int, min_allocator<int>> l2(a2, a2+1);
+        l1.splice(l1.begin(), l2);
+        assert(l1.size() == 3);
+        assert(distance(l1.begin(), l1.end()) == 3);
+        assert(l2.size() == 0);
+        assert(distance(l2.begin(), l2.end()) == 0);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 4);
+        ++i;
+        assert(*i == 1);
+        ++i;
+        assert(*i == 2);
+    }
+    {
+        std::list<int, min_allocator<int>> l1(a1, a1+2);
+        std::list<int, min_allocator<int>> l2(a2, a2+1);
+        l1.splice(next(l1.begin()), l2);
+        assert(l1.size() == 3);
+        assert(distance(l1.begin(), l1.end()) == 3);
+        assert(l2.size() == 0);
+        assert(distance(l2.begin(), l2.end()) == 0);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 1);
+        ++i;
+        assert(*i == 4);
+        ++i;
+        assert(*i == 2);
+    }
+    {
+        std::list<int, min_allocator<int>> l1(a1, a1+2);
+        std::list<int, min_allocator<int>> l2(a2, a2+1);
+        l1.splice(next(l1.begin(), 2), l2);
+        assert(l1.size() == 3);
+        assert(distance(l1.begin(), l1.end()) == 3);
+        assert(l2.size() == 0);
+        assert(distance(l2.begin(), l2.end()) == 0);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 1);
+        ++i;
+        assert(*i == 2);
+        ++i;
+        assert(*i == 4);
+    }
+    {
+        std::list<int, min_allocator<int>> l1(a1, a1+2);
+        std::list<int, min_allocator<int>> l2(a2, a2+2);
+        l1.splice(l1.begin(), l2);
+        assert(l1.size() == 4);
+        assert(distance(l1.begin(), l1.end()) == 4);
+        assert(l2.size() == 0);
+        assert(distance(l2.begin(), l2.end()) == 0);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 4);
+        ++i;
+        assert(*i == 5);
+        ++i;
+        assert(*i == 1);
+        ++i;
+        assert(*i == 2);
+    }
+    {
+        std::list<int, min_allocator<int>> l1(a1, a1+2);
+        std::list<int, min_allocator<int>> l2(a2, a2+2);
+        l1.splice(next(l1.begin()), l2);
+        assert(l1.size() == 4);
+        assert(distance(l1.begin(), l1.end()) == 4);
+        assert(l2.size() == 0);
+        assert(distance(l2.begin(), l2.end()) == 0);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 1);
+        ++i;
+        assert(*i == 4);
+        ++i;
+        assert(*i == 5);
+        ++i;
+        assert(*i == 2);
+    }
+    {
+        std::list<int, min_allocator<int>> l1(a1, a1+2);
+        std::list<int, min_allocator<int>> l2(a2, a2+2);
+        l1.splice(next(l1.begin(), 2), l2);
+        assert(l1.size() == 4);
+        assert(distance(l1.begin(), l1.end()) == 4);
+        assert(l2.size() == 0);
+        assert(distance(l2.begin(), l2.end()) == 0);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 1);
+        ++i;
+        assert(*i == 2);
+        ++i;
+        assert(*i == 4);
+        ++i;
+        assert(*i == 5);
+    }
+    {
+        std::list<int, min_allocator<int>> l1(a1, a1+3);
+        std::list<int, min_allocator<int>> l2(a2, a2+3);
+        l1.splice(l1.begin(), l2);
+        assert(l1.size() == 6);
+        assert(distance(l1.begin(), l1.end()) == 6);
+        assert(l2.size() == 0);
+        assert(distance(l2.begin(), l2.end()) == 0);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 4);
+        ++i;
+        assert(*i == 5);
+        ++i;
+        assert(*i == 6);
+        ++i;
+        assert(*i == 1);
+        ++i;
+        assert(*i == 2);
+        ++i;
+        assert(*i == 3);
+    }
+    {
+        std::list<int, min_allocator<int>> l1(a1, a1+3);
+        std::list<int, min_allocator<int>> l2(a2, a2+3);
+        l1.splice(next(l1.begin()), l2);
+        assert(l1.size() == 6);
+        assert(distance(l1.begin(), l1.end()) == 6);
+        assert(l2.size() == 0);
+        assert(distance(l2.begin(), l2.end()) == 0);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 1);
+        ++i;
+        assert(*i == 4);
+        ++i;
+        assert(*i == 5);
+        ++i;
+        assert(*i == 6);
+        ++i;
+        assert(*i == 2);
+        ++i;
+        assert(*i == 3);
+    }
+    {
+        std::list<int, min_allocator<int>> l1(a1, a1+3);
+        std::list<int, min_allocator<int>> l2(a2, a2+3);
+        l1.splice(next(l1.begin(), 2), l2);
+        assert(l1.size() == 6);
+        assert(distance(l1.begin(), l1.end()) == 6);
+        assert(l2.size() == 0);
+        assert(distance(l2.begin(), l2.end()) == 0);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 1);
+        ++i;
+        assert(*i == 2);
+        ++i;
+        assert(*i == 4);
+        ++i;
+        assert(*i == 5);
+        ++i;
+        assert(*i == 6);
+        ++i;
+        assert(*i == 3);
+    }
+    {
+        std::list<int, min_allocator<int>> l1(a1, a1+3);
+        std::list<int, min_allocator<int>> l2(a2, a2+3);
+        l1.splice(next(l1.begin(), 3), l2);
+        assert(l1.size() == 6);
+        assert(distance(l1.begin(), l1.end()) == 6);
+        assert(l2.size() == 0);
+        assert(distance(l2.begin(), l2.end()) == 0);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 1);
+        ++i;
+        assert(*i == 2);
+        ++i;
+        assert(*i == 3);
+        ++i;
+        assert(*i == 4);
+        ++i;
+        assert(*i == 5);
+        ++i;
+        assert(*i == 6);
+    }
+#if _LIBCPP_DEBUG2 >= 1
+    {
+        std::list<int, min_allocator<int>> v1(3);
+        std::list<int, min_allocator<int>> v2(3);
+        v1.splice(v2.begin(), v2);
+        assert(false);
+    }
+#endif
+#endif
 }
diff --git a/libcxx/test/containers/sequences/list/list.ops/splice_pos_list_iter.pass.cpp b/libcxx/test/containers/sequences/list/list.ops/splice_pos_list_iter.pass.cpp
index 64402ce1bc7..0f6caac9946 100644
--- a/libcxx/test/containers/sequences/list/list.ops/splice_pos_list_iter.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.ops/splice_pos_list_iter.pass.cpp
@@ -18,6 +18,8 @@
 #include <list>
 #include <cassert>
 
+#include "../../../min_allocator.h"
+
 int main()
 {
     int a1[] = {1, 2, 3};
@@ -186,4 +188,170 @@ int main()
         assert(false);
     }
 #endif
+#if __cplusplus >= 201103L
+    {
+        std::list<int, min_allocator<int>> l1;
+        std::list<int, min_allocator<int>> l2(a2, a2+1);
+        l1.splice(l1.end(), l2, l2.begin());
+        assert(l1.size() == 1);
+        assert(distance(l1.begin(), l1.end()) == 1);
+        assert(l2.size() == 0);
+        assert(distance(l2.begin(), l2.end()) == 0);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 4);
+    }
+    {
+        std::list<int, min_allocator<int>> l1;
+        std::list<int, min_allocator<int>> l2(a2, a2+2);
+        l1.splice(l1.end(), l2, l2.begin());
+        assert(l1.size() == 1);
+        assert(distance(l1.begin(), l1.end()) == 1);
+        assert(l2.size() == 1);
+        assert(distance(l2.begin(), l2.end()) == 1);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 4);
+        i = l2.begin();
+        assert(*i == 5);
+    }
+    {
+        std::list<int, min_allocator<int>> l1;
+        std::list<int, min_allocator<int>> l2(a2, a2+2);
+        l1.splice(l1.end(), l2, next(l2.begin()));
+        assert(l1.size() == 1);
+        assert(distance(l1.begin(), l1.end()) == 1);
+        assert(l2.size() == 1);
+        assert(distance(l2.begin(), l2.end()) == 1);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 5);
+        i = l2.begin();
+        assert(*i == 4);
+    }
+    {
+        std::list<int, min_allocator<int>> l1;
+        std::list<int, min_allocator<int>> l2(a2, a2+3);
+        l1.splice(l1.end(), l2, l2.begin());
+        assert(l1.size() == 1);
+        assert(distance(l1.begin(), l1.end()) == 1);
+        assert(l2.size() == 2);
+        assert(distance(l2.begin(), l2.end()) == 2);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 4);
+        i = l2.begin();
+        assert(*i == 5);
+        ++i;
+        assert(*i == 6);
+    }
+    {
+        std::list<int, min_allocator<int>> l1;
+        std::list<int, min_allocator<int>> l2(a2, a2+3);
+        l1.splice(l1.end(), l2, next(l2.begin()));
+        assert(l1.size() == 1);
+        assert(distance(l1.begin(), l1.end()) == 1);
+        assert(l2.size() == 2);
+        assert(distance(l2.begin(), l2.end()) == 2);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 5);
+        i = l2.begin();
+        assert(*i == 4);
+        ++i;
+        assert(*i == 6);
+    }
+    {
+        std::list<int, min_allocator<int>> l1;
+        std::list<int, min_allocator<int>> l2(a2, a2+3);
+        l1.splice(l1.end(), l2, next(l2.begin(), 2));
+        assert(l1.size() == 1);
+        assert(distance(l1.begin(), l1.end()) == 1);
+        assert(l2.size() == 2);
+        assert(distance(l2.begin(), l2.end()) == 2);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 6);
+        i = l2.begin();
+        assert(*i == 4);
+        ++i;
+        assert(*i == 5);
+    }
+    {
+        std::list<int, min_allocator<int>> l1(a1, a1+1);
+        l1.splice(l1.begin(), l1, l1.begin());
+        assert(l1.size() == 1);
+        assert(distance(l1.begin(), l1.end()) == 1);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 1);
+    }
+    {
+        std::list<int, min_allocator<int>> l1(a1, a1+1);
+        std::list<int, min_allocator<int>> l2(a2, a2+1);
+        l1.splice(l1.begin(), l2, l2.begin());
+        assert(l1.size() == 2);
+        assert(distance(l1.begin(), l1.end()) == 2);
+        assert(l2.size() == 0);
+        assert(distance(l2.begin(), l2.end()) == 0);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 4);
+        ++i;
+        assert(*i == 1);
+    }
+    {
+        std::list<int, min_allocator<int>> l1(a1, a1+1);
+        std::list<int, min_allocator<int>> l2(a2, a2+1);
+        l1.splice(next(l1.begin()), l2, l2.begin());
+        assert(l1.size() == 2);
+        assert(distance(l1.begin(), l1.end()) == 2);
+        assert(l2.size() == 0);
+        assert(distance(l2.begin(), l2.end()) == 0);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 1);
+        ++i;
+        assert(*i == 4);
+    }
+    {
+        std::list<int, min_allocator<int>> l1(a1, a1+2);
+        l1.splice(l1.begin(), l1, l1.begin());
+        assert(l1.size() == 2);
+        assert(distance(l1.begin(), l1.end()) == 2);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 1);
+        ++i;
+        assert(*i == 2);
+    }
+    {
+        std::list<int, min_allocator<int>> l1(a1, a1+2);
+        l1.splice(l1.begin(), l1, next(l1.begin()));
+        assert(l1.size() == 2);
+        assert(distance(l1.begin(), l1.end()) == 2);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 2);
+        ++i;
+        assert(*i == 1);
+    }
+    {
+        std::list<int, min_allocator<int>> l1(a1, a1+2);
+        l1.splice(next(l1.begin()), l1, l1.begin());
+        assert(l1.size() == 2);
+        assert(distance(l1.begin(), l1.end()) == 2);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 1);
+        ++i;
+        assert(*i == 2);
+    }
+    {
+        std::list<int, min_allocator<int>> l1(a1, a1+2);
+        l1.splice(next(l1.begin()), l1, next(l1.begin()));
+        assert(l1.size() == 2);
+        assert(distance(l1.begin(), l1.end()) == 2);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 1);
+        ++i;
+        assert(*i == 2);
+    }
+#if _LIBCPP_DEBUG2 >= 1
+    {
+        std::list<int, min_allocator<int>> v1(3);
+        std::list<int, min_allocator<int>> v2(3);
+        v1.splice(v1.begin(), v2, v1.begin());
+        assert(false);
+    }
+#endif
+#endif
 }
diff --git a/libcxx/test/containers/sequences/list/list.ops/splice_pos_list_iter_iter.pass.cpp b/libcxx/test/containers/sequences/list/list.ops/splice_pos_list_iter_iter.pass.cpp
index 2dabf837f12..209fbb94f51 100644
--- a/libcxx/test/containers/sequences/list/list.ops/splice_pos_list_iter_iter.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.ops/splice_pos_list_iter_iter.pass.cpp
@@ -18,6 +18,8 @@
 #include <list>
 #include <cassert>
 
+#include "../../../min_allocator.h"
+
 int main()
 {
     int a1[] = {1, 2, 3};
@@ -126,4 +128,110 @@ int main()
         assert(false);
     }
 #endif
+#if __cplusplus >= 201103L
+    {
+        std::list<int, min_allocator<int>> l1(a1, a1+3);
+        l1.splice(l1.begin(), l1, next(l1.begin()), next(l1.begin()));
+        assert(l1.size() == 3);
+        assert(distance(l1.begin(), l1.end()) == 3);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 1);
+        ++i;
+        assert(*i == 2);
+        ++i;
+        assert(*i == 3);
+    }
+    {
+        std::list<int, min_allocator<int>> l1(a1, a1+3);
+        l1.splice(l1.begin(), l1, next(l1.begin()), next(l1.begin(), 2));
+        assert(l1.size() == 3);
+        assert(distance(l1.begin(), l1.end()) == 3);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 2);
+        ++i;
+        assert(*i == 1);
+        ++i;
+        assert(*i == 3);
+    }
+    {
+        std::list<int, min_allocator<int>> l1(a1, a1+3);
+        l1.splice(l1.begin(), l1, next(l1.begin()), next(l1.begin(), 3));
+        assert(l1.size() == 3);
+        assert(distance(l1.begin(), l1.end()) == 3);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 2);
+        ++i;
+        assert(*i == 3);
+        ++i;
+        assert(*i == 1);
+    }
+    {
+        std::list<int, min_allocator<int>> l1(a1, a1+3);
+        std::list<int, min_allocator<int>> l2(a2, a2+3);
+        l1.splice(l1.begin(), l2, next(l2.begin()), l2.end());
+        assert(l1.size() == 5);
+        assert(distance(l1.begin(), l1.end()) == 5);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 5);
+        ++i;
+        assert(*i == 6);
+        ++i;
+        assert(*i == 1);
+        ++i;
+        assert(*i == 2);
+        ++i;
+        assert(*i == 3);
+        assert(l2.size() == 1);
+        i = l2.begin();
+        assert(*i == 4);
+    }
+    {
+        std::list<int, min_allocator<int>> l1(a1, a1+3);
+        std::list<int, min_allocator<int>> l2(a2, a2+3);
+        l1.splice(next(l1.begin()), l2, next(l2.begin()), l2.end());
+        assert(l1.size() == 5);
+        assert(distance(l1.begin(), l1.end()) == 5);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 1);
+        ++i;
+        assert(*i == 5);
+        ++i;
+        assert(*i == 6);
+        ++i;
+        assert(*i == 2);
+        ++i;
+        assert(*i == 3);
+        assert(l2.size() == 1);
+        i = l2.begin();
+        assert(*i == 4);
+    }
+    {
+        std::list<int, min_allocator<int>> l1(a1, a1+3);
+        std::list<int, min_allocator<int>> l2(a2, a2+3);
+        l1.splice(l1.end(), l2, next(l2.begin()), l2.end());
+        assert(l1.size() == 5);
+        assert(distance(l1.begin(), l1.end()) == 5);
+        std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
+        assert(*i == 1);
+        ++i;
+        assert(*i == 2);
+        ++i;
+        assert(*i == 3);
+        ++i;
+        assert(*i == 5);
+        ++i;
+        assert(*i == 6);
+        assert(l2.size() == 1);
+        i = l2.begin();
+        assert(*i == 4);
+    }
+#if _LIBCPP_DEBUG2 >= 1
+    {
+        std::list<int, min_allocator<int>> v1(3);
+        std::list<int, min_allocator<int>> v2(3);
+        v1.splice(v1.begin(), v2, v2.begin(), v1.end());
+        assert(false);
+    }
+#endif
+#endif
 }
diff --git a/libcxx/test/containers/sequences/list/list.ops/unique.pass.cpp b/libcxx/test/containers/sequences/list/list.ops/unique.pass.cpp
index 17f79dc7997..cfd9d03ab42 100644
--- a/libcxx/test/containers/sequences/list/list.ops/unique.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.ops/unique.pass.cpp
@@ -14,11 +14,24 @@
 #include <list>
 #include <cassert>
 
+#include "../../../min_allocator.h"
+
 int main()
 {
+    {
     int a1[] = {2, 1, 1, 4, 4, 4, 4, 3, 3};
     int a2[] = {2, 1, 4, 3};
     std::list<int> c(a1, a1+sizeof(a1)/sizeof(a1[0]));
     c.unique();
     assert(c == std::list<int>(a2, a2+4));
+    }
+#if __cplusplus >= 201103L
+    {
+    int a1[] = {2, 1, 1, 4, 4, 4, 4, 3, 3};
+    int a2[] = {2, 1, 4, 3};
+    std::list<int, min_allocator<int>> c(a1, a1+sizeof(a1)/sizeof(a1[0]));
+    c.unique();
+    assert((c == std::list<int, min_allocator<int>>(a2, a2+4)));
+    }
+#endif
 }
diff --git a/libcxx/test/containers/sequences/list/list.ops/unique_pred.pass.cpp b/libcxx/test/containers/sequences/list/list.ops/unique_pred.pass.cpp
index 08aede671cb..a9687a9e5ed 100644
--- a/libcxx/test/containers/sequences/list/list.ops/unique_pred.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.ops/unique_pred.pass.cpp
@@ -14,6 +14,8 @@
 #include <list>
 #include <cassert>
 
+#include "../../../min_allocator.h"
+
 bool g(int x, int y)
 {
     return x == y;
@@ -21,9 +23,20 @@ bool g(int x, int y)
 
 int main()
 {
+    {
     int a1[] = {2, 1, 1, 4, 4, 4, 4, 3, 3};
     int a2[] = {2, 1, 4, 3};
     std::list<int> c(a1, a1+sizeof(a1)/sizeof(a1[0]));
     c.unique(g);
     assert(c == std::list<int>(a2, a2+4));
+    }
+#if __cplusplus >= 201103L
+    {
+    int a1[] = {2, 1, 1, 4, 4, 4, 4, 3, 3};
+    int a2[] = {2, 1, 4, 3};
+    std::list<int, min_allocator<int>> c(a1, a1+sizeof(a1)/sizeof(a1[0]));
+    c.unique(g);
+    assert((c == std::list<int, min_allocator<int>>(a2, a2+4)));
+    }
+#endif
 }
diff --git a/libcxx/test/containers/sequences/list/list.special/db_swap_1.pass.cpp b/libcxx/test/containers/sequences/list/list.special/db_swap_1.pass.cpp
index 12730c2863e..9cb169055e2 100644
--- a/libcxx/test/containers/sequences/list/list.special/db_swap_1.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.special/db_swap_1.pass.cpp
@@ -20,6 +20,7 @@
 #include <cassert>
 
 #include <__debug>
+#include "../../../min_allocator.h"
 
 int main()
 {
@@ -38,5 +39,21 @@ int main()
         c1.erase(i1);
         assert(false);
     }
+#if __cplusplus >= 201103L
+    {
+        int a1[] = {1, 3, 7, 9, 10};
+        int a2[] = {0, 2, 4, 5, 6, 8, 11};
+        std::list<int, min_allocator<int>> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
+        std::list<int, min_allocator<int>> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
+        std::list<int, min_allocator<int>>::iterator i1 = c1.begin();
+        std::list<int, min_allocator<int>>::iterator i2 = c2.begin();
+        swap(c1, c2);
+        c1.erase(i2);
+        c2.erase(i1);
+        std::list<int, min_allocator<int>>::iterator j = i1;
+        c1.erase(i1);
+        assert(false);
+    }
+#endif
 #endif
 }
diff --git a/libcxx/test/containers/sequences/list/list.special/swap.pass.cpp b/libcxx/test/containers/sequences/list/list.special/swap.pass.cpp
index f6f25ba7f93..a8283fdeb59 100644
--- a/libcxx/test/containers/sequences/list/list.special/swap.pass.cpp
+++ b/libcxx/test/containers/sequences/list/list.special/swap.pass.cpp
@@ -15,6 +15,7 @@
 #include <list>
 #include <cassert>
 #include "../../../test_allocator.h"
+#include "../../../min_allocator.h"
 
 int main()
 {
@@ -85,4 +86,61 @@ int main()
         assert((c2 == std::list<int, A>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
         assert(c2.get_allocator() == A(1));
     }
+#if __cplusplus >= 201103L
+    {
+        int a1[] = {1, 3, 7, 9, 10};
+        int a2[] = {0, 2, 4, 5, 6, 8, 11};
+        std::list<int, min_allocator<int>> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
+        std::list<int, min_allocator<int>> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
+        swap(c1, c2);
+        assert((c1 == std::list<int, min_allocator<int>>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
+        assert((c2 == std::list<int, min_allocator<int>>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
+    }
+    {
+        int a1[] = {1, 3, 7, 9, 10};
+        int a2[] = {0, 2, 4, 5, 6, 8, 11};
+        std::list<int, min_allocator<int>> c1(a1, a1);
+        std::list<int, min_allocator<int>> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
+        swap(c1, c2);
+        assert((c1 == std::list<int, min_allocator<int>>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
+        assert(c2.empty());
+        assert(distance(c2.begin(), c2.end()) == 0);
+    }
+    {
+        int a1[] = {1, 3, 7, 9, 10};
+        int a2[] = {0, 2, 4, 5, 6, 8, 11};
+        std::list<int, min_allocator<int>> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
+        std::list<int, min_allocator<int>> c2(a2, a2);
+        swap(c1, c2);
+        assert(c1.empty());
+        assert(distance(c1.begin(), c1.end()) == 0);
+        assert((c2 == std::list<int, min_allocator<int>>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
+    }
+    {
+        int a1[] = {1, 3, 7, 9, 10};
+        int a2[] = {0, 2, 4, 5, 6, 8, 11};
+        std::list<int, min_allocator<int>> c1(a1, a1);
+        std::list<int, min_allocator<int>> c2(a2, a2);
+        swap(c1, c2);
+        assert(c1.empty());
+        assert(distance(c1.begin(), c1.end()) == 0);
+        assert(c2.empty());
+        assert(distance(c2.begin(), c2.end()) == 0);
+    }
+#ifndef _LIBCPP_DEBUG_LEVEL
+// This test known to result in undefined behavior detected by _LIBCPP_DEBUG_LEVEL >= 1
+    {
+        int a1[] = {1, 3, 7, 9, 10};
+        int a2[] = {0, 2, 4, 5, 6, 8, 11};
+        typedef min_allocator<int> A;
+        std::list<int, A> c1(a1, a1+sizeof(a1)/sizeof(a1[0]), A());
+        std::list<int, A> c2(a2, a2+sizeof(a2)/sizeof(a2[0]), A());
+        swap(c1, c2);
+        assert((c1 == std::list<int, A>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
+        assert(c1.get_allocator() == A());
+        assert((c2 == std::list<int, A>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
+        assert(c2.get_allocator() == A());
+    }
+#endif
+#endif
 }
diff --git a/libcxx/test/containers/sequences/list/types.pass.cpp b/libcxx/test/containers/sequences/list/types.pass.cpp
index e8de4573725..9fa3a0573ed 100644
--- a/libcxx/test/containers/sequences/list/types.pass.cpp
+++ b/libcxx/test/containers/sequences/list/types.pass.cpp
@@ -25,6 +25,8 @@
 #include <list>
 #include <type_traits>
 
+#include "../../min_allocator.h"
+
 int main()
 {
     static_assert((std::is_same<std::list<int>::value_type, int>::value), "");
@@ -33,4 +35,12 @@ int main()
     static_assert((std::is_same<std::list<int>::const_reference, std::allocator<int>::const_reference>::value), "");
     static_assert((std::is_same<std::list<int>::pointer, std::allocator<int>::pointer>::value), "");
     static_assert((std::is_same<std::list<int>::const_pointer, std::allocator<int>::const_pointer>::value), "");
+#if __cplusplus >= 201103L
+    static_assert((std::is_same<std::list<int, min_allocator<int>>::value_type, int>::value), "");
+    static_assert((std::is_same<std::list<int, min_allocator<int>>::allocator_type, min_allocator<int> >::value), "");
+    static_assert((std::is_same<std::list<int, min_allocator<int>>::reference, int&>::value), "");
+    static_assert((std::is_same<std::list<int, min_allocator<int>>::const_reference, const int&>::value), "");
+    static_assert((std::is_same<std::list<int, min_allocator<int>>::pointer, min_pointer<int>>::value), "");
+    static_assert((std::is_same<std::list<int, min_allocator<int>>::const_pointer, min_pointer<const int>>::value), "");
+#endif
 }