From 43a8d92fae37aae48ddefdc12ffe85f5165f104e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Efe=20G=C3=B6kdemir?= Date: Sun, 1 Nov 2026 19:57:46 +0300 Subject: [PATCH 1/2] fix: validate list-view size buffers --- src/nanoarrow/common/array.c | 7 ++- src/nanoarrow/common/array_test.cc | 94 ++++++++++++++++++++++++++++++ 2 files changed, 98 insertions(+), 3 deletions(-) diff --git a/src/nanoarrow/common/array.c b/src/nanoarrow/common/array.c index ee308ea61..dc4b13791 100644 --- a/src/nanoarrow/common/array.c +++ b/src/nanoarrow/common/array.c @@ -1616,9 +1616,10 @@ static int ArrowArrayViewValidateMinimal(struct ArrowArrayView* array_view, // unknown, assign the buffer size; otherwise, validate it. int64_t offset_plus_length = array_view->offset + array_view->length; - // Only loop over the first two buffers because the size of the third buffer - // is always data dependent for all current Arrow types. - for (int i = 0; i < 2; i++) { + // List views also have a fixed-size buffer containing element sizes. + const int n_buffers = + array_view->layout.buffer_type[2] == NANOARROW_BUFFER_TYPE_SIZE ? 3 : 2; + for (int i = 0; i < n_buffers; i++) { int64_t element_size_bytes = array_view->layout.element_size_bits[i] / 8; // Initialize with a value that will cause an error if accidentally used uninitialized // Need to suppress the clang-tidy warning because gcc warns for possible use diff --git a/src/nanoarrow/common/array_test.cc b/src/nanoarrow/common/array_test.cc index 31f442708..1aaa2fc03 100644 --- a/src/nanoarrow/common/array_test.cc +++ b/src/nanoarrow/common/array_test.cc @@ -3660,6 +3660,100 @@ TEST(ArrayTest, ArrayViewTestListView) { ArrowArrayViewReset(&array_view); } +class ListViewSizeBufferTest : public ::testing::TestWithParam { + protected: + void SetUp() override { + ArrowArrayViewInitFromType(array_view.get(), GetParam()); + ASSERT_EQ(ArrowArrayViewAllocateChildren(array_view.get(), 1), NANOARROW_OK); + ArrowArrayViewInitFromType(array_view->children[0], NANOARROW_TYPE_NA); + element_size = array_view->layout.element_size_bits[2] / 8; + array_view->buffer_views[1].data.data = offsets; + array_view->buffer_views[1].size_bytes = sizeof(offsets); + array_view->buffer_views[2].data.data = sizes; + } + + nanoarrow::UniqueArrayView array_view; + int64_t element_size; + int64_t offsets[2] = {0, 0}; + int64_t sizes[2] = {0, 0}; +}; + +TEST_P(ListViewSizeBufferTest, RejectsMissingSizes) { + struct ArrowArray child = {}; + struct ArrowArray* children[] = {&child}; + const void* buffers[] = {nullptr, offsets, nullptr}; + struct ArrowArray array = {}; + array.length = 1; + array.n_buffers = 3; + array.buffers = buffers; + array.n_children = 1; + array.children = children; + struct ArrowError error; + + EXPECT_EQ(ArrowArrayViewSetArray(array_view.get(), &array, &error), EINVAL); +} + +TEST_P(ListViewSizeBufferTest, RejectsShortSizes) { + struct ArrowError error; + array_view->length = 1; + for (int64_t offset : {0, 1}) { + array_view->offset = offset; + const int64_t required_size = (offset + array_view->length) * element_size; + for (int64_t size = 0; size < required_size; size++) { + array_view->buffer_views[2].size_bytes = size; + for (auto level : + {NANOARROW_VALIDATION_LEVEL_MINIMAL, NANOARROW_VALIDATION_LEVEL_DEFAULT, + NANOARROW_VALIDATION_LEVEL_FULL}) { + ASSERT_EQ(ArrowArrayViewValidate(array_view.get(), level, &error), EINVAL) + << "offset: " << offset << ", size: " << size << ", level: " << level; + } + } + } +} + +TEST_P(ListViewSizeBufferTest, InfersUnknownSizes) { + struct ArrowError error; + array_view->length = 1; + array_view->offset = 1; + for (auto level : + {NANOARROW_VALIDATION_LEVEL_MINIMAL, NANOARROW_VALIDATION_LEVEL_DEFAULT, + NANOARROW_VALIDATION_LEVEL_FULL}) { + array_view->buffer_views[2].size_bytes = -1; + ASSERT_EQ(ArrowArrayViewValidate(array_view.get(), level, &error), NANOARROW_OK) + << error.message; + EXPECT_EQ(array_view->buffer_views[2].size_bytes, 2 * element_size); + } +} + +TEST_P(ListViewSizeBufferTest, AcceptsSufficientSizes) { + struct ArrowError error; + array_view->length = 1; + for (int64_t offset : {0, 1}) { + array_view->offset = offset; + array_view->buffer_views[2].size_bytes = (offset + 1) * element_size; + EXPECT_EQ( + ArrowArrayViewValidate(array_view.get(), NANOARROW_VALIDATION_LEVEL_FULL, &error), + NANOARROW_OK) + << error.message; + } +} + +TEST_P(ListViewSizeBufferTest, AcceptsEmptySizes) { + struct ArrowError error; + array_view->buffer_views[1].data.data = nullptr; + array_view->buffer_views[1].size_bytes = 0; + array_view->buffer_views[2].data.data = nullptr; + array_view->buffer_views[2].size_bytes = 0; + EXPECT_EQ( + ArrowArrayViewValidate(array_view.get(), NANOARROW_VALIDATION_LEVEL_FULL, &error), + NANOARROW_OK) + << error.message; +} + +INSTANTIATE_TEST_SUITE_P(ArrayTest, ListViewSizeBufferTest, + ::testing::Values(NANOARROW_TYPE_LIST_VIEW, + NANOARROW_TYPE_LARGE_LIST_VIEW)); + TEST(ArrayTest, ArrayViewTestListViewGet) { struct ArrowArrayView array_view; ArrowArrayViewInitFromType(&array_view, NANOARROW_TYPE_LIST_VIEW); From 3696f095d07e2aa6ceb87db2445312b76973c2dd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Efe=20G=C3=B6kdemir?= Date: Sun, 1 Nov 2026 20:22:40 +0300 Subject: [PATCH 2/2] test(r): normalise str spacing in array snapshots --- r/tests/testthat/test-array.R | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/r/tests/testthat/test-array.R b/r/tests/testthat/test-array.R index e2169d19e..17562e142 100644 --- a/r/tests/testthat/test-array.R +++ b/r/tests/testthat/test-array.R @@ -38,14 +38,19 @@ test_that("schemaless nanoarrow_array format, print, and str methods work", { }) test_that("string/binary view nanoarrow_array buffers print correctly", { + # str() spacing differs between R versions. + normalize_str_output <- function(x) { + gsub(": (List of|