RegularTestCore.hpp

Go to the documentation of this file.

 
//                Copyright Oliver J. Rosten 2018.                //
// Distributed under the GNU GENERAL PUBLIC LICENSE, Version 3.0. //
//    (See accompanying file LICENSE.md or copy at                //
//          https://www.gnu.org/licenses/gpl-3.0.en.html)         //
 
#pragma once
 
#include "sequoia/TestFramework/FreeTestCore.hpp"
#include "sequoia/TestFramework/RegularCheckers.hpp"
 
namespace sequoia::testing
{
  [[nodiscard]]
  std::string regular_message(std::string_view description);
 
  template<test_mode Mode>
  class regular_extender
  {
  public:
    constexpr static test_mode mode{Mode};
 
    regular_extender() = default;
 
    template<pseudoregular T, class Self>
    void check_semantics(this Self& self, const reporter& description, const T& x, const T& y)
    {
      testing::check_semantics(regular_message(self.report(description)),
                               self.m_Logger,
                               x,
                               y,
                               optional_ref<const T>{},
                               optional_ref<const T>{});
    }
 
    template<pseudoregular T, class U, class Self>
      requires equivalence_checkable_for_semantics<Mode, T, U>
    void check_semantics(this Self& self,
                         const reporter& description,
                         const T& x,
                         const T& y,
                         const U& xEquivalent,
                         const U& yEquivalent)
    {
      testing::check_semantics(regular_message(self.report(description)),
                               self.m_Logger,
                               x,
                               y,
                               xEquivalent,
                               yEquivalent,
                               optional_ref<const T>{},
                               optional_ref<const T>{});
    }
 
    template<pseudoregular T, class U, class V, class Self>
      requires equivalence_checkable_for_semantics<Mode, T, U> && checkable_against_for_semantics<Mode, T, V>
    void check_semantics(this Self& self,
                         const reporter& description,
                         const T& x,
                         const T& y,
                         const U& xEquivalent,
                         const U& yEquivalent,
                         const V& movedFromPostConstruction,
                         const V& movedFromPostAssignment)
    {
      testing::check_semantics(regular_message(self.report(description)),
                               self.m_Logger,
                               x,
                               y,
                               xEquivalent,
                               yEquivalent,
                               optional_ref<const V>{movedFromPostConstruction},
                               optional_ref<const V>{movedFromPostAssignment});
    }
 
    template<pseudoregular T, class Self>
      requires std::totally_ordered<T>
    void check_semantics(this Self& self, const reporter& description, const T& x, const T& y, std::weak_ordering order)
    {
      testing::check_semantics(regular_message(self.report(description)),
                               self.m_Logger,
                               x,
                               y,
                               optional_ref<const T>{},
                               optional_ref<const T>{},
                               order);
    }
 
    template<pseudoregular T, class U, class Self>
      requires std::totally_ordered<T> && equivalence_checkable_for_semantics<Mode, T, U>
    void check_semantics(this Self& self,
                         const reporter& description,
                         const T& x,
                         const T& y,
                         const U& xEquivalent,
                         const U& yEquivalent,
                         std::weak_ordering order)
    {
      testing::check_semantics(regular_message(self.report(description)),
                               self.m_Logger,
                               x,
                               y,
                               xEquivalent,
                               yEquivalent,
                               optional_ref<const T>{},
                               optional_ref<const T>{},
                               order);
    }
 
    template<pseudoregular T, class U, class V, class Self>
      requires std::totally_ordered<T> && equivalence_checkable_for_semantics<Mode, T, U> && checkable_against_for_semantics<Mode, T, V>
    void check_semantics(this Self& self,
                         const reporter& description,
                         const T& x,
                         const T& y,
                         const U& xEquivalent,
                         const U& yEquivalent,
                         const V& movedFromPostConstruction,
                         const V& movedFromPostAssignment,
                         std::weak_ordering order)
    {
      testing::check_semantics(regular_message(self.report(description)),
                               self.m_Logger,
                               x,
                               y,
                               xEquivalent,
                               yEquivalent,
                               optional_ref<const V>{movedFromPostConstruction},
                               optional_ref<const V>{movedFromPostAssignment},
                               order);
    }
 
    template<pseudoregular T, std::invocable<T&> Mutator, class Self>
    void check_semantics(this Self& self, const reporter& description, const T& x, const T& y, Mutator m)
    {
      testing::check_semantics(regular_message(self.report(description)),
                               self.m_Logger,
                               x,
                               y,
                               optional_ref<const T>{},
                               optional_ref<const T>{},
                               std::move(m));
    }
 
    template<pseudoregular T, class U, std::invocable<T&> Mutator, class Self>
      requires equivalence_checkable_for_semantics<Mode, T, U>
    void check_semantics(this Self& self,
                         const reporter& description,
                         const T& x,
                         const T& y,
                         const U& xEquivalent,
                         const U& yEquivalent,
                         Mutator m)
    {
      testing::check_semantics(regular_message(self.report(description)),
                               self.m_Logger,
                               x,
                               y,
                               xEquivalent,
                               yEquivalent,
                               optional_ref<const T>{},
                               optional_ref<const T>{},
                               std::move(m));
    }
 
    template<pseudoregular T, class U, class V, std::invocable<T&> Mutator, class Self>
      requires equivalence_checkable_for_semantics<Mode, T, U>
    void check_semantics(this Self& self,
                         const reporter& description,
                         const T& x,
                         const T& y,
                         const U& xEquivalent,
                         const U& yEquivalent,
                         const V& movedFromPostConstruction,
                         const V& movedFromPostAssignment,
                         Mutator m)
    {
      testing::check_semantics(regular_message(self.report(description)),
                               self.m_Logger,
                               x,
                               y,
                               xEquivalent,
                               yEquivalent,
                               optional_ref<const V>{movedFromPostConstruction},
                               optional_ref<const V>{movedFromPostAssignment},
                               std::move(m));
    }
 
    template<pseudoregular T, std::invocable<T&> Mutator, class Self>
      requires std::totally_ordered<T>
    void check_semantics(this Self& self, const reporter& description, const T& x, const T& y, std::weak_ordering order, Mutator m)
    {
      testing::check_semantics(regular_message(self.report(description)),
                               self.m_Logger,
                               x,
                               y,
                               optional_ref<const T>{},
                               optional_ref<const T>{},
                               order,
                               std::move(m));
    }
 
    template<pseudoregular T, class U, std::invocable<T&> Mutator, class Self>
      requires std::totally_ordered<T> && equivalence_checkable_for_semantics<Mode, T, U>
    void check_semantics(this Self& self,
                         const reporter& description,
                         const T& x,
                         const T& y,
                         const U& xEquivalent,
                         const U& yEquivalent,
                         std::weak_ordering order,
                         Mutator m)
    {
      testing::check_semantics(regular_message(self.report(description)),
                               self.m_Logger,
                               x,
                               y,
                               xEquivalent,
                               yEquivalent,
                               optional_ref<const T>{},
                               optional_ref<const T>{},
                               order,
                               std::move(m));
    }
 
    template<pseudoregular T, class U, class V, std::invocable<T&> Mutator, class Self>
      requires equivalence_checkable_for_semantics<Mode, T, U>
    void check_semantics(this Self& self,
                         const reporter& description,
                         const T& x,
                         const T& y,
                         const U& xEquivalent,
                         const U& yEquivalent,
                         const V& movedFromPostConstruction,
                         const V& movedFromPostAssignment,
                         std::weak_ordering order,
                         Mutator m)
    {
      testing::check_semantics(regular_message(self.report(description)),
                               self.m_Logger,
                               x,
                               y,
                               xEquivalent,
                               yEquivalent,
                               optional_ref<const V>{movedFromPostConstruction},
                               optional_ref<const V>{movedFromPostAssignment},
                               order,
                               std::move(m));
    }
  protected:
    ~regular_extender() = default;
 
    regular_extender(regular_extender&&)            noexcept = default;
    regular_extender& operator=(regular_extender&&) noexcept = default;
  };
 
  template<test_mode mode>
  using canonical_regular_test = basic_test<mode, regular_extender<mode>>;
 
  using regular_test                = canonical_regular_test<test_mode::standard>;
  using regular_false_positive_test = canonical_regular_test<test_mode::false_positive>;
  using regular_false_negative_test = canonical_regular_test<test_mode::false_negative>;
}