is_value.hpp

Go to the documentation of this file.

#pragma once
#include "is_not_value.hpp"
#include "operator_value.hpp"
#include "../assert.hpp"
#include "../assume.hpp"
#include "../collection_assert.hpp"
#include "../collection_assume.hpp"
#include "../collection_valid.hpp"
#include "../string_assert.hpp"
#include "../string_assume.hpp"
#include "../string_valid.hpp"
#include "../valid.hpp"

namespace xtd {
  namespace tunit {
    namespace constraints {
      template<class actual_t> class that_value;
      
      template<class actual_t>
      class is_value : public actual_value<actual_t> {
      public:
        
        inline auto not_() {return is_not_value<actual_t>(self_);}
        
        auto empty(const xtd::diagnostics::stack_frame& stack_frame = xtd::diagnostics::stack_frame::current()) {
          if (actual_value<actual_t>::is_assert()) xtd::tunit::assert::is_empty(actual_value<actual_t>::actual(), stack_frame);
          else if (actual_value<actual_t>::is_valid()) xtd::tunit::valid::is_empty(actual_value<actual_t>::actual(), stack_frame);
          else xtd::tunit::assume::is_empty(actual_value<actual_t>::actual(), stack_frame);
          return operator_value<actual_t>(self_);
        }

        auto empty(const xtd::string& message, const xtd::diagnostics::stack_frame& stack_frame = xtd::diagnostics::stack_frame::current()) {
          if (actual_value<actual_t>::is_assert()) xtd::tunit::assert::is_empty(actual_value<actual_t>::actual(), stack_frame);
          else if (actual_value<actual_t>::is_valid()) xtd::tunit::valid::is_empty(actual_value<actual_t>::actual(), stack_frame);
          else xtd::tunit::assume::is_empty(actual_value<actual_t>::actual(), stack_frame);
          return operator_value<actual_t>(self_);
        }
        
        template<class expected_t>
        auto equal_to(const expected_t& expected, const xtd::diagnostics::stack_frame& stack_frame = xtd::diagnostics::stack_frame::current()) const {
          if (actual_value<actual_t>::is_assert()) xtd::tunit::assert::are_equal(expected, actual_value<actual_t>::actual(), stack_frame);
          else if (actual_value<actual_t>::is_valid()) xtd::tunit::valid::are_equal(expected, actual_value<actual_t>::actual(), stack_frame);
          else xtd::tunit::assume::are_equal(expected, actual_value<actual_t>::actual(), stack_frame);
          return operator_value<actual_t>(self_);
        }

        template<class expected_t>
        auto equal_to(const expected_t& expected, const xtd::string& message, const xtd::diagnostics::stack_frame& stack_frame = xtd::diagnostics::stack_frame::current()) const {
          if (actual_value<actual_t>::is_assert()) xtd::tunit::assert::are_equal(expected, actual_value<actual_t>::actual(), message, stack_frame);
          else if (actual_value<actual_t>::is_valid()) xtd::tunit::valid::are_equal(expected, actual_value<actual_t>::actual(), message, stack_frame);
          else xtd::tunit::assume::are_equal(expected, actual_value<actual_t>::actual(), message, stack_frame);
          return operator_value<actual_t>(self_);
        }
        
        template<class expected_t>
        auto same_as(const expected_t& expected, const xtd::diagnostics::stack_frame& stack_frame = xtd::diagnostics::stack_frame::current()) const {
          if (actual_value<actual_t>::is_assert()) xtd::tunit::assert::are_same(expected, actual_value<actual_t>::actual(), stack_frame);
          else if (actual_value<actual_t>::is_valid()) xtd::tunit::valid::are_same(expected, actual_value<actual_t>::actual(), stack_frame);
          else xtd::tunit::assume::are_same(expected, actual_value<actual_t>::actual(), stack_frame);
          return operator_value<actual_t>(self_);
        }

        template<class expected_t>
        auto same_as(const expected_t& expected, const xtd::string& message, const xtd::diagnostics::stack_frame& stack_frame = xtd::diagnostics::stack_frame::current()) const {
          if (actual_value<actual_t>::is_assert()) xtd::tunit::assert::are_same(expected, actual_value<actual_t>::actual(), message, stack_frame);
          else if (actual_value<actual_t>::is_valid()) xtd::tunit::valid::are_same(expected, actual_value<actual_t>::actual(), message, stack_frame);
          else xtd::tunit::assume::are_same(expected, actual_value<actual_t>::actual(), message, stack_frame);
          return operator_value<actual_t>(self_);
        }

        
      protected:
        
        is_value() = default;
        is_value(actual_value<actual_t>&& v) : actual_value<actual_t> {std::move(v)} {}
        is_value(const actual_value<actual_t>& v) : actual_value<actual_t> {v} {}
        
      private:
        template<class value_t> friend class that_value;
      };
    }
  }
}