// explicit map(const key_compare& comp);
-// key_compare key_comp() const;
-
#include <map>
#include <cassert>
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <map>
+
+// key_compare key_comp() const;
+
+#include <map>
+#include <cassert>
+#include <string>
+
+int main(int, char**) {
+ typedef std::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_comp()(p1.first->first, p2.first->first));
+ assert(!cm.key_comp()(p2.first->first, p1.first->first));
+
+ return 0;
+}
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <map>
+
+// value_compare value_comp() const;
+
+#include <map>
+#include <cassert>
+#include <string>
+
+int main(int, char**) {
+ typedef std::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.value_comp()(*p1.first, *p2.first));
+ assert(!cm.value_comp()(*p2.first, *p1.first));
+
+ return 0;
+}
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <map>
+
+// class value_compare
+
+// bool operator()( const value_type& lhs, const value_type& rhs ) const;
+
+#include <map>
+#include <cassert>
+#include <string>
+#include <utility>
+
+template <typename Map>
+struct CallCompMember : Map::value_compare {
+ CallCompMember(const typename Map::value_compare& vc) : Map::value_compare(vc) {}
+
+ typedef typename Map::value_type value_type;
+ bool operator()(const value_type& value1, const value_type& value2) const {
+ return this->comp(value1.first, value2.first);
+ }
+};
+
+int main(int, char**) {
+ typedef std::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::value_compare vc = m.value_comp();
+ CallCompMember<map_type> call_comp = m.value_comp();
+
+ assert(vc(*p1.first, *p2.first));
+ assert(call_comp(*p1.first, *p2.first));
+
+ assert(!vc(*p2.first, *p1.first));
+ assert(!call_comp(*p2.first, *p1.first));
+
+ return 0;
+}
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <map>
+
+// class value_compare
+
+// REQUIRES: c++98 || c++03 || c++11 || c++14
+
+#include <map>
+#include <string>
+
+#include "test_macros.h"
+
+int main(int, char**) {
+ typedef std::map<int, std::string> map_type;
+ typedef map_type::value_compare value_compare;
+ typedef map_type::value_type value_type;
+
+ ASSERT_SAME_TYPE(value_compare::result_type, bool);
+ ASSERT_SAME_TYPE(value_compare::first_argument_type, value_type);
+ ASSERT_SAME_TYPE(value_compare::second_argument_type, value_type);
+
+ return 0;
+}
// explicit multimap(const key_compare& comp);
-// key_compare key_comp() const;
-
#include <map>
#include <cassert>
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <map>
+
+// key_compare key_comp() const;
+
+#include <map>
+#include <cassert>
+#include <string>
+
+int main(int, char**) {
+ typedef std::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(2, "abc"));
+
+ const map_type& cm = m;
+
+ assert(cm.key_comp()(i1->first, i2->first));
+ assert(!cm.key_comp()(i2->first, i1->first));
+
+ return 0;
+}
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <map>
+
+// value_compare value_comp() const;
+
+#include <map>
+#include <cassert>
+#include <string>
+
+int main(int, char**) {
+ typedef std::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(2, "abc"));
+
+ const map_type& cm = m;
+
+ assert(cm.value_comp()(*i1, *i2));
+ assert(!cm.value_comp()(*i2, *i1));
+
+ return 0;
+}
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <map>
+
+// class value_compare
+
+// bool operator()( const value_type& lhs, const value_type& rhs ) const;
+
+#include <map>
+#include <cassert>
+#include <string>
+#include <utility>
+
+template <typename MMap>
+struct CallCompMember : MMap::value_compare {
+ CallCompMember(const typename MMap::value_compare& vc) : MMap::value_compare(vc) {}
+
+ typedef typename MMap::value_type value_type;
+ bool operator()(const value_type& value1, const value_type& value2) const {
+ return this->comp(value1.first, value2.first);
+ }
+};
+
+int main(int, char**) {
+ typedef std::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(2, "abc"));
+
+ const map_type::value_compare vc = m.value_comp();
+ CallCompMember<map_type> call_comp = m.value_comp();
+
+ assert(vc(*i1, *i2));
+ assert(call_comp(*i1, *i2));
+
+ assert(!vc(*i2, *i1));
+ assert(!call_comp(*i2, *i1));
+
+ return 0;
+}
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <map>
+
+// class value_compare
+
+// REQUIRES: c++98 || c++03 || c++11 || c++14
+
+#include <map>
+#include <string>
+
+#include "test_macros.h"
+
+int main(int, char**) {
+ typedef std::multimap<int, std::string> map_type;
+ typedef map_type::value_compare value_compare;
+ typedef map_type::value_type value_type;
+
+ ASSERT_SAME_TYPE(value_compare::result_type, bool);
+ ASSERT_SAME_TYPE(value_compare::first_argument_type, value_type);
+ ASSERT_SAME_TYPE(value_compare::second_argument_type, value_type);
+
+ return 0;
+}
// class multiset
-// explicit multiset(const value_compare& comp);
-// value_compare and key_compare are the same type for set/multiset
-
-// key_compare key_comp() const;
-// value_compare value_comp() const;
+// explicit multiset(const key_compare& comp);
#include <set>
#include <cassert>
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <set>
+
+// key_compare key_comp() const;
+// value_compare value_comp() const;
+
+#include <set>
+#include <cassert>
+
+int main(int, char**) {
+ typedef std::multiset<int> set_type;
+
+ set_type s;
+ set_type::iterator i1 = s.insert(1);
+ set_type::iterator i2 = s.insert(2);
+
+ const set_type& cs = s;
+
+ assert(cs.key_comp()(*i1, *i2));
+ assert(!cs.key_comp()(*i2, *i1));
+
+ assert(cs.value_comp()(*i1, *i2));
+ assert(!cs.value_comp()(*i2, *i1));
+
+ return 0;
+}
// class set
-// explicit set(const value_compare& comp) const;
-// value_compare and key_compare are the same type for set/multiset
-
-// key_compare key_comp() const;
-// value_compare value_comp() const;
+// explicit set(const key_compare& comp) const;
#include <set>
#include <cassert>
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <set>
+
+// key_compare key_comp() const;
+// value_compare value_comp() const;
+
+#include <set>
+#include <cassert>
+
+int main(int, char**) {
+ typedef std::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_comp()(*p1.first, *p2.first));
+ assert(!cs.key_comp()(*p2.first, *p1.first));
+
+ assert(cs.value_comp()(*p1.first, *p2.first));
+ assert(!cs.value_comp()(*p2.first, *p1.first));
+
+ return 0;
+}