Home | History | Annotate | Download | only in tests 
      1 /*
      2  * Copyright (C) 2015 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #include "aidl_test_client_parcelables.h"
     18 
     19 #include <iostream>
     20 #include <vector>
     21 
     22 // libutils:
     23 using android::sp;
     24 
     25 // libbinder:
     26 using android::binder::Status;
     27 
     28 // generated
     29 using android::aidl::tests::ITestService;
     30 using android::aidl::tests::SimpleParcelable;
     31 using android::os::PersistableBundle;
     32 
     33 using std::cout;
     34 using std::endl;
     35 using std::vector;
     36 
     37 namespace android {
     38 namespace aidl {
     39 namespace tests {
     40 namespace client {
     41 
     42 bool ConfirmSimpleParcelables(const sp<ITestService>& s) {
     43   cout << "Confirming passing and returning SimpleParcelable objects works."
     44        << endl;
     45 
     46   SimpleParcelable input("Booya", 42);
     47   SimpleParcelable out_param, returned;
     48   Status status = s->RepeatSimpleParcelable(input, &out_param, &returned);
     49   if (!status.isOk()) {
     50     cout << "Binder call failed." << endl;
     51     return false;
     52   }
     53   if (input != out_param || input != returned) {
     54     cout << "Failed to repeat SimpleParcelable objects." << endl;
     55     return false;
     56   }
     57 
     58   cout << "Attempting to reverse an array of SimpleParcelable objects." << endl;
     59   const vector<SimpleParcelable> original{SimpleParcelable("first", 0),
     60                                           SimpleParcelable("second", 1),
     61                                           SimpleParcelable("third", 2)};
     62   vector<SimpleParcelable> repeated;
     63   vector<SimpleParcelable> reversed;
     64   status = s->ReverseSimpleParcelables(original, &repeated, &reversed);
     65   if (!status.isOk()) {
     66     cout << "Binder call failed." << endl;
     67     return false;
     68   }
     69   std::reverse(reversed.begin(), reversed.end());
     70   if (repeated != original || reversed != original) {
     71     cout << "Failed to reverse an array of SimpleParcelable objects." << endl;
     72     return false;
     73   }
     74 
     75   return true;
     76 }
     77 
     78 bool ConfirmPersistableBundles(const sp<ITestService>& s) {
     79   cout << "Confirming passing and returning PersistableBundle objects works."
     80        << endl;
     81 
     82   PersistableBundle empty_bundle, returned;
     83   Status status = s->RepeatPersistableBundle(empty_bundle, &returned);
     84   if (!status.isOk()) {
     85     cout << "Binder call failed for empty PersistableBundle." << endl;
     86     return false;
     87   }
     88   if (empty_bundle != returned) {
     89     cout << "Failed to repeat empty PersistableBundle." << endl;
     90     return false;
     91   }
     92 
     93   PersistableBundle non_empty_bundle;
     94   non_empty_bundle.putBoolean(String16("test_bool"), false);
     95   non_empty_bundle.putInt(String16("test_int"), 33);
     96   non_empty_bundle.putLong(String16("test_long"), 34359738368l);
     97   non_empty_bundle.putDouble(String16("test_double"), 1.1);
     98   non_empty_bundle.putString(String16("test_string"), String16("Woot!"));
     99   non_empty_bundle.putBooleanVector(String16("test_bool_vector"),
    100                                     {true, false, true});
    101   non_empty_bundle.putIntVector(String16("test_int_vector"), {33, 44, 55, 142});
    102   non_empty_bundle.putLongVector(String16("test_long_vector"),
    103                                  {34l, 8371l, 34359738375l});
    104   non_empty_bundle.putDoubleVector(String16("test_double_vector"), {2.2, 5.4});
    105   non_empty_bundle.putStringVector(String16("test_string_vector"),
    106                                    {String16("hello"), String16("world!")});
    107   PersistableBundle nested_bundle;
    108   nested_bundle.putInt(String16("test_nested_int"), 345);
    109   non_empty_bundle.putPersistableBundle(String16("test_persistable_bundle"),
    110                                         nested_bundle);
    111 
    112   status = s->RepeatPersistableBundle(non_empty_bundle, &returned);
    113   if (!status.isOk()) {
    114     cout << "Binder call failed. " << endl;
    115     return false;
    116   }
    117   if (non_empty_bundle != returned) {
    118     cout << "Failed to repeat PersistableBundle object." << endl;
    119     return false;
    120   }
    121 
    122   cout << "Attempting to reverse an array of PersistableBundle objects."
    123        << endl;
    124   PersistableBundle first;
    125   PersistableBundle second;
    126   PersistableBundle third;
    127   first.putInt(String16("test_int"), 1231);
    128   second.putLong(String16("test_long"), 222222l);
    129   third.putDouble(String16("test_double"), 10.8);
    130   const vector<PersistableBundle> original{first, second, third};
    131 
    132   vector<PersistableBundle> repeated;
    133   vector<PersistableBundle> reversed;
    134   status = s->ReversePersistableBundles(original, &repeated, &reversed);
    135   if (!status.isOk()) {
    136     cout << "Binder call failed." << endl;
    137     return false;
    138   }
    139   std::reverse(reversed.begin(), reversed.end());
    140   if (repeated != original || reversed != original) {
    141     cout << "Failed to reverse an array of PersistableBundle objects." << endl;
    142     return false;
    143   }
    144 
    145   return true;
    146 }
    147 
    148 }  // namespace client
    149 }  // namespace tests
    150 }  // namespace aidl
    151 }  // namespace android
    152