| /* |
| * 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::ByteEnum; |
| using android::aidl::tests::IntEnum; |
| using android::aidl::tests::ITestService; |
| using android::aidl::tests::LongEnum; |
| 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, "byte enum array", |
| unique_ptr<vector<ByteEnum>>(new vector<ByteEnum>({ByteEnum::FOO, ByteEnum::BAR})), |
| &ITestService::RepeatNullableByteEnumArray)) { |
| return false; |
| } |
| |
| if (!ConfirmNullableType( |
| s, "int enum array", |
| unique_ptr<vector<IntEnum>>(new vector<IntEnum>({IntEnum::FOO, IntEnum::BAR})), |
| &ITestService::RepeatNullableIntEnumArray)) { |
| return false; |
| } |
| |
| if (!ConfirmNullableType( |
| s, "long enum array", |
| unique_ptr<vector<LongEnum>>(new vector<LongEnum>({LongEnum::FOO, LongEnum::BAR})), |
| &ITestService::RepeatNullableLongEnumArray)) { |
| 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 |