Home | History | Annotate | Download | only in tests 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "mojo/public/cpp/bindings/array.h"
      6 
      7 #include "mojo/public/cpp/bindings/lib/serialization.h"
      8 #include "mojo/public/cpp/bindings/tests/array_common_test.h"
      9 #include "mojo/public/cpp/bindings/tests/container_test_util.h"
     10 #include "testing/gtest/include/gtest/gtest.h"
     11 
     12 namespace mojo {
     13 namespace test {
     14 namespace {
     15 
     16 using ArrayTest = testing::Test;
     17 
     18 ARRAY_COMMON_TEST(Array, NullAndEmpty)
     19 ARRAY_COMMON_TEST(Array, Basic)
     20 ARRAY_COMMON_TEST(Array, Bool)
     21 ARRAY_COMMON_TEST(Array, Handle)
     22 ARRAY_COMMON_TEST(Array, HandlesAreClosed)
     23 ARRAY_COMMON_TEST(Array, Clone)
     24 ARRAY_COMMON_TEST(Array, Serialization_ArrayOfPOD)
     25 ARRAY_COMMON_TEST(Array, Serialization_EmptyArrayOfPOD)
     26 ARRAY_COMMON_TEST(Array, Serialization_ArrayOfArrayOfPOD)
     27 ARRAY_COMMON_TEST(Array, Serialization_ArrayOfBool)
     28 ARRAY_COMMON_TEST(Array, Serialization_ArrayOfString)
     29 ARRAY_COMMON_TEST(Array, Resize_Copyable)
     30 ARRAY_COMMON_TEST(Array, Resize_MoveOnly)
     31 
     32 TEST_F(ArrayTest, PushBack_Copyable) {
     33   ASSERT_EQ(0u, CopyableType::num_instances());
     34   Array<CopyableType> array(2);
     35   array = nullptr;
     36   std::vector<CopyableType*> value_ptrs;
     37   size_t capacity = array.storage().capacity();
     38   for (size_t i = 0; i < capacity; i++) {
     39     CopyableType value;
     40     value_ptrs.push_back(value.ptr());
     41     array.push_back(value);
     42     ASSERT_EQ(i + 1, array.size());
     43     ASSERT_EQ(i + 1, value_ptrs.size());
     44     EXPECT_EQ(array.size() + 1, CopyableType::num_instances());
     45     EXPECT_TRUE(array[i].copied());
     46     EXPECT_EQ(value_ptrs[i], array[i].ptr());
     47     array[i].ResetCopied();
     48     EXPECT_TRUE(array);
     49   }
     50   {
     51     CopyableType value;
     52     value_ptrs.push_back(value.ptr());
     53     array.push_back(value);
     54     EXPECT_EQ(array.size() + 1, CopyableType::num_instances());
     55   }
     56   ASSERT_EQ(capacity + 1, array.size());
     57   EXPECT_EQ(array.size(), CopyableType::num_instances());
     58 
     59   for (size_t i = 0; i < array.size(); i++) {
     60     EXPECT_TRUE(array[i].copied());
     61     EXPECT_EQ(value_ptrs[i], array[i].ptr());
     62   }
     63   array = nullptr;
     64   EXPECT_EQ(0u, CopyableType::num_instances());
     65 }
     66 
     67 TEST_F(ArrayTest, PushBack_MoveOnly) {
     68   ASSERT_EQ(0u, MoveOnlyType::num_instances());
     69   Array<MoveOnlyType> array(2);
     70   array = nullptr;
     71   std::vector<MoveOnlyType*> value_ptrs;
     72   size_t capacity = array.storage().capacity();
     73   for (size_t i = 0; i < capacity; i++) {
     74     MoveOnlyType value;
     75     value_ptrs.push_back(value.ptr());
     76     array.push_back(std::move(value));
     77     ASSERT_EQ(i + 1, array.size());
     78     ASSERT_EQ(i + 1, value_ptrs.size());
     79     EXPECT_EQ(array.size() + 1, MoveOnlyType::num_instances());
     80     EXPECT_TRUE(array[i].moved());
     81     EXPECT_EQ(value_ptrs[i], array[i].ptr());
     82     array[i].ResetMoved();
     83     EXPECT_TRUE(array);
     84   }
     85   {
     86     MoveOnlyType value;
     87     value_ptrs.push_back(value.ptr());
     88     array.push_back(std::move(value));
     89     EXPECT_EQ(array.size() + 1, MoveOnlyType::num_instances());
     90   }
     91   ASSERT_EQ(capacity + 1, array.size());
     92   EXPECT_EQ(array.size(), MoveOnlyType::num_instances());
     93 
     94   for (size_t i = 0; i < array.size(); i++) {
     95     EXPECT_TRUE(array[i].moved());
     96     EXPECT_EQ(value_ptrs[i], array[i].ptr());
     97   }
     98   array = nullptr;
     99   EXPECT_EQ(0u, MoveOnlyType::num_instances());
    100 }
    101 
    102 TEST_F(ArrayTest, MoveFromAndToSTLVector_Copyable) {
    103   std::vector<CopyableType> vec1(1);
    104   Array<CopyableType> arr(std::move(vec1));
    105   ASSERT_EQ(1u, arr.size());
    106   ASSERT_FALSE(arr[0].copied());
    107 
    108   std::vector<CopyableType> vec2(arr.PassStorage());
    109   ASSERT_EQ(1u, vec2.size());
    110   ASSERT_FALSE(vec2[0].copied());
    111 
    112   ASSERT_EQ(0u, arr.size());
    113   ASSERT_TRUE(arr.is_null());
    114 }
    115 
    116 TEST_F(ArrayTest, MoveFromAndToSTLVector_MoveOnly) {
    117   std::vector<MoveOnlyType> vec1(1);
    118   Array<MoveOnlyType> arr(std::move(vec1));
    119 
    120   ASSERT_EQ(1u, arr.size());
    121 
    122   std::vector<MoveOnlyType> vec2(arr.PassStorage());
    123   ASSERT_EQ(1u, vec2.size());
    124 
    125   ASSERT_EQ(0u, arr.size());
    126   ASSERT_TRUE(arr.is_null());
    127 }
    128 
    129 }  // namespace
    130 }  // namespace test
    131 }  // namespace mojo
    132