1/*
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
17#include <iostream>
18#include <string>
19#include <vector>
20
21#include <gtest/gtest.h>
22
23#include "options.h"
24
25using std::cerr;
26using std::endl;
27using std::string;
28using std::unique_ptr;
29using std::vector;
30
31namespace android {
32namespace aidl {
33namespace {
34
35const char kPreprocessCommandOutputFile[] = "output_file_name";
36const char kPreprocessCommandInput1[] = "input1";
37const char kPreprocessCommandInput2[] = "input2";
38const char kPreprocessCommandInput3[] = "input3";
39const char* kPreprocessCommand[] = {
40    "aidl", "--preprocess",
41    kPreprocessCommandOutputFile,
42    kPreprocessCommandInput1,
43    kPreprocessCommandInput2,
44    kPreprocessCommandInput3,
45    nullptr,
46};
47
48const char kCompileCommandInput[] = "directory/ITool.aidl";
49const char kCompileCommandIncludePath[] = "-Iinclude_path";
50const char* kCompileJavaCommand[] = {
51    "aidl",
52    "-b",
53    kCompileCommandIncludePath,
54    kCompileCommandInput,
55    nullptr,
56};
57const char kCompileCommandJavaOutput[] = "directory/ITool.java";
58
59const char kCompileDepFileNinja[] = "-ninja";
60const char* kCompileJavaCommandNinja[] = {
61    "aidl",
62    "-b",
63    kCompileDepFileNinja,
64    kCompileCommandIncludePath,
65    kCompileCommandInput,
66    nullptr,
67};
68
69const char kCompileDepFile[] = "-doutput.deps";
70const char kCompileCommandHeaderDir[] = "output/dir";
71const char kCompileCommandCppOutput[] = "some/file.cpp";
72const char* kCompileCppCommand[] = {
73    "aidl-cpp",
74    kCompileCommandIncludePath,
75    kCompileDepFile,
76    kCompileCommandInput,
77    kCompileCommandHeaderDir,
78    kCompileCommandCppOutput,
79    nullptr,
80};
81const char* kCompileCppCommandNinja[] = {
82    "aidl-cpp",
83    kCompileCommandIncludePath,
84    kCompileDepFile,
85    kCompileDepFileNinja,
86    kCompileCommandInput,
87    kCompileCommandHeaderDir,
88    kCompileCommandCppOutput,
89    nullptr,
90};
91
92template <typename T>
93unique_ptr<T> GetOptions(const char* command[]) {
94  int argc = 0;
95  const char** command_part = command;
96  for (; *command_part; ++argc, ++command_part) {}
97  unique_ptr<T> options(T::Parse(argc, command));
98  if (!options) {
99    cerr << "Failed to parse command line:";
100    for (int i = 0; i < argc; ++i) {
101      cerr << " " << command[i];
102      cerr << endl;
103    }
104  }
105  EXPECT_NE(options, nullptr) << "Failed to parse options!";
106  return options;
107}
108
109}  // namespace
110
111TEST(JavaOptionsTests, ParsesPreprocess) {
112  unique_ptr<JavaOptions> options = GetOptions<JavaOptions>(kPreprocessCommand);
113  EXPECT_EQ(JavaOptions::PREPROCESS_AIDL, options->task);
114  EXPECT_EQ(false, options->fail_on_parcelable_);
115  EXPECT_EQ(0u, options->import_paths_.size());
116  EXPECT_EQ(0u, options->preprocessed_files_.size());
117  EXPECT_EQ(string{}, options->input_file_name_);
118  EXPECT_EQ(string{kPreprocessCommandOutputFile}, options->output_file_name_);
119  EXPECT_EQ(false, options->auto_dep_file_);
120  const vector<string> expected_input{kPreprocessCommandInput1,
121                                      kPreprocessCommandInput2,
122                                      kPreprocessCommandInput3};
123  EXPECT_EQ(expected_input, options->files_to_preprocess_);
124}
125
126TEST(JavaOptionsTests, ParsesCompileJava) {
127  unique_ptr<JavaOptions> options =
128      GetOptions<JavaOptions>(kCompileJavaCommand);
129  EXPECT_EQ(JavaOptions::COMPILE_AIDL_TO_JAVA, options->task);
130  EXPECT_EQ(true, options->fail_on_parcelable_);
131  EXPECT_EQ(1u, options->import_paths_.size());
132  EXPECT_EQ(0u, options->preprocessed_files_.size());
133  EXPECT_EQ(string{kCompileCommandInput}, options->input_file_name_);
134  EXPECT_EQ(string{kCompileCommandJavaOutput}, options->output_file_name_);
135  EXPECT_EQ(false, options->auto_dep_file_);
136  EXPECT_EQ(false, options->DependencyFileNinja());
137}
138
139TEST(JavaOptionsTests, ParsesCompileJavaNinja) {
140  unique_ptr<JavaOptions> options =
141      GetOptions<JavaOptions>(kCompileJavaCommandNinja);
142  EXPECT_EQ(JavaOptions::COMPILE_AIDL_TO_JAVA, options->task);
143  EXPECT_EQ(true, options->fail_on_parcelable_);
144  EXPECT_EQ(1u, options->import_paths_.size());
145  EXPECT_EQ(0u, options->preprocessed_files_.size());
146  EXPECT_EQ(string{kCompileCommandInput}, options->input_file_name_);
147  EXPECT_EQ(string{kCompileCommandJavaOutput}, options->output_file_name_);
148  EXPECT_EQ(false, options->auto_dep_file_);
149  EXPECT_EQ(true, options->DependencyFileNinja());
150}
151
152TEST(CppOptionsTests, ParsesCompileCpp) {
153  unique_ptr<CppOptions> options = GetOptions<CppOptions>(kCompileCppCommand);
154  ASSERT_EQ(1u, options->import_paths_.size());
155  EXPECT_EQ(string{kCompileCommandIncludePath}.substr(2),
156            options->import_paths_[0]);
157  EXPECT_EQ(string{kCompileDepFile}.substr(2), options->dep_file_name_);
158  EXPECT_EQ(false, options->DependencyFileNinja());
159  EXPECT_EQ(kCompileCommandInput, options->InputFileName());
160  EXPECT_EQ(kCompileCommandHeaderDir, options->OutputHeaderDir());
161  EXPECT_EQ(kCompileCommandCppOutput, options->OutputCppFilePath());
162}
163
164TEST(CppOptionsTests, ParsesCompileCppNinja) {
165  unique_ptr<CppOptions> options = GetOptions<CppOptions>(kCompileCppCommandNinja);
166  ASSERT_EQ(1u, options->import_paths_.size());
167  EXPECT_EQ(string{kCompileCommandIncludePath}.substr(2),
168            options->import_paths_[0]);
169  EXPECT_EQ(string{kCompileDepFile}.substr(2), options->dep_file_name_);
170  EXPECT_EQ(true, options->DependencyFileNinja());
171  EXPECT_EQ(kCompileCommandInput, options->InputFileName());
172  EXPECT_EQ(kCompileCommandHeaderDir, options->OutputHeaderDir());
173  EXPECT_EQ(kCompileCommandCppOutput, options->OutputCppFilePath());
174}
175
176TEST(OptionsTests, EndsWith) {
177  EXPECT_TRUE(EndsWith("foo", ""));
178  EXPECT_TRUE(EndsWith("foo", "o"));
179  EXPECT_TRUE(EndsWith("foo", "foo"));
180  EXPECT_FALSE(EndsWith("foo", "fooo"));
181  EXPECT_FALSE(EndsWith("", "o"));
182  EXPECT_TRUE(EndsWith("", ""));
183}
184
185TEST(OptionsTests, ReplaceSuffix) {
186  struct test_case_t {
187    const char* input;
188    const char* old_suffix;
189    const char* new_suffix;
190    const char* result;
191  };
192  const size_t kNumCases = 3;
193  test_case_t kTestInput[kNumCases] = {
194    {"foo.bar", "bar", "foo", "foo.foo"},
195    {"whole", "whole", "new", "new"},
196    {"", "", "", ""},
197  };
198  for (const auto& test_case : kTestInput) {
199    string mutated = test_case.input;
200    EXPECT_TRUE(ReplaceSuffix(test_case.old_suffix,
201                              test_case.new_suffix,
202                              &mutated));
203    EXPECT_EQ(mutated, test_case.result);
204  }
205}
206
207}  // namespace android
208}  // namespace aidl
209