blob: 66df51e75b1fce88c837660c463a171023c2170d [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
Jooyung Hane87cdd02020-12-11 16:47:35 +090019#include <android-base/format.h>
Christopher Wileyec31a052016-01-25 07:28:51 -080020#include <android-base/stringprintf.h>
Jiyong Parkf1f5c802020-05-19 17:33:00 +090021#include <gmock/gmock.h>
Christopher Wiley90be4e32015-10-20 14:55:25 -070022#include <gtest/gtest.h>
23
Jooyung Han1f14ab32020-10-14 13:48:29 +090024#include <map>
25#include <memory>
26#include <set>
27#include <string>
28#include <vector>
29
Steven Moreland49585242019-12-18 16:06:49 -080030#include "aidl_checkapi.h"
Jooyung Han1f56b702021-02-11 13:16:15 +090031#include "aidl_dumpapi.h"
Christopher Wiley90be4e32015-10-20 14:55:25 -070032#include "aidl_language.h"
Steven Moreland860b1942018-08-16 14:59:28 -070033#include "aidl_to_cpp.h"
Jeongik Cha047c5ee2019-08-07 23:16:49 +090034#include "aidl_to_java.h"
Jooyung Han161bb0f2021-01-21 12:30:16 +090035#include "comments.h"
Jiyong Park2a7c92b2020-07-22 19:12:36 +090036#include "logging.h"
Jeongik Cha047c5ee2019-08-07 23:16:49 +090037#include "options.h"
Christopher Wiley90be4e32015-10-20 14:55:25 -070038#include "tests/fake_io_delegate.h"
Christopher Wiley90be4e32015-10-20 14:55:25 -070039
Jeongik Cha2a5b4d82019-08-06 19:37:59 +090040using android::aidl::internals::parse_preprocessed_file;
Christopher Wiley90be4e32015-10-20 14:55:25 -070041using android::aidl::test::FakeIoDelegate;
Christopher Wileyec31a052016-01-25 07:28:51 -080042using android::base::StringPrintf;
Jooyung Han1f14ab32020-10-14 13:48:29 +090043using std::map;
Christopher Wiley12e894a2016-01-29 11:55:07 -080044using std::set;
Christopher Wiley90be4e32015-10-20 14:55:25 -070045using std::string;
46using std::unique_ptr;
Christopher Wiley12e894a2016-01-29 11:55:07 -080047using std::vector;
Jooyung Hanf8dbbcc2020-12-26 03:05:55 +090048using testing::HasSubstr;
Devin Moore7b8d5c92020-03-17 14:14:08 -070049using testing::TestParamInfo;
Jeongik Cha2a5b4d82019-08-06 19:37:59 +090050using testing::internal::CaptureStderr;
51using testing::internal::GetCapturedStderr;
Christopher Wiley90be4e32015-10-20 14:55:25 -070052
53namespace android {
54namespace aidl {
Christopher Wileyf8136192016-04-12 14:19:35 -070055namespace {
56
57const char kExpectedDepFileContents[] =
58R"(place/for/output/p/IFoo.java : \
59 p/IFoo.aidl
60
61p/IFoo.aidl :
62)";
63
Dan Willemsen93298ee2016-11-10 23:55:55 -080064const char kExpectedNinjaDepFileContents[] =
65R"(place/for/output/p/IFoo.java : \
66 p/IFoo.aidl
67)";
68
Jiyong Parkdf202122019-09-30 20:48:35 +090069const char kExpectedParcelableDeclarationDepFileContents[] =
70 R"( : \
71 p/Foo.aidl
72
73p/Foo.aidl :
74)";
75
76const char kExpectedStructuredParcelableDepFileContents[] =
Steven Moreland2a9a7d62019-02-05 16:11:54 -080077 R"(place/for/output/p/Foo.java : \
Christopher Wileyb1bbdf82016-04-21 11:43:45 -070078 p/Foo.aidl
79
80p/Foo.aidl :
81)";
82
Christopher Wileyf8136192016-04-12 14:19:35 -070083} // namespace
Christopher Wiley90be4e32015-10-20 14:55:25 -070084
Devin Moore7b8d5c92020-03-17 14:14:08 -070085class AidlTest : public ::testing::TestWithParam<Options::Language> {
Christopher Wiley90be4e32015-10-20 14:55:25 -070086 protected:
Jeongik Cha047c5ee2019-08-07 23:16:49 +090087 AidlDefinedType* Parse(const string& path, const string& contents, AidlTypenames& typenames_,
88 Options::Language lang, AidlError* error = nullptr,
Steven Moreland1eac5fa2018-08-27 19:35:05 -070089 const vector<string> additional_arguments = {}) {
Christopher Wiley0522cd52015-10-28 15:39:44 -070090 io_delegate_.SetFileContents(path, contents);
Jiyong Parkfbbfa932018-07-30 21:44:10 +090091 vector<string> args;
Devin Moore7b8d5c92020-03-17 14:14:08 -070092 args.emplace_back("aidl");
Jooyung Han9435e9a2021-01-06 10:16:31 +090093 args.emplace_back("--lang=" + to_string(lang));
Steven Moreland1eac5fa2018-08-27 19:35:05 -070094 for (const string& s : additional_arguments) {
95 args.emplace_back(s);
96 }
97 for (const string& f : preprocessed_files_) {
Jiyong Parkfbbfa932018-07-30 21:44:10 +090098 args.emplace_back("--preprocessed=" + f);
99 }
Steven Moreland1eac5fa2018-08-27 19:35:05 -0700100 for (const string& i : import_paths_) {
Jiyong Parkfbbfa932018-07-30 21:44:10 +0900101 args.emplace_back("--include=" + i);
102 }
103 args.emplace_back(path);
104 Options options = Options::From(args);
Jiyong Parkb034bf02018-07-30 17:44:33 +0900105 vector<string> imported_files;
Jiyong Park8c380532018-08-30 14:55:26 +0900106 ImportResolver import_resolver{io_delegate_, path, import_paths_, {}};
Christopher Wiley69b44cf2016-05-03 13:43:33 -0700107 AidlError actual_error = ::android::aidl::internals::load_and_validate_aidl(
Jiyong Park8e79b7f2020-07-20 20:52:38 +0900108 path, options, io_delegate_, &typenames_, &imported_files);
Jiyong Parkb034bf02018-07-30 17:44:33 +0900109
Christopher Wiley69b44cf2016-05-03 13:43:33 -0700110 if (error != nullptr) {
111 *error = actual_error;
112 }
Jiyong Parkb034bf02018-07-30 17:44:33 +0900113
114 if (actual_error != AidlError::OK) {
115 return nullptr;
116 }
117
Jiyong Park8e79b7f2020-07-20 20:52:38 +0900118 const auto& defined_types = typenames_.MainDocument().DefinedTypes();
Jiyong Parkb034bf02018-07-30 17:44:33 +0900119 EXPECT_EQ(1ul, defined_types.size());
120
Jiyong Park8e79b7f2020-07-20 20:52:38 +0900121 return defined_types.front().get();
Christopher Wiley90be4e32015-10-20 14:55:25 -0700122 }
Christopher Wiley0522cd52015-10-28 15:39:44 -0700123
Devin Moore7b8d5c92020-03-17 14:14:08 -0700124 Options::Language GetLanguage() { return GetParam(); }
125
Christopher Wiley0522cd52015-10-28 15:39:44 -0700126 FakeIoDelegate io_delegate_;
Christopher Wiley41544372015-11-03 14:52:29 -0800127 vector<string> preprocessed_files_;
Jiyong Park8c380532018-08-30 14:55:26 +0900128 set<string> import_paths_;
Jeongik Cha047c5ee2019-08-07 23:16:49 +0900129 AidlTypenames typenames_;
Christopher Wiley90be4e32015-10-20 14:55:25 -0700130};
131
Devin Moore7b8d5c92020-03-17 14:14:08 -0700132// Instantiate the AidlTest parameterized suite, calling all of the TEST_P
133// tests with each of the supported languages as a parameter.
134INSTANTIATE_TEST_SUITE_P(AidlTestSuite, AidlTest,
135 testing::Values(Options::Language::CPP, Options::Language::JAVA,
Andrei Homescub62afd92020-05-11 19:24:59 -0700136 Options::Language::NDK, Options::Language::RUST),
Devin Moore7b8d5c92020-03-17 14:14:08 -0700137 [](const testing::TestParamInfo<Options::Language>& info) {
Jooyung Han9435e9a2021-01-06 10:16:31 +0900138 return to_string(info.param);
Devin Moore7b8d5c92020-03-17 14:14:08 -0700139 });
140
141TEST_P(AidlTest, AcceptMissingPackage) {
142 EXPECT_NE(nullptr, Parse("IFoo.aidl", "interface IFoo { }", typenames_, GetLanguage()));
Christopher Wiley90be4e32015-10-20 14:55:25 -0700143}
144
Devin Moore7b8d5c92020-03-17 14:14:08 -0700145TEST_P(AidlTest, EndsInSingleLineComment) {
146 EXPECT_NE(nullptr, Parse("IFoo.aidl", "interface IFoo { } // foo", typenames_, GetLanguage()));
Steven Moreland9c2988f2019-07-17 17:49:10 -0700147}
148
Steven Morelandebc3c5d2020-09-30 23:40:33 +0000149TEST_P(AidlTest, InterfaceRequiresCorrectPath) {
150 const string expected_stderr =
151 "ERROR: a/Foo.aidl:1.11-21: IBar should be declared in a file called a/IBar.aidl\n";
152 const std::string file_contents = "package a; interface IBar {}";
153 CaptureStderr();
154 EXPECT_EQ(nullptr, Parse("a/Foo.aidl", file_contents, typenames_, GetLanguage()));
155 EXPECT_EQ(expected_stderr, GetCapturedStderr()) << file_contents;
156}
157
158TEST_P(AidlTest, ParcelableRequiresCorrectPath) {
159 const string expected_stderr =
160 "ERROR: a/Foo.aidl:1.11-21: Bar should be declared in a file called a/Bar.aidl\n";
161 const std::string file_contents = "package a; interface Bar {}";
162 CaptureStderr();
163 EXPECT_EQ(nullptr, Parse("a/Foo.aidl", file_contents, typenames_, GetLanguage()));
164 EXPECT_EQ(expected_stderr, GetCapturedStderr()) << file_contents;
165}
166
167TEST_P(AidlTest, UnstructuredParcelableRequiresCorrectPath) {
168 const string expected_stderr =
169 "ERROR: a/Foo.aidl:1.22-26: Bar should be declared in a file called a/Bar.aidl\n";
170 const std::string file_contents = "package a; parcelable Bar cpp_header \"anything.h\";";
171 CaptureStderr();
172 EXPECT_EQ(nullptr, Parse("a/Foo.aidl", file_contents, typenames_, GetLanguage()));
173 EXPECT_EQ(expected_stderr, GetCapturedStderr()) << file_contents;
174}
175
176TEST_P(AidlTest, EnumRequiresCorrectPath) {
177 const string expected_stderr =
178 "ERROR: a/Foo.aidl:1.16-20: Bar should be declared in a file called a/Bar.aidl\n";
179 const std::string file_contents = "package a; enum Bar { A, }";
180 CaptureStderr();
181 EXPECT_EQ(nullptr, Parse("a/Foo.aidl", file_contents, typenames_, GetLanguage()));
182 EXPECT_EQ(expected_stderr, GetCapturedStderr()) << file_contents;
183}
184
Devin Moore7b8d5c92020-03-17 14:14:08 -0700185TEST_P(AidlTest, RejectsArraysOfBinders) {
Jiyong Park8c380532018-08-30 14:55:26 +0900186 import_paths_.emplace("");
Christopher Wiley0522cd52015-10-28 15:39:44 -0700187 io_delegate_.SetFileContents("bar/IBar.aidl",
188 "package bar; interface IBar {}");
Devin Moore097a3ab2020-03-11 16:08:44 -0700189 const string path = "foo/IFoo.aidl";
190 const string contents =
191 "package foo;\n"
192 "import bar.IBar;\n"
193 "interface IFoo { void f(in IBar[] input); }";
194 const string expected_stderr = "ERROR: foo/IFoo.aidl:3.27-32: Binder type cannot be an array\n";
195 CaptureStderr();
Devin Moore7b8d5c92020-03-17 14:14:08 -0700196 EXPECT_EQ(nullptr, Parse(path, contents, typenames_, GetLanguage()));
Devin Moore097a3ab2020-03-11 16:08:44 -0700197 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Christopher Wiley0522cd52015-10-28 15:39:44 -0700198}
199
Devin Moore7b8d5c92020-03-17 14:14:08 -0700200TEST_P(AidlTest, SupportOnlyOutParameters) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700201 const string interface_list = "package a; interface IBar { void f(out List<String> bar); }";
Devin Moore7b8d5c92020-03-17 14:14:08 -0700202 EXPECT_NE(nullptr, Parse("a/IBar.aidl", interface_list, typenames_, GetLanguage()));
Jiyong Park40782d02020-07-24 19:17:43 +0900203}
Devin Moore097a3ab2020-03-11 16:08:44 -0700204
Jiyong Park40782d02020-07-24 19:17:43 +0900205TEST_P(AidlTest, RejectOutParametersForIBinder) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700206 const string interface_ibinder = "package a; interface IBaz { void f(out IBinder bar); }";
207 const string expected_ibinder_stderr =
Jooyung Han15fd6c62020-10-23 13:54:46 +0900208 "ERROR: a/IBaz.aidl:1.47-51: 'bar' can't be an out parameter because IBinder can only be an "
209 "in parameter.\n";
Devin Moore097a3ab2020-03-11 16:08:44 -0700210 CaptureStderr();
Devin Moore7b8d5c92020-03-17 14:14:08 -0700211 EXPECT_EQ(nullptr, Parse("a/IBaz.aidl", interface_ibinder, typenames_, GetLanguage()));
Devin Moore097a3ab2020-03-11 16:08:44 -0700212 EXPECT_EQ(expected_ibinder_stderr, GetCapturedStderr());
Jeongik Chaa2080bf2019-06-18 16:44:29 +0900213}
214
Jiyong Park40782d02020-07-24 19:17:43 +0900215TEST_P(AidlTest, RejectsOutParametersInOnewayInterface) {
Jooyung Han020d8d12021-02-26 17:23:02 +0900216 const string oneway_interface = "package a; oneway interface IBar { void f(out int[] bar); }";
Devin Moore097a3ab2020-03-11 16:08:44 -0700217 const string expected_stderr =
218 "ERROR: a/IBar.aidl:1.40-42: oneway method 'f' cannot have out parameters\n";
Devin Moore7b8d5c92020-03-17 14:14:08 -0700219 CaptureStderr();
220 EXPECT_EQ(nullptr, Parse("a/IBar.aidl", oneway_interface, typenames_, GetLanguage()));
221 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Park40782d02020-07-24 19:17:43 +0900222}
Devin Moore7b8d5c92020-03-17 14:14:08 -0700223
Jiyong Park40782d02020-07-24 19:17:43 +0900224TEST_P(AidlTest, RejectsOutParametersInOnewayMethod) {
Jooyung Han020d8d12021-02-26 17:23:02 +0900225 const string oneway_method = "package a; interface IBar { oneway void f(out int[] bar); }";
Jiyong Park40782d02020-07-24 19:17:43 +0900226 const string expected_stderr =
227 "ERROR: a/IBar.aidl:1.40-42: oneway method 'f' cannot have out parameters\n";
Devin Moore097a3ab2020-03-11 16:08:44 -0700228 CaptureStderr();
Devin Moore7b8d5c92020-03-17 14:14:08 -0700229 EXPECT_EQ(nullptr, Parse("a/IBar.aidl", oneway_method, typenames_, GetLanguage()));
Devin Moore097a3ab2020-03-11 16:08:44 -0700230 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Christopher Wiley90be4e32015-10-20 14:55:25 -0700231}
232
Devin Moore7b8d5c92020-03-17 14:14:08 -0700233TEST_P(AidlTest, RejectsOnewayNonVoidReturn) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700234 const string oneway_method = "package a; interface IFoo { oneway int f(); }";
235 const string expected_stderr =
236 "ERROR: a/IFoo.aidl:1.39-41: oneway method 'f' cannot return a value\n";
237 CaptureStderr();
Devin Moore7b8d5c92020-03-17 14:14:08 -0700238 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", oneway_method, typenames_, GetLanguage()));
Devin Moore097a3ab2020-03-11 16:08:44 -0700239 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Christopher Wiley90be4e32015-10-20 14:55:25 -0700240}
241
Devin Moore7b8d5c92020-03-17 14:14:08 -0700242TEST_P(AidlTest, RejectsNullablePrimitive) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700243 const string oneway_method = "package a; interface IFoo { @nullable int f(); }";
244 const string expected_stderr =
245 "ERROR: a/IFoo.aidl:1.38-42: Primitive type cannot get nullable annotation\n";
246 CaptureStderr();
Devin Moore7b8d5c92020-03-17 14:14:08 -0700247 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", oneway_method, typenames_, GetLanguage()));
Devin Moore097a3ab2020-03-11 16:08:44 -0700248 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Casey Dahlin57dbe242015-12-04 11:44:02 -0800249}
250
Devin Moore2f2077a2020-08-28 11:27:53 -0700251TEST_P(AidlTest, AcceptNullableList) {
252 const string oneway_method = "package a; interface IFoo { @nullable List<String> f(); }";
253 const string expected_stderr = "";
254 CaptureStderr();
255 EXPECT_NE(nullptr, Parse("a/IFoo.aidl", oneway_method, typenames_, GetLanguage()));
256 EXPECT_EQ(expected_stderr, GetCapturedStderr());
257}
258
Devin Moore7b8d5c92020-03-17 14:14:08 -0700259TEST_P(AidlTest, RejectsDuplicatedArgumentNames) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700260 const string method = "package a; interface IFoo { void f(int a, int a); }";
261 const string expected_stderr =
262 "ERROR: a/IFoo.aidl:1.33-35: method 'f' has duplicate argument name 'a'\n";
263 CaptureStderr();
Devin Moore7b8d5c92020-03-17 14:14:08 -0700264 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", method, typenames_, GetLanguage()));
Devin Moore097a3ab2020-03-11 16:08:44 -0700265 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Steven Morelandb3cd3c72018-10-11 12:37:45 -0700266}
267
Jeongik Cha13066da2020-08-06 15:43:19 +0900268TEST_P(AidlTest, RejectsDuplicatedFieldNames) {
269 const string method = "package a; parcelable Foo { int a; String a; }";
Jooyung Han59af9cc2020-10-25 21:44:14 +0900270 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 +0900271 CaptureStderr();
272 EXPECT_EQ(nullptr, Parse("a/Foo.aidl", method, typenames_, GetLanguage()));
273 EXPECT_EQ(expected_stderr, GetCapturedStderr());
274}
275
Jooyung Hand902a972020-10-23 17:32:44 +0900276TEST_P(AidlTest, RejectsRepeatedAnnotations) {
277 const string method = R"(@Hide @Hide parcelable Foo {})";
278 const string expected_stderr =
279 "ERROR: Foo.aidl:1.23-27: 'Hide' is repeated, but not allowed. Previous location: "
280 "Foo.aidl:1.1-6\n";
281 CaptureStderr();
282 EXPECT_EQ(nullptr, Parse("Foo.aidl", method, typenames_, GetLanguage()));
283 EXPECT_EQ(expected_stderr, GetCapturedStderr());
284}
285
Jooyung Han05bd8a82021-04-28 23:56:38 +0900286TEST_P(AidlTest, AcceptsEmptyParcelable) {
287 CaptureStderr();
288 EXPECT_NE(nullptr, Parse("Foo.aidl", "parcelable Foo {}", typenames_, GetLanguage()));
289 EXPECT_EQ("", GetCapturedStderr());
290}
291
Devin Moore7b8d5c92020-03-17 14:14:08 -0700292TEST_P(AidlTest, RejectsDuplicatedAnnotationParams) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700293 const string method = "package a; interface IFoo { @UnsupportedAppUsage(foo=1, foo=2)void f(); }";
294 const string expected_stderr = "ERROR: a/IFoo.aidl:1.56-62: Trying to redefine parameter foo.\n";
295 CaptureStderr();
Devin Moore7b8d5c92020-03-17 14:14:08 -0700296 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", method, typenames_, GetLanguage()));
Devin Moore097a3ab2020-03-11 16:08:44 -0700297 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Andrei Onea9445fc62019-06-27 18:11:59 +0100298}
299
Devin Moore7b8d5c92020-03-17 14:14:08 -0700300TEST_P(AidlTest, RejectUnsupportedInterfaceAnnotations) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700301 AidlError error;
302 const string method = "package a; @nullable interface IFoo { int f(); }";
Devin Moorec054bf82020-03-10 16:31:48 -0700303 CaptureStderr();
Devin Moore7b8d5c92020-03-17 14:14:08 -0700304 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", method, typenames_, GetLanguage(), &error));
Jooyung Han2d6b5c42021-01-09 01:01:06 +0900305 EXPECT_THAT(GetCapturedStderr(), HasSubstr("@nullable is not available."));
Devin Moorec054bf82020-03-10 16:31:48 -0700306 EXPECT_EQ(AidlError::BAD_TYPE, error);
Devin Moore24f68572020-02-26 13:20:59 -0800307}
308
Devin Moore7b8d5c92020-03-17 14:14:08 -0700309TEST_P(AidlTest, RejectUnsupportedTypeAnnotations) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700310 AidlError error;
311 const string method = "package a; interface IFoo { @JavaOnlyStableParcelable int f(); }";
Devin Moorec054bf82020-03-10 16:31:48 -0700312 CaptureStderr();
Devin Moore7b8d5c92020-03-17 14:14:08 -0700313 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", method, typenames_, GetLanguage(), &error));
Jooyung Han2d6b5c42021-01-09 01:01:06 +0900314 EXPECT_THAT(GetCapturedStderr(), HasSubstr("@JavaOnlyStableParcelable is not available."));
Devin Moorec054bf82020-03-10 16:31:48 -0700315 EXPECT_EQ(AidlError::BAD_TYPE, error);
Devin Moore24f68572020-02-26 13:20:59 -0800316}
317
Devin Moore7b8d5c92020-03-17 14:14:08 -0700318TEST_P(AidlTest, RejectUnsupportedParcelableAnnotations) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700319 AidlError error;
320 const string method = "package a; @nullable parcelable IFoo cpp_header \"IFoo.h\";";
Devin Moorec054bf82020-03-10 16:31:48 -0700321 CaptureStderr();
Steven Morelandebc3c5d2020-09-30 23:40:33 +0000322 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", method, typenames_, GetLanguage(), &error));
Jooyung Han2d6b5c42021-01-09 01:01:06 +0900323 EXPECT_THAT(GetCapturedStderr(), HasSubstr("@nullable is not available."));
Devin Moorec054bf82020-03-10 16:31:48 -0700324 EXPECT_EQ(AidlError::BAD_TYPE, error);
Devin Moore24f68572020-02-26 13:20:59 -0800325}
326
Devin Moore7b8d5c92020-03-17 14:14:08 -0700327TEST_P(AidlTest, RejectUnsupportedParcelableDefineAnnotations) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700328 AidlError error;
Steven Morelandebc3c5d2020-09-30 23:40:33 +0000329 const string method = "package a; @nullable parcelable IFoo { String a; String b; }";
Devin Moorec054bf82020-03-10 16:31:48 -0700330 CaptureStderr();
Steven Morelandebc3c5d2020-09-30 23:40:33 +0000331 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", method, typenames_, GetLanguage(), &error));
Jooyung Han2d6b5c42021-01-09 01:01:06 +0900332 EXPECT_THAT(GetCapturedStderr(), HasSubstr("@nullable is not available."));
Devin Moorec054bf82020-03-10 16:31:48 -0700333 EXPECT_EQ(AidlError::BAD_TYPE, error);
Devin Moore24f68572020-02-26 13:20:59 -0800334}
335
Jiyong Park40782d02020-07-24 19:17:43 +0900336TEST_P(AidlTest, ParsesNonNullableAnnotation) {
337 auto parse_result =
338 Parse("a/IFoo.aidl", "package a; interface IFoo { String f(); }", typenames_, GetLanguage());
339 ASSERT_NE(nullptr, parse_result);
340 const AidlInterface* interface = parse_result->AsInterface();
341 ASSERT_NE(nullptr, interface);
342 ASSERT_FALSE(interface->GetMethods().empty());
343 EXPECT_FALSE(interface->GetMethods()[0]->GetType().IsNullable());
344}
345
Devin Moore7b8d5c92020-03-17 14:14:08 -0700346TEST_P(AidlTest, ParsesNullableAnnotation) {
Jiyong Park40782d02020-07-24 19:17:43 +0900347 auto parse_result = Parse("a/IFoo.aidl", "package a; interface IFoo { @nullable String f(); }",
348 typenames_, GetLanguage());
349 ASSERT_NE(nullptr, parse_result);
350 const AidlInterface* interface = parse_result->AsInterface();
351 ASSERT_NE(nullptr, interface);
352 ASSERT_FALSE(interface->GetMethods().empty());
353 EXPECT_TRUE(interface->GetMethods()[0]->GetType().IsNullable());
354}
355
356TEST_P(AidlTest, ParsesNonUtf8Annotations) {
357 auto parse_result =
358 Parse("a/IFoo.aidl", "package a; interface IFoo { String f(); }", typenames_, GetLanguage());
359 ASSERT_NE(nullptr, parse_result);
360 const AidlInterface* interface = parse_result->AsInterface();
361 ASSERT_NE(nullptr, interface);
362 ASSERT_FALSE(interface->GetMethods().empty());
363 EXPECT_FALSE(interface->GetMethods()[0]->GetType().IsUtf8InCpp());
Christopher Wileyec31a052016-01-25 07:28:51 -0800364}
365
Devin Moore7b8d5c92020-03-17 14:14:08 -0700366TEST_P(AidlTest, ParsesUtf8Annotations) {
Jiyong Park40782d02020-07-24 19:17:43 +0900367 auto parse_result = Parse("a/IFoo.aidl", "package a; interface IFoo { @utf8InCpp String f(); }",
368 typenames_, GetLanguage());
369 ASSERT_NE(nullptr, parse_result);
370 const AidlInterface* interface = parse_result->AsInterface();
371 ASSERT_NE(nullptr, interface);
372 ASSERT_FALSE(interface->GetMethods().empty());
373 EXPECT_TRUE(interface->GetMethods()[0]->GetType().IsUtf8InCpp());
Christopher Wileyec31a052016-01-25 07:28:51 -0800374}
375
Devin Moore7b8d5c92020-03-17 14:14:08 -0700376TEST_P(AidlTest, VintfRequiresStructuredAndStability) {
Steven Morelanda57d0a62019-07-30 09:41:14 -0700377 AidlError error;
Devin Moore0d0e3f62020-03-30 17:45:39 -0700378 const string expected_stderr =
379 "ERROR: IFoo.aidl:1.16-26: Must compile @VintfStability type w/ aidl_interface 'stability: "
380 "\"vintf\"'\n"
381 "ERROR: IFoo.aidl:1.16-26: Must compile @VintfStability type w/ aidl_interface "
382 "--structured\n";
383 CaptureStderr();
Devin Moore097a3ab2020-03-11 16:08:44 -0700384 ASSERT_EQ(nullptr, Parse("IFoo.aidl", "@VintfStability interface IFoo {}", typenames_,
Devin Moore7b8d5c92020-03-17 14:14:08 -0700385 GetLanguage(), &error));
Devin Moore0d0e3f62020-03-30 17:45:39 -0700386 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Steven Morelanda57d0a62019-07-30 09:41:14 -0700387 ASSERT_EQ(AidlError::NOT_STRUCTURED, error);
Steven Morelanda57d0a62019-07-30 09:41:14 -0700388}
389
Devin Moore7b8d5c92020-03-17 14:14:08 -0700390TEST_P(AidlTest, VintfRequiresStructured) {
Steven Morelanda57d0a62019-07-30 09:41:14 -0700391 AidlError error;
Devin Moore0d0e3f62020-03-30 17:45:39 -0700392 const string expected_stderr =
393 "ERROR: IFoo.aidl:1.16-26: Must compile @VintfStability type w/ aidl_interface "
394 "--structured\n";
395 CaptureStderr();
Devin Moore097a3ab2020-03-11 16:08:44 -0700396 ASSERT_EQ(nullptr, Parse("IFoo.aidl", "@VintfStability interface IFoo {}", typenames_,
Devin Moore7b8d5c92020-03-17 14:14:08 -0700397 GetLanguage(), &error, {"--stability", "vintf"}));
Devin Moore0d0e3f62020-03-30 17:45:39 -0700398 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Steven Morelanda57d0a62019-07-30 09:41:14 -0700399 ASSERT_EQ(AidlError::NOT_STRUCTURED, error);
Steven Morelanda57d0a62019-07-30 09:41:14 -0700400}
401
Devin Moore7b8d5c92020-03-17 14:14:08 -0700402TEST_P(AidlTest, VintfRequiresSpecifiedStability) {
Steven Morelanda57d0a62019-07-30 09:41:14 -0700403 AidlError error;
Devin Moore097a3ab2020-03-11 16:08:44 -0700404 const string expected_stderr =
405 "ERROR: IFoo.aidl:1.16-26: Must compile @VintfStability type w/ aidl_interface 'stability: "
406 "\"vintf\"'\n";
407 CaptureStderr();
408 ASSERT_EQ(nullptr, Parse("IFoo.aidl", "@VintfStability interface IFoo {}", typenames_,
Devin Moore7b8d5c92020-03-17 14:14:08 -0700409 GetLanguage(), &error, {"--structured"}));
Devin Moore097a3ab2020-03-11 16:08:44 -0700410 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Steven Morelanda57d0a62019-07-30 09:41:14 -0700411 ASSERT_EQ(AidlError::NOT_STRUCTURED, error);
Steven Morelanda57d0a62019-07-30 09:41:14 -0700412}
413
Devin Moore7b8d5c92020-03-17 14:14:08 -0700414TEST_P(AidlTest, ParsesStabilityAnnotations) {
Steven Morelanda57d0a62019-07-30 09:41:14 -0700415 AidlError error;
Devin Moore7b8d5c92020-03-17 14:14:08 -0700416 auto parse_result = Parse("IFoo.aidl", "@VintfStability interface IFoo {}", typenames_,
417 GetLanguage(), &error, {"--structured", "--stability", "vintf"});
Steven Morelanda57d0a62019-07-30 09:41:14 -0700418 ASSERT_EQ(AidlError::OK, error);
419 ASSERT_NE(nullptr, parse_result);
420 const AidlInterface* interface = parse_result->AsInterface();
421 ASSERT_NE(nullptr, interface);
422 ASSERT_TRUE(interface->IsVintfStability());
Steven Morelanda57d0a62019-07-30 09:41:14 -0700423}
424
Jeongik Cha64783ed2019-06-07 18:30:54 +0900425TEST_F(AidlTest, ParsesJavaOnlyStableParcelable) {
426 Options java_options = Options::From("aidl -o out --structured a/Foo.aidl");
Jeongik Cha88f95a82020-01-15 13:02:16 +0900427 Options cpp_options = Options::From("aidl --lang=cpp -o out -h out/include a/Foo.aidl");
428 Options cpp_structured_options =
Jeongik Cha64783ed2019-06-07 18:30:54 +0900429 Options::From("aidl --lang=cpp --structured -o out -h out/include a/Foo.aidl");
Andrei Homescub62afd92020-05-11 19:24:59 -0700430 Options rust_options = Options::From("aidl --lang=rust -o out --structured a/Foo.aidl");
Jeongik Cha64783ed2019-06-07 18:30:54 +0900431 io_delegate_.SetFileContents(
Jeongik Cha88f95a82020-01-15 13:02:16 +0900432 "a/Foo.aidl",
433 StringPrintf("package a; @JavaOnlyStableParcelable parcelable Foo cpp_header \"Foo.h\" ;"));
Jeongik Cha64783ed2019-06-07 18:30:54 +0900434
435 EXPECT_EQ(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
Jeongik Cha88f95a82020-01-15 13:02:16 +0900436 EXPECT_EQ(0, ::android::aidl::compile_aidl(cpp_options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -0700437 const string expected_stderr =
Jeongik Cha88f95a82020-01-15 13:02:16 +0900438 "ERROR: a/Foo.aidl:1.48-52: Cannot declared parcelable in a --structured interface. "
Devin Moorec054bf82020-03-10 16:31:48 -0700439 "Parcelable must be defined in AIDL directly.\n";
440 CaptureStderr();
Jeongik Cha88f95a82020-01-15 13:02:16 +0900441 EXPECT_NE(0, ::android::aidl::compile_aidl(cpp_structured_options, io_delegate_));
Devin Moorec054bf82020-03-10 16:31:48 -0700442 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Andrei Homescub62afd92020-05-11 19:24:59 -0700443
444 CaptureStderr();
445 EXPECT_NE(0, ::android::aidl::compile_aidl(rust_options, io_delegate_));
446 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jeongik Cha64783ed2019-06-07 18:30:54 +0900447}
448
Jooyung Han1cbc4962020-10-25 10:07:15 +0900449TEST_F(AidlTest, ParcelableSupportJavaDeriveToString) {
450 io_delegate_.SetFileContents("a/Foo.aidl", R"(package a;
451 @JavaDerive(toString=true) parcelable Foo { int a; float b; })");
452 Options java_options = Options::From("aidl --lang=java -o out a/Foo.aidl");
Jiyong Park43113fb2020-07-20 16:26:19 +0900453 EXPECT_EQ(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
454
455 string java_out;
Jooyung Han1cbc4962020-10-25 10:07:15 +0900456 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/Foo.java", &java_out));
Jiyong Park43113fb2020-07-20 16:26:19 +0900457 EXPECT_THAT(java_out, testing::HasSubstr("public String toString() {"));
458
459 // Other backends shouldn't be bothered
Jooyung Han1cbc4962020-10-25 10:07:15 +0900460 Options cpp_options = Options::From("aidl --lang=cpp -o out -h out a/Foo.aidl");
Jiyong Park43113fb2020-07-20 16:26:19 +0900461 EXPECT_EQ(0, ::android::aidl::compile_aidl(cpp_options, io_delegate_));
462
Jooyung Han1cbc4962020-10-25 10:07:15 +0900463 Options ndk_options = Options::From("aidl --lang=ndk -o out -h out a/Foo.aidl");
Jiyong Park43113fb2020-07-20 16:26:19 +0900464 EXPECT_EQ(0, ::android::aidl::compile_aidl(ndk_options, io_delegate_));
465}
466
Jooyung Han1cbc4962020-10-25 10:07:15 +0900467TEST_F(AidlTest, UnionSupportJavaDeriveToString) {
468 io_delegate_.SetFileContents("a/Foo.aidl", R"(package a;
469 @JavaDerive(toString=true) union Foo { int a; int[] b; })");
470 CaptureStderr();
471 Options java_options = Options::From("aidl --lang=java -o out a/Foo.aidl");
472 EXPECT_EQ(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
473 EXPECT_EQ("", GetCapturedStderr());
474
475 const string expected_to_string_method = R"--(
476 @Override
477 public String toString() {
478 switch (_tag) {
479 case a: return "a.Foo.a(" + (getA()) + ")";
480 case b: return "a.Foo.b(" + (java.util.Arrays.toString(getB())) + ")";
481 }
482 throw new IllegalStateException("unknown field: " + _tag);
483 }
484)--";
485
486 string java_out;
487 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/Foo.java", &java_out));
488 EXPECT_THAT(java_out, testing::HasSubstr(expected_to_string_method));
489}
490
Jiyong Park9aa3d042020-12-04 23:30:02 +0900491TEST_F(AidlTest, ParcelableSupportJavaDeriveEquals) {
492 io_delegate_.SetFileContents("a/Foo.aidl", R"(package a;
493 @JavaDerive(equals=true) parcelable Foo { int a; float b; })");
494 CaptureStderr();
495 Options java_options = Options::From("aidl --lang=java -o out a/Foo.aidl");
496 EXPECT_EQ(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
497 EXPECT_EQ("", GetCapturedStderr());
498
499 const std::string expected = R"--(
500 @Override
501 public boolean equals(Object other) {
502 if (this == other) return true;
503 if (other == null) return false;
504 if (!(other instanceof Foo)) return false;
505 Foo that = (Foo)other;
506 if (!java.util.Objects.deepEquals(a, that.a)) return false;
507 if (!java.util.Objects.deepEquals(b, that.b)) return false;
508 return true;
509 }
510
511 @Override
512 public int hashCode() {
513 return java.util.Arrays.deepHashCode(java.util.Arrays.asList(a, b).toArray());
514 }
515)--";
516
517 string java_out;
518 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/Foo.java", &java_out));
519 EXPECT_THAT(java_out, testing::HasSubstr(expected));
520}
521
522TEST_F(AidlTest, UnionSupportJavaDeriveEquals) {
523 io_delegate_.SetFileContents("a/Foo.aidl", R"(package a;
524 @JavaDerive(equals=true) union Foo { int a; int[] b; })");
525 CaptureStderr();
526 Options java_options = Options::From("aidl --lang=java -o out a/Foo.aidl");
527 EXPECT_EQ(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
528 EXPECT_EQ("", GetCapturedStderr());
529
530 const std::string expected = R"--(
531 @Override
532 public boolean equals(Object other) {
533 if (this == other) return true;
534 if (other == null) return false;
535 if (!(other instanceof Foo)) return false;
536 Foo that = (Foo)other;
537 if (_tag != that._tag) return false;
538 if (!java.util.Objects.deepEquals(_value, that._value)) return false;
539 return true;
540 }
541
542 @Override
543 public int hashCode() {
544 return java.util.Arrays.deepHashCode(java.util.Arrays.asList(_tag, _value).toArray());
545 }
546)--";
547
548 string java_out;
549 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/Foo.java", &java_out));
550 EXPECT_THAT(java_out, testing::HasSubstr(expected));
551}
552
Jooyung Han90345002020-10-23 15:28:53 +0900553TEST_F(AidlTest, RejectsJavaDeriveAnnotation) {
Jiyong Park43113fb2020-07-20 16:26:19 +0900554 {
Jooyung Han90345002020-10-23 15:28:53 +0900555 io_delegate_.SetFileContents("a/Foo.aidl",
556 "package a; @JavaDerive(blah=true) parcelable Foo{}");
557 Options java_options = Options::From("aidl --lang=java -o out a/Foo.aidl");
558 CaptureStderr();
559 EXPECT_NE(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
560 const std::string expected_stderr =
561 "ERROR: a/Foo.aidl:1.11-34: Parameter blah not supported for annotation JavaDerive.";
Jooyung Hanf8dbbcc2020-12-26 03:05:55 +0900562 EXPECT_THAT(GetCapturedStderr(),
563 HasSubstr("Parameter blah not supported for annotation JavaDerive."));
Jooyung Han90345002020-10-23 15:28:53 +0900564 }
565
566 {
567 io_delegate_.SetFileContents("a/IFoo.aidl", "package a; @JavaDerive interface IFoo{}");
Jiyong Park43113fb2020-07-20 16:26:19 +0900568 Options java_options = Options::From("aidl --lang=java -o out a/IFoo.aidl");
569 CaptureStderr();
570 EXPECT_NE(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
Jooyung Han2d6b5c42021-01-09 01:01:06 +0900571 EXPECT_THAT(GetCapturedStderr(), HasSubstr("@JavaDerive is not available."));
Jiyong Park43113fb2020-07-20 16:26:19 +0900572 }
573
574 {
Jooyung Han90345002020-10-23 15:28:53 +0900575 io_delegate_.SetFileContents("a/IFoo.aidl", "package a; @JavaDerive enum IFoo { A=1, }");
Jiyong Park43113fb2020-07-20 16:26:19 +0900576 Options java_options = Options::From("aidl --lang=java -o out a/IFoo.aidl");
577 CaptureStderr();
578 EXPECT_NE(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
Jooyung Han2d6b5c42021-01-09 01:01:06 +0900579 EXPECT_THAT(GetCapturedStderr(), HasSubstr("@JavaDerive is not available."));
Jiyong Park43113fb2020-07-20 16:26:19 +0900580 }
581}
582
Jiyong Park27fd7fd2020-08-27 16:25:09 +0900583TEST_P(AidlTest, ParseDescriptorAnnotation) {
584 AidlError error;
585 auto parse_result = Parse("IFoo.aidl", R"(@Descriptor(value="IBar") interface IFoo{})",
586 typenames_, GetLanguage(), &error, {"--structured"});
587 ASSERT_EQ(AidlError::OK, error);
588 ASSERT_NE(nullptr, parse_result);
589 const AidlInterface* interface = parse_result->AsInterface();
590 ASSERT_NE(nullptr, interface);
591 ASSERT_EQ("IBar", interface->GetDescriptor());
592}
593
Jiyong Park40782d02020-07-24 19:17:43 +0900594TEST_P(AidlTest, AcceptsOnewayMethod) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700595 const string oneway_method = "package a; interface IFoo { oneway void f(int a); }";
Devin Moore7b8d5c92020-03-17 14:14:08 -0700596 EXPECT_NE(nullptr, Parse("a/IFoo.aidl", oneway_method, typenames_, GetLanguage()));
Jiyong Park40782d02020-07-24 19:17:43 +0900597}
598
599TEST_P(AidlTest, AcceptsOnewayInterface) {
600 const string oneway_interface = "package a; oneway interface IBar { void f(int a); }";
Devin Moore7b8d5c92020-03-17 14:14:08 -0700601 EXPECT_NE(nullptr, Parse("a/IBar.aidl", oneway_interface, typenames_, GetLanguage()));
Christopher Wiley90be4e32015-10-20 14:55:25 -0700602}
Christopher Wileyef140932015-11-03 09:29:19 -0800603
Devin Moore7b8d5c92020-03-17 14:14:08 -0700604TEST_P(AidlTest, AcceptsAnnotatedOnewayMethod) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700605 const string oneway_method =
606 "package a; interface IFoo { @UnsupportedAppUsage oneway void f(int a); }";
Devin Moore7b8d5c92020-03-17 14:14:08 -0700607 EXPECT_NE(nullptr, Parse("a/IFoo.aidl", oneway_method, typenames_, GetLanguage()));
Artur Satayev91fe8712019-07-29 13:06:01 +0100608}
609
Steven Moreland65297cc2020-04-20 20:17:36 -0700610TEST_P(AidlTest, AnnotationsInMultiplePlaces) {
611 const string oneway_method =
612 "package a; interface IFoo { @UnsupportedAppUsage oneway @Hide void f(int a); }";
613 const AidlDefinedType* defined = Parse("a/IFoo.aidl", oneway_method, typenames_, GetLanguage());
614 ASSERT_NE(nullptr, defined);
615 const AidlInterface* iface = defined->AsInterface();
616 ASSERT_NE(nullptr, iface);
617
618 const auto& methods = iface->GetMethods();
619 ASSERT_EQ(1u, methods.size());
620 const auto& method = methods[0];
621 const AidlTypeSpecifier& ret_type = method->GetType();
622
623 // TODO(b/151102494): these annotations should be on the method
624 ASSERT_NE(nullptr, ret_type.UnsupportedAppUsage());
625 ASSERT_TRUE(ret_type.IsHide());
626}
627
Devin Moore7b8d5c92020-03-17 14:14:08 -0700628TEST_P(AidlTest, WritesComments) {
Artur Satayev91fe8712019-07-29 13:06:01 +0100629 string foo_interface =
Jooyung Han8451a202021-01-16 03:07:06 +0900630 R"(package a;
631 /* foo */
632 interface IFoo {
633 /* i */
634 int i();
635 // j
636 @nullable String j();
637 // k1
638 /* k2 */
639 @UnsupportedAppUsage oneway void k(int a);
640 })";
Artur Satayev91fe8712019-07-29 13:06:01 +0100641
Jooyung Han8451a202021-01-16 03:07:06 +0900642 CaptureStderr();
Devin Moore7b8d5c92020-03-17 14:14:08 -0700643 auto parse_result = Parse("a/IFoo.aidl", foo_interface, typenames_, GetLanguage());
Artur Satayev91fe8712019-07-29 13:06:01 +0100644 EXPECT_NE(nullptr, parse_result);
Jooyung Han8451a202021-01-16 03:07:06 +0900645 EXPECT_EQ("", GetCapturedStderr());
646
Jooyung Han161bb0f2021-01-21 12:30:16 +0900647 EXPECT_EQ((Comments{{"/* foo */"}}), parse_result->GetComments());
Artur Satayev91fe8712019-07-29 13:06:01 +0100648
649 const AidlInterface* interface = parse_result->AsInterface();
Jooyung Han161bb0f2021-01-21 12:30:16 +0900650 EXPECT_EQ((Comments{{"/* i */"}}), interface->GetMethods()[0]->GetComments());
651 EXPECT_EQ((Comments{{"// j\n"}}), interface->GetMethods()[1]->GetComments());
652 EXPECT_EQ((Comments{{"// k1\n"}, {"/* k2 */"}}), interface->GetMethods()[2]->GetComments());
Artur Satayev91fe8712019-07-29 13:06:01 +0100653}
654
Jooyung Han1a551d32020-10-05 15:37:26 +0900655TEST_P(AidlTest, CppHeaderCanBeIdentifierAsWell) {
656 io_delegate_.SetFileContents("p/cpp_header.aidl",
657 R"(package p;
658 parcelable cpp_header cpp_header "bar/header";)");
659 import_paths_.emplace("");
660 const string input_path = "p/IFoo.aidl";
661 const string input = R"(package p;
662 import p.cpp_header;
663 interface IFoo {
664 // get bar
665 cpp_header get();
666 })";
667
668 auto parse_result = Parse(input_path, input, typenames_, GetLanguage());
669 EXPECT_NE(nullptr, parse_result);
670 const AidlInterface* interface = parse_result->AsInterface();
Jooyung Han161bb0f2021-01-21 12:30:16 +0900671 EXPECT_EQ((Comments{{"// get bar\n"}}), interface->GetMethods()[0]->GetComments());
Jooyung Han1a551d32020-10-05 15:37:26 +0900672}
673
Christopher Wileyef140932015-11-03 09:29:19 -0800674TEST_F(AidlTest, ParsesPreprocessedFile) {
675 string simple_content = "parcelable a.Foo;\ninterface b.IBar;";
676 io_delegate_.SetFileContents("path", simple_content);
Steven Morelandcb1bcd72020-04-29 16:30:35 -0700677 EXPECT_FALSE(typenames_.ResolveTypename("a.Foo").is_resolved);
Jeongik Cha047c5ee2019-08-07 23:16:49 +0900678 EXPECT_TRUE(parse_preprocessed_file(io_delegate_, "path", &typenames_));
Steven Morelandcb1bcd72020-04-29 16:30:35 -0700679 EXPECT_TRUE(typenames_.ResolveTypename("a.Foo").is_resolved);
680 EXPECT_TRUE(typenames_.ResolveTypename("b.IBar").is_resolved);
Christopher Wileyef140932015-11-03 09:29:19 -0800681}
682
683TEST_F(AidlTest, ParsesPreprocessedFileWithWhitespace) {
684 string simple_content = "parcelable a.Foo;\n interface b.IBar ;\t";
685 io_delegate_.SetFileContents("path", simple_content);
Jeongik Cha047c5ee2019-08-07 23:16:49 +0900686
Steven Morelandcb1bcd72020-04-29 16:30:35 -0700687 EXPECT_FALSE(typenames_.ResolveTypename("a.Foo").is_resolved);
Jeongik Cha047c5ee2019-08-07 23:16:49 +0900688 EXPECT_TRUE(parse_preprocessed_file(io_delegate_, "path", &typenames_));
Steven Morelandcb1bcd72020-04-29 16:30:35 -0700689 EXPECT_TRUE(typenames_.ResolveTypename("a.Foo").is_resolved);
690 EXPECT_TRUE(typenames_.ResolveTypename("b.IBar").is_resolved);
Christopher Wileyef140932015-11-03 09:29:19 -0800691}
692
Devin Moore7b8d5c92020-03-17 14:14:08 -0700693TEST_P(AidlTest, PreferImportToPreprocessed) {
Christopher Wiley41544372015-11-03 14:52:29 -0800694 io_delegate_.SetFileContents("preprocessed", "interface another.IBar;");
695 io_delegate_.SetFileContents("one/IBar.aidl", "package one; "
696 "interface IBar {}");
697 preprocessed_files_.push_back("preprocessed");
Jiyong Park8c380532018-08-30 14:55:26 +0900698 import_paths_.emplace("");
Jeongik Cha047c5ee2019-08-07 23:16:49 +0900699 auto parse_result = Parse("p/IFoo.aidl", "package p; import one.IBar; interface IFoo {}",
Devin Moore7b8d5c92020-03-17 14:14:08 -0700700 typenames_, GetLanguage());
Christopher Wiley41544372015-11-03 14:52:29 -0800701 EXPECT_NE(nullptr, parse_result);
Jeongik Cha047c5ee2019-08-07 23:16:49 +0900702
Christopher Wiley41544372015-11-03 14:52:29 -0800703 // We expect to know about both kinds of IBar
Steven Morelandcb1bcd72020-04-29 16:30:35 -0700704 EXPECT_TRUE(typenames_.ResolveTypename("one.IBar").is_resolved);
705 EXPECT_TRUE(typenames_.ResolveTypename("another.IBar").is_resolved);
Christopher Wiley41544372015-11-03 14:52:29 -0800706 // But if we request just "IBar" we should get our imported one.
Jooyung Han8451a202021-01-16 03:07:06 +0900707 AidlTypeSpecifier ambiguous_type(AIDL_LOCATION_HERE, "IBar", false, nullptr, {});
Jeongik Cha047c5ee2019-08-07 23:16:49 +0900708 ambiguous_type.Resolve(typenames_);
709 EXPECT_EQ("one.IBar", ambiguous_type.GetName());
Christopher Wiley41544372015-11-03 14:52:29 -0800710}
711
Jiyong Park8f6ec462020-01-19 20:52:47 +0900712// Special case of PreferImportToPreprocessed. Imported type should be preferred
713// even when the preprocessed file already has the same type.
Devin Moore7b8d5c92020-03-17 14:14:08 -0700714TEST_P(AidlTest, B147918827) {
Jiyong Park8f6ec462020-01-19 20:52:47 +0900715 io_delegate_.SetFileContents("preprocessed", "interface another.IBar;\ninterface one.IBar;");
716 io_delegate_.SetFileContents("one/IBar.aidl",
717 "package one; "
718 "interface IBar {}");
719 preprocessed_files_.push_back("preprocessed");
720 import_paths_.emplace("");
721 auto parse_result = Parse("p/IFoo.aidl", "package p; import one.IBar; interface IFoo {}",
Devin Moore7b8d5c92020-03-17 14:14:08 -0700722 typenames_, GetLanguage());
Jiyong Park8f6ec462020-01-19 20:52:47 +0900723 EXPECT_NE(nullptr, parse_result);
724
725 // We expect to know about both kinds of IBar
Steven Morelandcb1bcd72020-04-29 16:30:35 -0700726 EXPECT_TRUE(typenames_.ResolveTypename("one.IBar").is_resolved);
727 EXPECT_TRUE(typenames_.ResolveTypename("another.IBar").is_resolved);
Jiyong Park8f6ec462020-01-19 20:52:47 +0900728 // But if we request just "IBar" we should get our imported one.
Jooyung Han8451a202021-01-16 03:07:06 +0900729 AidlTypeSpecifier ambiguous_type(AIDL_LOCATION_HERE, "IBar", false, nullptr, {});
Jiyong Park8f6ec462020-01-19 20:52:47 +0900730 ambiguous_type.Resolve(typenames_);
731 EXPECT_EQ("one.IBar", ambiguous_type.GetName());
732}
733
Casey Dahlinc1f39b42015-11-24 10:34:34 -0800734TEST_F(AidlTest, WritePreprocessedFile) {
735 io_delegate_.SetFileContents("p/Outer.aidl",
736 "package p; parcelable Outer.Inner;");
737 io_delegate_.SetFileContents("one/IBar.aidl", "package one; import p.Outer;"
738 "interface IBar {}");
739
Jiyong Park6f77e0c2018-07-28 16:55:44 +0900740 vector<string> args {
741 "aidl",
742 "--preprocess",
743 "preprocessed",
744 "p/Outer.aidl",
745 "one/IBar.aidl"};
746 Options options = Options::From(args);
Casey Dahlinc1f39b42015-11-24 10:34:34 -0800747 EXPECT_TRUE(::android::aidl::preprocess_aidl(options, io_delegate_));
748
749 string output;
750 EXPECT_TRUE(io_delegate_.GetWrittenContents("preprocessed", &output));
751 EXPECT_EQ("parcelable p.Outer.Inner;\ninterface one.IBar;\n", output);
752}
753
Jooyung Han720253d2021-01-05 19:13:17 +0900754TEST_P(AidlTest, SupportDeprecated) {
755 struct TestCase {
756 std::string output_file;
757 std::string annotation;
758 };
759
760 auto CheckDeprecated = [&](const std::string& filename, const std::string& contents,
Jooyung Hand4fe00e2021-01-11 16:21:53 +0900761 std::vector<std::pair<Options::Language, TestCase>> expectations) {
Jooyung Han720253d2021-01-05 19:13:17 +0900762 io_delegate_.SetFileContents(filename, contents);
763
764 auto options = Options::From("aidl --lang=" + to_string(GetLanguage()) + " " + filename +
765 " --out=out --header_out=out");
766 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jooyung Hand4fe00e2021-01-11 16:21:53 +0900767 for (const auto& [lang, test_case] : expectations) {
768 if (lang != GetLanguage()) continue;
Jooyung Han720253d2021-01-05 19:13:17 +0900769 string output;
Jooyung Han652ce482021-02-26 12:40:35 +0900770 EXPECT_TRUE(io_delegate_.GetWrittenContents(test_case.output_file, &output));
Jooyung Han720253d2021-01-05 19:13:17 +0900771 EXPECT_THAT(output, HasSubstr(test_case.annotation));
772 }
773 };
774
Jooyung Hand4fe00e2021-01-11 16:21:53 +0900775 // Emit escaped string for notes
776 CheckDeprecated(
777 "IFoo.aidl",
778 R"(interface IFoo {
779 /**
780 * @note asdf
781 * @deprecated a really long deprecation message
782 *
783 * which is really long
784 * @param foo bar
785 */
786 List<String> foo();
787 })",
788 {
789 {Options::Language::JAVA, {"out/IFoo.java", "@Deprecated"}},
790 {Options::Language::CPP,
791 {"out/IFoo.h",
792 R"(__attribute__((deprecated("a really long deprecation message which is really long"))))"}},
793 {Options::Language::NDK,
794 {"out/aidl/IFoo.h",
795 R"(__attribute__((deprecated("a really long deprecation message which is really long"))))"}},
796 {Options::Language::RUST,
797 {"out/IFoo.rs",
798 R"(#[deprecated = "a really long deprecation message which is really long"])"}},
799 });
800
Jooyung Han24effbf2021-01-16 10:24:03 +0900801 // In AIDL @deprecated can be in block comments as well as javadoc style
Jooyung Hand4fe00e2021-01-11 16:21:53 +0900802 CheckDeprecated(
803 "IFoo.aidl",
804 "interface IFoo {\n"
Jooyung Han24effbf2021-01-16 10:24:03 +0900805 " /* @deprecated use bar() */\n"
Jooyung Hand4fe00e2021-01-11 16:21:53 +0900806 " List<String> foo();\n"
807 "}",
808 {
809 {Options::Language::JAVA, {"out/IFoo.java", "@Deprecated"}},
Jooyung Hanb7a60ec2021-01-21 13:47:59 +0900810 {Options::Language::JAVA, {"out/IFoo.java", "/** @deprecated use bar() */"}},
Jooyung Hand4fe00e2021-01-11 16:21:53 +0900811 {Options::Language::CPP, {"out/IFoo.h", "__attribute__((deprecated(\"use bar()\")))"}},
812 {Options::Language::NDK,
813 {"out/aidl/IFoo.h", "__attribute__((deprecated(\"use bar()\")))"}},
814 {Options::Language::RUST, {"out/IFoo.rs", "#[deprecated = \"use bar()\"]"}},
815 });
Jooyung Han720253d2021-01-05 19:13:17 +0900816
Jooyung Han24effbf2021-01-16 10:24:03 +0900817 // but not in line comments
818 auto parsed = Parse("IFoo.aidl", "// @deprecated\ninterface IFoo {}", typenames_, GetLanguage());
819 EXPECT_FALSE(parsed->IsDeprecated());
820
821 // parcelable
Jooyung Han720253d2021-01-05 19:13:17 +0900822 CheckDeprecated("Foo.aidl",
823 "parcelable Foo {\n"
824 " /** @deprecated use bar*/\n"
825 " int foo = 0;\n"
826 "}",
827 {
828 {Options::Language::JAVA, {"out/Foo.java", "@Deprecated"}},
829 {Options::Language::CPP, {"out/Foo.h", "__attribute__((deprecated"}},
830 {Options::Language::NDK, {"out/aidl/Foo.h", "__attribute__((deprecated"}},
831 {Options::Language::RUST, {"out/Foo.rs", "#[deprecated"}},
832 });
833
Jooyung Han24effbf2021-01-16 10:24:03 +0900834 // interface constants
Jooyung Han720253d2021-01-05 19:13:17 +0900835 CheckDeprecated("IFoo.aidl",
836 "interface IFoo {\n"
837 " /** @deprecated use bar*/\n"
838 " const int FOO = 0;\n"
839 "}",
840 {
841 {Options::Language::JAVA, {"out/IFoo.java", "@Deprecated"}},
842 {Options::Language::CPP, {"out/IFoo.h", "__attribute__((deprecated"}},
843 {Options::Language::NDK, {"out/aidl/IFoo.h", "__attribute__((deprecated"}},
844 {Options::Language::RUST, {"out/IFoo.rs", "#[deprecated"}},
845 });
846
847 // union fields
848 CheckDeprecated("Foo.aidl",
849 "union Foo {\n"
850 " int bar = 0;\n"
851 " /** @deprecated use bar*/\n"
852 " int foo;\n"
853 "}",
854 {
855 {Options::Language::JAVA, {"out/Foo.java", "@Deprecated"}},
856 {Options::Language::CPP, {"out/Foo.h", "__attribute__((deprecated"}},
857 {Options::Language::NDK, {"out/aidl/Foo.h", "__attribute__((deprecated"}},
858 {Options::Language::RUST, {"out/Foo.rs", "#[deprecated"}},
859 });
860
861 CheckDeprecated("Foo.aidl",
862 "/** @deprecated use Bar */\n"
863 "parcelable Foo {}",
864 {
865 {Options::Language::JAVA, {"out/Foo.java", "@Deprecated"}},
866 {Options::Language::CPP, {"out/Foo.h", "__attribute__((deprecated"}},
867 {Options::Language::NDK, {"out/aidl/Foo.h", "__attribute__((deprecated"}},
868 {Options::Language::RUST, {"out/Foo.rs", "#[deprecated"}},
869 });
870
871 CheckDeprecated("Foo.aidl",
872 "/** @deprecated use Bar */\n"
873 "union Foo { int foo = 0; }",
874 {
875 {Options::Language::JAVA, {"out/Foo.java", "@Deprecated"}},
876 {Options::Language::CPP, {"out/Foo.h", "__attribute__((deprecated"}},
877 {Options::Language::NDK, {"out/aidl/Foo.h", "__attribute__((deprecated"}},
878 {Options::Language::RUST, {"out/Foo.rs", "#[deprecated"}},
879 });
880
881 CheckDeprecated("IFoo.aidl",
882 "/** @deprecated use IBar */\n"
883 "interface IFoo {}",
884 {
885 {Options::Language::JAVA, {"out/IFoo.java", "@Deprecated"}},
886 {Options::Language::CPP, {"out/IFoo.h", "__attribute__((deprecated"}},
887 {Options::Language::NDK, {"out/aidl/IFoo.h", "__attribute__((deprecated"}},
888 {Options::Language::RUST, {"out/IFoo.rs", "#[deprecated"}},
889 });
890
891 CheckDeprecated("Foo.aidl",
892 "/** @deprecated use IBar */\n"
893 "enum Foo { FOO }",
894 {
895 {Options::Language::JAVA, {"out/Foo.java", "@Deprecated"}},
896 {Options::Language::CPP, {"out/Foo.h", "__attribute__((deprecated"}},
897 {Options::Language::NDK, {"out/aidl/Foo.h", "__attribute__((deprecated"}},
Jooyung Hanb7a60ec2021-01-21 13:47:59 +0900898 // TODO(b/177860423) support "deprecated" in Rust enum
Jooyung Han720253d2021-01-05 19:13:17 +0900899 // {Options::Language::RUST, {"out/Foo.rs", "#[deprecated"}},
900 });
901}
902
Devin Moore7b8d5c92020-03-17 14:14:08 -0700903TEST_P(AidlTest, RequireOuterClass) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700904 const string expected_stderr = "ERROR: p/IFoo.aidl:1.54-60: Failed to resolve 'Inner'\n";
Christopher Wiley63bce2a2015-11-03 14:55:03 -0800905 io_delegate_.SetFileContents("p/Outer.aidl",
906 "package p; parcelable Outer.Inner;");
Jiyong Park8c380532018-08-30 14:55:26 +0900907 import_paths_.emplace("");
Devin Moore097a3ab2020-03-11 16:08:44 -0700908 CaptureStderr();
909 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl",
910 "package p; import p.Outer; interface IFoo { void f(in Inner c); }",
Devin Moore7b8d5c92020-03-17 14:14:08 -0700911 typenames_, GetLanguage()));
Devin Moore097a3ab2020-03-11 16:08:44 -0700912 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Christopher Wiley63bce2a2015-11-03 14:55:03 -0800913}
914
Devin Moore7b8d5c92020-03-17 14:14:08 -0700915TEST_P(AidlTest, ParseCompoundParcelableFromPreprocess) {
Christopher Wiley63bce2a2015-11-03 14:55:03 -0800916 io_delegate_.SetFileContents("preprocessed",
917 "parcelable p.Outer.Inner;");
918 preprocessed_files_.push_back("preprocessed");
Jeongik Cha047c5ee2019-08-07 23:16:49 +0900919 auto parse_result = Parse("p/IFoo.aidl", "package p; interface IFoo { void f(in Inner c); }",
Devin Moore7b8d5c92020-03-17 14:14:08 -0700920 typenames_, GetLanguage());
Christopher Wiley63bce2a2015-11-03 14:55:03 -0800921 // TODO(wiley): This should actually return nullptr because we require
922 // the outer class name. However, for legacy reasons,
923 // this behavior must be maintained. b/17415692
924 EXPECT_NE(nullptr, parse_result);
925}
926
Christopher Wiley632801d2015-11-05 14:15:49 -0800927TEST_F(AidlTest, FailOnParcelable) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700928 const string expected_foo_stderr =
929 "ERROR: p/IFoo.aidl:1.22-27: Refusing to generate code with unstructured parcelables. "
930 "Declared parcelables should be in their own file and/or cannot be used with --structured "
931 "interfaces.\n";
Steven Morelande2c64b42018-09-18 15:06:37 -0700932 io_delegate_.SetFileContents("p/IFoo.aidl", "package p; parcelable IFoo;");
933
Christopher Wiley632801d2015-11-05 14:15:49 -0800934 // By default, we shouldn't fail on parcelable.
Steven Morelande2c64b42018-09-18 15:06:37 -0700935 Options options1 = Options::From("aidl p/IFoo.aidl");
Devin Moore097a3ab2020-03-11 16:08:44 -0700936 CaptureStderr();
Jiyong Parkb034bf02018-07-30 17:44:33 +0900937 EXPECT_EQ(0, ::android::aidl::compile_aidl(options1, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -0700938 EXPECT_EQ("", GetCapturedStderr());
Jiyong Park6f77e0c2018-07-28 16:55:44 +0900939
Steven Morelande2c64b42018-09-18 15:06:37 -0700940 // -b considers this an error
Jiyong Park6f77e0c2018-07-28 16:55:44 +0900941 Options options2 = Options::From("aidl -b p/IFoo.aidl");
Devin Moore097a3ab2020-03-11 16:08:44 -0700942 CaptureStderr();
Jiyong Parkb034bf02018-07-30 17:44:33 +0900943 EXPECT_NE(0, ::android::aidl::compile_aidl(options2, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -0700944 EXPECT_EQ(expected_foo_stderr, GetCapturedStderr());
Steven Morelande2c64b42018-09-18 15:06:37 -0700945
Devin Moore097a3ab2020-03-11 16:08:44 -0700946 const string expected_bar_stderr =
947 "ERROR: p/IBar.aidl:1.22-26: Refusing to generate code with unstructured parcelables. "
948 "Declared parcelables should be in their own file and/or cannot be used with --structured "
949 "interfaces.\n";
Steven Morelande2c64b42018-09-18 15:06:37 -0700950 io_delegate_.SetFileContents("p/IBar.aidl", "package p; parcelable Foo; interface IBar{}");
951
Jiyong Parkda8c6932019-08-12 19:56:08 +0900952 // With '-b' option, a parcelable and an interface should fail.
Steven Morelande2c64b42018-09-18 15:06:37 -0700953 Options options3 = Options::From("aidl p/IBar.aidl");
Devin Moore097a3ab2020-03-11 16:08:44 -0700954 CaptureStderr();
Jiyong Parkda8c6932019-08-12 19:56:08 +0900955 EXPECT_EQ(0, ::android::aidl::compile_aidl(options3, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -0700956 EXPECT_EQ("", GetCapturedStderr());
Steven Morelande2c64b42018-09-18 15:06:37 -0700957 Options options4 = Options::From("aidl -b p/IBar.aidl");
Devin Moore097a3ab2020-03-11 16:08:44 -0700958 CaptureStderr();
Steven Morelande2c64b42018-09-18 15:06:37 -0700959 EXPECT_NE(0, ::android::aidl::compile_aidl(options4, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -0700960 EXPECT_EQ(expected_bar_stderr, GetCapturedStderr());
Christopher Wiley632801d2015-11-05 14:15:49 -0800961}
962
Devin Moore7b8d5c92020-03-17 14:14:08 -0700963TEST_P(AidlTest, StructuredFailOnUnstructuredParcelable) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700964 const string expected_stderr =
965 "ERROR: ./o/WhoKnowsWhat.aidl:1.22-35: o.WhoKnowsWhat is not structured, but this is a "
966 "structured interface.\n";
Steven Moreland1eac5fa2018-08-27 19:35:05 -0700967 io_delegate_.SetFileContents("o/WhoKnowsWhat.aidl", "package o; parcelable WhoKnowsWhat;");
968 import_paths_.emplace("");
Devin Moore097a3ab2020-03-11 16:08:44 -0700969 AidlError error;
970 CaptureStderr();
971 EXPECT_EQ(
972 nullptr,
Steven Moreland1eac5fa2018-08-27 19:35:05 -0700973 Parse("p/IFoo.aidl",
974 "package p; import o.WhoKnowsWhat; interface IFoo { void f(in WhoKnowsWhat thisIs); }",
Devin Moore7b8d5c92020-03-17 14:14:08 -0700975 typenames_, GetLanguage(), &error, {"--structured"}));
Devin Moore097a3ab2020-03-11 16:08:44 -0700976 EXPECT_EQ(expected_stderr, GetCapturedStderr());
977 EXPECT_EQ(AidlError::NOT_STRUCTURED, error);
Steven Moreland1eac5fa2018-08-27 19:35:05 -0700978}
979
Devin Moore7b8d5c92020-03-17 14:14:08 -0700980TEST_P(AidlTest, FailOnDuplicateConstantNames) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700981 AidlError error;
982 const string expected_stderr =
983 "ERROR: p/IFoo.aidl:4.34-45: Found duplicate constant name 'DUPLICATED'\n";
984 CaptureStderr();
Jeongik Cha047c5ee2019-08-07 23:16:49 +0900985 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl",
986 R"(package p;
Christopher Wiley69b44cf2016-05-03 13:43:33 -0700987 interface IFoo {
988 const String DUPLICATED = "d";
989 const int DUPLICATED = 1;
990 }
991 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -0700992 typenames_, GetLanguage(), &error));
Devin Moore097a3ab2020-03-11 16:08:44 -0700993 EXPECT_EQ(expected_stderr, GetCapturedStderr());
994 EXPECT_EQ(AidlError::BAD_TYPE, error);
Christopher Wiley69b44cf2016-05-03 13:43:33 -0700995}
996
Steven Morelande689da22020-11-10 02:06:30 +0000997TEST_P(AidlTest, FailOnTooBigConstant) {
998 AidlError error;
999 const string expected_stderr =
1000 "ERROR: p/IFoo.aidl:3.48-52: Invalid type specifier for an int32 literal: byte\n";
1001 CaptureStderr();
1002 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl",
1003 R"(package p;
1004 interface IFoo {
1005 const byte type2small = 256;
1006 }
1007 )",
1008 typenames_, GetLanguage(), &error));
1009 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1010 EXPECT_EQ(AidlError::BAD_TYPE, error);
1011}
1012
Jooyung Han30f64ad2020-12-15 08:16:31 +09001013TEST_F(AidlTest, BoolConstantsEvaluatesToIntegers) {
1014 io_delegate_.SetFileContents("a/Foo.aidl", "package a; parcelable Foo { const int y = true; }");
1015 CaptureStderr();
1016 auto options = Options::From("aidl --lang java -o out a/Foo.aidl");
1017 EXPECT_EQ(0, aidl::compile_aidl(options, io_delegate_));
1018 EXPECT_EQ("", GetCapturedStderr());
1019 string code;
1020 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/Foo.java", &code));
1021 EXPECT_THAT(code, testing::HasSubstr("public static final int y = 1;"));
1022}
1023
Jooyung Han535c5e82020-12-29 15:16:59 +09001024TEST_F(AidlTest, AidlConstantValue_EvaluatedValue) {
Jooyung Han71a1b582020-12-25 23:58:41 +09001025 using Ptr = unique_ptr<AidlConstantValue>;
1026 const AidlLocation& loc = AIDL_LOCATION_HERE;
1027
Jooyung Han535c5e82020-12-29 15:16:59 +09001028 EXPECT_EQ('c', Ptr(AidlConstantValue::Character(loc, 'c'))->EvaluatedValue<char>());
1029 EXPECT_EQ("abc", Ptr(AidlConstantValue::String(loc, "\"abc\""))->EvaluatedValue<string>());
1030 EXPECT_FLOAT_EQ(1.0f, Ptr(AidlConstantValue::Floating(loc, "1.0f"))->EvaluatedValue<float>());
1031 EXPECT_EQ(true, Ptr(AidlConstantValue::Boolean(loc, true))->EvaluatedValue<bool>());
Jooyung Han71a1b582020-12-25 23:58:41 +09001032
1033 AidlBinaryConstExpression one_plus_one(loc, Ptr(AidlConstantValue::Integral(loc, "1")), "+",
1034 Ptr(AidlConstantValue::Integral(loc, "1")));
Jooyung Han535c5e82020-12-29 15:16:59 +09001035 EXPECT_EQ(2, one_plus_one.EvaluatedValue<int32_t>());
Jooyung Han71a1b582020-12-25 23:58:41 +09001036
1037 auto values = unique_ptr<vector<Ptr>>{new vector<Ptr>};
1038 values->emplace_back(AidlConstantValue::String(loc, "\"hello\""));
1039 values->emplace_back(AidlConstantValue::String(loc, "\"world\""));
1040 vector<string> expected{"hello", "world"};
Jooyung Han535c5e82020-12-29 15:16:59 +09001041 EXPECT_EQ(
1042 expected,
1043 Ptr(AidlConstantValue::Array(loc, std::move(values)))->EvaluatedValue<vector<string>>());
Jooyung Han71a1b582020-12-25 23:58:41 +09001044}
1045
Devin Moore7b8d5c92020-03-17 14:14:08 -07001046TEST_P(AidlTest, FailOnManyDefinedTypes) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001047 AidlError error;
Devin Moore5de18ed2020-04-02 13:52:29 -07001048 const string expected_stderr =
1049 "ERROR: p/IFoo.aidl:3.33-38: You must declare only one type per file.\n";
Devin Moorec054bf82020-03-10 16:31:48 -07001050 CaptureStderr();
Steven Morelandc258abc2018-07-10 14:03:38 -07001051 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl",
1052 R"(package p;
1053 interface IFoo {}
Steven Morelandc258abc2018-07-10 14:03:38 -07001054 parcelable IBar {}
1055 parcelable StructuredParcelable {}
1056 interface IBaz {}
Jeongik Cha2a5b4d82019-08-06 19:37:59 +09001057 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -07001058 typenames_, GetLanguage(), &error));
Devin Moorec054bf82020-03-10 16:31:48 -07001059 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Steven Morelandc258abc2018-07-10 14:03:38 -07001060 // Parse success is important for clear error handling even if the cases aren't
1061 // actually supported in code generation.
Devin Moore097a3ab2020-03-11 16:08:44 -07001062 EXPECT_EQ(AidlError::BAD_TYPE, error);
Steven Morelandc258abc2018-07-10 14:03:38 -07001063}
1064
Devin Moore7b8d5c92020-03-17 14:14:08 -07001065TEST_P(AidlTest, FailOnNoDefinedTypes) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001066 AidlError error;
1067 const string expected_stderr = "ERROR: p/IFoo.aidl:1.11-11: syntax error, unexpected $end\n";
1068 CaptureStderr();
Devin Moore7b8d5c92020-03-17 14:14:08 -07001069 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl", R"(package p;)", typenames_, GetLanguage(), &error));
Devin Moore097a3ab2020-03-11 16:08:44 -07001070 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1071 EXPECT_EQ(AidlError::PARSE_ERROR, error);
Steven Morelandc258abc2018-07-10 14:03:38 -07001072}
1073
Steven Morelandf9e922f2020-07-08 21:15:27 +00001074TEST_P(AidlTest, FailOnEmptyListWithComma) {
1075 AidlError error;
1076 const string expected_stderr =
1077 "ERROR: p/Foo.aidl:1.45-47: syntax error, unexpected ',', expecting '}'\n";
1078 CaptureStderr();
1079 EXPECT_EQ(nullptr, Parse("p/Foo.aidl", R"(package p; parcelable Foo { uint64_t[] a = { , }; })",
1080 typenames_, GetLanguage(), &error));
1081 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1082 EXPECT_EQ(AidlError::PARSE_ERROR, error);
1083}
1084
Devin Moore7b8d5c92020-03-17 14:14:08 -07001085TEST_P(AidlTest, FailOnMalformedConstHexValue) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001086 AidlError error;
1087 const string expected_stderr =
Devin Moore2a088902020-09-17 10:51:19 -07001088 "ERROR: p/IFoo.aidl:3.50-71: Could not parse hexvalue: 0xffffffffffffffffff\n";
Devin Moore097a3ab2020-03-11 16:08:44 -07001089 CaptureStderr();
Jeongik Cha047c5ee2019-08-07 23:16:49 +09001090 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl",
1091 R"(package p;
Roshan Pius3b2203d2016-07-22 16:13:20 -07001092 interface IFoo {
1093 const int BAD_HEX_VALUE = 0xffffffffffffffffff;
1094 }
1095 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -07001096 typenames_, GetLanguage(), &error));
Devin Moore097a3ab2020-03-11 16:08:44 -07001097 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1098 EXPECT_EQ(AidlError::PARSE_ERROR, error);
Roshan Pius3b2203d2016-07-22 16:13:20 -07001099}
1100
Jiyong Park18132182020-06-08 20:24:40 +09001101TEST_P(AidlTest, FailOnMalformedQualifiedNameAsIdentifier) {
1102 AidlError error;
1103 const string expected_stderr =
1104 "ERROR: p/IFoo.aidl:1.25-26: syntax error, unexpected ';', expecting identifier or "
1105 "cpp_header (which can also be used as an identifier)\n";
1106 CaptureStderr();
1107 // Notice the trailing dot(.) in the name, which isn't a correct name
1108 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl", R"(package p; parcelable A.; )", typenames_,
1109 GetLanguage(), &error));
1110 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1111 EXPECT_EQ(AidlError::PARSE_ERROR, error);
1112}
1113
1114TEST_P(AidlTest, FailOnMalformedQualifiedNameAsPackage) {
1115 AidlError error;
1116 const string expected_stderr =
1117 "ERROR: p/IFoo.aidl:1.11-12: syntax error, unexpected ';', expecting identifier or "
1118 "cpp_header (which can also be used as an identifier)\n";
1119 CaptureStderr();
1120 // Notice the trailing dot(.) in the package name
1121 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl", R"(package p.; parcelable A; )", typenames_,
1122 GetLanguage(), &error));
1123 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1124 EXPECT_EQ(AidlError::PARSE_ERROR, error);
1125}
1126
Devin Moore7b8d5c92020-03-17 14:14:08 -07001127TEST_P(AidlTest, ParsePositiveConstHexValue) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001128 AidlError error;
Devin Moore7b8d5c92020-03-17 14:14:08 -07001129 auto parse_result = Parse("p/IFoo.aidl",
1130 R"(package p;
Roshan Pius3b2203d2016-07-22 16:13:20 -07001131 interface IFoo {
1132 const int POSITIVE_HEX_VALUE = 0xf5;
1133 }
1134 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -07001135 typenames_, GetLanguage(), &error);
1136 EXPECT_NE(nullptr, parse_result);
1137 const AidlInterface* interface = parse_result->AsInterface();
Steven Moreland5557f1c2018-07-02 13:50:23 -07001138 ASSERT_NE(nullptr, interface);
Steven Moreland693640b2018-07-19 13:46:27 -07001139 const auto& cpp_constants = interface->GetConstantDeclarations();
1140 EXPECT_EQ((size_t)1, cpp_constants.size());
1141 EXPECT_EQ("POSITIVE_HEX_VALUE", cpp_constants[0]->GetName());
Will McVickerd7d18df2019-09-12 13:40:50 -07001142 EXPECT_TRUE(cpp_constants[0]->CheckValid(typenames_));
Steven Moreland860b1942018-08-16 14:59:28 -07001143 EXPECT_EQ("245", cpp_constants[0]->ValueString(cpp::ConstantValueDecorator));
Roshan Pius3b2203d2016-07-22 16:13:20 -07001144}
1145
Devin Moore7b8d5c92020-03-17 14:14:08 -07001146TEST_P(AidlTest, ParseNegativeConstHexValue) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001147 AidlError error;
Devin Moore7b8d5c92020-03-17 14:14:08 -07001148 auto parse_result = Parse("p/IFoo.aidl",
1149 R"(package p;
Roshan Pius3b2203d2016-07-22 16:13:20 -07001150 interface IFoo {
1151 const int NEGATIVE_HEX_VALUE = 0xffffffff;
1152 }
1153 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -07001154 typenames_, GetLanguage(), &error);
1155 ASSERT_NE(nullptr, parse_result);
1156 const AidlInterface* interface = parse_result->AsInterface();
Steven Moreland5557f1c2018-07-02 13:50:23 -07001157 ASSERT_NE(nullptr, interface);
Steven Moreland693640b2018-07-19 13:46:27 -07001158 const auto& cpp_constants = interface->GetConstantDeclarations();
1159 EXPECT_EQ((size_t)1, cpp_constants.size());
1160 EXPECT_EQ("NEGATIVE_HEX_VALUE", cpp_constants[0]->GetName());
Will McVickerd7d18df2019-09-12 13:40:50 -07001161 EXPECT_EQ(true, cpp_constants[0]->CheckValid(typenames_));
Steven Moreland860b1942018-08-16 14:59:28 -07001162 EXPECT_EQ("-1", cpp_constants[0]->ValueString(cpp::ConstantValueDecorator));
Roshan Pius3b2203d2016-07-22 16:13:20 -07001163}
1164
Devin Moore7b8d5c92020-03-17 14:14:08 -07001165TEST_P(AidlTest, UnderstandsNestedParcelables) {
Ningyuan Wangd17c58b2016-09-29 14:33:14 -07001166 io_delegate_.SetFileContents(
1167 "p/Outer.aidl",
1168 "package p; parcelable Outer.Inner cpp_header \"baz/header\";");
Jiyong Park8c380532018-08-30 14:55:26 +09001169 import_paths_.emplace("");
Ningyuan Wangd17c58b2016-09-29 14:33:14 -07001170 const string input_path = "p/IFoo.aidl";
1171 const string input = "package p; import p.Outer; interface IFoo"
1172 " { Outer.Inner get(); }";
1173
Devin Moore7b8d5c92020-03-17 14:14:08 -07001174 auto parse_result = Parse(input_path, input, typenames_, GetLanguage());
1175 EXPECT_NE(nullptr, parse_result);
Jeongik Cha047c5ee2019-08-07 23:16:49 +09001176
Steven Morelandcb1bcd72020-04-29 16:30:35 -07001177 EXPECT_TRUE(typenames_.ResolveTypename("p.Outer.Inner").is_resolved);
Ningyuan Wangd17c58b2016-09-29 14:33:14 -07001178 // C++ uses "::" instead of "." to refer to a inner class.
Jooyung Han8451a202021-01-16 03:07:06 +09001179 AidlTypeSpecifier nested_type(AIDL_LOCATION_HERE, "p.Outer.Inner", false, nullptr, {});
Jeongik Cha047c5ee2019-08-07 23:16:49 +09001180 EXPECT_EQ("::p::Outer::Inner", cpp::CppNameOf(nested_type, typenames_));
Ningyuan Wangd17c58b2016-09-29 14:33:14 -07001181}
1182
Jooyung Han0a950bd2021-05-15 12:50:36 +09001183TEST_F(AidlTest, CppNameOf_GenericType) {
1184 io_delegate_.SetFileContents("p/Wrapper.aidl", "package p; parcelable Wrapper<T> { T wrapped; }");
1185 import_paths_.emplace("");
1186 // Since we don't support compilation of Wrapper directly (due to "T" reference),
1187 // prepare Holder so that Wrapper gets parsed into AidlTypenames
1188 const string input_path = "p/Holder.aidl";
1189 const string input =
1190 "package p; import p.Wrapper; parcelable Holder {\n"
1191 " @nullable Wrapper<String> value;\n"
1192 "}";
1193
1194 auto parse_result = Parse(input_path, input, typenames_, Options::Language::CPP);
1195 EXPECT_NE(nullptr, parse_result);
1196
1197 auto type = [](std::string name, auto&&... type_params) -> std::unique_ptr<AidlTypeSpecifier> {
1198 auto params = new std::vector<std::unique_ptr<AidlTypeSpecifier>>;
1199 (..., params->emplace_back(std::move(type_params)));
1200 return std::make_unique<AidlTypeSpecifier>(AIDL_LOCATION_HERE, name, false, params, Comments{});
1201 };
1202
1203 auto set_nullable = [](std::unique_ptr<AidlTypeSpecifier>&& type) {
1204 std::vector<AidlAnnotation> annotations;
1205 annotations.emplace_back(*AidlAnnotation::Parse(AIDL_LOCATION_HERE, "nullable", nullptr, {}));
1206 type->Annotate(std::move(annotations));
1207 return std::move(type);
1208 };
1209
1210 auto set_array = [](std::unique_ptr<AidlTypeSpecifier>&& type) {
1211 (void)type->SetArray();
1212 return std::move(type);
1213 };
1214
1215 auto w = type("p.Wrapper", type("String"));
1216 EXPECT_EQ("::p::Wrapper<::android::String16>", cpp::CppNameOf(*w, typenames_));
1217
1218 auto nullable_w = set_nullable(type("p.Wrapper", type("String")));
1219 EXPECT_EQ("::std::optional<::p::Wrapper<::android::String16>>",
1220 cpp::CppNameOf(*nullable_w, typenames_));
1221
1222 auto array_w = set_array(type("p.Wrapper", type("String")));
1223 EXPECT_EQ("::std::vector<::p::Wrapper<::android::String16>>",
1224 cpp::CppNameOf(*array_w, typenames_));
1225
1226 auto nullable_array_w = set_nullable(set_array(type("p.Wrapper", type("String"))));
1227 EXPECT_EQ("::std::optional<::std::vector<::std::optional<::p::Wrapper<::android::String16>>>>",
1228 cpp::CppNameOf(*nullable_array_w, typenames_));
1229
1230 auto list_w = type("List", type("p.Wrapper", type("String")));
1231 EXPECT_EQ("::std::vector<::p::Wrapper<::android::String16>>",
1232 cpp::CppNameOf(*list_w, typenames_));
1233
1234 auto nullable_list_w = set_nullable(type("List", type("p.Wrapper", type("String"))));
1235 EXPECT_EQ("::std::optional<::std::vector<::std::optional<::p::Wrapper<::android::String16>>>>",
1236 cpp::CppNameOf(*nullable_list_w, typenames_));
1237}
1238
Devin Moore7b8d5c92020-03-17 14:14:08 -07001239TEST_P(AidlTest, UnderstandsNativeParcelables) {
Christopher Wiley9078d722015-11-17 10:23:49 -08001240 io_delegate_.SetFileContents(
1241 "p/Bar.aidl",
Casey Dahlincd639212015-12-15 12:51:04 -08001242 "package p; parcelable Bar cpp_header \"baz/header\";");
Jiyong Park8c380532018-08-30 14:55:26 +09001243 import_paths_.emplace("");
Christopher Wiley9078d722015-11-17 10:23:49 -08001244 const string input_path = "p/IFoo.aidl";
1245 const string input = "package p; import p.Bar; interface IFoo { }";
Devin Moore7b8d5c92020-03-17 14:14:08 -07001246 auto parse_result = Parse(input_path, input, typenames_, GetLanguage());
1247 EXPECT_NE(nullptr, parse_result);
Steven Morelandcb1bcd72020-04-29 16:30:35 -07001248 EXPECT_TRUE(typenames_.ResolveTypename("p.Bar").is_resolved);
Jooyung Han8451a202021-01-16 03:07:06 +09001249 AidlTypeSpecifier native_type(AIDL_LOCATION_HERE, "p.Bar", false, nullptr, {});
Devin Moore7b8d5c92020-03-17 14:14:08 -07001250 native_type.Resolve(typenames_);
1251
1252 EXPECT_EQ("p.Bar", java::InstantiableJavaSignatureOf(native_type, typenames_));
1253 // C++ understands C++ specific stuff
1254 EXPECT_EQ("::p::Bar", cpp::CppNameOf(native_type, typenames_));
1255 set<string> headers;
Devin Moore2f2077a2020-08-28 11:27:53 -07001256 cpp::AddHeaders(native_type, typenames_, &headers);
Devin Moore7b8d5c92020-03-17 14:14:08 -07001257 EXPECT_EQ(1u, headers.size());
1258 EXPECT_EQ(1u, headers.count("baz/header"));
Christopher Wiley9078d722015-11-17 10:23:49 -08001259}
1260
Christopher Wileyf8136192016-04-12 14:19:35 -07001261TEST_F(AidlTest, WritesCorrectDependencyFile) {
1262 // While the in tree build system always gives us an output file name,
1263 // other android tools take advantage of our ability to infer the intended
1264 // file name. This test makes sure we handle this correctly.
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001265 vector<string> args = {
1266 "aidl",
1267 "-d dep/file/path",
1268 "-o place/for/output",
1269 "p/IFoo.aidl"};
1270 Options options = Options::From(args);
1271 io_delegate_.SetFileContents(options.InputFiles().front(), "package p; interface IFoo {}");
Jiyong Parkb034bf02018-07-30 17:44:33 +09001272 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
Christopher Wileyf8136192016-04-12 14:19:35 -07001273 string actual_dep_file_contents;
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001274 EXPECT_TRUE(io_delegate_.GetWrittenContents(options.DependencyFile(), &actual_dep_file_contents));
Christopher Wileyf8136192016-04-12 14:19:35 -07001275 EXPECT_EQ(actual_dep_file_contents, kExpectedDepFileContents);
1276}
1277
Dan Willemsen93298ee2016-11-10 23:55:55 -08001278TEST_F(AidlTest, WritesCorrectDependencyFileNinja) {
1279 // While the in tree build system always gives us an output file name,
1280 // other android tools take advantage of our ability to infer the intended
1281 // file name. This test makes sure we handle this correctly.
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001282 vector<string> args = {
1283 "aidl",
1284 "-d dep/file/path",
1285 "--ninja",
1286 "-o place/for/output",
1287 "p/IFoo.aidl"};
1288 Options options = Options::From(args);
1289 io_delegate_.SetFileContents(options.InputFiles().front(), "package p; interface IFoo {}");
Jiyong Parkb034bf02018-07-30 17:44:33 +09001290 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
Dan Willemsen93298ee2016-11-10 23:55:55 -08001291 string actual_dep_file_contents;
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001292 EXPECT_TRUE(io_delegate_.GetWrittenContents(options.DependencyFile(), &actual_dep_file_contents));
Dan Willemsen93298ee2016-11-10 23:55:55 -08001293 EXPECT_EQ(actual_dep_file_contents, kExpectedNinjaDepFileContents);
1294}
1295
Jiyong Parkdf202122019-09-30 20:48:35 +09001296TEST_F(AidlTest, WritesTrivialDependencyFileForParcelableDeclaration) {
Christopher Wileyb1bbdf82016-04-21 11:43:45 -07001297 // The SDK uses aidl to decide whether a .aidl file is a parcelable. It does
1298 // this by calling aidl with every .aidl file it finds, then parsing the
1299 // generated dependency files. Those that reference .java output files are
1300 // for interfaces and those that do not are parcelables. However, for both
1301 // parcelables and interfaces, we *must* generate a non-empty dependency file.
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001302 vector<string> args = {
1303 "aidl",
1304 "-o place/for/output",
1305 "-d dep/file/path",
1306 "p/Foo.aidl"};
1307 Options options = Options::From(args);
1308 io_delegate_.SetFileContents(options.InputFiles().front(), "package p; parcelable Foo;");
Jiyong Parkb034bf02018-07-30 17:44:33 +09001309 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
Christopher Wileyb1bbdf82016-04-21 11:43:45 -07001310 string actual_dep_file_contents;
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001311 EXPECT_TRUE(io_delegate_.GetWrittenContents(options.DependencyFile(), &actual_dep_file_contents));
Jiyong Parkdf202122019-09-30 20:48:35 +09001312 EXPECT_EQ(actual_dep_file_contents, kExpectedParcelableDeclarationDepFileContents);
1313}
1314
1315TEST_F(AidlTest, WritesDependencyFileForStructuredParcelable) {
1316 vector<string> args = {
1317 "aidl",
1318 "--structured",
1319 "-o place/for/output",
1320 "-d dep/file/path",
1321 "p/Foo.aidl"};
1322 Options options = Options::From(args);
1323 io_delegate_.SetFileContents(options.InputFiles().front(), "package p; parcelable Foo {int a;}");
1324 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1325 string actual_dep_file_contents;
1326 EXPECT_TRUE(io_delegate_.GetWrittenContents(options.DependencyFile(), &actual_dep_file_contents));
1327 EXPECT_EQ(actual_dep_file_contents, kExpectedStructuredParcelableDepFileContents);
Christopher Wileyb1bbdf82016-04-21 11:43:45 -07001328}
1329
Jiyong Park9ca5c7e2019-10-17 15:01:14 +09001330TEST_F(AidlTest, NoJavaOutputForParcelableDeclaration) {
1331 vector<string> args = {
1332 "aidl",
1333 "--lang=java",
1334 "-o place/for/output",
1335 "p/Foo.aidl"};
1336 Options options = Options::From(args);
1337 io_delegate_.SetFileContents(options.InputFiles().front(), "package p; parcelable Foo;");
1338 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1339 string output_file_contents;
1340 EXPECT_FALSE(io_delegate_.GetWrittenContents(options.OutputFile(), &output_file_contents));
1341}
1342
Devin Moore21b26772020-08-26 16:37:56 -07001343TEST_P(AidlTest, RejectsListArray) {
Devin Moore6a01ca12020-08-28 10:24:19 -07001344 const string expected_stderr = "ERROR: a/Foo.aidl:2.1-7: List[] is not supported.\n";
Devin Moore21b26772020-08-26 16:37:56 -07001345 const string list_array_parcelable =
1346 "package a; parcelable Foo {\n"
1347 " List[] lists; }";
1348 CaptureStderr();
1349 EXPECT_EQ(nullptr, Parse("a/Foo.aidl", list_array_parcelable, typenames_, GetLanguage()));
1350 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1351}
1352
Jiyong Parkf8d53612020-05-04 14:06:13 +09001353TEST_P(AidlTest, RejectsPrimitiveListInStableAidl) {
1354 AidlError error;
1355 string expected_stderr =
1356 "ERROR: a/IFoo.aidl:2.7-11: "
1357 "Encountered an untyped List or Map. The use of untyped List/Map is "
1358 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
1359 "the receiving side. Consider switching to an array or a generic List/Map.\n";
1360 if (GetLanguage() != Options::Language::JAVA) {
1361 expected_stderr =
1362 "ERROR: a/IFoo.aidl:2.1-7: "
1363 "Currently, only the Java backend supports non-generic List.\n";
1364 }
1365
1366 const string primitive_interface =
1367 "package a; interface IFoo {\n"
1368 " List foo(); }";
1369 CaptureStderr();
Jiyong Park40782d02020-07-24 19:17:43 +09001370 AidlTypenames tn1;
1371 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", primitive_interface, tn1, GetLanguage(), &error,
Jiyong Parkf8d53612020-05-04 14:06:13 +09001372 {"--structured"}));
1373 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Parkf8d53612020-05-04 14:06:13 +09001374
1375 string primitive_parcelable =
1376 "package a; parcelable IFoo {\n"
1377 " List foo;}";
1378 CaptureStderr();
Jiyong Park40782d02020-07-24 19:17:43 +09001379 AidlTypenames tn2;
1380 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", primitive_parcelable, tn2, GetLanguage(), &error,
Jiyong Parkf8d53612020-05-04 14:06:13 +09001381 {"--structured"}));
1382 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1383}
1384
Jeongik Cha225519b2020-08-29 01:55:32 +09001385TEST_P(AidlTest, ExtensionTest) {
1386 CaptureStderr();
Jeongik Cha649e8a72020-03-27 17:47:40 +09001387 string extendable_parcelable =
1388 "package a; parcelable Data {\n"
1389 " ParcelableHolder extension;\n"
1390 " ParcelableHolder extension2;\n"
1391 "}";
Jeongik Cha8f02a532020-10-14 00:16:28 +09001392 if (GetLanguage() == Options::Language::RUST) {
Jeongik Cha225519b2020-08-29 01:55:32 +09001393 EXPECT_EQ(nullptr, Parse("a/Data.aidl", extendable_parcelable, typenames_, GetLanguage()));
1394 EXPECT_EQ(
Jeongik Cha8f02a532020-10-14 00:16:28 +09001395 "ERROR: a/Data.aidl:2.1-19: The Rust backend does not support ParcelableHolder "
Jeongik Cha225519b2020-08-29 01:55:32 +09001396 "yet.\n",
1397 GetCapturedStderr());
1398 } else {
1399 EXPECT_NE(nullptr, Parse("a/Data.aidl", extendable_parcelable, typenames_, GetLanguage()));
1400 EXPECT_EQ("", GetCapturedStderr());
1401 }
1402}
1403TEST_P(AidlTest, ParcelableHolderAsReturnType) {
1404 CaptureStderr();
Jeongik Cha649e8a72020-03-27 17:47:40 +09001405 string parcelableholder_return_interface =
1406 "package a; interface IFoo {\n"
1407 " ParcelableHolder foo();\n"
1408 "}";
Jeongik Cha225519b2020-08-29 01:55:32 +09001409 EXPECT_EQ(nullptr,
1410 Parse("a/IFoo.aidl", parcelableholder_return_interface, typenames_, GetLanguage()));
Jeongik Cha649e8a72020-03-27 17:47:40 +09001411
Jeongik Cha8f02a532020-10-14 00:16:28 +09001412 if (GetLanguage() == Options::Language::RUST) {
Jeongik Cha225519b2020-08-29 01:55:32 +09001413 EXPECT_EQ(
Steven Morelandebc3c5d2020-09-30 23:40:33 +00001414 "ERROR: a/IFoo.aidl:2.19-23: ParcelableHolder cannot be a return type\n"
Jeongik Cha8f02a532020-10-14 00:16:28 +09001415 "ERROR: a/IFoo.aidl:2.1-19: The Rust backend does not support ParcelableHolder "
Jeongik Cha225519b2020-08-29 01:55:32 +09001416 "yet.\n",
1417 GetCapturedStderr());
1418 return;
1419 }
1420 EXPECT_EQ("ERROR: a/IFoo.aidl:2.19-23: ParcelableHolder cannot be a return type\n",
1421 GetCapturedStderr());
1422}
1423
1424TEST_P(AidlTest, ParcelableHolderAsArgumentType) {
1425 CaptureStderr();
Jeongik Cha649e8a72020-03-27 17:47:40 +09001426 string extendable_parcelable_arg_interface =
1427 "package a; interface IFoo {\n"
1428 " void foo(in ParcelableHolder ph);\n"
1429 "}";
Jeongik Cha225519b2020-08-29 01:55:32 +09001430 EXPECT_EQ(nullptr,
1431 Parse("a/IFoo.aidl", extendable_parcelable_arg_interface, typenames_, GetLanguage()));
1432
Jeongik Cha8f02a532020-10-14 00:16:28 +09001433 if (GetLanguage() == Options::Language::RUST) {
Jeongik Cha225519b2020-08-29 01:55:32 +09001434 EXPECT_EQ(
Steven Morelandebc3c5d2020-09-30 23:40:33 +00001435 "ERROR: a/IFoo.aidl:2.31-34: ParcelableHolder cannot be an argument type\n"
Jeongik Cha8f02a532020-10-14 00:16:28 +09001436 "ERROR: a/IFoo.aidl:2.14-31: The Rust backend does not support ParcelableHolder "
Jeongik Cha225519b2020-08-29 01:55:32 +09001437 "yet.\n",
1438 GetCapturedStderr());
1439 return;
1440 }
1441 EXPECT_EQ("ERROR: a/IFoo.aidl:2.31-34: ParcelableHolder cannot be an argument type\n",
1442 GetCapturedStderr());
Jeongik Cha649e8a72020-03-27 17:47:40 +09001443}
1444
Jeongik Chaf6ec8982020-10-15 00:10:30 +09001445TEST_P(AidlTest, RejectNullableParcelableHolderField) {
1446 io_delegate_.SetFileContents("Foo.aidl", "parcelable Foo { @nullable ParcelableHolder ext; }");
Jooyung Han9435e9a2021-01-06 10:16:31 +09001447 Options options = Options::From("aidl Foo.aidl --lang=" + to_string(GetLanguage()));
Jeongik Chaf6ec8982020-10-15 00:10:30 +09001448 const string expected_stderr = "ERROR: Foo.aidl:1.27-44: ParcelableHolder cannot be nullable.\n";
1449 CaptureStderr();
1450 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
1451 if (GetLanguage() == Options::Language::RUST) {
1452 EXPECT_EQ(
1453 "ERROR: Foo.aidl:1.27-44: ParcelableHolder cannot be nullable.\n"
1454 "ERROR: Foo.aidl:1.27-44: The Rust backend does not support ParcelableHolder "
1455 "yet.\n",
1456 GetCapturedStderr());
1457 return;
1458 }
1459 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1460}
1461
Jooyung Han3f347ca2020-12-01 12:41:50 +09001462TEST_P(AidlTest, ParcelablesWithConstants) {
1463 io_delegate_.SetFileContents("Foo.aidl", "parcelable Foo { const int BIT = 0x1 << 3; }");
Jooyung Han9435e9a2021-01-06 10:16:31 +09001464 Options options = Options::From("aidl Foo.aidl --lang=" + to_string(GetLanguage()));
Jooyung Han3f347ca2020-12-01 12:41:50 +09001465 CaptureStderr();
1466 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1467 EXPECT_EQ("", GetCapturedStderr());
1468}
1469
1470TEST_P(AidlTest, UnionWithConstants) {
1471 io_delegate_.SetFileContents("Foo.aidl", "union Foo { const int BIT = 0x1 << 3; int n; }");
Jooyung Han9435e9a2021-01-06 10:16:31 +09001472 Options options = Options::From("aidl Foo.aidl --lang=" + to_string(GetLanguage()));
Jooyung Han3f347ca2020-12-01 12:41:50 +09001473 CaptureStderr();
1474 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1475 EXPECT_EQ("", GetCapturedStderr());
1476}
1477
Jooyung Han633eab62021-01-07 14:12:40 +09001478TEST_F(AidlTest, ConstantsWithAnnotations) {
1479 io_delegate_.SetFileContents("IFoo.aidl",
1480 "interface IFoo {\n"
1481 " @JavaPassthrough(annotation=\"@Foo\")\n"
1482 " const @JavaPassthrough(annotation=\"@Bar\") int FOO = 0;\n"
1483 "}");
1484 Options options = Options::From("aidl IFoo.aidl --lang=java -o out");
1485 CaptureStderr();
1486 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1487 EXPECT_EQ("", GetCapturedStderr());
1488 string code;
1489 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/IFoo.java", &code));
1490 EXPECT_THAT(code, HasSubstr("@Foo\n"));
1491 EXPECT_THAT(code, HasSubstr("@Bar\n"));
1492}
1493
Jiyong Park02da7422018-07-16 16:00:26 +09001494TEST_F(AidlTest, ApiDump) {
1495 io_delegate_.SetFileContents(
1496 "foo/bar/IFoo.aidl",
1497 "package foo.bar;\n"
1498 "import foo.bar.Data;\n"
Jooyung Han24effbf2021-01-16 10:24:03 +09001499 "// commented /* @hide */\n"
Jiyong Park02da7422018-07-16 16:00:26 +09001500 "interface IFoo {\n"
Jooyung Han161bb0f2021-01-21 12:30:16 +09001501 " /* @hide applied \n"
1502 " @deprecated use foo2 */\n"
1503 " int foo(out int[] a, String b, boolean c, inout List<String> d);\n"
1504 " int foo2(@utf8InCpp String x, inout List<String> y);\n"
Jiyong Park02da7422018-07-16 16:00:26 +09001505 " IFoo foo3(IFoo foo);\n"
1506 " Data getData();\n"
Jooyung Han161bb0f2021-01-21 12:30:16 +09001507 " // @hide not applied\n"
Jooyung Han9fd67022021-01-13 10:49:48 +09001508 " /** blahblah\n"
1509 " @deprecated\n"
1510 " reason why... */\n"
Jiyong Parka428d212018-08-29 22:26:30 +09001511 " const int A = 1;\n"
Jooyung Han24effbf2021-01-16 10:24:03 +09001512 " // @deprecated tags in line comments are ignored\n"
Jiyong Parka428d212018-08-29 22:26:30 +09001513 " const String STR = \"Hello\";\n"
Jiyong Park02da7422018-07-16 16:00:26 +09001514 "}\n");
1515 io_delegate_.SetFileContents("foo/bar/Data.aidl",
1516 "package foo.bar;\n"
1517 "import foo.bar.IFoo;\n"
Jeongik Cha997281d2020-01-16 15:23:59 +09001518 "/* @hide*/\n"
Jiyong Park02da7422018-07-16 16:00:26 +09001519 "parcelable Data {\n"
Jeongik Cha997281d2020-01-16 15:23:59 +09001520 " // @hide\n"
Jiyong Parka468e2a2018-08-29 21:25:18 +09001521 " int x = 10;\n"
Jeongik Cha997281d2020-01-16 15:23:59 +09001522 " // @hide\n"
Jiyong Park02da7422018-07-16 16:00:26 +09001523 " int y;\n"
Jeongik Cha997281d2020-01-16 15:23:59 +09001524 " /*@hide2*/\n"
Jooyung Han55f96ad2020-12-13 10:08:33 +09001525 " IFoo foo;\n"
Jooyung Han24effbf2021-01-16 10:24:03 +09001526 " // Ignore @hide property in line comment\n"
Jeongik Cha3271ffa2018-12-04 15:19:20 +09001527 " @nullable String[] c;\n"
Jiyong Park02da7422018-07-16 16:00:26 +09001528 "}\n");
1529 io_delegate_.SetFileContents("api.aidl", "");
Jiyong Park633246c2019-11-25 10:50:05 +09001530 vector<string> args = {"aidl", "--dumpapi", "--out=dump", "--include=.",
1531 "foo/bar/IFoo.aidl", "foo/bar/Data.aidl"};
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001532 Options options = Options::From(args);
Jiyong Park02da7422018-07-16 16:00:26 +09001533 bool result = dump_api(options, io_delegate_);
1534 ASSERT_TRUE(result);
1535 string actual;
Jiyong Parke59c3682018-09-11 23:10:25 +09001536 EXPECT_TRUE(io_delegate_.GetWrittenContents("dump/foo/bar/IFoo.aidl", &actual));
Jooyung Han161bb0f2021-01-21 12:30:16 +09001537 EXPECT_EQ(string(kPreamble).append(R"(package foo.bar;
Jiyong Parke59c3682018-09-11 23:10:25 +09001538interface IFoo {
Jooyung Han161bb0f2021-01-21 12:30:16 +09001539 /**
1540 * @hide
1541 * @deprecated use foo2
1542 */
Jiyong Parke59c3682018-09-11 23:10:25 +09001543 int foo(out int[] a, String b, boolean c, inout List<String> d);
1544 int foo2(@utf8InCpp String x, inout List<String> y);
1545 foo.bar.IFoo foo3(foo.bar.IFoo foo);
1546 foo.bar.Data getData();
Jooyung Han161bb0f2021-01-21 12:30:16 +09001547 /**
1548 * @deprecated reason why...
1549 */
Jiyong Parke59c3682018-09-11 23:10:25 +09001550 const int A = 1;
1551 const String STR = "Hello";
1552}
Jooyung Han161bb0f2021-01-21 12:30:16 +09001553)"),
1554 actual);
Jiyong Park02da7422018-07-16 16:00:26 +09001555
Jiyong Parke59c3682018-09-11 23:10:25 +09001556 EXPECT_TRUE(io_delegate_.GetWrittenContents("dump/foo/bar/Data.aidl", &actual));
Jooyung Han161bb0f2021-01-21 12:30:16 +09001557 EXPECT_EQ(string(kPreamble).append(R"(package foo.bar;
Jooyung Han8db65942021-03-02 18:14:44 +09001558/* @hide */
Jiyong Parke59c3682018-09-11 23:10:25 +09001559parcelable Data {
1560 int x = 10;
1561 int y;
1562 foo.bar.IFoo foo;
Jeongik Cha3271ffa2018-12-04 15:19:20 +09001563 @nullable String[] c;
Jiyong Park02da7422018-07-16 16:00:26 +09001564}
Jooyung Han161bb0f2021-01-21 12:30:16 +09001565)"),
1566 actual);
Jiyong Park02da7422018-07-16 16:00:26 +09001567}
1568
Jiyong Parked65bf42018-08-28 15:43:27 +09001569TEST_F(AidlTest, ApiDumpWithManualIds) {
1570 io_delegate_.SetFileContents(
1571 "foo/bar/IFoo.aidl",
1572 "package foo.bar;\n"
1573 "interface IFoo {\n"
1574 " int foo() = 1;\n"
1575 " int bar() = 2;\n"
1576 " int baz() = 10;\n"
1577 "}\n");
1578
Jiyong Parke59c3682018-09-11 23:10:25 +09001579 vector<string> args = {"aidl", "--dumpapi", "-o dump", "foo/bar/IFoo.aidl"};
Jiyong Parked65bf42018-08-28 15:43:27 +09001580 Options options = Options::From(args);
1581 bool result = dump_api(options, io_delegate_);
1582 ASSERT_TRUE(result);
1583 string actual;
Jiyong Parke59c3682018-09-11 23:10:25 +09001584 EXPECT_TRUE(io_delegate_.GetWrittenContents("dump/foo/bar/IFoo.aidl", &actual));
Paul Trautrimb01451d2020-02-27 13:10:16 +09001585 EXPECT_EQ(actual, string(kPreamble).append(R"(package foo.bar;
Jiyong Parke59c3682018-09-11 23:10:25 +09001586interface IFoo {
1587 int foo() = 1;
1588 int bar() = 2;
1589 int baz() = 10;
Jiyong Parked65bf42018-08-28 15:43:27 +09001590}
Paul Trautrimb01451d2020-02-27 13:10:16 +09001591)"));
Jiyong Parked65bf42018-08-28 15:43:27 +09001592}
1593
1594TEST_F(AidlTest, ApiDumpWithManualIdsOnlyOnSomeMethods) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001595 const string expected_stderr =
1596 "ERROR: foo/bar/IFoo.aidl:4.8-12: You must either assign id's to all methods or to none of "
1597 "them.\n";
Jiyong Parked65bf42018-08-28 15:43:27 +09001598 io_delegate_.SetFileContents(
1599 "foo/bar/IFoo.aidl",
1600 "package foo.bar;\n"
1601 "interface IFoo {\n"
1602 " int foo() = 1;\n"
1603 " int bar();\n"
1604 " int baz() = 10;\n"
1605 "}\n");
1606
Jiyong Parke59c3682018-09-11 23:10:25 +09001607 vector<string> args = {"aidl", "--dumpapi", "-o dump", "foo/bar/IFoo.aidl"};
Jiyong Parked65bf42018-08-28 15:43:27 +09001608 Options options = Options::From(args);
Devin Moore097a3ab2020-03-11 16:08:44 -07001609 CaptureStderr();
Jiyong Parked65bf42018-08-28 15:43:27 +09001610 EXPECT_FALSE(dump_api(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001611 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Parked65bf42018-08-28 15:43:27 +09001612}
1613
Jooyung Han965e31d2020-11-27 12:30:16 +09001614TEST_F(AidlTest, ApiDumpConstWithAnnotation) {
1615 io_delegate_.SetFileContents("foo/bar/IFoo.aidl",
1616 "package foo.bar;\n"
1617 "interface IFoo {\n"
1618 " @utf8InCpp String foo();\n"
1619 " const @utf8InCpp String bar = \"bar\";\n"
1620 "}\n");
1621
1622 vector<string> args = {"aidl", "--dumpapi", "-o dump", "foo/bar/IFoo.aidl"};
1623 Options options = Options::From(args);
1624 CaptureStderr();
1625 EXPECT_TRUE(dump_api(options, io_delegate_));
1626 EXPECT_EQ("", GetCapturedStderr());
1627 string actual;
1628 EXPECT_TRUE(io_delegate_.GetWrittenContents("dump/foo/bar/IFoo.aidl", &actual));
Jooyung Han965e31d2020-11-27 12:30:16 +09001629 EXPECT_EQ(string(kPreamble).append(R"(package foo.bar;
1630interface IFoo {
1631 @utf8InCpp String foo();
Jooyung Hanb3ca6302020-11-27 14:13:27 +09001632 const @utf8InCpp String bar = "bar";
Jooyung Han965e31d2020-11-27 12:30:16 +09001633}
1634)"),
1635 actual);
1636}
1637
Jooyung Hanfdaae1d2020-12-14 13:16:15 +09001638TEST_F(AidlTest, ApiDumpWithEnums) {
1639 io_delegate_.SetFileContents("foo/bar/Enum.aidl",
1640 "package foo.bar;\n"
1641 "enum Enum {\n"
1642 " FOO,\n"
1643 " BAR = FOO + 1,\n"
1644 "}\n");
1645
1646 vector<string> args = {"aidl", "--dumpapi", "-I . ", "-o dump", "foo/bar/Enum.aidl"};
1647 Options options = Options::From(args);
1648 CaptureStderr();
1649 EXPECT_TRUE(dump_api(options, io_delegate_));
1650 EXPECT_EQ("", GetCapturedStderr());
1651 string actual;
1652 EXPECT_TRUE(io_delegate_.GetWrittenContents("dump/foo/bar/Enum.aidl", &actual));
1653 EXPECT_EQ(string(kPreamble).append("package foo.bar;\n"
1654 "enum Enum {\n"
1655 " FOO = 0,\n"
1656 " BAR = 1,\n"
1657 "}\n"),
1658 actual);
1659}
1660
1661TEST_F(AidlTest, ApiDumpWithEnumDefaultValues) {
1662 io_delegate_.SetFileContents("foo/bar/Enum.aidl",
1663 "package foo.bar;\n"
1664 "enum Enum {\n"
1665 " FOO,\n"
1666 "}\n");
1667 io_delegate_.SetFileContents("foo/bar/Foo.aidl",
1668 "package foo.bar;\n"
1669 "import foo.bar.Enum;\n"
1670 "parcelable Foo {\n"
1671 " Enum e = Enum.FOO;\n"
1672 "}\n");
1673
1674 vector<string> args = {"aidl", "--dumpapi", "-I . ", "-o dump", "foo/bar/Foo.aidl"};
1675 Options options = Options::From(args);
1676 CaptureStderr();
1677 EXPECT_TRUE(dump_api(options, io_delegate_));
1678 EXPECT_EQ("", GetCapturedStderr());
1679 string actual;
1680 EXPECT_TRUE(io_delegate_.GetWrittenContents("dump/foo/bar/Foo.aidl", &actual));
1681 EXPECT_EQ(string(kPreamble).append("package foo.bar;\n"
1682 "parcelable Foo {\n"
1683 " foo.bar.Enum e = foo.bar.Enum.FOO;\n"
1684 "}\n"),
1685 actual);
1686}
1687
Jiyong Park1d2df7d2018-07-23 15:22:50 +09001688TEST_F(AidlTest, CheckNumGenericTypeSecifier) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001689 const string expected_list_stderr =
Steven Morelandebc3c5d2020-09-30 23:40:33 +00001690 "ERROR: p/IFoo.aidl:1.37-41: List can only have one type parameter, but got: "
1691 "'List<String,String>'\n";
Devin Moore097a3ab2020-03-11 16:08:44 -07001692 const string expected_map_stderr =
1693 "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 +09001694 Options options = Options::From("aidl p/IFoo.aidl IFoo.java");
1695 io_delegate_.SetFileContents(options.InputFiles().front(),
Jiyong Park1d2df7d2018-07-23 15:22:50 +09001696 "package p; interface IFoo {"
1697 "void foo(List<String, String> a);}");
Devin Moore097a3ab2020-03-11 16:08:44 -07001698 CaptureStderr();
Jiyong Parkb034bf02018-07-30 17:44:33 +09001699 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001700 EXPECT_EQ(expected_list_stderr, GetCapturedStderr());
Jiyong Park1d2df7d2018-07-23 15:22:50 +09001701
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001702 io_delegate_.SetFileContents(options.InputFiles().front(),
Jiyong Park1d2df7d2018-07-23 15:22:50 +09001703 "package p; interface IFoo {"
1704 "void foo(Map<String> a);}");
Devin Moore097a3ab2020-03-11 16:08:44 -07001705 CaptureStderr();
Jiyong Parkb034bf02018-07-30 17:44:33 +09001706 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001707 EXPECT_EQ(expected_map_stderr, GetCapturedStderr());
Jiyong Parkb034bf02018-07-30 17:44:33 +09001708}
1709
Jeongik Chae48d9942020-01-02 17:39:00 +09001710TEST_F(AidlTest, CheckTypeParameterInMapType) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001711 const string expected_stderr =
1712 "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 +09001713 Options options = Options::From("aidl -I p p/IFoo.aidl");
1714 io_delegate_.SetFileContents("p/Bar.aidl", "package p; parcelable Bar { String s; }");
1715
1716 io_delegate_.SetFileContents("p/IFoo.aidl",
1717 "package p; interface IFoo {"
1718 "Map<String, Bar> foo();}");
1719 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1720
1721 io_delegate_.SetFileContents("p/IFoo.aidl",
1722 "package p; interface IFoo {"
1723 "Map<Bar, Bar> foo();}");
Devin Moore097a3ab2020-03-11 16:08:44 -07001724 CaptureStderr();
Jeongik Chae48d9942020-01-02 17:39:00 +09001725 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001726 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jeongik Chae48d9942020-01-02 17:39:00 +09001727
1728 io_delegate_.SetFileContents("p/IFoo.aidl",
1729 "package p; interface IFoo {"
1730 "Map<String, String> foo();}");
1731 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1732
1733 io_delegate_.SetFileContents("p/IFoo.aidl",
1734 "package p; interface IFoo {"
1735 "Map<String, ParcelFileDescriptor> foo();}");
1736 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1737}
1738
Jeongik Chadf76dc72019-11-28 00:08:47 +09001739TEST_F(AidlTest, WrongGenericType) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001740 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 +09001741 Options options = Options::From("aidl p/IFoo.aidl IFoo.java");
1742 io_delegate_.SetFileContents(options.InputFiles().front(),
1743 "package p; interface IFoo {"
1744 "String<String> foo(); }");
Devin Moore097a3ab2020-03-11 16:08:44 -07001745 CaptureStderr();
Jeongik Chadf76dc72019-11-28 00:08:47 +09001746 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001747 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jeongik Chadf76dc72019-11-28 00:08:47 +09001748}
1749
1750TEST_F(AidlTest, UserDefinedUnstructuredGenericParcelableType) {
1751 Options optionsForParcelable = Options::From("aidl -I p p/Bar.aidl");
1752 io_delegate_.SetFileContents("p/Bar.aidl", "package p; parcelable Bar<T, T>;");
Devin Moore097a3ab2020-03-11 16:08:44 -07001753 CaptureStderr();
Jeongik Chadf76dc72019-11-28 00:08:47 +09001754 EXPECT_NE(0, ::android::aidl::compile_aidl(optionsForParcelable, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001755 EXPECT_EQ("ERROR: p/Bar.aidl:1.22-26: Every type parameter should be unique.\n",
1756 GetCapturedStderr());
Jeongik Chadf76dc72019-11-28 00:08:47 +09001757
1758 Options options = Options::From("aidl -I p p/IFoo.aidl");
1759 io_delegate_.SetFileContents("p/Bar.aidl", "package p; parcelable Bar;");
1760 io_delegate_.SetFileContents("p/IFoo.aidl",
1761 "package p; interface IFoo {"
1762 "Bar<String, String> foo();}");
Devin Moore097a3ab2020-03-11 16:08:44 -07001763 CaptureStderr();
Jeongik Chadf76dc72019-11-28 00:08:47 +09001764 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001765 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 +09001766 io_delegate_.SetFileContents("p/Bar.aidl", "package p; parcelable Bar<T>;");
Devin Moore097a3ab2020-03-11 16:08:44 -07001767 CaptureStderr();
Jeongik Chadf76dc72019-11-28 00:08:47 +09001768 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001769 EXPECT_EQ("ERROR: p/IFoo.aidl:1.28-31: p.Bar must have 1 type parameters, but got 2\n",
1770 GetCapturedStderr());
Jeongik Chadf76dc72019-11-28 00:08:47 +09001771 io_delegate_.SetFileContents("p/Bar.aidl", "package p; parcelable Bar<T, V>;");
1772 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1773 io_delegate_.SetFileContents("p/IFoo.aidl",
1774 "package p; interface IFoo {"
1775 "Bar<String, ParcelFileDescriptor> foo();}");
1776 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jeongik Chae74c86d2019-12-12 16:54:03 +09001777
1778 io_delegate_.SetFileContents("p/IFoo.aidl",
1779 "package p; interface IFoo {"
1780 "Bar<int, long> foo();}");
1781
1782 io_delegate_.SetFileContents("p/IFoo.aidl",
1783 "package p; interface IFoo {"
1784 "Bar<int[], long[]> foo();}");
1785
1786 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jeongik Chadf76dc72019-11-28 00:08:47 +09001787}
1788
Jeongik Cha0e426012019-07-29 15:57:02 +09001789TEST_F(AidlTest, FailOnMultipleTypesInSingleFile) {
1790 std::vector<std::string> rawOptions{"aidl --lang=java -o out foo/bar/Foo.aidl",
Andrei Homescub62afd92020-05-11 19:24:59 -07001791 "aidl --lang=cpp -o out -h out/include foo/bar/Foo.aidl",
1792 "aidl --lang=rust -o out foo/bar/Foo.aidl"};
Devin Moore5de18ed2020-04-02 13:52:29 -07001793 for (const auto& rawOption : rawOptions) {
1794 string expected_stderr =
1795 "ERROR: foo/bar/Foo.aidl:3.1-10: You must declare only one type per file.\n";
Jeongik Cha0e426012019-07-29 15:57:02 +09001796 Options options = Options::From(rawOption);
1797 io_delegate_.SetFileContents(options.InputFiles().front(),
1798 "package foo.bar;\n"
1799 "interface IFoo1 { int foo(); }\n"
1800 "interface IFoo2 { int foo(); }\n"
1801 "parcelable Data1 { int a; int b;}\n"
1802 "parcelable Data2 { int a; int b;}\n");
Devin Moore097a3ab2020-03-11 16:08:44 -07001803 CaptureStderr();
Jeongik Cha0e426012019-07-29 15:57:02 +09001804 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001805 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Parkb034bf02018-07-30 17:44:33 +09001806
Jeongik Cha0e426012019-07-29 15:57:02 +09001807 io_delegate_.SetFileContents(options.InputFiles().front(),
1808 "package foo.bar;\n"
1809 "interface IFoo1 { int foo(); }\n"
1810 "interface IFoo2 { int foo(); }\n");
Devin Moore097a3ab2020-03-11 16:08:44 -07001811 CaptureStderr();
Jeongik Cha0e426012019-07-29 15:57:02 +09001812 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001813 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Parkb034bf02018-07-30 17:44:33 +09001814
Devin Moore5de18ed2020-04-02 13:52:29 -07001815 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 +09001816 io_delegate_.SetFileContents(options.InputFiles().front(),
1817 "package foo.bar;\n"
1818 "parcelable Data1 { int a; int b;}\n"
1819 "parcelable Data2 { int a; int b;}\n");
Devin Moore097a3ab2020-03-11 16:08:44 -07001820 CaptureStderr();
Jeongik Cha0e426012019-07-29 15:57:02 +09001821 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001822 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Parkb034bf02018-07-30 17:44:33 +09001823 }
1824}
1825
Devin Moorebdba2a82020-03-31 15:19:02 -07001826TEST_P(AidlTest, FailParseOnEmptyFile) {
1827 const string contents = "";
1828 const string expected_stderr = "ERROR: a/IFoo.aidl:1.1-1: syntax error, unexpected $end\n";
1829 CaptureStderr();
1830 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", contents, typenames_, GetLanguage()));
1831 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1832}
1833
Jiyong Parkb034bf02018-07-30 17:44:33 +09001834TEST_F(AidlTest, MultipleInputFiles) {
1835 Options options = Options::From(
Jiyong Park633246c2019-11-25 10:50:05 +09001836 "aidl --lang=java -o out -I . foo/bar/IFoo.aidl foo/bar/Data.aidl");
Jiyong Parkb034bf02018-07-30 17:44:33 +09001837
1838 io_delegate_.SetFileContents(options.InputFiles().at(0),
1839 "package foo.bar;\n"
1840 "import foo.bar.Data;\n"
1841 "interface IFoo { Data getData(); }\n");
1842
1843 io_delegate_.SetFileContents(options.InputFiles().at(1),
1844 "package foo.bar;\n"
1845 "import foo.bar.IFoo;\n"
1846 "parcelable Data { IFoo foo; }\n");
1847
1848 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1849
1850 string content;
1851 for (const auto file : {
1852 "out/foo/bar/IFoo.java", "out/foo/bar/Data.java"}) {
1853 content.clear();
1854 EXPECT_TRUE(io_delegate_.GetWrittenContents(file, &content));
1855 EXPECT_FALSE(content.empty());
1856 }
1857}
1858
1859TEST_F(AidlTest, MultipleInputFilesCpp) {
1860 Options options = Options::From("aidl --lang=cpp -o out -h out/include "
Jiyong Park633246c2019-11-25 10:50:05 +09001861 "-I . foo/bar/IFoo.aidl foo/bar/Data.aidl");
Jiyong Parkb034bf02018-07-30 17:44:33 +09001862
1863 io_delegate_.SetFileContents(options.InputFiles().at(0),
1864 "package foo.bar;\n"
1865 "import foo.bar.Data;\n"
1866 "interface IFoo { Data getData(); }\n");
1867
1868 io_delegate_.SetFileContents(options.InputFiles().at(1),
1869 "package foo.bar;\n"
1870 "import foo.bar.IFoo;\n"
1871 "parcelable Data { IFoo foo; }\n");
1872
1873 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1874
1875 string content;
1876 for (const auto file : {
Jiyong Parkb03551f2018-08-06 19:20:51 +09001877 "out/foo/bar/IFoo.cpp", "out/foo/bar/Data.cpp",
Jiyong Parkb034bf02018-07-30 17:44:33 +09001878 "out/include/foo/bar/IFoo.h", "out/include/foo/bar/Data.h",
1879 "out/include/foo/bar/BpFoo.h", "out/include/foo/bar/BpData.h",
1880 "out/include/foo/bar/BnFoo.h", "out/include/foo/bar/BnData.h"}) {
1881 content.clear();
1882 EXPECT_TRUE(io_delegate_.GetWrittenContents(file, &content));
1883 EXPECT_FALSE(content.empty());
1884 }
Jiyong Park1d2df7d2018-07-23 15:22:50 +09001885}
1886
Andrei Homescub62afd92020-05-11 19:24:59 -07001887TEST_F(AidlTest, MultipleInputFilesRust) {
1888 Options options =
1889 Options::From("aidl --lang=rust -o out -I . foo/bar/IFoo.aidl foo/bar/Data.aidl");
1890
1891 io_delegate_.SetFileContents(options.InputFiles().at(0),
1892 "package foo.bar;\n"
1893 "import foo.bar.Data;\n"
1894 "interface IFoo { Data getData(); }\n");
1895
1896 io_delegate_.SetFileContents(options.InputFiles().at(1),
1897 "package foo.bar;\n"
1898 "import foo.bar.IFoo;\n"
1899 "parcelable Data { IFoo foo; }\n");
1900
1901 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1902
1903 string content;
1904 for (const auto file : {"out/foo/bar/IFoo.rs", "out/foo/bar/Data.rs"}) {
1905 content.clear();
1906 EXPECT_TRUE(io_delegate_.GetWrittenContents(file, &content));
1907 EXPECT_FALSE(content.empty());
1908 }
1909}
1910
Devin Moore097a3ab2020-03-11 16:08:44 -07001911TEST_F(AidlTest, ConflictWithMetaTransactionGetVersion) {
1912 const string expected_stderr =
1913 "ERROR: p/IFoo.aidl:1.31-51: method getInterfaceVersion() is reserved for internal use.\n";
Jiyong Park309668e2018-07-28 16:55:44 +09001914 Options options = Options::From("aidl --lang=java -o place/for/output p/IFoo.aidl");
1915 // int getInterfaceVersion() is one of the meta transactions
1916 io_delegate_.SetFileContents(options.InputFiles().front(),
1917 "package p; interface IFoo {"
1918 "int getInterfaceVersion(); }");
Devin Moore097a3ab2020-03-11 16:08:44 -07001919 CaptureStderr();
Jiyong Parkb034bf02018-07-30 17:44:33 +09001920 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001921 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1922}
Jiyong Park309668e2018-07-28 16:55:44 +09001923
Devin Moore097a3ab2020-03-11 16:08:44 -07001924TEST_F(AidlTest, ConflictWithSimilarMetaTransaction) {
1925 // boolean getInterfaceVersion() is not a meta transaction, but should be
1926 // prevented because return type is not part of a method signature
1927 const string expected_stderr =
1928 "ERROR: p/IFoo.aidl:1.35-55: method getInterfaceVersion() is reserved for internal use.\n";
1929 Options options = Options::From("aidl --lang=java -o place/for/output p/IFoo.aidl");
Jiyong Park309668e2018-07-28 16:55:44 +09001930 io_delegate_.SetFileContents(options.InputFiles().front(),
1931 "package p; interface IFoo {"
1932 "boolean getInterfaceVersion(); }");
Devin Moore097a3ab2020-03-11 16:08:44 -07001933 CaptureStderr();
Jiyong Parkb034bf02018-07-30 17:44:33 +09001934 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001935 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1936}
Jiyong Park309668e2018-07-28 16:55:44 +09001937
Devin Moore097a3ab2020-03-11 16:08:44 -07001938TEST_F(AidlTest, ConflictWithMetaTransactionGetName) {
Jiyong Park309668e2018-07-28 16:55:44 +09001939 // this is another reserved name
Devin Moore097a3ab2020-03-11 16:08:44 -07001940 const string expected_stderr =
1941 "ERROR: p/IFoo.aidl:1.34-53: method getTransactionName(int) is reserved for internal use.\n";
1942 Options options = Options::From("aidl --lang=java -o place/for/output p/IFoo.aidl");
Jiyong Park309668e2018-07-28 16:55:44 +09001943 io_delegate_.SetFileContents(options.InputFiles().front(),
1944 "package p; interface IFoo {"
1945 "String getTransactionName(int code); }");
Devin Moore097a3ab2020-03-11 16:08:44 -07001946 CaptureStderr();
Jiyong Parkb034bf02018-07-30 17:44:33 +09001947 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001948 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Park309668e2018-07-28 16:55:44 +09001949
1950 // this is not a meta interface method as it differs type arguments
1951 io_delegate_.SetFileContents(options.InputFiles().front(),
1952 "package p; interface IFoo {"
1953 "String getTransactionName(); }");
Jiyong Parkb034bf02018-07-30 17:44:33 +09001954 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jiyong Park309668e2018-07-28 16:55:44 +09001955}
1956
Jooyung Hanb8a97772021-01-19 01:27:38 +09001957TEST_F(AidlTest, CheckApiForEquality) {
1958 CaptureStderr();
1959 Options options = Options::From("aidl --checkapi=equal old new");
1960
1961 io_delegate_.SetFileContents("old/p/IFoo.aidl",
1962 "package p; interface IFoo{ @utf8InCpp @nullable String foo();}");
1963 io_delegate_.SetFileContents("new/p/IFoo.aidl",
1964 "package p; interface IFoo{ @utf8InCpp String foo();}");
1965
1966 EXPECT_FALSE(::android::aidl::check_api(options, io_delegate_));
1967 EXPECT_THAT(GetCapturedStderr(), HasSubstr("+ @utf8InCpp String foo();"));
1968}
1969
Daniel Norman85aed542019-08-21 12:01:14 -07001970TEST_F(AidlTest, DifferentOrderAnnotationsInCheckAPI) {
Jeongik Cha3271ffa2018-12-04 15:19:20 +09001971 Options options = Options::From("aidl --checkapi old new");
1972 io_delegate_.SetFileContents("old/p/IFoo.aidl",
1973 "package p; interface IFoo{ @utf8InCpp @nullable String foo();}");
1974 io_delegate_.SetFileContents("new/p/IFoo.aidl",
1975 "package p; interface IFoo{ @nullable @utf8InCpp String foo();}");
1976
1977 EXPECT_TRUE(::android::aidl::check_api(options, io_delegate_));
1978}
1979
Jiyong Park3656c3c2018-08-01 20:02:01 +09001980TEST_F(AidlTest, SuccessOnIdenticalApiDumps) {
Jiyong Parke59c3682018-09-11 23:10:25 +09001981 Options options = Options::From("aidl --checkapi old new");
1982 io_delegate_.SetFileContents("old/p/IFoo.aidl", "package p; interface IFoo{ void foo();}");
1983 io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p; interface IFoo{ void foo();}");
Jiyong Park3656c3c2018-08-01 20:02:01 +09001984
1985 EXPECT_TRUE(::android::aidl::check_api(options, io_delegate_));
1986}
1987
Jooyung Hanfdaae1d2020-12-14 13:16:15 +09001988TEST_F(AidlTest, CheckApi_EnumFieldsWithDefaultValues) {
1989 Options options = Options::From("aidl --checkapi old new");
1990 const string foo_definition = "package p; parcelable Foo{ p.Enum e = p.Enum.FOO; }";
1991 const string enum_definition = "package p; enum Enum { FOO }";
1992 io_delegate_.SetFileContents("old/p/Foo.aidl", foo_definition);
1993 io_delegate_.SetFileContents("old/p/Enum.aidl", enum_definition);
1994 io_delegate_.SetFileContents("new/p/Foo.aidl", foo_definition);
1995 io_delegate_.SetFileContents("new/p/Enum.aidl", enum_definition);
1996
1997 EXPECT_TRUE(::android::aidl::check_api(options, io_delegate_));
1998}
1999
Jooyung Han8e3b72c2021-05-22 02:54:37 +09002000TEST_F(AidlTest, CheckApi_EnumFieldsFromImported) {
2001 Options options = Options::From("aidl --checkapi old new -I import");
2002
2003 io_delegate_.SetFileContents("old/p/Foo.aidl", "package p; parcelable Foo{ other.Enum e; }");
2004 io_delegate_.SetFileContents("new/p/Foo.aidl",
2005 "package p; parcelable Foo{ other.Enum e = other.Enum.FOO; }");
2006 io_delegate_.SetFileContents("import/other/Enum.aidl", "package other; enum Enum { FOO }");
2007
2008 EXPECT_TRUE(::android::aidl::check_api(options, io_delegate_));
2009}
2010
Jooyung Han02a11be2021-02-11 13:18:06 +09002011TEST_F(AidlTest, CheckApiEqual_EnumFieldsWithDefaultValues) {
2012 Options options = Options::From("aidl --checkapi=equal old new");
2013 const string foo_definition = "package p; parcelable Foo{ p.Enum e = p.Enum.FOO; }";
2014 const string enum_definition = "package p; enum Enum { FOO }";
2015 io_delegate_.SetFileContents("old/p/Foo.aidl", foo_definition);
2016 io_delegate_.SetFileContents("old/p/Enum.aidl", enum_definition);
2017 io_delegate_.SetFileContents("new/p/Foo.aidl", foo_definition);
2018 io_delegate_.SetFileContents("new/p/Enum.aidl", enum_definition);
2019 CaptureStderr();
2020 EXPECT_TRUE(::android::aidl::check_api(options, io_delegate_));
2021 EXPECT_EQ("", GetCapturedStderr());
2022}
2023
Daniel Norman85aed542019-08-21 12:01:14 -07002024class AidlTestCompatibleChanges : public AidlTest {
2025 protected:
2026 Options options_ = Options::From("aidl --checkapi old new");
2027};
2028
2029TEST_F(AidlTestCompatibleChanges, NewType) {
2030 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2031 "package p;"
2032 "interface IFoo {"
2033 " void foo(int a);"
2034 "}");
2035 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2036 "package p;"
2037 "interface IFoo {"
2038 " void foo(int a);"
2039 "}");
2040 io_delegate_.SetFileContents("new/p/IBar.aidl",
2041 "package p;"
2042 "interface IBar {"
2043 " void bar();"
2044 "}");
2045 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2046}
2047
2048TEST_F(AidlTestCompatibleChanges, NewMethod) {
2049 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2050 "package p;"
2051 "interface IFoo {"
2052 " void foo(int a);"
2053 "}");
2054 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2055 "package p;"
2056 "interface IFoo {"
2057 " void foo(int a);"
2058 " void bar();"
Jooyung Han8e3b72c2021-05-22 02:54:37 +09002059 " void baz(in List<String> arg);"
Daniel Norman85aed542019-08-21 12:01:14 -07002060 "}");
2061 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2062}
2063
2064TEST_F(AidlTestCompatibleChanges, NewField) {
2065 io_delegate_.SetFileContents("old/p/Data.aidl",
2066 "package p;"
2067 "parcelable Data {"
2068 " int foo;"
2069 "}");
2070 io_delegate_.SetFileContents("new/p/Data.aidl",
2071 "package p;"
2072 "parcelable Data {"
2073 " int foo;"
Steven Moreland370ed342020-04-28 18:14:39 -07002074 " int bar = 0;"
Jiyong Parkf8d53612020-05-04 14:06:13 +09002075 " @nullable List<Data> list;"
Daniel Norman85aed542019-08-21 12:01:14 -07002076 "}");
2077 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2078}
2079
Jooyung Han05bd8a82021-04-28 23:56:38 +09002080TEST_F(AidlTestCompatibleChanges, NewField2) {
2081 io_delegate_.SetFileContents("old/p/Data.aidl",
2082 "package p;"
2083 "parcelable Data {"
2084 "}");
2085 io_delegate_.SetFileContents("new/p/Data.aidl",
2086 "package p;"
2087 "parcelable Data {"
2088 " int foo = 0;"
2089 "}");
2090 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2091}
2092
Daniel Norman85aed542019-08-21 12:01:14 -07002093TEST_F(AidlTestCompatibleChanges, NewEnumerator) {
2094 io_delegate_.SetFileContents("old/p/Enum.aidl",
2095 "package p;"
2096 "enum Enum {"
2097 " FOO = 1,"
2098 "}");
2099 io_delegate_.SetFileContents("new/p/Enum.aidl",
2100 "package p;"
2101 "enum Enum {"
2102 " FOO = 1,"
2103 " BAR = 2,"
2104 "}");
2105 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2106}
2107
2108TEST_F(AidlTestCompatibleChanges, ReorderedEnumerator) {
2109 io_delegate_.SetFileContents("old/p/Enum.aidl",
2110 "package p;"
2111 "enum Enum {"
2112 " FOO = 1,"
2113 " BAR = 2,"
2114 "}");
2115 io_delegate_.SetFileContents("new/p/Enum.aidl",
2116 "package p;"
2117 "enum Enum {"
2118 " BAR = 2,"
2119 " FOO = 1,"
2120 "}");
2121 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2122}
2123
Jooyung Hanb5c55cd2020-10-22 07:59:01 +09002124TEST_F(AidlTestCompatibleChanges, NewUnionField) {
2125 io_delegate_.SetFileContents("old/p/Union.aidl",
2126 "package p;"
2127 "union Union {"
2128 " String foo;"
2129 "}");
2130 io_delegate_.SetFileContents("new/p/Union.aidl",
2131 "package p;"
2132 "union Union {"
2133 " String foo;"
2134 " int num;"
2135 "}");
2136 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2137}
2138
Daniel Norman85aed542019-08-21 12:01:14 -07002139TEST_F(AidlTestCompatibleChanges, NewPackage) {
Jiyong Parke59c3682018-09-11 23:10:25 +09002140 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2141 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002142 "interface IFoo {"
2143 " void foo(int a);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002144 "}");
2145 io_delegate_.SetFileContents("old/p/Data.aidl",
2146 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002147 "parcelable Data {"
2148 " int foo;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002149 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002150 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2151 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002152 "interface IFoo {"
2153 " void foo(int a);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002154 "}");
2155 io_delegate_.SetFileContents("new/p/Data.aidl",
2156 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002157 "parcelable Data {"
2158 " int foo;"
Jiyong Parke59c3682018-09-11 23:10:25 +09002159 "}");
2160 io_delegate_.SetFileContents("new/q/IFoo.aidl",
2161 "package q;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002162 "interface IFoo {"
Jiyong Parke59c3682018-09-11 23:10:25 +09002163 " void foo(int a);"
2164 "}");
2165 io_delegate_.SetFileContents("new/q/Data.aidl",
2166 "package q;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002167 "parcelable Data {"
2168 " int foo;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002169 "}");
Daniel Norman85aed542019-08-21 12:01:14 -07002170 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2171}
Jiyong Park3656c3c2018-08-01 20:02:01 +09002172
Daniel Norman85aed542019-08-21 12:01:14 -07002173TEST_F(AidlTestCompatibleChanges, ArgNameChange) {
2174 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2175 "package p;"
2176 "interface IFoo {"
2177 " void foo(int a);"
2178 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002179 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2180 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002181 "interface IFoo {"
2182 " void foo(int b);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002183 "}");
Daniel Norman85aed542019-08-21 12:01:14 -07002184 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2185}
Jiyong Parke59c3682018-09-11 23:10:25 +09002186
Daniel Norman85aed542019-08-21 12:01:14 -07002187TEST_F(AidlTestCompatibleChanges, AddedConstValue) {
Jiyong Parke59c3682018-09-11 23:10:25 +09002188 io_delegate_.SetFileContents("old/p/I.aidl",
2189 "package p; interface I {"
2190 "const int A = 1; }");
2191 io_delegate_.SetFileContents("new/p/I.aidl",
2192 "package p ; interface I {"
2193 "const int A = 1; const int B = 2;}");
Daniel Norman85aed542019-08-21 12:01:14 -07002194 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2195}
Jiyong Parka428d212018-08-29 22:26:30 +09002196
Daniel Norman85aed542019-08-21 12:01:14 -07002197TEST_F(AidlTestCompatibleChanges, ChangedConstValueOrder) {
Jiyong Parke59c3682018-09-11 23:10:25 +09002198 io_delegate_.SetFileContents("old/p/I.aidl",
2199 "package p; interface I {"
2200 "const int A = 1; const int B = 2;}");
2201 io_delegate_.SetFileContents("new/p/I.aidl",
2202 "package p ; interface I {"
2203 "const int B = 2; const int A = 1;}");
Daniel Norman85aed542019-08-21 12:01:14 -07002204 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
Jiyong Park3656c3c2018-08-01 20:02:01 +09002205}
2206
Jooyung Han69ea4ba2020-10-29 15:33:37 +09002207TEST_F(AidlTestCompatibleChanges, ReorderedAnnatations) {
2208 io_delegate_.SetFileContents("old/p/Foo.aidl",
2209 "package p;"
2210 "@JavaPassthrough(annotation=\"Alice\")"
2211 "@JavaPassthrough(annotation=\"Bob\")"
2212 "parcelable Foo {}");
2213 io_delegate_.SetFileContents("new/p/Foo.aidl",
2214 "package p;"
2215 "@JavaPassthrough(annotation=\"Bob\")"
2216 "@JavaPassthrough(annotation=\"Alice\")"
2217 "parcelable Foo {}");
2218 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2219}
2220
Jooyung Han00073272020-11-27 14:20:20 +09002221TEST_F(AidlTestCompatibleChanges, OkayToDeprecate) {
2222 io_delegate_.SetFileContents("old/p/Foo.aidl",
2223 "package p;"
2224 "parcelable Foo {}");
2225 io_delegate_.SetFileContents("new/p/Foo.aidl",
2226 "package p;"
2227 "@JavaPassthrough(annotation=\"@Deprecated\")"
2228 "parcelable Foo {}");
2229 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2230}
2231
Jooyung Han636fd2f2020-10-22 11:33:45 +09002232TEST_F(AidlTestCompatibleChanges, NewFieldOfNewType) {
2233 io_delegate_.SetFileContents("old/p/Data.aidl",
2234 "package p;"
2235 "parcelable Data {"
2236 " int num;"
2237 "}");
2238 io_delegate_.SetFileContents(
2239 "new/p/Data.aidl",
2240 "package p;"
2241 "parcelable Data {"
2242 " int num;"
2243 " p.Enum e;" // this is considered as valid since 0(enum default) is valid for "Enum" type
2244 "}");
2245 io_delegate_.SetFileContents("new/p/Enum.aidl",
2246 "package p;"
2247 "enum Enum {"
2248 " FOO = 0,"
2249 " BAR = 1,"
2250 "}");
2251 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2252}
2253
Jooyung Han308bbe02021-04-27 12:09:59 +09002254TEST_F(AidlTestCompatibleChanges, CompatibleExplicitDefaults) {
2255 io_delegate_.SetFileContents("old/p/Data.aidl",
2256 "package p;\n"
2257 "parcelable Data {\n"
2258 " p.Enum e;\n"
2259 "}");
2260 io_delegate_.SetFileContents("old/p/Enum.aidl",
2261 "package p;\n"
2262 "enum Enum {\n"
2263 " FOO = 0,\n"
2264 " BAR = 1,\n"
2265 "}");
2266 io_delegate_.SetFileContents("new/p/Data.aidl",
2267 "package p;\n"
2268 "parcelable Data {\n"
2269 " p.Enum e = p.Enum.FOO;\n"
2270 "}");
2271 io_delegate_.SetFileContents("new/p/Enum.aidl",
2272 "package p;\n"
2273 "enum Enum {\n"
2274 " FOO = 0,\n"
2275 " BAR = 1,\n"
2276 "}");
2277 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2278}
2279
Daniel Norman85aed542019-08-21 12:01:14 -07002280class AidlTestIncompatibleChanges : public AidlTest {
2281 protected:
2282 Options options_ = Options::From("aidl --checkapi old new");
2283};
2284
2285TEST_F(AidlTestIncompatibleChanges, RemovedType) {
Jiyong Park0cf03b12020-07-22 19:36:34 +09002286 const string expected_stderr = "ERROR: old/p/IFoo.aidl:1.11-20: Removed type: p.IFoo\n";
Jiyong Parke59c3682018-09-11 23:10:25 +09002287 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2288 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002289 "interface IFoo {"
2290 " void foo(in String[] str);"
2291 " void bar(@utf8InCpp String str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002292 "}");
Devin Moored131d5e2020-03-31 10:39:10 -07002293 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002294 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moored131d5e2020-03-31 10:39:10 -07002295 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002296}
2297
2298TEST_F(AidlTestIncompatibleChanges, RemovedMethod) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002299 const string expected_stderr =
2300 "ERROR: old/p/IFoo.aidl:1.61-65: Removed or changed method: p.IFoo.bar(String)\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002301 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2302 "package p;"
2303 "interface IFoo {"
2304 " void foo(in String[] str);"
2305 " void bar(@utf8InCpp String str);"
2306 "}");
2307 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2308 "package p;"
2309 "interface IFoo {"
2310 " void foo(in String[] str);"
2311 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002312 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002313 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002314 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002315}
2316
Jiyong Parkf8d53612020-05-04 14:06:13 +09002317TEST_F(AidlTestIncompatibleChanges, UntypedListInInterface) {
2318 const string expected_stderr =
2319 "ERROR: new/p/IFoo.aidl:1.61-65: "
2320 "Encountered an untyped List or Map. The use of untyped List/Map is "
2321 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
2322 "the receiving side. Consider switching to an array or a generic List/Map.\n"
2323 "ERROR: new/p/IFoo.aidl: Failed to read.\n";
2324 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2325 "package p;"
2326 "interface IFoo {"
2327 " void foo(in String[] str);"
2328 "}");
2329 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2330 "package p;"
2331 "interface IFoo {"
2332 " void foo(in String[] str);"
2333 " void bar(in List arg);"
2334 "}");
2335 CaptureStderr();
2336 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2337 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2338}
2339
2340TEST_F(AidlTestCompatibleChanges, UntypedListInParcelable) {
2341 const string expected_stderr =
2342 "ERROR: new/p/Data.aidl:1.54-59: "
2343 "Encountered an untyped List or Map. The use of untyped List/Map is "
2344 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
2345 "the receiving side. Consider switching to an array or a generic List/Map.\n"
2346 "ERROR: new/p/Data.aidl: Failed to read.\n";
2347 io_delegate_.SetFileContents("old/p/Data.aidl",
2348 "package p;"
2349 "parcelable Data {"
2350 " int foo;"
2351 "}");
2352 io_delegate_.SetFileContents("new/p/Data.aidl",
2353 "package p;"
2354 "parcelable Data {"
2355 " int foo;"
2356 " @nullable List list;"
2357 "}");
2358 CaptureStderr();
2359 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2360 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2361}
2362
Daniel Norman85aed542019-08-21 12:01:14 -07002363TEST_F(AidlTestIncompatibleChanges, RemovedField) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002364 const string expected_stderr =
2365 "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 +09002366 io_delegate_.SetFileContents("old/p/Data.aidl",
2367 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002368 "parcelable Data {"
2369 " int foo;"
2370 " int bar;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002371 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002372 io_delegate_.SetFileContents("new/p/Data.aidl",
2373 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002374 "parcelable Data {"
2375 " int foo;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002376 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002377 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002378 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002379 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002380}
Jiyong Park3656c3c2018-08-01 20:02:01 +09002381
Jooyung Hanb5c55cd2020-10-22 07:59:01 +09002382TEST_F(AidlTestIncompatibleChanges, NewFieldWithNoDefault) {
2383 const string expected_stderr =
2384 "ERROR: new/p/Data.aidl:1.46-50: Field 'str' does not have a useful default in some "
2385 "backends. Please either provide a default value for this field or mark the field as "
2386 "@nullable. This value or a null value will be used automatically when an old version of "
2387 "this parcelable is sent to a process which understands a new version of this parcelable. In "
2388 "order to make sure your code continues to be backwards compatible, make sure the default or "
2389 "null value does not cause a semantic change to this parcelable.\n";
2390 io_delegate_.SetFileContents("old/p/Data.aidl",
2391 "package p;"
2392 "parcelable Data {"
2393 " int num;"
2394 "}");
2395 io_delegate_.SetFileContents("new/p/Data.aidl",
2396 "package p;"
2397 "parcelable Data {"
2398 " int num;"
2399 " String str;"
2400 "}");
2401 CaptureStderr();
2402 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2403 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2404}
2405
Jooyung Han636fd2f2020-10-22 11:33:45 +09002406TEST_F(AidlTestIncompatibleChanges, NewFieldWithNonZeroEnum) {
2407 const string expected_stderr =
2408 "ERROR: new/p/Data.aidl:1.46-48: Field 'e' of enum 'Enum' can't be initialized as '0'. "
2409 "Please make sure 'Enum' has '0' as a valid value.\n";
2410 io_delegate_.SetFileContents("old/p/Data.aidl",
2411 "package p;"
2412 "parcelable Data {"
2413 " int num;"
2414 "}");
2415 io_delegate_.SetFileContents("new/p/Data.aidl",
2416 "package p;"
2417 "parcelable Data {"
2418 " int num;"
2419 " p.Enum e;"
2420 "}");
2421 io_delegate_.SetFileContents("new/p/Enum.aidl",
2422 "package p;"
2423 "enum Enum {"
2424 " FOO = 1,"
2425 " BAR = 2,"
2426 "}");
2427 CaptureStderr();
2428 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2429 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2430}
2431
Daniel Norman85aed542019-08-21 12:01:14 -07002432TEST_F(AidlTestIncompatibleChanges, RemovedEnumerator) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002433 const string expected_stderr =
2434 "ERROR: new/p/Enum.aidl:1.15-20: Removed enumerator from p.Enum: FOO\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002435 io_delegate_.SetFileContents("old/p/Enum.aidl",
2436 "package p;"
2437 "enum Enum {"
2438 " FOO = 1,"
2439 " BAR = 2,"
2440 "}");
2441 io_delegate_.SetFileContents("new/p/Enum.aidl",
2442 "package p;"
2443 "enum Enum {"
2444 " BAR = 2,"
2445 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002446 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002447 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002448 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002449}
2450
Jooyung Hanb5c55cd2020-10-22 07:59:01 +09002451TEST_F(AidlTestIncompatibleChanges, RemovedUnionField) {
2452 const string expected_stderr =
2453 "ERROR: new/p/Union.aidl:1.16-22: Number of fields in p.Union is reduced from 2 to 1.\n";
2454 io_delegate_.SetFileContents("old/p/Union.aidl",
2455 "package p;"
2456 "union Union {"
2457 " String str;"
2458 " int num;"
2459 "}");
2460 io_delegate_.SetFileContents("new/p/Union.aidl",
2461 "package p;"
2462 "union Union {"
2463 " String str;"
2464 "}");
2465 CaptureStderr();
2466 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2467 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2468}
2469
Daniel Norman85aed542019-08-21 12:01:14 -07002470TEST_F(AidlTestIncompatibleChanges, RenamedMethod) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002471 const string expected_stderr =
2472 "ERROR: old/p/IFoo.aidl:1.61-65: Removed or changed method: p.IFoo.bar(String)\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002473 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2474 "package p;"
2475 "interface IFoo {"
2476 " void foo(in String[] str);"
2477 " void bar(@utf8InCpp String str);"
2478 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002479 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2480 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002481 "interface IFoo {"
2482 " void foo(in String[] str);"
2483 " void bar2(@utf8InCpp String str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002484 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002485 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002486 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002487 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002488}
2489
Daniel Norman85aed542019-08-21 12:01:14 -07002490TEST_F(AidlTestIncompatibleChanges, RenamedType) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002491 const string expected_stderr = "ERROR: old/p/IFoo.aidl:1.11-20: Removed type: p.IFoo\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002492 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2493 "package p;"
2494 "interface IFoo {"
2495 " void foo(in String[] str);"
2496 " void bar(@utf8InCpp String str);"
2497 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002498 io_delegate_.SetFileContents("new/p/IFoo2.aidl",
2499 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002500 "interface IFoo2 {"
2501 " void foo(in String[] str);"
2502 " void bar(@utf8InCpp String str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002503 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002504 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002505 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002506 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002507}
Jiyong Park3656c3c2018-08-01 20:02:01 +09002508
Daniel Norman85aed542019-08-21 12:01:14 -07002509TEST_F(AidlTestIncompatibleChanges, ChangedEnumerator) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002510 const string expected_stderr =
2511 "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 -07002512 io_delegate_.SetFileContents("old/p/Enum.aidl",
2513 "package p;"
2514 "enum Enum {"
2515 " FOO = 1,"
2516 " BAR = 2,"
2517 "}");
2518 io_delegate_.SetFileContents("new/p/Enum.aidl",
2519 "package p;"
2520 "enum Enum {"
2521 " FOO = 3,"
2522 " BAR = 2,"
2523 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002524 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002525 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002526 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002527}
2528
2529TEST_F(AidlTestIncompatibleChanges, ReorderedMethod) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002530 const string expected_stderr =
2531 "ERROR: new/p/IFoo.aidl:1.67-71: Transaction ID changed: p.IFoo.foo(String[]) is changed "
2532 "from 0 to 1.\n"
2533 "ERROR: new/p/IFoo.aidl:1.33-37: Transaction ID changed: p.IFoo.bar(String) is changed from "
2534 "1 to 0.\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002535 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2536 "package p;"
2537 "interface IFoo {"
2538 " void foo(in String[] str);"
2539 " void bar(@utf8InCpp String str);"
2540 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002541 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2542 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002543 "interface IFoo {"
2544 " void bar(@utf8InCpp String str);"
2545 " void foo(in String[] str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002546 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002547 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002548 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002549 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002550}
2551
2552TEST_F(AidlTestIncompatibleChanges, ReorderedField) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002553 const string expected_stderr =
Jiyong Parkb07d9932020-05-15 12:56:54 +09002554 "ERROR: new/p/Data.aidl:1.33-37: Reordered bar from 1 to 0.\n"
2555 "ERROR: new/p/Data.aidl:1.43-47: Reordered foo from 0 to 1.\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002556 io_delegate_.SetFileContents("old/p/Data.aidl",
Jiyong Parke59c3682018-09-11 23:10:25 +09002557 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002558 "parcelable Data {"
2559 " int foo;"
2560 " int bar;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002561 "}");
Daniel Norman85aed542019-08-21 12:01:14 -07002562 io_delegate_.SetFileContents("new/p/Data.aidl",
2563 "package p;"
2564 "parcelable Data {"
2565 " int bar;"
2566 " int foo;"
2567 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002568 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002569 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002570 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002571}
Jiyong Park3656c3c2018-08-01 20:02:01 +09002572
Daniel Norman85aed542019-08-21 12:01:14 -07002573TEST_F(AidlTestIncompatibleChanges, ChangedDirectionSpecifier) {
Devin Mooreeccdb902020-03-24 16:22:40 -07002574 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 -07002575 io_delegate_.SetFileContents("old/p/IFoo.aidl",
Jiyong Parke59c3682018-09-11 23:10:25 +09002576 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002577 "interface IFoo {"
2578 " void foo(in String[] str);"
2579 " void bar(@utf8InCpp String str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002580 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002581 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2582 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002583 "interface IFoo {"
2584 " void foo(out String[] str);"
2585 " void bar(@utf8InCpp String str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002586 "}");
Devin Mooreeccdb902020-03-24 16:22:40 -07002587 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002588 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Mooreeccdb902020-03-24 16:22:40 -07002589 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002590}
Jiyong Park3656c3c2018-08-01 20:02:01 +09002591
Daniel Norman85aed542019-08-21 12:01:14 -07002592TEST_F(AidlTestIncompatibleChanges, AddedAnnotation) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002593 const string expected_stderr =
2594 "ERROR: new/p/IFoo.aidl:1.51-58: Changed annotations: (empty) to @utf8InCpp\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002595 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2596 "package p;"
2597 "interface IFoo {"
2598 " void foo(in String[] str);"
2599 " void bar(@utf8InCpp String str);"
2600 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002601 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2602 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002603 "interface IFoo {"
Jiyong Parke59c3682018-09-11 23:10:25 +09002604 " void foo(in @utf8InCpp String[] str);"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002605 " void bar(@utf8InCpp String str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002606 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002607 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002608 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002609 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002610}
Jiyong Park3656c3c2018-08-01 20:02:01 +09002611
Daniel Norman85aed542019-08-21 12:01:14 -07002612TEST_F(AidlTestIncompatibleChanges, RemovedAnnotation) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002613 const string expected_stderr =
2614 "ERROR: new/p/IFoo.aidl:1.66-72: Changed annotations: @utf8InCpp to (empty)\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002615 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2616 "package p;"
2617 "interface IFoo {"
2618 " void foo(in String[] str);"
2619 " void bar(@utf8InCpp String str);"
2620 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002621 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2622 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002623 "interface IFoo {"
Jiyong Parke59c3682018-09-11 23:10:25 +09002624 " void foo(in String[] str);"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002625 " void bar(String str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002626 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002627 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002628 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002629 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002630}
Jiyong Park3656c3c2018-08-01 20:02:01 +09002631
Jooyung Han60b2fde2020-10-29 15:12:40 +09002632TEST_F(AidlTestIncompatibleChanges, ChangedBackingTypeOfEnum) {
2633 const string expected_stderr =
2634 "ERROR: new/p/Foo.aidl:1.11-32: Type changed: byte to long.\n"
2635 "ERROR: new/p/Foo.aidl:1.36-40: Changed backing types.\n";
2636 io_delegate_.SetFileContents("old/p/Foo.aidl",
2637 "package p;"
2638 "@Backing(type=\"byte\")"
2639 "enum Foo {"
2640 " FOO, BAR,"
2641 "}");
2642 io_delegate_.SetFileContents("new/p/Foo.aidl",
2643 "package p;"
2644 "@Backing(type=\"long\")"
2645 "enum Foo {"
2646 " FOO, BAR,"
2647 "}");
2648 CaptureStderr();
2649 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2650 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2651}
2652
Jooyung Han69ea4ba2020-10-29 15:33:37 +09002653TEST_F(AidlTestIncompatibleChanges, ChangedAnnatationParams) {
2654 const string expected_stderr =
2655 "ERROR: new/p/Foo.aidl:1.55-59: Changed annotations: @JavaPassthrough(annotation=\"Alice\") "
2656 "to @JavaPassthrough(annotation=\"Bob\")\n";
2657 io_delegate_.SetFileContents("old/p/Foo.aidl",
2658 "package p;"
2659 "@JavaPassthrough(annotation=\"Alice\")"
2660 "parcelable Foo {}");
2661 io_delegate_.SetFileContents("new/p/Foo.aidl",
2662 "package p;"
2663 "@JavaPassthrough(annotation=\"Bob\")"
2664 "parcelable Foo {}");
2665
2666 CaptureStderr();
2667 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2668 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2669}
2670
Devin Mooredb7ac512020-08-07 11:17:36 -07002671TEST_F(AidlTestIncompatibleChanges, AddedParcelableAnnotation) {
2672 const string expected_stderr =
Jooyung Han2d6b5c42021-01-09 01:01:06 +09002673 "ERROR: new/p/Foo.aidl:1.32-36: Changed annotations: (empty) to @FixedSize\n";
Devin Mooredb7ac512020-08-07 11:17:36 -07002674 io_delegate_.SetFileContents("old/p/Foo.aidl",
2675 "package p;"
2676 "parcelable Foo {"
2677 " int A;"
2678 "}");
2679 io_delegate_.SetFileContents("new/p/Foo.aidl",
2680 "package p;"
Jooyung Han2d6b5c42021-01-09 01:01:06 +09002681 "@FixedSize parcelable Foo {"
Devin Mooredb7ac512020-08-07 11:17:36 -07002682 " int A;"
2683 "}");
2684 CaptureStderr();
2685 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2686 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2687}
2688
2689TEST_F(AidlTestIncompatibleChanges, RemovedParcelableAnnotation) {
2690 const string expected_stderr =
Jooyung Han2d6b5c42021-01-09 01:01:06 +09002691 "ERROR: new/p/Foo.aidl:1.21-25: Changed annotations: @FixedSize to (empty)\n";
Devin Mooredb7ac512020-08-07 11:17:36 -07002692 io_delegate_.SetFileContents("old/p/Foo.aidl",
2693 "package p;"
Jooyung Han2d6b5c42021-01-09 01:01:06 +09002694 "@FixedSize parcelable Foo {"
Devin Mooredb7ac512020-08-07 11:17:36 -07002695 " int A;"
2696 "}");
2697 io_delegate_.SetFileContents("new/p/Foo.aidl",
2698 "package p;"
2699 "parcelable Foo {"
2700 " int A;"
2701 "}");
2702 CaptureStderr();
2703 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2704 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2705}
2706
Daniel Norman85aed542019-08-21 12:01:14 -07002707TEST_F(AidlTestIncompatibleChanges, RemovedPackage) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002708 const string expected_stderr = "ERROR: old/q/IFoo.aidl:1.11-21: Removed type: q.IFoo\n";
Jiyong Parke59c3682018-09-11 23:10:25 +09002709 io_delegate_.SetFileContents("old/p/IFoo.aidl", "package p; interface IFoo{}");
2710 io_delegate_.SetFileContents("old/q/IFoo.aidl", "package q; interface IFoo{}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002711 io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p; interface IFoo{}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002712 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002713 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002714 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002715}
Jiyong Parka468e2a2018-08-29 21:25:18 +09002716
Daniel Norman85aed542019-08-21 12:01:14 -07002717TEST_F(AidlTestIncompatibleChanges, ChangedDefaultValue) {
Steven Moreland370ed342020-04-28 18:14:39 -07002718 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 +09002719 io_delegate_.SetFileContents("old/p/D.aidl", "package p; parcelable D { int a = 1; }");
2720 io_delegate_.SetFileContents("new/p/D.aidl", "package p; parcelable D { int a = 2; }");
Devin Moore097a3ab2020-03-11 16:08:44 -07002721 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002722 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002723 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002724}
Jiyong Parka428d212018-08-29 22:26:30 +09002725
Daniel Norman85aed542019-08-21 12:01:14 -07002726TEST_F(AidlTestIncompatibleChanges, RemovedConstValue) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002727 const string expected_stderr =
2728 "ERROR: old/p/I.aidl:1.51-53: Removed constant declaration: p.I.B\n";
Jiyong Parke59c3682018-09-11 23:10:25 +09002729 io_delegate_.SetFileContents("old/p/I.aidl",
2730 "package p; interface I {"
2731 "const int A = 1; const int B = 2;}");
2732 io_delegate_.SetFileContents("new/p/I.aidl", "package p; interface I { const int A = 1; }");
Devin Moore097a3ab2020-03-11 16:08:44 -07002733 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002734 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002735 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002736}
Jiyong Parka428d212018-08-29 22:26:30 +09002737
Daniel Norman85aed542019-08-21 12:01:14 -07002738TEST_F(AidlTestIncompatibleChanges, ChangedConstValue) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002739 const string expected_stderr =
2740 "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 +09002741 io_delegate_.SetFileContents("old/p/I.aidl", "package p; interface I { const int A = 1; }");
2742 io_delegate_.SetFileContents("new/p/I.aidl", "package p; interface I { const int A = 2; }");
Devin Moore097a3ab2020-03-11 16:08:44 -07002743 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002744 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002745 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Park3c35e392018-08-30 13:10:30 +09002746}
2747
Devin Moorec7e47a32020-08-07 10:55:25 -07002748TEST_F(AidlTestIncompatibleChanges, FixedSizeAddedField) {
2749 const string expected_stderr =
2750 "ERROR: new/p/Foo.aidl:1.33-37: Number of fields in p.Foo is changed from 1 to 2. "
2751 "This is an incompatible change for FixedSize types.\n";
2752 io_delegate_.SetFileContents("old/p/Foo.aidl",
2753 "package p; @FixedSize parcelable Foo { int A = 1; }");
2754 io_delegate_.SetFileContents("new/p/Foo.aidl",
2755 "package p; @FixedSize parcelable Foo { int A = 1; int B = 2; }");
2756 CaptureStderr();
2757 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2758 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2759}
2760
Jeongik Cha68d18e72021-04-29 20:07:01 +09002761TEST_F(AidlTestIncompatibleChanges, UidRangeParcelAddedField) {
2762 const string expected_stderr =
2763 "ERROR: new/android/net/UidRangeParcel.aidl:1.32-47: Number of fields in "
2764 "android.net.UidRangeParcel is changed from 1 to 2. "
2765 "But it is forbidden because of legacy support.\n";
2766 io_delegate_.SetFileContents("old/android/net/UidRangeParcel.aidl",
2767 "package android.net; parcelable UidRangeParcel { int A = 1; }");
2768 io_delegate_.SetFileContents(
2769 "new/android/net/UidRangeParcel.aidl",
2770 "package android.net; parcelable UidRangeParcel { int A = 1; int B = 2; }");
2771 CaptureStderr();
2772 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2773 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2774}
2775
Devin Moorec7e47a32020-08-07 10:55:25 -07002776TEST_F(AidlTestIncompatibleChanges, FixedSizeRemovedField) {
2777 const string expected_stderr =
2778 "ERROR: new/p/Foo.aidl:1.33-37: Number of fields in p.Foo is reduced from 2 to 1.\n";
2779 io_delegate_.SetFileContents("old/p/Foo.aidl",
2780 "package p; @FixedSize parcelable Foo { int A = 1; int B = 1; }");
2781 io_delegate_.SetFileContents("new/p/Foo.aidl",
2782 "package p; @FixedSize parcelable Foo { int A = 1; }");
2783 CaptureStderr();
2784 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2785 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2786}
2787
2788TEST_P(AidlTest, RejectNonFixedSizeFromFixedSize) {
2789 const string expected_stderr =
2790 "ERROR: Foo.aidl:1.36-38: The @FixedSize parcelable 'Foo' has a non-fixed size field named "
2791 "a.\n"
2792 "ERROR: Foo.aidl:1.44-46: The @FixedSize parcelable 'Foo' has a non-fixed size field named "
2793 "b.\n"
2794 "ERROR: Foo.aidl:1.55-57: The @FixedSize parcelable 'Foo' has a non-fixed size field named "
2795 "c.\n"
2796 "ERROR: Foo.aidl:1.80-82: The @FixedSize parcelable 'Foo' has a non-fixed size field named "
2797 "d.\n"
2798 "ERROR: Foo.aidl:1.92-94: The @FixedSize parcelable 'Foo' has a non-fixed size field named "
2799 "e.\n"
2800 "ERROR: Foo.aidl:1.109-111: The @FixedSize parcelable 'Foo' has a non-fixed size field named "
2801 "f.\n";
2802
2803 io_delegate_.SetFileContents("Foo.aidl",
2804 "@FixedSize parcelable Foo { "
2805 " int[] a;"
2806 " Bar b;"
2807 " String c;"
2808 " ParcelFileDescriptor d;"
2809 " IBinder e;"
2810 " List<String> f;"
Steven Moreland265f3d42020-09-24 19:06:54 +00002811 " int isFixedSize;"
Devin Moorec7e47a32020-08-07 10:55:25 -07002812 "}");
2813 io_delegate_.SetFileContents("Bar.aidl", "parcelable Bar { int a; }");
Jooyung Han9435e9a2021-01-06 10:16:31 +09002814 Options options = Options::From("aidl Foo.aidl -I . --lang=" + to_string(GetLanguage()));
Devin Moorec7e47a32020-08-07 10:55:25 -07002815
2816 CaptureStderr();
2817 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
2818 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2819}
2820
2821TEST_P(AidlTest, AcceptFixedSizeFromFixedSize) {
2822 const string expected_stderr = "";
2823
2824 io_delegate_.SetFileContents("Foo.aidl", "@FixedSize parcelable Foo { int a; Bar b; }");
2825 io_delegate_.SetFileContents("Bar.aidl", "@FixedSize parcelable Bar { Val c; }");
2826 io_delegate_.SetFileContents("Val.aidl", "enum Val { A, B, }");
Jooyung Han9435e9a2021-01-06 10:16:31 +09002827 Options options = Options::From("aidl Foo.aidl -I . --lang=" + to_string(GetLanguage()));
Devin Moorec7e47a32020-08-07 10:55:25 -07002828
2829 CaptureStderr();
2830 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
2831 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2832}
2833
Jiyong Park8c380532018-08-30 14:55:26 +09002834TEST_F(AidlTest, RejectAmbiguousImports) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002835 const string expected_stderr =
2836 "ERROR: p/IFoo.aidl: Duplicate files found for q.IBar from:\n"
2837 "dir1/q/IBar.aidl\n"
2838 "dir2/q/IBar.aidl\n"
Devin Moore5de18ed2020-04-02 13:52:29 -07002839 "ERROR: p/IFoo.aidl: Couldn't find import for class q.IBar\n";
Jiyong Park8c380532018-08-30 14:55:26 +09002840 Options options = Options::From("aidl --lang=java -o out -I dir1 -I dir2 p/IFoo.aidl");
2841 io_delegate_.SetFileContents("p/IFoo.aidl", "package p; import q.IBar; interface IFoo{}");
2842 io_delegate_.SetFileContents("dir1/q/IBar.aidl", "package q; interface IBar{}");
2843 io_delegate_.SetFileContents("dir2/q/IBar.aidl", "package q; interface IBar{}");
2844
Devin Moore097a3ab2020-03-11 16:08:44 -07002845 CaptureStderr();
Jiyong Park8c380532018-08-30 14:55:26 +09002846 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002847 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Park8c380532018-08-30 14:55:26 +09002848}
2849
Jiyong Parked65bf42018-08-28 15:43:27 +09002850TEST_F(AidlTest, HandleManualIdAssignments) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002851 const string expected_stderr =
2852 "ERROR: new/p/IFoo.aidl:1.32-36: Transaction ID changed: p.IFoo.foo() is changed from 10 to "
2853 "11.\n";
Jiyong Parke59c3682018-09-11 23:10:25 +09002854 Options options = Options::From("aidl --checkapi old new");
2855 io_delegate_.SetFileContents("old/p/IFoo.aidl", "package p; interface IFoo{ void foo() = 10;}");
2856 io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p; interface IFoo{ void foo() = 10;}");
Jiyong Parked65bf42018-08-28 15:43:27 +09002857
2858 EXPECT_TRUE(::android::aidl::check_api(options, io_delegate_));
2859
Jiyong Parke59c3682018-09-11 23:10:25 +09002860 io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p; interface IFoo{ void foo() = 11;}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002861 CaptureStderr();
Jiyong Parked65bf42018-08-28 15:43:27 +09002862 EXPECT_FALSE(::android::aidl::check_api(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002863 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Parked65bf42018-08-28 15:43:27 +09002864}
2865
Jooyung Han652ce482021-02-26 12:40:35 +09002866TEST_P(AidlTest, ParcelFileDescriptorIsBuiltinType) {
2867 Options options =
2868 Options::From("aidl --lang=" + to_string(GetLanguage()) + " -h out -o out p/IFoo.aidl");
Jiyong Parke05195e2018-10-08 18:24:23 +09002869
2870 // use without import
2871 io_delegate_.SetFileContents("p/IFoo.aidl",
2872 "package p; interface IFoo{ void foo(in ParcelFileDescriptor fd);}");
Jooyung Han652ce482021-02-26 12:40:35 +09002873 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
2874
2875 // capture output files
2876 map<string, string> outputs = io_delegate_.OutputFiles();
Jiyong Parke05195e2018-10-08 18:24:23 +09002877
Devin Moore7b8d5c92020-03-17 14:14:08 -07002878 // use without import but with full name
Jiyong Parke05195e2018-10-08 18:24:23 +09002879 io_delegate_.SetFileContents(
2880 "p/IFoo.aidl",
2881 "package p; interface IFoo{ void foo(in android.os.ParcelFileDescriptor fd);}");
Jooyung Han652ce482021-02-26 12:40:35 +09002882 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
2883 // output files should be the same
2884 EXPECT_EQ(outputs, io_delegate_.OutputFiles());
Jiyong Parke05195e2018-10-08 18:24:23 +09002885
2886 // use with import (as before)
2887 io_delegate_.SetFileContents("p/IFoo.aidl",
2888 "package p;"
2889 "import android.os.ParcelFileDescriptor;"
2890 "interface IFoo{"
2891 " void foo(in ParcelFileDescriptor fd);"
2892 "}");
Jooyung Han652ce482021-02-26 12:40:35 +09002893 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
2894 // output files should be the same
2895 EXPECT_EQ(outputs, io_delegate_.OutputFiles());
Jiyong Parke05195e2018-10-08 18:24:23 +09002896}
Jiyong Parked65bf42018-08-28 15:43:27 +09002897
Jooyung Han020d8d12021-02-26 17:23:02 +09002898TEST_P(AidlTest, RejectsOutputParcelFileDescriptor) {
2899 Options options = Options::From("aidl p/IFoo.aidl -I . --lang=" + to_string(GetLanguage()));
2900 CaptureStderr();
2901 io_delegate_.SetFileContents("p/IFoo.aidl",
2902 "package p;"
2903 "interface IFoo{"
2904 " void foo(out ParcelFileDescriptor fd);"
2905 "}");
2906 EXPECT_EQ(1, ::android::aidl::compile_aidl(options, io_delegate_));
2907 EXPECT_THAT(GetCapturedStderr(), HasSubstr("can't be an out parameter"));
2908}
2909
2910TEST_P(AidlTest, RejectsArgumentDirectionNotSpecified) {
2911 Options options = Options::From("aidl p/IFoo.aidl -I . --lang=" + to_string(GetLanguage()));
2912 CaptureStderr();
2913 io_delegate_.SetFileContents("p/IFoo.aidl",
2914 "package p;"
2915 "interface IFoo{"
2916 " void foo(ParcelFileDescriptor fd);"
2917 "}");
2918 EXPECT_EQ(1, ::android::aidl::compile_aidl(options, io_delegate_));
2919 EXPECT_THAT(GetCapturedStderr(),
2920 HasSubstr("ParcelFileDescriptor can be an in or inout parameter."));
2921}
2922
Jiyong Park3633b722019-04-11 15:38:26 +09002923TEST_F(AidlTest, ManualIds) {
2924 Options options = Options::From("aidl --lang=java -o out IFoo.aidl");
2925 io_delegate_.SetFileContents("IFoo.aidl",
2926 "interface IFoo {\n"
2927 " void foo() = 0;\n"
2928 " void bar() = 1;\n"
2929 "}");
2930 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
2931}
2932
2933TEST_F(AidlTest, ManualIdsWithMetaTransactions) {
2934 Options options = Options::From("aidl --lang=java --version 10 -o out IFoo.aidl");
2935 io_delegate_.SetFileContents("IFoo.aidl",
2936 "interface IFoo {\n"
2937 " void foo() = 0;\n"
2938 " void bar() = 1;\n"
2939 "}");
2940 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
2941}
2942
2943TEST_F(AidlTest, FailOnDuplicatedIds) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002944 const string expected_stderr =
2945 "ERROR: IFoo.aidl:3.7-11: Found duplicate method id (3) for method bar\n";
Jiyong Park3633b722019-04-11 15:38:26 +09002946 Options options = Options::From("aidl --lang=java --version 10 -o out IFoo.aidl");
2947 io_delegate_.SetFileContents("IFoo.aidl",
2948 "interface IFoo {\n"
2949 " void foo() = 3;\n"
2950 " void bar() = 3;\n"
2951 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002952 CaptureStderr();
Jiyong Park3633b722019-04-11 15:38:26 +09002953 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002954 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Park3633b722019-04-11 15:38:26 +09002955}
2956
2957TEST_F(AidlTest, FailOnOutOfRangeIds) {
2958 // 16777115 is kLastMetaMethodId + 1
Devin Moore097a3ab2020-03-11 16:08:44 -07002959 const string expected_stderr =
2960 "ERROR: IFoo.aidl:3.7-11: Found out of bounds id (16777115) for method bar. "
2961 "Value for id must be between 0 and 16777114 inclusive.\n";
Jiyong Park3633b722019-04-11 15:38:26 +09002962 Options options = Options::From("aidl --lang=java --version 10 -o out IFoo.aidl");
2963 io_delegate_.SetFileContents("IFoo.aidl",
2964 "interface IFoo {\n"
2965 " void foo() = 3;\n"
2966 " void bar() = 16777115;\n"
2967 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002968 CaptureStderr();
Jiyong Park3633b722019-04-11 15:38:26 +09002969 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002970 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Park3633b722019-04-11 15:38:26 +09002971}
2972
2973TEST_F(AidlTest, FailOnPartiallyAssignedIds) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002974 const string expected_stderr =
2975 "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 +09002976 Options options = Options::From("aidl --lang=java --version 10 -o out IFoo.aidl");
2977 io_delegate_.SetFileContents("IFoo.aidl",
2978 "interface IFoo {\n"
2979 " void foo() = 3;\n"
2980 " void bar();\n"
2981 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002982 CaptureStderr();
Jiyong Park3633b722019-04-11 15:38:26 +09002983 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002984 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Park3633b722019-04-11 15:38:26 +09002985}
2986
Jiyong Parkc6816252019-07-08 08:12:28 +09002987TEST_F(AidlTest, AllowDuplicatedImportPaths) {
2988 Options options = Options::From("aidl --lang=java -I dir -I dir IFoo.aidl");
2989 io_delegate_.SetFileContents("dir/IBar.aidl", "interface IBar{}");
2990 io_delegate_.SetFileContents("IFoo.aidl", "import IBar; interface IFoo{}");
2991 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
2992}
2993
2994TEST_F(AidlTest, FailOnAmbiguousImports) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002995 const string expected_stderr =
2996 "ERROR: IFoo.aidl: Duplicate files found for IBar from:\n"
2997 "dir/IBar.aidl\n"
2998 "dir2/IBar.aidl\n"
Devin Moore5de18ed2020-04-02 13:52:29 -07002999 "ERROR: IFoo.aidl: Couldn't find import for class IBar\n";
Devin Moore097a3ab2020-03-11 16:08:44 -07003000
Jiyong Parkc6816252019-07-08 08:12:28 +09003001 Options options = Options::From("aidl --lang=java -I dir -I dir2 IFoo.aidl");
3002 io_delegate_.SetFileContents("dir/IBar.aidl", "interface IBar{}");
3003 io_delegate_.SetFileContents("dir2/IBar.aidl", "interface IBar{}");
3004 io_delegate_.SetFileContents("IFoo.aidl", "import IBar; interface IFoo{}");
Devin Moore097a3ab2020-03-11 16:08:44 -07003005 CaptureStderr();
Jiyong Parkc6816252019-07-08 08:12:28 +09003006 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07003007 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Parkc6816252019-07-08 08:12:28 +09003008}
3009
Jiyong Parkf1f5c802020-05-19 17:33:00 +09003010TEST_F(AidlTest, UnusedImportDoesNotContributeInclude) {
3011 io_delegate_.SetFileContents("a/b/IFoo.aidl",
3012 "package a.b;\n"
3013 "import a.b.IBar;\n"
3014 "import a.b.IQux;\n"
3015 "interface IFoo { IQux foo(); }\n");
3016 io_delegate_.SetFileContents("a/b/IBar.aidl", "package a.b; interface IBar { void foo(); }");
3017 io_delegate_.SetFileContents("a/b/IQux.aidl", "package a.b; interface IQux { void foo(); }");
3018
3019 Options options = Options::From("aidl --lang=ndk a/b/IFoo.aidl -I . -o out -h out/include");
3020 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3021
3022 string output;
3023 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/include/aidl/a/b/IFoo.h", &output));
3024 // IBar was imported but wasn't used. include is not expected.
3025 EXPECT_THAT(output, Not(testing::HasSubstr("#include <aidl/a/b/IBar.h>")));
3026 // IBar was imported and used. include is expected.
3027 EXPECT_THAT(output, (testing::HasSubstr("#include <aidl/a/b/IQux.h>")));
3028}
3029
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09003030TEST_F(AidlTest, ParseJavaPassthroughAnnotation) {
Jooyung Hane6bc5e12020-10-13 10:57:10 +09003031 io_delegate_.SetFileContents("a/IFoo.aidl", R"--(package a;
Jooyung Han4cde01d2020-10-13 11:10:47 +09003032 import a.MyEnum;
Jooyung Hane6bc5e12020-10-13 10:57:10 +09003033 @JavaPassthrough(annotation="@com.android.Alice(arg=com.android.Alice.Value.A)")
3034 @JavaPassthrough(annotation="@com.android.AliceTwo")
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09003035 interface IFoo {
3036 @JavaPassthrough(annotation="@com.android.Bob")
Jooyung Han4cde01d2020-10-13 11:10:47 +09003037 void foo(@JavaPassthrough(annotation="@com.android.Cat") int x, MyEnum y);
Jiyong Park7c3b0e42020-08-04 16:08:32 +09003038 const @JavaPassthrough(annotation="@com.android.David") int A = 3;
Jooyung Hane6bc5e12020-10-13 10:57:10 +09003039 })--");
Jooyung Han4cde01d2020-10-13 11:10:47 +09003040 // JavaPassthrough should work with other types as well (e.g. enum)
3041 io_delegate_.SetFileContents("a/MyEnum.aidl", R"--(package a;
3042 @JavaPassthrough(annotation="@com.android.Alice(arg=com.android.Alice.Value.A)")
3043 @JavaPassthrough(annotation="@com.android.AliceTwo")
3044 @Backing(type="byte")
3045 enum MyEnum {
3046 a, b, c
3047 })--");
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09003048
Jooyung Han4cde01d2020-10-13 11:10:47 +09003049 Options java_options = Options::From("aidl -I . --lang=java -o out a/IFoo.aidl a/MyEnum.aidl");
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09003050 EXPECT_EQ(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
3051
3052 string java_out;
3053 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/IFoo.java", &java_out));
Jooyung Hane6bc5e12020-10-13 10:57:10 +09003054 // type-decl-level annotations with newline at the end
3055 EXPECT_THAT(java_out, testing::HasSubstr("@com.android.Alice(arg=com.android.Alice.Value.A)\n"));
3056 EXPECT_THAT(java_out, testing::HasSubstr("@com.android.AliceTwo\n"));
3057 // member-decl-level annotations with newline at the end
3058 EXPECT_THAT(java_out, testing::HasSubstr("@com.android.Bob\n"));
3059 EXPECT_THAT(java_out, testing::HasSubstr("@com.android.David\n"));
3060 // inline annotations with space at the end
3061 EXPECT_THAT(java_out, testing::HasSubstr("@com.android.Cat "));
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09003062
Jooyung Han4cde01d2020-10-13 11:10:47 +09003063 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/MyEnum.java", &java_out));
3064 // type-decl-level annotations with newline at the end
3065 EXPECT_THAT(java_out, testing::HasSubstr("@com.android.Alice(arg=com.android.Alice.Value.A)\n"));
3066 EXPECT_THAT(java_out, testing::HasSubstr("@com.android.AliceTwo\n"));
3067
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09003068 // Other backends shouldn't be bothered
Jooyung Han4cde01d2020-10-13 11:10:47 +09003069 Options cpp_options =
3070 Options::From("aidl -I . --lang=cpp -o out -h out a/IFoo.aidl a/MyEnum.aidl");
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09003071 EXPECT_EQ(0, ::android::aidl::compile_aidl(cpp_options, io_delegate_));
3072
Jooyung Han4cde01d2020-10-13 11:10:47 +09003073 Options ndk_options =
3074 Options::From("aidl -I . --lang=ndk -o out -h out a/IFoo.aidl a/MyEnum.aidl");
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09003075 EXPECT_EQ(0, ::android::aidl::compile_aidl(ndk_options, io_delegate_));
Andrei Homescub62afd92020-05-11 19:24:59 -07003076
Jooyung Han4cde01d2020-10-13 11:10:47 +09003077 Options rust_options = Options::From("aidl -I . --lang=rust -o out a/IFoo.aidl a/MyEnum.aidl");
Andrei Homescub62afd92020-05-11 19:24:59 -07003078 EXPECT_EQ(0, ::android::aidl::compile_aidl(rust_options, io_delegate_));
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09003079}
3080
Andrei Homescue61feb52020-08-18 15:44:24 -07003081TEST_F(AidlTest, ParseRustDerive) {
3082 io_delegate_.SetFileContents("a/Foo.aidl", R"(package a;
3083 @RustDerive(Clone=true, Copy=false)
3084 parcelable Foo {
3085 int a;
3086 })");
3087
3088 Options rust_options = Options::From("aidl --lang=rust -o out a/Foo.aidl");
3089 EXPECT_EQ(0, ::android::aidl::compile_aidl(rust_options, io_delegate_));
3090
3091 string rust_out;
3092 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/Foo.rs", &rust_out));
3093 EXPECT_THAT(rust_out, testing::HasSubstr("#[derive(Debug, Clone)]"));
3094
3095 // Other backends shouldn't be bothered
3096 Options cpp_options = Options::From("aidl --lang=cpp -o out -h out a/Foo.aidl");
3097 EXPECT_EQ(0, ::android::aidl::compile_aidl(cpp_options, io_delegate_));
3098
3099 Options ndk_options = Options::From("aidl --lang=ndk -o out -h out a/Foo.aidl");
3100 EXPECT_EQ(0, ::android::aidl::compile_aidl(ndk_options, io_delegate_));
3101
3102 Options java_options = Options::From("aidl --lang=java -o out a/Foo.aidl");
3103 EXPECT_EQ(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
3104}
3105
Jiyong Park56f73d72019-06-11 12:20:28 +09003106class AidlOutputPathTest : public AidlTest {
3107 protected:
3108 void SetUp() override {
3109 AidlTest::SetUp();
3110 io_delegate_.SetFileContents("sub/dir/foo/bar/IFoo.aidl", "package foo.bar; interface IFoo {}");
3111 }
3112
3113 void Test(const Options& options, const std::string expected_output_path) {
3114 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3115 // check the existence
3116 EXPECT_TRUE(io_delegate_.GetWrittenContents(expected_output_path, nullptr));
3117 }
3118};
3119
3120TEST_F(AidlOutputPathTest, OutDirWithNoOutputFile) {
3121 // <out_dir> / <package_name> / <type_name>.java
3122 Test(Options::From("aidl -o out sub/dir/foo/bar/IFoo.aidl"), "out/foo/bar/IFoo.java");
3123}
3124
3125TEST_F(AidlOutputPathTest, OutDirWithOutputFile) {
3126 // when output file is explicitly set, it is always respected. -o option is
3127 // ignored.
3128 Test(Options::From("aidl -o out sub/dir/foo/bar/IFoo.aidl output/IFoo.java"), "output/IFoo.java");
3129}
3130
3131TEST_F(AidlOutputPathTest, NoOutDirWithOutputFile) {
3132 Test(Options::From("aidl -o out sub/dir/foo/bar/IFoo.aidl output/IFoo.java"), "output/IFoo.java");
3133}
3134
3135TEST_F(AidlOutputPathTest, NoOutDirWithNoOutputFile) {
3136 // output is the same as the input file except for the suffix
3137 Test(Options::From("aidl sub/dir/foo/bar/IFoo.aidl"), "sub/dir/foo/bar/IFoo.java");
3138}
3139
Devin Moore7b8d5c92020-03-17 14:14:08 -07003140TEST_P(AidlTest, FailOnOutOfBoundsInt32MaxConstInt) {
Devin Moore097a3ab2020-03-11 16:08:44 -07003141 AidlError error;
3142 const string expected_stderr =
3143 "ERROR: p/IFoo.aidl:3.58-69: Invalid type specifier for an int64 literal: int\n";
3144 CaptureStderr();
Will McVickera4e5b132019-10-03 13:52:21 -07003145 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl",
3146 R"(package p;
3147 interface IFoo {
3148 const int int32_max_oob = 2147483650;
3149 }
3150 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -07003151 typenames_, GetLanguage(), &error));
Devin Moore097a3ab2020-03-11 16:08:44 -07003152 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3153 EXPECT_EQ(AidlError::BAD_TYPE, error);
Will McVickera4e5b132019-10-03 13:52:21 -07003154}
3155
Devin Moore7b8d5c92020-03-17 14:14:08 -07003156TEST_P(AidlTest, FailOnOutOfBoundsInt32MinConstInt) {
Devin Moore097a3ab2020-03-11 16:08:44 -07003157 AidlError error;
3158 const string expected_stderr =
3159 "ERROR: p/IFoo.aidl:3.58-60: Invalid type specifier for an int64 literal: int\n";
3160 CaptureStderr();
Will McVickera4e5b132019-10-03 13:52:21 -07003161 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl",
3162 R"(package p;
3163 interface IFoo {
3164 const int int32_min_oob = -2147483650;
3165 }
3166 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -07003167 typenames_, GetLanguage(), &error));
Devin Moore097a3ab2020-03-11 16:08:44 -07003168 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3169 EXPECT_EQ(AidlError::BAD_TYPE, error);
Will McVickera4e5b132019-10-03 13:52:21 -07003170}
3171
Devin Moore7b8d5c92020-03-17 14:14:08 -07003172TEST_P(AidlTest, FailOnOutOfBoundsInt64MaxConstInt) {
Devin Moore097a3ab2020-03-11 16:08:44 -07003173 AidlError error;
3174 const string expected_stderr =
Devin Moore2a088902020-09-17 10:51:19 -07003175 "ERROR: p/IFoo.aidl:3.59-86: Could not parse integer: 21474836509999999999999999\n";
Devin Moore097a3ab2020-03-11 16:08:44 -07003176 CaptureStderr();
Will McVickera4e5b132019-10-03 13:52:21 -07003177 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl",
3178 R"(package p;
3179 interface IFoo {
3180 const long int64_max_oob = 21474836509999999999999999;
3181 }
3182 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -07003183 typenames_, GetLanguage(), &error));
Devin Moore097a3ab2020-03-11 16:08:44 -07003184 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3185 EXPECT_EQ(AidlError::PARSE_ERROR, error);
Will McVickera4e5b132019-10-03 13:52:21 -07003186}
3187
Devin Moore7b8d5c92020-03-17 14:14:08 -07003188TEST_P(AidlTest, FailOnOutOfBoundsInt64MinConstInt) {
Devin Moore097a3ab2020-03-11 16:08:44 -07003189 AidlError error;
3190 const string expected_stderr =
Devin Moore2a088902020-09-17 10:51:19 -07003191 "ERROR: p/IFoo.aidl:3.61-87: Could not parse integer: 21474836509999999999999999\n";
Devin Moore097a3ab2020-03-11 16:08:44 -07003192 CaptureStderr();
Will McVickera4e5b132019-10-03 13:52:21 -07003193 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl",
3194 R"(package p;
3195 interface IFoo {
3196 const long int64_min_oob = -21474836509999999999999999;
3197 }
3198 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -07003199 typenames_, GetLanguage(), &error));
Devin Moore097a3ab2020-03-11 16:08:44 -07003200 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3201 EXPECT_EQ(AidlError::PARSE_ERROR, error);
Will McVickera4e5b132019-10-03 13:52:21 -07003202}
3203
Devin Moore7b8d5c92020-03-17 14:14:08 -07003204TEST_P(AidlTest, FailOnOutOfBoundsAutofilledEnum) {
Devin Moore097a3ab2020-03-11 16:08:44 -07003205 AidlError error;
Devin Mooredf93ebb2020-03-25 14:03:35 -07003206 const string expected_stderr =
Jooyung Han29813842020-12-08 01:28:03 +09003207 "ERROR: p/TestEnum.aidl:5.1-36: Invalid type specifier for an int32 literal: byte\n"
Devin Mooredf93ebb2020-03-25 14:03:35 -07003208 "ERROR: p/TestEnum.aidl:5.1-36: Enumerator type differs from enum backing type.\n";
3209 CaptureStderr();
Daniel Normanb28684e2019-10-17 15:31:39 -07003210 EXPECT_EQ(nullptr, Parse("p/TestEnum.aidl",
3211 R"(package p;
3212 @Backing(type="byte")
3213 enum TestEnum {
3214 FOO = 127,
3215 BAR,
3216 }
3217 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -07003218 typenames_, GetLanguage(), &error));
Devin Mooredf93ebb2020-03-25 14:03:35 -07003219 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Devin Moore097a3ab2020-03-11 16:08:44 -07003220 EXPECT_EQ(AidlError::BAD_TYPE, error);
Daniel Normanb28684e2019-10-17 15:31:39 -07003221}
3222
Devin Mooredecaf292020-04-30 09:16:40 -07003223TEST_P(AidlTest, UnsupportedBackingAnnotationParam) {
3224 AidlError error;
3225 const string expected_stderr =
3226 "ERROR: p/TestEnum.aidl:2.1-51: Parameter foo not supported for annotation Backing. It must "
Devin Mooredecaf292020-04-30 09:16:40 -07003227 "be one of: type\n";
3228 CaptureStderr();
3229 EXPECT_EQ(nullptr, Parse("p/TestEnum.aidl",
3230 R"(package p;
3231 @Backing(foo="byte")
3232 enum TestEnum {
3233 FOO = 1,
3234 BAR,
3235 }
3236 )",
3237 typenames_, GetLanguage(), &error));
3238 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3239 EXPECT_EQ(AidlError::BAD_TYPE, error);
3240}
3241
Jooyung Han5721a232020-12-24 04:34:55 +09003242TEST_P(AidlTest, BackingAnnotationRequireTypeParameter) {
3243 const string expected_stderr = "ERROR: Enum.aidl:1.1-9: Missing 'type' on @Backing.\n";
3244 CaptureStderr();
3245 EXPECT_EQ(nullptr, Parse("Enum.aidl", "@Backing enum Enum { FOO }", typenames_, GetLanguage()));
3246 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3247}
3248
Jooyung Han66813932020-10-23 13:24:44 +09003249TEST_F(AidlTest, SupportJavaOnlyImmutableAnnotation) {
Jeongik Chad0a10272020-08-06 16:33:36 +09003250 io_delegate_.SetFileContents("Foo.aidl",
3251 "@JavaOnlyImmutable parcelable Foo { int a; Bar b; List<Bar> c; "
3252 "Map<String, Baz> d; Bar[] e; }");
3253 io_delegate_.SetFileContents("Bar.aidl", "@JavaOnlyImmutable parcelable Bar { String a; }");
3254 io_delegate_.SetFileContents("Baz.aidl",
3255 "@JavaOnlyImmutable @JavaOnlyStableParcelable parcelable Baz;");
Jeongik Cha36f76c32020-07-28 00:25:52 +09003256 Options options = Options::From("aidl --lang=java -I . Foo.aidl");
3257 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3258}
3259
Jooyung Han66813932020-10-23 13:24:44 +09003260TEST_F(AidlTest, RejectMutableParcelableFromJavaOnlyImmutableParcelable) {
Jeongik Chad0a10272020-08-06 16:33:36 +09003261 io_delegate_.SetFileContents("Foo.aidl", "@JavaOnlyImmutable parcelable Foo { Bar bar; }");
Jeongik Cha36f76c32020-07-28 00:25:52 +09003262 io_delegate_.SetFileContents("Bar.aidl", "parcelable Bar { String a; }");
Jooyung Hand4057c42020-10-23 13:28:22 +09003263 string expected_error =
Jooyung Han59af9cc2020-10-25 21:44:14 +09003264 "ERROR: Foo.aidl:1.40-44: The @JavaOnlyImmutable 'Foo' has a non-immutable field "
3265 "named 'bar'.\n";
3266 CaptureStderr();
3267 Options options = Options::From("aidl --lang=java Foo.aidl -I .");
3268 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3269 EXPECT_EQ(expected_error, GetCapturedStderr());
3270}
3271
Jooyung Han09e551c2021-05-11 11:44:48 +09003272TEST_F(AidlTest, JavaOnlyImmutableParcelableWithEnumFields) {
3273 io_delegate_.SetFileContents("Foo.aidl", "@JavaOnlyImmutable parcelable Foo { Bar bar; }");
3274 io_delegate_.SetFileContents("Bar.aidl", "enum Bar { FOO }");
3275 CaptureStderr();
3276 Options options = Options::From("aidl --lang=java Foo.aidl -I .");
3277 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3278 EXPECT_EQ("", GetCapturedStderr());
3279}
3280
Jooyung Han59af9cc2020-10-25 21:44:14 +09003281TEST_F(AidlTest, RejectMutableParcelableFromJavaOnlyImmutableUnion) {
3282 io_delegate_.SetFileContents("Foo.aidl", "@JavaOnlyImmutable union Foo { Bar bar; }");
3283 io_delegate_.SetFileContents("Bar.aidl", "parcelable Bar { String a; }");
3284 string expected_error =
3285 "ERROR: Foo.aidl:1.35-39: The @JavaOnlyImmutable 'Foo' has a non-immutable field "
Jooyung Hand4057c42020-10-23 13:28:22 +09003286 "named 'bar'.\n";
3287 CaptureStderr();
Jeongik Cha36f76c32020-07-28 00:25:52 +09003288 Options options = Options::From("aidl --lang=java Foo.aidl -I .");
3289 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jooyung Hand4057c42020-10-23 13:28:22 +09003290 EXPECT_EQ(expected_error, GetCapturedStderr());
Jeongik Cha36f76c32020-07-28 00:25:52 +09003291}
3292
Jooyung Han66813932020-10-23 13:24:44 +09003293TEST_F(AidlTest, ImmutableParcelableCannotBeInOut) {
Jeongik Chad0a10272020-08-06 16:33:36 +09003294 io_delegate_.SetFileContents("Foo.aidl", "@JavaOnlyImmutable parcelable Foo { int a; }");
Jooyung Han15fd6c62020-10-23 13:54:46 +09003295 io_delegate_.SetFileContents("IBar.aidl", "interface IBar { void my(inout Foo foo); }");
3296 string expected_error =
3297 "ERROR: IBar.aidl:1.35-39: 'foo' can't be an inout parameter because @JavaOnlyImmutable can "
3298 "only be an in parameter.\n";
3299 CaptureStderr();
Jeongik Cha36f76c32020-07-28 00:25:52 +09003300 Options options = Options::From("aidl --lang=java IBar.aidl -I .");
3301 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jooyung Han15fd6c62020-10-23 13:54:46 +09003302 EXPECT_EQ(expected_error, GetCapturedStderr());
Jeongik Cha36f76c32020-07-28 00:25:52 +09003303}
3304
Jooyung Han66813932020-10-23 13:24:44 +09003305TEST_F(AidlTest, ImmutableParcelableCannotBeOut) {
Jeongik Chad0a10272020-08-06 16:33:36 +09003306 io_delegate_.SetFileContents("Foo.aidl", "@JavaOnlyImmutable parcelable Foo { int a; }");
Jooyung Han15fd6c62020-10-23 13:54:46 +09003307 io_delegate_.SetFileContents("IBar.aidl", "interface IBar { void my(out Foo foo); }");
3308 string expected_error =
3309 "ERROR: IBar.aidl:1.33-37: 'foo' can't be an out parameter because @JavaOnlyImmutable can "
3310 "only be an in parameter.\n";
3311 CaptureStderr();
Jeongik Cha36f76c32020-07-28 00:25:52 +09003312 Options options = Options::From("aidl --lang=java IBar.aidl -I .");
3313 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jooyung Han15fd6c62020-10-23 13:54:46 +09003314 EXPECT_EQ(expected_error, GetCapturedStderr());
Jeongik Cha36f76c32020-07-28 00:25:52 +09003315}
3316
Jooyung Han66813932020-10-23 13:24:44 +09003317TEST_F(AidlTest, ImmutableParcelableFieldNameRestriction) {
Jeongik Chad0a10272020-08-06 16:33:36 +09003318 io_delegate_.SetFileContents("Foo.aidl", "@JavaOnlyImmutable parcelable Foo { int a; int A; }");
Jeongik Cha91180252020-07-31 15:43:11 +09003319 Options options = Options::From("aidl --lang=java Foo.aidl");
3320 const string expected_stderr =
Jooyung Han59af9cc2020-10-25 21:44:14 +09003321 "ERROR: Foo.aidl:1.47-49: 'Foo' has duplicate field name 'A' after capitalizing the first "
3322 "letter\n";
Jeongik Cha91180252020-07-31 15:43:11 +09003323 CaptureStderr();
3324 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3325 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3326}
Devin Moore53fc99c2020-08-12 08:07:52 -07003327
Jooyung Hanfe086af2021-01-16 03:44:47 +09003328TEST_P(AidlTest, UnionInUnion) {
3329 import_paths_.insert(".");
3330 io_delegate_.SetFileContents("Bar.aidl", "union Bar { int n = 42; long l; }");
3331 CaptureStderr();
3332 EXPECT_NE(nullptr, Parse("Foo.aidl", "union Foo { Bar b; int n; }", typenames_, GetLanguage()));
3333 EXPECT_THAT("", GetCapturedStderr());
3334}
3335
Jooyung Hanfe89f122020-10-14 03:49:18 +09003336TEST_P(AidlTest, UnionRejectsEmptyDecl) {
3337 const string method = "package a; union Foo {}";
3338 const string expected_stderr = "ERROR: a/Foo.aidl:1.17-21: The union 'Foo' has no fields.\n";
3339 CaptureStderr();
3340 EXPECT_EQ(nullptr, Parse("a/Foo.aidl", method, typenames_, GetLanguage()));
3341 EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr(expected_stderr));
3342}
3343
3344TEST_P(AidlTest, UnionRejectsParcelableHolder) {
3345 const string method = "package a; union Foo { ParcelableHolder x; }";
3346 const string expected_stderr =
3347 "ERROR: a/Foo.aidl:1.40-42: A union can't have a member of ParcelableHolder 'x'\n";
3348 CaptureStderr();
3349 EXPECT_EQ(nullptr, Parse("a/Foo.aidl", method, typenames_, GetLanguage()));
3350 EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr(expected_stderr));
3351}
3352
Jooyung Han53fb4242020-12-17 16:03:49 +09003353TEST_P(AidlTest, UnionRejectsFirstEnumWithNoDefaults) {
3354 import_paths_.insert(".");
3355 io_delegate_.SetFileContents("a/Enum.aidl", "package a; enum Enum { FOO, BAR }");
3356 const string expected_err = "The union's first member should have a useful default value.";
3357 CaptureStderr();
3358 EXPECT_EQ(nullptr,
3359 Parse("a/Foo.aidl", "package a; union Foo { a.Enum e; }", typenames_, GetLanguage()));
3360 EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr(expected_err));
3361}
3362
Devin Moore53fc99c2020-08-12 08:07:52 -07003363TEST_P(AidlTest, GenericStructuredParcelable) {
3364 io_delegate_.SetFileContents("Foo.aidl", "parcelable Foo<T, U> { int a; int A; }");
Jooyung Han9435e9a2021-01-06 10:16:31 +09003365 Options options = Options::From("aidl Foo.aidl --lang=" + to_string(GetLanguage()));
Devin Moore53fc99c2020-08-12 08:07:52 -07003366 const string expected_stderr = "";
3367 CaptureStderr();
3368 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3369 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3370}
3371
Jooyung Han3f347ca2020-12-01 12:41:50 +09003372TEST_F(AidlTest, GenericStructuredParcelableWithStringConstants_Cpp) {
3373 io_delegate_.SetFileContents("Foo.aidl",
3374 "parcelable Foo<T, U> { int a; const String s = \"\"; }");
3375 Options options =
Jooyung Han9435e9a2021-01-06 10:16:31 +09003376 Options::From("aidl Foo.aidl --lang=" + to_string(Options::Language::CPP) + " -o out -h out");
Jooyung Han3f347ca2020-12-01 12:41:50 +09003377 const string expected_stderr = "";
3378 CaptureStderr();
3379 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3380 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3381
3382 string code;
3383 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/Foo.h", &code));
3384 EXPECT_THAT(code, testing::HasSubstr(R"--(template <typename T, typename U>
3385const ::android::String16& Foo<T,U>::s() {
3386 static const ::android::String16 value(::android::String16(""));
3387 return value;
3388})--"));
3389}
3390
3391TEST_F(AidlTest, GenericStructuredParcelableWithStringConstants_Ndk) {
3392 io_delegate_.SetFileContents("Foo.aidl",
3393 "parcelable Foo<T, U> { int a; const String s = \"\"; }");
3394 Options options =
Jooyung Han9435e9a2021-01-06 10:16:31 +09003395 Options::From("aidl Foo.aidl --lang=" + to_string(Options::Language::NDK) + " -o out -h out");
Jooyung Han3f347ca2020-12-01 12:41:50 +09003396 const string expected_stderr = "";
3397 CaptureStderr();
3398 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3399 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3400
3401 string code;
3402 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/aidl/Foo.h", &code));
3403 EXPECT_THAT(code, testing::HasSubstr(R"--(template <typename T, typename U>
3404const char* Foo<T, U>::s = "";
3405)--"));
3406}
3407
Jooyung Han8c9a4e12020-10-26 15:39:54 +09003408TEST_F(AidlTest, NestedTypeArgs) {
3409 io_delegate_.SetFileContents("a/Bar.aidl", "package a; parcelable Bar<A> { }");
Steven Moreland6c07b832020-10-29 23:39:53 +00003410 io_delegate_.SetFileContents("a/Baz.aidl", "package a; parcelable Baz<A, B> { }");
3411
3412 io_delegate_.SetFileContents("a/Foo.aidl",
3413 "package a; import a.Bar; import a.Baz; parcelable Foo { "
3414 "Baz<Bar<Bar<String[]>>[], Bar<String>> barss; }");
Jooyung Han8c9a4e12020-10-26 15:39:54 +09003415 Options options = Options::From("aidl a/Foo.aidl -I . -o out --lang=java");
3416 const string expected_stderr = "";
3417 CaptureStderr();
3418 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3419 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3420
3421 string code;
3422 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/Foo.java", &code));
Steven Moreland6c07b832020-10-29 23:39:53 +00003423 EXPECT_THAT(code,
3424 testing::HasSubstr(
3425 "a.Baz<a.Bar<a.Bar<java.lang.String[]>>[],a.Bar<java.lang.String>> barss;"));
3426}
3427
3428TEST_F(AidlTest, DoubleArrayError) {
3429 io_delegate_.SetFileContents("a/Bar.aidl", "package a; parcelable Bar { String[][] a; }");
3430
3431 Options options = Options::From("aidl a/Bar.aidl -I . -o out --lang=java");
3432 const string expected_stderr =
3433 "ERROR: a/Bar.aidl:1.28-37: Can only have one dimensional arrays.\n";
3434 CaptureStderr();
3435 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3436 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3437}
3438
3439TEST_F(AidlTest, DoubleGenericError) {
3440 io_delegate_.SetFileContents("a/Bar.aidl",
3441 "package a; parcelable Bar { List<String><String> a; }");
3442
3443 Options options = Options::From("aidl a/Bar.aidl -I . -o out --lang=java");
3444 const string expected_stderr =
3445 "ERROR: a/Bar.aidl:1.28-33: Can only specify one set of type parameters.\n";
3446 CaptureStderr();
3447 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3448 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3449}
3450
3451TEST_F(AidlTest, ArrayBeforeGenericError) {
3452 io_delegate_.SetFileContents("a/Bar.aidl", "package a; parcelable Bar { List[]<String> a; }");
3453
3454 Options options = Options::From("aidl a/Bar.aidl -I . -o out --lang=java");
Steven Moreland6c07b832020-10-29 23:39:53 +00003455 CaptureStderr();
3456 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jooyung Han97c324a2021-02-15 16:09:51 +09003457 EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr("syntax error, unexpected '<'"));
3458}
3459
3460TEST_F(AidlTest, NullableArraysAreNotSupported) {
3461 io_delegate_.SetFileContents("a/Bar.aidl",
3462 "package a; parcelable Bar { String @nullable [] a; }");
3463
3464 Options options = Options::From("aidl a/Bar.aidl -I . -o out --lang=java");
3465 CaptureStderr();
3466 EXPECT_EQ(1, ::android::aidl::compile_aidl(options, io_delegate_));
3467 EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr("Annotations for arrays are not supported."));
3468}
3469
3470TEST_F(AidlTest, ListOfNullablesAreNotSupported) {
3471 io_delegate_.SetFileContents("a/Bar.aidl",
3472 "package a; parcelable Bar { List<@nullable String> a; }");
3473
3474 Options options = Options::From("aidl a/Bar.aidl -I . -o out --lang=java");
3475 CaptureStderr();
3476 EXPECT_EQ(1, ::android::aidl::compile_aidl(options, io_delegate_));
3477 EXPECT_THAT(GetCapturedStderr(),
3478 testing::HasSubstr("Annotations for type arguments are not supported."));
Jooyung Han8c9a4e12020-10-26 15:39:54 +09003479}
3480
Jooyung Han14004ed2020-10-16 03:49:57 +09003481struct GenericAidlTest : ::testing::Test {
3482 FakeIoDelegate io_delegate_;
3483 void Compile(string cmd) {
Steven Moreland6c07b832020-10-29 23:39:53 +00003484 io_delegate_.SetFileContents("Foo.aidl", "parcelable Foo { Bar<Baz<Qux>> x; }");
Jooyung Han14004ed2020-10-16 03:49:57 +09003485 io_delegate_.SetFileContents("Bar.aidl", "parcelable Bar<T> { }");
3486 io_delegate_.SetFileContents("Baz.aidl", "parcelable Baz<T> { }");
3487 io_delegate_.SetFileContents("Qux.aidl", "parcelable Qux { }");
3488
3489 Options options = Options::From(cmd);
3490 CaptureStderr();
3491 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3492 EXPECT_EQ("", GetCapturedStderr());
3493 }
3494};
3495
3496TEST_F(GenericAidlTest, ImportGenericParameterTypesCPP) {
3497 Compile("aidl Foo.aidl --lang=cpp -I . -o out -h out");
3498 string code;
3499 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/Foo.h", &code));
3500 EXPECT_THAT(code, testing::HasSubstr("#include <Bar.h>"));
3501 EXPECT_THAT(code, testing::HasSubstr("#include <Baz.h>"));
3502 EXPECT_THAT(code, testing::HasSubstr("#include <Qux.h>"));
3503}
3504
3505TEST_F(GenericAidlTest, ImportGenericParameterTypesNDK) {
3506 Compile("aidl Foo.aidl --lang=ndk -I . -o out -h out");
3507 string code;
3508 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/aidl/Foo.h", &code));
3509 EXPECT_THAT(code, testing::HasSubstr("#include <aidl/Bar.h>"));
3510 EXPECT_THAT(code, testing::HasSubstr("#include <aidl/Baz.h>"));
3511 EXPECT_THAT(code, testing::HasSubstr("#include <aidl/Qux.h>"));
3512}
3513
Devin Moore53fc99c2020-08-12 08:07:52 -07003514TEST_P(AidlTest, RejectGenericStructuredParcelabelRepeatedParam) {
3515 io_delegate_.SetFileContents("Foo.aidl", "parcelable Foo<T,T> { int a; int A; }");
Jooyung Han9435e9a2021-01-06 10:16:31 +09003516 Options options = Options::From("aidl Foo.aidl --lang=" + to_string(GetLanguage()));
Devin Moore53fc99c2020-08-12 08:07:52 -07003517 const string expected_stderr =
3518 "ERROR: Foo.aidl:1.11-15: Every type parameter should be unique.\n";
3519 CaptureStderr();
3520 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3521 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3522}
3523
3524TEST_P(AidlTest, RejectGenericStructuredParcelableField) {
3525 io_delegate_.SetFileContents("Foo.aidl", "parcelable Foo<T,T> { T a; int A; }");
Jooyung Han9435e9a2021-01-06 10:16:31 +09003526 Options options = Options::From("aidl Foo.aidl --lang=" + to_string(GetLanguage()));
Devin Moore53fc99c2020-08-12 08:07:52 -07003527 const string expected_stderr = "ERROR: Foo.aidl:1.22-24: Failed to resolve 'T'\n";
3528 CaptureStderr();
3529 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3530 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3531}
3532
Jooyung Han7a308842020-10-27 19:06:49 +09003533TEST_P(AidlTest, LongCommentWithinConstExpression) {
3534 io_delegate_.SetFileContents("Foo.aidl", "enum Foo { FOO = (1 << 1) /* comment */ | 0x0 }");
Jooyung Han9435e9a2021-01-06 10:16:31 +09003535 Options options = Options::From("aidl Foo.aidl --lang=" + to_string(GetLanguage()));
Jooyung Han7a308842020-10-27 19:06:49 +09003536 CaptureStderr();
3537 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3538 EXPECT_EQ("", GetCapturedStderr());
3539}
3540
Jeongik Chaef44e622020-10-23 16:00:52 +09003541TEST_F(AidlTest, RejectUntypdeListAndMapInUnion) {
3542 io_delegate_.SetFileContents("a/Foo.aidl", "package a; union Foo { List l; Map m; }");
3543 Options options = Options::From("aidl a/Foo.aidl --lang=java -o out");
3544 std::string expectedErr =
3545 "ERROR: a/Foo.aidl:1.28-30: "
3546 "Encountered an untyped List or Map. The use of untyped List/Map is "
3547 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
3548 "the receiving side. Consider switching to an array or a generic List/Map.\n"
3549 "ERROR: a/Foo.aidl:1.35-37: "
3550 "Encountered an untyped List or Map. The use of untyped List/Map is "
3551 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
3552 "the receiving side. Consider switching to an array or a generic List/Map.\n";
3553 CaptureStderr();
3554 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3555 EXPECT_EQ(expectedErr, GetCapturedStderr());
3556}
3557
3558TEST_F(AidlTest, RejectUntypdeListAndMapInUnstructuredParcelable) {
Jooyung Hanea2147c2020-10-21 18:16:56 +09003559 io_delegate_.SetFileContents("a/Foo.aidl", "package a; parcelable Foo { List l; Map m; }");
3560 Options options = Options::From("aidl a/Foo.aidl --lang=java -o out");
Jeongik Chaef44e622020-10-23 16:00:52 +09003561 std::string expectedErr =
3562 "ERROR: a/Foo.aidl:1.33-35: "
3563 "Encountered an untyped List or Map. The use of untyped List/Map is "
3564 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
3565 "the receiving side. Consider switching to an array or a generic List/Map.\n"
3566 "ERROR: a/Foo.aidl:1.40-42: "
3567 "Encountered an untyped List or Map. The use of untyped List/Map is "
3568 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
3569 "the receiving side. Consider switching to an array or a generic List/Map.\n";
Jooyung Hanea2147c2020-10-21 18:16:56 +09003570 CaptureStderr();
Jeongik Chaef44e622020-10-23 16:00:52 +09003571 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3572 EXPECT_EQ(expectedErr, GetCapturedStderr());
3573}
Jooyung Hanea2147c2020-10-21 18:16:56 +09003574
Jeongik Chaef44e622020-10-23 16:00:52 +09003575TEST_F(AidlTest, RejectNestedUntypedListAndMap) {
3576 io_delegate_.SetFileContents("a/Bar.aidl", "package a; parcelable Bar<T>;");
3577 io_delegate_.SetFileContents(
3578 "a/Foo.aidl", "package a; import a.Bar; parcelable Foo { Bar<List> a; Bar<Map> b; }");
3579 Options options = Options::From("aidl a/Foo.aidl -I . --lang=java -o out");
3580 std::string expectedErr =
3581 "ERROR: a/Foo.aidl:1.52-54: "
3582 "Encountered an untyped List or Map. The use of untyped List/Map is "
3583 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
3584 "the receiving side. Consider switching to an array or a generic List/Map.\n"
3585 "ERROR: a/Foo.aidl:1.64-66: "
3586 "Encountered an untyped List or Map. The use of untyped List/Map is "
3587 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
3588 "the receiving side. Consider switching to an array or a generic List/Map.\n";
3589 CaptureStderr();
3590 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3591 EXPECT_EQ(expectedErr, GetCapturedStderr());
Jooyung Hanea2147c2020-10-21 18:16:56 +09003592}
3593
Jooyung Han690f5842020-12-04 13:02:04 +09003594TEST_F(AidlTest, EnumWithDefaults_Java) {
3595 io_delegate_.SetFileContents("a/p/Enum.aidl", "package p; enum Enum { FOO, BAR }");
3596 io_delegate_.SetFileContents("a/p/Foo.aidl", R"(
3597package p;
3598import p.Enum;
3599parcelable Foo {
3600 Enum e = Enum.BAR;
3601})");
3602 CaptureStderr();
3603 auto options = Options::From("aidl -I a --lang java -o out a/p/Foo.aidl");
3604 EXPECT_EQ(0, aidl::compile_aidl(options, io_delegate_));
3605 auto err = GetCapturedStderr();
3606 EXPECT_EQ("", err);
3607
3608 string code;
3609 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/p/Foo.java", &code));
Jooyung Han2d833612020-12-17 15:59:27 +09003610 EXPECT_THAT(code, testing::HasSubstr("byte e = p.Enum.BAR"));
Jooyung Han690f5842020-12-04 13:02:04 +09003611}
3612
3613TEST_F(AidlTest, EnumWithDefaults_Cpp) {
3614 io_delegate_.SetFileContents("a/p/Enum.aidl", "package p; enum Enum { FOO, BAR }");
3615 io_delegate_.SetFileContents("a/p/Foo.aidl", R"(
3616package p;
3617import p.Enum;
3618parcelable Foo {
3619 Enum e = Enum.BAR;
3620})");
3621 CaptureStderr();
3622 auto options = Options::From("aidl -I a --lang cpp -o out -h out a/p/Foo.aidl");
3623 EXPECT_EQ(0, aidl::compile_aidl(options, io_delegate_));
3624 auto err = GetCapturedStderr();
3625 EXPECT_EQ("", err);
3626
3627 string code;
3628 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/p/Foo.h", &code));
3629 EXPECT_THAT(code, testing::HasSubstr("::p::Enum e = ::p::Enum(::p::Enum::BAR);"));
3630}
3631
3632TEST_F(AidlTest, EnumWithDefaults_Ndk) {
3633 io_delegate_.SetFileContents("a/p/Enum.aidl", "package p; enum Enum { FOO, BAR }");
3634 io_delegate_.SetFileContents("a/p/Foo.aidl", R"(
3635package p;
3636import p.Enum;
3637parcelable Foo {
3638 Enum e = Enum.BAR;
3639})");
3640 CaptureStderr();
3641 auto options = Options::From("aidl -I a --lang ndk -o out -h out a/p/Foo.aidl");
3642 EXPECT_EQ(0, aidl::compile_aidl(options, io_delegate_));
3643 auto err = GetCapturedStderr();
3644 EXPECT_EQ("", err);
3645
3646 string code;
3647 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/aidl/p/Foo.h", &code));
3648 EXPECT_THAT(code, testing::HasSubstr("::aidl::p::Enum e = ::aidl::p::Enum::BAR;"));
3649}
3650
3651TEST_F(AidlTest, EnumWithDefaults_Rust) {
3652 io_delegate_.SetFileContents("a/p/Enum.aidl", "package p; enum Enum { FOO, BAR }");
3653 io_delegate_.SetFileContents("a/p/Foo.aidl", R"(
3654package p;
3655import p.Enum;
3656parcelable Foo {
3657 int n = 42;
3658 Enum e = Enum.BAR;
3659})");
3660 CaptureStderr();
3661 auto options = Options::From("aidl -I a --lang rust -o out -h out a/p/Foo.aidl");
3662 EXPECT_EQ(0, aidl::compile_aidl(options, io_delegate_));
3663 auto err = GetCapturedStderr();
3664 EXPECT_EQ("", err);
3665
3666 string code;
3667 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/p/Foo.rs", &code));
3668 EXPECT_THAT(code, testing::HasSubstr(R"(
3669 fn default() -> Self {
3670 Self {
3671 n: 42,
3672 e: crate::mangled::_1_p_4_Enum::BAR,
3673 }
3674 })"));
3675}
3676
3677TEST_P(AidlTest, EnumeratorIsConstantValue_DefaultValue) {
3678 import_paths_.insert("a");
3679 io_delegate_.SetFileContents("a/p/Enum.aidl", "package p; enum Enum { FOO = 1, BAR = 2}");
3680 CaptureStderr();
3681 const AidlDefinedType* type = Parse("a/p/Foo.aidl", R"(
3682package p;
3683import p.Enum;
3684parcelable Foo {
3685 int e = Enum.FOO | Enum.BAR;
3686})",
3687 typenames_, GetLanguage());
3688 auto err = GetCapturedStderr();
3689 EXPECT_EQ("", err);
3690 EXPECT_TRUE(type);
3691 const auto& fields = type->AsStructuredParcelable()->GetFields();
3692 EXPECT_EQ("int e = 3", fields[0]->ToString());
3693}
3694
3695TEST_P(AidlTest, EnumeratorIsConstantValue_CanDefineOtherEnumerator) {
3696 CaptureStderr();
3697 const AidlDefinedType* type = Parse("a/p/Foo.aidl", R"(
3698@Backing(type="int")
3699enum Foo {
3700 STANDARD_SHIFT = 16,
3701 STANDARD_BT709 = 1 << STANDARD_SHIFT,
3702 STANDARD_BT601_625 = 2 << STANDARD_SHIFT,
3703}
3704)",
3705 typenames_, GetLanguage());
3706 auto err = GetCapturedStderr();
3707 EXPECT_EQ("", err);
3708 EXPECT_TRUE(type);
3709 const auto& enum_type = type->AsEnumDeclaration();
3710 string code;
Jooyung Han1f56b702021-02-11 13:16:15 +09003711 auto writer = CodeWriter::ForString(&code);
3712 DumpVisitor visitor(*writer);
3713 visitor.Visit(*enum_type);
3714 writer->Close();
Jooyung Han690f5842020-12-04 13:02:04 +09003715 EXPECT_EQ(R"--(@Backing(type="int")
3716enum Foo {
3717 STANDARD_SHIFT = 16,
3718 STANDARD_BT709 = 65536,
3719 STANDARD_BT601_625 = 131072,
3720}
3721)--",
3722 code);
3723}
3724
3725TEST_F(AidlTest, EnumDefaultShouldBeEnumerators) {
3726 io_delegate_.SetFileContents("a/p/Enum.aidl", "package p; enum Enum { FOO = 1, BAR = 2}");
3727 io_delegate_.SetFileContents("a/p/Foo.aidl", R"(
3728package p;
3729import p.Enum;
3730parcelable Foo {
3731 Enum e = Enum.FOO | Enum.BAR;
3732})");
3733 CaptureStderr();
3734 auto options = Options::From("aidl -I a --lang java -o out -h out a/p/Foo.aidl");
3735 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
3736 auto err = GetCapturedStderr();
3737 EXPECT_EQ("ERROR: a/p/Foo.aidl:5.11-20: Invalid value (Enum.FOO|Enum.BAR) for enum p.Enum\n",
3738 err);
3739}
3740
3741TEST_P(AidlTest, DefaultWithEmptyArray) {
3742 io_delegate_.SetFileContents("a/p/Foo.aidl", "package p; parcelable Foo { p.Bar[] bars = {}; }");
3743 io_delegate_.SetFileContents("a/p/Bar.aidl", "package p; parcelable Bar { }");
3744 CaptureStderr();
Jooyung Han9435e9a2021-01-06 10:16:31 +09003745 auto options =
3746 Options::From("aidl -I a --lang " + to_string(GetLanguage()) + " -o out -h out a/p/Foo.aidl");
Jooyung Han690f5842020-12-04 13:02:04 +09003747 EXPECT_EQ(0, aidl::compile_aidl(options, io_delegate_));
3748 auto err = GetCapturedStderr();
3749 EXPECT_EQ("", err);
3750}
3751
3752TEST_P(AidlTest, RejectRefsInAnnotation) {
3753 io_delegate_.SetFileContents("a/p/IFoo.aidl",
3754 "package p; interface IFoo {\n"
3755 " const String ANNOTATION = \"@Annotation\";\n"
3756 " @JavaPassthrough(annotation=ANNOTATION) void foo();\n"
3757 "}");
3758 CaptureStderr();
Jooyung Han9435e9a2021-01-06 10:16:31 +09003759 auto options =
3760 Options::From("aidl --lang " + to_string(GetLanguage()) + " -o out -h out a/p/IFoo.aidl");
Jooyung Han690f5842020-12-04 13:02:04 +09003761 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
3762 auto err = GetCapturedStderr();
3763 EXPECT_EQ(
3764 "ERROR: a/p/IFoo.aidl:3.31-41: Value must be a constant expression but contains reference to "
3765 "ANNOTATION.\n",
3766 err);
3767}
3768
3769TEST_F(AidlTest, DefaultWithEnumValues) {
3770 io_delegate_.SetFileContents(
3771 "a/p/Foo.aidl",
3772 "package p; import p.Bar; parcelable Foo { Bar[] bars = { Bar.FOO, Bar.FOO }; }");
3773 io_delegate_.SetFileContents("a/p/Bar.aidl", "package p; enum Bar { FOO, BAR }");
3774 CaptureStderr();
3775 auto options = Options::From("aidl -I a --lang ndk -o out -h out a/p/Foo.aidl");
3776 EXPECT_EQ(0, aidl::compile_aidl(options, io_delegate_));
3777 auto err = GetCapturedStderr();
3778 EXPECT_EQ("", err);
3779 string code;
3780 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/aidl/p/Foo.h", &code));
3781 EXPECT_THAT(
3782 code, testing::HasSubstr(
3783 "std::vector<::aidl::p::Bar> bars = {::aidl::p::Bar::FOO, ::aidl::p::Bar::FOO};"));
3784}
3785
Jooyung Han14259392020-12-07 10:00:08 +09003786TEST_F(AidlTest, RejectsCircularReferencingEnumerators) {
3787 io_delegate_.SetFileContents("a/p/Foo.aidl", "package p; enum Foo { A = B, B }");
3788 CaptureStderr();
3789 auto options = Options::From("aidl -I a --lang ndk -o out -h out a/p/Foo.aidl");
3790 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
3791 auto err = GetCapturedStderr();
Jooyung Hanb9d60e02021-05-21 07:54:17 +09003792 EXPECT_EQ("ERROR: a/p/Foo.aidl:1.26-28: Found a circular reference: B -> A -> B\n", err);
Jooyung Han14259392020-12-07 10:00:08 +09003793}
3794
3795TEST_F(AidlTest, RejectsCircularReferencingConsts) {
3796 io_delegate_.SetFileContents("a/p/Foo.aidl",
3797 "package p; parcelable Foo { const int A = A + 1; }");
3798 CaptureStderr();
3799 auto options = Options::From("aidl -I a --lang ndk -o out -h out a/p/Foo.aidl");
3800 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
3801 auto err = GetCapturedStderr();
Jooyung Han29813842020-12-08 01:28:03 +09003802 EXPECT_EQ("ERROR: a/p/Foo.aidl:1.42-44: Found a circular reference: A -> A\n", err);
3803}
3804
3805TEST_F(AidlTest, RecursiveReferences) {
3806 io_delegate_.SetFileContents("a/p/Foo.aidl",
3807 "package p; parcelable Foo { const int A = p.Bar.A + 1; }");
3808 io_delegate_.SetFileContents("a/p/Bar.aidl",
3809 "package p; parcelable Bar { const int A = p.Baz.A + 1; }");
3810 io_delegate_.SetFileContents("a/p/Baz.aidl", "package p; parcelable Baz { const int A = 1; }");
3811 CaptureStderr();
3812 auto options = Options::From("aidl -I a --lang ndk -o out -h out a/p/Foo.aidl");
3813 EXPECT_EQ(0, aidl::compile_aidl(options, io_delegate_));
3814 EXPECT_EQ("", GetCapturedStderr());
3815}
3816
Jooyung Hanb9d60e02021-05-21 07:54:17 +09003817TEST_P(AidlTest, CircularReferenceWithFullyQualified) {
3818 io_delegate_.SetFileContents("Foo.aidl", "enum Foo { A = Foo.A }");
3819 auto options =
3820 Options::From("aidl --lang " + to_string(GetLanguage()) + " -I . -o out -h out Foo.aidl");
3821 const string err = "ERROR: Foo.aidl:1.15-21: Found a circular reference: Foo.A -> Foo.A\n";
3822 CaptureStderr();
3823 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
3824 EXPECT_EQ(err, GetCapturedStderr());
3825}
3826
3827TEST_P(AidlTest, ConstRefsCanPointToTheSameValue) {
3828 io_delegate_.SetFileContents("Foo.aidl", "enum Foo { A = 0 }");
3829 // this demonstrates the case that "Foo.A" const-ref node is visited twice by B and C.
3830 io_delegate_.SetFileContents("Bar.aidl", "enum Bar { A = Foo.A, B = A, C = A }");
3831 auto options =
3832 Options::From("aidl --lang " + to_string(GetLanguage()) + " -I . -o out -h out Bar.aidl");
3833 CaptureStderr();
3834 EXPECT_EQ(0, aidl::compile_aidl(options, io_delegate_));
3835 EXPECT_EQ("", GetCapturedStderr());
3836}
3837
Jooyung Hane9f5b272021-01-07 00:18:11 +09003838TEST_P(AidlTest, UnknownConstReference) {
3839 io_delegate_.SetFileContents("Foo.aidl", " parcelable Foo { UnknownType field = UNKNOWN_REF; }");
3840 auto options =
3841 Options::From("aidl --lang " + to_string(GetLanguage()) + " -o out -h out Foo.aidl");
3842 const string err =
3843 "ERROR: Foo.aidl:1.18-30: Failed to resolve 'UnknownType'\n"
3844 "ERROR: Foo.aidl:1.38-50: Can't find UNKNOWN_REF in Foo\n"
3845 "ERROR: Foo.aidl:1.38-50: Unknown reference 'UNKNOWN_REF'\n";
3846 CaptureStderr();
3847 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
3848 EXPECT_EQ(err, GetCapturedStderr());
3849}
3850
Jooyung Han29813842020-12-08 01:28:03 +09003851TEST_P(AidlTest, JavaCompatibleBuiltinTypes) {
3852 string contents = R"(
3853import android.os.IBinder;
3854import android.os.IInterface;
3855interface IFoo {}
3856 )";
3857 EXPECT_NE(nullptr, Parse("IFoo.aidl", contents, typenames_, GetLanguage()));
Jooyung Han14259392020-12-07 10:00:08 +09003858}
3859
Jooyung Han888c5bc2020-12-22 17:28:47 +09003860TEST_P(AidlTest, WarningInterfaceName) {
3861 io_delegate_.SetFileContents("p/Foo.aidl", "interface Foo {}");
Jooyung Han9435e9a2021-01-06 10:16:31 +09003862 auto options = Options::From("aidl --lang " + to_string(GetLanguage()) +
Jooyung Han888c5bc2020-12-22 17:28:47 +09003863 " -Weverything -o out -h out p/Foo.aidl");
3864 CaptureStderr();
3865 EXPECT_EQ(0, aidl::compile_aidl(options, io_delegate_));
Jooyung Han808a2a02020-12-28 16:46:54 +09003866 EXPECT_EQ("WARNING: p/Foo.aidl:1.1-10: Interface names should start with I. [-Winterface-name]\n",
Jooyung Han888c5bc2020-12-22 17:28:47 +09003867 GetCapturedStderr());
3868}
3869
3870TEST_P(AidlTest, ErrorInterfaceName) {
3871 io_delegate_.SetFileContents("p/Foo.aidl", "interface Foo {}");
Jooyung Han9435e9a2021-01-06 10:16:31 +09003872 auto options = Options::From("aidl --lang " + to_string(GetLanguage()) +
Jooyung Han888c5bc2020-12-22 17:28:47 +09003873 " -Weverything -Werror -o out -h out p/Foo.aidl");
3874 CaptureStderr();
3875 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
Jooyung Han808a2a02020-12-28 16:46:54 +09003876 EXPECT_EQ("ERROR: p/Foo.aidl:1.1-10: Interface names should start with I. [-Winterface-name]\n",
Jooyung Han3b990182020-12-22 17:44:31 +09003877 GetCapturedStderr());
3878}
3879
Jiyong Park9f4c3822021-04-07 20:36:45 +09003880TEST_F(AidlTest, RejectsIncorrectOutputFilePathOnLegacyCppInput) {
3881 const std::string input_file = "base/p/q/IFoo.aidl";
3882 const std::string header_dir = "out/";
3883 const std::string output_file = "out/base/p/q/IFoo.cpp";
3884 const std::string package = "p.q"; // not base.p.q
3885 io_delegate_.SetFileContents(input_file, "package " + package + "; interface IFoo {}");
3886
3887 auto options = Options::From({"aidl-cpp", input_file, header_dir, output_file});
3888 CaptureStderr();
3889 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
3890 EXPECT_THAT(
3891 GetCapturedStderr(),
3892 testing::StartsWith(
3893 "ERROR: base/p/q/IFoo.aidl:1.13-23: Output file is expected to be at out/p/q/IFoo.cpp, "
3894 "but is out/base/p/q/IFoo.cpp."));
3895}
3896
Jooyung Hanb7a60ec2021-01-21 13:47:59 +09003897TEST_F(AidlTest, FormatCommentsForJava) {
3898 using android::aidl::FormatCommentsForJava;
3899
3900 struct TestCase {
3901 vector<Comment> comments;
3902 string formatted;
3903 };
3904 vector<TestCase> testcases = {
3905 {{}, ""},
3906 {{{"// line comments\n"}}, "// line comments\n"},
3907 {{{"// @hide \n"}}, "// @hide \n"},
3908 // Transform the last block comment as Javadoc.
3909 {{{"/*\n"
3910 " * Hello, world!\n"
3911 " */"}},
3912 "/**\n"
3913 " * Hello, world!\n"
3914 " */"},
3915 {{{"/* @hide */"}}, "/** @hide */"},
3916 {{{"/**\n"
3917 " @param foo ...\n"
3918 "*/"}},
3919 "/**\n"
3920 " @param foo ...\n"
3921 "*/"},
3922 {{{"/* @hide */"}, {"/* @hide */"}}, "/* @hide *//** @hide */"},
3923 {{{"/* @deprecated first */"}, {"/* @deprecated second */"}},
3924 "/* @deprecated first *//** @deprecated second */"},
3925 {{{"/* @deprecated */"}, {"/** @param foo */"}}, "/* @deprecated *//** @param foo */"},
3926 // Line comments are printed as they are
3927 {{{"/* @deprecated */"}, {"// line comments\n"}}, "/* @deprecated */// line comments\n"},
3928 };
3929 for (const auto& [input, formatted] : testcases) {
3930 EXPECT_EQ(formatted, FormatCommentsForJava(input));
3931 }
3932}
3933
Jooyung Han2d6b5c42021-01-09 01:01:06 +09003934TEST_F(AidlTest, HideIsNotForArgs) {
3935 io_delegate_.SetFileContents("IFoo.aidl",
3936 "interface IFoo {\n"
3937 " void foo(in @Hide int x);\n"
3938 "}");
3939 auto options = Options::From("aidl --lang=java IFoo.aidl");
3940 CaptureStderr();
3941 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
3942 EXPECT_THAT(GetCapturedStderr(), HasSubstr("@Hide is not available"));
3943}
3944
3945TEST_F(AidlTest, SuppressWarningsIsNotForArgs) {
3946 io_delegate_.SetFileContents(
3947 "IFoo.aidl",
3948 "interface IFoo {\n"
3949 " void foo(in @SuppressWarnings(value=\"inout-parameter\") int x);\n"
3950 "}");
3951 auto options = Options::From("aidl --lang=java IFoo.aidl");
3952 CaptureStderr();
3953 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
3954 EXPECT_THAT(GetCapturedStderr(), HasSubstr("@SuppressWarnings is not available"));
3955}
3956
Jooyung Hanfd3be322020-12-13 09:11:06 +09003957struct TypeParam {
Jooyung Hane87cdd02020-12-11 16:47:35 +09003958 string kind;
3959 string literal;
3960};
3961
Jooyung Hanfd3be322020-12-13 09:11:06 +09003962const TypeParam kTypeParams[] = {
Jooyung Hancea89002021-02-15 17:04:04 +09003963 {"primitive", "int"}, {"primitiveArray", "int[]"},
3964 {"String", "String"}, {"StringArray", "String[]"},
Jooyung Hane87cdd02020-12-11 16:47:35 +09003965 {"IBinder", "IBinder"}, {"ParcelFileDescriptor", "ParcelFileDescriptor"},
3966 {"parcelable", "Foo"}, {"enum", "a.Enum"},
3967 {"union", "a.Union"}, {"interface", "a.IBar"},
3968};
3969
3970const std::map<std::string, std::string> kListSupportExpectations = {
3971 {"cpp_primitive", "A generic type cannot have any primitive type parameters."},
3972 {"java_primitive", "A generic type cannot have any primitive type parameters."},
3973 {"ndk_primitive", "A generic type cannot have any primitive type parameters."},
3974 {"rust_primitive", "A generic type cannot have any primitive type parameters."},
Jooyung Hancea89002021-02-15 17:04:04 +09003975 {"cpp_primitiveArray", "List of arrays is not supported."},
3976 {"java_primitiveArray", "List of arrays is not supported."},
3977 {"ndk_primitiveArray", "List of arrays is not supported."},
3978 {"rust_primitiveArray", "List of arrays is not supported."},
Jooyung Hane87cdd02020-12-11 16:47:35 +09003979 {"cpp_String", ""},
3980 {"java_String", ""},
3981 {"ndk_String", ""},
3982 {"rust_String", ""},
Jooyung Hancea89002021-02-15 17:04:04 +09003983 {"cpp_StringArray", "List of arrays is not supported."},
3984 {"java_StringArray", "List of arrays is not supported."},
3985 {"ndk_StringArray", "List of arrays is not supported."},
3986 {"rust_StringArray", "List of arrays is not supported."},
Jooyung Hane87cdd02020-12-11 16:47:35 +09003987 {"cpp_IBinder", ""},
3988 {"java_IBinder", ""},
3989 {"ndk_IBinder", "List<IBinder> is not supported. List in NDK doesn't support IBinder."},
3990 {"rust_IBinder", ""},
Jooyung Han55f96ad2020-12-13 10:08:33 +09003991 {"cpp_ParcelFileDescriptor", ""},
Jooyung Hane87cdd02020-12-11 16:47:35 +09003992 {"java_ParcelFileDescriptor", ""},
3993 {"ndk_ParcelFileDescriptor", ""},
3994 {"rust_ParcelFileDescriptor", ""},
Jooyung Han55f96ad2020-12-13 10:08:33 +09003995 {"cpp_interface", "List<a.IBar> is not supported."},
3996 {"java_interface", "List<a.IBar> is not supported."},
3997 {"ndk_interface", "List<a.IBar> is not supported."},
3998 {"rust_interface", "List<a.IBar> is not supported."},
3999 {"cpp_parcelable", ""},
Jooyung Hane87cdd02020-12-11 16:47:35 +09004000 {"java_parcelable", ""},
4001 {"ndk_parcelable", ""},
4002 {"rust_parcelable", ""},
4003 {"cpp_enum", "A generic type cannot have any primitive type parameters."},
4004 {"java_enum", "A generic type cannot have any primitive type parameters."},
4005 {"ndk_enum", "A generic type cannot have any primitive type parameters."},
4006 {"rust_enum", "A generic type cannot have any primitive type parameters."},
Jooyung Han55f96ad2020-12-13 10:08:33 +09004007 {"cpp_union", ""},
Jooyung Hane87cdd02020-12-11 16:47:35 +09004008 {"java_union", ""},
4009 {"ndk_union", ""},
4010 {"rust_union", ""},
4011};
4012
Jooyung Hand236e552020-12-13 09:21:27 +09004013const std::map<std::string, std::string> kArraySupportExpectations = {
4014 {"cpp_primitive", ""},
4015 {"java_primitive", ""},
4016 {"ndk_primitive", ""},
4017 {"rust_primitive", ""},
Jooyung Hancea89002021-02-15 17:04:04 +09004018 {"cpp_primitiveArray", "Can only have one dimensional arrays."},
4019 {"java_primitiveArray", "Can only have one dimensional arrays."},
4020 {"ndk_primitiveArray", "Can only have one dimensional arrays."},
4021 {"rust_primitiveArray", "Can only have one dimensional arrays."},
Jooyung Hand236e552020-12-13 09:21:27 +09004022 {"cpp_String", ""},
4023 {"java_String", ""},
4024 {"ndk_String", ""},
4025 {"rust_String", ""},
Jooyung Hancea89002021-02-15 17:04:04 +09004026 {"cpp_StringArray", "Can only have one dimensional arrays."},
4027 {"java_StringArray", "Can only have one dimensional arrays."},
4028 {"ndk_StringArray", "Can only have one dimensional arrays."},
4029 {"rust_StringArray", "Can only have one dimensional arrays."},
Jooyung Hand236e552020-12-13 09:21:27 +09004030 {"cpp_IBinder", ""},
4031 {"java_IBinder", ""},
4032 {"ndk_IBinder", "The ndk backend does not support array of IBinder"},
4033 {"rust_IBinder", "The rust backend does not support array of IBinder"},
4034 {"cpp_ParcelFileDescriptor", ""},
4035 {"java_ParcelFileDescriptor", ""},
4036 {"ndk_ParcelFileDescriptor", ""},
4037 {"rust_ParcelFileDescriptor", ""},
4038 {"cpp_interface", "Binder type cannot be an array"},
4039 {"java_interface", "Binder type cannot be an array"},
4040 {"ndk_interface", "Binder type cannot be an array"},
4041 {"rust_interface", "Binder type cannot be an array"},
4042 {"cpp_parcelable", ""},
4043 {"java_parcelable", ""},
4044 {"ndk_parcelable", ""},
4045 {"rust_parcelable", ""},
4046 {"cpp_enum", ""},
4047 {"java_enum", ""},
4048 {"ndk_enum", ""},
4049 {"rust_enum", ""},
4050 {"cpp_union", ""},
4051 {"java_union", ""},
4052 {"ndk_union", ""},
4053 {"rust_union", ""},
4054};
4055
Jooyung Hanfd3be322020-12-13 09:11:06 +09004056class AidlTypeParamTest : public testing::TestWithParam<std::tuple<Options::Language, TypeParam>> {
Jooyung Hane87cdd02020-12-11 16:47:35 +09004057 public:
Jooyung Hanfd3be322020-12-13 09:11:06 +09004058 void Run(const std::string& generic_type_decl,
4059 const std::map<std::string, std::string>& expectations) {
Jooyung Hane87cdd02020-12-11 16:47:35 +09004060 const auto& param = GetParam();
Jooyung Han9435e9a2021-01-06 10:16:31 +09004061 const auto& lang = to_string(std::get<0>(param));
Jooyung Hane87cdd02020-12-11 16:47:35 +09004062 const auto& kind = std::get<1>(param).kind;
4063
4064 FakeIoDelegate io;
4065 io.SetFileContents("a/IBar.aidl", "package a; interface IBar { }");
4066 io.SetFileContents("a/Enum.aidl", "package a; enum Enum { A }");
4067 io.SetFileContents("a/Union.aidl", "package a; union Union { int a; }");
Jooyung Hanfd3be322020-12-13 09:11:06 +09004068 std::string decl = fmt::format(generic_type_decl, std::get<1>(param).literal);
4069 io.SetFileContents("a/Foo.aidl", "package a; parcelable Foo { " + decl + " f; }");
Jooyung Hane87cdd02020-12-11 16:47:35 +09004070
4071 const auto options =
4072 Options::From(fmt::format("aidl -I . --lang={} a/Foo.aidl -o out -h out", lang));
4073 CaptureStderr();
4074 compile_aidl(options, io);
Jooyung Hanfd3be322020-12-13 09:11:06 +09004075 auto it = expectations.find(lang + "_" + kind);
4076 EXPECT_TRUE(it != expectations.end());
Jooyung Hane87cdd02020-12-11 16:47:35 +09004077 const string err = GetCapturedStderr();
4078 if (it->second.empty()) {
4079 EXPECT_EQ("", err);
4080 } else {
4081 EXPECT_THAT(err, testing::HasSubstr(it->second));
4082 }
4083 }
4084};
4085
4086INSTANTIATE_TEST_SUITE_P(
Jooyung Hanfd3be322020-12-13 09:11:06 +09004087 AidlTestSuite, AidlTypeParamTest,
Jooyung Hane87cdd02020-12-11 16:47:35 +09004088 testing::Combine(testing::Values(Options::Language::CPP, Options::Language::JAVA,
4089 Options::Language::NDK, Options::Language::RUST),
Jooyung Hanfd3be322020-12-13 09:11:06 +09004090 testing::ValuesIn(kTypeParams)),
4091 [](const testing::TestParamInfo<std::tuple<Options::Language, TypeParam>>& info) {
Jooyung Han9435e9a2021-01-06 10:16:31 +09004092 return to_string(std::get<0>(info.param)) + "_" + std::get<1>(info.param).kind;
Jooyung Hane87cdd02020-12-11 16:47:35 +09004093 });
4094
Jooyung Hanfd3be322020-12-13 09:11:06 +09004095TEST_P(AidlTypeParamTest, ListSupportedTypes) {
4096 Run("List<{}>", kListSupportExpectations);
4097}
Jooyung Hane87cdd02020-12-11 16:47:35 +09004098
Jooyung Hand236e552020-12-13 09:21:27 +09004099TEST_P(AidlTypeParamTest, ArraySupportedTypes) {
4100 Run("{}[]", kArraySupportExpectations);
4101}
4102
Christopher Wiley90be4e32015-10-20 14:55:25 -07004103} // namespace aidl
4104} // namespace android