Skip to content

Commit 64d2924

Browse files
asfernandesasfernandes
committed
Make boost not required in the tests
1 parent 9203811 commit 64d2924

7 files changed

Lines changed: 474 additions & 71 deletions

File tree

‎AGENTS.md‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -20,6 +20,5 @@
2020
- Use `cmake --build --preset default` from the repo root.
2121
2222
### Tests
23-
- Test code can use Boost.Multiprecision without conditional compilation.
2423
- Run the Boost.Test suite with `ctest --preset default --verbose`.
2524
- Boost.Test options can be used with environments variables like `BOOST_TEST_LOG_LEVEL=all`.

‎src/fb-cpp/Client.h‎

Lines changed: 17 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -94,6 +94,7 @@ namespace fbcpp
9494
Client(Client&& o) noexcept
9595
: master{o.master},
9696
util{o.util},
97+
int128Util{o.int128Util},
9798
decFloat16Util{o.decFloat16Util},
9899
decFloat34Util{o.decFloat34Util}
99100
#if FB_CPP_USE_BOOST_DLL != 0
@@ -103,6 +104,7 @@ namespace fbcpp
103104
{
104105
o.master = nullptr;
105106
o.util = nullptr;
107+
o.int128Util = nullptr;
106108
o.decFloat16Util = nullptr;
107109
o.decFloat34Util = nullptr;
108110
}
@@ -149,6 +151,20 @@ namespace fbcpp
149151
return util;
150152
}
151153

154+
///
155+
/// Returns a Firebird IInt128 interface.
156+
///
157+
template <std::derived_from<fb::IStatus> StatusType>
158+
fb::IInt128* getInt128Util(StatusType* status)
159+
{
160+
assert(status);
161+
162+
if (!int128Util)
163+
int128Util = getUtil()->getInt128(status);
164+
165+
return int128Util;
166+
}
167+
152168
///
153169
/// Returns a Firebird IDecFloat16 interface.
154170
///
@@ -194,6 +210,7 @@ namespace fbcpp
194210
private:
195211
fb::IMaster* master;
196212
fb::IUtil* util = nullptr;
213+
fb::IInt128* int128Util = nullptr;
197214
fb::IDecFloat16* decFloat16Util = nullptr;
198215
fb::IDecFloat34* decFloat34Util = nullptr;
199216
#if FB_CPP_USE_BOOST_DLL != 0

‎src/fb-cpp/Statement.h‎

Lines changed: 16 additions & 56 deletions
Original file line numberDiff line numberDiff line change
@@ -1044,9 +1044,6 @@ namespace fbcpp
10441044
case DescriptorAdjustedType::INT16:
10451045
case DescriptorAdjustedType::INT32:
10461046
case DescriptorAdjustedType::INT64:
1047-
#if FB_CPP_USE_BOOST_MULTIPRECISION != 0
1048-
case DescriptorAdjustedType::INT128:
1049-
#endif
10501047
{
10511048
std::string strValue(value);
10521049
int scale = 0;
@@ -1066,47 +1063,6 @@ namespace fbcpp
10661063
strValue.erase(dotPos, 1);
10671064
}
10681065

1069-
#if FB_CPP_USE_BOOST_MULTIPRECISION != 0
1070-
const auto parseDecimalToBoostInt128 = [this](std::string_view text)
1071-
{
1072-
bool isNegative = false;
1073-
std::size_t pos = 0;
1074-
1075-
if (!text.empty() && (text.front() == '+' || text.front() == '-'))
1076-
{
1077-
isNegative = text.front() == '-';
1078-
++pos;
1079-
}
1080-
1081-
if (pos == text.size())
1082-
this->numericConverter.throwConversionErrorFromString(std::string{text});
1083-
1084-
BoostInt128 result{};
1085-
1086-
for (; pos < text.size(); ++pos)
1087-
{
1088-
const char c = text[pos];
1089-
1090-
if (c < '0' || c > '9')
1091-
this->numericConverter.throwConversionErrorFromString(std::string{text});
1092-
1093-
result *= 10;
1094-
result += static_cast<int>(c - '0');
1095-
}
1096-
1097-
return isNegative ? -result : result;
1098-
};
1099-
1100-
auto scaledValue = ScaledBoostInt128{parseDecimalToBoostInt128(strValue), scale};
1101-
1102-
if (scale != descriptor.scale)
1103-
{
1104-
scaledValue.value = numericConverter.numberToNumber<BoostInt128>(scaledValue, descriptor.scale);
1105-
scaledValue.scale = descriptor.scale;
1106-
}
1107-
1108-
setScaledBoostInt128(index, scaledValue);
1109-
#else
11101066
static_assert(sizeof(long long) == sizeof(std::int64_t));
11111067
std::int64_t intValue;
11121068
const auto convResult =
@@ -1123,10 +1079,19 @@ namespace fbcpp
11231079
}
11241080

11251081
setScaledInt64(index, scaledValue);
1126-
#endif
11271082
return;
11281083
}
11291084

1085+
case DescriptorAdjustedType::INT128:
1086+
{
1087+
std::string strValue(value);
1088+
attachment.getClient()
1089+
.getInt128Util(&statusWrapper)
1090+
->fromString(&statusWrapper, descriptor.scale, strValue.c_str(),
1091+
reinterpret_cast<OpaqueInt128*>(&message[descriptor.offset]));
1092+
break;
1093+
}
1094+
11301095
case DescriptorAdjustedType::FLOAT:
11311096
case DescriptorAdjustedType::DOUBLE:
11321097
{
@@ -1172,6 +1137,7 @@ namespace fbcpp
11721137
calendarConverter.stringToOpaqueTimestampTz(value);
11731138
break;
11741139
#if FB_CPP_USE_BOOST_MULTIPRECISION != 0
1140+
// FIXME: use IDecFloat
11751141
case DescriptorAdjustedType::DECFLOAT16:
11761142
case DescriptorAdjustedType::DECFLOAT34:
11771143
try
@@ -2025,12 +1991,9 @@ namespace fbcpp
20251991
return numericConverter.numberToString(
20261992
ScaledInt64{*reinterpret_cast<const std::int64_t*>(data), descriptor.scale});
20271993

2028-
#if FB_CPP_USE_BOOST_MULTIPRECISION != 0
20291994
case DescriptorAdjustedType::INT128:
2030-
return numericConverter.numberToString(ScaledBoostInt128{
2031-
numericConverter.opaqueInt128ToBoostInt128(*reinterpret_cast<const OpaqueInt128*>(data)),
2032-
descriptor.scale});
2033-
#endif
1995+
return numericConverter.opaqueInt128ToString(
1996+
*reinterpret_cast<const OpaqueInt128*>(data), descriptor.scale);
20341997

20351998
case DescriptorAdjustedType::FLOAT:
20361999
return numericConverter.numberToString(*reinterpret_cast<const float*>(data));
@@ -2054,15 +2017,11 @@ namespace fbcpp
20542017
return calendarConverter.opaqueTimestampTzToString(
20552018
*reinterpret_cast<const OpaqueTimestampTz*>(data));
20562019

2057-
#if FB_CPP_USE_BOOST_MULTIPRECISION != 0
20582020
case DescriptorAdjustedType::DECFLOAT16:
2059-
return numericConverter.numberToString(numericConverter.opaqueDecFloat16ToBoostDecFloat16(
2060-
*reinterpret_cast<const OpaqueDecFloat16*>(data)));
2021+
return numericConverter.opaqueDecFloat16ToString(*reinterpret_cast<const OpaqueDecFloat16*>(data));
20612022

20622023
case DescriptorAdjustedType::DECFLOAT34:
2063-
return numericConverter.numberToString(numericConverter.opaqueDecFloat34ToBoostDecFloat34(
2064-
*reinterpret_cast<const OpaqueDecFloat34*>(data)));
2065-
#endif
2024+
return numericConverter.opaqueDecFloat34ToString(*reinterpret_cast<const OpaqueDecFloat34*>(data));
20662025

20672026
case DescriptorAdjustedType::STRING:
20682027
return std::string{reinterpret_cast<const char*>(data + sizeof(std::uint16_t)),
@@ -2213,6 +2172,7 @@ namespace fbcpp
22132172
std::optional<BoostDecFloat34> boostDecFloat34;
22142173
#endif
22152174

2175+
// FIXME: Use IUtil
22162176
switch (descriptor.adjustedType)
22172177
{
22182178
#if FB_CPP_USE_BOOST_MULTIPRECISION != 0

‎src/test/Client.cpp‎

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -43,4 +43,11 @@ BOOST_AUTO_TEST_CASE(isNotValidAfterMove)
4343
BOOST_CHECK_EQUAL(client1.isValid(), false);
4444
}
4545

46+
#if FB_CPP_USE_BOOST_DLL != 0
47+
BOOST_AUTO_TEST_CASE(loadWithBoostDll)
48+
{
49+
BOOST_CHECK_THROW(Client("invalid_library_name"), boost::system::system_error);
50+
}
51+
#endif
52+
4653
BOOST_AUTO_TEST_SUITE_END()

‎src/test/NumericConverter.cpp‎

Lines changed: 29 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -31,8 +31,11 @@
3131

3232
static constexpr float floatTolerance = 0.00001f;
3333
static constexpr double doubleTolerance = 0.00000000000001;
34+
35+
#if FB_CPP_USE_BOOST_MULTIPRECISION != 0
3436
static const BoostDecFloat16 decFloat16Tolerance{"0.00000000000001"};
3537
static const BoostDecFloat34 decFloat34Tolerance{"0.00000000000000000000000000000001"};
38+
#endif
3639

3740

3841
BOOST_AUTO_TEST_SUITE(NumericConverterSuite)
@@ -77,6 +80,7 @@ BOOST_AUTO_TEST_CASE(convertScaledInt16)
7780
BOOST_CHECK_EQUAL(converter.numberToNumber<std::int64_t>(ScaledInt16{-3'2768, -4}, 0), -3);
7881
BOOST_CHECK_EQUAL(converter.numberToNumber<std::int64_t>(ScaledInt16{-3'276'8, -1}, -1), -32768);
7982

83+
#if FB_CPP_USE_BOOST_MULTIPRECISION != 0
8084
BOOST_CHECK_EQUAL(converter.numberToNumber<BoostInt128>(ScaledInt16{12'3, -1}, -2), 12'30);
8185
BOOST_CHECK_EQUAL(converter.numberToNumber<BoostInt128>(ScaledInt16{-12'3, -1}, -2), -12'30);
8286
BOOST_CHECK_EQUAL(converter.numberToNumber<BoostInt128>(ScaledInt16{12'3, -1}, -4), 12'3000);
@@ -87,6 +91,7 @@ BOOST_AUTO_TEST_CASE(convertScaledInt16)
8791
BOOST_CHECK_EQUAL(converter.numberToNumber<BoostInt128>(ScaledInt16{-3'276'8, -1}, 0), -3'277);
8892
BOOST_CHECK_EQUAL(converter.numberToNumber<BoostInt128>(ScaledInt16{-3'2768, -4}, 0), -3);
8993
BOOST_CHECK_EQUAL(converter.numberToNumber<BoostInt128>(ScaledInt16{-3'276'8, -1}, -1), -32768);
94+
#endif
9095

9196
BOOST_CHECK_CLOSE(converter.numberToNumber<float>(ScaledInt16{12'3, -1}), 12.3f, floatTolerance);
9297
BOOST_CHECK_CLOSE(converter.numberToNumber<float>(ScaledInt16{-12'3, -1}), -12.3f, floatTolerance);
@@ -102,6 +107,7 @@ BOOST_AUTO_TEST_CASE(convertScaledInt16)
102107
BOOST_CHECK_CLOSE(converter.numberToNumber<double>(ScaledInt16{-3'276'8, -1}), -3'276.8, doubleTolerance);
103108
BOOST_CHECK_CLOSE(converter.numberToNumber<double>(ScaledInt16{-3'2768, -4}), -3.2768, doubleTolerance);
104109

110+
#if FB_CPP_USE_BOOST_MULTIPRECISION != 0
105111
BOOST_CHECK_CLOSE(
106112
converter.numberToNumber<BoostDecFloat16>(ScaledInt16{12'3, -1}), BoostDecFloat16{"12.3"}, decFloat16Tolerance);
107113
BOOST_CHECK_CLOSE(converter.numberToNumber<BoostDecFloat16>(ScaledInt16{-12'3, -1}), BoostDecFloat16{"-12.3"},
@@ -127,6 +133,7 @@ BOOST_AUTO_TEST_CASE(convertScaledInt16)
127133
decFloat34Tolerance);
128134
BOOST_CHECK_CLOSE(converter.numberToNumber<BoostDecFloat34>(ScaledInt16{-3'2768, -4}), BoostDecFloat34{"-3.2768"},
129135
decFloat34Tolerance);
136+
#endif
130137

131138
BOOST_CHECK_EQUAL(converter.numberToString(ScaledInt16{32767, 0}), "32767");
132139
BOOST_CHECK_EQUAL(converter.numberToString(ScaledInt16{-32768, 0}), "-32768");
@@ -169,6 +176,7 @@ BOOST_AUTO_TEST_CASE(convertScaledInt32)
169176
BOOST_CHECK_EQUAL(converter.numberToNumber<std::int64_t>(ScaledInt32{-214'748'3648, -4}, 0), -214'748);
170177
BOOST_CHECK_EQUAL(converter.numberToNumber<std::int64_t>(ScaledInt32{-214'748'364'8, -1}, -1), -214'748'364'8);
171178

179+
#if FB_CPP_USE_BOOST_MULTIPRECISION != 0
172180
BOOST_CHECK(converter.numberToNumber<BoostInt128>(ScaledInt32{12'3, -1}, -2) == BoostInt128{12'30});
173181
BOOST_CHECK(converter.numberToNumber<BoostInt128>(ScaledInt32{-12'3, -1}, -2) == BoostInt128{-12'30});
174182
BOOST_CHECK(converter.numberToNumber<BoostInt128>(ScaledInt32{12'3, -1}, -4) == BoostInt128{12'3000});
@@ -181,6 +189,7 @@ BOOST_AUTO_TEST_CASE(convertScaledInt32)
181189
BOOST_CHECK(converter.numberToNumber<BoostInt128>(ScaledInt32{-214'748'3648, -4}, 0) == BoostInt128{-214'748});
182190
BOOST_CHECK(
183191
converter.numberToNumber<BoostInt128>(ScaledInt32{-214'748'364'8, -1}, -1) == BoostInt128{-2'147'483'648});
192+
#endif
184193

185194
BOOST_CHECK_CLOSE(converter.numberToNumber<float>(ScaledInt32{12'3, -1}), 12.3f, floatTolerance);
186195
BOOST_CHECK_CLOSE(converter.numberToNumber<float>(ScaledInt32{-12'3, -1}), -12.3f, floatTolerance);
@@ -198,6 +207,7 @@ BOOST_AUTO_TEST_CASE(convertScaledInt32)
198207
converter.numberToNumber<double>(ScaledInt32{-214'748'364'8, -1}), -214'748'364.8, doubleTolerance);
199208
BOOST_CHECK_CLOSE(converter.numberToNumber<double>(ScaledInt32{-214'748'3648, -4}), -214'748.3648, doubleTolerance);
200209

210+
#if FB_CPP_USE_BOOST_MULTIPRECISION != 0
201211
BOOST_CHECK_CLOSE(
202212
converter.numberToNumber<BoostDecFloat16>(ScaledInt32{12'3, -1}), BoostDecFloat16{"12.3"}, decFloat16Tolerance);
203213
BOOST_CHECK_CLOSE(converter.numberToNumber<BoostDecFloat16>(ScaledInt32{-12'3, -1}), BoostDecFloat16{"-12.3"},
@@ -223,6 +233,7 @@ BOOST_AUTO_TEST_CASE(convertScaledInt32)
223233
BoostDecFloat34{"-214748364.8"}, decFloat34Tolerance);
224234
BOOST_CHECK_CLOSE(converter.numberToNumber<BoostDecFloat34>(ScaledInt32{-214'748'3648, -4}),
225235
BoostDecFloat34{"-214748.3648"}, decFloat34Tolerance);
236+
#endif
226237

227238
BOOST_CHECK_EQUAL(converter.numberToString(ScaledInt32{2'147'483'647, 0}), "2147483647");
228239
BOOST_CHECK_EQUAL(converter.numberToString(ScaledInt32{-2'147'483'648, 0}), "-2147483648");
@@ -261,6 +272,7 @@ BOOST_AUTO_TEST_CASE(convertScaledInt64)
261272
BOOST_CHECK_EQUAL(converter.numberToNumber<std::int64_t>(ScaledInt64{-922'337'203'685'477'580'7LL - 1, -1}, -1),
262273
-922'337'203'685'477'580'7LL - 1);
263274

275+
#if FB_CPP_USE_BOOST_MULTIPRECISION != 0
264276
BOOST_CHECK_EQUAL(converter.numberToNumber<BoostInt128>(ScaledInt64{12'3, -1}, -2), 12'30);
265277
BOOST_CHECK_EQUAL(converter.numberToNumber<BoostInt128>(ScaledInt64{-12'3, -1}, -2), -12'30);
266278
BOOST_CHECK_EQUAL(converter.numberToNumber<BoostInt128>(ScaledInt64{12'3, -1}, -4), 12'3000);
@@ -277,6 +289,7 @@ BOOST_AUTO_TEST_CASE(convertScaledInt64)
277289
BoostInt128{-922'337'203'685'478});
278290
BOOST_CHECK(converter.numberToNumber<BoostInt128>(ScaledInt64{-922'337'203'685'477'580'7LL - 1, -1}, -1) ==
279291
BoostInt128{-922'337'203'685'477'580'7LL - 1});
292+
#endif
280293

281294
BOOST_CHECK_CLOSE(converter.numberToNumber<float>(ScaledInt64{12'3, -1}), 12.3f, floatTolerance);
282295
BOOST_CHECK_CLOSE(converter.numberToNumber<float>(ScaledInt64{-12'3, -1}), -12.3f, floatTolerance);
@@ -300,6 +313,7 @@ BOOST_AUTO_TEST_CASE(convertScaledInt64)
300313
BOOST_CHECK_CLOSE(converter.numberToNumber<double>(ScaledInt64{-922'337'203'685'477'5807LL - 1, -4}),
301314
-9.223372036854775807e14, doubleTolerance);
302315

316+
#if FB_CPP_USE_BOOST_MULTIPRECISION != 0
303317
BOOST_CHECK_CLOSE(
304318
converter.numberToNumber<BoostDecFloat16>(ScaledInt64{12'3, -1}), BoostDecFloat16{"12.3"}, decFloat16Tolerance);
305319
BOOST_CHECK_CLOSE(converter.numberToNumber<BoostDecFloat16>(ScaledInt64{-12'3, -1}), BoostDecFloat16{"-12.3"},
@@ -325,6 +339,7 @@ BOOST_AUTO_TEST_CASE(convertScaledInt64)
325339
BoostDecFloat34{"-922337203685477580.8"}, decFloat34Tolerance);
326340
BOOST_CHECK_CLOSE(converter.numberToNumber<BoostDecFloat34>(ScaledInt64{-922'337'203'685'477'5807LL - 1, -4}),
327341
BoostDecFloat34{"-922337203685477.5808"}, decFloat34Tolerance);
342+
#endif
328343

329344
BOOST_CHECK_EQUAL(converter.numberToString(ScaledInt64{922'337'203'685'477'5807LL, 0}), "9223372036854775807");
330345
BOOST_CHECK_EQUAL(
@@ -337,6 +352,7 @@ BOOST_AUTO_TEST_CASE(convertScaledInt64)
337352
converter.numberToString(ScaledInt64{-922'337'203'685'477'5807LL - 1, -4}), "-922337203685477.5808");
338353
}
339354

355+
#if FB_CPP_USE_BOOST_MULTIPRECISION != 0
340356
BOOST_AUTO_TEST_CASE(convertScaledBoostInt128)
341357
{
342358
const auto status = CLIENT.newStatus();
@@ -463,6 +479,7 @@ BOOST_AUTO_TEST_CASE(convertScaledBoostInt128)
463479
converter.numberToString(ScaledBoostInt128{BoostInt128{"-170141183460469231731687303715884105728"}, -4}),
464480
"-17014118346046923173168730371588410.5728");
465481
}
482+
#endif
466483

467484
BOOST_AUTO_TEST_CASE(convertFloat)
468485
{
@@ -504,6 +521,7 @@ BOOST_AUTO_TEST_CASE(convertFloat)
504521
BOOST_CHECK_EQUAL(converter.numberToNumber<std::int64_t>(-3.2768f, 0), -3);
505522
BOOST_CHECK_EQUAL(converter.numberToNumber<std::int64_t>(-3'276.8f, -1), -32768);
506523

524+
#if FB_CPP_USE_BOOST_MULTIPRECISION != 0
507525
BOOST_CHECK_EQUAL(converter.numberToNumber<BoostInt128>(12.3f, -2), 12'30);
508526
BOOST_CHECK_EQUAL(converter.numberToNumber<BoostInt128>(-12.3f, -2), -12'30);
509527
BOOST_CHECK_EQUAL(converter.numberToNumber<BoostInt128>(12.3f, -4), 12'3000);
@@ -514,6 +532,7 @@ BOOST_AUTO_TEST_CASE(convertFloat)
514532
BOOST_CHECK_EQUAL(converter.numberToNumber<BoostInt128>(-3'276.8f, 0), -3'277);
515533
BOOST_CHECK_EQUAL(converter.numberToNumber<BoostInt128>(-3.2768f, 0), -3);
516534
BOOST_CHECK_EQUAL(converter.numberToNumber<BoostInt128>(-3'276.8f, -1), -32768);
535+
#endif
517536

518537
BOOST_CHECK_CLOSE(converter.numberToNumber<double>(12.3f), 12.3, floatTolerance);
519538
BOOST_CHECK_CLOSE(converter.numberToNumber<double>(-12.3f), -12.3, floatTolerance);
@@ -522,6 +541,7 @@ BOOST_AUTO_TEST_CASE(convertFloat)
522541
BOOST_CHECK_CLOSE(converter.numberToNumber<double>(-3'276.8f), -3'276.8, floatTolerance);
523542
BOOST_CHECK_CLOSE(converter.numberToNumber<double>(-3.2768f), -3.2768, floatTolerance);
524543

544+
#if FB_CPP_USE_BOOST_MULTIPRECISION != 0
525545
BOOST_CHECK_CLOSE(converter.numberToNumber<BoostDecFloat16>(12.3f), BoostDecFloat16{"12.3"}, floatTolerance);
526546
BOOST_CHECK_CLOSE(converter.numberToNumber<BoostDecFloat16>(-12.3f), BoostDecFloat16{"-12.3"}, floatTolerance);
527547
BOOST_CHECK_CLOSE(converter.numberToNumber<BoostDecFloat16>(3276.7f), BoostDecFloat16{"3276.7"}, floatTolerance);
@@ -535,6 +555,7 @@ BOOST_AUTO_TEST_CASE(convertFloat)
535555
BOOST_CHECK_CLOSE(converter.numberToNumber<BoostDecFloat34>(3.2767f), BoostDecFloat34{"3.2767"}, floatTolerance);
536556
BOOST_CHECK_CLOSE(converter.numberToNumber<BoostDecFloat34>(-3276.8f), BoostDecFloat34{"-3276.8"}, floatTolerance);
537557
BOOST_CHECK_CLOSE(converter.numberToNumber<BoostDecFloat34>(-3.2768f), BoostDecFloat34{"-3.2768"}, floatTolerance);
558+
#endif
538559

539560
BOOST_CHECK_CLOSE(std::stof(converter.numberToString(12.3f)), 12.3f, floatTolerance);
540561
BOOST_CHECK_CLOSE(std::stof(converter.numberToString(-12.3f)), -12.3f, floatTolerance);
@@ -584,6 +605,7 @@ BOOST_AUTO_TEST_CASE(convertDouble)
584605
BOOST_CHECK_EQUAL(converter.numberToNumber<std::int64_t>(-3.2768, 0), -3);
585606
BOOST_CHECK_EQUAL(converter.numberToNumber<std::int64_t>(-3'276.8, -1), -32768);
586607

608+
#if FB_CPP_USE_BOOST_MULTIPRECISION != 0
587609
BOOST_CHECK_EQUAL(converter.numberToNumber<BoostInt128>(12.3, -2), 12'30);
588610
BOOST_CHECK_EQUAL(converter.numberToNumber<BoostInt128>(-12.3, -2), -12'30);
589611
BOOST_CHECK_EQUAL(converter.numberToNumber<BoostInt128>(12.3, -4), 12'3000);
@@ -594,6 +616,7 @@ BOOST_AUTO_TEST_CASE(convertDouble)
594616
BOOST_CHECK_EQUAL(converter.numberToNumber<BoostInt128>(-3'276.8, 0), -3'277);
595617
BOOST_CHECK_EQUAL(converter.numberToNumber<BoostInt128>(-3.2768, 0), -3);
596618
BOOST_CHECK_EQUAL(converter.numberToNumber<BoostInt128>(-3'276.8, -1), -32768);
619+
#endif
597620

598621
BOOST_CHECK_CLOSE(converter.numberToNumber<float>(12.3), 12.3f, floatTolerance);
599622
BOOST_CHECK_CLOSE(converter.numberToNumber<float>(-12.3), -12.3f, floatTolerance);
@@ -602,6 +625,7 @@ BOOST_AUTO_TEST_CASE(convertDouble)
602625
BOOST_CHECK_CLOSE(converter.numberToNumber<float>(-3'276.8), -3'276.8f, floatTolerance);
603626
BOOST_CHECK_CLOSE(converter.numberToNumber<float>(-3.2768), -3.2768f, floatTolerance);
604627

628+
#if FB_CPP_USE_BOOST_MULTIPRECISION != 0
605629
BOOST_CHECK_CLOSE(converter.numberToNumber<BoostDecFloat16>(12.3), BoostDecFloat16{"12.3"}, doubleTolerance);
606630
BOOST_CHECK_CLOSE(converter.numberToNumber<BoostDecFloat16>(-12.3), BoostDecFloat16{"-12.3"}, doubleTolerance);
607631
BOOST_CHECK_CLOSE(converter.numberToNumber<BoostDecFloat16>(3276.7), BoostDecFloat16{"3276.7"}, doubleTolerance);
@@ -615,6 +639,7 @@ BOOST_AUTO_TEST_CASE(convertDouble)
615639
BOOST_CHECK_CLOSE(converter.numberToNumber<BoostDecFloat34>(3.2767), BoostDecFloat34{"3.2767"}, doubleTolerance);
616640
BOOST_CHECK_CLOSE(converter.numberToNumber<BoostDecFloat34>(-3276.8), BoostDecFloat34{"-3276.8"}, doubleTolerance);
617641
BOOST_CHECK_CLOSE(converter.numberToNumber<BoostDecFloat34>(-3.2768), BoostDecFloat34{"-3.2768"}, doubleTolerance);
642+
#endif
618643

619644
BOOST_CHECK_CLOSE(std::stod(converter.numberToString(12.3)), 12.3, doubleTolerance);
620645
BOOST_CHECK_CLOSE(std::stod(converter.numberToString(-12.3)), -12.3, doubleTolerance);
@@ -624,6 +649,8 @@ BOOST_AUTO_TEST_CASE(convertDouble)
624649
BOOST_CHECK_CLOSE(std::stod(converter.numberToString(-3.2768)), -3.2768, doubleTolerance);
625650
}
626651

652+
#if FB_CPP_USE_BOOST_MULTIPRECISION != 0
653+
627654
BOOST_AUTO_TEST_CASE(convertDecFloat16)
628655
{
629656
const auto status = CLIENT.newStatus();
@@ -848,4 +875,6 @@ BOOST_AUTO_TEST_CASE(decFloat34NumberLimits)
848875
BOOST_CHECK_EQUAL(BoostDecFloat34{lowestString}, lowestValue);
849876
}
850877

878+
#endif
879+
851880
BOOST_AUTO_TEST_SUITE_END()

0 commit comments

Comments
 (0)