unit_test_utils.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#define BOOST_NO_AUTO_PTR
 
#include <boost/test/unit_test.hpp>
 
#include <qa_utils/wx_utils/wx_assert.h>
 
#include <cstdint>
#include <functional>
#include <optional>
#include <set>
#include <vector>
 
#include <wx/gdicmn.h>
#include <wx/log.h>
#include <wx/string.h>
 
#include <wx_log_utils.h>
 
 
template<class T>
struct PRINTABLE_OPT
{
    PRINTABLE_OPT( const std::optional<T>& aOpt ) : m_Opt( aOpt ){};
    PRINTABLE_OPT( const T& aVal ) : m_Opt( aVal ){};
 
    std::optional<T> m_Opt;
};
 

#define KI_CHECK_OPT_EQUAL( lhs, rhs )                                                            \
    BOOST_CHECK_EQUAL( PRINTABLE_OPT( lhs ), PRINTABLE_OPT( rhs ) )
 
 
template <class T>
inline std::ostream& operator<<( std::ostream& aOs, const PRINTABLE_OPT<T>& aOptional )
{
    if( aOptional.m_Opt.has_value() )
        aOs << *aOptional.m_Opt;
    else
        aOs << "nullopt";
 
    return aOs;
}
 
 
template <class L, class R>
inline bool operator==( const PRINTABLE_OPT<L>& aLhs, const PRINTABLE_OPT<R>& aRhs )
{
    if( !aLhs.m_Opt.has_value() && !aRhs.m_Opt.has_value() )
        return true; // both nullopt
 
    return aLhs.m_Opt.has_value() && aRhs.m_Opt.has_value() && *aLhs.m_Opt == *aRhs.m_Opt;
}
 
 
template <class L, class R>
inline bool operator!=( const PRINTABLE_OPT<L>& aLhs, const PRINTABLE_OPT<R>& aRhs )
{
    return !( aLhs == aRhs );
}
 
 
// boost_test_print_type has to be in the same namespace as the printed type
namespace std
{

template <typename T>
std::ostream& boost_test_print_type( std::ostream& os, std::vector<T> const& aVec )
{
    os << "std::vector size " << aVec.size() << " [";
 
    for( const auto& i : aVec )
    {
        os << "\n    " << i;
    }
 
    os << "]";
    return os;
}

template <typename K, typename V>
std::ostream& boost_test_print_type( std::ostream& os, std::map<K, V> const& aMap )
{
    os << "std::map size " << aMap.size() << " [";
 
    for( const auto& [key, value] : aMap )
    {
        os << "\n    " << key << " = " << value;
    }
 
    os << "]";
    return os;
}

template <typename K, typename V>
std::ostream& boost_test_print_type( std::ostream& os, std::pair<K, V> const& aPair )
{
    os << "[" << aPair.first << ", " << aPair.second << "]";
    return os;
}

template <typename T>
std::ostream& boost_test_print_type( std::ostream& os, std::set<T> const& aSet )
{
    os << "set size " << aSet.size() << " [";
    for( const auto& i : aSet )
    {
        os << "\n    " << i;
    }
 
    os << "]";
    return os;
}
 
} // namespace std
 
 
//-----------------------------------------------------------------------------+
// Boost.Test printing helpers for wx types / wide string literals
//-----------------------------------------------------------------------------+
 
// C++20 removed operator<<(ostream&, const wchar_t*) (P1423R3), which breaks wxString streaming
// via implicit wchar_t* conversion in Boost.Test's lazy_ostream (used by BOOST_TEST_CONTEXT,
// BOOST_TEST_MESSAGE, BOOST_CHECK_MESSAGE, and BOOST_FAIL).
inline std::ostream& boost_test_print_type( std::ostream& os, const wxString& v )
{
#if wxUSE_UNICODE
    os << v.ToUTF8().data();
#else
    os << v.c_str();
#endif
    return os;
}
 
 
// Wide string literal arrays
template <std::size_t N>
std::ostream& boost_test_print_type( std::ostream& os, const wchar_t ( &ws )[N] )
{
    wxString tmp( ws );
#if wxUSE_UNICODE
    os << tmp.ToUTF8().data();
#else
    os << tmp;
#endif
    return os;
}
 
 
namespace boost { namespace unit_test
{
template<> struct is_forward_iterable<wxString> : public mpl::false_ {};
 
}} // namespace boost::unit_test
 
 
namespace boost { namespace test_tools { namespace tt_detail {
 
template<std::size_t N>
struct print_log_value<wchar_t[ N ]>
{
    void operator()( std::ostream& os, const wchar_t (&ws)[ N ] )
    {
        wxString tmp( ws );
#if wxUSE_UNICODE
        os << tmp.ToUTF8().data();
#else
        os << tmp;
#endif
    }
};
 
}}} // namespace boost::test_tools::tt_detail
 

std::ostream& boost_test_print_type( std::ostream& os, wxPoint const& aVec );
 
namespace KI_TEST
{
 
template <typename EXP_CONT> using EXP_OBJ = typename EXP_CONT::value_type;
template <typename FOUND_CONT> using FOUND_OBJ = typename FOUND_CONT::value_type;

template <typename EXP_OBJ, typename FOUND_OBJ>
using MATCH_PRED = std::function<bool( const EXP_OBJ&, const FOUND_OBJ& )>;

template <typename EXP_CONT, typename FOUND_CONT, typename MATCH_PRED>
void CheckUnorderedMatches( const EXP_CONT& aExpected, const FOUND_CONT& aFound,
                            MATCH_PRED aMatchPredicate )
{
    using EXP_OBJ = typename EXP_CONT::value_type;
 
    // set of object we've already found
    std::set<const EXP_OBJ*> matched;
 
    // fill the set of object that match
    for( const auto& found : aFound )
    {
        for( const auto& expected : aExpected )
        {
            if( aMatchPredicate( expected, found ) )
            {
                matched.insert( &expected );
                break;
            }
        }
    }
 
    // first check every expected object was "found"
    for( const EXP_OBJ& exp : aExpected )
    {
        BOOST_CHECK_MESSAGE( matched.count( &exp ) > 0, "Expected item was not found. Expected: \n"
                                                                << exp );
    }
 
    // check every "found" object was expected
    for( const EXP_OBJ* found : matched )
    {
        const bool was_expected = std::find_if( aExpected.begin(), aExpected.end(),
                [found]( const EXP_OBJ& aObj )
                {
                    return &aObj == found;
                } ) != aExpected.end();
 
        BOOST_CHECK_MESSAGE( was_expected, "Found item was not expected. Found: \n" << *found );
    }
}
 

template <typename T>
bool CollectionHasNoDuplicates( const T& aCollection )
{
    T sorted = aCollection;
    std::sort( sorted.begin(), sorted.end() );
 
    return std::adjacent_find( sorted.begin(), sorted.end() ) == sorted.end();
}
 

struct NAMED_CASE
{
    std::string m_CaseName;
 
    friend std::ostream& operator<<( std::ostream& os, const NAMED_CASE& aCase )
    {
        os << aCase.m_CaseName;
        return os;
    }
};
 

#if wxDEBUG_LEVEL > 0
#define CHECK_WX_ASSERT( STATEMENT ) BOOST_CHECK_THROW( STATEMENT, KI_TEST::WX_ASSERT_ERROR );
#else
#define CHECK_WX_ASSERT( STATEMENT )
#endif
 

class COUNTING_WXLOG : public wxLog
{
public:
    COUNTING_WXLOG( wxLogLevelValues aMaxLevel ) :
            m_maxLevel( aMaxLevel )
    {
    }
 
    unsigned GetCount() const { return m_count; }
 
protected:
    void DoLogRecord( wxLogLevel aLevel, const wxString&, const wxLogRecordInfo& ) override
    {
        if( aLevel <= m_maxLevel )
            m_count++;
    }
 
private:
    wxLogLevelValues m_maxLevel;
    unsigned         m_count = 0;
};
 

class SCOPED_COUNTING_WXLOG : public SCOPED_WXLOG_TARGET
{
public:
    SCOPED_COUNTING_WXLOG( unsigned* aLogCount, wxLogLevelValues aMaxLevel = wxLOG_Error ) :
            SCOPED_WXLOG_TARGET( &m_logger ),
            m_logger( aMaxLevel ),
            m_logCountRef( aLogCount )
    {
    }
 
    ~SCOPED_COUNTING_WXLOG()
    {
        // Update the caller's log count reference with the number of logs recorded
        if( m_logCountRef )
            *m_logCountRef = m_logger.GetCount();
    }
 
    /*
     * Gets the current count of matching log messages.
     */
    unsigned GetCount() const { return m_logger.GetCount(); }
 
private:
    COUNTING_WXLOG m_logger;
    unsigned*      m_logCountRef;
};
 

std::string GetEeschemaTestDataDir();
 
std::string GetTestDataRootDir();

std::vector<uint8_t> LoadBinaryData( const std::string& aFilePath, std::optional<size_t> aLoadBytes = std::nullopt );

std::string LoadStringData( const wxString& aPath );

bool CanDoDisplayTests();
 
} // namespace KI_TEST