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 85adb56c chore(ci): Fix tests for centos7 and s390x (#642)
85adb56c is described below
commit 85adb56cdd095910a29c4227948a2109fbda5b8b
Author: Dewey Dunnington <[email protected]>
AuthorDate: Wed Oct 2 16:28:46 2024 -0500
chore(ci): Fix tests for centos7 and s390x (#642)
A few tests were failing on the centos7 run, which these days mostly
checks for accidental C++17 or R >= 4.0 usage or Arrow > 9.0.0 usage in
the tests.
Closes #640.
Checked with:
```bash
export NANOARROW_PLATFORM=centos7
docker compose run --rm verify
```
and
```bash
export NANOARROW_PLATFORM=alpine
export NANOARROW_ARCH=s390x
docker compose run --rm verify
```
---
r/tests/testthat/test-ipc.R | 10 +++----
src/nanoarrow/common/array_test.cc | 59 +++++++++++++++++++++++--------------
src/nanoarrow/common/schema_test.cc | 9 ++++++
src/nanoarrow/ipc/decoder_test.cc | 16 ++++++++++
4 files changed, 67 insertions(+), 27 deletions(-)
diff --git a/r/tests/testthat/test-ipc.R b/r/tests/testthat/test-ipc.R
index 3944de4b..8a4c2bfe 100644
--- a/r/tests/testthat/test-ipc.R
+++ b/r/tests/testthat/test-ipc.R
@@ -103,7 +103,7 @@ test_that("write_nanoarrow() works for file paths", {
tf <- tempfile()
on.exit(unlink(tf))
- df <- data.frame(letters = letters)
+ df <- data.frame(letters = letters, stringsAsFactors = FALSE)
expect_identical(write_nanoarrow(df, tf), df)
expect_identical(as.data.frame(read_nanoarrow(tf)), df)
})
@@ -127,7 +127,7 @@ test_that("write_nanoarrow() works for URLs", {
tf <- tempfile()
on.exit(unlink(tf))
- df <- data.frame(letters = letters)
+ df <- data.frame(letters = letters, stringsAsFactors = FALSE)
expect_identical(write_nanoarrow(df, paste0("file://", tf)), df)
expect_identical(as.data.frame(read_nanoarrow(tf)), df)
})
@@ -151,7 +151,7 @@ test_that("write_nanoarrow() works for compressed .gz file
paths", {
tf <- tempfile(fileext = ".gz")
on.exit(unlink(tf))
- df <- data.frame(letters = letters)
+ df <- data.frame(letters = letters, stringsAsFactors = FALSE)
expect_identical(write_nanoarrow(df, tf), df)
expect_identical(as.data.frame(read_nanoarrow(tf)), df)
})
@@ -175,7 +175,7 @@ test_that("write_nanoarrow() works for compressed .bz2 file
paths", {
tf <- tempfile(fileext = ".bz2")
on.exit(unlink(tf))
- df <- data.frame(letters = letters)
+ df <- data.frame(letters = letters, stringsAsFactors = FALSE)
expect_identical(write_nanoarrow(df, tf), df)
expect_identical(as.data.frame(read_nanoarrow(tf)), df)
})
@@ -212,7 +212,7 @@ test_that("write_nanoarrow() errors for compressed .zip
file paths", {
tf <- tempfile(fileext = ".zip")
on.exit(unlink(tf))
- df <- data.frame(letters = letters)
+ df <- data.frame(letters = letters, stringsAsFactors = FALSE)
expect_error(
write_nanoarrow(df, tf),
"zip compression not supported"
diff --git a/src/nanoarrow/common/array_test.cc
b/src/nanoarrow/common/array_test.cc
index 37443cd4..5ef77029 100644
--- a/src/nanoarrow/common/array_test.cc
+++ b/src/nanoarrow/common/array_test.cc
@@ -895,12 +895,12 @@ TEST(ArrayTest, ArrayTestAppendToLargeStringArray) {
ArrowArrayRelease(&array);
}
-template <enum ArrowType ArrowT, typename ValueT>
void TestAppendToInlinedDataViewArray(
- std::function<ArrowErrorCode(struct ArrowArray*, ValueT)> AppendFunc) {
+ enum ArrowType arrow_type,
+ std::function<ArrowErrorCode(struct ArrowArray*, const char*)> AppendFunc)
{
struct ArrowArray array;
- ASSERT_EQ(ArrowArrayInitFromType(&array, ArrowT), NANOARROW_OK);
+ ASSERT_EQ(ArrowArrayInitFromType(&array, arrow_type), NANOARROW_OK);
EXPECT_EQ(ArrowArrayStartAppending(&array), NANOARROW_OK);
// Check that we can reserve
@@ -908,7 +908,7 @@ void TestAppendToInlinedDataViewArray(
EXPECT_EQ(ArrowArrayBuffer(&array, 1)->capacity_bytes,
5 * sizeof(union ArrowBinaryView));
- EXPECT_EQ(AppendFunc(&array, ValueT{{"inlinestring"}, 12}), NANOARROW_OK);
+ EXPECT_EQ(AppendFunc(&array, "inlinestring"), NANOARROW_OK);
EXPECT_EQ(ArrowArrayAppendNull(&array, 2), NANOARROW_OK);
EXPECT_EQ(ArrowArrayAppendEmpty(&array, 1), NANOARROW_OK);
EXPECT_EQ(ArrowArrayFinishBuildingDefault(&array, nullptr), NANOARROW_OK);
@@ -934,12 +934,12 @@ void TestAppendToInlinedDataViewArray(
ArrowArrayRelease(&array);
};
-template <enum ArrowType ArrowT, typename ValueT>
void TestAppendToDataViewArray(
- std::function<ArrowErrorCode(struct ArrowArray*, ValueT)> AppendFunc) {
+ enum ArrowType arrow_type,
+ std::function<ArrowErrorCode(struct ArrowArray*, const char*)> AppendFunc)
{
struct ArrowArray array;
- ASSERT_EQ(ArrowArrayInitFromType(&array, ArrowT), NANOARROW_OK);
+ ASSERT_EQ(ArrowArrayInitFromType(&array, arrow_type), NANOARROW_OK);
EXPECT_EQ(ArrowArrayStartAppending(&array), NANOARROW_OK);
// Check that we can reserve
@@ -951,15 +951,12 @@ void TestAppendToDataViewArray(
std::string filler(NANOARROW_BINARY_VIEW_BLOCK_SIZE - 34, 'x');
std::string str2{"goes_into_second_variadic_buffer"};
- EXPECT_EQ(AppendFunc(&array, ValueT{{"1234"}, 4}), NANOARROW_OK);
+ EXPECT_EQ(AppendFunc(&array, "1234"), NANOARROW_OK);
EXPECT_EQ(ArrowArrayAppendNull(&array, 2), NANOARROW_OK);
- EXPECT_EQ(AppendFunc(&array, {{str1.c_str()},
static_cast<int64_t>(str1.size())}),
- NANOARROW_OK);
+ EXPECT_EQ(AppendFunc(&array, str1.c_str()), NANOARROW_OK);
EXPECT_EQ(ArrowArrayAppendEmpty(&array, 1), NANOARROW_OK);
- EXPECT_EQ(AppendFunc(&array, {{filler.c_str()},
static_cast<int64_t>(filler.size())}),
- NANOARROW_OK);
- EXPECT_EQ(AppendFunc(&array, {{str2.c_str()},
static_cast<int64_t>(str2.size())}),
- NANOARROW_OK);
+ EXPECT_EQ(AppendFunc(&array, filler.c_str()), NANOARROW_OK);
+ EXPECT_EQ(AppendFunc(&array, str2.c_str()), NANOARROW_OK);
EXPECT_EQ(ArrowArrayFinishBuildingDefault(&array, nullptr), NANOARROW_OK);
EXPECT_EQ(array.length, 7);
@@ -1004,17 +1001,27 @@ void TestAppendToDataViewArray(
};
TEST(ArrayTest, ArrayTestAppendToBinaryViewArray) {
- TestAppendToInlinedDataViewArray<NANOARROW_TYPE_STRING_VIEW, struct
ArrowStringView>(
- ArrowArrayAppendString);
- TestAppendToDataViewArray<NANOARROW_TYPE_STRING_VIEW, struct
ArrowStringView>(
- ArrowArrayAppendString);
+ TestAppendToInlinedDataViewArray(
+ NANOARROW_TYPE_STRING_VIEW, [&](ArrowArray* array, const char* value) {
+ return ArrowArrayAppendString(array, ArrowCharView(value));
+ });
+
+ TestAppendToDataViewArray(NANOARROW_TYPE_STRING_VIEW,
+ [&](ArrowArray* array, const char* value) {
+ return ArrowArrayAppendString(array,
ArrowCharView(value));
+ });
};
TEST(ArrayTest, ArrayTestAppendToStringViewArray) {
- TestAppendToInlinedDataViewArray<NANOARROW_TYPE_BINARY_VIEW, struct
ArrowBufferView>(
- ArrowArrayAppendBytes);
- TestAppendToDataViewArray<NANOARROW_TYPE_BINARY_VIEW, struct
ArrowBufferView>(
- ArrowArrayAppendBytes);
+ TestAppendToInlinedDataViewArray(NANOARROW_TYPE_BINARY_VIEW, [&](ArrowArray*
array,
+ const char*
value) {
+ return ArrowArrayAppendBytes(array, {{value},
static_cast<int64_t>(strlen(value))});
+ });
+
+ TestAppendToDataViewArray(NANOARROW_TYPE_BINARY_VIEW, [&](ArrowArray* array,
+ const char* value)
{
+ return ArrowArrayAppendBytes(array, {{value},
static_cast<int64_t>(strlen(value))});
+ });
};
TEST(ArrayTest, ArrayTestAppendToFixedSizeBinaryArray) {
@@ -3562,15 +3569,20 @@ void TestGetFromBinaryView(
}
TEST(ArrayViewTest, ArrayViewTestGetStringView) {
+#if defined(ARROW_VERSION_MAJOR) && ARROW_VERSION_MAJOR >= 15
auto string_view_builder = StringViewBuilder();
const auto get_string_view = [](const struct ArrowStringView* sv) { return
sv->data; };
TestGetFromInlinedBinaryView<StringViewBuilder, struct ArrowStringView>(
string_view_builder, ArrowArrayViewGetStringUnsafe, get_string_view);
TestGetFromBinaryView<StringViewBuilder, struct ArrowStringView>(
string_view_builder, ArrowArrayViewGetStringUnsafe, get_string_view);
+#else
+ GTEST_SKIP() << "Arrow C++ StringView compatibility test needs Arrow C++ >=
15";
+#endif
}
TEST(ArrayViewTest, ArrayViewTestGetBinaryView) {
+#if defined(ARROW_VERSION_MAJOR) && ARROW_VERSION_MAJOR >= 15
auto binary_view_builder = BinaryViewBuilder();
const auto get_buffer_view = [](const struct ArrowBufferView* bv) {
return bv->data.data;
@@ -3579,6 +3591,9 @@ TEST(ArrayViewTest, ArrayViewTestGetBinaryView) {
binary_view_builder, ArrowArrayViewGetBytesUnsafe, get_buffer_view);
TestGetFromBinaryView<BinaryViewBuilder, struct ArrowBufferView>(
binary_view_builder, ArrowArrayViewGetBytesUnsafe, get_buffer_view);
+#else
+ GTEST_SKIP() << "Arrow C++ StringView compatibility test needs Arrow C++ >=
15";
+#endif
}
TEST(ArrayViewTest, ArrayViewTestGetIntervalYearMonth) {
diff --git a/src/nanoarrow/common/schema_test.cc
b/src/nanoarrow/common/schema_test.cc
index df0d1aba..163f96c7 100644
--- a/src/nanoarrow/common/schema_test.cc
+++ b/src/nanoarrow/common/schema_test.cc
@@ -912,7 +912,13 @@ TEST(SchemaViewTest, SchemaViewInitBinaryAndString) {
EXPECT_EQ(schema_view.layout.element_size_bits[2], 0);
EXPECT_EQ(ArrowSchemaToStdString(&schema), "large_string");
ArrowSchemaRelease(&schema);
+}
+TEST(SchemaViewTest, SchemaViewInitBinaryAndStringView) {
+#if defined(ARROW_VERSION_MAJOR) && ARROW_VERSION_MAJOR >= 15
+ struct ArrowSchema schema;
+ struct ArrowSchemaView schema_view;
+ struct ArrowError error;
ARROW_EXPECT_OK(ExportType(*utf8_view(), &schema));
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
EXPECT_EQ(schema_view.type, NANOARROW_TYPE_STRING_VIEW);
@@ -938,6 +944,9 @@ TEST(SchemaViewTest, SchemaViewInitBinaryAndString) {
EXPECT_EQ(schema_view.layout.element_size_bits[1], 128);
EXPECT_EQ(ArrowSchemaToStdString(&schema), "binary_view");
ArrowSchemaRelease(&schema);
+#else
+ GTEST_SKIP() << "Arrow C++ StringView compatibility test needs Arrow C++ >=
15";
+#endif
}
TEST(SchemaViewTest, SchemaViewInitBinaryAndStringErrors) {
diff --git a/src/nanoarrow/ipc/decoder_test.cc
b/src/nanoarrow/ipc/decoder_test.cc
index f5e54dd2..88cd7d99 100644
--- a/src/nanoarrow/ipc/decoder_test.cc
+++ b/src/nanoarrow/ipc/decoder_test.cc
@@ -132,14 +132,30 @@ TEST(NanoarrowIpcTest, NanoarrowIpcCheckHeader) {
uint32_t eight_bad_bytes[] = {negative_one_le * 256, 999};
data.data.as_uint32 = eight_bad_bytes;
data.size_bytes = sizeof(eight_bad_bytes);
+
+#if defined(__BIG_ENDIAN__)
+ EXPECT_EQ(ArrowIpcDecoderVerifyHeader(&decoder, data, &error), ESPIPE);
+ EXPECT_STREQ(
+ error.message,
+ "Expected >= 16777219 bytes of remaining data but found 8 bytes in
buffer");
+#else
EXPECT_EQ(ArrowIpcDecoderVerifyHeader(&decoder, data, &error), EINVAL);
EXPECT_STREQ(error.message,
"Expected 0xFFFFFFFF at start of message but found 0xFFFFFF00");
+#endif
ArrowErrorInit(&error);
+
+#if defined(__BIG_ENDIAN__)
+ EXPECT_EQ(ArrowIpcDecoderDecodeHeader(&decoder, data, &error), ESPIPE);
+ EXPECT_STREQ(
+ error.message,
+ "Expected >= 16777219 bytes of remaining data but found 8 bytes in
buffer");
+#else
EXPECT_EQ(ArrowIpcDecoderDecodeHeader(&decoder, data, &error), EINVAL);
EXPECT_STREQ(error.message,
"Expected 0xFFFFFFFF at start of message but found 0xFFFFFF00");
+#endif
eight_bad_bytes[0] = 0xFFFFFFFF;
eight_bad_bytes[1] = negative_one_le;
