summaryrefslogtreecommitdiffstats
path: root/src/VBox/Runtime/testcase/tstRTBigNum.cpp
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-05-06 03:01:46 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-05-06 03:01:46 +0000
commitf8fe689a81f906d1b91bb3220acde2a4ecb14c5b (patch)
tree26484e9d7e2c67806c2d1760196ff01aaa858e8c /src/VBox/Runtime/testcase/tstRTBigNum.cpp
parentInitial commit. (diff)
downloadvirtualbox-f8fe689a81f906d1b91bb3220acde2a4ecb14c5b.tar.xz
virtualbox-f8fe689a81f906d1b91bb3220acde2a4ecb14c5b.zip
Adding upstream version 6.0.4-dfsg.upstream/6.0.4-dfsgupstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
-rw-r--r--src/VBox/Runtime/testcase/tstRTBigNum.cpp1762
1 files changed, 1762 insertions, 0 deletions
diff --git a/src/VBox/Runtime/testcase/tstRTBigNum.cpp b/src/VBox/Runtime/testcase/tstRTBigNum.cpp
new file mode 100644
index 00000000..aeeb484a
--- /dev/null
+++ b/src/VBox/Runtime/testcase/tstRTBigNum.cpp
@@ -0,0 +1,1762 @@
+/* $Id: tstRTBigNum.cpp $ */
+/** @file
+ * IPRT - Testcase for the RTBigNum* functions.
+ */
+
+/*
+ * Copyright (C) 2006-2019 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(&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);
+}
+
+
+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);
+
+#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);
+
+#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);
+#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);
+}
+
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-20 18:21:08 +0000