blob: 02cbf5fdf8e5d3772c814dfc54a04c30e183d8ba [file] [log] [blame]
Christopher Wiley90be4e32015-10-20 14:55:25 -07001/*
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
Jooyung Han1f14ab32020-10-14 13:48:29 +090017#include "aidl.h"
Christopher Wiley90be4e32015-10-20 14:55:25 -070018
Christopher Wileyec31a052016-01-25 07:28:51 -080019#include <android-base/stringprintf.h>
Jiyong Parkf1f5c802020-05-19 17:33:00 +090020#include <gmock/gmock.h>
Christopher Wiley90be4e32015-10-20 14:55:25 -070021#include <gtest/gtest.h>
22
Jooyung Han1f14ab32020-10-14 13:48:29 +090023#include <map>
24#include <memory>
25#include <set>
26#include <string>
27#include <vector>
28
Steven Moreland49585242019-12-18 16:06:49 -080029#include "aidl_checkapi.h"
Christopher Wiley90be4e32015-10-20 14:55:25 -070030#include "aidl_language.h"
Steven Moreland860b1942018-08-16 14:59:28 -070031#include "aidl_to_cpp.h"
Jeongik Cha047c5ee2019-08-07 23:16:49 +090032#include "aidl_to_java.h"
Jiyong Park2a7c92b2020-07-22 19:12:36 +090033#include "logging.h"
Jeongik Cha047c5ee2019-08-07 23:16:49 +090034#include "options.h"
Christopher Wiley90be4e32015-10-20 14:55:25 -070035#include "tests/fake_io_delegate.h"
Christopher Wiley90be4e32015-10-20 14:55:25 -070036
Jeongik Cha2a5b4d82019-08-06 19:37:59 +090037using android::aidl::internals::parse_preprocessed_file;
Christopher Wiley90be4e32015-10-20 14:55:25 -070038using android::aidl::test::FakeIoDelegate;
Christopher Wileyec31a052016-01-25 07:28:51 -080039using android::base::StringPrintf;
Jooyung Han1f14ab32020-10-14 13:48:29 +090040using std::map;
Christopher Wiley12e894a2016-01-29 11:55:07 -080041using std::set;
Christopher Wiley90be4e32015-10-20 14:55:25 -070042using std::string;
43using std::unique_ptr;
Christopher Wiley12e894a2016-01-29 11:55:07 -080044using std::vector;
Devin Moore7b8d5c92020-03-17 14:14:08 -070045using testing::TestParamInfo;
Jeongik Cha2a5b4d82019-08-06 19:37:59 +090046using testing::internal::CaptureStderr;
47using testing::internal::GetCapturedStderr;
Christopher Wiley90be4e32015-10-20 14:55:25 -070048
49namespace android {
50namespace aidl {
Christopher Wileyf8136192016-04-12 14:19:35 -070051namespace {
52
53const char kExpectedDepFileContents[] =
54R"(place/for/output/p/IFoo.java : \
55 p/IFoo.aidl
56
57p/IFoo.aidl :
58)";
59
Dan Willemsen93298ee2016-11-10 23:55:55 -080060const char kExpectedNinjaDepFileContents[] =
61R"(place/for/output/p/IFoo.java : \
62 p/IFoo.aidl
63)";
64
Jiyong Parkdf202122019-09-30 20:48:35 +090065const char kExpectedParcelableDeclarationDepFileContents[] =
66 R"( : \
67 p/Foo.aidl
68
69p/Foo.aidl :
70)";
71
72const char kExpectedStructuredParcelableDepFileContents[] =
Steven Moreland2a9a7d62019-02-05 16:11:54 -080073 R"(place/for/output/p/Foo.java : \
Christopher Wileyb1bbdf82016-04-21 11:43:45 -070074 p/Foo.aidl
75
76p/Foo.aidl :
77)";
78
Jooyung Hand2fa0232020-10-19 02:51:41 +090079const char kExpectedJavaParcelableOutputContents[] =
Jeongik Chaa755c2a2018-12-12 16:28:23 +090080 R"(/*
81 * This file is auto-generated. DO NOT MODIFY.
Jeongik Chaa755c2a2018-12-12 16:28:23 +090082 */
Makoto Onuki78a1c1c2020-03-04 16:57:23 -080083@android.annotation.Hide
Jeongik Chaa755c2a2018-12-12 16:28:23 +090084public class Rect implements android.os.Parcelable
85{
86 // Comment
87
Makoto Onuki78a1c1c2020-03-04 16:57:23 -080088 @android.annotation.Hide
Jeongik Chaa755c2a2018-12-12 16:28:23 +090089 public int x = 5;
90
Makoto Onuki78a1c1c2020-03-04 16:57:23 -080091 @android.annotation.Hide
92 @android.compat.annotation.UnsupportedAppUsage(expectedSignature = "dummy", implicitMember = "dummy", maxTargetSdk = 28, publicAlternatives = "dummy", trackingBug = 42L, overrideSourcePosition="Rect.aidl:7:1:10:14")
Steven Moreland541788d2020-05-21 22:05:52 +000093 public int y = 0;
Jiyong Parkd4e73c82019-07-24 21:39:15 +090094
95 public android.os.ParcelFileDescriptor fd;
Jooyung Hand2fa0232020-10-19 02:51:41 +090096
97 public java.util.List<android.os.ParcelFileDescriptor> fds;
Jeongik Chaa755c2a2018-12-12 16:28:23 +090098 public static final android.os.Parcelable.Creator<Rect> CREATOR = new android.os.Parcelable.Creator<Rect>() {
99 @Override
100 public Rect createFromParcel(android.os.Parcel _aidl_source) {
101 Rect _aidl_out = new Rect();
102 _aidl_out.readFromParcel(_aidl_source);
103 return _aidl_out;
104 }
105 @Override
106 public Rect[] newArray(int _aidl_size) {
107 return new Rect[_aidl_size];
108 }
109 };
110 @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag)
111 {
112 int _aidl_start_pos = _aidl_parcel.dataPosition();
113 _aidl_parcel.writeInt(0);
114 _aidl_parcel.writeInt(x);
115 _aidl_parcel.writeInt(y);
Jiyong Parkd4e73c82019-07-24 21:39:15 +0900116 if ((fd!=null)) {
117 _aidl_parcel.writeInt(1);
118 fd.writeToParcel(_aidl_parcel, 0);
119 }
120 else {
121 _aidl_parcel.writeInt(0);
122 }
Jooyung Hana61aa232020-10-20 04:00:08 +0900123 _aidl_parcel.writeTypedList(fds);
Jeongik Chaa755c2a2018-12-12 16:28:23 +0900124 int _aidl_end_pos = _aidl_parcel.dataPosition();
125 _aidl_parcel.setDataPosition(_aidl_start_pos);
126 _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos);
127 _aidl_parcel.setDataPosition(_aidl_end_pos);
128 }
129 public final void readFromParcel(android.os.Parcel _aidl_parcel)
130 {
131 int _aidl_start_pos = _aidl_parcel.dataPosition();
132 int _aidl_parcelable_size = _aidl_parcel.readInt();
Jeongik Chaa755c2a2018-12-12 16:28:23 +0900133 try {
Jeongik Cha36f76c32020-07-28 00:25:52 +0900134 if (_aidl_parcelable_size < 0) return;
Jeongik Chaa755c2a2018-12-12 16:28:23 +0900135 x = _aidl_parcel.readInt();
136 if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return;
137 y = _aidl_parcel.readInt();
138 if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return;
Jiyong Parkd4e73c82019-07-24 21:39:15 +0900139 if ((0!=_aidl_parcel.readInt())) {
140 fd = android.os.ParcelFileDescriptor.CREATOR.createFromParcel(_aidl_parcel);
141 }
142 else {
143 fd = null;
144 }
145 if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return;
Jooyung Hana61aa232020-10-20 04:00:08 +0900146 fds = _aidl_parcel.createTypedArrayList(android.os.ParcelFileDescriptor.CREATOR);
Jooyung Hand2fa0232020-10-19 02:51:41 +0900147 if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return;
Jeongik Chaa755c2a2018-12-12 16:28:23 +0900148 } finally {
Jeongik Cha8b329982020-09-01 20:59:36 +0900149 if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) {
150 throw new android.os.BadParcelableException("Overflow in the size of parcelable");
151 }
Jeongik Chaa755c2a2018-12-12 16:28:23 +0900152 _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size);
153 }
154 }
Jooyung Hand2fa0232020-10-19 02:51:41 +0900155 @Override
156 public int describeContents() {
157 int _mask = 0;
Jooyung Hanea2147c2020-10-21 18:16:56 +0900158 _mask |= describeContents(fd);
159 _mask |= describeContents(fds);
Jooyung Hand2fa0232020-10-19 02:51:41 +0900160 return _mask;
Jeongik Cha372a8c82018-12-12 16:31:11 +0900161 }
Jooyung Hanea2147c2020-10-21 18:16:56 +0900162 private int describeContents(Object _v) {
163 if (_v == null) return 0;
164 if (_v instanceof java.util.Collection) {
165 int _mask = 0;
166 for (Object o : (java.util.Collection) _v) {
167 _mask |= describeContents(o);
168 }
169 return _mask;
170 }
171 if (_v instanceof android.os.Parcelable) {
172 return ((android.os.Parcelable) _v).describeContents();
173 }
174 return 0;
175 }
Jeongik Chaa755c2a2018-12-12 16:28:23 +0900176}
177)";
178
Devin Moore2f2077a2020-08-28 11:27:53 -0700179// clang-format off
180const char kExpectedCppHeaderOutput[] =
181 R"(#pragma once
182
183#include <binder/IBinder.h>
184#include <binder/IInterface.h>
185#include <binder/Status.h>
186#include <optional>
187#include <utils/String16.h>
188#include <utils/StrongPointer.h>
189#include <vector>
190
191class IFoo : public ::android::IInterface {
192public:
193 DECLARE_META_INTERFACE(Foo)
194 virtual ::android::binder::Status foo(::std::optional<::std::vector<::std::optional<::android::String16>>>* _aidl_return) = 0;
195}; // class IFoo
196class IFooDefault : public IFoo {
197public:
198 ::android::IBinder* onAsBinder() override {
199 return nullptr;
200 }
201 ::android::binder::Status foo(::std::optional<::std::vector<::std::optional<::android::String16>>>*) override {
202 return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION);
203 }
204}; // class IFooDefault
205)";
206// clang-format on
207
Christopher Wileyf8136192016-04-12 14:19:35 -0700208} // namespace
Christopher Wiley90be4e32015-10-20 14:55:25 -0700209
Devin Moore7b8d5c92020-03-17 14:14:08 -0700210class AidlTest : public ::testing::TestWithParam<Options::Language> {
Christopher Wiley90be4e32015-10-20 14:55:25 -0700211 protected:
Jeongik Cha047c5ee2019-08-07 23:16:49 +0900212 AidlDefinedType* Parse(const string& path, const string& contents, AidlTypenames& typenames_,
213 Options::Language lang, AidlError* error = nullptr,
Steven Moreland1eac5fa2018-08-27 19:35:05 -0700214 const vector<string> additional_arguments = {}) {
Christopher Wiley0522cd52015-10-28 15:39:44 -0700215 io_delegate_.SetFileContents(path, contents);
Jiyong Parkfbbfa932018-07-30 21:44:10 +0900216 vector<string> args;
Devin Moore7b8d5c92020-03-17 14:14:08 -0700217 args.emplace_back("aidl");
218 args.emplace_back("--lang=" + Options::LanguageToString(lang));
Steven Moreland1eac5fa2018-08-27 19:35:05 -0700219 for (const string& s : additional_arguments) {
220 args.emplace_back(s);
221 }
222 for (const string& f : preprocessed_files_) {
Jiyong Parkfbbfa932018-07-30 21:44:10 +0900223 args.emplace_back("--preprocessed=" + f);
224 }
Steven Moreland1eac5fa2018-08-27 19:35:05 -0700225 for (const string& i : import_paths_) {
Jiyong Parkfbbfa932018-07-30 21:44:10 +0900226 args.emplace_back("--include=" + i);
227 }
228 args.emplace_back(path);
229 Options options = Options::From(args);
Jiyong Parkb034bf02018-07-30 17:44:33 +0900230 vector<string> imported_files;
Jiyong Park8c380532018-08-30 14:55:26 +0900231 ImportResolver import_resolver{io_delegate_, path, import_paths_, {}};
Christopher Wiley69b44cf2016-05-03 13:43:33 -0700232 AidlError actual_error = ::android::aidl::internals::load_and_validate_aidl(
Jiyong Park8e79b7f2020-07-20 20:52:38 +0900233 path, options, io_delegate_, &typenames_, &imported_files);
Jiyong Parkb034bf02018-07-30 17:44:33 +0900234
Christopher Wiley69b44cf2016-05-03 13:43:33 -0700235 if (error != nullptr) {
236 *error = actual_error;
237 }
Jiyong Parkb034bf02018-07-30 17:44:33 +0900238
239 if (actual_error != AidlError::OK) {
240 return nullptr;
241 }
242
Jiyong Park8e79b7f2020-07-20 20:52:38 +0900243 const auto& defined_types = typenames_.MainDocument().DefinedTypes();
Jiyong Parkb034bf02018-07-30 17:44:33 +0900244 EXPECT_EQ(1ul, defined_types.size());
245
Jiyong Park8e79b7f2020-07-20 20:52:38 +0900246 return defined_types.front().get();
Christopher Wiley90be4e32015-10-20 14:55:25 -0700247 }
Christopher Wiley0522cd52015-10-28 15:39:44 -0700248
Devin Moore7b8d5c92020-03-17 14:14:08 -0700249 Options::Language GetLanguage() { return GetParam(); }
250
Christopher Wiley0522cd52015-10-28 15:39:44 -0700251 FakeIoDelegate io_delegate_;
Christopher Wiley41544372015-11-03 14:52:29 -0800252 vector<string> preprocessed_files_;
Jiyong Park8c380532018-08-30 14:55:26 +0900253 set<string> import_paths_;
Jeongik Cha047c5ee2019-08-07 23:16:49 +0900254 AidlTypenames typenames_;
Christopher Wiley90be4e32015-10-20 14:55:25 -0700255};
256
Devin Moore7b8d5c92020-03-17 14:14:08 -0700257// Instantiate the AidlTest parameterized suite, calling all of the TEST_P
258// tests with each of the supported languages as a parameter.
259INSTANTIATE_TEST_SUITE_P(AidlTestSuite, AidlTest,
260 testing::Values(Options::Language::CPP, Options::Language::JAVA,
Andrei Homescub62afd92020-05-11 19:24:59 -0700261 Options::Language::NDK, Options::Language::RUST),
Devin Moore7b8d5c92020-03-17 14:14:08 -0700262 [](const testing::TestParamInfo<Options::Language>& info) {
263 return Options::LanguageToString(info.param);
264 });
265
266TEST_P(AidlTest, AcceptMissingPackage) {
267 EXPECT_NE(nullptr, Parse("IFoo.aidl", "interface IFoo { }", typenames_, GetLanguage()));
Christopher Wiley90be4e32015-10-20 14:55:25 -0700268}
269
Devin Moore7b8d5c92020-03-17 14:14:08 -0700270TEST_P(AidlTest, EndsInSingleLineComment) {
271 EXPECT_NE(nullptr, Parse("IFoo.aidl", "interface IFoo { } // foo", typenames_, GetLanguage()));
Steven Moreland9c2988f2019-07-17 17:49:10 -0700272}
273
Steven Morelandebc3c5d2020-09-30 23:40:33 +0000274TEST_P(AidlTest, InterfaceRequiresCorrectPath) {
275 const string expected_stderr =
276 "ERROR: a/Foo.aidl:1.11-21: IBar should be declared in a file called a/IBar.aidl\n";
277 const std::string file_contents = "package a; interface IBar {}";
278 CaptureStderr();
279 EXPECT_EQ(nullptr, Parse("a/Foo.aidl", file_contents, typenames_, GetLanguage()));
280 EXPECT_EQ(expected_stderr, GetCapturedStderr()) << file_contents;
281}
282
283TEST_P(AidlTest, ParcelableRequiresCorrectPath) {
284 const string expected_stderr =
285 "ERROR: a/Foo.aidl:1.11-21: Bar should be declared in a file called a/Bar.aidl\n";
286 const std::string file_contents = "package a; interface Bar {}";
287 CaptureStderr();
288 EXPECT_EQ(nullptr, Parse("a/Foo.aidl", file_contents, typenames_, GetLanguage()));
289 EXPECT_EQ(expected_stderr, GetCapturedStderr()) << file_contents;
290}
291
292TEST_P(AidlTest, UnstructuredParcelableRequiresCorrectPath) {
293 const string expected_stderr =
294 "ERROR: a/Foo.aidl:1.22-26: Bar should be declared in a file called a/Bar.aidl\n";
295 const std::string file_contents = "package a; parcelable Bar cpp_header \"anything.h\";";
296 CaptureStderr();
297 EXPECT_EQ(nullptr, Parse("a/Foo.aidl", file_contents, typenames_, GetLanguage()));
298 EXPECT_EQ(expected_stderr, GetCapturedStderr()) << file_contents;
299}
300
301TEST_P(AidlTest, EnumRequiresCorrectPath) {
302 const string expected_stderr =
303 "ERROR: a/Foo.aidl:1.16-20: Bar should be declared in a file called a/Bar.aidl\n";
304 const std::string file_contents = "package a; enum Bar { A, }";
305 CaptureStderr();
306 EXPECT_EQ(nullptr, Parse("a/Foo.aidl", file_contents, typenames_, GetLanguage()));
307 EXPECT_EQ(expected_stderr, GetCapturedStderr()) << file_contents;
308}
309
Devin Moore7b8d5c92020-03-17 14:14:08 -0700310TEST_P(AidlTest, RejectsArraysOfBinders) {
Jiyong Park8c380532018-08-30 14:55:26 +0900311 import_paths_.emplace("");
Christopher Wiley0522cd52015-10-28 15:39:44 -0700312 io_delegate_.SetFileContents("bar/IBar.aidl",
313 "package bar; interface IBar {}");
Devin Moore097a3ab2020-03-11 16:08:44 -0700314 const string path = "foo/IFoo.aidl";
315 const string contents =
316 "package foo;\n"
317 "import bar.IBar;\n"
318 "interface IFoo { void f(in IBar[] input); }";
319 const string expected_stderr = "ERROR: foo/IFoo.aidl:3.27-32: Binder type cannot be an array\n";
320 CaptureStderr();
Devin Moore7b8d5c92020-03-17 14:14:08 -0700321 EXPECT_EQ(nullptr, Parse(path, contents, typenames_, GetLanguage()));
Devin Moore097a3ab2020-03-11 16:08:44 -0700322 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Christopher Wiley0522cd52015-10-28 15:39:44 -0700323}
324
Devin Moore7b8d5c92020-03-17 14:14:08 -0700325TEST_P(AidlTest, SupportOnlyOutParameters) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700326 const string interface_list = "package a; interface IBar { void f(out List<String> bar); }";
Devin Moore7b8d5c92020-03-17 14:14:08 -0700327 EXPECT_NE(nullptr, Parse("a/IBar.aidl", interface_list, typenames_, GetLanguage()));
Jiyong Park40782d02020-07-24 19:17:43 +0900328}
Devin Moore097a3ab2020-03-11 16:08:44 -0700329
Jiyong Park40782d02020-07-24 19:17:43 +0900330TEST_P(AidlTest, RejectOutParametersForIBinder) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700331 const string interface_ibinder = "package a; interface IBaz { void f(out IBinder bar); }";
332 const string expected_ibinder_stderr =
Jooyung Han15fd6c62020-10-23 13:54:46 +0900333 "ERROR: a/IBaz.aidl:1.47-51: 'bar' can't be an out parameter because IBinder can only be an "
334 "in parameter.\n";
Devin Moore097a3ab2020-03-11 16:08:44 -0700335 CaptureStderr();
Devin Moore7b8d5c92020-03-17 14:14:08 -0700336 EXPECT_EQ(nullptr, Parse("a/IBaz.aidl", interface_ibinder, typenames_, GetLanguage()));
Devin Moore097a3ab2020-03-11 16:08:44 -0700337 EXPECT_EQ(expected_ibinder_stderr, GetCapturedStderr());
Jeongik Chaa2080bf2019-06-18 16:44:29 +0900338}
339
Jiyong Park40782d02020-07-24 19:17:43 +0900340TEST_P(AidlTest, RejectsOutParametersInOnewayInterface) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700341 const string oneway_interface = "package a; oneway interface IBar { void f(out int bar); }";
342 const string expected_stderr =
343 "ERROR: a/IBar.aidl:1.40-42: oneway method 'f' cannot have out parameters\n";
Devin Moore7b8d5c92020-03-17 14:14:08 -0700344 CaptureStderr();
345 EXPECT_EQ(nullptr, Parse("a/IBar.aidl", oneway_interface, typenames_, GetLanguage()));
346 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Park40782d02020-07-24 19:17:43 +0900347}
Devin Moore7b8d5c92020-03-17 14:14:08 -0700348
Jiyong Park40782d02020-07-24 19:17:43 +0900349TEST_P(AidlTest, RejectsOutParametersInOnewayMethod) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700350 const string oneway_method = "package a; interface IBar { oneway void f(out int bar); }";
Jiyong Park40782d02020-07-24 19:17:43 +0900351 const string expected_stderr =
352 "ERROR: a/IBar.aidl:1.40-42: oneway method 'f' cannot have out parameters\n";
Devin Moore097a3ab2020-03-11 16:08:44 -0700353 CaptureStderr();
Devin Moore7b8d5c92020-03-17 14:14:08 -0700354 EXPECT_EQ(nullptr, Parse("a/IBar.aidl", oneway_method, typenames_, GetLanguage()));
Devin Moore097a3ab2020-03-11 16:08:44 -0700355 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Christopher Wiley90be4e32015-10-20 14:55:25 -0700356}
357
Devin Moore7b8d5c92020-03-17 14:14:08 -0700358TEST_P(AidlTest, RejectsOnewayNonVoidReturn) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700359 const string oneway_method = "package a; interface IFoo { oneway int f(); }";
360 const string expected_stderr =
361 "ERROR: a/IFoo.aidl:1.39-41: oneway method 'f' cannot return a value\n";
362 CaptureStderr();
Devin Moore7b8d5c92020-03-17 14:14:08 -0700363 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", oneway_method, typenames_, GetLanguage()));
Devin Moore097a3ab2020-03-11 16:08:44 -0700364 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Christopher Wiley90be4e32015-10-20 14:55:25 -0700365}
366
Devin Moore7b8d5c92020-03-17 14:14:08 -0700367TEST_P(AidlTest, RejectsNullablePrimitive) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700368 const string oneway_method = "package a; interface IFoo { @nullable int f(); }";
369 const string expected_stderr =
370 "ERROR: a/IFoo.aidl:1.38-42: Primitive type cannot get nullable annotation\n";
371 CaptureStderr();
Devin Moore7b8d5c92020-03-17 14:14:08 -0700372 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", oneway_method, typenames_, GetLanguage()));
Devin Moore097a3ab2020-03-11 16:08:44 -0700373 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Casey Dahlin57dbe242015-12-04 11:44:02 -0800374}
375
Devin Moore2f2077a2020-08-28 11:27:53 -0700376TEST_P(AidlTest, AcceptNullableList) {
377 const string oneway_method = "package a; interface IFoo { @nullable List<String> f(); }";
378 const string expected_stderr = "";
379 CaptureStderr();
380 EXPECT_NE(nullptr, Parse("a/IFoo.aidl", oneway_method, typenames_, GetLanguage()));
381 EXPECT_EQ(expected_stderr, GetCapturedStderr());
382}
383
Devin Moore7b8d5c92020-03-17 14:14:08 -0700384TEST_P(AidlTest, RejectsDuplicatedArgumentNames) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700385 const string method = "package a; interface IFoo { void f(int a, int a); }";
386 const string expected_stderr =
387 "ERROR: a/IFoo.aidl:1.33-35: method 'f' has duplicate argument name 'a'\n";
388 CaptureStderr();
Devin Moore7b8d5c92020-03-17 14:14:08 -0700389 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", method, typenames_, GetLanguage()));
Devin Moore097a3ab2020-03-11 16:08:44 -0700390 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Steven Morelandb3cd3c72018-10-11 12:37:45 -0700391}
392
Jeongik Cha13066da2020-08-06 15:43:19 +0900393TEST_P(AidlTest, RejectsDuplicatedFieldNames) {
394 const string method = "package a; parcelable Foo { int a; String a; }";
Jooyung Han59af9cc2020-10-25 21:44:14 +0900395 const string expected_stderr = "ERROR: a/Foo.aidl:1.42-44: 'Foo' has duplicate field name 'a'\n";
Jeongik Cha13066da2020-08-06 15:43:19 +0900396 CaptureStderr();
397 EXPECT_EQ(nullptr, Parse("a/Foo.aidl", method, typenames_, GetLanguage()));
398 EXPECT_EQ(expected_stderr, GetCapturedStderr());
399}
400
Jooyung Hand902a972020-10-23 17:32:44 +0900401TEST_P(AidlTest, RejectsRepeatedAnnotations) {
402 const string method = R"(@Hide @Hide parcelable Foo {})";
403 const string expected_stderr =
404 "ERROR: Foo.aidl:1.23-27: 'Hide' is repeated, but not allowed. Previous location: "
405 "Foo.aidl:1.1-6\n";
406 CaptureStderr();
407 EXPECT_EQ(nullptr, Parse("Foo.aidl", method, typenames_, GetLanguage()));
408 EXPECT_EQ(expected_stderr, GetCapturedStderr());
409}
410
Devin Moore7b8d5c92020-03-17 14:14:08 -0700411TEST_P(AidlTest, RejectsDuplicatedAnnotationParams) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700412 const string method = "package a; interface IFoo { @UnsupportedAppUsage(foo=1, foo=2)void f(); }";
413 const string expected_stderr = "ERROR: a/IFoo.aidl:1.56-62: Trying to redefine parameter foo.\n";
414 CaptureStderr();
Devin Moore7b8d5c92020-03-17 14:14:08 -0700415 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", method, typenames_, GetLanguage()));
Devin Moore097a3ab2020-03-11 16:08:44 -0700416 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Andrei Onea9445fc62019-06-27 18:11:59 +0100417}
418
Devin Moore7b8d5c92020-03-17 14:14:08 -0700419TEST_P(AidlTest, RejectUnsupportedInterfaceAnnotations) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700420 AidlError error;
421 const string method = "package a; @nullable interface IFoo { int f(); }";
422 const string expected_stderr =
Devin Moore24f68572020-02-26 13:20:59 -0800423 "ERROR: a/IFoo.aidl:1.21-31: 'nullable' is not a supported annotation for this node. "
Jiyong Park27fd7fd2020-08-27 16:25:09 +0900424 "It must be one of: Hide, UnsupportedAppUsage, VintfStability, JavaPassthrough, Descriptor\n";
Devin Moorec054bf82020-03-10 16:31:48 -0700425 CaptureStderr();
Devin Moore7b8d5c92020-03-17 14:14:08 -0700426 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", method, typenames_, GetLanguage(), &error));
Devin Moorec054bf82020-03-10 16:31:48 -0700427 EXPECT_EQ(expected_stderr, GetCapturedStderr());
428 EXPECT_EQ(AidlError::BAD_TYPE, error);
Devin Moore24f68572020-02-26 13:20:59 -0800429}
430
Devin Moore7b8d5c92020-03-17 14:14:08 -0700431TEST_P(AidlTest, RejectUnsupportedTypeAnnotations) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700432 AidlError error;
433 const string method = "package a; interface IFoo { @JavaOnlyStableParcelable int f(); }";
434 const string expected_stderr =
Devin Moore24f68572020-02-26 13:20:59 -0800435 "ERROR: a/IFoo.aidl:1.54-58: 'JavaOnlyStableParcelable' is not a supported annotation "
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +0900436 "for this node. It must be one of: Hide, UnsupportedAppUsage, nullable, utf8InCpp, JavaPassthrough\n";
Devin Moorec054bf82020-03-10 16:31:48 -0700437 CaptureStderr();
Devin Moore7b8d5c92020-03-17 14:14:08 -0700438 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", method, typenames_, GetLanguage(), &error));
Devin Moorec054bf82020-03-10 16:31:48 -0700439 EXPECT_EQ(expected_stderr, GetCapturedStderr());
440 EXPECT_EQ(AidlError::BAD_TYPE, error);
Devin Moore24f68572020-02-26 13:20:59 -0800441}
442
Devin Moore7b8d5c92020-03-17 14:14:08 -0700443TEST_P(AidlTest, RejectUnsupportedParcelableAnnotations) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700444 AidlError error;
445 const string method = "package a; @nullable parcelable IFoo cpp_header \"IFoo.h\";";
446 const string expected_stderr =
Steven Morelandebc3c5d2020-09-30 23:40:33 +0000447 "ERROR: a/IFoo.aidl:1.32-37: 'nullable' is not a supported annotation for this node. "
Jeongik Cha36f76c32020-07-28 00:25:52 +0900448 "It must be one of: Hide, JavaOnlyStableParcelable, UnsupportedAppUsage, VintfStability, "
Jeongik Chad0a10272020-08-06 16:33:36 +0900449 "JavaPassthrough, JavaOnlyImmutable\n";
Devin Moorec054bf82020-03-10 16:31:48 -0700450 CaptureStderr();
Steven Morelandebc3c5d2020-09-30 23:40:33 +0000451 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", method, typenames_, GetLanguage(), &error));
Devin Moorec054bf82020-03-10 16:31:48 -0700452 EXPECT_EQ(expected_stderr, GetCapturedStderr());
453 EXPECT_EQ(AidlError::BAD_TYPE, error);
Devin Moore24f68572020-02-26 13:20:59 -0800454}
455
Devin Moore7b8d5c92020-03-17 14:14:08 -0700456TEST_P(AidlTest, RejectUnsupportedParcelableDefineAnnotations) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700457 AidlError error;
Steven Morelandebc3c5d2020-09-30 23:40:33 +0000458 const string method = "package a; @nullable parcelable IFoo { String a; String b; }";
Devin Moore097a3ab2020-03-11 16:08:44 -0700459 const string expected_stderr =
Steven Morelandebc3c5d2020-09-30 23:40:33 +0000460 "ERROR: a/IFoo.aidl:1.32-37: 'nullable' is not a supported annotation for this node. "
Jooyung Han90345002020-10-23 15:28:53 +0900461 "It must be one of: Hide, UnsupportedAppUsage, VintfStability, JavaPassthrough, JavaDerive, "
Andrei Homescue61feb52020-08-18 15:44:24 -0700462 "JavaOnlyImmutable, FixedSize, RustDerive\n";
Devin Moorec054bf82020-03-10 16:31:48 -0700463 CaptureStderr();
Steven Morelandebc3c5d2020-09-30 23:40:33 +0000464 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", method, typenames_, GetLanguage(), &error));
Devin Moorec054bf82020-03-10 16:31:48 -0700465 EXPECT_EQ(expected_stderr, GetCapturedStderr());
466 EXPECT_EQ(AidlError::BAD_TYPE, error);
Devin Moore24f68572020-02-26 13:20:59 -0800467}
468
Jiyong Park40782d02020-07-24 19:17:43 +0900469TEST_P(AidlTest, ParsesNonNullableAnnotation) {
470 auto parse_result =
471 Parse("a/IFoo.aidl", "package a; interface IFoo { String f(); }", typenames_, GetLanguage());
472 ASSERT_NE(nullptr, parse_result);
473 const AidlInterface* interface = parse_result->AsInterface();
474 ASSERT_NE(nullptr, interface);
475 ASSERT_FALSE(interface->GetMethods().empty());
476 EXPECT_FALSE(interface->GetMethods()[0]->GetType().IsNullable());
477}
478
Devin Moore7b8d5c92020-03-17 14:14:08 -0700479TEST_P(AidlTest, ParsesNullableAnnotation) {
Jiyong Park40782d02020-07-24 19:17:43 +0900480 auto parse_result = Parse("a/IFoo.aidl", "package a; interface IFoo { @nullable String f(); }",
481 typenames_, GetLanguage());
482 ASSERT_NE(nullptr, parse_result);
483 const AidlInterface* interface = parse_result->AsInterface();
484 ASSERT_NE(nullptr, interface);
485 ASSERT_FALSE(interface->GetMethods().empty());
486 EXPECT_TRUE(interface->GetMethods()[0]->GetType().IsNullable());
487}
488
489TEST_P(AidlTest, ParsesNonUtf8Annotations) {
490 auto parse_result =
491 Parse("a/IFoo.aidl", "package a; interface IFoo { String f(); }", typenames_, GetLanguage());
492 ASSERT_NE(nullptr, parse_result);
493 const AidlInterface* interface = parse_result->AsInterface();
494 ASSERT_NE(nullptr, interface);
495 ASSERT_FALSE(interface->GetMethods().empty());
496 EXPECT_FALSE(interface->GetMethods()[0]->GetType().IsUtf8InCpp());
Christopher Wileyec31a052016-01-25 07:28:51 -0800497}
498
Devin Moore7b8d5c92020-03-17 14:14:08 -0700499TEST_P(AidlTest, ParsesUtf8Annotations) {
Jiyong Park40782d02020-07-24 19:17:43 +0900500 auto parse_result = Parse("a/IFoo.aidl", "package a; interface IFoo { @utf8InCpp String f(); }",
501 typenames_, GetLanguage());
502 ASSERT_NE(nullptr, parse_result);
503 const AidlInterface* interface = parse_result->AsInterface();
504 ASSERT_NE(nullptr, interface);
505 ASSERT_FALSE(interface->GetMethods().empty());
506 EXPECT_TRUE(interface->GetMethods()[0]->GetType().IsUtf8InCpp());
Christopher Wileyec31a052016-01-25 07:28:51 -0800507}
508
Devin Moore7b8d5c92020-03-17 14:14:08 -0700509TEST_P(AidlTest, VintfRequiresStructuredAndStability) {
Steven Morelanda57d0a62019-07-30 09:41:14 -0700510 AidlError error;
Devin Moore0d0e3f62020-03-30 17:45:39 -0700511 const string expected_stderr =
512 "ERROR: IFoo.aidl:1.16-26: Must compile @VintfStability type w/ aidl_interface 'stability: "
513 "\"vintf\"'\n"
514 "ERROR: IFoo.aidl:1.16-26: Must compile @VintfStability type w/ aidl_interface "
515 "--structured\n";
516 CaptureStderr();
Devin Moore097a3ab2020-03-11 16:08:44 -0700517 ASSERT_EQ(nullptr, Parse("IFoo.aidl", "@VintfStability interface IFoo {}", typenames_,
Devin Moore7b8d5c92020-03-17 14:14:08 -0700518 GetLanguage(), &error));
Devin Moore0d0e3f62020-03-30 17:45:39 -0700519 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Steven Morelanda57d0a62019-07-30 09:41:14 -0700520 ASSERT_EQ(AidlError::NOT_STRUCTURED, error);
Steven Morelanda57d0a62019-07-30 09:41:14 -0700521}
522
Devin Moore7b8d5c92020-03-17 14:14:08 -0700523TEST_P(AidlTest, VintfRequiresStructured) {
Steven Morelanda57d0a62019-07-30 09:41:14 -0700524 AidlError error;
Devin Moore0d0e3f62020-03-30 17:45:39 -0700525 const string expected_stderr =
526 "ERROR: IFoo.aidl:1.16-26: Must compile @VintfStability type w/ aidl_interface "
527 "--structured\n";
528 CaptureStderr();
Devin Moore097a3ab2020-03-11 16:08:44 -0700529 ASSERT_EQ(nullptr, Parse("IFoo.aidl", "@VintfStability interface IFoo {}", typenames_,
Devin Moore7b8d5c92020-03-17 14:14:08 -0700530 GetLanguage(), &error, {"--stability", "vintf"}));
Devin Moore0d0e3f62020-03-30 17:45:39 -0700531 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Steven Morelanda57d0a62019-07-30 09:41:14 -0700532 ASSERT_EQ(AidlError::NOT_STRUCTURED, error);
Steven Morelanda57d0a62019-07-30 09:41:14 -0700533}
534
Devin Moore7b8d5c92020-03-17 14:14:08 -0700535TEST_P(AidlTest, VintfRequiresSpecifiedStability) {
Steven Morelanda57d0a62019-07-30 09:41:14 -0700536 AidlError error;
Devin Moore097a3ab2020-03-11 16:08:44 -0700537 const string expected_stderr =
538 "ERROR: IFoo.aidl:1.16-26: Must compile @VintfStability type w/ aidl_interface 'stability: "
539 "\"vintf\"'\n";
540 CaptureStderr();
541 ASSERT_EQ(nullptr, Parse("IFoo.aidl", "@VintfStability interface IFoo {}", typenames_,
Devin Moore7b8d5c92020-03-17 14:14:08 -0700542 GetLanguage(), &error, {"--structured"}));
Devin Moore097a3ab2020-03-11 16:08:44 -0700543 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Steven Morelanda57d0a62019-07-30 09:41:14 -0700544 ASSERT_EQ(AidlError::NOT_STRUCTURED, error);
Steven Morelanda57d0a62019-07-30 09:41:14 -0700545}
546
Devin Moore7b8d5c92020-03-17 14:14:08 -0700547TEST_P(AidlTest, ParsesStabilityAnnotations) {
Steven Morelanda57d0a62019-07-30 09:41:14 -0700548 AidlError error;
Devin Moore7b8d5c92020-03-17 14:14:08 -0700549 auto parse_result = Parse("IFoo.aidl", "@VintfStability interface IFoo {}", typenames_,
550 GetLanguage(), &error, {"--structured", "--stability", "vintf"});
Steven Morelanda57d0a62019-07-30 09:41:14 -0700551 ASSERT_EQ(AidlError::OK, error);
552 ASSERT_NE(nullptr, parse_result);
553 const AidlInterface* interface = parse_result->AsInterface();
554 ASSERT_NE(nullptr, interface);
555 ASSERT_TRUE(interface->IsVintfStability());
Steven Morelanda57d0a62019-07-30 09:41:14 -0700556}
557
Jeongik Cha64783ed2019-06-07 18:30:54 +0900558TEST_F(AidlTest, ParsesJavaOnlyStableParcelable) {
559 Options java_options = Options::From("aidl -o out --structured a/Foo.aidl");
Jeongik Cha88f95a82020-01-15 13:02:16 +0900560 Options cpp_options = Options::From("aidl --lang=cpp -o out -h out/include a/Foo.aidl");
561 Options cpp_structured_options =
Jeongik Cha64783ed2019-06-07 18:30:54 +0900562 Options::From("aidl --lang=cpp --structured -o out -h out/include a/Foo.aidl");
Andrei Homescub62afd92020-05-11 19:24:59 -0700563 Options rust_options = Options::From("aidl --lang=rust -o out --structured a/Foo.aidl");
Jeongik Cha64783ed2019-06-07 18:30:54 +0900564 io_delegate_.SetFileContents(
Jeongik Cha88f95a82020-01-15 13:02:16 +0900565 "a/Foo.aidl",
566 StringPrintf("package a; @JavaOnlyStableParcelable parcelable Foo cpp_header \"Foo.h\" ;"));
Jeongik Cha64783ed2019-06-07 18:30:54 +0900567
568 EXPECT_EQ(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
Jeongik Cha88f95a82020-01-15 13:02:16 +0900569 EXPECT_EQ(0, ::android::aidl::compile_aidl(cpp_options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -0700570 const string expected_stderr =
Jeongik Cha88f95a82020-01-15 13:02:16 +0900571 "ERROR: a/Foo.aidl:1.48-52: Cannot declared parcelable in a --structured interface. "
Devin Moorec054bf82020-03-10 16:31:48 -0700572 "Parcelable must be defined in AIDL directly.\n";
573 CaptureStderr();
Jeongik Cha88f95a82020-01-15 13:02:16 +0900574 EXPECT_NE(0, ::android::aidl::compile_aidl(cpp_structured_options, io_delegate_));
Devin Moorec054bf82020-03-10 16:31:48 -0700575 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Andrei Homescub62afd92020-05-11 19:24:59 -0700576
577 CaptureStderr();
578 EXPECT_NE(0, ::android::aidl::compile_aidl(rust_options, io_delegate_));
579 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jeongik Cha64783ed2019-06-07 18:30:54 +0900580}
581
Jooyung Han1cbc4962020-10-25 10:07:15 +0900582TEST_F(AidlTest, ParcelableSupportJavaDeriveToString) {
583 io_delegate_.SetFileContents("a/Foo.aidl", R"(package a;
584 @JavaDerive(toString=true) parcelable Foo { int a; float b; })");
585 Options java_options = Options::From("aidl --lang=java -o out a/Foo.aidl");
Jiyong Park43113fb2020-07-20 16:26:19 +0900586 EXPECT_EQ(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
587
588 string java_out;
Jooyung Han1cbc4962020-10-25 10:07:15 +0900589 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/Foo.java", &java_out));
Jiyong Park43113fb2020-07-20 16:26:19 +0900590 EXPECT_THAT(java_out, testing::HasSubstr("public String toString() {"));
591
592 // Other backends shouldn't be bothered
Jooyung Han1cbc4962020-10-25 10:07:15 +0900593 Options cpp_options = Options::From("aidl --lang=cpp -o out -h out a/Foo.aidl");
Jiyong Park43113fb2020-07-20 16:26:19 +0900594 EXPECT_EQ(0, ::android::aidl::compile_aidl(cpp_options, io_delegate_));
595
Jooyung Han1cbc4962020-10-25 10:07:15 +0900596 Options ndk_options = Options::From("aidl --lang=ndk -o out -h out a/Foo.aidl");
Jiyong Park43113fb2020-07-20 16:26:19 +0900597 EXPECT_EQ(0, ::android::aidl::compile_aidl(ndk_options, io_delegate_));
598}
599
Jooyung Han1cbc4962020-10-25 10:07:15 +0900600TEST_F(AidlTest, UnionSupportJavaDeriveToString) {
601 io_delegate_.SetFileContents("a/Foo.aidl", R"(package a;
602 @JavaDerive(toString=true) union Foo { int a; int[] b; })");
603 CaptureStderr();
604 Options java_options = Options::From("aidl --lang=java -o out a/Foo.aidl");
605 EXPECT_EQ(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
606 EXPECT_EQ("", GetCapturedStderr());
607
608 const string expected_to_string_method = R"--(
609 @Override
610 public String toString() {
611 switch (_tag) {
612 case a: return "a.Foo.a(" + (getA()) + ")";
613 case b: return "a.Foo.b(" + (java.util.Arrays.toString(getB())) + ")";
614 }
615 throw new IllegalStateException("unknown field: " + _tag);
616 }
617)--";
618
619 string java_out;
620 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/Foo.java", &java_out));
621 EXPECT_THAT(java_out, testing::HasSubstr(expected_to_string_method));
622}
623
Jooyung Han90345002020-10-23 15:28:53 +0900624TEST_F(AidlTest, RejectsJavaDeriveAnnotation) {
Jiyong Park43113fb2020-07-20 16:26:19 +0900625 {
Jooyung Han90345002020-10-23 15:28:53 +0900626 io_delegate_.SetFileContents("a/Foo.aidl",
627 "package a; @JavaDerive(blah=true) parcelable Foo{}");
628 Options java_options = Options::From("aidl --lang=java -o out a/Foo.aidl");
629 CaptureStderr();
630 EXPECT_NE(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
631 const std::string expected_stderr =
632 "ERROR: a/Foo.aidl:1.11-34: Parameter blah not supported for annotation JavaDerive.";
633 EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr(expected_stderr));
634 }
635
636 {
637 io_delegate_.SetFileContents("a/IFoo.aidl", "package a; @JavaDerive interface IFoo{}");
Jiyong Park43113fb2020-07-20 16:26:19 +0900638 Options java_options = Options::From("aidl --lang=java -o out a/IFoo.aidl");
639 CaptureStderr();
640 EXPECT_NE(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
641 const std::string expected_stderr =
Jooyung Han90345002020-10-23 15:28:53 +0900642 "ERROR: a/IFoo.aidl:1.23-33: 'JavaDerive' is not a supported annotation for this node. "
Jiyong Park27fd7fd2020-08-27 16:25:09 +0900643 "It must be one of: Hide, UnsupportedAppUsage, VintfStability, JavaPassthrough, "
644 "Descriptor\n";
Jiyong Park43113fb2020-07-20 16:26:19 +0900645 EXPECT_EQ(expected_stderr, GetCapturedStderr());
646 }
647
648 {
Jooyung Han90345002020-10-23 15:28:53 +0900649 io_delegate_.SetFileContents("a/IFoo.aidl", "package a; @JavaDerive enum IFoo { A=1, }");
Jiyong Park43113fb2020-07-20 16:26:19 +0900650 Options java_options = Options::From("aidl --lang=java -o out a/IFoo.aidl");
651 CaptureStderr();
652 EXPECT_NE(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
653 const std::string expected_stderr =
Jooyung Han90345002020-10-23 15:28:53 +0900654 "ERROR: a/IFoo.aidl:1.28-33: 'JavaDerive' is not a supported annotation for this node. "
Jiyong Park43113fb2020-07-20 16:26:19 +0900655 "It must be one of: Backing, Hide, VintfStability, JavaPassthrough\n";
656 EXPECT_EQ(expected_stderr, GetCapturedStderr());
657 }
658}
659
Jiyong Park27fd7fd2020-08-27 16:25:09 +0900660TEST_P(AidlTest, ParseDescriptorAnnotation) {
661 AidlError error;
662 auto parse_result = Parse("IFoo.aidl", R"(@Descriptor(value="IBar") interface IFoo{})",
663 typenames_, GetLanguage(), &error, {"--structured"});
664 ASSERT_EQ(AidlError::OK, error);
665 ASSERT_NE(nullptr, parse_result);
666 const AidlInterface* interface = parse_result->AsInterface();
667 ASSERT_NE(nullptr, interface);
668 ASSERT_EQ("IBar", interface->GetDescriptor());
669}
670
Jiyong Park40782d02020-07-24 19:17:43 +0900671TEST_P(AidlTest, AcceptsOnewayMethod) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700672 const string oneway_method = "package a; interface IFoo { oneway void f(int a); }";
Devin Moore7b8d5c92020-03-17 14:14:08 -0700673 EXPECT_NE(nullptr, Parse("a/IFoo.aidl", oneway_method, typenames_, GetLanguage()));
Jiyong Park40782d02020-07-24 19:17:43 +0900674}
675
676TEST_P(AidlTest, AcceptsOnewayInterface) {
677 const string oneway_interface = "package a; oneway interface IBar { void f(int a); }";
Devin Moore7b8d5c92020-03-17 14:14:08 -0700678 EXPECT_NE(nullptr, Parse("a/IBar.aidl", oneway_interface, typenames_, GetLanguage()));
Christopher Wiley90be4e32015-10-20 14:55:25 -0700679}
Christopher Wileyef140932015-11-03 09:29:19 -0800680
Devin Moore7b8d5c92020-03-17 14:14:08 -0700681TEST_P(AidlTest, AcceptsAnnotatedOnewayMethod) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700682 const string oneway_method =
683 "package a; interface IFoo { @UnsupportedAppUsage oneway void f(int a); }";
Devin Moore7b8d5c92020-03-17 14:14:08 -0700684 EXPECT_NE(nullptr, Parse("a/IFoo.aidl", oneway_method, typenames_, GetLanguage()));
Artur Satayev91fe8712019-07-29 13:06:01 +0100685}
686
Steven Moreland65297cc2020-04-20 20:17:36 -0700687TEST_P(AidlTest, AnnotationsInMultiplePlaces) {
688 const string oneway_method =
689 "package a; interface IFoo { @UnsupportedAppUsage oneway @Hide void f(int a); }";
690 const AidlDefinedType* defined = Parse("a/IFoo.aidl", oneway_method, typenames_, GetLanguage());
691 ASSERT_NE(nullptr, defined);
692 const AidlInterface* iface = defined->AsInterface();
693 ASSERT_NE(nullptr, iface);
694
695 const auto& methods = iface->GetMethods();
696 ASSERT_EQ(1u, methods.size());
697 const auto& method = methods[0];
698 const AidlTypeSpecifier& ret_type = method->GetType();
699
700 // TODO(b/151102494): these annotations should be on the method
701 ASSERT_NE(nullptr, ret_type.UnsupportedAppUsage());
702 ASSERT_TRUE(ret_type.IsHide());
703}
704
Devin Moore7b8d5c92020-03-17 14:14:08 -0700705TEST_P(AidlTest, WritesComments) {
Artur Satayev91fe8712019-07-29 13:06:01 +0100706 string foo_interface =
707 "package a; /* foo */ interface IFoo {"
708 " /* i */ int i();"
709 " /* j */ @nullable String j();"
710 " /* k */ @UnsupportedAppUsage oneway void k(int a); }";
711
Devin Moore7b8d5c92020-03-17 14:14:08 -0700712 auto parse_result = Parse("a/IFoo.aidl", foo_interface, typenames_, GetLanguage());
Artur Satayev91fe8712019-07-29 13:06:01 +0100713 EXPECT_NE(nullptr, parse_result);
714 EXPECT_EQ("/* foo */", parse_result->GetComments());
715
716 const AidlInterface* interface = parse_result->AsInterface();
717 EXPECT_EQ("/* i */", interface->GetMethods()[0]->GetComments());
718 EXPECT_EQ("/* j */", interface->GetMethods()[1]->GetComments());
719 EXPECT_EQ("/* k */", interface->GetMethods()[2]->GetComments());
720}
721
Jooyung Han1a551d32020-10-05 15:37:26 +0900722TEST_P(AidlTest, CppHeaderCanBeIdentifierAsWell) {
723 io_delegate_.SetFileContents("p/cpp_header.aidl",
724 R"(package p;
725 parcelable cpp_header cpp_header "bar/header";)");
726 import_paths_.emplace("");
727 const string input_path = "p/IFoo.aidl";
728 const string input = R"(package p;
729 import p.cpp_header;
730 interface IFoo {
731 // get bar
732 cpp_header get();
733 })";
734
735 auto parse_result = Parse(input_path, input, typenames_, GetLanguage());
736 EXPECT_NE(nullptr, parse_result);
737 const AidlInterface* interface = parse_result->AsInterface();
738 EXPECT_EQ("// get bar\n", interface->GetMethods()[0]->GetComments());
739}
740
Christopher Wileyef140932015-11-03 09:29:19 -0800741TEST_F(AidlTest, ParsesPreprocessedFile) {
742 string simple_content = "parcelable a.Foo;\ninterface b.IBar;";
743 io_delegate_.SetFileContents("path", simple_content);
Steven Morelandcb1bcd72020-04-29 16:30:35 -0700744 EXPECT_FALSE(typenames_.ResolveTypename("a.Foo").is_resolved);
Jeongik Cha047c5ee2019-08-07 23:16:49 +0900745 EXPECT_TRUE(parse_preprocessed_file(io_delegate_, "path", &typenames_));
Steven Morelandcb1bcd72020-04-29 16:30:35 -0700746 EXPECT_TRUE(typenames_.ResolveTypename("a.Foo").is_resolved);
747 EXPECT_TRUE(typenames_.ResolveTypename("b.IBar").is_resolved);
Christopher Wileyef140932015-11-03 09:29:19 -0800748}
749
750TEST_F(AidlTest, ParsesPreprocessedFileWithWhitespace) {
751 string simple_content = "parcelable a.Foo;\n interface b.IBar ;\t";
752 io_delegate_.SetFileContents("path", simple_content);
Jeongik Cha047c5ee2019-08-07 23:16:49 +0900753
Steven Morelandcb1bcd72020-04-29 16:30:35 -0700754 EXPECT_FALSE(typenames_.ResolveTypename("a.Foo").is_resolved);
Jeongik Cha047c5ee2019-08-07 23:16:49 +0900755 EXPECT_TRUE(parse_preprocessed_file(io_delegate_, "path", &typenames_));
Steven Morelandcb1bcd72020-04-29 16:30:35 -0700756 EXPECT_TRUE(typenames_.ResolveTypename("a.Foo").is_resolved);
757 EXPECT_TRUE(typenames_.ResolveTypename("b.IBar").is_resolved);
Christopher Wileyef140932015-11-03 09:29:19 -0800758}
759
Devin Moore7b8d5c92020-03-17 14:14:08 -0700760TEST_P(AidlTest, PreferImportToPreprocessed) {
Christopher Wiley41544372015-11-03 14:52:29 -0800761 io_delegate_.SetFileContents("preprocessed", "interface another.IBar;");
762 io_delegate_.SetFileContents("one/IBar.aidl", "package one; "
763 "interface IBar {}");
764 preprocessed_files_.push_back("preprocessed");
Jiyong Park8c380532018-08-30 14:55:26 +0900765 import_paths_.emplace("");
Jeongik Cha047c5ee2019-08-07 23:16:49 +0900766 auto parse_result = Parse("p/IFoo.aidl", "package p; import one.IBar; interface IFoo {}",
Devin Moore7b8d5c92020-03-17 14:14:08 -0700767 typenames_, GetLanguage());
Christopher Wiley41544372015-11-03 14:52:29 -0800768 EXPECT_NE(nullptr, parse_result);
Jeongik Cha047c5ee2019-08-07 23:16:49 +0900769
Christopher Wiley41544372015-11-03 14:52:29 -0800770 // We expect to know about both kinds of IBar
Steven Morelandcb1bcd72020-04-29 16:30:35 -0700771 EXPECT_TRUE(typenames_.ResolveTypename("one.IBar").is_resolved);
772 EXPECT_TRUE(typenames_.ResolveTypename("another.IBar").is_resolved);
Christopher Wiley41544372015-11-03 14:52:29 -0800773 // But if we request just "IBar" we should get our imported one.
Steven Moreland02e012e2018-08-02 14:58:10 -0700774 AidlTypeSpecifier ambiguous_type(AIDL_LOCATION_HERE, "IBar", false, nullptr, "");
Jeongik Cha047c5ee2019-08-07 23:16:49 +0900775 ambiguous_type.Resolve(typenames_);
776 EXPECT_EQ("one.IBar", ambiguous_type.GetName());
Christopher Wiley41544372015-11-03 14:52:29 -0800777}
778
Jiyong Park8f6ec462020-01-19 20:52:47 +0900779// Special case of PreferImportToPreprocessed. Imported type should be preferred
780// even when the preprocessed file already has the same type.
Devin Moore7b8d5c92020-03-17 14:14:08 -0700781TEST_P(AidlTest, B147918827) {
Jiyong Park8f6ec462020-01-19 20:52:47 +0900782 io_delegate_.SetFileContents("preprocessed", "interface another.IBar;\ninterface one.IBar;");
783 io_delegate_.SetFileContents("one/IBar.aidl",
784 "package one; "
785 "interface IBar {}");
786 preprocessed_files_.push_back("preprocessed");
787 import_paths_.emplace("");
788 auto parse_result = Parse("p/IFoo.aidl", "package p; import one.IBar; interface IFoo {}",
Devin Moore7b8d5c92020-03-17 14:14:08 -0700789 typenames_, GetLanguage());
Jiyong Park8f6ec462020-01-19 20:52:47 +0900790 EXPECT_NE(nullptr, parse_result);
791
792 // We expect to know about both kinds of IBar
Steven Morelandcb1bcd72020-04-29 16:30:35 -0700793 EXPECT_TRUE(typenames_.ResolveTypename("one.IBar").is_resolved);
794 EXPECT_TRUE(typenames_.ResolveTypename("another.IBar").is_resolved);
Jiyong Park8f6ec462020-01-19 20:52:47 +0900795 // But if we request just "IBar" we should get our imported one.
796 AidlTypeSpecifier ambiguous_type(AIDL_LOCATION_HERE, "IBar", false, nullptr, "");
797 ambiguous_type.Resolve(typenames_);
798 EXPECT_EQ("one.IBar", ambiguous_type.GetName());
799}
800
Casey Dahlinc1f39b42015-11-24 10:34:34 -0800801TEST_F(AidlTest, WritePreprocessedFile) {
802 io_delegate_.SetFileContents("p/Outer.aidl",
803 "package p; parcelable Outer.Inner;");
804 io_delegate_.SetFileContents("one/IBar.aidl", "package one; import p.Outer;"
805 "interface IBar {}");
806
Jiyong Park6f77e0c2018-07-28 16:55:44 +0900807 vector<string> args {
808 "aidl",
809 "--preprocess",
810 "preprocessed",
811 "p/Outer.aidl",
812 "one/IBar.aidl"};
813 Options options = Options::From(args);
Casey Dahlinc1f39b42015-11-24 10:34:34 -0800814 EXPECT_TRUE(::android::aidl::preprocess_aidl(options, io_delegate_));
815
816 string output;
817 EXPECT_TRUE(io_delegate_.GetWrittenContents("preprocessed", &output));
818 EXPECT_EQ("parcelable p.Outer.Inner;\ninterface one.IBar;\n", output);
819}
820
Jeongik Chaa755c2a2018-12-12 16:28:23 +0900821TEST_F(AidlTest, JavaParcelableOutput) {
Andrei Onea9445fc62019-06-27 18:11:59 +0100822 io_delegate_.SetFileContents(
823 "Rect.aidl",
Makoto Onuki78a1c1c2020-03-04 16:57:23 -0800824 "@Hide\n"
Andrei Onea9445fc62019-06-27 18:11:59 +0100825 "parcelable Rect {\n"
826 " // Comment\n"
Makoto Onuki78a1c1c2020-03-04 16:57:23 -0800827 " @Hide\n"
Andrei Onea9445fc62019-06-27 18:11:59 +0100828 " int x=5;\n"
Makoto Onuki78a1c1c2020-03-04 16:57:23 -0800829 " @Hide\n"
Andrei Onea9445fc62019-06-27 18:11:59 +0100830 " @UnsupportedAppUsage(maxTargetSdk = 28, trackingBug = 42, implicitMember = \"dummy\", "
Andrei Onea07fa3e02019-07-04 17:55:19 +0100831 "expectedSignature = \"dummy\", publicAlternatives = \"d\" \n + \"u\" + \n \"m\" \n + \"m\" "
832 "+ \"y\")\n"
Andrei Onea9445fc62019-06-27 18:11:59 +0100833 " int y;\n"
Jiyong Parkd4e73c82019-07-24 21:39:15 +0900834 " ParcelFileDescriptor fd;\n"
Jooyung Hand2fa0232020-10-19 02:51:41 +0900835 " List<ParcelFileDescriptor> fds;\n"
Andrei Onea9445fc62019-06-27 18:11:59 +0100836 "}");
Jeongik Chaa755c2a2018-12-12 16:28:23 +0900837
838 vector<string> args{"aidl", "Rect.aidl"};
839 Options options = Options::From(args);
840 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
841
842 string output;
843 EXPECT_TRUE(io_delegate_.GetWrittenContents("Rect.java", &output));
Jooyung Hand2fa0232020-10-19 02:51:41 +0900844 EXPECT_EQ(kExpectedJavaParcelableOutputContents, output);
Jeongik Chaa755c2a2018-12-12 16:28:23 +0900845}
846
Devin Moore2f2077a2020-08-28 11:27:53 -0700847TEST_F(AidlTest, CppHeaderIncludes) {
848 io_delegate_.SetFileContents("IFoo.aidl",
849 "interface IFoo {\n"
850 " @nullable List<String> foo();\n"
851 "}");
852
853 vector<string> args{"aidl", "--lang=cpp", "IFoo.aidl"};
854 Options options = Options::From(args);
855 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
856 std::vector<std::string> empty;
857 EXPECT_EQ(empty, io_delegate_.ListFiles(""));
858 EXPECT_EQ(empty, io_delegate_.ListFiles("/"));
859 EXPECT_EQ(empty, io_delegate_.ListFiles("out"));
860
861 // Make sure the optional and String16.h includes are added
862 string output;
863 EXPECT_TRUE(io_delegate_.GetWrittenContents("IFoo.h", &output));
864 EXPECT_EQ(kExpectedCppHeaderOutput, output);
865}
866
Devin Moore7b8d5c92020-03-17 14:14:08 -0700867TEST_P(AidlTest, RequireOuterClass) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700868 const string expected_stderr = "ERROR: p/IFoo.aidl:1.54-60: Failed to resolve 'Inner'\n";
Christopher Wiley63bce2a2015-11-03 14:55:03 -0800869 io_delegate_.SetFileContents("p/Outer.aidl",
870 "package p; parcelable Outer.Inner;");
Jiyong Park8c380532018-08-30 14:55:26 +0900871 import_paths_.emplace("");
Devin Moore097a3ab2020-03-11 16:08:44 -0700872 CaptureStderr();
873 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl",
874 "package p; import p.Outer; interface IFoo { void f(in Inner c); }",
Devin Moore7b8d5c92020-03-17 14:14:08 -0700875 typenames_, GetLanguage()));
Devin Moore097a3ab2020-03-11 16:08:44 -0700876 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Christopher Wiley63bce2a2015-11-03 14:55:03 -0800877}
878
Devin Moore7b8d5c92020-03-17 14:14:08 -0700879TEST_P(AidlTest, ParseCompoundParcelableFromPreprocess) {
Christopher Wiley63bce2a2015-11-03 14:55:03 -0800880 io_delegate_.SetFileContents("preprocessed",
881 "parcelable p.Outer.Inner;");
882 preprocessed_files_.push_back("preprocessed");
Jeongik Cha047c5ee2019-08-07 23:16:49 +0900883 auto parse_result = Parse("p/IFoo.aidl", "package p; interface IFoo { void f(in Inner c); }",
Devin Moore7b8d5c92020-03-17 14:14:08 -0700884 typenames_, GetLanguage());
Christopher Wiley63bce2a2015-11-03 14:55:03 -0800885 // TODO(wiley): This should actually return nullptr because we require
886 // the outer class name. However, for legacy reasons,
887 // this behavior must be maintained. b/17415692
888 EXPECT_NE(nullptr, parse_result);
889}
890
Christopher Wiley632801d2015-11-05 14:15:49 -0800891TEST_F(AidlTest, FailOnParcelable) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700892 const string expected_foo_stderr =
893 "ERROR: p/IFoo.aidl:1.22-27: Refusing to generate code with unstructured parcelables. "
894 "Declared parcelables should be in their own file and/or cannot be used with --structured "
895 "interfaces.\n";
Steven Morelande2c64b42018-09-18 15:06:37 -0700896 io_delegate_.SetFileContents("p/IFoo.aidl", "package p; parcelable IFoo;");
897
Christopher Wiley632801d2015-11-05 14:15:49 -0800898 // By default, we shouldn't fail on parcelable.
Steven Morelande2c64b42018-09-18 15:06:37 -0700899 Options options1 = Options::From("aidl p/IFoo.aidl");
Devin Moore097a3ab2020-03-11 16:08:44 -0700900 CaptureStderr();
Jiyong Parkb034bf02018-07-30 17:44:33 +0900901 EXPECT_EQ(0, ::android::aidl::compile_aidl(options1, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -0700902 EXPECT_EQ("", GetCapturedStderr());
Jiyong Park6f77e0c2018-07-28 16:55:44 +0900903
Steven Morelande2c64b42018-09-18 15:06:37 -0700904 // -b considers this an error
Jiyong Park6f77e0c2018-07-28 16:55:44 +0900905 Options options2 = Options::From("aidl -b p/IFoo.aidl");
Devin Moore097a3ab2020-03-11 16:08:44 -0700906 CaptureStderr();
Jiyong Parkb034bf02018-07-30 17:44:33 +0900907 EXPECT_NE(0, ::android::aidl::compile_aidl(options2, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -0700908 EXPECT_EQ(expected_foo_stderr, GetCapturedStderr());
Steven Morelande2c64b42018-09-18 15:06:37 -0700909
Devin Moore097a3ab2020-03-11 16:08:44 -0700910 const string expected_bar_stderr =
911 "ERROR: p/IBar.aidl:1.22-26: Refusing to generate code with unstructured parcelables. "
912 "Declared parcelables should be in their own file and/or cannot be used with --structured "
913 "interfaces.\n";
Steven Morelande2c64b42018-09-18 15:06:37 -0700914 io_delegate_.SetFileContents("p/IBar.aidl", "package p; parcelable Foo; interface IBar{}");
915
Jiyong Parkda8c6932019-08-12 19:56:08 +0900916 // With '-b' option, a parcelable and an interface should fail.
Steven Morelande2c64b42018-09-18 15:06:37 -0700917 Options options3 = Options::From("aidl p/IBar.aidl");
Devin Moore097a3ab2020-03-11 16:08:44 -0700918 CaptureStderr();
Jiyong Parkda8c6932019-08-12 19:56:08 +0900919 EXPECT_EQ(0, ::android::aidl::compile_aidl(options3, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -0700920 EXPECT_EQ("", GetCapturedStderr());
Steven Morelande2c64b42018-09-18 15:06:37 -0700921 Options options4 = Options::From("aidl -b p/IBar.aidl");
Devin Moore097a3ab2020-03-11 16:08:44 -0700922 CaptureStderr();
Steven Morelande2c64b42018-09-18 15:06:37 -0700923 EXPECT_NE(0, ::android::aidl::compile_aidl(options4, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -0700924 EXPECT_EQ(expected_bar_stderr, GetCapturedStderr());
Christopher Wiley632801d2015-11-05 14:15:49 -0800925}
926
Devin Moore7b8d5c92020-03-17 14:14:08 -0700927TEST_P(AidlTest, StructuredFailOnUnstructuredParcelable) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700928 const string expected_stderr =
929 "ERROR: ./o/WhoKnowsWhat.aidl:1.22-35: o.WhoKnowsWhat is not structured, but this is a "
930 "structured interface.\n";
Steven Moreland1eac5fa2018-08-27 19:35:05 -0700931 io_delegate_.SetFileContents("o/WhoKnowsWhat.aidl", "package o; parcelable WhoKnowsWhat;");
932 import_paths_.emplace("");
Devin Moore097a3ab2020-03-11 16:08:44 -0700933 AidlError error;
934 CaptureStderr();
935 EXPECT_EQ(
936 nullptr,
Steven Moreland1eac5fa2018-08-27 19:35:05 -0700937 Parse("p/IFoo.aidl",
938 "package p; import o.WhoKnowsWhat; interface IFoo { void f(in WhoKnowsWhat thisIs); }",
Devin Moore7b8d5c92020-03-17 14:14:08 -0700939 typenames_, GetLanguage(), &error, {"--structured"}));
Devin Moore097a3ab2020-03-11 16:08:44 -0700940 EXPECT_EQ(expected_stderr, GetCapturedStderr());
941 EXPECT_EQ(AidlError::NOT_STRUCTURED, error);
Steven Moreland1eac5fa2018-08-27 19:35:05 -0700942}
943
Devin Moore7b8d5c92020-03-17 14:14:08 -0700944TEST_P(AidlTest, FailOnDuplicateConstantNames) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700945 AidlError error;
946 const string expected_stderr =
947 "ERROR: p/IFoo.aidl:4.34-45: Found duplicate constant name 'DUPLICATED'\n";
948 CaptureStderr();
Jeongik Cha047c5ee2019-08-07 23:16:49 +0900949 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl",
950 R"(package p;
Christopher Wiley69b44cf2016-05-03 13:43:33 -0700951 interface IFoo {
952 const String DUPLICATED = "d";
953 const int DUPLICATED = 1;
954 }
955 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -0700956 typenames_, GetLanguage(), &error));
Devin Moore097a3ab2020-03-11 16:08:44 -0700957 EXPECT_EQ(expected_stderr, GetCapturedStderr());
958 EXPECT_EQ(AidlError::BAD_TYPE, error);
Christopher Wiley69b44cf2016-05-03 13:43:33 -0700959}
960
Devin Moore7b8d5c92020-03-17 14:14:08 -0700961TEST_P(AidlTest, FailOnManyDefinedTypes) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700962 AidlError error;
Devin Moore5de18ed2020-04-02 13:52:29 -0700963 const string expected_stderr =
964 "ERROR: p/IFoo.aidl:3.33-38: You must declare only one type per file.\n";
Devin Moorec054bf82020-03-10 16:31:48 -0700965 CaptureStderr();
Steven Morelandc258abc2018-07-10 14:03:38 -0700966 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl",
967 R"(package p;
968 interface IFoo {}
Steven Morelandc258abc2018-07-10 14:03:38 -0700969 parcelable IBar {}
970 parcelable StructuredParcelable {}
971 interface IBaz {}
Jeongik Cha2a5b4d82019-08-06 19:37:59 +0900972 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -0700973 typenames_, GetLanguage(), &error));
Devin Moorec054bf82020-03-10 16:31:48 -0700974 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Steven Morelandc258abc2018-07-10 14:03:38 -0700975 // Parse success is important for clear error handling even if the cases aren't
976 // actually supported in code generation.
Devin Moore097a3ab2020-03-11 16:08:44 -0700977 EXPECT_EQ(AidlError::BAD_TYPE, error);
Steven Morelandc258abc2018-07-10 14:03:38 -0700978}
979
Devin Moore7b8d5c92020-03-17 14:14:08 -0700980TEST_P(AidlTest, FailOnNoDefinedTypes) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700981 AidlError error;
982 const string expected_stderr = "ERROR: p/IFoo.aidl:1.11-11: syntax error, unexpected $end\n";
983 CaptureStderr();
Devin Moore7b8d5c92020-03-17 14:14:08 -0700984 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl", R"(package p;)", typenames_, GetLanguage(), &error));
Devin Moore097a3ab2020-03-11 16:08:44 -0700985 EXPECT_EQ(expected_stderr, GetCapturedStderr());
986 EXPECT_EQ(AidlError::PARSE_ERROR, error);
Steven Morelandc258abc2018-07-10 14:03:38 -0700987}
988
Steven Morelandf9e922f2020-07-08 21:15:27 +0000989TEST_P(AidlTest, FailOnEmptyListWithComma) {
990 AidlError error;
991 const string expected_stderr =
992 "ERROR: p/Foo.aidl:1.45-47: syntax error, unexpected ',', expecting '}'\n";
993 CaptureStderr();
994 EXPECT_EQ(nullptr, Parse("p/Foo.aidl", R"(package p; parcelable Foo { uint64_t[] a = { , }; })",
995 typenames_, GetLanguage(), &error));
996 EXPECT_EQ(expected_stderr, GetCapturedStderr());
997 EXPECT_EQ(AidlError::PARSE_ERROR, error);
998}
999
Devin Moore7b8d5c92020-03-17 14:14:08 -07001000TEST_P(AidlTest, FailOnMalformedConstHexValue) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001001 AidlError error;
1002 const string expected_stderr =
Devin Moore2a088902020-09-17 10:51:19 -07001003 "ERROR: p/IFoo.aidl:3.50-71: Could not parse hexvalue: 0xffffffffffffffffff\n";
Devin Moore097a3ab2020-03-11 16:08:44 -07001004 CaptureStderr();
Jeongik Cha047c5ee2019-08-07 23:16:49 +09001005 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl",
1006 R"(package p;
Roshan Pius3b2203d2016-07-22 16:13:20 -07001007 interface IFoo {
1008 const int BAD_HEX_VALUE = 0xffffffffffffffffff;
1009 }
1010 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -07001011 typenames_, GetLanguage(), &error));
Devin Moore097a3ab2020-03-11 16:08:44 -07001012 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1013 EXPECT_EQ(AidlError::PARSE_ERROR, error);
Roshan Pius3b2203d2016-07-22 16:13:20 -07001014}
1015
Jiyong Park18132182020-06-08 20:24:40 +09001016TEST_P(AidlTest, FailOnMalformedQualifiedNameAsIdentifier) {
1017 AidlError error;
1018 const string expected_stderr =
1019 "ERROR: p/IFoo.aidl:1.25-26: syntax error, unexpected ';', expecting identifier or "
1020 "cpp_header (which can also be used as an identifier)\n";
1021 CaptureStderr();
1022 // Notice the trailing dot(.) in the name, which isn't a correct name
1023 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl", R"(package p; parcelable A.; )", typenames_,
1024 GetLanguage(), &error));
1025 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1026 EXPECT_EQ(AidlError::PARSE_ERROR, error);
1027}
1028
1029TEST_P(AidlTest, FailOnMalformedQualifiedNameAsPackage) {
1030 AidlError error;
1031 const string expected_stderr =
1032 "ERROR: p/IFoo.aidl:1.11-12: syntax error, unexpected ';', expecting identifier or "
1033 "cpp_header (which can also be used as an identifier)\n";
1034 CaptureStderr();
1035 // Notice the trailing dot(.) in the package name
1036 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl", R"(package p.; parcelable A; )", typenames_,
1037 GetLanguage(), &error));
1038 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1039 EXPECT_EQ(AidlError::PARSE_ERROR, error);
1040}
1041
Devin Moore7b8d5c92020-03-17 14:14:08 -07001042TEST_P(AidlTest, ParsePositiveConstHexValue) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001043 AidlError error;
Devin Moore7b8d5c92020-03-17 14:14:08 -07001044 auto parse_result = Parse("p/IFoo.aidl",
1045 R"(package p;
Roshan Pius3b2203d2016-07-22 16:13:20 -07001046 interface IFoo {
1047 const int POSITIVE_HEX_VALUE = 0xf5;
1048 }
1049 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -07001050 typenames_, GetLanguage(), &error);
1051 EXPECT_NE(nullptr, parse_result);
1052 const AidlInterface* interface = parse_result->AsInterface();
Steven Moreland5557f1c2018-07-02 13:50:23 -07001053 ASSERT_NE(nullptr, interface);
Steven Moreland693640b2018-07-19 13:46:27 -07001054 const auto& cpp_constants = interface->GetConstantDeclarations();
1055 EXPECT_EQ((size_t)1, cpp_constants.size());
1056 EXPECT_EQ("POSITIVE_HEX_VALUE", cpp_constants[0]->GetName());
Will McVickerd7d18df2019-09-12 13:40:50 -07001057 EXPECT_TRUE(cpp_constants[0]->CheckValid(typenames_));
Steven Moreland860b1942018-08-16 14:59:28 -07001058 EXPECT_EQ("245", cpp_constants[0]->ValueString(cpp::ConstantValueDecorator));
Roshan Pius3b2203d2016-07-22 16:13:20 -07001059}
1060
Devin Moore7b8d5c92020-03-17 14:14:08 -07001061TEST_P(AidlTest, ParseNegativeConstHexValue) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001062 AidlError error;
Devin Moore7b8d5c92020-03-17 14:14:08 -07001063 auto parse_result = Parse("p/IFoo.aidl",
1064 R"(package p;
Roshan Pius3b2203d2016-07-22 16:13:20 -07001065 interface IFoo {
1066 const int NEGATIVE_HEX_VALUE = 0xffffffff;
1067 }
1068 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -07001069 typenames_, GetLanguage(), &error);
1070 ASSERT_NE(nullptr, parse_result);
1071 const AidlInterface* interface = parse_result->AsInterface();
Steven Moreland5557f1c2018-07-02 13:50:23 -07001072 ASSERT_NE(nullptr, interface);
Steven Moreland693640b2018-07-19 13:46:27 -07001073 const auto& cpp_constants = interface->GetConstantDeclarations();
1074 EXPECT_EQ((size_t)1, cpp_constants.size());
1075 EXPECT_EQ("NEGATIVE_HEX_VALUE", cpp_constants[0]->GetName());
Will McVickerd7d18df2019-09-12 13:40:50 -07001076 EXPECT_EQ(true, cpp_constants[0]->CheckValid(typenames_));
Steven Moreland860b1942018-08-16 14:59:28 -07001077 EXPECT_EQ("-1", cpp_constants[0]->ValueString(cpp::ConstantValueDecorator));
Roshan Pius3b2203d2016-07-22 16:13:20 -07001078}
1079
Devin Moore7b8d5c92020-03-17 14:14:08 -07001080TEST_P(AidlTest, UnderstandsNestedParcelables) {
Ningyuan Wangd17c58b2016-09-29 14:33:14 -07001081 io_delegate_.SetFileContents(
1082 "p/Outer.aidl",
1083 "package p; parcelable Outer.Inner cpp_header \"baz/header\";");
Jiyong Park8c380532018-08-30 14:55:26 +09001084 import_paths_.emplace("");
Ningyuan Wangd17c58b2016-09-29 14:33:14 -07001085 const string input_path = "p/IFoo.aidl";
1086 const string input = "package p; import p.Outer; interface IFoo"
1087 " { Outer.Inner get(); }";
1088
Devin Moore7b8d5c92020-03-17 14:14:08 -07001089 auto parse_result = Parse(input_path, input, typenames_, GetLanguage());
1090 EXPECT_NE(nullptr, parse_result);
Jeongik Cha047c5ee2019-08-07 23:16:49 +09001091
Steven Morelandcb1bcd72020-04-29 16:30:35 -07001092 EXPECT_TRUE(typenames_.ResolveTypename("p.Outer.Inner").is_resolved);
Ningyuan Wangd17c58b2016-09-29 14:33:14 -07001093 // C++ uses "::" instead of "." to refer to a inner class.
Jeongik Cha047c5ee2019-08-07 23:16:49 +09001094 AidlTypeSpecifier nested_type(AIDL_LOCATION_HERE, "p.Outer.Inner", false, nullptr, "");
1095 EXPECT_EQ("::p::Outer::Inner", cpp::CppNameOf(nested_type, typenames_));
Ningyuan Wangd17c58b2016-09-29 14:33:14 -07001096}
1097
Devin Moore7b8d5c92020-03-17 14:14:08 -07001098TEST_P(AidlTest, UnderstandsNativeParcelables) {
Christopher Wiley9078d722015-11-17 10:23:49 -08001099 io_delegate_.SetFileContents(
1100 "p/Bar.aidl",
Casey Dahlincd639212015-12-15 12:51:04 -08001101 "package p; parcelable Bar cpp_header \"baz/header\";");
Jiyong Park8c380532018-08-30 14:55:26 +09001102 import_paths_.emplace("");
Christopher Wiley9078d722015-11-17 10:23:49 -08001103 const string input_path = "p/IFoo.aidl";
1104 const string input = "package p; import p.Bar; interface IFoo { }";
Devin Moore7b8d5c92020-03-17 14:14:08 -07001105 auto parse_result = Parse(input_path, input, typenames_, GetLanguage());
1106 EXPECT_NE(nullptr, parse_result);
Steven Morelandcb1bcd72020-04-29 16:30:35 -07001107 EXPECT_TRUE(typenames_.ResolveTypename("p.Bar").is_resolved);
Devin Moore7b8d5c92020-03-17 14:14:08 -07001108 AidlTypeSpecifier native_type(AIDL_LOCATION_HERE, "p.Bar", false, nullptr, "");
1109 native_type.Resolve(typenames_);
1110
1111 EXPECT_EQ("p.Bar", java::InstantiableJavaSignatureOf(native_type, typenames_));
1112 // C++ understands C++ specific stuff
1113 EXPECT_EQ("::p::Bar", cpp::CppNameOf(native_type, typenames_));
1114 set<string> headers;
Devin Moore2f2077a2020-08-28 11:27:53 -07001115 cpp::AddHeaders(native_type, typenames_, &headers);
Devin Moore7b8d5c92020-03-17 14:14:08 -07001116 EXPECT_EQ(1u, headers.size());
1117 EXPECT_EQ(1u, headers.count("baz/header"));
Christopher Wiley9078d722015-11-17 10:23:49 -08001118}
1119
Christopher Wileyf8136192016-04-12 14:19:35 -07001120TEST_F(AidlTest, WritesCorrectDependencyFile) {
1121 // While the in tree build system always gives us an output file name,
1122 // other android tools take advantage of our ability to infer the intended
1123 // file name. This test makes sure we handle this correctly.
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001124 vector<string> args = {
1125 "aidl",
1126 "-d dep/file/path",
1127 "-o place/for/output",
1128 "p/IFoo.aidl"};
1129 Options options = Options::From(args);
1130 io_delegate_.SetFileContents(options.InputFiles().front(), "package p; interface IFoo {}");
Jiyong Parkb034bf02018-07-30 17:44:33 +09001131 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
Christopher Wileyf8136192016-04-12 14:19:35 -07001132 string actual_dep_file_contents;
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001133 EXPECT_TRUE(io_delegate_.GetWrittenContents(options.DependencyFile(), &actual_dep_file_contents));
Christopher Wileyf8136192016-04-12 14:19:35 -07001134 EXPECT_EQ(actual_dep_file_contents, kExpectedDepFileContents);
1135}
1136
Dan Willemsen93298ee2016-11-10 23:55:55 -08001137TEST_F(AidlTest, WritesCorrectDependencyFileNinja) {
1138 // While the in tree build system always gives us an output file name,
1139 // other android tools take advantage of our ability to infer the intended
1140 // file name. This test makes sure we handle this correctly.
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001141 vector<string> args = {
1142 "aidl",
1143 "-d dep/file/path",
1144 "--ninja",
1145 "-o place/for/output",
1146 "p/IFoo.aidl"};
1147 Options options = Options::From(args);
1148 io_delegate_.SetFileContents(options.InputFiles().front(), "package p; interface IFoo {}");
Jiyong Parkb034bf02018-07-30 17:44:33 +09001149 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
Dan Willemsen93298ee2016-11-10 23:55:55 -08001150 string actual_dep_file_contents;
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001151 EXPECT_TRUE(io_delegate_.GetWrittenContents(options.DependencyFile(), &actual_dep_file_contents));
Dan Willemsen93298ee2016-11-10 23:55:55 -08001152 EXPECT_EQ(actual_dep_file_contents, kExpectedNinjaDepFileContents);
1153}
1154
Jiyong Parkdf202122019-09-30 20:48:35 +09001155TEST_F(AidlTest, WritesTrivialDependencyFileForParcelableDeclaration) {
Christopher Wileyb1bbdf82016-04-21 11:43:45 -07001156 // The SDK uses aidl to decide whether a .aidl file is a parcelable. It does
1157 // this by calling aidl with every .aidl file it finds, then parsing the
1158 // generated dependency files. Those that reference .java output files are
1159 // for interfaces and those that do not are parcelables. However, for both
1160 // parcelables and interfaces, we *must* generate a non-empty dependency file.
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001161 vector<string> args = {
1162 "aidl",
1163 "-o place/for/output",
1164 "-d dep/file/path",
1165 "p/Foo.aidl"};
1166 Options options = Options::From(args);
1167 io_delegate_.SetFileContents(options.InputFiles().front(), "package p; parcelable Foo;");
Jiyong Parkb034bf02018-07-30 17:44:33 +09001168 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
Christopher Wileyb1bbdf82016-04-21 11:43:45 -07001169 string actual_dep_file_contents;
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001170 EXPECT_TRUE(io_delegate_.GetWrittenContents(options.DependencyFile(), &actual_dep_file_contents));
Jiyong Parkdf202122019-09-30 20:48:35 +09001171 EXPECT_EQ(actual_dep_file_contents, kExpectedParcelableDeclarationDepFileContents);
1172}
1173
1174TEST_F(AidlTest, WritesDependencyFileForStructuredParcelable) {
1175 vector<string> args = {
1176 "aidl",
1177 "--structured",
1178 "-o place/for/output",
1179 "-d dep/file/path",
1180 "p/Foo.aidl"};
1181 Options options = Options::From(args);
1182 io_delegate_.SetFileContents(options.InputFiles().front(), "package p; parcelable Foo {int a;}");
1183 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1184 string actual_dep_file_contents;
1185 EXPECT_TRUE(io_delegate_.GetWrittenContents(options.DependencyFile(), &actual_dep_file_contents));
1186 EXPECT_EQ(actual_dep_file_contents, kExpectedStructuredParcelableDepFileContents);
Christopher Wileyb1bbdf82016-04-21 11:43:45 -07001187}
1188
Jiyong Park9ca5c7e2019-10-17 15:01:14 +09001189TEST_F(AidlTest, NoJavaOutputForParcelableDeclaration) {
1190 vector<string> args = {
1191 "aidl",
1192 "--lang=java",
1193 "-o place/for/output",
1194 "p/Foo.aidl"};
1195 Options options = Options::From(args);
1196 io_delegate_.SetFileContents(options.InputFiles().front(), "package p; parcelable Foo;");
1197 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1198 string output_file_contents;
1199 EXPECT_FALSE(io_delegate_.GetWrittenContents(options.OutputFile(), &output_file_contents));
1200}
1201
Jeongik Cha08ca2182019-11-21 14:01:13 +09001202// TODO(b/136048684)
Devin Moore7b8d5c92020-03-17 14:14:08 -07001203TEST_P(AidlTest, PrimitiveList) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001204 const string primitive_interface =
Jeongik Cha08ca2182019-11-21 14:01:13 +09001205 "package a; interface IFoo {\n"
1206 " List<int> foo(); }";
Devin Moore7b8d5c92020-03-17 14:14:08 -07001207 string expected_stderr;
1208 switch (GetLanguage()) {
1209 case Options::Language::CPP:
1210 expected_stderr =
Steven Morelandebc3c5d2020-09-30 23:40:33 +00001211 "ERROR: a/IFoo.aidl:2.1-7: A generic type cannot have any primitive type parameters.\n"
Devin Moore7b8d5c92020-03-17 14:14:08 -07001212 "ERROR: a/IFoo.aidl:2.1-7: List<int> is not supported. List in cpp supports only "
1213 "String and IBinder.\n";
1214 break;
1215 case Options::Language::JAVA:
1216 expected_stderr =
Steven Morelandebc3c5d2020-09-30 23:40:33 +00001217 "ERROR: a/IFoo.aidl:2.1-7: A generic type cannot have any primitive type parameters.\n"
Devin Moore7b8d5c92020-03-17 14:14:08 -07001218 "ERROR: a/IFoo.aidl:2.1-7: List<int> is not supported. List in Java supports only "
1219 "String, IBinder, and ParcelFileDescriptor.\n";
1220 break;
1221 case Options::Language::NDK:
Andrei Homescub62afd92020-05-11 19:24:59 -07001222 case Options::Language::RUST:
1223 expected_stderr =
1224 "ERROR: a/IFoo.aidl:2.1-7: A generic type cannot have any primitive type parameters.\n";
1225 break;
Devin Moore7b8d5c92020-03-17 14:14:08 -07001226 default:
1227 AIDL_FATAL(AIDL_LOCATION_HERE)
1228 << "Unexpected Options::Language enumerator: " << static_cast<size_t>(GetLanguage());
1229 }
1230 CaptureStderr();
Jiyong Park40782d02020-07-24 19:17:43 +09001231 AidlTypenames tn1;
1232 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", primitive_interface, tn1, GetLanguage()));
Devin Moore7b8d5c92020-03-17 14:14:08 -07001233 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Devin Moore7b8d5c92020-03-17 14:14:08 -07001234
1235 string primitive_parcelable =
1236 "package a; parcelable IFoo {\n"
Jeongik Cha08ca2182019-11-21 14:01:13 +09001237 " List<int> foo;}";
Devin Moore097a3ab2020-03-11 16:08:44 -07001238 CaptureStderr();
Jiyong Park40782d02020-07-24 19:17:43 +09001239 AidlTypenames tn2;
1240 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", primitive_parcelable, tn2, GetLanguage()));
Devin Moore7b8d5c92020-03-17 14:14:08 -07001241 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jeongik Cha08ca2182019-11-21 14:01:13 +09001242}
1243
Devin Moore21b26772020-08-26 16:37:56 -07001244TEST_P(AidlTest, RejectsListArray) {
Devin Moore6a01ca12020-08-28 10:24:19 -07001245 const string expected_stderr = "ERROR: a/Foo.aidl:2.1-7: List[] is not supported.\n";
Devin Moore21b26772020-08-26 16:37:56 -07001246 const string list_array_parcelable =
1247 "package a; parcelable Foo {\n"
1248 " List[] lists; }";
1249 CaptureStderr();
1250 EXPECT_EQ(nullptr, Parse("a/Foo.aidl", list_array_parcelable, typenames_, GetLanguage()));
1251 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1252}
1253
Jiyong Parkf8d53612020-05-04 14:06:13 +09001254TEST_P(AidlTest, RejectsPrimitiveListInStableAidl) {
1255 AidlError error;
1256 string expected_stderr =
1257 "ERROR: a/IFoo.aidl:2.7-11: "
1258 "Encountered an untyped List or Map. The use of untyped List/Map is "
1259 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
1260 "the receiving side. Consider switching to an array or a generic List/Map.\n";
1261 if (GetLanguage() != Options::Language::JAVA) {
1262 expected_stderr =
1263 "ERROR: a/IFoo.aidl:2.1-7: "
1264 "Currently, only the Java backend supports non-generic List.\n";
1265 }
1266
1267 const string primitive_interface =
1268 "package a; interface IFoo {\n"
1269 " List foo(); }";
1270 CaptureStderr();
Jiyong Park40782d02020-07-24 19:17:43 +09001271 AidlTypenames tn1;
1272 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", primitive_interface, tn1, GetLanguage(), &error,
Jiyong Parkf8d53612020-05-04 14:06:13 +09001273 {"--structured"}));
1274 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Parkf8d53612020-05-04 14:06:13 +09001275
1276 string primitive_parcelable =
1277 "package a; parcelable IFoo {\n"
1278 " List foo;}";
1279 CaptureStderr();
Jiyong Park40782d02020-07-24 19:17:43 +09001280 AidlTypenames tn2;
1281 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", primitive_parcelable, tn2, GetLanguage(), &error,
Jiyong Parkf8d53612020-05-04 14:06:13 +09001282 {"--structured"}));
1283 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1284}
1285
Jeongik Cha225519b2020-08-29 01:55:32 +09001286TEST_P(AidlTest, ExtensionTest) {
1287 CaptureStderr();
Jeongik Cha649e8a72020-03-27 17:47:40 +09001288 string extendable_parcelable =
1289 "package a; parcelable Data {\n"
1290 " ParcelableHolder extension;\n"
1291 " ParcelableHolder extension2;\n"
1292 "}";
Jeongik Cha8f02a532020-10-14 00:16:28 +09001293 if (GetLanguage() == Options::Language::RUST) {
Jeongik Cha225519b2020-08-29 01:55:32 +09001294 EXPECT_EQ(nullptr, Parse("a/Data.aidl", extendable_parcelable, typenames_, GetLanguage()));
1295 EXPECT_EQ(
Jeongik Cha8f02a532020-10-14 00:16:28 +09001296 "ERROR: a/Data.aidl:2.1-19: The Rust backend does not support ParcelableHolder "
Jeongik Cha225519b2020-08-29 01:55:32 +09001297 "yet.\n",
1298 GetCapturedStderr());
1299 } else {
1300 EXPECT_NE(nullptr, Parse("a/Data.aidl", extendable_parcelable, typenames_, GetLanguage()));
1301 EXPECT_EQ("", GetCapturedStderr());
1302 }
1303}
1304TEST_P(AidlTest, ParcelableHolderAsReturnType) {
1305 CaptureStderr();
Jeongik Cha649e8a72020-03-27 17:47:40 +09001306 string parcelableholder_return_interface =
1307 "package a; interface IFoo {\n"
1308 " ParcelableHolder foo();\n"
1309 "}";
Jeongik Cha225519b2020-08-29 01:55:32 +09001310 EXPECT_EQ(nullptr,
1311 Parse("a/IFoo.aidl", parcelableholder_return_interface, typenames_, GetLanguage()));
Jeongik Cha649e8a72020-03-27 17:47:40 +09001312
Jeongik Cha8f02a532020-10-14 00:16:28 +09001313 if (GetLanguage() == Options::Language::RUST) {
Jeongik Cha225519b2020-08-29 01:55:32 +09001314 EXPECT_EQ(
Steven Morelandebc3c5d2020-09-30 23:40:33 +00001315 "ERROR: a/IFoo.aidl:2.19-23: ParcelableHolder cannot be a return type\n"
Jeongik Cha8f02a532020-10-14 00:16:28 +09001316 "ERROR: a/IFoo.aidl:2.1-19: The Rust backend does not support ParcelableHolder "
Jeongik Cha225519b2020-08-29 01:55:32 +09001317 "yet.\n",
1318 GetCapturedStderr());
1319 return;
1320 }
1321 EXPECT_EQ("ERROR: a/IFoo.aidl:2.19-23: ParcelableHolder cannot be a return type\n",
1322 GetCapturedStderr());
1323}
1324
1325TEST_P(AidlTest, ParcelableHolderAsArgumentType) {
1326 CaptureStderr();
Jeongik Cha649e8a72020-03-27 17:47:40 +09001327 string extendable_parcelable_arg_interface =
1328 "package a; interface IFoo {\n"
1329 " void foo(in ParcelableHolder ph);\n"
1330 "}";
Jeongik Cha225519b2020-08-29 01:55:32 +09001331 EXPECT_EQ(nullptr,
1332 Parse("a/IFoo.aidl", extendable_parcelable_arg_interface, typenames_, GetLanguage()));
1333
Jeongik Cha8f02a532020-10-14 00:16:28 +09001334 if (GetLanguage() == Options::Language::RUST) {
Jeongik Cha225519b2020-08-29 01:55:32 +09001335 EXPECT_EQ(
Steven Morelandebc3c5d2020-09-30 23:40:33 +00001336 "ERROR: a/IFoo.aidl:2.31-34: ParcelableHolder cannot be an argument type\n"
Jeongik Cha8f02a532020-10-14 00:16:28 +09001337 "ERROR: a/IFoo.aidl:2.14-31: The Rust backend does not support ParcelableHolder "
Jeongik Cha225519b2020-08-29 01:55:32 +09001338 "yet.\n",
1339 GetCapturedStderr());
1340 return;
1341 }
1342 EXPECT_EQ("ERROR: a/IFoo.aidl:2.31-34: ParcelableHolder cannot be an argument type\n",
1343 GetCapturedStderr());
Jeongik Cha649e8a72020-03-27 17:47:40 +09001344}
1345
Jeongik Chaf6ec8982020-10-15 00:10:30 +09001346TEST_P(AidlTest, RejectNullableParcelableHolderField) {
1347 io_delegate_.SetFileContents("Foo.aidl", "parcelable Foo { @nullable ParcelableHolder ext; }");
1348 Options options =
1349 Options::From("aidl Foo.aidl --lang=" + Options::LanguageToString(GetLanguage()));
1350 const string expected_stderr = "ERROR: Foo.aidl:1.27-44: ParcelableHolder cannot be nullable.\n";
1351 CaptureStderr();
1352 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
1353 if (GetLanguage() == Options::Language::RUST) {
1354 EXPECT_EQ(
1355 "ERROR: Foo.aidl:1.27-44: ParcelableHolder cannot be nullable.\n"
1356 "ERROR: Foo.aidl:1.27-44: The Rust backend does not support ParcelableHolder "
1357 "yet.\n",
1358 GetCapturedStderr());
1359 return;
1360 }
1361 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1362}
1363
Jiyong Park02da7422018-07-16 16:00:26 +09001364TEST_F(AidlTest, ApiDump) {
1365 io_delegate_.SetFileContents(
1366 "foo/bar/IFoo.aidl",
1367 "package foo.bar;\n"
1368 "import foo.bar.Data;\n"
Jeongik Cha997281d2020-01-16 15:23:59 +09001369 "// comment @hide\n"
Jiyong Park02da7422018-07-16 16:00:26 +09001370 "interface IFoo {\n"
Jeongik Cha997281d2020-01-16 15:23:59 +09001371 " /* @hide */\n"
Jiyong Park02da7422018-07-16 16:00:26 +09001372 " int foo(out int[] a, String b, boolean c, inout List<String> d);\n"
1373 " int foo2(@utf8InCpp String x, inout List<String> y);\n"
1374 " IFoo foo3(IFoo foo);\n"
1375 " Data getData();\n"
Jeongik Cha997281d2020-01-16 15:23:59 +09001376 " // @hide\n"
Jiyong Parka428d212018-08-29 22:26:30 +09001377 " const int A = 1;\n"
1378 " const String STR = \"Hello\";\n"
Jiyong Park02da7422018-07-16 16:00:26 +09001379 "}\n");
1380 io_delegate_.SetFileContents("foo/bar/Data.aidl",
1381 "package foo.bar;\n"
1382 "import foo.bar.IFoo;\n"
Jeongik Cha997281d2020-01-16 15:23:59 +09001383 "/* @hide*/\n"
Jiyong Park02da7422018-07-16 16:00:26 +09001384 "parcelable Data {\n"
Jeongik Cha997281d2020-01-16 15:23:59 +09001385 " // @hide\n"
Jiyong Parka468e2a2018-08-29 21:25:18 +09001386 " int x = 10;\n"
Jeongik Cha997281d2020-01-16 15:23:59 +09001387 " // @hide\n"
Jiyong Park02da7422018-07-16 16:00:26 +09001388 " int y;\n"
1389 " IFoo foo;\n"
1390 " List<IFoo> a;\n"
Jeongik Cha997281d2020-01-16 15:23:59 +09001391 " /*@hide2*/\n"
Jiyong Park02da7422018-07-16 16:00:26 +09001392 " List<foo.bar.IFoo> b;\n"
Jeongik Cha997281d2020-01-16 15:23:59 +09001393 " // It should be @hide property\n"
Jeongik Cha3271ffa2018-12-04 15:19:20 +09001394 " @nullable String[] c;\n"
Jiyong Park02da7422018-07-16 16:00:26 +09001395 "}\n");
1396 io_delegate_.SetFileContents("api.aidl", "");
Jiyong Park633246c2019-11-25 10:50:05 +09001397 vector<string> args = {"aidl", "--dumpapi", "--out=dump", "--include=.",
1398 "foo/bar/IFoo.aidl", "foo/bar/Data.aidl"};
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001399 Options options = Options::From(args);
Jiyong Park02da7422018-07-16 16:00:26 +09001400 bool result = dump_api(options, io_delegate_);
1401 ASSERT_TRUE(result);
1402 string actual;
Jiyong Parke59c3682018-09-11 23:10:25 +09001403 EXPECT_TRUE(io_delegate_.GetWrittenContents("dump/foo/bar/IFoo.aidl", &actual));
Paul Trautrimb01451d2020-02-27 13:10:16 +09001404 EXPECT_EQ(actual, string(kPreamble).append(R"(package foo.bar;
Jeongik Cha997281d2020-01-16 15:23:59 +09001405/* @hide */
Jiyong Parke59c3682018-09-11 23:10:25 +09001406interface IFoo {
Jeongik Cha997281d2020-01-16 15:23:59 +09001407 /* @hide */
Jiyong Parke59c3682018-09-11 23:10:25 +09001408 int foo(out int[] a, String b, boolean c, inout List<String> d);
1409 int foo2(@utf8InCpp String x, inout List<String> y);
1410 foo.bar.IFoo foo3(foo.bar.IFoo foo);
1411 foo.bar.Data getData();
Jeongik Cha997281d2020-01-16 15:23:59 +09001412 /* @hide */
Jiyong Parke59c3682018-09-11 23:10:25 +09001413 const int A = 1;
1414 const String STR = "Hello";
1415}
Paul Trautrimb01451d2020-02-27 13:10:16 +09001416)"));
Jiyong Park02da7422018-07-16 16:00:26 +09001417
Jiyong Parke59c3682018-09-11 23:10:25 +09001418 EXPECT_TRUE(io_delegate_.GetWrittenContents("dump/foo/bar/Data.aidl", &actual));
Paul Trautrimb01451d2020-02-27 13:10:16 +09001419 EXPECT_EQ(actual, string(kPreamble).append(R"(package foo.bar;
Jeongik Cha997281d2020-01-16 15:23:59 +09001420/* @hide */
Jiyong Parke59c3682018-09-11 23:10:25 +09001421parcelable Data {
Jeongik Cha997281d2020-01-16 15:23:59 +09001422 /* @hide */
Jiyong Parke59c3682018-09-11 23:10:25 +09001423 int x = 10;
Jeongik Cha997281d2020-01-16 15:23:59 +09001424 /* @hide */
Jiyong Parke59c3682018-09-11 23:10:25 +09001425 int y;
1426 foo.bar.IFoo foo;
1427 List<foo.bar.IFoo> a;
1428 List<foo.bar.IFoo> b;
Jeongik Cha997281d2020-01-16 15:23:59 +09001429 /* @hide */
Jeongik Cha3271ffa2018-12-04 15:19:20 +09001430 @nullable String[] c;
Jiyong Park02da7422018-07-16 16:00:26 +09001431}
Paul Trautrimb01451d2020-02-27 13:10:16 +09001432)"));
Jiyong Park02da7422018-07-16 16:00:26 +09001433}
1434
Jiyong Parked65bf42018-08-28 15:43:27 +09001435TEST_F(AidlTest, ApiDumpWithManualIds) {
1436 io_delegate_.SetFileContents(
1437 "foo/bar/IFoo.aidl",
1438 "package foo.bar;\n"
1439 "interface IFoo {\n"
1440 " int foo() = 1;\n"
1441 " int bar() = 2;\n"
1442 " int baz() = 10;\n"
1443 "}\n");
1444
Jiyong Parke59c3682018-09-11 23:10:25 +09001445 vector<string> args = {"aidl", "--dumpapi", "-o dump", "foo/bar/IFoo.aidl"};
Jiyong Parked65bf42018-08-28 15:43:27 +09001446 Options options = Options::From(args);
1447 bool result = dump_api(options, io_delegate_);
1448 ASSERT_TRUE(result);
1449 string actual;
Jiyong Parke59c3682018-09-11 23:10:25 +09001450 EXPECT_TRUE(io_delegate_.GetWrittenContents("dump/foo/bar/IFoo.aidl", &actual));
Paul Trautrimb01451d2020-02-27 13:10:16 +09001451 EXPECT_EQ(actual, string(kPreamble).append(R"(package foo.bar;
Jiyong Parke59c3682018-09-11 23:10:25 +09001452interface IFoo {
1453 int foo() = 1;
1454 int bar() = 2;
1455 int baz() = 10;
Jiyong Parked65bf42018-08-28 15:43:27 +09001456}
Paul Trautrimb01451d2020-02-27 13:10:16 +09001457)"));
Jiyong Parked65bf42018-08-28 15:43:27 +09001458}
1459
1460TEST_F(AidlTest, ApiDumpWithManualIdsOnlyOnSomeMethods) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001461 const string expected_stderr =
1462 "ERROR: foo/bar/IFoo.aidl:4.8-12: You must either assign id's to all methods or to none of "
1463 "them.\n";
Jiyong Parked65bf42018-08-28 15:43:27 +09001464 io_delegate_.SetFileContents(
1465 "foo/bar/IFoo.aidl",
1466 "package foo.bar;\n"
1467 "interface IFoo {\n"
1468 " int foo() = 1;\n"
1469 " int bar();\n"
1470 " int baz() = 10;\n"
1471 "}\n");
1472
Jiyong Parke59c3682018-09-11 23:10:25 +09001473 vector<string> args = {"aidl", "--dumpapi", "-o dump", "foo/bar/IFoo.aidl"};
Jiyong Parked65bf42018-08-28 15:43:27 +09001474 Options options = Options::From(args);
Devin Moore097a3ab2020-03-11 16:08:44 -07001475 CaptureStderr();
Jiyong Parked65bf42018-08-28 15:43:27 +09001476 EXPECT_FALSE(dump_api(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001477 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Parked65bf42018-08-28 15:43:27 +09001478}
1479
Jiyong Park1d2df7d2018-07-23 15:22:50 +09001480TEST_F(AidlTest, CheckNumGenericTypeSecifier) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001481 const string expected_list_stderr =
Steven Morelandebc3c5d2020-09-30 23:40:33 +00001482 "ERROR: p/IFoo.aidl:1.37-41: List can only have one type parameter, but got: "
1483 "'List<String,String>'\n";
Devin Moore097a3ab2020-03-11 16:08:44 -07001484 const string expected_map_stderr =
1485 "ERROR: p/IFoo.aidl:1.37-40: Map must have 0 or 2 type parameters, but got 'Map<String>'\n";
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001486 Options options = Options::From("aidl p/IFoo.aidl IFoo.java");
1487 io_delegate_.SetFileContents(options.InputFiles().front(),
Jiyong Park1d2df7d2018-07-23 15:22:50 +09001488 "package p; interface IFoo {"
1489 "void foo(List<String, String> a);}");
Devin Moore097a3ab2020-03-11 16:08:44 -07001490 CaptureStderr();
Jiyong Parkb034bf02018-07-30 17:44:33 +09001491 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001492 EXPECT_EQ(expected_list_stderr, GetCapturedStderr());
Jiyong Park1d2df7d2018-07-23 15:22:50 +09001493
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001494 io_delegate_.SetFileContents(options.InputFiles().front(),
Jiyong Park1d2df7d2018-07-23 15:22:50 +09001495 "package p; interface IFoo {"
1496 "void foo(Map<String> a);}");
Devin Moore097a3ab2020-03-11 16:08:44 -07001497 CaptureStderr();
Jiyong Parkb034bf02018-07-30 17:44:33 +09001498 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001499 EXPECT_EQ(expected_map_stderr, GetCapturedStderr());
Jiyong Parkb034bf02018-07-30 17:44:33 +09001500}
1501
Jeongik Chae48d9942020-01-02 17:39:00 +09001502TEST_F(AidlTest, CheckTypeParameterInMapType) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001503 const string expected_stderr =
1504 "ERROR: p/IFoo.aidl:1.28-31: The type of key in map must be String, but it is 'p.Bar'\n";
Jeongik Chae48d9942020-01-02 17:39:00 +09001505 Options options = Options::From("aidl -I p p/IFoo.aidl");
1506 io_delegate_.SetFileContents("p/Bar.aidl", "package p; parcelable Bar { String s; }");
1507
1508 io_delegate_.SetFileContents("p/IFoo.aidl",
1509 "package p; interface IFoo {"
1510 "Map<String, Bar> foo();}");
1511 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1512
1513 io_delegate_.SetFileContents("p/IFoo.aidl",
1514 "package p; interface IFoo {"
1515 "Map<Bar, Bar> foo();}");
Devin Moore097a3ab2020-03-11 16:08:44 -07001516 CaptureStderr();
Jeongik Chae48d9942020-01-02 17:39:00 +09001517 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001518 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jeongik Chae48d9942020-01-02 17:39:00 +09001519
1520 io_delegate_.SetFileContents("p/IFoo.aidl",
1521 "package p; interface IFoo {"
1522 "Map<String, String> foo();}");
1523 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1524
1525 io_delegate_.SetFileContents("p/IFoo.aidl",
1526 "package p; interface IFoo {"
1527 "Map<String, ParcelFileDescriptor> foo();}");
1528 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1529}
1530
Jeongik Chadf76dc72019-11-28 00:08:47 +09001531TEST_F(AidlTest, WrongGenericType) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001532 const string expected_stderr = "ERROR: p/IFoo.aidl:1.28-34: String is not a generic type.\n";
Jeongik Chadf76dc72019-11-28 00:08:47 +09001533 Options options = Options::From("aidl p/IFoo.aidl IFoo.java");
1534 io_delegate_.SetFileContents(options.InputFiles().front(),
1535 "package p; interface IFoo {"
1536 "String<String> foo(); }");
Devin Moore097a3ab2020-03-11 16:08:44 -07001537 CaptureStderr();
Jeongik Chadf76dc72019-11-28 00:08:47 +09001538 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001539 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jeongik Chadf76dc72019-11-28 00:08:47 +09001540}
1541
1542TEST_F(AidlTest, UserDefinedUnstructuredGenericParcelableType) {
1543 Options optionsForParcelable = Options::From("aidl -I p p/Bar.aidl");
1544 io_delegate_.SetFileContents("p/Bar.aidl", "package p; parcelable Bar<T, T>;");
Devin Moore097a3ab2020-03-11 16:08:44 -07001545 CaptureStderr();
Jeongik Chadf76dc72019-11-28 00:08:47 +09001546 EXPECT_NE(0, ::android::aidl::compile_aidl(optionsForParcelable, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001547 EXPECT_EQ("ERROR: p/Bar.aidl:1.22-26: Every type parameter should be unique.\n",
1548 GetCapturedStderr());
Jeongik Chadf76dc72019-11-28 00:08:47 +09001549
1550 Options options = Options::From("aidl -I p p/IFoo.aidl");
1551 io_delegate_.SetFileContents("p/Bar.aidl", "package p; parcelable Bar;");
1552 io_delegate_.SetFileContents("p/IFoo.aidl",
1553 "package p; interface IFoo {"
1554 "Bar<String, String> foo();}");
Devin Moore097a3ab2020-03-11 16:08:44 -07001555 CaptureStderr();
Jeongik Chadf76dc72019-11-28 00:08:47 +09001556 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001557 EXPECT_EQ("ERROR: p/IFoo.aidl:1.28-31: p.Bar is not a generic type.\n", GetCapturedStderr());
Jeongik Chadf76dc72019-11-28 00:08:47 +09001558 io_delegate_.SetFileContents("p/Bar.aidl", "package p; parcelable Bar<T>;");
Devin Moore097a3ab2020-03-11 16:08:44 -07001559 CaptureStderr();
Jeongik Chadf76dc72019-11-28 00:08:47 +09001560 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001561 EXPECT_EQ("ERROR: p/IFoo.aidl:1.28-31: p.Bar must have 1 type parameters, but got 2\n",
1562 GetCapturedStderr());
Jeongik Chadf76dc72019-11-28 00:08:47 +09001563 io_delegate_.SetFileContents("p/Bar.aidl", "package p; parcelable Bar<T, V>;");
1564 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1565 io_delegate_.SetFileContents("p/IFoo.aidl",
1566 "package p; interface IFoo {"
1567 "Bar<String, ParcelFileDescriptor> foo();}");
1568 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jeongik Chae74c86d2019-12-12 16:54:03 +09001569
1570 io_delegate_.SetFileContents("p/IFoo.aidl",
1571 "package p; interface IFoo {"
1572 "Bar<int, long> foo();}");
1573
1574 io_delegate_.SetFileContents("p/IFoo.aidl",
1575 "package p; interface IFoo {"
1576 "Bar<int[], long[]> foo();}");
1577
1578 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jeongik Chadf76dc72019-11-28 00:08:47 +09001579}
1580
Jeongik Cha0e426012019-07-29 15:57:02 +09001581TEST_F(AidlTest, FailOnMultipleTypesInSingleFile) {
1582 std::vector<std::string> rawOptions{"aidl --lang=java -o out foo/bar/Foo.aidl",
Andrei Homescub62afd92020-05-11 19:24:59 -07001583 "aidl --lang=cpp -o out -h out/include foo/bar/Foo.aidl",
1584 "aidl --lang=rust -o out foo/bar/Foo.aidl"};
Devin Moore5de18ed2020-04-02 13:52:29 -07001585 for (const auto& rawOption : rawOptions) {
1586 string expected_stderr =
1587 "ERROR: foo/bar/Foo.aidl:3.1-10: You must declare only one type per file.\n";
Jeongik Cha0e426012019-07-29 15:57:02 +09001588 Options options = Options::From(rawOption);
1589 io_delegate_.SetFileContents(options.InputFiles().front(),
1590 "package foo.bar;\n"
1591 "interface IFoo1 { int foo(); }\n"
1592 "interface IFoo2 { int foo(); }\n"
1593 "parcelable Data1 { int a; int b;}\n"
1594 "parcelable Data2 { int a; int b;}\n");
Devin Moore097a3ab2020-03-11 16:08:44 -07001595 CaptureStderr();
Jeongik Cha0e426012019-07-29 15:57:02 +09001596 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001597 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Parkb034bf02018-07-30 17:44:33 +09001598
Jeongik Cha0e426012019-07-29 15:57:02 +09001599 io_delegate_.SetFileContents(options.InputFiles().front(),
1600 "package foo.bar;\n"
1601 "interface IFoo1 { int foo(); }\n"
1602 "interface IFoo2 { int foo(); }\n");
Devin Moore097a3ab2020-03-11 16:08:44 -07001603 CaptureStderr();
Jeongik Cha0e426012019-07-29 15:57:02 +09001604 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001605 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Parkb034bf02018-07-30 17:44:33 +09001606
Devin Moore5de18ed2020-04-02 13:52:29 -07001607 expected_stderr = "ERROR: foo/bar/Foo.aidl:3.11-17: You must declare only one type per file.\n";
Jeongik Cha0e426012019-07-29 15:57:02 +09001608 io_delegate_.SetFileContents(options.InputFiles().front(),
1609 "package foo.bar;\n"
1610 "parcelable Data1 { int a; int b;}\n"
1611 "parcelable Data2 { int a; int b;}\n");
Devin Moore097a3ab2020-03-11 16:08:44 -07001612 CaptureStderr();
Jeongik Cha0e426012019-07-29 15:57:02 +09001613 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001614 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Parkb034bf02018-07-30 17:44:33 +09001615 }
1616}
1617
Devin Moorebdba2a82020-03-31 15:19:02 -07001618TEST_P(AidlTest, FailParseOnEmptyFile) {
1619 const string contents = "";
1620 const string expected_stderr = "ERROR: a/IFoo.aidl:1.1-1: syntax error, unexpected $end\n";
1621 CaptureStderr();
1622 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", contents, typenames_, GetLanguage()));
1623 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1624}
1625
Jiyong Parkb034bf02018-07-30 17:44:33 +09001626TEST_F(AidlTest, MultipleInputFiles) {
1627 Options options = Options::From(
Jiyong Park633246c2019-11-25 10:50:05 +09001628 "aidl --lang=java -o out -I . foo/bar/IFoo.aidl foo/bar/Data.aidl");
Jiyong Parkb034bf02018-07-30 17:44:33 +09001629
1630 io_delegate_.SetFileContents(options.InputFiles().at(0),
1631 "package foo.bar;\n"
1632 "import foo.bar.Data;\n"
1633 "interface IFoo { Data getData(); }\n");
1634
1635 io_delegate_.SetFileContents(options.InputFiles().at(1),
1636 "package foo.bar;\n"
1637 "import foo.bar.IFoo;\n"
1638 "parcelable Data { IFoo foo; }\n");
1639
1640 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1641
1642 string content;
1643 for (const auto file : {
1644 "out/foo/bar/IFoo.java", "out/foo/bar/Data.java"}) {
1645 content.clear();
1646 EXPECT_TRUE(io_delegate_.GetWrittenContents(file, &content));
1647 EXPECT_FALSE(content.empty());
1648 }
1649}
1650
1651TEST_F(AidlTest, MultipleInputFilesCpp) {
1652 Options options = Options::From("aidl --lang=cpp -o out -h out/include "
Jiyong Park633246c2019-11-25 10:50:05 +09001653 "-I . foo/bar/IFoo.aidl foo/bar/Data.aidl");
Jiyong Parkb034bf02018-07-30 17:44:33 +09001654
1655 io_delegate_.SetFileContents(options.InputFiles().at(0),
1656 "package foo.bar;\n"
1657 "import foo.bar.Data;\n"
1658 "interface IFoo { Data getData(); }\n");
1659
1660 io_delegate_.SetFileContents(options.InputFiles().at(1),
1661 "package foo.bar;\n"
1662 "import foo.bar.IFoo;\n"
1663 "parcelable Data { IFoo foo; }\n");
1664
1665 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1666
1667 string content;
1668 for (const auto file : {
Jiyong Parkb03551f2018-08-06 19:20:51 +09001669 "out/foo/bar/IFoo.cpp", "out/foo/bar/Data.cpp",
Jiyong Parkb034bf02018-07-30 17:44:33 +09001670 "out/include/foo/bar/IFoo.h", "out/include/foo/bar/Data.h",
1671 "out/include/foo/bar/BpFoo.h", "out/include/foo/bar/BpData.h",
1672 "out/include/foo/bar/BnFoo.h", "out/include/foo/bar/BnData.h"}) {
1673 content.clear();
1674 EXPECT_TRUE(io_delegate_.GetWrittenContents(file, &content));
1675 EXPECT_FALSE(content.empty());
1676 }
Jiyong Park1d2df7d2018-07-23 15:22:50 +09001677}
1678
Andrei Homescub62afd92020-05-11 19:24:59 -07001679TEST_F(AidlTest, MultipleInputFilesRust) {
1680 Options options =
1681 Options::From("aidl --lang=rust -o out -I . foo/bar/IFoo.aidl foo/bar/Data.aidl");
1682
1683 io_delegate_.SetFileContents(options.InputFiles().at(0),
1684 "package foo.bar;\n"
1685 "import foo.bar.Data;\n"
1686 "interface IFoo { Data getData(); }\n");
1687
1688 io_delegate_.SetFileContents(options.InputFiles().at(1),
1689 "package foo.bar;\n"
1690 "import foo.bar.IFoo;\n"
1691 "parcelable Data { IFoo foo; }\n");
1692
1693 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1694
1695 string content;
1696 for (const auto file : {"out/foo/bar/IFoo.rs", "out/foo/bar/Data.rs"}) {
1697 content.clear();
1698 EXPECT_TRUE(io_delegate_.GetWrittenContents(file, &content));
1699 EXPECT_FALSE(content.empty());
1700 }
1701}
1702
Devin Moore097a3ab2020-03-11 16:08:44 -07001703TEST_F(AidlTest, ConflictWithMetaTransactionGetVersion) {
1704 const string expected_stderr =
1705 "ERROR: p/IFoo.aidl:1.31-51: method getInterfaceVersion() is reserved for internal use.\n";
Jiyong Park309668e2018-07-28 16:55:44 +09001706 Options options = Options::From("aidl --lang=java -o place/for/output p/IFoo.aidl");
1707 // int getInterfaceVersion() is one of the meta transactions
1708 io_delegate_.SetFileContents(options.InputFiles().front(),
1709 "package p; interface IFoo {"
1710 "int getInterfaceVersion(); }");
Devin Moore097a3ab2020-03-11 16:08:44 -07001711 CaptureStderr();
Jiyong Parkb034bf02018-07-30 17:44:33 +09001712 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001713 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1714}
Jiyong Park309668e2018-07-28 16:55:44 +09001715
Devin Moore097a3ab2020-03-11 16:08:44 -07001716TEST_F(AidlTest, ConflictWithSimilarMetaTransaction) {
1717 // boolean getInterfaceVersion() is not a meta transaction, but should be
1718 // prevented because return type is not part of a method signature
1719 const string expected_stderr =
1720 "ERROR: p/IFoo.aidl:1.35-55: method getInterfaceVersion() is reserved for internal use.\n";
1721 Options options = Options::From("aidl --lang=java -o place/for/output p/IFoo.aidl");
Jiyong Park309668e2018-07-28 16:55:44 +09001722 io_delegate_.SetFileContents(options.InputFiles().front(),
1723 "package p; interface IFoo {"
1724 "boolean getInterfaceVersion(); }");
Devin Moore097a3ab2020-03-11 16:08:44 -07001725 CaptureStderr();
Jiyong Parkb034bf02018-07-30 17:44:33 +09001726 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001727 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1728}
Jiyong Park309668e2018-07-28 16:55:44 +09001729
Devin Moore097a3ab2020-03-11 16:08:44 -07001730TEST_F(AidlTest, ConflictWithMetaTransactionGetName) {
Jiyong Park309668e2018-07-28 16:55:44 +09001731 // this is another reserved name
Devin Moore097a3ab2020-03-11 16:08:44 -07001732 const string expected_stderr =
1733 "ERROR: p/IFoo.aidl:1.34-53: method getTransactionName(int) is reserved for internal use.\n";
1734 Options options = Options::From("aidl --lang=java -o place/for/output p/IFoo.aidl");
Jiyong Park309668e2018-07-28 16:55:44 +09001735 io_delegate_.SetFileContents(options.InputFiles().front(),
1736 "package p; interface IFoo {"
1737 "String getTransactionName(int code); }");
Devin Moore097a3ab2020-03-11 16:08:44 -07001738 CaptureStderr();
Jiyong Parkb034bf02018-07-30 17:44:33 +09001739 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001740 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Park309668e2018-07-28 16:55:44 +09001741
1742 // this is not a meta interface method as it differs type arguments
1743 io_delegate_.SetFileContents(options.InputFiles().front(),
1744 "package p; interface IFoo {"
1745 "String getTransactionName(); }");
Jiyong Parkb034bf02018-07-30 17:44:33 +09001746 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jiyong Park309668e2018-07-28 16:55:44 +09001747}
1748
Daniel Norman85aed542019-08-21 12:01:14 -07001749TEST_F(AidlTest, DifferentOrderAnnotationsInCheckAPI) {
Jeongik Cha3271ffa2018-12-04 15:19:20 +09001750 Options options = Options::From("aidl --checkapi old new");
1751 io_delegate_.SetFileContents("old/p/IFoo.aidl",
1752 "package p; interface IFoo{ @utf8InCpp @nullable String foo();}");
1753 io_delegate_.SetFileContents("new/p/IFoo.aidl",
1754 "package p; interface IFoo{ @nullable @utf8InCpp String foo();}");
1755
1756 EXPECT_TRUE(::android::aidl::check_api(options, io_delegate_));
1757}
1758
Jiyong Park3656c3c2018-08-01 20:02:01 +09001759TEST_F(AidlTest, SuccessOnIdenticalApiDumps) {
Jiyong Parke59c3682018-09-11 23:10:25 +09001760 Options options = Options::From("aidl --checkapi old new");
1761 io_delegate_.SetFileContents("old/p/IFoo.aidl", "package p; interface IFoo{ void foo();}");
1762 io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p; interface IFoo{ void foo();}");
Jiyong Park3656c3c2018-08-01 20:02:01 +09001763
1764 EXPECT_TRUE(::android::aidl::check_api(options, io_delegate_));
1765}
1766
Daniel Norman85aed542019-08-21 12:01:14 -07001767class AidlTestCompatibleChanges : public AidlTest {
1768 protected:
1769 Options options_ = Options::From("aidl --checkapi old new");
1770};
1771
1772TEST_F(AidlTestCompatibleChanges, NewType) {
1773 io_delegate_.SetFileContents("old/p/IFoo.aidl",
1774 "package p;"
1775 "interface IFoo {"
1776 " void foo(int a);"
1777 "}");
1778 io_delegate_.SetFileContents("new/p/IFoo.aidl",
1779 "package p;"
1780 "interface IFoo {"
1781 " void foo(int a);"
1782 "}");
1783 io_delegate_.SetFileContents("new/p/IBar.aidl",
1784 "package p;"
1785 "interface IBar {"
1786 " void bar();"
1787 "}");
1788 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
1789}
1790
1791TEST_F(AidlTestCompatibleChanges, NewMethod) {
1792 io_delegate_.SetFileContents("old/p/IFoo.aidl",
1793 "package p;"
1794 "interface IFoo {"
1795 " void foo(int a);"
1796 "}");
1797 io_delegate_.SetFileContents("new/p/IFoo.aidl",
1798 "package p;"
1799 "interface IFoo {"
1800 " void foo(int a);"
1801 " void bar();"
Jiyong Parkf8d53612020-05-04 14:06:13 +09001802 " void baz(in List<IFoo> arg);"
Daniel Norman85aed542019-08-21 12:01:14 -07001803 "}");
1804 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
1805}
1806
1807TEST_F(AidlTestCompatibleChanges, NewField) {
1808 io_delegate_.SetFileContents("old/p/Data.aidl",
1809 "package p;"
1810 "parcelable Data {"
1811 " int foo;"
1812 "}");
1813 io_delegate_.SetFileContents("new/p/Data.aidl",
1814 "package p;"
1815 "parcelable Data {"
1816 " int foo;"
Steven Moreland370ed342020-04-28 18:14:39 -07001817 " int bar = 0;"
Jiyong Parkf8d53612020-05-04 14:06:13 +09001818 " @nullable List<Data> list;"
Daniel Norman85aed542019-08-21 12:01:14 -07001819 "}");
1820 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
1821}
1822
1823TEST_F(AidlTestCompatibleChanges, NewEnumerator) {
1824 io_delegate_.SetFileContents("old/p/Enum.aidl",
1825 "package p;"
1826 "enum Enum {"
1827 " FOO = 1,"
1828 "}");
1829 io_delegate_.SetFileContents("new/p/Enum.aidl",
1830 "package p;"
1831 "enum Enum {"
1832 " FOO = 1,"
1833 " BAR = 2,"
1834 "}");
1835 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
1836}
1837
1838TEST_F(AidlTestCompatibleChanges, ReorderedEnumerator) {
1839 io_delegate_.SetFileContents("old/p/Enum.aidl",
1840 "package p;"
1841 "enum Enum {"
1842 " FOO = 1,"
1843 " BAR = 2,"
1844 "}");
1845 io_delegate_.SetFileContents("new/p/Enum.aidl",
1846 "package p;"
1847 "enum Enum {"
1848 " BAR = 2,"
1849 " FOO = 1,"
1850 "}");
1851 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
1852}
1853
Jooyung Hanb5c55cd2020-10-22 07:59:01 +09001854TEST_F(AidlTestCompatibleChanges, NewUnionField) {
1855 io_delegate_.SetFileContents("old/p/Union.aidl",
1856 "package p;"
1857 "union Union {"
1858 " String foo;"
1859 "}");
1860 io_delegate_.SetFileContents("new/p/Union.aidl",
1861 "package p;"
1862 "union Union {"
1863 " String foo;"
1864 " int num;"
1865 "}");
1866 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
1867}
1868
Daniel Norman85aed542019-08-21 12:01:14 -07001869TEST_F(AidlTestCompatibleChanges, NewPackage) {
Jiyong Parke59c3682018-09-11 23:10:25 +09001870 io_delegate_.SetFileContents("old/p/IFoo.aidl",
1871 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09001872 "interface IFoo {"
1873 " void foo(int a);"
Jiyong Parke59c3682018-09-11 23:10:25 +09001874 "}");
1875 io_delegate_.SetFileContents("old/p/Data.aidl",
1876 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09001877 "parcelable Data {"
1878 " int foo;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09001879 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09001880 io_delegate_.SetFileContents("new/p/IFoo.aidl",
1881 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09001882 "interface IFoo {"
1883 " void foo(int a);"
Jiyong Parke59c3682018-09-11 23:10:25 +09001884 "}");
1885 io_delegate_.SetFileContents("new/p/Data.aidl",
1886 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09001887 "parcelable Data {"
1888 " int foo;"
Jiyong Parke59c3682018-09-11 23:10:25 +09001889 "}");
1890 io_delegate_.SetFileContents("new/q/IFoo.aidl",
1891 "package q;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09001892 "interface IFoo {"
Jiyong Parke59c3682018-09-11 23:10:25 +09001893 " void foo(int a);"
1894 "}");
1895 io_delegate_.SetFileContents("new/q/Data.aidl",
1896 "package q;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09001897 "parcelable Data {"
1898 " int foo;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09001899 "}");
Daniel Norman85aed542019-08-21 12:01:14 -07001900 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
1901}
Jiyong Park3656c3c2018-08-01 20:02:01 +09001902
Daniel Norman85aed542019-08-21 12:01:14 -07001903TEST_F(AidlTestCompatibleChanges, ArgNameChange) {
1904 io_delegate_.SetFileContents("old/p/IFoo.aidl",
1905 "package p;"
1906 "interface IFoo {"
1907 " void foo(int a);"
1908 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09001909 io_delegate_.SetFileContents("new/p/IFoo.aidl",
1910 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09001911 "interface IFoo {"
1912 " void foo(int b);"
Jiyong Parke59c3682018-09-11 23:10:25 +09001913 "}");
Daniel Norman85aed542019-08-21 12:01:14 -07001914 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
1915}
Jiyong Parke59c3682018-09-11 23:10:25 +09001916
Daniel Norman85aed542019-08-21 12:01:14 -07001917TEST_F(AidlTestCompatibleChanges, AddedConstValue) {
Jiyong Parke59c3682018-09-11 23:10:25 +09001918 io_delegate_.SetFileContents("old/p/I.aidl",
1919 "package p; interface I {"
1920 "const int A = 1; }");
1921 io_delegate_.SetFileContents("new/p/I.aidl",
1922 "package p ; interface I {"
1923 "const int A = 1; const int B = 2;}");
Daniel Norman85aed542019-08-21 12:01:14 -07001924 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
1925}
Jiyong Parka428d212018-08-29 22:26:30 +09001926
Daniel Norman85aed542019-08-21 12:01:14 -07001927TEST_F(AidlTestCompatibleChanges, ChangedConstValueOrder) {
Jiyong Parke59c3682018-09-11 23:10:25 +09001928 io_delegate_.SetFileContents("old/p/I.aidl",
1929 "package p; interface I {"
1930 "const int A = 1; const int B = 2;}");
1931 io_delegate_.SetFileContents("new/p/I.aidl",
1932 "package p ; interface I {"
1933 "const int B = 2; const int A = 1;}");
Daniel Norman85aed542019-08-21 12:01:14 -07001934 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
Jiyong Park3656c3c2018-08-01 20:02:01 +09001935}
1936
Jooyung Han69ea4ba2020-10-29 15:33:37 +09001937TEST_F(AidlTestCompatibleChanges, ReorderedAnnatations) {
1938 io_delegate_.SetFileContents("old/p/Foo.aidl",
1939 "package p;"
1940 "@JavaPassthrough(annotation=\"Alice\")"
1941 "@JavaPassthrough(annotation=\"Bob\")"
1942 "parcelable Foo {}");
1943 io_delegate_.SetFileContents("new/p/Foo.aidl",
1944 "package p;"
1945 "@JavaPassthrough(annotation=\"Bob\")"
1946 "@JavaPassthrough(annotation=\"Alice\")"
1947 "parcelable Foo {}");
1948 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
1949}
1950
Jooyung Han636fd2f2020-10-22 11:33:45 +09001951TEST_F(AidlTestCompatibleChanges, NewFieldOfNewType) {
1952 io_delegate_.SetFileContents("old/p/Data.aidl",
1953 "package p;"
1954 "parcelable Data {"
1955 " int num;"
1956 "}");
1957 io_delegate_.SetFileContents(
1958 "new/p/Data.aidl",
1959 "package p;"
1960 "parcelable Data {"
1961 " int num;"
1962 " p.Enum e;" // this is considered as valid since 0(enum default) is valid for "Enum" type
1963 "}");
1964 io_delegate_.SetFileContents("new/p/Enum.aidl",
1965 "package p;"
1966 "enum Enum {"
1967 " FOO = 0,"
1968 " BAR = 1,"
1969 "}");
1970 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
1971}
1972
Daniel Norman85aed542019-08-21 12:01:14 -07001973class AidlTestIncompatibleChanges : public AidlTest {
1974 protected:
1975 Options options_ = Options::From("aidl --checkapi old new");
1976};
1977
1978TEST_F(AidlTestIncompatibleChanges, RemovedType) {
Jiyong Park0cf03b12020-07-22 19:36:34 +09001979 const string expected_stderr = "ERROR: old/p/IFoo.aidl:1.11-20: Removed type: p.IFoo\n";
Jiyong Parke59c3682018-09-11 23:10:25 +09001980 io_delegate_.SetFileContents("old/p/IFoo.aidl",
1981 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09001982 "interface IFoo {"
1983 " void foo(in String[] str);"
1984 " void bar(@utf8InCpp String str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09001985 "}");
Devin Moored131d5e2020-03-31 10:39:10 -07001986 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07001987 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moored131d5e2020-03-31 10:39:10 -07001988 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07001989}
1990
1991TEST_F(AidlTestIncompatibleChanges, RemovedMethod) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001992 const string expected_stderr =
1993 "ERROR: old/p/IFoo.aidl:1.61-65: Removed or changed method: p.IFoo.bar(String)\n";
Daniel Norman85aed542019-08-21 12:01:14 -07001994 io_delegate_.SetFileContents("old/p/IFoo.aidl",
1995 "package p;"
1996 "interface IFoo {"
1997 " void foo(in String[] str);"
1998 " void bar(@utf8InCpp String str);"
1999 "}");
2000 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2001 "package p;"
2002 "interface IFoo {"
2003 " void foo(in String[] str);"
2004 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002005 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002006 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002007 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002008}
2009
Jiyong Parkf8d53612020-05-04 14:06:13 +09002010TEST_F(AidlTestIncompatibleChanges, UntypedListInInterface) {
2011 const string expected_stderr =
2012 "ERROR: new/p/IFoo.aidl:1.61-65: "
2013 "Encountered an untyped List or Map. The use of untyped List/Map is "
2014 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
2015 "the receiving side. Consider switching to an array or a generic List/Map.\n"
2016 "ERROR: new/p/IFoo.aidl: Failed to read.\n";
2017 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2018 "package p;"
2019 "interface IFoo {"
2020 " void foo(in String[] str);"
2021 "}");
2022 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2023 "package p;"
2024 "interface IFoo {"
2025 " void foo(in String[] str);"
2026 " void bar(in List arg);"
2027 "}");
2028 CaptureStderr();
2029 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2030 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2031}
2032
2033TEST_F(AidlTestCompatibleChanges, UntypedListInParcelable) {
2034 const string expected_stderr =
2035 "ERROR: new/p/Data.aidl:1.54-59: "
2036 "Encountered an untyped List or Map. The use of untyped List/Map is "
2037 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
2038 "the receiving side. Consider switching to an array or a generic List/Map.\n"
2039 "ERROR: new/p/Data.aidl: Failed to read.\n";
2040 io_delegate_.SetFileContents("old/p/Data.aidl",
2041 "package p;"
2042 "parcelable Data {"
2043 " int foo;"
2044 "}");
2045 io_delegate_.SetFileContents("new/p/Data.aidl",
2046 "package p;"
2047 "parcelable Data {"
2048 " int foo;"
2049 " @nullable List list;"
2050 "}");
2051 CaptureStderr();
2052 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2053 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2054}
2055
Daniel Norman85aed542019-08-21 12:01:14 -07002056TEST_F(AidlTestIncompatibleChanges, RemovedField) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002057 const string expected_stderr =
2058 "ERROR: new/p/Data.aidl:1.21-26: Number of fields in p.Data is reduced from 2 to 1.\n";
Jiyong Parke59c3682018-09-11 23:10:25 +09002059 io_delegate_.SetFileContents("old/p/Data.aidl",
2060 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002061 "parcelable Data {"
2062 " int foo;"
2063 " int bar;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002064 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002065 io_delegate_.SetFileContents("new/p/Data.aidl",
2066 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002067 "parcelable Data {"
2068 " int foo;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002069 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002070 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002071 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002072 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002073}
Jiyong Park3656c3c2018-08-01 20:02:01 +09002074
Jooyung Hanb5c55cd2020-10-22 07:59:01 +09002075TEST_F(AidlTestIncompatibleChanges, NewFieldWithNoDefault) {
2076 const string expected_stderr =
2077 "ERROR: new/p/Data.aidl:1.46-50: Field 'str' does not have a useful default in some "
2078 "backends. Please either provide a default value for this field or mark the field as "
2079 "@nullable. This value or a null value will be used automatically when an old version of "
2080 "this parcelable is sent to a process which understands a new version of this parcelable. In "
2081 "order to make sure your code continues to be backwards compatible, make sure the default or "
2082 "null value does not cause a semantic change to this parcelable.\n";
2083 io_delegate_.SetFileContents("old/p/Data.aidl",
2084 "package p;"
2085 "parcelable Data {"
2086 " int num;"
2087 "}");
2088 io_delegate_.SetFileContents("new/p/Data.aidl",
2089 "package p;"
2090 "parcelable Data {"
2091 " int num;"
2092 " String str;"
2093 "}");
2094 CaptureStderr();
2095 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2096 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2097}
2098
Jooyung Han636fd2f2020-10-22 11:33:45 +09002099TEST_F(AidlTestIncompatibleChanges, NewFieldWithNonZeroEnum) {
2100 const string expected_stderr =
2101 "ERROR: new/p/Data.aidl:1.46-48: Field 'e' of enum 'Enum' can't be initialized as '0'. "
2102 "Please make sure 'Enum' has '0' as a valid value.\n";
2103 io_delegate_.SetFileContents("old/p/Data.aidl",
2104 "package p;"
2105 "parcelable Data {"
2106 " int num;"
2107 "}");
2108 io_delegate_.SetFileContents("new/p/Data.aidl",
2109 "package p;"
2110 "parcelable Data {"
2111 " int num;"
2112 " p.Enum e;"
2113 "}");
2114 io_delegate_.SetFileContents("new/p/Enum.aidl",
2115 "package p;"
2116 "enum Enum {"
2117 " FOO = 1,"
2118 " BAR = 2,"
2119 "}");
2120 CaptureStderr();
2121 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2122 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2123}
2124
Daniel Norman85aed542019-08-21 12:01:14 -07002125TEST_F(AidlTestIncompatibleChanges, RemovedEnumerator) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002126 const string expected_stderr =
2127 "ERROR: new/p/Enum.aidl:1.15-20: Removed enumerator from p.Enum: FOO\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002128 io_delegate_.SetFileContents("old/p/Enum.aidl",
2129 "package p;"
2130 "enum Enum {"
2131 " FOO = 1,"
2132 " BAR = 2,"
2133 "}");
2134 io_delegate_.SetFileContents("new/p/Enum.aidl",
2135 "package p;"
2136 "enum Enum {"
2137 " BAR = 2,"
2138 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002139 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002140 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002141 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002142}
2143
Jooyung Hanb5c55cd2020-10-22 07:59:01 +09002144TEST_F(AidlTestIncompatibleChanges, RemovedUnionField) {
2145 const string expected_stderr =
2146 "ERROR: new/p/Union.aidl:1.16-22: Number of fields in p.Union is reduced from 2 to 1.\n";
2147 io_delegate_.SetFileContents("old/p/Union.aidl",
2148 "package p;"
2149 "union Union {"
2150 " String str;"
2151 " int num;"
2152 "}");
2153 io_delegate_.SetFileContents("new/p/Union.aidl",
2154 "package p;"
2155 "union Union {"
2156 " String str;"
2157 "}");
2158 CaptureStderr();
2159 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2160 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2161}
2162
Daniel Norman85aed542019-08-21 12:01:14 -07002163TEST_F(AidlTestIncompatibleChanges, RenamedMethod) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002164 const string expected_stderr =
2165 "ERROR: old/p/IFoo.aidl:1.61-65: Removed or changed method: p.IFoo.bar(String)\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002166 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2167 "package p;"
2168 "interface IFoo {"
2169 " void foo(in String[] str);"
2170 " void bar(@utf8InCpp String str);"
2171 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002172 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2173 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002174 "interface IFoo {"
2175 " void foo(in String[] str);"
2176 " void bar2(@utf8InCpp String str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002177 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002178 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002179 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002180 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002181}
2182
Daniel Norman85aed542019-08-21 12:01:14 -07002183TEST_F(AidlTestIncompatibleChanges, RenamedType) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002184 const string expected_stderr = "ERROR: old/p/IFoo.aidl:1.11-20: Removed type: p.IFoo\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002185 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2186 "package p;"
2187 "interface IFoo {"
2188 " void foo(in String[] str);"
2189 " void bar(@utf8InCpp String str);"
2190 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002191 io_delegate_.SetFileContents("new/p/IFoo2.aidl",
2192 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002193 "interface IFoo2 {"
2194 " void foo(in String[] str);"
2195 " void bar(@utf8InCpp String str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002196 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002197 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002198 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002199 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002200}
Jiyong Park3656c3c2018-08-01 20:02:01 +09002201
Daniel Norman85aed542019-08-21 12:01:14 -07002202TEST_F(AidlTestIncompatibleChanges, ChangedEnumerator) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002203 const string expected_stderr =
2204 "ERROR: new/p/Enum.aidl:1.15-20: Changed enumerator value: p.Enum::FOO from 1 to 3.\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002205 io_delegate_.SetFileContents("old/p/Enum.aidl",
2206 "package p;"
2207 "enum Enum {"
2208 " FOO = 1,"
2209 " BAR = 2,"
2210 "}");
2211 io_delegate_.SetFileContents("new/p/Enum.aidl",
2212 "package p;"
2213 "enum Enum {"
2214 " FOO = 3,"
2215 " BAR = 2,"
2216 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002217 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002218 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002219 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002220}
2221
2222TEST_F(AidlTestIncompatibleChanges, ReorderedMethod) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002223 const string expected_stderr =
2224 "ERROR: new/p/IFoo.aidl:1.67-71: Transaction ID changed: p.IFoo.foo(String[]) is changed "
2225 "from 0 to 1.\n"
2226 "ERROR: new/p/IFoo.aidl:1.33-37: Transaction ID changed: p.IFoo.bar(String) is changed from "
2227 "1 to 0.\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002228 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2229 "package p;"
2230 "interface IFoo {"
2231 " void foo(in String[] str);"
2232 " void bar(@utf8InCpp String str);"
2233 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002234 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2235 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002236 "interface IFoo {"
2237 " void bar(@utf8InCpp String str);"
2238 " void foo(in String[] str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002239 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002240 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002241 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002242 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002243}
2244
2245TEST_F(AidlTestIncompatibleChanges, ReorderedField) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002246 const string expected_stderr =
Jiyong Parkb07d9932020-05-15 12:56:54 +09002247 "ERROR: new/p/Data.aidl:1.33-37: Reordered bar from 1 to 0.\n"
2248 "ERROR: new/p/Data.aidl:1.43-47: Reordered foo from 0 to 1.\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002249 io_delegate_.SetFileContents("old/p/Data.aidl",
Jiyong Parke59c3682018-09-11 23:10:25 +09002250 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002251 "parcelable Data {"
2252 " int foo;"
2253 " int bar;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002254 "}");
Daniel Norman85aed542019-08-21 12:01:14 -07002255 io_delegate_.SetFileContents("new/p/Data.aidl",
2256 "package p;"
2257 "parcelable Data {"
2258 " int bar;"
2259 " int foo;"
2260 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002261 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002262 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002263 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002264}
Jiyong Park3656c3c2018-08-01 20:02:01 +09002265
Daniel Norman85aed542019-08-21 12:01:14 -07002266TEST_F(AidlTestIncompatibleChanges, ChangedDirectionSpecifier) {
Devin Mooreeccdb902020-03-24 16:22:40 -07002267 const string expected_stderr = "ERROR: new/p/IFoo.aidl:1.33-37: Direction changed: in to out.\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002268 io_delegate_.SetFileContents("old/p/IFoo.aidl",
Jiyong Parke59c3682018-09-11 23:10:25 +09002269 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002270 "interface IFoo {"
2271 " void foo(in String[] str);"
2272 " void bar(@utf8InCpp String str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002273 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002274 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2275 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002276 "interface IFoo {"
2277 " void foo(out String[] str);"
2278 " void bar(@utf8InCpp String str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002279 "}");
Devin Mooreeccdb902020-03-24 16:22:40 -07002280 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002281 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Mooreeccdb902020-03-24 16:22:40 -07002282 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002283}
Jiyong Park3656c3c2018-08-01 20:02:01 +09002284
Daniel Norman85aed542019-08-21 12:01:14 -07002285TEST_F(AidlTestIncompatibleChanges, AddedAnnotation) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002286 const string expected_stderr =
2287 "ERROR: new/p/IFoo.aidl:1.51-58: Changed annotations: (empty) to @utf8InCpp\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002288 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2289 "package p;"
2290 "interface IFoo {"
2291 " void foo(in String[] str);"
2292 " void bar(@utf8InCpp String str);"
2293 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002294 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2295 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002296 "interface IFoo {"
Jiyong Parke59c3682018-09-11 23:10:25 +09002297 " void foo(in @utf8InCpp String[] str);"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002298 " void bar(@utf8InCpp String str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002299 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002300 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002301 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002302 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002303}
Jiyong Park3656c3c2018-08-01 20:02:01 +09002304
Daniel Norman85aed542019-08-21 12:01:14 -07002305TEST_F(AidlTestIncompatibleChanges, RemovedAnnotation) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002306 const string expected_stderr =
2307 "ERROR: new/p/IFoo.aidl:1.66-72: Changed annotations: @utf8InCpp to (empty)\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002308 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2309 "package p;"
2310 "interface IFoo {"
2311 " void foo(in String[] str);"
2312 " void bar(@utf8InCpp String str);"
2313 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002314 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2315 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002316 "interface IFoo {"
Jiyong Parke59c3682018-09-11 23:10:25 +09002317 " void foo(in String[] str);"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002318 " void bar(String str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002319 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002320 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002321 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002322 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002323}
Jiyong Park3656c3c2018-08-01 20:02:01 +09002324
Jooyung Han60b2fde2020-10-29 15:12:40 +09002325TEST_F(AidlTestIncompatibleChanges, ChangedBackingTypeOfEnum) {
2326 const string expected_stderr =
2327 "ERROR: new/p/Foo.aidl:1.11-32: Type changed: byte to long.\n"
2328 "ERROR: new/p/Foo.aidl:1.36-40: Changed backing types.\n";
2329 io_delegate_.SetFileContents("old/p/Foo.aidl",
2330 "package p;"
2331 "@Backing(type=\"byte\")"
2332 "enum Foo {"
2333 " FOO, BAR,"
2334 "}");
2335 io_delegate_.SetFileContents("new/p/Foo.aidl",
2336 "package p;"
2337 "@Backing(type=\"long\")"
2338 "enum Foo {"
2339 " FOO, BAR,"
2340 "}");
2341 CaptureStderr();
2342 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2343 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2344}
2345
Jooyung Han69ea4ba2020-10-29 15:33:37 +09002346TEST_F(AidlTestIncompatibleChanges, ChangedAnnatationParams) {
2347 const string expected_stderr =
2348 "ERROR: new/p/Foo.aidl:1.55-59: Changed annotations: @JavaPassthrough(annotation=\"Alice\") "
2349 "to @JavaPassthrough(annotation=\"Bob\")\n";
2350 io_delegate_.SetFileContents("old/p/Foo.aidl",
2351 "package p;"
2352 "@JavaPassthrough(annotation=\"Alice\")"
2353 "parcelable Foo {}");
2354 io_delegate_.SetFileContents("new/p/Foo.aidl",
2355 "package p;"
2356 "@JavaPassthrough(annotation=\"Bob\")"
2357 "parcelable Foo {}");
2358
2359 CaptureStderr();
2360 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2361 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2362}
2363
Devin Mooredb7ac512020-08-07 11:17:36 -07002364TEST_F(AidlTestIncompatibleChanges, AddedParcelableAnnotation) {
2365 const string expected_stderr =
2366 "ERROR: new/p/Foo.aidl:1.47-51: Changed annotations: (empty) to @JavaOnlyStableParcelable\n";
2367 io_delegate_.SetFileContents("old/p/Foo.aidl",
2368 "package p;"
2369 "parcelable Foo {"
2370 " int A;"
2371 "}");
2372 io_delegate_.SetFileContents("new/p/Foo.aidl",
2373 "package p;"
2374 "@JavaOnlyStableParcelable parcelable Foo {"
2375 " int A;"
2376 "}");
2377 CaptureStderr();
2378 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2379 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2380}
2381
2382TEST_F(AidlTestIncompatibleChanges, RemovedParcelableAnnotation) {
2383 const string expected_stderr =
2384 "ERROR: new/p/Foo.aidl:1.21-25: Changed annotations: @JavaOnlyStableParcelable to (empty)\n";
2385 io_delegate_.SetFileContents("old/p/Foo.aidl",
2386 "package p;"
2387 "@JavaOnlyStableParcelable parcelable Foo {"
2388 " int A;"
2389 "}");
2390 io_delegate_.SetFileContents("new/p/Foo.aidl",
2391 "package p;"
2392 "parcelable Foo {"
2393 " int A;"
2394 "}");
2395 CaptureStderr();
2396 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2397 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2398}
2399
Daniel Norman85aed542019-08-21 12:01:14 -07002400TEST_F(AidlTestIncompatibleChanges, RemovedPackage) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002401 const string expected_stderr = "ERROR: old/q/IFoo.aidl:1.11-21: Removed type: q.IFoo\n";
Jiyong Parke59c3682018-09-11 23:10:25 +09002402 io_delegate_.SetFileContents("old/p/IFoo.aidl", "package p; interface IFoo{}");
2403 io_delegate_.SetFileContents("old/q/IFoo.aidl", "package q; interface IFoo{}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002404 io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p; interface IFoo{}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002405 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002406 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002407 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002408}
Jiyong Parka468e2a2018-08-29 21:25:18 +09002409
Daniel Norman85aed542019-08-21 12:01:14 -07002410TEST_F(AidlTestIncompatibleChanges, ChangedDefaultValue) {
Steven Moreland370ed342020-04-28 18:14:39 -07002411 const string expected_stderr = "ERROR: new/p/D.aidl:1.30-32: Changed default value: 1 to 2.\n";
Jiyong Parke59c3682018-09-11 23:10:25 +09002412 io_delegate_.SetFileContents("old/p/D.aidl", "package p; parcelable D { int a = 1; }");
2413 io_delegate_.SetFileContents("new/p/D.aidl", "package p; parcelable D { int a = 2; }");
Devin Moore097a3ab2020-03-11 16:08:44 -07002414 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002415 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002416 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002417}
Jiyong Parka428d212018-08-29 22:26:30 +09002418
Daniel Norman85aed542019-08-21 12:01:14 -07002419TEST_F(AidlTestIncompatibleChanges, RemovedConstValue) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002420 const string expected_stderr =
2421 "ERROR: old/p/I.aidl:1.51-53: Removed constant declaration: p.I.B\n";
Jiyong Parke59c3682018-09-11 23:10:25 +09002422 io_delegate_.SetFileContents("old/p/I.aidl",
2423 "package p; interface I {"
2424 "const int A = 1; const int B = 2;}");
2425 io_delegate_.SetFileContents("new/p/I.aidl", "package p; interface I { const int A = 1; }");
Devin Moore097a3ab2020-03-11 16:08:44 -07002426 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002427 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002428 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002429}
Jiyong Parka428d212018-08-29 22:26:30 +09002430
Daniel Norman85aed542019-08-21 12:01:14 -07002431TEST_F(AidlTestIncompatibleChanges, ChangedConstValue) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002432 const string expected_stderr =
2433 "ERROR: new/p/I.aidl:1.11-21: Changed constant value: p.I.A from 1 to 2.\n";
Jiyong Parke59c3682018-09-11 23:10:25 +09002434 io_delegate_.SetFileContents("old/p/I.aidl", "package p; interface I { const int A = 1; }");
2435 io_delegate_.SetFileContents("new/p/I.aidl", "package p; interface I { const int A = 2; }");
Devin Moore097a3ab2020-03-11 16:08:44 -07002436 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002437 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002438 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Park3c35e392018-08-30 13:10:30 +09002439}
2440
Devin Moorec7e47a32020-08-07 10:55:25 -07002441TEST_F(AidlTestIncompatibleChanges, FixedSizeAddedField) {
2442 const string expected_stderr =
2443 "ERROR: new/p/Foo.aidl:1.33-37: Number of fields in p.Foo is changed from 1 to 2. "
2444 "This is an incompatible change for FixedSize types.\n";
2445 io_delegate_.SetFileContents("old/p/Foo.aidl",
2446 "package p; @FixedSize parcelable Foo { int A = 1; }");
2447 io_delegate_.SetFileContents("new/p/Foo.aidl",
2448 "package p; @FixedSize parcelable Foo { int A = 1; int B = 2; }");
2449 CaptureStderr();
2450 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2451 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2452}
2453
2454TEST_F(AidlTestIncompatibleChanges, FixedSizeRemovedField) {
2455 const string expected_stderr =
2456 "ERROR: new/p/Foo.aidl:1.33-37: Number of fields in p.Foo is reduced from 2 to 1.\n";
2457 io_delegate_.SetFileContents("old/p/Foo.aidl",
2458 "package p; @FixedSize parcelable Foo { int A = 1; int B = 1; }");
2459 io_delegate_.SetFileContents("new/p/Foo.aidl",
2460 "package p; @FixedSize parcelable Foo { int A = 1; }");
2461 CaptureStderr();
2462 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2463 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2464}
2465
2466TEST_P(AidlTest, RejectNonFixedSizeFromFixedSize) {
2467 const string expected_stderr =
2468 "ERROR: Foo.aidl:1.36-38: The @FixedSize parcelable 'Foo' has a non-fixed size field named "
2469 "a.\n"
2470 "ERROR: Foo.aidl:1.44-46: The @FixedSize parcelable 'Foo' has a non-fixed size field named "
2471 "b.\n"
2472 "ERROR: Foo.aidl:1.55-57: The @FixedSize parcelable 'Foo' has a non-fixed size field named "
2473 "c.\n"
2474 "ERROR: Foo.aidl:1.80-82: The @FixedSize parcelable 'Foo' has a non-fixed size field named "
2475 "d.\n"
2476 "ERROR: Foo.aidl:1.92-94: The @FixedSize parcelable 'Foo' has a non-fixed size field named "
2477 "e.\n"
2478 "ERROR: Foo.aidl:1.109-111: The @FixedSize parcelable 'Foo' has a non-fixed size field named "
2479 "f.\n";
2480
2481 io_delegate_.SetFileContents("Foo.aidl",
2482 "@FixedSize parcelable Foo { "
2483 " int[] a;"
2484 " Bar b;"
2485 " String c;"
2486 " ParcelFileDescriptor d;"
2487 " IBinder e;"
2488 " List<String> f;"
Steven Moreland265f3d42020-09-24 19:06:54 +00002489 " int isFixedSize;"
Devin Moorec7e47a32020-08-07 10:55:25 -07002490 "}");
2491 io_delegate_.SetFileContents("Bar.aidl", "parcelable Bar { int a; }");
2492 Options options =
2493 Options::From("aidl Foo.aidl -I . --lang=" + Options::LanguageToString(GetLanguage()));
2494
2495 CaptureStderr();
2496 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
2497 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2498}
2499
2500TEST_P(AidlTest, AcceptFixedSizeFromFixedSize) {
2501 const string expected_stderr = "";
2502
2503 io_delegate_.SetFileContents("Foo.aidl", "@FixedSize parcelable Foo { int a; Bar b; }");
2504 io_delegate_.SetFileContents("Bar.aidl", "@FixedSize parcelable Bar { Val c; }");
2505 io_delegate_.SetFileContents("Val.aidl", "enum Val { A, B, }");
2506 Options options =
2507 Options::From("aidl Foo.aidl -I . --lang=" + Options::LanguageToString(GetLanguage()));
2508
2509 CaptureStderr();
2510 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
2511 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2512}
2513
Jiyong Park8c380532018-08-30 14:55:26 +09002514TEST_F(AidlTest, RejectAmbiguousImports) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002515 const string expected_stderr =
2516 "ERROR: p/IFoo.aidl: Duplicate files found for q.IBar from:\n"
2517 "dir1/q/IBar.aidl\n"
2518 "dir2/q/IBar.aidl\n"
Devin Moore5de18ed2020-04-02 13:52:29 -07002519 "ERROR: p/IFoo.aidl: Couldn't find import for class q.IBar\n";
Jiyong Park8c380532018-08-30 14:55:26 +09002520 Options options = Options::From("aidl --lang=java -o out -I dir1 -I dir2 p/IFoo.aidl");
2521 io_delegate_.SetFileContents("p/IFoo.aidl", "package p; import q.IBar; interface IFoo{}");
2522 io_delegate_.SetFileContents("dir1/q/IBar.aidl", "package q; interface IBar{}");
2523 io_delegate_.SetFileContents("dir2/q/IBar.aidl", "package q; interface IBar{}");
2524
Devin Moore097a3ab2020-03-11 16:08:44 -07002525 CaptureStderr();
Jiyong Park8c380532018-08-30 14:55:26 +09002526 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002527 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Park8c380532018-08-30 14:55:26 +09002528}
2529
Jiyong Parked65bf42018-08-28 15:43:27 +09002530TEST_F(AidlTest, HandleManualIdAssignments) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002531 const string expected_stderr =
2532 "ERROR: new/p/IFoo.aidl:1.32-36: Transaction ID changed: p.IFoo.foo() is changed from 10 to "
2533 "11.\n";
Jiyong Parke59c3682018-09-11 23:10:25 +09002534 Options options = Options::From("aidl --checkapi old new");
2535 io_delegate_.SetFileContents("old/p/IFoo.aidl", "package p; interface IFoo{ void foo() = 10;}");
2536 io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p; interface IFoo{ void foo() = 10;}");
Jiyong Parked65bf42018-08-28 15:43:27 +09002537
2538 EXPECT_TRUE(::android::aidl::check_api(options, io_delegate_));
2539
Jiyong Parke59c3682018-09-11 23:10:25 +09002540 io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p; interface IFoo{ void foo() = 11;}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002541 CaptureStderr();
Jiyong Parked65bf42018-08-28 15:43:27 +09002542 EXPECT_FALSE(::android::aidl::check_api(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002543 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Parked65bf42018-08-28 15:43:27 +09002544}
2545
Jiyong Parke05195e2018-10-08 18:24:23 +09002546TEST_F(AidlTest, ParcelFileDescriptorIsBuiltinType) {
2547 Options javaOptions = Options::From("aidl --lang=java -o out p/IFoo.aidl");
2548 Options cppOptions = Options::From("aidl --lang=cpp -h out -o out p/IFoo.aidl");
Andrei Homescub62afd92020-05-11 19:24:59 -07002549 Options rustOptions = Options::From("aidl --lang=rust -o out p/IFoo.aidl");
Jiyong Parke05195e2018-10-08 18:24:23 +09002550
2551 // use without import
2552 io_delegate_.SetFileContents("p/IFoo.aidl",
2553 "package p; interface IFoo{ void foo(in ParcelFileDescriptor fd);}");
2554 EXPECT_EQ(0, ::android::aidl::compile_aidl(javaOptions, io_delegate_));
2555 EXPECT_EQ(0, ::android::aidl::compile_aidl(cppOptions, io_delegate_));
Andrei Homescub62afd92020-05-11 19:24:59 -07002556 EXPECT_EQ(0, ::android::aidl::compile_aidl(rustOptions, io_delegate_));
Jiyong Parke05195e2018-10-08 18:24:23 +09002557
Devin Moore7b8d5c92020-03-17 14:14:08 -07002558 // use without import but with full name
Jiyong Parke05195e2018-10-08 18:24:23 +09002559 io_delegate_.SetFileContents(
2560 "p/IFoo.aidl",
2561 "package p; interface IFoo{ void foo(in android.os.ParcelFileDescriptor fd);}");
2562 EXPECT_EQ(0, ::android::aidl::compile_aidl(javaOptions, io_delegate_));
2563 EXPECT_EQ(0, ::android::aidl::compile_aidl(cppOptions, io_delegate_));
Andrei Homescub62afd92020-05-11 19:24:59 -07002564 EXPECT_EQ(0, ::android::aidl::compile_aidl(rustOptions, io_delegate_));
Jiyong Parke05195e2018-10-08 18:24:23 +09002565
2566 // use with import (as before)
2567 io_delegate_.SetFileContents("p/IFoo.aidl",
2568 "package p;"
2569 "import android.os.ParcelFileDescriptor;"
2570 "interface IFoo{"
2571 " void foo(in ParcelFileDescriptor fd);"
2572 "}");
2573 EXPECT_EQ(0, ::android::aidl::compile_aidl(javaOptions, io_delegate_));
2574 EXPECT_EQ(0, ::android::aidl::compile_aidl(cppOptions, io_delegate_));
Andrei Homescub62afd92020-05-11 19:24:59 -07002575 EXPECT_EQ(0, ::android::aidl::compile_aidl(rustOptions, io_delegate_));
Jiyong Parke05195e2018-10-08 18:24:23 +09002576}
Jiyong Parked65bf42018-08-28 15:43:27 +09002577
Jiyong Park3633b722019-04-11 15:38:26 +09002578TEST_F(AidlTest, ManualIds) {
2579 Options options = Options::From("aidl --lang=java -o out IFoo.aidl");
2580 io_delegate_.SetFileContents("IFoo.aidl",
2581 "interface IFoo {\n"
2582 " void foo() = 0;\n"
2583 " void bar() = 1;\n"
2584 "}");
2585 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
2586}
2587
2588TEST_F(AidlTest, ManualIdsWithMetaTransactions) {
2589 Options options = Options::From("aidl --lang=java --version 10 -o out IFoo.aidl");
2590 io_delegate_.SetFileContents("IFoo.aidl",
2591 "interface IFoo {\n"
2592 " void foo() = 0;\n"
2593 " void bar() = 1;\n"
2594 "}");
2595 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
2596}
2597
2598TEST_F(AidlTest, FailOnDuplicatedIds) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002599 const string expected_stderr =
2600 "ERROR: IFoo.aidl:3.7-11: Found duplicate method id (3) for method bar\n";
Jiyong Park3633b722019-04-11 15:38:26 +09002601 Options options = Options::From("aidl --lang=java --version 10 -o out IFoo.aidl");
2602 io_delegate_.SetFileContents("IFoo.aidl",
2603 "interface IFoo {\n"
2604 " void foo() = 3;\n"
2605 " void bar() = 3;\n"
2606 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002607 CaptureStderr();
Jiyong Park3633b722019-04-11 15:38:26 +09002608 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002609 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Park3633b722019-04-11 15:38:26 +09002610}
2611
2612TEST_F(AidlTest, FailOnOutOfRangeIds) {
2613 // 16777115 is kLastMetaMethodId + 1
Devin Moore097a3ab2020-03-11 16:08:44 -07002614 const string expected_stderr =
2615 "ERROR: IFoo.aidl:3.7-11: Found out of bounds id (16777115) for method bar. "
2616 "Value for id must be between 0 and 16777114 inclusive.\n";
Jiyong Park3633b722019-04-11 15:38:26 +09002617 Options options = Options::From("aidl --lang=java --version 10 -o out IFoo.aidl");
2618 io_delegate_.SetFileContents("IFoo.aidl",
2619 "interface IFoo {\n"
2620 " void foo() = 3;\n"
2621 " void bar() = 16777115;\n"
2622 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002623 CaptureStderr();
Jiyong Park3633b722019-04-11 15:38:26 +09002624 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002625 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Park3633b722019-04-11 15:38:26 +09002626}
2627
2628TEST_F(AidlTest, FailOnPartiallyAssignedIds) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002629 const string expected_stderr =
2630 "ERROR: IFoo.aidl:3.7-11: You must either assign id's to all methods or to none of them.\n";
Jiyong Park3633b722019-04-11 15:38:26 +09002631 Options options = Options::From("aidl --lang=java --version 10 -o out IFoo.aidl");
2632 io_delegate_.SetFileContents("IFoo.aidl",
2633 "interface IFoo {\n"
2634 " void foo() = 3;\n"
2635 " void bar();\n"
2636 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002637 CaptureStderr();
Jiyong Park3633b722019-04-11 15:38:26 +09002638 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002639 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Park3633b722019-04-11 15:38:26 +09002640}
2641
Jiyong Parkc6816252019-07-08 08:12:28 +09002642TEST_F(AidlTest, AllowDuplicatedImportPaths) {
2643 Options options = Options::From("aidl --lang=java -I dir -I dir IFoo.aidl");
2644 io_delegate_.SetFileContents("dir/IBar.aidl", "interface IBar{}");
2645 io_delegate_.SetFileContents("IFoo.aidl", "import IBar; interface IFoo{}");
2646 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
2647}
2648
2649TEST_F(AidlTest, FailOnAmbiguousImports) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002650 const string expected_stderr =
2651 "ERROR: IFoo.aidl: Duplicate files found for IBar from:\n"
2652 "dir/IBar.aidl\n"
2653 "dir2/IBar.aidl\n"
Devin Moore5de18ed2020-04-02 13:52:29 -07002654 "ERROR: IFoo.aidl: Couldn't find import for class IBar\n";
Devin Moore097a3ab2020-03-11 16:08:44 -07002655
Jiyong Parkc6816252019-07-08 08:12:28 +09002656 Options options = Options::From("aidl --lang=java -I dir -I dir2 IFoo.aidl");
2657 io_delegate_.SetFileContents("dir/IBar.aidl", "interface IBar{}");
2658 io_delegate_.SetFileContents("dir2/IBar.aidl", "interface IBar{}");
2659 io_delegate_.SetFileContents("IFoo.aidl", "import IBar; interface IFoo{}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002660 CaptureStderr();
Jiyong Parkc6816252019-07-08 08:12:28 +09002661 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002662 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Parkc6816252019-07-08 08:12:28 +09002663}
2664
Jiyong Parkf1f5c802020-05-19 17:33:00 +09002665TEST_F(AidlTest, UnusedImportDoesNotContributeInclude) {
2666 io_delegate_.SetFileContents("a/b/IFoo.aidl",
2667 "package a.b;\n"
2668 "import a.b.IBar;\n"
2669 "import a.b.IQux;\n"
2670 "interface IFoo { IQux foo(); }\n");
2671 io_delegate_.SetFileContents("a/b/IBar.aidl", "package a.b; interface IBar { void foo(); }");
2672 io_delegate_.SetFileContents("a/b/IQux.aidl", "package a.b; interface IQux { void foo(); }");
2673
2674 Options options = Options::From("aidl --lang=ndk a/b/IFoo.aidl -I . -o out -h out/include");
2675 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
2676
2677 string output;
2678 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/include/aidl/a/b/IFoo.h", &output));
2679 // IBar was imported but wasn't used. include is not expected.
2680 EXPECT_THAT(output, Not(testing::HasSubstr("#include <aidl/a/b/IBar.h>")));
2681 // IBar was imported and used. include is expected.
2682 EXPECT_THAT(output, (testing::HasSubstr("#include <aidl/a/b/IQux.h>")));
2683}
2684
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09002685TEST_F(AidlTest, ParseJavaPassthroughAnnotation) {
Jooyung Hane6bc5e12020-10-13 10:57:10 +09002686 io_delegate_.SetFileContents("a/IFoo.aidl", R"--(package a;
Jooyung Han4cde01d2020-10-13 11:10:47 +09002687 import a.MyEnum;
Jooyung Hane6bc5e12020-10-13 10:57:10 +09002688 @JavaPassthrough(annotation="@com.android.Alice(arg=com.android.Alice.Value.A)")
2689 @JavaPassthrough(annotation="@com.android.AliceTwo")
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09002690 interface IFoo {
2691 @JavaPassthrough(annotation="@com.android.Bob")
Jooyung Han4cde01d2020-10-13 11:10:47 +09002692 void foo(@JavaPassthrough(annotation="@com.android.Cat") int x, MyEnum y);
Jiyong Park7c3b0e42020-08-04 16:08:32 +09002693 const @JavaPassthrough(annotation="@com.android.David") int A = 3;
Jooyung Hane6bc5e12020-10-13 10:57:10 +09002694 })--");
Jooyung Han4cde01d2020-10-13 11:10:47 +09002695 // JavaPassthrough should work with other types as well (e.g. enum)
2696 io_delegate_.SetFileContents("a/MyEnum.aidl", R"--(package a;
2697 @JavaPassthrough(annotation="@com.android.Alice(arg=com.android.Alice.Value.A)")
2698 @JavaPassthrough(annotation="@com.android.AliceTwo")
2699 @Backing(type="byte")
2700 enum MyEnum {
2701 a, b, c
2702 })--");
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09002703
Jooyung Han4cde01d2020-10-13 11:10:47 +09002704 Options java_options = Options::From("aidl -I . --lang=java -o out a/IFoo.aidl a/MyEnum.aidl");
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09002705 EXPECT_EQ(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
2706
2707 string java_out;
2708 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/IFoo.java", &java_out));
Jooyung Hane6bc5e12020-10-13 10:57:10 +09002709 // type-decl-level annotations with newline at the end
2710 EXPECT_THAT(java_out, testing::HasSubstr("@com.android.Alice(arg=com.android.Alice.Value.A)\n"));
2711 EXPECT_THAT(java_out, testing::HasSubstr("@com.android.AliceTwo\n"));
2712 // member-decl-level annotations with newline at the end
2713 EXPECT_THAT(java_out, testing::HasSubstr("@com.android.Bob\n"));
2714 EXPECT_THAT(java_out, testing::HasSubstr("@com.android.David\n"));
2715 // inline annotations with space at the end
2716 EXPECT_THAT(java_out, testing::HasSubstr("@com.android.Cat "));
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09002717
Jooyung Han4cde01d2020-10-13 11:10:47 +09002718 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/MyEnum.java", &java_out));
2719 // type-decl-level annotations with newline at the end
2720 EXPECT_THAT(java_out, testing::HasSubstr("@com.android.Alice(arg=com.android.Alice.Value.A)\n"));
2721 EXPECT_THAT(java_out, testing::HasSubstr("@com.android.AliceTwo\n"));
2722
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09002723 // Other backends shouldn't be bothered
Jooyung Han4cde01d2020-10-13 11:10:47 +09002724 Options cpp_options =
2725 Options::From("aidl -I . --lang=cpp -o out -h out a/IFoo.aidl a/MyEnum.aidl");
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09002726 EXPECT_EQ(0, ::android::aidl::compile_aidl(cpp_options, io_delegate_));
2727
Jooyung Han4cde01d2020-10-13 11:10:47 +09002728 Options ndk_options =
2729 Options::From("aidl -I . --lang=ndk -o out -h out a/IFoo.aidl a/MyEnum.aidl");
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09002730 EXPECT_EQ(0, ::android::aidl::compile_aidl(ndk_options, io_delegate_));
Andrei Homescub62afd92020-05-11 19:24:59 -07002731
Jooyung Han4cde01d2020-10-13 11:10:47 +09002732 Options rust_options = Options::From("aidl -I . --lang=rust -o out a/IFoo.aidl a/MyEnum.aidl");
Andrei Homescub62afd92020-05-11 19:24:59 -07002733 EXPECT_EQ(0, ::android::aidl::compile_aidl(rust_options, io_delegate_));
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09002734}
2735
Andrei Homescue61feb52020-08-18 15:44:24 -07002736TEST_F(AidlTest, ParseRustDerive) {
2737 io_delegate_.SetFileContents("a/Foo.aidl", R"(package a;
2738 @RustDerive(Clone=true, Copy=false)
2739 parcelable Foo {
2740 int a;
2741 })");
2742
2743 Options rust_options = Options::From("aidl --lang=rust -o out a/Foo.aidl");
2744 EXPECT_EQ(0, ::android::aidl::compile_aidl(rust_options, io_delegate_));
2745
2746 string rust_out;
2747 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/Foo.rs", &rust_out));
2748 EXPECT_THAT(rust_out, testing::HasSubstr("#[derive(Debug, Clone)]"));
2749
2750 // Other backends shouldn't be bothered
2751 Options cpp_options = Options::From("aidl --lang=cpp -o out -h out a/Foo.aidl");
2752 EXPECT_EQ(0, ::android::aidl::compile_aidl(cpp_options, io_delegate_));
2753
2754 Options ndk_options = Options::From("aidl --lang=ndk -o out -h out a/Foo.aidl");
2755 EXPECT_EQ(0, ::android::aidl::compile_aidl(ndk_options, io_delegate_));
2756
2757 Options java_options = Options::From("aidl --lang=java -o out a/Foo.aidl");
2758 EXPECT_EQ(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
2759}
2760
Jiyong Park56f73d72019-06-11 12:20:28 +09002761class AidlOutputPathTest : public AidlTest {
2762 protected:
2763 void SetUp() override {
2764 AidlTest::SetUp();
2765 io_delegate_.SetFileContents("sub/dir/foo/bar/IFoo.aidl", "package foo.bar; interface IFoo {}");
2766 }
2767
2768 void Test(const Options& options, const std::string expected_output_path) {
2769 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
2770 // check the existence
2771 EXPECT_TRUE(io_delegate_.GetWrittenContents(expected_output_path, nullptr));
2772 }
2773};
2774
2775TEST_F(AidlOutputPathTest, OutDirWithNoOutputFile) {
2776 // <out_dir> / <package_name> / <type_name>.java
2777 Test(Options::From("aidl -o out sub/dir/foo/bar/IFoo.aidl"), "out/foo/bar/IFoo.java");
2778}
2779
2780TEST_F(AidlOutputPathTest, OutDirWithOutputFile) {
2781 // when output file is explicitly set, it is always respected. -o option is
2782 // ignored.
2783 Test(Options::From("aidl -o out sub/dir/foo/bar/IFoo.aidl output/IFoo.java"), "output/IFoo.java");
2784}
2785
2786TEST_F(AidlOutputPathTest, NoOutDirWithOutputFile) {
2787 Test(Options::From("aidl -o out sub/dir/foo/bar/IFoo.aidl output/IFoo.java"), "output/IFoo.java");
2788}
2789
2790TEST_F(AidlOutputPathTest, NoOutDirWithNoOutputFile) {
2791 // output is the same as the input file except for the suffix
2792 Test(Options::From("aidl sub/dir/foo/bar/IFoo.aidl"), "sub/dir/foo/bar/IFoo.java");
2793}
2794
Devin Moore7b8d5c92020-03-17 14:14:08 -07002795TEST_P(AidlTest, FailOnOutOfBoundsInt32MaxConstInt) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002796 AidlError error;
2797 const string expected_stderr =
2798 "ERROR: p/IFoo.aidl:3.58-69: Invalid type specifier for an int64 literal: int\n";
2799 CaptureStderr();
Will McVickera4e5b132019-10-03 13:52:21 -07002800 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl",
2801 R"(package p;
2802 interface IFoo {
2803 const int int32_max_oob = 2147483650;
2804 }
2805 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -07002806 typenames_, GetLanguage(), &error));
Devin Moore097a3ab2020-03-11 16:08:44 -07002807 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2808 EXPECT_EQ(AidlError::BAD_TYPE, error);
Will McVickera4e5b132019-10-03 13:52:21 -07002809}
2810
Devin Moore7b8d5c92020-03-17 14:14:08 -07002811TEST_P(AidlTest, FailOnOutOfBoundsInt32MinConstInt) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002812 AidlError error;
2813 const string expected_stderr =
2814 "ERROR: p/IFoo.aidl:3.58-60: Invalid type specifier for an int64 literal: int\n";
2815 CaptureStderr();
Will McVickera4e5b132019-10-03 13:52:21 -07002816 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl",
2817 R"(package p;
2818 interface IFoo {
2819 const int int32_min_oob = -2147483650;
2820 }
2821 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -07002822 typenames_, GetLanguage(), &error));
Devin Moore097a3ab2020-03-11 16:08:44 -07002823 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2824 EXPECT_EQ(AidlError::BAD_TYPE, error);
Will McVickera4e5b132019-10-03 13:52:21 -07002825}
2826
Devin Moore7b8d5c92020-03-17 14:14:08 -07002827TEST_P(AidlTest, FailOnOutOfBoundsInt64MaxConstInt) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002828 AidlError error;
2829 const string expected_stderr =
Devin Moore2a088902020-09-17 10:51:19 -07002830 "ERROR: p/IFoo.aidl:3.59-86: Could not parse integer: 21474836509999999999999999\n";
Devin Moore097a3ab2020-03-11 16:08:44 -07002831 CaptureStderr();
Will McVickera4e5b132019-10-03 13:52:21 -07002832 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl",
2833 R"(package p;
2834 interface IFoo {
2835 const long int64_max_oob = 21474836509999999999999999;
2836 }
2837 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -07002838 typenames_, GetLanguage(), &error));
Devin Moore097a3ab2020-03-11 16:08:44 -07002839 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2840 EXPECT_EQ(AidlError::PARSE_ERROR, error);
Will McVickera4e5b132019-10-03 13:52:21 -07002841}
2842
Devin Moore7b8d5c92020-03-17 14:14:08 -07002843TEST_P(AidlTest, FailOnOutOfBoundsInt64MinConstInt) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002844 AidlError error;
2845 const string expected_stderr =
Devin Moore2a088902020-09-17 10:51:19 -07002846 "ERROR: p/IFoo.aidl:3.61-87: Could not parse integer: 21474836509999999999999999\n";
Devin Moore097a3ab2020-03-11 16:08:44 -07002847 CaptureStderr();
Will McVickera4e5b132019-10-03 13:52:21 -07002848 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl",
2849 R"(package p;
2850 interface IFoo {
2851 const long int64_min_oob = -21474836509999999999999999;
2852 }
2853 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -07002854 typenames_, GetLanguage(), &error));
Devin Moore097a3ab2020-03-11 16:08:44 -07002855 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2856 EXPECT_EQ(AidlError::PARSE_ERROR, error);
Will McVickera4e5b132019-10-03 13:52:21 -07002857}
2858
Devin Moore7b8d5c92020-03-17 14:14:08 -07002859TEST_P(AidlTest, FailOnOutOfBoundsAutofilledEnum) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002860 AidlError error;
Devin Mooredf93ebb2020-03-25 14:03:35 -07002861 const string expected_stderr =
2862 "ERROR: p/TestEnum.aidl:3.35-44: Invalid type specifier for an int32 "
2863 "literal: byte\n"
2864 "ERROR: p/TestEnum.aidl:5.1-36: Enumerator type differs from enum backing type.\n";
2865 CaptureStderr();
Daniel Normanb28684e2019-10-17 15:31:39 -07002866 EXPECT_EQ(nullptr, Parse("p/TestEnum.aidl",
2867 R"(package p;
2868 @Backing(type="byte")
2869 enum TestEnum {
2870 FOO = 127,
2871 BAR,
2872 }
2873 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -07002874 typenames_, GetLanguage(), &error));
Devin Mooredf93ebb2020-03-25 14:03:35 -07002875 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Devin Moore097a3ab2020-03-11 16:08:44 -07002876 EXPECT_EQ(AidlError::BAD_TYPE, error);
Daniel Normanb28684e2019-10-17 15:31:39 -07002877}
2878
Devin Mooredecaf292020-04-30 09:16:40 -07002879TEST_P(AidlTest, UnsupportedBackingAnnotationParam) {
2880 AidlError error;
2881 const string expected_stderr =
2882 "ERROR: p/TestEnum.aidl:2.1-51: Parameter foo not supported for annotation Backing. It must "
2883 "be one of: type\n"
2884 "ERROR: p/TestEnum.aidl:2.1-51: Parameter foo not supported for annotation Backing. It must "
2885 "be one of: type\n";
2886 CaptureStderr();
2887 EXPECT_EQ(nullptr, Parse("p/TestEnum.aidl",
2888 R"(package p;
2889 @Backing(foo="byte")
2890 enum TestEnum {
2891 FOO = 1,
2892 BAR,
2893 }
2894 )",
2895 typenames_, GetLanguage(), &error));
2896 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2897 EXPECT_EQ(AidlError::BAD_TYPE, error);
2898}
2899
Jooyung Han66813932020-10-23 13:24:44 +09002900TEST_F(AidlTest, SupportJavaOnlyImmutableAnnotation) {
Jeongik Chad0a10272020-08-06 16:33:36 +09002901 io_delegate_.SetFileContents("Foo.aidl",
2902 "@JavaOnlyImmutable parcelable Foo { int a; Bar b; List<Bar> c; "
2903 "Map<String, Baz> d; Bar[] e; }");
2904 io_delegate_.SetFileContents("Bar.aidl", "@JavaOnlyImmutable parcelable Bar { String a; }");
2905 io_delegate_.SetFileContents("Baz.aidl",
2906 "@JavaOnlyImmutable @JavaOnlyStableParcelable parcelable Baz;");
Jeongik Cha36f76c32020-07-28 00:25:52 +09002907 Options options = Options::From("aidl --lang=java -I . Foo.aidl");
2908 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
2909}
2910
Jooyung Han66813932020-10-23 13:24:44 +09002911TEST_F(AidlTest, RejectMutableParcelableFromJavaOnlyImmutableParcelable) {
Jeongik Chad0a10272020-08-06 16:33:36 +09002912 io_delegate_.SetFileContents("Foo.aidl", "@JavaOnlyImmutable parcelable Foo { Bar bar; }");
Jeongik Cha36f76c32020-07-28 00:25:52 +09002913 io_delegate_.SetFileContents("Bar.aidl", "parcelable Bar { String a; }");
Jooyung Hand4057c42020-10-23 13:28:22 +09002914 string expected_error =
Jooyung Han59af9cc2020-10-25 21:44:14 +09002915 "ERROR: Foo.aidl:1.40-44: The @JavaOnlyImmutable 'Foo' has a non-immutable field "
2916 "named 'bar'.\n";
2917 CaptureStderr();
2918 Options options = Options::From("aidl --lang=java Foo.aidl -I .");
2919 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
2920 EXPECT_EQ(expected_error, GetCapturedStderr());
2921}
2922
2923TEST_F(AidlTest, RejectMutableParcelableFromJavaOnlyImmutableUnion) {
2924 io_delegate_.SetFileContents("Foo.aidl", "@JavaOnlyImmutable union Foo { Bar bar; }");
2925 io_delegate_.SetFileContents("Bar.aidl", "parcelable Bar { String a; }");
2926 string expected_error =
2927 "ERROR: Foo.aidl:1.35-39: The @JavaOnlyImmutable 'Foo' has a non-immutable field "
Jooyung Hand4057c42020-10-23 13:28:22 +09002928 "named 'bar'.\n";
2929 CaptureStderr();
Jeongik Cha36f76c32020-07-28 00:25:52 +09002930 Options options = Options::From("aidl --lang=java Foo.aidl -I .");
2931 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jooyung Hand4057c42020-10-23 13:28:22 +09002932 EXPECT_EQ(expected_error, GetCapturedStderr());
Jeongik Cha36f76c32020-07-28 00:25:52 +09002933}
2934
Jooyung Han66813932020-10-23 13:24:44 +09002935TEST_F(AidlTest, ImmutableParcelableCannotBeInOut) {
Jeongik Chad0a10272020-08-06 16:33:36 +09002936 io_delegate_.SetFileContents("Foo.aidl", "@JavaOnlyImmutable parcelable Foo { int a; }");
Jooyung Han15fd6c62020-10-23 13:54:46 +09002937 io_delegate_.SetFileContents("IBar.aidl", "interface IBar { void my(inout Foo foo); }");
2938 string expected_error =
2939 "ERROR: IBar.aidl:1.35-39: 'foo' can't be an inout parameter because @JavaOnlyImmutable can "
2940 "only be an in parameter.\n";
2941 CaptureStderr();
Jeongik Cha36f76c32020-07-28 00:25:52 +09002942 Options options = Options::From("aidl --lang=java IBar.aidl -I .");
2943 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jooyung Han15fd6c62020-10-23 13:54:46 +09002944 EXPECT_EQ(expected_error, GetCapturedStderr());
Jeongik Cha36f76c32020-07-28 00:25:52 +09002945}
2946
Jooyung Han66813932020-10-23 13:24:44 +09002947TEST_F(AidlTest, ImmutableParcelableCannotBeOut) {
Jeongik Chad0a10272020-08-06 16:33:36 +09002948 io_delegate_.SetFileContents("Foo.aidl", "@JavaOnlyImmutable parcelable Foo { int a; }");
Jooyung Han15fd6c62020-10-23 13:54:46 +09002949 io_delegate_.SetFileContents("IBar.aidl", "interface IBar { void my(out Foo foo); }");
2950 string expected_error =
2951 "ERROR: IBar.aidl:1.33-37: 'foo' can't be an out parameter because @JavaOnlyImmutable can "
2952 "only be an in parameter.\n";
2953 CaptureStderr();
Jeongik Cha36f76c32020-07-28 00:25:52 +09002954 Options options = Options::From("aidl --lang=java IBar.aidl -I .");
2955 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jooyung Han15fd6c62020-10-23 13:54:46 +09002956 EXPECT_EQ(expected_error, GetCapturedStderr());
Jeongik Cha36f76c32020-07-28 00:25:52 +09002957}
2958
Jooyung Han66813932020-10-23 13:24:44 +09002959TEST_F(AidlTest, ImmutableParcelableFieldNameRestriction) {
Jeongik Chad0a10272020-08-06 16:33:36 +09002960 io_delegate_.SetFileContents("Foo.aidl", "@JavaOnlyImmutable parcelable Foo { int a; int A; }");
Jeongik Cha91180252020-07-31 15:43:11 +09002961 Options options = Options::From("aidl --lang=java Foo.aidl");
2962 const string expected_stderr =
Jooyung Han59af9cc2020-10-25 21:44:14 +09002963 "ERROR: Foo.aidl:1.47-49: 'Foo' has duplicate field name 'A' after capitalizing the first "
2964 "letter\n";
Jeongik Cha91180252020-07-31 15:43:11 +09002965 CaptureStderr();
2966 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
2967 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2968}
Devin Moore53fc99c2020-08-12 08:07:52 -07002969
Jooyung Han1f14ab32020-10-14 13:48:29 +09002970const char kUnionExampleExpectedOutputCppHeader[] = R"(#pragma once
2971
2972#include <a/ByteEnum.h>
2973#include <binder/Parcel.h>
Jooyung Hand2fa0232020-10-19 02:51:41 +09002974#include <binder/ParcelFileDescriptor.h>
Jooyung Han1f14ab32020-10-14 13:48:29 +09002975#include <binder/Status.h>
Jooyung Han74b1dd42020-11-01 22:17:16 +09002976#include <codecvt>
Jooyung Han1f14ab32020-10-14 13:48:29 +09002977#include <cstdint>
Jooyung Han74b1dd42020-11-01 22:17:16 +09002978#include <locale>
2979#include <sstream>
Jooyung Han3df81ae2020-10-17 17:59:59 +09002980#include <type_traits>
Jooyung Han1f14ab32020-10-14 13:48:29 +09002981#include <utility>
2982#include <variant>
2983#include <vector>
2984
2985namespace a {
2986
2987class Foo : public ::android::Parcelable {
2988public:
Jooyung Han97945de2020-10-15 16:41:38 +09002989 inline bool operator!=(const Foo& rhs) const {
2990 return _value != rhs._value;
Jooyung Han1f14ab32020-10-14 13:48:29 +09002991 }
Jooyung Han97945de2020-10-15 16:41:38 +09002992 inline bool operator<(const Foo& rhs) const {
2993 return _value < rhs._value;
Jooyung Han1f14ab32020-10-14 13:48:29 +09002994 }
Jooyung Han97945de2020-10-15 16:41:38 +09002995 inline bool operator<=(const Foo& rhs) const {
2996 return _value <= rhs._value;
Jooyung Han1f14ab32020-10-14 13:48:29 +09002997 }
Jooyung Han97945de2020-10-15 16:41:38 +09002998 inline bool operator==(const Foo& rhs) const {
2999 return _value == rhs._value;
Jooyung Han1f14ab32020-10-14 13:48:29 +09003000 }
Jooyung Han97945de2020-10-15 16:41:38 +09003001 inline bool operator>(const Foo& rhs) const {
3002 return _value > rhs._value;
Jooyung Han1f14ab32020-10-14 13:48:29 +09003003 }
Jooyung Han97945de2020-10-15 16:41:38 +09003004 inline bool operator>=(const Foo& rhs) const {
3005 return _value >= rhs._value;
Jooyung Han1f14ab32020-10-14 13:48:29 +09003006 }
Jooyung Han97945de2020-10-15 16:41:38 +09003007
Jooyung Han1f14ab32020-10-14 13:48:29 +09003008 enum Tag : int32_t {
Jooyung Han97945de2020-10-15 16:41:38 +09003009 ns = 0, // int[] ns;
3010 e, // a.ByteEnum e;
Jooyung Hand2fa0232020-10-19 02:51:41 +09003011 pfd, // ParcelFileDescriptor pfd;
Jooyung Han1f14ab32020-10-14 13:48:29 +09003012 };
Jooyung Han97945de2020-10-15 16:41:38 +09003013
Jooyung Han1f14ab32020-10-14 13:48:29 +09003014 template<typename _Tp>
Jooyung Han97945de2020-10-15 16:41:38 +09003015 static constexpr bool _not_self = !std::is_same_v<std::remove_cv_t<std::remove_reference_t<_Tp>>, Foo>;
Jooyung Han1f14ab32020-10-14 13:48:29 +09003016
3017 Foo() : _value(std::in_place_index<ns>, ::std::vector<int32_t>({42})) { }
Jooyung Han97945de2020-10-15 16:41:38 +09003018 Foo(const Foo&) = default;
3019 Foo(Foo&&) = default;
Jooyung Han1f14ab32020-10-14 13:48:29 +09003020 Foo& operator=(const Foo&) = default;
3021 Foo& operator=(Foo&&) = default;
3022
Jooyung Han97945de2020-10-15 16:41:38 +09003023 template <typename _Tp, std::enable_if_t<_not_self<_Tp>, int> = 0>
3024 constexpr Foo(_Tp&& _arg)
3025 : _value(std::forward<_Tp>(_arg)) {}
3026
3027 template <typename... _Tp>
3028 constexpr explicit Foo(_Tp&&... _args)
3029 : _value(std::forward<_Tp>(_args)...) {}
3030
3031 template <Tag _tag, typename... _Tp>
3032 static Foo make(_Tp&&... _args) {
3033 return Foo(std::in_place_index<_tag>, std::forward<_Tp>(_args)...);
Jooyung Han1f14ab32020-10-14 13:48:29 +09003034 }
Jooyung Han97945de2020-10-15 16:41:38 +09003035
3036 template <Tag _tag, typename _Tp, typename... _Up>
3037 static Foo make(std::initializer_list<_Tp> _il, _Up&&... _args) {
3038 return Foo(std::in_place_index<_tag>, std::move(_il), std::forward<_Up>(_args)...);
Jooyung Han1f14ab32020-10-14 13:48:29 +09003039 }
3040
3041 Tag getTag() const {
Jooyung Han97945de2020-10-15 16:41:38 +09003042 return static_cast<Tag>(_value.index());
Jooyung Han1f14ab32020-10-14 13:48:29 +09003043 }
3044
Jooyung Han97945de2020-10-15 16:41:38 +09003045 template <Tag _tag>
Jooyung Han1f14ab32020-10-14 13:48:29 +09003046 const auto& get() const {
Jooyung Han97945de2020-10-15 16:41:38 +09003047 if (getTag() != _tag) { abort(); }
3048 return std::get<_tag>(_value);
Jooyung Han1f14ab32020-10-14 13:48:29 +09003049 }
3050
Jooyung Han97945de2020-10-15 16:41:38 +09003051 template <Tag _tag>
Jooyung Han1f14ab32020-10-14 13:48:29 +09003052 auto& get() {
Jooyung Han97945de2020-10-15 16:41:38 +09003053 if (getTag() != _tag) { abort(); }
3054 return std::get<_tag>(_value);
Jooyung Han1f14ab32020-10-14 13:48:29 +09003055 }
3056
Jooyung Han97945de2020-10-15 16:41:38 +09003057 template <Tag _tag, typename... _Tp>
3058 void set(_Tp&&... _args) {
3059 _value.emplace<_tag>(std::forward<_Tp>(_args)...);
Jooyung Han1f14ab32020-10-14 13:48:29 +09003060 }
3061
3062 ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) override final;
3063 ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const override final;
3064 static const std::string& getParcelableDescriptor() {
3065 static const std::string DESCIPTOR = "a.Foo";
3066 return DESCIPTOR;
3067 }
Jooyung Hanb8e01b92020-11-01 16:49:13 +09003068 template <typename _T> class _has_toString {
3069 template <typename _U> static std::true_type __has_toString(decltype(&_U::toString));
3070 template <typename _U> static std::false_type __has_toString(...);
3071 public: enum { value = decltype(__has_toString<_T>(nullptr))::value };
3072 };
3073 template <typename _T> inline static std::string _call_toString(const _T& t) {
3074 if constexpr (_has_toString<_T>::value) return t.toString();
3075 return "{no toString() implemented}";
3076 }
Jooyung Han74b1dd42020-11-01 22:17:16 +09003077 inline std::string toString() const {
3078 std::ostringstream os;
3079 os << "Foo{";
3080 switch (getTag()) {
3081 case ns: os << "ns: " << [&](){ std::ostringstream o; o << "["; bool first = true; for (const auto& v: get<ns>()) { (void)v; if (first) first = false; else o << ", "; o << std::to_string(v); }; o << "]"; return o.str(); }(); break;
3082 case e: os << "e: " << a::toString(get<e>()); break;
3083 case pfd: os << "pfd: " << ""; break;
3084 }
3085 os << "}";
3086 return os.str();
3087 }
Jooyung Han1f14ab32020-10-14 13:48:29 +09003088private:
Jooyung Hand2fa0232020-10-19 02:51:41 +09003089 std::variant<::std::vector<int32_t>, ::a::ByteEnum, ::android::os::ParcelFileDescriptor> _value;
Jooyung Han1f14ab32020-10-14 13:48:29 +09003090}; // class Foo
3091
3092} // namespace a
3093)";
3094
3095const char kUnionExampleExpectedOutputCppSource[] = R"(#include <a/Foo.h>
3096
3097namespace a {
3098
3099::android::status_t Foo::readFromParcel(const ::android::Parcel* _aidl_parcel) {
3100 ::android::status_t _aidl_ret_status;
3101 int32_t _aidl_tag;
3102 if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_tag)) != ::android::OK) return _aidl_ret_status;
3103 switch (_aidl_tag) {
3104 case ns: {
3105 ::std::vector<int32_t> _aidl_value;
3106 if ((_aidl_ret_status = _aidl_parcel->readInt32Vector(&_aidl_value)) != ::android::OK) return _aidl_ret_status;
3107 set<ns>(std::move(_aidl_value));
3108 return ::android::OK; }
3109 case e: {
3110 ::a::ByteEnum _aidl_value;
3111 if ((_aidl_ret_status = _aidl_parcel->readByte(reinterpret_cast<int8_t *>(&_aidl_value))) != ::android::OK) return _aidl_ret_status;
3112 set<e>(std::move(_aidl_value));
3113 return ::android::OK; }
Jooyung Hand2fa0232020-10-19 02:51:41 +09003114 case pfd: {
3115 ::android::os::ParcelFileDescriptor _aidl_value;
3116 if ((_aidl_ret_status = _aidl_parcel->readParcelable(&_aidl_value)) != ::android::OK) return _aidl_ret_status;
3117 set<pfd>(std::move(_aidl_value));
3118 return ::android::OK; }
Jooyung Han1f14ab32020-10-14 13:48:29 +09003119 }
3120 return ::android::BAD_VALUE;
3121}
3122
3123::android::status_t Foo::writeToParcel(::android::Parcel* _aidl_parcel) const {
3124 ::android::status_t _aidl_ret_status = _aidl_parcel->writeInt32(getTag());
3125 if (_aidl_ret_status != ::android::OK) return _aidl_ret_status;
3126 switch (getTag()) {
3127 case ns: return _aidl_parcel->writeInt32Vector(get<ns>());
3128 case e: return _aidl_parcel->writeByte(static_cast<int8_t>(get<e>()));
Jooyung Hand2fa0232020-10-19 02:51:41 +09003129 case pfd: return _aidl_parcel->writeParcelable(get<pfd>());
Jooyung Han1f14ab32020-10-14 13:48:29 +09003130 }
3131 abort();
3132}
3133
3134} // namespace a
3135)";
3136
Jooyung Han6beac042020-10-17 21:59:43 +09003137const char kUnionExampleExpectedOutputNdkHeader[] = R"(#pragma once
3138#include <android/binder_interface_utils.h>
3139#include <android/binder_parcelable_utils.h>
Jooyung Han74b1dd42020-11-01 22:17:16 +09003140#include <codecvt>
3141#include <locale>
3142#include <sstream>
Jooyung Han6beac042020-10-17 21:59:43 +09003143
3144#include <type_traits>
3145#include <utility>
3146#include <variant>
3147#include <cstdint>
3148#include <memory>
3149#include <optional>
3150#include <string>
3151#include <vector>
3152#ifdef BINDER_STABILITY_SUPPORT
3153#include <android/binder_stability.h>
3154#endif // BINDER_STABILITY_SUPPORT
3155#include <aidl/a/ByteEnum.h>
3156namespace aidl {
3157namespace a {
3158class Foo {
3159public:
3160 typedef std::false_type fixed_size;
3161 static const char* descriptor;
3162
3163 enum Tag : int32_t {
3164 ns = 0, // int[] ns;
3165 e, // a.ByteEnum e;
Jooyung Hand2fa0232020-10-19 02:51:41 +09003166 pfd, // ParcelFileDescriptor pfd;
Jooyung Han6beac042020-10-17 21:59:43 +09003167 };
3168
3169 template<typename _Tp>
3170 static constexpr bool _not_self = !std::is_same_v<std::remove_cv_t<std::remove_reference_t<_Tp>>, Foo>;
3171
3172 Foo() : _value(std::in_place_index<ns>, std::vector<int32_t>({42})) { }
3173 Foo(const Foo&) = default;
3174 Foo(Foo&&) = default;
3175 Foo& operator=(const Foo&) = default;
3176 Foo& operator=(Foo&&) = default;
3177
3178 template <typename _Tp, std::enable_if_t<_not_self<_Tp>, int> = 0>
3179 constexpr Foo(_Tp&& _arg)
3180 : _value(std::forward<_Tp>(_arg)) {}
3181
3182 template <typename... _Tp>
3183 constexpr explicit Foo(_Tp&&... _args)
3184 : _value(std::forward<_Tp>(_args)...) {}
3185
3186 template <Tag _tag, typename... _Tp>
3187 static Foo make(_Tp&&... _args) {
3188 return Foo(std::in_place_index<_tag>, std::forward<_Tp>(_args)...);
3189 }
3190
3191 template <Tag _tag, typename _Tp, typename... _Up>
3192 static Foo make(std::initializer_list<_Tp> _il, _Up&&... _args) {
3193 return Foo(std::in_place_index<_tag>, std::move(_il), std::forward<_Up>(_args)...);
3194 }
3195
3196 Tag getTag() const {
3197 return static_cast<Tag>(_value.index());
3198 }
3199
3200 template <Tag _tag>
3201 const auto& get() const {
3202 if (getTag() != _tag) { abort(); }
3203 return std::get<_tag>(_value);
3204 }
3205
3206 template <Tag _tag>
3207 auto& get() {
3208 if (getTag() != _tag) { abort(); }
3209 return std::get<_tag>(_value);
3210 }
3211
3212 template <Tag _tag, typename... _Tp>
3213 void set(_Tp&&... _args) {
3214 _value.emplace<_tag>(std::forward<_Tp>(_args)...);
3215 }
3216
3217 binder_status_t readFromParcel(const AParcel* _parcel);
3218 binder_status_t writeToParcel(AParcel* _parcel) const;
3219 static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL;
Jooyung Hanb8e01b92020-11-01 16:49:13 +09003220 template <typename _T> class _has_toString {
3221 template <typename _U> static std::true_type __has_toString(decltype(&_U::toString));
3222 template <typename _U> static std::false_type __has_toString(...);
3223 public: enum { value = decltype(__has_toString<_T>(nullptr))::value };
3224 };
3225 template <typename _T> inline static std::string _call_toString(const _T& t) {
3226 if constexpr (_has_toString<_T>::value) return t.toString();
3227 return "{no toString() implemented}";
3228 }
Jooyung Han74b1dd42020-11-01 22:17:16 +09003229 inline std::string toString() const {
3230 std::ostringstream os;
3231 os << "Foo{";
3232 switch (getTag()) {
3233 case ns: os << "ns: " << [&](){ std::ostringstream o; o << "["; bool first = true; for (const auto& v: get<ns>()) { (void)v; if (first) first = false; else o << ", "; o << std::to_string(v); }; o << "]"; return o.str(); }(); break;
3234 case e: os << "e: " << a::toString(get<e>()); break;
3235 case pfd: os << "pfd: " << ""; break;
3236 }
3237 os << "}";
3238 return os.str();
3239 }
Jooyung Han6beac042020-10-17 21:59:43 +09003240private:
Jooyung Hand2fa0232020-10-19 02:51:41 +09003241 std::variant<std::vector<int32_t>, ::aidl::a::ByteEnum, ::ndk::ScopedFileDescriptor> _value;
Jooyung Han6beac042020-10-17 21:59:43 +09003242};
3243} // namespace a
3244} // namespace aidl
3245)";
3246
3247const char kUnionExampleExpectedOutputNdkSource[] = R"(#include "aidl/a/Foo.h"
3248
3249#include <android/binder_parcel_utils.h>
3250
3251namespace aidl {
3252namespace a {
3253const char* Foo::descriptor = "a.Foo";
3254
3255binder_status_t Foo::readFromParcel(const AParcel* _parcel) {
3256 binder_status_t _aidl_ret_status;
3257 int32_t _aidl_tag;
3258 if ((_aidl_ret_status = AParcel_readInt32(_parcel, &_aidl_tag)) != STATUS_OK) return _aidl_ret_status;
3259 switch (_aidl_tag) {
3260 case ns: {
3261 std::vector<int32_t> _aidl_value;
3262 if ((_aidl_ret_status = ::ndk::AParcel_readVector(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status;
3263 set<ns>(std::move(_aidl_value));
3264 return STATUS_OK; }
3265 case e: {
3266 ::aidl::a::ByteEnum _aidl_value;
3267 if ((_aidl_ret_status = AParcel_readByte(_parcel, reinterpret_cast<int8_t*>(&_aidl_value))) != STATUS_OK) return _aidl_ret_status;
3268 set<e>(std::move(_aidl_value));
3269 return STATUS_OK; }
Jooyung Hand2fa0232020-10-19 02:51:41 +09003270 case pfd: {
3271 ::ndk::ScopedFileDescriptor _aidl_value;
3272 if ((_aidl_ret_status = ::ndk::AParcel_readRequiredParcelFileDescriptor(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status;
3273 set<pfd>(std::move(_aidl_value));
3274 return STATUS_OK; }
Jooyung Han6beac042020-10-17 21:59:43 +09003275 }
3276 return STATUS_BAD_VALUE;
3277}
3278binder_status_t Foo::writeToParcel(AParcel* _parcel) const {
3279 binder_status_t _aidl_ret_status = AParcel_writeInt32(_parcel, getTag());
3280 if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status;
3281 switch (getTag()) {
3282 case ns: return ::ndk::AParcel_writeVector(_parcel, get<ns>());
3283 case e: return AParcel_writeByte(_parcel, static_cast<int8_t>(get<e>()));
Jooyung Hand2fa0232020-10-19 02:51:41 +09003284 case pfd: return ::ndk::AParcel_writeRequiredParcelFileDescriptor(_parcel, get<pfd>());
Jooyung Han6beac042020-10-17 21:59:43 +09003285 }
3286 abort();
3287}
3288
3289} // namespace a
3290} // namespace aidl
3291)";
3292
Jooyung Han1f14ab32020-10-14 13:48:29 +09003293const char kUnionExampleExpectedOutputJava[] = R"(/*
3294 * This file is auto-generated. DO NOT MODIFY.
3295 */
3296package a;
3297
3298
3299public final class Foo implements android.os.Parcelable {
Jooyung Han97945de2020-10-15 16:41:38 +09003300 // tags for union fields
3301 public final static int ns = 0; // int[] ns;
3302 public final static int e = 1; // a.ByteEnum e;
Jooyung Hand2fa0232020-10-19 02:51:41 +09003303 public final static int pfd = 2; // ParcelFileDescriptor pfd;
Jooyung Han1f14ab32020-10-14 13:48:29 +09003304
3305 private int _tag;
3306 private Object _value;
3307
3308 public Foo() {
Jooyung Hance62f932020-10-25 10:21:49 +09003309 int[] _value = {42};
3310 this._tag = ns;
3311 this._value = _value;
Jooyung Han1f14ab32020-10-14 13:48:29 +09003312 }
Jooyung Han97945de2020-10-15 16:41:38 +09003313
Jooyung Han1f14ab32020-10-14 13:48:29 +09003314 private Foo(android.os.Parcel _aidl_parcel) {
3315 readFromParcel(_aidl_parcel);
3316 }
Jooyung Han97945de2020-10-15 16:41:38 +09003317
Jooyung Hance62f932020-10-25 10:21:49 +09003318 private Foo(int _tag, Object _value) {
3319 this._tag = _tag;
3320 this._value = _value;
Jooyung Han1f14ab32020-10-14 13:48:29 +09003321 }
3322
3323 public int getTag() {
3324 return _tag;
3325 }
3326
Jooyung Han97945de2020-10-15 16:41:38 +09003327 // int[] ns;
Jooyung Han1f14ab32020-10-14 13:48:29 +09003328
3329 public static Foo ns(int[] _value) {
3330 return new Foo(ns, _value);
3331 }
Jooyung Han97945de2020-10-15 16:41:38 +09003332
Jooyung Han1f14ab32020-10-14 13:48:29 +09003333 public int[] getNs() {
3334 _assertTag(ns);
3335 return (int[]) _value;
3336 }
Jooyung Han97945de2020-10-15 16:41:38 +09003337
Jooyung Han1f14ab32020-10-14 13:48:29 +09003338 public void setNs(int[] _value) {
3339 _set(ns, _value);
3340 }
3341
Jooyung Han97945de2020-10-15 16:41:38 +09003342 // a.ByteEnum e;
Jooyung Han1f14ab32020-10-14 13:48:29 +09003343
3344 public static Foo e(byte _value) {
3345 return new Foo(e, _value);
3346 }
Jooyung Han97945de2020-10-15 16:41:38 +09003347
Jooyung Han1f14ab32020-10-14 13:48:29 +09003348 public byte getE() {
3349 _assertTag(e);
3350 return (byte) _value;
3351 }
Jooyung Han97945de2020-10-15 16:41:38 +09003352
Jooyung Han1f14ab32020-10-14 13:48:29 +09003353 public void setE(byte _value) {
3354 _set(e, _value);
3355 }
3356
Jooyung Hand2fa0232020-10-19 02:51:41 +09003357 // ParcelFileDescriptor pfd;
3358
3359 public static Foo pfd(android.os.ParcelFileDescriptor _value) {
3360 return new Foo(pfd, _value);
3361 }
3362
3363 public android.os.ParcelFileDescriptor getPfd() {
3364 _assertTag(pfd);
3365 return (android.os.ParcelFileDescriptor) _value;
3366 }
3367
3368 public void setPfd(android.os.ParcelFileDescriptor _value) {
3369 _set(pfd, _value);
3370 }
3371
Jooyung Han1f14ab32020-10-14 13:48:29 +09003372 public static final android.os.Parcelable.Creator<Foo> CREATOR = new android.os.Parcelable.Creator<Foo>() {
3373 @Override
3374 public Foo createFromParcel(android.os.Parcel _aidl_source) {
Jooyung Han97945de2020-10-15 16:41:38 +09003375 return new Foo(_aidl_source);
Jooyung Han1f14ab32020-10-14 13:48:29 +09003376 }
3377 @Override
3378 public Foo[] newArray(int _aidl_size) {
3379 return new Foo[_aidl_size];
3380 }
3381 };
Jooyung Han97945de2020-10-15 16:41:38 +09003382
Jooyung Han1f14ab32020-10-14 13:48:29 +09003383 @Override
3384 public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) {
3385 _aidl_parcel.writeInt(_tag);
3386 switch (_tag) {
3387 case ns:
3388 _aidl_parcel.writeIntArray(getNs());
3389 break;
3390 case e:
3391 _aidl_parcel.writeByte(getE());
3392 break;
Jooyung Hand2fa0232020-10-19 02:51:41 +09003393 case pfd:
3394 if ((getPfd()!=null)) {
3395 _aidl_parcel.writeInt(1);
3396 getPfd().writeToParcel(_aidl_parcel, 0);
3397 }
3398 else {
3399 _aidl_parcel.writeInt(0);
3400 }
3401 break;
Jooyung Han1f14ab32020-10-14 13:48:29 +09003402 }
3403 }
Jooyung Han97945de2020-10-15 16:41:38 +09003404
Jooyung Han1f14ab32020-10-14 13:48:29 +09003405 public void readFromParcel(android.os.Parcel _aidl_parcel) {
3406 int _aidl_tag;
3407 _aidl_tag = _aidl_parcel.readInt();
3408 switch (_aidl_tag) {
3409 case ns: {
3410 int[] _aidl_value;
3411 _aidl_value = _aidl_parcel.createIntArray();
3412 _set(_aidl_tag, _aidl_value);
3413 return; }
3414 case e: {
3415 byte _aidl_value;
3416 _aidl_value = _aidl_parcel.readByte();
3417 _set(_aidl_tag, _aidl_value);
3418 return; }
Jooyung Hand2fa0232020-10-19 02:51:41 +09003419 case pfd: {
3420 android.os.ParcelFileDescriptor _aidl_value;
3421 if ((0!=_aidl_parcel.readInt())) {
3422 _aidl_value = android.os.ParcelFileDescriptor.CREATOR.createFromParcel(_aidl_parcel);
3423 }
3424 else {
3425 _aidl_value = null;
3426 }
3427 _set(_aidl_tag, _aidl_value);
3428 return; }
Jooyung Han1f14ab32020-10-14 13:48:29 +09003429 }
3430 throw new RuntimeException("union: out of range: " + _aidl_tag);
3431 }
Jooyung Han97945de2020-10-15 16:41:38 +09003432
Jooyung Han1f14ab32020-10-14 13:48:29 +09003433 @Override
3434 public int describeContents() {
Jooyung Hand2fa0232020-10-19 02:51:41 +09003435 int _mask = 0;
3436 switch (getTag()) {
3437 case pfd:
Jooyung Hanea2147c2020-10-21 18:16:56 +09003438 _mask |= describeContents(getPfd());
Jooyung Hand2fa0232020-10-19 02:51:41 +09003439 break;
3440 }
3441 return _mask;
Jooyung Han1f14ab32020-10-14 13:48:29 +09003442 }
Jooyung Hanea2147c2020-10-21 18:16:56 +09003443 private int describeContents(Object _v) {
3444 if (_v == null) return 0;
3445 if (_v instanceof android.os.Parcelable) {
3446 return ((android.os.Parcelable) _v).describeContents();
3447 }
3448 return 0;
3449 }
Jooyung Han1f14ab32020-10-14 13:48:29 +09003450
3451 private void _assertTag(int tag) {
3452 if (getTag() != tag) {
Jooyung Hanef9b0f62020-10-14 21:52:55 +09003453 throw new IllegalStateException("bad access: " + _tagString(tag) + ", " + _tagString(getTag()) + " is available.");
Jooyung Han1f14ab32020-10-14 13:48:29 +09003454 }
3455 }
Jooyung Han97945de2020-10-15 16:41:38 +09003456
Jooyung Han1f14ab32020-10-14 13:48:29 +09003457 private String _tagString(int _tag) {
3458 switch (_tag) {
3459 case ns: return "ns";
3460 case e: return "e";
Jooyung Hand2fa0232020-10-19 02:51:41 +09003461 case pfd: return "pfd";
Jooyung Han1f14ab32020-10-14 13:48:29 +09003462 }
3463 throw new IllegalStateException("unknown field: " + _tag);
3464 }
Jooyung Han97945de2020-10-15 16:41:38 +09003465
Jooyung Hance62f932020-10-25 10:21:49 +09003466 private void _set(int _tag, Object _value) {
3467 this._tag = _tag;
3468 this._value = _value;
Jooyung Han1f14ab32020-10-14 13:48:29 +09003469 }
3470}
3471)";
3472
Jooyung Hanf93b5bd2020-10-28 15:12:08 +09003473const char kUnionExampleExpectedOutputRust[] = R"(#[derive(Debug)]
3474pub enum Foo {
3475 Ns(Vec<i32>),
3476 E(crate::mangled::_1_a_8_ByteEnum),
3477 Pfd(Option<binder::parcel::ParcelFileDescriptor>),
3478}
3479pub(crate) mod mangled { pub use super::Foo as _1_a_3_Foo; }
3480impl Default for Foo {
3481 fn default() -> Self {
3482 Self::Ns(vec!{42})
3483 }
3484}
3485impl binder::parcel::Serialize for Foo {
3486 fn serialize(&self, parcel: &mut binder::parcel::Parcel) -> binder::Result<()> {
3487 <Self as binder::parcel::SerializeOption>::serialize_option(Some(self), parcel)
3488 }
3489}
3490impl binder::parcel::SerializeArray for Foo {}
3491impl binder::parcel::SerializeOption for Foo {
3492 fn serialize_option(this: Option<&Self>, parcel: &mut binder::parcel::Parcel) -> binder::Result<()> {
3493 let this = if let Some(this) = this {
3494 parcel.write(&1i32)?;
3495 this
3496 } else {
3497 return parcel.write(&0i32);
3498 };
3499 match this {
3500 Self::Ns(v) => {
3501 parcel.write(&0i32)?;
3502 parcel.write(v)
3503 }
3504 Self::E(v) => {
3505 parcel.write(&1i32)?;
3506 parcel.write(v)
3507 }
3508 Self::Pfd(v) => {
3509 parcel.write(&2i32)?;
3510 let __field_ref = v.as_ref().ok_or(binder::StatusCode::UNEXPECTED_NULL)?;
3511 parcel.write(__field_ref)
3512 }
3513 }
3514 }
3515}
3516impl binder::parcel::Deserialize for Foo {
3517 fn deserialize(parcel: &binder::parcel::Parcel) -> binder::Result<Self> {
3518 <Self as binder::parcel::DeserializeOption>::deserialize_option(parcel)
3519 .transpose()
3520 .unwrap_or(Err(binder::StatusCode::UNEXPECTED_NULL))
3521 }
3522}
3523impl binder::parcel::DeserializeArray for Foo {}
3524impl binder::parcel::DeserializeOption for Foo {
3525 fn deserialize_option(parcel: &binder::parcel::Parcel) -> binder::Result<Option<Self>> {
3526 let status: i32 = parcel.read()?;
3527 if status == 0 { return Ok(None); }
3528 let tag: i32 = parcel.read()?;
3529 match tag {
3530 0 => {
3531 let value: Vec<i32> = parcel.read()?;
3532 Ok(Some(Self::Ns(value)))
3533 }
3534 1 => {
3535 let value: crate::mangled::_1_a_8_ByteEnum = parcel.read()?;
3536 Ok(Some(Self::E(value)))
3537 }
3538 2 => {
3539 let value: Option<binder::parcel::ParcelFileDescriptor> = Some(parcel.read()?);
3540 Ok(Some(Self::Pfd(value)))
3541 }
3542 _ => {
3543 Err(binder::StatusCode::BAD_VALUE)
3544 }
3545 }
3546 }
3547}
3548)";
3549
Jooyung Han97945de2020-10-15 16:41:38 +09003550struct AidlUnionTest : ::testing::Test {
3551 void SetUp() override {
3552 io_delegate_.SetFileContents("a/Foo.aidl", R"(
Jooyung Han1f14ab32020-10-14 13:48:29 +09003553package a;
3554import a.ByteEnum;
3555union Foo {
3556 int[] ns = {42};
3557 ByteEnum e;
Jooyung Hand2fa0232020-10-19 02:51:41 +09003558 ParcelFileDescriptor pfd;
Jooyung Han1f14ab32020-10-14 13:48:29 +09003559}
3560)");
Jooyung Han97945de2020-10-15 16:41:38 +09003561 io_delegate_.SetFileContents("a/ByteEnum.aidl", R"(
Jooyung Han1f14ab32020-10-14 13:48:29 +09003562package a;
3563@Backing(type="byte")
3564enum ByteEnum {
3565 a, b, c
3566}
3567)");
Jooyung Han97945de2020-10-15 16:41:38 +09003568 }
3569 FakeIoDelegate io_delegate_;
3570 void Compile(string lang) {
3571 string command = "aidl --structured -I. -o out --lang=" + lang;
3572 if (lang == "cpp" || lang == "ndk") {
3573 command += " -h out";
3574 }
3575 command += " a/Foo.aidl";
3576 auto opts = Options::From(command);
Jooyung Han1f14ab32020-10-14 13:48:29 +09003577 CaptureStderr();
3578 auto ret = ::android::aidl::compile_aidl(opts, io_delegate_);
3579 auto err = GetCapturedStderr();
3580 EXPECT_EQ(0, ret) << err;
Jooyung Han97945de2020-10-15 16:41:38 +09003581 }
3582 void EXPECT_COMPILE_OUTPUTS(const map<string, string>& outputs) {
3583 for (const auto& [path, expected] : outputs) {
Jooyung Han1f14ab32020-10-14 13:48:29 +09003584 string actual;
3585 EXPECT_TRUE(io_delegate_.GetWrittenContents(path, &actual)) << path << " not found.";
3586 EXPECT_EQ(expected, actual);
3587 }
Jooyung Han97945de2020-10-15 16:41:38 +09003588 }
3589};
Jooyung Han1f14ab32020-10-14 13:48:29 +09003590
Jooyung Han97945de2020-10-15 16:41:38 +09003591TEST_F(AidlUnionTest, Example_Cpp) {
3592 Compile("cpp");
3593 EXPECT_COMPILE_OUTPUTS(
3594 map<string, string>({{"out/a/Foo.cpp", kUnionExampleExpectedOutputCppSource},
3595 {"out/a/Foo.h", kUnionExampleExpectedOutputCppHeader}}));
3596}
3597
Jooyung Han6beac042020-10-17 21:59:43 +09003598TEST_F(AidlUnionTest, Example_Ndk) {
3599 Compile("ndk");
3600 EXPECT_COMPILE_OUTPUTS(
3601 map<string, string>({{"out/a/Foo.cpp", kUnionExampleExpectedOutputNdkSource},
3602 {"out/aidl/a/Foo.h", kUnionExampleExpectedOutputNdkHeader}}));
3603}
3604
Jooyung Han97945de2020-10-15 16:41:38 +09003605TEST_F(AidlUnionTest, Example_Java) {
3606 Compile("java");
3607 EXPECT_COMPILE_OUTPUTS(
3608 map<string, string>({{"out/a/Foo.java", kUnionExampleExpectedOutputJava}}));
Jooyung Hanf93b5bd2020-10-28 15:12:08 +09003609}
3610
3611TEST_F(AidlUnionTest, Example_Rust) {
3612 Compile("rust");
3613 EXPECT_COMPILE_OUTPUTS(map<string, string>({{"out/a/Foo.rs", kUnionExampleExpectedOutputRust}}));
Jooyung Han1f14ab32020-10-14 13:48:29 +09003614}
3615
Jooyung Hanfe89f122020-10-14 03:49:18 +09003616TEST_P(AidlTest, UnionRejectsEmptyDecl) {
3617 const string method = "package a; union Foo {}";
3618 const string expected_stderr = "ERROR: a/Foo.aidl:1.17-21: The union 'Foo' has no fields.\n";
3619 CaptureStderr();
3620 EXPECT_EQ(nullptr, Parse("a/Foo.aidl", method, typenames_, GetLanguage()));
3621 EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr(expected_stderr));
3622}
3623
3624TEST_P(AidlTest, UnionRejectsParcelableHolder) {
3625 const string method = "package a; union Foo { ParcelableHolder x; }";
3626 const string expected_stderr =
3627 "ERROR: a/Foo.aidl:1.40-42: A union can't have a member of ParcelableHolder 'x'\n";
3628 CaptureStderr();
3629 EXPECT_EQ(nullptr, Parse("a/Foo.aidl", method, typenames_, GetLanguage()));
3630 EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr(expected_stderr));
3631}
3632
Devin Moore53fc99c2020-08-12 08:07:52 -07003633TEST_P(AidlTest, GenericStructuredParcelable) {
3634 io_delegate_.SetFileContents("Foo.aidl", "parcelable Foo<T, U> { int a; int A; }");
3635 Options options =
3636 Options::From("aidl Foo.aidl --lang=" + Options::LanguageToString(GetLanguage()));
3637 const string expected_stderr = "";
3638 CaptureStderr();
3639 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3640 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3641}
3642
Jooyung Han8c9a4e12020-10-26 15:39:54 +09003643TEST_F(AidlTest, NestedTypeArgs) {
3644 io_delegate_.SetFileContents("a/Bar.aidl", "package a; parcelable Bar<A> { }");
Steven Moreland6c07b832020-10-29 23:39:53 +00003645 io_delegate_.SetFileContents("a/Baz.aidl", "package a; parcelable Baz<A, B> { }");
3646
3647 io_delegate_.SetFileContents("a/Foo.aidl",
3648 "package a; import a.Bar; import a.Baz; parcelable Foo { "
3649 "Baz<Bar<Bar<String[]>>[], Bar<String>> barss; }");
Jooyung Han8c9a4e12020-10-26 15:39:54 +09003650 Options options = Options::From("aidl a/Foo.aidl -I . -o out --lang=java");
3651 const string expected_stderr = "";
3652 CaptureStderr();
3653 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3654 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3655
3656 string code;
3657 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/Foo.java", &code));
Steven Moreland6c07b832020-10-29 23:39:53 +00003658 EXPECT_THAT(code,
3659 testing::HasSubstr(
3660 "a.Baz<a.Bar<a.Bar<java.lang.String[]>>[],a.Bar<java.lang.String>> barss;"));
3661}
3662
3663TEST_F(AidlTest, DoubleArrayError) {
3664 io_delegate_.SetFileContents("a/Bar.aidl", "package a; parcelable Bar { String[][] a; }");
3665
3666 Options options = Options::From("aidl a/Bar.aidl -I . -o out --lang=java");
3667 const string expected_stderr =
3668 "ERROR: a/Bar.aidl:1.28-37: Can only have one dimensional arrays.\n";
3669 CaptureStderr();
3670 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3671 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3672}
3673
3674TEST_F(AidlTest, DoubleGenericError) {
3675 io_delegate_.SetFileContents("a/Bar.aidl",
3676 "package a; parcelable Bar { List<String><String> a; }");
3677
3678 Options options = Options::From("aidl a/Bar.aidl -I . -o out --lang=java");
3679 const string expected_stderr =
3680 "ERROR: a/Bar.aidl:1.28-33: Can only specify one set of type parameters.\n";
3681 CaptureStderr();
3682 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3683 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3684}
3685
3686TEST_F(AidlTest, ArrayBeforeGenericError) {
3687 io_delegate_.SetFileContents("a/Bar.aidl", "package a; parcelable Bar { List[]<String> a; }");
3688
3689 Options options = Options::From("aidl a/Bar.aidl -I . -o out --lang=java");
3690 const string expected_stderr =
3691 "ERROR: a/Bar.aidl:1.28-33: Must specify type parameters (<>) before array ([]).\n";
3692 CaptureStderr();
3693 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3694 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jooyung Han8c9a4e12020-10-26 15:39:54 +09003695}
3696
Jooyung Han14004ed2020-10-16 03:49:57 +09003697struct GenericAidlTest : ::testing::Test {
3698 FakeIoDelegate io_delegate_;
3699 void Compile(string cmd) {
Steven Moreland6c07b832020-10-29 23:39:53 +00003700 io_delegate_.SetFileContents("Foo.aidl", "parcelable Foo { Bar<Baz<Qux>> x; }");
Jooyung Han14004ed2020-10-16 03:49:57 +09003701 io_delegate_.SetFileContents("Bar.aidl", "parcelable Bar<T> { }");
3702 io_delegate_.SetFileContents("Baz.aidl", "parcelable Baz<T> { }");
3703 io_delegate_.SetFileContents("Qux.aidl", "parcelable Qux { }");
3704
3705 Options options = Options::From(cmd);
3706 CaptureStderr();
3707 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3708 EXPECT_EQ("", GetCapturedStderr());
3709 }
3710};
3711
3712TEST_F(GenericAidlTest, ImportGenericParameterTypesCPP) {
3713 Compile("aidl Foo.aidl --lang=cpp -I . -o out -h out");
3714 string code;
3715 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/Foo.h", &code));
3716 EXPECT_THAT(code, testing::HasSubstr("#include <Bar.h>"));
3717 EXPECT_THAT(code, testing::HasSubstr("#include <Baz.h>"));
3718 EXPECT_THAT(code, testing::HasSubstr("#include <Qux.h>"));
3719}
3720
3721TEST_F(GenericAidlTest, ImportGenericParameterTypesNDK) {
3722 Compile("aidl Foo.aidl --lang=ndk -I . -o out -h out");
3723 string code;
3724 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/aidl/Foo.h", &code));
3725 EXPECT_THAT(code, testing::HasSubstr("#include <aidl/Bar.h>"));
3726 EXPECT_THAT(code, testing::HasSubstr("#include <aidl/Baz.h>"));
3727 EXPECT_THAT(code, testing::HasSubstr("#include <aidl/Qux.h>"));
3728}
3729
Devin Moore53fc99c2020-08-12 08:07:52 -07003730TEST_P(AidlTest, RejectGenericStructuredParcelabelRepeatedParam) {
3731 io_delegate_.SetFileContents("Foo.aidl", "parcelable Foo<T,T> { int a; int A; }");
3732 Options options =
3733 Options::From("aidl Foo.aidl --lang=" + Options::LanguageToString(GetLanguage()));
3734 const string expected_stderr =
3735 "ERROR: Foo.aidl:1.11-15: Every type parameter should be unique.\n";
3736 CaptureStderr();
3737 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3738 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3739}
3740
3741TEST_P(AidlTest, RejectGenericStructuredParcelableField) {
3742 io_delegate_.SetFileContents("Foo.aidl", "parcelable Foo<T,T> { T a; int A; }");
3743 Options options =
3744 Options::From("aidl Foo.aidl --lang=" + Options::LanguageToString(GetLanguage()));
3745 const string expected_stderr = "ERROR: Foo.aidl:1.22-24: Failed to resolve 'T'\n";
3746 CaptureStderr();
3747 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3748 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3749}
3750
Jooyung Han7a308842020-10-27 19:06:49 +09003751TEST_P(AidlTest, LongCommentWithinConstExpression) {
3752 io_delegate_.SetFileContents("Foo.aidl", "enum Foo { FOO = (1 << 1) /* comment */ | 0x0 }");
3753 Options options =
3754 Options::From("aidl Foo.aidl --lang=" + Options::LanguageToString(GetLanguage()));
3755 CaptureStderr();
3756 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3757 EXPECT_EQ("", GetCapturedStderr());
3758}
3759
Jeongik Chaef44e622020-10-23 16:00:52 +09003760TEST_F(AidlTest, RejectUntypdeListAndMapInUnion) {
3761 io_delegate_.SetFileContents("a/Foo.aidl", "package a; union Foo { List l; Map m; }");
3762 Options options = Options::From("aidl a/Foo.aidl --lang=java -o out");
3763 std::string expectedErr =
3764 "ERROR: a/Foo.aidl:1.28-30: "
3765 "Encountered an untyped List or Map. The use of untyped List/Map is "
3766 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
3767 "the receiving side. Consider switching to an array or a generic List/Map.\n"
3768 "ERROR: a/Foo.aidl:1.35-37: "
3769 "Encountered an untyped List or Map. The use of untyped List/Map is "
3770 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
3771 "the receiving side. Consider switching to an array or a generic List/Map.\n";
3772 CaptureStderr();
3773 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3774 EXPECT_EQ(expectedErr, GetCapturedStderr());
3775}
3776
3777TEST_F(AidlTest, RejectUntypdeListAndMapInUnstructuredParcelable) {
Jooyung Hanea2147c2020-10-21 18:16:56 +09003778 io_delegate_.SetFileContents("a/Foo.aidl", "package a; parcelable Foo { List l; Map m; }");
3779 Options options = Options::From("aidl a/Foo.aidl --lang=java -o out");
Jeongik Chaef44e622020-10-23 16:00:52 +09003780 std::string expectedErr =
3781 "ERROR: a/Foo.aidl:1.33-35: "
3782 "Encountered an untyped List or Map. The use of untyped List/Map is "
3783 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
3784 "the receiving side. Consider switching to an array or a generic List/Map.\n"
3785 "ERROR: a/Foo.aidl:1.40-42: "
3786 "Encountered an untyped List or Map. The use of untyped List/Map is "
3787 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
3788 "the receiving side. Consider switching to an array or a generic List/Map.\n";
Jooyung Hanea2147c2020-10-21 18:16:56 +09003789 CaptureStderr();
Jeongik Chaef44e622020-10-23 16:00:52 +09003790 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3791 EXPECT_EQ(expectedErr, GetCapturedStderr());
3792}
Jooyung Hanea2147c2020-10-21 18:16:56 +09003793
Jeongik Chaef44e622020-10-23 16:00:52 +09003794TEST_F(AidlTest, RejectNestedUntypedListAndMap) {
3795 io_delegate_.SetFileContents("a/Bar.aidl", "package a; parcelable Bar<T>;");
3796 io_delegate_.SetFileContents(
3797 "a/Foo.aidl", "package a; import a.Bar; parcelable Foo { Bar<List> a; Bar<Map> b; }");
3798 Options options = Options::From("aidl a/Foo.aidl -I . --lang=java -o out");
3799 std::string expectedErr =
3800 "ERROR: a/Foo.aidl:1.52-54: "
3801 "Encountered an untyped List or Map. The use of untyped List/Map is "
3802 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
3803 "the receiving side. Consider switching to an array or a generic List/Map.\n"
3804 "ERROR: a/Foo.aidl:1.64-66: "
3805 "Encountered an untyped List or Map. The use of untyped List/Map is "
3806 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
3807 "the receiving side. Consider switching to an array or a generic List/Map.\n";
3808 CaptureStderr();
3809 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3810 EXPECT_EQ(expectedErr, GetCapturedStderr());
Jooyung Hanea2147c2020-10-21 18:16:56 +09003811}
3812
Christopher Wiley90be4e32015-10-20 14:55:25 -07003813} // namespace aidl
3814} // namespace android