chore(ci): Ensure tests pass for Arrow C++ <12 and on C++11 (#514)

Tests for #507 and
#501 and/or
#503 either used C++17 or
features from Arrow C++ > 12. Our test suite still supports these
(although perhaps parts of this support should be dropped soon).

On Windows, formatting with `%lu` was doing some unexpected formatting.
We could do a better job formatting 64-bit integers in error messages
(e.g., using `PRId64` and the requisite defines to ensure it works on
mingw); however, we probably won't ever be able to support properly
formatting an unsigned 64-bit integer on every platform we support. I
changed the error message (and its test) slightly to reflect that.

Author: paleolimbot

src/nanoarrow/array.c

@@ -888,14 +888,11 @@ static int ArrowArrayViewValidateMinimal(struct ArrowArrayView* array_view,
       // uint64_t is used here to avoid overflow when adding the offset and length
       if ((uint64_t)array_view->offset + (uint64_t)array_view->length >
           (uint64_t)max_length) {
-        ArrowErrorSet(
-            error,
-            "Offset + length of a run-end encoded array must fit in a value"
-            " of the run end type %s, but offset + length is %lu while the "
-            "allowed maximum is %lu",
-            ArrowTypeString(run_ends_view->storage_type),
-            (unsigned long)array_view->offset + (unsigned long)array_view->length,
-            (unsigned long)max_length);
+        ArrowErrorSet(error,
+                      "Offset + length of a run-end encoded array must fit in a value"
+                      " of the run end type %s, but offset + length is %ld",
+                      ArrowTypeString(run_ends_view->storage_type),
+                      (long)array_view->offset + (long)array_view->length);
         return EINVAL;
       }
       if (run_ends_view->length > values_view->length) {

src/nanoarrow/array_test.cc

@@ -26,13 +26,17 @@
 #include <arrow/array/builder_decimal.h>
 #include <arrow/array/builder_nested.h>
 #include <arrow/array/builder_primitive.h>
-#include <arrow/array/builder_run_end.h>
 #include <arrow/array/builder_time.h>
 #include <arrow/array/builder_union.h>
 #include <arrow/c/bridge.h>
 #include <arrow/compare.h>
+#include <arrow/config.h>
 #include <arrow/util/decimal.h>
 
+#if defined(ARROW_VERSION_MAJOR) && ARROW_VERSION_MAJOR >= 12
+#include <arrow/array/builder_run_end.h>
+#endif
+
 #include "nanoarrow/nanoarrow.hpp"
 
 using namespace arrow;
@@ -1482,11 +1486,9 @@ TEST(ArrayTest, ArrayTestAppendToRunEndEncodedArray) {
     array.offset = INT32_MAX;
     EXPECT_EQ(ArrowArrayFinishBuilding(&array, NANOARROW_VALIDATION_LEVEL_FULL, &error),
               EINVAL);
-    EXPECT_STREQ(
-        ArrowErrorMessage(&error),
-        "Offset + length of a run-end encoded array must fit in a value of the "
-        "run end type int32, but offset + length is 2147483654 while the allowed "
-        "maximum is 2147483647");
+    EXPECT_STREQ(ArrowErrorMessage(&error),
+                 "Offset + length of a run-end encoded array must fit in a value of the "
+                 "run end type int32, but offset + length is 2147483654");
 
     ((struct ArrowArrayPrivateData*)(array.children[0]->private_data))->storage_type =
         NANOARROW_TYPE_INT16;
@@ -1496,18 +1498,17 @@ TEST(ArrayTest, ArrayTestAppendToRunEndEncodedArray) {
     EXPECT_STREQ(
         ArrowErrorMessage(&error),
         "Offset + length of a run-end encoded array must fit in a value of the run end "
-        "type int16, but offset + length is 32774 while the allowed maximum is 32767");
+        "type int16, but offset + length is 32774");
 
     ((struct ArrowArrayPrivateData*)(array.children[0]->private_data))->storage_type =
         NANOARROW_TYPE_INT64;
     array.offset = INT64_MAX;
     EXPECT_EQ(ArrowArrayFinishBuilding(&array, NANOARROW_VALIDATION_LEVEL_FULL, &error),
               EINVAL);
-    EXPECT_STREQ(ArrowErrorMessage(&error),
-                 "Offset + length of a run-end encoded array must fit in a value of the "
-                 "run end type int64, but offset + length is 9223372036854775814 while "
-                 "the allowed "
-                 "maximum is 9223372036854775807");
+    EXPECT_THAT(
+        ArrowErrorMessage(&error),
+        ::testing::StartsWith("Offset + length of a run-end encoded array must fit in a "
+                              "value of the run end type int64, but offset + length is"));
   }
   ((struct ArrowArrayPrivateData*)(array.children[0]->private_data))->storage_type =
       NANOARROW_TYPE_INT32;
@@ -1572,6 +1573,10 @@ TEST(ArrayTest, ArrayTestAppendToRunEndEncodedArray) {
   EXPECT_EQ(ArrowArrayFinishBuilding(&array, NANOARROW_VALIDATION_LEVEL_FULL, &error),
             NANOARROW_OK);
 
+#if !defined(ARROW_VERSION_MAJOR) || ARROW_VERSION_MAJOR < 12
+  ArrowSchemaRelease(&schema);
+  ArrowArrayRelease(&array);
+#else
   auto arrow_array = ImportArray(&array, &schema);
   ARROW_EXPECT_OK(arrow_array);
 
@@ -1591,6 +1596,7 @@ TEST(ArrayTest, ArrayTestAppendToRunEndEncodedArray) {
 
   EXPECT_STREQ(arrow_array.ValueUnsafe()->ToString().c_str(),
                expected_array.ValueUnsafe()->ToString().c_str());
+#endif
 }
 
 TEST(ArrayTest, ArrayTestUnionUtils) {
@@ -2577,20 +2583,6 @@ TEST(ArrayTest, ArrayViewTestSparseUnionGet) {
   ArrowArrayRelease(&array);
 }
 
-template <
-    typename TypeClass, typename ValueType,
-    typename std::enable_if<std::is_same_v<TypeClass, HalfFloatType>, bool>::type = true>
-auto transform_value(ValueType t) -> uint16_t {
-  return ArrowFloatToHalfFloat(t);
-}
-
-template <
-    typename TypeClass, typename ValueType,
-    typename std::enable_if<!std::is_same_v<TypeClass, HalfFloatType>, bool>::type = true>
-auto transform_value(ValueType t) -> ValueType {
-  return t;
-}
-
 template <typename TypeClass>
 void TestGetFromNumericArrayView() {
   struct ArrowArray array;
@@ -2602,9 +2594,17 @@ void TestGetFromNumericArrayView() {
 
   // Array with nulls
   auto builder = NumericBuilder<TypeClass>();
-  ARROW_EXPECT_OK(builder.Append(transform_value<TypeClass>(1)));
-  ARROW_EXPECT_OK(builder.AppendNulls(2));
-  ARROW_EXPECT_OK(builder.Append(transform_value<TypeClass>(4)));
+
+  if (type->id() == Type::HALF_FLOAT) {
+    ARROW_EXPECT_OK(builder.Append(ArrowFloatToHalfFloat(1)));
+    ARROW_EXPECT_OK(builder.AppendNulls(2));
+    ARROW_EXPECT_OK(builder.Append(ArrowFloatToHalfFloat(4)));
+  } else {
+    ARROW_EXPECT_OK(builder.Append(1));
+    ARROW_EXPECT_OK(builder.AppendNulls(2));
+    ARROW_EXPECT_OK(builder.Append(4));
+  }
+
   auto maybe_arrow_array = builder.Finish();
   ARROW_EXPECT_OK(maybe_arrow_array);
   auto arrow_array = maybe_arrow_array.ValueUnsafe();
@@ -2635,8 +2635,15 @@ void TestGetFromNumericArrayView() {
 
   // Array without nulls (Arrow does not allocate the validity buffer)
   builder = NumericBuilder<TypeClass>();
-  ARROW_EXPECT_OK(builder.Append(transform_value<TypeClass>(1)));
-  ARROW_EXPECT_OK(builder.Append(transform_value<TypeClass>(2)));
+
+  if (type->id() == Type::HALF_FLOAT) {
+    ARROW_EXPECT_OK(builder.Append(ArrowFloatToHalfFloat(1)));
+    ARROW_EXPECT_OK(builder.Append(ArrowFloatToHalfFloat(2)));
+  } else {
+    ARROW_EXPECT_OK(builder.Append(1));
+    ARROW_EXPECT_OK(builder.Append(2));
+  }
+
   maybe_arrow_array = builder.Finish();
   ARROW_EXPECT_OK(maybe_arrow_array);
   arrow_array = maybe_arrow_array.ValueUnsafe();

src/nanoarrow/schema_test.cc

@@ -18,6 +18,7 @@
 #include <gtest/gtest.h>
 
 #include <arrow/c/bridge.h>
+#include <arrow/config.h>
 #include <arrow/testing/gtest_util.h>
 #include <arrow/util/key_value_metadata.h>
 
@@ -235,6 +236,9 @@ TEST(SchemaTest, SchemaInitRunEndEncoded) {
 
   ASSERT_EQ(ArrowSchemaSetType(schema.children[1], NANOARROW_TYPE_FLOAT), NANOARROW_OK);
 
+#if !defined(ARROW_VERSION_MAJOR) || ARROW_VERSION_MAJOR < 12
+  ArrowSchemaRelease(&schema);
+#else
   auto arrow_type = ImportType(&schema);
   ARROW_EXPECT_OK(arrow_type);
   EXPECT_TRUE(arrow_type.ValueUnsafe()->Equals(run_end_encoded(int16(), float32())));
@@ -258,6 +262,7 @@ TEST(SchemaTest, SchemaInitRunEndEncoded) {
   arrow_type = ImportType(&schema);
   ARROW_EXPECT_OK(arrow_type);
   EXPECT_TRUE(arrow_type.ValueUnsafe()->Equals(run_end_encoded(int64(), float32())));
+#endif
 }
 
 TEST(SchemaTest, SchemaInitDateTime) {
@@ -543,6 +548,9 @@ TEST(SchemaTest, SchemaCopyDictType) {
 }
 
 TEST(SchemaTest, SchemaCopyRunEndEncodedType) {
+#if !defined(ARROW_VERSION_MAJOR) || ARROW_VERSION_MAJOR < 12
+  GTEST_SKIP() << "Arrow C++ REE integration test requires ARROW_VERSION_MAJOR >= 12";
+#else
   struct ArrowSchema schema;
   auto struct_type = run_end_encoded(int32(), float32());
   ARROW_EXPECT_OK(ExportType(*struct_type, &schema));
@@ -560,6 +568,7 @@ TEST(SchemaTest, SchemaCopyRunEndEncodedType) {
 
   ArrowSchemaRelease(&schema);
   ArrowSchemaRelease(&schema_copy);
+#endif
 }
 
 TEST(SchemaTest, SchemaCopyFlags) {