Add tests for unordered container tests and std::string

llvm-svn: 290655

4 files changed, 547 insertions, 0 deletions

diff --git a/libcxx/test/libcxx/debug/containers/db_string.pass.cpp b/libcxx/test/libcxx/debug/containers/db_string.pass.cpp
new file mode 100644
index 00000000000..ee1634140ff
--- /dev/null
+++ b/libcxx/test/libcxx/debug/containers/db_string.pass.cpp
@@ -0,0 +1,96 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+// UNSUPPORTED: libcpp-no-exceptions, libcpp-no-if-constexpr
+
+// test container debugging
+
+#define _LIBCPP_DEBUG 1
+#define _LIBCPP_DEBUG_USE_EXCEPTIONS
+#include <string>
+#include <vector>
+
+#include "test_macros.h"
+#include "debug_mode_helper.h"
+
+using namespace IteratorDebugChecks;
+
+typedef std::basic_string<char, std::char_traits<char>, test_allocator<char>>  StringType;
+
+template <class Container = StringType, ContainerType CT = CT_String>
+struct StringContainerChecks : BasicContainerChecks<Container, CT> {
+  using Base = BasicContainerChecks<Container, CT_String>;
+  using value_type = typename Container::value_type;
+  using allocator_type = typename Container::allocator_type;
+  using iterator = typename Container::iterator;
+  using const_iterator = typename Container::const_iterator;
+
+  using Base::makeContainer;
+  using Base::makeValueType;
+
+public:
+  static void run() {
+    Base::run_iterator_tests();
+    // FIXME: get these passing
+    // Base::run_allocator_aware_tests();
+    try {
+      for (int N : {3, 128}) {
+        FrontOnEmptyContainer(N);
+        BackOnEmptyContainer(N);
+        PopBack(N);
+      }
+    } catch (...) {
+      assert(false && "uncaught debug exception");
+    }
+  }
+
+private:
+  static void BackOnEmptyContainer(int N) {
+    CHECKPOINT("testing back on empty");
+    Container C = makeContainer(N);
+    Container const& CC = C;
+    iterator it = --C.end();
+    (void)C.back();
+    (void)CC.back();
+    C.pop_back();
+    CHECK_DEBUG_THROWS( C.erase(it) );
+    C.clear();
+    CHECK_DEBUG_THROWS( C.back() );
+    CHECK_DEBUG_THROWS( CC.back() );
+  }
+
+  static void FrontOnEmptyContainer(int N) {
+    CHECKPOINT("testing front on empty");
+    Container C = makeContainer(N);
+    Container const& CC = C;
+    (void)C.front();
+    (void)CC.front();
+    C.clear();
+    CHECK_DEBUG_THROWS( C.front() );
+    CHECK_DEBUG_THROWS( CC.front() );
+  }
+
+  static void PopBack(int N) {
+    CHECKPOINT("testing pop_back() invalidation");
+    Container C1 = makeContainer(N);
+    iterator it1 = C1.end();
+    --it1;
+    C1.pop_back();
+    CHECK_DEBUG_THROWS( C1.erase(it1) );
+    C1.erase(C1.begin(), C1.end());
+    assert(C1.size() == 0);
+    CHECK_DEBUG_THROWS( C1.pop_back() );
+  }
+};
+
+int main()
+{
+  StringContainerChecks<>::run();
+}
diff --git a/libcxx/test/libcxx/debug/containers/db_unord_container_tests.pass.cpp b/libcxx/test/libcxx/debug/containers/db_unord_container_tests.pass.cpp
new file mode 100644
index 00000000000..708fc7f8b95
--- /dev/null
+++ b/libcxx/test/libcxx/debug/containers/db_unord_container_tests.pass.cpp
@@ -0,0 +1,66 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+// UNSUPPORTED: libcpp-no-exceptions, libcpp-no-if-constexpr
+
+// test container debugging
+
+#define _LIBCPP_DEBUG 1
+#define _LIBCPP_DEBUG_USE_EXCEPTIONS
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <cassert>
+#include "debug_mode_helper.h"
+
+using namespace IteratorDebugChecks;
+
+template <class Container, ContainerType CT>
+struct UnorderedContainerChecks : BasicContainerChecks<Container, CT> {
+  using Base = BasicContainerChecks<Container, CT>;
+  using value_type = typename Container::value_type;
+  using iterator = typename Container::iterator;
+  using const_iterator = typename Container::const_iterator;
+  using traits = std::iterator_traits<iterator>;
+  using category = typename traits::iterator_category;
+
+  using Base::makeContainer;
+public:
+  static void run() {
+    Base::run();
+    try {
+     // FIXME
+    } catch (...) {
+      assert(false && "uncaught debug exception");
+    }
+  }
+private:
+
+};
+
+int main()
+{
+  using SetAlloc = test_allocator<int>;
+  using MapAlloc = test_allocator<std::pair<const int, int>>;
+  {
+    UnorderedContainerChecks<
+        std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, MapAlloc>,
+        CT_UnorderedMap>::run();
+    UnorderedContainerChecks<
+        std::unordered_set<int, std::hash<int>, std::equal_to<int>, SetAlloc>,
+        CT_UnorderedSet>::run();
+    UnorderedContainerChecks<
+        std::unordered_multimap<int, int, std::hash<int>, std::equal_to<int>, MapAlloc>,
+        CT_UnorderedMultiMap>::run();
+    UnorderedContainerChecks<
+        std::unordered_multiset<int, std::hash<int>, std::equal_to<int>, SetAlloc>,
+        CT_UnorderedMultiSet>::run();
+  }
+}
diff --git a/libcxx/test/libcxx/test/config.py b/libcxx/test/libcxx/test/config.py
index c2408683cfe..4551845104d 100644
--- a/libcxx/test/libcxx/test/config.py
+++ b/libcxx/test/libcxx/test/config.py
@@ -335,6 +335,9 @@ class Configuration(object):
         if self.get_lit_bool('has_libatomic', False):
             self.config.available_features.add('libatomic')
 
+        if '__cpp_if_constexpr' not in self.cxx.dumpMacros():
+            self.config.available_features.add('libcpp-no-if-constexpr')
+
     def configure_compile_flags(self):
         no_default_flags = self.get_lit_bool('no_default_flags', False)
         if not no_default_flags:
diff --git a/libcxx/test/support/debug_mode_helper.h b/libcxx/test/support/debug_mode_helper.h
new file mode 100644
index 00000000000..0c6170589c2
--- /dev/null
+++ b/libcxx/test/support/debug_mode_helper.h
@@ -0,0 +1,382 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef TEST_SUPPORT_DEBUG_MODE_HELPER_H
+#define TEST_SUPPORT_DEBUG_MODE_HELPER_H
+
+#ifndef _LIBCPP_DEBUG
+#error _LIBCPP_DEBUG must be defined before including this header
+#endif
+#ifndef _LIBCPP_DEBUG_USE_EXCEPTIONS
+#error _LIBCPP_DEBUG_USE_EXCEPTIONS must be defined before including this header
+#endif
+
+#include <ciso646>
+#ifndef _LIBCPP_VERSION
+#error This header may only be used for libc++ tests"
+#endif
+
+#include <__debug>
+#include <utility>
+#include <cstddef>
+#include <cstdlib>
+#include <cassert>
+
+#include "test_macros.h"
+#include "assert_checkpoint.h"
+#include "test_allocator.h"
+
+// These test make use of 'if constexpr'.
+#if TEST_STD_VER <= 14
+#error This header may only be used in C++17 and greater
+#endif
+#ifdef TEST_HAS_NO_EXCEPTIONS
+#error These tests require exceptions
+#endif
+
+#ifndef __cpp_if_constexpr
+#error These tests require if constexpr
+#endif
+
+/// Assert that the specified expression throws a libc++ debug exception.
+#define CHECK_DEBUG_THROWS(...) assert((CheckDebugThrows( [&]() { __VA_ARGS__; } )))
+
+template <class Func>
+inline bool CheckDebugThrows(Func&& func) {
+  try {
+    func();
+  } catch (std::__libcpp_debug_exception const&) {
+    return true;
+  }
+  return false;
+}
+
+namespace IteratorDebugChecks {
+
+enum ContainerType {
+  CT_None,
+  CT_String,
+  CT_Vector,
+  CT_VectorBool,
+  CT_List,
+  CT_Deque,
+  CT_ForwardList,
+  CT_Map,
+  CT_Set,
+  CT_MultiMap,
+  CT_MultiSet,
+  CT_UnorderedMap,
+  CT_UnorderedSet,
+  CT_UnorderedMultiMap,
+  CT_UnorderedMultiSet
+};
+
+constexpr bool isSequential(ContainerType CT) {
+  return CT_Vector >= CT && CT_ForwardList <= CT;
+}
+
+constexpr bool isAssociative(ContainerType CT) {
+  return CT_Map >= CT && CT_MultiSet <= CT;
+}
+
+constexpr bool isUnordered(ContainerType CT) {
+  return CT_UnorderedMap >= CT && CT_UnorderedMultiSet <= CT;
+}
+
+constexpr bool isSet(ContainerType CT) {
+  return CT == CT_Set
+      || CT == CT_MultiSet
+      || CT == CT_UnorderedSet
+      || CT == CT_UnorderedMultiSet;
+}
+
+constexpr bool isMap(ContainerType CT) {
+  return CT == CT_Map
+      || CT == CT_MultiMap
+      || CT == CT_UnorderedMap
+      || CT == CT_UnorderedMultiMap;
+}
+
+constexpr bool isMulti(ContainerType CT) {
+  return CT == CT_MultiMap
+      || CT == CT_MultiSet
+      || CT == CT_UnorderedMultiMap
+      || CT == CT_UnorderedMultiSet;
+}
+
+template <class Container, class ValueType = typename Container::value_type>
+struct ContainerDebugHelper {
+  static_assert(std::is_constructible<ValueType, int>::value,
+                "must be constructible from int");
+
+  static ValueType makeValueType(int val = 0, int = 0) {
+    return ValueType(val);
+  }
+};
+
+template <class Container>
+struct ContainerDebugHelper<Container, char> {
+  static char makeValueType(int = 0, int = 0) {
+    return 'A';
+  }
+};
+
+template <class Container, class Key, class Value>
+struct ContainerDebugHelper<Container, std::pair<const Key, Value> > {
+  using ValueType = std::pair<const Key, Value>;
+  static_assert(std::is_constructible<Key, int>::value,
+                "must be constructible from int");
+  static_assert(std::is_constructible<Value, int>::value,
+                "must be constructible from int");
+
+  static ValueType makeValueType(int key = 0, int val = 0) {
+    return ValueType(key, val);
+  }
+};
+
+template <class Container, ContainerType CT,
+    class Helper = ContainerDebugHelper<Container> >
+struct BasicContainerChecks {
+  using value_type = typename Container::value_type;
+  using iterator = typename Container::iterator;
+  using const_iterator = typename Container::const_iterator;
+  using allocator_type = typename Container::allocator_type;
+  using traits = std::iterator_traits<iterator>;
+  using category = typename traits::iterator_category;
+
+  static_assert(std::is_same<test_allocator<value_type>, allocator_type>::value,
+                "the container must use a test allocator");
+
+  static constexpr bool IsBiDir =
+      std::is_convertible<category, std::bidirectional_iterator_tag>::value;
+
+public:
+  static void run() {
+    run_iterator_tests();
+    run_container_tests();
+    run_allocator_aware_tests();
+  }
+
+  static void run_iterator_tests() {
+    try {
+      TestNullIterators<iterator>();
+      TestNullIterators<const_iterator>();
+      if constexpr (IsBiDir) { DecrementBegin(); }
+      IncrementEnd();
+      DerefEndIterator();
+    } catch (...) {
+      assert(false && "uncaught debug exception");
+    }
+  }
+
+  static void run_container_tests() {
+    try {
+      CopyInvalidatesIterators();
+      MoveInvalidatesIterators();
+      if constexpr (CT != CT_ForwardList) {
+          EraseIter();
+          EraseIterIter();
+      }
+    } catch (...) {
+      assert(false && "uncaught debug exception");
+    }
+  }
+
+  static void run_allocator_aware_tests() {
+    try {
+      SwapNonEqualAllocators();
+      if constexpr (CT != CT_ForwardList) {
+          SwapInvalidatesIterators(); // FIXME: This should work
+      }
+    } catch (...) {
+      assert(false && "uncaught debug exception");
+    }
+  }
+
+  static Container makeContainer(int size, allocator_type A = allocator_type()) {
+    Container C(A);
+    if constexpr (CT == CT_ForwardList) {
+      for (int i = 0; i < size; ++i)
+        C.insert_after(C.before_begin(), Helper::makeValueType(i));
+    } else {
+      for (int i = 0; i < size; ++i)
+        C.insert(C.end(), Helper::makeValueType(i));
+      assert(C.size() == static_cast<std::size_t>(size));
+    }
+    return C;
+  }
+
+  static value_type makeValueType(int value) {
+    return Helper::makeValueType(value);
+  }
+
+private:
+  // Iterator tests
+  template <class Iter>
+  static void TestNullIterators() {
+    CHECKPOINT("testing null iterator");
+    Iter it;
+    CHECK_DEBUG_THROWS( ++it );
+    CHECK_DEBUG_THROWS( it++ );
+    CHECK_DEBUG_THROWS( *it );
+    if constexpr (CT != CT_VectorBool) {
+      CHECK_DEBUG_THROWS( it.operator->() );
+    }
+    if constexpr (IsBiDir) {
+      CHECK_DEBUG_THROWS( --it );
+      CHECK_DEBUG_THROWS( it-- );
+    }
+  }
+
+  static void DecrementBegin() {
+    CHECKPOINT("testing decrement on begin");
+    Container C = makeContainer(1);
+    iterator i = C.end();
+    const_iterator ci = C.cend();
+    --i;
+    --ci;
+    assert(i == C.begin());
+    CHECK_DEBUG_THROWS( --i );
+    CHECK_DEBUG_THROWS( i-- );
+    CHECK_DEBUG_THROWS( --ci );
+    CHECK_DEBUG_THROWS( ci-- );
+  }
+
+  static void IncrementEnd() {
+    CHECKPOINT("testing increment on end");
+    Container C = makeContainer(1);
+    iterator i = C.begin();
+    const_iterator ci = C.begin();
+    ++i;
+    ++ci;
+    assert(i == C.end());
+    CHECK_DEBUG_THROWS( ++i );
+    CHECK_DEBUG_THROWS( i++ );
+    CHECK_DEBUG_THROWS( ++ci );
+    CHECK_DEBUG_THROWS( ci++ );
+  }
+
+  static void DerefEndIterator() {
+    CHECKPOINT("testing deref end iterator");
+    Container C = makeContainer(1);
+    iterator i = C.begin();
+    const_iterator ci = C.cbegin();
+    (void)*i; (void)*ci;
+    if constexpr (CT != CT_VectorBool) {
+      i.operator->();
+      ci.operator->();
+    }
+    ++i; ++ci;
+    assert(i == C.end());
+    CHECK_DEBUG_THROWS( *i );
+    CHECK_DEBUG_THROWS( *ci );
+    if constexpr (CT != CT_VectorBool) {
+      CHECK_DEBUG_THROWS( i.operator->() );
+      CHECK_DEBUG_THROWS( ci.operator->() );
+    }
+  }
+
+  // Container tests
+  static void CopyInvalidatesIterators() {
+    CHECKPOINT("copy invalidates iterators");
+    Container C1 = makeContainer(3);
+    iterator i = C1.begin();
+    Container C2 = C1;
+    if constexpr (CT == CT_ForwardList) {
+      iterator i_next = i;
+      ++i_next;
+      (void)*i_next;
+      CHECK_DEBUG_THROWS( C2.erase_after(i) );
+      C1.erase_after(i);
+      CHECK_DEBUG_THROWS( *i_next );
+    } else {
+      CHECK_DEBUG_THROWS( C2.erase(i) );
+      (void)*i;
+      C1.erase(i);
+      CHECK_DEBUG_THROWS( *i );
+    }
+  }
+
+  static void MoveInvalidatesIterators() {
+    CHECKPOINT("copy move invalidates iterators");
+    Container C1 = makeContainer(3);
+    iterator i = C1.begin();
+    Container C2 = std::move(C1);
+    (void) *i;
+    if constexpr (CT == CT_ForwardList) {
+      CHECK_DEBUG_THROWS( C1.erase_after(i) );
+      C2.erase_after(i);
+    } else {
+      CHECK_DEBUG_THROWS( C1.erase(i) );
+      C2.erase(i);
+      CHECK_DEBUG_THROWS(*i);
+    }
+  }
+
+  static void EraseIter() {
+    CHECKPOINT("testing erase invalidation");
+    Container C1 = makeContainer(2);
+    iterator it1 = C1.begin();
+    iterator it1_next = it1;
+    ++it1_next;
+    Container C2 = C1;
+    CHECK_DEBUG_THROWS( C2.erase(it1) ); // wrong container
+    CHECK_DEBUG_THROWS( C2.erase(C2.end()) ); // erase with end
+    C1.erase(it1_next);
+    CHECK_DEBUG_THROWS( C1.erase(it1_next) ); // invalidated iterator
+    C1.erase(it1);
+    CHECK_DEBUG_THROWS( C1.erase(it1) ); // invalidated iterator
+  }
+
+  static void EraseIterIter() {
+    CHECKPOINT("testing erase iter iter invalidation");
+    Container C1 = makeContainer(2);
+    iterator it1 = C1.begin();
+    iterator it1_next = it1;
+    ++it1_next;
+    Container C2 = C1;
+    iterator it2 = C2.begin();
+    iterator it2_next = it2;
+    ++it2_next;
+    CHECK_DEBUG_THROWS( C2.erase(it1, it1_next) ); // begin from wrong container
+    CHECK_DEBUG_THROWS( C2.erase(it1, it2_next) ); // end   from wrong container
+    CHECK_DEBUG_THROWS( C2.erase(it2, it1_next) ); // both  from wrong container
+    C2.erase(it2, it2_next);
+  }
+
+  // Allocator aware tests
+  static void SwapInvalidatesIterators() {
+    CHECKPOINT("testing swap invalidates iterators");
+    Container C1 = makeContainer(3);
+    Container C2 = makeContainer(3);
+    iterator it1 = C1.begin();
+    iterator it2 = C2.begin();
+    swap(C1, C2);
+    CHECK_DEBUG_THROWS( C1.erase(it1) );
+    C1.erase(it2);
+    //C2.erase(it1);
+    CHECK_DEBUG_THROWS( C1.erase(it1) );
+  }
+
+  static void SwapNonEqualAllocators() {
+    CHECKPOINT("testing swap with non-equal allocators");
+    Container C1 = makeContainer(3, allocator_type(1));
+    Container C2 = makeContainer(1, allocator_type(2));
+    Container C3 = makeContainer(2, allocator_type(2));
+    swap(C2, C3);
+    CHECK_DEBUG_THROWS( swap(C1, C2) );
+  }
+
+private:
+  BasicContainerChecks() = delete;
+};
+
+} // namespace IteratorDebugChecks
+
+#endif // TEST_SUPPORT_DEBUG_MODE_HELPER_H