Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d58bce0d authored by Stephen Crane's avatar Stephen Crane
Browse files

Add Rust/C++ Parcel serialization tests 

This tests cross-language marshaling between C++ and Rust for all
available parcelable types.

Test: atest libbinder_rs-internal_test

Change-Id: I57fae844d58395ee85f0afa4604e1480262f1a4b
parent cb8eb2be

libs/binder/TEST_MAPPING

+3 −0
Original line number Diff line number Diff line
@@ -65,6 +65,9 @@ 
    },

    {

      "name": "binderRustNdkInteropTest"

    },

    {

      "name": "rustBinderSerializationTest"

    }

  ]

}

libs/binder/rust/src/binder.rs

+1 −1
Original line number Diff line number Diff line
@@ -613,7 +613,7 @@ macro_rules! declare_binder_interface { 


        impl $crate::parcel::Serialize for dyn $interface + '_

        where

            $interface: $crate::Interface

            dyn $interface: $crate::Interface

        {

            fn serialize(&self, parcel: &mut $crate::parcel::Parcel) -> $crate::Result<()> {

                let binder = $crate::Interface::as_binder(self);

libs/binder/rust/src/proxy.rs

+14 −0
Original line number Diff line number Diff line
@@ -70,6 +70,20 @@ impl SpIBinder { 
        ptr.as_mut().map(|p| Self(p))

    }



    /// Extract a raw `AIBinder` pointer from this wrapper.

    ///

    /// This method should _only_ be used for testing. Do not try to use the NDK

    /// interface directly for anything else.

    ///

    /// # Safety

    ///

    /// The resulting pointer is valid only as long as the SpIBinder is alive.

    /// The SpIBinder object retains ownership of the AIBinder and the caller

    /// should not attempt to free the returned pointer.

    pub unsafe fn as_raw(&self) -> *mut sys::AIBinder {

        self.0

    }



    /// Return true if this binder object is hosted in a different process than

    /// the current one.

    pub fn is_remote(&self) -> bool {

libs/binder/rust/tests/Android.bp

+47 −0
Original line number Diff line number Diff line
@@ -79,3 +79,50 @@ rust_ffi_static { 
        "IBinderRustNdkInteropTest-rust",

    ],

}



cc_test {

    name: "rustBinderSerializationTest",

    shared_libs: [

        "libbinder",

        "libbinder_ndk",

        "libutils",

        "libbase",

    ],

    static_libs: [

        "libbinder_rs_serialization_test"

    ],

    srcs: [

        "serialization.cpp",

    ],

    auto_gen_config: true,

    test_suites: ["general-tests"],

}



rust_bindgen {

    name: "libbinder_rs_serialization_bindgen",

    crate_name: "binder_rs_serialization_bindgen",

    wrapper_src: "serialization.hpp",

    source_stem: "bindings",

    cpp_std: "gnu++17",

    bindgen_flags: [

        "--whitelist-type", "Transaction",

        "--whitelist-var", "TESTDATA_.*",

    ],



    shared_libs: [

        "libbinder",

        "libc++",

    ],

}



rust_ffi_static {

    name: "libbinder_rs_serialization_test",

    crate_name: "binder_rs_serialization_test",

    srcs: [

        "serialization.rs",

        ":libbinder_rs_serialization_bindgen",

    ],

    rustlibs: [

        "libbinder_rs",

    ],

}

libs/binder/rust/tests/serialization.cpp

0 → 100644
+454 −0
Original line number Diff line number Diff line 
/*

 * 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();

}