1 files changed, 28 insertions, 19 deletions

diff --git a/src/test/bignum_tests.cpp b/src/test/bignum_tests.cpp
index 5b898d149..9d67324c7 100644
--- a/src/test/bignum_tests.cpp
+++ b/src/test/bignum_tests.cpp
@@ -1,8 +1,9 @@
-#include <boost/test/unit_test.hpp>
+#include "bignum.h"
+
 #include <limits>
+#include <stdint.h>
 
-#include "bignum.h"
-#include "util.h"
+#include <boost/test/unit_test.hpp>
 
 BOOST_AUTO_TEST_SUITE(bignum_tests)
 
@@ -46,7 +47,7 @@ BOOST_AUTO_TEST_SUITE(bignum_tests)
 // Let's force this code not to be inlined, in order to actually
 // test a generic version of the function. This increases the chance
 // that -ftrapv will detect overflows.
-NOINLINE void mysetint64(CBigNum& num, int64 n)
+NOINLINE void mysetint64(CBigNum& num, int64_t n)
 {
     num.setint64(n);
 }
@@ -55,7 +56,7 @@ NOINLINE void mysetint64(CBigNum& num, int64 n)
 // value to 0, then the second one with a non-inlined function.
 BOOST_AUTO_TEST_CASE(bignum_setint64)
 {
-    int64 n;
+    int64_t n;
 
     {
         n = 0;
@@ -103,7 +104,7 @@ BOOST_AUTO_TEST_CASE(bignum_setint64)
         BOOST_CHECK(num.ToString() == "-5");
     }
     {
-        n = std::numeric_limits<int64>::min();
+        n = std::numeric_limits<int64_t>::min();
         CBigNum num(n);
         BOOST_CHECK(num.ToString() == "-9223372036854775808");
         num.setulong(0);
@@ -112,7 +113,7 @@ BOOST_AUTO_TEST_CASE(bignum_setint64)
         BOOST_CHECK(num.ToString() == "-9223372036854775808");
     }
     {
-        n = std::numeric_limits<int64>::max();
+        n = std::numeric_limits<int64_t>::max();
         CBigNum num(n);
         BOOST_CHECK(num.ToString() == "9223372036854775807");
         num.setulong(0);
@@ -128,51 +129,59 @@ BOOST_AUTO_TEST_CASE(bignum_SetCompact)
     CBigNum num;
     num.SetCompact(0);
     BOOST_CHECK_EQUAL(num.GetHex(), "0");
-    BOOST_CHECK_EQUAL(num.GetCompact(), 0);
+    BOOST_CHECK_EQUAL(num.GetCompact(), 0U);
 
     num.SetCompact(0x00123456);
     BOOST_CHECK_EQUAL(num.GetHex(), "0");
-    BOOST_CHECK_EQUAL(num.GetCompact(), 0);
+    BOOST_CHECK_EQUAL(num.GetCompact(), 0U);
 
     num.SetCompact(0x01123456);
     BOOST_CHECK_EQUAL(num.GetHex(), "12");
-    BOOST_CHECK_EQUAL(num.GetCompact(), 0x01120000);
+    BOOST_CHECK_EQUAL(num.GetCompact(), 0x01120000U);
 
     // Make sure that we don't generate compacts with the 0x00800000 bit set
     num = 0x80;
-    BOOST_CHECK_EQUAL(num.GetCompact(), 0x02008000);
+    BOOST_CHECK_EQUAL(num.GetCompact(), 0x02008000U);
 
     num.SetCompact(0x01fedcba);
     BOOST_CHECK_EQUAL(num.GetHex(), "-7e");
-    BOOST_CHECK_EQUAL(num.GetCompact(), 0x01fe0000);
+    BOOST_CHECK_EQUAL(num.GetCompact(), 0x01fe0000U);
 
     num.SetCompact(0x02123456);
     BOOST_CHECK_EQUAL(num.GetHex(), "1234");
-    BOOST_CHECK_EQUAL(num.GetCompact(), 0x02123400);
+    BOOST_CHECK_EQUAL(num.GetCompact(), 0x02123400U);
 
     num.SetCompact(0x03123456);
     BOOST_CHECK_EQUAL(num.GetHex(), "123456");
-    BOOST_CHECK_EQUAL(num.GetCompact(), 0x03123456);
+    BOOST_CHECK_EQUAL(num.GetCompact(), 0x03123456U);
 
     num.SetCompact(0x04123456);
     BOOST_CHECK_EQUAL(num.GetHex(), "12345600");
-    BOOST_CHECK_EQUAL(num.GetCompact(), 0x04123456);
+    BOOST_CHECK_EQUAL(num.GetCompact(), 0x04123456U);
 
     num.SetCompact(0x04923456);
     BOOST_CHECK_EQUAL(num.GetHex(), "-12345600");
-    BOOST_CHECK_EQUAL(num.GetCompact(), 0x04923456);
+    BOOST_CHECK_EQUAL(num.GetCompact(), 0x04923456U);
 
     num.SetCompact(0x05009234);
     BOOST_CHECK_EQUAL(num.GetHex(), "92340000");
-    BOOST_CHECK_EQUAL(num.GetCompact(), 0x05009234);
+    BOOST_CHECK_EQUAL(num.GetCompact(), 0x05009234U);
 
     num.SetCompact(0x20123456);
     BOOST_CHECK_EQUAL(num.GetHex(), "1234560000000000000000000000000000000000000000000000000000000000");
-    BOOST_CHECK_EQUAL(num.GetCompact(), 0x20123456);
+    BOOST_CHECK_EQUAL(num.GetCompact(), 0x20123456U);
 
     num.SetCompact(0xff123456);
     BOOST_CHECK_EQUAL(num.GetHex(), "123456000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000");
-    BOOST_CHECK_EQUAL(num.GetCompact(), 0xff123456);
+    BOOST_CHECK_EQUAL(num.GetCompact(), 0xff123456U);
+}
+
+BOOST_AUTO_TEST_CASE(bignum_SetHex)
+{
+    std::string hexStr = "deecf97fd890808b9cc0f1b6a3e7a60b400f52710e6ad075b1340755bfa58cc9";
+    CBigNum num;
+    num.SetHex(hexStr);
+    BOOST_CHECK_EQUAL(num.GetHex(), hexStr);
 }
 
 BOOST_AUTO_TEST_SUITE_END()