You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
285 lines
9.4 KiB
285 lines
9.4 KiB
/*
|
|
* 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 <vector>
|
|
|
|
#include <utils/String16.h>
|
|
#include <utils/String8.h>
|
|
|
|
#include "android/aidl/tests/ByteEnum.h"
|
|
#include "android/aidl/tests/INamedCallback.h"
|
|
#include "android/aidl/tests/IntEnum.h"
|
|
#include "android/aidl/tests/LongEnum.h"
|
|
|
|
#include "aidl_test_client.h"
|
|
#include "gmock/gmock.h"
|
|
|
|
using android::IBinder;
|
|
using android::sp;
|
|
using android::String16;
|
|
using android::String8;
|
|
using android::binder::Status;
|
|
|
|
// generated
|
|
using android::aidl::tests::ByteEnum;
|
|
using android::aidl::tests::INamedCallback;
|
|
using android::aidl::tests::IntEnum;
|
|
using android::aidl::tests::ITestService;
|
|
using android::aidl::tests::LongEnum;
|
|
|
|
using testing::Eq;
|
|
|
|
struct AidlPrimitiveTest : public AidlTest {
|
|
template <typename T, typename U, typename V>
|
|
void DoTest(Status (ITestService::*func)(T, U*), V input) {
|
|
U repeated;
|
|
auto status = (*service.*func)(input, &repeated);
|
|
ASSERT_TRUE(status.isOk()) << status;
|
|
ASSERT_THAT(repeated, Eq(input));
|
|
}
|
|
|
|
template <typename T>
|
|
void DoTest(Status (ITestService::*func)(const std::vector<T>&, std::vector<T>*, std::vector<T>*),
|
|
const std::vector<T>& input) {
|
|
// must be preallocated for Java servers
|
|
std::vector<T> repeated(input.size());
|
|
std::vector<T> reversed;
|
|
auto status = (*service.*func)(input, &repeated, &reversed);
|
|
ASSERT_TRUE(status.isOk()) << status;
|
|
ASSERT_THAT(repeated, Eq(input));
|
|
|
|
std::vector<T> reversed_input(input);
|
|
std::reverse(reversed_input.begin(), reversed_input.end());
|
|
ASSERT_THAT(reversed, Eq(reversed_input));
|
|
}
|
|
};
|
|
|
|
TEST_F(AidlPrimitiveTest, aBoolean) {
|
|
DoTest(&ITestService::RepeatBoolean, true);
|
|
}
|
|
|
|
TEST_F(AidlPrimitiveTest, aByte) {
|
|
DoTest(&ITestService::RepeatByte, int8_t{-128});
|
|
}
|
|
|
|
TEST_F(AidlPrimitiveTest, aChar) {
|
|
DoTest(&ITestService::RepeatChar, char16_t{'A'});
|
|
}
|
|
|
|
TEST_F(AidlPrimitiveTest, aInt) {
|
|
DoTest(&ITestService::RepeatInt, int32_t{1 << 30});
|
|
}
|
|
|
|
TEST_F(AidlPrimitiveTest, aLong) {
|
|
DoTest(&ITestService::RepeatLong, int64_t{1LL << 60});
|
|
}
|
|
|
|
TEST_F(AidlPrimitiveTest, aFloat) {
|
|
DoTest(&ITestService::RepeatFloat, float{1.0f / 3.0f});
|
|
}
|
|
|
|
TEST_F(AidlPrimitiveTest, aDouble) {
|
|
DoTest(&ITestService::RepeatDouble, double{1.0 / 3.0});
|
|
}
|
|
|
|
TEST_F(AidlPrimitiveTest, byteConstants) {
|
|
constexpr int8_t consts[] = {ITestService::BYTE_TEST_CONSTANT};
|
|
for (auto sent : consts) {
|
|
DoTest(&ITestService::RepeatByte, sent);
|
|
}
|
|
}
|
|
|
|
TEST_F(AidlPrimitiveTest, intConstants) {
|
|
constexpr int32_t consts[] = {
|
|
ITestService::TEST_CONSTANT, ITestService::TEST_CONSTANT2, ITestService::TEST_CONSTANT3,
|
|
ITestService::TEST_CONSTANT4, ITestService::TEST_CONSTANT5, ITestService::TEST_CONSTANT6,
|
|
ITestService::TEST_CONSTANT7, ITestService::TEST_CONSTANT8, ITestService::TEST_CONSTANT9,
|
|
ITestService::TEST_CONSTANT10, ITestService::TEST_CONSTANT11, ITestService::TEST_CONSTANT12};
|
|
for (auto sent : consts) {
|
|
DoTest(&ITestService::RepeatInt, sent);
|
|
}
|
|
}
|
|
|
|
TEST_F(AidlPrimitiveTest, longConstants) {
|
|
constexpr int64_t consts[] = {ITestService::LONG_TEST_CONSTANT};
|
|
for (auto sent : consts) {
|
|
DoTest(&ITestService::RepeatLong, sent);
|
|
}
|
|
}
|
|
|
|
TEST_F(AidlPrimitiveTest, strings) {
|
|
std::vector<String16> strings = {
|
|
String16("Deliver us from evil."), String16(), String16("\0\0", 2),
|
|
// This is actually two unicode code points:
|
|
// U+10437: The 'small letter yee' character in the deseret alphabet
|
|
// U+20AC: A euro sign
|
|
String16("\xD8\x01\xDC\x37\x20\xAC"), ITestService::STRING_TEST_CONSTANT(),
|
|
ITestService::STRING_TEST_CONSTANT2()};
|
|
for (auto sent : strings) {
|
|
DoTest(&ITestService::RepeatString, sent);
|
|
}
|
|
}
|
|
|
|
TEST_F(AidlPrimitiveTest, booleanArray) {
|
|
DoTest(&ITestService::ReverseBoolean, {true, false, false});
|
|
}
|
|
|
|
TEST_F(AidlPrimitiveTest, byteArrvay) {
|
|
DoTest(&ITestService::ReverseByte, {uint8_t{255}, uint8_t{0}, uint8_t{127}});
|
|
}
|
|
|
|
TEST_F(AidlPrimitiveTest, charArray) {
|
|
DoTest(&ITestService::ReverseChar, {char16_t{'A'}, char16_t{'B'}, char16_t{'C'}});
|
|
}
|
|
|
|
TEST_F(AidlPrimitiveTest, intArray) {
|
|
DoTest(&ITestService::ReverseInt, {1, 2, 3});
|
|
}
|
|
|
|
TEST_F(AidlPrimitiveTest, longArrayr) {
|
|
DoTest(&ITestService::ReverseLong, {-1LL, 0LL, int64_t{1LL << 60}});
|
|
}
|
|
|
|
TEST_F(AidlPrimitiveTest, floatArrays) {
|
|
DoTest(&ITestService::ReverseFloat, {-0.3f, -0.7f, 8.0f});
|
|
}
|
|
|
|
TEST_F(AidlPrimitiveTest, doubleArray) {
|
|
DoTest(&ITestService::ReverseDouble, {1.0 / 3.0, 1.0 / 7.0, 42.0});
|
|
}
|
|
|
|
TEST_F(AidlPrimitiveTest, stringArray) {
|
|
DoTest(&ITestService::ReverseString, {String16{"f"}, String16{"a"}, String16{"b"}});
|
|
}
|
|
|
|
TEST_F(AidlPrimitiveTest, byteEnumArray) {
|
|
DoTest(&ITestService::ReverseByteEnum, {ByteEnum::FOO, ByteEnum::BAR, ByteEnum::BAR});
|
|
}
|
|
|
|
TEST_F(AidlPrimitiveTest, byteEnumArray2) {
|
|
DoTest(&ITestService::ReverseByteEnum, {std::begin(::android::enum_range<ByteEnum>()),
|
|
std::end(::android::enum_range<ByteEnum>())});
|
|
}
|
|
|
|
TEST_F(AidlPrimitiveTest, intEnumArray) {
|
|
DoTest(&ITestService::ReverseIntEnum, {IntEnum::FOO, IntEnum::BAR, IntEnum::BAR});
|
|
}
|
|
|
|
TEST_F(AidlPrimitiveTest, longEnumArray) {
|
|
DoTest(&ITestService::ReverseLongEnum, {LongEnum::FOO, LongEnum::BAR, LongEnum::BAR});
|
|
}
|
|
|
|
TEST_F(AidlPrimitiveTest, stringList) {
|
|
DoTest(&ITestService::ReverseStringList, {String16{"f"}, String16{"a"}, String16{"b"}});
|
|
}
|
|
|
|
TEST_F(AidlPrimitiveTest, binderArray) {
|
|
std::vector<String16> names = {String16{"Larry"}, String16{"Curly"}, String16{"Moe"}};
|
|
|
|
std::vector<sp<IBinder>> input;
|
|
for (int i = 0; i < 3; i++) {
|
|
sp<INamedCallback> got;
|
|
auto status = service->GetOtherTestService(names[i], &got);
|
|
ASSERT_TRUE(status.isOk());
|
|
input.push_back(INamedCallback::asBinder(got));
|
|
}
|
|
|
|
if (cpp_java_tests) {
|
|
std::vector<sp<IBinder>> output;
|
|
std::vector<sp<IBinder>> reversed;
|
|
auto status = cpp_java_tests->ReverseNamedCallbackList(input, &output, &reversed);
|
|
ASSERT_TRUE(status.isOk());
|
|
ASSERT_THAT(output.size(), Eq(3u));
|
|
ASSERT_THAT(reversed.size(), Eq(3u));
|
|
|
|
for (int i = 0; i < 3; i++) {
|
|
String16 ret;
|
|
sp<INamedCallback> named_callback = android::interface_cast<INamedCallback>(output[i]);
|
|
auto status = named_callback->GetName(&ret);
|
|
ASSERT_TRUE(status.isOk());
|
|
ASSERT_THAT(ret, Eq(names[i]));
|
|
}
|
|
|
|
for (int i = 0; i < 3; i++) {
|
|
String16 ret;
|
|
sp<INamedCallback> named_callback = android::interface_cast<INamedCallback>(reversed[i]);
|
|
auto status = named_callback->GetName(&ret);
|
|
ASSERT_TRUE(status.isOk());
|
|
ASSERT_THAT(ret, Eq(names[2 - i]));
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST_F(AidlPrimitiveTest, constantExpressions) {
|
|
EXPECT_THAT(ITestService::A1, Eq(1));
|
|
EXPECT_THAT(ITestService::A2, Eq(1));
|
|
EXPECT_THAT(ITestService::A3, Eq(1));
|
|
EXPECT_THAT(ITestService::A4, Eq(1));
|
|
EXPECT_THAT(ITestService::A5, Eq(1));
|
|
EXPECT_THAT(ITestService::A6, Eq(1));
|
|
EXPECT_THAT(ITestService::A7, Eq(1));
|
|
EXPECT_THAT(ITestService::A8, Eq(1));
|
|
EXPECT_THAT(ITestService::A9, Eq(1));
|
|
EXPECT_THAT(ITestService::A10, Eq(1));
|
|
EXPECT_THAT(ITestService::A11, Eq(1));
|
|
EXPECT_THAT(ITestService::A12, Eq(1));
|
|
EXPECT_THAT(ITestService::A13, Eq(1));
|
|
EXPECT_THAT(ITestService::A14, Eq(1));
|
|
EXPECT_THAT(ITestService::A15, Eq(1));
|
|
EXPECT_THAT(ITestService::A16, Eq(1));
|
|
EXPECT_THAT(ITestService::A17, Eq(1));
|
|
EXPECT_THAT(ITestService::A18, Eq(1));
|
|
EXPECT_THAT(ITestService::A19, Eq(1));
|
|
EXPECT_THAT(ITestService::A20, Eq(1));
|
|
EXPECT_THAT(ITestService::A21, Eq(1));
|
|
EXPECT_THAT(ITestService::A22, Eq(1));
|
|
EXPECT_THAT(ITestService::A23, Eq(1));
|
|
EXPECT_THAT(ITestService::A24, Eq(1));
|
|
EXPECT_THAT(ITestService::A25, Eq(1));
|
|
EXPECT_THAT(ITestService::A26, Eq(1));
|
|
EXPECT_THAT(ITestService::A27, Eq(1));
|
|
EXPECT_THAT(ITestService::A28, Eq(1));
|
|
EXPECT_THAT(ITestService::A29, Eq(1));
|
|
EXPECT_THAT(ITestService::A30, Eq(1));
|
|
EXPECT_THAT(ITestService::A31, Eq(1));
|
|
EXPECT_THAT(ITestService::A32, Eq(1));
|
|
EXPECT_THAT(ITestService::A33, Eq(1));
|
|
EXPECT_THAT(ITestService::A34, Eq(1));
|
|
EXPECT_THAT(ITestService::A35, Eq(1));
|
|
EXPECT_THAT(ITestService::A36, Eq(1));
|
|
EXPECT_THAT(ITestService::A37, Eq(1));
|
|
EXPECT_THAT(ITestService::A38, Eq(1));
|
|
EXPECT_THAT(ITestService::A39, Eq(1));
|
|
EXPECT_THAT(ITestService::A40, Eq(1));
|
|
EXPECT_THAT(ITestService::A41, Eq(1));
|
|
EXPECT_THAT(ITestService::A42, Eq(1));
|
|
EXPECT_THAT(ITestService::A43, Eq(1));
|
|
EXPECT_THAT(ITestService::A44, Eq(1));
|
|
EXPECT_THAT(ITestService::A45, Eq(1));
|
|
EXPECT_THAT(ITestService::A46, Eq(1));
|
|
EXPECT_THAT(ITestService::A47, Eq(1));
|
|
EXPECT_THAT(ITestService::A48, Eq(1));
|
|
EXPECT_THAT(ITestService::A49, Eq(1));
|
|
EXPECT_THAT(ITestService::A50, Eq(1));
|
|
EXPECT_THAT(ITestService::A51, Eq(1));
|
|
EXPECT_THAT(ITestService::A52, Eq(1));
|
|
EXPECT_THAT(ITestService::A53, Eq(1));
|
|
EXPECT_THAT(ITestService::A54, Eq(1));
|
|
EXPECT_THAT(ITestService::A55, Eq(1));
|
|
EXPECT_THAT(ITestService::A56, Eq(1));
|
|
EXPECT_THAT(ITestService::A57, Eq(1));
|
|
}
|