Android11/system/tools/aidl/tests/end_to_end_tests.cpp

/*
 * 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