ARCHIVE/xahaud
3
0
Fork 0
mirror of https://github.com/Xahau/xahaud.git synced 2025-12-06 17:27:52 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix RippleBookType and unit tests

Browse Source
This commit is contained in:
Vinnie Falco
2013-12-27 21:18:46 -08:00
parent 27b771e2ba
commit 49677aa799
2 changed files with 332 additions and 125 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/ripple/types/api/RippleAssets.h
View File

@@ -180,8 +180,8 @@ bool operator<= (RippleAssetType <LhsByValue> const& lhs,
//------------------------------------------------------------------------------
typedef RippleAssetType <false> RippleAssetRef;
typedef RippleAssetType <true> RippleAsset;
typedef RippleAssetType <false> RippleAssetRef;
/** Create an asset specifier by parsing the given JSON.
Errors, if any, will be returned or injected into the specified result
@@ -285,7 +285,7 @@ bool operator< (RippleBookType <LhsByValue> const& lhs,
RippleBookType <RhsByValue> const& rhs)
{
int const diff (compare (lhs.in, rhs.in));
if (diff != 0 || lhs.in.is_xrp ())
if (diff != 0)
return diff < 0;
return lhs.out < rhs.out;
}
@@ -314,8 +314,8 @@ bool operator<= (RippleBookType <LhsByValue> const& lhs,
//------------------------------------------------------------------------------
typedef RippleBookType <false> RippleBook;
typedef RippleBookType <true> RippleBookRef;
typedef RippleBookType <true> RippleBook;
typedef RippleBookType <false> RippleBookRef;
}

449
src/ripple/types/impl/RippleAssets.cpp
View File

@@ -18,6 +18,7 @@
//==============================================================================
#include <set>
#include <typeinfo>
#include <unordered_set>
#include <boost/unordered_set.hpp>
@@ -32,6 +33,81 @@ namespace ripple {
class RippleAssetTests : public UnitTest
{
public:
// Comparison, hash tests for uint60 (via base_uint)
template <typename Unsigned>
void testUnsigned ()
{
Unsigned const u1 (1);
Unsigned const u2 (2);
Unsigned const u3 (3);
expect (u1 != u2);
expect (u1 < u2);
expect (u1 <= u2);
expect (u2 <= u2);
expect (u2 == u2);
expect (u2 >= u2);
expect (u3 >= u2);
expect (u3 > u2);
std::hash <Unsigned> const hash;
expect (hash (u1) == hash (u1));
expect (hash (u2) == hash (u2));
expect (hash (u3) == hash (u3));
expect (hash (u1) != hash (u2));
expect (hash (u1) != hash (u3));
expect (hash (u2) != hash (u3));
}
//--------------------------------------------------------------------------
// Comparison, hash tests for RippleAssetType
template <class Asset>
void testAssetType ()
{
RippleCurrency const c1 (1); RippleIssuer const i1 (1);
RippleCurrency const c2 (2); RippleIssuer const i2 (2);
RippleCurrency const c3 (3); RippleIssuer const i3 (3);
expect (Asset (c1, i1) != Asset (c2, i1));
expect (Asset (c1, i1) < Asset (c2, i1));
expect (Asset (c1, i1) <= Asset (c2, i1));
expect (Asset (c2, i1) <= Asset (c2, i1));
expect (Asset (c2, i1) == Asset (c2, i1));
expect (Asset (c2, i1) >= Asset (c2, i1));
expect (Asset (c3, i1) >= Asset (c2, i1));
expect (Asset (c3, i1) > Asset (c2, i1));
expect (Asset (c1, i1) != Asset (c1, i2));
expect (Asset (c1, i1) < Asset (c1, i2));
expect (Asset (c1, i1) <= Asset (c1, i2));
expect (Asset (c1, i2) <= Asset (c1, i2));
expect (Asset (c1, i2) == Asset (c1, i2));
expect (Asset (c1, i2) >= Asset (c1, i2));
expect (Asset (c1, i3) >= Asset (c1, i2));
expect (Asset (c1, i3) > Asset (c1, i2));
std::hash <Asset> const hash;
expect (hash (Asset (c1, i1)) == hash (Asset (c1, i1)));
expect (hash (Asset (c1, i2)) == hash (Asset (c1, i2)));
expect (hash (Asset (c1, i3)) == hash (Asset (c1, i3)));
expect (hash (Asset (c2, i1)) == hash (Asset (c2, i1)));
expect (hash (Asset (c2, i2)) == hash (Asset (c2, i2)));
expect (hash (Asset (c2, i3)) == hash (Asset (c2, i3)));
expect (hash (Asset (c3, i1)) == hash (Asset (c3, i1)));
expect (hash (Asset (c3, i2)) == hash (Asset (c3, i2)));
expect (hash (Asset (c3, i3)) == hash (Asset (c3, i3)));
expect (hash (Asset (c1, i1)) != hash (Asset (c1, i2)));
expect (hash (Asset (c1, i1)) != hash (Asset (c1, i3)));
expect (hash (Asset (c1, i1)) != hash (Asset (c2, i1)));
expect (hash (Asset (c1, i1)) != hash (Asset (c2, i2)));
expect (hash (Asset (c1, i1)) != hash (Asset (c2, i3)));
expect (hash (Asset (c1, i1)) != hash (Asset (c3, i1)));
expect (hash (Asset (c1, i1)) != hash (Asset (c3, i2)));
expect (hash (Asset (c1, i1)) != hash (Asset (c3, i3)));
}
template <class Set>
void testAssetSet ()
{
@@ -42,27 +118,40 @@ public:
RippleAssetRef const a1 (c1, i1);
RippleAssetRef const a2 (c2, i2);
Set c;
{
Set c;
c.insert (a1);
c.insert (a2);
expect (c.erase (RippleAsset (c1, i2)) == 0);
expect (c.erase (RippleAsset (c1, i1)) == 1);
expect (c.erase (RippleAsset (c2, i2)) == 1);
expect (c.empty ());
c.insert (a1);
if (! expect (c.size () == 1)) return;
c.insert (a2);
if (! expect (c.size () == 2)) return;
c.insert (a1);
c.insert (a2);
expect (c.erase (RippleAssetRef (c1, i2)) == 0);
expect (c.erase (RippleAssetRef (c1, i1)) == 1);
expect (c.erase (RippleAssetRef (c2, i2)) == 1);
expect (c.empty ());
if (! expect (c.erase (RippleAsset (c1, i2)) == 0)) return;
if (! expect (c.erase (RippleAsset (c1, i1)) == 1)) return;
if (! expect (c.erase (RippleAsset (c2, i2)) == 1)) return;
if (! expect (c.empty ())) return;
}
#if STL_SET_HAS_EMPLACE
c.emplace (c1, i1);
c.emplace (c2, i2);
expect (c.size() == 2);
#endif
{
Set c;
c.insert (a1);
if (! expect (c.size () == 1)) return;
c.insert (a2);
if (! expect (c.size () == 2)) return;
if (! expect (c.erase (RippleAssetRef (c1, i2)) == 0)) return;
if (! expect (c.erase (RippleAssetRef (c1, i1)) == 1)) return;
if (! expect (c.erase (RippleAssetRef (c2, i2)) == 1)) return;
if (! expect (c.empty ())) return;
#if STL_SET_HAS_EMPLACE
c.emplace (c1, i1);
if (! expect (c.size() == 1)) return;
c.emplace (c2, i2);
if (! expect (c.size() == 2)) return;
#endif
}
}
template <class Map>
@@ -75,74 +164,119 @@ public:
RippleAssetRef const a1 (c1, i1);
RippleAssetRef const a2 (c2, i2);
Map c;
{
Map c;
c.insert (std::make_pair (a1, 1));
c.insert (std::make_pair (a2, 2));
expect (c.erase (RippleAsset (c1, i2)) == 0);
expect (c.erase (RippleAsset (c1, i1)) == 1);
expect (c.erase (RippleAsset (c2, i2)) == 1);
expect (c.empty ());
c.insert (std::make_pair (a1, 1));
if (! expect (c.size () == 1)) return;
c.insert (std::make_pair (a2, 2));
if (! expect (c.size () == 2)) return;
c.insert (std::make_pair (a1, 1));
c.insert (std::make_pair (a2, 2));
expect (c.erase (RippleAssetRef (c1, i2)) == 0);
expect (c.erase (RippleAssetRef (c1, i1)) == 1);
expect (c.erase (RippleAssetRef (c2, i2)) == 1);
expect (c.empty ());
if (! expect (c.erase (RippleAsset (c1, i2)) == 0)) return;
if (! expect (c.erase (RippleAsset (c1, i1)) == 1)) return;
if (! expect (c.erase (RippleAsset (c2, i2)) == 1)) return;
if (! expect (c.empty ())) return;
}
{
Map c;
c.insert (std::make_pair (a1, 1));
if (! expect (c.size () == 1)) return;
c.insert (std::make_pair (a2, 2));
if (! expect (c.size () == 2)) return;
if (! expect (c.erase (RippleAssetRef (c1, i2)) == 0)) return;
if (! expect (c.erase (RippleAssetRef (c1, i1)) == 1)) return;
if (! expect (c.erase (RippleAssetRef (c2, i2)) == 1)) return;
if (! expect (c.empty ())) return;
}
}
void testAssets ()
void testAssetSets ()
{
beginTestCase ("assets");
RippleCurrency const c1 (1);
RippleIssuer const i1 (1);
RippleCurrency const c2 (2);
RippleIssuer const i2 (2);
{
RippleAssetRef a0 (xrp_asset ());
expect (a0 == xrp_asset());
RippleAssetRef a1 (c1, i1);
RippleAssetRef a2 (a1);
expect (a1 == a2);
}
{
// VFALCO NOTE this should be uninitialized
RippleAsset uninitialized_asset;
}
{
RippleAsset a1 (c1, i1);
RippleAsset a2 (a1);
expect (a1 == a2);
expect (a1 != xrp_asset());
a2 = RippleAsset (c2, i2);
expect (a1 < a2);
}
beginTestCase ("std::set <RippleAsset>");
testAssetSet <std::set <RippleAsset>> ();
testAssetSet <std::set <RippleAssetRef>> ();
testAssetSet <std::unordered_set <RippleAsset>> ();
testAssetSet <std::unordered_set <RippleAssetRef>> ();
testAssetSet <boost::unordered_set <RippleAsset>> ();
testAssetSet <boost::unordered_set <RippleAssetRef>> ();
beginTestCase ("std::set <RippleAssetRef>");
testAssetSet <std::set <RippleAssetRef>> ();
beginTestCase ("std::unordered_set <RippleAsset>");
testAssetSet <std::unordered_set <RippleAsset>> ();
beginTestCase ("std::unordered_set <RippleAssetRef>");
testAssetSet <std::unordered_set <RippleAssetRef>> ();
beginTestCase ("boost::unordered_set <RippleAsset>");
testAssetSet <boost::unordered_set <RippleAsset>> ();
beginTestCase ("boost::unordered_set <RippleAssetRef>");
testAssetSet <boost::unordered_set <RippleAssetRef>> ();
}
void testAssetMaps ()
{
beginTestCase ("std::map <RippleAsset, int>");
testAssetMap <std::map <RippleAsset, int>> ();
beginTestCase ("std::map <RippleAssetRef, int>");
testAssetMap <std::map <RippleAssetRef, int>> ();
beginTestCase ("std::unordered_map <RippleAsset, int>");
testAssetMap <std::unordered_map <RippleAsset, int>> ();
beginTestCase ("std::unordered_map <RippleAssetRef, int>");
testAssetMap <std::unordered_map <RippleAssetRef, int>> ();
beginTestCase ("boost::unordered_map <RippleAsset, int>");
testAssetMap <boost::unordered_map <RippleAsset, int>> ();
beginTestCase ("boost::unordered_map <RippleAssetRef, int>");
testAssetMap <boost::unordered_map <RippleAssetRef, int>> ();
}
//--------------------------------------------------------------------------
// Comparison, hash tests for RippleBookType
template <class Book>
void testBook ()
{
RippleCurrency const c1 (1); RippleIssuer const i1 (1);
RippleCurrency const c2 (2); RippleIssuer const i2 (2);
RippleCurrency const c3 (3); RippleIssuer const i3 (3);
RippleAsset a1 (c1, i1);
RippleAsset a2 (c1, i2);
RippleAsset a3 (c2, i2);
RippleAsset a4 (c3, i2);
expect (Book (a1, a2) != Book (a2, a3));
expect (Book (a1, a2) < Book (a2, a3));
expect (Book (a1, a2) <= Book (a2, a3));
expect (Book (a2, a3) <= Book (a2, a3));
expect (Book (a2, a3) == Book (a2, a3));
expect (Book (a2, a3) >= Book (a2, a3));
expect (Book (a3, a4) >= Book (a2, a3));
expect (Book (a3, a4) > Book (a2, a3));
std::hash <Book> const hash;
expect (hash (Book (a1, a2)) == hash (Book (a1, a2)));
expect (hash (Book (a1, a3)) == hash (Book (a1, a3)));
expect (hash (Book (a1, a4)) == hash (Book (a1, a4)));
expect (hash (Book (a2, a3)) == hash (Book (a2, a3)));
expect (hash (Book (a2, a4)) == hash (Book (a2, a4)));
expect (hash (Book (a3, a4)) == hash (Book (a3, a4)));
expect (hash (Book (a1, a2)) != hash (Book (a1, a3)));
expect (hash (Book (a1, a2)) != hash (Book (a1, a4)));
expect (hash (Book (a1, a2)) != hash (Book (a2, a3)));
expect (hash (Book (a1, a2)) != hash (Book (a2, a4)));
expect (hash (Book (a1, a2)) != hash (Book (a3, a4)));
}
//--------------------------------------------------------------------------
template <class Set>
void testBookSet ()
{
@@ -155,27 +289,40 @@ public:
RippleBookRef const b1 (a1, a2);
RippleBookRef const b2 (a2, a1);
Set c;
{
Set c;
c.insert (b1);
c.insert (b2);
expect (c.erase (RippleBook (a1, a1)) == 0);
expect (c.erase (RippleBook (a1, a2)) == 1);
expect (c.erase (RippleBook (a2, a1)) == 1);
expect (c.empty ());
c.insert (b1);
if (! expect (c.size () == 1)) return;
c.insert (b2);
if (! expect (c.size () == 2)) return;
c.insert (b1);
c.insert (b2);
expect (c.erase (RippleBookRef (a1, a1)) == 0);
expect (c.erase (RippleBookRef (a1, a2)) == 1);
expect (c.erase (RippleBookRef (a2, a1)) == 1);
expect (c.empty ());
if (! expect (c.erase (RippleBook (a1, a1)) == 0)) return;
if (! expect (c.erase (RippleBook (a1, a2)) == 1)) return;
if (! expect (c.erase (RippleBook (a2, a1)) == 1)) return;
if (! expect (c.empty ())) return;
}
#if STL_SET_HAS_EMPLACE
c.emplace (a1, a2);
c.emplace (a2, a1);
expect (c.size() == 2);
#endif
{
Set c;
c.insert (b1);
if (! expect (c.size () == 1)) return;
c.insert (b2);
if (! expect (c.size () == 2)) return;
if (! expect (c.erase (RippleBookRef (a1, a1)) == 0)) return;
if (! expect (c.erase (RippleBookRef (a1, a2)) == 1)) return;
if (! expect (c.erase (RippleBookRef (a2, a1)) == 1)) return;
if (! expect (c.empty ())) return;
#if STL_SET_HAS_EMPLACE
c.emplace (a1, a2);
if (! expect (c.size() == 1)) return;
c.emplace (a2, a1);
if (! expect (c.size() == 2)) return;
#endif
}
}
template <class Map>
@@ -190,55 +337,115 @@ public:
RippleBookRef const b1 (a1, a2);
RippleBookRef const b2 (a2, a1);
Map c;
//typename Map::value_type value_type;
//std::pair <RippleBookRef const, int> value_type;
c.insert (std::make_pair (b1, 1));
c.insert (std::make_pair (b2, 2));
expect (c.erase (RippleBook (a1, a1)) == 0);
expect (c.erase (RippleBook (a1, a2)) == 1);
expect (c.erase (RippleBook (a2, a1)) == 1);
expect (c.empty ());
{
Map c;
c.insert (std::make_pair (b1, 1));
c.insert (std::make_pair (b2, 2));
expect (c.erase (RippleBookRef (a1, a1)) == 0);
expect (c.erase (RippleBookRef (a1, a2)) == 1);
expect (c.erase (RippleBookRef (a2, a1)) == 1);
expect (c.empty ());
//c.insert (value_type (b1, 1));
c.insert (std::make_pair (b1, 1));
if (! expect (c.size () == 1)) return;
//c.insert (value_type (b2, 2));
c.insert (std::make_pair (b2, 1));
if (! expect (c.size () == 2)) return;
if (! expect (c.erase (RippleBook (a1, a1)) == 0)) return;
if (! expect (c.erase (RippleBook (a1, a2)) == 1)) return;
if (! expect (c.erase (RippleBook (a2, a1)) == 1)) return;
if (! expect (c.empty ())) return;
}
{
Map c;
//c.insert (value_type (b1, 1));
c.insert (std::make_pair (b1, 1));
if (! expect (c.size () == 1)) return;
//c.insert (value_type (b2, 2));
c.insert (std::make_pair (b2, 1));
if (! expect (c.size () == 2)) return;
if (! expect (c.erase (RippleBookRef (a1, a1)) == 0)) return;
if (! expect (c.erase (RippleBookRef (a1, a2)) == 1)) return;
if (! expect (c.erase (RippleBookRef (a2, a1)) == 1)) return;
if (! expect (c.empty ())) return;
}
}
void testBooks ()
void testBookSets ()
{
beginTestCase ("books");
RippleAsset a1 (RippleCurrency (1), RippleIssuer (1));
RippleAsset a2 (RippleCurrency (2), RippleIssuer (2));
RippleBook b1 (a1, a2);
RippleBook b2 (a2, a1);
expect (b1 != b2);
expect (b1 < b2);
beginTestCase ("std::set <RippleBook>");
testBookSet <std::set <RippleBook>> ();
testBookSet <std::set <RippleBookRef>> ();
testBookSet <std::unordered_set <RippleBook>> ();
testBookSet <std::unordered_set <RippleBookRef>> ();
testBookSet <boost::unordered_set <RippleBook>> ();
testBookSet <boost::unordered_set <RippleBookRef>> ();
beginTestCase ("std::set <RippleBookRef>");
testBookSet <std::set <RippleBookRef>> ();
beginTestCase ("std::unordered_set <RippleBook>");
testBookSet <std::unordered_set <RippleBook>> ();
beginTestCase ("std::unordered_set <RippleBookRef>");
testBookSet <std::unordered_set <RippleBookRef>> ();
beginTestCase ("boost::unordered_set <RippleBook>");
testBookSet <boost::unordered_set <RippleBook>> ();
beginTestCase ("boost::unordered_set <RippleBookRef>");
testBookSet <boost::unordered_set <RippleBookRef>> ();
}
void testBookMaps ()
{
beginTestCase ("std::map <RippleBook, int>");
testBookMap <std::map <RippleBook, int>> ();
beginTestCase ("std::map <RippleBookRef, int>");
testBookMap <std::map <RippleBookRef, int>> ();
beginTestCase ("std::unordered_map <RippleBook, int>");
testBookMap <std::unordered_map <RippleBook, int>> ();
beginTestCase ("std::unordered_map <RippleBookRef, int>");
testBookMap <std::unordered_map <RippleBookRef, int>> ();
beginTestCase ("boost::unordered_map <RippleBook, int>");
testBookMap <boost::unordered_map <RippleBook, int>> ();
beginTestCase ("boost::unordered_map <RippleBookRef, int>");
testBookMap <boost::unordered_map <RippleBookRef, int>> ();
}
//--------------------------------------------------------------------------
void runTest ()
{
testAssets ();
testBooks ();
beginTestCase ("RippleCurrency");
testUnsigned <RippleCurrency> ();
beginTestCase ("RippleIssuer");
testUnsigned <RippleIssuer> ();
// ---
beginTestCase ("RippleAsset");
testAssetType <RippleAsset> ();
beginTestCase ("RippleAssetRef");
testAssetType <RippleAssetRef> ();
testAssetSets ();
testAssetMaps ();
// ---
beginTestCase ("RippleBook");
testBook <RippleBook> ();
beginTestCase ("RippleBookRef");
testBook <RippleBookRef> ();
testBookSets ();
testBookMaps ();
}
RippleAssetTests () : UnitTest ("RippleAsset", "ripple")