| /* |
| * 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: |
| virtual void SetUp() { |
| } |
| |
| 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; |
| |
| JavaOptions options; |
| options.fail_on_parcelable_ = true; |
| options.import_paths_.push_back(""); |
| options.input_file_name_ = CanonicalNameToPath(kCanonicalName, ".aidl"); |
| options.output_file_name_ = kJavaOutputPath; |
| options.dep_file_name_ = "an/arbitrary/path/to/deps.P"; |
| |
| // Load up our fake file system with data. |
| io_delegate_.SetFileContents(options.input_file_name_, kInterfaceDefinition); |
| io_delegate_.AddCompoundParcelable("android.test.CompoundParcelable", |
| {"Subclass1", "Subclass2"}); |
| AddStubAidls(kImportedParcelables, kImportedInterfaces); |
| |
| // Check that we parse correctly. |
| EXPECT_EQ(android::aidl::compile_aidl_to_java(options, io_delegate_), 0); |
| CheckFileContents(kJavaOutputPath, kExpectedJavaOutput); |
| CheckFileContents(options.DependencyFilePath(), kExpectedJavaDepsOutput); |
| } |
| |
| TEST_F(EndToEndTest, IExampleInterface_WithTrace) { |
| using namespace ::android::aidl::test_data::example_interface; |
| |
| JavaOptions options; |
| options.fail_on_parcelable_ = true; |
| options.import_paths_.push_back(""); |
| options.input_file_name_ = CanonicalNameToPath(kCanonicalName, ".aidl"); |
| options.output_file_name_ = kJavaOutputPath; |
| options.dep_file_name_ = "an/arbitrary/path/to/deps.P"; |
| options.gen_traces_ = true; |
| |
| // Load up our fake file system with data. |
| io_delegate_.SetFileContents(options.input_file_name_, kInterfaceDefinition); |
| io_delegate_.AddCompoundParcelable("android.test.CompoundParcelable", |
| {"Subclass1", "Subclass2"}); |
| AddStubAidls(kImportedParcelables, kImportedInterfaces); |
| |
| // Check that we parse correctly. |
| EXPECT_EQ(android::aidl::compile_aidl_to_java(options, io_delegate_), 0); |
| CheckFileContents(kJavaOutputPath, kExpectedJavaOutputWithTrace); |
| CheckFileContents(options.DependencyFilePath(), kExpectedJavaDepsOutput); |
| } |
| |
| TEST_F(EndToEndTest, IExampleInterface_Outlining) { |
| using namespace ::android::aidl::test_data::example_interface; |
| |
| JavaOptions options; |
| options.fail_on_parcelable_ = true; |
| options.import_paths_.push_back(""); |
| options.input_file_name_ = CanonicalNameToPath(kCanonicalName, ".aidl"); |
| options.output_file_name_ = kJavaOutputPath; |
| options.dep_file_name_ = "an/arbitrary/path/to/deps.P"; |
| options.onTransact_outline_threshold_ = 4; |
| options.onTransact_non_outline_count_ = 3; |
| |
| // Load up our fake file system with data. |
| io_delegate_.SetFileContents(options.input_file_name_, kInterfaceDefinitionOutlining); |
| io_delegate_.AddCompoundParcelable("android.test.CompoundParcelable", |
| {"Subclass1", "Subclass2"}); |
| AddStubAidls(kImportedParcelables, kImportedInterfaces); |
| |
| // Check that we parse correctly. |
| EXPECT_EQ(android::aidl::compile_aidl_to_java(options, io_delegate_), 0); |
| CheckFileContents(kJavaOutputPath, kExpectedJavaOutputOutlining); |
| CheckFileContents(options.DependencyFilePath(), kExpectedJavaDepsOutput); |
| } |
| |
| TEST_F(EndToEndTest, IPingResponderCpp) { |
| using namespace ::android::aidl::test_data::ping_responder; |
| |
| const string input_path = CanonicalNameToPath(kCanonicalName, ".aidl"); |
| const string output_file = kCppOutputPath; |
| const size_t argc = 6; |
| const char* cmdline[argc + 1] = { |
| "aidl-cpp", "-ddeps.P", "-I.", input_path.c_str(), kGenHeaderDir, |
| output_file.c_str(), nullptr |
| }; |
| auto options = CppOptions::Parse(argc, cmdline); |
| |
| // Set up input paths. |
| io_delegate_.SetFileContents(input_path, kInterfaceDefinition); |
| AddStubAidls(kImportedParcelables, kImportedInterfaces, kCppParcelableHeader); |
| |
| // Check that we parse and generate code correctly. |
| EXPECT_EQ(android::aidl::compile_aidl_to_cpp(*options, io_delegate_), 0); |
| CheckFileContents(output_file, kExpectedCppOutput); |
| CheckFileContents(kGenInterfaceHeaderPath, kExpectedIHeaderOutput); |
| CheckFileContents(kGenClientHeaderPath, kExpectedBpHeaderOutput); |
| CheckFileContents(kGenServerHeaderPath, kExpectedBnHeaderOutput); |
| CheckFileContents(options->DependencyFilePath(), kExpectedCppDepsOutput); |
| } |
| |
| TEST_F(EndToEndTest, StringConstantsInCpp) { |
| using namespace ::android::aidl::test_data::string_constants; |
| |
| const string input_path = CanonicalNameToPath(kCanonicalName, ".aidl"); |
| const string output_file = kCppOutputPath; |
| const size_t argc = 4; |
| const char* cmdline[argc + 1] = { |
| "aidl-cpp", input_path.c_str(), kGenHeaderDir, |
| output_file.c_str(), nullptr |
| }; |
| auto options = CppOptions::Parse(argc, cmdline); |
| |
| // Set up input paths. |
| io_delegate_.SetFileContents(input_path, kInterfaceDefinition); |
| |
| // Check that we parse and generate code correctly. |
| EXPECT_EQ(android::aidl::compile_aidl_to_cpp(*options, io_delegate_), 0); |
| CheckFileContents(output_file, kExpectedCppOutput); |
| CheckFileContents(kGenInterfaceHeaderPath, kExpectedIHeaderOutput); |
| } |
| |
| TEST_F(EndToEndTest, StringConstantsInJava) { |
| using namespace ::android::aidl::test_data::string_constants; |
| |
| const string input_path = CanonicalNameToPath(kCanonicalName, ".aidl"); |
| const string output_file = kJavaOutputPath; |
| const size_t argc = 4; |
| const char* cmdline[argc + 1] = { |
| "aidl", |
| "-b", |
| input_path.c_str(), |
| output_file.c_str(), |
| nullptr, |
| }; |
| auto options = JavaOptions::Parse(argc, cmdline); |
| |
| // Load up our fake file system with data. |
| io_delegate_.SetFileContents(input_path, kInterfaceDefinition); |
| |
| // Check that we parse correctly. |
| EXPECT_EQ(android::aidl::compile_aidl_to_java(*options, io_delegate_), 0); |
| CheckFileContents(kJavaOutputPath, kExpectedJavaOutput); |
| } |
| |
| } // namespace android |
| } // namespace aidl |