directory_valid.h

Go to the documentation of this file.

#pragma once
#include "valid.h"
#include "directory_assert.h"

namespace tunit {
  class directory_valid final : private base_assert {
  public:
    directory_valid() = delete;
    
#if defined(__cpp_lib_filesystem)
    static void are_equal(const std::filesystem::directory_entry& expected, const std::filesystem::directory_entry& actual) {are_equal(expected, actual, "", line_info());}
    
    static void are_equal(const std::filesystem::directory_entry& expected, const std::filesystem::directory_entry& actual, const tunit::line_info& line_info) {are_equal(expected, actual, "", line_info);}
    
    static void are_equal(const std::filesystem::directory_entry& expected, const std::filesystem::directory_entry& actual, const std::string& message) {are_equal(expected, actual, message, line_info());}
    
    static void are_equal(const std::filesystem::directory_entry& expected, const std::filesystem::directory_entry& actual, const std::string& message, const tunit::line_info& line_info) {
      try {
        directory_assert::are_equal(expected, actual, message, line_info);
      } catch (...) {
        base_assert::error();
      }
    }

    static void are_not_equal(const std::filesystem::directory_entry& expected, const std::filesystem::directory_entry& actual) {are_not_equal(expected, actual, "", line_info());}
    
    static void are_not_equal(const std::filesystem::directory_entry& expected, const std::filesystem::directory_entry& actual, const tunit::line_info& line_info) {are_not_equal(expected, actual, "", line_info);}
    
    static void are_not_equal(const std::filesystem::directory_entry& expected, const std::filesystem::directory_entry& actual, const std::string& message) {are_not_equal(expected, actual, message, line_info());}
    
    static void are_not_equal(const std::filesystem::directory_entry& expected, const std::filesystem::directory_entry& actual, const std::string& message, const tunit::line_info& line_info) {
      try {
        directory_assert::are_not_equal(expected, actual, message, line_info);
      } catch (...) {
        base_assert::error();
      }
    }
#endif

    template<typename Char>
    static void exists(const std::basic_string<Char>& directory) {exists(directory, "", line_info());}
    
    template<typename Char>
    static void exists(const std::basic_string<Char>& directory, const tunit::line_info& line_info) {exists(directory, "", line_info);}
    
    template<typename Char>
    static void exists(const std::basic_string<Char>& directory, const std::string& message) {exists(directory, message, line_info());}
    
    template<typename Char>
    static void exists(const std::basic_string<Char>& directory, const std::string& message, const tunit::line_info& line_info) {
      try {
        directory_assert::exists(directory, message, line_info);
      } catch (...) {
        base_assert::error();
      }
    }
    
    template<typename Char>
    static void exists(const Char* directory) {exists(directory, "", line_info());}
    template<typename Char>
    static void exists(const Char* directory, const tunit::line_info& line_info) {exists(directory, "", line_info);}
    template<typename Char>
    static void exists(const Char* directory, const std::string& message) {exists(directory, message, line_info());}
    template<typename Char>
    static void exists(const Char* directory, const std::string& message, const tunit::line_info& line_info) {exists(std::basic_string<Char>(directory), message, line_info);}
    
    template<typename Char>
    static void does_not_exist(const std::basic_string<Char>& directory) {does_not_exist(directory, "", line_info());}
    
    template<typename Char>
    static void does_not_exist(const std::basic_string<Char>& directory, const tunit::line_info& line_info) {does_not_exist(directory, "", line_info);}
    
    template<typename Char>
    static void does_not_exist(const std::basic_string<Char>& directory, const std::string& message) {does_not_exist(directory, message, line_info());}
    
    template<typename Char>
    static void does_not_exist(const std::basic_string<Char>& directory, const std::string& message, const tunit::line_info& line_info) {
      try {
        directory_assert::does_not_exist(directory, message, line_info);
      } catch (...) {
        base_assert::error();
      }
    }
    
    template<typename Char>
    static void does_not_exist(const Char* directory) {does_not_exist(directory, "", line_info());}
    template<typename Char>
    static void does_not_exist(const Char* directory, const tunit::line_info& line_info) {does_not_exist(directory, "", line_info);}
    template<typename Char>
    static void does_not_exist(const Char* directory, const std::string& message) {does_not_exist(directory, message, line_info());}
    template<typename Char>
    static void does_not_exist(const Char* directory, const std::string& message, const tunit::line_info& line_info) {does_not_exist(std::basic_string<Char>(directory), message, line_info);}
  };
}