| // Copyright 2018 The Fuchsia 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 "lib/fidl/cpp/clone.h" |
| |
| #include <gtest/gtest.h> |
| |
| #ifdef __Fuchsia__ |
| #include <lib/zx/channel.h> |
| #include <lib/zx/socket.h> |
| #endif |
| |
| namespace fidl { |
| namespace { |
| |
| TEST(Clone, Control) { |
| int8_t a = 32; |
| int8_t b = 0; |
| EXPECT_EQ(ZX_OK, Clone(a, &b)); |
| EXPECT_EQ(32, b); |
| } |
| |
| #ifdef __Fuchsia__ |
| TEST(Clone, Socket) { |
| zx::socket h1, h2; |
| EXPECT_EQ(ZX_OK, zx::socket::create(0, &h1, &h2)); |
| zx::socket h; |
| |
| EXPECT_EQ(ZX_OK, Clone(h1, &h)); |
| h.reset(); |
| EXPECT_EQ(ZX_OK, Clone(h, &h2)); |
| EXPECT_FALSE(h2.is_valid()); |
| } |
| |
| TEST(Clone, Channel) { |
| zx::channel h1, h2; |
| EXPECT_EQ(ZX_OK, zx::channel::create(0, &h1, &h2)); |
| zx::channel h; |
| |
| EXPECT_EQ(ZX_ERR_ACCESS_DENIED, Clone(h1, &h)); |
| EXPECT_EQ(ZX_OK, Clone(h, &h2)); |
| EXPECT_FALSE(h2.is_valid()); |
| } |
| #endif |
| |
| TEST(Clone, VectorPtrPrimitive) { |
| VectorPtr<int> intvec1({1, 2, 3, 4}); |
| VectorPtr<int> intvec2; |
| |
| EXPECT_TRUE(intvec1.has_value()); |
| EXPECT_FALSE(intvec2.has_value()); |
| EXPECT_EQ(ZX_OK, Clone(intvec1, &intvec2)); |
| EXPECT_TRUE(intvec1.has_value()); |
| EXPECT_TRUE(intvec2.has_value()); |
| EXPECT_EQ(intvec1->size(), 4u); |
| EXPECT_EQ(intvec2->size(), 4u); |
| EXPECT_EQ(intvec2->at(0), 1); |
| EXPECT_EQ(intvec2->at(1), 2); |
| EXPECT_EQ(intvec2->at(2), 3); |
| EXPECT_EQ(intvec2->at(3), 4); |
| |
| intvec1->push_back(5); |
| EXPECT_EQ(intvec1->size(), 5u); |
| EXPECT_EQ(intvec2->size(), 4u); |
| |
| VectorPtr<int> intvec3; |
| EXPECT_TRUE(intvec2.has_value()); |
| EXPECT_FALSE(intvec3.has_value()); |
| EXPECT_EQ(ZX_OK, Clone(intvec3, &intvec2)); |
| EXPECT_FALSE(intvec2.has_value()); |
| EXPECT_FALSE(intvec3.has_value()); |
| |
| VectorPtr<int> empty; |
| empty.emplace(); |
| EXPECT_TRUE(empty.has_value()); |
| EXPECT_EQ(empty->size(), 0u); |
| auto cloned_empty = fidl::Clone(empty); |
| EXPECT_TRUE(cloned_empty.has_value()); |
| EXPECT_EQ(cloned_empty->size(), 0u); |
| } |
| |
| TEST(Clone, VectorPtrString) { |
| VectorPtr<std::string> strvec1({"satu", "dua", "tiga", "empat"}); |
| VectorPtr<std::string> strvec2; |
| VectorPtr<std::string> strvec3; |
| |
| EXPECT_TRUE(strvec1.has_value()); |
| EXPECT_FALSE(strvec2.has_value()); |
| EXPECT_EQ(ZX_OK, Clone(strvec1, &strvec2)); |
| EXPECT_TRUE(strvec1.has_value()); |
| EXPECT_TRUE(strvec2.has_value()); |
| EXPECT_EQ(strvec1->size(), 4u); |
| EXPECT_EQ(strvec2->size(), 4u); |
| EXPECT_EQ(strvec2->at(0), "satu"); |
| EXPECT_EQ(strvec2->at(1), "dua"); |
| EXPECT_EQ(strvec2->at(2), "tiga"); |
| EXPECT_EQ(strvec2->at(3), "empat"); |
| |
| strvec1->push_back("lima"); |
| EXPECT_EQ(strvec1->size(), 5u); |
| EXPECT_EQ(strvec2->size(), 4u); |
| |
| EXPECT_TRUE(strvec2.has_value()); |
| EXPECT_FALSE(strvec3.has_value()); |
| EXPECT_EQ(ZX_OK, Clone(strvec3, &strvec2)); |
| EXPECT_FALSE(strvec2.has_value()); |
| EXPECT_FALSE(strvec3.has_value()); |
| |
| VectorPtr<std::string> empty; |
| empty.emplace(); |
| EXPECT_TRUE(empty.has_value()); |
| EXPECT_EQ(empty->size(), 0u); |
| auto cloned_empty = fidl::Clone(empty); |
| EXPECT_TRUE(cloned_empty.has_value()); |
| EXPECT_EQ(cloned_empty->size(), 0u); |
| } |
| |
| // There's a different implementation for Clone<VectorPtr<T>> for strings and |
| // primitives vs all other types. |
| TEST(Clone, VectorPtrVector) { |
| VectorPtr<std::vector<int>> vecvec1({std::vector<int>(1, 1), std::vector<int>(2, 2), |
| std::vector<int>(3, 3), std::vector<int>(4, 4)}); |
| VectorPtr<std::vector<int>> vecvec2; |
| VectorPtr<std::vector<int>> vecvec3; |
| |
| EXPECT_TRUE(vecvec1.has_value()); |
| EXPECT_FALSE(vecvec2.has_value()); |
| EXPECT_EQ(ZX_OK, Clone(vecvec1, &vecvec2)); |
| EXPECT_TRUE(vecvec1.has_value()); |
| EXPECT_TRUE(vecvec2.has_value()); |
| EXPECT_EQ(vecvec1->size(), 4u); |
| EXPECT_EQ(vecvec2->size(), 4u); |
| EXPECT_EQ(vecvec2->at(0).size(), 1u); |
| EXPECT_EQ(vecvec2->at(1).size(), 2u); |
| EXPECT_EQ(vecvec2->at(2).size(), 3u); |
| EXPECT_EQ(vecvec2->at(3).size(), 4u); |
| |
| vecvec1->push_back(std::vector<int>(5, 5)); |
| EXPECT_EQ(vecvec1->size(), 5u); |
| EXPECT_EQ(vecvec2->size(), 4u); |
| |
| EXPECT_TRUE(vecvec2.has_value()); |
| EXPECT_FALSE(vecvec3.has_value()); |
| EXPECT_EQ(ZX_OK, Clone(vecvec3, &vecvec2)); |
| EXPECT_FALSE(vecvec2.has_value()); |
| EXPECT_FALSE(vecvec3.has_value()); |
| |
| VectorPtr<std::vector<int>> empty; |
| empty.emplace(); |
| EXPECT_TRUE(empty.has_value()); |
| EXPECT_EQ(empty->size(), 0u); |
| auto cloned_empty = fidl::Clone(empty); |
| EXPECT_TRUE(cloned_empty.has_value()); |
| EXPECT_EQ(cloned_empty->size(), 0u); |
| } |
| |
| } // namespace |
| } // namespace fidl |