// Copyright 2019 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 "wire_parser.h"

#include <fuchsia/sys/cpp/fidl.h>
#include <lib/async-loop/cpp/loop.h>

#include <iostream>
#include <string>
#include <vector>

#include "gtest/gtest.h"
#include "lib/fidl/cpp/test/frobinator_impl.h"
#include "library_loader.h"
#include "message_decoder.h"
#include "rapidjson/stringbuffer.h"
#include "rapidjson/writer.h"
#include "test/fidlcat/examples/cpp/fidl.h"
#include "tools/fidlcat/lib/library_loader_test_data.h"
#include "wire_object.h"
#include "wire_parser.h"

namespace fidlcat {

// Stolen from //sdk/lib/fidl/cpp/test/async_loop_for_test.{h,cc}; cc
// is not public

class AsyncLoopForTestImpl;

class AsyncLoopForTest {
 public:
  // The AsyncLoopForTest constructor should also call
  // async_set_default_dispatcher() with the chosen dispatcher implementation.
  AsyncLoopForTest();
  ~AsyncLoopForTest();

  // This call matches the behavior of async_loop_run_until_idle().
  zx_status_t RunUntilIdle();

  // This call matches the behavior of async_loop_run().
  zx_status_t Run();

  // Returns the underlying async_t.
  async_dispatcher_t* dispatcher();

 private:
  std::unique_ptr<AsyncLoopForTestImpl> impl_;
};

class AsyncLoopForTestImpl {
 public:
  AsyncLoopForTestImpl() : loop_(&kAsyncLoopConfigAttachToThread) {}
  ~AsyncLoopForTestImpl() = default;

  async::Loop* loop() { return &loop_; }

 private:
  async::Loop loop_;
};

AsyncLoopForTest::AsyncLoopForTest()
    : impl_(std::make_unique<AsyncLoopForTestImpl>()) {}

AsyncLoopForTest::~AsyncLoopForTest() = default;

zx_status_t AsyncLoopForTest::RunUntilIdle() {
  return impl_->loop()->RunUntilIdle();
}

zx_status_t AsyncLoopForTest::Run() { return impl_->loop()->Run(); }

async_dispatcher_t* AsyncLoopForTest::dispatcher() {
  return impl_->loop()->dispatcher();
}

LibraryLoader* InitLoader() {
  std::vector<std::unique_ptr<std::istream>> library_files;
  fidlcat_test::ExampleMap examples;
  for (auto element : examples.map()) {
    std::unique_ptr<std::istream> file = std::make_unique<std::istringstream>(
        std::istringstream(element.second));
    library_files.push_back(std::move(file));
  }
  LibraryReadError err;
  return new LibraryLoader(library_files, &err);
}

LibraryLoader* GetLoader() {
  static LibraryLoader* loader = InitLoader();
  return loader;
}

class WireParserTest : public ::testing::Test {
 protected:
  void SetUp() override {
    loader_ = GetLoader();
    ASSERT_NE(loader_, nullptr);
  };
  LibraryLoader* loader_;
};

// The tests in this file work the following way:
// 1) Create a channel.
// 2) Bind an interface pointer to the client side of that channel.
// 3) Listen at the other end of the channel for the message.
// 4) Convert the message to JSON using the JSON message converter, and check
//    that the results look as expected.

// This binds |invoke| to one end of a channel, invokes it, and drops the wire
// format bits it picks up off the other end into |message|.
template <class T>
void InterceptRequest(fidl::Message& message,
                      std::function<void(fidl::InterfacePtr<T>&)> invoke) {
  AsyncLoopForTest loop;

  zx::channel h1, h2;
  EXPECT_EQ(ZX_OK, zx::channel::create(0, &h1, &h2));
  fidl::InterfacePtr<T> ptr;
  int error_count = 0;
  ptr.set_error_handler([&error_count](zx_status_t status) {
    EXPECT_EQ(ZX_ERR_INVALID_ARGS, status);
    ++error_count;
  });

  EXPECT_EQ(ZX_OK, ptr.Bind(std::move(h1)));

  invoke(ptr);

  loop.RunUntilIdle();

  EXPECT_EQ(ZX_OK, message.Read(h2.get(), 0));
}

TEST_F(WireParserTest, ParseSingleString) {
  fidl::MessageBuffer buffer;
  fidl::Message message = buffer.CreateEmptyMessage();

  InterceptRequest<fidl::test::frobinator::Frobinator>(
      message, [](fidl::InterfacePtr<fidl::test::frobinator::Frobinator>& ptr) {
        ptr->Grob("one", [](fidl::StringPtr value) { FAIL(); });
      });

  fidl_message_header_t header = message.header();

  const InterfaceMethod* method;
  ASSERT_TRUE(loader_->GetByOrdinal(header.ordinal, &method));
  ASSERT_EQ("Grob", method->name());
  rapidjson::Document actual;
  fidlcat::RequestToJSON(method, message, actual);

  rapidjson::Document expected;
  expected.Parse(R"JSON({"value":"one"})JSON");
  ASSERT_EQ(expected, actual);
}

// This is a general-purpose macro for calling InterceptRequest and checking its
// results.  It can be generalized to a wide variety of types (and is, below).
// It checks for successful parsing, as well as failure when parsing truncated
// values.
// _iface is the interface method name on examples::this_is_an_interface
//    (TODO: generalize which interface to use)
// _json_value is a JSON representation of the value in the previous parameter.
// The remaining parameters are the parameters to _iface to generate the
// _json_value.
#define TEST_WIRE_TO_JSON_BODY(_iface, _json_value, ...)                       \
  do {                                                                         \
    fidl::MessageBuffer buffer;                                                \
    fidl::Message message = buffer.CreateEmptyMessage();                       \
    using test::fidlcat::examples::this_is_an_interface;                       \
    InterceptRequest<this_is_an_interface>(                                    \
        message, [&](fidl::InterfacePtr<this_is_an_interface>& ptr) {          \
          ptr->_iface(__VA_ARGS__);                                            \
        });                                                                    \
                                                                               \
    fidl_message_header_t header = message.header();                           \
                                                                               \
    const InterfaceMethod* method;                                             \
    ASSERT_TRUE(loader_->GetByOrdinal(header.ordinal, &method));               \
    ASSERT_EQ(#_iface, method->name());                                        \
                                                                               \
    rapidjson::Document actual;                                                \
    ASSERT_TRUE(fidlcat::RequestToJSON(method, message, actual))               \
        << "Could not convert message to json";                                \
    rapidjson::StringBuffer actual_string;                                     \
    rapidjson::Writer<rapidjson::StringBuffer> actual_w(actual_string);        \
    actual.Accept(actual_w);                                                   \
                                                                               \
    rapidjson::Document expected;                                              \
    std::string expected_source = _json_value;                                 \
    expected.Parse(expected_source.c_str());                                   \
    rapidjson::StringBuffer expected_string;                                   \
    rapidjson::Writer<rapidjson::StringBuffer> expected_w(expected_string);    \
    expected.Accept(expected_w);                                               \
                                                                               \
    ASSERT_EQ(expected, actual)                                                \
        << "expected = " << expected_string.GetString() << " ("                \
        << expected_source << ")"                                              \
        << " and actual = " << actual_string.GetString();                      \
                                                                               \
    for (uint32_t actual = 0; actual < message.bytes().actual(); ++actual) {   \
      fidl::HandlePart handles(message.handles().data(),                       \
                               message.handles().capacity(),                   \
                               message.handles().actual());                    \
      fidl::BytePart bytes(message.bytes().data(), message.bytes().capacity(), \
                           actual);                                            \
      fidl::Message message_copy(std::move(bytes), std::move(handles));        \
      MessageDecoder decoder(message_copy, /*output_errors=*/false);           \
      std::unique_ptr<Object> object =                                         \
          decoder.DecodeMessage(*method->request());                           \
      ASSERT_TRUE(decoder.HasError())                                          \
          << "expect decoding error for buffer size " << actual                \
          << " instead of " << message.bytes().actual();                       \
    }                                                                          \
                                                                               \
    for (uint32_t actual = 0; message.handles().actual() > actual; actual++) { \
      fidl::HandlePart handles(message.handles().data(),                       \
                               message.handles().capacity(), actual);          \
      fidl::BytePart bytes(message.bytes().data(), message.bytes().capacity(), \
                           message.bytes().actual());                          \
      fidl::Message message_copy(std::move(bytes), std::move(handles));        \
      MessageDecoder decoder(message_copy, /*output_errors=*/false);           \
      std::unique_ptr<Object> object =                                         \
          decoder.DecodeMessage(*method->request());                           \
      ASSERT_TRUE(decoder.HasError())                                          \
          << "expect decoding error for handle size " << actual                \
          << " instead of " << message.handles().actual();                     \
    }                                                                          \
  } while (0)

// This is a convenience wrapper for calling TEST_WIRE_TO_JSON_BODY that simply
// executes the code in a test.
// _testname is the name of the test (prepended by Parse in the output)
// _iface is the interface method name on examples::this_is_an_interface
//    (TODO: generalize which interface to use)
// _json_value is a JSON representation of the value in the previous parameter.
// The remaining parameters are the parameters to _iface to generate the
// _json_value.
#define TEST_WIRE_TO_JSON(_testname, _iface, _json_value, ...) \
  TEST_F(WireParserTest, Parse##_testname) {                   \
    TEST_WIRE_TO_JSON_BODY(_iface, _json_value, __VA_ARGS__);  \
  }

namespace {

std::string RawPair(std::string key, std::string value) {
  std::string result = "{\"";
  result.append(key);
  result.append("\":");
  result.append(value);
  result.append("}");
  return result;
}

}  // namespace

// Scalar Tests

namespace {

template <class T>
std::string SingleToJson(std::string key, T value) {
  return RawPair(key, "\"" + std::to_string(value) + "\"");
}

}  // namespace

#define TEST_SINGLE(_iface, _key, _value) \
  TEST_WIRE_TO_JSON(_iface, _iface, SingleToJson(#_key, _value), _value)

TEST_SINGLE(Float32, f32, 0.25)
TEST_SINGLE(Float64, f64, 9007199254740992.0)
TEST_SINGLE(Int8, i8, std::numeric_limits<int8_t>::min())
TEST_SINGLE(Int16, i16, std::numeric_limits<int16_t>::min())
TEST_SINGLE(Int32, i32, std::numeric_limits<int32_t>::min())
TEST_SINGLE(Int64, i64, std::numeric_limits<int64_t>::min())
TEST_SINGLE(Uint8, i8, std::numeric_limits<uint8_t>::max())
TEST_SINGLE(Uint16, i16, std::numeric_limits<uint16_t>::max())
TEST_SINGLE(Uint32, i32, std::numeric_limits<uint32_t>::max())
TEST_SINGLE(Uint64, i64, std::numeric_limits<uint64_t>::max())

TEST_WIRE_TO_JSON(SingleBool, Bool, R"({"b":"true"})", true)

TEST_WIRE_TO_JSON(TwoTuple, Complex, R"({"real":"1", "imaginary":"2"})", 1, 2);

TEST_WIRE_TO_JSON(StringInt, StringInt, R"({"s":"groucho", "i32":"4"})",
                  "groucho", 4)

// Vector / Array Tests

namespace {
int32_t one_param[1] = {1};
int32_t two_params[2] = {1, 2};

template <class T, size_t N>
std::array<T, N> ToArray(T ts[N]) {
  ::std::array<T, N> ret;
  std::copy_n(&ts[0], N, ret.begin());
  return ret;
}

// Converts an array to a VectorPtr, so that it can be passed to a FIDL
// interface.
template <class T>
fidl::VectorPtr<T> ToVector(T ts[], size_t n) {
  std::vector<T> vec;
  for (size_t i = 0; i < n; i++) {
    vec.push_back(ts[i]);
  }
  ::fidl::VectorPtr<T> ret(vec);
  return ret;
}

}  // namespace

TEST_WIRE_TO_JSON(Array1, Array1, R"({"b_1":["1"]})",
                  (ToArray<int32_t, 1>(one_param)));

TEST_WIRE_TO_JSON(Array2, Array2, R"({"b_2":["1", "2"]})",
                  (ToArray<int32_t, 2>(two_params)));

TEST_WIRE_TO_JSON(VectorOneElt, Vector, R"({"v_1":["1"]})",
                  (ToVector<int32_t>(one_param, 1)));

std::string NullPair(std::string key, void* v) { return RawPair(key, "null"); }

TEST_WIRE_TO_JSON(NullVector, Vector, R"({"v_1": null})", nullptr)

namespace {

std::array<std::string, 2> TwoStringArrayFromVals(std::string v1,
                                                  std::string v2) {
  std::array<std::string, 2> brother_array;
  brother_array[0] = v1;
  brother_array[1] = v2;
  return brother_array;
}

}  // namespace

TEST_WIRE_TO_JSON(TwoStringArrayInt, TwoStringArrayInt,
                  R"({"arr":["harpo","chico"], "i32":"1"})",
                  TwoStringArrayFromVals("harpo", "chico"), 1)

namespace {

fidl::VectorPtr<std::string> TwoStringVectorFromVals(std::string v1,
                                                     std::string v2) {
  std::vector<std::string> brother_vector;
  brother_vector.push_back(v1);
  brother_vector.push_back(v2);
  return fidl::VectorPtr(brother_vector);
}

}  // namespace

TEST_WIRE_TO_JSON(TwoStringVectorInt, TwoStringVectorInt,
                  R"({"vec":["harpo", "chico"], "i32":"1"})",
                  TwoStringVectorFromVals("harpo", "chico"), 1)

// Struct Tests

namespace {

class StructSupport {
 public:
  StructSupport() {
    pt.b = true;
    pt.i8 = std::numeric_limits<int8_t>::min();
    pt.i16 = std::numeric_limits<int16_t>::min();
    pt.i32 = std::numeric_limits<int32_t>::min();
    pt.i64 = std::numeric_limits<int64_t>::min();
    pt.u8 = std::numeric_limits<uint8_t>::max();
    pt.u16 = std::numeric_limits<uint16_t>::max();
    pt.u32 = std::numeric_limits<uint32_t>::max();
    pt.u64 = std::numeric_limits<uint64_t>::max();
    pt.f32 = 0.25;
    pt.f64 = 9007199254740992.0;
  }

  // TODO: It might be nice to have a more readable strategy for generating
  // JSON, e.g.,:
  // return GenerateObject([&]() {
  //  GenerateObjectMember("b", "true");
  //  GenerateObjectMember("i8", "-128");
  //  ...
  // });
  // Ideally, we'd also harmonize StructSupport and HandleStructSupport.
  std::string GetJSON() {
    std::ostringstream es;
    es << R"JSON({"p":{)JSON"
       << R"JSON("b":")JSON" << (pt.b ? "true" : "false") << R"JSON(",)JSON"
       << R"JSON("i8":")JSON" << std::to_string(pt.i8)
       << R"JSON(", "i16":")JSON" << std::to_string(pt.i16)
       << R"JSON(", "i32":")JSON" << std::to_string(pt.i32)
       << R"JSON(", "i64":")JSON" << std::to_string(pt.i64)
       << R"JSON(", "u8":")JSON" << std::to_string(pt.u8)
       << R"JSON(", "u16":")JSON" << std::to_string(pt.u16)
       << R"JSON(", "u32":")JSON" << std::to_string(pt.u32)
       << R"JSON(", "u64":")JSON" << std::to_string(pt.u64)
       << R"JSON(", "f32":")JSON" << std::to_string(pt.f32)
       << R"JSON(", "f64":")JSON" << std::to_string(pt.f64) << "\"}}";
    return es.str();
  }
  test::fidlcat::examples::primitive_types pt;
};

}  // namespace

TEST_F(WireParserTest, ParseStruct) {
  StructSupport sd;
  TEST_WIRE_TO_JSON_BODY(Struct, sd.GetJSON(), sd.pt);
}

namespace {

test::fidlcat::examples::two_string_struct TwoStringStructFromVals(
    std::string v1, std::string v2) {
  test::fidlcat::examples::two_string_struct tss;
  tss.value1 = v1;
  tss.value2 = v2;
  return tss;
}

}  // namespace

TEST_WIRE_TO_JSON(TwoStringStructInt, TwoStringStructInt,
                  R"({"s":{"value1":"harpo", "value2":"chico"}, "i32":"1"})",
                  TwoStringStructFromVals("harpo", "chico"), 1)

namespace {

std::unique_ptr<test::fidlcat::examples::two_string_struct>
TwoStringStructFromValsPtr(std::string v1, std::string v2) {
  std::unique_ptr<test::fidlcat::examples::two_string_struct> ptr(
      new test::fidlcat::examples::two_string_struct());
  ptr->value1 = v1;
  ptr->value2 = v2;
  return ptr;
}

}  // namespace

TEST_WIRE_TO_JSON(TwoStringNullableStructInt, TwoStringNullableStructInt,
                  R"({"s":{"value1":"harpo", "value2":"chico"}, "i32":"1"})",
                  TwoStringStructFromValsPtr("harpo", "chico"), 1)

TEST_WIRE_TO_JSON(NullableStruct, NullableStruct, R"({"p":null})", nullptr);

TEST_WIRE_TO_JSON(NullableStructAndInt, NullableStructAndInt,
                  R"({"p":null, "i":"1"})", nullptr, 1);

// TODO: Add the following struct tests:
// struct{uint8 f1; uint32 f2;}
// struct{struct{uint8 f1; uint32 f2;} inner; uint8 f3;}

// Union and XUnion tests

namespace {

using isu = test::fidlcat::examples::int_struct_union;
using xisu = test::fidlcat::examples::int_struct_xunion;

template <class T>
T GetIntUnion(int32_t i) {
  T u;
  u.set_variant_i(i);
  return u;
}

template <class T>
T GetStructUnion(std::string v1, std::string v2) {
  T u;
  test::fidlcat::examples::two_string_struct tss =
      TwoStringStructFromVals(v1, v2);
  u.set_variant_tss(tss);
  return u;
}

template <class T>
std::unique_ptr<T> GetIntUnionPtr(int32_t i) {
  std::unique_ptr<T> ptr(new T());
  ptr->set_variant_i(i);
  return ptr;
}

template <class T>
std::unique_ptr<T> GetStructUnionPtr(std::string v1, std::string v2) {
  std::unique_ptr<T> ptr(new T());
  test::fidlcat::examples::two_string_struct tss =
      TwoStringStructFromVals(v1, v2);
  ptr->set_variant_tss(tss);
  return ptr;
}

}  // namespace

TEST_WIRE_TO_JSON(UnionInt, Union, R"({"isu":{"variant_i":"42"}, "i" : "1"})",
                  GetIntUnion<isu>(42), 1);

TEST_WIRE_TO_JSON(
    UnionStruct, Union,
    R"({"isu":{"variant_tss":{"value1":"harpo","value2":"chico"}}, "i":"1"})",
    GetStructUnion<isu>("harpo", "chico"), 1);

TEST_WIRE_TO_JSON(NullableUnionInt, NullableUnion,
                  R"({"isu":{"variant_i":"42"}, "i" : "1"})",
                  GetIntUnionPtr<isu>(42), 1);

TEST_WIRE_TO_JSON(
    NullableUnionStruct, NullableUnion,
    R"({"isu":{"variant_tss":{"value1":"harpo","value2":"chico"}}, "i":"1"})",
    GetStructUnionPtr<isu>("harpo", "chico"), 1);

TEST_WIRE_TO_JSON(NullableUnionIntFirstInt, NullableUnionIntFirst,
                  R"({"i" : "1", "isu":{"variant_i":"42"}})", 1,
                  GetIntUnionPtr<isu>(42));

TEST_WIRE_TO_JSON(
    NullableUnionIntFirstStruct, NullableUnionIntFirst,
    R"({"i": "1", "isu":{"variant_tss":{"value1":"harpo","value2":"chico"}}})",
    1, GetStructUnionPtr<isu>("harpo", "chico"));

TEST_WIRE_TO_JSON(XUnionInt, XUnion, R"({"isu":{"variant_i":"42"}, "i" : "1"})",
                  GetIntUnion<xisu>(42), 1);

TEST_WIRE_TO_JSON(
    XUnionStruct, XUnion,
    R"({"isu":{"variant_tss":{"value1":"harpo","value2":"chico"}}, "i":"1"})",
    GetStructUnion<xisu>("harpo", "chico"), 1);

TEST_WIRE_TO_JSON(NullableXUnionInt, NullableXUnion,
                  R"({"isu":{"variant_i":"42"}, "i" : "1"})",
                  GetIntUnionPtr<xisu>(42), 1);

TEST_WIRE_TO_JSON(
    NullableXUnionStruct, NullableXUnion,
    R"({"isu":{"variant_tss":{"value1":"harpo","value2":"chico"}}, "i":"1"})",
    GetStructUnionPtr<xisu>("harpo", "chico"), 1);

TEST_WIRE_TO_JSON(NullableXUnionIntFirstInt, NullableXUnionIntFirst,
                  R"({"i" : "1", "isu":{"variant_i":"42"}})", 1,
                  GetIntUnionPtr<xisu>(42));

TEST_WIRE_TO_JSON(
    NullableXUnionIntFirstStruct, NullableXUnionIntFirst,
    R"({"i": "1", "isu":{"variant_tss":{"value1":"harpo","value2":"chico"}}})",
    1, GetStructUnionPtr<xisu>("harpo", "chico"));

namespace {

using uuu = test::fidlcat::examples::u8_u16_union;
using uux = test::fidlcat::examples::u8_u16_xunion;

template <class T>
T GetUInt8Union(uint8_t i) {
  T u;
  u.set_variant_u8(i);
  return u;
}

template <class T>
T GetUInt16Union(uint16_t i) {
  T u;
  u.set_variant_u16(i);
  return u;
}

}  // namespace

TEST_WIRE_TO_JSON(ShortUnion8, ShortUnion,
                  R"({"u":{"variant_u8":"16"}, "i":"1"})",
                  GetUInt8Union<uuu>(16), 1);

TEST_WIRE_TO_JSON(ShortUnion16, ShortUnion,
                  R"({"u":{"variant_u16":"1024"}, "i":"1"})",
                  GetUInt16Union<uuu>(1024), 1);

TEST_WIRE_TO_JSON(ShortXUnion8, ShortXUnion,
                  R"({"u":{"variant_u8":"16"}, "i":"1"})",
                  GetUInt8Union<uux>(16), 1);

TEST_WIRE_TO_JSON(ShortXUnion16, ShortXUnion,
                  R"({"u":{"variant_u16":"1024"}, "i":"1"})",
                  GetUInt16Union<uux>(1024), 1);

// Enum Tests

TEST_WIRE_TO_JSON(DefaultEnum, DefaultEnum, R"({"ev":"x"})",
                  test::fidlcat::examples::default_enum::x);
TEST_WIRE_TO_JSON(I8Enum, I8Enum, R"({"ev":"x"})",
                  test::fidlcat::examples::i8_enum::x);
TEST_WIRE_TO_JSON(I16Enum, I16Enum, R"({"ev":"x"})",
                  test::fidlcat::examples::i16_enum::x);

// Table Tests

test::fidlcat::examples::value_table GetTable(
    std::optional<int16_t> first_int16, std::optional<std::string> value1,
    std::optional<std::string> value2, std::optional<int32_t> third_union_val) {
  test::fidlcat::examples::value_table table;
  if (first_int16.has_value()) {
    table.set_first_int16(*first_int16);
  }
  if (value1.has_value()) {
    table.set_second_struct(TwoStringStructFromVals(*value1, *value2));
  }
  if (third_union_val.has_value()) {
    test::fidlcat::examples::int_struct_union u;
    u.set_variant_i(*third_union_val);
    table.set_third_union(std::move(u));
  }
  return table;
}

TEST_WIRE_TO_JSON(Table0, Table, R"({"table":{}, "i":"2"})",
                  GetTable({}, {}, {}, {}), 2)

TEST_WIRE_TO_JSON(Table1, Table,
                  R"({"table":{
                          "third_union":{"variant_i":"42"}
                      },
                      "i":"2"})",
                  GetTable({}, {}, {}, 42), 2)

TEST_WIRE_TO_JSON(Table2, Table,
                  R"({"table":{
                          "second_struct":{"value1":"harpo", "value2":"groucho"}
                      },
                      "i":"2"})",
                  GetTable({}, "harpo", "groucho", {}), 2)

TEST_WIRE_TO_JSON(Table3, Table,
                  R"({"table":{
                          "second_struct":{
                              "value1":"harpo", "value2":"groucho"},
                          "third_union":{"variant_i":"42"}},
                      "i":"2"})",
                  GetTable({}, "harpo", "groucho", 42), 2)

TEST_WIRE_TO_JSON(Table4, Table, R"({"table":{
                                         "first_int16":"1"
                                     },
                                     "i":"2"})",
                  GetTable(1, {}, {}, {}), 2)

TEST_WIRE_TO_JSON(Table5, Table,
                  R"({"table":{
                          "first_int16":"1",
                          "third_union":{"variant_i":"42"}
                      },
                      "i":"2"})",
                  GetTable(1, {}, {}, 42), 2)

TEST_WIRE_TO_JSON(Table6, Table,
                  R"({"table":{
                          "first_int16":"1",
                          "second_struct":{
                              "value1":"harpo", "value2":"groucho"}
                      },
                      "i":"2"})",
                  GetTable(1, "harpo", "groucho", {}), 2)

TEST_WIRE_TO_JSON(Table7, Table,
                  R"({"table":{
                          "first_int16":"1",
                          "second_struct":{
                              "value1":"harpo", "value2":"groucho"},
                          "third_union":{"variant_i":"42"}
                      },
                      "i":"2"})",
                  GetTable(1, "harpo", "groucho", 42), 2)

// TODO(DX-1476): Add a test that exercises what happens when we encounter an
// unknown type in a table.

// Handle Tests

namespace {

class HandleSupport {
 public:
  HandleSupport() {
    zx::channel::create(0, &out1_, &out2_);
    json_ = R"({"ch":")";
    json_.append(std::to_string(out2_.get()));
    json_.append(R"("})");
  }
  zx::channel handle() { return std::move(out2_); }
  std::string GetJSON() { return json_; }

 private:
  zx::channel out1_;
  zx::channel out2_;
  std::string json_;
};

}  // namespace

TEST_F(WireParserTest, ParseHandle) {
  HandleSupport support;
  TEST_WIRE_TO_JSON_BODY(Handle, support.GetJSON(), support.handle());
}

TEST_F(WireParserTest, ParseNullableHandle) {
  HandleSupport support;
  TEST_WIRE_TO_JSON_BODY(NullableHandle, support.GetJSON(), support.handle());
}

namespace {

class HandleStructSupport {
 public:
  HandleStructSupport() {
    zx::channel::create(0, &out1_, &out2_);
    zx::channel::create(0, &out3_, &out4_);
    json_ = R"({"hs":{"h1":")";
    json_.append(std::to_string(out1_.get()));
    json_.append(R"(", "h2":")");
    json_.append(std::to_string(out2_.get()));
    json_.append(R"(", "h3":")");
    json_.append(std::to_string(out3_.get()));
    json_.append(R"("}})");
  }
  test::fidlcat::examples::handle_struct handle_struct() {
    test::fidlcat::examples::handle_struct hs;
    hs.h1 = std::move(out1_);
    hs.h2 = std::move(out2_);
    hs.h3 = std::move(out3_);
    return hs;
  }
  std::string GetJSON() { return json_; }

 private:
  zx::channel out1_;
  zx::channel out2_;
  zx::channel out3_;
  zx::channel out4_;

  std::string json_;
};

}  // namespace

TEST_F(WireParserTest, ParseHandleStruct) {
  HandleStructSupport support;
  TEST_WIRE_TO_JSON_BODY(HandleStruct, support.GetJSON(),
                         support.handle_struct());
}

// Corrupt data tests

TEST_F(WireParserTest, BadSchemaPrintHex) {
  std::vector<std::unique_ptr<std::istream>> library_files;
  // i32 in the schema is missing "subtype": "int32"
  std::string bad_schema = R"FIDL({
  "version": "0.0.1",
  "name": "fidl.examples.types",
  "library_dependencies": [],
  "bits_declarations": [],
  "const_declarations": [],
  "enum_declarations": [],
  "interface_declarations": [
    {
      "name": "test.fidlcat.examples/this_is_an_interface",
      "location": {
        "filename": "../../tools/fidlcat/lib/testdata/types.test.fidl",
        "line": 7,
        "column": 9
      },
      "methods": [
        {
          "ordinal": 912304001,
          "generated_ordinal": 912304001,
          "name": "Int32",
          "location": {
            "filename": "../../tools/fidlcat/lib/testdata/types.test.fidl",
            "line": 12,
            "column": 4
          },
          "has_request": true,
          "maybe_request": [
            {
              "type": {
                "kind": "primitive"
              },
              "name": "i32",
              "location": {
                "filename": "../../tools/fidlcat/lib/testdata/types.test.fidl",
                "line": 12,
                "column": 16
              },
              "size": 4,
              "max_out_of_line": 0,
              "alignment": 4,
              "offset": 16,
              "max_handles": 0
            }
          ],
          "maybe_request_size": 24,
          "maybe_request_alignment": 8,
          "has_response": false
        }
      ]
    }
  ],
  "struct_declarations": [],
  "table_declarations": [],
  "union_declarations": [],
  "xunion_declarations": []
})FIDL";
  std::unique_ptr<std::istream> file =
      std::make_unique<std::istringstream>(std::istringstream(bad_schema));
  library_files.push_back(std::move(file));
  LibraryReadError err;
  LibraryLoader loader(library_files, &err);
  ASSERT_TRUE(err.value == LibraryReadError::ErrorValue::kOk);
  fidl::MessageBuffer buffer;
  fidl::Message message = buffer.CreateEmptyMessage();

  InterceptRequest<test::fidlcat::examples::this_is_an_interface>(
      message,
      [](fidl::InterfacePtr<test::fidlcat::examples::this_is_an_interface>&
             ptr) { ptr->Int32(0xdeadbeef); });

  fidl_message_header_t header = message.header();

  const InterfaceMethod* method;
  // If this is false, you probably have to update the schema above.
  ASSERT_TRUE(loader.GetByOrdinal(header.ordinal, &method));

  rapidjson::Document actual;
  fidlcat::RequestToJSON(method, message, actual);

  ASSERT_STREQ(actual["i32"].GetString(), "ef be ad de");
}

}  // namespace fidlcat