/* $Id: tstRTBigNum.cpp $ */
/** @file
 * IPRT - Testcase for the RTBigNum* functions.
 */

/*
 * Copyright (C) 2006-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 *
 * The contents of this file may alternatively be used under the terms
 * of the Common Development and Distribution License Version 1.0
 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
 * VirtualBox OSE distribution, in which case the provisions of the
 * CDDL are applicable instead of those of the GPL.
 *
 * You may elect to license modified versions of this file under the
 * terms and conditions of either the GPL or the CDDL or both.
 */


/*********************************************************************************************************************************
*   Header Files                                                                                                                 *
*********************************************************************************************************************************/
#include <iprt/bignum.h>
#include <iprt/uint128.h>
#include <iprt/uint64.h>
#include <iprt/uint32.h>

#include <iprt/err.h>
#include <iprt/rand.h>
#include <iprt/string.h>
#include <iprt/test.h>
#include <iprt/thread.h>
#include <iprt/time.h>

#if 1
# include <openssl/bn.h>
#endif


/*********************************************************************************************************************************
*   Global Variables                                                                                                             *
*********************************************************************************************************************************/
static RTTEST g_hTest;


static uint8_t const g_abLargePositive[] =
{
    0x67,0xcd,0xd6,0x60,0x4e,0xaa,0xe9,0x8e,0x06,0x99,0xde,0xb2,0xf5,0x1c,0xc3,0xfc,
    0xf5,0x17,0x41,0xec,0x42,0x68,0xf0,0xab,0x0e,0xe6,0x79,0xa8,0x32,0x97,0x55,0x00,
    0x49,0x21,0x2b,0x72,0x4b,0x34,0x33,0xe1,0xe2,0xfe,0xa2,0xb8,0x39,0x7a,0x2f,0x17,
    0xae,0x1f,0xbb,0xdb,0x46,0xbc,0x59,0x8b,0x13,0x05,0x28,0x96,0xf6,0xfd,0xc1,0xa4
};
static RTBIGNUM g_LargePositive;
static RTBIGNUM g_LargePositive2; /**< Smaller than g_LargePositive.  */

static uint8_t const g_abLargePositiveMinus1[] =
{
    0x67,0xcd,0xd6,0x60,0x4e,0xaa,0xe9,0x8e,0x06,0x99,0xde,0xb2,0xf5,0x1c,0xc3,0xfc,
    0xf5,0x17,0x41,0xec,0x42,0x68,0xf0,0xab,0x0e,0xe6,0x79,0xa8,0x32,0x97,0x55,0x00,
    0x49,0x21,0x2b,0x72,0x4b,0x34,0x33,0xe1,0xe2,0xfe,0xa2,0xb8,0x39,0x7a,0x2f,0x17,
    0xae,0x1f,0xbb,0xdb,0x46,0xbc,0x59,0x8b,0x13,0x05,0x28,0x96,0xf6,0xfd,0xc1,0xa3
};
static RTBIGNUM g_LargePositiveMinus1; /**< g_LargePositive - 1 */


static uint8_t const g_abLargeNegative[] =
{
    0xf2,0xde,0xbd,0xaf,0x43,0x9e,0x1e,0x88,0xdc,0x64,0x37,0xa9,0xdb,0xb7,0x26,0x31,
    0x92,0x1d,0xf5,0x43,0x4c,0xb0,0x21,0x2b,0x07,0x4e,0xf5,0x94,0x9e,0xce,0x15,0x79,
    0x13,0x0c,0x70,0x68,0x49,0x46,0xcf,0x72,0x2b,0xc5,0x8f,0xab,0x7c,0x88,0x2d,0x1e,
    0x3b,0x43,0x5b,0xdb,0x47,0x45,0x7a,0x25,0x74,0x46,0x1d,0x87,0x24,0xaa,0xab,0x0d,
    0x3e,0xdf,0xd1,0xd8,0x44,0x6f,0x01,0x84,0x01,0x36,0xe0,0x84,0x6e,0x6f,0x41,0xbb,
    0xae,0x1a,0x31,0xef,0x42,0x23,0xfd,0xda,0xda,0x0f,0x7d,0x88,0x8f,0xf5,0x63,0x72,
    0x36,0x9f,0xa9,0xa4,0x4f,0xa0,0xa6,0xb1,0x3b,0xbe,0x0d,0x9d,0x62,0x88,0x98,0x8b
};
static RTBIGNUM g_LargeNegative;
static RTBIGNUM g_LargeNegative2; /**< A few digits less than g_LargeNegative, i.e. larger value.  */

static uint8_t const g_abLargeNegativePluss1[] =
{
    0xf2,0xde,0xbd,0xaf,0x43,0x9e,0x1e,0x88,0xdc,0x64,0x37,0xa9,0xdb,0xb7,0x26,0x31,
    0x92,0x1d,0xf5,0x43,0x4c,0xb0,0x21,0x2b,0x07,0x4e,0xf5,0x94,0x9e,0xce,0x15,0x79,
    0x13,0x0c,0x70,0x68,0x49,0x46,0xcf,0x72,0x2b,0xc5,0x8f,0xab,0x7c,0x88,0x2d,0x1e,
    0x3b,0x43,0x5b,0xdb,0x47,0x45,0x7a,0x25,0x74,0x46,0x1d,0x87,0x24,0xaa,0xab,0x0d,
    0x3e,0xdf,0xd1,0xd8,0x44,0x6f,0x01,0x84,0x01,0x36,0xe0,0x84,0x6e,0x6f,0x41,0xbb,
    0xae,0x1a,0x31,0xef,0x42,0x23,0xfd,0xda,0xda,0x0f,0x7d,0x88,0x8f,0xf5,0x63,0x72,
    0x36,0x9f,0xa9,0xa4,0x4f,0xa0,0xa6,0xb1,0x3b,0xbe,0x0d,0x9d,0x62,0x88,0x98,0x8c
};
static RTBIGNUM g_LargeNegativePluss1; /**< g_LargeNegative + 1 */


static uint8_t const g_ab64BitPositive1[] = { 0x53, 0xe0, 0xdf, 0x11,  0x85, 0x93, 0x06, 0x21 };
static uint64_t g_u64BitPositive1 = UINT64_C(0x53e0df1185930621);
static RTBIGNUM g_64BitPositive1;


static RTBIGNUM g_Zero;
static RTBIGNUM g_One;
static RTBIGNUM g_Two;
static RTBIGNUM g_Three;
static RTBIGNUM g_Four;
static RTBIGNUM g_Five;
static RTBIGNUM g_Ten;
static RTBIGNUM g_FourtyTwo;

static uint8_t const g_abMinus1[] = { 0xff, 0xff, 0xff, 0xff,  0xff, 0xff, 0xff, 0xff };
//static int64_t  g_iBitMinus1 = -1;
static RTBIGNUM g_Minus1;


/** @name The components of a real PKCS #7 signature (extracted from a build of
 *   this testcase).
 * @{ */
static uint8_t const g_abPubKeyExp[] = { 0x01, 0x00, 0x01 };
static RTBIGNUM      g_PubKeyExp;
static uint8_t const g_abPubKeyMod[] =
{
    0x00, 0xea, 0x61, 0x4e, 0xa0, 0xb2, 0xae, 0x38, 0xbc, 0x43, 0x24, 0x5a, 0x28, 0xc7, 0xa0, 0x69,
    0x82, 0x11, 0xd5, 0x78, 0xe8, 0x6b, 0x41, 0x54, 0x7b, 0x6c, 0x69, 0x13, 0xc8, 0x68, 0x75, 0x0f,
    0xe4, 0x66, 0x54, 0xcd, 0xe3, 0x55, 0x33, 0x3b, 0x7f, 0x9f, 0x55, 0x75, 0x80, 0x6e, 0xd0, 0x8a,
    0xff, 0xc1, 0xf4, 0xbf, 0xfd, 0x70, 0x9b, 0x73, 0x7e, 0xee, 0xf1, 0x80, 0x23, 0xd4, 0xbd, 0xba,
    0xdc, 0xce, 0x09, 0x4a, 0xeb, 0xb0, 0xdd, 0x86, 0x4a, 0x0b, 0x8e, 0x3e, 0x9a, 0x8a, 0x58, 0xed,
    0x98, 0x4f, 0x25, 0xe5, 0x0c, 0x18, 0xd8, 0x10, 0x95, 0xce, 0xe4, 0x19, 0x82, 0x38, 0xcd, 0x76,
    0x6a, 0x38, 0xe5, 0x14, 0xe6, 0x95, 0x0d, 0x80, 0xc5, 0x09, 0x5e, 0x93, 0xf4, 0x6f, 0x82, 0x8e,
    0x9c, 0x81, 0x09, 0xd6, 0xd4, 0xee, 0xd5, 0x1f, 0x94, 0x2d, 0x13, 0x18, 0x9a, 0xbc, 0x88, 0x5d,
    0x9a, 0xe5, 0x66, 0x08, 0x99, 0x93, 0x1b, 0x8a, 0x69, 0x3f, 0x68, 0xb2, 0x97, 0x2a, 0x24, 0xf6,
    0x65, 0x2a, 0x94, 0x33, 0x94, 0x14, 0x5c, 0x6f, 0xff, 0x95, 0xd0, 0x2b, 0xf0, 0x2b, 0xcb, 0x49,
    0xcd, 0x03, 0x3a, 0x45, 0xd5, 0x22, 0x1c, 0xb3, 0xee, 0xd5, 0xaf, 0xb3, 0x5b, 0xcb, 0x1b, 0x35,
    0x4e, 0xff, 0x21, 0x0a, 0x55, 0x1f, 0xa0, 0xf9, 0xdc, 0xad, 0x7a, 0x89, 0x0b, 0x6e, 0x3f, 0x75,
    0xc0, 0x6c, 0x44, 0xff, 0x90, 0x63, 0x79, 0xcf, 0x70, 0x20, 0x60, 0x33, 0x3c, 0xb1, 0xfa, 0x6b,
    0x6c, 0x55, 0x3c, 0xeb, 0x8d, 0x18, 0xe9, 0x0a, 0x81, 0xd5, 0x24, 0xc1, 0x88, 0x7c, 0xa6, 0x8e,
    0xd3, 0x2c, 0x51, 0x1d, 0x6d, 0xdf, 0x51, 0xd5, 0x72, 0x54, 0x7a, 0x98, 0xc0, 0x36, 0x35, 0x21,
    0x66, 0x3c, 0x2f, 0x01, 0xc0, 0x8e, 0xb0, 0x56, 0x60, 0x6e, 0x67, 0x4f, 0x5f, 0xac, 0x05, 0x60,
    0x9b
};
static RTBIGNUM g_PubKeyMod;
static uint8_t const g_abSignature[] =
{
    0x00, 0xae, 0xca, 0x93, 0x47, 0x0b, 0xfa, 0xd8, 0xb9, 0xbb, 0x5a, 0x5e, 0xf6, 0x75, 0x90, 0xed,
    0x80, 0x37, 0x03, 0x6d, 0x23, 0x91, 0x30, 0x0c, 0x9d, 0xbf, 0x34, 0xc1, 0xf9, 0x43, 0xa7, 0xec,
    0xc0, 0x83, 0xc0, 0x98, 0x3f, 0x8a, 0x65, 0x48, 0x7c, 0xa4, 0x9f, 0x14, 0x4d, 0x52, 0x90, 0x2d,
    0x17, 0xd1, 0x3e, 0x05, 0xd6, 0x35, 0x1b, 0xdb, 0xe5, 0x1a, 0xa2, 0x54, 0x8c, 0x30, 0x6f, 0xfe,
    0xa1, 0xd9, 0x98, 0x3f, 0xb5, 0x65, 0x14, 0x9c, 0x50, 0x55, 0xa1, 0xbf, 0xb5, 0x12, 0xc4, 0xf2,
    0x72, 0x27, 0x14, 0x59, 0xb5, 0x23, 0x67, 0x11, 0x2a, 0xd8, 0xa8, 0x85, 0x4b, 0xc5, 0xb0, 0x2f,
    0x73, 0x54, 0xcf, 0x33, 0xa0, 0x06, 0xf2, 0x8e, 0x4f, 0x4b, 0x18, 0x97, 0x08, 0x47, 0xce, 0x0c,
    0x47, 0x97, 0x0d, 0xbd, 0x8b, 0xce, 0x61, 0x31, 0x21, 0x7e, 0xc4, 0x1d, 0x03, 0xf8, 0x06, 0xca,
    0x9f, 0xd3, 0x5e, 0x4b, 0xfc, 0xf1, 0x99, 0x34, 0x78, 0x83, 0xfa, 0xab, 0x9c, 0x7c, 0x6b, 0x5c,
    0x3d, 0x45, 0x39, 0x6d, 0x6a, 0x6c, 0xd5, 0x63, 0x3e, 0xbe, 0x09, 0x62, 0x64, 0x5f, 0x83, 0x3b,
    0xb6, 0x5c, 0x7e, 0x8e, 0xeb, 0x1e, 0x6a, 0x34, 0xb9, 0xc7, 0x92, 0x92, 0x58, 0x64, 0x48, 0xfe,
    0xf8, 0x35, 0x53, 0x07, 0x89, 0xb4, 0x29, 0x4d, 0x3d, 0x79, 0x43, 0x73, 0x0f, 0x16, 0x21, 0xab,
    0xb7, 0x07, 0x2b, 0x5a, 0x8a, 0x0f, 0xd7, 0x2e, 0x95, 0xb4, 0x26, 0x66, 0x65, 0x72, 0xac, 0x7e,
    0x46, 0x70, 0xe6, 0xad, 0x43, 0xa2, 0x73, 0x54, 0x6a, 0x41, 0xc8, 0x9c, 0x1e, 0x65, 0xed, 0x06,
    0xd1, 0xc7, 0x99, 0x3e, 0x5f, 0x5a, 0xd3, 0xd0, 0x1a, 0x9b, 0x0e, 0x3e, 0x04, 0x66, 0xb6, 0xaa,
    0xa6, 0x51, 0xb8, 0xc0, 0x13, 0x19, 0x34, 0x0e, 0x86, 0x02, 0xd5, 0xc8, 0x10, 0xaa, 0x1f, 0x97,
    0x95
};
static RTBIGNUM g_Signature;
static uint8_t const g_abSignatureDecrypted[] =
{
    0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x30, 0x21, 0x30,
    0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03, 0x02, 0x1a, 0x05, 0x00, 0x04, 0x14, 0x54, 0x60, 0xb0, 0x65,
    0xf1, 0xbc, 0x40, 0x77, 0xfc, 0x9e, 0xfc, 0x2f, 0x94, 0x62, 0x62, 0x61, 0x43, 0xb9, 0x01, 0xb9
};
static RTBIGNUM g_SignatureDecrypted;
/** @} */


static void testInitOneLittleEndian(uint8_t const *pb, size_t cb, PRTBIGNUM pBigNum)
{
    uint8_t abLittleEndian[sizeof(g_abLargePositive) + sizeof(g_abLargeNegative)];
    RTTESTI_CHECK_RETV(cb <= sizeof(abLittleEndian));

    size_t         cbLeft = cb;
    uint8_t       *pbDst  = abLittleEndian + cb - 1;
    uint8_t const *pbSrc  = pb;
    while (cbLeft-- > 0)
        *pbDst-- = *pbSrc++;

    RTBIGNUM Num;
    RTTESTI_CHECK_RC_RETV(RTBigNumInit(&Num, RTBIGNUMINIT_F_ENDIAN_LITTLE | RTBIGNUMINIT_F_SIGNED,
                                       abLittleEndian, cb), VINF_SUCCESS);
    RTTESTI_CHECK(Num.fNegative == pBigNum->fNegative);
    RTTESTI_CHECK(Num.cUsed == pBigNum->cUsed);
    RTTESTI_CHECK(RTBigNumCompare(&Num, pBigNum) == 0);
    RTTESTI_CHECK_RC(RTBigNumDestroy(&Num), VINF_SUCCESS);

    RTTESTI_CHECK_RC_RETV(RTBigNumInit(&Num, RTBIGNUMINIT_F_ENDIAN_LITTLE | RTBIGNUMINIT_F_SIGNED | RTBIGNUMINIT_F_SENSITIVE,
                                       abLittleEndian, cb), VINF_SUCCESS);
    RTTESTI_CHECK(Num.fNegative == pBigNum->fNegative);
    RTTESTI_CHECK(Num.cUsed == pBigNum->cUsed);
    RTTESTI_CHECK(RTBigNumCompare(&Num, pBigNum) == 0);
    RTTESTI_CHECK_RC(RTBigNumDestroy(&Num), VINF_SUCCESS);
}

static void testMoreInit(void)
{
    RTTESTI_CHECK(!g_LargePositive.fNegative);
    RTTESTI_CHECK(!g_LargePositive.fSensitive);
    RTTESTI_CHECK(!g_LargePositive2.fNegative);
    RTTESTI_CHECK(!g_LargePositive2.fSensitive);
    RTTESTI_CHECK(g_LargeNegative.fNegative);
    RTTESTI_CHECK(!g_LargeNegative.fSensitive);
    RTTESTI_CHECK(g_LargeNegative2.fNegative);
    RTTESTI_CHECK(!g_LargeNegative2.fSensitive);

    RTTESTI_CHECK(!g_Zero.fNegative);
    RTTESTI_CHECK(!g_Zero.fSensitive);
    RTTESTI_CHECK(g_Zero.cUsed == 0);

    RTTESTI_CHECK(g_Minus1.fNegative);
    RTTESTI_CHECK(!g_Minus1.fSensitive);
    RTTESTI_CHECK(g_Minus1.cUsed == 1);
    RTTESTI_CHECK(g_Minus1.pauElements[0] == 1);

    RTTESTI_CHECK(g_One.cUsed       == 1 && g_One.pauElements[0]        == 1);
    RTTESTI_CHECK(g_Two.cUsed       == 1 && g_Two.pauElements[0]        == 2);
    RTTESTI_CHECK(g_Three.cUsed     == 1 && g_Three.pauElements[0]      == 3);
    RTTESTI_CHECK(g_Four.cUsed      == 1 && g_Four.pauElements[0]       == 4);
    RTTESTI_CHECK(g_Ten.cUsed       == 1 && g_Ten.pauElements[0]        == 10);
    RTTESTI_CHECK(g_FourtyTwo.cUsed == 1 && g_FourtyTwo.pauElements[0]  == 42);

    /* Test big endian initialization w/ sensitive variation. */
    testInitOneLittleEndian(g_abLargePositive, sizeof(g_abLargePositive), &g_LargePositive);
    testInitOneLittleEndian(g_abLargePositive, sizeof(g_abLargePositive) - 11, &g_LargePositive2);

    testInitOneLittleEndian(g_abLargeNegative, sizeof(g_abLargeNegative), &g_LargeNegative);
    testInitOneLittleEndian(g_abLargeNegative, sizeof(g_abLargeNegative) - 9, &g_LargeNegative2);

    RTTESTI_CHECK(g_Minus1.cUsed == 1);
    testInitOneLittleEndian(g_abMinus1, sizeof(g_abMinus1), &g_Minus1);
    testInitOneLittleEndian(g_abMinus1, 1, &g_Minus1);
    testInitOneLittleEndian(g_abMinus1, 4, &g_Minus1);

}


static void testCompare(void)
{
    RTTestSub(g_hTest, "RTBigNumCompare*");
    RTTESTI_CHECK(RTBigNumCompare(&g_LargePositive, &g_LargePositive) == 0);
    RTTESTI_CHECK(RTBigNumCompare(&g_LargePositive2, &g_LargePositive) == -1);
    RTTESTI_CHECK(RTBigNumCompare(&g_LargePositive, &g_LargePositive2) == 1);
    RTTESTI_CHECK(RTBigNumCompare(&g_Zero, &g_LargePositive) == -1);
    RTTESTI_CHECK(RTBigNumCompare(&g_LargePositive, &g_Zero) == 1);
    RTTESTI_CHECK(RTBigNumCompare(&g_LargePositive2, &g_Zero) == 1);
    RTTESTI_CHECK(RTBigNumCompare(&g_LargePositive, &g_LargePositiveMinus1) == 1);
    RTTESTI_CHECK(RTBigNumCompare(&g_LargePositiveMinus1, &g_LargePositive) == -1);

    RTTESTI_CHECK(RTBigNumCompare(&g_LargeNegative, &g_LargeNegative) == 0);
    RTTESTI_CHECK(RTBigNumCompare(&g_LargeNegative, &g_LargeNegative2) == -1);
    RTTESTI_CHECK(RTBigNumCompare(&g_LargeNegative2, &g_LargeNegative) == 1);
    RTTESTI_CHECK(RTBigNumCompare(&g_Zero, &g_LargeNegative) == 1);
    RTTESTI_CHECK(RTBigNumCompare(&g_LargeNegative, &g_Zero) == -1);
    RTTESTI_CHECK(RTBigNumCompare(&g_LargeNegative2, &g_Zero) == -1);
    RTTESTI_CHECK(RTBigNumCompare(&g_LargeNegative, &g_LargeNegativePluss1) == -1);
    RTTESTI_CHECK(RTBigNumCompare(&g_LargeNegativePluss1, &g_LargeNegative) == 1);

    RTTESTI_CHECK(RTBigNumCompare(&g_LargeNegative, &g_LargePositive) == -1);
    RTTESTI_CHECK(RTBigNumCompare(&g_LargePositive, &g_LargeNegative) == 1);
    RTTESTI_CHECK(RTBigNumCompare(&g_LargeNegative2, &g_LargePositive) == -1);
    RTTESTI_CHECK(RTBigNumCompare(&g_LargePositive, &g_LargeNegative2) == 1);
    RTTESTI_CHECK(RTBigNumCompare(&g_LargeNegative2, &g_LargePositive2) == -1);
    RTTESTI_CHECK(RTBigNumCompare(&g_LargePositive2, &g_LargeNegative2) == 1);

    RTTESTI_CHECK(RTBigNumCompareWithU64(&g_Zero, 0) == 0);
    RTTESTI_CHECK(RTBigNumCompareWithU64(&g_Zero, 1) == -1);
    RTTESTI_CHECK(RTBigNumCompareWithU64(&g_Zero, UINT32_MAX) == -1);
    RTTESTI_CHECK(RTBigNumCompareWithU64(&g_Zero, UINT64_MAX) == -1);
    RTTESTI_CHECK(RTBigNumCompareWithU64(&g_LargePositive, UINT64_MAX) == 1);
    RTTESTI_CHECK(RTBigNumCompareWithU64(&g_LargePositive2, 0x7213593) == 1);
    RTTESTI_CHECK(RTBigNumCompareWithU64(&g_LargeNegative, 0) == -1);
    RTTESTI_CHECK(RTBigNumCompareWithU64(&g_LargeNegative, 1) == -1);
    RTTESTI_CHECK(RTBigNumCompareWithU64(&g_LargeNegative, UINT64_MAX) == -1);
    RTTESTI_CHECK(RTBigNumCompareWithU64(&g_LargeNegative, 0x80034053) == -1);
    RTTESTI_CHECK(RTBigNumCompareWithU64(&g_64BitPositive1, g_u64BitPositive1) == 0);
    RTTESTI_CHECK(RTBigNumCompareWithU64(&g_64BitPositive1, g_u64BitPositive1 - 1) == 1);
    RTTESTI_CHECK(RTBigNumCompareWithU64(&g_64BitPositive1, g_u64BitPositive1 + 1) == -1);

    RTTESTI_CHECK(RTBigNumCompareWithS64(&g_Zero, 0) == 0);
    RTTESTI_CHECK(RTBigNumCompareWithS64(&g_Zero, 1) == -1);
    RTTESTI_CHECK(RTBigNumCompareWithS64(&g_Zero, -1) == 1);
    RTTESTI_CHECK(RTBigNumCompareWithS64(&g_Zero, INT32_MAX) == -1);
    RTTESTI_CHECK(RTBigNumCompareWithS64(&g_LargeNegative, INT32_MIN) == -1);
    RTTESTI_CHECK(RTBigNumCompareWithS64(&g_LargeNegative, INT64_MIN) == -1);
    RTTESTI_CHECK(g_u64BitPositive1 < (uint64_t)INT64_MAX);
    RTTESTI_CHECK(RTBigNumCompareWithS64(&g_64BitPositive1, g_u64BitPositive1) == 0);
    RTTESTI_CHECK(RTBigNumCompareWithS64(&g_64BitPositive1, g_u64BitPositive1 - 1) == 1);
    RTTESTI_CHECK(RTBigNumCompareWithS64(&g_64BitPositive1, g_u64BitPositive1 + 1) == -1);
    RTTESTI_CHECK(RTBigNumCompareWithS64(&g_64BitPositive1, INT64_MIN) == 1);
    RTTESTI_CHECK(RTBigNumCompareWithS64(&g_64BitPositive1, INT64_MAX) == -1);
    RTTESTI_CHECK(RTBigNumCompareWithS64(&g_Minus1, -1) == 0);
    RTTESTI_CHECK(RTBigNumCompareWithS64(&g_Minus1, -2) == 1);
    RTTESTI_CHECK(RTBigNumCompareWithS64(&g_Minus1, 0) == -1);
}


static void testSubtraction(void)
{
    RTTestSub(g_hTest, "RTBigNumSubtract");

    for (uint32_t fFlags = 0; fFlags <= RTBIGNUMINIT_F_SENSITIVE; fFlags += RTBIGNUMINIT_F_SENSITIVE)
    {
        RTBIGNUM Result;
        RTTESTI_CHECK_RC_RETV(RTBigNumInitZero(&Result, fFlags), VINF_SUCCESS);
        RTBIGNUM Result2;
        RTTESTI_CHECK_RC_RETV(RTBigNumInitZero(&Result2, fFlags), VINF_SUCCESS);

        RTTESTI_CHECK_RC(RTBigNumSubtract(&Result, &g_Minus1, &g_Minus1), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 0) == 0);

        RTTESTI_CHECK_RC(RTBigNumSubtract(&Result, &g_Zero, &g_Minus1), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 1) == 0);

        RTTESTI_CHECK_RC(RTBigNumSubtract(&Result, &g_Minus1, &g_Zero), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, -1) == 0);

        RTTESTI_CHECK_RC(RTBigNumSubtract(&Result, &g_64BitPositive1, &g_Minus1), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithU64(&Result, g_u64BitPositive1 + 1) == 0);

        RTTESTI_CHECK_RC(RTBigNumSubtract(&Result, &g_Minus1, &g_64BitPositive1), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, INT64_C(-1) - g_u64BitPositive1) == 0);

        RTTESTI_CHECK_RC(RTBigNumSubtract(&Result, &g_LargePositive, &g_LargePositiveMinus1), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 1) == 0);
        RTTESTI_CHECK(Result.cUsed == 1);

        RTTESTI_CHECK_RC(RTBigNumSubtract(&Result, &g_LargePositiveMinus1, &g_LargePositive), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, -1) == 0);
        RTTESTI_CHECK(Result.cUsed == 1);

        RTTESTI_CHECK(RTBigNumCompare(&g_LargeNegative, &g_LargeNegativePluss1) < 0);
        RTTESTI_CHECK_RC(RTBigNumSubtract(&Result, &g_LargeNegative, &g_LargeNegativePluss1), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, -1) == 0);
        RTTESTI_CHECK(Result.cUsed == 1);

        RTTESTI_CHECK_RC(RTBigNumSubtract(&Result, &g_LargeNegativePluss1, &g_LargeNegative), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 1) == 0);
        RTTESTI_CHECK(Result.cUsed == 1);

        RTTESTI_CHECK_RC(RTBigNumSubtract(&Result, &g_LargeNegativePluss1, &g_LargeNegativePluss1), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 0) == 0);
        RTTESTI_CHECK(Result.cUsed == 0);

        RTTESTI_CHECK_RC(RTBigNumDestroy(&Result), VINF_SUCCESS);
        RTTESTI_CHECK_RC(RTBigNumDestroy(&Result2), VINF_SUCCESS);
    }
}


static void testAddition(void)
{
    RTTestSub(g_hTest, "RTBigNumAdd");

    for (uint32_t fFlags = 0; fFlags <= RTBIGNUMINIT_F_SENSITIVE; fFlags += RTBIGNUMINIT_F_SENSITIVE)
    {
        RTBIGNUM Result;
        RTTESTI_CHECK_RC_RETV(RTBigNumInitZero(&Result, fFlags), VINF_SUCCESS);
        RTBIGNUM Result2;
        RTTESTI_CHECK_RC_RETV(RTBigNumInitZero(&Result2, fFlags), VINF_SUCCESS);

        RTTESTI_CHECK_RC(RTBigNumAdd(&Result, &g_Minus1, &g_Minus1), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, -2) == 0);

        RTTESTI_CHECK_RC(RTBigNumAdd(&Result, &g_Zero, &g_Minus1), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, -1) == 0);

        RTTESTI_CHECK_RC(RTBigNumAdd(&Result, &g_Zero, &g_64BitPositive1), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithU64(&Result, g_u64BitPositive1) == 0);

        RTTESTI_CHECK_RC(RTBigNumAdd(&Result, &g_Minus1, &g_64BitPositive1), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithU64(&Result, g_u64BitPositive1 - 1) == 0);

        RTTESTI_CHECK(g_u64BitPositive1 * 2 > g_u64BitPositive1);
        RTTESTI_CHECK_RC(RTBigNumAdd(&Result, &g_64BitPositive1, &g_64BitPositive1), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithU64(&Result, g_u64BitPositive1 * 2) == 0);


        RTTESTI_CHECK_RC(RTBigNumAssign(&Result2, &g_LargePositive), VINF_SUCCESS);
        RTTESTI_CHECK_RC(RTBigNumNegateThis(&Result2), VINF_SUCCESS);

        RTTESTI_CHECK_RC(RTBigNumAdd(&Result, &g_LargePositive, &Result2), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithU64(&Result, 0) == 0);

        RTTESTI_CHECK_RC(RTBigNumAdd(&Result, &Result2, &g_LargePositive), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithU64(&Result, 0) == 0);

        RTTESTI_CHECK_RC(RTBigNumAdd(&Result, &g_LargePositiveMinus1, &Result2), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, -1) == 0);

        RTTESTI_CHECK_RC(RTBigNumAdd(&Result, &Result2, &g_LargePositiveMinus1), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, -1) == 0);


        RTTESTI_CHECK_RC(RTBigNumAdd(&Result, &g_LargePositive, &g_LargePositiveMinus1), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompare(&Result, &g_LargePositive) > 0);
        RTTESTI_CHECK_RC(RTBigNumSubtract(&Result2, &Result, &g_LargePositiveMinus1), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompare(&Result2, &g_LargePositive) == 0);
        RTTESTI_CHECK_RC(RTBigNumSubtract(&Result2, &Result, &g_LargePositive), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompare(&Result2, &g_LargePositiveMinus1) == 0);

        RTTESTI_CHECK_RC(RTBigNumAdd(&Result, &g_LargePositive, &g_LargeNegative), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompare(&Result, &g_LargeNegative) > 0);
        RTTESTI_CHECK(RTBigNumCompare(&Result, &g_LargePositive) < 0);
        RTTESTI_CHECK_RC(RTBigNumSubtract(&Result2, &Result, &g_LargePositive), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompare(&Result2, &g_LargeNegative) == 0);
        RTTESTI_CHECK_RC(RTBigNumSubtract(&Result2, &Result, &g_LargeNegative), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompare(&Result2, &g_LargePositive) == 0);

        RTTESTI_CHECK_RC(RTBigNumAdd(&Result, &g_LargeNegativePluss1, &g_LargeNegative), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompare(&Result, &g_LargeNegative) < 0);
        RTTESTI_CHECK_RC(RTBigNumSubtract(&Result2, &Result, &g_LargeNegative), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompare(&Result2, &g_LargeNegativePluss1) == 0);

        RTTESTI_CHECK_RC(RTBigNumDestroy(&Result), VINF_SUCCESS);
        RTTESTI_CHECK_RC(RTBigNumDestroy(&Result2), VINF_SUCCESS);
    }
}

static void testShift(void)
{
    RTTestSub(g_hTest, "RTBigNumShiftLeft, RTBigNumShiftRight");

    for (uint32_t fFlags = 0; fFlags <= RTBIGNUMINIT_F_SENSITIVE; fFlags += RTBIGNUMINIT_F_SENSITIVE)
    {
        RTBIGNUM Result;
        RTTESTI_CHECK_RC_RETV(RTBigNumInitZero(&Result, fFlags), VINF_SUCCESS);
        RTBIGNUM Result2;
        RTTESTI_CHECK_RC_RETV(RTBigNumInitZero(&Result2, fFlags), VINF_SUCCESS);

        /* basic left tests */
        RTTESTI_CHECK_RC(RTBigNumShiftLeft(&Result, &g_Minus1, 1), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, -2) == 0);

        RTTESTI_CHECK_RC(RTBigNumShiftLeft(&Result, &g_Minus1, 0), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, -1) == 0);

        RTTESTI_CHECK_RC(RTBigNumShiftLeft(&Result, &g_Minus1, 2), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, -4) == 0);

        RTTESTI_CHECK_RC(RTBigNumShiftLeft(&Result, &g_Minus1, 8), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, -256) == 0);

        RTTESTI_CHECK_RC(RTBigNumShiftLeft(&Result, &g_Zero, 511), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 0) == 0);

        RTTESTI_CHECK_RC(RTBigNumShiftLeft(&Result, &g_FourtyTwo, 1), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 84) == 0);

        RTTESTI_CHECK_RC(RTBigNumShiftLeft(&Result, &g_FourtyTwo, 27+24), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, UINT64_C(0x150000000000000)) == 0);

        RTTESTI_CHECK_RC(RTBigNumShiftLeft(&Result, &g_FourtyTwo, 27), VINF_SUCCESS);
        RTTESTI_CHECK_RC(RTBigNumShiftLeft(&Result2, &Result, 24), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result2, UINT64_C(0x150000000000000)) == 0);

        RTTESTI_CHECK_RC(RTBigNumShiftLeft(&Result, &g_LargePositive, 2), VINF_SUCCESS);
        RTTESTI_CHECK_RC(RTBigNumMultiply(&Result2, &g_LargePositive, &g_Four), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompare(&Result2, &Result) == 0);

        /* basic right tests. */
        RTTESTI_CHECK_RC(RTBigNumShiftRight(&Result, &g_Minus1, 1), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 0) == 0);

        RTTESTI_CHECK_RC(RTBigNumShiftRight(&Result, &g_Minus1, 8), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 0) == 0);

        RTTESTI_CHECK_RC(RTBigNumShiftRight(&Result, &g_Zero, 511), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 0) == 0);

        RTTESTI_CHECK_RC(RTBigNumShiftRight(&Result, &g_FourtyTwo, 0), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 42) == 0);

        RTTESTI_CHECK_RC(RTBigNumShiftRight(&Result, &g_FourtyTwo, 1), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 21) == 0);

        RTTESTI_CHECK_RC(RTBigNumShiftRight(&Result, &g_FourtyTwo, 2), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 10) == 0);

        RTTESTI_CHECK_RC(RTBigNumShiftRight(&Result, &g_FourtyTwo, 3), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 5) == 0);

        RTTESTI_CHECK_RC(RTBigNumShiftRight(&Result, &g_FourtyTwo, 4), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 2) == 0);

        RTTESTI_CHECK_RC(RTBigNumShiftRight(&Result, &g_FourtyTwo, 5), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 1) == 0);

        RTTESTI_CHECK_RC(RTBigNumShiftRight(&Result, &g_FourtyTwo, 6), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 0) == 0);

        RTTESTI_CHECK_RC(RTBigNumShiftRight(&Result, &g_FourtyTwo, 549), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 0) == 0);

        RTTESTI_CHECK_RC(RTBigNumDivideLong(&Result2, &Result, &g_LargePositive, &g_Four), VINF_SUCCESS);
        RTTESTI_CHECK_RC(RTBigNumShiftRight(&Result, &g_LargePositive, 2), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompare(&Result2, &Result) == 0);

        /* Some simple back and forth. */
        RTTESTI_CHECK_RC(RTBigNumShiftLeft(&Result, &g_One, 2), VINF_SUCCESS);
        RTTESTI_CHECK_RC(RTBigNumShiftRight(&Result2, &Result, 2), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompare(&Result2, &g_One) == 0);

        RTTESTI_CHECK_RC(RTBigNumShiftLeft(&Result, &g_Three, 63), VINF_SUCCESS);
        RTTESTI_CHECK_RC(RTBigNumShiftRight(&Result2, &Result, 63), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompare(&Result2, &g_Three) == 0);

        for (uint32_t i = 0; i < 1024; i++)
        {
            RTTESTI_CHECK_RC(RTBigNumShiftLeft(&Result, &g_LargePositive, i), VINF_SUCCESS);
            RTTESTI_CHECK_RC(RTBigNumShiftRight(&Result2, &Result, i), VINF_SUCCESS);
            RTTESTI_CHECK(RTBigNumCompare(&Result2, &g_LargePositive) == 0);
        }

        RTTESTI_CHECK_RC(RTBigNumShiftLeft(&Result, &g_LargePositive, 2), VINF_SUCCESS);
        RTTESTI_CHECK_RC(RTBigNumShiftLeft(&Result2, &Result, 250), VINF_SUCCESS);
        RTTESTI_CHECK_RC(RTBigNumShiftLeft(&Result, &Result2, 999), VINF_SUCCESS);
        RTTESTI_CHECK_RC(RTBigNumShiftRight(&Result2, &Result, 1), VINF_SUCCESS);
        RTTESTI_CHECK_RC(RTBigNumShiftRight(&Result, &Result2, 250), VINF_SUCCESS);
        RTTESTI_CHECK_RC(RTBigNumShiftRight(&Result2, &Result, 1), VINF_SUCCESS);
        RTTESTI_CHECK_RC(RTBigNumShiftRight(&Result, &Result2, 999), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompare(&Result, &g_LargePositive) == 0);


        RTTESTI_CHECK_RC(RTBigNumDestroy(&Result), VINF_SUCCESS);
        RTTESTI_CHECK_RC(RTBigNumDestroy(&Result2), VINF_SUCCESS);
    }
}

static bool testHexStringToNum(PRTBIGNUM pBigNum, const char *pszHex, uint32_t fFlags)
{
    uint8_t abBuf[_4K];
    size_t  cbHex = strlen(pszHex);
    RTTESTI_CHECK_RET(!(cbHex & 1), false);
    cbHex /= 2;
    RTTESTI_CHECK_RET(cbHex < sizeof(abBuf), false);
    RTTESTI_CHECK_RC_RET(RTStrConvertHexBytes(pszHex, abBuf, cbHex, 0), VINF_SUCCESS, false);
    RTTESTI_CHECK_RC_RET(RTBigNumInit(pBigNum, RTBIGNUMINIT_F_ENDIAN_BIG | fFlags, abBuf, cbHex), VINF_SUCCESS, false);
    return true;
}

static void testMultiplication(void)
{
    RTTestSub(g_hTest, "RTBigNumMultiply");

    for (uint32_t fFlags = 0; fFlags <= RTBIGNUMINIT_F_SENSITIVE; fFlags += RTBIGNUMINIT_F_SENSITIVE)
    {
        RTBIGNUM Result;
        RTTESTI_CHECK_RC_RETV(RTBigNumInitZero(&Result, fFlags), VINF_SUCCESS);
        RTBIGNUM Result2;
        RTTESTI_CHECK_RC_RETV(RTBigNumInitZero(&Result2, fFlags), VINF_SUCCESS);

        RTTESTI_CHECK_RC(RTBigNumMultiply(&Result, &g_Minus1, &g_Minus1), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 1) == 0);

        RTTESTI_CHECK_RC(RTBigNumMultiply(&Result, &g_Zero, &g_Minus1), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 0) == 0);
        RTTESTI_CHECK_RC(RTBigNumMultiply(&Result, &g_Minus1, &g_Zero), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 0) == 0);

        RTTESTI_CHECK_RC(RTBigNumMultiply(&Result, &g_Minus1, &g_64BitPositive1), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, -(int64_t)g_u64BitPositive1) == 0);
        RTTESTI_CHECK_RC(RTBigNumMultiply(&Result, &g_64BitPositive1, &g_Minus1), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, -(int64_t)g_u64BitPositive1) == 0);


        static struct
        {
            const char *pszF1, *pszF2, *pszResult;
        } s_aTests[] =
        {
            {
                "29865DBFA717181B9DD4B515BD072DE10A5A314385F6DED735AC553FCD307D30C499",
                "4DD65692F7365B90C55F63988E5B6C448653E7DB9DD941507586BD8CF71398287C",
                "0CA02E8FFDB0EEA37264338A4AAA91C8974E162DDFCBCF804B434A11955671B89B3645AAB75423D60CA3459B0B4F3F28978DA768779FB54CF362FD61924637582F221C"
            },
            {
                "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
                "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
                "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE0000000000000000000000000000000000000001"
            }
        };
        for (uint32_t i = 0; i < RT_ELEMENTS(s_aTests); i++)
        {
            RTBIGNUM F1, F2, Expected;
            if (   testHexStringToNum(&F1, s_aTests[i].pszF1, RTBIGNUMINIT_F_UNSIGNED | fFlags)
                && testHexStringToNum(&F2, s_aTests[i].pszF2, RTBIGNUMINIT_F_UNSIGNED | fFlags)
                && testHexStringToNum(&Expected, s_aTests[i].pszResult, RTBIGNUMINIT_F_UNSIGNED | fFlags))
            {
                RTTESTI_CHECK_RC(RTBigNumMultiply(&Result, &F1, &F2), VINF_SUCCESS);
                RTTESTI_CHECK(RTBigNumCompare(&Result, &Expected) == 0);
                RTTESTI_CHECK_RC(RTBigNumDestroy(&F1), VINF_SUCCESS);
                RTTESTI_CHECK_RC(RTBigNumDestroy(&F2), VINF_SUCCESS);
                RTTESTI_CHECK_RC(RTBigNumDestroy(&Expected), VINF_SUCCESS);
            }
        }
        RTTESTI_CHECK_RC(RTBigNumDestroy(&Result), VINF_SUCCESS);
        RTTESTI_CHECK_RC(RTBigNumDestroy(&Result2), VINF_SUCCESS);
    }
}


#if 0 /* Java program for generating testDivision test data. */
import java.math.BigInteger;
import java.lang.System;
import java.lang.Integer;
import java.util.Random;
import java.security.SecureRandom;

class bigintdivtestgen
{

public static String format(BigInteger BigNum)
{
    String str = BigNum.toString(16);
    if ((str.length() & 1) != 0)
        str = "0" + str;
    return str;
}

public static void main(String args[])
{
    Random Rnd = new SecureRandom();

    /* Can't go to far here because before we reach 11K both windows compilers
       will have reached some kind of section limit. Probably string pool related. */
    int cDivisorLarger = 0;
    for (int i = 0; i < 9216; i++)
    {
        int cDividendBits = Rnd.nextInt(4095) + 1;
        int cDivisorBits  = i < 9 ? cDividendBits : Rnd.nextInt(4095) + 1;
        if (cDivisorBits > cDividendBits)
        {
            cDivisorLarger++;
            if (cDivisorLarger > i / 4)
                cDivisorBits = Rnd.nextInt(cDividendBits);
        }

        BigInteger Dividend = new BigInteger(cDividendBits, Rnd);
        BigInteger Divisor  = new BigInteger(cDivisorBits, Rnd);
        while (Divisor.compareTo(BigInteger.ZERO) == 0) {
            cDivisorBits++;
            Divisor = new BigInteger(cDivisorBits, Rnd);
        }

        BigInteger[] Result = Dividend.divideAndRemainder(Divisor);

        System.out.println("    { /* i=" + Integer.toString(i)
                           + " cDividendBits=" + Integer.toString(cDividendBits)
                           + " cDivisorBits=" + Integer.toString(cDivisorBits) + " */");

        System.out.println("        \"" + format(Dividend)  + "\",");
        System.out.println("        \"" + format(Divisor)   + "\",");
        System.out.println("        \"" + format(Result[0]) + "\",");
        System.out.println("        \"" + format(Result[1]) + "\"");
        System.out.println("    },");
    }
}
}
#endif

static void testDivision(void)
{
    RTTestSub(g_hTest, "RTBigNumDivide");

    //for (uint32_t fFlags = 0; fFlags <= RTBIGNUMINIT_F_SENSITIVE; fFlags += RTBIGNUMINIT_F_SENSITIVE)
    uint32_t fFlags = 0;
    {
        RTBIGNUM Quotient;
        RTTESTI_CHECK_RC_RETV(RTBigNumInitZero(&Quotient, fFlags), VINF_SUCCESS);
        RTBIGNUM Remainder;
        RTTESTI_CHECK_RC_RETV(RTBigNumInitZero(&Remainder, fFlags), VINF_SUCCESS);

        RTTESTI_CHECK_RC(RTBigNumDivide(&Quotient, &Remainder, &g_Minus1, &g_Minus1), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Quotient, 1) == 0);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Remainder, 0) == 0);

        RTTESTI_CHECK_RC(RTBigNumDivide(&Quotient, &Remainder, &g_Zero, &g_Minus1), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Quotient, 0) == 0);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Remainder, 0) == 0);

        RTTESTI_CHECK_RC(RTBigNumDivide(&Quotient, &Remainder, &g_Minus1, &g_Zero), VERR_BIGNUM_DIV_BY_ZERO);
        RTTESTI_CHECK_RC(RTBigNumDivide(&Quotient, &Remainder, &g_LargeNegative, &g_Zero), VERR_BIGNUM_DIV_BY_ZERO);
        RTTESTI_CHECK_RC(RTBigNumDivide(&Quotient, &Remainder, &g_LargePositive, &g_Zero), VERR_BIGNUM_DIV_BY_ZERO);

        RTTESTI_CHECK_RC(RTBigNumDivide(&Quotient, &Remainder, &g_Four, &g_Two), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Quotient, 2) == 0);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Remainder, 0) == 0);

        RTTESTI_CHECK_RC(RTBigNumDivide(&Quotient, &Remainder, &g_Three, &g_Two), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Quotient, 1) == 0);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Remainder, 1) == 0);

        RTTESTI_CHECK_RC(RTBigNumDivide(&Quotient, &Remainder, &g_Ten, &g_Two), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Quotient, 5) == 0);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Remainder, 0) == 0);


        RTTESTI_CHECK_RC(RTBigNumDivide(&Quotient, &Remainder, &g_LargePositive, &g_LargePositiveMinus1), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Quotient, 1) == 0);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Remainder, 1) == 0);

        RTTESTI_CHECK_RC(RTBigNumDivide(&Quotient, &Remainder, &g_LargeNegative, &g_LargeNegativePluss1), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Quotient, 1) == 0);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Remainder, -1) == 0);

        static struct
        {
            const char *pszDividend, *pszDivisor, *pszQuotient, *pszRemainder;
        } const s_aTests[] =
        {
#if 1
#include "tstRTBigNum-div-test-data.h"
            {   "ff", "10", /* = */ "0f", "0f" },
            { /* cDividendBits=323 cDivisorBits=195 */
                "064530fd21b30e179b5bd5efd1f4a7e8df173c13965bd75e1502891303060b417e62711ceb17a73e56",
                "0784fac4a7c6b5165a99dc3228b6484cba9c7dfadde85cdde3",
                "d578cc87ed22ac3630a4d1e5fc590ae6",
                "06acef436982f9c4fc9b0a44d3df1e72cad3ef0cb51ba20664"
            },
            {
                "ffffffffffffffffffffffffffffffffffffffffffffffff",
                "fffffffffffffffffffffffffffffffffffffffffffffffe",
                "01",
                "01"
            },
            {
                "922222222222222222222222222222222222222222222222",
                "811111111111111111111111111111111111111111111111",
                "01",
                "111111111111111111111111111111111111111111111111"
            },
            {
                "955555555555555555555555555555555555555555555555",
                "211111111111111111111111111111111111111111111111",
                "04",
                "111111111111111111111111111111111111111111111111"
            },
#endif
            /* This test triggers negative special cases in Knuth's division algorithm. */
            {
                "0137698320ec00bcaa13cd9c18df564bf6df45c5c4c73ad2012cb36cf897c5ff00db638256e19c9ba5a8fbe828ac6e8d470a5f3391d4350ca1390f79c4e4f944eb",
                "67cdd6604eaae98e0699deb2f51cc3fcf51741ec4268f0ab0ee679a83297550049212b724b3433e1e2fea2b8397a2f17ae1fbbdb46bc598b13052896f6fdc1a4",
                "02",
                "67cdd6604eaae98e0699deb2f51cc3fcf51741ec4268f0ab0ee679a83297550049212b724b3433e1e2fea2b8397a2f17ae1fbbdb46bc598b13052896f6fdc1a3"
            },
        };
        for (uint32_t i = 0; i < RT_ELEMENTS(s_aTests); i++)
        {
            RTBIGNUM Dividend, Divisor, ExpectedQ, ExpectedR;
            if (   testHexStringToNum(&Dividend,  s_aTests[i].pszDividend, RTBIGNUMINIT_F_UNSIGNED | fFlags)
                && testHexStringToNum(&Divisor,   s_aTests[i].pszDivisor, RTBIGNUMINIT_F_UNSIGNED | fFlags)
                && testHexStringToNum(&ExpectedQ, s_aTests[i].pszQuotient, RTBIGNUMINIT_F_UNSIGNED | fFlags)
                && testHexStringToNum(&ExpectedR, s_aTests[i].pszRemainder, RTBIGNUMINIT_F_UNSIGNED | fFlags))
            {
                RTTESTI_CHECK_RC(RTBigNumDivide(&Quotient, &Remainder, &Dividend, &Divisor), VINF_SUCCESS);

                if (   RTBigNumCompare(&Quotient,  &ExpectedQ) != 0
                    || RTBigNumCompare(&Remainder, &ExpectedR) != 0)
                {
                    RTTestIFailed("i=%#x both\n"
                                  "ExpQ: %.*Rhxs\n"
                                  "GotQ: %.*Rhxs\n"
                                  "ExpR: %.*Rhxs\n"
                                  "GotR: %.*Rhxs\n",
                                  i,
                                  ExpectedQ.cUsed * RTBIGNUM_ELEMENT_SIZE, ExpectedQ.pauElements,
                                  Quotient.cUsed  * RTBIGNUM_ELEMENT_SIZE, Quotient.pauElements,
                                  ExpectedR.cUsed * RTBIGNUM_ELEMENT_SIZE, ExpectedR.pauElements,
                                  Remainder.cUsed * RTBIGNUM_ELEMENT_SIZE, Remainder.pauElements);
                    RTTestIPrintf(RTTESTLVL_ALWAYS,  "{ \"%s\", \"%s\", \"%s\", \"%s\" },\n",
                                  s_aTests[i].pszDividend, s_aTests[i].pszDivisor,
                                  s_aTests[i].pszQuotient, s_aTests[i].pszRemainder);
                }

                RTTESTI_CHECK_RC(RTBigNumDivideLong(&Quotient, &Remainder, &Dividend, &Divisor), VINF_SUCCESS);
                RTTESTI_CHECK(RTBigNumCompare(&Quotient,  &ExpectedQ) == 0);
                RTTESTI_CHECK(RTBigNumCompare(&Remainder, &ExpectedR) == 0);

                RTTESTI_CHECK_RC(RTBigNumModulo(&Remainder, &Dividend, &Divisor), VINF_SUCCESS);
                RTTESTI_CHECK(RTBigNumCompare(&Remainder, &ExpectedR) == 0);


                RTTESTI_CHECK_RC(RTBigNumDestroy(&ExpectedR), VINF_SUCCESS);
                RTTESTI_CHECK_RC(RTBigNumDestroy(&ExpectedQ), VINF_SUCCESS);
                RTTESTI_CHECK_RC(RTBigNumDestroy(&Divisor), VINF_SUCCESS);
                RTTESTI_CHECK_RC(RTBigNumDestroy(&Dividend), VINF_SUCCESS);
            }
        }

        RTTESTI_CHECK_RC(RTBigNumDestroy(&Quotient), VINF_SUCCESS);
        RTTESTI_CHECK_RC(RTBigNumDestroy(&Remainder), VINF_SUCCESS);
    }
}


static void testModulo(void)
{
    RTTestSub(g_hTest, "RTBigNumModulo");

    for (uint32_t fFlags = 0; fFlags <= RTBIGNUMINIT_F_SENSITIVE; fFlags += RTBIGNUMINIT_F_SENSITIVE)
    {
        RTBIGNUM Result;
        RTTESTI_CHECK_RC_RETV(RTBigNumInitZero(&Result, fFlags), VINF_SUCCESS);
        RTBIGNUM Tmp;
        RTTESTI_CHECK_RC_RETV(RTBigNumInitZero(&Tmp, fFlags), VINF_SUCCESS);

        RTTESTI_CHECK_RC(RTBigNumModulo(&Result, &g_Minus1, &g_Minus1), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 0) == 0);

        RTTESTI_CHECK_RC(RTBigNumModulo(&Result, &g_Zero, &g_Minus1), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 0) == 0);

        RTTESTI_CHECK_RC(RTBigNumModulo(&Result, &g_Minus1, &g_Zero), VERR_BIGNUM_DIV_BY_ZERO);
        RTTESTI_CHECK_RC(RTBigNumModulo(&Result, &g_LargeNegative, &g_Zero), VERR_BIGNUM_DIV_BY_ZERO);
        RTTESTI_CHECK_RC(RTBigNumModulo(&Result, &g_LargePositive, &g_Zero), VERR_BIGNUM_DIV_BY_ZERO);

        RTTESTI_CHECK_RC(RTBigNumModulo(&Result, &g_Four, &g_Two), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 0) == 0);

        RTTESTI_CHECK_RC(RTBigNumModulo(&Result, &g_Three, &g_Two), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 1) == 0);

        RTTESTI_CHECK_RC(RTBigNumModulo(&Result, &g_Ten, &g_Two), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 0) == 0);

        RTTESTI_CHECK_RC(RTBigNumModulo(&Result, &g_LargePositive, &g_LargePositiveMinus1), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 1) == 0);

        RTTESTI_CHECK_RC(RTBigNumModulo(&Result, &g_LargePositiveMinus1, &g_LargePositive), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompare(&Result, &g_LargePositiveMinus1) == 0);

        RTTESTI_CHECK_RC(RTBigNumAdd(&Result, &g_LargePositiveMinus1, &g_LargePositive), VINF_SUCCESS);
        RTTESTI_CHECK_RC(RTBigNumAdd(&Tmp, &g_LargePositive, &Result), VINF_SUCCESS);
        RTTESTI_CHECK_RC(RTBigNumModulo(&Result, &Tmp, &g_LargePositiveMinus1), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 2) == 0);
        RTTESTI_CHECK_RC(RTBigNumModulo(&Result, &Tmp, &g_LargePositive), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompare(&Result, &g_LargePositiveMinus1) == 0);

        RTTESTI_CHECK_RC(RTBigNumModulo(&Result, &g_LargeNegative, &g_LargeNegativePluss1), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, -1) == 0);

        RTTESTI_CHECK_RC(RTBigNumDestroy(&Tmp), VINF_SUCCESS);
        RTTESTI_CHECK_RC(RTBigNumDestroy(&Result), VINF_SUCCESS);
    }
}


static void testExponentiation(void)
{
    RTTestSub(g_hTest, "RTBigNumExponentiate");

    for (uint32_t fFlags = 0; fFlags <= RTBIGNUMINIT_F_SENSITIVE; fFlags += RTBIGNUMINIT_F_SENSITIVE)
    {
        RTBIGNUM Result;
        RTTESTI_CHECK_RC_RETV(RTBigNumInitZero(&Result, fFlags), VINF_SUCCESS);
        RTBIGNUM Result2;
        RTTESTI_CHECK_RC_RETV(RTBigNumInitZero(&Result2, fFlags), VINF_SUCCESS);

        RTTESTI_CHECK_RC(RTBigNumExponentiate(&Result, &g_One, &g_One), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 1) == 0);

        RTTESTI_CHECK_RC(RTBigNumExponentiate(&Result, &g_Two, &g_One), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 2) == 0);

        RTTESTI_CHECK_RC(RTBigNumExponentiate(&Result, &g_Two, &g_Two), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 4) == 0);

        RTTESTI_CHECK_RC(RTBigNumExponentiate(&Result, &g_Two, &g_Ten), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 1024) == 0);

        RTTESTI_CHECK_RC(RTBigNumExponentiate(&Result, &g_Five, &g_Five), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 3125) == 0);

        RTTESTI_CHECK_RC(RTBigNumExponentiate(&Result, &g_Five, &g_Ten), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 9765625) == 0);

        static struct
        {
            const char *pszBase, *pszExponent, *pszResult;
        } s_aTests[] =
        {
            {
                "180DB4284A119D6133AE4BB0C27C27D1", /*^*/ "3A", /* = */
                "04546412B9E39476F10009F62608F614774C5AE475482434F138C3EA976583ECE09E58F1F03CE41F821A1D5DA59B69D031290B0AC7F7D5058E3AFA2CA3DAA7261D1620CA"
                "D050576C0AFDF51ADBFCB9073B9D8324E816EA6BE4648DF68092F6617ED609045E6BE9D5410AE2CFF725832414E67656233F4DFA952461D321282426D50E2AF524D779EC"
                "0744547E8A4F0768C2C49AF3A5A89D129430CA58456BE4534BC53C67523506C7A8B5770D88CF28B6B3EEBE73F3EA71BA2CE27C4C89BE0D699922B1A1EB20143CB0830A43"
                "D864DDFFF026BA781614C2D55F3EDEA7257B93A0F40824E57D6EDFCFFB4611C316374D0D15698E6584851F1898DCAE75FC4D180908763DDB2FF93766EF144D091274AFE5"
                "6980A1F4F574D577DAD833EA9486A4B499BFCA9C08225D7BDB2C632B4D9B53EF51C02ED419F22657D626064BCC2B083CD664E1A8D68F82F33233A833AC98AA0282B8B88D"
                "A430CF2E581A1C7C4A1D646CA42760ED10C398F7C032A94D53964E6885B5C1CA884EC15081D4C010978627C85767FEC6F93364044EA86567F9610ABFB837808CC995FB5F"
                "710B21CE198E0D4AD9F73C3BD56CB9965C85C790BF3F4B326B5245BFA81783126217BF80687C4A8AA3AE80969A4407191B4F90E71A0ABCCB5FEDD40477CE9D10FBAEF103"
                "8457AB19BD793CECDFF8B29A96F12F590BFED544E08F834A44DEEF461281C40024EFE9388689AAC69BCBAB3D06434172D9319F30754756E1CF77B300679215BEBD27FC20"
                "A2F1D2029BC767D4894A5F7B21BD784CD1DD4F41697839969CB6D2AA1E0AFA5D3D644A792586F681EB36475CAE59EB457E55D6AC2E286E196BFAC000C7389A96C514552D"
                "5D9D3DD962F72DAE4A7575A9A67856646239560A39E50826BB2523598C8F8FF0EC8D09618378E9F362A8FBFE842B55CD1855A95D8A5E93B8B91D31EB8FBBF57113F06171"
                "BB69B81C4240EC4C7D1AC67EA1CE4CEBEE71828917EC1CF500E1AD2F09535F5498CD6E613383810A840A265AED5DD20AE58FFF2D0DEB8EF99FA494B22714F520E8E8B684"
                "5E8521966A7B1699236998A730FDF9F049CE2A4EA44D1EBC3B9754908848540D0DEE64A6D60E2BFBC3362B659C10543BDC20C1BAD3D68B173442C100C2C366CB885E8490"
                "EDB977E49E9D51D4427B73B3B999AF4BA17685387182C3918D20808197A2E3FCDD0F66ECDEC05542C23A08B94C83BDF93606A49E9A0645B002CFCA1EAE1917BEED0D6542"
                "9A0EF00E5FB5F70D61C8C4DF1F1E9DA58188A221"
            },
            {
                "03", /*^*/ "164b", /* = */
                "29ABEC229C2B15C41573F8608D4DCD2DADAACA94CA3C40B42FFAD32D6202E228E16F61E050FF97EC5D45F24A4EB057C2D1A5DA72DFC5944E6941DBEDDE70EF56702BEC35"
                "A3150EFE84E87185E3CBAB1D73F434EB820E41298BDD4F3941230DFFD8DFF1D2E2F3C5D0CB5088505B9C78507A81AAD8073C28B8FA70771C3E04110344328C6B3F38E55A"
                "32B009F4DDA1813232C3FF422DF4E4D12545C803C63D0BE67E2E773B2BAC41CC69D895787B217D7BE9CE80BD4B500AE630AA21B50A06E0A74953F8011E9F23863CA79885"
                "35D5FF0214DBD9B25756BE3D43008A15C018348E6A7C3355F4BECF37595BD530E5AC1AD3B14182862E47AD002097465F6B78F435B0D6365E18490567F508CD3CAAAD340A"
                "E76A218FE8B517F923FE9CCDE61CB35409590CDBC606D89BA33B32A3862DEE7AB99DFBE103D02D2BED6D418B949E6B3C51CAB8AB5BE93AA104FA10D3A02D4CAD6700CD0F"
                "83922EAAB18705915198DE51C1C562984E2B7571F36A4D756C459B61E0A4B7DE268A74E807311273DD51C2863771AB72504044C870E2498F13BF1DE92C13D93008E304D2"
                "879C5D8A646DB5BF7BC64D96BB9E2FBA2EA6BF55CD825ABD995762F661C327133BE01F9A9F298CA096B3CE61CBBD8047A003870B218AC505D72ED6C7BF3B37BE5877B6A1"
                "606A713EE86509C99B2A3627FD74AE7E81FE7F69C34B40E01A6F8B18A328E0F9D18A7911E5645331540538AA76B6D5D591F14313D730CFE30728089A245EE91058748F0C"
                "E3E6CE4DE51D23E233BFF9007E0065AEBAA3FB0D0FACE62A4757FE1C9C7075E2214071197D5074C92AF1E6D853F7DE782F32F1E40507CB981A1C10AC6B1C23AC46C07EF1"
                "EDE857C444902B936771DF75E0EE6C2CB3F0F9DBB387BAD0658E98F42A7338DE45E2F1B012B530FFD66861F74137C041D7558408A4A23B83FBDDE494381D9F9FF0326D44"
                "302F75DE68B91A54CFF6E3C2821D09F2664CA74783C29AF98E2F1D3D84CAC49EAE55BABE3D2CBE8833D50517109E19CB5C63D1DE26E308ACC213D1CBCCF7C3AAE05B06D9"
                "909AB0A1AEFD02A193CFADC7F724D377E1F4E78DC21012BE26D910548CDF55B0AB9CB64756045FF48C3B858E954553267C4087EC5A9C860CFA56CF5CFBB442BDDA298230"
                "D6C000A6A6010D87FB4C3859C3AFAF15C37BCE03EBC392E8149056C489508841110060A991F1EEAF1E7CCF0B279AB2B35F3DAC0FAB4F4A107794E67D305E6D61A27C8FEB"
                "DEA00C3334C888B2092E740DD3EFF7A69F06CE12EF511126EB23D80902D1D54BF4AEE04DF9457D59E8859AA83D6229481E1B1BC7C3ED96F6F7C1CEEF7B904268FD00BE51"
                "1EF69692D593F8A9F7CCC053C343306940A4054A55DBA94D95FF6D02B7A73E110C2DBE6CA29C01B5921420B5BC9C92DAA9D82003829C6AE772FF12135C2E138C6725DC47"
                "7938F3062264575EBBB1CBB359E496DD7A38AE0E33D1B1D9C16BDD87E6DE44DFB832286AE01D00AA14B423DBF7ECCC34A0A06A249707B75C2BA931D7F4F513FDF0F6E516"
                "345B8DA85FEFD218B390828AECADF0C47916FAF44CB29010B0BB2BBA8E120B6DAFB2CC90B9D1B8659C2AFB"
            }
        };
        for (uint32_t i = 0; i < RT_ELEMENTS(s_aTests); i++)
        {
            RTBIGNUM Base, Exponent, Expected;
            if (   testHexStringToNum(&Base, s_aTests[i].pszBase, RTBIGNUMINIT_F_UNSIGNED | fFlags)
                && testHexStringToNum(&Exponent, s_aTests[i].pszExponent, RTBIGNUMINIT_F_UNSIGNED | fFlags)
                && testHexStringToNum(&Expected, s_aTests[i].pszResult, RTBIGNUMINIT_F_UNSIGNED | fFlags))
            {
                RTTESTI_CHECK_RC(RTBigNumExponentiate(&Result, &Base, &Exponent), VINF_SUCCESS);
                RTTESTI_CHECK(RTBigNumCompare(&Result, &Expected) == 0);
                RTTESTI_CHECK_RC(RTBigNumDestroy(&Base), VINF_SUCCESS);
                RTTESTI_CHECK_RC(RTBigNumDestroy(&Exponent), VINF_SUCCESS);
                RTTESTI_CHECK_RC(RTBigNumDestroy(&Expected), VINF_SUCCESS);
            }
        }
        RTTESTI_CHECK_RC(RTBigNumDestroy(&Result), VINF_SUCCESS);
        RTTESTI_CHECK_RC(RTBigNumDestroy(&Result2), VINF_SUCCESS);
    }
}


static void testModExp(void)
{
    RTTestSub(g_hTest, "RTBigNumModExp");
    RTBIGNUM Result;

    for (uint32_t fFlags = 0; fFlags <= RTBIGNUMINIT_F_SENSITIVE; fFlags += RTBIGNUMINIT_F_SENSITIVE)
    {
        RTTESTI_CHECK_RC_RETV(RTBigNumInitZero(&Result, fFlags), VINF_SUCCESS);

        RTTESTI_CHECK_RC(RTBigNumModExp(&Result, &g_One, &g_One, &g_One), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 0) == 0);
        RTTESTI_CHECK_RC(RTBigNumModExp(&Result, &g_LargePositive, &g_One, &g_One), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 0) == 0);
        RTTESTI_CHECK_RC(RTBigNumModExp(&Result, &g_LargePositive, &g_LargePositive, &g_One), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 0) == 0);

        RTTESTI_CHECK_RC(RTBigNumModExp(&Result, &g_One, &g_Zero, &g_Five), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 0) == 1);
        RTTESTI_CHECK_RC(RTBigNumModExp(&Result, &g_LargePositive, &g_Zero, &g_Five), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 0) == 1);
        RTTESTI_CHECK_RC(RTBigNumModExp(&Result, &g_LargePositive, &g_Zero, &g_One), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 0) == 0);
        RTTESTI_CHECK_RC(RTBigNumModExp(&Result, &g_LargePositive, &g_Zero, &g_LargePositive), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 0) == 1);

        RTTESTI_CHECK_RC(RTBigNumModExp(&Result, &g_Zero, &g_Zero, &g_Zero), VERR_BIGNUM_DIV_BY_ZERO);
        RTTESTI_CHECK_RC(RTBigNumModExp(&Result, &g_LargePositive, &g_Zero, &g_Zero), VERR_BIGNUM_DIV_BY_ZERO);
        RTTESTI_CHECK_RC(RTBigNumModExp(&Result, &g_LargePositive, &g_LargePositive, &g_Zero), VERR_BIGNUM_DIV_BY_ZERO);

        RTTESTI_CHECK_RC(RTBigNumModExp(&Result, &g_Two, &g_Four, &g_Five), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 1) == 0);

        RTTESTI_CHECK_RC(RTBigNumModExp(&Result, &g_Two, &g_Four, &g_Three), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 1) == 0);

        RTTESTI_CHECK_RC(RTBigNumModExp(&Result, &g_Three, &g_Three, &g_Three), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 0) == 0);

        RTTESTI_CHECK_RC(RTBigNumModExp(&Result, &g_Three, &g_Three, &g_Five), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 2) == 0);

        RTTESTI_CHECK_RC(RTBigNumModExp(&Result, &g_Three, &g_Five, &g_Five), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 3) == 0);

        RTTESTI_CHECK_RC(RTBigNumModExp(&Result, &g_Three, &g_Five, &g_Four), VINF_SUCCESS);
        RTTESTI_CHECK(RTBigNumCompareWithS64(&Result, 3) == 0);

#if 0
        static struct
        {
            const char *pszBase, *pszExponent, *pszModulus, *pszResult;
        } s_aTests[] =
        {
            {
                "180DB4284A119D6133AE4BB0C27C27D1", /*^*/ "3A", /*mod */ " ",  /* = */
            },
        };
        for (uint32_t i = 0; i < RT_ELEMENTS(s_aTests); i++)
        {
            RTBIGNUM Base, Exponent, Expected, Modulus;
            if (   testHexStringToNum(&Base, s_aTests[i].pszBase, RTBIGNUMINIT_F_UNSIGNED | fFlags)
                && testHexStringToNum(&Exponent, s_aTests[i].pszExponent, RTBIGNUMINIT_F_UNSIGNED | fFlags)
                && testHexStringToNum(&Modulus, s_aTests[i].pszModulus, RTBIGNUMINIT_F_UNSIGNED | fFlags)
                && testHexStringToNum(&Expected, s_aTests[i].pszResult, RTBIGNUMINIT_F_UNSIGNED | fFlags))
            {
                RTTESTI_CHECK_RC(RTBigNumModExp(&Result, &Base, &Exponent, &Modulus), VINF_SUCCESS);
                RTTESTI_CHECK(RTBigNumCompare(&Result, &Expected) == 0);
                RTTESTI_CHECK_RC(RTBigNumDestroy(&Base), VINF_SUCCESS);
                RTTESTI_CHECK_RC(RTBigNumDestroy(&Exponent), VINF_SUCCESS);
                RTTESTI_CHECK_RC(RTBigNumDestroy(&Expected), VINF_SUCCESS);
                RTTESTI_CHECK_RC(RTBigNumDestroy(&Modulus), VINF_SUCCESS);
            }
        }
#endif

        RTTESTI_CHECK_RC(RTBigNumDestroy(&Result), VINF_SUCCESS);
    }

    /* Decrypt a PKCS#7 signature. */
    RTTESTI_CHECK_RC_RETV(RTBigNumInitZero(&Result, 0), VINF_SUCCESS);
    RTTESTI_CHECK_RC(RTBigNumModExp(&Result, &g_Signature, &g_PubKeyExp, &g_PubKeyMod), VINF_SUCCESS);
    RTTESTI_CHECK(RTBigNumCompare(&Result, &g_SignatureDecrypted) == 0);
    RTTESTI_CHECK_RC(RTBigNumDestroy(&Result), VINF_SUCCESS);
}


static void testToBytes(void)
{
    RTTestSub(g_hTest, "RTBigNumToBytes*Endian");
    uint8_t abBuf[sizeof(g_abLargePositive) + sizeof(g_abLargeNegative)];

    memset(abBuf, 0xcc, sizeof(abBuf));
    RTTESTI_CHECK_RC(RTBigNumToBytesBigEndian(&g_Zero, abBuf, 1), VINF_SUCCESS);
    RTTESTI_CHECK(abBuf[0] == 0 && abBuf[1] == 0xcc);

    memset(abBuf, 0xcc, sizeof(abBuf));
    RTTESTI_CHECK_RC(RTBigNumToBytesBigEndian(&g_Zero, abBuf, 2), VINF_SUCCESS);
    RTTESTI_CHECK(abBuf[0] == 0 && abBuf[1] == 0 && abBuf[2] == 0xcc);

    memset(abBuf, 0xcc, sizeof(abBuf));
    RTTESTI_CHECK_RC(RTBigNumToBytesBigEndian(&g_Zero, abBuf, 3), VINF_SUCCESS);
    RTTESTI_CHECK(abBuf[0] == 0 && abBuf[1] == 0 && abBuf[2] == 0 && abBuf[3] == 0xcc);

    memset(abBuf, 0xcc, sizeof(abBuf));
    RTTESTI_CHECK_RC(RTBigNumToBytesBigEndian(&g_Zero, abBuf, 4), VINF_SUCCESS);
    RTTESTI_CHECK(abBuf[0] == 0 && abBuf[1] == 0 && abBuf[2] == 0 && abBuf[3] == 0 && abBuf[4] == 0xcc);


    memset(abBuf, 0xcc, sizeof(abBuf));
    RTTESTI_CHECK_RC(RTBigNumToBytesBigEndian(&g_Minus1, abBuf, 1), VINF_SUCCESS);
    RTTESTI_CHECK(abBuf[0] == 0xff && abBuf[1] == 0xcc && abBuf[2] == 0xcc && abBuf[3] == 0xcc && abBuf[4] == 0xcc);

    memset(abBuf, 0xcc, sizeof(abBuf));
    RTTESTI_CHECK_RC(RTBigNumToBytesBigEndian(&g_Minus1, abBuf, 2), VINF_SUCCESS);
    RTTESTI_CHECK(abBuf[0] == 0xff && abBuf[1] == 0xff && abBuf[2] == 0xcc && abBuf[3] == 0xcc && abBuf[4] == 0xcc);

    memset(abBuf, 0xcc, sizeof(abBuf));
    RTTESTI_CHECK_RC(RTBigNumToBytesBigEndian(&g_Minus1, abBuf, 3), VINF_SUCCESS);
    RTTESTI_CHECK(abBuf[0] == 0xff && abBuf[1] == 0xff && abBuf[2] == 0xff && abBuf[3] == 0xcc && abBuf[4] == 0xcc);

    memset(abBuf, 0xcc, sizeof(abBuf));
    RTTESTI_CHECK_RC(RTBigNumToBytesBigEndian(&g_Minus1, abBuf, 4), VINF_SUCCESS);
    RTTESTI_CHECK(abBuf[0] == 0xff && abBuf[1] == 0xff && abBuf[2] == 0xff && abBuf[3] == 0xff && abBuf[4] == 0xcc);


    memset(abBuf, 0xcc, sizeof(abBuf));
    RTTESTI_CHECK_RC(RTBigNumToBytesBigEndian(&g_LargePositive, abBuf, sizeof(g_abLargePositive)), VINF_SUCCESS);
    RTTESTI_CHECK(memcmp(abBuf, g_abLargePositive, sizeof(g_abLargePositive)) == 0);
    RTTESTI_CHECK(abBuf[sizeof(g_abLargePositive)] == 0xcc);

    memset(abBuf, 0xcc, sizeof(abBuf));
    RTTESTI_CHECK_RC(RTBigNumToBytesBigEndian(&g_LargePositive, abBuf, sizeof(g_abLargePositive) -1 ), VERR_BUFFER_OVERFLOW);
    RTTESTI_CHECK(memcmp(abBuf, &g_abLargePositive[1], sizeof(g_abLargePositive) - 1) == 0);
    RTTESTI_CHECK(abBuf[sizeof(g_abLargePositive) - 1] == 0xcc);
}


static void testBenchmarks(bool fOnlyModExp)
{
    RTTestSub(g_hTest, "Benchmarks");

    /*
     * For the modexp benchmark we decrypt a real PKCS #7 signature.
     */
    RTBIGNUM Decrypted;
    RTTESTI_CHECK_RC_RETV(RTBigNumInitZero(&Decrypted, 0 /*fFlags*/), VINF_SUCCESS);
    RTTESTI_CHECK_RC_RETV(RTBigNumModExp(&Decrypted, &g_Signature, &g_PubKeyExp, &g_PubKeyMod), VINF_SUCCESS);
    RTTESTI_CHECK_RC_RETV(RTBigNumModExp(&Decrypted, &g_Signature, &g_PubKeyExp, &g_PubKeyMod), VINF_SUCCESS);

    RTThreadYield();
    int      rc       = VINF_SUCCESS;
    uint32_t cRounds  = 0;
    uint64_t uStartTS = RTTimeNanoTS();
    while (cRounds < 10240)
    {
        rc |= RTBigNumModExp(&Decrypted, &g_Signature, &g_PubKeyExp, &g_PubKeyMod);
        cRounds++;
    }
    uint64_t uElapsed = RTTimeNanoTS() - uStartTS;
    RTTESTI_CHECK_RC(rc, VINF_SUCCESS);
    RTTestIValue("RTBigNumModExp", uElapsed / cRounds, RTTESTUNIT_NS_PER_CALL);

    if (fOnlyModExp)
        return;

#if 1
    /* Compare with OpenSSL BN. */
    BN_CTX *pObnCtx = BN_CTX_new();
    BIGNUM *pObnPubKeyExp = BN_bin2bn(g_abPubKeyExp, sizeof(g_abPubKeyExp), NULL);
    BIGNUM *pObnPubKeyMod = BN_bin2bn(g_abPubKeyMod, sizeof(g_abPubKeyMod), NULL);
    BIGNUM *pObnSignature = BN_bin2bn(g_abSignature, sizeof(g_abSignature), NULL);
    BIGNUM *pObnSignatureDecrypted = BN_bin2bn(g_abSignatureDecrypted, sizeof(g_abSignatureDecrypted), NULL);
    BIGNUM *pObnResult = BN_new();
    RTTESTI_CHECK_RETV(BN_mod_exp(pObnResult, pObnSignature, pObnPubKeyExp, pObnPubKeyMod, pObnCtx) == 1);
    RTTESTI_CHECK_RETV(BN_ucmp(pObnResult, pObnSignatureDecrypted) == 0);

    rc = 1;
    cRounds  = 0;
    uStartTS = RTTimeNanoTS();
    while (cRounds < 4096)
    {
        rc &= BN_mod_exp(pObnResult, pObnSignature, pObnPubKeyExp, pObnPubKeyMod, pObnCtx);
        cRounds++;
    }
    uElapsed = RTTimeNanoTS() - uStartTS;
    RTTESTI_CHECK_RC(rc, 1);
    RTTestIValue("BN_mod_exp", uElapsed / cRounds, RTTESTUNIT_NS_PER_CALL);

    rc = 1;
    cRounds  = 0;
    uStartTS = RTTimeNanoTS();
    while (cRounds < 4096)
    {
        rc &= BN_mod_exp_simple(pObnResult, pObnSignature, pObnPubKeyExp, pObnPubKeyMod, pObnCtx);
        cRounds++;
    }
    uElapsed = RTTimeNanoTS() - uStartTS;
    RTTESTI_CHECK_RC(rc, 1);
    RTTestIValue("BN_mod_exp_simple", uElapsed / cRounds, RTTESTUNIT_NS_PER_CALL);
#endif

    /*
     * Check out the speed of modulo.
     */
    RTBIGNUM Product;
    RTTESTI_CHECK_RC_RETV(RTBigNumInitZero(&Product, 0), VINF_SUCCESS);
    RTTESTI_CHECK_RC_RETV(RTBigNumMultiply(&Product, &g_Signature, &g_Signature), VINF_SUCCESS);
    RTTESTI_CHECK_RC_RETV(RTBigNumModulo(&Decrypted, &Product, &g_PubKeyMod), VINF_SUCCESS);
    RTThreadYield();
    rc       = VINF_SUCCESS;
    cRounds  = 0;
    uStartTS = RTTimeNanoTS();
    while (cRounds < 10240)
    {
        rc |= RTBigNumModulo(&Decrypted, &Product, &g_PubKeyMod);
        cRounds++;
    }
    uElapsed = RTTimeNanoTS() - uStartTS;
    RTTESTI_CHECK_RC(rc, VINF_SUCCESS);
    RTTestIValue("RTBigNumModulo", uElapsed / cRounds, RTTESTUNIT_NS_PER_CALL);

    RTBigNumDestroy(&Decrypted);

#if 1
    /* Compare with OpenSSL BN. */
    BIGNUM *pObnProduct = BN_new();
    RTTESTI_CHECK_RETV(BN_mul(pObnProduct, pObnSignature, pObnSignature, pObnCtx) == 1);
    RTTESTI_CHECK_RETV(BN_mod(pObnResult, pObnProduct, pObnPubKeyMod, pObnCtx) == 1);
    rc = 1;
    cRounds  = 0;
    uStartTS = RTTimeNanoTS();
    while (cRounds < 10240)
    {
        rc &= BN_mod(pObnResult, pObnProduct, pObnPubKeyMod, pObnCtx);
        cRounds++;
    }
    uElapsed = RTTimeNanoTS() - uStartTS;
    RTTESTI_CHECK_RC(rc, 1);
    RTTestIValue("BN_mod", uElapsed / cRounds, RTTESTUNIT_NS_PER_CALL);
#endif

    /*
     * Check out the speed of multiplication.
     */
    RTThreadYield();
    rc       = VINF_SUCCESS;
    cRounds  = 0;
    uStartTS = RTTimeNanoTS();
    while (cRounds < 10240)
    {
        rc |= RTBigNumMultiply(&Product, &g_Signature, &g_Signature);
        cRounds++;
    }
    uElapsed = RTTimeNanoTS() - uStartTS;
    RTTESTI_CHECK_RC(rc, VINF_SUCCESS);
    RTTestIValue("RTBigNumMultiply", uElapsed / cRounds, RTTESTUNIT_NS_PER_CALL);

    RTBigNumDestroy(&Product);

#if 1
    /* Compare with OpenSSL BN. */
    rc = 1;
    cRounds  = 0;
    uStartTS = RTTimeNanoTS();
    while (cRounds < 10240)
    {
        rc &= BN_mul(pObnProduct, pObnSignature, pObnSignature, pObnCtx);
        cRounds++;
    }
    uElapsed = RTTimeNanoTS() - uStartTS;
    RTTESTI_CHECK_RC(rc, 1);
    RTTestIValue("BN_mul", uElapsed / cRounds, RTTESTUNIT_NS_PER_CALL);

    BN_free(pObnPubKeyExp);
    BN_free(pObnPubKeyMod);
    BN_free(pObnSignature);
    BN_free(pObnSignatureDecrypted);
    BN_free(pObnResult);
    BN_free(pObnProduct);
    BN_CTX_free(pObnCtx);
#endif

}

/*
 * UInt128 tests (RTBigInt uses UInt128 in some cases.
 */

static void testUInt128Subtraction(void)
{
    RTTestSub(g_hTest, "RTUInt128Sub");

    static struct
    {
        RTUINT128U uMinuend, uSubtrahend, uResult;
    } const s_aTests[] =
    {
        { RTUINT128_INIT_C(0, 0), RTUINT128_INIT_C(0, 0), RTUINT128_INIT_C(0, 0) },
        { RTUINT128_INIT_C(0, 0), RTUINT128_INIT_C(0, 1), RTUINT128_INIT_C(~0, ~0) },
        { RTUINT128_INIT_C(0, 1), RTUINT128_INIT_C(0, 1), RTUINT128_INIT_C(0, 0) },
        { RTUINT128_INIT_C(0, 2), RTUINT128_INIT_C(0, 1), RTUINT128_INIT_C(0, 1) },
        { RTUINT128_INIT_C(0, 1), RTUINT128_INIT_C(0, 2), RTUINT128_INIT_C(~0, ~0) },
        { RTUINT128_INIT_C(2, 9), RTUINT128_INIT_C(2, 0), RTUINT128_INIT_C(0, 9) },
        { RTUINT128_INIT_C(2, 1), RTUINT128_INIT_C(0, 2), RTUINT128_INIT_C(1, ~0) },
        {
            RTUINT128_INIT_C(0xffffffffffffffff, 0x0000000000000000),
            RTUINT128_INIT_C(0x0000000000000000, 0xffffffffffffffff),
            RTUINT128_INIT_C(0xfffffffffffffffe, 0x0000000000000001),
        },
        {
            RTUINT128_INIT_C(0xffffffffffffffff, 0xfffffffffff00000),
            RTUINT128_INIT_C(0x0000000000000000, 0x00000000000fffff),
            RTUINT128_INIT_C(0xffffffffffffffff, 0xffffffffffe00001),
        },
        {
            RTUINT128_INIT_C(0xffffffffffffffff, 0xffffffffffffffff),
            RTUINT128_INIT_C(0x00000fffffffffff, 0xffffffffffffffff),
            RTUINT128_INIT_C(0xfffff00000000000, 0x0000000000000000)
        },
        {
            RTUINT128_INIT_C(0x0000000000000000, 0x000000251ce8fe85),
            RTUINT128_INIT_C(0x0000000000000000, 0x0000000301f41b4d),
            RTUINT128_INIT_C(0x0000000000000000, 0x000000221af4e338),
        },
        {
            RTUINT128_INIT_C(0xfd4d22a441ffa48c, 0x170739b573a9498d),
            RTUINT128_INIT_C(0x43459cea40782b26, 0xc8c16bb29cb3b343),
            RTUINT128_INIT_C(0xba0785ba01877965, 0x4e45ce02d6f5964a),
        },
    };
    for (uint32_t i = 0; i < RT_ELEMENTS(s_aTests); i++)
    {
        RTUINT128U uResult;
        PRTUINT128U pResult = RTUInt128Sub(&uResult, &s_aTests[i].uMinuend, &s_aTests[i].uSubtrahend);
        if (pResult != &uResult)
            RTTestIFailed("test #%i returns %p instead of %p", i, pResult, &uResult);
        else if (RTUInt128IsNotEqual(&uResult, &s_aTests[i].uResult))
            RTTestIFailed("test #%i failed: remainder differs:\nExp: %016RX64`%016RX64\nGot: %016RX64`%016RX64",
                          i, s_aTests[i].uResult.s.Hi, s_aTests[i].uResult.s.Lo, uResult.s.Hi, uResult.s.Lo );

        uResult = s_aTests[i].uMinuend;
        pResult = RTUInt128AssignSub(&uResult, &s_aTests[i].uSubtrahend);
        RTTESTI_CHECK(pResult == &uResult);
        RTTESTI_CHECK(RTUInt128IsEqual(&uResult, &s_aTests[i].uResult));
    }
}


static void testUInt128Addition(void)
{
    RTTestSub(g_hTest, "RTUInt128Add");

    static struct
    {
        RTUINT128U uAugend, uAddend, uResult;
    } const s_aTests[] =
    {
        { RTUINT128_INIT_C(0, 0), RTUINT128_INIT_C(0, 0), RTUINT128_INIT_C(0, 0) },
        { RTUINT128_INIT_C(0, 0), RTUINT128_INIT_C(0, 1), RTUINT128_INIT_C(0, 1) },
        { RTUINT128_INIT_C(0, 1), RTUINT128_INIT_C(0, 1), RTUINT128_INIT_C(0, 2) },
        { RTUINT128_INIT_C(0, 2), RTUINT128_INIT_C(0, 1), RTUINT128_INIT_C(0, 3) },
        { RTUINT128_INIT_C(0, 1), RTUINT128_INIT_C(0, 2), RTUINT128_INIT_C(0, 3) },
        { RTUINT128_INIT_C(2, 9), RTUINT128_INIT_C(2, 0), RTUINT128_INIT_C(4, 9) },
        { RTUINT128_INIT_C(2, 1), RTUINT128_INIT_C(0, 2), RTUINT128_INIT_C(2, 3) },
        {
            RTUINT128_INIT_C(0xffffffffffffffff, 0x0000000000000000),
            RTUINT128_INIT_C(0x0000000000000000, 0xffffffffffffffff),
            RTUINT128_INIT_C(0xffffffffffffffff, 0xffffffffffffffff),
        },
        {
            RTUINT128_INIT_C(0xffffffffffffffff, 0xfffffffffff00000),
            RTUINT128_INIT_C(0x0000000000000000, 0x00000000000ffeff),
            RTUINT128_INIT_C(0xffffffffffffffff, 0xfffffffffffffeff),
        },
        {
            RTUINT128_INIT_C(0xefffffffffffffff, 0xfffffffffff00000),
            RTUINT128_INIT_C(0x0000000000000000, 0x00000000001fffff),
            RTUINT128_INIT_C(0xf000000000000000, 0x00000000000fffff),
        },
        {
            RTUINT128_INIT_C(0xeeeeeeeeeeeeeeee, 0xeeeeeeeeeee00000),
            RTUINT128_INIT_C(0x0111111111111111, 0x11111111112fffff),
            RTUINT128_INIT_C(0xf000000000000000, 0x00000000000fffff),
        },
        {
            RTUINT128_INIT_C(0xffffffffffffffff, 0xffffffffffffffff),
            RTUINT128_INIT_C(0x00000fffffffffff, 0xffffffffffffffff),
            RTUINT128_INIT_C(0x00000fffffffffff, 0xfffffffffffffffe)
        },
        {
            RTUINT128_INIT_C(0xffffffffffffffff, 0xffffffffffffffff),
            RTUINT128_INIT_C(0xffffffffffffffff, 0xffffffffffffffff),
            RTUINT128_INIT_C(0xffffffffffffffff, 0xfffffffffffffffe)
        },
        {
            RTUINT128_INIT_C(0x0000000000000000, 0x000000251ce8fe85),
            RTUINT128_INIT_C(0x0000000000000000, 0x0000000301f41b4d),
            RTUINT128_INIT_C(0x0000000000000000, 0x000000281edd19d2),
        },
        {
            RTUINT128_INIT_C(0xfd4d22a441ffa48c, 0x170739b573a9498d),
            RTUINT128_INIT_C(0x43459cea40782b26, 0xc8c16bb29cb3b343),
            RTUINT128_INIT_C(0x4092bf8e8277cfb2, 0xdfc8a568105cfcd0),
        },
    };
    for (uint32_t i = 0; i < RT_ELEMENTS(s_aTests); i++)
    {
        RTUINT128U uResult;
        PRTUINT128U pResult = RTUInt128Add(&uResult, &s_aTests[i].uAugend, &s_aTests[i].uAddend);
        if (pResult != &uResult)
            RTTestIFailed("test #%i returns %p instead of %p", i, pResult, &uResult);
        else if (RTUInt128IsNotEqual(&uResult, &s_aTests[i].uResult))
            RTTestIFailed("test #%i failed: result differs:\nExp: %016RX64`%016RX64\nGot: %016RX64`%016RX64",
                          i, s_aTests[i].uResult.s.Hi, s_aTests[i].uResult.s.Lo, uResult.s.Hi, uResult.s.Lo );

        uResult = s_aTests[i].uAugend;
        pResult = RTUInt128AssignAdd(&uResult, &s_aTests[i].uAddend);
        RTTESTI_CHECK(pResult == &uResult);
        RTTESTI_CHECK(RTUInt128IsEqual(&uResult, &s_aTests[i].uResult));

        if (s_aTests[i].uAddend.s.Hi == 0)
        {
            pResult = RTUInt128AddU64(&uResult, &s_aTests[i].uAugend, s_aTests[i].uAddend.s.Lo);
            RTTESTI_CHECK(pResult == &uResult);
            RTTESTI_CHECK(RTUInt128IsEqual(&uResult, &s_aTests[i].uResult));

            uResult = s_aTests[i].uAugend;
            pResult = RTUInt128AssignAddU64(&uResult, s_aTests[i].uAddend.s.Lo);
            RTTESTI_CHECK(pResult == &uResult);
            RTTESTI_CHECK(RTUInt128IsEqual(&uResult, &s_aTests[i].uResult));
        }

        if (s_aTests[i].uAugend.s.Hi == 0)
        {
            pResult = RTUInt128AddU64(&uResult, &s_aTests[i].uAddend, s_aTests[i].uAugend.s.Lo);
            RTTESTI_CHECK(pResult == &uResult);
            RTTESTI_CHECK(RTUInt128IsEqual(&uResult, &s_aTests[i].uResult));

            uResult = s_aTests[i].uAddend;
            pResult = RTUInt128AssignAddU64(&uResult, s_aTests[i].uAugend.s.Lo);
            RTTESTI_CHECK(pResult == &uResult);
            RTTESTI_CHECK(RTUInt128IsEqual(&uResult, &s_aTests[i].uResult));
        }
    }
}

static void testUInt128Multiplication(void)
{
    RTTestSub(g_hTest, "RTUInt128Mul");

    static struct
    {
        RTUINT128U uFactor1, uFactor2, uResult;
    } const s_aTests[] =
    {
        { RTUINT128_INIT_C(0, 0), RTUINT128_INIT_C(0, 1), RTUINT128_INIT_C(0, 0) },
        { RTUINT128_INIT_C(~0, ~0), RTUINT128_INIT_C(0, 0), RTUINT128_INIT_C(0, 0) },
        { RTUINT128_INIT_C(0, 1), RTUINT128_INIT_C(0, 1), RTUINT128_INIT_C(0, 1) },
        { RTUINT128_INIT_C(0, 1), RTUINT128_INIT_C(0, 2), RTUINT128_INIT_C(0, 2) },
        { RTUINT128_INIT_C(2, 0), RTUINT128_INIT_C(2, 0), RTUINT128_INIT_C(0, 0) },
        { RTUINT128_INIT_C(2, 1), RTUINT128_INIT_C(0, 2), RTUINT128_INIT_C(4, 2) },
        {
            RTUINT128_INIT_C(0x1111111111111111, 0x1111111111111111),
            RTUINT128_INIT_C(0, 2),
            RTUINT128_INIT_C(0x2222222222222222, 0x2222222222222222)
        },
        {
            RTUINT128_INIT_C(0x1111111111111111, 0x1111111111111111),
            RTUINT128_INIT_C(0, 0xf),
            RTUINT128_INIT_C(0xffffffffffffffff, 0xffffffffffffffff)
        },
        {
            RTUINT128_INIT_C(0x1111111111111111, 0x1111111111111111),
            RTUINT128_INIT_C(0,                             0x30000),
            RTUINT128_INIT_C(0x3333333333333333, 0x3333333333330000)
        },
        {
            RTUINT128_INIT_C(0x1111111111111111, 0x1111111111111111),
            RTUINT128_INIT_C(0,                          0x30000000),
            RTUINT128_INIT_C(0x3333333333333333, 0x3333333330000000)
        },
        {
            RTUINT128_INIT_C(0x1111111111111111, 0x1111111111111111),
            RTUINT128_INIT_C(0,                     0x3000000000000),
            RTUINT128_INIT_C(0x3333333333333333, 0x3333000000000000)
        },
        {
            RTUINT128_INIT_C(0x1111111111111111, 0x1111111111111111),
            RTUINT128_INIT_C(0x0000000000000003, 0x0000000000000000),
            RTUINT128_INIT_C(0x3333333333333333, 0x0000000000000000)
        },
        {
            RTUINT128_INIT_C(0x1111111111111111, 0x1111111111111111),
            RTUINT128_INIT_C(0x0000000300000000, 0x0000000000000000),
            RTUINT128_INIT_C(0x3333333300000000, 0x0000000000000000)
        },
        {
            RTUINT128_INIT_C(0x1111111111111111, 0x1111111111111111),
            RTUINT128_INIT_C(0x0003000000000000, 0x0000000000000000),
            RTUINT128_INIT_C(0x3333000000000000, 0x0000000000000000)
        },
        {
            RTUINT128_INIT_C(0x1111111111111111, 0x1111111111111111),
            RTUINT128_INIT_C(0x3000000000000000, 0x0000000000000000),
            RTUINT128_INIT_C(0x3000000000000000, 0x0000000000000000)
        },
        {
            RTUINT128_INIT_C(0x0000000000000000, 0x6816816816816817),
            RTUINT128_INIT_C(0x0000000000000000, 0x0000000000a0280a),
            RTUINT128_INIT_C(0x0000000000411e58, 0x7627627627b1a8e6)
        },
    };
    for (uint32_t i = 0; i < RT_ELEMENTS(s_aTests); i++)
    {
        RTUINT128U uResult;
        PRTUINT128U pResult = RTUInt128Mul(&uResult, &s_aTests[i].uFactor1, &s_aTests[i].uFactor2);
        if (pResult != &uResult)
            RTTestIFailed("test #%i returns %p instead of %p", i, pResult, &uResult);
        else if (RTUInt128IsNotEqual(&uResult, &s_aTests[i].uResult))
            RTTestIFailed("test #%i failed: \nExp: %016RX64`%016RX64\nGot: %016RX64`%016RX64",
                          i, s_aTests[i].uResult.s.Hi, s_aTests[i].uResult.s.Lo, uResult.s.Hi, uResult.s.Lo );

        if (s_aTests[i].uFactor2.s.Hi == 0)
        {
            pResult = RTUInt128MulByU64(&uResult, &s_aTests[i].uFactor1, s_aTests[i].uFactor2.s.Lo);
            RTTESTI_CHECK(pResult == &uResult);
            RTTESTI_CHECK(RTUInt128IsEqual(&uResult, &s_aTests[i].uResult));
        }

        if (s_aTests[i].uFactor1.s.Hi == 0)
        {
            pResult = RTUInt128MulByU64(&uResult, &s_aTests[i].uFactor2, s_aTests[i].uFactor1.s.Lo);
            RTTESTI_CHECK(pResult == &uResult);
            RTTESTI_CHECK(RTUInt128IsEqual(&uResult, &s_aTests[i].uResult));
        }

        uResult = s_aTests[i].uFactor1;
        pResult = RTUInt128AssignMul(&uResult, &s_aTests[i].uFactor2);
        RTTESTI_CHECK(pResult == &uResult);
        RTTESTI_CHECK(RTUInt128IsEqual(&uResult, &s_aTests[i].uResult));
    }
}


#if 0 /* Java program for generating testUInt128Division test data. */
import java.math.BigInteger;
import java.lang.System;
import java.lang.Integer;
import java.util.Random;
import java.security.SecureRandom;

class uint128divtestgen
{

public static String format(BigInteger BigNum)
{
    String str = BigNum.toString(16);
    while (str.length() < 32)
        str = "0" + str;
    return "RTUINT128_INIT_C(0x" + str.substring(0, 16) + ", 0x" + str.substring(16) + ")";
}

public static void main(String args[])
{
    Random Rnd = new SecureRandom();

    int cDivisorLarger = 0;
    for (int i = 0; i < 4096; i++)
    {
        int cDividendBits = Rnd.nextInt(127) + 1;
        int cDivisorBits  = i < 9 ? cDividendBits : Rnd.nextInt(127) + 1;
        if (cDivisorBits > cDividendBits)
        {
            if (cDivisorLarger > i / 16)
                cDividendBits = 128 - Rnd.nextInt(16);
            else
                cDivisorLarger++;
        }

        BigInteger Dividend = new BigInteger(cDividendBits, Rnd);
        BigInteger Divisor  = new BigInteger(cDivisorBits, Rnd);
        while (Divisor.compareTo(BigInteger.ZERO) == 0) {
            cDivisorBits++;
            Divisor = new BigInteger(cDivisorBits, Rnd);
        }

        BigInteger[] Result = Dividend.divideAndRemainder(Divisor);

        System.out.println("    { /* i=" + Integer.toString(i) + "; " + Integer.toString(cDividendBits) + " / " + Integer.toString(cDivisorBits) + " */");
        System.out.println("        " + format(Dividend)  + ", " + format(Divisor)   + ",");
        System.out.println("        " + format(Result[0]) + ", " + format(Result[1]) + "");
        System.out.println("    },");
    }
}
}
#endif

static void testUInt128Division(void)
{
    RTTestSub(g_hTest, "RTUInt128DivMod");

    static struct
    {
        RTUINT128U uDividend, uDivisor, uQuotient, uRemainder;
    } const s_aTests[] =
    {
        { RTUINT128_INIT_C(0, 0), RTUINT128_INIT_C(0, 1), RTUINT128_INIT_C(0, 0), RTUINT128_INIT_C(0, 0) }, /* #0 */
        { RTUINT128_INIT_C(0, 1), RTUINT128_INIT_C(0, 1), RTUINT128_INIT_C(0, 1), RTUINT128_INIT_C(0, 0) }, /* #1 */
        { RTUINT128_INIT_C(0, 1), RTUINT128_INIT_C(0, 2), RTUINT128_INIT_C(0, 0), RTUINT128_INIT_C(0, 1) }, /* #2 */
        { RTUINT128_INIT_C(2, 0), RTUINT128_INIT_C(2, 0), RTUINT128_INIT_C(0, 1), RTUINT128_INIT_C(0, 0) }, /* #3 */
        { RTUINT128_INIT_C(2, 1), RTUINT128_INIT_C(0, 2), RTUINT128_INIT_C(1, 0), RTUINT128_INIT_C(0, 1) }, /* #4 */
        {   /* #5 */
            RTUINT128_INIT_C(0xffffffffffffffff, 0x0000000000000000),
            RTUINT128_INIT_C(0x0000000000000000, 0xffffffffffffffff),
            RTUINT128_INIT_C(0x0000000000000001, 0x0000000000000000),
            RTUINT128_INIT_C(0x0000000000000000, 0x0000000000000000)
        },
        {   /* #6 */
            RTUINT128_INIT_C(0xffffffffffffffff, 0xfffffffffff00000),
            RTUINT128_INIT_C(0x00000fffffffffff, 0xffffffffffffffff),
            RTUINT128_INIT_C(0x0000000000000000, 0x0000000000100000),
            RTUINT128_INIT_C(0x0000000000000000, 0x0000000000000000)
        },
        {   /* #7 */
            RTUINT128_INIT_C(0xffffffffffffffff, 0xffffffffffffffff),
            RTUINT128_INIT_C(0x00000fffffffffff, 0xffffffffffffffff),
            RTUINT128_INIT_C(0x0000000000000000, 0x0000000000100000),
            RTUINT128_INIT_C(0x0000000000000000, 0x00000000000fffff)
        },
        {   /* #8 */
            RTUINT128_INIT_C(0x0000000000000000, 0x000000251ce8fe85), RTUINT128_INIT_C(0x0000000000000000, 0x0000000301f41b4d),
            RTUINT128_INIT_C(0x0000000000000000, 0x000000000000000c), RTUINT128_INIT_C(0x0000000000000000, 0x000000010577b6e9)
        },

#include "tstRTBigNum-uint128-div-test-data.h"
    };
    for (uint32_t i = 0; i < RT_ELEMENTS(s_aTests); i++)
    {
        RTUINT128U uResultQ, uResultR;
        PRTUINT128U pResultQ = RTUInt128DivRem(&uResultQ, &uResultR, &s_aTests[i].uDividend, &s_aTests[i].uDivisor);
        if (pResultQ != &uResultQ)
            RTTestIFailed("test #%i returns %p instead of %p", i, pResultQ, &uResultQ);
        else if (   RTUInt128IsNotEqual(&uResultQ, &s_aTests[i].uQuotient)
                 && RTUInt128IsNotEqual(&uResultR, &s_aTests[i].uRemainder))
        {
            RTTestIFailed("test #%i failed on both counts", i);
        }
        else if (RTUInt128IsNotEqual(&uResultQ, &s_aTests[i].uQuotient))
            RTTestIFailed("test #%i failed: quotient differs:\nExp: %016RX64`%016RX64\nGot: %016RX64`%016RX64",
                          i, s_aTests[i].uQuotient.s.Hi, s_aTests[i].uQuotient.s.Lo, uResultQ.s.Hi, uResultQ.s.Lo );
        else if (RTUInt128IsNotEqual(&uResultR, &s_aTests[i].uRemainder))
            RTTestIFailed("test #%i failed: remainder differs:\nExp: %016RX64`%016RX64\nGot: %016RX64`%016RX64",
                          i, s_aTests[i].uRemainder.s.Hi, s_aTests[i].uRemainder.s.Lo, uResultR.s.Hi, uResultR.s.Lo );

        pResultQ = RTUInt128Div(&uResultQ, &s_aTests[i].uDividend, &s_aTests[i].uDivisor);
        RTTESTI_CHECK(pResultQ == &uResultQ);
        RTTESTI_CHECK(RTUInt128IsEqual(&uResultQ, &s_aTests[i].uQuotient));

        uResultQ = s_aTests[i].uDividend;
        pResultQ = RTUInt128AssignDiv(&uResultQ, &s_aTests[i].uDivisor);
        RTTESTI_CHECK(pResultQ == &uResultQ);
        RTTESTI_CHECK(RTUInt128IsEqual(&uResultQ, &s_aTests[i].uQuotient));


        PRTUINT128U pResultR = RTUInt128Mod(&uResultR, &s_aTests[i].uDividend, &s_aTests[i].uDivisor);
        RTTESTI_CHECK(pResultR == &uResultR);
        RTTESTI_CHECK(RTUInt128IsEqual(&uResultR, &s_aTests[i].uRemainder));

        uResultR = s_aTests[i].uDividend;
        pResultR = RTUInt128AssignMod(&uResultR, &s_aTests[i].uDivisor);
        RTTESTI_CHECK(pResultR == &uResultR);
        RTTESTI_CHECK(RTUInt128IsEqual(&uResultR, &s_aTests[i].uRemainder));
    }
}


static void testUInt64Division(void)
{
    /*
     * Check the results against native code.
     */
    RTTestSub(g_hTest, "RTUInt64DivRem");
    for (uint32_t i = 0; i < _1M / 2; i++)
    {
        uint64_t const uDividend  = RTRandU64Ex(0, UINT64_MAX);
        uint64_t const uDivisor   = RTRandU64Ex(1, UINT64_MAX);
        uint64_t const uQuotient  = uDividend / uDivisor;
        uint64_t const uRemainder = uDividend % uDivisor;
        RTUINT64U Dividend  = { uDividend  };
        RTUINT64U Divisor   = { uDivisor   };
        RTUINT64U Quotient  = { UINT64_MAX };
        RTUINT64U Remainder = { UINT64_MAX };
        RTTESTI_CHECK(RTUInt64DivRem(&Quotient, &Remainder, &Dividend, &Divisor) == &Quotient);
        if (uQuotient != Quotient.u || uRemainder != Remainder.u)
            RTTestIFailed("%RU64 / %RU64 -> %RU64 rem %RU64, expected %RU64 rem %RU64",
                          uDividend, uDivisor, Quotient.u, Remainder.u, uQuotient, uRemainder);
    }
}


static void testUInt32Division(void)
{
    /*
     * Check the results against native code.
     */
    RTTestSub(g_hTest, "RTUInt32DivRem");
    for (uint32_t i = 0; i < _1M / 2; i++)
    {
        uint32_t const uDividend  = RTRandU32Ex(0, UINT32_MAX);
        uint32_t const uDivisor   = RTRandU32Ex(1, UINT32_MAX);
        uint32_t const uQuotient  = uDividend / uDivisor;
        uint32_t const uRemainder = uDividend % uDivisor;
        RTUINT32U Dividend  = { uDividend  };
        RTUINT32U Divisor   = { uDivisor   };
        RTUINT32U Quotient  = { UINT32_MAX };
        RTUINT32U Remainder = { UINT32_MAX };
        RTTESTI_CHECK(RTUInt32DivRem(&Quotient, &Remainder, &Dividend, &Divisor) == &Quotient);
        if (uQuotient != Quotient.u || uRemainder != Remainder.u)
            RTTestIFailed("%u / %u -> %u rem %u, expected %u rem %u",
                          uDividend, uDivisor, Quotient.u, Remainder.u, uQuotient, uRemainder);
    }
}



int main(int argc, char **argv)
{
    RT_NOREF_PV(argv);

    RTEXITCODE rcExit = RTTestInitAndCreate("tstRTBigNum", &g_hTest);
    if (rcExit != RTEXITCODE_SUCCESS)
        return rcExit;
    RTTestBanner(g_hTest);

    /* Init fixed integers. */
    RTTestSub(g_hTest, "RTBigNumInit");
    RTTESTI_CHECK_RC(RTBigNumInit(&g_LargePositive, RTBIGNUMINIT_F_ENDIAN_BIG | RTBIGNUMINIT_F_SIGNED,
                                  g_abLargePositive, sizeof(g_abLargePositive)), VINF_SUCCESS);
    RTTESTI_CHECK_RC(RTBigNumInit(&g_LargePositive2, RTBIGNUMINIT_F_ENDIAN_BIG | RTBIGNUMINIT_F_SIGNED,
                                  g_abLargePositive, sizeof(g_abLargePositive) - 11), VINF_SUCCESS);
    RTTESTI_CHECK_RC(RTBigNumInit(&g_LargePositiveMinus1, RTBIGNUMINIT_F_ENDIAN_BIG | RTBIGNUMINIT_F_SIGNED,
                                  g_abLargePositiveMinus1, sizeof(g_abLargePositiveMinus1)), VINF_SUCCESS);
    RTTESTI_CHECK_RC(RTBigNumInit(&g_LargeNegative, RTBIGNUMINIT_F_ENDIAN_BIG | RTBIGNUMINIT_F_SIGNED,
                                  g_abLargeNegative, sizeof(g_abLargeNegative)), VINF_SUCCESS);
    RTTESTI_CHECK_RC(RTBigNumInit(&g_LargeNegative2, RTBIGNUMINIT_F_ENDIAN_BIG | RTBIGNUMINIT_F_SIGNED,
                                  g_abLargeNegative, sizeof(g_abLargeNegative) - 9), VINF_SUCCESS);
    RTTESTI_CHECK_RC(RTBigNumInit(&g_LargeNegativePluss1, RTBIGNUMINIT_F_ENDIAN_BIG | RTBIGNUMINIT_F_SIGNED,
                                  g_abLargeNegativePluss1, sizeof(g_abLargeNegativePluss1)), VINF_SUCCESS);
    RTTESTI_CHECK_RC(RTBigNumInit(&g_64BitPositive1, RTBIGNUMINIT_F_ENDIAN_BIG | RTBIGNUMINIT_F_SIGNED,
                                  g_ab64BitPositive1, sizeof(g_ab64BitPositive1)), VINF_SUCCESS);

    RTTESTI_CHECK_RC(RTBigNumInitZero(&g_Zero, 0), VINF_SUCCESS);
    RTTESTI_CHECK_RC(RTBigNumInit(&g_One,       RTBIGNUMINIT_F_ENDIAN_BIG | RTBIGNUMINIT_F_SIGNED, "\x01", 1), VINF_SUCCESS);
    RTTESTI_CHECK_RC(RTBigNumInit(&g_Two,       RTBIGNUMINIT_F_ENDIAN_BIG | RTBIGNUMINIT_F_SIGNED, "\x02", 1), VINF_SUCCESS);
    RTTESTI_CHECK_RC(RTBigNumInit(&g_Three,     RTBIGNUMINIT_F_ENDIAN_BIG | RTBIGNUMINIT_F_SIGNED, "\x03", 1), VINF_SUCCESS);
    RTTESTI_CHECK_RC(RTBigNumInit(&g_Four,      RTBIGNUMINIT_F_ENDIAN_BIG | RTBIGNUMINIT_F_SIGNED, "\x04", 1), VINF_SUCCESS);
    RTTESTI_CHECK_RC(RTBigNumInit(&g_Five,      RTBIGNUMINIT_F_ENDIAN_BIG | RTBIGNUMINIT_F_SIGNED, "\x05", 1), VINF_SUCCESS);
    RTTESTI_CHECK_RC(RTBigNumInit(&g_Ten,       RTBIGNUMINIT_F_ENDIAN_BIG | RTBIGNUMINIT_F_SIGNED, "\x0a", 1), VINF_SUCCESS);
    RTTESTI_CHECK_RC(RTBigNumInit(&g_FourtyTwo, RTBIGNUMINIT_F_ENDIAN_BIG | RTBIGNUMINIT_F_SIGNED, "\x2a", 1), VINF_SUCCESS);

    RTTESTI_CHECK_RC(RTBigNumInit(&g_Minus1, RTBIGNUMINIT_F_ENDIAN_BIG | RTBIGNUMINIT_F_SIGNED,
                                  g_abMinus1, sizeof(g_abMinus1)), VINF_SUCCESS);

    RTTESTI_CHECK_RC(RTBigNumInit(&g_PubKeyExp, RTBIGNUMINIT_F_ENDIAN_BIG | RTBIGNUMINIT_F_UNSIGNED,
                                  g_abPubKeyExp, sizeof(g_abPubKeyExp)), VINF_SUCCESS);
    RTTESTI_CHECK_RC(RTBigNumInit(&g_PubKeyMod, RTBIGNUMINIT_F_ENDIAN_BIG | RTBIGNUMINIT_F_UNSIGNED,
                                  g_abPubKeyMod, sizeof(g_abPubKeyMod)), VINF_SUCCESS);
    RTTESTI_CHECK_RC(RTBigNumInit(&g_Signature, RTBIGNUMINIT_F_ENDIAN_BIG | RTBIGNUMINIT_F_UNSIGNED,
                                  g_abSignature, sizeof(g_abSignature)), VINF_SUCCESS);
    RTTESTI_CHECK_RC(RTBigNumInit(&g_SignatureDecrypted, RTBIGNUMINIT_F_ENDIAN_BIG | RTBIGNUMINIT_F_UNSIGNED,
                                  g_abSignatureDecrypted, sizeof(g_abSignatureDecrypted)), VINF_SUCCESS);
    testMoreInit();

    if (RTTestIErrorCount() == 0)
    {
        if (argc != 2)
        {
            /* Test UInt128 first as it may be used by RTBigInt. */
            testUInt128Multiplication();
            testUInt128Division();
            testUInt128Subtraction();
            testUInt128Addition();

            /* Test UInt32 and UInt64 division as it's used by the watcom support code (BIOS, ValKit, OS/2 GAs). */
            testUInt32Division();
            testUInt64Division();

            /* Test the RTBigInt operations. */
            testCompare();
            testSubtraction();
            testAddition();
            testShift();
            testMultiplication();
            testDivision();
            testModulo();
            testExponentiation();
            testModExp();
            testToBytes();
        }

        /* Benchmarks */
        testBenchmarks(argc == 2);

        /* Cleanups. */
        RTTestSub(g_hTest, "RTBigNumDestroy");
        RTTESTI_CHECK_RC(RTBigNumDestroy(&g_LargePositive), VINF_SUCCESS);
        RTTESTI_CHECK_RC(RTBigNumDestroy(&g_LargePositive2), VINF_SUCCESS);
        RTTESTI_CHECK_RC(RTBigNumDestroy(&g_LargeNegative), VINF_SUCCESS);
        RTTESTI_CHECK_RC(RTBigNumDestroy(&g_LargeNegative2), VINF_SUCCESS);
        RTTESTI_CHECK_RC(RTBigNumDestroy(&g_Zero), VINF_SUCCESS);
        RTTESTI_CHECK_RC(RTBigNumDestroy(&g_64BitPositive1), VINF_SUCCESS);
    }

    return RTTestSummaryAndDestroy(g_hTest);
}

