blob: b37bc6ee2ffee6311733b9fa3a945c47764d2671 [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 Han0a950bd2021-05-15 12:50:36 +09001290TEST_F(AidlTest, CppNameOf_GenericType) {
1291 io_delegate_.SetFileContents("p/Wrapper.aidl", "package p; parcelable Wrapper<T> { T wrapped; }");
1292 import_paths_.emplace("");
1293 // Since we don't support compilation of Wrapper directly (due to "T" reference),
1294 // prepare Holder so that Wrapper gets parsed into AidlTypenames
1295 const string input_path = "p/Holder.aidl";
1296 const string input =
1297 "package p; import p.Wrapper; parcelable Holder {\n"
1298 " @nullable Wrapper<String> value;\n"
1299 "}";
1300
1301 auto parse_result = Parse(input_path, input, typenames_, Options::Language::CPP);
1302 EXPECT_NE(nullptr, parse_result);
1303
1304 auto type = [](std::string name, auto&&... type_params) -> std::unique_ptr<AidlTypeSpecifier> {
1305 auto params = new std::vector<std::unique_ptr<AidlTypeSpecifier>>;
1306 (..., params->emplace_back(std::move(type_params)));
1307 return std::make_unique<AidlTypeSpecifier>(AIDL_LOCATION_HERE, name, false, params, Comments{});
1308 };
1309
1310 auto set_nullable = [](std::unique_ptr<AidlTypeSpecifier>&& type) {
1311 std::vector<AidlAnnotation> annotations;
1312 annotations.emplace_back(*AidlAnnotation::Parse(AIDL_LOCATION_HERE, "nullable", nullptr, {}));
1313 type->Annotate(std::move(annotations));
1314 return std::move(type);
1315 };
1316
1317 auto set_array = [](std::unique_ptr<AidlTypeSpecifier>&& type) {
1318 (void)type->SetArray();
1319 return std::move(type);
1320 };
1321
1322 auto w = type("p.Wrapper", type("String"));
1323 EXPECT_EQ("::p::Wrapper<::android::String16>", cpp::CppNameOf(*w, typenames_));
1324
1325 auto nullable_w = set_nullable(type("p.Wrapper", type("String")));
1326 EXPECT_EQ("::std::optional<::p::Wrapper<::android::String16>>",
1327 cpp::CppNameOf(*nullable_w, typenames_));
1328
1329 auto array_w = set_array(type("p.Wrapper", type("String")));
1330 EXPECT_EQ("::std::vector<::p::Wrapper<::android::String16>>",
1331 cpp::CppNameOf(*array_w, typenames_));
1332
1333 auto nullable_array_w = set_nullable(set_array(type("p.Wrapper", type("String"))));
1334 EXPECT_EQ("::std::optional<::std::vector<::std::optional<::p::Wrapper<::android::String16>>>>",
1335 cpp::CppNameOf(*nullable_array_w, typenames_));
1336
1337 auto list_w = type("List", type("p.Wrapper", type("String")));
1338 EXPECT_EQ("::std::vector<::p::Wrapper<::android::String16>>",
1339 cpp::CppNameOf(*list_w, typenames_));
1340
1341 auto nullable_list_w = set_nullable(type("List", type("p.Wrapper", type("String"))));
1342 EXPECT_EQ("::std::optional<::std::vector<::std::optional<::p::Wrapper<::android::String16>>>>",
1343 cpp::CppNameOf(*nullable_list_w, typenames_));
1344}
1345
Devin Moore7b8d5c92020-03-17 14:14:08 -07001346TEST_P(AidlTest, UnderstandsNativeParcelables) {
Christopher Wiley9078d722015-11-17 10:23:49 -08001347 io_delegate_.SetFileContents(
1348 "p/Bar.aidl",
Casey Dahlincd639212015-12-15 12:51:04 -08001349 "package p; parcelable Bar cpp_header \"baz/header\";");
Jiyong Park8c380532018-08-30 14:55:26 +09001350 import_paths_.emplace("");
Christopher Wiley9078d722015-11-17 10:23:49 -08001351 const string input_path = "p/IFoo.aidl";
1352 const string input = "package p; import p.Bar; interface IFoo { }";
Devin Moore7b8d5c92020-03-17 14:14:08 -07001353 auto parse_result = Parse(input_path, input, typenames_, GetLanguage());
1354 EXPECT_NE(nullptr, parse_result);
Steven Morelandcb1bcd72020-04-29 16:30:35 -07001355 EXPECT_TRUE(typenames_.ResolveTypename("p.Bar").is_resolved);
Jooyung Han8451a202021-01-16 03:07:06 +09001356 AidlTypeSpecifier native_type(AIDL_LOCATION_HERE, "p.Bar", false, nullptr, {});
Jooyung Han13f1fa52021-06-11 18:06:12 +09001357 native_type.Resolve(typenames_, parse_result);
Devin Moore7b8d5c92020-03-17 14:14:08 -07001358
1359 EXPECT_EQ("p.Bar", java::InstantiableJavaSignatureOf(native_type, typenames_));
1360 // C++ understands C++ specific stuff
1361 EXPECT_EQ("::p::Bar", cpp::CppNameOf(native_type, typenames_));
1362 set<string> headers;
Devin Moore2f2077a2020-08-28 11:27:53 -07001363 cpp::AddHeaders(native_type, typenames_, &headers);
Devin Moore7b8d5c92020-03-17 14:14:08 -07001364 EXPECT_EQ(1u, headers.size());
1365 EXPECT_EQ(1u, headers.count("baz/header"));
Christopher Wiley9078d722015-11-17 10:23:49 -08001366}
1367
Christopher Wileyf8136192016-04-12 14:19:35 -07001368TEST_F(AidlTest, WritesCorrectDependencyFile) {
1369 // While the in tree build system always gives us an output file name,
1370 // other android tools take advantage of our ability to infer the intended
1371 // file name. This test makes sure we handle this correctly.
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001372 vector<string> args = {
1373 "aidl",
1374 "-d dep/file/path",
1375 "-o place/for/output",
1376 "p/IFoo.aidl"};
1377 Options options = Options::From(args);
1378 io_delegate_.SetFileContents(options.InputFiles().front(), "package p; interface IFoo {}");
Jiyong Parkb034bf02018-07-30 17:44:33 +09001379 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
Christopher Wileyf8136192016-04-12 14:19:35 -07001380 string actual_dep_file_contents;
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001381 EXPECT_TRUE(io_delegate_.GetWrittenContents(options.DependencyFile(), &actual_dep_file_contents));
Christopher Wileyf8136192016-04-12 14:19:35 -07001382 EXPECT_EQ(actual_dep_file_contents, kExpectedDepFileContents);
1383}
1384
Dan Willemsen93298ee2016-11-10 23:55:55 -08001385TEST_F(AidlTest, WritesCorrectDependencyFileNinja) {
1386 // While the in tree build system always gives us an output file name,
1387 // other android tools take advantage of our ability to infer the intended
1388 // file name. This test makes sure we handle this correctly.
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001389 vector<string> args = {
1390 "aidl",
1391 "-d dep/file/path",
1392 "--ninja",
1393 "-o place/for/output",
1394 "p/IFoo.aidl"};
1395 Options options = Options::From(args);
1396 io_delegate_.SetFileContents(options.InputFiles().front(), "package p; interface IFoo {}");
Jiyong Parkb034bf02018-07-30 17:44:33 +09001397 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
Dan Willemsen93298ee2016-11-10 23:55:55 -08001398 string actual_dep_file_contents;
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001399 EXPECT_TRUE(io_delegate_.GetWrittenContents(options.DependencyFile(), &actual_dep_file_contents));
Dan Willemsen93298ee2016-11-10 23:55:55 -08001400 EXPECT_EQ(actual_dep_file_contents, kExpectedNinjaDepFileContents);
1401}
1402
Jiyong Parkdf202122019-09-30 20:48:35 +09001403TEST_F(AidlTest, WritesTrivialDependencyFileForParcelableDeclaration) {
Christopher Wileyb1bbdf82016-04-21 11:43:45 -07001404 // The SDK uses aidl to decide whether a .aidl file is a parcelable. It does
1405 // this by calling aidl with every .aidl file it finds, then parsing the
1406 // generated dependency files. Those that reference .java output files are
1407 // for interfaces and those that do not are parcelables. However, for both
1408 // parcelables and interfaces, we *must* generate a non-empty dependency file.
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001409 vector<string> args = {
1410 "aidl",
1411 "-o place/for/output",
1412 "-d dep/file/path",
1413 "p/Foo.aidl"};
1414 Options options = Options::From(args);
1415 io_delegate_.SetFileContents(options.InputFiles().front(), "package p; parcelable Foo;");
Jiyong Parkb034bf02018-07-30 17:44:33 +09001416 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
Christopher Wileyb1bbdf82016-04-21 11:43:45 -07001417 string actual_dep_file_contents;
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001418 EXPECT_TRUE(io_delegate_.GetWrittenContents(options.DependencyFile(), &actual_dep_file_contents));
Jiyong Parkdf202122019-09-30 20:48:35 +09001419 EXPECT_EQ(actual_dep_file_contents, kExpectedParcelableDeclarationDepFileContents);
1420}
1421
1422TEST_F(AidlTest, WritesDependencyFileForStructuredParcelable) {
1423 vector<string> args = {
1424 "aidl",
1425 "--structured",
1426 "-o place/for/output",
1427 "-d dep/file/path",
1428 "p/Foo.aidl"};
1429 Options options = Options::From(args);
1430 io_delegate_.SetFileContents(options.InputFiles().front(), "package p; parcelable Foo {int a;}");
1431 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1432 string actual_dep_file_contents;
1433 EXPECT_TRUE(io_delegate_.GetWrittenContents(options.DependencyFile(), &actual_dep_file_contents));
1434 EXPECT_EQ(actual_dep_file_contents, kExpectedStructuredParcelableDepFileContents);
Christopher Wileyb1bbdf82016-04-21 11:43:45 -07001435}
1436
Jiyong Park9ca5c7e2019-10-17 15:01:14 +09001437TEST_F(AidlTest, NoJavaOutputForParcelableDeclaration) {
1438 vector<string> args = {
1439 "aidl",
1440 "--lang=java",
1441 "-o place/for/output",
1442 "p/Foo.aidl"};
1443 Options options = Options::From(args);
1444 io_delegate_.SetFileContents(options.InputFiles().front(), "package p; parcelable Foo;");
1445 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1446 string output_file_contents;
1447 EXPECT_FALSE(io_delegate_.GetWrittenContents(options.OutputFile(), &output_file_contents));
1448}
1449
Devin Moore21b26772020-08-26 16:37:56 -07001450TEST_P(AidlTest, RejectsListArray) {
Devin Moore6a01ca12020-08-28 10:24:19 -07001451 const string expected_stderr = "ERROR: a/Foo.aidl:2.1-7: List[] is not supported.\n";
Devin Moore21b26772020-08-26 16:37:56 -07001452 const string list_array_parcelable =
1453 "package a; parcelable Foo {\n"
1454 " List[] lists; }";
1455 CaptureStderr();
1456 EXPECT_EQ(nullptr, Parse("a/Foo.aidl", list_array_parcelable, typenames_, GetLanguage()));
1457 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1458}
1459
Jiyong Parkf8d53612020-05-04 14:06:13 +09001460TEST_P(AidlTest, RejectsPrimitiveListInStableAidl) {
1461 AidlError error;
1462 string expected_stderr =
1463 "ERROR: a/IFoo.aidl:2.7-11: "
1464 "Encountered an untyped List or Map. The use of untyped List/Map is "
1465 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
1466 "the receiving side. Consider switching to an array or a generic List/Map.\n";
1467 if (GetLanguage() != Options::Language::JAVA) {
1468 expected_stderr =
1469 "ERROR: a/IFoo.aidl:2.1-7: "
1470 "Currently, only the Java backend supports non-generic List.\n";
1471 }
1472
1473 const string primitive_interface =
1474 "package a; interface IFoo {\n"
1475 " List foo(); }";
1476 CaptureStderr();
Jiyong Park40782d02020-07-24 19:17:43 +09001477 AidlTypenames tn1;
1478 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", primitive_interface, tn1, GetLanguage(), &error,
Jiyong Parkf8d53612020-05-04 14:06:13 +09001479 {"--structured"}));
1480 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Parkf8d53612020-05-04 14:06:13 +09001481
1482 string primitive_parcelable =
1483 "package a; parcelable IFoo {\n"
1484 " List foo;}";
1485 CaptureStderr();
Jiyong Park40782d02020-07-24 19:17:43 +09001486 AidlTypenames tn2;
1487 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", primitive_parcelable, tn2, GetLanguage(), &error,
Jiyong Parkf8d53612020-05-04 14:06:13 +09001488 {"--structured"}));
1489 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1490}
1491
Jeongik Cha225519b2020-08-29 01:55:32 +09001492TEST_P(AidlTest, ExtensionTest) {
1493 CaptureStderr();
Jeongik Cha649e8a72020-03-27 17:47:40 +09001494 string extendable_parcelable =
1495 "package a; parcelable Data {\n"
1496 " ParcelableHolder extension;\n"
1497 " ParcelableHolder extension2;\n"
1498 "}";
Jeongik Cha8f02a532020-10-14 00:16:28 +09001499 if (GetLanguage() == Options::Language::RUST) {
Jeongik Cha225519b2020-08-29 01:55:32 +09001500 EXPECT_EQ(nullptr, Parse("a/Data.aidl", extendable_parcelable, typenames_, GetLanguage()));
1501 EXPECT_EQ(
Jeongik Cha8f02a532020-10-14 00:16:28 +09001502 "ERROR: a/Data.aidl:2.1-19: The Rust backend does not support ParcelableHolder "
Jeongik Cha225519b2020-08-29 01:55:32 +09001503 "yet.\n",
1504 GetCapturedStderr());
1505 } else {
1506 EXPECT_NE(nullptr, Parse("a/Data.aidl", extendable_parcelable, typenames_, GetLanguage()));
1507 EXPECT_EQ("", GetCapturedStderr());
1508 }
1509}
1510TEST_P(AidlTest, ParcelableHolderAsReturnType) {
1511 CaptureStderr();
Jeongik Cha649e8a72020-03-27 17:47:40 +09001512 string parcelableholder_return_interface =
1513 "package a; interface IFoo {\n"
1514 " ParcelableHolder foo();\n"
1515 "}";
Jeongik Cha225519b2020-08-29 01:55:32 +09001516 EXPECT_EQ(nullptr,
1517 Parse("a/IFoo.aidl", parcelableholder_return_interface, typenames_, GetLanguage()));
Jeongik Cha649e8a72020-03-27 17:47:40 +09001518
Jeongik Cha8f02a532020-10-14 00:16:28 +09001519 if (GetLanguage() == Options::Language::RUST) {
Jeongik Cha225519b2020-08-29 01:55:32 +09001520 EXPECT_EQ(
Steven Morelandebc3c5d2020-09-30 23:40:33 +00001521 "ERROR: a/IFoo.aidl:2.19-23: ParcelableHolder cannot be a return type\n"
Jeongik Cha8f02a532020-10-14 00:16:28 +09001522 "ERROR: a/IFoo.aidl:2.1-19: The Rust backend does not support ParcelableHolder "
Jeongik Cha225519b2020-08-29 01:55:32 +09001523 "yet.\n",
1524 GetCapturedStderr());
1525 return;
1526 }
1527 EXPECT_EQ("ERROR: a/IFoo.aidl:2.19-23: ParcelableHolder cannot be a return type\n",
1528 GetCapturedStderr());
1529}
1530
1531TEST_P(AidlTest, ParcelableHolderAsArgumentType) {
1532 CaptureStderr();
Jeongik Cha649e8a72020-03-27 17:47:40 +09001533 string extendable_parcelable_arg_interface =
1534 "package a; interface IFoo {\n"
1535 " void foo(in ParcelableHolder ph);\n"
1536 "}";
Jeongik Cha225519b2020-08-29 01:55:32 +09001537 EXPECT_EQ(nullptr,
1538 Parse("a/IFoo.aidl", extendable_parcelable_arg_interface, typenames_, GetLanguage()));
1539
Jeongik Cha8f02a532020-10-14 00:16:28 +09001540 if (GetLanguage() == Options::Language::RUST) {
Jeongik Cha225519b2020-08-29 01:55:32 +09001541 EXPECT_EQ(
Steven Morelandebc3c5d2020-09-30 23:40:33 +00001542 "ERROR: a/IFoo.aidl:2.31-34: ParcelableHolder cannot be an argument type\n"
Jeongik Cha8f02a532020-10-14 00:16:28 +09001543 "ERROR: a/IFoo.aidl:2.14-31: The Rust backend does not support ParcelableHolder "
Jeongik Cha225519b2020-08-29 01:55:32 +09001544 "yet.\n",
1545 GetCapturedStderr());
1546 return;
1547 }
1548 EXPECT_EQ("ERROR: a/IFoo.aidl:2.31-34: ParcelableHolder cannot be an argument type\n",
1549 GetCapturedStderr());
Jeongik Cha649e8a72020-03-27 17:47:40 +09001550}
1551
Jeongik Chaf6ec8982020-10-15 00:10:30 +09001552TEST_P(AidlTest, RejectNullableParcelableHolderField) {
1553 io_delegate_.SetFileContents("Foo.aidl", "parcelable Foo { @nullable ParcelableHolder ext; }");
Jooyung Han9435e9a2021-01-06 10:16:31 +09001554 Options options = Options::From("aidl Foo.aidl --lang=" + to_string(GetLanguage()));
Jeongik Chaf6ec8982020-10-15 00:10:30 +09001555 const string expected_stderr = "ERROR: Foo.aidl:1.27-44: ParcelableHolder cannot be nullable.\n";
1556 CaptureStderr();
1557 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
1558 if (GetLanguage() == Options::Language::RUST) {
1559 EXPECT_EQ(
1560 "ERROR: Foo.aidl:1.27-44: ParcelableHolder cannot be nullable.\n"
1561 "ERROR: Foo.aidl:1.27-44: The Rust backend does not support ParcelableHolder "
1562 "yet.\n",
1563 GetCapturedStderr());
1564 return;
1565 }
1566 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1567}
1568
Jooyung Han3f347ca2020-12-01 12:41:50 +09001569TEST_P(AidlTest, ParcelablesWithConstants) {
1570 io_delegate_.SetFileContents("Foo.aidl", "parcelable Foo { const int BIT = 0x1 << 3; }");
Jooyung Han9435e9a2021-01-06 10:16:31 +09001571 Options options = Options::From("aidl Foo.aidl --lang=" + to_string(GetLanguage()));
Jooyung Han3f347ca2020-12-01 12:41:50 +09001572 CaptureStderr();
1573 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1574 EXPECT_EQ("", GetCapturedStderr());
1575}
1576
1577TEST_P(AidlTest, UnionWithConstants) {
1578 io_delegate_.SetFileContents("Foo.aidl", "union Foo { const int BIT = 0x1 << 3; int n; }");
Jooyung Han9435e9a2021-01-06 10:16:31 +09001579 Options options = Options::From("aidl Foo.aidl --lang=" + to_string(GetLanguage()));
Jooyung Han3f347ca2020-12-01 12:41:50 +09001580 CaptureStderr();
1581 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1582 EXPECT_EQ("", GetCapturedStderr());
1583}
1584
Jooyung Han633eab62021-01-07 14:12:40 +09001585TEST_F(AidlTest, ConstantsWithAnnotations) {
1586 io_delegate_.SetFileContents("IFoo.aidl",
1587 "interface IFoo {\n"
1588 " @JavaPassthrough(annotation=\"@Foo\")\n"
1589 " const @JavaPassthrough(annotation=\"@Bar\") int FOO = 0;\n"
1590 "}");
1591 Options options = Options::From("aidl IFoo.aidl --lang=java -o out");
1592 CaptureStderr();
1593 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1594 EXPECT_EQ("", GetCapturedStderr());
1595 string code;
1596 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/IFoo.java", &code));
1597 EXPECT_THAT(code, HasSubstr("@Foo\n"));
1598 EXPECT_THAT(code, HasSubstr("@Bar\n"));
1599}
1600
Jiyong Park02da7422018-07-16 16:00:26 +09001601TEST_F(AidlTest, ApiDump) {
1602 io_delegate_.SetFileContents(
1603 "foo/bar/IFoo.aidl",
1604 "package foo.bar;\n"
1605 "import foo.bar.Data;\n"
Jooyung Han24effbf2021-01-16 10:24:03 +09001606 "// commented /* @hide */\n"
Jiyong Park02da7422018-07-16 16:00:26 +09001607 "interface IFoo {\n"
Jooyung Han161bb0f2021-01-21 12:30:16 +09001608 " /* @hide applied \n"
1609 " @deprecated use foo2 */\n"
1610 " int foo(out int[] a, String b, boolean c, inout List<String> d);\n"
1611 " int foo2(@utf8InCpp String x, inout List<String> y);\n"
Jiyong Park02da7422018-07-16 16:00:26 +09001612 " IFoo foo3(IFoo foo);\n"
1613 " Data getData();\n"
Jooyung Han161bb0f2021-01-21 12:30:16 +09001614 " // @hide not applied\n"
Jooyung Han9fd67022021-01-13 10:49:48 +09001615 " /** blahblah\n"
1616 " @deprecated\n"
1617 " reason why... */\n"
Jiyong Parka428d212018-08-29 22:26:30 +09001618 " const int A = 1;\n"
Jooyung Han24effbf2021-01-16 10:24:03 +09001619 " // @deprecated tags in line comments are ignored\n"
Jiyong Parka428d212018-08-29 22:26:30 +09001620 " const String STR = \"Hello\";\n"
Jiyong Park02da7422018-07-16 16:00:26 +09001621 "}\n");
1622 io_delegate_.SetFileContents("foo/bar/Data.aidl",
1623 "package foo.bar;\n"
1624 "import foo.bar.IFoo;\n"
Jeongik Cha997281d2020-01-16 15:23:59 +09001625 "/* @hide*/\n"
Jiyong Park02da7422018-07-16 16:00:26 +09001626 "parcelable Data {\n"
Jeongik Cha997281d2020-01-16 15:23:59 +09001627 " // @hide\n"
Jiyong Parka468e2a2018-08-29 21:25:18 +09001628 " int x = 10;\n"
Jeongik Cha997281d2020-01-16 15:23:59 +09001629 " // @hide\n"
Jiyong Park02da7422018-07-16 16:00:26 +09001630 " int y;\n"
Jeongik Cha997281d2020-01-16 15:23:59 +09001631 " /*@hide2*/\n"
Jooyung Han55f96ad2020-12-13 10:08:33 +09001632 " IFoo foo;\n"
Jooyung Han24effbf2021-01-16 10:24:03 +09001633 " // Ignore @hide property in line comment\n"
Jeongik Cha3271ffa2018-12-04 15:19:20 +09001634 " @nullable String[] c;\n"
Jiyong Park02da7422018-07-16 16:00:26 +09001635 "}\n");
1636 io_delegate_.SetFileContents("api.aidl", "");
Jiyong Park633246c2019-11-25 10:50:05 +09001637 vector<string> args = {"aidl", "--dumpapi", "--out=dump", "--include=.",
1638 "foo/bar/IFoo.aidl", "foo/bar/Data.aidl"};
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001639 Options options = Options::From(args);
Jiyong Park02da7422018-07-16 16:00:26 +09001640 bool result = dump_api(options, io_delegate_);
1641 ASSERT_TRUE(result);
1642 string actual;
Jiyong Parke59c3682018-09-11 23:10:25 +09001643 EXPECT_TRUE(io_delegate_.GetWrittenContents("dump/foo/bar/IFoo.aidl", &actual));
Jooyung Han161bb0f2021-01-21 12:30:16 +09001644 EXPECT_EQ(string(kPreamble).append(R"(package foo.bar;
Jiyong Parke59c3682018-09-11 23:10:25 +09001645interface IFoo {
Jooyung Han161bb0f2021-01-21 12:30:16 +09001646 /**
1647 * @hide
1648 * @deprecated use foo2
1649 */
Jiyong Parke59c3682018-09-11 23:10:25 +09001650 int foo(out int[] a, String b, boolean c, inout List<String> d);
1651 int foo2(@utf8InCpp String x, inout List<String> y);
1652 foo.bar.IFoo foo3(foo.bar.IFoo foo);
1653 foo.bar.Data getData();
Jooyung Han161bb0f2021-01-21 12:30:16 +09001654 /**
1655 * @deprecated reason why...
1656 */
Jiyong Parke59c3682018-09-11 23:10:25 +09001657 const int A = 1;
1658 const String STR = "Hello";
1659}
Jooyung Han161bb0f2021-01-21 12:30:16 +09001660)"),
1661 actual);
Jiyong Park02da7422018-07-16 16:00:26 +09001662
Jiyong Parke59c3682018-09-11 23:10:25 +09001663 EXPECT_TRUE(io_delegate_.GetWrittenContents("dump/foo/bar/Data.aidl", &actual));
Jooyung Han161bb0f2021-01-21 12:30:16 +09001664 EXPECT_EQ(string(kPreamble).append(R"(package foo.bar;
Jooyung Han8db65942021-03-02 18:14:44 +09001665/* @hide */
Jiyong Parke59c3682018-09-11 23:10:25 +09001666parcelable Data {
1667 int x = 10;
1668 int y;
1669 foo.bar.IFoo foo;
Jeongik Cha3271ffa2018-12-04 15:19:20 +09001670 @nullable String[] c;
Jiyong Park02da7422018-07-16 16:00:26 +09001671}
Jooyung Han161bb0f2021-01-21 12:30:16 +09001672)"),
1673 actual);
Jiyong Park02da7422018-07-16 16:00:26 +09001674}
1675
Jiyong Parked65bf42018-08-28 15:43:27 +09001676TEST_F(AidlTest, ApiDumpWithManualIds) {
1677 io_delegate_.SetFileContents(
1678 "foo/bar/IFoo.aidl",
1679 "package foo.bar;\n"
1680 "interface IFoo {\n"
1681 " int foo() = 1;\n"
1682 " int bar() = 2;\n"
1683 " int baz() = 10;\n"
1684 "}\n");
1685
Jiyong Parke59c3682018-09-11 23:10:25 +09001686 vector<string> args = {"aidl", "--dumpapi", "-o dump", "foo/bar/IFoo.aidl"};
Jiyong Parked65bf42018-08-28 15:43:27 +09001687 Options options = Options::From(args);
1688 bool result = dump_api(options, io_delegate_);
1689 ASSERT_TRUE(result);
1690 string actual;
Jiyong Parke59c3682018-09-11 23:10:25 +09001691 EXPECT_TRUE(io_delegate_.GetWrittenContents("dump/foo/bar/IFoo.aidl", &actual));
Paul Trautrimb01451d2020-02-27 13:10:16 +09001692 EXPECT_EQ(actual, string(kPreamble).append(R"(package foo.bar;
Jiyong Parke59c3682018-09-11 23:10:25 +09001693interface IFoo {
1694 int foo() = 1;
1695 int bar() = 2;
1696 int baz() = 10;
Jiyong Parked65bf42018-08-28 15:43:27 +09001697}
Paul Trautrimb01451d2020-02-27 13:10:16 +09001698)"));
Jiyong Parked65bf42018-08-28 15:43:27 +09001699}
1700
1701TEST_F(AidlTest, ApiDumpWithManualIdsOnlyOnSomeMethods) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001702 const string expected_stderr =
1703 "ERROR: foo/bar/IFoo.aidl:4.8-12: You must either assign id's to all methods or to none of "
1704 "them.\n";
Jiyong Parked65bf42018-08-28 15:43:27 +09001705 io_delegate_.SetFileContents(
1706 "foo/bar/IFoo.aidl",
1707 "package foo.bar;\n"
1708 "interface IFoo {\n"
1709 " int foo() = 1;\n"
1710 " int bar();\n"
1711 " int baz() = 10;\n"
1712 "}\n");
1713
Jiyong Parke59c3682018-09-11 23:10:25 +09001714 vector<string> args = {"aidl", "--dumpapi", "-o dump", "foo/bar/IFoo.aidl"};
Jiyong Parked65bf42018-08-28 15:43:27 +09001715 Options options = Options::From(args);
Devin Moore097a3ab2020-03-11 16:08:44 -07001716 CaptureStderr();
Jiyong Parked65bf42018-08-28 15:43:27 +09001717 EXPECT_FALSE(dump_api(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001718 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Parked65bf42018-08-28 15:43:27 +09001719}
1720
Jooyung Han965e31d2020-11-27 12:30:16 +09001721TEST_F(AidlTest, ApiDumpConstWithAnnotation) {
1722 io_delegate_.SetFileContents("foo/bar/IFoo.aidl",
1723 "package foo.bar;\n"
1724 "interface IFoo {\n"
1725 " @utf8InCpp String foo();\n"
1726 " const @utf8InCpp String bar = \"bar\";\n"
1727 "}\n");
1728
1729 vector<string> args = {"aidl", "--dumpapi", "-o dump", "foo/bar/IFoo.aidl"};
1730 Options options = Options::From(args);
1731 CaptureStderr();
1732 EXPECT_TRUE(dump_api(options, io_delegate_));
1733 EXPECT_EQ("", GetCapturedStderr());
1734 string actual;
1735 EXPECT_TRUE(io_delegate_.GetWrittenContents("dump/foo/bar/IFoo.aidl", &actual));
Jooyung Han965e31d2020-11-27 12:30:16 +09001736 EXPECT_EQ(string(kPreamble).append(R"(package foo.bar;
1737interface IFoo {
1738 @utf8InCpp String foo();
Jooyung Hanb3ca6302020-11-27 14:13:27 +09001739 const @utf8InCpp String bar = "bar";
Jooyung Han965e31d2020-11-27 12:30:16 +09001740}
1741)"),
1742 actual);
1743}
1744
Jooyung Hanfdaae1d2020-12-14 13:16:15 +09001745TEST_F(AidlTest, ApiDumpWithEnums) {
1746 io_delegate_.SetFileContents("foo/bar/Enum.aidl",
1747 "package foo.bar;\n"
1748 "enum Enum {\n"
1749 " FOO,\n"
1750 " BAR = FOO + 1,\n"
1751 "}\n");
1752
1753 vector<string> args = {"aidl", "--dumpapi", "-I . ", "-o dump", "foo/bar/Enum.aidl"};
1754 Options options = Options::From(args);
1755 CaptureStderr();
1756 EXPECT_TRUE(dump_api(options, io_delegate_));
1757 EXPECT_EQ("", GetCapturedStderr());
1758 string actual;
1759 EXPECT_TRUE(io_delegate_.GetWrittenContents("dump/foo/bar/Enum.aidl", &actual));
1760 EXPECT_EQ(string(kPreamble).append("package foo.bar;\n"
1761 "enum Enum {\n"
1762 " FOO = 0,\n"
1763 " BAR = 1,\n"
1764 "}\n"),
1765 actual);
1766}
1767
1768TEST_F(AidlTest, ApiDumpWithEnumDefaultValues) {
1769 io_delegate_.SetFileContents("foo/bar/Enum.aidl",
1770 "package foo.bar;\n"
1771 "enum Enum {\n"
1772 " FOO,\n"
1773 "}\n");
1774 io_delegate_.SetFileContents("foo/bar/Foo.aidl",
1775 "package foo.bar;\n"
1776 "import foo.bar.Enum;\n"
1777 "parcelable Foo {\n"
1778 " Enum e = Enum.FOO;\n"
1779 "}\n");
1780
1781 vector<string> args = {"aidl", "--dumpapi", "-I . ", "-o dump", "foo/bar/Foo.aidl"};
1782 Options options = Options::From(args);
1783 CaptureStderr();
1784 EXPECT_TRUE(dump_api(options, io_delegate_));
1785 EXPECT_EQ("", GetCapturedStderr());
1786 string actual;
1787 EXPECT_TRUE(io_delegate_.GetWrittenContents("dump/foo/bar/Foo.aidl", &actual));
1788 EXPECT_EQ(string(kPreamble).append("package foo.bar;\n"
1789 "parcelable Foo {\n"
1790 " foo.bar.Enum e = foo.bar.Enum.FOO;\n"
1791 "}\n"),
1792 actual);
1793}
1794
Jooyung Han71dfec32021-05-23 07:18:58 +09001795TEST_F(AidlTest, ApiDumpWithGenerics) {
1796 io_delegate_.SetFileContents("foo/bar/Foo.aidl",
1797 "package foo.bar;\n"
1798 "parcelable Foo<T, U> {\n"
1799 "}\n");
1800
1801 vector<string> args = {"aidl", "--dumpapi", "-I . ", "-o dump", "foo/bar/Foo.aidl"};
1802 Options options = Options::From(args);
1803 CaptureStderr();
1804 EXPECT_TRUE(dump_api(options, io_delegate_));
1805 EXPECT_EQ("", GetCapturedStderr());
1806 string actual;
1807 EXPECT_TRUE(io_delegate_.GetWrittenContents("dump/foo/bar/Foo.aidl", &actual));
1808 EXPECT_EQ(string(kPreamble).append("package foo.bar;\n"
1809 "parcelable Foo<T, U> {\n"
1810 "}\n"),
1811 actual);
1812}
1813
Jiyong Park1d2df7d2018-07-23 15:22:50 +09001814TEST_F(AidlTest, CheckNumGenericTypeSecifier) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001815 const string expected_list_stderr =
Steven Morelandebc3c5d2020-09-30 23:40:33 +00001816 "ERROR: p/IFoo.aidl:1.37-41: List can only have one type parameter, but got: "
1817 "'List<String,String>'\n";
Devin Moore097a3ab2020-03-11 16:08:44 -07001818 const string expected_map_stderr =
1819 "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 +09001820 Options options = Options::From("aidl p/IFoo.aidl IFoo.java");
1821 io_delegate_.SetFileContents(options.InputFiles().front(),
Jiyong Park1d2df7d2018-07-23 15:22:50 +09001822 "package p; interface IFoo {"
1823 "void foo(List<String, String> a);}");
Devin Moore097a3ab2020-03-11 16:08:44 -07001824 CaptureStderr();
Jiyong Parkb034bf02018-07-30 17:44:33 +09001825 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001826 EXPECT_EQ(expected_list_stderr, GetCapturedStderr());
Jiyong Park1d2df7d2018-07-23 15:22:50 +09001827
Jiyong Park6f77e0c2018-07-28 16:55:44 +09001828 io_delegate_.SetFileContents(options.InputFiles().front(),
Jiyong Park1d2df7d2018-07-23 15:22:50 +09001829 "package p; interface IFoo {"
1830 "void foo(Map<String> a);}");
Devin Moore097a3ab2020-03-11 16:08:44 -07001831 CaptureStderr();
Jiyong Parkb034bf02018-07-30 17:44:33 +09001832 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001833 EXPECT_EQ(expected_map_stderr, GetCapturedStderr());
Jiyong Parkb034bf02018-07-30 17:44:33 +09001834}
1835
Jeongik Chae48d9942020-01-02 17:39:00 +09001836TEST_F(AidlTest, CheckTypeParameterInMapType) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001837 const string expected_stderr =
1838 "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 +09001839 Options options = Options::From("aidl -I . p/IFoo.aidl");
Jeongik Chae48d9942020-01-02 17:39:00 +09001840 io_delegate_.SetFileContents("p/Bar.aidl", "package p; parcelable Bar { String s; }");
1841
1842 io_delegate_.SetFileContents("p/IFoo.aidl",
1843 "package p; interface IFoo {"
Jooyung Han13f1fa52021-06-11 18:06:12 +09001844 "Map<String, p.Bar> foo();}");
Jeongik Chae48d9942020-01-02 17:39:00 +09001845 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1846
1847 io_delegate_.SetFileContents("p/IFoo.aidl",
1848 "package p; interface IFoo {"
Jooyung Han13f1fa52021-06-11 18:06:12 +09001849 "Map<p.Bar, p.Bar> foo();}");
Devin Moore097a3ab2020-03-11 16:08:44 -07001850 CaptureStderr();
Jeongik Chae48d9942020-01-02 17:39:00 +09001851 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001852 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jeongik Chae48d9942020-01-02 17:39:00 +09001853
1854 io_delegate_.SetFileContents("p/IFoo.aidl",
1855 "package p; interface IFoo {"
1856 "Map<String, String> foo();}");
1857 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1858
1859 io_delegate_.SetFileContents("p/IFoo.aidl",
1860 "package p; interface IFoo {"
1861 "Map<String, ParcelFileDescriptor> foo();}");
1862 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1863}
1864
Jeongik Chadf76dc72019-11-28 00:08:47 +09001865TEST_F(AidlTest, WrongGenericType) {
Devin Moore097a3ab2020-03-11 16:08:44 -07001866 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 +09001867 Options options = Options::From("aidl p/IFoo.aidl IFoo.java");
1868 io_delegate_.SetFileContents(options.InputFiles().front(),
1869 "package p; interface IFoo {"
1870 "String<String> foo(); }");
Devin Moore097a3ab2020-03-11 16:08:44 -07001871 CaptureStderr();
Jeongik Chadf76dc72019-11-28 00:08:47 +09001872 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001873 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jeongik Chadf76dc72019-11-28 00:08:47 +09001874}
1875
1876TEST_F(AidlTest, UserDefinedUnstructuredGenericParcelableType) {
Jooyung Han13f1fa52021-06-11 18:06:12 +09001877 Options optionsForParcelable = Options::From("aidl -I . p/Bar.aidl");
Jeongik Chadf76dc72019-11-28 00:08:47 +09001878 io_delegate_.SetFileContents("p/Bar.aidl", "package p; parcelable Bar<T, T>;");
Devin Moore097a3ab2020-03-11 16:08:44 -07001879 CaptureStderr();
Jeongik Chadf76dc72019-11-28 00:08:47 +09001880 EXPECT_NE(0, ::android::aidl::compile_aidl(optionsForParcelable, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001881 EXPECT_EQ("ERROR: p/Bar.aidl:1.22-26: Every type parameter should be unique.\n",
1882 GetCapturedStderr());
Jeongik Chadf76dc72019-11-28 00:08:47 +09001883
Jooyung Han13f1fa52021-06-11 18:06:12 +09001884 Options options = Options::From("aidl -I . p/IFoo.aidl");
Jeongik Chadf76dc72019-11-28 00:08:47 +09001885 io_delegate_.SetFileContents("p/Bar.aidl", "package p; parcelable Bar;");
1886 io_delegate_.SetFileContents("p/IFoo.aidl",
1887 "package p; interface IFoo {"
Jooyung Han13f1fa52021-06-11 18:06:12 +09001888 "p.Bar<String, String> foo();}");
Devin Moore097a3ab2020-03-11 16:08:44 -07001889 CaptureStderr();
Jeongik Chadf76dc72019-11-28 00:08:47 +09001890 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jooyung Han13f1fa52021-06-11 18:06:12 +09001891 EXPECT_THAT(GetCapturedStderr(), HasSubstr("p.Bar is not a generic type"));
Jeongik Chadf76dc72019-11-28 00:08:47 +09001892 io_delegate_.SetFileContents("p/Bar.aidl", "package p; parcelable Bar<T>;");
Devin Moore097a3ab2020-03-11 16:08:44 -07001893 CaptureStderr();
Jeongik Chadf76dc72019-11-28 00:08:47 +09001894 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jooyung Han13f1fa52021-06-11 18:06:12 +09001895 EXPECT_THAT(GetCapturedStderr(), HasSubstr("p.Bar must have 1 type parameters, but got 2"));
Jeongik Chadf76dc72019-11-28 00:08:47 +09001896 io_delegate_.SetFileContents("p/Bar.aidl", "package p; parcelable Bar<T, V>;");
1897 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1898 io_delegate_.SetFileContents("p/IFoo.aidl",
1899 "package p; interface IFoo {"
Jooyung Han13f1fa52021-06-11 18:06:12 +09001900 "p.Bar<String, ParcelFileDescriptor> foo();}");
Jeongik Chadf76dc72019-11-28 00:08:47 +09001901 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jeongik Chae74c86d2019-12-12 16:54:03 +09001902
1903 io_delegate_.SetFileContents("p/IFoo.aidl",
1904 "package p; interface IFoo {"
Jooyung Han13f1fa52021-06-11 18:06:12 +09001905 "p.Bar<int, long> foo();}");
Jeongik Chae74c86d2019-12-12 16:54:03 +09001906
1907 io_delegate_.SetFileContents("p/IFoo.aidl",
1908 "package p; interface IFoo {"
Jooyung Han13f1fa52021-06-11 18:06:12 +09001909 "p.Bar<int[], long[]> foo();}");
Jeongik Chae74c86d2019-12-12 16:54:03 +09001910
1911 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jeongik Chadf76dc72019-11-28 00:08:47 +09001912}
1913
Jeongik Cha0e426012019-07-29 15:57:02 +09001914TEST_F(AidlTest, FailOnMultipleTypesInSingleFile) {
1915 std::vector<std::string> rawOptions{"aidl --lang=java -o out foo/bar/Foo.aidl",
Andrei Homescub62afd92020-05-11 19:24:59 -07001916 "aidl --lang=cpp -o out -h out/include foo/bar/Foo.aidl",
1917 "aidl --lang=rust -o out foo/bar/Foo.aidl"};
Devin Moore5de18ed2020-04-02 13:52:29 -07001918 for (const auto& rawOption : rawOptions) {
1919 string expected_stderr =
1920 "ERROR: foo/bar/Foo.aidl:3.1-10: You must declare only one type per file.\n";
Jeongik Cha0e426012019-07-29 15:57:02 +09001921 Options options = Options::From(rawOption);
1922 io_delegate_.SetFileContents(options.InputFiles().front(),
1923 "package foo.bar;\n"
1924 "interface IFoo1 { int foo(); }\n"
1925 "interface IFoo2 { int foo(); }\n"
1926 "parcelable Data1 { int a; int b;}\n"
1927 "parcelable Data2 { int a; int b;}\n");
Devin Moore097a3ab2020-03-11 16:08:44 -07001928 CaptureStderr();
Jeongik Cha0e426012019-07-29 15:57:02 +09001929 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001930 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Parkb034bf02018-07-30 17:44:33 +09001931
Jeongik Cha0e426012019-07-29 15:57:02 +09001932 io_delegate_.SetFileContents(options.InputFiles().front(),
1933 "package foo.bar;\n"
1934 "interface IFoo1 { int foo(); }\n"
1935 "interface IFoo2 { int foo(); }\n");
Devin Moore097a3ab2020-03-11 16:08:44 -07001936 CaptureStderr();
Jeongik Cha0e426012019-07-29 15:57:02 +09001937 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001938 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Parkb034bf02018-07-30 17:44:33 +09001939
Devin Moore5de18ed2020-04-02 13:52:29 -07001940 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 +09001941 io_delegate_.SetFileContents(options.InputFiles().front(),
1942 "package foo.bar;\n"
1943 "parcelable Data1 { int a; int b;}\n"
1944 "parcelable Data2 { int a; int b;}\n");
Devin Moore097a3ab2020-03-11 16:08:44 -07001945 CaptureStderr();
Jeongik Cha0e426012019-07-29 15:57:02 +09001946 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07001947 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Parkb034bf02018-07-30 17:44:33 +09001948 }
1949}
1950
Devin Moorebdba2a82020-03-31 15:19:02 -07001951TEST_P(AidlTest, FailParseOnEmptyFile) {
1952 const string contents = "";
1953 const string expected_stderr = "ERROR: a/IFoo.aidl:1.1-1: syntax error, unexpected $end\n";
1954 CaptureStderr();
1955 EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", contents, typenames_, GetLanguage()));
1956 EXPECT_EQ(expected_stderr, GetCapturedStderr());
1957}
1958
Jiyong Parkb034bf02018-07-30 17:44:33 +09001959TEST_F(AidlTest, MultipleInputFiles) {
1960 Options options = Options::From(
Jiyong Park633246c2019-11-25 10:50:05 +09001961 "aidl --lang=java -o out -I . foo/bar/IFoo.aidl foo/bar/Data.aidl");
Jiyong Parkb034bf02018-07-30 17:44:33 +09001962
1963 io_delegate_.SetFileContents(options.InputFiles().at(0),
1964 "package foo.bar;\n"
1965 "import foo.bar.Data;\n"
1966 "interface IFoo { Data getData(); }\n");
1967
1968 io_delegate_.SetFileContents(options.InputFiles().at(1),
1969 "package foo.bar;\n"
1970 "import foo.bar.IFoo;\n"
1971 "parcelable Data { IFoo foo; }\n");
1972
1973 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1974
1975 string content;
1976 for (const auto file : {
1977 "out/foo/bar/IFoo.java", "out/foo/bar/Data.java"}) {
1978 content.clear();
1979 EXPECT_TRUE(io_delegate_.GetWrittenContents(file, &content));
1980 EXPECT_FALSE(content.empty());
1981 }
1982}
1983
1984TEST_F(AidlTest, MultipleInputFilesCpp) {
1985 Options options = Options::From("aidl --lang=cpp -o out -h out/include "
Jiyong Park633246c2019-11-25 10:50:05 +09001986 "-I . foo/bar/IFoo.aidl foo/bar/Data.aidl");
Jiyong Parkb034bf02018-07-30 17:44:33 +09001987
1988 io_delegate_.SetFileContents(options.InputFiles().at(0),
1989 "package foo.bar;\n"
1990 "import foo.bar.Data;\n"
1991 "interface IFoo { Data getData(); }\n");
1992
1993 io_delegate_.SetFileContents(options.InputFiles().at(1),
1994 "package foo.bar;\n"
1995 "import foo.bar.IFoo;\n"
1996 "parcelable Data { IFoo foo; }\n");
1997
1998 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
1999
2000 string content;
2001 for (const auto file : {
Jiyong Parkb03551f2018-08-06 19:20:51 +09002002 "out/foo/bar/IFoo.cpp", "out/foo/bar/Data.cpp",
Jiyong Parkb034bf02018-07-30 17:44:33 +09002003 "out/include/foo/bar/IFoo.h", "out/include/foo/bar/Data.h",
2004 "out/include/foo/bar/BpFoo.h", "out/include/foo/bar/BpData.h",
2005 "out/include/foo/bar/BnFoo.h", "out/include/foo/bar/BnData.h"}) {
2006 content.clear();
2007 EXPECT_TRUE(io_delegate_.GetWrittenContents(file, &content));
2008 EXPECT_FALSE(content.empty());
2009 }
Jiyong Park1d2df7d2018-07-23 15:22:50 +09002010}
2011
Andrei Homescub62afd92020-05-11 19:24:59 -07002012TEST_F(AidlTest, MultipleInputFilesRust) {
2013 Options options =
2014 Options::From("aidl --lang=rust -o out -I . foo/bar/IFoo.aidl foo/bar/Data.aidl");
2015
2016 io_delegate_.SetFileContents(options.InputFiles().at(0),
2017 "package foo.bar;\n"
2018 "import foo.bar.Data;\n"
2019 "interface IFoo { Data getData(); }\n");
2020
2021 io_delegate_.SetFileContents(options.InputFiles().at(1),
2022 "package foo.bar;\n"
2023 "import foo.bar.IFoo;\n"
2024 "parcelable Data { IFoo foo; }\n");
2025
2026 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
2027
2028 string content;
2029 for (const auto file : {"out/foo/bar/IFoo.rs", "out/foo/bar/Data.rs"}) {
2030 content.clear();
2031 EXPECT_TRUE(io_delegate_.GetWrittenContents(file, &content));
2032 EXPECT_FALSE(content.empty());
2033 }
2034}
2035
Devin Moore097a3ab2020-03-11 16:08:44 -07002036TEST_F(AidlTest, ConflictWithMetaTransactionGetVersion) {
2037 const string expected_stderr =
2038 "ERROR: p/IFoo.aidl:1.31-51: method getInterfaceVersion() is reserved for internal use.\n";
Jiyong Park309668e2018-07-28 16:55:44 +09002039 Options options = Options::From("aidl --lang=java -o place/for/output p/IFoo.aidl");
2040 // int getInterfaceVersion() is one of the meta transactions
2041 io_delegate_.SetFileContents(options.InputFiles().front(),
2042 "package p; interface IFoo {"
2043 "int getInterfaceVersion(); }");
Devin Moore097a3ab2020-03-11 16:08:44 -07002044 CaptureStderr();
Jiyong Parkb034bf02018-07-30 17:44:33 +09002045 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002046 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2047}
Jiyong Park309668e2018-07-28 16:55:44 +09002048
Devin Moore097a3ab2020-03-11 16:08:44 -07002049TEST_F(AidlTest, ConflictWithSimilarMetaTransaction) {
2050 // boolean getInterfaceVersion() is not a meta transaction, but should be
2051 // prevented because return type is not part of a method signature
2052 const string expected_stderr =
2053 "ERROR: p/IFoo.aidl:1.35-55: method getInterfaceVersion() is reserved for internal use.\n";
2054 Options options = Options::From("aidl --lang=java -o place/for/output p/IFoo.aidl");
Jiyong Park309668e2018-07-28 16:55:44 +09002055 io_delegate_.SetFileContents(options.InputFiles().front(),
2056 "package p; interface IFoo {"
2057 "boolean getInterfaceVersion(); }");
Devin Moore097a3ab2020-03-11 16:08:44 -07002058 CaptureStderr();
Jiyong Parkb034bf02018-07-30 17:44:33 +09002059 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002060 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2061}
Jiyong Park309668e2018-07-28 16:55:44 +09002062
Devin Moore097a3ab2020-03-11 16:08:44 -07002063TEST_F(AidlTest, ConflictWithMetaTransactionGetName) {
Jiyong Park309668e2018-07-28 16:55:44 +09002064 // this is another reserved name
Devin Moore097a3ab2020-03-11 16:08:44 -07002065 const string expected_stderr =
2066 "ERROR: p/IFoo.aidl:1.34-53: method getTransactionName(int) is reserved for internal use.\n";
2067 Options options = Options::From("aidl --lang=java -o place/for/output p/IFoo.aidl");
Jiyong Park309668e2018-07-28 16:55:44 +09002068 io_delegate_.SetFileContents(options.InputFiles().front(),
2069 "package p; interface IFoo {"
2070 "String getTransactionName(int code); }");
Devin Moore097a3ab2020-03-11 16:08:44 -07002071 CaptureStderr();
Jiyong Parkb034bf02018-07-30 17:44:33 +09002072 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002073 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Park309668e2018-07-28 16:55:44 +09002074
2075 // this is not a meta interface method as it differs type arguments
2076 io_delegate_.SetFileContents(options.InputFiles().front(),
2077 "package p; interface IFoo {"
2078 "String getTransactionName(); }");
Jiyong Parkb034bf02018-07-30 17:44:33 +09002079 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jiyong Park309668e2018-07-28 16:55:44 +09002080}
2081
Jooyung Hanb8a97772021-01-19 01:27:38 +09002082TEST_F(AidlTest, CheckApiForEquality) {
2083 CaptureStderr();
2084 Options options = Options::From("aidl --checkapi=equal old new");
2085
2086 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2087 "package p; interface IFoo{ @utf8InCpp @nullable String foo();}");
2088 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2089 "package p; interface IFoo{ @utf8InCpp String foo();}");
2090
2091 EXPECT_FALSE(::android::aidl::check_api(options, io_delegate_));
2092 EXPECT_THAT(GetCapturedStderr(), HasSubstr("+ @utf8InCpp String foo();"));
2093}
2094
Daniel Norman85aed542019-08-21 12:01:14 -07002095TEST_F(AidlTest, DifferentOrderAnnotationsInCheckAPI) {
Jeongik Cha3271ffa2018-12-04 15:19:20 +09002096 Options options = Options::From("aidl --checkapi old new");
2097 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2098 "package p; interface IFoo{ @utf8InCpp @nullable String foo();}");
2099 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2100 "package p; interface IFoo{ @nullable @utf8InCpp String foo();}");
2101
2102 EXPECT_TRUE(::android::aidl::check_api(options, io_delegate_));
2103}
2104
Jiyong Park3656c3c2018-08-01 20:02:01 +09002105TEST_F(AidlTest, SuccessOnIdenticalApiDumps) {
Jiyong Parke59c3682018-09-11 23:10:25 +09002106 Options options = Options::From("aidl --checkapi old new");
2107 io_delegate_.SetFileContents("old/p/IFoo.aidl", "package p; interface IFoo{ void foo();}");
2108 io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p; interface IFoo{ void foo();}");
Jiyong Park3656c3c2018-08-01 20:02:01 +09002109
2110 EXPECT_TRUE(::android::aidl::check_api(options, io_delegate_));
2111}
2112
Jooyung Hanfdaae1d2020-12-14 13:16:15 +09002113TEST_F(AidlTest, CheckApi_EnumFieldsWithDefaultValues) {
2114 Options options = Options::From("aidl --checkapi old new");
2115 const string foo_definition = "package p; parcelable Foo{ p.Enum e = p.Enum.FOO; }";
2116 const string enum_definition = "package p; enum Enum { FOO }";
2117 io_delegate_.SetFileContents("old/p/Foo.aidl", foo_definition);
2118 io_delegate_.SetFileContents("old/p/Enum.aidl", enum_definition);
2119 io_delegate_.SetFileContents("new/p/Foo.aidl", foo_definition);
2120 io_delegate_.SetFileContents("new/p/Enum.aidl", enum_definition);
2121
2122 EXPECT_TRUE(::android::aidl::check_api(options, io_delegate_));
2123}
2124
Jooyung Han8e3b72c2021-05-22 02:54:37 +09002125TEST_F(AidlTest, CheckApi_EnumFieldsFromImported) {
2126 Options options = Options::From("aidl --checkapi old new -I import");
2127
2128 io_delegate_.SetFileContents("old/p/Foo.aidl", "package p; parcelable Foo{ other.Enum e; }");
2129 io_delegate_.SetFileContents("new/p/Foo.aidl",
2130 "package p; parcelable Foo{ other.Enum e = other.Enum.FOO; }");
2131 io_delegate_.SetFileContents("import/other/Enum.aidl", "package other; enum Enum { FOO }");
2132
2133 EXPECT_TRUE(::android::aidl::check_api(options, io_delegate_));
2134}
2135
Jooyung Han02a11be2021-02-11 13:18:06 +09002136TEST_F(AidlTest, CheckApiEqual_EnumFieldsWithDefaultValues) {
2137 Options options = Options::From("aidl --checkapi=equal old new");
2138 const string foo_definition = "package p; parcelable Foo{ p.Enum e = p.Enum.FOO; }";
2139 const string enum_definition = "package p; enum Enum { FOO }";
2140 io_delegate_.SetFileContents("old/p/Foo.aidl", foo_definition);
2141 io_delegate_.SetFileContents("old/p/Enum.aidl", enum_definition);
2142 io_delegate_.SetFileContents("new/p/Foo.aidl", foo_definition);
2143 io_delegate_.SetFileContents("new/p/Enum.aidl", enum_definition);
2144 CaptureStderr();
2145 EXPECT_TRUE(::android::aidl::check_api(options, io_delegate_));
2146 EXPECT_EQ("", GetCapturedStderr());
2147}
2148
Daniel Norman85aed542019-08-21 12:01:14 -07002149class AidlTestCompatibleChanges : public AidlTest {
2150 protected:
2151 Options options_ = Options::From("aidl --checkapi old new");
2152};
2153
2154TEST_F(AidlTestCompatibleChanges, NewType) {
2155 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2156 "package p;"
2157 "interface IFoo {"
2158 " void foo(int a);"
2159 "}");
2160 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2161 "package p;"
2162 "interface IFoo {"
2163 " void foo(int a);"
2164 "}");
2165 io_delegate_.SetFileContents("new/p/IBar.aidl",
2166 "package p;"
2167 "interface IBar {"
2168 " void bar();"
2169 "}");
2170 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2171}
2172
2173TEST_F(AidlTestCompatibleChanges, NewMethod) {
2174 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2175 "package p;"
2176 "interface IFoo {"
2177 " void foo(int a);"
2178 "}");
2179 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2180 "package p;"
2181 "interface IFoo {"
2182 " void foo(int a);"
2183 " void bar();"
Jooyung Han8e3b72c2021-05-22 02:54:37 +09002184 " void baz(in List<String> arg);"
Daniel Norman85aed542019-08-21 12:01:14 -07002185 "}");
2186 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2187}
2188
2189TEST_F(AidlTestCompatibleChanges, NewField) {
2190 io_delegate_.SetFileContents("old/p/Data.aidl",
2191 "package p;"
2192 "parcelable Data {"
2193 " int foo;"
2194 "}");
2195 io_delegate_.SetFileContents("new/p/Data.aidl",
2196 "package p;"
2197 "parcelable Data {"
2198 " int foo;"
Steven Moreland370ed342020-04-28 18:14:39 -07002199 " int bar = 0;"
Jiyong Parkf8d53612020-05-04 14:06:13 +09002200 " @nullable List<Data> list;"
Daniel Norman85aed542019-08-21 12:01:14 -07002201 "}");
2202 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2203}
2204
Jooyung Han05bd8a82021-04-28 23:56:38 +09002205TEST_F(AidlTestCompatibleChanges, NewField2) {
2206 io_delegate_.SetFileContents("old/p/Data.aidl",
2207 "package p;"
2208 "parcelable Data {"
2209 "}");
2210 io_delegate_.SetFileContents("new/p/Data.aidl",
2211 "package p;"
2212 "parcelable Data {"
2213 " int foo = 0;"
2214 "}");
2215 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2216}
2217
Daniel Norman85aed542019-08-21 12:01:14 -07002218TEST_F(AidlTestCompatibleChanges, NewEnumerator) {
2219 io_delegate_.SetFileContents("old/p/Enum.aidl",
2220 "package p;"
2221 "enum Enum {"
2222 " FOO = 1,"
2223 "}");
2224 io_delegate_.SetFileContents("new/p/Enum.aidl",
2225 "package p;"
2226 "enum Enum {"
2227 " FOO = 1,"
2228 " BAR = 2,"
2229 "}");
2230 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2231}
2232
2233TEST_F(AidlTestCompatibleChanges, ReorderedEnumerator) {
2234 io_delegate_.SetFileContents("old/p/Enum.aidl",
2235 "package p;"
2236 "enum Enum {"
2237 " FOO = 1,"
2238 " BAR = 2,"
2239 "}");
2240 io_delegate_.SetFileContents("new/p/Enum.aidl",
2241 "package p;"
2242 "enum Enum {"
2243 " BAR = 2,"
2244 " FOO = 1,"
2245 "}");
2246 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2247}
2248
Jooyung Hanb5c55cd2020-10-22 07:59:01 +09002249TEST_F(AidlTestCompatibleChanges, NewUnionField) {
2250 io_delegate_.SetFileContents("old/p/Union.aidl",
2251 "package p;"
2252 "union Union {"
2253 " String foo;"
2254 "}");
2255 io_delegate_.SetFileContents("new/p/Union.aidl",
2256 "package p;"
2257 "union Union {"
2258 " String foo;"
2259 " int num;"
2260 "}");
2261 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2262}
2263
Daniel Norman85aed542019-08-21 12:01:14 -07002264TEST_F(AidlTestCompatibleChanges, NewPackage) {
Jiyong Parke59c3682018-09-11 23:10:25 +09002265 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2266 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002267 "interface IFoo {"
2268 " void foo(int a);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002269 "}");
2270 io_delegate_.SetFileContents("old/p/Data.aidl",
2271 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002272 "parcelable Data {"
2273 " int foo;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002274 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002275 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2276 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002277 "interface IFoo {"
2278 " void foo(int a);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002279 "}");
2280 io_delegate_.SetFileContents("new/p/Data.aidl",
2281 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002282 "parcelable Data {"
2283 " int foo;"
Jiyong Parke59c3682018-09-11 23:10:25 +09002284 "}");
2285 io_delegate_.SetFileContents("new/q/IFoo.aidl",
2286 "package q;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002287 "interface IFoo {"
Jiyong Parke59c3682018-09-11 23:10:25 +09002288 " void foo(int a);"
2289 "}");
2290 io_delegate_.SetFileContents("new/q/Data.aidl",
2291 "package q;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002292 "parcelable Data {"
2293 " int foo;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002294 "}");
Daniel Norman85aed542019-08-21 12:01:14 -07002295 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2296}
Jiyong Park3656c3c2018-08-01 20:02:01 +09002297
Daniel Norman85aed542019-08-21 12:01:14 -07002298TEST_F(AidlTestCompatibleChanges, ArgNameChange) {
2299 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2300 "package p;"
2301 "interface IFoo {"
2302 " void foo(int a);"
2303 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002304 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2305 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002306 "interface IFoo {"
2307 " void foo(int b);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002308 "}");
Daniel Norman85aed542019-08-21 12:01:14 -07002309 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2310}
Jiyong Parke59c3682018-09-11 23:10:25 +09002311
Daniel Norman85aed542019-08-21 12:01:14 -07002312TEST_F(AidlTestCompatibleChanges, AddedConstValue) {
Jiyong Parke59c3682018-09-11 23:10:25 +09002313 io_delegate_.SetFileContents("old/p/I.aidl",
2314 "package p; interface I {"
2315 "const int A = 1; }");
2316 io_delegate_.SetFileContents("new/p/I.aidl",
2317 "package p ; interface I {"
2318 "const int A = 1; const int B = 2;}");
Daniel Norman85aed542019-08-21 12:01:14 -07002319 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2320}
Jiyong Parka428d212018-08-29 22:26:30 +09002321
Daniel Norman85aed542019-08-21 12:01:14 -07002322TEST_F(AidlTestCompatibleChanges, ChangedConstValueOrder) {
Jiyong Parke59c3682018-09-11 23:10:25 +09002323 io_delegate_.SetFileContents("old/p/I.aidl",
2324 "package p; interface I {"
2325 "const int A = 1; const int B = 2;}");
2326 io_delegate_.SetFileContents("new/p/I.aidl",
2327 "package p ; interface I {"
2328 "const int B = 2; const int A = 1;}");
Daniel Norman85aed542019-08-21 12:01:14 -07002329 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
Jiyong Park3656c3c2018-08-01 20:02:01 +09002330}
2331
Jooyung Han69ea4ba2020-10-29 15:33:37 +09002332TEST_F(AidlTestCompatibleChanges, ReorderedAnnatations) {
2333 io_delegate_.SetFileContents("old/p/Foo.aidl",
2334 "package p;"
2335 "@JavaPassthrough(annotation=\"Alice\")"
2336 "@JavaPassthrough(annotation=\"Bob\")"
2337 "parcelable Foo {}");
2338 io_delegate_.SetFileContents("new/p/Foo.aidl",
2339 "package p;"
2340 "@JavaPassthrough(annotation=\"Bob\")"
2341 "@JavaPassthrough(annotation=\"Alice\")"
2342 "parcelable Foo {}");
2343 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2344}
2345
Jooyung Han00073272020-11-27 14:20:20 +09002346TEST_F(AidlTestCompatibleChanges, OkayToDeprecate) {
2347 io_delegate_.SetFileContents("old/p/Foo.aidl",
2348 "package p;"
2349 "parcelable Foo {}");
2350 io_delegate_.SetFileContents("new/p/Foo.aidl",
2351 "package p;"
2352 "@JavaPassthrough(annotation=\"@Deprecated\")"
2353 "parcelable Foo {}");
2354 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2355}
2356
Jooyung Han636fd2f2020-10-22 11:33:45 +09002357TEST_F(AidlTestCompatibleChanges, NewFieldOfNewType) {
2358 io_delegate_.SetFileContents("old/p/Data.aidl",
2359 "package p;"
2360 "parcelable Data {"
2361 " int num;"
2362 "}");
2363 io_delegate_.SetFileContents(
2364 "new/p/Data.aidl",
2365 "package p;"
2366 "parcelable Data {"
2367 " int num;"
2368 " p.Enum e;" // this is considered as valid since 0(enum default) is valid for "Enum" type
2369 "}");
2370 io_delegate_.SetFileContents("new/p/Enum.aidl",
2371 "package p;"
2372 "enum Enum {"
2373 " FOO = 0,"
2374 " BAR = 1,"
2375 "}");
2376 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2377}
2378
Jooyung Han308bbe02021-04-27 12:09:59 +09002379TEST_F(AidlTestCompatibleChanges, CompatibleExplicitDefaults) {
2380 io_delegate_.SetFileContents("old/p/Data.aidl",
2381 "package p;\n"
2382 "parcelable Data {\n"
2383 " p.Enum e;\n"
2384 "}");
2385 io_delegate_.SetFileContents("old/p/Enum.aidl",
2386 "package p;\n"
2387 "enum Enum {\n"
2388 " FOO = 0,\n"
2389 " BAR = 1,\n"
2390 "}");
2391 io_delegate_.SetFileContents("new/p/Data.aidl",
2392 "package p;\n"
2393 "parcelable Data {\n"
2394 " p.Enum e = p.Enum.FOO;\n"
2395 "}");
2396 io_delegate_.SetFileContents("new/p/Enum.aidl",
2397 "package p;\n"
2398 "enum Enum {\n"
2399 " FOO = 0,\n"
2400 " BAR = 1,\n"
2401 "}");
2402 EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_));
2403}
2404
Daniel Norman85aed542019-08-21 12:01:14 -07002405class AidlTestIncompatibleChanges : public AidlTest {
2406 protected:
2407 Options options_ = Options::From("aidl --checkapi old new");
2408};
2409
2410TEST_F(AidlTestIncompatibleChanges, RemovedType) {
Jiyong Park0cf03b12020-07-22 19:36:34 +09002411 const string expected_stderr = "ERROR: old/p/IFoo.aidl:1.11-20: Removed type: p.IFoo\n";
Jiyong Parke59c3682018-09-11 23:10:25 +09002412 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2413 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002414 "interface IFoo {"
2415 " void foo(in String[] str);"
2416 " void bar(@utf8InCpp String str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002417 "}");
Devin Moored131d5e2020-03-31 10:39:10 -07002418 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002419 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moored131d5e2020-03-31 10:39:10 -07002420 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002421}
2422
2423TEST_F(AidlTestIncompatibleChanges, RemovedMethod) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002424 const string expected_stderr =
2425 "ERROR: old/p/IFoo.aidl:1.61-65: Removed or changed method: p.IFoo.bar(String)\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002426 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2427 "package p;"
2428 "interface IFoo {"
2429 " void foo(in String[] str);"
2430 " void bar(@utf8InCpp String str);"
2431 "}");
2432 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2433 "package p;"
2434 "interface IFoo {"
2435 " void foo(in String[] str);"
2436 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002437 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002438 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002439 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002440}
2441
Jiyong Parkf8d53612020-05-04 14:06:13 +09002442TEST_F(AidlTestIncompatibleChanges, UntypedListInInterface) {
2443 const string expected_stderr =
2444 "ERROR: new/p/IFoo.aidl:1.61-65: "
2445 "Encountered an untyped List or Map. The use of untyped List/Map is "
2446 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
2447 "the receiving side. Consider switching to an array or a generic List/Map.\n"
2448 "ERROR: new/p/IFoo.aidl: Failed to read.\n";
2449 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2450 "package p;"
2451 "interface IFoo {"
2452 " void foo(in String[] str);"
2453 "}");
2454 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2455 "package p;"
2456 "interface IFoo {"
2457 " void foo(in String[] str);"
2458 " void bar(in List arg);"
2459 "}");
2460 CaptureStderr();
2461 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2462 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2463}
2464
2465TEST_F(AidlTestCompatibleChanges, UntypedListInParcelable) {
2466 const string expected_stderr =
2467 "ERROR: new/p/Data.aidl:1.54-59: "
2468 "Encountered an untyped List or Map. The use of untyped List/Map is "
2469 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
2470 "the receiving side. Consider switching to an array or a generic List/Map.\n"
2471 "ERROR: new/p/Data.aidl: Failed to read.\n";
2472 io_delegate_.SetFileContents("old/p/Data.aidl",
2473 "package p;"
2474 "parcelable Data {"
2475 " int foo;"
2476 "}");
2477 io_delegate_.SetFileContents("new/p/Data.aidl",
2478 "package p;"
2479 "parcelable Data {"
2480 " int foo;"
2481 " @nullable List list;"
2482 "}");
2483 CaptureStderr();
2484 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2485 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2486}
2487
Daniel Norman85aed542019-08-21 12:01:14 -07002488TEST_F(AidlTestIncompatibleChanges, RemovedField) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002489 const string expected_stderr =
2490 "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 +09002491 io_delegate_.SetFileContents("old/p/Data.aidl",
2492 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002493 "parcelable Data {"
2494 " int foo;"
2495 " int bar;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002496 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002497 io_delegate_.SetFileContents("new/p/Data.aidl",
2498 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002499 "parcelable Data {"
2500 " int foo;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002501 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002502 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002503 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002504 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002505}
Jiyong Park3656c3c2018-08-01 20:02:01 +09002506
Jooyung Hanb5c55cd2020-10-22 07:59:01 +09002507TEST_F(AidlTestIncompatibleChanges, NewFieldWithNoDefault) {
2508 const string expected_stderr =
2509 "ERROR: new/p/Data.aidl:1.46-50: Field 'str' does not have a useful default in some "
2510 "backends. Please either provide a default value for this field or mark the field as "
2511 "@nullable. This value or a null value will be used automatically when an old version of "
2512 "this parcelable is sent to a process which understands a new version of this parcelable. In "
2513 "order to make sure your code continues to be backwards compatible, make sure the default or "
2514 "null value does not cause a semantic change to this parcelable.\n";
2515 io_delegate_.SetFileContents("old/p/Data.aidl",
2516 "package p;"
2517 "parcelable Data {"
2518 " int num;"
2519 "}");
2520 io_delegate_.SetFileContents("new/p/Data.aidl",
2521 "package p;"
2522 "parcelable Data {"
2523 " int num;"
2524 " String str;"
2525 "}");
2526 CaptureStderr();
2527 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2528 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2529}
2530
Jooyung Han636fd2f2020-10-22 11:33:45 +09002531TEST_F(AidlTestIncompatibleChanges, NewFieldWithNonZeroEnum) {
2532 const string expected_stderr =
2533 "ERROR: new/p/Data.aidl:1.46-48: Field 'e' of enum 'Enum' can't be initialized as '0'. "
2534 "Please make sure 'Enum' has '0' as a valid value.\n";
2535 io_delegate_.SetFileContents("old/p/Data.aidl",
2536 "package p;"
2537 "parcelable Data {"
2538 " int num;"
2539 "}");
2540 io_delegate_.SetFileContents("new/p/Data.aidl",
2541 "package p;"
2542 "parcelable Data {"
2543 " int num;"
2544 " p.Enum e;"
2545 "}");
2546 io_delegate_.SetFileContents("new/p/Enum.aidl",
2547 "package p;"
2548 "enum Enum {"
2549 " FOO = 1,"
2550 " BAR = 2,"
2551 "}");
2552 CaptureStderr();
2553 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2554 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2555}
2556
Daniel Norman85aed542019-08-21 12:01:14 -07002557TEST_F(AidlTestIncompatibleChanges, RemovedEnumerator) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002558 const string expected_stderr =
2559 "ERROR: new/p/Enum.aidl:1.15-20: Removed enumerator from p.Enum: FOO\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002560 io_delegate_.SetFileContents("old/p/Enum.aidl",
2561 "package p;"
2562 "enum Enum {"
2563 " FOO = 1,"
2564 " BAR = 2,"
2565 "}");
2566 io_delegate_.SetFileContents("new/p/Enum.aidl",
2567 "package p;"
2568 "enum Enum {"
2569 " BAR = 2,"
2570 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002571 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002572 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002573 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002574}
2575
Jooyung Hanb5c55cd2020-10-22 07:59:01 +09002576TEST_F(AidlTestIncompatibleChanges, RemovedUnionField) {
2577 const string expected_stderr =
2578 "ERROR: new/p/Union.aidl:1.16-22: Number of fields in p.Union is reduced from 2 to 1.\n";
2579 io_delegate_.SetFileContents("old/p/Union.aidl",
2580 "package p;"
2581 "union Union {"
2582 " String str;"
2583 " int num;"
2584 "}");
2585 io_delegate_.SetFileContents("new/p/Union.aidl",
2586 "package p;"
2587 "union Union {"
2588 " String str;"
2589 "}");
2590 CaptureStderr();
2591 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2592 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2593}
2594
Daniel Norman85aed542019-08-21 12:01:14 -07002595TEST_F(AidlTestIncompatibleChanges, RenamedMethod) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002596 const string expected_stderr =
2597 "ERROR: old/p/IFoo.aidl:1.61-65: Removed or changed method: p.IFoo.bar(String)\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002598 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2599 "package p;"
2600 "interface IFoo {"
2601 " void foo(in String[] str);"
2602 " void bar(@utf8InCpp String str);"
2603 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002604 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2605 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002606 "interface IFoo {"
2607 " void foo(in String[] str);"
2608 " void bar2(@utf8InCpp String str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002609 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002610 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002611 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002612 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002613}
2614
Daniel Norman85aed542019-08-21 12:01:14 -07002615TEST_F(AidlTestIncompatibleChanges, RenamedType) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002616 const string expected_stderr = "ERROR: old/p/IFoo.aidl:1.11-20: Removed type: p.IFoo\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002617 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2618 "package p;"
2619 "interface IFoo {"
2620 " void foo(in String[] str);"
2621 " void bar(@utf8InCpp String str);"
2622 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002623 io_delegate_.SetFileContents("new/p/IFoo2.aidl",
2624 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002625 "interface IFoo2 {"
2626 " void foo(in String[] str);"
2627 " void bar(@utf8InCpp String str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002628 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002629 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002630 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002631 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002632}
Jiyong Park3656c3c2018-08-01 20:02:01 +09002633
Daniel Norman85aed542019-08-21 12:01:14 -07002634TEST_F(AidlTestIncompatibleChanges, ChangedEnumerator) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002635 const string expected_stderr =
2636 "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 -07002637 io_delegate_.SetFileContents("old/p/Enum.aidl",
2638 "package p;"
2639 "enum Enum {"
2640 " FOO = 1,"
2641 " BAR = 2,"
2642 "}");
2643 io_delegate_.SetFileContents("new/p/Enum.aidl",
2644 "package p;"
2645 "enum Enum {"
2646 " FOO = 3,"
2647 " BAR = 2,"
2648 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002649 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002650 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002651 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002652}
2653
2654TEST_F(AidlTestIncompatibleChanges, ReorderedMethod) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002655 const string expected_stderr =
2656 "ERROR: new/p/IFoo.aidl:1.67-71: Transaction ID changed: p.IFoo.foo(String[]) is changed "
2657 "from 0 to 1.\n"
2658 "ERROR: new/p/IFoo.aidl:1.33-37: Transaction ID changed: p.IFoo.bar(String) is changed from "
2659 "1 to 0.\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002660 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2661 "package p;"
2662 "interface IFoo {"
2663 " void foo(in String[] str);"
2664 " void bar(@utf8InCpp String str);"
2665 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002666 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2667 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002668 "interface IFoo {"
2669 " void bar(@utf8InCpp String str);"
2670 " void foo(in String[] str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002671 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002672 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002673 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002674 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002675}
2676
2677TEST_F(AidlTestIncompatibleChanges, ReorderedField) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002678 const string expected_stderr =
Jiyong Parkb07d9932020-05-15 12:56:54 +09002679 "ERROR: new/p/Data.aidl:1.33-37: Reordered bar from 1 to 0.\n"
2680 "ERROR: new/p/Data.aidl:1.43-47: Reordered foo from 0 to 1.\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002681 io_delegate_.SetFileContents("old/p/Data.aidl",
Jiyong Parke59c3682018-09-11 23:10:25 +09002682 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002683 "parcelable Data {"
2684 " int foo;"
2685 " int bar;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002686 "}");
Daniel Norman85aed542019-08-21 12:01:14 -07002687 io_delegate_.SetFileContents("new/p/Data.aidl",
2688 "package p;"
2689 "parcelable Data {"
2690 " int bar;"
2691 " int foo;"
2692 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002693 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002694 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002695 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002696}
Jiyong Park3656c3c2018-08-01 20:02:01 +09002697
Daniel Norman85aed542019-08-21 12:01:14 -07002698TEST_F(AidlTestIncompatibleChanges, ChangedDirectionSpecifier) {
Devin Mooreeccdb902020-03-24 16:22:40 -07002699 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 -07002700 io_delegate_.SetFileContents("old/p/IFoo.aidl",
Jiyong Parke59c3682018-09-11 23:10:25 +09002701 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002702 "interface IFoo {"
2703 " void foo(in String[] str);"
2704 " void bar(@utf8InCpp String str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002705 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002706 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2707 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002708 "interface IFoo {"
2709 " void foo(out String[] str);"
2710 " void bar(@utf8InCpp String str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002711 "}");
Devin Mooreeccdb902020-03-24 16:22:40 -07002712 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002713 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Mooreeccdb902020-03-24 16:22:40 -07002714 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002715}
Jiyong Park3656c3c2018-08-01 20:02:01 +09002716
Daniel Norman85aed542019-08-21 12:01:14 -07002717TEST_F(AidlTestIncompatibleChanges, AddedAnnotation) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002718 const string expected_stderr =
2719 "ERROR: new/p/IFoo.aidl:1.51-58: Changed annotations: (empty) to @utf8InCpp\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002720 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2721 "package p;"
2722 "interface IFoo {"
2723 " void foo(in String[] str);"
2724 " void bar(@utf8InCpp String str);"
2725 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002726 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2727 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002728 "interface IFoo {"
Jiyong Parke59c3682018-09-11 23:10:25 +09002729 " void foo(in @utf8InCpp String[] str);"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002730 " void bar(@utf8InCpp String str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002731 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002732 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002733 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002734 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002735}
Jiyong Park3656c3c2018-08-01 20:02:01 +09002736
Daniel Norman85aed542019-08-21 12:01:14 -07002737TEST_F(AidlTestIncompatibleChanges, RemovedAnnotation) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002738 const string expected_stderr =
2739 "ERROR: new/p/IFoo.aidl:1.66-72: Changed annotations: @utf8InCpp to (empty)\n";
Daniel Norman85aed542019-08-21 12:01:14 -07002740 io_delegate_.SetFileContents("old/p/IFoo.aidl",
2741 "package p;"
2742 "interface IFoo {"
2743 " void foo(in String[] str);"
2744 " void bar(@utf8InCpp String str);"
2745 "}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002746 io_delegate_.SetFileContents("new/p/IFoo.aidl",
2747 "package p;"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002748 "interface IFoo {"
Jiyong Parke59c3682018-09-11 23:10:25 +09002749 " void foo(in String[] str);"
Jiyong Park3656c3c2018-08-01 20:02:01 +09002750 " void bar(String str);"
Jiyong Parke59c3682018-09-11 23:10:25 +09002751 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002752 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002753 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002754 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002755}
Jiyong Park3656c3c2018-08-01 20:02:01 +09002756
Jooyung Han60b2fde2020-10-29 15:12:40 +09002757TEST_F(AidlTestIncompatibleChanges, ChangedBackingTypeOfEnum) {
2758 const string expected_stderr =
2759 "ERROR: new/p/Foo.aidl:1.11-32: Type changed: byte to long.\n"
2760 "ERROR: new/p/Foo.aidl:1.36-40: Changed backing types.\n";
2761 io_delegate_.SetFileContents("old/p/Foo.aidl",
2762 "package p;"
2763 "@Backing(type=\"byte\")"
2764 "enum Foo {"
2765 " FOO, BAR,"
2766 "}");
2767 io_delegate_.SetFileContents("new/p/Foo.aidl",
2768 "package p;"
2769 "@Backing(type=\"long\")"
2770 "enum Foo {"
2771 " FOO, BAR,"
2772 "}");
2773 CaptureStderr();
2774 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2775 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2776}
2777
Jooyung Han69ea4ba2020-10-29 15:33:37 +09002778TEST_F(AidlTestIncompatibleChanges, ChangedAnnatationParams) {
2779 const string expected_stderr =
2780 "ERROR: new/p/Foo.aidl:1.55-59: Changed annotations: @JavaPassthrough(annotation=\"Alice\") "
2781 "to @JavaPassthrough(annotation=\"Bob\")\n";
2782 io_delegate_.SetFileContents("old/p/Foo.aidl",
2783 "package p;"
2784 "@JavaPassthrough(annotation=\"Alice\")"
2785 "parcelable Foo {}");
2786 io_delegate_.SetFileContents("new/p/Foo.aidl",
2787 "package p;"
2788 "@JavaPassthrough(annotation=\"Bob\")"
2789 "parcelable Foo {}");
2790
2791 CaptureStderr();
2792 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2793 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2794}
2795
Devin Mooredb7ac512020-08-07 11:17:36 -07002796TEST_F(AidlTestIncompatibleChanges, AddedParcelableAnnotation) {
2797 const string expected_stderr =
Jooyung Han2d6b5c42021-01-09 01:01:06 +09002798 "ERROR: new/p/Foo.aidl:1.32-36: Changed annotations: (empty) to @FixedSize\n";
Devin Mooredb7ac512020-08-07 11:17:36 -07002799 io_delegate_.SetFileContents("old/p/Foo.aidl",
2800 "package p;"
2801 "parcelable Foo {"
2802 " int A;"
2803 "}");
2804 io_delegate_.SetFileContents("new/p/Foo.aidl",
2805 "package p;"
Jooyung Han2d6b5c42021-01-09 01:01:06 +09002806 "@FixedSize parcelable Foo {"
Devin Mooredb7ac512020-08-07 11:17:36 -07002807 " int A;"
2808 "}");
2809 CaptureStderr();
2810 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2811 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2812}
2813
2814TEST_F(AidlTestIncompatibleChanges, RemovedParcelableAnnotation) {
2815 const string expected_stderr =
Jooyung Han2d6b5c42021-01-09 01:01:06 +09002816 "ERROR: new/p/Foo.aidl:1.21-25: Changed annotations: @FixedSize to (empty)\n";
Devin Mooredb7ac512020-08-07 11:17:36 -07002817 io_delegate_.SetFileContents("old/p/Foo.aidl",
2818 "package p;"
Jooyung Han2d6b5c42021-01-09 01:01:06 +09002819 "@FixedSize parcelable Foo {"
Devin Mooredb7ac512020-08-07 11:17:36 -07002820 " int A;"
2821 "}");
2822 io_delegate_.SetFileContents("new/p/Foo.aidl",
2823 "package p;"
2824 "parcelable Foo {"
2825 " int A;"
2826 "}");
2827 CaptureStderr();
2828 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2829 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2830}
2831
Daniel Norman85aed542019-08-21 12:01:14 -07002832TEST_F(AidlTestIncompatibleChanges, RemovedPackage) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002833 const string expected_stderr = "ERROR: old/q/IFoo.aidl:1.11-21: Removed type: q.IFoo\n";
Jiyong Parke59c3682018-09-11 23:10:25 +09002834 io_delegate_.SetFileContents("old/p/IFoo.aidl", "package p; interface IFoo{}");
2835 io_delegate_.SetFileContents("old/q/IFoo.aidl", "package q; interface IFoo{}");
Jiyong Parke59c3682018-09-11 23:10:25 +09002836 io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p; interface IFoo{}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002837 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002838 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002839 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002840}
Jiyong Parka468e2a2018-08-29 21:25:18 +09002841
Daniel Norman85aed542019-08-21 12:01:14 -07002842TEST_F(AidlTestIncompatibleChanges, ChangedDefaultValue) {
Steven Moreland370ed342020-04-28 18:14:39 -07002843 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 +09002844 io_delegate_.SetFileContents("old/p/D.aidl", "package p; parcelable D { int a = 1; }");
2845 io_delegate_.SetFileContents("new/p/D.aidl", "package p; parcelable D { int a = 2; }");
Devin Moore097a3ab2020-03-11 16:08:44 -07002846 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002847 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002848 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002849}
Jiyong Parka428d212018-08-29 22:26:30 +09002850
Daniel Norman85aed542019-08-21 12:01:14 -07002851TEST_F(AidlTestIncompatibleChanges, RemovedConstValue) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002852 const string expected_stderr =
2853 "ERROR: old/p/I.aidl:1.51-53: Removed constant declaration: p.I.B\n";
Jiyong Parke59c3682018-09-11 23:10:25 +09002854 io_delegate_.SetFileContents("old/p/I.aidl",
2855 "package p; interface I {"
2856 "const int A = 1; const int B = 2;}");
2857 io_delegate_.SetFileContents("new/p/I.aidl", "package p; interface I { const int A = 1; }");
Devin Moore097a3ab2020-03-11 16:08:44 -07002858 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002859 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002860 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Daniel Norman85aed542019-08-21 12:01:14 -07002861}
Jiyong Parka428d212018-08-29 22:26:30 +09002862
Daniel Norman85aed542019-08-21 12:01:14 -07002863TEST_F(AidlTestIncompatibleChanges, ChangedConstValue) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002864 const string expected_stderr =
2865 "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 +09002866 io_delegate_.SetFileContents("old/p/I.aidl", "package p; interface I { const int A = 1; }");
2867 io_delegate_.SetFileContents("new/p/I.aidl", "package p; interface I { const int A = 2; }");
Devin Moore097a3ab2020-03-11 16:08:44 -07002868 CaptureStderr();
Daniel Norman85aed542019-08-21 12:01:14 -07002869 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002870 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Park3c35e392018-08-30 13:10:30 +09002871}
2872
Devin Moorec7e47a32020-08-07 10:55:25 -07002873TEST_F(AidlTestIncompatibleChanges, FixedSizeAddedField) {
2874 const string expected_stderr =
2875 "ERROR: new/p/Foo.aidl:1.33-37: Number of fields in p.Foo is changed from 1 to 2. "
2876 "This is an incompatible change for FixedSize types.\n";
2877 io_delegate_.SetFileContents("old/p/Foo.aidl",
2878 "package p; @FixedSize parcelable Foo { int A = 1; }");
2879 io_delegate_.SetFileContents("new/p/Foo.aidl",
2880 "package p; @FixedSize parcelable Foo { int A = 1; int B = 2; }");
2881 CaptureStderr();
2882 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2883 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2884}
2885
Jeongik Cha68d18e72021-04-29 20:07:01 +09002886TEST_F(AidlTestIncompatibleChanges, UidRangeParcelAddedField) {
2887 const string expected_stderr =
2888 "ERROR: new/android/net/UidRangeParcel.aidl:1.32-47: Number of fields in "
2889 "android.net.UidRangeParcel is changed from 1 to 2. "
2890 "But it is forbidden because of legacy support.\n";
2891 io_delegate_.SetFileContents("old/android/net/UidRangeParcel.aidl",
2892 "package android.net; parcelable UidRangeParcel { int A = 1; }");
2893 io_delegate_.SetFileContents(
2894 "new/android/net/UidRangeParcel.aidl",
2895 "package android.net; parcelable UidRangeParcel { int A = 1; int B = 2; }");
2896 CaptureStderr();
2897 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2898 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2899}
2900
Devin Moorec7e47a32020-08-07 10:55:25 -07002901TEST_F(AidlTestIncompatibleChanges, FixedSizeRemovedField) {
2902 const string expected_stderr =
2903 "ERROR: new/p/Foo.aidl:1.33-37: Number of fields in p.Foo is reduced from 2 to 1.\n";
2904 io_delegate_.SetFileContents("old/p/Foo.aidl",
2905 "package p; @FixedSize parcelable Foo { int A = 1; int B = 1; }");
2906 io_delegate_.SetFileContents("new/p/Foo.aidl",
2907 "package p; @FixedSize parcelable Foo { int A = 1; }");
2908 CaptureStderr();
2909 EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_));
2910 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2911}
2912
2913TEST_P(AidlTest, RejectNonFixedSizeFromFixedSize) {
2914 const string expected_stderr =
2915 "ERROR: Foo.aidl:1.36-38: The @FixedSize parcelable 'Foo' has a non-fixed size field named "
2916 "a.\n"
2917 "ERROR: Foo.aidl:1.44-46: The @FixedSize parcelable 'Foo' has a non-fixed size field named "
2918 "b.\n"
2919 "ERROR: Foo.aidl:1.55-57: The @FixedSize parcelable 'Foo' has a non-fixed size field named "
2920 "c.\n"
2921 "ERROR: Foo.aidl:1.80-82: The @FixedSize parcelable 'Foo' has a non-fixed size field named "
2922 "d.\n"
2923 "ERROR: Foo.aidl:1.92-94: The @FixedSize parcelable 'Foo' has a non-fixed size field named "
2924 "e.\n"
2925 "ERROR: Foo.aidl:1.109-111: The @FixedSize parcelable 'Foo' has a non-fixed size field named "
2926 "f.\n";
2927
2928 io_delegate_.SetFileContents("Foo.aidl",
2929 "@FixedSize parcelable Foo { "
2930 " int[] a;"
2931 " Bar b;"
2932 " String c;"
2933 " ParcelFileDescriptor d;"
2934 " IBinder e;"
2935 " List<String> f;"
Steven Moreland265f3d42020-09-24 19:06:54 +00002936 " int isFixedSize;"
Devin Moorec7e47a32020-08-07 10:55:25 -07002937 "}");
2938 io_delegate_.SetFileContents("Bar.aidl", "parcelable Bar { int a; }");
Jooyung Han9435e9a2021-01-06 10:16:31 +09002939 Options options = Options::From("aidl Foo.aidl -I . --lang=" + to_string(GetLanguage()));
Devin Moorec7e47a32020-08-07 10:55:25 -07002940
2941 CaptureStderr();
2942 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
2943 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2944}
2945
2946TEST_P(AidlTest, AcceptFixedSizeFromFixedSize) {
2947 const string expected_stderr = "";
2948
2949 io_delegate_.SetFileContents("Foo.aidl", "@FixedSize parcelable Foo { int a; Bar b; }");
2950 io_delegate_.SetFileContents("Bar.aidl", "@FixedSize parcelable Bar { Val c; }");
2951 io_delegate_.SetFileContents("Val.aidl", "enum Val { A, B, }");
Jooyung Han9435e9a2021-01-06 10:16:31 +09002952 Options options = Options::From("aidl Foo.aidl -I . --lang=" + to_string(GetLanguage()));
Devin Moorec7e47a32020-08-07 10:55:25 -07002953
2954 CaptureStderr();
2955 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
2956 EXPECT_EQ(expected_stderr, GetCapturedStderr());
2957}
2958
Jiyong Park8c380532018-08-30 14:55:26 +09002959TEST_F(AidlTest, RejectAmbiguousImports) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002960 const string expected_stderr =
2961 "ERROR: p/IFoo.aidl: Duplicate files found for q.IBar from:\n"
2962 "dir1/q/IBar.aidl\n"
2963 "dir2/q/IBar.aidl\n"
Devin Moore5de18ed2020-04-02 13:52:29 -07002964 "ERROR: p/IFoo.aidl: Couldn't find import for class q.IBar\n";
Jiyong Park8c380532018-08-30 14:55:26 +09002965 Options options = Options::From("aidl --lang=java -o out -I dir1 -I dir2 p/IFoo.aidl");
2966 io_delegate_.SetFileContents("p/IFoo.aidl", "package p; import q.IBar; interface IFoo{}");
2967 io_delegate_.SetFileContents("dir1/q/IBar.aidl", "package q; interface IBar{}");
2968 io_delegate_.SetFileContents("dir2/q/IBar.aidl", "package q; interface IBar{}");
2969
Devin Moore097a3ab2020-03-11 16:08:44 -07002970 CaptureStderr();
Jiyong Park8c380532018-08-30 14:55:26 +09002971 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002972 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Park8c380532018-08-30 14:55:26 +09002973}
2974
Jiyong Parked65bf42018-08-28 15:43:27 +09002975TEST_F(AidlTest, HandleManualIdAssignments) {
Devin Moore097a3ab2020-03-11 16:08:44 -07002976 const string expected_stderr =
2977 "ERROR: new/p/IFoo.aidl:1.32-36: Transaction ID changed: p.IFoo.foo() is changed from 10 to "
2978 "11.\n";
Jiyong Parke59c3682018-09-11 23:10:25 +09002979 Options options = Options::From("aidl --checkapi old new");
2980 io_delegate_.SetFileContents("old/p/IFoo.aidl", "package p; interface IFoo{ void foo() = 10;}");
2981 io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p; interface IFoo{ void foo() = 10;}");
Jiyong Parked65bf42018-08-28 15:43:27 +09002982
2983 EXPECT_TRUE(::android::aidl::check_api(options, io_delegate_));
2984
Jiyong Parke59c3682018-09-11 23:10:25 +09002985 io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p; interface IFoo{ void foo() = 11;}");
Devin Moore097a3ab2020-03-11 16:08:44 -07002986 CaptureStderr();
Jiyong Parked65bf42018-08-28 15:43:27 +09002987 EXPECT_FALSE(::android::aidl::check_api(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07002988 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Parked65bf42018-08-28 15:43:27 +09002989}
2990
Jooyung Han652ce482021-02-26 12:40:35 +09002991TEST_P(AidlTest, ParcelFileDescriptorIsBuiltinType) {
2992 Options options =
2993 Options::From("aidl --lang=" + to_string(GetLanguage()) + " -h out -o out p/IFoo.aidl");
Jiyong Parke05195e2018-10-08 18:24:23 +09002994
2995 // use without import
2996 io_delegate_.SetFileContents("p/IFoo.aidl",
2997 "package p; interface IFoo{ void foo(in ParcelFileDescriptor fd);}");
Jooyung Han652ce482021-02-26 12:40:35 +09002998 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
2999
3000 // capture output files
3001 map<string, string> outputs = io_delegate_.OutputFiles();
Jiyong Parke05195e2018-10-08 18:24:23 +09003002
Devin Moore7b8d5c92020-03-17 14:14:08 -07003003 // use without import but with full name
Jiyong Parke05195e2018-10-08 18:24:23 +09003004 io_delegate_.SetFileContents(
3005 "p/IFoo.aidl",
3006 "package p; interface IFoo{ void foo(in android.os.ParcelFileDescriptor fd);}");
Jooyung Han652ce482021-02-26 12:40:35 +09003007 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3008 // output files should be the same
3009 EXPECT_EQ(outputs, io_delegate_.OutputFiles());
Jiyong Parke05195e2018-10-08 18:24:23 +09003010
3011 // use with import (as before)
3012 io_delegate_.SetFileContents("p/IFoo.aidl",
3013 "package p;"
3014 "import android.os.ParcelFileDescriptor;"
3015 "interface IFoo{"
3016 " void foo(in ParcelFileDescriptor fd);"
3017 "}");
Jooyung Han652ce482021-02-26 12:40:35 +09003018 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3019 // output files should be the same
3020 EXPECT_EQ(outputs, io_delegate_.OutputFiles());
Jiyong Parke05195e2018-10-08 18:24:23 +09003021}
Jiyong Parked65bf42018-08-28 15:43:27 +09003022
Jooyung Han020d8d12021-02-26 17:23:02 +09003023TEST_P(AidlTest, RejectsOutputParcelFileDescriptor) {
3024 Options options = Options::From("aidl p/IFoo.aidl -I . --lang=" + to_string(GetLanguage()));
3025 CaptureStderr();
3026 io_delegate_.SetFileContents("p/IFoo.aidl",
3027 "package p;"
3028 "interface IFoo{"
3029 " void foo(out ParcelFileDescriptor fd);"
3030 "}");
3031 EXPECT_EQ(1, ::android::aidl::compile_aidl(options, io_delegate_));
3032 EXPECT_THAT(GetCapturedStderr(), HasSubstr("can't be an out parameter"));
3033}
3034
3035TEST_P(AidlTest, RejectsArgumentDirectionNotSpecified) {
3036 Options options = Options::From("aidl p/IFoo.aidl -I . --lang=" + to_string(GetLanguage()));
3037 CaptureStderr();
3038 io_delegate_.SetFileContents("p/IFoo.aidl",
3039 "package p;"
3040 "interface IFoo{"
3041 " void foo(ParcelFileDescriptor fd);"
3042 "}");
3043 EXPECT_EQ(1, ::android::aidl::compile_aidl(options, io_delegate_));
3044 EXPECT_THAT(GetCapturedStderr(),
3045 HasSubstr("ParcelFileDescriptor can be an in or inout parameter."));
3046}
3047
Jiyong Park3633b722019-04-11 15:38:26 +09003048TEST_F(AidlTest, ManualIds) {
3049 Options options = Options::From("aidl --lang=java -o out IFoo.aidl");
3050 io_delegate_.SetFileContents("IFoo.aidl",
3051 "interface IFoo {\n"
3052 " void foo() = 0;\n"
3053 " void bar() = 1;\n"
3054 "}");
3055 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3056}
3057
3058TEST_F(AidlTest, ManualIdsWithMetaTransactions) {
3059 Options options = Options::From("aidl --lang=java --version 10 -o out IFoo.aidl");
3060 io_delegate_.SetFileContents("IFoo.aidl",
3061 "interface IFoo {\n"
3062 " void foo() = 0;\n"
3063 " void bar() = 1;\n"
3064 "}");
3065 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3066}
3067
3068TEST_F(AidlTest, FailOnDuplicatedIds) {
Devin Moore097a3ab2020-03-11 16:08:44 -07003069 const string expected_stderr =
3070 "ERROR: IFoo.aidl:3.7-11: Found duplicate method id (3) for method bar\n";
Jiyong Park3633b722019-04-11 15:38:26 +09003071 Options options = Options::From("aidl --lang=java --version 10 -o out IFoo.aidl");
3072 io_delegate_.SetFileContents("IFoo.aidl",
3073 "interface IFoo {\n"
3074 " void foo() = 3;\n"
3075 " void bar() = 3;\n"
3076 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07003077 CaptureStderr();
Jiyong Park3633b722019-04-11 15:38:26 +09003078 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07003079 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Park3633b722019-04-11 15:38:26 +09003080}
3081
3082TEST_F(AidlTest, FailOnOutOfRangeIds) {
3083 // 16777115 is kLastMetaMethodId + 1
Devin Moore097a3ab2020-03-11 16:08:44 -07003084 const string expected_stderr =
3085 "ERROR: IFoo.aidl:3.7-11: Found out of bounds id (16777115) for method bar. "
3086 "Value for id must be between 0 and 16777114 inclusive.\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() = 16777115;\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, FailOnPartiallyAssignedIds) {
Devin Moore097a3ab2020-03-11 16:08:44 -07003099 const string expected_stderr =
3100 "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 +09003101 Options options = Options::From("aidl --lang=java --version 10 -o out IFoo.aidl");
3102 io_delegate_.SetFileContents("IFoo.aidl",
3103 "interface IFoo {\n"
3104 " void foo() = 3;\n"
3105 " void bar();\n"
3106 "}");
Devin Moore097a3ab2020-03-11 16:08:44 -07003107 CaptureStderr();
Jiyong Park3633b722019-04-11 15:38:26 +09003108 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07003109 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Park3633b722019-04-11 15:38:26 +09003110}
3111
Jiyong Parkc6816252019-07-08 08:12:28 +09003112TEST_F(AidlTest, AllowDuplicatedImportPaths) {
3113 Options options = Options::From("aidl --lang=java -I dir -I dir IFoo.aidl");
3114 io_delegate_.SetFileContents("dir/IBar.aidl", "interface IBar{}");
3115 io_delegate_.SetFileContents("IFoo.aidl", "import IBar; interface IFoo{}");
3116 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3117}
3118
3119TEST_F(AidlTest, FailOnAmbiguousImports) {
Devin Moore097a3ab2020-03-11 16:08:44 -07003120 const string expected_stderr =
3121 "ERROR: IFoo.aidl: Duplicate files found for IBar from:\n"
3122 "dir/IBar.aidl\n"
3123 "dir2/IBar.aidl\n"
Devin Moore5de18ed2020-04-02 13:52:29 -07003124 "ERROR: IFoo.aidl: Couldn't find import for class IBar\n";
Devin Moore097a3ab2020-03-11 16:08:44 -07003125
Jiyong Parkc6816252019-07-08 08:12:28 +09003126 Options options = Options::From("aidl --lang=java -I dir -I dir2 IFoo.aidl");
3127 io_delegate_.SetFileContents("dir/IBar.aidl", "interface IBar{}");
3128 io_delegate_.SetFileContents("dir2/IBar.aidl", "interface IBar{}");
3129 io_delegate_.SetFileContents("IFoo.aidl", "import IBar; interface IFoo{}");
Devin Moore097a3ab2020-03-11 16:08:44 -07003130 CaptureStderr();
Jiyong Parkc6816252019-07-08 08:12:28 +09003131 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Devin Moore097a3ab2020-03-11 16:08:44 -07003132 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Jiyong Parkc6816252019-07-08 08:12:28 +09003133}
3134
Jiyong Parkf1f5c802020-05-19 17:33:00 +09003135TEST_F(AidlTest, UnusedImportDoesNotContributeInclude) {
3136 io_delegate_.SetFileContents("a/b/IFoo.aidl",
3137 "package a.b;\n"
3138 "import a.b.IBar;\n"
3139 "import a.b.IQux;\n"
3140 "interface IFoo { IQux foo(); }\n");
3141 io_delegate_.SetFileContents("a/b/IBar.aidl", "package a.b; interface IBar { void foo(); }");
3142 io_delegate_.SetFileContents("a/b/IQux.aidl", "package a.b; interface IQux { void foo(); }");
3143
3144 Options options = Options::From("aidl --lang=ndk a/b/IFoo.aidl -I . -o out -h out/include");
3145 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3146
3147 string output;
3148 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/include/aidl/a/b/IFoo.h", &output));
3149 // IBar was imported but wasn't used. include is not expected.
3150 EXPECT_THAT(output, Not(testing::HasSubstr("#include <aidl/a/b/IBar.h>")));
3151 // IBar was imported and used. include is expected.
3152 EXPECT_THAT(output, (testing::HasSubstr("#include <aidl/a/b/IQux.h>")));
3153}
3154
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09003155TEST_F(AidlTest, ParseJavaPassthroughAnnotation) {
Jooyung Hane6bc5e12020-10-13 10:57:10 +09003156 io_delegate_.SetFileContents("a/IFoo.aidl", R"--(package a;
Jooyung Han4cde01d2020-10-13 11:10:47 +09003157 import a.MyEnum;
Jooyung Hane6bc5e12020-10-13 10:57:10 +09003158 @JavaPassthrough(annotation="@com.android.Alice(arg=com.android.Alice.Value.A)")
3159 @JavaPassthrough(annotation="@com.android.AliceTwo")
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09003160 interface IFoo {
3161 @JavaPassthrough(annotation="@com.android.Bob")
Jooyung Han4cde01d2020-10-13 11:10:47 +09003162 void foo(@JavaPassthrough(annotation="@com.android.Cat") int x, MyEnum y);
Jiyong Park7c3b0e42020-08-04 16:08:32 +09003163 const @JavaPassthrough(annotation="@com.android.David") int A = 3;
Jooyung Hane6bc5e12020-10-13 10:57:10 +09003164 })--");
Jooyung Han4cde01d2020-10-13 11:10:47 +09003165 // JavaPassthrough should work with other types as well (e.g. enum)
3166 io_delegate_.SetFileContents("a/MyEnum.aidl", R"--(package a;
3167 @JavaPassthrough(annotation="@com.android.Alice(arg=com.android.Alice.Value.A)")
3168 @JavaPassthrough(annotation="@com.android.AliceTwo")
3169 @Backing(type="byte")
3170 enum MyEnum {
3171 a, b, c
3172 })--");
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09003173
Jooyung Han4cde01d2020-10-13 11:10:47 +09003174 Options java_options = Options::From("aidl -I . --lang=java -o out a/IFoo.aidl a/MyEnum.aidl");
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09003175 EXPECT_EQ(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
3176
3177 string java_out;
3178 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/IFoo.java", &java_out));
Jooyung Hane6bc5e12020-10-13 10:57:10 +09003179 // type-decl-level annotations with newline at the end
3180 EXPECT_THAT(java_out, testing::HasSubstr("@com.android.Alice(arg=com.android.Alice.Value.A)\n"));
3181 EXPECT_THAT(java_out, testing::HasSubstr("@com.android.AliceTwo\n"));
3182 // member-decl-level annotations with newline at the end
3183 EXPECT_THAT(java_out, testing::HasSubstr("@com.android.Bob\n"));
3184 EXPECT_THAT(java_out, testing::HasSubstr("@com.android.David\n"));
3185 // inline annotations with space at the end
3186 EXPECT_THAT(java_out, testing::HasSubstr("@com.android.Cat "));
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09003187
Jooyung Han4cde01d2020-10-13 11:10:47 +09003188 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/MyEnum.java", &java_out));
3189 // type-decl-level annotations with newline at the end
3190 EXPECT_THAT(java_out, testing::HasSubstr("@com.android.Alice(arg=com.android.Alice.Value.A)\n"));
3191 EXPECT_THAT(java_out, testing::HasSubstr("@com.android.AliceTwo\n"));
3192
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09003193 // Other backends shouldn't be bothered
Jooyung Han4cde01d2020-10-13 11:10:47 +09003194 Options cpp_options =
3195 Options::From("aidl -I . --lang=cpp -o out -h out a/IFoo.aidl a/MyEnum.aidl");
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09003196 EXPECT_EQ(0, ::android::aidl::compile_aidl(cpp_options, io_delegate_));
3197
Jooyung Han4cde01d2020-10-13 11:10:47 +09003198 Options ndk_options =
3199 Options::From("aidl -I . --lang=ndk -o out -h out a/IFoo.aidl a/MyEnum.aidl");
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09003200 EXPECT_EQ(0, ::android::aidl::compile_aidl(ndk_options, io_delegate_));
Andrei Homescub62afd92020-05-11 19:24:59 -07003201
Jooyung Han4cde01d2020-10-13 11:10:47 +09003202 Options rust_options = Options::From("aidl -I . --lang=rust -o out a/IFoo.aidl a/MyEnum.aidl");
Andrei Homescub62afd92020-05-11 19:24:59 -07003203 EXPECT_EQ(0, ::android::aidl::compile_aidl(rust_options, io_delegate_));
Jiyong Parkbf5fd5c2020-06-05 19:48:05 +09003204}
3205
Andrei Homescue61feb52020-08-18 15:44:24 -07003206TEST_F(AidlTest, ParseRustDerive) {
3207 io_delegate_.SetFileContents("a/Foo.aidl", R"(package a;
3208 @RustDerive(Clone=true, Copy=false)
3209 parcelable Foo {
3210 int a;
3211 })");
3212
3213 Options rust_options = Options::From("aidl --lang=rust -o out a/Foo.aidl");
3214 EXPECT_EQ(0, ::android::aidl::compile_aidl(rust_options, io_delegate_));
3215
3216 string rust_out;
3217 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/Foo.rs", &rust_out));
3218 EXPECT_THAT(rust_out, testing::HasSubstr("#[derive(Debug, Clone)]"));
3219
3220 // Other backends shouldn't be bothered
3221 Options cpp_options = Options::From("aidl --lang=cpp -o out -h out a/Foo.aidl");
3222 EXPECT_EQ(0, ::android::aidl::compile_aidl(cpp_options, io_delegate_));
3223
3224 Options ndk_options = Options::From("aidl --lang=ndk -o out -h out a/Foo.aidl");
3225 EXPECT_EQ(0, ::android::aidl::compile_aidl(ndk_options, io_delegate_));
3226
3227 Options java_options = Options::From("aidl --lang=java -o out a/Foo.aidl");
3228 EXPECT_EQ(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
3229}
3230
Jiyong Park56f73d72019-06-11 12:20:28 +09003231class AidlOutputPathTest : public AidlTest {
3232 protected:
3233 void SetUp() override {
3234 AidlTest::SetUp();
3235 io_delegate_.SetFileContents("sub/dir/foo/bar/IFoo.aidl", "package foo.bar; interface IFoo {}");
3236 }
3237
3238 void Test(const Options& options, const std::string expected_output_path) {
3239 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3240 // check the existence
3241 EXPECT_TRUE(io_delegate_.GetWrittenContents(expected_output_path, nullptr));
3242 }
3243};
3244
3245TEST_F(AidlOutputPathTest, OutDirWithNoOutputFile) {
3246 // <out_dir> / <package_name> / <type_name>.java
3247 Test(Options::From("aidl -o out sub/dir/foo/bar/IFoo.aidl"), "out/foo/bar/IFoo.java");
3248}
3249
3250TEST_F(AidlOutputPathTest, OutDirWithOutputFile) {
3251 // when output file is explicitly set, it is always respected. -o option is
3252 // ignored.
3253 Test(Options::From("aidl -o out sub/dir/foo/bar/IFoo.aidl output/IFoo.java"), "output/IFoo.java");
3254}
3255
3256TEST_F(AidlOutputPathTest, NoOutDirWithOutputFile) {
3257 Test(Options::From("aidl -o out sub/dir/foo/bar/IFoo.aidl output/IFoo.java"), "output/IFoo.java");
3258}
3259
3260TEST_F(AidlOutputPathTest, NoOutDirWithNoOutputFile) {
3261 // output is the same as the input file except for the suffix
3262 Test(Options::From("aidl sub/dir/foo/bar/IFoo.aidl"), "sub/dir/foo/bar/IFoo.java");
3263}
3264
Devin Moore7b8d5c92020-03-17 14:14:08 -07003265TEST_P(AidlTest, FailOnOutOfBoundsInt32MaxConstInt) {
Devin Moore097a3ab2020-03-11 16:08:44 -07003266 AidlError error;
3267 const string expected_stderr =
3268 "ERROR: p/IFoo.aidl:3.58-69: Invalid type specifier for an int64 literal: int\n";
3269 CaptureStderr();
Will McVickera4e5b132019-10-03 13:52:21 -07003270 EXPECT_EQ(nullptr, Parse("p/IFoo.aidl",
3271 R"(package p;
3272 interface IFoo {
3273 const int int32_max_oob = 2147483650;
3274 }
3275 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -07003276 typenames_, GetLanguage(), &error));
Devin Moore097a3ab2020-03-11 16:08:44 -07003277 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3278 EXPECT_EQ(AidlError::BAD_TYPE, error);
Will McVickera4e5b132019-10-03 13:52:21 -07003279}
3280
Devin Moore7b8d5c92020-03-17 14:14:08 -07003281TEST_P(AidlTest, FailOnOutOfBoundsInt32MinConstInt) {
Devin Moore097a3ab2020-03-11 16:08:44 -07003282 AidlError error;
3283 const string expected_stderr =
3284 "ERROR: p/IFoo.aidl:3.58-60: 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_min_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, FailOnOutOfBoundsInt64MaxConstInt) {
Devin Moore097a3ab2020-03-11 16:08:44 -07003298 AidlError error;
3299 const string expected_stderr =
Devin Moore2a088902020-09-17 10:51:19 -07003300 "ERROR: p/IFoo.aidl:3.59-86: Could not parse integer: 21474836509999999999999999\n";
Devin Moore097a3ab2020-03-11 16:08:44 -07003301 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 long int64_max_oob = 21474836509999999999999999;
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::PARSE_ERROR, error);
Will McVickera4e5b132019-10-03 13:52:21 -07003311}
3312
Devin Moore7b8d5c92020-03-17 14:14:08 -07003313TEST_P(AidlTest, FailOnOutOfBoundsInt64MinConstInt) {
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.61-87: 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_min_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, FailOnOutOfBoundsAutofilledEnum) {
Devin Moore097a3ab2020-03-11 16:08:44 -07003330 AidlError error;
Devin Mooredf93ebb2020-03-25 14:03:35 -07003331 const string expected_stderr =
Jooyung Han29813842020-12-08 01:28:03 +09003332 "ERROR: p/TestEnum.aidl:5.1-36: Invalid type specifier for an int32 literal: byte\n"
Devin Mooredf93ebb2020-03-25 14:03:35 -07003333 "ERROR: p/TestEnum.aidl:5.1-36: Enumerator type differs from enum backing type.\n";
3334 CaptureStderr();
Daniel Normanb28684e2019-10-17 15:31:39 -07003335 EXPECT_EQ(nullptr, Parse("p/TestEnum.aidl",
3336 R"(package p;
3337 @Backing(type="byte")
3338 enum TestEnum {
3339 FOO = 127,
3340 BAR,
3341 }
3342 )",
Devin Moore7b8d5c92020-03-17 14:14:08 -07003343 typenames_, GetLanguage(), &error));
Devin Mooredf93ebb2020-03-25 14:03:35 -07003344 EXPECT_EQ(expected_stderr, GetCapturedStderr());
Devin Moore097a3ab2020-03-11 16:08:44 -07003345 EXPECT_EQ(AidlError::BAD_TYPE, error);
Daniel Normanb28684e2019-10-17 15:31:39 -07003346}
3347
Devin Mooredecaf292020-04-30 09:16:40 -07003348TEST_P(AidlTest, UnsupportedBackingAnnotationParam) {
3349 AidlError error;
3350 const string expected_stderr =
3351 "ERROR: p/TestEnum.aidl:2.1-51: Parameter foo not supported for annotation Backing. It must "
Devin Mooredecaf292020-04-30 09:16:40 -07003352 "be one of: type\n";
3353 CaptureStderr();
3354 EXPECT_EQ(nullptr, Parse("p/TestEnum.aidl",
3355 R"(package p;
3356 @Backing(foo="byte")
3357 enum TestEnum {
3358 FOO = 1,
3359 BAR,
3360 }
3361 )",
3362 typenames_, GetLanguage(), &error));
3363 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3364 EXPECT_EQ(AidlError::BAD_TYPE, error);
3365}
3366
Jooyung Han5721a232020-12-24 04:34:55 +09003367TEST_P(AidlTest, BackingAnnotationRequireTypeParameter) {
3368 const string expected_stderr = "ERROR: Enum.aidl:1.1-9: Missing 'type' on @Backing.\n";
3369 CaptureStderr();
3370 EXPECT_EQ(nullptr, Parse("Enum.aidl", "@Backing enum Enum { FOO }", typenames_, GetLanguage()));
3371 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3372}
3373
Jooyung Han66813932020-10-23 13:24:44 +09003374TEST_F(AidlTest, SupportJavaOnlyImmutableAnnotation) {
Jeongik Chad0a10272020-08-06 16:33:36 +09003375 io_delegate_.SetFileContents("Foo.aidl",
3376 "@JavaOnlyImmutable parcelable Foo { int a; Bar b; List<Bar> c; "
3377 "Map<String, Baz> d; Bar[] e; }");
3378 io_delegate_.SetFileContents("Bar.aidl", "@JavaOnlyImmutable parcelable Bar { String a; }");
3379 io_delegate_.SetFileContents("Baz.aidl",
3380 "@JavaOnlyImmutable @JavaOnlyStableParcelable parcelable Baz;");
Jeongik Cha36f76c32020-07-28 00:25:52 +09003381 Options options = Options::From("aidl --lang=java -I . Foo.aidl");
3382 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3383}
3384
Jooyung Han66813932020-10-23 13:24:44 +09003385TEST_F(AidlTest, RejectMutableParcelableFromJavaOnlyImmutableParcelable) {
Jeongik Chad0a10272020-08-06 16:33:36 +09003386 io_delegate_.SetFileContents("Foo.aidl", "@JavaOnlyImmutable parcelable Foo { Bar bar; }");
Jeongik Cha36f76c32020-07-28 00:25:52 +09003387 io_delegate_.SetFileContents("Bar.aidl", "parcelable Bar { String a; }");
Jooyung Hand4057c42020-10-23 13:28:22 +09003388 string expected_error =
Jooyung Han59af9cc2020-10-25 21:44:14 +09003389 "ERROR: Foo.aidl:1.40-44: The @JavaOnlyImmutable 'Foo' has a non-immutable field "
3390 "named 'bar'.\n";
3391 CaptureStderr();
3392 Options options = Options::From("aidl --lang=java Foo.aidl -I .");
3393 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3394 EXPECT_EQ(expected_error, GetCapturedStderr());
3395}
3396
Jooyung Han09e551c2021-05-11 11:44:48 +09003397TEST_F(AidlTest, JavaOnlyImmutableParcelableWithEnumFields) {
3398 io_delegate_.SetFileContents("Foo.aidl", "@JavaOnlyImmutable parcelable Foo { Bar bar; }");
3399 io_delegate_.SetFileContents("Bar.aidl", "enum Bar { FOO }");
3400 CaptureStderr();
3401 Options options = Options::From("aidl --lang=java Foo.aidl -I .");
3402 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3403 EXPECT_EQ("", GetCapturedStderr());
3404}
3405
Jooyung Han59af9cc2020-10-25 21:44:14 +09003406TEST_F(AidlTest, RejectMutableParcelableFromJavaOnlyImmutableUnion) {
3407 io_delegate_.SetFileContents("Foo.aidl", "@JavaOnlyImmutable union Foo { Bar bar; }");
3408 io_delegate_.SetFileContents("Bar.aidl", "parcelable Bar { String a; }");
3409 string expected_error =
3410 "ERROR: Foo.aidl:1.35-39: The @JavaOnlyImmutable 'Foo' has a non-immutable field "
Jooyung Hand4057c42020-10-23 13:28:22 +09003411 "named 'bar'.\n";
3412 CaptureStderr();
Jeongik Cha36f76c32020-07-28 00:25:52 +09003413 Options options = Options::From("aidl --lang=java Foo.aidl -I .");
3414 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jooyung Hand4057c42020-10-23 13:28:22 +09003415 EXPECT_EQ(expected_error, GetCapturedStderr());
Jeongik Cha36f76c32020-07-28 00:25:52 +09003416}
3417
Jooyung Han66813932020-10-23 13:24:44 +09003418TEST_F(AidlTest, ImmutableParcelableCannotBeInOut) {
Jeongik Chad0a10272020-08-06 16:33:36 +09003419 io_delegate_.SetFileContents("Foo.aidl", "@JavaOnlyImmutable parcelable Foo { int a; }");
Jooyung Han15fd6c62020-10-23 13:54:46 +09003420 io_delegate_.SetFileContents("IBar.aidl", "interface IBar { void my(inout Foo foo); }");
3421 string expected_error =
3422 "ERROR: IBar.aidl:1.35-39: 'foo' can't be an inout parameter because @JavaOnlyImmutable can "
3423 "only be an in parameter.\n";
3424 CaptureStderr();
Jeongik Cha36f76c32020-07-28 00:25:52 +09003425 Options options = Options::From("aidl --lang=java IBar.aidl -I .");
3426 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jooyung Han15fd6c62020-10-23 13:54:46 +09003427 EXPECT_EQ(expected_error, GetCapturedStderr());
Jeongik Cha36f76c32020-07-28 00:25:52 +09003428}
3429
Jooyung Han66813932020-10-23 13:24:44 +09003430TEST_F(AidlTest, ImmutableParcelableCannotBeOut) {
Jeongik Chad0a10272020-08-06 16:33:36 +09003431 io_delegate_.SetFileContents("Foo.aidl", "@JavaOnlyImmutable parcelable Foo { int a; }");
Jooyung Han15fd6c62020-10-23 13:54:46 +09003432 io_delegate_.SetFileContents("IBar.aidl", "interface IBar { void my(out Foo foo); }");
3433 string expected_error =
3434 "ERROR: IBar.aidl:1.33-37: 'foo' can't be an out parameter because @JavaOnlyImmutable can "
3435 "only be an in parameter.\n";
3436 CaptureStderr();
Jeongik Cha36f76c32020-07-28 00:25:52 +09003437 Options options = Options::From("aidl --lang=java IBar.aidl -I .");
3438 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jooyung Han15fd6c62020-10-23 13:54:46 +09003439 EXPECT_EQ(expected_error, GetCapturedStderr());
Jeongik Cha36f76c32020-07-28 00:25:52 +09003440}
3441
Jooyung Han66813932020-10-23 13:24:44 +09003442TEST_F(AidlTest, ImmutableParcelableFieldNameRestriction) {
Jeongik Chad0a10272020-08-06 16:33:36 +09003443 io_delegate_.SetFileContents("Foo.aidl", "@JavaOnlyImmutable parcelable Foo { int a; int A; }");
Jeongik Cha91180252020-07-31 15:43:11 +09003444 Options options = Options::From("aidl --lang=java Foo.aidl");
3445 const string expected_stderr =
Jooyung Han59af9cc2020-10-25 21:44:14 +09003446 "ERROR: Foo.aidl:1.47-49: 'Foo' has duplicate field name 'A' after capitalizing the first "
3447 "letter\n";
Jeongik Cha91180252020-07-31 15:43:11 +09003448 CaptureStderr();
3449 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3450 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3451}
Devin Moore53fc99c2020-08-12 08:07:52 -07003452
Jooyung Hanfe086af2021-01-16 03:44:47 +09003453TEST_P(AidlTest, UnionInUnion) {
3454 import_paths_.insert(".");
3455 io_delegate_.SetFileContents("Bar.aidl", "union Bar { int n = 42; long l; }");
3456 CaptureStderr();
3457 EXPECT_NE(nullptr, Parse("Foo.aidl", "union Foo { Bar b; int n; }", typenames_, GetLanguage()));
3458 EXPECT_THAT("", GetCapturedStderr());
3459}
3460
Jooyung Hanfe89f122020-10-14 03:49:18 +09003461TEST_P(AidlTest, UnionRejectsEmptyDecl) {
3462 const string method = "package a; union Foo {}";
3463 const string expected_stderr = "ERROR: a/Foo.aidl:1.17-21: The union 'Foo' has no fields.\n";
3464 CaptureStderr();
3465 EXPECT_EQ(nullptr, Parse("a/Foo.aidl", method, typenames_, GetLanguage()));
3466 EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr(expected_stderr));
3467}
3468
3469TEST_P(AidlTest, UnionRejectsParcelableHolder) {
3470 const string method = "package a; union Foo { ParcelableHolder x; }";
3471 const string expected_stderr =
3472 "ERROR: a/Foo.aidl:1.40-42: A union can't have a member of ParcelableHolder 'x'\n";
3473 CaptureStderr();
3474 EXPECT_EQ(nullptr, Parse("a/Foo.aidl", method, typenames_, GetLanguage()));
3475 EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr(expected_stderr));
3476}
3477
Jooyung Han53fb4242020-12-17 16:03:49 +09003478TEST_P(AidlTest, UnionRejectsFirstEnumWithNoDefaults) {
3479 import_paths_.insert(".");
3480 io_delegate_.SetFileContents("a/Enum.aidl", "package a; enum Enum { FOO, BAR }");
3481 const string expected_err = "The union's first member should have a useful default value.";
3482 CaptureStderr();
3483 EXPECT_EQ(nullptr,
3484 Parse("a/Foo.aidl", "package a; union Foo { a.Enum e; }", typenames_, GetLanguage()));
3485 EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr(expected_err));
3486}
3487
Devin Moore53fc99c2020-08-12 08:07:52 -07003488TEST_P(AidlTest, GenericStructuredParcelable) {
3489 io_delegate_.SetFileContents("Foo.aidl", "parcelable Foo<T, U> { int a; int A; }");
Jooyung Han9435e9a2021-01-06 10:16:31 +09003490 Options options = Options::From("aidl Foo.aidl --lang=" + to_string(GetLanguage()));
Devin Moore53fc99c2020-08-12 08:07:52 -07003491 const string expected_stderr = "";
3492 CaptureStderr();
3493 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3494 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3495}
3496
Jooyung Han3f347ca2020-12-01 12:41:50 +09003497TEST_F(AidlTest, GenericStructuredParcelableWithStringConstants_Cpp) {
3498 io_delegate_.SetFileContents("Foo.aidl",
3499 "parcelable Foo<T, U> { int a; const String s = \"\"; }");
3500 Options options =
Jooyung Han9435e9a2021-01-06 10:16:31 +09003501 Options::From("aidl Foo.aidl --lang=" + to_string(Options::Language::CPP) + " -o out -h out");
Jooyung Han3f347ca2020-12-01 12:41:50 +09003502 const string expected_stderr = "";
3503 CaptureStderr();
3504 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3505 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3506
3507 string code;
3508 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/Foo.h", &code));
3509 EXPECT_THAT(code, testing::HasSubstr(R"--(template <typename T, typename U>
3510const ::android::String16& Foo<T,U>::s() {
3511 static const ::android::String16 value(::android::String16(""));
3512 return value;
3513})--"));
3514}
3515
3516TEST_F(AidlTest, GenericStructuredParcelableWithStringConstants_Ndk) {
3517 io_delegate_.SetFileContents("Foo.aidl",
3518 "parcelable Foo<T, U> { int a; const String s = \"\"; }");
3519 Options options =
Jooyung Han9435e9a2021-01-06 10:16:31 +09003520 Options::From("aidl Foo.aidl --lang=" + to_string(Options::Language::NDK) + " -o out -h out");
Jooyung Han3f347ca2020-12-01 12:41:50 +09003521 const string expected_stderr = "";
3522 CaptureStderr();
3523 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3524 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3525
3526 string code;
3527 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/aidl/Foo.h", &code));
3528 EXPECT_THAT(code, testing::HasSubstr(R"--(template <typename T, typename U>
3529const char* Foo<T, U>::s = "";
3530)--"));
3531}
3532
Jooyung Han8c9a4e12020-10-26 15:39:54 +09003533TEST_F(AidlTest, NestedTypeArgs) {
3534 io_delegate_.SetFileContents("a/Bar.aidl", "package a; parcelable Bar<A> { }");
Steven Moreland6c07b832020-10-29 23:39:53 +00003535 io_delegate_.SetFileContents("a/Baz.aidl", "package a; parcelable Baz<A, B> { }");
3536
3537 io_delegate_.SetFileContents("a/Foo.aidl",
3538 "package a; import a.Bar; import a.Baz; parcelable Foo { "
3539 "Baz<Bar<Bar<String[]>>[], Bar<String>> barss; }");
Jooyung Han8c9a4e12020-10-26 15:39:54 +09003540 Options options = Options::From("aidl a/Foo.aidl -I . -o out --lang=java");
3541 const string expected_stderr = "";
3542 CaptureStderr();
3543 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3544 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3545
3546 string code;
3547 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/Foo.java", &code));
Steven Moreland6c07b832020-10-29 23:39:53 +00003548 EXPECT_THAT(code,
3549 testing::HasSubstr(
3550 "a.Baz<a.Bar<a.Bar<java.lang.String[]>>[],a.Bar<java.lang.String>> barss;"));
3551}
3552
3553TEST_F(AidlTest, DoubleArrayError) {
3554 io_delegate_.SetFileContents("a/Bar.aidl", "package a; parcelable Bar { String[][] a; }");
3555
3556 Options options = Options::From("aidl a/Bar.aidl -I . -o out --lang=java");
3557 const string expected_stderr =
3558 "ERROR: a/Bar.aidl:1.28-37: Can only have one dimensional arrays.\n";
3559 CaptureStderr();
3560 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3561 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3562}
3563
3564TEST_F(AidlTest, DoubleGenericError) {
3565 io_delegate_.SetFileContents("a/Bar.aidl",
3566 "package a; parcelable Bar { List<String><String> a; }");
3567
3568 Options options = Options::From("aidl a/Bar.aidl -I . -o out --lang=java");
3569 const string expected_stderr =
3570 "ERROR: a/Bar.aidl:1.28-33: Can only specify one set of type parameters.\n";
3571 CaptureStderr();
3572 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3573 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3574}
3575
3576TEST_F(AidlTest, ArrayBeforeGenericError) {
3577 io_delegate_.SetFileContents("a/Bar.aidl", "package a; parcelable Bar { List[]<String> a; }");
3578
3579 Options options = Options::From("aidl a/Bar.aidl -I . -o out --lang=java");
Steven Moreland6c07b832020-10-29 23:39:53 +00003580 CaptureStderr();
3581 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
Jooyung Han97c324a2021-02-15 16:09:51 +09003582 EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr("syntax error, unexpected '<'"));
3583}
3584
3585TEST_F(AidlTest, NullableArraysAreNotSupported) {
3586 io_delegate_.SetFileContents("a/Bar.aidl",
3587 "package a; parcelable Bar { String @nullable [] a; }");
3588
3589 Options options = Options::From("aidl a/Bar.aidl -I . -o out --lang=java");
3590 CaptureStderr();
3591 EXPECT_EQ(1, ::android::aidl::compile_aidl(options, io_delegate_));
3592 EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr("Annotations for arrays are not supported."));
3593}
3594
3595TEST_F(AidlTest, ListOfNullablesAreNotSupported) {
3596 io_delegate_.SetFileContents("a/Bar.aidl",
3597 "package a; parcelable Bar { List<@nullable String> a; }");
3598
3599 Options options = Options::From("aidl a/Bar.aidl -I . -o out --lang=java");
3600 CaptureStderr();
3601 EXPECT_EQ(1, ::android::aidl::compile_aidl(options, io_delegate_));
3602 EXPECT_THAT(GetCapturedStderr(),
3603 testing::HasSubstr("Annotations for type arguments are not supported."));
Jooyung Han8c9a4e12020-10-26 15:39:54 +09003604}
3605
Jooyung Han14004ed2020-10-16 03:49:57 +09003606struct GenericAidlTest : ::testing::Test {
3607 FakeIoDelegate io_delegate_;
3608 void Compile(string cmd) {
Steven Moreland6c07b832020-10-29 23:39:53 +00003609 io_delegate_.SetFileContents("Foo.aidl", "parcelable Foo { Bar<Baz<Qux>> x; }");
Jooyung Han14004ed2020-10-16 03:49:57 +09003610 io_delegate_.SetFileContents("Bar.aidl", "parcelable Bar<T> { }");
3611 io_delegate_.SetFileContents("Baz.aidl", "parcelable Baz<T> { }");
3612 io_delegate_.SetFileContents("Qux.aidl", "parcelable Qux { }");
3613
3614 Options options = Options::From(cmd);
3615 CaptureStderr();
3616 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3617 EXPECT_EQ("", GetCapturedStderr());
3618 }
3619};
3620
3621TEST_F(GenericAidlTest, ImportGenericParameterTypesCPP) {
3622 Compile("aidl Foo.aidl --lang=cpp -I . -o out -h out");
3623 string code;
3624 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/Foo.h", &code));
3625 EXPECT_THAT(code, testing::HasSubstr("#include <Bar.h>"));
3626 EXPECT_THAT(code, testing::HasSubstr("#include <Baz.h>"));
3627 EXPECT_THAT(code, testing::HasSubstr("#include <Qux.h>"));
3628}
3629
3630TEST_F(GenericAidlTest, ImportGenericParameterTypesNDK) {
3631 Compile("aidl Foo.aidl --lang=ndk -I . -o out -h out");
3632 string code;
3633 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/aidl/Foo.h", &code));
3634 EXPECT_THAT(code, testing::HasSubstr("#include <aidl/Bar.h>"));
3635 EXPECT_THAT(code, testing::HasSubstr("#include <aidl/Baz.h>"));
3636 EXPECT_THAT(code, testing::HasSubstr("#include <aidl/Qux.h>"));
3637}
3638
Devin Moore53fc99c2020-08-12 08:07:52 -07003639TEST_P(AidlTest, RejectGenericStructuredParcelabelRepeatedParam) {
3640 io_delegate_.SetFileContents("Foo.aidl", "parcelable Foo<T,T> { int a; int A; }");
Jooyung Han9435e9a2021-01-06 10:16:31 +09003641 Options options = Options::From("aidl Foo.aidl --lang=" + to_string(GetLanguage()));
Devin Moore53fc99c2020-08-12 08:07:52 -07003642 const string expected_stderr =
3643 "ERROR: Foo.aidl:1.11-15: Every type parameter should be unique.\n";
3644 CaptureStderr();
3645 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3646 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3647}
3648
3649TEST_P(AidlTest, RejectGenericStructuredParcelableField) {
3650 io_delegate_.SetFileContents("Foo.aidl", "parcelable Foo<T,T> { T a; int A; }");
Jooyung Han9435e9a2021-01-06 10:16:31 +09003651 Options options = Options::From("aidl Foo.aidl --lang=" + to_string(GetLanguage()));
Devin Moore53fc99c2020-08-12 08:07:52 -07003652 const string expected_stderr = "ERROR: Foo.aidl:1.22-24: Failed to resolve 'T'\n";
3653 CaptureStderr();
3654 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3655 EXPECT_EQ(expected_stderr, GetCapturedStderr());
3656}
3657
Jooyung Han7a308842020-10-27 19:06:49 +09003658TEST_P(AidlTest, LongCommentWithinConstExpression) {
3659 io_delegate_.SetFileContents("Foo.aidl", "enum Foo { FOO = (1 << 1) /* comment */ | 0x0 }");
Jooyung Han9435e9a2021-01-06 10:16:31 +09003660 Options options = Options::From("aidl Foo.aidl --lang=" + to_string(GetLanguage()));
Jooyung Han7a308842020-10-27 19:06:49 +09003661 CaptureStderr();
3662 EXPECT_EQ(0, ::android::aidl::compile_aidl(options, io_delegate_));
3663 EXPECT_EQ("", GetCapturedStderr());
3664}
3665
Jeongik Chaef44e622020-10-23 16:00:52 +09003666TEST_F(AidlTest, RejectUntypdeListAndMapInUnion) {
3667 io_delegate_.SetFileContents("a/Foo.aidl", "package a; union Foo { List l; Map m; }");
3668 Options options = Options::From("aidl a/Foo.aidl --lang=java -o out");
3669 std::string expectedErr =
3670 "ERROR: a/Foo.aidl:1.28-30: "
3671 "Encountered an untyped List or Map. The use of untyped List/Map is "
3672 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
3673 "the receiving side. Consider switching to an array or a generic List/Map.\n"
3674 "ERROR: a/Foo.aidl:1.35-37: "
3675 "Encountered an untyped List or Map. The use of untyped List/Map is "
3676 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
3677 "the receiving side. Consider switching to an array or a generic List/Map.\n";
3678 CaptureStderr();
3679 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3680 EXPECT_EQ(expectedErr, GetCapturedStderr());
3681}
3682
3683TEST_F(AidlTest, RejectUntypdeListAndMapInUnstructuredParcelable) {
Jooyung Hanea2147c2020-10-21 18:16:56 +09003684 io_delegate_.SetFileContents("a/Foo.aidl", "package a; parcelable Foo { List l; Map m; }");
3685 Options options = Options::From("aidl a/Foo.aidl --lang=java -o out");
Jeongik Chaef44e622020-10-23 16:00:52 +09003686 std::string expectedErr =
3687 "ERROR: a/Foo.aidl:1.33-35: "
3688 "Encountered an untyped List or Map. The use of untyped List/Map is "
3689 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
3690 "the receiving side. Consider switching to an array or a generic List/Map.\n"
3691 "ERROR: a/Foo.aidl:1.40-42: "
3692 "Encountered an untyped List or Map. The use of untyped List/Map is "
3693 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
3694 "the receiving side. Consider switching to an array or a generic List/Map.\n";
Jooyung Hanea2147c2020-10-21 18:16:56 +09003695 CaptureStderr();
Jeongik Chaef44e622020-10-23 16:00:52 +09003696 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3697 EXPECT_EQ(expectedErr, GetCapturedStderr());
3698}
Jooyung Hanea2147c2020-10-21 18:16:56 +09003699
Jeongik Chaef44e622020-10-23 16:00:52 +09003700TEST_F(AidlTest, RejectNestedUntypedListAndMap) {
3701 io_delegate_.SetFileContents("a/Bar.aidl", "package a; parcelable Bar<T>;");
3702 io_delegate_.SetFileContents(
3703 "a/Foo.aidl", "package a; import a.Bar; parcelable Foo { Bar<List> a; Bar<Map> b; }");
3704 Options options = Options::From("aidl a/Foo.aidl -I . --lang=java -o out");
3705 std::string expectedErr =
3706 "ERROR: a/Foo.aidl:1.52-54: "
3707 "Encountered an untyped List or Map. The use of untyped List/Map is "
3708 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
3709 "the receiving side. Consider switching to an array or a generic List/Map.\n"
3710 "ERROR: a/Foo.aidl:1.64-66: "
3711 "Encountered an untyped List or Map. The use of untyped List/Map is "
3712 "prohibited because it is not guaranteed that the objects in the list are recognizable in "
3713 "the receiving side. Consider switching to an array or a generic List/Map.\n";
3714 CaptureStderr();
3715 EXPECT_NE(0, ::android::aidl::compile_aidl(options, io_delegate_));
3716 EXPECT_EQ(expectedErr, GetCapturedStderr());
Jooyung Hanea2147c2020-10-21 18:16:56 +09003717}
3718
Jooyung Han690f5842020-12-04 13:02:04 +09003719TEST_F(AidlTest, EnumWithDefaults_Java) {
3720 io_delegate_.SetFileContents("a/p/Enum.aidl", "package p; enum Enum { FOO, BAR }");
3721 io_delegate_.SetFileContents("a/p/Foo.aidl", R"(
3722package p;
3723import p.Enum;
3724parcelable Foo {
3725 Enum e = Enum.BAR;
3726})");
3727 CaptureStderr();
3728 auto options = Options::From("aidl -I a --lang java -o out a/p/Foo.aidl");
3729 EXPECT_EQ(0, aidl::compile_aidl(options, io_delegate_));
3730 auto err = GetCapturedStderr();
3731 EXPECT_EQ("", err);
3732
3733 string code;
3734 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/p/Foo.java", &code));
Jooyung Han2d833612020-12-17 15:59:27 +09003735 EXPECT_THAT(code, testing::HasSubstr("byte e = p.Enum.BAR"));
Jooyung Han690f5842020-12-04 13:02:04 +09003736}
3737
3738TEST_F(AidlTest, EnumWithDefaults_Cpp) {
3739 io_delegate_.SetFileContents("a/p/Enum.aidl", "package p; enum Enum { FOO, BAR }");
3740 io_delegate_.SetFileContents("a/p/Foo.aidl", R"(
3741package p;
3742import p.Enum;
3743parcelable Foo {
3744 Enum e = Enum.BAR;
3745})");
3746 CaptureStderr();
3747 auto options = Options::From("aidl -I a --lang cpp -o out -h out a/p/Foo.aidl");
3748 EXPECT_EQ(0, aidl::compile_aidl(options, io_delegate_));
3749 auto err = GetCapturedStderr();
3750 EXPECT_EQ("", err);
3751
3752 string code;
3753 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/p/Foo.h", &code));
3754 EXPECT_THAT(code, testing::HasSubstr("::p::Enum e = ::p::Enum(::p::Enum::BAR);"));
3755}
3756
3757TEST_F(AidlTest, EnumWithDefaults_Ndk) {
3758 io_delegate_.SetFileContents("a/p/Enum.aidl", "package p; enum Enum { FOO, BAR }");
3759 io_delegate_.SetFileContents("a/p/Foo.aidl", R"(
3760package p;
3761import p.Enum;
3762parcelable Foo {
3763 Enum e = Enum.BAR;
3764})");
3765 CaptureStderr();
3766 auto options = Options::From("aidl -I a --lang ndk -o out -h out a/p/Foo.aidl");
3767 EXPECT_EQ(0, aidl::compile_aidl(options, io_delegate_));
3768 auto err = GetCapturedStderr();
3769 EXPECT_EQ("", err);
3770
3771 string code;
3772 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/aidl/p/Foo.h", &code));
3773 EXPECT_THAT(code, testing::HasSubstr("::aidl::p::Enum e = ::aidl::p::Enum::BAR;"));
3774}
3775
3776TEST_F(AidlTest, EnumWithDefaults_Rust) {
3777 io_delegate_.SetFileContents("a/p/Enum.aidl", "package p; enum Enum { FOO, BAR }");
3778 io_delegate_.SetFileContents("a/p/Foo.aidl", R"(
3779package p;
3780import p.Enum;
3781parcelable Foo {
3782 int n = 42;
3783 Enum e = Enum.BAR;
3784})");
3785 CaptureStderr();
3786 auto options = Options::From("aidl -I a --lang rust -o out -h out a/p/Foo.aidl");
3787 EXPECT_EQ(0, aidl::compile_aidl(options, io_delegate_));
3788 auto err = GetCapturedStderr();
3789 EXPECT_EQ("", err);
3790
3791 string code;
3792 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/p/Foo.rs", &code));
3793 EXPECT_THAT(code, testing::HasSubstr(R"(
3794 fn default() -> Self {
3795 Self {
3796 n: 42,
3797 e: crate::mangled::_1_p_4_Enum::BAR,
3798 }
3799 })"));
3800}
3801
3802TEST_P(AidlTest, EnumeratorIsConstantValue_DefaultValue) {
3803 import_paths_.insert("a");
3804 io_delegate_.SetFileContents("a/p/Enum.aidl", "package p; enum Enum { FOO = 1, BAR = 2}");
3805 CaptureStderr();
3806 const AidlDefinedType* type = Parse("a/p/Foo.aidl", R"(
3807package p;
3808import p.Enum;
3809parcelable Foo {
3810 int e = Enum.FOO | Enum.BAR;
3811})",
3812 typenames_, GetLanguage());
3813 auto err = GetCapturedStderr();
3814 EXPECT_EQ("", err);
3815 EXPECT_TRUE(type);
3816 const auto& fields = type->AsStructuredParcelable()->GetFields();
3817 EXPECT_EQ("int e = 3", fields[0]->ToString());
3818}
3819
3820TEST_P(AidlTest, EnumeratorIsConstantValue_CanDefineOtherEnumerator) {
3821 CaptureStderr();
3822 const AidlDefinedType* type = Parse("a/p/Foo.aidl", R"(
3823@Backing(type="int")
3824enum Foo {
3825 STANDARD_SHIFT = 16,
3826 STANDARD_BT709 = 1 << STANDARD_SHIFT,
3827 STANDARD_BT601_625 = 2 << STANDARD_SHIFT,
3828}
3829)",
3830 typenames_, GetLanguage());
3831 auto err = GetCapturedStderr();
3832 EXPECT_EQ("", err);
3833 EXPECT_TRUE(type);
3834 const auto& enum_type = type->AsEnumDeclaration();
3835 string code;
Jooyung Han1f56b702021-02-11 13:16:15 +09003836 auto writer = CodeWriter::ForString(&code);
3837 DumpVisitor visitor(*writer);
3838 visitor.Visit(*enum_type);
3839 writer->Close();
Jooyung Han690f5842020-12-04 13:02:04 +09003840 EXPECT_EQ(R"--(@Backing(type="int")
3841enum Foo {
3842 STANDARD_SHIFT = 16,
3843 STANDARD_BT709 = 65536,
3844 STANDARD_BT601_625 = 131072,
3845}
3846)--",
3847 code);
3848}
3849
3850TEST_F(AidlTest, EnumDefaultShouldBeEnumerators) {
3851 io_delegate_.SetFileContents("a/p/Enum.aidl", "package p; enum Enum { FOO = 1, BAR = 2}");
3852 io_delegate_.SetFileContents("a/p/Foo.aidl", R"(
3853package p;
3854import p.Enum;
3855parcelable Foo {
3856 Enum e = Enum.FOO | Enum.BAR;
3857})");
3858 CaptureStderr();
3859 auto options = Options::From("aidl -I a --lang java -o out -h out a/p/Foo.aidl");
3860 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
3861 auto err = GetCapturedStderr();
3862 EXPECT_EQ("ERROR: a/p/Foo.aidl:5.11-20: Invalid value (Enum.FOO|Enum.BAR) for enum p.Enum\n",
3863 err);
3864}
3865
Jooyung Han361cd102021-05-24 11:30:10 +09003866TEST_F(AidlTest, EnumDefaultShouldBeEnumerators_RejectsNumericValue) {
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 = 1;
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 EXPECT_THAT(GetCapturedStderr(), HasSubstr("Invalid value (1) for enum p.Enum"));
3878}
3879
Jooyung Han690f5842020-12-04 13:02:04 +09003880TEST_P(AidlTest, DefaultWithEmptyArray) {
3881 io_delegate_.SetFileContents("a/p/Foo.aidl", "package p; parcelable Foo { p.Bar[] bars = {}; }");
3882 io_delegate_.SetFileContents("a/p/Bar.aidl", "package p; parcelable Bar { }");
3883 CaptureStderr();
Jooyung Han9435e9a2021-01-06 10:16:31 +09003884 auto options =
3885 Options::From("aidl -I a --lang " + to_string(GetLanguage()) + " -o out -h out a/p/Foo.aidl");
Jooyung Han690f5842020-12-04 13:02:04 +09003886 EXPECT_EQ(0, aidl::compile_aidl(options, io_delegate_));
3887 auto err = GetCapturedStderr();
3888 EXPECT_EQ("", err);
3889}
3890
3891TEST_P(AidlTest, RejectRefsInAnnotation) {
3892 io_delegate_.SetFileContents("a/p/IFoo.aidl",
3893 "package p; interface IFoo {\n"
3894 " const String ANNOTATION = \"@Annotation\";\n"
3895 " @JavaPassthrough(annotation=ANNOTATION) void foo();\n"
3896 "}");
3897 CaptureStderr();
Jooyung Han9435e9a2021-01-06 10:16:31 +09003898 auto options =
3899 Options::From("aidl --lang " + to_string(GetLanguage()) + " -o out -h out a/p/IFoo.aidl");
Jooyung Han690f5842020-12-04 13:02:04 +09003900 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
3901 auto err = GetCapturedStderr();
3902 EXPECT_EQ(
3903 "ERROR: a/p/IFoo.aidl:3.31-41: Value must be a constant expression but contains reference to "
3904 "ANNOTATION.\n",
3905 err);
3906}
3907
3908TEST_F(AidlTest, DefaultWithEnumValues) {
3909 io_delegate_.SetFileContents(
3910 "a/p/Foo.aidl",
3911 "package p; import p.Bar; parcelable Foo { Bar[] bars = { Bar.FOO, Bar.FOO }; }");
3912 io_delegate_.SetFileContents("a/p/Bar.aidl", "package p; enum Bar { FOO, BAR }");
3913 CaptureStderr();
3914 auto options = Options::From("aidl -I a --lang ndk -o out -h out a/p/Foo.aidl");
3915 EXPECT_EQ(0, aidl::compile_aidl(options, io_delegate_));
3916 auto err = GetCapturedStderr();
3917 EXPECT_EQ("", err);
3918 string code;
3919 EXPECT_TRUE(io_delegate_.GetWrittenContents("out/aidl/p/Foo.h", &code));
3920 EXPECT_THAT(
3921 code, testing::HasSubstr(
3922 "std::vector<::aidl::p::Bar> bars = {::aidl::p::Bar::FOO, ::aidl::p::Bar::FOO};"));
3923}
3924
Jooyung Han14259392020-12-07 10:00:08 +09003925TEST_F(AidlTest, RejectsCircularReferencingEnumerators) {
3926 io_delegate_.SetFileContents("a/p/Foo.aidl", "package p; enum Foo { A = B, B }");
3927 CaptureStderr();
3928 auto options = Options::From("aidl -I a --lang ndk -o out -h out a/p/Foo.aidl");
3929 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
3930 auto err = GetCapturedStderr();
Jooyung Hanb9d60e02021-05-21 07:54:17 +09003931 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 +09003932}
3933
3934TEST_F(AidlTest, RejectsCircularReferencingConsts) {
3935 io_delegate_.SetFileContents("a/p/Foo.aidl",
3936 "package p; parcelable Foo { const int A = A + 1; }");
3937 CaptureStderr();
3938 auto options = Options::From("aidl -I a --lang ndk -o out -h out a/p/Foo.aidl");
3939 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
3940 auto err = GetCapturedStderr();
Jooyung Han29813842020-12-08 01:28:03 +09003941 EXPECT_EQ("ERROR: a/p/Foo.aidl:1.42-44: Found a circular reference: A -> A\n", err);
3942}
3943
3944TEST_F(AidlTest, RecursiveReferences) {
3945 io_delegate_.SetFileContents("a/p/Foo.aidl",
3946 "package p; parcelable Foo { const int A = p.Bar.A + 1; }");
3947 io_delegate_.SetFileContents("a/p/Bar.aidl",
3948 "package p; parcelable Bar { const int A = p.Baz.A + 1; }");
3949 io_delegate_.SetFileContents("a/p/Baz.aidl", "package p; parcelable Baz { const int A = 1; }");
3950 CaptureStderr();
3951 auto options = Options::From("aidl -I a --lang ndk -o out -h out a/p/Foo.aidl");
3952 EXPECT_EQ(0, aidl::compile_aidl(options, io_delegate_));
3953 EXPECT_EQ("", GetCapturedStderr());
3954}
3955
Jooyung Hanb9d60e02021-05-21 07:54:17 +09003956TEST_P(AidlTest, CircularReferenceWithFullyQualified) {
3957 io_delegate_.SetFileContents("Foo.aidl", "enum Foo { A = Foo.A }");
3958 auto options =
3959 Options::From("aidl --lang " + to_string(GetLanguage()) + " -I . -o out -h out Foo.aidl");
3960 const string err = "ERROR: Foo.aidl:1.15-21: Found a circular reference: Foo.A -> Foo.A\n";
3961 CaptureStderr();
3962 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
3963 EXPECT_EQ(err, GetCapturedStderr());
3964}
3965
3966TEST_P(AidlTest, ConstRefsCanPointToTheSameValue) {
3967 io_delegate_.SetFileContents("Foo.aidl", "enum Foo { A = 0 }");
3968 // this demonstrates the case that "Foo.A" const-ref node is visited twice by B and C.
3969 io_delegate_.SetFileContents("Bar.aidl", "enum Bar { A = Foo.A, B = A, C = A }");
3970 auto options =
3971 Options::From("aidl --lang " + to_string(GetLanguage()) + " -I . -o out -h out Bar.aidl");
3972 CaptureStderr();
3973 EXPECT_EQ(0, aidl::compile_aidl(options, io_delegate_));
3974 EXPECT_EQ("", GetCapturedStderr());
3975}
3976
Jooyung Hane9f5b272021-01-07 00:18:11 +09003977TEST_P(AidlTest, UnknownConstReference) {
3978 io_delegate_.SetFileContents("Foo.aidl", " parcelable Foo { UnknownType field = UNKNOWN_REF; }");
3979 auto options =
3980 Options::From("aidl --lang " + to_string(GetLanguage()) + " -o out -h out Foo.aidl");
3981 const string err =
3982 "ERROR: Foo.aidl:1.18-30: Failed to resolve 'UnknownType'\n"
3983 "ERROR: Foo.aidl:1.38-50: Can't find UNKNOWN_REF in Foo\n"
3984 "ERROR: Foo.aidl:1.38-50: Unknown reference 'UNKNOWN_REF'\n";
3985 CaptureStderr();
3986 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
3987 EXPECT_EQ(err, GetCapturedStderr());
3988}
3989
Jooyung Han29813842020-12-08 01:28:03 +09003990TEST_P(AidlTest, JavaCompatibleBuiltinTypes) {
3991 string contents = R"(
3992import android.os.IBinder;
3993import android.os.IInterface;
3994interface IFoo {}
3995 )";
3996 EXPECT_NE(nullptr, Parse("IFoo.aidl", contents, typenames_, GetLanguage()));
Jooyung Han14259392020-12-07 10:00:08 +09003997}
3998
Jooyung Han888c5bc2020-12-22 17:28:47 +09003999TEST_P(AidlTest, WarningInterfaceName) {
4000 io_delegate_.SetFileContents("p/Foo.aidl", "interface Foo {}");
Jooyung Han9435e9a2021-01-06 10:16:31 +09004001 auto options = Options::From("aidl --lang " + to_string(GetLanguage()) +
Jooyung Han888c5bc2020-12-22 17:28:47 +09004002 " -Weverything -o out -h out p/Foo.aidl");
4003 CaptureStderr();
4004 EXPECT_EQ(0, aidl::compile_aidl(options, io_delegate_));
Jooyung Han808a2a02020-12-28 16:46:54 +09004005 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 +09004006 GetCapturedStderr());
4007}
4008
4009TEST_P(AidlTest, ErrorInterfaceName) {
4010 io_delegate_.SetFileContents("p/Foo.aidl", "interface Foo {}");
Jooyung Han9435e9a2021-01-06 10:16:31 +09004011 auto options = Options::From("aidl --lang " + to_string(GetLanguage()) +
Jooyung Han888c5bc2020-12-22 17:28:47 +09004012 " -Weverything -Werror -o out -h out p/Foo.aidl");
4013 CaptureStderr();
4014 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
Jooyung Han808a2a02020-12-28 16:46:54 +09004015 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 +09004016 GetCapturedStderr());
4017}
4018
Jiyong Park9f4c3822021-04-07 20:36:45 +09004019TEST_F(AidlTest, RejectsIncorrectOutputFilePathOnLegacyCppInput) {
4020 const std::string input_file = "base/p/q/IFoo.aidl";
4021 const std::string header_dir = "out/";
4022 const std::string output_file = "out/base/p/q/IFoo.cpp";
4023 const std::string package = "p.q"; // not base.p.q
4024 io_delegate_.SetFileContents(input_file, "package " + package + "; interface IFoo {}");
4025
4026 auto options = Options::From({"aidl-cpp", input_file, header_dir, output_file});
4027 CaptureStderr();
4028 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
4029 EXPECT_THAT(
4030 GetCapturedStderr(),
4031 testing::StartsWith(
4032 "ERROR: base/p/q/IFoo.aidl:1.13-23: Output file is expected to be at out/p/q/IFoo.cpp, "
4033 "but is out/base/p/q/IFoo.cpp."));
4034}
4035
Jooyung Hanb7a60ec2021-01-21 13:47:59 +09004036TEST_F(AidlTest, FormatCommentsForJava) {
4037 using android::aidl::FormatCommentsForJava;
4038
4039 struct TestCase {
4040 vector<Comment> comments;
4041 string formatted;
4042 };
4043 vector<TestCase> testcases = {
4044 {{}, ""},
4045 {{{"// line comments\n"}}, "// line comments\n"},
4046 {{{"// @hide \n"}}, "// @hide \n"},
4047 // Transform the last block comment as Javadoc.
4048 {{{"/*\n"
4049 " * Hello, world!\n"
4050 " */"}},
4051 "/**\n"
4052 " * Hello, world!\n"
4053 " */"},
4054 {{{"/* @hide */"}}, "/** @hide */"},
4055 {{{"/**\n"
4056 " @param foo ...\n"
4057 "*/"}},
4058 "/**\n"
4059 " @param foo ...\n"
4060 "*/"},
4061 {{{"/* @hide */"}, {"/* @hide */"}}, "/* @hide *//** @hide */"},
4062 {{{"/* @deprecated first */"}, {"/* @deprecated second */"}},
4063 "/* @deprecated first *//** @deprecated second */"},
4064 {{{"/* @deprecated */"}, {"/** @param foo */"}}, "/* @deprecated *//** @param foo */"},
4065 // Line comments are printed as they are
4066 {{{"/* @deprecated */"}, {"// line comments\n"}}, "/* @deprecated */// line comments\n"},
4067 };
4068 for (const auto& [input, formatted] : testcases) {
4069 EXPECT_EQ(formatted, FormatCommentsForJava(input));
4070 }
4071}
4072
Jooyung Han2d6b5c42021-01-09 01:01:06 +09004073TEST_F(AidlTest, HideIsNotForArgs) {
4074 io_delegate_.SetFileContents("IFoo.aidl",
4075 "interface IFoo {\n"
4076 " void foo(in @Hide int x);\n"
4077 "}");
4078 auto options = Options::From("aidl --lang=java IFoo.aidl");
4079 CaptureStderr();
4080 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
4081 EXPECT_THAT(GetCapturedStderr(), HasSubstr("@Hide is not available"));
4082}
4083
4084TEST_F(AidlTest, SuppressWarningsIsNotForArgs) {
4085 io_delegate_.SetFileContents(
4086 "IFoo.aidl",
4087 "interface IFoo {\n"
4088 " void foo(in @SuppressWarnings(value=\"inout-parameter\") int x);\n"
4089 "}");
4090 auto options = Options::From("aidl --lang=java IFoo.aidl");
4091 CaptureStderr();
4092 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
4093 EXPECT_THAT(GetCapturedStderr(), HasSubstr("@SuppressWarnings is not available"));
4094}
4095
Jooyung Hanfa181932021-06-12 07:56:53 +09004096TEST_F(AidlTest, VoidCantBeUsedInMethodParameterType) {
4097 io_delegate_.SetFileContents("p/IFoo.aidl", "interface IFoo{ void j(void n);}");
4098 auto options = Options::From("aidl --lang=java -o out p/IFoo.aidl");
4099 CaptureStderr();
4100 EXPECT_EQ(1, aidl::compile_aidl(options, io_delegate_));
4101 EXPECT_THAT(GetCapturedStderr(), HasSubstr("'void' is an invalid type for the parameter 'n'"));
4102}
4103
Jooyung Hanfd3be322020-12-13 09:11:06 +09004104struct TypeParam {
Jooyung Hane87cdd02020-12-11 16:47:35 +09004105 string kind;
4106 string literal;
4107};
4108
Jooyung Hanfd3be322020-12-13 09:11:06 +09004109const TypeParam kTypeParams[] = {
Jooyung Hancea89002021-02-15 17:04:04 +09004110 {"primitive", "int"}, {"primitiveArray", "int[]"},
4111 {"String", "String"}, {"StringArray", "String[]"},
Jooyung Hane87cdd02020-12-11 16:47:35 +09004112 {"IBinder", "IBinder"}, {"ParcelFileDescriptor", "ParcelFileDescriptor"},
4113 {"parcelable", "Foo"}, {"enum", "a.Enum"},
4114 {"union", "a.Union"}, {"interface", "a.IBar"},
4115};
4116
4117const std::map<std::string, std::string> kListSupportExpectations = {
4118 {"cpp_primitive", "A generic type cannot have any primitive type parameters."},
4119 {"java_primitive", "A generic type cannot have any primitive type parameters."},
4120 {"ndk_primitive", "A generic type cannot have any primitive type parameters."},
4121 {"rust_primitive", "A generic type cannot have any primitive type parameters."},
Jooyung Hancea89002021-02-15 17:04:04 +09004122 {"cpp_primitiveArray", "List of arrays is not supported."},
4123 {"java_primitiveArray", "List of arrays is not supported."},
4124 {"ndk_primitiveArray", "List of arrays is not supported."},
4125 {"rust_primitiveArray", "List of arrays is not supported."},
Jooyung Hane87cdd02020-12-11 16:47:35 +09004126 {"cpp_String", ""},
4127 {"java_String", ""},
4128 {"ndk_String", ""},
4129 {"rust_String", ""},
Jooyung Hancea89002021-02-15 17:04:04 +09004130 {"cpp_StringArray", "List of arrays is not supported."},
4131 {"java_StringArray", "List of arrays is not supported."},
4132 {"ndk_StringArray", "List of arrays is not supported."},
4133 {"rust_StringArray", "List of arrays is not supported."},
Jooyung Hane87cdd02020-12-11 16:47:35 +09004134 {"cpp_IBinder", ""},
4135 {"java_IBinder", ""},
4136 {"ndk_IBinder", "List<IBinder> is not supported. List in NDK doesn't support IBinder."},
4137 {"rust_IBinder", ""},
Jooyung Han55f96ad2020-12-13 10:08:33 +09004138 {"cpp_ParcelFileDescriptor", ""},
Jooyung Hane87cdd02020-12-11 16:47:35 +09004139 {"java_ParcelFileDescriptor", ""},
4140 {"ndk_ParcelFileDescriptor", ""},
4141 {"rust_ParcelFileDescriptor", ""},
Jooyung Han55f96ad2020-12-13 10:08:33 +09004142 {"cpp_interface", "List<a.IBar> is not supported."},
4143 {"java_interface", "List<a.IBar> is not supported."},
4144 {"ndk_interface", "List<a.IBar> is not supported."},
4145 {"rust_interface", "List<a.IBar> is not supported."},
4146 {"cpp_parcelable", ""},
Jooyung Hane87cdd02020-12-11 16:47:35 +09004147 {"java_parcelable", ""},
4148 {"ndk_parcelable", ""},
4149 {"rust_parcelable", ""},
4150 {"cpp_enum", "A generic type cannot have any primitive type parameters."},
4151 {"java_enum", "A generic type cannot have any primitive type parameters."},
4152 {"ndk_enum", "A generic type cannot have any primitive type parameters."},
4153 {"rust_enum", "A generic type cannot have any primitive type parameters."},
Jooyung Han55f96ad2020-12-13 10:08:33 +09004154 {"cpp_union", ""},
Jooyung Hane87cdd02020-12-11 16:47:35 +09004155 {"java_union", ""},
4156 {"ndk_union", ""},
4157 {"rust_union", ""},
4158};
4159
Jooyung Hand236e552020-12-13 09:21:27 +09004160const std::map<std::string, std::string> kArraySupportExpectations = {
4161 {"cpp_primitive", ""},
4162 {"java_primitive", ""},
4163 {"ndk_primitive", ""},
4164 {"rust_primitive", ""},
Jooyung Hancea89002021-02-15 17:04:04 +09004165 {"cpp_primitiveArray", "Can only have one dimensional arrays."},
4166 {"java_primitiveArray", "Can only have one dimensional arrays."},
4167 {"ndk_primitiveArray", "Can only have one dimensional arrays."},
4168 {"rust_primitiveArray", "Can only have one dimensional arrays."},
Jooyung Hand236e552020-12-13 09:21:27 +09004169 {"cpp_String", ""},
4170 {"java_String", ""},
4171 {"ndk_String", ""},
4172 {"rust_String", ""},
Jooyung Hancea89002021-02-15 17:04:04 +09004173 {"cpp_StringArray", "Can only have one dimensional arrays."},
4174 {"java_StringArray", "Can only have one dimensional arrays."},
4175 {"ndk_StringArray", "Can only have one dimensional arrays."},
4176 {"rust_StringArray", "Can only have one dimensional arrays."},
Jooyung Hand236e552020-12-13 09:21:27 +09004177 {"cpp_IBinder", ""},
4178 {"java_IBinder", ""},
4179 {"ndk_IBinder", "The ndk backend does not support array of IBinder"},
4180 {"rust_IBinder", "The rust backend does not support array of IBinder"},
4181 {"cpp_ParcelFileDescriptor", ""},
4182 {"java_ParcelFileDescriptor", ""},
4183 {"ndk_ParcelFileDescriptor", ""},
4184 {"rust_ParcelFileDescriptor", ""},
4185 {"cpp_interface", "Binder type cannot be an array"},
4186 {"java_interface", "Binder type cannot be an array"},
4187 {"ndk_interface", "Binder type cannot be an array"},
4188 {"rust_interface", "Binder type cannot be an array"},
4189 {"cpp_parcelable", ""},
4190 {"java_parcelable", ""},
4191 {"ndk_parcelable", ""},
4192 {"rust_parcelable", ""},
4193 {"cpp_enum", ""},
4194 {"java_enum", ""},
4195 {"ndk_enum", ""},
4196 {"rust_enum", ""},
4197 {"cpp_union", ""},
4198 {"java_union", ""},
4199 {"ndk_union", ""},
4200 {"rust_union", ""},
4201};
4202
Jooyung Hanfd3be322020-12-13 09:11:06 +09004203class AidlTypeParamTest : public testing::TestWithParam<std::tuple<Options::Language, TypeParam>> {
Jooyung Hane87cdd02020-12-11 16:47:35 +09004204 public:
Jooyung Hanfd3be322020-12-13 09:11:06 +09004205 void Run(const std::string& generic_type_decl,
4206 const std::map<std::string, std::string>& expectations) {
Jooyung Hane87cdd02020-12-11 16:47:35 +09004207 const auto& param = GetParam();
Jooyung Han9435e9a2021-01-06 10:16:31 +09004208 const auto& lang = to_string(std::get<0>(param));
Jooyung Hane87cdd02020-12-11 16:47:35 +09004209 const auto& kind = std::get<1>(param).kind;
4210
4211 FakeIoDelegate io;
4212 io.SetFileContents("a/IBar.aidl", "package a; interface IBar { }");
4213 io.SetFileContents("a/Enum.aidl", "package a; enum Enum { A }");
4214 io.SetFileContents("a/Union.aidl", "package a; union Union { int a; }");
Jooyung Hanfd3be322020-12-13 09:11:06 +09004215 std::string decl = fmt::format(generic_type_decl, std::get<1>(param).literal);
4216 io.SetFileContents("a/Foo.aidl", "package a; parcelable Foo { " + decl + " f; }");
Jooyung Hane87cdd02020-12-11 16:47:35 +09004217
4218 const auto options =
4219 Options::From(fmt::format("aidl -I . --lang={} a/Foo.aidl -o out -h out", lang));
4220 CaptureStderr();
4221 compile_aidl(options, io);
Jooyung Hanfd3be322020-12-13 09:11:06 +09004222 auto it = expectations.find(lang + "_" + kind);
4223 EXPECT_TRUE(it != expectations.end());
Jooyung Hane87cdd02020-12-11 16:47:35 +09004224 const string err = GetCapturedStderr();
4225 if (it->second.empty()) {
4226 EXPECT_EQ("", err);
4227 } else {
4228 EXPECT_THAT(err, testing::HasSubstr(it->second));
4229 }
4230 }
4231};
4232
4233INSTANTIATE_TEST_SUITE_P(
Jooyung Hanfd3be322020-12-13 09:11:06 +09004234 AidlTestSuite, AidlTypeParamTest,
Jooyung Hane87cdd02020-12-11 16:47:35 +09004235 testing::Combine(testing::Values(Options::Language::CPP, Options::Language::JAVA,
4236 Options::Language::NDK, Options::Language::RUST),
Jooyung Hanfd3be322020-12-13 09:11:06 +09004237 testing::ValuesIn(kTypeParams)),
4238 [](const testing::TestParamInfo<std::tuple<Options::Language, TypeParam>>& info) {
Jooyung Han9435e9a2021-01-06 10:16:31 +09004239 return to_string(std::get<0>(info.param)) + "_" + std::get<1>(info.param).kind;
Jooyung Hane87cdd02020-12-11 16:47:35 +09004240 });
4241
Jooyung Hanfd3be322020-12-13 09:11:06 +09004242TEST_P(AidlTypeParamTest, ListSupportedTypes) {
4243 Run("List<{}>", kListSupportExpectations);
4244}
Jooyung Hane87cdd02020-12-11 16:47:35 +09004245
Jooyung Hand236e552020-12-13 09:21:27 +09004246TEST_P(AidlTypeParamTest, ArraySupportedTypes) {
4247 Run("{}[]", kArraySupportExpectations);
4248}
4249
Christopher Wiley90be4e32015-10-20 14:55:25 -07004250} // namespace aidl
4251} // namespace android