blob: 8eef049ff258b6ee28a313a2bc31194c7cf1c8e3 [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
Devin Moore7b8d5c92020-03-17 14:14:08 -0700286TEST_P(AidlTest, RejectsDuplicatedAnnotationParams) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700287 const string method = "package a; interface IFoo { @UnsupportedAppUsage(foo=1, foo=2)void f(); }";
288 const string expected_stderr = "ERROR: a/IFoo.aidl:1.56-62: Trying to redefine parameter foo.\n";
289 CaptureStderr();
Devin Moore7b8d5c92020-03-17 14:14:08 -0700290 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", method, typenames_, GetLanguage()));
Devin Moore097a3ab2020-03-11 16:08:44 -0700291 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Andrei Onea9445fc62019-06-27 18:11:59 +0100292}
293
Devin Moore7b8d5c92020-03-17 14:14:08 -0700294TEST_P(AidlTest, RejectUnsupportedInterfaceAnnotations) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700295 AidlError error;
296 const string method = "package a; @nullable interface IFoo { int f(); }";
Devin Moorec054bf82020-03-10 16:31:48 -0700297 CaptureStderr();
Devin Moore7b8d5c92020-03-17 14:14:08 -0700298 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", method, typenames_, GetLanguage(), &error));
Jooyung Han2d6b5c42021-01-09 01:01:06 +0900299 EXPECT_THAT(GetCapturedStderr(), HasSubstr("@nullable is not available."));
Devin Moorec054bf82020-03-10 16:31:48 -0700300 EXPECT_EQ(AidlError::BAD_TYPE, error);
Devin Moore24f68572020-02-26 13:20:59 -0800301}
302
Devin Moore7b8d5c92020-03-17 14:14:08 -0700303TEST_P(AidlTest, RejectUnsupportedTypeAnnotations) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700304 AidlError error;
305 const string method = "package a; interface IFoo { @JavaOnlyStableParcelable int f(); }";
Devin Moorec054bf82020-03-10 16:31:48 -0700306 CaptureStderr();
Devin Moore7b8d5c92020-03-17 14:14:08 -0700307 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", method, typenames_, GetLanguage(), &error));
Jooyung Han2d6b5c42021-01-09 01:01:06 +0900308 EXPECT_THAT(GetCapturedStderr(), HasSubstr("@JavaOnlyStableParcelable is not available."));
Devin Moorec054bf82020-03-10 16:31:48 -0700309 EXPECT_EQ(AidlError::BAD_TYPE, error);
Devin Moore24f68572020-02-26 13:20:59 -0800310}
311
Devin Moore7b8d5c92020-03-17 14:14:08 -0700312TEST_P(AidlTest, RejectUnsupportedParcelableAnnotations) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700313 AidlError error;
314 const string method = "package a; @nullable parcelable IFoo cpp_header \"IFoo.h\";";
Devin Moorec054bf82020-03-10 16:31:48 -0700315 CaptureStderr();
Steven Morelandebc3c5d2020-09-30 23:40:33 +0000316 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", method, typenames_, GetLanguage(), &error));
Jooyung Han2d6b5c42021-01-09 01:01:06 +0900317 EXPECT_THAT(GetCapturedStderr(), HasSubstr("@nullable is not available."));
Devin Moorec054bf82020-03-10 16:31:48 -0700318 EXPECT_EQ(AidlError::BAD_TYPE, error);
Devin Moore24f68572020-02-26 13:20:59 -0800319}
320
Devin Moore7b8d5c92020-03-17 14:14:08 -0700321TEST_P(AidlTest, RejectUnsupportedParcelableDefineAnnotations) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700322 AidlError error;
Steven Morelandebc3c5d2020-09-30 23:40:33 +0000323 const string method = "package a; @nullable parcelable IFoo { String a; String b; }";
Devin Moorec054bf82020-03-10 16:31:48 -0700324 CaptureStderr();
Steven Morelandebc3c5d2020-09-30 23:40:33 +0000325 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", method, typenames_, GetLanguage(), &error));
Jooyung Han2d6b5c42021-01-09 01:01:06 +0900326 EXPECT_THAT(GetCapturedStderr(), HasSubstr("@nullable is not available."));
Devin Moorec054bf82020-03-10 16:31:48 -0700327 EXPECT_EQ(AidlError::BAD_TYPE, error);
Devin Moore24f68572020-02-26 13:20:59 -0800328}
329
Jiyong Park40782d02020-07-24 19:17:43 +0900330TEST_P(AidlTest, ParsesNonNullableAnnotation) {
331 auto parse_result =
332 Parse("a/IFoo.aidl", "package a; interface IFoo { String f(); }", typenames_, GetLanguage());
333 ASSERT_NE(nullptr, parse_result);
334 const AidlInterface* interface = parse_result->AsInterface();
335 ASSERT_NE(nullptr, interface);
336 ASSERT_FALSE(interface->GetMethods().empty());
337 EXPECT_FALSE(interface->GetMethods()[0]->GetType().IsNullable());
338}
339
Devin Moore7b8d5c92020-03-17 14:14:08 -0700340TEST_P(AidlTest, ParsesNullableAnnotation) {
Jiyong Park40782d02020-07-24 19:17:43 +0900341 auto parse_result = Parse("a/IFoo.aidl", "package a; interface IFoo { @nullable String f(); }",
342 typenames_, GetLanguage());
343 ASSERT_NE(nullptr, parse_result);
344 const AidlInterface* interface = parse_result->AsInterface();
345 ASSERT_NE(nullptr, interface);
346 ASSERT_FALSE(interface->GetMethods().empty());
347 EXPECT_TRUE(interface->GetMethods()[0]->GetType().IsNullable());
348}
349
350TEST_P(AidlTest, ParsesNonUtf8Annotations) {
351 auto parse_result =
352 Parse("a/IFoo.aidl", "package a; interface IFoo { String f(); }", typenames_, GetLanguage());
353 ASSERT_NE(nullptr, parse_result);
354 const AidlInterface* interface = parse_result->AsInterface();
355 ASSERT_NE(nullptr, interface);
356 ASSERT_FALSE(interface->GetMethods().empty());
357 EXPECT_FALSE(interface->GetMethods()[0]->GetType().IsUtf8InCpp());
Christopher Wileyec31a052016-01-25 07:28:51 -0800358}
359
Devin Moore7b8d5c92020-03-17 14:14:08 -0700360TEST_P(AidlTest, ParsesUtf8Annotations) {
Jiyong Park40782d02020-07-24 19:17:43 +0900361 auto parse_result = Parse("a/IFoo.aidl", "package a; interface IFoo { @utf8InCpp String f(); }",
362 typenames_, GetLanguage());
363 ASSERT_NE(nullptr, parse_result);
364 const AidlInterface* interface = parse_result->AsInterface();
365 ASSERT_NE(nullptr, interface);
366 ASSERT_FALSE(interface->GetMethods().empty());
367 EXPECT_TRUE(interface->GetMethods()[0]->GetType().IsUtf8InCpp());
Christopher Wileyec31a052016-01-25 07:28:51 -0800368}
369
Devin Moore7b8d5c92020-03-17 14:14:08 -0700370TEST_P(AidlTest, VintfRequiresStructuredAndStability) {
Steven Morelanda57d0a62019-07-30 09:41:14 -0700371 AidlError error;
Devin Moore0d0e3f62020-03-30 17:45:39 -0700372 const string expected_stderr =
373 "ERROR: IFoo.aidl:1.16-26: Must compile @VintfStability type w/ aidl_interface 'stability: "
374 "\"vintf\"'\n"
375 "ERROR: IFoo.aidl:1.16-26: Must compile @VintfStability type w/ aidl_interface "
376 "--structured\n";
377 CaptureStderr();
Devin Moore097a3ab2020-03-11 16:08:44 -0700378 ASSERT_EQ(nullptr, Parse("IFoo.aidl", "@VintfStability interface IFoo {}", typenames_,
Devin Moore7b8d5c92020-03-17 14:14:08 -0700379 GetLanguage(), &error));
Devin Moore0d0e3f62020-03-30 17:45:39 -0700380 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Steven Morelanda57d0a62019-07-30 09:41:14 -0700381 ASSERT_EQ(AidlError::NOT_STRUCTURED, error);
Steven Morelanda57d0a62019-07-30 09:41:14 -0700382}
383
Devin Moore7b8d5c92020-03-17 14:14:08 -0700384TEST_P(AidlTest, VintfRequiresStructured) {
Steven Morelanda57d0a62019-07-30 09:41:14 -0700385 AidlError error;
Devin Moore0d0e3f62020-03-30 17:45:39 -0700386 const string expected_stderr =
387 "ERROR: IFoo.aidl:1.16-26: Must compile @VintfStability type w/ aidl_interface "
388 "--structured\n";
389 CaptureStderr();
Devin Moore097a3ab2020-03-11 16:08:44 -0700390 ASSERT_EQ(nullptr, Parse("IFoo.aidl", "@VintfStability interface IFoo {}", typenames_,
Devin Moore7b8d5c92020-03-17 14:14:08 -0700391 GetLanguage(), &error, {"--stability", "vintf"}));
Devin Moore0d0e3f62020-03-30 17:45:39 -0700392 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Steven Morelanda57d0a62019-07-30 09:41:14 -0700393 ASSERT_EQ(AidlError::NOT_STRUCTURED, error);
Steven Morelanda57d0a62019-07-30 09:41:14 -0700394}
395
Devin Moore7b8d5c92020-03-17 14:14:08 -0700396TEST_P(AidlTest, VintfRequiresSpecifiedStability) {
Steven Morelanda57d0a62019-07-30 09:41:14 -0700397 AidlError error;
Devin Moore097a3ab2020-03-11 16:08:44 -0700398 const string expected_stderr =
399 "ERROR: IFoo.aidl:1.16-26: Must compile @VintfStability type w/ aidl_interface 'stability: "
400 "\"vintf\"'\n";
401 CaptureStderr();
402 ASSERT_EQ(nullptr, Parse("IFoo.aidl", "@VintfStability interface IFoo {}", typenames_,
Devin Moore7b8d5c92020-03-17 14:14:08 -0700403 GetLanguage(), &error, {"--structured"}));
Devin Moore097a3ab2020-03-11 16:08:44 -0700404 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Steven Morelanda57d0a62019-07-30 09:41:14 -0700405 ASSERT_EQ(AidlError::NOT_STRUCTURED, error);
Steven Morelanda57d0a62019-07-30 09:41:14 -0700406}
407
Devin Moore7b8d5c92020-03-17 14:14:08 -0700408TEST_P(AidlTest, ParsesStabilityAnnotations) {
Steven Morelanda57d0a62019-07-30 09:41:14 -0700409 AidlError error;
Devin Moore7b8d5c92020-03-17 14:14:08 -0700410 auto parse_result = Parse("IFoo.aidl", "@VintfStability interface IFoo {}", typenames_,
411 GetLanguage(), &error, {"--structured", "--stability", "vintf"});
Steven Morelanda57d0a62019-07-30 09:41:14 -0700412 ASSERT_EQ(AidlError::OK, error);
413 ASSERT_NE(nullptr, parse_result);
414 const AidlInterface* interface = parse_result->AsInterface();
415 ASSERT_NE(nullptr, interface);
416 ASSERT_TRUE(interface->IsVintfStability());
Steven Morelanda57d0a62019-07-30 09:41:14 -0700417}
418
Jeongik Cha64783ed2019-06-07 18:30:54 +0900419TEST_F(AidlTest, ParsesJavaOnlyStableParcelable) {
420 Options java_options = Options::From("aidl -o out --structured a/Foo.aidl");
Jeongik Cha88f95a82020-01-15 13:02:16 +0900421 Options cpp_options = Options::From("aidl --lang=cpp -o out -h out/include a/Foo.aidl");
422 Options cpp_structured_options =
Jeongik Cha64783ed2019-06-07 18:30:54 +0900423 Options::From("aidl --lang=cpp --structured -o out -h out/include a/Foo.aidl");
Andrei Homescub62afd92020-05-11 19:24:59 -0700424 Options rust_options = Options::From("aidl --lang=rust -o out --structured a/Foo.aidl");
Jeongik Cha64783ed2019-06-07 18:30:54 +0900425 io_delegate_.SetFileContents(
Jeongik Cha88f95a82020-01-15 13:02:16 +0900426 "a/Foo.aidl",
427 StringPrintf("package a; @JavaOnlyStableParcelable parcelable Foo cpp_header \"Foo.h\" ;"));
Jeongik Cha64783ed2019-06-07 18:30:54 +0900428
429 EXPECT_EQ(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
Jeongik Cha88f95a82020-01-15 13:02:16 +0900430 EXPECT_EQ(0, ::android::aidl::compile_aidl(cpp_options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -0700431 const string expected_stderr =
Jeongik Cha88f95a82020-01-15 13:02:16 +0900432 "ERROR: a/Foo.aidl:1.48-52: Cannot declared parcelable in a --structured interface. "
Devin Moorec054bf82020-03-10 16:31:48 -0700433 "Parcelable must be defined in AIDL directly.\n";
434 CaptureStderr();
Jeongik Cha88f95a82020-01-15 13:02:16 +0900435 EXPECT_NE(0, ::android::aidl::compile_aidl(cpp_structured_options, io_delegate_));
Devin Moorec054bf82020-03-10 16:31:48 -0700436 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Andrei Homescub62afd92020-05-11 19:24:59 -0700437
438 CaptureStderr();
439 EXPECT_NE(0, ::android::aidl::compile_aidl(rust_options, io_delegate_));
440 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jeongik Cha64783ed2019-06-07 18:30:54 +0900441}
442
Jooyung Han1cbc4962020-10-25 10:07:15 +0900443TEST_F(AidlTest, ParcelableSupportJavaDeriveToString) {
444 io_delegate_.SetFileContents("a/Foo.aidl", R"(package a;
445 @JavaDerive(toString=true) parcelable Foo { int a; float b; })");
446 Options java_options = Options::From("aidl --lang=java -o out a/Foo.aidl");
Jiyong Park43113fb2020-07-20 16:26:19 +0900447 EXPECT_EQ(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
448
449 string java_out;
Jooyung Han1cbc4962020-10-25 10:07:15 +0900450 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/Foo.java", &java_out));
Jiyong Park43113fb2020-07-20 16:26:19 +0900451 EXPECT_THAT(java_out, testing::HasSubstr("public String toString() {"));
452
453 // Other backends shouldn't be bothered
Jooyung Han1cbc4962020-10-25 10:07:15 +0900454 Options cpp_options = Options::From("aidl --lang=cpp -o out -h out a/Foo.aidl");
Jiyong Park43113fb2020-07-20 16:26:19 +0900455 EXPECT_EQ(0, ::android::aidl::compile_aidl(cpp_options, io_delegate_));
456
Jooyung Han1cbc4962020-10-25 10:07:15 +0900457 Options ndk_options = Options::From("aidl --lang=ndk -o out -h out a/Foo.aidl");
Jiyong Park43113fb2020-07-20 16:26:19 +0900458 EXPECT_EQ(0, ::android::aidl::compile_aidl(ndk_options, io_delegate_));
459}
460
Jooyung Han1cbc4962020-10-25 10:07:15 +0900461TEST_F(AidlTest, UnionSupportJavaDeriveToString) {
462 io_delegate_.SetFileContents("a/Foo.aidl", R"(package a;
463 @JavaDerive(toString=true) union Foo { int a; int[] b; })");
464 CaptureStderr();
465 Options java_options = Options::From("aidl --lang=java -o out a/Foo.aidl");
466 EXPECT_EQ(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
467 EXPECT_EQ("", GetCapturedStderr());
468
469 const string expected_to_string_method = R"--(
470 @Override
471 public String toString() {
472 switch (_tag) {
473 case a: return "a.Foo.a(" + (getA()) + ")";
474 case b: return "a.Foo.b(" + (java.util.Arrays.toString(getB())) + ")";
475 }
476 throw new IllegalStateException("unknown field: " + _tag);
477 }
478)--";
479
480 string java_out;
481 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/Foo.java", &java_out));
482 EXPECT_THAT(java_out, testing::HasSubstr(expected_to_string_method));
483}
484
Jiyong Park9aa3d042020-12-04 23:30:02 +0900485TEST_F(AidlTest, ParcelableSupportJavaDeriveEquals) {
486 io_delegate_.SetFileContents("a/Foo.aidl", R"(package a;
487 @JavaDerive(equals=true) parcelable Foo { int a; float b; })");
488 CaptureStderr();
489 Options java_options = Options::From("aidl --lang=java -o out a/Foo.aidl");
490 EXPECT_EQ(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
491 EXPECT_EQ("", GetCapturedStderr());
492
493 const std::string expected = R"--(
494 @Override
495 public boolean equals(Object other) {
496 if (this == other) return true;
497 if (other == null) return false;
498 if (!(other instanceof Foo)) return false;
499 Foo that = (Foo)other;
500 if (!java.util.Objects.deepEquals(a, that.a)) return false;
501 if (!java.util.Objects.deepEquals(b, that.b)) return false;
502 return true;
503 }
504
505 @Override
506 public int hashCode() {
507 return java.util.Arrays.deepHashCode(java.util.Arrays.asList(a, b).toArray());
508 }
509)--";
510
511 string java_out;
512 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/Foo.java", &java_out));
513 EXPECT_THAT(java_out, testing::HasSubstr(expected));
514}
515
516TEST_F(AidlTest, UnionSupportJavaDeriveEquals) {
517 io_delegate_.SetFileContents("a/Foo.aidl", R"(package a;
518 @JavaDerive(equals=true) union Foo { int a; int[] b; })");
519 CaptureStderr();
520 Options java_options = Options::From("aidl --lang=java -o out a/Foo.aidl");
521 EXPECT_EQ(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
522 EXPECT_EQ("", GetCapturedStderr());
523
524 const std::string expected = R"--(
525 @Override
526 public boolean equals(Object other) {
527 if (this == other) return true;
528 if (other == null) return false;
529 if (!(other instanceof Foo)) return false;
530 Foo that = (Foo)other;
531 if (_tag != that._tag) return false;
532 if (!java.util.Objects.deepEquals(_value, that._value)) return false;
533 return true;
534 }
535
536 @Override
537 public int hashCode() {
538 return java.util.Arrays.deepHashCode(java.util.Arrays.asList(_tag, _value).toArray());
539 }
540)--";
541
542 string java_out;
543 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/Foo.java", &java_out));
544 EXPECT_THAT(java_out, testing::HasSubstr(expected));
545}
546
Jooyung Han90345002020-10-23 15:28:53 +0900547TEST_F(AidlTest, RejectsJavaDeriveAnnotation) {
Jiyong Park43113fb2020-07-20 16:26:19 +0900548 {
Jooyung Han90345002020-10-23 15:28:53 +0900549 io_delegate_.SetFileContents("a/Foo.aidl",
550 "package a; @JavaDerive(blah=true) parcelable Foo{}");
551 Options java_options = Options::From("aidl --lang=java -o out a/Foo.aidl");
552 CaptureStderr();
553 EXPECT_NE(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
554 const std::string expected_stderr =
555 "ERROR: a/Foo.aidl:1.11-34: Parameter blah not supported for annotation JavaDerive.";
Jooyung Hanf8dbbcc2020-12-26 03:05:55 +0900556 EXPECT_THAT(GetCapturedStderr(),
557 HasSubstr("Parameter blah not supported for annotation JavaDerive."));
Jooyung Han90345002020-10-23 15:28:53 +0900558 }
559
560 {
561 io_delegate_.SetFileContents("a/IFoo.aidl", "package a; @JavaDerive interface IFoo{}");
Jiyong Park43113fb2020-07-20 16:26:19 +0900562 Options java_options = Options::From("aidl --lang=java -o out a/IFoo.aidl");
563 CaptureStderr();
564 EXPECT_NE(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
Jooyung Han2d6b5c42021-01-09 01:01:06 +0900565 EXPECT_THAT(GetCapturedStderr(), HasSubstr("@JavaDerive is not available."));
Jiyong Park43113fb2020-07-20 16:26:19 +0900566 }
567
568 {
Jooyung Han90345002020-10-23 15:28:53 +0900569 io_delegate_.SetFileContents("a/IFoo.aidl", "package a; @JavaDerive enum IFoo { A=1, }");
Jiyong Park43113fb2020-07-20 16:26:19 +0900570 Options java_options = Options::From("aidl --lang=java -o out a/IFoo.aidl");
571 CaptureStderr();
572 EXPECT_NE(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
Jooyung Han2d6b5c42021-01-09 01:01:06 +0900573 EXPECT_THAT(GetCapturedStderr(), HasSubstr("@JavaDerive is not available."));
Jiyong Park43113fb2020-07-20 16:26:19 +0900574 }
575}
576
Jiyong Park27fd7fd2020-08-27 16:25:09 +0900577TEST_P(AidlTest, ParseDescriptorAnnotation) {
578 AidlError error;
579 auto parse_result = Parse("IFoo.aidl", R"(@Descriptor(value="IBar") interface IFoo{})",
580 typenames_, GetLanguage(), &error, {"--structured"});
581 ASSERT_EQ(AidlError::OK, error);
582 ASSERT_NE(nullptr, parse_result);
583 const AidlInterface* interface = parse_result->AsInterface();
584 ASSERT_NE(nullptr, interface);
585 ASSERT_EQ("IBar", interface->GetDescriptor());
586}
587
Jiyong Park40782d02020-07-24 19:17:43 +0900588TEST_P(AidlTest, AcceptsOnewayMethod) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700589 const string oneway_method = "package a; interface IFoo { oneway void f(int a); }";
Devin Moore7b8d5c92020-03-17 14:14:08 -0700590 EXPECT_NE(nullptr, Parse("a/IFoo.aidl", oneway_method, typenames_, GetLanguage()));
Jiyong Park40782d02020-07-24 19:17:43 +0900591}
592
593TEST_P(AidlTest, AcceptsOnewayInterface) {
594 const string oneway_interface = "package a; oneway interface IBar { void f(int a); }";
Devin Moore7b8d5c92020-03-17 14:14:08 -0700595 EXPECT_NE(nullptr, Parse("a/IBar.aidl", oneway_interface, typenames_, GetLanguage()));
Christopher Wiley90be4e32015-10-20 14:55:25 -0700596}
Christopher Wileyef140932015-11-03 09:29:19 -0800597
Devin Moore7b8d5c92020-03-17 14:14:08 -0700598TEST_P(AidlTest, AcceptsAnnotatedOnewayMethod) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700599 const string oneway_method =
600 "package a; interface IFoo { @UnsupportedAppUsage oneway void f(int a); }";
Devin Moore7b8d5c92020-03-17 14:14:08 -0700601 EXPECT_NE(nullptr, Parse("a/IFoo.aidl", oneway_method, typenames_, GetLanguage()));
Artur Satayev91fe8712019-07-29 13:06:01 +0100602}
603
Steven Moreland65297cc2020-04-20 20:17:36 -0700604TEST_P(AidlTest, AnnotationsInMultiplePlaces) {
605 const string oneway_method =
606 "package a; interface IFoo { @UnsupportedAppUsage oneway @Hide void f(int a); }";
607 const AidlDefinedType* defined = Parse("a/IFoo.aidl", oneway_method, typenames_, GetLanguage());
608 ASSERT_NE(nullptr, defined);
609 const AidlInterface* iface = defined->AsInterface();
610 ASSERT_NE(nullptr, iface);
611
612 const auto& methods = iface->GetMethods();
613 ASSERT_EQ(1u, methods.size());
614 const auto& method = methods[0];
615 const AidlTypeSpecifier& ret_type = method->GetType();
616
617 // TODO(b/151102494): these annotations should be on the method
618 ASSERT_NE(nullptr, ret_type.UnsupportedAppUsage());
619 ASSERT_TRUE(ret_type.IsHide());
620}
621
Devin Moore7b8d5c92020-03-17 14:14:08 -0700622TEST_P(AidlTest, WritesComments) {
Artur Satayev91fe8712019-07-29 13:06:01 +0100623 string foo_interface =
Jooyung Han8451a202021-01-16 03:07:06 +0900624 R"(package a;
625 /* foo */
626 interface IFoo {
627 /* i */
628 int i();
629 // j
630 @nullable String j();
631 // k1
632 /* k2 */
633 @UnsupportedAppUsage oneway void k(int a);
634 })";
Artur Satayev91fe8712019-07-29 13:06:01 +0100635
Jooyung Han8451a202021-01-16 03:07:06 +0900636 CaptureStderr();
Devin Moore7b8d5c92020-03-17 14:14:08 -0700637 auto parse_result = Parse("a/IFoo.aidl", foo_interface, typenames_, GetLanguage());
Artur Satayev91fe8712019-07-29 13:06:01 +0100638 EXPECT_NE(nullptr, parse_result);
Jooyung Han8451a202021-01-16 03:07:06 +0900639 EXPECT_EQ("", GetCapturedStderr());
640
Jooyung Han161bb0f2021-01-21 12:30:16 +0900641 EXPECT_EQ((Comments{{"/* foo */"}}), parse_result->GetComments());
Artur Satayev91fe8712019-07-29 13:06:01 +0100642
643 const AidlInterface* interface = parse_result->AsInterface();
Jooyung Han161bb0f2021-01-21 12:30:16 +0900644 EXPECT_EQ((Comments{{"/* i */"}}), interface->GetMethods()[0]->GetComments());
645 EXPECT_EQ((Comments{{"// j\n"}}), interface->GetMethods()[1]->GetComments());
646 EXPECT_EQ((Comments{{"// k1\n"}, {"/* k2 */"}}), interface->GetMethods()[2]->GetComments());
Artur Satayev91fe8712019-07-29 13:06:01 +0100647}
648
Jooyung Han1a551d32020-10-05 15:37:26 +0900649TEST_P(AidlTest, CppHeaderCanBeIdentifierAsWell) {
650 io_delegate_.SetFileContents("p/cpp_header.aidl",
651 R"(package p;
652 parcelable cpp_header cpp_header "bar/header";)");
653 import_paths_.emplace("");
654 const string input_path = "p/IFoo.aidl";
655 const string input = R"(package p;
656 import p.cpp_header;
657 interface IFoo {
658 // get bar
659 cpp_header get();
660 })";
661
662 auto parse_result = Parse(input_path, input, typenames_, GetLanguage());
663 EXPECT_NE(nullptr, parse_result);
664 const AidlInterface* interface = parse_result->AsInterface();
Jooyung Han161bb0f2021-01-21 12:30:16 +0900665 EXPECT_EQ((Comments{{"// get bar\n"}}), interface->GetMethods()[0]->GetComments());
Jooyung Han1a551d32020-10-05 15:37:26 +0900666}
667
Christopher Wileyef140932015-11-03 09:29:19 -0800668TEST_F(AidlTest, ParsesPreprocessedFile) {
669 string simple_content = "parcelable a.Foo;\ninterface b.IBar;";
670 io_delegate_.SetFileContents("path", simple_content);
Steven Morelandcb1bcd72020-04-29 16:30:35 -0700671 EXPECT_FALSE(typenames_.ResolveTypename("a.Foo").is_resolved);
Jeongik Cha047c5ee2019-08-07 23:16:49 +0900672 EXPECT_TRUE(parse_preprocessed_file(io_delegate_, "path", &typenames_));
Steven Morelandcb1bcd72020-04-29 16:30:35 -0700673 EXPECT_TRUE(typenames_.ResolveTypename("a.Foo").is_resolved);
674 EXPECT_TRUE(typenames_.ResolveTypename("b.IBar").is_resolved);
Christopher Wileyef140932015-11-03 09:29:19 -0800675}
676
677TEST_F(AidlTest, ParsesPreprocessedFileWithWhitespace) {
678 string simple_content = "parcelable a.Foo;\n interface b.IBar ;\t";
679 io_delegate_.SetFileContents("path", simple_content);
Jeongik Cha047c5ee2019-08-07 23:16:49 +0900680
Steven Morelandcb1bcd72020-04-29 16:30:35 -0700681 EXPECT_FALSE(typenames_.ResolveTypename("a.Foo").is_resolved);
Jeongik Cha047c5ee2019-08-07 23:16:49 +0900682 EXPECT_TRUE(parse_preprocessed_file(io_delegate_, "path", &typenames_));
Steven Morelandcb1bcd72020-04-29 16:30:35 -0700683 EXPECT_TRUE(typenames_.ResolveTypename("a.Foo").is_resolved);
684 EXPECT_TRUE(typenames_.ResolveTypename("b.IBar").is_resolved);
Christopher Wileyef140932015-11-03 09:29:19 -0800685}
686
Devin Moore7b8d5c92020-03-17 14:14:08 -0700687TEST_P(AidlTest, PreferImportToPreprocessed) {
Christopher Wiley41544372015-11-03 14:52:29 -0800688 io_delegate_.SetFileContents("preprocessed", "interface another.IBar;");
689 io_delegate_.SetFileContents("one/IBar.aidl", "package one; "
690 "interface IBar {}");
691 preprocessed_files_.push_back("preprocessed");
Jiyong Park8c380532018-08-30 14:55:26 +0900692 import_paths_.emplace("");
Jeongik Cha047c5ee2019-08-07 23:16:49 +0900693 auto parse_result = Parse("p/IFoo.aidl", "package p; import one.IBar; interface IFoo {}",
Devin Moore7b8d5c92020-03-17 14:14:08 -0700694 typenames_, GetLanguage());
Christopher Wiley41544372015-11-03 14:52:29 -0800695 EXPECT_NE(nullptr, parse_result);
Jeongik Cha047c5ee2019-08-07 23:16:49 +0900696
Christopher Wiley41544372015-11-03 14:52:29 -0800697 // We expect to know about both kinds of IBar
Steven Morelandcb1bcd72020-04-29 16:30:35 -0700698 EXPECT_TRUE(typenames_.ResolveTypename("one.IBar").is_resolved);
699 EXPECT_TRUE(typenames_.ResolveTypename("another.IBar").is_resolved);
Christopher Wiley41544372015-11-03 14:52:29 -0800700 // But if we request just "IBar" we should get our imported one.
Jooyung Han8451a202021-01-16 03:07:06 +0900701 AidlTypeSpecifier ambiguous_type(AIDL_LOCATION_HERE, "IBar", false, nullptr, {});
Jeongik Cha047c5ee2019-08-07 23:16:49 +0900702 ambiguous_type.Resolve(typenames_);
703 EXPECT_EQ("one.IBar", ambiguous_type.GetName());
Christopher Wiley41544372015-11-03 14:52:29 -0800704}
705
Jiyong Park8f6ec462020-01-19 20:52:47 +0900706// Special case of PreferImportToPreprocessed. Imported type should be preferred
707// even when the preprocessed file already has the same type.
Devin Moore7b8d5c92020-03-17 14:14:08 -0700708TEST_P(AidlTest, B147918827) {
Jiyong Park8f6ec462020-01-19 20:52:47 +0900709 io_delegate_.SetFileContents("preprocessed", "interface another.IBar;\ninterface one.IBar;");
710 io_delegate_.SetFileContents("one/IBar.aidl",
711 "package one; "
712 "interface IBar {}");
713 preprocessed_files_.push_back("preprocessed");
714 import_paths_.emplace("");
715 auto parse_result = Parse("p/IFoo.aidl", "package p; import one.IBar; interface IFoo {}",
Devin Moore7b8d5c92020-03-17 14:14:08 -0700716 typenames_, GetLanguage());
Jiyong Park8f6ec462020-01-19 20:52:47 +0900717 EXPECT_NE(nullptr, parse_result);
718
719 // We expect to know about both kinds of IBar
Steven Morelandcb1bcd72020-04-29 16:30:35 -0700720 EXPECT_TRUE(typenames_.ResolveTypename("one.IBar").is_resolved);
721 EXPECT_TRUE(typenames_.ResolveTypename("another.IBar").is_resolved);
Jiyong Park8f6ec462020-01-19 20:52:47 +0900722 // But if we request just "IBar" we should get our imported one.
Jooyung Han8451a202021-01-16 03:07:06 +0900723 AidlTypeSpecifier ambiguous_type(AIDL_LOCATION_HERE, "IBar", false, nullptr, {});
Jiyong Park8f6ec462020-01-19 20:52:47 +0900724 ambiguous_type.Resolve(typenames_);
725 EXPECT_EQ("one.IBar", ambiguous_type.GetName());
726}
727
Casey Dahlinc1f39b42015-11-24 10:34:34 -0800728TEST_F(AidlTest, WritePreprocessedFile) {
729 io_delegate_.SetFileContents("p/Outer.aidl",
730 "package p; parcelable Outer.Inner;");
731 io_delegate_.SetFileContents("one/IBar.aidl", "package one; import p.Outer;"
732 "interface IBar {}");
733
Jiyong Park6f77e0c2018-07-28 16:55:44 +0900734 vector<string> args {
735 "aidl",
736 "--preprocess",
737 "preprocessed",
738 "p/Outer.aidl",
739 "one/IBar.aidl"};
740 Options options = Options::From(args);
Casey Dahlinc1f39b42015-11-24 10:34:34 -0800741 EXPECT_TRUE(::android::aidl::preprocess_aidl(options, io_delegate_));
742
743 string output;
744 EXPECT_TRUE(io_delegate_.GetWrittenContents("preprocessed", &output));
745 EXPECT_EQ("parcelable p.Outer.Inner;\ninterface one.IBar;\n", output);
746}
747
Jooyung Han720253d2021-01-05 19:13:17 +0900748TEST_P(AidlTest, SupportDeprecated) {
749 struct TestCase {
750 std::string output_file;
751 std::string annotation;
752 };
753
754 auto CheckDeprecated = [&](const std::string& filename, const std::string& contents,
Jooyung Hand4fe00e2021-01-11 16:21:53 +0900755 std::vector<std::pair<Options::Language, TestCase>> expectations) {
Jooyung Han720253d2021-01-05 19:13:17 +0900756 io_delegate_.SetFileContents(filename, contents);
757
758 auto options = Options::From("aidl --lang=" + to_string(GetLanguage()) + " " + filename +
759 " --out=out --header_out=out");
760 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jooyung Hand4fe00e2021-01-11 16:21:53 +0900761 for (const auto& [lang, test_case] : expectations) {
762 if (lang != GetLanguage()) continue;
Jooyung Han720253d2021-01-05 19:13:17 +0900763 string output;
Jooyung Han652ce482021-02-26 12:40:35 +0900764 EXPECT_TRUE(io_delegate_.GetWrittenContents(test_case.output_file, &output));
Jooyung Han720253d2021-01-05 19:13:17 +0900765 EXPECT_THAT(output, HasSubstr(test_case.annotation));
766 }
767 };
768
Jooyung Hand4fe00e2021-01-11 16:21:53 +0900769 // Emit escaped string for notes
770 CheckDeprecated(
771 "IFoo.aidl",
772 R"(interface IFoo {
773 /**
774 * @note asdf
775 * @deprecated a really long deprecation message
776 *
777 * which is really long
778 * @param foo bar
779 */
780 List<String> foo();
781 })",
782 {
783 {Options::Language::JAVA, {"out/IFoo.java", "@Deprecated"}},
784 {Options::Language::CPP,
785 {"out/IFoo.h",
786 R"(__attribute__((deprecated("a really long deprecation message which is really long"))))"}},
787 {Options::Language::NDK,
788 {"out/aidl/IFoo.h",
789 R"(__attribute__((deprecated("a really long deprecation message which is really long"))))"}},
790 {Options::Language::RUST,
791 {"out/IFoo.rs",
792 R"(#[deprecated = "a really long deprecation message which is really long"])"}},
793 });
794
Jooyung Han24effbf2021-01-16 10:24:03 +0900795 // In AIDL @deprecated can be in block comments as well as javadoc style
Jooyung Hand4fe00e2021-01-11 16:21:53 +0900796 CheckDeprecated(
797 "IFoo.aidl",
798 "interface IFoo {\n"
Jooyung Han24effbf2021-01-16 10:24:03 +0900799 " /* @deprecated use bar() */\n"
Jooyung Hand4fe00e2021-01-11 16:21:53 +0900800 " List<String> foo();\n"
801 "}",
802 {
803 {Options::Language::JAVA, {"out/IFoo.java", "@Deprecated"}},
Jooyung Hanb7a60ec2021-01-21 13:47:59 +0900804 {Options::Language::JAVA, {"out/IFoo.java", "/** @deprecated use bar() */"}},
Jooyung Hand4fe00e2021-01-11 16:21:53 +0900805 {Options::Language::CPP, {"out/IFoo.h", "__attribute__((deprecated(\"use bar()\")))"}},
806 {Options::Language::NDK,
807 {"out/aidl/IFoo.h", "__attribute__((deprecated(\"use bar()\")))"}},
808 {Options::Language::RUST, {"out/IFoo.rs", "#[deprecated = \"use bar()\"]"}},
809 });
Jooyung Han720253d2021-01-05 19:13:17 +0900810
Jooyung Han24effbf2021-01-16 10:24:03 +0900811 // but not in line comments
812 auto parsed = Parse("IFoo.aidl", "// @deprecated\ninterface IFoo {}", typenames_, GetLanguage());
813 EXPECT_FALSE(parsed->IsDeprecated());
814
815 // parcelable
Jooyung Han720253d2021-01-05 19:13:17 +0900816 CheckDeprecated("Foo.aidl",
817 "parcelable Foo {\n"
818 " /** @deprecated use bar*/\n"
819 " int foo = 0;\n"
820 "}",
821 {
822 {Options::Language::JAVA, {"out/Foo.java", "@Deprecated"}},
823 {Options::Language::CPP, {"out/Foo.h", "__attribute__((deprecated"}},
824 {Options::Language::NDK, {"out/aidl/Foo.h", "__attribute__((deprecated"}},
825 {Options::Language::RUST, {"out/Foo.rs", "#[deprecated"}},
826 });
827
Jooyung Han24effbf2021-01-16 10:24:03 +0900828 // interface constants
Jooyung Han720253d2021-01-05 19:13:17 +0900829 CheckDeprecated("IFoo.aidl",
830 "interface IFoo {\n"
831 " /** @deprecated use bar*/\n"
832 " const int FOO = 0;\n"
833 "}",
834 {
835 {Options::Language::JAVA, {"out/IFoo.java", "@Deprecated"}},
836 {Options::Language::CPP, {"out/IFoo.h", "__attribute__((deprecated"}},
837 {Options::Language::NDK, {"out/aidl/IFoo.h", "__attribute__((deprecated"}},
838 {Options::Language::RUST, {"out/IFoo.rs", "#[deprecated"}},
839 });
840
841 // union fields
842 CheckDeprecated("Foo.aidl",
843 "union Foo {\n"
844 " int bar = 0;\n"
845 " /** @deprecated use bar*/\n"
846 " int foo;\n"
847 "}",
848 {
849 {Options::Language::JAVA, {"out/Foo.java", "@Deprecated"}},
850 {Options::Language::CPP, {"out/Foo.h", "__attribute__((deprecated"}},
851 {Options::Language::NDK, {"out/aidl/Foo.h", "__attribute__((deprecated"}},
852 {Options::Language::RUST, {"out/Foo.rs", "#[deprecated"}},
853 });
854
855 CheckDeprecated("Foo.aidl",
856 "/** @deprecated use Bar */\n"
857 "parcelable Foo {}",
858 {
859 {Options::Language::JAVA, {"out/Foo.java", "@Deprecated"}},
860 {Options::Language::CPP, {"out/Foo.h", "__attribute__((deprecated"}},
861 {Options::Language::NDK, {"out/aidl/Foo.h", "__attribute__((deprecated"}},
862 {Options::Language::RUST, {"out/Foo.rs", "#[deprecated"}},
863 });
864
865 CheckDeprecated("Foo.aidl",
866 "/** @deprecated use Bar */\n"
867 "union Foo { int foo = 0; }",
868 {
869 {Options::Language::JAVA, {"out/Foo.java", "@Deprecated"}},
870 {Options::Language::CPP, {"out/Foo.h", "__attribute__((deprecated"}},
871 {Options::Language::NDK, {"out/aidl/Foo.h", "__attribute__((deprecated"}},
872 {Options::Language::RUST, {"out/Foo.rs", "#[deprecated"}},
873 });
874
875 CheckDeprecated("IFoo.aidl",
876 "/** @deprecated use IBar */\n"
877 "interface IFoo {}",
878 {
879 {Options::Language::JAVA, {"out/IFoo.java", "@Deprecated"}},
880 {Options::Language::CPP, {"out/IFoo.h", "__attribute__((deprecated"}},
881 {Options::Language::NDK, {"out/aidl/IFoo.h", "__attribute__((deprecated"}},
882 {Options::Language::RUST, {"out/IFoo.rs", "#[deprecated"}},
883 });
884
885 CheckDeprecated("Foo.aidl",
886 "/** @deprecated use IBar */\n"
887 "enum Foo { FOO }",
888 {
889 {Options::Language::JAVA, {"out/Foo.java", "@Deprecated"}},
890 {Options::Language::CPP, {"out/Foo.h", "__attribute__((deprecated"}},
891 {Options::Language::NDK, {"out/aidl/Foo.h", "__attribute__((deprecated"}},
Jooyung Hanb7a60ec2021-01-21 13:47:59 +0900892 // TODO(b/177860423) support "deprecated" in Rust enum
Jooyung Han720253d2021-01-05 19:13:17 +0900893 // {Options::Language::RUST, {"out/Foo.rs", "#[deprecated"}},
894 });
895}
896
Devin Moore7b8d5c92020-03-17 14:14:08 -0700897TEST_P(AidlTest, RequireOuterClass) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700898 const string expected_stderr = "ERROR: p/IFoo.aidl:1.54-60: Failed to resolve 'Inner'\n";
Christopher Wiley63bce2a2015-11-03 14:55:03 -0800899 io_delegate_.SetFileContents("p/Outer.aidl",
900 "package p; parcelable Outer.Inner;");
Jiyong Park8c380532018-08-30 14:55:26 +0900901 import_paths_.emplace("");
Devin Moore097a3ab2020-03-11 16:08:44 -0700902 CaptureStderr();
903 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl",
904 "package p; import p.Outer; interface IFoo { void f(in Inner c); }",
Devin Moore7b8d5c92020-03-17 14:14:08 -0700905 typenames_, GetLanguage()));
Devin Moore097a3ab2020-03-11 16:08:44 -0700906 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Christopher Wiley63bce2a2015-11-03 14:55:03 -0800907}
908
Devin Moore7b8d5c92020-03-17 14:14:08 -0700909TEST_P(AidlTest, ParseCompoundParcelableFromPreprocess) {
Christopher Wiley63bce2a2015-11-03 14:55:03 -0800910 io_delegate_.SetFileContents("preprocessed",
911 "parcelable p.Outer.Inner;");
912 preprocessed_files_.push_back("preprocessed");
Jeongik Cha047c5ee2019-08-07 23:16:49 +0900913 auto parse_result = Parse("p/IFoo.aidl", "package p; interface IFoo { void f(in Inner c); }",
Devin Moore7b8d5c92020-03-17 14:14:08 -0700914 typenames_, GetLanguage());
Christopher Wiley63bce2a2015-11-03 14:55:03 -0800915 // TODO(wiley): This should actually return nullptr because we require
916 // the outer class name. However, for legacy reasons,
917 // this behavior must be maintained. b/17415692
918 EXPECT_NE(nullptr, parse_result);
919}
920
Christopher Wiley632801d2015-11-05 14:15:49 -0800921TEST_F(AidlTest, FailOnParcelable) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700922 const string expected_foo_stderr =
923 "ERROR: p/IFoo.aidl:1.22-27: Refusing to generate code with unstructured parcelables. "
924 "Declared parcelables should be in their own file and/or cannot be used with --structured "
925 "interfaces.\n";
Steven Morelande2c64b42018-09-18 15:06:37 -0700926 io_delegate_.SetFileContents("p/IFoo.aidl", "package p; parcelable IFoo;");
927
Christopher Wiley632801d2015-11-05 14:15:49 -0800928 // By default, we shouldn't fail on parcelable.
Steven Morelande2c64b42018-09-18 15:06:37 -0700929 Options options1 = Options::From("aidl p/IFoo.aidl");
Devin Moore097a3ab2020-03-11 16:08:44 -0700930 CaptureStderr();
Jiyong Parkb034bf02018-07-30 17:44:33 +0900931 EXPECT_EQ(0, ::android::aidl::compile_aidl(options1, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -0700932 EXPECT_EQ("", GetCapturedStderr());
Jiyong Park6f77e0c2018-07-28 16:55:44 +0900933
Steven Morelande2c64b42018-09-18 15:06:37 -0700934 // -b considers this an error
Jiyong Park6f77e0c2018-07-28 16:55:44 +0900935 Options options2 = Options::From("aidl -b p/IFoo.aidl");
Devin Moore097a3ab2020-03-11 16:08:44 -0700936 CaptureStderr();
Jiyong Parkb034bf02018-07-30 17:44:33 +0900937 EXPECT_NE(0, ::android::aidl::compile_aidl(options2, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -0700938 EXPECT_EQ(expected_foo_stderr, GetCapturedStderr());
Steven Morelande2c64b42018-09-18 15:06:37 -0700939
Devin Moore097a3ab2020-03-11 16:08:44 -0700940 const string expected_bar_stderr =
941 "ERROR: p/IBar.aidl:1.22-26: Refusing to generate code with unstructured parcelables. "
942 "Declared parcelables should be in their own file and/or cannot be used with --structured "
943 "interfaces.\n";
Steven Morelande2c64b42018-09-18 15:06:37 -0700944 io_delegate_.SetFileContents("p/IBar.aidl", "package p; parcelable Foo; interface IBar{}");
945
Jiyong Parkda8c6932019-08-12 19:56:08 +0900946 // With '-b' option, a parcelable and an interface should fail.
Steven Morelande2c64b42018-09-18 15:06:37 -0700947 Options options3 = Options::From("aidl p/IBar.aidl");
Devin Moore097a3ab2020-03-11 16:08:44 -0700948 CaptureStderr();
Jiyong Parkda8c6932019-08-12 19:56:08 +0900949 EXPECT_EQ(0, ::android::aidl::compile_aidl(options3, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -0700950 EXPECT_EQ("", GetCapturedStderr());
Steven Morelande2c64b42018-09-18 15:06:37 -0700951 Options options4 = Options::From("aidl -b p/IBar.aidl");
Devin Moore097a3ab2020-03-11 16:08:44 -0700952 CaptureStderr();
Steven Morelande2c64b42018-09-18 15:06:37 -0700953 EXPECT_NE(0, ::android::aidl::compile_aidl(options4, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -0700954 EXPECT_EQ(expected_bar_stderr, GetCapturedStderr());
Christopher Wiley632801d2015-11-05 14:15:49 -0800955}
956
Devin Moore7b8d5c92020-03-17 14:14:08 -0700957TEST_P(AidlTest, StructuredFailOnUnstructuredParcelable) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700958 const string expected_stderr =
959 "ERROR: ./o/WhoKnowsWhat.aidl:1.22-35: o.WhoKnowsWhat is not structured, but this is a "
960 "structured interface.\n";
Steven Moreland1eac5fa2018-08-27 19:35:05 -0700961 io_delegate_.SetFileContents("o/WhoKnowsWhat.aidl", "package o; parcelable WhoKnowsWhat;");
962 import_paths_.emplace("");
Devin Moore097a3ab2020-03-11 16:08:44 -0700963 AidlError error;
964 CaptureStderr();
965 EXPECT_EQ(
966 nullptr,
Steven Moreland1eac5fa2018-08-27 19:35:05 -0700967 Parse("p/IFoo.aidl",
968 "package p; import o.WhoKnowsWhat; interface IFoo { void f(in WhoKnowsWhat thisIs); }",
Devin Moore7b8d5c92020-03-17 14:14:08 -0700969 typenames_, GetLanguage(), &error, {"--structured"}));
Devin Moore097a3ab2020-03-11 16:08:44 -0700970 EXPECT_EQ(expected_stderr, GetCapturedStderr());
971 EXPECT_EQ(AidlError::NOT_STRUCTURED, error);
Steven Moreland1eac5fa2018-08-27 19:35:05 -0700972}
973
Devin Moore7b8d5c92020-03-17 14:14:08 -0700974TEST_P(AidlTest, FailOnDuplicateConstantNames) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700975 AidlError error;
976 const string expected_stderr =
977 "ERROR: p/IFoo.aidl:4.34-45: Found duplicate constant name 'DUPLICATED'\n";
978 CaptureStderr();
Jeongik Cha047c5ee2019-08-07 23:16:49 +0900979 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl",
980 R"(package p;
Christopher Wiley69b44cf2016-05-03 13:43:33 -0700981 interface IFoo {
982 const String DUPLICATED = "d";
983 const int DUPLICATED = 1;
984 }
985 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -0700986 typenames_, GetLanguage(), &error));
Devin Moore097a3ab2020-03-11 16:08:44 -0700987 EXPECT_EQ(expected_stderr, GetCapturedStderr());
988 EXPECT_EQ(AidlError::BAD_TYPE, error);
Christopher Wiley69b44cf2016-05-03 13:43:33 -0700989}
990
Steven Morelande689da22020-11-10 02:06:30 +0000991TEST_P(AidlTest, FailOnTooBigConstant) {
992 AidlError error;
993 const string expected_stderr =
994 "ERROR: p/IFoo.aidl:3.48-52: Invalid type specifier for an int32 literal: byte\n";
995 CaptureStderr();
996 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl",
997 R"(package p;
998 interface IFoo {
999 const byte type2small = 256;
1000 }
1001 )",
1002 typenames_, GetLanguage(), &error));
1003 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1004 EXPECT_EQ(AidlError::BAD_TYPE, error);
1005}
1006
Jooyung Han30f64ad2020-12-15 08:16:31 +09001007TEST_F(AidlTest, BoolConstantsEvaluatesToIntegers) {
1008 io_delegate_.SetFileContents("a/Foo.aidl", "package a; parcelable Foo { const int y = true; }");
1009 CaptureStderr();
1010 auto options = Options::From("aidl --lang java -o out a/Foo.aidl");
1011 EXPECT_EQ(0, aidl::compile_aidl(options, io_delegate_));
1012 EXPECT_EQ("", GetCapturedStderr());
1013 string code;
1014 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/Foo.java", &code));
1015 EXPECT_THAT(code, testing::HasSubstr("public static final int y = 1;"));
1016}
1017
Jooyung Han535c5e82020-12-29 15:16:59 +09001018TEST_F(AidlTest, AidlConstantValue_EvaluatedValue) {
Jooyung Han71a1b582020-12-25 23:58:41 +09001019 using Ptr = unique_ptr<AidlConstantValue>;
1020 const AidlLocation& loc = AIDL_LOCATION_HERE;
1021
Jooyung Han535c5e82020-12-29 15:16:59 +09001022 EXPECT_EQ('c', Ptr(AidlConstantValue::Character(loc, 'c'))->EvaluatedValue<char>());
1023 EXPECT_EQ("abc", Ptr(AidlConstantValue::String(loc, "\"abc\""))->EvaluatedValue<string>());
1024 EXPECT_FLOAT_EQ(1.0f, Ptr(AidlConstantValue::Floating(loc, "1.0f"))->EvaluatedValue<float>());
1025 EXPECT_EQ(true, Ptr(AidlConstantValue::Boolean(loc, true))->EvaluatedValue<bool>());
Jooyung Han71a1b582020-12-25 23:58:41 +09001026
1027 AidlBinaryConstExpression one_plus_one(loc, Ptr(AidlConstantValue::Integral(loc, "1")), "+",
1028 Ptr(AidlConstantValue::Integral(loc, "1")));
Jooyung Han535c5e82020-12-29 15:16:59 +09001029 EXPECT_EQ(2, one_plus_one.EvaluatedValue<int32_t>());
Jooyung Han71a1b582020-12-25 23:58:41 +09001030
1031 auto values = unique_ptr<vector<Ptr>>{new vector<Ptr>};
1032 values->emplace_back(AidlConstantValue::String(loc, "\"hello\""));
1033 values->emplace_back(AidlConstantValue::String(loc, "\"world\""));
1034 vector<string> expected{"hello", "world"};
Jooyung Han535c5e82020-12-29 15:16:59 +09001035 EXPECT_EQ(
1036 expected,
1037 Ptr(AidlConstantValue::Array(loc, std::move(values)))->EvaluatedValue<vector<string>>());
Jooyung Han71a1b582020-12-25 23:58:41 +09001038}
1039
Devin Moore7b8d5c92020-03-17 14:14:08 -07001040TEST_P(AidlTest, FailOnManyDefinedTypes) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001041 AidlError error;
Devin Moore5de18ed2020-04-02 13:52:29 -07001042 const string expected_stderr =
1043 "ERROR: p/IFoo.aidl:3.33-38: You must declare only one type per file.\n";
Devin Moorec054bf82020-03-10 16:31:48 -07001044 CaptureStderr();
Steven Morelandc258abc2018-07-10 14:03:38 -07001045 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl",
1046 R"(package p;
1047 interface IFoo {}
Steven Morelandc258abc2018-07-10 14:03:38 -07001048 parcelable IBar {}
1049 parcelable StructuredParcelable {}
1050 interface IBaz {}
Jeongik Cha2a5b4d82019-08-06 19:37:59 +09001051 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -07001052 typenames_, GetLanguage(), &error));
Devin Moorec054bf82020-03-10 16:31:48 -07001053 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Steven Morelandc258abc2018-07-10 14:03:38 -07001054 // Parse success is important for clear error handling even if the cases aren't
1055 // actually supported in code generation.
Devin Moore097a3ab2020-03-11 16:08:44 -07001056 EXPECT_EQ(AidlError::BAD_TYPE, error);
Steven Morelandc258abc2018-07-10 14:03:38 -07001057}
1058
Devin Moore7b8d5c92020-03-17 14:14:08 -07001059TEST_P(AidlTest, FailOnNoDefinedTypes) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001060 AidlError error;
1061 const string expected_stderr = "ERROR: p/IFoo.aidl:1.11-11: syntax error, unexpected $end\n";
1062 CaptureStderr();
Devin Moore7b8d5c92020-03-17 14:14:08 -07001063 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl", R"(package p;)", typenames_, GetLanguage(), &error));
Devin Moore097a3ab2020-03-11 16:08:44 -07001064 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1065 EXPECT_EQ(AidlError::PARSE_ERROR, error);
Steven Morelandc258abc2018-07-10 14:03:38 -07001066}
1067
Steven Morelandf9e922f2020-07-08 21:15:27 +00001068TEST_P(AidlTest, FailOnEmptyListWithComma) {
1069 AidlError error;
1070 const string expected_stderr =
1071 "ERROR: p/Foo.aidl:1.45-47: syntax error, unexpected ',', expecting '}'\n";
1072 CaptureStderr();
1073 EXPECT_EQ(nullptr, Parse("p/Foo.aidl", R"(package p; parcelable Foo { uint64_t[] a = { , }; })",
1074 typenames_, GetLanguage(), &error));
1075 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1076 EXPECT_EQ(AidlError::PARSE_ERROR, error);
1077}
1078
Devin Moore7b8d5c92020-03-17 14:14:08 -07001079TEST_P(AidlTest, FailOnMalformedConstHexValue) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001080 AidlError error;
1081 const string expected_stderr =
Devin Moore2a088902020-09-17 10:51:19 -07001082 "ERROR: p/IFoo.aidl:3.50-71: Could not parse hexvalue: 0xffffffffffffffffff\n";
Devin Moore097a3ab2020-03-11 16:08:44 -07001083 CaptureStderr();
Jeongik Cha047c5ee2019-08-07 23:16:49 +09001084 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl",
1085 R"(package p;
Roshan Pius3b2203d2016-07-22 16:13:20 -07001086 interface IFoo {
1087 const int BAD_HEX_VALUE = 0xffffffffffffffffff;
1088 }
1089 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -07001090 typenames_, GetLanguage(), &error));
Devin Moore097a3ab2020-03-11 16:08:44 -07001091 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1092 EXPECT_EQ(AidlError::PARSE_ERROR, error);
Roshan Pius3b2203d2016-07-22 16:13:20 -07001093}
1094
Jiyong Park18132182020-06-08 20:24:40 +09001095TEST_P(AidlTest, FailOnMalformedQualifiedNameAsIdentifier) {
1096 AidlError error;
1097 const string expected_stderr =
1098 "ERROR: p/IFoo.aidl:1.25-26: syntax error, unexpected ';', expecting identifier or "
1099 "cpp_header (which can also be used as an identifier)\n";
1100 CaptureStderr();
1101 // Notice the trailing dot(.) in the name, which isn't a correct name
1102 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl", R"(package p; parcelable A.; )", typenames_,
1103 GetLanguage(), &error));
1104 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1105 EXPECT_EQ(AidlError::PARSE_ERROR, error);
1106}
1107
1108TEST_P(AidlTest, FailOnMalformedQualifiedNameAsPackage) {
1109 AidlError error;
1110 const string expected_stderr =
1111 "ERROR: p/IFoo.aidl:1.11-12: syntax error, unexpected ';', expecting identifier or "
1112 "cpp_header (which can also be used as an identifier)\n";
1113 CaptureStderr();
1114 // Notice the trailing dot(.) in the package name
1115 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl", R"(package p.; parcelable A; )", typenames_,
1116 GetLanguage(), &error));
1117 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1118 EXPECT_EQ(AidlError::PARSE_ERROR, error);
1119}
1120
Devin Moore7b8d5c92020-03-17 14:14:08 -07001121TEST_P(AidlTest, ParsePositiveConstHexValue) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001122 AidlError error;
Devin Moore7b8d5c92020-03-17 14:14:08 -07001123 auto parse_result = Parse("p/IFoo.aidl",
1124 R"(package p;
Roshan Pius3b2203d2016-07-22 16:13:20 -07001125 interface IFoo {
1126 const int POSITIVE_HEX_VALUE = 0xf5;
1127 }
1128 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -07001129 typenames_, GetLanguage(), &error);
1130 EXPECT_NE(nullptr, parse_result);
1131 const AidlInterface* interface = parse_result->AsInterface();
Steven Moreland5557f1c2018-07-02 13:50:23 -07001132 ASSERT_NE(nullptr, interface);
Steven Moreland693640b2018-07-19 13:46:27 -07001133 const auto& cpp_constants = interface->GetConstantDeclarations();
1134 EXPECT_EQ((size_t)1, cpp_constants.size());
1135 EXPECT_EQ("POSITIVE_HEX_VALUE", cpp_constants[0]->GetName());
Will McVickerd7d18df2019-09-12 13:40:50 -07001136 EXPECT_TRUE(cpp_constants[0]->CheckValid(typenames_));
Steven Moreland860b1942018-08-16 14:59:28 -07001137 EXPECT_EQ("245", cpp_constants[0]->ValueString(cpp::ConstantValueDecorator));
Roshan Pius3b2203d2016-07-22 16:13:20 -07001138}
1139
Devin Moore7b8d5c92020-03-17 14:14:08 -07001140TEST_P(AidlTest, ParseNegativeConstHexValue) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001141 AidlError error;
Devin Moore7b8d5c92020-03-17 14:14:08 -07001142 auto parse_result = Parse("p/IFoo.aidl",
1143 R"(package p;
Roshan Pius3b2203d2016-07-22 16:13:20 -07001144 interface IFoo {
1145 const int NEGATIVE_HEX_VALUE = 0xffffffff;
1146 }
1147 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -07001148 typenames_, GetLanguage(), &error);
1149 ASSERT_NE(nullptr, parse_result);
1150 const AidlInterface* interface = parse_result->AsInterface();
Steven Moreland5557f1c2018-07-02 13:50:23 -07001151 ASSERT_NE(nullptr, interface);
Steven Moreland693640b2018-07-19 13:46:27 -07001152 const auto& cpp_constants = interface->GetConstantDeclarations();
1153 EXPECT_EQ((size_t)1, cpp_constants.size());
1154 EXPECT_EQ("NEGATIVE_HEX_VALUE", cpp_constants[0]->GetName());
Will McVickerd7d18df2019-09-12 13:40:50 -07001155 EXPECT_EQ(true, cpp_constants[0]->CheckValid(typenames_));
Steven Moreland860b1942018-08-16 14:59:28 -07001156 EXPECT_EQ("-1", cpp_constants[0]->ValueString(cpp::ConstantValueDecorator));
Roshan Pius3b2203d2016-07-22 16:13:20 -07001157}
1158
Devin Moore7b8d5c92020-03-17 14:14:08 -07001159TEST_P(AidlTest, UnderstandsNestedParcelables) {
Ningyuan Wangd17c58b2016-09-29 14:33:14 -07001160 io_delegate_.SetFileContents(
1161 "p/Outer.aidl",
1162 "package p; parcelable Outer.Inner cpp_header \"baz/header\";");
Jiyong Park8c380532018-08-30 14:55:26 +09001163 import_paths_.emplace("");
Ningyuan Wangd17c58b2016-09-29 14:33:14 -07001164 const string input_path = "p/IFoo.aidl";
1165 const string input = "package p; import p.Outer; interface IFoo"
1166 " { Outer.Inner get(); }";
1167
Devin Moore7b8d5c92020-03-17 14:14:08 -07001168 auto parse_result = Parse(input_path, input, typenames_, GetLanguage());
1169 EXPECT_NE(nullptr, parse_result);
Jeongik Cha047c5ee2019-08-07 23:16:49 +09001170
Steven Morelandcb1bcd72020-04-29 16:30:35 -07001171 EXPECT_TRUE(typenames_.ResolveTypename("p.Outer.Inner").is_resolved);
Ningyuan Wangd17c58b2016-09-29 14:33:14 -07001172 // C++ uses "::" instead of "." to refer to a inner class.
Jooyung Han8451a202021-01-16 03:07:06 +09001173 AidlTypeSpecifier nested_type(AIDL_LOCATION_HERE, "p.Outer.Inner", false, nullptr, {});
Jeongik Cha047c5ee2019-08-07 23:16:49 +09001174 EXPECT_EQ("::p::Outer::Inner", cpp::CppNameOf(nested_type, typenames_));
Ningyuan Wangd17c58b2016-09-29 14:33:14 -07001175}
1176
Devin Moore7b8d5c92020-03-17 14:14:08 -07001177TEST_P(AidlTest, UnderstandsNativeParcelables) {
Christopher Wiley9078d722015-11-17 10:23:49 -08001178 io_delegate_.SetFileContents(
1179 "p/Bar.aidl",
Casey Dahlincd639212015-12-15 12:51:04 -08001180 "package p; parcelable Bar cpp_header \"baz/header\";");
Jiyong Park8c380532018-08-30 14:55:26 +09001181 import_paths_.emplace("");
Christopher Wiley9078d722015-11-17 10:23:49 -08001182 const string input_path = "p/IFoo.aidl";
1183 const string input = "package p; import p.Bar; interface IFoo { }";
Devin Moore7b8d5c92020-03-17 14:14:08 -07001184 auto parse_result = Parse(input_path, input, typenames_, GetLanguage());
1185 EXPECT_NE(nullptr, parse_result);
Steven Morelandcb1bcd72020-04-29 16:30:35 -07001186 EXPECT_TRUE(typenames_.ResolveTypename("p.Bar").is_resolved);
Jooyung Han8451a202021-01-16 03:07:06 +09001187 AidlTypeSpecifier native_type(AIDL_LOCATION_HERE, "p.Bar", false, nullptr, {});
Devin Moore7b8d5c92020-03-17 14:14:08 -07001188 native_type.Resolve(typenames_);
1189
1190 EXPECT_EQ("p.Bar", java::InstantiableJavaSignatureOf(native_type, typenames_));
1191 // C++ understands C++ specific stuff
1192 EXPECT_EQ("::p::Bar", cpp::CppNameOf(native_type, typenames_));
1193 set<string> headers;
Devin Moore2f2077a2020-08-28 11:27:53 -07001194 cpp::AddHeaders(native_type, typenames_, &headers);
Devin Moore7b8d5c92020-03-17 14:14:08 -07001195 EXPECT_EQ(1u, headers.size());
1196 EXPECT_EQ(1u, headers.count("baz/header"));
Christopher Wiley9078d722015-11-17 10:23:49 -08001197}
1198
Christopher Wileyf8136192016-04-12 14:19:35 -07001199TEST_F(AidlTest, WritesCorrectDependencyFile) {
1200 // While the in tree build system always gives us an output file name,
1201 // other android tools take advantage of our ability to infer the intended
1202 // file name. This test makes sure we handle this correctly.
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001203 vector<string> args = {
1204 "aidl",
1205 "-d dep/file/path",
1206 "-o place/for/output",
1207 "p/IFoo.aidl"};
1208 Options options = Options::From(args);
1209 io_delegate_.SetFileContents(options.InputFiles().front(), "package p; interface IFoo {}");
Jiyong Parkb034bf02018-07-30 17:44:33 +09001210 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
Christopher Wileyf8136192016-04-12 14:19:35 -07001211 string actual_dep_file_contents;
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001212 EXPECT_TRUE(io_delegate_.GetWrittenContents(options.DependencyFile(), &actual_dep_file_contents));
Christopher Wileyf8136192016-04-12 14:19:35 -07001213 EXPECT_EQ(actual_dep_file_contents, kExpectedDepFileContents);
1214}
1215
Dan Willemsen93298ee2016-11-10 23:55:55 -08001216TEST_F(AidlTest, WritesCorrectDependencyFileNinja) {
1217 // While the in tree build system always gives us an output file name,
1218 // other android tools take advantage of our ability to infer the intended
1219 // file name. This test makes sure we handle this correctly.
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001220 vector<string> args = {
1221 "aidl",
1222 "-d dep/file/path",
1223 "--ninja",
1224 "-o place/for/output",
1225 "p/IFoo.aidl"};
1226 Options options = Options::From(args);
1227 io_delegate_.SetFileContents(options.InputFiles().front(), "package p; interface IFoo {}");
Jiyong Parkb034bf02018-07-30 17:44:33 +09001228 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
Dan Willemsen93298ee2016-11-10 23:55:55 -08001229 string actual_dep_file_contents;
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001230 EXPECT_TRUE(io_delegate_.GetWrittenContents(options.DependencyFile(), &actual_dep_file_contents));
Dan Willemsen93298ee2016-11-10 23:55:55 -08001231 EXPECT_EQ(actual_dep_file_contents, kExpectedNinjaDepFileContents);
1232}
1233
Jiyong Parkdf202122019-09-30 20:48:35 +09001234TEST_F(AidlTest, WritesTrivialDependencyFileForParcelableDeclaration) {
Christopher Wileyb1bbdf82016-04-21 11:43:45 -07001235 // The SDK uses aidl to decide whether a .aidl file is a parcelable. It does
1236 // this by calling aidl with every .aidl file it finds, then parsing the
1237 // generated dependency files. Those that reference .java output files are
1238 // for interfaces and those that do not are parcelables. However, for both
1239 // parcelables and interfaces, we *must* generate a non-empty dependency file.
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001240 vector<string> args = {
1241 "aidl",
1242 "-o place/for/output",
1243 "-d dep/file/path",
1244 "p/Foo.aidl"};
1245 Options options = Options::From(args);
1246 io_delegate_.SetFileContents(options.InputFiles().front(), "package p; parcelable Foo;");
Jiyong Parkb034bf02018-07-30 17:44:33 +09001247 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
Christopher Wileyb1bbdf82016-04-21 11:43:45 -07001248 string actual_dep_file_contents;
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001249 EXPECT_TRUE(io_delegate_.GetWrittenContents(options.DependencyFile(), &actual_dep_file_contents));
Jiyong Parkdf202122019-09-30 20:48:35 +09001250 EXPECT_EQ(actual_dep_file_contents, kExpectedParcelableDeclarationDepFileContents);
1251}
1252
1253TEST_F(AidlTest, WritesDependencyFileForStructuredParcelable) {
1254 vector<string> args = {
1255 "aidl",
1256 "--structured",
1257 "-o place/for/output",
1258 "-d dep/file/path",
1259 "p/Foo.aidl"};
1260 Options options = Options::From(args);
1261 io_delegate_.SetFileContents(options.InputFiles().front(), "package p; parcelable Foo {int a;}");
1262 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1263 string actual_dep_file_contents;
1264 EXPECT_TRUE(io_delegate_.GetWrittenContents(options.DependencyFile(), &actual_dep_file_contents));
1265 EXPECT_EQ(actual_dep_file_contents, kExpectedStructuredParcelableDepFileContents);
Christopher Wileyb1bbdf82016-04-21 11:43:45 -07001266}
1267
Jiyong Park9ca5c7e2019-10-17 15:01:14 +09001268TEST_F(AidlTest, NoJavaOutputForParcelableDeclaration) {
1269 vector<string> args = {
1270 "aidl",
1271 "--lang=java",
1272 "-o place/for/output",
1273 "p/Foo.aidl"};
1274 Options options = Options::From(args);
1275 io_delegate_.SetFileContents(options.InputFiles().front(), "package p; parcelable Foo;");
1276 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1277 string output_file_contents;
1278 EXPECT_FALSE(io_delegate_.GetWrittenContents(options.OutputFile(), &output_file_contents));
1279}
1280
Devin Moore21b26772020-08-26 16:37:56 -07001281TEST_P(AidlTest, RejectsListArray) {
Devin Moore6a01ca12020-08-28 10:24:19 -07001282 const string expected_stderr = "ERROR: a/Foo.aidl:2.1-7: List[] is not supported.\n";
Devin Moore21b26772020-08-26 16:37:56 -07001283 const string list_array_parcelable =
1284 "package a; parcelable Foo {\n"
1285 " List[] lists; }";
1286 CaptureStderr();
1287 EXPECT_EQ(nullptr, Parse("a/Foo.aidl", list_array_parcelable, typenames_, GetLanguage()));
1288 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1289}
1290
Jiyong Parkf8d53612020-05-04 14:06:13 +09001291TEST_P(AidlTest, RejectsPrimitiveListInStableAidl) {
1292 AidlError error;
1293 string expected_stderr =
1294 "ERROR: a/IFoo.aidl:2.7-11: "
1295 "Encountered an untyped List or Map. The use of untyped List/Map is "
1296 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
1297 "the receiving side. Consider switching to an array or a generic List/Map.\n";
1298 if (GetLanguage() != Options::Language::JAVA) {
1299 expected_stderr =
1300 "ERROR: a/IFoo.aidl:2.1-7: "
1301 "Currently, only the Java backend supports non-generic List.\n";
1302 }
1303
1304 const string primitive_interface =
1305 "package a; interface IFoo {\n"
1306 " List foo(); }";
1307 CaptureStderr();
Jiyong Park40782d02020-07-24 19:17:43 +09001308 AidlTypenames tn1;
1309 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", primitive_interface, tn1, GetLanguage(), &error,
Jiyong Parkf8d53612020-05-04 14:06:13 +09001310 {"--structured"}));
1311 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Parkf8d53612020-05-04 14:06:13 +09001312
1313 string primitive_parcelable =
1314 "package a; parcelable IFoo {\n"
1315 " List foo;}";
1316 CaptureStderr();
Jiyong Park40782d02020-07-24 19:17:43 +09001317 AidlTypenames tn2;
1318 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", primitive_parcelable, tn2, GetLanguage(), &error,
Jiyong Parkf8d53612020-05-04 14:06:13 +09001319 {"--structured"}));
1320 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1321}
1322
Jeongik Cha225519b2020-08-29 01:55:32 +09001323TEST_P(AidlTest, ExtensionTest) {
1324 CaptureStderr();
Jeongik Cha649e8a72020-03-27 17:47:40 +09001325 string extendable_parcelable =
1326 "package a; parcelable Data {\n"
1327 " ParcelableHolder extension;\n"
1328 " ParcelableHolder extension2;\n"
1329 "}";
Jeongik Cha8f02a532020-10-14 00:16:28 +09001330 if (GetLanguage() == Options::Language::RUST) {
Jeongik Cha225519b2020-08-29 01:55:32 +09001331 EXPECT_EQ(nullptr, Parse("a/Data.aidl", extendable_parcelable, typenames_, GetLanguage()));
1332 EXPECT_EQ(
Jeongik Cha8f02a532020-10-14 00:16:28 +09001333 "ERROR: a/Data.aidl:2.1-19: The Rust backend does not support ParcelableHolder "
Jeongik Cha225519b2020-08-29 01:55:32 +09001334 "yet.\n",
1335 GetCapturedStderr());
1336 } else {
1337 EXPECT_NE(nullptr, Parse("a/Data.aidl", extendable_parcelable, typenames_, GetLanguage()));
1338 EXPECT_EQ("", GetCapturedStderr());
1339 }
1340}
1341TEST_P(AidlTest, ParcelableHolderAsReturnType) {
1342 CaptureStderr();
Jeongik Cha649e8a72020-03-27 17:47:40 +09001343 string parcelableholder_return_interface =
1344 "package a; interface IFoo {\n"
1345 " ParcelableHolder foo();\n"
1346 "}";
Jeongik Cha225519b2020-08-29 01:55:32 +09001347 EXPECT_EQ(nullptr,
1348 Parse("a/IFoo.aidl", parcelableholder_return_interface, typenames_, GetLanguage()));
Jeongik Cha649e8a72020-03-27 17:47:40 +09001349
Jeongik Cha8f02a532020-10-14 00:16:28 +09001350 if (GetLanguage() == Options::Language::RUST) {
Jeongik Cha225519b2020-08-29 01:55:32 +09001351 EXPECT_EQ(
Steven Morelandebc3c5d2020-09-30 23:40:33 +00001352 "ERROR: a/IFoo.aidl:2.19-23: ParcelableHolder cannot be a return type\n"
Jeongik Cha8f02a532020-10-14 00:16:28 +09001353 "ERROR: a/IFoo.aidl:2.1-19: The Rust backend does not support ParcelableHolder "
Jeongik Cha225519b2020-08-29 01:55:32 +09001354 "yet.\n",
1355 GetCapturedStderr());
1356 return;
1357 }
1358 EXPECT_EQ("ERROR: a/IFoo.aidl:2.19-23: ParcelableHolder cannot be a return type\n",
1359 GetCapturedStderr());
1360}
1361
1362TEST_P(AidlTest, ParcelableHolderAsArgumentType) {
1363 CaptureStderr();
Jeongik Cha649e8a72020-03-27 17:47:40 +09001364 string extendable_parcelable_arg_interface =
1365 "package a; interface IFoo {\n"
1366 " void foo(in ParcelableHolder ph);\n"
1367 "}";
Jeongik Cha225519b2020-08-29 01:55:32 +09001368 EXPECT_EQ(nullptr,
1369 Parse("a/IFoo.aidl", extendable_parcelable_arg_interface, typenames_, GetLanguage()));
1370
Jeongik Cha8f02a532020-10-14 00:16:28 +09001371 if (GetLanguage() == Options::Language::RUST) {
Jeongik Cha225519b2020-08-29 01:55:32 +09001372 EXPECT_EQ(
Steven Morelandebc3c5d2020-09-30 23:40:33 +00001373 "ERROR: a/IFoo.aidl:2.31-34: ParcelableHolder cannot be an argument type\n"
Jeongik Cha8f02a532020-10-14 00:16:28 +09001374 "ERROR: a/IFoo.aidl:2.14-31: The Rust backend does not support ParcelableHolder "
Jeongik Cha225519b2020-08-29 01:55:32 +09001375 "yet.\n",
1376 GetCapturedStderr());
1377 return;
1378 }
1379 EXPECT_EQ("ERROR: a/IFoo.aidl:2.31-34: ParcelableHolder cannot be an argument type\n",
1380 GetCapturedStderr());
Jeongik Cha649e8a72020-03-27 17:47:40 +09001381}
1382
Jeongik Chaf6ec8982020-10-15 00:10:30 +09001383TEST_P(AidlTest, RejectNullableParcelableHolderField) {
1384 io_delegate_.SetFileContents("Foo.aidl", "parcelable Foo { @nullable ParcelableHolder ext; }");
Jooyung Han9435e9a2021-01-06 10:16:31 +09001385 Options options = Options::From("aidl Foo.aidl --lang=" + to_string(GetLanguage()));
Jeongik Chaf6ec8982020-10-15 00:10:30 +09001386 const string expected_stderr = "ERROR: Foo.aidl:1.27-44: ParcelableHolder cannot be nullable.\n";
1387 CaptureStderr();
1388 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
1389 if (GetLanguage() == Options::Language::RUST) {
1390 EXPECT_EQ(
1391 "ERROR: Foo.aidl:1.27-44: ParcelableHolder cannot be nullable.\n"
1392 "ERROR: Foo.aidl:1.27-44: The Rust backend does not support ParcelableHolder "
1393 "yet.\n",
1394 GetCapturedStderr());
1395 return;
1396 }
1397 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1398}
1399
Jooyung Han3f347ca2020-12-01 12:41:50 +09001400TEST_P(AidlTest, ParcelablesWithConstants) {
1401 io_delegate_.SetFileContents("Foo.aidl", "parcelable Foo { const int BIT = 0x1 << 3; }");
Jooyung Han9435e9a2021-01-06 10:16:31 +09001402 Options options = Options::From("aidl Foo.aidl --lang=" + to_string(GetLanguage()));
Jooyung Han3f347ca2020-12-01 12:41:50 +09001403 CaptureStderr();
1404 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1405 EXPECT_EQ("", GetCapturedStderr());
1406}
1407
1408TEST_P(AidlTest, UnionWithConstants) {
1409 io_delegate_.SetFileContents("Foo.aidl", "union Foo { const int BIT = 0x1 << 3; int n; }");
Jooyung Han9435e9a2021-01-06 10:16:31 +09001410 Options options = Options::From("aidl Foo.aidl --lang=" + to_string(GetLanguage()));
Jooyung Han3f347ca2020-12-01 12:41:50 +09001411 CaptureStderr();
1412 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1413 EXPECT_EQ("", GetCapturedStderr());
1414}
1415
Jooyung Han633eab62021-01-07 14:12:40 +09001416TEST_F(AidlTest, ConstantsWithAnnotations) {
1417 io_delegate_.SetFileContents("IFoo.aidl",
1418 "interface IFoo {\n"
1419 " @JavaPassthrough(annotation=\"@Foo\")\n"
1420 " const @JavaPassthrough(annotation=\"@Bar\") int FOO = 0;\n"
1421 "}");
1422 Options options = Options::From("aidl IFoo.aidl --lang=java -o out");
1423 CaptureStderr();
1424 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1425 EXPECT_EQ("", GetCapturedStderr());
1426 string code;
1427 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/IFoo.java", &code));
1428 EXPECT_THAT(code, HasSubstr("@Foo\n"));
1429 EXPECT_THAT(code, HasSubstr("@Bar\n"));
1430}
1431
Jiyong Park02da7422018-07-16 16:00:26 +09001432TEST_F(AidlTest, ApiDump) {
1433 io_delegate_.SetFileContents(
1434 "foo/bar/IFoo.aidl",
1435 "package foo.bar;\n"
1436 "import foo.bar.Data;\n"
Jooyung Han24effbf2021-01-16 10:24:03 +09001437 "// commented /* @hide */\n"
Jiyong Park02da7422018-07-16 16:00:26 +09001438 "interface IFoo {\n"
Jooyung Han161bb0f2021-01-21 12:30:16 +09001439 " /* @hide applied \n"
1440 " @deprecated use foo2 */\n"
1441 " int foo(out int[] a, String b, boolean c, inout List<String> d);\n"
1442 " int foo2(@utf8InCpp String x, inout List<String> y);\n"
Jiyong Park02da7422018-07-16 16:00:26 +09001443 " IFoo foo3(IFoo foo);\n"
1444 " Data getData();\n"
Jooyung Han161bb0f2021-01-21 12:30:16 +09001445 " // @hide not applied\n"
Jooyung Han9fd67022021-01-13 10:49:48 +09001446 " /** blahblah\n"
1447 " @deprecated\n"
1448 " reason why... */\n"
Jiyong Parka428d212018-08-29 22:26:30 +09001449 " const int A = 1;\n"
Jooyung Han24effbf2021-01-16 10:24:03 +09001450 " // @deprecated tags in line comments are ignored\n"
Jiyong Parka428d212018-08-29 22:26:30 +09001451 " const String STR = \"Hello\";\n"
Jiyong Park02da7422018-07-16 16:00:26 +09001452 "}\n");
1453 io_delegate_.SetFileContents("foo/bar/Data.aidl",
1454 "package foo.bar;\n"
1455 "import foo.bar.IFoo;\n"
Jeongik Cha997281d2020-01-16 15:23:59 +09001456 "/* @hide*/\n"
Jiyong Park02da7422018-07-16 16:00:26 +09001457 "parcelable Data {\n"
Jeongik Cha997281d2020-01-16 15:23:59 +09001458 " // @hide\n"
Jiyong Parka468e2a2018-08-29 21:25:18 +09001459 " int x = 10;\n"
Jeongik Cha997281d2020-01-16 15:23:59 +09001460 " // @hide\n"
Jiyong Park02da7422018-07-16 16:00:26 +09001461 " int y;\n"
Jeongik Cha997281d2020-01-16 15:23:59 +09001462 " /*@hide2*/\n"
Jooyung Han55f96ad2020-12-13 10:08:33 +09001463 " IFoo foo;\n"
Jooyung Han24effbf2021-01-16 10:24:03 +09001464 " // Ignore @hide property in line comment\n"
Jeongik Cha3271ffa2018-12-04 15:19:20 +09001465 " @nullable String[] c;\n"
Jiyong Park02da7422018-07-16 16:00:26 +09001466 "}\n");
1467 io_delegate_.SetFileContents("api.aidl", "");
Jiyong Park633246c2019-11-25 10:50:05 +09001468 vector<string> args = {"aidl", "--dumpapi", "--out=dump", "--include=.",
1469 "foo/bar/IFoo.aidl", "foo/bar/Data.aidl"};
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001470 Options options = Options::From(args);
Jiyong Park02da7422018-07-16 16:00:26 +09001471 bool result = dump_api(options, io_delegate_);
1472 ASSERT_TRUE(result);
1473 string actual;
Jiyong Parke59c3682018-09-11 23:10:25 +09001474 EXPECT_TRUE(io_delegate_.GetWrittenContents("dump/foo/bar/IFoo.aidl", &actual));
Jooyung Han161bb0f2021-01-21 12:30:16 +09001475 EXPECT_EQ(string(kPreamble).append(R"(package foo.bar;
Jiyong Parke59c3682018-09-11 23:10:25 +09001476interface IFoo {
Jooyung Han161bb0f2021-01-21 12:30:16 +09001477 /**
1478 * @hide
1479 * @deprecated use foo2
1480 */
Jiyong Parke59c3682018-09-11 23:10:25 +09001481 int foo(out int[] a, String b, boolean c, inout List<String> d);
1482 int foo2(@utf8InCpp String x, inout List<String> y);
1483 foo.bar.IFoo foo3(foo.bar.IFoo foo);
1484 foo.bar.Data getData();
Jooyung Han161bb0f2021-01-21 12:30:16 +09001485 /**
1486 * @deprecated reason why...
1487 */
Jiyong Parke59c3682018-09-11 23:10:25 +09001488 const int A = 1;
1489 const String STR = "Hello";
1490}
Jooyung Han161bb0f2021-01-21 12:30:16 +09001491)"),
1492 actual);
Jiyong Park02da7422018-07-16 16:00:26 +09001493
Jiyong Parke59c3682018-09-11 23:10:25 +09001494 EXPECT_TRUE(io_delegate_.GetWrittenContents("dump/foo/bar/Data.aidl", &actual));
Jooyung Han161bb0f2021-01-21 12:30:16 +09001495 EXPECT_EQ(string(kPreamble).append(R"(package foo.bar;
Jooyung Han8db65942021-03-02 18:14:44 +09001496/* @hide */
Jiyong Parke59c3682018-09-11 23:10:25 +09001497parcelable Data {
1498 int x = 10;
1499 int y;
1500 foo.bar.IFoo foo;
Jeongik Cha3271ffa2018-12-04 15:19:20 +09001501 @nullable String[] c;
Jiyong Park02da7422018-07-16 16:00:26 +09001502}
Jooyung Han161bb0f2021-01-21 12:30:16 +09001503)"),
1504 actual);
Jiyong Park02da7422018-07-16 16:00:26 +09001505}
1506
Jiyong Parked65bf42018-08-28 15:43:27 +09001507TEST_F(AidlTest, ApiDumpWithManualIds) {
1508 io_delegate_.SetFileContents(
1509 "foo/bar/IFoo.aidl",
1510 "package foo.bar;\n"
1511 "interface IFoo {\n"
1512 " int foo() = 1;\n"
1513 " int bar() = 2;\n"
1514 " int baz() = 10;\n"
1515 "}\n");
1516
Jiyong Parke59c3682018-09-11 23:10:25 +09001517 vector<string> args = {"aidl", "--dumpapi", "-o dump", "foo/bar/IFoo.aidl"};
Jiyong Parked65bf42018-08-28 15:43:27 +09001518 Options options = Options::From(args);
1519 bool result = dump_api(options, io_delegate_);
1520 ASSERT_TRUE(result);
1521 string actual;
Jiyong Parke59c3682018-09-11 23:10:25 +09001522 EXPECT_TRUE(io_delegate_.GetWrittenContents("dump/foo/bar/IFoo.aidl", &actual));
Paul Trautrimb01451d2020-02-27 13:10:16 +09001523 EXPECT_EQ(actual, string(kPreamble).append(R"(package foo.bar;
Jiyong Parke59c3682018-09-11 23:10:25 +09001524interface IFoo {
1525 int foo() = 1;
1526 int bar() = 2;
1527 int baz() = 10;
Jiyong Parked65bf42018-08-28 15:43:27 +09001528}
Paul Trautrimb01451d2020-02-27 13:10:16 +09001529)"));
Jiyong Parked65bf42018-08-28 15:43:27 +09001530}
1531
1532TEST_F(AidlTest, ApiDumpWithManualIdsOnlyOnSomeMethods) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001533 const string expected_stderr =
1534 "ERROR: foo/bar/IFoo.aidl:4.8-12: You must either assign id's to all methods or to none of "
1535 "them.\n";
Jiyong Parked65bf42018-08-28 15:43:27 +09001536 io_delegate_.SetFileContents(
1537 "foo/bar/IFoo.aidl",
1538 "package foo.bar;\n"
1539 "interface IFoo {\n"
1540 " int foo() = 1;\n"
1541 " int bar();\n"
1542 " int baz() = 10;\n"
1543 "}\n");
1544
Jiyong Parke59c3682018-09-11 23:10:25 +09001545 vector<string> args = {"aidl", "--dumpapi", "-o dump", "foo/bar/IFoo.aidl"};
Jiyong Parked65bf42018-08-28 15:43:27 +09001546 Options options = Options::From(args);
Devin Moore097a3ab2020-03-11 16:08:44 -07001547 CaptureStderr();
Jiyong Parked65bf42018-08-28 15:43:27 +09001548 EXPECT_FALSE(dump_api(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001549 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Parked65bf42018-08-28 15:43:27 +09001550}
1551
Jooyung Han965e31d2020-11-27 12:30:16 +09001552TEST_F(AidlTest, ApiDumpConstWithAnnotation) {
1553 io_delegate_.SetFileContents("foo/bar/IFoo.aidl",
1554 "package foo.bar;\n"
1555 "interface IFoo {\n"
1556 " @utf8InCpp String foo();\n"
1557 " const @utf8InCpp String bar = \"bar\";\n"
1558 "}\n");
1559
1560 vector<string> args = {"aidl", "--dumpapi", "-o dump", "foo/bar/IFoo.aidl"};
1561 Options options = Options::From(args);
1562 CaptureStderr();
1563 EXPECT_TRUE(dump_api(options, io_delegate_));
1564 EXPECT_EQ("", GetCapturedStderr());
1565 string actual;
1566 EXPECT_TRUE(io_delegate_.GetWrittenContents("dump/foo/bar/IFoo.aidl", &actual));
Jooyung Han965e31d2020-11-27 12:30:16 +09001567 EXPECT_EQ(string(kPreamble).append(R"(package foo.bar;
1568interface IFoo {
1569 @utf8InCpp String foo();
Jooyung Hanb3ca6302020-11-27 14:13:27 +09001570 const @utf8InCpp String bar = "bar";
Jooyung Han965e31d2020-11-27 12:30:16 +09001571}
1572)"),
1573 actual);
1574}
1575
Jooyung Hanfdaae1d2020-12-14 13:16:15 +09001576TEST_F(AidlTest, ApiDumpWithEnums) {
1577 io_delegate_.SetFileContents("foo/bar/Enum.aidl",
1578 "package foo.bar;\n"
1579 "enum Enum {\n"
1580 " FOO,\n"
1581 " BAR = FOO + 1,\n"
1582 "}\n");
1583
1584 vector<string> args = {"aidl", "--dumpapi", "-I . ", "-o dump", "foo/bar/Enum.aidl"};
1585 Options options = Options::From(args);
1586 CaptureStderr();
1587 EXPECT_TRUE(dump_api(options, io_delegate_));
1588 EXPECT_EQ("", GetCapturedStderr());
1589 string actual;
1590 EXPECT_TRUE(io_delegate_.GetWrittenContents("dump/foo/bar/Enum.aidl", &actual));
1591 EXPECT_EQ(string(kPreamble).append("package foo.bar;\n"
1592 "enum Enum {\n"
1593 " FOO = 0,\n"
1594 " BAR = 1,\n"
1595 "}\n"),
1596 actual);
1597}
1598
1599TEST_F(AidlTest, ApiDumpWithEnumDefaultValues) {
1600 io_delegate_.SetFileContents("foo/bar/Enum.aidl",
1601 "package foo.bar;\n"
1602 "enum Enum {\n"
1603 " FOO,\n"
1604 "}\n");
1605 io_delegate_.SetFileContents("foo/bar/Foo.aidl",
1606 "package foo.bar;\n"
1607 "import foo.bar.Enum;\n"
1608 "parcelable Foo {\n"
1609 " Enum e = Enum.FOO;\n"
1610 "}\n");
1611
1612 vector<string> args = {"aidl", "--dumpapi", "-I . ", "-o dump", "foo/bar/Foo.aidl"};
1613 Options options = Options::From(args);
1614 CaptureStderr();
1615 EXPECT_TRUE(dump_api(options, io_delegate_));
1616 EXPECT_EQ("", GetCapturedStderr());
1617 string actual;
1618 EXPECT_TRUE(io_delegate_.GetWrittenContents("dump/foo/bar/Foo.aidl", &actual));
1619 EXPECT_EQ(string(kPreamble).append("package foo.bar;\n"
1620 "parcelable Foo {\n"
1621 " foo.bar.Enum e = foo.bar.Enum.FOO;\n"
1622 "}\n"),
1623 actual);
1624}
1625
Jiyong Park1d2df7d2018-07-23 15:22:50 +09001626TEST_F(AidlTest, CheckNumGenericTypeSecifier) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001627 const string expected_list_stderr =
Steven Morelandebc3c5d2020-09-30 23:40:33 +00001628 "ERROR: p/IFoo.aidl:1.37-41: List can only have one type parameter, but got: "
1629 "'List<String,String>'\n";
Devin Moore097a3ab2020-03-11 16:08:44 -07001630 const string expected_map_stderr =
1631 "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 +09001632 Options options = Options::From("aidl p/IFoo.aidl IFoo.java");
1633 io_delegate_.SetFileContents(options.InputFiles().front(),
Jiyong Park1d2df7d2018-07-23 15:22:50 +09001634 "package p; interface IFoo {"
1635 "void foo(List<String, String> a);}");
Devin Moore097a3ab2020-03-11 16:08:44 -07001636 CaptureStderr();
Jiyong Parkb034bf02018-07-30 17:44:33 +09001637 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001638 EXPECT_EQ(expected_list_stderr, GetCapturedStderr());
Jiyong Park1d2df7d2018-07-23 15:22:50 +09001639
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001640 io_delegate_.SetFileContents(options.InputFiles().front(),
Jiyong Park1d2df7d2018-07-23 15:22:50 +09001641 "package p; interface IFoo {"
1642 "void foo(Map<String> a);}");
Devin Moore097a3ab2020-03-11 16:08:44 -07001643 CaptureStderr();
Jiyong Parkb034bf02018-07-30 17:44:33 +09001644 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001645 EXPECT_EQ(expected_map_stderr, GetCapturedStderr());
Jiyong Parkb034bf02018-07-30 17:44:33 +09001646}
1647
Jeongik Chae48d9942020-01-02 17:39:00 +09001648TEST_F(AidlTest, CheckTypeParameterInMapType) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001649 const string expected_stderr =
1650 "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 +09001651 Options options = Options::From("aidl -I p p/IFoo.aidl");
1652 io_delegate_.SetFileContents("p/Bar.aidl", "package p; parcelable Bar { String s; }");
1653
1654 io_delegate_.SetFileContents("p/IFoo.aidl",
1655 "package p; interface IFoo {"
1656 "Map<String, Bar> foo();}");
1657 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1658
1659 io_delegate_.SetFileContents("p/IFoo.aidl",
1660 "package p; interface IFoo {"
1661 "Map<Bar, Bar> foo();}");
Devin Moore097a3ab2020-03-11 16:08:44 -07001662 CaptureStderr();
Jeongik Chae48d9942020-01-02 17:39:00 +09001663 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001664 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jeongik Chae48d9942020-01-02 17:39:00 +09001665
1666 io_delegate_.SetFileContents("p/IFoo.aidl",
1667 "package p; interface IFoo {"
1668 "Map<String, String> foo();}");
1669 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1670
1671 io_delegate_.SetFileContents("p/IFoo.aidl",
1672 "package p; interface IFoo {"
1673 "Map<String, ParcelFileDescriptor> foo();}");
1674 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1675}
1676
Jeongik Chadf76dc72019-11-28 00:08:47 +09001677TEST_F(AidlTest, WrongGenericType) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001678 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 +09001679 Options options = Options::From("aidl p/IFoo.aidl IFoo.java");
1680 io_delegate_.SetFileContents(options.InputFiles().front(),
1681 "package p; interface IFoo {"
1682 "String<String> foo(); }");
Devin Moore097a3ab2020-03-11 16:08:44 -07001683 CaptureStderr();
Jeongik Chadf76dc72019-11-28 00:08:47 +09001684 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001685 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jeongik Chadf76dc72019-11-28 00:08:47 +09001686}
1687
1688TEST_F(AidlTest, UserDefinedUnstructuredGenericParcelableType) {
1689 Options optionsForParcelable = Options::From("aidl -I p p/Bar.aidl");
1690 io_delegate_.SetFileContents("p/Bar.aidl", "package p; parcelable Bar<T, T>;");
Devin Moore097a3ab2020-03-11 16:08:44 -07001691 CaptureStderr();
Jeongik Chadf76dc72019-11-28 00:08:47 +09001692 EXPECT_NE(0, ::android::aidl::compile_aidl(optionsForParcelable, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001693 EXPECT_EQ("ERROR: p/Bar.aidl:1.22-26: Every type parameter should be unique.\n",
1694 GetCapturedStderr());
Jeongik Chadf76dc72019-11-28 00:08:47 +09001695
1696 Options options = Options::From("aidl -I p p/IFoo.aidl");
1697 io_delegate_.SetFileContents("p/Bar.aidl", "package p; parcelable Bar;");
1698 io_delegate_.SetFileContents("p/IFoo.aidl",
1699 "package p; interface IFoo {"
1700 "Bar<String, String> foo();}");
Devin Moore097a3ab2020-03-11 16:08:44 -07001701 CaptureStderr();
Jeongik Chadf76dc72019-11-28 00:08:47 +09001702 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001703 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 +09001704 io_delegate_.SetFileContents("p/Bar.aidl", "package p; parcelable Bar<T>;");
Devin Moore097a3ab2020-03-11 16:08:44 -07001705 CaptureStderr();
Jeongik Chadf76dc72019-11-28 00:08:47 +09001706 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001707 EXPECT_EQ("ERROR: p/IFoo.aidl:1.28-31: p.Bar must have 1 type parameters, but got 2\n",
1708 GetCapturedStderr());
Jeongik Chadf76dc72019-11-28 00:08:47 +09001709 io_delegate_.SetFileContents("p/Bar.aidl", "package p; parcelable Bar<T, V>;");
1710 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1711 io_delegate_.SetFileContents("p/IFoo.aidl",
1712 "package p; interface IFoo {"
1713 "Bar<String, ParcelFileDescriptor> foo();}");
1714 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jeongik Chae74c86d2019-12-12 16:54:03 +09001715
1716 io_delegate_.SetFileContents("p/IFoo.aidl",
1717 "package p; interface IFoo {"
1718 "Bar<int, long> foo();}");
1719
1720 io_delegate_.SetFileContents("p/IFoo.aidl",
1721 "package p; interface IFoo {"
1722 "Bar<int[], long[]> foo();}");
1723
1724 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jeongik Chadf76dc72019-11-28 00:08:47 +09001725}
1726
Jeongik Cha0e426012019-07-29 15:57:02 +09001727TEST_F(AidlTest, FailOnMultipleTypesInSingleFile) {
1728 std::vector<std::string> rawOptions{"aidl --lang=java -o out foo/bar/Foo.aidl",
Andrei Homescub62afd92020-05-11 19:24:59 -07001729 "aidl --lang=cpp -o out -h out/include foo/bar/Foo.aidl",
1730 "aidl --lang=rust -o out foo/bar/Foo.aidl"};
Devin Moore5de18ed2020-04-02 13:52:29 -07001731 for (const auto& rawOption : rawOptions) {
1732 string expected_stderr =
1733 "ERROR: foo/bar/Foo.aidl:3.1-10: You must declare only one type per file.\n";
Jeongik Cha0e426012019-07-29 15:57:02 +09001734 Options options = Options::From(rawOption);
1735 io_delegate_.SetFileContents(options.InputFiles().front(),
1736 "package foo.bar;\n"
1737 "interface IFoo1 { int foo(); }\n"
1738 "interface IFoo2 { int foo(); }\n"
1739 "parcelable Data1 { int a; int b;}\n"
1740 "parcelable Data2 { int a; int b;}\n");
Devin Moore097a3ab2020-03-11 16:08:44 -07001741 CaptureStderr();
Jeongik Cha0e426012019-07-29 15:57:02 +09001742 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001743 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Parkb034bf02018-07-30 17:44:33 +09001744
Jeongik Cha0e426012019-07-29 15:57:02 +09001745 io_delegate_.SetFileContents(options.InputFiles().front(),
1746 "package foo.bar;\n"
1747 "interface IFoo1 { int foo(); }\n"
1748 "interface IFoo2 { int foo(); }\n");
Devin Moore097a3ab2020-03-11 16:08:44 -07001749 CaptureStderr();
Jeongik Cha0e426012019-07-29 15:57:02 +09001750 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001751 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Parkb034bf02018-07-30 17:44:33 +09001752
Devin Moore5de18ed2020-04-02 13:52:29 -07001753 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 +09001754 io_delegate_.SetFileContents(options.InputFiles().front(),
1755 "package foo.bar;\n"
1756 "parcelable Data1 { int a; int b;}\n"
1757 "parcelable Data2 { int a; int b;}\n");
Devin Moore097a3ab2020-03-11 16:08:44 -07001758 CaptureStderr();
Jeongik Cha0e426012019-07-29 15:57:02 +09001759 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001760 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Parkb034bf02018-07-30 17:44:33 +09001761 }
1762}
1763
Devin Moorebdba2a82020-03-31 15:19:02 -07001764TEST_P(AidlTest, FailParseOnEmptyFile) {
1765 const string contents = "";
1766 const string expected_stderr = "ERROR: a/IFoo.aidl:1.1-1: syntax error, unexpected $end\n";
1767 CaptureStderr();
1768 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", contents, typenames_, GetLanguage()));
1769 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1770}
1771
Jiyong Parkb034bf02018-07-30 17:44:33 +09001772TEST_F(AidlTest, MultipleInputFiles) {
1773 Options options = Options::From(
Jiyong Park633246c2019-11-25 10:50:05 +09001774 "aidl --lang=java -o out -I . foo/bar/IFoo.aidl foo/bar/Data.aidl");
Jiyong Parkb034bf02018-07-30 17:44:33 +09001775
1776 io_delegate_.SetFileContents(options.InputFiles().at(0),
1777 "package foo.bar;\n"
1778 "import foo.bar.Data;\n"
1779 "interface IFoo { Data getData(); }\n");
1780
1781 io_delegate_.SetFileContents(options.InputFiles().at(1),
1782 "package foo.bar;\n"
1783 "import foo.bar.IFoo;\n"
1784 "parcelable Data { IFoo foo; }\n");
1785
1786 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1787
1788 string content;
1789 for (const auto file : {
1790 "out/foo/bar/IFoo.java", "out/foo/bar/Data.java"}) {
1791 content.clear();
1792 EXPECT_TRUE(io_delegate_.GetWrittenContents(file, &content));
1793 EXPECT_FALSE(content.empty());
1794 }
1795}
1796
1797TEST_F(AidlTest, MultipleInputFilesCpp) {
1798 Options options = Options::From("aidl --lang=cpp -o out -h out/include "
Jiyong Park633246c2019-11-25 10:50:05 +09001799 "-I . foo/bar/IFoo.aidl foo/bar/Data.aidl");
Jiyong Parkb034bf02018-07-30 17:44:33 +09001800
1801 io_delegate_.SetFileContents(options.InputFiles().at(0),
1802 "package foo.bar;\n"
1803 "import foo.bar.Data;\n"
1804 "interface IFoo { Data getData(); }\n");
1805
1806 io_delegate_.SetFileContents(options.InputFiles().at(1),
1807 "package foo.bar;\n"
1808 "import foo.bar.IFoo;\n"
1809 "parcelable Data { IFoo foo; }\n");
1810
1811 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1812
1813 string content;
1814 for (const auto file : {
Jiyong Parkb03551f2018-08-06 19:20:51 +09001815 "out/foo/bar/IFoo.cpp", "out/foo/bar/Data.cpp",
Jiyong Parkb034bf02018-07-30 17:44:33 +09001816 "out/include/foo/bar/IFoo.h", "out/include/foo/bar/Data.h",
1817 "out/include/foo/bar/BpFoo.h", "out/include/foo/bar/BpData.h",
1818 "out/include/foo/bar/BnFoo.h", "out/include/foo/bar/BnData.h"}) {
1819 content.clear();
1820 EXPECT_TRUE(io_delegate_.GetWrittenContents(file, &content));
1821 EXPECT_FALSE(content.empty());
1822 }
Jiyong Park1d2df7d2018-07-23 15:22:50 +09001823}
1824
Andrei Homescub62afd92020-05-11 19:24:59 -07001825TEST_F(AidlTest, MultipleInputFilesRust) {
1826 Options options =
1827 Options::From("aidl --lang=rust -o out -I . foo/bar/IFoo.aidl foo/bar/Data.aidl");
1828
1829 io_delegate_.SetFileContents(options.InputFiles().at(0),
1830 "package foo.bar;\n"
1831 "import foo.bar.Data;\n"
1832 "interface IFoo { Data getData(); }\n");
1833
1834 io_delegate_.SetFileContents(options.InputFiles().at(1),
1835 "package foo.bar;\n"
1836 "import foo.bar.IFoo;\n"
1837 "parcelable Data { IFoo foo; }\n");
1838
1839 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1840
1841 string content;
1842 for (const auto file : {"out/foo/bar/IFoo.rs", "out/foo/bar/Data.rs"}) {
1843 content.clear();
1844 EXPECT_TRUE(io_delegate_.GetWrittenContents(file, &content));
1845 EXPECT_FALSE(content.empty());
1846 }
1847}
1848
Devin Moore097a3ab2020-03-11 16:08:44 -07001849TEST_F(AidlTest, ConflictWithMetaTransactionGetVersion) {
1850 const string expected_stderr =
1851 "ERROR: p/IFoo.aidl:1.31-51: method getInterfaceVersion() is reserved for internal use.\n";
Jiyong Park309668e2018-07-28 16:55:44 +09001852 Options options = Options::From("aidl --lang=java -o place/for/output p/IFoo.aidl");
1853 // int getInterfaceVersion() is one of the meta transactions
1854 io_delegate_.SetFileContents(options.InputFiles().front(),
1855 "package p; interface IFoo {"
1856 "int getInterfaceVersion(); }");
Devin Moore097a3ab2020-03-11 16:08:44 -07001857 CaptureStderr();
Jiyong Parkb034bf02018-07-30 17:44:33 +09001858 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001859 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1860}
Jiyong Park309668e2018-07-28 16:55:44 +09001861
Devin Moore097a3ab2020-03-11 16:08:44 -07001862TEST_F(AidlTest, ConflictWithSimilarMetaTransaction) {
1863 // boolean getInterfaceVersion() is not a meta transaction, but should be
1864 // prevented because return type is not part of a method signature
1865 const string expected_stderr =
1866 "ERROR: p/IFoo.aidl:1.35-55: method getInterfaceVersion() is reserved for internal use.\n";
1867 Options options = Options::From("aidl --lang=java -o place/for/output p/IFoo.aidl");
Jiyong Park309668e2018-07-28 16:55:44 +09001868 io_delegate_.SetFileContents(options.InputFiles().front(),
1869 "package p; interface IFoo {"
1870 "boolean getInterfaceVersion(); }");
Devin Moore097a3ab2020-03-11 16:08:44 -07001871 CaptureStderr();
Jiyong Parkb034bf02018-07-30 17:44:33 +09001872 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001873 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1874}
Jiyong Park309668e2018-07-28 16:55:44 +09001875
Devin Moore097a3ab2020-03-11 16:08:44 -07001876TEST_F(AidlTest, ConflictWithMetaTransactionGetName) {
Jiyong Park309668e2018-07-28 16:55:44 +09001877 // this is another reserved name
Devin Moore097a3ab2020-03-11 16:08:44 -07001878 const string expected_stderr =
1879 "ERROR: p/IFoo.aidl:1.34-53: method getTransactionName(int) is reserved for internal use.\n";
1880 Options options = Options::From("aidl --lang=java -o place/for/output p/IFoo.aidl");
Jiyong Park309668e2018-07-28 16:55:44 +09001881 io_delegate_.SetFileContents(options.InputFiles().front(),
1882 "package p; interface IFoo {"
1883 "String getTransactionName(int code); }");
Devin Moore097a3ab2020-03-11 16:08:44 -07001884 CaptureStderr();
Jiyong Parkb034bf02018-07-30 17:44:33 +09001885 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001886 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Park309668e2018-07-28 16:55:44 +09001887
1888 // this is not a meta interface method as it differs type arguments
1889 io_delegate_.SetFileContents(options.InputFiles().front(),
1890 "package p; interface IFoo {"
1891 "String getTransactionName(); }");
Jiyong Parkb034bf02018-07-30 17:44:33 +09001892 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jiyong Park309668e2018-07-28 16:55:44 +09001893}
1894
Jooyung Hanb8a97772021-01-19 01:27:38 +09001895TEST_F(AidlTest, CheckApiForEquality) {
1896 CaptureStderr();
1897 Options options = Options::From("aidl --checkapi=equal old new");
1898
1899 io_delegate_.SetFileContents("old/p/IFoo.aidl",
1900 "package p; interface IFoo{ @utf8InCpp @nullable String foo();}");
1901 io_delegate_.SetFileContents("new/p/IFoo.aidl",
1902 "package p; interface IFoo{ @utf8InCpp String foo();}");
1903
1904 EXPECT_FALSE(::android::aidl::check_api(options, io_delegate_));
1905 EXPECT_THAT(GetCapturedStderr(), HasSubstr("+ @utf8InCpp String foo();"));
1906}
1907
Daniel Norman85aed542019-08-21 12:01:14 -07001908TEST_F(AidlTest, DifferentOrderAnnotationsInCheckAPI) {
Jeongik Cha3271ffa2018-12-04 15:19:20 +09001909 Options options = Options::From("aidl --checkapi old new");
1910 io_delegate_.SetFileContents("old/p/IFoo.aidl",
1911 "package p; interface IFoo{ @utf8InCpp @nullable String foo();}");
1912 io_delegate_.SetFileContents("new/p/IFoo.aidl",
1913 "package p; interface IFoo{ @nullable @utf8InCpp String foo();}");
1914
1915 EXPECT_TRUE(::android::aidl::check_api(options, io_delegate_));
1916}
1917
Jiyong Park3656c3c2018-08-01 20:02:01 +09001918TEST_F(AidlTest, SuccessOnIdenticalApiDumps) {
Jiyong Parke59c3682018-09-11 23:10:25 +09001919 Options options = Options::From("aidl --checkapi old new");
1920 io_delegate_.SetFileContents("old/p/IFoo.aidl", "package p; interface IFoo{ void foo();}");
1921 io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p; interface IFoo{ void foo();}");
Jiyong Park3656c3c2018-08-01 20:02:01 +09001922
1923 EXPECT_TRUE(::android::aidl::check_api(options, io_delegate_));
1924}
1925
Jooyung Hanfdaae1d2020-12-14 13:16:15 +09001926TEST_F(AidlTest, CheckApi_EnumFieldsWithDefaultValues) {
1927 Options options = Options::From("aidl --checkapi old new");
1928 const string foo_definition = "package p; parcelable Foo{ p.Enum e = p.Enum.FOO; }";
1929 const string enum_definition = "package p; enum Enum { FOO }";
1930 io_delegate_.SetFileContents("old/p/Foo.aidl", foo_definition);
1931 io_delegate_.SetFileContents("old/p/Enum.aidl", enum_definition);
1932 io_delegate_.SetFileContents("new/p/Foo.aidl", foo_definition);
1933 io_delegate_.SetFileContents("new/p/Enum.aidl", enum_definition);
1934
1935 EXPECT_TRUE(::android::aidl::check_api(options, io_delegate_));
1936}
1937
Jooyung Han02a11be2021-02-11 13:18:06 +09001938TEST_F(AidlTest, CheckApiEqual_EnumFieldsWithDefaultValues) {
1939 Options options = Options::From("aidl --checkapi=equal old new");
1940 const string foo_definition = "package p; parcelable Foo{ p.Enum e = p.Enum.FOO; }";
1941 const string enum_definition = "package p; enum Enum { FOO }";
1942 io_delegate_.SetFileContents("old/p/Foo.aidl", foo_definition);
1943 io_delegate_.SetFileContents("old/p/Enum.aidl", enum_definition);
1944 io_delegate_.SetFileContents("new/p/Foo.aidl", foo_definition);
1945 io_delegate_.SetFileContents("new/p/Enum.aidl", enum_definition);
1946 CaptureStderr();
1947 EXPECT_TRUE(::android::aidl::check_api(options, io_delegate_));
1948 EXPECT_EQ("", GetCapturedStderr());
1949}
1950
Daniel Norman85aed542019-08-21 12:01:14 -07001951class AidlTestCompatibleChanges : public AidlTest {
1952 protected:
1953 Options options_ = Options::From("aidl --checkapi old new");
1954};
1955
1956TEST_F(AidlTestCompatibleChanges, NewType) {
1957 io_delegate_.SetFileContents("old/p/IFoo.aidl",
1958 "package p;"
1959 "interface IFoo {"
1960 " void foo(int a);"
1961 "}");
1962 io_delegate_.SetFileContents("new/p/IFoo.aidl",
1963 "package p;"
1964 "interface IFoo {"
1965 " void foo(int a);"
1966 "}");
1967 io_delegate_.SetFileContents("new/p/IBar.aidl",
1968 "package p;"
1969 "interface IBar {"
1970 " void bar();"
1971 "}");
1972 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
1973}
1974
1975TEST_F(AidlTestCompatibleChanges, NewMethod) {
1976 io_delegate_.SetFileContents("old/p/IFoo.aidl",
1977 "package p;"
1978 "interface IFoo {"
1979 " void foo(int a);"
1980 "}");
1981 io_delegate_.SetFileContents("new/p/IFoo.aidl",
1982 "package p;"
1983 "interface IFoo {"
1984 " void foo(int a);"
1985 " void bar();"
Jiyong Parkf8d53612020-05-04 14:06:13 +09001986 " void baz(in List<IFoo> arg);"
Daniel Norman85aed542019-08-21 12:01:14 -07001987 "}");
1988 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
1989}
1990
1991TEST_F(AidlTestCompatibleChanges, NewField) {
1992 io_delegate_.SetFileContents("old/p/Data.aidl",
1993 "package p;"
1994 "parcelable Data {"
1995 " int foo;"
1996 "}");
1997 io_delegate_.SetFileContents("new/p/Data.aidl",
1998 "package p;"
1999 "parcelable Data {"
2000 " int foo;"
Steven Moreland370ed342020-04-28 18:14:39 -07002001 " int bar = 0;"
Jiyong Parkf8d53612020-05-04 14:06:13 +09002002 " @nullable List<Data> list;"
Daniel Norman85aed542019-08-21 12:01:14 -07002003 "}");
2004 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2005}
2006
2007TEST_F(AidlTestCompatibleChanges, NewEnumerator) {
2008 io_delegate_.SetFileContents("old/p/Enum.aidl",
2009 "package p;"
2010 "enum Enum {"
2011 " FOO = 1,"
2012 "}");
2013 io_delegate_.SetFileContents("new/p/Enum.aidl",
2014 "package p;"
2015 "enum Enum {"
2016 " FOO = 1,"
2017 " BAR = 2,"
2018 "}");
2019 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2020}
2021
2022TEST_F(AidlTestCompatibleChanges, ReorderedEnumerator) {
2023 io_delegate_.SetFileContents("old/p/Enum.aidl",
2024 "package p;"
2025 "enum Enum {"
2026 " FOO = 1,"
2027 " BAR = 2,"
2028 "}");
2029 io_delegate_.SetFileContents("new/p/Enum.aidl",
2030 "package p;"
2031 "enum Enum {"
2032 " BAR = 2,"
2033 " FOO = 1,"
2034 "}");
2035 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2036}
2037
Jooyung Hanb5c55cd2020-10-22 07:59:01 +09002038TEST_F(AidlTestCompatibleChanges, NewUnionField) {
2039 io_delegate_.SetFileContents("old/p/Union.aidl",
2040 "package p;"
2041 "union Union {"
2042 " String foo;"
2043 "}");
2044 io_delegate_.SetFileContents("new/p/Union.aidl",
2045 "package p;"
2046 "union Union {"
2047 " String foo;"
2048 " int num;"
2049 "}");
2050 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2051}
2052
Daniel Norman85aed542019-08-21 12:01:14 -07002053TEST_F(AidlTestCompatibleChanges, NewPackage) {
Jiyong Parke59c3682018-09-11 23:10:25 +09002054 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2055 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002056 "interface IFoo {"
2057 " void foo(int a);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002058 "}");
2059 io_delegate_.SetFileContents("old/p/Data.aidl",
2060 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002061 "parcelable Data {"
2062 " int foo;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002063 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002064 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2065 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002066 "interface IFoo {"
2067 " void foo(int a);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002068 "}");
2069 io_delegate_.SetFileContents("new/p/Data.aidl",
2070 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002071 "parcelable Data {"
2072 " int foo;"
Jiyong Parke59c3682018-09-11 23:10:25 +09002073 "}");
2074 io_delegate_.SetFileContents("new/q/IFoo.aidl",
2075 "package q;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002076 "interface IFoo {"
Jiyong Parke59c3682018-09-11 23:10:25 +09002077 " void foo(int a);"
2078 "}");
2079 io_delegate_.SetFileContents("new/q/Data.aidl",
2080 "package q;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002081 "parcelable Data {"
2082 " int foo;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002083 "}");
Daniel Norman85aed542019-08-21 12:01:14 -07002084 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2085}
Jiyong Park3656c3c2018-08-01 20:02:01 +09002086
Daniel Norman85aed542019-08-21 12:01:14 -07002087TEST_F(AidlTestCompatibleChanges, ArgNameChange) {
2088 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2089 "package p;"
2090 "interface IFoo {"
2091 " void foo(int a);"
2092 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002093 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2094 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002095 "interface IFoo {"
2096 " void foo(int b);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002097 "}");
Daniel Norman85aed542019-08-21 12:01:14 -07002098 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2099}
Jiyong Parke59c3682018-09-11 23:10:25 +09002100
Daniel Norman85aed542019-08-21 12:01:14 -07002101TEST_F(AidlTestCompatibleChanges, AddedConstValue) {
Jiyong Parke59c3682018-09-11 23:10:25 +09002102 io_delegate_.SetFileContents("old/p/I.aidl",
2103 "package p; interface I {"
2104 "const int A = 1; }");
2105 io_delegate_.SetFileContents("new/p/I.aidl",
2106 "package p ; interface I {"
2107 "const int A = 1; const int B = 2;}");
Daniel Norman85aed542019-08-21 12:01:14 -07002108 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2109}
Jiyong Parka428d212018-08-29 22:26:30 +09002110
Daniel Norman85aed542019-08-21 12:01:14 -07002111TEST_F(AidlTestCompatibleChanges, ChangedConstValueOrder) {
Jiyong Parke59c3682018-09-11 23:10:25 +09002112 io_delegate_.SetFileContents("old/p/I.aidl",
2113 "package p; interface I {"
2114 "const int A = 1; const int B = 2;}");
2115 io_delegate_.SetFileContents("new/p/I.aidl",
2116 "package p ; interface I {"
2117 "const int B = 2; const int A = 1;}");
Daniel Norman85aed542019-08-21 12:01:14 -07002118 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
Jiyong Park3656c3c2018-08-01 20:02:01 +09002119}
2120
Jooyung Han69ea4ba2020-10-29 15:33:37 +09002121TEST_F(AidlTestCompatibleChanges, ReorderedAnnatations) {
2122 io_delegate_.SetFileContents("old/p/Foo.aidl",
2123 "package p;"
2124 "@JavaPassthrough(annotation=\"Alice\")"
2125 "@JavaPassthrough(annotation=\"Bob\")"
2126 "parcelable Foo {}");
2127 io_delegate_.SetFileContents("new/p/Foo.aidl",
2128 "package p;"
2129 "@JavaPassthrough(annotation=\"Bob\")"
2130 "@JavaPassthrough(annotation=\"Alice\")"
2131 "parcelable Foo {}");
2132 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2133}
2134
Jooyung Han00073272020-11-27 14:20:20 +09002135TEST_F(AidlTestCompatibleChanges, OkayToDeprecate) {
2136 io_delegate_.SetFileContents("old/p/Foo.aidl",
2137 "package p;"
2138 "parcelable Foo {}");
2139 io_delegate_.SetFileContents("new/p/Foo.aidl",
2140 "package p;"
2141 "@JavaPassthrough(annotation=\"@Deprecated\")"
2142 "parcelable Foo {}");
2143 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2144}
2145
Jooyung Han636fd2f2020-10-22 11:33:45 +09002146TEST_F(AidlTestCompatibleChanges, NewFieldOfNewType) {
2147 io_delegate_.SetFileContents("old/p/Data.aidl",
2148 "package p;"
2149 "parcelable Data {"
2150 " int num;"
2151 "}");
2152 io_delegate_.SetFileContents(
2153 "new/p/Data.aidl",
2154 "package p;"
2155 "parcelable Data {"
2156 " int num;"
2157 " p.Enum e;" // this is considered as valid since 0(enum default) is valid for "Enum" type
2158 "}");
2159 io_delegate_.SetFileContents("new/p/Enum.aidl",
2160 "package p;"
2161 "enum Enum {"
2162 " FOO = 0,"
2163 " BAR = 1,"
2164 "}");
2165 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2166}
2167
Daniel Norman85aed542019-08-21 12:01:14 -07002168class AidlTestIncompatibleChanges : public AidlTest {
2169 protected:
2170 Options options_ = Options::From("aidl --checkapi old new");
2171};
2172
2173TEST_F(AidlTestIncompatibleChanges, RemovedType) {
Jiyong Park0cf03b12020-07-22 19:36:34 +09002174 const string expected_stderr = "ERROR: old/p/IFoo.aidl:1.11-20: Removed type: p.IFoo\n";
Jiyong Parke59c3682018-09-11 23:10:25 +09002175 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2176 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002177 "interface IFoo {"
2178 " void foo(in String[] str);"
2179 " void bar(@utf8InCpp String str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002180 "}");
Devin Moored131d5e2020-03-31 10:39:10 -07002181 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002182 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moored131d5e2020-03-31 10:39:10 -07002183 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002184}
2185
2186TEST_F(AidlTestIncompatibleChanges, RemovedMethod) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002187 const string expected_stderr =
2188 "ERROR: old/p/IFoo.aidl:1.61-65: Removed or changed method: p.IFoo.bar(String)\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002189 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2190 "package p;"
2191 "interface IFoo {"
2192 " void foo(in String[] str);"
2193 " void bar(@utf8InCpp String str);"
2194 "}");
2195 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2196 "package p;"
2197 "interface IFoo {"
2198 " void foo(in String[] str);"
2199 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002200 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002201 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002202 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002203}
2204
Jiyong Parkf8d53612020-05-04 14:06:13 +09002205TEST_F(AidlTestIncompatibleChanges, UntypedListInInterface) {
2206 const string expected_stderr =
2207 "ERROR: new/p/IFoo.aidl:1.61-65: "
2208 "Encountered an untyped List or Map. The use of untyped List/Map is "
2209 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
2210 "the receiving side. Consider switching to an array or a generic List/Map.\n"
2211 "ERROR: new/p/IFoo.aidl: Failed to read.\n";
2212 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2213 "package p;"
2214 "interface IFoo {"
2215 " void foo(in String[] str);"
2216 "}");
2217 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2218 "package p;"
2219 "interface IFoo {"
2220 " void foo(in String[] str);"
2221 " void bar(in List arg);"
2222 "}");
2223 CaptureStderr();
2224 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2225 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2226}
2227
2228TEST_F(AidlTestCompatibleChanges, UntypedListInParcelable) {
2229 const string expected_stderr =
2230 "ERROR: new/p/Data.aidl:1.54-59: "
2231 "Encountered an untyped List or Map. The use of untyped List/Map is "
2232 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
2233 "the receiving side. Consider switching to an array or a generic List/Map.\n"
2234 "ERROR: new/p/Data.aidl: Failed to read.\n";
2235 io_delegate_.SetFileContents("old/p/Data.aidl",
2236 "package p;"
2237 "parcelable Data {"
2238 " int foo;"
2239 "}");
2240 io_delegate_.SetFileContents("new/p/Data.aidl",
2241 "package p;"
2242 "parcelable Data {"
2243 " int foo;"
2244 " @nullable List list;"
2245 "}");
2246 CaptureStderr();
2247 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2248 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2249}
2250
Daniel Norman85aed542019-08-21 12:01:14 -07002251TEST_F(AidlTestIncompatibleChanges, RemovedField) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002252 const string expected_stderr =
2253 "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 +09002254 io_delegate_.SetFileContents("old/p/Data.aidl",
2255 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002256 "parcelable Data {"
2257 " int foo;"
2258 " int bar;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002259 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002260 io_delegate_.SetFileContents("new/p/Data.aidl",
2261 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002262 "parcelable Data {"
2263 " int foo;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002264 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002265 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002266 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002267 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002268}
Jiyong Park3656c3c2018-08-01 20:02:01 +09002269
Jooyung Hanb5c55cd2020-10-22 07:59:01 +09002270TEST_F(AidlTestIncompatibleChanges, NewFieldWithNoDefault) {
2271 const string expected_stderr =
2272 "ERROR: new/p/Data.aidl:1.46-50: Field 'str' does not have a useful default in some "
2273 "backends. Please either provide a default value for this field or mark the field as "
2274 "@nullable. This value or a null value will be used automatically when an old version of "
2275 "this parcelable is sent to a process which understands a new version of this parcelable. In "
2276 "order to make sure your code continues to be backwards compatible, make sure the default or "
2277 "null value does not cause a semantic change to this parcelable.\n";
2278 io_delegate_.SetFileContents("old/p/Data.aidl",
2279 "package p;"
2280 "parcelable Data {"
2281 " int num;"
2282 "}");
2283 io_delegate_.SetFileContents("new/p/Data.aidl",
2284 "package p;"
2285 "parcelable Data {"
2286 " int num;"
2287 " String str;"
2288 "}");
2289 CaptureStderr();
2290 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2291 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2292}
2293
Jooyung Han636fd2f2020-10-22 11:33:45 +09002294TEST_F(AidlTestIncompatibleChanges, NewFieldWithNonZeroEnum) {
2295 const string expected_stderr =
2296 "ERROR: new/p/Data.aidl:1.46-48: Field 'e' of enum 'Enum' can't be initialized as '0'. "
2297 "Please make sure 'Enum' has '0' as a valid value.\n";
2298 io_delegate_.SetFileContents("old/p/Data.aidl",
2299 "package p;"
2300 "parcelable Data {"
2301 " int num;"
2302 "}");
2303 io_delegate_.SetFileContents("new/p/Data.aidl",
2304 "package p;"
2305 "parcelable Data {"
2306 " int num;"
2307 " p.Enum e;"
2308 "}");
2309 io_delegate_.SetFileContents("new/p/Enum.aidl",
2310 "package p;"
2311 "enum Enum {"
2312 " FOO = 1,"
2313 " BAR = 2,"
2314 "}");
2315 CaptureStderr();
2316 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2317 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2318}
2319
Daniel Norman85aed542019-08-21 12:01:14 -07002320TEST_F(AidlTestIncompatibleChanges, RemovedEnumerator) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002321 const string expected_stderr =
2322 "ERROR: new/p/Enum.aidl:1.15-20: Removed enumerator from p.Enum: FOO\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002323 io_delegate_.SetFileContents("old/p/Enum.aidl",
2324 "package p;"
2325 "enum Enum {"
2326 " FOO = 1,"
2327 " BAR = 2,"
2328 "}");
2329 io_delegate_.SetFileContents("new/p/Enum.aidl",
2330 "package p;"
2331 "enum Enum {"
2332 " BAR = 2,"
2333 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002334 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002335 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002336 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002337}
2338
Jooyung Hanb5c55cd2020-10-22 07:59:01 +09002339TEST_F(AidlTestIncompatibleChanges, RemovedUnionField) {
2340 const string expected_stderr =
2341 "ERROR: new/p/Union.aidl:1.16-22: Number of fields in p.Union is reduced from 2 to 1.\n";
2342 io_delegate_.SetFileContents("old/p/Union.aidl",
2343 "package p;"
2344 "union Union {"
2345 " String str;"
2346 " int num;"
2347 "}");
2348 io_delegate_.SetFileContents("new/p/Union.aidl",
2349 "package p;"
2350 "union Union {"
2351 " String str;"
2352 "}");
2353 CaptureStderr();
2354 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2355 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2356}
2357
Daniel Norman85aed542019-08-21 12:01:14 -07002358TEST_F(AidlTestIncompatibleChanges, RenamedMethod) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002359 const string expected_stderr =
2360 "ERROR: old/p/IFoo.aidl:1.61-65: Removed or changed method: p.IFoo.bar(String)\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002361 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2362 "package p;"
2363 "interface IFoo {"
2364 " void foo(in String[] str);"
2365 " void bar(@utf8InCpp String str);"
2366 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002367 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2368 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002369 "interface IFoo {"
2370 " void foo(in String[] str);"
2371 " void bar2(@utf8InCpp String str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002372 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002373 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002374 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002375 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002376}
2377
Daniel Norman85aed542019-08-21 12:01:14 -07002378TEST_F(AidlTestIncompatibleChanges, RenamedType) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002379 const string expected_stderr = "ERROR: old/p/IFoo.aidl:1.11-20: Removed type: p.IFoo\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002380 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2381 "package p;"
2382 "interface IFoo {"
2383 " void foo(in String[] str);"
2384 " void bar(@utf8InCpp String str);"
2385 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002386 io_delegate_.SetFileContents("new/p/IFoo2.aidl",
2387 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002388 "interface IFoo2 {"
2389 " void foo(in String[] str);"
2390 " void bar(@utf8InCpp String str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002391 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002392 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002393 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002394 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002395}
Jiyong Park3656c3c2018-08-01 20:02:01 +09002396
Daniel Norman85aed542019-08-21 12:01:14 -07002397TEST_F(AidlTestIncompatibleChanges, ChangedEnumerator) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002398 const string expected_stderr =
2399 "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 -07002400 io_delegate_.SetFileContents("old/p/Enum.aidl",
2401 "package p;"
2402 "enum Enum {"
2403 " FOO = 1,"
2404 " BAR = 2,"
2405 "}");
2406 io_delegate_.SetFileContents("new/p/Enum.aidl",
2407 "package p;"
2408 "enum Enum {"
2409 " FOO = 3,"
2410 " BAR = 2,"
2411 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002412 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002413 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002414 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002415}
2416
2417TEST_F(AidlTestIncompatibleChanges, ReorderedMethod) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002418 const string expected_stderr =
2419 "ERROR: new/p/IFoo.aidl:1.67-71: Transaction ID changed: p.IFoo.foo(String[]) is changed "
2420 "from 0 to 1.\n"
2421 "ERROR: new/p/IFoo.aidl:1.33-37: Transaction ID changed: p.IFoo.bar(String) is changed from "
2422 "1 to 0.\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002423 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2424 "package p;"
2425 "interface IFoo {"
2426 " void foo(in String[] str);"
2427 " void bar(@utf8InCpp String str);"
2428 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002429 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2430 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002431 "interface IFoo {"
2432 " void bar(@utf8InCpp String str);"
2433 " void foo(in String[] str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002434 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002435 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002436 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002437 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002438}
2439
2440TEST_F(AidlTestIncompatibleChanges, ReorderedField) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002441 const string expected_stderr =
Jiyong Parkb07d9932020-05-15 12:56:54 +09002442 "ERROR: new/p/Data.aidl:1.33-37: Reordered bar from 1 to 0.\n"
2443 "ERROR: new/p/Data.aidl:1.43-47: Reordered foo from 0 to 1.\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002444 io_delegate_.SetFileContents("old/p/Data.aidl",
Jiyong Parke59c3682018-09-11 23:10:25 +09002445 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002446 "parcelable Data {"
2447 " int foo;"
2448 " int bar;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002449 "}");
Daniel Norman85aed542019-08-21 12:01:14 -07002450 io_delegate_.SetFileContents("new/p/Data.aidl",
2451 "package p;"
2452 "parcelable Data {"
2453 " int bar;"
2454 " int foo;"
2455 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002456 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002457 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002458 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002459}
Jiyong Park3656c3c2018-08-01 20:02:01 +09002460
Daniel Norman85aed542019-08-21 12:01:14 -07002461TEST_F(AidlTestIncompatibleChanges, ChangedDirectionSpecifier) {
Devin Mooreeccdb902020-03-24 16:22:40 -07002462 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 -07002463 io_delegate_.SetFileContents("old/p/IFoo.aidl",
Jiyong Parke59c3682018-09-11 23:10:25 +09002464 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002465 "interface IFoo {"
2466 " void foo(in String[] str);"
2467 " void bar(@utf8InCpp String str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002468 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002469 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2470 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002471 "interface IFoo {"
2472 " void foo(out String[] str);"
2473 " void bar(@utf8InCpp String str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002474 "}");
Devin Mooreeccdb902020-03-24 16:22:40 -07002475 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002476 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Mooreeccdb902020-03-24 16:22:40 -07002477 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002478}
Jiyong Park3656c3c2018-08-01 20:02:01 +09002479
Daniel Norman85aed542019-08-21 12:01:14 -07002480TEST_F(AidlTestIncompatibleChanges, AddedAnnotation) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002481 const string expected_stderr =
2482 "ERROR: new/p/IFoo.aidl:1.51-58: Changed annotations: (empty) to @utf8InCpp\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002483 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2484 "package p;"
2485 "interface IFoo {"
2486 " void foo(in String[] str);"
2487 " void bar(@utf8InCpp String str);"
2488 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002489 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2490 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002491 "interface IFoo {"
Jiyong Parke59c3682018-09-11 23:10:25 +09002492 " void foo(in @utf8InCpp String[] str);"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002493 " void bar(@utf8InCpp String str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002494 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002495 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002496 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002497 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002498}
Jiyong Park3656c3c2018-08-01 20:02:01 +09002499
Daniel Norman85aed542019-08-21 12:01:14 -07002500TEST_F(AidlTestIncompatibleChanges, RemovedAnnotation) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002501 const string expected_stderr =
2502 "ERROR: new/p/IFoo.aidl:1.66-72: Changed annotations: @utf8InCpp to (empty)\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002503 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2504 "package p;"
2505 "interface IFoo {"
2506 " void foo(in String[] str);"
2507 " void bar(@utf8InCpp String str);"
2508 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002509 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2510 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002511 "interface IFoo {"
Jiyong Parke59c3682018-09-11 23:10:25 +09002512 " void foo(in String[] str);"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002513 " void bar(String str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002514 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002515 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002516 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002517 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002518}
Jiyong Park3656c3c2018-08-01 20:02:01 +09002519
Jooyung Han60b2fde2020-10-29 15:12:40 +09002520TEST_F(AidlTestIncompatibleChanges, ChangedBackingTypeOfEnum) {
2521 const string expected_stderr =
2522 "ERROR: new/p/Foo.aidl:1.11-32: Type changed: byte to long.\n"
2523 "ERROR: new/p/Foo.aidl:1.36-40: Changed backing types.\n";
2524 io_delegate_.SetFileContents("old/p/Foo.aidl",
2525 "package p;"
2526 "@Backing(type=\"byte\")"
2527 "enum Foo {"
2528 " FOO, BAR,"
2529 "}");
2530 io_delegate_.SetFileContents("new/p/Foo.aidl",
2531 "package p;"
2532 "@Backing(type=\"long\")"
2533 "enum Foo {"
2534 " FOO, BAR,"
2535 "}");
2536 CaptureStderr();
2537 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2538 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2539}
2540
Jooyung Han69ea4ba2020-10-29 15:33:37 +09002541TEST_F(AidlTestIncompatibleChanges, ChangedAnnatationParams) {
2542 const string expected_stderr =
2543 "ERROR: new/p/Foo.aidl:1.55-59: Changed annotations: @JavaPassthrough(annotation=\"Alice\") "
2544 "to @JavaPassthrough(annotation=\"Bob\")\n";
2545 io_delegate_.SetFileContents("old/p/Foo.aidl",
2546 "package p;"
2547 "@JavaPassthrough(annotation=\"Alice\")"
2548 "parcelable Foo {}");
2549 io_delegate_.SetFileContents("new/p/Foo.aidl",
2550 "package p;"
2551 "@JavaPassthrough(annotation=\"Bob\")"
2552 "parcelable Foo {}");
2553
2554 CaptureStderr();
2555 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2556 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2557}
2558
Devin Mooredb7ac512020-08-07 11:17:36 -07002559TEST_F(AidlTestIncompatibleChanges, AddedParcelableAnnotation) {
2560 const string expected_stderr =
Jooyung Han2d6b5c42021-01-09 01:01:06 +09002561 "ERROR: new/p/Foo.aidl:1.32-36: Changed annotations: (empty) to @FixedSize\n";
Devin Mooredb7ac512020-08-07 11:17:36 -07002562 io_delegate_.SetFileContents("old/p/Foo.aidl",
2563 "package p;"
2564 "parcelable Foo {"
2565 " int A;"
2566 "}");
2567 io_delegate_.SetFileContents("new/p/Foo.aidl",
2568 "package p;"
Jooyung Han2d6b5c42021-01-09 01:01:06 +09002569 "@FixedSize parcelable Foo {"
Devin Mooredb7ac512020-08-07 11:17:36 -07002570 " int A;"
2571 "}");
2572 CaptureStderr();
2573 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2574 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2575}
2576
2577TEST_F(AidlTestIncompatibleChanges, RemovedParcelableAnnotation) {
2578 const string expected_stderr =
Jooyung Han2d6b5c42021-01-09 01:01:06 +09002579 "ERROR: new/p/Foo.aidl:1.21-25: Changed annotations: @FixedSize to (empty)\n";
Devin Mooredb7ac512020-08-07 11:17:36 -07002580 io_delegate_.SetFileContents("old/p/Foo.aidl",
2581 "package p;"
Jooyung Han2d6b5c42021-01-09 01:01:06 +09002582 "@FixedSize parcelable Foo {"
Devin Mooredb7ac512020-08-07 11:17:36 -07002583 " int A;"
2584 "}");
2585 io_delegate_.SetFileContents("new/p/Foo.aidl",
2586 "package p;"
2587 "parcelable Foo {"
2588 " int A;"
2589 "}");
2590 CaptureStderr();
2591 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2592 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2593}
2594
Daniel Norman85aed542019-08-21 12:01:14 -07002595TEST_F(AidlTestIncompatibleChanges, RemovedPackage) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002596 const string expected_stderr = "ERROR: old/q/IFoo.aidl:1.11-21: Removed type: q.IFoo\n";
Jiyong Parke59c3682018-09-11 23:10:25 +09002597 io_delegate_.SetFileContents("old/p/IFoo.aidl", "package p; interface IFoo{}");
2598 io_delegate_.SetFileContents("old/q/IFoo.aidl", "package q; interface IFoo{}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002599 io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p; interface IFoo{}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002600 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002601 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002602 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002603}
Jiyong Parka468e2a2018-08-29 21:25:18 +09002604
Daniel Norman85aed542019-08-21 12:01:14 -07002605TEST_F(AidlTestIncompatibleChanges, ChangedDefaultValue) {
Steven Moreland370ed342020-04-28 18:14:39 -07002606 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 +09002607 io_delegate_.SetFileContents("old/p/D.aidl", "package p; parcelable D { int a = 1; }");
2608 io_delegate_.SetFileContents("new/p/D.aidl", "package p; parcelable D { int a = 2; }");
Devin Moore097a3ab2020-03-11 16:08:44 -07002609 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002610 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002611 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002612}
Jiyong Parka428d212018-08-29 22:26:30 +09002613
Daniel Norman85aed542019-08-21 12:01:14 -07002614TEST_F(AidlTestIncompatibleChanges, RemovedConstValue) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002615 const string expected_stderr =
2616 "ERROR: old/p/I.aidl:1.51-53: Removed constant declaration: p.I.B\n";
Jiyong Parke59c3682018-09-11 23:10:25 +09002617 io_delegate_.SetFileContents("old/p/I.aidl",
2618 "package p; interface I {"
2619 "const int A = 1; const int B = 2;}");
2620 io_delegate_.SetFileContents("new/p/I.aidl", "package p; interface I { const int A = 1; }");
Devin Moore097a3ab2020-03-11 16:08:44 -07002621 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002622 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002623 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002624}
Jiyong Parka428d212018-08-29 22:26:30 +09002625
Daniel Norman85aed542019-08-21 12:01:14 -07002626TEST_F(AidlTestIncompatibleChanges, ChangedConstValue) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002627 const string expected_stderr =
2628 "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 +09002629 io_delegate_.SetFileContents("old/p/I.aidl", "package p; interface I { const int A = 1; }");
2630 io_delegate_.SetFileContents("new/p/I.aidl", "package p; interface I { const int A = 2; }");
Devin Moore097a3ab2020-03-11 16:08:44 -07002631 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002632 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002633 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Park3c35e392018-08-30 13:10:30 +09002634}
2635
Devin Moorec7e47a32020-08-07 10:55:25 -07002636TEST_F(AidlTestIncompatibleChanges, FixedSizeAddedField) {
2637 const string expected_stderr =
2638 "ERROR: new/p/Foo.aidl:1.33-37: Number of fields in p.Foo is changed from 1 to 2. "
2639 "This is an incompatible change for FixedSize types.\n";
2640 io_delegate_.SetFileContents("old/p/Foo.aidl",
2641 "package p; @FixedSize parcelable Foo { int A = 1; }");
2642 io_delegate_.SetFileContents("new/p/Foo.aidl",
2643 "package p; @FixedSize parcelable Foo { int A = 1; int B = 2; }");
2644 CaptureStderr();
2645 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2646 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2647}
2648
2649TEST_F(AidlTestIncompatibleChanges, FixedSizeRemovedField) {
2650 const string expected_stderr =
2651 "ERROR: new/p/Foo.aidl:1.33-37: Number of fields in p.Foo is reduced from 2 to 1.\n";
2652 io_delegate_.SetFileContents("old/p/Foo.aidl",
2653 "package p; @FixedSize parcelable Foo { int A = 1; int B = 1; }");
2654 io_delegate_.SetFileContents("new/p/Foo.aidl",
2655 "package p; @FixedSize parcelable Foo { int A = 1; }");
2656 CaptureStderr();
2657 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2658 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2659}
2660
2661TEST_P(AidlTest, RejectNonFixedSizeFromFixedSize) {
2662 const string expected_stderr =
2663 "ERROR: Foo.aidl:1.36-38: The @FixedSize parcelable 'Foo' has a non-fixed size field named "
2664 "a.\n"
2665 "ERROR: Foo.aidl:1.44-46: The @FixedSize parcelable 'Foo' has a non-fixed size field named "
2666 "b.\n"
2667 "ERROR: Foo.aidl:1.55-57: The @FixedSize parcelable 'Foo' has a non-fixed size field named "
2668 "c.\n"
2669 "ERROR: Foo.aidl:1.80-82: The @FixedSize parcelable 'Foo' has a non-fixed size field named "
2670 "d.\n"
2671 "ERROR: Foo.aidl:1.92-94: The @FixedSize parcelable 'Foo' has a non-fixed size field named "
2672 "e.\n"
2673 "ERROR: Foo.aidl:1.109-111: The @FixedSize parcelable 'Foo' has a non-fixed size field named "
2674 "f.\n";
2675
2676 io_delegate_.SetFileContents("Foo.aidl",
2677 "@FixedSize parcelable Foo { "
2678 " int[] a;"
2679 " Bar b;"
2680 " String c;"
2681 " ParcelFileDescriptor d;"
2682 " IBinder e;"
2683 " List<String> f;"
Steven Moreland265f3d42020-09-24 19:06:54 +00002684 " int isFixedSize;"
Devin Moorec7e47a32020-08-07 10:55:25 -07002685 "}");
2686 io_delegate_.SetFileContents("Bar.aidl", "parcelable Bar { int a; }");
Jooyung Han9435e9a2021-01-06 10:16:31 +09002687 Options options = Options::From("aidl Foo.aidl -I . --lang=" + to_string(GetLanguage()));
Devin Moorec7e47a32020-08-07 10:55:25 -07002688
2689 CaptureStderr();
2690 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
2691 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2692}
2693
2694TEST_P(AidlTest, AcceptFixedSizeFromFixedSize) {
2695 const string expected_stderr = "";
2696
2697 io_delegate_.SetFileContents("Foo.aidl", "@FixedSize parcelable Foo { int a; Bar b; }");
2698 io_delegate_.SetFileContents("Bar.aidl", "@FixedSize parcelable Bar { Val c; }");
2699 io_delegate_.SetFileContents("Val.aidl", "enum Val { A, B, }");
Jooyung Han9435e9a2021-01-06 10:16:31 +09002700 Options options = Options::From("aidl Foo.aidl -I . --lang=" + to_string(GetLanguage()));
Devin Moorec7e47a32020-08-07 10:55:25 -07002701
2702 CaptureStderr();
2703 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
2704 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2705}
2706
Jiyong Park8c380532018-08-30 14:55:26 +09002707TEST_F(AidlTest, RejectAmbiguousImports) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002708 const string expected_stderr =
2709 "ERROR: p/IFoo.aidl: Duplicate files found for q.IBar from:\n"
2710 "dir1/q/IBar.aidl\n"
2711 "dir2/q/IBar.aidl\n"
Devin Moore5de18ed2020-04-02 13:52:29 -07002712 "ERROR: p/IFoo.aidl: Couldn't find import for class q.IBar\n";
Jiyong Park8c380532018-08-30 14:55:26 +09002713 Options options = Options::From("aidl --lang=java -o out -I dir1 -I dir2 p/IFoo.aidl");
2714 io_delegate_.SetFileContents("p/IFoo.aidl", "package p; import q.IBar; interface IFoo{}");
2715 io_delegate_.SetFileContents("dir1/q/IBar.aidl", "package q; interface IBar{}");
2716 io_delegate_.SetFileContents("dir2/q/IBar.aidl", "package q; interface IBar{}");
2717
Devin Moore097a3ab2020-03-11 16:08:44 -07002718 CaptureStderr();
Jiyong Park8c380532018-08-30 14:55:26 +09002719 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002720 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Park8c380532018-08-30 14:55:26 +09002721}
2722
Jiyong Parked65bf42018-08-28 15:43:27 +09002723TEST_F(AidlTest, HandleManualIdAssignments) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002724 const string expected_stderr =
2725 "ERROR: new/p/IFoo.aidl:1.32-36: Transaction ID changed: p.IFoo.foo() is changed from 10 to "
2726 "11.\n";
Jiyong Parke59c3682018-09-11 23:10:25 +09002727 Options options = Options::From("aidl --checkapi old new");
2728 io_delegate_.SetFileContents("old/p/IFoo.aidl", "package p; interface IFoo{ void foo() = 10;}");
2729 io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p; interface IFoo{ void foo() = 10;}");
Jiyong Parked65bf42018-08-28 15:43:27 +09002730
2731 EXPECT_TRUE(::android::aidl::check_api(options, io_delegate_));
2732
Jiyong Parke59c3682018-09-11 23:10:25 +09002733 io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p; interface IFoo{ void foo() = 11;}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002734 CaptureStderr();
Jiyong Parked65bf42018-08-28 15:43:27 +09002735 EXPECT_FALSE(::android::aidl::check_api(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002736 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Parked65bf42018-08-28 15:43:27 +09002737}
2738
Jooyung Han652ce482021-02-26 12:40:35 +09002739TEST_P(AidlTest, ParcelFileDescriptorIsBuiltinType) {
2740 Options options =
2741 Options::From("aidl --lang=" + to_string(GetLanguage()) + " -h out -o out p/IFoo.aidl");
Jiyong Parke05195e2018-10-08 18:24:23 +09002742
2743 // use without import
2744 io_delegate_.SetFileContents("p/IFoo.aidl",
2745 "package p; interface IFoo{ void foo(in ParcelFileDescriptor fd);}");
Jooyung Han652ce482021-02-26 12:40:35 +09002746 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
2747
2748 // capture output files
2749 map<string, string> outputs = io_delegate_.OutputFiles();
Jiyong Parke05195e2018-10-08 18:24:23 +09002750
Devin Moore7b8d5c92020-03-17 14:14:08 -07002751 // use without import but with full name
Jiyong Parke05195e2018-10-08 18:24:23 +09002752 io_delegate_.SetFileContents(
2753 "p/IFoo.aidl",
2754 "package p; interface IFoo{ void foo(in android.os.ParcelFileDescriptor fd);}");
Jooyung Han652ce482021-02-26 12:40:35 +09002755 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
2756 // output files should be the same
2757 EXPECT_EQ(outputs, io_delegate_.OutputFiles());
Jiyong Parke05195e2018-10-08 18:24:23 +09002758
2759 // use with import (as before)
2760 io_delegate_.SetFileContents("p/IFoo.aidl",
2761 "package p;"
2762 "import android.os.ParcelFileDescriptor;"
2763 "interface IFoo{"
2764 " void foo(in ParcelFileDescriptor fd);"
2765 "}");
Jooyung Han652ce482021-02-26 12:40:35 +09002766 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
2767 // output files should be the same
2768 EXPECT_EQ(outputs, io_delegate_.OutputFiles());
Jiyong Parke05195e2018-10-08 18:24:23 +09002769}
Jiyong Parked65bf42018-08-28 15:43:27 +09002770
Jooyung Han020d8d12021-02-26 17:23:02 +09002771TEST_P(AidlTest, RejectsOutputParcelFileDescriptor) {
2772 Options options = Options::From("aidl p/IFoo.aidl -I . --lang=" + to_string(GetLanguage()));
2773 CaptureStderr();
2774 io_delegate_.SetFileContents("p/IFoo.aidl",
2775 "package p;"
2776 "interface IFoo{"
2777 " void foo(out ParcelFileDescriptor fd);"
2778 "}");
2779 EXPECT_EQ(1, ::android::aidl::compile_aidl(options, io_delegate_));
2780 EXPECT_THAT(GetCapturedStderr(), HasSubstr("can't be an out parameter"));
2781}
2782
2783TEST_P(AidlTest, RejectsArgumentDirectionNotSpecified) {
2784 Options options = Options::From("aidl p/IFoo.aidl -I . --lang=" + to_string(GetLanguage()));
2785 CaptureStderr();
2786 io_delegate_.SetFileContents("p/IFoo.aidl",
2787 "package p;"
2788 "interface IFoo{"
2789 " void foo(ParcelFileDescriptor fd);"
2790 "}");
2791 EXPECT_EQ(1, ::android::aidl::compile_aidl(options, io_delegate_));
2792 EXPECT_THAT(GetCapturedStderr(),
2793 HasSubstr("ParcelFileDescriptor can be an in or inout parameter."));
2794}
2795
Jiyong Park3633b722019-04-11 15:38:26 +09002796TEST_F(AidlTest, ManualIds) {
2797 Options options = Options::From("aidl --lang=java -o out IFoo.aidl");
2798 io_delegate_.SetFileContents("IFoo.aidl",
2799 "interface IFoo {\n"
2800 " void foo() = 0;\n"
2801 " void bar() = 1;\n"
2802 "}");
2803 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
2804}
2805
2806TEST_F(AidlTest, ManualIdsWithMetaTransactions) {
2807 Options options = Options::From("aidl --lang=java --version 10 -o out IFoo.aidl");
2808 io_delegate_.SetFileContents("IFoo.aidl",
2809 "interface IFoo {\n"
2810 " void foo() = 0;\n"
2811 " void bar() = 1;\n"
2812 "}");
2813 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
2814}
2815
2816TEST_F(AidlTest, FailOnDuplicatedIds) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002817 const string expected_stderr =
2818 "ERROR: IFoo.aidl:3.7-11: Found duplicate method id (3) for method bar\n";
Jiyong Park3633b722019-04-11 15:38:26 +09002819 Options options = Options::From("aidl --lang=java --version 10 -o out IFoo.aidl");
2820 io_delegate_.SetFileContents("IFoo.aidl",
2821 "interface IFoo {\n"
2822 " void foo() = 3;\n"
2823 " void bar() = 3;\n"
2824 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002825 CaptureStderr();
Jiyong Park3633b722019-04-11 15:38:26 +09002826 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002827 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Park3633b722019-04-11 15:38:26 +09002828}
2829
2830TEST_F(AidlTest, FailOnOutOfRangeIds) {
2831 // 16777115 is kLastMetaMethodId + 1
Devin Moore097a3ab2020-03-11 16:08:44 -07002832 const string expected_stderr =
2833 "ERROR: IFoo.aidl:3.7-11: Found out of bounds id (16777115) for method bar. "
2834 "Value for id must be between 0 and 16777114 inclusive.\n";
Jiyong Park3633b722019-04-11 15:38:26 +09002835 Options options = Options::From("aidl --lang=java --version 10 -o out IFoo.aidl");
2836 io_delegate_.SetFileContents("IFoo.aidl",
2837 "interface IFoo {\n"
2838 " void foo() = 3;\n"
2839 " void bar() = 16777115;\n"
2840 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002841 CaptureStderr();
Jiyong Park3633b722019-04-11 15:38:26 +09002842 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002843 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Park3633b722019-04-11 15:38:26 +09002844}
2845
2846TEST_F(AidlTest, FailOnPartiallyAssignedIds) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002847 const string expected_stderr =
2848 "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 +09002849 Options options = Options::From("aidl --lang=java --version 10 -o out IFoo.aidl");
2850 io_delegate_.SetFileContents("IFoo.aidl",
2851 "interface IFoo {\n"
2852 " void foo() = 3;\n"
2853 " void bar();\n"
2854 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002855 CaptureStderr();
Jiyong Park3633b722019-04-11 15:38:26 +09002856 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002857 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Park3633b722019-04-11 15:38:26 +09002858}
2859
Jiyong Parkc6816252019-07-08 08:12:28 +09002860TEST_F(AidlTest, AllowDuplicatedImportPaths) {
2861 Options options = Options::From("aidl --lang=java -I dir -I dir IFoo.aidl");
2862 io_delegate_.SetFileContents("dir/IBar.aidl", "interface IBar{}");
2863 io_delegate_.SetFileContents("IFoo.aidl", "import IBar; interface IFoo{}");
2864 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
2865}
2866
2867TEST_F(AidlTest, FailOnAmbiguousImports) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002868 const string expected_stderr =
2869 "ERROR: IFoo.aidl: Duplicate files found for IBar from:\n"
2870 "dir/IBar.aidl\n"
2871 "dir2/IBar.aidl\n"
Devin Moore5de18ed2020-04-02 13:52:29 -07002872 "ERROR: IFoo.aidl: Couldn't find import for class IBar\n";
Devin Moore097a3ab2020-03-11 16:08:44 -07002873
Jiyong Parkc6816252019-07-08 08:12:28 +09002874 Options options = Options::From("aidl --lang=java -I dir -I dir2 IFoo.aidl");
2875 io_delegate_.SetFileContents("dir/IBar.aidl", "interface IBar{}");
2876 io_delegate_.SetFileContents("dir2/IBar.aidl", "interface IBar{}");
2877 io_delegate_.SetFileContents("IFoo.aidl", "import IBar; interface IFoo{}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002878 CaptureStderr();
Jiyong Parkc6816252019-07-08 08:12:28 +09002879 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002880 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Parkc6816252019-07-08 08:12:28 +09002881}
2882
Jiyong Parkf1f5c802020-05-19 17:33:00 +09002883TEST_F(AidlTest, UnusedImportDoesNotContributeInclude) {
2884 io_delegate_.SetFileContents("a/b/IFoo.aidl",
2885 "package a.b;\n"
2886 "import a.b.IBar;\n"
2887 "import a.b.IQux;\n"
2888 "interface IFoo { IQux foo(); }\n");
2889 io_delegate_.SetFileContents("a/b/IBar.aidl", "package a.b; interface IBar { void foo(); }");
2890 io_delegate_.SetFileContents("a/b/IQux.aidl", "package a.b; interface IQux { void foo(); }");
2891
2892 Options options = Options::From("aidl --lang=ndk a/b/IFoo.aidl -I . -o out -h out/include");
2893 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
2894
2895 string output;
2896 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/include/aidl/a/b/IFoo.h", &output));
2897 // IBar was imported but wasn't used. include is not expected.
2898 EXPECT_THAT(output, Not(testing::HasSubstr("#include <aidl/a/b/IBar.h>")));
2899 // IBar was imported and used. include is expected.
2900 EXPECT_THAT(output, (testing::HasSubstr("#include <aidl/a/b/IQux.h>")));
2901}
2902
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09002903TEST_F(AidlTest, ParseJavaPassthroughAnnotation) {
Jooyung Hane6bc5e12020-10-13 10:57:10 +09002904 io_delegate_.SetFileContents("a/IFoo.aidl", R"--(package a;
Jooyung Han4cde01d2020-10-13 11:10:47 +09002905 import a.MyEnum;
Jooyung Hane6bc5e12020-10-13 10:57:10 +09002906 @JavaPassthrough(annotation="@com.android.Alice(arg=com.android.Alice.Value.A)")
2907 @JavaPassthrough(annotation="@com.android.AliceTwo")
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09002908 interface IFoo {
2909 @JavaPassthrough(annotation="@com.android.Bob")
Jooyung Han4cde01d2020-10-13 11:10:47 +09002910 void foo(@JavaPassthrough(annotation="@com.android.Cat") int x, MyEnum y);
Jiyong Park7c3b0e42020-08-04 16:08:32 +09002911 const @JavaPassthrough(annotation="@com.android.David") int A = 3;
Jooyung Hane6bc5e12020-10-13 10:57:10 +09002912 })--");
Jooyung Han4cde01d2020-10-13 11:10:47 +09002913 // JavaPassthrough should work with other types as well (e.g. enum)
2914 io_delegate_.SetFileContents("a/MyEnum.aidl", R"--(package a;
2915 @JavaPassthrough(annotation="@com.android.Alice(arg=com.android.Alice.Value.A)")
2916 @JavaPassthrough(annotation="@com.android.AliceTwo")
2917 @Backing(type="byte")
2918 enum MyEnum {
2919 a, b, c
2920 })--");
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09002921
Jooyung Han4cde01d2020-10-13 11:10:47 +09002922 Options java_options = Options::From("aidl -I . --lang=java -o out a/IFoo.aidl a/MyEnum.aidl");
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09002923 EXPECT_EQ(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
2924
2925 string java_out;
2926 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/IFoo.java", &java_out));
Jooyung Hane6bc5e12020-10-13 10:57:10 +09002927 // type-decl-level annotations with newline at the end
2928 EXPECT_THAT(java_out, testing::HasSubstr("@com.android.Alice(arg=com.android.Alice.Value.A)\n"));
2929 EXPECT_THAT(java_out, testing::HasSubstr("@com.android.AliceTwo\n"));
2930 // member-decl-level annotations with newline at the end
2931 EXPECT_THAT(java_out, testing::HasSubstr("@com.android.Bob\n"));
2932 EXPECT_THAT(java_out, testing::HasSubstr("@com.android.David\n"));
2933 // inline annotations with space at the end
2934 EXPECT_THAT(java_out, testing::HasSubstr("@com.android.Cat "));
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09002935
Jooyung Han4cde01d2020-10-13 11:10:47 +09002936 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/MyEnum.java", &java_out));
2937 // type-decl-level annotations with newline at the end
2938 EXPECT_THAT(java_out, testing::HasSubstr("@com.android.Alice(arg=com.android.Alice.Value.A)\n"));
2939 EXPECT_THAT(java_out, testing::HasSubstr("@com.android.AliceTwo\n"));
2940
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09002941 // Other backends shouldn't be bothered
Jooyung Han4cde01d2020-10-13 11:10:47 +09002942 Options cpp_options =
2943 Options::From("aidl -I . --lang=cpp -o out -h out a/IFoo.aidl a/MyEnum.aidl");
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09002944 EXPECT_EQ(0, ::android::aidl::compile_aidl(cpp_options, io_delegate_));
2945
Jooyung Han4cde01d2020-10-13 11:10:47 +09002946 Options ndk_options =
2947 Options::From("aidl -I . --lang=ndk -o out -h out a/IFoo.aidl a/MyEnum.aidl");
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09002948 EXPECT_EQ(0, ::android::aidl::compile_aidl(ndk_options, io_delegate_));
Andrei Homescub62afd92020-05-11 19:24:59 -07002949
Jooyung Han4cde01d2020-10-13 11:10:47 +09002950 Options rust_options = Options::From("aidl -I . --lang=rust -o out a/IFoo.aidl a/MyEnum.aidl");
Andrei Homescub62afd92020-05-11 19:24:59 -07002951 EXPECT_EQ(0, ::android::aidl::compile_aidl(rust_options, io_delegate_));
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09002952}
2953
Andrei Homescue61feb52020-08-18 15:44:24 -07002954TEST_F(AidlTest, ParseRustDerive) {
2955 io_delegate_.SetFileContents("a/Foo.aidl", R"(package a;
2956 @RustDerive(Clone=true, Copy=false)
2957 parcelable Foo {
2958 int a;
2959 })");
2960
2961 Options rust_options = Options::From("aidl --lang=rust -o out a/Foo.aidl");
2962 EXPECT_EQ(0, ::android::aidl::compile_aidl(rust_options, io_delegate_));
2963
2964 string rust_out;
2965 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/Foo.rs", &rust_out));
2966 EXPECT_THAT(rust_out, testing::HasSubstr("#[derive(Debug, Clone)]"));
2967
2968 // Other backends shouldn't be bothered
2969 Options cpp_options = Options::From("aidl --lang=cpp -o out -h out a/Foo.aidl");
2970 EXPECT_EQ(0, ::android::aidl::compile_aidl(cpp_options, io_delegate_));
2971
2972 Options ndk_options = Options::From("aidl --lang=ndk -o out -h out a/Foo.aidl");
2973 EXPECT_EQ(0, ::android::aidl::compile_aidl(ndk_options, io_delegate_));
2974
2975 Options java_options = Options::From("aidl --lang=java -o out a/Foo.aidl");
2976 EXPECT_EQ(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
2977}
2978
Jiyong Park56f73d72019-06-11 12:20:28 +09002979class AidlOutputPathTest : public AidlTest {
2980 protected:
2981 void SetUp() override {
2982 AidlTest::SetUp();
2983 io_delegate_.SetFileContents("sub/dir/foo/bar/IFoo.aidl", "package foo.bar; interface IFoo {}");
2984 }
2985
2986 void Test(const Options& options, const std::string expected_output_path) {
2987 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
2988 // check the existence
2989 EXPECT_TRUE(io_delegate_.GetWrittenContents(expected_output_path, nullptr));
2990 }
2991};
2992
2993TEST_F(AidlOutputPathTest, OutDirWithNoOutputFile) {
2994 // <out_dir> / <package_name> / <type_name>.java
2995 Test(Options::From("aidl -o out sub/dir/foo/bar/IFoo.aidl"), "out/foo/bar/IFoo.java");
2996}
2997
2998TEST_F(AidlOutputPathTest, OutDirWithOutputFile) {
2999 // when output file is explicitly set, it is always respected. -o option is
3000 // ignored.
3001 Test(Options::From("aidl -o out sub/dir/foo/bar/IFoo.aidl output/IFoo.java"), "output/IFoo.java");
3002}
3003
3004TEST_F(AidlOutputPathTest, NoOutDirWithOutputFile) {
3005 Test(Options::From("aidl -o out sub/dir/foo/bar/IFoo.aidl output/IFoo.java"), "output/IFoo.java");
3006}
3007
3008TEST_F(AidlOutputPathTest, NoOutDirWithNoOutputFile) {
3009 // output is the same as the input file except for the suffix
3010 Test(Options::From("aidl sub/dir/foo/bar/IFoo.aidl"), "sub/dir/foo/bar/IFoo.java");
3011}
3012
Devin Moore7b8d5c92020-03-17 14:14:08 -07003013TEST_P(AidlTest, FailOnOutOfBoundsInt32MaxConstInt) {
Devin Moore097a3ab2020-03-11 16:08:44 -07003014 AidlError error;
3015 const string expected_stderr =
3016 "ERROR: p/IFoo.aidl:3.58-69: Invalid type specifier for an int64 literal: int\n";
3017 CaptureStderr();
Will McVickera4e5b132019-10-03 13:52:21 -07003018 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl",
3019 R"(package p;
3020 interface IFoo {
3021 const int int32_max_oob = 2147483650;
3022 }
3023 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -07003024 typenames_, GetLanguage(), &error));
Devin Moore097a3ab2020-03-11 16:08:44 -07003025 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3026 EXPECT_EQ(AidlError::BAD_TYPE, error);
Will McVickera4e5b132019-10-03 13:52:21 -07003027}
3028
Devin Moore7b8d5c92020-03-17 14:14:08 -07003029TEST_P(AidlTest, FailOnOutOfBoundsInt32MinConstInt) {
Devin Moore097a3ab2020-03-11 16:08:44 -07003030 AidlError error;
3031 const string expected_stderr =
3032 "ERROR: p/IFoo.aidl:3.58-60: Invalid type specifier for an int64 literal: int\n";
3033 CaptureStderr();
Will McVickera4e5b132019-10-03 13:52:21 -07003034 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl",
3035 R"(package p;
3036 interface IFoo {
3037 const int int32_min_oob = -2147483650;
3038 }
3039 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -07003040 typenames_, GetLanguage(), &error));
Devin Moore097a3ab2020-03-11 16:08:44 -07003041 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3042 EXPECT_EQ(AidlError::BAD_TYPE, error);
Will McVickera4e5b132019-10-03 13:52:21 -07003043}
3044
Devin Moore7b8d5c92020-03-17 14:14:08 -07003045TEST_P(AidlTest, FailOnOutOfBoundsInt64MaxConstInt) {
Devin Moore097a3ab2020-03-11 16:08:44 -07003046 AidlError error;
3047 const string expected_stderr =
Devin Moore2a088902020-09-17 10:51:19 -07003048 "ERROR: p/IFoo.aidl:3.59-86: Could not parse integer: 21474836509999999999999999\n";
Devin Moore097a3ab2020-03-11 16:08:44 -07003049 CaptureStderr();
Will McVickera4e5b132019-10-03 13:52:21 -07003050 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl",
3051 R"(package p;
3052 interface IFoo {
3053 const long int64_max_oob = 21474836509999999999999999;
3054 }
3055 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -07003056 typenames_, GetLanguage(), &error));
Devin Moore097a3ab2020-03-11 16:08:44 -07003057 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3058 EXPECT_EQ(AidlError::PARSE_ERROR, error);
Will McVickera4e5b132019-10-03 13:52:21 -07003059}
3060
Devin Moore7b8d5c92020-03-17 14:14:08 -07003061TEST_P(AidlTest, FailOnOutOfBoundsInt64MinConstInt) {
Devin Moore097a3ab2020-03-11 16:08:44 -07003062 AidlError error;
3063 const string expected_stderr =
Devin Moore2a088902020-09-17 10:51:19 -07003064 "ERROR: p/IFoo.aidl:3.61-87: Could not parse integer: 21474836509999999999999999\n";
Devin Moore097a3ab2020-03-11 16:08:44 -07003065 CaptureStderr();
Will McVickera4e5b132019-10-03 13:52:21 -07003066 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl",
3067 R"(package p;
3068 interface IFoo {
3069 const long int64_min_oob = -21474836509999999999999999;
3070 }
3071 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -07003072 typenames_, GetLanguage(), &error));
Devin Moore097a3ab2020-03-11 16:08:44 -07003073 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3074 EXPECT_EQ(AidlError::PARSE_ERROR, error);
Will McVickera4e5b132019-10-03 13:52:21 -07003075}
3076
Devin Moore7b8d5c92020-03-17 14:14:08 -07003077TEST_P(AidlTest, FailOnOutOfBoundsAutofilledEnum) {
Devin Moore097a3ab2020-03-11 16:08:44 -07003078 AidlError error;
Devin Mooredf93ebb2020-03-25 14:03:35 -07003079 const string expected_stderr =
Jooyung Han29813842020-12-08 01:28:03 +09003080 "ERROR: p/TestEnum.aidl:5.1-36: Invalid type specifier for an int32 literal: byte\n"
Devin Mooredf93ebb2020-03-25 14:03:35 -07003081 "ERROR: p/TestEnum.aidl:5.1-36: Enumerator type differs from enum backing type.\n";
3082 CaptureStderr();
Daniel Normanb28684e2019-10-17 15:31:39 -07003083 EXPECT_EQ(nullptr, Parse("p/TestEnum.aidl",
3084 R"(package p;
3085 @Backing(type="byte")
3086 enum TestEnum {
3087 FOO = 127,
3088 BAR,
3089 }
3090 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -07003091 typenames_, GetLanguage(), &error));
Devin Mooredf93ebb2020-03-25 14:03:35 -07003092 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Devin Moore097a3ab2020-03-11 16:08:44 -07003093 EXPECT_EQ(AidlError::BAD_TYPE, error);
Daniel Normanb28684e2019-10-17 15:31:39 -07003094}
3095
Devin Mooredecaf292020-04-30 09:16:40 -07003096TEST_P(AidlTest, UnsupportedBackingAnnotationParam) {
3097 AidlError error;
3098 const string expected_stderr =
3099 "ERROR: p/TestEnum.aidl:2.1-51: Parameter foo not supported for annotation Backing. It must "
Devin Mooredecaf292020-04-30 09:16:40 -07003100 "be one of: type\n";
3101 CaptureStderr();
3102 EXPECT_EQ(nullptr, Parse("p/TestEnum.aidl",
3103 R"(package p;
3104 @Backing(foo="byte")
3105 enum TestEnum {
3106 FOO = 1,
3107 BAR,
3108 }
3109 )",
3110 typenames_, GetLanguage(), &error));
3111 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3112 EXPECT_EQ(AidlError::BAD_TYPE, error);
3113}
3114
Jooyung Han5721a232020-12-24 04:34:55 +09003115TEST_P(AidlTest, BackingAnnotationRequireTypeParameter) {
3116 const string expected_stderr = "ERROR: Enum.aidl:1.1-9: Missing 'type' on @Backing.\n";
3117 CaptureStderr();
3118 EXPECT_EQ(nullptr, Parse("Enum.aidl", "@Backing enum Enum { FOO }", typenames_, GetLanguage()));
3119 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3120}
3121
Jooyung Han66813932020-10-23 13:24:44 +09003122TEST_F(AidlTest, SupportJavaOnlyImmutableAnnotation) {
Jeongik Chad0a10272020-08-06 16:33:36 +09003123 io_delegate_.SetFileContents("Foo.aidl",
3124 "@JavaOnlyImmutable parcelable Foo { int a; Bar b; List<Bar> c; "
3125 "Map<String, Baz> d; Bar[] e; }");
3126 io_delegate_.SetFileContents("Bar.aidl", "@JavaOnlyImmutable parcelable Bar { String a; }");
3127 io_delegate_.SetFileContents("Baz.aidl",
3128 "@JavaOnlyImmutable @JavaOnlyStableParcelable parcelable Baz;");
Jeongik Cha36f76c32020-07-28 00:25:52 +09003129 Options options = Options::From("aidl --lang=java -I . Foo.aidl");
3130 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3131}
3132
Jooyung Han66813932020-10-23 13:24:44 +09003133TEST_F(AidlTest, RejectMutableParcelableFromJavaOnlyImmutableParcelable) {
Jeongik Chad0a10272020-08-06 16:33:36 +09003134 io_delegate_.SetFileContents("Foo.aidl", "@JavaOnlyImmutable parcelable Foo { Bar bar; }");
Jeongik Cha36f76c32020-07-28 00:25:52 +09003135 io_delegate_.SetFileContents("Bar.aidl", "parcelable Bar { String a; }");
Jooyung Hand4057c42020-10-23 13:28:22 +09003136 string expected_error =
Jooyung Han59af9cc2020-10-25 21:44:14 +09003137 "ERROR: Foo.aidl:1.40-44: The @JavaOnlyImmutable 'Foo' has a non-immutable field "
3138 "named 'bar'.\n";
3139 CaptureStderr();
3140 Options options = Options::From("aidl --lang=java Foo.aidl -I .");
3141 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3142 EXPECT_EQ(expected_error, GetCapturedStderr());
3143}
3144
3145TEST_F(AidlTest, RejectMutableParcelableFromJavaOnlyImmutableUnion) {
3146 io_delegate_.SetFileContents("Foo.aidl", "@JavaOnlyImmutable union Foo { Bar bar; }");
3147 io_delegate_.SetFileContents("Bar.aidl", "parcelable Bar { String a; }");
3148 string expected_error =
3149 "ERROR: Foo.aidl:1.35-39: The @JavaOnlyImmutable 'Foo' has a non-immutable field "
Jooyung Hand4057c42020-10-23 13:28:22 +09003150 "named 'bar'.\n";
3151 CaptureStderr();
Jeongik Cha36f76c32020-07-28 00:25:52 +09003152 Options options = Options::From("aidl --lang=java Foo.aidl -I .");
3153 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jooyung Hand4057c42020-10-23 13:28:22 +09003154 EXPECT_EQ(expected_error, GetCapturedStderr());
Jeongik Cha36f76c32020-07-28 00:25:52 +09003155}
3156
Jooyung Han66813932020-10-23 13:24:44 +09003157TEST_F(AidlTest, ImmutableParcelableCannotBeInOut) {
Jeongik Chad0a10272020-08-06 16:33:36 +09003158 io_delegate_.SetFileContents("Foo.aidl", "@JavaOnlyImmutable parcelable Foo { int a; }");
Jooyung Han15fd6c62020-10-23 13:54:46 +09003159 io_delegate_.SetFileContents("IBar.aidl", "interface IBar { void my(inout Foo foo); }");
3160 string expected_error =
3161 "ERROR: IBar.aidl:1.35-39: 'foo' can't be an inout parameter because @JavaOnlyImmutable can "
3162 "only be an in parameter.\n";
3163 CaptureStderr();
Jeongik Cha36f76c32020-07-28 00:25:52 +09003164 Options options = Options::From("aidl --lang=java IBar.aidl -I .");
3165 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jooyung Han15fd6c62020-10-23 13:54:46 +09003166 EXPECT_EQ(expected_error, GetCapturedStderr());
Jeongik Cha36f76c32020-07-28 00:25:52 +09003167}
3168
Jooyung Han66813932020-10-23 13:24:44 +09003169TEST_F(AidlTest, ImmutableParcelableCannotBeOut) {
Jeongik Chad0a10272020-08-06 16:33:36 +09003170 io_delegate_.SetFileContents("Foo.aidl", "@JavaOnlyImmutable parcelable Foo { int a; }");
Jooyung Han15fd6c62020-10-23 13:54:46 +09003171 io_delegate_.SetFileContents("IBar.aidl", "interface IBar { void my(out Foo foo); }");
3172 string expected_error =
3173 "ERROR: IBar.aidl:1.33-37: 'foo' can't be an out parameter because @JavaOnlyImmutable can "
3174 "only be an in parameter.\n";
3175 CaptureStderr();
Jeongik Cha36f76c32020-07-28 00:25:52 +09003176 Options options = Options::From("aidl --lang=java IBar.aidl -I .");
3177 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jooyung Han15fd6c62020-10-23 13:54:46 +09003178 EXPECT_EQ(expected_error, GetCapturedStderr());
Jeongik Cha36f76c32020-07-28 00:25:52 +09003179}
3180
Jooyung Han66813932020-10-23 13:24:44 +09003181TEST_F(AidlTest, ImmutableParcelableFieldNameRestriction) {
Jeongik Chad0a10272020-08-06 16:33:36 +09003182 io_delegate_.SetFileContents("Foo.aidl", "@JavaOnlyImmutable parcelable Foo { int a; int A; }");
Jeongik Cha91180252020-07-31 15:43:11 +09003183 Options options = Options::From("aidl --lang=java Foo.aidl");
3184 const string expected_stderr =
Jooyung Han59af9cc2020-10-25 21:44:14 +09003185 "ERROR: Foo.aidl:1.47-49: 'Foo' has duplicate field name 'A' after capitalizing the first "
3186 "letter\n";
Jeongik Cha91180252020-07-31 15:43:11 +09003187 CaptureStderr();
3188 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3189 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3190}
Devin Moore53fc99c2020-08-12 08:07:52 -07003191
Jooyung Hanfe086af2021-01-16 03:44:47 +09003192TEST_P(AidlTest, UnionInUnion) {
3193 import_paths_.insert(".");
3194 io_delegate_.SetFileContents("Bar.aidl", "union Bar { int n = 42; long l; }");
3195 CaptureStderr();
3196 EXPECT_NE(nullptr, Parse("Foo.aidl", "union Foo { Bar b; int n; }", typenames_, GetLanguage()));
3197 EXPECT_THAT("", GetCapturedStderr());
3198}
3199
Jooyung Hanfe89f122020-10-14 03:49:18 +09003200TEST_P(AidlTest, UnionRejectsEmptyDecl) {
3201 const string method = "package a; union Foo {}";
3202 const string expected_stderr = "ERROR: a/Foo.aidl:1.17-21: The union 'Foo' has no fields.\n";
3203 CaptureStderr();
3204 EXPECT_EQ(nullptr, Parse("a/Foo.aidl", method, typenames_, GetLanguage()));
3205 EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr(expected_stderr));
3206}
3207
3208TEST_P(AidlTest, UnionRejectsParcelableHolder) {
3209 const string method = "package a; union Foo { ParcelableHolder x; }";
3210 const string expected_stderr =
3211 "ERROR: a/Foo.aidl:1.40-42: A union can't have a member of ParcelableHolder 'x'\n";
3212 CaptureStderr();
3213 EXPECT_EQ(nullptr, Parse("a/Foo.aidl", method, typenames_, GetLanguage()));
3214 EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr(expected_stderr));
3215}
3216
Jooyung Han53fb4242020-12-17 16:03:49 +09003217TEST_P(AidlTest, UnionRejectsFirstEnumWithNoDefaults) {
3218 import_paths_.insert(".");
3219 io_delegate_.SetFileContents("a/Enum.aidl", "package a; enum Enum { FOO, BAR }");
3220 const string expected_err = "The union's first member should have a useful default value.";
3221 CaptureStderr();
3222 EXPECT_EQ(nullptr,
3223 Parse("a/Foo.aidl", "package a; union Foo { a.Enum e; }", typenames_, GetLanguage()));
3224 EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr(expected_err));
3225}
3226
Devin Moore53fc99c2020-08-12 08:07:52 -07003227TEST_P(AidlTest, GenericStructuredParcelable) {
3228 io_delegate_.SetFileContents("Foo.aidl", "parcelable Foo<T, U> { int a; int A; }");
Jooyung Han9435e9a2021-01-06 10:16:31 +09003229 Options options = Options::From("aidl Foo.aidl --lang=" + to_string(GetLanguage()));
Devin Moore53fc99c2020-08-12 08:07:52 -07003230 const string expected_stderr = "";
3231 CaptureStderr();
3232 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3233 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3234}
3235
Jooyung Han3f347ca2020-12-01 12:41:50 +09003236TEST_F(AidlTest, GenericStructuredParcelableWithStringConstants_Cpp) {
3237 io_delegate_.SetFileContents("Foo.aidl",
3238 "parcelable Foo<T, U> { int a; const String s = \"\"; }");
3239 Options options =
Jooyung Han9435e9a2021-01-06 10:16:31 +09003240 Options::From("aidl Foo.aidl --lang=" + to_string(Options::Language::CPP) + " -o out -h out");
Jooyung Han3f347ca2020-12-01 12:41:50 +09003241 const string expected_stderr = "";
3242 CaptureStderr();
3243 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3244 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3245
3246 string code;
3247 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/Foo.h", &code));
3248 EXPECT_THAT(code, testing::HasSubstr(R"--(template <typename T, typename U>
3249const ::android::String16& Foo<T,U>::s() {
3250 static const ::android::String16 value(::android::String16(""));
3251 return value;
3252})--"));
3253}
3254
3255TEST_F(AidlTest, GenericStructuredParcelableWithStringConstants_Ndk) {
3256 io_delegate_.SetFileContents("Foo.aidl",
3257 "parcelable Foo<T, U> { int a; const String s = \"\"; }");
3258 Options options =
Jooyung Han9435e9a2021-01-06 10:16:31 +09003259 Options::From("aidl Foo.aidl --lang=" + to_string(Options::Language::NDK) + " -o out -h out");
Jooyung Han3f347ca2020-12-01 12:41:50 +09003260 const string expected_stderr = "";
3261 CaptureStderr();
3262 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3263 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3264
3265 string code;
3266 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/aidl/Foo.h", &code));
3267 EXPECT_THAT(code, testing::HasSubstr(R"--(template <typename T, typename U>
3268const char* Foo<T, U>::s = "";
3269)--"));
3270}
3271
Jooyung Han8c9a4e12020-10-26 15:39:54 +09003272TEST_F(AidlTest, NestedTypeArgs) {
3273 io_delegate_.SetFileContents("a/Bar.aidl", "package a; parcelable Bar<A> { }");
Steven Moreland6c07b832020-10-29 23:39:53 +00003274 io_delegate_.SetFileContents("a/Baz.aidl", "package a; parcelable Baz<A, B> { }");
3275
3276 io_delegate_.SetFileContents("a/Foo.aidl",
3277 "package a; import a.Bar; import a.Baz; parcelable Foo { "
3278 "Baz<Bar<Bar<String[]>>[], Bar<String>> barss; }");
Jooyung Han8c9a4e12020-10-26 15:39:54 +09003279 Options options = Options::From("aidl a/Foo.aidl -I . -o out --lang=java");
3280 const string expected_stderr = "";
3281 CaptureStderr();
3282 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3283 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3284
3285 string code;
3286 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/Foo.java", &code));
Steven Moreland6c07b832020-10-29 23:39:53 +00003287 EXPECT_THAT(code,
3288 testing::HasSubstr(
3289 "a.Baz<a.Bar<a.Bar<java.lang.String[]>>[],a.Bar<java.lang.String>> barss;"));
3290}
3291
3292TEST_F(AidlTest, DoubleArrayError) {
3293 io_delegate_.SetFileContents("a/Bar.aidl", "package a; parcelable Bar { String[][] a; }");
3294
3295 Options options = Options::From("aidl a/Bar.aidl -I . -o out --lang=java");
3296 const string expected_stderr =
3297 "ERROR: a/Bar.aidl:1.28-37: Can only have one dimensional arrays.\n";
3298 CaptureStderr();
3299 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3300 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3301}
3302
3303TEST_F(AidlTest, DoubleGenericError) {
3304 io_delegate_.SetFileContents("a/Bar.aidl",
3305 "package a; parcelable Bar { List<String><String> a; }");
3306
3307 Options options = Options::From("aidl a/Bar.aidl -I . -o out --lang=java");
3308 const string expected_stderr =
3309 "ERROR: a/Bar.aidl:1.28-33: Can only specify one set of type parameters.\n";
3310 CaptureStderr();
3311 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3312 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3313}
3314
3315TEST_F(AidlTest, ArrayBeforeGenericError) {
3316 io_delegate_.SetFileContents("a/Bar.aidl", "package a; parcelable Bar { List[]<String> a; }");
3317
3318 Options options = Options::From("aidl a/Bar.aidl -I . -o out --lang=java");
Steven Moreland6c07b832020-10-29 23:39:53 +00003319 CaptureStderr();
3320 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jooyung Han97c324a2021-02-15 16:09:51 +09003321 EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr("syntax error, unexpected '<'"));
3322}
3323
3324TEST_F(AidlTest, NullableArraysAreNotSupported) {
3325 io_delegate_.SetFileContents("a/Bar.aidl",
3326 "package a; parcelable Bar { String @nullable [] a; }");
3327
3328 Options options = Options::From("aidl a/Bar.aidl -I . -o out --lang=java");
3329 CaptureStderr();
3330 EXPECT_EQ(1, ::android::aidl::compile_aidl(options, io_delegate_));
3331 EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr("Annotations for arrays are not supported."));
3332}
3333
3334TEST_F(AidlTest, ListOfNullablesAreNotSupported) {
3335 io_delegate_.SetFileContents("a/Bar.aidl",
3336 "package a; parcelable Bar { List<@nullable String> a; }");
3337
3338 Options options = Options::From("aidl a/Bar.aidl -I . -o out --lang=java");
3339 CaptureStderr();
3340 EXPECT_EQ(1, ::android::aidl::compile_aidl(options, io_delegate_));
3341 EXPECT_THAT(GetCapturedStderr(),
3342 testing::HasSubstr("Annotations for type arguments are not supported."));
Jooyung Han8c9a4e12020-10-26 15:39:54 +09003343}
3344
Jooyung Han14004ed2020-10-16 03:49:57 +09003345struct GenericAidlTest : ::testing::Test {
3346 FakeIoDelegate io_delegate_;
3347 void Compile(string cmd) {
Steven Moreland6c07b832020-10-29 23:39:53 +00003348 io_delegate_.SetFileContents("Foo.aidl", "parcelable Foo { Bar<Baz<Qux>> x; }");
Jooyung Han14004ed2020-10-16 03:49:57 +09003349 io_delegate_.SetFileContents("Bar.aidl", "parcelable Bar<T> { }");
3350 io_delegate_.SetFileContents("Baz.aidl", "parcelable Baz<T> { }");
3351 io_delegate_.SetFileContents("Qux.aidl", "parcelable Qux { }");
3352
3353 Options options = Options::From(cmd);
3354 CaptureStderr();
3355 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3356 EXPECT_EQ("", GetCapturedStderr());
3357 }
3358};
3359
3360TEST_F(GenericAidlTest, ImportGenericParameterTypesCPP) {
3361 Compile("aidl Foo.aidl --lang=cpp -I . -o out -h out");
3362 string code;
3363 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/Foo.h", &code));
3364 EXPECT_THAT(code, testing::HasSubstr("#include <Bar.h>"));
3365 EXPECT_THAT(code, testing::HasSubstr("#include <Baz.h>"));
3366 EXPECT_THAT(code, testing::HasSubstr("#include <Qux.h>"));
3367}
3368
3369TEST_F(GenericAidlTest, ImportGenericParameterTypesNDK) {
3370 Compile("aidl Foo.aidl --lang=ndk -I . -o out -h out");
3371 string code;
3372 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/aidl/Foo.h", &code));
3373 EXPECT_THAT(code, testing::HasSubstr("#include <aidl/Bar.h>"));
3374 EXPECT_THAT(code, testing::HasSubstr("#include <aidl/Baz.h>"));
3375 EXPECT_THAT(code, testing::HasSubstr("#include <aidl/Qux.h>"));
3376}
3377
Devin Moore53fc99c2020-08-12 08:07:52 -07003378TEST_P(AidlTest, RejectGenericStructuredParcelabelRepeatedParam) {
3379 io_delegate_.SetFileContents("Foo.aidl", "parcelable Foo<T,T> { int a; int A; }");
Jooyung Han9435e9a2021-01-06 10:16:31 +09003380 Options options = Options::From("aidl Foo.aidl --lang=" + to_string(GetLanguage()));
Devin Moore53fc99c2020-08-12 08:07:52 -07003381 const string expected_stderr =
3382 "ERROR: Foo.aidl:1.11-15: Every type parameter should be unique.\n";
3383 CaptureStderr();
3384 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3385 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3386}
3387
3388TEST_P(AidlTest, RejectGenericStructuredParcelableField) {
3389 io_delegate_.SetFileContents("Foo.aidl", "parcelable Foo<T,T> { T a; int A; }");
Jooyung Han9435e9a2021-01-06 10:16:31 +09003390 Options options = Options::From("aidl Foo.aidl --lang=" + to_string(GetLanguage()));
Devin Moore53fc99c2020-08-12 08:07:52 -07003391 const string expected_stderr = "ERROR: Foo.aidl:1.22-24: Failed to resolve 'T'\n";
3392 CaptureStderr();
3393 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3394 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3395}
3396
Jooyung Han7a308842020-10-27 19:06:49 +09003397TEST_P(AidlTest, LongCommentWithinConstExpression) {
3398 io_delegate_.SetFileContents("Foo.aidl", "enum Foo { FOO = (1 << 1) /* comment */ | 0x0 }");
Jooyung Han9435e9a2021-01-06 10:16:31 +09003399 Options options = Options::From("aidl Foo.aidl --lang=" + to_string(GetLanguage()));
Jooyung Han7a308842020-10-27 19:06:49 +09003400 CaptureStderr();
3401 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3402 EXPECT_EQ("", GetCapturedStderr());
3403}
3404
Jeongik Chaef44e622020-10-23 16:00:52 +09003405TEST_F(AidlTest, RejectUntypdeListAndMapInUnion) {
3406 io_delegate_.SetFileContents("a/Foo.aidl", "package a; union Foo { List l; Map m; }");
3407 Options options = Options::From("aidl a/Foo.aidl --lang=java -o out");
3408 std::string expectedErr =
3409 "ERROR: a/Foo.aidl:1.28-30: "
3410 "Encountered an untyped List or Map. The use of untyped List/Map is "
3411 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
3412 "the receiving side. Consider switching to an array or a generic List/Map.\n"
3413 "ERROR: a/Foo.aidl:1.35-37: "
3414 "Encountered an untyped List or Map. The use of untyped List/Map is "
3415 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
3416 "the receiving side. Consider switching to an array or a generic List/Map.\n";
3417 CaptureStderr();
3418 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3419 EXPECT_EQ(expectedErr, GetCapturedStderr());
3420}
3421
3422TEST_F(AidlTest, RejectUntypdeListAndMapInUnstructuredParcelable) {
Jooyung Hanea2147c2020-10-21 18:16:56 +09003423 io_delegate_.SetFileContents("a/Foo.aidl", "package a; parcelable Foo { List l; Map m; }");
3424 Options options = Options::From("aidl a/Foo.aidl --lang=java -o out");
Jeongik Chaef44e622020-10-23 16:00:52 +09003425 std::string expectedErr =
3426 "ERROR: a/Foo.aidl:1.33-35: "
3427 "Encountered an untyped List or Map. The use of untyped List/Map is "
3428 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
3429 "the receiving side. Consider switching to an array or a generic List/Map.\n"
3430 "ERROR: a/Foo.aidl:1.40-42: "
3431 "Encountered an untyped List or Map. The use of untyped List/Map is "
3432 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
3433 "the receiving side. Consider switching to an array or a generic List/Map.\n";
Jooyung Hanea2147c2020-10-21 18:16:56 +09003434 CaptureStderr();
Jeongik Chaef44e622020-10-23 16:00:52 +09003435 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3436 EXPECT_EQ(expectedErr, GetCapturedStderr());
3437}
Jooyung Hanea2147c2020-10-21 18:16:56 +09003438
Jeongik Chaef44e622020-10-23 16:00:52 +09003439TEST_F(AidlTest, RejectNestedUntypedListAndMap) {
3440 io_delegate_.SetFileContents("a/Bar.aidl", "package a; parcelable Bar<T>;");
3441 io_delegate_.SetFileContents(
3442 "a/Foo.aidl", "package a; import a.Bar; parcelable Foo { Bar<List> a; Bar<Map> b; }");
3443 Options options = Options::From("aidl a/Foo.aidl -I . --lang=java -o out");
3444 std::string expectedErr =
3445 "ERROR: a/Foo.aidl:1.52-54: "
3446 "Encountered an untyped List or Map. The use of untyped List/Map is "
3447 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
3448 "the receiving side. Consider switching to an array or a generic List/Map.\n"
3449 "ERROR: a/Foo.aidl:1.64-66: "
3450 "Encountered an untyped List or Map. The use of untyped List/Map is "
3451 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
3452 "the receiving side. Consider switching to an array or a generic List/Map.\n";
3453 CaptureStderr();
3454 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3455 EXPECT_EQ(expectedErr, GetCapturedStderr());
Jooyung Hanea2147c2020-10-21 18:16:56 +09003456}
3457
Jooyung Han690f5842020-12-04 13:02:04 +09003458TEST_F(AidlTest, EnumWithDefaults_Java) {
3459 io_delegate_.SetFileContents("a/p/Enum.aidl", "package p; enum Enum { FOO, BAR }");
3460 io_delegate_.SetFileContents("a/p/Foo.aidl", R"(
3461package p;
3462import p.Enum;
3463parcelable Foo {
3464 Enum e = Enum.BAR;
3465})");
3466 CaptureStderr();
3467 auto options = Options::From("aidl -I a --lang java -o out a/p/Foo.aidl");
3468 EXPECT_EQ(0, aidl::compile_aidl(options, io_delegate_));
3469 auto err = GetCapturedStderr();
3470 EXPECT_EQ("", err);
3471
3472 string code;
3473 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/p/Foo.java", &code));
Jooyung Han2d833612020-12-17 15:59:27 +09003474 EXPECT_THAT(code, testing::HasSubstr("byte e = p.Enum.BAR"));
Jooyung Han690f5842020-12-04 13:02:04 +09003475}
3476
3477TEST_F(AidlTest, EnumWithDefaults_Cpp) {
3478 io_delegate_.SetFileContents("a/p/Enum.aidl", "package p; enum Enum { FOO, BAR }");
3479 io_delegate_.SetFileContents("a/p/Foo.aidl", R"(
3480package p;
3481import p.Enum;
3482parcelable Foo {
3483 Enum e = Enum.BAR;
3484})");
3485 CaptureStderr();
3486 auto options = Options::From("aidl -I a --lang cpp -o out -h out a/p/Foo.aidl");
3487 EXPECT_EQ(0, aidl::compile_aidl(options, io_delegate_));
3488 auto err = GetCapturedStderr();
3489 EXPECT_EQ("", err);
3490
3491 string code;
3492 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/p/Foo.h", &code));
3493 EXPECT_THAT(code, testing::HasSubstr("::p::Enum e = ::p::Enum(::p::Enum::BAR);"));
3494}
3495
3496TEST_F(AidlTest, EnumWithDefaults_Ndk) {
3497 io_delegate_.SetFileContents("a/p/Enum.aidl", "package p; enum Enum { FOO, BAR }");
3498 io_delegate_.SetFileContents("a/p/Foo.aidl", R"(
3499package p;
3500import p.Enum;
3501parcelable Foo {
3502 Enum e = Enum.BAR;
3503})");
3504 CaptureStderr();
3505 auto options = Options::From("aidl -I a --lang ndk -o out -h out a/p/Foo.aidl");
3506 EXPECT_EQ(0, aidl::compile_aidl(options, io_delegate_));
3507 auto err = GetCapturedStderr();
3508 EXPECT_EQ("", err);
3509
3510 string code;
3511 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/aidl/p/Foo.h", &code));
3512 EXPECT_THAT(code, testing::HasSubstr("::aidl::p::Enum e = ::aidl::p::Enum::BAR;"));
3513}
3514
3515TEST_F(AidlTest, EnumWithDefaults_Rust) {
3516 io_delegate_.SetFileContents("a/p/Enum.aidl", "package p; enum Enum { FOO, BAR }");
3517 io_delegate_.SetFileContents("a/p/Foo.aidl", R"(
3518package p;
3519import p.Enum;
3520parcelable Foo {
3521 int n = 42;
3522 Enum e = Enum.BAR;
3523})");
3524 CaptureStderr();
3525 auto options = Options::From("aidl -I a --lang rust -o out -h out a/p/Foo.aidl");
3526 EXPECT_EQ(0, aidl::compile_aidl(options, io_delegate_));
3527 auto err = GetCapturedStderr();
3528 EXPECT_EQ("", err);
3529
3530 string code;
3531 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/p/Foo.rs", &code));
3532 EXPECT_THAT(code, testing::HasSubstr(R"(
3533 fn default() -> Self {
3534 Self {
3535 n: 42,
3536 e: crate::mangled::_1_p_4_Enum::BAR,
3537 }
3538 })"));
3539}
3540
3541TEST_P(AidlTest, EnumeratorIsConstantValue_DefaultValue) {
3542 import_paths_.insert("a");
3543 io_delegate_.SetFileContents("a/p/Enum.aidl", "package p; enum Enum { FOO = 1, BAR = 2}");
3544 CaptureStderr();
3545 const AidlDefinedType* type = Parse("a/p/Foo.aidl", R"(
3546package p;
3547import p.Enum;
3548parcelable Foo {
3549 int e = Enum.FOO | Enum.BAR;
3550})",
3551 typenames_, GetLanguage());
3552 auto err = GetCapturedStderr();
3553 EXPECT_EQ("", err);
3554 EXPECT_TRUE(type);
3555 const auto& fields = type->AsStructuredParcelable()->GetFields();
3556 EXPECT_EQ("int e = 3", fields[0]->ToString());
3557}
3558
3559TEST_P(AidlTest, EnumeratorIsConstantValue_CanDefineOtherEnumerator) {
3560 CaptureStderr();
3561 const AidlDefinedType* type = Parse("a/p/Foo.aidl", R"(
3562@Backing(type="int")
3563enum Foo {
3564 STANDARD_SHIFT = 16,
3565 STANDARD_BT709 = 1 << STANDARD_SHIFT,
3566 STANDARD_BT601_625 = 2 << STANDARD_SHIFT,
3567}
3568)",
3569 typenames_, GetLanguage());
3570 auto err = GetCapturedStderr();
3571 EXPECT_EQ("", err);
3572 EXPECT_TRUE(type);
3573 const auto& enum_type = type->AsEnumDeclaration();
3574 string code;
Jooyung Han1f56b702021-02-11 13:16:15 +09003575 auto writer = CodeWriter::ForString(&code);
3576 DumpVisitor visitor(*writer);
3577 visitor.Visit(*enum_type);
3578 writer->Close();
Jooyung Han690f5842020-12-04 13:02:04 +09003579 EXPECT_EQ(R"--(@Backing(type="int")
3580enum Foo {
3581 STANDARD_SHIFT = 16,
3582 STANDARD_BT709 = 65536,
3583 STANDARD_BT601_625 = 131072,
3584}
3585)--",
3586 code);
3587}
3588
3589TEST_F(AidlTest, EnumDefaultShouldBeEnumerators) {
3590 io_delegate_.SetFileContents("a/p/Enum.aidl", "package p; enum Enum { FOO = 1, BAR = 2}");
3591 io_delegate_.SetFileContents("a/p/Foo.aidl", R"(
3592package p;
3593import p.Enum;
3594parcelable Foo {
3595 Enum e = Enum.FOO | Enum.BAR;
3596})");
3597 CaptureStderr();
3598 auto options = Options::From("aidl -I a --lang java -o out -h out a/p/Foo.aidl");
3599 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
3600 auto err = GetCapturedStderr();
3601 EXPECT_EQ("ERROR: a/p/Foo.aidl:5.11-20: Invalid value (Enum.FOO|Enum.BAR) for enum p.Enum\n",
3602 err);
3603}
3604
3605TEST_P(AidlTest, DefaultWithEmptyArray) {
3606 io_delegate_.SetFileContents("a/p/Foo.aidl", "package p; parcelable Foo { p.Bar[] bars = {}; }");
3607 io_delegate_.SetFileContents("a/p/Bar.aidl", "package p; parcelable Bar { }");
3608 CaptureStderr();
Jooyung Han9435e9a2021-01-06 10:16:31 +09003609 auto options =
3610 Options::From("aidl -I a --lang " + to_string(GetLanguage()) + " -o out -h out a/p/Foo.aidl");
Jooyung Han690f5842020-12-04 13:02:04 +09003611 EXPECT_EQ(0, aidl::compile_aidl(options, io_delegate_));
3612 auto err = GetCapturedStderr();
3613 EXPECT_EQ("", err);
3614}
3615
3616TEST_P(AidlTest, RejectRefsInAnnotation) {
3617 io_delegate_.SetFileContents("a/p/IFoo.aidl",
3618 "package p; interface IFoo {\n"
3619 " const String ANNOTATION = \"@Annotation\";\n"
3620 " @JavaPassthrough(annotation=ANNOTATION) void foo();\n"
3621 "}");
3622 CaptureStderr();
Jooyung Han9435e9a2021-01-06 10:16:31 +09003623 auto options =
3624 Options::From("aidl --lang " + to_string(GetLanguage()) + " -o out -h out a/p/IFoo.aidl");
Jooyung Han690f5842020-12-04 13:02:04 +09003625 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
3626 auto err = GetCapturedStderr();
3627 EXPECT_EQ(
3628 "ERROR: a/p/IFoo.aidl:3.31-41: Value must be a constant expression but contains reference to "
3629 "ANNOTATION.\n",
3630 err);
3631}
3632
3633TEST_F(AidlTest, DefaultWithEnumValues) {
3634 io_delegate_.SetFileContents(
3635 "a/p/Foo.aidl",
3636 "package p; import p.Bar; parcelable Foo { Bar[] bars = { Bar.FOO, Bar.FOO }; }");
3637 io_delegate_.SetFileContents("a/p/Bar.aidl", "package p; enum Bar { FOO, BAR }");
3638 CaptureStderr();
3639 auto options = Options::From("aidl -I a --lang ndk -o out -h out a/p/Foo.aidl");
3640 EXPECT_EQ(0, aidl::compile_aidl(options, io_delegate_));
3641 auto err = GetCapturedStderr();
3642 EXPECT_EQ("", err);
3643 string code;
3644 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/aidl/p/Foo.h", &code));
3645 EXPECT_THAT(
3646 code, testing::HasSubstr(
3647 "std::vector<::aidl::p::Bar> bars = {::aidl::p::Bar::FOO, ::aidl::p::Bar::FOO};"));
3648}
3649
Jooyung Han14259392020-12-07 10:00:08 +09003650TEST_F(AidlTest, RejectsCircularReferencingEnumerators) {
3651 io_delegate_.SetFileContents("a/p/Foo.aidl", "package p; enum Foo { A = B, B }");
3652 CaptureStderr();
3653 auto options = Options::From("aidl -I a --lang ndk -o out -h out a/p/Foo.aidl");
3654 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
3655 auto err = GetCapturedStderr();
Jooyung Han29813842020-12-08 01:28:03 +09003656 EXPECT_EQ(
3657 "ERROR: a/p/Foo.aidl:1.26-28: Found a circular reference: B -> A -> B\n"
3658 "ERROR: a/p/Foo.aidl:1.29-31: Found a circular reference: A -> B -> A\n",
3659 err);
Jooyung Han14259392020-12-07 10:00:08 +09003660}
3661
3662TEST_F(AidlTest, RejectsCircularReferencingConsts) {
3663 io_delegate_.SetFileContents("a/p/Foo.aidl",
3664 "package p; parcelable Foo { const int A = A + 1; }");
3665 CaptureStderr();
3666 auto options = Options::From("aidl -I a --lang ndk -o out -h out a/p/Foo.aidl");
3667 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
3668 auto err = GetCapturedStderr();
Jooyung Han29813842020-12-08 01:28:03 +09003669 EXPECT_EQ("ERROR: a/p/Foo.aidl:1.42-44: Found a circular reference: A -> A\n", err);
3670}
3671
3672TEST_F(AidlTest, RecursiveReferences) {
3673 io_delegate_.SetFileContents("a/p/Foo.aidl",
3674 "package p; parcelable Foo { const int A = p.Bar.A + 1; }");
3675 io_delegate_.SetFileContents("a/p/Bar.aidl",
3676 "package p; parcelable Bar { const int A = p.Baz.A + 1; }");
3677 io_delegate_.SetFileContents("a/p/Baz.aidl", "package p; parcelable Baz { const int A = 1; }");
3678 CaptureStderr();
3679 auto options = Options::From("aidl -I a --lang ndk -o out -h out a/p/Foo.aidl");
3680 EXPECT_EQ(0, aidl::compile_aidl(options, io_delegate_));
3681 EXPECT_EQ("", GetCapturedStderr());
3682}
3683
Jooyung Hane9f5b272021-01-07 00:18:11 +09003684TEST_P(AidlTest, UnknownConstReference) {
3685 io_delegate_.SetFileContents("Foo.aidl", " parcelable Foo { UnknownType field = UNKNOWN_REF; }");
3686 auto options =
3687 Options::From("aidl --lang " + to_string(GetLanguage()) + " -o out -h out Foo.aidl");
3688 const string err =
3689 "ERROR: Foo.aidl:1.18-30: Failed to resolve 'UnknownType'\n"
3690 "ERROR: Foo.aidl:1.38-50: Can't find UNKNOWN_REF in Foo\n"
3691 "ERROR: Foo.aidl:1.38-50: Unknown reference 'UNKNOWN_REF'\n";
3692 CaptureStderr();
3693 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
3694 EXPECT_EQ(err, GetCapturedStderr());
3695}
3696
Jooyung Han29813842020-12-08 01:28:03 +09003697TEST_P(AidlTest, JavaCompatibleBuiltinTypes) {
3698 string contents = R"(
3699import android.os.IBinder;
3700import android.os.IInterface;
3701interface IFoo {}
3702 )";
3703 EXPECT_NE(nullptr, Parse("IFoo.aidl", contents, typenames_, GetLanguage()));
Jooyung Han14259392020-12-07 10:00:08 +09003704}
3705
Jooyung Han888c5bc2020-12-22 17:28:47 +09003706TEST_P(AidlTest, WarningInterfaceName) {
3707 io_delegate_.SetFileContents("p/Foo.aidl", "interface Foo {}");
Jooyung Han9435e9a2021-01-06 10:16:31 +09003708 auto options = Options::From("aidl --lang " + to_string(GetLanguage()) +
Jooyung Han888c5bc2020-12-22 17:28:47 +09003709 " -Weverything -o out -h out p/Foo.aidl");
3710 CaptureStderr();
3711 EXPECT_EQ(0, aidl::compile_aidl(options, io_delegate_));
Jooyung Han808a2a02020-12-28 16:46:54 +09003712 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 +09003713 GetCapturedStderr());
3714}
3715
3716TEST_P(AidlTest, ErrorInterfaceName) {
3717 io_delegate_.SetFileContents("p/Foo.aidl", "interface Foo {}");
Jooyung Han9435e9a2021-01-06 10:16:31 +09003718 auto options = Options::From("aidl --lang " + to_string(GetLanguage()) +
Jooyung Han888c5bc2020-12-22 17:28:47 +09003719 " -Weverything -Werror -o out -h out p/Foo.aidl");
3720 CaptureStderr();
3721 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
Jooyung Han808a2a02020-12-28 16:46:54 +09003722 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 +09003723 GetCapturedStderr());
3724}
3725
Jiyong Park9f4c3822021-04-07 20:36:45 +09003726TEST_F(AidlTest, RejectsIncorrectOutputFilePathOnLegacyCppInput) {
3727 const std::string input_file = "base/p/q/IFoo.aidl";
3728 const std::string header_dir = "out/";
3729 const std::string output_file = "out/base/p/q/IFoo.cpp";
3730 const std::string package = "p.q"; // not base.p.q
3731 io_delegate_.SetFileContents(input_file, "package " + package + "; interface IFoo {}");
3732
3733 auto options = Options::From({"aidl-cpp", input_file, header_dir, output_file});
3734 CaptureStderr();
3735 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
3736 EXPECT_THAT(
3737 GetCapturedStderr(),
3738 testing::StartsWith(
3739 "ERROR: base/p/q/IFoo.aidl:1.13-23: Output file is expected to be at out/p/q/IFoo.cpp, "
3740 "but is out/base/p/q/IFoo.cpp."));
3741}
3742
Jooyung Hanb7a60ec2021-01-21 13:47:59 +09003743TEST_F(AidlTest, FormatCommentsForJava) {
3744 using android::aidl::FormatCommentsForJava;
3745
3746 struct TestCase {
3747 vector<Comment> comments;
3748 string formatted;
3749 };
3750 vector<TestCase> testcases = {
3751 {{}, ""},
3752 {{{"// line comments\n"}}, "// line comments\n"},
3753 {{{"// @hide \n"}}, "// @hide \n"},
3754 // Transform the last block comment as Javadoc.
3755 {{{"/*\n"
3756 " * Hello, world!\n"
3757 " */"}},
3758 "/**\n"
3759 " * Hello, world!\n"
3760 " */"},
3761 {{{"/* @hide */"}}, "/** @hide */"},
3762 {{{"/**\n"
3763 " @param foo ...\n"
3764 "*/"}},
3765 "/**\n"
3766 " @param foo ...\n"
3767 "*/"},
3768 {{{"/* @hide */"}, {"/* @hide */"}}, "/* @hide *//** @hide */"},
3769 {{{"/* @deprecated first */"}, {"/* @deprecated second */"}},
3770 "/* @deprecated first *//** @deprecated second */"},
3771 {{{"/* @deprecated */"}, {"/** @param foo */"}}, "/* @deprecated *//** @param foo */"},
3772 // Line comments are printed as they are
3773 {{{"/* @deprecated */"}, {"// line comments\n"}}, "/* @deprecated */// line comments\n"},
3774 };
3775 for (const auto& [input, formatted] : testcases) {
3776 EXPECT_EQ(formatted, FormatCommentsForJava(input));
3777 }
3778}
3779
Jooyung Han2d6b5c42021-01-09 01:01:06 +09003780TEST_F(AidlTest, HideIsNotForArgs) {
3781 io_delegate_.SetFileContents("IFoo.aidl",
3782 "interface IFoo {\n"
3783 " void foo(in @Hide int x);\n"
3784 "}");
3785 auto options = Options::From("aidl --lang=java IFoo.aidl");
3786 CaptureStderr();
3787 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
3788 EXPECT_THAT(GetCapturedStderr(), HasSubstr("@Hide is not available"));
3789}
3790
3791TEST_F(AidlTest, SuppressWarningsIsNotForArgs) {
3792 io_delegate_.SetFileContents(
3793 "IFoo.aidl",
3794 "interface IFoo {\n"
3795 " void foo(in @SuppressWarnings(value=\"inout-parameter\") int x);\n"
3796 "}");
3797 auto options = Options::From("aidl --lang=java IFoo.aidl");
3798 CaptureStderr();
3799 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
3800 EXPECT_THAT(GetCapturedStderr(), HasSubstr("@SuppressWarnings is not available"));
3801}
3802
Jooyung Hanfd3be322020-12-13 09:11:06 +09003803struct TypeParam {
Jooyung Hane87cdd02020-12-11 16:47:35 +09003804 string kind;
3805 string literal;
3806};
3807
Jooyung Hanfd3be322020-12-13 09:11:06 +09003808const TypeParam kTypeParams[] = {
Jooyung Hancea89002021-02-15 17:04:04 +09003809 {"primitive", "int"}, {"primitiveArray", "int[]"},
3810 {"String", "String"}, {"StringArray", "String[]"},
Jooyung Hane87cdd02020-12-11 16:47:35 +09003811 {"IBinder", "IBinder"}, {"ParcelFileDescriptor", "ParcelFileDescriptor"},
3812 {"parcelable", "Foo"}, {"enum", "a.Enum"},
3813 {"union", "a.Union"}, {"interface", "a.IBar"},
3814};
3815
3816const std::map<std::string, std::string> kListSupportExpectations = {
3817 {"cpp_primitive", "A generic type cannot have any primitive type parameters."},
3818 {"java_primitive", "A generic type cannot have any primitive type parameters."},
3819 {"ndk_primitive", "A generic type cannot have any primitive type parameters."},
3820 {"rust_primitive", "A generic type cannot have any primitive type parameters."},
Jooyung Hancea89002021-02-15 17:04:04 +09003821 {"cpp_primitiveArray", "List of arrays is not supported."},
3822 {"java_primitiveArray", "List of arrays is not supported."},
3823 {"ndk_primitiveArray", "List of arrays is not supported."},
3824 {"rust_primitiveArray", "List of arrays is not supported."},
Jooyung Hane87cdd02020-12-11 16:47:35 +09003825 {"cpp_String", ""},
3826 {"java_String", ""},
3827 {"ndk_String", ""},
3828 {"rust_String", ""},
Jooyung Hancea89002021-02-15 17:04:04 +09003829 {"cpp_StringArray", "List of arrays is not supported."},
3830 {"java_StringArray", "List of arrays is not supported."},
3831 {"ndk_StringArray", "List of arrays is not supported."},
3832 {"rust_StringArray", "List of arrays is not supported."},
Jooyung Hane87cdd02020-12-11 16:47:35 +09003833 {"cpp_IBinder", ""},
3834 {"java_IBinder", ""},
3835 {"ndk_IBinder", "List<IBinder> is not supported. List in NDK doesn't support IBinder."},
3836 {"rust_IBinder", ""},
Jooyung Han55f96ad2020-12-13 10:08:33 +09003837 {"cpp_ParcelFileDescriptor", ""},
Jooyung Hane87cdd02020-12-11 16:47:35 +09003838 {"java_ParcelFileDescriptor", ""},
3839 {"ndk_ParcelFileDescriptor", ""},
3840 {"rust_ParcelFileDescriptor", ""},
Jooyung Han55f96ad2020-12-13 10:08:33 +09003841 {"cpp_interface", "List<a.IBar> is not supported."},
3842 {"java_interface", "List<a.IBar> is not supported."},
3843 {"ndk_interface", "List<a.IBar> is not supported."},
3844 {"rust_interface", "List<a.IBar> is not supported."},
3845 {"cpp_parcelable", ""},
Jooyung Hane87cdd02020-12-11 16:47:35 +09003846 {"java_parcelable", ""},
3847 {"ndk_parcelable", ""},
3848 {"rust_parcelable", ""},
3849 {"cpp_enum", "A generic type cannot have any primitive type parameters."},
3850 {"java_enum", "A generic type cannot have any primitive type parameters."},
3851 {"ndk_enum", "A generic type cannot have any primitive type parameters."},
3852 {"rust_enum", "A generic type cannot have any primitive type parameters."},
Jooyung Han55f96ad2020-12-13 10:08:33 +09003853 {"cpp_union", ""},
Jooyung Hane87cdd02020-12-11 16:47:35 +09003854 {"java_union", ""},
3855 {"ndk_union", ""},
3856 {"rust_union", ""},
3857};
3858
Jooyung Hand236e552020-12-13 09:21:27 +09003859const std::map<std::string, std::string> kArraySupportExpectations = {
3860 {"cpp_primitive", ""},
3861 {"java_primitive", ""},
3862 {"ndk_primitive", ""},
3863 {"rust_primitive", ""},
Jooyung Hancea89002021-02-15 17:04:04 +09003864 {"cpp_primitiveArray", "Can only have one dimensional arrays."},
3865 {"java_primitiveArray", "Can only have one dimensional arrays."},
3866 {"ndk_primitiveArray", "Can only have one dimensional arrays."},
3867 {"rust_primitiveArray", "Can only have one dimensional arrays."},
Jooyung Hand236e552020-12-13 09:21:27 +09003868 {"cpp_String", ""},
3869 {"java_String", ""},
3870 {"ndk_String", ""},
3871 {"rust_String", ""},
Jooyung Hancea89002021-02-15 17:04:04 +09003872 {"cpp_StringArray", "Can only have one dimensional arrays."},
3873 {"java_StringArray", "Can only have one dimensional arrays."},
3874 {"ndk_StringArray", "Can only have one dimensional arrays."},
3875 {"rust_StringArray", "Can only have one dimensional arrays."},
Jooyung Hand236e552020-12-13 09:21:27 +09003876 {"cpp_IBinder", ""},
3877 {"java_IBinder", ""},
3878 {"ndk_IBinder", "The ndk backend does not support array of IBinder"},
3879 {"rust_IBinder", "The rust backend does not support array of IBinder"},
3880 {"cpp_ParcelFileDescriptor", ""},
3881 {"java_ParcelFileDescriptor", ""},
3882 {"ndk_ParcelFileDescriptor", ""},
3883 {"rust_ParcelFileDescriptor", ""},
3884 {"cpp_interface", "Binder type cannot be an array"},
3885 {"java_interface", "Binder type cannot be an array"},
3886 {"ndk_interface", "Binder type cannot be an array"},
3887 {"rust_interface", "Binder type cannot be an array"},
3888 {"cpp_parcelable", ""},
3889 {"java_parcelable", ""},
3890 {"ndk_parcelable", ""},
3891 {"rust_parcelable", ""},
3892 {"cpp_enum", ""},
3893 {"java_enum", ""},
3894 {"ndk_enum", ""},
3895 {"rust_enum", ""},
3896 {"cpp_union", ""},
3897 {"java_union", ""},
3898 {"ndk_union", ""},
3899 {"rust_union", ""},
3900};
3901
Jooyung Hanfd3be322020-12-13 09:11:06 +09003902class AidlTypeParamTest : public testing::TestWithParam<std::tuple<Options::Language, TypeParam>> {
Jooyung Hane87cdd02020-12-11 16:47:35 +09003903 public:
Jooyung Hanfd3be322020-12-13 09:11:06 +09003904 void Run(const std::string& generic_type_decl,
3905 const std::map<std::string, std::string>& expectations) {
Jooyung Hane87cdd02020-12-11 16:47:35 +09003906 const auto& param = GetParam();
Jooyung Han9435e9a2021-01-06 10:16:31 +09003907 const auto& lang = to_string(std::get<0>(param));
Jooyung Hane87cdd02020-12-11 16:47:35 +09003908 const auto& kind = std::get<1>(param).kind;
3909
3910 FakeIoDelegate io;
3911 io.SetFileContents("a/IBar.aidl", "package a; interface IBar { }");
3912 io.SetFileContents("a/Enum.aidl", "package a; enum Enum { A }");
3913 io.SetFileContents("a/Union.aidl", "package a; union Union { int a; }");
Jooyung Hanfd3be322020-12-13 09:11:06 +09003914 std::string decl = fmt::format(generic_type_decl, std::get<1>(param).literal);
3915 io.SetFileContents("a/Foo.aidl", "package a; parcelable Foo { " + decl + " f; }");
Jooyung Hane87cdd02020-12-11 16:47:35 +09003916
3917 const auto options =
3918 Options::From(fmt::format("aidl -I . --lang={} a/Foo.aidl -o out -h out", lang));
3919 CaptureStderr();
3920 compile_aidl(options, io);
Jooyung Hanfd3be322020-12-13 09:11:06 +09003921 auto it = expectations.find(lang + "_" + kind);
3922 EXPECT_TRUE(it != expectations.end());
Jooyung Hane87cdd02020-12-11 16:47:35 +09003923 const string err = GetCapturedStderr();
3924 if (it->second.empty()) {
3925 EXPECT_EQ("", err);
3926 } else {
3927 EXPECT_THAT(err, testing::HasSubstr(it->second));
3928 }
3929 }
3930};
3931
3932INSTANTIATE_TEST_SUITE_P(
Jooyung Hanfd3be322020-12-13 09:11:06 +09003933 AidlTestSuite, AidlTypeParamTest,
Jooyung Hane87cdd02020-12-11 16:47:35 +09003934 testing::Combine(testing::Values(Options::Language::CPP, Options::Language::JAVA,
3935 Options::Language::NDK, Options::Language::RUST),
Jooyung Hanfd3be322020-12-13 09:11:06 +09003936 testing::ValuesIn(kTypeParams)),
3937 [](const testing::TestParamInfo<std::tuple<Options::Language, TypeParam>>& info) {
Jooyung Han9435e9a2021-01-06 10:16:31 +09003938 return to_string(std::get<0>(info.param)) + "_" + std::get<1>(info.param).kind;
Jooyung Hane87cdd02020-12-11 16:47:35 +09003939 });
3940
Jooyung Hanfd3be322020-12-13 09:11:06 +09003941TEST_P(AidlTypeParamTest, ListSupportedTypes) {
3942 Run("List<{}>", kListSupportExpectations);
3943}
Jooyung Hane87cdd02020-12-11 16:47:35 +09003944
Jooyung Hand236e552020-12-13 09:21:27 +09003945TEST_P(AidlTypeParamTest, ArraySupportedTypes) {
3946 Run("{}[]", kArraySupportExpectations);
3947}
3948
Christopher Wiley90be4e32015-10-20 14:55:25 -07003949} // namespace aidl
3950} // namespace android