aidl/tests/aidl_test_client_nullables.cpp

/*
 * 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