From a8f58800bba823756d8d4becfffcf2d7b7334838 Mon Sep 17 00:00:00 2001 From: Dewey Dunnington Date: Tue, 9 Apr 2024 14:56:11 -0300 Subject: [PATCH] compiler warnings --- dev/benchmarks/c/array_benchmark.cc | 8 +- src/nanoarrow/array_test.cc | 4 +- src/nanoarrow/buffer_test.cc | 21 ++-- .../integration/c_data_integration.cc | 2 + src/nanoarrow/nanoarrow.hpp | 2 + src/nanoarrow/nanoarrow_testing.hpp | 22 ++-- src/nanoarrow/nanoarrow_testing_test.cc | 111 ++++++++---------- src/nanoarrow/schema_test.cc | 3 +- src/nanoarrow/utils_test.cc | 2 + 9 files changed, 91 insertions(+), 84 deletions(-) diff --git a/dev/benchmarks/c/array_benchmark.cc b/dev/benchmarks/c/array_benchmark.cc index d81b80d46..9e028fcb2 100644 --- a/dev/benchmarks/c/array_benchmark.cc +++ b/dev/benchmarks/c/array_benchmark.cc @@ -231,7 +231,7 @@ static void BenchmarkArrayViewGetString(benchmark::State& state) { int64_t n_alphabets = n_values / alphabet.size() + 1; std::vector data(alphabet.size() * n_alphabets); - for (int64_t data_pos = 0; data_pos < data.size(); data_pos += alphabet.size()) { + for (size_t data_pos = 0; data_pos < data.size(); data_pos += alphabet.size()) { memcpy(data.data() + data_pos, alphabet.data(), alphabet.size()); } @@ -262,7 +262,7 @@ static ArrowErrorCode CreateAndAppendToArrayInt(ArrowArray* array, NANOARROW_RETURN_NOT_OK(ArrowArrayInitFromType(array, type)); NANOARROW_RETURN_NOT_OK(ArrowArrayStartAppending(array)); - for (int64_t i = 0; i < values.size(); i++) { + for (size_t i = 0; i < values.size(); i++) { NANOARROW_RETURN_NOT_OK(ArrowArrayAppendInt(array, values[i])); } @@ -293,7 +293,7 @@ static void BenchmarkArrayAppendString(benchmark::State& state) { int64_t value_size = 7; std::vector values(n_values); - int64_t alphabet_pos = 0; + size_t alphabet_pos = 0; for (std::string& value : values) { if ((alphabet_pos + value_size) >= kAlphabet.size()) { alphabet_pos = 0; @@ -361,7 +361,7 @@ static ArrowErrorCode CreateAndAppendIntWithNulls(ArrowArray* array, NANOARROW_RETURN_NOT_OK(ArrowArrayStartAppending(array)); CType non_null_value = std::numeric_limits::max() / 2; - for (int64_t i = 0; i < validity.size(); i++) { + for (size_t i = 0; i < validity.size(); i++) { if (validity[i]) { NANOARROW_RETURN_NOT_OK(ArrowArrayAppendInt(array, non_null_value)); } else { diff --git a/src/nanoarrow/array_test.cc b/src/nanoarrow/array_test.cc index 364e26182..81360b0a7 100644 --- a/src/nanoarrow/array_test.cc +++ b/src/nanoarrow/array_test.cc @@ -848,9 +848,9 @@ TEST(ArrayTest, ArrayTestAppendToFixedSizeBinaryArray) { ASSERT_EQ(ArrowArrayReserve(&array, 5), NANOARROW_OK); EXPECT_EQ(ArrowArrayBuffer(&array, 1)->capacity_bytes, 5 * 5); - EXPECT_EQ(ArrowArrayAppendBytes(&array, {"12345", 5}), NANOARROW_OK); + EXPECT_EQ(ArrowArrayAppendBytes(&array, {{"12345"}, 5}), NANOARROW_OK); EXPECT_EQ(ArrowArrayAppendNull(&array, 2), NANOARROW_OK); - EXPECT_EQ(ArrowArrayAppendBytes(&array, {"67890", 5}), NANOARROW_OK); + EXPECT_EQ(ArrowArrayAppendBytes(&array, {{"67890"}, 5}), NANOARROW_OK); EXPECT_EQ(ArrowArrayAppendEmpty(&array, 1), NANOARROW_OK); EXPECT_EQ(ArrowArrayFinishBuildingDefault(&array, nullptr), NANOARROW_OK); diff --git a/src/nanoarrow/buffer_test.cc b/src/nanoarrow/buffer_test.cc index 4cf196b5d..5c14161db 100644 --- a/src/nanoarrow/buffer_test.cc +++ b/src/nanoarrow/buffer_test.cc @@ -29,6 +29,7 @@ static uint8_t* TestAllocatorReallocate(struct ArrowBufferAllocator* allocator, uint8_t* ptr, int64_t old_size, int64_t new_size) { + NANOARROW_UNUSED(allocator); uint8_t* new_ptr = reinterpret_cast(malloc(new_size)); int64_t copy_size = std::min(old_size, new_size); @@ -45,6 +46,8 @@ static uint8_t* TestAllocatorReallocate(struct ArrowBufferAllocator* allocator, static void TestAllocatorFree(struct ArrowBufferAllocator* allocator, uint8_t* ptr, int64_t size) { + NANOARROW_UNUSED(allocator); + NANOARROW_UNUSED(size); free(ptr); } @@ -188,7 +191,7 @@ TEST(BufferTest, BufferTestAppendHelpers) { ArrowBufferReset(&buffer); EXPECT_EQ(ArrowBufferAppendUInt8(&buffer, 123), NANOARROW_OK); - EXPECT_EQ(reinterpret_cast(buffer.data)[0], 123); + EXPECT_EQ(reinterpret_cast(buffer.data)[0], 123U); ArrowBufferReset(&buffer); EXPECT_EQ(ArrowBufferAppendInt16(&buffer, 123), NANOARROW_OK); @@ -196,7 +199,7 @@ TEST(BufferTest, BufferTestAppendHelpers) { ArrowBufferReset(&buffer); EXPECT_EQ(ArrowBufferAppendUInt16(&buffer, 123), NANOARROW_OK); - EXPECT_EQ(reinterpret_cast(buffer.data)[0], 123); + EXPECT_EQ(reinterpret_cast(buffer.data)[0], 123U); ArrowBufferReset(&buffer); EXPECT_EQ(ArrowBufferAppendInt32(&buffer, 123), NANOARROW_OK); @@ -204,7 +207,7 @@ TEST(BufferTest, BufferTestAppendHelpers) { ArrowBufferReset(&buffer); EXPECT_EQ(ArrowBufferAppendUInt32(&buffer, 123), NANOARROW_OK); - EXPECT_EQ(reinterpret_cast(buffer.data)[0], 123); + EXPECT_EQ(reinterpret_cast(buffer.data)[0], 123U); ArrowBufferReset(&buffer); EXPECT_EQ(ArrowBufferAppendInt64(&buffer, 123), NANOARROW_OK); @@ -212,7 +215,7 @@ TEST(BufferTest, BufferTestAppendHelpers) { ArrowBufferReset(&buffer); EXPECT_EQ(ArrowBufferAppendUInt64(&buffer, 123), NANOARROW_OK); - EXPECT_EQ(reinterpret_cast(buffer.data)[0], 123); + EXPECT_EQ(reinterpret_cast(buffer.data)[0], 123U); ArrowBufferReset(&buffer); EXPECT_EQ(ArrowBufferAppendDouble(&buffer, 123), NANOARROW_OK); @@ -241,7 +244,7 @@ TEST(BitmapTest, BitmapTestElement) { uint8_t bitmap[10]; memset(bitmap, 0xff, sizeof(bitmap)); - for (int i = 0; i < sizeof(bitmap) * 8; i++) { + for (size_t i = 0; i < sizeof(bitmap) * 8; i++) { EXPECT_EQ(ArrowBitGet(bitmap, i), 1); } @@ -256,7 +259,7 @@ TEST(BitmapTest, BitmapTestElement) { EXPECT_EQ(ArrowBitGet(bitmap, 16 + 7), 1); memset(bitmap, 0x00, sizeof(bitmap)); - for (int i = 0; i < sizeof(bitmap) * 8; i++) { + for (size_t i = 0; i < sizeof(bitmap) * 8; i++) { EXPECT_EQ(ArrowBitGet(bitmap, i), 0); } @@ -271,7 +274,7 @@ TEST(BitmapTest, BitmapTestElement) { EXPECT_EQ(ArrowBitGet(bitmap, 16 + 7), 0); } -template +template void TestArrowBitmapUnpackUnsafe(const uint8_t* bitmap, std::vector expected) { int8_t out[length]; int32_t out32[length]; @@ -281,12 +284,12 @@ void TestArrowBitmapUnpackUnsafe(const uint8_t* bitmap, std::vector expe ASSERT_EQ(length, expected.size()); ArrowBitsUnpackInt8(bitmap, offset, length, out); - for (int i = 0; i < length; i++) { + for (size_t i = 0; i < length; i++) { EXPECT_EQ(out[i], expected[i]); } ArrowBitsUnpackInt32(bitmap, offset, length, out32); - for (int i = 0; i < length; i++) { + for (size_t i = 0; i < length; i++) { EXPECT_EQ(out32[i], expected[i]); } } diff --git a/src/nanoarrow/integration/c_data_integration.cc b/src/nanoarrow/integration/c_data_integration.cc index 6ab09ea71..3660af7c3 100644 --- a/src/nanoarrow/integration/c_data_integration.cc +++ b/src/nanoarrow/integration/c_data_integration.cc @@ -28,6 +28,7 @@ static int64_t kBytesAllocated = 0; static uint8_t* IntegrationTestReallocate(ArrowBufferAllocator* allocator, uint8_t* ptr, int64_t old_size, int64_t new_size) { + NANOARROW_UNUSED(allocator); ArrowBufferAllocator default_allocator = ArrowBufferAllocatorDefault(); kBytesAllocated -= old_size; uint8_t* out = @@ -41,6 +42,7 @@ static uint8_t* IntegrationTestReallocate(ArrowBufferAllocator* allocator, uint8 static void IntegrationTestFree(struct ArrowBufferAllocator* allocator, uint8_t* ptr, int64_t size) { + NANOARROW_UNUSED(allocator); ArrowBufferAllocator default_allocator = ArrowBufferAllocatorDefault(); kBytesAllocated -= size; default_allocator.free(&default_allocator, ptr, size); diff --git a/src/nanoarrow/nanoarrow.hpp b/src/nanoarrow/nanoarrow.hpp index 09a031511..aa8b248ae 100644 --- a/src/nanoarrow/nanoarrow.hpp +++ b/src/nanoarrow/nanoarrow.hpp @@ -244,6 +244,8 @@ class Unique { template static inline void DeallocateWrappedBuffer(struct ArrowBufferAllocator* allocator, uint8_t* ptr, int64_t size) { + NANOARROW_UNUSED(ptr); + NANOARROW_UNUSED(size); auto obj = reinterpret_cast(allocator->private_data); delete obj; } diff --git a/src/nanoarrow/nanoarrow_testing.hpp b/src/nanoarrow/nanoarrow_testing.hpp index 4e39ee09b..a7602b700 100644 --- a/src/nanoarrow/nanoarrow_testing.hpp +++ b/src/nanoarrow/nanoarrow_testing.hpp @@ -1105,7 +1105,7 @@ class TestingJSONReader { } else if (num_batch == kNumBatchReadAll) { batch_ids.resize(batches.size()); std::iota(batch_ids.begin(), batch_ids.end(), 0); - } else if (num_batch >= 0 && num_batch < batches.size()) { + } else if (num_batch >= 0 && static_cast(num_batch) < batches.size()) { batch_ids.push_back(num_batch); } else { ArrowErrorSet(error, "Expected num_batch between 0 and %d but got %d", @@ -1887,8 +1887,9 @@ class TestingJSONReader { const auto& columns = value["columns"]; NANOARROW_RETURN_NOT_OK( Check(columns.is_array(), error, "RecordBatch columns must be array")); - NANOARROW_RETURN_NOT_OK(Check(columns.size() == array_view->n_children, error, - "RecordBatch children has incorrect size")); + NANOARROW_RETURN_NOT_OK( + Check(columns.size() == static_cast(array_view->n_children), error, + "RecordBatch children has incorrect size")); for (int64_t i = 0; i < array_view->n_children; i++) { NANOARROW_RETURN_NOT_OK(SetArrayColumn(columns[i], schema->children[i], @@ -1987,8 +1988,9 @@ class TestingJSONReader { const auto& children = value["children"]; NANOARROW_RETURN_NOT_OK( Check(children.is_array(), error, error_prefix + "children must be array")); - NANOARROW_RETURN_NOT_OK(Check(children.size() == array_view->n_children, error, - error_prefix + "children has incorrect size")); + NANOARROW_RETURN_NOT_OK( + Check(children.size() == static_cast(array_view->n_children), error, + error_prefix + "children has incorrect size")); for (int64_t i = 0; i < array_view->n_children; i++) { NANOARROW_RETURN_NOT_OK(SetArrayColumn(children[i], schema->children[i], @@ -2272,7 +2274,8 @@ class TestingJSONReader { // Check offsets against values const T* expected_offset = reinterpret_cast(offsets->data); NANOARROW_RETURN_NOT_OK(Check( - offsets->size_bytes == ((value.size() + 1) * sizeof(T)), error, + static_cast(offsets->size_bytes) == ((value.size() + 1) * sizeof(T)), + error, "Expected offset buffer with " + std::to_string(value.size()) + " elements")); NANOARROW_RETURN_NOT_OK( Check(*expected_offset++ == 0, error, "first offset must be zero")); @@ -2310,7 +2313,8 @@ class TestingJSONReader { // Check offsets against values if not fixed size const T* expected_offset = reinterpret_cast(offsets->data); NANOARROW_RETURN_NOT_OK(Check( - offsets->size_bytes == ((value.size() + 1) * sizeof(T)), error, + static_cast(offsets->size_bytes) == ((value.size() + 1) * sizeof(T)), + error, "Expected offset buffer with " + std::to_string(value.size()) + " elements")); NANOARROW_RETURN_NOT_OK( Check(*expected_offset++ == 0, error, "first offset must be zero")); @@ -2355,7 +2359,7 @@ class TestingJSONReader { Check(item.is_string(), error, "binary data buffer item must be string")); auto item_str = item.get(); - int64_t item_size_bytes = item_str.size() / 2; + size_t item_size_bytes = item_str.size() / 2; NANOARROW_RETURN_NOT_OK(Check((item_size_bytes * 2) == item_str.size(), error, "binary data buffer item must have even size")); @@ -2502,7 +2506,7 @@ class TestingJSONComparison { public: /// \brief Returns the number of differences found by the previous call - size_t num_differences() const { return differences_.size(); } + int64_t num_differences() const { return differences_.size(); } /// \brief Dump a human-readable summary of differences to out void WriteDifferences(std::ostream& out) { diff --git a/src/nanoarrow/nanoarrow_testing_test.cc b/src/nanoarrow/nanoarrow_testing_test.cc index ce1e873e3..4fcb9b69f 100644 --- a/src/nanoarrow/nanoarrow_testing_test.cc +++ b/src/nanoarrow/nanoarrow_testing_test.cc @@ -39,21 +39,24 @@ ArrowErrorCode WriteColumnJSON(std::ostream& out, TestingJSONWriter& writer, ArrowErrorCode WriteSchemaJSON(std::ostream& out, TestingJSONWriter& writer, const ArrowSchema* schema, ArrowArrayView* array_view) { + NANOARROW_UNUSED(array_view); return writer.WriteSchema(out, schema); } ArrowErrorCode WriteFieldJSON(std::ostream& out, TestingJSONWriter& writer, const ArrowSchema* schema, ArrowArrayView* array_view) { + NANOARROW_UNUSED(array_view); return writer.WriteField(out, schema); } ArrowErrorCode WriteTypeJSON(std::ostream& out, TestingJSONWriter& writer, const ArrowSchema* schema, ArrowArrayView* array_view) { + NANOARROW_UNUSED(array_view); return writer.WriteType(out, schema); } -void TestWriteJSON(std::function type_expr, - std::function append_expr, +void TestWriteJSON(ArrowErrorCode (*type_expr)(ArrowSchema*), + ArrowErrorCode (*append_expr)(ArrowArray*), ArrowErrorCode (*test_expr)(std::ostream&, TestingJSONWriter&, const ArrowSchema*, ArrowArrayView*), const std::string& expected_json, @@ -61,11 +64,16 @@ void TestWriteJSON(std::function type_expr, std::stringstream ss; nanoarrow::UniqueSchema schema; - ASSERT_EQ(type_expr(schema.get()), NANOARROW_OK); + if (type_expr != nullptr) { + ASSERT_EQ(type_expr(schema.get()), NANOARROW_OK); + } + nanoarrow::UniqueArray array; ASSERT_EQ(ArrowArrayInitFromSchema(array.get(), schema.get(), nullptr), NANOARROW_OK); ASSERT_EQ(ArrowArrayStartAppending(array.get()), NANOARROW_OK); - ASSERT_EQ(append_expr(array.get()), NANOARROW_OK); + if (append_expr != nullptr) { + ASSERT_EQ(append_expr(array.get()), NANOARROW_OK); + } ASSERT_EQ(ArrowArrayFinishBuildingDefault(array.get(), nullptr), NANOARROW_OK); nanoarrow::UniqueArrayView array_view; @@ -87,8 +95,7 @@ TEST(NanoarrowTestingTest, NanoarrowTestingTestColumnNull) { [](ArrowSchema* schema) { return ArrowSchemaInitFromType(schema, NANOARROW_TYPE_NA); }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteColumnJSON, - R"({"name": null, "count": 0})"); + /*append_expr*/ nullptr, &WriteColumnJSON, R"({"name": null, "count": 0})"); TestWriteJSON( [](ArrowSchema* schema) { @@ -96,8 +103,7 @@ TEST(NanoarrowTestingTest, NanoarrowTestingTestColumnNull) { NANOARROW_RETURN_NOT_OK(ArrowSchemaSetName(schema, "colname")); return NANOARROW_OK; }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteColumnJSON, - R"({"name": "colname", "count": 0})"); + /*append_expr*/ nullptr, &WriteColumnJSON, R"({"name": "colname", "count": 0})"); } TEST(NanoarrowTestingTest, NanoarrowTestingTestColumnInt) { @@ -105,7 +111,7 @@ TEST(NanoarrowTestingTest, NanoarrowTestingTestColumnInt) { [](ArrowSchema* schema) { return ArrowSchemaInitFromType(schema, NANOARROW_TYPE_INT32); }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteColumnJSON, + /*append_expr*/ nullptr, &WriteColumnJSON, R"({"name": null, "count": 0, "VALIDITY": [], "DATA": []})"); // Without a null value @@ -304,7 +310,7 @@ TEST(NanoarrowTestingTest, NanoarrowTestingTestColumnStruct) { NANOARROW_RETURN_NOT_OK(ArrowSchemaSetTypeStruct(schema, 0)); return NANOARROW_OK; }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteColumnJSON, + /*append_expr*/ nullptr, &WriteColumnJSON, R"({"name": null, "count": 0, "VALIDITY": [], "children": []})"); // Non-empty struct @@ -320,7 +326,7 @@ TEST(NanoarrowTestingTest, NanoarrowTestingTestColumnStruct) { NANOARROW_RETURN_NOT_OK(ArrowSchemaSetName(schema->children[1], "col2")); return NANOARROW_OK; }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteColumnJSON, + /*append_expr*/ nullptr, &WriteColumnJSON, R"({"name": null, "count": 0, "VALIDITY": [], "children": [)" R"({"name": "col1", "count": 0}, {"name": "col2", "count": 0}]})"); } @@ -334,7 +340,7 @@ TEST(NanoarrowTestingTest, NanoarrowTestingTestColumnDenseUnion) { ArrowSchemaSetTypeUnion(schema, NANOARROW_TYPE_DENSE_UNION, 0)); return NANOARROW_OK; }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteColumnJSON, + /*append_expr*/ nullptr, &WriteColumnJSON, R"({"name": null, "count": 0, "TYPE_ID": [], "OFFSET": [], "children": []})"); } @@ -346,8 +352,7 @@ TEST(NanoarrowTestingTest, NanoarrowTestingTestBatch) { NANOARROW_RETURN_NOT_OK(ArrowSchemaSetTypeStruct(schema, 0)); return NANOARROW_OK; }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteBatchJSON, - R"({"count": 0, "columns": []})"); + /*append_expr*/ nullptr, &WriteBatchJSON, R"({"count": 0, "columns": []})"); } TEST(NanoarrowTestingTest, NanoarrowTestingTestSchema) { @@ -358,8 +363,7 @@ TEST(NanoarrowTestingTest, NanoarrowTestingTestSchema) { NANOARROW_RETURN_NOT_OK(ArrowSchemaSetTypeStruct(schema, 0)); return NANOARROW_OK; }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteSchemaJSON, - R"({"fields": []})"); + /*append_expr*/ nullptr, &WriteSchemaJSON, R"({"fields": []})"); // More than zero fields TestWriteJSON( @@ -372,7 +376,7 @@ TEST(NanoarrowTestingTest, NanoarrowTestingTestSchema) { ArrowSchemaSetType(schema->children[1], NANOARROW_TYPE_STRING)); return NANOARROW_OK; }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteSchemaJSON, + /*append_expr*/ nullptr, &WriteSchemaJSON, R"({"fields": [)" R"({"name": null, "nullable": true, "type": {"name": "null"}, "children": []}, )" R"({"name": null, "nullable": true, "type": {"name": "utf8"}, "children": []}]})"); @@ -384,7 +388,7 @@ TEST(NanoarrowTestingTest, NanoarrowTestingTestFieldBasic) { NANOARROW_RETURN_NOT_OK(ArrowSchemaInitFromType(schema, NANOARROW_TYPE_NA)); return NANOARROW_OK; }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteFieldJSON, + /*append_expr*/ nullptr, &WriteFieldJSON, R"({"name": null, "nullable": true, "type": {"name": "null"}, "children": []})"); TestWriteJSON( @@ -393,7 +397,7 @@ TEST(NanoarrowTestingTest, NanoarrowTestingTestFieldBasic) { schema->flags = 0; return NANOARROW_OK; }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteFieldJSON, + /*append_expr*/ nullptr, &WriteFieldJSON, R"({"name": null, "nullable": false, "type": {"name": "null"}, "children": []})"); TestWriteJSON( @@ -402,7 +406,7 @@ TEST(NanoarrowTestingTest, NanoarrowTestingTestFieldBasic) { NANOARROW_RETURN_NOT_OK(ArrowSchemaSetName(schema, "colname")); return NANOARROW_OK; }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteFieldJSON, + /*append_expr*/ nullptr, &WriteFieldJSON, R"({"name": "colname", "nullable": true, "type": {"name": "null"}, "children": []})"); } @@ -415,7 +419,7 @@ TEST(NanoarrowTestingTest, NanoarrowTestingTestFieldDict) { ArrowSchemaInitFromType(schema->dictionary, NANOARROW_TYPE_STRING)); return NANOARROW_OK; }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteFieldJSON, + /*append_expr*/ nullptr, &WriteFieldJSON, R"({"name": null, "nullable": true, "type": {"name": "utf8"}, )" R"("dictionary": {"id": 0, "indexType": {"name": "int", "bitWidth": 16, "isSigned": true}, )" R"("isOrdered": false}, "children": []})"); @@ -428,7 +432,7 @@ TEST(NanoarrowTestingTest, NanoarrowTestingTestFieldMetadata) { NANOARROW_RETURN_NOT_OK(ArrowSchemaInitFromType(schema, NANOARROW_TYPE_NA)); return NANOARROW_OK; }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteFieldJSON, + /*append_expr*/ nullptr, &WriteFieldJSON, R"({"name": null, "nullable": true, "type": {"name": "null"}, "children": []})"); // Non-null but zero-size metadata @@ -438,7 +442,7 @@ TEST(NanoarrowTestingTest, NanoarrowTestingTestFieldMetadata) { NANOARROW_RETURN_NOT_OK(ArrowSchemaSetMetadata(schema, "\0\0\0\0")); return NANOARROW_OK; }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteFieldJSON, + /*append_expr*/ nullptr, &WriteFieldJSON, R"({"name": null, "nullable": true, "type": {"name": "null"}, "children": [], "metadata": []})"); // Non-zero size metadata @@ -456,7 +460,7 @@ TEST(NanoarrowTestingTest, NanoarrowTestingTestFieldMetadata) { ArrowSchemaSetMetadata(schema, reinterpret_cast(buffer->data))); return NANOARROW_OK; }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteFieldJSON, + /*append_expr*/ nullptr, &WriteFieldJSON, R"({"name": null, "nullable": true, "type": {"name": "null"}, "children": [], )" R"("metadata": [{"key": "k1", "value": "v1"}, {"key": "k2", "value": "v2"}]})"); } @@ -472,7 +476,7 @@ TEST(NanoarrowTestingTest, NanoarrowTestingTestFieldNested) { ArrowSchemaSetType(schema->children[1], NANOARROW_TYPE_STRING)); return NANOARROW_OK; }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteFieldJSON, + /*append_expr*/ nullptr, &WriteFieldJSON, R"({"name": null, "nullable": true, "type": {"name": "struct"}, "children": [)" R"({"name": null, "nullable": true, "type": {"name": "null"}, "children": []}, )" R"({"name": null, "nullable": true, "type": {"name": "utf8"}, "children": []}]})"); @@ -483,78 +487,72 @@ TEST(NanoarrowTestingTest, NanoarrowTestingTestTypePrimitive) { [](ArrowSchema* schema) { return ArrowSchemaInitFromType(schema, NANOARROW_TYPE_NA); }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteTypeJSON, - R"({"name": "null"})"); + /*append_expr*/ nullptr, &WriteTypeJSON, R"({"name": "null"})"); TestWriteJSON( [](ArrowSchema* schema) { return ArrowSchemaInitFromType(schema, NANOARROW_TYPE_BOOL); }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteTypeJSON, - R"({"name": "bool"})"); + /*append_expr*/ nullptr, &WriteTypeJSON, R"({"name": "bool"})"); TestWriteJSON( [](ArrowSchema* schema) { return ArrowSchemaInitFromType(schema, NANOARROW_TYPE_INT8); }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteTypeJSON, + /*append_expr*/ nullptr, &WriteTypeJSON, R"({"name": "int", "bitWidth": 8, "isSigned": true})"); TestWriteJSON( [](ArrowSchema* schema) { return ArrowSchemaInitFromType(schema, NANOARROW_TYPE_UINT8); }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteTypeJSON, + /*append_expr*/ nullptr, &WriteTypeJSON, R"({"name": "int", "bitWidth": 8, "isSigned": false})"); TestWriteJSON( [](ArrowSchema* schema) { return ArrowSchemaInitFromType(schema, NANOARROW_TYPE_HALF_FLOAT); }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteTypeJSON, + /*append_expr*/ nullptr, &WriteTypeJSON, R"({"name": "floatingpoint", "precision": "HALF"})"); TestWriteJSON( [](ArrowSchema* schema) { return ArrowSchemaInitFromType(schema, NANOARROW_TYPE_FLOAT); }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteTypeJSON, + /*append_expr*/ nullptr, &WriteTypeJSON, R"({"name": "floatingpoint", "precision": "SINGLE"})"); TestWriteJSON( [](ArrowSchema* schema) { return ArrowSchemaInitFromType(schema, NANOARROW_TYPE_DOUBLE); }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteTypeJSON, + /*append_expr*/ nullptr, &WriteTypeJSON, R"({"name": "floatingpoint", "precision": "DOUBLE"})"); TestWriteJSON( [](ArrowSchema* schema) { return ArrowSchemaInitFromType(schema, NANOARROW_TYPE_STRING); }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteTypeJSON, - R"({"name": "utf8"})"); + /*append_expr*/ nullptr, &WriteTypeJSON, R"({"name": "utf8"})"); TestWriteJSON( [](ArrowSchema* schema) { return ArrowSchemaInitFromType(schema, NANOARROW_TYPE_LARGE_STRING); }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteTypeJSON, - R"({"name": "largeutf8"})"); + /*append_expr*/ nullptr, &WriteTypeJSON, R"({"name": "largeutf8"})"); TestWriteJSON( [](ArrowSchema* schema) { return ArrowSchemaInitFromType(schema, NANOARROW_TYPE_BINARY); }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteTypeJSON, - R"({"name": "binary"})"); + /*append_expr*/ nullptr, &WriteTypeJSON, R"({"name": "binary"})"); TestWriteJSON( [](ArrowSchema* schema) { return ArrowSchemaInitFromType(schema, NANOARROW_TYPE_LARGE_BINARY); }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteTypeJSON, - R"({"name": "largebinary"})"); + /*append_expr*/ nullptr, &WriteTypeJSON, R"({"name": "largebinary"})"); } TEST(NanoarrowTestingTest, NanoarrowTestingTestTypeParameterized) { @@ -565,7 +563,7 @@ TEST(NanoarrowTestingTest, NanoarrowTestingTestTypeParameterized) { ArrowSchemaSetTypeFixedSize(schema, NANOARROW_TYPE_FIXED_SIZE_BINARY, 123)); return NANOARROW_OK; }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteTypeJSON, + /*append_expr*/ nullptr, &WriteTypeJSON, R"({"name": "fixedsizebinary", "byteWidth": 123})"); TestWriteJSON( @@ -575,7 +573,7 @@ TEST(NanoarrowTestingTest, NanoarrowTestingTestTypeParameterized) { ArrowSchemaSetTypeDecimal(schema, NANOARROW_TYPE_DECIMAL128, 10, 3)); return NANOARROW_OK; }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteTypeJSON, + /*append_expr*/ nullptr, &WriteTypeJSON, R"({"name": "decimal", "bitWidth": 128, "precision": 10, "scale": 3})"); TestWriteJSON( @@ -584,8 +582,7 @@ TEST(NanoarrowTestingTest, NanoarrowTestingTestTypeParameterized) { NANOARROW_RETURN_NOT_OK(ArrowSchemaSetTypeStruct(schema, 0)); return NANOARROW_OK; }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteTypeJSON, - R"({"name": "struct"})"); + /*append_expr*/ nullptr, &WriteTypeJSON, R"({"name": "struct"})"); TestWriteJSON( [](ArrowSchema* schema) { @@ -595,8 +592,7 @@ TEST(NanoarrowTestingTest, NanoarrowTestingTestTypeParameterized) { ArrowSchemaSetType(schema->children[0], NANOARROW_TYPE_INT32)); return NANOARROW_OK; }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteTypeJSON, - R"({"name": "list"})"); + /*append_expr*/ nullptr, &WriteTypeJSON, R"({"name": "list"})"); TestWriteJSON( [](ArrowSchema* schema) { @@ -608,8 +604,7 @@ TEST(NanoarrowTestingTest, NanoarrowTestingTestTypeParameterized) { ArrowSchemaSetType(schema->children[0]->children[1], NANOARROW_TYPE_INT32)); return NANOARROW_OK; }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteTypeJSON, - R"({"name": "map", "keysSorted": false})"); + /*append_expr*/ nullptr, &WriteTypeJSON, R"({"name": "map", "keysSorted": false})"); TestWriteJSON( [](ArrowSchema* schema) { @@ -622,8 +617,7 @@ TEST(NanoarrowTestingTest, NanoarrowTestingTestTypeParameterized) { schema->flags = ARROW_FLAG_MAP_KEYS_SORTED; return NANOARROW_OK; }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteTypeJSON, - R"({"name": "map", "keysSorted": true})"); + /*append_expr*/ nullptr, &WriteTypeJSON, R"({"name": "map", "keysSorted": true})"); TestWriteJSON( [](ArrowSchema* schema) { @@ -633,8 +627,7 @@ TEST(NanoarrowTestingTest, NanoarrowTestingTestTypeParameterized) { ArrowSchemaSetType(schema->children[0], NANOARROW_TYPE_INT32)); return NANOARROW_OK; }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteTypeJSON, - R"({"name": "largelist"})"); + /*append_expr*/ nullptr, &WriteTypeJSON, R"({"name": "largelist"})"); TestWriteJSON( [](ArrowSchema* schema) { @@ -645,7 +638,7 @@ TEST(NanoarrowTestingTest, NanoarrowTestingTestTypeParameterized) { ArrowSchemaSetType(schema->children[0], NANOARROW_TYPE_INT32)); return NANOARROW_OK; }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteTypeJSON, + /*append_expr*/ nullptr, &WriteTypeJSON, R"({"name": "fixedsizelist", "listSize": 12})"); } @@ -657,7 +650,7 @@ TEST(NanoarrowTestingTest, NanoarrowTestingTestTypeUnion) { ArrowSchemaSetTypeUnion(schema, NANOARROW_TYPE_SPARSE_UNION, 0)); return NANOARROW_OK; }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteTypeJSON, + /*append_expr*/ nullptr, &WriteTypeJSON, R"({"name": "union", "mode": "SPARSE", "typeIds": []})"); TestWriteJSON( @@ -671,7 +664,7 @@ TEST(NanoarrowTestingTest, NanoarrowTestingTestTypeUnion) { ArrowSchemaSetType(schema->children[1], NANOARROW_TYPE_INT32)); return NANOARROW_OK; }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteTypeJSON, + /*append_expr*/ nullptr, &WriteTypeJSON, R"({"name": "union", "mode": "SPARSE", "typeIds": [0,1]})"); TestWriteJSON( @@ -681,7 +674,7 @@ TEST(NanoarrowTestingTest, NanoarrowTestingTestTypeUnion) { ArrowSchemaSetTypeUnion(schema, NANOARROW_TYPE_DENSE_UNION, 0)); return NANOARROW_OK; }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteTypeJSON, + /*append_expr*/ nullptr, &WriteTypeJSON, R"({"name": "union", "mode": "DENSE", "typeIds": []})"); TestWriteJSON( @@ -695,7 +688,7 @@ TEST(NanoarrowTestingTest, NanoarrowTestingTestTypeUnion) { ArrowSchemaSetType(schema->children[1], NANOARROW_TYPE_INT32)); return NANOARROW_OK; }, - [](ArrowArray* array) { return NANOARROW_OK; }, &WriteTypeJSON, + /*append_expr*/ nullptr, &WriteTypeJSON, R"({"name": "union", "mode": "DENSE", "typeIds": [0,1]})"); } diff --git a/src/nanoarrow/schema_test.cc b/src/nanoarrow/schema_test.cc index acafb3a2c..6e521eefa 100644 --- a/src/nanoarrow/schema_test.cc +++ b/src/nanoarrow/schema_test.cc @@ -1510,7 +1510,8 @@ TEST(MetadataTest, Metadata) { std::string simple_metadata = SimpleMetadata(); EXPECT_EQ(ArrowMetadataSizeOf(nullptr), 0); - EXPECT_EQ(ArrowMetadataSizeOf(simple_metadata.data()), simple_metadata.size()); + EXPECT_EQ(ArrowMetadataSizeOf(simple_metadata.data()), + static_cast(simple_metadata.size())); EXPECT_EQ(ArrowMetadataHasKey(simple_metadata.data(), ArrowCharView("key")), 1); EXPECT_EQ(ArrowMetadataHasKey(simple_metadata.data(), ArrowCharView("not_a_key")), 0); diff --git a/src/nanoarrow/utils_test.cc b/src/nanoarrow/utils_test.cc index 8b4fe9226..d35ba3f28 100644 --- a/src/nanoarrow/utils_test.cc +++ b/src/nanoarrow/utils_test.cc @@ -166,6 +166,8 @@ struct CustomFreeData { static void CustomFree(struct ArrowBufferAllocator* allocator, uint8_t* ptr, int64_t size) { + NANOARROW_UNUSED(ptr); + NANOARROW_UNUSED(size); auto data = reinterpret_cast(allocator->private_data); ArrowFree(data->pointer_proxy); data->pointer_proxy = nullptr;