1 files changed, 181 insertions, 1 deletions
diff --git a/test/std/containers/sequences/list/list.cons/input_iterator.pass.cpp b/test/std/containers/sequences/list/list.cons/input_iterator.pass.cpp
index 3b3c2f7ef..3cdcc7362 100644
--- a/test/std/containers/sequences/list/list.cons/input_iterator.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/input_iterator.pass.cpp
@@ -17,8 +17,12 @@
 #include "test_iterators.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
+#if TEST_STD_VER >= 11
+#include "emplace_constructible.h"
+#include "container_test_types.h"
+#endif
 
-int main()
+void basic_test()
 {
     {
         int a[] = {0, 1, 2, 3};
@@ -76,3 +80,179 @@ int main()
     }
 #endif
 }
+
+
+
+void test_emplacable_concept() {
+#if TEST_STD_VER >= 11
+  int arr1[] = {42};
+  int arr2[] = {1, 101, 42};
+  {
+    using T = EmplaceConstructible<int>;
+    using It = random_access_iterator<int*>;
+    {
+      std::list<T> v(It(arr1), It(std::end(arr1)));
+      auto I = v.begin();
+      assert(I->value == 42);
+    }
+    {
+      std::list<T> v(It(arr2), It(std::end(arr2)));
+      auto I = v.begin();
+      assert(I->value == 1);
+      ++I;
+      assert(I->value == 101);
+      ++I;
+      assert(I->value == 42);
+    }
+  }
+  {
+    using T = EmplaceConstructible<int>;
+    using It = input_iterator<int*>;
+    {
+      std::list<T> v(It(arr1), It(std::end(arr1)));
+      auto I = v.begin();
+      assert(I->value == 42);
+    }
+    {
+      std::list<T> v(It(arr2), It(std::end(arr2)));
+      auto I = v.begin();
+      //assert(v[0].copied == 0);
+      assert(I->value == 1);
+      //assert(v[1].copied == 0);
+      ++I;
+      assert(I->value == 101);
+      ++I;
+      assert(I->value == 42);
+    }
+  }
+#endif
+}
+
+
+
+void test_emplacable_concept_with_alloc() {
+#if TEST_STD_VER >= 11
+  int arr1[] = {42};
+  int arr2[] = {1, 101, 42};
+  {
+    using T = EmplaceConstructible<int>;
+    using It = random_access_iterator<int*>;
+    std::allocator<T> a;
+    {
+      std::list<T> v(It(arr1), It(std::end(arr1)), a);
+      auto I = v.begin();
+      assert(I->value == 42);
+    }
+    {
+      std::list<T> v(It(arr2), It(std::end(arr2)), a);
+      auto I = v.begin();
+      assert(I->value == 1);
+      ++I;
+      assert(I->value == 101);
+      ++I;
+      assert(I->value == 42);
+    }
+  }
+  {
+    using T = EmplaceConstructible<int>;
+    using It = input_iterator<int*>;
+    std::allocator<T> a;
+    {
+      std::list<T> v(It(arr1), It(std::end(arr1)), a);
+      auto I = v.begin();
+      assert(I->value == 42);
+    }
+    {
+      std::list<T> v(It(arr2), It(std::end(arr2)), a);
+      auto I = v.begin();
+      //assert(v[0].copied == 0);
+      assert(I->value == 1);
+      //assert(v[1].copied == 0);
+      ++I;
+      assert(I->value == 101);
+      ++I;
+      assert(I->value == 42);
+    }
+  }
+#endif
+}
+
+void test_ctor_under_alloc() {
+#if TEST_STD_VER >= 11
+  int arr1[] = {42};
+  int arr2[] = {1, 101, 42};
+  {
+    using C = TCT::list<>;
+    using T = typename C::value_type;
+    using It = forward_iterator<int*>;
+    {
+      ExpectConstructGuard<int&> G(1);
+      C v(It(arr1), It(std::end(arr1)));
+    }
+    {
+      ExpectConstructGuard<int&> G(3);
+      C v(It(arr2), It(std::end(arr2)));
+    }
+  }
+  {
+    using C = TCT::list<>;
+    using T = typename C::value_type;
+    using It = input_iterator<int*>;
+    {
+      ExpectConstructGuard<int&> G(1);
+      C v(It(arr1), It(std::end(arr1)));
+    }
+    {
+      ExpectConstructGuard<int&> G(3);
+      C v(It(arr2), It(std::end(arr2)));
+    }
+  }
+#endif
+}
+
+void test_ctor_under_alloc_with_alloc() {
+#if TEST_STD_VER >= 11
+  int arr1[] = {42};
+  int arr2[] = {1, 101, 42};
+  {
+    using C = TCT::list<>;
+    using T = typename C::value_type;
+    using It = forward_iterator<int*>;
+    using Alloc = typename C::allocator_type;
+    Alloc a;
+    {
+      ExpectConstructGuard<int&> G(1);
+      C v(It(arr1), It(std::end(arr1)), a);
+    }
+    {
+      ExpectConstructGuard<int&> G(3);
+      C v(It(arr2), It(std::end(arr2)), a);
+    }
+  }
+  {
+    using C = TCT::list<>;
+    using T = typename C::value_type;
+    using It = input_iterator<int*>;
+    using Alloc = typename C::allocator_type;
+    Alloc a;
+    {
+      ExpectConstructGuard<int&> G(1);
+      C v(It(arr1), It(std::end(arr1)), a);
+    }
+    {
+      ExpectConstructGuard<int&> G(3);
+      C v(It(arr2), It(std::end(arr2)), a);
+    }
+  }
+#endif
+}
+
+
+
+int main() {
+  basic_test();
+  test_emplacable_concept();
+  test_emplacable_concept_with_alloc();
+  test_ctor_under_alloc();
+  test_ctor_under_alloc_with_alloc();
+}