settings.h

Go to the documentation of this file.

 
#pragma once
#include "../tunit_export.h"
#include <chrono>
#include <cstdlib>
#include <string>
 
namespace xtd {
  namespace tunit {
    class tunit_export_ settings final {
    public:
      settings() = default;
      
      settings(const settings&) = default;
      settings& operator=(const settings&) = default;
 
      static xtd::tunit::settings& default_settings() noexcept;
 
      bool also_run_ignored_tests() const noexcept {return also_run_ignored_tests_;}
 
      void also_run_ignored_tests(bool also_run_ignored_tests) noexcept {also_run_ignored_tests_ = also_run_ignored_tests;}
      
      int exit_status() const noexcept {return exit_status_;}
      
      void exit_status(int exit_status) noexcept {exit_status_ = exit_status;}
      
      const std::string& filter_tests() const noexcept {return filter_tests_;}
 
      void filter_tests(const std::string& filter_tests) noexcept {filter_tests_ = filter_tests;}
 
      bool is_match_test_name(const std::string& test_class_name, const std::string& test_name) const noexcept {return pattern_compare(test_class_name + "." + test_name, filter_tests_);}
 
      bool list_tests() const noexcept {return list_tests_;}
 
      void list_tests(bool list_tests) noexcept {list_tests_ = list_tests;}
      
      bool output_color() const noexcept {return output_color_;}
      
      void output_color(bool output_color) noexcept {output_color_ = output_color;}
      
      bool output_xml() const noexcept {return output_xml_;}
      
      void output_xml(bool output_xml) noexcept {output_xml_ = output_xml;}
      
      std::string output_xml_path() const noexcept {return output_xml_path_;}
      
      void output_xml_path(const std::string& output_xml_path) noexcept {output_xml_path_ = output_xml_path;}
      
      bool shuffle_test() const noexcept {return shuffle_tests_;}
      
      void shuffle_test(bool shuffle_test) noexcept {shuffle_tests_ = shuffle_test;}
      
      int random_seed() const noexcept {return random_seed_;}
      
      void random_seed(int random_seed) noexcept {random_seed_ = random_seed;}
      
      int repeat_test() const noexcept {return repeat_tests_;}
      
      void repeat_tests(int repeat_tests) noexcept {repeat_tests_ = repeat_tests;}
 
      bool show_duration() const noexcept {return show_duration_;}
      
      void show_duration(bool show_duration) noexcept {show_duration_ = show_duration;}
 
      std::chrono::time_point<std::chrono::system_clock> end_time() const noexcept {return end_time_;}
 
      std::chrono::time_point<std::chrono::system_clock> start_time() const noexcept {return start_time_;}
 
    private:
      friend class unit_test;
      
      bool pattern_compare(const std::string& name, const std::string& pattern) const noexcept {
        if (pattern == "") return name == "";
        if (name == "") return false;
        if (pattern == "*" || pattern == "*.*") return true;
        if (pattern[0] == '*') return pattern_compare(name, pattern.substr(1)) || pattern_compare(name.substr(1), pattern);
        return ((pattern[0] == '?') || (name[0] == pattern[0])) && pattern_compare(name.substr(1), pattern.substr(1));
      }
 
      void end_time(const std::chrono::time_point<std::chrono::system_clock>& end_time) noexcept {start_time_ = end_time;}
      void start_time(const std::chrono::time_point<std::chrono::system_clock>& start_time) noexcept {start_time_ = start_time;}
 
      bool also_run_ignored_tests_ = false;
      std::string filter_tests_ = "*.*";
      int exit_status_ = EXIT_SUCCESS;
      bool list_tests_ = false;
      bool output_color_ = true;
      bool output_xml_;
      std::string output_xml_path_ = "tests.xml";
      bool show_duration_ = true;
      bool shuffle_tests_ = false;
      int random_seed_ = 0;
      int repeat_tests_ = 1;
      std::chrono::time_point<std::chrono::system_clock> start_time_;
      std::chrono::time_point<std::chrono::system_clock> end_time_;
    };
  }
}