Improve tests + nits

Author: pitrou

cpp/src/arrow/pretty_print.cc

@@ -110,10 +110,11 @@ void PrettyPrinter::Write(std::string_view data) {
   Write(data, options_.element_size_limit);
 }
 
-void PrettyPrinter::Write(std::string_view data, const int max_chars) {
+void PrettyPrinter::Write(std::string_view data, int max_chars) {
   (*sink_) << data.substr(0, max_chars);
-  if (data.size() > static_cast<uint64_t>(max_chars)) {
-    (*sink_) << " (... " << data.size() - max_chars << " chars omitted)";
+  if (data.size() > static_cast<size_t>(max_chars)) {
+    (*sink_) << " (... " << data.size() - static_cast<size_t>(max_chars)
+             << " chars omitted)";
   }
 }
 
@@ -122,7 +123,7 @@ void PrettyPrinter::WriteIndented(std::string_view data) {
   Write(data, options_.element_size_limit);
 }
 
-void PrettyPrinter::WriteIndented(std::string_view data, const int max_chars) {
+void PrettyPrinter::WriteIndented(std::string_view data, int max_chars) {
   Indent();
   Write(data, max_chars);
 }
@@ -192,7 +193,7 @@ class ArrayPrinter : public PrettyPrinter {
 
   template <typename ArrayType, typename Formatter>
   Status WritePrimitiveValues(const ArrayType& array, Formatter* formatter) {
-    auto appender = [&](std::string_view v) { this->Write(v); };
+    auto appender = [&](std::string_view v) { Write(v); };
     auto format_func = [&](int64_t i) {
       (*formatter)(array.GetView(i), appender);
       return Status::OK();

cpp/src/arrow/pretty_print_test.cc

@@ -25,6 +25,7 @@
 #include <memory>
 #include <sstream>
 #include <string>
+#include <string_view>
 #include <vector>
 
 #include "arrow/array.h"
@@ -47,37 +48,37 @@ class TestPrettyPrint : public ::testing::Test {
 };
 
 template <typename T>
-void CheckStream(const T& obj, const PrettyPrintOptions& options, const char* expected) {
+void CheckStream(const T& obj, const PrettyPrintOptions& options,
+                 std::string_view expected) {
   std::ostringstream sink;
   ASSERT_OK(PrettyPrint(obj, options, &sink));
   std::string result = sink.str();
-  ASSERT_EQ(std::string(expected, strlen(expected)), result);
+  ASSERT_EQ(expected, result);
 }
 
-void CheckArray(const Array& arr, const PrettyPrintOptions& options, const char* expected,
-                bool check_operator = true) {
+void CheckArray(const Array& arr, const PrettyPrintOptions& options,
+                std::string_view expected, bool check_operator = true) {
   ARROW_SCOPED_TRACE("For datatype: ", arr.type()->ToString());
   CheckStream(arr, options, expected);
 
-  if (options.indent == 0 && check_operator) {
+  if (options.indent == 0 && options.element_size_limit == 100 && check_operator) {
     std::stringstream ss;
     ss << arr;
-    std::string result = std::string(expected, strlen(expected));
-    ASSERT_EQ(result, ss.str());
+    ASSERT_EQ(expected, ss.str());
   }
 }
 
 template <typename T>
-void Check(const T& obj, const PrettyPrintOptions& options, const char* expected) {
+void Check(const T& obj, const PrettyPrintOptions& options, std::string_view expected) {
   std::string result;
   ASSERT_OK(PrettyPrint(obj, options, &result));
-  ASSERT_EQ(std::string(expected, strlen(expected)), result);
+  ASSERT_EQ(expected, result);
 }
 
 template <typename TYPE, typename C_TYPE>
 void CheckPrimitive(const std::shared_ptr<DataType>& type,
                     const PrettyPrintOptions& options, const std::vector<bool>& is_valid,
-                    const std::vector<C_TYPE>& values, const char* expected,
+                    const std::vector<C_TYPE>& values, std::string_view expected,
                     bool check_operator = true) {
   std::shared_ptr<Array> array;
   ArrayFromVector<TYPE, C_TYPE>(type, is_valid, values, &array);
@@ -86,7 +87,7 @@ void CheckPrimitive(const std::shared_ptr<DataType>& type,
 
 template <typename TYPE, typename C_TYPE>
 void CheckPrimitive(const PrettyPrintOptions& options, const std::vector<bool>& is_valid,
-                    const std::vector<C_TYPE>& values, const char* expected,
+                    const std::vector<C_TYPE>& values, std::string_view expected,
                     bool check_operator = true) {
   CheckPrimitive<TYPE, C_TYPE>(TypeTraits<TYPE>::type_singleton(), options, is_valid,
                                values, expected, check_operator);
@@ -158,12 +159,12 @@ TEST_F(TestPrettyPrint, PrimitiveType) {
   ])expected";
   CheckPrimitive<DoubleType, double>({2, 10}, is_valid, values2, ex2_in2);
 
-  std::vector<std::string> values3 = {"foo", "bar", "", "baz", ""};
+  std::vector<std::string> values3 = {"foo", "bar", "", "a longer string", ""};
   static const char* ex3 = R"expected([
   "foo",
   "bar",
   null,
-  "baz",
+  "a longer string",
   null
 ])expected";
   CheckPrimitive<StringType, std::string>({0, 10}, is_valid, values3, ex3);
@@ -172,19 +173,19 @@ TEST_F(TestPrettyPrint, PrimitiveType) {
     "foo",
     "bar",
     null,
-    "baz",
+    "a longer string",
     null
   ])expected";
   CheckPrimitive<StringType, std::string>({2, 10}, is_valid, values3, ex3_in2);
   CheckPrimitive<LargeStringType, std::string>({2, 10}, is_valid, values3, ex3_in2);
 
   PrettyPrintOptions options{2, 10};
-  options.element_size_limit = 2;
+  options.element_size_limit = 8;
   static const char* ex3_in3 = R"expected(  [
-    " (... 3 chars omitted)",
-    " (... 3 chars omitted)",
+    "foo",
+    "bar",
     null,
-    " (... 3 chars omitted)",
+    "a long (... 9 chars omitted)",
     null
   ])expected";
   CheckPrimitive<StringType, std::string>(options, is_valid, values3, ex3_in3);
@@ -1139,6 +1140,12 @@ TEST_F(TestPrettyPrint, DecimalTypes) {
 
     static const char* ex = "[\n  123.4567,\n  456.7891,\n  null\n]";
     CheckArray(*array, {0}, ex);
+
+    auto options = PrettyPrintOptions();
+    options.element_size_limit = 3;
+    static const char* ex_2 =
+        "[\n  123 (... 5 chars omitted),\n  456 (... 5 chars omitted),\n  null\n]";
+    CheckArray(*array, options, ex_2);
   }
 }
 

python/pyarrow/array.pxi

@@ -1384,9 +1384,8 @@ cdef class Array(_PandasConvertible):
         skip_new_lines : bool
             If the array should be rendered as a single line of text
             or if each element should be on its own line.
-        element_size_limit : int
-            Maximum number of characters of a single element before it is truncated,
-            by default ``100``.
+        element_size_limit : int, default 100
+            Maximum number of characters of a single element before it is truncated.
         """
         cdef:
             c_string result

python/pyarrow/table.pxi

@@ -1,3 +1,4 @@
+
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements.  See the NOTICE file
 # distributed with this work for additional information
@@ -137,9 +138,9 @@ cdef class ChunkedArray(_PandasConvertible):
         skip_new_lines : bool
             If the array should be rendered as a single line of text
             or if each element should be on its own line.
-        element_size_limit : int
-            Maximum number of characters of a single element before it is truncated,
-            by default ``100``.
+        element_size_limit : int, default 100
+            Maximum number of characters of a single element before it is truncated.
+
         Examples
         --------
         >>> import pyarrow as pa

python/pyarrow/tests/test_array.py

@@ -75,17 +75,32 @@ def test_constructor_raises():
 
 
 def test_list_format():
-    arr = pa.array([[1], None, [200, 3, None]])
-    result = arr.to_string(element_size_limit=2)
+    arr = pa.array([["foo"], None, ["bar", "a longer string", None]])
+    result = arr.to_string()
+    expected = """\
+[
+  [
+    "foo"
+  ],
+  null,
+  [
+    "bar",
+    "a longer string",
+    null
+  ]
+]"""
+    assert result == expected
+
+    result = arr.to_string(element_size_limit=10)
     expected = """\
 [
   [
-    1
+    "foo"
   ],
   null,
   [
-    20 (... 1 chars omitted),
-    3,
+    "bar",
+    "a longer (... 7 chars omitted)",
     null
   ]
 ]"""

python/pyarrow/types.pxi

@@ -3581,6 +3581,7 @@ cdef class Schema(_Weakrefable):
             Display Schema-level KeyValueMetadata
         element_size_limit : int, default 100
             Maximum number of characters of a single element before it is truncated.
+
         Returns
         -------
         str : the formatted output