Don't include unit test sources in code coverage (RIPD-1132):

Most files containing unit test code are moved to
src/test. JTx and the test client code are not yet moved.

src/test/basics/hardened_hash_test.cpp

@@ -0,0 +1,265 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of Beast: https://github.com/vinniefalco/Beast
+    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose  with  or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#include <BeastConfig.h>
+#include <ripple/basics/hardened_hash.h>
+#include <ripple/beast/unit_test.h>
+#include <boost/functional/hash.hpp>
+#include <array>
+#include <cstdint>
+#include <iomanip>
+#include <functional>
+#include <unordered_map>
+#include <unordered_set>
+
+namespace ripple {
+namespace detail {
+
+template <class T>
+class test_user_type_member
+{
+private:
+    T t;
+
+public:
+    explicit test_user_type_member (T const& t_ = T())
+        : t (t_)
+    {
+    }
+
+    template <class Hasher>
+    friend void hash_append (Hasher& h, test_user_type_member const& a) noexcept
+    {
+        using beast::hash_append;
+        hash_append (h, a.t);
+    }
+};
+
+template <class T>
+class test_user_type_free
+{
+private:
+    T t;
+
+public:
+    explicit test_user_type_free (T const& t_ = T())
+        : t (t_)
+    {
+    }
+
+    template <class Hasher>
+    friend void hash_append (Hasher& h, test_user_type_free const& a) noexcept
+    {
+        using beast::hash_append;
+        hash_append (h, a.t);
+    }
+};
+
+} // detail
+} // ripple
+
+//------------------------------------------------------------------------------
+
+namespace ripple {
+
+namespace detail {
+
+template <class T>
+using test_hardened_unordered_set =
+    std::unordered_set <T, hardened_hash <>>;
+
+template <class T>
+using test_hardened_unordered_map =
+    std::unordered_map <T, int, hardened_hash <>>;
+
+template <class T>
+using test_hardened_unordered_multiset =
+    std::unordered_multiset <T, hardened_hash <>>;
+
+template <class T>
+using test_hardened_unordered_multimap =
+    std::unordered_multimap <T, int, hardened_hash <>>;
+
+} // detail
+
+template <std::size_t Bits, class UInt = std::uint64_t>
+class unsigned_integer
+{
+private:
+    static_assert (std::is_integral<UInt>::value &&
+        std::is_unsigned <UInt>::value,
+            "UInt must be an unsigned integral type");
+
+    static_assert (Bits%(8*sizeof(UInt))==0,
+        "Bits must be a multiple of 8*sizeof(UInt)");
+
+    static_assert (Bits >= (8*sizeof(UInt)),
+        "Bits must be at least 8*sizeof(UInt)");
+
+    static std::size_t const size = Bits/(8*sizeof(UInt));
+
+    std::array <UInt, size> m_vec;
+
+public:
+    using value_type = UInt;
+
+    static std::size_t const bits = Bits;
+    static std::size_t const bytes = bits / 8;
+
+    template <class Int>
+    static
+    unsigned_integer
+    from_number (Int v)
+    {
+        unsigned_integer result;
+        for (std::size_t i (1); i < size; ++i)
+            result.m_vec [i] = 0;
+        result.m_vec[0] = v;
+        return result;
+    }
+
+    void*
+    data() noexcept
+    {
+        return &m_vec[0];
+    }
+
+    void const*
+    data() const noexcept
+    {
+        return &m_vec[0];
+    }
+
+    template <class Hasher>
+    friend void hash_append(Hasher& h, unsigned_integer const& a) noexcept
+    {
+        using beast::hash_append;
+        hash_append (h, a.m_vec);
+    }
+
+    friend
+    std::ostream&
+    operator<< (std::ostream& s, unsigned_integer const& v)
+    {
+        for (std::size_t i (0); i < size; ++i)
+            s <<
+                std::hex <<
+                std::setfill ('0') <<
+                std::setw (2*sizeof(UInt)) <<
+                v.m_vec[i]
+                ;
+        return s;
+    }
+};
+
+using sha256_t = unsigned_integer <256, std::size_t>;
+
+static_assert (sha256_t::bits == 256,
+    "sha256_t must have 256 bits");
+
+} // ripple
+
+//------------------------------------------------------------------------------
+
+namespace ripple {
+
+class hardened_hash_test
+    : public beast::unit_test::suite
+{
+public:
+    template <class T>
+    void
+    check ()
+    {
+        T t{};
+        hardened_hash <>() (t);
+        pass();
+    }
+
+    template <template <class T> class U>
+    void
+    check_user_type()
+    {
+        check <U <bool>> ();
+        check <U <char>> ();
+        check <U <signed char>> ();
+        check <U <unsigned char>> ();
+        // These cause trouble for boost
+        //check <U <char16_t>> ();
+        //check <U <char32_t>> ();
+        check <U <wchar_t>> ();
+        check <U <short>> ();
+        check <U <unsigned short>> ();
+        check <U <int>> ();
+        check <U <unsigned int>> ();
+        check <U <long>> ();
+        check <U <long long>> ();
+        check <U <unsigned long>> ();
+        check <U <unsigned long long>> ();
+        check <U <float>> ();
+        check <U <double>> ();
+        check <U <long double>> ();
+    }
+
+    template <template <class T> class C >
+    void
+    check_container()
+    {
+        {
+            C <detail::test_user_type_member <std::string>> c;
+        }
+
+        pass();
+
+        {
+            C <detail::test_user_type_free <std::string>> c;
+        }
+
+        pass();
+    }
+
+    void
+    test_user_types()
+    {
+        testcase ("user types");
+        check_user_type <detail::test_user_type_member> ();
+        check_user_type <detail::test_user_type_free> ();
+    }
+
+    void
+    test_containers()
+    {
+        testcase ("containers");
+        check_container <detail::test_hardened_unordered_set>();
+        check_container <detail::test_hardened_unordered_map>();
+        check_container <detail::test_hardened_unordered_multiset>();
+        check_container <detail::test_hardened_unordered_multimap>();
+    }
+
+    void
+    run ()
+    {
+        test_user_types();
+        test_containers();
+    }
+};
+
+BEAST_DEFINE_TESTSUITE(hardened_hash,basics,ripple);
+
+} // ripple