| /** |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you 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 "utility/textbased_test/TextBasedTestDriver.hpp" |
| |
| #include <memory> |
| #include <set> |
| #include <sstream> |
| #include <string> |
| #include <vector> |
| |
| #include "utility/Macros.hpp" |
| #include "utility/textbased_test/TextBasedTest.hpp" |
| |
| #include "glog/logging.h" |
| #include "gtest/gtest.h" |
| |
| #define EXPECT_TEXT_CASE(test_case, \ |
| comments_and_options_text, \ |
| option_set, \ |
| test_input_text, \ |
| expected_test_output_text) \ |
| EXPECT_EQ(comments_and_options_text, (test_case)->preceding_text); \ |
| EXPECT_EQ(test_input_text, (test_case)->input_text); \ |
| EXPECT_EQ(expected_test_output_text, (test_case)->expected_output_text); \ |
| EXPECT_EQ(option_set, (test_case)->options) |
| |
| namespace quickstep { |
| |
| class TextBasedTestDriverTest : public ::testing::Test { |
| protected: |
| TextBasedTestDriverTest() |
| : preregistered_options_{"option1", "option2", "option3", "option4", "option5", "option6", "option7", "option8", |
| "option9", "option10"} { |
| } |
| |
| /** |
| * @brief Resets the test driver with the text stored |
| * in \p string_stream and gets test cases. |
| * |
| * @param string_stream The stream where to extract the test cases. |
| * @return A vector of TextBasedTestCases from the input stream. |
| */ |
| std::vector<TextBasedTestCase*>* extractTestCasesFromStream(const std::ostringstream &string_stream) { |
| std::istringstream input_stream(string_stream.str()); |
| test_driver_.reset(new TextBasedTestDriver(&input_stream, nullptr /* test_runner */)); |
| test_driver_->registerOptions(preregistered_options_); |
| return test_driver_->populateAndReturnTestCases(); |
| } |
| |
| std::unique_ptr<TextBasedTestDriver> test_driver_; |
| // Pre-registered options. |
| const std::vector<std::string> preregistered_options_; |
| |
| private: |
| DISALLOW_COPY_AND_ASSIGN(TextBasedTestDriverTest); |
| }; |
| |
| TEST_F(TextBasedTestDriverTest, SingleTestCase) { |
| const std::string comments_and_options = |
| "\n# Comment line 1\n\n" |
| "# Comment line 2\r\n\n" |
| "[option1 option2]\n" |
| "[ option3 option4 option3 ]\n" |
| "[default option5]\n"; |
| const std::string test_input_txt = |
| "input line 1\n\n" |
| "input line 2 \r\n"; |
| const std::string expected_test_output_text = |
| "expected output line 1\n" |
| "----------\n" |
| "expected output line 2\n\n"; |
| |
| std::ostringstream input_text_stream; |
| |
| // Empty input stream is OK. |
| extractTestCasesFromStream(input_text_stream); |
| |
| // Having only comments is also OK. |
| input_text_stream << "# Comment"; |
| extractTestCasesFromStream(input_text_stream); |
| |
| // Having options but no test cases is not allowed. |
| input_text_stream.str(""); |
| input_text_stream << comments_and_options; |
| EXPECT_DEATH(extractTestCasesFromStream(input_text_stream), "Has options but no input test text"); |
| |
| // With a valid test case. |
| input_text_stream << test_input_txt << "--\n" << expected_test_output_text << "==\n"; |
| std::vector<TextBasedTestCase*> *test_cases = |
| extractTestCasesFromStream(input_text_stream); |
| CHECK_EQ(test_cases->size(), 1u); |
| EXPECT_TEXT_CASE((*test_cases)[0], |
| comments_and_options, |
| std::set<std::string>({"option1", "option2", "option3", "option4", "option5"}), |
| test_input_txt, |
| expected_test_output_text); |
| |
| input_text_stream.str(""); |
| // Do not append a test-case separator at the end. |
| input_text_stream << comments_and_options << test_input_txt << "--\n" << expected_test_output_text; |
| test_cases = extractTestCasesFromStream(input_text_stream); |
| |
| // The result should be the same. The last test-case separator can |
| // be omitted. |
| CHECK_EQ(test_cases->size(), 1u); |
| EXPECT_TEXT_CASE((*test_cases)[0], |
| comments_and_options, |
| std::set<std::string>({"option1", "option2", "option3", "option4", "option5"}), |
| test_input_txt, |
| expected_test_output_text); |
| |
| input_text_stream.str(""); |
| // We only require that the input-output (test-case) separators |
| // begin with "--" ("=="). |
| input_text_stream |
| << comments_and_options << test_input_txt << "-------abc\n" << expected_test_output_text << "=======def\n"; |
| test_cases = extractTestCasesFromStream(input_text_stream); |
| |
| CHECK_EQ(test_cases->size(), 1u); |
| EXPECT_TEXT_CASE((*test_cases)[0], |
| comments_and_options, |
| std::set<std::string>({"option1", "option2", "option3", "option4", "option5"}), |
| test_input_txt, |
| expected_test_output_text); |
| |
| // Without comments. |
| input_text_stream.str(""); |
| input_text_stream << "[option1]\n" << test_input_txt << "--\n" << expected_test_output_text << "==\n"; |
| test_cases = extractTestCasesFromStream(input_text_stream); |
| |
| CHECK_EQ(test_cases->size(), 1u); |
| EXPECT_TEXT_CASE((*test_cases)[0], |
| "[option1]\n", |
| std::set<std::string>({"option1"}), |
| test_input_txt, |
| expected_test_output_text); |
| |
| // Without options. |
| input_text_stream.str(""); |
| input_text_stream << "# Comments\n" << test_input_txt << "--\n" << expected_test_output_text << "==\n"; |
| test_cases = extractTestCasesFromStream(input_text_stream); |
| |
| CHECK_EQ(test_cases->size(), 1u); |
| EXPECT_TEXT_CASE((*test_cases)[0], |
| "# Comments\n", |
| std::set<std::string>(), |
| test_input_txt, |
| expected_test_output_text); |
| |
| // Without comments and options. |
| input_text_stream.str(""); |
| input_text_stream << test_input_txt << "--\n" << expected_test_output_text << "==\n"; |
| test_cases = extractTestCasesFromStream(input_text_stream); |
| |
| CHECK_EQ(test_cases->size(), 1u); |
| EXPECT_TEXT_CASE((*test_cases)[0], |
| "" /* comments_and_options_text */, |
| std::set<std::string>(), |
| test_input_txt, |
| expected_test_output_text); |
| |
| // With empty expected output. |
| input_text_stream.str(""); |
| input_text_stream << test_input_txt << "--\n=="; |
| test_cases = extractTestCasesFromStream(input_text_stream); |
| CHECK_EQ(test_cases->size(), 1u); |
| EXPECT_TEXT_CASE((*test_cases)[0], |
| "" /* comments_and_options_text */, |
| std::set<std::string>(), |
| test_input_txt, |
| "" /* expected_test_output_text */); |
| |
| input_text_stream.str(""); |
| input_text_stream << test_input_txt << "--"; |
| test_cases = extractTestCasesFromStream(input_text_stream); |
| CHECK_EQ(test_cases->size(), 1u); |
| EXPECT_TEXT_CASE((*test_cases)[0], |
| "" /* comments_and_options_text */, |
| std::set<std::string>(), |
| test_input_txt, |
| "" /* expected_test_output_text */); |
| } |
| |
| TEST_F(TextBasedTestDriverTest, DefaultOptionsTest) { |
| const std::string comments_and_options_0 = |
| "# Comments for the first case\n" |
| "[default option1 option2]\n" |
| "[default option3]\n"; |
| const std::string comments_and_options_1 = |
| "# Comments for the second case\n" |
| "[option4 option5]\n"; |
| const std::string test_input_txt = |
| "input line\n"; |
| const std::string expected_test_output_text = |
| "expected output line 1\n"; |
| |
| std::ostringstream input_text_stream; |
| input_text_stream << comments_and_options_0 << test_input_txt << "--\n" << expected_test_output_text << "==\n" |
| << comments_and_options_1 << test_input_txt << "--\n" << expected_test_output_text << "==\n"; |
| |
| std::vector<TextBasedTestCase*> *test_cases = |
| extractTestCasesFromStream(input_text_stream); |
| |
| CHECK_EQ(test_cases->size(), 2u); |
| EXPECT_TEXT_CASE((*test_cases)[0], |
| comments_and_options_0, |
| std::set<std::string>({"option1", "option2", "option3"}), |
| test_input_txt, |
| expected_test_output_text); |
| EXPECT_TEXT_CASE((*test_cases)[1], |
| comments_and_options_1, |
| std::set<std::string>({"option1", "option2", "option3", "option4", "option5"}), |
| test_input_txt, |
| expected_test_output_text); |
| |
| // A default option statement in a new test case clears the default |
| // options set by previous test cases. The third and fourth test cases |
| // do not inherit option1 -- option3. |
| const std::string comments_and_options_3 = |
| "# Comments for the third case\n" |
| "[default option6]\n" |
| "[option7 option8]\n"; |
| const std::string comments_and_options_4 = |
| "# Comments for the third case\n" |
| "[option9 option10]\n"; |
| input_text_stream << comments_and_options_3 << test_input_txt << "--\n" << expected_test_output_text << "==\n" |
| << comments_and_options_4 << test_input_txt << "--\n" << expected_test_output_text << "==\n"; |
| test_cases = extractTestCasesFromStream(input_text_stream); |
| |
| CHECK_EQ(test_cases->size(), 4u); |
| EXPECT_TEXT_CASE((*test_cases)[2], |
| comments_and_options_3, |
| std::set<std::string>({"option6", "option7", "option8"}), |
| test_input_txt, |
| expected_test_output_text); |
| EXPECT_TEXT_CASE((*test_cases)[3], |
| comments_and_options_4, |
| std::set<std::string>({"option6", "option9", "option10"}), |
| test_input_txt, |
| expected_test_output_text); |
| } |
| |
| TEST_F(TextBasedTestDriverTest, SameAsAboveTest) { |
| const std::string comments_and_options = |
| "# Comments for the first case\n" |
| "[option1 option2]\n"; |
| const std::string test_input_txt = |
| "input line\n"; |
| const std::string expected_test_output_text = |
| "expected output line 1\n"; |
| const std::string same_as_above_test_output_text = |
| "[same as above]"; |
| |
| std::ostringstream input_text_stream; |
| input_text_stream << comments_and_options << test_input_txt << "--\n" << same_as_above_test_output_text; |
| EXPECT_DEATH(extractTestCasesFromStream(input_text_stream), |
| "Cannot specify \"same as above\" in the first test case"); |
| |
| input_text_stream.str(""); |
| input_text_stream << comments_and_options << test_input_txt << "--\n" << expected_test_output_text << "==\n" |
| << comments_and_options << test_input_txt << "--\n" << same_as_above_test_output_text; |
| std::vector<TextBasedTestCase*> *test_cases = |
| extractTestCasesFromStream(input_text_stream); |
| |
| CHECK_EQ(test_cases->size(), 2u); |
| EXPECT_TEXT_CASE((*test_cases)[1], |
| comments_and_options, |
| std::set<std::string>({"option1", "option2"}), |
| test_input_txt, |
| expected_test_output_text); |
| } |
| |
| TEST_F(TextBasedTestDriverTest, OptionErrors) { |
| const std::string test_input_txt = "input line\n"; |
| const std::string expected_test_output_text = "expected output line\n"; |
| |
| const std::string with_unregistered_option = |
| "# Comments for the first case\n" |
| "[unregistered_option]\n"; |
| std::ostringstream input_text_stream; |
| input_text_stream << with_unregistered_option << test_input_txt << "--\n" << expected_test_output_text; |
| EXPECT_DEATH( |
| extractTestCasesFromStream(input_text_stream), |
| "Option unregistered_option is not found"); |
| |
| const std::string invalid_option_line_0 = "[option1] [option2]\n"; |
| input_text_stream.str(""); |
| input_text_stream << invalid_option_line_0 << test_input_txt << "--\n" << expected_test_output_text; |
| EXPECT_DEATH( |
| extractTestCasesFromStream(input_text_stream), |
| "Cannot have text after options"); |
| |
| const std::string invalid_option_line_1 = "[option1] abc\n"; |
| input_text_stream.str(""); |
| input_text_stream << invalid_option_line_1 << test_input_txt << "--\n" << expected_test_output_text; |
| EXPECT_DEATH( |
| extractTestCasesFromStream(input_text_stream), |
| "Cannot have text after options"); |
| |
| const std::string with_no_options_0 = "[]\n"; |
| input_text_stream.str(""); |
| input_text_stream << with_no_options_0 << test_input_txt << "--\n" << expected_test_output_text; |
| EXPECT_DEATH( |
| extractTestCasesFromStream(input_text_stream), |
| "Has no options specified in the brackets"); |
| |
| const std::string with_no_options_1 = "[ \t ]\n"; |
| input_text_stream.str(""); |
| input_text_stream << with_no_options_1 << test_input_txt << "--\n" << expected_test_output_text; |
| EXPECT_DEATH( |
| extractTestCasesFromStream(input_text_stream), |
| "Has no options specified in the brackets"); |
| |
| const std::string with_no_options_2 = "[ default ]\n"; |
| input_text_stream.str(""); |
| input_text_stream << with_no_options_2 << test_input_txt << "--\n" << expected_test_output_text; |
| EXPECT_DEATH( |
| extractTestCasesFromStream(input_text_stream), |
| "Has no options specified in the brackets"); |
| } |
| |
| } // namespace quickstep |
