Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 1 | #define LOG_TAG "hidl_test" |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 2 | #include <android-base/logging.h> |
| 3 | |
Steven Moreland | 88ca451 | 2016-08-11 11:24:10 -0700 | [diff] [blame] | 4 | #include <android/hardware/tests/foo/1.0/BnFoo.h> |
| 5 | #include <android/hardware/tests/foo/1.0/BnFooCallback.h> |
| 6 | #include <android/hardware/tests/bar/1.0/BnBar.h> |
Yifan Hong | bf459bc | 2016-08-23 16:50:37 -0700 | [diff] [blame] | 7 | #include <android/hardware/tests/pointer/1.0/BnGraph.h> |
| 8 | #include <android/hardware/tests/pointer/1.0/BnPointer.h> |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 9 | |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 10 | #include <gtest/gtest.h> |
Iliyan Malchev | 0acf419 | 2016-08-22 19:33:20 -0700 | [diff] [blame] | 11 | #include <inttypes.h> |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 12 | #if GTEST_IS_THREADSAFE |
| 13 | #include <sys/types.h> |
| 14 | #include <signal.h> |
| 15 | #include <errno.h> |
| 16 | #include <pthread.h> |
| 17 | #else |
| 18 | #error "GTest did not detect pthread library." |
| 19 | #endif |
| 20 | |
Yifan Hong | bf459bc | 2016-08-23 16:50:37 -0700 | [diff] [blame] | 21 | #include <vector> |
| 22 | #include <sstream> |
| 23 | |
Martijn Coenen | 7473fab | 2016-08-19 14:05:40 +0200 | [diff] [blame] | 24 | #include <hidl/IServiceManager.h> |
Martijn Coenen | 9391510 | 2016-09-01 01:35:52 +0200 | [diff] [blame] | 25 | #include <hidl/Status.h> |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 26 | #include <hwbinder/IPCThreadState.h> |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 27 | #include <hwbinder/ProcessState.h> |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 28 | |
Iliyan Malchev | 0acf419 | 2016-08-22 19:33:20 -0700 | [diff] [blame] | 29 | #include <utils/Condition.h> |
| 30 | #include <utils/Timers.h> |
| 31 | |
Yifan Hong | bf459bc | 2016-08-23 16:50:37 -0700 | [diff] [blame] | 32 | #define PUSH_ERROR_IF(__cond__) if(__cond__) { errors.push_back(std::to_string(__LINE__) + ": " + #__cond__); } |
| 33 | #define EXPECT_OK(__ret__) EXPECT_TRUE(isOk(__ret__)) |
Yifan Hong | 8446590 | 2016-09-27 15:52:17 -0700 | [diff] [blame] | 34 | #define EXPECT_FAIL(__ret__) EXPECT_FALSE(isOk(__ret__)) |
Yifan Hong | bf459bc | 2016-08-23 16:50:37 -0700 | [diff] [blame] | 35 | #define EXPECT_ARRAYEQ(__a1__, __a2__, __size__) EXPECT_TRUE(IsArrayEq(__a1__, __a2__, __size__)) |
| 36 | |
| 37 | // TODO uncomment this when kernel is patched with pointer changes. |
| 38 | //#define HIDL_RUN_POINTER_TESTS 1 |
| 39 | |
Yifan Hong | 3eac8a3 | 2016-10-11 10:02:59 -0700 | [diff] [blame^] | 40 | |
| 41 | // Defined in FooCallback. |
| 42 | static const nsecs_t DELAY_S = 1; |
| 43 | static const nsecs_t DELAY_NS = seconds_to_nanoseconds(DELAY_S); |
| 44 | static const nsecs_t TOLERANCE_NS = milliseconds_to_nanoseconds(10); |
| 45 | static const nsecs_t ONEWAY_TOLERANCE_NS = milliseconds_to_nanoseconds(1); |
| 46 | |
Steven Moreland | 88ca451 | 2016-08-11 11:24:10 -0700 | [diff] [blame] | 47 | using ::android::hardware::tests::foo::V1_0::IFoo; |
| 48 | using ::android::hardware::tests::foo::V1_0::IFooCallback; |
| 49 | using ::android::hardware::tests::bar::V1_0::IBar; |
Steven Moreland | 4078631 | 2016-08-16 10:29:40 -0700 | [diff] [blame] | 50 | using ::android::hardware::tests::bar::V1_0::IHwBar; |
Steven Moreland | 88ca451 | 2016-08-11 11:24:10 -0700 | [diff] [blame] | 51 | using ::android::hardware::tests::foo::V1_0::Abc; |
Yifan Hong | bf459bc | 2016-08-23 16:50:37 -0700 | [diff] [blame] | 52 | using ::android::hardware::tests::pointer::V1_0::IGraph; |
| 53 | using ::android::hardware::tests::pointer::V1_0::IPointer; |
Iliyan Malchev | 2b6591b | 2016-08-18 19:15:19 -0700 | [diff] [blame] | 54 | using ::android::hardware::Return; |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 55 | using ::android::hardware::Void; |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 56 | using ::android::hardware::hidl_array; |
Andreas Huber | 8a82ff7 | 2016-08-04 10:29:39 -0700 | [diff] [blame] | 57 | using ::android::hardware::hidl_vec; |
| 58 | using ::android::hardware::hidl_string; |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 59 | using ::android::sp; |
Iliyan Malchev | 0acf419 | 2016-08-22 19:33:20 -0700 | [diff] [blame] | 60 | using ::android::Mutex; |
| 61 | using ::android::Condition; |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 62 | |
Yifan Hong | bf459bc | 2016-08-23 16:50:37 -0700 | [diff] [blame] | 63 | template <typename T> |
| 64 | static inline ::testing::AssertionResult isOk(::android::hardware::Return<T> ret) { |
| 65 | return ret.getStatus().isOk() |
| 66 | ? (::testing::AssertionSuccess() << ret.getStatus()) |
| 67 | : (::testing::AssertionFailure() << ret.getStatus()); |
| 68 | } |
| 69 | |
| 70 | template<typename T, typename S> |
| 71 | static inline bool isArrayEqual(const T arr1, const S arr2, size_t size) { |
| 72 | for(size_t i = 0; i < size; i++) |
| 73 | if(arr1[i] != arr2[i]) |
| 74 | return false; |
| 75 | return true; |
| 76 | } |
| 77 | |
| 78 | static void simpleGraph(IGraph::Graph& g) { |
| 79 | g.nodes.resize(2); |
| 80 | g.edges.resize(1); |
| 81 | g.nodes[0].data = 10; |
| 82 | g.nodes[1].data = 20; |
| 83 | g.edges[0].left = &g.nodes[0]; |
| 84 | g.edges[0].right = &g.nodes[1]; |
| 85 | } |
| 86 | static bool isSimpleGraph(const IGraph::Graph &g) { |
| 87 | if(g.nodes.size() != 2) return false; |
| 88 | if(g.edges.size() != 1) return false; |
| 89 | if(g.nodes[0].data != 10) return false; |
| 90 | if(g.nodes[1].data != 20) return false; |
| 91 | if(g.edges[0].left != &g.nodes[0]) return false; |
| 92 | if(g.edges[0].right != &g.nodes[1]) return false; |
| 93 | return true; |
| 94 | } |
| 95 | |
| 96 | static void logSimpleGraph(const char *prefix, const IGraph::Graph& g) { |
| 97 | ALOGI("%s Graph %p, %d nodes, %d edges", prefix, &g, (int)g.nodes.size(), (int)g.edges.size()); |
| 98 | std::ostringstream os; |
| 99 | for(size_t i = 0; i < g.nodes.size(); i++) |
| 100 | os << &g.nodes[i] << " = " << g.nodes[i].data << ", "; |
| 101 | ALOGI("%s Nodes: [%s]", prefix, os.str().c_str()); |
| 102 | os.str(""); |
| 103 | os.clear(); |
| 104 | for(size_t i = 0; i < g.edges.size(); i++) |
| 105 | os << g.edges[i].left << " -> " << g.edges[i].right << ", "; |
| 106 | ALOGI("%s Edges: [%s]", prefix, os.str().c_str()); |
| 107 | } |
| 108 | |
| 109 | struct GraphInterface : public IGraph { |
| 110 | Return<void> passAGraph(const Graph& e) override; |
| 111 | Return<void> giveAGraph(giveAGraph_cb _cb) override; |
| 112 | Return<void> passANode(const IGraph::Node& n) override; |
| 113 | Return<void> passTwoGraphs(IGraph::Graph const* g1, IGraph::Graph const* g2) override; |
| 114 | Return<void> passAGamma(const IGraph::Gamma& c) override; |
| 115 | Return<void> passASimpleRef(const IGraph::Alpha * a) override; |
| 116 | Return<void> giveASimpleRef(giveASimpleRef_cb _hidl_cb) override; |
| 117 | Return<void> passASimpleRefS(const IGraph::Theta * s) override; |
| 118 | Return<int32_t> getErrors() override; |
| 119 | private: |
| 120 | std::vector<std::string> errors; |
| 121 | }; |
| 122 | |
| 123 | Return<void> GraphInterface::passAGraph(const Graph& g) { |
| 124 | ALOGI("SERVER(Graph) passAGraph start."); |
| 125 | PUSH_ERROR_IF(!isSimpleGraph(g)); |
| 126 | // logSimpleGraph("SERVER(Graph) passAGraph:", g); |
| 127 | return Void(); |
| 128 | } |
| 129 | |
| 130 | Return<void> GraphInterface::giveAGraph(giveAGraph_cb _cb) { |
| 131 | IGraph::Graph g; |
| 132 | simpleGraph(g); |
| 133 | _cb(g); |
| 134 | return Void(); |
| 135 | } |
| 136 | |
| 137 | Return<void> GraphInterface::passANode(const IGraph::Node& n) { |
| 138 | PUSH_ERROR_IF(n.data != 10); |
| 139 | return Void(); |
| 140 | } |
| 141 | |
| 142 | Return<void> GraphInterface::passTwoGraphs(IGraph::Graph const* g1, IGraph::Graph const* g2) { |
| 143 | PUSH_ERROR_IF(g1 != g2); |
| 144 | PUSH_ERROR_IF(!isSimpleGraph(*g1)); |
| 145 | logSimpleGraph("SERVER(Graph): passTwoGraphs", *g2); |
| 146 | return Void(); |
| 147 | } |
| 148 | |
| 149 | Return<void> GraphInterface::passAGamma(const IGraph::Gamma& c) { |
| 150 | if(c.a_ptr == nullptr && c.b_ptr == nullptr) |
| 151 | return Void(); |
| 152 | ALOGI("SERVER(Graph) passAGamma received c.a = %p, c.b = %p, c.a->s = %p, c.b->s = %p", |
| 153 | c.a_ptr, c.b_ptr, c.a_ptr->s_ptr, c.b_ptr->s_ptr); |
| 154 | ALOGI("SERVER(Graph) passAGamma received data %d, %d", |
| 155 | (int)c.a_ptr->s_ptr->data, (int)c.b_ptr->s_ptr->data); |
| 156 | PUSH_ERROR_IF(c.a_ptr->s_ptr != c.b_ptr->s_ptr); |
| 157 | return Void(); |
| 158 | } |
| 159 | Return<void> GraphInterface::passASimpleRef(const IGraph::Alpha * a_ptr) { |
| 160 | ALOGI("SERVER(Graph) passASimpleRef received %d", a_ptr->s_ptr->data); |
| 161 | PUSH_ERROR_IF(a_ptr->s_ptr->data != 500); |
| 162 | return Void(); |
| 163 | } |
| 164 | Return<void> GraphInterface::passASimpleRefS(const IGraph::Theta * s_ptr) { |
| 165 | ALOGI("SERVER(Graph) passASimpleRefS received %d @ %p", s_ptr->data, s_ptr); |
| 166 | PUSH_ERROR_IF(s_ptr->data == 10); |
| 167 | return Void(); |
| 168 | } |
| 169 | Return<void> GraphInterface::giveASimpleRef(giveASimpleRef_cb _cb) { |
| 170 | IGraph::Theta s; s.data = 500; |
| 171 | IGraph::Alpha a; a.s_ptr = &s; |
| 172 | _cb(&a); |
| 173 | return Void(); |
| 174 | } |
| 175 | |
| 176 | Return<int32_t> GraphInterface::getErrors() { |
| 177 | if(!errors.empty()) { |
| 178 | for(const auto& e : errors) |
| 179 | ALOGW("SERVER(Graph) error: %s", e.c_str()); |
| 180 | } |
| 181 | return errors.size(); |
| 182 | } |
| 183 | |
| 184 | struct PointerInterface : public IPointer { |
| 185 | private: |
| 186 | std::vector<std::string> errors; |
| 187 | public: |
| 188 | Return<int32_t> getErrors() { |
| 189 | if(!errors.empty()) { |
| 190 | for(const auto& e : errors) |
| 191 | ALOGW("SERVER(Pointer) error: %s", e.c_str()); |
| 192 | } |
| 193 | return errors.size(); |
| 194 | } |
| 195 | Return<void> foo1(const IPointer::Sam& s, IPointer::Sam const* s_ptr) override { |
| 196 | PUSH_ERROR_IF(!(&s == s_ptr)); |
| 197 | return Void(); |
| 198 | } |
| 199 | Return<void> foo2(const IPointer::Sam& s, const IPointer::Ada& a) override { |
| 200 | PUSH_ERROR_IF(!(&s == a.s_ptr)); |
| 201 | return Void(); |
| 202 | } |
| 203 | Return<void> foo3(const IPointer::Sam& s, const IPointer::Ada& a, const IPointer::Bob& b) override { |
| 204 | PUSH_ERROR_IF(!(&a == b.a_ptr && a.s_ptr == b.s_ptr && a.s_ptr == &s)); |
| 205 | return Void(); |
| 206 | } |
| 207 | Return<void> foo4(IPointer::Sam const* s_ptr) override { |
| 208 | PUSH_ERROR_IF(!(s_ptr->data == 500)); |
| 209 | return Void(); |
| 210 | } |
| 211 | Return<void> foo5(const IPointer::Ada& a, const IPointer::Bob& b) override { |
| 212 | PUSH_ERROR_IF(!(a.s_ptr == b.s_ptr && b.a_ptr == &a)); |
| 213 | return Void(); |
| 214 | } |
| 215 | Return<void> foo6(IPointer::Ada const* a_ptr) override { |
| 216 | PUSH_ERROR_IF(!(a_ptr->s_ptr->data == 500)); |
| 217 | return Void(); |
| 218 | } |
| 219 | Return<void> foo7(IPointer::Ada const* a_ptr, IPointer::Bob const* b_ptr) override { |
| 220 | PUSH_ERROR_IF(!(a_ptr->s_ptr == b_ptr->s_ptr && a_ptr == b_ptr->a_ptr && a_ptr->s_ptr->data == 500)); |
| 221 | return Void(); |
| 222 | } |
| 223 | Return<void> foo8(const IPointer::Dom& d) override { |
| 224 | const IPointer::Cin& c = d.c; |
| 225 | PUSH_ERROR_IF(&c.a != c.b_ptr->a_ptr); |
| 226 | PUSH_ERROR_IF(c.a.s_ptr != c.b_ptr->s_ptr); |
| 227 | PUSH_ERROR_IF(c.a.s_ptr->data != 500); |
| 228 | return Void(); |
| 229 | } |
| 230 | Return<void> foo9(::android::hardware::hidl_string const* str_ref) override { |
| 231 | ALOGI("SERVER(Pointer) foo9 got string @ %p (size = %ld) \"%s\"", |
| 232 | str_ref->c_str(), |
| 233 | (unsigned long) str_ref->size(), str_ref->c_str()); |
| 234 | PUSH_ERROR_IF(!(strcmp(str_ref->c_str(), "meowmeowmeow") == 0)); |
| 235 | return Void(); |
| 236 | } |
| 237 | Return<void> foo10(const ::android::hardware::hidl_vec<IPointer::Sam const*>& s_ptr_vec) override { |
| 238 | PUSH_ERROR_IF(s_ptr_vec[0]->data != 500); |
| 239 | if(s_ptr_vec.size() != 5) { |
| 240 | errors.push_back("foo10: s_ptr_vec.size() != 5"); |
| 241 | return Void(); |
| 242 | } |
| 243 | for(size_t i = 0; i < s_ptr_vec.size(); i++) |
| 244 | PUSH_ERROR_IF(s_ptr_vec[0] != s_ptr_vec[i]); |
| 245 | return Void(); |
| 246 | } |
| 247 | Return<void> foo11(::android::hardware::hidl_vec<IPointer::Sam> const* s_vec_ptr) override { |
| 248 | if(s_vec_ptr->size() != 5) { |
| 249 | errors.push_back("foo11: s_vec_ptr->size() != 5"); |
| 250 | return Void(); |
| 251 | } |
| 252 | for(size_t i = 0; i < 5; i++) |
| 253 | PUSH_ERROR_IF((*s_vec_ptr)[i].data != 500); |
| 254 | return Void(); |
| 255 | } |
| 256 | Return<void> foo12(hidl_array<IPointer::Sam, 5> const* s_array_ref) override { |
| 257 | for(size_t i = 0; i < 5; ++i) |
| 258 | PUSH_ERROR_IF((*s_array_ref)[i].data != 500); |
| 259 | return Void(); |
| 260 | } |
| 261 | Return<void> foo13(const hidl_array<IPointer::Sam const*, 5>& s_ref_array) override { |
| 262 | PUSH_ERROR_IF(s_ref_array[0]->data != 500) |
| 263 | for(size_t i = 0; i < 5; i++) |
| 264 | PUSH_ERROR_IF(s_ref_array[i] != s_ref_array[0]) |
| 265 | return Void(); |
| 266 | } |
| 267 | Return<void> foo14(IPointer::Sam const* const* const* s_3ptr) override { |
| 268 | PUSH_ERROR_IF(!((***s_3ptr).data == 500)) |
| 269 | return Void(); |
| 270 | } |
| 271 | Return<void> foo15(int32_t const* const* const* i_3ptr) override { |
| 272 | PUSH_ERROR_IF(!((***i_3ptr) == 500)) |
| 273 | return Void(); |
| 274 | } |
| 275 | |
| 276 | Return<void> foo16(const IPointer::Ptr& p) override { |
| 277 | PUSH_ERROR_IF((*p.array_ptr)[0].s_ptr->data != 500); |
| 278 | for(size_t i = 0; i < 5; i++) PUSH_ERROR_IF((*p.array_ptr)[i].s_ptr != (*p.array_ptr)[0].s_ptr); |
| 279 | PUSH_ERROR_IF(*(p.int_ptr) != 500); |
| 280 | for(size_t i = 0; i < 5; i++) PUSH_ERROR_IF((*p.int_array_ptr)[i] != 500); |
| 281 | for(size_t i = 0; i < 5; i++) PUSH_ERROR_IF(p.int_ptr_array[i] != p.int_ptr); |
| 282 | PUSH_ERROR_IF(p.a_ptr_vec.size() != 5); |
| 283 | PUSH_ERROR_IF(p.a_ptr_vec[0]->s_ptr->data != 500); |
| 284 | for(size_t i = 0; i < 5; i++) PUSH_ERROR_IF(p.a_ptr_vec[i]->s_ptr != p.a_ptr_vec[0]->s_ptr); |
| 285 | PUSH_ERROR_IF(strcmp(p.str_ref->c_str(), "meowmeowmeow") != 0); |
| 286 | PUSH_ERROR_IF(p.a_vec_ptr->size() != 5); |
| 287 | PUSH_ERROR_IF((*p.a_vec_ptr)[0].s_ptr->data != 500); |
| 288 | for(size_t i = 0; i < 5; i++) PUSH_ERROR_IF((*p.a_vec_ptr)[i].s_ptr != (*p.a_vec_ptr)[0].s_ptr); |
| 289 | return Void(); |
| 290 | }; |
| 291 | Return<void> foo17(IPointer::Ptr const* p) override { |
| 292 | return foo16(*p); |
| 293 | }; |
| 294 | Return<void> foo18(hidl_string const* str_ref, hidl_string const* str_ref2, const hidl_string& str) override { |
| 295 | PUSH_ERROR_IF(&str != str_ref); |
| 296 | PUSH_ERROR_IF(str_ref != str_ref2); |
| 297 | PUSH_ERROR_IF(strcmp(str.c_str(), "meowmeowmeow") != 0) |
| 298 | return Void(); |
| 299 | }; |
| 300 | Return<void> foo19( |
| 301 | hidl_vec<IPointer::Ada> const* a_vec_ref, |
| 302 | const hidl_vec<IPointer::Ada>& a_vec, |
| 303 | hidl_vec<IPointer::Ada> const* a_vec_ref2) { |
| 304 | PUSH_ERROR_IF(&a_vec != a_vec_ref); |
| 305 | PUSH_ERROR_IF(a_vec_ref2 != a_vec_ref); |
| 306 | PUSH_ERROR_IF(a_vec.size() != 5); |
| 307 | PUSH_ERROR_IF(a_vec[0].s_ptr->data != 500); |
| 308 | for(size_t i = 0; i < 5; i++) |
| 309 | PUSH_ERROR_IF(a_vec[i].s_ptr != a_vec[0].s_ptr); |
| 310 | return Void(); |
| 311 | }; |
| 312 | |
Yifan Hong | 8446590 | 2016-09-27 15:52:17 -0700 | [diff] [blame] | 313 | Return<void> foo20(const hidl_vec<IPointer::Sam const*>&) override { |
| 314 | return Void(); |
| 315 | } |
Yifan Hong | bf459bc | 2016-08-23 16:50:37 -0700 | [diff] [blame] | 316 | Return<void> foo21(hidl_array<IPointer::Ada, 3, 2, 1> const* a_array_ptr) override { |
| 317 | const hidl_array<IPointer::Ada, 3, 2, 1>& a_array = *a_array_ptr; |
| 318 | PUSH_ERROR_IF(a_array[0][0][0].s_ptr->data != 500); |
| 319 | for(size_t i = 0; i < 3; i++) |
| 320 | for(size_t j = 0; j < 2; j++) |
| 321 | for(size_t k = 0; k < 1; k++) |
| 322 | PUSH_ERROR_IF(a_array[i][j][k].s_ptr != a_array[0][0][0].s_ptr); |
| 323 | return Void(); |
| 324 | } |
| 325 | Return<void> foo22(const hidl_array<IPointer::Ada const*, 3, 2, 1>& a_ptr_array) override { |
| 326 | PUSH_ERROR_IF(a_ptr_array[0][0][0]->s_ptr->data != 500); |
| 327 | for(size_t i = 0; i < 3; i++) |
| 328 | for(size_t j = 0; j < 2; j++) |
| 329 | for(size_t k = 0; k < 1; k++) |
| 330 | PUSH_ERROR_IF(a_ptr_array[i][j][k] != a_ptr_array[0][0][0]); |
| 331 | return Void(); |
| 332 | } |
| 333 | |
| 334 | IPointer::Sam *s; |
| 335 | IPointer::Ada *a; |
| 336 | IPointer::Bob *b; |
| 337 | IPointer::Cin *c; |
| 338 | IPointer::Dom *d; |
| 339 | |
| 340 | IPointer::Ptr p; |
| 341 | hidl_array<IPointer::Ada, 5> a_array; |
| 342 | int32_t someInt; |
| 343 | hidl_array<int32_t, 5> someIntArray; |
| 344 | hidl_string str; |
| 345 | hidl_vec<IPointer::Ada> a_vec; |
| 346 | PointerInterface() { |
| 347 | d = new IPointer::Dom(); |
| 348 | s = new IPointer::Sam(); |
| 349 | b = new IPointer::Bob(); |
| 350 | c = &d->c; |
| 351 | a = &c->a; |
| 352 | b->s_ptr = a->s_ptr = s; |
| 353 | b->a_ptr = a; |
| 354 | c->b_ptr = b; |
| 355 | s->data = 500; |
| 356 | |
| 357 | someInt = 500; |
| 358 | for(size_t i = 0; i < 5; i++) someIntArray[i] = 500; |
| 359 | |
| 360 | for(size_t i = 0; i < 5; i++) a_array[i] = *a; |
| 361 | |
| 362 | for(size_t i = 0; i < 5; i++) p.ptr_array[i] = a; |
| 363 | p.array_ptr = &a_array; |
| 364 | p.int_ptr = &someInt; |
| 365 | p.int_array_ptr = &someIntArray; |
| 366 | for(size_t i = 0; i < 5; i++) p.int_ptr_array[i] = &someInt; |
| 367 | p.a_ptr_vec.resize(5); |
| 368 | for(size_t i = 0; i < 5; i++) p.a_ptr_vec[i] = a; |
| 369 | str = "meowmeowmeow"; |
| 370 | p.str_ref = &str; |
| 371 | a_vec.resize(5); |
| 372 | for(size_t i = 0; i < 5; i++) a_vec[i].s_ptr = s; |
| 373 | p.a_vec_ptr = &a_vec; |
| 374 | } |
| 375 | ~PointerInterface() { |
| 376 | delete d; delete s; delete b; |
| 377 | } |
| 378 | Return<void> bar1(bar1_cb _cb) override { |
| 379 | _cb(*s, s); |
| 380 | return Void(); |
| 381 | } |
| 382 | Return<void> bar2(bar2_cb _cb) override { |
| 383 | _cb(*s, *a); |
| 384 | return Void(); |
| 385 | } |
| 386 | Return<void> bar3(bar3_cb _cb) override { |
| 387 | _cb(*s, *a, *b); |
| 388 | return Void(); |
| 389 | } |
| 390 | Return<void> bar4(bar4_cb _cb) override { |
| 391 | _cb(s); |
| 392 | return Void(); |
| 393 | } |
| 394 | Return<void> bar5(bar5_cb _cb) override { |
| 395 | _cb(*a, *b); |
| 396 | return Void(); |
| 397 | } |
| 398 | Return<void> bar6(bar6_cb _cb) override { |
| 399 | _cb(a); |
| 400 | return Void(); |
| 401 | } |
| 402 | Return<void> bar7(bar7_cb _cb) override { |
| 403 | _cb(a, b); |
| 404 | return Void(); |
| 405 | } |
| 406 | Return<void> bar8(bar8_cb _cb) override { |
| 407 | _cb(*d); |
| 408 | return Void(); |
| 409 | } |
| 410 | Return<void> bar9(bar9_cb _cb) override { |
| 411 | _cb(&str); |
| 412 | return Void(); |
| 413 | } |
| 414 | Return<void> bar10(bar10_cb _cb) override { |
| 415 | hidl_vec<const IPointer::Sam *> v; v.resize(5); |
| 416 | for(size_t i = 0; i < 5; i++) v[i] = s; |
| 417 | _cb(v); |
| 418 | return Void(); |
| 419 | } |
| 420 | Return<void> bar11(bar11_cb _cb) override { |
| 421 | hidl_vec<IPointer::Sam> v; v.resize(5); |
| 422 | for(size_t i = 0; i < 5; i++) v[i].data = 500; |
| 423 | _cb(&v); |
| 424 | return Void(); |
| 425 | } |
| 426 | Return<void> bar12(bar12_cb _cb) override { |
| 427 | hidl_array<IPointer::Sam, 5> array; |
| 428 | for(size_t i = 0; i < 5; i++) array[i] = *s; |
| 429 | _cb(&array); |
| 430 | return Void(); |
| 431 | } |
| 432 | Return<void> bar13(bar13_cb _cb) override { |
| 433 | hidl_array<const IPointer::Sam *, 5> array; |
| 434 | for(size_t i = 0; i < 5; i++) array[i] = s; |
| 435 | _cb(array); |
| 436 | return Void(); |
| 437 | } |
| 438 | Return<void> bar14(bar14_cb _cb) override { |
| 439 | IPointer::Sam const* p1 = s; |
| 440 | IPointer::Sam const* const* p2 = &p1; |
| 441 | _cb(&p2); |
| 442 | return Void(); |
| 443 | } |
| 444 | Return<void> bar15(bar15_cb _cb) override { |
| 445 | int32_t const* p1 = &someInt; |
| 446 | int32_t const* const* p2 = &p1; |
| 447 | _cb(&p2); |
| 448 | return Void(); |
| 449 | } |
| 450 | Return<void> bar16(bar16_cb _cb) override { |
| 451 | _cb(p); |
| 452 | return Void(); |
| 453 | } |
| 454 | Return<void> bar17(bar17_cb _cb) override { |
| 455 | _cb(&p); |
| 456 | return Void(); |
| 457 | } |
| 458 | Return<void> bar18(bar18_cb _cb) override { |
| 459 | _cb(&str, &str, str); |
| 460 | return Void(); |
| 461 | } |
| 462 | Return<void> bar19(bar19_cb _cb) override { |
| 463 | _cb(&a_vec, a_vec, &a_vec); |
| 464 | return Void(); |
| 465 | } |
Yifan Hong | 8446590 | 2016-09-27 15:52:17 -0700 | [diff] [blame] | 466 | Return<void> bar20(bar20_cb _cb) override { |
| 467 | // 1026 == PARCEL_REF_CAP + 2. |
| 468 | // 1026 means 1 writeBuffer and 1025 writeReferences. 1025 > PARCEL_REF_CAP. |
| 469 | hidl_vec<const IPointer::Sam *> v; v.resize(1026); |
| 470 | for(size_t i = 0; i < 1026; i++) v[i] = s; |
| 471 | _cb(v); |
| 472 | return Void(); |
| 473 | } |
Yifan Hong | bf459bc | 2016-08-23 16:50:37 -0700 | [diff] [blame] | 474 | Return<void> bar21(bar21_cb _cb) override { |
| 475 | hidl_array<IPointer::Ada, 3, 2, 1> a_array; |
| 476 | for(size_t i = 0; i < 3; i++) |
| 477 | for(size_t j = 0; j < 2; j++) |
| 478 | for(size_t k = 0; k < 1; k++) |
| 479 | a_array[i][j][k] = *a; |
| 480 | _cb(&a_array); |
| 481 | return Void(); |
| 482 | } |
| 483 | Return<void> bar22(bar22_cb _cb) override { |
| 484 | hidl_array<const IPointer::Ada *, 3, 2, 1> a_ptr_array; |
| 485 | for(size_t i = 0; i < 3; i++) |
| 486 | for(size_t j = 0; j < 2; j++) |
| 487 | for(size_t k = 0; k < 1; k++) |
| 488 | a_ptr_array[i][j][k] = a; |
| 489 | _cb(a_ptr_array); |
| 490 | return Void(); |
| 491 | } |
| 492 | }; |
| 493 | |
Steven Moreland | 4078631 | 2016-08-16 10:29:40 -0700 | [diff] [blame] | 494 | struct FooCallback : public IFooCallback { |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 495 | FooCallback() : mLock{}, mCond{} {} |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 496 | Return<void> heyItsYou(const sp<IFooCallback> &cb) override; |
Iliyan Malchev | 2b6591b | 2016-08-18 19:15:19 -0700 | [diff] [blame] | 497 | Return<bool> heyItsYouIsntIt(const sp<IFooCallback> &cb) override; |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 498 | Return<void> heyItsTheMeaningOfLife(uint8_t tmol) override; |
| 499 | Return<void> reportResults(int64_t ns, reportResults_cb cb) override; |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 500 | Return<void> youBlockedMeFor(const hidl_array<int64_t, 3> &ns) override; |
Iliyan Malchev | 0acf419 | 2016-08-22 19:33:20 -0700 | [diff] [blame] | 501 | |
Steven Moreland | 60bce22 | 2016-09-07 10:17:43 -0700 | [diff] [blame] | 502 | static constexpr nsecs_t DELAY_S = 1; |
Iliyan Malchev | 0acf419 | 2016-08-22 19:33:20 -0700 | [diff] [blame] | 503 | static constexpr nsecs_t DELAY_NS = seconds_to_nanoseconds(DELAY_S); |
| 504 | static constexpr nsecs_t TOLERANCE_NS = milliseconds_to_nanoseconds(10); |
| 505 | static constexpr nsecs_t ONEWAY_TOLERANCE_NS = milliseconds_to_nanoseconds(1); |
| 506 | |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 507 | hidl_array<InvokeInfo, 3> invokeInfo; |
Iliyan Malchev | 0acf419 | 2016-08-22 19:33:20 -0700 | [diff] [blame] | 508 | Mutex mLock; |
| 509 | Condition mCond; |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 510 | }; |
| 511 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 512 | Return<void> FooCallback::heyItsYou( |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 513 | const sp<IFooCallback> &_cb) { |
Iliyan Malchev | 0acf419 | 2016-08-22 19:33:20 -0700 | [diff] [blame] | 514 | nsecs_t start = systemTime(); |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 515 | ALOGI("SERVER(FooCallback) heyItsYou cb = %p", _cb.get()); |
Iliyan Malchev | 0acf419 | 2016-08-22 19:33:20 -0700 | [diff] [blame] | 516 | mLock.lock(); |
| 517 | invokeInfo[0].invoked = true; |
| 518 | invokeInfo[0].timeNs = systemTime() - start; |
| 519 | mCond.signal(); |
| 520 | mLock.unlock(); |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 521 | return Void(); |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 522 | } |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 523 | |
Iliyan Malchev | 2b6591b | 2016-08-18 19:15:19 -0700 | [diff] [blame] | 524 | Return<bool> FooCallback::heyItsYouIsntIt(const sp<IFooCallback> &_cb) { |
Iliyan Malchev | 0acf419 | 2016-08-22 19:33:20 -0700 | [diff] [blame] | 525 | nsecs_t start = systemTime(); |
| 526 | ALOGI("SERVER(FooCallback) heyItsYouIsntIt cb = %p sleeping for %" PRId64 " seconds", _cb.get(), DELAY_S); |
| 527 | sleep(DELAY_S); |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 528 | ALOGI("SERVER(FooCallback) heyItsYouIsntIt cb = %p responding", _cb.get()); |
Iliyan Malchev | 0acf419 | 2016-08-22 19:33:20 -0700 | [diff] [blame] | 529 | mLock.lock(); |
| 530 | invokeInfo[1].invoked = true; |
| 531 | invokeInfo[1].timeNs = systemTime() - start; |
| 532 | mCond.signal(); |
| 533 | mLock.unlock(); |
Iliyan Malchev | d856b05 | 2016-08-16 22:25:27 -0700 | [diff] [blame] | 534 | return true; |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 535 | } |
| 536 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 537 | Return<void> FooCallback::heyItsTheMeaningOfLife(uint8_t tmol) { |
Iliyan Malchev | 0acf419 | 2016-08-22 19:33:20 -0700 | [diff] [blame] | 538 | nsecs_t start = systemTime(); |
| 539 | ALOGI("SERVER(FooCallback) heyItsTheMeaningOfLife = %d sleeping for %" PRId64 " seconds", tmol, DELAY_S); |
| 540 | sleep(DELAY_S); |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 541 | ALOGI("SERVER(FooCallback) heyItsTheMeaningOfLife = %d done sleeping", tmol); |
Iliyan Malchev | 0acf419 | 2016-08-22 19:33:20 -0700 | [diff] [blame] | 542 | mLock.lock(); |
| 543 | invokeInfo[2].invoked = true; |
| 544 | invokeInfo[2].timeNs = systemTime() - start; |
| 545 | mCond.signal(); |
| 546 | mLock.unlock(); |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 547 | return Void(); |
Iliyan Malchev | 0acf419 | 2016-08-22 19:33:20 -0700 | [diff] [blame] | 548 | } |
| 549 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 550 | Return<void> FooCallback::reportResults(int64_t ns, reportResults_cb cb) { |
Andreas Huber | 03866f5 | 2016-08-30 14:19:52 -0700 | [diff] [blame] | 551 | ALOGI("SERVER(FooCallback) reportResults(%" PRId64 " seconds)", nanoseconds_to_seconds(ns)); |
Iliyan Malchev | 0acf419 | 2016-08-22 19:33:20 -0700 | [diff] [blame] | 552 | nsecs_t leftToWaitNs = ns; |
| 553 | mLock.lock(); |
| 554 | while (!(invokeInfo[0].invoked && invokeInfo[1].invoked && invokeInfo[2].invoked) && |
| 555 | leftToWaitNs > 0) { |
| 556 | nsecs_t start = systemTime(); |
| 557 | ::android::status_t rc = mCond.waitRelative(mLock, leftToWaitNs); |
| 558 | if (rc != ::android::OK) { |
Andreas Huber | 03866f5 | 2016-08-30 14:19:52 -0700 | [diff] [blame] | 559 | ALOGI("SERVER(FooCallback)::reportResults(%" PRId64 " ns) Condition::waitRelative(%" PRId64 ") returned error (%d)", ns, leftToWaitNs, rc); |
Iliyan Malchev | 0acf419 | 2016-08-22 19:33:20 -0700 | [diff] [blame] | 560 | break; |
| 561 | } |
Andreas Huber | 03866f5 | 2016-08-30 14:19:52 -0700 | [diff] [blame] | 562 | ALOGI("SERVER(FooCallback)::reportResults(%" PRId64 " ns) Condition::waitRelative was signalled", ns); |
Iliyan Malchev | 0acf419 | 2016-08-22 19:33:20 -0700 | [diff] [blame] | 563 | leftToWaitNs -= systemTime() - start; |
| 564 | } |
| 565 | mLock.unlock(); |
| 566 | cb(leftToWaitNs, invokeInfo); |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 567 | return Void(); |
Iliyan Malchev | 0acf419 | 2016-08-22 19:33:20 -0700 | [diff] [blame] | 568 | } |
| 569 | |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 570 | Return<void> FooCallback::youBlockedMeFor(const hidl_array<int64_t, 3> &ns) { |
Iliyan Malchev | 0acf419 | 2016-08-22 19:33:20 -0700 | [diff] [blame] | 571 | for (size_t i = 0; i < 3; i++) { |
| 572 | invokeInfo[i].callerBlockedNs = ns[i]; |
| 573 | } |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 574 | return Void(); |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 575 | } |
| 576 | |
Steven Moreland | 4078631 | 2016-08-16 10:29:40 -0700 | [diff] [blame] | 577 | struct Bar : public IBar { |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 578 | Return<void> doThis(float param) override; |
Steven Moreland | 45fa6eb | 2016-10-18 18:32:55 +0000 | [diff] [blame] | 579 | Return<void> doThis(uint32_t param) override; |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 580 | |
Iliyan Malchev | 2b6591b | 2016-08-18 19:15:19 -0700 | [diff] [blame] | 581 | Return<int32_t> doThatAndReturnSomething(int64_t param) override; |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 582 | |
Iliyan Malchev | 2b6591b | 2016-08-18 19:15:19 -0700 | [diff] [blame] | 583 | Return<double> doQuiteABit( |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 584 | int32_t a, |
| 585 | int64_t b, |
| 586 | float c, |
Iliyan Malchev | d856b05 | 2016-08-16 22:25:27 -0700 | [diff] [blame] | 587 | double d) override; |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 588 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 589 | Return<void> doSomethingElse( |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 590 | const hidl_array<int32_t, 15> ¶m, |
| 591 | doSomethingElse_cb _cb) override; |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 592 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 593 | Return<void> doStuffAndReturnAString( |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 594 | doStuffAndReturnAString_cb _cb) override; |
| 595 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 596 | Return<void> mapThisVector( |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 597 | const hidl_vec<int32_t> ¶m, mapThisVector_cb _cb) override; |
| 598 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 599 | Return<void> callMe( |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 600 | const sp<IFooCallback> &cb) override; |
| 601 | |
Iliyan Malchev | 2b6591b | 2016-08-18 19:15:19 -0700 | [diff] [blame] | 602 | Return<SomeEnum> useAnEnum(SomeEnum param) override; |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 603 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 604 | Return<void> haveAGooberVec(const hidl_vec<Goober>& param) override; |
| 605 | Return<void> haveAGoober(const Goober &g) override; |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 606 | Return<void> haveAGooberArray(const hidl_array<Goober, 20> &lots) override; |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 607 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 608 | Return<void> haveATypeFromAnotherFile(const Abc &def) override; |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 609 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 610 | Return<void> haveSomeStrings( |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 611 | const hidl_array<hidl_string, 3> &array, |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 612 | haveSomeStrings_cb _cb) override; |
| 613 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 614 | Return<void> haveAStringVec( |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 615 | const hidl_vec<hidl_string> &vector, |
| 616 | haveAStringVec_cb _cb) override; |
Andreas Huber | 6cb08cf | 2016-08-03 15:44:51 -0700 | [diff] [blame] | 617 | |
Andreas Huber | f9d49f1 | 2016-09-12 14:58:36 -0700 | [diff] [blame] | 618 | Return<void> transposeMe( |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 619 | const hidl_array<float, 3, 5> &in, transposeMe_cb _cb) override; |
Andreas Huber | f9d49f1 | 2016-09-12 14:58:36 -0700 | [diff] [blame] | 620 | |
| 621 | Return<void> callingDrWho( |
| 622 | const MultiDimensional &in, |
| 623 | callingDrWho_cb _hidl_cb) override; |
| 624 | |
Andreas Huber | 709b62d | 2016-09-19 11:21:18 -0700 | [diff] [blame] | 625 | Return<void> transpose( |
| 626 | const StringMatrix5x3 &in, transpose_cb _hidl_cb) override; |
| 627 | |
| 628 | Return<void> transpose2( |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 629 | const hidl_array<hidl_string, 5, 3> &in, |
Andreas Huber | 709b62d | 2016-09-19 11:21:18 -0700 | [diff] [blame] | 630 | transpose2_cb _hidl_cb) override; |
| 631 | |
Andreas Huber | 5e44a29 | 2016-09-27 14:52:39 -0700 | [diff] [blame] | 632 | Return<void> sendVec( |
| 633 | const hidl_vec<uint8_t> &data, sendVec_cb _hidl_cb) override; |
| 634 | |
Yifan Hong | be2a373 | 2016-10-05 13:33:41 -0700 | [diff] [blame] | 635 | Return<void> sendVecVec(sendVecVec_cb _hidl_cb) override; |
| 636 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 637 | Return<void> thisIsNew() override; |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 638 | }; |
| 639 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 640 | Return<void> Bar::doThis(float param) { |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 641 | ALOGI("SERVER(Bar) doThis(%.2f)", param); |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 642 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 643 | return Void(); |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 644 | } |
| 645 | |
Steven Moreland | 45fa6eb | 2016-10-18 18:32:55 +0000 | [diff] [blame] | 646 | Return<void> Bar::doThis(uint32_t param) { |
| 647 | ALOGI("SERVER(Bar) doThis (int) (%d)", param); |
| 648 | return Void(); |
| 649 | } |
| 650 | |
Iliyan Malchev | 2b6591b | 2016-08-18 19:15:19 -0700 | [diff] [blame] | 651 | Return<int32_t> Bar::doThatAndReturnSomething( |
Iliyan Malchev | d856b05 | 2016-08-16 22:25:27 -0700 | [diff] [blame] | 652 | int64_t param) { |
Andreas Huber | e8047bf | 2016-10-03 16:09:15 -0700 | [diff] [blame] | 653 | LOG(INFO) << "SERVER(Bar) doThatAndReturnSomething(" << param << ")"; |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 654 | |
Iliyan Malchev | d856b05 | 2016-08-16 22:25:27 -0700 | [diff] [blame] | 655 | return 666; |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 656 | } |
| 657 | |
Iliyan Malchev | 2b6591b | 2016-08-18 19:15:19 -0700 | [diff] [blame] | 658 | Return<double> Bar::doQuiteABit( |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 659 | int32_t a, |
| 660 | int64_t b, |
| 661 | float c, |
Iliyan Malchev | d856b05 | 2016-08-16 22:25:27 -0700 | [diff] [blame] | 662 | double d) { |
Andreas Huber | e8047bf | 2016-10-03 16:09:15 -0700 | [diff] [blame] | 663 | LOG(INFO) << "SERVER(Bar) doQuiteABit(" |
| 664 | << a |
| 665 | << ", " |
| 666 | << b |
| 667 | << ", " |
| 668 | << c |
| 669 | << ", " |
| 670 | << d |
| 671 | << ")"; |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 672 | |
Iliyan Malchev | d856b05 | 2016-08-16 22:25:27 -0700 | [diff] [blame] | 673 | return 666.5; |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 674 | } |
| 675 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 676 | Return<void> Bar::doSomethingElse( |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 677 | const hidl_array<int32_t, 15> ¶m, doSomethingElse_cb _cb) { |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 678 | ALOGI("SERVER(Bar) doSomethingElse(...)"); |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 679 | |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 680 | hidl_array<int32_t, 32> result; |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 681 | for (size_t i = 0; i < 15; ++i) { |
| 682 | result[i] = 2 * param[i]; |
| 683 | result[15 + i] = param[i]; |
| 684 | } |
| 685 | result[30] = 1; |
| 686 | result[31] = 2; |
| 687 | |
| 688 | _cb(result); |
| 689 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 690 | return Void(); |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 691 | } |
| 692 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 693 | Return<void> Bar::doStuffAndReturnAString( |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 694 | doStuffAndReturnAString_cb _cb) { |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 695 | ALOGI("SERVER(Bar) doStuffAndReturnAString"); |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 696 | |
| 697 | hidl_string s; |
| 698 | s = "Hello, world"; |
| 699 | |
| 700 | _cb(s); |
| 701 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 702 | return Void(); |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 703 | } |
| 704 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 705 | Return<void> Bar::mapThisVector( |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 706 | const hidl_vec<int32_t> ¶m, mapThisVector_cb _cb) { |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 707 | ALOGI("SERVER(Bar) mapThisVector"); |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 708 | |
| 709 | hidl_vec<int32_t> out; |
Andreas Huber | 899b063 | 2016-08-15 12:21:19 -0700 | [diff] [blame] | 710 | out.resize(param.size()); |
Steven Moreland | 88ca451 | 2016-08-11 11:24:10 -0700 | [diff] [blame] | 711 | |
| 712 | for (size_t i = 0; i < out.size(); ++i) { |
| 713 | out[i] = param[i] * 2; |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 714 | } |
| 715 | |
| 716 | _cb(out); |
| 717 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 718 | return Void(); |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 719 | } |
| 720 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 721 | Return<void> Bar::callMe( |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 722 | const sp<IFooCallback> &cb) { |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 723 | ALOGI("SERVER(Bar) callMe %p", cb.get()); |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 724 | |
| 725 | if (cb != NULL) { |
Iliyan Malchev | 0acf419 | 2016-08-22 19:33:20 -0700 | [diff] [blame] | 726 | |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 727 | hidl_array<nsecs_t, 3> c; |
Iliyan Malchev | 0acf419 | 2016-08-22 19:33:20 -0700 | [diff] [blame] | 728 | ALOGI("SERVER(Bar) callMe %p calling IFooCallback::heyItsYou, " \ |
| 729 | "should return immediately", cb.get()); |
| 730 | c[0] = systemTime(); |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 731 | cb->heyItsYou(cb); |
Iliyan Malchev | 0acf419 | 2016-08-22 19:33:20 -0700 | [diff] [blame] | 732 | c[0] = systemTime() - c[0]; |
| 733 | ALOGI("SERVER(Bar) callMe %p calling IFooCallback::heyItsYou " \ |
| 734 | "returned after %" PRId64 "ns", cb.get(), c[0]); |
| 735 | |
| 736 | ALOGI("SERVER(Bar) callMe %p calling IFooCallback::heyItsYouIsntIt, " \ |
| 737 | "should block for %" PRId64 " seconds", cb.get(), |
| 738 | FooCallback::DELAY_S); |
| 739 | c[1] = systemTime(); |
Iliyan Malchev | d856b05 | 2016-08-16 22:25:27 -0700 | [diff] [blame] | 740 | bool answer = cb->heyItsYouIsntIt(cb); |
Iliyan Malchev | 0acf419 | 2016-08-22 19:33:20 -0700 | [diff] [blame] | 741 | c[1] = systemTime() - c[1]; |
| 742 | ALOGI("SERVER(Bar) callMe %p IFooCallback::heyItsYouIsntIt " \ |
| 743 | "responded with %d after %" PRId64 "ns", cb.get(), answer, c[1]); |
| 744 | |
| 745 | ALOGI("SERVER(Bar) callMe %p calling " \ |
| 746 | "IFooCallback::heyItsTheMeaningOfLife, " \ |
| 747 | "should return immediately ", cb.get()); |
| 748 | c[2] = systemTime(); |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 749 | cb->heyItsTheMeaningOfLife(42); |
Iliyan Malchev | 0acf419 | 2016-08-22 19:33:20 -0700 | [diff] [blame] | 750 | c[2] = systemTime() - c[2]; |
| 751 | ALOGI("SERVER(Bar) callMe %p After call to " \ |
| 752 | "IFooCallback::heyItsTheMeaningOfLife " \ |
| 753 | "responded after %" PRId64 "ns", cb.get(), c[2]); |
| 754 | |
| 755 | ALOGI("SERVER(Bar) callMe %p calling IFooCallback::youBlockedMeFor " \ |
| 756 | "to report times", cb.get()); |
| 757 | cb->youBlockedMeFor(c); |
| 758 | ALOGI("SERVER(Bar) callMe %p After call to " \ |
| 759 | "IFooCallback::heyYouBlockedMeFor", cb.get()); |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 760 | } |
| 761 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 762 | return Void(); |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 763 | } |
| 764 | |
Iliyan Malchev | 2b6591b | 2016-08-18 19:15:19 -0700 | [diff] [blame] | 765 | Return<Bar::SomeEnum> Bar::useAnEnum(SomeEnum param) { |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 766 | ALOGI("SERVER(Bar) useAnEnum %d", (int)param); |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 767 | |
Iliyan Malchev | d856b05 | 2016-08-16 22:25:27 -0700 | [diff] [blame] | 768 | return SomeEnum::goober; |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 769 | } |
| 770 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 771 | Return<void> Bar::haveAGooberVec(const hidl_vec<Goober>& param) { |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 772 | ALOGI("SERVER(Bar) haveAGooberVec ¶m = %p", ¶m); |
Andreas Huber | 6cb08cf | 2016-08-03 15:44:51 -0700 | [diff] [blame] | 773 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 774 | return Void(); |
Andreas Huber | 6cb08cf | 2016-08-03 15:44:51 -0700 | [diff] [blame] | 775 | } |
| 776 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 777 | Return<void> Bar::haveAGoober(const Goober &g) { |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 778 | ALOGI("SERVER(Bar) haveaGoober g=%p", &g); |
Andreas Huber | 6cb08cf | 2016-08-03 15:44:51 -0700 | [diff] [blame] | 779 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 780 | return Void(); |
Andreas Huber | 6cb08cf | 2016-08-03 15:44:51 -0700 | [diff] [blame] | 781 | } |
| 782 | |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 783 | Return<void> Bar::haveAGooberArray(const hidl_array<Goober, 20> & /* lots */) { |
| 784 | ALOGI("SERVER(Bar) haveAGooberArray"); |
Steven Moreland | 88ca451 | 2016-08-11 11:24:10 -0700 | [diff] [blame] | 785 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 786 | return Void(); |
Steven Moreland | 88ca451 | 2016-08-11 11:24:10 -0700 | [diff] [blame] | 787 | } |
| 788 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 789 | Return<void> Bar::haveATypeFromAnotherFile(const Abc &def) { |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 790 | ALOGI("SERVER(Bar) haveATypeFromAnotherFile def=%p", &def); |
Andreas Huber | 6cb08cf | 2016-08-03 15:44:51 -0700 | [diff] [blame] | 791 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 792 | return Void(); |
Andreas Huber | 6cb08cf | 2016-08-03 15:44:51 -0700 | [diff] [blame] | 793 | } |
| 794 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 795 | Return<void> Bar::haveSomeStrings( |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 796 | const hidl_array<hidl_string, 3> &array, |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 797 | haveSomeStrings_cb _cb) { |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 798 | ALOGI("SERVER(Bar) haveSomeStrings([\"%s\", \"%s\", \"%s\"])", |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 799 | array[0].c_str(), |
| 800 | array[1].c_str(), |
| 801 | array[2].c_str()); |
| 802 | |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 803 | hidl_array<hidl_string, 2> result; |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 804 | result[0] = "Hello"; |
| 805 | result[1] = "World"; |
| 806 | |
| 807 | _cb(result); |
| 808 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 809 | return Void(); |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 810 | } |
| 811 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 812 | Return<void> Bar::haveAStringVec( |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 813 | const hidl_vec<hidl_string> &vector, |
| 814 | haveAStringVec_cb _cb) { |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 815 | ALOGI("SERVER(Bar) haveAStringVec([\"%s\", \"%s\", \"%s\"])", |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 816 | vector[0].c_str(), |
| 817 | vector[1].c_str(), |
| 818 | vector[2].c_str()); |
| 819 | |
| 820 | hidl_vec<hidl_string> result; |
| 821 | result.resize(2); |
| 822 | |
| 823 | result[0] = "Hello"; |
| 824 | result[1] = "World"; |
| 825 | |
| 826 | _cb(result); |
| 827 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 828 | return Void(); |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 829 | } |
| 830 | |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 831 | using std::to_string; |
| 832 | |
| 833 | static std::string to_string(const IFoo::StringMatrix5x3 &M); |
| 834 | static std::string to_string(const IFoo::StringMatrix3x5 &M); |
| 835 | static std::string to_string(const hidl_string &s); |
| 836 | |
Andreas Huber | 5e44a29 | 2016-09-27 14:52:39 -0700 | [diff] [blame] | 837 | template<typename T> |
| 838 | static std::string to_string(const T *elems, size_t n) { |
| 839 | std::string out; |
| 840 | out = "["; |
| 841 | for (size_t i = 0; i < n; ++i) { |
| 842 | if (i > 0) { |
| 843 | out += ", "; |
| 844 | } |
| 845 | out += to_string(elems[i]); |
| 846 | } |
| 847 | out += "]"; |
| 848 | |
| 849 | return out; |
| 850 | } |
| 851 | |
| 852 | template<typename T, size_t SIZE> |
| 853 | static std::string to_string(const hidl_array<T, SIZE> &array) { |
| 854 | return to_string(&array[0], SIZE); |
| 855 | } |
| 856 | |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 857 | template<typename T, size_t SIZE1, size_t SIZE2> |
| 858 | static std::string to_string(const hidl_array<T, SIZE1, SIZE2> &array) { |
| 859 | std::string out; |
| 860 | out = "["; |
| 861 | for (size_t i = 0; i < SIZE1; ++i) { |
Andreas Huber | f9d49f1 | 2016-09-12 14:58:36 -0700 | [diff] [blame] | 862 | if (i > 0) { |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 863 | out += ", "; |
Andreas Huber | f9d49f1 | 2016-09-12 14:58:36 -0700 | [diff] [blame] | 864 | } |
| 865 | |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 866 | out += "["; |
| 867 | for (size_t j = 0; j < SIZE2; ++j) { |
Andreas Huber | f9d49f1 | 2016-09-12 14:58:36 -0700 | [diff] [blame] | 868 | if (j > 0) { |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 869 | out += ", "; |
Andreas Huber | f9d49f1 | 2016-09-12 14:58:36 -0700 | [diff] [blame] | 870 | } |
Andreas Huber | f9d49f1 | 2016-09-12 14:58:36 -0700 | [diff] [blame] | 871 | |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 872 | out += to_string(array[i][j]); |
| 873 | } |
| 874 | out += "]"; |
| 875 | } |
| 876 | out += "]"; |
| 877 | |
| 878 | return out; |
| 879 | } |
| 880 | |
Andreas Huber | 5e44a29 | 2016-09-27 14:52:39 -0700 | [diff] [blame] | 881 | template<typename T> |
| 882 | static std::string to_string(const hidl_vec<T> &vec) { |
| 883 | return to_string(&vec[0], vec.size()); |
| 884 | } |
| 885 | |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 886 | static std::string to_string(const IFoo::StringMatrix5x3 &M) { |
| 887 | return to_string(M.s); |
| 888 | } |
| 889 | |
| 890 | static std::string to_string(const IFoo::StringMatrix3x5 &M) { |
| 891 | return to_string(M.s); |
| 892 | } |
| 893 | |
| 894 | static std::string to_string(const hidl_string &s) { |
| 895 | return std::string("'") + s.c_str() + "'"; |
Andreas Huber | f9d49f1 | 2016-09-12 14:58:36 -0700 | [diff] [blame] | 896 | } |
| 897 | |
| 898 | Return<void> Bar::transposeMe( |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 899 | const hidl_array<float, 3, 5> &in, transposeMe_cb _cb) { |
| 900 | ALOGI("SERVER(Bar) transposeMe(%s)", to_string(in).c_str()); |
Andreas Huber | f9d49f1 | 2016-09-12 14:58:36 -0700 | [diff] [blame] | 901 | |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 902 | hidl_array<float, 5, 3> out; |
Andreas Huber | f9d49f1 | 2016-09-12 14:58:36 -0700 | [diff] [blame] | 903 | for (size_t i = 0; i < 5; ++i) { |
| 904 | for (size_t j = 0; j < 3; ++j) { |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 905 | out[i][j] = in[j][i]; |
Andreas Huber | f9d49f1 | 2016-09-12 14:58:36 -0700 | [diff] [blame] | 906 | } |
| 907 | } |
| 908 | |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 909 | ALOGI("SERVER(Bar) transposeMe returning %s", to_string(out).c_str()); |
| 910 | |
| 911 | _cb(out); |
Andreas Huber | f9d49f1 | 2016-09-12 14:58:36 -0700 | [diff] [blame] | 912 | |
| 913 | return Void(); |
| 914 | } |
| 915 | |
| 916 | static std::string QuuxToString(const IFoo::Quux &val) { |
| 917 | std::string s; |
| 918 | |
| 919 | s = "Quux(first='"; |
| 920 | s += val.first.c_str(); |
| 921 | s += "', last='"; |
| 922 | s += val.last.c_str(); |
| 923 | s += "')"; |
| 924 | |
| 925 | return s; |
| 926 | } |
| 927 | |
| 928 | static std::string MultiDimensionalToString(const IFoo::MultiDimensional &val) { |
| 929 | std::string s; |
| 930 | |
| 931 | s += "MultiDimensional("; |
| 932 | |
| 933 | s += "quuxMatrix=["; |
Andreas Huber | 709b62d | 2016-09-19 11:21:18 -0700 | [diff] [blame] | 934 | |
| 935 | size_t k = 0; |
Andreas Huber | f9d49f1 | 2016-09-12 14:58:36 -0700 | [diff] [blame] | 936 | for (size_t i = 0; i < 5; ++i) { |
| 937 | if (i > 0) { |
| 938 | s += ", "; |
| 939 | } |
| 940 | |
| 941 | s += "["; |
Andreas Huber | 709b62d | 2016-09-19 11:21:18 -0700 | [diff] [blame] | 942 | for (size_t j = 0; j < 3; ++j, ++k) { |
Andreas Huber | f9d49f1 | 2016-09-12 14:58:36 -0700 | [diff] [blame] | 943 | if (j > 0) { |
| 944 | s += ", "; |
| 945 | } |
| 946 | |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 947 | s += QuuxToString(val.quuxMatrix[i][j]); |
Andreas Huber | f9d49f1 | 2016-09-12 14:58:36 -0700 | [diff] [blame] | 948 | } |
| 949 | } |
| 950 | s += "]"; |
| 951 | |
| 952 | s += ")"; |
| 953 | |
| 954 | return s; |
| 955 | } |
| 956 | |
| 957 | Return<void> Bar::callingDrWho( |
| 958 | const MultiDimensional &in, callingDrWho_cb _hidl_cb) { |
| 959 | ALOGI("SERVER(Bar) callingDrWho(%s)", MultiDimensionalToString(in).c_str()); |
| 960 | |
| 961 | MultiDimensional out; |
| 962 | for (size_t i = 0; i < 5; ++i) { |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 963 | for (size_t j = 0; j < 3; ++j) { |
| 964 | out.quuxMatrix[i][j].first = in.quuxMatrix[4 - i][2 - j].last; |
| 965 | out.quuxMatrix[i][j].last = in.quuxMatrix[4 - i][2 - j].first; |
Andreas Huber | f9d49f1 | 2016-09-12 14:58:36 -0700 | [diff] [blame] | 966 | } |
| 967 | } |
| 968 | |
| 969 | _hidl_cb(out); |
| 970 | |
| 971 | return Void(); |
| 972 | } |
| 973 | |
Andreas Huber | 709b62d | 2016-09-19 11:21:18 -0700 | [diff] [blame] | 974 | Return<void> Bar::transpose(const StringMatrix5x3 &in, transpose_cb _hidl_cb) { |
| 975 | LOG(INFO) << "SERVER(Bar) transpose " << to_string(in); |
| 976 | |
| 977 | StringMatrix3x5 out; |
Andreas Huber | 709b62d | 2016-09-19 11:21:18 -0700 | [diff] [blame] | 978 | for (size_t i = 0; i < 3; ++i) { |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 979 | for (size_t j = 0; j < 5; ++j) { |
| 980 | out.s[i][j] = in.s[j][i]; |
Andreas Huber | 709b62d | 2016-09-19 11:21:18 -0700 | [diff] [blame] | 981 | } |
| 982 | } |
| 983 | |
| 984 | _hidl_cb(out); |
| 985 | |
| 986 | return Void(); |
| 987 | } |
| 988 | |
| 989 | Return<void> Bar::transpose2( |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 990 | const hidl_array<hidl_string, 5, 3> &in, transpose2_cb _hidl_cb) { |
| 991 | LOG(INFO) << "SERVER(Bar) transpose2 " << to_string(in); |
Andreas Huber | 709b62d | 2016-09-19 11:21:18 -0700 | [diff] [blame] | 992 | |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 993 | hidl_array<hidl_string, 3, 5> out; |
Andreas Huber | 709b62d | 2016-09-19 11:21:18 -0700 | [diff] [blame] | 994 | for (size_t i = 0; i < 3; ++i) { |
| 995 | for (size_t j = 0; j < 5; ++j) { |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 996 | out[i][j] = in[j][i]; |
Andreas Huber | 709b62d | 2016-09-19 11:21:18 -0700 | [diff] [blame] | 997 | } |
| 998 | } |
| 999 | |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 1000 | _hidl_cb(out); |
Andreas Huber | 709b62d | 2016-09-19 11:21:18 -0700 | [diff] [blame] | 1001 | |
| 1002 | return Void(); |
| 1003 | } |
| 1004 | |
Andreas Huber | 5e44a29 | 2016-09-27 14:52:39 -0700 | [diff] [blame] | 1005 | Return<void> Bar::sendVec( |
| 1006 | const hidl_vec<uint8_t> &data, sendVec_cb _hidl_cb) { |
| 1007 | _hidl_cb(data); |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 1008 | |
Iliyan Malchev | d57066f | 2016-09-08 13:59:38 -0700 | [diff] [blame] | 1009 | return Void(); |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 1010 | } |
| 1011 | |
Yifan Hong | be2a373 | 2016-10-05 13:33:41 -0700 | [diff] [blame] | 1012 | Return<void> Bar::sendVecVec(sendVecVec_cb _hidl_cb) { |
| 1013 | hidl_vec<hidl_vec<uint8_t>> data; |
| 1014 | _hidl_cb(data); |
| 1015 | |
| 1016 | return Void(); |
| 1017 | } |
| 1018 | |
Andreas Huber | 5e44a29 | 2016-09-27 14:52:39 -0700 | [diff] [blame] | 1019 | Return<void> Bar::thisIsNew() { |
| 1020 | ALOGI("SERVER(Bar) thisIsNew"); |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 1021 | |
Andreas Huber | 5e44a29 | 2016-09-27 14:52:39 -0700 | [diff] [blame] | 1022 | return Void(); |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 1023 | } |
| 1024 | |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1025 | template <class T> |
Martijn Coenen | a21f149 | 2016-09-08 15:55:14 +0200 | [diff] [blame] | 1026 | static void startServer(T server, |
Yifan Hong | 3eac8a3 | 2016-10-11 10:02:59 -0700 | [diff] [blame^] | 1027 | const std::string &serviceName, |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1028 | const char *tag) { |
Andreas Huber | 8a82ff7 | 2016-08-04 10:29:39 -0700 | [diff] [blame] | 1029 | using namespace android::hardware; |
Yifan Hong | 3eac8a3 | 2016-10-11 10:02:59 -0700 | [diff] [blame^] | 1030 | ALOGI("SERVER(%s) registering %s", tag, serviceName.c_str()); |
Martijn Coenen | a21f149 | 2016-09-08 15:55:14 +0200 | [diff] [blame] | 1031 | server->registerAsService(serviceName); |
Yifan Hong | 3eac8a3 | 2016-10-11 10:02:59 -0700 | [diff] [blame^] | 1032 | ALOGI("SERVER(%s) starting %s", tag, serviceName.c_str()); |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1033 | ProcessState::self()->setThreadPoolMaxThreadCount(0); |
| 1034 | ProcessState::self()->startThreadPool(); |
| 1035 | IPCThreadState::self()->joinThreadPool(); // never ends. needs kill(). |
Yifan Hong | 3eac8a3 | 2016-10-11 10:02:59 -0700 | [diff] [blame^] | 1036 | ALOGI("SERVER(%s) %s ends.", tag, serviceName.c_str()); |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1037 | } |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 1038 | |
Yifan Hong | bf459bc | 2016-08-23 16:50:37 -0700 | [diff] [blame] | 1039 | static void killServer(pid_t pid, const char *serverName) { |
| 1040 | if(kill(pid, SIGTERM)) { |
| 1041 | ALOGE("Could not kill %s; errno = %d", serverName, errno); |
| 1042 | } else { |
| 1043 | int status; |
| 1044 | ALOGI("Waiting for %s to exit...", serverName); |
| 1045 | waitpid(pid, &status, 0); |
| 1046 | ALOGI("Continuing..."); |
| 1047 | } |
| 1048 | } |
| 1049 | |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 1050 | |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1051 | class HidlTest : public ::testing::Test { |
| 1052 | public: |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1053 | sp<IFoo> foo; |
| 1054 | sp<IBar> bar; |
Iliyan Malchev | 0acf419 | 2016-08-22 19:33:20 -0700 | [diff] [blame] | 1055 | sp<IFooCallback> fooCb; |
Yifan Hong | bf459bc | 2016-08-23 16:50:37 -0700 | [diff] [blame] | 1056 | sp<IGraph> graphInterface; |
| 1057 | sp<IPointer> pointerInterface; |
| 1058 | PointerInterface validationPointerInterface; |
| 1059 | |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1060 | virtual void SetUp() override { |
| 1061 | ALOGI("Test setup beginning..."); |
Martijn Coenen | a21f149 | 2016-09-08 15:55:14 +0200 | [diff] [blame] | 1062 | foo = IFoo::getService("foo"); |
Yifan Hong | 7a82772 | 2016-10-06 17:20:12 -0700 | [diff] [blame] | 1063 | ASSERT_NE(foo, nullptr); |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1064 | |
Martijn Coenen | a21f149 | 2016-09-08 15:55:14 +0200 | [diff] [blame] | 1065 | bar = IBar::getService("foo"); |
Yifan Hong | 7a82772 | 2016-10-06 17:20:12 -0700 | [diff] [blame] | 1066 | ASSERT_NE(bar, nullptr); |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1067 | |
Martijn Coenen | a21f149 | 2016-09-08 15:55:14 +0200 | [diff] [blame] | 1068 | fooCb = IFooCallback::getService("foo callback"); |
Yifan Hong | 7a82772 | 2016-10-06 17:20:12 -0700 | [diff] [blame] | 1069 | ASSERT_NE(fooCb, nullptr); |
Iliyan Malchev | 0acf419 | 2016-08-22 19:33:20 -0700 | [diff] [blame] | 1070 | |
Yifan Hong | bf459bc | 2016-08-23 16:50:37 -0700 | [diff] [blame] | 1071 | graphInterface = IGraph::getService("graph"); |
Yifan Hong | 7a82772 | 2016-10-06 17:20:12 -0700 | [diff] [blame] | 1072 | ASSERT_NE(graphInterface, nullptr); |
Yifan Hong | bf459bc | 2016-08-23 16:50:37 -0700 | [diff] [blame] | 1073 | |
| 1074 | pointerInterface = IPointer::getService("pointer"); |
Yifan Hong | 3eac8a3 | 2016-10-11 10:02:59 -0700 | [diff] [blame^] | 1075 | ASSERT_NE(pointerInterface, nullptr); |
Yifan Hong | bf459bc | 2016-08-23 16:50:37 -0700 | [diff] [blame] | 1076 | |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1077 | ALOGI("Test setup complete"); |
| 1078 | } |
| 1079 | virtual void TearDown() override { |
| 1080 | } |
| 1081 | }; |
| 1082 | |
| 1083 | class HidlEnvironment : public ::testing::Environment { |
| 1084 | private: |
Yifan Hong | bf459bc | 2016-08-23 16:50:37 -0700 | [diff] [blame] | 1085 | pid_t fooCallbackServerPid, barServerPid, graphServerPid, pointerServerPid; |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1086 | public: |
| 1087 | virtual void SetUp() { |
| 1088 | ALOGI("Environment setup beginning..."); |
| 1089 | // use fork to create and kill to destroy server processes. |
| 1090 | if ((barServerPid = fork()) == 0) { |
| 1091 | // Fear me, I am a child. |
Martijn Coenen | a21f149 | 2016-09-08 15:55:14 +0200 | [diff] [blame] | 1092 | startServer(new Bar, "foo", "Bar"); // never returns |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1093 | return; |
| 1094 | } |
| 1095 | |
| 1096 | if ((fooCallbackServerPid = fork()) == 0) { |
| 1097 | // Fear me, I am a second child. |
Martijn Coenen | a21f149 | 2016-09-08 15:55:14 +0200 | [diff] [blame] | 1098 | startServer(new FooCallback, "foo callback", "FooCalback"); // never returns |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1099 | return; |
| 1100 | } |
| 1101 | |
Yifan Hong | bf459bc | 2016-08-23 16:50:37 -0700 | [diff] [blame] | 1102 | if ((graphServerPid = fork()) == 0) { |
| 1103 | // Fear me, I am a third child. |
| 1104 | startServer(new GraphInterface, "graph", "Graph"); // never returns |
| 1105 | return; |
| 1106 | } |
| 1107 | |
| 1108 | if ((pointerServerPid = fork()) == 0) { |
| 1109 | // Fear me, I am a forth child. |
| 1110 | startServer(new PointerInterface, "pointer", "Pointer"); // never returns |
| 1111 | return; |
| 1112 | } |
| 1113 | |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1114 | // Fear you not, I am parent. |
| 1115 | sleep(1); |
| 1116 | ALOGI("Environment setup complete."); |
| 1117 | } |
| 1118 | |
| 1119 | virtual void TearDown() { |
| 1120 | // clean up by killing server processes. |
| 1121 | ALOGI("Environment tear-down beginning..."); |
| 1122 | ALOGI("Killing servers..."); |
Yifan Hong | bf459bc | 2016-08-23 16:50:37 -0700 | [diff] [blame] | 1123 | killServer(barServerPid, "barServer"); |
| 1124 | killServer(fooCallbackServerPid, "fooCallbackServer"); |
| 1125 | killServer(graphServerPid, "graphServer"); |
| 1126 | killServer(pointerServerPid, "pointerServer"); |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1127 | ALOGI("Servers all killed."); |
| 1128 | ALOGI("Environment tear-down complete."); |
| 1129 | } |
| 1130 | }; |
| 1131 | |
| 1132 | TEST_F(HidlTest, FooDoThisTest) { |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 1133 | ALOGI("CLIENT call doThis."); |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1134 | EXPECT_OK(foo->doThis(1.0f)); |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 1135 | ALOGI("CLIENT doThis returned."); |
Iliyan Malchev | 0acf419 | 2016-08-22 19:33:20 -0700 | [diff] [blame] | 1136 | EXPECT_EQ(true, true); |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1137 | } |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 1138 | |
Steven Moreland | 45fa6eb | 2016-10-18 18:32:55 +0000 | [diff] [blame] | 1139 | TEST_F(HidlTest, FooDoThisIntTest) { |
| 1140 | ALOGI("CLIENT call doThis (int)."); |
| 1141 | EXPECT_OK(foo->doThis(42u)); |
| 1142 | ALOGI("CLIENT doThis (int) returned."); |
| 1143 | EXPECT_EQ(true, true); |
| 1144 | } |
| 1145 | |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1146 | TEST_F(HidlTest, FooDoThatAndReturnSomethingTest) { |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 1147 | ALOGI("CLIENT call doThatAndReturnSomething."); |
Iliyan Malchev | d856b05 | 2016-08-16 22:25:27 -0700 | [diff] [blame] | 1148 | int32_t result = foo->doThatAndReturnSomething(2.0f); |
| 1149 | ALOGI("CLIENT doThatAndReturnSomething returned %d.", result); |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1150 | EXPECT_EQ(result, 666); |
| 1151 | } |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 1152 | |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1153 | TEST_F(HidlTest, FooDoQuiteABitTest) { |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 1154 | ALOGI("CLIENT call doQuiteABit"); |
Iliyan Malchev | d856b05 | 2016-08-16 22:25:27 -0700 | [diff] [blame] | 1155 | double something = foo->doQuiteABit(1, 2, 3.0f, 4.0); |
| 1156 | ALOGI("CLIENT doQuiteABit returned %f.", something); |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1157 | EXPECT_DOUBLE_EQ(something, 666.5); |
| 1158 | } |
| 1159 | |
| 1160 | TEST_F(HidlTest, FooDoSomethingElseTest) { |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 1161 | |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 1162 | ALOGI("CLIENT call doSomethingElse"); |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 1163 | hidl_array<int32_t, 15> param; |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 1164 | for (size_t i = 0; i < sizeof(param) / sizeof(param[0]); ++i) { |
| 1165 | param[i] = i; |
| 1166 | } |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1167 | EXPECT_OK(foo->doSomethingElse(param, [&](const auto &something) { |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 1168 | ALOGI("CLIENT doSomethingElse returned %s.", |
Andreas Huber | 5e44a29 | 2016-09-27 14:52:39 -0700 | [diff] [blame] | 1169 | to_string(something).c_str()); |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1170 | int32_t expect[] = {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, |
| 1171 | 26, 28, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 1, 2}; |
Steven Moreland | e70455b | 2016-09-14 15:46:36 -0700 | [diff] [blame] | 1172 | EXPECT_TRUE(isArrayEqual(something, expect, 32)); |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1173 | })); |
| 1174 | } |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 1175 | |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1176 | TEST_F(HidlTest, FooDoStuffAndReturnAStringTest) { |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 1177 | ALOGI("CLIENT call doStuffAndReturnAString"); |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1178 | EXPECT_OK(foo->doStuffAndReturnAString([&](const auto &something) { |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 1179 | ALOGI("CLIENT doStuffAndReturnAString returned '%s'.", |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 1180 | something.c_str()); |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1181 | EXPECT_STREQ(something.c_str(), "Hello, world"); |
| 1182 | })); |
| 1183 | } |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 1184 | |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1185 | TEST_F(HidlTest, FooMapThisVectorTest) { |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 1186 | hidl_vec<int32_t> vecParam; |
| 1187 | vecParam.resize(10); |
| 1188 | for (size_t i = 0; i < 10; ++i) { |
| 1189 | vecParam[i] = i; |
| 1190 | } |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1191 | EXPECT_OK(foo->mapThisVector(vecParam, [&](const auto &something) { |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 1192 | ALOGI("CLIENT mapThisVector returned %s.", |
Andreas Huber | 5e44a29 | 2016-09-27 14:52:39 -0700 | [diff] [blame] | 1193 | to_string(something).c_str()); |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1194 | int32_t expect[] = {0, 2, 4, 6, 8, 10, 12, 14, 16, 18}; |
Steven Moreland | e70455b | 2016-09-14 15:46:36 -0700 | [diff] [blame] | 1195 | EXPECT_TRUE(isArrayEqual(something, expect, something.size())); |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1196 | })); |
| 1197 | } |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 1198 | |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1199 | TEST_F(HidlTest, FooCallMeTest) { |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 1200 | ALOGI("CLIENT call callMe."); |
Iliyan Malchev | 0acf419 | 2016-08-22 19:33:20 -0700 | [diff] [blame] | 1201 | // callMe is oneway, should return instantly. |
| 1202 | nsecs_t now; |
| 1203 | now = systemTime(); |
| 1204 | EXPECT_OK(foo->callMe(fooCb)); |
Yifan Hong | 3eac8a3 | 2016-10-11 10:02:59 -0700 | [diff] [blame^] | 1205 | EXPECT_LT(systemTime() - now, ONEWAY_TOLERANCE_NS); |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 1206 | ALOGI("CLIENT callMe returned."); |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1207 | } |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 1208 | |
Iliyan Malchev | 0acf419 | 2016-08-22 19:33:20 -0700 | [diff] [blame] | 1209 | TEST_F(HidlTest, ForReportResultsTest) { |
| 1210 | |
| 1211 | // Bar::callMe will invoke three methods on FooCallback; one will return |
| 1212 | // right away (even though it is a two-way method); the second one will |
Yifan Hong | 3eac8a3 | 2016-10-11 10:02:59 -0700 | [diff] [blame^] | 1213 | // block Bar for DELAY_S seconds, and the third one will return |
Iliyan Malchev | 0acf419 | 2016-08-22 19:33:20 -0700 | [diff] [blame] | 1214 | // to Bar right away (is oneway) but will itself block for DELAY_S seconds. |
| 1215 | // We need a way to make sure that these three things have happened within |
| 1216 | // 2*DELAY_S seconds plus some small tolerance. |
| 1217 | // |
| 1218 | // Method FooCallback::reportResults() takes a timeout parameter. It blocks for |
| 1219 | // that length of time, while waiting for the three methods above to |
| 1220 | // complete. It returns the information of whether each method was invoked, |
| 1221 | // as well as how long the body of the method took to execute. We verify |
| 1222 | // the information returned by reportResults() against the timeout we pass (which |
| 1223 | // is long enough for the method bodies to execute, plus tolerance), and |
| 1224 | // verify that eachof them executed, as expected, and took the length of |
| 1225 | // time to execute that we also expect. |
| 1226 | |
| 1227 | const nsecs_t reportResultsNs = |
Yifan Hong | 3eac8a3 | 2016-10-11 10:02:59 -0700 | [diff] [blame^] | 1228 | 2 * DELAY_NS + TOLERANCE_NS; |
Andreas Huber | 03866f5 | 2016-08-30 14:19:52 -0700 | [diff] [blame] | 1229 | |
Iliyan Malchev | 0acf419 | 2016-08-22 19:33:20 -0700 | [diff] [blame] | 1230 | ALOGI("CLIENT: Waiting for up to %" PRId64 " seconds.", |
| 1231 | nanoseconds_to_seconds(reportResultsNs)); |
| 1232 | |
| 1233 | fooCb->reportResults(reportResultsNs, |
| 1234 | [&](int64_t timeLeftNs, |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 1235 | const hidl_array<IFooCallback::InvokeInfo, 3> &invokeResults) { |
Iliyan Malchev | 0acf419 | 2016-08-22 19:33:20 -0700 | [diff] [blame] | 1236 | ALOGI("CLIENT: FooCallback::reportResults() is returning data."); |
| 1237 | ALOGI("CLIENT: Waited for %" PRId64 " milliseconds.", |
| 1238 | nanoseconds_to_milliseconds(reportResultsNs - timeLeftNs)); |
| 1239 | |
Yifan Hong | 3eac8a3 | 2016-10-11 10:02:59 -0700 | [diff] [blame^] | 1240 | EXPECT_LE(0, timeLeftNs); |
| 1241 | EXPECT_LE(timeLeftNs, reportResultsNs); |
Iliyan Malchev | 0acf419 | 2016-08-22 19:33:20 -0700 | [diff] [blame] | 1242 | |
| 1243 | // two-way method, was supposed to return right away |
| 1244 | EXPECT_TRUE(invokeResults[0].invoked); |
Yifan Hong | 3eac8a3 | 2016-10-11 10:02:59 -0700 | [diff] [blame^] | 1245 | EXPECT_LE(invokeResults[0].timeNs, invokeResults[0].callerBlockedNs); |
| 1246 | EXPECT_LE(invokeResults[0].callerBlockedNs, TOLERANCE_NS); |
Iliyan Malchev | 0acf419 | 2016-08-22 19:33:20 -0700 | [diff] [blame] | 1247 | // two-way method, was supposed to block caller for DELAY_NS |
| 1248 | EXPECT_TRUE(invokeResults[1].invoked); |
Yifan Hong | 3eac8a3 | 2016-10-11 10:02:59 -0700 | [diff] [blame^] | 1249 | EXPECT_LE(invokeResults[1].timeNs, invokeResults[1].callerBlockedNs); |
| 1250 | EXPECT_LE(invokeResults[1].callerBlockedNs, |
| 1251 | DELAY_NS + TOLERANCE_NS); |
Iliyan Malchev | 0acf419 | 2016-08-22 19:33:20 -0700 | [diff] [blame] | 1252 | // one-way method, do not block caller, but body was supposed to block for DELAY_NS |
| 1253 | EXPECT_TRUE(invokeResults[2].invoked); |
Yifan Hong | 3eac8a3 | 2016-10-11 10:02:59 -0700 | [diff] [blame^] | 1254 | EXPECT_LE(invokeResults[2].callerBlockedNs, ONEWAY_TOLERANCE_NS); |
| 1255 | EXPECT_LE(invokeResults[2].timeNs, DELAY_NS + TOLERANCE_NS); |
Iliyan Malchev | 0acf419 | 2016-08-22 19:33:20 -0700 | [diff] [blame] | 1256 | }); |
| 1257 | } |
| 1258 | |
| 1259 | |
| 1260 | |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1261 | TEST_F(HidlTest, FooUseAnEnumTest) { |
| 1262 | ALOGI("CLIENT call useAnEnum."); |
Iliyan Malchev | d856b05 | 2016-08-16 22:25:27 -0700 | [diff] [blame] | 1263 | IFoo::SomeEnum sleepy = foo->useAnEnum(IFoo::SomeEnum::quux); |
| 1264 | ALOGI("CLIENT useAnEnum returned %u", (unsigned)sleepy); |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1265 | EXPECT_EQ(sleepy, IFoo::SomeEnum::goober); |
| 1266 | } |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 1267 | |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1268 | TEST_F(HidlTest, FooHaveAGooberTest) { |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 1269 | hidl_vec<IFoo::Goober> gooberVecParam; |
| 1270 | gooberVecParam.resize(2); |
| 1271 | gooberVecParam[0].name = "Hello"; |
| 1272 | gooberVecParam[1].name = "World"; |
| 1273 | |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 1274 | ALOGI("CLIENT call haveAGooberVec."); |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1275 | EXPECT_OK(foo->haveAGooberVec(gooberVecParam)); |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 1276 | ALOGI("CLIENT haveAGooberVec returned."); |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 1277 | |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 1278 | ALOGI("CLIENT call haveaGoober."); |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1279 | EXPECT_OK(foo->haveAGoober(gooberVecParam[0])); |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 1280 | ALOGI("CLIENT haveaGoober returned."); |
| 1281 | |
| 1282 | ALOGI("CLIENT call haveAGooberArray."); |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 1283 | hidl_array<IFoo::Goober, 20> gooberArrayParam; |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1284 | EXPECT_OK(foo->haveAGooberArray(gooberArrayParam)); |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 1285 | ALOGI("CLIENT haveAGooberArray returned."); |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1286 | } |
Steven Moreland | 88ca451 | 2016-08-11 11:24:10 -0700 | [diff] [blame] | 1287 | |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1288 | TEST_F(HidlTest, FooHaveATypeFromAnotherFileTest) { |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 1289 | ALOGI("CLIENT call haveATypeFromAnotherFile."); |
Steven Moreland | 88ca451 | 2016-08-11 11:24:10 -0700 | [diff] [blame] | 1290 | Abc abcParam{}; |
| 1291 | abcParam.x = "alphabet"; |
| 1292 | abcParam.y = 3.14f; |
| 1293 | abcParam.z = new native_handle_t(); |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1294 | EXPECT_OK(foo->haveATypeFromAnotherFile(abcParam)); |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 1295 | ALOGI("CLIENT haveATypeFromAnotherFile returned."); |
Steven Moreland | 88ca451 | 2016-08-11 11:24:10 -0700 | [diff] [blame] | 1296 | delete abcParam.z; |
| 1297 | abcParam.z = NULL; |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1298 | } |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 1299 | |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1300 | TEST_F(HidlTest, FooHaveSomeStringsTest) { |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 1301 | ALOGI("CLIENT call haveSomeStrings."); |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 1302 | hidl_array<hidl_string, 3> stringArrayParam; |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 1303 | stringArrayParam[0] = "What"; |
| 1304 | stringArrayParam[1] = "a"; |
| 1305 | stringArrayParam[2] = "disaster"; |
Steven Moreland | 67f67b4 | 2016-09-29 08:59:02 -0700 | [diff] [blame] | 1306 | EXPECT_OK(foo->haveSomeStrings( |
| 1307 | stringArrayParam, |
| 1308 | [&](const auto &out) { |
| 1309 | ALOGI("CLIENT haveSomeStrings returned %s.", |
| 1310 | to_string(out).c_str()); |
| 1311 | |
| 1312 | EXPECT_EQ(to_string(out), "['Hello', 'World']"); |
| 1313 | })); |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 1314 | ALOGI("CLIENT haveSomeStrings returned."); |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1315 | } |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 1316 | |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1317 | TEST_F(HidlTest, FooHaveAStringVecTest) { |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 1318 | ALOGI("CLIENT call haveAStringVec."); |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 1319 | hidl_vec<hidl_string> stringVecParam; |
| 1320 | stringVecParam.resize(3); |
| 1321 | stringVecParam[0] = "What"; |
| 1322 | stringVecParam[1] = "a"; |
| 1323 | stringVecParam[2] = "disaster"; |
Steven Moreland | 67f67b4 | 2016-09-29 08:59:02 -0700 | [diff] [blame] | 1324 | EXPECT_OK(foo->haveAStringVec( |
| 1325 | stringVecParam, |
| 1326 | [&](const auto &out) { |
| 1327 | ALOGI("CLIENT haveAStringVec returned %s.", |
| 1328 | to_string(out).c_str()); |
| 1329 | |
| 1330 | EXPECT_EQ(to_string(out), "['Hello', 'World']"); |
| 1331 | })); |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 1332 | ALOGI("CLIENT haveAStringVec returned."); |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1333 | } |
Andreas Huber | 6cb08cf | 2016-08-03 15:44:51 -0700 | [diff] [blame] | 1334 | |
Andreas Huber | f9d49f1 | 2016-09-12 14:58:36 -0700 | [diff] [blame] | 1335 | TEST_F(HidlTest, FooTransposeMeTest) { |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 1336 | hidl_array<float, 3, 5> in; |
Andreas Huber | f9d49f1 | 2016-09-12 14:58:36 -0700 | [diff] [blame] | 1337 | float k = 1.0f; |
| 1338 | for (size_t i = 0; i < 3; ++i) { |
| 1339 | for (size_t j = 0; j < 5; ++j, ++k) { |
| 1340 | in[i][j] = k; |
| 1341 | } |
| 1342 | } |
| 1343 | |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 1344 | ALOGI("CLIENT call transposeMe(%s).", to_string(in).c_str()); |
Andreas Huber | f9d49f1 | 2016-09-12 14:58:36 -0700 | [diff] [blame] | 1345 | |
| 1346 | EXPECT_OK(foo->transposeMe( |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 1347 | in, |
Andreas Huber | f9d49f1 | 2016-09-12 14:58:36 -0700 | [diff] [blame] | 1348 | [&](const auto &out) { |
| 1349 | ALOGI("CLIENT transposeMe returned %s.", |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 1350 | to_string(out).c_str()); |
Andreas Huber | f9d49f1 | 2016-09-12 14:58:36 -0700 | [diff] [blame] | 1351 | |
| 1352 | for (size_t i = 0; i < 3; ++i) { |
| 1353 | for (size_t j = 0; j < 5; ++j) { |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 1354 | EXPECT_EQ(out[j][i], in[i][j]); |
Andreas Huber | f9d49f1 | 2016-09-12 14:58:36 -0700 | [diff] [blame] | 1355 | } |
| 1356 | } |
| 1357 | })); |
| 1358 | } |
| 1359 | |
| 1360 | TEST_F(HidlTest, FooCallingDrWhoTest) { |
| 1361 | IFoo::MultiDimensional in; |
| 1362 | |
| 1363 | size_t k = 0; |
| 1364 | for (size_t i = 0; i < 5; ++i) { |
| 1365 | for (size_t j = 0; j < 3; ++j, ++k) { |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 1366 | in.quuxMatrix[i][j].first = ("First " + std::to_string(k)).c_str(); |
| 1367 | in.quuxMatrix[i][j].last = ("Last " + std::to_string(15-k)).c_str(); |
Andreas Huber | f9d49f1 | 2016-09-12 14:58:36 -0700 | [diff] [blame] | 1368 | } |
| 1369 | } |
| 1370 | |
| 1371 | ALOGI("CLIENT call callingDrWho(%s).", |
| 1372 | MultiDimensionalToString(in).c_str()); |
| 1373 | |
| 1374 | EXPECT_OK(foo->callingDrWho( |
| 1375 | in, |
| 1376 | [&](const auto &out) { |
| 1377 | ALOGI("CLIENT callingDrWho returned %s.", |
| 1378 | MultiDimensionalToString(out).c_str()); |
| 1379 | |
Andreas Huber | 709b62d | 2016-09-19 11:21:18 -0700 | [diff] [blame] | 1380 | size_t k = 0; |
Andreas Huber | f9d49f1 | 2016-09-12 14:58:36 -0700 | [diff] [blame] | 1381 | for (size_t i = 0; i < 5; ++i) { |
Andreas Huber | 709b62d | 2016-09-19 11:21:18 -0700 | [diff] [blame] | 1382 | for (size_t j = 0; j < 3; ++j, ++k) { |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 1383 | EXPECT_STREQ( |
| 1384 | out.quuxMatrix[i][j].first.c_str(), |
| 1385 | in.quuxMatrix[4 - i][2 - j].last.c_str()); |
Andreas Huber | f9d49f1 | 2016-09-12 14:58:36 -0700 | [diff] [blame] | 1386 | |
| 1387 | EXPECT_STREQ( |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 1388 | out.quuxMatrix[i][j].last.c_str(), |
| 1389 | in.quuxMatrix[4 - i][2 - j].first.c_str()); |
Andreas Huber | f9d49f1 | 2016-09-12 14:58:36 -0700 | [diff] [blame] | 1390 | } |
| 1391 | } |
| 1392 | })); |
| 1393 | } |
| 1394 | |
Andreas Huber | 709b62d | 2016-09-19 11:21:18 -0700 | [diff] [blame] | 1395 | static std::string numberToEnglish(int x) { |
| 1396 | static const char *const kDigits[] = { |
| 1397 | "zero", |
| 1398 | "one", |
| 1399 | "two", |
| 1400 | "three", |
| 1401 | "four", |
| 1402 | "five", |
| 1403 | "six", |
| 1404 | "seven", |
| 1405 | "eight", |
| 1406 | "nine", |
| 1407 | }; |
| 1408 | |
| 1409 | if (x < 0) { |
| 1410 | return "negative " + numberToEnglish(-x); |
| 1411 | } |
| 1412 | |
| 1413 | if (x < 10) { |
| 1414 | return kDigits[x]; |
| 1415 | } |
| 1416 | |
| 1417 | if (x <= 15) { |
| 1418 | static const char *const kSpecialTens[] = { |
| 1419 | "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", |
| 1420 | }; |
| 1421 | |
| 1422 | return kSpecialTens[x - 10]; |
| 1423 | } |
| 1424 | |
| 1425 | if (x < 20) { |
| 1426 | return std::string(kDigits[x % 10]) + "teen"; |
| 1427 | } |
| 1428 | |
| 1429 | if (x < 100) { |
| 1430 | static const char *const kDecades[] = { |
| 1431 | "twenty", "thirty", "forty", "fifty", "sixty", "seventy", |
| 1432 | "eighty", "ninety", |
| 1433 | }; |
| 1434 | |
| 1435 | return std::string(kDecades[x / 10 - 2]) + kDigits[x % 10]; |
| 1436 | } |
| 1437 | |
| 1438 | return "positively huge!"; |
| 1439 | } |
| 1440 | |
| 1441 | TEST_F(HidlTest, FooTransposeTest) { |
| 1442 | IFoo::StringMatrix5x3 in; |
| 1443 | |
Andreas Huber | 709b62d | 2016-09-19 11:21:18 -0700 | [diff] [blame] | 1444 | for (int i = 0; i < 5; ++i) { |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 1445 | for (int j = 0; j < 3; ++j) { |
| 1446 | in.s[i][j] = numberToEnglish(3 * i + j + 1).c_str(); |
Andreas Huber | 709b62d | 2016-09-19 11:21:18 -0700 | [diff] [blame] | 1447 | } |
| 1448 | } |
| 1449 | |
| 1450 | EXPECT_OK(foo->transpose( |
| 1451 | in, |
| 1452 | [&](const auto &out) { |
| 1453 | EXPECT_EQ( |
| 1454 | to_string(out), |
| 1455 | "[['one', 'four', 'seven', 'ten', 'thirteen'], " |
| 1456 | "['two', 'five', 'eight', 'eleven', 'fourteen'], " |
| 1457 | "['three', 'six', 'nine', 'twelve', 'fifteen']]"); |
| 1458 | })); |
| 1459 | } |
| 1460 | |
| 1461 | TEST_F(HidlTest, FooTranspose2Test) { |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 1462 | hidl_array<hidl_string, 5, 3> in; |
Andreas Huber | 709b62d | 2016-09-19 11:21:18 -0700 | [diff] [blame] | 1463 | |
Andreas Huber | 709b62d | 2016-09-19 11:21:18 -0700 | [diff] [blame] | 1464 | for (int i = 0; i < 5; ++i) { |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 1465 | for (int j = 0; j < 3; ++j) { |
| 1466 | in[i][j] = numberToEnglish(3 * i + j + 1).c_str(); |
Andreas Huber | 709b62d | 2016-09-19 11:21:18 -0700 | [diff] [blame] | 1467 | } |
| 1468 | } |
| 1469 | |
| 1470 | EXPECT_OK(foo->transpose2( |
| 1471 | in, |
| 1472 | [&](const auto &out) { |
| 1473 | EXPECT_EQ( |
Andreas Huber | f03332a | 2016-09-22 15:35:43 -0700 | [diff] [blame] | 1474 | to_string(out), |
Andreas Huber | 709b62d | 2016-09-19 11:21:18 -0700 | [diff] [blame] | 1475 | "[['one', 'four', 'seven', 'ten', 'thirteen'], " |
| 1476 | "['two', 'five', 'eight', 'eleven', 'fourteen'], " |
| 1477 | "['three', 'six', 'nine', 'twelve', 'fifteen']]"); |
| 1478 | })); |
| 1479 | } |
| 1480 | |
Yifan Hong | b725d67 | 2016-10-10 10:14:15 -0700 | [diff] [blame] | 1481 | TEST_F(HidlTest, FooNullNativeHandleTest) { |
| 1482 | Abc xyz; |
| 1483 | xyz.z = nullptr; |
| 1484 | EXPECT_FAIL(foo->haveATypeFromAnotherFile(xyz)); |
| 1485 | } |
Steven Moreland | 67f67b4 | 2016-09-29 08:59:02 -0700 | [diff] [blame] | 1486 | |
| 1487 | TEST_F(HidlTest, FooNonNullCallbackTest) { |
| 1488 | hidl_array<hidl_string, 5, 3> in; |
| 1489 | |
| 1490 | EXPECT_FAIL(foo->transpose2(in, nullptr /* _hidl_cb */)); |
| 1491 | } |
| 1492 | |
Andreas Huber | 5e44a29 | 2016-09-27 14:52:39 -0700 | [diff] [blame] | 1493 | TEST_F(HidlTest, FooSendVecTest) { |
| 1494 | hidl_vec<uint8_t> in; |
| 1495 | in.resize(16); |
| 1496 | for (size_t i = 0; i < in.size(); ++i) { |
| 1497 | in[i] = i; |
| 1498 | } |
| 1499 | |
| 1500 | EXPECT_OK(foo->sendVec( |
| 1501 | in, |
| 1502 | [&](const auto &out) { |
| 1503 | EXPECT_EQ(to_string(in), to_string(out)); |
| 1504 | })); |
| 1505 | } |
| 1506 | |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1507 | TEST_F(HidlTest, BarThisIsNewTest) { |
Iliyan Malchev | 0acf419 | 2016-08-22 19:33:20 -0700 | [diff] [blame] | 1508 | // Now the tricky part, get access to the derived interface. |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 1509 | ALOGI("CLIENT call thisIsNew."); |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1510 | EXPECT_OK(bar->thisIsNew()); |
Iliyan Malchev | b31e10c | 2016-08-13 23:03:25 -0700 | [diff] [blame] | 1511 | ALOGI("CLIENT thisIsNew returned."); |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 1512 | } |
| 1513 | |
Andreas Huber | 5d03477 | 2016-09-28 14:23:51 -0700 | [diff] [blame] | 1514 | TEST_F(HidlTest, TestArrayDimensionality) { |
| 1515 | hidl_array<int, 2> oneDim; |
| 1516 | hidl_array<int, 2, 3> twoDim; |
| 1517 | hidl_array<int, 2, 3, 4> threeDim; |
| 1518 | |
| 1519 | EXPECT_EQ(oneDim.size(), 2u); |
| 1520 | EXPECT_EQ(twoDim.size(), std::make_tuple(2u, 3u)); |
| 1521 | EXPECT_EQ(threeDim.size(), std::make_tuple(2u, 3u, 4u)); |
| 1522 | } |
| 1523 | |
Yifan Hong | bf459bc | 2016-08-23 16:50:37 -0700 | [diff] [blame] | 1524 | #if HIDL_RUN_POINTER_TESTS |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 1525 | |
Yifan Hong | bf459bc | 2016-08-23 16:50:37 -0700 | [diff] [blame] | 1526 | TEST_F(HidlTest, PassAGraphTest) { |
| 1527 | IGraph::Graph g; |
| 1528 | simpleGraph(g); |
| 1529 | logSimpleGraph("CLIENT", g); |
| 1530 | ALOGI("CLIENT call passAGraph"); |
| 1531 | EXPECT_OK(graphInterface->passAGraph(g)); |
| 1532 | } |
| 1533 | |
| 1534 | TEST_F(HidlTest, GiveAGraphTest) { |
| 1535 | EXPECT_OK(graphInterface->giveAGraph([&](const auto &newGraph) { |
| 1536 | logSimpleGraph("CLIENT", newGraph); |
| 1537 | EXPECT_TRUE(isSimpleGraph(newGraph)); |
| 1538 | })); |
| 1539 | } |
| 1540 | TEST_F(HidlTest, PassANodeTest) { |
| 1541 | IGraph::Node node; node.data = 10; |
| 1542 | EXPECT_OK(graphInterface->passANode(node)); |
| 1543 | } |
| 1544 | TEST_F(HidlTest, PassTwoGraphsTest) { |
| 1545 | IGraph::Graph g; |
| 1546 | simpleGraph(g); |
| 1547 | EXPECT_OK(graphInterface->passTwoGraphs(&g, &g)); |
| 1548 | } |
| 1549 | TEST_F(HidlTest, PassAGammaTest) { |
| 1550 | IGraph::Theta s; s.data = 500; |
| 1551 | IGraph::Alpha a; a.s_ptr = &s; |
| 1552 | IGraph::Beta b; b.s_ptr = &s; |
| 1553 | IGraph::Gamma c; c.a_ptr = &a; c.b_ptr = &b; |
| 1554 | ALOGI("CLIENT calling passAGamma: c.a = %p, c.b = %p, c.a->s = %p, c.b->s = %p", |
| 1555 | c.a_ptr, c.b_ptr, c.a_ptr->s_ptr, c.b_ptr->s_ptr); |
| 1556 | EXPECT_OK(graphInterface->passAGamma(c)); |
| 1557 | } |
| 1558 | TEST_F(HidlTest, PassNullTest) { |
| 1559 | IGraph::Gamma c; |
| 1560 | c.a_ptr = nullptr; |
| 1561 | c.b_ptr = nullptr; |
| 1562 | EXPECT_OK(graphInterface->passAGamma(c)); |
| 1563 | } |
| 1564 | TEST_F(HidlTest, PassASimpleRefTest) { |
| 1565 | IGraph::Theta s; |
| 1566 | s.data = 500; |
| 1567 | IGraph::Alpha a; |
| 1568 | a.s_ptr = &s; |
| 1569 | EXPECT_OK(graphInterface->passASimpleRef(&a)); |
| 1570 | } |
| 1571 | TEST_F(HidlTest, PassASimpleRefSTest) { |
| 1572 | IGraph::Theta s; |
| 1573 | s.data = 500; |
| 1574 | ALOGI("CLIENT call passASimpleRefS with %p", &s); |
| 1575 | EXPECT_OK(graphInterface->passASimpleRefS(&s)); |
| 1576 | } |
| 1577 | TEST_F(HidlTest, GiveASimpleRefTest) { |
| 1578 | EXPECT_OK(graphInterface->giveASimpleRef([&](const auto & a_ptr) { |
| 1579 | EXPECT_EQ(a_ptr->s_ptr->data, 500); |
| 1580 | })); |
| 1581 | } |
| 1582 | TEST_F(HidlTest, GraphReportErrorsTest) { |
| 1583 | Return<int32_t> ret = graphInterface->getErrors(); |
| 1584 | EXPECT_OK(ret); |
| 1585 | EXPECT_EQ(int32_t(ret), 0); |
| 1586 | } |
| 1587 | |
| 1588 | TEST_F(HidlTest, PointerPassOldBufferTest) { |
| 1589 | EXPECT_OK(validationPointerInterface.bar1([&](const auto& sptr, const auto& s) { |
| 1590 | EXPECT_OK(pointerInterface->foo1(sptr, s)); |
| 1591 | })); |
| 1592 | } |
| 1593 | TEST_F(HidlTest, PointerPassOldBufferTest2) { |
| 1594 | EXPECT_OK(validationPointerInterface.bar2([&](const auto& s, const auto& a) { |
| 1595 | EXPECT_OK(pointerInterface->foo2(s, a)); |
| 1596 | })); |
| 1597 | } |
| 1598 | TEST_F(HidlTest, PointerPassSameOldBufferPointerTest) { |
| 1599 | EXPECT_OK(validationPointerInterface.bar3([&](const auto& s, const auto& a, const auto& b) { |
| 1600 | EXPECT_OK(pointerInterface->foo3(s, a, b)); |
| 1601 | })); |
| 1602 | } |
| 1603 | TEST_F(HidlTest, PointerPassOnlyTest) { |
| 1604 | EXPECT_OK(validationPointerInterface.bar4([&](const auto& s) { |
| 1605 | EXPECT_OK(pointerInterface->foo4(s)); |
| 1606 | })); |
| 1607 | } |
| 1608 | TEST_F(HidlTest, PointerPassTwoEmbeddedTest) { |
| 1609 | EXPECT_OK(validationPointerInterface.bar5([&](const auto& a, const auto& b) { |
| 1610 | EXPECT_OK(pointerInterface->foo5(a, b)); |
| 1611 | })); |
| 1612 | } |
| 1613 | TEST_F(HidlTest, PointerPassIndirectBufferHasDataTest) { |
| 1614 | EXPECT_OK(validationPointerInterface.bar6([&](const auto& a) { |
| 1615 | EXPECT_OK(pointerInterface->foo6(a)); |
| 1616 | })); |
| 1617 | } |
| 1618 | TEST_F(HidlTest, PointerPassTwoIndirectBufferTest) { |
| 1619 | EXPECT_OK(validationPointerInterface.bar7([&](const auto& a, const auto& b) { |
| 1620 | EXPECT_OK(pointerInterface->foo7(a, b)); |
| 1621 | })); |
| 1622 | } |
| 1623 | TEST_F(HidlTest, PointerPassDeeplyIndirectTest) { |
| 1624 | EXPECT_OK(validationPointerInterface.bar8([&](const auto& d) { |
| 1625 | EXPECT_OK(pointerInterface->foo8(d)); |
| 1626 | })); |
| 1627 | } |
| 1628 | TEST_F(HidlTest, PointerPassStringRefTest) { |
| 1629 | EXPECT_OK(validationPointerInterface.bar9([&](const auto& str) { |
| 1630 | EXPECT_OK(pointerInterface->foo9(str)); |
| 1631 | })); |
| 1632 | } |
| 1633 | TEST_F(HidlTest, PointerPassRefVecTest) { |
| 1634 | EXPECT_OK(validationPointerInterface.bar10([&](const auto& v) { |
| 1635 | EXPECT_OK(pointerInterface->foo10(v)); |
| 1636 | })); |
| 1637 | } |
| 1638 | TEST_F(HidlTest, PointerPassVecRefTest) { |
| 1639 | EXPECT_OK(validationPointerInterface.bar11([&](const auto& v) { |
| 1640 | EXPECT_OK(pointerInterface->foo11(v)); |
| 1641 | })); |
| 1642 | } |
| 1643 | TEST_F(HidlTest, PointerPassArrayRefTest) { |
| 1644 | EXPECT_OK(validationPointerInterface.bar12([&](const auto& array) { |
| 1645 | EXPECT_OK(pointerInterface->foo12(array)); |
| 1646 | })); |
| 1647 | } |
| 1648 | TEST_F(HidlTest, PointerPassRefArrayTest) { |
| 1649 | EXPECT_OK(validationPointerInterface.bar13([&](const auto& array) { |
| 1650 | EXPECT_OK(pointerInterface->foo13(array)); |
| 1651 | })); |
| 1652 | } |
| 1653 | TEST_F(HidlTest, PointerPass3RefTest) { |
| 1654 | EXPECT_OK(validationPointerInterface.bar14([&](const auto& p3) { |
| 1655 | EXPECT_OK(pointerInterface->foo14(p3)); |
| 1656 | })); |
| 1657 | } |
| 1658 | TEST_F(HidlTest, PointerPassInt3RefTest) { |
| 1659 | EXPECT_OK(validationPointerInterface.bar15([&](const auto& p3) { |
| 1660 | EXPECT_OK(pointerInterface->foo15(p3)); |
| 1661 | })); |
| 1662 | } |
| 1663 | TEST_F(HidlTest, PointerPassEmbeddedPointersTest) { |
| 1664 | EXPECT_OK(validationPointerInterface.bar16([&](const auto& p) { |
| 1665 | EXPECT_OK(pointerInterface->foo16(p)); |
| 1666 | })); |
| 1667 | } |
| 1668 | TEST_F(HidlTest, PointerPassEmbeddedPointers2Test) { |
| 1669 | EXPECT_OK(validationPointerInterface.bar17([&](const auto& p) { |
| 1670 | EXPECT_OK(pointerInterface->foo17(p)); |
| 1671 | })); |
| 1672 | } |
| 1673 | TEST_F(HidlTest, PointerPassCopiedStringTest) { |
| 1674 | EXPECT_OK(validationPointerInterface.bar18([&](const auto& str_ref, const auto& str_ref2, const auto& str) { |
| 1675 | EXPECT_OK(pointerInterface->foo18(str_ref, str_ref2, str)); |
| 1676 | })); |
| 1677 | } |
| 1678 | TEST_F(HidlTest, PointerPassCopiedVecTest) { |
| 1679 | EXPECT_OK(validationPointerInterface.bar19([&](const auto& a_vec_ref, const auto& a_vec, const auto& a_vec_ref2) { |
| 1680 | EXPECT_OK(pointerInterface->foo19(a_vec_ref, a_vec, a_vec_ref2)); |
| 1681 | })); |
| 1682 | } |
Yifan Hong | 8446590 | 2016-09-27 15:52:17 -0700 | [diff] [blame] | 1683 | TEST_F(HidlTest, PointerPassBigRefVecTest) { |
| 1684 | EXPECT_OK(validationPointerInterface.bar20([&](const auto& v) { |
| 1685 | EXPECT_FAIL(pointerInterface->foo20(v)); |
| 1686 | })); |
| 1687 | } |
Yifan Hong | bf459bc | 2016-08-23 16:50:37 -0700 | [diff] [blame] | 1688 | TEST_F(HidlTest, PointerPassMultidimArrayRefTest) { |
| 1689 | EXPECT_OK(validationPointerInterface.bar21([&](const auto& v) { |
| 1690 | EXPECT_OK(pointerInterface->foo21(v)); |
| 1691 | })); |
| 1692 | } |
| 1693 | TEST_F(HidlTest, PointerPassRefMultidimArrayTest) { |
| 1694 | EXPECT_OK(validationPointerInterface.bar22([&](const auto& v) { |
| 1695 | EXPECT_OK(pointerInterface->foo22(v)); |
| 1696 | })); |
| 1697 | } |
| 1698 | TEST_F(HidlTest, PointerGiveOldBufferTest) { |
| 1699 | EXPECT_OK(pointerInterface->bar1([&](const auto& sptr, const auto& s) { |
| 1700 | EXPECT_OK(validationPointerInterface.foo1(sptr, s)); |
| 1701 | })); |
| 1702 | } |
| 1703 | TEST_F(HidlTest, PointerGiveOldBufferTest2) { |
| 1704 | EXPECT_OK(pointerInterface->bar2([&](const auto& s, const auto& a) { |
| 1705 | EXPECT_OK(validationPointerInterface.foo2(s, a)); |
| 1706 | })); |
| 1707 | } |
| 1708 | TEST_F(HidlTest, PointerGiveSameOldBufferPointerTest) { |
| 1709 | EXPECT_OK(pointerInterface->bar3([&](const auto& s, const auto& a, const auto& b) { |
| 1710 | EXPECT_OK(validationPointerInterface.foo3(s, a, b)); |
| 1711 | })); |
| 1712 | } |
| 1713 | TEST_F(HidlTest, PointerGiveOnlyTest) { |
| 1714 | EXPECT_OK(pointerInterface->bar4([&](const auto& s) { |
| 1715 | EXPECT_OK(validationPointerInterface.foo4(s)); |
| 1716 | })); |
| 1717 | } |
| 1718 | TEST_F(HidlTest, PointerGiveTwoEmbeddedTest) { |
| 1719 | EXPECT_OK(pointerInterface->bar5([&](const auto& a, const auto& b) { |
| 1720 | EXPECT_OK(validationPointerInterface.foo5(a, b)); |
| 1721 | })); |
| 1722 | } |
| 1723 | TEST_F(HidlTest, PointerGiveIndirectBufferHasDataTest) { |
| 1724 | EXPECT_OK(pointerInterface->bar6([&](const auto& a) { |
| 1725 | EXPECT_OK(validationPointerInterface.foo6(a)); |
| 1726 | })); |
| 1727 | } |
| 1728 | TEST_F(HidlTest, PointerGiveTwoIndirectBufferTest) { |
| 1729 | EXPECT_OK(pointerInterface->bar7([&](const auto& a, const auto& b) { |
| 1730 | EXPECT_OK(validationPointerInterface.foo7(a, b)); |
| 1731 | })); |
| 1732 | } |
| 1733 | TEST_F(HidlTest, PointerGiveDeeplyIndirectTest) { |
| 1734 | EXPECT_OK(pointerInterface->bar8([&](const auto& d) { |
| 1735 | EXPECT_OK(validationPointerInterface.foo8(d)); |
| 1736 | })); |
| 1737 | } |
| 1738 | TEST_F(HidlTest, PointerGiveStringRefTest) { |
| 1739 | EXPECT_OK(pointerInterface->bar9([&](const auto& str) { |
| 1740 | EXPECT_OK(validationPointerInterface.foo9(str)); |
| 1741 | })); |
| 1742 | } |
| 1743 | TEST_F(HidlTest, PointerGiveRefVecTest) { |
| 1744 | EXPECT_OK(pointerInterface->bar10([&](const auto& v) { |
| 1745 | EXPECT_OK(validationPointerInterface.foo10(v)); |
| 1746 | })); |
| 1747 | } |
| 1748 | TEST_F(HidlTest, PointerGiveVecRefTest) { |
| 1749 | EXPECT_OK(pointerInterface->bar11([&](const auto& v) { |
| 1750 | EXPECT_OK(validationPointerInterface.foo11(v)); |
| 1751 | })); |
| 1752 | } |
| 1753 | TEST_F(HidlTest, PointerGiveArrayRefTest) { |
| 1754 | EXPECT_OK(pointerInterface->bar12([&](const auto& array) { |
| 1755 | EXPECT_OK(validationPointerInterface.foo12(array)); |
| 1756 | })); |
| 1757 | } |
| 1758 | TEST_F(HidlTest, PointerGiveRefArrayTest) { |
| 1759 | EXPECT_OK(pointerInterface->bar13([&](const auto& array) { |
| 1760 | EXPECT_OK(validationPointerInterface.foo13(array)); |
| 1761 | })); |
| 1762 | } |
| 1763 | TEST_F(HidlTest, PointerGive3RefTest) { |
| 1764 | EXPECT_OK(pointerInterface->bar14([&](const auto& p3) { |
| 1765 | EXPECT_OK(validationPointerInterface.foo14(p3)); |
| 1766 | })); |
| 1767 | } |
| 1768 | TEST_F(HidlTest, PointerGiveInt3RefTest) { |
| 1769 | EXPECT_OK(pointerInterface->bar15([&](const auto& p3) { |
| 1770 | EXPECT_OK(validationPointerInterface.foo15(p3)); |
| 1771 | })); |
| 1772 | } |
| 1773 | TEST_F(HidlTest, PointerGiveEmbeddedPointersTest) { |
| 1774 | EXPECT_OK(pointerInterface->bar16([&](const auto& p) { |
| 1775 | EXPECT_OK(validationPointerInterface.foo16(p)); |
| 1776 | })); |
| 1777 | } |
| 1778 | TEST_F(HidlTest, PointerGiveEmbeddedPointers2Test) { |
| 1779 | EXPECT_OK(pointerInterface->bar17([&](const auto& p) { |
| 1780 | EXPECT_OK(validationPointerInterface.foo17(p)); |
| 1781 | })); |
| 1782 | } |
| 1783 | TEST_F(HidlTest, PointerGiveCopiedStringTest) { |
| 1784 | EXPECT_OK(pointerInterface->bar18([&](const auto& str_ref, const auto& str_ref2, const auto& str) { |
| 1785 | EXPECT_OK(validationPointerInterface.foo18(str_ref, str_ref2, str)); |
| 1786 | })); |
| 1787 | } |
| 1788 | TEST_F(HidlTest, PointerGiveCopiedVecTest) { |
| 1789 | EXPECT_OK(pointerInterface->bar19([&](const auto& a_vec_ref, const auto& a_vec, const auto& a_vec_ref2) { |
| 1790 | EXPECT_OK(validationPointerInterface.foo19(a_vec_ref, a_vec, a_vec_ref2)); |
| 1791 | })); |
| 1792 | } |
Yifan Hong | 8446590 | 2016-09-27 15:52:17 -0700 | [diff] [blame] | 1793 | // This cannot be enabled until _hidl_error is not ignored when |
| 1794 | // the remote writeEmbeddedReferencesToParcel. |
| 1795 | // TEST_F(HidlTest, PointerGiveBigRefVecTest) { |
| 1796 | // EXPECT_FAIL(pointerInterface->bar20([&](const auto& v) { |
| 1797 | // })); |
| 1798 | // } |
Yifan Hong | bf459bc | 2016-08-23 16:50:37 -0700 | [diff] [blame] | 1799 | TEST_F(HidlTest, PointerGiveMultidimArrayRefTest) { |
| 1800 | EXPECT_OK(pointerInterface->bar21([&](const auto& v) { |
| 1801 | EXPECT_OK(validationPointerInterface.foo21(v)); |
| 1802 | })); |
| 1803 | } |
| 1804 | TEST_F(HidlTest, PointerGiveRefMultidimArrayTest) { |
| 1805 | EXPECT_OK(pointerInterface->bar22([&](const auto& v) { |
| 1806 | EXPECT_OK(validationPointerInterface.foo22(v)); |
| 1807 | })); |
| 1808 | } |
| 1809 | TEST_F(HidlTest, PointerReportErrorsTest) { |
| 1810 | Return<int32_t> ret = pointerInterface->getErrors(); |
| 1811 | EXPECT_OK(ret); |
| 1812 | EXPECT_EQ(int32_t(ret), 0); |
| 1813 | } |
| 1814 | #endif |
| 1815 | |
| 1816 | int main(int argc, char **argv) { |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1817 | ::testing::InitGoogleTest(&argc, argv); |
Yifan Hong | 3eac8a3 | 2016-10-11 10:02:59 -0700 | [diff] [blame^] | 1818 | ::testing::AddGlobalTestEnvironment(new HidlEnvironment); |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1819 | int status = RUN_ALL_TESTS(); |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 1820 | |
Yifan Hong | 1dc8793 | 2016-08-19 09:51:01 -0700 | [diff] [blame] | 1821 | ALOGI("Test result = %d", status); |
| 1822 | return status; |
Andreas Huber | 9cd48d0 | 2016-08-03 14:25:59 -0700 | [diff] [blame] | 1823 | } |