From 99e72e57af903a297355e482108490acd0f91880 Mon Sep 17 00:00:00 2001 From: Will Ayd Date: Sat, 9 Nov 2024 13:13:49 -0500 Subject: [PATCH 1/9] test: Make Arrow C++ dependency optional --- .github/workflows/build-and-test.yaml | 18 +++++++++++++ CMakeLists.txt | 39 +++++++++++++++------------ meson.build | 9 +++++-- src/nanoarrow/common/array_test.cc | 24 +++++++++++++++++ src/nanoarrow/common/schema_test.cc | 34 +++++++++++++++++++++++ src/nanoarrow/common/utils_test.cc | 8 ++++++ src/nanoarrow/ipc/decoder_test.cc | 12 +++++++++ src/nanoarrow/ipc/files_test.cc | 2 ++ 8 files changed, 127 insertions(+), 19 deletions(-) diff --git a/.github/workflows/build-and-test.yaml b/.github/workflows/build-and-test.yaml index 127917edd..51ab4fed0 100644 --- a/.github/workflows/build-and-test.yaml +++ b/.github/workflows/build-and-test.yaml @@ -158,3 +158,21 @@ jobs: - name: Run meson testing script run: | PKG_CONFIG_PATH="$(pwd)/arrow/lib/pkgconfig" ci/scripts/build-with-meson.sh + + test-no-arrow: + name: test-no-arrow + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - name: Build nanoarrow + run: | + cmake -S . -B build -DNANOARROW_BUILD_TESTS=ON -DCMAKE_POSITION_INDEPENDENT_CODE=ON \ + -DCMAKE_PREFIX_PATH="${ARROW_PATH}" + + cmake --build build + + - name: Run tests + run: | + cd build + ctest -T test --output-on-failure . diff --git a/CMakeLists.txt b/CMakeLists.txt index 4cefb8fb5..8c349b157 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -422,26 +422,31 @@ if(NANOARROW_BUILD_TESTS) ) include(CTest) - find_package(Arrow REQUIRED) - message(STATUS "Arrow version: ${ARROW_VERSION}") - message(STATUS "Arrow SO version: ${ARROW_FULL_SO_VERSION}") + find_package(Arrow) + if(Arrow_FOUND) + message(STATUS "Arrow version: ${ARROW_VERSION}") + message(STATUS "Arrow SO version: ${ARROW_FULL_SO_VERSION}") - # Give caller the option to link a static version of Arrow C++ - if(NANOARROW_ARROW_STATIC) - set(NANOARROW_ARROW_TARGET arrow_static) - else() - set(NANOARROW_ARROW_TARGET arrow_shared) - endif() + # TODO: does this propoagate to projects using as a subproject? + add_compile_definitions("-DNANOARROW_ARROW_FOUND") - # Arrow >= 10.0.0 requires C++17; GTest requires C++11. - # Leave the option open to use an older version of Arrow - # to make it easier to test on old Linux (e.g., Centos7) - if(${ARROW_VERSION} VERSION_GREATER_EQUAL "10.0.0") - set(CMAKE_CXX_STANDARD 17) - else() - set(CMAKE_CXX_STANDARD 11) + # Give caller the option to link a static version of Arrow C++ + if(NANOARROW_ARROW_STATIC) + set(NANOARROW_ARROW_TARGET arrow_static) + else() + set(NANOARROW_ARROW_TARGET arrow_shared) + endif() + + # Arrow >= 10.0.0 requires C++17; GTest requires C++11. + # Leave the option open to use an older version of Arrow + # to make it easier to test on old Linux (e.g., Centos7) + if(${ARROW_VERSION} VERSION_GREATER_EQUAL "10.0.0") + set(CMAKE_CXX_STANDARD 17) + else() + set(CMAKE_CXX_STANDARD 11) + endif() + set(CMAKE_CXX_STANDARD_REQUIRED ON) endif() - set(CMAKE_CXX_STANDARD_REQUIRED ON) add_subdirectory("thirdparty/googletest") diff --git a/meson.build b/meson.build index 6bbbe01ac..d0477dc0d 100644 --- a/meson.build +++ b/meson.build @@ -47,6 +47,13 @@ add_project_arguments( language: 'cpp', ) +# The system include suppresses compilation warnings from Arrow +arrow_dep = dependency('arrow', include_type: 'system', required: false) +if arrow_dep.found() + add_project_arguments('-DNANOARROW_ARROW_FOUND', language : 'c') + add_project_arguments('-DNANOARROW_ARROW_FOUND', language : 'cpp') +endif + if get_option('buildtype') in ['debug', 'debugoptimized'] add_project_arguments('-DNANOARROW_DEBUG', language: 'c') add_project_arguments('-DNANOARROW_DEBUG', language: 'cpp') @@ -208,8 +215,6 @@ if get_option('tests') # Similarly code coverage has a built in option users should use instead # https://mesonbuild.com/Unit-tests.html#coverage - # The system include suppresses compilation warnings from Arrow - arrow_dep = dependency('arrow', include_type: 'system') gtest_dep = dependency('gtest_main') gmock_dep = dependency('gmock') diff --git a/src/nanoarrow/common/array_test.cc b/src/nanoarrow/common/array_test.cc index 5ef77029a..1e30f6bf1 100644 --- a/src/nanoarrow/common/array_test.cc +++ b/src/nanoarrow/common/array_test.cc @@ -20,6 +20,7 @@ #include #include +#if defined(NANOARROW_ARROW_FOUND) #include #include #include @@ -35,10 +36,13 @@ #if defined(ARROW_VERSION_MAJOR) && ARROW_VERSION_MAJOR >= 12 #include #endif +#endif #include "nanoarrow/nanoarrow.hpp" +#if defined(NANOARROW_ARROW_FOUND) using namespace arrow; +#endif using namespace nanoarrow::literals; using nanoarrow::NA; using testing::ElementsAre; @@ -46,6 +50,7 @@ using testing::ElementsAre; // Lightweight versions of ArrowTesting's ARROW_EXPECT_OK. This // version accomplishes the task of making sure the status message // ends up in the ctests log. +#if defined(NANOARROW_ARROW_FOUND) void ARROW_EXPECT_OK(Status status) { if (!status.ok()) { throw std::runtime_error(status.message()); @@ -57,6 +62,7 @@ void ARROW_EXPECT_OK(Result> result) { throw std::runtime_error(result.status().message()); } } +#endif TEST(ArrayTest, ArrayTestInit) { struct ArrowArray array; @@ -380,6 +386,7 @@ INSTANTIATE_TEST_SUITE_P(NanoarrowIpcTest, UnparameterizedTypeTestFixture, ::testing::Values(NANOARROW_TYPE_NA, NANOARROW_TYPE_INT32, NANOARROW_TYPE_BINARY, NANOARROW_TYPE_STRUCT)); +#if defined(NANOARROW_ARROW_FOUND) TEST(ArrayTest, ArrayTestAppendToNullArray) { struct ArrowArray array; ASSERT_EQ(ArrowArrayInitFromType(&array, NANOARROW_TYPE_NA), NANOARROW_OK); @@ -566,6 +573,7 @@ TEST(ArrayTest, ArrayTestAppendToStringArray) { EXPECT_TRUE(arrow_array.ValueUnsafe()->Equals(expected_array.ValueUnsafe())); } +#endif TEST(ArrayTest, ArrayTestAppendEmptyToString) { struct ArrowArray array; @@ -577,6 +585,7 @@ TEST(ArrayTest, ArrayTestAppendEmptyToString) { ArrowArrayRelease(&array); } +#if defined(NANOARROW_ARROW_FOUND) TEST(ArrayTest, ArrayTestAppendToUInt64Array) { struct ArrowArray array; @@ -608,6 +617,7 @@ TEST(ArrayTest, ArrayTestAppendToUInt64Array) { EXPECT_TRUE(arrow_array.ValueUnsafe()->Equals(expected_array.ValueUnsafe())); } +#endif TEST(ArrayTest, ArrayTestAppendToUInt32Array) { struct ArrowArray array; @@ -629,6 +639,7 @@ TEST(ArrayTest, ArrayTestAppendToUInt32Array) { ArrowArrayRelease(&array); } +#if defined(NANOARROW_ARROW_FOUND) TEST(ArrayTest, ArrayTestAppendToUInt16Array) { struct ArrowArray array; @@ -844,6 +855,7 @@ TEST(ArrayTest, ArrayTestAppendToHalfFloatArray) { auto arrow_array = ImportArray(&array, float16()); ARROW_EXPECT_OK(arrow_array); } +#endif TEST(ArrayTest, ArrayTestAppendToBoolArray) { struct ArrowArray array; @@ -1095,6 +1107,7 @@ TEST(ArrayTest, ArrayTestAppendToIntervalArrayYearMonth) { ArrowArrayRelease(&array); } +#if defined(NANOARROW_ARROW_FOUND) TEST(ArrayTest, ArrayTestAppendToIntervalArrayDayTime) { struct ArrowArray array; @@ -1518,6 +1531,7 @@ TEST(ArrayTest, ArrayTestAppendToFixedSizeListArray) { EXPECT_TRUE(arrow_array.ValueUnsafe()->Equals(expected_array.ValueUnsafe())); } +#endif TEST(ArrayTest, ArrayTestAppendToListArrayErrors) { struct ArrowArray array; @@ -1535,6 +1549,7 @@ TEST(ArrayTest, ArrayTestAppendToListArrayErrors) { ArrowSchemaRelease(&schema); } +#if defined(NANOARROW_ARROW_FOUND) TEST(ArrayTest, ArrayTestAppendToStructArray) { struct ArrowArray array; struct ArrowSchema schema; @@ -1744,6 +1759,7 @@ TEST(ArrayTest, ArrayTestAppendToRunEndEncodedArray) { expected_array.ValueUnsafe()->ToString().c_str()); #endif } +#endif TEST(ArrayTest, ArrayTestUnionUtils) { // Check length calculation with nullptr @@ -1776,6 +1792,7 @@ TEST(ArrayTest, ArrayTestUnionUtils) { EXPECT_FALSE(_ArrowUnionTypeIdsWillEqualChildIndices("0,2", 2)); } +#if defined(NANOARROW_ARROW_FOUND) TEST(ArrayTest, ArrayTestAppendToDenseUnionArray) { struct ArrowArray array; struct ArrowSchema schema; @@ -1871,6 +1888,7 @@ TEST(ArrayTest, ArrayTestAppendToSparseUnionArray) { expected_array.ValueUnsafe()->ToString()); EXPECT_TRUE(arrow_array.ValueUnsafe()->Equals(expected_array.ValueUnsafe())); } +#endif TEST(ArrayTest, ArrayTestAppendToUnionArrayErrors) { struct ArrowArray array; @@ -3250,6 +3268,7 @@ TEST(ArrayTest, ArrayViewTestSparseUnionGet) { // the "value type" that would correspond to what ArrowArrayViewGetDoubleUnsafe() // or ArrowArrayAppendDouble() do since they operate on the logical/represented // value. +#if defined(NANOARROW_ARROW_FOUND) template BuilderValueT logical_value_to_builder_value(int64_t value) { return static_cast(value); @@ -3352,6 +3371,7 @@ TEST(ArrayViewTest, ArrayViewTestGetNumeric) { TestGetFromNumericArrayView(); TestGetFromNumericArrayView(); } +#endif TEST(ArrayViewTest, ArrayViewTestGetFloat16) { struct ArrowArray array; @@ -3419,6 +3439,7 @@ TEST(ArrayViewTest, ArrayViewTestGetFloat16) { ArrowSchemaRelease(&schema); } +#if defined(NANOARROW_ARROW_FOUND) template void TestGetFromBinary(BuilderClass& builder) { struct ArrowArray array; @@ -3595,6 +3616,7 @@ TEST(ArrayViewTest, ArrayViewTestGetBinaryView) { GTEST_SKIP() << "Arrow C++ StringView compatibility test needs Arrow C++ >= 15"; #endif } +#endif TEST(ArrayViewTest, ArrayViewTestGetIntervalYearMonth) { struct ArrowArray array; @@ -3633,6 +3655,7 @@ TEST(ArrayViewTest, ArrayViewTestGetIntervalYearMonth) { ArrowArrayRelease(&array); } +#if defined(NANOARROW_ARROW_FOUND) TEST(ArrayViewTest, ArrayViewTestGetIntervalDayTime) { struct ArrowArray array; struct ArrowSchema schema; @@ -3780,3 +3803,4 @@ TEST(ArrayViewTest, ArrayViewTestGetDecimal256) { ArrowSchemaRelease(&schema); ArrowArrayRelease(&array); } +#endif diff --git a/src/nanoarrow/common/schema_test.cc b/src/nanoarrow/common/schema_test.cc index 163f96c70..5ffbce642 100644 --- a/src/nanoarrow/common/schema_test.cc +++ b/src/nanoarrow/common/schema_test.cc @@ -17,14 +17,18 @@ #include +#if defined(NANOARROW_ARROW_FOUND) #include #include #include #include +#endif #include "nanoarrow/nanoarrow.hpp" +#if defined(NANOARROW_ARROW_FOUND) using namespace arrow; +#endif // Helper to avoid the verbosity of ArrowSchemaToStdString std::string ArrowSchemaToStdString(struct ArrowSchema* schema, bool recursive = true) { @@ -76,6 +80,7 @@ TEST(SchemaTest, SchemaInit) { ArrowSchemaRelease(&schema); } +#if defined(NANOARROW_ARROW_FOUND) static void ExpectSchemaInitOk(enum ArrowType type, std::shared_ptr expected_arrow_type) { struct ArrowSchema schema; @@ -113,6 +118,7 @@ TEST(SchemaTest, SchemaInitSimple) { ExpectSchemaInitOk(NANOARROW_TYPE_BINARY_VIEW, binary_view()); #endif } +#endif TEST(SchemaTest, SchemaInitSimpleError) { struct ArrowSchema schema; @@ -120,6 +126,7 @@ TEST(SchemaTest, SchemaInitSimpleError) { EXPECT_EQ(schema.release, nullptr); } +#if defined(NANOARROW_ARROW_FOUND) TEST(SchemaTest, SchemaTestInitNestedList) { struct ArrowSchema schema; @@ -225,6 +232,7 @@ TEST(SchemaTest, SchemaInitDecimal) { ARROW_EXPECT_OK(arrow_type); EXPECT_TRUE(arrow_type.ValueUnsafe()->Equals(decimal256(3, 4))); } +#endif TEST(SchemaTest, SchemaInitRunEndEncoded) { struct ArrowSchema schema; @@ -271,6 +279,7 @@ TEST(SchemaTest, SchemaInitRunEndEncoded) { #endif } +#if defined(NANOARROW_ARROW_FOUND) TEST(SchemaTest, SchemaInitDateTime) { struct ArrowSchema schema; @@ -452,6 +461,7 @@ TEST(SchemaTest, SchemaInitUnion) { EXPECT_TRUE(arrow_type.ValueUnsafe()->Equals( dense_union({field("u1", int32()), field("u2", utf8())}))); } +#endif TEST(SchemaTest, SchemaSetFormat) { struct ArrowSchema schema; @@ -505,6 +515,7 @@ TEST(SchemaTest, SchemaAllocateDictionary) { ArrowSchemaRelease(&schema); } +#if defined(NANOARROW_ARROW_FOUND) TEST(SchemaTest, SchemaCopySimpleType) { struct ArrowSchema schema; ARROW_EXPECT_OK(ExportType(*int32(), &schema)); @@ -616,6 +627,7 @@ TEST(SchemaTest, SchemaCopyMetadata) { ArrowSchemaRelease(&schema); } +#endif TEST(SchemaViewTest, SchemaViewInitErrors) { struct ArrowSchema schema; @@ -671,6 +683,7 @@ TEST(SchemaViewTest, SchemaViewInitErrors) { ArrowSchemaRelease(&schema); } +#if defined(NANOARROW_ARROW_FOUND) void ExpectSimpleTypeOk(std::shared_ptr arrow_t, enum ArrowType nanoarrow_t, int bitwidth, const char* formatted) { struct ArrowSchema schema; @@ -723,6 +736,7 @@ TEST(SchemaViewTest, SchemaViewInitSimple) { ExpectSimpleTypeOk(float64(), NANOARROW_TYPE_DOUBLE, 64, "double"); ExpectSimpleTypeOk(float32(), NANOARROW_TYPE_FLOAT, 32, "float"); } +#endif TEST(SchemaViewTest, SchemaViewInitSimpleErrors) { struct ArrowSchema schema; @@ -738,6 +752,7 @@ TEST(SchemaViewTest, SchemaViewInitSimpleErrors) { ArrowSchemaRelease(&schema); } +#if defined(NANOARROW_ARROW_FOUND) TEST(SchemaViewTest, SchemaViewInitDecimal) { struct ArrowSchema schema; struct ArrowSchemaView schema_view; @@ -781,6 +796,7 @@ TEST(SchemaViewTest, SchemaViewInitDecimal) { EXPECT_EQ(ArrowSchemaToStdString(&schema), "decimal256(5, 6)"); ArrowSchemaRelease(&schema); } +#endif TEST(SchemaViewTest, SchemaViewInitDecimalErrors) { struct ArrowSchema schema; @@ -827,6 +843,7 @@ TEST(SchemaViewTest, SchemaViewInitDecimalErrors) { ArrowSchemaRelease(&schema); } +#if defined(NANOARROW_ARROW_FOUND) TEST(SchemaViewTest, SchemaViewInitBinaryAndString) { struct ArrowSchema schema; struct ArrowSchemaView schema_view; @@ -948,6 +965,7 @@ TEST(SchemaViewTest, SchemaViewInitBinaryAndStringView) { GTEST_SKIP() << "Arrow C++ StringView compatibility test needs Arrow C++ >= 15"; #endif } +#endif TEST(SchemaViewTest, SchemaViewInitBinaryAndStringErrors) { struct ArrowSchema schema; @@ -978,6 +996,7 @@ TEST(SchemaViewTest, SchemaViewInitBinaryAndStringErrors) { ArrowSchemaRelease(&schema); } +#if defined(NANOARROW_ARROW_FOUND) TEST(SchemaViewTest, SchemaViewInitTimeDate) { struct ArrowSchema schema; struct ArrowSchemaView schema_view; @@ -1142,6 +1161,7 @@ TEST(SchemaViewTest, SchemaViewInitTimeInterval) { EXPECT_EQ(ArrowSchemaToStdString(&schema), "interval_month_day_nano"); ArrowSchemaRelease(&schema); } +#endif TEST(SchemaViewTest, SchemaViewInitTimeErrors) { struct ArrowSchema schema; @@ -1193,6 +1213,7 @@ TEST(SchemaViewTest, SchemaViewInitTimeErrors) { ArrowSchemaRelease(&schema); } +#if defined(NANOARROW_ARROW_FOUND) TEST(SchemaViewTest, SchemaViewInitNestedList) { struct ArrowSchema schema; struct ArrowSchemaView schema_view; @@ -1248,6 +1269,7 @@ TEST(SchemaViewTest, SchemaViewInitNestedList) { EXPECT_EQ(ArrowSchemaToStdString(&schema), "fixed_size_list(123)"); ArrowSchemaRelease(&schema); } +#endif TEST(SchemaViewTest, SchemaViewNestedListErrors) { struct ArrowSchema schema; @@ -1273,6 +1295,7 @@ TEST(SchemaViewTest, SchemaViewNestedListErrors) { ArrowSchemaRelease(&schema); } +#if defined(NANOARROW_ARROW_FOUND) TEST(SchemaViewTest, SchemaViewInitNestedStruct) { struct ArrowSchema schema; struct ArrowSchemaView schema_view; @@ -1300,6 +1323,7 @@ TEST(SchemaViewTest, SchemaViewInitNestedStruct) { ArrowSchemaRelease(&schema); } +#endif TEST(SchemaViewTest, SchemaViewInitNestedStructErrors) { struct ArrowSchema schema; @@ -1328,6 +1352,7 @@ TEST(SchemaViewTest, SchemaViewInitNestedStructErrors) { ArrowSchemaRelease(&schema); } +#if defined(NANOARROW_ARROW_FOUND) TEST(SchemaViewTest, SchemaViewInitNestedMap) { struct ArrowSchema schema; struct ArrowSchemaView schema_view; @@ -1348,6 +1373,7 @@ TEST(SchemaViewTest, SchemaViewInitNestedMap) { "map>"); ArrowSchemaRelease(&schema); } +#endif TEST(SchemaViewTest, SchemaViewInitNestedMapErrors) { struct ArrowSchema schema; @@ -1409,6 +1435,7 @@ TEST(SchemaViewTest, SchemaViewInitNestedMapErrors) { ArrowSchemaRelease(&schema); } +#if defined(NANOARROW_ARROW_FOUND) TEST(SchemaViewTest, SchemaViewInitNestedUnion) { struct ArrowSchema schema; struct ArrowSchemaView schema_view; @@ -1448,6 +1475,7 @@ TEST(SchemaViewTest, SchemaViewInitNestedUnion) { EXPECT_EQ(ArrowSchemaToStdString(&schema), "sparse_union([0])"); ArrowSchemaRelease(&schema); } +#endif TEST(SchemaViewTest, SchemaViewInitNestedUnionErrors) { struct ArrowSchema schema; @@ -1500,6 +1528,7 @@ TEST(SchemaViewTest, SchemaViewInitInvalidSpecErrors) { ArrowSchemaRelease(&schema); } +#if defined(NANOARROW_ARROW_FOUND) TEST(SchemaViewTest, SchemaViewInitDictionary) { struct ArrowSchema schema; struct ArrowSchemaView schema_view; @@ -1512,6 +1541,7 @@ TEST(SchemaViewTest, SchemaViewInitDictionary) { EXPECT_EQ(ArrowSchemaToStdString(&schema), "dictionary(int32)"); ArrowSchemaRelease(&schema); } +#endif TEST(SchemaViewTest, SchemaViewInitDictionaryErrors) { struct ArrowSchema schema; @@ -1535,6 +1565,7 @@ TEST(SchemaViewTest, SchemaViewInitDictionaryErrors) { ArrowSchemaRelease(&schema); } +#if defined(NANOARROW_ARROW_FOUND) TEST(SchemaViewTest, SchemaViewInitExtension) { using namespace nanoarrow::literals; @@ -1555,7 +1586,9 @@ TEST(SchemaViewTest, SchemaViewInitExtension) { ArrowSchemaRelease(&schema); } +#endif +#if defined(NANOARROW_ARROW_FOUND) TEST(SchemaViewTest, SchemaViewInitExtensionDictionary) { using namespace nanoarrow::literals; @@ -1596,6 +1629,7 @@ TEST(SchemaViewTest, SchemaFormatEmptyNested) { ArrowSchemaRelease(&schema); } +#endif TEST(SchemaViewTest, SchemaFormatInvalid) { EXPECT_EQ(ArrowSchemaToStdString(nullptr), "[invalid: pointer is null]"); diff --git a/src/nanoarrow/common/utils_test.cc b/src/nanoarrow/common/utils_test.cc index e42990c44..7de3fad47 100644 --- a/src/nanoarrow/common/utils_test.cc +++ b/src/nanoarrow/common/utils_test.cc @@ -18,14 +18,18 @@ #include #include +#if defined(NANOARROW_ARROW_FOUND) #include +#endif #include #include #include "nanoarrow/nanoarrow.hpp" #include "nanoarrow/nanoarrow_testing.hpp" +#if defined(NANOARROW_ARROW_FOUND) using namespace arrow; +#endif TEST(BuildIdTest, VersionTest) { EXPECT_STREQ(ArrowNanoarrowVersion(), NANOARROW_VERSION); @@ -252,6 +256,7 @@ TEST(AllocatorTest, AllocatorTestMemoryPool) { #endif } +#if defined(NANOARROW_ARROW_FOUND) TEST(DecimalTest, Decimal128Test) { struct ArrowDecimal decimal; ArrowDecimalInit(&decimal, 128, 10, 3); @@ -288,6 +293,7 @@ TEST(DecimalTest, Decimal128Test) { ArrowDecimalSetBytes(&decimal, bytes_neg); EXPECT_EQ(memcmp(decimal.words, bytes_neg, sizeof(bytes_neg)), 0); } +#endif TEST(DecimalTest, DecimalNegateTest) { using namespace nanoarrow::literals; @@ -346,6 +352,7 @@ TEST(DecimalTest, DecimalNegateTest) { ArrowBufferReset(&buffer); } +#if defined(NANOARROW_ARROW_FOUND) TEST(DecimalTest, Decimal256Test) { using namespace nanoarrow::literals; @@ -384,6 +391,7 @@ TEST(DecimalTest, Decimal256Test) { ArrowDecimalSetBytes(&decimal, bytes_neg); EXPECT_EQ(memcmp(decimal.words, bytes_neg, sizeof(bytes_neg)), 0); } +#endif TEST(DecimalTest, DecimalStringTestBasic) { using namespace nanoarrow::literals; diff --git a/src/nanoarrow/ipc/decoder_test.cc b/src/nanoarrow/ipc/decoder_test.cc index 29209ec73..4c2c4c4ec 100644 --- a/src/nanoarrow/ipc/decoder_test.cc +++ b/src/nanoarrow/ipc/decoder_test.cc @@ -17,10 +17,12 @@ #include +#if defined(NANOARROW_ARROW_FOUND) #include #include #include #include +#endif #include #include @@ -29,7 +31,9 @@ #include "nanoarrow/nanoarrow_ipc.hpp" +#if defined(NANOARROW_ARROW_FOUND) using namespace arrow; +#endif // Copied from decoder.c so we can test the internal state extern "C" { @@ -465,6 +469,7 @@ TEST(NanoarrowIpcTest, NanoarrowIpcSetSchemaErrors) { ArrowIpcDecoderReset(&decoder); } +#if defined(NANOARROW_ARROW_FOUND) class ArrowTypeParameterizedTestFixture : public ::testing::TestWithParam> { protected: @@ -500,6 +505,7 @@ TEST_P(ArrowTypeParameterizedTestFixture, NanoarrowIpcArrowTypeRoundtrip) { ArrowIpcDecoderReset(&decoder); } +#endif std::string ArrowSchemaMetadataToString(const char* metadata) { struct ArrowMetadataReader reader {}; @@ -557,6 +563,7 @@ std::string ArrowSchemaToString(const struct ArrowSchema* schema) { return out; } +#if defined(NANOARROW_ARROW_FOUND) TEST_P(ArrowTypeParameterizedTestFixture, NanoarrowIpcNanoarrowTypeRoundtrip) { nanoarrow::UniqueSchema schema; ASSERT_TRUE( @@ -593,6 +600,7 @@ TEST_P(ArrowTypeParameterizedTestFixture, NanoarrowIpcNanoarrowTypeRoundtrip) { EXPECT_EQ(ArrowSchemaToString(roundtripped.get()), ArrowSchemaToString(schema.get())); } +#endif TEST(NanoarrowIpcTest, NanoarrowIpcDecodeSimpleRecordBatchFromShared) { struct ArrowIpcDecoder decoder; @@ -727,6 +735,7 @@ TEST(NanoarrowIpcTest, NanoarrowIpcSharedBufferThreadSafeDecode) { // We will get a (occasional) memory leak if the atomic counter does not work } +#if defined(NANOARROW_ARROW_FOUND) TEST_P(ArrowTypeParameterizedTestFixture, NanoarrowIpcArrowArrayRoundtrip) { const std::shared_ptr& data_type = GetParam(); std::shared_ptr dummy_schema = @@ -792,6 +801,7 @@ TEST_P(ArrowTypeParameterizedTestFixture, NanoarrowIpcArrowArrayRoundtrip) { ArrowSchemaRelease(&schema); ArrowIpcDecoderReset(&decoder); } +#endif void AssertArrayViewIdentical(const struct ArrowArrayView* actual, const struct ArrowArrayView* expected) { @@ -816,6 +826,7 @@ void AssertArrayViewIdentical(const struct ArrowArrayView* actual, } } +#if defined(NANOARROW_ARROW_FOUND) TEST_P(ArrowTypeParameterizedTestFixture, NanoarrowIpcNanoarrowArrayRoundtrip) { struct ArrowError error; nanoarrow::UniqueSchema schema; @@ -1224,6 +1235,7 @@ INSTANTIATE_TEST_SUITE_P(NanoarrowIpcTest, ArrowTypeIdParameterizedTestFixture, NANOARROW_TYPE_DECIMAL128, NANOARROW_TYPE_DECIMAL256, NANOARROW_TYPE_INTERVAL_MONTH_DAY_NANO)); +#endif TEST(NanoarrowIpcTest, NanoarrowIpcFooterDecodingErrors) { struct ArrowError error; diff --git a/src/nanoarrow/ipc/files_test.cc b/src/nanoarrow/ipc/files_test.cc index 011d59356..727e14695 100644 --- a/src/nanoarrow/ipc/files_test.cc +++ b/src/nanoarrow/ipc/files_test.cc @@ -21,6 +21,7 @@ #include +#if defined(NANOARROW_ARROW_FOUND) #include #include #include @@ -494,3 +495,4 @@ INSTANTIATE_TEST_SUITE_P( "Schema message field with DictionaryEncoding not supported") // Comment to keep last line from wrapping )); +#endif From 9198c20abcaf897393279e5781d1117444b9bd91 Mon Sep 17 00:00:00 2001 From: Will Ayd Date: Tue, 12 Nov 2024 14:06:34 -0500 Subject: [PATCH 2/9] Add option for testing without Arrow --- .github/workflows/build-and-test-device.yaml | 4 +-- .github/workflows/build-and-test-ipc.yaml | 4 +-- .github/workflows/build-and-test.yaml | 7 ++-- .github/workflows/clang-tidy.yaml | 6 ++-- CMakeLists.txt | 5 ++- CMakePresets.json | 1 + README.md | 13 ++++++-- ci/scripts/coverage.sh | 3 +- dev/release/verify-release-candidate.sh | 6 ++-- meson.build | 8 +++-- meson.options | 1 + src/nanoarrow/common/array_test.cc | 24 +++++++------- src/nanoarrow/common/schema_test.cc | 34 ++++++++++---------- src/nanoarrow/common/utils_test.cc | 8 ++--- src/nanoarrow/ipc/decoder_test.cc | 12 +++---- src/nanoarrow/ipc/files_test.cc | 2 +- 16 files changed, 78 insertions(+), 60 deletions(-) diff --git a/.github/workflows/build-and-test-device.yaml b/.github/workflows/build-and-test-device.yaml index 10ecaf70f..3304d8fb1 100644 --- a/.github/workflows/build-and-test-device.yaml +++ b/.github/workflows/build-and-test-device.yaml @@ -98,8 +98,8 @@ jobs: cd build export VERBOSE=1 cmake .. -DCMAKE_BUILD_TYPE=Debug -DNANOARROW_DEVICE=ON \ - -DNANOARROW_BUILD_TESTS=ON -DCMAKE_PREFIX_PATH="${ARROW_PATH}" \ - ${{ matrix.config.cmake_args }} + -DNANOARROW_BUILD_TESTS=ON -DNANOARROW_BUILD_TESTS_WITH_ARROW=ON \ + -DCMAKE_PREFIX_PATH="${ARROW_PATH}" ${{ matrix.config.cmake_args }} cmake --build . diff --git a/.github/workflows/build-and-test-ipc.yaml b/.github/workflows/build-and-test-ipc.yaml index 0fd74d842..cd28908a8 100644 --- a/.github/workflows/build-and-test-ipc.yaml +++ b/.github/workflows/build-and-test-ipc.yaml @@ -91,8 +91,8 @@ jobs: cd build cmake .. -DCMAKE_BUILD_TYPE=Debug -DNANOARROW_BUILD_TESTS=ON \ - -DNANOARROW_IPC=ON -DCMAKE_PREFIX_PATH="${ARROW_PATH}" \ - ${{ matrix.config.cmake_args }} + -DNANOARROW_BUILD_TESTS_WITH_ARROW=ON -DNANOARROW_IPC=ON \ + -DCMAKE_PREFIX_PATH="${ARROW_PATH}" ${{ matrix.config.cmake_args }} cmake --build . diff --git a/.github/workflows/build-and-test.yaml b/.github/workflows/build-and-test.yaml index 51ab4fed0..9432c359a 100644 --- a/.github/workflows/build-and-test.yaml +++ b/.github/workflows/build-and-test.yaml @@ -82,7 +82,8 @@ jobs: cd build cmake .. -DNANOARROW_BUILD_TESTS=ON -DCMAKE_POSITION_INDEPENDENT_CODE=ON \ - -DCMAKE_PREFIX_PATH="${ARROW_PATH}" ${{ matrix.config.cmake_args }} + -DNANOARROW_BUILD_TESTS_WITH_ARROW=ON -DCMAKE_PREFIX_PATH="${ARROW_PATH}" \ + ${{ matrix.config.cmake_args }} cmake --build . @@ -167,8 +168,8 @@ jobs: - name: Build nanoarrow run: | - cmake -S . -B build -DNANOARROW_BUILD_TESTS=ON -DCMAKE_POSITION_INDEPENDENT_CODE=ON \ - -DCMAKE_PREFIX_PATH="${ARROW_PATH}" + cmake -S . -B build -DNANOARROW_BUILD_TESTS=ON -DNANOARROW_BUILD_TESTS_WITH_ARROW=OFF \ + -DCMAKE_POSITION_INDEPENDENT_CODE=ON -DCMAKE_PREFIX_PATH="${ARROW_PATH}" cmake --build build diff --git a/.github/workflows/clang-tidy.yaml b/.github/workflows/clang-tidy.yaml index 2e4c4b4cf..f7fbdfbcb 100644 --- a/.github/workflows/clang-tidy.yaml +++ b/.github/workflows/clang-tidy.yaml @@ -66,9 +66,9 @@ jobs: cd build cmake .. -DNANOARROW_DEVICE=ON -DNANOARROW_IPC=ON \ - -DNANOARROW_BUILD_TESTS=ON -DCMAKE_POSITION_INDEPENDENT_CODE=ON \ - -DCMAKE_BUILD_TYPE=Debug -DCMAKE_EXPORT_COMPILE_COMMANDS=ON \ - -DCMAKE_PREFIX_PATH="${ARROW_PATH}" + -DNANOARROW_BUILD_TESTS=ON -DNANOARROW_BUILD_TESTS_WITH_ARROW=ON \ + -DCMAKE_POSITION_INDEPENDENT_CODE=ON -DCMAKE_BUILD_TYPE=Debug \ + -DCMAKE_EXPORT_COMPILE_COMMANDS=ON -DCMAKE_PREFIX_PATH="${ARROW_PATH}" cmake --build . diff --git a/CMakeLists.txt b/CMakeLists.txt index 8c349b157..f487ee693 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -45,6 +45,7 @@ option(NANOARROW_DEVICE_WITH_CUDA "Build CUDA libraries" OFF) # Development options option(NANOARROW_BUILD_APPS "Build utility applications" OFF) option(NANOARROW_BUILD_TESTS "Build tests" OFF) +option(NANOARROW_BUILD_TESTS_WITH_ARROW "Build tests that require Arrow" OFF) option(NANOARROW_BUILD_BENCHMARKS "Build benchmarks" OFF) option(NANOARROW_BUILD_INTEGRATION_TESTS "Build cross-implementation Arrow integration tests" OFF) @@ -428,7 +429,9 @@ if(NANOARROW_BUILD_TESTS) message(STATUS "Arrow SO version: ${ARROW_FULL_SO_VERSION}") # TODO: does this propoagate to projects using as a subproject? - add_compile_definitions("-DNANOARROW_ARROW_FOUND") + if(NANOARROW_BUILD_TESTS_WITH_ARROW) + add_compile_definitions("-DNANOARROW_BUILD_TESTS_WITH_ARROW") + endif() # Give caller the option to link a static version of Arrow C++ if(NANOARROW_ARROW_STATIC) diff --git a/CMakePresets.json b/CMakePresets.json index d5ff3ea0e..efd3e5105 100644 --- a/CMakePresets.json +++ b/CMakePresets.json @@ -21,6 +21,7 @@ "cacheVariables": { "CMAKE_BUILD_TYPE": "Debug", "NANOARROW_BUILD_TESTS": "ON" + "NANOARROW_BUILD_TESTS_WITH_ARROW": "ON" } }, { diff --git a/README.md b/README.md index b3c5e1cf6..6ac460349 100644 --- a/README.md +++ b/README.md @@ -127,9 +127,7 @@ cmake .. cmake --build . ``` -Building nanoarrow with tests currently requires [Arrow C++](https://arrow.apache.org/install/). -If installed via a system package manager like `apt`, `dnf`, or `brew`, the tests can be -built with: +To build nanoarrow along with tests run: ```sh mkdir build && cd build @@ -137,6 +135,15 @@ cmake .. -DNANOARROW_BUILD_TESTS=ON cmake --build . ``` +If you are able to install [Arrow C++](https://arrow.apache.org/install/) you can enable +more testing: + +```sh +mkdir build && cd build +cmake .. -DNANOARROW_BUILD_TESTS=ON -DNANOARROW_BUILD_TESTS_WITH_ARROW=ON +cmake --build . +``` + Tests can be run with `ctest`. ### Building with Meson diff --git a/ci/scripts/coverage.sh b/ci/scripts/coverage.sh index 14c3688e0..c8d117609 100755 --- a/ci/scripts/coverage.sh +++ b/ci/scripts/coverage.sh @@ -74,7 +74,8 @@ function main() { cmake "${TARGET_NANOARROW_DIR}" \ -DNANOARROW_DEVICE=ON -DNANOARROW_IPC=ON \ - -DNANOARROW_BUILD_TESTS=ON -DNANOARROW_CODE_COVERAGE=ON + -DNANOARROW_BUILD_TESTS=ON -DNANOARROW_BUILD_TESTS_WITH_ARROW=ON \ + -DNANOARROW_CODE_COVERAGE=ON cmake --build . CTEST_OUTPUT_ON_FAILURE=1 ctest . diff --git a/dev/release/verify-release-candidate.sh b/dev/release/verify-release-candidate.sh index 18591ad69..8c1973fa6 100755 --- a/dev/release/verify-release-candidate.sh +++ b/dev/release/verify-release-candidate.sh @@ -243,12 +243,14 @@ test_cmake_project() { test_c() { show_header "Build and test C library" - test_cmake_project build . -DNANOARROW_BUILD_TESTS=ON -DNANOARROW_IPC=ON + test_cmake_project build . -DNANOARROW_BUILD_TESTS=ON -DNANOARROW_IPC=ON \ + -DNANOARROW_BUILD_TESTS_WITH_ARROW=ON } test_c_bundled() { show_header "Build test bundled C library" - test_cmake_project build-bundled . -DNANOARROW_BUILD_TESTS=ON -DNANOARROW_IPC=ON -DNANOARROW_BUNDLE=ON + test_cmake_project build-bundled . -DNANOARROW_BUILD_TESTS=ON -DNANOARROW_IPC=ON \ + -DNANOARROW_BUILD_TESTS_WITH_ARROW=ON -DNANOARROW_BUNDLE=ON } test_r() { diff --git a/meson.build b/meson.build index d0477dc0d..20a5d9b0a 100644 --- a/meson.build +++ b/meson.build @@ -49,9 +49,11 @@ add_project_arguments( # The system include suppresses compilation warnings from Arrow arrow_dep = dependency('arrow', include_type: 'system', required: false) -if arrow_dep.found() - add_project_arguments('-DNANOARROW_ARROW_FOUND', language : 'c') - add_project_arguments('-DNANOARROW_ARROW_FOUND', language : 'cpp') +if get_option('tests_with_arrow') and not arrow_dep.found() + error('tests_with_arrow=true but could not find Arrow') +elif get_option('tests_with_arrow') + add_project_arguments('-DNANOARROW_BUILD_TESTS_WITH_ARROW', language : 'c') + add_project_arguments('-DNANOARROW_BUILD_TESTS_WITH_ARROW', language : 'cpp') endif if get_option('buildtype') in ['debug', 'debugoptimized'] diff --git a/meson.options b/meson.options index f1ff092d4..93fec9505 100644 --- a/meson.options +++ b/meson.options @@ -16,6 +16,7 @@ # under the License. option('tests', type: 'boolean', description: 'Build tests', value: false) +option('tests_with_arrow', type: 'boolean', description: 'Build tests with Arrow', value: false) option('benchmarks', type: 'boolean', description: 'Build benchmarks', value: false) option('apps', type: 'boolean', description: 'Build utility applications', value: false) option('ipc', type: 'boolean', description: 'Build IPC libraries', value: false) diff --git a/src/nanoarrow/common/array_test.cc b/src/nanoarrow/common/array_test.cc index 1e30f6bf1..0e7839d66 100644 --- a/src/nanoarrow/common/array_test.cc +++ b/src/nanoarrow/common/array_test.cc @@ -20,7 +20,7 @@ #include #include -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) #include #include #include @@ -40,7 +40,7 @@ #include "nanoarrow/nanoarrow.hpp" -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) using namespace arrow; #endif using namespace nanoarrow::literals; @@ -50,7 +50,7 @@ using testing::ElementsAre; // Lightweight versions of ArrowTesting's ARROW_EXPECT_OK. This // version accomplishes the task of making sure the status message // ends up in the ctests log. -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) void ARROW_EXPECT_OK(Status status) { if (!status.ok()) { throw std::runtime_error(status.message()); @@ -386,7 +386,7 @@ INSTANTIATE_TEST_SUITE_P(NanoarrowIpcTest, UnparameterizedTypeTestFixture, ::testing::Values(NANOARROW_TYPE_NA, NANOARROW_TYPE_INT32, NANOARROW_TYPE_BINARY, NANOARROW_TYPE_STRUCT)); -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) TEST(ArrayTest, ArrayTestAppendToNullArray) { struct ArrowArray array; ASSERT_EQ(ArrowArrayInitFromType(&array, NANOARROW_TYPE_NA), NANOARROW_OK); @@ -585,7 +585,7 @@ TEST(ArrayTest, ArrayTestAppendEmptyToString) { ArrowArrayRelease(&array); } -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) TEST(ArrayTest, ArrayTestAppendToUInt64Array) { struct ArrowArray array; @@ -639,7 +639,7 @@ TEST(ArrayTest, ArrayTestAppendToUInt32Array) { ArrowArrayRelease(&array); } -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) TEST(ArrayTest, ArrayTestAppendToUInt16Array) { struct ArrowArray array; @@ -1107,7 +1107,7 @@ TEST(ArrayTest, ArrayTestAppendToIntervalArrayYearMonth) { ArrowArrayRelease(&array); } -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) TEST(ArrayTest, ArrayTestAppendToIntervalArrayDayTime) { struct ArrowArray array; @@ -1549,7 +1549,7 @@ TEST(ArrayTest, ArrayTestAppendToListArrayErrors) { ArrowSchemaRelease(&schema); } -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) TEST(ArrayTest, ArrayTestAppendToStructArray) { struct ArrowArray array; struct ArrowSchema schema; @@ -1792,7 +1792,7 @@ TEST(ArrayTest, ArrayTestUnionUtils) { EXPECT_FALSE(_ArrowUnionTypeIdsWillEqualChildIndices("0,2", 2)); } -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) TEST(ArrayTest, ArrayTestAppendToDenseUnionArray) { struct ArrowArray array; struct ArrowSchema schema; @@ -3268,7 +3268,7 @@ TEST(ArrayTest, ArrayViewTestSparseUnionGet) { // the "value type" that would correspond to what ArrowArrayViewGetDoubleUnsafe() // or ArrowArrayAppendDouble() do since they operate on the logical/represented // value. -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) template BuilderValueT logical_value_to_builder_value(int64_t value) { return static_cast(value); @@ -3439,7 +3439,7 @@ TEST(ArrayViewTest, ArrayViewTestGetFloat16) { ArrowSchemaRelease(&schema); } -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) template void TestGetFromBinary(BuilderClass& builder) { struct ArrowArray array; @@ -3655,7 +3655,7 @@ TEST(ArrayViewTest, ArrayViewTestGetIntervalYearMonth) { ArrowArrayRelease(&array); } -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) TEST(ArrayViewTest, ArrayViewTestGetIntervalDayTime) { struct ArrowArray array; struct ArrowSchema schema; diff --git a/src/nanoarrow/common/schema_test.cc b/src/nanoarrow/common/schema_test.cc index 5ffbce642..6fd888840 100644 --- a/src/nanoarrow/common/schema_test.cc +++ b/src/nanoarrow/common/schema_test.cc @@ -17,7 +17,7 @@ #include -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) #include #include #include @@ -26,7 +26,7 @@ #include "nanoarrow/nanoarrow.hpp" -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) using namespace arrow; #endif @@ -80,7 +80,7 @@ TEST(SchemaTest, SchemaInit) { ArrowSchemaRelease(&schema); } -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) static void ExpectSchemaInitOk(enum ArrowType type, std::shared_ptr expected_arrow_type) { struct ArrowSchema schema; @@ -126,7 +126,7 @@ TEST(SchemaTest, SchemaInitSimpleError) { EXPECT_EQ(schema.release, nullptr); } -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) TEST(SchemaTest, SchemaTestInitNestedList) { struct ArrowSchema schema; @@ -279,7 +279,7 @@ TEST(SchemaTest, SchemaInitRunEndEncoded) { #endif } -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) TEST(SchemaTest, SchemaInitDateTime) { struct ArrowSchema schema; @@ -515,7 +515,7 @@ TEST(SchemaTest, SchemaAllocateDictionary) { ArrowSchemaRelease(&schema); } -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) TEST(SchemaTest, SchemaCopySimpleType) { struct ArrowSchema schema; ARROW_EXPECT_OK(ExportType(*int32(), &schema)); @@ -683,7 +683,7 @@ TEST(SchemaViewTest, SchemaViewInitErrors) { ArrowSchemaRelease(&schema); } -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) void ExpectSimpleTypeOk(std::shared_ptr arrow_t, enum ArrowType nanoarrow_t, int bitwidth, const char* formatted) { struct ArrowSchema schema; @@ -752,7 +752,7 @@ TEST(SchemaViewTest, SchemaViewInitSimpleErrors) { ArrowSchemaRelease(&schema); } -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) TEST(SchemaViewTest, SchemaViewInitDecimal) { struct ArrowSchema schema; struct ArrowSchemaView schema_view; @@ -843,7 +843,7 @@ TEST(SchemaViewTest, SchemaViewInitDecimalErrors) { ArrowSchemaRelease(&schema); } -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) TEST(SchemaViewTest, SchemaViewInitBinaryAndString) { struct ArrowSchema schema; struct ArrowSchemaView schema_view; @@ -996,7 +996,7 @@ TEST(SchemaViewTest, SchemaViewInitBinaryAndStringErrors) { ArrowSchemaRelease(&schema); } -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) TEST(SchemaViewTest, SchemaViewInitTimeDate) { struct ArrowSchema schema; struct ArrowSchemaView schema_view; @@ -1213,7 +1213,7 @@ TEST(SchemaViewTest, SchemaViewInitTimeErrors) { ArrowSchemaRelease(&schema); } -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) TEST(SchemaViewTest, SchemaViewInitNestedList) { struct ArrowSchema schema; struct ArrowSchemaView schema_view; @@ -1295,7 +1295,7 @@ TEST(SchemaViewTest, SchemaViewNestedListErrors) { ArrowSchemaRelease(&schema); } -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) TEST(SchemaViewTest, SchemaViewInitNestedStruct) { struct ArrowSchema schema; struct ArrowSchemaView schema_view; @@ -1352,7 +1352,7 @@ TEST(SchemaViewTest, SchemaViewInitNestedStructErrors) { ArrowSchemaRelease(&schema); } -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) TEST(SchemaViewTest, SchemaViewInitNestedMap) { struct ArrowSchema schema; struct ArrowSchemaView schema_view; @@ -1435,7 +1435,7 @@ TEST(SchemaViewTest, SchemaViewInitNestedMapErrors) { ArrowSchemaRelease(&schema); } -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) TEST(SchemaViewTest, SchemaViewInitNestedUnion) { struct ArrowSchema schema; struct ArrowSchemaView schema_view; @@ -1528,7 +1528,7 @@ TEST(SchemaViewTest, SchemaViewInitInvalidSpecErrors) { ArrowSchemaRelease(&schema); } -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) TEST(SchemaViewTest, SchemaViewInitDictionary) { struct ArrowSchema schema; struct ArrowSchemaView schema_view; @@ -1565,7 +1565,7 @@ TEST(SchemaViewTest, SchemaViewInitDictionaryErrors) { ArrowSchemaRelease(&schema); } -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) TEST(SchemaViewTest, SchemaViewInitExtension) { using namespace nanoarrow::literals; @@ -1588,7 +1588,7 @@ TEST(SchemaViewTest, SchemaViewInitExtension) { } #endif -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) TEST(SchemaViewTest, SchemaViewInitExtensionDictionary) { using namespace nanoarrow::literals; diff --git a/src/nanoarrow/common/utils_test.cc b/src/nanoarrow/common/utils_test.cc index 7de3fad47..6e87a45ea 100644 --- a/src/nanoarrow/common/utils_test.cc +++ b/src/nanoarrow/common/utils_test.cc @@ -18,7 +18,7 @@ #include #include -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) #include #endif #include @@ -27,7 +27,7 @@ #include "nanoarrow/nanoarrow.hpp" #include "nanoarrow/nanoarrow_testing.hpp" -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) using namespace arrow; #endif @@ -256,7 +256,7 @@ TEST(AllocatorTest, AllocatorTestMemoryPool) { #endif } -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) TEST(DecimalTest, Decimal128Test) { struct ArrowDecimal decimal; ArrowDecimalInit(&decimal, 128, 10, 3); @@ -352,7 +352,7 @@ TEST(DecimalTest, DecimalNegateTest) { ArrowBufferReset(&buffer); } -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) TEST(DecimalTest, Decimal256Test) { using namespace nanoarrow::literals; diff --git a/src/nanoarrow/ipc/decoder_test.cc b/src/nanoarrow/ipc/decoder_test.cc index 4c2c4c4ec..f59e52c5c 100644 --- a/src/nanoarrow/ipc/decoder_test.cc +++ b/src/nanoarrow/ipc/decoder_test.cc @@ -17,7 +17,7 @@ #include -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) #include #include #include @@ -31,7 +31,7 @@ #include "nanoarrow/nanoarrow_ipc.hpp" -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) using namespace arrow; #endif @@ -469,7 +469,7 @@ TEST(NanoarrowIpcTest, NanoarrowIpcSetSchemaErrors) { ArrowIpcDecoderReset(&decoder); } -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) class ArrowTypeParameterizedTestFixture : public ::testing::TestWithParam> { protected: @@ -563,7 +563,7 @@ std::string ArrowSchemaToString(const struct ArrowSchema* schema) { return out; } -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) TEST_P(ArrowTypeParameterizedTestFixture, NanoarrowIpcNanoarrowTypeRoundtrip) { nanoarrow::UniqueSchema schema; ASSERT_TRUE( @@ -735,7 +735,7 @@ TEST(NanoarrowIpcTest, NanoarrowIpcSharedBufferThreadSafeDecode) { // We will get a (occasional) memory leak if the atomic counter does not work } -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) TEST_P(ArrowTypeParameterizedTestFixture, NanoarrowIpcArrowArrayRoundtrip) { const std::shared_ptr& data_type = GetParam(); std::shared_ptr dummy_schema = @@ -826,7 +826,7 @@ void AssertArrayViewIdentical(const struct ArrowArrayView* actual, } } -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) TEST_P(ArrowTypeParameterizedTestFixture, NanoarrowIpcNanoarrowArrayRoundtrip) { struct ArrowError error; nanoarrow::UniqueSchema schema; diff --git a/src/nanoarrow/ipc/files_test.cc b/src/nanoarrow/ipc/files_test.cc index 727e14695..cb505ce2d 100644 --- a/src/nanoarrow/ipc/files_test.cc +++ b/src/nanoarrow/ipc/files_test.cc @@ -21,7 +21,7 @@ #include -#if defined(NANOARROW_ARROW_FOUND) +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) #include #include #include From fa52487deac8a0cd1b75e631b3ac411ca150247c Mon Sep 17 00:00:00 2001 From: Will Ayd Date: Tue, 12 Nov 2024 14:27:22 -0500 Subject: [PATCH 3/9] Meson configuration cleanup --- meson.build | 133 +++++++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 122 insertions(+), 11 deletions(-) diff --git a/meson.build b/meson.build index 20a5d9b0a..a276c7f19 100644 --- a/meson.build +++ b/meson.build @@ -47,15 +47,6 @@ add_project_arguments( language: 'cpp', ) -# The system include suppresses compilation warnings from Arrow -arrow_dep = dependency('arrow', include_type: 'system', required: false) -if get_option('tests_with_arrow') and not arrow_dep.found() - error('tests_with_arrow=true but could not find Arrow') -elif get_option('tests_with_arrow') - add_project_arguments('-DNANOARROW_BUILD_TESTS_WITH_ARROW', language : 'c') - add_project_arguments('-DNANOARROW_BUILD_TESTS_WITH_ARROW', language : 'cpp') -endif - if get_option('buildtype') in ['debug', 'debugoptimized'] add_project_arguments('-DNANOARROW_DEBUG', language: 'c') add_project_arguments('-DNANOARROW_DEBUG', language: 'cpp') @@ -214,8 +205,15 @@ if get_option('tests') # wrap the tests with valgrind via `meson test --wrap=valgrind`. See # https://mesonbuild.com/Unit-tests.html - # Similarly code coverage has a built in option users should use instead - # https://mesonbuild.com/Unit-tests.html#coverage + arrow_dep = dependency('arrow', include_type: 'system', required: false) + if get_option('tests_with_arrow') and not arrow_dep.found() + error('tests_with_arrow=true but could not find Arrow') + endif + + test_cpp_args = [] + if get_option('tests_with_arrow') + test_cpp_args += ['-DNANOARROW_BUILD_TESTS_WITH_ARROW'] + endif gtest_dep = dependency('gtest_main') gmock_dep = dependency('gmock') @@ -342,6 +340,119 @@ if get_option('tests') ) test('nanoarrow-device-metal', exc) endif +======= + foreach name : nanoarrow_tests + exc = executable( + name + '-test', + sources: 'src/nanoarrow/common/' + name.replace('-', '_') + '_test.cc', + include_directories: incdir, + dependencies: [nanoarrow_testing_dep, arrow_dep, gtest_dep, gmock_dep], + cpp_args: test_cpp_args, + ) + test(name, exc) + endforeach + + nanoarrow_hpp_tests = ['array_stream', 'buffer', 'exception', 'unique', 'view'] + + foreach name : nanoarrow_hpp_tests + exc = executable( + 'hpp-' + name + '-test', + sources: 'src/nanoarrow/hpp/' + name.replace('-', '_') + '_test.cc', + include_directories: incdir, + dependencies: [nanoarrow_testing_dep, gtest_dep, gmock_dep], + cpp_args: test_cpp_args, + ) + test(name, exc) + endforeach + + testing_test = executable( + 'nanoarrow-testing-test', + 'src/nanoarrow/testing/testing_test.cc', + include_directories: incdir, + dependencies: [nanoarrow_testing_dep, arrow_dep, gtest_dep], + cpp_args: test_cpp_args, + ) + test('nanoarrow-testing-test', testing_test) + + c_data_integration_test = executable( + 'c-data-integration-test', + 'src/nanoarrow/integration/c_data_integration_test.cc', + link_with: [c_data_integration_lib], + dependencies: [nanoarrow_testing_dep, arrow_dep, gtest_dep], + include_directories: incdir, + cpp_args: test_cpp_args, + ) + test('c-data-integration', c_data_integration_test) + + if get_option('ipc') + zlib_dep = dependency('zlib') + ipc_test_files = { + 'ipc-decoder': { + 'src': 'decoder', + 'deps': [nanoarrow_ipc_dep, flatcc_dep, arrow_dep, gtest_dep, gmock_dep], + 'timeout': 30, + }, + 'ipc-reader': { + 'src': 'reader', + 'deps': [nanoarrow_ipc_dep, arrow_dep, gtest_dep], + # the ipc reader test can take longer when executed + # under valgrind, hence the increased timeout + 'timeout': 90, + + }, + 'ipc-files': { + 'src': 'files', + 'deps': [ + nanoarrow_testing_dep, + nanoarrow_ipc_dep, + flatcc_dep, + zlib_dep, + arrow_dep, + gtest_dep, + ], + 'timeout': 30, + }, + 'ipc-hpp': { + 'src': 'ipc_hpp', + 'deps': [nanoarrow_testing_dep, nanoarrow_ipc_dep, gtest_dep], + 'timeout': 30, + }, + } + + foreach name, config : ipc_test_files + exc = executable( + 'nanoarrow-' + name + '-test', + 'src/nanoarrow/ipc/' + config['src'] + '_test.cc', + dependencies: config['deps'], + cpp_args: test_cpp_args, + ) + test(name, exc, timeout: config['timeout']) + endforeach + endif + + if needs_device + device_tests = ['device', 'device_hpp'] + foreach device_test : device_tests + exc = executable( + 'nanoarrow-' + device_test.replace('_', '-') + '-test', + 'src/nanoarrow/device/' + device_test + '_test.cc', + link_with: nanoarrow_device_lib, + dependencies: [nanoarrow_testing_dep, gtest_dep], + cpp_args: test_cpp_args, + ) + test(device_test.replace('_', '-'), exc) + endforeach + + if get_option('metal') + exc = executable( + 'nanoarrow-device-metal-test', + 'src/nanoarrow/device/metal_test.cc', + link_with: nanoarrow_device_lib, + dependencies: [nanoarrow_testing_dep, gtest_dep, metal_cpp_dep], + cpp_args: test_cpp_args, + ) + test('nanoarrow-device-metal', exc) +>>>>>>> a580e29 (Meson configuration cleanup) endif endif From d9f7b365eec63128c54970b8054f8afcc6693028 Mon Sep 17 00:00:00 2001 From: Will Ayd Date: Tue, 12 Nov 2024 15:00:22 -0500 Subject: [PATCH 4/9] Narrower ifdefined scopes --- src/nanoarrow/common/array_test.cc | 118 ++++++++++++++++++++++++---- src/nanoarrow/common/schema_test.cc | 35 +++++++-- src/nanoarrow/common/utils_test.cc | 8 +- 3 files changed, 137 insertions(+), 24 deletions(-) diff --git a/src/nanoarrow/common/array_test.cc b/src/nanoarrow/common/array_test.cc index 0e7839d66..a5f4ed5ba 100644 --- a/src/nanoarrow/common/array_test.cc +++ b/src/nanoarrow/common/array_test.cc @@ -386,7 +386,6 @@ INSTANTIATE_TEST_SUITE_P(NanoarrowIpcTest, UnparameterizedTypeTestFixture, ::testing::Values(NANOARROW_TYPE_NA, NANOARROW_TYPE_INT32, NANOARROW_TYPE_BINARY, NANOARROW_TYPE_STRUCT)); -#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) TEST(ArrayTest, ArrayTestAppendToNullArray) { struct ArrowArray array; ASSERT_EQ(ArrowArrayInitFromType(&array, NANOARROW_TYPE_NA), NANOARROW_OK); @@ -400,11 +399,13 @@ TEST(ArrayTest, ArrayTestAppendToNullArray) { EXPECT_EQ(array.length, 3); EXPECT_EQ(array.null_count, 3); +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) auto arrow_array = ImportArray(&array, null()); ARROW_EXPECT_OK(arrow_array); auto expected_array = MakeArrayOfNull(null(), 3); ARROW_EXPECT_OK(expected_array); EXPECT_TRUE(arrow_array.ValueUnsafe()->Equals(expected_array.ValueUnsafe())); +#endif ASSERT_EQ(ArrowArrayInitFromType(&array, NANOARROW_TYPE_NA), NANOARROW_OK); EXPECT_EQ(ArrowArrayAppendInt(&array, 0), EINVAL); @@ -441,6 +442,7 @@ TEST(ArrayTest, ArrayTestAppendToInt64Array) { EXPECT_EQ(data_buffer[3], 3); EXPECT_EQ(data_buffer[4], 0); +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) auto arrow_array = ImportArray(&array, int64()); ARROW_EXPECT_OK(arrow_array); @@ -452,6 +454,9 @@ TEST(ArrayTest, ArrayTestAppendToInt64Array) { auto expected_array = builder.Finish(); EXPECT_TRUE(arrow_array.ValueUnsafe()->Equals(expected_array.ValueUnsafe())); +#else + ArrowArrayRelease(&array); +#endif } TEST(ArrayTest, ArrayTestAppendToInt32Array) { @@ -470,6 +475,7 @@ TEST(ArrayTest, ArrayTestAppendToInt32Array) { EXPECT_EQ(array.buffers[0], nullptr); EXPECT_EQ(data_buffer[0], 123); +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) auto arrow_array = ImportArray(&array, int32()); ARROW_EXPECT_OK(arrow_array); @@ -478,6 +484,9 @@ TEST(ArrayTest, ArrayTestAppendToInt32Array) { auto expected_array = builder.Finish(); EXPECT_TRUE(arrow_array.ValueUnsafe()->Equals(expected_array.ValueUnsafe())); +#else + ArrowArrayRelease(&array); +#endif } TEST(ArrayTest, ArrayTestAppendToInt16Array) { @@ -496,6 +505,7 @@ TEST(ArrayTest, ArrayTestAppendToInt16Array) { EXPECT_EQ(array.buffers[0], nullptr); EXPECT_EQ(data_buffer[0], 123); +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) auto arrow_array = ImportArray(&array, int16()); ARROW_EXPECT_OK(arrow_array); @@ -504,6 +514,9 @@ TEST(ArrayTest, ArrayTestAppendToInt16Array) { auto expected_array = builder.Finish(); EXPECT_TRUE(arrow_array.ValueUnsafe()->Equals(expected_array.ValueUnsafe())); +#else + ArrowArrayRelease(&array); +#endif } TEST(ArrayTest, ArrayTestAppendToInt8Array) { @@ -522,6 +535,7 @@ TEST(ArrayTest, ArrayTestAppendToInt8Array) { EXPECT_EQ(array.buffers[0], nullptr); EXPECT_EQ(data_buffer[0], 123); +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) auto arrow_array = ImportArray(&array, int8()); ARROW_EXPECT_OK(arrow_array); @@ -530,6 +544,9 @@ TEST(ArrayTest, ArrayTestAppendToInt8Array) { auto expected_array = builder.Finish(); EXPECT_TRUE(arrow_array.ValueUnsafe()->Equals(expected_array.ValueUnsafe())); +#else + ArrowArrayRelease(&array); +#endif } TEST(ArrayTest, ArrayTestAppendToStringArray) { @@ -561,6 +578,7 @@ TEST(ArrayTest, ArrayTestAppendToStringArray) { EXPECT_EQ(offset_buffer[4], 9); EXPECT_EQ(memcmp(data_buffer, "123456789", 9), 0); +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) auto arrow_array = ImportArray(&array, utf8()); ARROW_EXPECT_OK(arrow_array); @@ -572,8 +590,10 @@ TEST(ArrayTest, ArrayTestAppendToStringArray) { auto expected_array = builder.Finish(); EXPECT_TRUE(arrow_array.ValueUnsafe()->Equals(expected_array.ValueUnsafe())); -} +#else + ArrowArrayRelease(&array); #endif +} TEST(ArrayTest, ArrayTestAppendEmptyToString) { struct ArrowArray array; @@ -585,7 +605,6 @@ TEST(ArrayTest, ArrayTestAppendEmptyToString) { ArrowArrayRelease(&array); } -#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) TEST(ArrayTest, ArrayTestAppendToUInt64Array) { struct ArrowArray array; @@ -606,6 +625,7 @@ TEST(ArrayTest, ArrayTestAppendToUInt64Array) { EXPECT_EQ(data_buffer[2], 0); EXPECT_EQ(data_buffer[3], 3); +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) auto arrow_array = ImportArray(&array, uint64()); ARROW_EXPECT_OK(arrow_array); @@ -616,8 +636,10 @@ TEST(ArrayTest, ArrayTestAppendToUInt64Array) { auto expected_array = builder.Finish(); EXPECT_TRUE(arrow_array.ValueUnsafe()->Equals(expected_array.ValueUnsafe())); -} +#else + ArrowArrayRelease(&array); #endif +} TEST(ArrayTest, ArrayTestAppendToUInt32Array) { struct ArrowArray array; @@ -639,7 +661,6 @@ TEST(ArrayTest, ArrayTestAppendToUInt32Array) { ArrowArrayRelease(&array); } -#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) TEST(ArrayTest, ArrayTestAppendToUInt16Array) { struct ArrowArray array; @@ -660,6 +681,7 @@ TEST(ArrayTest, ArrayTestAppendToUInt16Array) { EXPECT_EQ(data_buffer[0], 1); EXPECT_EQ(data_buffer[1], 3); +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) auto arrow_array = ImportArray(&array, uint16()); ARROW_EXPECT_OK(arrow_array); @@ -669,6 +691,9 @@ TEST(ArrayTest, ArrayTestAppendToUInt16Array) { auto expected_array = builder.Finish(); EXPECT_TRUE(arrow_array.ValueUnsafe()->Equals(expected_array.ValueUnsafe())); +#else + ArrowArrayRelease(&array); +#endif } TEST(ArrayTest, ArrayTestAppendToUInt8Array) { @@ -691,6 +716,7 @@ TEST(ArrayTest, ArrayTestAppendToUInt8Array) { EXPECT_EQ(data_buffer[0], 1); EXPECT_EQ(data_buffer[1], 3); +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) auto arrow_array = ImportArray(&array, uint8()); ARROW_EXPECT_OK(arrow_array); @@ -700,6 +726,9 @@ TEST(ArrayTest, ArrayTestAppendToUInt8Array) { auto expected_array = builder.Finish(); EXPECT_TRUE(arrow_array.ValueUnsafe()->Equals(expected_array.ValueUnsafe())); +#else + ArrowArrayRelease(&array); +#endif } TEST(ArrayTest, ArrayTestAppendToDoubleArray) { @@ -739,6 +768,7 @@ TEST(ArrayTest, ArrayTestAppendToDoubleArray) { EXPECT_FLOAT_EQ(static_cast(data_buffer[9]), -1); EXPECT_FLOAT_EQ(static_cast(data_buffer[10]), 0); +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) auto arrow_array = ImportArray(&array, float64()); ARROW_EXPECT_OK(arrow_array); @@ -757,6 +787,9 @@ TEST(ArrayTest, ArrayTestAppendToDoubleArray) { auto options = arrow::EqualOptions::Defaults().nans_equal(true); EXPECT_TRUE(arrow_array.ValueUnsafe()->Equals(expected_array.ValueUnsafe(), options)); +#else + ArrowArrayRelease(&array); +#endif } TEST(ArrayTest, ArrayTestAppendToFloatArray) { @@ -795,6 +828,7 @@ TEST(ArrayTest, ArrayTestAppendToFloatArray) { EXPECT_FLOAT_EQ(data_buffer[9], -1); EXPECT_FLOAT_EQ(data_buffer[10], 0); +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) auto arrow_array = ImportArray(&array, float32()); ARROW_EXPECT_OK(arrow_array); @@ -813,6 +847,9 @@ TEST(ArrayTest, ArrayTestAppendToFloatArray) { auto options = arrow::EqualOptions::Defaults().nans_equal(true); EXPECT_TRUE(arrow_array.ValueUnsafe()->Equals(expected_array.ValueUnsafe(), options)); +#else + ArrowArrayRelease(&array); +#endif } TEST(ArrayTest, ArrayTestAppendToHalfFloatArray) { @@ -852,10 +889,13 @@ TEST(ArrayTest, ArrayTestAppendToHalfFloatArray) { EXPECT_FLOAT_EQ(ArrowHalfFloatToFloat(data_buffer[9]), -1); EXPECT_FLOAT_EQ(ArrowHalfFloatToFloat(data_buffer[10]), 0); +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) auto arrow_array = ImportArray(&array, float16()); ARROW_EXPECT_OK(arrow_array); -} +#else + ArrowArrayRelease(&array); #endif +} TEST(ArrayTest, ArrayTestAppendToBoolArray) { struct ArrowArray array; @@ -1107,7 +1147,6 @@ TEST(ArrayTest, ArrayTestAppendToIntervalArrayYearMonth) { ArrowArrayRelease(&array); } -#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) TEST(ArrayTest, ArrayTestAppendToIntervalArrayDayTime) { struct ArrowArray array; @@ -1131,6 +1170,7 @@ TEST(ArrayTest, ArrayTestAppendToIntervalArrayDayTime) { EXPECT_EQ(memcmp(data_buffer, &interval.days, 4), 0); EXPECT_EQ(memcmp(data_buffer + sizeof(interval.days), &interval.ms, 4), 0); +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) auto arrow_array = ImportArray(&array, day_time_interval()); ARROW_EXPECT_OK(arrow_array); @@ -1141,6 +1181,9 @@ TEST(ArrayTest, ArrayTestAppendToIntervalArrayDayTime) { auto expected_array = builder.Finish(); EXPECT_TRUE(arrow_array.ValueUnsafe()->Equals(expected_array.ValueUnsafe())); +#else + ArrowArrayRelease(&array); +#endif } TEST(ArrayTest, ArrayTestAppendToIntervalArrayMonthDayNano) { @@ -1180,6 +1223,7 @@ TEST(ArrayTest, ArrayTestAppendToIntervalArrayMonthDayNano) { &interval.ns, sizeof(interval.ns)), 0); +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) auto arrow_array = ImportArray(&array, month_day_nano_interval()); ARROW_EXPECT_OK(arrow_array); @@ -1193,6 +1237,9 @@ TEST(ArrayTest, ArrayTestAppendToIntervalArrayMonthDayNano) { auto expected_array = builder.Finish(); EXPECT_TRUE(arrow_array.ValueUnsafe()->Equals(expected_array.ValueUnsafe())); +#else + ArrowArrayRelease(&array); +#endif } TEST(ArrayTest, ArrayTestAppendToDecimal128Array) { @@ -1223,6 +1270,7 @@ TEST(ArrayTest, ArrayTestAppendToDecimal128Array) { ArrowDecimalSetInt(&decimal, -67890); EXPECT_EQ(memcmp(data_buffer + 3 * 16, decimal.words, 16), 0); +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) auto arrow_array = ImportArray(&array, decimal128(10, 3)); ARROW_EXPECT_OK(arrow_array); @@ -1233,6 +1281,9 @@ TEST(ArrayTest, ArrayTestAppendToDecimal128Array) { auto expected_array = builder.Finish(); EXPECT_TRUE(arrow_array.ValueUnsafe()->Equals(expected_array.ValueUnsafe())); +#else + ArrowArrayRelease(&array); +#endif } TEST(ArrayTest, ArrayTestAppendToDecimal256Array) { @@ -1263,6 +1314,7 @@ TEST(ArrayTest, ArrayTestAppendToDecimal256Array) { ArrowDecimalSetInt(&decimal, -67890); EXPECT_EQ(memcmp(data_buffer + 3 * 32, decimal.words, 32), 0); +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) auto arrow_array = ImportArray(&array, decimal256(10, 3)); ARROW_EXPECT_OK(arrow_array); @@ -1273,6 +1325,9 @@ TEST(ArrayTest, ArrayTestAppendToDecimal256Array) { auto expected_array = builder.Finish(); EXPECT_TRUE(arrow_array.ValueUnsafe()->Equals(expected_array.ValueUnsafe())); +#else + ArrowArrayRelease(&array); +#endif } TEST(ArrayTest, ArrayTestAppendToListArray) { @@ -1318,6 +1373,7 @@ TEST(ArrayTest, ArrayTestAppendToListArray) { array.children[0]->length = array.children[0]->length + 1; EXPECT_EQ(ArrowArrayFinishBuildingDefault(&array, &error), NANOARROW_OK); +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) auto arrow_array = ImportArray(&array, &schema); ARROW_EXPECT_OK(arrow_array); @@ -1334,6 +1390,10 @@ TEST(ArrayTest, ArrayTestAppendToListArray) { ARROW_EXPECT_OK(expected_array); EXPECT_TRUE(arrow_array.ValueUnsafe()->Equals(expected_array.ValueUnsafe())); +#else + ArrowSchemaRelease(&schema); + ArrowArrayRelease(&array); +#endif } TEST(ArrayTest, ArrayTestAppendToLargeListArray) { @@ -1380,6 +1440,7 @@ TEST(ArrayTest, ArrayTestAppendToLargeListArray) { array.children[0]->length = array.children[0]->length + 1; EXPECT_EQ(ArrowArrayFinishBuildingDefault(&array, &error), NANOARROW_OK); +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) auto arrow_array = ImportArray(&array, &schema); ARROW_EXPECT_OK(arrow_array); @@ -1397,6 +1458,10 @@ TEST(ArrayTest, ArrayTestAppendToLargeListArray) { ARROW_EXPECT_OK(expected_array); EXPECT_TRUE(arrow_array.ValueUnsafe()->Equals(expected_array.ValueUnsafe())); +#else + ArrowSchemaRelease(&schema); + ArrowArrayRelease(&array); +#endif } TEST(ArrayTest, ArrayTestAppendToMapArray) { @@ -1444,6 +1509,7 @@ TEST(ArrayTest, ArrayTestAppendToMapArray) { array.children[0]->length = array.children[0]->length + 1; EXPECT_EQ(ArrowArrayFinishBuildingDefault(&array, &error), NANOARROW_OK); +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) auto maybe_arrow_array = ImportArray(&array, &schema); ARROW_EXPECT_OK(maybe_arrow_array); auto arrow_array = std::move(maybe_arrow_array).MoveValueUnsafe(); @@ -1462,6 +1528,10 @@ TEST(ArrayTest, ArrayTestAppendToMapArray) { auto expected_array = std::move(maybe_expected_array).MoveValueUnsafe(); EXPECT_TRUE(arrow_array->Equals(expected_array)); +#else + ArrowSchemaRelease(&schema); + ArrowArrayRelease(&array); +#endif } TEST(ArrayTest, ArrayTestAppendToFixedSizeListArray) { @@ -1512,6 +1582,7 @@ TEST(ArrayTest, ArrayTestAppendToFixedSizeListArray) { array.children[0]->length = array.children[0]->length + 1; EXPECT_EQ(ArrowArrayFinishBuildingDefault(&array, nullptr), NANOARROW_OK); +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) auto arrow_array = ImportArray(&array, &schema); ARROW_EXPECT_OK(arrow_array); @@ -1530,8 +1601,11 @@ TEST(ArrayTest, ArrayTestAppendToFixedSizeListArray) { ARROW_EXPECT_OK(expected_array); EXPECT_TRUE(arrow_array.ValueUnsafe()->Equals(expected_array.ValueUnsafe())); -} +#else + ArrowSchemaRelease(&schema); + ArrowArrayRelease(&array); #endif +} TEST(ArrayTest, ArrayTestAppendToListArrayErrors) { struct ArrowArray array; @@ -1549,7 +1623,6 @@ TEST(ArrayTest, ArrayTestAppendToListArrayErrors) { ArrowSchemaRelease(&schema); } -#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) TEST(ArrayTest, ArrayTestAppendToStructArray) { struct ArrowArray array; struct ArrowSchema schema; @@ -1581,6 +1654,7 @@ TEST(ArrayTest, ArrayTestAppendToStructArray) { EXPECT_EQ(ArrowArrayFinishBuildingDefault(&array, nullptr), NANOARROW_OK); +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) auto arrow_array = ImportArray(&array, &schema); ARROW_EXPECT_OK(arrow_array); @@ -1597,6 +1671,10 @@ TEST(ArrayTest, ArrayTestAppendToStructArray) { ARROW_EXPECT_OK(expected_array); EXPECT_TRUE(arrow_array.ValueUnsafe()->Equals(expected_array.ValueUnsafe())); +#else + ArrowSchemaRelease(&schema); + ArrowArrayRelease(&array); +#endif } TEST(ArrayTest, ArrayTestAppendToRunEndEncodedArray) { @@ -1734,7 +1812,8 @@ TEST(ArrayTest, ArrayTestAppendToRunEndEncodedArray) { EXPECT_EQ(ArrowArrayFinishBuilding(&array, NANOARROW_VALIDATION_LEVEL_FULL, &error), NANOARROW_OK); -#if !defined(ARROW_VERSION_MAJOR) || ARROW_VERSION_MAJOR < 12 +#if !defined(NANOARROW_BUILD_TESTS_WITH_ARROW) || !defined(ARROW_VERSION_MAJOR) || \ + ARROW_VERSION_MAJOR < 12 ArrowSchemaRelease(&schema); ArrowArrayRelease(&array); #else @@ -1759,7 +1838,6 @@ TEST(ArrayTest, ArrayTestAppendToRunEndEncodedArray) { expected_array.ValueUnsafe()->ToString().c_str()); #endif } -#endif TEST(ArrayTest, ArrayTestUnionUtils) { // Check length calculation with nullptr @@ -1792,7 +1870,6 @@ TEST(ArrayTest, ArrayTestUnionUtils) { EXPECT_FALSE(_ArrowUnionTypeIdsWillEqualChildIndices("0,2", 2)); } -#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) TEST(ArrayTest, ArrayTestAppendToDenseUnionArray) { struct ArrowArray array; struct ArrowSchema schema; @@ -1817,6 +1894,7 @@ TEST(ArrayTest, ArrayTestAppendToDenseUnionArray) { EXPECT_EQ(ArrowArrayFinishBuildingDefault(&array, nullptr), NANOARROW_OK); +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) auto arrow_array = ImportArray(&array, &schema); ARROW_EXPECT_OK(arrow_array); @@ -1837,6 +1915,10 @@ TEST(ArrayTest, ArrayTestAppendToDenseUnionArray) { ARROW_EXPECT_OK(expected_array); EXPECT_TRUE(arrow_array.ValueUnsafe()->Equals(expected_array.ValueUnsafe())); +#else + ArrowSchemaRelease(&schema); + ArrowArrayRelease(&array); +#endif } TEST(ArrayTest, ArrayTestAppendToSparseUnionArray) { @@ -1862,6 +1944,7 @@ TEST(ArrayTest, ArrayTestAppendToSparseUnionArray) { EXPECT_EQ(ArrowArrayAppendEmpty(&array, 1), NANOARROW_OK); EXPECT_EQ(ArrowArrayFinishBuildingDefault(&array, nullptr), NANOARROW_OK); +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) auto arrow_array = ImportArray(&array, &schema); ARROW_EXPECT_OK(arrow_array); @@ -1887,8 +1970,11 @@ TEST(ArrayTest, ArrayTestAppendToSparseUnionArray) { EXPECT_EQ(arrow_array.ValueUnsafe()->ToString(), expected_array.ValueUnsafe()->ToString()); EXPECT_TRUE(arrow_array.ValueUnsafe()->Equals(expected_array.ValueUnsafe())); -} +#else + ArrowSchemaRelease(&schema); + ArrowArrayRelease(&array); #endif +} TEST(ArrayTest, ArrayTestAppendToUnionArrayErrors) { struct ArrowArray array; @@ -3590,7 +3676,8 @@ void TestGetFromBinaryView( } TEST(ArrayViewTest, ArrayViewTestGetStringView) { -#if defined(ARROW_VERSION_MAJOR) && ARROW_VERSION_MAJOR >= 15 +#if !defined(NANOARROW_BUILD_TESTS_WITH_ARROW) || \ + 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( @@ -3603,7 +3690,8 @@ TEST(ArrayViewTest, ArrayViewTestGetStringView) { } TEST(ArrayViewTest, ArrayViewTestGetBinaryView) { -#if defined(ARROW_VERSION_MAJOR) && ARROW_VERSION_MAJOR >= 15 +#if !defined(NANOARROW_BUILD_TESTS_WITH_ARROW) || \ + 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; diff --git a/src/nanoarrow/common/schema_test.cc b/src/nanoarrow/common/schema_test.cc index 6fd888840..3d4864000 100644 --- a/src/nanoarrow/common/schema_test.cc +++ b/src/nanoarrow/common/schema_test.cc @@ -126,7 +126,6 @@ TEST(SchemaTest, SchemaInitSimpleError) { EXPECT_EQ(schema.release, nullptr); } -#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) TEST(SchemaTest, SchemaTestInitNestedList) { struct ArrowSchema schema; @@ -134,6 +133,7 @@ TEST(SchemaTest, SchemaTestInitNestedList) { EXPECT_STREQ(schema.format, "+l"); ASSERT_EQ(ArrowSchemaSetType(schema.children[0], NANOARROW_TYPE_INT32), NANOARROW_OK); +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) auto arrow_type = ImportType(&schema); ARROW_EXPECT_OK(arrow_type); EXPECT_TRUE(arrow_type.ValueUnsafe()->Equals(list(int32()))); @@ -145,6 +145,9 @@ TEST(SchemaTest, SchemaTestInitNestedList) { arrow_type = ImportType(&schema); ARROW_EXPECT_OK(arrow_type); EXPECT_TRUE(arrow_type.ValueUnsafe()->Equals(large_list(int32()))); +#else + ArrowSchemaRelease(&schema); +#endif } TEST(SchemaTest, SchemaTestInitNestedStruct) { @@ -156,9 +159,13 @@ TEST(SchemaTest, SchemaTestInitNestedStruct) { ASSERT_EQ(ArrowSchemaSetType(schema.children[0], NANOARROW_TYPE_INT32), NANOARROW_OK); ASSERT_EQ(ArrowSchemaSetName(schema.children[0], "item"), NANOARROW_OK); +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) auto arrow_type = ImportType(&schema); ARROW_EXPECT_OK(arrow_type); EXPECT_TRUE(arrow_type.ValueUnsafe()->Equals(struct_({field("item", int32())}))); +#else + ArrowSchemaRelease(&schema); +#endif } TEST(SchemaTest, SchemaTestInitNestedMap) { @@ -177,9 +184,13 @@ TEST(SchemaTest, SchemaTestInitNestedMap) { EXPECT_FALSE(schema.children[0]->flags & ARROW_FLAG_NULLABLE); EXPECT_FALSE(schema.children[0]->children[0]->flags & ARROW_FLAG_NULLABLE); +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) auto arrow_type = ImportType(&schema); ARROW_EXPECT_OK(arrow_type); EXPECT_TRUE(arrow_type.ValueUnsafe()->Equals(map(int32(), utf8()))); +#else + ArrowSchemaRelease(&schema); +#endif } TEST(SchemaTest, SchemaInitFixedSize) { @@ -194,6 +205,7 @@ TEST(SchemaTest, SchemaInitFixedSize) { NANOARROW_OK); EXPECT_STREQ(schema.format, "w:45"); +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) auto arrow_type = ImportType(&schema); ARROW_EXPECT_OK(arrow_type); EXPECT_TRUE(arrow_type.ValueUnsafe()->Equals(fixed_size_binary(45))); @@ -207,6 +219,9 @@ TEST(SchemaTest, SchemaInitFixedSize) { arrow_type = ImportType(&schema); ARROW_EXPECT_OK(arrow_type); EXPECT_TRUE(arrow_type.ValueUnsafe()->Equals(fixed_size_list(int32(), 12))); +#else + ArrowSchemaRelease(&schema); +#endif } TEST(SchemaTest, SchemaInitDecimal) { @@ -220,6 +235,7 @@ TEST(SchemaTest, SchemaInitDecimal) { NANOARROW_OK); EXPECT_STREQ(schema.format, "d:1,2"); +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) auto arrow_type = ImportType(&schema); ARROW_EXPECT_OK(arrow_type); EXPECT_TRUE(arrow_type.ValueUnsafe()->Equals(decimal128(1, 2))); @@ -231,8 +247,10 @@ TEST(SchemaTest, SchemaInitDecimal) { arrow_type = ImportType(&schema); ARROW_EXPECT_OK(arrow_type); EXPECT_TRUE(arrow_type.ValueUnsafe()->Equals(decimal256(3, 4))); -} +#else + ArrowSchemaRelease(&schema); #endif +} TEST(SchemaTest, SchemaInitRunEndEncoded) { struct ArrowSchema schema; @@ -250,7 +268,8 @@ TEST(SchemaTest, SchemaInitRunEndEncoded) { ASSERT_EQ(ArrowSchemaSetType(schema.children[1], NANOARROW_TYPE_FLOAT), NANOARROW_OK); -#if !defined(ARROW_VERSION_MAJOR) || ARROW_VERSION_MAJOR < 12 +#if !defined(NANOARROW_BUILD_TESTS_WITH_ARROW) || !defined(ARROW_VERSION_MAJOR) || \ + ARROW_VERSION_MAJOR < 12 ArrowSchemaRelease(&schema); #else auto arrow_type = ImportType(&schema); @@ -279,7 +298,6 @@ TEST(SchemaTest, SchemaInitRunEndEncoded) { #endif } -#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) TEST(SchemaTest, SchemaInitDateTime) { struct ArrowSchema schema; @@ -326,6 +344,7 @@ TEST(SchemaTest, SchemaInitDateTime) { NANOARROW_OK); EXPECT_STREQ(schema.format, "tts"); +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) auto arrow_type = ImportType(&schema); ARROW_EXPECT_OK(arrow_type); EXPECT_TRUE(arrow_type.ValueUnsafe()->Equals(time32(TimeUnit::SECOND))); @@ -400,6 +419,9 @@ TEST(SchemaTest, SchemaInitDateTime) { ARROW_EXPECT_OK(arrow_type); EXPECT_TRUE( arrow_type.ValueUnsafe()->Equals(timestamp(TimeUnit::SECOND, "America/Halifax"))); +#else + ArrowSchemaRelease(&schema); +#endif } TEST(SchemaTest, SchemaInitUnion) { @@ -427,6 +449,7 @@ TEST(SchemaTest, SchemaInitUnion) { EXPECT_STREQ(schema.format, "+us:0"); EXPECT_EQ(schema.n_children, 1); +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) auto arrow_type = ImportType(&schema); ARROW_EXPECT_OK(arrow_type); EXPECT_TRUE(arrow_type.ValueUnsafe()->Equals(sparse_union({field("u1", int32())}))); @@ -460,8 +483,10 @@ TEST(SchemaTest, SchemaInitUnion) { ARROW_EXPECT_OK(arrow_type); EXPECT_TRUE(arrow_type.ValueUnsafe()->Equals( dense_union({field("u1", int32()), field("u2", utf8())}))); -} +#else + ArrowSchemaRelease(&schema); #endif +} TEST(SchemaTest, SchemaSetFormat) { struct ArrowSchema schema; diff --git a/src/nanoarrow/common/utils_test.cc b/src/nanoarrow/common/utils_test.cc index 6e87a45ea..be7ff7582 100644 --- a/src/nanoarrow/common/utils_test.cc +++ b/src/nanoarrow/common/utils_test.cc @@ -256,7 +256,6 @@ TEST(AllocatorTest, AllocatorTestMemoryPool) { #endif } -#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) TEST(DecimalTest, Decimal128Test) { struct ArrowDecimal decimal; ArrowDecimalInit(&decimal, 128, 10, 3); @@ -271,6 +270,7 @@ TEST(DecimalTest, Decimal128Test) { EXPECT_EQ(decimal.low_word_index - decimal.high_word_index + 1, decimal.n_words); } +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) auto dec_pos = *Decimal128::FromString("12.345"); uint8_t bytes_pos[16]; dec_pos.ToBytes(bytes_pos); @@ -292,8 +292,8 @@ TEST(DecimalTest, Decimal128Test) { EXPECT_EQ(memcmp(decimal.words, bytes_neg, sizeof(bytes_neg)), 0); ArrowDecimalSetBytes(&decimal, bytes_neg); EXPECT_EQ(memcmp(decimal.words, bytes_neg, sizeof(bytes_neg)), 0); -} #endif +} TEST(DecimalTest, DecimalNegateTest) { using namespace nanoarrow::literals; @@ -352,7 +352,6 @@ TEST(DecimalTest, DecimalNegateTest) { ArrowBufferReset(&buffer); } -#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) TEST(DecimalTest, Decimal256Test) { using namespace nanoarrow::literals; @@ -369,6 +368,7 @@ TEST(DecimalTest, Decimal256Test) { EXPECT_EQ(decimal.low_word_index - decimal.high_word_index + 1, decimal.n_words); } +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) auto dec_pos = *Decimal256::FromString("12.345"); uint8_t bytes_pos[32]; dec_pos.ToBytes(bytes_pos); @@ -390,8 +390,8 @@ TEST(DecimalTest, Decimal256Test) { EXPECT_EQ(memcmp(decimal.words, bytes_neg, sizeof(bytes_neg)), 0); ArrowDecimalSetBytes(&decimal, bytes_neg); EXPECT_EQ(memcmp(decimal.words, bytes_neg, sizeof(bytes_neg)), 0); -} #endif +} TEST(DecimalTest, DecimalStringTestBasic) { using namespace nanoarrow::literals; From ff4b4b2847a5cf7cff0316e8c969ab29122d43ba Mon Sep 17 00:00:00 2001 From: Will Ayd Date: Tue, 12 Nov 2024 15:25:53 -0500 Subject: [PATCH 5/9] Updated CMake Configuration --- CMakeLists.txt | 46 +++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 41 insertions(+), 5 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index f487ee693..8e6df872f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -428,11 +428,6 @@ if(NANOARROW_BUILD_TESTS) message(STATUS "Arrow version: ${ARROW_VERSION}") message(STATUS "Arrow SO version: ${ARROW_FULL_SO_VERSION}") - # TODO: does this propoagate to projects using as a subproject? - if(NANOARROW_BUILD_TESTS_WITH_ARROW) - add_compile_definitions("-DNANOARROW_BUILD_TESTS_WITH_ARROW") - endif() - # Give caller the option to link a static version of Arrow C++ if(NANOARROW_ARROW_STATIC) set(NANOARROW_ARROW_TARGET arrow_static) @@ -525,6 +520,27 @@ if(NANOARROW_BUILD_TESTS) gmock_main nanoarrow_coverage_config) + list(APPEND + NanoarrowTests + utils_test + buffer_test + array_test + schema_test + array_stream_test + nanoarrow_testing_test + c_data_integration_test + hpp_array_stream + hpp_buffer + hpp_exception + hpp_unique + hpp_view) + if(Arrow_FOUND) + foreach(test_target ${NanoarrowTests}) + target_compile_definitions(${test_target} + PRIVATE -DNANOARROW_BUILD_TESTS_WITH_ARROW) + endforeach() + endif() + include(GoogleTest) # Some users have reported a timeout with the default value of 5 # Building with -DBUILD_SHARED_LIBS=ON may also help reduce the size of test @@ -577,6 +593,11 @@ if(NANOARROW_BUILD_TESTS) target_link_libraries(nanoarrow_ipc_${name}_test flatccrt) endif() + if(Arrow_FOUND) + target_compile_definitions(nanoarrow_ipc_${name}_test + PRIVATE -DNANOARROW_BUILD_TESTS_WITH_ARROW) + endif() + gtest_discover_tests(nanoarrow_ipc_${name}_test) endforeach() @@ -601,6 +622,13 @@ if(NANOARROW_BUILD_TESTS) gtest_main nanoarrow_coverage_config) + if(Arrow_FOUND) + target_compile_definitions(nanoarrow_device_test + PRIVATE -DNANOARROW_BUILD_TESTS_WITH_ARROW) + target_compile_definitions(nanoarrow_device_hpp_test + PRIVATE -DNANOARROW_BUILD_TESTS_WITH_ARROW) + endif() + include(GoogleTest) gtest_discover_tests(nanoarrow_device_test) gtest_discover_tests(nanoarrow_device_hpp_test) @@ -612,6 +640,10 @@ if(NANOARROW_BUILD_TESTS) nanoarrow gtest_main nanoarrow_coverage_config) + if(Arrow_FOUND) + target_compile_definitions(nanoarrow_device_metal_test + PRIVATE -DNANOARROW_BUILD_TESTS_WITH_ARROW) + endif() gtest_discover_tests(nanoarrow_device_metal_test) endif() @@ -623,6 +655,10 @@ if(NANOARROW_BUILD_TESTS) CUDA::cuda_driver gtest_main nanoarrow_coverage_config) + if(Arrow_FOUND) + target_compile_definitions(nanoarrow_device_cuda_test + PRIVATE -DNANOARROW_BUILD_TESTS_WITH_ARROW) + endif() gtest_discover_tests(nanoarrow_device_cuda_test) endif() endif() From d4657176c2de73afe2caa5063a2286279fe7a0bb Mon Sep 17 00:00:00 2001 From: Will Ayd Date: Tue, 12 Nov 2024 15:51:23 -0500 Subject: [PATCH 6/9] fix test leak --- src/nanoarrow/common/array_test.cc | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/nanoarrow/common/array_test.cc b/src/nanoarrow/common/array_test.cc index a5f4ed5ba..02c062ba2 100644 --- a/src/nanoarrow/common/array_test.cc +++ b/src/nanoarrow/common/array_test.cc @@ -405,6 +405,8 @@ TEST(ArrayTest, ArrayTestAppendToNullArray) { auto expected_array = MakeArrayOfNull(null(), 3); ARROW_EXPECT_OK(expected_array); EXPECT_TRUE(arrow_array.ValueUnsafe()->Equals(expected_array.ValueUnsafe())); +#else + ArrowArrayRelease(&array); #endif ASSERT_EQ(ArrowArrayInitFromType(&array, NANOARROW_TYPE_NA), NANOARROW_OK); From 7db51a6427f2b25258fb7fd3ff466060b04543dd Mon Sep 17 00:00:00 2001 From: Will Ayd Date: Wed, 13 Nov 2024 12:12:29 -0500 Subject: [PATCH 7/9] fix rebase issue --- meson.build | 120 +++------------------------------------------------- 1 file changed, 5 insertions(+), 115 deletions(-) diff --git a/meson.build b/meson.build index a276c7f19..53dd824d7 100644 --- a/meson.build +++ b/meson.build @@ -205,14 +205,17 @@ if get_option('tests') # wrap the tests with valgrind via `meson test --wrap=valgrind`. See # https://mesonbuild.com/Unit-tests.html + # Similarly code coverage has a built in option users should use instead + # https://mesonbuild.com/Unit-tests.html#coverage + arrow_dep = dependency('arrow', include_type: 'system', required: false) if get_option('tests_with_arrow') and not arrow_dep.found() - error('tests_with_arrow=true but could not find Arrow') + error('tests_with_arrow=true but could not find Arrow') endif test_cpp_args = [] if get_option('tests_with_arrow') - test_cpp_args += ['-DNANOARROW_BUILD_TESTS_WITH_ARROW'] + test_cpp_args += ['-DNANOARROW_BUILD_TESTS_WITH_ARROW'] endif gtest_dep = dependency('gtest_main') @@ -340,119 +343,6 @@ if get_option('tests') ) test('nanoarrow-device-metal', exc) endif -======= - foreach name : nanoarrow_tests - exc = executable( - name + '-test', - sources: 'src/nanoarrow/common/' + name.replace('-', '_') + '_test.cc', - include_directories: incdir, - dependencies: [nanoarrow_testing_dep, arrow_dep, gtest_dep, gmock_dep], - cpp_args: test_cpp_args, - ) - test(name, exc) - endforeach - - nanoarrow_hpp_tests = ['array_stream', 'buffer', 'exception', 'unique', 'view'] - - foreach name : nanoarrow_hpp_tests - exc = executable( - 'hpp-' + name + '-test', - sources: 'src/nanoarrow/hpp/' + name.replace('-', '_') + '_test.cc', - include_directories: incdir, - dependencies: [nanoarrow_testing_dep, gtest_dep, gmock_dep], - cpp_args: test_cpp_args, - ) - test(name, exc) - endforeach - - testing_test = executable( - 'nanoarrow-testing-test', - 'src/nanoarrow/testing/testing_test.cc', - include_directories: incdir, - dependencies: [nanoarrow_testing_dep, arrow_dep, gtest_dep], - cpp_args: test_cpp_args, - ) - test('nanoarrow-testing-test', testing_test) - - c_data_integration_test = executable( - 'c-data-integration-test', - 'src/nanoarrow/integration/c_data_integration_test.cc', - link_with: [c_data_integration_lib], - dependencies: [nanoarrow_testing_dep, arrow_dep, gtest_dep], - include_directories: incdir, - cpp_args: test_cpp_args, - ) - test('c-data-integration', c_data_integration_test) - - if get_option('ipc') - zlib_dep = dependency('zlib') - ipc_test_files = { - 'ipc-decoder': { - 'src': 'decoder', - 'deps': [nanoarrow_ipc_dep, flatcc_dep, arrow_dep, gtest_dep, gmock_dep], - 'timeout': 30, - }, - 'ipc-reader': { - 'src': 'reader', - 'deps': [nanoarrow_ipc_dep, arrow_dep, gtest_dep], - # the ipc reader test can take longer when executed - # under valgrind, hence the increased timeout - 'timeout': 90, - - }, - 'ipc-files': { - 'src': 'files', - 'deps': [ - nanoarrow_testing_dep, - nanoarrow_ipc_dep, - flatcc_dep, - zlib_dep, - arrow_dep, - gtest_dep, - ], - 'timeout': 30, - }, - 'ipc-hpp': { - 'src': 'ipc_hpp', - 'deps': [nanoarrow_testing_dep, nanoarrow_ipc_dep, gtest_dep], - 'timeout': 30, - }, - } - - foreach name, config : ipc_test_files - exc = executable( - 'nanoarrow-' + name + '-test', - 'src/nanoarrow/ipc/' + config['src'] + '_test.cc', - dependencies: config['deps'], - cpp_args: test_cpp_args, - ) - test(name, exc, timeout: config['timeout']) - endforeach - endif - - if needs_device - device_tests = ['device', 'device_hpp'] - foreach device_test : device_tests - exc = executable( - 'nanoarrow-' + device_test.replace('_', '-') + '-test', - 'src/nanoarrow/device/' + device_test + '_test.cc', - link_with: nanoarrow_device_lib, - dependencies: [nanoarrow_testing_dep, gtest_dep], - cpp_args: test_cpp_args, - ) - test(device_test.replace('_', '-'), exc) - endforeach - - if get_option('metal') - exc = executable( - 'nanoarrow-device-metal-test', - 'src/nanoarrow/device/metal_test.cc', - link_with: nanoarrow_device_lib, - dependencies: [nanoarrow_testing_dep, gtest_dep, metal_cpp_dep], - cpp_args: test_cpp_args, - ) - test('nanoarrow-device-metal', exc) ->>>>>>> a580e29 (Meson configuration cleanup) endif endif From 76af9976c1bf088c1eb65e619ccc66fa2fd3a532 Mon Sep 17 00:00:00 2001 From: Will Ayd Date: Wed, 13 Nov 2024 15:09:01 -0500 Subject: [PATCH 8/9] Feedback --- .github/workflows/verify.yaml | 12 ++++++++++-- CMakeLists.txt | 4 ++-- CMakePresets.json | 1 - dev/release/verify-release-candidate.sh | 6 ++---- src/nanoarrow/common/array_test.cc | 3 ++- src/nanoarrow/common/schema_test.cc | 9 ++++++--- 6 files changed, 22 insertions(+), 13 deletions(-) diff --git a/.github/workflows/verify.yaml b/.github/workflows/verify.yaml index c6fbb7e27..9fb025f8e 100644 --- a/.github/workflows/verify.yaml +++ b/.github/workflows/verify.yaml @@ -101,13 +101,21 @@ jobs: if: matrix.config.label == 'windows' shell: bash run: | - echo "NANOARROW_CMAKE_OPTIONS=${NANOARROW_CMAKE_OPTIONS} -DNANOARROW_ARROW_STATIC=ON -DArrow_DIR=$(pwd -W)/arrow/lib/cmake/Arrow -Dgtest_force_shared_crt=ON" >> $GITHUB_ENV + cat << EOF | tr '\n' ' ' >> $GITHUB_ENV + NANOARROW_CMAKE_OPTIONS=${NANOARROW_CMAKE_OPTIONS} + -DNANOARROW_ARROW_STATIC=ON + -DNANOARROW_BUILD_TESTS_WITH_ARROW=ON + -DArrow_DIR=$(pwd -W)/arrow/lib/cmake/Arrow + -Dgtest_force_shared_crt=ON - name: Set CMake options (POSIX) if: matrix.config.label != 'windows' shell: bash run: | - echo "NANOARROW_CMAKE_OPTIONS=${NANOARROW_CMAKE_OPTIONS} -DArrow_DIR=$(pwd)/arrow/lib/cmake/Arrow" >> $GITHUB_ENV + cat << EOF | tr '\n' ' ' >> $GITHUB_ENV + NANOARROW_CMAKE_OPTIONS=${NANOARROW_CMAKE_OPTIONS} + -DNANOARROW_BUILD_TESTS_WITH_ARROW=ON + -DArrow_DIR=$(pwd)/arrow/lib/cmake/Arrow - name: Run dev/release/verify-release-candidate.sh shell: bash diff --git a/CMakeLists.txt b/CMakeLists.txt index 8e6df872f..a24f78733 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -423,8 +423,8 @@ if(NANOARROW_BUILD_TESTS) ) include(CTest) - find_package(Arrow) - if(Arrow_FOUND) + if(NANOARROW_BUILD_TESTS_WITH_ARROW) + find_package(Arrow REQUIRED) message(STATUS "Arrow version: ${ARROW_VERSION}") message(STATUS "Arrow SO version: ${ARROW_FULL_SO_VERSION}") diff --git a/CMakePresets.json b/CMakePresets.json index efd3e5105..d5ff3ea0e 100644 --- a/CMakePresets.json +++ b/CMakePresets.json @@ -21,7 +21,6 @@ "cacheVariables": { "CMAKE_BUILD_TYPE": "Debug", "NANOARROW_BUILD_TESTS": "ON" - "NANOARROW_BUILD_TESTS_WITH_ARROW": "ON" } }, { diff --git a/dev/release/verify-release-candidate.sh b/dev/release/verify-release-candidate.sh index 8c1973fa6..18591ad69 100755 --- a/dev/release/verify-release-candidate.sh +++ b/dev/release/verify-release-candidate.sh @@ -243,14 +243,12 @@ test_cmake_project() { test_c() { show_header "Build and test C library" - test_cmake_project build . -DNANOARROW_BUILD_TESTS=ON -DNANOARROW_IPC=ON \ - -DNANOARROW_BUILD_TESTS_WITH_ARROW=ON + test_cmake_project build . -DNANOARROW_BUILD_TESTS=ON -DNANOARROW_IPC=ON } test_c_bundled() { show_header "Build test bundled C library" - test_cmake_project build-bundled . -DNANOARROW_BUILD_TESTS=ON -DNANOARROW_IPC=ON \ - -DNANOARROW_BUILD_TESTS_WITH_ARROW=ON -DNANOARROW_BUNDLE=ON + test_cmake_project build-bundled . -DNANOARROW_BUILD_TESTS=ON -DNANOARROW_IPC=ON -DNANOARROW_BUNDLE=ON } test_r() { diff --git a/src/nanoarrow/common/array_test.cc b/src/nanoarrow/common/array_test.cc index 02c062ba2..04d3b1d25 100644 --- a/src/nanoarrow/common/array_test.cc +++ b/src/nanoarrow/common/array_test.cc @@ -33,7 +33,8 @@ #include #include -#if defined(ARROW_VERSION_MAJOR) && ARROW_VERSION_MAJOR >= 12 +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) && defined(ARROW_VERSION_MAJOR) && \ + ARROW_VERSION_MAJOR >= 12 #include #endif #endif diff --git a/src/nanoarrow/common/schema_test.cc b/src/nanoarrow/common/schema_test.cc index 3d4864000..f05f5e08f 100644 --- a/src/nanoarrow/common/schema_test.cc +++ b/src/nanoarrow/common/schema_test.cc @@ -113,7 +113,8 @@ TEST(SchemaTest, SchemaInitSimple) { ExpectSchemaInitOk(NANOARROW_TYPE_INTERVAL_MONTHS, month_interval()); ExpectSchemaInitOk(NANOARROW_TYPE_INTERVAL_DAY_TIME, day_time_interval()); ExpectSchemaInitOk(NANOARROW_TYPE_INTERVAL_MONTH_DAY_NANO, month_day_nano_interval()); -#if defined(ARROW_VERSION_MAJOR) && ARROW_VERSION_MAJOR >= 15 +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) && defined(ARROW_VERSION_MAJOR) && \ + ARROW_VERSION_MAJOR >= 15 ExpectSchemaInitOk(NANOARROW_TYPE_STRING_VIEW, utf8_view()); ExpectSchemaInitOk(NANOARROW_TYPE_BINARY_VIEW, binary_view()); #endif @@ -590,7 +591,8 @@ TEST(SchemaTest, SchemaCopyDictType) { } TEST(SchemaTest, SchemaCopyRunEndEncodedType) { -#if !defined(ARROW_VERSION_MAJOR) || ARROW_VERSION_MAJOR < 12 +#if !defined(NANOARROW_BUILD_TESTS_WITH_ARROW) || !defined(ARROW_VERSION_MAJOR) || \ + ARROW_VERSION_MAJOR < 12 GTEST_SKIP() << "Arrow C++ REE integration test requires ARROW_VERSION_MAJOR >= 12"; #else struct ArrowSchema schema; @@ -957,7 +959,8 @@ TEST(SchemaViewTest, SchemaViewInitBinaryAndString) { } TEST(SchemaViewTest, SchemaViewInitBinaryAndStringView) { -#if defined(ARROW_VERSION_MAJOR) && ARROW_VERSION_MAJOR >= 15 +#if defined(NANOARROW_BUILD_TESTS_WITH_ARROW) && defined(ARROW_VERSION_MAJOR) && \ + ARROW_VERSION_MAJOR >= 15 struct ArrowSchema schema; struct ArrowSchemaView schema_view; struct ArrowError error; From 6d349c728aaadff3c16b9daf090838244b826b62 Mon Sep 17 00:00:00 2001 From: Will Ayd Date: Thu, 14 Nov 2024 14:45:44 -0500 Subject: [PATCH 9/9] Updated README --- README.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 6ac460349..27b5c944b 100644 --- a/README.md +++ b/README.md @@ -162,9 +162,9 @@ After setting up your project, be sure to enable the options you want: meson configure -Dtests=true -Dbenchmarks=true ``` -If Arrow is installed in a non-standard location on your system, you may need to -pass the `--pkg-config-path ` argument to either -the setup or configure steps above. +You can enable better test coverage if Apache Arrow is installed on your system +with `-Dtest_with_arrow=true`. Depending on how you have installed Apache Arrow, +you may also need to pass `--pkg-config-path `. With the above out of the way, the `compile` command should take care of the rest: