This is an automated email from the ASF dual-hosted git repository.
paleolimbot pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/arrow-nanoarrow.git
The following commit(s) were added to refs/heads/main by this push:
new c1f0f376 refactor: Use ArrowStringView C++ literal in tests (#528)
c1f0f376 is described below
commit c1f0f376da5e3b058f5d22915c7d57a69a4d6eeb
Author: Dewey Dunnington <[email protected]>
AuthorDate: Fri Jun 21 14:26:07 2024 +0000
refactor: Use ArrowStringView C++ literal in tests (#528)
In https://github.com/apache/arrow-nanoarrow/pull/404, the `_v` literal
was added, making it much more compact to define an `ArrowStringView`
and compare its equality to something else.
This PR refactors tests that used `EXPECT/ASSERT_EQ()` to be more
compact, and replaces `ArrowCharView()` with the string literal.
From reading
https://en.cppreference.com/w/cpp/string/basic_string_view/operator%22%22sv
and https://json.nlohmann.me/api/macros/json_use_global_udls/#notes it
seems like constraining the user-defined literal to a namespace is the
"modern" way to do this...I am not sure that `"_sv"` is the best choice
(maybe too close to `"sv"`?), but it did seem more descriptive than
`"_v` for those reading the tests without knowing that these literals
are defined.
---
src/nanoarrow/array_test.cc | 49 ++++++++--------
src/nanoarrow/buffer_test.cc | 6 +-
src/nanoarrow/nanoarrow.hpp | 30 ++++++----
src/nanoarrow/nanoarrow_device_cuda_test.cc | 8 ++-
src/nanoarrow/nanoarrow_device_metal_test.cc | 6 +-
src/nanoarrow/nanoarrow_device_test.cc | 8 ++-
src/nanoarrow/nanoarrow_hpp_test.cc | 9 ++-
src/nanoarrow/nanoarrow_testing_test.cc | 76 +++++++++++--------------
src/nanoarrow/schema_test.cc | 83 ++++++++++++----------------
src/nanoarrow/utils_test.cc | 32 ++++++-----
10 files changed, 153 insertions(+), 154 deletions(-)
diff --git a/src/nanoarrow/array_test.cc b/src/nanoarrow/array_test.cc
index 024aca8d..7b6d37e5 100644
--- a/src/nanoarrow/array_test.cc
+++ b/src/nanoarrow/array_test.cc
@@ -39,6 +39,7 @@
#include "nanoarrow/nanoarrow.hpp"
using namespace arrow;
+using namespace nanoarrow::literals;
using nanoarrow::NA;
using testing::ElementsAre;
@@ -256,8 +257,8 @@ TEST(ArrayTest, ArrayTestExplicitValidationLevel) {
ASSERT_EQ(ArrowArrayInitFromType(&array, NANOARROW_TYPE_STRING),
NANOARROW_OK);
EXPECT_EQ(ArrowArrayStartAppending(&array), NANOARROW_OK);
- EXPECT_EQ(ArrowArrayAppendString(&array, ArrowCharView("1234")),
NANOARROW_OK);
- EXPECT_EQ(ArrowArrayAppendString(&array, ArrowCharView("5678")),
NANOARROW_OK);
+ EXPECT_EQ(ArrowArrayAppendString(&array, "1234"_asv), NANOARROW_OK);
+ EXPECT_EQ(ArrowArrayAppendString(&array, "5678"_asv), NANOARROW_OK);
EXPECT_EQ(ArrowArrayFinishBuilding(&array, NANOARROW_VALIDATION_LEVEL_NONE,
&error),
NANOARROW_OK);
@@ -312,8 +313,8 @@ TEST(ArrayTest, ArrayTestValidateMinimalBufferAccess) {
ASSERT_EQ(ArrowArrayInitFromType(&array, NANOARROW_TYPE_STRING),
NANOARROW_OK);
EXPECT_EQ(ArrowArrayStartAppending(&array), NANOARROW_OK);
- EXPECT_EQ(ArrowArrayAppendString(&array, ArrowCharView("1234")),
NANOARROW_OK);
- EXPECT_EQ(ArrowArrayAppendString(&array, ArrowCharView("5678")),
NANOARROW_OK);
+ EXPECT_EQ(ArrowArrayAppendString(&array, "1234"_asv), NANOARROW_OK);
+ EXPECT_EQ(ArrowArrayAppendString(&array, "5678"_asv), NANOARROW_OK);
// Temporarily make it so that referencing the offsets buffer will crash
// but make sure it has the correct size_bytes and passes minimal validation
@@ -395,7 +396,7 @@ TEST(ArrayTest, ArrayTestAppendToNullArray) {
buffer_view.data.data = nullptr;
buffer_view.size_bytes = 0;
EXPECT_EQ(ArrowArrayAppendBytes(&array, buffer_view), EINVAL);
- EXPECT_EQ(ArrowArrayAppendString(&array, ArrowCharView("")), EINVAL);
+ EXPECT_EQ(ArrowArrayAppendString(&array, ""_asv), EINVAL);
ArrowArrayRelease(&array);
}
@@ -523,9 +524,9 @@ TEST(ArrayTest, ArrayTestAppendToStringArray) {
ASSERT_EQ(ArrowArrayReserve(&array, 5), NANOARROW_OK);
EXPECT_EQ(ArrowArrayBuffer(&array, 1)->capacity_bytes, (5 + 1) *
sizeof(int32_t));
- EXPECT_EQ(ArrowArrayAppendString(&array, ArrowCharView("1234")),
NANOARROW_OK);
+ EXPECT_EQ(ArrowArrayAppendString(&array, "1234"_asv), NANOARROW_OK);
EXPECT_EQ(ArrowArrayAppendNull(&array, 2), NANOARROW_OK);
- EXPECT_EQ(ArrowArrayAppendString(&array, ArrowCharView("56789")),
NANOARROW_OK);
+ EXPECT_EQ(ArrowArrayAppendString(&array, "56789"_asv), NANOARROW_OK);
EXPECT_EQ(ArrowArrayAppendEmpty(&array, 1), NANOARROW_OK);
EXPECT_EQ(ArrowArrayFinishBuildingDefault(&array, nullptr), NANOARROW_OK);
@@ -559,7 +560,7 @@ TEST(ArrayTest, ArrayTestAppendEmptyToString) {
struct ArrowArray array;
ASSERT_EQ(ArrowArrayInitFromType(&array, NANOARROW_TYPE_STRING),
NANOARROW_OK);
ASSERT_EQ(ArrowArrayStartAppending(&array), NANOARROW_OK);
- ASSERT_EQ(ArrowArrayAppendString(&array, ArrowCharView("")), NANOARROW_OK);
+ ASSERT_EQ(ArrowArrayAppendString(&array, ""_asv), NANOARROW_OK);
EXPECT_EQ(ArrowArrayFinishBuildingDefault(&array, nullptr), NANOARROW_OK);
EXPECT_NE(array.buffers[2], nullptr);
ArrowArrayRelease(&array);
@@ -859,9 +860,9 @@ TEST(ArrayTest, ArrayTestAppendToLargeStringArray) {
ASSERT_EQ(ArrowArrayReserve(&array, 5), NANOARROW_OK);
EXPECT_EQ(ArrowArrayBuffer(&array, 1)->capacity_bytes, (5 + 1) *
sizeof(int64_t));
- EXPECT_EQ(ArrowArrayAppendString(&array, ArrowCharView("1234")),
NANOARROW_OK);
+ EXPECT_EQ(ArrowArrayAppendString(&array, "1234"_asv), NANOARROW_OK);
EXPECT_EQ(ArrowArrayAppendNull(&array, 2), NANOARROW_OK);
- EXPECT_EQ(ArrowArrayAppendString(&array, ArrowCharView("56789")),
NANOARROW_OK);
+ EXPECT_EQ(ArrowArrayAppendString(&array, "56789"_asv), NANOARROW_OK);
EXPECT_EQ(ArrowArrayAppendEmpty(&array, 1), NANOARROW_OK);
EXPECT_EQ(ArrowArrayFinishBuildingDefault(&array, nullptr), NANOARROW_OK);
@@ -879,7 +880,7 @@ TEST(ArrayTest, ArrayTestAppendToLargeStringArray) {
EXPECT_EQ(memcmp(data_buffer, "123456789", 9), 0);
EXPECT_THAT(nanoarrow::ViewArrayAsBytes<64>(&array),
- ElementsAre("1234"_v, NA, NA, "56789"_v, ""_v));
+ ElementsAre("1234"_asv, NA, NA, "56789"_asv, ""_asv));
ArrowArrayRelease(&array);
}
@@ -915,7 +916,7 @@ TEST(ArrayTest, ArrayTestAppendToFixedSizeBinaryArray) {
EXPECT_EQ(memcmp(data_buffer, expected_data, 25), 0);
EXPECT_THAT(nanoarrow::ViewArrayAsFixedSizeBytes(&array, 5),
- ElementsAre("12345"_v, NA, NA, "67890"_v, "\0\0\0\0\0"_v));
+ ElementsAre("12345"_asv, NA, NA, "67890"_asv, "\0\0\0\0\0"_asv));
ArrowArrayRelease(&array);
ArrowSchemaRelease(&schema);
}
@@ -1264,9 +1265,8 @@ TEST(ArrayTest, ArrayTestAppendToMapArray) {
ASSERT_EQ(ArrowArrayReserve(&array, 5), NANOARROW_OK);
EXPECT_EQ(ArrowArrayBuffer(array.children[0], 1)->capacity_bytes, 0);
- struct ArrowStringView string_value = ArrowCharView("foobar");
ASSERT_EQ(ArrowArrayAppendInt(array.children[0]->children[0], 123),
NANOARROW_OK);
- ASSERT_EQ(ArrowArrayAppendString(array.children[0]->children[1],
string_value),
+ ASSERT_EQ(ArrowArrayAppendString(array.children[0]->children[1],
"foobar"_asv),
NANOARROW_OK);
EXPECT_EQ(ArrowArrayFinishElement(array.children[0]), NANOARROW_OK);
EXPECT_EQ(ArrowArrayFinishElement(&array), NANOARROW_OK);
@@ -1653,7 +1653,7 @@ TEST(ArrayTest, ArrayTestAppendToDenseUnionArray) {
ASSERT_EQ(ArrowArrayAppendInt(array.children[0], 123), NANOARROW_OK);
EXPECT_EQ(ArrowArrayFinishUnionElement(&array, 0), NANOARROW_OK);
EXPECT_EQ(ArrowArrayAppendNull(&array, 2), NANOARROW_OK);
- ASSERT_EQ(ArrowArrayAppendString(array.children[1], ArrowCharView("one
twenty four")),
+ ASSERT_EQ(ArrowArrayAppendString(array.children[1], "one twenty four"_asv),
NANOARROW_OK);
EXPECT_EQ(ArrowArrayFinishUnionElement(&array, 1), NANOARROW_OK);
EXPECT_EQ(ArrowArrayAppendEmpty(&array, 1), NANOARROW_OK);
@@ -1699,7 +1699,7 @@ TEST(ArrayTest, ArrayTestAppendToSparseUnionArray) {
ASSERT_EQ(ArrowArrayAppendInt(array.children[0], 123), NANOARROW_OK);
EXPECT_EQ(ArrowArrayFinishUnionElement(&array, 0), NANOARROW_OK);
EXPECT_EQ(ArrowArrayAppendNull(&array, 2), NANOARROW_OK);
- ASSERT_EQ(ArrowArrayAppendString(array.children[1], ArrowCharView("one
twenty four")),
+ ASSERT_EQ(ArrowArrayAppendString(array.children[1], "one twenty four"_asv),
NANOARROW_OK);
EXPECT_EQ(ArrowArrayFinishUnionElement(&array, 1), NANOARROW_OK);
EXPECT_EQ(ArrowArrayAppendEmpty(&array, 1), NANOARROW_OK);
@@ -2345,8 +2345,8 @@ TEST(ArrayTest, ArrayViewTestDictionary) {
struct ArrowArray array;
ASSERT_EQ(ArrowArrayInitFromSchema(&array, &schema, nullptr), NANOARROW_OK);
ASSERT_EQ(ArrowArrayStartAppending(&array), NANOARROW_OK);
- ASSERT_EQ(ArrowArrayAppendString(array.dictionary, ArrowCharView("abc")),
NANOARROW_OK);
- ASSERT_EQ(ArrowArrayAppendString(array.dictionary, ArrowCharView("def")),
NANOARROW_OK);
+ ASSERT_EQ(ArrowArrayAppendString(array.dictionary, "abc"_asv), NANOARROW_OK);
+ ASSERT_EQ(ArrowArrayAppendString(array.dictionary, "def"_asv), NANOARROW_OK);
ASSERT_EQ(ArrowArrayAppendInt(&array, 0), NANOARROW_OK);
ASSERT_EQ(ArrowArrayAppendInt(&array, 1), NANOARROW_OK);
ASSERT_EQ(ArrowArrayFinishBuildingDefault(&array, nullptr), NANOARROW_OK);
@@ -2361,11 +2361,8 @@ TEST(ArrayTest, ArrayViewTestDictionary) {
EXPECT_EQ(ArrowArrayViewGetIntUnsafe(&array_view, 0), 0);
EXPECT_EQ(ArrowArrayViewGetIntUnsafe(&array_view, 1), 1);
- struct ArrowStringView item;
- item = ArrowArrayViewGetStringUnsafe(array_view.dictionary, 0);
- EXPECT_EQ(std::string(item.data, item.size_bytes), "abc");
- item = ArrowArrayViewGetStringUnsafe(array_view.dictionary, 1);
- EXPECT_EQ(std::string(item.data, item.size_bytes), "def");
+ EXPECT_EQ(ArrowArrayViewGetStringUnsafe(array_view.dictionary, 0),
"abc"_asv);
+ EXPECT_EQ(ArrowArrayViewGetStringUnsafe(array_view.dictionary, 1),
"def"_asv);
ArrowArrayRelease(&array);
@@ -2405,7 +2402,7 @@ TEST(ArrayTest, ArrayViewTestUnionChildIndices) {
ASSERT_EQ(ArrowArrayStartAppending(&array), NANOARROW_OK);
ASSERT_EQ(ArrowArrayAppendInt(array.children[0], 123), NANOARROW_OK);
ASSERT_EQ(ArrowArrayFinishUnionElement(&array, 0), NANOARROW_OK);
- ASSERT_EQ(ArrowArrayAppendString(array.children[1], ArrowCharView("one
twenty four")),
+ ASSERT_EQ(ArrowArrayAppendString(array.children[1], "one twenty four"_asv),
NANOARROW_OK);
ASSERT_EQ(ArrowArrayFinishUnionElement(&array, 1), NANOARROW_OK);
ASSERT_EQ(ArrowArrayFinishBuildingDefault(&array, nullptr), NANOARROW_OK);
@@ -2513,7 +2510,7 @@ TEST(ArrayTest, ArrayViewTestDenseUnionGet) {
ASSERT_EQ(ArrowArrayStartAppending(&array), NANOARROW_OK);
ASSERT_EQ(ArrowArrayAppendInt(array.children[0], 123), NANOARROW_OK);
ASSERT_EQ(ArrowArrayFinishUnionElement(&array, 0), NANOARROW_OK);
- ASSERT_EQ(ArrowArrayAppendString(array.children[1], ArrowCharView("one
twenty four")),
+ ASSERT_EQ(ArrowArrayAppendString(array.children[1], "one twenty four"_asv),
NANOARROW_OK);
ASSERT_EQ(ArrowArrayFinishUnionElement(&array, 1), NANOARROW_OK);
ASSERT_EQ(ArrowArrayAppendNull(&array, 1), NANOARROW_OK);
@@ -2559,7 +2556,7 @@ TEST(ArrayTest, ArrayViewTestSparseUnionGet) {
ASSERT_EQ(ArrowArrayStartAppending(&array), NANOARROW_OK);
ASSERT_EQ(ArrowArrayAppendInt(array.children[0], 123), NANOARROW_OK);
ASSERT_EQ(ArrowArrayFinishUnionElement(&array, 0), NANOARROW_OK);
- ASSERT_EQ(ArrowArrayAppendString(array.children[1], ArrowCharView("one
twenty four")),
+ ASSERT_EQ(ArrowArrayAppendString(array.children[1], "one twenty four"_asv),
NANOARROW_OK);
ASSERT_EQ(ArrowArrayFinishUnionElement(&array, 1), NANOARROW_OK);
ASSERT_EQ(ArrowArrayAppendNull(&array, 1), NANOARROW_OK);
diff --git a/src/nanoarrow/buffer_test.cc b/src/nanoarrow/buffer_test.cc
index 053debf8..5287e76c 100644
--- a/src/nanoarrow/buffer_test.cc
+++ b/src/nanoarrow/buffer_test.cc
@@ -21,7 +21,7 @@
#include <gtest/gtest.h>
-#include "nanoarrow/nanoarrow.h"
+#include "nanoarrow/nanoarrow.hpp"
// This test allocator guarantees that allocator->reallocate will return
// a new pointer so that we can test when reallocations happen whilst
@@ -194,6 +194,8 @@ TEST(BufferTest, BufferTestError) {
}
TEST(BufferTest, BufferTestAppendHelpers) {
+ using namespace nanoarrow::literals;
+
struct ArrowBuffer buffer;
ArrowBufferInit(&buffer);
@@ -237,7 +239,7 @@ TEST(BufferTest, BufferTestAppendHelpers) {
EXPECT_EQ(reinterpret_cast<float*>(buffer.data)[0], 123);
ArrowBufferReset(&buffer);
- EXPECT_EQ(ArrowBufferAppendStringView(&buffer, ArrowCharView("a")),
NANOARROW_OK);
+ EXPECT_EQ(ArrowBufferAppendStringView(&buffer, "a"_asv), NANOARROW_OK);
EXPECT_EQ(reinterpret_cast<char*>(buffer.data)[0], 'a');
EXPECT_EQ(buffer.size_bytes, 1);
ArrowBufferReset(&buffer);
diff --git a/src/nanoarrow/nanoarrow.hpp b/src/nanoarrow/nanoarrow.hpp
index a5d44f9a..f51db74c 100644
--- a/src/nanoarrow/nanoarrow.hpp
+++ b/src/nanoarrow/nanoarrow.hpp
@@ -82,6 +82,23 @@ class Exception : public std::exception {
/// @}
+namespace literals {
+
+/// \defgroup nanoarrow_hpp-string_view_helpers ArrowStringView helpers
+///
+/// Factories and equality comparison for ArrowStringView.
+///
+/// @{
+
+/// \brief User literal operator allowing ArrowStringView construction like
"str"_asv
+inline ArrowStringView operator"" _asv(const char* data, std::size_t
size_bytes) {
+ return {data, static_cast<int64_t>(size_bytes)};
+}
+
+// @}
+
+} // namespace literals
+
namespace internal {
/// \defgroup nanoarrow_hpp-unique_base Base classes for Unique wrappers
@@ -893,22 +910,11 @@ class ViewArrayStream {
} // namespace nanoarrow
-/// \defgroup nanoarrow_hpp-string_view_helpers ArrowStringView helpers
-///
-/// Factories and equality comparison for ArrowStringView.
-///
-/// @{
-
/// \brief Equality comparison operator between ArrowStringView
+/// \ingroup nanoarrow_hpp-string_view_helpers
inline bool operator==(ArrowStringView l, ArrowStringView r) {
if (l.size_bytes != r.size_bytes) return false;
return memcmp(l.data, r.data, l.size_bytes) == 0;
}
-/// \brief User literal operator allowing ArrowStringView construction like
"str"_sv
-inline ArrowStringView operator"" _v(const char* data, std::size_t size_bytes)
{
- return {data, static_cast<int64_t>(size_bytes)};
-}
-/// @}
-
#endif
diff --git a/src/nanoarrow/nanoarrow_device_cuda_test.cc
b/src/nanoarrow/nanoarrow_device_cuda_test.cc
index 0a861443..5ee06396 100644
--- a/src/nanoarrow/nanoarrow_device_cuda_test.cc
+++ b/src/nanoarrow/nanoarrow_device_cuda_test.cc
@@ -197,6 +197,8 @@ std::tuple<ArrowDeviceType, enum ArrowType, bool>
TestParams(ArrowDeviceType dev
}
TEST_P(StringTypeParameterizedTestFixture, ArrowDeviceCudaArrayViewString) {
+ using namespace nanoarrow::literals;
+
struct ArrowDevice* cpu = ArrowDeviceCpu();
struct ArrowDevice* gpu = ArrowDeviceCuda(std::get<0>(GetParam()), 0);
struct ArrowArray array;
@@ -208,13 +210,13 @@ TEST_P(StringTypeParameterizedTestFixture,
ArrowDeviceCudaArrayViewString) {
ASSERT_EQ(ArrowArrayInitFromType(&array, string_type), NANOARROW_OK);
ASSERT_EQ(ArrowArrayStartAppending(&array), NANOARROW_OK);
- ASSERT_EQ(ArrowArrayAppendString(&array, ArrowCharView("abc")),
NANOARROW_OK);
- ASSERT_EQ(ArrowArrayAppendString(&array, ArrowCharView("defg")),
NANOARROW_OK);
+ ASSERT_EQ(ArrowArrayAppendString(&array, "abc"_asv), NANOARROW_OK);
+ ASSERT_EQ(ArrowArrayAppendString(&array, "defg"_asv), NANOARROW_OK);
if (include_null) {
ASSERT_EQ(ArrowArrayAppendNull(&array, 1), NANOARROW_OK);
expected_data_size = 7;
} else {
- ASSERT_EQ(ArrowArrayAppendString(&array, ArrowCharView("hjk")),
NANOARROW_OK);
+ ASSERT_EQ(ArrowArrayAppendString(&array, "hjk"_asv), NANOARROW_OK);
expected_data_size = 10;
}
ASSERT_EQ(ArrowArrayFinishBuildingDefault(&array, nullptr), NANOARROW_OK);
diff --git a/src/nanoarrow/nanoarrow_device_metal_test.cc
b/src/nanoarrow/nanoarrow_device_metal_test.cc
index 10a9e83f..679d655b 100644
--- a/src/nanoarrow/nanoarrow_device_metal_test.cc
+++ b/src/nanoarrow/nanoarrow_device_metal_test.cc
@@ -222,6 +222,8 @@ class StringTypeParameterizedTestFixture
};
TEST_P(StringTypeParameterizedTestFixture, ArrowDeviceMetalArrayViewString) {
+ using namespace nanoarrow::literals;
+
struct ArrowDevice* metal = ArrowDeviceMetalDefaultDevice();
struct ArrowDevice* cpu = ArrowDeviceCpu();
struct ArrowArray array;
@@ -231,8 +233,8 @@ TEST_P(StringTypeParameterizedTestFixture,
ArrowDeviceMetalArrayViewString) {
ASSERT_EQ(ArrowArrayInitFromType(&array, string_type), NANOARROW_OK);
ASSERT_EQ(ArrowArrayStartAppending(&array), NANOARROW_OK);
- ASSERT_EQ(ArrowArrayAppendString(&array, ArrowCharView("abc")),
NANOARROW_OK);
- ASSERT_EQ(ArrowArrayAppendString(&array, ArrowCharView("defg")),
NANOARROW_OK);
+ ASSERT_EQ(ArrowArrayAppendString(&array, "abc"_asv), NANOARROW_OK);
+ ASSERT_EQ(ArrowArrayAppendString(&array, "defg"_asv), NANOARROW_OK);
ASSERT_EQ(ArrowArrayAppendNull(&array, 1), NANOARROW_OK);
ASSERT_EQ(ArrowArrayFinishBuildingDefault(&array, nullptr), NANOARROW_OK);
diff --git a/src/nanoarrow/nanoarrow_device_test.cc
b/src/nanoarrow/nanoarrow_device_test.cc
index ad2ed9c8..6765baed 100644
--- a/src/nanoarrow/nanoarrow_device_test.cc
+++ b/src/nanoarrow/nanoarrow_device_test.cc
@@ -19,7 +19,7 @@
#include <gtest/gtest.h>
-#include "nanoarrow/nanoarrow_device.h"
+#include "nanoarrow/nanoarrow_device.hpp"
TEST(NanoarrowDevice, CheckRuntime) {
EXPECT_EQ(ArrowDeviceCheckRuntime(nullptr), NANOARROW_OK);
@@ -68,6 +68,8 @@ class StringTypeParameterizedTestFixture
};
TEST_P(StringTypeParameterizedTestFixture, ArrowDeviceCpuArrayViewString) {
+ using namespace nanoarrow::literals;
+
struct ArrowDevice* cpu = ArrowDeviceCpu();
struct ArrowArray array;
struct ArrowDeviceArray device_array;
@@ -76,8 +78,8 @@ TEST_P(StringTypeParameterizedTestFixture,
ArrowDeviceCpuArrayViewString) {
ASSERT_EQ(ArrowArrayInitFromType(&array, string_type), NANOARROW_OK);
ASSERT_EQ(ArrowArrayStartAppending(&array), NANOARROW_OK);
- ASSERT_EQ(ArrowArrayAppendString(&array, ArrowCharView("abc")),
NANOARROW_OK);
- ASSERT_EQ(ArrowArrayAppendString(&array, ArrowCharView("defg")),
NANOARROW_OK);
+ ASSERT_EQ(ArrowArrayAppendString(&array, "abc"_asv), NANOARROW_OK);
+ ASSERT_EQ(ArrowArrayAppendString(&array, "defg"_asv), NANOARROW_OK);
ASSERT_EQ(ArrowArrayAppendNull(&array, 1), NANOARROW_OK);
ASSERT_EQ(ArrowArrayFinishBuildingDefault(&array, nullptr), NANOARROW_OK);
diff --git a/src/nanoarrow/nanoarrow_hpp_test.cc
b/src/nanoarrow/nanoarrow_hpp_test.cc
index 05b6b8de..31250f6c 100644
--- a/src/nanoarrow/nanoarrow_hpp_test.cc
+++ b/src/nanoarrow/nanoarrow_hpp_test.cc
@@ -288,6 +288,8 @@ TEST(NanoarrowHppTest, NanoarrowHppViewArrayAsTest) {
}
TEST(NanoarrowHppTest, NanoarrowHppViewArrayAsBytesTest) {
+ using namespace nanoarrow::literals;
+
nanoarrow::UniqueBuffer is_valid, offsets, data;
nanoarrow::BufferInitSequence(is_valid.get(), std::vector<uint8_t>{0xFF});
ArrowBitClear(is_valid->data, 2);
@@ -304,7 +306,8 @@ TEST(NanoarrowHppTest, NanoarrowHppViewArrayAsBytesTest) {
array.buffers = buffers;
int i = 0;
- ArrowStringView expected[] = {"a"_v, "b"_v, "c"_v, "d"_v, "e"_v, "f"_v,
"g"_v};
+ ArrowStringView expected[] = {"a"_asv, "b"_asv, "c"_asv, "d"_asv,
+ "e"_asv, "f"_asv, "g"_asv};
for (auto slot : nanoarrow::ViewArrayAsBytes<32>(&array)) {
if (i == 2 || i == 5) {
EXPECT_EQ(slot, nanoarrow::NA);
@@ -316,6 +319,8 @@ TEST(NanoarrowHppTest, NanoarrowHppViewArrayAsBytesTest) {
}
TEST(NanoarrowHppTest, NanoarrowHppViewArrayAsFixedSizeBytesTest) {
+ using namespace nanoarrow::literals;
+
nanoarrow::UniqueBuffer is_valid, data;
nanoarrow::BufferInitSequence(is_valid.get(), std::vector<uint8_t>{0xFF});
ArrowBitClear(is_valid->data, 2);
@@ -335,7 +340,7 @@ TEST(NanoarrowHppTest,
NanoarrowHppViewArrayAsFixedSizeBytesTest) {
if (i == 2 || i == 5) {
EXPECT_EQ(slot, nanoarrow::NA);
} else {
- EXPECT_EQ(slot, i % 2 == 0 ? "foo"_v : "bar"_v);
+ EXPECT_EQ(slot, i % 2 == 0 ? "foo"_asv : "bar"_asv);
}
++i;
}
diff --git a/src/nanoarrow/nanoarrow_testing_test.cc
b/src/nanoarrow/nanoarrow_testing_test.cc
index ebd1853a..90abef8a 100644
--- a/src/nanoarrow/nanoarrow_testing_test.cc
+++ b/src/nanoarrow/nanoarrow_testing_test.cc
@@ -25,6 +25,7 @@
using nanoarrow::testing::TestingJSONComparison;
using nanoarrow::testing::TestingJSONReader;
using nanoarrow::testing::TestingJSONWriter;
+using namespace nanoarrow::literals;
ArrowErrorCode WriteBatchJSON(std::ostream& out, TestingJSONWriter& writer,
const ArrowSchema* schema, ArrowArrayView*
array_view) {
@@ -209,8 +210,8 @@ TEST(NanoarrowTestingTest,
NanoarrowTestingTestColumnString) {
},
[](ArrowArray* array) {
NANOARROW_RETURN_NOT_OK(ArrowArrayAppendNull(array, 1));
- NANOARROW_RETURN_NOT_OK(ArrowArrayAppendString(array,
ArrowCharView("abc")));
- NANOARROW_RETURN_NOT_OK(ArrowArrayAppendString(array,
ArrowCharView("def")));
+ NANOARROW_RETURN_NOT_OK(ArrowArrayAppendString(array, "abc"_asv));
+ NANOARROW_RETURN_NOT_OK(ArrowArrayAppendString(array, "def"_asv));
return NANOARROW_OK;
},
&WriteColumnJSON,
@@ -236,7 +237,7 @@ TEST(NanoarrowTestingTest,
NanoarrowTestingTestColumnString) {
return ArrowSchemaInitFromType(schema, NANOARROW_TYPE_STRING);
},
[](ArrowArray* array) {
- NANOARROW_RETURN_NOT_OK(ArrowArrayAppendString(array,
ArrowCharView("\u0001")));
+ NANOARROW_RETURN_NOT_OK(ArrowArrayAppendString(array, "\u0001"_asv));
return NANOARROW_OK;
},
&WriteColumnJSON,
@@ -251,8 +252,8 @@ TEST(NanoarrowTestingTest,
NanoarrowTestingTestColumnLargeString) {
},
[](ArrowArray* array) {
NANOARROW_RETURN_NOT_OK(ArrowArrayAppendNull(array, 1));
- NANOARROW_RETURN_NOT_OK(ArrowArrayAppendString(array,
ArrowCharView("abc")));
- NANOARROW_RETURN_NOT_OK(ArrowArrayAppendString(array,
ArrowCharView("def")));
+ NANOARROW_RETURN_NOT_OK(ArrowArrayAppendString(array, "abc"_asv));
+ NANOARROW_RETURN_NOT_OK(ArrowArrayAppendString(array, "def"_asv));
return NANOARROW_OK;
},
&WriteColumnJSON,
@@ -272,7 +273,7 @@ TEST(NanoarrowTestingTest,
NanoarrowTestingTestColumnBinary) {
value_view.size_bytes = sizeof(value);
NANOARROW_RETURN_NOT_OK(ArrowArrayAppendNull(array, 1));
- NANOARROW_RETURN_NOT_OK(ArrowArrayAppendString(array,
ArrowCharView("abc")));
+ NANOARROW_RETURN_NOT_OK(ArrowArrayAppendString(array, "abc"_asv));
NANOARROW_RETURN_NOT_OK(ArrowArrayAppendBytes(array, value_view));
return NANOARROW_OK;
},
@@ -449,10 +450,10 @@ TEST(NanoarrowTestingTest,
NanoarrowTestingTestFieldMetadata) {
[](ArrowSchema* schema) {
nanoarrow::UniqueBuffer buffer;
NANOARROW_RETURN_NOT_OK(ArrowMetadataBuilderInit(buffer.get(),
nullptr));
- NANOARROW_RETURN_NOT_OK(ArrowMetadataBuilderAppend(
- buffer.get(), ArrowCharView("k1"), ArrowCharView("v1")));
- NANOARROW_RETURN_NOT_OK(ArrowMetadataBuilderAppend(
- buffer.get(), ArrowCharView("k2"), ArrowCharView("v2")));
+ NANOARROW_RETURN_NOT_OK(
+ ArrowMetadataBuilderAppend(buffer.get(), "k1"_asv, "v1"_asv));
+ NANOARROW_RETURN_NOT_OK(
+ ArrowMetadataBuilderAppend(buffer.get(), "k2"_asv, "v2"_asv));
NANOARROW_RETURN_NOT_OK(ArrowSchemaInitFromType(schema,
NANOARROW_TYPE_NA));
NANOARROW_RETURN_NOT_OK(
@@ -723,8 +724,8 @@ TEST(NanoarrowTestingTest, NanoarrowTestingTestReadSchema) {
ArrowStringView key;
ArrowStringView value;
ASSERT_EQ(ArrowMetadataReaderRead(&metadata_reader, &key, &value),
NANOARROW_OK);
- ASSERT_EQ(std::string(key.data, key.size_bytes), "k1");
- ASSERT_EQ(std::string(value.data, value.size_bytes), "v1");
+ ASSERT_EQ(key, "k1"_asv);
+ ASSERT_EQ(value, "v1"_asv);
// Check invalid JSON
EXPECT_EQ(reader.ReadSchema(R"({)", schema.get()), EINVAL);
@@ -799,12 +800,12 @@ TEST(NanoarrowTestingTest,
NanoarrowTestingTestReadFieldMetadata) {
ASSERT_EQ(metadata.remaining_keys, 2);
ASSERT_EQ(ArrowMetadataReaderRead(&metadata, &key, &value), NANOARROW_OK);
- ASSERT_EQ(std::string(key.data, key.size_bytes), "k1");
- ASSERT_EQ(std::string(value.data, value.size_bytes), "v1");
+ ASSERT_EQ(key, "k1"_asv);
+ ASSERT_EQ(value, "v1"_asv);
ASSERT_EQ(ArrowMetadataReaderRead(&metadata, &key, &value), NANOARROW_OK);
- ASSERT_EQ(std::string(key.data, key.size_bytes), "k2");
- ASSERT_EQ(std::string(value.data, value.size_bytes), "v2");
+ ASSERT_EQ(key, "k2"_asv);
+ ASSERT_EQ(value, "v2"_asv);
}
TEST(NanoarrowTestingTest, NanoarrowTestingTestReadFieldNested) {
@@ -1398,11 +1399,9 @@ TEST(NanoarrowTestingTest,
NanoarrowTestingTestSchemaComparison) {
// With different top-level metadata
nanoarrow::UniqueBuffer buf;
ASSERT_EQ(ArrowMetadataBuilderInit(buf.get(), nullptr), NANOARROW_OK);
- ASSERT_EQ(ArrowMetadataBuilderAppend(buf.get(), ArrowCharView("key1"),
- ArrowCharView("value1")),
+ ASSERT_EQ(ArrowMetadataBuilderAppend(buf.get(), "key1"_asv, "value1"_asv),
NANOARROW_OK);
- ASSERT_EQ(ArrowMetadataBuilderAppend(buf.get(), ArrowCharView("key2"),
- ArrowCharView("value2")),
+ ASSERT_EQ(ArrowMetadataBuilderAppend(buf.get(), "key2"_asv, "value2"_asv),
NANOARROW_OK);
ASSERT_EQ(ArrowSchemaSetMetadata(actual.get(),
reinterpret_cast<char*>(buf->data)),
NANOARROW_OK);
@@ -1490,22 +1489,18 @@ TEST(NanoarrowTestingTest,
NanoarrowTestingTestMetadataComparison) {
// With different top-level metadata that are not equivalent because of order
buf.reset();
ASSERT_EQ(ArrowMetadataBuilderInit(buf.get(), nullptr), NANOARROW_OK);
- ASSERT_EQ(ArrowMetadataBuilderAppend(buf.get(), ArrowCharView("key1"),
- ArrowCharView("value1")),
+ ASSERT_EQ(ArrowMetadataBuilderAppend(buf.get(), "key1"_asv, "value1"_asv),
NANOARROW_OK);
- ASSERT_EQ(ArrowMetadataBuilderAppend(buf.get(), ArrowCharView("key2"),
- ArrowCharView("value2")),
+ ASSERT_EQ(ArrowMetadataBuilderAppend(buf.get(), "key2"_asv, "value2"_asv),
NANOARROW_OK);
ASSERT_EQ(ArrowSchemaSetMetadata(actual.get(),
reinterpret_cast<char*>(buf->data)),
NANOARROW_OK);
buf.reset();
ASSERT_EQ(ArrowMetadataBuilderInit(buf.get(), nullptr), NANOARROW_OK);
- ASSERT_EQ(ArrowMetadataBuilderAppend(buf.get(), ArrowCharView("key2"),
- ArrowCharView("value2")),
+ ASSERT_EQ(ArrowMetadataBuilderAppend(buf.get(), "key2"_asv, "value2"_asv),
NANOARROW_OK);
- ASSERT_EQ(ArrowMetadataBuilderAppend(buf.get(), ArrowCharView("key1"),
- ArrowCharView("value1")),
+ ASSERT_EQ(ArrowMetadataBuilderAppend(buf.get(), "key1"_asv, "value1"_asv),
NANOARROW_OK);
ASSERT_EQ(ArrowSchemaSetMetadata(expected.get(),
reinterpret_cast<char*>(buf->data)),
NANOARROW_OK);
@@ -1560,11 +1555,9 @@ TEST(NanoarrowTestingTest,
NanoarrowTestingTestMetadataComparison) {
// With different top-level metadata that are not equivalent because of item
content
buf.reset();
ASSERT_EQ(ArrowMetadataBuilderInit(buf.get(), nullptr), NANOARROW_OK);
- ASSERT_EQ(ArrowMetadataBuilderAppend(buf.get(), ArrowCharView("key2"),
- ArrowCharView("value2")),
+ ASSERT_EQ(ArrowMetadataBuilderAppend(buf.get(), "key2"_asv, "value2"_asv),
NANOARROW_OK);
- ASSERT_EQ(ArrowMetadataBuilderAppend(buf.get(), ArrowCharView("key1"),
- ArrowCharView("gazornenplat")),
+ ASSERT_EQ(ArrowMetadataBuilderAppend(buf.get(), "key1"_asv,
"gazornenplat"_asv),
NANOARROW_OK);
ASSERT_EQ(ArrowSchemaSetMetadata(actual.get(),
reinterpret_cast<char*>(buf->data)),
NANOARROW_OK);
@@ -1597,11 +1590,9 @@ TEST(NanoarrowTestingTest,
NanoarrowTestingTestMetadataComparison) {
// With different top-level metadata that are not equivalent because of item
keys
buf.reset();
ASSERT_EQ(ArrowMetadataBuilderInit(buf.get(), nullptr), NANOARROW_OK);
- ASSERT_EQ(ArrowMetadataBuilderAppend(buf.get(), ArrowCharView("key2"),
- ArrowCharView("value2")),
+ ASSERT_EQ(ArrowMetadataBuilderAppend(buf.get(), "key2"_asv, "value2"_asv),
NANOARROW_OK);
- ASSERT_EQ(ArrowMetadataBuilderAppend(buf.get(), ArrowCharView("key3"),
- ArrowCharView("value1")),
+ ASSERT_EQ(ArrowMetadataBuilderAppend(buf.get(), "key3"_asv, "value1"_asv),
NANOARROW_OK);
ASSERT_EQ(ArrowSchemaSetMetadata(actual.get(),
reinterpret_cast<char*>(buf->data)),
NANOARROW_OK);
@@ -1634,11 +1625,9 @@ TEST(NanoarrowTestingTest,
NanoarrowTestingTestMetadataComparison) {
// Metadata that are not equal and contain duplicate keys
buf.reset();
ASSERT_EQ(ArrowMetadataBuilderInit(buf.get(), nullptr), NANOARROW_OK);
- ASSERT_EQ(ArrowMetadataBuilderAppend(buf.get(), ArrowCharView("key2"),
- ArrowCharView("value2")),
+ ASSERT_EQ(ArrowMetadataBuilderAppend(buf.get(), "key2"_asv, "value2"_asv),
NANOARROW_OK);
- ASSERT_EQ(ArrowMetadataBuilderAppend(buf.get(), ArrowCharView("key2"),
- ArrowCharView("value2 again")),
+ ASSERT_EQ(ArrowMetadataBuilderAppend(buf.get(), "key2"_asv, "value2
again"_asv),
NANOARROW_OK);
ASSERT_EQ(ArrowSchemaSetMetadata(actual.get(),
reinterpret_cast<char*>(buf->data)),
NANOARROW_OK);
@@ -1774,9 +1763,8 @@ TEST(NanoarrowTestingTest,
NanoarrowTestingTestArrayWithDictionaryComparison) {
NANOARROW_OK);
ASSERT_EQ(ArrowArrayStartAppending(expected.get()), NANOARROW_OK);
ASSERT_EQ(ArrowArrayAppendInt(expected->children[0], 0), NANOARROW_OK);
- ASSERT_EQ(
- ArrowArrayAppendString(expected->children[0]->dictionary,
ArrowCharView("abc")),
- NANOARROW_OK);
+ ASSERT_EQ(ArrowArrayAppendString(expected->children[0]->dictionary,
"abc"_asv),
+ NANOARROW_OK);
ASSERT_EQ(ArrowArrayFinishElement(expected.get()), NANOARROW_OK);
ASSERT_EQ(ArrowArrayFinishBuildingDefault(expected.get(), nullptr),
NANOARROW_OK);
@@ -1784,7 +1772,7 @@ TEST(NanoarrowTestingTest,
NanoarrowTestingTestArrayWithDictionaryComparison) {
ASSERT_EQ(ArrowArrayInitFromSchema(actual.get(), schema.get(), nullptr),
NANOARROW_OK);
ASSERT_EQ(ArrowArrayStartAppending(actual.get()), NANOARROW_OK);
ASSERT_EQ(ArrowArrayAppendInt(actual->children[0], 0), NANOARROW_OK);
- ASSERT_EQ(ArrowArrayAppendString(actual->children[0]->dictionary,
ArrowCharView("def")),
+ ASSERT_EQ(ArrowArrayAppendString(actual->children[0]->dictionary, "def"_asv),
NANOARROW_OK);
ASSERT_EQ(ArrowArrayFinishElement(actual.get()), NANOARROW_OK);
ASSERT_EQ(ArrowArrayFinishBuildingDefault(actual.get(), nullptr),
NANOARROW_OK);
diff --git a/src/nanoarrow/schema_test.cc b/src/nanoarrow/schema_test.cc
index 8c23e606..175ea993 100644
--- a/src/nanoarrow/schema_test.cc
+++ b/src/nanoarrow/schema_test.cc
@@ -22,7 +22,7 @@
#include <arrow/testing/gtest_util.h>
#include <arrow/util/key_value_metadata.h>
-#include "nanoarrow/nanoarrow.h"
+#include "nanoarrow/nanoarrow.hpp"
using namespace arrow;
@@ -1495,6 +1495,8 @@ TEST(SchemaViewTest, SchemaViewInitDictionaryErrors) {
}
TEST(SchemaViewTest, SchemaViewInitExtension) {
+ using namespace nanoarrow::literals;
+
struct ArrowSchema schema;
struct ArrowSchemaView schema_view;
struct ArrowError error;
@@ -1506,18 +1508,16 @@ TEST(SchemaViewTest, SchemaViewInitExtension) {
auto int_field = field("field_name", int32(), arrow_meta);
ARROW_EXPECT_OK(ExportField(*int_field, &schema));
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
- EXPECT_EQ(
- std::string(schema_view.extension_name.data,
schema_view.extension_name.size_bytes),
- "arrow.test.ext_name");
- EXPECT_EQ(std::string(schema_view.extension_metadata.data,
- schema_view.extension_metadata.size_bytes),
- "test metadata");
+ EXPECT_EQ(schema_view.extension_name, "arrow.test.ext_name"_asv);
+ EXPECT_EQ(schema_view.extension_metadata, "test metadata"_asv);
EXPECT_EQ(ArrowSchemaToStdString(&schema), "arrow.test.ext_name{int32}");
ArrowSchemaRelease(&schema);
}
TEST(SchemaViewTest, SchemaViewInitExtensionDictionary) {
+ using namespace nanoarrow::literals;
+
struct ArrowSchema schema;
struct ArrowSchemaView schema_view;
struct ArrowError error;
@@ -1531,12 +1531,8 @@ TEST(SchemaViewTest, SchemaViewInitExtensionDictionary) {
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
EXPECT_EQ(schema_view.type, NANOARROW_TYPE_DICTIONARY);
EXPECT_EQ(schema_view.storage_type, NANOARROW_TYPE_INT32);
- EXPECT_EQ(
- std::string(schema_view.extension_name.data,
schema_view.extension_name.size_bytes),
- "arrow.test.ext_name");
- EXPECT_EQ(std::string(schema_view.extension_metadata.data,
- schema_view.extension_metadata.size_bytes),
- "test metadata");
+ EXPECT_EQ(schema_view.extension_name, "arrow.test.ext_name"_asv);
+ EXPECT_EQ(schema_view.extension_metadata, "test metadata"_asv);
EXPECT_EQ(ArrowSchemaToStdString(&schema),
"arrow.test.ext_name{dictionary(int32)<string>}");
@@ -1576,6 +1572,8 @@ TEST(SchemaViewTest, SchemaFormatInvalid) {
}
TEST(MetadataTest, Metadata) {
+ using namespace nanoarrow::literals;
+
// Encoded metadata string for "key": "value"
std::string simple_metadata = SimpleMetadata();
@@ -1583,22 +1581,23 @@ TEST(MetadataTest, Metadata) {
EXPECT_EQ(ArrowMetadataSizeOf(simple_metadata.data()),
static_cast<int64_t>(simple_metadata.size()));
- EXPECT_EQ(ArrowMetadataHasKey(simple_metadata.data(), ArrowCharView("key")),
1);
- EXPECT_EQ(ArrowMetadataHasKey(simple_metadata.data(),
ArrowCharView("not_a_key")), 0);
+ EXPECT_EQ(ArrowMetadataHasKey(simple_metadata.data(), "key"_asv), 1);
+ EXPECT_EQ(ArrowMetadataHasKey(simple_metadata.data(), "not_a_key"_asv), 0);
- struct ArrowStringView value = ArrowCharView("default_val");
- EXPECT_EQ(ArrowMetadataGetValue(simple_metadata.data(),
ArrowCharView("key"), &value),
+ struct ArrowStringView value = "default_val"_asv;
+ EXPECT_EQ(ArrowMetadataGetValue(simple_metadata.data(), "key"_asv, &value),
NANOARROW_OK);
- EXPECT_EQ(std::string(value.data, value.size_bytes), "value");
+ EXPECT_EQ(value, "value"_asv);
- value = ArrowCharView("default_val");
- EXPECT_EQ(
- ArrowMetadataGetValue(simple_metadata.data(),
ArrowCharView("not_a_key"), &value),
- NANOARROW_OK);
- EXPECT_EQ(std::string(value.data, value.size_bytes), "default_val");
+ value = "default_val"_asv;
+ EXPECT_EQ(ArrowMetadataGetValue(simple_metadata.data(), "not_a_key"_asv,
&value),
+ NANOARROW_OK);
+ EXPECT_EQ(value, "default_val"_asv);
}
TEST(MetadataTest, MetadataBuild) {
+ using namespace nanoarrow::literals;
+
// Encoded metadata string for "key": "value"
std::string simple_metadata = SimpleMetadata();
@@ -1618,59 +1617,49 @@ TEST(MetadataTest, MetadataBuild) {
EXPECT_EQ(metadata_builder.data, nullptr);
// Recreate simple_metadata
- ASSERT_EQ(ArrowMetadataBuilderAppend(&metadata_builder, ArrowCharView("key"),
- ArrowCharView("value")),
+ ASSERT_EQ(ArrowMetadataBuilderAppend(&metadata_builder, "key"_asv,
"value"_asv),
NANOARROW_OK);
ASSERT_EQ(metadata_builder.size_bytes, simple_metadata.size());
EXPECT_EQ(memcmp(metadata_builder.data, simple_metadata.data(),
simple_metadata.size()),
0);
// Remove a key that doesn't exist
- ASSERT_EQ(ArrowMetadataBuilderRemove(&metadata_builder,
ArrowCharView("key2")),
- NANOARROW_OK);
+ ASSERT_EQ(ArrowMetadataBuilderRemove(&metadata_builder, "key2"_asv),
NANOARROW_OK);
ASSERT_EQ(metadata_builder.size_bytes, simple_metadata.size());
EXPECT_EQ(
memcmp(metadata_builder.data, simple_metadata.data(),
metadata_builder.size_bytes),
0);
// Add a new key
- ASSERT_EQ(ArrowMetadataBuilderSet(&metadata_builder, ArrowCharView("key2"),
- ArrowCharView("value2")),
+ ASSERT_EQ(ArrowMetadataBuilderSet(&metadata_builder, "key2"_asv,
"value2"_asv),
NANOARROW_OK);
EXPECT_EQ(metadata_builder.size_bytes,
simple_metadata.size() + sizeof(int32_t) + 4 + sizeof(int32_t) +
6);
struct ArrowStringView value = ArrowCharView(nullptr);
- ASSERT_EQ(ArrowMetadataGetValue((const char*)metadata_builder.data,
- ArrowCharView("key2"), &value),
+ ASSERT_EQ(ArrowMetadataGetValue((const char*)metadata_builder.data,
"key2"_asv, &value),
NANOARROW_OK);
- EXPECT_EQ(std::string(value.data, value.size_bytes), "value2");
+ EXPECT_EQ(value, "value2"_asv);
// Set an existing key
- ASSERT_EQ(ArrowMetadataBuilderSet(&metadata_builder, ArrowCharView("key"),
- ArrowCharView("value3")),
+ ASSERT_EQ(ArrowMetadataBuilderSet(&metadata_builder, "key"_asv,
"value3"_asv),
NANOARROW_OK);
value = ArrowCharView(nullptr);
- ASSERT_EQ(ArrowMetadataGetValue((const char*)metadata_builder.data,
- ArrowCharView("key"), &value),
+ ASSERT_EQ(ArrowMetadataGetValue((const char*)metadata_builder.data,
"key"_asv, &value),
NANOARROW_OK);
- EXPECT_EQ(std::string(value.data, value.size_bytes), "value3");
+ EXPECT_EQ(value, "value3"_asv);
value = ArrowCharView(nullptr);
- ASSERT_EQ(ArrowMetadataGetValue((const char*)metadata_builder.data,
- ArrowCharView("key2"), &value),
+ ASSERT_EQ(ArrowMetadataGetValue((const char*)metadata_builder.data,
"key2"_asv, &value),
NANOARROW_OK);
- EXPECT_EQ(std::string(value.data, value.size_bytes), "value2");
+ EXPECT_EQ(value, "value2"_asv);
// Remove a key that does exist
- ASSERT_EQ(ArrowMetadataBuilderRemove(&metadata_builder,
ArrowCharView("key")),
- NANOARROW_OK);
- EXPECT_EQ(ArrowMetadataHasKey((const char*)metadata_builder.data,
ArrowCharView("key")),
- false);
+ ASSERT_EQ(ArrowMetadataBuilderRemove(&metadata_builder, "key"_asv),
NANOARROW_OK);
+ EXPECT_EQ(ArrowMetadataHasKey((const char*)metadata_builder.data,
"key"_asv), false);
value = ArrowCharView(nullptr);
- ASSERT_EQ(ArrowMetadataGetValue((const char*)metadata_builder.data,
- ArrowCharView("key2"), &value),
+ ASSERT_EQ(ArrowMetadataGetValue((const char*)metadata_builder.data,
"key2"_asv, &value),
NANOARROW_OK);
- EXPECT_EQ(std::string(value.data, value.size_bytes), "value2");
+ EXPECT_EQ(value, "value2"_asv);
ArrowBufferReset(&metadata_builder);
}
diff --git a/src/nanoarrow/utils_test.cc b/src/nanoarrow/utils_test.cc
index 3a63df4d..6a753da0 100644
--- a/src/nanoarrow/utils_test.cc
+++ b/src/nanoarrow/utils_test.cc
@@ -286,6 +286,8 @@ TEST(DecimalTest, Decimal128Test) {
}
TEST(DecimalTest, DecimalNegateTest) {
+ using namespace nanoarrow::literals;
+
struct ArrowDecimal decimal;
struct ArrowBuffer buffer;
ArrowBufferInit(&buffer);
@@ -312,9 +314,9 @@ TEST(DecimalTest, DecimalNegateTest) {
std::numeric_limits<uint64_t>::max());
// Check with a large value that fits in the 128 bit size
- ASSERT_EQ(ArrowDecimalSetDigits(
- &decimal,
ArrowCharView("123456789012345678901234567890123456789")),
- NANOARROW_OK);
+ ASSERT_EQ(
+ ArrowDecimalSetDigits(&decimal,
"123456789012345678901234567890123456789"_asv),
+ NANOARROW_OK);
ArrowDecimalNegate(&decimal);
buffer.size_bytes = 0;
@@ -341,6 +343,8 @@ TEST(DecimalTest, DecimalNegateTest) {
}
TEST(DecimalTest, Decimal256Test) {
+ using namespace nanoarrow::literals;
+
struct ArrowDecimal decimal;
ArrowDecimalInit(&decimal, 256, 10, 3);
@@ -378,6 +382,8 @@ TEST(DecimalTest, Decimal256Test) {
}
TEST(DecimalTest, DecimalStringTestBasic) {
+ using namespace nanoarrow::literals;
+
struct ArrowDecimal decimal;
ArrowDecimalInit(&decimal, 128, 39, 0);
@@ -385,7 +391,7 @@ TEST(DecimalTest, DecimalStringTestBasic) {
ArrowBufferInit(&buffer);
// Only spans one 32-bit word
- ASSERT_EQ(ArrowDecimalSetDigits(&decimal, ArrowCharView("123456")),
NANOARROW_OK);
+ ASSERT_EQ(ArrowDecimalSetDigits(&decimal, "123456"_asv), NANOARROW_OK);
EXPECT_EQ(ArrowDecimalGetIntUnsafe(&decimal), 123456);
// Check roundtrip to string
@@ -395,7 +401,7 @@ TEST(DecimalTest, DecimalStringTestBasic) {
"123456");
// Negative value
- ASSERT_EQ(ArrowDecimalSetDigits(&decimal, ArrowCharView("-123456")),
NANOARROW_OK);
+ ASSERT_EQ(ArrowDecimalSetDigits(&decimal, "-123456"_asv), NANOARROW_OK);
EXPECT_EQ(ArrowDecimalGetIntUnsafe(&decimal), -123456);
// Check roundtrip to string
@@ -405,7 +411,7 @@ TEST(DecimalTest, DecimalStringTestBasic) {
"-123456");
// Spans >1 32-bit word
- ASSERT_EQ(ArrowDecimalSetDigits(&decimal, ArrowCharView("1234567899")),
NANOARROW_OK);
+ ASSERT_EQ(ArrowDecimalSetDigits(&decimal, "1234567899"_asv), NANOARROW_OK);
EXPECT_EQ(ArrowDecimalGetIntUnsafe(&decimal), 1234567899L);
// Check roundtrip to string
@@ -415,8 +421,7 @@ TEST(DecimalTest, DecimalStringTestBasic) {
"1234567899");
// Check maximum value of a 64-bit integer
- ASSERT_EQ(ArrowDecimalSetDigits(&decimal,
ArrowCharView("18446744073709551615")),
- NANOARROW_OK);
+ ASSERT_EQ(ArrowDecimalSetDigits(&decimal, "18446744073709551615"_asv),
NANOARROW_OK);
EXPECT_EQ(decimal.words[decimal.low_word_index],
std::numeric_limits<uint64_t>::max());
EXPECT_EQ(decimal.words[decimal.high_word_index], 0);
@@ -427,9 +432,9 @@ TEST(DecimalTest, DecimalStringTestBasic) {
"18446744073709551615");
// Check with the maximum value of a signed 128-bit integer
- ASSERT_EQ(ArrowDecimalSetDigits(
- &decimal,
ArrowCharView("170141183460469231731687303715884105727")),
- NANOARROW_OK);
+ ASSERT_EQ(
+ ArrowDecimalSetDigits(&decimal,
"170141183460469231731687303715884105727"_asv),
+ NANOARROW_OK);
EXPECT_EQ(decimal.words[decimal.low_word_index],
std::numeric_limits<uint64_t>::max());
EXPECT_EQ(decimal.words[decimal.high_word_index],
std::numeric_limits<int64_t>::max());
@@ -457,10 +462,11 @@ TEST(DecimalTest, DecimalStringTestBasic) {
}
TEST(DecimalTest, DecimalStringTestInvalid) {
+ using namespace nanoarrow::literals;
+
struct ArrowDecimal decimal;
ArrowDecimalInit(&decimal, 128, 39, 0);
- EXPECT_EQ(ArrowDecimalSetDigits(&decimal, ArrowCharView("this is not an
integer")),
- EINVAL);
+ EXPECT_EQ(ArrowDecimalSetDigits(&decimal, "this is not an integer"_asv),
EINVAL);
}
TEST(DecimalTest, DecimalRoundtripPowerOfTenTest) {
