[MERGE #5657 @duongnhn] Add NativeTest for BigInt class

duongnhn · duongnhn · commit 705338be8b9d · 2018-09-04T09:48:19.000-07:00
Merge pull request #5657 from duongnhn:user/duongn/nativetest-bigint - Create first nativetests for BigInt class in DataStructure. - Cover: Init, Add, Substract. - TODO: add more for other operation.
diff --git a/bin/NativeTests/BigIntTest.cpp b/bin/NativeTests/BigIntTest.cpp
@@ -0,0 +1,225 @@
+//-------------------------------------------------------------------------------------------------------
+// Copyright (C) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
+//-------------------------------------------------------------------------------------------------------
+
+#include "stdafx.h"
+#pragma warning(disable:26434) // Function definition hides non-virtual function in base class
+#pragma warning(disable:26439) // Implicit noexcept
+#pragma warning(disable:26451) // Arithmetic overflow
+#pragma warning(disable:26495) // Uninitialized member variable
+#include "catch.hpp"
+#include "BigIntTest.h"
+
+#pragma warning(disable:4100) // unreferenced formal parameter
+#pragma warning(disable:6387) // suppressing preFAST which raises warning for passing null to the JsRT APIs
+#pragma warning(disable:6262) // CATCH is using stack variables to report errors, suppressing the preFAST warning.
+
+namespace BigIntTest
+{
+    TEST_CASE("Init_Compare", "[BigIntTest]")
+    {
+        uint32 digits[1];
+        int32 length = 1;
+        Js::BigInt bi1, bi2;
+        BOOL f;
+        int result;
+
+        digits[0] = 0x00001111;
+        f = bi1.FInitFromRglu(digits, length);
+        REQUIRE(f);
+
+        SECTION("Equal number init from the same array and length")
+        {
+            f = bi2.FInitFromRglu(digits, length);
+            REQUIRE(f);
+            result = bi1.Compare(&bi2);
+            CHECK(result == 0);
+        }
+
+        SECTION("Equal number init from other big int number")
+        {
+            f = bi2.FInitFromBigint(&bi1);
+            REQUIRE(f);
+            result = bi1.Compare(&bi2);
+            CHECK(result == 0);
+        }
+
+        SECTION("Greater number")
+        {
+            digits[0] = 0x00000001;
+            f = bi2.FInitFromRglu(digits, length);
+            REQUIRE(f);
+            result = bi1.Compare(&bi2);
+            CHECK(result == 1);
+        }
+
+        SECTION("Smaller number")
+        {
+            digits[0] = 0x00000001;
+            f = bi2.FInitFromRglu(digits, length);
+            REQUIRE(f);
+            result = bi2.Compare(&bi1);
+            CHECK(result == -1);
+        }
+    }
+
+    TEST_CASE("Addition", "[BigIntTest]")
+    {
+        uint32 digits[1], digit1s[2];
+        int32 length = 1;
+        Js::BigInt bi1, bi2, bi3;
+        BOOL f;
+        int result;
+
+        SECTION("Check 0x33331111 + 0x33331111 = 0x66662222")
+        {
+            digits[0] = 0x33331111;
+            f = bi1.FInitFromRglu(digits, length);
+            REQUIRE(f);
+            f = bi2.FInitFromBigint(&bi1);
+            REQUIRE(f);
+            f = bi1.FAdd(&bi2);
+            REQUIRE(f);
+            digits[0] = 0x66662222;
+            f = bi3.FInitFromRglu(digits, length);
+            REQUIRE(f);
+            result = bi1.Compare(&bi3);
+            CHECK(result == 0);
+        }
+
+        SECTION("Check 0xffffffff + 0x1 = 0x100000000")
+        {
+            digits[0] = 0xffffffff;
+            f = bi1.FInitFromRglu(digits, length);
+            REQUIRE(f);
+            digits[0] = 0x00000001;
+            f = bi2.FInitFromRglu(digits, length);
+            REQUIRE(f);
+            f = bi1.FAdd(&bi2);
+            digit1s[0] = 0x0;
+            digit1s[1] = 0x1;
+            f = bi3.FInitFromRglu(digit1s, 2);
+            REQUIRE(f);
+            result = bi1.Compare(&bi3);
+            CHECK(result == 0);
+        }
+
+        SECTION("Check 0xffffffffffffffff + 0x1 = 0x10000000000000000")
+        {
+            digit1s[0] = 0xffffffff;
+            digit1s[1] = 0xffffffff;
+            f = bi1.FInitFromRglu(digit1s, 2);
+            REQUIRE(f);
+            digits[0] = 0x00000001;
+            f = bi2.FInitFromRglu(digits, 1);
+            REQUIRE(f);
+            f = bi1.FAdd(&bi2);
+            uint32 digit2s[3];
+            digit2s[0] = 0x0;
+            digit2s[1] = 0x0;
+            digit2s[2] = 0x1;
+            f = bi3.FInitFromRglu(digit2s, 3);
+            REQUIRE(f);
+            result = bi1.Compare(&bi3);
+            CHECK(result == 0);
+        }
+    }
+
+    TEST_CASE("Addition_Subtraction_Large_Number", "[BigIntTest]")
+    {
+        const int l1 = 50, l2 = 1;
+        uint32 digit1s[l1], digit2s[l2];
+        Js::BigInt bi1, bi2;
+        BOOL f;
+
+        SECTION("Check 0xf...0xf + 0x1 = 0x1_0x0...0x0")
+        {
+            for (int i = 0; i < l1; i++)
+            {
+                digit1s[i] = 0xffffffff;
+            }
+            f = bi1.FInitFromRglu(digit1s, l1);
+            REQUIRE(f);
+            digit2s[0] = 0x1;
+            f = bi2.FInitFromRglu(digit2s, l2);
+            REQUIRE(f);
+            f = bi1.FAdd(&bi2);
+            REQUIRE(f);
+            int32 length = bi1.Clu();
+            CHECK(length == l1 + 1);
+            uint32 digit = bi1.Lu(length - 1);
+            CHECK(digit == 1);
+            for (int i = 0; i < length - 1; i++)
+            {
+                digit = bi1.Lu(i);
+                CHECK(digit == 0);
+            }
+        }
+    }
+
+    TEST_CASE("Subtraction", "[BigIntTest]")
+    {
+        uint32 digits[1], digit1s[2];
+        int32 length = 1;
+        Js::BigInt bi1, bi2, bi3;
+        BOOL f;
+        int result;
+
+        SECTION("Check 0x66662222 - 0x33331111 = 0x33331111")
+        {
+            digits[0] = 0x33331111;
+            f = bi1.FInitFromRglu(digits, length);
+            REQUIRE(f);
+            f = bi2.FInitFromBigint(&bi1);
+            REQUIRE(f);
+            digits[0] = 0x66662222;
+            f = bi3.FInitFromRglu(digits, length);
+            REQUIRE(f);
+            bi3.Subtract(&bi2);
+            result = bi1.Compare(&bi3);
+            CHECK(result == 0);
+        }
+
+        SECTION("Check 0x3_0x1 - 0x1_0x0 = 0x2_0x1")
+        {
+            digit1s[0] = 0x1;
+            digit1s[1] = 0x3;
+            f = bi3.FInitFromRglu(digit1s, 2);
+            REQUIRE(f);
+            digit1s[0] = 0x0;
+            digit1s[1] = 0x1;
+            f = bi2.FInitFromRglu(digit1s, 2);
+            REQUIRE(f);
+            bi3.Subtract(&bi2);
+            int l = bi3.Clu();
+            CHECK(l == 2);
+            int digit = bi3.Lu(1);
+            CHECK(digit == 2);
+            digit = bi3.Lu(0);
+            CHECK(digit == 1);
+        }
+
+        SECTION("Check 0x2_0x0 - 0x1 = 0x1_0xfffffff")
+        {
+            digit1s[0] = 0x0;
+            digit1s[1] = 0x2;
+            f = bi3.FInitFromRglu(digit1s, 2);
+            REQUIRE(f);
+            digits[0] = 0x1;
+            f = bi2.FInitFromRglu(digits, 1);
+            REQUIRE(f);
+            bi3.Subtract(&bi2);
+            int l = bi3.Clu();
+            CHECK(l == 2);
+            int digit = bi3.Lu(1);
+            CHECK(digit == 1);
+            digit = bi3.Lu(0);
+            CHECK(digit == 0xffffffff);
+        }
+
+        SECTION("Currently 0x1_0x0 - 0x1 is overflow")
+        {
+        }
+    }
+}
diff --git a/bin/NativeTests/BigIntTest.h b/bin/NativeTests/BigIntTest.h
@@ -0,0 +1,49 @@
+//-------------------------------------------------------------------------------------------------------
+// Copyright (C) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
+//-------------------------------------------------------------------------------------------------------
+
+// This file contains stubs needed to make BigIntTest successfully compile and link as well
+// as a means to emulate behavior of objects that interact with BigInt class
+
+#include "..\..\lib\Common\Warnings.h"
+#include "..\..\lib\Common\Core\Api.cpp"
+#include "..\..\lib\Common\Common\NumberUtilities.cpp"
+
+namespace Js
+{
+    void Throw::FatalInternalError(long) 
+    {
+        Assert(false);
+    }
+
+    bool Throw::ReportAssert(__in char const *, unsigned int, __in char const *, __in char const *)
+    {
+        return false;
+    }
+
+    void Throw::LogAssert(void) {}
+}
+
+template <typename EncodedChar>
+double Js::NumberUtilities::StrToDbl(const EncodedChar *, const EncodedChar **, bool& )
+{
+    Assert(false);
+    return 0.0;// don't care
+}
+
+#if defined(_M_IX86) || defined(_M_X64)
+BOOL
+AutoSystemInfo::SSE3Available() const
+{
+    Assert(false);
+    return TRUE;
+}
+
+AutoSystemInfo AutoSystemInfo::Data;
+
+void AutoSystemInfo::Initialize(void){}
+#endif
+
+#include "..\..\lib\Common\DataStructures\BigInt.h"
+#include "..\..\lib\Common\DataStructures\BigInt.cpp"
diff --git a/bin/NativeTests/ConfigFlagsList.h b/bin/NativeTests/ConfigFlagsList.h
@@ -0,0 +1,7 @@
+//-------------------------------------------------------------------------------------------------------
+// Copyright (C) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
+//-------------------------------------------------------------------------------------------------------
+#pragma once
+
+// stub file for ConfigFlagsList.h
diff --git a/bin/NativeTests/NativeTests.vcxproj b/bin/NativeTests/NativeTests.vcxproj
@@ -48,6 +48,7 @@
     <ClInclude Include="stdafx.h" />
   </ItemGroup>
   <ItemGroup>
+    <ClCompile Include="BigIntTest.cpp" />
     <ClCompile Include="CodexAssert.cpp" />
     <ClCompile Include="CodexTests.cpp" />
     <ClCompile Include="FileLoadHelpers.cpp" />
diff --git a/lib/Common/DataStructures/BigInt.h b/lib/Common/DataStructures/BigInt.h
@@ -11,17 +11,18 @@ namespace Js
     ***************************************************************************/
     class BigInt
     {
+        // Non-negative BigInt is stored as an array of 'digit' where each digit is unit32
     private:
         // Make this big enough that we rarely have to call malloc.
-        enum { kcluMaxInit = 30 };
+        enum { kcluMaxInit = 30 };// initilize 30 digits
 
-        int32 m_cluMax;
-        int32 m_clu;
-        uint32 *m_prglu;
-        uint32 m_rgluInit[kcluMaxInit];
+        int32 m_cluMax; // current maximum length (or number of digits) it can contains
+        int32 m_clu; // current length (or number of digits)
+        uint32 *m_prglu; // pointer to array of digits
+        uint32 m_rgluInit[kcluMaxInit]; // pre-defined space to store array
 
         inline BigInt & operator= (BigInt &bi);
-        bool FResize(int32 clu);
+        bool FResize(int32 clu);// allocate more space if length go over maximum
 
 #if DBG
         #define AssertBi(pbi) Assert(pbi); (pbi)->AssertValid(true);
@@ -36,10 +37,10 @@ namespace Js
         BigInt(void);
         ~BigInt(void);
 
-        bool FInitFromRglu(uint32 *prglu, int32 clu);
-        bool FInitFromBigint(BigInt *pbiSrc);
+        bool FInitFromRglu(uint32 *prglu, int32 clu); // init from array and length
+        bool FInitFromBigint(BigInt *pbiSrc); 
         template <typename EncodedChar>
-        bool FInitFromDigits(const EncodedChar *prgch, int32 cch, int32 *pcchDec);
+        bool FInitFromDigits(const EncodedChar *prgch, int32 cch, int32 *pcchDec); 
         bool FMulAdd(uint32 luMul, uint32 luAdd);
         bool FMulPow5(int32 c5);
         bool FShiftLeft(int32 cbit);
@@ -50,8 +51,8 @@ namespace Js
         void Subtract(BigInt *pbi);
         int DivRem(BigInt *pbi);
 
-        int32 Clu(void);
-        uint32 Lu(int32 ilu);
+        int32 Clu(void); // return current length
+        uint32 Lu(int32 ilu); // return digit at position ilu start from 0
         double GetDbl(void);
     };
 }
