Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 1 | //#define LOG_NDEBUG 0 |
| 2 | #define LOG_TAG "hidl_test_java_native" |
| 3 | |
| 4 | #include <android-base/logging.h> |
| 5 | |
Steven Moreland | 4078631 | 2016-08-16 10:29:40 -0700 | [diff] [blame] | 6 | #include <android/hardware/tests/baz/1.0/IBaz.h> |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 7 | |
| 8 | #include <gtest/gtest.h> |
| 9 | #include <hidl/IServiceManager.h> |
Martijn Coenen | 9391510 | 2016-09-01 01:35:52 +0200 | [diff] [blame] | 10 | #include <hidl/Status.h> |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 11 | #include <hwbinder/IPCThreadState.h> |
| 12 | #include <hwbinder/ProcessState.h> |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 13 | |
| 14 | using ::android::sp; |
| 15 | using ::android::Thread; |
| 16 | using ::android::hardware::tests::baz::V1_0::IBase; |
| 17 | using ::android::hardware::tests::baz::V1_0::IBaz; |
| 18 | using ::android::hardware::tests::baz::V1_0::IBazCallback; |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 19 | |
| 20 | using ::android::hardware::hidl_vec; |
| 21 | using ::android::hardware::hidl_string; |
| 22 | using ::android::hardware::Return; |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 23 | using ::android::hardware::Void; |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 24 | |
Steven Moreland | 4078631 | 2016-08-16 10:29:40 -0700 | [diff] [blame] | 25 | struct BazCallback : public IBazCallback { |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 26 | Return<void> heyItsMe(const sp<IBazCallback> &cb) override; |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 27 | }; |
| 28 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 29 | Return<void> BazCallback::heyItsMe( |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 30 | const sp<IBazCallback> &cb) { |
| 31 | LOG(INFO) << "SERVER: heyItsMe cb = " << cb.get(); |
| 32 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 33 | return Void(); |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 34 | } |
| 35 | |
Steven Moreland | 4078631 | 2016-08-16 10:29:40 -0700 | [diff] [blame] | 36 | struct Baz : public IBaz { |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 37 | Return<void> someBaseMethod() override; |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 38 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 39 | Return<void> someOtherBaseMethod( |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 40 | const IBaz::Foo &foo, someOtherBaseMethod_cb _hidl_cb) override; |
| 41 | |
| 42 | Return<bool> someBoolMethod(bool x) override; |
| 43 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 44 | Return<void> someBoolArrayMethod( |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 45 | const bool x[3], someBoolArrayMethod_cb _hidl_cb) override; |
| 46 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 47 | Return<void> someBoolVectorMethod( |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 48 | const hidl_vec<bool> &x, someBoolVectorMethod_cb _hidl_cb) override; |
| 49 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 50 | Return<void> doSomethingElse( |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 51 | const int32_t param[15], doSomethingElse_cb _hidl_cb) override; |
| 52 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 53 | Return<void> doThis(float param) override; |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 54 | |
| 55 | Return<int32_t> doThatAndReturnSomething(int64_t param) override; |
| 56 | |
| 57 | Return<double> doQuiteABit( |
| 58 | int32_t a, |
| 59 | int64_t b, |
| 60 | float c, |
| 61 | double d) override; |
| 62 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 63 | Return<void> doStuffAndReturnAString( |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 64 | doStuffAndReturnAString_cb _hidl_cb) override; |
| 65 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 66 | Return<void> mapThisVector( |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 67 | const hidl_vec<int32_t>& param, mapThisVector_cb _hidl_cb) override; |
| 68 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 69 | Return<void> callMe(const sp<IBazCallback>& cb) override; |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 70 | Return<IBaz::SomeEnum> useAnEnum(IBaz::SomeEnum zzz) override; |
| 71 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 72 | Return<void> haveSomeStrings( |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 73 | const hidl_string array[3], haveSomeStrings_cb _hidl_cb) override; |
| 74 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 75 | Return<void> haveAStringVec( |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 76 | const hidl_vec<hidl_string>& vector, |
| 77 | haveAStringVec_cb _hidl_cb) override; |
| 78 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 79 | Return<void> returnABunchOfStrings(returnABunchOfStrings_cb _hidl_cb) override; |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 80 | }; |
| 81 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 82 | Return<void> Baz::someBaseMethod() { |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 83 | LOG(INFO) << "Baz::someBaseMethod"; |
| 84 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 85 | return Void(); |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 86 | } |
| 87 | |
| 88 | using std::to_string; |
| 89 | |
| 90 | static std::string to_string(const IBaz::Foo::Bar &bar); |
| 91 | static std::string to_string(const IBaz::Foo &foo); |
| 92 | static std::string to_string(const hidl_string &s); |
| 93 | static std::string to_string(bool x); |
| 94 | |
| 95 | template<class T> |
| 96 | static std::string array_to_string(const T *array, size_t size) { |
| 97 | std::string out; |
| 98 | out = "["; |
| 99 | for (size_t i = 0; i < size; ++i) { |
| 100 | if (i > 0) { |
| 101 | out += ", "; |
| 102 | } |
| 103 | out += to_string(array[i]); |
| 104 | } |
| 105 | out += "]"; |
| 106 | |
| 107 | return out; |
| 108 | } |
| 109 | |
| 110 | template<class T> |
| 111 | static std::string to_string(const hidl_vec<T> &vec) { |
| 112 | return array_to_string(&vec[0], vec.size()); |
| 113 | } |
| 114 | |
| 115 | static std::string to_string(bool x) { |
| 116 | return x ? "true" : "false"; |
| 117 | } |
| 118 | |
| 119 | static std::string to_string(const hidl_string &s) { |
| 120 | return std::string("'") + s.c_str() + "'"; |
| 121 | } |
| 122 | |
| 123 | static std::string to_string(const IBaz::Foo::Bar &bar) { |
| 124 | std::string out; |
| 125 | out = "Bar("; |
| 126 | out += "z = " + to_string(bar.z) + ", "; |
| 127 | out += "s = '" + std::string(bar.s.c_str()) + "'"; |
| 128 | out += ")"; |
| 129 | |
| 130 | return out; |
| 131 | } |
| 132 | |
| 133 | static std::string to_string(const IBaz::Foo &foo) { |
| 134 | std::string out; |
| 135 | out = "Foo("; |
| 136 | out += "x = " + to_string(foo.x) + ", "; |
| 137 | out += "y = " + to_string(foo.y) + ", "; |
| 138 | out += "aaa = " + to_string(foo.aaa); |
| 139 | out += ")"; |
| 140 | |
| 141 | return out; |
| 142 | } |
| 143 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 144 | Return<void> Baz::someOtherBaseMethod( |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 145 | const IBaz::Foo &foo, someOtherBaseMethod_cb _hidl_cb) { |
| 146 | LOG(INFO) << "Baz::someOtherBaseMethod " |
| 147 | << to_string(foo); |
| 148 | |
| 149 | _hidl_cb(foo); |
| 150 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 151 | return Void(); |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 152 | } |
| 153 | |
| 154 | Return<bool> Baz::someBoolMethod(bool x) { |
| 155 | LOG(INFO) << "Baz::someBoolMethod(" << to_string(x) << ")"; |
| 156 | |
| 157 | return !x; |
| 158 | } |
| 159 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 160 | Return<void> Baz::someBoolArrayMethod( |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 161 | const bool x[3], someBoolArrayMethod_cb _hidl_cb) { |
| 162 | LOG(INFO) << "Baz::someBoolArrayMethod(" |
| 163 | << to_string(x[0]) |
| 164 | << ", " |
| 165 | << to_string(x[1]) |
| 166 | << ", " |
| 167 | << to_string(x[2]) |
| 168 | << ")"; |
| 169 | |
| 170 | bool out[4]; |
| 171 | out[0] = !x[0]; |
| 172 | out[1] = !x[1]; |
| 173 | out[2] = !x[2]; |
| 174 | out[3] = true; |
| 175 | |
| 176 | _hidl_cb(out); |
| 177 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 178 | return Void(); |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 179 | } |
| 180 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 181 | Return<void> Baz::someBoolVectorMethod( |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 182 | const hidl_vec<bool> &x, someBoolVectorMethod_cb _hidl_cb) { |
| 183 | LOG(INFO) << "Baz::someBoolVectorMethod(" << to_string(x) << ")"; |
| 184 | |
| 185 | hidl_vec<bool> out; |
| 186 | out.resize(x.size()); |
| 187 | for (size_t i = 0; i < x.size(); ++i) { |
| 188 | out[i] = !x[i]; |
| 189 | } |
| 190 | |
| 191 | _hidl_cb(out); |
| 192 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 193 | return Void(); |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 194 | } |
| 195 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 196 | Return<void> Baz::doSomethingElse( |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 197 | const int32_t param[15], doSomethingElse_cb _hidl_cb) { |
| 198 | LOG(INFO) << "Baz::doSomethingElse(...)"; |
| 199 | |
| 200 | int32_t result[32] = { 0 }; |
| 201 | for (size_t i = 0; i < 15; ++i) { |
| 202 | result[i] = 2 * param[i]; |
| 203 | result[15 + i] = param[i]; |
| 204 | } |
| 205 | result[30] = 1; |
| 206 | result[31] = 2; |
| 207 | |
| 208 | _hidl_cb(result); |
| 209 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 210 | return Void(); |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 211 | } |
| 212 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 213 | Return<void> Baz::doThis(float param) { |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 214 | LOG(INFO) << "Baz::doThis(" << param << ")"; |
| 215 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 216 | return Void(); |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 217 | } |
| 218 | |
| 219 | Return<int32_t> Baz::doThatAndReturnSomething(int64_t param) { |
| 220 | LOG(INFO) << "Baz::doThatAndReturnSomething(" << param << ")"; |
| 221 | |
| 222 | return 666; |
| 223 | } |
| 224 | |
| 225 | Return<double> Baz::doQuiteABit( |
| 226 | int32_t a, |
| 227 | int64_t b, |
| 228 | float c, |
| 229 | double d) { |
| 230 | LOG(INFO) << "Baz::doQuiteABit(" |
| 231 | << a |
| 232 | << ", " |
| 233 | << b |
| 234 | << ", " |
| 235 | << c |
| 236 | << ", " |
| 237 | << d |
| 238 | << ")"; |
| 239 | |
| 240 | return 666.5; |
| 241 | } |
| 242 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 243 | Return<void> Baz::doStuffAndReturnAString( |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 244 | doStuffAndReturnAString_cb _hidl_cb) { |
| 245 | LOG(INFO) << "doStuffAndReturnAString"; |
| 246 | |
| 247 | hidl_string s; |
| 248 | s = "Hello, world!"; |
| 249 | |
| 250 | _hidl_cb(s); |
| 251 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 252 | return Void(); |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 253 | } |
| 254 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 255 | Return<void> Baz::mapThisVector( |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 256 | const hidl_vec<int32_t>& param, mapThisVector_cb _hidl_cb) { |
| 257 | LOG(INFO) << "mapThisVector"; |
| 258 | |
| 259 | hidl_vec<int32_t> out; |
| 260 | out.resize(param.size()); |
| 261 | for (size_t i = 0; i < param.size(); ++i) { |
| 262 | out[i] = param[i] * 2; |
| 263 | } |
| 264 | |
| 265 | _hidl_cb(out); |
| 266 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 267 | return Void(); |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 268 | } |
| 269 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 270 | Return<void> Baz::callMe(const sp<IBazCallback>& cb) { |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 271 | LOG(INFO) << "callMe " << cb.get(); |
| 272 | |
| 273 | if (cb != NULL) { |
| 274 | sp<IBazCallback> my_cb = new BazCallback; |
| 275 | cb->heyItsMe(my_cb); |
| 276 | } |
| 277 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 278 | return Void(); |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 279 | } |
| 280 | |
| 281 | Return<IBaz::SomeEnum> Baz::useAnEnum(IBaz::SomeEnum zzz) { |
| 282 | LOG(INFO) << "useAnEnum " << (int)zzz; |
| 283 | |
| 284 | return SomeEnum::goober; |
| 285 | } |
| 286 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 287 | Return<void> Baz::haveSomeStrings( |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 288 | const hidl_string array[3], haveSomeStrings_cb _hidl_cb) { |
| 289 | LOG(INFO) << "haveSomeStrings(" |
| 290 | << array_to_string(array, 3) |
| 291 | << ")"; |
| 292 | |
| 293 | hidl_string result[2]; |
| 294 | result[0] = "Hello"; |
| 295 | result[1] = "World"; |
| 296 | |
| 297 | _hidl_cb(result); |
| 298 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 299 | return Void(); |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 300 | } |
| 301 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 302 | Return<void> Baz::haveAStringVec( |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 303 | const hidl_vec<hidl_string>& vector, |
| 304 | haveAStringVec_cb _hidl_cb) { |
| 305 | LOG(INFO) << "haveAStringVec(" << to_string(vector) << ")"; |
| 306 | |
| 307 | hidl_vec<hidl_string> result; |
| 308 | result.resize(2); |
| 309 | |
| 310 | result[0] = "Hello"; |
| 311 | result[1] = "World"; |
| 312 | |
| 313 | _hidl_cb(result); |
| 314 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 315 | return Void(); |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 316 | } |
| 317 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 318 | Return<void> Baz::returnABunchOfStrings(returnABunchOfStrings_cb _hidl_cb) { |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 319 | hidl_string eins; eins = "Eins"; |
| 320 | hidl_string zwei; zwei = "Zwei"; |
| 321 | hidl_string drei; drei = "Drei"; |
| 322 | _hidl_cb(eins, zwei, drei); |
| 323 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 324 | return Void(); |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 325 | } |
| 326 | |
| 327 | static void usage(const char *me) { |
| 328 | fprintf(stderr, "%s [-c]lient | [-s]erver\n", me); |
| 329 | } |
| 330 | |
| 331 | struct HidlEnvironment : public ::testing::Environment { |
| 332 | void SetUp() override { |
| 333 | } |
| 334 | |
| 335 | void TearDown() override { |
| 336 | } |
| 337 | }; |
| 338 | |
| 339 | struct HidlTest : public ::testing::Test { |
| 340 | sp<IBaz> baz; |
| 341 | |
| 342 | void SetUp() override { |
| 343 | using namespace ::android::hardware; |
| 344 | |
| 345 | const hidl_version kVersion = make_hidl_version(1, 0); |
| 346 | |
Martijn Coenen | 4ff971c | 2016-09-08 13:40:02 +0200 | [diff] [blame^] | 347 | baz = IBaz::getService("baz", kVersion); |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 348 | |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 349 | CHECK(baz != NULL); |
| 350 | } |
| 351 | |
| 352 | void TearDown() override { |
| 353 | } |
| 354 | }; |
| 355 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 356 | template <typename T> |
| 357 | static void EXPECT_OK(::android::hardware::Return<T> ret) { |
| 358 | EXPECT_TRUE(ret.getStatus().isOk()); |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 359 | } |
| 360 | |
| 361 | TEST_F(HidlTest, BazSomeBaseMethodTest) { |
| 362 | EXPECT_OK(baz->someBaseMethod()); |
| 363 | } |
| 364 | |
| 365 | TEST_F(HidlTest, BazSomeOtherBaseMethodTest) { |
| 366 | IBase::Foo foo; |
| 367 | foo.x = 1; |
| 368 | foo.y.z = 2.5; |
| 369 | foo.y.s = "Hello, world"; |
| 370 | |
| 371 | foo.aaa.resize(5); |
| 372 | for (size_t i = 0; i < foo.aaa.size(); ++i) { |
| 373 | foo.aaa[i].z = 1.0f + (float)i * 0.01f; |
| 374 | foo.aaa[i].s = ("Hello, world " + std::to_string(i)).c_str(); |
| 375 | } |
| 376 | |
| 377 | EXPECT_OK( |
| 378 | baz->someOtherBaseMethod( |
| 379 | foo, |
| 380 | [&](const auto &result) { |
| 381 | EXPECT_EQ( |
| 382 | to_string(result), |
| 383 | "Foo(x = 1, " |
| 384 | "y = Bar(z = 2.500000, s = 'Hello, world'), " |
| 385 | "aaa = [Bar(z = 1.000000, s = 'Hello, world 0'), " |
| 386 | "Bar(z = 1.010000, s = 'Hello, world 1'), " |
| 387 | "Bar(z = 1.020000, s = 'Hello, world 2'), " |
| 388 | "Bar(z = 1.030000, s = 'Hello, world 3'), " |
| 389 | "Bar(z = 1.040000, s = 'Hello, world 4')])"); |
| 390 | })); |
| 391 | } |
| 392 | |
| 393 | TEST_F(HidlTest, BazSomeBoolMethodTest) { |
| 394 | auto result = baz->someBoolMethod(true); |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 395 | EXPECT_OK(result); |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 396 | EXPECT_EQ(to_string(result), "false"); |
| 397 | } |
| 398 | |
| 399 | TEST_F(HidlTest, BazSomeBoolArrayMethodTest) { |
| 400 | const bool someBoolArray[3] = { true, false, true }; |
| 401 | |
| 402 | EXPECT_OK( |
| 403 | baz->someBoolArrayMethod( |
| 404 | someBoolArray, |
| 405 | [&](const auto &result) { |
| 406 | EXPECT_EQ( |
| 407 | array_to_string(result, 4), |
| 408 | "[false, true, false, true]"); |
| 409 | })); |
| 410 | } |
| 411 | |
| 412 | TEST_F(HidlTest, BazSomeBoolVectorMethodTest) { |
| 413 | hidl_vec<bool> someBoolVector; |
| 414 | someBoolVector.resize(4); |
| 415 | for (size_t i = 0; i < someBoolVector.size(); ++i) { |
| 416 | someBoolVector[i] = ((i & 1) == 0); |
| 417 | } |
| 418 | |
| 419 | EXPECT_OK( |
| 420 | baz->someBoolVectorMethod( |
| 421 | someBoolVector, |
| 422 | [&](const auto &result) { |
| 423 | EXPECT_EQ( |
| 424 | to_string(result), "[false, true, false, true]"); |
| 425 | })); |
| 426 | } |
| 427 | |
| 428 | TEST_F(HidlTest, BazDoThisMethodTest) { |
| 429 | EXPECT_OK(baz->doThis(1.0f)); |
| 430 | } |
| 431 | |
| 432 | TEST_F(HidlTest, BazDoThatAndReturnSomethingMethodTest) { |
| 433 | auto result = baz->doThatAndReturnSomething(1); |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 434 | EXPECT_OK(result); |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 435 | EXPECT_EQ(to_string(result), "666"); |
| 436 | } |
| 437 | |
| 438 | TEST_F(HidlTest, BazDoQuiteABitMethodTest) { |
| 439 | auto result = baz->doQuiteABit(1, 2ll, 3.0f, 4.0); |
| 440 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 441 | EXPECT_OK(result); |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 442 | EXPECT_EQ(to_string(result), "666.500000"); |
| 443 | } |
| 444 | |
| 445 | TEST_F(HidlTest, BazDoSomethingElseMethodTest) { |
| 446 | int32_t param[15]; |
| 447 | for (size_t i = 0; i < 15; ++i) { |
| 448 | param[i] = i; |
| 449 | } |
| 450 | |
| 451 | EXPECT_OK( |
| 452 | baz->doSomethingElse( |
| 453 | param, |
| 454 | [&](const auto &result) { |
| 455 | EXPECT_EQ( |
| 456 | array_to_string(result, 32), |
| 457 | "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, " |
| 458 | "28, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, " |
| 459 | "1, 2]"); |
| 460 | })); |
| 461 | } |
| 462 | |
| 463 | TEST_F(HidlTest, BazDoStuffAndReturnAStringMethodTest) { |
| 464 | EXPECT_OK( |
| 465 | baz->doStuffAndReturnAString( |
| 466 | [&](const auto &result) { |
| 467 | EXPECT_EQ(to_string(result), "'Hello, world!'"); |
| 468 | })); |
| 469 | } |
| 470 | |
| 471 | TEST_F(HidlTest, BazMapThisVectorMethodTest) { |
| 472 | hidl_vec<int32_t> vec_param; |
| 473 | vec_param.resize(15); |
| 474 | for (size_t i = 0; i < 15; ++i) { |
| 475 | vec_param[i] = i; |
| 476 | } |
| 477 | |
| 478 | EXPECT_OK( |
| 479 | baz->mapThisVector( |
| 480 | vec_param, |
| 481 | [&](const auto &result) { |
| 482 | EXPECT_EQ( |
| 483 | array_to_string(&result[0], result.size()), |
| 484 | "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, " |
| 485 | "28]"); |
| 486 | })); |
| 487 | } |
| 488 | |
| 489 | TEST_F(HidlTest, BazCallMeMethodTest) { |
| 490 | EXPECT_OK(baz->callMe(new BazCallback())); |
| 491 | } |
| 492 | |
| 493 | TEST_F(HidlTest, BazUseAnEnumMethodTest) { |
| 494 | auto result = baz->useAnEnum(IBaz::SomeEnum::bar); |
| 495 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 496 | EXPECT_OK(result); |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 497 | EXPECT_TRUE(result == IBaz::SomeEnum::quux); |
| 498 | } |
| 499 | |
| 500 | TEST_F(HidlTest, BazHaveSomeStringsMethodTest) { |
| 501 | hidl_string string_params[3]; |
| 502 | string_params[0] = "one"; |
| 503 | string_params[1] = "two"; |
| 504 | string_params[2] = "three"; |
| 505 | |
| 506 | EXPECT_OK( |
| 507 | baz->haveSomeStrings( |
| 508 | string_params, |
| 509 | [&](const auto &result) { |
| 510 | EXPECT_EQ( |
| 511 | array_to_string(result, 2), "['Hello', 'World']"); |
| 512 | })); |
| 513 | } |
| 514 | |
| 515 | TEST_F(HidlTest, BazHaveAStringVecMethodTest) { |
| 516 | hidl_vec<hidl_string> string_vec; |
| 517 | string_vec.resize(4); |
| 518 | string_vec[0] = "Uno"; |
| 519 | string_vec[1] = "Dos"; |
| 520 | string_vec[2] = "Tres"; |
| 521 | string_vec[3] = "Cuatro"; |
| 522 | |
| 523 | EXPECT_OK( |
| 524 | baz->haveAStringVec( |
| 525 | string_vec, |
| 526 | [&](const auto &result) { |
| 527 | EXPECT_EQ( |
| 528 | array_to_string(&result[0], result.size()), |
| 529 | "['Hello', 'World']"); |
| 530 | })); |
| 531 | } |
| 532 | |
| 533 | TEST_F(HidlTest, BazReturnABunchOfStringsMethodTest) { |
| 534 | EXPECT_OK( |
| 535 | baz->returnABunchOfStrings( |
| 536 | [&](const auto &a, const auto &b, const auto &c) { |
| 537 | EXPECT_EQ( |
| 538 | to_string(a) + ", " + to_string(b) + ", " + to_string(c), |
| 539 | "'Eins', 'Zwei', 'Drei'"); |
| 540 | })); |
| 541 | } |
| 542 | |
| 543 | int main(int argc, char **argv) { |
| 544 | using namespace android::hardware; |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 545 | |
| 546 | const char *me = argv[0]; |
| 547 | |
| 548 | bool wantClient = false; |
| 549 | bool wantServer = false; |
| 550 | |
| 551 | int res; |
| 552 | while ((res = getopt(argc, argv, "chs")) >= 0) { |
| 553 | switch (res) { |
| 554 | case 'c': |
| 555 | { |
| 556 | wantClient = true; |
| 557 | break; |
| 558 | } |
| 559 | |
| 560 | case 's': |
| 561 | { |
| 562 | wantServer = true; |
| 563 | break; |
| 564 | } |
| 565 | |
| 566 | case '?': |
| 567 | case 'h': |
| 568 | default: |
| 569 | { |
| 570 | usage(me); |
| 571 | exit(1); |
| 572 | break; |
| 573 | } |
| 574 | } |
| 575 | } |
| 576 | |
| 577 | if ((!wantClient && !wantServer) || (wantClient && wantServer)) { |
| 578 | usage(me); |
| 579 | exit(1); |
| 580 | } |
| 581 | |
| 582 | if (wantClient) { |
| 583 | ::testing::AddGlobalTestEnvironment(new HidlEnvironment); |
| 584 | ::testing::InitGoogleTest(&argc, argv); |
| 585 | int status = RUN_ALL_TESTS(); |
| 586 | return status; |
| 587 | } else { |
| 588 | sp<Baz> baz = new Baz; |
| 589 | |
| 590 | const hidl_version kVersion = make_hidl_version(1, 0); |
| 591 | |
Martijn Coenen | 4ff971c | 2016-09-08 13:40:02 +0200 | [diff] [blame^] | 592 | baz->registerAsService("baz", kVersion); |
Andreas Huber | 401cd16 | 2016-08-26 10:40:30 -0700 | [diff] [blame] | 593 | |
| 594 | ProcessState::self()->startThreadPool(); |
| 595 | ProcessState::self()->setThreadPoolMaxThreadCount(0); |
| 596 | IPCThreadState::self()->joinThreadPool(); |
| 597 | } |
| 598 | |
| 599 | return 0; |
| 600 | } |
| 601 | |