| /* |
| * Copyright (C) 2015, The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <memory> |
| #include <string> |
| #include <vector> |
| |
| #include <android-base/logging.h> |
| #include <gtest/gtest.h> |
| |
| #include "aidl.h" |
| #include "options.h" |
| #include "tests/fake_io_delegate.h" |
| #include "tests/test_data.h" |
| #include "tests/test_util.h" |
| |
| using android::aidl::test::CanonicalNameToPath; |
| using android::aidl::test::FakeIoDelegate; |
| using std::string; |
| using std::unique_ptr; |
| using std::vector; |
| |
| namespace android { |
| namespace aidl { |
| |
| class EndToEndTest : public ::testing::Test { |
| protected: |
| void SetUp() override { |
| } |
| |
| void AddStubAidls(const char** parcelables, const char** interfaces, |
| const char* cpp_header=nullptr) { |
| for ( ; *parcelables; ++parcelables) { |
| io_delegate_.AddStubParcelable( |
| *parcelables, (cpp_header) ? cpp_header : ""); |
| } |
| for ( ; *interfaces; ++interfaces) { |
| io_delegate_.AddStubInterface(*interfaces); |
| } |
| } |
| |
| void CheckFileContents(const string& rel_path, |
| const string& expected_content) { |
| string actual_content; |
| ASSERT_TRUE(io_delegate_.GetWrittenContents(rel_path, &actual_content)) |
| << "Expected aidl to write to " << rel_path << " but it did not."; |
| |
| if (actual_content == expected_content) { |
| return; // success! |
| } |
| |
| test::PrintDiff(expected_content, actual_content); |
| FAIL() << "Actual contents of " << rel_path |
| << " did not match expected content"; |
| } |
| |
| FakeIoDelegate io_delegate_; |
| }; |
| |
| TEST_F(EndToEndTest, IExampleInterface) { |
| using namespace ::android::aidl::test_data::example_interface; |
| |
| vector<string> args = { |
| "aidl", |
| "-b", |
| "-I .", |
| "-d an/arbitrary/path/to/dep.P", |
| CanonicalNameToPath(kCanonicalName, ".aidl"), |
| kJavaOutputPath}; |
| Options options = Options::From(args); |
| |
| // Load up our fake file system with data. |
| io_delegate_.SetFileContents(options.InputFiles().front(), kInterfaceDefinition); |
| io_delegate_.AddCompoundParcelable("android.test.CompoundParcelable", |
| {"Subclass1", "Subclass2"}); |
| AddStubAidls(kImportedParcelables, kImportedInterfaces); |
| |
| // Check that we parse correctly. |
| EXPECT_EQ(android::aidl::compile_aidl(options, io_delegate_), 0); |
| CheckFileContents(kJavaOutputPath, kExpectedJavaOutput); |
| CheckFileContents(options.DependencyFile(), kExpectedJavaDepsOutput); |
| } |
| |
| TEST_F(EndToEndTest, IExampleInterface_WithTrace) { |
| using namespace ::android::aidl::test_data::example_interface; |
| |
| vector<string> args = { |
| "aidl", |
| "-b", |
| "-I .", |
| "-t", //trace |
| "-d an/arbitrary/path/to/dep.P", |
| CanonicalNameToPath(kCanonicalName, ".aidl"), |
| kJavaOutputPath}; |
| Options options = Options::From(args); |
| |
| // Load up our fake file system with data. |
| io_delegate_.SetFileContents(options.InputFiles().front(), kInterfaceDefinition); |
| io_delegate_.AddCompoundParcelable("android.test.CompoundParcelable", |
| {"Subclass1", "Subclass2"}); |
| AddStubAidls(kImportedParcelables, kImportedInterfaces); |
| |
| // Check that we parse correctly. |
| EXPECT_EQ(android::aidl::compile_aidl(options, io_delegate_), 0); |
| CheckFileContents(kJavaOutputPath, kExpectedJavaOutputWithTrace); |
| CheckFileContents(options.DependencyFile(), kExpectedJavaDepsOutput); |
| } |
| |
| TEST_F(EndToEndTest, IExampleInterface_WithTransactionNames) { |
| using namespace ::android::aidl::test_data::example_interface; |
| |
| vector<string> args = { |
| "aidl", |
| "-b", |
| "-I .", |
| "--transaction_name", //trace |
| "-d an/arbitrary/path/to/dep.P", |
| CanonicalNameToPath(kCanonicalName, ".aidl"), |
| kJavaOutputPath}; |
| Options options = Options::From(args); |
| |
| // Load up our fake file system with data. |
| io_delegate_.SetFileContents(options.InputFiles().front(), kInterfaceDefinition); |
| io_delegate_.AddCompoundParcelable("android.test.CompoundParcelable", |
| {"Subclass1", "Subclass2"}); |
| AddStubAidls(kImportedParcelables, kImportedInterfaces); |
| |
| // Check that we parse correctly. |
| EXPECT_EQ(android::aidl::compile_aidl(options, io_delegate_), 0); |
| CheckFileContents(kJavaOutputPath, kExpectedJavaOutputWithTransactionNames); |
| CheckFileContents(options.DependencyFile(), kExpectedJavaDepsOutput); |
| } |
| |
| TEST_F(EndToEndTest, IExampleInterface_Outlining) { |
| using namespace ::android::aidl::test_data::example_interface; |
| |
| vector<string> args = { |
| "aidl", |
| "-b", |
| "-I .", |
| "-d an/arbitrary/path/to/dep.P", |
| CanonicalNameToPath(kCanonicalName, ".aidl"), |
| kJavaOutputPath}; |
| Options options = Options::From(args); |
| options.onTransact_outline_threshold_ = 4; |
| options.onTransact_non_outline_count_ = 3; |
| |
| // Load up our fake file system with data. |
| io_delegate_.SetFileContents(options.InputFiles().front(), kInterfaceDefinitionOutlining); |
| io_delegate_.AddCompoundParcelable("android.test.CompoundParcelable", |
| {"Subclass1", "Subclass2"}); |
| AddStubAidls(kImportedParcelables, kImportedInterfaces); |
| |
| // Check that we parse correctly. |
| EXPECT_EQ(android::aidl::compile_aidl(options, io_delegate_), 0); |
| CheckFileContents(kJavaOutputPath, kExpectedJavaOutputOutlining); |
| CheckFileContents(options.DependencyFile(), kExpectedJavaDepsOutput); |
| } |
| |
| TEST_F(EndToEndTest, IExampleInterface_WithVersionAndHash) { |
| using namespace ::android::aidl::test_data::example_interface; |
| |
| vector<string> args = { |
| "aidl", |
| "-b", |
| "-I .", |
| "-d an/arbitrary/path/to/dep.P", |
| "--version=10", |
| "--hash=abcdefg", |
| CanonicalNameToPath(kCanonicalName, ".aidl"), |
| kJavaOutputPath}; |
| Options options = Options::From(args); |
| options.onTransact_outline_threshold_ = 4; |
| options.onTransact_non_outline_count_ = 3; |
| |
| // Load up our fake file system with data. |
| io_delegate_.SetFileContents(options.InputFiles().front(), kInterfaceDefinitionOutlining); |
| io_delegate_.AddCompoundParcelable("android.test.CompoundParcelable", |
| {"Subclass1", "Subclass2"}); |
| AddStubAidls(kImportedParcelables, kImportedInterfaces); |
| |
| // Check that we parse correctly. |
| EXPECT_EQ(android::aidl::compile_aidl(options, io_delegate_), 0); |
| CheckFileContents(kJavaOutputPath, kExpectedJavaOutputWithVersionAndHash); |
| CheckFileContents(options.DependencyFile(), kExpectedJavaDepsOutput); |
| } |
| |
| |
| TEST_F(EndToEndTest, IPingResponderCpp) { |
| using namespace ::android::aidl::test_data::ping_responder; |
| |
| vector<string> args = { |
| "aidl-cpp", |
| "-d deps.P", |
| "-I .", |
| CanonicalNameToPath(kCanonicalName, ".aidl"), |
| kGenHeaderDir, |
| kCppOutputPath}; |
| Options options = Options::From(args); |
| |
| // Set up input paths. |
| io_delegate_.SetFileContents(CanonicalNameToPath(kCanonicalName, ".aidl"), kInterfaceDefinition); |
| AddStubAidls(kImportedParcelables, kImportedInterfaces, kCppParcelableHeader); |
| |
| // Check that we parse and generate code correctly. |
| EXPECT_EQ(android::aidl::compile_aidl(options, io_delegate_), 0); |
| CheckFileContents(kCppOutputPath, kExpectedCppOutput); |
| CheckFileContents(kGenInterfaceHeaderPath, kExpectedIHeaderOutput); |
| CheckFileContents(kGenClientHeaderPath, kExpectedBpHeaderOutput); |
| CheckFileContents(kGenServerHeaderPath, kExpectedBnHeaderOutput); |
| CheckFileContents(options.DependencyFile(), kExpectedCppDepsOutput); |
| } |
| |
| TEST_F(EndToEndTest, IPingResponderCpp_WithVersionAndHash) { |
| using namespace ::android::aidl::test_data::ping_responder; |
| |
| vector<string> args = { |
| "aidl-cpp", |
| "-d deps.P", |
| "-I .", |
| "--version=10", |
| "--hash=abcdefg", |
| CanonicalNameToPath(kCanonicalName, ".aidl"), |
| kGenHeaderDir, |
| kCppOutputPath}; |
| Options options = Options::From(args); |
| |
| // Set up input paths. |
| io_delegate_.SetFileContents(CanonicalNameToPath(kCanonicalName, ".aidl"), kInterfaceDefinition); |
| AddStubAidls(kImportedParcelables, kImportedInterfaces, kCppParcelableHeader); |
| |
| // Check that we parse and generate code correctly. |
| EXPECT_EQ(android::aidl::compile_aidl(options, io_delegate_), 0); |
| CheckFileContents(kCppOutputPath, kExpectedCppOutputWithVersionAndHash); |
| CheckFileContents(kGenInterfaceHeaderPath, kExpectedIHeaderOutputWithVersionAndHash); |
| CheckFileContents(kGenClientHeaderPath, kExpectedBpHeaderOutputWithVersionAndHash); |
| CheckFileContents(kGenServerHeaderPath, kExpectedBnHeaderOutputWithVersionAndHash); |
| CheckFileContents(options.DependencyFile(), kExpectedCppDepsOutput); |
| } |
| |
| TEST_F(EndToEndTest, StringConstantsInCpp) { |
| using namespace ::android::aidl::test_data::string_constants; |
| |
| vector<string> args = { |
| "aidl-cpp", |
| CanonicalNameToPath(kCanonicalName, ".aidl"), |
| kGenHeaderDir, |
| kCppOutputPath}; |
| Options options = Options::From(args); |
| |
| // Set up input paths. |
| io_delegate_.SetFileContents(CanonicalNameToPath(kCanonicalName, ".aidl"), kInterfaceDefinition); |
| |
| // Check that we parse and generate code correctly. |
| EXPECT_EQ(android::aidl::compile_aidl(options, io_delegate_), 0); |
| CheckFileContents(kCppOutputPath, kExpectedCppOutput); |
| CheckFileContents(kGenInterfaceHeaderPath, kExpectedIHeaderOutput); |
| } |
| |
| TEST_F(EndToEndTest, StringConstantsInJava) { |
| using namespace ::android::aidl::test_data::string_constants; |
| |
| vector<string> args = { |
| "aidl", |
| "-b", |
| CanonicalNameToPath(kCanonicalName, ".aidl"), |
| kJavaOutputPath}; |
| Options options = Options::From(args); |
| |
| // Load up our fake file system with data. |
| io_delegate_.SetFileContents(CanonicalNameToPath(kCanonicalName, ".aidl"), kInterfaceDefinition); |
| |
| // Check that we parse correctly. |
| EXPECT_EQ(android::aidl::compile_aidl(options, io_delegate_), 0); |
| CheckFileContents(kJavaOutputPath, kExpectedJavaOutput); |
| } |
| |
| TEST_F(EndToEndTest, StringConstantsInCpp_WithVersionAndHash) { |
| using namespace ::android::aidl::test_data::string_constants; |
| |
| vector<string> args = { |
| "aidl-cpp", |
| "--version=10", |
| "--hash=abcdefg", |
| CanonicalNameToPath(kCanonicalName, ".aidl"), |
| kGenHeaderDir, |
| kCppOutputPath}; |
| Options options = Options::From(args); |
| |
| // Set up input paths. |
| io_delegate_.SetFileContents(CanonicalNameToPath(kCanonicalName, ".aidl"), kInterfaceDefinition); |
| |
| // Check that we parse and generate code correctly. |
| EXPECT_EQ(android::aidl::compile_aidl(options, io_delegate_), 0); |
| CheckFileContents(kCppOutputPath, kExpectedCppOutputWithVersionAndHash); |
| CheckFileContents(kGenInterfaceHeaderPath, kExpectedIHeaderOutputWithVersionAndHash); |
| } |
| |
| TEST_F(EndToEndTest, StringConstantsInJava_WithVersionAndHash) { |
| using namespace ::android::aidl::test_data::string_constants; |
| |
| vector<string> args = { |
| "aidl", |
| "-b", |
| "--version=10", |
| "--hash=abcdefg", |
| CanonicalNameToPath(kCanonicalName, ".aidl"), |
| kJavaOutputPath}; |
| Options options = Options::From(args); |
| |
| // Load up our fake file system with data. |
| io_delegate_.SetFileContents(CanonicalNameToPath(kCanonicalName, ".aidl"), kInterfaceDefinition); |
| |
| // Check that we parse correctly. |
| EXPECT_EQ(android::aidl::compile_aidl(options, io_delegate_), 0); |
| CheckFileContents(kJavaOutputPath, kExpectedJavaOutputWithVersionAndHash); |
| } |
| |
| } // namespace aidl |
| } // namespace android |