1 /*
2 * Copyright (C) 2020, 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 //! Test Rust client for the AIDL compiler.
18
19 use ::binder::{binder_impl::Parcel, Parcelable};
20 use aidl_test_fixedsizearray::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::{
21 FixedSizeArrayExample,
22 IRepeatFixedSizeArray::{BpRepeatFixedSizeArray, IRepeatFixedSizeArray},
23 IntParcelable::IntParcelable,
24 };
25 use aidl_test_interface::aidl::android::aidl::tests::nested::{
26 INestedService, ParcelableWithNested,
27 };
28 use aidl_test_interface::aidl::android::aidl::tests::unions::EnumUnion::EnumUnion;
29 use aidl_test_interface::aidl::android::aidl::tests::INewName::{self, BpNewName};
30 use aidl_test_interface::aidl::android::aidl::tests::IOldName::{self, BpOldName};
31 use aidl_test_interface::aidl::android::aidl::tests::ITestService::{
32 self, BpTestService, Empty::Empty, ITestServiceDefault, ITestServiceDefaultRef,
33 };
34 use aidl_test_interface::aidl::android::aidl::tests::{
35 extension::ExtendableParcelable::ExtendableParcelable, extension::MyExt::MyExt,
36 extension::MyExt2::MyExt2, extension::MyExtLike::MyExtLike, BackendType::BackendType,
37 ByteEnum::ByteEnum, IntEnum::IntEnum, LongEnum::LongEnum, RecursiveList::RecursiveList,
38 StructuredParcelable, Union,
39 };
40 use aidl_test_interface::binder::{self, BinderFeatures, IBinder, Interface};
41 use aidl_test_nonvintf_parcelable::aidl::android::aidl::tests::nonvintf::{
42 NonVintfExtendableParcelable::NonVintfExtendableParcelable,
43 NonVintfParcelable::NonVintfParcelable,
44 };
45 use aidl_test_unstable_parcelable::aidl::android::aidl::tests::unstable::{
46 UnstableExtendableParcelable::UnstableExtendableParcelable,
47 UnstableParcelable::UnstableParcelable,
48 };
49 use aidl_test_versioned_interface::aidl::android::aidl::versioned::tests::{
50 BazUnion::BazUnion, Foo::Foo, IFooInterface, IFooInterface::BpFooInterface,
51 };
52 use aidl_test_vintf_parcelable::aidl::android::aidl::tests::vintf::{
53 VintfExtendableParcelable::VintfExtendableParcelable, VintfParcelable::VintfParcelable,
54 };
55 use android_aidl_test_trunk::aidl::android::aidl::test::trunk::{
56 ITrunkStableTest::BpTrunkStableTest, ITrunkStableTest::IMyCallback,
57 ITrunkStableTest::ITrunkStableTest, ITrunkStableTest::MyEnum::MyEnum,
58 ITrunkStableTest::MyOtherParcelable::MyOtherParcelable,
59 ITrunkStableTest::MyParcelable::MyParcelable, ITrunkStableTest::MyUnion::MyUnion,
60 };
61 use simple_parcelable::SimpleParcelable;
62
63 use std::fs::File;
64 use std::io::{Read, Write};
65 use std::os::fd::{FromRawFd, OwnedFd};
66 use std::sync::{Arc, Mutex};
67
get_test_service() -> binder::Strong<dyn ITestService::ITestService>68 fn get_test_service() -> binder::Strong<dyn ITestService::ITestService> {
69 binder::wait_for_interface(<BpTestService as ITestService::ITestService>::get_descriptor())
70 .expect("did not get binder service")
71 }
72
get_test_trunk_stable_service() -> binder::Strong<dyn ITrunkStableTest>73 fn get_test_trunk_stable_service() -> binder::Strong<dyn ITrunkStableTest> {
74 binder::wait_for_interface(<BpTrunkStableTest as ITrunkStableTest>::get_descriptor())
75 .expect("did not get binder service")
76 }
77
78 #[test]
test_constants()79 fn test_constants() {
80 assert_eq!(ITestService::A1, 1);
81 assert_eq!(ITestService::A2, 1);
82 assert_eq!(ITestService::A3, 1);
83 assert_eq!(ITestService::A4, 1);
84 assert_eq!(ITestService::A5, 1);
85 assert_eq!(ITestService::A6, 1);
86 assert_eq!(ITestService::A7, 1);
87 assert_eq!(ITestService::A8, 1);
88 assert_eq!(ITestService::A9, 1);
89 assert_eq!(ITestService::A10, 1);
90 assert_eq!(ITestService::A11, 1);
91 assert_eq!(ITestService::A12, 1);
92 assert_eq!(ITestService::A13, 1);
93 assert_eq!(ITestService::A14, 1);
94 assert_eq!(ITestService::A15, 1);
95 assert_eq!(ITestService::A16, 1);
96 assert_eq!(ITestService::A17, 1);
97 assert_eq!(ITestService::A18, 1);
98 assert_eq!(ITestService::A19, 1);
99 assert_eq!(ITestService::A20, 1);
100 assert_eq!(ITestService::A21, 1);
101 assert_eq!(ITestService::A22, 1);
102 assert_eq!(ITestService::A23, 1);
103 assert_eq!(ITestService::A24, 1);
104 assert_eq!(ITestService::A25, 1);
105 assert_eq!(ITestService::A26, 1);
106 assert_eq!(ITestService::A27, 1);
107 assert_eq!(ITestService::A28, 1);
108 assert_eq!(ITestService::A29, 1);
109 assert_eq!(ITestService::A30, 1);
110 assert_eq!(ITestService::A31, 1);
111 assert_eq!(ITestService::A32, 1);
112 assert_eq!(ITestService::A33, 1);
113 assert_eq!(ITestService::A34, 1);
114 assert_eq!(ITestService::A35, 1);
115 assert_eq!(ITestService::A36, 1);
116 assert_eq!(ITestService::A37, 1);
117 assert_eq!(ITestService::A38, 1);
118 assert_eq!(ITestService::A39, 1);
119 assert_eq!(ITestService::A40, 1);
120 assert_eq!(ITestService::A41, 1);
121 assert_eq!(ITestService::A42, 1);
122 assert_eq!(ITestService::A43, 1);
123 assert_eq!(ITestService::A44, 1);
124 assert_eq!(ITestService::A45, 1);
125 assert_eq!(ITestService::A46, 1);
126 assert_eq!(ITestService::A47, 1);
127 assert_eq!(ITestService::A48, 1);
128 assert_eq!(ITestService::A49, 1);
129 assert_eq!(ITestService::A50, 1);
130 assert_eq!(ITestService::A51, 1);
131 assert_eq!(ITestService::A52, 1);
132 assert_eq!(ITestService::A53, 1);
133 assert_eq!(ITestService::A54, 1);
134 assert_eq!(ITestService::A55, 1);
135 assert_eq!(ITestService::A56, 1);
136 assert_eq!(ITestService::A57, 1);
137 assert_eq!(ITestService::FLOAT_CONSTANT4, 2.2_f32);
138 assert_eq!(ITestService::FLOAT_CONSTANT5, -2.2_f32);
139 assert_eq!(ITestService::DOUBLE_CONSTANT4, 2.2_f64);
140 assert_eq!(ITestService::DOUBLE_CONSTANT5, -2.2_f64);
141 }
142
143 #[test]
test_oneway()144 fn test_oneway() {
145 let result = get_test_service().TestOneway();
146 assert_eq!(result, Ok(()));
147 }
148
149 macro_rules! test_primitive {
150 ($test:ident, $func:ident, $value:expr) => {
151 #[test]
152 fn $test() {
153 let value = $value;
154 let result = get_test_service().$func(value);
155 assert_eq!(result, Ok(value));
156 }
157 };
158 }
159
160 test_primitive! {test_primitive_bool_false, RepeatBoolean, false}
161 test_primitive! {test_primitive_bool_true, RepeatBoolean, true}
162 test_primitive! {test_primitive_byte, RepeatByte, -128i8}
163 test_primitive! {test_primitive_char, RepeatChar, 'A' as u16}
164 test_primitive! {test_primitive_int, RepeatInt, 1i32 << 30}
165 test_primitive! {test_primitive_long, RepeatLong, 1i64 << 60}
166 test_primitive! {test_primitive_float, RepeatFloat, 1.0f32 / 3.0f32}
167 test_primitive! {test_primitive_double, RepeatDouble, 1.0f64 / 3.0f64}
168 test_primitive! {test_primitive_byte_constant, RepeatByte, ITestService::BYTE_CONSTANT}
169 test_primitive! {test_primitive_constant1, RepeatInt, ITestService::CONSTANT}
170 test_primitive! {test_primitive_constant2, RepeatInt, ITestService::CONSTANT2}
171 test_primitive! {test_primitive_constant3, RepeatInt, ITestService::CONSTANT3}
172 test_primitive! {test_primitive_constant4, RepeatInt, ITestService::CONSTANT4}
173 test_primitive! {test_primitive_constant5, RepeatInt, ITestService::CONSTANT5}
174 test_primitive! {test_primitive_constant6, RepeatInt, ITestService::CONSTANT6}
175 test_primitive! {test_primitive_constant7, RepeatInt, ITestService::CONSTANT7}
176 test_primitive! {test_primitive_constant8, RepeatInt, ITestService::CONSTANT8}
177 test_primitive! {test_primitive_constant9, RepeatInt, ITestService::CONSTANT9}
178 test_primitive! {test_primitive_constant10, RepeatInt, ITestService::CONSTANT10}
179 test_primitive! {test_primitive_constant11, RepeatInt, ITestService::CONSTANT11}
180 test_primitive! {test_primitive_constant12, RepeatInt, ITestService::CONSTANT12}
181 test_primitive! {test_primitive_long_constant, RepeatLong, ITestService::LONG_CONSTANT}
182 test_primitive! {test_primitive_byte_enum, RepeatByteEnum, ByteEnum::FOO}
183 test_primitive! {test_primitive_int_enum, RepeatIntEnum, IntEnum::BAR}
184 test_primitive! {test_primitive_int_enum_undefined, RepeatIntEnum, IntEnum(12)}
185 test_primitive! {test_primitive_int_enum_bitwise_or, RepeatIntEnum, IntEnum::FOO | IntEnum::BAR}
186 test_primitive! {test_primitive_int_enum_bitwise_and, RepeatIntEnum, IntEnum::FOO & IntEnum::BAR}
187 test_primitive! {test_primitive_int_enum_bitwise_xor, RepeatIntEnum, IntEnum::FOO ^ IntEnum::BAR}
188 test_primitive! {test_primitive_long_enum, RepeatLongEnum, LongEnum::FOO}
189 test_primitive! {test_primitive_float_constant, RepeatFloat, ITestService::FLOAT_CONSTANT}
190 test_primitive! {test_primitive_float_constant2, RepeatFloat, ITestService::FLOAT_CONSTANT2}
191 test_primitive! {test_primitive_float_constant3, RepeatFloat, ITestService::FLOAT_CONSTANT3}
192 test_primitive! {test_primitive_float_constant4, RepeatFloat, ITestService::FLOAT_CONSTANT4}
193 test_primitive! {test_primitive_float_constant5, RepeatFloat, ITestService::FLOAT_CONSTANT5}
194 test_primitive! {test_primitive_float_constant6, RepeatFloat, ITestService::FLOAT_CONSTANT6}
195 test_primitive! {test_primitive_float_constant7, RepeatFloat, ITestService::FLOAT_CONSTANT7}
196 test_primitive! {test_primitive_double_constant, RepeatDouble, ITestService::DOUBLE_CONSTANT}
197 test_primitive! {test_primitive_double_constant2, RepeatDouble, ITestService::DOUBLE_CONSTANT2}
198 test_primitive! {test_primitive_double_constant3, RepeatDouble, ITestService::DOUBLE_CONSTANT3}
199 test_primitive! {test_primitive_double_constant4, RepeatDouble, ITestService::DOUBLE_CONSTANT4}
200 test_primitive! {test_primitive_double_constant5, RepeatDouble, ITestService::DOUBLE_CONSTANT5}
201 test_primitive! {test_primitive_double_constant6, RepeatDouble, ITestService::DOUBLE_CONSTANT6}
202 test_primitive! {test_primitive_double_constant7, RepeatDouble, ITestService::DOUBLE_CONSTANT7}
203
204 #[test]
test_repeat_string()205 fn test_repeat_string() {
206 let service = get_test_service();
207 let inputs = [
208 "typical string".into(),
209 String::new(),
210 "\0\0".into(),
211 // This is actually two unicode code points:
212 // U+10437: The 'small letter yee' character in the deseret alphabet
213 // U+20AC: A euro sign
214 String::from_utf16(&[0xD801, 0xDC37, 0x20AC]).expect("error converting string"),
215 ITestService::STRING_CONSTANT.into(),
216 ITestService::STRING_CONSTANT2.into(),
217 ];
218 for input in &inputs {
219 let result = service.RepeatString(input);
220 assert_eq!(result.as_ref(), Ok(input));
221 }
222 }
223
224 #[test]
test_enum_or()225 fn test_enum_or() {
226 assert_eq!(IntEnum::FOO | IntEnum::BAR, IntEnum(1000 | 2000));
227 }
228
229 #[test]
test_enum_or_assign()230 fn test_enum_or_assign() {
231 let mut var = IntEnum(0);
232 var |= IntEnum::FOO;
233 assert_eq!(var, IntEnum::FOO);
234 var |= IntEnum::BAR;
235 assert_eq!(var, IntEnum::FOO | IntEnum::BAR)
236 }
237
238 #[test]
test_enum_xor()239 fn test_enum_xor() {
240 assert_eq!(IntEnum(0) ^ IntEnum::BAR, IntEnum::BAR);
241
242 let var_both = IntEnum::FOO | IntEnum::BAR;
243 let int_both = 1000 | 2000;
244 assert_eq!(var_both ^ IntEnum::BAR, IntEnum(int_both ^ 2000));
245 assert_eq!(var_both ^ IntEnum::FOO, IntEnum(int_both ^ 1000));
246 }
247
248 #[test]
test_enum_xor_assign()249 fn test_enum_xor_assign() {
250 let mut var = IntEnum(0);
251 var ^= IntEnum::BAR;
252 assert_eq!(var, IntEnum::BAR);
253
254 var = IntEnum::FOO | IntEnum::BAR;
255 var ^= IntEnum::BAR;
256 assert_eq!(var, IntEnum((1000 | 2000) ^ 2000));
257 }
258
259 #[test]
test_enum_and()260 fn test_enum_and() {
261 assert_eq!(IntEnum::FOO & IntEnum::BAR, IntEnum(1000 & 2000));
262
263 let var_both = IntEnum::FOO | IntEnum::BAR;
264 assert_eq!(var_both & IntEnum::BAR, IntEnum::BAR);
265 assert_eq!(var_both & IntEnum::FOO, IntEnum::FOO);
266 }
267
268 #[test]
test_enum_and_assign()269 fn test_enum_and_assign() {
270 let mut var = IntEnum(0x7FFFFFFF);
271 var &= IntEnum::FOO;
272 assert_eq!(var, IntEnum::FOO);
273 var &= IntEnum(0);
274 assert_eq!(var, IntEnum(0));
275
276 var = IntEnum(0x7FFFFFFF);
277 var &= IntEnum(0xFF);
278 assert_eq!(var, IntEnum(0xFF));
279 }
280
281 #[test]
test_enum_shift()282 fn test_enum_shift() {
283 assert_eq!(IntEnum(1 << IntEnum::ZERO.get()), IntEnum(0b1));
284 assert_eq!(IntEnum(1 << IntEnum::ONE.get()), IntEnum(0b10));
285 assert_eq!(IntEnum(1 << IntEnum::TWO.get()), IntEnum(0b100));
286 }
287
288 #[test]
test_repeat_parcelable()289 fn test_repeat_parcelable() {
290 let service = get_test_service();
291 let input = SimpleParcelable { name: "foo".to_string(), number: 42 };
292 let mut out_param = SimpleParcelable::default();
293 let returned = service.RepeatSimpleParcelable(&input, &mut out_param);
294 assert_eq!(returned, Ok(input.clone()));
295 assert_eq!(out_param, input);
296 }
297
298 macro_rules! test_reverse_array {
299 ($test:ident, $func:ident, $array:expr) => {
300 #[test]
301 fn $test() {
302 let mut array = $array.to_vec();
303
304 // Java needs initial values here (can't resize arrays)
305 let mut repeated = vec![Default::default(); array.len()];
306
307 let result = get_test_service().$func(&array, &mut repeated);
308 assert_eq!(repeated, array);
309 array.reverse();
310 assert_eq!(result, Ok(array));
311 }
312 };
313 }
314
315 test_reverse_array! {test_array_boolean, ReverseBoolean, [true, false, false]}
316 test_reverse_array! {test_array_byte, ReverseByte, [255u8, 0u8, 127u8]}
317 test_reverse_array! {
318 service,
319 ReverseChar,
320 ['A' as u16, 'B' as u16, 'C' as u16]
321 }
322 test_reverse_array! {test_array_int, ReverseInt, [1, 2, 3]}
323 test_reverse_array! {test_array_long, ReverseLong, [-1i64, 0i64, 1i64 << 60]}
324 test_reverse_array! {test_array_float, ReverseFloat, [-0.3f32, -0.7f32, 8.0f32]}
325 test_reverse_array! {
326 test_array_double,
327 ReverseDouble,
328 [1.0f64 / 3.0f64, 1.0f64 / 7.0f64, 42.0f64]
329 }
330 test_reverse_array! {
331 test_array_string,
332 ReverseString,
333 ["f".into(), "a".into(), "b".into()]
334 }
335 test_reverse_array! {
336 test_array_byte_enum,
337 ReverseByteEnum,
338 [ByteEnum::FOO, ByteEnum::BAR, ByteEnum::BAR]
339 }
340 test_reverse_array! {
341 test_array_byte_enum_values,
342 ReverseByteEnum,
343 ByteEnum::enum_values()
344 }
345 test_reverse_array! {
346 test_array_byte_enum_v2,
347 ReverseByteEnum,
348 [ByteEnum::FOO, ByteEnum::BAR, ByteEnum::BAZ]
349 }
350 test_reverse_array! {
351 test_array_int_enum,
352 ReverseIntEnum,
353 [IntEnum::FOO, IntEnum::BAR, IntEnum::BAR]
354 }
355 test_reverse_array! {
356 test_array_long_enum,
357 ReverseLongEnum,
358 [LongEnum::FOO, LongEnum::BAR, LongEnum::BAR]
359 }
360 test_reverse_array! {
361 test_array_string_list,
362 ReverseStringList,
363 ["f".into(), "a".into(), "b".into()]
364 }
365 test_reverse_array! {
366 test_array_utf8_string,
367 ReverseUtf8CppString,
368 [
369 "a".into(),
370 String::new(),
371 std::str::from_utf8(&[0xC3, 0xB8])
372 .expect("error converting string")
373 .into(),
374 ]
375 }
376 test_reverse_array! {
377 test_reverse_parcelable,
378 ReverseSimpleParcelables,
379 [
380 SimpleParcelable {name: "a".to_string(), number: 1 },
381 SimpleParcelable {name: "b".to_string(), number: 2 },
382 SimpleParcelable {name: "c".to_string(), number: 3 },
383 ]
384 }
385
386 #[test]
test_binder_exchange()387 fn test_binder_exchange() {
388 const NAME: &str = "Smythe";
389 let service = get_test_service();
390 let got = service.GetOtherTestService(NAME).expect("error calling GetOtherTestService");
391 assert_eq!(got.GetName().as_ref().map(String::as_ref), Ok(NAME));
392 assert_eq!(service.VerifyName(&got, NAME), Ok(true));
393 }
394
395 #[test]
test_binder_array_exchange()396 fn test_binder_array_exchange() {
397 let names = vec!["Fizz".into(), "Buzz".into()];
398 let service = get_test_service();
399 let got = service.GetInterfaceArray(&names).expect("error calling GetInterfaceArray");
400 assert_eq!(got.iter().map(|s| s.GetName()).collect::<Result<Vec<_>, _>>(), Ok(names.clone()));
401 assert_eq!(service.VerifyNamesWithInterfaceArray(&got, &names), Ok(true));
402 }
403
404 #[test]
test_binder_nullable_array_exchange()405 fn test_binder_nullable_array_exchange() {
406 let names = vec![Some("Fizz".into()), None, Some("Buzz".into())];
407 let service = get_test_service();
408 let got = service
409 .GetNullableInterfaceArray(Some(&names))
410 .expect("error calling GetNullableInterfaceArray");
411 assert_eq!(
412 got.as_ref().map(|arr| arr
413 .iter()
414 .map(|opt_s| opt_s.as_ref().map(|s| s.GetName().expect("error calling GetName")))
415 .collect::<Vec<_>>()),
416 Some(names.clone())
417 );
418 assert_eq!(
419 service.VerifyNamesWithNullableInterfaceArray(got.as_ref().map(|v| &v[..]), Some(&names)),
420 Ok(true)
421 );
422 }
423
424 #[test]
test_interface_list_exchange()425 fn test_interface_list_exchange() {
426 let names = vec![Some("Fizz".into()), None, Some("Buzz".into())];
427 let service = get_test_service();
428 let got = service.GetInterfaceList(Some(&names)).expect("error calling GetInterfaceList");
429 assert_eq!(
430 got.as_ref().map(|arr| arr
431 .iter()
432 .map(|opt_s| opt_s.as_ref().map(|s| s.GetName().expect("error calling GetName")))
433 .collect::<Vec<_>>()),
434 Some(names.clone())
435 );
436 assert_eq!(
437 service.VerifyNamesWithInterfaceList(got.as_ref().map(|v| &v[..]), Some(&names)),
438 Ok(true)
439 );
440 }
441
build_pipe() -> (OwnedFd, OwnedFd)442 fn build_pipe() -> (OwnedFd, OwnedFd) {
443 // Safety: we get two file descriptors from pipe()
444 // and pass them after checking if the function returned
445 // without an error, so the descriptors should be valid
446 // by that point
447 unsafe {
448 let mut fds = [0, 0];
449 if libc::pipe(fds.as_mut_ptr()) != 0 {
450 panic!("pipe() error");
451 }
452 (OwnedFd::from_raw_fd(fds[0]), OwnedFd::from_raw_fd(fds[1]))
453 }
454 }
455
456 /// Helper function that constructs a `File` from a `ParcelFileDescriptor`.
457 ///
458 /// This is needed because `File` is currently the way to read and write
459 /// to pipes using the `Read` and `Write` traits.
file_from_pfd(fd: &binder::ParcelFileDescriptor) -> File460 fn file_from_pfd(fd: &binder::ParcelFileDescriptor) -> File {
461 fd.as_ref().try_clone().expect("failed to clone file descriptor").into()
462 }
463
464 #[test]
test_parcel_file_descriptor()465 fn test_parcel_file_descriptor() {
466 let service = get_test_service();
467 let (read_fd, write_fd) = build_pipe();
468 let mut read_file = File::from(read_fd);
469
470 let write_pfd = binder::ParcelFileDescriptor::new(write_fd);
471 let result_pfd = service
472 .RepeatParcelFileDescriptor(&write_pfd)
473 .expect("error calling RepeatParcelFileDescriptor");
474
475 const TEST_DATA: &[u8] = b"FrazzleSnazzleFlimFlamFlibbityGumboChops";
476 file_from_pfd(&result_pfd).write_all(TEST_DATA).expect("error writing to pipe");
477
478 let mut buf = [0u8; TEST_DATA.len()];
479 read_file.read_exact(&mut buf).expect("error reading from pipe");
480 assert_eq!(&buf[..], TEST_DATA);
481 }
482
483 #[test]
test_parcel_file_descriptor_array()484 fn test_parcel_file_descriptor_array() {
485 let service = get_test_service();
486
487 let (read_fd, write_fd) = build_pipe();
488 let input =
489 [binder::ParcelFileDescriptor::new(read_fd), binder::ParcelFileDescriptor::new(write_fd)];
490
491 let mut repeated = vec![];
492
493 let backend = service.getBackendType().expect("error getting backend type");
494 if backend == BackendType::JAVA {
495 // Java needs initial values here (can't resize arrays)
496 // Other backends can't accept 'None', but we can use it in Java for convenience, rather
497 // than creating file descriptors.
498 repeated = vec![None, None];
499 }
500
501 let result = service
502 .ReverseParcelFileDescriptorArray(&input[..], &mut repeated)
503 .expect("error calling ReverseParcelFileDescriptorArray");
504
505 file_from_pfd(&input[1]).write_all(b"First").expect("error writing to pipe");
506 file_from_pfd(repeated[1].as_ref().expect("received None for ParcelFileDescriptor"))
507 .write_all(b"Second")
508 .expect("error writing to pipe");
509 file_from_pfd(&result[0]).write_all(b"Third").expect("error writing to pipe");
510
511 const TEST_DATA: &[u8] = b"FirstSecondThird";
512 let mut buf = [0u8; TEST_DATA.len()];
513 file_from_pfd(&input[0]).read_exact(&mut buf).expect("error reading from pipe");
514 assert_eq!(&buf[..], TEST_DATA);
515 }
516
517 #[test]
test_service_specific_exception()518 fn test_service_specific_exception() {
519 let service = get_test_service();
520
521 for i in -1..2 {
522 let result = service.ThrowServiceException(i);
523 assert!(result.is_err());
524
525 let status = result.unwrap_err();
526 assert_eq!(status.exception_code(), binder::ExceptionCode::SERVICE_SPECIFIC);
527 assert_eq!(status.service_specific_error(), i);
528 }
529 }
530
531 macro_rules! test_nullable {
532 ($test:ident, $func:ident, $value:expr) => {
533 #[test]
534 fn $test() {
535 let service = get_test_service();
536 let value = Some($value);
537 let result = service.$func(value.as_deref());
538 assert_eq!(result, Ok(value));
539
540 let result = service.$func(None);
541 assert_eq!(result, Ok(None));
542 }
543 };
544 }
545
546 test_nullable! {test_nullable_array_int, RepeatNullableIntArray, vec![1, 2, 3]}
547 test_nullable! {
548 test_nullable_array_byte_enum,
549 RepeatNullableByteEnumArray,
550 vec![ByteEnum::FOO, ByteEnum::BAR]
551 }
552 test_nullable! {
553 test_nullable_array_int_enum,
554 RepeatNullableIntEnumArray,
555 vec![IntEnum::FOO, IntEnum::BAR]
556 }
557 test_nullable! {
558 test_nullable_array_long_enum,
559 RepeatNullableLongEnumArray,
560 vec![LongEnum::FOO, LongEnum::BAR]
561 }
562 test_nullable! {test_nullable_string, RepeatNullableString, "Blooob".into()}
563 test_nullable! {
564 test_nullable_string_list,
565 RepeatNullableStringList,
566 vec![
567 Some("Wat".into()),
568 Some("Blooob".into()),
569 Some("Wat".into()),
570 None,
571 Some("YEAH".into()),
572 Some("OKAAAAY".into()),
573 ]
574 }
575
576 #[test]
test_nullable_parcelable()577 fn test_nullable_parcelable() {
578 let value = Empty {};
579
580 let service = get_test_service();
581 let value = Some(value);
582 let result = service.RepeatNullableParcelable(value.as_ref());
583 assert_eq!(result, Ok(value));
584
585 let result = service.RepeatNullableParcelable(None);
586 assert_eq!(result, Ok(None));
587 }
588
589 test_nullable! {
590 test_nullable_parcelable_array,
591 RepeatNullableParcelableArray,
592 vec![
593 Some(Empty {}),
594 None,
595 ]
596 }
597
598 test_nullable! {
599 test_nullable_parcelable_list,
600 RepeatNullableParcelableList,
601 vec![
602 Some(Empty {}),
603 None,
604 ]
605 }
606
607 #[test]
test_binder()608 fn test_binder() {
609 let service = get_test_service();
610 assert!(service.GetCallback(true).expect("error calling GetCallback").is_none());
611 let callback = service
612 .GetCallback(false)
613 .expect("error calling GetCallback")
614 .expect("expected Some from GetCallback");
615
616 // We don't have any place to get a fresh `SpIBinder`, so we
617 // reuse the interface for the binder tests
618 let binder = callback.as_binder();
619 assert_eq!(service.TakesAnIBinder(&binder), Ok(()));
620 assert_eq!(service.TakesANullableIBinder(None), Ok(()));
621 assert_eq!(service.TakesANullableIBinder(Some(&binder)), Ok(()));
622 }
623
624 macro_rules! test_reverse_null_array {
625 ($service:expr, $func:ident, $expect_repeated:expr) => {{
626 let mut repeated = None;
627 let result = $service.$func(None, &mut repeated);
628 assert_eq!(repeated, $expect_repeated);
629 assert_eq!(result, Ok(None));
630 }};
631 }
632
633 macro_rules! test_reverse_nullable_array {
634 ($service:expr, $func:ident, $array:expr) => {{
635 let mut array = $array;
636 // Java needs initial values here (can't resize arrays)
637 let mut repeated = Some(vec![Default::default(); array.len()]);
638 let result = $service.$func(Some(&array[..]), &mut repeated);
639 assert_eq!(repeated.as_ref(), Some(&array));
640 array.reverse();
641 assert_eq!(result, Ok(Some(array)));
642 }};
643 }
644
645 #[test]
test_utf8_string()646 fn test_utf8_string() {
647 let service = get_test_service();
648 let inputs = [
649 "typical string",
650 "",
651 "\0\0",
652 std::str::from_utf8(&[0xF0, 0x90, 0x90, 0xB7, 0xE2, 0x82, 0xAC])
653 .expect("error converting string"),
654 ITestService::STRING_CONSTANT_UTF8,
655 ];
656 for input in &inputs {
657 let result = service.RepeatUtf8CppString(input);
658 assert_eq!(result.as_ref().map(String::as_str), Ok(*input));
659
660 let result = service.RepeatNullableUtf8CppString(Some(input));
661 assert_eq!(result.as_ref().map(Option::as_deref), Ok(Some(*input)));
662 }
663
664 let result = service.RepeatNullableUtf8CppString(None);
665 assert_eq!(result, Ok(None));
666
667 let inputs = vec![
668 Some("typical string".into()),
669 Some(String::new()),
670 None,
671 Some(
672 std::str::from_utf8(&[0xF0, 0x90, 0x90, 0xB7, 0xE2, 0x82, 0xAC])
673 .expect("error converting string")
674 .into(),
675 ),
676 Some(ITestService::STRING_CONSTANT_UTF8.into()),
677 ];
678
679 // Java can't return a null list as a parameter
680 let backend = service.getBackendType().expect("error getting backend type");
681 let null_output = if backend == BackendType::JAVA { Some(vec![]) } else { None };
682 test_reverse_null_array!(service, ReverseUtf8CppStringList, null_output);
683
684 test_reverse_null_array!(service, ReverseNullableUtf8CppString, None);
685
686 test_reverse_nullable_array!(service, ReverseUtf8CppStringList, inputs.clone());
687 test_reverse_nullable_array!(service, ReverseNullableUtf8CppString, inputs);
688 }
689
690 #[allow(clippy::approx_constant)]
691 #[allow(clippy::float_cmp)]
692 #[test]
test_parcelable()693 fn test_parcelable() {
694 let service = get_test_service();
695 let mut parcelable = StructuredParcelable::StructuredParcelable::default();
696
697 const DESIRED_VALUE: i32 = 23;
698 parcelable.f = DESIRED_VALUE;
699
700 assert_eq!(parcelable.stringDefaultsToFoo, "foo");
701 assert_eq!(parcelable.byteDefaultsToFour, 4);
702 assert_eq!(parcelable.intDefaultsToFive, 5);
703 assert_eq!(parcelable.longDefaultsToNegativeSeven, -7);
704 assert!(parcelable.booleanDefaultsToTrue);
705 assert_eq!(parcelable.charDefaultsToC, 'C' as u16);
706 assert_eq!(parcelable.floatDefaultsToPi, 3.14f32);
707 assert_eq!(parcelable.doubleWithDefault, -3.14e17f64);
708 assert!(!parcelable.boolDefault);
709 assert_eq!(parcelable.byteDefault, 0);
710 assert_eq!(parcelable.intDefault, 0);
711 assert_eq!(parcelable.longDefault, 0);
712 assert_eq!(parcelable.floatDefault, 0.0f32);
713 assert_eq!(parcelable.doubleDefault, 0.0f64);
714 assert_eq!(parcelable.arrayDefaultsTo123, &[1, 2, 3]);
715 assert!(parcelable.arrayDefaultsToEmpty.is_empty());
716
717 let result = service.FillOutStructuredParcelable(&mut parcelable);
718 assert_eq!(result, Ok(()));
719
720 assert_eq!(parcelable.shouldContainThreeFs, [DESIRED_VALUE, DESIRED_VALUE, DESIRED_VALUE]);
721 assert_eq!(parcelable.shouldBeJerry, "Jerry");
722 assert_eq!(parcelable.int32_min, i32::MIN);
723 assert_eq!(parcelable.int32_max, i32::MAX);
724 assert_eq!(parcelable.int64_max, i64::MAX);
725 assert_eq!(parcelable.hexInt32_neg_1, -1);
726 for i in parcelable.int8_1 {
727 assert_eq!(i, 1);
728 }
729 for i in parcelable.int32_1 {
730 assert_eq!(i, 1);
731 }
732 for i in parcelable.int64_1 {
733 assert_eq!(i, 1);
734 }
735 assert_eq!(parcelable.hexInt32_pos_1, 1);
736 assert_eq!(parcelable.hexInt64_pos_1, 1);
737 assert_eq!(parcelable.const_exprs_1.0, 1);
738 assert_eq!(parcelable.const_exprs_2.0, 1);
739 assert_eq!(parcelable.const_exprs_3.0, 1);
740 assert_eq!(parcelable.const_exprs_4.0, 1);
741 assert_eq!(parcelable.const_exprs_5.0, 1);
742 assert_eq!(parcelable.const_exprs_6.0, 1);
743 assert_eq!(parcelable.const_exprs_7.0, 1);
744 assert_eq!(parcelable.const_exprs_8.0, 1);
745 assert_eq!(parcelable.const_exprs_9.0, 1);
746 assert_eq!(parcelable.const_exprs_10.0, 1);
747 assert_eq!(parcelable.addString1, "hello world!");
748 assert_eq!(parcelable.addString2, "The quick brown fox jumps over the lazy dog.");
749
750 assert_eq!(
751 parcelable.shouldSetBit0AndBit2,
752 StructuredParcelable::BIT0 | StructuredParcelable::BIT2
753 );
754
755 assert_eq!(parcelable.u, Some(Union::Union::Ns(vec![1, 2, 3])));
756 assert_eq!(parcelable.shouldBeConstS1, Some(Union::Union::S(Union::S1.to_string())))
757 }
758
759 #[test]
test_repeat_extendable_parcelable()760 fn test_repeat_extendable_parcelable() {
761 let service = get_test_service();
762
763 let ext = Arc::new(MyExt { a: 42, b: "EXT".into() });
764 let mut ep = ExtendableParcelable { a: 1, b: "a".into(), c: 42, ..Default::default() };
765 ep.ext.set_parcelable(Arc::clone(&ext)).expect("error setting parcelable");
766
767 let mut ep2 = ExtendableParcelable::default();
768 let result = service.RepeatExtendableParcelable(&ep, &mut ep2);
769 assert_eq!(result, Ok(()));
770 assert_eq!(ep2.a, ep.a);
771 assert_eq!(ep2.b, ep.b);
772
773 let ret_ext = ep2.ext.get_parcelable::<MyExt>().expect("error getting parcelable");
774 assert!(ret_ext.is_some());
775
776 let ret_ext = ret_ext.unwrap();
777 assert_eq!(ret_ext.a, ext.a);
778 assert_eq!(ret_ext.b, ext.b);
779 }
780
781 #[test]
test_repeat_extendable_parcelable_vintf()782 fn test_repeat_extendable_parcelable_vintf() {
783 let service = get_test_service();
784
785 let inner_vintf = Arc::new(VintfParcelable { a: 5 });
786
787 let mut vintf_ext = VintfExtendableParcelable::default();
788 vintf_ext.ext.set_parcelable(inner_vintf.clone()).unwrap();
789 let vintf_ext = Arc::new(vintf_ext);
790
791 let mut ep = ExtendableParcelable { a: 1, b: "a".into(), c: 42, ..Default::default() };
792 ep.ext.set_parcelable(Arc::clone(&vintf_ext)).expect("error setting parcelable");
793
794 let mut ep2 = ExtendableParcelable::default();
795 let result = service.RepeatExtendableParcelableVintf(&ep, &mut ep2);
796 assert_eq!(result, Ok(()));
797 assert_eq!(ep2.a, ep.a);
798 assert_eq!(ep2.b, ep.b);
799
800 let ret_ext = ep2
801 .ext
802 .get_parcelable::<VintfExtendableParcelable>()
803 .expect("error getting parcelable")
804 .expect("get_parcelable returned None");
805 let ret_inner = ret_ext
806 .ext
807 .get_parcelable::<VintfParcelable>()
808 .expect("error getting parcelable")
809 .expect("get_parcelable returned None");
810 assert_eq!(ret_inner.a, inner_vintf.a);
811 }
812
813 macro_rules! test_parcelable_holder_stability {
814 ($test:ident, $holder:path, $parcelable:path) => {
815 #[test]
816 fn $test() {
817 let mut holder = <$holder>::default();
818 let parcelable = Arc::new(<$parcelable>::default());
819 let result = holder.ext.set_parcelable(Arc::clone(&parcelable));
820 assert_eq!(result, Ok(()));
821
822 let parcelable2 = holder.ext.get_parcelable::<$parcelable>().unwrap().unwrap();
823 assert!(Arc::ptr_eq(&parcelable, &parcelable2));
824 }
825 };
826 }
827
828 test_parcelable_holder_stability! {
829 test_vintf_parcelable_holder_can_contain_vintf_parcelable,
830 VintfExtendableParcelable,
831 VintfParcelable
832 }
833 test_parcelable_holder_stability! {
834 test_stable_parcelable_holder_can_contain_vintf_parcelable,
835 NonVintfExtendableParcelable,
836 VintfParcelable
837 }
838 test_parcelable_holder_stability! {
839 test_stable_parcelable_holder_can_contain_non_vintf_parcelable,
840 NonVintfExtendableParcelable,
841 NonVintfParcelable
842 }
843 test_parcelable_holder_stability! {
844 test_stable_parcelable_holder_can_contain_unstable_parcelable,
845 NonVintfExtendableParcelable,
846 UnstableParcelable
847 }
848 test_parcelable_holder_stability! {
849 test_unstable_parcelable_holder_can_contain_vintf_parcelable,
850 UnstableExtendableParcelable,
851 VintfParcelable
852 }
853 test_parcelable_holder_stability! {
854 test_unstable_parcelable_holder_can_contain_non_vintf_parcelable,
855 UnstableExtendableParcelable,
856 NonVintfParcelable
857 }
858 test_parcelable_holder_stability! {
859 test_unstable_parcelable_holder_can_contain_unstable_parcelable,
860 UnstableExtendableParcelable,
861 UnstableParcelable
862 }
863
864 #[test]
test_vintf_parcelable_holder_cannot_contain_not_vintf_parcelable()865 fn test_vintf_parcelable_holder_cannot_contain_not_vintf_parcelable() {
866 let mut holder = VintfExtendableParcelable::default();
867 let parcelable = Arc::new(NonVintfParcelable::default());
868 let result = holder.ext.set_parcelable(Arc::clone(&parcelable));
869 assert_eq!(result, Err(binder::StatusCode::BAD_VALUE));
870
871 let parcelable2 = holder.ext.get_parcelable::<NonVintfParcelable>();
872 assert!(parcelable2.unwrap().is_none());
873 }
874
875 #[test]
test_vintf_parcelable_holder_cannot_contain_unstable_parcelable()876 fn test_vintf_parcelable_holder_cannot_contain_unstable_parcelable() {
877 let mut holder = VintfExtendableParcelable::default();
878 let parcelable = Arc::new(UnstableParcelable::default());
879 let result = holder.ext.set_parcelable(Arc::clone(&parcelable));
880 assert_eq!(result, Err(binder::StatusCode::BAD_VALUE));
881
882 let parcelable2 = holder.ext.get_parcelable::<UnstableParcelable>();
883 assert!(parcelable2.unwrap().is_none());
884 }
885
886 #[test]
test_read_write_extension()887 fn test_read_write_extension() {
888 let ext = Arc::new(MyExt { a: 42, b: "EXT".into() });
889 let ext2 = Arc::new(MyExt2 { a: 42, b: MyExt { a: 24, b: "INEXT".into() }, c: "EXT2".into() });
890
891 let mut ep = ExtendableParcelable { a: 1, b: "a".into(), c: 42, ..Default::default() };
892
893 ep.ext.set_parcelable(Arc::clone(&ext)).unwrap();
894 ep.ext2.set_parcelable(Arc::clone(&ext2)).unwrap();
895
896 let ext_like = ep.ext.get_parcelable::<MyExtLike>();
897 assert_eq!(ext_like.unwrap_err(), binder::StatusCode::BAD_VALUE);
898
899 let actual_ext = ep.ext.get_parcelable::<MyExt>();
900 assert!(actual_ext.unwrap().is_some());
901 let actual_ext2 = ep.ext2.get_parcelable::<MyExt2>();
902 assert!(actual_ext2.unwrap().is_some());
903
904 check_extension_content(&ep, &ext, &ext2);
905
906 let mut parcel = Parcel::new();
907 ep.write_to_parcel(&mut parcel.borrowed()).unwrap();
908
909 // SAFETY: 0 is less than the current size of the parcel data buffer, because the parcel is not
910 // empty.
911 unsafe {
912 parcel.set_data_position(0).unwrap();
913 }
914 let mut ep1 = ExtendableParcelable::default();
915 ep1.read_from_parcel(parcel.borrowed_ref()).unwrap();
916
917 // SAFETY: 0 is less than the current size of the parcel data buffer, because the parcel is not
918 // empty.
919 unsafe {
920 parcel.set_data_position(0).unwrap();
921 }
922 ep1.write_to_parcel(&mut parcel.borrowed()).unwrap();
923
924 // SAFETY: 0 is less than the current size of the parcel data buffer, because the parcel is not
925 // empty.
926 unsafe {
927 parcel.set_data_position(0).unwrap();
928 }
929 let mut ep2 = ExtendableParcelable::default();
930 ep2.read_from_parcel(parcel.borrowed_ref()).unwrap();
931
932 let ext_like = ep2.ext.get_parcelable::<MyExtLike>();
933 assert!(ext_like.unwrap().is_none());
934
935 let actual_ext = ep2.ext.get_parcelable::<MyExt>();
936 assert!(actual_ext.unwrap().is_some());
937
938 let new_ext2 =
939 Arc::new(MyExt2 { a: 79, b: MyExt { a: 42, b: "INNEWEXT".into() }, c: "NEWEXT2".into() });
940 ep2.ext2.set_parcelable(Arc::clone(&new_ext2)).unwrap();
941
942 check_extension_content(&ep1, &ext, &ext2);
943 check_extension_content(&ep2, &ext, &new_ext2);
944 }
945
check_extension_content(ep: &ExtendableParcelable, ext: &MyExt, ext2: &MyExt2)946 fn check_extension_content(ep: &ExtendableParcelable, ext: &MyExt, ext2: &MyExt2) {
947 assert_eq!(ep.a, 1);
948 assert_eq!(ep.b, "a");
949 assert_eq!(ep.c, 42);
950
951 let actual_ext = ep.ext.get_parcelable::<MyExt>().unwrap().unwrap();
952 assert_eq!(ext.a, actual_ext.a);
953 assert_eq!(ext.b, actual_ext.b);
954
955 let actual_ext2 = ep.ext2.get_parcelable::<MyExt2>().unwrap().unwrap();
956 assert_eq!(ext2.a, actual_ext2.a);
957 assert_eq!(ext2.b.a, actual_ext2.b.a);
958 assert_eq!(ext2.b.b, actual_ext2.b.b);
959 assert_eq!(ext2.c, actual_ext2.c);
960 }
961
962 #[test]
test_reverse_recursive_list()963 fn test_reverse_recursive_list() {
964 let service = get_test_service();
965
966 let mut head = None;
967 for n in 0..10 {
968 let node = RecursiveList { value: n, next: head };
969 head = Some(Box::new(node));
970 }
971 // head = [9, 8, .., 0]
972 let result = service.ReverseList(head.as_ref().unwrap());
973 assert!(result.is_ok());
974
975 // reversed should be [0, 1, ... 9]
976 let mut reversed: Option<&RecursiveList> = result.as_ref().ok();
977 for n in 0..10 {
978 assert_eq!(reversed.map(|inner| inner.value), Some(n));
979 reversed = reversed.unwrap().next.as_ref().map(|n| n.as_ref());
980 }
981 assert!(reversed.is_none())
982 }
983
984 #[test]
test_get_union_tags()985 fn test_get_union_tags() {
986 let service = get_test_service();
987 let result = service.GetUnionTags(&[]);
988 assert_eq!(result, Ok(vec![]));
989 let result = service.GetUnionTags(&[Union::Union::N(0), Union::Union::Ns(vec![])]);
990 assert_eq!(result, Ok(vec![Union::Tag::Tag::n, Union::Tag::Tag::ns]));
991 }
992
993 #[test]
test_unions()994 fn test_unions() {
995 assert_eq!(Union::Union::default(), Union::Union::Ns(vec![]));
996 assert_eq!(EnumUnion::default(), EnumUnion::IntEnum(IntEnum::FOO));
997 }
998
999 const EXPECTED_ARG_VALUE: i32 = 100;
1000 const EXPECTED_RETURN_VALUE: i32 = 200;
1001
1002 struct TestDefaultImpl;
1003
1004 impl binder::Interface for TestDefaultImpl {}
1005
1006 impl ITestServiceDefault for TestDefaultImpl {
UnimplementedMethod(&self, arg: i32) -> binder::Result<i32>1007 fn UnimplementedMethod(&self, arg: i32) -> binder::Result<i32> {
1008 assert_eq!(arg, EXPECTED_ARG_VALUE);
1009 Ok(EXPECTED_RETURN_VALUE)
1010 }
1011 }
1012
1013 #[test]
test_default_impl()1014 fn test_default_impl() {
1015 let service = get_test_service();
1016 let di: ITestServiceDefaultRef = Some(Arc::new(TestDefaultImpl));
1017 <BpTestService as ITestService::ITestService>::setDefaultImpl(di);
1018
1019 let result = service.UnimplementedMethod(EXPECTED_ARG_VALUE);
1020 assert_eq!(result, Ok(EXPECTED_RETURN_VALUE));
1021 }
1022
1023 #[test]
test_versioned_interface_version()1024 fn test_versioned_interface_version() {
1025 let service: binder::Strong<dyn IFooInterface::IFooInterface> = binder::wait_for_interface(
1026 <BpFooInterface as IFooInterface::IFooInterface>::get_descriptor(),
1027 )
1028 .expect("did not get binder service");
1029
1030 let version = service.getInterfaceVersion();
1031 assert_eq!(version, Ok(1));
1032 }
1033
1034 #[test]
test_versioned_interface_hash()1035 fn test_versioned_interface_hash() {
1036 let service: binder::Strong<dyn IFooInterface::IFooInterface> = binder::wait_for_interface(
1037 <BpFooInterface as IFooInterface::IFooInterface>::get_descriptor(),
1038 )
1039 .expect("did not get binder service");
1040
1041 let hash = service.getInterfaceHash();
1042 assert_eq!(hash.as_ref().map(String::as_str), Ok("9e7be1859820c59d9d55dd133e71a3687b5d2e5b"));
1043 }
1044
1045 #[test]
test_versioned_known_union_field_is_ok()1046 fn test_versioned_known_union_field_is_ok() {
1047 let service: binder::Strong<dyn IFooInterface::IFooInterface> = binder::wait_for_interface(
1048 <BpFooInterface as IFooInterface::IFooInterface>::get_descriptor(),
1049 )
1050 .expect("did not get binder service");
1051
1052 assert_eq!(service.acceptUnionAndReturnString(&BazUnion::IntNum(42)), Ok(String::from("42")));
1053 }
1054
1055 #[test]
test_versioned_unknown_union_field_triggers_error()1056 fn test_versioned_unknown_union_field_triggers_error() {
1057 let service: binder::Strong<dyn IFooInterface::IFooInterface> = binder::wait_for_interface(
1058 <BpFooInterface as IFooInterface::IFooInterface>::get_descriptor(),
1059 )
1060 .expect("did not get binder service");
1061
1062 let ret = service.acceptUnionAndReturnString(&BazUnion::LongNum(42));
1063 assert!(ret.is_err());
1064
1065 let main_service = get_test_service();
1066 let backend = main_service.getBackendType().expect("error getting backend type");
1067
1068 // b/173458620 - for investigation of fixing difference
1069 if backend == BackendType::JAVA {
1070 assert_eq!(ret.unwrap_err().exception_code(), binder::ExceptionCode::ILLEGAL_ARGUMENT);
1071 } else {
1072 assert_eq!(ret.unwrap_err().transaction_error(), binder::StatusCode::BAD_VALUE);
1073 }
1074 }
1075
1076 #[test]
test_array_of_parcelable_with_new_field()1077 fn test_array_of_parcelable_with_new_field() {
1078 let service: binder::Strong<dyn IFooInterface::IFooInterface> = binder::wait_for_interface(
1079 <BpFooInterface as IFooInterface::IFooInterface>::get_descriptor(),
1080 )
1081 .expect("did not get binder service");
1082
1083 let foos = [Default::default(), Default::default(), Default::default()];
1084 let ret = service.returnsLengthOfFooArray(&foos);
1085 assert_eq!(ret, Ok(foos.len() as i32));
1086 }
1087
1088 #[test]
test_read_data_correctly_after_parcelable_with_new_field()1089 fn test_read_data_correctly_after_parcelable_with_new_field() {
1090 let service: binder::Strong<dyn IFooInterface::IFooInterface> = binder::wait_for_interface(
1091 <BpFooInterface as IFooInterface::IFooInterface>::get_descriptor(),
1092 )
1093 .expect("did not get binder service");
1094
1095 let in_foo = Default::default();
1096 let mut inout_foo = Foo { intDefault42: 0 };
1097 let mut out_foo = Foo { intDefault42: 0 };
1098 let ret = service.ignoreParcelablesAndRepeatInt(&in_foo, &mut inout_foo, &mut out_foo, 43);
1099 assert_eq!(ret, Ok(43));
1100 assert_eq!(inout_foo.intDefault42, 0);
1101 assert_eq!(out_foo.intDefault42, 0);
1102 }
1103
1104 #[test]
test_calling_v2_api_triggers_error()1105 fn test_calling_v2_api_triggers_error() {
1106 let service: binder::Strong<dyn IFooInterface::IFooInterface> = binder::wait_for_interface(
1107 <BpFooInterface as IFooInterface::IFooInterface>::get_descriptor(),
1108 )
1109 .expect("did not get binder service");
1110
1111 let ret = service.newApi();
1112
1113 assert_eq!(ret.unwrap_err().transaction_error(), binder::StatusCode::UNKNOWN_TRANSACTION);
1114 }
1115
test_renamed_interface<F>(f: F) where F: FnOnce(binder::Strong<dyn IOldName::IOldName>, binder::Strong<dyn INewName::INewName>),1116 fn test_renamed_interface<F>(f: F)
1117 where
1118 F: FnOnce(binder::Strong<dyn IOldName::IOldName>, binder::Strong<dyn INewName::INewName>),
1119 {
1120 let service = get_test_service();
1121 let old_name = service.GetOldNameInterface();
1122 assert!(old_name.is_ok());
1123
1124 let new_name = service.GetNewNameInterface();
1125 assert!(new_name.is_ok());
1126
1127 f(old_name.unwrap(), new_name.unwrap());
1128 }
1129
1130 #[test]
test_renamed_interface_old_as_old()1131 fn test_renamed_interface_old_as_old() {
1132 test_renamed_interface(|old_name, _| {
1133 assert_eq!(
1134 <BpOldName as IOldName::IOldName>::get_descriptor(),
1135 "android.aidl.tests.IOldName"
1136 );
1137
1138 let real_name = old_name.RealName();
1139 assert_eq!(real_name.as_ref().map(String::as_str), Ok("OldName"));
1140 });
1141 }
1142
1143 #[test]
test_renamed_interface_new_as_new()1144 fn test_renamed_interface_new_as_new() {
1145 test_renamed_interface(|_, new_name| {
1146 assert_eq!(
1147 <BpNewName as INewName::INewName>::get_descriptor(),
1148 "android.aidl.tests.IOldName"
1149 );
1150
1151 let real_name = new_name.RealName();
1152 assert_eq!(real_name.as_ref().map(String::as_str), Ok("NewName"));
1153 });
1154 }
1155
1156 #[test]
test_renamed_interface_old_as_new()1157 fn test_renamed_interface_old_as_new() {
1158 test_renamed_interface(|old_name, _| {
1159 let new_name = old_name.as_binder().into_interface::<dyn INewName::INewName>();
1160 assert!(new_name.is_ok());
1161
1162 let real_name = new_name.unwrap().RealName();
1163 assert_eq!(real_name.as_ref().map(String::as_str), Ok("OldName"));
1164 });
1165 }
1166
1167 #[test]
test_renamed_interface_new_as_old()1168 fn test_renamed_interface_new_as_old() {
1169 test_renamed_interface(|_, new_name| {
1170 let old_name = new_name.as_binder().into_interface::<dyn IOldName::IOldName>();
1171 assert!(old_name.is_ok());
1172
1173 let real_name = old_name.unwrap().RealName();
1174 assert_eq!(real_name.as_ref().map(String::as_str), Ok("NewName"));
1175 });
1176 }
1177
1178 #[derive(Debug, Default)]
1179 struct Callback {
1180 received: Arc<Mutex<Option<ParcelableWithNested::Status::Status>>>,
1181 }
1182
1183 impl Interface for Callback {}
1184
1185 impl INestedService::ICallback::ICallback for Callback {
done(&self, st: ParcelableWithNested::Status::Status) -> binder::Result<()>1186 fn done(&self, st: ParcelableWithNested::Status::Status) -> binder::Result<()> {
1187 *self.received.lock().unwrap() = Some(st);
1188 Ok(())
1189 }
1190 }
1191
1192 #[test]
test_nested_type()1193 fn test_nested_type() {
1194 let service: binder::Strong<dyn INestedService::INestedService> = binder::wait_for_interface(
1195 <INestedService::BpNestedService as INestedService::INestedService>::get_descriptor(),
1196 )
1197 .expect("did not get binder service");
1198
1199 let p = ParcelableWithNested::ParcelableWithNested {
1200 status: ParcelableWithNested::Status::Status::OK,
1201 };
1202 // OK -> NOT_OK
1203 let ret = service.flipStatus(&p);
1204 assert_eq!(
1205 ret,
1206 Ok(INestedService::Result::Result { status: ParcelableWithNested::Status::Status::NOT_OK })
1207 );
1208 let received = Arc::new(Mutex::new(None));
1209 // NOT_OK -> OK with nested callback interface
1210 let cb = INestedService::ICallback::BnCallback::new_binder(
1211 Callback { received: Arc::clone(&received) },
1212 BinderFeatures::default(),
1213 );
1214 let ret = service.flipStatusWithCallback(ParcelableWithNested::Status::Status::NOT_OK, &cb);
1215 assert_eq!(ret, Ok(()));
1216 let received = received.lock().unwrap();
1217 assert_eq!(*received, Some(ParcelableWithNested::Status::Status::OK))
1218 }
1219
1220 #[test]
test_nonnull_binder()1221 fn test_nonnull_binder() {
1222 let service = get_test_service();
1223 let result = service.TakesAnIBinder(&service.as_binder());
1224 assert!(result.is_ok());
1225 }
1226
1227 #[test]
test_binder_list_without_null()1228 fn test_binder_list_without_null() {
1229 let service = get_test_service();
1230 let result = service.TakesAnIBinderList(&[service.as_binder()]);
1231 assert!(result.is_ok());
1232 }
1233
1234 #[test]
test_null_binder_to_annotated_method()1235 fn test_null_binder_to_annotated_method() {
1236 let service = get_test_service();
1237 let result = service.TakesANullableIBinder(None);
1238 assert!(result.is_ok());
1239 }
1240
1241 #[test]
test_binder_list_with_null_to_annotated_method()1242 fn test_binder_list_with_null_to_annotated_method() {
1243 let service = get_test_service();
1244 let result = service.TakesANullableIBinderList(Some(&[Some(service.as_binder()), None]));
1245 assert!(result.is_ok());
1246 }
1247
1248 #[test]
test_binder_array()1249 fn test_binder_array() {
1250 let service = get_test_service();
1251 let callback = service
1252 .GetCallback(false)
1253 .expect("error calling GetCallback")
1254 .expect("expected Some from GetCallback");
1255
1256 let mut array = vec![service.as_binder(), callback.as_binder()];
1257
1258 // Java needs initial values here (can't resize arrays)
1259 let mut repeated = vec![Default::default(); array.len()];
1260
1261 let result = service.ReverseIBinderArray(&array, &mut repeated);
1262 assert_eq!(repeated.into_iter().collect::<Option<Vec<_>>>().as_ref(), Some(&array));
1263 array.reverse();
1264 assert_eq!(result, Ok(array));
1265 }
1266
1267 #[test]
test_nullable_binder_array()1268 fn test_nullable_binder_array() {
1269 let service = get_test_service();
1270 let mut array = vec![Some(service.as_binder()), None];
1271
1272 // Java needs initial values here (can't resize arrays)
1273 let mut repeated = Some(vec![Default::default(); array.len()]);
1274
1275 let result = service.ReverseNullableIBinderArray(Some(&array[..]), &mut repeated);
1276 assert_eq!(repeated.as_ref(), Some(&array));
1277 array.reverse();
1278 assert_eq!(result, Ok(Some(array)));
1279 }
1280
1281 #[test]
test_read_write_fixed_size_array()1282 fn test_read_write_fixed_size_array() {
1283 let mut parcel = Parcel::new();
1284 let mut p: FixedSizeArrayExample = Default::default();
1285 p.byteMatrix[0][0] = 0;
1286 p.byteMatrix[0][1] = 1;
1287 p.byteMatrix[1][0] = 2;
1288 p.byteMatrix[1][1] = 3;
1289
1290 p.floatMatrix[0][0] = 0.0;
1291 p.floatMatrix[0][1] = 1.0;
1292 p.floatMatrix[1][0] = 2.0;
1293 p.floatMatrix[1][1] = 3.0;
1294
1295 p.boolNullableArray = Some([true, false]);
1296 p.byteNullableArray = Some([42, 0]);
1297 p.stringNullableArray = Some([Some("hello".into()), Some("world".into())]);
1298
1299 p.boolNullableMatrix = Some([[true, false], Default::default()]);
1300 p.byteNullableMatrix = Some([[42, 0], Default::default()]);
1301 p.stringNullableMatrix =
1302 Some([[Some("hello".into()), Some("world".into())], Default::default()]);
1303
1304 assert_eq!(parcel.write(&p), Ok(()));
1305 // SAFETY: 0 is less than the current size of the parcel data buffer, because the parcel is not
1306 // empty.
1307 unsafe {
1308 parcel.set_data_position(0).unwrap();
1309 }
1310 assert_eq!(p, parcel.read::<FixedSizeArrayExample>().unwrap());
1311 }
1312
1313 #[test]
test_fixed_size_array_uses_array_optimization()1314 fn test_fixed_size_array_uses_array_optimization() {
1315 let mut parcel = Parcel::new();
1316 let byte_array = [[1u8, 2u8, 3u8], [4u8, 5u8, 6u8]];
1317 assert_eq!(parcel.write(&byte_array), Ok(()));
1318 // SAFETY: 0 is less than the current size of the parcel data buffer, because the parcel is not
1319 // empty.
1320 unsafe {
1321 parcel.set_data_position(0).unwrap();
1322 }
1323 assert_eq!(parcel.read::<i32>(), Ok(2i32));
1324 assert_eq!(parcel.read::<Vec<u8>>(), Ok(vec![1u8, 2u8, 3u8]));
1325 assert_eq!(parcel.read::<Vec<u8>>(), Ok(vec![4u8, 5u8, 6u8]));
1326 }
1327
1328 macro_rules! test_repeat_fixed_size_array {
1329 ($service:ident, $func:ident, $value:expr) => {
1330 let array = $value;
1331 let mut repeated = Default::default();
1332 let result = $service.$func(&array, &mut repeated).unwrap();
1333 assert_eq!(repeated, array);
1334 assert_eq!(result, array);
1335 };
1336 }
1337
1338 macro_rules! test_repeat_fixed_size_array_1d_binder {
1339 ($service:ident, $func:ident, $value:expr) => {
1340 let array = $value;
1341 let mut repeated = Default::default();
1342 let result = $service.$func(&array, &mut repeated).unwrap();
1343 assert_eq!(result, array.clone());
1344 assert_eq!(repeated, array.map(Some));
1345 };
1346 }
1347
1348 macro_rules! test_repeat_fixed_size_array_2d_binder {
1349 ($service:ident, $func:ident, $value:expr) => {
1350 let array = $value;
1351 let mut repeated = Default::default();
1352 let result = $service.$func(&array, &mut repeated).unwrap();
1353 assert_eq!(result, array.clone());
1354 assert_eq!(repeated, array.map(|row| row.map(Some)));
1355 };
1356 }
1357
1358 #[test]
test_fixed_size_array_over_binder()1359 fn test_fixed_size_array_over_binder() {
1360 let test_service = get_test_service();
1361 let service: binder::Strong<dyn IRepeatFixedSizeArray> = binder::wait_for_interface(
1362 <BpRepeatFixedSizeArray as IRepeatFixedSizeArray>::get_descriptor(),
1363 )
1364 .expect("did not get binder service");
1365
1366 test_repeat_fixed_size_array!(service, RepeatBytes, [1u8, 2u8, 3u8]);
1367 test_repeat_fixed_size_array!(service, RepeatInts, [1i32, 2i32, 3i32]);
1368
1369 let binder1 = test_service.as_binder();
1370 let binder2 = test_service
1371 .GetCallback(false)
1372 .expect("error calling GetCallback")
1373 .expect("expected Some from GetCallback")
1374 .as_binder();
1375 let binder3 = service.as_binder();
1376 test_repeat_fixed_size_array_1d_binder!(
1377 service,
1378 RepeatBinders,
1379 [binder1.clone(), binder2.clone(), binder3.clone()]
1380 );
1381
1382 let p1 = IntParcelable { value: 1 };
1383 let p2 = IntParcelable { value: 2 };
1384 let p3 = IntParcelable { value: 3 };
1385 test_repeat_fixed_size_array!(service, RepeatParcelables, [p1, p2, p3]);
1386
1387 test_repeat_fixed_size_array!(service, Repeat2dBytes, [[1u8, 2u8, 3u8], [1u8, 2u8, 3u8]]);
1388 test_repeat_fixed_size_array!(service, Repeat2dInts, [[1i32, 2i32, 3i32], [1i32, 2i32, 3i32]]);
1389
1390 test_repeat_fixed_size_array_2d_binder!(
1391 service,
1392 Repeat2dBinders,
1393 [[binder1.clone(), binder2.clone(), binder3.clone()], [binder1, binder2, binder3]]
1394 );
1395
1396 test_repeat_fixed_size_array!(service, Repeat2dParcelables, [[p1, p2, p3], [p1, p2, p3]]);
1397 }
1398
1399 #[test]
test_ping()1400 fn test_ping() {
1401 let test_service = get_test_service();
1402 assert_eq!(test_service.as_binder().ping_binder(), Ok(()));
1403 }
1404
1405 #[test]
test_trunk_stable_parcelable()1406 fn test_trunk_stable_parcelable() {
1407 let service = get_test_trunk_stable_service();
1408 let res = service.getInterfaceVersion();
1409 assert!(res.is_ok());
1410 let version = res.unwrap();
1411
1412 let p1 = MyParcelable { a: 12, b: 13, c: 14 };
1413 let result = service.repeatParcelable(&p1);
1414 assert!(result.is_ok());
1415 let p2 = result.unwrap();
1416 assert_eq!(p1.a, p2.a);
1417 assert_eq!(p1.b, p2.b);
1418 if version == 1 {
1419 assert_ne!(p1.c, p2.c);
1420 assert_eq!(0, p2.c);
1421 } else {
1422 assert_eq!(p1.c, p2.c);
1423 }
1424 }
1425
1426 #[test]
test_trunk_stable_enum()1427 fn test_trunk_stable_enum() {
1428 let service = get_test_trunk_stable_service();
1429 let e1 = MyEnum::THREE;
1430 let result = service.repeatEnum(e1);
1431 assert!(result.is_ok());
1432 assert_eq!(result.unwrap(), e1);
1433 }
1434 #[test]
test_trunk_stable_union()1435 fn test_trunk_stable_union() {
1436 let service = get_test_trunk_stable_service();
1437 let res = service.getInterfaceVersion();
1438 assert!(res.is_ok());
1439 let version = res.unwrap();
1440
1441 let u1 = MyUnion::C(14);
1442 let result = service.repeatUnion(&u1);
1443 if version == 1 {
1444 assert!(result.is_err());
1445 } else {
1446 assert!(result.is_ok());
1447 }
1448 }
1449 #[test]
test_trunk_stable_unimplemented()1450 fn test_trunk_stable_unimplemented() {
1451 let service = get_test_trunk_stable_service();
1452 let res = service.getInterfaceVersion();
1453 assert!(res.is_ok());
1454 let version = res.unwrap();
1455
1456 let p1 = MyOtherParcelable { a: 12, b: 13 };
1457 let result = service.repeatOtherParcelable(&p1);
1458 if version == 1 {
1459 assert!(result.is_err());
1460 } else {
1461 assert!(result.is_ok());
1462 }
1463 }
1464
1465 #[test]
test_trunk_stable_hash()1466 fn test_trunk_stable_hash() {
1467 let service = get_test_trunk_stable_service();
1468 let res = service.getInterfaceVersion();
1469 assert!(res.is_ok());
1470 let version = res.unwrap();
1471
1472 let hash = service.getInterfaceHash();
1473 if version == 1 {
1474 assert_eq!(
1475 hash.as_ref().map(String::as_str),
1476 Ok("88311b9118fb6fe9eff4a2ca19121de0587f6d5f")
1477 );
1478 // Check local values of version and hash
1479 assert_eq!(
1480 android_aidl_test_trunk::aidl::android::aidl::test::trunk::ITrunkStableTest::VERSION,
1481 1
1482 );
1483 assert_eq!(
1484 android_aidl_test_trunk::aidl::android::aidl::test::trunk::ITrunkStableTest::HASH,
1485 "88311b9118fb6fe9eff4a2ca19121de0587f6d5f"
1486 );
1487 } else {
1488 assert_eq!(hash.as_ref().map(String::as_str), Ok("notfrozen"));
1489 // Check local values of version and hash
1490 assert_eq!(
1491 android_aidl_test_trunk::aidl::android::aidl::test::trunk::ITrunkStableTest::VERSION,
1492 2
1493 );
1494 assert_eq!(
1495 android_aidl_test_trunk::aidl::android::aidl::test::trunk::ITrunkStableTest::HASH,
1496 "notfrozen"
1497 );
1498 }
1499 }
1500
1501 #[derive(Debug, Default)]
1502 pub struct MyCallback {
1503 pub repeat_parcelable_called: Arc<Mutex<bool>>,
1504 pub repeat_enum_called: Arc<Mutex<bool>>,
1505 pub repeat_union_called: Arc<Mutex<bool>>,
1506 pub repeat_other_parcelable_called: Arc<Mutex<bool>>,
1507 }
1508
1509 impl Interface for MyCallback {}
1510
1511 impl IMyCallback::IMyCallback for MyCallback {
repeatParcelable(&self, in_parcel: &MyParcelable) -> binder::Result<MyParcelable>1512 fn repeatParcelable(&self, in_parcel: &MyParcelable) -> binder::Result<MyParcelable> {
1513 *self.repeat_parcelable_called.lock().unwrap() = true;
1514 let tmp: MyParcelable = MyParcelable { a: in_parcel.a, b: in_parcel.b, c: in_parcel.c };
1515 Ok(tmp)
1516 }
repeatEnum(&self, in_enum: MyEnum) -> binder::Result<MyEnum>1517 fn repeatEnum(&self, in_enum: MyEnum) -> binder::Result<MyEnum> {
1518 *self.repeat_enum_called.lock().unwrap() = true;
1519 Ok(in_enum)
1520 }
repeatUnion(&self, in_union: &MyUnion) -> binder::Result<MyUnion>1521 fn repeatUnion(&self, in_union: &MyUnion) -> binder::Result<MyUnion> {
1522 *self.repeat_union_called.lock().unwrap() = true;
1523 match in_union {
1524 MyUnion::A(n) => Ok(MyUnion::A(*n)),
1525 MyUnion::B(n) => Ok(MyUnion::B(*n)),
1526 MyUnion::C(n) => Ok(MyUnion::C(*n)),
1527 }
1528 }
repeatOtherParcelable( &self, in_parcel: &MyOtherParcelable, ) -> binder::Result<MyOtherParcelable>1529 fn repeatOtherParcelable(
1530 &self,
1531 in_parcel: &MyOtherParcelable,
1532 ) -> binder::Result<MyOtherParcelable> {
1533 *self.repeat_other_parcelable_called.lock().unwrap() = true;
1534 let tmp: MyOtherParcelable = MyOtherParcelable { a: in_parcel.a, b: in_parcel.b };
1535 Ok(tmp)
1536 }
1537 }
1538
1539 #[test]
test_trunk_stable_callback()1540 fn test_trunk_stable_callback() {
1541 let service = get_test_trunk_stable_service();
1542 let res = service.getInterfaceVersion();
1543 assert!(res.is_ok());
1544 let version = res.unwrap();
1545
1546 let repeat_parcelable_called = Arc::new(Mutex::new(false));
1547 let repeat_enum_called = Arc::new(Mutex::new(false));
1548 let repeat_union_called = Arc::new(Mutex::new(false));
1549 let repeat_other_parcelable_called = Arc::new(Mutex::new(false));
1550 let cb = IMyCallback::BnMyCallback::new_binder(
1551 MyCallback {
1552 repeat_parcelable_called: Arc::clone(&repeat_parcelable_called),
1553 repeat_enum_called: Arc::clone(&repeat_enum_called),
1554 repeat_union_called: Arc::clone(&repeat_union_called),
1555 repeat_other_parcelable_called: Arc::clone(&repeat_other_parcelable_called),
1556 },
1557 BinderFeatures::default(),
1558 );
1559 let result = service.callMyCallback(&cb);
1560 assert!(result.is_ok());
1561 assert!(*repeat_parcelable_called.lock().unwrap());
1562 assert!(*repeat_enum_called.lock().unwrap());
1563 assert!(*repeat_union_called.lock().unwrap());
1564 if version == 1 {
1565 assert!(!*repeat_other_parcelable_called.lock().unwrap());
1566 } else {
1567 assert!(*repeat_other_parcelable_called.lock().unwrap());
1568 }
1569 }
1570