diff options
Diffstat (limited to 'libs/binder/tests/binderParcelTest.cpp')
-rw-r--r-- | libs/binder/tests/binderParcelTest.cpp | 148 |
1 files changed, 148 insertions, 0 deletions
diff --git a/libs/binder/tests/binderParcelTest.cpp b/libs/binder/tests/binderParcelTest.cpp new file mode 100644 index 0000000000..841d47b264 --- /dev/null +++ b/libs/binder/tests/binderParcelTest.cpp @@ -0,0 +1,148 @@ +/* + * 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 <binder/Parcel.h> +#include <binder/IPCThreadState.h> +#include <gtest/gtest.h> + +using android::IPCThreadState; +using android::OK; +using android::Parcel; +using android::String16; +using android::String8; +using android::status_t; + +TEST(Parcel, NonNullTerminatedString8) { + String8 kTestString = String8("test-is-good"); + + // write non-null terminated string + Parcel p; + p.writeString8(kTestString); + p.setDataPosition(0); + // BAD! assumption of wire format for test + // write over length of string + p.writeInt32(kTestString.size() - 2); + + p.setDataPosition(0); + String8 output; + EXPECT_NE(OK, p.readString8(&output)); + EXPECT_EQ(output.size(), 0); +} + +TEST(Parcel, NonNullTerminatedString16) { + String16 kTestString = String16("test-is-good"); + + // write non-null terminated string + Parcel p; + p.writeString16(kTestString); + p.setDataPosition(0); + // BAD! assumption of wire format for test + // write over length of string + p.writeInt32(kTestString.size() - 2); + + p.setDataPosition(0); + String16 output; + EXPECT_NE(OK, p.readString16(&output)); + EXPECT_EQ(output.size(), 0); +} + +// Tests a second operation results in a parcel at the same location as it +// started. +void parcelOpSameLength(const std::function<void(Parcel*)>& a, const std::function<void(Parcel*)>& b) { + Parcel p; + a(&p); + size_t end = p.dataPosition(); + p.setDataPosition(0); + b(&p); + EXPECT_EQ(end, p.dataPosition()); +} + +TEST(Parcel, InverseInterfaceToken) { + const String16 token = String16("asdf"); + parcelOpSameLength([&] (Parcel* p) { + p->writeInterfaceToken(token); + }, [&] (Parcel* p) { + EXPECT_TRUE(p->enforceInterface(token, IPCThreadState::self())); + }); +} + +TEST(Parcel, Utf8FromUtf16Read) { + const char* token = "asdf"; + parcelOpSameLength([&] (Parcel* p) { + p->writeString16(String16(token)); + }, [&] (Parcel* p) { + std::string s; + EXPECT_EQ(OK, p->readUtf8FromUtf16(&s)); + EXPECT_EQ(token, s); + }); +} + +TEST(Parcel, Utf8AsUtf16Write) { + std::string token = "asdf"; + parcelOpSameLength([&] (Parcel* p) { + p->writeUtf8AsUtf16(token); + }, [&] (Parcel* p) { + String16 s; + EXPECT_EQ(OK, p->readString16(&s)); + EXPECT_EQ(s, String16(token.c_str())); + }); +} + +template <typename T> +using readFunc = status_t (Parcel::*)(T* out) const; +template <typename T> +using writeFunc = status_t (Parcel::*)(const T& in); +template <typename T> +using copyWriteFunc = status_t (Parcel::*)(T in); + +template <typename T, typename WRITE_FUNC> +void readWriteInverse(std::vector<T>&& ts, readFunc<T> r, WRITE_FUNC w) { + for (const T& value : ts) { + parcelOpSameLength([&] (Parcel* p) { + (*p.*w)(value); + }, [&] (Parcel* p) { + T outValue; + EXPECT_EQ(OK, (*p.*r)(&outValue)); + EXPECT_EQ(value, outValue); + }); + } +} + +template <typename T> +void readWriteInverse(std::vector<T>&& ts, readFunc<T> r, writeFunc<T> w) { + readWriteInverse<T, writeFunc<T>>(std::move(ts), r, w); +} +template <typename T> +void readWriteInverse(std::vector<T>&& ts, readFunc<T> r, copyWriteFunc<T> w) { + readWriteInverse<T, copyWriteFunc<T>>(std::move(ts), r, w); +} + +#define TEST_READ_WRITE_INVERSE(type, name, ...) \ + TEST(Parcel, Inverse##name) { \ + readWriteInverse<type>(__VA_ARGS__, &Parcel::read##name, &Parcel::write##name); \ + } + +TEST_READ_WRITE_INVERSE(int32_t, Int32, {-2, -1, 0, 1, 2}); +TEST_READ_WRITE_INVERSE(uint32_t, Uint32, {0, 1, 2}); +TEST_READ_WRITE_INVERSE(int64_t, Int64, {-2, -1, 0, 1, 2}); +TEST_READ_WRITE_INVERSE(uint64_t, Uint64, {0, 1, 2}); +TEST_READ_WRITE_INVERSE(float, Float, {-1.0f, 0.0f, 3.14f}); +TEST_READ_WRITE_INVERSE(double, Double, {-1.0, 0.0, 3.14}); +TEST_READ_WRITE_INVERSE(bool, Bool, {true, false}); +TEST_READ_WRITE_INVERSE(char16_t, Char, {u'a', u'\0'}); +TEST_READ_WRITE_INVERSE(int8_t, Byte, {-1, 0, 1}); +TEST_READ_WRITE_INVERSE(String8, String8, {String8(), String8("a"), String8("asdf")}); +TEST_READ_WRITE_INVERSE(String16, String16, {String16(), String16("a"), String16("asdf")}); |