directory_assert.h

Go to the documentation of this file.

#pragma once
#include "assert.h"
#include <sys/stat.h>
#if defined(__cpp_lib_filesystem)
#include <filesystem>
#endif

namespace tunit {
  class directory_assert final : private base_assert {
  public:
    directory_assert() = 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) {
      if (expected != actual)
        base_assert::fail(base_assert::to_string(expected.path().string()), base_assert::to_string(actual.path().string()), message, line_info);
      else
        assert::succeed(message, line_info);
    }

    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) {
      if (expected != actual)
        base_assert::fail(base_assert::to_string(expected.path().string()), base_assert::to_string(actual.path().string()), message, line_info);
      else
        assert::succeed(message, line_info);
    }
#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) {
      struct stat info;
      if(stat(directory.c_str(), &info ) != 0 || (info.st_mode & S_IFDIR) != S_IFDIR)
        base_assert::fail("directory exists", base_assert::to_string(directory), message, line_info);
      else
        assert::succeed(message, line_info);
    }
    
    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) {
      struct stat info;
      if(stat(directory.c_str(), &info ) == 0 && (info.st_mode & S_IFDIR) == S_IFDIR)
        base_assert::fail("not directory exists", base_assert::to_string(directory), message, line_info);
      else
        assert::succeed(message, line_info);
    }
    
    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);}
  };
}

#define exists_(...) __CMD_ASSERT_ARGS(exists, __VA_ARGS__)

#define does_not_exist_(...) __CMD_ASSERT_ARGS(does_not_exist, __VA_ARGS__)