1/*
2 * Copyright (C) 2015, The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *     http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include "tests/test_data.h"
18
19namespace android {
20namespace aidl {
21namespace test_data {
22namespace ping_responder {
23
24const char kCanonicalName[] = "android.os.IPingResponder";
25const char kInterfaceDefinition[] = R"(
26package android.os;
27
28import bar.Unused;
29
30interface IPingResponder {
31  String Ping(String input);
32
33  @nullable
34  String NullablePing(@nullable String input);
35
36  @utf8InCpp
37  String Utf8Ping(@utf8InCpp String input);
38
39  @utf8InCpp @nullable
40  String NullableUtf8Ping(@utf8InCpp @nullable String input);
41}
42)";
43
44const char kCppOutputPath[] = "some/path/to/output.cpp";
45
46const char kCppParcelableHeader[] = "cpp-header-str";
47
48const char* kImportedParcelables[] = {
49  "bar.Unused",
50  nullptr,
51};
52
53const char* kImportedInterfaces[] = {
54  nullptr,
55};
56
57const char kGenHeaderDir[] = "some/path";
58const char kGenInterfaceHeaderPath[] = "some/path/android/os/IPingResponder.h";
59const char kGenClientHeaderPath[] = "some/path/android/os/BpPingResponder.h";
60const char kGenServerHeaderPath[] = "some/path/android/os/BnPingResponder.h";
61
62const char kExpectedCppDepsOutput[] =
63R"(some/path/to/output.cpp : \
64  android/os/IPingResponder.aidl \
65  ./bar/Unused.aidl
66
67android/os/IPingResponder.aidl :
68./bar/Unused.aidl :
69
70some/path/android/os/BpPingResponder.h \
71    some/path/android/os/BnPingResponder.h \
72    some/path/android/os/IPingResponder.h : \
73    android/os/IPingResponder.aidl \
74    ./bar/Unused.aidl
75)";
76
77const char kExpectedCppOutput[] =
78R"(#include <android/os/IPingResponder.h>
79#include <android/os/BpPingResponder.h>
80
81namespace android {
82
83namespace os {
84
85IMPLEMENT_META_INTERFACE(PingResponder, "android.os.IPingResponder")
86
87}  // namespace os
88
89}  // namespace android
90#include <android/os/BpPingResponder.h>
91#include <binder/Parcel.h>
92
93namespace android {
94
95namespace os {
96
97BpPingResponder::BpPingResponder(const ::android::sp<::android::IBinder>& _aidl_impl)
98    : BpInterface<IPingResponder>(_aidl_impl){
99}
100
101::android::binder::Status BpPingResponder::Ping(const ::android::String16& input, ::android::String16* _aidl_return) {
102::android::Parcel _aidl_data;
103::android::Parcel _aidl_reply;
104::android::status_t _aidl_ret_status = ::android::OK;
105::android::binder::Status _aidl_status;
106_aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor());
107if (((_aidl_ret_status) != (::android::OK))) {
108goto _aidl_error;
109}
110_aidl_ret_status = _aidl_data.writeString16(input);
111if (((_aidl_ret_status) != (::android::OK))) {
112goto _aidl_error;
113}
114_aidl_ret_status = remote()->transact(IPingResponder::PING, _aidl_data, &_aidl_reply);
115if (((_aidl_ret_status) != (::android::OK))) {
116goto _aidl_error;
117}
118_aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply);
119if (((_aidl_ret_status) != (::android::OK))) {
120goto _aidl_error;
121}
122if (!_aidl_status.isOk()) {
123return _aidl_status;
124}
125_aidl_ret_status = _aidl_reply.readString16(_aidl_return);
126if (((_aidl_ret_status) != (::android::OK))) {
127goto _aidl_error;
128}
129_aidl_error:
130_aidl_status.setFromStatusT(_aidl_ret_status);
131return _aidl_status;
132}
133
134::android::binder::Status BpPingResponder::NullablePing(const ::std::unique_ptr<::android::String16>& input, ::std::unique_ptr<::android::String16>* _aidl_return) {
135::android::Parcel _aidl_data;
136::android::Parcel _aidl_reply;
137::android::status_t _aidl_ret_status = ::android::OK;
138::android::binder::Status _aidl_status;
139_aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor());
140if (((_aidl_ret_status) != (::android::OK))) {
141goto _aidl_error;
142}
143_aidl_ret_status = _aidl_data.writeString16(input);
144if (((_aidl_ret_status) != (::android::OK))) {
145goto _aidl_error;
146}
147_aidl_ret_status = remote()->transact(IPingResponder::NULLABLEPING, _aidl_data, &_aidl_reply);
148if (((_aidl_ret_status) != (::android::OK))) {
149goto _aidl_error;
150}
151_aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply);
152if (((_aidl_ret_status) != (::android::OK))) {
153goto _aidl_error;
154}
155if (!_aidl_status.isOk()) {
156return _aidl_status;
157}
158_aidl_ret_status = _aidl_reply.readString16(_aidl_return);
159if (((_aidl_ret_status) != (::android::OK))) {
160goto _aidl_error;
161}
162_aidl_error:
163_aidl_status.setFromStatusT(_aidl_ret_status);
164return _aidl_status;
165}
166
167::android::binder::Status BpPingResponder::Utf8Ping(const ::std::string& input, ::std::string* _aidl_return) {
168::android::Parcel _aidl_data;
169::android::Parcel _aidl_reply;
170::android::status_t _aidl_ret_status = ::android::OK;
171::android::binder::Status _aidl_status;
172_aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor());
173if (((_aidl_ret_status) != (::android::OK))) {
174goto _aidl_error;
175}
176_aidl_ret_status = _aidl_data.writeUtf8AsUtf16(input);
177if (((_aidl_ret_status) != (::android::OK))) {
178goto _aidl_error;
179}
180_aidl_ret_status = remote()->transact(IPingResponder::UTF8PING, _aidl_data, &_aidl_reply);
181if (((_aidl_ret_status) != (::android::OK))) {
182goto _aidl_error;
183}
184_aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply);
185if (((_aidl_ret_status) != (::android::OK))) {
186goto _aidl_error;
187}
188if (!_aidl_status.isOk()) {
189return _aidl_status;
190}
191_aidl_ret_status = _aidl_reply.readUtf8FromUtf16(_aidl_return);
192if (((_aidl_ret_status) != (::android::OK))) {
193goto _aidl_error;
194}
195_aidl_error:
196_aidl_status.setFromStatusT(_aidl_ret_status);
197return _aidl_status;
198}
199
200::android::binder::Status BpPingResponder::NullableUtf8Ping(const ::std::unique_ptr<::std::string>& input, ::std::unique_ptr<::std::string>* _aidl_return) {
201::android::Parcel _aidl_data;
202::android::Parcel _aidl_reply;
203::android::status_t _aidl_ret_status = ::android::OK;
204::android::binder::Status _aidl_status;
205_aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor());
206if (((_aidl_ret_status) != (::android::OK))) {
207goto _aidl_error;
208}
209_aidl_ret_status = _aidl_data.writeUtf8AsUtf16(input);
210if (((_aidl_ret_status) != (::android::OK))) {
211goto _aidl_error;
212}
213_aidl_ret_status = remote()->transact(IPingResponder::NULLABLEUTF8PING, _aidl_data, &_aidl_reply);
214if (((_aidl_ret_status) != (::android::OK))) {
215goto _aidl_error;
216}
217_aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply);
218if (((_aidl_ret_status) != (::android::OK))) {
219goto _aidl_error;
220}
221if (!_aidl_status.isOk()) {
222return _aidl_status;
223}
224_aidl_ret_status = _aidl_reply.readUtf8FromUtf16(_aidl_return);
225if (((_aidl_ret_status) != (::android::OK))) {
226goto _aidl_error;
227}
228_aidl_error:
229_aidl_status.setFromStatusT(_aidl_ret_status);
230return _aidl_status;
231}
232
233}  // namespace os
234
235}  // namespace android
236#include <android/os/BnPingResponder.h>
237#include <binder/Parcel.h>
238
239namespace android {
240
241namespace os {
242
243::android::status_t BnPingResponder::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) {
244::android::status_t _aidl_ret_status = ::android::OK;
245switch (_aidl_code) {
246case Call::PING:
247{
248::android::String16 in_input;
249::android::String16 _aidl_return;
250if (!(_aidl_data.checkInterface(this))) {
251_aidl_ret_status = ::android::BAD_TYPE;
252break;
253}
254_aidl_ret_status = _aidl_data.readString16(&in_input);
255if (((_aidl_ret_status) != (::android::OK))) {
256break;
257}
258::android::binder::Status _aidl_status(Ping(in_input, &_aidl_return));
259_aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply);
260if (((_aidl_ret_status) != (::android::OK))) {
261break;
262}
263if (!_aidl_status.isOk()) {
264break;
265}
266_aidl_ret_status = _aidl_reply->writeString16(_aidl_return);
267if (((_aidl_ret_status) != (::android::OK))) {
268break;
269}
270}
271break;
272case Call::NULLABLEPING:
273{
274::std::unique_ptr<::android::String16> in_input;
275::std::unique_ptr<::android::String16> _aidl_return;
276if (!(_aidl_data.checkInterface(this))) {
277_aidl_ret_status = ::android::BAD_TYPE;
278break;
279}
280_aidl_ret_status = _aidl_data.readString16(&in_input);
281if (((_aidl_ret_status) != (::android::OK))) {
282break;
283}
284::android::binder::Status _aidl_status(NullablePing(in_input, &_aidl_return));
285_aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply);
286if (((_aidl_ret_status) != (::android::OK))) {
287break;
288}
289if (!_aidl_status.isOk()) {
290break;
291}
292_aidl_ret_status = _aidl_reply->writeString16(_aidl_return);
293if (((_aidl_ret_status) != (::android::OK))) {
294break;
295}
296}
297break;
298case Call::UTF8PING:
299{
300::std::string in_input;
301::std::string _aidl_return;
302if (!(_aidl_data.checkInterface(this))) {
303_aidl_ret_status = ::android::BAD_TYPE;
304break;
305}
306_aidl_ret_status = _aidl_data.readUtf8FromUtf16(&in_input);
307if (((_aidl_ret_status) != (::android::OK))) {
308break;
309}
310::android::binder::Status _aidl_status(Utf8Ping(in_input, &_aidl_return));
311_aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply);
312if (((_aidl_ret_status) != (::android::OK))) {
313break;
314}
315if (!_aidl_status.isOk()) {
316break;
317}
318_aidl_ret_status = _aidl_reply->writeUtf8AsUtf16(_aidl_return);
319if (((_aidl_ret_status) != (::android::OK))) {
320break;
321}
322}
323break;
324case Call::NULLABLEUTF8PING:
325{
326::std::unique_ptr<::std::string> in_input;
327::std::unique_ptr<::std::string> _aidl_return;
328if (!(_aidl_data.checkInterface(this))) {
329_aidl_ret_status = ::android::BAD_TYPE;
330break;
331}
332_aidl_ret_status = _aidl_data.readUtf8FromUtf16(&in_input);
333if (((_aidl_ret_status) != (::android::OK))) {
334break;
335}
336::android::binder::Status _aidl_status(NullableUtf8Ping(in_input, &_aidl_return));
337_aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply);
338if (((_aidl_ret_status) != (::android::OK))) {
339break;
340}
341if (!_aidl_status.isOk()) {
342break;
343}
344_aidl_ret_status = _aidl_reply->writeUtf8AsUtf16(_aidl_return);
345if (((_aidl_ret_status) != (::android::OK))) {
346break;
347}
348}
349break;
350default:
351{
352_aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags);
353}
354break;
355}
356if (_aidl_ret_status == ::android::UNEXPECTED_NULL) {
357_aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeToParcel(_aidl_reply);
358}
359return _aidl_ret_status;
360}
361
362}  // namespace os
363
364}  // namespace android
365)";
366
367const char kExpectedIHeaderOutput[] =
368R"(#ifndef AIDL_GENERATED_ANDROID_OS_I_PING_RESPONDER_H_
369#define AIDL_GENERATED_ANDROID_OS_I_PING_RESPONDER_H_
370
371#include <binder/IBinder.h>
372#include <binder/IInterface.h>
373#include <binder/Status.h>
374#include <memory>
375#include <string>
376#include <utils/String16.h>
377#include <utils/StrongPointer.h>
378
379namespace android {
380
381namespace os {
382
383class IPingResponder : public ::android::IInterface {
384public:
385DECLARE_META_INTERFACE(PingResponder)
386virtual ::android::binder::Status Ping(const ::android::String16& input, ::android::String16* _aidl_return) = 0;
387virtual ::android::binder::Status NullablePing(const ::std::unique_ptr<::android::String16>& input, ::std::unique_ptr<::android::String16>* _aidl_return) = 0;
388virtual ::android::binder::Status Utf8Ping(const ::std::string& input, ::std::string* _aidl_return) = 0;
389virtual ::android::binder::Status NullableUtf8Ping(const ::std::unique_ptr<::std::string>& input, ::std::unique_ptr<::std::string>* _aidl_return) = 0;
390enum Call {
391  PING = ::android::IBinder::FIRST_CALL_TRANSACTION + 0,
392  NULLABLEPING = ::android::IBinder::FIRST_CALL_TRANSACTION + 1,
393  UTF8PING = ::android::IBinder::FIRST_CALL_TRANSACTION + 2,
394  NULLABLEUTF8PING = ::android::IBinder::FIRST_CALL_TRANSACTION + 3,
395};
396};  // class IPingResponder
397
398}  // namespace os
399
400}  // namespace android
401
402#endif  // AIDL_GENERATED_ANDROID_OS_I_PING_RESPONDER_H_
403)";
404
405const char kExpectedBpHeaderOutput[] =
406R"(#ifndef AIDL_GENERATED_ANDROID_OS_BP_PING_RESPONDER_H_
407#define AIDL_GENERATED_ANDROID_OS_BP_PING_RESPONDER_H_
408
409#include <binder/IBinder.h>
410#include <binder/IInterface.h>
411#include <utils/Errors.h>
412#include <android/os/IPingResponder.h>
413
414namespace android {
415
416namespace os {
417
418class BpPingResponder : public ::android::BpInterface<IPingResponder> {
419public:
420explicit BpPingResponder(const ::android::sp<::android::IBinder>& _aidl_impl);
421virtual ~BpPingResponder() = default;
422::android::binder::Status Ping(const ::android::String16& input, ::android::String16* _aidl_return) override;
423::android::binder::Status NullablePing(const ::std::unique_ptr<::android::String16>& input, ::std::unique_ptr<::android::String16>* _aidl_return) override;
424::android::binder::Status Utf8Ping(const ::std::string& input, ::std::string* _aidl_return) override;
425::android::binder::Status NullableUtf8Ping(const ::std::unique_ptr<::std::string>& input, ::std::unique_ptr<::std::string>* _aidl_return) override;
426};  // class BpPingResponder
427
428}  // namespace os
429
430}  // namespace android
431
432#endif  // AIDL_GENERATED_ANDROID_OS_BP_PING_RESPONDER_H_
433)";
434
435const char kExpectedBnHeaderOutput[] =
436R"(#ifndef AIDL_GENERATED_ANDROID_OS_BN_PING_RESPONDER_H_
437#define AIDL_GENERATED_ANDROID_OS_BN_PING_RESPONDER_H_
438
439#include <binder/IInterface.h>
440#include <android/os/IPingResponder.h>
441
442namespace android {
443
444namespace os {
445
446class BnPingResponder : public ::android::BnInterface<IPingResponder> {
447public:
448::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags = 0) override;
449};  // class BnPingResponder
450
451}  // namespace os
452
453}  // namespace android
454
455#endif  // AIDL_GENERATED_ANDROID_OS_BN_PING_RESPONDER_H_
456)";
457
458}  // namespace ping_responder
459}  // namespace test_data
460}  // namespace aidl
461}  // namespace android
462