mojo: Switch the clipboard interface over to using map<>.

mojo/public/cpp/bindings/tests/map_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "mojo/public/cpp/bindings/array.h"
 #include "mojo/public/cpp/bindings/lib/array_serialization.h"
 #include "mojo/public/cpp/bindings/lib/bindings_internal.h"
 #include "mojo/public/cpp/bindings/lib/fixed_buffer.h"
 #include "mojo/public/cpp/bindings/map.h"
 #include "mojo/public/cpp/bindings/string.h"
@@ skipping 32 matching lines @@
   Map<String, int> map;
   for (size_t i = 0; i < kStringIntDataSize; ++i)
     map.insert(kStringIntData[i].string_data, kStringIntData[i].int_data);
 
   for (size_t i = 0; i < kStringIntDataSize; ++i) {
     EXPECT_EQ(kStringIntData[i].int_data,
               map.at(kStringIntData[i].string_data));
   }
 }
 
+TEST_F(MapTest, TestIndexOperator) {
+  Map<String, int> map;
+  for (size_t i = 0; i < kStringIntDataSize; ++i)
+    map[kStringIntData[i].string_data] = kStringIntData[i].int_data;
+
+  for (size_t i = 0; i < kStringIntDataSize; ++i) {
+    EXPECT_EQ(kStringIntData[i].int_data,
+              map.at(kStringIntData[i].string_data));
+  }
+}
+
+TEST_F(MapTest, TestIndexOperatorAsRValue) {
+  Map<String, int> map;
+  for (size_t i = 0; i < kStringIntDataSize; ++i)
+    map.insert(kStringIntData[i].string_data, kStringIntData[i].int_data);
+
+  for (size_t i = 0; i < kStringIntDataSize; ++i) {
+    EXPECT_EQ(kStringIntData[i].int_data, map[kStringIntData[i].string_data]);
+  }
+}
+
+TEST_F(MapTest, TestIndexOperatorMoveOnly) {
+  ASSERT_EQ(0u, MoveOnlyType::num_instances());
+  mojo::Map<mojo::String, mojo::Array<int32_t>> map;
+  std::vector<MoveOnlyType*> value_ptrs;
+
+  for (size_t i = 0; i < kStringIntDataSize; ++i) {
+    const char* key = kStringIntData[i].string_data;
+    Array<int32_t> array(1);
+    array[0] = kStringIntData[i].int_data;
+    map[key] = array.Pass();
+    EXPECT_TRUE(map);
+  }
+
+  // We now read back that data, to test the behavior of operator[].
+  for (size_t i = 0; i < kStringIntDataSize; ++i) {
+    auto it = map.find(kStringIntData[i].string_data);
+    ASSERT_TRUE(it != map.end());
+    ASSERT_EQ(1u, it.GetValue().size());
+    EXPECT_EQ(kStringIntData[i].int_data, it.GetValue()[0]);
+  }
+}
+
 TEST_F(MapTest, ConstructedFromArray) {
   Array<String> keys(kStringIntDataSize);
   Array<int> values(kStringIntDataSize);
   for (size_t i = 0; i < kStringIntDataSize; ++i) {
     keys[i] = kStringIntData[i].string_data;
     values[i] = kStringIntData[i].int_data;
   }
 
   Map<String, int> map(keys.Pass(), values.Pass());
 
@@ skipping 83 matching lines @@
     EXPECT_TRUE(map.at(key).moved());
     EXPECT_EQ(value_ptrs[i], map.at(key).ptr());
     map.at(key).ResetMoved();
     EXPECT_TRUE(map);
   }
 
   // std::map doesn't have a capacity() method like std::vector so this test is
   // a lot more boring.
 
   map.reset();
-  EXPECT_EQ(0u, CopyableType::num_instances());
+  EXPECT_EQ(0u, MoveOnlyType::num_instances());
+}
+
+TEST_F(MapTest, IndexOperator_MoveOnly) {
+  ASSERT_EQ(0u, MoveOnlyType::num_instances());
+  mojo::Map<mojo::String, MoveOnlyType> map;
+  std::vector<MoveOnlyType*> value_ptrs;
+
+  for (size_t i = 0; i < kStringIntDataSize; ++i) {
+    const char* key = kStringIntData[i].string_data;
+    MoveOnlyType value;
+    value_ptrs.push_back(value.ptr());
+    map[key] = value.Pass();
+    ASSERT_EQ(i + 1, map.size());
+    ASSERT_EQ(i + 1, value_ptrs.size());
+    EXPECT_EQ(map.size() + 1, MoveOnlyType::num_instances());
+    EXPECT_TRUE(map.at(key).moved());
+    EXPECT_EQ(value_ptrs[i], map.at(key).ptr());
+    map.at(key).ResetMoved();
+    EXPECT_TRUE(map);
+  }
+
+  // std::map doesn't have a capacity() method like std::vector so this test is
+  // a lot more boring.
+
+  map.reset();
+  EXPECT_EQ(0u, MoveOnlyType::num_instances());
 }
 
 TEST_F(MapTest, STLToMojo) {
   std::map<std::string, int> stl_data;
   for (size_t i = 0; i < kStringIntDataSize; ++i)
     stl_data[kStringIntData[i].string_data] = kStringIntData[i].int_data;
 
   Map<String, int32_t> mojo_data = Map<String, int32_t>::From(stl_data);
 
   for (size_t i = 0; i < kStringIntDataSize; ++i) {
@@ skipping 162 matching lines @@
 
   ASSERT_EQ(1u, to_receive->second.size());
   ASSERT_EQ(1u, to_receive->second[0].size());
   ASSERT_FALSE(to_receive->second[0].at("hello world")[0]);
   ASSERT_TRUE(to_receive->second[0].at("hello world")[1]);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo