[libcxx][test][NFC] Add tests for hash_function() and key_eq() in unordered containers

[ldionne]

Summary

Add tests for hasher hash_function() const and key_equal key_eq() const observers in unordered containers

[• Quuxplusone]

https://reviews.llvm.org/harbormaster/unit/view/2593320/
https://reviews.llvm.org/harbormaster/unit/view/2593321/

/home/libcxx-builder/.buildkite-agent/builds/998e9b442c55-1/llvm-project/libcxx-ci/build/generic-debug-iterators/include/c++/v1/__hash_table:330: _LIBCPP_ASSERT '::std::__libcpp_is_constant_evaluated() || (__get_const_db()->__dereferenceable(this))' failed. Attempted to dereference a non-dereferenceable unordered container iterator

/home/libcxx-builder/.buildkite-agent/builds/998e9b442c55-1/llvm-project/libcxx-ci/build/generic-debug-iterators/include/c++/v1/__hash_table:442: _LIBCPP_ASSERT '::std::__libcpp_is_constant_evaluated() || (__get_const_db()->__dereferenceable(this))' failed. Attempted to dereference a non-dereferenceable unordered container const_iterator

What's the deal with these failures? The test code doesn't jump out at me as wrong, so I wonder if you've uncovered a bug. Thoughts?

[ldionne]

Could you rebase onto main and re-upload this? I suspect the failures might go away now that we've changed a few things about the debug mode.

[rarutyun]

In D119703#3473061, @ldionne wrote:

Could you rebase onto main and re-upload this? I suspect the failures might go away now that we've changed a few things about the debug mode.

Rebased

[ldionne]

I looked into this a bit, and I think we might not be registering debug iterators properly in unordered_set and unordered_map when we insert. I'm not sure why the rest of the test suite would be happy with this, though.

[ldionne]

This LGTM, I think the CI failures should not be relevant anymore since so much has changed about the debug mode.

[ldionne]

Commandeering to rebase.

[ldionne]

Rebase (and run clang-format on the tests)

[ldionne]

Rebase to poke CI.

[ldionne]

The CI failures are with TSAN but everything fails with TSAN right now, so this looks good.

libcxx/test/std/containers/unord/unord.map/hash_function.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_map>
+
+// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
+//           class Alloc = allocator<pair<const Key, T>>>
+// class unordered_map
+
+// hasher hash_function() const;
+
+#include <unordered_map>
+#include <string>
+#include <cassert>
+
+int main(int, char**) {
+  typedef std::unordered_map<int, std::string> map_type;
+  map_type m;
+
+  std::pair<map_type::iterator, bool> p = m.insert(map_type::value_type(1, "abc"));
+
+  const map_type& cm = m;
+  assert(cm.hash_function()(p.first->first) == cm.hash_function()(1));
+  assert(cm.hash_function()(1) == cm.hash_function()(p.first->first));
+
+  return 0;
+}

libcxx/test/std/containers/unord/unord.map/key_eq.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_map>
+
+// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
+//           class Alloc = allocator<pair<const Key, T>>>
+// class unordered_map
+
+// hasher key_eq() const;
+
+#include <unordered_map>
+#include <string>
+#include <cassert>
+
+int main(int, char**) {
+  typedef std::unordered_map<int, std::string> map_type;
+
+  map_type m;
+  std::pair<map_type::iterator, bool> p1 = m.insert(map_type::value_type(1, "abc"));
+  std::pair<map_type::iterator, bool> p2 = m.insert(map_type::value_type(2, "abc"));
+
+  const map_type& cm = m;
+
+  assert(cm.key_eq()(p1.first->first, p1.first->first));
+  assert(cm.key_eq()(p2.first->first, p2.first->first));
+  assert(!cm.key_eq()(p1.first->first, p2.first->first));
+  assert(!cm.key_eq()(p2.first->first, p1.first->first));
+
+  return 0;
+}

libcxx/test/std/containers/unord/unord.multimap/hash_function.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_map>
+
+// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
+//           class Alloc = allocator<pair<const Key, T>>>
+// class unordered_multimap
+
+// hasher hash_function() const;
+
+#include <unordered_map>
+#include <string>
+#include <cassert>
+
+int main(int, char**) {
+  typedef std::unordered_multimap<int, std::string> map_type;
+  map_type m;
+
+  map_type::iterator i1 = m.insert(map_type::value_type(1, "abc"));
+  map_type::iterator i2 = m.insert(map_type::value_type(1, "bcd"));
+
+  const map_type& cm = m;
+  assert(cm.hash_function()(i1->first) == cm.hash_function()(i2->first));
+  assert(cm.hash_function()(i2->first) == cm.hash_function()(i1->first));
+
+  return 0;
+}

libcxx/test/std/containers/unord/unord.multimap/key_eq.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_map>
+
+// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
+//           class Alloc = allocator<pair<const Key, T>>>
+// class unordered_multimap
+
+// hasher key_eq() const;
+
+#include <unordered_map>
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main(int, char**) {
+  typedef std::unordered_multimap<int, std::string> map_type;
+
+  map_type m;
+  map_type::iterator i1 = m.insert(map_type::value_type(1, "abc"));
+  map_type::iterator i2 = m.insert(map_type::value_type(1, "bcd"));
+  map_type::iterator i3 = m.insert(map_type::value_type(2, "abc"));
+
+  const map_type& cm = m;
+
+  assert(cm.key_eq()(i1->first, i1->first));
+  assert(cm.key_eq()(i2->first, i2->first));
+  assert(cm.key_eq()(i3->first, i3->first));
+
+  assert(cm.key_eq()(i1->first, i2->first));
+  assert(cm.key_eq()(i2->first, i1->first));
+
+  assert(!cm.key_eq()(i1->first, i3->first));
+  assert(!cm.key_eq()(i3->first, i1->first));
+
+  assert(!cm.key_eq()(i2->first, i3->first));
+  assert(!cm.key_eq()(i3->first, i2->first));
+
+  return 0;
+}

libcxx/test/std/containers/unord/unord.multiset/hash_function.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_set>
+
+// template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
+//           class Alloc = allocator<Value>>
+// class unordered_multiset
+
+// hasher hash_function() const;
+
+#include <unordered_set>
+#include <cassert>
+
+int main(int, char**) {
+  typedef std::unordered_multiset<int> set_type;
+  set_type s;
+
+  set_type::iterator i1 = s.insert(1);
+  set_type::iterator i2 = s.insert(1);
+
+  const set_type& cs = s;
+  assert(cs.hash_function()(*i1) == cs.hash_function()(*i2));
+  assert(cs.hash_function()(*i2) == cs.hash_function()(*i1));
+
+  return 0;
+}

libcxx/test/std/containers/unord/unord.multiset/key_eq.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_set>
+
+// template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
+//           class Alloc = allocator<Value>>
+// class unordered_multiset
+
+// key_equal key_eq() const;
+
+#include <unordered_set>
+#include <cassert>
+
+int main(int, char**) {
+  typedef std::unordered_multiset<int> set_type;
+  set_type s;
+
+  set_type::iterator i1 = s.insert(1);
+  set_type::iterator i2 = s.insert(1);
+  set_type::iterator i3 = s.insert(2);
+
+  const set_type& cs = s;
+
+  assert(cs.key_eq()(*i1, *i1));
+  assert(cs.key_eq()(*i2, *i2));
+  assert(cs.key_eq()(*i3, *i3));
+
+  assert(cs.key_eq()(*i1, *i2));
+  assert(cs.key_eq()(*i2, *i1));
+
+  assert(!cs.key_eq()(*i1, *i3));
+  assert(!cs.key_eq()(*i3, *i1));
+
+  assert(!cs.key_eq()(*i2, *i3));
+  assert(!cs.key_eq()(*i3, *i2));
+
+  return 0;
+}

libcxx/test/std/containers/unord/unord.set/hash_function.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_set>
+
+// template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
+//           class Alloc = allocator<Value>>
+// class unordered_set
+
+// hasher hash_function() const;
+
+#include <unordered_set>
+#include <cassert>
+
+int main(int, char**) {
+  typedef std::unordered_set<int> set_type;
+  set_type s;
+
+  std::pair<set_type::iterator, bool> p = s.insert(1);
+
+  const set_type& cs = s;
+  assert(cs.hash_function()(*p.first) == cs.hash_function()(1));
+  assert(cs.hash_function()(1) == cs.hash_function()(*p.first));
+
+  return 0;
+}

libcxx/test/std/containers/unord/unord.set/key_eq.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_set>
+
+// template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
+//           class Alloc = allocator<Value>>
+// class unordered_set
+
+// key_equal key_eq() const;
+
+#include <unordered_set>
+#include <cassert>
+
+int main(int, char**) {
+  typedef std::unordered_set<int> set_type;
+
+  set_type s;
+
+  std::pair<set_type::iterator, bool> p1 = s.insert(1);
+  std::pair<set_type::iterator, bool> p2 = s.insert(2);
+
+  const set_type& cs = s;
+
+  assert(cs.key_eq()(*p1.first, *p1.first));
+  assert(cs.key_eq()(*p2.first, *p2.first));
+
+  assert(!cs.key_eq()(*p1.first, *p2.first));
+  assert(!cs.key_eq()(*p2.first, *p1.first));
+
+  return 0;
+}