settings.h

Go to the documentation of this file.

#pragma once
#include <chrono>
#include <cstdlib>
#include <string>

namespace tunit {
  class settings final {
  public:
    settings() = default;
    
    settings(const settings&) = default;
    settings& operator=(const settings&) = default;

    static tunit::settings& default_settings() noexcept {
      static tunit::settings settings;
      return settings;
    }

    bool also_run_ignored_tests() const noexcept {return this->also_run_ignored_tests_;}

    void also_run_ignored_tests(bool also_run_ignored_tests) noexcept {this->also_run_ignored_tests_ = also_run_ignored_tests;}
    
    int exit_status() const noexcept {return this->exit_status_;}
    
    void exit_status(int exit_status) noexcept {this->exit_status_ = exit_status;}
    
    const std::string& filter_tests() const noexcept {return this->filter_tests_;}

    void filter_tests(const std::string& filter_tests) noexcept {this->filter_tests_ = filter_tests;}

    bool is_match_test_name(const std::string& test_class_name, const std::string& test_name) const noexcept {return this->pattern_compare(test_class_name + "." + test_name, this->filter_tests_);}

    bool list_tests() const noexcept {return this->list_tests_;}

    void list_tests(bool list_tests) noexcept {this->list_tests_ = list_tests;}
    
    bool output_color() const noexcept {return this->output_color_;}
    
    void output_color(bool output_color) noexcept {this->output_color_ = output_color;}
    
    bool output_xml() const noexcept {return this->output_xml_;}
    
    void output_xml(bool output_xml) noexcept {this->output_xml_ = output_xml;}
    
    std::string output_xml_path() const noexcept {return this->output_xml_path_;}
    
    void output_xml_path(const std::string& output_xml_path) noexcept {this->output_xml_path_ = output_xml_path;}
    
    bool shuffle_test() const noexcept {return this->shuffle_tests_;}
    
    void shuffle_test(bool shuffle_test) noexcept {this->shuffle_tests_ = shuffle_test;}
    
    int random_seed() const noexcept {return this->random_seed_;}
    
    void random_seed(int random_seed) noexcept {this->random_seed_ = random_seed;}
    
    int repeaat_test() const noexcept {return this->repeat_tests_;}
    
    void repeat_tests(int repeat_tests) noexcept {this->repeat_tests_ = repeat_tests;}

    bool show_duration() const noexcept {return this->show_duration_;}
    
    void show_duration(bool show_duration) noexcept {this->show_duration_ = show_duration;}

    std::chrono::time_point<std::chrono::system_clock> end_time() const noexcept {return this->end_time_;}

    std::chrono::time_point<std::chrono::system_clock> start_time() const noexcept {return this->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 this->pattern_compare(name, pattern.substr(1)) || this->pattern_compare(name.substr(1), pattern);
      return ((pattern[0] == '?') || (name[0] == pattern[0])) && this->pattern_compare(name.substr(1), pattern.substr(1));
    }

    void end_time(const std::chrono::time_point<std::chrono::system_clock>& end_time) noexcept {this->start_time_ = end_time;}
    void start_time(const std::chrono::time_point<std::chrono::system_clock>& start_time) noexcept {this->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_;
  };
}