tests/aidl_test_client_parcelables.cpp - platform/system/tools/aidl - Git at Google

 /*
  * Copyright (C) 2015 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.
  */

 #include <android/aidl/tests/ParcelableForToString.h>
 #include <android/aidl/tests/extension/MyExt.h>
 #include <android/aidl/tests/extension/MyExt2.h>
 #include <android/aidl/tests/extension/MyExtLike.h>
 #include <android/aidl/tests/unions/EnumUnion.h>
 #include "aidl_test_client.h"

 #include <string>
 #include <vector>

 using android::IInterface;
 using android::sp;
 using android::String16;
 using android::aidl::tests::ConstantExpressionEnum;
 using android::aidl::tests::GenericStructuredParcelable;
 using android::aidl::tests::INamedCallback;
 using android::aidl::tests::IntEnum;
 using android::aidl::tests::ITestService;
 using android::aidl::tests::OtherParcelableForToString;
 using android::aidl::tests::ParcelableForToString;
 using android::aidl::tests::SimpleParcelable;
 using android::aidl::tests::StructuredParcelable;
 using android::aidl::tests::Union;
 using android::aidl::tests::extension::ExtendableParcelable;
 using android::aidl::tests::extension::MyExt;
 using android::aidl::tests::extension::MyExt2;
 using android::aidl::tests::extension::MyExtLike;
 using android::aidl::tests::unions::EnumUnion;
 using android::binder::Status;
 using android::os::PersistableBundle;
 using std::string;
 using std::vector;

 TEST_F(AidlTest, RepeatSimpleParcelable) {
   if (!cpp_java_tests) GTEST_SKIP() << "Service does not support the CPP/Java-only tests.";

   SimpleParcelable input("Booya", 42);
   SimpleParcelable out_param, returned;
   Status status = cpp_java_tests->RepeatSimpleParcelable(input, &out_param, &returned);
   ASSERT_TRUE(status.isOk()) << status.toString8();
   EXPECT_EQ(input, out_param) << input.toString() << " " << out_param.toString();
   EXPECT_EQ(input, returned) << input.toString() << " " << returned.toString();
 }

 TEST_F(AidlTest, RepeatGenericStructureParcelable) {
   if (!cpp_java_tests) GTEST_SKIP() << "Service does not support the CPP/Java-only tests.";

   GenericStructuredParcelable<int32_t, StructuredParcelable, IntEnum> input, out_param, returned;
   input.a = 41;
   input.b = 42;
   Status status = cpp_java_tests->RepeatGenericParcelable(input, &out_param, &returned);
   ASSERT_TRUE(status.isOk()) << status.toString8();
   EXPECT_EQ(input, out_param);
   EXPECT_EQ(input, returned);
 }

 TEST_F(AidlTest, ReverseSimpleParcelable) {
   if (!cpp_java_tests) GTEST_SKIP() << "Service does not support the CPP/Java-only tests.";

   const vector<SimpleParcelable> original{SimpleParcelable("first", 0),
                                           SimpleParcelable("second", 1),
                                           SimpleParcelable("third", 2)};
   vector<SimpleParcelable> repeated;
   if (backend == BackendType::JAVA) {
     repeated = vector<SimpleParcelable>(original.size());
   }
   vector<SimpleParcelable> reversed;
   Status status = cpp_java_tests->ReverseSimpleParcelables(original, &repeated, &reversed);
   ASSERT_TRUE(status.isOk()) << status.toString8();

   EXPECT_EQ(repeated, original);

   std::reverse(reversed.begin(), reversed.end());
   EXPECT_EQ(reversed, original);
 }

 TEST_F(AidlTest, ConfirmPersistableBundles) {
   if (!cpp_java_tests) GTEST_SKIP() << "Service does not support the CPP/Java-only tests.";

   PersistableBundle empty_bundle, returned;
   Status status = cpp_java_tests->RepeatPersistableBundle(empty_bundle, &returned);
   ASSERT_TRUE(status.isOk()) << status.toString8();
   EXPECT_EQ(empty_bundle, returned);
 }

 TEST_F(AidlTest, ConfirmPersistableBundlesNonEmpty) {
   if (!cpp_java_tests) GTEST_SKIP() << "Service does not support the CPP/Java-only tests.";

   PersistableBundle non_empty_bundle, returned;
   non_empty_bundle.putBoolean(String16("test_bool"), false);
   non_empty_bundle.putInt(String16("test_int"), 33);
   non_empty_bundle.putLong(String16("test_long"), 34359738368L);
   non_empty_bundle.putDouble(String16("test_double"), 1.1);
   non_empty_bundle.putString(String16("test_string"), String16("Woot!"));
   non_empty_bundle.putBooleanVector(String16("test_bool_vector"),
                                     {true, false, true});
   non_empty_bundle.putIntVector(String16("test_int_vector"), {33, 44, 55, 142});
   non_empty_bundle.putLongVector(String16("test_long_vector"),
                                  {34L, 8371L, 34359738375L});
   non_empty_bundle.putDoubleVector(String16("test_double_vector"), {2.2, 5.4});
   non_empty_bundle.putStringVector(String16("test_string_vector"),
                                    {String16("hello"), String16("world!")});
   PersistableBundle nested_bundle;
   nested_bundle.putInt(String16("test_nested_int"), 345);
   non_empty_bundle.putPersistableBundle(String16("test_persistable_bundle"),
                                         nested_bundle);

   Status status = cpp_java_tests->RepeatPersistableBundle(non_empty_bundle, &returned);
   ASSERT_TRUE(status.isOk()) << status.toString8();
   EXPECT_EQ(non_empty_bundle, returned);
 }

 TEST_F(AidlTest, ReversePersistableBundles) {
   if (!cpp_java_tests) GTEST_SKIP() << "Service does not support the CPP/Java-only tests.";

   PersistableBundle first;
   PersistableBundle second;
   PersistableBundle third;
   first.putInt(String16("test_int"), 1231);
   second.putLong(String16("test_long"), 222222L);
   third.putDouble(String16("test_double"), 10.8);
   const vector<PersistableBundle> original{first, second, third};

   vector<PersistableBundle> repeated;
   if (backend == BackendType::JAVA) {
     repeated = vector<PersistableBundle>(original.size());
   }
   vector<PersistableBundle> reversed;
   Status status = cpp_java_tests->ReversePersistableBundles(original, &repeated, &reversed);
   ASSERT_TRUE(status.isOk()) << status.toString8();

   EXPECT_EQ(repeated, original);

   std::reverse(reversed.begin(), reversed.end());
   EXPECT_EQ(reversed, original);
 }

 TEST_F(AidlTest, ReverseUnion) {
   if (!cpp_java_tests) GTEST_SKIP() << "Service does not support the CPP/Java-only tests.";

   Union original = Union::make<Union::ns>({1, 2, 3});
   Union repeated, reversed;
   Status status = cpp_java_tests->ReverseUnion(original, &repeated, &reversed);
   ASSERT_TRUE(status.isOk()) << status.toString8();

   EXPECT_EQ(repeated, original);

   std::reverse(reversed.get<Union::ns>().begin(), reversed.get<Union::ns>().end());
   EXPECT_EQ(reversed, original);
 }

 TEST_F(AidlTest, UnionUsage) {
   // default ctor inits with first member's default value
   EXPECT_EQ(Union::make<Union::ns>(), Union());

   // make<tag>(...) to create a value for a tag.
   Union one_two_three = Union::make<Union::ns>({1, 2, 3});

   // getTag() queries the tag of the content
   EXPECT_EQ(Union::ns, one_two_three.getTag());

   // Ctor(...) works if a target tag has a unique type among fields.
   EXPECT_EQ(one_two_three, Union(std::vector{1, 2, 3}));
   EXPECT_EQ(one_two_three, std::vector<int>({1, 2, 3}));

   // Use std::in_place_index<tag> to avoid "move"
   // Note that make<tag>(...) involves "move" of the content value
   EXPECT_EQ(Union::make<Union::ns>(3, 0), Union(std::in_place_index<Union::ns>, 3, 0));

   Union one_two = one_two_three;
   // get<tag> can be used to modify the content
   one_two.get<Union::ns>().pop_back();
   EXPECT_EQ(one_two, std::vector<int>({1, 2}));
   // get<tag> can be lvalue
   one_two.get<Union::ns>() = std::vector<int>{1, 2};
   EXPECT_EQ(one_two, std::vector<int>({1, 2}));

   // abort with a bad access
   EXPECT_DEATH(one_two.get<Union::n>(), "bad access");

   // set<tag>(...) overwrites the content with a new tag
   one_two_three.set<Union::s>("123");
   EXPECT_EQ(one_two_three, std::string("123"));

   // Or, you can simply assign a new value.
   // note that this works only if the target type is unique
   one_two_three = std::vector<std::string>{"1", "2", "3"};
   EXPECT_EQ(Union::ss, one_two_three.getTag());
 }

 TEST_F(AidlTest, UnionDefaultConstructorInitializeWithFirstMember) {
   EXPECT_EQ(Union::make<Union::ns>(), Union());  // int[] ns
   EXPECT_EQ(EnumUnion::make<EnumUnion::intEnum>(IntEnum::FOO),
             EnumUnion());  // IntEnum intEnum = IntEnum.FOO
 }

 TEST_F(AidlTest, StructuredParcelableEquality) {
   // TODO: break up equality tests, these are hard to read, because you need to
   // keep the state of the parcelables in mind
   StructuredParcelable parcelable1;
   StructuredParcelable parcelable2;

   parcelable1.f = 11;
   parcelable2.f = 11;

   service->FillOutStructuredParcelable(&parcelable1);
   service->FillOutStructuredParcelable(&parcelable2);

   sp<INamedCallback> callback1;
   sp<INamedCallback> callback2;
   service->GetOtherTestService(String16("callback1"), &callback1);
   service->GetOtherTestService(String16("callback2"), &callback2);

   parcelable1.ibinder = IInterface::asBinder(callback1);
   parcelable2.ibinder = IInterface::asBinder(callback1);

   EXPECT_EQ(parcelable1, parcelable2);

   parcelable1.f = 0;
   EXPECT_LT(parcelable1, parcelable2);
   parcelable1.f = 11;

   parcelable1.shouldBeJerry = "Jarry";
   EXPECT_LT(parcelable1, parcelable2);
   parcelable1.shouldBeJerry = "Jerry";

   parcelable2.shouldContainThreeFs = {};
   EXPECT_GT(parcelable1, parcelable2);
   parcelable2.shouldContainThreeFs = {parcelable2.f, parcelable2.f, parcelable2.f};

   parcelable2.shouldBeIntBar = IntEnum::FOO;
   EXPECT_GT(parcelable1, parcelable2);
   parcelable2.shouldBeIntBar = IntEnum::BAR;

   parcelable2.ibinder = IInterface::asBinder(callback2);
   EXPECT_NE(parcelable1, parcelable2);
 }

 TEST_F(AidlTest, ConfirmStructuredParcelables) {
   constexpr int kDesiredValue = 23;

   StructuredParcelable parcelable;
   parcelable.f = kDesiredValue;

   EXPECT_EQ(parcelable.stringDefaultsToFoo, String16("foo"));
   EXPECT_EQ(parcelable.byteDefaultsToFour, 4);
   EXPECT_EQ(parcelable.intDefaultsToFive, 5);
   EXPECT_EQ(parcelable.longDefaultsToNegativeSeven, -7);
   EXPECT_EQ(parcelable.booleanDefaultsToTrue, true);
   EXPECT_EQ(parcelable.charDefaultsToC, 'C');
   EXPECT_TRUE(parcelable.floatDefaultsToPi == 3.14f) << parcelable.floatDefaultsToPi;
   EXPECT_TRUE(parcelable.doubleWithDefault == -3.14e17) << parcelable.doubleWithDefault;

   EXPECT_EQ(parcelable.boolDefault, false);
   EXPECT_EQ(parcelable.byteDefault, 0);
   EXPECT_EQ(parcelable.intDefault, 0);
   EXPECT_EQ(parcelable.longDefault, 0);
   EXPECT_EQ(parcelable.floatDefault, 0.0f);
   EXPECT_EQ(parcelable.doubleDefault, 0.0);

   ASSERT_EQ(parcelable.arrayDefaultsTo123.size(), 3u);
   EXPECT_EQ(parcelable.arrayDefaultsTo123[0], 1);
   EXPECT_EQ(parcelable.arrayDefaultsTo123[1], 2);
   EXPECT_EQ(parcelable.arrayDefaultsTo123[2], 3);
   EXPECT_TRUE(parcelable.arrayDefaultsToEmpty.empty());

   EXPECT_EQ(parcelable.defaultWithFoo, IntEnum::FOO);

   service->FillOutStructuredParcelable(&parcelable);

   ASSERT_EQ(parcelable.shouldContainThreeFs.size(), 3u);
   EXPECT_EQ(parcelable.shouldContainThreeFs[0], kDesiredValue);
   EXPECT_EQ(parcelable.shouldContainThreeFs[1], kDesiredValue);
   EXPECT_EQ(parcelable.shouldContainThreeFs[2], kDesiredValue);

   EXPECT_EQ(parcelable.shouldBeJerry, "Jerry");
   EXPECT_EQ(parcelable.int32_min, INT32_MIN);
   EXPECT_EQ(parcelable.int32_max, INT32_MAX);
   EXPECT_EQ(parcelable.int64_max, INT64_MAX);
   EXPECT_EQ(parcelable.hexInt32_neg_1, -1);

   for (size_t ndx = 0; ndx < parcelable.int32_1.size(); ndx++) {
     EXPECT_EQ(parcelable.int32_1[ndx], 1) << ndx;
   }

   for (size_t ndx = 0; ndx < parcelable.int64_1.size(); ndx++) {
     EXPECT_EQ(parcelable.int64_1[ndx], 1) << ndx;
   }

   EXPECT_EQ(parcelable.hexInt32_pos_1, 1);
   EXPECT_EQ(parcelable.hexInt64_pos_1, 1);

   EXPECT_EQ(static_cast<int>(parcelable.const_exprs_1), 1);
   EXPECT_EQ(static_cast<int>(parcelable.const_exprs_2), 1);
   EXPECT_EQ(static_cast<int>(parcelable.const_exprs_3), 1);
   EXPECT_EQ(static_cast<int>(parcelable.const_exprs_4), 1);
   EXPECT_EQ(static_cast<int>(parcelable.const_exprs_5), 1);
   EXPECT_EQ(static_cast<int>(parcelable.const_exprs_6), 1);
   EXPECT_EQ(static_cast<int>(parcelable.const_exprs_7), 1);
   EXPECT_EQ(static_cast<int>(parcelable.const_exprs_8), 1);
   EXPECT_EQ(static_cast<int>(parcelable.const_exprs_9), 1);
   EXPECT_EQ(static_cast<int>(parcelable.const_exprs_10), 1);

   EXPECT_EQ(parcelable.addString1, "hello world!");
   EXPECT_EQ(parcelable.addString2, "The quick brown fox jumps over the lazy dog.");

   EXPECT_EQ(StructuredParcelable::BIT0 | StructuredParcelable::BIT2,
             parcelable.shouldSetBit0AndBit2);

   EXPECT_EQ(parcelable.u->get<Union::ns>(), vector<int32_t>({1, 2, 3}));
   EXPECT_EQ(parcelable.shouldBeConstS1->get<Union::s>(), Union::S1());
 }

 TEST_F(AidlTest, EmptyParcelableHolder) {
   using namespace android::aidl::tests::extension;
   android::Parcel parcel;
   {
     ExtendableParcelable ep;
     ep.writeToParcel(&parcel);
     std::shared_ptr<MyExt> emptyExt;
     ep.ext.getParcelable(&emptyExt);
     EXPECT_FALSE(emptyExt);
   }
   {
     parcel.setDataPosition(0);
     ExtendableParcelable ep;
     ep.readFromParcel(&parcel);
     std::shared_ptr<MyExt> emptyExt;
     ep.ext.getParcelable(&emptyExt);
     EXPECT_FALSE(emptyExt);
   }
 }

 TEST_F(AidlTest, ParcelableHolderEqualityOperator) {
   auto ph1 = android::os::ParcelableHolder(android::Parcelable::Stability::STABILITY_LOCAL);
   auto ph2 = android::os::ParcelableHolder(android::Parcelable::Stability::STABILITY_LOCAL);
   auto ph3 = android::os::ParcelableHolder(android::Parcelable::Stability::STABILITY_LOCAL);
   auto ptr1 = std::make_shared<MyExt>();
   auto ptr2 = std::make_shared<MyExt>();
   ptr1->a = 1;
   ptr1->b = "a";
   ptr2->a = 1;
   ptr2->b = "a";

   ph1.setParcelable(ptr1);
   ph2.setParcelable(ptr1);
   ph3.setParcelable(ptr2);

   // ParcelableHolder always uses its address as a comparison criterion.
   EXPECT_TRUE(ph1 != ph2);
   EXPECT_TRUE(ph2 != ph3);
   EXPECT_TRUE(ph1 == ph1);
   EXPECT_TRUE(ph2 == ph2);
   EXPECT_TRUE(ph3 == ph3);

   android::Parcel parcel;
   ph1.writeToParcel(&parcel);
   ph2.writeToParcel(&parcel);
   ph3.writeToParcel(&parcel);
   parcel.setDataPosition(0);

   ph1.readFromParcel(&parcel);
   ph2.readFromParcel(&parcel);
   ph3.readFromParcel(&parcel);

   // ParcelableHolder always uses its address as a comparison criterion.
   EXPECT_TRUE(ph1 != ph2);
   EXPECT_TRUE(ph2 != ph3);
   EXPECT_TRUE(ph1 == ph1);
   EXPECT_TRUE(ph2 == ph2);
   EXPECT_TRUE(ph3 == ph3);
 }

 TEST_F(AidlTest, NativeExtednableParcelable) {
   using namespace android::aidl::tests::extension;
   MyExt ext;
   ext.a = 42;
   ext.b = "EXT";

   MyExt2 ext2;
   ext2.a = 42;
   ext2.b.a = 24;
   ext2.b.b = "INEXT";
   ext2.c = "EXT2";
   android::Parcel parcel;
   {
     ExtendableParcelable ep;
     ep.a = 1;
     ep.b = "a";
     ep.c = 42L;

     EXPECT_TRUE(ep.ext.setParcelable(ext) == android::OK);
     EXPECT_TRUE(ep.ext2.setParcelable(ext2) == android::OK);

     std::shared_ptr<MyExtLike> extLike;
     ep.ext.getParcelable(&extLike);
     EXPECT_FALSE(extLike) << "The extension type must be MyExt, so it has to fail even though "
                              "MyExtLike has the same structure as MyExt.";

     std::shared_ptr<MyExt> actualExt;
     ep.ext.getParcelable(&actualExt);
     std::shared_ptr<MyExt2> actualExt2;
     ep.ext2.getParcelable(&actualExt2);

     EXPECT_TRUE(actualExt);
     EXPECT_TRUE(actualExt2);

     EXPECT_EQ(ext, *actualExt);
     EXPECT_EQ(ext2, *actualExt2);

     ep.writeToParcel(&parcel);
   }

   parcel.setDataPosition(0);
   {
     ExtendableParcelable ep;
     ep.readFromParcel(&parcel);

     std::shared_ptr<MyExtLike> extLike;
     ep.ext.getParcelable(&extLike);
     EXPECT_FALSE(extLike) << "The extension type must be MyExt, so it has to fail even though "
                              "MyExtLike has the same structure as MyExt.";

     std::shared_ptr<MyExt> actualExt;
     ep.ext.getParcelable(&actualExt);
     std::shared_ptr<MyExt2> actualExt2;
     ep.ext2.getParcelable(&actualExt2);

     std::shared_ptr<MyExt> emptyExt;
     ep.ext2.getParcelable(&emptyExt);
     EXPECT_FALSE(emptyExt);

     EXPECT_TRUE(actualExt);
     EXPECT_TRUE(actualExt2);

     EXPECT_EQ(ext, *actualExt);
     EXPECT_EQ(ext2, *actualExt2);
   }
 }

 TEST_F(AidlTest, ParcelableToString) {
   ParcelableForToString p;
   p.intValue = 10;
   p.intArray = {20, 30};
   p.longValue = 100L;
   p.longArray = {200L, 300L};
   p.doubleValue = 3.14;
   p.doubleArray = {1.1, 1.2};
   p.floatValue = 3.14f;
   p.floatArray = {1.1f, 1.2f};
   p.byteValue = 3;
   p.byteArray = {5, 6};
   p.booleanValue = true;
   p.booleanArray = {true, false};
   p.stringValue = String16("this is a string");
   p.stringArray = {String16("hello"), String16("world")};
   p.stringList = {String16("alice"), String16("bob")};
   OtherParcelableForToString op;
   op.field = String16("other");
   p.parcelableValue = op;
   p.parcelableArray = {op, op};
   p.enumValue = IntEnum::FOO;
   p.enumArray = {IntEnum::FOO, IntEnum::BAR};
   // p.nullArray = null;
   // p.nullList = null;
   GenericStructuredParcelable<int32_t, StructuredParcelable, IntEnum> gen;
   gen.a = 1;
   gen.b = 2;
   p.parcelableGeneric = gen;
   p.unionValue = Union(std::vector<std::string>{"union", "value"});

   const string expected =
       "ParcelableForToString{"
       "intValue: 10, "
       "intArray: [20, 30], "
       "longValue: 100, "
       "longArray: [200, 300], "
       "doubleValue: 3.140000, "
       "doubleArray: [1.100000, 1.200000], "
       "floatValue: 3.140000, "
       "floatArray: [1.100000, 1.200000], "
       "byteValue: 3, "
       "byteArray: [5, 6], "
       "booleanValue: true, "
       "booleanArray: [true, false], "
       "stringValue: this is a string, "
       "stringArray: [hello, world], "
       "stringList: [alice, bob], "
       "parcelableValue: OtherParcelableForToString{field: other}, "
       "parcelableArray: ["
       "OtherParcelableForToString{field: other}, "
       "OtherParcelableForToString{field: other}], "
       "enumValue: FOO, "
       "enumArray: [FOO, BAR], "
       "nullArray: [], "
       "nullList: [], "
       "parcelableGeneric: GenericStructuredParcelable{a: 1, b: 2}, "
       "unionValue: Union{ss: [union, value]}"
       "}";

   EXPECT_EQ(expected, p.toString());
 }
	/*
	* Copyright (C) 2015 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.
	*/

	#include <android/aidl/tests/ParcelableForToString.h>
	#include <android/aidl/tests/extension/MyExt.h>
	#include <android/aidl/tests/extension/MyExt2.h>
	#include <android/aidl/tests/extension/MyExtLike.h>
	#include <android/aidl/tests/unions/EnumUnion.h>
	#include "aidl_test_client.h"

	#include <string>
	#include <vector>

	using android::IInterface;
	using android::sp;
	using android::String16;
	using android::aidl::tests::ConstantExpressionEnum;
	using android::aidl::tests::GenericStructuredParcelable;
	using android::aidl::tests::INamedCallback;
	using android::aidl::tests::IntEnum;
	using android::aidl::tests::ITestService;
	using android::aidl::tests::OtherParcelableForToString;
	using android::aidl::tests::ParcelableForToString;
	using android::aidl::tests::SimpleParcelable;
	using android::aidl::tests::StructuredParcelable;
	using android::aidl::tests::Union;
	using android::aidl::tests::extension::ExtendableParcelable;
	using android::aidl::tests::extension::MyExt;
	using android::aidl::tests::extension::MyExt2;
	using android::aidl::tests::extension::MyExtLike;
	using android::aidl::tests::unions::EnumUnion;
	using android::binder::Status;
	using android::os::PersistableBundle;
	using std::string;
	using std::vector;

	TEST_F(AidlTest, RepeatSimpleParcelable) {
	if (!cpp_java_tests) GTEST_SKIP() << "Service does not support the CPP/Java-only tests.";

	SimpleParcelable input("Booya", 42);
	SimpleParcelable out_param, returned;
	Status status = cpp_java_tests->RepeatSimpleParcelable(input, &out_param, &returned);
	ASSERT_TRUE(status.isOk()) << status.toString8();
	EXPECT_EQ(input, out_param) << input.toString() << " " << out_param.toString();
	EXPECT_EQ(input, returned) << input.toString() << " " << returned.toString();
	}

	TEST_F(AidlTest, RepeatGenericStructureParcelable) {
	if (!cpp_java_tests) GTEST_SKIP() << "Service does not support the CPP/Java-only tests.";

	GenericStructuredParcelable<int32_t, StructuredParcelable, IntEnum> input, out_param, returned;
	input.a = 41;
	input.b = 42;
	Status status = cpp_java_tests->RepeatGenericParcelable(input, &out_param, &returned);
	ASSERT_TRUE(status.isOk()) << status.toString8();
	EXPECT_EQ(input, out_param);
	EXPECT_EQ(input, returned);
	}

	TEST_F(AidlTest, ReverseSimpleParcelable) {
	if (!cpp_java_tests) GTEST_SKIP() << "Service does not support the CPP/Java-only tests.";

	const vector<SimpleParcelable> original{SimpleParcelable("first", 0),
	SimpleParcelable("second", 1),
	SimpleParcelable("third", 2)};
	vector<SimpleParcelable> repeated;
	if (backend == BackendType::JAVA) {
	repeated = vector<SimpleParcelable>(original.size());
	}
	vector<SimpleParcelable> reversed;
	Status status = cpp_java_tests->ReverseSimpleParcelables(original, &repeated, &reversed);
	ASSERT_TRUE(status.isOk()) << status.toString8();

	EXPECT_EQ(repeated, original);

	std::reverse(reversed.begin(), reversed.end());
	EXPECT_EQ(reversed, original);
	}

	TEST_F(AidlTest, ConfirmPersistableBundles) {
	if (!cpp_java_tests) GTEST_SKIP() << "Service does not support the CPP/Java-only tests.";

	PersistableBundle empty_bundle, returned;
	Status status = cpp_java_tests->RepeatPersistableBundle(empty_bundle, &returned);
	ASSERT_TRUE(status.isOk()) << status.toString8();
	EXPECT_EQ(empty_bundle, returned);
	}

	TEST_F(AidlTest, ConfirmPersistableBundlesNonEmpty) {
	if (!cpp_java_tests) GTEST_SKIP() << "Service does not support the CPP/Java-only tests.";

	PersistableBundle non_empty_bundle, returned;
	non_empty_bundle.putBoolean(String16("test_bool"), false);
	non_empty_bundle.putInt(String16("test_int"), 33);
	non_empty_bundle.putLong(String16("test_long"), 34359738368L);
	non_empty_bundle.putDouble(String16("test_double"), 1.1);
	non_empty_bundle.putString(String16("test_string"), String16("Woot!"));
	non_empty_bundle.putBooleanVector(String16("test_bool_vector"),
	{true, false, true});
	non_empty_bundle.putIntVector(String16("test_int_vector"), {33, 44, 55, 142});
	non_empty_bundle.putLongVector(String16("test_long_vector"),
	{34L, 8371L, 34359738375L});
	non_empty_bundle.putDoubleVector(String16("test_double_vector"), {2.2, 5.4});
	non_empty_bundle.putStringVector(String16("test_string_vector"),
	{String16("hello"), String16("world!")});
	PersistableBundle nested_bundle;
	nested_bundle.putInt(String16("test_nested_int"), 345);
	non_empty_bundle.putPersistableBundle(String16("test_persistable_bundle"),
	nested_bundle);

	Status status = cpp_java_tests->RepeatPersistableBundle(non_empty_bundle, &returned);
	ASSERT_TRUE(status.isOk()) << status.toString8();
	EXPECT_EQ(non_empty_bundle, returned);
	}

	TEST_F(AidlTest, ReversePersistableBundles) {
	if (!cpp_java_tests) GTEST_SKIP() << "Service does not support the CPP/Java-only tests.";

	PersistableBundle first;
	PersistableBundle second;
	PersistableBundle third;
	first.putInt(String16("test_int"), 1231);
	second.putLong(String16("test_long"), 222222L);
	third.putDouble(String16("test_double"), 10.8);
	const vector<PersistableBundle> original{first, second, third};

	vector<PersistableBundle> repeated;
	if (backend == BackendType::JAVA) {
	repeated = vector<PersistableBundle>(original.size());
	}
	vector<PersistableBundle> reversed;
	Status status = cpp_java_tests->ReversePersistableBundles(original, &repeated, &reversed);
	ASSERT_TRUE(status.isOk()) << status.toString8();

	EXPECT_EQ(repeated, original);

	std::reverse(reversed.begin(), reversed.end());
	EXPECT_EQ(reversed, original);
	}

	TEST_F(AidlTest, ReverseUnion) {
	if (!cpp_java_tests) GTEST_SKIP() << "Service does not support the CPP/Java-only tests.";

	Union original = Union::make<Union::ns>({1, 2, 3});
	Union repeated, reversed;
	Status status = cpp_java_tests->ReverseUnion(original, &repeated, &reversed);
	ASSERT_TRUE(status.isOk()) << status.toString8();

	EXPECT_EQ(repeated, original);

	std::reverse(reversed.get<Union::ns>().begin(), reversed.get<Union::ns>().end());
	EXPECT_EQ(reversed, original);
	}

	TEST_F(AidlTest, UnionUsage) {
	// default ctor inits with first member's default value
	EXPECT_EQ(Union::make<Union::ns>(), Union());

	// make<tag>(...) to create a value for a tag.
	Union one_two_three = Union::make<Union::ns>({1, 2, 3});

	// getTag() queries the tag of the content
	EXPECT_EQ(Union::ns, one_two_three.getTag());

	// Ctor(...) works if a target tag has a unique type among fields.
	EXPECT_EQ(one_two_three, Union(std::vector{1, 2, 3}));
	EXPECT_EQ(one_two_three, std::vector<int>({1, 2, 3}));

	// Use std::in_place_index<tag> to avoid "move"
	// Note that make<tag>(...) involves "move" of the content value
	EXPECT_EQ(Union::make<Union::ns>(3, 0), Union(std::in_place_index<Union::ns>, 3, 0));

	Union one_two = one_two_three;
	// get<tag> can be used to modify the content
	one_two.get<Union::ns>().pop_back();
	EXPECT_EQ(one_two, std::vector<int>({1, 2}));
	// get<tag> can be lvalue
	one_two.get<Union::ns>() = std::vector<int>{1, 2};
	EXPECT_EQ(one_two, std::vector<int>({1, 2}));

	// abort with a bad access
	EXPECT_DEATH(one_two.get<Union::n>(), "bad access");

	// set<tag>(...) overwrites the content with a new tag
	one_two_three.set<Union::s>("123");
	EXPECT_EQ(one_two_three, std::string("123"));

	// Or, you can simply assign a new value.
	// note that this works only if the target type is unique
	one_two_three = std::vector<std::string>{"1", "2", "3"};
	EXPECT_EQ(Union::ss, one_two_three.getTag());
	}

	TEST_F(AidlTest, UnionDefaultConstructorInitializeWithFirstMember) {
	EXPECT_EQ(Union::make<Union::ns>(), Union()); // int[] ns
	EXPECT_EQ(EnumUnion::make<EnumUnion::intEnum>(IntEnum::FOO),
	EnumUnion()); // IntEnum intEnum = IntEnum.FOO
	}

	TEST_F(AidlTest, StructuredParcelableEquality) {
	// TODO: break up equality tests, these are hard to read, because you need to
	// keep the state of the parcelables in mind
	StructuredParcelable parcelable1;
	StructuredParcelable parcelable2;

	parcelable1.f = 11;
	parcelable2.f = 11;

	service->FillOutStructuredParcelable(&parcelable1);
	service->FillOutStructuredParcelable(&parcelable2);

	sp<INamedCallback> callback1;
	sp<INamedCallback> callback2;
	service->GetOtherTestService(String16("callback1"), &callback1);
	service->GetOtherTestService(String16("callback2"), &callback2);

	parcelable1.ibinder = IInterface::asBinder(callback1);
	parcelable2.ibinder = IInterface::asBinder(callback1);

	EXPECT_EQ(parcelable1, parcelable2);

	parcelable1.f = 0;
	EXPECT_LT(parcelable1, parcelable2);
	parcelable1.f = 11;

	parcelable1.shouldBeJerry = "Jarry";
	EXPECT_LT(parcelable1, parcelable2);
	parcelable1.shouldBeJerry = "Jerry";

	parcelable2.shouldContainThreeFs = {};
	EXPECT_GT(parcelable1, parcelable2);
	parcelable2.shouldContainThreeFs = {parcelable2.f, parcelable2.f, parcelable2.f};

	parcelable2.shouldBeIntBar = IntEnum::FOO;
	EXPECT_GT(parcelable1, parcelable2);
	parcelable2.shouldBeIntBar = IntEnum::BAR;

	parcelable2.ibinder = IInterface::asBinder(callback2);
	EXPECT_NE(parcelable1, parcelable2);
	}

	TEST_F(AidlTest, ConfirmStructuredParcelables) {
	constexpr int kDesiredValue = 23;

	StructuredParcelable parcelable;
	parcelable.f = kDesiredValue;

	EXPECT_EQ(parcelable.stringDefaultsToFoo, String16("foo"));
	EXPECT_EQ(parcelable.byteDefaultsToFour, 4);
	EXPECT_EQ(parcelable.intDefaultsToFive, 5);
	EXPECT_EQ(parcelable.longDefaultsToNegativeSeven, -7);
	EXPECT_EQ(parcelable.booleanDefaultsToTrue, true);
	EXPECT_EQ(parcelable.charDefaultsToC, 'C');
	EXPECT_TRUE(parcelable.floatDefaultsToPi == 3.14f) << parcelable.floatDefaultsToPi;
	EXPECT_TRUE(parcelable.doubleWithDefault == -3.14e17) << parcelable.doubleWithDefault;

	EXPECT_EQ(parcelable.boolDefault, false);
	EXPECT_EQ(parcelable.byteDefault, 0);
	EXPECT_EQ(parcelable.intDefault, 0);
	EXPECT_EQ(parcelable.longDefault, 0);
	EXPECT_EQ(parcelable.floatDefault, 0.0f);
	EXPECT_EQ(parcelable.doubleDefault, 0.0);

	ASSERT_EQ(parcelable.arrayDefaultsTo123.size(), 3u);
	EXPECT_EQ(parcelable.arrayDefaultsTo123[0], 1);
	EXPECT_EQ(parcelable.arrayDefaultsTo123[1], 2);
	EXPECT_EQ(parcelable.arrayDefaultsTo123[2], 3);
	EXPECT_TRUE(parcelable.arrayDefaultsToEmpty.empty());

	EXPECT_EQ(parcelable.defaultWithFoo, IntEnum::FOO);

	service->FillOutStructuredParcelable(&parcelable);

	ASSERT_EQ(parcelable.shouldContainThreeFs.size(), 3u);
	EXPECT_EQ(parcelable.shouldContainThreeFs[0], kDesiredValue);
	EXPECT_EQ(parcelable.shouldContainThreeFs[1], kDesiredValue);
	EXPECT_EQ(parcelable.shouldContainThreeFs[2], kDesiredValue);

	EXPECT_EQ(parcelable.shouldBeJerry, "Jerry");
	EXPECT_EQ(parcelable.int32_min, INT32_MIN);
	EXPECT_EQ(parcelable.int32_max, INT32_MAX);
	EXPECT_EQ(parcelable.int64_max, INT64_MAX);
	EXPECT_EQ(parcelable.hexInt32_neg_1, -1);

	for (size_t ndx = 0; ndx < parcelable.int32_1.size(); ndx++) {
	EXPECT_EQ(parcelable.int32_1[ndx], 1) << ndx;
	}

	for (size_t ndx = 0; ndx < parcelable.int64_1.size(); ndx++) {
	EXPECT_EQ(parcelable.int64_1[ndx], 1) << ndx;
	}

	EXPECT_EQ(parcelable.hexInt32_pos_1, 1);
	EXPECT_EQ(parcelable.hexInt64_pos_1, 1);

	EXPECT_EQ(static_cast<int>(parcelable.const_exprs_1), 1);
	EXPECT_EQ(static_cast<int>(parcelable.const_exprs_2), 1);
	EXPECT_EQ(static_cast<int>(parcelable.const_exprs_3), 1);
	EXPECT_EQ(static_cast<int>(parcelable.const_exprs_4), 1);
	EXPECT_EQ(static_cast<int>(parcelable.const_exprs_5), 1);
	EXPECT_EQ(static_cast<int>(parcelable.const_exprs_6), 1);
	EXPECT_EQ(static_cast<int>(parcelable.const_exprs_7), 1);
	EXPECT_EQ(static_cast<int>(parcelable.const_exprs_8), 1);
	EXPECT_EQ(static_cast<int>(parcelable.const_exprs_9), 1);
	EXPECT_EQ(static_cast<int>(parcelable.const_exprs_10), 1);

	EXPECT_EQ(parcelable.addString1, "hello world!");
	EXPECT_EQ(parcelable.addString2, "The quick brown fox jumps over the lazy dog.");

	EXPECT_EQ(StructuredParcelable::BIT0 \| StructuredParcelable::BIT2,
	parcelable.shouldSetBit0AndBit2);

	EXPECT_EQ(parcelable.u->get<Union::ns>(), vector<int32_t>({1, 2, 3}));
	EXPECT_EQ(parcelable.shouldBeConstS1->get<Union::s>(), Union::S1());
	}

	TEST_F(AidlTest, EmptyParcelableHolder) {
	using namespace android::aidl::tests::extension;
	android::Parcel parcel;
	{
	ExtendableParcelable ep;
	ep.writeToParcel(&parcel);
	std::shared_ptr<MyExt> emptyExt;
	ep.ext.getParcelable(&emptyExt);
	EXPECT_FALSE(emptyExt);
	}
	{
	parcel.setDataPosition(0);
	ExtendableParcelable ep;
	ep.readFromParcel(&parcel);
	std::shared_ptr<MyExt> emptyExt;
	ep.ext.getParcelable(&emptyExt);
	EXPECT_FALSE(emptyExt);
	}
	}

	TEST_F(AidlTest, ParcelableHolderEqualityOperator) {
	auto ph1 = android::os::ParcelableHolder(android::Parcelable::Stability::STABILITY_LOCAL);
	auto ph2 = android::os::ParcelableHolder(android::Parcelable::Stability::STABILITY_LOCAL);
	auto ph3 = android::os::ParcelableHolder(android::Parcelable::Stability::STABILITY_LOCAL);
	auto ptr1 = std::make_shared<MyExt>();
	auto ptr2 = std::make_shared<MyExt>();
	ptr1->a = 1;
	ptr1->b = "a";
	ptr2->a = 1;
	ptr2->b = "a";

	ph1.setParcelable(ptr1);
	ph2.setParcelable(ptr1);
	ph3.setParcelable(ptr2);

	// ParcelableHolder always uses its address as a comparison criterion.
	EXPECT_TRUE(ph1 != ph2);
	EXPECT_TRUE(ph2 != ph3);
	EXPECT_TRUE(ph1 == ph1);
	EXPECT_TRUE(ph2 == ph2);
	EXPECT_TRUE(ph3 == ph3);

	android::Parcel parcel;
	ph1.writeToParcel(&parcel);
	ph2.writeToParcel(&parcel);
	ph3.writeToParcel(&parcel);
	parcel.setDataPosition(0);

	ph1.readFromParcel(&parcel);
	ph2.readFromParcel(&parcel);
	ph3.readFromParcel(&parcel);

	// ParcelableHolder always uses its address as a comparison criterion.
	EXPECT_TRUE(ph1 != ph2);
	EXPECT_TRUE(ph2 != ph3);
	EXPECT_TRUE(ph1 == ph1);
	EXPECT_TRUE(ph2 == ph2);
	EXPECT_TRUE(ph3 == ph3);
	}

	TEST_F(AidlTest, NativeExtednableParcelable) {
	using namespace android::aidl::tests::extension;
	MyExt ext;
	ext.a = 42;
	ext.b = "EXT";

	MyExt2 ext2;
	ext2.a = 42;
	ext2.b.a = 24;
	ext2.b.b = "INEXT";
	ext2.c = "EXT2";
	android::Parcel parcel;
	{
	ExtendableParcelable ep;
	ep.a = 1;
	ep.b = "a";
	ep.c = 42L;

	EXPECT_TRUE(ep.ext.setParcelable(ext) == android::OK);
	EXPECT_TRUE(ep.ext2.setParcelable(ext2) == android::OK);

	std::shared_ptr<MyExtLike> extLike;
	ep.ext.getParcelable(&extLike);
	EXPECT_FALSE(extLike) << "The extension type must be MyExt, so it has to fail even though "
	"MyExtLike has the same structure as MyExt.";

	std::shared_ptr<MyExt> actualExt;
	ep.ext.getParcelable(&actualExt);
	std::shared_ptr<MyExt2> actualExt2;
	ep.ext2.getParcelable(&actualExt2);

	EXPECT_TRUE(actualExt);
	EXPECT_TRUE(actualExt2);

	EXPECT_EQ(ext, *actualExt);
	EXPECT_EQ(ext2, *actualExt2);

	ep.writeToParcel(&parcel);
	}

	parcel.setDataPosition(0);
	{
	ExtendableParcelable ep;
	ep.readFromParcel(&parcel);

	std::shared_ptr<MyExtLike> extLike;
	ep.ext.getParcelable(&extLike);
	EXPECT_FALSE(extLike) << "The extension type must be MyExt, so it has to fail even though "
	"MyExtLike has the same structure as MyExt.";

	std::shared_ptr<MyExt> actualExt;
	ep.ext.getParcelable(&actualExt);
	std::shared_ptr<MyExt2> actualExt2;
	ep.ext2.getParcelable(&actualExt2);

	std::shared_ptr<MyExt> emptyExt;
	ep.ext2.getParcelable(&emptyExt);
	EXPECT_FALSE(emptyExt);

	EXPECT_TRUE(actualExt);
	EXPECT_TRUE(actualExt2);

	EXPECT_EQ(ext, *actualExt);
	EXPECT_EQ(ext2, *actualExt2);
	}
	}

	TEST_F(AidlTest, ParcelableToString) {
	ParcelableForToString p;
	p.intValue = 10;
	p.intArray = {20, 30};
	p.longValue = 100L;
	p.longArray = {200L, 300L};
	p.doubleValue = 3.14;
	p.doubleArray = {1.1, 1.2};
	p.floatValue = 3.14f;
	p.floatArray = {1.1f, 1.2f};
	p.byteValue = 3;
	p.byteArray = {5, 6};
	p.booleanValue = true;
	p.booleanArray = {true, false};
	p.stringValue = String16("this is a string");
	p.stringArray = {String16("hello"), String16("world")};
	p.stringList = {String16("alice"), String16("bob")};
	OtherParcelableForToString op;
	op.field = String16("other");
	p.parcelableValue = op;
	p.parcelableArray = {op, op};
	p.enumValue = IntEnum::FOO;
	p.enumArray = {IntEnum::FOO, IntEnum::BAR};
	// p.nullArray = null;
	// p.nullList = null;
	GenericStructuredParcelable<int32_t, StructuredParcelable, IntEnum> gen;
	gen.a = 1;
	gen.b = 2;
	p.parcelableGeneric = gen;
	p.unionValue = Union(std::vector<std::string>{"union", "value"});

	const string expected =
	"ParcelableForToString{"
	"intValue: 10, "
	"intArray: [20, 30], "
	"longValue: 100, "
	"longArray: [200, 300], "
	"doubleValue: 3.140000, "
	"doubleArray: [1.100000, 1.200000], "
	"floatValue: 3.140000, "
	"floatArray: [1.100000, 1.200000], "
	"byteValue: 3, "
	"byteArray: [5, 6], "
	"booleanValue: true, "
	"booleanArray: [true, false], "
	"stringValue: this is a string, "
	"stringArray: [hello, world], "
	"stringList: [alice, bob], "
	"parcelableValue: OtherParcelableForToString{field: other}, "
	"parcelableArray: ["
	"OtherParcelableForToString{field: other}, "
	"OtherParcelableForToString{field: other}], "
	"enumValue: FOO, "
	"enumArray: [FOO, BAR], "
	"nullArray: [], "
	"nullList: [], "
	"parcelableGeneric: GenericStructuredParcelable{a: 1, b: 2}, "
	"unionValue: Union{ss: [union, value]}"
	"}";

	EXPECT_EQ(expected, p.toString());
	}