1 files changed, 0 insertions, 454 deletions
diff --git a/libs/binder/rust/tests/serialization.cpp b/libs/binder/rust/tests/serialization.cpp
deleted file mode 100644
index ec780f28a1..0000000000
--- a/libs/binder/rust/tests/serialization.cpp
+++ /dev/null
@@ -1,454 +0,0 @@
-/*
- * Copyright (C) 2020 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/binder_ibinder_platform.h>
-#include <android/binder_libbinder.h>
-#include <binder/IServiceManager.h>
-#include <binder/Parcel.h>
-#include <binder/ParcelFileDescriptor.h>
-#include <binder/ProcessState.h>
-#include <binder/Status.h>
-#include <gtest/gtest.h>
-#include <utils/Errors.h>
-#include <utils/String16.h>
-#include "android-base/file.h"
-#include "serialization.hpp"
-
-#include <cmath>
-#include <cstdint>
-#include <iostream>
-#include <optional>
-
-using namespace std;
-using namespace android;
-using android::base::unique_fd;
-using android::os::ParcelFileDescriptor;
-
-// defined in Rust
-extern "C" AIBinder *rust_service();
-
-
-const int8_t TESTDATA_I8[4] = {-128, 0, 117, 127};
-const uint8_t TESTDATA_U8[4] = {0, 42, 117, 255};
-const char16_t TESTDATA_CHARS[4] = {0, 42, 117, numeric_limits<char16_t>::max()};
-const int32_t TESTDATA_I32[4] = {numeric_limits<int32_t>::min(), 0, 117, numeric_limits<int32_t>::max()};
-const int64_t TESTDATA_I64[4] = {numeric_limits<int64_t>::min(), 0, 117, numeric_limits<int64_t>::max()};
-const uint64_t TESTDATA_U64[4] = {0, 42, 117, numeric_limits<uint64_t>::max()};
-const float TESTDATA_FLOAT[4] = {
-        numeric_limits<float>::quiet_NaN(),
-        -numeric_limits<float>::infinity(),
-        117.0,
-        numeric_limits<float>::infinity(),
-};
-const double TESTDATA_DOUBLE[4] = {
-        numeric_limits<double>::quiet_NaN(),
-        -numeric_limits<double>::infinity(),
-        117.0,
-        numeric_limits<double>::infinity(),
-};
-const bool TESTDATA_BOOL[4] = {true, false, false, true};
-const char* const TESTDATA_STRS[4] = {"", nullptr, "test", ""};
-
-static ::testing::Environment* gEnvironment;
-
-class SerializationEnvironment : public ::testing::Environment {
-public:
-    void SetUp() override {
-        m_server = AIBinder_toPlatformBinder(rust_service());
-    }
-
-    sp<IBinder> getServer(void) { return m_server; }
-
-private:
-    sp<IBinder> m_server;
-};
-
-
-class SerializationTest : public ::testing::Test {
-protected:
-    void SetUp() override {
-        ASSERT_NE(gEnvironment, nullptr);
-        m_server = static_cast<SerializationEnvironment *>(gEnvironment)->getServer();
-    }
-
-    sp<IBinder> m_server;
-};
-
-
-TEST_F(SerializationTest, SerializeBool) {
-    android::Parcel data;
-    data.writeInterfaceToken(String16("read_parcel_test"));
-
-    vector<bool> bools(begin(TESTDATA_BOOL), end(TESTDATA_BOOL));
-    ASSERT_EQ(data.writeBool(true), OK);
-    ASSERT_EQ(data.writeBool(false), OK);
-    ASSERT_EQ(data.writeBoolVector(bools), OK);
-    ASSERT_EQ(data.writeBoolVector(nullopt), OK);
-
-    android::Parcel reply;
-    ASSERT_EQ(m_server->transact(TEST_BOOL, data, &reply), OK);
-
-    vector<bool> read_bools;
-    optional<vector<bool>> maybe_bools;
-    ASSERT_EQ(reply.readBool(), true);
-    ASSERT_EQ(reply.readBool(), false);
-    ASSERT_EQ(reply.readBoolVector(&read_bools), OK);
-    ASSERT_EQ(read_bools, bools);
-    ASSERT_EQ(reply.readBoolVector(&maybe_bools), OK);
-    ASSERT_EQ(maybe_bools, nullopt);
-
-    int32_t end;
-    ASSERT_EQ(reply.readInt32(&end), NOT_ENOUGH_DATA);
-}
-
-TEST_F(SerializationTest, SerializeByte) {
-    android::Parcel data;
-    data.writeInterfaceToken(String16("read_parcel_test"));
-
-    vector<int8_t> i8s(begin(TESTDATA_I8), end(TESTDATA_I8));
-    vector<uint8_t> u8s(begin(TESTDATA_U8), end(TESTDATA_U8));
-    data.writeByte(0);
-    data.writeByte(1);
-    data.writeByte(numeric_limits<int8_t>::max());
-    data.writeByteVector(i8s);
-    data.writeByteVector(u8s);
-    data.writeByteVector(optional<vector<int8_t>>({}));
-
-    android::Parcel reply;
-    ASSERT_EQ(m_server->transact(TEST_BYTE, data, &reply), OK);
-
-    vector<int8_t> read_i8s;
-    vector<uint8_t> read_u8s;
-    optional<vector<int8_t>> maybe_i8s;
-    ASSERT_EQ(reply.readByte(), 0);
-    ASSERT_EQ(reply.readByte(), 1);
-    ASSERT_EQ(reply.readByte(), numeric_limits<int8_t>::max());
-    ASSERT_EQ(reply.readByteVector(&read_i8s), OK);
-    ASSERT_EQ(read_i8s, i8s);
-    ASSERT_EQ(reply.readByteVector(&read_u8s), OK);
-    ASSERT_EQ(read_u8s, u8s);
-    ASSERT_EQ(reply.readByteVector(&maybe_i8s), OK);
-    ASSERT_EQ(maybe_i8s, nullopt);
-
-    int32_t end;
-    ASSERT_EQ(reply.readInt32(&end), NOT_ENOUGH_DATA);
-}
-
-TEST_F(SerializationTest, SerializeU16) {
-    android::Parcel data;
-    data.writeInterfaceToken(String16("read_parcel_test"));
-
-    vector<char16_t> chars(begin(TESTDATA_CHARS), end(TESTDATA_CHARS));
-    data.writeChar(0);
-    data.writeChar(1);
-    data.writeChar(numeric_limits<char16_t>::max());
-    data.writeCharVector(chars);
-    data.writeCharVector(nullopt);
-
-    android::Parcel reply;
-    ASSERT_EQ(m_server->transact(TEST_U16, data, &reply), OK);
-
-    vector<char16_t> read_chars;
-    optional<vector<char16_t>> maybe_chars;
-    ASSERT_EQ(reply.readChar(), 0);
-    ASSERT_EQ(reply.readChar(), 1);
-    ASSERT_EQ(reply.readChar(), numeric_limits<char16_t>::max());
-    ASSERT_EQ(reply.readCharVector(&read_chars), OK);
-    ASSERT_EQ(read_chars, chars);
-    ASSERT_EQ(reply.readCharVector(&maybe_chars), OK);
-    ASSERT_EQ(maybe_chars, nullopt);
-
-    int32_t end;
-    ASSERT_EQ(reply.readInt32(&end), NOT_ENOUGH_DATA);
-}
-
-TEST_F(SerializationTest, SerializeI32) {
-    android::Parcel data;
-    data.writeInterfaceToken(String16("read_parcel_test"));
-
-    vector<int32_t> i32s(begin(TESTDATA_I32), end(TESTDATA_I32));
-    data.writeInt32(0);
-    data.writeInt32(1);
-    data.writeInt32(numeric_limits<int32_t>::max());
-    data.writeInt32Vector(i32s);
-    data.writeInt32Vector(nullopt);
-
-    android::Parcel reply;
-    ASSERT_EQ(m_server->transact(TEST_I32, data, &reply), OK);
-
-    vector<int32_t> read_i32s;
-    optional<vector<int32_t>> maybe_i32s;
-    ASSERT_EQ(reply.readInt32(), 0);
-    ASSERT_EQ(reply.readInt32(), 1);
-    ASSERT_EQ(reply.readInt32(), numeric_limits<int32_t>::max());
-    ASSERT_EQ(reply.readInt32Vector(&read_i32s), OK);
-    ASSERT_EQ(read_i32s, i32s);
-    ASSERT_EQ(reply.readInt32Vector(&maybe_i32s), OK);
-    ASSERT_EQ(maybe_i32s, nullopt);
-
-    int32_t end;
-    ASSERT_EQ(reply.readInt32(&end), NOT_ENOUGH_DATA);
-}
-
-TEST_F(SerializationTest, SerializeI64) {
-    android::Parcel data;
-    data.writeInterfaceToken(String16("read_parcel_test"));
-
-    vector<int64_t> i64s(begin(TESTDATA_I64), end(TESTDATA_I64));
-    data.writeInt64(0);
-    data.writeInt64(1);
-    data.writeInt64(numeric_limits<int64_t>::max());
-    data.writeInt64Vector(i64s);
-    data.writeInt64Vector(nullopt);
-
-    android::Parcel reply;
-    ASSERT_EQ(m_server->transact(TEST_I64, data, &reply), OK);
-
-    vector<int64_t> read_i64s;
-    optional<vector<int64_t>> maybe_i64s;
-    ASSERT_EQ(reply.readInt64(), 0);
-    ASSERT_EQ(reply.readInt64(), 1);
-    ASSERT_EQ(reply.readInt64(), numeric_limits<int64_t>::max());
-    ASSERT_EQ(reply.readInt64Vector(&read_i64s), OK);
-    ASSERT_EQ(read_i64s, i64s);
-    ASSERT_EQ(reply.readInt64Vector(&maybe_i64s), OK);
-    ASSERT_EQ(maybe_i64s, nullopt);
-
-    int32_t end;
-    ASSERT_EQ(reply.readInt32(&end), NOT_ENOUGH_DATA);
-}
-
-TEST_F(SerializationTest, SerializeU64) {
-    android::Parcel data;
-    data.writeInterfaceToken(String16("read_parcel_test"));
-
-    vector<uint64_t> u64s(begin(TESTDATA_U64), end(TESTDATA_U64));
-    data.writeUint64(0);
-    data.writeUint64(1);
-    data.writeUint64(numeric_limits<uint64_t>::max());
-    data.writeUint64Vector(u64s);
-    data.writeUint64Vector(nullopt);
-
-    android::Parcel reply;
-    ASSERT_EQ(m_server->transact(TEST_U64, data, &reply), OK);
-
-    vector<uint64_t> read_u64s;
-    optional<vector<uint64_t>> maybe_u64s;
-    ASSERT_EQ(reply.readUint64(), 0);
-    ASSERT_EQ(reply.readUint64(), 1);
-    ASSERT_EQ(reply.readUint64(), numeric_limits<uint64_t>::max());
-    ASSERT_EQ(reply.readUint64Vector(&read_u64s), OK);
-    ASSERT_EQ(read_u64s, u64s);
-    ASSERT_EQ(reply.readUint64Vector(&maybe_u64s), OK);
-    ASSERT_EQ(maybe_u64s, nullopt);
-
-    int32_t end;
-    ASSERT_EQ(reply.readInt32(&end), NOT_ENOUGH_DATA);
-}
-
-TEST_F(SerializationTest, SerializeF32) {
-    android::Parcel data;
-    data.writeInterfaceToken(String16("read_parcel_test"));
-
-    vector<float> floats(begin(TESTDATA_FLOAT), end(TESTDATA_FLOAT));
-    data.writeFloat(0);
-    data.writeFloatVector(floats);
-    data.writeFloatVector(nullopt);
-
-    android::Parcel reply;
-    ASSERT_EQ(m_server->transact(TEST_F32, data, &reply), OK);
-
-    vector<float> read_floats;
-    optional<vector<float>> maybe_floats;
-    ASSERT_EQ(reply.readFloat(), 0);
-    ASSERT_EQ(reply.readFloatVector(&read_floats), OK);
-    ASSERT_TRUE(isnan(read_floats[0]));
-    ASSERT_EQ(read_floats[1], floats[1]);
-    ASSERT_EQ(read_floats[2], floats[2]);
-    ASSERT_EQ(read_floats[3], floats[3]);
-    ASSERT_EQ(reply.readFloatVector(&maybe_floats), OK);
-    ASSERT_EQ(maybe_floats, nullopt);
-
-    int32_t end;
-    ASSERT_EQ(reply.readInt32(&end), NOT_ENOUGH_DATA);
-}
-
-TEST_F(SerializationTest, SerializeF64) {
-    android::Parcel data;
-    data.writeInterfaceToken(String16("read_parcel_test"));
-
-    vector<double> doubles(begin(TESTDATA_DOUBLE), end(TESTDATA_DOUBLE));
-    data.writeDouble(0);
-    data.writeDoubleVector(doubles);
-    data.writeDoubleVector(nullopt);
-
-    android::Parcel reply;
-    ASSERT_EQ(m_server->transact(TEST_F64, data, &reply), OK);
-
-    vector<double> read_doubles;
-    optional<vector<double>> maybe_doubles;
-    ASSERT_EQ(reply.readDouble(), 0);
-    ASSERT_EQ(reply.readDoubleVector(&read_doubles), OK);
-    ASSERT_TRUE(isnan(read_doubles[0]));
-    ASSERT_EQ(read_doubles[1], doubles[1]);
-    ASSERT_EQ(read_doubles[2], doubles[2]);
-    ASSERT_EQ(read_doubles[3], doubles[3]);
-    ASSERT_EQ(reply.readDoubleVector(&maybe_doubles), OK);
-    ASSERT_EQ(maybe_doubles, nullopt);
-
-    int32_t end;
-    ASSERT_EQ(reply.readInt32(&end), NOT_ENOUGH_DATA);
-}
-
-TEST_F(SerializationTest, SerializeString) {
-    android::Parcel data;
-    data.writeInterfaceToken(String16("read_parcel_test"));
-
-    vector<optional<String16>> strings;
-    for (auto I = begin(TESTDATA_STRS), E = end(TESTDATA_STRS); I != E; ++I) {
-        if (*I == nullptr) {
-            strings.push_back(optional<String16>());
-        } else {
-            strings.emplace_back(*I);
-        }
-    }
-    data.writeUtf8AsUtf16(string("testing"));
-    data.writeString16(nullopt);
-    data.writeString16Vector(strings);
-    data.writeString16Vector(nullopt);
-
-    android::Parcel reply;
-    ASSERT_EQ(m_server->transact(TEST_STRING, data, &reply), OK);
-
-    optional<String16> maybe_string;
-    optional<vector<optional<String16>>> read_strings;
-    ASSERT_EQ(reply.readString16(), String16("testing"));
-    ASSERT_EQ(reply.readString16(&maybe_string), OK);
-    ASSERT_EQ(maybe_string, nullopt);
-    ASSERT_EQ(reply.readString16Vector(&read_strings), OK);
-    ASSERT_EQ(read_strings, strings);
-    ASSERT_EQ(reply.readString16Vector(&read_strings), OK);
-    ASSERT_EQ(read_strings, nullopt);
-
-    int32_t end;
-    ASSERT_EQ(reply.readInt32(&end), NOT_ENOUGH_DATA);
-}
-
-TEST_F(SerializationTest, SerializeFileDescriptor) {
-    unique_fd out_file, in_file;
-    ASSERT_TRUE(base::Pipe(&out_file, &in_file));
-
-    vector<ParcelFileDescriptor> file_descriptors;
-    file_descriptors.push_back(ParcelFileDescriptor(std::move(out_file)));
-    file_descriptors.push_back(ParcelFileDescriptor(std::move(in_file)));
-
-    android::Parcel data;
-    data.writeInterfaceToken(String16("read_parcel_test"));
-
-    data.writeParcelable(file_descriptors[0]);
-    data.writeParcelable(file_descriptors[1]);
-    data.writeParcelableVector(file_descriptors);
-
-    android::Parcel reply;
-    ASSERT_EQ(m_server->transact(TEST_FILE_DESCRIPTOR, data, &reply), OK);
-
-    ParcelFileDescriptor returned_fd1, returned_fd2;
-    vector<ParcelFileDescriptor> returned_file_descriptors;
-    ASSERT_EQ(reply.readParcelable(&returned_fd1), OK);
-    ASSERT_EQ(reply.readParcelable(&returned_fd2), OK);
-    ASSERT_EQ(reply.readParcelableVector(&returned_file_descriptors), OK);
-
-    int32_t end;
-    ASSERT_EQ(reply.readInt32(&end), NOT_ENOUGH_DATA);
-
-    base::WriteStringToFd("Testing", returned_fd2.get());
-    base::WriteStringToFd("File", returned_file_descriptors[1].get());
-    base::WriteStringToFd("Descriptors", file_descriptors[1].get());
-
-    string expected = "TestingFileDescriptors";
-    vector<char> buf(expected.length());
-    base::ReadFully(file_descriptors[0].release(), buf.data(), buf.size());
-    ASSERT_EQ(expected, string(buf.data()));
-}
-
-TEST_F(SerializationTest, SerializeIBinder) {
-    android::Parcel data;
-    data.writeInterfaceToken(String16("read_parcel_test"));
-
-    data.writeStrongBinder(m_server);
-    data.writeStrongBinder(nullptr);
-    data.writeStrongBinderVector({m_server, nullptr});
-    data.writeStrongBinderVector(nullopt);
-
-    android::Parcel reply;
-    ASSERT_EQ(m_server->transact(TEST_IBINDER, data, &reply), OK);
-
-    optional<vector<sp<IBinder>>> binders;
-    ASSERT_TRUE(reply.readStrongBinder());
-    ASSERT_FALSE(reply.readStrongBinder());
-    ASSERT_EQ(reply.readStrongBinderVector(&binders), OK);
-    ASSERT_EQ(binders->size(), 2);
-    ASSERT_TRUE((*binders)[0]);
-    ASSERT_FALSE((*binders)[1]);
-    ASSERT_EQ(reply.readStrongBinderVector(&binders), OK);
-    ASSERT_FALSE(binders);
-
-    int32_t end;
-    ASSERT_EQ(reply.readInt32(&end), NOT_ENOUGH_DATA);
-}
-
-TEST_F(SerializationTest, SerializeStatus) {
-    android::Parcel data;
-    data.writeInterfaceToken(String16("read_parcel_test"));
-
-    binder::Status::ok().writeToParcel(&data);
-    binder::Status::fromExceptionCode(binder::Status::EX_NULL_POINTER, "a status message")
-            .writeToParcel(&data);
-    binder::Status::fromServiceSpecificError(42, "a service-specific error").writeToParcel(&data);
-
-    android::Parcel reply;
-    ASSERT_EQ(m_server->transact(TEST_STATUS, data, &reply), OK);
-
-    binder::Status status;
-
-    ASSERT_EQ(status.readFromParcel(reply), OK);
-    ASSERT_TRUE(status.isOk());
-
-    ASSERT_EQ(status.readFromParcel(reply), OK);
-    ASSERT_EQ(status.exceptionCode(), binder::Status::EX_NULL_POINTER);
-    ASSERT_EQ(status.exceptionMessage(), "a status message");
-
-    ASSERT_EQ(status.readFromParcel(reply), OK);
-    ASSERT_EQ(status.serviceSpecificErrorCode(), 42);
-    ASSERT_EQ(status.exceptionMessage(), "a service-specific error");
-
-    int32_t end;
-    ASSERT_EQ(reply.readInt32(&end), NOT_ENOUGH_DATA);
-}
-
-// Test that failures from Rust properly propagate to C++
-TEST_F(SerializationTest, SerializeRustFail) {
-    android::Parcel data;
-    data.writeInterfaceToken(String16("read_parcel_test"));
-    ASSERT_EQ(m_server->transact(TEST_FAIL, data, nullptr), FAILED_TRANSACTION);
-}
-
-int main(int argc, char **argv) {
-    ::testing::InitGoogleTest(&argc, argv);
-    gEnvironment = AddGlobalTestEnvironment(new SerializationEnvironment());
-    ProcessState::self()->startThreadPool();
-    return RUN_ALL_TESTS();
-}