string transparent test

Author: huixie90

libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/at_transparent.pass.cpp

@@ -106,6 +106,13 @@ int main(int, char**) {
     TEST_IGNORE_NODISCARD m.at(Transparent<int>{3});
     assert(transparent_used);
   }
+  {
+    // std::string and C string literal
+    using M = std::flat_map<std::string, int, std::less<>>;
+    M m{{"alpha", 1}, {"beta", 2}, {"epsilon", 1}, {"eta", 3}, {"gamma", 3}};
+    int& x = m.at("alpha");
+    assert(x == 1);
+  }
 
   return 0;
 }

libcxx/test/std/containers/container.adaptors/flat.map/flat.map.access/index_transparent.pass.cpp

@@ -94,6 +94,13 @@ int main(int, char**) {
     m[ConvertibleTransparent<int>{3}];
     assert(transparent_used);
   }
+  {
+    // std::string and C string literal
+    using M = std::flat_map<std::string, int, std::less<>>;
+    M m{{"alpha", 1}, {"beta", 2}, {"epsilon", 1}, {"eta", 3}, {"gamma", 3}};
+    int& x = m["alpha"];
+    assert(x == 1);
+  }
   {
     auto index_func = [](auto& m, auto key_arg, auto value_arg) {
       using FlatMap                             = std::decay_t<decltype(m)>;

libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_key_transparent.pass.cpp

@@ -139,6 +139,13 @@ int main(int, char**) {
     };
     test_erase_exception_guarantee(erase_transparent);
   }
+  {
+    // std::string and C string literal
+    using M = std::flat_map<std::string, int, std::less<>>;
+    M m{{"alpha", 1}, {"beta", 2}, {"epsilon", 1}, {"eta", 3}, {"gamma", 3}};
+    auto n = m.erase("beta");
+    assert(n == 1);
+  }
 
   return 0;
 }

libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_transparent.pass.cpp

@@ -163,5 +163,15 @@ int main(int, char**) {
     };
     test_emplace_exception_guarantee(insert_func_iter);
   }
+  {
+    // std::string and C string literal
+    using M = std::flat_map<std::string, int, std::less<>>;
+    M m{{"alpha", 1}, {"beta", 2}, {"epsilon", 1}, {"eta", 3}, {"gamma", 3}};
+    auto [it, inserted] = m.insert({"alpha", 1});
+    assert(!inserted);
+    assert(it == m.begin());
+    auto it2 = m.insert(m.begin(), {"beta2", 2});
+    assert(it2 == m.begin() + 2);
+  }
   return 0;
 }

libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/try_emplace_transparent.pass.cpp

@@ -160,6 +160,17 @@ int main(int, char**) {
     assert(p->second == 3);
     assert(transparent_used);
   }
+  {
+    // std::string and C string literal
+    using M = std::flat_map<std::string, int, std::less<>>;
+    M m{{"alpha", 1}, {"beta", 2}, {"epsilon", 1}, {"eta", 3}, {"gamma", 3}};
+    auto [it1, inserted] = m.try_emplace("charlie", 4);
+    assert(it1 == m.begin() + 2);
+    assert(inserted);
+
+    auto it2 = m.try_emplace(m.begin(), "beta2", 2);
+    assert(it2 == m.begin() + 2);
+  }
   {
     auto try_emplace = [](auto& m, auto key_arg, auto value_arg) {
       using M   = std::decay_t<decltype(m)>;

libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/contains_transparent.pass.cpp

@@ -14,6 +14,7 @@
 
 #include <cassert>
 #include <flat_map>
+#include <functional>
 #include <string>
 #include <utility>
 #include <deque>
@@ -67,5 +68,12 @@ int main(int, char**) {
     assert(b);
     assert(transparent_used);
   }
+  {
+    // std::string and C string literal
+    using M = std::flat_map<std::string, int, std::less<>>;
+    M m{{"alpha", 1}, {"beta", 2}, {"epsilon", 1}, {"eta", 3}, {"gamma", 3}};
+    assert(m.contains("beta") == true);
+    assert(m.contains("charlie") == false);
+  }
   return 0;
 }

libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/count_transparent.pass.cpp

@@ -15,6 +15,7 @@
 #include <cassert>
 #include <deque>
 #include <flat_map>
+#include <functional>
 #include <string>
 #include <utility>
 
@@ -67,6 +68,13 @@ int main(int, char**) {
     assert(n == 1);
     assert(transparent_used);
   }
+  {
+    // std::string and C string literal
+    using M = std::flat_map<std::string, int, std::less<>>;
+    M m{{"alpha", 1}, {"beta", 2}, {"epsilon", 1}, {"eta", 3}, {"gamma", 3}};
+    assert(m.count("alpha") == 1);
+    assert(m.count("charlie") == 0);
+  }
 
   return 0;
 }

libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/equal_range_transparent.pass.cpp

@@ -16,6 +16,7 @@
 #include <cassert>
 #include <deque>
 #include <flat_map>
+#include <functional>
 #include <string>
 #include <utility>
 
@@ -95,6 +96,14 @@ int main(int, char**) {
     assert(p.first != p.second);
     assert(transparent_used);
   }
+  {
+    // std::string and C string literal
+    using M = std::flat_map<std::string, int, std::less<>>;
+    M m{{"alpha", 1}, {"beta", 2}, {"epsilon", 1}, {"eta", 3}, {"gamma", 3}};
+    auto [first, last] = m.equal_range("beta");
+    assert(first == m.begin() + 1);
+    assert(last == m.begin() + 2);
+  }
 
   return 0;
 }

libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/find_transparent.pass.cpp

@@ -16,6 +16,7 @@
 #include <cassert>
 #include <deque>
 #include <flat_map>
+#include <functional>
 #include <string>
 #include <utility>
 
@@ -83,6 +84,13 @@ int main(int, char**) {
     assert(it != m.end());
     assert(transparent_used);
   }
+  {
+    // std::string and C string literal
+    using M = std::flat_map<std::string, int, std::less<>>;
+    M m{{"alpha", 1}, {"beta", 2}, {"epsilon", 1}, {"eta", 3}, {"gamma", 3}};
+    auto it = m.find("beta");
+    assert(it == m.begin() + 1);
+  }
 
   return 0;
 }

libcxx/test/std/containers/container.adaptors/flat.map/flat.map.operations/lower_bound_transparent.pass.cpp

@@ -16,6 +16,7 @@
 #include <cassert>
 #include <deque>
 #include <flat_map>
+#include <functional>
 #include <string>
 #include <utility>
 
@@ -90,6 +91,13 @@ int main(int, char**) {
     assert(it != m.end());
     assert(transparent_used);
   }
+  {
+    // std::string and C string literal
+    using M = std::flat_map<std::string, int, std::less<>>;
+    M m{{"alpha", 1}, {"beta", 2}, {"epsilon", 1}, {"eta", 3}, {"gamma", 3}};
+    auto it = m.lower_bound("charlie");
+    assert(it == m.begin() + 2);
+  }
 
   return 0;
 }