/*
 * Copyright (C) 2018 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#define LOG_TAG "Cts-NdkBinderTest"

#include <aidl/test_package/BnEmpty.h>
#include <aidl/test_package/BpCompatTest.h>
#include <aidl/test_package/BpTest.h>
#include <aidl/test_package/ByteEnum.h>
#include <aidl/test_package/ExtendableParcelable.h>
#include <aidl/test_package/FixedSize.h>
#include <aidl/test_package/Foo.h>
#include <aidl/test_package/IntEnum.h>
#include <aidl/test_package/LongEnum.h>
#include <aidl/test_package/RegularPolygon.h>
#include <android/binder_ibinder_jni.h>
#include <android/log.h>
#include <gtest/gtest.h>

#include "itest_impl.h"
#include "utilities.h"

#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <type_traits>

using ::aidl::test_package::Bar;
using ::aidl::test_package::BpTest;
using ::aidl::test_package::ByteEnum;
using ::aidl::test_package::ExtendableParcelable;
using ::aidl::test_package::FixedSize;
using ::aidl::test_package::Foo;
using ::aidl::test_package::GenericBar;
using ::aidl::test_package::ICompatTest;
using ::aidl::test_package::IntEnum;
using ::aidl::test_package::ITest;
using ::aidl::test_package::LongEnum;
using ::aidl::test_package::MyExt;
using ::aidl::test_package::RegularPolygon;
using ::ndk::ScopedAStatus;
using ::ndk::ScopedFileDescriptor;
using ::ndk::SharedRefBase;
using ::ndk::SpAIBinder;

// This client is built for 32 and 64-bit targets. The size of FixedSize must remain the same.
static_assert(sizeof(FixedSize) == 16);
static_assert(offsetof(FixedSize, a) == 0);
static_assert(offsetof(FixedSize, b) == 8);

// AIDL tests which are independent of the service
class NdkBinderTest_AidlLocal : public NdkBinderTest {};

TEST_F(NdkBinderTest_AidlLocal, FromBinder) {
  std::shared_ptr<MyTest> test = SharedRefBase::make<MyTest>();
  SpAIBinder binder = test->asBinder();
  EXPECT_EQ(test, ITest::fromBinder(binder));

  EXPECT_FALSE(test->isRemote());
}

TEST_F(NdkBinderTest_AidlLocal, ConfirmFixedSizeTrue) {
  bool res = std::is_same<FixedSize::fixed_size, std::true_type>::value;
  EXPECT_EQ(res, true);
}

TEST_F(NdkBinderTest_AidlLocal, ConfirmFixedSizeFalse) {
  bool res = std::is_same<RegularPolygon::fixed_size, std::true_type>::value;
  EXPECT_EQ(res, false);
}

struct Params {
  std::shared_ptr<ITest> iface;
  bool shouldBeRemote;
  bool shouldBeWrapped;
  std::string expectedName;
  bool shouldBeOld;
};

#define iface GetParam().iface
#define shouldBeRemote GetParam().shouldBeRemote
#define shouldBeWrapped GetParam().shouldBeWrapped

// AIDL tests which run on each type of service (local C++, local Java, remote C++, remote Java,
// etc..)
class NdkBinderTest_Aidl : public NdkBinderTest,
                           public ::testing::WithParamInterface<Params> {};

TEST_P(NdkBinderTest_Aidl, GotTest) { ASSERT_NE(nullptr, iface); }

TEST_P(NdkBinderTest_Aidl, SanityCheckSource) {
  std::string name;
  ASSERT_OK(iface->GetName(&name));
  EXPECT_EQ(GetParam().expectedName, name);
}

TEST_P(NdkBinderTest_Aidl, Remoteness) {
  ASSERT_EQ(shouldBeRemote, iface->isRemote());
}

TEST_P(NdkBinderTest_Aidl, UseBinder) {
  ASSERT_EQ(STATUS_OK, AIBinder_ping(iface->asBinder().get()));
}

TEST_P(NdkBinderTest_Aidl, GetExtension) {
  SpAIBinder ext;
  ASSERT_EQ(STATUS_OK, AIBinder_getExtension(iface->asBinder().get(), ext.getR()));

  // TODO(b/139325468): add support in Java as well
  if (GetParam().expectedName == "CPP") {
    EXPECT_EQ(STATUS_OK, AIBinder_ping(ext.get()));
  } else {
    ASSERT_EQ(nullptr, ext.get());
  }
}

bool ReadFdToString(int fd, std::string* content) {
  char buf[64];
  ssize_t n;
  while ((n = TEMP_FAILURE_RETRY(read(fd, &buf[0], sizeof(buf)))) > 0) {
    content->append(buf, n);
  }
  return (n == 0) ? true : false;
}

std::string dumpToString(std::shared_ptr<ITest> itest, std::vector<const char*> args) {
  int fd[2] = {-1, -1};
  EXPECT_EQ(0, socketpair(AF_UNIX, SOCK_STREAM, 0, fd));

  EXPECT_OK(itest->dump(fd[0], args.data(), args.size()));
  close(fd[0]);

  std::string ret;
  EXPECT_TRUE(ReadFdToString(fd[1], &ret));

  close(fd[1]);
  return ret;
}

auto getCompatTest(std::shared_ptr<ITest> itest) {
  SpAIBinder binder;
  itest->getICompatTest(&binder);
  return ICompatTest::fromBinder(binder);
}

TEST_P(NdkBinderTest_Aidl, UseDump) {
  std::string name;
  EXPECT_OK(iface->GetName(&name));
  if (name == "JAVA" && !iface->isRemote()) {
    // TODO(b/127361166): GTEST_SKIP is considered a failure, would prefer to use that here
    // TODO(b/127339049): JavaBBinder doesn't implement dump
    return;
  }

  EXPECT_EQ("", dumpToString(iface, {}));
  EXPECT_EQ("", dumpToString(iface, {"", ""}));
  EXPECT_EQ("Hello World!", dumpToString(iface, {"Hello ", "World!"}));
  EXPECT_EQ("ABC", dumpToString(iface, {"A", "B", "C"}));
}

TEST_P(NdkBinderTest_Aidl, Trivial) {
  ASSERT_OK(iface->TestVoidReturn());

  if (shouldBeWrapped) {
    ASSERT_OK(iface->TestOneway());
  } else {
    ASSERT_EQ(STATUS_UNKNOWN_ERROR, AStatus_getStatus(iface->TestOneway().get()));
  }
}

TEST_P(NdkBinderTest_Aidl, CallingInfo) {
  EXPECT_OK(iface->CacheCallingInfoFromOneway());
  int32_t res;

  EXPECT_OK(iface->GiveMeMyCallingPid(&res));
  EXPECT_EQ(getpid(), res);

  EXPECT_OK(iface->GiveMeMyCallingUid(&res));
  EXPECT_EQ(getuid(), res);

  EXPECT_OK(iface->GiveMeMyCallingPidFromOneway(&res));
  if (shouldBeRemote) {
    // PID is hidden from oneway calls
    EXPECT_EQ(0, res);
  } else {
    EXPECT_EQ(getpid(), res);
  }

  EXPECT_OK(iface->GiveMeMyCallingUidFromOneway(&res));
  EXPECT_EQ(getuid(), res);
}

TEST_P(NdkBinderTest_Aidl, Constants) {
  ASSERT_EQ(0, ITest::kZero);
  ASSERT_EQ(1, ITest::kOne);
  ASSERT_EQ(0xffffffff, ITest::kOnes);
  ASSERT_EQ(1, ITest::kByteOne);
  ASSERT_EQ(0xffffffffffffffff, ITest::kLongOnes);
  ASSERT_EQ(std::string(""), ITest::kEmpty);
  ASSERT_EQ(std::string("foo"), ITest::kFoo);
}

TEST_P(NdkBinderTest_Aidl, RepeatPrimitiveInt) {
  int32_t out;
  ASSERT_OK(iface->RepeatInt(3, &out));
  EXPECT_EQ(3, out);
}

TEST_P(NdkBinderTest_Aidl, RepeatPrimitiveLong) {
  int64_t out;
  ASSERT_OK(iface->RepeatLong(3, &out));
  EXPECT_EQ(3, out);
}

TEST_P(NdkBinderTest_Aidl, RepeatPrimitiveFloat) {
  float out;
  ASSERT_OK(iface->RepeatFloat(2.0f, &out));
  EXPECT_EQ(2.0f, out);
}

TEST_P(NdkBinderTest_Aidl, RepeatPrimitiveDouble) {
  double out;
  ASSERT_OK(iface->RepeatDouble(3.0, &out));
  EXPECT_EQ(3.0, out);
}

TEST_P(NdkBinderTest_Aidl, RepeatPrimitiveBoolean) {
  bool out;
  ASSERT_OK(iface->RepeatBoolean(true, &out));
  EXPECT_EQ(true, out);
}

TEST_P(NdkBinderTest_Aidl, RepeatPrimitiveChar) {
  char16_t out;
  ASSERT_OK(iface->RepeatChar(L'@', &out));
  EXPECT_EQ(L'@', out);
}

TEST_P(NdkBinderTest_Aidl, RepeatPrimitiveByte) {
  int8_t out;
  ASSERT_OK(iface->RepeatByte(3, &out));
  EXPECT_EQ(3, out);
}

TEST_P(NdkBinderTest_Aidl, RepeatPrimitiveByteEnum) {
  ByteEnum out;
  ASSERT_OK(iface->RepeatByteEnum(ByteEnum::FOO, &out));
  EXPECT_EQ(ByteEnum::FOO, out);
}

TEST_P(NdkBinderTest_Aidl, RepeatPrimitiveIntEnum) {
  IntEnum out;
  ASSERT_OK(iface->RepeatIntEnum(IntEnum::FOO, &out));
  EXPECT_EQ(IntEnum::FOO, out);
}

TEST_P(NdkBinderTest_Aidl, RepeatPrimitiveLongEnum) {
  LongEnum out;
  ASSERT_OK(iface->RepeatLongEnum(LongEnum::FOO, &out));
  EXPECT_EQ(LongEnum::FOO, out);
}

TEST_P(NdkBinderTest_Aidl, EnumToString) {
  EXPECT_EQ(toString(ByteEnum::FOO), "FOO");
  EXPECT_EQ(toString(IntEnum::BAR), "BAR");
  EXPECT_EQ(toString(LongEnum::FOO), "FOO");

  EXPECT_EQ(toString(static_cast<IntEnum>(-1)), "-1");
}

TEST_P(NdkBinderTest_Aidl, EnumValues) {
  auto range = ::ndk::enum_range<ByteEnum>();
  auto iter = range.begin();
  EXPECT_EQ(ByteEnum::FOO, *iter++);
  EXPECT_EQ(ByteEnum::BAR, *iter++);
  EXPECT_EQ(range.end(), iter);
}

TEST_P(NdkBinderTest_Aidl, RepeatBinder) {
  SpAIBinder binder = iface->asBinder();
  SpAIBinder ret;

  ASSERT_OK(iface->RepeatBinder(binder, &ret));
  EXPECT_EQ(binder.get(), ret.get());

  if (shouldBeWrapped) {
    ndk::ScopedAStatus status = iface->RepeatBinder(nullptr, &ret);
    ASSERT_EQ(STATUS_UNEXPECTED_NULL, AStatus_getStatus(status.get()));
  } else {
    ASSERT_OK(iface->RepeatBinder(nullptr, &ret));
    EXPECT_EQ(nullptr, ret.get());
  }

  ASSERT_OK(iface->RepeatNullableBinder(binder, &ret));
  EXPECT_EQ(binder.get(), ret.get());

  ASSERT_OK(iface->RepeatNullableBinder(nullptr, &ret));
  EXPECT_EQ(nullptr, ret.get());
}

TEST_P(NdkBinderTest_Aidl, RepeatInterface) {
  class MyEmpty : public ::aidl::test_package::BnEmpty {};

  std::shared_ptr<IEmpty> empty = SharedRefBase::make<MyEmpty>();

  std::shared_ptr<IEmpty> ret;
  ASSERT_OK(iface->RepeatInterface(empty, &ret));
  EXPECT_EQ(empty.get(), ret.get());

  // interfaces are always nullable in AIDL C++, and that behavior was carried
  // over to the NDK backend for consistency
  ASSERT_OK(iface->RepeatInterface(nullptr, &ret));
  EXPECT_EQ(nullptr, ret.get());

  ASSERT_OK(iface->RepeatNullableInterface(empty, &ret));
  EXPECT_EQ(empty.get(), ret.get());

  ASSERT_OK(iface->RepeatNullableInterface(nullptr, &ret));
  EXPECT_EQ(nullptr, ret.get());
}

static void checkInOut(const ScopedFileDescriptor& inFd,
                       const ScopedFileDescriptor& outFd) {
  static const std::string kContent = "asdf";

  ASSERT_EQ(static_cast<int>(kContent.size()),
            write(inFd.get(), kContent.data(), kContent.size()));

  std::string out;
  out.resize(kContent.size());
  ASSERT_EQ(static_cast<int>(kContent.size()),
            read(outFd.get(), &out[0], kContent.size()));

  EXPECT_EQ(kContent, out);
}

static void checkFdRepeat(
    const std::shared_ptr<ITest>& test,
    ScopedAStatus (ITest::*repeatFd)(const ScopedFileDescriptor&,
                                     ScopedFileDescriptor*)) {
  int fds[2];

  while (pipe(fds) == -1 && errno == EAGAIN)
    ;

  ScopedFileDescriptor readFd(fds[0]);
  ScopedFileDescriptor writeFd(fds[1]);

  ScopedFileDescriptor readOutFd;
  ASSERT_OK((test.get()->*repeatFd)(readFd, &readOutFd));

  checkInOut(writeFd, readOutFd);
}

TEST_P(NdkBinderTest_Aidl, RepeatFdArray) {
  int fds[2];

  while (pipe(fds) == -1 && errno == EAGAIN)
    ;
  std::vector<ScopedFileDescriptor> sfds;
  sfds.emplace_back(fds[0]);
  sfds.emplace_back(fds[1]);

  std::vector<ScopedFileDescriptor> sfds_out1;
  sfds_out1.resize(sfds.size());
  std::vector<ScopedFileDescriptor> sfds_out2;

  ASSERT_OK((iface->RepeatFdArray(sfds, &sfds_out1, &sfds_out2)));

  // sfds <-> sfds_out1
  checkInOut(sfds[1], sfds_out1[0]);
  checkInOut(sfds_out1[1], sfds[0]);

  // sfds_out1 <-> sfds_out2
  checkInOut(sfds_out1[1], sfds_out2[0]);
  checkInOut(sfds_out2[1], sfds_out1[0]);

  // sfds <-> sfds_out2
  checkInOut(sfds[1], sfds_out2[0]);
  checkInOut(sfds_out2[1], sfds[0]);
}

TEST_P(NdkBinderTest_Aidl, RepeatFd) { checkFdRepeat(iface, &ITest::RepeatFd); }

TEST_P(NdkBinderTest_Aidl, RepeatNullableFd) {
  checkFdRepeat(iface, &ITest::RepeatNullableFd);

  ScopedFileDescriptor in;
  EXPECT_EQ(-1, in.get());

  ScopedFileDescriptor out;
  ASSERT_OK(iface->RepeatNullableFd(in, &out));

  EXPECT_EQ(-1, out.get());
}

TEST_P(NdkBinderTest_Aidl, RepeatString) {
  std::string res;

  EXPECT_OK(iface->RepeatString("", &res));
  EXPECT_EQ("", res);

  EXPECT_OK(iface->RepeatString("a", &res));
  EXPECT_EQ("a", res);

  EXPECT_OK(iface->RepeatString("say what?", &res));
  EXPECT_EQ("say what?", res);
}

TEST_P(NdkBinderTest_Aidl, RepeatNullableString) {
  std::optional<std::string> res;

  EXPECT_OK(iface->RepeatNullableString(std::nullopt, &res));
  EXPECT_EQ(std::nullopt, res);

  EXPECT_OK(iface->RepeatNullableString("", &res));
  EXPECT_EQ("", *res);

  EXPECT_OK(iface->RepeatNullableString("a", &res));
  EXPECT_EQ("a", *res);

  EXPECT_OK(iface->RepeatNullableString("say what?", &res));
  EXPECT_EQ("say what?", *res);
}

TEST_P(NdkBinderTest_Aidl, ParcelableDefaults) {
  RegularPolygon polygon;

  EXPECT_EQ("square", polygon.name);
  EXPECT_EQ(4, polygon.numSides);
  EXPECT_EQ(1.0f, polygon.sideLength);
}

TEST_P(NdkBinderTest_Aidl, RepeatPolygon) {
  RegularPolygon defaultPolygon = {"hexagon", 6, 2.0f};
  RegularPolygon outputPolygon;
  ASSERT_OK(iface->RepeatPolygon(defaultPolygon, &outputPolygon));
  EXPECT_EQ(defaultPolygon, outputPolygon);
}

TEST_P(NdkBinderTest_Aidl, RepeatNullNullablePolygon) {
  std::optional<RegularPolygon> defaultPolygon;
  std::optional<RegularPolygon> outputPolygon;
  ASSERT_OK(iface->RepeatNullablePolygon(defaultPolygon, &outputPolygon));
  EXPECT_EQ(defaultPolygon, outputPolygon);
}

TEST_P(NdkBinderTest_Aidl, RepeatPresentNullablePolygon) {
  std::optional<RegularPolygon> defaultPolygon =
      std::optional<RegularPolygon>({"septagon", 7, 3.0f});
  std::optional<RegularPolygon> outputPolygon;
  ASSERT_OK(iface->RepeatNullablePolygon(defaultPolygon, &outputPolygon));
  EXPECT_EQ(defaultPolygon, outputPolygon);
}

TEST_P(NdkBinderTest_Aidl, InsAndOuts) {
  RegularPolygon defaultPolygon;
  ASSERT_OK(iface->RenamePolygon(&defaultPolygon, "Jerry"));
  EXPECT_EQ("Jerry", defaultPolygon.name);
}

TEST_P(NdkBinderTest_Aidl, NewField) {
  Baz baz;
  baz.d = {"a", "b", "c"};

  Baz outbaz;

  ASSERT_OK(getCompatTest(iface)->repeatBaz(baz, &outbaz));

  if (GetParam().shouldBeOld) {
    EXPECT_EQ(std::nullopt, outbaz.d);
  } else {
    EXPECT_EQ(baz.d, outbaz.d);
  }
}

TEST_P(NdkBinderTest_Aidl, RenameFoo) {
  Foo foo;
  Foo outputFoo;
  ASSERT_OK(iface->renameFoo(&foo, "MYFOO"));

  EXPECT_EQ("MYFOO", foo.a);
}

TEST_P(NdkBinderTest_Aidl, RenameBar) {
  Foo foo;
  Foo outputFoo;
  ASSERT_OK(iface->renameBar(&foo, "MYBAR"));

  EXPECT_EQ("MYBAR", foo.d.a);
}

TEST_P(NdkBinderTest_Aidl, GetLastItem) {
  Foo foo;
  foo.f = 15;
  int retF;
  ASSERT_OK(iface->getF(foo, &retF));
  EXPECT_EQ(15, retF);
}

namespace aidl {
namespace test_package {
bool operator==(const SimpleUnion& lhs, const SimpleUnion& rhs) {
  if (lhs.getTag() != rhs.getTag()) return false;
  switch (lhs.getTag()) {
    case SimpleUnion::a:
      return lhs.get<SimpleUnion::a>() == rhs.get<SimpleUnion::a>();
    case SimpleUnion::b:
      return lhs.get<SimpleUnion::b>() == rhs.get<SimpleUnion::b>();
    case SimpleUnion::c:
      return lhs.get<SimpleUnion::c>() == rhs.get<SimpleUnion::c>();
    case SimpleUnion::d:
      return lhs.get<SimpleUnion::d>() == rhs.get<SimpleUnion::d>();
    case SimpleUnion::e:
      return lhs.get<SimpleUnion::e>() == rhs.get<SimpleUnion::e>();
    case SimpleUnion::f:
      return lhs.get<SimpleUnion::f>() == rhs.get<SimpleUnion::f>();
  }
}
}  // namespace test_package
}  // namespace aidl

TEST_P(NdkBinderTest_Aidl, RepeatFoo) {
  Foo foo;
  foo.a = "NEW FOO";
  foo.b = 57;
  foo.d.b = "a";
  foo.e.d = 99;
  foo.shouldBeByteBar = ByteEnum::BAR;
  foo.shouldBeIntBar = IntEnum::BAR;
  foo.shouldBeLongBar = LongEnum::BAR;
  foo.shouldContainTwoByteFoos = {ByteEnum::FOO, ByteEnum::FOO};
  foo.shouldContainTwoIntFoos = {IntEnum::FOO, IntEnum::FOO};
  foo.shouldContainTwoLongFoos = {LongEnum::FOO, LongEnum::FOO};
  foo.u = SimpleUnion::make<SimpleUnion::c>("hello");

  Foo retFoo;

  ASSERT_OK(iface->repeatFoo(foo, &retFoo));

  EXPECT_EQ(foo.a, retFoo.a);
  EXPECT_EQ(foo.b, retFoo.b);
  EXPECT_EQ(foo.d.b, retFoo.d.b);
  EXPECT_EQ(foo.e.d, retFoo.e.d);
  EXPECT_EQ(foo.shouldBeByteBar, retFoo.shouldBeByteBar);
  EXPECT_EQ(foo.shouldBeIntBar, retFoo.shouldBeIntBar);
  EXPECT_EQ(foo.shouldBeLongBar, retFoo.shouldBeLongBar);
  EXPECT_EQ(foo.shouldContainTwoByteFoos, retFoo.shouldContainTwoByteFoos);
  EXPECT_EQ(foo.shouldContainTwoIntFoos, retFoo.shouldContainTwoIntFoos);
  EXPECT_EQ(foo.shouldContainTwoLongFoos, retFoo.shouldContainTwoLongFoos);
  EXPECT_EQ(foo.u, retFoo.u);
}

TEST_P(NdkBinderTest_Aidl, RepeatGenericBar) {
  GenericBar<int32_t> bar;
  bar.a = 40;
  bar.shouldBeGenericFoo.a = 41;
  bar.shouldBeGenericFoo.b = 42;

  GenericBar<int32_t> retBar;

  ASSERT_OK(iface->repeatGenericBar(bar, &retBar));

  EXPECT_EQ(bar.a, retBar.a);
  EXPECT_EQ(bar.shouldBeGenericFoo.a, retBar.shouldBeGenericFoo.a);
  EXPECT_EQ(bar.shouldBeGenericFoo.b, retBar.shouldBeGenericFoo.b);
}

template <typename T>
using RepeatMethod = ScopedAStatus (ITest::*)(const std::vector<T>&,
                                              std::vector<T>*, std::vector<T>*);

namespace aidl {
namespace test_package {
inline bool operator==(const RegularPolygon& lhs, const RegularPolygon& rhs) {
  return lhs.name == rhs.name && lhs.numSides == rhs.numSides && lhs.sideLength == rhs.sideLength;
}
inline bool operator==(const std::vector<RegularPolygon>& lhs,
                       const std::vector<RegularPolygon>& rhs) {
  if (lhs.size() != rhs.size()) return false;
  for (size_t i = 0; i < lhs.size(); i++) {
    if (!(lhs[i] == rhs[i])) return false;
  }
  return true;
}
}  // namespace test_package
}  // namespace aidl

template <typename T>
void testRepeat(const std::shared_ptr<ITest>& i, RepeatMethod<T> repeatMethod,
                std::vector<std::vector<T>> tests) {
  for (const auto& input : tests) {
    std::vector<T> out1;
    out1.resize(input.size());
    std::vector<T> out2;

    ASSERT_OK((i.get()->*repeatMethod)(input, &out1, &out2)) << input.size();
    EXPECT_EQ(input, out1);
    EXPECT_EQ(input, out2);
  }
}

template <typename T>
void testRepeat2List(const std::shared_ptr<ITest>& i, RepeatMethod<T> repeatMethod,
                     std::vector<std::vector<T>> tests) {
  for (const auto& input : tests) {
    std::vector<T> out1;
    std::vector<T> out2;
    std::vector<T> expected;

    expected.insert(expected.end(), input.begin(), input.end());
    expected.insert(expected.end(), input.begin(), input.end());

    ASSERT_OK((i.get()->*repeatMethod)(input, &out1, &out2)) << expected.size();
    EXPECT_EQ(expected, out1);
    EXPECT_EQ(expected, out2);
  }
}

TEST_P(NdkBinderTest_Aidl, Arrays) {
  testRepeat<bool>(iface, &ITest::RepeatBooleanArray,
                   {
                       {},
                       {true},
                       {false, true, false},
                   });
  testRepeat<uint8_t>(iface, &ITest::RepeatByteArray,
                      {
                          {},
                          {1},
                          {1, 2, 3},
                      });
  testRepeat<char16_t>(iface, &ITest::RepeatCharArray,
                       {
                           {},
                           {L'@'},
                           {L'@', L'!', L'A'},
                       });
  testRepeat<int32_t>(iface, &ITest::RepeatIntArray,
                      {
                          {},
                          {1},
                          {1, 2, 3},
                      });
  testRepeat<int64_t>(iface, &ITest::RepeatLongArray,
                      {
                          {},
                          {1},
                          {1, 2, 3},
                      });
  testRepeat<float>(iface, &ITest::RepeatFloatArray,
                    {
                        {},
                        {1.0f},
                        {1.0f, 2.0f, 3.0f},
                    });
  testRepeat<double>(iface, &ITest::RepeatDoubleArray,
                     {
                         {},
                         {1.0},
                         {1.0, 2.0, 3.0},
                     });
  testRepeat<ByteEnum>(iface, &ITest::RepeatByteEnumArray,
                       {
                           {},
                           {ByteEnum::FOO},
                           {ByteEnum::FOO, ByteEnum::BAR},
                       });
  testRepeat<IntEnum>(iface, &ITest::RepeatIntEnumArray,
                      {
                          {},
                          {IntEnum::FOO},
                          {IntEnum::FOO, IntEnum::BAR},
                      });
  testRepeat<LongEnum>(iface, &ITest::RepeatLongEnumArray,
                       {
                           {},
                           {LongEnum::FOO},
                           {LongEnum::FOO, LongEnum::BAR},
                       });
  testRepeat<std::string>(iface, &ITest::RepeatStringArray,
                          {
                              {},
                              {"asdf"},
                              {"", "aoeu", "lol", "brb"},
                          });
  testRepeat<RegularPolygon>(iface, &ITest::RepeatRegularPolygonArray,
                             {
                                 {},
                                 {{"hexagon", 6, 2.0f}},
                                 {{"hexagon", 6, 2.0f}, {"square", 4, 7.0f}, {"pentagon", 5, 4.2f}},
                             });
}

TEST_P(NdkBinderTest_Aidl, Lists) {
  testRepeat2List<std::string>(iface, &ITest::Repeat2StringList,
                               {
                                   {},
                                   {"asdf"},
                                   {"", "aoeu", "lol", "brb"},
                               });
  testRepeat2List<RegularPolygon>(
      iface, &ITest::Repeat2RegularPolygonList,
      {
          {},
          {{"hexagon", 6, 2.0f}},
          {{"hexagon", 6, 2.0f}, {"square", 4, 7.0f}, {"pentagon", 5, 4.2f}},
      });
}

template <typename T>
using RepeatNullableMethod = ScopedAStatus (ITest::*)(
    const std::optional<std::vector<std::optional<T>>>&,
    std::optional<std::vector<std::optional<T>>>*,
    std::optional<std::vector<std::optional<T>>>*);

template <typename T>
void testRepeat(
    const std::shared_ptr<ITest>& i, RepeatNullableMethod<T> repeatMethod,
    std::vector<std::optional<std::vector<std::optional<T>>>> tests) {
  for (const auto& input : tests) {
    std::optional<std::vector<std::optional<T>>> out1;
    if (input) {
      out1 = std::vector<std::optional<T>>{};
      out1->resize(input->size());
    }
    std::optional<std::vector<std::optional<T>>> out2;

    ASSERT_OK((i.get()->*repeatMethod)(input, &out1, &out2))
        << (input ? input->size() : -1);
    EXPECT_EQ(input, out1);
    EXPECT_EQ(input, out2);
  }
}

template <typename T>
using SingleRepeatNullableMethod = ScopedAStatus (ITest::*)(
    const std::optional<std::vector<T>>&, std::optional<std::vector<T>>*);

template <typename T>
void testRepeat(const std::shared_ptr<ITest>& i,
                SingleRepeatNullableMethod<T> repeatMethod,
                std::vector<std::optional<std::vector<T>>> tests) {
  for (const auto& input : tests) {
    std::optional<std::vector<T>> ret;
    ASSERT_OK((i.get()->*repeatMethod)(input, &ret))
        << (input ? input->size() : -1);
    EXPECT_EQ(input, ret);
  }
}

TEST_P(NdkBinderTest_Aidl, NullableArrays) {
  testRepeat<bool>(iface, &ITest::RepeatNullableBooleanArray,
                   {
                       std::nullopt,
                       {{}},
                       {{true}},
                       {{false, true, false}},
                   });
  testRepeat<uint8_t>(iface, &ITest::RepeatNullableByteArray,
                      {
                          std::nullopt,
                          {{}},
                          {{1}},
                          {{1, 2, 3}},
                      });
  testRepeat<char16_t>(iface, &ITest::RepeatNullableCharArray,
                       {
                           std::nullopt,
                           {{}},
                           {{L'@'}},
                           {{L'@', L'!', L'A'}},
                       });
  testRepeat<int32_t>(iface, &ITest::RepeatNullableIntArray,
                      {
                          std::nullopt,
                          {{}},
                          {{1}},
                          {{1, 2, 3}},
                      });
  testRepeat<int64_t>(iface, &ITest::RepeatNullableLongArray,
                      {
                          std::nullopt,
                          {{}},
                          {{1}},
                          {{1, 2, 3}},
                      });
  testRepeat<float>(iface, &ITest::RepeatNullableFloatArray,
                    {
                        std::nullopt,
                        {{}},
                        {{1.0f}},
                        {{1.0f, 2.0f, 3.0f}},
                    });
  testRepeat<double>(iface, &ITest::RepeatNullableDoubleArray,
                     {
                         std::nullopt,
                         {{}},
                         {{1.0}},
                         {{1.0, 2.0, 3.0}},
                     });
  testRepeat<ByteEnum>(iface, &ITest::RepeatNullableByteEnumArray,
                       {
                           std::nullopt,
                           {{}},
                           {{ByteEnum::FOO}},
                           {{ByteEnum::FOO, ByteEnum::BAR}},
                       });
  testRepeat<IntEnum>(iface, &ITest::RepeatNullableIntEnumArray,
                      {
                          std::nullopt,
                          {{}},
                          {{IntEnum::FOO}},
                          {{IntEnum::FOO, IntEnum::BAR}},
                      });
  testRepeat<LongEnum>(iface, &ITest::RepeatNullableLongEnumArray,
                       {
                           std::nullopt,
                           {{}},
                           {{LongEnum::FOO}},
                           {{LongEnum::FOO, LongEnum::BAR}},
                       });
  testRepeat<std::optional<std::string>>(
      iface, &ITest::RepeatNullableStringArray,
      {
          std::nullopt,
          {{}},
          {{"asdf"}},
          {{std::nullopt}},
          {{"aoeu", "lol", "brb"}},
          {{"", "aoeu", std::nullopt, "brb"}},
      });
  testRepeat<std::string>(iface, &ITest::DoubleRepeatNullableStringArray,
                          {
                              {{}},
                              {{"asdf"}},
                              {{std::nullopt}},
                              {{"aoeu", "lol", "brb"}},
                              {{"", "aoeu", std::nullopt, "brb"}},
                          });
}

class DefaultImpl : public ::aidl::test_package::ICompatTestDefault {
 public:
  ::ndk::ScopedAStatus NewMethodThatReturns10(int32_t* _aidl_return) override {
    *_aidl_return = 100;  // default impl returns different value
    return ::ndk::ScopedAStatus(AStatus_newOk());
  }
};

TEST_P(NdkBinderTest_Aidl, NewMethod) {
  std::shared_ptr<ICompatTest> default_impl = SharedRefBase::make<DefaultImpl>();
  ::aidl::test_package::ICompatTest::setDefaultImpl(default_impl);

  auto compat_test = getCompatTest(iface);
  int32_t res;
  EXPECT_OK(compat_test->NewMethodThatReturns10(&res));
  if (GetParam().shouldBeOld) {
    // Remote was built with version 1 interface which does not have
    // "NewMethodThatReturns10". In this case the default method
    // which returns 100 is called.
    EXPECT_EQ(100, res);
  } else {
    // Remote is built with the current version of the interface.
    // The method returns 10.
    EXPECT_EQ(10, res);
  }
}

TEST_P(NdkBinderTest_Aidl, RepeatStringNullableLater) {
  std::optional<std::string> res;

  std::string name;
  EXPECT_OK(iface->GetName(&name));

  // Java considers every type to be nullable, but this is okay, since it will
  // pass back NullPointerException to the client if it does not handle a null
  // type, similar to how a C++ server would refuse to unparcel a null
  // non-nullable type. Of course, this is not ideal, but the problem runs very
  // deep.
  const bool supports_nullable = !GetParam().shouldBeOld || name == "Java";
  auto compat_test = getCompatTest(iface);
  if (supports_nullable) {
    EXPECT_OK(compat_test->RepeatStringNullableLater(std::nullopt, &res));
    EXPECT_EQ(std::nullopt, res);
  } else {
    ndk::ScopedAStatus status = compat_test->RepeatStringNullableLater(std::nullopt, &res);
    ASSERT_EQ(STATUS_UNEXPECTED_NULL, AStatus_getStatus(status.get()));
  }

  EXPECT_OK(compat_test->RepeatStringNullableLater("", &res));
  EXPECT_EQ("", res);

  EXPECT_OK(compat_test->RepeatStringNullableLater("a", &res));
  EXPECT_EQ("a", res);

  EXPECT_OK(compat_test->RepeatStringNullableLater("say what?", &res));
  EXPECT_EQ("say what?", res);
}

TEST_P(NdkBinderTest_Aidl, GetInterfaceVersion) {
  int32_t res;
  auto compat_test = getCompatTest(iface);
  EXPECT_OK(compat_test->getInterfaceVersion(&res));
  if (GetParam().shouldBeOld) {
    EXPECT_EQ(1, res);
  } else {
    // 3 is the not-yet-frozen version
    EXPECT_EQ(3, res);
  }
}

TEST_P(NdkBinderTest_Aidl, GetInterfaceHash) {
  std::string res;
  auto compat_test = getCompatTest(iface);
  EXPECT_OK(compat_test->getInterfaceHash(&res));
  if (GetParam().shouldBeOld) {
    // aidl_api/libbinder_ndk_test_interface/1/.hash
    EXPECT_EQ("b663b681b3e0d66f9b5428c2f23365031b7d4ba0", res);
  } else {
    EXPECT_EQ("notfrozen", res);
  }
}

TEST_P(NdkBinderTest_Aidl, ParcelableHolderTest) {
  ExtendableParcelable ep;
  MyExt myext1;
  myext1.a = 42;
  myext1.b = "mystr";
  ep.ext.setParcelable(&myext1);
  std::unique_ptr<MyExt> myext2 = ep.ext.getParcelable<MyExt>();
  EXPECT_TRUE(myext2);
  EXPECT_EQ(42, myext2->a);
  EXPECT_EQ("mystr", myext2->b);

  AParcel* parcel = AParcel_create();
  ep.writeToParcel(parcel);
  AParcel_setDataPosition(parcel, 0);
  ExtendableParcelable ep2;
  ep2.readFromParcel(parcel);
  std::unique_ptr<MyExt> myext3 = ep2.ext.getParcelable<MyExt>();
  EXPECT_TRUE(myext3);
  EXPECT_EQ(42, myext3->a);
  EXPECT_EQ("mystr", myext3->b);
  AParcel_delete(parcel);
}
TEST_P(NdkBinderTest_Aidl, ParcelableHolderCommunicationTest) {
  ExtendableParcelable ep;

  MyExt myext1;
  myext1.a = 42;
  myext1.b = "mystr";
  ep.ext.setParcelable(&myext1);

  ExtendableParcelable ep2;
  EXPECT_OK(iface->RepeatExtendableParcelable(ep, &ep2));
  std::unique_ptr<MyExt> myext2 = ep2.ext.getParcelable<MyExt>();
  EXPECT_TRUE(myext2);
  EXPECT_EQ(42, myext2->a);
  EXPECT_EQ("mystr", myext2->b);
}

std::shared_ptr<ITest> getProxyLocalService() {
  std::shared_ptr<MyTest> test = SharedRefBase::make<MyTest>();
  SpAIBinder binder = test->asBinder();

  // adding an arbitrary class as the extension
  std::shared_ptr<MyTest> ext = SharedRefBase::make<MyTest>();
  SpAIBinder extBinder = ext->asBinder();

  binder_status_t ret = AIBinder_setExtension(binder.get(), extBinder.get());
  if (ret != STATUS_OK) {
    __android_log_write(ANDROID_LOG_ERROR, LOG_TAG, "Could not set local extension");
  }

  // BpTest -> AIBinder -> test
  //
  // Warning: for testing purposes only. This parcels things within the same process for testing
  // purposes. In normal usage, this should just return SharedRefBase::make<MyTest> directly.
  return SharedRefBase::make<BpTest>(binder);
}

std::shared_ptr<ITest> getNdkBinderTestJavaService(const std::string& method) {
  JNIEnv* env = GetEnv();
  if (env == nullptr) {
    __android_log_write(ANDROID_LOG_ERROR, LOG_TAG, "No environment");
    return nullptr;
  }

  jobject object = callStaticJavaMethodForObject(env, "android/binder/cts/NdkBinderTest", method,
                                                 "()Landroid/os/IBinder;");

  SpAIBinder binder = SpAIBinder(AIBinder_fromJavaBinder(env, object));

  return ITest::fromBinder(binder);
}

INSTANTIATE_TEST_CASE_P(LocalProxyToNative, NdkBinderTest_Aidl,
                        ::testing::Values(Params{getProxyLocalService(), false /*shouldBeRemote*/,
                                                 true /*shouldBeWrapped*/, "CPP",
                                                 false /*shouldBeOld*/}));
INSTANTIATE_TEST_CASE_P(LocalNativeFromJava, NdkBinderTest_Aidl,
                        ::testing::Values(Params{
                            getNdkBinderTestJavaService("getLocalNativeService"),
                            false /*shouldBeRemote*/, false /*shouldBeWrapped*/, "CPP",
                            false /*shouldBeOld*/}));
INSTANTIATE_TEST_CASE_P(LocalJava, NdkBinderTest_Aidl,
                        ::testing::Values(Params{getNdkBinderTestJavaService("getLocalJavaService"),
                                                 false /*shouldBeRemote*/, true /*shouldBeWrapped*/,
                                                 "JAVA", false /*shouldBeOld*/}));
INSTANTIATE_TEST_CASE_P(RemoteNative, NdkBinderTest_Aidl,
                        ::testing::Values(Params{
                            getNdkBinderTestJavaService("getRemoteNativeService"),
                            true /*shouldBeRemote*/, true /*shouldBeWrapped*/, "CPP",
                            false /*shouldBeOld*/}));
INSTANTIATE_TEST_CASE_P(RemoteJava, NdkBinderTest_Aidl,
                        ::testing::Values(Params{
                            getNdkBinderTestJavaService("getRemoteJavaService"),
                            true /*shouldBeRemote*/, true /*shouldBeWrapped*/, "JAVA",
                            false /*shouldBeOld*/}));

INSTANTIATE_TEST_CASE_P(RemoteNativeOld, NdkBinderTest_Aidl,
                        ::testing::Values(Params{
                            getNdkBinderTestJavaService("getRemoteOldNativeService"),
                            true /*shouldBeRemote*/, true /*shouldBeWrapped*/, "CPP",
                            true /*shouldBeOld*/}));