Mojo C++ bindings: Fix bug: array<>, map<> should only initialize elements if they're not null when…

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/lib/map_serialization.h"
 #include "mojo/public/cpp/bindings/lib/validate_params.h"
 #include "mojo/public/cpp/bindings/map.h"
 #include "mojo/public/cpp/bindings/string.h"
 #include "mojo/public/cpp/bindings/tests/container_test_util.h"
 #include "mojo/public/cpp/environment/environment.h"
+#include "mojo/public/interfaces/bindings/tests/rect.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace test {
 
 namespace {
 
 using mojo::internal::Array_Data;
 using mojo::internal::ArrayValidateParams;
 using mojo::internal::FixedBufferForTesting;
 using mojo::internal::Map_Data;
 using mojo::internal::String_Data;
+using mojo::internal::ValidationError;
 
 struct StringIntData {
   const char* string_data;
   int int_data;
 } kStringIntData[] = {
       {"one", 1},
       {"two", 2},
       {"three", 3},
       {"four", 4},
 };
@@ skipping 212 matching lines @@
 TEST_F(MapTest, ArrayOfMap) {
   {
     auto array = Array<Map<int32_t, int8_t>>::New(1);
     array[0].insert(1, 42);
 
     size_t size = GetSerializedSize_(array);
     FixedBufferForTesting buf(size);
     Array_Data<Map_Data<int32_t, int8_t>*>* data = nullptr;
     ArrayValidateParams validate_params(
         0, false, new ArrayValidateParams(0, false, nullptr));
-    EXPECT_EQ(internal::ValidationError::NONE,
+    EXPECT_EQ(ValidationError::NONE,
               SerializeArray_(&array, &buf, &data, &validate_params));
 
     Array<Map<int32_t, int8_t>> deserialized_array;
     Deserialize_(data, &deserialized_array);
 
     ASSERT_EQ(1u, deserialized_array.size());
     ASSERT_EQ(1u, deserialized_array[0].size());
     ASSERT_EQ(42, deserialized_array[0].at(1));
   }
 
   {
     auto array = Array<Map<String, Array<bool>>>::New(1);
     auto map_value = Array<bool>::New(2);
     map_value[0] = false;
     map_value[1] = true;
     array[0].insert("hello world", map_value.Pass());
 
     size_t size = GetSerializedSize_(array);
     FixedBufferForTesting buf(size);
     Array_Data<Map_Data<String_Data*, Array_Data<bool>*>*>* data = nullptr;
     ArrayValidateParams validate_params(
         0, false, new ArrayValidateParams(
                       0, false, new ArrayValidateParams(0, false, nullptr)));
-    EXPECT_EQ(internal::ValidationError::NONE,
+    EXPECT_EQ(ValidationError::NONE,
               SerializeArray_(&array, &buf, &data, &validate_params));
 
     Array<Map<String, Array<bool>>> deserialized_array;
     Deserialize_(data, &deserialized_array);
 
     ASSERT_EQ(1u, deserialized_array.size());
     ASSERT_EQ(1u, deserialized_array[0].size());
     ASSERT_FALSE(deserialized_array[0].at("hello world")[0]);
     ASSERT_TRUE(deserialized_array[0].at("hello world")[1]);
   }
@@ skipping 76 matching lines @@
     ASSERT_NE(test_map2.find(iter.GetKey()), test_map2.end());
     EXPECT_EQ(test_map.at(iter.GetKey()), test_map.at(iter.GetKey()));
   }
 
   for (auto iter = test_map2.cbegin(); iter != test_map2.cend(); ++iter) {
     ASSERT_NE(test_map.find(iter.GetKey()), test_map.end());
     EXPECT_EQ(test_map2.at(iter.GetKey()), test_map2.at(iter.GetKey()));
   }
 }
 
+// Test serialization/deserialization of a map with null elements.
+TEST_F(MapTest, Serialization_MapOfNullableStructs) {
+  ArrayValidateParams validate_nullable(2, true, nullptr);
+  ArrayValidateParams validate_non_nullable(2, false, nullptr);
+
+  Map<uint32_t, RectPtr> map;
+  map[0] = RectPtr();
+  map[1] = Rect::New();
+  map[1]->x = 1;
+  map[1]->y = 2;
+  map[1]->width = 3;
+  map[1]->height = 4;
+  EXPECT_TRUE(map[0].is_null());
+  EXPECT_TRUE(!map[1].is_null());
+
+  size_t size = GetSerializedSize_(map);
+  EXPECT_EQ(8u +                       // map header
+                (8u + 8u) +            // pointers to keys and values array
+                (8u + 2 * 4u) +        // keys array data
+                (8u +                  // values array data
+                 (8u) +                // 1 null value
+                 (8u + 8U + 4 * 4U)),  // 1 Rect value
+            size);
+
+  // 1. Should not be able to serialize null elements.
+  {
+    FixedBufferForTesting buf(size);
+    Map_Data<int32_t, Rect::Data_*>* data = nullptr;
+    EXPECT_EQ(ValidationError::UNEXPECTED_NULL_POINTER,
+              SerializeMap_(&map, &buf, &data, &validate_non_nullable));
+  }
+
+  // 2. Successfully serialize null elements.
+  FixedBufferForTesting buf(size);
+  Map_Data<int32_t, Rect::Data_*>* data = nullptr;
+  EXPECT_EQ(ValidationError::NONE,
+            SerializeMap_(&map, &buf, &data, &validate_nullable));
+  EXPECT_NE(nullptr, data);
+
+  // 3. Deserialize deserialize null elements.
+  Map<uint32_t, RectPtr> map2;
+  EXPECT_EQ(0u, map2.size());
+  EXPECT_TRUE(map2.is_null());
+  Deserialize_(data, &map2);
+  EXPECT_EQ(2u, map2.size());
+  EXPECT_FALSE(map2.is_null());
+  EXPECT_TRUE(map2[0].is_null());
+  EXPECT_FALSE(map2[1].is_null());
+  EXPECT_EQ(1, map2[1]->x);
+  EXPECT_EQ(2, map2[1]->y);
+  EXPECT_EQ(3, map2[1]->width);
+  EXPECT_EQ(4, map2[1]->height);
+}
+
 }  // namespace
 }  // namespace test
 }  // namespace mojo