SERVER-69668 FLE2 range float precision: update OSTType algorithm

16 files changed, 2652 insertions, 783 deletions

diff --git a/buildscripts/lldb/lldb_printers.py b/buildscripts/lldb/lldb_printers.py
index 6c0bee9d53b..63dea8ca7f1 100644
--- a/buildscripts/lldb/lldb_printers.py
+++ b/buildscripts/lldb/lldb_printers.py
@@ -21,6 +21,7 @@ try:
     import collections
     from bson import json_util
     from bson.codec_options import CodecOptions
+    from bson import Decimal128
 except ImportError:
     print("Warning: Could not load bson library for Python {}.".format(sys.version))
     print("Check with the pip command if pymongo 3.x is installed.")
@@ -36,6 +37,8 @@ def __lldb_init_module(debugger, *_args):
     debugger.HandleCommand("type summary add mongo::StatusWith -F lldb_printers.StatusWithPrinter")
     debugger.HandleCommand("type summary add mongo::StringData -F lldb_printers.StringDataPrinter")
     debugger.HandleCommand("type summary add mongo::UUID -F lldb_printers.UUIDPrinter")
+    debugger.HandleCommand("type summary add mongo::Decimal128 -F lldb_printers.Decimal128Printer")
+
     debugger.HandleCommand(
         "type summary add --summary-string '${var.m_pathname}' 'boost::filesystem::path'")
     debugger.HandleCommand(
@@ -111,6 +114,14 @@ def UUIDPrinter(valobj, *_args):  # pylint: disable=invalid-name
     return str(uuid.UUID("".join(uuid_hex_bytes)))
 
 
+def Decimal128Printer(valobj, *_args):  # pylint: disable=invalid-name
+    """Print the Decimal128's string value."""
+    value = valobj.GetChildMemberWithName("_value")
+    low64 = value.GetChildMemberWithName("low64").GetValueAsUnsigned()
+    high64 = value.GetChildMemberWithName("high64").GetValueAsUnsigned()
+    return Decimal128((high64, low64))
+
+
 class UniquePtrPrinter:
     """Pretty printer for std::unique_ptr."""
 
diff --git a/src/mongo/crypto/SConscript b/src/mongo/crypto/SConscript
index 9e403911625..facbaa5a689 100644
--- a/src/mongo/crypto/SConscript
+++ b/src/mongo/crypto/SConscript
@@ -132,6 +132,7 @@ env.CppUnitTest(
     source=[
         'aead_encryption_test.cpp',
         'encryption_fields_util_test.cpp',
+        'encryption_fields_validation_test.cpp',
         'fle_crypto_test.cpp',
         'fle_crypto_test_vectors.cpp',
         'mechanism_scram_test.cpp',
diff --git a/src/mongo/crypto/encryption_fields_validation.cpp b/src/mongo/crypto/encryption_fields_validation.cpp
index b873a7dfdf3..136e51a0fee 100644
--- a/src/mongo/crypto/encryption_fields_validation.cpp
+++ b/src/mongo/crypto/encryption_fields_validation.cpp
@@ -33,6 +33,7 @@
 #include "mongo/crypto/encryption_fields_gen.h"
 #include "mongo/crypto/encryption_fields_util.h"
 #include "mongo/db/field_ref.h"
+#include <math.h>
 
 namespace mongo {
 
@@ -103,13 +104,41 @@ void validateRangeIndex(BSONType fieldType, QueryTypeConfig& query) {
 
             if (!query.getMin().has_value()) {
                 if (fieldType == NumberDouble) {
-                    query.setMin(mongo::Value(std::numeric_limits<double>::min()));
+                    query.setMin(mongo::Value(std::numeric_limits<double>::lowest()));
                     query.setMax(mongo::Value(std::numeric_limits<double>::max()));
                 } else {
                     query.setMin(mongo::Value(Decimal128::kLargestNegative));
                     query.setMax(mongo::Value(Decimal128::kLargestPositive));
                 }
             }
+
+            if (query.getPrecision().has_value()) {
+                uint32_t precision = query.getPrecision().value();
+                if (fieldType == NumberDouble) {
+                    uassert(
+                        6966805,
+                        "The number of decimal digits for minimum value must be less then or equal "
+                        "to precision",
+                        validateDoublePrecisionRange(query.getMin()->coerceToDouble(), precision));
+                    uassert(
+                        6966806,
+                        "The number of decimal digits for maximum value must be less then or equal "
+                        "to precision",
+                        validateDoublePrecisionRange(query.getMax()->coerceToDouble(), precision));
+
+                } else {
+                    auto minDecimal = query.getMin()->coerceToDecimal();
+                    uassert(6966807,
+                            "The number of decimal digits for minimum value must be less then or "
+                            "equal to precision",
+                            validateDecimal128PrecisionRange(minDecimal, precision));
+                    auto maxDecimal = query.getMax()->coerceToDecimal();
+                    uassert(6966808,
+                            "The number of decimal digits for maximum value must be less then or "
+                            "equal to precision",
+                            validateDecimal128PrecisionRange(maxDecimal, precision));
+                }
+            }
         }
             // We want to perform the same validation after sanitizing floating
             // point parameters, so we call FMT_FALLTHROUGH here.
@@ -229,4 +258,23 @@ void validateEncryptedFieldConfig(const EncryptedFieldConfig* config) {
         fieldPaths.push_back(std::move(newPath));
     }
 }
+
+bool validateDoublePrecisionRange(double d, uint32_t precision) {
+    double maybe_integer = d * pow(10.0, precision);
+    double floor_integer = floor(maybe_integer);
+
+    // We want to prevent users from making mistakes by specifing extra precision in the bounds.
+    // Since floating point is inaccurate, we need to account for this when testing for equality by
+    // considering the values almost equal to likely mean the bounds are within the precision range.
+    auto e = std::numeric_limits<double>::epsilon();
+    return fabs(maybe_integer - floor_integer) <= (e * floor_integer);
+}
+
+bool validateDecimal128PrecisionRange(Decimal128& dec, uint32_t precision) {
+    Decimal128 maybe_integer = dec.scale(precision);
+    Decimal128 floor_integer = maybe_integer.round();
+
+    return maybe_integer == floor_integer;
+}
+
 }  // namespace mongo
diff --git a/src/mongo/crypto/encryption_fields_validation.h b/src/mongo/crypto/encryption_fields_validation.h
index 26ac2932e77..6735d7b2b1e 100644
--- a/src/mongo/crypto/encryption_fields_validation.h
+++ b/src/mongo/crypto/encryption_fields_validation.h
@@ -31,6 +31,8 @@
 
 #include "mongo/bson/bsontypes.h"
 #include "mongo/db/exec/document_value/value.h"
+#include "mongo/platform/decimal128.h"
+
 
 namespace mongo {
 class EncryptedField;
@@ -52,4 +54,7 @@ Value coerceValueToRangeIndexTypes(Value val, BSONType fieldType);
 
 void validateEncryptedField(const EncryptedField* field);
 void validateEncryptedFieldConfig(const EncryptedFieldConfig* config);
+
+bool validateDoublePrecisionRange(double d, uint32_t precision);
+bool validateDecimal128PrecisionRange(Decimal128& dec, uint32_t precision);
 }  // namespace mongo
diff --git a/src/mongo/crypto/encryption_fields_validation_test.cpp b/src/mongo/crypto/encryption_fields_validation_test.cpp
new file mode 100644
index 00000000000..5ab9b2a432a
--- /dev/null
+++ b/src/mongo/crypto/encryption_fields_validation_test.cpp
@@ -0,0 +1,74 @@
+/**
+ *    Copyright (C) 2022-present MongoDB, Inc.
+ *
+ *    This program is free software: you can redistribute it and/or modify
+ *    it under the terms of the Server Side Public License, version 1,
+ *    as published by MongoDB, Inc.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    Server Side Public License for more details.
+ *
+ *    You should have received a copy of the Server Side Public License
+ *    along with this program. If not, see
+ *    <http://www.mongodb.com/licensing/server-side-public-license>.
+ *
+ *    As a special exception, the copyright holders give permission to link the
+ *    code of portions of this program with the OpenSSL library under certain
+ *    conditions as described in each individual source file and distribute
+ *    linked combinations including the program with the OpenSSL library. You
+ *    must comply with the Server Side Public License in all respects for
+ *    all of the code used other than as permitted herein. If you modify file(s)
+ *    with this exception, you may extend this exception to your version of the
+ *    file(s), but you are not obligated to do so. If you do not wish to do so,
+ *    delete this exception statement from your version. If you delete this
+ *    exception statement from all source files in the program, then also delete
+ *    it in the license file.
+ */
+
+#include "mongo/platform/basic.h"
+
+#include "mongo/crypto/encryption_fields_validation.h"
+
+#include "mongo/platform/decimal128.h"
+#include "mongo/unittest/unittest.h"
+
+namespace mongo {
+
+
+TEST(FLEValidationUtils, ValidateDoublePrecisionRange) {
+
+
+    ASSERT(validateDoublePrecisionRange(3.000, 0));
+    ASSERT(validateDoublePrecisionRange(3.000, 1));
+    ASSERT(validateDoublePrecisionRange(3.000, 2));
+
+    ASSERT_FALSE(validateDoublePrecisionRange(3.100, 0));
+    ASSERT(validateDoublePrecisionRange(3.100, 1));
+    ASSERT(validateDoublePrecisionRange(3.100, 2));
+
+    ASSERT(validateDoublePrecisionRange(1.000, 3));
+
+    ASSERT_FALSE(validateDoublePrecisionRange(3.140, 1));
+}
+
+bool validateDecimal128PrecisionRangeTest(std::string s, uint32_t precision) {
+    Decimal128 dec(s);
+    return validateDecimal128PrecisionRange(dec, precision);
+}
+
+TEST(FLEValidationUtils, ValidateDecimalPrecisionRange) {
+
+    ASSERT(validateDecimal128PrecisionRangeTest("3.000", 0));
+    ASSERT(validateDecimal128PrecisionRangeTest("3.000", 1));
+    ASSERT(validateDecimal128PrecisionRangeTest("3.000", 2));
+
+    ASSERT_FALSE(validateDecimal128PrecisionRangeTest("3.100", 0));
+    ASSERT(validateDecimal128PrecisionRangeTest("3.100", 1));
+    ASSERT(validateDecimal128PrecisionRangeTest("3.100", 2));
+
+    ASSERT_FALSE(validateDecimal128PrecisionRangeTest("3.140", 1));
+}
+
+}  // namespace mongo
diff --git a/src/mongo/crypto/fle_crypto.cpp b/src/mongo/crypto/fle_crypto.cpp
index 512b61a6ef3..2aa75de066e 100644
--- a/src/mongo/crypto/fle_crypto.cpp
+++ b/src/mongo/crypto/fle_crypto.cpp
@@ -37,6 +37,7 @@
 #include <iomanip>
 #include <iterator>
 #include <limits>
+#include <math.h>
 #include <memory>
 #include <stack>
 #include <string>
@@ -83,10 +84,10 @@
 // Optional defines to help with debugging
 //
 // Appends unencrypted fields to the state collections to aid in debugging
-//#define FLE2_DEBUG_STATE_COLLECTIONS
+// #define FLE2_DEBUG_STATE_COLLECTIONS
 
 // Verbose std::cout to troubleshoot the EmuBinary algorithm
-//#define DEBUG_ENUM_BINARY 1
+// #define DEBUG_ENUM_BINARY 1
 
 #ifdef FLE2_DEBUG_STATE_COLLECTIONS
 static_assert(kDebugBuild == 1, "Only use in debug builds");
@@ -140,6 +141,7 @@ constexpr size_t kHmacKeyOffset = 64;
 
 constexpr boost::multiprecision::uint128_t k1(1);
 constexpr boost::multiprecision::int128_t k10(10);
+constexpr boost::multiprecision::uint128_t k10ui(10);
 
 #ifdef FLE2_DEBUG_STATE_COLLECTIONS
 constexpr auto kDebugId = "_debug_id";
@@ -747,19 +749,12 @@ std::unique_ptr<Edges> getEdges(FLE2RangeInsertSpec spec, int sparsity) {
             uassert(6775508,
                     "max bound must be double",
                     !maxBound.has_value() || maxBound->type() == BSONType::NumberDouble);
-            // TODO - SERVER-69667 remove
-            uassert(7006610,
-                    "unexpected min bound",
-                    !minBound.has_value() ||
-                        minBound->numberDouble() == std::numeric_limits<double>::min());
-            uassert(7006611,
-                    "unexpected max bound",
-                    !maxBound.has_value() ||
-                        maxBound->numberDouble() == std::numeric_limits<double>::max());
-            return getEdgesDouble(element.Double(),
-                                  minBound.map([](BSONElement m) { return m.Double(); }),
-                                  maxBound.map([](BSONElement m) { return m.Double(); }),
-                                  sparsity);
+            return getEdgesDouble(
+                element.Double(),
+                minBound.map([](BSONElement m) { return m.Double(); }),
+                maxBound.map([](BSONElement m) { return m.Double(); }),
+                spec.getPrecision().map([](std::int32_t m) { return static_cast<uint32_t>(m); }),
+                sparsity);
 
         case BSONType::NumberDecimal:
             uassert(6775509,
@@ -768,19 +763,12 @@ std::unique_ptr<Edges> getEdges(FLE2RangeInsertSpec spec, int sparsity) {
             uassert(6775510,
                     "max bound must be decimal",
                     !maxBound.has_value() || maxBound->type() == BSONType::NumberDecimal);
-            // TODO - SERVER-69667 remove
-            uassert(7006612,
-                    "unexpected min bound",
-                    !minBound.has_value() ||
-                        minBound->numberDecimal() == Decimal128::kLargestNegative);
-            uassert(7006613,
-                    "unexpected max bound",
-                    !maxBound.has_value() ||
-                        maxBound->numberDecimal() == Decimal128::kLargestPositive);
-            return getEdgesDecimal128(element.numberDecimal(),
-                                      minBound.map([](BSONElement m) { return m.numberDecimal(); }),
-                                      maxBound.map([](BSONElement m) { return m.numberDecimal(); }),
-                                      sparsity);
+            return getEdgesDecimal128(
+                element.numberDecimal(),
+                minBound.map([](BSONElement m) { return m.numberDecimal(); }),
+                maxBound.map([](BSONElement m) { return m.numberDecimal(); }),
+                spec.getPrecision().map([](std::int32_t m) { return static_cast<uint32_t>(m); }),
+                sparsity);
 
         default:
             uassert(6775500, "must use supported FLE2 range type", false);
@@ -1512,6 +1500,14 @@ boost::multiprecision::int128_t exp10(int x) {
     return pow(k10, x);
 }
 
+boost::multiprecision::uint128_t exp10ui128(int x) {
+    return pow(k10ui, x);
+}
+
+double exp10Double(int x) {
+    return pow(10, x);
+}
+
 }  // namespace
 
 std::vector<std::string> getMinCover(const FLE2RangeFindSpec& spec, uint8_t sparsity) {
@@ -1573,8 +1569,11 @@ std::vector<std::string> getMinCover(const FLE2RangeFindSpec& spec, uint8_t spar
                                   includeLowerBound,
                                   upperBound.numberDouble(),
                                   includeUpperBound,
-                                  indexMin.Double(),
-                                  indexMax.Double(),
+                                  indexMin.numberDouble(),
+                                  indexMax.numberDouble(),
+                                  edgesInfo.getPrecision().map(
+                                      [](std::int32_t m) { return static_cast<uint32_t>(m); }),
+
                                   sparsity);
         case NumberDecimal:
             return minCoverDecimal128(lowerBound.numberDecimal(),
@@ -1583,6 +1582,9 @@ std::vector<std::string> getMinCover(const FLE2RangeFindSpec& spec, uint8_t spar
                                       includeUpperBound,
                                       indexMin.numberDecimal(),
                                       indexMax.numberDecimal(),
+                                      edgesInfo.getPrecision().map(
+                                          [](std::int32_t m) { return static_cast<uint32_t>(m); }),
+
                                       sparsity);
         default:
             // IDL validates that no other type is permitted.
@@ -3501,9 +3503,10 @@ OSTType_Int64 getTypeInfo64(int64_t value,
 
 OSTType_Double getTypeInfoDouble(double value,
                                  boost::optional<double> min,
-                                 boost::optional<double> max) {
+                                 boost::optional<double> max,
+                                 boost::optional<uint32_t> precision) {
     uassert(6775007,
-            "Must specify both a lower and upper bound or no bounds.",
+            "Must specify both a lower bound and upper bound or no bounds.",
             min.has_value() == max.has_value());
 
     uassert(6775008,
@@ -3525,6 +3528,70 @@ OSTType_Double getTypeInfoDouble(double value,
         value = 0;
     }
 
+    // When we use precision mode, we try to represent as a double value that fits in [-2^63, 2^63]
+    // (i.e. is a valid int64)
+    //
+    // This check determines if we can represent the precision truncated value as a 64-bit integer
+    // I.e. Is ((ub - lb) * 10^precision) < 64 bits.
+    //
+    // It is important we determine whether a range and its precision fit without looking that value
+    // because the encoding for precision truncated doubles is incompatible with the encoding for
+    // doubles without precision.
+    //
+    bool use_precision_mode = false;
+    uint32_t bits_range;
+    if (precision.has_value()) {
+
+        // Subnormal representations can support up to 5x10^-324 as a number
+        uassert(6966801,
+                "Precision must be between 0 and 324 inclusive",
+                precision.get() >= 0 && precision.get() <= 324);
+
+        uassert(6966803,
+                "Must specify both a lower bound, upper bound and precision",
+                min.has_value() == max.has_value() && max.has_value() == precision.has_value());
+
+        double range = max.get() - min.get();
+
+        // We can overflow if max = max double and min = min double so make sure we have finite
+        // number after we do subtraction
+        if (std::isfinite(range)) {
+
+            // This creates a range which is wider then we permit by our min/max bounds check with
+            // the +1 but it is as the algorithm is written in the paper.
+            double rangeAndPrecision = (range + 1) * exp10Double(precision.get());
+
+            if (std::isfinite(rangeAndPrecision)) {
+
+                double bits_range_double = log2(rangeAndPrecision);
+                bits_range = ceil(bits_range_double);
+
+                if (bits_range < 64) {
+                    use_precision_mode = true;
+                }
+            }
+        }
+    }
+
+    if (use_precision_mode) {
+
+        // Take a number of xxxx.ppppp and truncate it xxxx.ppp if precision = 3. We do not change
+        // the digits before the decimal place.
+        double v_prime = trunc(value * exp10Double(precision.get())) / exp10Double(precision.get());
+        int64_t v_prime2 = (v_prime - min.get()) * exp10Double(precision.get());
+
+        invariant(v_prime2 < std::numeric_limits<int64_t>::max() && v_prime2 >= 0);
+
+        uint64_t ret = static_cast<uint64_t>(v_prime2);
+
+        // Adjust maximum value to be the max bit range. This will be used by getEdges/minCover to
+        // trim bits.
+        uint64_t max_value = (1ULL << bits_range) - 1;
+        invariant(ret <= max_value);
+
+        return {ret, 0, max_value};
+    }
+
     // When we translate the double into "bits", the sign bit means that the negative numbers
     // get mapped into the higher 63 bits of a 64-bit integer. We want them to map into the lower
     // 64-bits so we invert the sign bit.
@@ -3552,12 +3619,45 @@ OSTType_Double getTypeInfoDouble(double value,
     return {uv, 0, std::numeric_limits<uint64_t>::max()};
 }
 
+boost::multiprecision::uint128_t toInt128FromDecimal128(Decimal128 dec) {
+    // This algorithm only works because it assumes we are dealing with Decimal128 numbers that are
+    // valid uint128 numbers. This means the Decimal128 has to be an integer or else the result is
+    // undefined.
+    invariant(dec.isFinite());
+    invariant(!dec.isNegative());
+
+    // If after rounding, the number has changed, we have a fraction, not an integer.
+    invariant(dec.round() == dec);
+
+    boost::multiprecision::uint128_t ret(dec.getCoefficientHigh());
+
+    ret <<= 64;
+    ret |= dec.getCoefficientLow();
+
+    auto exponent = static_cast<int32_t>(dec.getBiasedExponent()) - Decimal128::kExponentBias;
+
+    auto e1 = exp10ui128(labs(exponent));
+    if (exponent < 0) {
+        ret /= e1;
+    } else {
+        ret *= e1;
+    }
+
+    // Round-trip our new Int128 back to Decimal128 and make sure it is equal to the original
+    // Decimal128 or else.
+    Decimal128 roundTrip(ret.str());
+    invariant(roundTrip == dec);
+
+    return ret;
+}
+
 // For full algorithm see SERVER-68542
 OSTType_Decimal128 getTypeInfoDecimal128(Decimal128 value,
                                          boost::optional<Decimal128> min,
-                                         boost::optional<Decimal128> max) {
+                                         boost::optional<Decimal128> max,
+                                         boost::optional<uint32_t> precision) {
     uassert(6854201,
-            "Must specify both a lower and upper bound or no bounds.",
+            "Must specify both a lower bound and upper bound or no bounds.",
             min.has_value() == max.has_value());
 
     uassert(6854202,
@@ -3575,6 +3675,95 @@ OSTType_Decimal128 getTypeInfoDecimal128(Decimal128 value,
                 value >= min.value() && value <= max.value());
     }
 
+    // When we use precision mode, we try to represent as a decimal128 value that fits in [-2^127,
+    // 2^127] (i.e. is a valid int128)
+    //
+    // This check determines if we can represent the precision truncated value as a 128-bit integer
+    // I.e. Is ((ub - lb) * 10^precision) < 128 bits.
+    //
+    // It is important we determine whether a range and its precision fit without looking that value
+    // because the encoding for precision truncated decimal128 is incompatible with normal
+    // decimal128 values.
+    bool use_precision_mode = false;
+    int bits_range = 0;
+    if (precision.has_value()) {
+        uassert(6966804,
+                "Must specify both a lower bound, upper bound and precision",
+                min.has_value() == max.has_value() && max.has_value() == precision.has_value());
+
+        uassert(6966802,
+                "Precision must be between 0 and 6182 inclusive",
+                precision.get() >= 0 && precision.get() <= 6142);
+
+
+        Decimal128 bounds = max.get().subtract(min.get()).add(Decimal128(1));
+
+        if (bounds.isFinite()) {
+            Decimal128 bits_range_dec = bounds.scale(precision.get()).logarithm(Decimal128(2));
+
+            if (bits_range_dec.isFinite() && bits_range_dec < Decimal128(128)) {
+                // kRoundTowardPositive is the same as C99 ceil()
+
+                bits_range = bits_range_dec.toIntExact(Decimal128::kRoundTowardPositive);
+
+                if (bits_range < 128) {
+                    use_precision_mode = true;
+                }
+            }
+        }
+    }
+
+    if (use_precision_mode) {
+        // Example value: 31.4159
+        // Example Precision = 2
+
+        // Shift the number up
+        // Returns: 3141.9
+        Decimal128 valueScaled = value.scale(precision.get());
+
+        // Round the number down
+        // Returns 3141.0
+        Decimal128 valueTruncated = valueScaled.round(Decimal128::kRoundTowardZero);
+
+        // Shift the number down
+        // Returns: 31.41
+        Decimal128 v_prime = valueTruncated.scale(-static_cast<int32_t>(precision.get()));
+
+        // Adjust the number by the lower bound
+        // Make it an integer by scaling the number
+        //
+        // Returns 3141.0
+        Decimal128 v_prime2 = v_prime.subtract(min.get()).scale(precision.get());
+
+        invariant(v_prime2.logarithm(Decimal128(2)).isLess(Decimal128(128)));
+
+        // Now we need to get the Decimal128 out as a 128-bit integer
+        // But Decimal128 does not support conversion to Int128.
+        //
+        // If we think the Decimal128 fits in the range, based on the maximum value, we try to
+        // convert to int64 directly.
+        if (bits_range < 64) {
+
+            // Try conversion to int64, it may fail but since it is easy we try this first.
+            //
+            uint32_t signalingFlags = Decimal128::SignalingFlag::kNoFlag;
+
+            std::int64_t vPrimeInt264 = v_prime2.toLongExact(&signalingFlags);
+
+            if (signalingFlags == Decimal128::SignalingFlag::kNoFlag) {
+                std::uint64_t vPrimeUInt264 = static_cast<uint64_t>(vPrimeInt264);
+                return {vPrimeUInt264, 0, (1ULL << bits_range) - 1};
+            }
+        }
+
+        boost::multiprecision::uint128_t u_ret = toInt128FromDecimal128(v_prime2);
+
+        boost::multiprecision::uint128_t max_dec =
+            (boost::multiprecision::uint128_t(1) << bits_range) - 1;
+
+        return {u_ret, 0, max_dec};
+    }
+
     bool isNegative = value.isNegative();
     int32_t scale = value.getBiasedExponent() - Decimal128::kExponentBias;
     int64_t highCoefficent = value.getCoefficientHigh();
@@ -3743,16 +3932,18 @@ std::unique_ptr<Edges> getEdgesInt64(int64_t value,
 std::unique_ptr<Edges> getEdgesDouble(double value,
                                       boost::optional<double> min,
                                       boost::optional<double> max,
+                                      boost::optional<uint32_t> precision,
                                       int sparsity) {
-    auto aost = getTypeInfoDouble(value, min, max);
+    auto aost = getTypeInfoDouble(value, min, max, precision);
     return getEdgesT(aost.value, aost.min, aost.max, sparsity);
 }
 
 std::unique_ptr<Edges> getEdgesDecimal128(Decimal128 value,
                                           boost::optional<Decimal128> min,
                                           boost::optional<Decimal128> max,
+                                          boost::optional<uint32_t> precision,
                                           int sparsity) {
-    auto aost = getTypeInfoDecimal128(value, min, max);
+    auto aost = getTypeInfoDecimal128(value, min, max, precision);
     return getEdgesT(aost.value, aost.min, aost.max, sparsity);
 }
 
@@ -3919,9 +4110,10 @@ std::vector<std::string> minCoverDouble(double lowerBound,
                                         bool includeUpperBound,
                                         boost::optional<double> min,
                                         boost::optional<double> max,
+                                        boost::optional<uint32_t> precision,
                                         int sparsity) {
-    auto a = getTypeInfoDouble(lowerBound, min, max);
-    auto b = getTypeInfoDouble(upperBound, min, max);
+    auto a = getTypeInfoDouble(lowerBound, min, max, precision);
+    auto b = getTypeInfoDouble(upperBound, min, max, precision);
     dassert(a.min == b.min);
     dassert(a.max == b.max);
     adjustBounds(a, includeLowerBound, b, includeUpperBound);
@@ -3936,9 +4128,10 @@ std::vector<std::string> minCoverDecimal128(Decimal128 lowerBound,
                                             bool includeUpperBound,
                                             boost::optional<Decimal128> min,
                                             boost::optional<Decimal128> max,
+                                            boost::optional<uint32_t> precision,
                                             int sparsity) {
-    auto a = getTypeInfoDecimal128(lowerBound, min, max);
-    auto b = getTypeInfoDecimal128(upperBound, min, max);
+    auto a = getTypeInfoDecimal128(lowerBound, min, max, precision);
+    auto b = getTypeInfoDecimal128(upperBound, min, max, precision);
     dassert(a.min == b.min);
     dassert(a.max == b.max);
     adjustBounds(a, includeLowerBound, b, includeUpperBound);
diff --git a/src/mongo/crypto/fle_crypto.h b/src/mongo/crypto/fle_crypto.h
index 298092c8bec..6c0bb59095f 100644
--- a/src/mongo/crypto/fle_crypto.h
+++ b/src/mongo/crypto/fle_crypto.h
@@ -1141,7 +1141,8 @@ struct OSTType_Double {
 
 OSTType_Double getTypeInfoDouble(double value,
                                  boost::optional<double> min,
-                                 boost::optional<double> max);
+                                 boost::optional<double> max,
+                                 boost::optional<uint32_t> precision);
 /**
  * Describe the encoding of an BSON Decimal (i.e. IEEE 754 Decimal128)
  *
@@ -1159,9 +1160,13 @@ struct OSTType_Decimal128 {
     boost::multiprecision::uint128_t max;
 };
 
+boost::multiprecision::uint128_t toInt128FromDecimal128(Decimal128 dec);
+
 OSTType_Decimal128 getTypeInfoDecimal128(Decimal128 value,
                                          boost::optional<Decimal128> min,
-                                         boost::optional<Decimal128> max);
+                                         boost::optional<Decimal128> max,
+                                         boost::optional<uint32_t> precision);
+
 
 struct FLEFindEdgeTokenSet {
     EDCDerivedFromDataToken edc;
@@ -1216,11 +1221,14 @@ std::unique_ptr<Edges> getEdgesInt64(int64_t value,
 std::unique_ptr<Edges> getEdgesDouble(double value,
                                       boost::optional<double> min,
                                       boost::optional<double> max,
+                                      boost::optional<uint32_t> precision,
                                       int sparsity);
 
 std::unique_ptr<Edges> getEdgesDecimal128(Decimal128 value,
                                           boost::optional<Decimal128> min,
                                           boost::optional<Decimal128> max,
+                                          boost::optional<uint32_t> precision,
+
                                           int sparsity);
 /**
  * Mincover calculator
@@ -1248,6 +1256,7 @@ std::vector<std::string> minCoverDouble(double lowerBound,
                                         bool includeUpperBound,
                                         boost::optional<double> min,
                                         boost::optional<double> max,
+                                        boost::optional<uint32_t> precision,
                                         int sparsity);
 
 std::vector<std::string> minCoverDecimal128(Decimal128 lowerBound,
@@ -1256,6 +1265,8 @@ std::vector<std::string> minCoverDecimal128(Decimal128 lowerBound,
                                             bool includeUpperBound,
                                             boost::optional<Decimal128> min,
                                             boost::optional<Decimal128> max,
+                                            boost::optional<uint32_t> precision,
+
                                             int sparsity);
 /**
  * Utility functions manipulating buffers.
diff --git a/src/mongo/crypto/fle_crypto_test.cpp b/src/mongo/crypto/fle_crypto_test.cpp
index 652e56dab2f..e7dc119953e 100644
--- a/src/mongo/crypto/fle_crypto_test.cpp
+++ b/src/mongo/crypto/fle_crypto_test.cpp
@@ -32,6 +32,7 @@
 #include "mongo/crypto/fle_crypto.h"
 
 #include <algorithm>
+#include <boost/algorithm/string/replace.hpp>
 #include <cstdint>
 #include <iostream>
 #include <limits>
@@ -2354,9 +2355,9 @@ TEST(RangeTest, Int64_Errors) {
     ASSERT_THROWS_CODE(getTypeInfo64(4, LLONG_MIN, LLONG_MIN), AssertionException, 6775005);
 }
 
-
 TEST(RangeTest, Double_Bounds) {
-#define ASSERT_EIB(x, z) ASSERT_EQ(getTypeInfoDouble((x), -1E100, 1E100).value, (z));
+#define ASSERT_EIB(x, z) \
+    ASSERT_EQ(getTypeInfoDouble((x), boost::none, boost::none, boost::none).value, (z));
 
     // Larger numbers map to larger uint64
     ASSERT_EIB(-1111, 4570770991734587392ULL);
@@ -2403,24 +2404,99 @@ TEST(RangeTest, Double_Bounds) {
 #undef ASSERT_EIB
 }
 
+TEST(RangeTest, Double_Bounds_Precision) {
+#define ASSERT_EIBP(x, y, z) ASSERT_EQ(getTypeInfoDouble((x), -100000, 100000, y).value, (z));
+
+    ASSERT_EIBP(3.141592653589, 1, 1000031);
+    ASSERT_EIBP(3.141592653589, 2, 10000314);
+    ASSERT_EIBP(3.141592653589, 3, 100003141);
+    ASSERT_EIBP(3.141592653589, 4, 1000031415);
+    ASSERT_EIBP(3.141592653589, 5, 10000314159);
+    ASSERT_EIBP(3.141592653589, 6, 100003141592);
+    ASSERT_EIBP(3.141592653589, 7, 1000031415926);
+#undef ASSERT_EIBP
+
+
+#define ASSERT_EIBB(v, ub, lb, prc, z)                   \
+    {                                                    \
+        auto _ost = getTypeInfoDouble((v), lb, ub, prc); \
+        ASSERT_NE(_ost.max, 18446744073709551615ULL);    \
+        ASSERT_EQ(_ost.value, z);                        \
+    }
+#define ASSERT_EIBB_OVERFLOW(v, ub, lb, prc, z)          \
+    {                                                    \
+        auto _ost = getTypeInfoDouble((v), lb, ub, prc); \
+        ASSERT_EQ(_ost.max, 18446744073709551615ULL);    \
+        ASSERT_EQ(_ost.value, z);                        \
+    }
+
+    ASSERT_EIBB(0, 1, -1, 3, 1000);
+    ASSERT_EIBB(0, 1, -1E5, 3, 100000000);
+
+    ASSERT_EIBB(-1E-33, 1, -1E5, 3, 100000000);
+
+    ASSERT_EIBB_OVERFLOW(0,
+                         std::numeric_limits<double>::max(),
+                         std::numeric_limits<double>::lowest(),
+                         3,
+                         9223372036854775808ULL);
+
+    ASSERT_EIBB(3.141592653589, 5, 0, 0, 3);
+    ASSERT_EIBB(3.141592653589, 5, 0, 1, 31);
+
+    ASSERT_EIBB(3.141592653589, 5, 0, 2, 314);
+
+    ASSERT_EIBB(3.141592653589, 5, 0, 3, 3141);
+    ASSERT_EIBB(3.141592653589, 5, 0, 16, 31415926535890000);
+
+
+    ASSERT_EIBB(-5, -1, -10, 3, 5000);
 
-TEST(RangeTest, Double_Errors) {
-    ASSERT_THROWS_CODE(getTypeInfoDouble(1, boost::none, 2), AssertionException, 6775007);
-    ASSERT_THROWS_CODE(getTypeInfoDouble(1, 0, boost::none), AssertionException, 6775007);
-    ASSERT_THROWS_CODE(getTypeInfoDouble(1, 2, 1), AssertionException, 6775009);
 
+    ASSERT_EIBB_OVERFLOW(1E100,
+                         std::numeric_limits<double>::max(),
+                         std::numeric_limits<double>::lowest(),
+                         3,
+                         15326393489903895421ULL);
 
-    ASSERT_THROWS_CODE(getTypeInfoDouble(1, 2, 3), AssertionException, 6775010);
-    ASSERT_THROWS_CODE(getTypeInfoDouble(4, 2, 3), AssertionException, 6775010);
+    ASSERT_EIBB(1E9, 1E10, 0, 3, 1000000000000);
+    ASSERT_EIBB(1E9, 1E10, 0, 0, 1000000000);
 
 
-    ASSERT_THROWS_CODE(getTypeInfoDouble(std::numeric_limits<double>::infinity(), 1, 2),
+    ASSERT_EIBB(-5, 10, -10, 0, 5);
+    ASSERT_EIBB(-5, 10, -10, 2, 500);
+
+    ASSERT_EIBB_OVERFLOW(1E-30, 10E-30, 1E-30, 35, 13381399884061196960ULL);
+
+#undef ASSERT_EIBB
+#undef ASSERT_EIBB_OVERFLOW
+}
+
+TEST(RangeTest, Double_Bounds_Precision_Errors) {
+
+    ASSERT_THROWS_CODE(
+        getTypeInfoDouble(1, boost::none, boost::none, 1), AssertionException, 6966803);
+
+    ASSERT_THROWS_CODE(getTypeInfoDouble(1, 1, 2, -1), AssertionException, 6966801);
+    ASSERT_THROWS_CODE(getTypeInfoDouble(1, 1, 2, 325), AssertionException, 6966801);
+}
+
+TEST(RangeTest, Double_Errors) {
+    ASSERT_THROWS_CODE(getTypeInfoDouble(1, boost::none, 2, 5), AssertionException, 6775007);
+    ASSERT_THROWS_CODE(getTypeInfoDouble(1, 0, boost::none, 5), AssertionException, 6775007);
+    ASSERT_THROWS_CODE(getTypeInfoDouble(1, 2, 1, 5), AssertionException, 6775009);
+
+    ASSERT_THROWS_CODE(getTypeInfoDouble(1, 2, 3, 5), AssertionException, 6775010);
+    ASSERT_THROWS_CODE(getTypeInfoDouble(4, 2, 3, 5), AssertionException, 6775010);
+
+
+    ASSERT_THROWS_CODE(getTypeInfoDouble(std::numeric_limits<double>::infinity(), 1, 2, 5),
                        AssertionException,
                        6775008);
-    ASSERT_THROWS_CODE(getTypeInfoDouble(std::numeric_limits<double>::quiet_NaN(), 1, 2),
+    ASSERT_THROWS_CODE(getTypeInfoDouble(std::numeric_limits<double>::quiet_NaN(), 1, 2, 5),
                        AssertionException,
                        6775008);
-    ASSERT_THROWS_CODE(getTypeInfoDouble(std::numeric_limits<double>::signaling_NaN(), 1, 2),
+    ASSERT_THROWS_CODE(getTypeInfoDouble(std::numeric_limits<double>::signaling_NaN(), 1, 2, 5),
                        AssertionException,
                        6775008);
 }
@@ -2431,24 +2507,25 @@ TEST(EdgeCalcTest, SparsityConstraints) {
     ASSERT_THROWS_CODE(getEdgesInt32(1, 0, 8, -1), AssertionException, 6775101);
     ASSERT_THROWS_CODE(getEdgesInt64(1, 0, 8, 0), AssertionException, 6775101);
     ASSERT_THROWS_CODE(getEdgesInt64(1, 0, 8, -1), AssertionException, 6775101);
-    ASSERT_THROWS_CODE(getEdgesDouble(1.0, 0.0, 8.0, 0), AssertionException, 6775101);
-    ASSERT_THROWS_CODE(getEdgesDouble(1.0, 0.0, 8.0, -1), AssertionException, 6775101);
+    ASSERT_THROWS_CODE(getEdgesDouble(1.0, 0.0, 8.0, 5, 0), AssertionException, 6775101);
+    ASSERT_THROWS_CODE(getEdgesDouble(1.0, 0.0, 8.0, 5, -1), AssertionException, 6775101);
 }
 
 TEST(MinCoverCalcTest, MinCoverConstraints) {
     ASSERT(minCoverInt32(2, true, 1, true, 0, 7, 1).empty());
     ASSERT(minCoverInt64(2, true, 1, true, 0, 7, 1).empty());
-    ASSERT(minCoverDouble(2, true, 1, 0, true, 7, 1).empty());
+    ASSERT(minCoverDouble(2, true, 1, true, 0, 7, boost::none, 1).empty());
     ASSERT(minCoverDecimal128(
-               Decimal128(2), true, Decimal128(1), true, Decimal128(0), Decimal128(7), 1)
+               Decimal128(2), true, Decimal128(1), true, Decimal128(0), Decimal128(7), 5, 1)
                .empty());
 }
 
-TEST(RangeTest, Decimal1238_Bounds) {
-#define ASSERT_EIB(x, z)                                                                 \
-    ASSERT_EQ(boost::multiprecision::to_string(                                          \
-                  getTypeInfoDecimal128(Decimal128(x), boost::none, boost::none).value), \
-              (z));
+TEST(RangeTest, Decimal128_Bounds) {
+#define ASSERT_EIB(x, z)                                                                        \
+    ASSERT_EQ(                                                                                  \
+        boost::multiprecision::to_string(                                                       \
+            getTypeInfoDecimal128(Decimal128(x), boost::none, boost::none, boost::none).value), \
+        (z));
 
     // Larger numbers map tw larger uint64
     ASSERT_EIB(-1234567890E7, "108549948892579231731687303715884111887");
@@ -2531,42 +2608,200 @@ TEST(RangeTest, Decimal1238_Bounds) {
 #undef ASSERT_EIB
 }
 
-TEST(RangeTest, Decimal1238_Errors) {
-    ASSERT_THROWS_CODE(getTypeInfoDecimal128(Decimal128(1), boost::none, Decimal128(2)),
+
+TEST(RangeTest, Decimal128_Bounds_Precision) {
+
+#define ASSERT_EIBP(x, y, z)                                                                    \
+    ASSERT_EQ(                                                                                  \
+        getTypeInfoDecimal128(Decimal128(x), Decimal128(-100000), Decimal128(100000), y).value, \
+        (z));
+
+    ASSERT_EIBP("3.141592653589E-1", 10, 1000003141592653);
+    ASSERT_EIBP("31.41592653589E-2", 10, 1000003141592653);
+    ASSERT_EIBP("314.1592653589E-3", 10, 1000003141592653);
+    ASSERT_EIBP("3141.592653589E-4", 10, 1000003141592653);
+    ASSERT_EIBP("31415.92653589E-5", 10, 1000003141592653);
+    ASSERT_EIBP("314159.2653589E-6", 10, 1000003141592653);
+    ASSERT_EIBP("3141592.653589E-7", 10, 1000003141592653);
+    ASSERT_EIBP("31415926.53589E-8", 10, 1000003141592653);
+
+#undef ASSERT_EIBP
+
+#define ASSERT_EIBPL(x, y, z)                                                                   \
+    ASSERT_EQ(                                                                                  \
+        getTypeInfoDecimal128(Decimal128(x), Decimal128(-100000), Decimal128("1E22"), y).value, \
+        boost::multiprecision::uint128_t(z));
+
+    ASSERT_EIBPL("3.1415926535897932384626433832795E20", 5, "31415926535897942384626433");
+    ASSERT_EIBPL("3.1415926535897932384626433832795E20", 6, "314159265358979423846264338");
+
+    ASSERT_EIBPL("3.1415926535897932384626433832795E20", 7, "3141592653589794238462643383");
+
+    ASSERT_EIBPL("3.1415926535897932384626433832795E20", 8, "31415926535897942384626433832");
+
+#undef ASSERT_EIBP
+
+#define ASSERT_EIBP(x, y, z)                                                                    \
+    ASSERT_EQ(                                                                                  \
+        getTypeInfoDecimal128(Decimal128(x), Decimal128(-100000), Decimal128(100000), y).value, \
+        (z));
+
+    ASSERT_EIBP(3.141592653589, 1, 1000031);
+    ASSERT_EIBP(3.141592653589, 2, 10000314);
+    ASSERT_EIBP(3.141592653589, 3, 100003141);
+    ASSERT_EIBP(3.141592653589, 4, 1000031415);
+    ASSERT_EIBP(3.141592653589, 5, 10000314159);
+    ASSERT_EIBP(3.141592653589, 6, 100003141592);
+    ASSERT_EIBP(3.141592653589, 7, 1000031415926);
+#undef ASSERT_EIBP
+
+
+#define ASSERT_EIBB(v, ub, lb, prc, z)                                                         \
+    {                                                                                          \
+        auto _ost = getTypeInfoDecimal128(Decimal128(v), Decimal128(lb), Decimal128(ub), prc); \
+        ASSERT_NE(_ost.max.str(), "340282366920938463463374607431768211455");                  \
+        ASSERT_EQ(_ost.value, z);                                                              \
+    }
+
+#define ASSERT_EIBB_OVERFLOW(v, ub, lb, prc, z)                                                \
+    {                                                                                          \
+        auto _ost = getTypeInfoDecimal128(Decimal128(v), Decimal128(lb), Decimal128(ub), prc); \
+        ASSERT_EQ(_ost.max.str(), "340282366920938463463374607431768211455");                  \
+        ASSERT_EQ(_ost.value, z);                                                              \
+    }
+
+    ASSERT_EIBB(0, 1, -1, 3, 1000);
+    ASSERT_EIBB(0, 1, -1E5, 3, 100000000);
+
+    ASSERT_EIBB(-1E-33, 1, -1E5, 3, 100000000);
+
+    ASSERT_EIBB_OVERFLOW(
+        0,
+        Decimal128::kLargestPositive,
+        Decimal128::kLargestNegative,
+        3,
+        boost::multiprecision::uint128_t("170141183460469231731687303715884105728"));
+    ASSERT_EIBB_OVERFLOW(
+        0,
+        std::numeric_limits<double>::max(),
+        std::numeric_limits<double>::lowest(),
+        3,
+        boost::multiprecision::uint128_t("170141183460469231731687303715884105728"));
+
+    ASSERT_EIBB(3.141592653589, 5, 0, 0, 3);
+    ASSERT_EIBB(3.141592653589, 5, 0, 1, 31);
+
+    ASSERT_EIBB(3.141592653589, 5, 0, 2, 314);
+
+    ASSERT_EIBB(3.141592653589, 5, 0, 3, 3141);
+    ASSERT_EIBB(3.141592653589, 5, 0, 16, 31415926535890000);
+
+
+    ASSERT_EIBB(-5, -1, -10, 3, 5000);
+
+
+    ASSERT_EIBB_OVERFLOW(
+        1E100,
+        std::numeric_limits<double>::max(),
+        std::numeric_limits<double>::lowest(),
+        3,
+        boost::multiprecision::uint128_t("232572183460469231731687303715884099485"));
+
+    ASSERT_EIBB(1E9, 1E10, 0, 3, 1000000000000);
+    ASSERT_EIBB(1E9, 1E10, 0, 0, 1000000000);
+
+
+    ASSERT_EIBB(-5, 10, -10, 0, 5);
+    ASSERT_EIBB(-5, 10, -10, 2, 500);
+
+
+    ASSERT_EIBB(5E-30, 10E-30, 1E-30, 35, boost::multiprecision::uint128_t("400000"));
+
+#undef ASSERT_EIBB
+#undef ASSERT_EIBB_OVERFLOW
+}
+
+TEST(RangeTest, Decimal128_Errors) {
+    ASSERT_THROWS_CODE(getTypeInfoDecimal128(Decimal128(1), boost::none, Decimal128(2), 5),
                        AssertionException,
                        6854201);
-    ASSERT_THROWS_CODE(getTypeInfoDecimal128(Decimal128(1), Decimal128(0), boost::none),
+    ASSERT_THROWS_CODE(getTypeInfoDecimal128(Decimal128(1), Decimal128(0), boost::none, 5),
                        AssertionException,
                        6854201);
-    ASSERT_THROWS_CODE(getTypeInfoDecimal128(Decimal128(1), Decimal128(2), Decimal128(1)),
+    ASSERT_THROWS_CODE(getTypeInfoDecimal128(Decimal128(1), Decimal128(2), Decimal128(1), 5),
                        AssertionException,
                        6854203);
 
 
-    ASSERT_THROWS_CODE(getTypeInfoDecimal128(Decimal128(1), Decimal128(2), Decimal128(3)),
+    ASSERT_THROWS_CODE(getTypeInfoDecimal128(Decimal128(1), Decimal128(2), Decimal128(3), 5),
                        AssertionException,
                        6854204);
-    ASSERT_THROWS_CODE(getTypeInfoDecimal128(Decimal128(4), Decimal128(2), Decimal128(3)),
+    ASSERT_THROWS_CODE(getTypeInfoDecimal128(Decimal128(4), Decimal128(2), Decimal128(3), 5),
                        AssertionException,
                        6854204);
 
 
     ASSERT_THROWS_CODE(
-        getTypeInfoDecimal128(Decimal128::kPositiveInfinity, boost::none, boost::none),
+        getTypeInfoDecimal128(Decimal128::kPositiveInfinity, boost::none, boost::none, boost::none),
+        AssertionException,
+        6854202);
+    ASSERT_THROWS_CODE(
+        getTypeInfoDecimal128(Decimal128::kNegativeInfinity, boost::none, boost::none, boost::none),
         AssertionException,
         6854202);
+
     ASSERT_THROWS_CODE(
-        getTypeInfoDecimal128(Decimal128::kNegativeInfinity, boost::none, boost::none),
+        getTypeInfoDecimal128(Decimal128::kPositiveNaN, boost::none, boost::none, boost::none),
         AssertionException,
         6854202);
 
-    ASSERT_THROWS_CODE(getTypeInfoDecimal128(Decimal128::kPositiveNaN, boost::none, boost::none),
+    ASSERT_THROWS_CODE(
+        getTypeInfoDecimal128(Decimal128::kNegativeNaN, boost::none, boost::none, boost::none),
+        AssertionException,
+        6854202);
+}
+
+
+TEST(RangeTest, Decimal128_Bounds_Precision_Errors) {
+
+    ASSERT_THROWS_CODE(getTypeInfoDecimal128(Decimal128(1), boost::none, boost::none, 1),
                        AssertionException,
-                       6854202);
+                       6966804);
 
-    ASSERT_THROWS_CODE(getTypeInfoDecimal128(Decimal128::kNegativeNaN, boost::none, boost::none),
+    ASSERT_THROWS_CODE(getTypeInfoDecimal128(Decimal128(1), Decimal128(1), Decimal128(2), -1),
                        AssertionException,
-                       6854202);
+                       6966802);
+
+    ASSERT_THROWS_CODE(getTypeInfoDecimal128(Decimal128(1), Decimal128(1), Decimal128(2), 6143),
+                       AssertionException,
+                       6966802);
+}
+
+void roundTripDecimal128_Int128(std::string dec_str) {
+    Decimal128 dec(dec_str);
+
+    auto ret = toInt128FromDecimal128(dec);
+
+    Decimal128 roundTrip(ret.str());
+    ASSERT(roundTrip == dec);
+}
+
+TEST(RangeTest, Decimal128_to_Int128) {
+    roundTripDecimal128_Int128("0");
+    roundTripDecimal128_Int128("123");
+    roundTripDecimal128_Int128("40000000");
+    roundTripDecimal128_Int128("40000000.00");
+    roundTripDecimal128_Int128("40000000.00000");
+    roundTripDecimal128_Int128("40000000.000000000000");
+
+    roundTripDecimal128_Int128("40000.000E5");
+    roundTripDecimal128_Int128("40000000E10");
+    roundTripDecimal128_Int128("40000.000E10");
+    roundTripDecimal128_Int128("40000000E20");
+    roundTripDecimal128_Int128("40000.000E20");
+    roundTripDecimal128_Int128("40000000E30");
+    roundTripDecimal128_Int128("40000.000E30");
+    roundTripDecimal128_Int128("4E37");
 }
 
 // Tests to make sure that the getMinCover() interface properly calculates the mincover when given a
@@ -2608,6 +2843,44 @@ void assertMinCoverResult(A lb,
     }
 }
 
+template <typename A, typename B, typename C, typename D>
+void assertMinCoverResultPrecision(A lb,
+                                   bool lbIncluded,
+                                   B ub,
+                                   bool ubIncluded,
+                                   C min,
+                                   D max,
+                                   int sparsity,
+                                   int precision,
+                                   std::initializer_list<std::string> expectedList) {
+    std::vector<std::string> expected{expectedList};
+    std::vector<BSONElement> elems;
+    auto vals = BSON_ARRAY(lb << ub << min << max);
+    vals.elems(elems);
+
+    FLE2RangeFindSpecEdgesInfo edgesInfo;
+
+    edgesInfo.setLowerBound(elems[0]);
+    edgesInfo.setLbIncluded(lbIncluded);
+    edgesInfo.setUpperBound(elems[1]);
+    edgesInfo.setUbIncluded(ubIncluded);
+    edgesInfo.setIndexMin(elems[2]);
+    edgesInfo.setIndexMax(elems[3]);
+    edgesInfo.setPrecision(precision);
+
+    FLE2RangeFindSpec spec;
+    spec.setEdgesInfo(edgesInfo);
+
+    spec.setFirstOperator(Fle2RangeOperator::kGt);
+    spec.setPayloadId(1234);
+
+    auto result = getMinCover(spec, sparsity);
+    ASSERT_EQ(result.size(), expected.size());
+    for (size_t i = 0; i < result.size(); i++) {
+        ASSERT_EQ(result[i], expected[i]) << spec.toBSON();
+    }
+}
+
 TEST(MinCoverInterfaceTest, Int32_Basic) {
     assertMinCoverResult(7, true, 32, true, 0, 32, 1, {"000111", "001", "01", "100000"});
     assertMinCoverResult(7, false, 32, false, 0, 32, 1, {"001", "01"});
@@ -3466,35 +3739,41 @@ TEST(MinCoverInterfaceTest, Decimal_Basic) {
 }
 
 TEST(MinCoverInterfaceTest, InfiniteRangeBounds) {
-    assertMinCoverResult(7,
+    assertMinCoverResult(7.0,
                          true,
                          std::numeric_limits<double>::infinity(),
                          true,
-                         0,
-                         32,
+                         0.0,
+                         32.0,
                          1,
-                         {"000111", "001", "01", "100000"});
-    assertMinCoverResult(0,
+                         {
+                             "11000000000111",
+                             "11000000001",
+                             "1100000001000000000000000000000000000000000000000000000000000000",
+                         });
+    assertMinCoverResult(0.0,
                          true,
-                         8,
+                         8.0,
                          true,
-                         0,
-                         32,
+                         0.0,
+                         32.0,
                          1,
                          {
-                             "000",
-                             "001000",
+                             "10",
+                             "11000000000",
+                             "1100000000100000000000000000000000000000000000000000000000000000",
                          });
     assertMinCoverResult(-std::numeric_limits<double>::infinity(),
                          true,
-                         8,
+                         8.0,
                          true,
-                         0,
-                         32,
+                         0.0,
+                         32.0,
                          1,
                          {
-                             "000",
-                             "001000",
+                             "10",
+                             "11000000000",
+                             "1100000000100000000000000000000000000000000000000000000000000000",
                          });
 }
 
@@ -3513,6 +3792,31 @@ TEST(MinCoverInteraceTest, InvalidBounds) {
         assertMinCoverResult(0, true, 0, false, 0, 7, 1, {}), AssertionException, 6901317);
 }
 
+// Test point queries and that trimming bitstrings is correct in precision mode
+TEST(MinCoverInteraceTest, Precision_Equal) {
+    assertMinCoverResultPrecision(3.14159, true, 3.14159, true, 0.0, 10.0, 1, 2, {"00100111010"});
+    assertMinCoverResultPrecision(Decimal128(3.14159),
+                                  true,
+                                  Decimal128(3.14159),
+                                  true,
+                                  Decimal128(0.0),
+                                  Decimal128(10.0),
+                                  1,
+                                  2,
+                                  {"00100111010"});
+
+    assertMinCoverResultPrecision(3.1, true, 3.1, true, 0.0, 12.0, 1, 1, {"00011111"});
+    assertMinCoverResultPrecision(Decimal128(3.1),
+                                  true,
+                                  Decimal128(3.1),
+                                  true,
+                                  Decimal128(0.0),
+                                  Decimal128(12.0),
+                                  1,
+                                  1,
+                                  {"00011111"});
+}
+
 DEATH_TEST_REGEX(MinCoverInterfaceTest, Error_MinMaxTypeMismatch, "Tripwire assertion.*6901300") {
     std::vector<BSONElement> elems;
     auto vals = BSON_ARRAY(10 << 11 << 4 << 11.5);
diff --git a/src/mongo/crypto/fle_crypto_test_vectors.cpp b/src/mongo/crypto/fle_crypto_test_vectors.cpp
index ce05c8ab97a..448da457457 100644
--- a/src/mongo/crypto/fle_crypto_test_vectors.cpp
+++ b/src/mongo/crypto/fle_crypto_test_vectors.cpp
@@ -138,6 +138,14 @@ TEST(EdgeCalcTest, Int64_TestVectors) {
     }
 }
 
+std::unique_ptr<Edges> getEdgesDoubleForTest(double value,
+                                             boost::optional<double> min,
+                                             boost::optional<double> max,
+                                             int sparsity) {
+    // The non-precision test vectors set min/max which is not allowed
+    return getEdgesDouble(value, boost::none, boost::none, boost::none, sparsity);
+}
+
 TEST(EdgeCalcTest, Double_TestVectors) {
     std::vector<EdgeCalcTestVector<double>> testVectors = {
 #include "test_vectors/edges_double.cstruct"
@@ -148,6 +156,16 @@ TEST(EdgeCalcTest, Double_TestVectors) {
 }
 
 
+std::unique_ptr<Edges> getEdgesDecimal128ForTest(Decimal128 value,
+                                                 boost::optional<Decimal128> min,
+                                                 boost::optional<Decimal128> max,
+                                                 int sparsity) {
+
+    // The non-precision test vectors set min/max which is not allowed
+    return getEdgesDecimal128(value, boost::none, boost::none, boost::none, sparsity);
+}
+
+
 TEST(EdgeCalcTest, Decimal128_TestVectors) {
     std::vector<EdgeCalcTestVector<Decimal128>> testVectors = {
 #include "test_vectors/edges_decimal128.cstruct"
@@ -213,24 +231,118 @@ TEST(MinCoverCalcTest, Int64_TestVectors) {
     }
 }
 
+std::vector<std::string> minCoverDoubleForTest(double lowerBound,
+                                               bool includeLowerBound,
+                                               double upperBound,
+                                               bool includeUpperBound,
+                                               boost::optional<double> min,
+                                               boost::optional<double> max,
+                                               int sparsity) {
+    // The non-precision test vectors set min/max which is not allowed
+    return minCoverDouble(lowerBound,
+                          includeLowerBound,
+                          upperBound,
+                          includeUpperBound,
+                          boost::none,
+                          boost::none,
+                          boost::none,
+                          sparsity);
+}
+
 TEST(MinCoverCalcTest, Double_TestVectors) {
     MinCoverTestVector<double> testVectors[] = {
 #include "test_vectors/mincover_double.cstruct"
     };
     for (const auto& testVector : testVectors) {
-        ASSERT_TRUE(testVector.validate(minCoverDouble));
+        ASSERT_TRUE(testVector.validate(minCoverDoubleForTest));
     }
 }
 
+std::vector<std::string> minCoverDecimal128ForTest(Decimal128 lowerBound,
+                                                   bool includeLowerBound,
+                                                   Decimal128 upperBound,
+                                                   bool includeUpperBound,
+                                                   boost::optional<Decimal128> min,
+                                                   boost::optional<Decimal128> max,
+                                                   int sparsity) {
+
+    // The non-precision test vectors set min/max which is not allowed
+    return minCoverDecimal128(lowerBound,
+                              includeLowerBound,
+                              upperBound,
+                              includeUpperBound,
+                              boost::none,
+                              boost::none,
+                              boost::none,
+                              sparsity);
+}
+
+
 TEST(MinCoverCalcTest, Decimal128_TestVectors) {
     MinCoverTestVector<Decimal128> testVectors[] = {
 #include "test_vectors/mincover_decimal128.cstruct"
     };
     for (const auto& testVector : testVectors) {
-        ASSERT_TRUE(testVector.validate(minCoverDecimal128));
+        ASSERT_TRUE(testVector.validate(minCoverDecimal128ForTest));
     }
 }
 
 #pragma clang optimize on
 
+
+template <typename T>
+struct MinCoverTestVectorPrecision {
+    T rangeMin, rangeMax;
+    T min, max;
+    int sparsity;
+    uint32_t precision;
+    std::string expect;
+
+    bool validate(
+        std::function<std::vector<std::string>(
+            T, bool, T, bool, boost::optional<T>, boost::optional<T>, uint32_t, int)> algo) const {
+        auto result = algo(rangeMin, true, rangeMax, true, min, max, precision, sparsity);
+
+        std::stringstream ss(expect);
+        std::vector<std::string> vexpect;
+        std::string item;
+        while (std::getline(ss, item, '\n') && !item.empty()) {
+            vexpect.push_back(std::move(item));
+        }
+
+        if (std::equal(result.begin(), result.end(), vexpect.begin())) {
+            return true;
+        }
+
+        LOGV2_ERROR(6966809,
+                    "MinCover algorithm produced unexpected result",
+                    "rangeMin"_attr = rangeMin,
+                    "rangeMax"_attr = rangeMax,
+                    "min"_attr = min,
+                    "max"_attr = max,
+                    "sparsity"_attr = sparsity,
+                    "precision"_attr = precision,
+                    "expect"_attr = expect,
+                    "got"_attr = result);
+        return false;
+    }
+};
+
+TEST(MinCoverCalcPrecisionTest, Double_TestVectors) {
+    MinCoverTestVectorPrecision<double> testVectors[] = {
+#include "test_vectors/mincover_double_precision.cstruct"
+    };
+    for (const auto& testVector : testVectors) {
+        ASSERT_TRUE(testVector.validate(minCoverDouble));
+    }
+}
+
+TEST(MinCoverCalcPrecisionTest, Decimal128_TestVectors) {
+    MinCoverTestVectorPrecision<Decimal128> testVectors[] = {
+#include "test_vectors/mincover_decimal128_precision.cstruct"
+    };
+    for (const auto& testVector : testVectors) {
+        ASSERT_TRUE(testVector.validate(minCoverDecimal128));
+    }
+}
 }  // namespace mongo
diff --git a/src/mongo/crypto/fle_fields_util.cpp b/src/mongo/crypto/fle_fields_util.cpp
index 02653266b8a..94e6f107ef0 100644
--- a/src/mongo/crypto/fle_fields_util.cpp
+++ b/src/mongo/crypto/fle_fields_util.cpp
@@ -156,5 +156,5 @@ void validateIDLFLE2RangeFindSpec(const FLE2RangeFindSpec* placeholder) {
     auto lb = edgesInfo.getLowerBound().getElement();
     auto ub = edgesInfo.getUpperBound().getElement();
     validateQueryBounds(min.type(), lb, ub);
-}  // namespace mongo
+}
 }  // namespace mongo
diff --git a/src/mongo/crypto/test_vectors/edges_decimal128.cstruct b/src/mongo/crypto/test_vectors/edges_decimal128.cstruct
index a7d8130eaff..46d99cc33da 100644
--- a/src/mongo/crypto/test_vectors/edges_decimal128.cstruct
+++ b/src/mongo/crypto/test_vectors/edges_decimal128.cstruct
@@ -1,4 +1,4 @@
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 1, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 1, {
             "1",
             "10",
             "100",
@@ -129,7 +129,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 2, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 2, {
             "10",
             "1000",
             "100000",
@@ -196,7 +196,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 3, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 3, {
             "100",
             "100000",
             "100000000",
@@ -242,7 +242,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 4, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 4, {
             "1000",
             "10000000",
             "100000000000",
@@ -277,7 +277,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 8, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 8, {
             "10000000",
             "1000000000000000",
             "100000000000000000000000",
@@ -296,7 +296,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 10, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 10, {
             "1000000000",
             "10000000000000000000",
             "100000000000000000000000000000",
@@ -312,7 +312,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 11, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 11, {
             "10000000000",
             "1000000000000000000000",
             "100000000000000000000000000000000",
@@ -327,7 +327,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 16, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 16, {
             "1000000000000000",
             "10000000000000000000000000000000",
             "100000000000000000000000000000000000000000000000",
@@ -338,7 +338,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 31, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 31, {
             "1000000000000000000000000000000",
             "10000000000000000000000000000000000000000000000000000000000000",
             "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
@@ -346,14 +346,14 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 32, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128(12.3400000000000), 32, {
             "10000000000000000000000000000000",
             "1000000000000000000000000000000000000000000000000000000000000000",
             "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 1, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 1, {
             "1",
             "10",
             "100",
@@ -484,7 +484,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 2, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 2, {
             "10",
             "1000",
             "100000",
@@ -551,7 +551,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 3, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 3, {
             "100",
             "100000",
             "100000000",
@@ -597,7 +597,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 4, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 4, {
             "1000",
             "10000000",
             "100000000000",
@@ -632,7 +632,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 8, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 8, {
             "10000000",
             "1000000000000000",
             "100000000000000000000000",
@@ -651,7 +651,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 10, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 10, {
             "1000000000",
             "10000000000000000000",
             "100000000000000000000000000000",
@@ -667,7 +667,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 11, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 11, {
             "10000000000",
             "1000000000000000000000",
             "100000000000000000000000000000000",
@@ -682,7 +682,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 16, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 16, {
             "1000000000000000",
             "10000000000000000000000000000000",
             "100000000000000000000000000000000000000000000000",
@@ -693,7 +693,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 31, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 31, {
             "1000000000000000000000000000000",
             "10000000000000000000000000000000000000000000000000000000000000",
             "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
@@ -701,14 +701,14 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 32, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 32, {
             "10000000000000000000000000000000",
             "1000000000000000000000000000000000000000000000000000000000000000",
             "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 1, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 1, {
             "1",
             "10",
             "100",
@@ -839,7 +839,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 2, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 2, {
             "10",
             "1000",
             "100000",
@@ -906,7 +906,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 3, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 3, {
             "100",
             "100000",
             "100000000",
@@ -952,7 +952,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 4, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 4, {
             "1000",
             "10000000",
             "100000000000",
@@ -987,7 +987,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 8, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 8, {
             "10000000",
             "1000000000000000",
             "100000000000000000000000",
@@ -1006,7 +1006,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 10, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 10, {
             "1000000000",
             "10000000000000000000",
             "100000000000000000000000000000",
@@ -1022,7 +1022,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 11, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 11, {
             "10000000000",
             "1000000000000000000000",
             "100000000000000000000000000000000",
@@ -1037,7 +1037,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 16, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 16, {
             "1000000000000000",
             "10000000000000000000000000000000",
             "100000000000000000000000000000000000000000000000",
@@ -1048,7 +1048,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 31, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 31, {
             "1000000000000000000000000000000",
             "10000000000000000000000000000000000000000000000000000000000000",
             "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
@@ -1056,14 +1056,14 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 32, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 32, {
             "10000000000000000000000000000000",
             "1000000000000000000000000000000000000000000000000000000000000000",
             "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 1, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 1, {
             "1",
             "10",
             "100",
@@ -1194,7 +1194,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 2, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 2, {
             "10",
             "1000",
             "100000",
@@ -1261,7 +1261,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 3, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 3, {
             "100",
             "100000",
             "100000000",
@@ -1307,7 +1307,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 4, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 4, {
             "1000",
             "10000000",
             "100000000000",
@@ -1342,7 +1342,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 8, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 8, {
             "10000000",
             "1000000000000000",
             "100000000000000000000000",
@@ -1361,7 +1361,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 10, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 10, {
             "1000000000",
             "10000000000000000000",
             "100000000000000000000000000000",
@@ -1377,7 +1377,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 11, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 11, {
             "10000000000",
             "1000000000000000000000",
             "100000000000000000000000000000000",
@@ -1392,7 +1392,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 16, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 16, {
             "1000000000000000",
             "10000000000000000000000000000000",
             "100000000000000000000000000000000000000000000000",
@@ -1403,7 +1403,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 31, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 31, {
             "1000000000000000000000000000000",
             "10000000000000000000000000000000000000000000000000000000000000",
             "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
@@ -1411,14 +1411,14 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 32, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(0), Decimal128::kLargestPositive, 32, {
             "10000000000000000000000000000000",
             "1000000000000000000000000000000000000000000000000000000000000000",
             "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 1, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 1, {
             "1",
             "10",
             "100",
@@ -1549,7 +1549,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 2, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 2, {
             "10",
             "1000",
             "100000",
@@ -1616,7 +1616,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 3, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 3, {
             "100",
             "100000",
             "100000000",
@@ -1662,7 +1662,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 4, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 4, {
             "1000",
             "10000000",
             "100000000000",
@@ -1697,7 +1697,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 8, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 8, {
             "10000000",
             "1000000000000000",
             "100000000000000000000000",
@@ -1716,7 +1716,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 10, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 10, {
             "1000000000",
             "10000000000000000000",
             "100000000000000000000000000000",
@@ -1732,7 +1732,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 11, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 11, {
             "10000000000",
             "1000000000000000000000",
             "100000000000000000000000000000000",
@@ -1747,7 +1747,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 16, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 16, {
             "1000000000000000",
             "10000000000000000000000000000000",
             "100000000000000000000000000000000000000000000000",
@@ -1758,7 +1758,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 31, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 31, {
             "1000000000000000000000000000000",
             "10000000000000000000000000000000000000000000000000000000000000",
             "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
@@ -1766,14 +1766,14 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 32, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 32, {
             "10000000000000000000000000000000",
             "1000000000000000000000000000000000000000000000000000000000000000",
             "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 1, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 1, {
             "1",
             "10",
             "100",
@@ -1904,7 +1904,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 2, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 2, {
             "10",
             "1000",
             "100000",
@@ -1971,7 +1971,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 3, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 3, {
             "100",
             "100000",
             "100000000",
@@ -2017,7 +2017,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 4, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 4, {
             "1000",
             "10000000",
             "100000000000",
@@ -2052,7 +2052,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 8, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 8, {
             "10000000",
             "1000000000000000",
             "100000000000000000000000",
@@ -2071,7 +2071,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 10, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 10, {
             "1000000000",
             "10000000000000000000",
             "100000000000000000000000000000",
@@ -2087,7 +2087,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 11, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 11, {
             "10000000000",
             "1000000000000000000000",
             "100000000000000000000000000000000",
@@ -2102,7 +2102,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 16, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 16, {
             "1000000000000000",
             "10000000000000000000000000000000",
             "100000000000000000000000000000000000000000000000",
@@ -2113,7 +2113,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 31, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 31, {
             "1000000000000000000000000000000",
             "10000000000000000000000000000000000000000000000000000000000000",
             "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
@@ -2121,14 +2121,14 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 32, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 32, {
             "10000000000000000000000000000000",
             "1000000000000000000000000000000000000000000000000000000000000000",
             "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 1, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 1, {
             "1",
             "10",
             "100",
@@ -2259,7 +2259,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 2, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 2, {
             "10",
             "1000",
             "100000",
@@ -2326,7 +2326,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 3, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 3, {
             "100",
             "100000",
             "100000000",
@@ -2372,7 +2372,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 4, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 4, {
             "1000",
             "10000000",
             "100000000000",
@@ -2407,7 +2407,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 8, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 8, {
             "10000000",
             "1000000000000000",
             "100000000000000000000000",
@@ -2426,7 +2426,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 10, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 10, {
             "1000000000",
             "10000000000000000000",
             "100000000000000000000000000000",
@@ -2442,7 +2442,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 11, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 11, {
             "10000000000",
             "1000000000000000000000",
             "100000000000000000000000000000000",
@@ -2457,7 +2457,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 16, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 16, {
             "1000000000000000",
             "10000000000000000000000000000000",
             "100000000000000000000000000000000000000000000000",
@@ -2468,7 +2468,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 31, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 31, {
             "1000000000000000000000000000000",
             "10000000000000000000000000000000000000000000000000000000000000",
             "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
@@ -2476,14 +2476,14 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 32, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 32, {
             "10000000000000000000000000000000",
             "1000000000000000000000000000000000000000000000000000000000000000",
             "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 1, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 1, {
             "1",
             "10",
             "100",
@@ -2614,7 +2614,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 2, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 2, {
             "10",
             "1000",
             "100000",
@@ -2681,7 +2681,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 3, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 3, {
             "100",
             "100000",
             "100000000",
@@ -2727,7 +2727,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 4, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 4, {
             "1000",
             "10000000",
             "100000000000",
@@ -2762,7 +2762,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 8, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 8, {
             "10000000",
             "1000000000000000",
             "100000000000000000000000",
@@ -2781,7 +2781,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 10, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 10, {
             "1000000000",
             "10000000000000000000",
             "100000000000000000000000000000",
@@ -2797,7 +2797,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 11, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 11, {
             "10000000000",
             "1000000000000000000000",
             "100000000000000000000000000000000",
@@ -2812,7 +2812,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 16, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 16, {
             "1000000000000000",
             "10000000000000000000000000000000",
             "100000000000000000000000000000000000000000000000",
@@ -2823,7 +2823,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 31, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 31, {
             "1000000000000000000000000000000",
             "10000000000000000000000000000000000000000000000000000000000000",
             "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
@@ -2831,14 +2831,14 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 32, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 32, {
             "10000000000000000000000000000000",
             "1000000000000000000000000000000000000000000000000000000000000000",
             "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 1, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 1, {
             "1",
             "10",
             "100",
@@ -2969,7 +2969,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 2, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 2, {
             "10",
             "1000",
             "100000",
@@ -3036,7 +3036,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 3, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 3, {
             "100",
             "100000",
             "100000000",
@@ -3082,7 +3082,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 4, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 4, {
             "1000",
             "10000000",
             "100000000000",
@@ -3117,7 +3117,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 8, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 8, {
             "10000000",
             "1000000000000000",
             "100000000000000000000000",
@@ -3136,7 +3136,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 10, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 10, {
             "1000000000",
             "10000000000000000000",
             "100000000000000000000000000000",
@@ -3152,7 +3152,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 11, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 11, {
             "10000000000",
             "1000000000000000000000",
             "100000000000000000000000000000000",
@@ -3167,7 +3167,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 16, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 16, {
             "1000000000000000",
             "10000000000000000000000000000000",
             "100000000000000000000000000000000000000000000000",
@@ -3178,7 +3178,7 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 31, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 31, {
             "1000000000000000000000000000000",
             "10000000000000000000000000000000000000000000000000000000000000",
             "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
@@ -3186,14 +3186,14 @@
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(0), boost::none, boost::none, 32, {
+        {&getEdgesDecimal128ForTest, Decimal128(0), boost::none, boost::none, 32, {
             "10000000000000000000000000000000",
             "1000000000000000000000000000000000000000000000000000000000000000",
             "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 1, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 1, {
             "0",
             "01",
             "010",
@@ -3324,7 +3324,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 2, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 2, {
             "01",
             "0101",
             "010100",
@@ -3391,7 +3391,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 3, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 3, {
             "010",
             "010100",
             "010100011",
@@ -3437,7 +3437,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 4, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 4, {
             "0101",
             "01010001",
             "010100011100",
@@ -3472,7 +3472,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 8, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 8, {
             "01010001",
             "0101000111001101",
             "010100011100110101110001",
@@ -3491,7 +3491,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 10, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 10, {
             "0101000111",
             "01010001110011010111",
             "010100011100110101110001001001",
@@ -3507,7 +3507,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 11, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 11, {
             "01010001110",
             "0101000111001101011100",
             "010100011100110101110001001001100",
@@ -3522,7 +3522,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 16, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 16, {
             "0101000111001101",
             "01010001110011010111000100100110",
             "010100011100110101110001001001100100101000011100",
@@ -3533,7 +3533,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 31, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 31, {
             "0101000111001101011100010010011",
             "01010001110011010111000100100110010010100001110000111010110001",
             "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001",
@@ -3541,14 +3541,14 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 32, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128(12.3400000000000), 32, {
             "01010001110011010111000100100110",
             "0101000111001101011100010010011001001010000111000011101011000101",
             "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010",
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 1, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 1, {
             "0",
             "01",
             "010",
@@ -3679,7 +3679,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 2, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 2, {
             "01",
             "0101",
             "010100",
@@ -3746,7 +3746,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 3, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 3, {
             "010",
             "010100",
             "010100011",
@@ -3792,7 +3792,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 4, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 4, {
             "0101",
             "01010001",
             "010100011100",
@@ -3827,7 +3827,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 8, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 8, {
             "01010001",
             "0101000111001101",
             "010100011100110101110001",
@@ -3846,7 +3846,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 10, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 10, {
             "0101000111",
             "01010001110011010111",
             "010100011100110101110001001001",
@@ -3862,7 +3862,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 11, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 11, {
             "01010001110",
             "0101000111001101011100",
             "010100011100110101110001001001100",
@@ -3877,7 +3877,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 16, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 16, {
             "0101000111001101",
             "01010001110011010111000100100110",
             "010100011100110101110001001001100100101000011100",
@@ -3888,7 +3888,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 31, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 31, {
             "0101000111001101011100010010011",
             "01010001110011010111000100100110010010100001110000111010110001",
             "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001",
@@ -3896,14 +3896,14 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 32, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128(12.3400000000000), 32, {
             "01010001110011010111000100100110",
             "0101000111001101011100010010011001001010000111000011101011000101",
             "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010",
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 1, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 1, {
             "0",
             "01",
             "010",
@@ -4034,7 +4034,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 2, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 2, {
             "01",
             "0101",
             "010100",
@@ -4101,7 +4101,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 3, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 3, {
             "010",
             "010100",
             "010100011",
@@ -4147,7 +4147,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 4, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 4, {
             "0101",
             "01010001",
             "010100011100",
@@ -4182,7 +4182,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 8, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 8, {
             "01010001",
             "0101000111001101",
             "010100011100110101110001",
@@ -4201,7 +4201,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 10, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 10, {
             "0101000111",
             "01010001110011010111",
             "010100011100110101110001001001",
@@ -4217,7 +4217,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 11, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 11, {
             "01010001110",
             "0101000111001101011100",
             "010100011100110101110001001001100",
@@ -4232,7 +4232,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 16, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 16, {
             "0101000111001101",
             "01010001110011010111000100100110",
             "010100011100110101110001001001100100101000011100",
@@ -4243,7 +4243,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 31, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 31, {
             "0101000111001101011100010010011",
             "01010001110011010111000100100110010010100001110000111010110001",
             "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001",
@@ -4251,14 +4251,14 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 32, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 32, {
             "01010001110011010111000100100110",
             "0101000111001101011100010010011001001010000111000011101011000101",
             "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010",
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 1, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 1, {
             "0",
             "01",
             "010",
@@ -4389,7 +4389,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 2, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 2, {
             "01",
             "0101",
             "010100",
@@ -4456,7 +4456,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 3, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 3, {
             "010",
             "010100",
             "010100011",
@@ -4502,7 +4502,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 4, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 4, {
             "0101",
             "01010001",
             "010100011100",
@@ -4537,7 +4537,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 8, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 8, {
             "01010001",
             "0101000111001101",
             "010100011100110101110001",
@@ -4556,7 +4556,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 10, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 10, {
             "0101000111",
             "01010001110011010111",
             "010100011100110101110001001001",
@@ -4572,7 +4572,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 11, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 11, {
             "01010001110",
             "0101000111001101011100",
             "010100011100110101110001001001100",
@@ -4587,7 +4587,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 16, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 16, {
             "0101000111001101",
             "01010001110011010111000100100110",
             "010100011100110101110001001001100100101000011100",
@@ -4598,7 +4598,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 31, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 31, {
             "0101000111001101011100010010011",
             "01010001110011010111000100100110010010100001110000111010110001",
             "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001",
@@ -4606,14 +4606,14 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 32, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 32, {
             "01010001110011010111000100100110",
             "0101000111001101011100010010011001001010000111000011101011000101",
             "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010",
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 1, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 1, {
             "0",
             "01",
             "010",
@@ -4744,7 +4744,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 2, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 2, {
             "01",
             "0101",
             "010100",
@@ -4811,7 +4811,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 3, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 3, {
             "010",
             "010100",
             "010100011",
@@ -4857,7 +4857,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 4, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 4, {
             "0101",
             "01010001",
             "010100011100",
@@ -4892,7 +4892,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 8, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 8, {
             "01010001",
             "0101000111001101",
             "010100011100110101110001",
@@ -4911,7 +4911,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 10, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 10, {
             "0101000111",
             "01010001110011010111",
             "010100011100110101110001001001",
@@ -4927,7 +4927,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 11, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 11, {
             "01010001110",
             "0101000111001101011100",
             "010100011100110101110001001001100",
@@ -4942,7 +4942,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 16, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 16, {
             "0101000111001101",
             "01010001110011010111000100100110",
             "010100011100110101110001001001100100101000011100",
@@ -4953,7 +4953,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 31, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 31, {
             "0101000111001101011100010010011",
             "01010001110011010111000100100110010010100001110000111010110001",
             "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001",
@@ -4961,14 +4961,14 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 32, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 32, {
             "01010001110011010111000100100110",
             "0101000111001101011100010010011001001010000111000011101011000101",
             "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010",
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 1, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 1, {
             "0",
             "01",
             "010",
@@ -5099,7 +5099,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 2, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 2, {
             "01",
             "0101",
             "010100",
@@ -5166,7 +5166,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 3, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 3, {
             "010",
             "010100",
             "010100011",
@@ -5212,7 +5212,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 4, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 4, {
             "0101",
             "01010001",
             "010100011100",
@@ -5247,7 +5247,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 8, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 8, {
             "01010001",
             "0101000111001101",
             "010100011100110101110001",
@@ -5266,7 +5266,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 10, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 10, {
             "0101000111",
             "01010001110011010111",
             "010100011100110101110001001001",
@@ -5282,7 +5282,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 11, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 11, {
             "01010001110",
             "0101000111001101011100",
             "010100011100110101110001001001100",
@@ -5297,7 +5297,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 16, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 16, {
             "0101000111001101",
             "01010001110011010111000100100110",
             "010100011100110101110001001001100100101000011100",
@@ -5308,7 +5308,7 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 31, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 31, {
             "0101000111001101011100010010011",
             "01010001110011010111000100100110010010100001110000111010110001",
             "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001",
@@ -5316,14 +5316,14 @@
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(-0.00700000000000000), boost::none, boost::none, 32, {
+        {&getEdgesDecimal128ForTest, Decimal128(-0.00700000000000000), boost::none, boost::none, 32, {
             "01010001110011010111000100100110",
             "0101000111001101011100010010011001001010000111000011101011000101",
             "010100011100110101110001001001100100101000011100001110101100010100001011100100110101110001001010",
             "01010001110011010111000100100110010010100001110000111010110001010000101110010011010111000100101000000000000000000001011111111100",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 1, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 1, {
             "1",
             "10",
             "101",
@@ -5454,7 +5454,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 2, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 2, {
             "10",
             "1010",
             "101011",
@@ -5521,7 +5521,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 3, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 3, {
             "101",
             "101011",
             "101011100",
@@ -5567,7 +5567,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 4, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 4, {
             "1010",
             "10101110",
             "101011100011",
@@ -5602,7 +5602,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 8, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 8, {
             "10101110",
             "1010111000111001",
             "101011100011100110001011",
@@ -5621,7 +5621,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 10, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 10, {
             "1010111000",
             "10101110001110011000",
             "101011100011100110001011011110",
@@ -5637,7 +5637,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 11, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 11, {
             "10101110001",
             "1010111000111001100010",
             "101011100011100110001011011110101",
@@ -5652,7 +5652,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 16, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 16, {
             "1010111000111001",
             "10101110001110011000101101111010",
             "101011100011100110001011011110101010100010011111",
@@ -5663,7 +5663,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 31, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 31, {
             "1010111000111001100010110111101",
             "10101110001110011000101101111010101010001001111111001001000100",
             "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011",
@@ -5671,14 +5671,14 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 32, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0), Decimal128::kLargestPositive, 32, {
             "10101110001110011000101101111010",
             "1010111000111001100010110111101010101000100111111100100100010000",
             "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111",
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 1, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 1, {
             "1",
             "10",
             "101",
@@ -5809,7 +5809,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 2, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 2, {
             "10",
             "1010",
             "101011",
@@ -5876,7 +5876,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 3, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 3, {
             "101",
             "101011",
             "101011100",
@@ -5922,7 +5922,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 4, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 4, {
             "1010",
             "10101110",
             "101011100011",
@@ -5957,7 +5957,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 8, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 8, {
             "10101110",
             "1010111000111001",
             "101011100011100110001011",
@@ -5976,7 +5976,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 10, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 10, {
             "1010111000",
             "10101110001110011000",
             "101011100011100110001011011110",
@@ -5992,7 +5992,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 11, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 11, {
             "10101110001",
             "1010111000111001100010",
             "101011100011100110001011011110101",
@@ -6007,7 +6007,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 16, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 16, {
             "1010111000111001",
             "10101110001110011000101101111010",
             "101011100011100110001011011110101010100010011111",
@@ -6018,7 +6018,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 31, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 31, {
             "1010111000111001100010110111101",
             "10101110001110011000101101111010101010001001111111001001000100",
             "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011",
@@ -6026,14 +6026,14 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 32, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(0.123400000000000), Decimal128::kLargestPositive, 32, {
             "10101110001110011000101101111010",
             "1010111000111001100010110111101010101000100111111100100100010000",
             "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111",
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 1, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 1, {
             "1",
             "10",
             "101",
@@ -6164,7 +6164,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 2, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 2, {
             "10",
             "1010",
             "101011",
@@ -6231,7 +6231,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 3, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 3, {
             "101",
             "101011",
             "101011100",
@@ -6277,7 +6277,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 4, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 4, {
             "1010",
             "10101110",
             "101011100011",
@@ -6312,7 +6312,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 8, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 8, {
             "10101110",
             "1010111000111001",
             "101011100011100110001011",
@@ -6331,7 +6331,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 10, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 10, {
             "1010111000",
             "10101110001110011000",
             "101011100011100110001011011110",
@@ -6347,7 +6347,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 11, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 11, {
             "10101110001",
             "1010111000111001100010",
             "101011100011100110001011011110101",
@@ -6362,7 +6362,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 16, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 16, {
             "1010111000111001",
             "10101110001110011000101101111010",
             "101011100011100110001011011110101010100010011111",
@@ -6373,7 +6373,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 31, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 31, {
             "1010111000111001100010110111101",
             "10101110001110011000101101111010101010001001111111001001000100",
             "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011",
@@ -6381,14 +6381,14 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 32, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 32, {
             "10101110001110011000101101111010",
             "1010111000111001100010110111101010101000100111111100100100010000",
             "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111",
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 1, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 1, {
             "1",
             "10",
             "101",
@@ -6519,7 +6519,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 2, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 2, {
             "10",
             "1010",
             "101011",
@@ -6586,7 +6586,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 3, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 3, {
             "101",
             "101011",
             "101011100",
@@ -6632,7 +6632,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 4, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 4, {
             "1010",
             "10101110",
             "101011100011",
@@ -6667,7 +6667,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 8, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 8, {
             "10101110",
             "1010111000111001",
             "101011100011100110001011",
@@ -6686,7 +6686,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 10, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 10, {
             "1010111000",
             "10101110001110011000",
             "101011100011100110001011011110",
@@ -6702,7 +6702,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 11, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 11, {
             "10101110001",
             "1010111000111001100010",
             "101011100011100110001011011110101",
@@ -6717,7 +6717,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 16, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 16, {
             "1010111000111001",
             "10101110001110011000101101111010",
             "101011100011100110001011011110101010100010011111",
@@ -6728,7 +6728,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 31, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 31, {
             "1010111000111001100010110111101",
             "10101110001110011000101101111010101010001001111111001001000100",
             "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011",
@@ -6736,14 +6736,14 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 32, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), Decimal128::kLargestNegative, Decimal128::kLargestPositive, 32, {
             "10101110001110011000101101111010",
             "1010111000111001100010110111101010101000100111111100100100010000",
             "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111",
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 1, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 1, {
             "1",
             "10",
             "101",
@@ -6874,7 +6874,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 2, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 2, {
             "10",
             "1010",
             "101011",
@@ -6941,7 +6941,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 3, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 3, {
             "101",
             "101011",
             "101011100",
@@ -6987,7 +6987,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 4, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 4, {
             "1010",
             "10101110",
             "101011100011",
@@ -7022,7 +7022,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 8, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 8, {
             "10101110",
             "1010111000111001",
             "101011100011100110001011",
@@ -7041,7 +7041,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 10, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 10, {
             "1010111000",
             "10101110001110011000",
             "101011100011100110001011011110",
@@ -7057,7 +7057,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 11, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 11, {
             "10101110001",
             "1010111000111001100010",
             "101011100011100110001011011110101",
@@ -7072,7 +7072,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 16, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 16, {
             "1010111000111001",
             "10101110001110011000101101111010",
             "101011100011100110001011011110101010100010011111",
@@ -7083,7 +7083,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 31, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 31, {
             "1010111000111001100010110111101",
             "10101110001110011000101101111010101010001001111111001001000100",
             "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011",
@@ -7091,14 +7091,14 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 32, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 32, {
             "10101110001110011000101101111010",
             "1010111000111001100010110111101010101000100111111100100100010000",
             "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111",
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 1, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 1, {
             "1",
             "10",
             "101",
@@ -7229,7 +7229,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 2, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 2, {
             "10",
             "1010",
             "101011",
@@ -7296,7 +7296,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 3, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 3, {
             "101",
             "101011",
             "101011100",
@@ -7342,7 +7342,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 4, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 4, {
             "1010",
             "10101110",
             "101011100011",
@@ -7377,7 +7377,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 8, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 8, {
             "10101110",
             "1010111000111001",
             "101011100011100110001011",
@@ -7396,7 +7396,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 10, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 10, {
             "1010111000",
             "10101110001110011000",
             "101011100011100110001011011110",
@@ -7412,7 +7412,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 11, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 11, {
             "10101110001",
             "1010111000111001100010",
             "101011100011100110001011011110101",
@@ -7427,7 +7427,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 16, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 16, {
             "1010111000111001",
             "10101110001110011000101101111010",
             "101011100011100110001011011110101010100010011111",
@@ -7438,7 +7438,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 31, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 31, {
             "1010111000111001100010110111101",
             "10101110001110011000101101111010101010001001111111001001000100",
             "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011",
@@ -7446,14 +7446,14 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 32, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 32, {
             "10101110001110011000101101111010",
             "1010111000111001100010110111101010101000100111111100100100010000",
             "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111",
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 1, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 1, {
             "1",
             "10",
             "101",
@@ -7584,7 +7584,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 2, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 2, {
             "10",
             "1010",
             "101011",
@@ -7651,7 +7651,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 3, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 3, {
             "101",
             "101011",
             "101011100",
@@ -7697,7 +7697,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 4, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 4, {
             "1010",
             "10101110",
             "101011100011",
@@ -7732,7 +7732,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 8, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 8, {
             "10101110",
             "1010111000111001",
             "101011100011100110001011",
@@ -7751,7 +7751,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 10, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 10, {
             "1010111000",
             "10101110001110011000",
             "101011100011100110001011011110",
@@ -7767,7 +7767,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 11, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 11, {
             "10101110001",
             "1010111000111001100010",
             "101011100011100110001011011110101",
@@ -7782,7 +7782,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 16, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 16, {
             "1010111000111001",
             "10101110001110011000101101111010",
             "101011100011100110001011011110101010100010011111",
@@ -7793,7 +7793,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 31, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 31, {
             "1010111000111001100010110111101",
             "10101110001110011000101101111010101010001001111111001001000100",
             "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011",
@@ -7801,14 +7801,14 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 32, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 32, {
             "10101110001110011000101101111010",
             "1010111000111001100010110111101010101000100111111100100100010000",
             "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111",
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 1, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 1, {
             "1",
             "10",
             "101",
@@ -7939,7 +7939,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 2, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 2, {
             "10",
             "1010",
             "101011",
@@ -8006,7 +8006,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 3, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 3, {
             "101",
             "101011",
             "101011100",
@@ -8052,7 +8052,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 4, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 4, {
             "1010",
             "10101110",
             "101011100011",
@@ -8087,7 +8087,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 8, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 8, {
             "10101110",
             "1010111000111001",
             "101011100011100110001011",
@@ -8106,7 +8106,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 10, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 10, {
             "1010111000",
             "10101110001110011000",
             "101011100011100110001011011110",
@@ -8122,7 +8122,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 11, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 11, {
             "10101110001",
             "1010111000111001100010",
             "101011100011100110001011011110101",
@@ -8137,7 +8137,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 16, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 16, {
             "1010111000111001",
             "10101110001110011000101101111010",
             "101011100011100110001011011110101010100010011111",
@@ -8148,7 +8148,7 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 31, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 31, {
             "1010111000111001100010110111101",
             "10101110001110011000101101111010101010001001111111001001000100",
             "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011",
@@ -8156,14 +8156,14 @@
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128(32.7770000000000), boost::none, boost::none, 32, {
+        {&getEdgesDecimal128ForTest, Decimal128(32.7770000000000), boost::none, boost::none, 32, {
             "10101110001110011000101101111010",
             "1010111000111001100010110111101010101000100111111100100100010000",
             "101011100011100110001011011110101010100010011111110010010001000000101010010000011000011000011111",
             "10101110001110011000101101111010101010001001111111001001000100000010101001000001100001100001111110011111111111111110100000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 1, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 1, {
             "1",
             "11",
             "110",
@@ -8294,7 +8294,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 2, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 2, {
             "11",
             "1101",
             "110111",
@@ -8361,7 +8361,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 3, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 3, {
             "110",
             "110111",
             "110111000",
@@ -8407,7 +8407,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 4, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 4, {
             "1101",
             "11011100",
             "110111000111",
@@ -8442,7 +8442,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 8, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 8, {
             "11011100",
             "1101110001110001",
             "110111000111000111010011",
@@ -8461,7 +8461,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 10, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 10, {
             "1101110001",
             "11011100011100011101",
             "110111000111000111010011110000",
@@ -8477,7 +8477,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 11, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 11, {
             "11011100011",
             "1101110001110001110100",
             "110111000111000111010011110000001",
@@ -8492,7 +8492,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 16, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 16, {
             "1101110001110001",
             "11011100011100011101001111000000",
             "110111000111000111010011110000001000100101110100",
@@ -8503,7 +8503,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 31, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 31, {
             "1101110001110001110100111100000",
             "11011100011100011101001111000000100010010111010000001010011010",
             "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111",
@@ -8511,14 +8511,14 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 32, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0), Decimal128::kLargestPositive, 32, {
             "11011100011100011101001111000000",
             "1101110001110001110100111100000010001001011101000000101001101010",
             "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111",
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 1, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 1, {
             "1",
             "11",
             "110",
@@ -8649,7 +8649,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 2, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 2, {
             "11",
             "1101",
             "110111",
@@ -8716,7 +8716,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 3, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 3, {
             "110",
             "110111",
             "110111000",
@@ -8762,7 +8762,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 4, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 4, {
             "1101",
             "11011100",
             "110111000111",
@@ -8797,7 +8797,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 8, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 8, {
             "11011100",
             "1101110001110001",
             "110111000111000111010011",
@@ -8816,7 +8816,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 10, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 10, {
             "1101110001",
             "11011100011100011101",
             "110111000111000111010011110000",
@@ -8832,7 +8832,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 11, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 11, {
             "11011100011",
             "1101110001110001110100",
             "110111000111000111010011110000001",
@@ -8847,7 +8847,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 16, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 16, {
             "1101110001110001",
             "11011100011100011101001111000000",
             "110111000111000111010011110000001000100101110100",
@@ -8858,7 +8858,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 31, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 31, {
             "1101110001110001110100111100000",
             "11011100011100011101001111000000100010010111010000001010011010",
             "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111",
@@ -8866,14 +8866,14 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 32, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(0.123400000000000), Decimal128::kLargestPositive, 32, {
             "11011100011100011101001111000000",
             "1101110001110001110100111100000010001001011101000000101001101010",
             "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111",
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 1, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 1, {
             "1",
             "11",
             "110",
@@ -9004,7 +9004,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 2, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 2, {
             "11",
             "1101",
             "110111",
@@ -9071,7 +9071,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 3, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 3, {
             "110",
             "110111",
             "110111000",
@@ -9117,7 +9117,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 4, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 4, {
             "1101",
             "11011100",
             "110111000111",
@@ -9152,7 +9152,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 8, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 8, {
             "11011100",
             "1101110001110001",
             "110111000111000111010011",
@@ -9171,7 +9171,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 10, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 10, {
             "1101110001",
             "11011100011100011101",
             "110111000111000111010011110000",
@@ -9187,7 +9187,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 11, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 11, {
             "11011100011",
             "1101110001110001110100",
             "110111000111000111010011110000001",
@@ -9202,7 +9202,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 16, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 16, {
             "1101110001110001",
             "11011100011100011101001111000000",
             "110111000111000111010011110000001000100101110100",
@@ -9213,7 +9213,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 31, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 31, {
             "1101110001110001110100111100000",
             "11011100011100011101001111000000100010010111010000001010011010",
             "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111",
@@ -9221,14 +9221,14 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 32, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128(-54.3210000000000), Decimal128::kLargestPositive, 32, {
             "11011100011100011101001111000000",
             "1101110001110001110100111100000010001001011101000000101001101010",
             "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111",
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 1, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 1, {
             "1",
             "11",
             "110",
@@ -9359,7 +9359,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 2, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 2, {
             "11",
             "1101",
             "110111",
@@ -9426,7 +9426,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 3, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 3, {
             "110",
             "110111",
             "110111000",
@@ -9472,7 +9472,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 4, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 4, {
             "1101",
             "11011100",
             "110111000111",
@@ -9507,7 +9507,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 8, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 8, {
             "11011100",
             "1101110001110001",
             "110111000111000111010011",
@@ -9526,7 +9526,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 10, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 10, {
             "1101110001",
             "11011100011100011101",
             "110111000111000111010011110000",
@@ -9542,7 +9542,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 11, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 11, {
             "11011100011",
             "1101110001110001110100",
             "110111000111000111010011110000001",
@@ -9557,7 +9557,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 16, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 16, {
             "1101110001110001",
             "11011100011100011101001111000000",
             "110111000111000111010011110000001000100101110100",
@@ -9568,7 +9568,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 31, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 31, {
             "1101110001110001110100111100000",
             "11011100011100011101001111000000100010010111010000001010011010",
             "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111",
@@ -9576,14 +9576,14 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 32, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 32, {
             "11011100011100011101001111000000",
             "1101110001110001110100111100000010001001011101000000101001101010",
             "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111",
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 1, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 1, {
             "1",
             "11",
             "110",
@@ -9714,7 +9714,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 2, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 2, {
             "11",
             "1101",
             "110111",
@@ -9781,7 +9781,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 3, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 3, {
             "110",
             "110111",
             "110111000",
@@ -9827,7 +9827,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 4, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 4, {
             "1101",
             "11011100",
             "110111000111",
@@ -9862,7 +9862,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 8, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 8, {
             "11011100",
             "1101110001110001",
             "110111000111000111010011",
@@ -9881,7 +9881,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 10, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 10, {
             "1101110001",
             "11011100011100011101",
             "110111000111000111010011110000",
@@ -9897,7 +9897,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 11, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 11, {
             "11011100011",
             "1101110001110001110100",
             "110111000111000111010011110000001",
@@ -9912,7 +9912,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 16, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 16, {
             "1101110001110001",
             "11011100011100011101001111000000",
             "110111000111000111010011110000001000100101110100",
@@ -9923,7 +9923,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 31, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 31, {
             "1101110001110001110100111100000",
             "11011100011100011101001111000000100010010111010000001010011010",
             "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111",
@@ -9931,14 +9931,14 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 32, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 32, {
             "11011100011100011101001111000000",
             "1101110001110001110100111100000010001001011101000000101001101010",
             "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111",
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 1, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 1, {
             "1",
             "11",
             "110",
@@ -10069,7 +10069,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 2, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 2, {
             "11",
             "1101",
             "110111",
@@ -10136,7 +10136,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 3, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 3, {
             "110",
             "110111",
             "110111000",
@@ -10182,7 +10182,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 4, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 4, {
             "1101",
             "11011100",
             "110111000111",
@@ -10217,7 +10217,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 8, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 8, {
             "11011100",
             "1101110001110001",
             "110111000111000111010011",
@@ -10236,7 +10236,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 10, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 10, {
             "1101110001",
             "11011100011100011101",
             "110111000111000111010011110000",
@@ -10252,7 +10252,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 11, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 11, {
             "11011100011",
             "1101110001110001110100",
             "110111000111000111010011110000001",
@@ -10267,7 +10267,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 16, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 16, {
             "1101110001110001",
             "11011100011100011101001111000000",
             "110111000111000111010011110000001000100101110100",
@@ -10278,7 +10278,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 31, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 31, {
             "1101110001110001110100111100000",
             "11011100011100011101001111000000100010010111010000001010011010",
             "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111",
@@ -10286,14 +10286,14 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 32, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 32, {
             "11011100011100011101001111000000",
             "1101110001110001110100111100000010001001011101000000101001101010",
             "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111",
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 1, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 1, {
             "1",
             "11",
             "110",
@@ -10424,7 +10424,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 2, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 2, {
             "11",
             "1101",
             "110111",
@@ -10491,7 +10491,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 3, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 3, {
             "110",
             "110111",
             "110111000",
@@ -10537,7 +10537,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 4, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 4, {
             "1101",
             "11011100",
             "110111000111",
@@ -10572,7 +10572,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 8, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 8, {
             "11011100",
             "1101110001110001",
             "110111000111000111010011",
@@ -10591,7 +10591,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 10, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 10, {
             "1101110001",
             "11011100011100011101",
             "110111000111000111010011110000",
@@ -10607,7 +10607,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 11, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 11, {
             "11011100011",
             "1101110001110001110100",
             "110111000111000111010011110000001",
@@ -10622,7 +10622,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 16, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 16, {
             "1101110001110001",
             "11011100011100011101001111000000",
             "110111000111000111010011110000001000100101110100",
@@ -10633,7 +10633,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 31, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 31, {
             "1101110001110001110100111100000",
             "11011100011100011101001111000000100010010111010000001010011010",
             "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111",
@@ -10641,14 +10641,14 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 32, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 32, {
             "11011100011100011101001111000000",
             "1101110001110001110100111100000010001001011101000000101001101010",
             "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111",
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 1, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 1, {
             "1",
             "11",
             "110",
@@ -10779,7 +10779,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 2, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 2, {
             "11",
             "1101",
             "110111",
@@ -10846,7 +10846,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 3, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 3, {
             "110",
             "110111",
             "110111000",
@@ -10892,7 +10892,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 4, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 4, {
             "1101",
             "11011100",
             "110111000111",
@@ -10927,7 +10927,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 8, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 8, {
             "11011100",
             "1101110001110001",
             "110111000111000111010011",
@@ -10946,7 +10946,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 10, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 10, {
             "1101110001",
             "11011100011100011101",
             "110111000111000111010011110000",
@@ -10962,7 +10962,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 11, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 11, {
             "11011100011",
             "1101110001110001110100",
             "110111000111000111010011110000001",
@@ -10977,7 +10977,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 16, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 16, {
             "1101110001110001",
             "11011100011100011101001111000000",
             "110111000111000111010011110000001000100101110100",
@@ -10988,7 +10988,7 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 31, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 31, {
             "1101110001110001110100111100000",
             "11011100011100011101001111000000100010010111010000001010011010",
             "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111",
@@ -10996,14 +10996,14 @@
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestPositive, boost::none, boost::none, 32, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestPositive, boost::none, boost::none, 32, {
             "11011100011100011101001111000000",
             "1101110001110001110100111100000010001001011101000000101001101010",
             "110111000111000111010011110000001000100101110100000010100110101010001010101100101011111111111111",
             "11011100011100011101001111000000100010010111010000001010011010101000101010110010101111111111111111111111111111111101000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 1, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 1, {
             "0",
             "00",
             "001",
@@ -11134,7 +11134,7 @@
             "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 2, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 2, {
             "00",
             "0010",
             "001000",
@@ -11201,7 +11201,7 @@
             "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 3, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 3, {
             "001",
             "001000",
             "001000111",
@@ -11247,7 +11247,7 @@
             "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 4, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 4, {
             "0010",
             "00100011",
             "001000111000",
@@ -11282,7 +11282,7 @@
             "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 8, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 8, {
             "00100011",
             "0010001110001110",
             "001000111000111000101100",
@@ -11301,7 +11301,7 @@
             "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 10, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 10, {
             "0010001110",
             "00100011100011100010",
             "001000111000111000101100001111",
@@ -11317,7 +11317,7 @@
             "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 11, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 11, {
             "00100011100",
             "0010001110001110001011",
             "001000111000111000101100001111110",
@@ -11332,7 +11332,7 @@
             "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 16, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 16, {
             "0010001110001110",
             "00100011100011100010110000111111",
             "001000111000111000101100001111110111011010001011",
@@ -11343,7 +11343,7 @@
             "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 31, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 31, {
             "0010001110001110001011000011111",
             "00100011100011100010110000111111011101101000101111110101100101",
             "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000",
@@ -11351,14 +11351,14 @@
             "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 32, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(12.3400000000000), 32, {
             "00100011100011100010110000111111",
             "0010001110001110001011000011111101110110100010111111010110010101",
             "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000",
             "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 1, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 1, {
             "0",
             "00",
             "001",
@@ -11489,7 +11489,7 @@
             "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 2, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 2, {
             "00",
             "0010",
             "001000",
@@ -11556,7 +11556,7 @@
             "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 3, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 3, {
             "001",
             "001000",
             "001000111",
@@ -11602,7 +11602,7 @@
             "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 4, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 4, {
             "0010",
             "00100011",
             "001000111000",
@@ -11637,7 +11637,7 @@
             "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 8, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 8, {
             "00100011",
             "0010001110001110",
             "001000111000111000101100",
@@ -11656,7 +11656,7 @@
             "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 10, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 10, {
             "0010001110",
             "00100011100011100010",
             "001000111000111000101100001111",
@@ -11672,7 +11672,7 @@
             "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 11, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 11, {
             "00100011100",
             "0010001110001110001011",
             "001000111000111000101100001111110",
@@ -11687,7 +11687,7 @@
             "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 16, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 16, {
             "0010001110001110",
             "00100011100011100010110000111111",
             "001000111000111000101100001111110111011010001011",
@@ -11698,7 +11698,7 @@
             "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 31, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 31, {
             "0010001110001110001011000011111",
             "00100011100011100010110000111111011101101000101111110101100101",
             "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000",
@@ -11706,14 +11706,14 @@
             "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 32, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128(-21.0980000000000), 32, {
             "00100011100011100010110000111111",
             "0010001110001110001011000011111101110110100010111111010110010101",
             "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000",
             "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 1, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 1, {
             "0",
             "00",
             "001",
@@ -11844,7 +11844,7 @@
             "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 2, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 2, {
             "00",
             "0010",
             "001000",
@@ -11911,7 +11911,7 @@
             "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 3, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 3, {
             "001",
             "001000",
             "001000111",
@@ -11957,7 +11957,7 @@
             "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 4, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 4, {
             "0010",
             "00100011",
             "001000111000",
@@ -11992,7 +11992,7 @@
             "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 8, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 8, {
             "00100011",
             "0010001110001110",
             "001000111000111000101100",
@@ -12011,7 +12011,7 @@
             "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 10, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 10, {
             "0010001110",
             "00100011100011100010",
             "001000111000111000101100001111",
@@ -12027,7 +12027,7 @@
             "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 11, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 11, {
             "00100011100",
             "0010001110001110001011",
             "001000111000111000101100001111110",
@@ -12042,7 +12042,7 @@
             "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 16, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 16, {
             "0010001110001110",
             "00100011100011100010110000111111",
             "001000111000111000101100001111110111011010001011",
@@ -12053,7 +12053,7 @@
             "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 31, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 31, {
             "0010001110001110001011000011111",
             "00100011100011100010110000111111011101101000101111110101100101",
             "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000",
@@ -12061,14 +12061,14 @@
             "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 32, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, Decimal128::kLargestNegative, Decimal128::kLargestPositive, 32, {
             "00100011100011100010110000111111",
             "0010001110001110001011000011111101110110100010111111010110010101",
             "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000",
             "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, boost::none, boost::none, 1, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, boost::none, boost::none, 1, {
             "0",
             "00",
             "001",
@@ -12199,7 +12199,7 @@
             "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, boost::none, boost::none, 2, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, boost::none, boost::none, 2, {
             "00",
             "0010",
             "001000",
@@ -12266,7 +12266,7 @@
             "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, boost::none, boost::none, 3, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, boost::none, boost::none, 3, {
             "001",
             "001000",
             "001000111",
@@ -12312,7 +12312,7 @@
             "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, boost::none, boost::none, 4, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, boost::none, boost::none, 4, {
             "0010",
             "00100011",
             "001000111000",
@@ -12347,7 +12347,7 @@
             "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, boost::none, boost::none, 8, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, boost::none, boost::none, 8, {
             "00100011",
             "0010001110001110",
             "001000111000111000101100",
@@ -12366,7 +12366,7 @@
             "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, boost::none, boost::none, 10, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, boost::none, boost::none, 10, {
             "0010001110",
             "00100011100011100010",
             "001000111000111000101100001111",
@@ -12382,7 +12382,7 @@
             "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, boost::none, boost::none, 11, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, boost::none, boost::none, 11, {
             "00100011100",
             "0010001110001110001011",
             "001000111000111000101100001111110",
@@ -12397,7 +12397,7 @@
             "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, boost::none, boost::none, 16, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, boost::none, boost::none, 16, {
             "0010001110001110",
             "00100011100011100010110000111111",
             "001000111000111000101100001111110111011010001011",
@@ -12408,7 +12408,7 @@
             "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, boost::none, boost::none, 31, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, boost::none, boost::none, 31, {
             "0010001110001110001011000011111",
             "00100011100011100010110000111111011101101000101111110101100101",
             "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000",
@@ -12416,7 +12416,7 @@
             "00100011100011100010110000111111011101101000101111110101100101010111010101001101010000000000000000000000000000000011000000000000",
             "root",
         }},
-        {&getEdgesDecimal128, Decimal128::kLargestNegative, boost::none, boost::none, 32, {
+        {&getEdgesDecimal128ForTest, Decimal128::kLargestNegative, boost::none, boost::none, 32, {
             "00100011100011100010110000111111",
             "0010001110001110001011000011111101110110100010111111010110010101",
             "001000111000111000101100001111110111011010001011111101011001010101110101010011010100000000000000",
diff --git a/src/mongo/crypto/test_vectors/edges_double.cstruct b/src/mongo/crypto/test_vectors/edges_double.cstruct
index fafec401630..e7ec1198df6 100644
--- a/src/mongo/crypto/test_vectors/edges_double.cstruct
+++ b/src/mongo/crypto/test_vectors/edges_double.cstruct
@@ -1,4 +1,4 @@
-        {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 1, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 1, {
             "1",
             "10",
             "100",
@@ -65,7 +65,7 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 2, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 2, {
             "10",
             "1000",
             "100000",
@@ -100,7 +100,7 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 3, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 3, {
             "100",
             "100000",
             "100000000",
@@ -125,7 +125,7 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 4, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 4, {
             "1000",
             "10000000",
             "100000000000",
@@ -144,7 +144,7 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 8, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 8, {
             "10000000",
             "1000000000000000",
             "100000000000000000000000",
@@ -155,7 +155,7 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 10, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 10, {
             "1000000000",
             "10000000000000000000",
             "100000000000000000000000000000",
@@ -165,7 +165,7 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 11, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 11, {
             "10000000000",
             "1000000000000000000000",
             "100000000000000000000000000000000",
@@ -174,25 +174,25 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 16, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 16, {
             "1000000000000000",
             "10000000000000000000000000000000",
             "100000000000000000000000000000000000000000000000",
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 31, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 31, {
             "1000000000000000000000000000000",
             "10000000000000000000000000000000000000000000000000000000000000",
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 32, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 12.33999999999999986, 32, {
             "10000000000000000000000000000000",
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 1, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 1, {
             "1",
             "10",
             "100",
@@ -259,7 +259,7 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 2, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 2, {
             "10",
             "1000",
             "100000",
@@ -294,7 +294,7 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 3, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 3, {
             "100",
             "100000",
             "100000000",
@@ -319,7 +319,7 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 4, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 4, {
             "1000",
             "10000000",
             "100000000000",
@@ -338,7 +338,7 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 8, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 8, {
             "10000000",
             "1000000000000000",
             "100000000000000000000000",
@@ -349,7 +349,7 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 10, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 10, {
             "1000000000",
             "10000000000000000000",
             "100000000000000000000000000000",
@@ -359,7 +359,7 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 11, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 11, {
             "10000000000",
             "1000000000000000000000",
             "100000000000000000000000000000000",
@@ -368,25 +368,25 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 16, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 16, {
             "1000000000000000",
             "10000000000000000000000000000000",
             "100000000000000000000000000000000000000000000000",
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 31, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 31, {
             "1000000000000000000000000000000",
             "10000000000000000000000000000000000000000000000000000000000000",
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 32, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 12.33999999999999986, 32, {
             "10000000000000000000000000000000",
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, {
             "1",
             "10",
             "100",
@@ -453,7 +453,7 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, {
             "10",
             "1000",
             "100000",
@@ -488,7 +488,7 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, {
             "100",
             "100000",
             "100000000",
@@ -513,7 +513,7 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, {
             "1000",
             "10000000",
             "100000000000",
@@ -532,7 +532,7 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, {
             "10000000",
             "1000000000000000",
             "100000000000000000000000",
@@ -543,7 +543,7 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, {
             "1000000000",
             "10000000000000000000",
             "100000000000000000000000000000",
@@ -553,7 +553,7 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, {
             "10000000000",
             "1000000000000000000000",
             "100000000000000000000000000000000",
@@ -562,25 +562,25 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, {
             "1000000000000000",
             "10000000000000000000000000000000",
             "100000000000000000000000000000000000000000000000",
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, {
             "1000000000000000000000000000000",
             "10000000000000000000000000000000000000000000000000000000000000",
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, {
             "10000000000000000000000000000000",
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, {
             "1",
             "10",
             "100",
@@ -647,7 +647,7 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, {
             "10",
             "1000",
             "100000",
@@ -682,7 +682,7 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, {
             "100",
             "100000",
             "100000000",
@@ -707,7 +707,7 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, {
             "1000",
             "10000000",
             "100000000000",
@@ -726,7 +726,7 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, {
             "10000000",
             "1000000000000000",
             "100000000000000000000000",
@@ -737,7 +737,7 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, {
             "1000000000",
             "10000000000000000000",
             "100000000000000000000000000000",
@@ -747,7 +747,7 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, {
             "10000000000",
             "1000000000000000000000",
             "100000000000000000000000000000000",
@@ -756,25 +756,25 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, {
             "1000000000000000",
             "10000000000000000000000000000000",
             "100000000000000000000000000000000000000000000000",
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, {
             "1000000000000000000000000000000",
             "10000000000000000000000000000000000000000000000000000000000000",
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, {
             "10000000000000000000000000000000",
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 1, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 1, {
             "1",
             "10",
             "100",
@@ -841,7 +841,7 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 2, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 2, {
             "10",
             "1000",
             "100000",
@@ -876,7 +876,7 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 3, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 3, {
             "100",
             "100000",
             "100000000",
@@ -901,7 +901,7 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 4, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 4, {
             "1000",
             "10000000",
             "100000000000",
@@ -920,7 +920,7 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 8, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 8, {
             "10000000",
             "1000000000000000",
             "100000000000000000000000",
@@ -931,7 +931,7 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 10, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 10, {
             "1000000000",
             "10000000000000000000",
             "100000000000000000000000000000",
@@ -941,7 +941,7 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 11, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 11, {
             "10000000000",
             "1000000000000000000000",
             "100000000000000000000000000000000",
@@ -950,25 +950,25 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 16, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 16, {
             "1000000000000000",
             "10000000000000000000000000000000",
             "100000000000000000000000000000000000000000000000",
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 31, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 31, {
             "1000000000000000000000000000000",
             "10000000000000000000000000000000000000000000000000000000000000",
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 32, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 32, {
             "10000000000000000000000000000000",
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 1, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 1, {
             "1",
             "10",
             "100",
@@ -1035,7 +1035,7 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 2, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 2, {
             "10",
             "1000",
             "100000",
@@ -1070,7 +1070,7 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 3, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 3, {
             "100",
             "100000",
             "100000000",
@@ -1095,7 +1095,7 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 4, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 4, {
             "1000",
             "10000000",
             "100000000000",
@@ -1114,7 +1114,7 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 8, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 8, {
             "10000000",
             "1000000000000000",
             "100000000000000000000000",
@@ -1125,7 +1125,7 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 10, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 10, {
             "1000000000",
             "10000000000000000000",
             "100000000000000000000000000000",
@@ -1135,7 +1135,7 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 11, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 11, {
             "10000000000",
             "1000000000000000000000",
             "100000000000000000000000000000000",
@@ -1144,25 +1144,25 @@
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 16, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 16, {
             "1000000000000000",
             "10000000000000000000000000000000",
             "100000000000000000000000000000000000000000000000",
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 31, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 31, {
             "1000000000000000000000000000000",
             "10000000000000000000000000000000000000000000000000000000000000",
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, 0.00000000000000000, boost::none, boost::none, 32, {
+        {&getEdgesDoubleForTest, 0.00000000000000000, boost::none, boost::none, 32, {
             "10000000000000000000000000000000",
             "1000000000000000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 1, {
+        {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 1, {
             "0",
             "01",
             "010",
@@ -1229,7 +1229,7 @@
             "0100000010000011010100111111011111001110110110010001011010000111",
             "root",
         }},
-        {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 2, {
+        {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 2, {
             "01",
             "0100",
             "010000",
@@ -1264,7 +1264,7 @@
             "0100000010000011010100111111011111001110110110010001011010000111",
             "root",
         }},
-        {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 3, {
+        {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 3, {
             "010",
             "010000",
             "010000001",
@@ -1289,7 +1289,7 @@
             "0100000010000011010100111111011111001110110110010001011010000111",
             "root",
         }},
-        {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 4, {
+        {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 4, {
             "0100",
             "01000000",
             "010000001000",
@@ -1308,7 +1308,7 @@
             "0100000010000011010100111111011111001110110110010001011010000111",
             "root",
         }},
-        {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 8, {
+        {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 8, {
             "01000000",
             "0100000010000011",
             "010000001000001101010011",
@@ -1319,7 +1319,7 @@
             "0100000010000011010100111111011111001110110110010001011010000111",
             "root",
         }},
-        {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 10, {
+        {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 10, {
             "0100000010",
             "01000000100000110101",
             "010000001000001101010011111101",
@@ -1329,7 +1329,7 @@
             "0100000010000011010100111111011111001110110110010001011010000111",
             "root",
         }},
-        {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 11, {
+        {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 11, {
             "01000000100",
             "0100000010000011010100",
             "010000001000001101010011111101111",
@@ -1338,25 +1338,25 @@
             "0100000010000011010100111111011111001110110110010001011010000111",
             "root",
         }},
-        {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 16, {
+        {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 16, {
             "0100000010000011",
             "01000000100000110101001111110111",
             "010000001000001101010011111101111100111011011001",
             "0100000010000011010100111111011111001110110110010001011010000111",
             "root",
         }},
-        {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 31, {
+        {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 31, {
             "0100000010000011010100111111011",
             "01000000100000110101001111110111110011101101100100010110100001",
             "0100000010000011010100111111011111001110110110010001011010000111",
             "root",
         }},
-        {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 32, {
+        {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 12.33999999999999986, 32, {
             "01000000100000110101001111110111",
             "0100000010000011010100111111011111001110110110010001011010000111",
             "root",
         }},
-        {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, {
+        {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, {
             "0",
             "01",
             "010",
@@ -1423,7 +1423,7 @@
             "0100000010000011010100111111011111001110110110010001011010000111",
             "root",
         }},
-        {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, {
+        {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, {
             "01",
             "0100",
             "010000",
@@ -1458,7 +1458,7 @@
             "0100000010000011010100111111011111001110110110010001011010000111",
             "root",
         }},
-        {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, {
+        {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, {
             "010",
             "010000",
             "010000001",
@@ -1483,7 +1483,7 @@
             "0100000010000011010100111111011111001110110110010001011010000111",
             "root",
         }},
-        {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, {
+        {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, {
             "0100",
             "01000000",
             "010000001000",
@@ -1502,7 +1502,7 @@
             "0100000010000011010100111111011111001110110110010001011010000111",
             "root",
         }},
-        {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, {
+        {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, {
             "01000000",
             "0100000010000011",
             "010000001000001101010011",
@@ -1513,7 +1513,7 @@
             "0100000010000011010100111111011111001110110110010001011010000111",
             "root",
         }},
-        {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, {
+        {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, {
             "0100000010",
             "01000000100000110101",
             "010000001000001101010011111101",
@@ -1523,7 +1523,7 @@
             "0100000010000011010100111111011111001110110110010001011010000111",
             "root",
         }},
-        {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, {
+        {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, {
             "01000000100",
             "0100000010000011010100",
             "010000001000001101010011111101111",
@@ -1532,25 +1532,25 @@
             "0100000010000011010100111111011111001110110110010001011010000111",
             "root",
         }},
-        {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, {
+        {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, {
             "0100000010000011",
             "01000000100000110101001111110111",
             "010000001000001101010011111101111100111011011001",
             "0100000010000011010100111111011111001110110110010001011010000111",
             "root",
         }},
-        {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, {
+        {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, {
             "0100000010000011010100111111011",
             "01000000100000110101001111110111110011101101100100010110100001",
             "0100000010000011010100111111011111001110110110010001011010000111",
             "root",
         }},
-        {&getEdgesDouble, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, {
+        {&getEdgesDoubleForTest, -0.00700000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, {
             "01000000100000110101001111110111",
             "0100000010000011010100111111011111001110110110010001011010000111",
             "root",
         }},
-        {&getEdgesDouble, -0.00700000000000000, boost::none, boost::none, 1, {
+        {&getEdgesDoubleForTest, -0.00700000000000000, boost::none, boost::none, 1, {
             "0",
             "01",
             "010",
@@ -1617,7 +1617,7 @@
             "0100000010000011010100111111011111001110110110010001011010000111",
             "root",
         }},
-        {&getEdgesDouble, -0.00700000000000000, boost::none, boost::none, 2, {
+        {&getEdgesDoubleForTest, -0.00700000000000000, boost::none, boost::none, 2, {
             "01",
             "0100",
             "010000",
@@ -1652,7 +1652,7 @@
             "0100000010000011010100111111011111001110110110010001011010000111",
             "root",
         }},
-        {&getEdgesDouble, -0.00700000000000000, boost::none, boost::none, 3, {
+        {&getEdgesDoubleForTest, -0.00700000000000000, boost::none, boost::none, 3, {
             "010",
             "010000",
             "010000001",
@@ -1677,7 +1677,7 @@
             "0100000010000011010100111111011111001110110110010001011010000111",
             "root",
         }},
-        {&getEdgesDouble, -0.00700000000000000, boost::none, boost::none, 4, {
+        {&getEdgesDoubleForTest, -0.00700000000000000, boost::none, boost::none, 4, {
             "0100",
             "01000000",
             "010000001000",
@@ -1696,7 +1696,7 @@
             "0100000010000011010100111111011111001110110110010001011010000111",
             "root",
         }},
-        {&getEdgesDouble, -0.00700000000000000, boost::none, boost::none, 8, {
+        {&getEdgesDoubleForTest, -0.00700000000000000, boost::none, boost::none, 8, {
             "01000000",
             "0100000010000011",
             "010000001000001101010011",
@@ -1707,7 +1707,7 @@
             "0100000010000011010100111111011111001110110110010001011010000111",
             "root",
         }},
-        {&getEdgesDouble, -0.00700000000000000, boost::none, boost::none, 10, {
+        {&getEdgesDoubleForTest, -0.00700000000000000, boost::none, boost::none, 10, {
             "0100000010",
             "01000000100000110101",
             "010000001000001101010011111101",
@@ -1717,7 +1717,7 @@
             "0100000010000011010100111111011111001110110110010001011010000111",
             "root",
         }},
-        {&getEdgesDouble, -0.00700000000000000, boost::none, boost::none, 11, {
+        {&getEdgesDoubleForTest, -0.00700000000000000, boost::none, boost::none, 11, {
             "01000000100",
             "0100000010000011010100",
             "010000001000001101010011111101111",
@@ -1726,25 +1726,25 @@
             "0100000010000011010100111111011111001110110110010001011010000111",
             "root",
         }},
-        {&getEdgesDouble, -0.00700000000000000, boost::none, boost::none, 16, {
+        {&getEdgesDoubleForTest, -0.00700000000000000, boost::none, boost::none, 16, {
             "0100000010000011",
             "01000000100000110101001111110111",
             "010000001000001101010011111101111100111011011001",
             "0100000010000011010100111111011111001110110110010001011010000111",
             "root",
         }},
-        {&getEdgesDouble, -0.00700000000000000, boost::none, boost::none, 31, {
+        {&getEdgesDoubleForTest, -0.00700000000000000, boost::none, boost::none, 31, {
             "0100000010000011010100111111011",
             "01000000100000110101001111110111110011101101100100010110100001",
             "0100000010000011010100111111011111001110110110010001011010000111",
             "root",
         }},
-        {&getEdgesDouble, -0.00700000000000000, boost::none, boost::none, 32, {
+        {&getEdgesDoubleForTest, -0.00700000000000000, boost::none, boost::none, 32, {
             "01000000100000110101001111110111",
             "0100000010000011010100111111011111001110110110010001011010000111",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, {
             "1",
             "11",
             "110",
@@ -1811,7 +1811,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, {
             "11",
             "1100",
             "110000",
@@ -1846,7 +1846,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, {
             "110",
             "110000",
             "110000000",
@@ -1871,7 +1871,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, {
             "1100",
             "11000000",
             "110000000100",
@@ -1890,7 +1890,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, {
             "11000000",
             "1100000001000000",
             "110000000100000001100011",
@@ -1901,7 +1901,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, {
             "1100000001",
             "11000000010000000110",
             "110000000100000001100011011101",
@@ -1911,7 +1911,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, {
             "11000000010",
             "1100000001000000011000",
             "110000000100000001100011011101001",
@@ -1920,25 +1920,25 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, {
             "1100000001000000",
             "11000000010000000110001101110100",
             "110000000100000001100011011101001011110001101010",
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, {
             "1100000001000000011000110111010",
             "11000000010000000110001101110100101111000110101001111110111110",
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, {
             "11000000010000000110001101110100",
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, {
             "1",
             "11",
             "110",
@@ -2005,7 +2005,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, {
             "11",
             "1100",
             "110000",
@@ -2040,7 +2040,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, {
             "110",
             "110000",
             "110000000",
@@ -2065,7 +2065,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, {
             "1100",
             "11000000",
             "110000000100",
@@ -2084,7 +2084,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, {
             "11000000",
             "1100000001000000",
             "110000000100000001100011",
@@ -2095,7 +2095,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, {
             "1100000001",
             "11000000010000000110",
             "110000000100000001100011011101",
@@ -2105,7 +2105,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, {
             "11000000010",
             "1100000001000000011000",
             "110000000100000001100011011101001",
@@ -2114,25 +2114,25 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, {
             "1100000001000000",
             "11000000010000000110001101110100",
             "110000000100000001100011011101001011110001101010",
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, {
             "1100000001000000011000110111010",
             "11000000010000000110001101110100101111000110101001111110111110",
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, {
             "11000000010000000110001101110100",
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, {
             "1",
             "11",
             "110",
@@ -2199,7 +2199,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, {
             "11",
             "1100",
             "110000",
@@ -2234,7 +2234,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, {
             "110",
             "110000",
             "110000000",
@@ -2259,7 +2259,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, {
             "1100",
             "11000000",
             "110000000100",
@@ -2278,7 +2278,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, {
             "11000000",
             "1100000001000000",
             "110000000100000001100011",
@@ -2289,7 +2289,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, {
             "1100000001",
             "11000000010000000110",
             "110000000100000001100011011101",
@@ -2299,7 +2299,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, {
             "11000000010",
             "1100000001000000011000",
             "110000000100000001100011011101001",
@@ -2308,25 +2308,25 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, {
             "1100000001000000",
             "11000000010000000110001101110100",
             "110000000100000001100011011101001011110001101010",
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, {
             "1100000001000000011000110111010",
             "11000000010000000110001101110100101111000110101001111110111110",
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, {
             "11000000010000000110001101110100",
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, {
             "1",
             "11",
             "110",
@@ -2393,7 +2393,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, {
             "11",
             "1100",
             "110000",
@@ -2428,7 +2428,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, {
             "110",
             "110000",
             "110000000",
@@ -2453,7 +2453,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, {
             "1100",
             "11000000",
             "110000000100",
@@ -2472,7 +2472,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, {
             "11000000",
             "1100000001000000",
             "110000000100000001100011",
@@ -2483,7 +2483,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, {
             "1100000001",
             "11000000010000000110",
             "110000000100000001100011011101",
@@ -2493,7 +2493,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, {
             "11000000010",
             "1100000001000000011000",
             "110000000100000001100011011101001",
@@ -2502,25 +2502,25 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, {
             "1100000001000000",
             "11000000010000000110001101110100",
             "110000000100000001100011011101001011110001101010",
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, {
             "1100000001000000011000110111010",
             "11000000010000000110001101110100101111000110101001111110111110",
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, {
             "11000000010000000110001101110100",
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 1, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 1, {
             "1",
             "11",
             "110",
@@ -2587,7 +2587,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 2, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 2, {
             "11",
             "1100",
             "110000",
@@ -2622,7 +2622,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 3, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 3, {
             "110",
             "110000",
             "110000000",
@@ -2647,7 +2647,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 4, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 4, {
             "1100",
             "11000000",
             "110000000100",
@@ -2666,7 +2666,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 8, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 8, {
             "11000000",
             "1100000001000000",
             "110000000100000001100011",
@@ -2677,7 +2677,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 10, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 10, {
             "1100000001",
             "11000000010000000110",
             "110000000100000001100011011101",
@@ -2687,7 +2687,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 11, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 11, {
             "11000000010",
             "1100000001000000011000",
             "110000000100000001100011011101001",
@@ -2696,25 +2696,25 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 16, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 16, {
             "1100000001000000",
             "11000000010000000110001101110100",
             "110000000100000001100011011101001011110001101010",
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 31, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 31, {
             "1100000001000000011000110111010",
             "11000000010000000110001101110100101111000110101001111110111110",
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 32, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 32, {
             "11000000010000000110001101110100",
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 1, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 1, {
             "1",
             "11",
             "110",
@@ -2781,7 +2781,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 2, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 2, {
             "11",
             "1100",
             "110000",
@@ -2816,7 +2816,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 3, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 3, {
             "110",
             "110000",
             "110000000",
@@ -2841,7 +2841,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 4, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 4, {
             "1100",
             "11000000",
             "110000000100",
@@ -2860,7 +2860,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 8, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 8, {
             "11000000",
             "1100000001000000",
             "110000000100000001100011",
@@ -2871,7 +2871,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 10, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 10, {
             "1100000001",
             "11000000010000000110",
             "110000000100000001100011011101",
@@ -2881,7 +2881,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 11, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 11, {
             "11000000010",
             "1100000001000000011000",
             "110000000100000001100011011101001",
@@ -2890,25 +2890,25 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 16, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 16, {
             "1100000001000000",
             "11000000010000000110001101110100",
             "110000000100000001100011011101001011110001101010",
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 31, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 31, {
             "1100000001000000011000110111010",
             "11000000010000000110001101110100101111000110101001111110111110",
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 32, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 32, {
             "11000000010000000110001101110100",
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 1, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 1, {
             "1",
             "11",
             "110",
@@ -2975,7 +2975,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 2, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 2, {
             "11",
             "1100",
             "110000",
@@ -3010,7 +3010,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 3, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 3, {
             "110",
             "110000",
             "110000000",
@@ -3035,7 +3035,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 4, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 4, {
             "1100",
             "11000000",
             "110000000100",
@@ -3054,7 +3054,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 8, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 8, {
             "11000000",
             "1100000001000000",
             "110000000100000001100011",
@@ -3065,7 +3065,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 10, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 10, {
             "1100000001",
             "11000000010000000110",
             "110000000100000001100011011101",
@@ -3075,7 +3075,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 11, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 11, {
             "11000000010",
             "1100000001000000011000",
             "110000000100000001100011011101001",
@@ -3084,25 +3084,25 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 16, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 16, {
             "1100000001000000",
             "11000000010000000110001101110100",
             "110000000100000001100011011101001011110001101010",
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 31, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 31, {
             "1100000001000000011000110111010",
             "11000000010000000110001101110100101111000110101001111110111110",
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 32, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 32, {
             "11000000010000000110001101110100",
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 1, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 1, {
             "1",
             "11",
             "110",
@@ -3169,7 +3169,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 2, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 2, {
             "11",
             "1100",
             "110000",
@@ -3204,7 +3204,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 3, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 3, {
             "110",
             "110000",
             "110000000",
@@ -3229,7 +3229,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 4, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 4, {
             "1100",
             "11000000",
             "110000000100",
@@ -3248,7 +3248,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 8, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 8, {
             "11000000",
             "1100000001000000",
             "110000000100000001100011",
@@ -3259,7 +3259,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 10, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 10, {
             "1100000001",
             "11000000010000000110",
             "110000000100000001100011011101",
@@ -3269,7 +3269,7 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 11, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 11, {
             "11000000010",
             "1100000001000000011000",
             "110000000100000001100011011101001",
@@ -3278,25 +3278,25 @@
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 16, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 16, {
             "1100000001000000",
             "11000000010000000110001101110100",
             "110000000100000001100011011101001011110001101010",
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 31, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 31, {
             "1100000001000000011000110111010",
             "11000000010000000110001101110100101111000110101001111110111110",
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 32.77700000000000102, boost::none, boost::none, 32, {
+        {&getEdgesDoubleForTest, 32.77700000000000102, boost::none, boost::none, 32, {
             "11000000010000000110001101110100",
             "1100000001000000011000110111010010111100011010100111111011111010",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, {
             "1",
             "11",
             "111",
@@ -3363,7 +3363,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, {
             "11",
             "1111",
             "111111",
@@ -3398,7 +3398,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, {
             "111",
             "111111",
             "111111111",
@@ -3423,7 +3423,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, {
             "1111",
             "11111111",
             "111111111110",
@@ -3442,7 +3442,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, {
             "11111111",
             "1111111111101111",
             "111111111110111111111111",
@@ -3453,7 +3453,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, {
             "1111111111",
             "11111111111011111111",
             "111111111110111111111111111111",
@@ -3463,7 +3463,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, {
             "11111111111",
             "1111111111101111111111",
             "111111111110111111111111111111111",
@@ -3472,25 +3472,25 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, {
             "1111111111101111",
             "11111111111011111111111111111111",
             "111111111110111111111111111111111111111111111111",
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, {
             "1111111111101111111111111111111",
             "11111111111011111111111111111111111111111111111111111111111111",
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, {
             "11111111111011111111111111111111",
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, {
             "1",
             "11",
             "111",
@@ -3557,7 +3557,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, {
             "11",
             "1111",
             "111111",
@@ -3592,7 +3592,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, {
             "111",
             "111111",
             "111111111",
@@ -3617,7 +3617,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, {
             "1111",
             "11111111",
             "111111111110",
@@ -3636,7 +3636,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, {
             "11111111",
             "1111111111101111",
             "111111111110111111111111",
@@ -3647,7 +3647,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, {
             "1111111111",
             "11111111111011111111",
             "111111111110111111111111111111",
@@ -3657,7 +3657,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, {
             "11111111111",
             "1111111111101111111111",
             "111111111110111111111111111111111",
@@ -3666,25 +3666,25 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, {
             "1111111111101111",
             "11111111111011111111111111111111",
             "111111111110111111111111111111111111111111111111",
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, {
             "1111111111101111111111111111111",
             "11111111111011111111111111111111111111111111111111111111111111",
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 0.12340000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, {
             "11111111111011111111111111111111",
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, {
             "1",
             "11",
             "111",
@@ -3751,7 +3751,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, {
             "11",
             "1111",
             "111111",
@@ -3786,7 +3786,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, {
             "111",
             "111111",
             "111111111",
@@ -3811,7 +3811,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, {
             "1111",
             "11111111",
             "111111111110",
@@ -3830,7 +3830,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, {
             "11111111",
             "1111111111101111",
             "111111111110111111111111",
@@ -3841,7 +3841,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, {
             "1111111111",
             "11111111111011111111",
             "111111111110111111111111111111",
@@ -3851,7 +3851,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, {
             "11111111111",
             "1111111111101111111111",
             "111111111110111111111111111111111",
@@ -3860,25 +3860,25 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, {
             "1111111111101111",
             "11111111111011111111111111111111",
             "111111111110111111111111111111111111111111111111",
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, {
             "1111111111101111111111111111111",
             "11111111111011111111111111111111111111111111111111111111111111",
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, {
             "11111111111011111111111111111111",
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, {
             "1",
             "11",
             "111",
@@ -3945,7 +3945,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, {
             "11",
             "1111",
             "111111",
@@ -3980,7 +3980,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, {
             "111",
             "111111",
             "111111111",
@@ -4005,7 +4005,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, {
             "1111",
             "11111111",
             "111111111110",
@@ -4024,7 +4024,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, {
             "11111111",
             "1111111111101111",
             "111111111110111111111111",
@@ -4035,7 +4035,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, {
             "1111111111",
             "11111111111011111111",
             "111111111110111111111111111111",
@@ -4045,7 +4045,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, {
             "11111111111",
             "1111111111101111111111",
             "111111111110111111111111111111111",
@@ -4054,25 +4054,25 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, {
             "1111111111101111",
             "11111111111011111111111111111111",
             "111111111110111111111111111111111111111111111111",
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, {
             "1111111111101111111111111111111",
             "11111111111011111111111111111111111111111111111111111111111111",
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, {
             "11111111111011111111111111111111",
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 1, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 1, {
             "1",
             "11",
             "111",
@@ -4139,7 +4139,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 2, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 2, {
             "11",
             "1111",
             "111111",
@@ -4174,7 +4174,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 3, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 3, {
             "111",
             "111111",
             "111111111",
@@ -4199,7 +4199,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 4, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 4, {
             "1111",
             "11111111",
             "111111111110",
@@ -4218,7 +4218,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 8, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 8, {
             "11111111",
             "1111111111101111",
             "111111111110111111111111",
@@ -4229,7 +4229,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 10, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 10, {
             "1111111111",
             "11111111111011111111",
             "111111111110111111111111111111",
@@ -4239,7 +4239,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 11, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 11, {
             "11111111111",
             "1111111111101111111111",
             "111111111110111111111111111111111",
@@ -4248,25 +4248,25 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 16, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 16, {
             "1111111111101111",
             "11111111111011111111111111111111",
             "111111111110111111111111111111111111111111111111",
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 31, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 31, {
             "1111111111101111111111111111111",
             "11111111111011111111111111111111111111111111111111111111111111",
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 32, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 32, {
             "11111111111011111111111111111111",
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 1, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 1, {
             "1",
             "11",
             "111",
@@ -4333,7 +4333,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 2, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 2, {
             "11",
             "1111",
             "111111",
@@ -4368,7 +4368,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 3, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 3, {
             "111",
             "111111",
             "111111111",
@@ -4393,7 +4393,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 4, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 4, {
             "1111",
             "11111111",
             "111111111110",
@@ -4412,7 +4412,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 8, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 8, {
             "11111111",
             "1111111111101111",
             "111111111110111111111111",
@@ -4423,7 +4423,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 10, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 10, {
             "1111111111",
             "11111111111011111111",
             "111111111110111111111111111111",
@@ -4433,7 +4433,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 11, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 11, {
             "11111111111",
             "1111111111101111111111",
             "111111111110111111111111111111111",
@@ -4442,25 +4442,25 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 16, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 16, {
             "1111111111101111",
             "11111111111011111111111111111111",
             "111111111110111111111111111111111111111111111111",
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 31, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 31, {
             "1111111111101111111111111111111",
             "11111111111011111111111111111111111111111111111111111111111111",
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 32, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 32, {
             "11111111111011111111111111111111",
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 1, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 1, {
             "1",
             "11",
             "111",
@@ -4527,7 +4527,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 2, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 2, {
             "11",
             "1111",
             "111111",
@@ -4562,7 +4562,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 3, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 3, {
             "111",
             "111111",
             "111111111",
@@ -4587,7 +4587,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 4, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 4, {
             "1111",
             "11111111",
             "111111111110",
@@ -4606,7 +4606,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 8, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 8, {
             "11111111",
             "1111111111101111",
             "111111111110111111111111",
@@ -4617,7 +4617,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 10, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 10, {
             "1111111111",
             "11111111111011111111",
             "111111111110111111111111111111",
@@ -4627,7 +4627,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 11, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 11, {
             "11111111111",
             "1111111111101111111111",
             "111111111110111111111111111111111",
@@ -4636,25 +4636,25 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 16, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 16, {
             "1111111111101111",
             "11111111111011111111111111111111",
             "111111111110111111111111111111111111111111111111",
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 31, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 31, {
             "1111111111101111111111111111111",
             "11111111111011111111111111111111111111111111111111111111111111",
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 32, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 32, {
             "11111111111011111111111111111111",
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 1, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 1, {
             "1",
             "11",
             "111",
@@ -4721,7 +4721,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 2, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 2, {
             "11",
             "1111",
             "111111",
@@ -4756,7 +4756,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 3, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 3, {
             "111",
             "111111",
             "111111111",
@@ -4781,7 +4781,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 4, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 4, {
             "1111",
             "11111111",
             "111111111110",
@@ -4800,7 +4800,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 8, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 8, {
             "11111111",
             "1111111111101111",
             "111111111110111111111111",
@@ -4811,7 +4811,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 10, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 10, {
             "1111111111",
             "11111111111011111111",
             "111111111110111111111111111111",
@@ -4821,7 +4821,7 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 11, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 11, {
             "11111111111",
             "1111111111101111111111",
             "111111111110111111111111111111111",
@@ -4830,25 +4830,25 @@
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 16, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 16, {
             "1111111111101111",
             "11111111111011111111111111111111",
             "111111111110111111111111111111111111111111111111",
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 31, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 31, {
             "1111111111101111111111111111111",
             "11111111111011111111111111111111111111111111111111111111111111",
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 32, {
+        {&getEdgesDoubleForTest, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, boost::none, boost::none, 32, {
             "11111111111011111111111111111111",
             "1111111111101111111111111111111111111111111111111111111111111111",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), 0.00000000000000000, 12.33999999999999986, 1, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), 0.00000000000000000, 12.33999999999999986, 1, {
             "1",
             "10",
             "100",
@@ -4915,7 +4915,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), 0.00000000000000000, 12.33999999999999986, 2, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), 0.00000000000000000, 12.33999999999999986, 2, {
             "10",
             "1000",
             "100000",
@@ -4950,7 +4950,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), 0.00000000000000000, 12.33999999999999986, 3, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), 0.00000000000000000, 12.33999999999999986, 3, {
             "100",
             "100000",
             "100000000",
@@ -4975,7 +4975,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), 0.00000000000000000, 12.33999999999999986, 4, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), 0.00000000000000000, 12.33999999999999986, 4, {
             "1000",
             "10000000",
             "100000000001",
@@ -4994,7 +4994,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), 0.00000000000000000, 12.33999999999999986, 8, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), 0.00000000000000000, 12.33999999999999986, 8, {
             "10000000",
             "1000000000010000",
             "100000000001000000000000",
@@ -5005,7 +5005,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), 0.00000000000000000, 12.33999999999999986, 10, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), 0.00000000000000000, 12.33999999999999986, 10, {
             "1000000000",
             "10000000000100000000",
             "100000000001000000000000000000",
@@ -5015,7 +5015,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), 0.00000000000000000, 12.33999999999999986, 11, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), 0.00000000000000000, 12.33999999999999986, 11, {
             "10000000000",
             "1000000000010000000000",
             "100000000001000000000000000000000",
@@ -5024,25 +5024,25 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), 0.00000000000000000, 12.33999999999999986, 16, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), 0.00000000000000000, 12.33999999999999986, 16, {
             "1000000000010000",
             "10000000000100000000000000000000",
             "100000000001000000000000000000000000000000000000",
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), 0.00000000000000000, 12.33999999999999986, 31, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), 0.00000000000000000, 12.33999999999999986, 31, {
             "1000000000010000000000000000000",
             "10000000000100000000000000000000000000000000000000000000000000",
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), 0.00000000000000000, 12.33999999999999986, 32, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), 0.00000000000000000, 12.33999999999999986, 32, {
             "10000000000100000000000000000000",
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), -54.32099999999999795, 12.33999999999999986, 1, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), -54.32099999999999795, 12.33999999999999986, 1, {
             "1",
             "10",
             "100",
@@ -5109,7 +5109,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), -54.32099999999999795, 12.33999999999999986, 2, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), -54.32099999999999795, 12.33999999999999986, 2, {
             "10",
             "1000",
             "100000",
@@ -5144,7 +5144,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), -54.32099999999999795, 12.33999999999999986, 3, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), -54.32099999999999795, 12.33999999999999986, 3, {
             "100",
             "100000",
             "100000000",
@@ -5169,7 +5169,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), -54.32099999999999795, 12.33999999999999986, 4, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), -54.32099999999999795, 12.33999999999999986, 4, {
             "1000",
             "10000000",
             "100000000001",
@@ -5188,7 +5188,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), -54.32099999999999795, 12.33999999999999986, 8, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), -54.32099999999999795, 12.33999999999999986, 8, {
             "10000000",
             "1000000000010000",
             "100000000001000000000000",
@@ -5199,7 +5199,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), -54.32099999999999795, 12.33999999999999986, 10, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), -54.32099999999999795, 12.33999999999999986, 10, {
             "1000000000",
             "10000000000100000000",
             "100000000001000000000000000000",
@@ -5209,7 +5209,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), -54.32099999999999795, 12.33999999999999986, 11, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), -54.32099999999999795, 12.33999999999999986, 11, {
             "10000000000",
             "1000000000010000000000",
             "100000000001000000000000000000000",
@@ -5218,25 +5218,25 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), -54.32099999999999795, 12.33999999999999986, 16, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), -54.32099999999999795, 12.33999999999999986, 16, {
             "1000000000010000",
             "10000000000100000000000000000000",
             "100000000001000000000000000000000000000000000000",
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), -54.32099999999999795, 12.33999999999999986, 31, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), -54.32099999999999795, 12.33999999999999986, 31, {
             "1000000000010000000000000000000",
             "10000000000100000000000000000000000000000000000000000000000000",
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), -54.32099999999999795, 12.33999999999999986, 32, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), -54.32099999999999795, 12.33999999999999986, 32, {
             "10000000000100000000000000000000",
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 12.33999999999999986, 1, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 12.33999999999999986, 1, {
             "1",
             "10",
             "100",
@@ -5303,7 +5303,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 12.33999999999999986, 2, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 12.33999999999999986, 2, {
             "10",
             "1000",
             "100000",
@@ -5338,7 +5338,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 12.33999999999999986, 3, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 12.33999999999999986, 3, {
             "100",
             "100000",
             "100000000",
@@ -5363,7 +5363,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 12.33999999999999986, 4, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 12.33999999999999986, 4, {
             "1000",
             "10000000",
             "100000000001",
@@ -5382,7 +5382,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 12.33999999999999986, 8, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 12.33999999999999986, 8, {
             "10000000",
             "1000000000010000",
             "100000000001000000000000",
@@ -5393,7 +5393,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 12.33999999999999986, 10, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 12.33999999999999986, 10, {
             "1000000000",
             "10000000000100000000",
             "100000000001000000000000000000",
@@ -5403,7 +5403,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 12.33999999999999986, 11, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 12.33999999999999986, 11, {
             "10000000000",
             "1000000000010000000000",
             "100000000001000000000000000000000",
@@ -5412,25 +5412,25 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 12.33999999999999986, 16, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 12.33999999999999986, 16, {
             "1000000000010000",
             "10000000000100000000000000000000",
             "100000000001000000000000000000000000000000000000",
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 12.33999999999999986, 31, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 12.33999999999999986, 31, {
             "1000000000010000000000000000000",
             "10000000000100000000000000000000000000000000000000000000000000",
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 12.33999999999999986, 32, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 12.33999999999999986, 32, {
             "10000000000100000000000000000000",
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, {
             "1",
             "10",
             "100",
@@ -5497,7 +5497,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, {
             "10",
             "1000",
             "100000",
@@ -5532,7 +5532,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, {
             "100",
             "100000",
             "100000000",
@@ -5557,7 +5557,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, {
             "1000",
             "10000000",
             "100000000001",
@@ -5576,7 +5576,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, {
             "10000000",
             "1000000000010000",
             "100000000001000000000000",
@@ -5587,7 +5587,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, {
             "1000000000",
             "10000000000100000000",
             "100000000001000000000000000000",
@@ -5597,7 +5597,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, {
             "10000000000",
             "1000000000010000000000",
             "100000000001000000000000000000000",
@@ -5606,25 +5606,25 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, {
             "1000000000010000",
             "10000000000100000000000000000000",
             "100000000001000000000000000000000000000000000000",
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, {
             "1000000000010000000000000000000",
             "10000000000100000000000000000000000000000000000000000000000000",
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), 0.00000000000000000, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, {
             "10000000000100000000000000000000",
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, {
             "1",
             "10",
             "100",
@@ -5691,7 +5691,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, {
             "10",
             "1000",
             "100000",
@@ -5726,7 +5726,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, {
             "100",
             "100000",
             "100000000",
@@ -5751,7 +5751,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, {
             "1000",
             "10000000",
             "100000000001",
@@ -5770,7 +5770,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, {
             "10000000",
             "1000000000010000",
             "100000000001000000000000",
@@ -5781,7 +5781,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, {
             "1000000000",
             "10000000000100000000",
             "100000000001000000000000000000",
@@ -5791,7 +5791,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, {
             "10000000000",
             "1000000000010000000000",
             "100000000001000000000000000000000",
@@ -5800,25 +5800,25 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, {
             "1000000000010000",
             "10000000000100000000000000000000",
             "100000000001000000000000000000000000000000000000",
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, {
             "1000000000010000000000000000000",
             "10000000000100000000000000000000000000000000000000000000000000",
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), -54.32099999999999795, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, {
             "10000000000100000000000000000000",
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 1, {
             "1",
             "10",
             "100",
@@ -5885,7 +5885,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 2, {
             "10",
             "1000",
             "100000",
@@ -5920,7 +5920,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 3, {
             "100",
             "100000",
             "100000000",
@@ -5945,7 +5945,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 4, {
             "1000",
             "10000000",
             "100000000001",
@@ -5964,7 +5964,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 8, {
             "10000000",
             "1000000000010000",
             "100000000001000000000000",
@@ -5975,7 +5975,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 10, {
             "1000000000",
             "10000000000100000000",
             "100000000001000000000000000000",
@@ -5985,7 +5985,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 11, {
             "10000000000",
             "1000000000010000000000",
             "100000000001000000000000000000000",
@@ -5994,25 +5994,25 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 16, {
             "1000000000010000",
             "10000000000100000000000000000000",
             "100000000001000000000000000000000000000000000000",
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 31, {
             "1000000000010000000000000000000",
             "10000000000100000000000000000000000000000000000000000000000000",
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), std::numeric_limits<double>::min(), 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.00000000000000000, 32, {
             "10000000000100000000000000000000",
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), boost::none, boost::none, 1, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), boost::none, boost::none, 1, {
             "1",
             "10",
             "100",
@@ -6079,7 +6079,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), boost::none, boost::none, 2, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), boost::none, boost::none, 2, {
             "10",
             "1000",
             "100000",
@@ -6114,7 +6114,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), boost::none, boost::none, 3, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), boost::none, boost::none, 3, {
             "100",
             "100000",
             "100000000",
@@ -6139,7 +6139,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), boost::none, boost::none, 4, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), boost::none, boost::none, 4, {
             "1000",
             "10000000",
             "100000000001",
@@ -6158,7 +6158,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), boost::none, boost::none, 8, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), boost::none, boost::none, 8, {
             "10000000",
             "1000000000010000",
             "100000000001000000000000",
@@ -6169,7 +6169,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), boost::none, boost::none, 10, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), boost::none, boost::none, 10, {
             "1000000000",
             "10000000000100000000",
             "100000000001000000000000000000",
@@ -6179,7 +6179,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), boost::none, boost::none, 11, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), boost::none, boost::none, 11, {
             "10000000000",
             "1000000000010000000000",
             "100000000001000000000000000000000",
@@ -6188,25 +6188,25 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), boost::none, boost::none, 16, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), boost::none, boost::none, 16, {
             "1000000000010000",
             "10000000000100000000000000000000",
             "100000000001000000000000000000000000000000000000",
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), boost::none, boost::none, 31, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), boost::none, boost::none, 31, {
             "1000000000010000000000000000000",
             "10000000000100000000000000000000000000000000000000000000000000",
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), boost::none, boost::none, 32, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), boost::none, boost::none, 32, {
             "10000000000100000000000000000000",
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), boost::none, boost::none, 1, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), boost::none, boost::none, 1, {
             "1",
             "10",
             "100",
@@ -6273,7 +6273,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), boost::none, boost::none, 2, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), boost::none, boost::none, 2, {
             "10",
             "1000",
             "100000",
@@ -6308,7 +6308,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), boost::none, boost::none, 3, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), boost::none, boost::none, 3, {
             "100",
             "100000",
             "100000000",
@@ -6333,7 +6333,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), boost::none, boost::none, 4, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), boost::none, boost::none, 4, {
             "1000",
             "10000000",
             "100000000001",
@@ -6352,7 +6352,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), boost::none, boost::none, 8, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), boost::none, boost::none, 8, {
             "10000000",
             "1000000000010000",
             "100000000001000000000000",
@@ -6363,7 +6363,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), boost::none, boost::none, 10, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), boost::none, boost::none, 10, {
             "1000000000",
             "10000000000100000000",
             "100000000001000000000000000000",
@@ -6373,7 +6373,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), boost::none, boost::none, 11, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), boost::none, boost::none, 11, {
             "10000000000",
             "1000000000010000000000",
             "100000000001000000000000000000000",
@@ -6382,25 +6382,25 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), boost::none, boost::none, 16, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), boost::none, boost::none, 16, {
             "1000000000010000",
             "10000000000100000000000000000000",
             "100000000001000000000000000000000000000000000000",
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), boost::none, boost::none, 31, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), boost::none, boost::none, 31, {
             "1000000000010000000000000000000",
             "10000000000100000000000000000000000000000000000000000000000000",
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), boost::none, boost::none, 32, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), boost::none, boost::none, 32, {
             "10000000000100000000000000000000",
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), boost::none, boost::none, 1, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), boost::none, boost::none, 1, {
             "1",
             "10",
             "100",
@@ -6467,7 +6467,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), boost::none, boost::none, 2, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), boost::none, boost::none, 2, {
             "10",
             "1000",
             "100000",
@@ -6502,7 +6502,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), boost::none, boost::none, 3, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), boost::none, boost::none, 3, {
             "100",
             "100000",
             "100000000",
@@ -6527,7 +6527,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), boost::none, boost::none, 4, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), boost::none, boost::none, 4, {
             "1000",
             "10000000",
             "100000000001",
@@ -6546,7 +6546,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), boost::none, boost::none, 8, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), boost::none, boost::none, 8, {
             "10000000",
             "1000000000010000",
             "100000000001000000000000",
@@ -6557,7 +6557,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), boost::none, boost::none, 10, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), boost::none, boost::none, 10, {
             "1000000000",
             "10000000000100000000",
             "100000000001000000000000000000",
@@ -6567,7 +6567,7 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), boost::none, boost::none, 11, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), boost::none, boost::none, 11, {
             "10000000000",
             "1000000000010000000000",
             "100000000001000000000000000000000",
@@ -6576,20 +6576,20 @@
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), boost::none, boost::none, 16, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), boost::none, boost::none, 16, {
             "1000000000010000",
             "10000000000100000000000000000000",
             "100000000001000000000000000000000000000000000000",
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), boost::none, boost::none, 31, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), boost::none, boost::none, 31, {
             "1000000000010000000000000000000",
             "10000000000100000000000000000000000000000000000000000000000000",
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
         }},
-        {&getEdgesDouble, std::numeric_limits<double>::min(), boost::none, boost::none, 32, {
+        {&getEdgesDoubleForTest, std::numeric_limits<double>::min(), boost::none, boost::none, 32, {
             "10000000000100000000000000000000",
             "1000000000010000000000000000000000000000000000000000000000000000",
             "root",
diff --git a/src/mongo/crypto/test_vectors/mincover_decimal128_precision.cstruct b/src/mongo/crypto/test_vectors/mincover_decimal128_precision.cstruct
new file mode 100644
index 00000000000..a3955ea49ce
--- /dev/null
+++ b/src/mongo/crypto/test_vectors/mincover_decimal128_precision.cstruct
@@ -0,0 +1,394 @@
+// this file was generated using code in
+// https://github.com/10gen/ost1-misc/tree/master/my-app
+//
+
+{ Decimal128("0.000000"), Decimal128("1.638400"), Decimal128("0.000000"), Decimal128("6.500000"), 1, 1,
+R"(000
+0010000
+)"},
+
+{ Decimal128("0.000000"), Decimal128("1.638400"), Decimal128("0.000000"), Decimal128("6.550000"), 1, 2,
+R"(000
+00100
+00101000
+)"},
+
+{ Decimal128("0.000000"), Decimal128("1.638400"), Decimal128("0.000000"), Decimal128("6.553000"), 1, 3,
+R"(000
+0010
+0011000
+00110010
+00110011000
+001100110010
+0011001100110
+)"},
+
+{ Decimal128("0.000000"), Decimal128("1.638400"), Decimal128("0.000000"), Decimal128("6.553600"), 1, 4,
+R"(000
+00100000000000000
+)"},
+
+{ Decimal128("1000000.000000"), Decimal128("20000000.000000"), Decimal128("788545.000000"), Decimal128("340282366920938463463374607431769000000.000000"), 1, 0,
+R"(10101110010000101011110001011110110001000110001000111001100010011001001111011110100000101111110111111111111111111110011111111011
+101011100100001010111100010111101100010001100010001110011000100110010011110111101000001011111101111111111111111111100111111111
+101011100100001010111100010111101100010001100010001110011000100110010011110111101000001011111101111111111111111111101
+10101110010000101011110001011110110001000110001000111001100010011001001111011110100000101111110111111111111111111111
+10101110010000101011110001011110110001000110001000111001100010011001001111011110100000101111111
+1010111001000010101111000101111011000100011000100011100110001001100100111101111010000011
+10101110010000101011110001011110110001000110001000111001100010011001001111011110100001
+1010111001000010101111000101111011000100011000100011100110001001100100111101111010001
+101011100100001010111100010111101100010001100010001110011000100110010011110111101001
+10101110010000101011110001011110110001000110001000111001100010011001001111011110101
+1010111001000010101111000101111011000100011000100011100110001001100100111101111011
+10101110010000101011110001011110110001000110001000111001100010011001001111011111
+101011100100001010111100010111101100010001100010001110011000100110010011111
+1010111001000010101111000101111011000100011000100011100110001001100101
+101011100100001010111100010111101100010001100010001110011000100110011
+1010111001000010101111000101111011000100011000100011100110001001101
+101011100100001010111100010111101100010001100010001110011000100111
+101011100100001010111100010111101100010001100010001110011000101
+10101110010000101011110001011110110001000110001000111001100011
+101011100100001010111100010111101100010001100010001110011001
+10101110010000101011110001011110110001000110001000111001101
+1010111001000010101111000101111011000100011000100011100111
+1010111001000010101111000101111011000100011000100011101
+101011100100001010111100010111101100010001100010001111
+10101110010000101011110001011110110001000110001001
+1010111001000010101111000101111011000100011000101
+101011100100001010111100010111101100010001100011
+1010111001000010101111000101111011000100011001
+101011100100001010111100010111101100010001101
+10101110010000101011110001011110110001000111
+10101110010000101011110001011110110001001
+1010111001000010101111000101111011000101
+101011100100001010111100010111101100011
+1010111001000010101111000101111011001
+101011100100001010111100010111101101
+10101110010000101011110001011110111
+10101110010000101011110001011111
+101011100100001010111100011
+1010111001000010101111001
+101011100100001010111101
+10101110010000101011111
+101011100100001011
+1010111001000011
+10101110010001000
+101011100100010010
+10101110010001001100
+101011100100010011010
+10101110010001001101100
+1010111001000100110110100
+101011100100010011011010100
+1010111001000100110110101010
+101011100100010011011010101100
+1010111001000100110110101011010
+1010111001000100110110101011011000
+1010111001000100110110101011011001000
+1010111001000100110110101011011001001000
+101011100100010011011010101101100100100100
+10101110010001001101101010110110010010010100
+1010111001000100110110101011011001001001010100
+10101110010001001101101010110110010010010101010000
+10101110010001001101101010110110010010010101010001000
+101011100100010011011010101101100100100101010100010010
+1010111001000100110110101011011001001001010101000100110
+101011100100010011011010101101100100100101010100010011100
+1010111001000100110110101011011001001001010101000100111010
+101011100100010011011010101101100100100101010100010011101100
+1010111001000100110110101011011001001001010101000100111011010
+10101110010001001101101010110110010010010101010001001110110110
+1010111001000100110110101011011001001001010101000100111011011100
+1010111001000100110110101011011001001001010101000100111011011101000000
+101011100100010011011010101101100100100101010100010011101101110100000100000
+10101110010001001101101010110110010010010101010001001110110111010000010000100
+101011100100010011011010101101100100100101010100010011101101110100000100001010
+10101110010001001101101010110110010010010101010001001110110111010000010000101100
+1010111001000100110110101011011001001001010101000100111011011101000001000010110100
+10101110010001001101101010110110010010010101010001001110110111010000010000101101010
+1010111001000100110110101011011001001001010101000100111011011101000001000010110101100
+10101110010001001101101010110110010010010101010001001110110111010000010000101101011010
+101011100100010011011010101101100100100101010100010011101101110100000100001011010110110000
+1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100010
+101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001100
+10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110100
+101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101010
+1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010110
+10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101110
+101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011110
+1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111110
+10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111110
+101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111110
+1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111110
+10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111110
+101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111111110
+1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111110
+10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111110
+101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111111111110
+1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111110
+10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111111110
+101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111111111111110
+1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111111110
+10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111111111110
+101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111111111111111110
+1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111111111110
+1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111111111111000
+10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111111111111110010
+101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111111111111111111100110
+1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111111111111001110
+10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111111111111110011110
+101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111111111111111111100111110
+1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111111111111001111110
+10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111111111111110011111110
+1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111111111111001111111100
+10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111111111111110011111111010
+)"},
+
+{ Decimal128("1000000.000000"), Decimal128("20000000.000000"), Decimal128("788544.000000"), Decimal128("340282366920938463463374607431769000000.000000"), 1, 0,
+R"(10101110010000101011110001011110110001000110001000111001100010011001001111011110100000101111110111111111111111111110011111111011
+101011100100001010111100010111101100010001100010001110011000100110010011110111101000001011111101111111111111111111100111111111
+101011100100001010111100010111101100010001100010001110011000100110010011110111101000001011111101111111111111111111101
+10101110010000101011110001011110110001000110001000111001100010011001001111011110100000101111110111111111111111111111
+10101110010000101011110001011110110001000110001000111001100010011001001111011110100000101111111
+1010111001000010101111000101111011000100011000100011100110001001100100111101111010000011
+10101110010000101011110001011110110001000110001000111001100010011001001111011110100001
+1010111001000010101111000101111011000100011000100011100110001001100100111101111010001
+101011100100001010111100010111101100010001100010001110011000100110010011110111101001
+10101110010000101011110001011110110001000110001000111001100010011001001111011110101
+1010111001000010101111000101111011000100011000100011100110001001100100111101111011
+10101110010000101011110001011110110001000110001000111001100010011001001111011111
+101011100100001010111100010111101100010001100010001110011000100110010011111
+1010111001000010101111000101111011000100011000100011100110001001100101
+101011100100001010111100010111101100010001100010001110011000100110011
+1010111001000010101111000101111011000100011000100011100110001001101
+101011100100001010111100010111101100010001100010001110011000100111
+101011100100001010111100010111101100010001100010001110011000101
+10101110010000101011110001011110110001000110001000111001100011
+101011100100001010111100010111101100010001100010001110011001
+10101110010000101011110001011110110001000110001000111001101
+1010111001000010101111000101111011000100011000100011100111
+1010111001000010101111000101111011000100011000100011101
+101011100100001010111100010111101100010001100010001111
+10101110010000101011110001011110110001000110001001
+1010111001000010101111000101111011000100011000101
+101011100100001010111100010111101100010001100011
+1010111001000010101111000101111011000100011001
+101011100100001010111100010111101100010001101
+10101110010000101011110001011110110001000111
+10101110010000101011110001011110110001001
+1010111001000010101111000101111011000101
+101011100100001010111100010111101100011
+1010111001000010101111000101111011001
+101011100100001010111100010111101101
+10101110010000101011110001011110111
+10101110010000101011110001011111
+101011100100001010111100011
+1010111001000010101111001
+101011100100001010111101
+10101110010000101011111
+101011100100001011
+1010111001000011
+10101110010001000
+101011100100010010
+10101110010001001100
+101011100100010011010
+10101110010001001101100
+1010111001000100110110100
+101011100100010011011010100
+1010111001000100110110101010
+101011100100010011011010101100
+1010111001000100110110101011010
+1010111001000100110110101011011000
+1010111001000100110110101011011001000
+1010111001000100110110101011011001001000
+101011100100010011011010101101100100100100
+10101110010001001101101010110110010010010100
+1010111001000100110110101011011001001001010100
+10101110010001001101101010110110010010010101010000
+10101110010001001101101010110110010010010101010001000
+101011100100010011011010101101100100100101010100010010
+1010111001000100110110101011011001001001010101000100110
+101011100100010011011010101101100100100101010100010011100
+1010111001000100110110101011011001001001010101000100111010
+101011100100010011011010101101100100100101010100010011101100
+1010111001000100110110101011011001001001010101000100111011010
+10101110010001001101101010110110010010010101010001001110110110
+1010111001000100110110101011011001001001010101000100111011011100
+1010111001000100110110101011011001001001010101000100111011011101000000
+101011100100010011011010101101100100100101010100010011101101110100000100000
+10101110010001001101101010110110010010010101010001001110110111010000010000100
+101011100100010011011010101101100100100101010100010011101101110100000100001010
+10101110010001001101101010110110010010010101010001001110110111010000010000101100
+1010111001000100110110101011011001001001010101000100111011011101000001000010110100
+10101110010001001101101010110110010010010101010001001110110111010000010000101101010
+1010111001000100110110101011011001001001010101000100111011011101000001000010110101100
+10101110010001001101101010110110010010010101010001001110110111010000010000101101011010
+101011100100010011011010101101100100100101010100010011101101110100000100001011010110110000
+1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100010
+101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001100
+10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110100
+101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101010
+1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010110
+10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101110
+101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011110
+1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111110
+10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111110
+101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111110
+1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111110
+10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111110
+101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111111110
+1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111110
+10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111110
+101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111111111110
+1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111110
+10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111111110
+101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111111111111110
+1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111111110
+10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111111111110
+101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111111111111111110
+1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111111111110
+1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111111111111000
+10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111111111111110010
+101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111111111111111111100110
+1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111111111111001110
+10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111111111111110011110
+101011100100010011011010101101100100100101010100010011101101110100000100001011010110110001101011111111111111111111100111110
+1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111111111111001111110
+10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111111111111110011111110
+1010111001000100110110101011011001001001010101000100111011011101000001000010110101101100011010111111111111111111111001111111100
+10101110010001001101101010110110010010010101010001001110110111010000010000101101011011000110101111111111111111111110011111111010
+)"},
+
+// WRONG - this triggers 128 bits for the range calculation which does not use the precision code path therefore
+// { Decimal128("1000000.000000"), Decimal128("20000000.000000"), Decimal128("1.788545"), Decimal128("34028236692093846346337460743.176900"), 1, 10,
+// R"(0000000000000000000000000000000000000000000000000000000000000000000000000001110100011010100100010011100010101111111
+// 000000000000000000000000000000000000000000000000000000000000000000000000000111010001101010010001001110001011
+// 0000000000000000000000000000000000000000000000000000000000000000000000000001110100011010100100010011100011
+// 00000000000000000000000000000000000000000000000000000000000000000000000000011101000110101001000100111001
+// 0000000000000000000000000000000000000000000000000000000000000000000000000001110100011010100100010011101
+// 000000000000000000000000000000000000000000000000000000000000000000000000000111010001101010010001001111
+// 00000000000000000000000000000000000000000000000000000000000000000000000000011101000110101001000101
+// 0000000000000000000000000000000000000000000000000000000000000000000000000001110100011010100100011
+// 00000000000000000000000000000000000000000000000000000000000000000000000000011101000110101001001
+// 0000000000000000000000000000000000000000000000000000000000000000000000000001110100011010100101
+// 000000000000000000000000000000000000000000000000000000000000000000000000000111010001101010011
+// 0000000000000000000000000000000000000000000000000000000000000000000000000001110100011010101
+// 000000000000000000000000000000000000000000000000000000000000000000000000000111010001101011
+// 0000000000000000000000000000000000000000000000000000000000000000000000000001110100011011
+// 00000000000000000000000000000000000000000000000000000000000000000000000000011101000111
+// 00000000000000000000000000000000000000000000000000000000000000000000000000011101001
+// 0000000000000000000000000000000000000000000000000000000000000000000000000001110101
+// 000000000000000000000000000000000000000000000000000000000000000000000000000111011
+// 0000000000000000000000000000000000000000000000000000000000000000000000000001111
+// 000000000000000000000000000000000000000000000000000000000000000000000000001
+// 00000000000000000000000000000000000000000000000000000000000000000000000001
+// 0000000000000000000000000000000000000000000000000000000000000000000000001
+// 000000000000000000000000000000000000000000000000000000000000000000000001
+// 00000000000000000000000000000000000000000000000000000000000000000000001000
+// 000000000000000000000000000000000000000000000000000000000000000000000010010000
+// 0000000000000000000000000000000000000000000000000000000000000000000000100100010
+// 000000000000000000000000000000000000000000000000000000000000000000000010010001100000
+// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001000
+// 0000000000000000000000000000000000000000000000000000000000000000000000100100011000010010
+// 00000000000000000000000000000000000000000000000000000000000000000000001001000110000100110
+// 00000000000000000000000000000000000000000000000000000000000000000000001001000110000100111000
+// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001001110010
+// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001001110011000
+// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001001110011001000
+// 0000000000000000000000000000000000000000000000000000000000000000000000100100011000010011100110010010
+// 00000000000000000000000000000000000000000000000000000000000000000000001001000110000100111001100100110
+// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001001110011001001110
+// 0000000000000000000000000000000000000000000000000000000000000000000000100100011000010011100110010011110
+// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001001110011001001111100
+// 00000000000000000000000000000000000000000000000000000000000000000000001001000110000100111001100100111110100
+// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001001110011001001111101010
+// )"},
+
+// { Decimal128("1000000.000000"), Decimal128("20000000.000000"), Decimal128("1.788545"), Decimal128("34028236692093846346337460743.176900"), 1, 10,
+// R"(0000000000000000000000000000000000000000000000000000000000000000000000000001110100011010100100010011100010101111111
+// 000000000000000000000000000000000000000000000000000000000000000000000000000111010001101010010001001110001011
+// 0000000000000000000000000000000000000000000000000000000000000000000000000001110100011010100100010011100011
+// 00000000000000000000000000000000000000000000000000000000000000000000000000011101000110101001000100111001
+// 0000000000000000000000000000000000000000000000000000000000000000000000000001110100011010100100010011101
+// 000000000000000000000000000000000000000000000000000000000000000000000000000111010001101010010001001111
+// 00000000000000000000000000000000000000000000000000000000000000000000000000011101000110101001000101
+// 0000000000000000000000000000000000000000000000000000000000000000000000000001110100011010100100011
+// 00000000000000000000000000000000000000000000000000000000000000000000000000011101000110101001001
+// 0000000000000000000000000000000000000000000000000000000000000000000000000001110100011010100101
+// 000000000000000000000000000000000000000000000000000000000000000000000000000111010001101010011
+// 0000000000000000000000000000000000000000000000000000000000000000000000000001110100011010101
+// 000000000000000000000000000000000000000000000000000000000000000000000000000111010001101011
+// 0000000000000000000000000000000000000000000000000000000000000000000000000001110100011011
+// 00000000000000000000000000000000000000000000000000000000000000000000000000011101000111
+// 00000000000000000000000000000000000000000000000000000000000000000000000000011101001
+// 0000000000000000000000000000000000000000000000000000000000000000000000000001110101
+// 000000000000000000000000000000000000000000000000000000000000000000000000000111011
+// 0000000000000000000000000000000000000000000000000000000000000000000000000001111
+// 000000000000000000000000000000000000000000000000000000000000000000000000001
+// 00000000000000000000000000000000000000000000000000000000000000000000000001
+// 0000000000000000000000000000000000000000000000000000000000000000000000001
+// 000000000000000000000000000000000000000000000000000000000000000000000001
+// 00000000000000000000000000000000000000000000000000000000000000000000001000
+// 000000000000000000000000000000000000000000000000000000000000000000000010010000
+// 0000000000000000000000000000000000000000000000000000000000000000000000100100010
+// 000000000000000000000000000000000000000000000000000000000000000000000010010001100000
+// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001000
+// 0000000000000000000000000000000000000000000000000000000000000000000000100100011000010010
+// 00000000000000000000000000000000000000000000000000000000000000000000001001000110000100110
+// 00000000000000000000000000000000000000000000000000000000000000000000001001000110000100111000
+// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001001110010
+// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001001110011000
+// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001001110011001000
+// 0000000000000000000000000000000000000000000000000000000000000000000000100100011000010011100110010010
+// 00000000000000000000000000000000000000000000000000000000000000000000001001000110000100111001100100110
+// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001001110011001001110
+// 0000000000000000000000000000000000000000000000000000000000000000000000100100011000010011100110010011110
+// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001001110011001001111100
+// 00000000000000000000000000000000000000000000000000000000000000000000001001000110000100111001100100111110100
+// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001001110011001001111101010
+// )"},
+
+// WRONG bits calculation in Java code
+// { Decimal128("1000000.000000"), Decimal128("20000000.000000"), Decimal128("1.788545"), Decimal128("34028236692093846346337460743.176900"), 1, 9,
+// R"(0000000000000000000000000000000000000000000000000000000000000000000000000001110100011010100100010011100010101111111
+// 000000000000000000000000000000000000000000000000000000000000000000000000000111010001101010010001001110001011
+// 0000000000000000000000000000000000000000000000000000000000000000000000000001110100011010100100010011100011
+// 00000000000000000000000000000000000000000000000000000000000000000000000000011101000110101001000100111001
+// 0000000000000000000000000000000000000000000000000000000000000000000000000001110100011010100100010011101
+// 000000000000000000000000000000000000000000000000000000000000000000000000000111010001101010010001001111
+// 00000000000000000000000000000000000000000000000000000000000000000000000000011101000110101001000101
+// 0000000000000000000000000000000000000000000000000000000000000000000000000001110100011010100100011
+// 00000000000000000000000000000000000000000000000000000000000000000000000000011101000110101001001
+// 0000000000000000000000000000000000000000000000000000000000000000000000000001110100011010100101
+// 000000000000000000000000000000000000000000000000000000000000000000000000000111010001101010011
+// 0000000000000000000000000000000000000000000000000000000000000000000000000001110100011010101
+// 000000000000000000000000000000000000000000000000000000000000000000000000000111010001101011
+// 0000000000000000000000000000000000000000000000000000000000000000000000000001110100011011
+// 00000000000000000000000000000000000000000000000000000000000000000000000000011101000111
+// 00000000000000000000000000000000000000000000000000000000000000000000000000011101001
+// 0000000000000000000000000000000000000000000000000000000000000000000000000001110101
+// 000000000000000000000000000000000000000000000000000000000000000000000000000111011
+// 0000000000000000000000000000000000000000000000000000000000000000000000000001111
+// 000000000000000000000000000000000000000000000000000000000000000000000000001
+// 00000000000000000000000000000000000000000000000000000000000000000000000001
+// 0000000000000000000000000000000000000000000000000000000000000000000000001
+// 000000000000000000000000000000000000000000000000000000000000000000000001
+// 00000000000000000000000000000000000000000000000000000000000000000000001000
+// 000000000000000000000000000000000000000000000000000000000000000000000010010000
+// 0000000000000000000000000000000000000000000000000000000000000000000000100100010
+// 000000000000000000000000000000000000000000000000000000000000000000000010010001100000
+// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001000
+// 0000000000000000000000000000000000000000000000000000000000000000000000100100011000010010
+// 00000000000000000000000000000000000000000000000000000000000000000000001001000110000100110
+// 00000000000000000000000000000000000000000000000000000000000000000000001001000110000100111000
+// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001001110010
+// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001001110011000
+// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001001110011001000
+// 0000000000000000000000000000000000000000000000000000000000000000000000100100011000010011100110010010
+// 00000000000000000000000000000000000000000000000000000000000000000000001001000110000100111001100100110
+// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001001110011001001110
+// 0000000000000000000000000000000000000000000000000000000000000000000000100100011000010011100110010011110
+// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001001110011001001111100
+// 00000000000000000000000000000000000000000000000000000000000000000000001001000110000100111001100100111110100
+// 000000000000000000000000000000000000000000000000000000000000000000000010010001100001001110011001001111101010
+// )"},
+
diff --git a/src/mongo/crypto/test_vectors/mincover_double_precision.cstruct b/src/mongo/crypto/test_vectors/mincover_double_precision.cstruct
new file mode 100644
index 00000000000..374a3e44497
--- /dev/null
+++ b/src/mongo/crypto/test_vectors/mincover_double_precision.cstruct
@@ -0,0 +1,705 @@
+// this file was generated using code in
+// https://github.com/10gen/ost1-misc/tree/master/my-app
+//
+
+{ 0.000000, 1.638400, 0.000000, 6.500000, 1, 1,
+R"(000
+0010000
+)"},
+
+{ 0.000000, 1.638400, 0.000000, 6.550000, 1, 2,
+R"(000
+00100
+00101000
+)"},
+
+{ 0.000000, 1.638400, 0.000000, 6.553000, 1, 3,
+R"(000
+0010
+0011000
+00110010
+00110011000
+001100110010
+0011001100110
+)"},
+
+{ 0.000000, 1.638400, 0.000000, 6.553600, 1, 4,
+R"(000
+00100000000000000
+)"},
+
+{ 10000.000000, 20000.000000, 383.000000, 18446744073709552000.000000, 1, 0,
+R"(110000001100001110001
+11000000110000111001
+1100000011000011101
+110000001100001111
+11000000110001
+1100000011001
+110000001101000
+1100000011010010
+11000000110100110
+110000001101001110000
+1100000011010011100010000000000000000000000000000000000000000000
+)"},
+
+{ 10000.000000, 20000.000000, 384.000000, 18446744073709552000.000000, 1, 0,
+R"(110000001100001110001
+11000000110000111001
+1100000011000011101
+110000001100001111
+11000000110001
+1100000011001
+110000001101000
+1100000011010010
+11000000110100110
+110000001101001110000
+1100000011010011100010000000000000000000000000000000000000000000
+)"},
+
+// WRONG from Java code - too many zeros are used as a prefix, too many results
+// { 10000.000000, 20000.000000, 1.384000, 184467440737095.530000, 1, 5,
+// R"(0000000000000000000000000000000000100110001001000100011
+// 00000000000000000000000000000000001001100010010001001
+// 0000000000000000000000000000000000100110001001000101
+// 000000000000000000000000000000000010011000100100011
+// 0000000000000000000000000000000000100110001001001
+// 000000000000000000000000000000000010011000100101
+// 00000000000000000000000000000000001001100010011
+// 000000000000000000000000000000000010011000101
+// 00000000000000000000000000000000001001100011
+// 000000000000000000000000000000000010011001
+// 00000000000000000000000000000000001001101
+// 0000000000000000000000000000000000100111
+// 0000000000000000000000000000000000101
+// 000000000000000000000000000000000011
+// 0000000000000000000000000000000001000
+// 00000000000000000000000000000000010010
+// 000000000000000000000000000000000100110000
+// 000000000000000000000000000000000100110001000
+// 000000000000000000000000000000000100110001001000
+// 0000000000000000000000000000000001001100010010010
+// 00000000000000000000000000000000010011000100100110
+// 000000000000000000000000000000000100110001001001110
+// 000000000000000000000000000000000100110001001001111000
+// 0000000000000000000000000000000001001100010010011110010
+// 0000000000000000000000000000000001001100010010011110011000
+// )"},
+
+// { 10000.000000, 20000.000000, 0.384000, 184467440737095.530000, 1, 5,
+// R"(00000000000000000000000000000000001001100010010101
+// 0000000000000000000000000000000000100110001001011
+// 00000000000000000000000000000000001001100010011
+// 000000000000000000000000000000000010011000101
+// 00000000000000000000000000000000001001100011
+// 000000000000000000000000000000000010011001
+// 00000000000000000000000000000000001001101
+// 0000000000000000000000000000000000100111
+// 0000000000000000000000000000000000101
+// 000000000000000000000000000000000011
+// 0000000000000000000000000000000001000
+// 00000000000000000000000000000000010010
+// 000000000000000000000000000000000100110000
+// 000000000000000000000000000000000100110001000
+// 00000000000000000000000000000000010011000100100
+// 0000000000000000000000000000000001001100010010100
+// 00000000000000000000000000000000010011000100101010
+// 000000000000000000000000000000000100110001001010110
+// 0000000000000000000000000000000001001100010010101110000000
+// )"},
+
+// { 10000.000000, 20000.000000, 0.384000, 184467440737095.530000, 1, 4,
+// R"(00000000000000000000000000000000001001100010010101
+// 0000000000000000000000000000000000100110001001011
+// 00000000000000000000000000000000001001100010011
+// 000000000000000000000000000000000010011000101
+// 00000000000000000000000000000000001001100011
+// 000000000000000000000000000000000010011001
+// 00000000000000000000000000000000001001101
+// 0000000000000000000000000000000000100111
+// 0000000000000000000000000000000000101
+// 000000000000000000000000000000000011
+// 0000000000000000000000000000000001000
+// 00000000000000000000000000000000010010
+// 000000000000000000000000000000000100110000
+// 000000000000000000000000000000000100110001000
+// 00000000000000000000000000000000010011000100100
+// 0000000000000000000000000000000001001100010010100
+// 00000000000000000000000000000000010011000100101010
+// 000000000000000000000000000000000100110001001010110
+// 0000000000000000000000000000000001001100010010101110000000
+// )"},
+
+{ 13.000000, 192.000000, 2.000000, 314.000000, 1, 0,
+R"(000001011
+0000011
+00001
+0001
+001
+0100
+01010
+010110
+0101110
+01011110
+010111110
+)"},
+
+{ 13.000000, 192.000000, 2.700000, 314.100000, 1, 1,
+R"(000001100111
+000001101
+00000111
+00001
+0001
+001
+010
+0110
+011100
+0111010
+0111011000
+01110110010
+)"},
+
+{ 13.000000, 192.000000, 2.710000, 314.150000, 1, 2,
+R"(000010000000101
+00001000000011
+000010000001
+00001000001
+0000100001
+000010001
+00001001
+0000101
+000011
+0001
+001
+01
+1000
+1001000
+10010010
+100100110
+1001001110
+10010011110
+10010011111000
+)"},
+
+{ 13.000000, 192.000000, 2.718000, 314.159000, 1, 3,
+R"(000001010000010101
+00000101000001011
+000001010000011
+0000010100001
+000001010001
+00000101001
+0000010101
+000001011
+0000011
+00001
+0001
+001
+0100
+01010
+010110
+0101110000
+01011100010
+0101110001100
+01011100011010
+010111000110110000
+0101110001101100010
+)"},
+
+{ 13.000000, 192.000000, 2.718200, 314.159200, 1, 4,
+R"(000001100100011010001
+00000110010001101001
+0000011001000110101
+000001100100011011
+0000011001000111
+0000011001001
+000001100101
+00000110011
+000001101
+00000111
+00001
+0001
+001
+010
+0110
+0111000
+01110010
+011100110
+01110011100000
+011100111000010
+0111001110000110
+011100111000011100
+011100111000011101000
+0111001110000111010010
+)"},
+
+{ 13.000000, 192.000000, 2.718280, 314.159260, 1, 5,
+R"(00000111110110000010011
+000001111101100000101
+00000111110110000011
+000001111101100001
+00000111110110001
+0000011111011001
+000001111101101
+00000111110111
+00000111111
+00001
+0001
+001
+01
+1000
+1001000000
+10010000010
+1001000001100
+1001000001101000
+10010000011010010000
+1001000001101001000100
+10010000011010010001010
+1001000001101001000101100
+)"},
+
+{ 13.000000, 192.000000, 2.718281, 314.159265, 1, 6,
+R"(0000010011100111000101111011
+00000100111001110001011111
+000001001110011100011
+0000010011100111001
+000001001110011101
+00000100111001111
+0000010011101
+000001001111
+00000101
+0000011
+00001
+0001
+001
+0100
+01010
+0101100
+0101101000
+0101101001000000
+01011010010000010
+0101101001000001100
+010110100100000110100
+0101101001000001101010
+010110100100000110101100
+0101101001000001101011010
+01011010010000011010110110
+)"},
+
+{ 13.000000, 192.000000, 2.718282, 314.159265, 1, 7,
+R"(000001100010000011011101100111
+000001100010000011011101101
+00000110001000001101110111
+00000110001000001101111
+0000011000100000111
+0000011000100001
+000001100010001
+00000110001001
+0000011000101
+000001100011
+0000011001
+000001101
+00000111
+00001
+0001
+001
+010
+0110
+011100000
+0111000010
+011100001100
+011100001101000
+01110000110100100000
+011100001101001000010
+011100001101001000011000
+0111000011010010000110010000
+01110000110100100001100100010
+011100001101001000011001000110
+01110000110100100001100100011100
+)"},
+
+// Numerical imprecision - the constant "e" as 2.718282 is not a precise double
+// { 13.000000, 192.000000, 2.718282, 314.159265, 1, 8,
+// R"(0000011110101001000101010000010101
+// 000001111010100100010101000001011
+// 0000011110101001000101010000011
+// 00000111101010010001010100001
+// 0000011110101001000101010001
+// 000001111010100100010101001
+// 00000111101010010001010101
+// 0000011110101001000101011
+// 00000111101010010001011
+// 000001111010100100011
+// 0000011110101001001
+// 000001111010100101
+// 00000111101010011
+// 000001111010101
+// 00000111101011
+// 000001111011
+// 0000011111
+// 00001
+// 0001
+// 001
+// 01
+// 10000
+// 100010
+// 10001100
+// 10001101000000
+// 100011010000010
+// 10001101000001100
+// 10001101000001101000
+// 100011010000011010010
+// 1000110100000110100110
+// 10001101000001101001110
+// 100011010000011010011110
+// 10001101000001101001111100
+// 100011010000011010011111010
+// 100011010000011010011111011000
+// 10001101000001101001111101100100
+// 1000110100000110100111110110010100
+// 10001101000001101001111101100101010
+// )"},
+
+// { 13.000000, 192.000000, 2.718282, 314.159265, 1, 9,
+// R"(0000010011001001101011010010001100111
+// 0000010011001001101011010010001101
+// 000001001100100110101101001000111
+// 000001001100100110101101001001
+// 00000100110010011010110100101
+// 0000010011001001101011010011
+// 00000100110010011010110101
+// 0000010011001001101011011
+// 00000100110010011010111
+// 00000100110010011011
+// 000001001100100111
+// 000001001100101
+// 00000100110011
+// 000001001101
+// 00000100111
+// 00000101
+// 0000011
+// 00001
+// 0001
+// 001
+// 0100
+// 01010
+// 01011000000
+// 01011000001000
+// 0101100000100100000
+// 01011000001001000010000
+// 010110000010010000100010
+// 0101100000100100001000110
+// 0101100000100100001000111000
+// 01011000001001000010001110010
+// 010110000010010000100011100110
+// 0101100000100100001000111001110
+// 01011000001001000010001110011110
+// 01011000001001000010001110011111000
+// 010110000010010000100011100111110010
+// 0101100000100100001000111001111100110
+// 010110000010010000100011100111110011100
+// )"},
+
+// { 13.000000, 192.000000, 2.718282, 314.159265, 1, 10,
+// R"(0000010111111100000110000110110000000101
+// 000001011111110000011000011011000000011
+// 0000010111111100000110000110110000001
+// 000001011111110000011000011011000001
+// 00000101111111000001100001101100001
+// 0000010111111100000110000110110001
+// 000001011111110000011000011011001
+// 00000101111111000001100001101101
+// 0000010111111100000110000110111
+// 0000010111111100000110000111
+// 0000010111111100000110001
+// 000001011111110000011001
+// 00000101111111000001101
+// 0000010111111100000111
+// 0000010111111100001
+// 000001011111110001
+// 00000101111111001
+// 0000010111111101
+// 000001011111111
+// 0000011
+// 00001
+// 0001
+// 001
+// 010
+// 01100
+// 011010
+// 0110110
+// 01101110000
+// 0110111000100
+// 01101110001010
+// 0110111000101100
+// 0110111000101101000
+// 011011100010110100100
+// 0110111000101101001010
+// 0110111000101101001011000
+// 011011100010110100101100100000
+// 0110111000101101001011001000010
+// 01101110001011010010110010000110
+// 01101110001011010010110010000111000000
+// 0110111000101101001011001000011100000100
+// 011011100010110100101100100001110000010100
+// )"},
+
+// { 13.000000, 192.000000, 2.718282, 314.159265, 1, 11,
+// R"(000001110111101100011110100001110000011000011
+// 0000011101111011000111101000011100000110001
+// 000001110111101100011110100001110000011001
+// 00000111011110110001111010000111000001101
+// 0000011101111011000111101000011100000111
+// 0000011101111011000111101000011100001
+// 000001110111101100011110100001110001
+// 00000111011110110001111010000111001
+// 0000011101111011000111101000011101
+// 000001110111101100011110100001111
+// 00000111011110110001111010001
+// 0000011101111011000111101001
+// 000001110111101100011110101
+// 00000111011110110001111011
+// 000001110111101100011111
+// 0000011101111011001
+// 000001110111101101
+// 00000111011110111
+// 00000111011111
+// 000001111
+// 00001
+// 0001
+// 001
+// 01
+// 10000
+// 10001000
+// 100010010
+// 10001001100
+// 100010011010
+// 1000100110110
+// 100010011011100000
+// 1000100110111000010
+// 10001001101110000110
+// 1000100110111000011100
+// 10001001101110000111010
+// 100010011011100001110110
+// 1000100110111000011101110
+// 100010011011100001110111100
+// 10001001101110000111011110100
+// 100010011011100001110111101010000
+// 1000100110111000011101111010100010
+// 10001001101110000111011110101000110000
+// 100010011011100001110111101010001100010
+// 1000100110111000011101111010100011000110000
+// )"},
+
+// { 13.000000, 192.000000, 2.718282, 314.159265, 1, 12,
+// R"(0000010010101100111100110001010001100011110010101
+// 000001001010110011110011000101000110001111001011
+// 0000010010101100111100110001010001100011110011
+// 00000100101011001111001100010100011000111101
+// 0000010010101100111100110001010001100011111
+// 00000100101011001111001100010100011001
+// 0000010010101100111100110001010001101
+// 000001001010110011110011000101000111
+// 000001001010110011110011000101001
+// 00000100101011001111001100010101
+// 0000010010101100111100110001011
+// 00000100101011001111001100011
+// 000001001010110011110011001
+// 00000100101011001111001101
+// 0000010010101100111100111
+// 0000010010101100111101
+// 000001001010110011111
+// 0000010010101101
+// 000001001010111
+// 000001001011
+// 0000010011
+// 00000101
+// 0000011
+// 00001
+// 0001
+// 001
+// 0100
+// 010100
+// 0101010
+// 010101100000
+// 010101100001000
+// 0101011000010010
+// 010101100001001100
+// 010101100001001101000
+// 01010110000100110100100
+// 0101011000010011010010100
+// 01010110000100110100101010
+// 01010110000100110100101011000
+// 01010110000100110100101011001000
+// 0101011000010011010010101100100100
+// 01010110000100110100101011001001010
+// 010101100001001101001010110010010110
+// 0101011000010011010010101100100101110
+// 010101100001001101001010110010010111100
+// 0101011000010011010010101100100101111010
+// 01010110000100110100101011001001011110110
+// 010101100001001101001010110010010111101110
+// 010101100001001101001010110010010111101111000
+// 01010110000100110100101011001001011110111100100
+// 010101100001001101001010110010010111101111001010
+// )"},
+
+// { 13.000000, 192.000000, 2.718282, 314.159265, 1, 13,
+// R"(0000000010010101100111100110001010001100011110010101
+// 000000001001010110011110011000101000110001111001011
+// 0000000010010101100111100110001010001100011110011
+// 00000000100101011001111001100010100011000111101
+// 0000000010010101100111100110001010001100011111
+// 00000000100101011001111001100010100011001
+// 0000000010010101100111100110001010001101
+// 000000001001010110011110011000101000111
+// 000000001001010110011110011000101001
+// 00000000100101011001111001100010101
+// 0000000010010101100111100110001011
+// 00000000100101011001111001100011
+// 000000001001010110011110011001
+// 00000000100101011001111001101
+// 0000000010010101100111100111
+// 0000000010010101100111101
+// 000000001001010110011111
+// 0000000010010101101
+// 000000001001010111
+// 000000001001011
+// 0000000010011
+// 00000000101
+// 0000000011
+// 00000001
+// 0000001
+// 000001
+// 0000100
+// 000010100
+// 0000101010
+// 000010101100000
+// 000010101100001000
+// 0000101011000010010
+// 000010101100001001100
+// 000010101100001001101000
+// 00001010110000100110100100
+// 0000101011000010011010010100
+// 00001010110000100110100101010
+// 00001010110000100110100101011000
+// 00001010110000100110100101011001000
+// 0000101011000010011010010101100100100
+// 00001010110000100110100101011001001010
+// 000010101100001001101001010110010010110
+// 0000101011000010011010010101100100101110
+// 000010101100001001101001010110010010111100
+// 0000101011000010011010010101100100101111010
+// 00001010110000100110100101011001001011110110
+// 000010101100001001101001010110010010111101110
+// 000010101100001001101001010110010010111101111000
+// 00001010110000100110100101011001001011110111100100
+// 000010101100001001101001010110010010111101111001010
+// )"},
+
+// { 13.000000, 192.000000, 2.718282, 314.159265, 1, 14,
+// R"(000001110100111000111011110011111101101111101100011
+// 0000011101001110001110111100111111011011111011001
+// 000001110100111000111011110011111101101111101101
+// 00000111010011100011101111001111110110111110111
+// 00000111010011100011101111001111110110111111
+// 00000111010011100011101111001111110111
+// 00000111010011100011101111001111111
+// 0000011101001110001110111101
+// 000001110100111000111011111
+// 0000011101001110001111
+// 000001110100111001
+// 00000111010011101
+// 0000011101001111
+// 000001110101
+// 00000111011
+// 000001111
+// 00001
+// 0001
+// 001
+// 01
+// 100000
+// 1000010
+// 1000011000
+// 10000110010
+// 100001100110
+// 1000011001110
+// 10000110011110
+// 100001100111110
+// 1000011001111110000
+// 1000011001111110001000
+// 1000011001111110001001000
+// 10000110011111100010010010
+// 1000011001111110001001001100
+// 10000110011111100010010011010
+// 1000011001111110001001001101100
+// 100001100111111000100100110110100
+// 1000011001111110001001001101101010
+// 100001100111111000100100110110101100
+// 1000011001111110001001001101101011010000
+// 100001100111111000100100110110101101000100
+// 1000011001111110001001001101101011010001010
+// 100001100111111000100100110110101101000101100
+// 1000011001111110001001001101101011010001011010
+// 10000110011111100010010011011010110100010110110000
+// 100001100111111000100100110110101101000101101100010
+// 1000011001111110001001001101101011010001011011000110000
+// )"},
+
+// { 13.000000, 192.000000, 2.718282, 314.159265, 1, 15,
+// R"(00000100100100001110010101100001111010010111001110111011011
+// 000001001001000011100101011000011110100101110011101110111
+// 000001001001000011100101011000011110100101110011101111
+// 00000100100100001110010101100001111010010111001111
+// 0000010010010000111001010110000111101001011101
+// 000001001001000011100101011000011110100101111
+// 00000100100100001110010101100001111010011
+// 000001001001000011100101011000011110101
+// 00000100100100001110010101100001111011
+// 000001001001000011100101011000011111
+// 0000010010010000111001010110001
+// 000001001001000011100101011001
+// 00000100100100001110010101101
+// 0000010010010000111001010111
+// 0000010010010000111001011
+// 00000100100100001110011
+// 000001001001000011101
+// 00000100100100001111
+// 0000010010010001
+// 000001001001001
+// 00000100100101
+// 0000010010011
+// 00000100101
+// 0000010011
+// 00000101
+// 0000011
+// 00001
+// 0001
+// 001
+// 0100
+// 010100
+// 0101010000000
+// 01010100000010
+// 010101000000110
+// 01010100000011100
+// 010101000000111010
+// 01010100000011101100
+// 0101010000001110110100
+// 01010100000011101101010
+// 010101000000111011010110
+// 01010100000011101101011100000
+// 010101000000111011010111000010000
+// 0101010000001110110101110000100010
+// 010101000000111011010111000010001100000
+// 01010100000011101101011100001000110000100
+// 010101000000111011010111000010001100001010
+// 0101010000001110110101110000100011000010110
+// 01010100000011101101011100001000110000101110000
+// 010101000000111011010111000010001100001011100010
+// 0101010000001110110101110000100011000010111000110
+// 010101000000111011010111000010001100001011100011100
+// 0101010000001110110101110000100011000010111000111010
+// 01010100000011101101011100001000110000101110001110110
+// 0101010000001110110101110000100011000010111000111011100
+// 01010100000011101101011100001000110000101110001110111010
+// 010101000000111011010111000010001100001011100011101110110
+// )"},
+
diff --git a/src/mongo/platform/decimal128.cpp b/src/mongo/platform/decimal128.cpp
index 630d2037b50..04d18f2d211 100644
--- a/src/mongo/platform/decimal128.cpp
+++ b/src/mongo/platform/decimal128.cpp
@@ -893,6 +893,15 @@ Decimal128 Decimal128::power(const Decimal128& other,
     return Decimal128{libraryTypeToValue(result)}.add(kLargestNegativeExponentZero);
 }
 
+Decimal128 Decimal128::scale(int n, RoundingMode roundMode) const {
+    std::uint32_t throwAwayFlag = 0;
+    BID_UINT128 x = decimal128ToLibraryType(_value);
+
+    BID_UINT128 result = bid128_scalbn(x, n, roundMode, &throwAwayFlag);
+    return Decimal128{libraryTypeToValue(result)};
+    ;
+}
+
 Decimal128 Decimal128::nonNormalizingQuantize(const Decimal128& other,
                                               RoundingMode roundMode) const {
     std::uint32_t throwAwayFlag = 0;
diff --git a/src/mongo/platform/decimal128.h b/src/mongo/platform/decimal128.h
index 34002337786..6e788f75d8b 100644
--- a/src/mongo/platform/decimal128.h
+++ b/src/mongo/platform/decimal128.h
@@ -487,6 +487,8 @@ public:
     Decimal128 squareRoot(std::uint32_t* signalingFlags,
                           RoundingMode roundMode = kRoundTiesToEven) const;
 
+    Decimal128 scale(int n, RoundingMode roundMode = kRoundTiesToEven) const;
+
     /**
      * This function quantizes the current decimal given a quantum reference
      */