blob: 27bf1948d509c23ff57c7a8a767017d4f2fe48b5 [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"
Jooyung Han93f48f02021-06-05 00:11:16 +090038#include "parser.h"
39#include "preprocess.h"
Christopher Wiley90be4e32015-10-20 14:55:25 -070040#include "tests/fake_io_delegate.h"
Christopher Wiley90be4e32015-10-20 14:55:25 -070041
42using android::aidl::test::FakeIoDelegate;
Christopher Wileyec31a052016-01-25 07:28:51 -080043using android::base::StringPrintf;
Jooyung Han1f14ab32020-10-14 13:48:29 +090044using std::map;
Christopher Wiley12e894a2016-01-29 11:55:07 -080045using std::set;
Christopher Wiley90be4e32015-10-20 14:55:25 -070046using std::string;
47using std::unique_ptr;
Christopher Wiley12e894a2016-01-29 11:55:07 -080048using std::vector;
Jooyung Hanf8dbbcc2020-12-26 03:05:55 +090049using testing::HasSubstr;
Devin Moore7b8d5c92020-03-17 14:14:08 -070050using testing::TestParamInfo;
Jeongik Cha2a5b4d82019-08-06 19:37:59 +090051using testing::internal::CaptureStderr;
52using testing::internal::GetCapturedStderr;
Christopher Wiley90be4e32015-10-20 14:55:25 -070053
54namespace android {
55namespace aidl {
Christopher Wileyf8136192016-04-12 14:19:35 -070056namespace {
57
58const char kExpectedDepFileContents[] =
59R"(place/for/output/p/IFoo.java : \
60 p/IFoo.aidl
61
62p/IFoo.aidl :
63)";
64
Dan Willemsen93298ee2016-11-10 23:55:55 -080065const char kExpectedNinjaDepFileContents[] =
66R"(place/for/output/p/IFoo.java : \
67 p/IFoo.aidl
68)";
69
Jiyong Parkdf202122019-09-30 20:48:35 +090070const char kExpectedParcelableDeclarationDepFileContents[] =
71 R"( : \
72 p/Foo.aidl
73
74p/Foo.aidl :
75)";
76
77const char kExpectedStructuredParcelableDepFileContents[] =
Steven Moreland2a9a7d62019-02-05 16:11:54 -080078 R"(place/for/output/p/Foo.java : \
Christopher Wileyb1bbdf82016-04-21 11:43:45 -070079 p/Foo.aidl
80
81p/Foo.aidl :
82)";
83
Christopher Wileyf8136192016-04-12 14:19:35 -070084} // namespace
Christopher Wiley90be4e32015-10-20 14:55:25 -070085
Devin Moore7b8d5c92020-03-17 14:14:08 -070086class AidlTest : public ::testing::TestWithParam<Options::Language> {
Christopher Wiley90be4e32015-10-20 14:55:25 -070087 protected:
Jeongik Cha047c5ee2019-08-07 23:16:49 +090088 AidlDefinedType* Parse(const string& path, const string& contents, AidlTypenames& typenames_,
89 Options::Language lang, AidlError* error = nullptr,
Steven Moreland1eac5fa2018-08-27 19:35:05 -070090 const vector<string> additional_arguments = {}) {
Christopher Wiley0522cd52015-10-28 15:39:44 -070091 io_delegate_.SetFileContents(path, contents);
Jiyong Parkfbbfa932018-07-30 21:44:10 +090092 vector<string> args;
Devin Moore7b8d5c92020-03-17 14:14:08 -070093 args.emplace_back("aidl");
Jooyung Han9435e9a2021-01-06 10:16:31 +090094 args.emplace_back("--lang=" + to_string(lang));
Steven Moreland1eac5fa2018-08-27 19:35:05 -070095 for (const string& s : additional_arguments) {
96 args.emplace_back(s);
97 }
98 for (const string& f : preprocessed_files_) {
Jiyong Parkfbbfa932018-07-30 21:44:10 +090099 args.emplace_back("--preprocessed=" + f);
100 }
Steven Moreland1eac5fa2018-08-27 19:35:05 -0700101 for (const string& i : import_paths_) {
Jiyong Parkfbbfa932018-07-30 21:44:10 +0900102 args.emplace_back("--include=" + i);
103 }
104 args.emplace_back(path);
105 Options options = Options::From(args);
Jiyong Parkb034bf02018-07-30 17:44:33 +0900106 vector<string> imported_files;
Jooyung Han6529b822021-06-11 22:05:26 +0900107 ImportResolver import_resolver{io_delegate_, path, import_paths_};
Christopher Wiley69b44cf2016-05-03 13:43:33 -0700108 AidlError actual_error = ::android::aidl::internals::load_and_validate_aidl(
Jiyong Park8e79b7f2020-07-20 20:52:38 +0900109 path, options, io_delegate_, &typenames_, &imported_files);
Jiyong Parkb034bf02018-07-30 17:44:33 +0900110
Christopher Wiley69b44cf2016-05-03 13:43:33 -0700111 if (error != nullptr) {
112 *error = actual_error;
113 }
Jiyong Parkb034bf02018-07-30 17:44:33 +0900114
115 if (actual_error != AidlError::OK) {
116 return nullptr;
117 }
118
Jiyong Park8e79b7f2020-07-20 20:52:38 +0900119 const auto& defined_types = typenames_.MainDocument().DefinedTypes();
Jiyong Parkb034bf02018-07-30 17:44:33 +0900120 EXPECT_EQ(1ul, defined_types.size());
121
Jiyong Park8e79b7f2020-07-20 20:52:38 +0900122 return defined_types.front().get();
Christopher Wiley90be4e32015-10-20 14:55:25 -0700123 }
Christopher Wiley0522cd52015-10-28 15:39:44 -0700124
Devin Moore7b8d5c92020-03-17 14:14:08 -0700125 Options::Language GetLanguage() { return GetParam(); }
126
Christopher Wiley0522cd52015-10-28 15:39:44 -0700127 FakeIoDelegate io_delegate_;
Christopher Wiley41544372015-11-03 14:52:29 -0800128 vector<string> preprocessed_files_;
Jiyong Park8c380532018-08-30 14:55:26 +0900129 set<string> import_paths_;
Jeongik Cha047c5ee2019-08-07 23:16:49 +0900130 AidlTypenames typenames_;
Christopher Wiley90be4e32015-10-20 14:55:25 -0700131};
132
Devin Moore7b8d5c92020-03-17 14:14:08 -0700133// Instantiate the AidlTest parameterized suite, calling all of the TEST_P
134// tests with each of the supported languages as a parameter.
135INSTANTIATE_TEST_SUITE_P(AidlTestSuite, AidlTest,
136 testing::Values(Options::Language::CPP, Options::Language::JAVA,
Andrei Homescub62afd92020-05-11 19:24:59 -0700137 Options::Language::NDK, Options::Language::RUST),
Devin Moore7b8d5c92020-03-17 14:14:08 -0700138 [](const testing::TestParamInfo<Options::Language>& info) {
Jooyung Han9435e9a2021-01-06 10:16:31 +0900139 return to_string(info.param);
Devin Moore7b8d5c92020-03-17 14:14:08 -0700140 });
141
142TEST_P(AidlTest, AcceptMissingPackage) {
143 EXPECT_NE(nullptr, Parse("IFoo.aidl", "interface IFoo { }", typenames_, GetLanguage()));
Christopher Wiley90be4e32015-10-20 14:55:25 -0700144}
145
Devin Moore7b8d5c92020-03-17 14:14:08 -0700146TEST_P(AidlTest, EndsInSingleLineComment) {
147 EXPECT_NE(nullptr, Parse("IFoo.aidl", "interface IFoo { } // foo", typenames_, GetLanguage()));
Steven Moreland9c2988f2019-07-17 17:49:10 -0700148}
149
Steven Morelandebc3c5d2020-09-30 23:40:33 +0000150TEST_P(AidlTest, InterfaceRequiresCorrectPath) {
151 const string expected_stderr =
152 "ERROR: a/Foo.aidl:1.11-21: IBar should be declared in a file called a/IBar.aidl\n";
153 const std::string file_contents = "package a; interface IBar {}";
154 CaptureStderr();
155 EXPECT_EQ(nullptr, Parse("a/Foo.aidl", file_contents, typenames_, GetLanguage()));
156 EXPECT_EQ(expected_stderr, GetCapturedStderr()) << file_contents;
157}
158
159TEST_P(AidlTest, ParcelableRequiresCorrectPath) {
160 const string expected_stderr =
161 "ERROR: a/Foo.aidl:1.11-21: Bar should be declared in a file called a/Bar.aidl\n";
162 const std::string file_contents = "package a; interface Bar {}";
163 CaptureStderr();
164 EXPECT_EQ(nullptr, Parse("a/Foo.aidl", file_contents, typenames_, GetLanguage()));
165 EXPECT_EQ(expected_stderr, GetCapturedStderr()) << file_contents;
166}
167
168TEST_P(AidlTest, UnstructuredParcelableRequiresCorrectPath) {
169 const string expected_stderr =
170 "ERROR: a/Foo.aidl:1.22-26: Bar should be declared in a file called a/Bar.aidl\n";
171 const std::string file_contents = "package a; parcelable Bar cpp_header \"anything.h\";";
172 CaptureStderr();
173 EXPECT_EQ(nullptr, Parse("a/Foo.aidl", file_contents, typenames_, GetLanguage()));
174 EXPECT_EQ(expected_stderr, GetCapturedStderr()) << file_contents;
175}
176
177TEST_P(AidlTest, EnumRequiresCorrectPath) {
178 const string expected_stderr =
179 "ERROR: a/Foo.aidl:1.16-20: Bar should be declared in a file called a/Bar.aidl\n";
180 const std::string file_contents = "package a; enum Bar { A, }";
181 CaptureStderr();
182 EXPECT_EQ(nullptr, Parse("a/Foo.aidl", file_contents, typenames_, GetLanguage()));
183 EXPECT_EQ(expected_stderr, GetCapturedStderr()) << file_contents;
184}
185
Devin Moore7b8d5c92020-03-17 14:14:08 -0700186TEST_P(AidlTest, RejectsArraysOfBinders) {
Jiyong Park8c380532018-08-30 14:55:26 +0900187 import_paths_.emplace("");
Christopher Wiley0522cd52015-10-28 15:39:44 -0700188 io_delegate_.SetFileContents("bar/IBar.aidl",
189 "package bar; interface IBar {}");
Devin Moore097a3ab2020-03-11 16:08:44 -0700190 const string path = "foo/IFoo.aidl";
191 const string contents =
192 "package foo;\n"
193 "import bar.IBar;\n"
194 "interface IFoo { void f(in IBar[] input); }";
195 const string expected_stderr = "ERROR: foo/IFoo.aidl:3.27-32: Binder type cannot be an array\n";
196 CaptureStderr();
Devin Moore7b8d5c92020-03-17 14:14:08 -0700197 EXPECT_EQ(nullptr, Parse(path, contents, typenames_, GetLanguage()));
Devin Moore097a3ab2020-03-11 16:08:44 -0700198 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Christopher Wiley0522cd52015-10-28 15:39:44 -0700199}
200
Devin Moore7b8d5c92020-03-17 14:14:08 -0700201TEST_P(AidlTest, SupportOnlyOutParameters) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700202 const string interface_list = "package a; interface IBar { void f(out List<String> bar); }";
Devin Moore7b8d5c92020-03-17 14:14:08 -0700203 EXPECT_NE(nullptr, Parse("a/IBar.aidl", interface_list, typenames_, GetLanguage()));
Jiyong Park40782d02020-07-24 19:17:43 +0900204}
Devin Moore097a3ab2020-03-11 16:08:44 -0700205
Jiyong Park40782d02020-07-24 19:17:43 +0900206TEST_P(AidlTest, RejectOutParametersForIBinder) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700207 const string interface_ibinder = "package a; interface IBaz { void f(out IBinder bar); }";
208 const string expected_ibinder_stderr =
Jooyung Han15fd6c62020-10-23 13:54:46 +0900209 "ERROR: a/IBaz.aidl:1.47-51: 'bar' can't be an out parameter because IBinder can only be an "
210 "in parameter.\n";
Devin Moore097a3ab2020-03-11 16:08:44 -0700211 CaptureStderr();
Devin Moore7b8d5c92020-03-17 14:14:08 -0700212 EXPECT_EQ(nullptr, Parse("a/IBaz.aidl", interface_ibinder, typenames_, GetLanguage()));
Devin Moore097a3ab2020-03-11 16:08:44 -0700213 EXPECT_EQ(expected_ibinder_stderr, GetCapturedStderr());
Jeongik Chaa2080bf2019-06-18 16:44:29 +0900214}
215
Jiyong Park40782d02020-07-24 19:17:43 +0900216TEST_P(AidlTest, RejectsOutParametersInOnewayInterface) {
Jooyung Han020d8d12021-02-26 17:23:02 +0900217 const string oneway_interface = "package a; oneway interface IBar { void f(out int[] bar); }";
Devin Moore097a3ab2020-03-11 16:08:44 -0700218 const string expected_stderr =
219 "ERROR: a/IBar.aidl:1.40-42: oneway method 'f' cannot have out parameters\n";
Devin Moore7b8d5c92020-03-17 14:14:08 -0700220 CaptureStderr();
221 EXPECT_EQ(nullptr, Parse("a/IBar.aidl", oneway_interface, typenames_, GetLanguage()));
222 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Park40782d02020-07-24 19:17:43 +0900223}
Devin Moore7b8d5c92020-03-17 14:14:08 -0700224
Jiyong Park40782d02020-07-24 19:17:43 +0900225TEST_P(AidlTest, RejectsOutParametersInOnewayMethod) {
Jooyung Han020d8d12021-02-26 17:23:02 +0900226 const string oneway_method = "package a; interface IBar { oneway void f(out int[] bar); }";
Jiyong Park40782d02020-07-24 19:17:43 +0900227 const string expected_stderr =
228 "ERROR: a/IBar.aidl:1.40-42: oneway method 'f' cannot have out parameters\n";
Devin Moore097a3ab2020-03-11 16:08:44 -0700229 CaptureStderr();
Devin Moore7b8d5c92020-03-17 14:14:08 -0700230 EXPECT_EQ(nullptr, Parse("a/IBar.aidl", oneway_method, typenames_, GetLanguage()));
Devin Moore097a3ab2020-03-11 16:08:44 -0700231 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Christopher Wiley90be4e32015-10-20 14:55:25 -0700232}
233
Devin Moore7b8d5c92020-03-17 14:14:08 -0700234TEST_P(AidlTest, RejectsOnewayNonVoidReturn) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700235 const string oneway_method = "package a; interface IFoo { oneway int f(); }";
236 const string expected_stderr =
237 "ERROR: a/IFoo.aidl:1.39-41: oneway method 'f' cannot return a value\n";
238 CaptureStderr();
Devin Moore7b8d5c92020-03-17 14:14:08 -0700239 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", oneway_method, typenames_, GetLanguage()));
Devin Moore097a3ab2020-03-11 16:08:44 -0700240 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Christopher Wiley90be4e32015-10-20 14:55:25 -0700241}
242
Devin Moore7b8d5c92020-03-17 14:14:08 -0700243TEST_P(AidlTest, RejectsNullablePrimitive) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700244 const string oneway_method = "package a; interface IFoo { @nullable int f(); }";
245 const string expected_stderr =
246 "ERROR: a/IFoo.aidl:1.38-42: Primitive type cannot get nullable annotation\n";
247 CaptureStderr();
Devin Moore7b8d5c92020-03-17 14:14:08 -0700248 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", oneway_method, typenames_, GetLanguage()));
Devin Moore097a3ab2020-03-11 16:08:44 -0700249 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Casey Dahlin57dbe242015-12-04 11:44:02 -0800250}
251
Devin Moore2f2077a2020-08-28 11:27:53 -0700252TEST_P(AidlTest, AcceptNullableList) {
253 const string oneway_method = "package a; interface IFoo { @nullable List<String> f(); }";
254 const string expected_stderr = "";
255 CaptureStderr();
256 EXPECT_NE(nullptr, Parse("a/IFoo.aidl", oneway_method, typenames_, GetLanguage()));
257 EXPECT_EQ(expected_stderr, GetCapturedStderr());
258}
259
Devin Moore7b8d5c92020-03-17 14:14:08 -0700260TEST_P(AidlTest, RejectsDuplicatedArgumentNames) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700261 const string method = "package a; interface IFoo { void f(int a, int a); }";
262 const string expected_stderr =
263 "ERROR: a/IFoo.aidl:1.33-35: method 'f' has duplicate argument name 'a'\n";
264 CaptureStderr();
Devin Moore7b8d5c92020-03-17 14:14:08 -0700265 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", method, typenames_, GetLanguage()));
Devin Moore097a3ab2020-03-11 16:08:44 -0700266 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Steven Morelandb3cd3c72018-10-11 12:37:45 -0700267}
268
Jeongik Cha13066da2020-08-06 15:43:19 +0900269TEST_P(AidlTest, RejectsDuplicatedFieldNames) {
270 const string method = "package a; parcelable Foo { int a; String a; }";
Jooyung Han59af9cc2020-10-25 21:44:14 +0900271 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 +0900272 CaptureStderr();
273 EXPECT_EQ(nullptr, Parse("a/Foo.aidl", method, typenames_, GetLanguage()));
274 EXPECT_EQ(expected_stderr, GetCapturedStderr());
275}
276
Jooyung Hand902a972020-10-23 17:32:44 +0900277TEST_P(AidlTest, RejectsRepeatedAnnotations) {
278 const string method = R"(@Hide @Hide parcelable Foo {})";
279 const string expected_stderr =
280 "ERROR: Foo.aidl:1.23-27: 'Hide' is repeated, but not allowed. Previous location: "
281 "Foo.aidl:1.1-6\n";
282 CaptureStderr();
283 EXPECT_EQ(nullptr, Parse("Foo.aidl", method, typenames_, GetLanguage()));
284 EXPECT_EQ(expected_stderr, GetCapturedStderr());
285}
286
Jooyung Han05bd8a82021-04-28 23:56:38 +0900287TEST_P(AidlTest, AcceptsEmptyParcelable) {
288 CaptureStderr();
289 EXPECT_NE(nullptr, Parse("Foo.aidl", "parcelable Foo {}", typenames_, GetLanguage()));
290 EXPECT_EQ("", GetCapturedStderr());
291}
292
Devin Moore7b8d5c92020-03-17 14:14:08 -0700293TEST_P(AidlTest, RejectsDuplicatedAnnotationParams) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700294 const string method = "package a; interface IFoo { @UnsupportedAppUsage(foo=1, foo=2)void f(); }";
295 const string expected_stderr = "ERROR: a/IFoo.aidl:1.56-62: Trying to redefine parameter foo.\n";
296 CaptureStderr();
Devin Moore7b8d5c92020-03-17 14:14:08 -0700297 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", method, typenames_, GetLanguage()));
Devin Moore097a3ab2020-03-11 16:08:44 -0700298 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Andrei Onea9445fc62019-06-27 18:11:59 +0100299}
300
Devin Moore7b8d5c92020-03-17 14:14:08 -0700301TEST_P(AidlTest, RejectUnsupportedInterfaceAnnotations) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700302 AidlError error;
303 const string method = "package a; @nullable interface IFoo { int f(); }";
Devin Moorec054bf82020-03-10 16:31:48 -0700304 CaptureStderr();
Devin Moore7b8d5c92020-03-17 14:14:08 -0700305 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", method, typenames_, GetLanguage(), &error));
Jooyung Han2d6b5c42021-01-09 01:01:06 +0900306 EXPECT_THAT(GetCapturedStderr(), HasSubstr("@nullable is not available."));
Devin Moorec054bf82020-03-10 16:31:48 -0700307 EXPECT_EQ(AidlError::BAD_TYPE, error);
Devin Moore24f68572020-02-26 13:20:59 -0800308}
309
Devin Moore7b8d5c92020-03-17 14:14:08 -0700310TEST_P(AidlTest, RejectUnsupportedTypeAnnotations) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700311 AidlError error;
312 const string method = "package a; interface IFoo { @JavaOnlyStableParcelable int f(); }";
Devin Moorec054bf82020-03-10 16:31:48 -0700313 CaptureStderr();
Devin Moore7b8d5c92020-03-17 14:14:08 -0700314 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", method, typenames_, GetLanguage(), &error));
Jooyung Han2d6b5c42021-01-09 01:01:06 +0900315 EXPECT_THAT(GetCapturedStderr(), HasSubstr("@JavaOnlyStableParcelable is not available."));
Devin Moorec054bf82020-03-10 16:31:48 -0700316 EXPECT_EQ(AidlError::BAD_TYPE, error);
Devin Moore24f68572020-02-26 13:20:59 -0800317}
318
Devin Moore7b8d5c92020-03-17 14:14:08 -0700319TEST_P(AidlTest, RejectUnsupportedParcelableAnnotations) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700320 AidlError error;
321 const string method = "package a; @nullable parcelable IFoo cpp_header \"IFoo.h\";";
Devin Moorec054bf82020-03-10 16:31:48 -0700322 CaptureStderr();
Steven Morelandebc3c5d2020-09-30 23:40:33 +0000323 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", method, typenames_, GetLanguage(), &error));
Jooyung Han2d6b5c42021-01-09 01:01:06 +0900324 EXPECT_THAT(GetCapturedStderr(), HasSubstr("@nullable is not available."));
Devin Moorec054bf82020-03-10 16:31:48 -0700325 EXPECT_EQ(AidlError::BAD_TYPE, error);
Devin Moore24f68572020-02-26 13:20:59 -0800326}
327
Devin Moore7b8d5c92020-03-17 14:14:08 -0700328TEST_P(AidlTest, RejectUnsupportedParcelableDefineAnnotations) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700329 AidlError error;
Steven Morelandebc3c5d2020-09-30 23:40:33 +0000330 const string method = "package a; @nullable parcelable IFoo { String a; String b; }";
Devin Moorec054bf82020-03-10 16:31:48 -0700331 CaptureStderr();
Steven Morelandebc3c5d2020-09-30 23:40:33 +0000332 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", method, typenames_, GetLanguage(), &error));
Jooyung Han2d6b5c42021-01-09 01:01:06 +0900333 EXPECT_THAT(GetCapturedStderr(), HasSubstr("@nullable is not available."));
Devin Moorec054bf82020-03-10 16:31:48 -0700334 EXPECT_EQ(AidlError::BAD_TYPE, error);
Devin Moore24f68572020-02-26 13:20:59 -0800335}
336
Jiyong Park40782d02020-07-24 19:17:43 +0900337TEST_P(AidlTest, ParsesNonNullableAnnotation) {
338 auto parse_result =
339 Parse("a/IFoo.aidl", "package a; interface IFoo { String f(); }", typenames_, GetLanguage());
340 ASSERT_NE(nullptr, parse_result);
341 const AidlInterface* interface = parse_result->AsInterface();
342 ASSERT_NE(nullptr, interface);
343 ASSERT_FALSE(interface->GetMethods().empty());
344 EXPECT_FALSE(interface->GetMethods()[0]->GetType().IsNullable());
345}
346
Devin Moore7b8d5c92020-03-17 14:14:08 -0700347TEST_P(AidlTest, ParsesNullableAnnotation) {
Jiyong Park40782d02020-07-24 19:17:43 +0900348 auto parse_result = Parse("a/IFoo.aidl", "package a; interface IFoo { @nullable String f(); }",
349 typenames_, GetLanguage());
350 ASSERT_NE(nullptr, parse_result);
351 const AidlInterface* interface = parse_result->AsInterface();
352 ASSERT_NE(nullptr, interface);
353 ASSERT_FALSE(interface->GetMethods().empty());
354 EXPECT_TRUE(interface->GetMethods()[0]->GetType().IsNullable());
355}
356
357TEST_P(AidlTest, ParsesNonUtf8Annotations) {
358 auto parse_result =
359 Parse("a/IFoo.aidl", "package a; interface IFoo { String f(); }", typenames_, GetLanguage());
360 ASSERT_NE(nullptr, parse_result);
361 const AidlInterface* interface = parse_result->AsInterface();
362 ASSERT_NE(nullptr, interface);
363 ASSERT_FALSE(interface->GetMethods().empty());
364 EXPECT_FALSE(interface->GetMethods()[0]->GetType().IsUtf8InCpp());
Christopher Wileyec31a052016-01-25 07:28:51 -0800365}
366
Devin Moore7b8d5c92020-03-17 14:14:08 -0700367TEST_P(AidlTest, ParsesUtf8Annotations) {
Jiyong Park40782d02020-07-24 19:17:43 +0900368 auto parse_result = Parse("a/IFoo.aidl", "package a; interface IFoo { @utf8InCpp String f(); }",
369 typenames_, GetLanguage());
370 ASSERT_NE(nullptr, parse_result);
371 const AidlInterface* interface = parse_result->AsInterface();
372 ASSERT_NE(nullptr, interface);
373 ASSERT_FALSE(interface->GetMethods().empty());
374 EXPECT_TRUE(interface->GetMethods()[0]->GetType().IsUtf8InCpp());
Christopher Wileyec31a052016-01-25 07:28:51 -0800375}
376
Devin Moore7b8d5c92020-03-17 14:14:08 -0700377TEST_P(AidlTest, VintfRequiresStructuredAndStability) {
Steven Morelanda57d0a62019-07-30 09:41:14 -0700378 AidlError error;
Devin Moore0d0e3f62020-03-30 17:45:39 -0700379 const string expected_stderr =
380 "ERROR: IFoo.aidl:1.16-26: Must compile @VintfStability type w/ aidl_interface 'stability: "
381 "\"vintf\"'\n"
382 "ERROR: IFoo.aidl:1.16-26: Must compile @VintfStability type w/ aidl_interface "
383 "--structured\n";
384 CaptureStderr();
Devin Moore097a3ab2020-03-11 16:08:44 -0700385 ASSERT_EQ(nullptr, Parse("IFoo.aidl", "@VintfStability interface IFoo {}", typenames_,
Devin Moore7b8d5c92020-03-17 14:14:08 -0700386 GetLanguage(), &error));
Devin Moore0d0e3f62020-03-30 17:45:39 -0700387 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Steven Morelanda57d0a62019-07-30 09:41:14 -0700388 ASSERT_EQ(AidlError::NOT_STRUCTURED, error);
Steven Morelanda57d0a62019-07-30 09:41:14 -0700389}
390
Devin Moore7b8d5c92020-03-17 14:14:08 -0700391TEST_P(AidlTest, VintfRequiresStructured) {
Steven Morelanda57d0a62019-07-30 09:41:14 -0700392 AidlError error;
Devin Moore0d0e3f62020-03-30 17:45:39 -0700393 const string expected_stderr =
394 "ERROR: IFoo.aidl:1.16-26: Must compile @VintfStability type w/ aidl_interface "
395 "--structured\n";
396 CaptureStderr();
Devin Moore097a3ab2020-03-11 16:08:44 -0700397 ASSERT_EQ(nullptr, Parse("IFoo.aidl", "@VintfStability interface IFoo {}", typenames_,
Devin Moore7b8d5c92020-03-17 14:14:08 -0700398 GetLanguage(), &error, {"--stability", "vintf"}));
Devin Moore0d0e3f62020-03-30 17:45:39 -0700399 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Steven Morelanda57d0a62019-07-30 09:41:14 -0700400 ASSERT_EQ(AidlError::NOT_STRUCTURED, error);
Steven Morelanda57d0a62019-07-30 09:41:14 -0700401}
402
Devin Moore7b8d5c92020-03-17 14:14:08 -0700403TEST_P(AidlTest, VintfRequiresSpecifiedStability) {
Steven Morelanda57d0a62019-07-30 09:41:14 -0700404 AidlError error;
Devin Moore097a3ab2020-03-11 16:08:44 -0700405 const string expected_stderr =
406 "ERROR: IFoo.aidl:1.16-26: Must compile @VintfStability type w/ aidl_interface 'stability: "
407 "\"vintf\"'\n";
408 CaptureStderr();
409 ASSERT_EQ(nullptr, Parse("IFoo.aidl", "@VintfStability interface IFoo {}", typenames_,
Devin Moore7b8d5c92020-03-17 14:14:08 -0700410 GetLanguage(), &error, {"--structured"}));
Devin Moore097a3ab2020-03-11 16:08:44 -0700411 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Steven Morelanda57d0a62019-07-30 09:41:14 -0700412 ASSERT_EQ(AidlError::NOT_STRUCTURED, error);
Steven Morelanda57d0a62019-07-30 09:41:14 -0700413}
414
Devin Moore7b8d5c92020-03-17 14:14:08 -0700415TEST_P(AidlTest, ParsesStabilityAnnotations) {
Steven Morelanda57d0a62019-07-30 09:41:14 -0700416 AidlError error;
Devin Moore7b8d5c92020-03-17 14:14:08 -0700417 auto parse_result = Parse("IFoo.aidl", "@VintfStability interface IFoo {}", typenames_,
418 GetLanguage(), &error, {"--structured", "--stability", "vintf"});
Steven Morelanda57d0a62019-07-30 09:41:14 -0700419 ASSERT_EQ(AidlError::OK, error);
420 ASSERT_NE(nullptr, parse_result);
421 const AidlInterface* interface = parse_result->AsInterface();
422 ASSERT_NE(nullptr, interface);
423 ASSERT_TRUE(interface->IsVintfStability());
Steven Morelanda57d0a62019-07-30 09:41:14 -0700424}
425
Jeongik Cha64783ed2019-06-07 18:30:54 +0900426TEST_F(AidlTest, ParsesJavaOnlyStableParcelable) {
427 Options java_options = Options::From("aidl -o out --structured a/Foo.aidl");
Jeongik Cha88f95a82020-01-15 13:02:16 +0900428 Options cpp_options = Options::From("aidl --lang=cpp -o out -h out/include a/Foo.aidl");
429 Options cpp_structured_options =
Jeongik Cha64783ed2019-06-07 18:30:54 +0900430 Options::From("aidl --lang=cpp --structured -o out -h out/include a/Foo.aidl");
Andrei Homescub62afd92020-05-11 19:24:59 -0700431 Options rust_options = Options::From("aidl --lang=rust -o out --structured a/Foo.aidl");
Jeongik Cha64783ed2019-06-07 18:30:54 +0900432 io_delegate_.SetFileContents(
Jeongik Cha88f95a82020-01-15 13:02:16 +0900433 "a/Foo.aidl",
434 StringPrintf("package a; @JavaOnlyStableParcelable parcelable Foo cpp_header \"Foo.h\" ;"));
Jeongik Cha64783ed2019-06-07 18:30:54 +0900435
436 EXPECT_EQ(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
Jeongik Cha88f95a82020-01-15 13:02:16 +0900437 EXPECT_EQ(0, ::android::aidl::compile_aidl(cpp_options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -0700438 const string expected_stderr =
Jeongik Cha88f95a82020-01-15 13:02:16 +0900439 "ERROR: a/Foo.aidl:1.48-52: Cannot declared parcelable in a --structured interface. "
Devin Moorec054bf82020-03-10 16:31:48 -0700440 "Parcelable must be defined in AIDL directly.\n";
441 CaptureStderr();
Jeongik Cha88f95a82020-01-15 13:02:16 +0900442 EXPECT_NE(0, ::android::aidl::compile_aidl(cpp_structured_options, io_delegate_));
Devin Moorec054bf82020-03-10 16:31:48 -0700443 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Andrei Homescub62afd92020-05-11 19:24:59 -0700444
445 CaptureStderr();
446 EXPECT_NE(0, ::android::aidl::compile_aidl(rust_options, io_delegate_));
447 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jeongik Cha64783ed2019-06-07 18:30:54 +0900448}
449
Jooyung Han1cbc4962020-10-25 10:07:15 +0900450TEST_F(AidlTest, ParcelableSupportJavaDeriveToString) {
451 io_delegate_.SetFileContents("a/Foo.aidl", R"(package a;
452 @JavaDerive(toString=true) parcelable Foo { int a; float b; })");
453 Options java_options = Options::From("aidl --lang=java -o out a/Foo.aidl");
Jiyong Park43113fb2020-07-20 16:26:19 +0900454 EXPECT_EQ(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
455
456 string java_out;
Jooyung Han1cbc4962020-10-25 10:07:15 +0900457 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/Foo.java", &java_out));
Jiyong Park43113fb2020-07-20 16:26:19 +0900458 EXPECT_THAT(java_out, testing::HasSubstr("public String toString() {"));
459
460 // Other backends shouldn't be bothered
Jooyung Han1cbc4962020-10-25 10:07:15 +0900461 Options cpp_options = Options::From("aidl --lang=cpp -o out -h out a/Foo.aidl");
Jiyong Park43113fb2020-07-20 16:26:19 +0900462 EXPECT_EQ(0, ::android::aidl::compile_aidl(cpp_options, io_delegate_));
463
Jooyung Han1cbc4962020-10-25 10:07:15 +0900464 Options ndk_options = Options::From("aidl --lang=ndk -o out -h out a/Foo.aidl");
Jiyong Park43113fb2020-07-20 16:26:19 +0900465 EXPECT_EQ(0, ::android::aidl::compile_aidl(ndk_options, io_delegate_));
466}
467
Jooyung Han1cbc4962020-10-25 10:07:15 +0900468TEST_F(AidlTest, UnionSupportJavaDeriveToString) {
469 io_delegate_.SetFileContents("a/Foo.aidl", R"(package a;
470 @JavaDerive(toString=true) union Foo { int a; int[] b; })");
471 CaptureStderr();
472 Options java_options = Options::From("aidl --lang=java -o out a/Foo.aidl");
473 EXPECT_EQ(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
474 EXPECT_EQ("", GetCapturedStderr());
475
476 const string expected_to_string_method = R"--(
477 @Override
478 public String toString() {
479 switch (_tag) {
480 case a: return "a.Foo.a(" + (getA()) + ")";
481 case b: return "a.Foo.b(" + (java.util.Arrays.toString(getB())) + ")";
482 }
483 throw new IllegalStateException("unknown field: " + _tag);
484 }
485)--";
486
487 string java_out;
488 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/Foo.java", &java_out));
489 EXPECT_THAT(java_out, testing::HasSubstr(expected_to_string_method));
490}
491
Jiyong Park9aa3d042020-12-04 23:30:02 +0900492TEST_F(AidlTest, ParcelableSupportJavaDeriveEquals) {
493 io_delegate_.SetFileContents("a/Foo.aidl", R"(package a;
494 @JavaDerive(equals=true) parcelable Foo { int a; float b; })");
495 CaptureStderr();
496 Options java_options = Options::From("aidl --lang=java -o out a/Foo.aidl");
497 EXPECT_EQ(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
498 EXPECT_EQ("", GetCapturedStderr());
499
500 const std::string expected = R"--(
501 @Override
502 public boolean equals(Object other) {
503 if (this == other) return true;
504 if (other == null) return false;
505 if (!(other instanceof Foo)) return false;
506 Foo that = (Foo)other;
507 if (!java.util.Objects.deepEquals(a, that.a)) return false;
508 if (!java.util.Objects.deepEquals(b, that.b)) return false;
509 return true;
510 }
511
512 @Override
513 public int hashCode() {
514 return java.util.Arrays.deepHashCode(java.util.Arrays.asList(a, b).toArray());
515 }
516)--";
517
518 string java_out;
519 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/Foo.java", &java_out));
520 EXPECT_THAT(java_out, testing::HasSubstr(expected));
521}
522
523TEST_F(AidlTest, UnionSupportJavaDeriveEquals) {
524 io_delegate_.SetFileContents("a/Foo.aidl", R"(package a;
525 @JavaDerive(equals=true) union Foo { int a; int[] b; })");
526 CaptureStderr();
527 Options java_options = Options::From("aidl --lang=java -o out a/Foo.aidl");
528 EXPECT_EQ(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
529 EXPECT_EQ("", GetCapturedStderr());
530
531 const std::string expected = R"--(
532 @Override
533 public boolean equals(Object other) {
534 if (this == other) return true;
535 if (other == null) return false;
536 if (!(other instanceof Foo)) return false;
537 Foo that = (Foo)other;
538 if (_tag != that._tag) return false;
539 if (!java.util.Objects.deepEquals(_value, that._value)) return false;
540 return true;
541 }
542
543 @Override
544 public int hashCode() {
545 return java.util.Arrays.deepHashCode(java.util.Arrays.asList(_tag, _value).toArray());
546 }
547)--";
548
549 string java_out;
550 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/Foo.java", &java_out));
551 EXPECT_THAT(java_out, testing::HasSubstr(expected));
552}
553
Jooyung Han90345002020-10-23 15:28:53 +0900554TEST_F(AidlTest, RejectsJavaDeriveAnnotation) {
Jiyong Park43113fb2020-07-20 16:26:19 +0900555 {
Jooyung Han90345002020-10-23 15:28:53 +0900556 io_delegate_.SetFileContents("a/Foo.aidl",
557 "package a; @JavaDerive(blah=true) parcelable Foo{}");
558 Options java_options = Options::From("aidl --lang=java -o out a/Foo.aidl");
559 CaptureStderr();
560 EXPECT_NE(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
561 const std::string expected_stderr =
562 "ERROR: a/Foo.aidl:1.11-34: Parameter blah not supported for annotation JavaDerive.";
Jooyung Hanf8dbbcc2020-12-26 03:05:55 +0900563 EXPECT_THAT(GetCapturedStderr(),
564 HasSubstr("Parameter blah not supported for annotation JavaDerive."));
Jooyung Han90345002020-10-23 15:28:53 +0900565 }
566
567 {
568 io_delegate_.SetFileContents("a/IFoo.aidl", "package a; @JavaDerive interface IFoo{}");
Jiyong Park43113fb2020-07-20 16:26:19 +0900569 Options java_options = Options::From("aidl --lang=java -o out a/IFoo.aidl");
570 CaptureStderr();
571 EXPECT_NE(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
Jooyung Han2d6b5c42021-01-09 01:01:06 +0900572 EXPECT_THAT(GetCapturedStderr(), HasSubstr("@JavaDerive is not available."));
Jiyong Park43113fb2020-07-20 16:26:19 +0900573 }
574
575 {
Jooyung Han90345002020-10-23 15:28:53 +0900576 io_delegate_.SetFileContents("a/IFoo.aidl", "package a; @JavaDerive enum IFoo { A=1, }");
Jiyong Park43113fb2020-07-20 16:26:19 +0900577 Options java_options = Options::From("aidl --lang=java -o out a/IFoo.aidl");
578 CaptureStderr();
579 EXPECT_NE(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
Jooyung Han2d6b5c42021-01-09 01:01:06 +0900580 EXPECT_THAT(GetCapturedStderr(), HasSubstr("@JavaDerive is not available."));
Jiyong Park43113fb2020-07-20 16:26:19 +0900581 }
582}
583
Jiyong Park27fd7fd2020-08-27 16:25:09 +0900584TEST_P(AidlTest, ParseDescriptorAnnotation) {
585 AidlError error;
586 auto parse_result = Parse("IFoo.aidl", R"(@Descriptor(value="IBar") interface IFoo{})",
587 typenames_, GetLanguage(), &error, {"--structured"});
588 ASSERT_EQ(AidlError::OK, error);
589 ASSERT_NE(nullptr, parse_result);
590 const AidlInterface* interface = parse_result->AsInterface();
591 ASSERT_NE(nullptr, interface);
592 ASSERT_EQ("IBar", interface->GetDescriptor());
593}
594
Jiyong Park40782d02020-07-24 19:17:43 +0900595TEST_P(AidlTest, AcceptsOnewayMethod) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700596 const string oneway_method = "package a; interface IFoo { oneway void f(int a); }";
Devin Moore7b8d5c92020-03-17 14:14:08 -0700597 EXPECT_NE(nullptr, Parse("a/IFoo.aidl", oneway_method, typenames_, GetLanguage()));
Jiyong Park40782d02020-07-24 19:17:43 +0900598}
599
600TEST_P(AidlTest, AcceptsOnewayInterface) {
601 const string oneway_interface = "package a; oneway interface IBar { void f(int a); }";
Devin Moore7b8d5c92020-03-17 14:14:08 -0700602 EXPECT_NE(nullptr, Parse("a/IBar.aidl", oneway_interface, typenames_, GetLanguage()));
Christopher Wiley90be4e32015-10-20 14:55:25 -0700603}
Christopher Wileyef140932015-11-03 09:29:19 -0800604
Devin Moore7b8d5c92020-03-17 14:14:08 -0700605TEST_P(AidlTest, AcceptsAnnotatedOnewayMethod) {
Devin Moore097a3ab2020-03-11 16:08:44 -0700606 const string oneway_method =
607 "package a; interface IFoo { @UnsupportedAppUsage oneway void f(int a); }";
Devin Moore7b8d5c92020-03-17 14:14:08 -0700608 EXPECT_NE(nullptr, Parse("a/IFoo.aidl", oneway_method, typenames_, GetLanguage()));
Artur Satayev91fe8712019-07-29 13:06:01 +0100609}
610
Steven Moreland65297cc2020-04-20 20:17:36 -0700611TEST_P(AidlTest, AnnotationsInMultiplePlaces) {
612 const string oneway_method =
613 "package a; interface IFoo { @UnsupportedAppUsage oneway @Hide void f(int a); }";
614 const AidlDefinedType* defined = Parse("a/IFoo.aidl", oneway_method, typenames_, GetLanguage());
615 ASSERT_NE(nullptr, defined);
616 const AidlInterface* iface = defined->AsInterface();
617 ASSERT_NE(nullptr, iface);
618
619 const auto& methods = iface->GetMethods();
620 ASSERT_EQ(1u, methods.size());
621 const auto& method = methods[0];
622 const AidlTypeSpecifier& ret_type = method->GetType();
623
624 // TODO(b/151102494): these annotations should be on the method
625 ASSERT_NE(nullptr, ret_type.UnsupportedAppUsage());
626 ASSERT_TRUE(ret_type.IsHide());
627}
628
Devin Moore7b8d5c92020-03-17 14:14:08 -0700629TEST_P(AidlTest, WritesComments) {
Artur Satayev91fe8712019-07-29 13:06:01 +0100630 string foo_interface =
Jooyung Han8451a202021-01-16 03:07:06 +0900631 R"(package a;
632 /* foo */
633 interface IFoo {
634 /* i */
635 int i();
636 // j
637 @nullable String j();
638 // k1
639 /* k2 */
640 @UnsupportedAppUsage oneway void k(int a);
641 })";
Artur Satayev91fe8712019-07-29 13:06:01 +0100642
Jooyung Han8451a202021-01-16 03:07:06 +0900643 CaptureStderr();
Devin Moore7b8d5c92020-03-17 14:14:08 -0700644 auto parse_result = Parse("a/IFoo.aidl", foo_interface, typenames_, GetLanguage());
Artur Satayev91fe8712019-07-29 13:06:01 +0100645 EXPECT_NE(nullptr, parse_result);
Jooyung Han8451a202021-01-16 03:07:06 +0900646 EXPECT_EQ("", GetCapturedStderr());
647
Jooyung Han161bb0f2021-01-21 12:30:16 +0900648 EXPECT_EQ((Comments{{"/* foo */"}}), parse_result->GetComments());
Artur Satayev91fe8712019-07-29 13:06:01 +0100649
650 const AidlInterface* interface = parse_result->AsInterface();
Jooyung Han161bb0f2021-01-21 12:30:16 +0900651 EXPECT_EQ((Comments{{"/* i */"}}), interface->GetMethods()[0]->GetComments());
652 EXPECT_EQ((Comments{{"// j\n"}}), interface->GetMethods()[1]->GetComments());
653 EXPECT_EQ((Comments{{"// k1\n"}, {"/* k2 */"}}), interface->GetMethods()[2]->GetComments());
Artur Satayev91fe8712019-07-29 13:06:01 +0100654}
655
Jooyung Han1a551d32020-10-05 15:37:26 +0900656TEST_P(AidlTest, CppHeaderCanBeIdentifierAsWell) {
657 io_delegate_.SetFileContents("p/cpp_header.aidl",
658 R"(package p;
659 parcelable cpp_header cpp_header "bar/header";)");
660 import_paths_.emplace("");
661 const string input_path = "p/IFoo.aidl";
662 const string input = R"(package p;
663 import p.cpp_header;
664 interface IFoo {
665 // get bar
666 cpp_header get();
667 })";
668
669 auto parse_result = Parse(input_path, input, typenames_, GetLanguage());
670 EXPECT_NE(nullptr, parse_result);
671 const AidlInterface* interface = parse_result->AsInterface();
Jooyung Han161bb0f2021-01-21 12:30:16 +0900672 EXPECT_EQ((Comments{{"// get bar\n"}}), interface->GetMethods()[0]->GetComments());
Jooyung Han1a551d32020-10-05 15:37:26 +0900673}
674
Christopher Wileyef140932015-11-03 09:29:19 -0800675TEST_F(AidlTest, ParsesPreprocessedFile) {
676 string simple_content = "parcelable a.Foo;\ninterface b.IBar;";
677 io_delegate_.SetFileContents("path", simple_content);
Steven Morelandcb1bcd72020-04-29 16:30:35 -0700678 EXPECT_FALSE(typenames_.ResolveTypename("a.Foo").is_resolved);
Jooyung Han93f48f02021-06-05 00:11:16 +0900679 EXPECT_TRUE(Parser::Parse("path", io_delegate_, typenames_, /*is_preprocessed=*/true));
Steven Morelandcb1bcd72020-04-29 16:30:35 -0700680 EXPECT_TRUE(typenames_.ResolveTypename("a.Foo").is_resolved);
681 EXPECT_TRUE(typenames_.ResolveTypename("b.IBar").is_resolved);
Christopher Wileyef140932015-11-03 09:29:19 -0800682}
683
684TEST_F(AidlTest, ParsesPreprocessedFileWithWhitespace) {
685 string simple_content = "parcelable a.Foo;\n interface b.IBar ;\t";
686 io_delegate_.SetFileContents("path", simple_content);
Jeongik Cha047c5ee2019-08-07 23:16:49 +0900687
Steven Morelandcb1bcd72020-04-29 16:30:35 -0700688 EXPECT_FALSE(typenames_.ResolveTypename("a.Foo").is_resolved);
Jooyung Han93f48f02021-06-05 00:11:16 +0900689 EXPECT_TRUE(Parser::Parse("path", io_delegate_, typenames_, /*is_preprocessed=*/true));
Steven Morelandcb1bcd72020-04-29 16:30:35 -0700690 EXPECT_TRUE(typenames_.ResolveTypename("a.Foo").is_resolved);
691 EXPECT_TRUE(typenames_.ResolveTypename("b.IBar").is_resolved);
Christopher Wileyef140932015-11-03 09:29:19 -0800692}
693
Devin Moore7b8d5c92020-03-17 14:14:08 -0700694TEST_P(AidlTest, PreferImportToPreprocessed) {
Christopher Wiley41544372015-11-03 14:52:29 -0800695 io_delegate_.SetFileContents("preprocessed", "interface another.IBar;");
696 io_delegate_.SetFileContents("one/IBar.aidl", "package one; "
697 "interface IBar {}");
698 preprocessed_files_.push_back("preprocessed");
Jiyong Park8c380532018-08-30 14:55:26 +0900699 import_paths_.emplace("");
Jeongik Cha047c5ee2019-08-07 23:16:49 +0900700 auto parse_result = Parse("p/IFoo.aidl", "package p; import one.IBar; interface IFoo {}",
Devin Moore7b8d5c92020-03-17 14:14:08 -0700701 typenames_, GetLanguage());
Christopher Wiley41544372015-11-03 14:52:29 -0800702 EXPECT_NE(nullptr, parse_result);
Jeongik Cha047c5ee2019-08-07 23:16:49 +0900703
Christopher Wiley41544372015-11-03 14:52:29 -0800704 // We expect to know about both kinds of IBar
Steven Morelandcb1bcd72020-04-29 16:30:35 -0700705 EXPECT_TRUE(typenames_.ResolveTypename("one.IBar").is_resolved);
706 EXPECT_TRUE(typenames_.ResolveTypename("another.IBar").is_resolved);
Christopher Wiley41544372015-11-03 14:52:29 -0800707 // But if we request just "IBar" we should get our imported one.
Jooyung Han8451a202021-01-16 03:07:06 +0900708 AidlTypeSpecifier ambiguous_type(AIDL_LOCATION_HERE, "IBar", false, nullptr, {});
Jooyung Han13f1fa52021-06-11 18:06:12 +0900709 ambiguous_type.Resolve(typenames_, parse_result);
Jeongik Cha047c5ee2019-08-07 23:16:49 +0900710 EXPECT_EQ("one.IBar", ambiguous_type.GetName());
Christopher Wiley41544372015-11-03 14:52:29 -0800711}
712
Jiyong Park8f6ec462020-01-19 20:52:47 +0900713// Special case of PreferImportToPreprocessed. Imported type should be preferred
714// even when the preprocessed file already has the same type.
Devin Moore7b8d5c92020-03-17 14:14:08 -0700715TEST_P(AidlTest, B147918827) {
Jiyong Park8f6ec462020-01-19 20:52:47 +0900716 io_delegate_.SetFileContents("preprocessed", "interface another.IBar;\ninterface one.IBar;");
717 io_delegate_.SetFileContents("one/IBar.aidl",
718 "package one; "
719 "interface IBar {}");
720 preprocessed_files_.push_back("preprocessed");
721 import_paths_.emplace("");
722 auto parse_result = Parse("p/IFoo.aidl", "package p; import one.IBar; interface IFoo {}",
Devin Moore7b8d5c92020-03-17 14:14:08 -0700723 typenames_, GetLanguage());
Jiyong Park8f6ec462020-01-19 20:52:47 +0900724 EXPECT_NE(nullptr, parse_result);
725
726 // We expect to know about both kinds of IBar
Steven Morelandcb1bcd72020-04-29 16:30:35 -0700727 EXPECT_TRUE(typenames_.ResolveTypename("one.IBar").is_resolved);
728 EXPECT_TRUE(typenames_.ResolveTypename("another.IBar").is_resolved);
Jiyong Park8f6ec462020-01-19 20:52:47 +0900729 // But if we request just "IBar" we should get our imported one.
Jooyung Han8451a202021-01-16 03:07:06 +0900730 AidlTypeSpecifier ambiguous_type(AIDL_LOCATION_HERE, "IBar", false, nullptr, {});
Jooyung Han13f1fa52021-06-11 18:06:12 +0900731 ambiguous_type.Resolve(typenames_, parse_result);
Jiyong Park8f6ec462020-01-19 20:52:47 +0900732 EXPECT_EQ("one.IBar", ambiguous_type.GetName());
733}
734
Casey Dahlinc1f39b42015-11-24 10:34:34 -0800735TEST_F(AidlTest, WritePreprocessedFile) {
736 io_delegate_.SetFileContents("p/Outer.aidl",
737 "package p; parcelable Outer.Inner;");
738 io_delegate_.SetFileContents("one/IBar.aidl", "package one; import p.Outer;"
739 "interface IBar {}");
740
Jooyung Han93f48f02021-06-05 00:11:16 +0900741 vector<string> args{"aidl", "--preprocess", "preprocessed",
742 "-I.", "p/Outer.aidl", "one/IBar.aidl"};
Jiyong Park6f77e0c2018-07-28 16:55:44 +0900743 Options options = Options::From(args);
Jooyung Han93f48f02021-06-05 00:11:16 +0900744 EXPECT_TRUE(::android::aidl::Preprocess(options, io_delegate_));
Casey Dahlinc1f39b42015-11-24 10:34:34 -0800745
Jooyung Han93f48f02021-06-05 00:11:16 +0900746 std::map<std::string, std::string> expected = {{"preprocessed",
747 "parcelable p.Outer.Inner;\n"
748 "interface one.IBar {\n"
749 "}\n"}};
750 EXPECT_THAT(io_delegate_.OutputFiles(), testing::Eq(expected));
751}
752
753TEST_F(AidlTest, PreprocessVariousThings) {
754 io_delegate_.SetFileContents("foo/bar/IFoo.aidl",
755 "package foo.bar;\n"
756 "interface IFoo {\n"
757 " int foo();\n"
758 " const int FOO = foo.bar.Bar.BAR + 1; // should be 44\n"
759 "}\n");
760 io_delegate_.SetFileContents("foo/bar/Bar.aidl",
761 "package foo.bar;\n"
762 "parcelable Bar {\n"
763 " const int BAR = imported.Foo.FOO + 1; // should be 43\n"
764 " imported.Foo foo;\n"
765 "}\n");
766 io_delegate_.SetFileContents("foo/bar/Gen.aidl",
767 "package foo.bar;\n"
768 "parcelable Gen<T> {\n"
769 "}\n");
770 io_delegate_.SetFileContents("foo/bar/Enum.aidl",
771 "package foo.bar;\n"
772 "enum Enum {\n"
773 " FOO = 3, BAR = FOO + 3, // should be 3, 6\n"
774 "}\n");
775 io_delegate_.SetFileContents("sub/imported/Foo.aidl",
776 "package imported;\n"
777 "parcelable Foo {\n"
778 " const int FOO = 42;\n"
779 "}\n");
780
781 vector<string> args = {
782 "aidl",
783 "--preprocess",
784 "preprocessed",
785 "-Isub",
786 "-I.",
787 "foo/bar/IFoo.aidl",
788 "foo/bar/Bar.aidl",
789 "foo/bar/Gen.aidl",
790 "foo/bar/Enum.aidl",
791 };
792 ASSERT_TRUE(Preprocess(Options::From(args), io_delegate_));
793 std::string preprocessed =
794 "interface foo.bar.IFoo {\n"
795 " const int FOO = 44;\n"
796 "}\n"
797 "parcelable foo.bar.Bar {\n"
798 " const int BAR = 43;\n"
799 "}\n"
800 "parcelable foo.bar.Gen<T> {\n"
801 "}\n"
802 "enum foo.bar.Enum {\n"
803 " FOO = 3,\n"
804 " BAR = 6,\n"
805 "}\n";
806 std::map<std::string, std::string> expected = {{"preprocessed", preprocessed}};
807 EXPECT_THAT(io_delegate_.OutputFiles(), testing::Eq(expected));
808
809 // use preprocessed
810 io_delegate_.SetFileContents("a/Foo.aidl",
811 "package a; parcelable Foo { const int y = foo.bar.Bar.BAR; }");
812 io_delegate_.SetFileContents("preprocessed", preprocessed);
813 CaptureStderr();
814 auto options = Options::From("aidl --lang java -o out a/Foo.aidl -ppreprocessed");
815 EXPECT_EQ(0, aidl::compile_aidl(options, io_delegate_));
816 EXPECT_EQ("", GetCapturedStderr());
817 string code;
818 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/Foo.java", &code));
819 EXPECT_THAT(code, testing::HasSubstr("public static final int y = 43;"));
820}
821
822TEST_F(AidlTest, PreprocessedFileCantDeclarePackage) {
823 string simple_content = "package xxx; parcelable a.Foo;";
824 io_delegate_.SetFileContents("path", simple_content);
825 CaptureStderr();
826 EXPECT_FALSE(Parser::Parse("path", io_delegate_, typenames_, /*is_preprocessed=*/true));
827 EXPECT_THAT(GetCapturedStderr(), HasSubstr("Preprocessed file can't declare package."));
828}
829
830TEST_F(AidlTest, RejectQualifiedTypeNameUnlessPreprocessed) {
831 string simple_content = "parcelable a.Foo {}";
832 io_delegate_.SetFileContents("path", simple_content);
833 CaptureStderr();
834 EXPECT_FALSE(Parser::Parse("path", io_delegate_, typenames_, /*is_preprocessed=*/false));
835 EXPECT_THAT(GetCapturedStderr(), HasSubstr("Type name can't be qualified"));
Casey Dahlinc1f39b42015-11-24 10:34:34 -0800836}
837
Jooyung Han13f1fa52021-06-11 18:06:12 +0900838TEST_P(AidlTest, PreprocessedCanDeclareJavaStyleBuiltinTypes) {
839 string contents = R"(
840 interface android.os.IBinder;
841 interface android.os.IInterface;
842 parcelable android.os.ParcelFileDescriptor;
843 )";
844 io_delegate_.SetFileContents("path", contents);
845 CaptureStderr();
846 EXPECT_TRUE(Parser::Parse("path", io_delegate_, typenames_, /*is_preprocessed=*/true));
847 EXPECT_THAT(GetCapturedStderr(), "");
848}
849
Jooyung Han720253d2021-01-05 19:13:17 +0900850TEST_P(AidlTest, SupportDeprecated) {
851 struct TestCase {
852 std::string output_file;
853 std::string annotation;
854 };
855
856 auto CheckDeprecated = [&](const std::string& filename, const std::string& contents,
Jooyung Hand4fe00e2021-01-11 16:21:53 +0900857 std::vector<std::pair<Options::Language, TestCase>> expectations) {
Jooyung Han720253d2021-01-05 19:13:17 +0900858 io_delegate_.SetFileContents(filename, contents);
859
860 auto options = Options::From("aidl --lang=" + to_string(GetLanguage()) + " " + filename +
861 " --out=out --header_out=out");
862 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jooyung Hand4fe00e2021-01-11 16:21:53 +0900863 for (const auto& [lang, test_case] : expectations) {
864 if (lang != GetLanguage()) continue;
Jooyung Han720253d2021-01-05 19:13:17 +0900865 string output;
Jooyung Han652ce482021-02-26 12:40:35 +0900866 EXPECT_TRUE(io_delegate_.GetWrittenContents(test_case.output_file, &output));
Jooyung Han720253d2021-01-05 19:13:17 +0900867 EXPECT_THAT(output, HasSubstr(test_case.annotation));
868 }
869 };
870
Jooyung Hand4fe00e2021-01-11 16:21:53 +0900871 // Emit escaped string for notes
872 CheckDeprecated(
873 "IFoo.aidl",
874 R"(interface IFoo {
875 /**
876 * @note asdf
877 * @deprecated a really long deprecation message
878 *
879 * which is really long
880 * @param foo bar
881 */
882 List<String> foo();
883 })",
884 {
885 {Options::Language::JAVA, {"out/IFoo.java", "@Deprecated"}},
886 {Options::Language::CPP,
887 {"out/IFoo.h",
888 R"(__attribute__((deprecated("a really long deprecation message which is really long"))))"}},
889 {Options::Language::NDK,
890 {"out/aidl/IFoo.h",
891 R"(__attribute__((deprecated("a really long deprecation message which is really long"))))"}},
892 {Options::Language::RUST,
893 {"out/IFoo.rs",
894 R"(#[deprecated = "a really long deprecation message which is really long"])"}},
895 });
896
Jooyung Han24effbf2021-01-16 10:24:03 +0900897 // In AIDL @deprecated can be in block comments as well as javadoc style
Jooyung Hand4fe00e2021-01-11 16:21:53 +0900898 CheckDeprecated(
899 "IFoo.aidl",
900 "interface IFoo {\n"
Jooyung Han24effbf2021-01-16 10:24:03 +0900901 " /* @deprecated use bar() */\n"
Jooyung Hand4fe00e2021-01-11 16:21:53 +0900902 " List<String> foo();\n"
903 "}",
904 {
905 {Options::Language::JAVA, {"out/IFoo.java", "@Deprecated"}},
Jooyung Hanb7a60ec2021-01-21 13:47:59 +0900906 {Options::Language::JAVA, {"out/IFoo.java", "/** @deprecated use bar() */"}},
Jooyung Hand4fe00e2021-01-11 16:21:53 +0900907 {Options::Language::CPP, {"out/IFoo.h", "__attribute__((deprecated(\"use bar()\")))"}},
908 {Options::Language::NDK,
909 {"out/aidl/IFoo.h", "__attribute__((deprecated(\"use bar()\")))"}},
910 {Options::Language::RUST, {"out/IFoo.rs", "#[deprecated = \"use bar()\"]"}},
911 });
Jooyung Han720253d2021-01-05 19:13:17 +0900912
Jooyung Han24effbf2021-01-16 10:24:03 +0900913 // but not in line comments
914 auto parsed = Parse("IFoo.aidl", "// @deprecated\ninterface IFoo {}", typenames_, GetLanguage());
915 EXPECT_FALSE(parsed->IsDeprecated());
916
917 // parcelable
Jooyung Han720253d2021-01-05 19:13:17 +0900918 CheckDeprecated("Foo.aidl",
919 "parcelable Foo {\n"
920 " /** @deprecated use bar*/\n"
921 " int foo = 0;\n"
922 "}",
923 {
924 {Options::Language::JAVA, {"out/Foo.java", "@Deprecated"}},
925 {Options::Language::CPP, {"out/Foo.h", "__attribute__((deprecated"}},
926 {Options::Language::NDK, {"out/aidl/Foo.h", "__attribute__((deprecated"}},
927 {Options::Language::RUST, {"out/Foo.rs", "#[deprecated"}},
928 });
929
Jooyung Han24effbf2021-01-16 10:24:03 +0900930 // interface constants
Jooyung Han720253d2021-01-05 19:13:17 +0900931 CheckDeprecated("IFoo.aidl",
932 "interface IFoo {\n"
933 " /** @deprecated use bar*/\n"
934 " const int FOO = 0;\n"
935 "}",
936 {
937 {Options::Language::JAVA, {"out/IFoo.java", "@Deprecated"}},
938 {Options::Language::CPP, {"out/IFoo.h", "__attribute__((deprecated"}},
939 {Options::Language::NDK, {"out/aidl/IFoo.h", "__attribute__((deprecated"}},
940 {Options::Language::RUST, {"out/IFoo.rs", "#[deprecated"}},
941 });
942
943 // union fields
944 CheckDeprecated("Foo.aidl",
945 "union Foo {\n"
946 " int bar = 0;\n"
947 " /** @deprecated use bar*/\n"
948 " int foo;\n"
949 "}",
950 {
951 {Options::Language::JAVA, {"out/Foo.java", "@Deprecated"}},
952 {Options::Language::CPP, {"out/Foo.h", "__attribute__((deprecated"}},
953 {Options::Language::NDK, {"out/aidl/Foo.h", "__attribute__((deprecated"}},
954 {Options::Language::RUST, {"out/Foo.rs", "#[deprecated"}},
955 });
956
957 CheckDeprecated("Foo.aidl",
958 "/** @deprecated use Bar */\n"
959 "parcelable Foo {}",
960 {
961 {Options::Language::JAVA, {"out/Foo.java", "@Deprecated"}},
962 {Options::Language::CPP, {"out/Foo.h", "__attribute__((deprecated"}},
963 {Options::Language::NDK, {"out/aidl/Foo.h", "__attribute__((deprecated"}},
964 {Options::Language::RUST, {"out/Foo.rs", "#[deprecated"}},
965 });
966
967 CheckDeprecated("Foo.aidl",
968 "/** @deprecated use Bar */\n"
969 "union Foo { int foo = 0; }",
970 {
971 {Options::Language::JAVA, {"out/Foo.java", "@Deprecated"}},
972 {Options::Language::CPP, {"out/Foo.h", "__attribute__((deprecated"}},
973 {Options::Language::NDK, {"out/aidl/Foo.h", "__attribute__((deprecated"}},
974 {Options::Language::RUST, {"out/Foo.rs", "#[deprecated"}},
975 });
976
977 CheckDeprecated("IFoo.aidl",
978 "/** @deprecated use IBar */\n"
979 "interface IFoo {}",
980 {
981 {Options::Language::JAVA, {"out/IFoo.java", "@Deprecated"}},
982 {Options::Language::CPP, {"out/IFoo.h", "__attribute__((deprecated"}},
983 {Options::Language::NDK, {"out/aidl/IFoo.h", "__attribute__((deprecated"}},
984 {Options::Language::RUST, {"out/IFoo.rs", "#[deprecated"}},
985 });
986
987 CheckDeprecated("Foo.aidl",
988 "/** @deprecated use IBar */\n"
989 "enum Foo { FOO }",
990 {
991 {Options::Language::JAVA, {"out/Foo.java", "@Deprecated"}},
992 {Options::Language::CPP, {"out/Foo.h", "__attribute__((deprecated"}},
993 {Options::Language::NDK, {"out/aidl/Foo.h", "__attribute__((deprecated"}},
Jooyung Hanb7a60ec2021-01-21 13:47:59 +0900994 // TODO(b/177860423) support "deprecated" in Rust enum
Jooyung Han720253d2021-01-05 19:13:17 +0900995 // {Options::Language::RUST, {"out/Foo.rs", "#[deprecated"}},
996 });
997}
998
Devin Moore7b8d5c92020-03-17 14:14:08 -0700999TEST_P(AidlTest, RequireOuterClass) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001000 const string expected_stderr = "ERROR: p/IFoo.aidl:1.54-60: Failed to resolve 'Inner'\n";
Christopher Wiley63bce2a2015-11-03 14:55:03 -08001001 io_delegate_.SetFileContents("p/Outer.aidl",
1002 "package p; parcelable Outer.Inner;");
Jiyong Park8c380532018-08-30 14:55:26 +09001003 import_paths_.emplace("");
Devin Moore097a3ab2020-03-11 16:08:44 -07001004 CaptureStderr();
1005 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl",
1006 "package p; import p.Outer; interface IFoo { void f(in Inner c); }",
Devin Moore7b8d5c92020-03-17 14:14:08 -07001007 typenames_, GetLanguage()));
Devin Moore097a3ab2020-03-11 16:08:44 -07001008 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Christopher Wiley63bce2a2015-11-03 14:55:03 -08001009}
1010
Devin Moore7b8d5c92020-03-17 14:14:08 -07001011TEST_P(AidlTest, ParseCompoundParcelableFromPreprocess) {
Christopher Wiley63bce2a2015-11-03 14:55:03 -08001012 io_delegate_.SetFileContents("preprocessed",
1013 "parcelable p.Outer.Inner;");
1014 preprocessed_files_.push_back("preprocessed");
Jeongik Cha047c5ee2019-08-07 23:16:49 +09001015 auto parse_result = Parse("p/IFoo.aidl", "package p; interface IFoo { void f(in Inner c); }",
Devin Moore7b8d5c92020-03-17 14:14:08 -07001016 typenames_, GetLanguage());
Christopher Wiley63bce2a2015-11-03 14:55:03 -08001017 // TODO(wiley): This should actually return nullptr because we require
1018 // the outer class name. However, for legacy reasons,
1019 // this behavior must be maintained. b/17415692
1020 EXPECT_NE(nullptr, parse_result);
1021}
1022
Christopher Wiley632801d2015-11-05 14:15:49 -08001023TEST_F(AidlTest, FailOnParcelable) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001024 const string expected_foo_stderr =
1025 "ERROR: p/IFoo.aidl:1.22-27: Refusing to generate code with unstructured parcelables. "
1026 "Declared parcelables should be in their own file and/or cannot be used with --structured "
1027 "interfaces.\n";
Steven Morelande2c64b42018-09-18 15:06:37 -07001028 io_delegate_.SetFileContents("p/IFoo.aidl", "package p; parcelable IFoo;");
1029
Christopher Wiley632801d2015-11-05 14:15:49 -08001030 // By default, we shouldn't fail on parcelable.
Steven Morelande2c64b42018-09-18 15:06:37 -07001031 Options options1 = Options::From("aidl p/IFoo.aidl");
Devin Moore097a3ab2020-03-11 16:08:44 -07001032 CaptureStderr();
Jiyong Parkb034bf02018-07-30 17:44:33 +09001033 EXPECT_EQ(0, ::android::aidl::compile_aidl(options1, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001034 EXPECT_EQ("", GetCapturedStderr());
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001035
Steven Morelande2c64b42018-09-18 15:06:37 -07001036 // -b considers this an error
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001037 Options options2 = Options::From("aidl -b p/IFoo.aidl");
Devin Moore097a3ab2020-03-11 16:08:44 -07001038 CaptureStderr();
Jiyong Parkb034bf02018-07-30 17:44:33 +09001039 EXPECT_NE(0, ::android::aidl::compile_aidl(options2, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001040 EXPECT_EQ(expected_foo_stderr, GetCapturedStderr());
Steven Morelande2c64b42018-09-18 15:06:37 -07001041
Devin Moore097a3ab2020-03-11 16:08:44 -07001042 const string expected_bar_stderr =
1043 "ERROR: p/IBar.aidl:1.22-26: Refusing to generate code with unstructured parcelables. "
1044 "Declared parcelables should be in their own file and/or cannot be used with --structured "
1045 "interfaces.\n";
Steven Morelande2c64b42018-09-18 15:06:37 -07001046 io_delegate_.SetFileContents("p/IBar.aidl", "package p; parcelable Foo; interface IBar{}");
1047
Jiyong Parkda8c6932019-08-12 19:56:08 +09001048 // With '-b' option, a parcelable and an interface should fail.
Steven Morelande2c64b42018-09-18 15:06:37 -07001049 Options options3 = Options::From("aidl p/IBar.aidl");
Devin Moore097a3ab2020-03-11 16:08:44 -07001050 CaptureStderr();
Jiyong Parkda8c6932019-08-12 19:56:08 +09001051 EXPECT_EQ(0, ::android::aidl::compile_aidl(options3, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001052 EXPECT_EQ("", GetCapturedStderr());
Steven Morelande2c64b42018-09-18 15:06:37 -07001053 Options options4 = Options::From("aidl -b p/IBar.aidl");
Devin Moore097a3ab2020-03-11 16:08:44 -07001054 CaptureStderr();
Steven Morelande2c64b42018-09-18 15:06:37 -07001055 EXPECT_NE(0, ::android::aidl::compile_aidl(options4, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001056 EXPECT_EQ(expected_bar_stderr, GetCapturedStderr());
Christopher Wiley632801d2015-11-05 14:15:49 -08001057}
1058
Jooyung Han13f1fa52021-06-11 18:06:12 +09001059TEST_P(AidlTest, ImportingJavaStyleBuiltinTypesIsAllowed) {
1060 string contents = R"(
1061 import android.os.IBinder;
1062 import android.os.IInterface;
1063 interface IFoo {
1064 void foo(in IBinder b);
1065 }
1066 )";
1067 EXPECT_NE(nullptr, Parse("IFoo.aidl", contents, typenames_, GetLanguage()));
1068}
1069
Devin Moore7b8d5c92020-03-17 14:14:08 -07001070TEST_P(AidlTest, StructuredFailOnUnstructuredParcelable) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001071 const string expected_stderr =
Jooyung Han397a7602021-06-05 00:06:22 +09001072 "ERROR: o/WhoKnowsWhat.aidl:1.22-35: o.WhoKnowsWhat is not structured, but this is a "
Devin Moore097a3ab2020-03-11 16:08:44 -07001073 "structured interface.\n";
Steven Moreland1eac5fa2018-08-27 19:35:05 -07001074 io_delegate_.SetFileContents("o/WhoKnowsWhat.aidl", "package o; parcelable WhoKnowsWhat;");
1075 import_paths_.emplace("");
Devin Moore097a3ab2020-03-11 16:08:44 -07001076 AidlError error;
1077 CaptureStderr();
1078 EXPECT_EQ(
1079 nullptr,
Steven Moreland1eac5fa2018-08-27 19:35:05 -07001080 Parse("p/IFoo.aidl",
1081 "package p; import o.WhoKnowsWhat; interface IFoo { void f(in WhoKnowsWhat thisIs); }",
Devin Moore7b8d5c92020-03-17 14:14:08 -07001082 typenames_, GetLanguage(), &error, {"--structured"}));
Devin Moore097a3ab2020-03-11 16:08:44 -07001083 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1084 EXPECT_EQ(AidlError::NOT_STRUCTURED, error);
Steven Moreland1eac5fa2018-08-27 19:35:05 -07001085}
1086
Devin Moore7b8d5c92020-03-17 14:14:08 -07001087TEST_P(AidlTest, FailOnDuplicateConstantNames) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001088 AidlError error;
1089 const string expected_stderr =
1090 "ERROR: p/IFoo.aidl:4.34-45: Found duplicate constant name 'DUPLICATED'\n";
1091 CaptureStderr();
Jeongik Cha047c5ee2019-08-07 23:16:49 +09001092 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl",
1093 R"(package p;
Christopher Wiley69b44cf2016-05-03 13:43:33 -07001094 interface IFoo {
1095 const String DUPLICATED = "d";
1096 const int DUPLICATED = 1;
1097 }
1098 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -07001099 typenames_, GetLanguage(), &error));
Devin Moore097a3ab2020-03-11 16:08:44 -07001100 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1101 EXPECT_EQ(AidlError::BAD_TYPE, error);
Christopher Wiley69b44cf2016-05-03 13:43:33 -07001102}
1103
Steven Morelande689da22020-11-10 02:06:30 +00001104TEST_P(AidlTest, FailOnTooBigConstant) {
1105 AidlError error;
1106 const string expected_stderr =
1107 "ERROR: p/IFoo.aidl:3.48-52: Invalid type specifier for an int32 literal: byte\n";
1108 CaptureStderr();
1109 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl",
1110 R"(package p;
1111 interface IFoo {
1112 const byte type2small = 256;
1113 }
1114 )",
1115 typenames_, GetLanguage(), &error));
1116 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1117 EXPECT_EQ(AidlError::BAD_TYPE, error);
1118}
1119
Jooyung Han30f64ad2020-12-15 08:16:31 +09001120TEST_F(AidlTest, BoolConstantsEvaluatesToIntegers) {
1121 io_delegate_.SetFileContents("a/Foo.aidl", "package a; parcelable Foo { const int y = true; }");
1122 CaptureStderr();
1123 auto options = Options::From("aidl --lang java -o out a/Foo.aidl");
1124 EXPECT_EQ(0, aidl::compile_aidl(options, io_delegate_));
1125 EXPECT_EQ("", GetCapturedStderr());
1126 string code;
1127 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/Foo.java", &code));
1128 EXPECT_THAT(code, testing::HasSubstr("public static final int y = 1;"));
1129}
1130
Jooyung Han535c5e82020-12-29 15:16:59 +09001131TEST_F(AidlTest, AidlConstantValue_EvaluatedValue) {
Jooyung Han71a1b582020-12-25 23:58:41 +09001132 using Ptr = unique_ptr<AidlConstantValue>;
1133 const AidlLocation& loc = AIDL_LOCATION_HERE;
1134
Jooyung Han535c5e82020-12-29 15:16:59 +09001135 EXPECT_EQ('c', Ptr(AidlConstantValue::Character(loc, 'c'))->EvaluatedValue<char>());
1136 EXPECT_EQ("abc", Ptr(AidlConstantValue::String(loc, "\"abc\""))->EvaluatedValue<string>());
1137 EXPECT_FLOAT_EQ(1.0f, Ptr(AidlConstantValue::Floating(loc, "1.0f"))->EvaluatedValue<float>());
1138 EXPECT_EQ(true, Ptr(AidlConstantValue::Boolean(loc, true))->EvaluatedValue<bool>());
Jooyung Han71a1b582020-12-25 23:58:41 +09001139
1140 AidlBinaryConstExpression one_plus_one(loc, Ptr(AidlConstantValue::Integral(loc, "1")), "+",
1141 Ptr(AidlConstantValue::Integral(loc, "1")));
Jooyung Han535c5e82020-12-29 15:16:59 +09001142 EXPECT_EQ(2, one_plus_one.EvaluatedValue<int32_t>());
Jooyung Han71a1b582020-12-25 23:58:41 +09001143
1144 auto values = unique_ptr<vector<Ptr>>{new vector<Ptr>};
1145 values->emplace_back(AidlConstantValue::String(loc, "\"hello\""));
1146 values->emplace_back(AidlConstantValue::String(loc, "\"world\""));
1147 vector<string> expected{"hello", "world"};
Jooyung Han535c5e82020-12-29 15:16:59 +09001148 EXPECT_EQ(
1149 expected,
1150 Ptr(AidlConstantValue::Array(loc, std::move(values)))->EvaluatedValue<vector<string>>());
Jooyung Han71a1b582020-12-25 23:58:41 +09001151}
1152
Devin Moore7b8d5c92020-03-17 14:14:08 -07001153TEST_P(AidlTest, FailOnManyDefinedTypes) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001154 AidlError error;
Devin Moore5de18ed2020-04-02 13:52:29 -07001155 const string expected_stderr =
1156 "ERROR: p/IFoo.aidl:3.33-38: You must declare only one type per file.\n";
Devin Moorec054bf82020-03-10 16:31:48 -07001157 CaptureStderr();
Steven Morelandc258abc2018-07-10 14:03:38 -07001158 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl",
1159 R"(package p;
1160 interface IFoo {}
Steven Morelandc258abc2018-07-10 14:03:38 -07001161 parcelable IBar {}
1162 parcelable StructuredParcelable {}
1163 interface IBaz {}
Jeongik Cha2a5b4d82019-08-06 19:37:59 +09001164 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -07001165 typenames_, GetLanguage(), &error));
Devin Moorec054bf82020-03-10 16:31:48 -07001166 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Steven Morelandc258abc2018-07-10 14:03:38 -07001167 // Parse success is important for clear error handling even if the cases aren't
1168 // actually supported in code generation.
Devin Moore097a3ab2020-03-11 16:08:44 -07001169 EXPECT_EQ(AidlError::BAD_TYPE, error);
Steven Morelandc258abc2018-07-10 14:03:38 -07001170}
1171
Devin Moore7b8d5c92020-03-17 14:14:08 -07001172TEST_P(AidlTest, FailOnNoDefinedTypes) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001173 AidlError error;
1174 const string expected_stderr = "ERROR: p/IFoo.aidl:1.11-11: syntax error, unexpected $end\n";
1175 CaptureStderr();
Devin Moore7b8d5c92020-03-17 14:14:08 -07001176 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl", R"(package p;)", typenames_, GetLanguage(), &error));
Devin Moore097a3ab2020-03-11 16:08:44 -07001177 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1178 EXPECT_EQ(AidlError::PARSE_ERROR, error);
Steven Morelandc258abc2018-07-10 14:03:38 -07001179}
1180
Steven Morelandf9e922f2020-07-08 21:15:27 +00001181TEST_P(AidlTest, FailOnEmptyListWithComma) {
1182 AidlError error;
1183 const string expected_stderr =
1184 "ERROR: p/Foo.aidl:1.45-47: syntax error, unexpected ',', expecting '}'\n";
1185 CaptureStderr();
1186 EXPECT_EQ(nullptr, Parse("p/Foo.aidl", R"(package p; parcelable Foo { uint64_t[] a = { , }; })",
1187 typenames_, GetLanguage(), &error));
1188 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1189 EXPECT_EQ(AidlError::PARSE_ERROR, error);
1190}
1191
Devin Moore7b8d5c92020-03-17 14:14:08 -07001192TEST_P(AidlTest, FailOnMalformedConstHexValue) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001193 AidlError error;
1194 const string expected_stderr =
Devin Moore2a088902020-09-17 10:51:19 -07001195 "ERROR: p/IFoo.aidl:3.50-71: Could not parse hexvalue: 0xffffffffffffffffff\n";
Devin Moore097a3ab2020-03-11 16:08:44 -07001196 CaptureStderr();
Jeongik Cha047c5ee2019-08-07 23:16:49 +09001197 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl",
1198 R"(package p;
Roshan Pius3b2203d2016-07-22 16:13:20 -07001199 interface IFoo {
1200 const int BAD_HEX_VALUE = 0xffffffffffffffffff;
1201 }
1202 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -07001203 typenames_, GetLanguage(), &error));
Devin Moore097a3ab2020-03-11 16:08:44 -07001204 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1205 EXPECT_EQ(AidlError::PARSE_ERROR, error);
Roshan Pius3b2203d2016-07-22 16:13:20 -07001206}
1207
Jiyong Park18132182020-06-08 20:24:40 +09001208TEST_P(AidlTest, FailOnMalformedQualifiedNameAsIdentifier) {
1209 AidlError error;
1210 const string expected_stderr =
1211 "ERROR: p/IFoo.aidl:1.25-26: syntax error, unexpected ';', expecting identifier or "
1212 "cpp_header (which can also be used as an identifier)\n";
1213 CaptureStderr();
1214 // Notice the trailing dot(.) in the name, which isn't a correct name
1215 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl", R"(package p; parcelable A.; )", typenames_,
1216 GetLanguage(), &error));
1217 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1218 EXPECT_EQ(AidlError::PARSE_ERROR, error);
1219}
1220
1221TEST_P(AidlTest, FailOnMalformedQualifiedNameAsPackage) {
1222 AidlError error;
1223 const string expected_stderr =
1224 "ERROR: p/IFoo.aidl:1.11-12: syntax error, unexpected ';', expecting identifier or "
1225 "cpp_header (which can also be used as an identifier)\n";
1226 CaptureStderr();
1227 // Notice the trailing dot(.) in the package name
1228 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl", R"(package p.; parcelable A; )", typenames_,
1229 GetLanguage(), &error));
1230 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1231 EXPECT_EQ(AidlError::PARSE_ERROR, error);
1232}
1233
Devin Moore7b8d5c92020-03-17 14:14:08 -07001234TEST_P(AidlTest, ParsePositiveConstHexValue) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001235 AidlError error;
Devin Moore7b8d5c92020-03-17 14:14:08 -07001236 auto parse_result = Parse("p/IFoo.aidl",
1237 R"(package p;
Roshan Pius3b2203d2016-07-22 16:13:20 -07001238 interface IFoo {
1239 const int POSITIVE_HEX_VALUE = 0xf5;
1240 }
1241 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -07001242 typenames_, GetLanguage(), &error);
1243 EXPECT_NE(nullptr, parse_result);
1244 const AidlInterface* interface = parse_result->AsInterface();
Steven Moreland5557f1c2018-07-02 13:50:23 -07001245 ASSERT_NE(nullptr, interface);
Steven Moreland693640b2018-07-19 13:46:27 -07001246 const auto& cpp_constants = interface->GetConstantDeclarations();
1247 EXPECT_EQ((size_t)1, cpp_constants.size());
1248 EXPECT_EQ("POSITIVE_HEX_VALUE", cpp_constants[0]->GetName());
Will McVickerd7d18df2019-09-12 13:40:50 -07001249 EXPECT_TRUE(cpp_constants[0]->CheckValid(typenames_));
Steven Moreland860b1942018-08-16 14:59:28 -07001250 EXPECT_EQ("245", cpp_constants[0]->ValueString(cpp::ConstantValueDecorator));
Roshan Pius3b2203d2016-07-22 16:13:20 -07001251}
1252
Devin Moore7b8d5c92020-03-17 14:14:08 -07001253TEST_P(AidlTest, ParseNegativeConstHexValue) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001254 AidlError error;
Devin Moore7b8d5c92020-03-17 14:14:08 -07001255 auto parse_result = Parse("p/IFoo.aidl",
1256 R"(package p;
Roshan Pius3b2203d2016-07-22 16:13:20 -07001257 interface IFoo {
1258 const int NEGATIVE_HEX_VALUE = 0xffffffff;
1259 }
1260 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -07001261 typenames_, GetLanguage(), &error);
1262 ASSERT_NE(nullptr, parse_result);
1263 const AidlInterface* interface = parse_result->AsInterface();
Steven Moreland5557f1c2018-07-02 13:50:23 -07001264 ASSERT_NE(nullptr, interface);
Steven Moreland693640b2018-07-19 13:46:27 -07001265 const auto& cpp_constants = interface->GetConstantDeclarations();
1266 EXPECT_EQ((size_t)1, cpp_constants.size());
1267 EXPECT_EQ("NEGATIVE_HEX_VALUE", cpp_constants[0]->GetName());
Will McVickerd7d18df2019-09-12 13:40:50 -07001268 EXPECT_EQ(true, cpp_constants[0]->CheckValid(typenames_));
Steven Moreland860b1942018-08-16 14:59:28 -07001269 EXPECT_EQ("-1", cpp_constants[0]->ValueString(cpp::ConstantValueDecorator));
Roshan Pius3b2203d2016-07-22 16:13:20 -07001270}
1271
Devin Moore7b8d5c92020-03-17 14:14:08 -07001272TEST_P(AidlTest, UnderstandsNestedParcelables) {
Ningyuan Wangd17c58b2016-09-29 14:33:14 -07001273 io_delegate_.SetFileContents(
1274 "p/Outer.aidl",
1275 "package p; parcelable Outer.Inner cpp_header \"baz/header\";");
Jiyong Park8c380532018-08-30 14:55:26 +09001276 import_paths_.emplace("");
Ningyuan Wangd17c58b2016-09-29 14:33:14 -07001277 const string input_path = "p/IFoo.aidl";
1278 const string input = "package p; import p.Outer; interface IFoo"
1279 " { Outer.Inner get(); }";
1280
Devin Moore7b8d5c92020-03-17 14:14:08 -07001281 auto parse_result = Parse(input_path, input, typenames_, GetLanguage());
1282 EXPECT_NE(nullptr, parse_result);
Jeongik Cha047c5ee2019-08-07 23:16:49 +09001283
Steven Morelandcb1bcd72020-04-29 16:30:35 -07001284 EXPECT_TRUE(typenames_.ResolveTypename("p.Outer.Inner").is_resolved);
Ningyuan Wangd17c58b2016-09-29 14:33:14 -07001285 // C++ uses "::" instead of "." to refer to a inner class.
Jooyung Han8451a202021-01-16 03:07:06 +09001286 AidlTypeSpecifier nested_type(AIDL_LOCATION_HERE, "p.Outer.Inner", false, nullptr, {});
Jeongik Cha047c5ee2019-08-07 23:16:49 +09001287 EXPECT_EQ("::p::Outer::Inner", cpp::CppNameOf(nested_type, typenames_));
Ningyuan Wangd17c58b2016-09-29 14:33:14 -07001288}
1289
Jooyung Han78fcaa82021-06-11 22:27:57 +09001290TEST_P(AidlTest, UnderstandsNestedParcelablesWithoutImports) {
1291 io_delegate_.SetFileContents("p/Outer.aidl",
1292 "package p; parcelable Outer.Inner cpp_header \"baz/header\";");
1293 import_paths_.emplace("");
1294 const string input_path = "p/IFoo.aidl";
1295 const string input = "package p; interface IFoo { p.Outer.Inner get(); }";
1296
1297 auto parse_result = Parse(input_path, input, typenames_, GetLanguage());
1298 EXPECT_NE(nullptr, parse_result);
1299
1300 EXPECT_TRUE(typenames_.ResolveTypename("p.Outer.Inner").is_resolved);
1301 // C++ uses "::" instead of "." to refer to a inner class.
1302 AidlTypeSpecifier nested_type(AIDL_LOCATION_HERE, "p.Outer.Inner", false, nullptr, {});
1303 EXPECT_EQ("::p::Outer::Inner", cpp::CppNameOf(nested_type, typenames_));
1304}
1305
Jooyung Han0a950bd2021-05-15 12:50:36 +09001306TEST_F(AidlTest, CppNameOf_GenericType) {
1307 io_delegate_.SetFileContents("p/Wrapper.aidl", "package p; parcelable Wrapper<T> { T wrapped; }");
1308 import_paths_.emplace("");
1309 // Since we don't support compilation of Wrapper directly (due to "T" reference),
1310 // prepare Holder so that Wrapper gets parsed into AidlTypenames
1311 const string input_path = "p/Holder.aidl";
1312 const string input =
1313 "package p; import p.Wrapper; parcelable Holder {\n"
1314 " @nullable Wrapper<String> value;\n"
1315 "}";
1316
1317 auto parse_result = Parse(input_path, input, typenames_, Options::Language::CPP);
1318 EXPECT_NE(nullptr, parse_result);
1319
1320 auto type = [](std::string name, auto&&... type_params) -> std::unique_ptr<AidlTypeSpecifier> {
1321 auto params = new std::vector<std::unique_ptr<AidlTypeSpecifier>>;
1322 (..., params->emplace_back(std::move(type_params)));
1323 return std::make_unique<AidlTypeSpecifier>(AIDL_LOCATION_HERE, name, false, params, Comments{});
1324 };
1325
1326 auto set_nullable = [](std::unique_ptr<AidlTypeSpecifier>&& type) {
1327 std::vector<AidlAnnotation> annotations;
1328 annotations.emplace_back(*AidlAnnotation::Parse(AIDL_LOCATION_HERE, "nullable", nullptr, {}));
1329 type->Annotate(std::move(annotations));
1330 return std::move(type);
1331 };
1332
1333 auto set_array = [](std::unique_ptr<AidlTypeSpecifier>&& type) {
1334 (void)type->SetArray();
1335 return std::move(type);
1336 };
1337
1338 auto w = type("p.Wrapper", type("String"));
1339 EXPECT_EQ("::p::Wrapper<::android::String16>", cpp::CppNameOf(*w, typenames_));
1340
1341 auto nullable_w = set_nullable(type("p.Wrapper", type("String")));
1342 EXPECT_EQ("::std::optional<::p::Wrapper<::android::String16>>",
1343 cpp::CppNameOf(*nullable_w, typenames_));
1344
1345 auto array_w = set_array(type("p.Wrapper", type("String")));
1346 EXPECT_EQ("::std::vector<::p::Wrapper<::android::String16>>",
1347 cpp::CppNameOf(*array_w, typenames_));
1348
1349 auto nullable_array_w = set_nullable(set_array(type("p.Wrapper", type("String"))));
1350 EXPECT_EQ("::std::optional<::std::vector<::std::optional<::p::Wrapper<::android::String16>>>>",
1351 cpp::CppNameOf(*nullable_array_w, typenames_));
1352
1353 auto list_w = type("List", type("p.Wrapper", type("String")));
1354 EXPECT_EQ("::std::vector<::p::Wrapper<::android::String16>>",
1355 cpp::CppNameOf(*list_w, typenames_));
1356
1357 auto nullable_list_w = set_nullable(type("List", type("p.Wrapper", type("String"))));
1358 EXPECT_EQ("::std::optional<::std::vector<::std::optional<::p::Wrapper<::android::String16>>>>",
1359 cpp::CppNameOf(*nullable_list_w, typenames_));
1360}
1361
Devin Moore7b8d5c92020-03-17 14:14:08 -07001362TEST_P(AidlTest, UnderstandsNativeParcelables) {
Christopher Wiley9078d722015-11-17 10:23:49 -08001363 io_delegate_.SetFileContents(
1364 "p/Bar.aidl",
Casey Dahlincd639212015-12-15 12:51:04 -08001365 "package p; parcelable Bar cpp_header \"baz/header\";");
Jiyong Park8c380532018-08-30 14:55:26 +09001366 import_paths_.emplace("");
Christopher Wiley9078d722015-11-17 10:23:49 -08001367 const string input_path = "p/IFoo.aidl";
1368 const string input = "package p; import p.Bar; interface IFoo { }";
Devin Moore7b8d5c92020-03-17 14:14:08 -07001369 auto parse_result = Parse(input_path, input, typenames_, GetLanguage());
1370 EXPECT_NE(nullptr, parse_result);
Steven Morelandcb1bcd72020-04-29 16:30:35 -07001371 EXPECT_TRUE(typenames_.ResolveTypename("p.Bar").is_resolved);
Jooyung Han8451a202021-01-16 03:07:06 +09001372 AidlTypeSpecifier native_type(AIDL_LOCATION_HERE, "p.Bar", false, nullptr, {});
Jooyung Han13f1fa52021-06-11 18:06:12 +09001373 native_type.Resolve(typenames_, parse_result);
Devin Moore7b8d5c92020-03-17 14:14:08 -07001374
1375 EXPECT_EQ("p.Bar", java::InstantiableJavaSignatureOf(native_type, typenames_));
1376 // C++ understands C++ specific stuff
1377 EXPECT_EQ("::p::Bar", cpp::CppNameOf(native_type, typenames_));
1378 set<string> headers;
Devin Moore2f2077a2020-08-28 11:27:53 -07001379 cpp::AddHeaders(native_type, typenames_, &headers);
Devin Moore7b8d5c92020-03-17 14:14:08 -07001380 EXPECT_EQ(1u, headers.size());
1381 EXPECT_EQ(1u, headers.count("baz/header"));
Christopher Wiley9078d722015-11-17 10:23:49 -08001382}
1383
Christopher Wileyf8136192016-04-12 14:19:35 -07001384TEST_F(AidlTest, WritesCorrectDependencyFile) {
1385 // While the in tree build system always gives us an output file name,
1386 // other android tools take advantage of our ability to infer the intended
1387 // file name. This test makes sure we handle this correctly.
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001388 vector<string> args = {
1389 "aidl",
1390 "-d dep/file/path",
1391 "-o place/for/output",
1392 "p/IFoo.aidl"};
1393 Options options = Options::From(args);
1394 io_delegate_.SetFileContents(options.InputFiles().front(), "package p; interface IFoo {}");
Jiyong Parkb034bf02018-07-30 17:44:33 +09001395 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
Christopher Wileyf8136192016-04-12 14:19:35 -07001396 string actual_dep_file_contents;
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001397 EXPECT_TRUE(io_delegate_.GetWrittenContents(options.DependencyFile(), &actual_dep_file_contents));
Christopher Wileyf8136192016-04-12 14:19:35 -07001398 EXPECT_EQ(actual_dep_file_contents, kExpectedDepFileContents);
1399}
1400
Dan Willemsen93298ee2016-11-10 23:55:55 -08001401TEST_F(AidlTest, WritesCorrectDependencyFileNinja) {
1402 // While the in tree build system always gives us an output file name,
1403 // other android tools take advantage of our ability to infer the intended
1404 // file name. This test makes sure we handle this correctly.
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001405 vector<string> args = {
1406 "aidl",
1407 "-d dep/file/path",
1408 "--ninja",
1409 "-o place/for/output",
1410 "p/IFoo.aidl"};
1411 Options options = Options::From(args);
1412 io_delegate_.SetFileContents(options.InputFiles().front(), "package p; interface IFoo {}");
Jiyong Parkb034bf02018-07-30 17:44:33 +09001413 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
Dan Willemsen93298ee2016-11-10 23:55:55 -08001414 string actual_dep_file_contents;
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001415 EXPECT_TRUE(io_delegate_.GetWrittenContents(options.DependencyFile(), &actual_dep_file_contents));
Dan Willemsen93298ee2016-11-10 23:55:55 -08001416 EXPECT_EQ(actual_dep_file_contents, kExpectedNinjaDepFileContents);
1417}
1418
Jiyong Parkdf202122019-09-30 20:48:35 +09001419TEST_F(AidlTest, WritesTrivialDependencyFileForParcelableDeclaration) {
Christopher Wileyb1bbdf82016-04-21 11:43:45 -07001420 // The SDK uses aidl to decide whether a .aidl file is a parcelable. It does
1421 // this by calling aidl with every .aidl file it finds, then parsing the
1422 // generated dependency files. Those that reference .java output files are
1423 // for interfaces and those that do not are parcelables. However, for both
1424 // parcelables and interfaces, we *must* generate a non-empty dependency file.
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001425 vector<string> args = {
1426 "aidl",
1427 "-o place/for/output",
1428 "-d dep/file/path",
1429 "p/Foo.aidl"};
1430 Options options = Options::From(args);
1431 io_delegate_.SetFileContents(options.InputFiles().front(), "package p; parcelable Foo;");
Jiyong Parkb034bf02018-07-30 17:44:33 +09001432 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
Christopher Wileyb1bbdf82016-04-21 11:43:45 -07001433 string actual_dep_file_contents;
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001434 EXPECT_TRUE(io_delegate_.GetWrittenContents(options.DependencyFile(), &actual_dep_file_contents));
Jiyong Parkdf202122019-09-30 20:48:35 +09001435 EXPECT_EQ(actual_dep_file_contents, kExpectedParcelableDeclarationDepFileContents);
1436}
1437
1438TEST_F(AidlTest, WritesDependencyFileForStructuredParcelable) {
1439 vector<string> args = {
1440 "aidl",
1441 "--structured",
1442 "-o place/for/output",
1443 "-d dep/file/path",
1444 "p/Foo.aidl"};
1445 Options options = Options::From(args);
1446 io_delegate_.SetFileContents(options.InputFiles().front(), "package p; parcelable Foo {int a;}");
1447 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1448 string actual_dep_file_contents;
1449 EXPECT_TRUE(io_delegate_.GetWrittenContents(options.DependencyFile(), &actual_dep_file_contents));
1450 EXPECT_EQ(actual_dep_file_contents, kExpectedStructuredParcelableDepFileContents);
Christopher Wileyb1bbdf82016-04-21 11:43:45 -07001451}
1452
Jiyong Park9ca5c7e2019-10-17 15:01:14 +09001453TEST_F(AidlTest, NoJavaOutputForParcelableDeclaration) {
1454 vector<string> args = {
1455 "aidl",
1456 "--lang=java",
1457 "-o place/for/output",
1458 "p/Foo.aidl"};
1459 Options options = Options::From(args);
1460 io_delegate_.SetFileContents(options.InputFiles().front(), "package p; parcelable Foo;");
1461 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1462 string output_file_contents;
1463 EXPECT_FALSE(io_delegate_.GetWrittenContents(options.OutputFile(), &output_file_contents));
1464}
1465
Devin Moore21b26772020-08-26 16:37:56 -07001466TEST_P(AidlTest, RejectsListArray) {
Devin Moore6a01ca12020-08-28 10:24:19 -07001467 const string expected_stderr = "ERROR: a/Foo.aidl:2.1-7: List[] is not supported.\n";
Devin Moore21b26772020-08-26 16:37:56 -07001468 const string list_array_parcelable =
1469 "package a; parcelable Foo {\n"
1470 " List[] lists; }";
1471 CaptureStderr();
1472 EXPECT_EQ(nullptr, Parse("a/Foo.aidl", list_array_parcelable, typenames_, GetLanguage()));
1473 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1474}
1475
Jiyong Parkf8d53612020-05-04 14:06:13 +09001476TEST_P(AidlTest, RejectsPrimitiveListInStableAidl) {
1477 AidlError error;
1478 string expected_stderr =
1479 "ERROR: a/IFoo.aidl:2.7-11: "
1480 "Encountered an untyped List or Map. The use of untyped List/Map is "
1481 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
1482 "the receiving side. Consider switching to an array or a generic List/Map.\n";
1483 if (GetLanguage() != Options::Language::JAVA) {
1484 expected_stderr =
1485 "ERROR: a/IFoo.aidl:2.1-7: "
1486 "Currently, only the Java backend supports non-generic List.\n";
1487 }
1488
1489 const string primitive_interface =
1490 "package a; interface IFoo {\n"
1491 " List foo(); }";
1492 CaptureStderr();
Jiyong Park40782d02020-07-24 19:17:43 +09001493 AidlTypenames tn1;
1494 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", primitive_interface, tn1, GetLanguage(), &error,
Jiyong Parkf8d53612020-05-04 14:06:13 +09001495 {"--structured"}));
1496 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Parkf8d53612020-05-04 14:06:13 +09001497
1498 string primitive_parcelable =
1499 "package a; parcelable IFoo {\n"
1500 " List foo;}";
1501 CaptureStderr();
Jiyong Park40782d02020-07-24 19:17:43 +09001502 AidlTypenames tn2;
1503 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", primitive_parcelable, tn2, GetLanguage(), &error,
Jiyong Parkf8d53612020-05-04 14:06:13 +09001504 {"--structured"}));
1505 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1506}
1507
Jeongik Cha225519b2020-08-29 01:55:32 +09001508TEST_P(AidlTest, ExtensionTest) {
1509 CaptureStderr();
Jeongik Cha649e8a72020-03-27 17:47:40 +09001510 string extendable_parcelable =
1511 "package a; parcelable Data {\n"
1512 " ParcelableHolder extension;\n"
1513 " ParcelableHolder extension2;\n"
1514 "}";
Jeongik Cha8f02a532020-10-14 00:16:28 +09001515 if (GetLanguage() == Options::Language::RUST) {
Jeongik Cha225519b2020-08-29 01:55:32 +09001516 EXPECT_EQ(nullptr, Parse("a/Data.aidl", extendable_parcelable, typenames_, GetLanguage()));
1517 EXPECT_EQ(
Jeongik Cha8f02a532020-10-14 00:16:28 +09001518 "ERROR: a/Data.aidl:2.1-19: The Rust backend does not support ParcelableHolder "
Jeongik Cha225519b2020-08-29 01:55:32 +09001519 "yet.\n",
1520 GetCapturedStderr());
1521 } else {
1522 EXPECT_NE(nullptr, Parse("a/Data.aidl", extendable_parcelable, typenames_, GetLanguage()));
1523 EXPECT_EQ("", GetCapturedStderr());
1524 }
1525}
1526TEST_P(AidlTest, ParcelableHolderAsReturnType) {
1527 CaptureStderr();
Jeongik Cha649e8a72020-03-27 17:47:40 +09001528 string parcelableholder_return_interface =
1529 "package a; interface IFoo {\n"
1530 " ParcelableHolder foo();\n"
1531 "}";
Jeongik Cha225519b2020-08-29 01:55:32 +09001532 EXPECT_EQ(nullptr,
1533 Parse("a/IFoo.aidl", parcelableholder_return_interface, typenames_, GetLanguage()));
Jeongik Cha649e8a72020-03-27 17:47:40 +09001534
Jeongik Cha8f02a532020-10-14 00:16:28 +09001535 if (GetLanguage() == Options::Language::RUST) {
Jeongik Cha225519b2020-08-29 01:55:32 +09001536 EXPECT_EQ(
Steven Morelandebc3c5d2020-09-30 23:40:33 +00001537 "ERROR: a/IFoo.aidl:2.19-23: ParcelableHolder cannot be a return type\n"
Jeongik Cha8f02a532020-10-14 00:16:28 +09001538 "ERROR: a/IFoo.aidl:2.1-19: The Rust backend does not support ParcelableHolder "
Jeongik Cha225519b2020-08-29 01:55:32 +09001539 "yet.\n",
1540 GetCapturedStderr());
1541 return;
1542 }
1543 EXPECT_EQ("ERROR: a/IFoo.aidl:2.19-23: ParcelableHolder cannot be a return type\n",
1544 GetCapturedStderr());
1545}
1546
1547TEST_P(AidlTest, ParcelableHolderAsArgumentType) {
1548 CaptureStderr();
Jeongik Cha649e8a72020-03-27 17:47:40 +09001549 string extendable_parcelable_arg_interface =
1550 "package a; interface IFoo {\n"
1551 " void foo(in ParcelableHolder ph);\n"
1552 "}";
Jeongik Cha225519b2020-08-29 01:55:32 +09001553 EXPECT_EQ(nullptr,
1554 Parse("a/IFoo.aidl", extendable_parcelable_arg_interface, typenames_, GetLanguage()));
1555
Jeongik Cha8f02a532020-10-14 00:16:28 +09001556 if (GetLanguage() == Options::Language::RUST) {
Jeongik Cha225519b2020-08-29 01:55:32 +09001557 EXPECT_EQ(
Steven Morelandebc3c5d2020-09-30 23:40:33 +00001558 "ERROR: a/IFoo.aidl:2.31-34: ParcelableHolder cannot be an argument type\n"
Jeongik Cha8f02a532020-10-14 00:16:28 +09001559 "ERROR: a/IFoo.aidl:2.14-31: The Rust backend does not support ParcelableHolder "
Jeongik Cha225519b2020-08-29 01:55:32 +09001560 "yet.\n",
1561 GetCapturedStderr());
1562 return;
1563 }
1564 EXPECT_EQ("ERROR: a/IFoo.aidl:2.31-34: ParcelableHolder cannot be an argument type\n",
1565 GetCapturedStderr());
Jeongik Cha649e8a72020-03-27 17:47:40 +09001566}
1567
Jeongik Chaf6ec8982020-10-15 00:10:30 +09001568TEST_P(AidlTest, RejectNullableParcelableHolderField) {
1569 io_delegate_.SetFileContents("Foo.aidl", "parcelable Foo { @nullable ParcelableHolder ext; }");
Jooyung Han9435e9a2021-01-06 10:16:31 +09001570 Options options = Options::From("aidl Foo.aidl --lang=" + to_string(GetLanguage()));
Jeongik Chaf6ec8982020-10-15 00:10:30 +09001571 const string expected_stderr = "ERROR: Foo.aidl:1.27-44: ParcelableHolder cannot be nullable.\n";
1572 CaptureStderr();
1573 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
1574 if (GetLanguage() == Options::Language::RUST) {
1575 EXPECT_EQ(
1576 "ERROR: Foo.aidl:1.27-44: ParcelableHolder cannot be nullable.\n"
1577 "ERROR: Foo.aidl:1.27-44: The Rust backend does not support ParcelableHolder "
1578 "yet.\n",
1579 GetCapturedStderr());
1580 return;
1581 }
1582 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1583}
1584
Jooyung Han3f347ca2020-12-01 12:41:50 +09001585TEST_P(AidlTest, ParcelablesWithConstants) {
1586 io_delegate_.SetFileContents("Foo.aidl", "parcelable Foo { const int BIT = 0x1 << 3; }");
Jooyung Han9435e9a2021-01-06 10:16:31 +09001587 Options options = Options::From("aidl Foo.aidl --lang=" + to_string(GetLanguage()));
Jooyung Han3f347ca2020-12-01 12:41:50 +09001588 CaptureStderr();
1589 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1590 EXPECT_EQ("", GetCapturedStderr());
1591}
1592
1593TEST_P(AidlTest, UnionWithConstants) {
1594 io_delegate_.SetFileContents("Foo.aidl", "union Foo { const int BIT = 0x1 << 3; int n; }");
Jooyung Han9435e9a2021-01-06 10:16:31 +09001595 Options options = Options::From("aidl Foo.aidl --lang=" + to_string(GetLanguage()));
Jooyung Han3f347ca2020-12-01 12:41:50 +09001596 CaptureStderr();
1597 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1598 EXPECT_EQ("", GetCapturedStderr());
1599}
1600
Jooyung Han633eab62021-01-07 14:12:40 +09001601TEST_F(AidlTest, ConstantsWithAnnotations) {
1602 io_delegate_.SetFileContents("IFoo.aidl",
1603 "interface IFoo {\n"
1604 " @JavaPassthrough(annotation=\"@Foo\")\n"
1605 " const @JavaPassthrough(annotation=\"@Bar\") int FOO = 0;\n"
1606 "}");
1607 Options options = Options::From("aidl IFoo.aidl --lang=java -o out");
1608 CaptureStderr();
1609 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1610 EXPECT_EQ("", GetCapturedStderr());
1611 string code;
1612 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/IFoo.java", &code));
1613 EXPECT_THAT(code, HasSubstr("@Foo\n"));
1614 EXPECT_THAT(code, HasSubstr("@Bar\n"));
1615}
1616
Jiyong Park02da7422018-07-16 16:00:26 +09001617TEST_F(AidlTest, ApiDump) {
1618 io_delegate_.SetFileContents(
1619 "foo/bar/IFoo.aidl",
1620 "package foo.bar;\n"
1621 "import foo.bar.Data;\n"
Jooyung Han24effbf2021-01-16 10:24:03 +09001622 "// commented /* @hide */\n"
Jiyong Park02da7422018-07-16 16:00:26 +09001623 "interface IFoo {\n"
Jooyung Han161bb0f2021-01-21 12:30:16 +09001624 " /* @hide applied \n"
1625 " @deprecated use foo2 */\n"
1626 " int foo(out int[] a, String b, boolean c, inout List<String> d);\n"
1627 " int foo2(@utf8InCpp String x, inout List<String> y);\n"
Jiyong Park02da7422018-07-16 16:00:26 +09001628 " IFoo foo3(IFoo foo);\n"
1629 " Data getData();\n"
Jooyung Han161bb0f2021-01-21 12:30:16 +09001630 " // @hide not applied\n"
Jooyung Han9fd67022021-01-13 10:49:48 +09001631 " /** blahblah\n"
1632 " @deprecated\n"
1633 " reason why... */\n"
Jiyong Parka428d212018-08-29 22:26:30 +09001634 " const int A = 1;\n"
Jooyung Han24effbf2021-01-16 10:24:03 +09001635 " // @deprecated tags in line comments are ignored\n"
Jiyong Parka428d212018-08-29 22:26:30 +09001636 " const String STR = \"Hello\";\n"
Jiyong Park02da7422018-07-16 16:00:26 +09001637 "}\n");
1638 io_delegate_.SetFileContents("foo/bar/Data.aidl",
1639 "package foo.bar;\n"
1640 "import foo.bar.IFoo;\n"
Jeongik Cha997281d2020-01-16 15:23:59 +09001641 "/* @hide*/\n"
Jiyong Park02da7422018-07-16 16:00:26 +09001642 "parcelable Data {\n"
Jeongik Cha997281d2020-01-16 15:23:59 +09001643 " // @hide\n"
Jiyong Parka468e2a2018-08-29 21:25:18 +09001644 " int x = 10;\n"
Jeongik Cha997281d2020-01-16 15:23:59 +09001645 " // @hide\n"
Jiyong Park02da7422018-07-16 16:00:26 +09001646 " int y;\n"
Jeongik Cha997281d2020-01-16 15:23:59 +09001647 " /*@hide2*/\n"
Jooyung Han55f96ad2020-12-13 10:08:33 +09001648 " IFoo foo;\n"
Jooyung Han24effbf2021-01-16 10:24:03 +09001649 " // Ignore @hide property in line comment\n"
Jeongik Cha3271ffa2018-12-04 15:19:20 +09001650 " @nullable String[] c;\n"
Jiyong Park02da7422018-07-16 16:00:26 +09001651 "}\n");
1652 io_delegate_.SetFileContents("api.aidl", "");
Jiyong Park633246c2019-11-25 10:50:05 +09001653 vector<string> args = {"aidl", "--dumpapi", "--out=dump", "--include=.",
1654 "foo/bar/IFoo.aidl", "foo/bar/Data.aidl"};
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001655 Options options = Options::From(args);
Jiyong Park02da7422018-07-16 16:00:26 +09001656 bool result = dump_api(options, io_delegate_);
1657 ASSERT_TRUE(result);
1658 string actual;
Jiyong Parke59c3682018-09-11 23:10:25 +09001659 EXPECT_TRUE(io_delegate_.GetWrittenContents("dump/foo/bar/IFoo.aidl", &actual));
Jooyung Han161bb0f2021-01-21 12:30:16 +09001660 EXPECT_EQ(string(kPreamble).append(R"(package foo.bar;
Jiyong Parke59c3682018-09-11 23:10:25 +09001661interface IFoo {
Jooyung Han161bb0f2021-01-21 12:30:16 +09001662 /**
1663 * @hide
1664 * @deprecated use foo2
1665 */
Jiyong Parke59c3682018-09-11 23:10:25 +09001666 int foo(out int[] a, String b, boolean c, inout List<String> d);
1667 int foo2(@utf8InCpp String x, inout List<String> y);
1668 foo.bar.IFoo foo3(foo.bar.IFoo foo);
1669 foo.bar.Data getData();
Jooyung Han161bb0f2021-01-21 12:30:16 +09001670 /**
1671 * @deprecated reason why...
1672 */
Jiyong Parke59c3682018-09-11 23:10:25 +09001673 const int A = 1;
1674 const String STR = "Hello";
1675}
Jooyung Han161bb0f2021-01-21 12:30:16 +09001676)"),
1677 actual);
Jiyong Park02da7422018-07-16 16:00:26 +09001678
Jiyong Parke59c3682018-09-11 23:10:25 +09001679 EXPECT_TRUE(io_delegate_.GetWrittenContents("dump/foo/bar/Data.aidl", &actual));
Jooyung Han161bb0f2021-01-21 12:30:16 +09001680 EXPECT_EQ(string(kPreamble).append(R"(package foo.bar;
Jooyung Han8db65942021-03-02 18:14:44 +09001681/* @hide */
Jiyong Parke59c3682018-09-11 23:10:25 +09001682parcelable Data {
1683 int x = 10;
1684 int y;
1685 foo.bar.IFoo foo;
Jeongik Cha3271ffa2018-12-04 15:19:20 +09001686 @nullable String[] c;
Jiyong Park02da7422018-07-16 16:00:26 +09001687}
Jooyung Han161bb0f2021-01-21 12:30:16 +09001688)"),
1689 actual);
Jiyong Park02da7422018-07-16 16:00:26 +09001690}
1691
Jiyong Parked65bf42018-08-28 15:43:27 +09001692TEST_F(AidlTest, ApiDumpWithManualIds) {
1693 io_delegate_.SetFileContents(
1694 "foo/bar/IFoo.aidl",
1695 "package foo.bar;\n"
1696 "interface IFoo {\n"
1697 " int foo() = 1;\n"
1698 " int bar() = 2;\n"
1699 " int baz() = 10;\n"
1700 "}\n");
1701
Jiyong Parke59c3682018-09-11 23:10:25 +09001702 vector<string> args = {"aidl", "--dumpapi", "-o dump", "foo/bar/IFoo.aidl"};
Jiyong Parked65bf42018-08-28 15:43:27 +09001703 Options options = Options::From(args);
1704 bool result = dump_api(options, io_delegate_);
1705 ASSERT_TRUE(result);
1706 string actual;
Jiyong Parke59c3682018-09-11 23:10:25 +09001707 EXPECT_TRUE(io_delegate_.GetWrittenContents("dump/foo/bar/IFoo.aidl", &actual));
Paul Trautrimb01451d2020-02-27 13:10:16 +09001708 EXPECT_EQ(actual, string(kPreamble).append(R"(package foo.bar;
Jiyong Parke59c3682018-09-11 23:10:25 +09001709interface IFoo {
1710 int foo() = 1;
1711 int bar() = 2;
1712 int baz() = 10;
Jiyong Parked65bf42018-08-28 15:43:27 +09001713}
Paul Trautrimb01451d2020-02-27 13:10:16 +09001714)"));
Jiyong Parked65bf42018-08-28 15:43:27 +09001715}
1716
1717TEST_F(AidlTest, ApiDumpWithManualIdsOnlyOnSomeMethods) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001718 const string expected_stderr =
1719 "ERROR: foo/bar/IFoo.aidl:4.8-12: You must either assign id's to all methods or to none of "
1720 "them.\n";
Jiyong Parked65bf42018-08-28 15:43:27 +09001721 io_delegate_.SetFileContents(
1722 "foo/bar/IFoo.aidl",
1723 "package foo.bar;\n"
1724 "interface IFoo {\n"
1725 " int foo() = 1;\n"
1726 " int bar();\n"
1727 " int baz() = 10;\n"
1728 "}\n");
1729
Jiyong Parke59c3682018-09-11 23:10:25 +09001730 vector<string> args = {"aidl", "--dumpapi", "-o dump", "foo/bar/IFoo.aidl"};
Jiyong Parked65bf42018-08-28 15:43:27 +09001731 Options options = Options::From(args);
Devin Moore097a3ab2020-03-11 16:08:44 -07001732 CaptureStderr();
Jiyong Parked65bf42018-08-28 15:43:27 +09001733 EXPECT_FALSE(dump_api(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001734 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Parked65bf42018-08-28 15:43:27 +09001735}
1736
Jooyung Han965e31d2020-11-27 12:30:16 +09001737TEST_F(AidlTest, ApiDumpConstWithAnnotation) {
1738 io_delegate_.SetFileContents("foo/bar/IFoo.aidl",
1739 "package foo.bar;\n"
1740 "interface IFoo {\n"
1741 " @utf8InCpp String foo();\n"
1742 " const @utf8InCpp String bar = \"bar\";\n"
1743 "}\n");
1744
1745 vector<string> args = {"aidl", "--dumpapi", "-o dump", "foo/bar/IFoo.aidl"};
1746 Options options = Options::From(args);
1747 CaptureStderr();
1748 EXPECT_TRUE(dump_api(options, io_delegate_));
1749 EXPECT_EQ("", GetCapturedStderr());
1750 string actual;
1751 EXPECT_TRUE(io_delegate_.GetWrittenContents("dump/foo/bar/IFoo.aidl", &actual));
Jooyung Han965e31d2020-11-27 12:30:16 +09001752 EXPECT_EQ(string(kPreamble).append(R"(package foo.bar;
1753interface IFoo {
1754 @utf8InCpp String foo();
Jooyung Hanb3ca6302020-11-27 14:13:27 +09001755 const @utf8InCpp String bar = "bar";
Jooyung Han965e31d2020-11-27 12:30:16 +09001756}
1757)"),
1758 actual);
1759}
1760
Jooyung Hanfdaae1d2020-12-14 13:16:15 +09001761TEST_F(AidlTest, ApiDumpWithEnums) {
1762 io_delegate_.SetFileContents("foo/bar/Enum.aidl",
1763 "package foo.bar;\n"
1764 "enum Enum {\n"
1765 " FOO,\n"
1766 " BAR = FOO + 1,\n"
1767 "}\n");
1768
1769 vector<string> args = {"aidl", "--dumpapi", "-I . ", "-o dump", "foo/bar/Enum.aidl"};
1770 Options options = Options::From(args);
1771 CaptureStderr();
1772 EXPECT_TRUE(dump_api(options, io_delegate_));
1773 EXPECT_EQ("", GetCapturedStderr());
1774 string actual;
1775 EXPECT_TRUE(io_delegate_.GetWrittenContents("dump/foo/bar/Enum.aidl", &actual));
1776 EXPECT_EQ(string(kPreamble).append("package foo.bar;\n"
1777 "enum Enum {\n"
1778 " FOO = 0,\n"
1779 " BAR = 1,\n"
1780 "}\n"),
1781 actual);
1782}
1783
1784TEST_F(AidlTest, ApiDumpWithEnumDefaultValues) {
1785 io_delegate_.SetFileContents("foo/bar/Enum.aidl",
1786 "package foo.bar;\n"
1787 "enum Enum {\n"
1788 " FOO,\n"
1789 "}\n");
1790 io_delegate_.SetFileContents("foo/bar/Foo.aidl",
1791 "package foo.bar;\n"
1792 "import foo.bar.Enum;\n"
1793 "parcelable Foo {\n"
1794 " Enum e = Enum.FOO;\n"
1795 "}\n");
1796
1797 vector<string> args = {"aidl", "--dumpapi", "-I . ", "-o dump", "foo/bar/Foo.aidl"};
1798 Options options = Options::From(args);
1799 CaptureStderr();
1800 EXPECT_TRUE(dump_api(options, io_delegate_));
1801 EXPECT_EQ("", GetCapturedStderr());
1802 string actual;
1803 EXPECT_TRUE(io_delegate_.GetWrittenContents("dump/foo/bar/Foo.aidl", &actual));
1804 EXPECT_EQ(string(kPreamble).append("package foo.bar;\n"
1805 "parcelable Foo {\n"
1806 " foo.bar.Enum e = foo.bar.Enum.FOO;\n"
1807 "}\n"),
1808 actual);
1809}
1810
Jooyung Han71dfec32021-05-23 07:18:58 +09001811TEST_F(AidlTest, ApiDumpWithGenerics) {
1812 io_delegate_.SetFileContents("foo/bar/Foo.aidl",
1813 "package foo.bar;\n"
1814 "parcelable Foo<T, U> {\n"
1815 "}\n");
1816
1817 vector<string> args = {"aidl", "--dumpapi", "-I . ", "-o dump", "foo/bar/Foo.aidl"};
1818 Options options = Options::From(args);
1819 CaptureStderr();
1820 EXPECT_TRUE(dump_api(options, io_delegate_));
1821 EXPECT_EQ("", GetCapturedStderr());
1822 string actual;
1823 EXPECT_TRUE(io_delegate_.GetWrittenContents("dump/foo/bar/Foo.aidl", &actual));
1824 EXPECT_EQ(string(kPreamble).append("package foo.bar;\n"
1825 "parcelable Foo<T, U> {\n"
1826 "}\n"),
1827 actual);
1828}
1829
Jiyong Park1d2df7d2018-07-23 15:22:50 +09001830TEST_F(AidlTest, CheckNumGenericTypeSecifier) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001831 const string expected_list_stderr =
Steven Morelandebc3c5d2020-09-30 23:40:33 +00001832 "ERROR: p/IFoo.aidl:1.37-41: List can only have one type parameter, but got: "
1833 "'List<String,String>'\n";
Devin Moore097a3ab2020-03-11 16:08:44 -07001834 const string expected_map_stderr =
1835 "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 +09001836 Options options = Options::From("aidl p/IFoo.aidl IFoo.java");
1837 io_delegate_.SetFileContents(options.InputFiles().front(),
Jiyong Park1d2df7d2018-07-23 15:22:50 +09001838 "package p; interface IFoo {"
1839 "void foo(List<String, String> a);}");
Devin Moore097a3ab2020-03-11 16:08:44 -07001840 CaptureStderr();
Jiyong Parkb034bf02018-07-30 17:44:33 +09001841 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001842 EXPECT_EQ(expected_list_stderr, GetCapturedStderr());
Jiyong Park1d2df7d2018-07-23 15:22:50 +09001843
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001844 io_delegate_.SetFileContents(options.InputFiles().front(),
Jiyong Park1d2df7d2018-07-23 15:22:50 +09001845 "package p; interface IFoo {"
1846 "void foo(Map<String> a);}");
Devin Moore097a3ab2020-03-11 16:08:44 -07001847 CaptureStderr();
Jiyong Parkb034bf02018-07-30 17:44:33 +09001848 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001849 EXPECT_EQ(expected_map_stderr, GetCapturedStderr());
Jiyong Parkb034bf02018-07-30 17:44:33 +09001850}
1851
Jeongik Chae48d9942020-01-02 17:39:00 +09001852TEST_F(AidlTest, CheckTypeParameterInMapType) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001853 const string expected_stderr =
1854 "ERROR: p/IFoo.aidl:1.28-31: The type of key in map must be String, but it is 'p.Bar'\n";
Jooyung Han13f1fa52021-06-11 18:06:12 +09001855 Options options = Options::From("aidl -I . p/IFoo.aidl");
Jeongik Chae48d9942020-01-02 17:39:00 +09001856 io_delegate_.SetFileContents("p/Bar.aidl", "package p; parcelable Bar { String s; }");
1857
1858 io_delegate_.SetFileContents("p/IFoo.aidl",
1859 "package p; interface IFoo {"
Jooyung Han13f1fa52021-06-11 18:06:12 +09001860 "Map<String, p.Bar> foo();}");
Jeongik Chae48d9942020-01-02 17:39:00 +09001861 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1862
1863 io_delegate_.SetFileContents("p/IFoo.aidl",
1864 "package p; interface IFoo {"
Jooyung Han13f1fa52021-06-11 18:06:12 +09001865 "Map<p.Bar, p.Bar> foo();}");
Devin Moore097a3ab2020-03-11 16:08:44 -07001866 CaptureStderr();
Jeongik Chae48d9942020-01-02 17:39:00 +09001867 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001868 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jeongik Chae48d9942020-01-02 17:39:00 +09001869
1870 io_delegate_.SetFileContents("p/IFoo.aidl",
1871 "package p; interface IFoo {"
1872 "Map<String, String> foo();}");
1873 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1874
1875 io_delegate_.SetFileContents("p/IFoo.aidl",
1876 "package p; interface IFoo {"
1877 "Map<String, ParcelFileDescriptor> foo();}");
1878 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1879}
1880
Jeongik Chadf76dc72019-11-28 00:08:47 +09001881TEST_F(AidlTest, WrongGenericType) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001882 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 +09001883 Options options = Options::From("aidl p/IFoo.aidl IFoo.java");
1884 io_delegate_.SetFileContents(options.InputFiles().front(),
1885 "package p; interface IFoo {"
1886 "String<String> foo(); }");
Devin Moore097a3ab2020-03-11 16:08:44 -07001887 CaptureStderr();
Jeongik Chadf76dc72019-11-28 00:08:47 +09001888 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001889 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jeongik Chadf76dc72019-11-28 00:08:47 +09001890}
1891
1892TEST_F(AidlTest, UserDefinedUnstructuredGenericParcelableType) {
Jooyung Han13f1fa52021-06-11 18:06:12 +09001893 Options optionsForParcelable = Options::From("aidl -I . p/Bar.aidl");
Jeongik Chadf76dc72019-11-28 00:08:47 +09001894 io_delegate_.SetFileContents("p/Bar.aidl", "package p; parcelable Bar<T, T>;");
Devin Moore097a3ab2020-03-11 16:08:44 -07001895 CaptureStderr();
Jeongik Chadf76dc72019-11-28 00:08:47 +09001896 EXPECT_NE(0, ::android::aidl::compile_aidl(optionsForParcelable, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001897 EXPECT_EQ("ERROR: p/Bar.aidl:1.22-26: Every type parameter should be unique.\n",
1898 GetCapturedStderr());
Jeongik Chadf76dc72019-11-28 00:08:47 +09001899
Jooyung Han13f1fa52021-06-11 18:06:12 +09001900 Options options = Options::From("aidl -I . p/IFoo.aidl");
Jeongik Chadf76dc72019-11-28 00:08:47 +09001901 io_delegate_.SetFileContents("p/Bar.aidl", "package p; parcelable Bar;");
1902 io_delegate_.SetFileContents("p/IFoo.aidl",
1903 "package p; interface IFoo {"
Jooyung Han13f1fa52021-06-11 18:06:12 +09001904 "p.Bar<String, String> foo();}");
Devin Moore097a3ab2020-03-11 16:08:44 -07001905 CaptureStderr();
Jeongik Chadf76dc72019-11-28 00:08:47 +09001906 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jooyung Han13f1fa52021-06-11 18:06:12 +09001907 EXPECT_THAT(GetCapturedStderr(), HasSubstr("p.Bar is not a generic type"));
Jeongik Chadf76dc72019-11-28 00:08:47 +09001908 io_delegate_.SetFileContents("p/Bar.aidl", "package p; parcelable Bar<T>;");
Devin Moore097a3ab2020-03-11 16:08:44 -07001909 CaptureStderr();
Jeongik Chadf76dc72019-11-28 00:08:47 +09001910 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jooyung Han13f1fa52021-06-11 18:06:12 +09001911 EXPECT_THAT(GetCapturedStderr(), HasSubstr("p.Bar must have 1 type parameters, but got 2"));
Jeongik Chadf76dc72019-11-28 00:08:47 +09001912 io_delegate_.SetFileContents("p/Bar.aidl", "package p; parcelable Bar<T, V>;");
1913 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1914 io_delegate_.SetFileContents("p/IFoo.aidl",
1915 "package p; interface IFoo {"
Jooyung Han13f1fa52021-06-11 18:06:12 +09001916 "p.Bar<String, ParcelFileDescriptor> foo();}");
Jeongik Chadf76dc72019-11-28 00:08:47 +09001917 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jeongik Chae74c86d2019-12-12 16:54:03 +09001918
1919 io_delegate_.SetFileContents("p/IFoo.aidl",
1920 "package p; interface IFoo {"
Jooyung Han13f1fa52021-06-11 18:06:12 +09001921 "p.Bar<int, long> foo();}");
Jeongik Chae74c86d2019-12-12 16:54:03 +09001922
1923 io_delegate_.SetFileContents("p/IFoo.aidl",
1924 "package p; interface IFoo {"
Jooyung Han13f1fa52021-06-11 18:06:12 +09001925 "p.Bar<int[], long[]> foo();}");
Jeongik Chae74c86d2019-12-12 16:54:03 +09001926
1927 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jeongik Chadf76dc72019-11-28 00:08:47 +09001928}
1929
Jeongik Cha0e426012019-07-29 15:57:02 +09001930TEST_F(AidlTest, FailOnMultipleTypesInSingleFile) {
1931 std::vector<std::string> rawOptions{"aidl --lang=java -o out foo/bar/Foo.aidl",
Andrei Homescub62afd92020-05-11 19:24:59 -07001932 "aidl --lang=cpp -o out -h out/include foo/bar/Foo.aidl",
1933 "aidl --lang=rust -o out foo/bar/Foo.aidl"};
Devin Moore5de18ed2020-04-02 13:52:29 -07001934 for (const auto& rawOption : rawOptions) {
1935 string expected_stderr =
1936 "ERROR: foo/bar/Foo.aidl:3.1-10: You must declare only one type per file.\n";
Jeongik Cha0e426012019-07-29 15:57:02 +09001937 Options options = Options::From(rawOption);
1938 io_delegate_.SetFileContents(options.InputFiles().front(),
1939 "package foo.bar;\n"
1940 "interface IFoo1 { int foo(); }\n"
1941 "interface IFoo2 { int foo(); }\n"
1942 "parcelable Data1 { int a; int b;}\n"
1943 "parcelable Data2 { int a; int b;}\n");
Devin Moore097a3ab2020-03-11 16:08:44 -07001944 CaptureStderr();
Jeongik Cha0e426012019-07-29 15:57:02 +09001945 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001946 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Parkb034bf02018-07-30 17:44:33 +09001947
Jeongik Cha0e426012019-07-29 15:57:02 +09001948 io_delegate_.SetFileContents(options.InputFiles().front(),
1949 "package foo.bar;\n"
1950 "interface IFoo1 { int foo(); }\n"
1951 "interface IFoo2 { int foo(); }\n");
Devin Moore097a3ab2020-03-11 16:08:44 -07001952 CaptureStderr();
Jeongik Cha0e426012019-07-29 15:57:02 +09001953 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001954 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Parkb034bf02018-07-30 17:44:33 +09001955
Devin Moore5de18ed2020-04-02 13:52:29 -07001956 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 +09001957 io_delegate_.SetFileContents(options.InputFiles().front(),
1958 "package foo.bar;\n"
1959 "parcelable Data1 { int a; int b;}\n"
1960 "parcelable Data2 { int a; int b;}\n");
Devin Moore097a3ab2020-03-11 16:08:44 -07001961 CaptureStderr();
Jeongik Cha0e426012019-07-29 15:57:02 +09001962 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001963 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Parkb034bf02018-07-30 17:44:33 +09001964 }
1965}
1966
Devin Moorebdba2a82020-03-31 15:19:02 -07001967TEST_P(AidlTest, FailParseOnEmptyFile) {
1968 const string contents = "";
1969 const string expected_stderr = "ERROR: a/IFoo.aidl:1.1-1: syntax error, unexpected $end\n";
1970 CaptureStderr();
1971 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", contents, typenames_, GetLanguage()));
1972 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1973}
1974
Jiyong Parkb034bf02018-07-30 17:44:33 +09001975TEST_F(AidlTest, MultipleInputFiles) {
1976 Options options = Options::From(
Jiyong Park633246c2019-11-25 10:50:05 +09001977 "aidl --lang=java -o out -I . foo/bar/IFoo.aidl foo/bar/Data.aidl");
Jiyong Parkb034bf02018-07-30 17:44:33 +09001978
1979 io_delegate_.SetFileContents(options.InputFiles().at(0),
1980 "package foo.bar;\n"
1981 "import foo.bar.Data;\n"
1982 "interface IFoo { Data getData(); }\n");
1983
1984 io_delegate_.SetFileContents(options.InputFiles().at(1),
1985 "package foo.bar;\n"
1986 "import foo.bar.IFoo;\n"
1987 "parcelable Data { IFoo foo; }\n");
1988
1989 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1990
1991 string content;
1992 for (const auto file : {
1993 "out/foo/bar/IFoo.java", "out/foo/bar/Data.java"}) {
1994 content.clear();
1995 EXPECT_TRUE(io_delegate_.GetWrittenContents(file, &content));
1996 EXPECT_FALSE(content.empty());
1997 }
1998}
1999
2000TEST_F(AidlTest, MultipleInputFilesCpp) {
2001 Options options = Options::From("aidl --lang=cpp -o out -h out/include "
Jiyong Park633246c2019-11-25 10:50:05 +09002002 "-I . foo/bar/IFoo.aidl foo/bar/Data.aidl");
Jiyong Parkb034bf02018-07-30 17:44:33 +09002003
2004 io_delegate_.SetFileContents(options.InputFiles().at(0),
2005 "package foo.bar;\n"
2006 "import foo.bar.Data;\n"
2007 "interface IFoo { Data getData(); }\n");
2008
2009 io_delegate_.SetFileContents(options.InputFiles().at(1),
2010 "package foo.bar;\n"
2011 "import foo.bar.IFoo;\n"
2012 "parcelable Data { IFoo foo; }\n");
2013
2014 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
2015
2016 string content;
2017 for (const auto file : {
Jiyong Parkb03551f2018-08-06 19:20:51 +09002018 "out/foo/bar/IFoo.cpp", "out/foo/bar/Data.cpp",
Jiyong Parkb034bf02018-07-30 17:44:33 +09002019 "out/include/foo/bar/IFoo.h", "out/include/foo/bar/Data.h",
2020 "out/include/foo/bar/BpFoo.h", "out/include/foo/bar/BpData.h",
2021 "out/include/foo/bar/BnFoo.h", "out/include/foo/bar/BnData.h"}) {
2022 content.clear();
2023 EXPECT_TRUE(io_delegate_.GetWrittenContents(file, &content));
2024 EXPECT_FALSE(content.empty());
2025 }
Jiyong Park1d2df7d2018-07-23 15:22:50 +09002026}
2027
Andrei Homescub62afd92020-05-11 19:24:59 -07002028TEST_F(AidlTest, MultipleInputFilesRust) {
2029 Options options =
2030 Options::From("aidl --lang=rust -o out -I . foo/bar/IFoo.aidl foo/bar/Data.aidl");
2031
2032 io_delegate_.SetFileContents(options.InputFiles().at(0),
2033 "package foo.bar;\n"
2034 "import foo.bar.Data;\n"
2035 "interface IFoo { Data getData(); }\n");
2036
2037 io_delegate_.SetFileContents(options.InputFiles().at(1),
2038 "package foo.bar;\n"
2039 "import foo.bar.IFoo;\n"
2040 "parcelable Data { IFoo foo; }\n");
2041
2042 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
2043
2044 string content;
2045 for (const auto file : {"out/foo/bar/IFoo.rs", "out/foo/bar/Data.rs"}) {
2046 content.clear();
2047 EXPECT_TRUE(io_delegate_.GetWrittenContents(file, &content));
2048 EXPECT_FALSE(content.empty());
2049 }
2050}
2051
Devin Moore097a3ab2020-03-11 16:08:44 -07002052TEST_F(AidlTest, ConflictWithMetaTransactionGetVersion) {
2053 const string expected_stderr =
2054 "ERROR: p/IFoo.aidl:1.31-51: method getInterfaceVersion() is reserved for internal use.\n";
Jiyong Park309668e2018-07-28 16:55:44 +09002055 Options options = Options::From("aidl --lang=java -o place/for/output p/IFoo.aidl");
2056 // int getInterfaceVersion() is one of the meta transactions
2057 io_delegate_.SetFileContents(options.InputFiles().front(),
2058 "package p; interface IFoo {"
2059 "int getInterfaceVersion(); }");
Devin Moore097a3ab2020-03-11 16:08:44 -07002060 CaptureStderr();
Jiyong Parkb034bf02018-07-30 17:44:33 +09002061 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002062 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2063}
Jiyong Park309668e2018-07-28 16:55:44 +09002064
Devin Moore097a3ab2020-03-11 16:08:44 -07002065TEST_F(AidlTest, ConflictWithSimilarMetaTransaction) {
2066 // boolean getInterfaceVersion() is not a meta transaction, but should be
2067 // prevented because return type is not part of a method signature
2068 const string expected_stderr =
2069 "ERROR: p/IFoo.aidl:1.35-55: method getInterfaceVersion() is reserved for internal use.\n";
2070 Options options = Options::From("aidl --lang=java -o place/for/output p/IFoo.aidl");
Jiyong Park309668e2018-07-28 16:55:44 +09002071 io_delegate_.SetFileContents(options.InputFiles().front(),
2072 "package p; interface IFoo {"
2073 "boolean getInterfaceVersion(); }");
Devin Moore097a3ab2020-03-11 16:08:44 -07002074 CaptureStderr();
Jiyong Parkb034bf02018-07-30 17:44:33 +09002075 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002076 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2077}
Jiyong Park309668e2018-07-28 16:55:44 +09002078
Devin Moore097a3ab2020-03-11 16:08:44 -07002079TEST_F(AidlTest, ConflictWithMetaTransactionGetName) {
Jiyong Park309668e2018-07-28 16:55:44 +09002080 // this is another reserved name
Devin Moore097a3ab2020-03-11 16:08:44 -07002081 const string expected_stderr =
2082 "ERROR: p/IFoo.aidl:1.34-53: method getTransactionName(int) is reserved for internal use.\n";
2083 Options options = Options::From("aidl --lang=java -o place/for/output p/IFoo.aidl");
Jiyong Park309668e2018-07-28 16:55:44 +09002084 io_delegate_.SetFileContents(options.InputFiles().front(),
2085 "package p; interface IFoo {"
2086 "String getTransactionName(int code); }");
Devin Moore097a3ab2020-03-11 16:08:44 -07002087 CaptureStderr();
Jiyong Parkb034bf02018-07-30 17:44:33 +09002088 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002089 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Park309668e2018-07-28 16:55:44 +09002090
2091 // this is not a meta interface method as it differs type arguments
2092 io_delegate_.SetFileContents(options.InputFiles().front(),
2093 "package p; interface IFoo {"
2094 "String getTransactionName(); }");
Jiyong Parkb034bf02018-07-30 17:44:33 +09002095 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jiyong Park309668e2018-07-28 16:55:44 +09002096}
2097
Jooyung Hanb8a97772021-01-19 01:27:38 +09002098TEST_F(AidlTest, CheckApiForEquality) {
2099 CaptureStderr();
2100 Options options = Options::From("aidl --checkapi=equal old new");
2101
2102 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2103 "package p; interface IFoo{ @utf8InCpp @nullable String foo();}");
2104 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2105 "package p; interface IFoo{ @utf8InCpp String foo();}");
2106
2107 EXPECT_FALSE(::android::aidl::check_api(options, io_delegate_));
2108 EXPECT_THAT(GetCapturedStderr(), HasSubstr("+ @utf8InCpp String foo();"));
2109}
2110
Daniel Norman85aed542019-08-21 12:01:14 -07002111TEST_F(AidlTest, DifferentOrderAnnotationsInCheckAPI) {
Jeongik Cha3271ffa2018-12-04 15:19:20 +09002112 Options options = Options::From("aidl --checkapi old new");
2113 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2114 "package p; interface IFoo{ @utf8InCpp @nullable String foo();}");
2115 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2116 "package p; interface IFoo{ @nullable @utf8InCpp String foo();}");
2117
2118 EXPECT_TRUE(::android::aidl::check_api(options, io_delegate_));
2119}
2120
Jiyong Park3656c3c2018-08-01 20:02:01 +09002121TEST_F(AidlTest, SuccessOnIdenticalApiDumps) {
Jiyong Parke59c3682018-09-11 23:10:25 +09002122 Options options = Options::From("aidl --checkapi old new");
2123 io_delegate_.SetFileContents("old/p/IFoo.aidl", "package p; interface IFoo{ void foo();}");
2124 io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p; interface IFoo{ void foo();}");
Jiyong Park3656c3c2018-08-01 20:02:01 +09002125
2126 EXPECT_TRUE(::android::aidl::check_api(options, io_delegate_));
2127}
2128
Jooyung Hanfdaae1d2020-12-14 13:16:15 +09002129TEST_F(AidlTest, CheckApi_EnumFieldsWithDefaultValues) {
2130 Options options = Options::From("aidl --checkapi old new");
2131 const string foo_definition = "package p; parcelable Foo{ p.Enum e = p.Enum.FOO; }";
2132 const string enum_definition = "package p; enum Enum { FOO }";
2133 io_delegate_.SetFileContents("old/p/Foo.aidl", foo_definition);
2134 io_delegate_.SetFileContents("old/p/Enum.aidl", enum_definition);
2135 io_delegate_.SetFileContents("new/p/Foo.aidl", foo_definition);
2136 io_delegate_.SetFileContents("new/p/Enum.aidl", enum_definition);
2137
2138 EXPECT_TRUE(::android::aidl::check_api(options, io_delegate_));
2139}
2140
Jooyung Han8e3b72c2021-05-22 02:54:37 +09002141TEST_F(AidlTest, CheckApi_EnumFieldsFromImported) {
2142 Options options = Options::From("aidl --checkapi old new -I import");
2143
2144 io_delegate_.SetFileContents("old/p/Foo.aidl", "package p; parcelable Foo{ other.Enum e; }");
2145 io_delegate_.SetFileContents("new/p/Foo.aidl",
2146 "package p; parcelable Foo{ other.Enum e = other.Enum.FOO; }");
2147 io_delegate_.SetFileContents("import/other/Enum.aidl", "package other; enum Enum { FOO }");
2148
2149 EXPECT_TRUE(::android::aidl::check_api(options, io_delegate_));
2150}
2151
Jooyung Han02a11be2021-02-11 13:18:06 +09002152TEST_F(AidlTest, CheckApiEqual_EnumFieldsWithDefaultValues) {
2153 Options options = Options::From("aidl --checkapi=equal old new");
2154 const string foo_definition = "package p; parcelable Foo{ p.Enum e = p.Enum.FOO; }";
2155 const string enum_definition = "package p; enum Enum { FOO }";
2156 io_delegate_.SetFileContents("old/p/Foo.aidl", foo_definition);
2157 io_delegate_.SetFileContents("old/p/Enum.aidl", enum_definition);
2158 io_delegate_.SetFileContents("new/p/Foo.aidl", foo_definition);
2159 io_delegate_.SetFileContents("new/p/Enum.aidl", enum_definition);
2160 CaptureStderr();
2161 EXPECT_TRUE(::android::aidl::check_api(options, io_delegate_));
2162 EXPECT_EQ("", GetCapturedStderr());
2163}
2164
Daniel Norman85aed542019-08-21 12:01:14 -07002165class AidlTestCompatibleChanges : public AidlTest {
2166 protected:
2167 Options options_ = Options::From("aidl --checkapi old new");
2168};
2169
2170TEST_F(AidlTestCompatibleChanges, NewType) {
2171 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2172 "package p;"
2173 "interface IFoo {"
2174 " void foo(int a);"
2175 "}");
2176 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2177 "package p;"
2178 "interface IFoo {"
2179 " void foo(int a);"
2180 "}");
2181 io_delegate_.SetFileContents("new/p/IBar.aidl",
2182 "package p;"
2183 "interface IBar {"
2184 " void bar();"
2185 "}");
2186 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2187}
2188
2189TEST_F(AidlTestCompatibleChanges, NewMethod) {
2190 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2191 "package p;"
2192 "interface IFoo {"
2193 " void foo(int a);"
2194 "}");
2195 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2196 "package p;"
2197 "interface IFoo {"
2198 " void foo(int a);"
2199 " void bar();"
Jooyung Han8e3b72c2021-05-22 02:54:37 +09002200 " void baz(in List<String> arg);"
Daniel Norman85aed542019-08-21 12:01:14 -07002201 "}");
2202 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2203}
2204
2205TEST_F(AidlTestCompatibleChanges, NewField) {
2206 io_delegate_.SetFileContents("old/p/Data.aidl",
2207 "package p;"
2208 "parcelable Data {"
2209 " int foo;"
2210 "}");
2211 io_delegate_.SetFileContents("new/p/Data.aidl",
2212 "package p;"
2213 "parcelable Data {"
2214 " int foo;"
Steven Moreland370ed342020-04-28 18:14:39 -07002215 " int bar = 0;"
Jiyong Parkf8d53612020-05-04 14:06:13 +09002216 " @nullable List<Data> list;"
Daniel Norman85aed542019-08-21 12:01:14 -07002217 "}");
2218 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2219}
2220
Jooyung Han05bd8a82021-04-28 23:56:38 +09002221TEST_F(AidlTestCompatibleChanges, NewField2) {
2222 io_delegate_.SetFileContents("old/p/Data.aidl",
2223 "package p;"
2224 "parcelable Data {"
2225 "}");
2226 io_delegate_.SetFileContents("new/p/Data.aidl",
2227 "package p;"
2228 "parcelable Data {"
2229 " int foo = 0;"
2230 "}");
2231 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2232}
2233
Daniel Norman85aed542019-08-21 12:01:14 -07002234TEST_F(AidlTestCompatibleChanges, NewEnumerator) {
2235 io_delegate_.SetFileContents("old/p/Enum.aidl",
2236 "package p;"
2237 "enum Enum {"
2238 " FOO = 1,"
2239 "}");
2240 io_delegate_.SetFileContents("new/p/Enum.aidl",
2241 "package p;"
2242 "enum Enum {"
2243 " FOO = 1,"
2244 " BAR = 2,"
2245 "}");
2246 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2247}
2248
2249TEST_F(AidlTestCompatibleChanges, ReorderedEnumerator) {
2250 io_delegate_.SetFileContents("old/p/Enum.aidl",
2251 "package p;"
2252 "enum Enum {"
2253 " FOO = 1,"
2254 " BAR = 2,"
2255 "}");
2256 io_delegate_.SetFileContents("new/p/Enum.aidl",
2257 "package p;"
2258 "enum Enum {"
2259 " BAR = 2,"
2260 " FOO = 1,"
2261 "}");
2262 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2263}
2264
Jooyung Hanb5c55cd2020-10-22 07:59:01 +09002265TEST_F(AidlTestCompatibleChanges, NewUnionField) {
2266 io_delegate_.SetFileContents("old/p/Union.aidl",
2267 "package p;"
2268 "union Union {"
2269 " String foo;"
2270 "}");
2271 io_delegate_.SetFileContents("new/p/Union.aidl",
2272 "package p;"
2273 "union Union {"
2274 " String foo;"
2275 " int num;"
2276 "}");
2277 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2278}
2279
Daniel Norman85aed542019-08-21 12:01:14 -07002280TEST_F(AidlTestCompatibleChanges, NewPackage) {
Jiyong Parke59c3682018-09-11 23:10:25 +09002281 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2282 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002283 "interface IFoo {"
2284 " void foo(int a);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002285 "}");
2286 io_delegate_.SetFileContents("old/p/Data.aidl",
2287 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002288 "parcelable Data {"
2289 " int foo;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002290 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002291 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2292 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002293 "interface IFoo {"
2294 " void foo(int a);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002295 "}");
2296 io_delegate_.SetFileContents("new/p/Data.aidl",
2297 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002298 "parcelable Data {"
2299 " int foo;"
Jiyong Parke59c3682018-09-11 23:10:25 +09002300 "}");
2301 io_delegate_.SetFileContents("new/q/IFoo.aidl",
2302 "package q;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002303 "interface IFoo {"
Jiyong Parke59c3682018-09-11 23:10:25 +09002304 " void foo(int a);"
2305 "}");
2306 io_delegate_.SetFileContents("new/q/Data.aidl",
2307 "package q;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002308 "parcelable Data {"
2309 " int foo;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002310 "}");
Daniel Norman85aed542019-08-21 12:01:14 -07002311 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2312}
Jiyong Park3656c3c2018-08-01 20:02:01 +09002313
Daniel Norman85aed542019-08-21 12:01:14 -07002314TEST_F(AidlTestCompatibleChanges, ArgNameChange) {
2315 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2316 "package p;"
2317 "interface IFoo {"
2318 " void foo(int a);"
2319 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002320 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2321 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002322 "interface IFoo {"
2323 " void foo(int b);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002324 "}");
Daniel Norman85aed542019-08-21 12:01:14 -07002325 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2326}
Jiyong Parke59c3682018-09-11 23:10:25 +09002327
Daniel Norman85aed542019-08-21 12:01:14 -07002328TEST_F(AidlTestCompatibleChanges, AddedConstValue) {
Jiyong Parke59c3682018-09-11 23:10:25 +09002329 io_delegate_.SetFileContents("old/p/I.aidl",
2330 "package p; interface I {"
2331 "const int A = 1; }");
2332 io_delegate_.SetFileContents("new/p/I.aidl",
2333 "package p ; interface I {"
2334 "const int A = 1; const int B = 2;}");
Daniel Norman85aed542019-08-21 12:01:14 -07002335 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2336}
Jiyong Parka428d212018-08-29 22:26:30 +09002337
Daniel Norman85aed542019-08-21 12:01:14 -07002338TEST_F(AidlTestCompatibleChanges, ChangedConstValueOrder) {
Jiyong Parke59c3682018-09-11 23:10:25 +09002339 io_delegate_.SetFileContents("old/p/I.aidl",
2340 "package p; interface I {"
2341 "const int A = 1; const int B = 2;}");
2342 io_delegate_.SetFileContents("new/p/I.aidl",
2343 "package p ; interface I {"
2344 "const int B = 2; const int A = 1;}");
Daniel Norman85aed542019-08-21 12:01:14 -07002345 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
Jiyong Park3656c3c2018-08-01 20:02:01 +09002346}
2347
Jooyung Han69ea4ba2020-10-29 15:33:37 +09002348TEST_F(AidlTestCompatibleChanges, ReorderedAnnatations) {
2349 io_delegate_.SetFileContents("old/p/Foo.aidl",
2350 "package p;"
2351 "@JavaPassthrough(annotation=\"Alice\")"
2352 "@JavaPassthrough(annotation=\"Bob\")"
2353 "parcelable Foo {}");
2354 io_delegate_.SetFileContents("new/p/Foo.aidl",
2355 "package p;"
2356 "@JavaPassthrough(annotation=\"Bob\")"
2357 "@JavaPassthrough(annotation=\"Alice\")"
2358 "parcelable Foo {}");
2359 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2360}
2361
Jooyung Han00073272020-11-27 14:20:20 +09002362TEST_F(AidlTestCompatibleChanges, OkayToDeprecate) {
2363 io_delegate_.SetFileContents("old/p/Foo.aidl",
2364 "package p;"
2365 "parcelable Foo {}");
2366 io_delegate_.SetFileContents("new/p/Foo.aidl",
2367 "package p;"
2368 "@JavaPassthrough(annotation=\"@Deprecated\")"
2369 "parcelable Foo {}");
2370 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2371}
2372
Jooyung Han636fd2f2020-10-22 11:33:45 +09002373TEST_F(AidlTestCompatibleChanges, NewFieldOfNewType) {
2374 io_delegate_.SetFileContents("old/p/Data.aidl",
2375 "package p;"
2376 "parcelable Data {"
2377 " int num;"
2378 "}");
2379 io_delegate_.SetFileContents(
2380 "new/p/Data.aidl",
2381 "package p;"
2382 "parcelable Data {"
2383 " int num;"
2384 " p.Enum e;" // this is considered as valid since 0(enum default) is valid for "Enum" type
2385 "}");
2386 io_delegate_.SetFileContents("new/p/Enum.aidl",
2387 "package p;"
2388 "enum Enum {"
2389 " FOO = 0,"
2390 " BAR = 1,"
2391 "}");
2392 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2393}
2394
Jooyung Han308bbe02021-04-27 12:09:59 +09002395TEST_F(AidlTestCompatibleChanges, CompatibleExplicitDefaults) {
2396 io_delegate_.SetFileContents("old/p/Data.aidl",
2397 "package p;\n"
2398 "parcelable Data {\n"
2399 " p.Enum e;\n"
2400 "}");
2401 io_delegate_.SetFileContents("old/p/Enum.aidl",
2402 "package p;\n"
2403 "enum Enum {\n"
2404 " FOO = 0,\n"
2405 " BAR = 1,\n"
2406 "}");
2407 io_delegate_.SetFileContents("new/p/Data.aidl",
2408 "package p;\n"
2409 "parcelable Data {\n"
2410 " p.Enum e = p.Enum.FOO;\n"
2411 "}");
2412 io_delegate_.SetFileContents("new/p/Enum.aidl",
2413 "package p;\n"
2414 "enum Enum {\n"
2415 " FOO = 0,\n"
2416 " BAR = 1,\n"
2417 "}");
2418 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2419}
2420
Daniel Norman85aed542019-08-21 12:01:14 -07002421class AidlTestIncompatibleChanges : public AidlTest {
2422 protected:
2423 Options options_ = Options::From("aidl --checkapi old new");
2424};
2425
2426TEST_F(AidlTestIncompatibleChanges, RemovedType) {
Jiyong Park0cf03b12020-07-22 19:36:34 +09002427 const string expected_stderr = "ERROR: old/p/IFoo.aidl:1.11-20: Removed type: p.IFoo\n";
Jiyong Parke59c3682018-09-11 23:10:25 +09002428 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2429 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002430 "interface IFoo {"
2431 " void foo(in String[] str);"
2432 " void bar(@utf8InCpp String str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002433 "}");
Devin Moored131d5e2020-03-31 10:39:10 -07002434 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002435 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moored131d5e2020-03-31 10:39:10 -07002436 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002437}
2438
2439TEST_F(AidlTestIncompatibleChanges, RemovedMethod) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002440 const string expected_stderr =
2441 "ERROR: old/p/IFoo.aidl:1.61-65: Removed or changed method: p.IFoo.bar(String)\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002442 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2443 "package p;"
2444 "interface IFoo {"
2445 " void foo(in String[] str);"
2446 " void bar(@utf8InCpp String str);"
2447 "}");
2448 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2449 "package p;"
2450 "interface IFoo {"
2451 " void foo(in String[] str);"
2452 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002453 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002454 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002455 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002456}
2457
Jiyong Parkf8d53612020-05-04 14:06:13 +09002458TEST_F(AidlTestIncompatibleChanges, UntypedListInInterface) {
2459 const string expected_stderr =
2460 "ERROR: new/p/IFoo.aidl:1.61-65: "
2461 "Encountered an untyped List or Map. The use of untyped List/Map is "
2462 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
2463 "the receiving side. Consider switching to an array or a generic List/Map.\n"
2464 "ERROR: new/p/IFoo.aidl: Failed to read.\n";
2465 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2466 "package p;"
2467 "interface IFoo {"
2468 " void foo(in String[] str);"
2469 "}");
2470 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2471 "package p;"
2472 "interface IFoo {"
2473 " void foo(in String[] str);"
2474 " void bar(in List arg);"
2475 "}");
2476 CaptureStderr();
2477 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2478 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2479}
2480
2481TEST_F(AidlTestCompatibleChanges, UntypedListInParcelable) {
2482 const string expected_stderr =
2483 "ERROR: new/p/Data.aidl:1.54-59: "
2484 "Encountered an untyped List or Map. The use of untyped List/Map is "
2485 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
2486 "the receiving side. Consider switching to an array or a generic List/Map.\n"
2487 "ERROR: new/p/Data.aidl: Failed to read.\n";
2488 io_delegate_.SetFileContents("old/p/Data.aidl",
2489 "package p;"
2490 "parcelable Data {"
2491 " int foo;"
2492 "}");
2493 io_delegate_.SetFileContents("new/p/Data.aidl",
2494 "package p;"
2495 "parcelable Data {"
2496 " int foo;"
2497 " @nullable List list;"
2498 "}");
2499 CaptureStderr();
2500 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2501 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2502}
2503
Daniel Norman85aed542019-08-21 12:01:14 -07002504TEST_F(AidlTestIncompatibleChanges, RemovedField) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002505 const string expected_stderr =
2506 "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 +09002507 io_delegate_.SetFileContents("old/p/Data.aidl",
2508 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002509 "parcelable Data {"
2510 " int foo;"
2511 " int bar;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002512 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002513 io_delegate_.SetFileContents("new/p/Data.aidl",
2514 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002515 "parcelable Data {"
2516 " int foo;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002517 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002518 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002519 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002520 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002521}
Jiyong Park3656c3c2018-08-01 20:02:01 +09002522
Jooyung Hanb5c55cd2020-10-22 07:59:01 +09002523TEST_F(AidlTestIncompatibleChanges, NewFieldWithNoDefault) {
2524 const string expected_stderr =
2525 "ERROR: new/p/Data.aidl:1.46-50: Field 'str' does not have a useful default in some "
2526 "backends. Please either provide a default value for this field or mark the field as "
2527 "@nullable. This value or a null value will be used automatically when an old version of "
2528 "this parcelable is sent to a process which understands a new version of this parcelable. In "
2529 "order to make sure your code continues to be backwards compatible, make sure the default or "
2530 "null value does not cause a semantic change to this parcelable.\n";
2531 io_delegate_.SetFileContents("old/p/Data.aidl",
2532 "package p;"
2533 "parcelable Data {"
2534 " int num;"
2535 "}");
2536 io_delegate_.SetFileContents("new/p/Data.aidl",
2537 "package p;"
2538 "parcelable Data {"
2539 " int num;"
2540 " String str;"
2541 "}");
2542 CaptureStderr();
2543 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2544 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2545}
2546
Jooyung Han636fd2f2020-10-22 11:33:45 +09002547TEST_F(AidlTestIncompatibleChanges, NewFieldWithNonZeroEnum) {
2548 const string expected_stderr =
2549 "ERROR: new/p/Data.aidl:1.46-48: Field 'e' of enum 'Enum' can't be initialized as '0'. "
2550 "Please make sure 'Enum' has '0' as a valid value.\n";
2551 io_delegate_.SetFileContents("old/p/Data.aidl",
2552 "package p;"
2553 "parcelable Data {"
2554 " int num;"
2555 "}");
2556 io_delegate_.SetFileContents("new/p/Data.aidl",
2557 "package p;"
2558 "parcelable Data {"
2559 " int num;"
2560 " p.Enum e;"
2561 "}");
2562 io_delegate_.SetFileContents("new/p/Enum.aidl",
2563 "package p;"
2564 "enum Enum {"
2565 " FOO = 1,"
2566 " BAR = 2,"
2567 "}");
2568 CaptureStderr();
2569 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2570 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2571}
2572
Daniel Norman85aed542019-08-21 12:01:14 -07002573TEST_F(AidlTestIncompatibleChanges, RemovedEnumerator) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002574 const string expected_stderr =
2575 "ERROR: new/p/Enum.aidl:1.15-20: Removed enumerator from p.Enum: FOO\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002576 io_delegate_.SetFileContents("old/p/Enum.aidl",
2577 "package p;"
2578 "enum Enum {"
2579 " FOO = 1,"
2580 " BAR = 2,"
2581 "}");
2582 io_delegate_.SetFileContents("new/p/Enum.aidl",
2583 "package p;"
2584 "enum Enum {"
2585 " BAR = 2,"
2586 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002587 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002588 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002589 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002590}
2591
Jooyung Hanb5c55cd2020-10-22 07:59:01 +09002592TEST_F(AidlTestIncompatibleChanges, RemovedUnionField) {
2593 const string expected_stderr =
2594 "ERROR: new/p/Union.aidl:1.16-22: Number of fields in p.Union is reduced from 2 to 1.\n";
2595 io_delegate_.SetFileContents("old/p/Union.aidl",
2596 "package p;"
2597 "union Union {"
2598 " String str;"
2599 " int num;"
2600 "}");
2601 io_delegate_.SetFileContents("new/p/Union.aidl",
2602 "package p;"
2603 "union Union {"
2604 " String str;"
2605 "}");
2606 CaptureStderr();
2607 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2608 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2609}
2610
Daniel Norman85aed542019-08-21 12:01:14 -07002611TEST_F(AidlTestIncompatibleChanges, RenamedMethod) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002612 const string expected_stderr =
2613 "ERROR: old/p/IFoo.aidl:1.61-65: Removed or changed method: p.IFoo.bar(String)\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002614 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2615 "package p;"
2616 "interface IFoo {"
2617 " void foo(in String[] str);"
2618 " void bar(@utf8InCpp String str);"
2619 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002620 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2621 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002622 "interface IFoo {"
2623 " void foo(in String[] str);"
2624 " void bar2(@utf8InCpp String str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002625 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002626 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002627 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002628 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002629}
2630
Daniel Norman85aed542019-08-21 12:01:14 -07002631TEST_F(AidlTestIncompatibleChanges, RenamedType) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002632 const string expected_stderr = "ERROR: old/p/IFoo.aidl:1.11-20: Removed type: p.IFoo\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002633 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2634 "package p;"
2635 "interface IFoo {"
2636 " void foo(in String[] str);"
2637 " void bar(@utf8InCpp String str);"
2638 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002639 io_delegate_.SetFileContents("new/p/IFoo2.aidl",
2640 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002641 "interface IFoo2 {"
2642 " void foo(in String[] str);"
2643 " void bar(@utf8InCpp String str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002644 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002645 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002646 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002647 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002648}
Jiyong Park3656c3c2018-08-01 20:02:01 +09002649
Daniel Norman85aed542019-08-21 12:01:14 -07002650TEST_F(AidlTestIncompatibleChanges, ChangedEnumerator) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002651 const string expected_stderr =
2652 "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 -07002653 io_delegate_.SetFileContents("old/p/Enum.aidl",
2654 "package p;"
2655 "enum Enum {"
2656 " FOO = 1,"
2657 " BAR = 2,"
2658 "}");
2659 io_delegate_.SetFileContents("new/p/Enum.aidl",
2660 "package p;"
2661 "enum Enum {"
2662 " FOO = 3,"
2663 " BAR = 2,"
2664 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002665 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002666 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002667 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002668}
2669
2670TEST_F(AidlTestIncompatibleChanges, ReorderedMethod) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002671 const string expected_stderr =
2672 "ERROR: new/p/IFoo.aidl:1.67-71: Transaction ID changed: p.IFoo.foo(String[]) is changed "
2673 "from 0 to 1.\n"
2674 "ERROR: new/p/IFoo.aidl:1.33-37: Transaction ID changed: p.IFoo.bar(String) is changed from "
2675 "1 to 0.\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002676 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2677 "package p;"
2678 "interface IFoo {"
2679 " void foo(in String[] str);"
2680 " void bar(@utf8InCpp String str);"
2681 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002682 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2683 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002684 "interface IFoo {"
2685 " void bar(@utf8InCpp String str);"
2686 " void foo(in String[] str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002687 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002688 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002689 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002690 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002691}
2692
2693TEST_F(AidlTestIncompatibleChanges, ReorderedField) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002694 const string expected_stderr =
Jiyong Parkb07d9932020-05-15 12:56:54 +09002695 "ERROR: new/p/Data.aidl:1.33-37: Reordered bar from 1 to 0.\n"
2696 "ERROR: new/p/Data.aidl:1.43-47: Reordered foo from 0 to 1.\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002697 io_delegate_.SetFileContents("old/p/Data.aidl",
Jiyong Parke59c3682018-09-11 23:10:25 +09002698 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002699 "parcelable Data {"
2700 " int foo;"
2701 " int bar;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002702 "}");
Daniel Norman85aed542019-08-21 12:01:14 -07002703 io_delegate_.SetFileContents("new/p/Data.aidl",
2704 "package p;"
2705 "parcelable Data {"
2706 " int bar;"
2707 " int foo;"
2708 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002709 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002710 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002711 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002712}
Jiyong Park3656c3c2018-08-01 20:02:01 +09002713
Daniel Norman85aed542019-08-21 12:01:14 -07002714TEST_F(AidlTestIncompatibleChanges, ChangedDirectionSpecifier) {
Devin Mooreeccdb902020-03-24 16:22:40 -07002715 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 -07002716 io_delegate_.SetFileContents("old/p/IFoo.aidl",
Jiyong Parke59c3682018-09-11 23:10:25 +09002717 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002718 "interface IFoo {"
2719 " void foo(in String[] str);"
2720 " void bar(@utf8InCpp String str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002721 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002722 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2723 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002724 "interface IFoo {"
2725 " void foo(out String[] str);"
2726 " void bar(@utf8InCpp String str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002727 "}");
Devin Mooreeccdb902020-03-24 16:22:40 -07002728 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002729 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Mooreeccdb902020-03-24 16:22:40 -07002730 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002731}
Jiyong Park3656c3c2018-08-01 20:02:01 +09002732
Daniel Norman85aed542019-08-21 12:01:14 -07002733TEST_F(AidlTestIncompatibleChanges, AddedAnnotation) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002734 const string expected_stderr =
2735 "ERROR: new/p/IFoo.aidl:1.51-58: Changed annotations: (empty) to @utf8InCpp\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002736 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2737 "package p;"
2738 "interface IFoo {"
2739 " void foo(in String[] str);"
2740 " void bar(@utf8InCpp String str);"
2741 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002742 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2743 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002744 "interface IFoo {"
Jiyong Parke59c3682018-09-11 23:10:25 +09002745 " void foo(in @utf8InCpp String[] str);"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002746 " void bar(@utf8InCpp String str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002747 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002748 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002749 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002750 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002751}
Jiyong Park3656c3c2018-08-01 20:02:01 +09002752
Daniel Norman85aed542019-08-21 12:01:14 -07002753TEST_F(AidlTestIncompatibleChanges, RemovedAnnotation) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002754 const string expected_stderr =
2755 "ERROR: new/p/IFoo.aidl:1.66-72: Changed annotations: @utf8InCpp to (empty)\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002756 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2757 "package p;"
2758 "interface IFoo {"
2759 " void foo(in String[] str);"
2760 " void bar(@utf8InCpp String str);"
2761 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002762 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2763 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002764 "interface IFoo {"
Jiyong Parke59c3682018-09-11 23:10:25 +09002765 " void foo(in String[] str);"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002766 " void bar(String str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002767 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002768 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002769 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002770 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002771}
Jiyong Park3656c3c2018-08-01 20:02:01 +09002772
Jooyung Han60b2fde2020-10-29 15:12:40 +09002773TEST_F(AidlTestIncompatibleChanges, ChangedBackingTypeOfEnum) {
2774 const string expected_stderr =
2775 "ERROR: new/p/Foo.aidl:1.11-32: Type changed: byte to long.\n"
2776 "ERROR: new/p/Foo.aidl:1.36-40: Changed backing types.\n";
2777 io_delegate_.SetFileContents("old/p/Foo.aidl",
2778 "package p;"
2779 "@Backing(type=\"byte\")"
2780 "enum Foo {"
2781 " FOO, BAR,"
2782 "}");
2783 io_delegate_.SetFileContents("new/p/Foo.aidl",
2784 "package p;"
2785 "@Backing(type=\"long\")"
2786 "enum Foo {"
2787 " FOO, BAR,"
2788 "}");
2789 CaptureStderr();
2790 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2791 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2792}
2793
Jooyung Han69ea4ba2020-10-29 15:33:37 +09002794TEST_F(AidlTestIncompatibleChanges, ChangedAnnatationParams) {
2795 const string expected_stderr =
2796 "ERROR: new/p/Foo.aidl:1.55-59: Changed annotations: @JavaPassthrough(annotation=\"Alice\") "
2797 "to @JavaPassthrough(annotation=\"Bob\")\n";
2798 io_delegate_.SetFileContents("old/p/Foo.aidl",
2799 "package p;"
2800 "@JavaPassthrough(annotation=\"Alice\")"
2801 "parcelable Foo {}");
2802 io_delegate_.SetFileContents("new/p/Foo.aidl",
2803 "package p;"
2804 "@JavaPassthrough(annotation=\"Bob\")"
2805 "parcelable Foo {}");
2806
2807 CaptureStderr();
2808 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2809 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2810}
2811
Devin Mooredb7ac512020-08-07 11:17:36 -07002812TEST_F(AidlTestIncompatibleChanges, AddedParcelableAnnotation) {
2813 const string expected_stderr =
Jooyung Han2d6b5c42021-01-09 01:01:06 +09002814 "ERROR: new/p/Foo.aidl:1.32-36: Changed annotations: (empty) to @FixedSize\n";
Devin Mooredb7ac512020-08-07 11:17:36 -07002815 io_delegate_.SetFileContents("old/p/Foo.aidl",
2816 "package p;"
2817 "parcelable Foo {"
2818 " int A;"
2819 "}");
2820 io_delegate_.SetFileContents("new/p/Foo.aidl",
2821 "package p;"
Jooyung Han2d6b5c42021-01-09 01:01:06 +09002822 "@FixedSize parcelable Foo {"
Devin Mooredb7ac512020-08-07 11:17:36 -07002823 " int A;"
2824 "}");
2825 CaptureStderr();
2826 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2827 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2828}
2829
2830TEST_F(AidlTestIncompatibleChanges, RemovedParcelableAnnotation) {
2831 const string expected_stderr =
Jooyung Han2d6b5c42021-01-09 01:01:06 +09002832 "ERROR: new/p/Foo.aidl:1.21-25: Changed annotations: @FixedSize to (empty)\n";
Devin Mooredb7ac512020-08-07 11:17:36 -07002833 io_delegate_.SetFileContents("old/p/Foo.aidl",
2834 "package p;"
Jooyung Han2d6b5c42021-01-09 01:01:06 +09002835 "@FixedSize parcelable Foo {"
Devin Mooredb7ac512020-08-07 11:17:36 -07002836 " int A;"
2837 "}");
2838 io_delegate_.SetFileContents("new/p/Foo.aidl",
2839 "package p;"
2840 "parcelable Foo {"
2841 " int A;"
2842 "}");
2843 CaptureStderr();
2844 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2845 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2846}
2847
Daniel Norman85aed542019-08-21 12:01:14 -07002848TEST_F(AidlTestIncompatibleChanges, RemovedPackage) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002849 const string expected_stderr = "ERROR: old/q/IFoo.aidl:1.11-21: Removed type: q.IFoo\n";
Jiyong Parke59c3682018-09-11 23:10:25 +09002850 io_delegate_.SetFileContents("old/p/IFoo.aidl", "package p; interface IFoo{}");
2851 io_delegate_.SetFileContents("old/q/IFoo.aidl", "package q; interface IFoo{}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002852 io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p; interface IFoo{}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002853 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002854 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002855 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002856}
Jiyong Parka468e2a2018-08-29 21:25:18 +09002857
Daniel Norman85aed542019-08-21 12:01:14 -07002858TEST_F(AidlTestIncompatibleChanges, ChangedDefaultValue) {
Steven Moreland370ed342020-04-28 18:14:39 -07002859 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 +09002860 io_delegate_.SetFileContents("old/p/D.aidl", "package p; parcelable D { int a = 1; }");
2861 io_delegate_.SetFileContents("new/p/D.aidl", "package p; parcelable D { int a = 2; }");
Devin Moore097a3ab2020-03-11 16:08:44 -07002862 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002863 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002864 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002865}
Jiyong Parka428d212018-08-29 22:26:30 +09002866
Daniel Norman85aed542019-08-21 12:01:14 -07002867TEST_F(AidlTestIncompatibleChanges, RemovedConstValue) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002868 const string expected_stderr =
2869 "ERROR: old/p/I.aidl:1.51-53: Removed constant declaration: p.I.B\n";
Jiyong Parke59c3682018-09-11 23:10:25 +09002870 io_delegate_.SetFileContents("old/p/I.aidl",
2871 "package p; interface I {"
2872 "const int A = 1; const int B = 2;}");
2873 io_delegate_.SetFileContents("new/p/I.aidl", "package p; interface I { const int A = 1; }");
Devin Moore097a3ab2020-03-11 16:08:44 -07002874 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002875 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002876 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002877}
Jiyong Parka428d212018-08-29 22:26:30 +09002878
Daniel Norman85aed542019-08-21 12:01:14 -07002879TEST_F(AidlTestIncompatibleChanges, ChangedConstValue) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002880 const string expected_stderr =
2881 "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 +09002882 io_delegate_.SetFileContents("old/p/I.aidl", "package p; interface I { const int A = 1; }");
2883 io_delegate_.SetFileContents("new/p/I.aidl", "package p; interface I { const int A = 2; }");
Devin Moore097a3ab2020-03-11 16:08:44 -07002884 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002885 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002886 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Park3c35e392018-08-30 13:10:30 +09002887}
2888
Devin Moorec7e47a32020-08-07 10:55:25 -07002889TEST_F(AidlTestIncompatibleChanges, FixedSizeAddedField) {
2890 const string expected_stderr =
2891 "ERROR: new/p/Foo.aidl:1.33-37: Number of fields in p.Foo is changed from 1 to 2. "
2892 "This is an incompatible change for FixedSize types.\n";
2893 io_delegate_.SetFileContents("old/p/Foo.aidl",
2894 "package p; @FixedSize parcelable Foo { int A = 1; }");
2895 io_delegate_.SetFileContents("new/p/Foo.aidl",
2896 "package p; @FixedSize parcelable Foo { int A = 1; int B = 2; }");
2897 CaptureStderr();
2898 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2899 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2900}
2901
Jeongik Cha68d18e72021-04-29 20:07:01 +09002902TEST_F(AidlTestIncompatibleChanges, UidRangeParcelAddedField) {
2903 const string expected_stderr =
2904 "ERROR: new/android/net/UidRangeParcel.aidl:1.32-47: Number of fields in "
2905 "android.net.UidRangeParcel is changed from 1 to 2. "
2906 "But it is forbidden because of legacy support.\n";
2907 io_delegate_.SetFileContents("old/android/net/UidRangeParcel.aidl",
2908 "package android.net; parcelable UidRangeParcel { int A = 1; }");
2909 io_delegate_.SetFileContents(
2910 "new/android/net/UidRangeParcel.aidl",
2911 "package android.net; parcelable UidRangeParcel { int A = 1; int B = 2; }");
2912 CaptureStderr();
2913 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2914 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2915}
2916
Devin Moorec7e47a32020-08-07 10:55:25 -07002917TEST_F(AidlTestIncompatibleChanges, FixedSizeRemovedField) {
2918 const string expected_stderr =
2919 "ERROR: new/p/Foo.aidl:1.33-37: Number of fields in p.Foo is reduced from 2 to 1.\n";
2920 io_delegate_.SetFileContents("old/p/Foo.aidl",
2921 "package p; @FixedSize parcelable Foo { int A = 1; int B = 1; }");
2922 io_delegate_.SetFileContents("new/p/Foo.aidl",
2923 "package p; @FixedSize parcelable Foo { int A = 1; }");
2924 CaptureStderr();
2925 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2926 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2927}
2928
2929TEST_P(AidlTest, RejectNonFixedSizeFromFixedSize) {
2930 const string expected_stderr =
2931 "ERROR: Foo.aidl:1.36-38: The @FixedSize parcelable 'Foo' has a non-fixed size field named "
2932 "a.\n"
2933 "ERROR: Foo.aidl:1.44-46: The @FixedSize parcelable 'Foo' has a non-fixed size field named "
2934 "b.\n"
2935 "ERROR: Foo.aidl:1.55-57: The @FixedSize parcelable 'Foo' has a non-fixed size field named "
2936 "c.\n"
2937 "ERROR: Foo.aidl:1.80-82: The @FixedSize parcelable 'Foo' has a non-fixed size field named "
2938 "d.\n"
2939 "ERROR: Foo.aidl:1.92-94: The @FixedSize parcelable 'Foo' has a non-fixed size field named "
2940 "e.\n"
2941 "ERROR: Foo.aidl:1.109-111: The @FixedSize parcelable 'Foo' has a non-fixed size field named "
2942 "f.\n";
2943
2944 io_delegate_.SetFileContents("Foo.aidl",
2945 "@FixedSize parcelable Foo { "
2946 " int[] a;"
2947 " Bar b;"
2948 " String c;"
2949 " ParcelFileDescriptor d;"
2950 " IBinder e;"
2951 " List<String> f;"
Steven Moreland265f3d42020-09-24 19:06:54 +00002952 " int isFixedSize;"
Devin Moorec7e47a32020-08-07 10:55:25 -07002953 "}");
2954 io_delegate_.SetFileContents("Bar.aidl", "parcelable Bar { int a; }");
Jooyung Han9435e9a2021-01-06 10:16:31 +09002955 Options options = Options::From("aidl Foo.aidl -I . --lang=" + to_string(GetLanguage()));
Devin Moorec7e47a32020-08-07 10:55:25 -07002956
2957 CaptureStderr();
2958 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
2959 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2960}
2961
2962TEST_P(AidlTest, AcceptFixedSizeFromFixedSize) {
2963 const string expected_stderr = "";
2964
2965 io_delegate_.SetFileContents("Foo.aidl", "@FixedSize parcelable Foo { int a; Bar b; }");
2966 io_delegate_.SetFileContents("Bar.aidl", "@FixedSize parcelable Bar { Val c; }");
2967 io_delegate_.SetFileContents("Val.aidl", "enum Val { A, B, }");
Jooyung Han9435e9a2021-01-06 10:16:31 +09002968 Options options = Options::From("aidl Foo.aidl -I . --lang=" + to_string(GetLanguage()));
Devin Moorec7e47a32020-08-07 10:55:25 -07002969
2970 CaptureStderr();
2971 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
2972 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2973}
2974
Jiyong Park8c380532018-08-30 14:55:26 +09002975TEST_F(AidlTest, RejectAmbiguousImports) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002976 const string expected_stderr =
2977 "ERROR: p/IFoo.aidl: Duplicate files found for q.IBar from:\n"
2978 "dir1/q/IBar.aidl\n"
2979 "dir2/q/IBar.aidl\n"
Devin Moore5de18ed2020-04-02 13:52:29 -07002980 "ERROR: p/IFoo.aidl: Couldn't find import for class q.IBar\n";
Jiyong Park8c380532018-08-30 14:55:26 +09002981 Options options = Options::From("aidl --lang=java -o out -I dir1 -I dir2 p/IFoo.aidl");
2982 io_delegate_.SetFileContents("p/IFoo.aidl", "package p; import q.IBar; interface IFoo{}");
2983 io_delegate_.SetFileContents("dir1/q/IBar.aidl", "package q; interface IBar{}");
2984 io_delegate_.SetFileContents("dir2/q/IBar.aidl", "package q; interface IBar{}");
2985
Devin Moore097a3ab2020-03-11 16:08:44 -07002986 CaptureStderr();
Jiyong Park8c380532018-08-30 14:55:26 +09002987 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002988 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Park8c380532018-08-30 14:55:26 +09002989}
2990
Jiyong Parked65bf42018-08-28 15:43:27 +09002991TEST_F(AidlTest, HandleManualIdAssignments) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002992 const string expected_stderr =
2993 "ERROR: new/p/IFoo.aidl:1.32-36: Transaction ID changed: p.IFoo.foo() is changed from 10 to "
2994 "11.\n";
Jiyong Parke59c3682018-09-11 23:10:25 +09002995 Options options = Options::From("aidl --checkapi old new");
2996 io_delegate_.SetFileContents("old/p/IFoo.aidl", "package p; interface IFoo{ void foo() = 10;}");
2997 io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p; interface IFoo{ void foo() = 10;}");
Jiyong Parked65bf42018-08-28 15:43:27 +09002998
2999 EXPECT_TRUE(::android::aidl::check_api(options, io_delegate_));
3000
Jiyong Parke59c3682018-09-11 23:10:25 +09003001 io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p; interface IFoo{ void foo() = 11;}");
Devin Moore097a3ab2020-03-11 16:08:44 -07003002 CaptureStderr();
Jiyong Parked65bf42018-08-28 15:43:27 +09003003 EXPECT_FALSE(::android::aidl::check_api(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07003004 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Parked65bf42018-08-28 15:43:27 +09003005}
3006
Jooyung Han652ce482021-02-26 12:40:35 +09003007TEST_P(AidlTest, ParcelFileDescriptorIsBuiltinType) {
3008 Options options =
3009 Options::From("aidl --lang=" + to_string(GetLanguage()) + " -h out -o out p/IFoo.aidl");
Jiyong Parke05195e2018-10-08 18:24:23 +09003010
3011 // use without import
3012 io_delegate_.SetFileContents("p/IFoo.aidl",
3013 "package p; interface IFoo{ void foo(in ParcelFileDescriptor fd);}");
Jooyung Han652ce482021-02-26 12:40:35 +09003014 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3015
3016 // capture output files
3017 map<string, string> outputs = io_delegate_.OutputFiles();
Jiyong Parke05195e2018-10-08 18:24:23 +09003018
Devin Moore7b8d5c92020-03-17 14:14:08 -07003019 // use without import but with full name
Jiyong Parke05195e2018-10-08 18:24:23 +09003020 io_delegate_.SetFileContents(
3021 "p/IFoo.aidl",
3022 "package p; interface IFoo{ void foo(in android.os.ParcelFileDescriptor fd);}");
Jooyung Han652ce482021-02-26 12:40:35 +09003023 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3024 // output files should be the same
3025 EXPECT_EQ(outputs, io_delegate_.OutputFiles());
Jiyong Parke05195e2018-10-08 18:24:23 +09003026
3027 // use with import (as before)
3028 io_delegate_.SetFileContents("p/IFoo.aidl",
3029 "package p;"
3030 "import android.os.ParcelFileDescriptor;"
3031 "interface IFoo{"
3032 " void foo(in ParcelFileDescriptor fd);"
3033 "}");
Jooyung Han652ce482021-02-26 12:40:35 +09003034 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3035 // output files should be the same
3036 EXPECT_EQ(outputs, io_delegate_.OutputFiles());
Jiyong Parke05195e2018-10-08 18:24:23 +09003037}
Jiyong Parked65bf42018-08-28 15:43:27 +09003038
Jooyung Han020d8d12021-02-26 17:23:02 +09003039TEST_P(AidlTest, RejectsOutputParcelFileDescriptor) {
3040 Options options = Options::From("aidl p/IFoo.aidl -I . --lang=" + to_string(GetLanguage()));
3041 CaptureStderr();
3042 io_delegate_.SetFileContents("p/IFoo.aidl",
3043 "package p;"
3044 "interface IFoo{"
3045 " void foo(out ParcelFileDescriptor fd);"
3046 "}");
3047 EXPECT_EQ(1, ::android::aidl::compile_aidl(options, io_delegate_));
3048 EXPECT_THAT(GetCapturedStderr(), HasSubstr("can't be an out parameter"));
3049}
3050
3051TEST_P(AidlTest, RejectsArgumentDirectionNotSpecified) {
3052 Options options = Options::From("aidl p/IFoo.aidl -I . --lang=" + to_string(GetLanguage()));
3053 CaptureStderr();
3054 io_delegate_.SetFileContents("p/IFoo.aidl",
3055 "package p;"
3056 "interface IFoo{"
3057 " void foo(ParcelFileDescriptor fd);"
3058 "}");
3059 EXPECT_EQ(1, ::android::aidl::compile_aidl(options, io_delegate_));
3060 EXPECT_THAT(GetCapturedStderr(),
3061 HasSubstr("ParcelFileDescriptor can be an in or inout parameter."));
3062}
3063
Jiyong Park3633b722019-04-11 15:38:26 +09003064TEST_F(AidlTest, ManualIds) {
3065 Options options = Options::From("aidl --lang=java -o out IFoo.aidl");
3066 io_delegate_.SetFileContents("IFoo.aidl",
3067 "interface IFoo {\n"
3068 " void foo() = 0;\n"
3069 " void bar() = 1;\n"
3070 "}");
3071 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3072}
3073
3074TEST_F(AidlTest, ManualIdsWithMetaTransactions) {
3075 Options options = Options::From("aidl --lang=java --version 10 -o out IFoo.aidl");
3076 io_delegate_.SetFileContents("IFoo.aidl",
3077 "interface IFoo {\n"
3078 " void foo() = 0;\n"
3079 " void bar() = 1;\n"
3080 "}");
3081 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3082}
3083
3084TEST_F(AidlTest, FailOnDuplicatedIds) {
Devin Moore097a3ab2020-03-11 16:08:44 -07003085 const string expected_stderr =
3086 "ERROR: IFoo.aidl:3.7-11: Found duplicate method id (3) for method bar\n";
Jiyong Park3633b722019-04-11 15:38:26 +09003087 Options options = Options::From("aidl --lang=java --version 10 -o out IFoo.aidl");
3088 io_delegate_.SetFileContents("IFoo.aidl",
3089 "interface IFoo {\n"
3090 " void foo() = 3;\n"
3091 " void bar() = 3;\n"
3092 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07003093 CaptureStderr();
Jiyong Park3633b722019-04-11 15:38:26 +09003094 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07003095 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Park3633b722019-04-11 15:38:26 +09003096}
3097
3098TEST_F(AidlTest, FailOnOutOfRangeIds) {
3099 // 16777115 is kLastMetaMethodId + 1
Devin Moore097a3ab2020-03-11 16:08:44 -07003100 const string expected_stderr =
3101 "ERROR: IFoo.aidl:3.7-11: Found out of bounds id (16777115) for method bar. "
3102 "Value for id must be between 0 and 16777114 inclusive.\n";
Jiyong Park3633b722019-04-11 15:38:26 +09003103 Options options = Options::From("aidl --lang=java --version 10 -o out IFoo.aidl");
3104 io_delegate_.SetFileContents("IFoo.aidl",
3105 "interface IFoo {\n"
3106 " void foo() = 3;\n"
3107 " void bar() = 16777115;\n"
3108 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07003109 CaptureStderr();
Jiyong Park3633b722019-04-11 15:38:26 +09003110 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07003111 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Park3633b722019-04-11 15:38:26 +09003112}
3113
3114TEST_F(AidlTest, FailOnPartiallyAssignedIds) {
Devin Moore097a3ab2020-03-11 16:08:44 -07003115 const string expected_stderr =
3116 "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 +09003117 Options options = Options::From("aidl --lang=java --version 10 -o out IFoo.aidl");
3118 io_delegate_.SetFileContents("IFoo.aidl",
3119 "interface IFoo {\n"
3120 " void foo() = 3;\n"
3121 " void bar();\n"
3122 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07003123 CaptureStderr();
Jiyong Park3633b722019-04-11 15:38:26 +09003124 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07003125 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Park3633b722019-04-11 15:38:26 +09003126}
3127
Jiyong Parkc6816252019-07-08 08:12:28 +09003128TEST_F(AidlTest, AllowDuplicatedImportPaths) {
3129 Options options = Options::From("aidl --lang=java -I dir -I dir IFoo.aidl");
3130 io_delegate_.SetFileContents("dir/IBar.aidl", "interface IBar{}");
3131 io_delegate_.SetFileContents("IFoo.aidl", "import IBar; interface IFoo{}");
3132 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3133}
3134
3135TEST_F(AidlTest, FailOnAmbiguousImports) {
Devin Moore097a3ab2020-03-11 16:08:44 -07003136 const string expected_stderr =
3137 "ERROR: IFoo.aidl: Duplicate files found for IBar from:\n"
3138 "dir/IBar.aidl\n"
3139 "dir2/IBar.aidl\n"
Devin Moore5de18ed2020-04-02 13:52:29 -07003140 "ERROR: IFoo.aidl: Couldn't find import for class IBar\n";
Devin Moore097a3ab2020-03-11 16:08:44 -07003141
Jiyong Parkc6816252019-07-08 08:12:28 +09003142 Options options = Options::From("aidl --lang=java -I dir -I dir2 IFoo.aidl");
3143 io_delegate_.SetFileContents("dir/IBar.aidl", "interface IBar{}");
3144 io_delegate_.SetFileContents("dir2/IBar.aidl", "interface IBar{}");
3145 io_delegate_.SetFileContents("IFoo.aidl", "import IBar; interface IFoo{}");
Devin Moore097a3ab2020-03-11 16:08:44 -07003146 CaptureStderr();
Jiyong Parkc6816252019-07-08 08:12:28 +09003147 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07003148 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Parkc6816252019-07-08 08:12:28 +09003149}
3150
Jiyong Parkf1f5c802020-05-19 17:33:00 +09003151TEST_F(AidlTest, UnusedImportDoesNotContributeInclude) {
3152 io_delegate_.SetFileContents("a/b/IFoo.aidl",
3153 "package a.b;\n"
3154 "import a.b.IBar;\n"
3155 "import a.b.IQux;\n"
3156 "interface IFoo { IQux foo(); }\n");
3157 io_delegate_.SetFileContents("a/b/IBar.aidl", "package a.b; interface IBar { void foo(); }");
3158 io_delegate_.SetFileContents("a/b/IQux.aidl", "package a.b; interface IQux { void foo(); }");
3159
3160 Options options = Options::From("aidl --lang=ndk a/b/IFoo.aidl -I . -o out -h out/include");
3161 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3162
3163 string output;
3164 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/include/aidl/a/b/IFoo.h", &output));
3165 // IBar was imported but wasn't used. include is not expected.
3166 EXPECT_THAT(output, Not(testing::HasSubstr("#include <aidl/a/b/IBar.h>")));
3167 // IBar was imported and used. include is expected.
3168 EXPECT_THAT(output, (testing::HasSubstr("#include <aidl/a/b/IQux.h>")));
3169}
3170
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09003171TEST_F(AidlTest, ParseJavaPassthroughAnnotation) {
Jooyung Hane6bc5e12020-10-13 10:57:10 +09003172 io_delegate_.SetFileContents("a/IFoo.aidl", R"--(package a;
Jooyung Han4cde01d2020-10-13 11:10:47 +09003173 import a.MyEnum;
Jooyung Hane6bc5e12020-10-13 10:57:10 +09003174 @JavaPassthrough(annotation="@com.android.Alice(arg=com.android.Alice.Value.A)")
3175 @JavaPassthrough(annotation="@com.android.AliceTwo")
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09003176 interface IFoo {
3177 @JavaPassthrough(annotation="@com.android.Bob")
Jooyung Han4cde01d2020-10-13 11:10:47 +09003178 void foo(@JavaPassthrough(annotation="@com.android.Cat") int x, MyEnum y);
Jiyong Park7c3b0e42020-08-04 16:08:32 +09003179 const @JavaPassthrough(annotation="@com.android.David") int A = 3;
Jooyung Hane6bc5e12020-10-13 10:57:10 +09003180 })--");
Jooyung Han4cde01d2020-10-13 11:10:47 +09003181 // JavaPassthrough should work with other types as well (e.g. enum)
3182 io_delegate_.SetFileContents("a/MyEnum.aidl", R"--(package a;
3183 @JavaPassthrough(annotation="@com.android.Alice(arg=com.android.Alice.Value.A)")
3184 @JavaPassthrough(annotation="@com.android.AliceTwo")
3185 @Backing(type="byte")
3186 enum MyEnum {
3187 a, b, c
3188 })--");
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09003189
Jooyung Han4cde01d2020-10-13 11:10:47 +09003190 Options java_options = Options::From("aidl -I . --lang=java -o out a/IFoo.aidl a/MyEnum.aidl");
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09003191 EXPECT_EQ(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
3192
3193 string java_out;
3194 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/IFoo.java", &java_out));
Jooyung Hane6bc5e12020-10-13 10:57:10 +09003195 // type-decl-level annotations with newline at the end
3196 EXPECT_THAT(java_out, testing::HasSubstr("@com.android.Alice(arg=com.android.Alice.Value.A)\n"));
3197 EXPECT_THAT(java_out, testing::HasSubstr("@com.android.AliceTwo\n"));
3198 // member-decl-level annotations with newline at the end
3199 EXPECT_THAT(java_out, testing::HasSubstr("@com.android.Bob\n"));
3200 EXPECT_THAT(java_out, testing::HasSubstr("@com.android.David\n"));
3201 // inline annotations with space at the end
3202 EXPECT_THAT(java_out, testing::HasSubstr("@com.android.Cat "));
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09003203
Jooyung Han4cde01d2020-10-13 11:10:47 +09003204 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/MyEnum.java", &java_out));
3205 // type-decl-level annotations with newline at the end
3206 EXPECT_THAT(java_out, testing::HasSubstr("@com.android.Alice(arg=com.android.Alice.Value.A)\n"));
3207 EXPECT_THAT(java_out, testing::HasSubstr("@com.android.AliceTwo\n"));
3208
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09003209 // Other backends shouldn't be bothered
Jooyung Han4cde01d2020-10-13 11:10:47 +09003210 Options cpp_options =
3211 Options::From("aidl -I . --lang=cpp -o out -h out a/IFoo.aidl a/MyEnum.aidl");
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09003212 EXPECT_EQ(0, ::android::aidl::compile_aidl(cpp_options, io_delegate_));
3213
Jooyung Han4cde01d2020-10-13 11:10:47 +09003214 Options ndk_options =
3215 Options::From("aidl -I . --lang=ndk -o out -h out a/IFoo.aidl a/MyEnum.aidl");
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09003216 EXPECT_EQ(0, ::android::aidl::compile_aidl(ndk_options, io_delegate_));
Andrei Homescub62afd92020-05-11 19:24:59 -07003217
Jooyung Han4cde01d2020-10-13 11:10:47 +09003218 Options rust_options = Options::From("aidl -I . --lang=rust -o out a/IFoo.aidl a/MyEnum.aidl");
Andrei Homescub62afd92020-05-11 19:24:59 -07003219 EXPECT_EQ(0, ::android::aidl::compile_aidl(rust_options, io_delegate_));
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09003220}
3221
Andrei Homescue61feb52020-08-18 15:44:24 -07003222TEST_F(AidlTest, ParseRustDerive) {
3223 io_delegate_.SetFileContents("a/Foo.aidl", R"(package a;
3224 @RustDerive(Clone=true, Copy=false)
3225 parcelable Foo {
3226 int a;
3227 })");
3228
3229 Options rust_options = Options::From("aidl --lang=rust -o out a/Foo.aidl");
3230 EXPECT_EQ(0, ::android::aidl::compile_aidl(rust_options, io_delegate_));
3231
3232 string rust_out;
3233 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/Foo.rs", &rust_out));
3234 EXPECT_THAT(rust_out, testing::HasSubstr("#[derive(Debug, Clone)]"));
3235
3236 // Other backends shouldn't be bothered
3237 Options cpp_options = Options::From("aidl --lang=cpp -o out -h out a/Foo.aidl");
3238 EXPECT_EQ(0, ::android::aidl::compile_aidl(cpp_options, io_delegate_));
3239
3240 Options ndk_options = Options::From("aidl --lang=ndk -o out -h out a/Foo.aidl");
3241 EXPECT_EQ(0, ::android::aidl::compile_aidl(ndk_options, io_delegate_));
3242
3243 Options java_options = Options::From("aidl --lang=java -o out a/Foo.aidl");
3244 EXPECT_EQ(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
3245}
3246
Jiyong Park56f73d72019-06-11 12:20:28 +09003247class AidlOutputPathTest : public AidlTest {
3248 protected:
3249 void SetUp() override {
3250 AidlTest::SetUp();
3251 io_delegate_.SetFileContents("sub/dir/foo/bar/IFoo.aidl", "package foo.bar; interface IFoo {}");
3252 }
3253
3254 void Test(const Options& options, const std::string expected_output_path) {
3255 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3256 // check the existence
3257 EXPECT_TRUE(io_delegate_.GetWrittenContents(expected_output_path, nullptr));
3258 }
3259};
3260
3261TEST_F(AidlOutputPathTest, OutDirWithNoOutputFile) {
3262 // <out_dir> / <package_name> / <type_name>.java
3263 Test(Options::From("aidl -o out sub/dir/foo/bar/IFoo.aidl"), "out/foo/bar/IFoo.java");
3264}
3265
3266TEST_F(AidlOutputPathTest, OutDirWithOutputFile) {
3267 // when output file is explicitly set, it is always respected. -o option is
3268 // ignored.
3269 Test(Options::From("aidl -o out sub/dir/foo/bar/IFoo.aidl output/IFoo.java"), "output/IFoo.java");
3270}
3271
3272TEST_F(AidlOutputPathTest, NoOutDirWithOutputFile) {
3273 Test(Options::From("aidl -o out sub/dir/foo/bar/IFoo.aidl output/IFoo.java"), "output/IFoo.java");
3274}
3275
3276TEST_F(AidlOutputPathTest, NoOutDirWithNoOutputFile) {
3277 // output is the same as the input file except for the suffix
3278 Test(Options::From("aidl sub/dir/foo/bar/IFoo.aidl"), "sub/dir/foo/bar/IFoo.java");
3279}
3280
Devin Moore7b8d5c92020-03-17 14:14:08 -07003281TEST_P(AidlTest, FailOnOutOfBoundsInt32MaxConstInt) {
Devin Moore097a3ab2020-03-11 16:08:44 -07003282 AidlError error;
3283 const string expected_stderr =
3284 "ERROR: p/IFoo.aidl:3.58-69: Invalid type specifier for an int64 literal: int\n";
3285 CaptureStderr();
Will McVickera4e5b132019-10-03 13:52:21 -07003286 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl",
3287 R"(package p;
3288 interface IFoo {
3289 const int int32_max_oob = 2147483650;
3290 }
3291 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -07003292 typenames_, GetLanguage(), &error));
Devin Moore097a3ab2020-03-11 16:08:44 -07003293 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3294 EXPECT_EQ(AidlError::BAD_TYPE, error);
Will McVickera4e5b132019-10-03 13:52:21 -07003295}
3296
Devin Moore7b8d5c92020-03-17 14:14:08 -07003297TEST_P(AidlTest, FailOnOutOfBoundsInt32MinConstInt) {
Devin Moore097a3ab2020-03-11 16:08:44 -07003298 AidlError error;
3299 const string expected_stderr =
3300 "ERROR: p/IFoo.aidl:3.58-60: Invalid type specifier for an int64 literal: int\n";
3301 CaptureStderr();
Will McVickera4e5b132019-10-03 13:52:21 -07003302 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl",
3303 R"(package p;
3304 interface IFoo {
3305 const int int32_min_oob = -2147483650;
3306 }
3307 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -07003308 typenames_, GetLanguage(), &error));
Devin Moore097a3ab2020-03-11 16:08:44 -07003309 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3310 EXPECT_EQ(AidlError::BAD_TYPE, error);
Will McVickera4e5b132019-10-03 13:52:21 -07003311}
3312
Devin Moore7b8d5c92020-03-17 14:14:08 -07003313TEST_P(AidlTest, FailOnOutOfBoundsInt64MaxConstInt) {
Devin Moore097a3ab2020-03-11 16:08:44 -07003314 AidlError error;
3315 const string expected_stderr =
Devin Moore2a088902020-09-17 10:51:19 -07003316 "ERROR: p/IFoo.aidl:3.59-86: Could not parse integer: 21474836509999999999999999\n";
Devin Moore097a3ab2020-03-11 16:08:44 -07003317 CaptureStderr();
Will McVickera4e5b132019-10-03 13:52:21 -07003318 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl",
3319 R"(package p;
3320 interface IFoo {
3321 const long int64_max_oob = 21474836509999999999999999;
3322 }
3323 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -07003324 typenames_, GetLanguage(), &error));
Devin Moore097a3ab2020-03-11 16:08:44 -07003325 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3326 EXPECT_EQ(AidlError::PARSE_ERROR, error);
Will McVickera4e5b132019-10-03 13:52:21 -07003327}
3328
Devin Moore7b8d5c92020-03-17 14:14:08 -07003329TEST_P(AidlTest, FailOnOutOfBoundsInt64MinConstInt) {
Devin Moore097a3ab2020-03-11 16:08:44 -07003330 AidlError error;
3331 const string expected_stderr =
Devin Moore2a088902020-09-17 10:51:19 -07003332 "ERROR: p/IFoo.aidl:3.61-87: Could not parse integer: 21474836509999999999999999\n";
Devin Moore097a3ab2020-03-11 16:08:44 -07003333 CaptureStderr();
Will McVickera4e5b132019-10-03 13:52:21 -07003334 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl",
3335 R"(package p;
3336 interface IFoo {
3337 const long int64_min_oob = -21474836509999999999999999;
3338 }
3339 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -07003340 typenames_, GetLanguage(), &error));
Devin Moore097a3ab2020-03-11 16:08:44 -07003341 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3342 EXPECT_EQ(AidlError::PARSE_ERROR, error);
Will McVickera4e5b132019-10-03 13:52:21 -07003343}
3344
Devin Moore7b8d5c92020-03-17 14:14:08 -07003345TEST_P(AidlTest, FailOnOutOfBoundsAutofilledEnum) {
Devin Moore097a3ab2020-03-11 16:08:44 -07003346 AidlError error;
Devin Mooredf93ebb2020-03-25 14:03:35 -07003347 const string expected_stderr =
Jooyung Han29813842020-12-08 01:28:03 +09003348 "ERROR: p/TestEnum.aidl:5.1-36: Invalid type specifier for an int32 literal: byte\n"
Devin Mooredf93ebb2020-03-25 14:03:35 -07003349 "ERROR: p/TestEnum.aidl:5.1-36: Enumerator type differs from enum backing type.\n";
3350 CaptureStderr();
Daniel Normanb28684e2019-10-17 15:31:39 -07003351 EXPECT_EQ(nullptr, Parse("p/TestEnum.aidl",
3352 R"(package p;
3353 @Backing(type="byte")
3354 enum TestEnum {
3355 FOO = 127,
3356 BAR,
3357 }
3358 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -07003359 typenames_, GetLanguage(), &error));
Devin Mooredf93ebb2020-03-25 14:03:35 -07003360 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Devin Moore097a3ab2020-03-11 16:08:44 -07003361 EXPECT_EQ(AidlError::BAD_TYPE, error);
Daniel Normanb28684e2019-10-17 15:31:39 -07003362}
3363
Devin Mooredecaf292020-04-30 09:16:40 -07003364TEST_P(AidlTest, UnsupportedBackingAnnotationParam) {
3365 AidlError error;
3366 const string expected_stderr =
3367 "ERROR: p/TestEnum.aidl:2.1-51: Parameter foo not supported for annotation Backing. It must "
Devin Mooredecaf292020-04-30 09:16:40 -07003368 "be one of: type\n";
3369 CaptureStderr();
3370 EXPECT_EQ(nullptr, Parse("p/TestEnum.aidl",
3371 R"(package p;
3372 @Backing(foo="byte")
3373 enum TestEnum {
3374 FOO = 1,
3375 BAR,
3376 }
3377 )",
3378 typenames_, GetLanguage(), &error));
3379 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3380 EXPECT_EQ(AidlError::BAD_TYPE, error);
3381}
3382
Jooyung Han5721a232020-12-24 04:34:55 +09003383TEST_P(AidlTest, BackingAnnotationRequireTypeParameter) {
3384 const string expected_stderr = "ERROR: Enum.aidl:1.1-9: Missing 'type' on @Backing.\n";
3385 CaptureStderr();
3386 EXPECT_EQ(nullptr, Parse("Enum.aidl", "@Backing enum Enum { FOO }", typenames_, GetLanguage()));
3387 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3388}
3389
Jooyung Han66813932020-10-23 13:24:44 +09003390TEST_F(AidlTest, SupportJavaOnlyImmutableAnnotation) {
Jeongik Chad0a10272020-08-06 16:33:36 +09003391 io_delegate_.SetFileContents("Foo.aidl",
3392 "@JavaOnlyImmutable parcelable Foo { int a; Bar b; List<Bar> c; "
3393 "Map<String, Baz> d; Bar[] e; }");
3394 io_delegate_.SetFileContents("Bar.aidl", "@JavaOnlyImmutable parcelable Bar { String a; }");
3395 io_delegate_.SetFileContents("Baz.aidl",
3396 "@JavaOnlyImmutable @JavaOnlyStableParcelable parcelable Baz;");
Jeongik Cha36f76c32020-07-28 00:25:52 +09003397 Options options = Options::From("aidl --lang=java -I . Foo.aidl");
3398 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3399}
3400
Jooyung Han66813932020-10-23 13:24:44 +09003401TEST_F(AidlTest, RejectMutableParcelableFromJavaOnlyImmutableParcelable) {
Jeongik Chad0a10272020-08-06 16:33:36 +09003402 io_delegate_.SetFileContents("Foo.aidl", "@JavaOnlyImmutable parcelable Foo { Bar bar; }");
Jeongik Cha36f76c32020-07-28 00:25:52 +09003403 io_delegate_.SetFileContents("Bar.aidl", "parcelable Bar { String a; }");
Jooyung Hand4057c42020-10-23 13:28:22 +09003404 string expected_error =
Jooyung Han59af9cc2020-10-25 21:44:14 +09003405 "ERROR: Foo.aidl:1.40-44: The @JavaOnlyImmutable 'Foo' has a non-immutable field "
3406 "named 'bar'.\n";
3407 CaptureStderr();
3408 Options options = Options::From("aidl --lang=java Foo.aidl -I .");
3409 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3410 EXPECT_EQ(expected_error, GetCapturedStderr());
3411}
3412
Jooyung Han09e551c2021-05-11 11:44:48 +09003413TEST_F(AidlTest, JavaOnlyImmutableParcelableWithEnumFields) {
3414 io_delegate_.SetFileContents("Foo.aidl", "@JavaOnlyImmutable parcelable Foo { Bar bar; }");
3415 io_delegate_.SetFileContents("Bar.aidl", "enum Bar { FOO }");
3416 CaptureStderr();
3417 Options options = Options::From("aidl --lang=java Foo.aidl -I .");
3418 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3419 EXPECT_EQ("", GetCapturedStderr());
3420}
3421
Jooyung Han59af9cc2020-10-25 21:44:14 +09003422TEST_F(AidlTest, RejectMutableParcelableFromJavaOnlyImmutableUnion) {
3423 io_delegate_.SetFileContents("Foo.aidl", "@JavaOnlyImmutable union Foo { Bar bar; }");
3424 io_delegate_.SetFileContents("Bar.aidl", "parcelable Bar { String a; }");
3425 string expected_error =
3426 "ERROR: Foo.aidl:1.35-39: The @JavaOnlyImmutable 'Foo' has a non-immutable field "
Jooyung Hand4057c42020-10-23 13:28:22 +09003427 "named 'bar'.\n";
3428 CaptureStderr();
Jeongik Cha36f76c32020-07-28 00:25:52 +09003429 Options options = Options::From("aidl --lang=java Foo.aidl -I .");
3430 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jooyung Hand4057c42020-10-23 13:28:22 +09003431 EXPECT_EQ(expected_error, GetCapturedStderr());
Jeongik Cha36f76c32020-07-28 00:25:52 +09003432}
3433
Jooyung Han66813932020-10-23 13:24:44 +09003434TEST_F(AidlTest, ImmutableParcelableCannotBeInOut) {
Jeongik Chad0a10272020-08-06 16:33:36 +09003435 io_delegate_.SetFileContents("Foo.aidl", "@JavaOnlyImmutable parcelable Foo { int a; }");
Jooyung Han15fd6c62020-10-23 13:54:46 +09003436 io_delegate_.SetFileContents("IBar.aidl", "interface IBar { void my(inout Foo foo); }");
3437 string expected_error =
3438 "ERROR: IBar.aidl:1.35-39: 'foo' can't be an inout parameter because @JavaOnlyImmutable can "
3439 "only be an in parameter.\n";
3440 CaptureStderr();
Jeongik Cha36f76c32020-07-28 00:25:52 +09003441 Options options = Options::From("aidl --lang=java IBar.aidl -I .");
3442 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jooyung Han15fd6c62020-10-23 13:54:46 +09003443 EXPECT_EQ(expected_error, GetCapturedStderr());
Jeongik Cha36f76c32020-07-28 00:25:52 +09003444}
3445
Jooyung Han66813932020-10-23 13:24:44 +09003446TEST_F(AidlTest, ImmutableParcelableCannotBeOut) {
Jeongik Chad0a10272020-08-06 16:33:36 +09003447 io_delegate_.SetFileContents("Foo.aidl", "@JavaOnlyImmutable parcelable Foo { int a; }");
Jooyung Han15fd6c62020-10-23 13:54:46 +09003448 io_delegate_.SetFileContents("IBar.aidl", "interface IBar { void my(out Foo foo); }");
3449 string expected_error =
3450 "ERROR: IBar.aidl:1.33-37: 'foo' can't be an out parameter because @JavaOnlyImmutable can "
3451 "only be an in parameter.\n";
3452 CaptureStderr();
Jeongik Cha36f76c32020-07-28 00:25:52 +09003453 Options options = Options::From("aidl --lang=java IBar.aidl -I .");
3454 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jooyung Han15fd6c62020-10-23 13:54:46 +09003455 EXPECT_EQ(expected_error, GetCapturedStderr());
Jeongik Cha36f76c32020-07-28 00:25:52 +09003456}
3457
Jooyung Han66813932020-10-23 13:24:44 +09003458TEST_F(AidlTest, ImmutableParcelableFieldNameRestriction) {
Jeongik Chad0a10272020-08-06 16:33:36 +09003459 io_delegate_.SetFileContents("Foo.aidl", "@JavaOnlyImmutable parcelable Foo { int a; int A; }");
Jeongik Cha91180252020-07-31 15:43:11 +09003460 Options options = Options::From("aidl --lang=java Foo.aidl");
3461 const string expected_stderr =
Jooyung Han59af9cc2020-10-25 21:44:14 +09003462 "ERROR: Foo.aidl:1.47-49: 'Foo' has duplicate field name 'A' after capitalizing the first "
3463 "letter\n";
Jeongik Cha91180252020-07-31 15:43:11 +09003464 CaptureStderr();
3465 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3466 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3467}
Devin Moore53fc99c2020-08-12 08:07:52 -07003468
Jooyung Hanfe086af2021-01-16 03:44:47 +09003469TEST_P(AidlTest, UnionInUnion) {
3470 import_paths_.insert(".");
3471 io_delegate_.SetFileContents("Bar.aidl", "union Bar { int n = 42; long l; }");
3472 CaptureStderr();
3473 EXPECT_NE(nullptr, Parse("Foo.aidl", "union Foo { Bar b; int n; }", typenames_, GetLanguage()));
3474 EXPECT_THAT("", GetCapturedStderr());
3475}
3476
Jooyung Hanfe89f122020-10-14 03:49:18 +09003477TEST_P(AidlTest, UnionRejectsEmptyDecl) {
3478 const string method = "package a; union Foo {}";
3479 const string expected_stderr = "ERROR: a/Foo.aidl:1.17-21: The union 'Foo' has no fields.\n";
3480 CaptureStderr();
3481 EXPECT_EQ(nullptr, Parse("a/Foo.aidl", method, typenames_, GetLanguage()));
3482 EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr(expected_stderr));
3483}
3484
3485TEST_P(AidlTest, UnionRejectsParcelableHolder) {
3486 const string method = "package a; union Foo { ParcelableHolder x; }";
3487 const string expected_stderr =
3488 "ERROR: a/Foo.aidl:1.40-42: A union can't have a member of ParcelableHolder 'x'\n";
3489 CaptureStderr();
3490 EXPECT_EQ(nullptr, Parse("a/Foo.aidl", method, typenames_, GetLanguage()));
3491 EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr(expected_stderr));
3492}
3493
Jooyung Han53fb4242020-12-17 16:03:49 +09003494TEST_P(AidlTest, UnionRejectsFirstEnumWithNoDefaults) {
3495 import_paths_.insert(".");
3496 io_delegate_.SetFileContents("a/Enum.aidl", "package a; enum Enum { FOO, BAR }");
3497 const string expected_err = "The union's first member should have a useful default value.";
3498 CaptureStderr();
3499 EXPECT_EQ(nullptr,
3500 Parse("a/Foo.aidl", "package a; union Foo { a.Enum e; }", typenames_, GetLanguage()));
3501 EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr(expected_err));
3502}
3503
Devin Moore53fc99c2020-08-12 08:07:52 -07003504TEST_P(AidlTest, GenericStructuredParcelable) {
3505 io_delegate_.SetFileContents("Foo.aidl", "parcelable Foo<T, U> { int a; int A; }");
Jooyung Han9435e9a2021-01-06 10:16:31 +09003506 Options options = Options::From("aidl Foo.aidl --lang=" + to_string(GetLanguage()));
Devin Moore53fc99c2020-08-12 08:07:52 -07003507 const string expected_stderr = "";
3508 CaptureStderr();
3509 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3510 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3511}
3512
Jooyung Han3f347ca2020-12-01 12:41:50 +09003513TEST_F(AidlTest, GenericStructuredParcelableWithStringConstants_Cpp) {
3514 io_delegate_.SetFileContents("Foo.aidl",
3515 "parcelable Foo<T, U> { int a; const String s = \"\"; }");
3516 Options options =
Jooyung Han9435e9a2021-01-06 10:16:31 +09003517 Options::From("aidl Foo.aidl --lang=" + to_string(Options::Language::CPP) + " -o out -h out");
Jooyung Han3f347ca2020-12-01 12:41:50 +09003518 const string expected_stderr = "";
3519 CaptureStderr();
3520 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3521 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3522
3523 string code;
3524 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/Foo.h", &code));
3525 EXPECT_THAT(code, testing::HasSubstr(R"--(template <typename T, typename U>
3526const ::android::String16& Foo<T,U>::s() {
3527 static const ::android::String16 value(::android::String16(""));
3528 return value;
3529})--"));
3530}
3531
3532TEST_F(AidlTest, GenericStructuredParcelableWithStringConstants_Ndk) {
3533 io_delegate_.SetFileContents("Foo.aidl",
3534 "parcelable Foo<T, U> { int a; const String s = \"\"; }");
3535 Options options =
Jooyung Han9435e9a2021-01-06 10:16:31 +09003536 Options::From("aidl Foo.aidl --lang=" + to_string(Options::Language::NDK) + " -o out -h out");
Jooyung Han3f347ca2020-12-01 12:41:50 +09003537 const string expected_stderr = "";
3538 CaptureStderr();
3539 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3540 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3541
3542 string code;
3543 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/aidl/Foo.h", &code));
3544 EXPECT_THAT(code, testing::HasSubstr(R"--(template <typename T, typename U>
3545const char* Foo<T, U>::s = "";
3546)--"));
3547}
3548
Jooyung Han8c9a4e12020-10-26 15:39:54 +09003549TEST_F(AidlTest, NestedTypeArgs) {
3550 io_delegate_.SetFileContents("a/Bar.aidl", "package a; parcelable Bar<A> { }");
Steven Moreland6c07b832020-10-29 23:39:53 +00003551 io_delegate_.SetFileContents("a/Baz.aidl", "package a; parcelable Baz<A, B> { }");
3552
3553 io_delegate_.SetFileContents("a/Foo.aidl",
3554 "package a; import a.Bar; import a.Baz; parcelable Foo { "
3555 "Baz<Bar<Bar<String[]>>[], Bar<String>> barss; }");
Jooyung Han8c9a4e12020-10-26 15:39:54 +09003556 Options options = Options::From("aidl a/Foo.aidl -I . -o out --lang=java");
3557 const string expected_stderr = "";
3558 CaptureStderr();
3559 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3560 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3561
3562 string code;
3563 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/Foo.java", &code));
Steven Moreland6c07b832020-10-29 23:39:53 +00003564 EXPECT_THAT(code,
3565 testing::HasSubstr(
3566 "a.Baz<a.Bar<a.Bar<java.lang.String[]>>[],a.Bar<java.lang.String>> barss;"));
3567}
3568
3569TEST_F(AidlTest, DoubleArrayError) {
3570 io_delegate_.SetFileContents("a/Bar.aidl", "package a; parcelable Bar { String[][] a; }");
3571
3572 Options options = Options::From("aidl a/Bar.aidl -I . -o out --lang=java");
3573 const string expected_stderr =
3574 "ERROR: a/Bar.aidl:1.28-37: Can only have one dimensional arrays.\n";
3575 CaptureStderr();
3576 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3577 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3578}
3579
3580TEST_F(AidlTest, DoubleGenericError) {
3581 io_delegate_.SetFileContents("a/Bar.aidl",
3582 "package a; parcelable Bar { List<String><String> a; }");
3583
3584 Options options = Options::From("aidl a/Bar.aidl -I . -o out --lang=java");
3585 const string expected_stderr =
3586 "ERROR: a/Bar.aidl:1.28-33: Can only specify one set of type parameters.\n";
3587 CaptureStderr();
3588 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3589 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3590}
3591
3592TEST_F(AidlTest, ArrayBeforeGenericError) {
3593 io_delegate_.SetFileContents("a/Bar.aidl", "package a; parcelable Bar { List[]<String> a; }");
3594
3595 Options options = Options::From("aidl a/Bar.aidl -I . -o out --lang=java");
Steven Moreland6c07b832020-10-29 23:39:53 +00003596 CaptureStderr();
3597 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jooyung Han97c324a2021-02-15 16:09:51 +09003598 EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr("syntax error, unexpected '<'"));
3599}
3600
3601TEST_F(AidlTest, NullableArraysAreNotSupported) {
3602 io_delegate_.SetFileContents("a/Bar.aidl",
3603 "package a; parcelable Bar { String @nullable [] a; }");
3604
3605 Options options = Options::From("aidl a/Bar.aidl -I . -o out --lang=java");
3606 CaptureStderr();
3607 EXPECT_EQ(1, ::android::aidl::compile_aidl(options, io_delegate_));
3608 EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr("Annotations for arrays are not supported."));
3609}
3610
3611TEST_F(AidlTest, ListOfNullablesAreNotSupported) {
3612 io_delegate_.SetFileContents("a/Bar.aidl",
3613 "package a; parcelable Bar { List<@nullable String> a; }");
3614
3615 Options options = Options::From("aidl a/Bar.aidl -I . -o out --lang=java");
3616 CaptureStderr();
3617 EXPECT_EQ(1, ::android::aidl::compile_aidl(options, io_delegate_));
3618 EXPECT_THAT(GetCapturedStderr(),
3619 testing::HasSubstr("Annotations for type arguments are not supported."));
Jooyung Han8c9a4e12020-10-26 15:39:54 +09003620}
3621
Jooyung Han14004ed2020-10-16 03:49:57 +09003622struct GenericAidlTest : ::testing::Test {
3623 FakeIoDelegate io_delegate_;
3624 void Compile(string cmd) {
Steven Moreland6c07b832020-10-29 23:39:53 +00003625 io_delegate_.SetFileContents("Foo.aidl", "parcelable Foo { Bar<Baz<Qux>> x; }");
Jooyung Han14004ed2020-10-16 03:49:57 +09003626 io_delegate_.SetFileContents("Bar.aidl", "parcelable Bar<T> { }");
3627 io_delegate_.SetFileContents("Baz.aidl", "parcelable Baz<T> { }");
3628 io_delegate_.SetFileContents("Qux.aidl", "parcelable Qux { }");
3629
3630 Options options = Options::From(cmd);
3631 CaptureStderr();
3632 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3633 EXPECT_EQ("", GetCapturedStderr());
3634 }
3635};
3636
3637TEST_F(GenericAidlTest, ImportGenericParameterTypesCPP) {
3638 Compile("aidl Foo.aidl --lang=cpp -I . -o out -h out");
3639 string code;
3640 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/Foo.h", &code));
3641 EXPECT_THAT(code, testing::HasSubstr("#include <Bar.h>"));
3642 EXPECT_THAT(code, testing::HasSubstr("#include <Baz.h>"));
3643 EXPECT_THAT(code, testing::HasSubstr("#include <Qux.h>"));
3644}
3645
3646TEST_F(GenericAidlTest, ImportGenericParameterTypesNDK) {
3647 Compile("aidl Foo.aidl --lang=ndk -I . -o out -h out");
3648 string code;
3649 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/aidl/Foo.h", &code));
3650 EXPECT_THAT(code, testing::HasSubstr("#include <aidl/Bar.h>"));
3651 EXPECT_THAT(code, testing::HasSubstr("#include <aidl/Baz.h>"));
3652 EXPECT_THAT(code, testing::HasSubstr("#include <aidl/Qux.h>"));
3653}
3654
Devin Moore53fc99c2020-08-12 08:07:52 -07003655TEST_P(AidlTest, RejectGenericStructuredParcelabelRepeatedParam) {
3656 io_delegate_.SetFileContents("Foo.aidl", "parcelable Foo<T,T> { int a; int A; }");
Jooyung Han9435e9a2021-01-06 10:16:31 +09003657 Options options = Options::From("aidl Foo.aidl --lang=" + to_string(GetLanguage()));
Devin Moore53fc99c2020-08-12 08:07:52 -07003658 const string expected_stderr =
3659 "ERROR: Foo.aidl:1.11-15: Every type parameter should be unique.\n";
3660 CaptureStderr();
3661 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3662 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3663}
3664
3665TEST_P(AidlTest, RejectGenericStructuredParcelableField) {
3666 io_delegate_.SetFileContents("Foo.aidl", "parcelable Foo<T,T> { T a; int A; }");
Jooyung Han9435e9a2021-01-06 10:16:31 +09003667 Options options = Options::From("aidl Foo.aidl --lang=" + to_string(GetLanguage()));
Devin Moore53fc99c2020-08-12 08:07:52 -07003668 const string expected_stderr = "ERROR: Foo.aidl:1.22-24: Failed to resolve 'T'\n";
3669 CaptureStderr();
3670 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3671 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3672}
3673
Jooyung Han7a308842020-10-27 19:06:49 +09003674TEST_P(AidlTest, LongCommentWithinConstExpression) {
3675 io_delegate_.SetFileContents("Foo.aidl", "enum Foo { FOO = (1 << 1) /* comment */ | 0x0 }");
Jooyung Han9435e9a2021-01-06 10:16:31 +09003676 Options options = Options::From("aidl Foo.aidl --lang=" + to_string(GetLanguage()));
Jooyung Han7a308842020-10-27 19:06:49 +09003677 CaptureStderr();
3678 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3679 EXPECT_EQ("", GetCapturedStderr());
3680}
3681
Jeongik Chaef44e622020-10-23 16:00:52 +09003682TEST_F(AidlTest, RejectUntypdeListAndMapInUnion) {
3683 io_delegate_.SetFileContents("a/Foo.aidl", "package a; union Foo { List l; Map m; }");
3684 Options options = Options::From("aidl a/Foo.aidl --lang=java -o out");
3685 std::string expectedErr =
3686 "ERROR: a/Foo.aidl:1.28-30: "
3687 "Encountered an untyped List or Map. The use of untyped List/Map is "
3688 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
3689 "the receiving side. Consider switching to an array or a generic List/Map.\n"
3690 "ERROR: a/Foo.aidl:1.35-37: "
3691 "Encountered an untyped List or Map. The use of untyped List/Map is "
3692 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
3693 "the receiving side. Consider switching to an array or a generic List/Map.\n";
3694 CaptureStderr();
3695 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3696 EXPECT_EQ(expectedErr, GetCapturedStderr());
3697}
3698
3699TEST_F(AidlTest, RejectUntypdeListAndMapInUnstructuredParcelable) {
Jooyung Hanea2147c2020-10-21 18:16:56 +09003700 io_delegate_.SetFileContents("a/Foo.aidl", "package a; parcelable Foo { List l; Map m; }");
3701 Options options = Options::From("aidl a/Foo.aidl --lang=java -o out");
Jeongik Chaef44e622020-10-23 16:00:52 +09003702 std::string expectedErr =
3703 "ERROR: a/Foo.aidl:1.33-35: "
3704 "Encountered an untyped List or Map. The use of untyped List/Map is "
3705 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
3706 "the receiving side. Consider switching to an array or a generic List/Map.\n"
3707 "ERROR: a/Foo.aidl:1.40-42: "
3708 "Encountered an untyped List or Map. The use of untyped List/Map is "
3709 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
3710 "the receiving side. Consider switching to an array or a generic List/Map.\n";
Jooyung Hanea2147c2020-10-21 18:16:56 +09003711 CaptureStderr();
Jeongik Chaef44e622020-10-23 16:00:52 +09003712 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3713 EXPECT_EQ(expectedErr, GetCapturedStderr());
3714}
Jooyung Hanea2147c2020-10-21 18:16:56 +09003715
Jeongik Chaef44e622020-10-23 16:00:52 +09003716TEST_F(AidlTest, RejectNestedUntypedListAndMap) {
3717 io_delegate_.SetFileContents("a/Bar.aidl", "package a; parcelable Bar<T>;");
3718 io_delegate_.SetFileContents(
3719 "a/Foo.aidl", "package a; import a.Bar; parcelable Foo { Bar<List> a; Bar<Map> b; }");
3720 Options options = Options::From("aidl a/Foo.aidl -I . --lang=java -o out");
3721 std::string expectedErr =
3722 "ERROR: a/Foo.aidl:1.52-54: "
3723 "Encountered an untyped List or Map. The use of untyped List/Map is "
3724 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
3725 "the receiving side. Consider switching to an array or a generic List/Map.\n"
3726 "ERROR: a/Foo.aidl:1.64-66: "
3727 "Encountered an untyped List or Map. The use of untyped List/Map is "
3728 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
3729 "the receiving side. Consider switching to an array or a generic List/Map.\n";
3730 CaptureStderr();
3731 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3732 EXPECT_EQ(expectedErr, GetCapturedStderr());
Jooyung Hanea2147c2020-10-21 18:16:56 +09003733}
3734
Jooyung Han690f5842020-12-04 13:02:04 +09003735TEST_F(AidlTest, EnumWithDefaults_Java) {
3736 io_delegate_.SetFileContents("a/p/Enum.aidl", "package p; enum Enum { FOO, BAR }");
3737 io_delegate_.SetFileContents("a/p/Foo.aidl", R"(
3738package p;
3739import p.Enum;
3740parcelable Foo {
3741 Enum e = Enum.BAR;
3742})");
3743 CaptureStderr();
3744 auto options = Options::From("aidl -I a --lang java -o out a/p/Foo.aidl");
3745 EXPECT_EQ(0, aidl::compile_aidl(options, io_delegate_));
3746 auto err = GetCapturedStderr();
3747 EXPECT_EQ("", err);
3748
3749 string code;
3750 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/p/Foo.java", &code));
Jooyung Han2d833612020-12-17 15:59:27 +09003751 EXPECT_THAT(code, testing::HasSubstr("byte e = p.Enum.BAR"));
Jooyung Han690f5842020-12-04 13:02:04 +09003752}
3753
3754TEST_F(AidlTest, EnumWithDefaults_Cpp) {
3755 io_delegate_.SetFileContents("a/p/Enum.aidl", "package p; enum Enum { FOO, BAR }");
3756 io_delegate_.SetFileContents("a/p/Foo.aidl", R"(
3757package p;
3758import p.Enum;
3759parcelable Foo {
3760 Enum e = Enum.BAR;
3761})");
3762 CaptureStderr();
3763 auto options = Options::From("aidl -I a --lang cpp -o out -h out a/p/Foo.aidl");
3764 EXPECT_EQ(0, aidl::compile_aidl(options, io_delegate_));
3765 auto err = GetCapturedStderr();
3766 EXPECT_EQ("", err);
3767
3768 string code;
3769 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/p/Foo.h", &code));
3770 EXPECT_THAT(code, testing::HasSubstr("::p::Enum e = ::p::Enum(::p::Enum::BAR);"));
3771}
3772
3773TEST_F(AidlTest, EnumWithDefaults_Ndk) {
3774 io_delegate_.SetFileContents("a/p/Enum.aidl", "package p; enum Enum { FOO, BAR }");
3775 io_delegate_.SetFileContents("a/p/Foo.aidl", R"(
3776package p;
3777import p.Enum;
3778parcelable Foo {
3779 Enum e = Enum.BAR;
3780})");
3781 CaptureStderr();
3782 auto options = Options::From("aidl -I a --lang ndk -o out -h out a/p/Foo.aidl");
3783 EXPECT_EQ(0, aidl::compile_aidl(options, io_delegate_));
3784 auto err = GetCapturedStderr();
3785 EXPECT_EQ("", err);
3786
3787 string code;
3788 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/aidl/p/Foo.h", &code));
3789 EXPECT_THAT(code, testing::HasSubstr("::aidl::p::Enum e = ::aidl::p::Enum::BAR;"));
3790}
3791
3792TEST_F(AidlTest, EnumWithDefaults_Rust) {
3793 io_delegate_.SetFileContents("a/p/Enum.aidl", "package p; enum Enum { FOO, BAR }");
3794 io_delegate_.SetFileContents("a/p/Foo.aidl", R"(
3795package p;
3796import p.Enum;
3797parcelable Foo {
3798 int n = 42;
3799 Enum e = Enum.BAR;
3800})");
3801 CaptureStderr();
3802 auto options = Options::From("aidl -I a --lang rust -o out -h out a/p/Foo.aidl");
3803 EXPECT_EQ(0, aidl::compile_aidl(options, io_delegate_));
3804 auto err = GetCapturedStderr();
3805 EXPECT_EQ("", err);
3806
3807 string code;
3808 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/p/Foo.rs", &code));
3809 EXPECT_THAT(code, testing::HasSubstr(R"(
3810 fn default() -> Self {
3811 Self {
3812 n: 42,
3813 e: crate::mangled::_1_p_4_Enum::BAR,
3814 }
3815 })"));
3816}
3817
3818TEST_P(AidlTest, EnumeratorIsConstantValue_DefaultValue) {
3819 import_paths_.insert("a");
3820 io_delegate_.SetFileContents("a/p/Enum.aidl", "package p; enum Enum { FOO = 1, BAR = 2}");
3821 CaptureStderr();
3822 const AidlDefinedType* type = Parse("a/p/Foo.aidl", R"(
3823package p;
3824import p.Enum;
3825parcelable Foo {
3826 int e = Enum.FOO | Enum.BAR;
3827})",
3828 typenames_, GetLanguage());
3829 auto err = GetCapturedStderr();
3830 EXPECT_EQ("", err);
3831 EXPECT_TRUE(type);
3832 const auto& fields = type->AsStructuredParcelable()->GetFields();
3833 EXPECT_EQ("int e = 3", fields[0]->ToString());
3834}
3835
3836TEST_P(AidlTest, EnumeratorIsConstantValue_CanDefineOtherEnumerator) {
3837 CaptureStderr();
3838 const AidlDefinedType* type = Parse("a/p/Foo.aidl", R"(
3839@Backing(type="int")
3840enum Foo {
3841 STANDARD_SHIFT = 16,
3842 STANDARD_BT709 = 1 << STANDARD_SHIFT,
3843 STANDARD_BT601_625 = 2 << STANDARD_SHIFT,
3844}
3845)",
3846 typenames_, GetLanguage());
3847 auto err = GetCapturedStderr();
3848 EXPECT_EQ("", err);
3849 EXPECT_TRUE(type);
3850 const auto& enum_type = type->AsEnumDeclaration();
3851 string code;
Jooyung Han1f56b702021-02-11 13:16:15 +09003852 auto writer = CodeWriter::ForString(&code);
3853 DumpVisitor visitor(*writer);
3854 visitor.Visit(*enum_type);
3855 writer->Close();
Jooyung Han690f5842020-12-04 13:02:04 +09003856 EXPECT_EQ(R"--(@Backing(type="int")
3857enum Foo {
3858 STANDARD_SHIFT = 16,
3859 STANDARD_BT709 = 65536,
3860 STANDARD_BT601_625 = 131072,
3861}
3862)--",
3863 code);
3864}
3865
3866TEST_F(AidlTest, EnumDefaultShouldBeEnumerators) {
3867 io_delegate_.SetFileContents("a/p/Enum.aidl", "package p; enum Enum { FOO = 1, BAR = 2}");
3868 io_delegate_.SetFileContents("a/p/Foo.aidl", R"(
3869package p;
3870import p.Enum;
3871parcelable Foo {
3872 Enum e = Enum.FOO | Enum.BAR;
3873})");
3874 CaptureStderr();
3875 auto options = Options::From("aidl -I a --lang java -o out -h out a/p/Foo.aidl");
3876 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
3877 auto err = GetCapturedStderr();
3878 EXPECT_EQ("ERROR: a/p/Foo.aidl:5.11-20: Invalid value (Enum.FOO|Enum.BAR) for enum p.Enum\n",
3879 err);
3880}
3881
Jooyung Han361cd102021-05-24 11:30:10 +09003882TEST_F(AidlTest, EnumDefaultShouldBeEnumerators_RejectsNumericValue) {
3883 io_delegate_.SetFileContents("a/p/Enum.aidl", "package p; enum Enum { FOO = 1, BAR = 2}");
3884 io_delegate_.SetFileContents("a/p/Foo.aidl", R"(
3885package p;
3886import p.Enum;
3887parcelable Foo {
3888 Enum e = 1;
3889})");
3890 CaptureStderr();
3891 auto options = Options::From("aidl -I a --lang java -o out -h out a/p/Foo.aidl");
3892 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
3893 EXPECT_THAT(GetCapturedStderr(), HasSubstr("Invalid value (1) for enum p.Enum"));
3894}
3895
Jooyung Han690f5842020-12-04 13:02:04 +09003896TEST_P(AidlTest, DefaultWithEmptyArray) {
3897 io_delegate_.SetFileContents("a/p/Foo.aidl", "package p; parcelable Foo { p.Bar[] bars = {}; }");
3898 io_delegate_.SetFileContents("a/p/Bar.aidl", "package p; parcelable Bar { }");
3899 CaptureStderr();
Jooyung Han9435e9a2021-01-06 10:16:31 +09003900 auto options =
3901 Options::From("aidl -I a --lang " + to_string(GetLanguage()) + " -o out -h out a/p/Foo.aidl");
Jooyung Han690f5842020-12-04 13:02:04 +09003902 EXPECT_EQ(0, aidl::compile_aidl(options, io_delegate_));
3903 auto err = GetCapturedStderr();
3904 EXPECT_EQ("", err);
3905}
3906
3907TEST_P(AidlTest, RejectRefsInAnnotation) {
3908 io_delegate_.SetFileContents("a/p/IFoo.aidl",
3909 "package p; interface IFoo {\n"
3910 " const String ANNOTATION = \"@Annotation\";\n"
3911 " @JavaPassthrough(annotation=ANNOTATION) void foo();\n"
3912 "}");
3913 CaptureStderr();
Jooyung Han9435e9a2021-01-06 10:16:31 +09003914 auto options =
3915 Options::From("aidl --lang " + to_string(GetLanguage()) + " -o out -h out a/p/IFoo.aidl");
Jooyung Han690f5842020-12-04 13:02:04 +09003916 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
3917 auto err = GetCapturedStderr();
3918 EXPECT_EQ(
3919 "ERROR: a/p/IFoo.aidl:3.31-41: Value must be a constant expression but contains reference to "
3920 "ANNOTATION.\n",
3921 err);
3922}
3923
3924TEST_F(AidlTest, DefaultWithEnumValues) {
3925 io_delegate_.SetFileContents(
3926 "a/p/Foo.aidl",
3927 "package p; import p.Bar; parcelable Foo { Bar[] bars = { Bar.FOO, Bar.FOO }; }");
3928 io_delegate_.SetFileContents("a/p/Bar.aidl", "package p; enum Bar { FOO, BAR }");
3929 CaptureStderr();
3930 auto options = Options::From("aidl -I a --lang ndk -o out -h out a/p/Foo.aidl");
3931 EXPECT_EQ(0, aidl::compile_aidl(options, io_delegate_));
3932 auto err = GetCapturedStderr();
3933 EXPECT_EQ("", err);
3934 string code;
3935 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/aidl/p/Foo.h", &code));
3936 EXPECT_THAT(
3937 code, testing::HasSubstr(
3938 "std::vector<::aidl::p::Bar> bars = {::aidl::p::Bar::FOO, ::aidl::p::Bar::FOO};"));
3939}
3940
Jooyung Han14259392020-12-07 10:00:08 +09003941TEST_F(AidlTest, RejectsCircularReferencingEnumerators) {
3942 io_delegate_.SetFileContents("a/p/Foo.aidl", "package p; enum Foo { A = B, B }");
3943 CaptureStderr();
3944 auto options = Options::From("aidl -I a --lang ndk -o out -h out a/p/Foo.aidl");
3945 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
3946 auto err = GetCapturedStderr();
Jooyung Hanb9d60e02021-05-21 07:54:17 +09003947 EXPECT_EQ("ERROR: a/p/Foo.aidl:1.26-28: Found a circular reference: B -> A -> B\n", err);
Jooyung Han14259392020-12-07 10:00:08 +09003948}
3949
3950TEST_F(AidlTest, RejectsCircularReferencingConsts) {
3951 io_delegate_.SetFileContents("a/p/Foo.aidl",
3952 "package p; parcelable Foo { const int A = A + 1; }");
3953 CaptureStderr();
3954 auto options = Options::From("aidl -I a --lang ndk -o out -h out a/p/Foo.aidl");
3955 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
3956 auto err = GetCapturedStderr();
Jooyung Han29813842020-12-08 01:28:03 +09003957 EXPECT_EQ("ERROR: a/p/Foo.aidl:1.42-44: Found a circular reference: A -> A\n", err);
3958}
3959
3960TEST_F(AidlTest, RecursiveReferences) {
3961 io_delegate_.SetFileContents("a/p/Foo.aidl",
3962 "package p; parcelable Foo { const int A = p.Bar.A + 1; }");
3963 io_delegate_.SetFileContents("a/p/Bar.aidl",
3964 "package p; parcelable Bar { const int A = p.Baz.A + 1; }");
3965 io_delegate_.SetFileContents("a/p/Baz.aidl", "package p; parcelable Baz { const int A = 1; }");
3966 CaptureStderr();
3967 auto options = Options::From("aidl -I a --lang ndk -o out -h out a/p/Foo.aidl");
3968 EXPECT_EQ(0, aidl::compile_aidl(options, io_delegate_));
3969 EXPECT_EQ("", GetCapturedStderr());
3970}
3971
Jooyung Hanb9d60e02021-05-21 07:54:17 +09003972TEST_P(AidlTest, CircularReferenceWithFullyQualified) {
3973 io_delegate_.SetFileContents("Foo.aidl", "enum Foo { A = Foo.A }");
3974 auto options =
3975 Options::From("aidl --lang " + to_string(GetLanguage()) + " -I . -o out -h out Foo.aidl");
3976 const string err = "ERROR: Foo.aidl:1.15-21: Found a circular reference: Foo.A -> Foo.A\n";
3977 CaptureStderr();
3978 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
3979 EXPECT_EQ(err, GetCapturedStderr());
3980}
3981
3982TEST_P(AidlTest, ConstRefsCanPointToTheSameValue) {
3983 io_delegate_.SetFileContents("Foo.aidl", "enum Foo { A = 0 }");
3984 // this demonstrates the case that "Foo.A" const-ref node is visited twice by B and C.
3985 io_delegate_.SetFileContents("Bar.aidl", "enum Bar { A = Foo.A, B = A, C = A }");
3986 auto options =
3987 Options::From("aidl --lang " + to_string(GetLanguage()) + " -I . -o out -h out Bar.aidl");
3988 CaptureStderr();
3989 EXPECT_EQ(0, aidl::compile_aidl(options, io_delegate_));
3990 EXPECT_EQ("", GetCapturedStderr());
3991}
3992
Jooyung Hane9f5b272021-01-07 00:18:11 +09003993TEST_P(AidlTest, UnknownConstReference) {
3994 io_delegate_.SetFileContents("Foo.aidl", " parcelable Foo { UnknownType field = UNKNOWN_REF; }");
3995 auto options =
3996 Options::From("aidl --lang " + to_string(GetLanguage()) + " -o out -h out Foo.aidl");
3997 const string err =
3998 "ERROR: Foo.aidl:1.18-30: Failed to resolve 'UnknownType'\n"
3999 "ERROR: Foo.aidl:1.38-50: Can't find UNKNOWN_REF in Foo\n"
4000 "ERROR: Foo.aidl:1.38-50: Unknown reference 'UNKNOWN_REF'\n";
4001 CaptureStderr();
4002 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
4003 EXPECT_EQ(err, GetCapturedStderr());
4004}
4005
Jooyung Han29813842020-12-08 01:28:03 +09004006TEST_P(AidlTest, JavaCompatibleBuiltinTypes) {
4007 string contents = R"(
4008import android.os.IBinder;
4009import android.os.IInterface;
4010interface IFoo {}
4011 )";
4012 EXPECT_NE(nullptr, Parse("IFoo.aidl", contents, typenames_, GetLanguage()));
Jooyung Han14259392020-12-07 10:00:08 +09004013}
4014
Jooyung Han888c5bc2020-12-22 17:28:47 +09004015TEST_P(AidlTest, WarningInterfaceName) {
4016 io_delegate_.SetFileContents("p/Foo.aidl", "interface Foo {}");
Jooyung Han9435e9a2021-01-06 10:16:31 +09004017 auto options = Options::From("aidl --lang " + to_string(GetLanguage()) +
Jooyung Han888c5bc2020-12-22 17:28:47 +09004018 " -Weverything -o out -h out p/Foo.aidl");
4019 CaptureStderr();
4020 EXPECT_EQ(0, aidl::compile_aidl(options, io_delegate_));
Jooyung Han808a2a02020-12-28 16:46:54 +09004021 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 +09004022 GetCapturedStderr());
4023}
4024
4025TEST_P(AidlTest, ErrorInterfaceName) {
4026 io_delegate_.SetFileContents("p/Foo.aidl", "interface Foo {}");
Jooyung Han9435e9a2021-01-06 10:16:31 +09004027 auto options = Options::From("aidl --lang " + to_string(GetLanguage()) +
Jooyung Han888c5bc2020-12-22 17:28:47 +09004028 " -Weverything -Werror -o out -h out p/Foo.aidl");
4029 CaptureStderr();
4030 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
Jooyung Han808a2a02020-12-28 16:46:54 +09004031 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 +09004032 GetCapturedStderr());
4033}
4034
Jiyong Park9f4c3822021-04-07 20:36:45 +09004035TEST_F(AidlTest, RejectsIncorrectOutputFilePathOnLegacyCppInput) {
4036 const std::string input_file = "base/p/q/IFoo.aidl";
4037 const std::string header_dir = "out/";
4038 const std::string output_file = "out/base/p/q/IFoo.cpp";
4039 const std::string package = "p.q"; // not base.p.q
4040 io_delegate_.SetFileContents(input_file, "package " + package + "; interface IFoo {}");
4041
4042 auto options = Options::From({"aidl-cpp", input_file, header_dir, output_file});
4043 CaptureStderr();
4044 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
4045 EXPECT_THAT(
4046 GetCapturedStderr(),
4047 testing::StartsWith(
4048 "ERROR: base/p/q/IFoo.aidl:1.13-23: Output file is expected to be at out/p/q/IFoo.cpp, "
4049 "but is out/base/p/q/IFoo.cpp."));
4050}
4051
Jooyung Hanb7a60ec2021-01-21 13:47:59 +09004052TEST_F(AidlTest, FormatCommentsForJava) {
4053 using android::aidl::FormatCommentsForJava;
4054
4055 struct TestCase {
4056 vector<Comment> comments;
4057 string formatted;
4058 };
4059 vector<TestCase> testcases = {
4060 {{}, ""},
4061 {{{"// line comments\n"}}, "// line comments\n"},
4062 {{{"// @hide \n"}}, "// @hide \n"},
4063 // Transform the last block comment as Javadoc.
4064 {{{"/*\n"
4065 " * Hello, world!\n"
4066 " */"}},
4067 "/**\n"
4068 " * Hello, world!\n"
4069 " */"},
4070 {{{"/* @hide */"}}, "/** @hide */"},
4071 {{{"/**\n"
4072 " @param foo ...\n"
4073 "*/"}},
4074 "/**\n"
4075 " @param foo ...\n"
4076 "*/"},
4077 {{{"/* @hide */"}, {"/* @hide */"}}, "/* @hide *//** @hide */"},
4078 {{{"/* @deprecated first */"}, {"/* @deprecated second */"}},
4079 "/* @deprecated first *//** @deprecated second */"},
4080 {{{"/* @deprecated */"}, {"/** @param foo */"}}, "/* @deprecated *//** @param foo */"},
4081 // Line comments are printed as they are
4082 {{{"/* @deprecated */"}, {"// line comments\n"}}, "/* @deprecated */// line comments\n"},
4083 };
4084 for (const auto& [input, formatted] : testcases) {
4085 EXPECT_EQ(formatted, FormatCommentsForJava(input));
4086 }
4087}
4088
Jooyung Han2d6b5c42021-01-09 01:01:06 +09004089TEST_F(AidlTest, HideIsNotForArgs) {
4090 io_delegate_.SetFileContents("IFoo.aidl",
4091 "interface IFoo {\n"
4092 " void foo(in @Hide int x);\n"
4093 "}");
4094 auto options = Options::From("aidl --lang=java IFoo.aidl");
4095 CaptureStderr();
4096 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
4097 EXPECT_THAT(GetCapturedStderr(), HasSubstr("@Hide is not available"));
4098}
4099
4100TEST_F(AidlTest, SuppressWarningsIsNotForArgs) {
4101 io_delegate_.SetFileContents(
4102 "IFoo.aidl",
4103 "interface IFoo {\n"
4104 " void foo(in @SuppressWarnings(value=\"inout-parameter\") int x);\n"
4105 "}");
4106 auto options = Options::From("aidl --lang=java IFoo.aidl");
4107 CaptureStderr();
4108 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
4109 EXPECT_THAT(GetCapturedStderr(), HasSubstr("@SuppressWarnings is not available"));
4110}
4111
Jooyung Hanfa181932021-06-12 07:56:53 +09004112TEST_F(AidlTest, VoidCantBeUsedInMethodParameterType) {
4113 io_delegate_.SetFileContents("p/IFoo.aidl", "interface IFoo{ void j(void n);}");
4114 auto options = Options::From("aidl --lang=java -o out p/IFoo.aidl");
4115 CaptureStderr();
4116 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
4117 EXPECT_THAT(GetCapturedStderr(), HasSubstr("'void' is an invalid type for the parameter 'n'"));
4118}
4119
Jooyung Hanfd3be322020-12-13 09:11:06 +09004120struct TypeParam {
Jooyung Hane87cdd02020-12-11 16:47:35 +09004121 string kind;
4122 string literal;
4123};
4124
Jooyung Hanfd3be322020-12-13 09:11:06 +09004125const TypeParam kTypeParams[] = {
Jooyung Hancea89002021-02-15 17:04:04 +09004126 {"primitive", "int"}, {"primitiveArray", "int[]"},
4127 {"String", "String"}, {"StringArray", "String[]"},
Jooyung Hane87cdd02020-12-11 16:47:35 +09004128 {"IBinder", "IBinder"}, {"ParcelFileDescriptor", "ParcelFileDescriptor"},
4129 {"parcelable", "Foo"}, {"enum", "a.Enum"},
4130 {"union", "a.Union"}, {"interface", "a.IBar"},
4131};
4132
4133const std::map<std::string, std::string> kListSupportExpectations = {
4134 {"cpp_primitive", "A generic type cannot have any primitive type parameters."},
4135 {"java_primitive", "A generic type cannot have any primitive type parameters."},
4136 {"ndk_primitive", "A generic type cannot have any primitive type parameters."},
4137 {"rust_primitive", "A generic type cannot have any primitive type parameters."},
Jooyung Hancea89002021-02-15 17:04:04 +09004138 {"cpp_primitiveArray", "List of arrays is not supported."},
4139 {"java_primitiveArray", "List of arrays is not supported."},
4140 {"ndk_primitiveArray", "List of arrays is not supported."},
4141 {"rust_primitiveArray", "List of arrays is not supported."},
Jooyung Hane87cdd02020-12-11 16:47:35 +09004142 {"cpp_String", ""},
4143 {"java_String", ""},
4144 {"ndk_String", ""},
4145 {"rust_String", ""},
Jooyung Hancea89002021-02-15 17:04:04 +09004146 {"cpp_StringArray", "List of arrays is not supported."},
4147 {"java_StringArray", "List of arrays is not supported."},
4148 {"ndk_StringArray", "List of arrays is not supported."},
4149 {"rust_StringArray", "List of arrays is not supported."},
Jooyung Hane87cdd02020-12-11 16:47:35 +09004150 {"cpp_IBinder", ""},
4151 {"java_IBinder", ""},
4152 {"ndk_IBinder", "List<IBinder> is not supported. List in NDK doesn't support IBinder."},
4153 {"rust_IBinder", ""},
Jooyung Han55f96ad2020-12-13 10:08:33 +09004154 {"cpp_ParcelFileDescriptor", ""},
Jooyung Hane87cdd02020-12-11 16:47:35 +09004155 {"java_ParcelFileDescriptor", ""},
4156 {"ndk_ParcelFileDescriptor", ""},
4157 {"rust_ParcelFileDescriptor", ""},
Jooyung Han55f96ad2020-12-13 10:08:33 +09004158 {"cpp_interface", "List<a.IBar> is not supported."},
4159 {"java_interface", "List<a.IBar> is not supported."},
4160 {"ndk_interface", "List<a.IBar> is not supported."},
4161 {"rust_interface", "List<a.IBar> is not supported."},
4162 {"cpp_parcelable", ""},
Jooyung Hane87cdd02020-12-11 16:47:35 +09004163 {"java_parcelable", ""},
4164 {"ndk_parcelable", ""},
4165 {"rust_parcelable", ""},
4166 {"cpp_enum", "A generic type cannot have any primitive type parameters."},
4167 {"java_enum", "A generic type cannot have any primitive type parameters."},
4168 {"ndk_enum", "A generic type cannot have any primitive type parameters."},
4169 {"rust_enum", "A generic type cannot have any primitive type parameters."},
Jooyung Han55f96ad2020-12-13 10:08:33 +09004170 {"cpp_union", ""},
Jooyung Hane87cdd02020-12-11 16:47:35 +09004171 {"java_union", ""},
4172 {"ndk_union", ""},
4173 {"rust_union", ""},
4174};
4175
Jooyung Hand236e552020-12-13 09:21:27 +09004176const std::map<std::string, std::string> kArraySupportExpectations = {
4177 {"cpp_primitive", ""},
4178 {"java_primitive", ""},
4179 {"ndk_primitive", ""},
4180 {"rust_primitive", ""},
Jooyung Hancea89002021-02-15 17:04:04 +09004181 {"cpp_primitiveArray", "Can only have one dimensional arrays."},
4182 {"java_primitiveArray", "Can only have one dimensional arrays."},
4183 {"ndk_primitiveArray", "Can only have one dimensional arrays."},
4184 {"rust_primitiveArray", "Can only have one dimensional arrays."},
Jooyung Hand236e552020-12-13 09:21:27 +09004185 {"cpp_String", ""},
4186 {"java_String", ""},
4187 {"ndk_String", ""},
4188 {"rust_String", ""},
Jooyung Hancea89002021-02-15 17:04:04 +09004189 {"cpp_StringArray", "Can only have one dimensional arrays."},
4190 {"java_StringArray", "Can only have one dimensional arrays."},
4191 {"ndk_StringArray", "Can only have one dimensional arrays."},
4192 {"rust_StringArray", "Can only have one dimensional arrays."},
Jooyung Hand236e552020-12-13 09:21:27 +09004193 {"cpp_IBinder", ""},
4194 {"java_IBinder", ""},
4195 {"ndk_IBinder", "The ndk backend does not support array of IBinder"},
4196 {"rust_IBinder", "The rust backend does not support array of IBinder"},
4197 {"cpp_ParcelFileDescriptor", ""},
4198 {"java_ParcelFileDescriptor", ""},
4199 {"ndk_ParcelFileDescriptor", ""},
4200 {"rust_ParcelFileDescriptor", ""},
4201 {"cpp_interface", "Binder type cannot be an array"},
4202 {"java_interface", "Binder type cannot be an array"},
4203 {"ndk_interface", "Binder type cannot be an array"},
4204 {"rust_interface", "Binder type cannot be an array"},
4205 {"cpp_parcelable", ""},
4206 {"java_parcelable", ""},
4207 {"ndk_parcelable", ""},
4208 {"rust_parcelable", ""},
4209 {"cpp_enum", ""},
4210 {"java_enum", ""},
4211 {"ndk_enum", ""},
4212 {"rust_enum", ""},
4213 {"cpp_union", ""},
4214 {"java_union", ""},
4215 {"ndk_union", ""},
4216 {"rust_union", ""},
4217};
4218
Jooyung Hanfd3be322020-12-13 09:11:06 +09004219class AidlTypeParamTest : public testing::TestWithParam<std::tuple<Options::Language, TypeParam>> {
Jooyung Hane87cdd02020-12-11 16:47:35 +09004220 public:
Jooyung Hanfd3be322020-12-13 09:11:06 +09004221 void Run(const std::string& generic_type_decl,
4222 const std::map<std::string, std::string>& expectations) {
Jooyung Hane87cdd02020-12-11 16:47:35 +09004223 const auto& param = GetParam();
Jooyung Han9435e9a2021-01-06 10:16:31 +09004224 const auto& lang = to_string(std::get<0>(param));
Jooyung Hane87cdd02020-12-11 16:47:35 +09004225 const auto& kind = std::get<1>(param).kind;
4226
4227 FakeIoDelegate io;
4228 io.SetFileContents("a/IBar.aidl", "package a; interface IBar { }");
4229 io.SetFileContents("a/Enum.aidl", "package a; enum Enum { A }");
4230 io.SetFileContents("a/Union.aidl", "package a; union Union { int a; }");
Jooyung Hanfd3be322020-12-13 09:11:06 +09004231 std::string decl = fmt::format(generic_type_decl, std::get<1>(param).literal);
4232 io.SetFileContents("a/Foo.aidl", "package a; parcelable Foo { " + decl + " f; }");
Jooyung Hane87cdd02020-12-11 16:47:35 +09004233
4234 const auto options =
4235 Options::From(fmt::format("aidl -I . --lang={} a/Foo.aidl -o out -h out", lang));
4236 CaptureStderr();
4237 compile_aidl(options, io);
Jooyung Hanfd3be322020-12-13 09:11:06 +09004238 auto it = expectations.find(lang + "_" + kind);
4239 EXPECT_TRUE(it != expectations.end());
Jooyung Hane87cdd02020-12-11 16:47:35 +09004240 const string err = GetCapturedStderr();
4241 if (it->second.empty()) {
4242 EXPECT_EQ("", err);
4243 } else {
4244 EXPECT_THAT(err, testing::HasSubstr(it->second));
4245 }
4246 }
4247};
4248
4249INSTANTIATE_TEST_SUITE_P(
Jooyung Hanfd3be322020-12-13 09:11:06 +09004250 AidlTestSuite, AidlTypeParamTest,
Jooyung Hane87cdd02020-12-11 16:47:35 +09004251 testing::Combine(testing::Values(Options::Language::CPP, Options::Language::JAVA,
4252 Options::Language::NDK, Options::Language::RUST),
Jooyung Hanfd3be322020-12-13 09:11:06 +09004253 testing::ValuesIn(kTypeParams)),
4254 [](const testing::TestParamInfo<std::tuple<Options::Language, TypeParam>>& info) {
Jooyung Han9435e9a2021-01-06 10:16:31 +09004255 return to_string(std::get<0>(info.param)) + "_" + std::get<1>(info.param).kind;
Jooyung Hane87cdd02020-12-11 16:47:35 +09004256 });
4257
Jooyung Hanfd3be322020-12-13 09:11:06 +09004258TEST_P(AidlTypeParamTest, ListSupportedTypes) {
4259 Run("List<{}>", kListSupportExpectations);
4260}
Jooyung Hane87cdd02020-12-11 16:47:35 +09004261
Jooyung Hand236e552020-12-13 09:21:27 +09004262TEST_P(AidlTypeParamTest, ArraySupportedTypes) {
4263 Run("{}[]", kArraySupportExpectations);
4264}
4265
Christopher Wiley90be4e32015-10-20 14:55:25 -07004266} // namespace aidl
4267} // namespace android