utility/textbased_test/TextBasedTestDriver.cpp - incubator-retired-quickstep - Git at Google

 /**
  * 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 <algorithm>
 #include <cctype>
 #include <cstdio>
 #include <fstream>
 #include <iostream>
 #include <istream>
 #include <set>
 #include <string>
 #include <vector>

 #include "utility/textbased_test/TextBasedTest.hpp"

 #include "glog/logging.h"

 namespace quickstep {

 namespace {

 static const char *kSameAsAboveString = "[same as above]";

 /**
  * @brief Returns a newline-terminated line from \p is.
  *
  * @param is The istream object from which line characters are extracted.
  * @param line The string object to store the extracted line.
  * @return True if \p line is not empty.
  */
 bool GetLineWithNewLineNotTrimmed(std::istream *is, std::string *line) {
   line->clear();

   std::istream::sentry se(*is, true);
   if (se) {
     std::streambuf* sb = is->rdbuf();
     for (;;) {
       const char c = sb->sgetc();
       switch (c) {
         case '\n':
           line->push_back(c);
           sb->sbumpc();
           return true;
         case '\r':
           *line += c;
           if (sb->snextc() == '\n') {
             line->push_back(sb->sgetc());
             sb->sbumpc();
           }
           return true;
         case EOF:
           is->setstate(std::ios_base::eofbit);
           if (line->empty()) {
             return false;
           }
           return true;
         default:
           line->push_back(c);
           sb->sbumpc();
       }
     }
   }

   return false;
 }

 }  // namespace

 TextBasedTestDriver::TextBasedTestDriver(std::istream *input_stream, TextBasedTestRunner *test_runner)
     : input_stream_(input_stream),
       test_runner_(test_runner) {
   CHECK(input_stream_->good());
 }

 TextBasedTestDriver::~TextBasedTestDriver() {
   clearTestCases();
 }

 void TextBasedTestDriver::clearTestCases() {
   for (const TextBasedTestCase *test_case : test_cases_) {
     delete test_case;
   }
   test_cases_.clear();
 }

 std::vector<TextBasedTestCase*>* TextBasedTestDriver::populateAndReturnTestCases() {
   populateTestCases();
   return &test_cases_;
 }

 void TextBasedTestDriver::writeActualOutput(std::ostream *out) const {
   const TextBasedTestCase *previous_case = nullptr;
   for (const TextBasedTestCase *test_case : test_cases_) {
     if (previous_case != nullptr) {
       *out << "==" << std::endl;
     }
     *out << test_case->preceding_text;
     *out << test_case->input_text;
     *out << "--" << std::endl;
     if (previous_case != nullptr &&
         test_case->actual_output_text == previous_case->actual_output_text) {
       *out << kSameAsAboveString << std::endl;
     } else {
       *out << test_case->actual_output_text;
     }
     previous_case = test_case;
   }
 }

 void TextBasedTestDriver::writeActualOutputToFile(const std::string &output_filename) const {
   std::ofstream file_stream(output_filename);
   CHECK(file_stream.is_open()) << "Output file " << output_filename << " cannot be written to";
   writeActualOutput(&file_stream);
 }

 void TextBasedTestDriver::populateTestCases() {
   TextBasedTestCase *test_case = readNextTestCase();
   while (test_case != nullptr) {
     CHECK(!std::all_of(test_case->input_text.begin(), test_case->input_text.end(), ::isspace)) << "Input text is empty";
     test_cases_.push_back(test_case);
     test_case = readNextTestCase();
   }
 }

 TextBasedTestCase* TextBasedTestDriver::readNextTestCase() {
   if (input_stream_->eof()) {
     return nullptr;
   }

   std::string line;
   std::ostringstream test_input;
   std::ostringstream non_test_input;
   std::ostringstream test_output;

   // Read leading comments.
   while (GetLineWithNewLineNotTrimmed(input_stream_, &line)) {
     DCHECK(!line.empty());
     if (line.at(0) == '[') {
       break;
     }
     if (line.at(0) != '#') {
       if (!std::all_of(line.begin(), line.end(), ::isspace)) {
         break;
       }
     }
     non_test_input << line;
   }

   if (line.empty()) {
     // We are reaching the end.
     CHECK(input_stream_->eof());
     return nullptr;
   }

   // Read option specifications.
   std::set<std::string> options;
   std::set<std::string> default_options;
   if (line.at(0) == '[') {
     readOptions(line, &options, &default_options);
     non_test_input << line;
     while (GetLineWithNewLineNotTrimmed(input_stream_, &line)) {
       DCHECK(!line.empty());
       if (line.at(0) == '[') {
         readOptions(line, &options, &default_options);
       } else {
         if (!std::all_of(line.begin(), line.end(), ::isspace)) {
           break;
         }
       }
       non_test_input << line;
     }
   }

   if (!default_options.empty()) {
     default_options_ = std::move(default_options);
   }
   options.insert(default_options_.begin(), default_options_.end());

   CHECK(!line.empty() || IsInputOutputSeparator(line)) << "Has options but no input test text";
   test_input << line;

   while (GetLineWithNewLineNotTrimmed(input_stream_, &line)) {
     if (IsInputOutputSeparator(line)) {
       break;
     }
     test_input << line;
   }

   while (GetLineWithNewLineNotTrimmed(input_stream_, &line)) {
     if (IsTestCaseSeparator(line)) {
       break;
     }
     test_output << line;
   }

   if (test_output.str().compare(0, ::strlen(kSameAsAboveString), kSameAsAboveString) == 0) {
     CHECK(!test_cases_.empty()) << "Cannot specify \"same as above\" in the first test case";
     test_output.str("");
     test_output << test_cases_.back()->expected_output_text;
   }

   return new TextBasedTestCase(non_test_input.str(),
                                test_input.str(),
                                test_output.str(),
                                std::move(options),
                                test_runner_);
 }

 void TextBasedTestDriver::readOptions(const std::string &line,
                                       std::set<std::string> *options_out,
                                       std::set<std::string> *default_options_out) {
   DCHECK(!line.empty() && line.at(0) == '[') << line;
   std::string token;
   std::istringstream line_stream(line);
   line_stream.get();

   // Create a temporary vector to store the options in the current line.
   // The options cannot be directly inserted to <options_out> and
   // copy the content to <default_options_out> if default is specified,
   // because <options_out> may contain non-default options given in
   // preceding lines.
   std::vector<std::string> options;
   while (line_stream >> token) {
     size_t bracket_pos = token.find(']');
     if (bracket_pos != std::string::npos) {
       CHECK_EQ(bracket_pos + 1, token.size()) << "Cannot have text after options";
       if (token.size() > 1) {
         options.push_back(token.substr(0, bracket_pos));
       }
       break;
     }
     options.push_back(token);
   }

   CHECK(!(line_stream >> token)) << "Cannot have text after options";

   bool is_default = false;
   std::vector<std::string>::const_iterator start_it = options.begin();
   std::vector<std::string>::const_iterator end_it = options.end();
   if (start_it != end_it && *start_it == "default") {
     ++start_it;
     is_default = true;
   }

   CHECK(start_it != end_it) << "Has no options specified in the brackets";

   if (is_default) {
     default_options_out->insert(start_it, end_it);
   }

   while (start_it != end_it) {
     CHECK(isRegisteredOption(*start_it)) << "Option " << *start_it << " is not found";
     options_out->insert(*start_it);
     ++start_it;
   }
 }

 bool TextBasedTestDriver::IsInputOutputSeparator(const std::string &str) {
   if (str.size() > 1 && str.at(0) == '-' && str.at(1) == '-') {
     return true;
   }
   return false;
 }

 bool TextBasedTestDriver::IsTestCaseSeparator(const std::string &str) {
   if (str.size() > 1 && str.at(0) == '=' && str.at(1) == '=') {
     return true;
   }
   return false;
 }

 bool TextBasedTestDriver::isValidOption(const std::string &name) const {
   if (name.empty()) return false;

   for (const char c : name) {
     if (!std::isalnum(c) && c != '_') {
       return false;
     }
   }
   return true;
 }

 void TextBasedTestDriver::registerOptions(const std::vector<std::string> &option_names) {
   for (const std::string &option_name : option_names) {
     registerOption(option_name);
   }
 }

 void TextBasedTestDriver::registerOption(const std::string &option_name) {
   CHECK(isValidOption(option_name))
       << "Option " << option_name << " is not valid (must contain only alphanumeric characters and underscores)";
   registered_options_.insert(option_name);
 }

 bool TextBasedTestDriver::isRegisteredOption(const std::string &option_name) const {
   return registered_options_.find(option_name) != registered_options_.end();
 }

 }  // namespace quickstep
	/**
	* 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 <algorithm>
	#include <cctype>
	#include <cstdio>
	#include <fstream>
	#include <iostream>
	#include <istream>
	#include <set>
	#include <string>
	#include <vector>

	#include "utility/textbased_test/TextBasedTest.hpp"

	#include "glog/logging.h"

	namespace quickstep {

	namespace {

	static const char *kSameAsAboveString = "[same as above]";

	/**
	* @brief Returns a newline-terminated line from \p is.
	*
	* @param is The istream object from which line characters are extracted.
	* @param line The string object to store the extracted line.
	* @return True if \p line is not empty.
	*/
	bool GetLineWithNewLineNotTrimmed(std::istream is, std::string line) {
	line->clear();

	std::istream::sentry se(*is, true);
	if (se) {
	std::streambuf* sb = is->rdbuf();
	for (;;) {
	const char c = sb->sgetc();
	switch (c) {
	case '\n':
	line->push_back(c);
	sb->sbumpc();
	return true;
	case '\r':
	*line += c;
	if (sb->snextc() == '\n') {
	line->push_back(sb->sgetc());
	sb->sbumpc();
	}
	return true;
	case EOF:
	is->setstate(std::ios_base::eofbit);
	if (line->empty()) {
	return false;
	}
	return true;
	default:
	line->push_back(c);
	sb->sbumpc();
	}
	}
	}

	return false;
	}

	} // namespace

	TextBasedTestDriver::TextBasedTestDriver(std::istream input_stream, TextBasedTestRunner test_runner)
	: input_stream_(input_stream),
	test_runner_(test_runner) {
	CHECK(input_stream_->good());
	}

	TextBasedTestDriver::~TextBasedTestDriver() {
	clearTestCases();
	}

	void TextBasedTestDriver::clearTestCases() {
	for (const TextBasedTestCase *test_case : test_cases_) {
	delete test_case;
	}
	test_cases_.clear();
	}

	std::vector<TextBasedTestCase> TextBasedTestDriver::populateAndReturnTestCases() {
	populateTestCases();
	return &test_cases_;
	}

	void TextBasedTestDriver::writeActualOutput(std::ostream *out) const {
	const TextBasedTestCase *previous_case = nullptr;
	for (const TextBasedTestCase *test_case : test_cases_) {
	if (previous_case != nullptr) {
	*out << "==" << std::endl;
	}
	*out << test_case->preceding_text;
	*out << test_case->input_text;
	*out << "--" << std::endl;
	if (previous_case != nullptr &&
	test_case->actual_output_text == previous_case->actual_output_text) {
	*out << kSameAsAboveString << std::endl;
	} else {
	*out << test_case->actual_output_text;
	}
	previous_case = test_case;
	}
	}

	void TextBasedTestDriver::writeActualOutputToFile(const std::string &output_filename) const {
	std::ofstream file_stream(output_filename);
	CHECK(file_stream.is_open()) << "Output file " << output_filename << " cannot be written to";
	writeActualOutput(&file_stream);
	}

	void TextBasedTestDriver::populateTestCases() {
	TextBasedTestCase *test_case = readNextTestCase();
	while (test_case != nullptr) {
	CHECK(!std::all_of(test_case->input_text.begin(), test_case->input_text.end(), ::isspace)) << "Input text is empty";
	test_cases_.push_back(test_case);
	test_case = readNextTestCase();
	}
	}

	TextBasedTestCase* TextBasedTestDriver::readNextTestCase() {
	if (input_stream_->eof()) {
	return nullptr;
	}

	std::string line;
	std::ostringstream test_input;
	std::ostringstream non_test_input;
	std::ostringstream test_output;

	// Read leading comments.
	while (GetLineWithNewLineNotTrimmed(input_stream_, &line)) {
	DCHECK(!line.empty());
	if (line.at(0) == '[') {
	break;
	}
	if (line.at(0) != '#') {
	if (!std::all_of(line.begin(), line.end(), ::isspace)) {
	break;
	}
	}
	non_test_input << line;
	}

	if (line.empty()) {
	// We are reaching the end.
	CHECK(input_stream_->eof());
	return nullptr;
	}

	// Read option specifications.
	std::set<std::string> options;
	std::set<std::string> default_options;
	if (line.at(0) == '[') {
	readOptions(line, &options, &default_options);
	non_test_input << line;
	while (GetLineWithNewLineNotTrimmed(input_stream_, &line)) {
	DCHECK(!line.empty());
	if (line.at(0) == '[') {
	readOptions(line, &options, &default_options);
	} else {
	if (!std::all_of(line.begin(), line.end(), ::isspace)) {
	break;
	}
	}
	non_test_input << line;
	}
	}

	if (!default_options.empty()) {
	default_options_ = std::move(default_options);
	}
	options.insert(default_options_.begin(), default_options_.end());

	CHECK(!line.empty() \|\| IsInputOutputSeparator(line)) << "Has options but no input test text";
	test_input << line;

	while (GetLineWithNewLineNotTrimmed(input_stream_, &line)) {
	if (IsInputOutputSeparator(line)) {
	break;
	}
	test_input << line;
	}

	while (GetLineWithNewLineNotTrimmed(input_stream_, &line)) {
	if (IsTestCaseSeparator(line)) {
	break;
	}
	test_output << line;
	}

	if (test_output.str().compare(0, ::strlen(kSameAsAboveString), kSameAsAboveString) == 0) {
	CHECK(!test_cases_.empty()) << "Cannot specify \"same as above\" in the first test case";
	test_output.str("");
	test_output << test_cases_.back()->expected_output_text;
	}

	return new TextBasedTestCase(non_test_input.str(),
	test_input.str(),
	test_output.str(),
	std::move(options),
	test_runner_);
	}

	void TextBasedTestDriver::readOptions(const std::string &line,
	std::set<std::string> *options_out,
	std::set<std::string> *default_options_out) {
	DCHECK(!line.empty() && line.at(0) == '[') << line;
	std::string token;
	std::istringstream line_stream(line);
	line_stream.get();

	// Create a temporary vector to store the options in the current line.
	// The options cannot be directly inserted to <options_out> and
	// copy the content to <default_options_out> if default is specified,
	// because <options_out> may contain non-default options given in
	// preceding lines.
	std::vector<std::string> options;
	while (line_stream >> token) {
	size_t bracket_pos = token.find(']');
	if (bracket_pos != std::string::npos) {
	CHECK_EQ(bracket_pos + 1, token.size()) << "Cannot have text after options";
	if (token.size() > 1) {
	options.push_back(token.substr(0, bracket_pos));
	}
	break;
	}
	options.push_back(token);
	}

	CHECK(!(line_stream >> token)) << "Cannot have text after options";

	bool is_default = false;
	std::vector<std::string>::const_iterator start_it = options.begin();
	std::vector<std::string>::const_iterator end_it = options.end();
	if (start_it != end_it && *start_it == "default") {
	++start_it;
	is_default = true;
	}

	CHECK(start_it != end_it) << "Has no options specified in the brackets";

	if (is_default) {
	default_options_out->insert(start_it, end_it);
	}

	while (start_it != end_it) {
	CHECK(isRegisteredOption(start_it)) << "Option " << start_it << " is not found";
	options_out->insert(*start_it);
	++start_it;
	}
	}

	bool TextBasedTestDriver::IsInputOutputSeparator(const std::string &str) {
	if (str.size() > 1 && str.at(0) == '-' && str.at(1) == '-') {
	return true;
	}
	return false;
	}

	bool TextBasedTestDriver::IsTestCaseSeparator(const std::string &str) {
	if (str.size() > 1 && str.at(0) == '=' && str.at(1) == '=') {
	return true;
	}
	return false;
	}

	bool TextBasedTestDriver::isValidOption(const std::string &name) const {
	if (name.empty()) return false;

	for (const char c : name) {
	if (!std::isalnum(c) && c != '_') {
	return false;
	}
	}
	return true;
	}

	void TextBasedTestDriver::registerOptions(const std::vector<std::string> &option_names) {
	for (const std::string &option_name : option_names) {
	registerOption(option_name);
	}
	}

	void TextBasedTestDriver::registerOption(const std::string &option_name) {
	CHECK(isValidOption(option_name))
	<< "Option " << option_name << " is not valid (must contain only alphanumeric characters and underscores)";
	registered_options_.insert(option_name);
	}

	bool TextBasedTestDriver::isRegisteredOption(const std::string &option_name) const {
	return registered_options_.find(option_name) != registered_options_.end();
	}

	} // namespace quickstep