/*
* 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 "aidl_test_client_nullables.h"
#include <utils/String16.h>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
// libutils:
using android::sp;
using android::String16;
// libbinder:
using android::binder::Status;
// generated
using android::aidl::tests::ITestService;
using android::aidl::tests::SimpleParcelable;
using std::string;
using std::unique_ptr;
using std::vector;
using std::cout;
using std::cerr;
using std::endl;
namespace android {
namespace aidl {
namespace tests {
namespace client {
namespace {
template<typename T>
bool ValuesEqual(const unique_ptr<T>& in, const unique_ptr<T>& out) {
return *in == *out;
}
template<>
bool ValuesEqual<vector<unique_ptr<String16>>>(
const unique_ptr<vector<unique_ptr<String16>>>& in,
const unique_ptr<vector<unique_ptr<String16>>>& out) {
if (!in) {
return !out;
}
if (!out) {
return false;
}
if (in->size() != out->size()) {
return false;
}
for (size_t i = 0; i < in->size(); i++) {
const unique_ptr<String16>& a = (*in)[i];
const unique_ptr<String16>& b = (*out)[i];
if (!(a || b)) {
continue;
}
if (!(a && b)) {
return false;
}
if (*a != *b) {
return false;
}
}
return true;
}
template<typename T>
bool ConfirmNullableType(const sp<ITestService>& s, const string& type_name,
unique_ptr<T> in,
Status(ITestService::*func)(const unique_ptr<T>&,
unique_ptr<T>*)) {
cout << "... Confirming nullables for " << type_name << " ..." << endl;
Status status;
unique_ptr<T> out;
status = (*s.*func)(in, &out);
if (!status.isOk()) {
cerr << "Could not repeat nullable " << type_name << "." << endl;
return false;
}
if (!out) {
cerr << "Got back null when repeating " << type_name << "." << endl;
return false;
}
if (!ValuesEqual(in, out)) {
cerr << "Got back a non-matching value when repeating " << type_name
<< "." << endl;
return false;
}
in.reset();
status = (*s.*func)(in, &out);
if (!status.isOk()) {
cerr << "Could not repeat null as " << type_name << "." << endl;
return false;
}
if (out) {
cerr << "Got back a value when sent null for " << type_name << "."
<< endl;
return false;
}
return true;
}
bool CheckAppropriateIBinderHandling(const sp<ITestService>& s) {
Status status;
sp<IBinder> binder = new BBinder();
sp<IBinder> null_binder = nullptr;
unique_ptr<vector<sp<IBinder>>> list_with_nulls(
new vector<sp<IBinder>>{binder, null_binder});
unique_ptr<vector<sp<IBinder>>> list_without_nulls(
new vector<sp<IBinder>>{binder, binder});
// Methods without @nullable throw up when given null binders
if (s->TakesAnIBinder(null_binder).exceptionCode() !=
binder::Status::EX_NULL_POINTER) {
cerr << "Did not receive expected null exception on line: "
<< __LINE__ << endl;
return false;
}
if (s->TakesAnIBinderList(*list_with_nulls).exceptionCode() !=
binder::Status::EX_NULL_POINTER) {
cerr << "Did not receive expected null exception on line: "
<< __LINE__ << endl;
return false;
}
// But those same methods are fine with valid binders
if (!s->TakesAnIBinder(binder).isOk()) {
cerr << "Received unexpected exception on line "
<< __LINE__ << endl;
return false;
}
if (!s->TakesAnIBinderList(*list_without_nulls).isOk()) {
cerr << "Received unexpected exception on line "
<< __LINE__ << endl;
return false;
}
// And methods with @nullable don't care.
if (!s->TakesANullableIBinder(null_binder).isOk()) {
cerr << "Received unexpected exception on line "
<< __LINE__ << endl;
return false;
}
if (!s->TakesANullableIBinder(binder).isOk()) {
cerr << "Received unexpected exception on line "
<< __LINE__ << endl;
return false;
}
if (!s->TakesANullableIBinderList(list_with_nulls).isOk()) {
cerr << "Received unexpected exception on line "
<< __LINE__ << endl;
return false;
}
if (!s->TakesANullableIBinderList(list_without_nulls).isOk()) {
cerr << "Received unexpected exception on line "
<< __LINE__ << endl;
return false;
}
return true;
}
bool CheckAppropriateIInterfaceHandling(const sp<ITestService>& s) {
sp<INamedCallback> callback;
if (!s->GetCallback(false, &callback).isOk()) {
cerr << "Received unexpected exception on line "
<< __LINE__ << endl;
return false;
}
if (callback.get() == nullptr) {
cerr << "Expected to receive a non-null binder on line: "
<< __LINE__ << endl;
return false;
}
if (!s->GetCallback(true, &callback).isOk()) {
cerr << "Received unexpected exception on line "
<< __LINE__ << endl;
return false;
}
if (callback.get() != nullptr) {
cerr << "Expected to receive a null binder on line: "
<< __LINE__ << endl;
return false;
}
return true;
}
} // namespace
bool ConfirmNullables(const sp<ITestService>& s) {
Status status;
cout << "Confirming passing and returning nullable values works." << endl;
if (!ConfirmNullableType(s, "integer array",
unique_ptr<vector<int32_t>>(
new vector<int32_t>({1,2,3})),
&ITestService::RepeatNullableIntArray)) {
return false;
}
if (!ConfirmNullableType(s, "string",
unique_ptr<String16>(new String16("Blooob")),
&ITestService::RepeatNullableString)) {
return false;
}
unique_ptr<vector<unique_ptr<String16>>> test_string_array(
new vector<unique_ptr<String16>>());
test_string_array->push_back(unique_ptr<String16>(new String16("Wat")));
test_string_array->push_back(unique_ptr<String16>(
new String16("Blooob")));
test_string_array->push_back(unique_ptr<String16>(new String16("Wat")));
test_string_array->push_back(unique_ptr<String16>(nullptr));
test_string_array->push_back(unique_ptr<String16>(new String16("YEAH")));
test_string_array->push_back(unique_ptr<String16>(
new String16("OKAAAAY")));
if (!ConfirmNullableType(s, "string array", std::move(test_string_array),
&ITestService::RepeatNullableStringList)) {
return false;
}
if (!ConfirmNullableType(s, "parcelable",
unique_ptr<SimpleParcelable>(
new SimpleParcelable("Booya", 42)),
&ITestService::RepeatNullableParcelable)) {
return false;
}
if (!CheckAppropriateIBinderHandling(s)) {
cerr << "Handled null IBinders poorly." << endl;
return false;
}
if (!CheckAppropriateIInterfaceHandling(s)) {
cerr << "Handled nullable IInterface instances poorly." << endl;
return false;
}
return true;
}
} // namespace client
} // namespace tests
} // namespace aidl
} // namespace android