src/lib/fsl/types/type_converters_unittest.cc

// Copyright 2013 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 "src/lib/fsl/types/type_converters.h"

#include <zircon/compiler.h>

#include <array>

#include <gtest/gtest.h>

#include "lib/fidl/cpp/vector.h"

namespace {
struct MyInteger {
  MyInteger() = default;
  explicit MyInteger(int x) : i(x) {}
  int i;
};

static inline bool operator==(const MyInteger& lhs, const MyInteger& rhs) { return lhs.i == rhs.i; }
}  // namespace

namespace fidl {
template <>
struct TypeConverter<int, MyInteger> {
  static int Convert(const MyInteger& value) { return value.i; }
};

template <>
struct TypeConverter<MyInteger, int> {
  static MyInteger Convert(const int& value) { return MyInteger(value); }
};
}  // namespace fidl

namespace fsl {
namespace {

TEST(TypeConversionTest, Vector) {
  std::vector<int> vec = {1, 2, 3};
  fidl::VectorPtr<int> vecptr = fidl::To<fidl::VectorPtr<int>>(vec);

  EXPECT_TRUE(vecptr.has_value());
  EXPECT_TRUE(vecptr);
  EXPECT_EQ(vec, *vecptr);

  std::vector<int> vec2 = fidl::To<std::vector<int>>(vecptr);
  EXPECT_EQ(vec, vec2);
}

TEST(TypeConversionTest, Vector_DifferentTypes) {
  std::vector<MyInteger> vec;
  vec.push_back(MyInteger(1));
  vec.push_back(MyInteger(2));
  vec.push_back(MyInteger(3));

  fidl::VectorPtr<int> vecptr = fidl::To<fidl::VectorPtr<int>>(vec);
  EXPECT_TRUE(vecptr.has_value());
  for (size_t i = 0; i < 3; ++i) {
    EXPECT_EQ(fidl::To<int>(vec[i]), (*vecptr)[i]);
  }

  std::vector<MyInteger> vec2 = fidl::To<std::vector<MyInteger>>(vecptr);
  EXPECT_EQ(vec, vec2);
}

TEST(TypeConversionTest, Vector_Null) {
  fidl::VectorPtr<int> vecptr;
  std::vector<int> vec = fidl::To<std::vector<int>>(vecptr);
  EXPECT_TRUE(vec.empty());
}

TEST(TypeConversionTest, Array_Vector) {
  constexpr size_t kSize = 3;
  const int kOriginal[kSize] = {1, 2, 3};
  std::array<int, kSize> array;
  for (size_t i = 0; i < array.size(); ++i) {
    array[i] = kOriginal[i];
  }

  fidl::VectorPtr<int> vecptr = fidl::To<fidl::VectorPtr<int>>(array);
  for (size_t i = 0; i < kSize; ++i) {
    EXPECT_EQ(kOriginal[i], (*vecptr)[i]);
  }

  std::vector<int> vec = fidl::To<std::vector<int>>(array);
  for (size_t i = 0; i < kSize; ++i) {
    EXPECT_EQ(kOriginal[i], vec[i]);
  }
}

TEST(TypeConversionTest, Array_Vector_DifferentTypes) {
  constexpr size_t kSize = 3;
  const int kOriginal[kSize] = {1, 2, 3};
  std::array<int, kSize> array;
  for (size_t i = 0; i < array.size(); ++i) {
    array[i] = kOriginal[i];
  }

  fidl::VectorPtr<MyInteger> vecptr = fidl::To<fidl::VectorPtr<MyInteger>>(array);
  for (size_t i = 0; i < kSize; ++i) {
    EXPECT_EQ(MyInteger(kOriginal[i]), (*vecptr)[i]);
  }

  std::vector<MyInteger> vec = fidl::To<std::vector<MyInteger>>(array);
  for (size_t i = 0; i < kSize; ++i) {
    EXPECT_EQ(MyInteger(kOriginal[i]), vec[i]);
  }
}

TEST(TypeConversionTest, String) {
  std::string str = "hello world";
  fidl::StringPtr strptr = fidl::To<fidl::StringPtr>(str);
  EXPECT_TRUE(strptr.has_value());
  EXPECT_EQ(str, *strptr);

  std::string str2 = fidl::To<std::string>(strptr);
  EXPECT_EQ(str, str2);
}

TEST(TypeConversionTest, String_Null) {
  fidl::StringPtr strptr;
  std::string str = fidl::To<std::string>(strptr);
  EXPECT_EQ("", str);
}

}  // namespace
}  // namespace fsl